def test__noise_map__with_and_without_hyper_galaxy(masked_imaging_7x7_no_blur):
g0 = ag.Galaxy(redshift=0.5,
light_profile=MockLightProfile(image_2d_value=1.0))
plane = ag.Plane(galaxies=[g0])
fit = ag.FitImaging(dataset=masked_imaging_7x7_no_blur, plane=plane)
assert fit.noise_map.slim == pytest.approx(
np.full(fill_value=2.0, shape=(9, )), 1.0e-1)
hyper_image = ag.Array2D.ones(shape_native=(3, 3), pixel_scales=1.0)
g0 = ag.Galaxy(
redshift=0.5,
light_profile=MockLightProfile(image_2d_value=1.0),
hyper_galaxy=ag.HyperGalaxy(contribution_factor=1.0,
noise_factor=1.0,
noise_power=1.0),
hyper_model_image=hyper_image,
hyper_galaxy_image=hyper_image,
hyper_minimum_value=0.0,
)
plane = ag.Plane(galaxies=[g0])
fit = ag.FitImaging(dataset=masked_imaging_7x7_no_blur, plane=plane)
assert fit.noise_map.slim == pytest.approx(
np.full(fill_value=4.0, shape=(9, )), 1.0e-1)
assert fit.log_likelihood == pytest.approx(-20.7470, 1.0e-4)
def test__subtracted_images_of_galaxies(masked_imaging_7x7_no_blur):
g0 = ag.Galaxy(redshift=0.5,
light_profile=MockLightProfile(image_2d=np.ones(1)))
g1 = ag.Galaxy(redshift=1.0,
light_profile=MockLightProfile(image_2d=2.0 * np.ones(1)))
g2 = ag.Galaxy(redshift=1.0,
light_profile=MockLightProfile(image_2d=3.0 * np.ones(1)))
plane = ag.Plane(redshift=0.75, galaxies=[g0, g1, g2])
fit = ag.FitImaging(dataset=masked_imaging_7x7_no_blur, plane=plane)
assert fit.subtracted_images_of_galaxies[0].slim[0] == -4.0
assert fit.subtracted_images_of_galaxies[1].slim[0] == -3.0
assert fit.subtracted_images_of_galaxies[2].slim[0] == -2.0
g0 = ag.Galaxy(redshift=0.5,
light_profile=MockLightProfile(image_2d=np.ones(1)))
g1 = ag.Galaxy(redshift=0.5)
g2 = ag.Galaxy(redshift=1.0,
light_profile=MockLightProfile(image_2d=3.0 * np.ones(1)))
plane = ag.Plane(redshift=0.75, galaxies=[g0, g1, g2])
fit = ag.FitImaging(dataset=masked_imaging_7x7_no_blur, plane=plane)
assert fit.subtracted_images_of_galaxies[0].slim[0] == -2.0
assert fit.subtracted_images_of_galaxies[1].slim[0] == -3.0
assert fit.subtracted_images_of_galaxies[2].slim[0] == 0.0
def test__fit_figure_of_merit(masked_imaging_7x7):
g0 = ag.Galaxy(
redshift=0.5,
light_profile=ag.lp.EllSersic(intensity=1.0),
mass_profile=ag.mp.SphIsothermal(einstein_radius=1.0),
)
g1 = ag.Galaxy(redshift=1.0, light_profile=ag.lp.EllSersic(intensity=1.0))
plane = ag.Plane(redshift=0.75, galaxies=[g0, g1])
fit = ag.FitImaging(dataset=masked_imaging_7x7, plane=plane)
assert (fit.image == np.full(fill_value=1.0, shape=(9, ))).all()
assert (fit.noise_map == np.full(fill_value=2.0, shape=(9, ))).all()
assert fit.log_likelihood == pytest.approx(-75938.05, 1e-4)
assert fit.figure_of_merit == pytest.approx(-75938.05, 1.0e-4)
pix = ag.pix.Rectangular(shape=(3, 3))
reg = ag.reg.Constant(coefficient=1.0)
g0 = ag.Galaxy(redshift=0.5, pixelization=pix, regularization=reg)
plane = ag.Plane(galaxies=[ag.Galaxy(redshift=0.5), g0])
fit = ag.FitImaging(dataset=masked_imaging_7x7, plane=plane)
assert (fit.image == np.full(fill_value=1.0, shape=(9, ))).all()
assert (fit.noise_map == np.full(fill_value=2.0, shape=(9, ))).all()
assert fit.log_evidence == pytest.approx(-22.9005, 1e-4)
assert fit.figure_of_merit == pytest.approx(-22.9005, 1.0e-4)
galaxy_light = ag.Galaxy(redshift=0.5,
light_profile=ag.lp.EllSersic(intensity=1.0))
pix = ag.pix.Rectangular(shape=(3, 3))
reg = ag.reg.Constant(coefficient=1.0)
galaxy_pix = ag.Galaxy(redshift=1.0, pixelization=pix, regularization=reg)
plane = ag.Plane(redshift=0.75, galaxies=[galaxy_light, galaxy_pix])
fit = ag.FitImaging(dataset=masked_imaging_7x7, plane=plane)
assert (fit.image == np.full(fill_value=1.0, shape=(9, ))).all()
assert (fit.noise_map == np.full(fill_value=2.0, shape=(9, ))).all()
assert fit.log_evidence == pytest.approx(-6840.5851, 1e-4)
assert fit.figure_of_merit == pytest.approx(-6840.5851, 1.0e-4)
def test__fit_figure_of_merit(interferometer_7):
g0 = ag.Galaxy(
redshift=0.5,
light_profile=ag.lp.EllSersic(intensity=1.0),
mass_profile=ag.mp.SphIsothermal(einstein_radius=1.0),
)
g1 = ag.Galaxy(redshift=1.0, light_profile=ag.lp.EllSersic(intensity=1.0))
plane = ag.Plane(redshift=0.75, galaxies=[g0, g1])
fit = ag.FitInterferometer(dataset=interferometer_7, plane=plane)
assert (fit.noise_map.slim == np.full(fill_value=2.0 + 2.0j,
shape=(7, ))).all()
assert fit.log_likelihood == pytest.approx(-2398107.3849, 1e-4)
assert fit.figure_of_merit == pytest.approx(-2398107.3849, 1.0e-4)
pix = ag.pix.Rectangular(shape=(3, 3))
reg = ag.reg.Constant(coefficient=0.01)
g0 = ag.Galaxy(redshift=0.5, pixelization=pix, regularization=reg)
plane = ag.Plane(galaxies=[ag.Galaxy(redshift=0.5), g0])
fit = ag.FitInterferometer(dataset=interferometer_7, plane=plane)
assert (fit.noise_map.slim == np.full(fill_value=2.0 + 2.0j,
shape=(7, ))).all()
assert fit.log_evidence == pytest.approx(-66.90612, 1e-4)
assert fit.figure_of_merit == pytest.approx(-66.90612, 1.0e-4)
galaxy_light = ag.Galaxy(redshift=0.5,
light_profile=ag.lp.EllSersic(intensity=1.0))
pix = ag.pix.Rectangular(shape=(3, 3))
reg = ag.reg.Constant(coefficient=1.0)
galaxy_pix = ag.Galaxy(redshift=1.0, pixelization=pix, regularization=reg)
plane = ag.Plane(redshift=0.75, galaxies=[galaxy_light, galaxy_pix])
fit = ag.FitInterferometer(dataset=interferometer_7, plane=plane)
assert (fit.noise_map.slim == np.full(fill_value=2.0 + 2.0j,
shape=(7, ))).all()
assert fit.log_evidence == pytest.approx(-283424.48941, 1e-4)
assert fit.figure_of_merit == pytest.approx(-283424.48941, 1.0e-4)
def test__via_plane_from__same_as_plane_image(self):
psf = ag.Kernel2D.from_gaussian(
shape_native=(7, 7), sigma=0.5, pixel_scales=0.05
)
grid = ag.Grid2D.uniform(shape_native=(20, 20), pixel_scales=0.05, sub_size=1)
galaxy_0 = ag.Galaxy(redshift=0.5, light=ag.lp.EllSersic(intensity=1.0))
galaxy_1 = ag.Galaxy(redshift=1.0, light=ag.lp.EllSersic(intensity=0.3))
plane = ag.Plane(redshift=0.75, galaxies=[galaxy_0, galaxy_1])
simulator = ag.SimulatorImaging(
psf=psf,
exposure_time=10000.0,
background_sky_level=100.0,
add_poisson_noise=False,
)
imaging = simulator.via_plane_from(plane=plane, grid=grid)
imaging_via_image = simulator.via_image_from(
image=plane.image_2d_from(grid=grid)
)
assert imaging.shape_native == (20, 20)
assert imaging.image.native[0, 0] != imaging_via_image.image.native[0, 0]
assert imaging.image.native[10, 10] == imaging_via_image.image.native[10, 10]
assert (imaging.psf == imaging_via_image.psf).all()
assert (imaging.noise_map == imaging_via_image.noise_map).all()
def test__max_log_likelihood_plane_available_as_result(
self, analysis_imaging_7x7):
galaxy_0 = ag.Galaxy(redshift=0.5,
light=ag.lp.EllSersic(intensity=1.0))
galaxy_1 = ag.Galaxy(redshift=0.5,
light=ag.lp.EllSersic(intensity=2.0))
model = af.Collection(
galaxies=af.Collection(galaxy_0=galaxy_0, galaxy_1=galaxy_1))
max_log_likelihood_plane = ag.Plane(galaxies=[galaxy_0, galaxy_1])
search = MockSearch(
name="test_search",
samples=MockSamples(
max_log_likelihood_instance=max_log_likelihood_plane),
)
result = search.fit(model=model, analysis=analysis_imaging_7x7)
assert isinstance(result.max_log_likelihood_plane, ag.Plane)
assert result.max_log_likelihood_plane.galaxies[
0].light.intensity == 1.0
assert result.max_log_likelihood_plane.galaxies[
1].light.intensity == 2.0
def test___all_fit_quantities__hyper_background_noise(self, interferometer_7):
hyper_background_noise = ag.hyper_data.HyperBackgroundNoise(noise_scale=1.0)
hyper_noise_map = hyper_background_noise.hyper_noise_map_from_complex_noise_map(
noise_map=interferometer_7.noise_map
)
galaxy_light = ag.Galaxy(
redshift=0.5, light_profile=ag.lp.EllSersic(intensity=1.0)
)
pix = ag.pix.Rectangular(shape=(3, 3))
reg = ag.reg.Constant(coefficient=1.0)
galaxy_pix = ag.Galaxy(redshift=1.0, pixelization=pix, regularization=reg)
plane = ag.Plane(redshift=0.75, galaxies=[galaxy_light, galaxy_pix])
fit = ag.FitInterferometer(
interferometer=interferometer_7,
plane=plane,
hyper_background_noise=hyper_background_noise,
)
assert hyper_noise_map.slim == pytest.approx(fit.inversion.noise_map, 1.0e-4)
assert hyper_noise_map.slim == pytest.approx(fit.noise_map.slim)
def test__galaxy_blurred_image_2d_dict_via_convolver_from(
sub_grid_2d_7x7, blurring_grid_2d_7x7, convolver_7x7):
g0 = ag.Galaxy(redshift=0.5, light_profile=ag.lp.EllSersic(intensity=1.0))
g1 = ag.Galaxy(
redshift=0.5,
mass_profile=ag.mp.SphIsothermal(einstein_radius=1.0),
light_profile=ag.lp.EllSersic(intensity=2.0),
)
g2 = ag.Galaxy(redshift=0.5, light_profile=ag.lp.EllSersic(intensity=3.0))
plane = ag.Plane(redshift=-0.75, galaxies=[g1, g0, g2])
blurred_image_2d_list = plane.blurred_image_2d_list_via_convolver_from(
grid=sub_grid_2d_7x7,
convolver=convolver_7x7,
blurring_grid=blurring_grid_2d_7x7,
)
blurred_image_dict = plane.galaxy_blurred_image_2d_dict_via_convolver_from(
grid=sub_grid_2d_7x7,
convolver=convolver_7x7,
blurring_grid=blurring_grid_2d_7x7,
)
assert (blurred_image_dict[g0].slim == blurred_image_2d_list[1].slim).all()
assert (blurred_image_dict[g1].slim == blurred_image_2d_list[0].slim).all()
assert (blurred_image_dict[g2].slim == blurred_image_2d_list[2].slim).all()
def test___fit_galaxy_model_image_dict__images_and_inversion_mapped_reconstructed_image(
self, interferometer_7
):
pix = ag.pix.Rectangular(shape=(3, 3))
reg = ag.reg.Constant(coefficient=1.0)
g0 = ag.Galaxy(redshift=0.5)
g1 = ag.Galaxy(redshift=1.0, pixelization=pix, regularization=reg)
plane = ag.Plane(redshift=0.75, galaxies=[g0, g1])
fit = ag.FitInterferometer(interferometer=interferometer_7, plane=plane)
mapper = pix.mapper_from_grid_and_sparse_grid(
grid=interferometer_7.grid, sparse_grid=None
)
inversion = inversions.InversionInterferometerMatrix.from_data_mapper_and_regularization(
mapper=mapper,
regularization=reg,
visibilities=interferometer_7.visibilities,
noise_map=interferometer_7.noise_map,
transformer=interferometer_7.transformer,
)
assert (fit.galaxy_model_image_dict[g0].native == np.zeros((7, 7))).all()
assert fit.galaxy_model_image_dict[g1].slim == pytest.approx(
inversion.mapped_reconstructed_image.slim, 1.0e-4
)
def test___all_fit_quantities__hyper_background_noise(self, interferometer_7):
hyper_background_noise = ag.hyper_data.HyperBackgroundNoise(noise_scale=1.0)
hyper_noise_map = hyper_background_noise.hyper_noise_map_from_complex_noise_map(
noise_map=interferometer_7.noise_map
)
g0 = ag.Galaxy(
redshift=0.5,
light_profile=ag.lp.EllSersic(intensity=1.0),
mass_profile=ag.mp.SphIsothermal(einstein_radius=1.0),
)
g1 = ag.Galaxy(redshift=1.0, light_profile=ag.lp.EllSersic(intensity=1.0))
plane = ag.Plane(redshift=0.75, galaxies=[g0, g1])
fit = ag.FitInterferometer(
interferometer=interferometer_7,
plane=plane,
hyper_background_noise=hyper_background_noise,
)
assert hyper_noise_map.slim == pytest.approx(fit.noise_map.slim)
fit = ag.FitInterferometer(
interferometer=interferometer_7,
plane=plane,
hyper_background_noise=hyper_background_noise,
use_hyper_scalings=False,
)
assert fit.noise_map == pytest.approx(interferometer_7.noise_map, 1.0e-4)
assert fit.noise_map != pytest.approx(hyper_noise_map.slim, 1.0e-4)
def test___fit_galaxy_visibilities_dict__corresponds_to_galaxy_visibilities(
self, interferometer_7
):
g0 = ag.Galaxy(
redshift=0.5,
light_profile=ag.lp.EllSersic(intensity=1.0),
mass_profile=ag.mp.SphIsothermal(einstein_radius=1.0),
)
g1 = ag.Galaxy(redshift=1.0, light_profile=ag.lp.EllSersic(intensity=1.0))
plane = ag.Plane(redshift=0.75, galaxies=[g0, g1])
fit = ag.FitInterferometer(interferometer=interferometer_7, plane=plane)
g0_profile_visibilities = g0.profile_visibilities_from_grid_and_transformer(
grid=interferometer_7.grid, transformer=interferometer_7.transformer
)
g1_profile_visibilities = g1.profile_visibilities_from_grid_and_transformer(
grid=interferometer_7.grid, transformer=interferometer_7.transformer
)
assert fit.galaxy_model_visibilities_dict[g0].slim == pytest.approx(
g0_profile_visibilities, 1.0e-4
)
assert fit.galaxy_model_visibilities_dict[g1].slim == pytest.approx(
g1_profile_visibilities, 1.0e-4
)
assert fit.model_visibilities.slim == pytest.approx(
fit.galaxy_model_visibilities_dict[g0].slim
+ fit.galaxy_model_visibilities_dict[g1].slim,
1.0e-4,
)
def test__from_plane__same_as_plane_input(self):
grid = ag.Grid2D.uniform(shape_native=(20, 20), pixel_scales=0.05, sub_size=1)
galaxy_0 = ag.Galaxy(
redshift=0.5,
light=ag.lp.EllSersic(intensity=1.0),
mass=ag.mp.EllIsothermal(einstein_radius=1.6),
)
galaxy_1 = ag.Galaxy(redshift=1.0, light=ag.lp.EllSersic(intensity=0.3))
plane = ag.Plane(redshift=0.75, galaxies=[galaxy_0, galaxy_1])
simulator = ag.SimulatorInterferometer(
uv_wavelengths=np.ones(shape=(7, 2)),
exposure_time=10000.0,
noise_sigma=0.1,
noise_seed=1,
)
interferometer = simulator.via_plane_from(plane=plane, grid=grid)
interferometer_via_image = simulator.via_image_from(
image=plane.image_2d_from(grid=grid)
)
assert (
interferometer.visibilities == interferometer_via_image.visibilities
).all()
assert (
interferometer.uv_wavelengths == interferometer_via_image.uv_wavelengths
).all()
assert (interferometer.noise_map == interferometer_via_image.noise_map).all()
def plane_via_database_from(fit: Fit):
"""
Returns a `Plane` object from an aggregator's `SearchOutput` class, which we call an 'agg_obj' to describe that
it acts as the aggregator object for one result in the `Aggregator`. This uses the aggregator's generator outputs
such that the function can use the `Aggregator`'s map function to to create a `Plane` generator.
The `Plane` is created following the same method as the PyAutoGalaxy `Search` classes using an instance of the
maximum log likelihood model's galaxies. These galaxies have their hyper-images added (if they were used in the
fit) and passed into a Plane object.
Parameters
----------
fit : af.SearchOutput
A PyAutoFit aggregator's SearchOutput object containing the generators of the results of PyAutoGalaxy model-fits.
"""
galaxies = fit.instance.galaxies
hyper_model_image = fit.value(name="hyper_model_image")
hyper_galaxy_image_path_dict = fit.value(name="hyper_galaxy_image_path_dict")
if hyper_galaxy_image_path_dict is not None:
for (galaxy_path, galaxy) in fit.instance.path_instance_tuples_for_class(
ag.Galaxy
):
if galaxy_path in hyper_galaxy_image_path_dict:
galaxy.hyper_model_image = hyper_model_image
galaxy.hyper_galaxy_image = hyper_galaxy_image_path_dict[galaxy_path]
return ag.Plane(galaxies=galaxies)
def make_plane_x2_galaxy_inversion_7x7():
source_gal_inversion = ag.Galaxy(
redshift=1.0,
pixelization=ag.pix.Rectangular(),
regularization=ag.reg.Constant(),
)
return ag.Plane(galaxies=[make_gal_x1_lp(), source_gal_inversion])
def make_samples():
galaxy_0 = ag.Galaxy(redshift=0.5,
light=ag.lp.EllSersic(centre=(0.0, 1.0)))
galaxy_1 = ag.Galaxy(redshift=1.0, light=ag.lp.EllSersic())
plane = ag.Plane(galaxies=[galaxy_0, galaxy_1])
return mock.MockSamples(max_log_likelihood_instance=plane)
def make_samples_with_result():
galaxies = [
ag.Galaxy(redshift=0.5, light=ag.lp.EllSersic(intensity=1.0)),
ag.Galaxy(redshift=1.0, light=ag.lp.EllSersic(intensity=2.0)),
]
plane = ag.Plane(galaxies=galaxies)
return MockSamples(max_log_likelihood_instance=plane)
def test__uses_hyper_fit_correctly(self, masked_imaging_7x7):
galaxies = af.ModelInstance()
galaxies.galaxy = ag.Galaxy(redshift=0.5,
light=ag.lp.EllSersic(intensity=1.0),
mass=ag.mp.SphIsothermal)
galaxies.source = ag.Galaxy(redshift=1.0, light=ag.lp.EllSersic())
instance = af.ModelInstance()
instance.galaxies = galaxies
galaxy_hyper_image = ag.Array2D.ones(shape_native=(3, 3),
pixel_scales=0.1)
galaxy_hyper_image[4] = 10.0
hyper_model_image = ag.Array2D.full(fill_value=0.5,
shape_native=(3, 3),
pixel_scales=0.1)
hyper_galaxy_image_path_dict = {
("galaxies", "galaxy"): galaxy_hyper_image
}
result = mock.MockResult(
hyper_galaxy_image_path_dict=hyper_galaxy_image_path_dict,
hyper_model_image=hyper_model_image,
)
analysis = ag.AnalysisImaging(dataset=masked_imaging_7x7,
hyper_dataset_result=result)
hyper_galaxy = ag.HyperGalaxy(contribution_factor=1.0,
noise_factor=1.0,
noise_power=1.0)
instance.galaxies.galaxy.hyper_galaxy = hyper_galaxy
fit_likelihood = analysis.log_likelihood_function(instance=instance)
g0 = ag.Galaxy(
redshift=0.5,
light_profile=instance.galaxies.galaxy.light,
mass_profile=instance.galaxies.galaxy.mass,
hyper_galaxy=hyper_galaxy,
hyper_model_image=hyper_model_image,
hyper_galaxy_image=galaxy_hyper_image,
hyper_minimum_value=0.0,
)
g1 = ag.Galaxy(redshift=1.0,
light_profile=instance.galaxies.source.light)
plane = ag.Plane(galaxies=[g0, g1])
fit = ag.FitImaging(dataset=masked_imaging_7x7, plane=plane)
assert (fit.plane.galaxies[0].hyper_galaxy_image == galaxy_hyper_image
).all()
assert fit_likelihood == fit.log_likelihood
def test___all_fit_quantities__no_hyper_methods(self, interferometer_7):
g0 = ag.Galaxy(
redshift=0.5,
light_profile=ag.lp.EllSersic(intensity=1.0),
mass_profile=ag.mp.SphIsothermal(einstein_radius=1.0),
)
g1 = ag.Galaxy(redshift=1.0, light_profile=ag.lp.EllSersic(intensity=1.0))
plane = ag.Plane(redshift=0.75, galaxies=[g0, g1])
fit = ag.FitInterferometer(interferometer=interferometer_7, plane=plane)
assert interferometer_7.noise_map == pytest.approx(fit.noise_map)
model_visibilities = plane.profile_visibilities_from_grid_and_transformer(
grid=interferometer_7.grid, transformer=interferometer_7.transformer
)
assert model_visibilities == pytest.approx(fit.model_visibilities, 1e-4)
residual_map = ag.util.fit.residual_map_from(
data=interferometer_7.visibilities, model_data=model_visibilities
)
assert residual_map == pytest.approx(fit.residual_map, 1e-4)
normalized_residual_map = ag.util.fit.normalized_residual_map_complex_from(
residual_map=residual_map, noise_map=interferometer_7.noise_map
)
assert normalized_residual_map == pytest.approx(
fit.normalized_residual_map, 1e-4
)
chi_squared_map = ag.util.fit.chi_squared_map_complex_from(
residual_map=residual_map, noise_map=interferometer_7.noise_map
)
assert chi_squared_map == pytest.approx(fit.chi_squared_map, 1e-4)
chi_squared = ag.util.fit.chi_squared_complex_from(
chi_squared_map=fit.chi_squared_map
)
noise_normalization = ag.util.fit.noise_normalization_complex_from(
noise_map=interferometer_7.noise_map
)
log_likelihood = ag.util.fit.log_likelihood_from(
chi_squared=chi_squared, noise_normalization=noise_normalization
)
assert log_likelihood == pytest.approx(fit.log_likelihood, 1e-4)
assert log_likelihood == fit.figure_of_merit
def test__model_visibilities(interferometer_7):
g0 = ag.Galaxy(redshift=0.5,
light_profile=MockLightProfile(image_2d=np.ones(2)))
plane = ag.Plane(galaxies=[g0])
fit = ag.FitInterferometer(dataset=interferometer_7, plane=plane)
assert fit.model_visibilities.slim[0] == pytest.approx(
np.array([1.2933 + 0.2829j]), 1.0e-4)
assert fit.log_likelihood == pytest.approx(-27.06284, 1.0e-4)
def test___fit_galaxy_model_visibilities_dict__has_image_and_inversion_mapped_reconstructed_image(
self, interferometer_7
):
g0 = ag.Galaxy(redshift=0.5, light_profile=ag.lp.EllSersic(intensity=1.0))
g1 = ag.Galaxy(redshift=0.5, light_profile=ag.lp.EllSersic(intensity=2.0))
pix = ag.pix.Rectangular(shape=(3, 3))
reg = ag.reg.Constant(coefficient=1.0)
galaxy_pix = ag.Galaxy(redshift=1.0, pixelization=pix, regularization=reg)
plane = ag.Plane(redshift=0.75, galaxies=[g0, g1, galaxy_pix])
fit = ag.FitInterferometer(interferometer=interferometer_7, plane=plane)
g0_visibilities = g0.profile_visibilities_from_grid_and_transformer(
grid=interferometer_7.grid, transformer=interferometer_7.transformer
)
g1_visibilities = g1.profile_visibilities_from_grid_and_transformer(
grid=interferometer_7.grid, transformer=interferometer_7.transformer
)
profile_visibilities = g0_visibilities + g1_visibilities
profile_subtracted_visibilities = (
interferometer_7.visibilities - profile_visibilities
)
mapper = pix.mapper_from_grid_and_sparse_grid(
grid=interferometer_7.grid,
settings=ag.SettingsPixelization(use_border=False),
)
inversion = inversions.InversionInterferometerMatrix.from_data_mapper_and_regularization(
visibilities=profile_subtracted_visibilities,
noise_map=interferometer_7.noise_map,
transformer=interferometer_7.transformer,
mapper=mapper,
regularization=reg,
)
g0_image = g0.image_2d_from_grid(grid=interferometer_7.grid)
g1_image = g1.image_2d_from_grid(grid=interferometer_7.grid)
assert fit.galaxy_model_image_dict[g0].slim == pytest.approx(
g0_image.slim, 1.0e-4
)
assert fit.galaxy_model_image_dict[g1].slim == pytest.approx(
g1_image.slim, 1.0e-4
)
assert fit.galaxy_model_image_dict[galaxy_pix].slim == pytest.approx(
inversion.mapped_reconstructed_image.slim, 1.0e-4
)
def test__results_include_pixelization__available_as_property(
self, analysis_imaging_7x7
):
source = ag.Galaxy(
redshift=1.0,
pixelization=ag.pix.VoronoiMagnification(shape=(2, 3)),
regularization=ag.reg.Constant(),
)
max_log_likelihood_plane = ag.Plane(galaxies=[source])
samples = mock.MockSamples(max_log_likelihood_instance=max_log_likelihood_plane)
result = res.ResultDataset(
samples=samples, analysis=analysis_imaging_7x7, model=None, search=None
)
assert isinstance(result.pixelization, ag.pix.VoronoiMagnification)
assert result.pixelization.shape == (2, 3)
source = ag.Galaxy(
redshift=1.0,
pixelization=ag.pix.VoronoiBrightnessImage(pixels=6),
regularization=ag.reg.Constant(),
)
source.hyper_galaxy_image = np.ones(9)
max_log_likelihood_plane = ag.Plane(galaxies=[source])
samples = mock.MockSamples(max_log_likelihood_instance=max_log_likelihood_plane)
result = res.ResultDataset(
samples=samples, analysis=analysis_imaging_7x7, model=None, search=None
)
assert isinstance(result.pixelization, ag.pix.VoronoiBrightnessImage)
assert result.pixelization.pixels == 6
def test__simulate_interferometer_from_galaxy__source_galaxy__compare_to_interferometer(
self,
):
galaxy_0 = ag.Galaxy(
redshift=0.5,
mass=ag.mp.EllIsothermal(
centre=(0.0, 0.0), einstein_radius=1.6, elliptical_comps=(0.17647, 0.0)
),
)
galaxy_1 = ag.Galaxy(
redshift=0.5,
light=ag.lp.EllSersic(
centre=(0.1, 0.1),
elliptical_comps=(0.096225, -0.055555),
intensity=0.3,
effective_radius=1.0,
sersic_index=2.5,
),
)
grid = ag.Grid2D.uniform(shape_native=(11, 11), pixel_scales=0.05, sub_size=1)
simulator = ag.SimulatorInterferometer(
uv_wavelengths=np.ones(shape=(7, 2)),
exposure_time=10000.0,
noise_sigma=0.1,
noise_seed=1,
)
interferometer = simulator.via_galaxies_from(
galaxies=[galaxy_0, galaxy_1], grid=grid
)
plane = ag.Plane(galaxies=[galaxy_0, galaxy_1])
interferometer_via_image = simulator.via_image_from(
image=plane.image_2d_from(grid=grid)
)
assert interferometer.visibilities == pytest.approx(
interferometer_via_image.visibilities, 1.0e-4
)
assert (
interferometer.uv_wavelengths == interferometer_via_image.uv_wavelengths
).all()
assert (interferometer_via_image.noise_map == interferometer.noise_map).all()
def test__simulate_imaging_from_galaxy__source_galaxy__compare_to_imaging(
self):
galaxy_0 = ag.Galaxy(
redshift=0.5,
mass=ag.mp.EllIsothermal(centre=(0.0, 0.0),
einstein_radius=1.6,
elliptical_comps=(0.17647, 0.0)),
)
galaxy_1 = ag.Galaxy(
redshift=1.0,
light=ag.lp.EllSersic(
centre=(0.1, 0.1),
elliptical_comps=(0.096225, -0.055555),
intensity=0.3,
effective_radius=1.0,
sersic_index=2.5,
),
)
grid = ag.Grid2D.uniform(shape_native=(11, 11),
pixel_scales=0.2,
sub_size=1)
psf = ag.Kernel2D.no_blur(pixel_scales=0.2)
simulator = ag.SimulatorImaging(
psf=psf,
exposure_time=10000.0,
background_sky_level=100.0,
add_poisson_noise=True,
noise_seed=1,
)
imaging = simulator.from_galaxies_and_grid(
galaxies=[galaxy_0, galaxy_1], grid=grid)
plane = ag.Plane(redshift=0.75, galaxies=[galaxy_0, galaxy_1])
imaging_via_image = simulator.from_image(
image=plane.image_2d_from_grid(grid=grid))
assert imaging.shape_native == (11, 11)
assert (imaging.image == imaging_via_image.image).all()
assert (imaging.psf == imaging_via_image.psf).all()
assert (imaging.noise_map == imaging_via_image.noise_map).all()
def test__1x2_image__1x2_visibilities__simple_fourier_transform(self):
# The image plane image generated by the galaxy is [1.0, 1.0]
# Thus the chi squared is 4.0**2.0 + 3.0**2.0 = 25.0
real_space_mask = ag.Mask2D.manual(
mask=[
[True, True, True, True],
[True, False, False, True],
[True, True, True, True],
],
pixel_scales=1.0,
)
interferometer = ag.Interferometer(
visibilities=ag.Visibilities.full(fill_value=5.0, shape_slim=(1,)),
noise_map=ag.Visibilities.ones(shape_slim=(1,)),
uv_wavelengths=np.array([[0.0, 0.0]]),
real_space_mask=real_space_mask,
settings=ag.SettingsInterferometer(
grid_class=ag.Grid2D, sub_size=1, transformer_class=ag.TransformerDFT
),
)
interferometer.visibilities[0] = 5.0 + 4.0j
# Setup as a ray trace instance, using a light profile for the galaxy
g0 = ag.Galaxy(redshift=0.5, light_profile=MockLightProfile(value=1.0, size=2))
plane = ag.Plane(galaxies=[g0])
fit = ag.FitInterferometer(interferometer=interferometer, plane=plane)
assert (fit.visibilities.slim == np.array([5.0 + 4.0j])).all()
assert (fit.noise_map.slim == np.array([1.0 + 1.0j])).all()
assert (fit.model_visibilities.slim == np.array([2.0 + 0.0j])).all()
assert (fit.residual_map.slim == np.array([3.0 + 4.0j])).all()
assert (fit.normalized_residual_map.slim == np.array([3.0 + 4.0j])).all()
assert (fit.chi_squared_map.slim == np.array([9.0 + 16.0j])).all()
assert fit.chi_squared == 25.0
assert fit.noise_normalization == pytest.approx(
2.0 * np.log(2 * np.pi * 1.0 ** 2.0), 1.0e-4
)
assert fit.log_likelihood == pytest.approx(
-0.5 * (25.0 + 2.0 * np.log(2 * np.pi * 1.0 ** 2.0)), 1.0e-4
)
def test__y_x(dataset_quantity_7x7_vector_yx_2d):
model_object = MockMassProfile(deflections_yx_2d=ag.VectorYX2D.full(
fill_value=3.0, shape_native=(7, 7), pixel_scales=1.0))
plane = ag.Plane(galaxies=[ag.Galaxy(redshift=0.5, mass=model_object)])
fit_quantity = ag.FitQuantity(
dataset=dataset_quantity_7x7_vector_yx_2d,
light_mass_obj=plane,
func_str="deflections_yx_2d_from",
)
assert (fit_quantity.y.dataset.data ==
dataset_quantity_7x7_vector_yx_2d.y.data).all()
assert (fit_quantity.x.dataset.data ==
dataset_quantity_7x7_vector_yx_2d.x.data).all()
def make_samples(model):
galaxy_0 = ag.Galaxy(redshift=0.5, light=ag.lp.EllSersic(centre=(0.0, 1.0)))
galaxy_1 = ag.Galaxy(redshift=1.0, light=ag.lp.EllSersic())
plane = ag.Plane(galaxies=[galaxy_0, galaxy_1])
parameters = [model.prior_count * [0.0], model.prior_count * [10.0]]
sample_list = Sample.from_lists(
model=model,
parameter_lists=parameters,
log_likelihood_list=[1.0, 2.0],
log_prior_list=[0.0, 0.0],
weight_list=[0.0, 1.0],
)
return mock.MockSamples(
model=model, sample_list=sample_list, max_log_likelihood_instance=plane
)
def test___fit_figure_of_merit__linear_operator(interferometer_7_lop):
pix = ag.pix.Rectangular(shape=(3, 3))
reg = ag.reg.Constant(coefficient=0.01)
g0 = ag.Galaxy(redshift=0.5, pixelization=pix, regularization=reg)
plane = ag.Plane(galaxies=[ag.Galaxy(redshift=0.5), g0])
fit = ag.FitInterferometer(
dataset=interferometer_7_lop,
plane=plane,
settings_inversion=ag.SettingsInversion(use_linear_operators=True),
)
assert (fit.noise_map.slim == np.full(fill_value=2.0 + 2.0j,
shape=(7, ))).all()
assert fit.log_evidence == pytest.approx(-71.5177, 1e-4)
assert fit.figure_of_merit == pytest.approx(-71.5177, 1.0e-4)
def test__fit_via_mock_profile(dataset_quantity_7x7_array_2d,
dataset_quantity_7x7_vector_yx_2d):
model_object = MockMassProfile(
convergence_2d=ag.Array2D.ones(shape_native=(7, 7), pixel_scales=1.0),
potential_2d=ag.Array2D.full(fill_value=2.0,
shape_native=(7, 7),
pixel_scales=1.0),
deflections_yx_2d=ag.VectorYX2D.full(fill_value=3.0,
shape_native=(7, 7),
pixel_scales=1.0),
)
plane = ag.Plane(galaxies=[ag.Galaxy(redshift=0.5, mass=model_object)])
fit_quantity = ag.FitQuantity(
dataset=dataset_quantity_7x7_array_2d,
light_mass_obj=plane,
func_str="convergence_2d_from",
)
assert fit_quantity.chi_squared == pytest.approx(0.0, 1.0e-4)
assert fit_quantity.log_likelihood == pytest.approx(
-0.5 * 49.0 * np.log(2 * np.pi * 2.0**2.0), 1.0e-4)
fit_quantity = ag.FitQuantity(
dataset=dataset_quantity_7x7_array_2d,
light_mass_obj=plane,
func_str="potential_2d_from",
)
assert fit_quantity.chi_squared == pytest.approx(12.25, 1.0e-4)
assert fit_quantity.log_likelihood == pytest.approx(-85.1171999, 1.0e-4)
fit_quantity = ag.FitQuantity(
dataset=dataset_quantity_7x7_vector_yx_2d,
light_mass_obj=plane,
func_str="deflections_yx_2d_from",
)
assert fit_quantity.chi_squared == pytest.approx(98.0, 1.0e-4)
assert fit_quantity.log_likelihood == pytest.approx(-206.98438, 1.0e-4)
def test___fit_galaxy_model_image_dict__corresponds_to_profile_galaxy_images(
self, interferometer_7
):
g0 = ag.Galaxy(
redshift=0.5,
light_profile=ag.lp.EllSersic(intensity=1.0),
mass_profile=ag.mp.SphIsothermal(einstein_radius=1.0),
)
g1 = ag.Galaxy(redshift=1.0, light_profile=ag.lp.EllSersic(intensity=1.0))
plane = ag.Plane(redshift=0.75, galaxies=[g0, g1])
fit = ag.FitInterferometer(interferometer=interferometer_7, plane=plane)
g0_image = g0.image_2d_from_grid(grid=interferometer_7.grid)
g1_image = g1.image_2d_from_grid(grid=interferometer_7.grid)
assert fit.galaxy_model_image_dict[g0].slim == pytest.approx(g0_image, 1.0e-4)
assert fit.galaxy_model_image_dict[g1].slim == pytest.approx(g1_image, 1.0e-4)
def test__results_include_pixelization__available_as_property(
self, analysis_imaging_7x7):
source = ag.Galaxy(
redshift=1.0,
pixelization=MockPixelization(mapper=1),
regularization=MockRegularization(),
)
max_log_likelihood_plane = ag.Plane(galaxies=[source])
samples = MockSamples(
max_log_likelihood_instance=max_log_likelihood_plane)
result = res.ResultDataset(samples=samples,
analysis=analysis_imaging_7x7,
model=None,
search=None)
assert isinstance(result.pixelization_list[0], MockPixelization)
assert result.pixelization_list[0].mapper == 1
