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(),
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 traced_sparse_grids_of_planes_from_grid(
self,
grid,
settings_pixelization=pix.SettingsPixelization(),
preloads=pload.Preloads(),
):
if (preloads.sparse_grids_of_planes is None
or settings_pixelization.is_stochastic):
sparse_image_plane_grids_of_planes = self.sparse_image_plane_grids_of_planes_from_grid(
grid=grid, pixelization_setting=settings_pixelization)
else:
sparse_image_plane_grids_of_planes = preloads.sparse_grids_of_planes
traced_sparse_grids_of_planes = []
for (plane_index, plane) in enumerate(self.planes):
if sparse_image_plane_grids_of_planes[plane_index] is None:
traced_sparse_grids_of_planes.append(None)
else:
traced_sparse_grids = self.traced_grids_of_planes_from_grid(
grid=sparse_image_plane_grids_of_planes[plane_index])
traced_sparse_grids_of_planes.append(
traced_sparse_grids[plane_index])
if len(sparse_image_plane_grids_of_planes) > 1:
return traced_sparse_grids_of_planes, sparse_image_plane_grids_of_planes[
1]
else:
return traced_sparse_grids_of_planes, sparse_image_plane_grids_of_planes[
0]
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 mappers_of_planes_from_grid(
self,
grid,
settings_pixelization=pix.SettingsPixelization(),
preloads=pload.Preloads(),
):
mappers_of_planes = []
traced_grids_of_planes = self.traced_grids_of_planes_from_grid(
grid=grid)
traced_sparse_grids_of_planes, sparse_image_plane_grid = self.traced_sparse_grids_of_planes_from_grid(
grid=grid,
settings_pixelization=settings_pixelization,
preloads=preloads)
for (plane_index, plane) in enumerate(self.planes):
if not plane.has_pixelization:
mappers_of_planes.append(None)
else:
mapper = plane.mapper_from_grid_and_sparse_grid(
grid=traced_grids_of_planes[plane_index],
sparse_grid=traced_sparse_grids_of_planes[plane_index],
sparse_image_plane_grid=sparse_image_plane_grid,
settings_pixelization=settings_pixelization,
)
mappers_of_planes.append(mapper)
return mappers_of_planes
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 mapper_from_grid_and_sparse_grid(
self,
grid,
sparse_grid,
sparse_image_plane_grid=None,
settings_pixelization=pix.SettingsPixelization(),
):
galaxies_with_pixelization = list(
filter(lambda galaxy: galaxy.pixelization is not None,
self.galaxies))
if len(galaxies_with_pixelization) == 0:
return None
if len(galaxies_with_pixelization) == 1:
pixelization = galaxies_with_pixelization[0].pixelization
return pixelization.mapper_from_grid_and_sparse_grid(
grid=grid,
sparse_grid=sparse_grid,
sparse_image_plane_grid=sparse_image_plane_grid,
hyper_image=galaxies_with_pixelization[0].hyper_galaxy_image,
settings=settings_pixelization,
)
elif len(galaxies_with_pixelization) > 1:
raise exc.PixelizationException(
"The number of galaxies with pixelizations in one plane is above 1"
)
def traced_sparse_grids_of_planes_from_grid(
self, grid, settings_pixelization=pix.SettingsPixelization()
):
if (
settings_pixelization.preload_sparse_grids_of_planes is None
or settings_pixelization.is_stochastic
):
sparse_image_plane_grids_of_planes = self.sparse_image_plane_grids_of_planes_from_grid(
grid=grid, pixelization_setting=settings_pixelization
)
else:
sparse_image_plane_grids_of_planes = (
settings_pixelization.preload_sparse_grids_of_planes
)
traced_sparse_grids_of_planes = []
for (plane_index, plane) in enumerate(self.planes):
if sparse_image_plane_grids_of_planes[plane_index] is None:
traced_sparse_grids_of_planes.append(None)
else:
traced_sparse_grids = self.traced_grids_of_planes_from_grid(
grid=sparse_image_plane_grids_of_planes[plane_index]
)
traced_sparse_grids_of_planes.append(traced_sparse_grids[plane_index])
return traced_sparse_grids_of_planes
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 sparse_image_plane_grids_of_planes_from_grid(
self, grid, pixelization_setting=pix.SettingsPixelization()):
sparse_image_plane_grids_of_planes = []
for plane in self.planes:
sparse_image_plane_grid = plane.sparse_image_plane_grid_from_grid(
grid=grid, settings_pixelization=pixelization_setting)
sparse_image_plane_grids_of_planes.append(sparse_image_plane_grid)
return sparse_image_plane_grids_of_planes
def sparse_image_plane_grid_from_grid(
self, grid, settings_pixelization=pix.SettingsPixelization()):
if not self.has_pixelization:
return None
hyper_galaxy_image = self.hyper_galaxy_image_of_galaxy_with_pixelization
return self.pixelization.sparse_grid_from_grid(
grid=grid,
hyper_image=hyper_galaxy_image,
settings=settings_pixelization)
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 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_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,
)
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,
)
