def test__masked_imaging__signal_to_noise_limit(self, imaging_7x7,
mask_7x7_1_pix):
imaging_snr_limit = imaging_7x7.signal_to_noise_limited_from(
signal_to_noise_limit=1.0)
phase_imaging_7x7 = al.PhaseImaging(
search=mock.MockSearch(),
settings=al.SettingsPhaseImaging(
settings_masked_imaging=al.SettingsMaskedImaging(
signal_to_noise_limit=1.0)),
)
analysis = phase_imaging_7x7.make_analysis(dataset=imaging_7x7,
mask=mask_7x7_1_pix,
results=mock.MockResults())
assert (analysis.masked_dataset.image.native ==
imaging_snr_limit.image.native *
np.invert(mask_7x7_1_pix)).all()
assert (analysis.masked_dataset.noise_map.native ==
imaging_snr_limit.noise_map.native *
np.invert(mask_7x7_1_pix)).all()
def test__stochastic_result(self, imaging_7x7, stochastic):
results = mock.MockResults(stochastic_log_evidences=[1.0, 1.0, 2.0])
result = stochastic.run(dataset=None, mask=None, results=results)
assert hasattr(result, "stochastic")
assert isinstance(result.stochastic, mock.MockResult)
assert stochastic.hyper_name == "stochastic"
assert isinstance(stochastic, al.StochasticPhase)
# noinspection PyUnusedLocal
def run_hyper(*args, **kwargs):
return mock.MockResult()
stochastic.run_hyper = run_hyper
result = stochastic.run(dataset=imaging_7x7, results=results)
assert hasattr(result, "stochastic")
assert isinstance(result.stochastic, mock.MockResult)
def test__fit_figure_of_merit__matches_correct_fit_given_galaxy_profiles(
self, interferometer_7, mask_7x7, visibilities_mask_7
):
lens_galaxy = al.Galaxy(
redshift=0.5, light=al.lp.EllipticalSersic(intensity=0.1)
)
phase_interferometer_7 = al.PhaseInterferometer(
galaxies=dict(lens=lens_galaxy),
cosmology=cosmo.FLRW,
settings=al.SettingsPhaseInterferometer(
settings_masked_interferometer=al.SettingsMaskedInterferometer(
sub_size=2
)
),
search=mock.MockSearch("test_phase"),
real_space_mask=mask_7x7,
)
analysis = phase_interferometer_7.make_analysis(
dataset=interferometer_7,
mask=visibilities_mask_7,
results=mock.MockResults(),
)
instance = phase_interferometer_7.model.instance_from_unit_vector([])
fit_figure_of_merit = analysis.log_likelihood_function(instance=instance)
masked_interferometer = al.MaskedInterferometer(
interferometer=interferometer_7,
visibilities_mask=visibilities_mask_7,
real_space_mask=mask_7x7,
settings=al.SettingsMaskedInterferometer(sub_size=2),
)
tracer = analysis.tracer_for_instance(instance=instance)
fit = al.FitInterferometer(
masked_interferometer=masked_interferometer, tracer=tracer
)
assert fit.log_likelihood == fit_figure_of_merit
def test__fit_imaging_generator_from_aggregator(imaging_7x7, mask_7x7,
samples):
phase_imaging_7x7 = al.PhaseImaging(
galaxies=dict(
lens=al.GalaxyModel(redshift=0.5, light=al.lp.EllipticalSersic),
source=al.GalaxyModel(redshift=1.0, light=al.lp.EllipticalSersic),
),
search=mock.MockSearch("test_phase_aggregator", samples=samples),
)
phase_imaging_7x7.run(dataset=imaging_7x7,
mask=mask_7x7,
results=mock.MockResults(samples=samples))
agg = af.Aggregator(directory=phase_imaging_7x7.paths.output_path)
fit_imaging_gen = al.agg.FitImaging(aggregator=agg)
for fit_imaging in fit_imaging_gen:
assert (fit_imaging.masked_imaging.imaging.image == imaging_7x7.image
).all()
def test__fit_using_positions(self, positions_x2, positions_x2_noise_map,
samples_with_result):
phase_positions_x2 = al.PhasePointSource(
galaxies=dict(
lens=al.GalaxyModel(redshift=0.5,
light=al.lp.EllipticalSersic),
source=al.GalaxyModel(redshift=1.0, point=al.ps.PointSource),
),
search=mock.MockSearch(samples=samples_with_result),
positions_solver=mock.MockPositionsSolver(
model_positions=positions_x2),
)
result = phase_positions_x2.run(
positions=positions_x2,
positions_noise_map=positions_x2_noise_map,
results=mock.MockResults(),
)
assert isinstance(result.instance.galaxies[0], al.Galaxy)
assert isinstance(result.instance.galaxies[0], al.Galaxy)
def test__positions_do_not_trace_within_threshold__raises_exception(
self, phase_imaging_7x7, imaging_7x7, mask_7x7):
imaging_7x7.positions = al.Grid2DIrregular([(1.0, 100.0),
(200.0, 2.0)])
phase_imaging_7x7 = al.PhaseImaging(
galaxies=dict(
lens=al.Galaxy(redshift=0.5, mass=al.mp.SphericalIsothermal()),
source=al.Galaxy(redshift=1.0),
),
settings=al.SettingsPhaseImaging(settings_lens=al.SettingsLens(
positions_threshold=0.01)),
search=mock.MockSearch(),
)
analysis = phase_imaging_7x7.make_analysis(dataset=imaging_7x7,
mask=mask_7x7,
results=mock.MockResults())
instance = phase_imaging_7x7.model.instance_from_unit_vector([])
with pytest.raises(exc.RayTracingException):
analysis.log_likelihood_function(instance=instance)
def test__tracer_generator_from_aggregator(imaging_7x7, mask_7x7, samples):
phase_imaging_7x7 = al.PhaseImaging(
galaxies=dict(
lens=al.GalaxyModel(redshift=0.5, light=al.lp.EllipticalSersic),
source=al.GalaxyModel(redshift=1.0, light=al.lp.EllipticalSersic),
),
search=mock.MockSearch("test_phase_aggregator", samples=samples),
)
phase_imaging_7x7.run(
dataset=imaging_7x7, mask=mask_7x7, results=mock.MockResults(samples=samples)
)
agg = af.Aggregator(directory=phase_imaging_7x7.paths.output_path)
tracer_gen = al.agg.Tracer(aggregator=agg)
for tracer in tracer_gen:
assert tracer.galaxies[0].redshift == 0.5
assert tracer.galaxies[0].light.centre == (0.0, 1.0)
assert tracer.galaxies[1].redshift == 1.0
def test__max_log_likelihood_tracer_source_centres_correct(
self, imaging_7x7, mask_7x7):
lens = al.Galaxy(redshift=0.5,
light=al.lp.SphericalSersic(intensity=1.0))
source = al.Galaxy(
redshift=1.0,
light=al.lp.SphericalSersic(centre=(9.0, 8.0), intensity=2.0),
pixelization=al.pix.Rectangular((3, 3)),
regularization=al.reg.Constant(coefficient=1.0),
)
tracer = al.Tracer.from_galaxies(galaxies=[lens, source])
samples = mock.MockSamples(max_log_likelihood_instance=tracer)
phase_dataset_7x7 = al.PhaseImaging(
search=mock.MockSearch("test_phase_2", samples=samples))
result = phase_dataset_7x7.run(dataset=imaging_7x7,
mask=mask_7x7,
results=mock.MockResults())
assert result.source_plane_centres.in_grouped_list == [[(9.0, 8.0),
(0.0, 0.0)]]
def test___phase_info_is_made(self, phase_positions_x2, positions_x2,
positions_x2_noise_map):
phase_positions_x2.make_analysis(
positions=positions_x2,
positions_noise_map=positions_x2_noise_map,
results=mock.MockResults(),
)
file_phase_info = path.join(
phase_positions_x2.search.paths.output_path, "phase.info")
phase_info = open(file_phase_info, "r")
search = phase_info.readline()
cosmology = phase_info.readline()
phase_info.close()
assert search == "Optimizer = MockSearch \n"
assert (
cosmology ==
'Cosmology = FlatLambdaCDM(name="Planck15", H0=67.7 km / (Mpc s), Om0=0.307, Tcmb0=2.725 K, '
"Neff=3.05, m_nu=[0. 0. 0.06] eV, Ob0=0.0486) \n")
def test__figure_of_merit__includes_fit_fluxes(self, positions_x2,
positions_x2_noise_map,
fluxes_x2,
fluxes_x2_noise_map):
lens_galaxy = al.Galaxy(
redshift=0.5,
sis=al.mp.SphericalIsothermal(einstein_radius=1.0),
light=al.ps.PointSourceFlux(flux=1.0),
)
phase_positions_x2 = al.PhasePointSource(
galaxies=dict(lens=lens_galaxy),
settings=al.SettingsPhasePositions(),
search=mock.MockSearch(),
positions_solver=mock.MockPositionsSolver(
model_positions=positions_x2),
)
analysis = phase_positions_x2.make_analysis(
positions=positions_x2,
positions_noise_map=positions_x2_noise_map,
fluxes=fluxes_x2,
fluxes_noise_map=fluxes_x2_noise_map,
results=mock.MockResults(),
)
instance = phase_positions_x2.model.instance_from_unit_vector([])
fit_figure_of_merit = analysis.log_likelihood_function(
instance=instance)
tracer = analysis.tracer_for_instance(instance=instance)
positions_solver = mock.MockPositionsSolver(
model_positions=positions_x2)
fit_positions = al.FitPositionsImage(
positions=positions_x2,
noise_map=positions_x2_noise_map,
tracer=tracer,
positions_solver=positions_solver,
)
fit_fluxes = al.FitFluxes(
fluxes=fluxes_x2,
noise_map=fluxes_x2_noise_map,
positions=positions_x2,
tracer=tracer,
)
assert (fit_positions.log_likelihood +
fit_fluxes.log_likelihood == fit_figure_of_merit)
model_positions = al.Grid2DIrregular([(0.0, 1.0), (1.0, 2.0)])
positions_solver = mock.MockPositionsSolver(
model_positions=model_positions)
phase_positions_x2 = al.PhasePointSource(
galaxies=dict(lens=lens_galaxy),
settings=al.SettingsPhasePositions(),
search=mock.MockSearch(),
positions_solver=positions_solver,
)
analysis = phase_positions_x2.make_analysis(
positions=positions_x2,
positions_noise_map=positions_x2_noise_map,
results=mock.MockResults(),
)
instance = phase_positions_x2.model.instance_from_unit_vector([])
fit_figure_of_merit = analysis.log_likelihood_function(
instance=instance)
fit_positions = al.FitPositionsImage(
positions=positions_x2,
noise_map=positions_x2_noise_map,
tracer=tracer,
positions_solver=positions_solver,
)
assert fit_positions.residual_map.in_list == [1.0, 1.0]
assert fit_positions.chi_squared == 2.0
assert fit_positions.log_likelihood == fit_figure_of_merit
def test__max_log_likelihood_tracer__multiple_image_positions_of_source_plane_centres_and_separations(
self, imaging_7x7, mask_7x7):
lens = al.Galaxy(
redshift=0.5,
mass=al.mp.EllipticalIsothermal(
centre=(0.001, 0.001),
einstein_radius=1.0,
elliptical_comps=(0.0, 0.111111),
),
)
source = al.Galaxy(
redshift=1.0,
light=al.lp.SphericalSersic(centre=(0.0, 0.0), intensity=2.0),
light1=al.lp.SphericalSersic(centre=(0.0, 0.1), intensity=2.0),
pixelization=al.pix.Rectangular((3, 3)),
regularization=al.reg.Constant(coefficient=1.0),
)
tracer = al.Tracer.from_galaxies(galaxies=[lens, source])
samples = mock.MockSamples(max_log_likelihood_instance=tracer)
phase_dataset_7x7 = al.PhaseImaging(
search=mock.MockSearch("test_phase_2", samples=samples))
result = phase_dataset_7x7.run(dataset=imaging_7x7,
mask=mask_7x7,
results=mock.MockResults())
mask = al.Mask2D.unmasked(shape_2d=(100, 100),
pixel_scales=0.05,
sub_size=1)
result.analysis.masked_dataset.mask = mask
multiple_images = (
result.image_plane_multiple_image_positions_of_source_plane_centres
)
grid = al.Grid.from_mask(mask=mask)
solver = al.PositionsFinder(grid=grid, pixel_scale_precision=0.001)
multiple_images_manual_0 = solver.solve(lensing_obj=tracer,
source_plane_coordinate=(0.0,
0.0))
multiple_images_manual_1 = solver.solve(lensing_obj=tracer,
source_plane_coordinate=(0.0,
0.1))
multiple_images_manual_2 = solver.solve(
lensing_obj=tracer,
source_plane_coordinate=result.source_plane_inversion_centres[0],
)
assert (multiple_images.in_grouped_list[0] ==
multiple_images_manual_0.in_grouped_list[0])
assert (multiple_images.in_grouped_list[1] ==
multiple_images_manual_1.in_grouped_list[0])
assert (multiple_images.in_grouped_list[2] ==
multiple_images_manual_2.in_grouped_list[0])
def test__stochastic_log_evidences(self, masked_imaging_7x7):
lens_hyper_image = al.Array2D.ones(shape_native=(3, 3),
pixel_scales=0.1)
lens_hyper_image[4] = 10.0
source_hyper_image = al.Array2D.ones(shape_native=(3, 3),
pixel_scales=0.1)
source_hyper_image[4] = 10.0
hyper_model_image = al.Array2D.full(fill_value=0.5,
shape_native=(3, 3),
pixel_scales=0.1)
hyper_galaxy_image_path_dict = {
("galaxies", "lens"): lens_hyper_image,
("galaxies", "source"): source_hyper_image,
}
results = mock.MockResults(
use_as_hyper_dataset=True,
hyper_galaxy_image_path_dict=hyper_galaxy_image_path_dict,
hyper_model_image=hyper_model_image,
)
galaxies = af.ModelInstance()
galaxies.lens = al.Galaxy(
redshift=0.5, mass=al.mp.SphericalIsothermal(einstein_radius=1.0))
galaxies.source = al.Galaxy(
redshift=1.0,
pixelization=al.pix.VoronoiMagnification(shape=(3, 3)),
regularization=al.reg.Constant(),
)
instance = af.ModelInstance()
instance.galaxies = galaxies
analysis = al.PhaseImaging.Analysis(
masked_imaging=masked_imaging_7x7,
settings=al.SettingsPhaseImaging(),
results=results,
cosmology=cosmo.Planck15,
)
stochastic_log_evidences = analysis.stochastic_log_evidences_for_instance(
instance=instance)
assert stochastic_log_evidences == None
galaxies.source = al.Galaxy(
redshift=1.0,
pixelization=al.pix.VoronoiBrightnessImage(pixels=9),
regularization=al.reg.Constant(),
)
instance = af.ModelInstance()
instance.galaxies = galaxies
analysis = al.PhaseImaging.Analysis(
masked_imaging=masked_imaging_7x7,
settings=al.SettingsPhaseImaging(),
results=results,
cosmology=cosmo.Planck15,
)
stochastic_log_evidences = analysis.stochastic_log_evidences_for_instance(
instance=instance)
assert stochastic_log_evidences[0] != stochastic_log_evidences[1]
def test__uses_auto_update_factor(self, image_7x7, noise_map_7x7, mask_7x7):
tracer = al.Tracer.from_galaxies(
galaxies=[al.Galaxy(redshift=0.5), al.Galaxy(redshift=1.0)]
)
# Auto positioning is OFF, so use input positions + threshold.
imaging_7x7 = al.Imaging(
image=image_7x7,
noise_map=noise_map_7x7,
positions=al.GridIrregularGrouped([[(1.0, 1.0)]]),
)
phase_imaging_7x7 = al.PhaseImaging(
search=mock.MockSearch("test_phase"),
settings=al.SettingsPhaseImaging(
settings_lens=al.SettingsLens(positions_threshold=0.1)
),
)
results = mock.MockResults(max_log_likelihood_tracer=tracer)
phase_imaging_7x7.modify_dataset(dataset=imaging_7x7, results=results)
phase_imaging_7x7.modify_settings(dataset=imaging_7x7, results=results)
analysis = phase_imaging_7x7.make_analysis(
dataset=imaging_7x7, mask=mask_7x7, results=results
)
assert analysis.settings.settings_lens.positions_threshold == 0.1
# Auto positioning is ON, but there are no previous results, so use separate of postiions x positions factor..
imaging_7x7 = al.Imaging(
image=image_7x7,
noise_map=noise_map_7x7,
positions=al.GridIrregularGrouped([[(1.0, 0.0), (-1.0, 0.0)]]),
)
phase_imaging_7x7 = al.PhaseImaging(
search=mock.MockSearch("test_phase"),
settings=al.SettingsPhaseImaging(
settings_lens=al.SettingsLens(
positions_threshold=0.1, auto_positions_factor=1.0
)
),
)
results = mock.MockResults(max_log_likelihood_tracer=tracer)
phase_imaging_7x7.modify_dataset(dataset=imaging_7x7, results=results)
phase_imaging_7x7.modify_settings(dataset=imaging_7x7, results=results)
analysis = phase_imaging_7x7.make_analysis(
dataset=imaging_7x7, mask=mask_7x7, results=results
)
assert analysis.settings.settings_lens.positions_threshold == 2.0
# Auto position is ON, and same as above but with a factor of 3.0 which increases the threshold.
imaging_7x7 = al.Imaging(
image=image_7x7,
noise_map=noise_map_7x7,
positions=al.GridIrregularGrouped([[(1.0, 0.0), (-1.0, 0.0)]]),
)
phase_imaging_7x7 = al.PhaseImaging(
search=mock.MockSearch("test_phase"),
settings=al.SettingsPhaseImaging(
settings_lens=al.SettingsLens(
positions_threshold=0.2, auto_positions_factor=3.0
)
),
)
results = mock.MockResults(
max_log_likelihood_tracer=tracer, updated_positions_threshold=0.2
)
phase_imaging_7x7.modify_dataset(dataset=imaging_7x7, results=results)
phase_imaging_7x7.modify_settings(dataset=imaging_7x7, results=results)
analysis = phase_imaging_7x7.make_analysis(
dataset=imaging_7x7, mask=mask_7x7, results=results
)
assert analysis.settings.settings_lens.positions_threshold == 6.0
# Auto position is ON, and same as above but with a minimum auto positions threshold that rounds the value up.
imaging_7x7 = al.Imaging(
image=image_7x7,
noise_map=noise_map_7x7,
positions=al.GridIrregularGrouped([[(1.0, 0.0), (-1.0, 0.0)]]),
)
phase_imaging_7x7 = al.PhaseImaging(
search=mock.MockSearch("test_phase"),
settings=al.SettingsPhaseImaging(
settings_lens=al.SettingsLens(
positions_threshold=0.2,
auto_positions_factor=3.0,
auto_positions_minimum_threshold=10.0,
)
),
)
results = mock.MockResults(
max_log_likelihood_tracer=tracer, updated_positions_threshold=0.2
)
phase_imaging_7x7.modify_dataset(dataset=imaging_7x7, results=results)
phase_imaging_7x7.modify_settings(dataset=imaging_7x7, results=results)
analysis = phase_imaging_7x7.make_analysis(
dataset=imaging_7x7, mask=mask_7x7, results=results
)
assert analysis.settings.settings_lens.positions_threshold == 10.0
# Auto positioning is ON, but positions are None and it cannot find new positions so no threshold.
imaging_7x7 = al.Imaging(
image=image_7x7, noise_map=noise_map_7x7, positions=None
)
phase_imaging_7x7 = al.PhaseImaging(
search=mock.MockSearch("test_phase"),
settings=al.SettingsPhaseImaging(
settings_lens=al.SettingsLens(auto_positions_factor=1.0)
),
)
results = mock.MockResults(max_log_likelihood_tracer=tracer)
phase_imaging_7x7.modify_dataset(dataset=imaging_7x7, results=results)
phase_imaging_7x7.modify_settings(dataset=imaging_7x7, results=results)
analysis = phase_imaging_7x7.make_analysis(
dataset=imaging_7x7, mask=mask_7x7, results=results
)
assert analysis.settings.settings_lens.positions_threshold == None
def test__auto_einstein_radius_is_used__einstein_radius_used_in_analysis(
self, imaging_7x7, mask_7x7
):
# If position threshold is input (not None) and positions are input, make the positions part of the lens dataset.
class MockTracer:
def __init__(self, einstein_radius_via_tangential_critical_curve):
self.einstein_radius_via_tangential_critical_curve = (
einstein_radius_via_tangential_critical_curve
)
def einstein_radius_from_grid(self, grid):
return self.einstein_radius_via_tangential_critical_curve
@property
def has_mass_profile(self):
return True
phase_imaging_7x7 = al.PhaseImaging(
search=mock.MockSearch("test_phase"),
settings=al.SettingsPhaseImaging(
settings_lens=al.SettingsLens(auto_einstein_radius_factor=None)
),
)
tracer = MockTracer(einstein_radius_via_tangential_critical_curve=2.0)
phase_imaging_7x7.modify_settings(
dataset=imaging_7x7,
results=mock.MockResults(max_log_likelihood_tracer=tracer),
)
analysis = phase_imaging_7x7.make_analysis(
dataset=imaging_7x7, mask=mask_7x7, results=mock.MockResults()
)
assert analysis.settings.settings_lens.einstein_radius_estimate == None
phase_imaging_7x7 = al.PhaseImaging(
search=mock.MockSearch("test_phase"),
settings=al.SettingsPhaseImaging(
settings_lens=al.SettingsLens(auto_einstein_radius_factor=1.0)
),
)
tracer = MockTracer(einstein_radius_via_tangential_critical_curve=2.0)
phase_imaging_7x7.modify_settings(
dataset=imaging_7x7,
results=mock.MockResults(max_log_likelihood_tracer=tracer),
)
analysis = phase_imaging_7x7.make_analysis(
dataset=imaging_7x7,
mask=mask_7x7,
results=mock.MockResults(max_log_likelihood_tracer=tracer),
)
print(analysis.settings.settings_lens.einstein_radius_estimate)
assert analysis.settings.settings_lens.einstein_radius_estimate == 2.0
def test__updates_correct_using_factor(
self, imaging_7x7, image_7x7, noise_map_7x7, mask_7x7
):
tracer = al.Tracer.from_galaxies(
galaxies=[al.Galaxy(redshift=0.5), al.Galaxy(redshift=1.0)]
)
# Auto positioning is OFF, so use input positions + threshold.
imaging_7x7 = al.Imaging(
image=image_7x7,
noise_map=noise_map_7x7,
positions=al.GridIrregularGrouped([[(1.0, 1.0)]]),
)
phase_imaging_7x7 = al.PhaseImaging(
search=mock.MockSearch("test_phase"),
settings=al.SettingsPhaseImaging(
settings_lens=al.SettingsLens(positions_threshold=0.1)
),
)
results = mock.MockResults(max_log_likelihood_tracer=tracer)
phase_imaging_7x7.modify_dataset(dataset=imaging_7x7, results=results)
analysis = phase_imaging_7x7.make_analysis(
dataset=imaging_7x7, mask=mask_7x7, results=results
)
assert analysis.masked_dataset.positions.in_grouped_list == [[(1.0, 1.0)]]
# Auto positioning is ON, but there are no previous results, so use input positions.
imaging_7x7 = al.Imaging(
image=image_7x7,
noise_map=noise_map_7x7,
positions=al.GridIrregularGrouped([[(1.0, 1.0)]]),
)
phase_imaging_7x7 = al.PhaseImaging(
search=mock.MockSearch("test_phase"),
settings=al.SettingsPhaseImaging(
settings_lens=al.SettingsLens(
positions_threshold=0.2, auto_positions_factor=2.0
)
),
)
phase_imaging_7x7.modify_dataset(dataset=imaging_7x7, results=results)
analysis = phase_imaging_7x7.make_analysis(
dataset=imaging_7x7, mask=mask_7x7, results=results
)
assert analysis.masked_dataset.positions.in_grouped_list == [[(1.0, 1.0)]]
# Auto positioning is ON, there are previous results so use their new positions and threshold (which is
# multiplied by the auto_positions_factor). However, only one set of positions is computed from the previous
# result, to use input positions.
imaging_7x7 = al.Imaging(
image=image_7x7,
noise_map=noise_map_7x7,
positions=al.GridIrregularGrouped([[(1.0, 1.0)]]),
)
phase_imaging_7x7 = al.PhaseImaging(
search=mock.MockSearch("test_phase"),
settings=al.SettingsPhaseImaging(
settings_lens=al.SettingsLens(
positions_threshold=0.2, auto_positions_factor=2.0
)
),
)
results = mock.MockResults(
max_log_likelihood_tracer=tracer,
updated_positions=al.GridIrregularGrouped(grid=[[(2.0, 2.0)]]),
updated_positions_threshold=0.3,
)
phase_imaging_7x7.modify_dataset(dataset=imaging_7x7, results=results)
analysis = phase_imaging_7x7.make_analysis(
dataset=imaging_7x7, mask=mask_7x7, results=results
)
assert analysis.masked_dataset.positions.in_grouped_list == [[(1.0, 1.0)]]
# Auto positioning is ON, but the tracer only has a single plane and thus no lensing, so use input positions.
imaging_7x7 = al.Imaging(
image=image_7x7,
noise_map=noise_map_7x7,
positions=al.GridIrregularGrouped([[(1.0, 1.0)]]),
)
phase_imaging_7x7 = al.PhaseImaging(
search=mock.MockSearch("test_phase"),
settings=al.SettingsPhaseImaging(
settings_lens=al.SettingsLens(
positions_threshold=0.2, auto_positions_factor=1.0
)
),
)
tracer_x1_plane = al.Tracer.from_galaxies(galaxies=[al.Galaxy(redshift=0.5)])
results = mock.MockResults(
max_log_likelihood_tracer=tracer_x1_plane,
updated_positions=al.GridIrregularGrouped(grid=[[(2.0, 2.0), (3.0, 3.0)]]),
updated_positions_threshold=0.3,
)
phase_imaging_7x7.modify_dataset(dataset=imaging_7x7, results=results)
analysis = phase_imaging_7x7.make_analysis(
dataset=imaging_7x7, mask=mask_7x7, results=results
)
assert analysis.masked_dataset.positions.in_grouped_list == [[(1.0, 1.0)]]
# Auto positioning is ON, there are previous results so use their new positions and threshold (which is
# multiplied by the auto_positions_factor). Multiple positions are available so these are now used.
imaging_7x7 = al.Imaging(
image=image_7x7,
noise_map=noise_map_7x7,
positions=al.GridIrregularGrouped([[(1.0, 1.0)]]),
)
phase_imaging_7x7 = al.PhaseImaging(
search=mock.MockSearch("test_phase"),
settings=al.SettingsPhaseImaging(
settings_lens=al.SettingsLens(
positions_threshold=0.2, auto_positions_factor=2.0
)
),
)
results = mock.MockResults(
max_log_likelihood_tracer=tracer,
updated_positions=al.GridIrregularGrouped(grid=[[(2.0, 2.0), (3.0, 3.0)]]),
updated_positions_threshold=0.3,
)
phase_imaging_7x7.modify_dataset(dataset=imaging_7x7, results=results)
analysis = phase_imaging_7x7.make_analysis(
dataset=imaging_7x7, mask=mask_7x7, results=results
)
assert analysis.masked_dataset.positions.in_grouped_list == [
[(2.0, 2.0), (3.0, 3.0)]
]
# Auto positioning is Off, but there are previous results with updated positions relative to the input
# positions, so use those with their positions threshold.
imaging_7x7 = al.Imaging(
image=image_7x7,
noise_map=noise_map_7x7,
positions=al.GridIrregularGrouped([[(2.0, 2.0)]]),
)
phase_imaging_7x7 = al.PhaseImaging(
search=mock.MockSearch("test_phase"),
settings=al.SettingsPhaseImaging(
settings_lens=al.SettingsLens(positions_threshold=0.1)
),
)
results = mock.MockResults(
max_log_likelihood_tracer=tracer,
positions=al.GridIrregularGrouped(grid=[[(3.0, 3.0), (4.0, 4.0)]]),
updated_positions_threshold=0.3,
)
phase_imaging_7x7.modify_dataset(dataset=imaging_7x7, results=results)
analysis = phase_imaging_7x7.make_analysis(
dataset=imaging_7x7, mask=mask_7x7, results=results
)
assert analysis.masked_dataset.positions.in_grouped_list == [
[(3.0, 3.0), (4.0, 4.0)]
]
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__max_log_likelihood_tracer_source_light_profile_centres_correct(
self, imaging_7x7, mask_7x7):
lens = al.Galaxy(redshift=0.5,
light=al.lp.SphericalSersic(intensity=1.0))
source = al.Galaxy(redshift=1.0,
light=al.lp.SphericalSersic(centre=(1.0, 2.0),
intensity=2.0))
tracer = al.Tracer.from_galaxies(galaxies=[lens, source])
samples = mock.MockSamples(max_log_likelihood_instance=tracer)
phase_dataset_7x7 = al.PhaseImaging(
search=mock.MockSearch("test_phase_2", samples=samples))
result = phase_dataset_7x7.run(dataset=imaging_7x7,
mask=mask_7x7,
results=mock.MockResults())
assert result.source_plane_light_profile_centres.in_grouped_list == [[
(1.0, 2.0)
]]
source = al.Galaxy(
redshift=1.0,
light=al.lp.SphericalSersic(centre=(1.0, 2.0), intensity=2.0),
light1=al.lp.SphericalSersic(centre=(3.0, 4.0), intensity=2.0),
)
source_1 = al.Galaxy(redshift=1.0,
light=al.lp.SphericalSersic(centre=(5.0, 6.0),
intensity=2.0))
tracer = al.Tracer.from_galaxies(galaxies=[lens, source, source_1])
samples = mock.MockSamples(max_log_likelihood_instance=tracer)
phase_dataset_7x7 = al.PhaseImaging(
search=mock.MockSearch("test_phase_2", samples=samples))
result = phase_dataset_7x7.run(dataset=imaging_7x7,
mask=mask_7x7,
results=mock.MockResults())
assert result.source_plane_light_profile_centres.in_grouped_list == [
[(1.0, 2.0), (3.0, 4.0)],
[(5.0, 6.0)],
]
tracer = al.Tracer.from_galaxies(galaxies=[al.Galaxy(redshift=0.5)])
samples = mock.MockSamples(max_log_likelihood_instance=tracer)
phase_dataset_7x7 = al.PhaseImaging(
search=mock.MockSearch("test_phase_2", samples=samples))
result = phase_dataset_7x7.run(dataset=imaging_7x7,
mask=mask_7x7,
results=mock.MockResults())
assert result.source_plane_light_profile_centres == []
def test__phase_is_extended_with_hyper_phases__sets_up_hyper_images(
self, interferometer_7, mask_7x7):
galaxies = af.ModelInstance()
galaxies.lens = al.Galaxy(redshift=0.5)
galaxies.source = al.Galaxy(redshift=1.0)
instance = af.ModelInstance()
instance.galaxies = galaxies
hyper_galaxy_image_path_dict = {
("galaxies", "lens"):
al.Array2D.ones(shape_native=(3, 3), pixel_scales=1.0),
("galaxies", "source"):
al.Array2D.full(fill_value=2.0,
shape_native=(3, 3),
pixel_scales=1.0),
}
hyper_galaxy_visibilities_path_dict = {
("galaxies", "lens"):
al.Visibilities.full(fill_value=4.0, shape_slim=(7, )),
("galaxies", "source"):
al.Visibilities.full(fill_value=5.0, shape_slim=(7, )),
}
results = mock.MockResults(
hyper_galaxy_image_path_dict=hyper_galaxy_image_path_dict,
hyper_model_image=al.Array2D.full(fill_value=3.0,
shape_native=(3, 3),
pixel_scales=1.0),
hyper_galaxy_visibilities_path_dict=
hyper_galaxy_visibilities_path_dict,
hyper_model_visibilities=al.Visibilities.full(fill_value=6.0,
shape_slim=(7, )),
mask=mask_7x7,
use_as_hyper_dataset=True,
)
phase_interferometer_7 = al.PhaseInterferometer(
galaxies=dict(lens=al.GalaxyModel(redshift=0.5,
hyper_galaxy=al.HyperGalaxy)),
search=mock.MockSearch("test_phase"),
real_space_mask=mask_7x7,
)
phase_interferometer_7.extend_with_hyper_phase(
setup_hyper=al.SetupHyper())
analysis = phase_interferometer_7.make_analysis(
dataset=interferometer_7, mask=mask_7x7, results=results)
assert (analysis.hyper_galaxy_image_path_dict[(
"galaxies", "lens")].native == np.ones((3, 3))).all()
assert (analysis.hyper_galaxy_image_path_dict[(
"galaxies", "source")].native == 2.0 * np.ones((3, 3))).all()
assert (analysis.hyper_model_image.native == 3.0 * np.ones(
(3, 3))).all()
assert (analysis.hyper_galaxy_visibilities_path_dict[(
"galaxies", "lens")] == (4.0 + 4.0j) * np.ones((7, ))).all()
assert (analysis.hyper_galaxy_visibilities_path_dict[(
"galaxies", "source")] == (5.0 + 5.0j) * np.ones((7, ))).all()
assert (analysis.hyper_model_visibilities == (6.0 + 6.0j) * np.ones(
(7, ))).all()
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)
def test__figure_of_merit__matches_correct_fit_given_galaxy_profiles(
self, positions_x2, positions_x2_noise_map):
lens_galaxy = al.Galaxy(redshift=0.5,
light=al.ps.PointSource(centre=(0.0, 0.0)))
phase_positions_x2 = al.PhasePointSource(
galaxies=dict(lens=lens_galaxy),
settings=al.SettingsPhasePositions(),
search=mock.MockSearch(),
positions_solver=mock.MockPositionsSolver(
model_positions=positions_x2),
)
analysis = phase_positions_x2.make_analysis(
positions=positions_x2,
positions_noise_map=positions_x2_noise_map,
results=mock.MockResults(),
)
instance = phase_positions_x2.model.instance_from_unit_vector([])
fit_figure_of_merit = analysis.log_likelihood_function(
instance=instance)
tracer = analysis.tracer_for_instance(instance=instance)
positions_solver = mock.MockPositionsSolver(
model_positions=positions_x2)
fit_positions = al.FitPositionsImage(
positions=positions_x2,
noise_map=positions_x2_noise_map,
tracer=tracer,
positions_solver=positions_solver,
)
assert fit_positions.chi_squared == 0.0
assert fit_positions.log_likelihood == fit_figure_of_merit
model_positions = al.Grid2DIrregular([(0.0, 1.0), (1.0, 2.0)])
positions_solver = mock.MockPositionsSolver(
model_positions=model_positions)
phase_positions_x2 = al.PhasePointSource(
galaxies=dict(lens=lens_galaxy),
settings=al.SettingsPhasePositions(),
search=mock.MockSearch(),
positions_solver=positions_solver,
)
analysis = phase_positions_x2.make_analysis(
positions=positions_x2,
positions_noise_map=positions_x2_noise_map,
results=mock.MockResults(),
)
instance = phase_positions_x2.model.instance_from_unit_vector([])
fit_figure_of_merit = analysis.log_likelihood_function(
instance=instance)
fit_positions = al.FitPositionsImage(
positions=positions_x2,
noise_map=positions_x2_noise_map,
tracer=tracer,
positions_solver=positions_solver,
)
assert fit_positions.residual_map.in_list == [1.0, 1.0]
assert fit_positions.chi_squared == 2.0
assert fit_positions.log_likelihood == fit_figure_of_merit
def test__uses_hyper_fit_correctly(self, masked_imaging_7x7):
galaxies = af.ModelInstance()
galaxies.lens = al.Galaxy(
redshift=0.5,
light=al.lp.EllipticalSersic(intensity=1.0),
mass=al.mp.SphericalIsothermal,
)
galaxies.source = al.Galaxy(redshift=1.0,
light=al.lp.EllipticalSersic())
instance = af.ModelInstance()
instance.galaxies = galaxies
lens_hyper_image = al.Array2D.ones(shape_native=(3, 3),
pixel_scales=0.1)
lens_hyper_image[4] = 10.0
hyper_model_image = al.Array2D.full(fill_value=0.5,
shape_native=(3, 3),
pixel_scales=0.1)
hyper_galaxy_image_path_dict = {("galaxies", "lens"): lens_hyper_image}
results = mock.MockResults(
use_as_hyper_dataset=True,
hyper_galaxy_image_path_dict=hyper_galaxy_image_path_dict,
hyper_model_image=hyper_model_image,
)
analysis = al.PhaseImaging.Analysis(
masked_imaging=masked_imaging_7x7,
settings=al.SettingsPhaseImaging(),
results=results,
cosmology=cosmo.Planck15,
)
hyper_galaxy = al.HyperGalaxy(contribution_factor=1.0,
noise_factor=1.0,
noise_power=1.0)
instance.galaxies.lens.hyper_galaxy = hyper_galaxy
fit_likelihood = analysis.log_likelihood_function(instance=instance)
g0 = al.Galaxy(
redshift=0.5,
light_profile=instance.galaxies.lens.light,
mass_profile=instance.galaxies.lens.mass,
hyper_galaxy=hyper_galaxy,
hyper_model_image=hyper_model_image,
hyper_galaxy_image=lens_hyper_image,
hyper_minimum_value=0.0,
)
g1 = al.Galaxy(redshift=1.0,
light_profile=instance.galaxies.source.light)
tracer = al.Tracer.from_galaxies(galaxies=[g0, g1])
fit = FitImaging(masked_imaging=masked_imaging_7x7, tracer=tracer)
assert (fit.tracer.galaxies[0].hyper_galaxy_image == lens_hyper_image
).all()
assert fit_likelihood == fit.log_likelihood
