Ejemplo n.º 1
0
    def test__summarize_in_units(self):
        sersic = al.light_profiles.SphericalSersic(intensity=3.0,
                                                   effective_radius=2.0,
                                                   sersic_index=2.0)

        summary_text = sersic.summarize_in_units(
            radii=[al.Length(10.0), al.Length(500.0)],
            prefix="sersic_",
            unit_length="arcsec",
            unit_luminosity="eps",
            whitespace=50,
        )

        i = 0

        assert summary_text[i] == "Light Profile = SphericalSersic\n"
        i += 1
        assert (
            summary_text[i] ==
            "sersic_luminosity_within_10.00_arcsec             1.8854e+02 eps")
        i += 1
        assert (
            summary_text[i] ==
            "sersic_luminosity_within_500.00_arcsec            1.9573e+02 eps")
        i += 1
Ejemplo n.º 2
0
    def test__luminosity_units_conversions__uses_exposure_time(self):
        sersic_eps = al.light_profiles.SphericalSersic(intensity=al.Luminosity(
            3.0, "eps"),
                                                       effective_radius=2.0,
                                                       sersic_index=1.0)

        radius = al.Length(0.5, "arcsec")

        luminosity_analytic = luminosity_from_radius_and_profile(
            radius=radius, profile=sersic_eps)

        luminosity_integral = sersic_eps.luminosity_within_circle_in_units(
            radius=radius, unit_luminosity="eps", exposure_time=3.0)

        # eps -> eps

        assert luminosity_analytic == pytest.approx(luminosity_integral, 1e-3)

        # eps -> counts

        luminosity_integral = sersic_eps.luminosity_within_circle_in_units(
            radius=radius, unit_luminosity="counts", exposure_time=3.0)

        assert 3.0 * luminosity_analytic == pytest.approx(
            luminosity_integral, 1e-3)

        sersic_counts = al.light_profiles.SphericalSersic(
            intensity=al.Luminosity(3.0, "counts"),
            effective_radius=2.0,
            sersic_index=1.0,
        )

        radius = al.Length(0.5, "arcsec")

        luminosity_analytic = luminosity_from_radius_and_profile(
            radius=radius, profile=sersic_counts)
        luminosity_integral = sersic_counts.luminosity_within_circle_in_units(
            radius=radius, unit_luminosity="eps", exposure_time=3.0)

        # counts -> eps

        assert luminosity_analytic / 3.0 == pytest.approx(
            luminosity_integral, 1e-3)

        luminosity_integral = sersic_counts.luminosity_within_circle_in_units(
            radius=radius, unit_luminosity="counts", exposure_time=3.0)

        # counts -> counts

        assert luminosity_analytic == pytest.approx(luminosity_integral, 1e-3)
Ejemplo n.º 3
0
    def test__conversions_from_arcsec_to_kpc_and_back__errors_raised_if_no_kpc_per_arcsec(
        self
    ):
        unit_arcsec = al.Length(value=2.0)

        assert unit_arcsec == 2.0
        assert unit_arcsec.unit_length == "arcsec"

        unit_arcsec = unit_arcsec.convert(unit_length="arcsec")

        assert unit_arcsec == 2.0
        assert unit_arcsec.unit == "arcsec"

        unit_kpc = unit_arcsec.convert(unit_length="kpc", kpc_per_arcsec=2.0)

        assert unit_kpc == 4.0
        assert unit_kpc.unit == "kpc"

        unit_kpc = unit_kpc.convert(unit_length="kpc")

        assert unit_kpc == 4.0
        assert unit_kpc.unit == "kpc"

        unit_arcsec = unit_kpc.convert(unit_length="arcsec", kpc_per_arcsec=2.0)

        assert unit_arcsec == 2.0
        assert unit_arcsec.unit == "arcsec"

        with pytest.raises(exc.UnitsException):
            unit_arcsec.convert(unit_length="kpc")
            unit_kpc.convert(unit_length="arcsec")
            unit_arcsec.convert(unit_length="lol")
