def test__more_model_positions_than_data_positions__pairs_closest_positions(
self):
g0 = al.Galaxy(redshift=1.0,
point_0=al.ps.PointSource(centre=(0.1, 0.1)))
tracer = al.Tracer.from_galaxies(
galaxies=[al.Galaxy(redshift=0.5), g0])
positions = al.Grid2DIrregular([(0.0, 0.0), (3.0, 4.0)])
noise_map = al.ValuesIrregular([0.5, 1.0])
model_positions = al.Grid2DIrregular([(3.0, 1.0), (2.0, 3.0),
(1.0, 0.0), (0.0, 1.0)])
positions_solver = mock.MockPositionsSolver(
model_positions=model_positions)
fit = al.FitPositionsImage(
name="point_0",
positions=positions,
noise_map=noise_map,
tracer=tracer,
positions_solver=positions_solver,
)
assert fit.model_positions.in_list == [(1.0, 0.0), (2.0, 3.0)]
assert fit.noise_map.in_list == [0.5, 1.0]
assert fit.residual_map.in_list == [1.0, np.sqrt(2.0)]
assert fit.normalized_residual_map.in_list == [2.0, np.sqrt(2.0) / 1.0]
assert fit.chi_squared_map.in_list == [4.0, np.sqrt(2.0)**2.0]
assert fit.chi_squared == pytest.approx(6.0, 1.0e-4)
assert fit.noise_normalization == pytest.approx(2.289459, 1.0e-4)
assert fit.log_likelihood == pytest.approx(-4.144729, 1.0e-4)
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.ValuesIrregular([1.0, 1.0])
positions = al.Grid2DIrregular([(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.Grid2DIrregular([(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.Grid2DIrregular(grid=[(0.0, 0.0), (0.0, 1.0)])
noise_map = al.ValuesIrregular([[1.0, 1.0]])
tracer = mock.MockTracer(traced_grid=positions)
fit = al.FitPositionsSourceMaxSeparation(positions=positions,
noise_map=noise_map,
tracer=tracer)
assert fit.furthest_separations_of_source_plane_positions.in_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.Grid2DIrregular(grid=[(0.0, 0.0), (0.0, 1.0), (0.0,
3.0)])
noise_map = al.ValuesIrregular([1.0, 1.0, 1.0])
tracer = mock.MockTracer(traced_grid=positions)
fit = al.FitPositionsSourceMaxSeparation(positions=positions,
noise_map=noise_map,
tracer=tracer)
assert fit.furthest_separations_of_source_plane_positions.in_list == [
3.0,
2.0,
3.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__check_positions_on_instantiation():
al.PositionsLHResample(positions=al.Grid2DIrregular([(1.0, 2.0),
(3.0, 4.0)]),
threshold=0.1)
# Positions input with threshold but positions are length 1.
with pytest.raises(exc.PositionsException):
al.PositionsLHResample(positions=al.Grid2DIrregular([(1.0, 2.0)]),
threshold=0.1)
def test__results_include_positions__available_as_property(
self, analysis_imaging_7x7, masked_imaging_7x7,
samples_with_result):
result = res.ResultDataset(
samples=samples_with_result,
analysis=analysis_imaging_7x7,
model=None,
search=None,
)
assert result.positions == None
analysis = al.AnalysisImaging(
dataset=masked_imaging_7x7,
positions=al.Grid2DIrregular([[(1.0, 1.0)]]),
settings_lens=al.SettingsLens(positions_threshold=1.0),
)
result = res.ResultDataset(samples=samples_with_result,
analysis=analysis,
model=None,
search=None)
assert (result.positions[0] == np.array([1.0, 1.0])).all()
def test__multi_plane_position_solving():
g0 = al.Galaxy(redshift=0.5, mass=al.mp.SphIsothermal(einstein_radius=1.0))
g1 = al.Galaxy(redshift=1.0, point_0=al.ps.Point(centre=(0.1, 0.1)))
g2 = al.Galaxy(redshift=2.0, point_1=al.ps.Point(centre=(0.1, 0.1)))
tracer = al.Tracer.from_galaxies(galaxies=[g0, g1, g2])
positions = al.Grid2DIrregular([(0.0, 1.0), (0.0, 2.0)])
noise_map = al.ValuesIrregular([0.5, 1.0])
traced_grids = tracer.traced_grid_2d_list_from(grid=positions)
fit_0 = al.FitPositionsSource(name="point_0",
positions=positions,
noise_map=noise_map,
tracer=tracer)
assert fit_0.model_positions[0, 1] == pytest.approx(0.326054, 1.0e-1)
assert fit_0.model_positions[1, 1] == pytest.approx(1.326054, 1.0e-1)
assert (fit_0.model_positions == traced_grids[1]).all()
fit_1 = al.FitPositionsSource(name="point_1",
positions=positions,
noise_map=noise_map,
tracer=tracer)
assert (fit_1.model_positions == traced_grids[2]).all()
def test__one_set_of_fluxes__residuals_likelihood_correct(self):
tracer = mock.MockTracer(
magnification=al.ValuesIrregular([2.0, 2.0]),
profile=al.ps.PointSourceFlux(flux=2.0),
)
fluxes = al.ValuesIrregular([1.0, 2.0])
noise_map = al.ValuesIrregular([3.0, 1.0])
positions = al.Grid2DIrregular([(0.0, 0.0), (3.0, 4.0)])
fit = al.FitFluxes(
name="point_0",
fluxes=fluxes,
noise_map=noise_map,
positions=positions,
tracer=tracer,
)
assert fit.fluxes.in_list == [1.0, 2.0]
assert fit.noise_map.in_list == [3.0, 1.0]
assert fit.model_fluxes.in_list == [4.0, 4.0]
assert fit.residual_map.in_list == [-3.0, -2.0]
assert fit.normalized_residual_map.in_list == [-1.0, -2.0]
assert fit.chi_squared_map.in_list == [1.0, 4.0]
assert fit.chi_squared == pytest.approx(5.0, 1.0e-4)
assert fit.noise_normalization == pytest.approx(5.87297, 1.0e-4)
assert fit.log_likelihood == pytest.approx(-5.43648, 1.0e-4)
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.Grid2DIrregular([[(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__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.Grid2DIrregular([(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_list[0] == np.array(
[1.0, 1.0])).all()
assert (analysis.masked_dataset.positions.in_list[1] == np.array(
[2.0, 2.0])).all()
assert analysis.settings.settings_lens.positions_threshold == 0.2
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.Grid2DIrregular([(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 make_dataset():
return al.PointSourceDataset(
"name",
positions=al.Grid2DIrregular([(1, 2)]),
positions_noise_map=al.ValuesIrregular([1]),
fluxes=al.ValuesIrregular([2]),
fluxes_noise_map=al.ValuesIrregular([3]),
)
def test__fits_dataset__positions_only():
point_source = al.ps.Point(centre=(0.1, 0.1))
galaxy_point_source = al.Galaxy(redshift=1.0, point_0=point_source)
tracer = al.Tracer.from_galaxies(
galaxies=[al.Galaxy(redshift=0.5), galaxy_point_source])
positions = al.Grid2DIrregular([(0.0, 0.0), (3.0, 4.0)])
noise_map = al.ValuesIrregular([0.5, 1.0])
model_positions = al.Grid2DIrregular([(3.0, 1.0), (2.0, 3.0)])
point_solver = al.m.MockPointSolver(model_positions=model_positions)
point_dataset_0 = al.PointDataset(name="point_0",
positions=positions,
positions_noise_map=noise_map)
point_dict = al.PointDict(point_dataset_list=[point_dataset_0])
fit = al.FitPointDict(point_dict=point_dict,
tracer=tracer,
point_solver=point_solver)
assert fit["point_0"].positions.log_likelihood == pytest.approx(
-22.14472, 1.0e-4)
assert fit["point_0"].flux == None
assert fit.log_likelihood == fit["point_0"].positions.log_likelihood
point_dataset_1 = al.PointDataset(name="point_1",
positions=positions,
positions_noise_map=noise_map)
point_dict = al.PointDict(
point_dataset_list=[point_dataset_0, point_dataset_1])
fit = al.FitPointDict(point_dict=point_dict,
tracer=tracer,
point_solver=point_solver)
assert fit["point_0"].positions.log_likelihood == pytest.approx(
-22.14472, 1.0e-4)
assert fit["point_0"].flux == None
assert fit["point_1"].positions == None
assert fit["point_1"].flux == None
assert fit.log_likelihood == fit["point_0"].positions.log_likelihood
def test__figure_of_merit__matches_correct_fit_given_galaxy_profiles(
self, positions_x2, positions_x2_noise_map):
point_source_dataset = al.PointSourceDataset(
name="point_0",
positions=positions_x2,
positions_noise_map=positions_x2_noise_map,
)
point_source_dict = al.PointSourceDict(
point_source_dataset_list=[point_source_dataset])
model = af.Collection(galaxies=af.Collection(lens=al.Galaxy(
redshift=0.5, point_0=al.ps.PointSource(centre=(0.0, 0.0)))))
solver = mock.MockPositionsSolver(model_positions=positions_x2)
analysis = al.AnalysisPointSource(point_source_dict=point_source_dict,
solver=solver)
instance = model.instance_from_unit_vector([])
analysis_log_likelihood = analysis.log_likelihood_function(
instance=instance)
tracer = analysis.tracer_for_instance(instance=instance)
fit_positions = al.FitPositionsImage(
name="point_0",
positions=positions_x2,
noise_map=positions_x2_noise_map,
tracer=tracer,
positions_solver=solver,
)
assert fit_positions.chi_squared == 0.0
assert fit_positions.log_likelihood == analysis_log_likelihood
model_positions = al.Grid2DIrregular([(0.0, 1.0), (1.0, 2.0)])
solver = mock.MockPositionsSolver(model_positions=model_positions)
analysis = al.AnalysisPointSource(point_source_dict=point_source_dict,
solver=solver)
analysis_log_likelihood = analysis.log_likelihood_function(
instance=instance)
fit_positions = al.FitPositionsImage(
name="point_0",
positions=positions_x2,
noise_map=positions_x2_noise_map,
tracer=tracer,
positions_solver=solver,
)
assert fit_positions.residual_map.in_list == [1.0, 1.0]
assert fit_positions.chi_squared == 2.0
assert fit_positions.log_likelihood == analysis_log_likelihood
def test__from_json_and_output_to_json():
point_dataset_0 = al.PointDataset(
name="source_1",
positions=al.Grid2DIrregular([[1.0, 1.0]]),
positions_noise_map=al.ValuesIrregular([1.0]),
)
point_dataset_1 = al.PointDataset(
name="source_2",
positions=al.Grid2DIrregular([[1.0, 1.0]]),
positions_noise_map=al.ValuesIrregular([1.0]),
fluxes=al.ValuesIrregular([2.0, 3.0]),
fluxes_noise_map=al.ValuesIrregular([4.0, 5.0]),
)
point_dict = al.PointDict(point_dataset_list=[point_dataset_0, point_dataset_1])
dir_path = path.join("{}".format(path.dirname(path.realpath(__file__))), "files")
if path.exists(dir_path):
shutil.rmtree(dir_path)
os.makedirs(dir_path)
file_path = path.join(dir_path, "point_dict.json")
point_dict.output_to_json(file_path=file_path, overwrite=True)
point_dict_via_json = al.PointDict.from_json(file_path=file_path)
assert point_dict_via_json["source_1"].name == "source_1"
assert point_dict_via_json["source_1"].positions.in_list == [(1.0, 1.0)]
assert point_dict_via_json["source_1"].positions_noise_map.in_list == [1.0]
assert point_dict_via_json["source_1"].fluxes == None
assert point_dict_via_json["source_1"].fluxes_noise_map == None
assert point_dict_via_json["source_2"].name == "source_2"
assert point_dict_via_json["source_2"].positions.in_list == [(1.0, 1.0)]
assert point_dict_via_json["source_2"].positions_noise_map.in_list == [1.0]
assert point_dict_via_json["source_2"].fluxes.in_list == [2.0, 3.0]
assert point_dict_via_json["source_2"].fluxes_noise_map.in_list == [4.0, 5.0]
def test__analysis_no_positions__removes_positions_and_threshold(
self, masked_imaging_7x7):
analysis = al.AnalysisImaging(
dataset=masked_imaging_7x7,
positions=al.Grid2DIrregular([(1.0, 100.0), (200.0, 2.0)]),
settings_lens=al.SettingsLens(positions_threshold=0.01),
)
assert analysis.no_positions.positions == None
assert analysis.no_positions.settings_lens.positions_threshold == None
def test__model_has_image_and_source_chi_squared__fits_both_correctly():
galaxy_point_image = al.Galaxy(redshift=1.0,
point_0=al.ps.Point(centre=(0.1, 0.1)))
galaxy_point_source = al.Galaxy(redshift=1.0,
point_1=al.ps.PointSourceChi(centre=(0.1,
0.1)))
tracer = al.Tracer.from_galaxies(galaxies=[
al.Galaxy(redshift=0.5), galaxy_point_image, galaxy_point_source
])
positions = al.Grid2DIrregular([(0.0, 0.0), (3.0, 4.0)])
noise_map = al.ValuesIrregular([0.5, 1.0])
model_positions = al.Grid2DIrregular([(3.0, 1.0), (2.0, 3.0)])
point_solver = al.m.MockPointSolver(model_positions=model_positions)
point_dataset_0 = al.PointDataset(name="point_0",
positions=positions,
positions_noise_map=noise_map)
point_dataset_1 = al.PointDataset(name="point_1",
positions=positions,
positions_noise_map=noise_map)
point_dict = al.PointDict(
point_dataset_list=[point_dataset_0, point_dataset_1])
fit = al.FitPointDict(point_dict=point_dict,
tracer=tracer,
point_solver=point_solver)
assert isinstance(fit["point_0"].positions, al.FitPositionsImage)
assert isinstance(fit["point_1"].positions, al.FitPositionsSource)
assert fit[
"point_0"].positions.model_positions.in_list == model_positions.in_list
assert fit[
"point_1"].positions.model_positions.in_list == positions.in_list
def test__point_dataset_structures_as_dict():
point_dataset_0 = al.PointDataset(
name="source_1",
positions=al.Grid2DIrregular([[1.0, 1.0]]),
positions_noise_map=al.ValuesIrregular([1.0]),
)
point_dict = al.PointDict(point_dataset_list=[point_dataset_0])
assert point_dict["source_1"].name == "source_1"
assert point_dict["source_1"].positions.in_list == [(1.0, 1.0)]
assert point_dict["source_1"].positions_noise_map.in_list == [1.0]
assert point_dict["source_1"].fluxes == None
assert point_dict["source_1"].fluxes_noise_map == None
point_dataset_1 = al.PointDataset(
name="source_2",
positions=al.Grid2DIrregular([[1.0, 1.0]]),
positions_noise_map=al.ValuesIrregular([1.0]),
fluxes=al.ValuesIrregular([2.0, 3.0]),
fluxes_noise_map=al.ValuesIrregular([4.0, 5.0]),
)
point_dict = al.PointDict(point_dataset_list=[point_dataset_0, point_dataset_1])
assert point_dict["source_1"].name == "source_1"
assert point_dict["source_1"].positions.in_list == [(1.0, 1.0)]
assert point_dict["source_1"].positions_noise_map.in_list == [1.0]
assert point_dict["source_1"].fluxes == None
assert point_dict["source_1"].fluxes_noise_map == None
assert point_dict["source_2"].name == "source_2"
assert point_dict["source_2"].positions.in_list == [(1.0, 1.0)]
assert point_dict["source_2"].positions_noise_map.in_list == [1.0]
assert point_dict["source_2"].fluxes.in_list == [2.0, 3.0]
assert point_dict["source_2"].fluxes_noise_map.in_list == [4.0, 5.0]
assert (point_dict.positions_list[0] == np.array([1.0, 1.0])).all()
assert (point_dict.positions_list[1] == np.array([1.0, 1.0])).all()
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.Grid2DIrregular([(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.Grid2DIrregular([(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.Grid2DIrregular([(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.Grid2DIrregular([(1.0, 1.0), (2.0, 2.0)])
)
def test__two_sets_of_positions__residuals_likelihood_correct(self):
point_source = al.ps.PointSource(centre=(0.1, 0.1))
galaxy_point_source = al.Galaxy(redshift=1.0, point_0=point_source)
tracer = al.Tracer.from_galaxies(
galaxies=[al.Galaxy(redshift=0.5), galaxy_point_source])
positions = al.Grid2DIrregular([(0.0, 0.0), (3.0, 4.0)])
noise_map = al.ValuesIrregular([0.5, 1.0])
model_positions = al.Grid2DIrregular([(3.0, 1.0), (2.0, 3.0)])
positions_solver = mock.MockPositionsSolver(
model_positions=model_positions)
fit = al.FitPositionsImage(
name="point_0",
positions=positions,
noise_map=noise_map,
tracer=tracer,
positions_solver=positions_solver,
)
assert fit.model_positions.in_list == [(3.0, 1.0), (2.0, 3.0)]
assert fit.model_positions.in_list == [(3.0, 1.0), (2.0, 3.0)]
assert fit.noise_map.in_list == [0.5, 1.0]
assert fit.residual_map.in_list == [np.sqrt(10.0), np.sqrt(2.0)]
assert fit.normalized_residual_map.in_list == [
np.sqrt(10.0) / 0.5,
np.sqrt(2.0) / 1.0,
]
assert fit.chi_squared_map.in_list == [
(np.sqrt(10.0) / 0.5)**2,
np.sqrt(2.0)**2.0,
]
assert fit.chi_squared == pytest.approx(42.0, 1.0e-4)
assert fit.noise_normalization == pytest.approx(2.28945, 1.0e-4)
assert fit.log_likelihood == pytest.approx(-22.14472, 1.0e-4)
def test__output_positions_info():
output_path = path.join(
"{}".format(os.path.dirname(os.path.realpath(__file__))), "files")
positions_likelihood = al.PositionsLHResample(positions=al.Grid2DIrregular(
[(1.0, 2.0), (3.0, 4.0)]),
threshold=0.1)
tracer = al.m.MockTracer(traced_grid_2d_list_from=al.Grid2DIrregular(
grid=[[(0.5, 1.5), (2.5, 3.5)]]))
positions_likelihood.output_positions_info(output_path=output_path,
tracer=tracer)
positions_file = path.join(output_path, "positions.info")
with open_(positions_file, "r") as f:
output = f.readlines()
assert "Positions" in output[0]
os.remove(positions_file)
def test__multi_plane_calculation(self, gal_x1_mp):
g0 = al.Galaxy(redshift=0.5,
mass=al.mp.SphIsothermal(einstein_radius=1.0))
g1 = al.Galaxy(redshift=1.0, point_0=al.ps.PointSourceFlux(flux=1.0))
g2 = al.Galaxy(redshift=2.0, point_1=al.ps.PointSourceFlux(flux=2.0))
tracer = al.Tracer.from_galaxies(galaxies=[g0, g1, g2])
fluxes = al.ValuesIrregular([1.0])
noise_map = al.ValuesIrregular([3.0])
positions = al.Grid2DIrregular([(2.0, 0.0)])
fit_0 = al.FitFluxes(
name="point_0",
fluxes=fluxes,
noise_map=noise_map,
positions=positions,
tracer=tracer,
)
deflections_func = partial(tracer.deflections_between_planes_from_grid,
plane_i=0,
plane_j=1)
magnification_0 = tracer.magnification_via_hessian_from_grid(
grid=positions, deflections_func=deflections_func)
assert fit_0.magnifications[0] == magnification_0
fit_1 = al.FitFluxes(
name="point_1",
fluxes=fluxes,
noise_map=noise_map,
positions=positions,
tracer=tracer,
)
deflections_func = partial(tracer.deflections_between_planes_from_grid,
plane_i=0,
plane_j=2)
magnification_1 = tracer.magnification_via_hessian_from_grid(
grid=positions, deflections_func=deflections_func)
assert fit_1.magnifications[0] == magnification_1
assert fit_0.magnifications[0] != pytest.approx(
fit_1.magnifications[0], 1.0e-1)
def test__multi_plane_position_solving(self):
grid = al.Grid2D.uniform(shape_native=(100, 100),
pixel_scales=0.05,
sub_size=1)
g0 = al.Galaxy(redshift=0.5,
mass=al.mp.SphIsothermal(einstein_radius=1.0))
g1 = al.Galaxy(redshift=1.0,
point_0=al.ps.PointSource(centre=(0.1, 0.1)))
g2 = al.Galaxy(redshift=2.0,
point_1=al.ps.PointSource(centre=(0.1, 0.1)))
tracer = al.Tracer.from_galaxies(galaxies=[g0, g1, g2])
positions = al.Grid2DIrregular([(0.0, 0.0), (3.0, 4.0)])
noise_map = al.ValuesIrregular([0.5, 1.0])
positions_solver = al.PositionsSolver(grid=grid,
pixel_scale_precision=0.01)
fit_0 = al.FitPositionsImage(
name="point_0",
positions=positions,
noise_map=noise_map,
tracer=tracer,
positions_solver=positions_solver,
)
fit_1 = al.FitPositionsImage(
name="point_1",
positions=positions,
noise_map=noise_map,
tracer=tracer,
positions_solver=positions_solver,
)
scaling_factor = al.util.cosmology.scaling_factor_between_redshifts_from(
redshift_0=0.5,
redshift_1=1.0,
redshift_final=2.0,
cosmology=tracer.cosmology,
)
assert fit_0.model_positions[0, 0] == pytest.approx(
scaling_factor * fit_1.model_positions[0, 0], 1.0e-1)
assert fit_0.model_positions[0, 1] == pytest.approx(
scaling_factor * fit_1.model_positions[0, 1], 1.0e-1)
def test__use_real_tracer(self, gal_x1_mp):
point_source = al.ps.PointSourceFlux(centre=(0.1, 0.1), flux=2.0)
galaxy_point_source = al.Galaxy(redshift=1.0, point_0=point_source)
tracer = al.Tracer.from_galaxies(galaxies=[gal_x1_mp, galaxy_point_source])
fluxes = al.ValuesIrregular([1.0, 2.0])
noise_map = al.ValuesIrregular([3.0, 1.0])
positions = al.Grid2DIrregular([(0.0, 0.0), (3.0, 4.0)])
fit = al.FitFluxes(
fluxes=fluxes, noise_map=noise_map, positions=positions, tracer=tracer
)
assert fit.model_fluxes.in_list[1] == pytest.approx(2.5, 1.0e-4)
assert fit.log_likelihood == pytest.approx(-3.11702, 1.0e-4)
def test__positions_do_not_trace_within_threshold__raises_exception(
self, masked_imaging_7x7):
model = af.Collection(galaxies=af.Collection(
lens=al.Galaxy(redshift=0.5, mass=al.mp.SphIsothermal()),
source=al.Galaxy(redshift=1.0),
))
analysis = al.AnalysisImaging(
dataset=masked_imaging_7x7,
positions=al.Grid2DIrregular([(1.0, 100.0), (200.0, 2.0)]),
settings_lens=al.SettingsLens(positions_threshold=0.01),
)
instance = model.instance_from_unit_vector([])
with pytest.raises(exc.RayTracingException):
analysis.log_likelihood_function(instance=instance)
def test__positions__resample__raises_exception(masked_imaging_7x7):
model = af.Collection(galaxies=af.Collection(
lens=al.Galaxy(redshift=0.5, mass=al.mp.SphIsothermal()),
source=al.Galaxy(redshift=1.0),
))
positions_likelihood = al.PositionsLHResample(positions=al.Grid2DIrregular(
[(1.0, 100.0), (200.0, 2.0)]),
threshold=0.01)
analysis = al.AnalysisImaging(dataset=masked_imaging_7x7,
positions_likelihood=positions_likelihood)
instance = model.instance_from_unit_vector([])
with pytest.raises(exc.RayTracingException):
analysis.log_likelihood_function(instance=instance)
def test__positions__likelihood_overwrite__changes_likelihood(
interferometer_7, mask_2d_7x7):
lens = al.Galaxy(redshift=0.5, mass=al.mp.SphIsothermal())
source = al.Galaxy(redshift=1.0, light=al.lp.SphSersic())
model = af.Collection(galaxies=af.Collection(lens=lens, source=source))
analysis = al.AnalysisInterferometer(dataset=interferometer_7)
instance = model.instance_from_unit_vector([])
analysis_log_likelihood = analysis.log_likelihood_function(
instance=instance)
tracer = analysis.tracer_via_instance_from(instance=instance)
fit = al.FitInterferometer(dataset=interferometer_7, tracer=tracer)
assert fit.log_likelihood == analysis_log_likelihood
assert analysis_log_likelihood == pytest.approx(-127914.36273, 1.0e-4)
positions_likelihood = al.PositionsLHPenalty(positions=al.Grid2DIrregular([
(1.0, 100.0), (200.0, 2.0)
]),
threshold=0.01)
analysis = al.AnalysisInterferometer(
dataset=interferometer_7, positions_likelihood=positions_likelihood)
analysis_log_likelihood = analysis.log_likelihood_function(
instance=instance)
log_likelihood_penalty_base = positions_likelihood.log_likelihood_penalty_base_from(
dataset=interferometer_7)
log_likelihood_penalty = positions_likelihood.log_likelihood_penalty_from(
tracer=tracer)
assert analysis_log_likelihood == pytest.approx(
log_likelihood_penalty_base - log_likelihood_penalty, 1.0e-4)
assert analysis_log_likelihood == pytest.approx(-22048700567.590656,
1.0e-4)
def test__positions__likelihood_overwrites__changes_likelihood(
masked_imaging_7x7):
lens = al.Galaxy(redshift=0.5, mass=al.mp.SphIsothermal())
source = al.Galaxy(redshift=1.0, light=al.lp.SphSersic())
model = af.Collection(galaxies=af.Collection(lens=lens, source=source))
instance = model.instance_from_unit_vector([])
analysis = al.AnalysisImaging(dataset=masked_imaging_7x7)
analysis_log_likelihood = analysis.log_likelihood_function(
instance=instance)
tracer = analysis.tracer_via_instance_from(instance=instance)
fit = al.FitImaging(dataset=masked_imaging_7x7, tracer=tracer)
assert fit.log_likelihood == pytest.approx(analysis_log_likelihood, 1.0e-4)
assert analysis_log_likelihood == pytest.approx(-6258.043397009, 1.0e-4)
positions_likelihood = al.PositionsLHPenalty(positions=al.Grid2DIrregular([
(1.0, 100.0), (200.0, 2.0)
]),
threshold=0.01)
analysis = al.AnalysisImaging(dataset=masked_imaging_7x7,
positions_likelihood=positions_likelihood)
analysis_log_likelihood = analysis.log_likelihood_function(
instance=instance)
log_likelihood_penalty_base = positions_likelihood.log_likelihood_penalty_base_from(
dataset=masked_imaging_7x7)
log_likelihood_penalty = positions_likelihood.log_likelihood_penalty_from(
tracer=tracer)
assert analysis_log_likelihood == pytest.approx(
log_likelihood_penalty_base - log_likelihood_penalty, 1.0e-4)
assert analysis_log_likelihood == pytest.approx(-22048700558.9052, 1.0e-4)
def test__two_sets_of_positions__residuals_likelihood_correct(self):
point_source = al.ps.PointSourceChi(centre=(0.0, 0.0))
galaxy_point_source = al.Galaxy(redshift=1.0, point_0=point_source)
tracer = al.Tracer.from_galaxies(
galaxies=[al.Galaxy(redshift=0.5), galaxy_point_source])
positions = al.Grid2DIrregular([(0.0, 1.0), (0.0, 2.0)])
noise_map = al.ValuesIrregular([0.5, 1.0])
fit = al.FitPositionsSource(name="point_0",
positions=positions,
noise_map=noise_map,
tracer=tracer)
assert fit.model_positions.in_list == [(0.0, 1.0), (0.0, 2.0)]
assert fit.noise_map.in_list == [0.5, 1.0]
assert fit.residual_map.in_list == [1.0, 2.0]
assert fit.normalized_residual_map.in_list == [1.0 / 0.5, 2.0 / 1.0]
assert fit.chi_squared_map.in_list == [(1.0 / 0.5)**2.0, 2.0**2.0]
assert fit.chi_squared == pytest.approx(8.0, 1.0e-4)
assert fit.noise_normalization == pytest.approx(2.28945, 1.0e-4)
assert fit.log_likelihood == pytest.approx(-5.14472988, 1.0e-4)
galaxy_mass = al.Galaxy(
redshift=0.5,
mass=al.mp.SphIsothermal(centre=(0.0, 0.0), einstein_radius=1.0),
)
tracer = al.Tracer.from_galaxies(
galaxies=[galaxy_mass, galaxy_point_source])
fit = al.FitPositionsSource(name="point_0",
positions=positions,
noise_map=noise_map,
tracer=tracer)
assert fit.model_positions.in_list == [(0.0, 0.0), (0.0, 1.0)]
assert fit.log_likelihood == pytest.approx(-1.6447298, 1.0e-4)
def test__modify_before_fit__inversion_no_positions_likelihood__raises_exception(
masked_imaging_7x7):
lens = al.Galaxy(redshift=0.5, mass=al.mp.SphIsothermal())
source = al.Galaxy(redshift=1.0,
pixelization=al.pix.Rectangular,
regularization=al.reg.Constant())
model = af.Collection(galaxies=af.Collection(lens=lens, source=source))
analysis = al.AnalysisImaging(dataset=masked_imaging_7x7)
with pytest.raises(exc.AnalysisException):
analysis.modify_before_fit(paths=af.DirectoryPaths(), model=model)
positions_likelihood = al.PositionsLHPenalty(positions=al.Grid2DIrregular([
(1.0, 100.0), (200.0, 2.0)
]),
threshold=0.01)
analysis = al.AnalysisImaging(dataset=masked_imaging_7x7,
positions_likelihood=positions_likelihood)
analysis.modify_before_fit(paths=af.DirectoryPaths(), model=model)
def test__results_include_positions__available_as_property(
analysis_imaging_7x7, masked_imaging_7x7, samples_with_result):
result = res.ResultDataset(samples=samples_with_result,
analysis=analysis_imaging_7x7,
model=None)
assert result.positions == None
positions_likelihood = al.PositionsLHResample(positions=al.Grid2DIrregular(
[(1.0, 100.0), (200.0, 2.0)]),
threshold=1.0)
analysis = al.AnalysisImaging(
dataset=masked_imaging_7x7,
positions_likelihood=positions_likelihood,
settings_lens=al.SettingsLens(threshold=1.0),
)
result = res.ResultDataset(samples=samples_with_result,
analysis=analysis,
model=None)
assert (result.positions[0] == np.array([1.0, 100.0])).all()
