Beispiel #1
0
    def test__convergence_values_correct(self):
        power_law = l1d.SphericalPowerLaw(einstein_radius=1.4,
                                          slope=1.6,
                                          redshift_source=0.8,
                                          redshift_lens=0.3)

        kappa = power_law.convergence_from_radii(radii=np.array([0.5, 1, 1.5]))

        assert kappa == pytest.approx(np.array([1.298, 0.857, 0.672]), 1e-3)
    def test__critical_surface_mass_density_correct_value(self):
        power_law = l1d.SphericalPowerLaw(einstein_radius=1.8,
                                          slope=1.7,
                                          redshift_source=0.8,
                                          redshift_lens=0.3)

        sigma_crit = power_law.critical_surface_density_of_lens

        assert sigma_crit == pytest.approx(3076534993.9914, 1e-4)
Beispiel #3
0
    def test__deflection_angle_values_correct(self):
        power_law = l1d.SphericalPowerLaw(einstein_radius=1.4,
                                          slope=1.6,
                                          redshift_source=0.8,
                                          redshift_lens=0.3)

        alpha = power_law.deflections_from_radii(radii=np.array([0.5, 1, 1.5]))

        assert alpha == pytest.approx(np.array([0.927, 1.224, 1.439]), 1e-3)
Beispiel #4
0
    def test__density_values_correct(self):
        power_law = l1d.SphericalPowerLaw(einstein_radius=1.4,
                                          slope=1.6,
                                          redshift_source=0.8,
                                          redshift_lens=0.3)

        sigma = power_law.density_from_radii(radii=np.array([0.5, 1, 1.5]))

        assert sigma == pytest.approx(
            np.array([9326310116, 3076534994, 1608110342]), 1e-3)
    def test__slope_equal_to_power_law_input(self):
        power_law = l1d.SphericalPowerLaw(
            einstein_radius=1.8, slope=2, redshift_source=0.8, redshift_lens=0.3
        )
        radii = np.arange(0.2, 3, 0.002)

        fit = l1d.PowerLawFit(profile=power_law, mask=None, radii=radii)

        slope_lensing = fit.slope_via_lensing()

        assert slope_lensing == pytest.approx(power_law.slope, 1e-4)
Beispiel #6
0
    def test__convergence_at_einstein_radius_less_than_one(self):
        power_law = l1d.SphericalPowerLaw(einstein_radius=1.8,
                                          slope=2,
                                          redshift_source=0.8,
                                          redshift_lens=0.3)
        radii = np.arange(0.2, 3, 0.002)

        kappa_ein = power_law.convergence_at_einstein_radius_from_radii(
            radii=radii)

        assert kappa_ein < 1
    def test__xi_two_equal_to_zero_for_sis(self):
        power_law = l1d.SphericalPowerLaw(
            einstein_radius=1.8, slope=2, redshift_source=0.8, redshift_lens=0.3
        )
        radii = np.arange(0.2, 3, 0.002)

        fit = l1d.PowerLawFit(profile=power_law, mask=None, radii=radii)

        xi_two = fit.xi_two()

        assert xi_two == pytest.approx(0, 1e-3)