Ejemplo n.º 4
0
    def test__within_ellipse_in_counts__check_multiplies_by_exposure_time(
            self):

        sersic = al.light_profiles.EllipticalSersic(
            axis_ratio=0.5,
            phi=90.0,
            intensity=3.0,
            effective_radius=2.0,
            sersic_index=2.0,
        )

        radius = al.Length(0.5, "arcsec")
        luminosity_grid = 0.0

        xs = np.linspace(-1.8, 1.8, 80)
        ys = np.linspace(-1.8, 1.8, 80)

        edge = xs[1] - xs[0]
        area = edge**2

        for x in xs:
            for y in ys:

                eta = sersic.grid_to_elliptical_radii(np.array([[x, y]]))

                if eta < radius:
                    luminosity_grid += sersic.profile_image_from_grid_radii(
                        eta) * area

        luminosity_integral = sersic.luminosity_within_ellipse_in_units(
            major_axis=radius, unit_luminosity="counts", exposure_time=3.0)

        assert 3.0 * luminosity_grid[0] == pytest.approx(
            luminosity_integral, 0.02)
Ejemplo n.º 5
0
        def test__conversion_requires_kpc_per_arcsec_but_does_not_supply_it_raises_error(
            self
        ):

            profile_arcsec = MockDimensionsProfile(
                position=(al.Length(1.0, "arcsec"), al.Length(2.0, "arcsec"))
            )

            with pytest.raises(exc.UnitsException):
                profile_arcsec.new_profile_with_units_converted(unit_length="kpc")

            profile_kpc = profile_arcsec.new_profile_with_units_converted(
                unit_length="kpc", kpc_per_arcsec=2.0
            )

            with pytest.raises(exc.UnitsException):
                profile_kpc.new_profile_with_units_converted(unit_length="arcsec")
Ejemplo n.º 6
0
        def test__unit_length__extracted_from_profile(self):

            profile = MockDimensionsProfile(
                length=al.Length(value=3.0, unit_length="arcsec")
            )

            assert profile.unit_length == "arcsec"

            profile = MockDimensionsProfile(
                length=al.Length(value=3.0, unit_length="kpc")
            )

            assert profile.unit_length == "kpc"

            profile = MockDimensionsProfile(length=1.0)

            assert profile.unit_length == None
Ejemplo n.º 7
0
    def unit_length_calc(
        self,
        length_input: al.Length,
        redshift_profile=None,
        cosmology=MockCosmology(),
        unit_length="arcsec",
        **kwargs
    ):

        return al.Length(self.length + length_input, self.unit_length)
Ejemplo n.º 8
0
    def test__luminosity_in_eps__spherical_sersic_2__compare_to_grid(self):
        sersic = al.light_profiles.SphericalSersic(intensity=3.0,
                                                   effective_radius=2.0,
                                                   sersic_index=2.0)

        radius = al.Length(1.0, "arcsec")

        luminosity_grid = luminosity_from_radius_and_profile(radius=radius,
                                                             profile=sersic)

        luminosity_integral = sersic.luminosity_within_circle_in_units(
            radius=radius, unit_luminosity="eps")

        assert luminosity_grid == pytest.approx(luminosity_integral, 0.02)
Ejemplo n.º 9
0
        def test__mass_conversion_requires_critical_surface_density_but_does_not_supply_it_raises_error(
            self
        ):

            profile_angular = MockDimensionsProfile(
                position=(al.Length(1.0, "arcsec"), al.Length(2.0, "arcsec")),
                param_float=2.0,
                length=al.Length(value=3.0, unit_length="arcsec"),
                luminosity=al.Luminosity(value=4.0, unit_luminosity="eps"),
                mass=al.Mass(value=5.0, unit_mass="angular"),
                mass_over_luminosity=al.MassOverLuminosity(
                    value=6.0, unit_luminosity="eps", unit_mass="angular"
                ),
            )

            with pytest.raises(exc.UnitsException):
                profile_angular.new_profile_with_units_converted(unit_mass="solMass")

            profile_solMass = profile_angular.new_profile_with_units_converted(
                unit_mass="solMass", critical_surface_density=10.0
            )

            with pytest.raises(exc.UnitsException):
                profile_solMass.new_profile_with_units_converted(unit_mass="angular")
