def inversion_imaging_from_grid_and_data(
self,
grid,
image,
noise_map,
convolver,
settings_pixelization=pix.SettingsPixelization(),
settings_inversion=inv.SettingsInversion(),
preloads=pload.Preloads(),
):
if preloads.mapper is None:
mappers_of_planes = self.mappers_of_planes_from_grid(
grid=grid,
settings_pixelization=settings_pixelization,
preloads=preloads,
)
else:
mappers_of_planes = [preloads.mapper]
return inv.InversionImagingMatrix.from_data_mapper_and_regularization(
image=image,
noise_map=noise_map,
convolver=convolver,
mapper=mappers_of_planes[-1],
regularization=self.regularizations_of_planes[-1],
settings=settings_inversion,
preloads=preloads,
)
def __init__(
self,
dataset,
hyper_result=None,
cosmology=cosmo.Planck15,
settings_pixelization=pix.SettingsPixelization(),
settings_inversion=inv.SettingsInversion(),
preloads=pload.Preloads(),
):
super().__init__(
dataset=dataset,
hyper_result=hyper_result,
cosmology=cosmology,
settings_pixelization=settings_pixelization,
settings_inversion=settings_inversion,
preloads=preloads,
)
if self.hyper_result is not None:
self.set_hyper_dataset(result=self.hyper_result)
else:
self.hyper_galaxy_visibilities_path_dict = None
self.hyper_model_visibilities = None
def inversion_interferometer_from_grid_and_data(
self,
grid,
visibilities,
noise_map,
transformer,
settings_pixelization=pix.SettingsPixelization(),
settings_inversion=inv.SettingsInversion(),
):
sparse_grid = self.sparse_image_plane_grid_from_grid(grid=grid)
mapper = self.mapper_from_grid_and_sparse_grid(
grid=grid,
sparse_grid=sparse_grid,
settings_pixelization=settings_pixelization,
)
return inv.AbstractInversionInterferometer.from_data_mapper_and_regularization(
visibilities=visibilities,
noise_map=noise_map,
transformer=transformer,
mapper=mapper,
regularization=self.regularization,
settings=settings_inversion,
)
def __init__(
self,
dataset,
hyper_result=None,
cosmology=cosmo.Planck15,
settings_pixelization=pix.SettingsPixelization(),
settings_inversion=inv.SettingsInversion(),
preloads=pload.Preloads(),
):
super().__init__(hyper_result=hyper_result, cosmology=cosmology)
self.dataset = dataset
if self.hyper_result is not None:
if hyper_result.search is not None:
hyper_result.search.paths = None
self.set_hyper_dataset(result=self.hyper_result)
else:
self.hyper_galaxy_image_path_dict = None
self.hyper_model_image = None
self.settings_pixelization = settings_pixelization
self.settings_inversion = settings_inversion
self.preloads = preloads
def inversion_imaging_from_grid_and_data(
self,
grid,
image,
noise_map,
convolver,
settings_pixelization=pix.SettingsPixelization(),
settings_inversion=inv.SettingsInversion(),
):
sparse_grid = self.sparse_image_plane_grid_from_grid(grid=grid)
mapper = self.mapper_from_grid_and_sparse_grid(
grid=grid,
sparse_grid=sparse_grid,
settings_pixelization=settings_pixelization,
)
return inv.InversionImagingMatrix.from_data_mapper_and_regularization(
image=image,
noise_map=noise_map,
convolver=convolver,
mapper=mapper,
regularization=self.regularization,
settings=settings_inversion,
)
def __init__(
self,
settings_masked_imaging=imaging.SettingsMaskedImaging(),
settings_pixelization=pix.SettingsPixelization(use_border=True),
settings_inversion=inv.SettingsInversion(),
settings_lens=SettingsLens(),
log_likelihood_cap=None,
):
super().__init__(
settings_masked_imaging=settings_masked_imaging,
settings_pixelization=settings_pixelization,
settings_inversion=settings_inversion,
log_likelihood_cap=log_likelihood_cap,
)
self.settings_lens = settings_lens
def __init__(
self,
masked_interferometer=interferometer.SettingsMaskedInterferometer(),
settings_pixelization=pix.SettingsPixelization(use_border=True),
settings_inversion=inv.SettingsInversion(),
settings_lens=SettingsLens(),
log_likelihood_cap=None,
):
super().__init__(
masked_interferometer=masked_interferometer,
settings_pixelization=settings_pixelization,
settings_inversion=settings_inversion,
log_likelihood_cap=log_likelihood_cap,
)
self.settings_lens = settings_lens
def __init__(
self,
dataset,
positions: grid_2d_irregular.Grid2DIrregular = None,
hyper_result=None,
cosmology=cosmo.Planck15,
settings_pixelization=pix.SettingsPixelization(),
settings_inversion=inv.SettingsInversion(),
settings_lens=settings.SettingsLens(),
preloads=pload.Preloads(),
):
"""
Parameters
----------
dataset
positions : grid_2d_irregular.Grid2DIrregular
Image-pixel coordinates in arc-seconds of bright regions of the lensed source that will map close to one
another in the source-plane(s) for an accurate mass model, which can be used to discard unphysical mass
models during model-fitting.
cosmology
settings_pixelization
settings_inversion
settings_lens
preloads
"""
super().__init__(
dataset=dataset,
hyper_result=hyper_result,
cosmology=cosmology,
settings_pixelization=settings_pixelization,
settings_inversion=settings_inversion,
preloads=preloads,
)
AnalysisLensing.__init__(self=self,
settings_lens=settings_lens,
cosmology=cosmology)
self.positions = positions
self.settings_lens = settings_lens
def __init__(
self,
dataset,
hyper_result=None,
cosmology=cosmo.Planck15,
settings_pixelization=pix.SettingsPixelization(),
settings_inversion=inv.SettingsInversion(),
preloads=pload.Preloads(),
):
super().__init__(
dataset=dataset,
hyper_result=hyper_result,
cosmology=cosmology,
settings_pixelization=settings_pixelization,
settings_inversion=settings_inversion,
preloads=preloads,
)
self.dataset = dataset
def inversion_imaging_from_grid_and_data(
self,
grid,
image,
noise_map,
convolver,
settings_pixelization=pix.SettingsPixelization(),
settings_inversion=inv.SettingsInversion(),
):
mappers_of_planes = self.mappers_of_planes_from_grid(
grid=grid, settings_pixelization=settings_pixelization)
return inv.InversionImagingMatrix.from_data_mapper_and_regularization(
image=image,
noise_map=noise_map,
convolver=convolver,
mapper=mappers_of_planes[-1],
regularization=self.regularizations_of_planes[-1],
settings=settings_inversion,
)
def compute_curvature_matrix(
visibilities: vis.Visibilities,
noise_map: vis.VisibilitiesNoiseMap,
transformer: trans.TransformerNUFFT,
mapper: mappers.Mapper,
regularization: reg.Regularization,
settings=inv.SettingsInversion(),
):
transformed_mapping_matrices = transformer.transformed_mapping_matrices_from_mapping_matrix(
mapping_matrix=mapper.mapping_matrix)
real_data_vector = inversion_util.data_vector_via_transformed_mapping_matrix_from(
transformed_mapping_matrix=transformed_mapping_matrices[0],
visibilities=visibilities[:, 0],
noise_map=noise_map[:, 0],
)
imag_data_vector = inversion_util.data_vector_via_transformed_mapping_matrix_from(
transformed_mapping_matrix=transformed_mapping_matrices[1],
visibilities=visibilities[:, 1],
noise_map=noise_map[:, 1],
)
real_curvature_matrix = inversion_util.curvature_matrix_via_mapping_matrix_from(
mapping_matrix=transformed_mapping_matrices[0],
noise_map=noise_map[:, 0])
imag_curvature_matrix = inversion_util.curvature_matrix_via_mapping_matrix_from(
mapping_matrix=transformed_mapping_matrices[1],
noise_map=noise_map[:, 1])
regularization_matrix = regularization.regularization_matrix_from_mapper(
mapper=mapper)
data_vector = np.add(real_data_vector, imag_data_vector)
curvature_matrix = np.add(real_curvature_matrix, imag_curvature_matrix)
curvature_reg_matrix = np.add(curvature_matrix, regularization_matrix)
return curvature_reg_matrix
def inversion_interferometer_from_grid_and_data(
self,
grid,
visibilities,
noise_map,
transformer,
settings_pixelization=pix.SettingsPixelization(),
settings_inversion=inv.SettingsInversion(),
preloads=pload.Preloads(),
):
mappers_of_planes = self.mappers_of_planes_from_grid(
grid=grid, settings_pixelization=settings_pixelization, preloads=preloads
)
return inv.AbstractInversionInterferometer.from_data_mapper_and_regularization(
visibilities=visibilities,
noise_map=noise_map,
transformer=transformer,
mapper=mappers_of_planes[-1],
regularization=self.regularizations_of_planes[-1],
settings=settings_inversion,
)
def __init__(
self,
masked_imaging,
tracer,
hyper_image_sky=None,
hyper_background_noise=None,
use_hyper_scaling=True,
settings_pixelization=pix.SettingsPixelization(),
settings_inversion=inv.SettingsInversion(),
):
""" An lens fitter, which contains the tracer's used to perform the fit and functions to manipulate \
the lens dataset's hyper_galaxies.
Parameters
-----------
tracer : ray_tracing.Tracer
The tracer, which describes the ray-tracing and strong lens configuration.
scaled_array_2d_from_array_1d : func
A function which maps the 1D lens hyper_galaxies to its unmasked 2D arrays.
"""
self.tracer = tracer
if use_hyper_scaling:
image = hyper_image_from_image_and_hyper_image_sky(
image=masked_imaging.image, hyper_image_sky=hyper_image_sky
)
noise_map = hyper_noise_map_from_noise_map_tracer_and_hyper_background_noise(
noise_map=masked_imaging.noise_map,
tracer=tracer,
hyper_background_noise=hyper_background_noise,
)
if (
tracer.has_hyper_galaxy
or hyper_image_sky is not None
or hyper_background_noise is not None
):
masked_imaging = masked_imaging.modify_image_and_noise_map(
image=image, noise_map=noise_map
)
else:
image = masked_imaging.image
noise_map = masked_imaging.noise_map
self.blurred_image = tracer.blurred_image_from_grid_and_convolver(
grid=masked_imaging.grid,
convolver=masked_imaging.convolver,
blurring_grid=masked_imaging.blurring_grid,
)
self.profile_subtracted_image = image - self.blurred_image
if not tracer.has_pixelization:
inversion = None
model_image = self.blurred_image
else:
inversion = tracer.inversion_imaging_from_grid_and_data(
grid=masked_imaging.grid_inversion,
image=self.profile_subtracted_image,
noise_map=noise_map,
convolver=masked_imaging.convolver,
settings_pixelization=settings_pixelization,
settings_inversion=settings_inversion,
)
model_image = self.blurred_image + inversion.mapped_reconstructed_image
super().__init__(
masked_imaging=masked_imaging,
model_image=model_image,
inversion=inversion,
use_mask_in_fit=False,
)
def __init__(
self,
masked_interferometer,
tracer,
hyper_background_noise=None,
use_hyper_scaling=True,
settings_pixelization=pix.SettingsPixelization(),
settings_inversion=inv.SettingsInversion(),
):
""" An lens fitter, which contains the tracer's used to perform the fit and functions to manipulate \
the lens dataset's hyper_galaxies.
Parameters
-----------
tracer : ray_tracing.Tracer
The tracer, which describes the ray-tracing and strong lens configuration.
scaled_array_2d_from_array_1d : func
A function which maps the 1D lens hyper_galaxies to its unmasked 2D arrays.
"""
if use_hyper_scaling:
if hyper_background_noise is not None:
noise_map = hyper_background_noise.hyper_noise_map_from_complex_noise_map(
noise_map=masked_interferometer.noise_map
)
else:
noise_map = masked_interferometer.noise_map
if hyper_background_noise is not None:
masked_interferometer = masked_interferometer.modify_noise_map(
noise_map=noise_map
)
else:
noise_map = masked_interferometer.noise_map
self.tracer = tracer
self.profile_visibilities = tracer.profile_visibilities_from_grid_and_transformer(
grid=masked_interferometer.grid,
transformer=masked_interferometer.transformer,
)
self.profile_subtracted_visibilities = (
masked_interferometer.visibilities - self.profile_visibilities
)
if not tracer.has_pixelization:
inversion = None
model_visibilities = self.profile_visibilities
else:
inversion = tracer.inversion_interferometer_from_grid_and_data(
grid=masked_interferometer.grid_inversion,
visibilities=self.profile_subtracted_visibilities,
noise_map=noise_map,
transformer=masked_interferometer.transformer,
settings_pixelization=settings_pixelization,
settings_inversion=settings_inversion,
)
model_visibilities = (
self.profile_visibilities + inversion.mapped_reconstructed_visibilities
)
super().__init__(
masked_interferometer=masked_interferometer,
model_visibilities=model_visibilities,
inversion=inversion,
use_mask_in_fit=False,
)
