예제 #1
0
파일: test_nfw.py 프로젝트: jesford/NFW
 def test_mass_consistency(self):
     m200 = 1e15
     c = 5.0
     z = 0.3
     nfw = NFW(m200, c, z)
     m500 = nfw.mass_Delta(500)
     c500 = nfw.radius_Delta(500) / nfw.r_s
     nfw2 = NFW(m500, c500, z, overdensity=500)
     assert_almost_equal(nfw2.mass_Delta(200).value / 1e14, m200 / 1e14)
예제 #2
0
파일: test_nfw.py 프로젝트: nhmc/NFW
 def test_radius_unit_consistency(self):
     r200 = 1.5
     c = 4
     z = 0.2
     nfw1 = NFW(r200, c, z, size_type='radius')
     nfw2 = NFW(r200 * u.Mpc, c, z, size_type='radius')
     nfw3 = NFW(r200*1000 * u.kiloparsec, c, z, size_type='radius')
     assert_almost_equal(nfw1.mass_Delta(200), nfw2.mass_Delta(200))
     assert_almost_equal(nfw1.mass_Delta(200), nfw3.mass_Delta(200))
예제 #3
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)
예제 #4
0
파일: test_nfw.py 프로젝트: jesford/NFW
 def test_radius_unit_consistency(self):
     r200 = 1.5
     c = 4
     z = 0.2
     nfw1 = NFW(r200, c, z, size_type="radius")
     nfw2 = NFW(r200 * u.Mpc, c, z, size_type="radius")
     nfw3 = NFW(r200 * 1000 * u.kiloparsec, c, z, size_type="radius")
     m200_1 = nfw1.mass_Delta(200)
     m200_2 = nfw2.mass_Delta(200)
     m200_3 = nfw3.mass_Delta(200)
     m200_1 = u.Quantity(m200_1, m200_3.unit)
     m200_2 = u.Quantity(m200_2, m200_3.unit)
     assert_almost_equal(m200_1.value, m200_2.value)
     assert_almost_equal(m200_1.value, m200_3.value)
예제 #5
0
 def _mdelta_to_mdelta_via_m200(self, m_in, func, overdensity_in,
                                overdensity_out, z):
     m200 = mass_concentration.mdelta_to_m200(m_in, func, overdensity_in,
                                              (z, self._cosmo))
     nfw = NFW(m200, func(m200, z, self._cosmo), z)
     m_out = nfw.mass_Delta(overdensity_out)
     return m_out
예제 #6
0
파일: test_nfw.py 프로젝트: jesford/NFW
 def test_mass_Delta(self):
     m200 = 1e15
     c = 5.0
     z = 0.3
     nfw = NFW(m200, c, z)
     m500 = nfw.mass_Delta(500)
     assert_almost_equal(m500.value / 1e14, 7.221140, 6)
예제 #7
0
파일: test_nfw.py 프로젝트: jesford/NFW
 def test_mean_crit_consistency(self):
     m200b = 1e15
     c = 5
     z = 0.3
     nfw = NFW(m200b, c, z, overdensity_type="mean")
     m200c = nfw.mass_Delta(200, overdensity_type="critical").value
     assert_almost_equal(m200c / 1e15, 2.062054316492159)
예제 #8
0
파일: test_nfw.py 프로젝트: jesford/NFW
 def test_radius_mass_consistency(self):
     m200 = 1e15
     c = 5.0
     z = 0.3
     nfw = NFW(m200, c, z)
     r200 = nfw.radius_Delta(200)
     nfw2 = NFW(r200, c, z, size_type="radius")
     assert_almost_equal(nfw2.mass_Delta(200).value / 1e14, m200 / 1e14)
예제 #9
0
 def test_m200_to_mdelta(self):
     m_in = u.Quantity(4e14, u.solMass)
     z = 0.45
     func = mass_concentration.duffy_concentration
     mdelta = mass_concentration.m200_to_mdelta(m_in, func, 500,
                                                (z, self._cosmo))
     nfw = NFW(m_in, func(m_in, z, self._cosmo), z)
     m500 = nfw.mass_Delta(500)
     assert_quantity_allclose(mdelta, m500)
예제 #10
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)