Ejemplo n.º 1
0
    def test__furthest_separation_of_source_plane_positions(self):

        positions = al.Grid2DIrregular(grid=[(0.0, 0.0), (0.0, 1.0)])
        noise_map = al.ValuesIrregular([[1.0, 1.0]])

        tracer = mock.MockTracer(traced_grid=positions)
        fit = al.FitPositionsSourceMaxSeparation(positions=positions,
                                                 noise_map=noise_map,
                                                 tracer=tracer)

        assert fit.furthest_separations_of_source_plane_positions.in_list == [
            1.0, 1.0
        ]
        assert fit.max_separation_of_source_plane_positions == 1.0
        assert fit.max_separation_within_threshold(threshold=2.0) == True
        assert fit.max_separation_within_threshold(threshold=0.5) == False

        positions = al.Grid2DIrregular(grid=[(0.0, 0.0), (0.0, 1.0), (0.0,
                                                                      3.0)])
        noise_map = al.ValuesIrregular([1.0, 1.0, 1.0])

        tracer = mock.MockTracer(traced_grid=positions)
        fit = al.FitPositionsSourceMaxSeparation(positions=positions,
                                                 noise_map=noise_map,
                                                 tracer=tracer)

        assert fit.furthest_separations_of_source_plane_positions.in_list == [
            3.0,
            2.0,
            3.0,
        ]
        assert fit.max_separation_of_source_plane_positions == 3.0
        assert fit.max_separation_within_threshold(threshold=3.5) == True
        assert fit.max_separation_within_threshold(threshold=2.0) == False
        assert fit.max_separation_within_threshold(threshold=0.5) == False
Ejemplo n.º 2
0
    def test__update_stellar_mass_priors_using_einstein_radius(self):

        grid = al.Grid2D.uniform(shape_native=(200, 200), pixel_scales=0.05)

        tracer = mock.MockTracer(einstein_radius=1.0, einstein_mass=4.0)
        fit = mock.MockFit(grid=grid)

        result = mock.MockResult(max_log_likelihood_tracer=tracer,
                                 max_log_likelihood_fit=fit)

        bulge_prior_model = af.PriorModel(al.lmp.SphericalSersic)

        bulge_prior_model.intensity = af.UniformPrior(lower_limit=0.99,
                                                      upper_limit=1.01)
        bulge_prior_model.effective_radius = af.UniformPrior(lower_limit=0.99,
                                                             upper_limit=1.01)
        bulge_prior_model.sersic_index = af.UniformPrior(lower_limit=2.99,
                                                         upper_limit=3.01)

        setup = al.SetupMassLightDark(bulge_prior_model=bulge_prior_model)

        setup.update_stellar_mass_priors_from_result(
            prior_model=bulge_prior_model,
            result=result,
            einstein_mass_range=[0.001, 10.0],
            bins=10,
        )

        assert setup.bulge_prior_model.mass_to_light_ratio.lower_limit == pytest.approx(
            0.00040519, 1.0e-1)
        assert setup.bulge_prior_model.mass_to_light_ratio.upper_limit == pytest.approx(
            4.051935, 1.0e-1)
Ejemplo n.º 3
0
    def test__one_set_of_fluxes__residuals_likelihood_correct(self):

        tracer = mock.MockTracer(
            magnification=al.ValuesIrregular([2.0, 2.0]),
            profile=al.ps.PointSourceFlux(flux=2.0),
        )

        fluxes = al.ValuesIrregular([1.0, 2.0])
        noise_map = al.ValuesIrregular([3.0, 1.0])
        positions = al.Grid2DIrregular([(0.0, 0.0), (3.0, 4.0)])

        fit = al.FitFluxes(
            name="point_0",
            fluxes=fluxes,
            noise_map=noise_map,
            positions=positions,
            tracer=tracer,
        )

        assert fit.fluxes.in_list == [1.0, 2.0]
        assert fit.noise_map.in_list == [3.0, 1.0]
        assert fit.model_fluxes.in_list == [4.0, 4.0]
        assert fit.residual_map.in_list == [-3.0, -2.0]
        assert fit.normalized_residual_map.in_list == [-1.0, -2.0]
        assert fit.chi_squared_map.in_list == [1.0, 4.0]
        assert fit.chi_squared == pytest.approx(5.0, 1.0e-4)
        assert fit.noise_normalization == pytest.approx(5.87297, 1.0e-4)
        assert fit.log_likelihood == pytest.approx(-5.43648, 1.0e-4)
Ejemplo n.º 4
0
    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.

        phase_imaging_7x7 = al.PhaseImaging(
            search=mock.MockSearch("test_phase"),
            settings=al.SettingsPhaseImaging(settings_lens=al.SettingsLens(
                auto_einstein_radius_factor=None)),
        )
        tracer = mock.MockTracer(einstein_radius=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 = mock.MockTracer(einstein_radius=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),
        )

        assert analysis.settings.settings_lens.einstein_radius_estimate == 2.0