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
class TestChameleon(object):
"""
class to test the Moffat profile
"""
def setup(self):
self.chameleon = Chameleon()
self.nie = NIE()
def test_theta_E_convert(self):
w_c, w_t = 2, 1
theta_E_convert, w_c, w_t = self.chameleon._theta_convert(alpha_1=1, w_c=w_c, w_t=w_t)
assert w_c == 1
assert w_t == 2
def test_function(self):
"""
:return:
"""
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 = {'alpha_1': 1., 'w_c': .5, 'w_t': 1., 'e1': e1, 'e2': e2}
theta_E_convert, w_c, w_t = self.chameleon._theta_convert(alpha_1=1, w_c=0.5, w_t=1.)
s_scale_1 = np.sqrt(4 * w_c ** 2 / (1. + q) ** 2)
s_scale_2 = np.sqrt(4 * w_t ** 2 / (1. + q) ** 2)
kwargs_1 = {'theta_E': theta_E_convert, 's_scale': s_scale_1, 'e1': e1, 'e2': e2}
kwargs_2 = {'theta_E': theta_E_convert, 's_scale': s_scale_2, 'e1': e1, 'e2': e2}
f_ = self.chameleon.function(x=x, y=1., **kwargs_light)
f_1 = self.nie.function(x=x, y=1., **kwargs_1)
f_2 = self.nie.function(x=x, y=1., **kwargs_2)
npt.assert_almost_equal(f_, (f_1 - f_2), decimal=5)
def test_derivatives(self):
"""
:return:
"""
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 = {'alpha_1': 1., 'w_c': .5, 'w_t': 1., 'e1': e1, 'e2': e2}
theta_E_convert, w_c, w_t = self.chameleon._theta_convert(alpha_1=1, w_c=0.5, w_t=1.)
s_scale_1 = np.sqrt(4 * w_c ** 2 / (1. + q) ** 2)
s_scale_2 = np.sqrt(4 * w_t ** 2 / (1. + q) ** 2)
kwargs_1 = {'theta_E': theta_E_convert, 's_scale': s_scale_1, 'e1': e1, 'e2': e2}
kwargs_2 = {'theta_E': theta_E_convert, 's_scale': s_scale_2, 'e1': e1, 'e2': e2}
f_x, f_y = self.chameleon.derivatives(x=x, y=1., **kwargs_light)
f_x_1, f_y_1 = self.nie.derivatives(x=x, y=1., **kwargs_1)
f_x_2, f_y_2 = self.nie.derivatives(x=x, y=1., **kwargs_2)
npt.assert_almost_equal(f_x, (f_x_1 - f_x_2), decimal=5)
npt.assert_almost_equal(f_y, (f_y_1 - f_y_2), decimal=5)
f_x, f_y = self.chameleon.derivatives(x=1, y=0., **kwargs_light)
npt.assert_almost_equal(f_x, 1, decimal=1)
def test_hessian(self):
"""
:return:
"""
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 = {'alpha_1': 1., 'w_c': .5, 'w_t': 1., 'e1': e1, 'e2': e2}
theta_E_convert, w_c, w_t = self.chameleon._theta_convert(alpha_1=1, w_c=0.5, w_t=1.)
s_scale_1 = np.sqrt(4 * w_c ** 2 / (1. + q) ** 2)
s_scale_2 = np.sqrt(4 * w_t ** 2 / (1. + q) ** 2)
kwargs_1 = {'theta_E': theta_E_convert, 's_scale': s_scale_1, 'e1': e1, 'e2': e2}
kwargs_2 = {'theta_E': theta_E_convert, 's_scale': s_scale_2, 'e1': e1, 'e2': e2}
f_xx, f_yy, f_xy = self.chameleon.hessian(x=x, y=1., **kwargs_light)
f_xx_1, f_yy_1, f_xy_1 = self.nie.hessian(x=x, y=1., **kwargs_1)
f_xx_2, f_yy_2, f_xy_2 = self.nie.hessian(x=x, y=1., **kwargs_2)
npt.assert_almost_equal(f_xx, (f_xx_1 - f_xx_2), decimal=5)
npt.assert_almost_equal(f_yy, (f_yy_1 - f_yy_2), decimal=5)
npt.assert_almost_equal(f_xy, (f_xy_1 - f_xy_2), decimal=5)