Beispiel #8
0
    def test__surface_mass_density_values_correct(self):
        power_law = l1d.SphericalPowerLaw(einstein_radius=1.4,
                                          slope=1.6,
                                          redshift_source=0.8,
                                          redshift_lens=0.3)

        sigma = power_law.surface_mass_density_from_radii(
            radii=np.array([0.5, 1, 1.5]))

        assert sigma == pytest.approx(
            np.array([3994429111, 2635340405, 2066245712]), 1e-3)
    def test__average_density_inside_einstein_radius_equal_to_sigma_crit(self):
        power_law = l1d.SphericalPowerLaw(einstein_radius=1.8,
                                          slope=1.7,
                                          redshift_source=0.8,
                                          redshift_lens=0.3)

        sigma_crit = power_law.critical_surface_density_of_lens

        integrand = (lambda r: 2 * np.pi * r * power_law.
                     surface_mass_density_from_radii(radii=r))

        av_density = integrate.quad(integrand, 0,
                                    power_law.einstein_radius)[0] / (
                                        np.pi * power_law.einstein_radius**2)

        assert av_density == pytest.approx(sigma_crit, 1e-3)

        Hernquist = l1d.Hernquist(mass=3.4e11,
                                  effective_radius=8.4,
                                  redshift_lens=0.6,
                                  redshift_source=1.2)

        radii = np.arange(0.01, 10, 0.001)

        einstein_radius = Hernquist.einstein_radius_in_kpc_from_radii(
            radii=radii)

        sigma_crit = Hernquist.critical_surface_density_of_lens

        integrand = (lambda r: 2 * np.pi * r * Hernquist.
                     surface_mass_density_from_radii(radii=r))

        av_density = integrate.quad(
            integrand, 0, einstein_radius)[0] / (np.pi * einstein_radius**2)

        assert av_density == pytest.approx(sigma_crit, 1e-3)

        nfw = l1d.NFWHilbert(mass_at_200=2.5e13,
                             redshift_lens=0.6,
                             redshift_source=1.2)
        radii = np.arange(0.01, 3, 0.001)

        einstein_radius = nfw.einstein_radius_in_kpc_from_radii(radii=radii)

        sigma_crit = nfw.critical_surface_density_of_lens

        integrand = (lambda r: 2 * np.pi * r * nfw.
                     surface_mass_density_from_radii(radii=r))

        av_density = integrate.quad(
            integrand, 0, einstein_radius)[0] / (np.pi * einstein_radius**2)

        assert av_density == pytest.approx(sigma_crit, 1e-3)
    def test__tangential_eigenvalue_equal_to_from_alpha(self):

        radii = np.arange(0.2, 3, 0.001)

        power_law = l1d.SphericalPowerLaw(einstein_radius=1.8,
                                          slope=1.8,
                                          redshift_source=0.8,
                                          redshift_lens=0.3)

        eigenvalue = power_law.tangential_eigenvalue_from_radii(radii=radii)

        alpha = power_law.deflections_from_radii(radii=radii)

        eigenvalue_alpha = 1 - alpha / radii

        mean_error = np.mean(eigenvalue_alpha - eigenvalue)

        assert mean_error < 1e-4

        nfw = l1d.NFWHilbert(mass_at_200=2.5e12,
                             redshift_lens=0.3,
                             redshift_source=0.8)

        radii = np.arange(0.2, 3, 0.002)

        eigenvalue = nfw.tangential_eigenvalue_from_radii(radii=radii)

        alpha = nfw.deflections_from_radii(radii=radii)

        eigenvalue_alpha = 1 - alpha / radii

        mean_error = np.mean(eigenvalue_alpha - eigenvalue)

        assert mean_error < 1e-4

        Hernquist = l1d.Hernquist(mass=3.4e10,
                                  effective_radius=1.8153,
                                  redshift_lens=0.3,
                                  redshift_source=0.8)

        radii = np.arange(0.2, 3, 0.002)

        eigenvalue = Hernquist.tangential_eigenvalue_from_radii(radii=radii)

        alpha = Hernquist.deflections_from_radii(radii=radii)

        eigenvalue_alpha = 1 - alpha / radii

        mean_error = np.mean(eigenvalue_alpha - eigenvalue)

        assert mean_error < 1e-4
Beispiel #11
0
    def test__shear_isothermal_sphere_equals_analytic(self):
        power_law = l1d.SphericalPowerLaw(einstein_radius=1.8,
                                          slope=2,
                                          redshift_source=0.8,
                                          redshift_lens=0.3)

        radii = np.arange(0.2, 3, 0.002)

        shear_isothermal = power_law.shear_from_radii(radii=radii)
        shear_isothermal_analytic = power_law.einstein_radius / (2 * radii)

        mean_error = np.average(shear_isothermal - shear_isothermal_analytic)

        assert mean_error < 1e-4
Beispiel #12
0
    def test__shear_isothermal_sphere_equals_convergence(self):
        power_law = l1d.SphericalPowerLaw(einstein_radius=1.8,
                                          slope=2,
                                          redshift_source=0.8,
                                          redshift_lens=0.3)

        radii = np.arange(0.2, 3, 0.002)

        shear_isothermal = power_law.shear_from_radii(radii=radii)
        kappa_isothermal = power_law.convergence_from_radii(radii=radii)

        mean_error = np.average(shear_isothermal - kappa_isothermal)

        assert mean_error < 1e-4
