Example #1
0
    def test_mdelta_to_mdelta(self):
        func = mass_concentration.duffy_concentration
        # Consistency
        z = 0.3
        m_in = u.Quantity(5e14, u.solMass)
        mdelta = mass_concentration.mdelta_to_mdelta(5e14, func, 500, 200,
                                                     (z, self._cosmo))
        c = func(mdelta, z, self._cosmo)
        nfw = NFW(mdelta, c, z)
        m_out = nfw.mass_Delta(500)
        assert_quantity_allclose(m_in, m_out)

        mdelta1 = mass_concentration.mdelta_to_mdelta(m_in, func, 200, 500,
                                                      (z, self._cosmo))
        nfw = NFW(m_in, func(m_in, z, self._cosmo), z)
        mdelta2 = nfw.mass_Delta(500)
        assert_quantity_allclose(mdelta1, mdelta2)
        # common cases:
        m_in = u.Quantity(1e14, u.solMass)
        z = 0
        mdelta1 = mass_concentration.mdelta_to_mdelta(m_in, func, 2500, 500,
                                                      (z, self._cosmo))
        mdelta2 = self._mdelta_to_mdelta_via_m200(m_in, func, 2500, 500, z)
        assert_quantity_allclose(mdelta1, mdelta2)

        # Test some extreme cases
        # first almost equal input and output overdensities
        m_in = u.Quantity(1e14, u.solMass)
        z = 1
        m200 = mass_concentration.mdelta_to_mdelta(m_in, func, 199, 200,
                                                   (z, self._cosmo))
        m_out = mass_concentration.mdelta_to_mdelta(m200, func, 200, 199,
                                                    (z, self._cosmo))
        assert_quantity_allclose(m_in, m_out)

        # identical input/output overdensity
        mdelta = mass_concentration.mdelta_to_mdelta(1e14, func, 200, 200,
                                                     (1, self._cosmo))
        assert_equal(mdelta.value, 1e14)

        # Large overdensity_in, small overdensity_out
        m_in = 1e15
        z = 0
        mdelta1 = mass_concentration.mdelta_to_mdelta(m_in, func, 2500, 50,
                                                      (z, self._cosmo))
        mdelta2 = self._mdelta_to_mdelta_via_m200(m_in, func, 2500, 50, z)
        assert_quantity_allclose(mdelta1, mdelta2)

        # Small overdensity_in, large overdensity_out, small halo mass
        m_in = 1e9
        z = 1
        mdelta1 = mass_concentration.mdelta_to_mdelta(m_in, func, 50, 2500,
                                                      (z, self._cosmo))
        mdelta2 = self._mdelta_to_mdelta_via_m200(m_in, func, 50, 2500, z)
        assert_quantity_allclose(mdelta1, mdelta2)
Example #2
0
 def test_mdelta_to_m200(self):
     m_in = u.Quantity(2e14, u.solMass)
     z = 0.2
     func = mass_concentration.duffy_concentration
     delta_in = 450
     # consistency with mdelta_to_mdelta
     md1 = mass_concentration.mdelta_to_m200(m_in, func, delta_in,
                                             (z, self._cosmo))
     md2 = mass_concentration.mdelta_to_mdelta(m_in, func,
                                               delta_in, 200,
                                               (z, self._cosmo))
     assert_quantity_allclose(md1, md2)
     # consistency with mass_Delta in NFW
     nfw = NFW(md1, func(md1, z, self._cosmo), z)
     m_out = nfw.mass_Delta(450)
     assert_quantity_allclose(m_in, m_out)