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)
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!')
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)