def test_derivatives(self):
"""
:return:
"""
doublechameleon = DoubleChameleon()
chameleon = Chameleon()
x = np.linspace(0.1, 10, 10)
phi_G, q = 0.3, 0.8
theta_E = 1.
ratio = 2.
e1, e2 = param_util.phi_q2_ellipticity(phi_G, q)
kwargs_light = {'theta_E': 1., 'ratio': 2, 'w_c1': .5, 'w_t1': 1., 'e11': e1, 'e21': e2, 'w_c2': .1, 'w_t2': .5, 'e12': e1, 'e22': e2}
kwargs_1 = {'theta_E': theta_E / (1 + 1. / ratio), 'w_c': .5, 'w_t': 1., 'e1': e1, 'e2': e2}
kwargs_2 = {'theta_E': theta_E / (1 + ratio), 'w_c': .1, 'w_t': .5, 'e1': e1, 'e2': e2}
f_x, f_y = doublechameleon.derivatives(x=x, y=1., **kwargs_light)
f_x1, f_y1 = chameleon.derivatives(x=x, y=1., **kwargs_1)
f_x2, f_y2 = chameleon.derivatives(x=x, y=1., **kwargs_2)
npt.assert_almost_equal(f_x, f_x1 + f_x2, decimal=8)
npt.assert_almost_equal(f_y, f_y1 + f_y2, decimal=8)
def test_critical_curves_tiling(self):
lens_model_list = ['SPEP']
phi, q = 1., 0.8
e1, e2 = param_util.phi_q2_ellipticity(phi, q)
kwargs_lens = [{
'theta_E': 1.,
'gamma': 2.,
'e1': e1,
'e2': e2,
'center_x': 0,
'center_y': 0
}]
lensModel = LensModelExtensions(LensModel(lens_model_list))
ra_crit, dec_crit = lensModel.critical_curve_tiling(kwargs_lens,
compute_window=5,
start_scale=0.01,
max_order=10)
# here we test whether the caustic points are in fact at high magnifications (close to infinite)
# close here means above magnification of 1000. This is more precise than the critical_curve_caustics() method
lens_model = LensModel(lens_model_list)
mag = lens_model.magnification(ra_crit, dec_crit, kwargs_lens)
assert np.all(np.abs(mag) > 1000)
def test_derivatives(self):
"""
:return:
"""
x = np.linspace(0.1, 10, 10)
w_c, w_t = 0.5, 1.
phi_G, q = 0.3, 0.8
e1, e2 = param_util.phi_q2_ellipticity(phi_G, q)
kwargs_light = {'theta_E': 1., 'w_c': .5, 'w_t': 1., 'e1': e1, 'e2': e2}
theta_E_convert = self.chameleon._theta_E_convert(theta_E=1, w_c=0.5, w_t=1.)
s_scale_1 = np.sqrt(4 * w_c ** 2 / (1. + q) ** 2)
s_scale_2 = np.sqrt(4 * w_t ** 2 / (1. + q) ** 2)
kwargs_1 = {'theta_E': theta_E_convert, 's_scale': s_scale_1, 'e1': e1, 'e2': e2}
kwargs_2 = {'theta_E': theta_E_convert, 's_scale': s_scale_2, 'e1': e1, 'e2': e2}
f_x, f_y = self.chameleon.derivatives(x=x, y=1., **kwargs_light)
f_x_1, f_y_1 = self.nie.derivatives(x=x, y=1., **kwargs_1)
f_x_2, f_y_2 = self.nie.derivatives(x=x, y=1., **kwargs_2)
npt.assert_almost_equal(f_x, (f_x_1 - f_x_2), decimal=5)
npt.assert_almost_equal(f_y, (f_y_1 - f_y_2), decimal=5)
f_x, f_y = self.chameleon.derivatives(x=1, y=0., **kwargs_light)
npt.assert_almost_equal(f_x, 1, decimal=1)
def test_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 _update_kwargs(self, x, kwargs_list):
"""
:param x: list of parameters corresponding to the free parameter of the first lens model in the list
:param kwargs_list: list of lens model kwargs
:return: updated kwargs_list
"""
lens_model = self._lens_mode_list[0]
if self._solver_type == 'CENTER':
[center_x, center_y] = x
kwargs_list[0]['center_x'] = center_x
kwargs_list[0]['center_y'] = center_y
elif self._solver_type == 'ELLIPSE':
[e1, e2] = x
kwargs_list[0]['e1'] = e1
kwargs_list[0]['e2'] = e2
elif self._solver_type == 'SHAPELETS':
[c10, c01] = x
coeffs = list(kwargs_list[0]['coeffs'])
coeffs[1: 3] = [c10, c01]
kwargs_list[0]['coeffs'] = coeffs
elif self._solver_type == 'THETA_E_PHI':
[theta_E, phi_G] = x
kwargs_list[0]['theta_E'] = theta_E
phi_G_no_sense, gamma_ext = param_util.shear_cartesian2polar(kwargs_list[1]['gamma1'], kwargs_list[1]['gamma2'])
gamma1, gamma2 = param_util.shear_polar2cartesian(phi_G, gamma_ext)
kwargs_list[1]['gamma1'] = gamma1
kwargs_list[1]['gamma2'] = gamma2
elif self._solver_type == 'THETA_E_ELLIPSE':
[theta_E, phi_G] = x
kwargs_list[0]['theta_E'] = theta_E
phi_G_no_sense, q = param_util.ellipticity2phi_q(kwargs_list[0]['e1'], kwargs_list[0]['e2'])
e1, e2 = param_util.phi_q2_ellipticity(phi_G, q)
kwargs_list[0]['e1'] = e1
kwargs_list[0]['e2'] = e2
else:
raise ValueError("Solver type %s not supported for 2-point solver!" % self._solver_type)
return kwargs_list
def setup(self):
lensModel = LensModel(lens_model_list=['SPEP'])
solver = LensEquationSolver(lensModel=lensModel)
e1, e2 = param_util.phi_q2_ellipticity(0, 0.7)
self.kwargs_lens = [{
'theta_E': 1.,
'center_x': 0,
'center_y': 0,
'e1': e1,
'e2': e2,
'gamma': 2
}]
self.sourcePos_x, self.sourcePos_y = 0.01, -0.01
self.x_pos, self.y_pos = solver.image_position_from_source(
sourcePos_x=self.sourcePos_x,
sourcePos_y=self.sourcePos_y,
kwargs_lens=self.kwargs_lens)
self.PointSource = PointSource(
point_source_type_list=[
'LENSED_POSITION', 'UNLENSED', 'SOURCE_POSITION'
],
lensModel=lensModel,
fixed_magnification_list=[False] * 3,
additional_images_list=[False] * 4,
flux_from_point_source_list=[True, True, True])
self.kwargs_ps = [{
'ra_image': self.x_pos,
'dec_image': self.y_pos,
'point_amp': np.ones_like(self.x_pos)
}, {
'ra_image': [1.],
'dec_image': [1.],
'point_amp': [10]
}, {
'ra_source': self.sourcePos_x,
'dec_source': self.sourcePos_y,
'point_amp': np.ones_like(self.x_pos)
}, {}]
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:
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.PEMD.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.PEMD.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_function(self):
"""
:return:
"""
chameleon = Chameleon()
nie = NIE()
x = np.linspace(0.1, 10, 10)
w_c, w_t = 0.5, 1.
phi_G, q = 0.3, 0.8
e1, e2 = param_util.phi_q2_ellipticity(phi_G, q)
kwargs_light = {'amp': 1., 'w_c': .5, 'w_t': 1., 'e1': e1, 'e2': e2}
s_scale_1 = np.sqrt(4 * w_c**2 / (1. + q)**2)
s_scale_2 = np.sqrt(4 * w_t**2 / (1. + q)**2)
amp_new, w_c, w_t = chameleon._chameleonLens._theta_E_convert(
1, w_c, w_t)
kwargs_1 = {'amp': amp_new, 's_scale': s_scale_1, 'e1': e1, 'e2': e2}
kwargs_2 = {'amp': amp_new, 's_scale': s_scale_2, 'e1': e1, 'e2': e2}
flux = chameleon.function(x=x, y=1., **kwargs_light)
flux1 = nie.function(x=x, y=1., **kwargs_1)
flux2 = nie.function(x=x, y=1., **kwargs_2)
npt.assert_almost_equal(flux, (flux1 - flux2) / (1. + q), decimal=5)
def test_regularization(self):
phi_E = 1.
gamma = 2.
q = 1.
phi_G = 1.
e1, e2 = param_util.phi_q2_ellipticity(phi_G, q)
x = 0.
y = 0.
f_x, f_y = self.EPL.derivatives(x, y, phi_E, gamma, e1, e2)
npt.assert_almost_equal(f_x, 0.)
npt.assert_almost_equal(f_y, 0.)
x = 0.
y = 0.
f_xx, f_xy, f_yx, f_yy = self.EPL.hessian(x, y, phi_E, gamma, e1, e2)
assert f_xx > 10 ** 5
assert f_yy > 10 ** 5
#npt.assert_almost_equal(f_xx, 10**10)
#npt.assert_almost_equal(f_yy, 10**10)
npt.assert_almost_equal(f_xy, 0)
npt.assert_almost_equal(f_yx, 0)
def test_hessian(self):
x = np.array([1.])
y = np.array([2.])
phi_E = 1.
gamma = 2.
q = 0.9
phi_G = 1.
s_scale = 0.001
e1, e2 = param_util.phi_q2_ellipticity(phi_G, q)
f_xx, f_xy, f_yx, f_yy = self.SPEMD.hessian(x, y, phi_E, gamma, e1, e2,
s_scale)
if fastell4py_bool:
f_xx_nie, f_xy_nie, f_yx_nie, f_yy_nie = self.NIE.hessian(
x, y, phi_E, e1, e2, s_scale)
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)
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)
def test_constraint_lensmodel(self):
lens_model_list = ['SPEP', 'SIS']
lensModel = LensModel(lens_model_list)
solver = Solver(solver_type='PROFILE', lensModel=lensModel, num_images=4)
lensEquationSolver = LensEquationSolver(lensModel)
sourcePos_x = 0.1
sourcePos_y = -0.1
deltapix = 0.05
numPix = 150
gamma = 1.9
phi_G, q = 0.5, 0.8
e1, e2 = param_util.phi_q2_ellipticity(phi_G, q)
kwargs_lens = [{'theta_E': 1., 'gamma': gamma, 'e1': e1, 'e2': e2, 'center_x': 0.1, 'center_y': -0.1},
{'theta_E': 0.1, 'center_x': 0.5, 'center_y': 0}]
x_pos, y_pos = lensEquationSolver.findBrightImage(sourcePos_x, sourcePos_y, kwargs_lens, numImages=4, min_distance=deltapix, search_window=numPix*deltapix)
kwargs_lens_init = [{'theta_E': 1.3, 'gamma': gamma, 'e1': 0, 'e2': 0, 'center_x': 0., 'center_y': 0}, {'theta_E': 0.1, 'center_x': 0.5, 'center_y': 0}]
kwargs_lens_new, accuracy = solver.constraint_lensmodel(x_pos, y_pos, kwargs_lens_init)
npt.assert_almost_equal(kwargs_lens_new[0]['theta_E'], kwargs_lens[0]['theta_E'], decimal=3)
npt.assert_almost_equal(kwargs_lens_new[0]['e1'], kwargs_lens[0]['e1'], decimal=3)
npt.assert_almost_equal(kwargs_lens_new[0]['e2'], kwargs_lens[0]['e2'], decimal=3)
npt.assert_almost_equal(kwargs_lens_new[0]['center_x'], kwargs_lens[0]['center_x'], decimal=3)
npt.assert_almost_equal(kwargs_lens_new[0]['center_y'], kwargs_lens[0]['center_y'], decimal=3)
npt.assert_almost_equal(kwargs_lens_new[0]['theta_E'], 1., decimal=3)
lensModel = LensModel(lens_model_list=lens_model_list)
x_source_new, y_source_new = lensModel.ray_shooting(x_pos, y_pos, kwargs_lens_new)
dist = np.sqrt((x_source_new - x_source_new[0]) ** 2 + (y_source_new - y_source_new[0]) ** 2)
assert np.max(dist) < 0.000001
kwargs_ps4 = [{'ra_image': x_pos, 'dec_image': y_pos}]
kwargs_lens_new = solver.update_solver(kwargs_lens_init, x_pos, y_pos)
npt.assert_almost_equal(kwargs_lens_new[0]['theta_E'], kwargs_lens[0]['theta_E'], decimal=3)
npt.assert_almost_equal(kwargs_lens_new[0]['e1'], kwargs_lens[0]['e1'], decimal=3)
npt.assert_almost_equal(kwargs_lens_new[0]['e2'], kwargs_lens[0]['e2'], decimal=3)
npt.assert_almost_equal(kwargs_lens_new[0]['center_x'], kwargs_lens[0]['center_x'], decimal=3)
npt.assert_almost_equal(kwargs_lens_new[0]['center_y'], kwargs_lens[0]['center_y'], decimal=3)
def test_hessian(self):
x = np.array([1])
y = np.array([2])
sigma0 = 1.
Ra, Rs = 0.5, 0.8
q, phi_G = 0.8, 0
e1, e2 = param_util.phi_q2_ellipticity(phi_G, q)
f_xx, f_xy, f_yx, f_yy = self.profile.hessian(x,
y,
sigma0,
Ra,
Rs,
e1,
e2,
center_x=0,
center_y=0)
assert f_xx[0] == 0.064049581333103234
assert f_yy[0] == -0.054062473386906618
assert f_xy[0] == -0.060054723013958089
npt.assert_almost_equal(f_xy, f_yx, decimal=6)
x = np.array([1, 3, 4])
y = np.array([2, 1, 1])
values = self.profile.hessian(x,
y,
sigma0,
Ra,
Rs,
e1,
e2,
center_x=0,
center_y=0)
assert values[0][0] == 0.064049581333103234
assert values[3][0] == -0.054062473386906618
assert values[1][0] == -0.060054723013958089
assert values[0][1] == -0.028967667070611824
assert values[3][1] == 0.06717994677218897
assert values[1][1] == -0.04425260183293922
def test_static(self):
doublechameleon = DoubleChameleon()
x, y = 1., 1.
phi_G, q = 0.3, 0.8
e1, e2 = param_util.phi_q2_ellipticity(phi_G, q)
kwargs_light = {
'alpha_1': 1,
'ratio': 0.5,
'w_c1': .5,
'w_t1': 1.,
'e11': e1,
'e21': e2,
'w_c2': .1,
'w_t2': .5,
'e12': e1,
'e22': e2
}
f_ = doublechameleon.function(x, y, **kwargs_light)
doublechameleon.set_static(**kwargs_light)
f_static = doublechameleon.function(x, y, **kwargs_light)
npt.assert_almost_equal(f_, f_static, decimal=8)
doublechameleon.set_dynamic()
kwargs_light = {
'alpha_1': 2,
'ratio': 0.5,
'w_c1': .5,
'w_t1': 1.,
'e11': e1,
'e21': e2,
'w_c2': .1,
'w_t2': .5,
'e12': e1,
'e22': e2
}
f_dyn = doublechameleon.function(x, y, **kwargs_light)
assert f_dyn != f_static
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_hessian(self):
"""
:return:
"""
x = np.linspace(0.1, 10, 10)
w_c, w_t = 0.5, 1.
phi_G, q = 0.3, 0.8
e1, e2 = param_util.phi_q2_ellipticity(phi_G, q)
kwargs_light = {
'alpha_1': 1.,
'w_c': .5,
'w_t': 1.,
'e1': e1,
'e2': e2
}
theta_E_convert, w_c, w_t, s_scale_1, s_scale_2 = self.chameleon.param_convert(
alpha_1=1, w_c=0.5, w_t=1., e1=e1, e2=e2)
kwargs_1 = {
'theta_E': theta_E_convert,
's_scale': s_scale_1,
'e1': e1,
'e2': e2
}
kwargs_2 = {
'theta_E': theta_E_convert,
's_scale': s_scale_2,
'e1': e1,
'e2': e2
}
f_xx, f_yy, f_xy = self.chameleon.hessian(x=x, y=1., **kwargs_light)
f_xx_1, f_yy_1, f_xy_1 = self.nie.hessian(x=x, y=1., **kwargs_1)
f_xx_2, f_yy_2, f_xy_2 = self.nie.hessian(x=x, y=1., **kwargs_2)
npt.assert_almost_equal(f_xx, (f_xx_1 - f_xx_2), decimal=5)
npt.assert_almost_equal(f_yy, (f_yy_1 - f_yy_2), decimal=5)
npt.assert_almost_equal(f_xy, (f_xy_1 - f_xy_2), decimal=5)
def test_realistic_1(self):
"""
realistic test example
:return:
"""
light_profile_list = ['HERNQUIST_ELLIPSE']
phi, q = 0.74260706384506325, 0.46728323131925864
e1, e2 = param_util.phi_q2_ellipticity(phi, q)
kwargs_light = [{
'Rs': 0.10535462602138289,
'e1': e1,
'e2': e2,
'center_x': -0.02678473951679429,
'center_y': 0.88691126347462712,
'amp': 3.7114695634960109
}]
lightProfile = LightProfile(light_profile_list)
R = 0.01
light2d = lightProfile.light_2d(R=R, kwargs_list=kwargs_light)
out = integrate.quad(
lambda x: lightProfile.light_3d(np.sqrt(R**2 + x**2), kwargs_light
), 0, 100)
print(out, 'out')
npt.assert_almost_equal(light2d / (out[0] * 2), 1., decimal=3)
def test_profile_slope(self):
lens_model = LensModelExtensions(LensModel(lens_model_list=['SPP']))
gamma_in = 2.
kwargs_lens = [{'theta_E': 1., 'gamma': gamma_in, 'center_x': 0, 'center_y': 0}]
gamma_out = lens_model.profile_slope(kwargs_lens)
npt.assert_array_almost_equal(gamma_out, gamma_in, decimal=3)
gamma_in = 1.7
kwargs_lens = [{'theta_E': 1., 'gamma': gamma_in, 'center_x': 0, 'center_y': 0}]
gamma_out = lens_model.profile_slope(kwargs_lens)
npt.assert_array_almost_equal(gamma_out, gamma_in, decimal=3)
gamma_in = 2.5
kwargs_lens = [{'theta_E': 1., 'gamma': gamma_in, 'center_x': 0, 'center_y': 0}]
gamma_out = lens_model.profile_slope(kwargs_lens)
npt.assert_array_almost_equal(gamma_out, gamma_in, decimal=3)
lens_model = LensModelExtensions(LensModel(lens_model_list=['SPEP']))
gamma_in = 2.
phi, q = 0.34403343049704888, 0.89760957136967312
e1, e2 = param_util.phi_q2_ellipticity(phi, q)
kwargs_lens = [{'theta_E': 1.4516812130749424, 'e1': e1, 'e2': e2, 'center_x': -0.04507598845306314,
'center_y': 0.054491803177414651, 'gamma': gamma_in}]
gamma_out = lens_model.profile_slope(kwargs_lens)
npt.assert_array_almost_equal(gamma_out, gamma_in, decimal=3)
def test_critical_curves(self):
lens_model_list = ['SPEP']
phi, q = 1., 0.8
e1, e2 = param_util.phi_q2_ellipticity(phi, q)
kwargs_lens = [{
'theta_E': 1.,
'gamma': 2.,
'e1': e1,
'e2': e2,
'center_x': 0,
'center_y': 0
}]
lens_model = LensModel(lens_model_list)
lensModelExtensions = LensModelExtensions(LensModel(lens_model_list))
ra_crit_list, dec_crit_list, ra_caustic_list, dec_caustic_list = lensModelExtensions.critical_curve_caustics(
kwargs_lens, compute_window=5, grid_scale=0.005)
# here we test whether the caustic points are in fact at high magnifications (close to infinite)
# close here means above magnification of 1000000 (with matplotlib method, this limit achieved was 170)
for k in range(len(ra_crit_list)):
ra_crit = ra_crit_list[k]
dec_crit = dec_crit_list[k]
mag = lens_model.magnification(ra_crit, dec_crit, kwargs_lens)
assert np.all(np.abs(mag) > 100000)
def test_function(self):
"""
:return:
"""
doublechameleon = DoubleChameleonPointMass()
phi_G, q = 0.3, 0.8
e1, e2 = param_util.phi_q2_ellipticity(phi_G, q)
kwargs_light = {
'theta_E': 1.,
'ratio_pointmass': 3,
'ratio_chameleon': 2,
'w_c1': .5,
'w_t1': 1.,
'e11': e1,
'e21': e2,
'w_c2': .1,
'w_t2': .5,
'e12': e1,
'e22': e2
}
flux = doublechameleon.function(x=1, y=1., **kwargs_light)
npt.assert_almost_equal(flux, 1.2324939073557235, decimal=4)
def test_hessian(self):
"""
:return:
"""
doublechameleon = DoubleChameleon()
chameleon = Chameleon()
x = np.linspace(0.1, 10, 10)
phi_G, q = 0.3, 0.8
theta_E = 1.
ratio = 2.
e1, e2 = param_util.phi_q2_ellipticity(phi_G, q)
kwargs_lens = {
'theta_E': theta_E,
'ratio': ratio,
'w_c1': .5,
'w_t1': 1.,
'e11': e1,
'e21': e2,
'w_c2': .1,
'w_t2': .5,
'e12': e1,
'e22': e2
}
kwargs_light = {
'amp': theta_E,
'ratio': ratio,
'w_c1': .5,
'w_t1': 1.,
'e11': e1,
'e21': e2,
'w_c2': .1,
'w_t2': .5,
'e12': e1,
'e22': e2
}
kwargs_1 = {
'theta_E': theta_E / (1 + 1. / ratio),
'w_c': .5,
'w_t': 1.,
'e1': e1,
'e2': e2
}
kwargs_2 = {
'theta_E': theta_E / (1 + ratio),
'w_c': .1,
'w_t': .5,
'e1': e1,
'e2': e2
}
f_xx, f_yy, f_xy = doublechameleon.hessian(x=x, y=1., **kwargs_lens)
f_xx1, f_yy1, f_xy1 = chameleon.hessian(x=x, y=1., **kwargs_1)
f_xx2, f_yy2, f_xy2 = chameleon.hessian(x=x, y=1., **kwargs_2)
npt.assert_almost_equal(f_xx, f_xx1 + f_xx2, decimal=8)
npt.assert_almost_equal(f_yy, f_yy1 + f_yy2, decimal=8)
npt.assert_almost_equal(f_xy, f_xy1 + f_xy2, decimal=8)
light = DoubleChameleonLight()
f_xx, f_yy, f_xy = doublechameleon.hessian(x=np.linspace(0, 1, 10),
y=np.zeros(10),
**kwargs_lens)
kappa = 1. / 2 * (f_xx + f_yy)
kappa_norm = kappa / np.mean(kappa)
flux = light.function(x=np.linspace(0, 1, 10),
y=np.zeros(10),
**kwargs_light)
flux_norm = flux / np.mean(flux)
npt.assert_almost_equal(kappa_norm, flux_norm, decimal=5)
def setup(self):
# data specifics
sigma_bkg = .05 # background noise per pixel
exp_time = 100 # exposure time (arbitrary units, flux per pixel is in units #photons/exp_time unit)
numPix = 100 # cutout pixel size
deltaPix = 0.05 # pixel size in arcsec (area per pixel = deltaPix**2)
fwhm = 0.5 # full width half max of PSF
# PSF specification
kwargs_data = sim_util.data_configure_simple(numPix, deltaPix,
exp_time, sigma_bkg)
data_class = ImageData(**kwargs_data)
kwargs_psf = {'psf_type': 'GAUSSIAN', 'fwhm': fwhm, 'truncation': 5}
psf_class = PSF(**kwargs_psf)
# 'EXERNAL_SHEAR': external shear
kwargs_shear = {
'gamma1': 0.01,
'gamma2': 0.01
} # gamma_ext: shear strength, psi_ext: shear angel (in radian)
phi, q = 0.2, 0.8
e1, e2 = param_util.phi_q2_ellipticity(phi, q)
kwargs_spemd = {
'theta_E': 1.,
'gamma': 1.8,
'center_x': 0,
'center_y': 0,
'e1': e1,
'e2': e2
}
lens_model_list = ['SPEP', 'SHEAR']
self.kwargs_lens = [kwargs_spemd, kwargs_shear]
lens_model_class = LensModel(lens_model_list=lens_model_list)
# list of light profiles (for lens and source)
# 'SERSIC': spherical Sersic profile
kwargs_sersic = {
'amp': 1.,
'R_sersic': 0.1,
'n_sersic': 2,
'center_x': 0,
'center_y': 0
}
# 'SERSIC_ELLIPSE': elliptical Sersic profile
phi, q = 0.2, 0.9
e1, e2 = param_util.phi_q2_ellipticity(phi, q)
kwargs_sersic_ellipse = {
'amp': 1.,
'R_sersic': .6,
'n_sersic': 7,
'center_x': 0,
'center_y': 0,
'e1': e1,
'e2': e2
}
lens_light_model_list = ['SERSIC']
self.kwargs_lens_light = [kwargs_sersic]
lens_light_model_class = LightModel(
light_model_list=lens_light_model_list)
source_model_list = ['SERSIC_ELLIPSE']
self.kwargs_source = [kwargs_sersic_ellipse]
source_model_class = LightModel(light_model_list=source_model_list)
self.kwargs_ps = [
{
'ra_source': 0.0001,
'dec_source': 0.0,
'source_amp': 1.
}
] # quasar point source position in the source plane and intrinsic brightness
point_source_class = PointSource(
point_source_type_list=['SOURCE_POSITION'],
fixed_magnification_list=[True])
kwargs_numerics = {
'supersampling_factor': 2,
'supersampling_convolution': True
}
imageModel = ImageModel(data_class,
psf_class,
lens_model_class,
source_model_class,
lens_light_model_class,
point_source_class,
kwargs_numerics=kwargs_numerics)
image_sim = sim_util.simulate_simple(imageModel, self.kwargs_lens,
self.kwargs_source,
self.kwargs_lens_light,
self.kwargs_ps)
data_class.update_data(image_sim)
kwargs_data['image_data'] = image_sim
self.solver = LensEquationSolver(lensModel=lens_model_class)
multi_band_list = [[kwargs_data, kwargs_psf, kwargs_numerics],
[kwargs_data, kwargs_psf, kwargs_numerics]]
kwargs_model = {
'lens_model_list': lens_model_list,
'source_light_model_list': source_model_list,
'point_source_model_list': ['SOURCE_POSITION'],
'fixed_magnification_list': [True],
'lens_light_model_list': lens_light_model_list
}
self.imageModel = JointLinear(multi_band_list, kwargs_model)
def generate_lens(sigma_bkg=sigma_bkg,
exp_time=exp_time,
numPix=numPix,
deltaPix=deltaPix,
fwhm=fwhm,
psf_type=psf_type,
kernel_size=kernel_size,
z_source=z_source,
z_lens=z_lens,
phi_ext=phi_ext,
gamma_ext=gamma_ext,
theta_E=theta_E,
gamma_lens=gamma_lens,
e1_lens=e1_lens,
e2_lens=e2_lens,
center_x_lens_light=center_x_lens_light,
center_y_lens_light=center_y_lens_light,
source_x=source_y,
source_y=source_y,
q_source=q_source,
phi_source=phi_source,
center_x=center_x,
center_y=center_y,
amp_source=amp_source,
R_sersic_source=R_sersic_source,
n_sersic_source=n_sersic_source,
phi_lens_light=phi_lens_light,
q_lens_light=q_lens_light,
amp_lens=amp_lens,
R_sersic_lens=R_sersic_lens,
n_sersic_lens=n_sersic_lens,
amp_ps=amp_ps,
supersampling_factor=supersampling_factor,
v_min=v_min,
v_max=v_max,
cosmo=cosmo,
cosmo2=cosmo2,
lens_pos_eq_lens_light_pos=True,
same_cosmology=True):
kwargs_data = sim_util.data_configure_simple(numPix, deltaPix, exp_time,
sigma_bkg)
data_class = ImageData(**kwargs_data)
kwargs_psf = {'psf_type': psf_type, 'pixel_size': deltaPix, 'fwhm': fwhm}
psf_class = PSF(**kwargs_psf)
cosmo = FlatLambdaCDM(H0=75, Om0=0.3, Ob0=0.)
cosmo = FlatLambdaCDM(H0=65, Om0=0.3, Ob0=0.)
gamma1, gamma2 = param_util.shear_polar2cartesian(phi=phi_ext,
gamma=gamma_ext)
kwargs_shear = {'gamma1': gamma1, 'gamma2': gamma2}
if lens_pos_eq_lens_light_pos:
center_x = center_x_lens_light
center_y = center_y_lens_light
if same_cosmology:
cosmo2 = cosmo
kwargs_spemd = {
'theta_E': theta_E,
'gamma': gamma_lens,
'center_x': center_x,
'center_y': center_y,
'e1': e1_lens,
'e2': e2_lens
}
lens_model_list = ['SPEP', 'SHEAR']
kwargs_lens = [kwargs_spemd, kwargs_shear]
lens_model_class = LensModel(lens_model_list=lens_model_list,
z_lens=z_lens,
z_source=z_source,
cosmo=cosmo)
lens_model_class2 = LensModel(lens_model_list=lens_model_list,
z_lens=z_lens,
z_source=z_source,
cosmo=cosmo2)
e1_source, e2_source = param_util.phi_q2_ellipticity(phi_source, q_source)
kwargs_sersic_source = {
'amp': amp_source,
'R_sersic': R_sersic_source,
'n_sersic': n_sersic_source,
'e1': e1_source,
'e2': e2_source,
'center_x': source_x,
'center_y': source_y
}
source_model_list = ['SERSIC_ELLIPSE']
kwargs_source = [kwargs_sersic_source]
source_model_class = LightModel(light_model_list=source_model_list)
##
e1_lens_light, e2_lens_light = param_util.phi_q2_ellipticity(
phi_lens_light, q_lens_light)
kwargs_sersic_lens = {
'amp': amp_lens,
'R_sersic': R_sersic_lens,
'n_sersic': n_sersic_lens,
'e1': e1_lens_light,
'e2': e2_lens_light,
'center_x': center_x_lens_light,
'center_y': center_y_lens_light
}
lens_light_model_list = ['SERSIC_ELLIPSE']
kwargs_lens_light = [kwargs_sersic_lens]
lens_light_model_class = LightModel(light_model_list=lens_light_model_list)
##
lensEquationSolver = LensEquationSolver(lens_model_class)
x_image, y_image = lensEquationSolver.findBrightImage(
source_x,
source_y, #position of ps
kwargs_lens, #lens proporties
numImages=4, #expected number of images
min_distance=deltaPix, #'resolution'
search_window=numPix * deltaPix) #search window limits
mag = lens_model_class.magnification(
x_image,
y_image, #for found above ps positions
kwargs=kwargs_lens) # and same lens properties
kwargs_ps = [{
'ra_image': x_image,
'dec_image': y_image,
'point_amp': np.abs(mag) * amp_ps
}]
point_source_list = ['LENSED_POSITION']
point_source_class = PointSource(point_source_type_list=point_source_list,
fixed_magnification_list=[False])
kwargs_numerics = {'supersampling_factor': supersampling_factor}
imageModel = ImageModel(
data_class, # take generated above data specs
psf_class, # same for psf
lens_model_class, # lens model (gal+ext)
source_model_class, # sourse light model
lens_light_model_class, # lens light model
point_source_class, # add generated ps images
kwargs_numerics=kwargs_numerics)
image_sim = imageModel.image(kwargs_lens, kwargs_source, kwargs_lens_light,
kwargs_ps)
poisson = image_util.add_poisson(image_sim, exp_time=exp_time)
bkg = image_util.add_background(image_sim, sigma_bkd=sigma_bkg)
image_sim = image_sim + bkg + poisson
data_class.update_data(image_sim)
kwargs_data['image_data'] = image_sim
cmap_string = 'gray'
cmap = plt.get_cmap(cmap_string)
cmap.set_bad(color='b', alpha=1.)
cmap.set_under('k')
f, axes = plt.subplots(1, 1, figsize=(6, 6), sharex=False, sharey=False)
ax = axes
im = ax.matshow(np.log10(image_sim),
origin='lower',
vmin=v_min,
vmax=v_max,
cmap=cmap,
extent=[0, 1, 0, 1])
ax.get_xaxis().set_visible(False)
ax.get_yaxis().set_visible(False)
ax.autoscale(False)
plt.show()
kwargs_model = {
'lens_model_list': lens_model_list,
'lens_light_model_list': lens_light_model_list,
'source_light_model_list': source_model_list,
'point_source_model_list': point_source_list
}
from lenstronomy.Analysis.td_cosmography import TDCosmography
td_cosmo = TDCosmography(z_lens,
z_source,
kwargs_model,
cosmo_fiducial=cosmo)
# time delays, the unit [days] is matched when the lensing angles are in arcsec
t_days = td_cosmo.time_delays(kwargs_lens, kwargs_ps, kappa_ext=0)
dt_days = t_days[1:] - t_days[0]
dt_sigma = [3, 5, 10] # Gaussian errors
dt_measured = np.random.normal(dt_days, dt_sigma)
print("the measured relative delays are: ", dt_measured)
return f, source_model_list, kwargs_data, kwargs_psf, kwargs_numerics, dt_measured, dt_sigma, kwargs_ps, lens_model_list, lens_light_model_list, source_model_list, point_source_list, lens_model_class2
class Lens0712(Quad):
x = np.array([-0.785, -0.729, 0.027, 0.389])
y = np.array([-0.142, -0.298, -0.805, 0.317])
m = np.array([1., 0.843, 0.418, 0.082])
sigma_x = np.array([0.005]*4)
sigma_y = np.array([0.005]*4)
sigma_m = np.zeros_like(sigma_x)
zlens, zsrc = 0.5, 1.5
data = Data(x, y, m, None, None,
sigma_x = sigma_x, sigma_y = sigma_y,
sigma_m=sigma_m)
identifier = 'lens0712'
flux_ratio_index = 0
fluximg = ['A', 'B', 'C', 'D'][flux_ratio_index]
_macromodel = get_default_SIE(zlens)
_macromodel.lenstronomy_args['theta_E'] = approx_theta_E(x, y)
gamma_min = 1.9
gamma_max = 2.2
srcmin = 0.001
srcmax = 0.02
satellite_mass_model = ['SERSIC_ELLIPSE_GAUSS_DEC']
# from mass center
satellite_pos_mass = np.array([0, 0])
disk_q, disk_angle = 0.23, 90 - 59.7
disk_angle *= np.pi / 180
disk_angle *= np.pi / 180
e1_disk, e2_disk = phi_q2_ellipticity(disk_angle, disk_q)
satellite_kwargs = [{'k_eff': 0.294, 'R_sersic': 0.389, 'n_sersic': 1, 'e1': e1_disk,
'e2': e2_disk, 'center_x':satellite_pos_mass[0], 'center_y':satellite_pos_mass[1]}]
def optimize_fit(self, kwargs_fit={}, macro_init = None, print_output = False):
if 'datatofit' in kwargs_fit.keys():
data = kwargs_fit['datatofit']
del kwargs_fit['datatofit']
else:
data = self.data
satellites = {}
satellites['lens_model_name'] = self.satellite_mass_model
satellites['z_satellite'] = [self.zlens]
satellites['kwargs_satellite'] = self.satellite_kwargs
kwargs_fit.update({'satellites': satellites})
optdata, optmodel = self._fit(data, self.solver, kwargs_fit, macromodel_init=macro_init)
if print_output:
self._print_output(optdata[0], optmodel[0])
return optdata[0], optmodel[0]
def optimize_fit_lensmodel(self, kwargs_fit={}, macro_init = None, print_output = False):
kwargs_fit.update({'identifier': self.identifier})
optdata, optmodel = self._fit_lensmodel(self.data, self.solver, kwargs_fit, macromodel_init=macro_init)
if print_output:
self._print_output(optdata[0], optmodel[0])
return optdata[0], optmodel[0]
def _print_output(self, optdata, optmodel):
macromodel = optmodel.lens_components[0]
print('optimized mags: ', optdata.m)
print('observed mags: ', self.data.m)
print('lensmodel fit: ')
print('Einstein radius: ', macromodel.lenstronomy_args['theta_E'])
print('shear, shear_theta:', macromodel.shear, macromodel.shear_theta)
print('ellipticity, PA:', macromodel.ellip_PA_polar()[0], macromodel.ellip_PA_polar()[1])
print('centroid: ', macromodel.lenstronomy_args['center_x'],
macromodel.lenstronomy_args['center_y'])
print('\n')
print('flux ratios w.r.t. image '+str(self.fluximg)+':')
print('observed: ', self.data.compute_flux_ratios(index=self.flux_ratio_index))
print('recovered: ', optdata.compute_flux_ratios(index=self.flux_ratio_index))
print(seed)
para=gene_para(seed=seed,fixh0=102)
#==============================================================================
# #######lens light
#==============================================================================
from lenstronomy.LightModel.light_model import LightModel
lens_light_para=para.lens_light()
np.random.seed(seed)
import magVSamp as mva
lens_light_para['q'] = 0.9 + np.random.normal(0,0.01)
lens_light_tran_Reff=lens_light_para['R_sersic']/np.sqrt(lens_light_para['q']) #!!!
#lens_light_tran_Reff = 1.1
lens_light_para['e1'], lens_light_para['e2'] = param_util.phi_q2_ellipticity(phi=lens_light_para['phi_G'], q=lens_light_para['q'])
lens_amp=mva.getAmp_lenstronomy(SERSIC_in_mag=lens_light_para,zp=zp)
lens_light_para['amp_sersic']=lens_amp
lens_light_model_list = ['SERSIC_ELLIPSE']
kwargs_lens_light = {'amp':lens_light_para['amp_sersic'], 'R_sersic': lens_light_tran_Reff, 'n_sersic': lens_light_para['n_sersic'],
'center_x': 0.0, 'center_y': 0.0, 'e1':lens_light_para['e1'], 'e2':lens_light_para['e2']}
kwargs_lens_light_copy = copy.deepcopy(kwargs_lens_light)
kwargs_lens_light_copy['phi_G'] = lens_light_para['phi_G']
kwargs_lens_light_copy['q'] = lens_light_para['q']
lens_light_para['amp_sersic'] = 1
light = LightModel(['SERSIC_ELLIPSE'])
total_flux_testamp1 = light.total_flux([kwargs_lens_light]) #The total flux for each sersic components as list
flux_should = 10.**(-0.4*(lens_light_para['mag_sersic']-zp))
def setup(self):
# data specifics
sigma_bkg = 0.01 # background noise per pixel
exp_time = 100 # exposure time (arbitrary units, flux per pixel is in units #photons/exp_time unit)
numPix = 100 # cutout pixel size
deltaPix = 0.05 # pixel size in arcsec (area per pixel = deltaPix**2)
fwhm = 0.3 # full width half max of PSF
# PSF specification
kwargs_data = sim_util.data_configure_simple(numPix, deltaPix, exp_time, sigma_bkg)
data_class = Data(kwargs_data)
sigma = util.fwhm2sigma(fwhm)
x_grid, y_grid = util.make_grid(numPix=31, deltapix=0.05)
from lenstronomy.LightModel.Profiles.gaussian import Gaussian
gaussian = Gaussian()
kernel_point_source = gaussian.function(x_grid, y_grid, amp=1., sigma_x=sigma, sigma_y=sigma,
center_x=0, center_y=0)
kernel_point_source /= np.sum(kernel_point_source)
kernel_point_source = util.array2image(kernel_point_source)
self.kwargs_psf = {'psf_type': 'PIXEL', 'kernel_point_source': kernel_point_source}
psf_class = PSF(kwargs_psf=self.kwargs_psf)
# 'EXERNAL_SHEAR': external shear
kwargs_shear = {'e1': 0.01, 'e2': 0.01} # gamma_ext: shear strength, psi_ext: shear angel (in radian)
phi, q = 0.2, 0.8
e1, e2 = param_util.phi_q2_ellipticity(phi, q)
kwargs_spemd = {'theta_E': 1., 'gamma': 1.8, 'center_x': 0, 'center_y': 0, 'e1': e1, 'e2': e2}
lens_model_list = ['SPEP', 'SHEAR']
self.kwargs_lens = [kwargs_spemd, kwargs_shear]
lens_model_class = LensModel(lens_model_list=lens_model_list)
# list of light profiles (for lens and source)
# 'SERSIC': spherical Sersic profile
kwargs_sersic = {'amp': 1., 'R_sersic': 0.1, 'n_sersic': 2, 'center_x': 0, 'center_y': 0}
# 'SERSIC_ELLIPSE': elliptical Sersic profile
phi, q = 0.2, 0.9
e1, e2 = param_util.phi_q2_ellipticity(phi, q)
kwargs_sersic_ellipse = {'amp': 1., 'R_sersic': .6, 'n_sersic': 7, 'center_x': 0, 'center_y': 0,
'e1': e1, 'e2': e2}
lens_light_model_list = ['SERSIC']
self.kwargs_lens_light = [kwargs_sersic]
lens_light_model_class = LightModel(light_model_list=lens_light_model_list)
source_model_list = ['SERSIC_ELLIPSE']
self.kwargs_source = [kwargs_sersic_ellipse]
source_model_class = LightModel(light_model_list=source_model_list)
self.kwargs_ps = [{'ra_source': 0.0, 'dec_source': 0.0,
'source_amp': 10.}] # quasar point source position in the source plane and intrinsic brightness
point_source_class = PointSource(point_source_type_list=['SOURCE_POSITION'], fixed_magnification_list=[True])
kwargs_numerics = {'subgrid_res': 3, 'psf_subgrid': True}
imageModel = ImageModel(data_class, psf_class, lens_model_class, source_model_class,
lens_light_model_class,
point_source_class, kwargs_numerics=kwargs_numerics)
image_sim = sim_util.simulate_simple(imageModel, self.kwargs_lens, self.kwargs_source,
self.kwargs_lens_light, self.kwargs_ps)
data_class.update_data(image_sim)
self.imageModel = ImageModel(data_class, psf_class, lens_model_class, source_model_class,
lens_light_model_class,
point_source_class, kwargs_numerics=kwargs_numerics)
self.psf_fitting = PsfFitting(self.imageModel)
def test_all_spep(self):
lensModel = LensModel(['SPEP'])
solver_spep_center = Solver2Point(lensModel, solver_type='CENTER')
solver_spep_ellipse = Solver2Point(lensModel, solver_type='ELLIPSE')
image_position_spep = LensEquationSolver(lensModel)
sourcePos_x = 0.1
sourcePos_y = 0.03
gamma = 1.9
phi_G, q = 0.5, 0.8
e1, e2 = param_util.phi_q2_ellipticity(phi_G, q)
kwargs_lens = [{
'theta_E': 1,
'gamma': gamma,
'e1': e1,
'e2': e2,
'center_x': 0.1,
'center_y': -0.1
}]
x_pos, y_pos = image_position_spep.findBrightImage(
sourcePos_x,
sourcePos_y,
kwargs_lens,
numImages=2,
min_distance=0.01,
search_window=5,
precision_limit=10**(-10),
num_iter_max=10)
print(x_pos, y_pos, 'test')
x_pos = x_pos[:2]
y_pos = y_pos[:2]
kwargs_init = [{
'theta_E': 1,
'gamma': gamma,
'e1': e1,
'e2': e2,
'center_x': 0,
'center_y': 0
}]
kwargs_out_center, precision = solver_spep_center.constraint_lensmodel(
x_pos, y_pos, kwargs_init)
kwargs_init = [{
'theta_E': 1,
'gamma': gamma,
'e1': 0,
'e2': 0,
'center_x': 0.1,
'center_y': -0.1
}]
kwargs_out_ellipse, precision = solver_spep_ellipse.constraint_lensmodel(
x_pos, y_pos, kwargs_init)
npt.assert_almost_equal(kwargs_out_center[0]['center_x'],
kwargs_lens[0]['center_x'],
decimal=3)
npt.assert_almost_equal(kwargs_out_center[0]['center_y'],
kwargs_lens[0]['center_y'],
decimal=3)
npt.assert_almost_equal(kwargs_out_center[0]['center_y'],
-0.1,
decimal=3)
npt.assert_almost_equal(kwargs_out_ellipse[0]['e1'],
kwargs_lens[0]['e1'],
decimal=3)
npt.assert_almost_equal(kwargs_out_ellipse[0]['e2'],
kwargs_lens[0]['e2'],
decimal=3)
npt.assert_almost_equal(kwargs_out_ellipse[0]['e1'], e1, decimal=3)
orientdiff = orientdiff+180
print (pahst, pasdss, orientdiff)
phi0new = (phi0-orientdiff)
if phi0new > 360:
phi0new = phi0new-360
phi1new = (phi1-orientdiff)
if phi1new > 360:
phi1new = phi1new-360
phi2new = (phi2-orientdiff)
if phi2new > 360:
phi1new = phi2new-360
phi0final = np.radians(-1*(phi0new-90))
phi1final = np.radians(-1*(phi1new-90))
phi2final = np.radians(-1*(phi2new-90))
print (phi1, phi1new, phi1final, orientdiff)
e1bulge, e2bulge = param_util.phi_q2_ellipticity(phi0final, q0)
e1disk, e2disk = param_util.phi_q2_ellipticity(phi1final, q1)
e1bar, e2bar = param_util.phi_q2_ellipticity(phi2final, q2)
obj = '{0}'.format(ID)
ID = 'L{0}'.format(ID) # Object ID
deep_seed = False # False = trial run
no_MCMC = True # True = without MCMC
mpi_para = False
pltshow = 0 #Change to 1 to show the plot while fitting.
pix_sz = 0.396 # The pixel scale of the SDSS images
exp_time = 53.91 #Exposure time in seconds of the SDSS images
lowerpos = -3*pix_sz #lower limit offset in x
upperpos = 3*pix_sz #lower limit offset in y
spreadx = 2*pix_sz #spread in x
spready = 2*pix_sz #spread in y
def test_all_nfw(self):
lensModel = LensModel(['SPEP'])
solver_nfw_ellipse = Solver2Point(lensModel, solver_type='ELLIPSE')
solver_nfw_center = Solver2Point(lensModel, solver_type='CENTER')
spep = LensModel(['SPEP'])
image_position_nfw = LensEquationSolver(LensModel(['SPEP', 'NFW']))
sourcePos_x = 0.1
sourcePos_y = 0.03
deltapix = 0.05
numPix = 100
gamma = 1.9
Rs = 0.1
nfw = NFW()
alpha_Rs = nfw._rho02alpha(1., Rs)
phi_G, q = 0.5, 0.8
e1, e2 = param_util.phi_q2_ellipticity(phi_G, q)
kwargs_lens = [{
'theta_E': 1.,
'gamma': gamma,
'e1': e1,
'e2': e2,
'center_x': 0.1,
'center_y': -0.1
}, {
'Rs': Rs,
'alpha_Rs': alpha_Rs,
'center_x': -0.5,
'center_y': 0.5
}]
x_pos, y_pos = image_position_nfw.findBrightImage(
sourcePos_x,
sourcePos_y,
kwargs_lens,
numImages=2,
min_distance=deltapix,
search_window=numPix * deltapix)
print(len(x_pos), 'number of images')
x_pos = x_pos[:2]
y_pos = y_pos[:2]
kwargs_init = [{
'theta_E': 1,
'gamma': gamma,
'e1': e1,
'e2': e2,
'center_x': 0.,
'center_y': 0
}, {
'Rs': Rs,
'alpha_Rs': alpha_Rs,
'center_x': -0.5,
'center_y': 0.5
}]
kwargs_out_center, precision = solver_nfw_center.constraint_lensmodel(
x_pos, y_pos, kwargs_init)
source_x, source_y = spep.ray_shooting(x_pos[0], y_pos[0],
kwargs_out_center)
x_pos_new, y_pos_new = image_position_nfw.findBrightImage(
source_x,
source_y,
kwargs_out_center,
numImages=2,
min_distance=deltapix,
search_window=numPix * deltapix)
print(kwargs_out_center, 'kwargs_out_center')
npt.assert_almost_equal(x_pos_new[0], x_pos[0], decimal=2)
npt.assert_almost_equal(y_pos_new[0], y_pos[0], decimal=2)
npt.assert_almost_equal(kwargs_out_center[0]['center_x'],
kwargs_lens[0]['center_x'],
decimal=2)
npt.assert_almost_equal(kwargs_out_center[0]['center_y'],
kwargs_lens[0]['center_y'],
decimal=2)
npt.assert_almost_equal(kwargs_out_center[0]['center_y'],
-0.1,
decimal=2)
kwargs_init = [{
'theta_E': 1.,
'gamma': gamma,
'e1': 0,
'e2': 0,
'center_x': 0.1,
'center_y': -0.1
}, {
'Rs': Rs,
'alpha_Rs': alpha_Rs,
'center_x': -0.5,
'center_y': 0.5
}]
kwargs_out_ellipse, precision = solver_nfw_ellipse.constraint_lensmodel(
x_pos, y_pos, kwargs_init)
npt.assert_almost_equal(kwargs_out_ellipse[0]['e1'],
kwargs_lens[0]['e1'],
decimal=2)
npt.assert_almost_equal(kwargs_out_ellipse[0]['e2'],
kwargs_lens[0]['e2'],
decimal=2)
npt.assert_almost_equal(kwargs_out_ellipse[0]['e1'], e1, decimal=2)
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 sample(self):
"""Gets kwargs of sampled parameters to be passed to lenstronomy
Returns
-------
dict
dictionary of config-specified components (e.g. lens mass), itself
a dictionary of sampled parameters corresponding to the config-specified
profile of that component
"""
kwargs = Dict()
# Sample redshifts
z_lens, z_src = self.sample_redshifts(redshifts_cfg=self.redshift)
# Sample velocity dispersion
vel_disp_iso = self.sample_vel_disp(vel_disp_cfg=self.kinematics.vel_disp)
# Sample lens_mass and lens_light parameters
abmag_lens = self.get_lens_absolute_magnitude(vel_disp_iso)
apmag_lens = self.get_lens_apparent_magnitude(abmag_lens, z_lens)
theta_E = self.theta_E_model(vel_disp_iso, z_lens, z_src, self.cosmo)
R_eff_lens, r_eff_lens = self.get_lens_size(vel_disp_iso, z_lens, apmag_lens)
gamma = self.gamma_model(R_eff_lens)
lens_light_q = self.lens_axis_ratio_model(vel_disp_iso)
kwargs['lens_mass'] = dict(
theta_E=theta_E,
gamma=gamma,
)
kwargs['lens_light'] = dict(
magnitude=apmag_lens,
R_sersic=r_eff_lens,
q=lens_light_q,
)
kwargs['external_shear'] = {}
# Sample src_light parameters
abmag_src = self.get_src_absolute_magnitude(z_src)
apmag_src = self.get_src_apparent_magnitude(abmag_src, z_src)
R_eff_src, r_eff_src = self.get_src_size(z_src, abmag_src)
kwargs['src_light'] = dict(
magnitude=apmag_src,
R_sersic=r_eff_src,
)
# Sample AGN_light parameters
if 'agn_light' in self.components:
abmag_agn = self.get_agn_absolute_magnitude(z_src)
apmag_agn = self.get_src_apparent_magnitude(abmag_agn, z_src)
kwargs['agn_light'] = dict(
magnitude=apmag_agn,
)
# Miscellaneous other parameters to export
kwargs['misc'] = dict(
z_lens=z_lens,
z_src=z_src,
vel_disp_iso=vel_disp_iso,
lens_light_R_eff=R_eff_lens,
src_light_R_eff=R_eff_src,
lens_light_abmag=abmag_lens,
src_light_abmag=abmag_src,
)
# Sample remaining parameters, not constrained by the above empirical relations,
# independently from their (marginally) diagonal BNN prior
for comp, param_name in self.params_to_realize:
hyperparams = getattr(self, comp)[param_name].copy()
kwargs[comp][param_name] = self.sample_param(hyperparams)
# Convert any q, phi into e1, e2 as required by lenstronomy
for comp in self.comps_qphi_to_e1e2: # e.g. 'lens_mass'
q = kwargs[comp].pop('q')
phi = kwargs[comp].pop('phi')
e1, e2 = param_util.phi_q2_ellipticity(phi, q)
kwargs[comp]['e1'] = e1
kwargs[comp]['e2'] = e2
# Source pos is defined wrt the lens pos
kwargs['src_light']['center_x'] += kwargs['lens_mass']['center_x']
kwargs['src_light']['center_y'] += kwargs['lens_mass']['center_y']
# Ext shear is defined wrt the lens center
kwargs['external_shear']['ra_0'] = kwargs['lens_mass']['center_x']
kwargs['external_shear']['dec_0'] = kwargs['lens_mass']['center_y']
if 'lens_light' in self.components:
# Lens light shares center with lens mass
kwargs['lens_light']['center_x'] = kwargs['lens_mass']['center_x']
kwargs['lens_light']['center_y'] = kwargs['lens_mass']['center_y']
return kwargs