Ejemplo n.º 10
0
    def test__profile_length_units_calculations__profile_is_converted_for_calculation_if_different_to_input_units(
        self
    ):

        profile = MockDimensionsProfile(length=al.Length(3.0, "arcsec"))

        cosmo = MockCosmology(kpc_per_arcsec=2.0)

        # length: arcsec -> arcsec, stays 3.0,  length_input: arcsec -> arcsec, stays 1.0

        length_input = al.Length(1.0, "arcsec")
        length = profile.unit_length_calc(
            length_input=length_input, unit_length="arcsec"
        )
        assert length.unit_length == "arcsec"
        assert length == 4.0

        # length: arcsec -> arcsec, stays 3.0,  length_input  kpc -> arcsec, converts to 1.0 / 2.0 = 0.5

        length_input = al.Length(1.0, "kpc")
        length = profile.unit_length_calc(
            length_input=length_input,
            unit_length="arcsec",
            redshift_profile=0.5,
            cosmology=cosmo,
        )
        assert length.unit_length == "arcsec"
        assert length == 3.5

        # length: arcsec -> kpc, converts to 3.0 * 2.0 = 6.0,  length_input  kpc -> kpc, stays 1.0

        length_input = al.Length(1.0, "kpc")
        length = profile.unit_length_calc(
            length_input=length_input,
            unit_length="kpc",
            redshift_profile=0.5,
            cosmology=cosmo,
        )
        assert length.unit_length == "kpc"
        assert length == 7.0

        profile = MockDimensionsProfile(length=al.Length(3.0, "kpc"))

        # length: kpc -> kpc, stays 3.0,  length_input: kpc -> kpc, stays 1.0

        length_input = al.Length(1.0, "kpc")
        length = profile.unit_length_calc(
            length_input=length_input,
            unit_length="kpc",
            redshift_profile=0.5,
            cosmology=cosmo,
        )
        assert length.unit_length == "kpc"
        assert length == 4.0

        # length: kpc -> kpc, stays 3.0,  length_input: arcsec -> kpc, convert to 1.0 * 2.0 = 2.0

        length_input = al.Length(1.0, "arcsec")
        length = profile.unit_length_calc(
            length_input=length_input,
            unit_length="kpc",
            redshift_profile=0.5,
            cosmology=cosmo,
        )
        assert length.unit_length == "kpc"
        assert length == 5.0

        # length: kpc -> arcsec, converts to 3.0 / 2.0 = 1.5,  length_input: kpc -> kpc, stays 1.0

        length_input = al.Length(1.0, "arcsec")
        length = profile.unit_length_calc(
            length_input=length_input,
            unit_length="arcsec",
            redshift_profile=0.5,
            cosmology=cosmo,
        )
        assert length.unit_length == "arcsec"
        assert length == 2.5
