def test__mask_changes_sub_size_depending_on_phase_attribute( self, phase_imaging_7x7, imaging_7x7): # If an input mask is supplied we use mask input. mask_input = al.Mask.circular(shape_2d=imaging_7x7.shape_2d, pixel_scales=1, sub_size=1, radius=1.5) phase_imaging_7x7.meta_dataset.sub_size = 1 analysis = phase_imaging_7x7.make_analysis( dataset=imaging_7x7, mask=mask_input, results=mock_pipeline.MockResults()) assert (analysis.masked_imaging.mask == mask_input).all() assert analysis.masked_imaging.mask.sub_size == 1 assert analysis.masked_imaging.mask.pixel_scales == mask_input.pixel_scales phase_imaging_7x7.meta_dataset.sub_size = 2 analysis = phase_imaging_7x7.make_analysis( dataset=imaging_7x7, mask=mask_input, results=mock_pipeline.MockResults()) assert (analysis.masked_imaging.mask == mask_input).all() assert analysis.masked_imaging.mask.sub_size == 2 assert analysis.masked_imaging.mask.pixel_scales == mask_input.pixel_scales
def test__auto_positions_update_threshold__uses_auto_update_factor( self, phase_imaging_7x7, phase_interferometer_7, imaging_7x7, interferometer_7, mask_7x7, ): # Auto positioning is OFF, so use input positions + threshold. phase_imaging_7x7.meta_dataset.positions_threshold = 0.1 phase_imaging_7x7.meta_dataset.auto_positions_factor = None analysis = phase_imaging_7x7.make_analysis( dataset=imaging_7x7, mask=mask_7x7, positions=al.Coordinates(coordinates=[[(1.0, 1.0)]]), results=mock_pipeline.MockResults(), ) assert analysis.masked_dataset.positions_threshold == 0.1 # Auto positioning is ON, but there are no previous results, so use input positions. phase_imaging_7x7.meta_dataset.auto_positions_factor = 1.0 analysis = phase_imaging_7x7.make_analysis( dataset=imaging_7x7, mask=mask_7x7, positions=al.Coordinates(coordinates=[[(1.0, 0.0), (-1.0, 0.0)]]), results=mock_pipeline.MockResults(), ) assert analysis.masked_dataset.positions_threshold == 2.0 phase_imaging_7x7.meta_dataset.positions_threshold = 0.2 phase_imaging_7x7.meta_dataset.auto_positions_factor = 3.0 analysis = phase_imaging_7x7.make_analysis( dataset=imaging_7x7, mask=mask_7x7, positions=al.Coordinates(coordinates=[[(1.0, 0.0), (-1.0, 0.0)]]), results=mock_pipeline.MockResults(updated_positions_threshold=0.2), ) assert analysis.masked_dataset.positions_threshold == 6.0 # Auto positioning is ON, but positionos are None so no update. phase_imaging_7x7.meta_dataset.auto_positions_factor = 1.0 phase_imaging_7x7.positions_threshold = None analysis = phase_imaging_7x7.make_analysis( dataset=imaging_7x7, mask=mask_7x7, results=mock_pipeline.MockResults() ) assert analysis.masked_dataset.positions_threshold == None
def test__use_border__determines_if_border_pixel_relocation_is_used( self, imaging_7x7, mask_7x7 ): # noinspection PyTypeChecker lens_galaxy = al.Galaxy( redshift=0.5, mass=al.mp.SphericalIsothermal(einstein_radius=100.0) ) source_galaxy = al.Galaxy( redshift=1.0, pixelization=al.pix.Rectangular(shape=(3, 3)), regularization=al.reg.Constant(coefficient=1.0), ) phase_imaging_7x7 = al.PhaseImaging( galaxies=[lens_galaxy, source_galaxy], cosmology=cosmo.Planck15, phase_name="test_phase", inversion_uses_border=True, ) analysis = phase_imaging_7x7.make_analysis( dataset=imaging_7x7, mask=mask_7x7, results=mock_pipeline.MockResults() ) analysis.masked_dataset.grid[4] = np.array([[500.0, 0.0]]) instance = phase_imaging_7x7.model.instance_from_unit_vector([]) tracer = analysis.tracer_for_instance(instance=instance) fit = analysis.masked_imaging_fit_for_tracer( tracer=tracer, hyper_image_sky=None, hyper_background_noise=None ) assert fit.inversion.mapper.grid[4][0] == pytest.approx(97.19584, 1.0e-2) assert fit.inversion.mapper.grid[4][1] == pytest.approx(-3.699999, 1.0e-2) phase_imaging_7x7 = al.PhaseImaging( galaxies=[lens_galaxy, source_galaxy], cosmology=cosmo.Planck15, phase_name="test_phase", inversion_uses_border=False, ) analysis = phase_imaging_7x7.make_analysis( dataset=imaging_7x7, mask=mask_7x7, results=mock_pipeline.MockResults() ) analysis.masked_dataset.grid[4] = np.array([300.0, 0.0]) instance = phase_imaging_7x7.model.instance_from_unit_vector([]) tracer = analysis.tracer_for_instance(instance=instance) fit = analysis.masked_imaging_fit_for_tracer( tracer=tracer, hyper_image_sky=None, hyper_background_noise=None ) assert fit.inversion.mapper.grid[4][0] == pytest.approx(200.0, 1.0e-4)
def test__most_likely_tracer_source_inversion_centres_correct( self, imaging_7x7, mask_7x7): phase_dataset_7x7 = al.PhaseImaging( non_linear_class=mock_pipeline.MockNLO, galaxies=dict( lens=al.Galaxy(redshift=0.5, light=al.lp.EllipticalSersic(intensity=1.0)), source=al.Galaxy( redshift=1.0, pixelization=al.pix.Rectangular((3, 3)), regularization=al.reg.Constant(coefficient=1.0), ), ), phase_name="test_phase_2", ) result = phase_dataset_7x7.run(dataset=imaging_7x7, mask=mask_7x7, results=mock_pipeline.MockResults()) assert result.most_likely_fit.inversion.reconstruction == pytest.approx( np.array([ 0.80707817, 0.80929118, 0.80707817, 0.80929118, 0.81251066, 0.80929118, 0.80707817, 0.80929118, 0.80707817, ]), 1.0e-4, ) assert result.source_plane_inversion_centres == [(0.0, 0.0)] phase_dataset_7x7 = al.PhaseImaging( non_linear_class=mock_pipeline.MockNLO, galaxies=dict( lens=al.Galaxy(redshift=0.5, light=al.lp.EllipticalSersic(intensity=1.0)), source=al.Galaxy(redshift=1.0), ), phase_name="test_phase_2", ) result = phase_dataset_7x7.run(dataset=imaging_7x7, mask=mask_7x7, results=mock_pipeline.MockResults()) assert result.source_plane_inversion_centres == []
def test__results_of_phase_include_pixelization__available_as_property( self, imaging_7x7, mask_7x7): phase_imaging_7x7 = al.PhaseImaging( non_linear_class=mock_pipeline.MockNLO, galaxies=dict( lens=al.Galaxy(redshift=0.5, light=al.lp.EllipticalSersic(intensity=1.0)), source=al.Galaxy( redshift=1.0, pixelization=al.pix.VoronoiMagnification(shape=(2, 3)), regularization=al.reg.Constant(), ), ), inversion_pixel_limit=6, phase_name="test_phase_2", ) result = phase_imaging_7x7.run(dataset=imaging_7x7, mask=mask_7x7, results=mock_pipeline.MockResults()) assert isinstance(result.pixelization, al.pix.VoronoiMagnification) assert result.pixelization.shape == (2, 3) phase_imaging_7x7 = al.PhaseImaging( non_linear_class=mock_pipeline.MockNLO, galaxies=dict( lens=al.Galaxy(redshift=0.5, light=al.lp.EllipticalSersic(intensity=1.0)), source=al.Galaxy( redshift=1.0, pixelization=al.pix.VoronoiBrightnessImage(pixels=6), regularization=al.reg.Constant(), ), ), inversion_pixel_limit=6, phase_name="test_phase_2", ) phase_imaging_7x7.galaxies.source.hyper_galaxy_image = np.ones(9) result = phase_imaging_7x7.run(dataset=imaging_7x7, mask=mask_7x7, results=mock_pipeline.MockResults()) assert isinstance(result.pixelization, al.pix.VoronoiBrightnessImage) assert result.pixelization.pixels == 6
def test__fit_figure_of_merit__matches_correct_fit_given_galaxy_profiles( self, interferometer_7, mask_7x7, visibilities_mask_7x2): lens_galaxy = al.Galaxy(redshift=0.5, light=al.lp.EllipticalSersic(intensity=0.1)) phase_interferometer_7 = al.PhaseInterferometer( real_space_mask=mask_7x7, galaxies=[lens_galaxy], cosmology=cosmo.FLRW, sub_size=2, phase_name="test_phase", ) analysis = phase_interferometer_7.make_analysis( dataset=interferometer_7, mask=visibilities_mask_7x2, results=mock_pipeline.MockResults(), ) instance = phase_interferometer_7.model.instance_from_unit_vector([]) fit_figure_of_merit = analysis.fit(instance=instance) real_space_mask = phase_interferometer_7.meta_dataset.mask_with_phase_sub_size_from_mask( mask=mask_7x7) masked_interferometer = al.MaskedInterferometer( interferometer=interferometer_7, visibilities_mask=visibilities_mask_7x2, real_space_mask=real_space_mask, ) tracer = analysis.tracer_for_instance(instance=instance) fit = al.FitInterferometer(masked_interferometer=masked_interferometer, tracer=tracer) assert fit.likelihood == fit_figure_of_merit
def make_results(mask_7x7, hyper_model_image_7x7, hyper_galaxy_image_0_7x7, hyper_galaxy_image_1_7x7): return mock_pipeline.MockResults( model_image=hyper_model_image_7x7, galaxy_images=[hyper_galaxy_image_0_7x7, hyper_galaxy_image_1_7x7], mask=mask_7x7, )
def test__phase_info_is_made(self, phase_interferometer_7, interferometer_7, visibilities_mask_7x2): phase_interferometer_7.make_analysis( dataset=interferometer_7, mask=visibilities_mask_7x2, results=mock_pipeline.MockResults(), ) file_phase_info = "{}/{}".format( phase_interferometer_7.optimizer.paths.phase_output_path, "phase.info") phase_info = open(file_phase_info, "r") optimizer = phase_info.readline() sub_size = phase_info.readline() primary_beam_shape_2d = phase_info.readline() positions_threshold = phase_info.readline() cosmology = phase_info.readline() phase_info.close() assert optimizer == "Optimizer = MockNLO \n" assert sub_size == "Sub-grid size = 2 \n" assert primary_beam_shape_2d == "Primary Beam shape = None \n" assert positions_threshold == "Positions Threshold = None \n" assert ( cosmology == 'Cosmology = FlatLambdaCDM(name="Planck15", H0=67.7 km / (Mpc s), Om0=0.307, Tcmb0=2.725 K, ' "Neff=3.05, m_nu=[0. 0. 0.06] eV, Ob0=0.0486) \n")
def test__customize(self, imaging_7x7, mask_7x7): class MyPlanePhaseAnd(al.PhaseImaging): def customize_priors(self, results): self.galaxies = results.last.instance.galaxies results = mock_pipeline.MockResults() galaxy = al.Galaxy(redshift=0.5) galaxy_model = al.GalaxyModel(redshift=0.5) setattr(results[0].instance, "galaxies", [galaxy]) setattr(results[0].model, "galaxies", [galaxy_model]) phase_dataset_7x7 = MyPlanePhaseAnd( phase_name="test_phase", non_linear_class=mock_pipeline.MockNLO) phase_dataset_7x7.make_analysis(dataset=imaging_7x7, mask=mask_7x7, results=results) phase_dataset_7x7.customize_priors(results=results) assert phase_dataset_7x7.galaxies == [galaxy] class MyPlanePhaseAnd(al.PhaseImaging): def customize_priors(self, results): self.galaxies = results.last.model.galaxies results = mock_pipeline.MockResults() galaxy = al.Galaxy(redshift=0.5) galaxy_model = al.GalaxyModel(redshift=0.5) setattr(results[0].instance, "galaxies", [galaxy]) setattr(results[0].model, "galaxies", [galaxy_model]) phase_dataset_7x7 = MyPlanePhaseAnd( phase_name="test_phase", non_linear_class=mock_pipeline.MockNLO) phase_dataset_7x7.make_analysis(dataset=imaging_7x7, mask=mask_7x7, results=results) phase_dataset_7x7.customize_priors(results) assert phase_dataset_7x7.galaxies == [galaxy_model]
def test__uses_pixelization_preload_grids_if_possible( self, imaging_7x7, mask_7x7): phase_dataset_7x7 = al.PhaseImaging(phase_name="test_phase") analysis = phase_dataset_7x7.make_analysis( dataset=imaging_7x7, mask=mask_7x7, results=mock_pipeline.MockResults()) assert analysis.masked_dataset.preload_sparse_grids_of_planes is None
def test__pixel_scale_interpolation_grid_is_input__interp_grid_used_in_analysis( self, phase_imaging_7x7, imaging_7x7, mask_7x7): # If use positions is true and positions are input, make the positions part of the lens dataset. phase_imaging_7x7.meta_dataset.pixel_scale_interpolation_grid = 0.1 analysis = phase_imaging_7x7.make_analysis( dataset=imaging_7x7, mask=mask_7x7, results=mock_pipeline.MockResults()) assert analysis.masked_imaging.pixel_scale_interpolation_grid == 0.1 assert hasattr(analysis.masked_imaging.grid, "interpolator") assert hasattr(analysis.masked_imaging.blurring_grid, "interpolator")
def test__masks_visibilities_and_noise_map_correctly( self, phase_interferometer_7, interferometer_7, visibilities_mask_7x2): analysis = phase_interferometer_7.make_analysis( dataset=interferometer_7, mask=visibilities_mask_7x2, results=mock_pipeline.MockResults(), ) assert (analysis.masked_interferometer.visibilities == interferometer_7.visibilities).all() assert (analysis.masked_interferometer.noise_map == interferometer_7.noise_map).all()
def test__positions_are_input__are_used_in_analysis( self, phase_imaging_7x7, imaging_7x7, mask_7x7): # If position threshold is input (not None) and positions are input, make the positions part of the lens dataset. phase_imaging_7x7.meta_dataset.positions_threshold = 0.2 analysis = phase_imaging_7x7.make_analysis( dataset=imaging_7x7, mask=mask_7x7, positions=[[(1.0, 1.0), (2.0, 2.0)]], results=mock_pipeline.MockResults(), ) assert (analysis.masked_dataset.positions[0][0] == np.array([1.0, 1.0 ])).all() assert (analysis.masked_dataset.positions[0][1] == np.array([2.0, 2.0 ])).all() assert analysis.masked_imaging.positions_threshold == 0.2 # If position threshold is input (not None) and but no positions are supplied, raise an error with pytest.raises(exc.PhaseException): phase_imaging_7x7.meta_dataset.positions_threshold = 0.2 phase_imaging_7x7.make_analysis( dataset=imaging_7x7, mask=mask_7x7, positions=None, results=mock_pipeline.MockResults(), ) phase_imaging_7x7.meta_dataset.positions_threshold = 0.2 phase_imaging_7x7.make_analysis( dataset=imaging_7x7, mask=mask_7x7, results=mock_pipeline.MockResults())
def test__results_of_phase_include_positions__available_as_property( self, imaging_7x7, mask_7x7): phase_imaging_7x7 = al.PhaseImaging( non_linear_class=mock_pipeline.MockNLO, galaxies=[ al.Galaxy(redshift=0.5, light=al.lp.EllipticalSersic(intensity=1.0)) ], phase_name="test_phase_2", ) result = phase_imaging_7x7.run(dataset=imaging_7x7, mask=mask_7x7, results=mock_pipeline.MockResults()) assert result.positions == None phase_imaging_7x7 = al.PhaseImaging( non_linear_class=mock_pipeline.MockNLO, galaxies=dict( lens=al.Galaxy(redshift=0.5, light=al.lp.EllipticalSersic(intensity=1.0)), source=al.Galaxy(redshift=1.0), ), positions_threshold=1.0, phase_name="test_phase_2", ) result = phase_imaging_7x7.run( dataset=imaging_7x7, mask=mask_7x7, positions=[[(1.0, 1.0)]], results=mock_pipeline.MockResults(), ) assert (result.positions[0] == np.array([1.0, 1.0])).all()
def test__mask_input_uses_mask(self, phase_imaging_7x7, imaging_7x7): # If an input mask is supplied we use mask input. mask_input = al.Mask.circular(shape_2d=imaging_7x7.shape_2d, pixel_scales=1.0, sub_size=1, radius=1.5) analysis = phase_imaging_7x7.make_analysis( dataset=imaging_7x7, mask=mask_input, results=mock_pipeline.MockResults()) assert (analysis.masked_imaging.mask == mask_input).all() assert analysis.masked_imaging.mask.pixel_scales == mask_input.pixel_scales
def test__results_of_phase_are_available_as_properties( self, imaging_7x7, mask_7x7): phase_dataset_7x7 = al.PhaseImaging( non_linear_class=mock_pipeline.MockNLO, galaxies=[ al.Galaxy(redshift=0.5, light=al.lp.EllipticalSersic(intensity=1.0)) ], phase_name="test_phase_2", ) result = phase_dataset_7x7.run(dataset=imaging_7x7, mask=mask_7x7, results=mock_pipeline.MockResults()) assert isinstance(result, al.AbstractPhase.Result)
def test__associate_images(self, masked_imaging_7x7): galaxies = af.ModelInstance() galaxies.lens = al.Galaxy(redshift=0.5) galaxies.source = al.Galaxy(redshift=1.0) instance = af.ModelInstance() instance.galaxies = galaxies hyper_galaxy_image_path_dict = { ("galaxies", "lens"): al.Array.ones(shape_2d=(3, 3), pixel_scales=1.0), ("galaxies", "source"): al.Array.full( fill_value=2.0, shape_2d=(3, 3), pixel_scales=1.0 ), } results = mock_pipeline.MockResults( instance=instance, hyper_galaxy_image_path_dict=hyper_galaxy_image_path_dict, hyper_model_image=al.Array.full(fill_value=3.0, shape_2d=(3, 3)), use_as_hyper_dataset=True, ) analysis = al.PhaseImaging.Analysis( masked_imaging=masked_imaging_7x7, cosmology=cosmo.Planck15, image_path="files/", results=results, ) instance = analysis.associate_hyper_images(instance=instance) assert instance.galaxies.lens.hyper_galaxy_image.in_2d == pytest.approx( np.ones((3, 3)), 1.0e-4 ) assert instance.galaxies.source.hyper_galaxy_image.in_2d == pytest.approx( 2.0 * np.ones((3, 3)), 1.0e-4 ) assert instance.galaxies.lens.hyper_model_image.in_2d == pytest.approx( 3.0 * np.ones((3, 3)), 1.0e-4 ) assert instance.galaxies.source.hyper_model_image.in_2d == pytest.approx( 3.0 * np.ones((3, 3)), 1.0e-4 )
def test__results_of_phase_include_mask__available_as_property( self, imaging_7x7, mask_7x7): phase_imaging_7x7 = al.PhaseImaging( non_linear_class=mock_pipeline.MockNLO, galaxies=[ al.Galaxy(redshift=0.5, light=al.lp.EllipticalSersic(intensity=1.0)) ], sub_size=2, phase_name="test_phase_2", ) result = phase_imaging_7x7.run(dataset=imaging_7x7, mask=mask_7x7, results=mock_pipeline.MockResults()) assert (result.mask == mask_7x7).all()
def test__most_likely_tracer__multiple_image_positions_of_source_plane_centres_and_separations( self, imaging_7x7, mask_7x7): phase_dataset_7x7 = al.PhaseImaging( non_linear_class=mock_pipeline.MockNLO, galaxies=dict( lens=al.Galaxy( redshift=0.5, mass=al.mp.EllipticalIsothermal(centre=(0.001, 0.001), einstein_radius=1.0, axis_ratio=0.8), ), source=al.Galaxy( redshift=1.0, light=al.lp.EllipticalCoreSersic(centre=(0.0, 0.0), intensity=2.0), light1=al.lp.EllipticalCoreSersic(centre=(0.0, 0.0), intensity=2.0), ), ), phase_name="test_phase_2", ) result = phase_dataset_7x7.run(dataset=imaging_7x7, mask=mask_7x7, results=mock_pipeline.MockResults()) # TODO : Again, we'll remove this need to pass a mask around when the Tracer uses an adaptive gird.. result.analysis.masked_dataset.mask = al.Mask.unmasked( shape_2d=(100, 100), pixel_scales=0.05, sub_size=1) coordinates = ( result.image_plane_multiple_image_positions_of_source_plane_centres ) assert coordinates[0][0] == pytest.approx((1.025, -0.025), 1.0e-4) assert coordinates[0][1] == pytest.approx((0.025, -0.975), 1.0e-4) assert coordinates[0][2] == pytest.approx((0.025, 0.975), 1.0e-4) assert coordinates[0][3] == pytest.approx((-1.025, -0.025), 1.0e-4) assert coordinates[1][0] == pytest.approx((1.025, -0.025), 1.0e-4) assert coordinates[1][1] == pytest.approx((0.025, -0.975), 1.0e-4) assert coordinates[1][2] == pytest.approx((0.025, 0.975), 1.0e-4) assert coordinates[1][3] == pytest.approx((-1.025, -0.025), 1.0e-4)
def test__fit_figure_of_merit__includes_hyper_image_and_noise__matches_fit( self, interferometer_7, mask_7x7, visibilities_mask_7x2): hyper_background_noise = al.hyper_data.HyperBackgroundNoise( noise_scale=1.0) lens_galaxy = al.Galaxy(redshift=0.5, light=al.lp.EllipticalSersic(intensity=0.1)) phase_interferometer_7 = al.PhaseInterferometer( real_space_mask=mask_7x7, galaxies=[lens_galaxy], hyper_background_noise=hyper_background_noise, cosmology=cosmo.FLRW, sub_size=4, phase_name="test_phase", ) analysis = phase_interferometer_7.make_analysis( dataset=interferometer_7, mask=visibilities_mask_7x2, results=mock_pipeline.MockResults(), ) instance = phase_interferometer_7.model.instance_from_unit_vector([]) fit_figure_of_merit = analysis.fit(instance=instance) real_space_mask = phase_interferometer_7.meta_dataset.mask_with_phase_sub_size_from_mask( mask=mask_7x7) assert real_space_mask.sub_size == 4 masked_interferometer = al.MaskedInterferometer( interferometer=interferometer_7, visibilities_mask=visibilities_mask_7x2, real_space_mask=real_space_mask, ) tracer = analysis.tracer_for_instance(instance=instance) fit = FitInterferometer( masked_interferometer=masked_interferometer, tracer=tracer, hyper_background_noise=hyper_background_noise, ) assert fit.likelihood == fit_figure_of_merit
def test__masked_imaging_generator_from_aggregator(imaging_7x7, mask_7x7): phase_imaging_7x7 = al.PhaseImaging( non_linear_class=mock_pipeline.MockNLO, galaxies=dict( lens=al.GalaxyModel(redshift=0.5, light=al.lp.EllipticalSersic), source=al.GalaxyModel(redshift=1.0, light=al.lp.EllipticalSersic), ), phase_name="test_phase_aggregator", ) phase_imaging_7x7.run(dataset=imaging_7x7, mask=mask_7x7, results=mock_pipeline.MockResults()) agg = af.Aggregator(directory=phase_imaging_7x7.paths.phase_output_path) masked_imaging_gen = al.agg.MaskedImaging(aggregator=agg) for masked_imaging in masked_imaging_gen: assert (masked_imaging.imaging.image == imaging_7x7.image).all()
def test__fit_using_interferometer(self, interferometer_7, mask_7x7, visibilities_mask_7x2): phase_interferometer_7 = al.PhaseInterferometer( non_linear_class=mock_pipeline.MockNLO, galaxies=dict( lens=al.GalaxyModel(redshift=0.5, light=al.lp.EllipticalSersic), source=al.GalaxyModel(redshift=1.0, light=al.lp.EllipticalSersic), ), real_space_mask=mask_7x7, phase_name="test_phase_test_fit", ) result = phase_interferometer_7.run( dataset=interferometer_7, mask=visibilities_mask_7x2, results=mock_pipeline.MockResults(), ) assert isinstance(result.instance.galaxies[0], al.Galaxy) assert isinstance(result.instance.galaxies[0], al.Galaxy)
def test__most_likely_tracer_available_as_result(self, imaging_7x7, mask_7x7): phase_dataset_7x7 = al.PhaseImaging( non_linear_class=mock_pipeline.MockNLO, galaxies=dict( lens=al.Galaxy(redshift=0.5, light=al.lp.EllipticalSersic(intensity=1.0)), source=al.Galaxy( redshift=1.0, light=al.lp.EllipticalCoreSersic(intensity=2.0)), ), phase_name="test_phase_2", ) result = phase_dataset_7x7.run(dataset=imaging_7x7, mask=mask_7x7, results=mock_pipeline.MockResults()) assert isinstance(result.most_likely_tracer, al.Tracer) assert result.most_likely_tracer.galaxies[0].light.intensity == 1.0 assert result.most_likely_tracer.galaxies[1].light.intensity == 2.0
def test__most_likely_tracer_source_centres_correct( self, imaging_7x7, mask_7x7): phase_dataset_7x7 = al.PhaseImaging( non_linear_class=mock_pipeline.MockNLO, galaxies=dict( lens=al.Galaxy(redshift=0.5, light=al.lp.EllipticalSersic(intensity=1.0)), source=al.Galaxy( redshift=1.0, light=al.lp.EllipticalCoreSersic(centre=(9.0, 8.0), intensity=2.0), pixelization=al.pix.Rectangular((3, 3)), regularization=al.reg.Constant(coefficient=1.0), ), ), phase_name="test_phase_2", ) result = phase_dataset_7x7.run(dataset=imaging_7x7, mask=mask_7x7, results=mock_pipeline.MockResults()) assert result.source_plane_centres == [(9.0, 8.0), (0.0, 0.0)]
def test__tracer_generator_from_aggregator(imaging_7x7, mask_7x7): phase_imaging_7x7 = al.PhaseImaging( non_linear_class=mock_pipeline.MockNLO, galaxies=dict( lens=al.GalaxyModel(redshift=0.5, light=al.lp.EllipticalSersic), source=al.GalaxyModel(redshift=1.0, light=al.lp.EllipticalSersic), ), phase_name="test_phase_aggregator", ) phase_imaging_7x7.run(dataset=imaging_7x7, mask=mask_7x7, results=mock_pipeline.MockResults()) agg = af.Aggregator(directory=phase_imaging_7x7.paths.phase_output_path) tracer_gen = al.agg.Tracer(aggregator=agg) for tracer in tracer_gen: assert tracer.galaxies[0].redshift == 0.5 assert tracer.galaxies[0].light.centre == (0.0, 1.0) assert tracer.galaxies[1].redshift == 1.0
def test__positions_do_not_trace_within_threshold__raises_exception( self, phase_imaging_7x7, imaging_7x7, mask_7x7): phase_imaging_7x7 = al.PhaseImaging( galaxies=dict(source=al.Galaxy(redshift=0.5)), positions_threshold=50.0, cosmology=cosmo.FLRW, phase_name="test_phase", ) analysis = phase_imaging_7x7.make_analysis( dataset=imaging_7x7, mask=mask_7x7, positions=[[(1.0, 1.0), (2.0, 2.0)]], results=mock_pipeline.MockResults(), ) instance = phase_imaging_7x7.model.instance_from_unit_vector([]) tracer = analysis.tracer_for_instance(instance=instance) analysis.masked_dataset.check_positions_trace_within_threshold_via_tracer( tracer=tracer) phase_imaging_7x7 = al.PhaseImaging( galaxies=dict(source=al.Galaxy(redshift=0.5)), positions_threshold=0.0, cosmology=cosmo.FLRW, phase_name="test_phase", ) analysis = phase_imaging_7x7.make_analysis( dataset=imaging_7x7, mask=mask_7x7, positions=[[(1.0, 1.0), (2.0, 2.0)]], results=mock_pipeline.MockResults(), ) instance = phase_imaging_7x7.model.instance_from_unit_vector([]) tracer = analysis.tracer_for_instance(instance=instance) with pytest.raises(exc.RayTracingException): analysis.masked_dataset.check_positions_trace_within_threshold_via_tracer( tracer=tracer) phase_imaging_7x7 = al.PhaseImaging( galaxies=dict(source=al.Galaxy(redshift=0.5)), positions_threshold=0.5, cosmology=cosmo.FLRW, phase_name="test_phase", ) analysis = phase_imaging_7x7.make_analysis( dataset=imaging_7x7, mask=mask_7x7, positions=[[(1.0, 0.0), (-1.0, 0.0)]], results=mock_pipeline.MockResults(), ) tracer = al.Tracer.from_galaxies(galaxies=[ al.Galaxy(redshift=0.5, mass=al.mp.SphericalIsothermal(einstein_radius=1.0)), al.Galaxy(redshift=1.0), ]) analysis.masked_dataset.check_positions_trace_within_threshold_via_tracer( tracer=tracer) tracer = al.Tracer.from_galaxies(galaxies=[ al.Galaxy(redshift=0.5, mass=al.mp.SphericalIsothermal(einstein_radius=0.0)), al.Galaxy(redshift=1.0), ]) with pytest.raises(exc.RayTracingException): analysis.masked_dataset.check_positions_trace_within_threshold_via_tracer( tracer=tracer) analysis = phase_imaging_7x7.make_analysis( dataset=imaging_7x7, mask=mask_7x7, positions=[[(0.0, 0.0), (0.0, 0.0)], [(0.0, 0.0), (0.0, 0.0)]], results=mock_pipeline.MockResults(), ) instance = phase_imaging_7x7.model.instance_from_unit_vector([]) tracer = analysis.tracer_for_instance(instance=instance) analysis.masked_dataset.check_positions_trace_within_threshold_via_tracer( tracer=tracer) analysis = phase_imaging_7x7.make_analysis( dataset=imaging_7x7, mask=mask_7x7, positions=[[(0.0, 0.0), (0.0, 0.0)], [(100.0, 0.0), (0.0, 0.0)]], results=mock_pipeline.MockResults(), ) instance = phase_imaging_7x7.model.instance_from_unit_vector([]) tracer = analysis.tracer_for_instance(instance=instance) with pytest.raises(exc.RayTracingException): analysis.masked_dataset.check_positions_trace_within_threshold_via_tracer( tracer=tracer)
def test__determines_if_pixelization_is_same_as_previous_phase( self, imaging_7x7, mask_7x7): results = mock_pipeline.MockResults() results.last.hyper_combined.preload_sparse_grids_of_planes = 1 phase_imaging_7x7 = al.PhaseImaging(phase_name="test_phase") results.last.pixelization = None analysis = phase_imaging_7x7.make_analysis(dataset=imaging_7x7, mask=mask_7x7, results=results) assert analysis.masked_dataset.preload_sparse_grids_of_planes is None phase_imaging_7x7 = al.PhaseImaging(phase_name="test_phase") results.last.pixelization = al.pix.Rectangular analysis = phase_imaging_7x7.make_analysis(dataset=imaging_7x7, mask=mask_7x7, results=results) assert analysis.masked_dataset.preload_sparse_grids_of_planes is None phase_imaging_7x7 = al.PhaseImaging( phase_name="test_phase", galaxies=[ al.Galaxy( redshift=0.5, pixelization=al.pix.Rectangular, regularization=al.reg.Constant, ) ], ) results.last.pixelization = None analysis = phase_imaging_7x7.make_analysis(dataset=imaging_7x7, mask=mask_7x7, results=results) assert analysis.masked_dataset.preload_sparse_grids_of_planes is None phase_imaging_7x7 = al.PhaseImaging( phase_name="test_phase", galaxies=[ al.Galaxy( redshift=0.5, pixelization=al.pix.Rectangular, regularization=al.reg.Constant, ) ], ) results.last.pixelization = al.pix.Rectangular analysis = phase_imaging_7x7.make_analysis(dataset=imaging_7x7, mask=mask_7x7, results=results) assert analysis.masked_dataset.preload_sparse_grids_of_planes == 1
def test__inversion_resolution_error_raised_if_above_inversion_pixel_limit( self, phase_imaging_7x7, imaging_7x7, mask_7x7): phase_imaging_7x7 = al.PhaseImaging( galaxies=dict(source=al.Galaxy( redshift=0.5, pixelization=al.pix.Rectangular(shape=(3, 3)), regularization=al.reg.Constant(), )), inversion_pixel_limit=10, cosmology=cosmo.FLRW, phase_name="test_phase", ) analysis = phase_imaging_7x7.make_analysis( dataset=imaging_7x7, mask=mask_7x7, results=mock_pipeline.MockResults()) instance = phase_imaging_7x7.model.instance_from_unit_vector([]) tracer = analysis.tracer_for_instance(instance=instance) analysis.masked_dataset.check_inversion_pixels_are_below_limit_via_tracer( tracer=tracer) phase_imaging_7x7 = al.PhaseImaging( galaxies=dict(source=al.Galaxy( redshift=0.5, pixelization=al.pix.Rectangular(shape=(4, 4)), regularization=al.reg.Constant(), )), inversion_pixel_limit=10, cosmology=cosmo.FLRW, phase_name="test_phase", ) analysis = phase_imaging_7x7.make_analysis( dataset=imaging_7x7, mask=mask_7x7, results=mock_pipeline.MockResults()) instance = phase_imaging_7x7.model.instance_from_unit_vector([]) tracer = analysis.tracer_for_instance(instance=instance) with pytest.raises(exc.PixelizationException): analysis.masked_dataset.check_inversion_pixels_are_below_limit_via_tracer( tracer=tracer) analysis.fit(instance=instance) phase_imaging_7x7 = al.PhaseImaging( galaxies=dict(source=al.Galaxy( redshift=0.5, pixelization=al.pix.Rectangular(shape=(3, 3)), regularization=al.reg.Constant(), )), inversion_pixel_limit=10, cosmology=cosmo.FLRW, phase_name="test_phase", ) analysis = phase_imaging_7x7.make_analysis( dataset=imaging_7x7, mask=mask_7x7, results=mock_pipeline.MockResults()) instance = phase_imaging_7x7.model.instance_from_unit_vector([]) tracer = analysis.tracer_for_instance(instance=instance) analysis.masked_dataset.check_inversion_pixels_are_below_limit_via_tracer( tracer=tracer) phase_imaging_7x7 = al.PhaseImaging( galaxies=dict(source=al.Galaxy( redshift=0.5, pixelization=al.pix.Rectangular(shape=(4, 4)), regularization=al.reg.Constant(), )), inversion_pixel_limit=10, cosmology=cosmo.FLRW, phase_name="test_phase", ) analysis = phase_imaging_7x7.make_analysis( dataset=imaging_7x7, mask=mask_7x7, results=mock_pipeline.MockResults()) instance = phase_imaging_7x7.model.instance_from_unit_vector([]) tracer = analysis.tracer_for_instance(instance=instance) with pytest.raises(exc.PixelizationException): analysis.masked_dataset.check_inversion_pixels_are_below_limit_via_tracer( tracer=tracer) analysis.fit(instance=instance)
def test__most_likely_tracer_source_light_profile_centres_correct( self, imaging_7x7, mask_7x7): phase_dataset_7x7 = al.PhaseImaging( non_linear_class=mock_pipeline.MockNLO, galaxies=dict( lens=al.Galaxy(redshift=0.5, light=al.lp.EllipticalSersic(intensity=1.0)), source=al.Galaxy( redshift=1.0, light=al.lp.EllipticalCoreSersic(centre=(1.0, 2.0), intensity=2.0), ), ), phase_name="test_phase_2", ) result = phase_dataset_7x7.run(dataset=imaging_7x7, mask=mask_7x7, results=mock_pipeline.MockResults()) assert result.source_plane_light_profile_centres == [(1.0, 2.0)] phase_dataset_7x7 = al.PhaseImaging( non_linear_class=mock_pipeline.MockNLO, galaxies=dict( lens=al.Galaxy(redshift=0.5, light=al.lp.EllipticalSersic(intensity=1.0)), source=al.Galaxy( redshift=1.0, light=al.lp.EllipticalCoreSersic(centre=(1.0, 2.0), intensity=2.0), light1=al.lp.EllipticalCoreSersic(centre=(3.0, 4.0), intensity=2.0), ), source1=al.Galaxy( redshift=1.0, light=al.lp.EllipticalCoreSersic(centre=(5.0, 6.0), intensity=2.0), ), ), phase_name="test_phase_2", ) result = phase_dataset_7x7.run(dataset=imaging_7x7, mask=mask_7x7, results=mock_pipeline.MockResults()) assert result.source_plane_light_profile_centres == [ (1.0, 2.0), (3.0, 4.0), (5.0, 6.0), ] phase_dataset_7x7 = al.PhaseImaging( non_linear_class=mock_pipeline.MockNLO, galaxies=dict(lens=al.Galaxy(redshift=0.5)), phase_name="test_phase_2", ) result = phase_dataset_7x7.run(dataset=imaging_7x7, mask=mask_7x7, results=mock_pipeline.MockResults()) assert result.source_plane_light_profile_centres == []
def test__auto_positions_update__updates_correct_using_factor( self, phase_imaging_7x7, phase_interferometer_7, imaging_7x7, interferometer_7, mask_7x7, ): # Auto positioning is OFF, so use input positions + threshold. phase_imaging_7x7.meta_dataset.positions_threshold = 0.1 phase_imaging_7x7.meta_dataset.auto_positions_factor = None analysis = phase_imaging_7x7.make_analysis( dataset=imaging_7x7, mask=mask_7x7, positions=al.Coordinates(coordinates=[[(1.0, 1.0)]]), results=mock_pipeline.MockResults(), ) assert analysis.masked_dataset.positions == [[(1.0, 1.0)]] # Auto positioning is ON, but there are no previous results, so use input positions. phase_imaging_7x7.meta_dataset.positions_threshold = 0.2 phase_imaging_7x7.meta_dataset.auto_positions_factor = 1.0 analysis = phase_imaging_7x7.make_analysis( dataset=imaging_7x7, mask=mask_7x7, positions=al.Coordinates(coordinates=[[(1.0, 1.0)]]), results=mock_pipeline.MockResults(), ) assert analysis.masked_dataset.positions == [[(1.0, 1.0)]] # Auto positioning is ON, there are previous results so use their new positions and threshold (which is # multiplied by the auto_positions_factor). However, only one set of positions is computed from the previous # result, to use input positions. phase_imaging_7x7.meta_dataset.positions_threshold = 0.2 phase_imaging_7x7.meta_dataset.auto_positions_factor = 2.0 results = mock_pipeline.MockResults( updated_positions=al.Coordinates(coordinates=[[(2.0, 2.0)]]), updated_positions_threshold=0.3, ) analysis = phase_imaging_7x7.make_analysis( dataset=imaging_7x7, mask=mask_7x7, positions=al.Coordinates(coordinates=[[(1.0, 1.0)]]), results=results, ) assert analysis.masked_dataset.positions == [[(1.0, 1.0)]] # Auto positioning is ON, there are previous results so use their new positions and threshold (which is # multiplied by the auto_positions_factor). Multiple positions are available so these are now used. phase_imaging_7x7.meta_dataset.positions_threshold = 0.2 phase_imaging_7x7.meta_dataset.auto_positions_factor = 2.0 results = mock_pipeline.MockResults( updated_positions=al.Coordinates(coordinates=[[(2.0, 2.0), (3.0, 3.0)]]), updated_positions_threshold=0.3, ) analysis = phase_imaging_7x7.make_analysis( dataset=imaging_7x7, mask=mask_7x7, positions=al.Coordinates(coordinates=[[(1.0, 1.0)]]), results=results, ) assert analysis.masked_dataset.positions == [[(2.0, 2.0), (3.0, 3.0)]] # Auto positioning is Off, but there are previous results with updated positions relative to the input # positions, so use those with their positions threshold. phase_imaging_7x7.meta_dataset.positions_threshold = 0.1 phase_imaging_7x7.meta_dataset.auto_positions_factor = None analysis = phase_imaging_7x7.make_analysis( dataset=imaging_7x7, mask=mask_7x7, positions=al.Coordinates(coordinates=[[(2.0, 2.0)]]), results=mock_pipeline.MockResults( positions=al.Coordinates(coordinates=[[(3.0, 3.0), (4.0, 4.0)]]), updated_positions_threshold=0.3, ), ) assert analysis.masked_dataset.positions == [[(3.0, 3.0), (4.0, 4.0)]] # Test function is called for phase_inteferometer phase_interferometer_7.meta_dataset.positions_threshold = None phase_interferometer_7.meta_dataset.auto_positions_factor = 2.0 analysis = phase_interferometer_7.make_analysis( dataset=interferometer_7, mask=mask_7x7, positions=al.Coordinates(coordinates=[[(1.0, 1.0)]]), results=mock_pipeline.MockResults( updated_positions=al.Coordinates(coordinates=[[(1.0, 1.0)]]), updated_positions_threshold=0.3, ), ) assert analysis.masked_dataset.positions == [[(1.0, 1.0)]]