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_density_lens(self): r = 1 kwargs = {'theta_E': 1, 'gamma': 2, 'e1': 0, 'e2': 0} rho = self.EPL.density_lens(r, **kwargs) from lenstronomy.LensModel.Profiles.spep import SPEP spep = SPEP() rho_spep = spep.density_lens(r, **kwargs) npt.assert_almost_equal(rho, rho_spep, decimal=7)
class TestSPEMD(object): """ tests the Gaussian methods """ def setup(self): from lenstronomy.LensModel.Profiles.pemd import PEMD from lenstronomy.LensModel.Profiles.spep import SPEP self.PEMD = PEMD(suppress_fastell=True) self.SPEP = SPEP() def test_function(self): phi_E = 1. gamma = 1.9 q = 0.9 phi_G = 1. e1, e2 = param_util.phi_q2_ellipticity(phi_G, q) x = np.array([1.]) y = np.array([2]) a = np.zeros_like(x) values = self.PEMD.function(x, y, phi_E, gamma, e1, e2) if fastell4py_bool: npt.assert_almost_equal(values[0], 2.1571106351401803, decimal=5) else: assert values == 0 a += values x = np.array(1.) y = np.array(2.) a = np.zeros_like(x) values = self.PEMD.function(x, y, phi_E, gamma, e1, e2) print(x, values) a += values if fastell4py_bool: npt.assert_almost_equal(values, 2.1571106351401803, decimal=5) else: assert values == 0 assert type(x) == type(values) x = np.array([2, 3, 4]) y = np.array([1, 1, 1]) values = self.PEMD.function(x, y, phi_E, gamma, e1, e2) if fastell4py_bool: npt.assert_almost_equal(values[0], 2.180188584782964, decimal=7) npt.assert_almost_equal(values[1], 3.2097137160951874, decimal=7) npt.assert_almost_equal(values[2], 4.3109976673748, decimal=7) else: npt.assert_almost_equal(values[0], 0, decimal=7) npt.assert_almost_equal(values[1], 0, decimal=7) npt.assert_almost_equal(values[2], 0, decimal=7) def test_derivatives(self): x = np.array([1]) y = np.array([2]) phi_E = 1. gamma = 1.9 q = 0.9 phi_G = 1. e1, e2 = param_util.phi_q2_ellipticity(phi_G, q) f_x, f_y = self.PEMD.derivatives(x, y, phi_E, gamma, e1, e2) if fastell4py_bool: npt.assert_almost_equal(f_x[0], 0.46664118422711387, decimal=7) npt.assert_almost_equal(f_y[0], 0.9530892465981603, decimal=7) else: npt.assert_almost_equal(f_x[0], 0, decimal=7) npt.assert_almost_equal(f_y[0], 0, decimal=7) x = np.array([1., 3, 4]) y = np.array([2., 1, 1]) a = np.zeros_like(x) values = self.PEMD.derivatives(x, y, phi_E, gamma, e1, e2) if fastell4py_bool: npt.assert_almost_equal(values[0][0], 0.46664118422711387, decimal=7) npt.assert_almost_equal(values[1][0], 0.9530892465981603, decimal=7) npt.assert_almost_equal(values[0][1], 1.0722265330847958, decimal=7) npt.assert_almost_equal(values[1][1], 0.3140067377020791, decimal=7) else: npt.assert_almost_equal(values[0][0], 0, decimal=7) npt.assert_almost_equal(values[1][0], 0, decimal=7) npt.assert_almost_equal(values[0][1], 0, decimal=7) npt.assert_almost_equal(values[1][1], 0, decimal=7) a += values[0] x = 1. y = 2. phi_E = 1. gamma = 1.9 q = 0.9 phi_G = 1. e1, e2 = param_util.phi_q2_ellipticity(phi_G, q) f_x, f_y = self.PEMD.derivatives(x, y, phi_E, gamma, e1, e2) if fastell4py_bool: npt.assert_almost_equal(f_x, 0.46664118422711387, decimal=7) npt.assert_almost_equal(f_y, 0.9530892465981603, decimal=7) else: npt.assert_almost_equal(f_x, 0, decimal=7) npt.assert_almost_equal(f_y, 0, decimal=7) x = 0. y = 0. f_x, f_y = self.PEMD.derivatives(x, y, phi_E, gamma, e1, e2) assert f_x == 0. assert f_y == 0. def test_hessian(self): x = np.array([1]) y = np.array([2]) phi_E = 1. gamma = 1.9 q = 0.9 phi_G = 1. e1, e2 = param_util.phi_q2_ellipticity(phi_G, q) f_xx, f_xy, f_yx, f_yy = self.PEMD.hessian(x, y, phi_E, gamma, e1, e2) if fastell4py_bool: npt.assert_almost_equal(f_xx, 0.4179041, decimal=7) npt.assert_almost_equal(f_yy, 0.1404714, decimal=7) npt.assert_almost_equal(f_xy, -0.1856134, decimal=7) else: npt.assert_almost_equal(f_xx, 0, decimal=7) npt.assert_almost_equal(f_yy, 0, decimal=7) npt.assert_almost_equal(f_xy, 0, decimal=7) npt.assert_almost_equal(f_xy, f_yx, decimal=8) x = 1. y = 2. phi_E = 1. gamma = 1.9 q = 0.9 phi_G = 1. e1, e2 = param_util.phi_q2_ellipticity(phi_G, q) a = np.zeros_like(x) f_xx, f_xy, f_yx, f_yy = self.PEMD.hessian(x, y, phi_E, gamma, e1, e2) if fastell4py_bool: npt.assert_almost_equal(f_xx, 0.41790408341142493, decimal=7) npt.assert_almost_equal(f_yy, 0.14047143086334482, decimal=7) npt.assert_almost_equal(f_xy, -0.1856133848300859, decimal=7) else: npt.assert_almost_equal(f_xx, 0, decimal=7) npt.assert_almost_equal(f_yy, 0, decimal=7) npt.assert_almost_equal(f_xy, 0, decimal=7) a += f_xx x = np.array([1, 3, 4]) y = np.array([2, 1, 1]) values = self.PEMD.hessian(x, y, phi_E, gamma, e1, e2) print(values, 'values') if fastell4py_bool: npt.assert_almost_equal(values[0][0], 0.41789957732890953, decimal=5) npt.assert_almost_equal(values[3][0], 0.14047593655054141, decimal=5) npt.assert_almost_equal(values[1][0], -0.18560737698052343, decimal=5) npt.assert_almost_equal(values[0][1], 0.068359818958208918, decimal=5) npt.assert_almost_equal(values[3][1], 0.32494089371516482, decimal=5) npt.assert_almost_equal(values[1][1], -0.097845438684594374, decimal=5) else: npt.assert_almost_equal(values[0][0], 0, decimal=7) def test_spep_spemd(self): x = np.array([1]) y = np.array([0]) phi_E = 1. gamma = 2. q = 1. phi_G = 1. e1, e2 = param_util.phi_q2_ellipticity(phi_G, q) f_x, f_y = self.PEMD.derivatives(x, y, phi_E, gamma, e1, e2) f_x_spep, f_y_spep = self.SPEP.derivatives(x, y, phi_E, gamma, e1, e2) if fastell4py_bool: npt.assert_almost_equal(f_x[0], f_x_spep[0], decimal=2) else: pass theta_E = 2. gamma = 2. q = 1. phi_G = 1. e1, e2 = param_util.phi_q2_ellipticity(phi_G, q) f_x, f_y = self.PEMD.derivatives(x, y, theta_E, gamma, e1, e2) f_x_spep, f_y_spep = self.SPEP.derivatives(x, y, theta_E, gamma, e1, e2) if fastell4py_bool: npt.assert_almost_equal(f_x[0], f_x_spep[0], decimal=2) else: pass theta_E = 2. gamma = 1.7 q = 1. phi_G = 1. e1, e2 = param_util.phi_q2_ellipticity(phi_G, q) f_x, f_y = self.PEMD.derivatives(x, y, theta_E, gamma, e1, e2) f_x_spep, f_y_spep = self.SPEP.derivatives(x, y, theta_E, gamma, e1, e2) if fastell4py_bool: npt.assert_almost_equal(f_x[0], f_x_spep[0], decimal=4) def test_bounds(self): from lenstronomy.LensModel.Profiles.spemd import SPEMD profile = SPEMD(suppress_fastell=True) compute_bool = profile._parameter_constraints(q_fastell=-1, gam=-1, s2=-1, q=-1) assert compute_bool is False def test_is_not_empty(self): func = self.PEMD.spemd_smooth.is_not_empty assert func(0.1, 0.2) assert func([0.1], [0.2]) assert func((0.1, 0.3), (0.2, 0.4)) assert func(np.array([0.1]), np.array([0.2])) assert not func([], []) assert not func(np.array([]), np.array([])) def test_density_lens(self): r = 1 kwargs = {'theta_E': 1, 'gamma': 2, 'e1': 0, 'e2': 0} rho = self.PEMD.density_lens(r, **kwargs) rho_spep = self.SPEP.density_lens(r, **kwargs) npt.assert_almost_equal(rho, rho_spep, decimal=7)
def __init__(self, lens_model_list, **kwargs): """ :param lens_model_list: list of strings with lens model names :param foreground_shear: bool, when True, models a foreground non-linear shear distortion """ self.func_list = [] self._foreground_shear = False for i, lens_type in enumerate(lens_model_list): if lens_type == 'SHEAR': from lenstronomy.LensModel.Profiles.external_shear import ExternalShear self.func_list.append(ExternalShear()) elif lens_type == 'CONVERGENCE': from lenstronomy.LensModel.Profiles.mass_sheet import MassSheet self.func_list.append(MassSheet()) elif lens_type == 'FLEXION': from lenstronomy.LensModel.Profiles.flexion import Flexion self.func_list.append(Flexion()) elif lens_type == 'POINT_MASS': from lenstronomy.LensModel.Profiles.point_mass import PointMass self.func_list.append(PointMass()) elif lens_type == 'SIS': from lenstronomy.LensModel.Profiles.sis import SIS self.func_list.append(SIS()) elif lens_type == 'SIS_TRUNCATED': from lenstronomy.LensModel.Profiles.sis_truncate import SIS_truncate self.func_list.append(SIS_truncate()) elif lens_type == 'SIE': from lenstronomy.LensModel.Profiles.sie import SIE self.func_list.append(SIE()) elif lens_type == 'SPP': from lenstronomy.LensModel.Profiles.spp import SPP self.func_list.append(SPP()) elif lens_type == 'NIE': from lenstronomy.LensModel.Profiles.nie import NIE self.func_list.append(NIE()) elif lens_type == 'NIE_SIMPLE': from lenstronomy.LensModel.Profiles.nie import NIE_simple self.func_list.append(NIE_simple()) elif lens_type == 'CHAMELEON': from lenstronomy.LensModel.Profiles.chameleon import Chameleon self.func_list.append(Chameleon()) elif lens_type == 'DOUBLE_CHAMELEON': from lenstronomy.LensModel.Profiles.chameleon import DoubleChameleon self.func_list.append(DoubleChameleon()) elif lens_type == 'SPEP': from lenstronomy.LensModel.Profiles.spep import SPEP self.func_list.append(SPEP()) elif lens_type == 'SPEMD': from lenstronomy.LensModel.Profiles.spemd import SPEMD self.func_list.append(SPEMD()) elif lens_type == 'SPEMD_SMOOTH': from lenstronomy.LensModel.Profiles.spemd_smooth import SPEMD_SMOOTH self.func_list.append(SPEMD_SMOOTH()) elif lens_type == 'NFW': from lenstronomy.LensModel.Profiles.nfw import NFW self.func_list.append(NFW(**kwargs)) elif lens_type == 'NFW_ELLIPSE': from lenstronomy.LensModel.Profiles.nfw_ellipse import NFW_ELLIPSE self.func_list.append( NFW_ELLIPSE(interpol=False, num_interp_X=1000, max_interp_X=100)) elif lens_type == 'TNFW': from lenstronomy.LensModel.Profiles.tnfw import TNFW self.func_list.append(TNFW()) elif lens_type == 'SERSIC': from lenstronomy.LensModel.Profiles.sersic import Sersic self.func_list.append(Sersic()) elif lens_type == 'SERSIC_ELLIPSE': from lenstronomy.LensModel.Profiles.sersic_ellipse import SersicEllipse self.func_list.append(SersicEllipse()) elif lens_type == 'PJAFFE': from lenstronomy.LensModel.Profiles.p_jaffe import PJaffe self.func_list.append(PJaffe()) elif lens_type == 'PJAFFE_ELLIPSE': from lenstronomy.LensModel.Profiles.p_jaffe_ellipse import PJaffe_Ellipse self.func_list.append(PJaffe_Ellipse()) elif lens_type == 'HERNQUIST': from lenstronomy.LensModel.Profiles.hernquist import Hernquist self.func_list.append(Hernquist()) elif lens_type == 'HERNQUIST_ELLIPSE': from lenstronomy.LensModel.Profiles.hernquist_ellipse import Hernquist_Ellipse self.func_list.append(Hernquist_Ellipse()) elif lens_type == 'GAUSSIAN': from lenstronomy.LensModel.Profiles.gaussian_potential import Gaussian self.func_list.append(Gaussian()) elif lens_type == 'GAUSSIAN_KAPPA': from lenstronomy.LensModel.Profiles.gaussian_kappa import GaussianKappa self.func_list.append(GaussianKappa()) elif lens_type == 'GAUSSIAN_KAPPA_ELLIPSE': from lenstronomy.LensModel.Profiles.gaussian_kappa_ellipse import GaussianKappaEllipse self.func_list.append(GaussianKappaEllipse()) elif lens_type == 'MULTI_GAUSSIAN_KAPPA': from lenstronomy.LensModel.Profiles.multi_gaussian_kappa import MultiGaussianKappa self.func_list.append(MultiGaussianKappa()) elif lens_type == 'MULTI_GAUSSIAN_KAPPA_ELLIPSE': from lenstronomy.LensModel.Profiles.multi_gaussian_kappa import MultiGaussianKappaEllipse self.func_list.append(MultiGaussianKappaEllipse()) elif lens_type == 'INTERPOL': from lenstronomy.LensModel.Profiles.interpol import Interpol_func self.func_list.append( Interpol_func(grid=False, min_grid_number=100)) elif lens_type == 'INTERPOL_SCALED': from lenstronomy.LensModel.Profiles.interpol import Interpol_func_scaled self.func_list.append( Interpol_func_scaled(grid=False, min_grid_number=100)) elif lens_type == 'SHAPELETS_POLAR': from lenstronomy.LensModel.Profiles.shapelet_pot_polar import PolarShapelets self.func_list.append(PolarShapelets()) elif lens_type == 'SHAPELETS_CART': from lenstronomy.LensModel.Profiles.shapelet_pot_cartesian import CartShapelets self.func_list.append(CartShapelets()) elif lens_type == 'DIPOLE': from lenstronomy.LensModel.Profiles.dipole import Dipole self.func_list.append(Dipole()) elif lens_type == 'FOREGROUND_SHEAR': from lenstronomy.LensModel.Profiles.external_shear import ExternalShear self.func_list.append(ExternalShear()) self._foreground_shear = True self._foreground_shear_idex = i else: raise ValueError('%s is not a valid lens model' % lens_type) self._model_list = lens_model_list
def setup(self): self.nie_potential = NIE_POTENTIAL() self.spep = SPEP()
class TestNIE_POTENTIAL(object): """ tests the NIE_POTENTIAL profile for different rotations """ def setup(self): self.nie_potential = NIE_POTENTIAL() self.spep = SPEP() def test_function(self): y = np.array([1., 2]) x = np.array([0., 0.]) theta_E = 1. theta_c = 0. ############# # no rotation ############# e1, e2 = 0.05, 0.0 eps = np.sqrt(e1**2 + e2**2) phi_G, q = param_util.ellipticity2phi_q(e1, e2) # map the nie_potential input to the spep input gamma_spep = 2. q_spep = np.sqrt(q) e1_spep, e2_spep = param_util.phi_q2_ellipticity(phi_G, q_spep) theta_E_conv = self.nie_potential._theta_q_convert(theta_E, q) theta_E_spep = theta_E_conv * np.sqrt(1 - eps) / ((1 - eps) / (1 + eps))**0.25 # compare the non-rotated output values = self.nie_potential.function(x, y, theta_E, theta_c, e1, e2) delta_pot = values[1] - values[0] values = self.spep.function(x, y, theta_E_spep, gamma_spep, e1_spep, e2_spep) delta_pot_spep = values[1] - values[0] npt.assert_almost_equal(delta_pot, delta_pot_spep, decimal=4) ############ # rotation 1 ############ e1, e2 = 0.05, 0.1 eps = np.sqrt(e1**2 + e2**2) phi_G, q = param_util.ellipticity2phi_q(e1, e2) # map the nie_potential input to the spep input gamma_spep = 2. q_spep = np.sqrt(q) e1_spep, e2_spep = param_util.phi_q2_ellipticity(phi_G, q_spep) theta_E_conv = self.nie_potential._theta_q_convert(theta_E, q) theta_E_spep = theta_E_conv * np.sqrt(1 - eps) / ((1 - eps) / (1 + eps))**0.25 # compare the rotated output values = self.nie_potential.function(x, y, theta_E, theta_c, e1, e2) delta_pot = values[1] - values[0] values = self.spep.function(x, y, theta_E_spep, gamma_spep, e1_spep, e2_spep) delta_pot_spep = values[1] - values[0] npt.assert_almost_equal(delta_pot, delta_pot_spep, decimal=4) ############ # rotation 2 ############ e1, e2 = 0.15, 0.13 eps = np.sqrt(e1**2 + e2**2) phi_G, q = param_util.ellipticity2phi_q(e1, e2) # map the nie_potential input to the spep input gamma_spep = 2. q_spep = np.sqrt(q) e1_spep, e2_spep = param_util.phi_q2_ellipticity(phi_G, q_spep) theta_E_conv = self.nie_potential._theta_q_convert(theta_E, q) theta_E_spep = theta_E_conv * np.sqrt(1 - eps) / ((1 - eps) / (1 + eps))**0.25 # compare the rotated output values = self.nie_potential.function(x, y, theta_E, theta_c, e1, e2) delta_pot = values[1] - values[0] values = self.spep.function(x, y, theta_E_spep, gamma_spep, e1_spep, e2_spep) delta_pot_spep = values[1] - values[0] npt.assert_almost_equal(delta_pot, delta_pot_spep, decimal=4) def test_derivatives(self): x = np.array([1]) y = np.array([2]) theta_E = 1. theta_c = 0. ############# # no rotation ############# e1, e2 = 0.05, 0.0 eps = np.sqrt(e1**2 + e2**2) phi_G, q = param_util.ellipticity2phi_q(e1, e2) # map the nie_potential input to the spep input gamma_spep = 2. q_spep = np.sqrt(q) e1_spep, e2_spep = param_util.phi_q2_ellipticity(phi_G, q_spep) theta_E_conv = self.nie_potential._theta_q_convert(theta_E, q) theta_E_spep = theta_E_conv * np.sqrt(1 - eps) / ((1 - eps) / (1 + eps))**0.25 # compare the non-rotated output f_x, f_y = self.nie_potential.derivatives(x, y, theta_E, theta_c, e1, e2) f_x_nie, f_y_nie = self.spep.derivatives(x, y, theta_E_spep, gamma_spep, e1_spep, e2_spep) npt.assert_almost_equal(f_x, f_x_nie, decimal=4) npt.assert_almost_equal(f_y, f_y_nie, decimal=4) ############ # rotation 1 ############ e1, e2 = 0.05, 0.1 eps = np.sqrt(e1**2 + e2**2) phi_G, q = param_util.ellipticity2phi_q(e1, e2) # map the nie_potential input to the spep input gamma_spep = 2. q_spep = np.sqrt(q) e1_spep, e2_spep = param_util.phi_q2_ellipticity(phi_G, q_spep) theta_E_conv = self.nie_potential._theta_q_convert(theta_E, q) theta_E_spep = theta_E_conv * np.sqrt(1 - eps) / ((1 - eps) / (1 + eps))**0.25 # compare the rotated output f_x, f_y = self.nie_potential.derivatives(x, y, theta_E, theta_c, e1, e2) f_x_nie, f_y_nie = self.spep.derivatives(x, y, theta_E_spep, gamma_spep, e1_spep, e2_spep) npt.assert_almost_equal(f_x, f_x_nie, decimal=4) npt.assert_almost_equal(f_y, f_y_nie, decimal=4) ############ # rotation 2 ############ e1, e2 = 0.15, 0.13 eps = np.sqrt(e1**2 + e2**2) phi_G, q = param_util.ellipticity2phi_q(e1, e2) # map the nie_potential input to the spep input gamma_spep = 2. q_spep = np.sqrt(q) e1_spep, e2_spep = param_util.phi_q2_ellipticity(phi_G, q_spep) theta_E_conv = self.nie_potential._theta_q_convert(theta_E, q) theta_E_spep = theta_E_conv * np.sqrt(1 - eps) / ((1 - eps) / (1 + eps))**0.25 # compare the rotated output f_x, f_y = self.nie_potential.derivatives(x, y, theta_E, theta_c, e1, e2) f_x_nie, f_y_nie = self.spep.derivatives(x, y, theta_E_spep, gamma_spep, e1_spep, e2_spep) npt.assert_almost_equal(f_x, f_x_nie, decimal=4) npt.assert_almost_equal(f_y, f_y_nie, decimal=4) def test_hessian(self): x = np.array([1]) y = np.array([2]) theta_E = 1. theta_c = 0. ############# # no rotation ############# e1, e2 = 0.05, 0.0 eps = np.sqrt(e1**2 + e2**2) phi_G, q = param_util.ellipticity2phi_q(e1, e2) # map the nie_potential input to the spep input gamma_spep = 2. q_spep = np.sqrt(q) e1_spep, e2_spep = param_util.phi_q2_ellipticity(phi_G, q_spep) theta_E_conv = self.nie_potential._theta_q_convert(theta_E, q) theta_E_spep = theta_E_conv * np.sqrt(1 - eps) / ((1 - eps) / (1 + eps))**0.25 # compare the non-rotated output f_xx, f_xy, f_yx, f_yy = self.nie_potential.hessian( x, y, theta_E, theta_c, e1, e2) f_xx_nie, f_xy_nie, f_yx_nie, f_yy_nie = self.spep.hessian( x, y, theta_E_spep, gamma_spep, e1_spep, e2_spep) npt.assert_almost_equal(f_xx, f_xx_nie, decimal=4) npt.assert_almost_equal(f_yy, f_yy_nie, decimal=4) npt.assert_almost_equal(f_xy, f_xy_nie, decimal=4) npt.assert_almost_equal(f_yx, f_yx_nie, decimal=4) ############ # rotation 1 ############ e1, e2 = 0.05, 0.1 eps = np.sqrt(e1**2 + e2**2) phi_G, q = param_util.ellipticity2phi_q(e1, e2) # map the nie_potential input to the spep input gamma_spep = 2. q_spep = np.sqrt(q) e1_spep, e2_spep = param_util.phi_q2_ellipticity(phi_G, q_spep) theta_E_conv = self.nie_potential._theta_q_convert(theta_E, q) theta_E_spep = theta_E_conv * np.sqrt(1 - eps) / ((1 - eps) / (1 + eps))**0.25 # compare the rotated output f_xx, f_xy, f_yx, f_yy = self.nie_potential.hessian( x, y, theta_E, theta_c, e1, e2) f_xx_nie, f_xy_nie, f_yx_nie, f_yy_nie = self.spep.hessian( x, y, theta_E_spep, gamma_spep, e1_spep, e2_spep) npt.assert_almost_equal(f_xx, f_xx_nie, decimal=4) npt.assert_almost_equal(f_yy, f_yy_nie, decimal=4) npt.assert_almost_equal(f_xy, f_xy_nie, decimal=4) npt.assert_almost_equal(f_yx, f_yx_nie, decimal=4) ############ # rotation 2 ############ e1, e2 = 0.15, 0.13 eps = np.sqrt(e1**2 + e2**2) phi_G, q = param_util.ellipticity2phi_q(e1, e2) # map the nie_potential input to the spep input gamma_spep = 2. q_spep = np.sqrt(q) e1_spep, e2_spep = param_util.phi_q2_ellipticity(phi_G, q_spep) theta_E_conv = self.nie_potential._theta_q_convert(theta_E, q) theta_E_spep = theta_E_conv * np.sqrt(1 - eps) / ((1 - eps) / (1 + eps))**0.25 # compare the rotated output f_xx, f_xy, f_yx, f_yy = self.nie_potential.hessian( x, y, theta_E, theta_c, e1, e2) f_xx_nie, f_xy_nie, f_yx_nie, f_yy_nie = self.spep.hessian( x, y, theta_E_spep, gamma_spep, e1_spep, e2_spep) npt.assert_almost_equal(f_xx, f_xx_nie, decimal=4) npt.assert_almost_equal(f_yy, f_yy_nie, decimal=4) npt.assert_almost_equal(f_xy, f_xy_nie, decimal=4) npt.assert_almost_equal(f_yx, f_yx_nie, decimal=4) 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_lens = {'theta_E': 1., 'theta_c': .1, 'e1': e1, 'e2': e2} f_ = self.nie_potential.function(x, y, **kwargs_lens) self.nie_potential.set_static(**kwargs_lens) f_static = self.nie_potential.function(x, y, **kwargs_lens) npt.assert_almost_equal(f_, f_static, decimal=8) self.nie_potential.set_dynamic() kwargs_lens = {'theta_E': 2., 'theta_c': .1, 'e1': e1, 'e2': e2} f_dyn = self.nie_potential.function(x, y, **kwargs_lens) assert f_dyn != f_static
def setup(self): self.SPEP = SPEP() self.SIE = SIE()
def setup(self): self.SPEP = SPEP()
def _import_class(self, lens_type, i, custom_class): if lens_type == 'SHIFT': from lenstronomy.LensModel.Profiles.alpha_shift import Shift return Shift() elif lens_type == 'SHEAR': from lenstronomy.LensModel.Profiles.shear import Shear return Shear() elif lens_type == 'CONVERGENCE': from lenstronomy.LensModel.Profiles.convergence import Convergence return Convergence() elif lens_type == 'FLEXION': from lenstronomy.LensModel.Profiles.flexion import Flexion return Flexion() elif lens_type == 'POINT_MASS': from lenstronomy.LensModel.Profiles.point_mass import PointMass return PointMass() elif lens_type == 'SIS': from lenstronomy.LensModel.Profiles.sis import SIS return SIS() elif lens_type == 'SIS_TRUNCATED': from lenstronomy.LensModel.Profiles.sis_truncate import SIS_truncate return SIS_truncate() elif lens_type == 'SIE': from lenstronomy.LensModel.Profiles.sie import SIE return SIE() elif lens_type == 'SPP': from lenstronomy.LensModel.Profiles.spp import SPP return SPP() elif lens_type == 'NIE': from lenstronomy.LensModel.Profiles.nie import NIE return NIE() elif lens_type == 'NIE_SIMPLE': from lenstronomy.LensModel.Profiles.nie import NIE_simple return NIE_simple() elif lens_type == 'CHAMELEON': from lenstronomy.LensModel.Profiles.chameleon import Chameleon return Chameleon() elif lens_type == 'DOUBLE_CHAMELEON': from lenstronomy.LensModel.Profiles.chameleon import DoubleChameleon return DoubleChameleon() elif lens_type == 'SPEP': from lenstronomy.LensModel.Profiles.spep import SPEP return SPEP() elif lens_type == 'SPEMD': from lenstronomy.LensModel.Profiles.spemd import SPEMD return SPEMD() elif lens_type == 'SPEMD_SMOOTH': from lenstronomy.LensModel.Profiles.spemd_smooth import SPEMD_SMOOTH return SPEMD_SMOOTH() elif lens_type == 'NFW': from lenstronomy.LensModel.Profiles.nfw import NFW return NFW() elif lens_type == 'NFW_ELLIPSE': from lenstronomy.LensModel.Profiles.nfw_ellipse import NFW_ELLIPSE return NFW_ELLIPSE() elif lens_type == 'TNFW': from lenstronomy.LensModel.Profiles.tnfw import TNFW return TNFW() elif lens_type == 'CNFW': from lenstronomy.LensModel.Profiles.cnfw import CNFW return CNFW() elif lens_type == 'SERSIC': from lenstronomy.LensModel.Profiles.sersic import Sersic return Sersic() elif lens_type == 'SERSIC_ELLIPSE': from lenstronomy.LensModel.Profiles.sersic_ellipse import SersicEllipse return SersicEllipse() elif lens_type == 'PJAFFE': from lenstronomy.LensModel.Profiles.p_jaffe import PJaffe return PJaffe() elif lens_type == 'PJAFFE_ELLIPSE': from lenstronomy.LensModel.Profiles.p_jaffe_ellipse import PJaffe_Ellipse return PJaffe_Ellipse() elif lens_type == 'HERNQUIST': from lenstronomy.LensModel.Profiles.hernquist import Hernquist return Hernquist() elif lens_type == 'HERNQUIST_ELLIPSE': from lenstronomy.LensModel.Profiles.hernquist_ellipse import Hernquist_Ellipse return Hernquist_Ellipse() elif lens_type == 'GAUSSIAN': from lenstronomy.LensModel.Profiles.gaussian_potential import Gaussian return Gaussian() elif lens_type == 'GAUSSIAN_KAPPA': from lenstronomy.LensModel.Profiles.gaussian_kappa import GaussianKappa return GaussianKappa() elif lens_type == 'GAUSSIAN_KAPPA_ELLIPSE': from lenstronomy.LensModel.Profiles.gaussian_kappa_ellipse import GaussianKappaEllipse return GaussianKappaEllipse() elif lens_type == 'MULTI_GAUSSIAN_KAPPA': from lenstronomy.LensModel.Profiles.multi_gaussian_kappa import MultiGaussianKappa return MultiGaussianKappa() elif lens_type == 'MULTI_GAUSSIAN_KAPPA_ELLIPSE': from lenstronomy.LensModel.Profiles.multi_gaussian_kappa import MultiGaussianKappaEllipse return MultiGaussianKappaEllipse() elif lens_type == 'INTERPOL': from lenstronomy.LensModel.Profiles.interpol import Interpol return Interpol(grid=False, min_grid_number=100) elif lens_type == 'INTERPOL_SCALED': from lenstronomy.LensModel.Profiles.interpol import InterpolScaled return InterpolScaled() elif lens_type == 'SHAPELETS_POLAR': from lenstronomy.LensModel.Profiles.shapelet_pot_polar import PolarShapelets return PolarShapelets() elif lens_type == 'SHAPELETS_CART': from lenstronomy.LensModel.Profiles.shapelet_pot_cartesian import CartShapelets return CartShapelets() elif lens_type == 'DIPOLE': from lenstronomy.LensModel.Profiles.dipole import Dipole return Dipole() elif lens_type == 'FOREGROUND_SHEAR': from lenstronomy.LensModel.Profiles.shear import Shear self._foreground_shear = True self._foreground_shear_idex = i return Shear() elif lens_type == 'coreBURKERT': from lenstronomy.LensModel.Profiles.coreBurkert import coreBurkert return coreBurkert() elif lens_type == 'NumericalAlpha': from lenstronomy.LensModel.Profiles.numerical_deflections import NumericalAlpha return NumericalAlpha(custom_class[i]) else: raise ValueError('%s is not a valid lens model' % lens_type)
class TestSPEP(object): """ tests the Gaussian methods """ def setup(self): self.SPEP = SPEP() self.SPP = SPP() self.SIS = SIS() def test_function(self): x = np.array([1]) y = np.array([2]) phi_E = 1. gamma = 1.9 q = 1 phi_G = 0. E = phi_E / (((3 - gamma) / 2.)**(1. / (1 - gamma)) * np.sqrt(q)) values_spep = self.SPEP.function(x, y, E, gamma, q, phi_G) values_spp = self.SPP.function(x, y, E, gamma) assert values_spep[0] == values_spp[0] x = np.array([0]) y = np.array([0]) values_spep = self.SPEP.function(x, y, E, gamma, q, phi_G) values_spp = self.SPP.function(x, y, E, gamma) assert values_spep[0] == values_spp[0] x = np.array([2, 3, 4]) y = np.array([1, 1, 1]) values_spep = self.SPEP.function(x, y, E, gamma, q, phi_G) values_spp = self.SPP.function(x, y, E, gamma) assert values_spep[0] == values_spp[0] assert values_spep[1] == values_spp[1] assert values_spep[2] == values_spp[2] def test_derivatives(self): x = np.array([1]) y = np.array([2]) phi_E = 1. gamma = 1.9 q = 1 phi_G = 0. E = phi_E / (((3 - gamma) / 2.)**(1. / (1 - gamma)) * np.sqrt(q)) f_x_spep, f_y_spep = self.SPEP.derivatives(x, y, E, gamma, q, phi_G) f_x_spp, f_y_spp = self.SPP.derivatives(x, y, E, gamma) assert f_x_spep[0] == f_x_spp[0] assert f_y_spep[0] == f_y_spp[0] x = np.array([0]) y = np.array([0]) f_x_spep, f_y_spep = self.SPEP.derivatives(x, y, E, gamma, q, phi_G) f_x_spp, f_y_spp = self.SPP.derivatives(x, y, E, gamma) assert f_x_spep[0] == f_x_spp[0] assert f_y_spep[0] == f_y_spp[0] x = np.array([1, 3, 4]) y = np.array([2, 1, 1]) f_x_spep, f_y_spep = self.SPEP.derivatives(x, y, E, gamma, q, phi_G) f_x_spp, f_y_spp = self.SPP.derivatives(x, y, E, gamma) assert f_x_spep[0] == f_x_spp[0] assert f_y_spep[0] == f_y_spp[0] assert f_x_spep[1] == f_x_spp[1] assert f_y_spep[1] == f_y_spp[1] assert f_x_spep[2] == f_x_spp[2] assert f_y_spep[2] == f_y_spp[2] def test_hessian(self): x = np.array([1]) y = np.array([2]) phi_E = 1. gamma = 1.9 q = 1. phi_G = 0. E = phi_E / (((3 - gamma) / 2.)**(1. / (1 - gamma)) * np.sqrt(q)) f_xx, f_yy, f_xy = self.SPEP.hessian(x, y, E, gamma, q, phi_G) f_xx_spep, f_yy_spep, f_xy_spep = self.SPEP.hessian( x, y, E, gamma, q, phi_G) f_xx_spp, f_yy_spp, f_xy_spp = self.SPP.hessian(x, y, E, gamma) assert f_xx_spep[0] == f_xx_spp[0] assert f_yy_spep[0] == f_yy_spp[0] assert f_xy_spep[0] == f_xy_spp[0] x = np.array([1, 3, 4]) y = np.array([2, 1, 1]) f_xx_spep, f_yy_spep, f_xy_spep = self.SPEP.hessian( x, y, E, gamma, q, phi_G) f_xx_spp, f_yy_spp, f_xy_spp = self.SPP.hessian(x, y, E, gamma) assert f_xx_spep[0] == f_xx_spp[0] assert f_yy_spep[0] == f_yy_spp[0] assert f_xy_spep[0] == f_xy_spp[0] assert f_xx_spep[1] == f_xx_spp[1] assert f_yy_spep[1] == f_yy_spp[1] assert f_xy_spep[1] == f_xy_spp[1] assert f_xx_spep[2] == f_xx_spp[2] assert f_yy_spep[2] == f_yy_spp[2] assert f_xy_spep[2] == f_xy_spp[2] def test_compare_sis(self): x = np.array([1]) y = np.array([2]) theta_E = 1. gamma = 2. f_sis = self.SIS.function(x, y, theta_E) f_spp = self.SPP.function(x, y, theta_E, gamma) f_x_sis, f_y_sis = self.SIS.derivatives(x, y, theta_E) f_x_spp, f_y_spp = self.SPP.derivatives(x, y, theta_E, gamma) f_xx_sis, f_yy_sis, f_xy_sis = self.SIS.hessian(x, y, theta_E) f_xx_spp, f_yy_spp, f_xy_spp = self.SPP.hessian(x, y, theta_E, gamma) npt.assert_almost_equal(f_sis[0], f_spp[0], decimal=7) npt.assert_almost_equal(f_x_sis[0], f_x_spp[0], decimal=7) npt.assert_almost_equal(f_y_sis[0], f_y_spp[0], decimal=7) npt.assert_almost_equal(f_xx_sis[0], f_xx_spp[0], decimal=7) npt.assert_almost_equal(f_yy_sis[0], f_yy_spp[0], decimal=7) npt.assert_almost_equal(f_xy_sis[0], f_xy_spp[0], decimal=7) def test_unit_conversion(self): theta_E = 2. gamma = 2.2 rho0 = self.SPP.theta2rho(theta_E, gamma) theta_E_out = self.SPP.rho2theta(rho0, gamma) assert theta_E == theta_E_out def test_mass_2d_lens(self): r = 1 theta_E = 1 gamma = 2 m_2d = self.SPP.mass_2d_lens(r, theta_E, gamma) npt.assert_almost_equal(m_2d, 3.1415926535897931, decimal=8) def test_grav_pot(self): x, y = 1, 0 rho0 = 1 gamma = 2 grav_pot = self.SPP.grav_pot(x, y, rho0, gamma, center_x=0, center_y=0) npt.assert_almost_equal(grav_pot, 12.566370614359172, decimal=8)
def setup(self): self.SPEP = SPEP() self.SPP = SPP() self.SIS = SIS()
def _import_class(lens_type, custom_class, kwargs_interp, z_lens=None, z_source=None): """ :param lens_type: string, lens model type :param custom_class: custom class :param z_lens: lens redshift # currently only used in NFW_MC model as this is redshift dependent :param z_source: source redshift # currently only used in NFW_MC model as this is redshift dependent :param kwargs_interp: interpolation keyword arguments specifying the numerics. See description in the Interpolate() class. Only applicable for 'INTERPOL' and 'INTERPOL_SCALED' models. :return: class instance of the lens model type """ if lens_type == 'SHIFT': from lenstronomy.LensModel.Profiles.constant_shift import Shift return Shift() elif lens_type == 'NIE_POTENTIAL': from lenstronomy.LensModel.Profiles.nie_potential import NIE_POTENTIAL return NIE_POTENTIAL() elif lens_type == 'CONST_MAG': from lenstronomy.LensModel.Profiles.const_mag import ConstMag return ConstMag() elif lens_type == 'SHEAR': from lenstronomy.LensModel.Profiles.shear import Shear return Shear() elif lens_type == 'SHEAR_GAMMA_PSI': from lenstronomy.LensModel.Profiles.shear import ShearGammaPsi return ShearGammaPsi() elif lens_type == 'SHEAR_REDUCED': from lenstronomy.LensModel.Profiles.shear import ShearReduced return ShearReduced() elif lens_type == 'CONVERGENCE': from lenstronomy.LensModel.Profiles.convergence import Convergence return Convergence() elif lens_type == 'HESSIAN': from lenstronomy.LensModel.Profiles.hessian import Hessian return Hessian() elif lens_type == 'FLEXION': from lenstronomy.LensModel.Profiles.flexion import Flexion return Flexion() elif lens_type == 'FLEXIONFG': from lenstronomy.LensModel.Profiles.flexionfg import Flexionfg return Flexionfg() elif lens_type == 'POINT_MASS': from lenstronomy.LensModel.Profiles.point_mass import PointMass return PointMass() elif lens_type == 'SIS': from lenstronomy.LensModel.Profiles.sis import SIS return SIS() elif lens_type == 'SIS_TRUNCATED': from lenstronomy.LensModel.Profiles.sis_truncate import SIS_truncate return SIS_truncate() elif lens_type == 'SIE': from lenstronomy.LensModel.Profiles.sie import SIE return SIE() elif lens_type == 'SPP': from lenstronomy.LensModel.Profiles.spp import SPP return SPP() elif lens_type == 'NIE': from lenstronomy.LensModel.Profiles.nie import NIE return NIE() elif lens_type == 'NIE_SIMPLE': from lenstronomy.LensModel.Profiles.nie import NIEMajorAxis return NIEMajorAxis() elif lens_type == 'CHAMELEON': from lenstronomy.LensModel.Profiles.chameleon import Chameleon return Chameleon() elif lens_type == 'DOUBLE_CHAMELEON': from lenstronomy.LensModel.Profiles.chameleon import DoubleChameleon return DoubleChameleon() elif lens_type == 'TRIPLE_CHAMELEON': from lenstronomy.LensModel.Profiles.chameleon import TripleChameleon return TripleChameleon() elif lens_type == 'SPEP': from lenstronomy.LensModel.Profiles.spep import SPEP return SPEP() elif lens_type == 'PEMD': from lenstronomy.LensModel.Profiles.pemd import PEMD return PEMD() elif lens_type == 'SPEMD': from lenstronomy.LensModel.Profiles.spemd import SPEMD return SPEMD() elif lens_type == 'EPL': from lenstronomy.LensModel.Profiles.epl import EPL return EPL() elif lens_type == 'EPL_NUMBA': from lenstronomy.LensModel.Profiles.epl_numba import EPL_numba return EPL_numba() elif lens_type == 'SPL_CORE': from lenstronomy.LensModel.Profiles.splcore import SPLCORE return SPLCORE() elif lens_type == 'NFW': from lenstronomy.LensModel.Profiles.nfw import NFW return NFW() elif lens_type == 'NFW_ELLIPSE': from lenstronomy.LensModel.Profiles.nfw_ellipse import NFW_ELLIPSE return NFW_ELLIPSE() elif lens_type == 'NFW_ELLIPSE_GAUSS_DEC': from lenstronomy.LensModel.Profiles.gauss_decomposition import NFWEllipseGaussDec return NFWEllipseGaussDec() elif lens_type == 'NFW_ELLIPSE_CSE': from lenstronomy.LensModel.Profiles.nfw_ellipse_cse import NFW_ELLIPSE_CSE return NFW_ELLIPSE_CSE() elif lens_type == 'TNFW': from lenstronomy.LensModel.Profiles.tnfw import TNFW return TNFW() elif lens_type == 'TNFW_ELLIPSE': from lenstronomy.LensModel.Profiles.tnfw_ellipse import TNFW_ELLIPSE return TNFW_ELLIPSE() elif lens_type == 'CNFW': from lenstronomy.LensModel.Profiles.cnfw import CNFW return CNFW() elif lens_type == 'CNFW_ELLIPSE': from lenstronomy.LensModel.Profiles.cnfw_ellipse import CNFW_ELLIPSE return CNFW_ELLIPSE() elif lens_type == 'CTNFW_GAUSS_DEC': from lenstronomy.LensModel.Profiles.gauss_decomposition import CTNFWGaussDec return CTNFWGaussDec() elif lens_type == 'NFW_MC': from lenstronomy.LensModel.Profiles.nfw_mass_concentration import NFWMC return NFWMC(z_lens=z_lens, z_source=z_source) elif lens_type == 'SERSIC': from lenstronomy.LensModel.Profiles.sersic import Sersic return Sersic() elif lens_type == 'SERSIC_ELLIPSE_POTENTIAL': from lenstronomy.LensModel.Profiles.sersic_ellipse_potential import SersicEllipse return SersicEllipse() elif lens_type == 'SERSIC_ELLIPSE_KAPPA': from lenstronomy.LensModel.Profiles.sersic_ellipse_kappa import SersicEllipseKappa return SersicEllipseKappa() elif lens_type == 'SERSIC_ELLIPSE_GAUSS_DEC': from lenstronomy.LensModel.Profiles.gauss_decomposition import SersicEllipseGaussDec return SersicEllipseGaussDec() elif lens_type == 'PJAFFE': from lenstronomy.LensModel.Profiles.p_jaffe import PJaffe return PJaffe() elif lens_type == 'PJAFFE_ELLIPSE': from lenstronomy.LensModel.Profiles.p_jaffe_ellipse import PJaffe_Ellipse return PJaffe_Ellipse() elif lens_type == 'HERNQUIST': from lenstronomy.LensModel.Profiles.hernquist import Hernquist return Hernquist() elif lens_type == 'HERNQUIST_ELLIPSE': from lenstronomy.LensModel.Profiles.hernquist_ellipse import Hernquist_Ellipse return Hernquist_Ellipse() elif lens_type == 'HERNQUIST_ELLIPSE_CSE': from lenstronomy.LensModel.Profiles.hernquist_ellipse_cse import HernquistEllipseCSE return HernquistEllipseCSE() elif lens_type == 'GAUSSIAN': from lenstronomy.LensModel.Profiles.gaussian_potential import Gaussian return Gaussian() elif lens_type == 'GAUSSIAN_KAPPA': from lenstronomy.LensModel.Profiles.gaussian_kappa import GaussianKappa return GaussianKappa() elif lens_type == 'GAUSSIAN_ELLIPSE_KAPPA': from lenstronomy.LensModel.Profiles.gaussian_ellipse_kappa import GaussianEllipseKappa return GaussianEllipseKappa() elif lens_type == 'GAUSSIAN_ELLIPSE_POTENTIAL': from lenstronomy.LensModel.Profiles.gaussian_ellipse_potential import GaussianEllipsePotential return GaussianEllipsePotential() elif lens_type == 'MULTI_GAUSSIAN_KAPPA': from lenstronomy.LensModel.Profiles.multi_gaussian_kappa import MultiGaussianKappa return MultiGaussianKappa() elif lens_type == 'MULTI_GAUSSIAN_KAPPA_ELLIPSE': from lenstronomy.LensModel.Profiles.multi_gaussian_kappa import MultiGaussianKappaEllipse return MultiGaussianKappaEllipse() elif lens_type == 'INTERPOL': from lenstronomy.LensModel.Profiles.interpol import Interpol return Interpol(**kwargs_interp) elif lens_type == 'INTERPOL_SCALED': from lenstronomy.LensModel.Profiles.interpol import InterpolScaled return InterpolScaled(**kwargs_interp) elif lens_type == 'SHAPELETS_POLAR': from lenstronomy.LensModel.Profiles.shapelet_pot_polar import PolarShapelets return PolarShapelets() elif lens_type == 'SHAPELETS_CART': from lenstronomy.LensModel.Profiles.shapelet_pot_cartesian import CartShapelets return CartShapelets() elif lens_type == 'DIPOLE': from lenstronomy.LensModel.Profiles.dipole import Dipole return Dipole() elif lens_type == 'CURVED_ARC_CONST': from lenstronomy.LensModel.Profiles.curved_arc_const import CurvedArcConst return CurvedArcConst() elif lens_type == 'CURVED_ARC_CONST_MST': from lenstronomy.LensModel.Profiles.curved_arc_const import CurvedArcConstMST return CurvedArcConstMST() elif lens_type == 'CURVED_ARC_SPP': from lenstronomy.LensModel.Profiles.curved_arc_spp import CurvedArcSPP return CurvedArcSPP() elif lens_type == 'CURVED_ARC_SIS_MST': from lenstronomy.LensModel.Profiles.curved_arc_sis_mst import CurvedArcSISMST return CurvedArcSISMST() elif lens_type == 'CURVED_ARC_SPT': from lenstronomy.LensModel.Profiles.curved_arc_spt import CurvedArcSPT return CurvedArcSPT() elif lens_type == 'CURVED_ARC_TAN_DIFF': from lenstronomy.LensModel.Profiles.curved_arc_tan_diff import CurvedArcTanDiff return CurvedArcTanDiff() elif lens_type == 'ARC_PERT': from lenstronomy.LensModel.Profiles.arc_perturbations import ArcPerturbations return ArcPerturbations() elif lens_type == 'coreBURKERT': from lenstronomy.LensModel.Profiles.coreBurkert import CoreBurkert return CoreBurkert() elif lens_type == 'CORED_DENSITY': from lenstronomy.LensModel.Profiles.cored_density import CoredDensity return CoredDensity() elif lens_type == 'CORED_DENSITY_2': from lenstronomy.LensModel.Profiles.cored_density_2 import CoredDensity2 return CoredDensity2() elif lens_type == 'CORED_DENSITY_EXP': from lenstronomy.LensModel.Profiles.cored_density_exp import CoredDensityExp return CoredDensityExp() elif lens_type == 'CORED_DENSITY_MST': from lenstronomy.LensModel.Profiles.cored_density_mst import CoredDensityMST return CoredDensityMST(profile_type='CORED_DENSITY') elif lens_type == 'CORED_DENSITY_2_MST': from lenstronomy.LensModel.Profiles.cored_density_mst import CoredDensityMST return CoredDensityMST(profile_type='CORED_DENSITY_2') elif lens_type == 'CORED_DENSITY_EXP_MST': from lenstronomy.LensModel.Profiles.cored_density_mst import CoredDensityMST return CoredDensityMST(profile_type='CORED_DENSITY_EXP') elif lens_type == 'NumericalAlpha': from lenstronomy.LensModel.Profiles.numerical_deflections import NumericalAlpha return NumericalAlpha(custom_class) elif lens_type == 'MULTIPOLE': from lenstronomy.LensModel.Profiles.multipole import Multipole return Multipole() elif lens_type == 'CSE': from lenstronomy.LensModel.Profiles.cored_steep_ellipsoid import CSE return CSE() elif lens_type == 'ElliSLICE': from lenstronomy.LensModel.Profiles.elliptical_density_slice import ElliSLICE return ElliSLICE() elif lens_type == 'ULDM': from lenstronomy.LensModel.Profiles.uldm import Uldm return Uldm() elif lens_type == 'CORED_DENSITY_ULDM_MST': from lenstronomy.LensModel.Profiles.cored_density_mst import CoredDensityMST return CoredDensityMST(profile_type='CORED_DENSITY_ULDM') else: raise ValueError( '%s is not a valid lens model. Supported are: %s.' % (lens_type, _SUPPORTED_MODELS))
def setup(self): from lenstronomy.LensModel.Profiles.spemd import SPEMD from lenstronomy.LensModel.Profiles.spep import SPEP self.SPEMD = SPEMD() self.SPEP = SPEP()
class TestSPEMD(object): """ tests the Gaussian methods """ def setup(self): from lenstronomy.LensModel.Profiles.spemd import SPEMD from lenstronomy.LensModel.Profiles.spep import SPEP self.SPEMD = SPEMD() self.SPEP = SPEP() def test_function(self): phi_E = 1. gamma = 1.9 q = 0.9 phi_G = 1. e1, e2 = param_util.phi_q2_ellipticity(phi_G, q) x = np.array([1.]) y = np.array([2]) a = np.zeros_like(x) values = self.SPEMD.function(x, y, phi_E, gamma, e1, e2) if fastell4py_bool: assert values == 2.1567297115381039 else: assert values == 0 a += values x = np.array(1.) y = np.array(2.) a = np.zeros_like(x) values = self.SPEMD.function(x, y, phi_E, gamma, e1, e2) print(x, values) a += values if fastell4py_bool: assert values == 2.1567297115381039 else: assert values == 0 assert type(x) == type(values) x = np.array([2, 3, 4]) y = np.array([1, 1, 1]) values = self.SPEMD.function(x, y, phi_E, gamma, e1, e2) if fastell4py_bool: npt.assert_almost_equal(values[0], 2.1798076611034141, decimal=7) npt.assert_almost_equal(values[1], 3.209319798597186, decimal=7) npt.assert_almost_equal(values[2], 4.3105937398856398, decimal=7) else: npt.assert_almost_equal(values[0], 0, decimal=7) npt.assert_almost_equal(values[1], 0, decimal=7) npt.assert_almost_equal(values[2], 0, decimal=7) def test_derivatives(self): x = np.array([1]) y = np.array([2]) phi_E = 1. gamma = 1.9 q = 0.9 phi_G = 1. e1, e2 = param_util.phi_q2_ellipticity(phi_G, q) f_x, f_y = self.SPEMD.derivatives(x, y, phi_E, gamma, e1, e2) if fastell4py_bool: npt.assert_almost_equal(f_x[0], 0.46663367437984204, decimal=7) npt.assert_almost_equal(f_y[0], 0.95307422686028065, decimal=7) else: npt.assert_almost_equal(f_x[0], 0, decimal=7) npt.assert_almost_equal(f_y[0], 0, decimal=7) x = np.array([1., 3, 4]) y = np.array([2., 1, 1]) a = np.zeros_like(x) values = self.SPEMD.derivatives(x, y, phi_E, gamma, e1, e2) if fastell4py_bool: npt.assert_almost_equal(values[0][0], 0.46663367437984204, decimal=7) npt.assert_almost_equal(values[1][0], 0.95307422686028065, decimal=7) npt.assert_almost_equal(values[0][1], 1.0722152681324291, decimal=7) npt.assert_almost_equal(values[1][1], 0.31400298272329669, decimal=7) else: npt.assert_almost_equal(values[0][0], 0, decimal=7) npt.assert_almost_equal(values[1][0], 0, decimal=7) npt.assert_almost_equal(values[0][1], 0, decimal=7) npt.assert_almost_equal(values[1][1], 0, decimal=7) a += values[0] x = 1. y = 2. phi_E = 1. gamma = 1.9 q = 0.9 phi_G = 1. e1, e2 = param_util.phi_q2_ellipticity(phi_G, q) f_x, f_y = self.SPEMD.derivatives(x, y, phi_E, gamma, e1, e2) if fastell4py_bool: npt.assert_almost_equal(f_x, 0.46663367437984204, decimal=7) npt.assert_almost_equal(f_y, 0.95307422686028065, decimal=7) else: npt.assert_almost_equal(f_x, 0, decimal=7) npt.assert_almost_equal(f_y, 0, decimal=7) x = 0. y = 0. f_x, f_y = self.SPEMD.derivatives(x, y, phi_E, gamma, e1, e2) assert f_x == 0. assert f_y == 0. def test_hessian(self): x = np.array([1]) y = np.array([2]) phi_E = 1. gamma = 1.9 q = 0.9 phi_G = 1. e1, e2 = param_util.phi_q2_ellipticity(phi_G, q) f_xx, f_yy, f_xy = self.SPEMD.hessian(x, y, phi_E, gamma, e1, e2) if fastell4py_bool: npt.assert_almost_equal(f_xx, 0.41789957732890953, decimal=7) npt.assert_almost_equal(f_yy, 0.14047593655054141, decimal=7) npt.assert_almost_equal(f_xy, -0.18560737698052343, decimal=7) else: npt.assert_almost_equal(f_xx, 0, decimal=7) npt.assert_almost_equal(f_yy, 0, decimal=7) npt.assert_almost_equal(f_xy, 0, decimal=7) x = 1. y = 2. phi_E = 1. gamma = 1.9 q = 0.9 phi_G = 1. e1, e2 = param_util.phi_q2_ellipticity(phi_G, q) a = np.zeros_like(x) f_xx, f_yy, f_xy = self.SPEMD.hessian(x, y, phi_E, gamma, e1, e2) if fastell4py_bool: npt.assert_almost_equal(f_xx, 0.41789957732890953, decimal=7) npt.assert_almost_equal(f_yy, 0.14047593655054141, decimal=7) npt.assert_almost_equal(f_xy, -0.18560737698052343, decimal=7) else: npt.assert_almost_equal(f_xx, 0, decimal=7) npt.assert_almost_equal(f_yy, 0, decimal=7) npt.assert_almost_equal(f_xy, 0, decimal=7) a += f_xx x = np.array([1, 3, 4]) y = np.array([2, 1, 1]) values = self.SPEMD.hessian(x, y, phi_E, gamma, e1, e2) print(values, 'values') if fastell4py_bool: npt.assert_almost_equal(values[0][0], 0.41789957732890953, decimal=7) npt.assert_almost_equal(values[1][0], 0.14047593655054141, decimal=7) npt.assert_almost_equal(values[2][0], -0.18560737698052343, decimal=7) npt.assert_almost_equal(values[0][1], 0.068359818958208918, decimal=7) npt.assert_almost_equal(values[1][1], 0.32494089371516482, decimal=7) npt.assert_almost_equal(values[2][1], -0.097845438684594374, decimal=7) else: npt.assert_almost_equal(values[0][0], 0, decimal=7) def test_spep_spemd(self): x = np.array([1]) y = np.array([0]) phi_E = 1. gamma = 2. q = 1. phi_G = 1. e1, e2 = param_util.phi_q2_ellipticity(phi_G, q) f_x, f_y = self.SPEMD.derivatives(x, y, phi_E, gamma, e1, e2) f_x_spep, f_y_spep = self.SPEP.derivatives(x, y, phi_E, gamma, e1, e2) if fastell4py_bool: npt.assert_almost_equal(f_x[0], f_x_spep[0], decimal=2) else: pass theta_E = 2. gamma = 2. q = 1. phi_G = 1. e1, e2 = param_util.phi_q2_ellipticity(phi_G, q) f_x, f_y = self.SPEMD.derivatives(x, y, theta_E, gamma, e1, e2) f_x_spep, f_y_spep = self.SPEP.derivatives(x, y, theta_E, gamma, e1, e2) if fastell4py_bool: npt.assert_almost_equal(f_x[0], f_x_spep[0], decimal=2) else: pass theta_E = 2. gamma = 1.7 q = 1. phi_G = 1. e1, e2 = param_util.phi_q2_ellipticity(phi_G, q) f_x, f_y = self.SPEMD.derivatives(x, y, theta_E, gamma, e1, e2) f_x_spep, f_y_spep = self.SPEP.derivatives(x, y, theta_E, gamma, e1, e2) if fastell4py_bool: npt.assert_almost_equal(f_x[0], f_x_spep[0], decimal=4) def test_bounds(self): from lenstronomy.LensModel.Profiles.spemd_smooth import SPEMD_SMOOTH profile = SPEMD_SMOOTH() theta_E, gamma, q, phi_G, s_scale = profile._parameter_constraints( theta_E=-1, s_scale=0, gamma=3, q=2, phi_G=0) assert theta_E == 0 def test_is_not_empty(self): func = self.SPEMD.spemd_smooth.is_not_empty assert func(0.1, 0.2) assert func([0.1], [0.2]) assert func((0.1, 0.3), (0.2, 0.4)) assert func(np.array([0.1]), np.array([0.2])) assert not func([], []) assert not func(np.array([]), np.array([])) def test_density_lens(self): r = 1 kwargs = {'theta_E': 1, 'gamma': 2, 'e1': 0, 'e2': 0} rho = self.SPEMD.density_lens(r, **kwargs) rho_spep = self.SPEP.density_lens(r, **kwargs) npt.assert_almost_equal(rho, rho_spep, decimal=7)
def setup(self): from lenstronomy.LensModel.Profiles.pemd import PEMD from lenstronomy.LensModel.Profiles.spep import SPEP self.PEMD = PEMD(suppress_fastell=True) self.SPEP = SPEP()
class TestSPEP(object): """ tests the Gaussian methods """ def setup(self): self.SPEP = SPEP() self.SIE = SIE() def test_function(self): x = 1 y = 2 phi_E = 1. gamma = 1.9 q = 0.9 phi_G = 1. e1, e2 = param_util.phi_q2_ellipticity(phi_G, q) values = self.SPEP.function(x, y, phi_E, gamma, e1, e2) npt.assert_almost_equal(values, 2.104213947346917, decimal=7) x = np.array([0]) y = np.array([0]) values = self.SPEP.function(x, y, phi_E, gamma, e1, e2) assert values[0] == 0 x = np.array([2, 3, 4]) y = np.array([1, 1, 1]) values = self.SPEP.function(x, y, phi_E, gamma, e1, e2) npt.assert_almost_equal(values[0], 2.1709510681181285, decimal=7) npt.assert_almost_equal(values[1], 3.2293397784259108, decimal=7) npt.assert_almost_equal(values[2], 4.3624056004556948, decimal=7) def test_derivatives(self): x = np.array([1]) y = np.array([2]) phi_E = 1. gamma = 1.9 q = 0.9 phi_G = 1. e1, e2 = param_util.phi_q2_ellipticity(phi_G, q) f_x, f_y = self.SPEP.derivatives(x, y, phi_E, gamma, e1, e2) npt.assert_almost_equal(f_x[0], 0.43989645846696634, decimal=7) npt.assert_almost_equal(f_y[0], 0.93736944180732129, decimal=7) x = np.array([0]) y = np.array([0]) f_x, f_y = self.SPEP.derivatives(x, y, phi_E, gamma, e1, e2) assert f_x[0] == 0 assert f_y[0] == 0 x = np.array([1, 3, 4]) y = np.array([2, 1, 1]) values = self.SPEP.derivatives(x, y, phi_E, gamma, e1, e2) npt.assert_almost_equal(values[0][0], 0.43989645846696634, decimal=7) npt.assert_almost_equal(values[1][0], 0.93736944180732129, decimal=7) npt.assert_almost_equal(values[0][1], 1.1029501948308649, decimal=7) npt.assert_almost_equal(values[1][1], 0.24342317177590794, decimal=7) x = 1 y = 2 phi_E = 1. gamma = 1.9 q = 0.9 phi_G = 1. e1, e2 = param_util.phi_q2_ellipticity(phi_G, q) f_x, f_y = self.SPEP.derivatives(x, y, phi_E, gamma, e1, e2) npt.assert_almost_equal(f_x, 0.43989645846696634, decimal=7) npt.assert_almost_equal(f_y, 0.93736944180732129, decimal=7) x = 0 y = 0 f_x, f_y = self.SPEP.derivatives(x, y, phi_E, gamma, e1, e2) assert f_x == 0 assert f_y == 0 def test_hessian(self): x = np.array([1]) y = np.array([2]) phi_E = 1. gamma = 1.9 q = 0.9 phi_G = 1. e1, e2 = param_util.phi_q2_ellipticity(phi_G, q) f_xx, f_yy,f_xy = self.SPEP.hessian(x, y, phi_E, gamma, e1, e2) npt.assert_almost_equal(f_xx[0], 0.46312881977317422, decimal=7) npt.assert_almost_equal(f_yy[0], 0.15165326557198552, decimal=7) npt.assert_almost_equal(f_xy[0], -0.20956958696323871, decimal=7) x = np.array([1,3,4]) y = np.array([2,1,1]) values = self.SPEP.hessian(x, y, phi_E, gamma, e1, e2) npt.assert_almost_equal(values[0][0], 0.46312881977317422, decimal=7) npt.assert_almost_equal(values[1][0], 0.15165326557198552, decimal=7) npt.assert_almost_equal(values[2][0], -0.20956958696323871, decimal=7) npt.assert_almost_equal(values[0][1], 0.070999592014527796, decimal=7) npt.assert_almost_equal(values[1][1], 0.33245358685908111, decimal=7) npt.assert_almost_equal(values[2][1], -0.10270375656049677, decimal=7) def test_spep_sie_conventions(self): x = np.array([1., 2., 0.]) y = np.array([2, 1., 1.]) phi_E = 1. gamma = 2 q = 0.9999 phi_G = 1. e1, e2 = param_util.phi_q2_ellipticity(phi_G, q) f_xx, f_yy, f_xy = self.SPEP.hessian(x, y, phi_E, gamma, e1, e2) f_xx_sie, f_yy_sie, f_xy_sie = self.SIE.hessian(x, y, phi_E, e1, e2) npt.assert_almost_equal(f_xx, f_xx_sie, decimal=4) npt.assert_almost_equal(f_yy, f_yy_sie, decimal=4) npt.assert_almost_equal(f_xy, f_xy_sie, decimal=4)
def _import_class(lens_type, custom_class, z_lens=None, z_source=None): """ :param lens_type: string, lens model type :param custom_class: custom class :param z_lens: lens redshift # currently only used in NFW_MC model as this is redshift dependent :param z_source: source redshift # currently only used in NFW_MC model as this is redshift dependent :return: class instance of the lens model type """ if lens_type == 'SHIFT': from lenstronomy.LensModel.Profiles.alpha_shift import Shift return Shift() elif lens_type == 'SHEAR': from lenstronomy.LensModel.Profiles.shear import Shear return Shear() elif lens_type == 'SHEAR_GAMMA_PSI': from lenstronomy.LensModel.Profiles.shear import ShearGammaPsi return ShearGammaPsi() elif lens_type == 'CONVERGENCE': from lenstronomy.LensModel.Profiles.convergence import Convergence return Convergence() elif lens_type == 'FLEXION': from lenstronomy.LensModel.Profiles.flexion import Flexion return Flexion() elif lens_type == 'FLEXIONFG': from lenstronomy.LensModel.Profiles.flexionfg import Flexionfg return Flexionfg() elif lens_type == 'POINT_MASS': from lenstronomy.LensModel.Profiles.point_mass import PointMass return PointMass() elif lens_type == 'SIS': from lenstronomy.LensModel.Profiles.sis import SIS return SIS() elif lens_type == 'SIS_TRUNCATED': from lenstronomy.LensModel.Profiles.sis_truncate import SIS_truncate return SIS_truncate() elif lens_type == 'SIE': from lenstronomy.LensModel.Profiles.sie import SIE return SIE() elif lens_type == 'SPP': from lenstronomy.LensModel.Profiles.spp import SPP return SPP() elif lens_type == 'NIE': from lenstronomy.LensModel.Profiles.nie import NIE return NIE() elif lens_type == 'NIE_SIMPLE': from lenstronomy.LensModel.Profiles.nie import NIEMajorAxis return NIEMajorAxis() elif lens_type == 'CHAMELEON': from lenstronomy.LensModel.Profiles.chameleon import Chameleon return Chameleon() elif lens_type == 'DOUBLE_CHAMELEON': from lenstronomy.LensModel.Profiles.chameleon import DoubleChameleon return DoubleChameleon() elif lens_type == 'TRIPLE_CHAMELEON': from lenstronomy.LensModel.Profiles.chameleon import TripleChameleon return TripleChameleon() elif lens_type == 'SPEP': from lenstronomy.LensModel.Profiles.spep import SPEP return SPEP() elif lens_type == 'SPEMD': from lenstronomy.LensModel.Profiles.spemd import SPEMD return SPEMD() elif lens_type == 'SPEMD_SMOOTH': from lenstronomy.LensModel.Profiles.spemd_smooth import SPEMD_SMOOTH return SPEMD_SMOOTH() elif lens_type == 'NFW': from lenstronomy.LensModel.Profiles.nfw import NFW return NFW() elif lens_type == 'NFW_ELLIPSE': from lenstronomy.LensModel.Profiles.nfw_ellipse import NFW_ELLIPSE return NFW_ELLIPSE() elif lens_type == 'NFW_ELLIPSE_GAUSS_DEC': from lenstronomy.LensModel.Profiles.gauss_decomposition import NFWEllipseGaussDec return NFWEllipseGaussDec() elif lens_type == 'TNFW': from lenstronomy.LensModel.Profiles.tnfw import TNFW return TNFW() elif lens_type == 'CNFW': from lenstronomy.LensModel.Profiles.cnfw import CNFW return CNFW() elif lens_type == 'CNFW_ELLIPSE': from lenstronomy.LensModel.Profiles.cnfw_ellipse import CNFW_ELLIPSE return CNFW_ELLIPSE() elif lens_type == 'CTNFW_GAUSS_DEC': from lenstronomy.LensModel.Profiles.gauss_decomposition import CTNFWGaussDec return CTNFWGaussDec() elif lens_type == 'NFW_MC': from lenstronomy.LensModel.Profiles.nfw_mass_concentration import NFWMC return NFWMC(z_lens=z_lens, z_source=z_source) elif lens_type == 'SERSIC': from lenstronomy.LensModel.Profiles.sersic import Sersic return Sersic() elif lens_type == 'SERSIC_ELLIPSE_POTENTIAL': from lenstronomy.LensModel.Profiles.sersic_ellipse_potential import SersicEllipse return SersicEllipse() elif lens_type == 'SERSIC_ELLIPSE_KAPPA': from lenstronomy.LensModel.Profiles.sersic_ellipse_kappa import SersicEllipseKappa return SersicEllipseKappa() elif lens_type == 'SERSIC_ELLIPSE_GAUSS_DEC': from lenstronomy.LensModel.Profiles.gauss_decomposition \ import SersicEllipseGaussDec return SersicEllipseGaussDec() elif lens_type == 'PJAFFE': from lenstronomy.LensModel.Profiles.p_jaffe import PJaffe return PJaffe() elif lens_type == 'PJAFFE_ELLIPSE': from lenstronomy.LensModel.Profiles.p_jaffe_ellipse import PJaffe_Ellipse return PJaffe_Ellipse() elif lens_type == 'HERNQUIST': from lenstronomy.LensModel.Profiles.hernquist import Hernquist return Hernquist() elif lens_type == 'HERNQUIST_ELLIPSE': from lenstronomy.LensModel.Profiles.hernquist_ellipse import Hernquist_Ellipse return Hernquist_Ellipse() elif lens_type == 'GAUSSIAN': from lenstronomy.LensModel.Profiles.gaussian_potential import Gaussian return Gaussian() elif lens_type == 'GAUSSIAN_KAPPA': from lenstronomy.LensModel.Profiles.gaussian_kappa import GaussianKappa return GaussianKappa() elif lens_type == 'GAUSSIAN_ELLIPSE_KAPPA': from lenstronomy.LensModel.Profiles.gaussian_ellipse_kappa import GaussianEllipseKappa return GaussianEllipseKappa() elif lens_type == 'GAUSSIAN_ELLIPSE_POTENTIAL': from lenstronomy.LensModel.Profiles.gaussian_ellipse_potential import GaussianEllipsePotential return GaussianEllipsePotential() elif lens_type == 'MULTI_GAUSSIAN_KAPPA': from lenstronomy.LensModel.Profiles.multi_gaussian_kappa import MultiGaussianKappa return MultiGaussianKappa() elif lens_type == 'MULTI_GAUSSIAN_KAPPA_ELLIPSE': from lenstronomy.LensModel.Profiles.multi_gaussian_kappa import MultiGaussianKappaEllipse return MultiGaussianKappaEllipse() elif lens_type == 'INTERPOL': from lenstronomy.LensModel.Profiles.interpol import Interpol return Interpol() elif lens_type == 'INTERPOL_SCALED': from lenstronomy.LensModel.Profiles.interpol import InterpolScaled return InterpolScaled() elif lens_type == 'SHAPELETS_POLAR': from lenstronomy.LensModel.Profiles.shapelet_pot_polar import PolarShapelets return PolarShapelets() elif lens_type == 'SHAPELETS_CART': from lenstronomy.LensModel.Profiles.shapelet_pot_cartesian import CartShapelets return CartShapelets() elif lens_type == 'DIPOLE': from lenstronomy.LensModel.Profiles.dipole import Dipole return Dipole() elif lens_type == 'CURVED_ARC': from lenstronomy.LensModel.Profiles.curved_arc import CurvedArc return CurvedArc() elif lens_type == 'ARC_PERT': from lenstronomy.LensModel.Profiles.arc_perturbations import ArcPerturbations return ArcPerturbations() elif lens_type == 'coreBURKERT': from lenstronomy.LensModel.Profiles.coreBurkert import CoreBurkert return CoreBurkert() elif lens_type == 'CORED_DENSITY': from lenstronomy.LensModel.Profiles.cored_density import CoredDensity return CoredDensity() elif lens_type == 'CORED_DENSITY_2': from lenstronomy.LensModel.Profiles.cored_density_2 import CoredDensity2 return CoredDensity2() elif lens_type == 'CORED_DENSITY_MST': from lenstronomy.LensModel.Profiles.cored_density_mst import CoredDensityMST return CoredDensityMST(profile_type='CORED_DENSITY') elif lens_type == 'CORED_DENSITY_2_MST': from lenstronomy.LensModel.Profiles.cored_density_mst import CoredDensityMST return CoredDensityMST(profile_type='CORED_DENSITY_2') elif lens_type == 'NumericalAlpha': from lenstronomy.LensModel.Profiles.numerical_deflections import NumericalAlpha return NumericalAlpha(custom_class) else: raise ValueError('%s is not a valid lens model' % lens_type)
class TestSPEMD(object): """ tests the Gaussian methods """ def setup(self): from lenstronomy.LensModel.Profiles.spemd import SPEMD from lenstronomy.LensModel.Profiles.spep import SPEP self.SPEMD = SPEMD() self.SPEP = SPEP() def test_function(self): phi_E = 1. gamma = 1.9 q = 0.9 phi_G = 1. x = np.array([1.]) y = np.array([2]) a = np.zeros_like(x) values = self.SPEMD.function(x, y, phi_E, gamma, q, phi_G) if fastell4py_bool: assert values == 2.1567297115381039 else: assert values == 0 a += values x = np.array(1.) y = np.array(2.) a = np.zeros_like(x) values = self.SPEMD.function(x, y, phi_E, gamma, q, phi_G) print(x, values) a += values if fastell4py_bool: assert values == 2.1567297115381039 else: assert values == 0 assert type(x) == type(values) x = np.array([2, 3, 4]) y = np.array([1, 1, 1]) values = self.SPEMD.function(x, y, phi_E, gamma, q, phi_G) if fastell4py_bool: npt.assert_almost_equal(values[0], 2.1798076611034141, decimal=7) npt.assert_almost_equal(values[1], 3.209319798597186, decimal=7) npt.assert_almost_equal(values[2], 4.3105937398856398, decimal=7) else: npt.assert_almost_equal(values[0], 0, decimal=7) npt.assert_almost_equal(values[1], 0, decimal=7) npt.assert_almost_equal(values[2], 0, decimal=7) def test_derivatives(self): x = np.array([1]) y = np.array([2]) phi_E = 1. gamma = 1.9 q = 0.9 phi_G = 1. f_x, f_y = self.SPEMD.derivatives(x, y, phi_E, gamma, q, phi_G) if fastell4py_bool: npt.assert_almost_equal(f_x[0], 0.46663367437984204, decimal=7) npt.assert_almost_equal(f_y[0], 0.95307422686028065, decimal=7) else: npt.assert_almost_equal(f_x[0], 0, decimal=7) npt.assert_almost_equal(f_y[0], 0, decimal=7) x = np.array([1., 3, 4]) y = np.array([2., 1, 1]) a = np.zeros_like(x) values = self.SPEMD.derivatives(x, y, phi_E, gamma, q, phi_G) if fastell4py_bool: npt.assert_almost_equal(values[0][0], 0.46663367437984204, decimal=7) npt.assert_almost_equal(values[1][0], 0.95307422686028065, decimal=7) npt.assert_almost_equal(values[0][1], 1.0722152681324291, decimal=7) npt.assert_almost_equal(values[1][1], 0.31400298272329669, decimal=7) else: npt.assert_almost_equal(values[0][0], 0, decimal=7) npt.assert_almost_equal(values[1][0], 0, decimal=7) npt.assert_almost_equal(values[0][1], 0, decimal=7) npt.assert_almost_equal(values[1][1], 0, decimal=7) a += values[0] x = 1. y = 2. phi_E = 1. gamma = 1.9 q = 0.9 phi_G = 1. f_x, f_y = self.SPEMD.derivatives(x, y, phi_E, gamma, q, phi_G) if fastell4py_bool: npt.assert_almost_equal(f_x, 0.46663367437984204, decimal=7) npt.assert_almost_equal(f_y, 0.95307422686028065, decimal=7) else: npt.assert_almost_equal(f_x, 0, decimal=7) npt.assert_almost_equal(f_y, 0, decimal=7) x = 0. y = 0. f_x, f_y = self.SPEMD.derivatives(x, y, phi_E, gamma, q, phi_G) assert f_x == 0. assert f_y == 0. def test_hessian(self): x = np.array([1]) y = np.array([2]) phi_E = 1. gamma = 1.9 q = 0.9 phi_G = 1. f_xx, f_yy,f_xy = self.SPEMD.hessian(x, y, phi_E, gamma, q, phi_G) if fastell4py_bool: npt.assert_almost_equal(f_xx, 0.41789957732890953, decimal=7) npt.assert_almost_equal(f_yy, 0.14047593655054141, decimal=7) npt.assert_almost_equal(f_xy, -0.18560737698052343, decimal=7) else: npt.assert_almost_equal(f_xx, 0, decimal=7) npt.assert_almost_equal(f_yy, 0, decimal=7) npt.assert_almost_equal(f_xy, 0, decimal=7) x = 1. y = 2. phi_E = 1. gamma = 1.9 q = 0.9 phi_G = 1. a = np.zeros_like(x) f_xx, f_yy,f_xy = self.SPEMD.hessian(x, y, phi_E, gamma, q, phi_G) if fastell4py_bool: npt.assert_almost_equal(f_xx, 0.41789957732890953, decimal=7) npt.assert_almost_equal(f_yy, 0.14047593655054141, decimal=7) npt.assert_almost_equal(f_xy, -0.18560737698052343, decimal=7) else: npt.assert_almost_equal(f_xx, 0, decimal=7) npt.assert_almost_equal(f_yy, 0, decimal=7) npt.assert_almost_equal(f_xy, 0, decimal=7) a += f_xx x = np.array([1,3,4]) y = np.array([2,1,1]) values = self.SPEMD.hessian(x, y, phi_E, gamma, q, phi_G) print(values, 'values') if fastell4py_bool: npt.assert_almost_equal(values[0][0], 0.41789957732890953, decimal=7) npt.assert_almost_equal(values[1][0], 0.14047593655054141, decimal=7) npt.assert_almost_equal(values[2][0], -0.18560737698052343, decimal=7) npt.assert_almost_equal(values[0][1], 0.068359818958208918, decimal=7) npt.assert_almost_equal(values[1][1], 0.32494089371516482, decimal=7) npt.assert_almost_equal(values[2][1], -0.097845438684594374, decimal=7) else: npt.assert_almost_equal(values[0][0], 0, decimal=7) def test_spep_spemd(self): x = np.array([1]) y = np.array([0]) phi_E = 1. gamma = 2. q = 1. phi_G = 1. f_x, f_y = self.SPEMD.derivatives(x, y, phi_E, gamma, q, phi_G) f_x_spep, f_y_spep = self.SPEP.derivatives(x, y, phi_E, gamma, q, phi_G) if fastell4py_bool: npt.assert_almost_equal(f_x[0], f_x_spep[0], decimal=2) else: pass theta_E = 2. gamma = 2. q = 1. phi_G = 1. f_x, f_y = self.SPEMD.derivatives(x, y, theta_E, gamma, q, phi_G) f_x_spep, f_y_spep = self.SPEP.derivatives(x, y, theta_E, gamma, q, phi_G) if fastell4py_bool: npt.assert_almost_equal(f_x[0], f_x_spep[0], decimal=2) else: pass theta_E = 2. gamma = 1.7 q = 1. phi_G = 1. f_x, f_y = self.SPEMD.derivatives(x, y, theta_E, gamma, q, phi_G) f_x_spep, f_y_spep = self.SPEP.derivatives(x, y, theta_E, gamma, q, phi_G) if fastell4py_bool: npt.assert_almost_equal(f_x[0], f_x_spep[0], decimal=4)