Ejemplo n.º 11
0
        def test__angular_to_solMass_conversions_of_mass__conversions_convert_values(
            self
        ):

            profile_angular = MockDimensionsProfile(
                position=(al.Length(1.0, "arcsec"), al.Length(2.0, "arcsec")),
                param_float=2.0,
                length=al.Length(value=3.0, unit_length="arcsec"),
                luminosity=al.Luminosity(value=4.0, unit_luminosity="eps"),
                mass=al.Mass(value=5.0, unit_mass="angular"),
                mass_over_luminosity=al.MassOverLuminosity(
                    value=6.0, unit_luminosity="eps", unit_mass="angular"
                ),
            )

            assert profile_angular.position == (1.0, 2.0)
            assert profile_angular.position[0].unit_length == "arcsec"
            assert profile_angular.position[1].unit_length == "arcsec"
            assert profile_angular.param_float == 2.0
            assert profile_angular.length == 3.0
            assert profile_angular.length.unit_length == "arcsec"
            assert profile_angular.luminosity == 4.0
            assert profile_angular.luminosity.unit_luminosity == "eps"
            assert profile_angular.mass == 5.0
            assert profile_angular.mass.unit_mass == "angular"
            assert profile_angular.mass_over_luminosity == 6.0
            assert profile_angular.mass_over_luminosity.unit == "angular / eps"

            profile_angular = profile_angular.new_profile_with_units_converted(
                unit_mass="angular"
            )

            assert profile_angular.position == (1.0, 2.0)
            assert profile_angular.position[0].unit_length == "arcsec"
            assert profile_angular.position[1].unit_length == "arcsec"
            assert profile_angular.param_float == 2.0
            assert profile_angular.length == 3.0
            assert profile_angular.length.unit_length == "arcsec"
            assert profile_angular.luminosity == 4.0
            assert profile_angular.luminosity.unit_luminosity == "eps"
            assert profile_angular.mass == 5.0
            assert profile_angular.mass.unit_mass == "angular"
            assert profile_angular.mass_over_luminosity == 6.0
            assert profile_angular.mass_over_luminosity.unit == "angular / eps"

            profile_solMass = profile_angular.new_profile_with_units_converted(
                unit_mass="solMass", critical_surface_density=10.0
            )

            assert profile_solMass.position == (1.0, 2.0)
            assert profile_solMass.position[0].unit_length == "arcsec"
            assert profile_solMass.position[1].unit_length == "arcsec"
            assert profile_solMass.param_float == 2.0
            assert profile_solMass.length == 3.0
            assert profile_solMass.length.unit_length == "arcsec"
            assert profile_solMass.luminosity == 4.0
            assert profile_solMass.luminosity.unit_luminosity == "eps"
            assert profile_solMass.mass == 50.0
            assert profile_solMass.mass.unit_mass == "solMass"
            assert profile_solMass.mass_over_luminosity == pytest.approx(60.0, 1.0e-4)
            assert profile_solMass.mass_over_luminosity.unit == "solMass / eps"

            profile_solMass = profile_solMass.new_profile_with_units_converted(
                unit_mass="solMass"
            )

            assert profile_solMass.position == (1.0, 2.0)
            assert profile_solMass.position[0].unit_length == "arcsec"
            assert profile_solMass.position[1].unit_length == "arcsec"
            assert profile_solMass.param_float == 2.0
            assert profile_solMass.length == 3.0
            assert profile_solMass.length.unit_length == "arcsec"
            assert profile_solMass.luminosity == 4.0
            assert profile_solMass.luminosity.unit_luminosity == "eps"
            assert profile_solMass.mass == 50.0
            assert profile_solMass.mass.unit_mass == "solMass"
            assert profile_solMass.mass_over_luminosity == pytest.approx(60.0, 1.0e-4)
            assert profile_solMass.mass_over_luminosity.unit == "solMass / eps"

            profile_angular = profile_solMass.new_profile_with_units_converted(
                unit_mass="angular", critical_surface_density=10.0
            )

            assert profile_angular.position == (1.0, 2.0)
            assert profile_angular.position[0].unit_length == "arcsec"
            assert profile_angular.position[1].unit_length == "arcsec"
            assert profile_angular.param_float == 2.0
            assert profile_angular.length == 3.0
            assert profile_angular.length.unit_length == "arcsec"
            assert profile_angular.luminosity == 4.0
            assert profile_angular.luminosity.unit_luminosity == "eps"
            assert profile_angular.mass == 5.0
            assert profile_angular.mass.unit_mass == "angular"
            assert profile_angular.mass_over_luminosity == pytest.approx(6.0, 1.0e-4)
            assert profile_angular.mass_over_luminosity.unit == "angular / eps"