Beispiel #13
0
    def test__convergence_from_deflections_and_analytic(self):
        power_law = l1d.SphericalPowerLaw(einstein_radius=1.8,
                                          slope=1.7,
                                          redshift_source=0.8,
                                          redshift_lens=0.3)
        radii = np.arange(0.2, 3, 0.002)

        kappa_analytic = power_law.convergence_from_radii(radii=radii)
        kappa_from_deflections = convergence_via_deflections_from_profile_and_radii(
            profile=power_law, radii=radii)

        mean_error = np.average(kappa_analytic - kappa_from_deflections)

        assert mean_error < 1e-4
Beispiel #14
0
    def test__convergence_isothermal_equal_to_analytic_formula(self):
        isothermal = l1d.SphericalPowerLaw(einstein_radius=1,
                                           slope=2,
                                           redshift_source=0.8,
                                           redshift_lens=0.3)
        radii = np.arange(0.2, 3, 0.002)

        kappa_isothermal = isothermal.convergence_from_radii(radii=radii)

        kappa_isothermal_analytic = np.divide(1 * isothermal.einstein_radius,
                                              2 * radii)

        assert kappa_isothermal == pytest.approx(kappa_isothermal_analytic,
                                                 1e-4)
Beispiel #15
0
    def test__isoyhemral_tangential_eigenvalue_equal_to_zero_at_einstein_radius(
            self):
        power_law = l1d.SphericalPowerLaw(einstein_radius=1.8,
                                          slope=2,
                                          redshift_source=0.8,
                                          redshift_lens=0.3)

        radii = np.arange(0.2, 3, 0.002)

        eigenvalue = power_law.tangential_eigenvalue_from_radii(radii=radii)

        index = np.argmin(np.abs(np.array(radii) - power_law.einstein_radius))

        assert eigenvalue[index] < 1e-4
Beispiel #16
0
    def test__mean_power_law_convergence_within_einstein_radius_equal_to_one(
            self):
        power_law = l1d.SphericalPowerLaw(einstein_radius=1.8,
                                          slope=2.3,
                                          redshift_source=0.8,
                                          redshift_lens=0.3)

        integrand = lambda r: 2 * np.pi * r * power_law.convergence_from_radii(
            radii=r)

        av_kappa = integrate.quad(integrand, 0,
                                  power_law.einstein_radius)[0] / (
                                      np.pi * power_law.einstein_radius**2)

        assert av_kappa == pytest.approx(1, 1e-3)
Beispiel #17
0
    def test__convergence_equals_surface_mass_density_divided_by_sigma_crit(
            self):
        power_law = l1d.SphericalPowerLaw(einstein_radius=1.8,
                                          slope=1.7,
                                          redshift_source=0.8,
                                          redshift_lens=0.3)
        radii = np.arange(0.2, 3, 0.002)

        kappa = power_law.convergence_from_radii(radii=radii)
        sigma_crit = power_law.critical_surface_density_of_lens
        rho = power_law.surface_mass_density_from_radii(radii=radii)

        kappa_via_sigma = rho / sigma_crit

        assert kappa == pytest.approx(kappa_via_sigma, 1e-3)
    def test__mass_inside_einstein_radius_equal_to_einstein_mass(self):
        power_law = l1d.SphericalPowerLaw(einstein_radius=1.8,
                                          slope=1.7,
                                          redshift_source=0.8,
                                          redshift_lens=0.3)
        radii = np.arange(0.2, 3, 0.002)

        einstein_mass = power_law.einstein_mass_in_solar_masses_from_radii(
            radii=radii)

        mass_within_r_ein = power_law.two_dimensional_mass_enclosed_within_radii(
            power_law.einstein_radius)

        assert einstein_mass == pytest.approx(mass_within_r_ein, 1e-4)

        Hernquist = l1d.Hernquist(mass=3.4e11,
                                  effective_radius=8.4,
                                  redshift_lens=0.6,
                                  redshift_source=1.2)
        radii = np.arange(0.2, 100, 0.001)

        einstein_radius = Hernquist.einstein_radius_in_kpc_from_radii(
            radii=radii)

        einstein_mass = Hernquist.einstein_mass_in_solar_masses_from_radii(
            radii=radii)

        mass_within_r_ein = Hernquist.two_dimensional_mass_enclosed_within_radii(
            einstein_radius)

        assert einstein_mass == pytest.approx(mass_within_r_ein, 1e-3)

        nfw = l1d.NFWHilbert(mass_at_200=2.5e13,
                             redshift_lens=0.6,
                             redshift_source=1.2)
        radii = np.arange(0.01, 3, 0.001)

        einstein_radius = nfw.einstein_radius_in_kpc_from_radii(radii=radii)

        einstein_mass = nfw.einstein_mass_in_solar_masses_from_radii(
            radii=radii)

        mass_within_r_ein = nfw.two_dimensional_mass_enclosed_within_radii(
            einstein_radius)

        assert einstein_mass == pytest.approx(mass_within_r_ein, 1e-3)
