def inversion_interferometer_from(
self,
grid,
visibilities,
noise_map,
transformer,
settings_pixelization=aa.SettingsPixelization(),
settings_inversion=aa.SettingsInversion(),
preloads=aa.Preloads(),
):
linear_obj_list = self.linear_obj_list_from(
grid=grid,
settings_pixelization=settings_pixelization,
preloads=preloads)
return inversion_interferometer_unpacked_from(
visibilities=visibilities,
noise_map=noise_map,
transformer=transformer,
linear_obj_list=linear_obj_list,
regularization_list=self.regularization_list,
settings=settings_inversion,
profiling_dict=self.profiling_dict,
)
def inversion_imaging_from(
self,
grid,
image,
noise_map,
convolver,
w_tilde,
settings_pixelization=aa.SettingsPixelization(),
settings_inversion=aa.SettingsInversion(),
preloads=aa.Preloads(),
):
linear_obj_list = self.linear_obj_list_from(
grid=grid,
settings_pixelization=settings_pixelization,
preloads=preloads)
return inversion_imaging_unpacked_from(
image=image,
noise_map=noise_map,
convolver=convolver,
w_tilde=w_tilde,
linear_obj_list=linear_obj_list,
regularization_list=self.regularization_list,
settings=settings_inversion,
profiling_dict=self.profiling_dict,
)
def linear_obj_list_from(
self,
grid,
settings_pixelization=aa.SettingsPixelization(),
preloads=aa.Preloads(),
):
if not self.has_pixelization:
return None
sparse_grid_list = self.sparse_image_plane_grid_list_from(grid=grid)
linear_obj_list = []
pixelization_list = self.pixelization_list
hyper_galaxy_image_list = self.hyper_galaxies_with_pixelization_image_list
for mapper_index in range(len(sparse_grid_list)):
mapper = self.mapper_from(
source_grid_slim=grid,
source_pixelization_grid=sparse_grid_list,
pixelization=pixelization_list[mapper_index],
hyper_galaxy_image=hyper_galaxy_image_list[mapper_index],
data_pixelization_grid=sparse_grid_list[mapper_index],
settings_pixelization=settings_pixelization,
preloads=preloads,
)
linear_obj_list.append(mapper)
return linear_obj_list
def __init__(
self,
dataset: Union[aa.Imaging, aa.Interferometer],
hyper_dataset_result: ResultDataset = None,
cosmology=cosmo.Planck15,
settings_pixelization: aa.SettingsPixelization = None,
settings_inversion: aa.SettingsInversion = None,
):
"""
Abstract Analysis class for all model-fits which fit galaxies (or objects containing galaxies like a plane)
to a dataset, like imaging or interferometer data.
This class stores the settings used to perform the model-fit for certain components of the model (e.g. a
pixelization or inversion), the Cosmology used for the analysis and hyper datasets used for certain model
classes.
Parameters
----------
dataset
The dataset that is the model is fitted too.
hyper_dataset_result
The hyper-model image and hyper galaxies images of a previous result in a model-fitting pipeline, which are
used by certain classes for adapting the analysis to the properties of the dataset.
cosmology
The Cosmology assumed for this analysis.
settings_pixelization
settings controlling how a pixelization is fitted during the model-fit, for example if a border is used
when creating the pixelization.
settings_inversion
Settings controlling how an inversion is fitted during the model-fit, for example which linear algebra
formalism is used.
"""
super().__init__(cosmology=cosmology)
self.dataset = dataset
self.hyper_dataset_result = hyper_dataset_result
if self.hyper_dataset_result is not None:
if hyper_dataset_result.search is not None:
hyper_dataset_result.search.paths = None
self.set_hyper_dataset(result=self.hyper_dataset_result)
else:
self.hyper_galaxy_image_path_dict = None
self.hyper_model_image = None
self.settings_pixelization = settings_pixelization or aa.SettingsPixelization()
self.settings_inversion = settings_inversion or aa.SettingsInversion()
self.preloads = aa.Preloads()
def mapper_from(
self,
source_grid_slim,
source_pixelization_grid,
pixelization,
hyper_galaxy_image,
data_pixelization_grid=None,
settings_pixelization=aa.SettingsPixelization(),
preloads=aa.Preloads(),
):
return pixelization.mapper_from(
source_grid_slim=source_grid_slim,
source_pixelization_grid=source_pixelization_grid,
data_pixelization_grid=data_pixelization_grid,
hyper_image=hyper_galaxy_image,
settings=settings_pixelization,
preloads=preloads,
profiling_dict=self.profiling_dict,
)
def test__preloads(self):
matrix_shape = (9, 3)
mask = aa.Mask2D.manual(
mask=np.array(
[[True, True, True], [False, False, False], [True, True, True]]
),
pixel_scales=1.0,
sub_size=1,
)
grid = aa.Grid2D.from_mask(mask=mask)
blurred_mapping_matrix = 2.0 * np.ones(matrix_shape)
curvature_matrix = 18.0 * np.ones((matrix_shape[1], matrix_shape[1]))
curvature_matrix_sparse_preload, curvature_matrix_preload_counts = aa.util.inversion.curvature_matrix_sparse_preload_via_mapping_matrix_from(
mapping_matrix=blurred_mapping_matrix
)
inversion = inversions.InversionImagingMatrix.from_data_mapper_and_regularization(
image=np.ones(9),
noise_map=np.ones(9),
convolver=mock.MockConvolver(matrix_shape),
mapper=mock.MockMapper(matrix_shape=matrix_shape, source_grid_slim=grid),
regularization=mock.MockRegularization(matrix_shape),
settings=aa.SettingsInversion(check_solution=False),
preloads=aa.Preloads(
blurred_mapping_matrix=blurred_mapping_matrix,
curvature_matrix_sparse_preload=curvature_matrix_sparse_preload,
curvature_matrix_preload_counts=curvature_matrix_preload_counts,
),
)
assert (inversion.blurred_mapping_matrix == blurred_mapping_matrix).all()