Ejemplo n.º 12
0
        def test__eps_to_counts_conversions_of_luminosity__conversions_convert_values(
            self
        ):

            profile_eps = MockDimensionsProfile(
                position=(al.Length(1.0, "arcsec"), al.Length(2.0, "arcsec")),
                param_float=2.0,
                length=al.Length(value=3.0, unit_length="arcsec"),
                luminosity=al.Luminosity(value=4.0, unit_luminosity="eps"),
                mass=al.Mass(value=5.0, unit_mass="angular"),
                mass_over_luminosity=al.MassOverLuminosity(
                    value=6.0, unit_luminosity="eps", unit_mass="angular"
                ),
            )

            assert profile_eps.position == (1.0, 2.0)
            assert profile_eps.position[0].unit_length == "arcsec"
            assert profile_eps.position[1].unit_length == "arcsec"
            assert profile_eps.param_float == 2.0
            assert profile_eps.length == 3.0
            assert profile_eps.length.unit_length == "arcsec"
            assert profile_eps.luminosity == 4.0
            assert profile_eps.luminosity.unit_luminosity == "eps"
            assert profile_eps.mass == 5.0
            assert profile_eps.mass.unit_mass == "angular"
            assert profile_eps.mass_over_luminosity == 6.0
            assert profile_eps.mass_over_luminosity.unit == "angular / eps"

            profile_eps = profile_eps.new_profile_with_units_converted(
                unit_luminosity="eps"
            )

            assert profile_eps.position == (1.0, 2.0)
            assert profile_eps.position[0].unit_length == "arcsec"
            assert profile_eps.position[1].unit_length == "arcsec"
            assert profile_eps.param_float == 2.0
            assert profile_eps.length == 3.0
            assert profile_eps.length.unit_length == "arcsec"
            assert profile_eps.luminosity == 4.0
            assert profile_eps.luminosity.unit_luminosity == "eps"
            assert profile_eps.mass == 5.0
            assert profile_eps.mass.unit_mass == "angular"
            assert profile_eps.mass_over_luminosity == 6.0
            assert profile_eps.mass_over_luminosity.unit == "angular / eps"

            profile_counts = profile_eps.new_profile_with_units_converted(
                unit_luminosity="counts", exposure_time=10.0
            )

            assert profile_counts.position == (1.0, 2.0)
            assert profile_counts.position[0].unit_length == "arcsec"
            assert profile_counts.position[1].unit_length == "arcsec"
            assert profile_counts.param_float == 2.0
            assert profile_counts.length == 3.0
            assert profile_counts.length.unit_length == "arcsec"
            assert profile_counts.luminosity == 40.0
            assert profile_counts.luminosity.unit_luminosity == "counts"
            assert profile_counts.mass == 5.0
            assert profile_counts.mass.unit_mass == "angular"
            assert profile_counts.mass_over_luminosity == pytest.approx(0.6, 1.0e-4)
            assert profile_counts.mass_over_luminosity.unit == "angular / counts"

            profile_counts = profile_counts.new_profile_with_units_converted(
                unit_luminosity="counts"
            )

            assert profile_counts.position == (1.0, 2.0)
            assert profile_counts.position[0].unit_length == "arcsec"
            assert profile_counts.position[1].unit_length == "arcsec"
            assert profile_counts.param_float == 2.0
            assert profile_counts.length == 3.0
            assert profile_counts.length.unit_length == "arcsec"
            assert profile_counts.luminosity == 40.0
            assert profile_counts.luminosity.unit_luminosity == "counts"
            assert profile_counts.mass == 5.0
            assert profile_counts.mass.unit_mass == "angular"
            assert profile_counts.mass_over_luminosity == pytest.approx(0.6, 1.0e-4)
            assert profile_counts.mass_over_luminosity.unit == "angular / counts"

            profile_eps = profile_counts.new_profile_with_units_converted(
                unit_luminosity="eps", exposure_time=10.0
            )

            assert profile_eps.position == (1.0, 2.0)
            assert profile_eps.position[0].unit_length == "arcsec"
            assert profile_eps.position[1].unit_length == "arcsec"
            assert profile_eps.param_float == 2.0
            assert profile_eps.length == 3.0
            assert profile_eps.length.unit_length == "arcsec"
            assert profile_eps.luminosity == 4.0
            assert profile_eps.luminosity.unit_luminosity == "eps"
            assert profile_eps.mass == 5.0
            assert profile_eps.mass.unit_mass == "angular"
            assert profile_eps.mass_over_luminosity == pytest.approx(6.0, 1.0e-4)
            assert profile_eps.mass_over_luminosity.unit == "angular / eps"
