示例#1
0
    def test__f_func_correct_values(self):
        Hernquist = l1d.Hernquist(mass=3.4e10,
                                  effective_radius=8.4,
                                  redshift_lens=0.3,
                                  redshift_source=0.8)

        f = Hernquist.f_func(x=np.array([0.5, 1.5]))

        assert f == pytest.approx(np.array([-0.520691993, 0.2477253115]))
示例#2
0
    def test_density_values_correct(self):
        Hernquist = l1d.Hernquist(mass=3.4e10,
                                  effective_radius=1.8153,
                                  redshift_lens=0.3,
                                  redshift_source=0.8)

        rho = Hernquist.density_from_radii(radii=np.array([0.5, 1, 1.5]))

        assert rho == pytest.approx(
            np.array([3206677372, 676408508, 230880770]), 1e-3)
示例#3
0
    def test__effective_radius_from_combined_profile(self):

        hernquist = l1d.Hernquist(effective_radius=1.0,
                                  mass=100.0,
                                  redshift_source=0.5,
                                  redshift_lens=1.0)

        combined = l1d.CombinedProfile(profiles=[hernquist])

        assert combined.effective_radius == 1.0
示例#4
0
    def test__deflection_angle_values_correct(self):
        Hernquist = l1d.Hernquist(mass=3.4e10,
                                  effective_radius=1.8153,
                                  redshift_lens=0.3,
                                  redshift_source=0.8)

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

        assert alpha == pytest.approx(np.array([1.2211165, 0, 1.045731397]),
                                      1e-3)
示例#5
0
    def test__convergence_at_einstein_radius_less_than_one(self):
        Hernquist = l1d.Hernquist(mass=3.4e10,
                                  effective_radius=8.4,
                                  redshift_lens=0.3,
                                  redshift_source=0.8)
        radii = np.arange(0.2, 3, 0.002)

        kappa_ein = Hernquist.convergence_at_einstein_radius_from_radii(
            radii=radii)

        assert kappa_ein < 1
示例#6
0
    def test__hernquist__mass_within_half_mass_radius_equal_to_half_total_three_d_mass(
            self):
        Hernquist = l1d.Hernquist(mass=3.4e10,
                                  effective_radius=8.4,
                                  redshift_lens=0.3,
                                  redshift_source=0.8)

        mass_3d = Hernquist.three_dimensional_mass_enclosed_within_radii(
            radii=Hernquist.half_mass_radius)

        assert mass_3d == pytest.approx(Hernquist.mass * 0.5, 1e-3)
示例#7
0
    def test__surface_mass_density_values_correct(self):
        Hernquist = l1d.Hernquist(mass=3.4e10,
                                  effective_radius=1.8153,
                                  redshift_lens=0.3,
                                  redshift_source=0.8)

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

        assert sigma == pytest.approx(np.array([4053818282, 0, 682832509]),
                                      1e-3)
示例#8
0
    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)
示例#9
0
    def test__convergence_equal_to_surface_mass_density_divided_by_sigma_crit(
            self):
        Hernquist = l1d.Hernquist(mass=3.4e10,
                                  effective_radius=8.4,
                                  redshift_lens=0.3,
                                  redshift_source=0.8)
        radii = np.arange(0.2, 3, 0.002)

        rho = Hernquist.surface_mass_density_from_radii(radii=radii)
        kappa = Hernquist.convergence_from_radii(radii=radii)
        kappa_via_sigma = rho / Hernquist.critical_surface_density_of_lens

        assert kappa == pytest.approx(kappa_via_sigma, 1e-4)
示例#10
0
    def test__convergence_values_correct(self):
        Hernquist = l1d.Hernquist(mass=3.4e10,
                                  effective_radius=1.8153,
                                  redshift_lens=0.3,
                                  redshift_source=0.8)

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

        kappa_s = Hernquist.kappa_s

        assert kappa == pytest.approx(np.array([1.318168568, 0.2219485564]),
                                      1e-3)
        assert kappa_s == pytest.approx(1.758883964, 1e-3)
示例#11
0
    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
示例#12
0
    def test__convergence_from_deflections_and_analytic(self):
        Hernquist = l1d.Hernquist(mass=3.4e10,
                                  effective_radius=8.4,
                                  redshift_lens=0.3,
                                  redshift_source=0.8)
        radii = np.arange(0.2, 3, 0.002)

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

        mean_error = np.average(kappa_analytic - kappa_from_deflections)

        assert mean_error < 1e-4
