def findBrightImage(self,
sourcePos_x,
sourcePos_y,
kwargs_lens,
numImages=4,
min_distance=0.01,
search_window=5,
precision_limit=10**(-10),
num_iter_max=10):
"""
:param sourcePos_x:
:param sourcePos_y:
:param deltapix:
:param numPix:
:param magThresh: magnification threshold for images to be selected
:param numImage: number of selected images (will select the highest magnified ones)
:param kwargs_lens:
:return:
"""
x_mins, y_mins = self.image_position_from_source(
sourcePos_x, sourcePos_y, kwargs_lens, min_distance, search_window,
precision_limit, num_iter_max)
mag_list = []
for i in range(len(x_mins)):
mag = self.lensModel.magnification(x_mins[i], y_mins[i],
kwargs_lens)
mag_list.append(abs(mag))
mag_list = np.array(mag_list)
x_mins_sorted = util.selectBest(x_mins, mag_list, numImages)
y_mins_sorted = util.selectBest(y_mins, mag_list, numImages)
return x_mins_sorted, y_mins_sorted
def test_raise(self):
with self.assertRaises(ValueError):
array = np.ones(5)
util.array2image(array)
with self.assertRaises(ValueError):
array = np.ones((2, 2))
util.array2cube(array, 2, 2)
with self.assertRaises(ValueError):
x, y = np.ones(6), np.ones(6)
util.get_axes(x, y)
with self.assertRaises(ValueError):
util.selectBest(array=np.ones(6),
criteria=np.ones(5),
numSelect=1,
highest=True)
with self.assertRaises(ValueError):
util.select_best(array=np.ones(6),
criteria=np.ones(5),
num_select=1,
highest=True)
with self.assertRaises(ValueError):
util.convert_bool_list(n=2, k=[3, 7])
with self.assertRaises(ValueError):
util.convert_bool_list(n=3, k=[True, True])
with self.assertRaises(ValueError):
util.convert_bool_list(n=2, k=[0.1, True])
def test_raise(self):
with self.assertRaises(ValueError):
array = np.ones(5)
util.array2image(array)
with self.assertRaises(ValueError):
x, y = np.ones(6), np.ones(6)
util.get_axes(x, y)
with self.assertRaises(ValueError):
util.selectBest(array=np.ones(6), criteria=np.ones(5), numSelect=1, highest=True)
def find_max_residuals(self, residuals, ra_coords, dec_coords, N):
"""
:param residuals: reduced residual map
:return: pixel coords of maximas
"""
ra_mins, dec_mins, values = util.neighborSelect(residuals, ra_coords, dec_coords)
ra_pos = util.selectBest(np.array(ra_mins), -np.array(values), N, highest=True)
dec_pos = util.selectBest(np.array(dec_mins), -np.array(values), N, highest=True)
return ra_pos, dec_pos
def test_selectBest():
array = np.array([4, 3, 6, 1, 3])
select = np.array([2, 4, 7, 3, 3])
numSelect = 4
array_select = util.selectBest(array, select, numSelect, highest=True)
assert array_select[0] == 6
assert array_select[3] == 1
array_select = util.selectBest(array, select, numSelect, highest=False)
assert array_select[0] == 3
assert array_select[3] == 4
array_select = util.selectBest(array, select, numSelect=10, highest=False)
assert len(array_select) == len(array)
def test_selectBest():
array = np.array([4, 3, 6, 1, 3])
select = np.array([2, 4, 7, 3, 3])
numSelect = 4
array_select = Util.selectBest(array, select, numSelect, highest=True)
assert array_select[0] == 6
assert array_select[3] == 1
def findBrightImage(self,
sourcePos_x,
sourcePos_y,
kwargs_lens,
numImages=4,
min_distance=0.01,
search_window=5,
precision_limit=10**(-10),
num_iter_max=10,
arrival_time_sort=True):
"""
:param sourcePos_x:
:param sourcePos_y:
:param deltapix:
:param numPix:
:param magThresh: magnification threshold for images to be selected
:param numImage: number of selected images (will select the highest magnified ones)
:param kwargs_lens:
:param ray_shooting_function: a special function for performing ray shooting; defaults to self.lensModel.ray_shooting
:param hessian_function: same as ray_shooting_function, but for computing the hessian matrix
:param magnification_function: same as ray_shooting_function, but for computing magnifications
:return:
"""
x_mins, y_mins = self.image_position_from_source(
sourcePos_x,
sourcePos_y,
kwargs_lens,
min_distance,
search_window,
precision_limit,
num_iter_max,
arrival_time_sort=arrival_time_sort)
mag_list = []
for i in range(len(x_mins)):
mag = self.lensModel.magnification(x_mins[i], y_mins[i],
kwargs_lens)
mag_list.append(abs(mag))
mag_list = np.array(mag_list)
x_mins_sorted = util.selectBest(x_mins, mag_list, numImages)
y_mins_sorted = util.selectBest(y_mins, mag_list, numImages)
if arrival_time_sort is True:
x_mins_sorted, y_mins_sorted = self.sort_arrival_times(
x_mins_sorted, y_mins_sorted, kwargs_lens)
return x_mins_sorted, y_mins_sorted
def findBrightImage(self, sourcePos_x, sourcePos_y, kwargs_lens, numImages=4, min_distance=0.01, search_window=5,
precision_limit=10**(-10), num_iter_max=10, arrival_time_sort=True, x_center=0, y_center=0,
num_random=0, non_linear=False, magnification_limit=None, initial_guess_cut=True, verbose=False):
"""
:param sourcePos_x: source position in units of angle
:param sourcePos_y: source position in units of angle
:param kwargs_lens: lens model parameters as keyword arguments
:param min_distance: minimum separation to consider for two images in units of angle
:param search_window: window size to be considered by the solver. Will not find image position outside this window
:param precision_limit: required precision in the lens equation solver (in units of angle in the source plane).
:param num_iter_max: maximum iteration of lens-source mapping conducted by solver to match the required precision
:param arrival_time_sort: bool, if True, sorts image position in arrival time (first arrival photon first listed)
:param initial_guess_cut: bool, if True, cuts initial local minima selected by the grid search based on distance criteria from the source position
:param verbose: bool, if True, prints some useful information for the user
:param x_center: float, center of the window to search for point sources
:param y_center: float, center of the window to search for point sources
:param num_random: int, number of random positions within the search window to be added to be starting
positions for the gradient decent solver
:param non_linear: bool, if True applies a non-linear solver not dependent on Hessian computation
:param magnification_limit: None or float, if set will only return image positions that have an
abs(magnification) larger than this number
:returns: (exact) angular position of (multiple) images ra_pos, dec_pos in units of angle
:returns: (exact) angular position of (multiple) images ra_pos, dec_pos in units of angle
"""
x_mins, y_mins = self.image_position_from_source(sourcePos_x, sourcePos_y, kwargs_lens,
min_distance=min_distance, search_window=search_window,
precision_limit=precision_limit, num_iter_max=num_iter_max,
arrival_time_sort=arrival_time_sort,
initial_guess_cut=initial_guess_cut, verbose=verbose,
x_center=x_center, y_center=y_center, num_random=num_random,
non_linear=non_linear, magnification_limit=magnification_limit)
mag_list = []
for i in range(len(x_mins)):
mag = self.lensModel.magnification(x_mins[i], y_mins[i], kwargs_lens)
mag_list.append(abs(mag))
mag_list = np.array(mag_list)
x_mins_sorted = util.selectBest(x_mins, mag_list, numImages)
y_mins_sorted = util.selectBest(y_mins, mag_list, numImages)
if arrival_time_sort is True:
x_mins_sorted, y_mins_sorted = self.sort_arrival_times(x_mins_sorted, y_mins_sorted, kwargs_lens)
return x_mins_sorted, y_mins_sorted
