def test_point_source(self):
pointSource = PointSource(point_source_type_list=['SOURCE_POSITION'],
fixed_magnification_list=[True])
kwargs_ps = [{'source_amp': 1000, 'ra_source': 0.1, 'dec_source': 0.1}]
lensModel = LensModel(lens_model_list=['SIS'])
kwargs_lens = [{'theta_E': 1, 'center_x': 0, 'center_y': 0}]
numPix = 64
deltaPix = 0.13
kwargs_data = sim_util.data_configure_simple(numPix,
deltaPix,
exposure_time=1,
background_rms=1)
data_class = ImageData(**kwargs_data)
psf_type = "GAUSSIAN"
fwhm = 0.9
kwargs_psf = {'psf_type': psf_type, 'fwhm': fwhm}
psf_class = PSF(**kwargs_psf)
imageModel = ImageModel(data_class=data_class,
psf_class=psf_class,
lens_model_class=lensModel,
point_source_class=pointSource)
image = imageModel.image(kwargs_lens=kwargs_lens, kwargs_ps=kwargs_ps)
assert np.sum(image) > 0
def test_extinction_map(self):
kwargs_data = sim_util.data_configure_simple(numPix=10, deltaPix=1, exposure_time=1, background_rms=1)
data_class = ImageData(**kwargs_data)
extinction_class = DifferentialExtinction(optical_depth_model=['UNIFORM'], tau0_index=0)
imageModel = ImageModel(data_class, PSF(), extinction_class=extinction_class)
extinction = imageModel.extinction_map(kwargs_extinction=[{'amp': 1}], kwargs_special={'tau0_list': [1, 0, 0]})
npt.assert_almost_equal(extinction, np.exp(-1))
def sepc_imageModel(self):
from lenstronomy.ImSim.image_model import ImageModel
from lenstronomy.Data.imaging_data import ImageData
from lenstronomy.Data.psf import PSF
data_class = ImageData(**self.kwargs_data)
from lenstronomy.PointSource.point_source import PointSource
pointSource = PointSource(
point_source_type_list=self.point_source_list)
psf_class = PSF(**self.kwargs_psf)
from lenstronomy.LightModel.light_model import LightModel
lightModel = LightModel(light_model_list=self.light_model_list)
if self.light_model_list is None:
imageModel = ImageModel(data_class,
psf_class,
point_source_class=pointSource,
kwargs_numerics=self.kwargs_numerics)
else:
imageModel = ImageModel(data_class,
psf_class,
source_model_class=lightModel,
point_source_class=pointSource,
kwargs_numerics=self.kwargs_numerics)
self.data_class = data_class
self.psf_class = psf_class
self.lightModel = lightModel
self.imageModel = imageModel
self.pointSource = pointSource
def generate_image(kwargs_lens_mass, kwargs_src_light, psf_model, data_api,
lens_mass_model, src_light_model):
"""Generate the image of a lensed extended source from provided model and model parameters
Parameters
----------
kwargs_lens_mass : dict
lens model parameters
kwargs_src_light : dict
host light model parameters
psf_model : lenstronomy PSF object
the PSF kernel point source map
data_api : lenstronomy DataAPI object
tool that handles detector and observation conditions
Returns
-------
tuple of (np.array, dict)
the lensed image
"""
img_features = {}
kwargs_numerics = {'supersampling_factor': 1}
image_data = data_api.data_class
# Instantiate image model
lensed_image_model = ImageModel(image_data,
psf_model,
lens_mass_model,
src_light_model,
None,
None,
kwargs_numerics=kwargs_numerics)
# Compute total magnification
lensed_total_flux = get_lensed_total_flux(kwargs_lens_mass,
kwargs_src_light,
lensed_image_model)
img_features['lensed_total_flux'] = lensed_total_flux
#try:
#unlensed_total_flux = get_unlenseD_total_flux_analytical(kwargs_src_light_list, src_light_model)
unlensed_image_model = ImageModel(image_data,
psf_model,
None,
src_light_model,
None,
None,
kwargs_numerics=kwargs_numerics)
unlensed_total_flux = get_unlensed_total_flux_numerical(
kwargs_src_light, unlensed_image_model
) # analytical only runs for profiles that allow analytic integration
img_features[
'total_magnification'] = lensed_total_flux / unlensed_total_flux
img_features['unlensed_total_flux'] = unlensed_total_flux
#except:
# pass
# Generate image for export
img = lensed_image_model.image(kwargs_lens_mass, kwargs_src_light, None,
None)
img = np.maximum(0.0, img) # safeguard against negative pixel values
return img, img_features
def test_create_empty(self):
kwargs_data = sim_util.data_configure_simple(numPix=10, deltaPix=1, exposure_time=1, background_rms=1)
data_class = ImageData(**kwargs_data)
imageModel_empty = ImageModel(data_class, PSF())
assert imageModel_empty._psf_error_map == False
flux = imageModel_empty.lens_surface_brightness(kwargs_lens_light=None)
assert flux.all() == 0
def test_low_res(self):
image_model = ImageModel(self.pixel_grid,
self.psf_class,
lens_light_model_class=self.lightModel,
kwargs_numerics=self.kwargs_numerics_low_res)
image_conv = image_model.image(kwargs_lens_light=self.kwargs_light,
unconvolved=False)
npt.assert_almost_equal(
(self.image_true - image_conv) / self.image_true, 0, decimal=1)
def test_sub_frame(self):
image_model = ImageModel(self.pixel_grid,
self.psf_class,
lens_light_model_class=self.lightModel,
kwargs_numerics=self.kwargs_numerics_partial)
image_conv = image_model.image(kwargs_lens_light=self.kwargs_light,
unconvolved=False)
delta = (self.image_true - image_conv) / self.image_true
npt.assert_almost_equal(delta[self._conv_pixels_partial], 0, decimal=1)
def setup(self):
self.SimAPI = Simulation()
# data specifics
sigma_bkg = .05 # background noise per pixel
exp_time = 100 # exposure time (arbitrary units, flux per pixel is in units #photons/exp_time unit)
numPix = 100 # cutout pixel size
deltaPix = 0.05 # pixel size in arcsec (area per pixel = deltaPix**2)
fwhm = 0.5 # full width half max of PSF
# PSF specification
kwargs_data = self.SimAPI.data_configure(numPix, deltaPix, exp_time, sigma_bkg)
data_class = Data(kwargs_data)
kwargs_psf = self.SimAPI.psf_configure(psf_type='GAUSSIAN', fwhm=fwhm, kernelsize=31, deltaPix=deltaPix, truncate=3,
kernel=None)
psf_class = PSF(kwargs_psf)
psf_class._psf_error_map = np.zeros_like(psf_class.kernel_point_source)
# 'EXERNAL_SHEAR': external shear
kwargs_shear = {'e1': 0.01, 'e2': 0.01} # gamma_ext: shear strength, psi_ext: shear angel (in radian)
phi, q = 0.2, 0.8
e1, e2 = param_util.phi_q2_ellipticity(phi, q)
kwargs_spemd = {'theta_E': 1., 'gamma': 1.8, 'center_x': 0, 'center_y': 0, 'e1': e1, 'e2': e2}
lens_model_list = ['SPEP', 'SHEAR']
self.kwargs_lens = [kwargs_spemd, kwargs_shear]
lens_model_class = LensModel(lens_model_list=lens_model_list)
# list of light profiles (for lens and source)
# 'SERSIC': spherical Sersic profile
kwargs_sersic = {'amp': 1., 'R_sersic': 0.1, 'n_sersic': 2, 'center_x': 0, 'center_y': 0}
# 'SERSIC_ELLIPSE': elliptical Sersic profile
phi, q = 0.2, 0.9
e1, e2 = param_util.phi_q2_ellipticity(phi, q)
kwargs_sersic_ellipse = {'amp': 1., 'R_sersic': .6, 'n_sersic': 7, 'center_x': 0, 'center_y': 0,
'e1': e1, 'e2': e2}
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.01, 'dec_source': 0.0,
'source_amp': 1.}] # quasar point source position in the source plane and intrinsic brightness
point_source_class = PointSource(point_source_type_list=['SOURCE_POSITION'], fixed_magnification_list=[True])
kwargs_numerics = {'subgrid_res': 2, 'psf_subgrid': True}
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 = self.SimAPI.simulate(imageModel, self.kwargs_lens, self.kwargs_source,
self.kwargs_lens_light, self.kwargs_ps)
data_class.update_data(image_sim)
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.solver = LensEquationSolver(lensModel=self.imageModel.LensModel)
def test_full(self):
image_model_true = ImageModel(
self.pixel_grid,
self.psf_class,
lens_light_model_class=self.lightModel,
kwargs_numerics=self.kwargs_numerics_true)
image_unconvolved = image_model_true.image(
kwargs_lens_light=self.kwargs_light, unconvolved=True)
npt.assert_almost_equal(np.sum(self.image_true) /
np.sum(image_unconvolved),
1,
decimal=2)
def kappa_map(self, kwargs_options, kwargs_data, kwargs_lens, kwargs_else,
x_clump, y_clump, phi_E_clump, r_trunc):
"""
:param kwargs_options:
:param kwargs_data:
:param kwargs_lens:
:param kwargs_else:
:return:
"""
kwargs_options_clump = copy.deepcopy(kwargs_options)
kwargs_options_clump["add_clump"] = True
clump_kwargs = {
'r_trunc': r_trunc,
'phi_E_clump': phi_E_clump,
'x_clump': x_clump,
'y_clump': y_clump
}
kwargs_else.update(clump_kwargs)
makeImage = ImageModel(kwargs_options_clump, kwargs_data)
if kwargs_options["multiBand"]:
x_grid, y_grid = kwargs_data[0]['x_coords'], kwargs_data[0][
'y_coords']
else:
x_grid, y_grid = kwargs_data['x_coords'], kwargs_data['y_coords']
kappa_result = util.array2image(
makeImage.LensModel.kappa(x_grid, y_grid, kwargs_else,
**kwargs_lens))
return kappa_result
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 create_image_model(kwargs_data, kwargs_psf, kwargs_numerics, kwargs_model):
"""
:param kwargs_data:
:param kwargs_psf:
:param kwargs_options:
:return:
"""
data_class = Data(kwargs_data)
psf_class = PSF(kwargs_psf)
lens_model_class = LensModel(
lens_model_list=kwargs_model.get('lens_model_list', []),
z_source=kwargs_model.get('z_source', None),
redshift_list=kwargs_model.get('redshift_list', None),
multi_plane=kwargs_model.get('multi_plane', False))
source_model_class = LightModel(
light_model_list=kwargs_model.get('source_light_model_list', []))
lens_light_model_class = LightModel(
light_model_list=kwargs_model.get('lens_light_model_list', []))
point_source_class = PointSource(
point_source_type_list=kwargs_model.get('point_source_model_list', []),
lensModel=lens_model_class,
fixed_magnification_list=kwargs_model.get('fixed_magnification_list',
None),
additional_images_list=kwargs_model.get('additional_images_list',
None),
min_distance=kwargs_model.get('min_distance', 0.01),
search_window=kwargs_model.get('search_window', 5),
precision_limit=kwargs_model.get('precision_limit', 10**(-10)),
num_iter_max=kwargs_model.get('num_iter_max', 100))
imageModel = ImageModel(data_class, psf_class, lens_model_class,
source_model_class, lens_light_model_class,
point_source_class, kwargs_numerics)
return imageModel
def _set_sim_api(self, num_pix, kwargs_detector, psf_kernel_size, which_psf_maps):
"""Set the simulation API objects
"""
self.data_api = DataAPI(num_pix, **kwargs_detector)
#self.pixel_scale = data_api.pixel_scale
pixel_scale = kwargs_detector['pixel_scale']
psf_model = psf_utils.get_PSF_model(kwargs_detector['psf_type'], pixel_scale, seeing=kwargs_detector['seeing'], kernel_size=psf_kernel_size, which_psf_maps=which_psf_maps)
# Set the precision level of lens equation solver
self.min_distance = 0.05
self.search_window = pixel_scale*num_pix
self.image_model = ImageModel(self.data_api.data_class, psf_model, self.lens_mass_model, self.src_light_model, self.lens_light_model, self.ps_model, kwargs_numerics=self.kwargs_numerics)
if 'agn_light' in self.components:
self.unlensed_image_model = ImageModel(self.data_api.data_class, psf_model, None, self.src_light_model, None, self.unlensed_ps_model, kwargs_numerics=self.kwargs_numerics)
else:
self.unlensed_image_model = ImageModel(self.data_api.data_class, psf_model, None, self.src_light_model, None, None, kwargs_numerics=self.kwargs_numerics)
def __init__(self,
multi_band_list,
lens_model_list=None,
source_model_class=None,
lens_light_model_class=None,
point_source_class=None):
imageModel_list = []
self._idex_lens_list = []
for i in range(len(multi_band_list)):
kwargs_data = multi_band_list[i][0]
kwargs_psf = multi_band_list[i][1]
kwargs_numerics = multi_band_list[i][2]
index_lens_list = multi_band_list[i][3].get(
'index_lens_list', [k for k in range(len(lens_model_list))])
self._idex_lens_list.append(index_lens_list)
lens_model_list_sub = [lens_model_list[k] for k in index_lens_list]
lens_model_class = LensModel(lens_model_list=lens_model_list_sub)
data_i = Data(kwargs_data=kwargs_data)
psf_i = PSF(kwargs_psf=kwargs_psf)
point_source_class_i = copy.deepcopy(point_source_class)
imageModel = ImageModel(data_i,
psf_i,
lens_model_class,
source_model_class,
lens_light_model_class,
point_source_class_i,
kwargs_numerics=kwargs_numerics)
imageModel_list.append(imageModel)
super(MultiFrame, self).__init__(imageModel_list)
def image_model_class(self, kwargs_numerics={}):
"""
:param kwargs_numerics: keyword arguments list of Numerics module
:return: instance of the ImageModel class with all the specified configurations
"""
return ImageModel(self.data_class, self.psf_class, self.lens_model_class, self.source_model_class,
self.lens_light_model_class, self.point_source_model_class, kwargs_numerics=kwargs_numerics)
def make_image_fixed_source(self,
param,
kwargs_options,
kwargs_data,
kwargs_lens,
kwargs_source,
kwargs_psf,
kwargs_lens_light,
kwargs_else,
add_noise=False):
"""
make an image with fixed source parameters
:param kwargs_lens:
:param kwargs_source:
:param kwargs_psf:
:param kwargs_lens_light:
:param kwargs_else:
:return:
"""
subgrid_res = kwargs_options['subgrid_res']
num_order = kwargs_options.get('shapelet_order', 0)
image = []
residuals = []
for i in range(self.num_bands(kwargs_data)):
kwargs_data_i = kwargs_data[i]
kwargs_psf_i = kwargs_psf["image" + str(i + 1)]
param_i = param[i]
deltaPix = kwargs_data_i['deltaPix']
x_grid, y_grid = kwargs_data_i['x_coords'], kwargs_data_i[
'y_coords']
x_grid_sub, y_grid_sub = util.make_subgrid(x_grid, y_grid,
subgrid_res)
numPix = len(kwargs_data_i['image_data'])
makeImage = ImageModel(kwargs_options, kwargs_data_i)
image_i, error_map = makeImage.make_image_with_params(
x_grid_sub, y_grid_sub, kwargs_lens, kwargs_source,
kwargs_psf_i, kwargs_lens_light, kwargs_else, numPix, deltaPix,
subgrid_res, param_i, num_order)
residuals_i = util.image2array(
makeImage.reduced_residuals(image_i, error_map))
residuals.append(residuals_i)
if add_noise:
image_i = makeImage.add_noise2image(image_i)
image.append(image_i)
return image, residuals
def __init__(self, numpix, kwargs_single_band, kwargs_model,
kwargs_numerics):
"""
:param numpix: number of pixels per axis
:param kwargs_single_band: keyword arguments specifying the class instance of DataAPI
:param kwargs_model: keyword arguments specifying the class instance of ModelAPI
:param kwargs_numerics: keyword argument with various numeric description (see ImageNumerics class for options)
"""
DataAPI.__init__(self, numpix, **kwargs_single_band)
ModelAPI.__init__(self, **kwargs_model)
self._image_model_class = ImageModel(self.data_class,
self.psf_class,
self.lens_model_class,
self.source_model_class,
self.lens_light_model_class,
self.point_source_model_class,
kwargs_numerics=kwargs_numerics)
def test_point_source_rendering(self):
# initialize data
from lenstronomy.SimulationAPI.simulations import Simulation
SimAPI = Simulation()
numPix = 100
deltaPix = 0.05
kwargs_data = SimAPI.data_configure(numPix, deltaPix, exposure_time=1, sigma_bkg=1)
data_class = Data(kwargs_data)
kernel = np.zeros((5, 5))
kernel[2, 2] = 1
kwargs_psf = {'kernel_point_source': kernel, 'kernel_pixel': kernel, 'psf_type': 'PIXEL'}
psf_class = PSF(kwargs_psf)
lens_model_class = LensModel(['SPEP'])
source_model_class = LightModel([])
lens_light_model_class = LightModel([])
kwargs_numerics = {'subgrid_res': 2, 'point_source_subgrid': 1}
point_source_class = PointSource(point_source_type_list=['LENSED_POSITION'], fixed_magnification_list=[False])
makeImage = ImageModel(data_class, psf_class, lens_model_class, source_model_class, lens_light_model_class, point_source_class, kwargs_numerics=kwargs_numerics)
# chose point source positions
x_pix = np.array([10, 5, 10, 90])
y_pix = np.array([40, 50, 60, 50])
ra_pos, dec_pos = makeImage.Data.map_pix2coord(x_pix, y_pix)
e1, e2 = param_util.phi_q2_ellipticity(0, 0.8)
kwargs_lens_init = [{'theta_E': 1, 'gamma': 2, 'e1': e1, 'e2': e2, 'center_x': 0, 'center_y': 0}]
kwargs_else = [{'ra_image': ra_pos, 'dec_image': dec_pos, 'point_amp': np.ones_like(ra_pos)}]
model = makeImage.image(kwargs_lens_init, kwargs_source={}, kwargs_lens_light={}, kwargs_ps=kwargs_else)
image = makeImage.ImageNumerics.array2image(model)
for i in range(len(x_pix)):
npt.assert_almost_equal(image[y_pix[i], x_pix[i]], 1, decimal=2)
x_pix = np.array([10.5, 5.5, 10.5, 90.5])
y_pix = np.array([40, 50, 60, 50])
ra_pos, dec_pos = makeImage.Data.map_pix2coord(x_pix, y_pix)
phi, q = 0., 0.8
e1, e2 = param_util.phi_q2_ellipticity(phi, q)
kwargs_lens_init = [{'theta_E': 1, 'gamma': 2, 'e1': e1, 'e2': e2, 'center_x': 0, 'center_y': 0}]
kwargs_else = [{'ra_image': ra_pos, 'dec_image': dec_pos, 'point_amp': np.ones_like(ra_pos)}]
model = makeImage.image(kwargs_lens_init, kwargs_source={}, kwargs_lens_light={}, kwargs_ps=kwargs_else)
image = makeImage.ImageNumerics.array2image(model)
for i in range(len(x_pix)):
print(int(y_pix[i]), int(x_pix[i]+0.5))
npt.assert_almost_equal(image[int(y_pix[i]), int(x_pix[i])], 0.5, decimal=1)
npt.assert_almost_equal(image[int(y_pix[i]), int(x_pix[i]+0.5)], 0.5, decimal=1)
def test_point_source_rendering(self):
# initialize data
numPix = 100
deltaPix = 0.05
kwargs_data = sim_util.data_configure_simple(numPix, deltaPix, exposure_time=1, background_rms=1)
data_class = ImageData(**kwargs_data)
kernel = np.zeros((5, 5))
kernel[2, 2] = 1
kwargs_psf = {'kernel_point_source': kernel, 'psf_type': 'PIXEL', 'psf_error_map': np.ones_like(kernel) * 0.001}
psf_class = PSF(**kwargs_psf)
lens_model_class = LensModel(['SPEP'])
source_model_class = LightModel([])
lens_light_model_class = LightModel([])
kwargs_numerics = {'supersampling_factor': 2, 'supersampling_convolution': True, 'point_source_supersampling_factor': 1}
point_source_class = PointSource(point_source_type_list=['LENSED_POSITION'], fixed_magnification_list=[False])
makeImage = ImageModel(data_class, psf_class, lens_model_class, source_model_class, lens_light_model_class, point_source_class, kwargs_numerics=kwargs_numerics)
# chose point source positions
x_pix = np.array([10, 5, 10, 90])
y_pix = np.array([40, 50, 60, 50])
ra_pos, dec_pos = makeImage.Data.map_pix2coord(x_pix, y_pix)
e1, e2 = param_util.phi_q2_ellipticity(0, 0.8)
kwargs_lens_init = [{'theta_E': 1, 'gamma': 2, 'e1': e1, 'e2': e2, 'center_x': 0, 'center_y': 0}]
kwargs_else = [{'ra_image': ra_pos, 'dec_image': dec_pos, 'point_amp': np.ones_like(ra_pos)}]
image = makeImage.image(kwargs_lens_init, kwargs_source={}, kwargs_lens_light={}, kwargs_ps=kwargs_else)
#print(np.shape(model), 'test')
#image = makeImage.ImageNumerics.array2image(model)
for i in range(len(x_pix)):
npt.assert_almost_equal(image[y_pix[i], x_pix[i]], 1, decimal=2)
x_pix = np.array([10.5, 5.5, 10.5, 90.5])
y_pix = np.array([40, 50, 60, 50])
ra_pos, dec_pos = makeImage.Data.map_pix2coord(x_pix, y_pix)
phi, q = 0., 0.8
e1, e2 = param_util.phi_q2_ellipticity(phi, q)
kwargs_lens_init = [{'theta_E': 1, 'gamma': 2, 'e1': e1, 'e2': e2, 'center_x': 0, 'center_y': 0}]
kwargs_else = [{'ra_image': ra_pos, 'dec_image': dec_pos, 'point_amp': np.ones_like(ra_pos)}]
image = makeImage.image(kwargs_lens_init, kwargs_source={}, kwargs_lens_light={}, kwargs_ps=kwargs_else)
#image = makeImage.ImageNumerics.array2image(model)
for i in range(len(x_pix)):
print(int(y_pix[i]), int(x_pix[i]+0.5))
npt.assert_almost_equal(image[int(y_pix[i]), int(x_pix[i])], 0.5, decimal=1)
npt.assert_almost_equal(image[int(y_pix[i]), int(x_pix[i]+0.5)], 0.5, decimal=1)
def create_image_model(kwargs_data,
kwargs_psf,
kwargs_numerics,
lens_model_list=[],
z_lens=None,
z_source=None,
lens_redshift_list=None,
multi_plane=False,
source_light_model_list=[],
lens_light_model_list=[],
point_source_model_list=[],
fixed_magnification_list=None,
additional_images_list=None,
min_distance=0.01,
search_window=5,
precision_limit=10**(-10),
num_iter_max=100,
multi_band_type=None,
source_deflection_scaling_list=None,
source_redshift_list=None,
cosmo=None):
"""
:param kwargs_data:
:param kwargs_psf:
:param kwargs_options:
:return:
"""
data_class = Data(kwargs_data)
psf_class = PSF(kwargs_psf)
lens_model_class = LensModel(lens_model_list=lens_model_list,
z_lens=z_lens,
z_source=z_source,
lens_redshift_list=lens_redshift_list,
multi_plane=multi_plane,
cosmo=cosmo)
source_model_class = LightModel(
light_model_list=source_light_model_list,
deflection_scaling_list=source_deflection_scaling_list,
source_redshift_list=source_redshift_list)
lens_light_model_class = LightModel(light_model_list=lens_light_model_list)
point_source_class = PointSource(
point_source_type_list=point_source_model_list,
lensModel=lens_model_class,
fixed_magnification_list=fixed_magnification_list,
additional_images_list=additional_images_list,
min_distance=min_distance,
search_window=search_window,
precision_limit=precision_limit,
num_iter_max=num_iter_max)
imageModel = ImageModel(data_class, psf_class, lens_model_class,
source_model_class, lens_light_model_class,
point_source_class, kwargs_numerics)
return imageModel
def setup(self):
# data specifics
sigma_bkg = .05 # background noise per pixel
exp_time = 100 # exposure time (arbitrary units, flux per pixel is in units #photons/exp_time unit)
numPix = 100 # cutout pixel size
deltaPix = 0.05 # 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 = {'psf_type': 'GAUSSIAN', 'fwhm': fwhm, 'truncation': 5, 'pixel_size': deltaPix}
psf_class = PSF(**kwargs_psf)
# 'EXTERNAL_SHEAR': external shear
kwargs_shear = {'e1': 0.01, 'e2': 0.01} # gamma_ext: shear strength, psi_ext: shear angel (in radian)
phi, q = 0.2, 0.8
e1, e2 = param_util.phi_q2_ellipticity(phi, q)
kwargs_spemd = {'theta_E': 1., 'gamma': 1.8, 'center_x': 0, 'center_y': 0, 'e1': e1, 'e2': e2}
lens_model_list = ['SPEP', 'SHEAR']
self.kwargs_lens = [kwargs_spemd, kwargs_shear]
lens_model_class = LensModel(lens_model_list=lens_model_list)
# list of light profiles (for lens and source)
# 'SERSIC': spherical Sersic profile
kwargs_sersic = {'amp': 1., 'R_sersic': 0.1, 'n_sersic': 2, 'center_x': 0, 'center_y': 0}
# 'SERSIC_ELLIPSE': elliptical Sersic profile
phi, q = 0.2, 0.9
e1, e2 = param_util.phi_q2_ellipticity(phi, q)
kwargs_sersic_ellipse = {'amp': 1., 'R_sersic': .6, 'n_sersic': 7, 'center_x': 0, 'center_y': 0,
'e1': e1, 'e2': e2}
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.0001, 'dec_source': 0.0,
'source_amp': 1.}] # quasar point source position in the source plane and intrinsic brightness
point_source_class = PointSource(point_source_type_list=['SOURCE_POSITION'], fixed_magnification_list=[True])
kwargs_numerics = {'supersampling_factor': 2, 'supersampling_convolution': True, 'compute_mode': 'gaussian'}
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)
kwargs_data['image_data'] = image_sim
self.solver = LensEquationSolver(lensModel=lens_model_class)
multi_band_list = [[kwargs_data, kwargs_psf, kwargs_numerics]]
kwargs_model = {'lens_model_list': lens_model_list, 'source_light_model_list': source_model_list,
'point_source_model_list': ['SOURCE_POSITION'], 'fixed_magnification_list': [True]}
self.imageModel = MultiLinear(multi_band_list, kwargs_model, likelihood_mask_list=None, compute_bool=None)
def __init__(self,
multi_band_list,
lens_model_class=None,
source_model_list=None,
lens_light_model_list=None,
point_source_class=None):
imageModel_list = []
self._index_source_list = []
self._index_lens_light_list = []
for i in range(len(multi_band_list)):
kwargs_data = multi_band_list[i][0]
kwargs_psf = multi_band_list[i][1]
kwargs_numerics = multi_band_list[i][2]
data_i = Data(kwargs_data=kwargs_data)
psf_i = PSF(kwargs_psf=kwargs_psf)
index_source_list = multi_band_list[i][3].get(
'index_source_light_model',
[k for k in range(len(source_model_list))])
self._index_source_list.append(index_source_list)
source_model_list_sub = [
source_model_list[k] for k in index_source_list
]
source_model_class = LightModel(
light_model_list=source_model_list_sub)
index_lens_light_list = multi_band_list[i][3].get(
'index_lens_light_model',
[k for k in range(len(source_model_list))])
self._index_lens_light_list.append(index_lens_light_list)
lens_light_model_list_sub = [
lens_light_model_list[k] for k in index_lens_light_list
]
lens_light_model_class = LightModel(
light_model_list=lens_light_model_list_sub)
imageModel = ImageModel(data_i,
psf_i,
lens_model_class,
source_model_class,
lens_light_model_class,
point_source_class,
kwargs_numerics=kwargs_numerics)
imageModel_list.append(imageModel)
super(MultiBandMultiModel, self).__init__(imageModel_list)
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 creat_image_model(kwargs_data, kwargs_psf, kwargs_numerics, kwargs_model):
"""
:param kwargs_data:
:param kwargs_psf:
:param kwargs_options:
:return:
"""
data_class = Data(kwargs_data)
psf_class = PSF(kwargs_psf)
if 'lens_model_list' in kwargs_model:
lens_model_class = LensModel(
lens_model_list=kwargs_model.get('lens_model_list', None),
z_source=kwargs_model.get('z_source', None),
redshift_list=kwargs_model.get('redshift_list', None),
multi_plane=kwargs_model.get('multi_plane', False))
else:
lens_model_class = None
if 'source_light_model_list' in kwargs_model:
source_model_class = LightModel(light_model_list=kwargs_model.get(
'source_light_model_list', ['NONE']))
else:
source_model_class = None
if 'lens_light_model_list' in kwargs_model:
lens_light_model_class = LightModel(light_model_list=kwargs_model.get(
'lens_light_model_list', ['NONE']))
else:
lens_light_model_class = None
if 'point_source_model_list' in kwargs_model:
point_source_class = PointSource(
point_source_type_list=kwargs_model.get('point_source_model_list',
['NONE']),
fixed_magnification_list=kwargs_model.get(
'fixed_magnification_list', None),
additional_images_list=kwargs_model.get('additional_images_list',
None))
else:
point_source_class = None
imageModel = ImageModel(data_class, psf_class, lens_model_class,
source_model_class, lens_light_model_class,
point_source_class, kwargs_numerics)
return imageModel
def __init__(self, multi_band_list, lens_model_class, source_model_class,
lens_light_model_class, point_source_class):
self._num_bands = len(multi_band_list)
self.lensModel = lens_model_class
self.pointSource = point_source_class
self._imageModel_list = []
for i in range(self._num_bands):
kwargs_data = multi_band_list[i][0]
kwargs_psf = multi_band_list[i][1]
kwargs_numerics = multi_band_list[i][2]
data_i = Data(kwargs_data=kwargs_data)
psf_i = PSF(kwargs_psf=kwargs_psf)
self._imageModel_list.append(
ImageModel(data_i,
psf_i,
lens_model_class,
source_model_class,
lens_light_model_class,
point_source_class,
kwargs_numerics=kwargs_numerics))
def __init__(self,
multi_band_list,
lens_model_class=None,
source_model_class=None,
lens_light_model_class=None,
point_source_class=None):
imageModel_list = []
for i in range(len(multi_band_list)):
kwargs_data = multi_band_list[i][0]
kwargs_psf = multi_band_list[i][1]
kwargs_numerics = multi_band_list[i][2]
data_i = Data(kwargs_data=kwargs_data)
psf_i = PSF(kwargs_psf=kwargs_psf)
imageModel = ImageModel(data_i,
psf_i,
lens_model_class,
source_model_class,
lens_light_model_class,
point_source_class,
kwargs_numerics=kwargs_numerics)
imageModel_list.append(imageModel)
super(MultiBand, self).__init__(imageModel_list)
def survey_kwargs(self, survey_kwargs):
survey_name = survey_kwargs['survey_name']
bandpass_list = survey_kwargs['bandpass_list']
coadd_years = survey_kwargs.get('coadd_years')
override_obs_kwargs = survey_kwargs.get('override_obs_kwargs', {})
override_camera_kwargs = survey_kwargs.get('override_camera_kwargs', {})
import lenstronomy.SimulationAPI.ObservationConfig as ObsConfig
from importlib import import_module
sys.path.insert(0, ObsConfig.__path__[0])
SurveyClass = getattr(import_module(survey_name), survey_name)
self._data_api = [] # init
self._image_model = [] # init
for bp in bandpass_list:
survey_obj = SurveyClass(band=bp,
psf_type=self.psf_type,
coadd_years=coadd_years)
# Override as specified in survey_kwargs
survey_obj.camera.update(override_camera_kwargs)
survey_obj.obs.update(override_obs_kwargs)
# This is what we'll actually use
kwargs_detector = survey_obj.kwargs_single_band()
data_api = DataAPI(self.n_pix, **kwargs_detector)
psf_model = psf_utils.get_PSF_model(self.psf_type,
self.pixel_scale,
seeing=kwargs_detector['seeing'],
kernel_size=self.psf_kernel_size,
which_psf_maps=self.which_psf_maps)
image_model_bp = ImageModel(data_api.data_class,
psf_model,
self.lens_model,
self.src_model,
None,
None,
kwargs_numerics=self.kwargs_numerics)
self._data_api.append(data_api)
self._image_model.append(image_model_bp)
def generate_lens(sigma_bkg=sigma_bkg,
exp_time=exp_time,
numPix=numPix,
deltaPix=deltaPix,
fwhm=fwhm,
psf_type=psf_type,
kernel_size=kernel_size,
z_source=z_source,
z_lens=z_lens,
phi_ext=phi_ext,
gamma_ext=gamma_ext,
theta_E=theta_E,
gamma_lens=gamma_lens,
e1_lens=e1_lens,
e2_lens=e2_lens,
center_x_lens_light=center_x_lens_light,
center_y_lens_light=center_y_lens_light,
source_x=source_y,
source_y=source_y,
q_source=q_source,
phi_source=phi_source,
center_x=center_x,
center_y=center_y,
amp_source=amp_source,
R_sersic_source=R_sersic_source,
n_sersic_source=n_sersic_source,
phi_lens_light=phi_lens_light,
q_lens_light=q_lens_light,
amp_lens=amp_lens,
R_sersic_lens=R_sersic_lens,
n_sersic_lens=n_sersic_lens,
amp_ps=amp_ps,
supersampling_factor=supersampling_factor,
v_min=v_min,
v_max=v_max,
cosmo=cosmo,
cosmo2=cosmo2,
lens_pos_eq_lens_light_pos=True,
same_cosmology=True):
kwargs_data = sim_util.data_configure_simple(numPix, deltaPix, exp_time,
sigma_bkg)
data_class = ImageData(**kwargs_data)
kwargs_psf = {'psf_type': psf_type, 'pixel_size': deltaPix, 'fwhm': fwhm}
psf_class = PSF(**kwargs_psf)
cosmo = FlatLambdaCDM(H0=75, Om0=0.3, Ob0=0.)
cosmo = FlatLambdaCDM(H0=65, Om0=0.3, Ob0=0.)
gamma1, gamma2 = param_util.shear_polar2cartesian(phi=phi_ext,
gamma=gamma_ext)
kwargs_shear = {'gamma1': gamma1, 'gamma2': gamma2}
if lens_pos_eq_lens_light_pos:
center_x = center_x_lens_light
center_y = center_y_lens_light
if same_cosmology:
cosmo2 = cosmo
kwargs_spemd = {
'theta_E': theta_E,
'gamma': gamma_lens,
'center_x': center_x,
'center_y': center_y,
'e1': e1_lens,
'e2': e2_lens
}
lens_model_list = ['SPEP', 'SHEAR']
kwargs_lens = [kwargs_spemd, kwargs_shear]
lens_model_class = LensModel(lens_model_list=lens_model_list,
z_lens=z_lens,
z_source=z_source,
cosmo=cosmo)
lens_model_class2 = LensModel(lens_model_list=lens_model_list,
z_lens=z_lens,
z_source=z_source,
cosmo=cosmo2)
e1_source, e2_source = param_util.phi_q2_ellipticity(phi_source, q_source)
kwargs_sersic_source = {
'amp': amp_source,
'R_sersic': R_sersic_source,
'n_sersic': n_sersic_source,
'e1': e1_source,
'e2': e2_source,
'center_x': source_x,
'center_y': source_y
}
source_model_list = ['SERSIC_ELLIPSE']
kwargs_source = [kwargs_sersic_source]
source_model_class = LightModel(light_model_list=source_model_list)
##
e1_lens_light, e2_lens_light = param_util.phi_q2_ellipticity(
phi_lens_light, q_lens_light)
kwargs_sersic_lens = {
'amp': amp_lens,
'R_sersic': R_sersic_lens,
'n_sersic': n_sersic_lens,
'e1': e1_lens_light,
'e2': e2_lens_light,
'center_x': center_x_lens_light,
'center_y': center_y_lens_light
}
lens_light_model_list = ['SERSIC_ELLIPSE']
kwargs_lens_light = [kwargs_sersic_lens]
lens_light_model_class = LightModel(light_model_list=lens_light_model_list)
##
lensEquationSolver = LensEquationSolver(lens_model_class)
x_image, y_image = lensEquationSolver.findBrightImage(
source_x,
source_y, #position of ps
kwargs_lens, #lens proporties
numImages=4, #expected number of images
min_distance=deltaPix, #'resolution'
search_window=numPix * deltaPix) #search window limits
mag = lens_model_class.magnification(
x_image,
y_image, #for found above ps positions
kwargs=kwargs_lens) # and same lens properties
kwargs_ps = [{
'ra_image': x_image,
'dec_image': y_image,
'point_amp': np.abs(mag) * amp_ps
}]
point_source_list = ['LENSED_POSITION']
point_source_class = PointSource(point_source_type_list=point_source_list,
fixed_magnification_list=[False])
kwargs_numerics = {'supersampling_factor': supersampling_factor}
imageModel = ImageModel(
data_class, # take generated above data specs
psf_class, # same for psf
lens_model_class, # lens model (gal+ext)
source_model_class, # sourse light model
lens_light_model_class, # lens light model
point_source_class, # add generated ps images
kwargs_numerics=kwargs_numerics)
image_sim = imageModel.image(kwargs_lens, kwargs_source, kwargs_lens_light,
kwargs_ps)
poisson = image_util.add_poisson(image_sim, exp_time=exp_time)
bkg = image_util.add_background(image_sim, sigma_bkd=sigma_bkg)
image_sim = image_sim + bkg + poisson
data_class.update_data(image_sim)
kwargs_data['image_data'] = image_sim
cmap_string = 'gray'
cmap = plt.get_cmap(cmap_string)
cmap.set_bad(color='b', alpha=1.)
cmap.set_under('k')
f, axes = plt.subplots(1, 1, figsize=(6, 6), sharex=False, sharey=False)
ax = axes
im = ax.matshow(np.log10(image_sim),
origin='lower',
vmin=v_min,
vmax=v_max,
cmap=cmap,
extent=[0, 1, 0, 1])
ax.get_xaxis().set_visible(False)
ax.get_yaxis().set_visible(False)
ax.autoscale(False)
plt.show()
kwargs_model = {
'lens_model_list': lens_model_list,
'lens_light_model_list': lens_light_model_list,
'source_light_model_list': source_model_list,
'point_source_model_list': point_source_list
}
from lenstronomy.Analysis.td_cosmography import TDCosmography
td_cosmo = TDCosmography(z_lens,
z_source,
kwargs_model,
cosmo_fiducial=cosmo)
# time delays, the unit [days] is matched when the lensing angles are in arcsec
t_days = td_cosmo.time_delays(kwargs_lens, kwargs_ps, kappa_ext=0)
dt_days = t_days[1:] - t_days[0]
dt_sigma = [3, 5, 10] # Gaussian errors
dt_measured = np.random.normal(dt_days, dt_sigma)
print("the measured relative delays are: ", dt_measured)
return f, source_model_list, kwargs_data, kwargs_psf, kwargs_numerics, dt_measured, dt_sigma, kwargs_ps, lens_model_list, lens_light_model_list, source_model_list, point_source_list, lens_model_class2
def setup(self):
# data specifics
sigma_bkg = 0.01 # background noise per pixel
exp_time = 100 # exposure time (arbitrary units, flux per pixel is in units #photons/exp_time unit)
numPix = 100 # cutout pixel size
deltaPix = 0.05 # pixel size in arcsec (area per pixel = deltaPix**2)
fwhm = 0.3 # 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)
sigma = util.fwhm2sigma(fwhm)
x_grid, y_grid = util.make_grid(numPix=31, deltapix=0.05)
from lenstronomy.LightModel.Profiles.gaussian import Gaussian
gaussian = Gaussian()
kernel_point_source = gaussian.function(x_grid, y_grid, amp=1., sigma_x=sigma, sigma_y=sigma,
center_x=0, center_y=0)
kernel_point_source /= np.sum(kernel_point_source)
kernel_point_source = util.array2image(kernel_point_source)
self.kwargs_psf = {'psf_type': 'PIXEL', 'kernel_point_source': kernel_point_source}
psf_class = PSF(kwargs_psf=self.kwargs_psf)
# 'EXERNAL_SHEAR': external shear
kwargs_shear = {'e1': 0.01, 'e2': 0.01} # gamma_ext: shear strength, psi_ext: shear angel (in radian)
phi, q = 0.2, 0.8
e1, e2 = param_util.phi_q2_ellipticity(phi, q)
kwargs_spemd = {'theta_E': 1., 'gamma': 1.8, 'center_x': 0, 'center_y': 0, 'e1': e1, 'e2': e2}
lens_model_list = ['SPEP', 'SHEAR']
self.kwargs_lens = [kwargs_spemd, kwargs_shear]
lens_model_class = LensModel(lens_model_list=lens_model_list)
# list of light profiles (for lens and source)
# 'SERSIC': spherical Sersic profile
kwargs_sersic = {'amp': 1., 'R_sersic': 0.1, 'n_sersic': 2, 'center_x': 0, 'center_y': 0}
# 'SERSIC_ELLIPSE': elliptical Sersic profile
phi, q = 0.2, 0.9
e1, e2 = param_util.phi_q2_ellipticity(phi, q)
kwargs_sersic_ellipse = {'amp': 1., 'R_sersic': .6, 'n_sersic': 7, 'center_x': 0, 'center_y': 0,
'e1': e1, 'e2': e2}
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.0, 'dec_source': 0.0,
'source_amp': 10.}] # quasar point source position in the source plane and intrinsic brightness
point_source_class = PointSource(point_source_type_list=['SOURCE_POSITION'], fixed_magnification_list=[True])
kwargs_numerics = {'subgrid_res': 3, 'psf_subgrid': True}
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.imageModel = ImageModel(data_class, psf_class, lens_model_class, source_model_class,
lens_light_model_class,
point_source_class, kwargs_numerics=kwargs_numerics)
self.psf_fitting = PsfFitting(self.imageModel)
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)
