def test__mask_changes_sub_size_depending_on_phase_attribute(
self, phase_imaging_7x7, imaging_7x7):
# If an input mask is supplied we use mask input.
mask_input = al.Mask.circular(shape_2d=imaging_7x7.shape_2d,
pixel_scales=1,
sub_size=1,
radius=1.5)
phase_imaging_7x7.meta_dataset.sub_size = 1
analysis = phase_imaging_7x7.make_analysis(
dataset=imaging_7x7,
mask=mask_input,
results=mock_pipeline.MockResults())
assert (analysis.masked_imaging.mask == mask_input).all()
assert analysis.masked_imaging.mask.sub_size == 1
assert analysis.masked_imaging.mask.pixel_scales == mask_input.pixel_scales
phase_imaging_7x7.meta_dataset.sub_size = 2
analysis = phase_imaging_7x7.make_analysis(
dataset=imaging_7x7,
mask=mask_input,
results=mock_pipeline.MockResults())
assert (analysis.masked_imaging.mask == mask_input).all()
assert analysis.masked_imaging.mask.sub_size == 2
assert analysis.masked_imaging.mask.pixel_scales == mask_input.pixel_scales
def test__auto_positions_update_threshold__uses_auto_update_factor(
self,
phase_imaging_7x7,
phase_interferometer_7,
imaging_7x7,
interferometer_7,
mask_7x7,
):
# Auto positioning is OFF, so use input positions + threshold.
phase_imaging_7x7.meta_dataset.positions_threshold = 0.1
phase_imaging_7x7.meta_dataset.auto_positions_factor = None
analysis = phase_imaging_7x7.make_analysis(
dataset=imaging_7x7,
mask=mask_7x7,
positions=al.Coordinates(coordinates=[[(1.0, 1.0)]]),
results=mock_pipeline.MockResults(),
)
assert analysis.masked_dataset.positions_threshold == 0.1
# Auto positioning is ON, but there are no previous results, so use input positions.
phase_imaging_7x7.meta_dataset.auto_positions_factor = 1.0
analysis = phase_imaging_7x7.make_analysis(
dataset=imaging_7x7,
mask=mask_7x7,
positions=al.Coordinates(coordinates=[[(1.0, 0.0), (-1.0, 0.0)]]),
results=mock_pipeline.MockResults(),
)
assert analysis.masked_dataset.positions_threshold == 2.0
phase_imaging_7x7.meta_dataset.positions_threshold = 0.2
phase_imaging_7x7.meta_dataset.auto_positions_factor = 3.0
analysis = phase_imaging_7x7.make_analysis(
dataset=imaging_7x7,
mask=mask_7x7,
positions=al.Coordinates(coordinates=[[(1.0, 0.0), (-1.0, 0.0)]]),
results=mock_pipeline.MockResults(updated_positions_threshold=0.2),
)
assert analysis.masked_dataset.positions_threshold == 6.0
# Auto positioning is ON, but positionos are None so no update.
phase_imaging_7x7.meta_dataset.auto_positions_factor = 1.0
phase_imaging_7x7.positions_threshold = None
analysis = phase_imaging_7x7.make_analysis(
dataset=imaging_7x7, mask=mask_7x7, results=mock_pipeline.MockResults()
)
assert analysis.masked_dataset.positions_threshold == None
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],
cosmology=cosmo.Planck15,
phase_name="test_phase",
inversion_uses_border=True,
)
analysis = phase_imaging_7x7.make_analysis(
dataset=imaging_7x7, mask=mask_7x7, results=mock_pipeline.MockResults()
)
analysis.masked_dataset.grid[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(
galaxies=[lens_galaxy, source_galaxy],
cosmology=cosmo.Planck15,
phase_name="test_phase",
inversion_uses_border=False,
)
analysis = phase_imaging_7x7.make_analysis(
dataset=imaging_7x7, mask=mask_7x7, results=mock_pipeline.MockResults()
)
analysis.masked_dataset.grid[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__most_likely_tracer_source_inversion_centres_correct(
self, imaging_7x7, mask_7x7):
phase_dataset_7x7 = al.PhaseImaging(
non_linear_class=mock_pipeline.MockNLO,
galaxies=dict(
lens=al.Galaxy(redshift=0.5,
light=al.lp.EllipticalSersic(intensity=1.0)),
source=al.Galaxy(
redshift=1.0,
pixelization=al.pix.Rectangular((3, 3)),
regularization=al.reg.Constant(coefficient=1.0),
),
),
phase_name="test_phase_2",
)
result = phase_dataset_7x7.run(dataset=imaging_7x7,
mask=mask_7x7,
results=mock_pipeline.MockResults())
assert result.most_likely_fit.inversion.reconstruction == pytest.approx(
np.array([
0.80707817,
0.80929118,
0.80707817,
0.80929118,
0.81251066,
0.80929118,
0.80707817,
0.80929118,
0.80707817,
]),
1.0e-4,
)
assert result.source_plane_inversion_centres == [(0.0, 0.0)]
phase_dataset_7x7 = al.PhaseImaging(
non_linear_class=mock_pipeline.MockNLO,
galaxies=dict(
lens=al.Galaxy(redshift=0.5,
light=al.lp.EllipticalSersic(intensity=1.0)),
source=al.Galaxy(redshift=1.0),
),
phase_name="test_phase_2",
)
result = phase_dataset_7x7.run(dataset=imaging_7x7,
mask=mask_7x7,
results=mock_pipeline.MockResults())
assert result.source_plane_inversion_centres == []
def test__results_of_phase_include_pixelization__available_as_property(
self, imaging_7x7, mask_7x7):
phase_imaging_7x7 = al.PhaseImaging(
non_linear_class=mock_pipeline.MockNLO,
galaxies=dict(
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(),
),
),
inversion_pixel_limit=6,
phase_name="test_phase_2",
)
result = phase_imaging_7x7.run(dataset=imaging_7x7,
mask=mask_7x7,
results=mock_pipeline.MockResults())
assert isinstance(result.pixelization, al.pix.VoronoiMagnification)
assert result.pixelization.shape == (2, 3)
phase_imaging_7x7 = al.PhaseImaging(
non_linear_class=mock_pipeline.MockNLO,
galaxies=dict(
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(),
),
),
inversion_pixel_limit=6,
phase_name="test_phase_2",
)
phase_imaging_7x7.galaxies.source.hyper_galaxy_image = np.ones(9)
result = phase_imaging_7x7.run(dataset=imaging_7x7,
mask=mask_7x7,
results=mock_pipeline.MockResults())
assert isinstance(result.pixelization, al.pix.VoronoiBrightnessImage)
assert result.pixelization.pixels == 6
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(
real_space_mask=mask_7x7,
galaxies=[lens_galaxy],
cosmology=cosmo.FLRW,
sub_size=2,
phase_name="test_phase",
)
analysis = phase_interferometer_7.make_analysis(
dataset=interferometer_7,
mask=visibilities_mask_7x2,
results=mock_pipeline.MockResults(),
)
instance = phase_interferometer_7.model.instance_from_unit_vector([])
fit_figure_of_merit = analysis.fit(instance=instance)
real_space_mask = phase_interferometer_7.meta_dataset.mask_with_phase_sub_size_from_mask(
mask=mask_7x7)
masked_interferometer = al.MaskedInterferometer(
interferometer=interferometer_7,
visibilities_mask=visibilities_mask_7x2,
real_space_mask=real_space_mask,
)
tracer = analysis.tracer_for_instance(instance=instance)
fit = al.FitInterferometer(masked_interferometer=masked_interferometer,
tracer=tracer)
assert fit.likelihood == fit_figure_of_merit
def make_results(mask_7x7, hyper_model_image_7x7, hyper_galaxy_image_0_7x7,
hyper_galaxy_image_1_7x7):
return mock_pipeline.MockResults(
model_image=hyper_model_image_7x7,
galaxy_images=[hyper_galaxy_image_0_7x7, hyper_galaxy_image_1_7x7],
mask=mask_7x7,
)
def test__phase_info_is_made(self, phase_interferometer_7,
interferometer_7, visibilities_mask_7x2):
phase_interferometer_7.make_analysis(
dataset=interferometer_7,
mask=visibilities_mask_7x2,
results=mock_pipeline.MockResults(),
)
file_phase_info = "{}/{}".format(
phase_interferometer_7.optimizer.paths.phase_output_path,
"phase.info")
phase_info = open(file_phase_info, "r")
optimizer = phase_info.readline()
sub_size = phase_info.readline()
primary_beam_shape_2d = phase_info.readline()
positions_threshold = phase_info.readline()
cosmology = phase_info.readline()
phase_info.close()
assert optimizer == "Optimizer = MockNLO \n"
assert sub_size == "Sub-grid size = 2 \n"
assert primary_beam_shape_2d == "Primary Beam shape = None \n"
assert positions_threshold == "Positions Threshold = None \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__customize(self, imaging_7x7, mask_7x7):
class MyPlanePhaseAnd(al.PhaseImaging):
def customize_priors(self, results):
self.galaxies = results.last.instance.galaxies
results = mock_pipeline.MockResults()
galaxy = al.Galaxy(redshift=0.5)
galaxy_model = al.GalaxyModel(redshift=0.5)
setattr(results[0].instance, "galaxies", [galaxy])
setattr(results[0].model, "galaxies", [galaxy_model])
phase_dataset_7x7 = MyPlanePhaseAnd(
phase_name="test_phase", non_linear_class=mock_pipeline.MockNLO)
phase_dataset_7x7.make_analysis(dataset=imaging_7x7,
mask=mask_7x7,
results=results)
phase_dataset_7x7.customize_priors(results=results)
assert phase_dataset_7x7.galaxies == [galaxy]
class MyPlanePhaseAnd(al.PhaseImaging):
def customize_priors(self, results):
self.galaxies = results.last.model.galaxies
results = mock_pipeline.MockResults()
galaxy = al.Galaxy(redshift=0.5)
galaxy_model = al.GalaxyModel(redshift=0.5)
setattr(results[0].instance, "galaxies", [galaxy])
setattr(results[0].model, "galaxies", [galaxy_model])
phase_dataset_7x7 = MyPlanePhaseAnd(
phase_name="test_phase", non_linear_class=mock_pipeline.MockNLO)
phase_dataset_7x7.make_analysis(dataset=imaging_7x7,
mask=mask_7x7,
results=results)
phase_dataset_7x7.customize_priors(results)
assert phase_dataset_7x7.galaxies == [galaxy_model]
def test__uses_pixelization_preload_grids_if_possible(
self, imaging_7x7, mask_7x7):
phase_dataset_7x7 = al.PhaseImaging(phase_name="test_phase")
analysis = phase_dataset_7x7.make_analysis(
dataset=imaging_7x7,
mask=mask_7x7,
results=mock_pipeline.MockResults())
assert analysis.masked_dataset.preload_sparse_grids_of_planes is None
def test__pixel_scale_interpolation_grid_is_input__interp_grid_used_in_analysis(
self, phase_imaging_7x7, imaging_7x7, mask_7x7):
# If use positions is true and positions are input, make the positions part of the lens dataset.
phase_imaging_7x7.meta_dataset.pixel_scale_interpolation_grid = 0.1
analysis = phase_imaging_7x7.make_analysis(
dataset=imaging_7x7,
mask=mask_7x7,
results=mock_pipeline.MockResults())
assert analysis.masked_imaging.pixel_scale_interpolation_grid == 0.1
assert hasattr(analysis.masked_imaging.grid, "interpolator")
assert hasattr(analysis.masked_imaging.blurring_grid, "interpolator")
def test__masks_visibilities_and_noise_map_correctly(
self, phase_interferometer_7, interferometer_7,
visibilities_mask_7x2):
analysis = phase_interferometer_7.make_analysis(
dataset=interferometer_7,
mask=visibilities_mask_7x2,
results=mock_pipeline.MockResults(),
)
assert (analysis.masked_interferometer.visibilities ==
interferometer_7.visibilities).all()
assert (analysis.masked_interferometer.noise_map ==
interferometer_7.noise_map).all()
def test__positions_are_input__are_used_in_analysis(
self, phase_imaging_7x7, imaging_7x7, mask_7x7):
# If position threshold is input (not None) and positions are input, make the positions part of the lens dataset.
phase_imaging_7x7.meta_dataset.positions_threshold = 0.2
analysis = phase_imaging_7x7.make_analysis(
dataset=imaging_7x7,
mask=mask_7x7,
positions=[[(1.0, 1.0), (2.0, 2.0)]],
results=mock_pipeline.MockResults(),
)
assert (analysis.masked_dataset.positions[0][0] == np.array([1.0, 1.0
])).all()
assert (analysis.masked_dataset.positions[0][1] == np.array([2.0, 2.0
])).all()
assert analysis.masked_imaging.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):
phase_imaging_7x7.meta_dataset.positions_threshold = 0.2
phase_imaging_7x7.make_analysis(
dataset=imaging_7x7,
mask=mask_7x7,
positions=None,
results=mock_pipeline.MockResults(),
)
phase_imaging_7x7.meta_dataset.positions_threshold = 0.2
phase_imaging_7x7.make_analysis(
dataset=imaging_7x7,
mask=mask_7x7,
results=mock_pipeline.MockResults())
def test__results_of_phase_include_positions__available_as_property(
self, imaging_7x7, mask_7x7):
phase_imaging_7x7 = al.PhaseImaging(
non_linear_class=mock_pipeline.MockNLO,
galaxies=[
al.Galaxy(redshift=0.5,
light=al.lp.EllipticalSersic(intensity=1.0))
],
phase_name="test_phase_2",
)
result = phase_imaging_7x7.run(dataset=imaging_7x7,
mask=mask_7x7,
results=mock_pipeline.MockResults())
assert result.positions == None
phase_imaging_7x7 = al.PhaseImaging(
non_linear_class=mock_pipeline.MockNLO,
galaxies=dict(
lens=al.Galaxy(redshift=0.5,
light=al.lp.EllipticalSersic(intensity=1.0)),
source=al.Galaxy(redshift=1.0),
),
positions_threshold=1.0,
phase_name="test_phase_2",
)
result = phase_imaging_7x7.run(
dataset=imaging_7x7,
mask=mask_7x7,
positions=[[(1.0, 1.0)]],
results=mock_pipeline.MockResults(),
)
assert (result.positions[0] == np.array([1.0, 1.0])).all()
def test__mask_input_uses_mask(self, phase_imaging_7x7, imaging_7x7):
# If an input mask is supplied we use mask input.
mask_input = al.Mask.circular(shape_2d=imaging_7x7.shape_2d,
pixel_scales=1.0,
sub_size=1,
radius=1.5)
analysis = phase_imaging_7x7.make_analysis(
dataset=imaging_7x7,
mask=mask_input,
results=mock_pipeline.MockResults())
assert (analysis.masked_imaging.mask == mask_input).all()
assert analysis.masked_imaging.mask.pixel_scales == mask_input.pixel_scales
def test__results_of_phase_are_available_as_properties(
self, imaging_7x7, mask_7x7):
phase_dataset_7x7 = al.PhaseImaging(
non_linear_class=mock_pipeline.MockNLO,
galaxies=[
al.Galaxy(redshift=0.5,
light=al.lp.EllipticalSersic(intensity=1.0))
],
phase_name="test_phase_2",
)
result = phase_dataset_7x7.run(dataset=imaging_7x7,
mask=mask_7x7,
results=mock_pipeline.MockResults())
assert isinstance(result, al.AbstractPhase.Result)
def test__associate_images(self, masked_imaging_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
),
}
results = mock_pipeline.MockResults(
instance=instance,
hyper_galaxy_image_path_dict=hyper_galaxy_image_path_dict,
hyper_model_image=al.Array.full(fill_value=3.0, shape_2d=(3, 3)),
use_as_hyper_dataset=True,
)
analysis = al.PhaseImaging.Analysis(
masked_imaging=masked_imaging_7x7,
cosmology=cosmo.Planck15,
image_path="files/",
results=results,
)
instance = analysis.associate_hyper_images(instance=instance)
assert instance.galaxies.lens.hyper_galaxy_image.in_2d == pytest.approx(
np.ones((3, 3)), 1.0e-4
)
assert instance.galaxies.source.hyper_galaxy_image.in_2d == pytest.approx(
2.0 * np.ones((3, 3)), 1.0e-4
)
assert instance.galaxies.lens.hyper_model_image.in_2d == pytest.approx(
3.0 * np.ones((3, 3)), 1.0e-4
)
assert instance.galaxies.source.hyper_model_image.in_2d == pytest.approx(
3.0 * np.ones((3, 3)), 1.0e-4
)
def test__results_of_phase_include_mask__available_as_property(
self, imaging_7x7, mask_7x7):
phase_imaging_7x7 = al.PhaseImaging(
non_linear_class=mock_pipeline.MockNLO,
galaxies=[
al.Galaxy(redshift=0.5,
light=al.lp.EllipticalSersic(intensity=1.0))
],
sub_size=2,
phase_name="test_phase_2",
)
result = phase_imaging_7x7.run(dataset=imaging_7x7,
mask=mask_7x7,
results=mock_pipeline.MockResults())
assert (result.mask == mask_7x7).all()
def test__most_likely_tracer__multiple_image_positions_of_source_plane_centres_and_separations(
self, imaging_7x7, mask_7x7):
phase_dataset_7x7 = al.PhaseImaging(
non_linear_class=mock_pipeline.MockNLO,
galaxies=dict(
lens=al.Galaxy(
redshift=0.5,
mass=al.mp.EllipticalIsothermal(centre=(0.001, 0.001),
einstein_radius=1.0,
axis_ratio=0.8),
),
source=al.Galaxy(
redshift=1.0,
light=al.lp.EllipticalCoreSersic(centre=(0.0, 0.0),
intensity=2.0),
light1=al.lp.EllipticalCoreSersic(centre=(0.0, 0.0),
intensity=2.0),
),
),
phase_name="test_phase_2",
)
result = phase_dataset_7x7.run(dataset=imaging_7x7,
mask=mask_7x7,
results=mock_pipeline.MockResults())
# TODO : Again, we'll remove this need to pass a mask around when the Tracer uses an adaptive gird..
result.analysis.masked_dataset.mask = al.Mask.unmasked(
shape_2d=(100, 100), pixel_scales=0.05, sub_size=1)
coordinates = (
result.image_plane_multiple_image_positions_of_source_plane_centres
)
assert coordinates[0][0] == pytest.approx((1.025, -0.025), 1.0e-4)
assert coordinates[0][1] == pytest.approx((0.025, -0.975), 1.0e-4)
assert coordinates[0][2] == pytest.approx((0.025, 0.975), 1.0e-4)
assert coordinates[0][3] == pytest.approx((-1.025, -0.025), 1.0e-4)
assert coordinates[1][0] == pytest.approx((1.025, -0.025), 1.0e-4)
assert coordinates[1][1] == pytest.approx((0.025, -0.975), 1.0e-4)
assert coordinates[1][2] == pytest.approx((0.025, 0.975), 1.0e-4)
assert coordinates[1][3] == pytest.approx((-1.025, -0.025), 1.0e-4)
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(
real_space_mask=mask_7x7,
galaxies=[lens_galaxy],
hyper_background_noise=hyper_background_noise,
cosmology=cosmo.FLRW,
sub_size=4,
phase_name="test_phase",
)
analysis = phase_interferometer_7.make_analysis(
dataset=interferometer_7,
mask=visibilities_mask_7x2,
results=mock_pipeline.MockResults(),
)
instance = phase_interferometer_7.model.instance_from_unit_vector([])
fit_figure_of_merit = analysis.fit(instance=instance)
real_space_mask = phase_interferometer_7.meta_dataset.mask_with_phase_sub_size_from_mask(
mask=mask_7x7)
assert real_space_mask.sub_size == 4
masked_interferometer = al.MaskedInterferometer(
interferometer=interferometer_7,
visibilities_mask=visibilities_mask_7x2,
real_space_mask=real_space_mask,
)
tracer = analysis.tracer_for_instance(instance=instance)
fit = FitInterferometer(
masked_interferometer=masked_interferometer,
tracer=tracer,
hyper_background_noise=hyper_background_noise,
)
assert fit.likelihood == fit_figure_of_merit
def test__masked_imaging_generator_from_aggregator(imaging_7x7, mask_7x7):
phase_imaging_7x7 = al.PhaseImaging(
non_linear_class=mock_pipeline.MockNLO,
galaxies=dict(
lens=al.GalaxyModel(redshift=0.5, light=al.lp.EllipticalSersic),
source=al.GalaxyModel(redshift=1.0, light=al.lp.EllipticalSersic),
),
phase_name="test_phase_aggregator",
)
phase_imaging_7x7.run(dataset=imaging_7x7,
mask=mask_7x7,
results=mock_pipeline.MockResults())
agg = af.Aggregator(directory=phase_imaging_7x7.paths.phase_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()
def test__fit_using_interferometer(self, interferometer_7, mask_7x7,
visibilities_mask_7x2):
phase_interferometer_7 = al.PhaseInterferometer(
non_linear_class=mock_pipeline.MockNLO,
galaxies=dict(
lens=al.GalaxyModel(redshift=0.5,
light=al.lp.EllipticalSersic),
source=al.GalaxyModel(redshift=1.0,
light=al.lp.EllipticalSersic),
),
real_space_mask=mask_7x7,
phase_name="test_phase_test_fit",
)
result = phase_interferometer_7.run(
dataset=interferometer_7,
mask=visibilities_mask_7x2,
results=mock_pipeline.MockResults(),
)
assert isinstance(result.instance.galaxies[0], al.Galaxy)
assert isinstance(result.instance.galaxies[0], al.Galaxy)
def test__most_likely_tracer_available_as_result(self, imaging_7x7,
mask_7x7):
phase_dataset_7x7 = al.PhaseImaging(
non_linear_class=mock_pipeline.MockNLO,
galaxies=dict(
lens=al.Galaxy(redshift=0.5,
light=al.lp.EllipticalSersic(intensity=1.0)),
source=al.Galaxy(
redshift=1.0,
light=al.lp.EllipticalCoreSersic(intensity=2.0)),
),
phase_name="test_phase_2",
)
result = phase_dataset_7x7.run(dataset=imaging_7x7,
mask=mask_7x7,
results=mock_pipeline.MockResults())
assert isinstance(result.most_likely_tracer, al.Tracer)
assert result.most_likely_tracer.galaxies[0].light.intensity == 1.0
assert result.most_likely_tracer.galaxies[1].light.intensity == 2.0
def test__most_likely_tracer_source_centres_correct(
self, imaging_7x7, mask_7x7):
phase_dataset_7x7 = al.PhaseImaging(
non_linear_class=mock_pipeline.MockNLO,
galaxies=dict(
lens=al.Galaxy(redshift=0.5,
light=al.lp.EllipticalSersic(intensity=1.0)),
source=al.Galaxy(
redshift=1.0,
light=al.lp.EllipticalCoreSersic(centre=(9.0, 8.0),
intensity=2.0),
pixelization=al.pix.Rectangular((3, 3)),
regularization=al.reg.Constant(coefficient=1.0),
),
),
phase_name="test_phase_2",
)
result = phase_dataset_7x7.run(dataset=imaging_7x7,
mask=mask_7x7,
results=mock_pipeline.MockResults())
assert result.source_plane_centres == [(9.0, 8.0), (0.0, 0.0)]
def test__tracer_generator_from_aggregator(imaging_7x7, mask_7x7):
phase_imaging_7x7 = al.PhaseImaging(
non_linear_class=mock_pipeline.MockNLO,
galaxies=dict(
lens=al.GalaxyModel(redshift=0.5, light=al.lp.EllipticalSersic),
source=al.GalaxyModel(redshift=1.0, light=al.lp.EllipticalSersic),
),
phase_name="test_phase_aggregator",
)
phase_imaging_7x7.run(dataset=imaging_7x7,
mask=mask_7x7,
results=mock_pipeline.MockResults())
agg = af.Aggregator(directory=phase_imaging_7x7.paths.phase_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__positions_do_not_trace_within_threshold__raises_exception(
self, phase_imaging_7x7, imaging_7x7, mask_7x7):
phase_imaging_7x7 = al.PhaseImaging(
galaxies=dict(source=al.Galaxy(redshift=0.5)),
positions_threshold=50.0,
cosmology=cosmo.FLRW,
phase_name="test_phase",
)
analysis = phase_imaging_7x7.make_analysis(
dataset=imaging_7x7,
mask=mask_7x7,
positions=[[(1.0, 1.0), (2.0, 2.0)]],
results=mock_pipeline.MockResults(),
)
instance = phase_imaging_7x7.model.instance_from_unit_vector([])
tracer = analysis.tracer_for_instance(instance=instance)
analysis.masked_dataset.check_positions_trace_within_threshold_via_tracer(
tracer=tracer)
phase_imaging_7x7 = al.PhaseImaging(
galaxies=dict(source=al.Galaxy(redshift=0.5)),
positions_threshold=0.0,
cosmology=cosmo.FLRW,
phase_name="test_phase",
)
analysis = phase_imaging_7x7.make_analysis(
dataset=imaging_7x7,
mask=mask_7x7,
positions=[[(1.0, 1.0), (2.0, 2.0)]],
results=mock_pipeline.MockResults(),
)
instance = phase_imaging_7x7.model.instance_from_unit_vector([])
tracer = analysis.tracer_for_instance(instance=instance)
with pytest.raises(exc.RayTracingException):
analysis.masked_dataset.check_positions_trace_within_threshold_via_tracer(
tracer=tracer)
phase_imaging_7x7 = al.PhaseImaging(
galaxies=dict(source=al.Galaxy(redshift=0.5)),
positions_threshold=0.5,
cosmology=cosmo.FLRW,
phase_name="test_phase",
)
analysis = phase_imaging_7x7.make_analysis(
dataset=imaging_7x7,
mask=mask_7x7,
positions=[[(1.0, 0.0), (-1.0, 0.0)]],
results=mock_pipeline.MockResults(),
)
tracer = al.Tracer.from_galaxies(galaxies=[
al.Galaxy(redshift=0.5,
mass=al.mp.SphericalIsothermal(einstein_radius=1.0)),
al.Galaxy(redshift=1.0),
])
analysis.masked_dataset.check_positions_trace_within_threshold_via_tracer(
tracer=tracer)
tracer = al.Tracer.from_galaxies(galaxies=[
al.Galaxy(redshift=0.5,
mass=al.mp.SphericalIsothermal(einstein_radius=0.0)),
al.Galaxy(redshift=1.0),
])
with pytest.raises(exc.RayTracingException):
analysis.masked_dataset.check_positions_trace_within_threshold_via_tracer(
tracer=tracer)
analysis = phase_imaging_7x7.make_analysis(
dataset=imaging_7x7,
mask=mask_7x7,
positions=[[(0.0, 0.0), (0.0, 0.0)], [(0.0, 0.0), (0.0, 0.0)]],
results=mock_pipeline.MockResults(),
)
instance = phase_imaging_7x7.model.instance_from_unit_vector([])
tracer = analysis.tracer_for_instance(instance=instance)
analysis.masked_dataset.check_positions_trace_within_threshold_via_tracer(
tracer=tracer)
analysis = phase_imaging_7x7.make_analysis(
dataset=imaging_7x7,
mask=mask_7x7,
positions=[[(0.0, 0.0), (0.0, 0.0)], [(100.0, 0.0), (0.0, 0.0)]],
results=mock_pipeline.MockResults(),
)
instance = phase_imaging_7x7.model.instance_from_unit_vector([])
tracer = analysis.tracer_for_instance(instance=instance)
with pytest.raises(exc.RayTracingException):
analysis.masked_dataset.check_positions_trace_within_threshold_via_tracer(
tracer=tracer)
def test__determines_if_pixelization_is_same_as_previous_phase(
self, imaging_7x7, mask_7x7):
results = mock_pipeline.MockResults()
results.last.hyper_combined.preload_sparse_grids_of_planes = 1
phase_imaging_7x7 = al.PhaseImaging(phase_name="test_phase")
results.last.pixelization = None
analysis = phase_imaging_7x7.make_analysis(dataset=imaging_7x7,
mask=mask_7x7,
results=results)
assert analysis.masked_dataset.preload_sparse_grids_of_planes is None
phase_imaging_7x7 = al.PhaseImaging(phase_name="test_phase")
results.last.pixelization = al.pix.Rectangular
analysis = phase_imaging_7x7.make_analysis(dataset=imaging_7x7,
mask=mask_7x7,
results=results)
assert analysis.masked_dataset.preload_sparse_grids_of_planes is None
phase_imaging_7x7 = al.PhaseImaging(
phase_name="test_phase",
galaxies=[
al.Galaxy(
redshift=0.5,
pixelization=al.pix.Rectangular,
regularization=al.reg.Constant,
)
],
)
results.last.pixelization = None
analysis = phase_imaging_7x7.make_analysis(dataset=imaging_7x7,
mask=mask_7x7,
results=results)
assert analysis.masked_dataset.preload_sparse_grids_of_planes is None
phase_imaging_7x7 = al.PhaseImaging(
phase_name="test_phase",
galaxies=[
al.Galaxy(
redshift=0.5,
pixelization=al.pix.Rectangular,
regularization=al.reg.Constant,
)
],
)
results.last.pixelization = al.pix.Rectangular
analysis = phase_imaging_7x7.make_analysis(dataset=imaging_7x7,
mask=mask_7x7,
results=results)
assert analysis.masked_dataset.preload_sparse_grids_of_planes == 1
def test__inversion_resolution_error_raised_if_above_inversion_pixel_limit(
self, phase_imaging_7x7, imaging_7x7, mask_7x7):
phase_imaging_7x7 = al.PhaseImaging(
galaxies=dict(source=al.Galaxy(
redshift=0.5,
pixelization=al.pix.Rectangular(shape=(3, 3)),
regularization=al.reg.Constant(),
)),
inversion_pixel_limit=10,
cosmology=cosmo.FLRW,
phase_name="test_phase",
)
analysis = phase_imaging_7x7.make_analysis(
dataset=imaging_7x7,
mask=mask_7x7,
results=mock_pipeline.MockResults())
instance = phase_imaging_7x7.model.instance_from_unit_vector([])
tracer = analysis.tracer_for_instance(instance=instance)
analysis.masked_dataset.check_inversion_pixels_are_below_limit_via_tracer(
tracer=tracer)
phase_imaging_7x7 = al.PhaseImaging(
galaxies=dict(source=al.Galaxy(
redshift=0.5,
pixelization=al.pix.Rectangular(shape=(4, 4)),
regularization=al.reg.Constant(),
)),
inversion_pixel_limit=10,
cosmology=cosmo.FLRW,
phase_name="test_phase",
)
analysis = phase_imaging_7x7.make_analysis(
dataset=imaging_7x7,
mask=mask_7x7,
results=mock_pipeline.MockResults())
instance = phase_imaging_7x7.model.instance_from_unit_vector([])
tracer = analysis.tracer_for_instance(instance=instance)
with pytest.raises(exc.PixelizationException):
analysis.masked_dataset.check_inversion_pixels_are_below_limit_via_tracer(
tracer=tracer)
analysis.fit(instance=instance)
phase_imaging_7x7 = al.PhaseImaging(
galaxies=dict(source=al.Galaxy(
redshift=0.5,
pixelization=al.pix.Rectangular(shape=(3, 3)),
regularization=al.reg.Constant(),
)),
inversion_pixel_limit=10,
cosmology=cosmo.FLRW,
phase_name="test_phase",
)
analysis = phase_imaging_7x7.make_analysis(
dataset=imaging_7x7,
mask=mask_7x7,
results=mock_pipeline.MockResults())
instance = phase_imaging_7x7.model.instance_from_unit_vector([])
tracer = analysis.tracer_for_instance(instance=instance)
analysis.masked_dataset.check_inversion_pixels_are_below_limit_via_tracer(
tracer=tracer)
phase_imaging_7x7 = al.PhaseImaging(
galaxies=dict(source=al.Galaxy(
redshift=0.5,
pixelization=al.pix.Rectangular(shape=(4, 4)),
regularization=al.reg.Constant(),
)),
inversion_pixel_limit=10,
cosmology=cosmo.FLRW,
phase_name="test_phase",
)
analysis = phase_imaging_7x7.make_analysis(
dataset=imaging_7x7,
mask=mask_7x7,
results=mock_pipeline.MockResults())
instance = phase_imaging_7x7.model.instance_from_unit_vector([])
tracer = analysis.tracer_for_instance(instance=instance)
with pytest.raises(exc.PixelizationException):
analysis.masked_dataset.check_inversion_pixels_are_below_limit_via_tracer(
tracer=tracer)
analysis.fit(instance=instance)
def test__most_likely_tracer_source_light_profile_centres_correct(
self, imaging_7x7, mask_7x7):
phase_dataset_7x7 = al.PhaseImaging(
non_linear_class=mock_pipeline.MockNLO,
galaxies=dict(
lens=al.Galaxy(redshift=0.5,
light=al.lp.EllipticalSersic(intensity=1.0)),
source=al.Galaxy(
redshift=1.0,
light=al.lp.EllipticalCoreSersic(centre=(1.0, 2.0),
intensity=2.0),
),
),
phase_name="test_phase_2",
)
result = phase_dataset_7x7.run(dataset=imaging_7x7,
mask=mask_7x7,
results=mock_pipeline.MockResults())
assert result.source_plane_light_profile_centres == [(1.0, 2.0)]
phase_dataset_7x7 = al.PhaseImaging(
non_linear_class=mock_pipeline.MockNLO,
galaxies=dict(
lens=al.Galaxy(redshift=0.5,
light=al.lp.EllipticalSersic(intensity=1.0)),
source=al.Galaxy(
redshift=1.0,
light=al.lp.EllipticalCoreSersic(centre=(1.0, 2.0),
intensity=2.0),
light1=al.lp.EllipticalCoreSersic(centre=(3.0, 4.0),
intensity=2.0),
),
source1=al.Galaxy(
redshift=1.0,
light=al.lp.EllipticalCoreSersic(centre=(5.0, 6.0),
intensity=2.0),
),
),
phase_name="test_phase_2",
)
result = phase_dataset_7x7.run(dataset=imaging_7x7,
mask=mask_7x7,
results=mock_pipeline.MockResults())
assert result.source_plane_light_profile_centres == [
(1.0, 2.0),
(3.0, 4.0),
(5.0, 6.0),
]
phase_dataset_7x7 = al.PhaseImaging(
non_linear_class=mock_pipeline.MockNLO,
galaxies=dict(lens=al.Galaxy(redshift=0.5)),
phase_name="test_phase_2",
)
result = phase_dataset_7x7.run(dataset=imaging_7x7,
mask=mask_7x7,
results=mock_pipeline.MockResults())
assert result.source_plane_light_profile_centres == []
def test__auto_positions_update__updates_correct_using_factor(
self,
phase_imaging_7x7,
phase_interferometer_7,
imaging_7x7,
interferometer_7,
mask_7x7,
):
# Auto positioning is OFF, so use input positions + threshold.
phase_imaging_7x7.meta_dataset.positions_threshold = 0.1
phase_imaging_7x7.meta_dataset.auto_positions_factor = None
analysis = phase_imaging_7x7.make_analysis(
dataset=imaging_7x7,
mask=mask_7x7,
positions=al.Coordinates(coordinates=[[(1.0, 1.0)]]),
results=mock_pipeline.MockResults(),
)
assert analysis.masked_dataset.positions == [[(1.0, 1.0)]]
# Auto positioning is ON, but there are no previous results, so use input positions.
phase_imaging_7x7.meta_dataset.positions_threshold = 0.2
phase_imaging_7x7.meta_dataset.auto_positions_factor = 1.0
analysis = phase_imaging_7x7.make_analysis(
dataset=imaging_7x7,
mask=mask_7x7,
positions=al.Coordinates(coordinates=[[(1.0, 1.0)]]),
results=mock_pipeline.MockResults(),
)
assert analysis.masked_dataset.positions == [[(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.
phase_imaging_7x7.meta_dataset.positions_threshold = 0.2
phase_imaging_7x7.meta_dataset.auto_positions_factor = 2.0
results = mock_pipeline.MockResults(
updated_positions=al.Coordinates(coordinates=[[(2.0, 2.0)]]),
updated_positions_threshold=0.3,
)
analysis = phase_imaging_7x7.make_analysis(
dataset=imaging_7x7,
mask=mask_7x7,
positions=al.Coordinates(coordinates=[[(1.0, 1.0)]]),
results=results,
)
assert analysis.masked_dataset.positions == [[(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.
phase_imaging_7x7.meta_dataset.positions_threshold = 0.2
phase_imaging_7x7.meta_dataset.auto_positions_factor = 2.0
results = mock_pipeline.MockResults(
updated_positions=al.Coordinates(coordinates=[[(2.0, 2.0), (3.0, 3.0)]]),
updated_positions_threshold=0.3,
)
analysis = phase_imaging_7x7.make_analysis(
dataset=imaging_7x7,
mask=mask_7x7,
positions=al.Coordinates(coordinates=[[(1.0, 1.0)]]),
results=results,
)
assert analysis.masked_dataset.positions == [[(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.
phase_imaging_7x7.meta_dataset.positions_threshold = 0.1
phase_imaging_7x7.meta_dataset.auto_positions_factor = None
analysis = phase_imaging_7x7.make_analysis(
dataset=imaging_7x7,
mask=mask_7x7,
positions=al.Coordinates(coordinates=[[(2.0, 2.0)]]),
results=mock_pipeline.MockResults(
positions=al.Coordinates(coordinates=[[(3.0, 3.0), (4.0, 4.0)]]),
updated_positions_threshold=0.3,
),
)
assert analysis.masked_dataset.positions == [[(3.0, 3.0), (4.0, 4.0)]]
# Test function is called for phase_inteferometer
phase_interferometer_7.meta_dataset.positions_threshold = None
phase_interferometer_7.meta_dataset.auto_positions_factor = 2.0
analysis = phase_interferometer_7.make_analysis(
dataset=interferometer_7,
mask=mask_7x7,
positions=al.Coordinates(coordinates=[[(1.0, 1.0)]]),
results=mock_pipeline.MockResults(
updated_positions=al.Coordinates(coordinates=[[(1.0, 1.0)]]),
updated_positions_threshold=0.3,
),
)
assert analysis.masked_dataset.positions == [[(1.0, 1.0)]]
