class Chameleon(object):
"""
class of the Chameleon model (See Suyu+2014) an elliptical truncated double isothermal profile
"""
param_names = ['amp', 'w_c', 'w_t', 'e1', 'e2', 'center_x', 'center_y']
lower_limit_default = {
'amp': 0,
'w_c': 0,
'w_t': 0,
'e1': -0.5,
'e2': -0.5,
'center_x': -100,
'center_y': -100
}
upper_limit_default = {
'amp': 100,
'w_c': 100,
'w_t': 100,
'e1': 0.5,
'e2': 0.5,
'center_x': 100,
'center_y': 100
}
def __init__(self):
self.nie = NIE()
self._chameleonLens = ChameleonLens()
def function(self, x, y, amp, w_c, w_t, e1, e2, center_x=0, center_y=0):
"""
:param x: ra-coordinate
:param y: dec-coordinate
:param amp: amplitude of first power-law flux
:param flux_ratio: ratio of amplitudes of first to second power-law profile
:param gamma1: power-law slope
:param gamma2: power-law slope
:param e1: ellipticity parameter
:param e2: ellipticity parameter
:param center_x: center
:param center_y: center
:return: flux of chameleon profile
"""
amp_new, w_c, w_t = self._chameleonLens._theta_convert(amp, w_c, w_t)
phi_G, q = param_util.ellipticity2phi_q(e1, e2)
s_scale_1 = np.sqrt(4 * w_c**2 / (1. + q)**2)
s_scale_2 = np.sqrt(4 * w_t**2 / (1. + q)**2)
flux1 = self.nie.function(x, y, 1, e1, e2, s_scale_1, center_x,
center_y)
flux2 = self.nie.function(x, y, 1, e1, e2, s_scale_2, center_x,
center_y)
flux = amp_new / (1. + q) * (flux1 - flux2)
return flux
def test_convergence2surface_brightness(self):
from lenstronomy.LightModel.Profiles.nie import NIE as NIE_Light
nie_light = NIE_Light()
kwargs = {'e1': 0.3, 'e2': -0.05, 's_scale': 0.5}
x, y = util.make_grid(numPix=10, deltapix=0.1)
f_xx, f_yy, f_xy = self.nie.hessian(x, y, theta_E=1, **kwargs)
kappa = 1/2. * (f_xx + f_yy)
flux = nie_light.function(x, y, amp=1, **kwargs)
npt.assert_almost_equal(kappa/np.sum(kappa), flux/np.sum(flux), decimal=5)
class Chameleon(object):
"""
class of the Chameleon model (See Dutton+ 2011, Suyu+2014) an elliptical truncated double isothermal profile
"""
param_names = ['amp', 'w_c', 'w_t', 'e1', 'e2', 'center_x', 'center_y']
lower_limit_default = {'amp': 0, 'w_c': 0, 'w_t': 0, 'e1': -0.5, 'e2': -0.5, 'center_x': -100, 'center_y': -100}
upper_limit_default = {'amp': 100, 'w_c': 100, 'w_t': 100, 'e1': 0.5, 'e2': 0.5, 'center_x': 100, 'center_y': 100}
def __init__(self):
self.nie = NIE()
self._chameleonLens = ChameleonLens()
def function(self, x, y, amp, w_c, w_t, e1, e2, center_x=0, center_y=0):
"""
:param x: ra-coordinate
:param y: dec-coordinate
:param w_c:
:param w_t:
:param amp: amplitude of first power-law flux
:param e1: eccentricity parameter
:param e2: eccentricity parameter
:param center_x: center
:param center_y: center
:return: flux of chameleon profile
"""
amp_new, w_c, w_t, s_scale_1, s_scale_2 = self._chameleonLens.param_convert(amp, w_c, w_t, e1, e2)
flux1 = self.nie.function(x, y, 1, e1, e2, s_scale_1, center_x, center_y)
flux2 = self.nie.function(x, y, 1, e1, e2, s_scale_2, center_x, center_y)
flux = amp_new * (flux1 - flux2)
return flux
def light_3d(self, r, amp, w_c, w_t, e1, e2, center_x=0, center_y=0):
"""
:param r: 3d radius
:param w_c:
:param w_t:
:param amp: amplitude of first power-law flux
:param e1: eccentricity parameter
:param e2: eccentricity parameter
:param center_x: center
:param center_y: center
:return: 3d flux of chameleon profile at radius r
"""
amp_new, w_c, w_t, s_scale_1, s_scale_2 = self._chameleonLens.param_convert(amp, w_c, w_t, e1, e2)
flux1 = self.nie.light_3d(r, 1, e1, e2, s_scale_1, center_x, center_y)
flux2 = self.nie.light_3d(r, 1, e1, e2, s_scale_2, center_x, center_y)
flux = amp_new * (flux1 - flux2)
return flux
def test_function(self):
"""
:return:
"""
lens = NIE_lens()
light = NIE_light()
x = np.linspace(0.1, 10, 10)
e1, e2 = 0.1, 0
s = 0.2
kwargs_light = {'amp': 1., 'e1': e1, 'e2': e2, 's_scale': s}
kwargs_lens = {'theta_E': 1., 'e1': e1, 'e2': e2, 's_scale': s}
flux = light.function(x=x, y=1., **kwargs_light)
f_xx, f_yy, f_xy = lens.hessian(x=x, y=1., **kwargs_lens)
kappa = 1/2. * (f_xx + f_yy)
npt.assert_almost_equal(flux/flux[-1], kappa/kappa[-1], decimal=4)
def test_function(self):
"""
:return:
"""
chameleon = Chameleon()
nie = NIE()
x = np.linspace(0.1, 10, 10)
w_c, w_t = 0.5, 1.
phi_G, q = 0.3, 0.8
e1, e2 = param_util.phi_q2_ellipticity(phi_G, q)
kwargs_light = {'amp': 1., 'w_c': .5, 'w_t': 1., 'e1': e1, 'e2': e2}
amp_new, w_c, w_t, s_scale_1, s_scale_2 = chameleon._chameleonLens.param_convert(
1, w_c, w_t, e1, e2)
kwargs_1 = {'amp': amp_new, 's_scale': s_scale_1, 'e1': e1, 'e2': e2}
kwargs_2 = {'amp': amp_new, 's_scale': s_scale_2, 'e1': e1, 'e2': e2}
flux = chameleon.function(x=x, y=1., **kwargs_light)
flux1 = nie.function(x=x, y=1., **kwargs_1)
flux2 = nie.function(x=x, y=1., **kwargs_2)
npt.assert_almost_equal(flux, (flux1 - flux2) / (1. + q), decimal=5)
