def test_lens_model_correspondence(self): """ here we test the proportionality of the convergence of the lens model with the surface brightness of the light model """ chameleon_lens = ChameleonLens() chameleon = Chameleon() x, y = util.make_grid(numPix=100, deltapix=0.1) e1, e2 = 0., 0 w_c, w_t = 0.5, 1. kwargs_light = {'amp': 1., 'w_c': w_c, 'w_t': w_t, 'e1': e1, 'e2': e2} kwargs_lens = { 'alpha_1': 1., 'w_c': w_c, 'w_t': w_t, 'e1': e1, 'e2': e2 } flux = chameleon.function(x=x, y=y, **kwargs_light) f_xx, f_xy, f_yx, f_yy = chameleon_lens.hessian(x=x, y=y, **kwargs_lens) kappa = 1 / 2. * (f_xx + f_yy) # flux2d = util.array2image(flux) # kappa2d = util.array2image(kappa) npt.assert_almost_equal(flux / np.mean(flux), kappa / np.mean(kappa), decimal=3)
def test_hessian(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_lens = {'alpha_1': theta_E, 'ratio': ratio, 'w_c1': .5, 'w_t1': 1., 'e11': e1, 'e21': e2, 'w_c2': .1, 'w_t2': .5, 'e12': e1, 'e22': e2} kwargs_light = {'amp': theta_E, 'ratio': ratio, 'w_c1': .5, 'w_t1': 1., 'e11': e1, 'e21': e2, 'w_c2': .1, 'w_t2': .5, 'e12': e1, 'e22': e2} kwargs_1 = {'alpha_1': theta_E / (1 + 1./ratio), 'w_c': .5, 'w_t': 1., 'e1': e1, 'e2': e2} kwargs_2 = {'alpha_1': theta_E / (1 + ratio), 'w_c': .1, 'w_t': .5, 'e1': e1, 'e2': e2} f_xx, f_yy, f_xy = doublechameleon.hessian(x=x, y=1., **kwargs_lens) f_xx1, f_yy1, f_xy1 = chameleon.hessian(x=x, y=1., **kwargs_1) f_xx2, f_yy2, f_xy2 = chameleon.hessian(x=x, y=1., **kwargs_2) npt.assert_almost_equal(f_xx, f_xx1 + f_xx2, decimal=8) npt.assert_almost_equal(f_yy, f_yy1 + f_yy2, decimal=8) npt.assert_almost_equal(f_xy, f_xy1 + f_xy2, decimal=8) light = DoubleChameleonLight() f_xx, f_yy, f_xy = doublechameleon.hessian(x=np.linspace(0, 1, 10), y=np.zeros(10), **kwargs_lens) kappa = 1./2 * (f_xx + f_yy) kappa_norm = kappa / np.mean(kappa) flux = light.function(x=np.linspace(0, 1, 10), y=np.zeros(10), **kwargs_light) flux_norm = flux / np.mean(flux) npt.assert_almost_equal(kappa_norm, flux_norm, decimal=5)
def test_hessian(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_lens = {'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 } kwargs_light = {'amp': 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} f_xx, f_yy, f_xy = triplechameleon.hessian(x=x, y=1., **kwargs_lens) f_xx1, f_yy1, f_xy1 = chameleon.hessian(x=x, y=1., **kwargs_1) f_xx2, f_yy2, f_xy2 = chameleon.hessian(x=x, y=1., **kwargs_2) f_xx3, f_yy3, f_xy3 = chameleon.hessian(x=x, y=1., **kwargs_3) npt.assert_almost_equal(f_xx, f_xx1 + f_xx2 + f_xx3, decimal=8) npt.assert_almost_equal(f_yy, f_yy1 + f_yy2 + f_yy3, decimal=8) npt.assert_almost_equal(f_xy, f_xy1 + f_xy2 + f_xy3, decimal=8) light = TripleChameleonLight() f_xx, f_yy, f_xy = triplechameleon.hessian(x=np.linspace(0, 1, 10), y=np.zeros(10), **kwargs_lens) kappa = 1./2 * (f_xx + f_yy) kappa_norm = kappa / np.mean(kappa) flux = light.function(x=np.linspace(0, 1, 10), y=np.zeros(10), **kwargs_light) flux_norm = flux / np.mean(flux) npt.assert_almost_equal(kappa_norm, flux_norm, 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 = 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