def test__results_of_phase_include_positions__available_as_property(
self, imaging_7x7, mask_7x7, samples_with_result
):
phase_imaging_7x7 = al.PhaseImaging(
phase_name="test_phase", search=mock.MockSearch(samples=samples_with_result)
)
result = phase_imaging_7x7.run(
dataset=imaging_7x7, mask=mask_7x7, results=mock.MockResults()
)
assert result.positions == None
phase_imaging_7x7 = al.PhaseImaging(
phase_name="test_phase",
galaxies=dict(lens=al.Galaxy(redshift=0.5), source=al.Galaxy(redshift=1.0)),
search=mock.MockSearch(samples=samples_with_result),
settings=al.SettingsPhaseImaging(
settings_lens=al.SettingsLens(positions_threshold=1.0)
),
)
imaging_7x7.positions = al.GridCoordinates([[(1.0, 1.0)]])
result = phase_imaging_7x7.run(
dataset=imaging_7x7, mask=mask_7x7, results=mock.MockResults()
)
assert (result.positions[0] == np.array([1.0, 1.0])).all()
def test__results_of_phase_include_pixelization__available_as_property(
self, imaging_7x7, mask_7x7
):
lens = al.Galaxy(redshift=0.5, light=al.lp.EllipticalSersic(intensity=1.0))
source = al.Galaxy(
redshift=1.0,
pixelization=al.pix.VoronoiMagnification(shape=(2, 3)),
regularization=al.reg.Constant(),
)
tracer = al.Tracer.from_galaxies(galaxies=[lens, source])
samples = mock.MockSamples(max_log_likelihood_instance=tracer)
phase_imaging_7x7 = al.PhaseImaging(
phase_name="test_phase",
settings=al.SettingsPhaseImaging(),
search=mock.MockSearch(samples=samples),
)
result = phase_imaging_7x7.run(
dataset=imaging_7x7, mask=mask_7x7, results=mock.MockResults()
)
assert isinstance(result.pixelization, al.pix.VoronoiMagnification)
assert result.pixelization.shape == (2, 3)
lens = al.Galaxy(redshift=0.5, light=al.lp.EllipticalSersic(intensity=1.0))
source = al.Galaxy(
redshift=1.0,
pixelization=al.pix.VoronoiBrightnessImage(pixels=6),
regularization=al.reg.Constant(),
)
source.hyper_galaxy_image = np.ones(9)
tracer = al.Tracer.from_galaxies(galaxies=[lens, source])
samples = mock.MockSamples(max_log_likelihood_instance=tracer)
phase_imaging_7x7 = al.PhaseImaging(
phase_name="test_phase",
settings=al.SettingsPhaseImaging(),
search=mock.MockSearch(samples=samples),
)
result = phase_imaging_7x7.run(
dataset=imaging_7x7, mask=mask_7x7, results=mock.MockResults()
)
assert isinstance(result.pixelization, al.pix.VoronoiBrightnessImage)
assert result.pixelization.pixels == 6
def test__positions_are_input__are_used_in_analysis(
self, image_7x7, noise_map_7x7, mask_7x7):
# If position threshold is input (not None) and positions are input, make the positions part of the lens dataset.
imaging_7x7 = al.Imaging(
image=image_7x7,
noise_map=noise_map_7x7,
positions=al.GridCoordinates([[(1.0, 1.0), (2.0, 2.0)]]),
)
phase_imaging_7x7 = al.PhaseImaging(
phase_name="test_phase",
search=mock.MockSearch(),
settings=al.SettingsPhaseImaging(settings_lens=al.SettingsLens(
positions_threshold=0.2)),
)
phase_imaging_7x7.modify_dataset(dataset=imaging_7x7,
results=mock.MockResults())
phase_imaging_7x7.modify_settings(dataset=imaging_7x7,
results=mock.MockResults())
analysis = phase_imaging_7x7.make_analysis(dataset=imaging_7x7,
mask=mask_7x7,
results=mock.MockResults())
assert (analysis.masked_dataset.positions.in_list[0][0] == np.array(
[1.0, 1.0])).all()
assert (analysis.masked_dataset.positions.in_list[0][1] == np.array(
[2.0, 2.0])).all()
assert analysis.settings.settings_lens.positions_threshold == 0.2
# If position threshold is input (not None) and but no positions are supplied, raise an error
with pytest.raises(exc.PhaseException):
imaging_7x7 = al.Imaging(image=image_7x7,
noise_map=noise_map_7x7,
positions=None)
phase_imaging_7x7 = al.PhaseImaging(
phase_name="test_phase",
search=mock.MockSearch(),
settings=al.SettingsPhaseImaging(settings_lens=al.SettingsLens(
positions_threshold=0.2)),
)
phase_imaging_7x7.modify_dataset(dataset=imaging_7x7,
results=mock.MockResults())
phase_imaging_7x7.modify_settings(dataset=imaging_7x7,
results=mock.MockResults())
def test__fit_interferometer_generator_from_aggregator(interferometer_7,
mask_7x7, samples):
phase_interferometer_7x7 = al.PhaseInterferometer(
phase_name="test_phase_aggregator",
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(samples=samples),
real_space_mask=mask_7x7,
)
phase_interferometer_7x7.run(
dataset=interferometer_7,
mask=mask_7x7,
results=mock.MockResults(samples=samples),
)
agg = af.Aggregator(directory=phase_interferometer_7x7.paths.output_path)
fit_interferometer_gen = al.agg.FitInterferometer(aggregator=agg)
for fit_interferometer in fit_interferometer_gen:
assert (fit_interferometer.masked_interferometer.interferometer.
visibilities == interferometer_7.visibilities).all()
assert (fit_interferometer.masked_interferometer.real_space_mask ==
mask_7x7).all()
def test__masked_imaging_generator_from_aggregator(imaging_7x7, mask_7x7,
samples):
phase_imaging_7x7 = al.PhaseImaging(
phase_name="test_phase_aggregator",
galaxies=dict(
lens=al.GalaxyModel(redshift=0.5, light=al.lp.EllipticalSersic),
source=al.GalaxyModel(redshift=1.0, light=al.lp.EllipticalSersic),
),
settings=al.SettingsPhaseImaging(
settings_masked_imaging=al.SettingsMaskedImaging(
grid_class=al.GridIterate,
grid_inversion_class=al.GridInterpolate,
fractional_accuracy=0.5,
sub_steps=[2],
pixel_scales_interp=0.1,
)),
search=mock.MockSearch(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)
masked_imaging_gen = al.agg.MaskedImaging(aggregator=agg)
for masked_imaging in masked_imaging_gen:
assert (masked_imaging.imaging.image == imaging_7x7.image).all()
assert isinstance(masked_imaging.grid, al.GridIterate)
assert isinstance(masked_imaging.grid_inversion, al.GridInterpolate)
assert masked_imaging.grid.sub_steps == [2]
assert masked_imaging.grid.fractional_accuracy == 0.5
assert masked_imaging.grid_inversion.pixel_scales_interp == (0.1, 0.1)
def test__positions_do_not_trace_within_threshold__raises_exception(
self, phase_interferometer_7, interferometer_7, mask_7x7, visibilities_mask_7x2
):
interferometer_7.positions = al.GridCoordinates([[(1.0, 100.0), (200.0, 2.0)]])
phase_interferometer_7 = al.PhaseInterferometer(
phase_name="test_phase",
real_space_mask=mask_7x7,
galaxies=dict(
lens=al.Galaxy(redshift=0.5, mass=al.mp.SphericalIsothermal()),
source=al.Galaxy(redshift=1.0),
),
settings=al.SettingsPhaseInterferometer(
settings_lens=al.SettingsLens(positions_threshold=0.01)
),
search=mock.MockSearch(),
)
analysis = phase_interferometer_7.make_analysis(
dataset=interferometer_7,
mask=visibilities_mask_7x2,
results=mock.MockResults(),
)
instance = phase_interferometer_7.model.instance_from_unit_vector([])
with pytest.raises(exc.RayTracingException):
analysis.log_likelihood_function(instance=instance)
def __init__(self):
self.phase_name = "phase_name"
self.paths = autofit.non_linear.paths.Paths(
name=self.phase_name, path_prefix="phase_path", folders=("",), tag=""
)
self.search = mock.MockSearch(paths=self.paths)
self.model = af.ModelMapper()
self.settings = al.SettingsPhaseImaging(log_likelihood_cap=None)
self.meta_dataset = MockMetaDataset(settings=self.settings)
def make_stochastic():
normal_phase = MockPhase()
# noinspection PyUnusedLocal
def run_hyper(*args, **kwargs):
return mock.MockResult()
return al.StochasticPhase(
phase=normal_phase, search=mock.MockSearch(), model_classes=(al.mp.MassProfile,)
)
def test__results_of_phase_include_mask__available_as_property(
self, imaging_7x7, mask_7x7, samples_with_result
):
phase_imaging_7x7 = al.PhaseImaging(
phase_name="test_phase",
galaxies=dict(lens=al.Galaxy(redshift=0.5), source=al.Galaxy(redshift=1.0)),
search=mock.MockSearch(samples=samples_with_result),
settings=al.SettingsPhaseImaging(
settings_masked_imaging=al.SettingsMaskedImaging(sub_size=2)
),
)
result = phase_imaging_7x7.run(
dataset=imaging_7x7, mask=mask_7x7, results=mock.MockResults()
)
assert (result.mask == mask_7x7).all()
def test__masked_interferometer_generator_from_aggregator(
interferometer_7, mask_7x7, samples):
phase_interferometer_7x7 = al.PhaseInterferometer(
phase_name="test_phase_aggregator",
galaxies=dict(
lens=al.GalaxyModel(redshift=0.5, light=al.lp.EllipticalSersic),
source=al.GalaxyModel(redshift=1.0, light=al.lp.EllipticalSersic),
),
settings=al.SettingsPhaseInterferometer(
masked_interferometer=al.SettingsMaskedInterferometer(
transformer_class=al.TransformerDFT,
grid_class=al.GridIterate,
grid_inversion_class=al.GridInterpolate,
fractional_accuracy=0.5,
sub_steps=[2],
pixel_scales_interp=0.1,
)),
search=mock.MockSearch(samples=samples),
real_space_mask=mask_7x7,
)
phase_interferometer_7x7.run(
dataset=interferometer_7,
mask=mask_7x7,
results=mock.MockResults(samples=samples),
)
agg = af.Aggregator(directory=phase_interferometer_7x7.paths.output_path)
masked_interferometer_gen = al.agg.MaskedInterferometer(aggregator=agg)
for masked_interferometer in masked_interferometer_gen:
assert (masked_interferometer.interferometer.visibilities ==
interferometer_7.visibilities).all()
assert (masked_interferometer.real_space_mask == mask_7x7).all()
assert isinstance(masked_interferometer.grid, al.GridIterate)
assert isinstance(masked_interferometer.grid_inversion,
al.GridInterpolate)
assert masked_interferometer.grid.sub_steps == [2]
assert masked_interferometer.grid.fractional_accuracy == 0.5
assert masked_interferometer.grid_inversion.pixel_scales_interp == (
0.1, 0.1)
assert isinstance(masked_interferometer.transformer, al.TransformerDFT)
def test__fit_figure_of_merit__includes_hyper_image_and_noise__matches_fit(
self, interferometer_7, mask_7x7, visibilities_mask_7x2
):
hyper_background_noise = al.hyper_data.HyperBackgroundNoise(noise_scale=1.0)
lens_galaxy = al.Galaxy(
redshift=0.5, light=al.lp.EllipticalSersic(intensity=0.1)
)
phase_interferometer_7 = al.PhaseInterferometer(
phase_name="test_phase",
galaxies=dict(lens=lens_galaxy),
hyper_background_noise=hyper_background_noise,
settings=al.SettingsPhaseInterferometer(
masked_interferometer=al.SettingsMaskedInterferometer(sub_size=4)
),
search=mock.MockSearch(),
real_space_mask=mask_7x7,
)
analysis = phase_interferometer_7.make_analysis(
dataset=interferometer_7,
mask=visibilities_mask_7x2,
results=mock.MockResults(),
)
instance = phase_interferometer_7.model.instance_from_unit_vector([])
fit_figure_of_merit = analysis.log_likelihood_function(instance=instance)
assert analysis.masked_interferometer.real_space_mask.sub_size == 4
masked_interferometer = al.MaskedInterferometer(
interferometer=interferometer_7,
visibilities_mask=visibilities_mask_7x2,
real_space_mask=mask_7x7,
settings=al.SettingsMaskedInterferometer(sub_size=4),
)
tracer = analysis.tracer_for_instance(instance=instance)
fit = FitInterferometer(
masked_interferometer=masked_interferometer,
tracer=tracer,
hyper_background_noise=hyper_background_noise,
)
assert fit.log_likelihood == fit_figure_of_merit
def test__phase_can_receive_hyper_image_and_noise_maps(self, mask_7x7):
phase_interferometer_7 = al.PhaseInterferometer(
phase_name="test_phase",
galaxies=dict(
lens=al.GalaxyModel(redshift=al.Redshift),
lens1=al.GalaxyModel(redshift=al.Redshift),
),
hyper_background_noise=al.hyper_data.HyperBackgroundNoise,
search=mock.MockSearch(),
real_space_mask=mask_7x7,
)
instance = phase_interferometer_7.model.instance_from_vector(
[0.1, 0.2, 0.3])
assert instance.galaxies[0].redshift == 0.1
assert instance.galaxies[1].redshift == 0.2
assert instance.hyper_background_noise.noise_scale == 0.3
def test__fit_using_interferometer(
self, interferometer_7, mask_7x7, visibilities_mask_7x2, samples_with_result
):
phase_interferometer_7 = al.PhaseInterferometer(
phase_name="test_phase",
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(samples=samples_with_result),
real_space_mask=mask_7x7,
)
result = phase_interferometer_7.run(
dataset=interferometer_7,
mask=visibilities_mask_7x2,
results=mock.MockResults(),
)
assert isinstance(result.instance.galaxies[0], al.Galaxy)
assert isinstance(result.instance.galaxies[0], al.Galaxy)
def test__fit_figure_of_merit__matches_correct_fit_given_galaxy_profiles(
self, interferometer_7, mask_7x7, visibilities_mask_7x2
):
lens_galaxy = al.Galaxy(
redshift=0.5, light=al.lp.EllipticalSersic(intensity=0.1)
)
phase_interferometer_7 = al.PhaseInterferometer(
phase_name="test_phase",
galaxies=dict(lens=lens_galaxy),
cosmology=cosmo.FLRW,
settings=al.SettingsPhaseInterferometer(
masked_interferometer=al.SettingsMaskedInterferometer(sub_size=2)
),
search=mock.MockSearch(),
real_space_mask=mask_7x7,
)
analysis = phase_interferometer_7.make_analysis(
dataset=interferometer_7,
mask=visibilities_mask_7x2,
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_7x2,
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__log_likelihood_cap(self, interferometer_7, mask_7x7):
lens_galaxy = al.Galaxy(redshift=0.5,
light=al.lp.EllipticalSersic(intensity=0.1))
phase_imaging_7x7 = al.PhaseInterferometer(
phase_name="test_phase",
galaxies=dict(lens=lens_galaxy),
settings=al.SettingsPhaseInterferometer(
masked_interferometer=al.SettingsMaskedInterferometer(
sub_size=1),
log_likelihood_cap=100.0,
),
search=mock.MockSearch(),
real_space_mask=mask_7x7,
)
analysis = phase_imaging_7x7.make_analysis(dataset=interferometer_7,
mask=mask_7x7,
results=mock.MockResults())
assert analysis.log_likelihood_cap == 100.0
def test__fit_imaging_generator_from_aggregator(imaging_7x7, mask_7x7,
samples):
phase_imaging_7x7 = al.PhaseImaging(
phase_name="test_phase_aggregator",
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(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__tracer_generator_from_aggregator(imaging_7x7, mask_7x7, samples):
phase_imaging_7x7 = al.PhaseImaging(
phase_name="test_phase_aggregator",
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(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__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(
phase_name="test_phase",
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(),
)
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.grid[4][0] == pytest.approx(
97.19584, 1.0e-2)
assert fit.inversion.mapper.grid[4][1] == pytest.approx(
-3.699999, 1.0e-2)
phase_imaging_7x7 = al.PhaseImaging(
phase_name="test_phase",
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(),
)
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.grid[4][0] == pytest.approx(200.0, 1.0e-4)
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.GridCoordinates([[(1.0, 1.0)]]),
)
phase_imaging_7x7 = al.PhaseImaging(
phase_name="test_phase",
search=mock.MockSearch(),
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.GridCoordinates([[(1.0, 0.0), (-1.0, 0.0)]]),
)
phase_imaging_7x7 = al.PhaseImaging(
phase_name="test_phase",
search=mock.MockSearch(),
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.GridCoordinates([[(1.0, 0.0), (-1.0, 0.0)]]),
)
phase_imaging_7x7 = al.PhaseImaging(
phase_name="test_phase",
search=mock.MockSearch(),
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.GridCoordinates([[(1.0, 0.0), (-1.0, 0.0)]]),
)
phase_imaging_7x7 = al.PhaseImaging(
phase_name="test_phase",
search=mock.MockSearch(),
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(
phase_name="test_phase",
search=mock.MockSearch(),
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__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.GridCoordinates([[(1.0, 1.0)]]),
)
phase_imaging_7x7 = al.PhaseImaging(
phase_name="test_phase",
search=mock.MockSearch(),
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_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.GridCoordinates([[(1.0, 1.0)]]),
)
phase_imaging_7x7 = al.PhaseImaging(
phase_name="test_phase",
search=mock.MockSearch(),
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_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.GridCoordinates([[(1.0, 1.0)]]),
)
phase_imaging_7x7 = al.PhaseImaging(
phase_name="test_phase",
search=mock.MockSearch(),
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.GridCoordinates(coordinates=[[(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_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.GridCoordinates([[(1.0, 1.0)]]),
)
phase_imaging_7x7 = al.PhaseImaging(
phase_name="test_phase",
search=mock.MockSearch(),
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.GridCoordinates(coordinates=[[(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_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.GridCoordinates([[(1.0, 1.0)]]),
)
phase_imaging_7x7 = al.PhaseImaging(
phase_name="test_phase",
search=mock.MockSearch(),
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.GridCoordinates(coordinates=[[(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_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.GridCoordinates([[(2.0, 2.0)]]),
)
phase_imaging_7x7 = al.PhaseImaging(
phase_name="test_phase",
search=mock.MockSearch(),
settings=al.SettingsPhaseImaging(settings_lens=al.SettingsLens(
positions_threshold=0.1)),
)
results = mock.MockResults(
max_log_likelihood_tracer=tracer,
positions=al.GridCoordinates(coordinates=[[(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_list == [[(3.0, 3.0),
(4.0, 4.0)]]
def make_phase_data(mask_7x7):
return al.PhaseDataset(phase_name="test_phase", search=mock.MockSearch())
def make_phase_imaging_7x7():
return al.PhaseImaging(phase_name="test_phase", search=mock.MockSearch())
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.Array.ones(shape_2d=(3, 3), pixel_scales=1.0),
("galaxies", "source"):
al.Array.full(fill_value=2.0, shape_2d=(3, 3), pixel_scales=1.0),
}
hyper_galaxy_visibilities_path_dict = {
("galaxies", "lens"):
al.Visibilities.full(fill_value=4.0, shape_1d=(7, )),
("galaxies", "source"):
al.Visibilities.full(fill_value=5.0, shape_1d=(7, )),
}
results = mock.MockResults(
hyper_galaxy_image_path_dict=hyper_galaxy_image_path_dict,
hyper_model_image=al.Array.full(fill_value=3.0, shape_2d=(3, 3)),
hyper_galaxy_visibilities_path_dict=
hyper_galaxy_visibilities_path_dict,
hyper_model_visibilities=al.Visibilities.full(fill_value=6.0,
shape_1d=(7, )),
mask=mask_7x7,
use_as_hyper_dataset=True,
)
phase_interferometer_7 = al.PhaseInterferometer(
phase_name="test_phase",
galaxies=dict(lens=al.GalaxyModel(redshift=0.5,
hyper_galaxy=al.HyperGalaxy)),
search=mock.MockSearch(),
real_space_mask=mask_7x7,
)
phase_interferometer_7.extend_with_multiple_hyper_phases(
setup=al.SetupPipeline())
analysis = phase_interferometer_7.make_analysis(
dataset=interferometer_7, mask=mask_7x7, results=results)
assert (analysis.hyper_galaxy_image_path_dict[(
"galaxies", "lens")].in_2d == np.ones((3, 3))).all()
assert (analysis.hyper_galaxy_image_path_dict[(
"galaxies", "source")].in_2d == 2.0 * np.ones((3, 3))).all()
assert (analysis.hyper_model_image.in_2d == 3.0 * np.ones(
(3, 3))).all()
assert (analysis.hyper_galaxy_visibilities_path_dict[("galaxies",
"lens")] == 4.0 *
np.ones((7, 2))).all()
assert (analysis.hyper_galaxy_visibilities_path_dict[(
"galaxies", "source")] == 5.0 * np.ones((7, 2))).all()
assert (analysis.hyper_model_visibilities == 6.0 * np.ones(
(7, 2))).all()
def test__masked_interferometer__settings_inputs_are_used_in_masked_interferometer(
self, interferometer_7, mask_7x7):
phase_interferometer_7 = al.PhaseInterferometer(
phase_name="phase_interferometer_7",
settings=al.SettingsPhaseInterferometer(
masked_interferometer=al.SettingsMaskedInterferometer(
grid_class=al.Grid,
grid_inversion_class=al.Grid,
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),
),
search=mock.MockSearch(),
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.Grid)
assert isinstance(analysis.masked_dataset.grid_inversion, al.Grid)
assert isinstance(analysis.masked_dataset.transformer,
al.TransformerNUFFT)
phase_interferometer_7 = al.PhaseInterferometer(
phase_name="phase_interferometer_7",
settings=al.SettingsPhaseInterferometer(
masked_interferometer=al.SettingsMaskedInterferometer(
grid_class=al.GridIterate,
sub_size=3,
fractional_accuracy=0.99,
sub_steps=[2],
transformer_class=al.TransformerDFT,
)),
search=mock.MockSearch(),
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.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]
assert isinstance(analysis.masked_dataset.transformer,
al.TransformerDFT)
def make_phase_interferometer_7(mask_7x7):
return al.PhaseInterferometer(
phase_name="test_phase", search=mock.MockSearch(), real_space_mask=mask_7x7
)
