def test_draw_light_PJaffe(self):
np.random.seed(41)
lightProfile = LightProfile(profile_list=['PJAFFE'])
kwargs_profile = [{'amp': 1., 'Rs': 0.5, 'Ra': 0.2}]
r_list = lightProfile.draw_light_2d(kwargs_profile, n=100000)
bins = np.linspace(0, 2, 10)
hist, bins_hist = np.histogram(r_list, bins=bins, density=True)
light2d = lightProfile.light_2d(R=(bins_hist[1:] + bins_hist[:-1]) /
2.,
kwargs_list=kwargs_profile)
light2d *= (bins_hist[1:] + bins_hist[:-1]) / 2.
light2d /= np.sum(light2d)
hist /= np.sum(hist)
print(light2d / hist)
npt.assert_almost_equal(light2d[8] / hist[8], 1, decimal=1)
lightProfile = LightProfile(profile_list=['PJAFFE'],
min_interpolate=0.0001,
max_interpolate=20.)
kwargs_profile = [{'amp': 1., 'Rs': 0.04, 'Ra': 0.02}]
r_list = lightProfile.draw_light_2d(kwargs_profile, n=100000)
bins = np.linspace(0., 0.1, 10)
hist, bins_hist = np.histogram(r_list, bins=bins, density=True)
light2d = lightProfile.light_2d(R=(bins_hist[1:] + bins_hist[:-1]) /
2.,
kwargs_list=kwargs_profile)
light2d *= (bins_hist[1:] + bins_hist[:-1]) / 2.
light2d /= np.sum(light2d)
hist /= np.sum(hist)
print(light2d / hist)
npt.assert_almost_equal(light2d[5] / hist[5], 1, decimal=1)
assert hasattr(lightProfile, '_kwargs_light_circularized')
lightProfile.delete_cache()
if hasattr(lightProfile, '_kwargs_light_circularized'):
assert False
def test_draw_light_PJaffe(self):
lightProfile = LightProfile(profile_list=['PJAFFE'])
kwargs_profile = [{'amp': 1., 'Rs': 0.5, 'Ra': 0.2}]
r_list = lightProfile.draw_light_2d(kwargs_profile, n=100000)
bins = np.linspace(0, 2, 10)
hist, bins_hist = np.histogram(r_list, bins=bins, normed=True)
light2d = lightProfile.light_2d(R=(bins_hist[1:] + bins_hist[:-1]) /
2.,
kwargs_list=kwargs_profile)
light2d *= (bins_hist[1:] + bins_hist[:-1]) / 2.
light2d /= np.sum(light2d)
hist /= np.sum(hist)
print(light2d / hist)
npt.assert_almost_equal(light2d[8] / hist[8], 1, decimal=1)
lightProfile = LightProfile(profile_list=['PJAFFE'],
min_interpolate=0.0001,
max_interpolate=20.)
kwargs_profile = [{'amp': 1., 'Rs': 0.04, 'Ra': 0.02}]
r_list = lightProfile.draw_light_2d(kwargs_profile, n=100000)
bins = np.linspace(0., 0.1, 10)
hist, bins_hist = np.histogram(r_list, bins=bins, normed=True)
light2d = lightProfile.light_2d(R=(bins_hist[1:] + bins_hist[:-1]) /
2.,
kwargs_list=kwargs_profile)
light2d *= (bins_hist[1:] + bins_hist[:-1]) / 2.
light2d /= np.sum(light2d)
hist /= np.sum(hist)
print(light2d / hist)
npt.assert_almost_equal(light2d[5] / hist[5], 1, decimal=1)
def test_draw_light_2d_linear(self):
np.random.seed(41)
lightProfile = LightProfile(profile_list=['HERNQUIST'],
interpol_grid_num=1000,
max_interpolate=10,
min_interpolate=0.01)
kwargs_profile = [{'amp': 1., 'Rs': 0.8}]
r_list = lightProfile.draw_light_2d_linear(kwargs_profile, n=100000)
bins = np.linspace(0., 1, 20)
hist, bins_hist = np.histogram(r_list, bins=bins, density=True)
light2d = lightProfile.light_2d(R=(bins_hist[1:] + bins_hist[:-1]) /
2.,
kwargs_list=kwargs_profile)
light2d_upper = lightProfile.light_2d(
R=bins_hist[1:], kwargs_list=kwargs_profile) * bins_hist[1:]
light2d_lower = lightProfile.light_2d(
R=bins_hist[:-1], kwargs_list=kwargs_profile) * bins_hist[:-1]
light2d *= (bins_hist[1:] + bins_hist[:-1]) / 2.
print((light2d_upper - light2d_lower) /
(light2d_upper + light2d_lower) * 2)
light2d /= np.sum(light2d)
hist /= np.sum(hist)
print(light2d / hist)
for i in range(2, len(hist)):
print(bins_hist[i], i, light2d[i] / hist[i])
npt.assert_almost_equal(light2d[i] / hist[i], 1, decimal=1)
def __init__(self, mass_profile_list, light_profile_list, aperture_type='slit', anisotropy_model='isotropic',
psf_type='GAUSSIAN', fwhm=0.7, moffat_beta=2.6, kwargs_cosmo={'D_d': 1000, 'D_s': 2000, 'D_ds': 500},
sampling_number=1000, interpol_grid_num=500, log_integration=False, max_integrate=10, min_integrate=0.001):
"""
:param mass_profile_list: list of lens (mass) model profiles
:param light_profile_list: list of light model profiles of the lensing galaxy
:param aperture_type: type of slit/shell aperture where the light is coming from. See details in Aperture() class.
:param anisotropy_model: type of stellar anisotropy model. See details in MamonLokasAnisotropy() class.
:param psf_type: string, point spread functino type, current support for 'GAUSSIAN' and 'MOFFAT'
:param fwhm: full width at half maximum seeing condition
:param moffat_beta: float, beta parameter of Moffat profile
:param kwargs_cosmo: keyword arguments that define the cosmology in terms of the angular diameter distances involved
"""
self.massProfile = MassProfile(mass_profile_list, kwargs_cosmo, interpol_grid_num=interpol_grid_num,
max_interpolate=max_integrate, min_interpolate=min_integrate)
self.lightProfile = LightProfile(light_profile_list, interpol_grid_num=interpol_grid_num,
max_interpolate=max_integrate, min_interpolate=min_integrate)
self.aperture = Aperture(aperture_type)
self.anisotropy = MamonLokasAnisotropy(anisotropy_model)
self.cosmo = Cosmo(**kwargs_cosmo)
self._num_sampling = sampling_number
self._interp_grid_num = interpol_grid_num
self._log_int = log_integration
self._max_integrate = max_integrate # maximal integration (and interpolation) in units of arcsecs
self._min_integrate = min_integrate # min integration (and interpolation) in units of arcsecs
self._psf = PSF(psf_type=psf_type, fwhm=fwhm, moffat_beta=moffat_beta)
def __init__(self, mass_profile_list, light_profile_list, kwargs_aperture, kwargs_psf, anisotropy_model='isotropic',
kwargs_cosmo={'D_d': 1000, 'D_s': 2000, 'D_ds': 500},
sampling_number=1000, interpol_grid_num=500, log_integration=False, max_integrate=10, min_integrate=0.001):
"""
:param mass_profile_list: list of lens (mass) model profiles
:param light_profile_list: list of light model profiles of the lensing galaxy
:param kwargs_aperture: keyword arguments describing the spectroscopic aperture, see Aperture() class
:param anisotropy_model: type of stellar anisotropy model. See details in MamonLokasAnisotropy() class.
:param kwargs_psf: keyword argument specifying the PSF of the observation
:param kwargs_cosmo: keyword arguments that define the cosmology in terms of the angular diameter distances involved
"""
self.massProfile = MassProfile(mass_profile_list, kwargs_cosmo, interpol_grid_num=interpol_grid_num,
max_interpolate=max_integrate, min_interpolate=min_integrate)
self.lightProfile = LightProfile(light_profile_list, interpol_grid_num=interpol_grid_num,
max_interpolate=max_integrate, min_interpolate=min_integrate)
self.aperture = aperture_select(**kwargs_aperture)
self.anisotropy = MamonLokasAnisotropy(anisotropy_model)
self.cosmo = Cosmo(**kwargs_cosmo)
self._num_sampling = sampling_number
self._interp_grid_num = interpol_grid_num
self._log_int = log_integration
self._max_integrate = max_integrate # maximal integration (and interpolation) in units of arcsecs
self._min_integrate = min_integrate # min integration (and interpolation) in units of arcsecs
self._psf = psf_select(**kwargs_psf)
def test_draw_light_3d(self):
lightProfile = LightProfile(profile_list=['HERNQUIST'],
min_interpolate=0.0001,
max_interpolate=100.)
kwargs_profile = [{'amp': 1., 'Rs': 0.5}]
r_list = lightProfile.draw_light_3d(kwargs_profile,
n=100000,
new_compute=False)
print(r_list, 'r_list')
# project it
R, x, y = velocity_util.project2d_random(r_list)
# test with draw light 2d profile routine
bins = np.linspace(0.1, 1, 10)
hist, bins_hist = np.histogram(r_list, bins=bins, density=True)
bins_plot = (bins_hist[1:] + bins_hist[:-1]) / 2.
light3d = lightProfile.light_3d(r=bins_plot,
kwargs_list=kwargs_profile)
light3d *= bins_plot**2
light3d /= np.sum(light3d)
hist /= np.sum(hist)
#import matplotlib.pyplot as plt
#plt.plot(bins_plot , light3d/light3d[5], label='3d reference')
#plt.plot(bins_plot, hist / hist[5], label='hist')
#plt.legend()
#plt.show()
print(light3d / hist)
npt.assert_almost_equal(light3d[5] / hist[5], 1, decimal=1)
def __init__(self,
mass_profile_list,
light_profile_list,
aperture_type='slit',
anisotropy_model='isotropic',
fwhm=0.7,
kwargs_numerics={},
kwargs_cosmo={
'D_d': 1000,
'D_s': 2000,
'D_ds': 500
}):
self.massProfile = MassProfile(mass_profile_list,
kwargs_cosmo,
kwargs_numerics=kwargs_numerics)
self.lightProfile = LightProfile(light_profile_list,
kwargs_numerics=kwargs_numerics)
self.aperture = Aperture(aperture_type)
self.anisotropy = MamonLokasAnisotropy(anisotropy_model)
self.FWHM = fwhm
self.cosmo = Cosmo(kwargs_cosmo)
#kwargs_numerics = {'sampling_number': 10000, 'interpol_grid_num': 5000, 'log_integration': False,
# 'max_integrate': 500}
self._num_sampling = kwargs_numerics.get('sampling_number', 1000)
self._interp_grid_num = kwargs_numerics.get('interpol_grid_num', 500)
self._log_int = kwargs_numerics.get('log_integration', False)
self._max_integrate = kwargs_numerics.get(
'max_integrate',
10) # maximal integration (and interpolation) in units of arcsecs
self._min_integrate = kwargs_numerics.get(
'min_integrate',
0.001) # min integration (and interpolation) in units of arcsecs
def __init__(self,
kwargs_model,
kwargs_cosmo,
interpol_grid_num=100,
log_integration=False,
max_integrate=100,
min_integrate=0.001):
"""
:param interpol_grid_num:
:param log_integration:
:param max_integrate:
:param min_integrate:
"""
mass_profile_list = kwargs_model.get('mass_profile_list')
light_profile_list = kwargs_model.get('light_profile_list')
anisotropy_model = kwargs_model.get('anisotropy_model')
self._interp_grid_num = interpol_grid_num
self._log_int = log_integration
self._max_integrate = max_integrate # maximal integration (and interpolation) in units of arcsecs
self._min_integrate = min_integrate # min integration (and interpolation) in units of arcsecs
self._max_interpolate = max_integrate # we chose to set the interpolation range to the integration range
self._min_interpolate = min_integrate # we chose to set the interpolation range to the integration range
self.lightProfile = LightProfile(light_profile_list,
interpol_grid_num=interpol_grid_num,
max_interpolate=max_integrate,
min_interpolate=min_integrate)
Anisotropy.__init__(self, anisotropy_type=anisotropy_model)
self.cosmo = Cosmo(**kwargs_cosmo)
self._mass_profile = SinglePlane(mass_profile_list)
def test_realistic(self):
"""
realistic test example
:return:
"""
light_profile_list = ['HERNQUIST_ELLIPSE', 'PJAFFE_ELLIPSE']
phi, q = 0.74260706384506325, 0.46728323131925864
e1, e2 = param_util.phi_q2_ellipticity(phi, q)
phi2, q2 = -0.33379268413794494, 0.66582356813012267
e12, e22 = param_util.phi_q2_ellipticity(phi2, q2)
kwargs_light = [{
'Rs': 0.10535462602138289,
'e1': e1,
'e2': e2,
'center_x': -0.02678473951679429,
'center_y': 0.88691126347462712,
'amp': 3.7114695634960109
}, {
'Rs': 0.44955054610388684,
'e1': e12,
'e2': e22,
'center_x': 0.019536801118136753,
'center_y': 0.0218888643537157,
'Ra': 0.0010000053334891974,
'amp': 967.00280526319796
}]
lightProfile = LightProfile(light_profile_list)
R = 0.01
light2d = lightProfile.light_2d(R=R, kwargs_list=kwargs_light)
out = integrate.quad(
lambda x: lightProfile.light_3d(np.sqrt(R**2 + x**2), kwargs_light
), 0, 100)
print(out, 'out')
npt.assert_almost_equal(light2d / (out[0] * 2), 1., decimal=3)
def test_light_3d(self):
lightProfile = LightProfile(profile_list=['HERNQUIST'])
r = np.logspace(-2, 2, 100)
kwargs_profile = [{'amp': 1., 'Rs': 0.5}]
light_3d = lightProfile.light_3d_interp(r, kwargs_profile)
light_3d_exact = lightProfile.light_3d(r, kwargs_profile)
for i in range(len(r)):
npt.assert_almost_equal(light_3d[i]/light_3d_exact[i], 1, decimal=3)
def test_del_cache(self):
lightProfile = LightProfile(profile_list=['HERNQUIST'])
lightProfile._light_cdf = 1
lightProfile._light_cdf_log = 2
lightProfile._f_light_3d = 3
lightProfile.delete_cache()
assert hasattr(lightProfile, '_light_cdf') is False
assert hasattr(lightProfile, '_light_cdf_log') is False
assert hasattr(lightProfile, '_f_light_3d') is False
def test_draw_light_3d_hernquist(self):
lightProfile = LightProfile(profile_list=['HERNQUIST'], min_interpolate=0.0001, max_interpolate=1000.)
kwargs_profile = [{'amp': 1., 'Rs': 0.5}]
r_list = lightProfile.draw_light_3d(kwargs_profile, n=1000000, new_compute=False)
print(r_list, 'r_list')
# project it
# test with draw light 2d profile routine
# compare with 3d analytical solution vs histogram binned
bins = np.linspace(0.0, 10, 20)
hist, bins_hist = np.histogram(r_list, bins=bins, density=True)
bins_plot = (bins_hist[1:] + bins_hist[:-1]) / 2.
light3d = lightProfile.light_3d(r=bins_plot, kwargs_list=kwargs_profile)
light3d *= bins_plot ** 2
light3d /= np.sum(light3d)
hist /= np.sum(hist)
#import matplotlib.pyplot as plt
#plt.plot(bins_plot , light3d/light3d[5], label='3d reference Hernquist')
#plt.plot(bins_plot, hist / hist[5], label='hist')
#plt.legend()
#plt.show()
print(light3d / hist)
#npt.assert_almost_equal(light3d / hist, 1, decimal=1)
# compare with 2d analytical solution vs histogram binned
#bins = np.linspace(0.1, 1, 10)
R, x, y = velocity_util.project2d_random(np.array(r_list))
hist_2d, bins_hist = np.histogram(R, bins=bins, density=True)
hist_2d /= np.sum(hist_2d)
bins_plot = (bins_hist[1:] + bins_hist[:-1]) / 2.
light2d = lightProfile.light_2d(R=bins_plot, kwargs_list=kwargs_profile)
light2d *= bins_plot ** 1
light2d /= np.sum(light2d)
light2d_finite = lightProfile.light_2d_finite(R=bins_plot, kwargs_list=kwargs_profile)
light2d_finite *= bins_plot ** 1
light2d_finite /= np.sum(light2d_finite)
hist /= np.sum(hist)
#import matplotlib.pyplot as plt
#plt.plot(bins_plot, light2d/light2d[5], '--', label='2d reference Hernquist')
#plt.plot(bins_plot, light2d_finite / light2d_finite[5], '-.', label='2d reference Hernquist finite')
#plt.plot(bins_plot, hist_2d / hist_2d[5], label='hist')
#plt.legend()
#plt.show()
print(light2d / hist_2d)
#plt.plot(R, r_list, '.', label='test')
#plt.legend()
#plt.xlim([0, 0.2])
#plt.ylim([0, 0.2])
#plt.show()
npt.assert_almost_equal(light2d / hist_2d, 1, decimal=1)
def test_projected_light_integral_pjaffe(self):
"""
:return:
"""
light_profile_list = ['PJAFFE']
kwargs_light = [{'Rs': .5, 'Ra': 0.01, 'sigma0': 1.}] # effective half light radius (2d projected) in arcsec
lightProfile = LightProfile(light_profile_list)
R = 0.01
light2d = lightProfile.light_2d(R=R, kwargs_list=kwargs_light)
out = integrate.quad(lambda x: lightProfile.light_3d(np.sqrt(R**2+x**2), kwargs_light), 0, 100)
print(out, 'out')
npt.assert_almost_equal(light2d/(out[0]*2), 1., decimal=3)
def test_projected_light_integral_hernquist_ellipse(self):
"""
:return:
"""
light_profile_list = ['HERNQUIST_ELLIPSE']
r_eff = 1.
kwargs_light = [{'Rs': r_eff, 'sigma0': 1., 'q': 0.8, 'phi_G': 1.}] # effective half light radius (2d projected) in arcsec
lightProfile = LightProfile(light_profile_list)
R = 2
light2d = lightProfile.light_2d(R=R, kwargs_list=kwargs_light)
out = integrate.quad(lambda x: lightProfile.light_3d(np.sqrt(R**2+x**2), kwargs_light), 0, 10)
npt.assert_almost_equal(light2d, out[0]*2, decimal=3)
def test_projected_light_integral_hernquist(self):
"""
:return:
"""
light_profile_list = ['HERNQUIST']
Rs = 1.
kwargs_light = [{'Rs': Rs, 'amp': 1.}] # effective half light radius (2d projected) in arcsec
lightProfile = LightProfile(light_profile_list)
R = 2
light2d = lightProfile.light_2d(R=R, kwargs_list=kwargs_light)
out = integrate.quad(lambda x: lightProfile.light_3d(np.sqrt(R**2+x**2), kwargs_light), 0, 100)
npt.assert_almost_equal(light2d, out[0]*2, decimal=3)
def test_realistic_1(self):
"""
realistic test example
:return:
"""
light_profile_list = ['HERNQUIST_ELLIPSE']
kwargs_light = [{'Rs': 0.10535462602138289, 'q': 0.46728323131925864, 'center_x': -0.02678473951679429, 'center_y': 0.88691126347462712, 'phi_G': 0.74260706384506325, 'sigma0': 3.7114695634960109}]
lightProfile = LightProfile(light_profile_list)
R = 0.01
light2d = lightProfile.light_2d(R=R, kwargs_list=kwargs_light)
out = integrate.quad(lambda x: lightProfile.light_3d(np.sqrt(R**2+x**2), kwargs_light), 0, 100)
print(out, 'out')
npt.assert_almost_equal(light2d/(out[0]*2), 1., decimal=3)
def test_draw_light(self):
lightProfile = LightProfile(profile_list=['HERNQUIST'])
kwargs_profile = [{'amp': 1., 'Rs': 0.8}]
r_list = lightProfile.draw_light_2d(kwargs_profile, n=500000)
bins = np.linspace(0., 1, 20)
hist, bins_hist = np.histogram(r_list, bins=bins, normed=True)
light2d = lightProfile.light_2d(R=(bins_hist[1:] + bins_hist[:-1])/2., kwargs_list=kwargs_profile)
light2d *= (bins_hist[1:] + bins_hist[:-1]) / 2.
light2d /= np.sum(light2d)
hist /= np.sum(hist)
print(light2d / hist)
for i in range(len(hist)):
print(bins_hist[i], i, light2d[i] / hist[i])
npt.assert_almost_equal(light2d[i] / hist[i], 1, decimal=1)
def test_projected_light_integral_hernquist_ellipse(self):
"""
:return:
"""
light_profile_list = ['HERNQUIST_ELLIPSE']
Rs = 1.
phi, q = 1, 0.8
e1, e2 = param_util.phi_q2_ellipticity(phi, q)
kwargs_light = [{'Rs': Rs, 'amp': 1.,'e1': e1, 'e2': e2}] # effective half light radius (2d projected) in arcsec
lightProfile = LightProfile(light_profile_list)
R = 2
light2d = lightProfile.light_2d(R=R, kwargs_list=kwargs_light)
out = integrate.quad(lambda x: lightProfile.light_3d(np.sqrt(R**2+x**2), kwargs_light), 0, 10)
npt.assert_almost_equal(light2d, out[0]*2, decimal=3)
def test_draw_light_2d_linear(self):
lightProfile = LightProfile(profile_list=['HERNQUIST'])
kwargs_profile = [{'sigma0': 1., 'Rs': 0.8}]
r_list = lightProfile.draw_light_2d_linear(kwargs_profile, n=100000)
bins = np.linspace(0., 1, 20)
hist, bins_hist = np.histogram(r_list, bins=bins, normed=True)
light2d = lightProfile.light_2d(R=(bins_hist[1:] + bins_hist[:-1])/2., kwargs_list=kwargs_profile)
light2d_upper = lightProfile.light_2d(R=bins_hist[1:], kwargs_list=kwargs_profile) * bins_hist[1:]
light2d_lower = lightProfile.light_2d(R=bins_hist[:-1], kwargs_list=kwargs_profile) * bins_hist[:-1]
light2d *= (bins_hist[1:] + bins_hist[:-1]) / 2.
print((light2d_upper - light2d_lower)/(light2d_upper + light2d_lower) * 2)
light2d /= np.sum(light2d)
hist /= np.sum(hist)
print(light2d / hist)
for i in range(2, len(hist)):
print(bins_hist[i], i, light2d[i] / hist[i])
npt.assert_almost_equal(light2d[i] / hist[i], 1, decimal=1)
def __init__(self,
kwargs_model,
kwargs_cosmo,
interpol_grid_num=1000,
log_integration=True,
max_integrate=1000,
min_integrate=0.0001,
max_light_draw=None,
lum_weight_int_method=True):
"""
What we need:
- max projected R to have ACCURATE I_R_sigma values
- make sure everything outside cancels out (or is not rendered)
:param interpol_grid_num: number of interpolation bins for integrand and interpolated functions
:param log_integration: bool, if True, performs the numerical integral in log space distance (adviced)
(only applies for lum_weight_int_method=True)
:param max_integrate: maximum radius (in arc seconds) of the Jeans equation integral
(assumes zero tracer particles outside this radius)
:param max_light_draw: float; (optional) if set, draws up to this radius, else uses max_interpolate value
:param lum_weight_int_method: bool, luminosity weighted dispersion integral to calculate LOS projected Jean's
solution. ATTENTION: currently less accurate than 3d solution
:param min_integrate:
"""
mass_profile_list = kwargs_model.get('mass_profile_list')
light_profile_list = kwargs_model.get('light_profile_list')
anisotropy_model = kwargs_model.get('anisotropy_model')
self._interp_grid_num = interpol_grid_num
self._log_int = log_integration
self._max_integrate = max_integrate # maximal integration (and interpolation) in units of arcsecs
self._min_integrate = min_integrate # min integration (and interpolation) in units of arcsecs
self._max_interpolate = max_integrate # we chose to set the interpolation range to the integration range
self._min_interpolate = min_integrate # we chose to set the interpolation range to the integration range
if max_light_draw is None:
max_light_draw = max_integrate # make sure the actual solution for the kinematics is only computed way inside the integral
self.lightProfile = LightProfile(light_profile_list,
interpol_grid_num=interpol_grid_num,
max_interpolate=max_integrate,
min_interpolate=min_integrate,
max_draw=max_light_draw)
Anisotropy.__init__(self, anisotropy_type=anisotropy_model)
self.cosmo = Cosmo(**kwargs_cosmo)
self._mass_profile = SinglePlane(mass_profile_list)
self._lum_weight_int_method = lum_weight_int_method
def __init__(self,
mass_profile_list,
light_profile_list,
aperture_type='slit',
anisotropy_model='isotropic',
fwhm=0.7,
kwargs_cosmo={
'D_d': 1000,
'D_s': 2000,
'D_ds': 500
},
sampling_number=1000,
interpol_grid_num=500,
log_integration=False,
max_integrate=10,
min_integrate=0.001):
"""
:param mass_profile_list: list of lens (mass) model profiles
:param light_profile_list: list of light model profiles of the lensing galaxy
:param aperture_type: type of slit/shell aperture where the light is coming from. See details in Aperture() class.
:param anisotropy_model: type of stellar anisotropy model. See details in MamonLokasAnisotropy() class.
:param fwhm: full width at half maximum seeing condition
:param kwargs_numerics: keyword arguments that control the numerical computation
:param kwargs_cosmo: keyword arguments that define the cosmology in terms of the angular diameter distances involved
"""
self.massProfile = MassProfile(mass_profile_list,
kwargs_cosmo,
interpol_grid_num=interpol_grid_num,
max_interpolate=max_integrate,
min_interpolate=min_integrate)
self.lightProfile = LightProfile(light_profile_list,
interpol_grid_num=interpol_grid_num,
max_interpolate=max_integrate,
min_interpolate=min_integrate)
self.aperture = Aperture(aperture_type)
self.anisotropy = MamonLokasAnisotropy(anisotropy_model)
self._fwhm = fwhm
self.cosmo = Cosmo(**kwargs_cosmo)
self._num_sampling = sampling_number
self._interp_grid_num = interpol_grid_num
self._log_int = log_integration
self._max_integrate = max_integrate # maximal integration (and interpolation) in units of arcsecs
self._min_integrate = min_integrate # min integration (and interpolation) in units of arcsecs
def test_light_2d_finite(self):
interpol_grid_num = 5000
max_interpolate = 10
min_interpolate = 0.0001
lightProfile = LightProfile(profile_list=['HERNQUIST'], interpol_grid_num=interpol_grid_num,
max_interpolate=max_interpolate, min_interpolate=min_interpolate)
kwargs_profile = [{'amp': 1., 'Rs': 1.}]
# check whether projected light integral is the same as analytic expression
R = 1.
I_R = lightProfile.light_2d_finite(R, kwargs_profile)
out = integrate.quad(lambda x: lightProfile.light_3d(np.sqrt(R ** 2 + x ** 2), kwargs_profile),
min_interpolate, np.sqrt(max_interpolate ** 2 - R ** 2))
l_R_quad = out[0] * 2
npt.assert_almost_equal(l_R_quad / I_R, 1, decimal=2)
l_R = lightProfile.light_2d(R, kwargs_profile)
npt.assert_almost_equal(l_R / I_R, 1, decimal=2)
def test_draw_light_3d_power_law(self):
lightProfile = LightProfile(profile_list=['POWER_LAW'], min_interpolate=0.0001, max_interpolate=1000.)
kwargs_profile = [{'amp': 1., 'gamma': 2, 'e1': 0, 'e2': 0}]
r_list = lightProfile.draw_light_3d(kwargs_profile, n=1000000, new_compute=False)
print(r_list, 'r_list')
# project it
R, x, y = velocity_util.project2d_random(r_list)
# test with draw light 2d profile routine
# compare with 3d analytical solution vs histogram binned
bins = np.linspace(0.1, 10, 10)
hist, bins_hist = np.histogram(r_list, bins=bins, density=True)
bins_plot = (bins_hist[1:] + bins_hist[:-1]) / 2.
light3d = lightProfile.light_3d(r=bins_plot, kwargs_list=kwargs_profile)
light3d *= bins_plot ** 2
light3d /= np.sum(light3d)
hist /= np.sum(hist)
#import matplotlib.pyplot as plt
#plt.plot(bins_plot , light3d/light3d[5], label='3d reference power-law')
#plt.plot(bins_plot, hist / hist[5], label='hist')
#plt.legend()
#plt.show()
print(light3d / hist)
npt.assert_almost_equal(light3d / hist, 1, decimal=1)
# compare with 2d analytical solution vs histogram binned
#bins = np.linspace(0.1, 1, 10)
hist, bins_hist = np.histogram(R, bins=bins, density=True)
bins_plot = (bins_hist[1:] + bins_hist[:-1]) / 2.
light2d = lightProfile.light_2d_finite(R=bins_plot, kwargs_list=kwargs_profile)
light2d *= bins_plot ** 1
light2d /= np.sum(light2d)
hist /= np.sum(hist)
#import matplotlib.pyplot as plt
#plt.plot(bins_plot , light2d/light2d[5], label='2d reference power-law')
#plt.plot(bins_plot, hist / hist[5], label='hist')
#plt.legend()
#plt.show()
print(light2d / hist)
npt.assert_almost_equal(light2d / hist, 1, decimal=1)