def test_nfw_sersic(self): kwargs_lens_nfw = {'alpha_Rs': 1.4129647849966354, 'Rs': 7.0991113634274736} kwargs_lens_sersic = {'k_eff': 0.24100561407593576, 'n_sersic': 1.8058507329346063, 'R_sersic': 1.0371803141813705} from lenstronomy.LensModel.Profiles.nfw import NFW from lenstronomy.LensModel.Profiles.sersic import Sersic nfw = NFW() sersic = Sersic() theta_E = 1.5 n_comp = 10 rs = np.logspace(-2., 1., 100) * theta_E f_xx_nfw, f_xy_nfw, f_yx_nfw, f_yy_nfw = nfw.hessian(rs, 0, **kwargs_lens_nfw) f_xx_s, f_xy_s, f_yx_s, f_yy_s = sersic.hessian(rs, 0, **kwargs_lens_sersic) kappa = 1 / 2. * (f_xx_nfw + f_xx_s + f_yy_nfw + f_yy_s) amplitudes, sigmas, norm = mge.mge_1d(rs, kappa, N=n_comp) kappa_mge = self.multiGaussian.function(rs, np.zeros_like(rs), amp=amplitudes, sigma=sigmas) from lenstronomy.LensModel.Profiles.multi_gaussian_kappa import MultiGaussianKappa mge_kappa = MultiGaussianKappa() f_xx_mge, f_xy_mge, f_yx_mge, f_yy_mge = mge_kappa.hessian(rs, np.zeros_like(rs), amp=amplitudes, sigma=sigmas) for i in range(0, 80): npt.assert_almost_equal(kappa_mge[i], 1. / 2 * (f_xx_mge[i] + f_yy_mge[i]), decimal=1) npt.assert_almost_equal((kappa[i] - kappa_mge[i]) / kappa[i], 0, decimal=1) f_nfw = nfw.function(theta_E, 0, **kwargs_lens_nfw) f_s = sersic.function(theta_E, 0, **kwargs_lens_sersic) f_mge = mge_kappa.function(theta_E, 0, sigma=sigmas, amp=amplitudes) npt.assert_almost_equal(f_mge / (f_nfw + f_s), 1, decimal=2)
def setup(self): self.sersic = Sersic(smoothing=0.02) self.sersic_elliptic = Sersic_elliptic(smoothing=0.02) self.double_sersic = DoubleSersic(smoothing=0.02) self.core_sersic = CoreSersic(smoothing=0.02) self.double_core_sersic = DoubleCoreSersic(smoothing=0.02) self.buldge_disk = BuldgeDisk(smoothing=0.02)
def __init__(self, light_model_list, smoothing=0.0000001): self.profile_type_list = light_model_list self.func_list = [] for profile_type in light_model_list: valid = True if profile_type == 'GAUSSIAN': from lenstronomy.LightModel.Profiles.gaussian import Gaussian self.func_list.append(Gaussian()) elif profile_type == 'GAUSSIAN_ELLIPSE': from lenstronomy.LightModel.Profiles.gaussian import GaussianEllipse self.func_list.append(GaussianEllipse()) elif profile_type == 'MULTI_GAUSSIAN': from lenstronomy.LightModel.Profiles.gaussian import MultiGaussian self.func_list.append(MultiGaussian()) elif profile_type == 'MULTI_GAUSSIAN_ELLIPSE': from lenstronomy.LightModel.Profiles.gaussian import MultiGaussianEllipse self.func_list.append(MultiGaussianEllipse()) elif profile_type == 'SERSIC': from lenstronomy.LightModel.Profiles.sersic import Sersic self.func_list.append(Sersic(smoothing=smoothing)) elif profile_type == 'SERSIC_ELLIPSE': from lenstronomy.LightModel.Profiles.sersic import Sersic_elliptic self.func_list.append(Sersic_elliptic(smoothing=smoothing)) elif profile_type == 'CORE_SERSIC': from lenstronomy.LightModel.Profiles.sersic import CoreSersic self.func_list.append(CoreSersic(smoothing=smoothing)) elif profile_type == 'SHAPELETS': from lenstronomy.LightModel.Profiles.shapelets import ShapeletSet self.func_list.append(ShapeletSet()) elif profile_type == 'HERNQUIST': from lenstronomy.LightModel.Profiles.hernquist import Hernquist self.func_list.append(Hernquist()) elif profile_type == 'HERNQUIST_ELLIPSE': from lenstronomy.LightModel.Profiles.hernquist import Hernquist_Ellipse self.func_list.append(Hernquist_Ellipse()) elif profile_type == 'PJAFFE': from lenstronomy.LightModel.Profiles.p_jaffe import PJaffe self.func_list.append(PJaffe()) elif profile_type == 'PJAFFE_ELLIPSE': from lenstronomy.LightModel.Profiles.p_jaffe import PJaffe_Ellipse self.func_list.append(PJaffe_Ellipse()) elif profile_type == 'UNIFORM': from lenstronomy.LightModel.Profiles.uniform import Uniform self.func_list.append(Uniform()) elif profile_type == 'POWER_LAW': from lenstronomy.LightModel.Profiles.power_law import PowerLaw self.func_list.append(PowerLaw()) elif profile_type == 'NIE': from lenstronomy.LightModel.Profiles.nie import NIE self.func_list.append(NIE()) elif profile_type == 'CHAMELEON': from lenstronomy.LightModel.Profiles.chameleon import Chameleon self.func_list.append(Chameleon()) elif profile_type == 'DOUBLE_CHAMELEON': from lenstronomy.LightModel.Profiles.chameleon import DoubleChameleon self.func_list.append(DoubleChameleon()) else: raise ValueError('Warning! No light model of type', profile_type, ' found!')
class TestSersic(object): """ tests the Gaussian methods """ def setup(self): self.sersic = Sersic(smoothing=0.02) self.sersic_elliptic = Sersic_elliptic(smoothing=0.02) self.double_sersic = DoubleSersic(smoothing=0.02) self.core_sersic = CoreSersic(smoothing=0.02) self.double_core_sersic = DoubleCoreSersic(smoothing=0.02) self.buldge_disk = BuldgeDisk(smoothing=0.02) def test_sersic(self): x = np.array([1]) y = np.array([2]) I0_sersic = 1 R_sersic = 1 n_sersic = 1 center_x = 0 center_y = 0 values = self.sersic.function(x, y, I0_sersic, R_sersic, n_sersic, center_x, center_y) npt.assert_almost_equal(values[0], 0.12658651833626802, decimal=6) x = np.array([0]) y = np.array([0]) values = self.sersic.function( x, y, I0_sersic, R_sersic, n_sersic, center_x, center_y) npt.assert_almost_equal(values[0], 5.1482559148107292, decimal=2) x = np.array([2,3,4]) y = np.array([1,1,1]) values = self.sersic.function( x, y, I0_sersic, R_sersic, n_sersic, center_x, center_y) npt.assert_almost_equal(values[0], 0.12658651833626802, decimal=6) npt.assert_almost_equal(values[1], 0.026902273598180083, decimal=6) npt.assert_almost_equal(values[2], 0.0053957432862338055, decimal=6) def test_symmetry_r_sersic(self): x = np.array([2,3,4]) y = np.array([1,1,1]) I0_sersic = 1 R_sersic1 = 1 R_sersic2 = 0.1 n_sersic = 1 center_x = 0 center_y = 0 values1 = self.sersic.function(x*R_sersic1, y*R_sersic1, I0_sersic, R_sersic1, n_sersic, center_x, center_y) values2 = self.sersic.function(x*R_sersic2, y*R_sersic2, I0_sersic, R_sersic2, n_sersic, center_x, center_y) npt.assert_almost_equal(values1[0], values2[0], decimal=6) npt.assert_almost_equal(values1[1], values2[1], decimal=6) npt.assert_almost_equal(values1[2], values2[2], decimal=6) def test_sersic_center(self): x = 0.01 y = 0. I0_sersic = 1 R_sersic = 0.1 n_sersic = 4. center_x = 0 center_y = 0 values = self.sersic.function(x, y, I0_sersic, R_sersic, n_sersic, center_x, center_y) npt.assert_almost_equal(values, 12.688073819377406, decimal=6) def test_sersic_elliptic(self): x = np.array([1]) y = np.array([2]) I0_sersic = 1 R_sersic = 1 n_sersic = 1 phi_G = 1 q = 0.9 center_x = 0 center_y = 0 values = self.sersic_elliptic.function(x, y, I0_sersic, R_sersic, n_sersic, phi_G, q, center_x, center_y) npt.assert_almost_equal(values[0], 0.12595366113005077, decimal=6) x = np.array([0]) y = np.array([0]) values = self.sersic_elliptic.function(x, y, I0_sersic, R_sersic, n_sersic, phi_G, q, center_x, center_y) npt.assert_almost_equal(values[0], 5.1482553482055664, decimal=2) x = np.array([2,3,4]) y = np.array([1,1,1]) values = self.sersic_elliptic.function(x, y, I0_sersic, R_sersic, n_sersic, phi_G, q, center_x, center_y) npt.assert_almost_equal(values[0], 0.11308277793465012, decimal=6) npt.assert_almost_equal(values[1], 0.021188620675507107, decimal=6) npt.assert_almost_equal(values[2], 0.0037276744362724477, decimal=6) def test_core_sersic(self): x = np.array([1]) y = np.array([2]) I0 = 1 Rb = 1 Re = 2 gamma = 3 n = 1 phi_G = 1 q = 0.9 center_x = 0 center_y = 0 values = self.core_sersic.function(x, y, I0, Rb, Re, n, gamma, phi_G, q, center_x, center_y) npt.assert_almost_equal(values[0], 0.84489101, decimal=8) x = np.array([0]) y = np.array([0]) values = self.core_sersic.function(x, y, I0, Rb, Re, n, gamma, phi_G, q, center_x, center_y) npt.assert_almost_equal(values[0], 288406.09, decimal=0) x = np.array([2,3,4]) y = np.array([1,1,1]) values = self.core_sersic.function(x, y, I0, Rb, Re, n, gamma, phi_G, q, center_x, center_y) npt.assert_almost_equal(values[0], 0.79749529635325933, decimal=6) npt.assert_almost_equal(values[1], 0.33653478121594838, decimal=6) npt.assert_almost_equal(values[2], 0.14050402887681532, decimal=6) def test_double_sersic(self): x = np.array([1]) y = np.array([2]) I0_sersic = 1 R_sersic = 1 n_sersic = 1 phi_G = 1 q = 0.9 I0_2 = 0.1 R_2 = 2 n_2 = 2 phi_G_2 = 1 q_2 = 1 center_x = 0 center_y = 0 values = self.double_sersic.function(x, y, I0_sersic, R_sersic, n_sersic, phi_G, q, I0_2, R_2, n_2, phi_G_2, q_2, center_x, center_y) npt.assert_almost_equal(values[0], 0.20696126663199443, decimal=8) x = np.array([0]) y = np.array([0]) values = self.double_sersic.function(x, y, I0_sersic, R_sersic, n_sersic, phi_G, q, I0_2, R_2, n_2, phi_G_2, q_2, center_x, center_y) npt.assert_almost_equal(values[0], 7.8708484172821045, decimal=8) x = np.array([2,3,4]) y = np.array([1,1,1]) values = self.double_sersic.function(x, y, I0_sersic, R_sersic, n_sersic, phi_G, q, I0_2, R_2, n_2, phi_G_2, q_2, center_x, center_y) npt.assert_almost_equal(values[0], 0.19409037374964733, decimal=8) npt.assert_almost_equal(values[1], 0.060052096255106595, decimal=8) npt.assert_almost_equal(values[2], 0.023917479151437715, decimal=8) def test_double_sersic_function_split(self): x = np.array([1]) y = np.array([2]) I0_sersic = 1 R_sersic = 1 n_sersic = 1 phi_G = 1 q = 0.9 I0_2 = 0.1 R_2 = 2 n_2 = 2 phi_G_2 = 1 q_2 = 1 center_x = 0 center_y = 0 func_1, func_2 = self.double_sersic.function_split(x, y, I0_sersic, R_sersic, n_sersic, phi_G, q, I0_2, R_2, n_2, phi_G_2, q_2, center_x, center_y) npt.assert_almost_equal(func_1[0], 0.12595365941524506) npt.assert_almost_equal(func_2[0], 0.081007614731788635) def test_double_core_sersic(self): x = np.array([1]) y = np.array([2]) I0_sersic = 1 R_sersic = 1 n_sersic = 1 phi_G = 1 q = 0.9 I0_2 = 0.1 R_2 = 2 n_2 = 2 Re = 0.1 gamma = 2 values = self.double_core_sersic.function(x, y, I0_sersic, Re, R_sersic, n_sersic, gamma, phi_G, q, I0_2, R_2, n_2, phi_G_2=0, q_2=1, center_x=0, center_y=0) npt.assert_almost_equal(values[0], 0.20695476233959198, decimal=5) x = np.array([0]) y = np.array([0]) values = self.double_core_sersic.function(x, y, I0_sersic, Re, R_sersic, n_sersic, gamma, phi_G, q, I0_2, R_2, n_2, phi_G_2=0, q_2=1, center_x=0, center_y=0) npt.assert_almost_equal(values[0], 115.86341203723811, decimal=5) x = np.array([2,3,4]) y = np.array([1,1,1]) values = self.double_core_sersic.function(x, y, I0_sersic, Re, R_sersic, n_sersic, gamma, phi_G, q, I0_2, R_2, n_2, phi_G_2=0, q_2=1, center_x=0, center_y=0) npt.assert_almost_equal(values[0], 0.19408468241596671, decimal=5) npt.assert_almost_equal(values[1], 0.060051398351788521, decimal=5) npt.assert_almost_equal(values[2], 0.023917404236271977, decimal=5) def test_double_core_sersic_function_split(self): x = np.array([1]) y = np.array([2]) I0_sersic = 1 R_sersic = 1 n_sersic = 1 phi_G = 1 q = 0.9 I0_2 = 0.1 R_2 = 2 n_2 = 2 Re = 0.1 gamma = 2 func_1, func_2 = self.double_core_sersic.function_split(x, y, I0_sersic, Re, R_sersic, n_sersic, gamma, phi_G, q, I0_2, R_2, n_2, phi_G_2=0, q_2=1, center_x=0, center_y=0) npt.assert_almost_equal(func_1[0], 0.12594715) npt.assert_almost_equal(func_2[0], 0.081007614731788635) def test_buldge_disk(self): x = np.array([1]) y = np.array([2]) I0_b = 1 R_b = 1 phi_G_b = 0 q_b = 0.9 I0_d = 1 R_d = 2 phi_G_d = 0 q_d = 0.7 values = self.buldge_disk.function(x, y, I0_b, R_b, phi_G_b, q_b, I0_d, R_d, phi_G_d, q_d, center_x=0, center_y=0) npt.assert_almost_equal(values[0], 0.57135696709156036, decimal=8) x = np.array([0]) y = np.array([0]) values = self.buldge_disk.function(x, y, I0_b, R_b, phi_G_b, q_b, I0_d, R_d, phi_G_d, q_d, center_x=0, center_y=0) npt.assert_almost_equal(values[0], 124.98796224594116, decimal=8) x = np.array([2,3,4]) y = np.array([1,1,1]) values = self.buldge_disk.function(x, y, I0_b, R_b, phi_G_b, q_b, I0_d, R_d, phi_G_d, q_d, center_x=0, center_y=0) npt.assert_almost_equal(values[0], 0.85350380837917328, decimal=8) npt.assert_almost_equal(values[1], 0.40610484033823013, decimal=8) npt.assert_almost_equal(values[2], 0.19044427201151848, decimal=8) def test_buldge_disk_function_split(self): x = np.array([1]) y = np.array([2]) I0_b = 1 R_b = 1 phi_G_b = 0 q_b = 0.9 I0_d = 1 R_d = 2 phi_G_d = 0 q_d = 0.7 func_1, func_2 = self.buldge_disk.function_split(x, y, I0_b, R_b, phi_G_b, q_b, I0_d, R_d, phi_G_d, q_d, center_x=0, center_y=0) npt.assert_almost_equal(func_1[0], 0.1476433128118515) npt.assert_almost_equal(func_2[0], 0.42371365427970886)
def __init__(self, light_model_list, smoothing=0.001): """ :param light_model_list: list of light models :param smoothing: smoothing factor for certain models (deprecated) """ self.profile_type_list = light_model_list self.func_list = [] for profile_type in light_model_list: if profile_type == 'GAUSSIAN': from lenstronomy.LightModel.Profiles.gaussian import Gaussian self.func_list.append(Gaussian()) elif profile_type == 'GAUSSIAN_ELLIPSE': from lenstronomy.LightModel.Profiles.gaussian import GaussianEllipse self.func_list.append(GaussianEllipse()) elif profile_type == 'ELLIPSOID': from lenstronomy.LightModel.Profiles.ellipsoid import Ellipsoid self.func_list.append(Ellipsoid()) elif profile_type == 'MULTI_GAUSSIAN': from lenstronomy.LightModel.Profiles.gaussian import MultiGaussian self.func_list.append(MultiGaussian()) elif profile_type == 'MULTI_GAUSSIAN_ELLIPSE': from lenstronomy.LightModel.Profiles.gaussian import MultiGaussianEllipse self.func_list.append(MultiGaussianEllipse()) elif profile_type == 'SERSIC': from lenstronomy.LightModel.Profiles.sersic import Sersic self.func_list.append(Sersic(smoothing=smoothing)) elif profile_type == 'SERSIC_ELLIPSE': from lenstronomy.LightModel.Profiles.sersic import SersicElliptic self.func_list.append( SersicElliptic(smoothing=smoothing, sersic_major_axis=sersic_major_axis_conf)) elif profile_type == 'CORE_SERSIC': from lenstronomy.LightModel.Profiles.sersic import CoreSersic self.func_list.append(CoreSersic(smoothing=smoothing)) elif profile_type == 'SHAPELETS': from lenstronomy.LightModel.Profiles.shapelets import ShapeletSet self.func_list.append(ShapeletSet()) elif profile_type == 'SHAPELETS_POLAR': from lenstronomy.LightModel.Profiles.shapelets_polar import ShapeletSetPolar self.func_list.append(ShapeletSetPolar(exponential=False)) elif profile_type == 'SHAPELETS_POLAR_EXP': from lenstronomy.LightModel.Profiles.shapelets_polar import ShapeletSetPolar self.func_list.append(ShapeletSetPolar(exponential=True)) elif profile_type == 'HERNQUIST': from lenstronomy.LightModel.Profiles.hernquist import Hernquist self.func_list.append(Hernquist()) elif profile_type == 'HERNQUIST_ELLIPSE': from lenstronomy.LightModel.Profiles.hernquist import HernquistEllipse self.func_list.append(HernquistEllipse()) elif profile_type == 'PJAFFE': from lenstronomy.LightModel.Profiles.p_jaffe import PJaffe self.func_list.append(PJaffe()) elif profile_type == 'PJAFFE_ELLIPSE': from lenstronomy.LightModel.Profiles.p_jaffe import PJaffe_Ellipse self.func_list.append(PJaffe_Ellipse()) elif profile_type == 'UNIFORM': from lenstronomy.LightModel.Profiles.uniform import Uniform self.func_list.append(Uniform()) elif profile_type == 'POWER_LAW': from lenstronomy.LightModel.Profiles.power_law import PowerLaw self.func_list.append(PowerLaw()) elif profile_type == 'NIE': from lenstronomy.LightModel.Profiles.nie import NIE self.func_list.append(NIE()) elif profile_type == 'CHAMELEON': from lenstronomy.LightModel.Profiles.chameleon import Chameleon self.func_list.append(Chameleon()) elif profile_type == 'DOUBLE_CHAMELEON': from lenstronomy.LightModel.Profiles.chameleon import DoubleChameleon self.func_list.append(DoubleChameleon()) elif profile_type == 'TRIPLE_CHAMELEON': from lenstronomy.LightModel.Profiles.chameleon import TripleChameleon self.func_list.append(TripleChameleon()) elif profile_type == 'INTERPOL': from lenstronomy.LightModel.Profiles.interpolation import Interpol self.func_list.append(Interpol()) elif profile_type == 'SLIT_STARLETS': from lenstronomy.LightModel.Profiles.starlets import SLIT_Starlets self.func_list.append( SLIT_Starlets(fast_inverse=True, second_gen=False)) elif profile_type == 'SLIT_STARLETS_GEN2': from lenstronomy.LightModel.Profiles.starlets import SLIT_Starlets self.func_list.append(SLIT_Starlets(second_gen=True)) else: raise ValueError( 'No light model of type %s found! Supported are the following models: %s' % (profile_type, _MODELS_SUPPORTED)) self._num_func = len(self.func_list)
def setup(self): self.sersic = Sersic() self.multiGaussian = MultiGaussian()
class TestMGE(object): """ tests the Gaussian methods """ def setup(self): self.sersic = Sersic() self.multiGaussian = MultiGaussian() def test_mge_1d_sersic(self): n_comp = 30 r_sersic = 1. n_sersic = 3.7 I0_sersic = 1. rs = np.logspace(-2., 1., 50) * r_sersic ss = self.sersic.function(rs, np.zeros_like(rs), amp=I0_sersic, n_sersic=n_sersic, R_sersic=r_sersic) amplitudes, sigmas, norm = mge.mge_1d(rs, ss, N=n_comp) ss_mge = self.multiGaussian.function(rs, np.zeros_like(rs), amp=amplitudes, sigma=sigmas) #print((ss - ss_mge)/ss) for i in range(10, len(ss) - 10): #print(rs[i]) npt.assert_almost_equal((ss_mge[i] - ss[i]) / ss[i], 0, decimal=1) amplitudes, sigmas, norm = mge.mge_1d(rs, np.zeros_like(rs), N=n_comp) assert amplitudes[0] == 0 amplitudes, sigmas, norm = mge.mge_1d(rs, np.zeros_like(rs), N=0) assert amplitudes[0] == 0 def test_mge_sersic_radius(self): n_comp = 30 r_sersic = .5 n_sersic = 3.7 I0_sersic = 1. rs = np.logspace(-2., 1., 50) * r_sersic ss = self.sersic.function(rs, np.zeros_like(rs), amp=I0_sersic, n_sersic=n_sersic, R_sersic=r_sersic) amplitudes, sigmas, norm = mge.mge_1d(rs, ss, N=n_comp) ss_mge = self.multiGaussian.function(rs, np.zeros_like(rs), amp=amplitudes, sigma=sigmas) print((ss - ss_mge) / (ss + ss_mge)) for i in range(10, len(ss) - 10): #print(rs[i]) npt.assert_almost_equal((ss_mge[i] - ss[i]) / (ss[i]), 0, decimal=1) def test_mge_sersic_n_sersic(self): n_comp = 20 r_sersic = 1.5 n_sersic = .5 I0_sersic = 1. rs = np.logspace(-2., 1., 50) * r_sersic ss = self.sersic.function(rs, np.zeros_like(rs), amp=I0_sersic, n_sersic=n_sersic, R_sersic=r_sersic) amplitudes, sigmas, norm = mge.mge_1d(rs, ss, N=n_comp) ss_mge = self.multiGaussian.function(rs, np.zeros_like(rs), amp=amplitudes, sigma=sigmas) for i in range(10, len(ss) - 10): npt.assert_almost_equal((ss_mge[i] - ss[i]) / (ss[i] + ss_mge[i]), 0, decimal=1) n_comp = 20 r_sersic = 1.5 n_sersic = 3.5 I0_sersic = 1. rs = np.logspace(-2., 1., 50) * r_sersic ss = self.sersic.function(rs, np.zeros_like(rs), amp=I0_sersic, n_sersic=n_sersic, R_sersic=r_sersic) amplitudes, sigmas, norm = mge.mge_1d(rs, ss, N=n_comp) ss_mge = self.multiGaussian.function(rs, np.zeros_like(rs), amp=amplitudes, sigma=sigmas) for i in range(10, len(ss) - 10): npt.assert_almost_equal((ss_mge[i] - ss[i]) / (ss[i] + ss_mge[i]), 0, decimal=1) def test_hernquist(self): hernquist = Hernquist() n_comp = 20 sigma0 = 1 r_eff = 1.5 rs = np.logspace(-2., 1., 50) * r_eff * 0.5 ss = hernquist.function(rs, np.zeros_like(rs), sigma0, Rs=r_eff) amplitudes, sigmas, norm = mge.mge_1d(rs, ss, N=n_comp) ss_mge = self.multiGaussian.function(rs, np.zeros_like(rs), amp=amplitudes, sigma=sigmas) for i in range(10, len(ss) - 10): npt.assert_almost_equal((ss_mge[i] - ss[i]) / (ss[i] + ss_mge[i]), 0, decimal=2) def test_hernquist_deprojection(self): hernquist = Hernquist() n_comp = 20 sigma0 = 1 r_eff = 1.5 rs = np.logspace(-2., 1., 50) * r_eff * 0.5 ss = hernquist.function(rs, np.zeros_like(rs), sigma0, Rs=r_eff) amplitudes, sigmas, norm = mge.mge_1d(rs, ss, N=n_comp) amplitudes_3d, sigmas_3d = mge.de_projection_3d(amplitudes, sigmas) ss_3d_mge = self.multiGaussian.function(rs, np.zeros_like(rs), amp=amplitudes_3d, sigma=sigmas_3d) ss_3d_mulit = self.multiGaussian.light_3d(rs, amp=amplitudes, sigma=sigmas) for i in range(10, len(ss_3d_mge)): npt.assert_almost_equal((ss_3d_mge[i] - ss_3d_mulit[i]) / (ss_3d_mulit[i] + ss_3d_mge[i]), 0, decimal=1) ss_3d = hernquist.light_3d(rs, sigma0, Rs=r_eff) for i in range(10, len(ss_3d) - 10): npt.assert_almost_equal( (ss_3d_mge[i] - ss_3d[i]) / (ss_3d[i] + ss_3d_mge[i]), 0, decimal=1) def test_spemd(self): from lenstronomy.LensModel.Profiles.spep import SPEP from lenstronomy.LensModel.Profiles.multi_gaussian_kappa import MultiGaussianKappa spep = SPEP() mge_kappa = MultiGaussianKappa() n_comp = 8 theta_E = 1.41 kwargs = {'theta_E': theta_E, 'e1': 0, 'e2': 0, 'gamma': 1.61} rs = np.logspace(-2., 1., 100) * theta_E f_xx, f_yy, f_xy = spep.hessian(rs, 0, **kwargs) kappa = 1 / 2. * (f_xx + f_yy) amplitudes, sigmas, norm = mge.mge_1d(rs, kappa, N=n_comp) kappa_mge = self.multiGaussian.function(rs, np.zeros_like(rs), amp=amplitudes, sigma=sigmas) f_xx_mge, f_yy_mge, f_xy_mge = mge_kappa.hessian(rs, np.zeros_like(rs), amp=amplitudes, sigma=sigmas) for i in range(0, 80): npt.assert_almost_equal(kappa_mge[i], 1. / 2 * (f_xx_mge[i] + f_yy_mge[i]), decimal=1) npt.assert_almost_equal((kappa[i] - kappa_mge[i]) / kappa[i], 0, decimal=1) f_ = spep.function(theta_E, 0, **kwargs) f_mge = mge_kappa.function(theta_E, 0, sigma=sigmas, amp=amplitudes) npt.assert_almost_equal(f_mge / f_, 1, decimal=2) def test_example(self): n_comp = 10 rs = np.array([ 0.01589126, 0.01703967, 0.01827108, 0.01959148, 0.0210073, 0.02252544, 0.02415329, 0.02589879, 0.02777042, 0.02977731, 0.03192923, 0.03423667, 0.03671086, 0.03936385, 0.04220857, 0.04525886, 0.0485296, 0.0520367, 0.05579724, 0.05982956, 0.06415327, 0.06878945, 0.07376067, 0.07909115, 0.08480685, 0.09093561, 0.09750727, 0.10455385, 0.11210966, 0.12021152, 0.12889887, 0.13821403, 0.14820238, 0.15891255, 0.17039672, 0.18271082, 0.19591482, 0.21007304, 0.22525444, 0.24153295, 0.25898787, 0.2777042, 0.29777311, 0.31929235, 0.34236672, 0.36710861, 0.39363853, 0.42208569, 0.45258865, 0.48529597, 0.52036697, 0.55797244, 0.59829556, 0.64153272, 0.6878945, 0.73760673, 0.79091152, 0.8480685, 0.90935605, 0.97507269, 1.04553848, 1.12109664, 1.20211518, 1.28898871, 1.38214034, 1.48202378, 1.58912553, 1.70396721, 1.82710819, 1.95914822, 2.10073042, 2.25254437, 2.4153295, 2.58987865, 2.77704199, 2.9777311, 3.19292345, 3.42366716, 3.67108607, 3.93638527, 4.22085689, 4.5258865, 4.85295974, 5.20366966, 5.57972441, 5.98295559, 6.41532717, 6.87894505, 7.37606729, 7.90911519, 8.48068497, 9.09356051, 9.75072687, 10.45538481, 11.21096643, 12.02115183, 12.88988708, 13.82140341, 14.82023784, 15.89125526 ]) kappa = np.array([ 12.13776067, 11.60484966, 11.09533396, 10.60818686, 10.14242668, 9.69711473, 9.27135349, 8.86428482, 8.47508818, 8.10297905, 7.7472073, 7.40705574, 7.08183863, 6.77090034, 6.47361399, 6.18938022, 5.917626, 5.65780342, 5.40938864, 5.1718808, 4.94480104, 4.72769151, 4.52011448, 4.3216514, 4.13190214, 3.9504841, 3.77703149, 3.61119459, 3.45263901, 3.30104507, 3.1561071, 3.01753287, 2.88504297, 2.75837025, 2.63725931, 2.52146595, 2.41075668, 2.30490829, 2.20370736, 2.10694982, 2.01444058, 1.92599312, 1.84142909, 1.76057799, 1.6832768, 1.60936965, 1.53870751, 1.47114792, 1.40655465, 1.34479745, 1.28575181, 1.22929867, 1.17532421, 1.12371958, 1.07438074, 1.02720821, 0.98210687, 0.93898578, 0.897758, 0.85834039, 0.82065349, 0.78462129, 0.75017114, 0.71723359, 0.68574222, 0.65563353, 0.62684681, 0.59932403, 0.57300967, 0.5478507, 0.52379638, 0.5007982, 0.47880979, 0.45778683, 0.43768691, 0.41846951, 0.40009589, 0.38252899, 0.3657334, 0.34967525, 0.33432216, 0.31964317, 0.30560868, 0.29219041, 0.27936129, 0.26709545, 0.25536817, 0.24415579, 0.23343571, 0.22318631, 0.21338694, 0.20401782, 0.19506006, 0.18649562, 0.17830721, 0.17047832, 0.16299318, 0.15583668, 0.14899441, 0.14245255 ]) amplitudes, sigmas, norm = mge.mge_1d(rs, kappa, N=n_comp) def test_nfw_sersic(self): kwargs_lens_nfw = { 'alpha_Rs': 1.4129647849966354, 'Rs': 7.0991113634274736 } kwargs_lens_sersic = { 'k_eff': 0.24100561407593576, 'n_sersic': 1.8058507329346063, 'R_sersic': 1.0371803141813705 } from lenstronomy.LensModel.Profiles.nfw import NFW from lenstronomy.LensModel.Profiles.sersic import Sersic nfw = NFW() sersic = Sersic() theta_E = 1.5 n_comp = 10 rs = np.logspace(-2., 1., 100) * theta_E f_xx_nfw, f_yy_nfw, f_xy_nfw = nfw.hessian(rs, 0, **kwargs_lens_nfw) f_xx_s, f_yy_s, f_xy_s = sersic.hessian(rs, 0, **kwargs_lens_sersic) kappa = 1 / 2. * (f_xx_nfw + f_xx_s + f_yy_nfw + f_yy_s) amplitudes, sigmas, norm = mge.mge_1d(rs, kappa, N=n_comp) kappa_mge = self.multiGaussian.function(rs, np.zeros_like(rs), amp=amplitudes, sigma=sigmas) from lenstronomy.LensModel.Profiles.multi_gaussian_kappa import MultiGaussianKappa mge_kappa = MultiGaussianKappa() f_xx_mge, f_yy_mge, f_xy_mge = mge_kappa.hessian(rs, np.zeros_like(rs), amp=amplitudes, sigma=sigmas) for i in range(0, 80): npt.assert_almost_equal(kappa_mge[i], 1. / 2 * (f_xx_mge[i] + f_yy_mge[i]), decimal=1) npt.assert_almost_equal((kappa[i] - kappa_mge[i]) / kappa[i], 0, decimal=1) f_nfw = nfw.function(theta_E, 0, **kwargs_lens_nfw) f_s = sersic.function(theta_E, 0, **kwargs_lens_sersic) f_mge = mge_kappa.function(theta_E, 0, sigma=sigmas, amp=amplitudes) npt.assert_almost_equal(f_mge / (f_nfw + f_s), 1, decimal=2)
def setup(self): self.sersic_2 = SersicEllipseKappa() self.sersic = Sersic() self.sersic_light = Sersic_light()
class TestSersic(object): """ tests the Gaussian methods """ def setup(self): self.sersic_2 = SersicEllipseKappa() self.sersic = Sersic() self.sersic_light = Sersic_light() def test_function(self): x = 1 y = 2 n_sersic = 2. R_sersic = 1. k_eff = 0.2 values = self.sersic.function(x, y, n_sersic, R_sersic, k_eff) npt.assert_almost_equal(values, 1.0272982586319199, decimal=10) x = np.array([0]) y = np.array([0]) values = self.sersic.function(x, y, n_sersic, R_sersic, k_eff) npt.assert_almost_equal(values[0], 0., decimal=9) x = np.array([2, 3, 4]) y = np.array([1, 1, 1]) values = self.sersic.function(x, y, n_sersic, R_sersic, k_eff) npt.assert_almost_equal(values[0], 1.0272982586319199, decimal=10) npt.assert_almost_equal(values[1], 1.3318743892966658, decimal=10) npt.assert_almost_equal(values[2], 1.584299393114988, decimal=10) def test_derivatives(self): x = np.array([1]) y = np.array([2]) n_sersic = 2. R_sersic = 1. k_eff = 0.2 f_x, f_y = self.sersic.derivatives(x, y, n_sersic, R_sersic, k_eff) f_x2, f_y2 = self.sersic_2.derivatives(x, y, n_sersic, R_sersic, k_eff, 0, 0.00000001) assert f_x[0] == 0.16556078301997193 assert f_y[0] == 0.33112156603994386 npt.assert_almost_equal(f_x2[0], f_x[0]) npt.assert_almost_equal(f_y2[0], f_y[0]) x = np.array([0]) y = np.array([0]) f_x, f_y = self.sersic.derivatives(x, y, n_sersic, R_sersic, k_eff) f_x2, f_y2 = self.sersic_2.derivatives(x, y, n_sersic, R_sersic, k_eff, 0, 0.00000001) assert f_x[0] == 0 assert f_y[0] == 0 npt.assert_almost_equal(f_x2[0], f_x[0]) npt.assert_almost_equal(f_y2[0], f_y[0]) x = np.array([1, 3, 4]) y = np.array([2, 1, 1]) values = self.sersic.derivatives(x, y, n_sersic, R_sersic, k_eff) values2 = self.sersic_2.derivatives(x, y, n_sersic, R_sersic, k_eff, 0, 0.00000001) assert values[0][0] == 0.16556078301997193 assert values[1][0] == 0.33112156603994386 assert values[0][1] == 0.2772992378623737 assert values[1][1] == 0.092433079287457892 npt.assert_almost_equal(values2[0][0], values[0][0]) npt.assert_almost_equal(values2[1][0], values[1][0]) npt.assert_almost_equal(values2[0][1], values[0][1]) npt.assert_almost_equal(values2[1][1], values[1][1]) values2 = self.sersic_2.derivatives(0.3, -0.2, n_sersic, R_sersic, k_eff, 0, 0.00000001) values = self.sersic.derivatives(0.3, -0.2, n_sersic, R_sersic, k_eff, 0, 0.00000001) npt.assert_almost_equal(values2[0], values[0]) npt.assert_almost_equal(values2[1], values[1]) def test_differentails(self): x_, y_ = 1., 1 n_sersic = 2. R_sersic = 1. k_eff = 0.2 r = np.sqrt(x_**2 + y_**2) d_alpha_dr = self.sersic.d_alpha_dr(x_, y_, n_sersic, R_sersic, k_eff) alpha = self.sersic.alpha_abs(x_, y_, n_sersic, R_sersic, k_eff) f_xx_ = d_alpha_dr * calc_util.d_r_dx( x_, y_) * x_ / r + alpha * calc_util.d_x_diffr_dx(x_, y_) f_yy_ = d_alpha_dr * calc_util.d_r_dy( x_, y_) * y_ / r + alpha * calc_util.d_y_diffr_dy(x_, y_) f_xy_ = d_alpha_dr * calc_util.d_r_dy( x_, y_) * x_ / r + alpha * calc_util.d_x_diffr_dy(x_, y_) f_xx = (d_alpha_dr / r - alpha / r**2) * y_**2 / r + alpha / r f_yy = (d_alpha_dr / r - alpha / r**2) * x_**2 / r + alpha / r f_xy = (d_alpha_dr / r - alpha / r**2) * x_ * y_ / r npt.assert_almost_equal(f_xx, f_xx_, decimal=10) npt.assert_almost_equal(f_yy, f_yy_, decimal=10) npt.assert_almost_equal(f_xy, f_xy_, decimal=10) def test_hessian(self): x = np.array([1]) y = np.array([2]) n_sersic = 2. R_sersic = 1. k_eff = 0.2 f_xx, f_xy, f_yx, f_yy = self.sersic.hessian(x, y, n_sersic, R_sersic, k_eff) assert f_xx[0] == 0.1123170666045793 npt.assert_almost_equal(f_yy[0], -0.047414082641598576, decimal=10) npt.assert_almost_equal(f_xy[0], -0.10648743283078525, decimal=10) npt.assert_almost_equal(f_xy, f_yx, decimal=5) x = np.array([1, 3, 4]) y = np.array([2, 1, 1]) values = self.sersic.hessian(x, y, n_sersic, R_sersic, k_eff) assert values[0][0] == 0.1123170666045793 npt.assert_almost_equal(values[3][0], -0.047414082641598576, decimal=10) npt.assert_almost_equal(values[1][0], -0.10648743283078525, decimal=10) npt.assert_almost_equal(values[0][1], -0.053273787681591328, decimal=10) npt.assert_almost_equal(values[3][1], 0.076243427402007985, decimal=10) npt.assert_almost_equal(values[1][1], -0.048568955656349749, decimal=10) f_xx2, f_xy2, f_yx2, f_yy2 = self.sersic_2.hessian( x, y, n_sersic, R_sersic, k_eff, 0.0000001, 0) npt.assert_almost_equal(f_xx2, values[0]) npt.assert_almost_equal(f_yy2, values[3], decimal=6) npt.assert_almost_equal(f_xy2, values[1], decimal=6) npt.assert_almost_equal(f_yx2, values[2], decimal=6) def test_alpha_abs(self): x = 1. dr = 0.0000001 n_sersic = 2.5 R_sersic = .5 k_eff = 0.2 alpha_abs = self.sersic.alpha_abs(x, 0, n_sersic, R_sersic, k_eff) f_dr = self.sersic.function(x + dr, 0, n_sersic, R_sersic, k_eff) f_ = self.sersic.function(x, 0, n_sersic, R_sersic, k_eff) alpha_abs_num = -(f_dr - f_) / dr npt.assert_almost_equal(alpha_abs_num, alpha_abs, decimal=3) def test_dalpha_dr(self): x = 1. dr = 0.0000001 n_sersic = 1. R_sersic = .5 k_eff = 0.2 d_alpha_dr = self.sersic.d_alpha_dr(x, 0, n_sersic, R_sersic, k_eff) alpha_dr = self.sersic.alpha_abs(x + dr, 0, n_sersic, R_sersic, k_eff) alpha = self.sersic.alpha_abs(x, 0, n_sersic, R_sersic, k_eff) d_alpha_dr_num = (alpha_dr - alpha) / dr npt.assert_almost_equal(d_alpha_dr, d_alpha_dr_num, decimal=3) def test_mag_sym(self): """ :return: """ r = 2. angle1 = 0. angle2 = 1.5 x1 = r * np.cos(angle1) y1 = r * np.sin(angle1) x2 = r * np.cos(angle2) y2 = r * np.sin(angle2) n_sersic = 4.5 R_sersic = 2.5 k_eff = 0.8 f_xx1, f_xy1, f_yx1, f_yy1 = self.sersic.hessian( x1, y1, n_sersic, R_sersic, k_eff) f_xx2, f_xy2, f_yx2, f_yy2 = self.sersic.hessian( x2, y2, n_sersic, R_sersic, k_eff) kappa_1 = (f_xx1 + f_yy1) / 2 kappa_2 = (f_xx2 + f_yy2) / 2 npt.assert_almost_equal(kappa_1, kappa_2, decimal=10) A_1 = (1 - f_xx1) * (1 - f_yy1) - f_xy1 * f_yx1 A_2 = (1 - f_xx2) * (1 - f_yy2) - f_xy2 * f_yx2 npt.assert_almost_equal(A_1, A_2, decimal=10) def test_convergernce(self): """ test the convergence and compares it with the original Sersic profile :return: """ x = np.array([0, 0, 0, 0, 0]) y = np.array([0.5, 1, 1.5, 2, 2.5]) n_sersic = 4.5 R_sersic = 2.5 k_eff = 0.2 f_xx, f_xy, f_yx, f_yy = self.sersic.hessian(x, y, n_sersic, R_sersic, k_eff) kappa = (f_xx + f_yy) / 2. assert kappa[0] > 0 flux = self.sersic_light.function(x, y, amp=1., R_sersic=R_sersic, n_sersic=n_sersic) flux /= flux[0] kappa /= kappa[0] npt.assert_almost_equal(flux[1], kappa[1], decimal=5) xvalues = np.linspace(0.5, 3., 100) e1, e2 = 0.4, 0. q = ellipticity2phi_q(e1, e2)[1] kappa_ellipse = self.sersic_2.projected_mass(xvalues, 0, q, n_sersic, R_sersic, k_eff) fxx, _, _, fyy = self.sersic_2.hessian(xvalues, 0, n_sersic, R_sersic, k_eff, e1, e2) npt.assert_almost_equal(kappa_ellipse, 0.5 * (fxx + fyy), decimal=5) def test_sersic_util(self): n = 1. Re = 2. k, bn = self.sersic.k_bn(n, Re) Re_new = self.sersic.k_Re(n, k) assert Re == Re_new
class TestSersic(object): """ tests the Gaussian methods """ def setup(self): self.sersic = Sersic(smoothing=0.02) self.sersic_elliptic = SersicElliptic(smoothing=0.02) self.core_sersic = CoreSersic(smoothing=0.02) def test_sersic(self): x = np.array([1]) y = np.array([2]) I0_sersic = 1 R_sersic = 1 n_sersic = 1 center_x = 0 center_y = 0 values = self.sersic.function(x, y, I0_sersic, R_sersic, n_sersic, center_x, center_y) npt.assert_almost_equal(values[0], 0.12658651833626802, decimal=6) x = np.array([0]) y = np.array([0]) values = self.sersic.function(x, y, I0_sersic, R_sersic, n_sersic, center_x, center_y) npt.assert_almost_equal(values[0], 5.1482559148107292, decimal=2) x = np.array([2, 3, 4]) y = np.array([1, 1, 1]) values = self.sersic.function(x, y, I0_sersic, R_sersic, n_sersic, center_x, center_y) npt.assert_almost_equal(values[0], 0.12658651833626802, decimal=6) npt.assert_almost_equal(values[1], 0.026902273598180083, decimal=6) npt.assert_almost_equal(values[2], 0.0053957432862338055, decimal=6) value = self.sersic.function(1000, 0, I0_sersic, R_sersic, n_sersic, center_x, center_y) npt.assert_almost_equal(value, 0, decimal=8) def test_symmetry_r_sersic(self): x = np.array([2, 3, 4]) y = np.array([1, 1, 1]) I0_sersic = 1 R_sersic1 = 1 R_sersic2 = 0.1 n_sersic = 1 center_x = 0 center_y = 0 values1 = self.sersic.function(x * R_sersic1, y * R_sersic1, I0_sersic, R_sersic1, n_sersic, center_x, center_y) values2 = self.sersic.function(x * R_sersic2, y * R_sersic2, I0_sersic, R_sersic2, n_sersic, center_x, center_y) npt.assert_almost_equal(values1[0], values2[0], decimal=6) npt.assert_almost_equal(values1[1], values2[1], decimal=6) npt.assert_almost_equal(values1[2], values2[2], decimal=6) def test_sersic_center(self): x = 0.01 y = 0. I0_sersic = 1 R_sersic = 0.1 n_sersic = 4. center_x = 0 center_y = 0 values = self.sersic.function(x, y, I0_sersic, R_sersic, n_sersic, center_x, center_y) npt.assert_almost_equal(values, 12.688073819377406, decimal=6) def test_sersic_elliptic(self): x = np.array([1]) y = np.array([2]) I0_sersic = 1 R_sersic = 1 n_sersic = 1 phi_G = 1 q = 0.9 e1, e2 = param_util.phi_q2_ellipticity(phi_G, q) center_x = 0 center_y = 0 values = self.sersic_elliptic.function(x, y, I0_sersic, R_sersic, n_sersic, e1, e2, center_x, center_y) npt.assert_almost_equal(values[0], 0.12595366113005077, decimal=6) x = np.array([0]) y = np.array([0]) values = self.sersic_elliptic.function(x, y, I0_sersic, R_sersic, n_sersic, e1, e2, center_x, center_y) npt.assert_almost_equal(values[0], 5.1482553482055664, decimal=2) x = np.array([2, 3, 4]) y = np.array([1, 1, 1]) values = self.sersic_elliptic.function(x, y, I0_sersic, R_sersic, n_sersic, e1, e2, center_x, center_y) npt.assert_almost_equal(values[0], 0.11308277793465012, decimal=6) npt.assert_almost_equal(values[1], 0.021188620675507107, decimal=6) npt.assert_almost_equal(values[2], 0.0037276744362724477, decimal=6) def test_core_sersic(self): x = np.array([1]) y = np.array([2]) I0 = 1 Rb = 1 Re = 2 gamma = 3 n = 1 phi_G = 1 q = 0.9 e1, e2 = param_util.phi_q2_ellipticity(phi_G, q) center_x = 0 center_y = 0 values = self.core_sersic.function(x, y, I0, Rb, Re, n, gamma, e1, e2, center_x, center_y) npt.assert_almost_equal(values[0], 0.84489101, decimal=8) x = np.array([0]) y = np.array([0]) values = self.core_sersic.function(x, y, I0, Rb, Re, n, gamma, e1, e2, center_x, center_y) npt.assert_almost_equal(values[0], 288406.09, decimal=0) x = np.array([2, 3, 4]) y = np.array([1, 1, 1]) values = self.core_sersic.function(x, y, I0, Rb, Re, n, gamma, e1, e2, center_x, center_y) npt.assert_almost_equal(values[0], 0.79749529635325933, decimal=6) npt.assert_almost_equal(values[1], 0.33653478121594838, decimal=6) npt.assert_almost_equal(values[2], 0.14050402887681532, decimal=6) def test_total_flux(self): r_eff = 0.2 I_eff = 1. n_sersic = 4 flux = self.sersic._total_flux(r_eff, I_eff, n_sersic) npt.assert_almost_equal(flux, 0.9065917451904356, decimal=5)
def setup(self): self.sersic = Sersic(smoothing=0.02) self.sersic_elliptic = SersicElliptic(smoothing=0.02) self.core_sersic = CoreSersic(smoothing=0.02)
def __init__(self, light_model_list, deflection_scaling_list=None, source_redshift_list=None, smoothing=0.0000001): """ :param light_model_list: list of light models :param deflection_scaling_list: list of floats, rescales the original reduced deflection angles from the lens model to enable different models to be placed at different optical (redshift) distances. None means they are all :param source_redshift_list: list of redshifts of the model components :param smoothing: smoothing factor for certain models (deprecated) """ self.profile_type_list = light_model_list self.deflection_scaling_list = deflection_scaling_list self.redshift_list = source_redshift_list self.func_list = [] for profile_type in light_model_list: if profile_type == 'GAUSSIAN': from lenstronomy.LightModel.Profiles.gaussian import Gaussian self.func_list.append(Gaussian()) elif profile_type == 'GAUSSIAN_ELLIPSE': from lenstronomy.LightModel.Profiles.gaussian import GaussianEllipse self.func_list.append(GaussianEllipse()) elif profile_type == 'MULTI_GAUSSIAN': from lenstronomy.LightModel.Profiles.gaussian import MultiGaussian self.func_list.append(MultiGaussian()) elif profile_type == 'MULTI_GAUSSIAN_ELLIPSE': from lenstronomy.LightModel.Profiles.gaussian import MultiGaussianEllipse self.func_list.append(MultiGaussianEllipse()) elif profile_type == 'SERSIC': from lenstronomy.LightModel.Profiles.sersic import Sersic self.func_list.append(Sersic(smoothing=smoothing)) elif profile_type == 'SERSIC_ELLIPSE': from lenstronomy.LightModel.Profiles.sersic import SersicElliptic self.func_list.append(SersicElliptic(smoothing=smoothing)) elif profile_type == 'CORE_SERSIC': from lenstronomy.LightModel.Profiles.sersic import CoreSersic self.func_list.append(CoreSersic(smoothing=smoothing)) elif profile_type == 'SHAPELETS': from lenstronomy.LightModel.Profiles.shapelets import ShapeletSet self.func_list.append(ShapeletSet()) elif profile_type == 'HERNQUIST': from lenstronomy.LightModel.Profiles.hernquist import Hernquist self.func_list.append(Hernquist()) elif profile_type == 'HERNQUIST_ELLIPSE': from lenstronomy.LightModel.Profiles.hernquist import HernquistEllipse self.func_list.append(HernquistEllipse()) elif profile_type == 'PJAFFE': from lenstronomy.LightModel.Profiles.p_jaffe import PJaffe self.func_list.append(PJaffe()) elif profile_type == 'PJAFFE_ELLIPSE': from lenstronomy.LightModel.Profiles.p_jaffe import PJaffe_Ellipse self.func_list.append(PJaffe_Ellipse()) elif profile_type == 'UNIFORM': from lenstronomy.LightModel.Profiles.uniform import Uniform self.func_list.append(Uniform()) elif profile_type == 'POWER_LAW': from lenstronomy.LightModel.Profiles.power_law import PowerLaw self.func_list.append(PowerLaw()) elif profile_type == 'NIE': from lenstronomy.LightModel.Profiles.nie import NIE self.func_list.append(NIE()) elif profile_type == 'CHAMELEON': from lenstronomy.LightModel.Profiles.chameleon import Chameleon self.func_list.append(Chameleon()) elif profile_type == 'DOUBLE_CHAMELEON': from lenstronomy.LightModel.Profiles.chameleon import DoubleChameleon self.func_list.append(DoubleChameleon()) elif profile_type == 'INTERPOL': from lenstronomy.LightModel.Profiles.interpolation import Interpol self.func_list.append(Interpol()) else: raise ValueError('Warning! No light model of type', profile_type, ' found!')
def setup(self): self.sersic = Sersic() self.sersic_light = Sersic_light()
class TestSersic(object): """ tests the Gaussian methods """ def setup(self): self.sersic = Sersic(smoothing=0.02) self.sersic_elliptic = SersicElliptic(smoothing=0.02) self.core_sersic = CoreSersic(smoothing=0.02) def test_sersic(self): x = np.array([1]) y = np.array([2]) I0_sersic = 1 R_sersic = 1 n_sersic = 1 center_x = 0 center_y = 0 values = self.sersic.function(x, y, I0_sersic, R_sersic, n_sersic, center_x, center_y) npt.assert_almost_equal(values[0], 0.12658651833626802, decimal=6) x = np.array([0]) y = np.array([0]) values = self.sersic.function( x, y, I0_sersic, R_sersic, n_sersic, center_x, center_y) npt.assert_almost_equal(values[0], 5.1482559148107292, decimal=2) x = np.array([2,3,4]) y = np.array([1,1,1]) values = self.sersic.function( x, y, I0_sersic, R_sersic, n_sersic, center_x, center_y) npt.assert_almost_equal(values[0], 0.12658651833626802, decimal=6) npt.assert_almost_equal(values[1], 0.026902273598180083, decimal=6) npt.assert_almost_equal(values[2], 0.0053957432862338055, decimal=6) value = self.sersic.function(1000, 0, I0_sersic, R_sersic, n_sersic, center_x, center_y) npt.assert_almost_equal(value, 0, decimal=8) def test_symmetry_r_sersic(self): x = np.array([2,3,4]) y = np.array([1,1,1]) I0_sersic = 1 R_sersic1 = 1 R_sersic2 = 0.1 n_sersic = 1 center_x = 0 center_y = 0 values1 = self.sersic.function(x*R_sersic1, y*R_sersic1, I0_sersic, R_sersic1, n_sersic, center_x, center_y) values2 = self.sersic.function(x*R_sersic2, y*R_sersic2, I0_sersic, R_sersic2, n_sersic, center_x, center_y) npt.assert_almost_equal(values1[0], values2[0], decimal=6) npt.assert_almost_equal(values1[1], values2[1], decimal=6) npt.assert_almost_equal(values1[2], values2[2], decimal=6) def test_sersic_center(self): x = 0.01 y = 0. I0_sersic = 1 R_sersic = 0.1 n_sersic = 4. center_x = 0 center_y = 0 values = self.sersic.function(x, y, I0_sersic, R_sersic, n_sersic, center_x, center_y) npt.assert_almost_equal(values, 12.688073819377406, decimal=6) def test_sersic_elliptic(self): x = np.array([1]) y = np.array([2]) I0_sersic = 1 R_sersic = 1 n_sersic = 1 phi_G = 1 q = 0.9 e1, e2 = param_util.phi_q2_ellipticity(phi_G, q) center_x = 0 center_y = 0 values = self.sersic_elliptic.function(x, y, I0_sersic, R_sersic, n_sersic, e1, e2, center_x, center_y) npt.assert_almost_equal(values[0], 0.12595366113005077, decimal=6) x = np.array([0]) y = np.array([0]) values = self.sersic_elliptic.function(x, y, I0_sersic, R_sersic, n_sersic, e1, e2, center_x, center_y) npt.assert_almost_equal(values[0], 5.1482553482055664, decimal=2) x = np.array([2,3,4]) y = np.array([1,1,1]) values = self.sersic_elliptic.function(x, y, I0_sersic, R_sersic, n_sersic, e1, e2, center_x, center_y) npt.assert_almost_equal(values[0], 0.11308277793465012, decimal=6) npt.assert_almost_equal(values[1], 0.021188620675507107, decimal=6) npt.assert_almost_equal(values[2], 0.0037276744362724477, decimal=6) def test_core_sersic(self): x = np.array([1]) y = np.array([2]) I0 = 1 Rb = 1 Re = 2 gamma = 3 n = 1 phi_G = 1 q = 0.9 e1, e2 = param_util.phi_q2_ellipticity(phi_G, q) center_x = 0 center_y = 0 values = self.core_sersic.function(x, y, I0, Rb, Re, n, gamma, e1, e2, center_x, center_y) npt.assert_almost_equal(values[0], 0.10338957116342086, decimal=8) x = np.array([0]) y = np.array([0]) values = self.core_sersic.function(x, y, I0, Rb, Re, n, gamma, e1, e2, center_x, center_y) npt.assert_almost_equal(values[0], 187852.14004235074, decimal=0) x = np.array([2,3,4]) y = np.array([1,1,1]) values = self.core_sersic.function(x, y, I0, Rb, Re, n, gamma, e1, e2, center_x, center_y) npt.assert_almost_equal(values[0], 0.09255079955772508, decimal=6) npt.assert_almost_equal(values[1], 0.01767817014938002, decimal=6) npt.assert_almost_equal(values[2], 0.0032541063777438853, decimal=6) def test_total_flux(self): deltapix = 0.1 x_grid, y_grid = util.make_grid(numPix=400, deltapix=deltapix) r_eff = 1 I_eff = 1. n_sersic = 2 flux_analytic = self.sersic.total_flux(amp=I_eff, R_sersic=r_eff, n_sersic=n_sersic, e1=0, e2=0) flux_grid = self.sersic.function(x_grid, y_grid, R_sersic=r_eff, n_sersic=n_sersic, amp=I_eff) flux_numeric = np.sum(flux_grid) * deltapix**2 npt.assert_almost_equal(flux_numeric/flux_analytic, 1, decimal=2) # and here we check with ellipticity e1, e2 = 0.1, 0 flux_analytic_ell = self.sersic.total_flux(amp=I_eff, R_sersic=r_eff, n_sersic=n_sersic, e1=e1, e2=e2) flux_grid = self.sersic_elliptic.function(x_grid, y_grid, R_sersic=r_eff, n_sersic=n_sersic, amp=I_eff, e1=e1, e2=e2) flux_numeric_ell = np.sum(flux_grid) * deltapix ** 2 print(flux_analytic, flux_analytic_ell, flux_numeric_ell) npt.assert_almost_equal(flux_numeric_ell / flux_analytic_ell, 1, decimal=2)
def setup(self): self.sersic = Sersic(smoothing=0.02) self.sersic_elliptic = SersicElliptic(smoothing=0.02, sersic_major_axis=True) self.core_sersic = CoreSersic(smoothing=0.02, sersic_major_axis=True)