def test_ellipticity_in_profiles(self): lightProfile = ['HERNQUIST_ELLIPSE', 'PJAFFE_ELLIPSE'] kwargs_profile = [{'Rs': 0.16350224766074103, 'q': 0.4105628122365978, 'center_x': -0.019983826426838536, 'center_y': 0.90000011282957304, 'phi_G': 0.14944144075912402, 'sigma0': 1.3168943578511678}, {'Rs': 0.29187068596715743, 'q': 0.70799587973181288, 'center_x': 0.020568531548241405, 'center_y': 0.036038490364800925, 'Ra': 0.020000382843298824, 'phi_G': -0.37221683730659516, 'sigma0': 85.948773973262391}] kwargs_options = {'lens_model_list': ['SPEP'], 'lens_model_internal_bool': [True], 'lens_light_model_internal_bool': [True, True], 'lens_light_model_list': lightProfile} lensAnalysis = LensAnalysis(kwargs_options) r_eff = lensAnalysis.half_light_radius_lens(kwargs_profile) kwargs_profile[0]['q'] = 1 kwargs_profile[1]['q'] = 1 r_eff_spherical = lensAnalysis.half_light_radius_lens(kwargs_profile) npt.assert_almost_equal(r_eff / r_eff_spherical, 1, decimal=2)
def test_sersic_vs_hernquist_kinematics(self): """ attention: this test only works for Sersic indices > \approx 2! Lower n_sersic will result in different predictions with the Hernquist assumptions replacing the correct Light model! :return: """ # anisotropy profile anisotropy_type = 'OsipkovMerritt' r_ani = 2. kwargs_anisotropy = {'r_ani': r_ani} # anisotropy radius [arcsec] # aperture as slit aperture_type = 'slit' length = 3.8 width = 0.9 kwargs_aperture = {'length': length, 'width': width, 'center_ra': 0, 'center_dec': 0, 'angle': 0} psf_fwhm = 0.7 # Gaussian FWHM psf kwargs_cosmo = {'D_d': 1000, 'D_s': 1500, 'D_ds': 800} # light profile light_profile_list = ['SERSIC'] r_sersic = .3 n_sersic = 2.8 kwargs_light = [{'amp': 1., 'R_sersic': r_sersic, 'n_sersic': n_sersic}] # effective half light radius (2d projected) in arcsec # mass profile mass_profile_list = ['SPP'] theta_E = 1.2 gamma = 2. kwargs_profile = [{'theta_E': theta_E, 'gamma': gamma}] # Einstein radius (arcsec) and power-law slope # Hernquist fit to Sersic profile lens_analysis = LensAnalysis({'lens_light_model_list': ['SERSIC'], 'lens_model_list': []}) r_eff = lens_analysis.half_light_radius_lens(kwargs_light, deltaPix=0.1, numPix=100) print(r_eff) light_profile_list_hernquist = ['HERNQUIST'] kwargs_light_hernquist = [{'Rs': r_eff*0.551, 'amp': 1.}] # mge of light profile lightModel = LightModel(light_profile_list) r_array = np.logspace(-3, 2, 100) * r_eff * 2 print(r_sersic/r_eff, 'r_sersic/r_eff') flux_r = lightModel.surface_brightness(r_array, 0, kwargs_light) amps, sigmas, norm = mge.mge_1d(r_array, flux_r, N=20) light_profile_list_mge = ['MULTI_GAUSSIAN'] kwargs_light_mge = [{'amp': amps, 'sigma': sigmas}] print(amps, sigmas, 'amp', 'sigma') galkin = Galkin(mass_profile_list, light_profile_list_hernquist, aperture_type=aperture_type, anisotropy_model=anisotropy_type, fwhm=psf_fwhm, kwargs_cosmo=kwargs_cosmo) sigma_v = galkin.vel_disp(kwargs_profile, kwargs_light_hernquist, kwargs_anisotropy, kwargs_aperture) galkin = Galkin(mass_profile_list, light_profile_list_mge, aperture_type=aperture_type, anisotropy_model=anisotropy_type, fwhm=psf_fwhm, kwargs_cosmo=kwargs_cosmo) sigma_v2 = galkin.vel_disp(kwargs_profile, kwargs_light_mge, kwargs_anisotropy, kwargs_aperture) print(sigma_v, sigma_v2, 'sigma_v Galkin, sigma_v MGEn') print((sigma_v/sigma_v2)**2) npt.assert_almost_equal((sigma_v-sigma_v2)/sigma_v2, 0, decimal=1)
def test_half_light_radius(self): kwargs_profile = [{ 'Rs': 0.16350224766074103, 'q': 0.4105628122365978, 'center_x': -0.019983826426838536, 'center_y': 0.90000011282957304, 'phi_G': 0.14944144075912402, 'sigma0': 1.3168943578511678 }, { 'Rs': 0.29187068596715743, 'q': 0.70799587973181288, 'center_x': -0.01, 'center_y': 0.9, 'Ra': 0.020000382843298824, 'phi_G': -0.37221683730659516, 'sigma0': 85.948773973262391 }] kwargs_options = { 'lens_model_list': ['SPEP'], 'lens_model_internal_bool': [True], 'lens_light_model_internal_bool': [True, True], 'lens_light_model_list': ['HERNQUIST_ELLIPSE', 'PJAFFE_ELLIPSE'] } lensAnalysis = LensAnalysis(kwargs_options) r_eff_true = 0.282786143932 r_eff = lensAnalysis.half_light_radius_lens(kwargs_profile, numPix=1000, deltaPix=0.05) #r_eff_new = lensAnalysis.half_light_radius(kwargs_profile, numPix=1000, deltaPix=0.01) npt.assert_almost_equal(r_eff / r_eff_true, 1, 2)
def test_ellipticity_in_profiles(self): np.random.seed(41) lightProfile = ['HERNQUIST_ELLIPSE', 'PJAFFE_ELLIPSE'] import lenstronomy.Util.param_util as param_util phi, q = 0.14944144075912402, 0.4105628122365978 e1, e2 = param_util.phi_q2_ellipticity(phi, q) phi2, q2 = -0.37221683730659516, 0.70799587973181288 e12, e22 = param_util.phi_q2_ellipticity(phi2, q2) center_x = -0.019983826426838536 center_y = 0.90000011282957304 kwargs_profile = [{ 'Rs': 0.16350224766074103, 'e1': e1, 'e2': e2, 'center_x': center_x, 'center_y': center_y, 'amp': 1.3168943578511678 }, { 'Rs': 0.29187068596715743, 'e1': e12, 'e2': e22, 'center_x': center_x, 'center_y': center_y, 'Ra': 0.020000382843298824, 'amp': 85.948773973262391 }] kwargs_options = { 'lens_model_list': ['SPEP'], 'lens_light_model_list': lightProfile } lensAnalysis = LensAnalysis(kwargs_options) r_eff = lensAnalysis.half_light_radius_lens(kwargs_profile, center_x=center_x, center_y=center_y, deltaPix=0.1, numPix=100) kwargs_profile[0]['e1'], kwargs_profile[0]['e2'] = 0, 0 kwargs_profile[1]['e1'], kwargs_profile[1]['e2'] = 0, 0 r_eff_spherical = lensAnalysis.half_light_radius_lens( kwargs_profile, center_x=center_x, center_y=center_y, deltaPix=0.1, numPix=100) npt.assert_almost_equal(r_eff / r_eff_spherical, 1, decimal=2)
def test_half_light_radius_hernquist(self): Rs = 1. kwargs_profile = [{'Rs': Rs, 'amp': 1.}] kwargs_options = { 'lens_model_list': [], 'lens_light_model_list': ['HERNQUIST'] } lensAnalysis = LensAnalysis(kwargs_options) r_eff_true = Rs / 0.551 r_eff = lensAnalysis.half_light_radius_lens(kwargs_profile, numPix=500, deltaPix=0.2) #r_eff_new = lensAnalysis.half_light_radius(kwargs_profile, numPix=1000, deltaPix=0.01) npt.assert_almost_equal(r_eff / r_eff_true, 1, 2)
def test_half_light_radius(self): phi, q = -0.37221683730659516, 0.70799587973181288 e1, e2 = param_util.phi_q2_ellipticity(phi, q) phi2, q2 = 0.14944144075912402, 0.4105628122365978 e12, e22 = param_util.phi_q2_ellipticity(phi2, q2) center_x = -0.019983826426838536 center_y = 0.90000011282957304 kwargs_profile = [{ 'Rs': 0.16350224766074103, 'e1': e12, 'e2': e22, 'center_x': center_x, 'center_y': center_y, 'amp': 1.3168943578511678 }, { 'Rs': 0.29187068596715743, 'center_x': center_x, 'center_y': center_y, 'Ra': 0.020000382843298824, 'e1': e1, 'e2': e2, 'amp': 85.948773973262391 }] kwargs_options = { 'lens_model_list': ['SPEP'], 'lens_model_internal_bool': [True], 'lens_light_model_internal_bool': [True, True], 'lens_light_model_list': ['HERNQUIST_ELLIPSE', 'PJAFFE_ELLIPSE'] } lensAnalysis = LensAnalysis(kwargs_options) r_eff_true = 0.25430388278592997 r_eff = lensAnalysis.half_light_radius_lens(kwargs_profile, center_x=center_x, center_y=center_y, numPix=1000, deltaPix=0.01) #r_eff_new = lensAnalysis.half_light_radius(kwargs_profile, numPix=1000, deltaPix=0.01) npt.assert_almost_equal(r_eff, r_eff_true, 2)
class LensProp(object): """ this class contains routines to compute time delays, magnification ratios, line of sight velocity dispersions etc for a given lens model """ def __init__(self, z_lens, z_source, kwargs_model, cosmo=None): self.z_d = z_lens self.z_s = z_source self.lensCosmo = LensCosmo(z_lens, z_source, cosmo=cosmo) self.lens_analysis = LensAnalysis(kwargs_model) self.lens_model = LensModelExtensions( lens_model_list=kwargs_model['lens_model_list']) self.kwargs_options = kwargs_model kwargs_cosmo = { 'D_d': self.lensCosmo.D_d, 'D_s': self.lensCosmo.D_s, 'D_ds': self.lensCosmo.D_ds } self.dispersion = Velocity_dispersion(kwargs_cosmo=kwargs_cosmo) def time_delays(self, kwargs_lens, kwargs_ps, kappa_ext=0): fermat_pot = self.lens_analysis.fermat_potential( kwargs_lens, kwargs_ps) time_delay = self.lensCosmo.time_delay_units(fermat_pot, kappa_ext) return time_delay def velocity_dispersion(self, kwargs_lens, kwargs_lens_light, aniso_param=1, r_eff=None, R_slit=0.81, dR_slit=0.1, psf_fwhm=0.7, num_evaluate=100): gamma = kwargs_lens[0]['gamma'] if r_eff is None: r_eff = self.lens_analysis.half_light_radius_lens( kwargs_lens_light) theta_E = kwargs_lens[0]['theta_E'] if self.dispersion.beta_const is False: aniso_param *= r_eff sigma2 = self.dispersion.vel_disp(gamma, theta_E, r_eff, aniso_param, R_slit, dR_slit, FWHM=psf_fwhm, num=num_evaluate) return sigma2 def velocity_disperson_numerical(self, kwargs_lens, kwargs_lens_light, kwargs_anisotropy, kwargs_aperture, psf_fwhm, aperture_type, anisotropy_model, r_eff=1., kwargs_numerics={}, MGE_light=False, MGE_mass=False): """ :param kwargs_lens: :param kwargs_lens_light: :param kwargs_anisotropy: :param kwargs_aperature: :return: """ kwargs_cosmo = { 'D_d': self.lensCosmo.D_d, 'D_s': self.lensCosmo.D_s, 'D_ds': self.lensCosmo.D_ds } mass_profile_list = [] kwargs_profile = [] lens_model_internal_bool = self.kwargs_options.get( 'lens_model_deflector_bool', [True] * len(kwargs_lens)) for i, lens_model in enumerate(self.kwargs_options['lens_model_list']): if lens_model_internal_bool[i]: mass_profile_list.append(lens_model) kwargs_lens_i = { k: v for k, v in kwargs_lens[i].items() if not k in ['center_x', 'center_y'] } kwargs_profile.append(kwargs_lens_i) if MGE_mass is True: massModel = LensModelExtensions(lens_model_list=mass_profile_list) theta_E = massModel.effective_einstein_radius(kwargs_lens) r_array = np.logspace(-4, 2, 200) * theta_E mass_r = massModel.kappa(r_array, 0, kwargs_profile) amps, sigmas, norm = mge.mge_1d(r_array, mass_r, N=20) mass_profile_list = ['MULTI_GAUSSIAN_KAPPA'] kwargs_profile = [{'amp': amps, 'sigma': sigmas}] light_profile_list = [] kwargs_light = [] lens_light_model_internal_bool = self.kwargs_options.get( 'light_model_deflector_bool', [True] * len(kwargs_lens_light)) for i, light_model in enumerate( self.kwargs_options['lens_light_model_list']): if lens_light_model_internal_bool[i]: light_profile_list.append(light_model) kwargs_Lens_light_i = { k: v for k, v in kwargs_lens_light[i].items() if not k in ['center_x', 'center_y'] } if 'q' in kwargs_Lens_light_i: kwargs_Lens_light_i['q'] = 1 kwargs_light.append(kwargs_Lens_light_i) if MGE_light is True: lightModel = LightModel(light_profile_list) r_array = np.logspace(-3, 2, 200) * r_eff * 2 flux_r = lightModel.surface_brightness(r_array, 0, kwargs_light) amps, sigmas, norm = mge.mge_1d(r_array, flux_r, N=20) light_profile_list = ['MULTI_GAUSSIAN'] kwargs_light = [{'amp': amps, 'sigma': sigmas}] galkin = Galkin(mass_profile_list, light_profile_list, aperture_type=aperture_type, anisotropy_model=anisotropy_model, fwhm=psf_fwhm, kwargs_cosmo=kwargs_cosmo, kwargs_numerics=kwargs_numerics) sigma_v = galkin.vel_disp(kwargs_profile, kwargs_light, kwargs_anisotropy, kwargs_aperture, r_eff=r_eff) return sigma_v def angular_diameter_relations(self, sigma_v_model, sigma_v, kappa_ext, D_dt_model, z_d): """ :return: """ sigma_v2_model = sigma_v_model**2 Ds_Dds = sigma_v**2 / (1 - kappa_ext) / ( sigma_v2_model * self.lensCosmo.D_ds / self.lensCosmo.D_s) D_d = D_dt_model / (1 + z_d) / Ds_Dds / (1 - kappa_ext) return D_d, Ds_Dds def angular_distances(self, sigma_v_measured, time_delay_measured, kappa_ext, sigma_v_modeled, fermat_pot): """ :param sigma_v_measured: velocity dispersion measured [km/s] :param time_delay_measured: time delay measured [d] :param kappa_ext: external convergence estimated [] :param sigma_v_modeled: lens model velocity dispersion with default cosmology and without external convergence [km/s] :param fermat_pot: fermat potential of lens model, modulo MSD of kappa_ext [arcsec^2] :return: D_d and D_d*D_s/D_ds, units in Mpc physical """ Ds_Dds = (sigma_v_measured / sigma_v_modeled)**2 / ( self.lensCosmo.D_ds / self.lensCosmo.D_s) / (1 - kappa_ext) DdDs_Dds = 1. / (1 + self.lensCosmo.z_lens) / (1 - kappa_ext) * ( const.c * time_delay_measured * const.day_s) / (fermat_pot * const.arcsec**2) / const.Mpc return Ds_Dds, DdDs_Dds
class LensProp(object): """ this class contains routines to compute time delays, magnification ratios, line of sight velocity dispersions etc for a given lens model """ def __init__(self, z_lens, z_source, kwargs_model, cosmo=None): """ :param z_lens: redshift of lens :param z_source: redshift of source :param kwargs_model: model keyword arguments :param cosmo: astropy.cosmology instance """ self.z_d = z_lens self.z_s = z_source self.lensCosmo = LensCosmo(z_lens, z_source, cosmo=cosmo) self.lens_analysis = LensAnalysis(kwargs_model) self._lensModelExt = LensModelExtensions(self.lens_analysis.LensModel) self.kwargs_options = kwargs_model kwargs_cosmo = { 'D_d': self.lensCosmo.D_d, 'D_s': self.lensCosmo.D_s, 'D_ds': self.lensCosmo.D_ds } self.analytic_kinematics = AnalyticKinematics(**kwargs_cosmo) def time_delays(self, kwargs_lens, kwargs_ps, kappa_ext=0): """ predicts the time delays of the image positions :param kwargs_lens: lens model parameters :param kwargs_ps: point source parameters :param kappa_ext: external convergence (optional) :return: time delays at image positions for the fixed cosmology """ fermat_pot = self.lens_analysis.fermat_potential( kwargs_lens, kwargs_ps) time_delay = self.lensCosmo.time_delay_units(fermat_pot, kappa_ext) return time_delay def velocity_dispersion(self, kwargs_lens, kwargs_lens_light, lens_light_model_bool_list=None, aniso_param=1, r_eff=None, R_slit=0.81, dR_slit=0.1, psf_fwhm=0.7, num_evaluate=1000): """ computes the LOS velocity dispersion of the lens within a slit of size R_slit x dR_slit and seeing psf_fwhm. The assumptions are a Hernquist light profile and the spherical power-law lens model at the first position. Further information can be found in the AnalyticKinematics() class. :param kwargs_lens: lens model parameters :param kwargs_lens_light: deflector light parameters :param aniso_param: scaled r_ani with respect to the half light radius :param r_eff: half light radius, if not provided, will be computed from the lens light model :param R_slit: width of the slit :param dR_slit: length of the slit :param psf_fwhm: full width at half maximum of the seeing condition :param num_evaluate: number of spectral rendering of the light distribution that end up on the slit :return: velocity dispersion in units [km/s] """ gamma = kwargs_lens[0]['gamma'] if 'center_x' in kwargs_lens_light[0]: center_x, center_y = kwargs_lens_light[0][ 'center_x'], kwargs_lens_light[0]['center_y'] else: center_x, center_y = 0, 0 if r_eff is None: r_eff = self.lens_analysis.half_light_radius_lens( kwargs_lens_light, center_x=center_x, center_y=center_y, model_bool_list=lens_light_model_bool_list) theta_E = kwargs_lens[0]['theta_E'] r_ani = aniso_param * r_eff sigma2 = self.analytic_kinematics.vel_disp( gamma, theta_E, r_eff, r_ani, R_slit, dR_slit, FWHM=psf_fwhm, rendering_number=num_evaluate) return sigma2 def velocity_dispersion_numerical(self, kwargs_lens, kwargs_lens_light, kwargs_anisotropy, kwargs_aperture, psf_fwhm, aperture_type, anisotropy_model, r_eff=None, kwargs_numerics={}, MGE_light=False, MGE_mass=False, lens_model_kinematics_bool=None, light_model_kinematics_bool=None, Hernquist_approx=False): """ Computes the LOS velocity dispersion of the deflector galaxy with arbitrary combinations of light and mass models. For a detailed description, visit the description of the Galkin() class. Additionaly to executing the Galkin routine, it has an optional Multi-Gaussian-Expansion decomposition of lens and light models that do not have a three-dimensional distribution built in, such as Sersic profiles etc. The center of all the lens and lens light models that are part of the kinematic estimate must be centered on the same point. :param kwargs_lens: lens model parameters :param kwargs_lens_light: lens light parameters :param kwargs_anisotropy: anisotropy parameters (see Galkin module) :param kwargs_aperture: aperture parameters (see Galkin module) :param psf_fwhm: full width at half maximum of the seeing (Gaussian form) :param aperture_type: type of aperture (see Galkin module :param anisotropy_model: stellar anisotropy model (see Galkin module) :param r_eff: a rough estimate of the half light radius of the lens light in case of computing the MGE of the light profile :param kwargs_numerics: keyword arguments that contain numerical options (see Galkin module) :param MGE_light: bool, if true performs the MGE for the light distribution :param MGE_mass: bool, if true performs the MGE for the mass distribution :param lens_model_kinematics_bool: bool list of length of the lens model. Only takes a subset of all the models as part of the kinematics computation (can be used to ignore substructure, shear etc that do not describe the main deflector potential :param light_model_kinematics_bool: bool list of length of the light model. Only takes a subset of all the models as part of the kinematics computation (can be used to ignore light components that do not describe the main deflector :return: LOS velocity dispersion [km/s] """ kwargs_cosmo = { 'D_d': self.lensCosmo.D_d, 'D_s': self.lensCosmo.D_s, 'D_ds': self.lensCosmo.D_ds } mass_profile_list = [] kwargs_profile = [] if lens_model_kinematics_bool is None: lens_model_kinematics_bool = [True] * len(kwargs_lens) for i, lens_model in enumerate(self.kwargs_options['lens_model_list']): if lens_model_kinematics_bool[i] is True: mass_profile_list.append(lens_model) if lens_model in ['INTERPOL', 'INTERPOL_SCLAED']: center_x, center_y = self._lensModelExt.lens_center( kwargs_lens, k=i) kwargs_lens_i = copy.deepcopy(kwargs_lens[i]) kwargs_lens_i['grid_interp_x'] -= center_x kwargs_lens_i['grid_interp_y'] -= center_y else: kwargs_lens_i = { k: v for k, v in kwargs_lens[i].items() if not k in ['center_x', 'center_y'] } kwargs_profile.append(kwargs_lens_i) if MGE_mass is True: lensModel = LensModel(lens_model_list=mass_profile_list) massModel = LensModelExtensions(lensModel) theta_E = massModel.effective_einstein_radius(kwargs_profile) r_array = np.logspace(-4, 2, 200) * theta_E mass_r = lensModel.kappa(r_array, np.zeros_like(r_array), kwargs_profile) amps, sigmas, norm = mge.mge_1d(r_array, mass_r, N=20) mass_profile_list = ['MULTI_GAUSSIAN_KAPPA'] kwargs_profile = [{'amp': amps, 'sigma': sigmas}] light_profile_list = [] kwargs_light = [] if light_model_kinematics_bool is None: light_model_kinematics_bool = [True] * len(kwargs_lens_light) for i, light_model in enumerate( self.kwargs_options['lens_light_model_list']): if light_model_kinematics_bool[i]: light_profile_list.append(light_model) kwargs_lens_light_i = { k: v for k, v in kwargs_lens_light[i].items() if not k in ['center_x', 'center_y'] } if 'q' in kwargs_lens_light_i: kwargs_lens_light_i['q'] = 1 kwargs_light.append(kwargs_lens_light_i) if r_eff is None: lensAnalysis = LensAnalysis( {'lens_light_model_list': light_profile_list}) r_eff = lensAnalysis.half_light_radius_lens( kwargs_light, model_bool_list=light_model_kinematics_bool) if Hernquist_approx is True: light_profile_list = ['HERNQUIST'] kwargs_light = [{'Rs': r_eff, 'amp': 1.}] else: if MGE_light is True: lightModel = LightModel(light_profile_list) r_array = np.logspace(-3, 2, 200) * r_eff * 2 flux_r = lightModel.surface_brightness(r_array, 0, kwargs_light) amps, sigmas, norm = mge.mge_1d(r_array, flux_r, N=20) light_profile_list = ['MULTI_GAUSSIAN'] kwargs_light = [{'amp': amps, 'sigma': sigmas}] galkin = Galkin(mass_profile_list, light_profile_list, aperture_type=aperture_type, anisotropy_model=anisotropy_model, fwhm=psf_fwhm, kwargs_cosmo=kwargs_cosmo, **kwargs_numerics) sigma2 = galkin.vel_disp(kwargs_profile, kwargs_light, kwargs_anisotropy, kwargs_aperture) return sigma2 def angular_diameter_relations(self, sigma_v_model, sigma_v, kappa_ext, D_dt_model): """ :return: """ sigma_v2_model = sigma_v_model**2 Ds_Dds = sigma_v**2 / (1 - kappa_ext) / ( sigma_v2_model * self.lensCosmo.D_ds / self.lensCosmo.D_s) D_d = D_dt_model / (1 + self.lensCosmo.z_lens) / Ds_Dds / (1 - kappa_ext) return D_d, Ds_Dds def angular_distances(self, sigma_v_measured, time_delay_measured, kappa_ext, sigma_v_modeled, fermat_pot): """ :param sigma_v_measured: velocity dispersion measured [km/s] :param time_delay_measured: time delay measured [d] :param kappa_ext: external convergence estimated [] :param sigma_v_modeled: lens model velocity dispersion with default cosmology and without external convergence [km/s] :param fermat_pot: fermat potential of lens model, modulo MSD of kappa_ext [arcsec^2] :return: D_d and D_d*D_s/D_ds, units in Mpc physical """ Ds_Dds = (sigma_v_measured / float(sigma_v_modeled))**2 / ( self.lensCosmo.D_ds / self.lensCosmo.D_s) / (1. - kappa_ext) DdDs_Dds = 1. / (1 + self.lensCosmo.z_lens) / (1. - kappa_ext) * ( const.c * time_delay_measured * const.day_s) / (fermat_pot * const.arcsec**2) / const.Mpc return Ds_Dds, DdDs_Dds
def velocity_dispersion_numerical(self, kwargs_lens, kwargs_lens_light, kwargs_anisotropy, kwargs_aperture, psf_fwhm, aperture_type, anisotropy_model, r_eff=None, kwargs_numerics={}, MGE_light=False, MGE_mass=False, lens_model_kinematics_bool=None, light_model_kinematics_bool=None, Hernquist_approx=False): """ Computes the LOS velocity dispersion of the deflector galaxy with arbitrary combinations of light and mass models. For a detailed description, visit the description of the Galkin() class. Additionaly to executing the Galkin routine, it has an optional Multi-Gaussian-Expansion decomposition of lens and light models that do not have a three-dimensional distribution built in, such as Sersic profiles etc. The center of all the lens and lens light models that are part of the kinematic estimate must be centered on the same point. :param kwargs_lens: lens model parameters :param kwargs_lens_light: lens light parameters :param kwargs_anisotropy: anisotropy parameters (see Galkin module) :param kwargs_aperture: aperture parameters (see Galkin module) :param psf_fwhm: full width at half maximum of the seeing (Gaussian form) :param aperture_type: type of aperture (see Galkin module :param anisotropy_model: stellar anisotropy model (see Galkin module) :param r_eff: a rough estimate of the half light radius of the lens light in case of computing the MGE of the light profile :param kwargs_numerics: keyword arguments that contain numerical options (see Galkin module) :param MGE_light: bool, if true performs the MGE for the light distribution :param MGE_mass: bool, if true performs the MGE for the mass distribution :param lens_model_kinematics_bool: bool list of length of the lens model. Only takes a subset of all the models as part of the kinematics computation (can be used to ignore substructure, shear etc that do not describe the main deflector potential :param light_model_kinematics_bool: bool list of length of the light model. Only takes a subset of all the models as part of the kinematics computation (can be used to ignore light components that do not describe the main deflector :return: LOS velocity dispersion [km/s] """ kwargs_cosmo = { 'D_d': self.lensCosmo.D_d, 'D_s': self.lensCosmo.D_s, 'D_ds': self.lensCosmo.D_ds } mass_profile_list = [] kwargs_profile = [] if lens_model_kinematics_bool is None: lens_model_kinematics_bool = [True] * len(kwargs_lens) for i, lens_model in enumerate(self.kwargs_options['lens_model_list']): if lens_model_kinematics_bool[i] is True: mass_profile_list.append(lens_model) if lens_model in ['INTERPOL', 'INTERPOL_SCLAED']: center_x, center_y = self._lensModelExt.lens_center( kwargs_lens, k=i) kwargs_lens_i = copy.deepcopy(kwargs_lens[i]) kwargs_lens_i['grid_interp_x'] -= center_x kwargs_lens_i['grid_interp_y'] -= center_y else: kwargs_lens_i = { k: v for k, v in kwargs_lens[i].items() if not k in ['center_x', 'center_y'] } kwargs_profile.append(kwargs_lens_i) if MGE_mass is True: lensModel = LensModel(lens_model_list=mass_profile_list) massModel = LensModelExtensions(lensModel) theta_E = massModel.effective_einstein_radius(kwargs_profile) r_array = np.logspace(-4, 2, 200) * theta_E mass_r = lensModel.kappa(r_array, np.zeros_like(r_array), kwargs_profile) amps, sigmas, norm = mge.mge_1d(r_array, mass_r, N=20) mass_profile_list = ['MULTI_GAUSSIAN_KAPPA'] kwargs_profile = [{'amp': amps, 'sigma': sigmas}] light_profile_list = [] kwargs_light = [] if light_model_kinematics_bool is None: light_model_kinematics_bool = [True] * len(kwargs_lens_light) for i, light_model in enumerate( self.kwargs_options['lens_light_model_list']): if light_model_kinematics_bool[i]: light_profile_list.append(light_model) kwargs_lens_light_i = { k: v for k, v in kwargs_lens_light[i].items() if not k in ['center_x', 'center_y'] } if 'q' in kwargs_lens_light_i: kwargs_lens_light_i['q'] = 1 kwargs_light.append(kwargs_lens_light_i) if r_eff is None: lensAnalysis = LensAnalysis( {'lens_light_model_list': light_profile_list}) r_eff = lensAnalysis.half_light_radius_lens( kwargs_light, model_bool_list=light_model_kinematics_bool) if Hernquist_approx is True: light_profile_list = ['HERNQUIST'] kwargs_light = [{'Rs': r_eff, 'amp': 1.}] else: if MGE_light is True: lightModel = LightModel(light_profile_list) r_array = np.logspace(-3, 2, 200) * r_eff * 2 flux_r = lightModel.surface_brightness(r_array, 0, kwargs_light) amps, sigmas, norm = mge.mge_1d(r_array, flux_r, N=20) light_profile_list = ['MULTI_GAUSSIAN'] kwargs_light = [{'amp': amps, 'sigma': sigmas}] galkin = Galkin(mass_profile_list, light_profile_list, aperture_type=aperture_type, anisotropy_model=anisotropy_model, fwhm=psf_fwhm, kwargs_cosmo=kwargs_cosmo, **kwargs_numerics) sigma2 = galkin.vel_disp(kwargs_profile, kwargs_light, kwargs_anisotropy, kwargs_aperture) return sigma2