Ejemplo n.º 13
0
        def test__arcsec_to_kpc_conversions_of_length__float_and_tuple_length__conversion_converts_values(
            self
        ):

            profile_arcsec = MockDimensionsProfile(
                position=(al.Length(1.0, "arcsec"), al.Length(2.0, "arcsec")),
                param_float=2.0,
                length=al.Length(value=3.0, unit_length="arcsec"),
                luminosity=al.Luminosity(value=4.0, unit_luminosity="eps"),
                mass=al.Mass(value=5.0, unit_mass="angular"),
                mass_over_luminosity=al.MassOverLuminosity(
                    value=6.0, unit_luminosity="eps", unit_mass="angular"
                ),
            )

            assert profile_arcsec.position == (1.0, 2.0)
            assert profile_arcsec.position[0].unit_length == "arcsec"
            assert profile_arcsec.position[1].unit_length == "arcsec"
            assert profile_arcsec.param_float == 2.0
            assert profile_arcsec.length == 3.0
            assert profile_arcsec.length.unit_length == "arcsec"
            assert profile_arcsec.luminosity == 4.0
            assert profile_arcsec.luminosity.unit_luminosity == "eps"
            assert profile_arcsec.mass == 5.0
            assert profile_arcsec.mass.unit_mass == "angular"
            assert profile_arcsec.mass_over_luminosity == 6.0
            assert profile_arcsec.mass_over_luminosity.unit == "angular / eps"

            profile_arcsec = profile_arcsec.new_profile_with_units_converted(
                unit_length="arcsec"
            )

            assert profile_arcsec.position == (1.0, 2.0)
            assert profile_arcsec.position[0].unit == "arcsec"
            assert profile_arcsec.position[1].unit == "arcsec"
            assert profile_arcsec.param_float == 2.0
            assert profile_arcsec.length == 3.0
            assert profile_arcsec.length.unit == "arcsec"
            assert profile_arcsec.luminosity == 4.0
            assert profile_arcsec.luminosity.unit == "eps"
            assert profile_arcsec.mass == 5.0
            assert profile_arcsec.mass.unit_mass == "angular"
            assert profile_arcsec.mass_over_luminosity == 6.0
            assert profile_arcsec.mass_over_luminosity.unit == "angular / eps"

            profile_kpc = profile_arcsec.new_profile_with_units_converted(
                unit_length="kpc", kpc_per_arcsec=2.0
            )

            assert profile_kpc.position == (2.0, 4.0)
            assert profile_kpc.position[0].unit == "kpc"
            assert profile_kpc.position[1].unit == "kpc"
            assert profile_kpc.param_float == 2.0
            assert profile_kpc.length == 6.0
            assert profile_kpc.length.unit == "kpc"
            assert profile_kpc.luminosity == 4.0
            assert profile_kpc.luminosity.unit == "eps"
            assert profile_arcsec.mass == 5.0
            assert profile_arcsec.mass.unit_mass == "angular"
            assert profile_kpc.mass_over_luminosity == 6.0
            assert profile_kpc.mass_over_luminosity.unit == "angular / eps"

            profile_kpc = profile_kpc.new_profile_with_units_converted(
                unit_length="kpc"
            )

            assert profile_kpc.position == (2.0, 4.0)
            assert profile_kpc.position[0].unit == "kpc"
            assert profile_kpc.position[1].unit == "kpc"
            assert profile_kpc.param_float == 2.0
            assert profile_kpc.length == 6.0
            assert profile_kpc.length.unit == "kpc"
            assert profile_kpc.luminosity == 4.0
            assert profile_kpc.luminosity.unit == "eps"
            assert profile_arcsec.mass == 5.0
            assert profile_arcsec.mass.unit_mass == "angular"
            assert profile_kpc.mass_over_luminosity == 6.0
            assert profile_kpc.mass_over_luminosity.unit == "angular / eps"

            profile_arcsec = profile_kpc.new_profile_with_units_converted(
                unit_length="arcsec", kpc_per_arcsec=2.0
            )

            assert profile_arcsec.position == (1.0, 2.0)
            assert profile_arcsec.position[0].unit == "arcsec"
            assert profile_arcsec.position[1].unit == "arcsec"
            assert profile_arcsec.param_float == 2.0
            assert profile_arcsec.length == 3.0
            assert profile_arcsec.length.unit == "arcsec"
            assert profile_arcsec.luminosity == 4.0
            assert profile_arcsec.luminosity.unit == "eps"
            assert profile_arcsec.mass == 5.0
            assert profile_arcsec.mass.unit_mass == "angular"
            assert profile_arcsec.mass_over_luminosity == 6.0
            assert profile_arcsec.mass_over_luminosity.unit == "angular / eps"
