def test__settings_with_is_stochastic_true(self):
settings = aa.SettingsPixelization(is_stochastic=False)
settings = settings.settings_with_is_stochastic_true()
assert settings.is_stochastic is True
settings = aa.SettingsPixelization(is_stochastic=True)
settings = settings.settings_with_is_stochastic_true()
assert settings.is_stochastic is True
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 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 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 mapper_galaxy_dict_from(
self,
grid: aa.type.Grid2DLike,
settings_pixelization=aa.SettingsPixelization(),
preloads=Preloads(),
) -> Dict[aa.AbstractMapper, ag.Galaxy]:
mapper_galaxy_dict = {}
if preloads.traced_grids_of_planes_for_inversion is None:
traced_grids_of_planes_list = self.traced_grid_2d_list_of_inversion_from(
grid=grid)
else:
traced_grids_of_planes_list = preloads.traced_grids_of_planes_for_inversion
if preloads.traced_sparse_grids_list_of_planes is None:
traced_sparse_grids_list_of_planes, sparse_image_plane_grid_list = self.traced_sparse_grid_pg_list_from(
grid=grid,
settings_pixelization=settings_pixelization,
preloads=preloads,
)
else:
traced_sparse_grids_list_of_planes = (
preloads.traced_sparse_grids_list_of_planes)
sparse_image_plane_grid_list = preloads.sparse_image_plane_grid_list
for (plane_index, plane) in enumerate(self.planes):
if plane.has_pixelization:
galaxies_with_pixelization_list = plane.galaxies_with_pixelization
for mapper_index in range(
len(traced_sparse_grids_list_of_planes[plane_index])):
mapper = plane.to_inversion.mapper_from(
source_grid_slim=traced_grids_of_planes_list[
plane_index],
source_pixelization_grid=
traced_sparse_grids_list_of_planes[plane_index]
[mapper_index],
data_pixelization_grid=sparse_image_plane_grid_list[
plane_index][mapper_index],
pixelization=self.pixelization_pg_list[plane_index]
[mapper_index],
hyper_galaxy_image=self.
hyper_galaxy_image_pg_list[plane_index][mapper_index],
settings_pixelization=settings_pixelization,
preloads=preloads,
)
galaxy = galaxies_with_pixelization_list[mapper_index]
mapper_galaxy_dict[mapper] = galaxy
return mapper_galaxy_dict
def test__interferometer(self):
visibilities_mask = np.full(fill_value=False, shape=(7, ))
real_space_mask = aa.Mask2D.unmasked(shape_native=(7, 7),
pixel_scales=0.1,
sub_size=1)
grid = aa.Grid2D.from_mask(mask=real_space_mask)
pix = aa.pix.VoronoiMagnification(shape=(7, 7))
sparse_grid = pix.sparse_grid_from_grid(grid=grid)
mapper = pix.mapper_from_grid_and_sparse_grid(
grid=grid,
sparse_grid=sparse_grid,
settings=aa.SettingsPixelization(use_border=False),
)
reg = aa.reg.Constant(coefficient=0.0)
visibilities = aa.Visibilities.manual_slim(visibilities=[
1.0 + 0.0j,
1.0 + 0.0j,
1.0 + 0.0j,
1.0 + 0.0j,
1.0 + 0.0j,
1.0 + 0.0j,
1.0 + 0.0j,
])
noise_map = aa.VisibilitiesNoiseMap.ones(shape_slim=(7, ))
uv_wavelengths = np.ones(shape=(7, 2))
interferometer = aa.Interferometer(
visibilities=visibilities,
noise_map=noise_map,
uv_wavelengths=uv_wavelengths,
real_space_mask=real_space_mask,
)
inversion = aa.Inversion(
dataset=interferometer,
mapper=mapper,
regularization=reg,
settings=aa.SettingsInversion(check_solution=False),
)
assert inversion.mapped_reconstructed_visibilities == pytest.approx(
1.0 + 0.0j * np.ones(shape=(7, )), 1.0e-4)
assert (np.imag(inversion.mapped_reconstructed_visibilities) <
0.0001).all()
assert (np.imag(inversion.mapped_reconstructed_visibilities) >
0.0).all()
def test__interferometer_linear_operator(self):
real_space_mask = aa.Mask2D.unmasked(shape_native=(7, 7),
pixel_scales=0.1,
sub_size=1)
grid = aa.Grid2D.from_mask(mask=real_space_mask)
pix = aa.pix.Rectangular(shape=(7, 7))
mapper = pix.mapper_from_grid_and_sparse_grid(
grid=grid,
sparse_grid=None,
settings=aa.SettingsPixelization(use_border=False),
)
reg = aa.reg.Constant(coefficient=0.0)
visibilities = aa.Visibilities.manual_slim(visibilities=[
1.0 + 0.0j,
1.0 + 0.0j,
1.0 + 0.0j,
1.0 + 0.0j,
1.0 + 0.0j,
1.0 + 0.0j,
1.0 + 0.0j,
])
noise_map = aa.VisibilitiesNoiseMap.ones(shape_slim=(7, ))
uv_wavelengths = np.ones(shape=(7, 2))
interferometer = aa.Interferometer(
visibilities=visibilities,
noise_map=noise_map,
uv_wavelengths=uv_wavelengths,
real_space_mask=real_space_mask,
settings=aa.SettingsInterferometer(
transformer_class=aa.TransformerNUFFT),
)
inversion = aa.Inversion(
dataset=interferometer,
mapper=mapper,
regularization=reg,
settings=aa.SettingsInversion(use_linear_operators=True,
check_solution=False),
)
assert inversion.mapped_reconstructed_visibilities == pytest.approx(
1.0 + 0.0j * np.ones(shape=(7, )), 1.0e-4)
assert (np.imag(inversion.mapped_reconstructed_visibilities) <
0.0001).all()
assert (np.imag(inversion.mapped_reconstructed_visibilities) >
0.0).all()
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 linear_obj_list_from(
self,
grid: aa.type.Grid2DLike,
settings_pixelization=aa.SettingsPixelization(),
preloads=Preloads(),
):
linear_obj_list = []
if preloads.traced_grids_of_planes_for_inversion is None:
traced_grids_of_planes = self.traced_grid_list_of_inversion_from(
grid=grid)
else:
traced_grids_of_planes = preloads.traced_grids_of_planes_for_inversion
if preloads.traced_sparse_grids_list_of_planes is None:
traced_sparse_grids_list_of_planes, sparse_image_plane_grid_list = self.traced_sparse_grid_pg_list_from(
grid=grid,
settings_pixelization=settings_pixelization,
preloads=preloads,
)
else:
traced_sparse_grids_list_of_planes = (
preloads.traced_sparse_grids_list_of_planes)
sparse_image_plane_grid_list = preloads.sparse_image_plane_grid_list
for (plane_index, plane) in enumerate(self.planes):
if plane.has_pixelization:
for mapper_index in range(
len(traced_sparse_grids_list_of_planes[plane_index])):
mapper = plane.mapper_from(
source_grid_slim=traced_grids_of_planes[plane_index],
source_pixelization_grid=
traced_sparse_grids_list_of_planes[plane_index]
[mapper_index],
data_pixelization_grid=sparse_image_plane_grid_list[
plane_index][mapper_index],
pixelization=self.pixelization_pg_list[plane_index]
[mapper_index],
hyper_galaxy_image=self.
hyper_galaxy_image_pg_list[plane_index][mapper_index],
settings_pixelization=settings_pixelization,
preloads=preloads,
)
linear_obj_list.append(mapper)
return linear_obj_list
def test__grid_is_relocated_via_border(self, sub_grid_2d_7x7):
pixelization = aa.pix.VoronoiMagnification(shape=(3, 3))
mask = aa.Mask2D.circular(
shape_native=(60, 60),
radius=1.0,
pixel_scales=(0.1, 0.1),
centre=(1.0, 1.0),
sub_size=1,
)
grid = aa.Grid2D.from_mask(mask=mask)
sparse_grid = pixelization.sparse_grid_from_grid(grid=grid)
grid[8, 0] = 100.0
mapper = pixelization.mapper_from_grid_and_sparse_grid(
grid=grid,
sparse_grid=sparse_grid,
settings=aa.SettingsPixelization(use_border=True),
)
assert grid[8, 0] != mapper.source_grid_slim[8, 0]
assert mapper.source_grid_slim[8, 0] < 5.0
grid[0, 0] = 0.0
sparse_grid[0, 0] = 100.0
mapper = pixelization.mapper_from_grid_and_sparse_grid(
grid=grid,
sparse_grid=sparse_grid,
settings=aa.SettingsPixelization(use_border=True),
)
assert sparse_grid[0, 0] != mapper.source_pixelization_grid[0, 0]
assert mapper.source_pixelization_grid[0, 0] < 5.0
def sparse_image_plane_grid_list_from(
self,
grid: aa.type.Grid2DLike,
settings_pixelization=aa.SettingsPixelization()
) -> Optional[List[aa.type.Grid2DLike]]:
if not self.has_pixelization:
return None
return [
pixelization.data_pixelization_grid_from(
data_grid_slim=grid,
hyper_image=hyper_galaxy_image,
settings=settings_pixelization,
) for pixelization, hyper_galaxy_image in zip(
self.pixelization_list,
self.hyper_galaxies_with_pixelization_image_list)
]
def traced_sparse_grid_pg_list_from(
self,
grid: aa.type.Grid2DLike,
settings_pixelization=aa.SettingsPixelization(),
preloads=Preloads(),
) -> Tuple[List[List], List[List]]:
"""
Ray-trace the sparse image plane grid used to define the source-pixel centres by calculating the deflection
angles at (y,x) coordinate on the grid from the galaxy mass profiles and then ray-trace them from the
image-plane to the source plane.
"""
if (preloads.sparse_image_plane_grid_pg_list is None
or settings_pixelization.is_stochastic):
sparse_image_plane_grid_pg_list = self.sparse_image_plane_grid_pg_list_from(
grid=grid, settings_pixelization=settings_pixelization)
else:
sparse_image_plane_grid_pg_list = preloads.sparse_image_plane_grid_pg_list
traced_sparse_grid_pg_list = []
for (plane_index, plane) in enumerate(self.planes):
if sparse_image_plane_grid_pg_list[plane_index] is None:
traced_sparse_grid_pg_list.append(None)
else:
traced_sparse_grids_list = []
for sparse_image_plane_grid in sparse_image_plane_grid_pg_list[
plane_index]:
try:
traced_sparse_grids_list.append(
self.traced_grid_list_from(
grid=sparse_image_plane_grid)[plane_index])
except AttributeError:
traced_sparse_grids_list.append(None)
traced_sparse_grid_pg_list.append(traced_sparse_grids_list)
return traced_sparse_grid_pg_list, sparse_image_plane_grid_pg_list
def sparse_image_plane_grid_pg_list_from(
self,
grid: aa.type.Grid2DLike,
settings_pixelization=aa.SettingsPixelization()
) -> List[List]:
"""
Specific pixelizations, like the `VoronoiMagnification`, begin by determining what will become its the
source-pixel centres by calculating them in the image-plane. The `VoronoiBrightnessImage` pixelization
performs a KMeans clustering.
"""
sparse_image_plane_grid_list_of_planes = []
for plane in self.planes:
sparse_image_plane_grid_list = plane.sparse_image_plane_grid_list_from(
grid=grid, settings_pixelization=settings_pixelization)
sparse_image_plane_grid_list_of_planes.append(
sparse_image_plane_grid_list)
return sparse_image_plane_grid_list_of_planes
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 __init__(
self,
dataset,
tracer,
hyper_background_noise=None,
use_hyper_scaling=True,
settings_pixelization=aa.SettingsPixelization(),
settings_inversion=aa.SettingsInversion(),
preloads=Preloads(),
profiling_dict: Optional[Dict] = None,
):
""" 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 : Tracer
The tracer, which describes the ray-tracing and strong lens configuration.
"""
self.tracer = tracer
self.hyper_background_noise = hyper_background_noise
self.use_hyper_scaling = use_hyper_scaling
self.settings_pixelization = settings_pixelization
self.settings_inversion = settings_inversion
self.preloads = preloads
self.profiling_dict = profiling_dict
if use_hyper_scaling:
if hyper_background_noise is not None:
noise_map = hyper_background_noise.hyper_noise_map_complex_from(
noise_map=dataset.noise_map)
else:
noise_map = dataset.noise_map
else:
noise_map = dataset.noise_map
self.tracer = tracer
self.profile_visibilities = self.tracer.visibilities_via_transformer_from(
grid=dataset.grid, transformer=dataset.transformer)
self.profile_subtracted_visibilities = (dataset.visibilities -
self.profile_visibilities)
if not tracer.has_pixelization:
inversion = None
model_visibilities = self.profile_visibilities
else:
inversion = tracer.inversion_interferometer_from(
grid=dataset.grid_inversion,
visibilities=self.profile_subtracted_visibilities,
noise_map=noise_map,
transformer=dataset.transformer,
settings_pixelization=settings_pixelization,
settings_inversion=settings_inversion,
preloads=preloads,
)
model_visibilities = (self.profile_visibilities +
inversion.mapped_reconstructed_data)
fit = aa.FitDataComplex(
data=dataset.visibilities,
noise_map=noise_map,
model_data=model_visibilities,
inversion=inversion,
use_mask_in_fit=False,
profiling_dict=profiling_dict,
)
super().__init__(dataset=dataset,
fit=fit,
profiling_dict=profiling_dict)
def test__15_grid__no_sub_grid(self):
mask = aa.Mask2D.manual(
mask=[
[True, True, True, True, True, True, True],
[True, True, True, True, True, True, True],
[True, False, False, False, False, False, True],
[True, False, False, False, False, False, True],
[True, False, False, False, False, False, True],
[True, True, True, True, True, True, True],
[True, True, True, True, True, True, True],
],
pixel_scales=1.0,
sub_size=1,
)
# There is no sub-grid, so our grid are just the masked_image grid (note the NumPy weighted_data structure
# ensures this has no sub-gridding)
grid = aa.Grid2D.manual_mask(
grid=[
[0.9, -0.9],
[1.0, -1.0],
[1.1, -1.1],
[0.9, 0.9],
[1.0, 1.0],
[1.1, 1.1],
[-0.01, 0.01],
[0.0, 0.0],
[0.01, 0.01],
[-0.9, -0.9],
[-1.0, -1.0],
[-1.1, -1.1],
[-0.9, 0.9],
[-1.0, 1.0],
[-1.1, 1.1],
],
mask=mask,
)
pix = aa.pix.Rectangular(shape=(3, 3))
mapper = pix.mapper_from_grid_and_sparse_grid(
grid=grid,
sparse_grid=None,
settings=aa.SettingsPixelization(use_border=False),
)
assert mapper.data_pixelization_grid == None
assert mapper.source_pixelization_grid.shape_native_scaled == pytest.approx(
(2.2, 2.2), 1.0e-4)
assert mapper.source_pixelization_grid.origin == pytest.approx(
(0.0, 0.0), 1.0e-4)
assert (mapper.mapping_matrix == np.array([
[1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0],
[1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0],
[1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0],
[0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0],
[0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0],
[0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0],
[0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0],
[0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0],
[0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0],
[0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0],
[0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0],
[0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0],
[0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0],
[0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0],
[0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0],
])).all()
assert mapper.shape_native == (3, 3)
reg = aa.reg.Constant(coefficient=1.0)
regularization_matrix = reg.regularization_matrix_from_mapper(
mapper=mapper)
assert (regularization_matrix == np.array([
[2.00000001, -1.0, 0.0, -1.0, 0.0, 0.0, 0.0, 0.0, 0.0],
[-1.0, 3.00000001, -1.0, 0.0, -1.0, 0.0, 0.0, 0.0, 0.0],
[0.0, -1.0, 2.00000001, 0.0, 0.0, -1.0, 0.0, 0.0, 0.0],
[-1.0, 0.0, 0.0, 3.00000001, -1.0, 0.0, -1.0, 0.0, 0.0],
[0.0, -1.0, 0.0, -1.0, 4.00000001, -1.0, 0.0, -1.0, 0.0],
[0.0, 0.0, -1.0, 0.0, -1.0, 3.00000001, 0.0, 0.0, -1.0],
[0.0, 0.0, 0.0, -1.0, 0.0, 0.0, 2.00000001, -1.0, 0.0],
[0.0, 0.0, 0.0, 0.0, -1.0, 0.0, -1.0, 3.00000001, -1.0],
[0.0, 0.0, 0.0, 0.0, 0.0, -1.0, 0.0, -1.0, 2.00000001],
])).all()
image = aa.Array2D.ones(shape_native=(7, 7), pixel_scales=1.0)
noise_map = aa.Array2D.ones(shape_native=(7, 7), pixel_scales=1.0)
psf = aa.Kernel2D.no_blur(pixel_scales=1.0)
imaging = aa.Imaging(image=image, noise_map=noise_map, psf=psf)
masked_imaging = imaging.apply_mask(mask=mask)
inversion = aa.Inversion(
dataset=masked_imaging,
mapper=mapper,
regularization=reg,
settings=aa.SettingsInversion(check_solution=False),
)
assert (
inversion.blurred_mapping_matrix == mapper.mapping_matrix).all()
assert (inversion.regularization_matrix == regularization_matrix).all()
assert inversion.mapped_reconstructed_image == pytest.approx(
np.ones(15), 1.0e-4)
def test__3x3_simple_grid__include_mask_with_offset_centre(self):
mask = aa.Mask2D.manual(
mask=[
[True, True, True, True, True, True, True],
[True, True, True, True, False, True, True],
[True, True, True, False, False, False, True],
[True, True, True, True, False, True, True],
[True, True, True, True, True, True, True],
[True, True, True, True, True, True, True],
[True, True, True, True, True, True, True],
],
pixel_scales=1.0,
sub_size=1,
)
grid = np.array([[2.0, 1.0], [1.0, 0.0], [1.0, 1.0], [1.0, 2.0],
[0.0, 1.0]])
grid = aa.Grid2D.manual_mask(grid=grid, mask=mask)
pix = aa.pix.VoronoiMagnification(shape=(3, 3))
sparse_grid = aa.Grid2DSparse.from_grid_and_unmasked_2d_grid_shape(
grid=grid, unmasked_sparse_shape=pix.shape)
mapper = pix.mapper_from_grid_and_sparse_grid(
grid=grid,
sparse_grid=sparse_grid,
settings=aa.SettingsPixelization(use_border=False),
)
assert mapper.source_pixelization_grid.shape_native_scaled == pytest.approx(
(2.0, 2.0), 1.0e-4)
assert (mapper.source_pixelization_grid == sparse_grid).all()
# assert mapper.pixelization_grid.origin == pytest.approx((1.0, 1.0), 1.0e-4)
assert isinstance(mapper, mappers.MapperVoronoi)
assert (mapper.mapping_matrix == np.array([
[1.0, 0.0, 0.0, 0.0, 0.0],
[0.0, 1.0, 0.0, 0.0, 0.0],
[0.0, 0.0, 1.0, 0.0, 0.0],
[0.0, 0.0, 0.0, 1.0, 0.0],
[0.0, 0.0, 0.0, 0.0, 1.0],
])).all()
reg = aa.reg.Constant(coefficient=1.0)
regularization_matrix = reg.regularization_matrix_from_mapper(
mapper=mapper)
assert (regularization_matrix == np.array([
[3.00000001, -1.0, -1.0, -1.0, 0.0],
[-1.0, 3.00000001, -1.0, 0.0, -1.0],
[-1.0, -1.0, 4.00000001, -1.0, -1.0],
[-1.0, 0.0, -1.0, 3.00000001, -1.0],
[0.0, -1.0, -1.0, -1.0, 3.00000001],
])).all()
image = aa.Array2D.ones(shape_native=(7, 7), pixel_scales=1.0)
noise_map = aa.Array2D.ones(shape_native=(7, 7), pixel_scales=1.0)
psf = aa.Kernel2D.no_blur(pixel_scales=1.0)
imaging = aa.Imaging(image=image, noise_map=noise_map, psf=psf)
masked_imaging = imaging.apply_mask(mask=mask)
inversion = aa.Inversion(
dataset=masked_imaging,
mapper=mapper,
regularization=reg,
settings=aa.SettingsInversion(check_solution=False),
)
assert (
inversion.blurred_mapping_matrix == mapper.mapping_matrix).all()
assert (inversion.regularization_matrix == regularization_matrix).all()
assert inversion.mapped_reconstructed_image == pytest.approx(
np.ones(5), 1.0e-4)
def __init__(
self,
dataset: aa.Imaging,
plane: Plane,
hyper_image_sky=None,
hyper_background_noise=None,
use_hyper_scalings: bool = True,
settings_pixelization: aa.SettingsPixelization = aa.SettingsPixelization(),
settings_inversion: aa.SettingsInversion = aa.SettingsInversion(),
):
""" An lens fitter, which contains the plane's used to perform the fit and functions to manipulate \
the lens dataset's hyper_galaxies.
Parameters
-----------
plane
The plane of galaxies whose model images are used to fit the imaging data.
"""
self.plane = plane
if use_hyper_scalings:
image = hyper_image_from(
image=dataset.image, hyper_image_sky=hyper_image_sky
)
noise_map = hyper_noise_map_from(
noise_map=dataset.noise_map,
plane=plane,
hyper_background_noise=hyper_background_noise,
)
else:
image = dataset.image
noise_map = dataset.noise_map
self.blurred_image = self.plane.blurred_image_2d_via_convolver_from(
grid=dataset.grid,
convolver=dataset.convolver,
blurring_grid=dataset.blurring_grid,
)
self.profile_subtracted_image = image - self.blurred_image
if not plane.has_pixelization:
inversion = None
model_image = self.blurred_image
else:
inversion = plane.inversion_imaging_from(
grid=dataset.grid_inversion,
image=self.profile_subtracted_image,
noise_map=noise_map,
convolver=dataset.convolver,
w_tilde=dataset.w_tilde,
settings_pixelization=settings_pixelization,
settings_inversion=settings_inversion,
)
model_image = self.blurred_image + inversion.mapped_reconstructed_image
fit = aa.FitData(
data=image,
noise_map=noise_map,
model_data=model_image,
mask=dataset.mask,
inversion=inversion,
use_mask_in_fit=False,
)
super().__init__(dataset=dataset, fit=fit)
def test__5_simple_grid__include_sub_grid(self):
mask = aa.Mask2D.manual(
mask=[
[True, True, True, True, True, True, True],
[True, True, True, True, True, True, True],
[True, True, True, False, True, True, True],
[True, True, False, False, False, True, True],
[True, True, True, False, True, True, True],
[True, True, True, True, True, True, True],
[True, True, True, True, True, True, True],
],
pixel_scales=2.0,
sub_size=2,
)
# Assume a 2x2 sub-grid, so each of our 5 masked_image-pixels are split into 4.
# The grid below is unphysical in that the (0.0, 0.0) terms on the end of each sub-grid probably couldn't
# happen for a real lens calculation. This is to make a mapping_matrix matrix which explicitly tests the
# sub-grid.
grid = aa.Grid2D.manual_mask(
grid=[
[1.0, -1.0],
[1.0, -1.0],
[1.0, -1.0],
[1.0, 1.0],
[1.0, 1.0],
[1.0, 1.0],
[-1.0, -1.0],
[-1.0, -1.0],
[-1.0, -1.0],
[-1.0, 1.0],
[-1.0, 1.0],
[-1.0, 1.0],
[0.0, 0.0],
[0.0, 0.0],
[0.0, 0.0],
[0.0, 0.0],
[0.0, 0.0],
[0.0, 0.0],
[0.0, 0.0],
[0.0, 0.0],
],
mask=mask,
)
pix = aa.pix.Rectangular(shape=(3, 3))
mapper = pix.mapper_from_grid_and_sparse_grid(
grid=grid,
sparse_grid=None,
settings=aa.SettingsPixelization(use_border=False),
)
assert mapper.data_pixelization_grid == None
assert mapper.source_pixelization_grid.shape_native_scaled == pytest.approx(
(2.0, 2.0), 1.0e-4)
assert mapper.source_pixelization_grid.origin == pytest.approx(
(0.0, 0.0), 1.0e-4)
assert (mapper.mapping_matrix == np.array([
[0.75, 0.0, 0.25, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0],
[0.0, 0.0, 0.5, 0.0, 0.0, 0.0, 0.5, 0.0, 0.0],
[0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.25, 0.0, 0.75],
[0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0],
[0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0],
])).all()
assert mapper.shape_native == (3, 3)
reg = aa.reg.Constant(coefficient=1.0)
regularization_matrix = reg.regularization_matrix_from_mapper(
mapper=mapper)
assert (regularization_matrix == np.array([
[2.00000001, -1.0, 0.0, -1.0, 0.0, 0.0, 0.0, 0.0, 0.0],
[-1.0, 3.00000001, -1.0, 0.0, -1.0, 0.0, 0.0, 0.0, 0.0],
[0.0, -1.0, 2.00000001, 0.0, 0.0, -1.0, 0.0, 0.0, 0.0],
[-1.0, 0.0, 0.0, 3.00000001, -1.0, 0.0, -1.0, 0.0, 0.0],
[0.0, -1.0, 0.0, -1.0, 4.00000001, -1.0, 0.0, -1.0, 0.0],
[0.0, 0.0, -1.0, 0.0, -1.0, 3.00000001, 0.0, 0.0, -1.0],
[0.0, 0.0, 0.0, -1.0, 0.0, 0.0, 2.00000001, -1.0, 0.0],
[0.0, 0.0, 0.0, 0.0, -1.0, 0.0, -1.0, 3.00000001, -1.0],
[0.0, 0.0, 0.0, 0.0, 0.0, -1.0, 0.0, -1.0, 2.00000001],
])).all()
image = aa.Array2D.ones(shape_native=(7, 7), pixel_scales=1.0)
noise_map = aa.Array2D.ones(shape_native=(7, 7), pixel_scales=1.0)
psf = aa.Kernel2D.no_blur(pixel_scales=1.0)
imaging = aa.Imaging(image=image, noise_map=noise_map, psf=psf)
masked_imaging = imaging.apply_mask(mask=mask)
inversion = aa.Inversion(
dataset=masked_imaging,
mapper=mapper,
regularization=reg,
settings=aa.SettingsInversion(check_solution=False),
)
assert (
inversion.blurred_mapping_matrix == mapper.mapping_matrix).all()
assert (inversion.regularization_matrix == regularization_matrix).all()
assert inversion.mapped_reconstructed_image == pytest.approx(
np.ones(5), 1.0e-4)
def __init__(
self,
dataset,
tracer,
hyper_image_sky=None,
hyper_background_noise=None,
use_hyper_scaling=True,
settings_pixelization=aa.SettingsPixelization(),
settings_inversion=aa.SettingsInversion(),
preloads=Preloads(),
profiling_dict: Optional[Dict] = None,
):
"""
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 : Tracer
The tracer, which describes the ray-tracing and strong lens configuration.
"""
self.tracer = tracer
self.hyper_image_sky = hyper_image_sky
self.hyper_background_noise = hyper_background_noise
self.use_hyper_scaling = use_hyper_scaling
self.settings_pixelization = settings_pixelization
self.settings_inversion = settings_inversion
self.preloads = preloads
self.profiling_dict = profiling_dict
if use_hyper_scaling:
image = hyper_image_from(image=dataset.image,
hyper_image_sky=hyper_image_sky)
noise_map = hyper_noise_map_from(
noise_map=dataset.noise_map,
tracer=tracer,
hyper_background_noise=hyper_background_noise,
)
else:
image = dataset.image
noise_map = dataset.noise_map
if preloads.blurred_image is None:
self.blurred_image = self.tracer.blurred_image_2d_via_convolver_from(
grid=dataset.grid,
convolver=dataset.convolver,
blurring_grid=dataset.blurring_grid,
)
else:
self.blurred_image = preloads.blurred_image
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=dataset.grid_inversion,
image=self.profile_subtracted_image,
noise_map=noise_map,
convolver=dataset.convolver,
w_tilde=dataset.w_tilde,
settings_pixelization=settings_pixelization,
settings_inversion=settings_inversion,
preloads=preloads,
)
model_image = self.blurred_image + inversion.mapped_reconstructed_image
fit = aa.FitData(
data=image,
noise_map=noise_map,
model_data=model_image,
mask=dataset.mask,
inversion=inversion,
use_mask_in_fit=False,
profiling_dict=profiling_dict,
)
super().__init__(dataset=dataset,
fit=fit,
profiling_dict=profiling_dict)