示例#13
0
    def test__convergence_at_einstein_radius_less_than_one(self):
        dm = l1d.NFWHilbert(mass_at_200=2.5e12,
                            redshift_lens=0.3,
                            redshift_source=1.0)
        baryons = l1d.Hernquist(mass=3.4e11,
                                effective_radius=3.2,
                                redshift_lens=0.3,
                                redshift_source=1.0)
        combined = l1d.CombinedProfile(profiles=[dm, baryons])

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

        kappa_ein = combined.convergence_at_einstein_radius_from_radii(
            radii=radii)

        assert kappa_ein < 1
示例#14
0
    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)
示例#15
0
    def test__deflections_equals_sum_of_individual_profile_deflections(self):
        dm = l1d.NFWHilbert(mass_at_200=2.5e14,
                            redshift_lens=0.3,
                            redshift_source=1.0)
        baryons = l1d.Hernquist(mass=3.4e11,
                                effective_radius=8.4,
                                redshift_lens=0.6,
                                redshift_source=1.2)

        combined = l1d.CombinedProfile(profiles=[dm, baryons])

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

        alpha_combined = combined.deflections_from_radii(radii=radii)
        alpha_NFW = dm.deflections_from_radii(radii=radii)
        alpha_pl = baryons.deflections_from_radii(radii=radii)

        assert alpha_combined == pytest.approx(alpha_NFW + alpha_pl, 1e-4)
示例#16
0
    def test__mean_Hernquist_convergence_within_einstein_radius_equal_to_one(
            self):
        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)

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

        einstein_radius = Hernquist.einstein_radius_in_kpc_from_radii(
            radii=radii)

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

        assert av_kappa == pytest.approx(1, 1e-3)
示例#17
0
    def test__surface_mass_density_equals_sum_of_individual_profiles(self):
        dm = l1d.NFWHilbert(mass_at_200=2.5e14,
                            redshift_lens=0.3,
                            redshift_source=1.0)
        baryons = l1d.Hernquist(mass=3.4e11,
                                effective_radius=8.4,
                                redshift_lens=0.6,
                                redshift_source=1.2)

        combined = l1d.CombinedProfile(profiles=[dm, baryons])

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

        sigma_combined = combined.surface_mass_density_from_radii(radii=radii)
        sigma_NFW = dm.surface_mass_density_from_radii(radii=radii)
        sigma_pl = baryons.surface_mass_density_from_radii(radii=radii)
        sigma_sum = sigma_NFW + sigma_pl

        assert sigma_combined == pytest.approx(sigma_sum, 1e-4)
示例#18
0
    def test__convergence_equals_sum_of_individual_profile_convergence(self):
        dm = l1d.NFWHilbert(mass_at_200=2.5e14,
                            redshift_lens=0.3,
                            redshift_source=1.0)
        baryons = l1d.Hernquist(mass=3.4e11,
                                effective_radius=8.4,
                                redshift_lens=0.6,
                                redshift_source=1.2)

        combined = l1d.CombinedProfile(profiles=[dm, baryons])

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

        kappa_combined = combined.convergence_from_radii(radii=radii)
        kappa_NFW = dm.convergence_from_radii(radii=radii)
        kappa_pl = baryons.convergence_from_radii(radii=radii)
        kappa_sum = kappa_NFW + kappa_pl

        assert kappa_combined == pytest.approx(kappa_sum, 1e-4)
示例#19
0
    def test__convergence_from_deflections_and_analytic(self):
        dm = l1d.NFWHilbert(mass_at_200=2.5e14,
                            redshift_lens=0.3,
                            redshift_source=1.0)
        baryons = l1d.Hernquist(mass=3.4e11,
                                effective_radius=8.4,
                                redshift_lens=0.6,
                                redshift_source=1.2)
        combined = l1d.CombinedProfile(profiles=[dm, baryons])

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

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

        mean_error = np.average(kappa_analytic - kappa_from_deflections)

        assert mean_error < 1e-4
    def test__three_d_mass_from_dynamics_slope_and_normalization_equals_analytic(self):
        dm = l1d.NFWHilbert(
            mass_at_200=2.5e12, redshift_lens=0.3, redshift_source=1.0
        )
        baryons = l1d.Hernquist(
            mass=3.4e11, effective_radius=3.2, redshift_lens=0.3, redshift_source=1.0
        )
        combined = l1d.CombinedProfile(profiles=[dm, baryons])

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

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

        rho_0, slope = fit.slope_and_normalisation_via_dynamics()

        reff = combined.effective_radius
        mdyn = combined.three_dimensional_mass_enclosed_within_effective_radius

        mdyn_from_dyn = mass_dynamical(rho0=rho_0, g=slope, Reff=reff * u.kpc)

        assert mdyn == pytest.approx(mdyn_from_dyn, 1e-3)
    def test__einstein_mass_from_dynamics_slope_and_normalization_equals_analytic(self):
        dm = l1d.NFWHilbert(
            mass_at_200=2.5e12, redshift_lens=0.3, redshift_source=1.0
        )
        baryons = l1d.Hernquist(
            mass=3.4e11, effective_radius=3.2, redshift_lens=0.3, redshift_source=1.0
        )
        combined = l1d.CombinedProfile(profiles=[dm, baryons])

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

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

        rho_0, slope = fit.slope_and_normalisation_via_dynamics()

        rein = combined.einstein_radius_in_kpc_from_radii(radii=radii)
        mein = combined.einstein_mass_in_solar_masses_from_radii(radii=radii)

        mein_from_dyn = mass_einstein(rho0=rho_0, g=slope, Rein=rein * u.kpc)

        assert mein == pytest.approx(mein_from_dyn, 1e-3)
