def test__same_as_above_with_real_tracer(self):
tracer = al.Tracer.from_galaxies(
galaxies=[
al.Galaxy(
redshift=0.5, mass=al.mp.SphericalIsothermal(einstein_radius=1.0)
),
al.Galaxy(redshift=1.0),
]
)
noise_map = al.ValuesIrregularGrouped([[1.0, 1.0]])
positions = al.GridIrregularGrouped([[(1.0, 0.0), (-1.0, 0.0)]])
fit = al.FitPositionsSourceMaxSeparation(
positions=positions, noise_map=noise_map, tracer=tracer
)
assert fit.max_separation_within_threshold(threshold=0.01)
positions = al.GridIrregularGrouped([[(1.2, 0.0), (-1.0, 0.0)]])
fit = al.FitPositionsSourceMaxSeparation(
positions=positions, noise_map=noise_map, tracer=tracer
)
assert fit.max_separation_within_threshold(threshold=0.3)
assert not fit.max_separation_within_threshold(threshold=0.15)
def test__furthest_separation_of_source_plane_positions(self):
positions = al.GridIrregularGrouped(grid=[[(0.0, 0.0), (0.0, 1.0)]])
noise_map = al.ValuesIrregularGrouped([[1.0, 1.0]])
tracer = MockTracerPositions(positions=positions)
fit = al.FitPositionsSourceMaxSeparation(
positions=positions, noise_map=noise_map, tracer=tracer
)
assert fit.furthest_separations_of_source_plane_positions.in_grouped_list == [
[1.0, 1.0]
]
assert fit.max_separation_of_source_plane_positions == 1.0
assert fit.max_separation_within_threshold(threshold=2.0) == True
assert fit.max_separation_within_threshold(threshold=0.5) == False
positions = al.GridIrregularGrouped(
grid=[[(0.0, 0.0), (0.0, 1.0), (0.0, 3.0)], [(0.0, 0.0)]]
)
noise_map = al.ValuesIrregularGrouped([[1.0, 1.0], [1.0]])
tracer = MockTracerPositions(positions=positions)
fit = al.FitPositionsSourceMaxSeparation(
positions=positions, noise_map=noise_map, tracer=tracer
)
assert fit.furthest_separations_of_source_plane_positions.in_grouped_list == [
[3.0, 2.0, 3.0],
[0.0],
]
assert fit.max_separation_of_source_plane_positions == 3.0
assert fit.max_separation_within_threshold(threshold=3.5) == True
assert fit.max_separation_within_threshold(threshold=2.0) == False
assert fit.max_separation_within_threshold(threshold=0.5) == False
def test_multiple_positions__mock_position_tracer__maximum_separation_is_correct(
self,
):
positions = al.GridIrregularGrouped([[(0.0, 0.0), (0.0, 1.0), (0.0, 0.5)]])
tracer = MockTracerPositions(positions=positions)
fit = al.FitPositionsSourcePlaneMaxSeparation(
positions=positions, tracer=tracer, noise_value=1.0
)
assert fit.maximum_separations[0] == 1.0
positions = al.GridIrregularGrouped([[(0.0, 0.0), (0.0, 0.0), (3.0, 3.0)]])
tracer = MockTracerPositions(positions=positions)
fit = al.FitPositionsSourcePlaneMaxSeparation(
positions=positions, tracer=tracer, noise_value=1.0
)
assert fit.maximum_separations[0] == np.sqrt(18)
al.GridIrregularGrouped([[(0.0, 0.0), (1.0, 1.0), (3.0, 3.0)]])
tracer = MockTracerPositions(positions=positions)
fit = al.FitPositionsSourcePlaneMaxSeparation(
positions=positions, tracer=tracer, noise_value=1.0
)
assert fit.maximum_separations[0] == np.sqrt(18)
positions = al.GridIrregularGrouped(
[
[
(-2.0, -4.0),
(1.0, 3.0),
(0.1, 0.1),
(-0.1, -0.1),
(0.3, 0.4),
(-0.6, 0.5),
]
]
)
tracer = MockTracerPositions(positions=positions)
fit = al.FitPositionsSourcePlaneMaxSeparation(
positions=positions, tracer=tracer, noise_value=1.0
)
assert fit.maximum_separations[0] == np.sqrt(np.square(3.0) + np.square(7.0))
positions = al.GridIrregularGrouped([[(8.0, 4.0), (8.0, 4.0), (-9.0, -4.0)]])
tracer = MockTracerPositions(positions=positions)
fit = al.FitPositionsSourcePlaneMaxSeparation(
positions=positions, tracer=tracer, noise_value=1.0
)
assert fit.maximum_separations[0] == np.sqrt(np.square(17.0) + np.square(8.0))
def test__positions_do_not_trace_within_threshold__raises_exception(
self, phase_interferometer_7, interferometer_7, mask_7x7,
visibilities_mask_7):
interferometer_7.positions = al.GridIrregularGrouped([[(1.0, 100.0),
(200.0, 2.0)]])
phase_interferometer_7 = al.PhaseInterferometer(
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("test_phase"),
)
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([])
with pytest.raises(exc.RayTracingException):
analysis.log_likelihood_function(instance=instance)
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.GridIrregularGrouped([[(1.0, 1.0), (2.0, 2.0)]]),
)
phase_imaging_7x7 = al.PhaseImaging(
search=mock.MockSearch("test_phase"),
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_grouped_list[0][0] ==
np.array([1.0, 1.0])).all()
assert (analysis.masked_dataset.positions.in_grouped_list[0][1] ==
np.array([2.0, 2.0])).all()
assert analysis.settings.settings_lens.positions_threshold == 0.2
def test__results_of_phase_include_positions__available_as_property(
self, imaging_7x7, mask_7x7, samples_with_result):
phase_imaging_7x7 = al.PhaseImaging(
search=mock.MockSearch("test_phase", 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(
galaxies=dict(lens=al.Galaxy(redshift=0.5),
source=al.Galaxy(redshift=1.0)),
search=mock.MockSearch("test_phase", samples=samples_with_result),
settings=al.SettingsPhaseImaging(settings_lens=al.SettingsLens(
positions_threshold=1.0)),
)
imaging_7x7.positions = al.GridIrregularGrouped([[(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__two_sets_of_positions__residuals_likelihood_correct(self):
tracer = MockTracerPositions(positions=None)
positions = al.GridIrregularGrouped([[(0.0, 0.0), (3.0, 4.0)], [(3.0, 3.0)]])
noise_map = al.ValuesIrregularGrouped([[0.5, 1.0], [1.0]])
model_positions = al.GridIrregularGrouped(
[[(3.0, 1.0), (2.0, 3.0)], [(3.0, 3.0)]]
)
positions_solver = mock.MockPositionsSolver(model_positions=model_positions)
fit = al.FitPositionsImage(
positions=positions,
noise_map=noise_map,
tracer=tracer,
positions_solver=positions_solver,
)
assert fit.model_positions_all.in_grouped_list == [
[(3.0, 1.0), (2.0, 3.0)],
[(3.0, 3.0)],
]
assert fit.model_positions.in_grouped_list == [
[(3.0, 1.0), (2.0, 3.0)],
[(3.0, 3.0)],
]
assert fit.noise_map.in_grouped_list == [[0.5, 1.0], [1.0]]
assert fit.residual_map.in_grouped_list == [
[np.sqrt(10.0), np.sqrt(2.0)],
[0.0],
]
assert fit.normalized_residual_map.in_grouped_list == [
[np.sqrt(10.0) / 0.5, np.sqrt(2.0) / 1.0],
[0.0],
]
assert fit.chi_squared_map.in_grouped_list == [
[(np.sqrt(10.0) / 0.5) ** 2, np.sqrt(2.0) ** 2.0],
[0.0],
]
assert fit.chi_squared == pytest.approx(42.0, 1.0e-4)
assert fit.noise_normalization == pytest.approx(4.12733, 1.0e-4)
assert fit.log_likelihood == pytest.approx(-23.06366, 1.0e-4)
def test__threshold__if_not_met_returns_ray_tracing_exception(self):
positions = al.GridIrregularGrouped([[(0.0, 0.0), (0.0, 1.0)]])
tracer = MockTracerPositions(positions=positions)
fit = al.FitPositionsSourcePlaneMaxSeparation(
positions=positions, tracer=tracer, noise_value=1.0
)
assert fit.maximum_separation_within_threshold(threshold=100.0)
assert not fit.maximum_separation_within_threshold(threshold=0.1)
def test__more_model_positions_than_data_positions__pairs_closest_positions(self):
tracer = MockTracerPositions(positions=None)
positions = al.GridIrregularGrouped([[(0.0, 0.0), (3.0, 4.0)], [(3.0, 3.0)]])
noise_map = al.ValuesIrregularGrouped([[0.5, 1.0], [1.0]])
model_positions = al.GridIrregularGrouped(
[[(3.0, 1.0), (2.0, 3.0), (1.0, 0.0), (0.0, 1.0)], [(3.0, 3.0), (4.0, 4.0)]]
)
positions_solver = mock.MockPositionsSolver(model_positions=model_positions)
fit = al.FitPositionsImage(
positions=positions,
noise_map=noise_map,
tracer=tracer,
positions_solver=positions_solver,
)
assert fit.model_positions_all.in_grouped_list == [
[(3.0, 1.0), (2.0, 3.0), (1.0, 0.0), (0.0, 1.0)],
[(3.0, 3.0), (4.0, 4.0)],
]
assert fit.model_positions.in_grouped_list == [
[(1.0, 0.0), (2.0, 3.0)],
[(3.0, 3.0)],
]
assert fit.noise_map.in_grouped_list == [[0.5, 1.0], [1.0]]
assert fit.residual_map.in_grouped_list == [[1.0, np.sqrt(2.0)], [0.0]]
assert fit.normalized_residual_map.in_grouped_list == [
[2.0, np.sqrt(2.0) / 1.0],
[0.0],
]
assert fit.chi_squared_map.in_grouped_list == [
[4.0, np.sqrt(2.0) ** 2.0],
[0.0],
]
assert fit.chi_squared == pytest.approx(6.0, 1.0e-4)
assert fit.noise_normalization == pytest.approx(4.12733, 1.0e-4)
assert fit.log_likelihood == pytest.approx(-5.06366, 1.0e-4)
def test__positions_do_not_trace_within_threshold__raises_exception(self,):
tracer = al.Tracer.from_galaxies(
galaxies=[
al.Galaxy(redshift=0.5, mass=al.mp.SphericalIsothermal()),
al.Galaxy(redshift=1.0),
]
)
settings = al.SettingsLens(positions_threshold=50.0)
settings.check_positions_trace_within_threshold_via_tracer(
tracer=tracer, positions=al.GridIrregularGrouped([[(1.0, 1.0), (2.0, 2.0)]])
)
settings = al.SettingsLens(positions_threshold=0.0)
with pytest.raises(exc.RayTracingException):
settings.check_positions_trace_within_threshold_via_tracer(
tracer=tracer,
positions=al.GridIrregularGrouped([[(1.0, 1.0), (2.0, 2.0)]]),
)
# No mass profile - doesnt raise exception
tracer = al.Tracer.from_galaxies(
galaxies=[al.Galaxy(redshift=0.5), al.Galaxy(redshift=1.0)]
)
settings.check_positions_trace_within_threshold_via_tracer(
tracer=tracer, positions=al.GridIrregularGrouped([[(1.0, 1.0), (2.0, 2.0)]])
)
# Single plane - doesnt raise exception
tracer = al.Tracer.from_galaxies(
galaxies=[al.Galaxy(redshift=0.5, mass=al.mp.SphericalIsothermal())]
)
settings.check_positions_trace_within_threshold_via_tracer(
tracer=tracer, positions=al.GridIrregularGrouped([[(1.0, 1.0), (2.0, 2.0)]])
)
def test_multiple_sets_of_positions__multiple_sets_of_max_distances(self):
positions = al.GridIrregularGrouped(
[
[(0.0, 0.0), (0.0, 1.0), (0.0, 0.5)],
[(0.0, 0.0), (0.0, 0.0), (3.0, 3.0)],
[(0.0, 0.0), (1.0, 1.0), (3.0, 3.0)],
]
)
tracer = MockTracerPositions(positions=positions)
fit = al.FitPositionsSourcePlaneMaxSeparation(
positions=positions, tracer=tracer, noise_value=1.0
)
assert fit.maximum_separations[0] == 1.0
assert fit.maximum_separations[1] == np.sqrt(18)
assert fit.maximum_separations[2] == np.sqrt(18)
def test__likelihood__is_sum_of_separations_divided_by_noise(self):
positions = al.GridIrregularGrouped(
[
[(0.0, 0.0), (0.0, 1.0), (0.0, 0.5)],
[(0.0, 0.0), (0.0, 0.0), (3.0, 3.0)],
[(0.0, 0.0), (1.0, 1.0), (3.0, 3.0)],
]
)
tracer = MockTracerPositions(positions=positions)
fit = al.FitPositionsSourcePlaneMaxSeparation(
positions=positions, tracer=tracer, noise_value=1.0
)
assert fit.chi_squared_map[0] == 1.0
assert fit.chi_squared_map[1] == pytest.approx(18.0, 1e-4)
assert fit.chi_squared_map[2] == pytest.approx(18.0, 1e-4)
assert fit.figure_of_merit == pytest.approx(-0.5 * (1.0 + 18 + 18), 1e-4)
fit = al.FitPositionsSourcePlaneMaxSeparation(
positions=positions, tracer=tracer, noise_value=2.0
)
assert fit.chi_squared_map[0] == (1.0 / 2.0) ** 2.0
assert fit.chi_squared_map[1] == pytest.approx(
(np.sqrt(18.0) / 2.0) ** 2.0, 1e-4
)
assert fit.chi_squared_map[2] == pytest.approx(
(np.sqrt(18.0) / 2.0) ** 2.0, 1e-4
)
assert fit.figure_of_merit == pytest.approx(
-0.5
* (
(1.0 / 2.0) ** 2.0
+ (np.sqrt(18.0) / 2.0) ** 2.0
+ (np.sqrt(18.0) / 2.0) ** 2.0
),
1e-4,
)
imaging = instrument_util.load_test_imaging(
dataset_name="light_sersic__source_sersic", instrument="vro")
array = imaging.image
plotter = aplt.Plotter(
figure=aplt.Figure(figsize=(10, 10)),
cmap=aplt.ColorMap(cmap="gray",
norm="symmetric_log",
norm_min=-0.13,
norm_max=20,
linthresh=0.02),
grid_scatterer=aplt.GridScatterer(marker="+", colors="cyan", size=450),
)
grid = al.GridIrregular(grid=[[1.0, 1.0], [2.0, 2.0], [3.0, 3.0]])
print(grid)
vector_field = al.VectorFieldIrregular(vectors=[(1.0, 2.0), (2.0, 1.0)],
grid=[(-1.0, 0.0), (-2.0, 0.0)])
aplt.Array(
array=array.in_2d,
grid=grid,
positions=al.GridIrregularGrouped([(0.0, 1.0), (0.0, 2.0)]),
vector_field=vector_field,
patches=vector_field.elliptical_patches,
plotter=plotter,
)
positions = solver.solve(
lensing_obj=tracer,
source_plane_coordinate=tracer.source_plane.galaxies[0].light.centre,
)
positions_true = al.GridIrregularGrouped.load(
file_path=pickle_path, filename=f"positions_{str(i)}"
)
minimum_separations = util.minimum_separations_from(
positions_true=positions, positions=positions_true
)
in_positions_true = util.check_if_positions_in_positions_true(
positions_true=positions_true, positions=positions, threshold=0.1
)
print()
print(positions_true.in_grouped_list)
print(positions.in_grouped_list)
print(minimum_separations)
print(in_positions_true)
positions_plot = al.GridIrregularGrouped(
grid=[positions.in_grouped_list[0], positions_true.in_grouped_list[0]]
)
visuals_2d = aplt.Visuals2D(positions=positions_plot)
tracer_plotter = aplt.TracerPlotter(tracer=tracer, grid=grid)
tracer_plotter.figure_image(visuals_2d=visuals_2d)
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
mass-model is clearly not accurate.
2) By removing these solutions, a global-maximum solution may be reached instead of a local-maxima. This is
because removing the incorrect mass models makes the non-linear parameter space less complex.
We can easily check the image-positions are accurate by plotting them using our `ImagingPlotter`.(they are the magenta
dots on the image).
To specify these positions, we use the `GridIrregularGrouped` object, which is used by **PyAutoLens** in general to specify (y,x)
coordinates.
"""
# %%
positions = al.GridIrregularGrouped(grid=[(1.6, 0.0), (0.0,
1.6), (-1.6,
0.0), (0.0,
-1.6)])
visuals_2d = aplt.Visuals2D(positions=positions)
imaging_plotter = aplt.ImagingPlotter(imaging=imaging, visuals_2d=visuals_2d)
imaging_plotter.subplot_imaging()
# %%
"""
For the positions to be used in a Phase, we associate them with the `Imaging` data.
We also pass the `SettingsPhaseImaging` a new object, `SettingsLens`. This includes the *position_threshold* used
during modeling to resample inaccurate mass models.
"""
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__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.lp.EllipticalSersic(intensity=0.1))
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.GridIrregularGrouped([[(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_grouped_list == [[1.0, 1.0]]
assert fit_positions.chi_squared == 2.0
assert fit_positions.log_likelihood == fit_figure_of_merit
lensing_obj=tracer,
source_plane_coordinate=tracer.source_plane.galaxies[0].light.centre,
)
positions_true = al.GridIrregularGrouped.load(
file_path=pickle_path, filename=f"positions_{str(i)}")
if positions is not None:
minimum_separations = util.minimum_separations_from(
positions_true=positions_true, positions=positions)
in_positions_true = util.check_if_positions_in_positions_true(
positions_true=positions_true, positions=positions, threshold=0.1)
positions_plot = al.GridIrregularGrouped(coordinates=[
positions.in_grouped_list[0],
positions_true.in_grouped_list[0],
])
else:
minimum_separations = None
in_positions_true = None
positions_plot = al.GridIrregularGrouped(
coordinates=[positions_true.in_grouped_list[0]])
print(positions)
aplt.Tracer.image(
tracer=tracer,
grid=grid,
def make_positions_x2():
return al.GridIrregularGrouped(grid=[[(1.0, 1.0), (2.0, 2.0)]])
n_y, n_x = imaging.shape_2d
hw = int(n_x / 2) * pixel_scales
ext = [-hw, hw, -hw, hw]
fig = plt.figure(figsize=(14, 14))
plt.imshow(imaging.in_2d,
cmap='gray',
norm=SymLogNorm(vmin=-0.13, vmax=20, linthresh=0.02))
plt.xlim(3500, 4000)
plt.ylim(5000, 5500)
plt.colorbar()
cid = fig.canvas.mpl_connect("button_press_event", onclick)
plt.show()
fig.canvas.mpl_disconnect(cid)
plt.close(fig)
light_centres = al.GridIrregularGrouped(grid=light_centres)
print(light_centres)
"""
Now lets plot the image and lens light centre, so we can check that the centre overlaps the brightest pixel in the
lens light.
"""
#aplt.Array(array=imaging, light_profile_centres=light_centres)
"""
Now we`re happy with the lens light centre(s), lets output them to the dataset folder of the lens, so that we can
load them from a.dat file in our pipelines!
"""
light_centres.output_to_file(
file_path=f"{output_path}{dataset_name}/lens_centre_pix.dat",
overwrite=True)
