def test__results_of_phase_include_positions__available_as_property( self, imaging_7x7, mask_7x7, samples_with_result ): phase_imaging_7x7 = al.PhaseImaging( phase_name="test_phase", search=mock.MockSearch(samples=samples_with_result) ) result = phase_imaging_7x7.run( dataset=imaging_7x7, mask=mask_7x7, results=mock.MockResults() ) assert result.positions == None phase_imaging_7x7 = al.PhaseImaging( phase_name="test_phase", galaxies=dict(lens=al.Galaxy(redshift=0.5), source=al.Galaxy(redshift=1.0)), search=mock.MockSearch(samples=samples_with_result), settings=al.SettingsPhaseImaging( settings_lens=al.SettingsLens(positions_threshold=1.0) ), ) imaging_7x7.positions = al.GridCoordinates([[(1.0, 1.0)]]) result = phase_imaging_7x7.run( dataset=imaging_7x7, mask=mask_7x7, results=mock.MockResults() ) assert (result.positions[0] == np.array([1.0, 1.0])).all()
def test__results_of_phase_include_pixelization__available_as_property( self, imaging_7x7, mask_7x7 ): lens = al.Galaxy(redshift=0.5, light=al.lp.EllipticalSersic(intensity=1.0)) source = al.Galaxy( redshift=1.0, pixelization=al.pix.VoronoiMagnification(shape=(2, 3)), regularization=al.reg.Constant(), ) tracer = al.Tracer.from_galaxies(galaxies=[lens, source]) samples = mock.MockSamples(max_log_likelihood_instance=tracer) phase_imaging_7x7 = al.PhaseImaging( phase_name="test_phase", settings=al.SettingsPhaseImaging(), search=mock.MockSearch(samples=samples), ) result = phase_imaging_7x7.run( dataset=imaging_7x7, mask=mask_7x7, results=mock.MockResults() ) assert isinstance(result.pixelization, al.pix.VoronoiMagnification) assert result.pixelization.shape == (2, 3) lens = al.Galaxy(redshift=0.5, light=al.lp.EllipticalSersic(intensity=1.0)) source = al.Galaxy( redshift=1.0, pixelization=al.pix.VoronoiBrightnessImage(pixels=6), regularization=al.reg.Constant(), ) source.hyper_galaxy_image = np.ones(9) tracer = al.Tracer.from_galaxies(galaxies=[lens, source]) samples = mock.MockSamples(max_log_likelihood_instance=tracer) phase_imaging_7x7 = al.PhaseImaging( phase_name="test_phase", settings=al.SettingsPhaseImaging(), search=mock.MockSearch(samples=samples), ) result = phase_imaging_7x7.run( dataset=imaging_7x7, mask=mask_7x7, results=mock.MockResults() ) assert isinstance(result.pixelization, al.pix.VoronoiBrightnessImage) assert result.pixelization.pixels == 6
def test__positions_are_input__are_used_in_analysis( self, image_7x7, noise_map_7x7, mask_7x7): # If position threshold is input (not None) and positions are input, make the positions part of the lens dataset. imaging_7x7 = al.Imaging( image=image_7x7, noise_map=noise_map_7x7, positions=al.GridCoordinates([[(1.0, 1.0), (2.0, 2.0)]]), ) phase_imaging_7x7 = al.PhaseImaging( phase_name="test_phase", search=mock.MockSearch(), settings=al.SettingsPhaseImaging(settings_lens=al.SettingsLens( positions_threshold=0.2)), ) phase_imaging_7x7.modify_dataset(dataset=imaging_7x7, results=mock.MockResults()) phase_imaging_7x7.modify_settings(dataset=imaging_7x7, results=mock.MockResults()) analysis = phase_imaging_7x7.make_analysis(dataset=imaging_7x7, mask=mask_7x7, results=mock.MockResults()) assert (analysis.masked_dataset.positions.in_list[0][0] == np.array( [1.0, 1.0])).all() assert (analysis.masked_dataset.positions.in_list[0][1] == np.array( [2.0, 2.0])).all() assert analysis.settings.settings_lens.positions_threshold == 0.2 # If position threshold is input (not None) and but no positions are supplied, raise an error with pytest.raises(exc.PhaseException): imaging_7x7 = al.Imaging(image=image_7x7, noise_map=noise_map_7x7, positions=None) phase_imaging_7x7 = al.PhaseImaging( phase_name="test_phase", search=mock.MockSearch(), settings=al.SettingsPhaseImaging(settings_lens=al.SettingsLens( positions_threshold=0.2)), ) phase_imaging_7x7.modify_dataset(dataset=imaging_7x7, results=mock.MockResults()) phase_imaging_7x7.modify_settings(dataset=imaging_7x7, results=mock.MockResults())
def test__fit_interferometer_generator_from_aggregator(interferometer_7, mask_7x7, samples): phase_interferometer_7x7 = al.PhaseInterferometer( phase_name="test_phase_aggregator", galaxies=dict( lens=al.GalaxyModel(redshift=0.5, light=al.lp.EllipticalSersic), source=al.GalaxyModel(redshift=1.0, light=al.lp.EllipticalSersic), ), search=mock.MockSearch(samples=samples), real_space_mask=mask_7x7, ) phase_interferometer_7x7.run( dataset=interferometer_7, mask=mask_7x7, results=mock.MockResults(samples=samples), ) agg = af.Aggregator(directory=phase_interferometer_7x7.paths.output_path) fit_interferometer_gen = al.agg.FitInterferometer(aggregator=agg) for fit_interferometer in fit_interferometer_gen: assert (fit_interferometer.masked_interferometer.interferometer. visibilities == interferometer_7.visibilities).all() assert (fit_interferometer.masked_interferometer.real_space_mask == mask_7x7).all()
def test__masked_imaging_generator_from_aggregator(imaging_7x7, mask_7x7, samples): phase_imaging_7x7 = al.PhaseImaging( phase_name="test_phase_aggregator", galaxies=dict( lens=al.GalaxyModel(redshift=0.5, light=al.lp.EllipticalSersic), source=al.GalaxyModel(redshift=1.0, light=al.lp.EllipticalSersic), ), settings=al.SettingsPhaseImaging( settings_masked_imaging=al.SettingsMaskedImaging( grid_class=al.GridIterate, grid_inversion_class=al.GridInterpolate, fractional_accuracy=0.5, sub_steps=[2], pixel_scales_interp=0.1, )), search=mock.MockSearch(samples=samples), ) phase_imaging_7x7.run(dataset=imaging_7x7, mask=mask_7x7, results=mock.MockResults(samples=samples)) agg = af.Aggregator(directory=phase_imaging_7x7.paths.output_path) masked_imaging_gen = al.agg.MaskedImaging(aggregator=agg) for masked_imaging in masked_imaging_gen: assert (masked_imaging.imaging.image == imaging_7x7.image).all() assert isinstance(masked_imaging.grid, al.GridIterate) assert isinstance(masked_imaging.grid_inversion, al.GridInterpolate) assert masked_imaging.grid.sub_steps == [2] assert masked_imaging.grid.fractional_accuracy == 0.5 assert masked_imaging.grid_inversion.pixel_scales_interp == (0.1, 0.1)
def test__positions_do_not_trace_within_threshold__raises_exception( self, phase_interferometer_7, interferometer_7, mask_7x7, visibilities_mask_7x2 ): interferometer_7.positions = al.GridCoordinates([[(1.0, 100.0), (200.0, 2.0)]]) phase_interferometer_7 = al.PhaseInterferometer( phase_name="test_phase", real_space_mask=mask_7x7, galaxies=dict( lens=al.Galaxy(redshift=0.5, mass=al.mp.SphericalIsothermal()), source=al.Galaxy(redshift=1.0), ), settings=al.SettingsPhaseInterferometer( settings_lens=al.SettingsLens(positions_threshold=0.01) ), search=mock.MockSearch(), ) analysis = phase_interferometer_7.make_analysis( dataset=interferometer_7, mask=visibilities_mask_7x2, results=mock.MockResults(), ) instance = phase_interferometer_7.model.instance_from_unit_vector([]) with pytest.raises(exc.RayTracingException): analysis.log_likelihood_function(instance=instance)
def __init__(self): self.phase_name = "phase_name" self.paths = autofit.non_linear.paths.Paths( name=self.phase_name, path_prefix="phase_path", folders=("",), tag="" ) self.search = mock.MockSearch(paths=self.paths) self.model = af.ModelMapper() self.settings = al.SettingsPhaseImaging(log_likelihood_cap=None) self.meta_dataset = MockMetaDataset(settings=self.settings)
def make_stochastic(): normal_phase = MockPhase() # noinspection PyUnusedLocal def run_hyper(*args, **kwargs): return mock.MockResult() return al.StochasticPhase( phase=normal_phase, search=mock.MockSearch(), model_classes=(al.mp.MassProfile,) )
def test__results_of_phase_include_mask__available_as_property( self, imaging_7x7, mask_7x7, samples_with_result ): phase_imaging_7x7 = al.PhaseImaging( phase_name="test_phase", galaxies=dict(lens=al.Galaxy(redshift=0.5), source=al.Galaxy(redshift=1.0)), search=mock.MockSearch(samples=samples_with_result), settings=al.SettingsPhaseImaging( settings_masked_imaging=al.SettingsMaskedImaging(sub_size=2) ), ) result = phase_imaging_7x7.run( dataset=imaging_7x7, mask=mask_7x7, results=mock.MockResults() ) assert (result.mask == mask_7x7).all()
def test__masked_interferometer_generator_from_aggregator( interferometer_7, mask_7x7, samples): phase_interferometer_7x7 = al.PhaseInterferometer( phase_name="test_phase_aggregator", galaxies=dict( lens=al.GalaxyModel(redshift=0.5, light=al.lp.EllipticalSersic), source=al.GalaxyModel(redshift=1.0, light=al.lp.EllipticalSersic), ), settings=al.SettingsPhaseInterferometer( masked_interferometer=al.SettingsMaskedInterferometer( transformer_class=al.TransformerDFT, grid_class=al.GridIterate, grid_inversion_class=al.GridInterpolate, fractional_accuracy=0.5, sub_steps=[2], pixel_scales_interp=0.1, )), search=mock.MockSearch(samples=samples), real_space_mask=mask_7x7, ) phase_interferometer_7x7.run( dataset=interferometer_7, mask=mask_7x7, results=mock.MockResults(samples=samples), ) agg = af.Aggregator(directory=phase_interferometer_7x7.paths.output_path) masked_interferometer_gen = al.agg.MaskedInterferometer(aggregator=agg) for masked_interferometer in masked_interferometer_gen: assert (masked_interferometer.interferometer.visibilities == interferometer_7.visibilities).all() assert (masked_interferometer.real_space_mask == mask_7x7).all() assert isinstance(masked_interferometer.grid, al.GridIterate) assert isinstance(masked_interferometer.grid_inversion, al.GridInterpolate) assert masked_interferometer.grid.sub_steps == [2] assert masked_interferometer.grid.fractional_accuracy == 0.5 assert masked_interferometer.grid_inversion.pixel_scales_interp == ( 0.1, 0.1) assert isinstance(masked_interferometer.transformer, al.TransformerDFT)
def test__fit_figure_of_merit__includes_hyper_image_and_noise__matches_fit( self, interferometer_7, mask_7x7, visibilities_mask_7x2 ): hyper_background_noise = al.hyper_data.HyperBackgroundNoise(noise_scale=1.0) lens_galaxy = al.Galaxy( redshift=0.5, light=al.lp.EllipticalSersic(intensity=0.1) ) phase_interferometer_7 = al.PhaseInterferometer( phase_name="test_phase", galaxies=dict(lens=lens_galaxy), hyper_background_noise=hyper_background_noise, settings=al.SettingsPhaseInterferometer( masked_interferometer=al.SettingsMaskedInterferometer(sub_size=4) ), search=mock.MockSearch(), real_space_mask=mask_7x7, ) analysis = phase_interferometer_7.make_analysis( dataset=interferometer_7, mask=visibilities_mask_7x2, results=mock.MockResults(), ) instance = phase_interferometer_7.model.instance_from_unit_vector([]) fit_figure_of_merit = analysis.log_likelihood_function(instance=instance) assert analysis.masked_interferometer.real_space_mask.sub_size == 4 masked_interferometer = al.MaskedInterferometer( interferometer=interferometer_7, visibilities_mask=visibilities_mask_7x2, real_space_mask=mask_7x7, settings=al.SettingsMaskedInterferometer(sub_size=4), ) tracer = analysis.tracer_for_instance(instance=instance) fit = FitInterferometer( masked_interferometer=masked_interferometer, tracer=tracer, hyper_background_noise=hyper_background_noise, ) assert fit.log_likelihood == fit_figure_of_merit
def test__phase_can_receive_hyper_image_and_noise_maps(self, mask_7x7): phase_interferometer_7 = al.PhaseInterferometer( phase_name="test_phase", galaxies=dict( lens=al.GalaxyModel(redshift=al.Redshift), lens1=al.GalaxyModel(redshift=al.Redshift), ), hyper_background_noise=al.hyper_data.HyperBackgroundNoise, search=mock.MockSearch(), real_space_mask=mask_7x7, ) instance = phase_interferometer_7.model.instance_from_vector( [0.1, 0.2, 0.3]) assert instance.galaxies[0].redshift == 0.1 assert instance.galaxies[1].redshift == 0.2 assert instance.hyper_background_noise.noise_scale == 0.3
def test__fit_using_interferometer( self, interferometer_7, mask_7x7, visibilities_mask_7x2, samples_with_result ): phase_interferometer_7 = al.PhaseInterferometer( phase_name="test_phase", galaxies=dict( lens=al.GalaxyModel(redshift=0.5, light=al.lp.EllipticalSersic), source=al.GalaxyModel(redshift=1.0, light=al.lp.EllipticalSersic), ), search=mock.MockSearch(samples=samples_with_result), real_space_mask=mask_7x7, ) result = phase_interferometer_7.run( dataset=interferometer_7, mask=visibilities_mask_7x2, results=mock.MockResults(), ) assert isinstance(result.instance.galaxies[0], al.Galaxy) assert isinstance(result.instance.galaxies[0], al.Galaxy)
def test__fit_figure_of_merit__matches_correct_fit_given_galaxy_profiles( self, interferometer_7, mask_7x7, visibilities_mask_7x2 ): lens_galaxy = al.Galaxy( redshift=0.5, light=al.lp.EllipticalSersic(intensity=0.1) ) phase_interferometer_7 = al.PhaseInterferometer( phase_name="test_phase", galaxies=dict(lens=lens_galaxy), cosmology=cosmo.FLRW, settings=al.SettingsPhaseInterferometer( masked_interferometer=al.SettingsMaskedInterferometer(sub_size=2) ), search=mock.MockSearch(), real_space_mask=mask_7x7, ) analysis = phase_interferometer_7.make_analysis( dataset=interferometer_7, mask=visibilities_mask_7x2, results=mock.MockResults(), ) instance = phase_interferometer_7.model.instance_from_unit_vector([]) fit_figure_of_merit = analysis.log_likelihood_function(instance=instance) masked_interferometer = al.MaskedInterferometer( interferometer=interferometer_7, visibilities_mask=visibilities_mask_7x2, real_space_mask=mask_7x7, settings=al.SettingsMaskedInterferometer(sub_size=2), ) tracer = analysis.tracer_for_instance(instance=instance) fit = al.FitInterferometer( masked_interferometer=masked_interferometer, tracer=tracer ) assert fit.log_likelihood == fit_figure_of_merit
def test__log_likelihood_cap(self, interferometer_7, mask_7x7): lens_galaxy = al.Galaxy(redshift=0.5, light=al.lp.EllipticalSersic(intensity=0.1)) phase_imaging_7x7 = al.PhaseInterferometer( phase_name="test_phase", galaxies=dict(lens=lens_galaxy), settings=al.SettingsPhaseInterferometer( masked_interferometer=al.SettingsMaskedInterferometer( sub_size=1), log_likelihood_cap=100.0, ), search=mock.MockSearch(), real_space_mask=mask_7x7, ) analysis = phase_imaging_7x7.make_analysis(dataset=interferometer_7, mask=mask_7x7, results=mock.MockResults()) assert analysis.log_likelihood_cap == 100.0
def test__fit_imaging_generator_from_aggregator(imaging_7x7, mask_7x7, samples): phase_imaging_7x7 = al.PhaseImaging( phase_name="test_phase_aggregator", galaxies=dict( lens=al.GalaxyModel(redshift=0.5, light=al.lp.EllipticalSersic), source=al.GalaxyModel(redshift=1.0, light=al.lp.EllipticalSersic), ), search=mock.MockSearch(samples=samples), ) phase_imaging_7x7.run(dataset=imaging_7x7, mask=mask_7x7, results=mock.MockResults(samples=samples)) agg = af.Aggregator(directory=phase_imaging_7x7.paths.output_path) fit_imaging_gen = al.agg.FitImaging(aggregator=agg) for fit_imaging in fit_imaging_gen: assert (fit_imaging.masked_imaging.imaging.image == imaging_7x7.image ).all()
def test__tracer_generator_from_aggregator(imaging_7x7, mask_7x7, samples): phase_imaging_7x7 = al.PhaseImaging( phase_name="test_phase_aggregator", galaxies=dict( lens=al.GalaxyModel(redshift=0.5, light=al.lp.EllipticalSersic), source=al.GalaxyModel(redshift=1.0, light=al.lp.EllipticalSersic), ), search=mock.MockSearch(samples=samples), ) phase_imaging_7x7.run(dataset=imaging_7x7, mask=mask_7x7, results=mock.MockResults(samples=samples)) agg = af.Aggregator(directory=phase_imaging_7x7.paths.output_path) tracer_gen = al.agg.Tracer(aggregator=agg) for tracer in tracer_gen: assert tracer.galaxies[0].redshift == 0.5 assert tracer.galaxies[0].light.centre == (0.0, 1.0) assert tracer.galaxies[1].redshift == 1.0
def test__use_border__determines_if_border_pixel_relocation_is_used( self, imaging_7x7, mask_7x7): # noinspection PyTypeChecker lens_galaxy = al.Galaxy( redshift=0.5, mass=al.mp.SphericalIsothermal(einstein_radius=100.0)) source_galaxy = al.Galaxy( redshift=1.0, pixelization=al.pix.Rectangular(shape=(3, 3)), regularization=al.reg.Constant(coefficient=1.0), ) phase_imaging_7x7 = al.PhaseImaging( phase_name="test_phase", galaxies=[lens_galaxy, source_galaxy], settings=al.SettingsPhaseImaging( settings_masked_imaging=al.SettingsMaskedImaging( grid_inversion_class=al.Grid), settings_pixelization=al.SettingsPixelization(use_border=True), ), search=mock.MockSearch(), ) analysis = phase_imaging_7x7.make_analysis(dataset=imaging_7x7, mask=mask_7x7, results=mock.MockResults()) analysis.masked_dataset.grid_inversion[4] = np.array([[500.0, 0.0]]) instance = phase_imaging_7x7.model.instance_from_unit_vector([]) tracer = analysis.tracer_for_instance(instance=instance) fit = analysis.masked_imaging_fit_for_tracer( tracer=tracer, hyper_image_sky=None, hyper_background_noise=None) assert fit.inversion.mapper.grid[4][0] == pytest.approx( 97.19584, 1.0e-2) assert fit.inversion.mapper.grid[4][1] == pytest.approx( -3.699999, 1.0e-2) phase_imaging_7x7 = al.PhaseImaging( phase_name="test_phase", galaxies=[lens_galaxy, source_galaxy], settings=al.SettingsPhaseImaging( settings_masked_imaging=al.SettingsMaskedImaging( grid_inversion_class=al.Grid), settings_pixelization=al.SettingsPixelization( use_border=False), ), search=mock.MockSearch(), ) analysis = phase_imaging_7x7.make_analysis(dataset=imaging_7x7, mask=mask_7x7, results=mock.MockResults()) analysis.masked_dataset.grid_inversion[4] = np.array([300.0, 0.0]) instance = phase_imaging_7x7.model.instance_from_unit_vector([]) tracer = analysis.tracer_for_instance(instance=instance) fit = analysis.masked_imaging_fit_for_tracer( tracer=tracer, hyper_image_sky=None, hyper_background_noise=None) assert fit.inversion.mapper.grid[4][0] == pytest.approx(200.0, 1.0e-4)
def test__uses_auto_update_factor(self, image_7x7, noise_map_7x7, mask_7x7): tracer = al.Tracer.from_galaxies( galaxies=[al.Galaxy(redshift=0.5), al.Galaxy(redshift=1.0)]) # Auto positioning is OFF, so use input positions + threshold. imaging_7x7 = al.Imaging( image=image_7x7, noise_map=noise_map_7x7, positions=al.GridCoordinates([[(1.0, 1.0)]]), ) phase_imaging_7x7 = al.PhaseImaging( phase_name="test_phase", search=mock.MockSearch(), settings=al.SettingsPhaseImaging(settings_lens=al.SettingsLens( positions_threshold=0.1)), ) results = mock.MockResults(max_log_likelihood_tracer=tracer) phase_imaging_7x7.modify_dataset(dataset=imaging_7x7, results=results) phase_imaging_7x7.modify_settings(dataset=imaging_7x7, results=results) analysis = phase_imaging_7x7.make_analysis(dataset=imaging_7x7, mask=mask_7x7, results=results) assert analysis.settings.settings_lens.positions_threshold == 0.1 # Auto positioning is ON, but there are no previous results, so use separate of postiions x positions factor.. imaging_7x7 = al.Imaging( image=image_7x7, noise_map=noise_map_7x7, positions=al.GridCoordinates([[(1.0, 0.0), (-1.0, 0.0)]]), ) phase_imaging_7x7 = al.PhaseImaging( phase_name="test_phase", search=mock.MockSearch(), settings=al.SettingsPhaseImaging(settings_lens=al.SettingsLens( positions_threshold=0.1, auto_positions_factor=1.0)), ) results = mock.MockResults(max_log_likelihood_tracer=tracer) phase_imaging_7x7.modify_dataset(dataset=imaging_7x7, results=results) phase_imaging_7x7.modify_settings(dataset=imaging_7x7, results=results) analysis = phase_imaging_7x7.make_analysis(dataset=imaging_7x7, mask=mask_7x7, results=results) assert analysis.settings.settings_lens.positions_threshold == 2.0 # Auto position is ON, and same as above but with a factor of 3.0 which increases the threshold. imaging_7x7 = al.Imaging( image=image_7x7, noise_map=noise_map_7x7, positions=al.GridCoordinates([[(1.0, 0.0), (-1.0, 0.0)]]), ) phase_imaging_7x7 = al.PhaseImaging( phase_name="test_phase", search=mock.MockSearch(), settings=al.SettingsPhaseImaging(settings_lens=al.SettingsLens( positions_threshold=0.2, auto_positions_factor=3.0)), ) results = mock.MockResults(max_log_likelihood_tracer=tracer, updated_positions_threshold=0.2) phase_imaging_7x7.modify_dataset(dataset=imaging_7x7, results=results) phase_imaging_7x7.modify_settings(dataset=imaging_7x7, results=results) analysis = phase_imaging_7x7.make_analysis(dataset=imaging_7x7, mask=mask_7x7, results=results) assert analysis.settings.settings_lens.positions_threshold == 6.0 # Auto position is ON, and same as above but with a minimum auto positions threshold that rounds the value up. imaging_7x7 = al.Imaging( image=image_7x7, noise_map=noise_map_7x7, positions=al.GridCoordinates([[(1.0, 0.0), (-1.0, 0.0)]]), ) phase_imaging_7x7 = al.PhaseImaging( phase_name="test_phase", search=mock.MockSearch(), settings=al.SettingsPhaseImaging(settings_lens=al.SettingsLens( positions_threshold=0.2, auto_positions_factor=3.0, auto_positions_minimum_threshold=10.0, )), ) results = mock.MockResults(max_log_likelihood_tracer=tracer, updated_positions_threshold=0.2) phase_imaging_7x7.modify_dataset(dataset=imaging_7x7, results=results) phase_imaging_7x7.modify_settings(dataset=imaging_7x7, results=results) analysis = phase_imaging_7x7.make_analysis(dataset=imaging_7x7, mask=mask_7x7, results=results) assert analysis.settings.settings_lens.positions_threshold == 10.0 # Auto positioning is ON, but positions are None and it cannot find new positions so no threshold. imaging_7x7 = al.Imaging(image=image_7x7, noise_map=noise_map_7x7, positions=None) phase_imaging_7x7 = al.PhaseImaging( phase_name="test_phase", search=mock.MockSearch(), settings=al.SettingsPhaseImaging(settings_lens=al.SettingsLens( auto_positions_factor=1.0)), ) results = mock.MockResults(max_log_likelihood_tracer=tracer) phase_imaging_7x7.modify_dataset(dataset=imaging_7x7, results=results) phase_imaging_7x7.modify_settings(dataset=imaging_7x7, results=results) analysis = phase_imaging_7x7.make_analysis(dataset=imaging_7x7, mask=mask_7x7, results=results) assert analysis.settings.settings_lens.positions_threshold == None
def test__updates_correct_using_factor(self, imaging_7x7, image_7x7, noise_map_7x7, mask_7x7): tracer = al.Tracer.from_galaxies( galaxies=[al.Galaxy(redshift=0.5), al.Galaxy(redshift=1.0)]) # Auto positioning is OFF, so use input positions + threshold. imaging_7x7 = al.Imaging( image=image_7x7, noise_map=noise_map_7x7, positions=al.GridCoordinates([[(1.0, 1.0)]]), ) phase_imaging_7x7 = al.PhaseImaging( phase_name="test_phase", search=mock.MockSearch(), settings=al.SettingsPhaseImaging(settings_lens=al.SettingsLens( positions_threshold=0.1)), ) results = mock.MockResults(max_log_likelihood_tracer=tracer) phase_imaging_7x7.modify_dataset(dataset=imaging_7x7, results=results) analysis = phase_imaging_7x7.make_analysis(dataset=imaging_7x7, mask=mask_7x7, results=results) assert analysis.masked_dataset.positions.in_list == [[(1.0, 1.0)]] # Auto positioning is ON, but there are no previous results, so use input positions. imaging_7x7 = al.Imaging( image=image_7x7, noise_map=noise_map_7x7, positions=al.GridCoordinates([[(1.0, 1.0)]]), ) phase_imaging_7x7 = al.PhaseImaging( phase_name="test_phase", search=mock.MockSearch(), settings=al.SettingsPhaseImaging(settings_lens=al.SettingsLens( positions_threshold=0.2, auto_positions_factor=2.0)), ) phase_imaging_7x7.modify_dataset(dataset=imaging_7x7, results=results) analysis = phase_imaging_7x7.make_analysis(dataset=imaging_7x7, mask=mask_7x7, results=results) assert analysis.masked_dataset.positions.in_list == [[(1.0, 1.0)]] # Auto positioning is ON, there are previous results so use their new positions and threshold (which is # multiplied by the auto_positions_factor). However, only one set of positions is computed from the previous # result, to use input positions. imaging_7x7 = al.Imaging( image=image_7x7, noise_map=noise_map_7x7, positions=al.GridCoordinates([[(1.0, 1.0)]]), ) phase_imaging_7x7 = al.PhaseImaging( phase_name="test_phase", search=mock.MockSearch(), settings=al.SettingsPhaseImaging(settings_lens=al.SettingsLens( positions_threshold=0.2, auto_positions_factor=2.0)), ) results = mock.MockResults( max_log_likelihood_tracer=tracer, updated_positions=al.GridCoordinates(coordinates=[[(2.0, 2.0)]]), updated_positions_threshold=0.3, ) phase_imaging_7x7.modify_dataset(dataset=imaging_7x7, results=results) analysis = phase_imaging_7x7.make_analysis(dataset=imaging_7x7, mask=mask_7x7, results=results) assert analysis.masked_dataset.positions.in_list == [[(1.0, 1.0)]] # Auto positioning is ON, but the tracer only has a single plane and thus no lensing, so use input positions. imaging_7x7 = al.Imaging( image=image_7x7, noise_map=noise_map_7x7, positions=al.GridCoordinates([[(1.0, 1.0)]]), ) phase_imaging_7x7 = al.PhaseImaging( phase_name="test_phase", search=mock.MockSearch(), settings=al.SettingsPhaseImaging(settings_lens=al.SettingsLens( positions_threshold=0.2, auto_positions_factor=1.0)), ) tracer_x1_plane = al.Tracer.from_galaxies( galaxies=[al.Galaxy(redshift=0.5)]) results = mock.MockResults( max_log_likelihood_tracer=tracer_x1_plane, updated_positions=al.GridCoordinates(coordinates=[[(2.0, 2.0), (3.0, 3.0)]]), updated_positions_threshold=0.3, ) phase_imaging_7x7.modify_dataset(dataset=imaging_7x7, results=results) analysis = phase_imaging_7x7.make_analysis(dataset=imaging_7x7, mask=mask_7x7, results=results) assert analysis.masked_dataset.positions.in_list == [[(1.0, 1.0)]] # Auto positioning is ON, there are previous results so use their new positions and threshold (which is # multiplied by the auto_positions_factor). Multiple positions are available so these are now used. imaging_7x7 = al.Imaging( image=image_7x7, noise_map=noise_map_7x7, positions=al.GridCoordinates([[(1.0, 1.0)]]), ) phase_imaging_7x7 = al.PhaseImaging( phase_name="test_phase", search=mock.MockSearch(), settings=al.SettingsPhaseImaging(settings_lens=al.SettingsLens( positions_threshold=0.2, auto_positions_factor=2.0)), ) results = mock.MockResults( max_log_likelihood_tracer=tracer, updated_positions=al.GridCoordinates(coordinates=[[(2.0, 2.0), (3.0, 3.0)]]), updated_positions_threshold=0.3, ) phase_imaging_7x7.modify_dataset(dataset=imaging_7x7, results=results) analysis = phase_imaging_7x7.make_analysis(dataset=imaging_7x7, mask=mask_7x7, results=results) assert analysis.masked_dataset.positions.in_list == [[(2.0, 2.0), (3.0, 3.0)]] # Auto positioning is Off, but there are previous results with updated positions relative to the input # positions, so use those with their positions threshold. imaging_7x7 = al.Imaging( image=image_7x7, noise_map=noise_map_7x7, positions=al.GridCoordinates([[(2.0, 2.0)]]), ) phase_imaging_7x7 = al.PhaseImaging( phase_name="test_phase", search=mock.MockSearch(), settings=al.SettingsPhaseImaging(settings_lens=al.SettingsLens( positions_threshold=0.1)), ) results = mock.MockResults( max_log_likelihood_tracer=tracer, positions=al.GridCoordinates(coordinates=[[(3.0, 3.0), (4.0, 4.0)]]), updated_positions_threshold=0.3, ) phase_imaging_7x7.modify_dataset(dataset=imaging_7x7, results=results) analysis = phase_imaging_7x7.make_analysis(dataset=imaging_7x7, mask=mask_7x7, results=results) assert analysis.masked_dataset.positions.in_list == [[(3.0, 3.0), (4.0, 4.0)]]
def make_phase_data(mask_7x7): return al.PhaseDataset(phase_name="test_phase", search=mock.MockSearch())
def make_phase_imaging_7x7(): return al.PhaseImaging(phase_name="test_phase", search=mock.MockSearch())
def test__phase_is_extended_with_hyper_phases__sets_up_hyper_images( self, interferometer_7, mask_7x7): galaxies = af.ModelInstance() galaxies.lens = al.Galaxy(redshift=0.5) galaxies.source = al.Galaxy(redshift=1.0) instance = af.ModelInstance() instance.galaxies = galaxies hyper_galaxy_image_path_dict = { ("galaxies", "lens"): al.Array.ones(shape_2d=(3, 3), pixel_scales=1.0), ("galaxies", "source"): al.Array.full(fill_value=2.0, shape_2d=(3, 3), pixel_scales=1.0), } hyper_galaxy_visibilities_path_dict = { ("galaxies", "lens"): al.Visibilities.full(fill_value=4.0, shape_1d=(7, )), ("galaxies", "source"): al.Visibilities.full(fill_value=5.0, shape_1d=(7, )), } results = mock.MockResults( hyper_galaxy_image_path_dict=hyper_galaxy_image_path_dict, hyper_model_image=al.Array.full(fill_value=3.0, shape_2d=(3, 3)), hyper_galaxy_visibilities_path_dict= hyper_galaxy_visibilities_path_dict, hyper_model_visibilities=al.Visibilities.full(fill_value=6.0, shape_1d=(7, )), mask=mask_7x7, use_as_hyper_dataset=True, ) phase_interferometer_7 = al.PhaseInterferometer( phase_name="test_phase", galaxies=dict(lens=al.GalaxyModel(redshift=0.5, hyper_galaxy=al.HyperGalaxy)), search=mock.MockSearch(), real_space_mask=mask_7x7, ) phase_interferometer_7.extend_with_multiple_hyper_phases( setup=al.SetupPipeline()) analysis = phase_interferometer_7.make_analysis( dataset=interferometer_7, mask=mask_7x7, results=results) assert (analysis.hyper_galaxy_image_path_dict[( "galaxies", "lens")].in_2d == np.ones((3, 3))).all() assert (analysis.hyper_galaxy_image_path_dict[( "galaxies", "source")].in_2d == 2.0 * np.ones((3, 3))).all() assert (analysis.hyper_model_image.in_2d == 3.0 * np.ones( (3, 3))).all() assert (analysis.hyper_galaxy_visibilities_path_dict[("galaxies", "lens")] == 4.0 * np.ones((7, 2))).all() assert (analysis.hyper_galaxy_visibilities_path_dict[( "galaxies", "source")] == 5.0 * np.ones((7, 2))).all() assert (analysis.hyper_model_visibilities == 6.0 * np.ones( (7, 2))).all()
def test__masked_interferometer__settings_inputs_are_used_in_masked_interferometer( self, interferometer_7, mask_7x7): phase_interferometer_7 = al.PhaseInterferometer( phase_name="phase_interferometer_7", settings=al.SettingsPhaseInterferometer( masked_interferometer=al.SettingsMaskedInterferometer( grid_class=al.Grid, grid_inversion_class=al.Grid, sub_size=3, signal_to_noise_limit=1.0, ), settings_pixelization=al.SettingsPixelization( use_border=False, is_stochastic=True), settings_inversion=al.SettingsInversion( use_linear_operators=True), ), search=mock.MockSearch(), real_space_mask=mask_7x7, ) assert (phase_interferometer_7.settings.settings_masked_interferometer. sub_size == 3) assert (phase_interferometer_7.settings.settings_masked_interferometer. signal_to_noise_limit == 1.0) assert phase_interferometer_7.settings.settings_pixelization.use_border == False assert (phase_interferometer_7.settings.settings_pixelization. is_stochastic == True) assert (phase_interferometer_7.settings.settings_inversion. use_linear_operators == True) analysis = phase_interferometer_7.make_analysis( dataset=interferometer_7, mask=mask_7x7, results=mock.MockResults()) assert isinstance(analysis.masked_dataset.grid, al.Grid) assert isinstance(analysis.masked_dataset.grid_inversion, al.Grid) assert isinstance(analysis.masked_dataset.transformer, al.TransformerNUFFT) phase_interferometer_7 = al.PhaseInterferometer( phase_name="phase_interferometer_7", settings=al.SettingsPhaseInterferometer( masked_interferometer=al.SettingsMaskedInterferometer( grid_class=al.GridIterate, sub_size=3, fractional_accuracy=0.99, sub_steps=[2], transformer_class=al.TransformerDFT, )), search=mock.MockSearch(), real_space_mask=mask_7x7, ) analysis = phase_interferometer_7.make_analysis( dataset=interferometer_7, mask=mask_7x7, results=mock.MockResults()) assert isinstance(analysis.masked_dataset.grid, al.GridIterate) assert analysis.masked_dataset.grid.sub_size == 1 assert analysis.masked_dataset.grid.fractional_accuracy == 0.99 assert analysis.masked_dataset.grid.sub_steps == [2] assert isinstance(analysis.masked_dataset.transformer, al.TransformerDFT)
def make_phase_interferometer_7(mask_7x7): return al.PhaseInterferometer( phase_name="test_phase", search=mock.MockSearch(), real_space_mask=mask_7x7 )