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 __init__(
self,
masked_interferometer,
settings,
cosmology,
results=None,
preloads=pload.Preloads(),
):
super(Analysis, self).__init__(
masked_dataset=masked_interferometer,
settings=settings,
cosmology=cosmology,
results=results,
preloads=preloads,
)
result = ag_analysis.last_result_with_use_as_hyper_dataset(
results=results)
if result is not None:
self.hyper_galaxy_visibilities_path_dict = (
result.hyper_galaxy_visibilities_path_dict)
self.hyper_model_visibilities = result.hyper_model_visibilities
else:
self.hyper_galaxy_visibilities_path_dict = None
self.hyper_model_visibilities = None
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 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 __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 preload_inversion_with_fixed_profiles(
result: af.Result, model: Optional[af.Collection] = None
) -> pload.Preloads:
"""
If the `MassProfile`'s in a model are all fixed parameters, and the parameters of the source `Pixelization` are
also fixed, the mapping of image-pixels to the source-pixels does not change for every likelihood evaluations.
Matrices used by the linear algebra calculation in an `Inversion` can therefore be preloaded.
This function inspects the `Result` and `Model` and returns a `Preload` object with the correct quantities for p
reloading. It raises an error if the `Model` is not suited to the preloading.
The preload is typically used when the lens light is being fitted, and a fixed mass model and source pixelization
and regularization are being used. This occurs in the LIGHT PIPELINE of the SLaM pipelines.
Parameters
----------
result
The result containing the linear algebra matrices which are to be preloaded (corresponding to the maximum
likelihood model of the model-fit).
model
The model, which is inspected to make sure the model-fit can have its `Inversion` quantities preloaded.
Returns
-------
Grid2D
The `Preloads` object containing the `Inversion` linear algebra matrices.
"""
if model is not None:
# if model.has_model(cls=mp.MassProfile):
# raise exc.PreloadException(
# "Cannot preload inversion when the mass profile is a model"
# )
if model_util.pixelization_is_model_from(model=model):
raise exc.PreloadException(
"Cannot preload inversion when the model includes a pixelization"
)
preloads = preload_pixelization_grid_from(result=result, model=model)
inversion = result.max_log_likelihood_fit.inversion
return pload.Preloads(
sparse_grids_of_planes=preloads.sparse_grids_of_planes,
blurred_mapping_matrix=inversion.blurred_mapping_matrix,
curvature_matrix_sparse_preload=inversion.curvature_matrix_sparse_preload,
curvature_matrix_preload_counts=inversion.curvature_matrix_preload_counts,
mapper=inversion.mapper,
)
def __init__(
self,
masked_imaging,
settings,
cosmology,
results=None,
preloads=pload.Preloads(),
):
super().__init__(
masked_dataset=masked_imaging,
settings=settings,
cosmology=cosmology,
results=results,
preloads=preloads,
)
def setup_preloads(self, results):
# Preload the source-plane grid of coordinates if the source parameters are fixed, skipping the KMeans.
sparse_grids_of_planes = None
blurred_mapping_matrix = None
curvature_matrix = None
mapper = None
if (not self.is_hyper_phase and results.last is not None
and self.pixelization is not None
and not self.pixelization_is_model):
if self.pixelization.__class__ is results.last.pixelization.__class__:
if hasattr(results.last, "hyper"):
sparse_grids_of_planes = (
results.last.hyper.
max_log_likelihood_pixelization_grids_of_planes)
else:
sparse_grids_of_planes = (
results.last.
max_log_likelihood_pixelization_grids_of_planes)
# Preload the blurred_mapping_matrix and curvature matrix calculation if only the parametric light profiles
# are being fitted.
if self.preload_inversion and not self.is_hyper_phase:
if hasattr(results.last, "hyper"):
inversion = results.last.hyper.max_log_likelihood_fit.inversion
else:
inversion = results.last.max_log_likelihood_fit.inversion
if inversion is not None:
blurred_mapping_matrix = inversion.blurred_mapping_matrix
curvature_matrix = inversion.curvature_matrix
mapper = inversion.mapper
return pload.Preloads(
sparse_grids_of_planes=sparse_grids_of_planes,
mapper=mapper,
blurred_mapping_matrix=blurred_mapping_matrix,
curvature_matrix=curvature_matrix,
)
def preload_pixelization_grid_from(
result: af.Result, model: Optional[af.Collection] = None
) -> pload.Preloads:
"""
If a model contains a `Pixelization` that is an `instance` whose parameters are fixed and the `Result` contains
the grid of this pixelization corresponding to these parameters, the grid can be preloaded to avoid repeating
calculations which recompute the pixelization grid every iteration of the log likelihood function.
This function inspects the `Result` and `Model` and returns a `Preloads` object with the appropriate pixelization
grid for preloading. It raises an error if the `Model` is not suited to the preloading.
Parameters
----------
result
The result containing the pixelization grid which is to be preloaded (corresponding to the maximum likelihood
model of the model-fit).
model
The model, which is inspected to make sure the model-fit can have its pixelization preloaded.
Returns
-------
Preloads
The `Preloads` object containing the (y,x) grid of coordinates representing the source plane pixelization
centres.
"""
if model is not None:
if model_util.pixelization_from(model=model) is None:
raise exc.PreloadException(
"Cannot preload pixelization when the model does not include a pixelization"
)
if model_util.pixelization_is_model_from(model=model):
raise exc.PreloadException(
"Cannot preload pixelization when the model include a pixelization but it is a model"
"component (preloading its grid will nullify changing its parameters)"
)
return pload.Preloads(
sparse_grids_of_planes=result.max_log_likelihood_pixelization_grids_of_planes
)
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 make_analysis(self,
dataset,
mask,
results=None,
preloads=pload.Preloads()):
"""
Returns an lens object. Also calls the prior passing and masked_interferometer modifying functions to allow child
classes to change the behaviour of the phase.
Parameters
----------
positions
mask: Mask2D
The default masks passed in by the pipeline
dataset: im.Interferometer
An masked_interferometer that has been masked
results: autofit.tools.pipeline.ResultsCollection
The result from the previous phase
Returns
-------
lens : Analysis
An lens object that the `NonLinearSearch` calls to determine the fit of a set of values
"""
masked_interferometer = interferometer.MaskedInterferometer(
interferometer=dataset,
visibilities_mask=mask,
real_space_mask=self.real_space_mask,
settings=self.settings.settings_masked_interferometer,
)
self.output_phase_info()
return self.Analysis(
masked_interferometer=masked_interferometer,
settings=self.settings,
cosmology=self.cosmology,
results=results,
preloads=preloads,
)
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(),
preloads=pload.Preloads(),
):
""" 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,
preloads=preloads,
)
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 from_data_mapper_and_regularization(
cls,
image: array_2d.Array2D,
noise_map: array_2d.Array2D,
convolver: conv.Convolver,
mapper: typing.Union[mappers.MapperRectangular, mappers.MapperVoronoi],
regularization: reg.Regularization,
settings=SettingsInversion(),
preloads=pload.Preloads(),
):
if preloads.blurred_mapping_matrix is None:
blurred_mapping_matrix = convolver.convolve_mapping_matrix(
mapping_matrix=mapper.mapping_matrix
)
else:
blurred_mapping_matrix = preloads.blurred_mapping_matrix
data_vector = inversion_util.data_vector_via_blurred_mapping_matrix_from(
blurred_mapping_matrix=blurred_mapping_matrix,
image=image,
noise_map=noise_map,
)
if preloads.curvature_matrix_sparse_preload is None:
curvature_matrix = inversion_util.curvature_matrix_via_mapping_matrix_from(
mapping_matrix=blurred_mapping_matrix, noise_map=noise_map
)
else:
curvature_matrix = inversion_util.curvature_matrix_via_sparse_preload_from(
mapping_matrix=blurred_mapping_matrix,
noise_map=noise_map,
curvature_matrix_sparse_preload=preloads.curvature_matrix_sparse_preload.astype(
"int"
),
curvature_matrix_preload_counts=preloads.curvature_matrix_preload_counts.astype(
"int"
),
)
regularization_matrix = regularization.regularization_matrix_from_mapper(
mapper=mapper
)
curvature_reg_matrix = np.add(curvature_matrix, regularization_matrix)
try:
values = np.linalg.solve(curvature_reg_matrix, data_vector)
except np.linalg.LinAlgError:
raise exc.InversionException()
if settings.check_solution:
if np.isclose(a=values[0], b=values[1], atol=1e-4).all():
if np.isclose(a=values[0], b=values, atol=1e-4).all():
raise exc.InversionException()
return InversionImagingMatrix(
image=image,
noise_map=noise_map,
convolver=convolver,
mapper=mapper,
regularization=regularization,
blurred_mapping_matrix=blurred_mapping_matrix,
curvature_matrix=curvature_matrix,
regularization_matrix=regularization_matrix,
curvature_reg_matrix=curvature_reg_matrix,
reconstruction=values,
settings=settings,
)
def __init__(
self,
masked_interferometer,
tracer,
hyper_background_noise=None,
use_hyper_scaling=True,
settings_pixelization=pix.SettingsPixelization(),
settings_inversion=inv.SettingsInversion(),
preloads=pload.Preloads(),
):
""" 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,
preloads=preloads,
)
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,
)