Ejemplo n.º 14
0
    def test__profile_mass_units_calculations__profile_is_converted_for_calculation_if_different_to_input_units(
        self
    ):

        profile = MockDimensionsProfile(
            length=al.Length(1.0, "arcsec"), mass=al.Mass(3.0, "angular")
        )

        cosmo = MockCosmology(critical_surface_density=2.0)

        # mass: angular -> angular, stays 3.0,  mass_input: angular -> angular, stays 1.0

        mass_input = al.Mass(1.0, "angular")
        mass = profile.unit_mass_calc(
            mass_input=mass_input,
            unit_mass="angular",
            redshift_profile=0.5,
            redshift_source=1.0,
            cosmology=cosmo,
        )
        assert mass.unit_mass == "angular"
        assert mass == 4.0

        # mass: angular -> angular, stays 3.0,  mass_input  solMass -> angular, stays as 1.0

        mass_input = al.Mass(1.0, "solMass")
        mass = profile.unit_mass_calc(
            mass_input=mass_input,
            unit_mass="angular",
            redshift_profile=0.5,
            redshift_source=1.0,
            cosmology=cosmo,
        )
        assert mass.unit_mass == "angular"
        assert mass == 4.0

        # mass: angular -> solMass, converts to 3.0 * 2.0 = 6.0,  mass_input  solMass -> solMass, stays 1.0

        mass_input = al.Mass(1.0, "solMass")
        mass = profile.unit_mass_calc(
            mass_input=mass_input,
            unit_mass="solMass",
            redshift_profile=0.5,
            redshift_source=1.0,
            cosmology=cosmo,
        )
        assert mass.unit_mass == "solMass"
        assert mass == 7.0

        profile = MockDimensionsProfile(
            length=al.Length(1.0, "arcsec"), mass=al.Mass(3.0, "solMass")
        )

        # mass: solMass -> solMass, stays 3.0,  mass_input: solMass -> solMass, stays 1.0

        mass_input = al.Mass(1.0, "solMass")
        mass = profile.unit_mass_calc(
            mass_input=mass_input,
            unit_mass="solMass",
            redshift_profile=0.5,
            redshift_source=1.0,
            cosmology=cosmo,
        )
        assert mass.unit_mass == "solMass"
        assert mass == 4.0

        # mass: solMass -> solMass, stays 3.0,  mass_input: angular -> solMass, convert to 1.0 * 2.0 = 2.0

        mass_input = al.Mass(1.0, "angular")
        mass = profile.unit_mass_calc(
            mass_input=mass_input,
            unit_mass="solMass",
            redshift_profile=0.5,
            redshift_source=1.0,
            cosmology=cosmo,
        )
        assert mass.unit_mass == "solMass"
        assert mass == 5.0

        # mass: solMass -> angular, stays 3.0,  mass_input: solMass -> solMass, stays 1.0

        mass_input = al.Mass(1.0, "angular")
        mass = profile.unit_mass_calc(
            mass_input=mass_input,
            unit_mass="angular",
            redshift_profile=0.5,
            redshift_source=1.0,
            cosmology=cosmo,
        )
        assert mass.unit_mass == "angular"
        assert mass == 4.0
