def test_draw_light_3d_hernquist(self):
lightProfile = LightProfile(profile_list=['HERNQUIST'], min_interpolate=0.0001, max_interpolate=1000.)
kwargs_profile = [{'amp': 1., 'Rs': 0.5}]
r_list = lightProfile.draw_light_3d(kwargs_profile, n=1000000, new_compute=False)
print(r_list, 'r_list')
# project it
# test with draw light 2d profile routine
# compare with 3d analytical solution vs histogram binned
bins = np.linspace(0.0, 10, 20)
hist, bins_hist = np.histogram(r_list, bins=bins, density=True)
bins_plot = (bins_hist[1:] + bins_hist[:-1]) / 2.
light3d = lightProfile.light_3d(r=bins_plot, kwargs_list=kwargs_profile)
light3d *= bins_plot ** 2
light3d /= np.sum(light3d)
hist /= np.sum(hist)
#import matplotlib.pyplot as plt
#plt.plot(bins_plot , light3d/light3d[5], label='3d reference Hernquist')
#plt.plot(bins_plot, hist / hist[5], label='hist')
#plt.legend()
#plt.show()
print(light3d / hist)
#npt.assert_almost_equal(light3d / hist, 1, decimal=1)
# compare with 2d analytical solution vs histogram binned
#bins = np.linspace(0.1, 1, 10)
R, x, y = velocity_util.project2d_random(np.array(r_list))
hist_2d, bins_hist = np.histogram(R, bins=bins, density=True)
hist_2d /= np.sum(hist_2d)
bins_plot = (bins_hist[1:] + bins_hist[:-1]) / 2.
light2d = lightProfile.light_2d(R=bins_plot, kwargs_list=kwargs_profile)
light2d *= bins_plot ** 1
light2d /= np.sum(light2d)
light2d_finite = lightProfile.light_2d_finite(R=bins_plot, kwargs_list=kwargs_profile)
light2d_finite *= bins_plot ** 1
light2d_finite /= np.sum(light2d_finite)
hist /= np.sum(hist)
#import matplotlib.pyplot as plt
#plt.plot(bins_plot, light2d/light2d[5], '--', label='2d reference Hernquist')
#plt.plot(bins_plot, light2d_finite / light2d_finite[5], '-.', label='2d reference Hernquist finite')
#plt.plot(bins_plot, hist_2d / hist_2d[5], label='hist')
#plt.legend()
#plt.show()
print(light2d / hist_2d)
#plt.plot(R, r_list, '.', label='test')
#plt.legend()
#plt.xlim([0, 0.2])
#plt.ylim([0, 0.2])
#plt.show()
npt.assert_almost_equal(light2d / hist_2d, 1, decimal=1)
def test_light_2d_finite(self):
interpol_grid_num = 5000
max_interpolate = 10
min_interpolate = 0.0001
lightProfile = LightProfile(profile_list=['HERNQUIST'], interpol_grid_num=interpol_grid_num,
max_interpolate=max_interpolate, min_interpolate=min_interpolate)
kwargs_profile = [{'amp': 1., 'Rs': 1.}]
# check whether projected light integral is the same as analytic expression
R = 1.
I_R = lightProfile.light_2d_finite(R, kwargs_profile)
out = integrate.quad(lambda x: lightProfile.light_3d(np.sqrt(R ** 2 + x ** 2), kwargs_profile),
min_interpolate, np.sqrt(max_interpolate ** 2 - R ** 2))
l_R_quad = out[0] * 2
npt.assert_almost_equal(l_R_quad / I_R, 1, decimal=2)
l_R = lightProfile.light_2d(R, kwargs_profile)
npt.assert_almost_equal(l_R / I_R, 1, decimal=2)
def test_draw_light_3d_power_law(self):
lightProfile = LightProfile(profile_list=['POWER_LAW'], min_interpolate=0.0001, max_interpolate=1000.)
kwargs_profile = [{'amp': 1., 'gamma': 2, 'e1': 0, 'e2': 0}]
r_list = lightProfile.draw_light_3d(kwargs_profile, n=1000000, new_compute=False)
print(r_list, 'r_list')
# project it
R, x, y = velocity_util.project2d_random(r_list)
# test with draw light 2d profile routine
# compare with 3d analytical solution vs histogram binned
bins = np.linspace(0.1, 10, 10)
hist, bins_hist = np.histogram(r_list, bins=bins, density=True)
bins_plot = (bins_hist[1:] + bins_hist[:-1]) / 2.
light3d = lightProfile.light_3d(r=bins_plot, kwargs_list=kwargs_profile)
light3d *= bins_plot ** 2
light3d /= np.sum(light3d)
hist /= np.sum(hist)
#import matplotlib.pyplot as plt
#plt.plot(bins_plot , light3d/light3d[5], label='3d reference power-law')
#plt.plot(bins_plot, hist / hist[5], label='hist')
#plt.legend()
#plt.show()
print(light3d / hist)
npt.assert_almost_equal(light3d / hist, 1, decimal=1)
# compare with 2d analytical solution vs histogram binned
#bins = np.linspace(0.1, 1, 10)
hist, bins_hist = np.histogram(R, bins=bins, density=True)
bins_plot = (bins_hist[1:] + bins_hist[:-1]) / 2.
light2d = lightProfile.light_2d_finite(R=bins_plot, kwargs_list=kwargs_profile)
light2d *= bins_plot ** 1
light2d /= np.sum(light2d)
hist /= np.sum(hist)
#import matplotlib.pyplot as plt
#plt.plot(bins_plot , light2d/light2d[5], label='2d reference power-law')
#plt.plot(bins_plot, hist / hist[5], label='hist')
#plt.legend()
#plt.show()
print(light2d / hist)
npt.assert_almost_equal(light2d / hist, 1, decimal=1)
class NumericKinematics(Anisotropy):
def __init__(self,
kwargs_model,
kwargs_cosmo,
interpol_grid_num=1000,
log_integration=True,
max_integrate=1000,
min_integrate=0.0001,
max_light_draw=None,
lum_weight_int_method=True):
"""
What we need:
- max projected R to have ACCURATE I_R_sigma values
- make sure everything outside cancels out (or is not rendered)
:param interpol_grid_num: number of interpolation bins for integrand and interpolated functions
:param log_integration: bool, if True, performs the numerical integral in log space distance (adviced)
(only applies for lum_weight_int_method=True)
:param max_integrate: maximum radius (in arc seconds) of the Jeans equation integral
(assumes zero tracer particles outside this radius)
:param max_light_draw: float; (optional) if set, draws up to this radius, else uses max_interpolate value
:param lum_weight_int_method: bool, luminosity weighted dispersion integral to calculate LOS projected Jean's
solution. ATTENTION: currently less accurate than 3d solution
:param min_integrate:
"""
mass_profile_list = kwargs_model.get('mass_profile_list')
light_profile_list = kwargs_model.get('light_profile_list')
anisotropy_model = kwargs_model.get('anisotropy_model')
self._interp_grid_num = interpol_grid_num
self._log_int = log_integration
self._max_integrate = max_integrate # maximal integration (and interpolation) in units of arcsecs
self._min_integrate = min_integrate # min integration (and interpolation) in units of arcsecs
self._max_interpolate = max_integrate # we chose to set the interpolation range to the integration range
self._min_interpolate = min_integrate # we chose to set the interpolation range to the integration range
if max_light_draw is None:
max_light_draw = max_integrate # make sure the actual solution for the kinematics is only computed way inside the integral
self.lightProfile = LightProfile(light_profile_list,
interpol_grid_num=interpol_grid_num,
max_interpolate=max_integrate,
min_interpolate=min_integrate,
max_draw=max_light_draw)
Anisotropy.__init__(self, anisotropy_type=anisotropy_model)
self.cosmo = Cosmo(**kwargs_cosmo)
self._mass_profile = SinglePlane(mass_profile_list)
self._lum_weight_int_method = lum_weight_int_method
def sigma_s2(self, r, R, kwargs_mass, kwargs_light, kwargs_anisotropy):
"""
returns unweighted los velocity dispersion for a specified 3d and projected radius
(if lum_weight_int_method=True then the 3d radius is not required and the function directly performs the
luminosity weighted integral in projection at R)
:param r: 3d radius (not needed for this calculation)
:param R: 2d projected radius (in angular units of arcsec)
:param kwargs_mass: mass model parameters (following lenstronomy lens model conventions)
:param kwargs_light: deflector light parameters (following lenstronomy light model conventions)
:param kwargs_anisotropy: anisotropy parameters, may vary according to anisotropy type chosen.
We refer to the Anisotropy() class for details on the parameters.
:return: weighted line-of-sight projected velocity dispersion at projected radius R with weights I
"""
if self._lum_weight_int_method is True:
return self.sigma_s2_project(R, kwargs_mass, kwargs_light,
kwargs_anisotropy)
else:
return self.sigma_s2_r(r, R, kwargs_mass, kwargs_light,
kwargs_anisotropy), 1
def sigma_s2_project(self, R, kwargs_mass, kwargs_light,
kwargs_anisotropy):
"""
returns luminosity-weighted los velocity dispersion for a specified projected radius R and weight
:param R: 2d projected radius (in angular units of arcsec)
:param kwargs_mass: mass model parameters (following lenstronomy lens model conventions)
:param kwargs_light: deflector light parameters (following lenstronomy light model conventions)
:param kwargs_anisotropy: anisotropy parameters, may vary according to anisotropy type chosen.
We refer to the Anisotropy() class for details on the parameters.
:return: line-of-sight projected velocity dispersion at projected radius R
"""
# nominator is numerically to a finite distance, so luminosity weighting might be off
# this could lead to an under-prediction of the velocity dispersion
# so we ask the function _I_R_sigma2() to also return the numerical l(r)
# I_R_sigma2, I_R = self._I_R_sigma2_interp(R, kwargs_mass, kwargs_light, kwargs_anisotropy)
I_R_sigma2, I_R = self._I_R_sigma2_interp(R, kwargs_mass, kwargs_light,
kwargs_anisotropy)
# I_R = self.lightProfile.light_2d(R, kwargs_light)
return I_R_sigma2 / I_R, 1
def sigma_s2_r(self, r, R, kwargs_mass, kwargs_light, kwargs_anisotropy):
"""
returns unweighted los velocity dispersion for a specified 3d radius r at projected radius R
:param r: 3d radius (not needed for this calculation)
:param R: 2d projected radius (in angular units of arcsec)
:param kwargs_mass: mass model parameters (following lenstronomy lens model conventions)
:param kwargs_light: deflector light parameters (following lenstronomy light model conventions)
:param kwargs_anisotropy: anisotropy parameters, may vary according to anisotropy type chosen.
We refer to the Anisotropy() class for details on the parameters.
:return: line-of-sight projected velocity dispersion at projected radius R from 3d radius r
"""
beta = self.beta_r(r, **kwargs_anisotropy)
return (1 - beta * R**2 / r**2) * self.sigma_r2(
r, kwargs_mass, kwargs_light, kwargs_anisotropy)
def sigma_r2(self, r, kwargs_mass, kwargs_light, kwargs_anisotropy):
"""
computes numerically the solution of the Jeans equation for a specific 3d radius
E.g. Equation (A1) of Mamon & Lokas https://arxiv.org/pdf/astro-ph/0405491.pdf
.. math::
l(r) \\sigma_r(r) ^ 2 = 1/f(r) \\int_r^{\\infty} f(s) l(s) G M(s) / s^2 ds
where l(r) is the 3d light profile
M(s) is the enclosed 3d mass
f is the solution to
d ln(f)/ d ln(r) = 2 beta(r)
:param r: 3d radius
:param kwargs_mass: mass model parameters (following lenstronomy lens model conventions)
:param kwargs_light: deflector light parameters (following lenstronomy light model conventions)
:param kwargs_anisotropy: anisotropy parameters, may vary according to anisotropy type chosen.
We refer to the Anisotropy() class for details on the parameters.
:return: sigma_r**2
"""
# l_r = self.lightProfile.light_3d_interp(r, kwargs_light)
l_r = self.lightProfile.light_3d(r, kwargs_light)
f_r = self.anisotropy_solution(r, **kwargs_anisotropy)
return 1 / f_r / l_r * self._jeans_solution_integral(
r, kwargs_mass, kwargs_light, kwargs_anisotropy) * const.G / (
const.arcsec * self.cosmo.dd * const.Mpc)
def mass_3d(self, r, kwargs):
"""
mass enclosed a 3d radius
:param r: in arc seconds
:param kwargs: lens model parameters in arc seconds
:return: mass enclosed physical radius in kg
"""
mass_dimless = self._mass_profile.mass_3d(r, kwargs)
mass_dim = mass_dimless * const.arcsec ** 2 * self.cosmo.dd * self.cosmo.ds / self.cosmo.dds * const.Mpc * \
const.c ** 2 / (4 * np.pi * const.G)
return mass_dim
def grav_potential(self, r, kwargs_mass):
"""
Gravitational potential in SI units
:param r: radius (arc seconds)
:param kwargs_mass:
:return: gravitational potential
"""
mass_dim = self.mass_3d(r, kwargs_mass)
grav_pot = -const.G * mass_dim / (r * const.arcsec * self.cosmo.dd *
const.Mpc)
return grav_pot
def draw_light(self, kwargs_light):
"""
:param kwargs_light: keyword argument (list) of the light model
:return: 3d radius (if possible), 2d projected radius, x-projected coordinate, y-projected coordinate
"""
r = self.lightProfile.draw_light_3d(kwargs_light, n=1)[0]
R, x, y = util.project2d_random(r)
return r, R, x, y
def delete_cache(self):
"""
delete interpolation function for a specific mass and light profile as well as for a specific anisotropy model
:return:
"""
if hasattr(self, '_log_mass_3d'):
del self._log_mass_3d
if hasattr(self, '_interp_jeans_integral'):
del self._interp_jeans_integral
if hasattr(self, '_interp_I_R_sigma2'):
del self._interp_I_R_sigma2
self.lightProfile.delete_cache()
self.delete_anisotropy_cache()
def _I_R_sigma2(self, R, kwargs_mass, kwargs_light, kwargs_anisotropy):
"""
equation A15 in Mamon & Lokas 2005 as a logarithmic numerical integral (if option is chosen)
:param R: 2d projected radius (in angular units)
:param kwargs_mass: mass model parameters (following lenstronomy lens model conventions)
:param kwargs_light: deflector light parameters (following lenstronomy light model conventions)
:param kwargs_anisotropy: anisotropy parameters, may vary according to anisotropy type chosen.
We refer to the Anisotropy() class for details on the parameters.
:return: integral of A15 in Mamon&Lokas 2005
"""
R = max(R, self._min_integrate)
max_integrate = self._max_integrate # make sure the integration of the Jeans equation is performed further out than the interpolation
# if False:
# # linear integral near R
# lin_max = min(2 * R_, self._max_interpolate)
# lin_max = min(lin_max, R_+1)
# r_array = np.linspace(start=R, stop=lin_max, num=int(self._interp_grid_num / 2))
# dr = r_array[2] - r_array[1]
# IR_sigma2_ = self._integrand_A15(r_array[1:] - dr/2, R, kwargs_mass, kwargs_light, kwargs_anisotropy)
# IR_sigma2_dr_lin = IR_sigma2_ * dr
# # logarithmic integral for larger extent
# max_log = np.log10(max_integrate)
# r_array = np.logspace(np.log10(lin_max), max_log, int(self._interp_grid_num / 2))
# dlog_r = (np.log10(r_array[2]) - np.log10(r_array[1])) * np.log(10)
# IR_sigma2_ = self._integrand_A15(r_array, R_, kwargs_mass, kwargs_light, kwargs_anisotropy)
# IR_sigma2_dr_log = IR_sigma2_ * dlog_r * r_array
# IR_sigma2_dr = np.append(IR_sigma2_dr_lin, IR_sigma2_dr_log)
if self._log_int is True:
min_log = np.log10(R)
max_log = np.log10(max_integrate)
dlogr = (max_log - min_log) / (self._interp_grid_num - 1)
r_array = np.logspace(min_log + dlogr / 2., max_log + dlogr / 2.,
self._interp_grid_num)
dlog_r = (np.log10(r_array[2]) - np.log10(r_array[1])) * np.log(10)
IR_sigma2_ = self._integrand_A15(r_array, R, kwargs_mass,
kwargs_light, kwargs_anisotropy)
IR_sigma2_dr = IR_sigma2_ * dlog_r * r_array
else:
r_array = np.linspace(start=R,
stop=self._max_interpolate,
num=self._interp_grid_num)
dr = r_array[2] - r_array[1]
IR_sigma2_ = self._integrand_A15(r_array + dr / 2., R, kwargs_mass,
kwargs_light, kwargs_anisotropy)
IR_sigma2_dr = IR_sigma2_ * dr
IR_sigma2 = np.sum(
IR_sigma2_dr) # integral from angle to physical scales
IR = self.lightProfile.light_2d_finite(R, kwargs_light)
return IR_sigma2 * 2 * const.G / (const.arcsec * self.cosmo.dd *
const.Mpc), IR
def _I_R_sigma2_interp(self, R, kwargs_mass, kwargs_light,
kwargs_anisotropy):
"""
equation A15 in Mamon&Lokas 2005 as interpolation in log space
:param R: projected radius
:param kwargs_mass: mass profile keyword arguments
:param kwargs_light: light model keyword arguments
:param kwargs_anisotropy: stellar anisotropy keyword arguments
:return:
"""
R = np.maximum(R, self._min_integrate)
if not hasattr(self, '_interp_I_R_sigma2'):
min_log = np.log10(self._min_integrate)
max_log = np.log10(self._max_integrate)
R_array = np.logspace(
min_log, max_log,
self._interp_grid_num) # self._interp_grid_num
I_R_sigma2_array = []
I_R_array = []
for R_i in R_array:
I_R_sigma2_, IR_ = self._I_R_sigma2(R_i, kwargs_mass,
kwargs_light,
kwargs_anisotropy)
I_R_sigma2_array.append(I_R_sigma2_)
I_R_array.append(IR_)
self._interp_I_R_sigma2 = interp1d(np.log(R_array),
np.array(I_R_sigma2_array),
fill_value="extrapolate")
self._interp_I_R = interp1d(np.log(R_array),
np.array(I_R_array),
fill_value="extrapolate")
return self._interp_I_R_sigma2(np.log(R)), self._interp_I_R(np.log(R))
def _integrand_A15(self, r, R, kwargs_mass, kwargs_light,
kwargs_anisotropy):
"""
integrand of A15 (in log space) in Mamon&Lokas 2005
:param r: 3d radius in arc seconds
:param R: 2d projected radius
:param kwargs_mass: mass model parameters (following lenstronomy lens model conventions)
:param kwargs_light: deflector light parameters (following lenstronomy light model conventions)
:param kwargs_anisotropy: anisotropy parameters, may vary according to anisotropy type chosen.
We refer to the Anisotropy() class for details on the parameters.
:return: integrand
"""
k_r = self.K(r, R, **kwargs_anisotropy)
# l_r = self.lightProfile.light_3d_interp(r, kwargs_light)
# m_r = self._mass_3d_interp(r, kwargs_mass)
l_r = self.lightProfile.light_3d(r, kwargs_light)
m_r = self.mass_3d(r, kwargs_mass)
out = k_r * l_r * m_r / r
return out
def _jeans_solution_integral(self, r, kwargs_mass, kwargs_light,
kwargs_anisotropy):
"""
interpolated solution of the integral
.. math::
\\int_r^{\\infty} f(s) l(s) G M(s) / s^2 ds
:param r: 3d radius
:param kwargs_mass: mass profile keyword arguments
:param kwargs_light: light profile keyword arguments
:param kwargs_anisotropy: anisotropy keyword arguments
:return: interpolated solution of the Jeans integral
(copped values at large radius as they become numerically inaccurate)
"""
if not hasattr(self, '_interp_jeans_integral'):
min_log = np.log10(self._min_integrate)
max_log = np.log10(
self._max_integrate
) # we extend the integral but ignore these outer solutions in the interpolation
r_array = np.logspace(min_log, max_log, self._interp_grid_num)
dlog_r = (np.log10(r_array[2]) - np.log10(r_array[1])) * np.log(10)
integrand_jeans = self._integrand_jeans_solution(
r_array, kwargs_mass, kwargs_light,
kwargs_anisotropy) * dlog_r * r_array
# flip array from inf to finite
integral_jeans_r = np.cumsum(np.flip(integrand_jeans))
# flip array back
integral_jeans_r = np.flip(integral_jeans_r)
# call 1d interpolation function
self._interp_jeans_integral = interp1d(
np.log(r_array[r_array <= self._max_integrate]),
integral_jeans_r[r_array <= self._max_integrate],
fill_value="extrapolate")
return self._interp_jeans_integral(np.log(r))
def _integrand_jeans_solution(self, r, kwargs_mass, kwargs_light,
kwargs_anisotropy):
"""
integrand of A1 (in log space) in Mamon&Lokas 2005 to calculate the Jeans equation numerically
f(s) l(s) M(s) / s^2
:param r: 3d radius
:param kwargs_mass: mass model keyword arguments
:param kwargs_light: light model keyword arguments
:param kwargs_anisotropy: anisotropy model keyword argument
:return: integrand value
"""
f_r = self.anisotropy_solution(r, **kwargs_anisotropy)
l_r = self.lightProfile.light_3d(r, kwargs_light)
m_r = self._mass_3d_interp(r, kwargs_mass)
out = f_r * l_r * m_r / r**2
return out
def _mass_3d_interp(self, r, kwargs, new_compute=False):
"""
:param r: in arc seconds
:param kwargs: lens model parameters in arc seconds
:param new_compute: bool, if True, recomputes the interpolation
:return: mass enclosed physical radius in kg
"""
if not hasattr(self, '_log_mass_3d') or new_compute is True:
r_array = np.logspace(np.log10(self._min_interpolate),
np.log10(self._max_interpolate),
self._interp_grid_num)
mass_3d_array = self.mass_3d(r_array, kwargs)
mass_3d_array[mass_3d_array < 10.**(-100)] = 10.**(-100)
self._log_mass_3d = interp1d(
np.log(r_array),
np.log(mass_3d_array / r_array),
fill_value=(np.log(mass_3d_array[0] / r_array[0]), -1000),
bounds_error=False)
return np.exp(self._log_mass_3d(np.log(r))) * np.minimum(
r, self._max_interpolate)