def test_function(self):
"""
:return:
"""
triplechameleon = TripleChameleon()
chameleon = Chameleon()
x = np.linspace(0.1, 10, 10)
phi_G, q = 0.3, 0.8
ratio12 = 2.
ratio13 = 3
e1, e2 = param_util.phi_q2_ellipticity(phi_G, q)
kwargs_light = {'alpha_1': 1., 'ratio12': ratio12, 'ratio13': ratio13, 'w_c1': .5, 'w_t1': 1., 'e11': e1, 'e21': e2,
'w_c2': .1, 'w_t2': .5, 'e12': e1, 'e22': e2,
'w_c3': .1, 'w_t3': .5, 'e13': e1, 'e23': e2
}
amp1 = 1. / (1. + 1. / ratio12 + 1. / ratio13)
amp2 = amp1 / ratio12
amp3 = amp1 / ratio13
kwargs_1 = {'alpha_1': amp1, 'w_c': .5, 'w_t': 1., 'e1': e1, 'e2': e2}
kwargs_2 = {'alpha_1': amp2, 'w_c': .1, 'w_t': .5, 'e1': e1, 'e2': e2}
kwargs_3 = {'alpha_1': amp3, 'w_c': .1, 'w_t': .5, 'e1': e1, 'e2': e2}
flux = triplechameleon.function(x=x, y=1., **kwargs_light)
flux1 = chameleon.function(x=x, y=1., **kwargs_1)
flux2 = chameleon.function(x=x, y=1., **kwargs_2)
flux3 = chameleon.function(x=x, y=1., **kwargs_3)
npt.assert_almost_equal(flux, flux1 + flux2 + flux3, decimal=8)
def test_function(self):
"""
:return:
"""
doublechameleon = DoubleChameleon()
chameleon = Chameleon()
x = np.linspace(0.1, 10, 10)
phi_G, q = 0.3, 0.8
theta_E = 1.
ratio = 2.
e1, e2 = param_util.phi_q2_ellipticity(phi_G, q)
kwargs_light = {
'theta_E': 1.,
'ratio': 2,
'w_c1': .5,
'w_t1': 1.,
'e11': e1,
'e21': e2,
'w_c2': .1,
'w_t2': .5,
'e12': e1,
'e22': e2
}
kwargs_1 = {
'theta_E': theta_E / (1 + 1. / ratio),
'w_c': .5,
'w_t': 1.,
'e1': e1,
'e2': e2
}
kwargs_2 = {
'theta_E': theta_E / (1 + ratio),
'w_c': .1,
'w_t': .5,
'e1': e1,
'e2': e2
}
flux = doublechameleon.function(x=x, y=1., **kwargs_light)
flux1 = chameleon.function(x=x, y=1., **kwargs_1)
flux2 = chameleon.function(x=x, y=1., **kwargs_2)
npt.assert_almost_equal(flux, flux1 + flux2, decimal=8)
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_E_convert(theta_E=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 = {
'theta_E': 1.,
'w_c': .5,
'w_t': 1.,
'e1': e1,
'e2': e2
}
theta_E_convert, w_c, w_t = self.chameleon._theta_E_convert(theta_E=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 = {
'theta_E': 1.,
'w_c': .5,
'w_t': 1.,
'e1': e1,
'e2': e2
}
theta_E_convert, w_c, w_t = self.chameleon._theta_E_convert(theta_E=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 = {
'theta_E': 1.,
'w_c': .5,
'w_t': 1.,
'e1': e1,
'e2': e2
}
theta_E_convert, w_c, w_t = self.chameleon._theta_E_convert(theta_E=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)
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, s_scale_1, s_scale_2 = self.chameleon.param_convert(
alpha_1=1, w_c=w_c, w_t=w_t, e1=0, e2=0)
assert w_c == 1
assert w_t == 2
assert theta_E_convert == 0
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, s_scale_1, s_scale_2 = self.chameleon.param_convert(
alpha_1=1, w_c=0.5, w_t=1., e1=e1, e2=e2)
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, s_scale_1, s_scale_2 = self.chameleon.param_convert(
alpha_1=1, w_c=0.5, w_t=1., e1=e1, e2=e2)
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, s_scale_1, s_scale_2 = self.chameleon.param_convert(
alpha_1=1, w_c=0.5, w_t=1., e1=e1, e2=e2)
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_xy, f_yx, f_yy = self.chameleon.hessian(x=x,
y=1.,
**kwargs_light)
f_xx_1, f_xy_1, f_yx_1, f_yy_1 = self.nie.hessian(x=x,
y=1.,
**kwargs_1)
f_xx_2, f_xy_2, f_yx_2, f_yy_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)
npt.assert_almost_equal(f_yx, (f_yx_1 - f_yx_2), decimal=5)
def test_static(self):
x, y = 1., 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
}
f_ = self.chameleon.function(x, y, **kwargs_light)
self.chameleon.set_static(**kwargs_light)
f_static = self.chameleon.function(x, y, **kwargs_light)
npt.assert_almost_equal(f_, f_static, decimal=8)
self.chameleon.set_dynamic()
kwargs_light = {
'alpha_1': 2.,
'w_c': .5,
'w_t': 1.,
'e1': e1,
'e2': e2
}
f_dyn = self.chameleon.function(x, y, **kwargs_light)
assert f_dyn != f_static