示例#22
0
    def test__mean_combined_convergence_within_einstein_radius_equal_to_one(
            self):
        nfw = l1d.NFWHilbert(mass_at_200=2.5e13,
                             redshift_lens=0.5,
                             redshift_source=1.0)
        Hernquist = l1d.Hernquist(mass=2e11,
                                  effective_radius=5,
                                  redshift_lens=0.5,
                                  redshift_source=1.0)
        combined = l1d.CombinedProfile([nfw, Hernquist])

        radii = np.arange(0.1, 8, 0.001)

        einstein_radius = combined.einstein_radius_in_kpc_from_radii(
            radii=radii)

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

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

        assert av_kappa == pytest.approx(1, 1e-3)
import matplotlib.pyplot as plt
import numpy as np
import lens1d as l1d
from astropy import cosmology

cosmo = cosmology.Planck15

fig_path = "/Users/dgmt59/Documents/Plots/1D/"

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

hernquist = l1d.Hernquist(mass=10**11.21,
                          effective_radius=5.68,
                          redshift_lens=0.351,
                          redshift_source=1.071)
total = l1d.CombinedProfile.from_hernquist_and_dark_matter_fraction_within_effective_radius(
    hernquist=hernquist, dark_matter_fraction=0.4)

kappa_total = total.convergence_from_radii(radii=radii)

fig1 = plt.figure(1)
plt.loglog(radii, kappa_total, label="total")
plt.legend()

plt.show()
示例#24
0
import matplotlib.pyplot as plt
import os
import numpy as np
import pandas as pd
import lens1d as l1d

fig_path = "/Users/dgmt59/Documents/Plots/one_d_slacs/"

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)
示例#25
0
    "slacs1143-0144",
    "slacs1250+0523",
    #   'slacs1432+6317',
    "slacs2238-0754",
    "slacs2341+0000",
])

lens_name_check = np.array(["slacs0912+0029"])

for lens in lens_name:
    f = open(f"{lens}_mass_test_1d", "w")
    for mass in masses:

        baryons = l1d.Hernquist(
            mass=10**mass,
            effective_radius=slacs["R_eff"][lens],
            redshift_lens=slacs["z_lens"][lens],
            redshift_source=slacs["z_source"][lens],
        )
        DM = l1d.NFWHilbert(
            mass_at_200=slacs["M200"][lens],
            redshift_lens=slacs["z_lens"][lens],
            redshift_source=slacs["z_source"][lens],
        )

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

        mask_einstein_radius = true_profile.mask_einstein_radius_from_radii(
            width=5, radii=radii)

        fit_mask = l1d.PowerLawFit(profile=true_profile,
                                   radii=radii,
import matplotlib.pyplot as plt
import os
import numpy as np
import pandas as pd
import lens1d as l1d

fig_path = "/Users/dgmt59/Documents/Plots/one_d_slacs/"

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)
    "slacs1143-0144",
    "slacs1250+0523",
    #   'slacs1432+6317',
    "slacs2238-0754",
    "slacs2341+0000",
])

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

f = open("slacs_like_test_f_dm", "w")

for i in range(len(lens_name)):

    baryons = l1d.Hernquist(
        mass=10**(slacs["log[M*/M]_chab"][lens_name[i]]),
        effective_radius=slacs["R_eff"][lens_name[i]],
        redshift_lens=slacs["z_lens"][lens_name[i]],
        redshift_source=slacs["z_source"][lens_name[i]],
    )

    true_profile = l1d.CombinedProfile.from_hernquist_and_dark_matter_fraction_within_effective_radius(
        hernquist=baryons,
        dark_matter_fraction=slacs["f_dm_chab"][lens_name[i]])

    mask_einstein_radius = true_profile.mask_einstein_radius_from_radii(
        width=5, radii=radii)

    fit_mask = l1d.PowerLawFit(profile=true_profile,
                               radii=radii,
                               mask=mask_einstein_radius)

    fit_no_mask = l1d.PowerLawFit(profile=true_profile, radii=radii, mask=None)