def test_create_image_model(self):
imageModel = class_creator.create_image_model(self.kwargs_data, self.kwargs_psf, kwargs_numerics={}, kwargs_model=self.kwargs_model)
assert imageModel.LensModel.lens_model_list[0] == 'SIS'
imageModel = class_creator.create_image_model(self.kwargs_data, self.kwargs_psf, kwargs_numerics={},
kwargs_model={})
assert imageModel.LensModel.lens_model_list == []
def psf_iteration(self, fitting_kwargs, lens_input, source_input,
lens_light_input, ps_input, cosmo_input):
#lens_temp = copy.deepcopy(lens_input)
lens_updated = self._param.update_lens_scaling(cosmo_input, lens_input)
source_updated = self._param.image2source_plane(
source_input, lens_updated)
psf_iter_factor = fitting_kwargs['psf_iter_factor']
psf_iter_num = fitting_kwargs['psf_iter_num']
compute_bool = fitting_kwargs.get('compute_bands',
[True] * len(self.multi_band_list))
kwargs_psf_iter = fitting_kwargs.get('kwargs_psf_iter', {})
for i in range(len(self.multi_band_list)):
if compute_bool[i] is True:
kwargs_data = self.multi_band_list[i][0]
kwargs_psf = self.multi_band_list[i][1]
kwargs_numerics = self.multi_band_list[i][2]
image_model = class_creator.create_image_model(
kwargs_data=kwargs_data,
kwargs_psf=kwargs_psf,
kwargs_numerics=kwargs_numerics,
kwargs_model=self.kwargs_model)
psf_iter = PsfFitting(image_model_class=image_model,
kwargs_psf_iter=kwargs_psf_iter)
kwargs_psf = psf_iter.update_iterative(kwargs_psf,
lens_updated,
source_updated,
lens_light_input,
ps_input,
factor=psf_iter_factor,
num_iter=psf_iter_num,
verbose=self._verbose,
no_break=True)
self.multi_band_list[i][1] = kwargs_psf
self.fitting.multi_band_list[i][1] = kwargs_psf
return 0
def __init__(self, kwargs_data, kwargs_psf, kwargs_numerics, kwargs_model, kwargs_lens, kwargs_source,
kwargs_lens_light, kwargs_ps, arrow_size=0.02, cmap_string="gist_heat"):
"""
:param kwargs_options:
:param kwargs_data:
:param arrow_size:
:param cmap_string:
"""
self._kwargs_data = kwargs_data
if isinstance(cmap_string, str) or isinstance(cmap_string, unicode):
cmap = plt.get_cmap(cmap_string)
else:
cmap = cmap_string
cmap.set_bad(color='k', alpha=1.)
cmap.set_under('k')
self._cmap = cmap
self._arrow_size = arrow_size
data = Data(kwargs_data)
self._coords = data._coords
nx, ny = np.shape(kwargs_data['image_data'])
Mpix2coord = kwargs_data['transform_pix2angle']
self._Mpix2coord = Mpix2coord
self._deltaPix = self._coords.pixel_size
self._frame_size = self._deltaPix * nx
x_grid, y_grid = data.coordinates
self._x_grid = util.image2array(x_grid)
self._y_grid = util.image2array(y_grid)
self._imageModel = class_creator.create_image_model(kwargs_data, kwargs_psf, kwargs_numerics, kwargs_model)
self._analysis = LensAnalysis(kwargs_model)
self._lensModel = 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))
self._lensModelExt = LensModelExtensions(self._lensModel)
model, error_map, cov_param, param = self._imageModel.image_linear_solve(kwargs_lens, kwargs_source,
kwargs_lens_light, kwargs_ps, inv_bool=True)
self._kwargs_lens = kwargs_lens
self._kwargs_source = kwargs_source
self._kwargs_lens_light = kwargs_lens_light
self._kwargs_else = kwargs_ps
self._model = model
self._data = kwargs_data['image_data']
self._cov_param = cov_param
self._norm_residuals = self._imageModel.reduced_residuals(model, error_map=error_map)
self._reduced_x2 = self._imageModel.reduced_chi2(model, error_map=error_map)
log_model = np.log10(model)
log_model[np.isnan(log_model)] = -5
self._v_min_default = max(np.min(log_model), -5)
self._v_max_default = min(np.max(log_model), 10)
print("reduced chi^2 = ", self._reduced_x2)
def savedeconvolvefits(lensRESI,lensRESR,lensRESG):
lens_light_resultI=np.load(lensRESI)
imageModelI = class_creator.create_image_model(kwargs_data, kwargs_psfI, kwargs_numerics, **kwargs_model)
modelI = imageModelI.image([],[],lens_light_resultI,
[], unconvolved=True, source_add=False,
lens_light_add=True, point_source_add=False)
pyfits.writeto('E:\\lenslightinfos\\deconvolvesersic\\'+lensRESI[18:-4]+'.fits',modelI,overwrite=True)
lens_light_resultR = np.load(lensRESR)
imageModelR = class_creator.create_image_model(kwargs_data, kwargs_psfR, kwargs_numerics, **kwargs_model)
modelR = imageModelR.image([], [], lens_light_resultR,
[], unconvolved=True, source_add=False,
lens_light_add=True, point_source_add=False)
pyfits.writeto('E:\\lenslightinfos\\deconvolvesersic\\'+lensRESR[18:-4]+'.fits', modelR,overwrite=True)
lens_light_resultG = np.load(lensRESG)
imageModelG = class_creator.create_image_model(kwargs_data, kwargs_psfG, kwargs_numerics, **kwargs_model)
modelG = imageModelG.image([], [], lens_light_resultG,
[], unconvolved=True, source_add=False,
lens_light_add=True, point_source_add=False)
pyfits.writeto('E:\\lenslightinfos\\deconvolvesersic\\'+lensRESG[18:-4]+'.fits', modelG,overwrite=True)
def _likelihood(self, args):
"""
routine to compute X2 given variable parameters for a MCMC/PSO chainF
"""
#generate image and computes likelihood
kwargs_data = self.update_data(args)
imageModel = class_creator.create_image_model(kwargs_data,
self._kwargs_psf,
self._kwargs_numerics,
**self._kwargs_model)
logL = imageModel.likelihood_data_given_model(
self._kwargs_lens,
self._kwargs_source,
self._kwargs_lens_light,
self._kwargs_else,
source_marg=self._source_marg)
return logL, None
def psf_iteration(self,
num_iter=10,
no_break=True,
stacking_method='median',
block_center_neighbour=0,
keep_psf_error_map=True,
psf_symmetry=1,
psf_iter_factor=1,
verbose=True,
compute_bands=None):
"""
iterative PSF reconstruction
:param num_iter: number of iterations in the process
:param no_break: bool, if False will break the process as soon as one step lead to a wors reconstruction then the previous step
:param stacking_method: string, 'median' and 'mean' supported
:param block_center_neighbour: radius of neighbouring point source to be blocked in the reconstruction
:param keep_psf_error_map: bool, whether or not to keep the previous psf_error_map
:param psf_symmetry: int, number of invariant rotations in the reconstructed PSF
:param psf_iter_factor: factor of new estimated PSF relative to the old one PSF_updated = (1-psf_iter_factor) * PSF_old + psf_iter_factor*PSF_new
:param verbose: bool, print statements
:param compute_bands: bool list, if multiple bands, this process can be limited to a subset of bands
:return: 0, updated PSF is stored in self.mult_iband_list
"""
#lens_temp = copy.deepcopy(lens_input)
kwargs_model = self._updateManager.kwargs_model
param_class = self._param_class
lens_updated = param_class.update_lens_scaling(self._cosmo_temp,
self._lens_temp)
source_updated = param_class.image2source_plane(
self._source_temp, lens_updated)
if compute_bands is None:
compute_bands = [True] * len(self.multi_band_list)
for i in range(len(self.multi_band_list)):
if compute_bands[i] is True:
kwargs_data = self.multi_band_list[i][0]
kwargs_psf = self.multi_band_list[i][1]
kwargs_numerics = self.multi_band_list[i][2]
image_model = class_creator.create_image_model(
kwargs_data=kwargs_data,
kwargs_psf=kwargs_psf,
kwargs_numerics=kwargs_numerics,
**kwargs_model)
psf_iter = PsfFitting(image_model_class=image_model)
kwargs_psf = psf_iter.update_iterative(
kwargs_psf,
lens_updated,
source_updated,
self._lens_light_temp,
self._ps_temp,
num_iter=num_iter,
no_break=no_break,
stacking_method=stacking_method,
block_center_neighbour=block_center_neighbour,
keep_psf_error_map=keep_psf_error_map,
psf_symmetry=psf_symmetry,
psf_iter_factor=psf_iter_factor,
verbose=verbose)
self.multi_band_list[i][1] = kwargs_psf
return 0
