def test_generalizedOM(self):
# generalized OM model
gom = Anisotropy(anisotropy_type='GOM')
r = self._r_array
R = 2
om = Anisotropy(anisotropy_type='OM')
kwargs_om = {'r_ani': 1.}
kwargs_gom = {'r_ani': 1., 'beta_inf': 1.}
beta_gom = gom.beta_r(r, **kwargs_gom)
beta_om = om.beta_r(r, **kwargs_om)
npt.assert_almost_equal(beta_gom, beta_om, decimal=5)
f_om = om.anisotropy_solution(r, **kwargs_om)
f_gom = gom.anisotropy_solution(r, **kwargs_gom)
npt.assert_almost_equal(f_gom, f_om, decimal=5)
K_gom = gom.K(r, R, **kwargs_gom)
K_om = om.K(r, R, **kwargs_om)
npt.assert_almost_equal(K_gom, K_om, decimal=3)
assert hasattr(gom._model, '_f_12_interp')
assert hasattr(gom._model, '_f_32_interp')
gom.delete_anisotropy_cache()
if hasattr(gom._model, '_f_12_interp'):
assert False
if hasattr(gom._model, '_f_32_interp'):
assert False
from lenstronomy.GalKin.anisotropy import GeneralizedOM
gom_class = GeneralizedOM()
_F = gom_class._F(a=3 / 2., z=0.5, beta_inf=1)
_F_array = gom_class._F(a=3 / 2., z=np.array([0.5]), beta_inf=1)
npt.assert_almost_equal(_F_array[0], _F, decimal=5)
def test_beta(self):
r = 2.
anisoClass = Anisotropy(anisotropy_type='const')
kwargs = {'beta': 1.}
beta = anisoClass.beta_r(r, **kwargs)
npt.assert_almost_equal(beta, 1, decimal=5)
anisoClass = Anisotropy(anisotropy_type='Colin')
kwargs = {'r_ani': 1}
beta = anisoClass.beta_r(r, **kwargs)
npt.assert_almost_equal(beta, 1. / 3, decimal=5)
anisoClass = Anisotropy(anisotropy_type='radial')
kwargs = {}
beta = anisoClass.beta_r(r, **kwargs)
npt.assert_almost_equal(beta, 1, decimal=5)
anisoClass = Anisotropy(anisotropy_type='isotropic')
kwargs = {}
beta = anisoClass.beta_r(r, **kwargs)
npt.assert_almost_equal(beta, 0, decimal=5)
anisoClass = Anisotropy(anisotropy_type='OM')
kwargs = {'r_ani': 1}
beta = anisoClass.beta_r(r, **kwargs)
npt.assert_almost_equal(beta, 0.8, decimal=5)
def test_isotropic_anisotropy(self):
# radial
r = 2.
R = 1.
isotropic = Anisotropy(anisotropy_type='isotropic')
kwargs_iso = {}
beta = isotropic.beta_r(r, **kwargs_iso)
k = isotropic.K(r, R, **kwargs_iso)
f = isotropic.anisotropy_solution(r, **kwargs_iso)
assert f == 1
print(beta, 'test')
const = Anisotropy(anisotropy_type='const')
kwargs = {'beta': beta}
k_const = const.K(r, R, **kwargs)
print(k, k_const)
npt.assert_almost_equal(k, k_const, decimal=5)
def test_radial_anisotropy(self):
# radial
r = 2.
R = 1.
radial = Anisotropy(anisotropy_type='radial')
kwargs_rad = {}
beta = radial.beta_r(r, **kwargs_rad)
k = radial.K(r, R, **kwargs_rad)
f = radial.anisotropy_solution(r, **kwargs_rad)
assert f == r**2
const = Anisotropy(anisotropy_type='const')
kwargs = {'beta': beta}
print(beta, 'beta')
#kwargs = {'beta': 1}
k_mamon = const.K(r, R, **kwargs)
print(k, k_mamon)
npt.assert_almost_equal(k, k_mamon, decimal=5)
class GalKinAnalytic(object):
"""
master class for all computations
"""
def __init__(self,
aperture='slit',
mass_profile='power_law',
light_profile='Hernquist',
anisotropy_type='r_ani',
psf_fwhm=0.7,
kwargs_cosmo={
'D_d': 1000,
'D_s': 2000,
'D_ds': 500
}):
"""
initializes the observation condition and masks
:param aperture_type: string
:param psf_fwhm: float
"""
self._mass_profile = mass_profile
self._fwhm = psf_fwhm
self._kwargs_cosmo = kwargs_cosmo
self.lightProfile = LightProfileOld(light_profile)
self.aperture = Aperture(aperture)
self.anisotropy = Anisotropy(anisotropy_type)
self.FWHM = psf_fwhm
self.jeans_solver = JeansSolver(kwargs_cosmo, mass_profile,
light_profile, anisotropy_type)
def vel_disp(self,
kwargs_profile,
kwargs_aperture,
kwargs_light,
kwargs_anisotropy,
num=1000):
"""
computes the averaged LOS velocity dispersion in the slit (convolved)
:param gamma:
:param phi_E:
:param r_eff:
:param r_ani:
:param R_slit:
:param FWHM:
:return:
"""
sigma_s2_sum = 0
for i in range(0, num):
sigma_s2_draw = self._vel_disp_one(kwargs_profile, kwargs_aperture,
kwargs_light, kwargs_anisotropy)
sigma_s2_sum += sigma_s2_draw
sigma_s2_average = sigma_s2_sum / num
return np.sqrt(sigma_s2_average)
def _vel_disp_one(self, kwargs_profile, kwargs_aperture, kwargs_light,
kwargs_anisotropy):
"""
computes one realisation of the velocity dispersion realized in the slit
:param gamma:
:param rho0_r0_gamma:
:param r_eff:
:param r_ani:
:param R_slit:
:param dR_slit:
:param FWHM:
:return:
"""
while True:
r = self.lightProfile.draw_light(kwargs_light) # draw r
R, x, y = util.R_r(r) # draw projected R
x_, y_ = util.displace_PSF(x, y, self.FWHM) # displace via PSF
bool = self.aperture.aperture_select(x_, y_, kwargs_aperture)
if bool is True:
break
sigma_s2 = self.sigma_s2(r, R, kwargs_profile, kwargs_anisotropy,
kwargs_light)
return sigma_s2
def sigma_s2(self, r, R, kwargs_profile, kwargs_anisotropy, kwargs_light):
"""
projected velocity dispersion
:param r:
:param R:
:param r_ani:
:param a:
:param gamma:
:param phi_E:
:return:
"""
beta = self.anisotropy.beta_r(r, kwargs_anisotropy)
return (1 - beta * R**2 / r**2) * self.sigma_r2(
r, kwargs_profile, kwargs_anisotropy, kwargs_light)
def sigma_r2(self, r, kwargs_profile, kwargs_anisotropy, kwargs_light):
"""
computes radial velocity dispersion at radius r (solving the Jeans equation
:param r:
:return:
"""
return self.jeans_solver.sigma_r2(r, kwargs_profile, kwargs_anisotropy,
kwargs_light)
