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