Beispiel #19
0
    def test__compare_to_autogalaxy__sigma_crit_equal_in_desired_units(self):

        cosmo = cosmology.Planck15

        power_law = l1d.SphericalPowerLaw(einstein_radius=1.4,
                                          slope=1.6,
                                          redshift_source=0.8,
                                          redshift_lens=0.3)
        sigma_crit = power_law.critical_surface_density_of_lens

        autolens_sigma_crit = ag.util.cosmology.critical_surface_density_between_redshifts_from(
            redshift_1=0.8,
            redshift_0=0.3,
            unit_length="kpc",
            unit_mass="solMass",
            cosmology=cosmo,
        )

        assert sigma_crit == pytest.approx(autolens_sigma_crit, 1e-4)
Beispiel #20
0
baryons = l1d.Hernquist(mass=10**11.4,
                        effective_radius=5.4,
                        redshift_lens=0.232,
                        redshift_source=1.3)

baryons_mass = l1d.Hernquist(mass=10**12.9,
                             effective_radius=1.1,
                             redshift_lens=0.3,
                             redshift_source=0.8)

DM = l1d.NFWHilbert(mass_at_200=2.31e13,
                    redshift_lens=0.3,
                    redshift_source=0.8)

isothermal = l1d.SphericalPowerLaw(einstein_radius=1.4,
                                   slope=2.0,
                                   redshift_lens=0.3,
                                   redshift_source=0.8)
no_bh = l1d.SphericalPowerLaw(einstein_radius=1.4,
                              slope=3.0,
                              redshift_lens=0.3,
                              redshift_source=0.8)

DM_cored = l1d.generalisedNFW(mass_at_200=1.21e13,
                              beta=1.9,
                              redshift_lens=0.3,
                              redshift_source=0.8)

print(DM.scale_radius)

radii = np.arange(0.4, 100, 0.001)
baryons = l1d.Hernquist(mass=10**11.53,
                        effective_radius=8.4,
                        redshift_lens=0.232,
                        redshift_source=1.3)

baryons_mass = l1d.Hernquist(mass=10**11.53,
                             effective_radius=8.4,
                             redshift_lens=0.232,
                             redshift_source=1.3)

DM = l1d.NFWHilbert(mass_at_200=1.5e12,
                    redshift_lens=0.232,
                    redshift_source=1.3)

isothermal = l1d.SphericalPowerLaw(einstein_radius=1.5,
                                   slope=2.0,
                                   redshift_lens=0.132,
                                   redshift_source=1.3)

DM_cored = l1d.generalisedNFW(mass_at_200=1.5e12,
                              beta=1.6,
                              redshift_lens=0.232,
                              redshift_source=1.3)

print(DM.scale_radius)

radii = np.arange(0.2, 200, 0.001)

true_profile = l1d.CombinedProfile(profiles=[baryons, DM])
true_profile_cored = l1d.CombinedProfile(profiles=[baryons_mass, DM_cored])

einstein_radius = true_profile.einstein_radius_in_kpc_from_radii(radii=radii)