Source code for lenstronomy.LensModel.Profiles.splcore

__author__ = 'dangilman'

import numpy as np
from lenstronomy.LensModel.Profiles.base_profile import LensProfileBase
from scipy.special import hyp2f1
from scipy.special import gamma as gamma_func

__all__ = ['SPLCORE']


[docs]class SPLCORE(LensProfileBase): """ This lens profile corresponds to a spherical power law (SPL) mass distribution with logarithmic slope gamma and a 3D core radius r_core .. math:: \rho\left(r, \rho_0, r_c, \gamma\right) = \rho_0 \frac{{r_c}^\gamma}{\left(r^2 + r_c^2\right)^{\frac{\gamma}{2}}} The difference between this and EPL is that this model contains a core radius, is circular, and is also defined for gamma=3. With respect to SPEMD, this model is different in that it is also defined for gamma = 3, is circular, and is defined in terms of a physical density parameter rho0, or the central density at r=0 divided by the critical density for lensing such that rho0 has units 1/arcsec. This class is defined for all gamma > 1 """ param_names = ['sigma0', 'center_x', 'center_y', 'r_core', 'gamma'] lower_limit_default = {'sigma0': 0, 'center_x': -100, 'center_y': -100, 'r_core': 1e-6, 'gamma': 1.+1e-6} upper_limit_default = {'sigma0': 1e+12, 'center_x': 100, 'center_y': 100, 'r_core': 100, 'gamma': 5.}
[docs] def function(self, x, y, sigma0, r_core, gamma, center_x=0, center_y=0): raise Exception('potential not implemented for this class')
[docs] def derivatives(self, x, y, sigma0, r_core, gamma, center_x=0, center_y=0): """ :param x: projected x position at which to evaluate function [arcsec] :param y: projected y position at which to evaluate function [arcsec] :param sigma0: convergence at r = 0 :param r_core: core radius [arcsec] :param gamma: logarithmic slope at r -> infinity :param center_x: x coordinate center of lens model [arcsec] :param center_y: y coordinate center of lens model [arcsec] :return: deflection angle alpha in x and y directions """ x_ = x - center_x y_ = y - center_y r = np.hypot(x_, y_) r = self._safe_r_division(r, r_core) alpha_r = self.alpha(r, sigma0, r_core, gamma) cos = x_/r sin = y_/r return alpha_r * cos, alpha_r * sin
[docs] def hessian(self, x, y, sigma0, r_core, gamma, center_x=0, center_y=0): """ :param x: projected x position at which to evaluate function [arcsec] :param y: projected y position at which to evaluate function [arcsec] :param sigma0: convergence at r = 0 :param r_core: core radius [arcsec] :param gamma: logarithmic slope at r -> infinity :param center_x: x coordinate center of lens model [arcsec] :param center_y: y coordinate center of lens model [arcsec] :return: hessian elements alpha_(x/y) = alpha_r * cos/sin(x/y / r) """ x_ = x - center_x y_ = y - center_y r = np.hypot(x_, y_) m2d = self.mass_2d_lens(r, sigma0, r_core, gamma) / np.pi r = self._safe_r_division(r, r_core) rho0 = self._sigma2rho0(sigma0, r_core) kappa = self.density_2d(x_, y_, rho0, r_core, gamma) gamma_tot = m2d / r ** 2 - kappa sin_2phi = -2*x_*y_/r**2 cos_2phi = (y_**2 - x_**2)/r**2 gamma1 = cos_2phi * gamma_tot gamma2 = sin_2phi * gamma_tot f_xx = kappa + gamma1 f_yy = kappa - gamma1 f_xy = gamma2 return f_xx, f_xy, f_xy, f_yy
[docs] def alpha(self, r, sigma0, r_core, gamma): """ Returns the deflection angle at r :param r: radius [arcsec] :param sigma0: convergence at r=0 :param r_core: core radius [arcsec] :param gamma: logarithmic slope at r -> infinity :return: deflection angle at r """ mass2d = self.mass_2d_lens(r, sigma0, r_core, gamma) return mass2d / r / np.pi
[docs] def density(self, r, rho0, r_core, gamma): """ Returns the 3D density at r :param r: radius [arcsec] :param sigma0: convergence at r=0 :param r_core: core radius [arcsec] :param gamma: logarithmic slope at r -> infinity :return: density at r """ return rho0 * r_core ** gamma / (r_core**2 + r**2) ** (gamma/2)
[docs] def density_lens(self, r, sigma0, r_core, gamma): """ Returns the 3D density at r :param r: radius [arcsec] :param sigma0: convergence at r=0 :param r_core: core radius [arcsec] :param gamma: logarithmic slope at r -> infinity :return: density at r """ rho0 = self._sigma2rho0(sigma0, r_core) return rho0 * r_core ** gamma / (r_core**2 + r**2) ** (gamma/2)
def _density_2d_r(self, r, rho0, r_core, gamma): """ Returns the convergence at radius r after applying _safe_r_division :param r: position [arcsec] :param sigma0: convergence at r=0 :param r_core: core radius [arcsec] :param gamma: logarithmic slope at r -> infinity :return: convergence at r """ sigma0 = self._rho02sigma(rho0, r_core) if gamma == 3: return 2 * r_core ** 2 * sigma0 / (r ** 2 + r_core ** 2) elif gamma == 2: return np.pi * r_core * sigma0 / (r_core ** 2 + r ** 2) ** 0.5 else: x = r / r_core exponent = (1 - gamma) / 2 return sigma0 * np.sqrt(np.pi) * gamma_func(0.5 * (gamma - 1)) / gamma_func(0.5 * gamma) * ( 1 + x ** 2) ** exponent
[docs] def density_2d(self, x, y, rho0, r_core, gamma): """ Returns the convergence at radius r :param x: x position [arcsec] :param y: y position [arcsec] :param sigma0: convergence at r=0 :param r_core: core radius [arcsec] :param gamma: logarithmic slope at r -> infinity :return: convergence at r """ r = np.hypot(x, y) r = self._safe_r_division(r, r_core) return self._density_2d_r(r, rho0, r_core, gamma)
[docs] def mass_3d(self, r, rho0, r_core, gamma): """ mass enclosed a 3d sphere or radius r :param r: radius [arcsec] :param rho0: density at r = 0 in units [rho_0_physical / sigma_crit] (which should be equal to [arcsec]) where rho_0_physical is a physical density normalization and sigma_crit is the critical density for lensing :param r_core: core radius [arcsec] :param gamma: logarithmic slope at r -> infinity :return: mass inside radius r """ return 4 * np.pi * r_core ** 3 * rho0 * self._g(r/r_core, gamma)
[docs] def mass_3d_lens(self, r, sigma0, r_core, gamma): """ mass enclosed a 3d sphere or radius r :param r: radius [arcsec] :param sigma0: convergence at r = 0 :param r_core: core radius [arcsec] :param gamma: logarithmic slope at r -> infinity :return: mass inside radius r """ rho0 = self._sigma2rho0(sigma0, r_core) return self.mass_3d(r, rho0, r_core, gamma)
[docs] def mass_2d(self, r, rho0, r_core, gamma): """ mass enclosed projected 2d disk of radius r :param r: radius [arcsec] :param rho0: density at r = 0 in units [rho_0_physical / sigma_crit] (which should be equal to [1/arcsec]) where rho_0_physical is a physical density normalization and sigma_crit is the critical density for lensing :param r_core: core radius [arcsec] :param gamma: logarithmic slope at r -> infinity :return: projected mass inside disk of radius r """ return 4 * np.pi * r_core ** 3 * rho0 * self._f(r/r_core, gamma)
[docs] def mass_2d_lens(self, r, sigma0, r_core, gamma): """ mass enclosed projected 2d disk of radius r :param r: radius [arcsec] :param sigma0: convergence at r = 0 where rho_0_physical is a physical density normalization and sigma_crit is the critical density for lensing :param r_core: core radius [arcsec] :param gamma: logarithmic slope at r -> infinity :return: projected mass inside disk of radius r """ rho0 = self._sigma2rho0(sigma0, r_core) return self.mass_2d(r, rho0, r_core, gamma)
@staticmethod def _safe_r_division(r, r_core, x_min=1e-6): """ Avoids accidental division by 0 :param r: radius in arcsec :param r_core: core radius in arcsec :return: a minimum value of r """ if isinstance(r, float) or isinstance(r, int): r = max(x_min * r_core, r) else: r[np.where(r < x_min * r_core)] = x_min * r_core return r @staticmethod def _sigma2rho0(sigma0, r_core): """ Converts the convergence normalization to the 3d normalization :param sigma0: convergence at r=0 :param r_core: core radius [arcsec] :return: density normalization in units 1/arcsec, or rho_0_physical / sigma_crit """ return sigma0 / r_core @staticmethod def _rho02sigma(rho0, r_core): """ Converts the convergence normalization to the 3d normalization :param sigma0: convergence at r=0 :param r_core: core radius [arcsec] :return: density normalization in units 1/arcsec, or rho_0_physical / sigma_crit """ return rho0 * r_core @staticmethod def _f(x, gamma): """ Returns the solution of the 2D mass integral defined such that .. math:: m_{\rm{2D}}\left(R\right) = 4 \pi r_{\rm{core}}^3 \rho_0 F\left(\frac{R}{r_{\rm{core}}}, \gamma\right) :param x: dimensionaless radius r/r_core :param gamma: logarithmic slope at r -> infinity :return: a number """ if gamma == 3: return 0.5 * np.log(x ** 2 + 1) elif gamma == 2: return np.pi/2 * ((x**2 + 1)**0.5 - 1) else: gamma_func_term = gamma_func(0.5 * (gamma - 1)) / gamma_func(0.5 * gamma) prefactor = np.sqrt(np.pi) * gamma_func_term / (2 * (gamma - 3)) term = (1 - (1 + x ** 2) ** ((3 - gamma) / 2)) return prefactor * term @staticmethod def _g(x, gamma): """ Returns the solution of the 3D mass integral defined such that Returns the solution of the 2D mass integral defined such that .. math:: m_{\rm{3D}}\left(R\right) = 4 \pi r_{\rm{core}}^3 \rho_0 G\left(\frac{R}{r_{\rm{core}}}, \gamma\right) :param x: dimensionaless radius r/r_core :param gamma: logarithmic slope at r -> infinity :return: a number """ if gamma == 3: return np.arcsinh(x) - x / (1 + x ** 2) ** 0.5 elif gamma == 2: return x - np.arctan(x) else: prefactor = 1 / ((gamma - 3) * (gamma - 1)) / x term = hyp2f1(-0.5, gamma / 2, 0.5, -x ** 2) - (1 + x ** 2) ** ((2 - gamma) / 2) * ( 1 + x ** 2 * (gamma - 1)) return prefactor * term