def test__use_border__determines_if_border_pixel_relocation_is_used(
self, masked_imaging_7x7
):
model = af.Collection(
galaxies=af.Collection(
lens=al.Galaxy(
redshift=0.5, mass=al.mp.SphIsothermal(einstein_radius=100.0)
),
source=al.Galaxy(
redshift=1.0,
pixelization=al.pix.Rectangular(shape=(3, 3)),
regularization=al.reg.Constant(coefficient=1.0),
),
)
)
masked_imaging_7x7 = masked_imaging_7x7.apply_settings(
settings=al.SettingsImaging(sub_size_inversion=2)
)
analysis = al.AnalysisImaging(
dataset=masked_imaging_7x7,
settings_pixelization=al.SettingsPixelization(use_border=True),
)
analysis.dataset.grid_inversion[4] = np.array([[500.0, 0.0]])
instance = model.instance_from_unit_vector([])
tracer = analysis.tracer_for_instance(instance=instance)
fit = analysis.fit_imaging_for_tracer(
tracer=tracer, hyper_image_sky=None, hyper_background_noise=None
)
assert fit.inversion.linear_obj_list[0].source_grid_slim[4][0] == pytest.approx(
97.19584, 1.0e-2
)
assert fit.inversion.linear_obj_list[0].source_grid_slim[4][1] == pytest.approx(
-3.699999, 1.0e-2
)
analysis = al.AnalysisImaging(
dataset=masked_imaging_7x7,
settings_pixelization=al.SettingsPixelization(use_border=False),
)
analysis.dataset.grid_inversion[4] = np.array([300.0, 0.0])
instance = model.instance_from_unit_vector([])
tracer = analysis.tracer_for_instance(instance=instance)
fit = analysis.fit_imaging_for_tracer(
tracer=tracer, hyper_image_sky=None, hyper_background_noise=None
)
assert fit.inversion.linear_obj_list[0].source_grid_slim[4][0] == pytest.approx(
200.0, 1.0e-4
)
def test___stochastic_mode__gives_different_log_likelihood_list(
interferometer_7):
pix = al.pix.VoronoiBrightnessImage(pixels=5)
reg = al.reg.Constant(coefficient=1.0)
g0 = al.Galaxy(
redshift=0.5,
pixelization=pix,
regularization=reg,
hyper_model_image=al.Array2D.ones(shape_native=(3, 3),
pixel_scales=1.0),
hyper_galaxy_image=al.Array2D.ones(shape_native=(3, 3),
pixel_scales=1.0),
)
tracer = al.Tracer.from_galaxies(galaxies=[al.Galaxy(redshift=0.5), g0])
fit_0 = al.FitInterferometer(
dataset=interferometer_7,
tracer=tracer,
settings_pixelization=al.SettingsPixelization(is_stochastic=False),
settings_inversion=al.SettingsInversion(use_w_tilde=False),
)
fit_1 = al.FitInterferometer(
dataset=interferometer_7,
tracer=tracer,
settings_pixelization=al.SettingsPixelization(is_stochastic=False),
settings_inversion=al.SettingsInversion(use_w_tilde=False),
)
assert fit_0.log_evidence == fit_1.log_evidence
fit_0 = al.FitInterferometer(
dataset=interferometer_7,
tracer=tracer,
settings_pixelization=al.SettingsPixelization(is_stochastic=True),
settings_inversion=al.SettingsInversion(use_w_tilde=False),
)
fit_1 = al.FitInterferometer(
dataset=interferometer_7,
tracer=tracer,
settings_pixelization=al.SettingsPixelization(is_stochastic=True),
settings_inversion=al.SettingsInversion(use_w_tilde=False),
)
assert fit_0.log_evidence != fit_1.log_evidence
def test__inversion_interferometer_from(sub_grid_2d_7x7, interferometer_7):
interferometer_7.data = al.Visibilities.ones(shape_slim=(7, ))
g_linear = al.Galaxy(redshift=0.5, light_linear=al.lp_linear.EllSersic())
tracer = al.Tracer.from_galaxies(
galaxies=[al.Galaxy(redshift=0.5), g_linear])
tracer_to_inversion = al.TracerToInversion(tracer=tracer)
inversion = tracer_to_inversion.inversion_interferometer_from(
dataset=interferometer_7,
visibilities=interferometer_7.visibilities,
noise_map=interferometer_7.noise_map,
w_tilde=None,
settings_pixelization=al.SettingsPixelization(use_border=False),
settings_inversion=al.SettingsInversion(use_w_tilde=False),
)
assert inversion.reconstruction[0] == pytest.approx(0.000513447, 1.0e-5)
pix = al.pix.Rectangular(shape=(7, 7))
reg = al.reg.Constant(coefficient=0.0)
g0 = al.Galaxy(redshift=0.5, pixelization=pix, regularization=reg)
tracer = al.Tracer.from_galaxies(galaxies=[al.Galaxy(redshift=0.5), g0])
tracer_to_inversion = al.TracerToInversion(tracer=tracer)
inversion = tracer_to_inversion.inversion_interferometer_from(
dataset=interferometer_7,
visibilities=interferometer_7.visibilities,
noise_map=interferometer_7.noise_map,
w_tilde=None,
settings_pixelization=al.SettingsPixelization(use_border=False),
settings_inversion=al.SettingsInversion(use_w_tilde=False),
)
assert inversion.reconstruction[0] == pytest.approx(-0.2662, 1.0e-4)
def test__masked_imaging__settings_inputs_are_used_in_masked_imaging(
self, imaging_7x7, mask_7x7):
phase_imaging_7x7 = al.PhaseImaging(
settings=al.SettingsPhaseImaging(
settings_masked_imaging=al.SettingsMaskedImaging(
grid_class=al.Grid,
grid_inversion_class=al.Grid,
sub_size=3,
signal_to_noise_limit=1.0,
bin_up_factor=2,
psf_shape_2d=(3, 3),
),
settings_pixelization=al.SettingsPixelization(
use_border=False, is_stochastic=True),
),
search=mock.MockSearch(),
)
assert phase_imaging_7x7.settings.settings_masked_imaging.sub_size == 3
assert (phase_imaging_7x7.settings.settings_masked_imaging.
signal_to_noise_limit == 1.0)
assert phase_imaging_7x7.settings.settings_masked_imaging.bin_up_factor == 2
assert phase_imaging_7x7.settings.settings_masked_imaging.psf_shape_2d == (
3, 3)
assert phase_imaging_7x7.settings.settings_pixelization.use_border == False
assert phase_imaging_7x7.settings.settings_pixelization.is_stochastic == True
analysis = phase_imaging_7x7.make_analysis(dataset=imaging_7x7,
mask=mask_7x7,
results=mock.MockResults())
assert isinstance(analysis.masked_dataset.grid, al.Grid)
assert isinstance(analysis.masked_dataset.grid_inversion, al.Grid)
phase_imaging_7x7 = al.PhaseImaging(
settings=al.SettingsPhaseImaging(
settings_masked_imaging=al.SettingsMaskedImaging(
grid_class=al.GridIterate,
sub_size=3,
fractional_accuracy=0.99,
sub_steps=[2],
)),
search=mock.MockSearch(),
)
analysis = phase_imaging_7x7.make_analysis(dataset=imaging_7x7,
mask=mask_7x7,
results=mock.MockResults())
assert isinstance(analysis.masked_dataset.grid, al.GridIterate)
assert analysis.masked_dataset.grid.sub_size == 1
assert analysis.masked_dataset.grid.fractional_accuracy == 0.99
assert analysis.masked_dataset.grid.sub_steps == [2]
def test__inversion_imaging_from(sub_grid_2d_7x7, masked_imaging_7x7):
g_linear = al.Galaxy(redshift=0.5, light_linear=al.lp_linear.EllSersic())
tracer = al.Tracer.from_galaxies(
galaxies=[al.Galaxy(redshift=0.5), g_linear])
tracer_to_inversion = al.TracerToInversion(tracer=tracer)
inversion = tracer_to_inversion.inversion_imaging_from(
dataset=masked_imaging_7x7,
image=masked_imaging_7x7.image,
noise_map=masked_imaging_7x7.noise_map,
w_tilde=masked_imaging_7x7.w_tilde,
settings_pixelization=al.SettingsPixelization(use_border=False),
settings_inversion=al.SettingsInversion(use_w_tilde=False),
)
assert inversion.reconstruction[0] == pytest.approx(0.002310, 1.0e-2)
pix = al.pix.Rectangular(shape=(3, 3))
reg = al.reg.Constant(coefficient=0.0)
g0 = al.Galaxy(redshift=0.5, pixelization=pix, regularization=reg)
tracer = al.Tracer.from_galaxies(galaxies=[al.Galaxy(redshift=0.5), g0])
tracer_to_inversion = al.TracerToInversion(tracer=tracer)
inversion = tracer_to_inversion.inversion_imaging_from(
dataset=masked_imaging_7x7,
image=masked_imaging_7x7.image,
noise_map=masked_imaging_7x7.noise_map,
w_tilde=masked_imaging_7x7.w_tilde,
settings_pixelization=al.SettingsPixelization(use_border=False),
settings_inversion=al.SettingsInversion(use_w_tilde=False),
)
assert inversion.mapped_reconstructed_image == pytest.approx(
masked_imaging_7x7.image, 1.0e-2)
def test__use_border__determines_if_border_pixel_relocation_is_used(
self, imaging_7x7, mask_7x7
):
# noinspection PyTypeChecker
lens_galaxy = al.Galaxy(
redshift=0.5, mass=al.mp.SphericalIsothermal(einstein_radius=100.0)
)
source_galaxy = al.Galaxy(
redshift=1.0,
pixelization=al.pix.Rectangular(shape=(3, 3)),
regularization=al.reg.Constant(coefficient=1.0),
)
phase_imaging_7x7 = al.PhaseImaging(
galaxies=[lens_galaxy, source_galaxy],
settings=al.SettingsPhaseImaging(
settings_masked_imaging=al.SettingsMaskedImaging(
grid_inversion_class=al.Grid
),
settings_pixelization=al.SettingsPixelization(use_border=True),
),
search=mock.MockSearch("test_phase"),
)
analysis = phase_imaging_7x7.make_analysis(
dataset=imaging_7x7, mask=mask_7x7, results=mock.MockResults()
)
analysis.masked_dataset.grid_inversion[4] = np.array([[500.0, 0.0]])
instance = phase_imaging_7x7.model.instance_from_unit_vector([])
tracer = analysis.tracer_for_instance(instance=instance)
fit = analysis.masked_imaging_fit_for_tracer(
tracer=tracer, hyper_image_sky=None, hyper_background_noise=None
)
assert fit.inversion.mapper.source_full_grid[4][0] == pytest.approx(
97.19584, 1.0e-2
)
assert fit.inversion.mapper.source_full_grid[4][1] == pytest.approx(
-3.699999, 1.0e-2
)
phase_imaging_7x7 = al.PhaseImaging(
galaxies=[lens_galaxy, source_galaxy],
settings=al.SettingsPhaseImaging(
settings_masked_imaging=al.SettingsMaskedImaging(
grid_inversion_class=al.Grid
),
settings_pixelization=al.SettingsPixelization(use_border=False),
),
search=mock.MockSearch("test_phase"),
)
analysis = phase_imaging_7x7.make_analysis(
dataset=imaging_7x7, mask=mask_7x7, results=mock.MockResults()
)
analysis.masked_dataset.grid_inversion[4] = np.array([300.0, 0.0])
instance = phase_imaging_7x7.model.instance_from_unit_vector([])
tracer = analysis.tracer_for_instance(instance=instance)
fit = analysis.masked_imaging_fit_for_tracer(
tracer=tracer, hyper_image_sky=None, hyper_background_noise=None
)
assert fit.inversion.mapper.source_full_grid[4][0] == pytest.approx(
200.0, 1.0e-4
)
def test__simulate_interferometer_data_and_fit__linear_light_profiles_and_pixelization(
):
grid = al.Grid2D.uniform(shape_native=(51, 51),
pixel_scales=0.1,
sub_size=1)
lens_galaxy = al.Galaxy(
redshift=0.5,
light=al.lp.EllSersic(centre=(0.1, 0.1), intensity=100.0),
mass=al.mp.EllIsothermal(centre=(0.1, 0.1), einstein_radius=1.0),
)
source_galaxy = al.Galaxy(
redshift=1.0,
bulge=al.lp.EllSersic(intensity=0.1, sersic_index=1.0),
disk=al.lp.EllSersic(intensity=0.2, sersic_index=4.0),
)
tracer = al.Tracer.from_galaxies(galaxies=[lens_galaxy, source_galaxy])
simulator = al.SimulatorInterferometer(
uv_wavelengths=np.array([
[0.04, 200.0, 0.3, 400000.0, 60000000.0],
[0.00003, 500.0, 600000.0, 0.1, 75555555],
]),
transformer_class=al.TransformerDFT,
exposure_time=300.0,
noise_if_add_noise_false=1.0,
noise_sigma=None,
)
interferometer = simulator.via_tracer_from(tracer=tracer, grid=grid)
interferometer = interferometer.apply_settings(
settings=al.SettingsInterferometer(grid_class=al.Grid2D,
transformer_class=al.TransformerDFT,
sub_size=1))
lens_galaxy_linear = al.Galaxy(
redshift=0.5,
light=al.lp_linear.EllSersic(centre=(0.1, 0.1)),
mass=al.mp.EllIsothermal(centre=(0.1, 0.1), einstein_radius=1.0),
)
source_galaxy_pix = al.Galaxy(
redshift=1.0,
pixelization=al.pix.Rectangular(shape=(3, 3)),
regularization=al.reg.Constant(coefficient=0.01),
)
tracer_linear = al.Tracer.from_galaxies(
galaxies=[lens_galaxy_linear, source_galaxy_pix])
fit_linear = al.FitInterferometer(
dataset=interferometer,
tracer=tracer_linear,
settings_pixelization=al.SettingsPixelization(use_border=False),
settings_inversion=al.SettingsInversion(use_w_tilde=False),
)
assert fit_linear.inversion.reconstruction == pytest.approx(
np.array([
1.00338472e02,
9.55074606e-02,
9.24767167e-02,
9.45392540e-02,
1.41969109e-01,
1.41828976e-01,
1.41521130e-01,
1.84257307e-01,
1.85507562e-01,
1.83726575e-01,
]),
1.0e-2,
)
assert fit_linear.figure_of_merit == pytest.approx(-29.20551989, 1.0e-4)
lens_galaxy_image = lens_galaxy.image_2d_from(grid=interferometer.grid)
assert fit_linear.galaxy_model_image_dict[
lens_galaxy_linear] == pytest.approx(lens_galaxy_image, 1.0e-2)
traced_grid_2d_list = tracer.traced_grid_2d_list_from(
grid=interferometer.grid)
source_galaxy_image = source_galaxy.image_2d_from(
grid=traced_grid_2d_list[1])
def test___lens_fit_galaxy_model_visibilities_dict__has_profile_visibilitiess_and_inversion_mapped_reconstructed_visibilities(
self, interferometer_7_grid):
g0 = al.Galaxy(redshift=0.5,
light_profile=al.lp.EllSersic(intensity=1.0))
g1 = al.Galaxy(redshift=0.5,
light_profile=al.lp.EllSersic(intensity=2.0))
g2 = al.Galaxy(redshift=0.5)
pix = al.pix.Rectangular(shape=(3, 3))
reg = al.reg.Constant(coefficient=1.0)
galaxy_pix = al.Galaxy(redshift=1.0,
pixelization=pix,
regularization=reg)
tracer = al.Tracer.from_galaxies(galaxies=[g0, g1, g2, galaxy_pix])
fit = al.FitInterferometer(interferometer=interferometer_7_grid,
tracer=tracer)
traced_grids = tracer.traced_grids_of_planes_from_grid(
grid=interferometer_7_grid.grid)
g0_visibilities = g0.profile_visibilities_from_grid_and_transformer(
grid=traced_grids[0],
transformer=interferometer_7_grid.transformer)
g1_visibilities = g1.profile_visibilities_from_grid_and_transformer(
grid=traced_grids[1],
transformer=interferometer_7_grid.transformer)
profile_visibilities = g0_visibilities + g1_visibilities
profile_subtracted_visibilities = (interferometer_7_grid.visibilities -
profile_visibilities)
mapper = pix.mapper_from_grid_and_sparse_grid(
grid=interferometer_7_grid.grid,
settings=al.SettingsPixelization(use_border=False),
)
inversion = inversions.InversionInterferometerMatrix.from_data_mapper_and_regularization(
visibilities=profile_subtracted_visibilities,
noise_map=interferometer_7_grid.noise_map,
transformer=interferometer_7_grid.transformer,
mapper=mapper,
regularization=reg,
)
assert (fit.galaxy_model_visibilities_dict[g2] == (0.0 + 0.0j) *
np.zeros((7, ))).all()
assert fit.galaxy_model_visibilities_dict[g0].slim == pytest.approx(
g0_visibilities.slim, 1.0e-4)
assert fit.galaxy_model_visibilities_dict[g1].slim == pytest.approx(
g1_visibilities.slim, 1.0e-4)
assert fit.galaxy_model_visibilities_dict[
galaxy_pix].slim == pytest.approx(
inversion.mapped_reconstructed_visibilities.slim, 1.0e-4)
assert fit.model_visibilities.slim == pytest.approx(
fit.galaxy_model_visibilities_dict[g0].slim +
fit.galaxy_model_visibilities_dict[g1].slim +
inversion.mapped_reconstructed_visibilities.slim,
1.0e-4,
)
def test__tag__mixture_of_values():
settings = al.SettingsPhaseImaging(
settings_masked_imaging=al.SettingsMaskedImaging(
grid_class=al.Grid,
grid_inversion_class=al.Grid,
sub_size=2,
signal_to_noise_limit=2,
bin_up_factor=None,
psf_shape_2d=None,
),
settings_lens=al.SettingsLens(positions_threshold=2.0),
)
assert settings.phase_tag_no_inversion == "settings__grid_sub_2__snr_2__pos_2.00"
assert (
settings.phase_tag_with_inversion
== "settings__grid_sub_2_inv_sub_2__snr_2__pos_2.00"
)
settings = al.SettingsPhaseImaging(
settings_masked_imaging=al.SettingsMaskedImaging(
grid_class=al.GridIterate,
grid_inversion_class=al.GridInterpolate,
fractional_accuracy=0.5,
pixel_scales_interp=0.3,
bin_up_factor=3,
psf_shape_2d=(2, 2),
),
settings_lens=al.SettingsLens(auto_positions_factor=0.5),
settings_pixelization=al.SettingsPixelization(
use_border=False, is_stochastic=True
),
log_likelihood_cap=200.01,
)
assert (
settings.phase_tag_no_inversion
== "settings__grid_facc_0.5__bin_3__psf_2x2__auto_pos_x0.50__lh_cap_200.0"
)
assert (
settings.phase_tag_with_inversion
== "settings__grid_facc_0.5_inv_interp_0.300__bin_3__psf_2x2__auto_pos_x0.50__no_border__stochastic__lh_cap_200.0"
)
settings = al.SettingsPhaseInterferometer(
masked_interferometer=al.SettingsMaskedInterferometer(
grid_class=al.GridIterate,
grid_inversion_class=al.GridInterpolate,
fractional_accuracy=0.5,
pixel_scales_interp=0.3,
transformer_class=al.TransformerDFT,
),
settings_pixelization=al.SettingsPixelization(
use_border=False, is_stochastic=True
),
log_likelihood_cap=100.01,
)
assert (
settings.phase_tag_no_inversion == "settings__grid_facc_0.5__dft__lh_cap_100.0"
)
assert (
settings.phase_tag_with_inversion
== "settings__grid_facc_0.5_inv_interp_0.300__dft__no_border__stochastic__lh_cap_100.0"
)
settings = al.SettingsPhaseInterferometer(
masked_interferometer=al.SettingsMaskedInterferometer(
transformer_class=al.TransformerNUFFT
),
settings_inversion=al.SettingsInversion(use_linear_operators=True),
)
assert settings.phase_tag_no_inversion == "settings__grid_sub_2__nufft"
assert (
settings.phase_tag_with_inversion
== "settings__grid_sub_2_inv_sub_2__nufft__lop"
)
def test__simulate_interferometer_data_and_fit__chi_squared_is_0__noise_normalization_correct(
):
grid = al.Grid2D.uniform(shape_native=(51, 51),
pixel_scales=0.1,
sub_size=1)
lens_galaxy = al.Galaxy(
redshift=0.5,
light=al.lp.EllSersic(centre=(0.1, 0.1), intensity=0.1),
mass=al.mp.EllIsothermal(centre=(0.1, 0.1), einstein_radius=1.0),
)
source_galaxy = al.Galaxy(redshift=1.0,
light=al.lp.EllExponential(centre=(0.1, 0.1),
intensity=0.5))
tracer = al.Tracer.from_galaxies(galaxies=[lens_galaxy, source_galaxy])
simulator = al.SimulatorInterferometer(
uv_wavelengths=np.ones(shape=(7, 2)),
transformer_class=al.TransformerDFT,
exposure_time=300.0,
noise_if_add_noise_false=1.0,
noise_sigma=None,
)
interferometer = simulator.from_tracer_and_grid(tracer=tracer, grid=grid)
file_path = path.join(
"{}".format(path.dirname(path.realpath(__file__))),
"data_temp",
"simulate_and_fit",
)
try:
shutil.rmtree(file_path)
except FileNotFoundError:
pass
if path.exists(file_path) is False:
os.makedirs(file_path)
interferometer.output_to_fits(
visibilities_path=path.join(file_path, "visibilities.fits"),
noise_map_path=path.join(file_path, "noise_map.fits"),
uv_wavelengths_path=path.join(file_path, "uv_wavelengths.fits"),
)
real_space_mask = al.Mask2D.unmasked(shape_native=(51, 51),
pixel_scales=0.1,
sub_size=2)
interferometer = al.Interferometer.from_fits(
visibilities_path=path.join(file_path, "visibilities.fits"),
noise_map_path=path.join(file_path, "noise_map.fits"),
uv_wavelengths_path=path.join(file_path, "uv_wavelengths.fits"),
real_space_mask=real_space_mask,
)
interferometer = interferometer.apply_settings(
settings=al.SettingsInterferometer(
transformer_class=al.TransformerDFT))
tracer = al.Tracer.from_galaxies(galaxies=[lens_galaxy, source_galaxy])
fit = al.FitInterferometer(
interferometer=interferometer,
tracer=tracer,
settings_pixelization=al.SettingsPixelization(use_border=False),
)
assert fit.chi_squared == pytest.approx(0.0)
pix = al.pix.Rectangular(shape=(7, 7))
reg = al.reg.Constant(coefficient=0.0001)
lens_galaxy = al.Galaxy(
redshift=0.5,
light=al.lp.EllSersic(centre=(0.1, 0.1), intensity=0.1),
mass=al.mp.EllIsothermal(centre=(0.1, 0.1), einstein_radius=1.0),
)
source_galaxy = al.Galaxy(redshift=1.0,
pixelization=pix,
regularization=reg)
tracer = al.Tracer.from_galaxies(galaxies=[lens_galaxy, source_galaxy])
fit = al.FitInterferometer(
interferometer=interferometer,
tracer=tracer,
settings_pixelization=al.SettingsPixelization(use_border=False),
)
assert abs(fit.chi_squared) < 1.0e-4
file_path = path.join("{}".format(path.dirname(path.realpath(__file__))),
"data_temp")
if path.exists(file_path) is True:
shutil.rmtree(file_path)
def test___blurred_and_model_image_properties(masked_imaging_7x7):
g0 = al.Galaxy(
redshift=0.5,
light_profile=al.lp.EllSersic(intensity=1.0),
mass_profile=al.mp.SphIsothermal(einstein_radius=1.0),
)
g1 = al.Galaxy(redshift=1.0, light_profile=al.lp.EllSersic(intensity=1.0))
tracer = al.Tracer.from_galaxies(galaxies=[g0, g1])
fit = al.FitImaging(dataset=masked_imaging_7x7, tracer=tracer)
blurred_images_of_planes = tracer.blurred_image_2d_list_via_convolver_from(
grid=masked_imaging_7x7.grid,
convolver=masked_imaging_7x7.convolver,
blurring_grid=masked_imaging_7x7.blurring_grid,
)
assert blurred_images_of_planes[0].native == pytest.approx(
fit.model_images_of_planes[0].native, 1.0e-4)
assert blurred_images_of_planes[1].native == pytest.approx(
fit.model_images_of_planes[1].native, 1.0e-4)
unmasked_blurred_image = tracer.unmasked_blurred_image_2d_via_psf_from(
grid=masked_imaging_7x7.grid, psf=masked_imaging_7x7.psf)
assert (unmasked_blurred_image == fit.unmasked_blurred_image).all()
unmasked_blurred_image_of_planes = tracer.unmasked_blurred_image_2d_list_via_psf_from(
grid=masked_imaging_7x7.grid, psf=masked_imaging_7x7.psf)
assert (unmasked_blurred_image_of_planes[0] ==
fit.unmasked_blurred_image_of_planes[0]).all()
assert (unmasked_blurred_image_of_planes[1] ==
fit.unmasked_blurred_image_of_planes[1]).all()
pix = al.pix.Rectangular(shape=(3, 3))
reg = al.reg.Constant(coefficient=1.0)
g0 = al.Galaxy(redshift=1.0, pixelization=pix, regularization=reg)
tracer = al.Tracer.from_galaxies(galaxies=[al.Galaxy(redshift=0.5), g0])
fit = al.FitImaging(dataset=masked_imaging_7x7, tracer=tracer)
mapper = pix.mapper_from(
source_grid_slim=masked_imaging_7x7.grid,
settings=al.SettingsPixelization(use_border=False),
)
inversion = al.Inversion(dataset=masked_imaging_7x7,
linear_obj_list=[mapper],
regularization_list=[reg])
assert (fit.model_images_of_planes[0].native == np.zeros((7, 7))).all()
assert inversion.mapped_reconstructed_image.native == pytest.approx(
fit.model_images_of_planes[1].native, 1.0e-4)
galaxy_light = al.Galaxy(redshift=0.5,
light_profile=al.lp.EllSersic(intensity=1.0))
galaxy_pix = al.Galaxy(redshift=1.0, pixelization=pix, regularization=reg)
tracer = al.Tracer.from_galaxies(galaxies=[galaxy_light, galaxy_pix])
fit = al.FitImaging(dataset=masked_imaging_7x7, tracer=tracer)
blurred_image = tracer.blurred_image_2d_via_convolver_from(
grid=masked_imaging_7x7.grid,
convolver=masked_imaging_7x7.convolver,
blurring_grid=masked_imaging_7x7.blurring_grid,
)
profile_subtracted_image = masked_imaging_7x7.image - blurred_image
mapper = pix.mapper_from(
source_grid_slim=masked_imaging_7x7.grid,
settings=al.SettingsPixelization(use_border=False),
)
inversion = al.InversionImaging(
image=profile_subtracted_image,
noise_map=masked_imaging_7x7.noise_map,
convolver=masked_imaging_7x7.convolver,
w_tilde=masked_imaging_7x7.w_tilde,
linear_obj_list=[mapper],
regularization_list=[reg],
)
assert blurred_image.native == pytest.approx(
fit.model_images_of_planes[0].native, 1.0e-4)
assert inversion.mapped_reconstructed_image.native == pytest.approx(
fit.model_images_of_planes[1].native, 1.0e-4)
def test__galaxy_model_image_dict(masked_imaging_7x7):
g0 = al.Galaxy(
redshift=0.5,
light_profile=al.lp.EllSersic(intensity=1.0),
mass_profile=al.mp.SphIsothermal(einstein_radius=1.0),
)
g1 = al.Galaxy(redshift=1.0, light_profile=al.lp.EllSersic(intensity=1.0))
g2 = al.Galaxy(redshift=1.0)
tracer = al.Tracer.from_galaxies(galaxies=[g0, g1, g2])
fit = al.FitImaging(dataset=masked_imaging_7x7, tracer=tracer)
traced_grids_of_planes = tracer.traced_grid_list_from(
grid=masked_imaging_7x7.grid)
traced_blurring_grids_of_planes = tracer.traced_grid_list_from(
grid=masked_imaging_7x7.blurring_grid)
g0_image = g0.image_2d_from(grid=traced_grids_of_planes[0])
g0_blurring_image = g0.image_2d_from(
grid=traced_blurring_grids_of_planes[0])
g0_blurred_image = masked_imaging_7x7.convolver.convolve_image(
image=g0_image, blurring_image=g0_blurring_image)
g1_image = g1.image_2d_from(grid=traced_grids_of_planes[1])
g1_blurring_image = g1.image_2d_from(
grid=traced_blurring_grids_of_planes[1])
g1_blurred_image = masked_imaging_7x7.convolver.convolve_image(
image=g1_image, blurring_image=g1_blurring_image)
assert fit.galaxy_model_image_dict[g0] == pytest.approx(
g0_blurred_image, 1.0e-4)
assert fit.galaxy_model_image_dict[g1] == pytest.approx(
g1_blurred_image, 1.0e-4)
assert (fit.galaxy_model_image_dict[g2].slim == np.zeros(9)).all()
assert fit.model_image.native == pytest.approx(
fit.galaxy_model_image_dict[g0].native +
fit.galaxy_model_image_dict[g1].native,
1.0e-4,
)
pix = al.pix.Rectangular(shape=(3, 3))
reg = al.reg.Constant(coefficient=1.0)
g0 = al.Galaxy(redshift=0.5)
g1 = al.Galaxy(redshift=1.0, pixelization=pix, regularization=reg)
tracer = al.Tracer.from_galaxies(galaxies=[g0, g1])
fit = al.FitImaging(dataset=masked_imaging_7x7, tracer=tracer)
mapper = pix.mapper_from(source_grid_slim=masked_imaging_7x7.grid,
source_pixelization_grid=None)
inversion = al.Inversion(
dataset=masked_imaging_7x7,
linear_obj_list=[mapper],
regularization_list=[reg],
settings=al.SettingsInversion(use_w_tilde=False),
)
assert (fit.galaxy_model_image_dict[g0] == np.zeros(9)).all()
assert fit.galaxy_model_image_dict[g1].native == pytest.approx(
inversion.mapped_reconstructed_image.native, 1.0e-4)
assert fit.model_image.native == pytest.approx(
fit.galaxy_model_image_dict[g1].native, 1.0e-4)
g0 = al.Galaxy(redshift=0.5, light_profile=al.lp.EllSersic(intensity=1.0))
g1 = al.Galaxy(redshift=0.5, light_profile=al.lp.EllSersic(intensity=2.0))
g2 = al.Galaxy(redshift=0.5)
pix = al.pix.Rectangular(shape=(3, 3))
reg = al.reg.Constant(coefficient=1.0)
galaxy_pix = al.Galaxy(redshift=1.0, pixelization=pix, regularization=reg)
tracer = al.Tracer.from_galaxies(galaxies=[g0, g1, g2, galaxy_pix])
masked_imaging_7x7.image[0] = 3.0
fit = al.FitImaging(dataset=masked_imaging_7x7, tracer=tracer)
traced_grids = tracer.traced_grid_list_from(grid=masked_imaging_7x7.grid)
traced_blurring_grids = tracer.traced_grid_list_from(
grid=masked_imaging_7x7.blurring_grid)
g0_image = g0.image_2d_from(grid=traced_grids[0])
g0_blurring_image = g0.image_2d_from(grid=traced_blurring_grids[0])
g0_blurred_image = masked_imaging_7x7.convolver.convolve_image(
image=g0_image, blurring_image=g0_blurring_image)
g1_image = g1.image_2d_from(grid=traced_grids[1])
g1_blurring_image = g1.image_2d_from(grid=traced_blurring_grids[1])
g1_blurred_image = masked_imaging_7x7.convolver.convolve_image(
image=g1_image, blurring_image=g1_blurring_image)
blurred_image = g0_blurred_image + g1_blurred_image
profile_subtracted_image = masked_imaging_7x7.image - blurred_image
mapper = pix.mapper_from(
source_grid_slim=masked_imaging_7x7.grid,
settings=al.SettingsPixelization(use_border=False),
)
inversion = al.InversionImaging(
image=profile_subtracted_image,
noise_map=masked_imaging_7x7.noise_map,
convolver=masked_imaging_7x7.convolver,
w_tilde=masked_imaging_7x7.w_tilde,
linear_obj_list=[mapper],
regularization_list=[reg],
)
assert (fit.galaxy_model_image_dict[g2] == np.zeros(9)).all()
assert fit.galaxy_model_image_dict[g0].native == pytest.approx(
g0_blurred_image.native, 1.0e-4)
assert fit.galaxy_model_image_dict[g1].native == pytest.approx(
g1_blurred_image.native, 1.0e-4)
assert fit.galaxy_model_image_dict[galaxy_pix].native == pytest.approx(
inversion.mapped_reconstructed_image.native, 1.0e-4)
assert fit.model_image.native == pytest.approx(
fit.galaxy_model_image_dict[g0].native +
fit.galaxy_model_image_dict[g1].native +
inversion.mapped_reconstructed_image.native,
1.0e-4,
)
def test__masked_interferometer__settings_inputs_are_used_in_masked_interferometer(
self, interferometer_7, mask_7x7):
phase_interferometer_7 = al.PhaseInterferometer(
search=mock.MockSearch("phase_interferometer_7"),
settings=al.SettingsPhaseInterferometer(
settings_masked_interferometer=al.SettingsMaskedInterferometer(
grid_class=al.Grid2D,
grid_inversion_class=al.Grid2D,
sub_size=3,
signal_to_noise_limit=1.0,
),
settings_pixelization=al.SettingsPixelization(
use_border=False, is_stochastic=True),
settings_inversion=al.SettingsInversion(
use_linear_operators=True),
),
real_space_mask=mask_7x7,
)
assert (phase_interferometer_7.settings.settings_masked_interferometer.
sub_size == 3)
assert (phase_interferometer_7.settings.settings_masked_interferometer.
signal_to_noise_limit == 1.0)
assert phase_interferometer_7.settings.settings_pixelization.use_border == False
assert (phase_interferometer_7.settings.settings_pixelization.
is_stochastic == True)
assert (phase_interferometer_7.settings.settings_inversion.
use_linear_operators == True)
analysis = phase_interferometer_7.make_analysis(
dataset=interferometer_7,
mask=mask_7x7,
results=mock.MockResults())
assert isinstance(analysis.masked_dataset.grid, al.Grid2D)
assert isinstance(analysis.masked_dataset.grid_inversion, al.Grid2D)
assert isinstance(analysis.masked_dataset.transformer,
al.TransformerNUFFT)
phase_interferometer_7 = al.PhaseInterferometer(
settings=al.SettingsPhaseInterferometer(
settings_masked_interferometer=al.SettingsMaskedInterferometer(
grid_class=al.Grid2DIterate,
sub_size=3,
fractional_accuracy=0.99,
sub_steps=[2],
transformer_class=al.TransformerDFT,
)),
search=mock.MockSearch("phase_interferometer_7"),
real_space_mask=mask_7x7,
)
analysis = phase_interferometer_7.make_analysis(
dataset=interferometer_7,
mask=mask_7x7,
results=mock.MockResults())
assert isinstance(analysis.masked_dataset.grid, al.Grid2DIterate)
assert analysis.masked_dataset.grid.sub_size == 1
assert analysis.masked_dataset.grid.fractional_accuracy == 0.99
assert analysis.masked_dataset.grid.sub_steps == [2]
assert isinstance(analysis.masked_dataset.transformer,
al.TransformerDFT)
for coefficient in coefficients:
reg = al.reg.Constant(coefficient=coefficient)
source_galaxy = al.Galaxy(
redshift=1.0,
pixelization=al.pix.VoronoiMagnification(shape=(30, 30)),
regularization=reg,
)
tracer = al.Tracer.from_galaxies(galaxies=[lens_galaxy, source_galaxy])
mapper = tracer.mappers_of_planes_from_grid(
grid=masked_interferometer.grid,
settings_pixelization=al.SettingsPixelization())[1]
curvature_matrix = compute_curvature_matrix(
visibilities=masked_interferometer.visibilities,
noise_map=masked_interferometer.noise_map,
transformer=masked_interferometer.transformer,
mapper=mapper,
regularization=reg,
)
regularization_matrix = reg.regularization_matrix_from_mapper(
mapper=mapper)
preconditioner_matrix = inversion_util.preconditioner_matrix_via_mapping_matrix_from(
mapping_matrix=mapper.mapping_matrix,
regularization_matrix=regularization_matrix,
redshift=1.0,
pixelization=al.pix.DelaunayMagnification,
regularization=al.reg.Constant,
),
)
)
search = af.DynestyStatic(
path_prefix=path.join("howtolens", "chapter_4"),
name="search[2]_mass[sie]_source[inversion_initialization]",
unique_tag=dataset_name,
nlive=20,
)
analysis = al.AnalysisImaging(
dataset=imaging, settings_pixelization=al.SettingsPixelization(use_border=True)
)
result_2 = search.fit(model=model, analysis=analysis)
"""
__Model + Search (Search 3)__
We use the results of searches 1 and 2 to create the lens model fitted in search 3, where:
- The lens galaxy's total mass distribution is an `EllIsothermal` and `ExternalShear` [7 parameters: priors
initialized from search 1].
- The source-galaxy's light uses a `DelaunayMagnification` pixelization [parameters fixed to results of search 2].
- This pixelization is regularized using a `Constant` scheme [parameters fixed to results of search 2].
# %%
"""
__Settings__
The `SettingsPhaseImaging` describe how the model is fitted to the data in the log likelihood function. We discussed
these in chapter 2, and a full description of all settings can be found in the example script:
`autolens_workspace/examples/model/customize/settings.py`.
The settings chosen here are applied to all phases in the pipeline. Note how we can use the _SettingsPixelization_
object to determine whether the border is used during the model-fit.
"""
# %%
settings_masked_imaging = al.SettingsMaskedImaging(sub_size=2)
settings_pixelization = al.SettingsPixelization(use_border=True)
settings = al.SettingsPhaseImaging(
settings_masked_imaging=settings_masked_imaging,
settings_pixelization=settings_pixelization,
)
# %%
"""
__Pipeline_Setup_And_Tagging__:
We will use the standardized `Setup` objects in this pipeline, which as discussed in chapter 3 provide us with
covenient and standardized tools to compose a lens model and tags the output paths.
We saw the `SetupMassTotal` object in the previous chapter, which:
def test__simulate_interferometer_data_and_fit__chi_squared_is_0__noise_normalization_correct(
):
grid = al.Grid.uniform(shape_2d=(51, 51), pixel_scales=0.1, sub_size=2)
lens_galaxy = al.Galaxy(
redshift=0.5,
light=al.lp.EllipticalSersic(centre=(0.1, 0.1), intensity=0.1),
mass=al.mp.EllipticalIsothermal(centre=(0.1, 0.1),
einstein_radius=1.0),
)
source_galaxy = al.Galaxy(
redshift=1.0,
light=al.lp.EllipticalExponential(centre=(0.1, 0.1), intensity=0.5),
)
tracer = al.Tracer.from_galaxies(galaxies=[lens_galaxy, source_galaxy])
simulator = al.SimulatorInterferometer(
uv_wavelengths=np.ones(shape=(7, 2)),
transformer_class=al.TransformerDFT,
exposure_time_map=al.Array.full(fill_value=300.0,
shape_2d=grid.shape_2d),
background_sky_map=al.Array.zeros(shape_2d=grid.shape_2d),
noise_if_add_noise_false=1.0,
noise_sigma=None,
)
interferometer = simulator.from_tracer_and_grid(tracer=tracer, grid=grid)
path = "{}/data_temp/simulate_and_fit".format(
os.path.dirname(os.path.realpath(
__file__))) # Setup path so we can output the simulated image.
try:
shutil.rmtree(path)
except FileNotFoundError:
pass
if os.path.exists(path) is False:
os.makedirs(path)
interferometer.output_to_fits(
visibilities_path=path + "/visibilities.fits",
noise_map_path=f"{path}/noise_map.fits",
uv_wavelengths_path=path + "/uv_wavelengths.fits",
)
interferometer = al.Interferometer.from_fits(
visibilities_path=path + "/visibilities.fits",
noise_map_path=f"{path}/noise_map.fits",
uv_wavelengths_path=path + "/uv_wavelengths.fits",
)
visibilities_mask = np.full(fill_value=False, shape=(7, 2))
real_space_mask = al.Mask.unmasked(shape_2d=(51, 51),
pixel_scales=0.1,
sub_size=2)
masked_interferometer = al.MaskedInterferometer(
interferometer=interferometer,
visibilities_mask=visibilities_mask,
real_space_mask=real_space_mask,
settings=al.SettingsMaskedInterferometer(
transformer_class=al.TransformerDFT),
)
tracer = al.Tracer.from_galaxies(galaxies=[lens_galaxy, source_galaxy])
fit = al.FitInterferometer(
masked_interferometer=masked_interferometer,
tracer=tracer,
settings_pixelization=al.SettingsPixelization(use_border=False),
)
assert fit.chi_squared == pytest.approx(0.0)
pix = al.pix.Rectangular(shape=(7, 7))
reg = al.reg.Constant(coefficient=0.0001)
lens_galaxy = al.Galaxy(
redshift=0.5,
light=al.lp.EllipticalSersic(centre=(0.1, 0.1), intensity=0.1),
mass=al.mp.EllipticalIsothermal(centre=(0.1, 0.1),
einstein_radius=1.0),
)
source_galaxy = al.Galaxy(redshift=1.0,
pixelization=pix,
regularization=reg)
tracer = al.Tracer.from_galaxies(galaxies=[lens_galaxy, source_galaxy])
fit = al.FitInterferometer(
masked_interferometer=masked_interferometer,
tracer=tracer,
settings_pixelization=al.SettingsPixelization(use_border=False),
)
assert abs(fit.chi_squared) < 1.0e-4
path = "{}/data_temp".format(os.path.dirname(os.path.realpath(
__file__))) # Setup path so we can output the simulated image.
if os.path.exists(path) == True:
shutil.rmtree(path)
def test___galaxy_model_visibilities_dict(interferometer_7,
interferometer_7_grid):
g0 = al.Galaxy(
redshift=0.5,
light_profile=al.lp.EllSersic(intensity=1.0),
mass_profile=al.mp.SphIsothermal(einstein_radius=1.0),
)
g1 = al.Galaxy(redshift=1.0, light_profile=al.lp.EllSersic(intensity=1.0))
g2 = al.Galaxy(redshift=1.0)
tracer = al.Tracer.from_galaxies(galaxies=[g0, g1, g2])
fit = al.FitInterferometer(dataset=interferometer_7_grid, tracer=tracer)
traced_grids_of_planes = tracer.traced_grid_list_from(
grid=interferometer_7_grid.grid)
g0_profile_visibilities = g0.visibilities_via_transformer_from(
grid=traced_grids_of_planes[0],
transformer=interferometer_7_grid.transformer)
g1_profile_visibilities = g1.visibilities_via_transformer_from(
grid=traced_grids_of_planes[1],
transformer=interferometer_7_grid.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.galaxy_model_visibilities_dict[g2].slim == (0.0 + 0.0j) *
np.zeros((7, ))).all()
assert fit.model_visibilities.slim == pytest.approx(
fit.galaxy_model_visibilities_dict[g0].slim +
fit.galaxy_model_visibilities_dict[g1].slim,
1.0e-4,
)
pix = al.pix.Rectangular(shape=(3, 3))
reg = al.reg.Constant(coefficient=1.0)
g0 = al.Galaxy(redshift=0.5)
g1 = al.Galaxy(redshift=1.0, pixelization=pix, regularization=reg)
tracer = al.Tracer.from_galaxies(galaxies=[g0, g1])
fit = al.FitInterferometer(dataset=interferometer_7, tracer=tracer)
mapper = pix.mapper_from(source_grid_slim=interferometer_7.grid,
source_pixelization_grid=None)
inversion = al.Inversion(dataset=interferometer_7,
linear_obj_list=[mapper],
regularization_list=[reg])
assert (fit.galaxy_model_visibilities_dict[g0] == (0.0 + 0.0j) * np.zeros(
(7, ))).all()
assert fit.galaxy_model_visibilities_dict[g1].slim == pytest.approx(
inversion.mapped_reconstructed_data.slim, 1.0e-4)
assert fit.model_visibilities.slim == pytest.approx(
fit.galaxy_model_visibilities_dict[g1].slim, 1.0e-4)
g0 = al.Galaxy(redshift=0.5, light_profile=al.lp.EllSersic(intensity=1.0))
g1 = al.Galaxy(redshift=0.5, light_profile=al.lp.EllSersic(intensity=2.0))
g2 = al.Galaxy(redshift=0.5)
pix = al.pix.Rectangular(shape=(3, 3))
reg = al.reg.Constant(coefficient=1.0)
galaxy_pix = al.Galaxy(redshift=1.0, pixelization=pix, regularization=reg)
tracer = al.Tracer.from_galaxies(galaxies=[g0, g1, g2, galaxy_pix])
fit = al.FitInterferometer(dataset=interferometer_7_grid, tracer=tracer)
traced_grids = tracer.traced_grid_list_from(
grid=interferometer_7_grid.grid)
g0_visibilities = g0.visibilities_via_transformer_from(
grid=traced_grids[0], transformer=interferometer_7_grid.transformer)
g1_visibilities = g1.visibilities_via_transformer_from(
grid=traced_grids[1], transformer=interferometer_7_grid.transformer)
profile_visibilities = g0_visibilities + g1_visibilities
profile_subtracted_visibilities = (interferometer_7_grid.visibilities -
profile_visibilities)
mapper = pix.mapper_from(
source_grid_slim=interferometer_7_grid.grid,
settings=al.SettingsPixelization(use_border=False),
)
inversion = al.InversionInterferometer(
visibilities=profile_subtracted_visibilities,
noise_map=interferometer_7_grid.noise_map,
transformer=interferometer_7_grid.transformer,
linear_obj_list=[mapper],
regularization_list=[reg],
settings=al.SettingsInversion(use_w_tilde=False),
)
assert (fit.galaxy_model_visibilities_dict[g2] == (0.0 + 0.0j) * np.zeros(
(7, ))).all()
assert fit.galaxy_model_visibilities_dict[g0].slim == pytest.approx(
g0_visibilities.slim, 1.0e-4)
assert fit.galaxy_model_visibilities_dict[g1].slim == pytest.approx(
g1_visibilities.slim, 1.0e-4)
assert fit.galaxy_model_visibilities_dict[
galaxy_pix].slim == pytest.approx(
inversion.mapped_reconstructed_data.slim, 1.0e-4)
assert fit.model_visibilities.slim == pytest.approx(
fit.galaxy_model_visibilities_dict[g0].slim +
fit.galaxy_model_visibilities_dict[g1].slim +
inversion.mapped_reconstructed_data.slim,
1.0e-4,
)
def test__simulate_interferometer_data_and_fit__linear_light_profiles_agree_with_standard_light_profiles(
):
grid = al.Grid2D.uniform(shape_native=(51, 51),
pixel_scales=0.1,
sub_size=1)
lens_galaxy = al.Galaxy(
redshift=0.5,
light=al.lp.EllSersic(centre=(0.1, 0.1), intensity=0.1),
mass=al.mp.EllIsothermal(centre=(0.1, 0.1), einstein_radius=1.0),
)
source_galaxy = al.Galaxy(
redshift=1.0,
bulge=al.lp.EllSersic(intensity=0.1, sersic_index=1.0),
disk=al.lp.EllSersic(intensity=0.2, sersic_index=4.0),
)
tracer = al.Tracer.from_galaxies(galaxies=[lens_galaxy, source_galaxy])
simulator = al.SimulatorInterferometer(
uv_wavelengths=np.array([
[0.04, 200.0, 0.3, 400000.0, 60000000.0],
[0.00003, 500.0, 600000.0, 0.1, 75555555],
]),
transformer_class=al.TransformerDFT,
exposure_time=300.0,
noise_if_add_noise_false=1.0,
noise_sigma=None,
)
interferometer = simulator.via_tracer_from(tracer=tracer, grid=grid)
interferometer = interferometer.apply_settings(
settings=al.SettingsInterferometer(grid_class=al.Grid2D,
transformer_class=al.TransformerDFT,
sub_size=1))
fit = al.FitInterferometer(
dataset=interferometer,
tracer=tracer,
settings_pixelization=al.SettingsPixelization(use_border=False),
settings_inversion=al.SettingsInversion(use_w_tilde=False),
)
lens_galaxy_linear = al.Galaxy(
redshift=0.5,
light=al.lp_linear.EllSersic(centre=(0.1, 0.1)),
mass=al.mp.EllIsothermal(centre=(0.1, 0.1), einstein_radius=1.0),
)
source_galaxy_linear = al.Galaxy(
redshift=1.0,
bulge=al.lp_linear.EllSersic(sersic_index=1.0),
disk=al.lp_linear.EllSersic(sersic_index=4.0),
)
tracer_linear = al.Tracer.from_galaxies(
galaxies=[lens_galaxy_linear, source_galaxy_linear])
fit_linear = al.FitInterferometer(
dataset=interferometer,
tracer=tracer_linear,
settings_pixelization=al.SettingsPixelization(use_border=False),
settings_inversion=al.SettingsInversion(use_w_tilde=False),
)
assert fit_linear.inversion.reconstruction == pytest.approx(
np.array([0.1, 0.1, 0.2]), 1.0e-4)
assert fit_linear.linear_light_profile_intensity_dict[
lens_galaxy_linear.light] == pytest.approx(0.1, 1.0e-2)
assert fit_linear.linear_light_profile_intensity_dict[
source_galaxy_linear.bulge] == pytest.approx(0.1, 1.0e-2)
assert fit_linear.linear_light_profile_intensity_dict[
source_galaxy_linear.disk] == pytest.approx(0.2, 1.0e-2)
assert fit.log_likelihood == fit_linear.log_likelihood
lens_galaxy_image = lens_galaxy.image_2d_from(grid=interferometer.grid)
assert fit_linear.galaxy_model_image_dict[
lens_galaxy_linear] == pytest.approx(lens_galaxy_image, 1.0e-4)
traced_grid_2d_list = tracer.traced_grid_2d_list_from(
grid=interferometer.grid)
source_galaxy_image = source_galaxy.image_2d_from(
grid=traced_grid_2d_list[1])
assert fit_linear.galaxy_model_image_dict[
source_galaxy_linear] == pytest.approx(source_galaxy_image, 1.0e-4)
lens_galaxy_visibilities = lens_galaxy.visibilities_via_transformer_from(
grid=interferometer.grid, transformer=interferometer.transformer)
assert fit_linear.galaxy_model_visibilities_dict[
lens_galaxy_linear] == pytest.approx(lens_galaxy_visibilities, 1.0e-4)
source_galaxy_visibilities = source_galaxy.visibilities_via_transformer_from(
grid=traced_grid_2d_list[1], transformer=interferometer.transformer)
assert fit_linear.galaxy_model_visibilities_dict[
source_galaxy_linear] == pytest.approx(source_galaxy_visibilities,
1.0e-4)
"""
__Modification__
The `FitImagingAgg` allow us to modify the fit settings. By default, it uses the `SettingsImaging`,
`SettingsPixelization` and `SettingsInversion` that were used during the model-fit.
However, we can change these settings such that the fit is performed differently. For example, what if I wanted to see
how the fit looks where the `Grid2D`'s `sub_size` is 4 (instead of the value of 2 that was used)? Or where the
pixelization didn`t use a border?
You can do this by passing the settings objects, which overwrite the ones used by the analysis.
"""
fit_agg = al.agg.FitImagingAgg(
aggregator=agg,
settings_imaging=al.SettingsImaging(sub_size=4),
settings_pixelization=al.SettingsPixelization(use_border=False),
)
fit_imaging_gen = fit_agg.max_log_likelihood_gen()
for fit in fit_imaging_gen:
fit_imaging_plotter = aplt.FitImagingPlotter(fit=fit)
fit_imaging_plotter.subplot_fit_imaging()
"""
__Visualization Customization__
The benefit of inspecting fits using the aggregator, rather than the files outputs to the hard-disk, is that we can
customize the plots using the PyAutoLens mat_plot_2d.
Below, we create a new function to apply as a generator to do this. However, we use a convenience method available
in the PyAutoLens aggregator package to set up the fit.
"""
def test___all_lens_fit_quantities__no_hyper_methods(
self, interferometer_7):
galaxy_light = al.Galaxy(redshift=0.5,
light_profile=al.lp.EllSersic(intensity=1.0))
pix = al.pix.Rectangular(shape=(3, 3))
reg = al.reg.Constant(coefficient=1.0)
galaxy_pix = al.Galaxy(redshift=1.0,
pixelization=pix,
regularization=reg)
tracer = al.Tracer.from_galaxies(galaxies=[galaxy_light, galaxy_pix])
fit = al.FitInterferometer(interferometer=interferometer_7,
tracer=tracer)
profile_visibilities = tracer.profile_visibilities_from_grid_and_transformer(
grid=interferometer_7.grid,
transformer=interferometer_7.transformer)
assert profile_visibilities.slim == pytest.approx(
fit.profile_visibilities.slim)
profile_subtracted_visibilities = (interferometer_7.visibilities -
profile_visibilities)
assert profile_subtracted_visibilities.slim == pytest.approx(
fit.profile_subtracted_visibilities.slim)
mapper = pix.mapper_from_grid_and_sparse_grid(
grid=interferometer_7.grid,
settings=al.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,
)
model_visibilities = (profile_visibilities +
inversion.mapped_reconstructed_visibilities)
assert model_visibilities.slim == pytest.approx(
fit.model_visibilities.slim)
residual_map = al.util.fit.residual_map_from(
data=interferometer_7.visibilities, model_data=model_visibilities)
assert residual_map.slim == pytest.approx(fit.residual_map.slim)
normalized_residual_map = al.util.fit.normalized_residual_map_complex_from(
residual_map=residual_map, noise_map=interferometer_7.noise_map)
assert normalized_residual_map.slim == pytest.approx(
fit.normalized_residual_map.slim)
chi_squared_map = al.util.fit.chi_squared_map_complex_from(
residual_map=residual_map, noise_map=interferometer_7.noise_map)
assert chi_squared_map.slim == pytest.approx(fit.chi_squared_map.slim)
chi_squared = al.util.fit.chi_squared_complex_from(
chi_squared_map=chi_squared_map)
noise_normalization = al.util.fit.noise_normalization_complex_from(
noise_map=interferometer_7.noise_map)
log_likelihood = al.util.fit.log_likelihood_from(
chi_squared=chi_squared, noise_normalization=noise_normalization)
assert log_likelihood == pytest.approx(fit.log_likelihood, 1e-4)
log_likelihood_with_regularization = al.util.fit.log_likelihood_with_regularization_from(
chi_squared=chi_squared,
regularization_term=inversion.regularization_term,
noise_normalization=noise_normalization,
)
assert log_likelihood_with_regularization == pytest.approx(
fit.log_likelihood_with_regularization, 1e-4)
log_evidence = al.util.fit.log_evidence_from(
chi_squared=chi_squared,
regularization_term=inversion.regularization_term,
log_curvature_regularization_term=inversion.
log_det_curvature_reg_matrix_term,
log_regularization_term=inversion.
log_det_regularization_matrix_term,
noise_normalization=noise_normalization,
)
assert log_evidence == fit.log_evidence
assert log_evidence == fit.figure_of_merit
mapped_reconstructed_image = al.util.inversion.mapped_reconstructed_data_from(
mapping_matrix=fit.inversion.mapper.mapping_matrix,
reconstruction=fit.inversion.reconstruction,
)
assert (fit.inversion.mapped_reconstructed_image.slim ==
mapped_reconstructed_image).all()
