def _new_shear(self, start_e1, start_e2, delta_phi, delta_gamma): phi_start, gamma_start = shear_cartesian2polar(start_e1, start_e2) phi_min, phi_max = phi_start + delta_phi, phi_start - delta_phi gamma_min, gamma_max = max(0.0001, gamma_start - delta_gamma), gamma_start + delta_gamma e1_min, e2_min = shear_polar2cartesian(phi_min, gamma_min) e1_max, e2_max = shear_polar2cartesian(phi_max, gamma_max) return e1_min, e2_min, e1_max, e2_max
def test_solver_simplified(self): lens_model_list = ['SPEP', 'SHEAR_GAMMA_PSI'] lensModel = LensModel(lens_model_list) lensEquationSolver = LensEquationSolver(lensModel) sourcePos_x = 0.1 sourcePos_y = -0.1 deltapix = 0.05 numPix = 150 gamma = 1.9 gamma_ext = 0.05 psi_ext = 0.4 #e1, e2 = param_util.phi_gamma_ellipticity(phi=psi_ext, gamma=gamma_ext) kwargs_lens = [{'theta_E': 1., 'gamma': gamma, 'e1': 0.1, 'e2': -0.1, 'center_x': 0.1, 'center_y': -0.1}, {'gamma_ext': gamma_ext, 'psi_ext': psi_ext}] x_pos, y_pos = lensEquationSolver.findBrightImage(sourcePos_x, sourcePos_y, kwargs_lens, numImages=4, min_distance=deltapix, search_window=numPix * deltapix) e1_new, e2_new = param_util.shear_polar2cartesian(phi=0., gamma=gamma_ext + 0.1) kwargs_lens_init = [{'theta_E': 1.3, 'gamma': gamma, 'e1': 0., 'e2': 0., 'center_x': 0., 'center_y': 0}, {'gamma_ext': gamma_ext + 0.1, 'psi_ext': 0}] solver = Solver4Point(lensModel, solver_type='PROFILE_SHEAR') kwargs_lens_new, accuracy = solver.constraint_lensmodel(x_pos, y_pos, kwargs_lens_init) assert accuracy < 10**(-10) x_source, y_source = lensModel.ray_shooting(x_pos, y_pos, kwargs_lens_new) x_source, y_source = np.mean(x_source), np.mean(y_source) x_pos_new, y_pos_new = lensEquationSolver.findBrightImage(x_source, y_source, kwargs_lens_new, numImages=4, min_distance=deltapix, search_window=numPix * deltapix) print(x_pos, x_pos_new) x_pos = np.sort(x_pos) x_pos_new = np.sort(x_pos_new) y_pos = np.sort(y_pos) y_pos_new = np.sort(y_pos_new) for i in range(len(x_pos)): npt.assert_almost_equal(x_pos[i], x_pos_new[i], decimal=6) npt.assert_almost_equal(y_pos[i], y_pos_new[i], decimal=6)
def args_to_kwargs(self, args): (thetaE, center_x, center_y, e1, e2, g1, g2) = args gamma = self.kwargs_lens[0]['gamma'] kwargs_epl = { 'theta_E': thetaE, 'center_x': center_x, 'center_y': center_y, 'e1': e1, 'e2': e2, 'gamma': gamma } phi, _ = shear_cartesian2polar(g1, g2) gamma1, gamma2 = shear_polar2cartesian(phi, self._shear_strength) kwargs_shear = {'gamma1': gamma1, 'gamma2': gamma2} self.kwargs_lens[0] = kwargs_epl self.kwargs_lens[1] = kwargs_shear self.kwargs_lens[2]['center_x'] = center_x self.kwargs_lens[2]['center_y'] = center_y phi, _ = ellipticity2phi_q(e1, e2) self.kwargs_lens[2]['phi_m'] = phi return self.kwargs_lens
def argstovary_todictionary(self,values): args_list = [] count = 0 for n in range(0, int(self._Ntovary)): args = {} if hasattr(self.routine, '_fixshear') and n == 1: # here values is [theta_E, x, y, e1, e2, shear_theta] # so convert into shear e1 e2 gamma1, gamma2 = shear_polar2cartesian(values[count], self.routine.fixed_values[n]['shear_magnitude']) args.update({'gamma1': gamma1, 'gamma2': gamma2}) else: for key in self.routine.param_names[n]: if key in self.routine.fixed_names[n]: args.update({key:self.routine.fixed_values[n][key]}) else: args.update({key:values[count]}) count += 1 args_list.append(args) return args_list
def test_phi_gamma_ellipticity_2(): e1, e2 = -0.04, -0.01 phi, gamma = param_util.shear_cartesian2polar(e1, e2) e1_out, e2_out = param_util.shear_polar2cartesian(phi, gamma) npt.assert_almost_equal(e1, e1_out, decimal=10) npt.assert_almost_equal(e2, e2_out, decimal=10)
def args_to_kwargs(self, args): """ :param args: array of lens model parameters :return: dictionary of lens model parameters with fixed shear = shear_strength """ (thetaE, center_x, center_y, e1, e2, g1, g2) = args gamma = self.kwargs_lens[0]['gamma'] kwargs_epl = { 'theta_E': thetaE, 'center_x': center_x, 'center_y': center_y, 'e1': e1, 'e2': e2, 'gamma': gamma } phi, _ = shear_cartesian2polar(g1, g2) gamma1, gamma2 = shear_polar2cartesian(phi, self._shear_strength) kwargs_shear = {'gamma1': gamma1, 'gamma2': gamma2} self.kwargs_lens[0] = kwargs_epl self.kwargs_lens[1] = kwargs_shear return self.kwargs_lens
def test_phi_gamma_ellipticity(): phi = -1. gamma = 0.1 e1, e2 = param_util.shear_polar2cartesian(phi, gamma) print(e1, e2, 'e1, e2') phi_out, gamma_out = param_util.shear_cartesian2polar(e1, e2) assert phi == phi_out assert gamma == gamma_out
def test_phi_gamma_ellipticity(): phi = -1. gamma = 0.1 e1, e2 = param_util.shear_polar2cartesian(phi, gamma) print(e1, e2, 'e1, e2') phi_out, gamma_out = param_util.shear_cartesian2polar(e1, e2) npt.assert_almost_equal(phi_out, phi, decimal=8) npt.assert_almost_equal(gamma_out, gamma_out, decimal=8)
def test_derivatives(self): x = np.array([1, 3, 4]) y = np.array([2, 1, 1]) gamma, psi = 0.1, 0.5 gamma1, gamma2 = param_util.shear_polar2cartesian(phi=psi, gamma=gamma) values = self.shear.derivatives(x, y, gamma, psi) values_e1e2 = self.shear_e1e2.derivatives(x, y, gamma1, gamma2) npt.assert_almost_equal(values, values_e1e2, decimal=5)
def test_solver_profile_shear_2(self): lens_model_list = ['SPEP', 'SHEAR'] lensModel = LensModel(lens_model_list) lensEquationSolver = LensEquationSolver(lensModel) sourcePos_x = 0. sourcePos_y = 0.1 deltapix = 0.05 numPix = 150 gamma = 1.98 gamma1, gamma2 = -0.04, -0.01 kwargs_shear = {'gamma1': gamma1, 'gamma2': gamma2} # shear values to the source plane kwargs_spemd = {'theta_E': 1.66, 'gamma': gamma, 'center_x': 0.0, 'center_y': 0.0, 'e1': 0.1, 'e2': 0.05} # parameters of the deflector lens model kwargs_lens = [kwargs_spemd, kwargs_shear] x_pos, y_pos = lensEquationSolver.findBrightImage(sourcePos_x, sourcePos_y, kwargs_lens, numImages=4, min_distance=deltapix, search_window=numPix * deltapix) print(x_pos, y_pos, 'test positions') gamma_ext = np.sqrt(gamma1 ** 2 + gamma2 ** 2) gamma1_init, gamma2_init = param_util.shear_polar2cartesian(gamma=gamma_ext, phi=-1.3) kwargs_lens_init = [{'theta_E': 1.3, 'gamma': gamma, 'e1': 0, 'e2': 0, 'center_x': 0., 'center_y': 0}, {'gamma1': gamma1_init, 'gamma2': gamma2_init}] solver = Solver4Point(lensModel, solver_type='PROFILE_SHEAR') kwargs_lens_new, accuracy = solver.constraint_lensmodel(x_pos, y_pos, kwargs_lens_init) assert accuracy < 10**(-10) x_source, y_source = lensModel.ray_shooting(x_pos, y_pos, kwargs_lens_new) x_source, y_source = np.mean(x_source), np.mean(y_source) x_pos_new, y_pos_new = lensEquationSolver.findBrightImage(x_source, y_source, kwargs_lens_new, numImages=4, min_distance=deltapix, search_window=numPix * deltapix) print(x_pos, x_pos_new) x_pos = np.sort(x_pos) x_pos_new = np.sort(x_pos_new) y_pos = np.sort(y_pos) y_pos_new = np.sort(y_pos_new) for i in range(len(x_pos)): npt.assert_almost_equal(x_pos[i], x_pos_new[i], decimal=6) npt.assert_almost_equal(y_pos[i], y_pos_new[i], decimal=6) npt.assert_almost_equal(kwargs_lens_new[1]['gamma1'], kwargs_lens[1]['gamma1'], decimal=8) npt.assert_almost_equal(kwargs_lens_new[1]['gamma2'], kwargs_lens[1]['gamma2'], decimal=8) npt.assert_almost_equal(kwargs_lens_new[0]['e1'], kwargs_lens[0]['e1'], decimal=8) npt.assert_almost_equal(kwargs_lens_new[0]['e2'], kwargs_lens[0]['e2'], decimal=8)
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 _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 """ if self._solver_type == 'PROFILE_SHEAR_GAMMA_PSI': phi_G = x[5] # % (2 * np.pi) kwargs_list[1]['psi_ext'] = phi_G if self._solver_type == 'PROFILE_SHEAR': phi_G = x[5] % np.pi 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 lens_model = self._lens_mode_list[0] if lens_model in ['SPEP', 'SPEMD', 'SIE', 'NIE', 'PEMD', 'EPL']: [theta_E, e1, e2, center_x, center_y, _] = x kwargs_list[0]['theta_E'] = theta_E kwargs_list[0]['e1'] = e1 kwargs_list[0]['e2'] = e2 kwargs_list[0]['center_x'] = center_x kwargs_list[0]['center_y'] = center_y elif lens_model in ['NFW_ELLIPSE', 'CNFW_ELLIPSE']: [alpha_Rs, e1, e2, center_x, center_y, _] = x kwargs_list[0]['alpha_Rs'] = alpha_Rs kwargs_list[0]['e1'] = e1 kwargs_list[0]['e2'] = e2 kwargs_list[0]['center_x'] = center_x kwargs_list[0]['center_y'] = center_y elif lens_model in ['SHAPELETS_CART']: [c10, c01, c20, c11, c02, _] = x coeffs = list(kwargs_list[0]['coeffs']) coeffs[1:6] = [c10, c01, c20, c11, c02] kwargs_list[0]['coeffs'] = coeffs else: raise ValueError( "Lens model %s not supported for 4-point solver!" % lens_model) return kwargs_list
def add_g1g2_columns(metadata): """Add alternate shear definitions (gamma1, gamma2) for external shear defined in terms of shear modulus and angle (gamma_ext, psi_ext) Parameters ---------- metadata : pd.DataFrame the metadatadata generated by Baobab Returns ------- pd.DataFrame metadata augmented with gamma1, gamma2 for the external shear component """ gamma_ext = metadata['external_shear_gamma_ext'].values psi_ext = metadata['external_shear_psi_ext'].values gamma1, gamma2 = param_util.shear_polar2cartesian(phi=psi_ext, gamma=gamma_ext) metadata['external_shear_gamma1'] = gamma1 metadata['external_shear_gamma2'] = gamma2 return metadata
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
def derivatives(self, x, y, gamma_ext, psi_ext, ra_0=0, dec_0=0): # rotation angle gamma1, gamma2 = param_util.shear_polar2cartesian(psi_ext, gamma_ext) return self._shear_e1e2.derivatives(x, y, gamma1, gamma2, ra_0, dec_0)
def hessian(self, x, y, gamma_ext, psi_ext, ra_0=0, dec_0=0): gamma1, gamma2 = param_util.shear_polar2cartesian(psi_ext, gamma_ext) return self._shear_e1e2.hessian(x, y, gamma1, gamma2, ra_0, dec_0)
def caustics_epl_shear(kwargs_lens, num_th=500, maginf=0, sourceplane=True, return_which=None): """ Analytically calculates the caustics of an EPL+shear lens model. Since for gamma>2, the outer critical curve does not exist, the option to find the curves for a set, finite magnification exists, by supplying maginf, so that the routine finds the curve of this magnification, rather than the true caustic. :param kwargs_lens: List of kwargs in lenstronomy style, following ['EPL', 'SHEAR'] format :param num_th: resolution. :param maginf: the outer critical curve for t>1 will be replaced with the curve where the inverse magnification is maginf :param sourceplane: if True (default), ray-shoot the calculated critical curves to the source plane :param return_which: options 'quad' (boundary of area within which there are 4 images), 'double' (boundary of area within which there are 2 images), 'caustic' (the diamond caustic) and 'cut' (the cut, if it exists, that is if t<2, else, if t>2, returns the caustic) and None (in that case: return quad, caustic, cut) :return: (2,N) array if return_which set, else a tuple of (caustic, cut, quad) """ e1, e2 = kwargs_lens[0]['e1'], kwargs_lens[0]['e2'] if len(kwargs_lens) > 1: gamma1unr, gamma2unr = kwargs_lens[1]['gamma1'], kwargs_lens[1][ 'gamma2'] else: gamma1unr, gamma2unr = 0, 0 _check_center(kwargs_lens) t = kwargs_lens[0]['gamma'] - 1 if 'gamma' in kwargs_lens[0] else 1 theta_ell, q = ellipticity2phi_q(e1, e2) theta_gamma, gamma_mag = shear_cartesian2polar(gamma1unr, gamma2unr) b = np.sqrt(q) * kwargs_lens[0]['theta_E'] cen = np.expand_dims( np.array([kwargs_lens[0]['center_x'], kwargs_lens[0]['center_y']]), 1) theta_gamma -= theta_ell gamma1, gamma2 = shear_polar2cartesian(theta_gamma, gamma_mag) M = rotmat(-theta_ell) phiell, q = ellipticity2phi_q(e1, e2) theta = np.linspace(0, 2 * np.pi, num_th, endpoint=False) r = 1 R, phi = pol_to_ell(1, theta, q) Omega = omega(phi, t, q) aa = 1 bb = -(2 - t) frac_roverR = r / R cc = (1 - t) * (2 - t) * (cdot(np.exp(1j * theta), Omega)) / frac_roverR * 2 / (1 + q) cc -= (1 - t)**2 * (2 / (1 + q))**2 * np.abs(Omega)**2 / frac_roverR**2 # Shear stuff: gammaint_fac = (-np.exp(2j * theta) * (2 - t) / 2 + (1 - t) * np.exp(1j * theta) * 2 / (1 + q) * Omega / frac_roverR) gamma = gamma1 + 1j * gamma2 aa -= np.abs(gamma)**2 bb -= 2 * cdot(gamma, gammaint_fac) usol = np.array(solvequadeq(cc, bb, aa)).T xcr_4, ycr_4 = pol_to_cart(b * usol[:, 1]**(-1 / t) * frac_roverR, theta) if t > 1: # If t>1, get the approximate outer caustic instead (where inverse magnification = maginf). usol = np.array(solvequadeq(cc, bb, aa - maginf)).T xcr_cut, ycr_cut = pol_to_cart(b * usol[:, 1]**(-1 / t) * frac_roverR, theta) else: usol = np.array(solvequadeq(cc, bb, aa + maginf)).T xcr_cut, ycr_cut = pol_to_cart(b * usol[:, 0]**(-1 / t) * frac_roverR, theta) al_cut = _alpha_epl_shear(xcr_cut, ycr_cut, b, q, t, gamma1, gamma2, Omega=Omega) al_4 = _alpha_epl_shear(xcr_4, ycr_4, b, q, t, gamma1, gamma2, Omega=Omega) if sourceplane: xca_cut, yca_cut = xcr_cut - al_cut.real, ycr_cut - al_cut.imag xca_4, yca_4 = xcr_4 - al_4.real, ycr_4 - al_4.imag else: xca_cut, yca_cut = xcr_cut, ycr_cut xca_4, yca_4 = xcr_4, ycr_4 if return_which == 'caustic': return M @ (xca_4, yca_4) + cen if return_which == 'cut': return M @ (xca_cut, yca_cut) + cen rcut, thcut = cart_to_pol(xca_cut, yca_cut) r, th = cart_to_pol(xca_4, yca_4) r2 = np.interp(th, thcut, rcut, period=2 * np.pi) if return_which == 'double': r = np.fmax(r, r2) else: # Quad r = np.fmin(r, r2) pos_tosample = np.empty((2, num_th)) pos_tosample[0], pos_tosample[1] = pol_to_cart(r, th) if return_which in ('double', 'quad'): return M @ pos_tosample + cen return M @ (xca_4, yca_4) + cen, M @ ( xca_cut, yca_cut ) + cen, M @ pos_tosample + cen # Mostly for some backward compatibility
def run(Ntotal_cusp, Ntotal_fold, Ntotal_cross, start_idx): continue_loop = True n_computed = 0 done_cusp, done_fold, done_cross = False, False, False n_cusp, n_fold, n_cross = 0, 0, 0 if Ntotal_cusp == 0: done_cusp = True if Ntotal_fold == 0: done_fold = True if Ntotal_cross == 0: done_cross = True lens_idx = int(start_idx) + n_computed dpath = dpath_base + str(lens_idx) if os.path.exists(dpath + '/lensdata.txt'): return while continue_loop: if done_cusp and done_cross and done_fold: break while True: rein, vdis, zlens, zsrc = sample_from_strides(1) if rein <= rein_max and rein >= rein_min: if zlens <= z_lens_max: if zsrc <= z_src_max: break pyhalo = pyHalo(zlens, zsrc) print('rein, zlens, zsrc: ', str(rein) + ' ' + str(zlens) + ' ' + str(zsrc)) ellip = draw_ellip() ellip_theta = draw_ellip_PA() shear = draw_shear() shear_theta = draw_shear_PA_correlated(ellip_theta, sigma=40) halo_args = { 'mdef_main': mass_def, 'mdef_los': mass_def, 'sigma_sub': sigma_sub, 'log_mlow': log_ml, 'log_mhigh': log_mh, 'power_law_index': -1.9, 'parent_m200': M_halo, 'r_tidal': r_tidal, 'cone_opening_angle': 5 * rein, 'opening_angle_factor': 5, 'subtract_subhalo_mass_sheet': True, 'subhalo_mass_sheet_scale': 1., 'R_ein_main': rein, 'LOS_normalization': LOSnorm } realization = pyhalo.render(model_type, halo_args)[0] e1, e2 = phi_q2_ellipticity(shear_theta * np.pi / 180, 1 - ellip) gamma1, gamma2 = shear_polar2cartesian(shear_theta * np.pi / 180, shear) kwargs_lens = [{ 'theta_E': rein, 'center_x': 0, 'center_y': 0, 'e1': e1, 'e2': e2, 'gamma': gamma }, { 'gamma1': gamma1, 'gamma2': gamma2 }] macromodel = MacroLensModel([PowerLawShear(zlens, kwargs_lens)]) source_args = { 'center_x': None, 'center_y': None, 'source_fwhm_pc': source_size_fwhm_pc } quasar = Quasar(source_args) system = QuadLensSystem(macromodel, zsrc, quasar, realization, pyhalo._cosmology) print('zlens: ', zlens) print('zsrc: ', zsrc) print('src_size_pc: ', source_size_fwhm_pc) print('R_ein:', rein) print('shear, ellip: ', shear, ellip) print('nhalos: ', len(realization.halos)) continue_findimg_loop = True while continue_findimg_loop: src_r = np.random.uniform(0.01, 0.1) src_phi = np.random.uniform(-np.pi, np.pi) srcx, srcy = src_r * np.cos(src_phi), src_r * np.sin(src_phi) print(srcx, srcy, np.sqrt(srcx**2 + srcy**2)) system.update_source_centroid(srcx, srcy) lens_model_smooth, kwargs_lens_smooth = system.get_lensmodel(False) lensModel, kwargs_lens = system.get_lensmodel() x_guess, y_guess = system.solve_lens_equation( lens_model_smooth, kwargs_lens_smooth) if len(x_guess) != 4: continue min_sep = min_img_sep(x_guess, y_guess) lens_config = identify(x_guess, y_guess, rein) if min_sep < 0.2: continue if lens_config == 0: config = 'cross' if done_cross: continue elif lens_config == 1: config = 'fold' if done_fold: continue else: config = 'cusp' if done_cusp: continue print('solving lens equation with halos... ') t0 = time() #x_image, y_image = iterative_rayshooting(srcx, srcy, # x_guess, y_guess, lensModel, kwargs_lens) x_image, y_image = system.solve_lens_equation( lensModel, kwargs_lens, 10**-6) tend = time() dt = np.round(tend - t0, 2) / 60 print('solved lens equation with ' + str(len(realization.halos)) + ' halos in ' + str(dt) + ' min.') lens_config = identify(x_image, y_image, rein) min_sep = min_img_sep(x_image, y_image) if min_sep < 0.2: continue if lens_config == 0: config = 'cross' if done_cross: continue elif lens_config == 1: config = 'fold' if done_fold: continue else: config = 'cusp' if done_cusp: continue images = system.background_quasar.get_images( x_image, y_image, lensModel, kwargs_lens) break_loop = False for img in images: if flux_at_edge(img): break_loop = True if break_loop: print('flux at edge... ') continue print(config) other_lens_args = {} other_lens_args['zlens'] = zlens other_lens_args['zsrc'] = zsrc other_lens_args['gamma'] = gamma other_lens_args['config'] = config other_lens_args['source_fwhm_pc'] = source_size_fwhm_pc other_lens_args['rmax2d_asec'] = 3 * rein continue_findimg_loop = False if lens_config == 0: n_cross += 1 if n_cross == Ntotal_cross: done_cross = True elif lens_config == 1: n_fold += 1 if n_fold == Ntotal_fold: done_fold = True else: n_cusp += 1 if n_cusp == Ntotal_cusp: done_cusp = True n_computed += 1 create_directory(dpath) x_image += np.random.normal(0, 0.005, 4) y_image += np.random.normal(0, 0.005, 4) magnifications = system.quasar_magnification(x_image, y_image, lensModel, kwargs_lens) data_with_halos = LensedQuasar(x_image, y_image, magnifications) data_with_halos.nimg = 4 data_with_halos.srcx = 0. data_with_halos.srcy = 0. data_with_halos.t = [0., 0., 0., 0.] write_data(dpath + '/lensdata.txt', [data_with_halos], mode='write') to_write = get_info_string(halo_args, other_lens_args) write_info(str(to_write), dpath + '/info.txt')