def test_setup(self): cosmo = None lens_model = LensModel(['EPL']) grid_radius_arcsec = None grid_resolution = None source_fwhm_parsec = 30. source_light_model = 'SINGLE_GAUSSIAN' z_source = 2. source_x, source_y = 0., 0. dx, dy, amp_scale, size_scale = None, None, None, None gridx, gridy, source_model, kwargs_source, grid_resolution, grid_radius_arcsec = setup_mag_finite(cosmo, lens_model, grid_radius_arcsec, grid_resolution, source_fwhm_parsec, source_light_model, z_source, source_x, source_y, dx, dy, amp_scale, size_scale) npt.assert_equal(True, len(source_model.func_list)==1) npt.assert_equal(True, grid_resolution is not None) npt.assert_equal(True, grid_radius_arcsec is not None) grid_resolution = 0.001 grid_radius_arcsec = 0.05 dx, dy, amp_scale, size_scale = 0., 0.1, 1., 1. source_light_model = 'DOUBLE_GAUSSIAN' gridx, gridy, source_model, kwargs_source, grid_resolution, grid_radius_arcsec = setup_mag_finite(cosmo, lens_model, grid_radius_arcsec, grid_resolution, source_fwhm_parsec, source_light_model, z_source, source_x, source_y, dx, dy, amp_scale, size_scale) npt.assert_equal(True, len(source_model.func_list) == 2) npt.assert_equal(kwargs_source[1]['center_y'], kwargs_source[0]['center_y'] + dy) npt.assert_equal(kwargs_source[1]['center_x'], kwargs_source[0]['center_x'] + dx) npt.assert_equal(True, grid_resolution == 0.001) npt.assert_equal(True, grid_radius_arcsec == 0.05) source_light_model = 'trash' npt.assert_raises(Exception, setup_mag_finite, cosmo, lens_model, grid_radius_arcsec, grid_resolution, source_fwhm_parsec, source_light_model, z_source, source_x, source_y, dx, dy, amp_scale, size_scale )
def magnification_finite_adaptive(self, x_image, y_image, source_x, source_y, kwargs_lens, source_fwhm_parsec, z_source, cosmo=None, grid_resolution=None, grid_radius_arcsec=None, axis_ratio=0.5, tol=0.001, step_size=0.05, use_largest_eigenvalue=True, source_light_model='SINGLE_GAUSSIAN', dx=None, dy=None, size_scale=None, amp_scale=None, fixed_aperture_size=False): """ This method computes image magnifications with a finite-size background source assuming a Gaussian or a double Gaussian source light profile. It can be much faster that magnification_finite for lens models with many deflectors and a compact source. This is because most pixels in a rectangular window around a lensed image of a compact source do not map onto the source, and therefore don't contribute to the integrated flux in the image plane. Rather than ray tracing through a rectangular grid, this routine accelerates the computation of image magnifications with finite-size sources by ray tracing through an elliptical region oriented such that tracks the surface brightness of the lensed image. The aperture size is initially quite small, and increases in size until the flux inside of it (and hence the magnification) converges. The orientation of the elliptical aperture is computed from the magnification tensor evaluated at the image coordinate. If for whatever reason you prefer a circular aperture to the elliptical approximation using the hessian eigenvectors, you can just set axis_ratio = 1. To use the eigenvalues of the hessian matrix to estimate the optimum axis ratio, set axis_ratio = 0. The default settings for the grid resolution and ray tracing window size work well for sources with fwhm between 0.5 - 100 pc. :param x_image: a list or array of x coordinates [units arcsec] :param y_image: a list or array of y coordinates [units arcsec] :param source_x: float, source position :param source_y: float, source position :param kwargs_lens: keyword arguments for the lens model :param source_fwhm_parsec: the size of the background source [units parsec] :param z_source: the source redshift :param cosmo: (optional) an instance of astropy.cosmology; if not specified, a default cosmology will be used :param grid_resolution: the grid resolution in units arcsec/pixel; if not specified, an appropriate value will be estimated from the source size :param grid_radius_arcsec: (optional) the size of the ray tracing region in arcsec; if not specified, an appropriate value will be estimated from the source size :param axis_ratio: the axis ratio of the ellipse used for ray tracing; if axis_ratio = 0, then the eigenvalues the hessian matrix will be used to estimate an appropriate axis ratio. Be warned: if the image is highly magnified it will tend to curve out of the resulting ellipse :param tol: tolerance for convergence in the magnification :param step_size: sets the increment for the successively larger ray tracing windows :param use_largest_eigenvalue: bool; if True, then the major axis of the ray tracing ellipse region will be aligned with the eigenvector corresponding to the largest eigenvalue of the hessian matrix :param source_light_model: the model for backgourn source light; currently implemented are 'SINGLE_GAUSSIAN' and 'DOUBLE_GAUSSIAN'. :param dx: used with source model 'DOUBLE_GAUSSIAN', the offset of the second source light profile from the first [arcsec] :param dy: used with source model 'DOUBLE_GAUSSIAN', the offset of the second source light profile from the first [arcsec] :param size_scale: used with source model 'DOUBLE_GAUSSIAN', the size of the second source light profile relative to the first :param amp_scale: used with source model 'DOUBLE_GAUSSIAN', the peak brightness of the second source light profile relative to the first :param fixed_aperture_size: bool, if True the flux is computed inside a fixed aperture size with radius grid_radius_arcsec :return: an array of image magnifications """ grid_x_0, grid_y_0, source_model, kwargs_source, grid_resolution, grid_radius_arcsec = setup_mag_finite(cosmo, self._lensModel, grid_radius_arcsec, grid_resolution, source_fwhm_parsec, source_light_model, z_source, source_x, source_y, dx, dy, amp_scale, size_scale) grid_x_0, grid_y_0 = grid_x_0.ravel(), grid_y_0.ravel() minimum_magnification = 1e-5 magnifications = [] for xi, yi in zip(x_image, y_image): if axis_ratio == 1: grid_r = np.hypot(grid_x_0, grid_y_0) else: w1, w2, v11, v12, v21, v22 = self.hessian_eigenvectors(xi, yi, kwargs_lens) _v = [np.array([v11, v12]), np.array([v21, v22])] _w = [abs(w1), abs(w2)] if use_largest_eigenvalue: idx = int(np.argmax(_w)) else: idx = int(np.argmin(_w)) v = _v[idx] rotation_angle = np.arctan(v[1] / v[0]) - np.pi / 2 grid_x, grid_y = util.rotate(grid_x_0, grid_y_0, rotation_angle) if axis_ratio == 0: sort = np.argsort(_w) q = _w[sort[0]] / _w[sort[1]] grid_r = np.hypot(grid_x, grid_y / q).ravel() else: grid_r = np.hypot(grid_x, grid_y / axis_ratio).ravel() flux_array = np.zeros_like(grid_x_0) step = step_size * grid_radius_arcsec r_min = 0 if fixed_aperture_size: r_max = grid_radius_arcsec else: r_max = step magnification_current = 0. while True: flux_array = self._magnification_adaptive_iteration(flux_array, xi, yi, grid_x_0, grid_y_0, grid_r, r_min, r_max, self._lensModel, kwargs_lens, source_model, kwargs_source) new_magnification = np.sum(flux_array) * grid_resolution ** 2 diff = abs(new_magnification - magnification_current) / new_magnification if r_max >= grid_radius_arcsec: break elif diff < tol and new_magnification > minimum_magnification: break else: r_min += step r_max += step magnification_current = new_magnification magnifications.append(new_magnification) return np.array(magnifications)
def plot_quasar_images(lens_model, x_image, y_image, source_x, source_y, kwargs_lens, source_fwhm_parsec, z_source, cosmo=None, grid_resolution=None, grid_radius_arcsec=None, source_light_model='SINGLE_GAUSSIAN', dx=None, dy=None, size_scale=None, amp_scale=None): """ This function plots the surface brightness in the image plane of a background source modeled as either a single Gaussian or two Gaussian light profiles. The flux is computed inside a circular aperture with radius grid_radius_arcsec. If grid_radius_arcsec is not specified a default value will be assumed. :param lens_model: an instance of LensModel :param x_image: a list or array of x coordinates [units arcsec] :param y_image: a list or array of y coordinates [units arcsec] :param kwargs_lens: keyword arguments for the lens model :param source_fwhm_parsec: the size of the background source [units parsec] :param z_source: the source redshift :param cosmo: (optional) an instance of astropy.cosmology; if not specified, a default cosmology will be used :param grid_resolution: the grid resolution in units arcsec/pixel; if not specified, an appropriate value will be estimated from the source size :param grid_radius_arcsec: (optional) the size of the ray tracing region in arcsec; if not specified, an appropriate value will be estimated from the source size :param source_light_model: the model for background source light; currently implemented are 'SINGLE_GAUSSIAN' and 'DOUBLE_GAUSSIAN'. :param dx: used with source model 'DOUBLE_GAUSSIAN', the offset of the second source light profile from the first [arcsec] :param dy: used with source model 'DOUBLE_GAUSSIAN', the offset of the second source light profile from the first [arcsec] :param size_scale: used with source model 'DOUBLE_GAUSSIAN', the size of the second source light profile relative to the first :param amp_scale: used with source model 'DOUBLE_GAUSSIAN', the peak brightness of the second source light profile relative to the first :return: Four images of the background source in the image plane """ lens_model_extension = LensModelExtensions(lens_model) magnifications = [] images = [] grid_x_0, grid_y_0, source_model, kwargs_source, grid_resolution, grid_radius_arcsec = \ setup_mag_finite(cosmo, lens_model, grid_radius_arcsec, grid_resolution, source_fwhm_parsec, source_light_model, z_source, source_x, source_y, dx, dy, amp_scale, size_scale) shape0 = grid_x_0.shape grid_x_0, grid_y_0 = grid_x_0.ravel(), grid_y_0.ravel() for xi, yi in zip(x_image, y_image): flux_array = np.zeros_like(grid_x_0) r_min = 0 r_max = grid_radius_arcsec grid_r = np.hypot(grid_x_0, grid_y_0) flux_array = lens_model_extension._magnification_adaptive_iteration( flux_array, xi, yi, grid_x_0, grid_y_0, grid_r, r_min, r_max, lens_model, kwargs_lens, source_model, kwargs_source) m = np.sum(flux_array) * grid_resolution**2 magnifications.append(m) images.append(flux_array.reshape(shape0)) magnifications = np.array(magnifications) flux_ratios = magnifications / max(magnifications) import matplotlib.pyplot as plt fig = plt.figure(1) fig.set_size_inches(16, 6) N = len(images) for i, (image, mag, fr) in enumerate(zip(images, magnifications, flux_ratios)): ax = plt.subplot(1, N, i + 1) ax.imshow(image, origin='lower', extent=[ -grid_radius_arcsec, grid_radius_arcsec, -grid_radius_arcsec, grid_radius_arcsec ]) ax.annotate('magnification: ' + str(np.round(mag, 3)), xy=(0.05, 0.9), xycoords='axes fraction', color='w', fontsize=12) ax.annotate('flux ratio: ' + str(np.round(fr, 3)), xy=(0.05, 0.8), xycoords='axes fraction', color='w', fontsize=12) plt.show()