def normalize_flux(self, kwargs_options, kwargs_source, kwargs_lens_light, kwargs_ps, norm_factor_source=1, norm_factor_lens_light=1, norm_factor_point_source=1.):
"""
multiplies the surface brightness amplitudes with a norm_factor
aim: mimic different telescopes photon collection area or colours for different imaging bands
:param kwargs_source:
:param kwargs_lens_light:
:param norm_factor:
:return:
"""
lensLightModel = LightModel(kwargs_options.get('lens_light_model_list', ['NONE']))
sourceModel = LightModel(kwargs_options.get('source_light_model_list', ['NONE']))
lensModel = LensModel(lens_model_list=kwargs_options.get('lens_model_list', ['NONE']))
pointSource = PointSource(point_source_type_list=kwargs_options.get('point_source_list', ['NONE']),
lensModel=lensModel, fixed_magnification_list=kwargs_options.get('fixed_magnification_list', [False]),
additional_images_list=kwargs_options.get('additional_images_list', [False]))
kwargs_source_updated = copy.deepcopy(kwargs_source)
kwargs_lens_light_updated = copy.deepcopy(kwargs_lens_light)
kwargs_ps_updated = copy.deepcopy(kwargs_ps)
kwargs_source_updated = sourceModel.re_normalize_flux(kwargs_source_updated, norm_factor_source)
kwargs_lens_light_updated = lensLightModel.re_normalize_flux(kwargs_lens_light_updated, norm_factor_lens_light)
kwargs_ps_updated = pointSource.re_normalize_flux(kwargs_ps_updated, norm_factor_point_source)
return kwargs_source_updated, kwargs_lens_light_updated, kwargs_ps_updated
class TestPointSource_fixed_mag(object):
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=[True]*4, additional_images_list=[False]*4)
self.kwargs_ps = [{'ra_image': self.x_pos, 'dec_image': self.y_pos, 'source_amp': 1},
{'ra_image': [1.], 'dec_image': [1.], 'point_amp': [10]},
{'ra_source': self.sourcePos_x, 'dec_source': self.sourcePos_y, 'source_amp': 1.}, {}]
def test_image_position(self):
x_image_list, y_image_list = self.PointSource.image_position(kwargs_ps=self.kwargs_ps, kwargs_lens=self.kwargs_lens)
npt.assert_almost_equal(x_image_list[0][0], self.x_pos[0], decimal=8)
npt.assert_almost_equal(x_image_list[1], 1, decimal=8)
npt.assert_almost_equal(x_image_list[2][0], self.x_pos[0], decimal=8)
def test_source_position(self):
x_source_list, y_source_list = self.PointSource.source_position(kwargs_ps=self.kwargs_ps, kwargs_lens=self.kwargs_lens)
npt.assert_almost_equal(x_source_list[0], self.sourcePos_x, decimal=8)
npt.assert_almost_equal(x_source_list[1], 1, decimal=8)
npt.assert_almost_equal(x_source_list[2], self.sourcePos_x, decimal=8)
def test_num_basis(self):
num_basis = self.PointSource.num_basis(self.kwargs_ps, self.kwargs_lens)
assert num_basis == 3
def test_linear_response_set(self):
ra_pos, dec_pos, amp, n = self.PointSource.linear_response_set(self.kwargs_ps, kwargs_lens=self.kwargs_lens, with_amp=False, k=None)
num_basis = self.PointSource.num_basis(self.kwargs_ps, self.kwargs_lens)
assert n == num_basis
assert ra_pos[0][0] == self.x_pos[0]
assert ra_pos[1][0] == 1
npt.assert_almost_equal(ra_pos[2][0], self.x_pos[0], decimal=8)
def test_point_source_list(self):
ra_list, dec_list, amp_list = self.PointSource.point_source_list(self.kwargs_ps, self.kwargs_lens)
assert ra_list[0] == self.x_pos[0]
assert len(ra_list) == 9
def test_check_image_positions(self):
bool = self.PointSource.check_image_positions(self.kwargs_ps, self.kwargs_lens, tolerance=0.001)
assert bool == True
def test_re_normalize_flux(self):
norm_factor = 10
kwargs_input = copy.deepcopy(self.kwargs_ps)
kwargs_ps = self.PointSource.re_normalize_flux(kwargs_input, norm_factor)
npt.assert_almost_equal(kwargs_ps[0]['source_amp'] / self.kwargs_ps[0]['source_amp'], norm_factor, decimal=8)
def test_set_amplitudes(self):
amp_list = [10, [100], 10]
kwargs_out = self.PointSource.set_amplitudes(amp_list, self.kwargs_ps)
assert kwargs_out[0]['source_amp'] == 10 * self.kwargs_ps[0]['source_amp']
assert kwargs_out[1]['point_amp'][0] == 10 * self.kwargs_ps[1]['point_amp'][0]
assert kwargs_out[2]['source_amp'] == 10 * self.kwargs_ps[2]['source_amp']