Ejemplo n.º 15
0
    def test__radius_units_conversions__light_profile_updates_units_and_computes_correct_luminosity(
            self):
        cosmology = mock_cosmology.MockCosmology(arcsec_per_kpc=0.5,
                                                 kpc_per_arcsec=2.0)

        sersic_arcsec = al.light_profiles.SphericalSersic(
            centre=(al.Length(0.0, "arcsec"), al.Length(0.0, "arcsec")),
            intensity=al.Luminosity(3.0, "eps"),
            effective_radius=al.Length(2.0, "arcsec"),
            sersic_index=1.0,
        )

        sersic_kpc = al.light_profiles.SphericalSersic(
            centre=(al.Length(0.0, "kpc"), al.Length(0.0, "kpc")),
            intensity=al.Luminosity(3.0, "eps"),
            effective_radius=al.Length(4.0, "kpc"),
            sersic_index=1.0,
        )

        radius = al.Length(0.5, "arcsec")

        luminosity_analytic = luminosity_from_radius_and_profile(
            radius=radius, profile=sersic_arcsec)

        # arcsec -> arcsec

        luminosity = sersic_arcsec.luminosity_within_circle_in_units(
            radius=radius)

        assert luminosity_analytic == pytest.approx(luminosity, 1e-3)

        # kpc -> arcsec

        luminosity_analytic = luminosity_from_radius_and_profile(
            radius=1.0, profile=sersic_kpc)

        luminosity = sersic_kpc.luminosity_within_circle_in_units(
            radius=radius, redshift_profile=0.5, cosmology=cosmology)

        assert luminosity_analytic == pytest.approx(luminosity, 1e-3)

        radius = al.Length(0.5, "kpc")

        luminosity_analytic = luminosity_from_radius_and_profile(
            radius=radius, profile=sersic_kpc)

        # kpc -> kpc

        luminosity = sersic_kpc.luminosity_within_circle_in_units(
            radius=radius)

        assert luminosity_analytic == pytest.approx(luminosity, 1e-3)

        # kpc -> arcsec

        luminosity_analytic = luminosity_from_radius_and_profile(
            radius=0.25, profile=sersic_arcsec)

        luminosity = sersic_arcsec.luminosity_within_circle_in_units(
            radius=radius, redshift_profile=0.5, cosmology=cosmology)

        assert luminosity_analytic == pytest.approx(luminosity, 1e-3)

        radius = al.Length(2.0, "arcsec")
        luminosity_arcsec = sersic_arcsec.luminosity_within_circle_in_units(
            radius=radius,
            redshift_profile=0.5,
            unit_mass="angular",
            cosmology=cosmology,
        )
        radius = al.Length(4.0, "kpc")
        luminosity_kpc = sersic_arcsec.luminosity_within_circle_in_units(
            radius=radius,
            redshift_profile=0.5,
            unit_mass="angular",
            cosmology=cosmology,
        )
        assert luminosity_arcsec == luminosity_kpc