diff options
Diffstat (limited to 'fg21sim/extragalactic/pointsources/fr2.py')
| -rw-r--r-- | fg21sim/extragalactic/pointsources/fr2.py | 380 |
1 files changed, 380 insertions, 0 deletions
diff --git a/fg21sim/extragalactic/pointsources/fr2.py b/fg21sim/extragalactic/pointsources/fr2.py new file mode 100644 index 0000000..b40f9ff --- /dev/null +++ b/fg21sim/extragalactic/pointsources/fr2.py @@ -0,0 +1,380 @@ +# Copyright (c) 2016 Zhixian MA <zxma_sjtu@qq.com> +# MIT license + +import numpy as np +import healpy as hp + +from .base import BasePointSource +from .psparams import PixelParams +from ...utils import grid +from ...utils import convert + + +class FRII(BasePointSource): + """ + Generate Faranoff-Riley II (FRII) AGN + + Parameters + ---------- + lobe_maj: float + The major half axis of the lobe + lobe_min: float + The minor half axis of the lobe + lobe_ang: float + The rotation angle of the lobe correspoind to line of sight + + Reference + ---------- + [1] Wang J et al., + "How to Identify and Separate Bright Galaxy Clusters from the + Low-frequency Radio Sky?", + 2010, ApJ, 723, 620-633. + http://adsabs.harvard.edu/abs/2010ApJ...723..620W + [2] Fast cirles drawing + https://github.com/liweitianux/fg21sim/fg21sim/utils/draw.py + https://github.com/liweitianux/fg21sim/fg21sim/utils/grid.py + """ + + def __init__(self, configs): + super().__init__(configs) + self.columns.extend( + ['lobe_maj (rad)', 'lobe_min (rad)', 'lobe_ang (deg)']) + self.nCols = len(self.columns) + self._set_configs() + # Paramters for core/lobe ratio + # Willman et al. 2008 Sec2.5.(iii)-(iv) + self.xmed = -2.8 + # Lorentz factor of the jet + self.gamma = 8 + # Number density matrix + self.rho_mat = self.calc_number_density() + # Cumulative distribution of z and lumo + self.cdf_z, self.cdf_lumo = self.calc_cdf() + + def _set_configs(self): + """Load the configs and set the corresponding class attributes""" + super()._set_configs() + pscomp = "extragalactic/pointsources/FRII/" + # point sources amount + self.num_ps = self.configs.getn(pscomp+"numps") + # prefix + self.prefix = self.configs.getn(pscomp+"prefix") + # redshift bin + z_type = self.configs.getn(pscomp+"z_type") + if z_type == 'custom': + start = self.configs.getn(pscomp+"z_start") + stop = self.configs.getn(pscomp+"z_stop") + step = self.configs.getn(pscomp+"z_step") + self.zbin = np.arange(start, stop + step, step) + else: + self.zbin = np.arange(0.1, 10, 0.05) + # luminosity bin + lumo_type = self.configs.getn(pscomp+"lumo_type") + if lumo_type == 'custom': + start = self.configs.getn(pscomp+"lumo_start") + stop = self.configs.getn(pscomp+"lumo_stop") + step = self.configs.getn(pscomp+"lumo_step") + self.lumobin = np.arange(start, stop + step, step) + else: + self.lumobin = np.arange(25.5, 30.5, 0.1) # [W/Hz/sr] + + def calc_number_density(self): + """ + Calculate number density rho(lumo,z) of FRI + + References + ---------- + [1] Wilman et al., + "A semi-empirical simulation of the extragalactic radio continuum + sky for next generation radio telescopes", + 2008, MNRAS, 388, 1335-1348. + http://adsabs.harvard.edu/abs/2008MNRAS.388.1335W + [2] Willott et al., + "The radio luminosity function from the low-frequency 3CRR, + 6CE and 7CRS complete samples", + 2001, MNRAS, 322, 536-552. + http://adsabs.harvard.edu/abs/2001MNRAS.322..536W + + Returns + ------- + rho_mat: np.ndarray + Number density matris (joint-distribution of luminosity and + reshift). + """ + # Init + rho_mat = np.zeros((len(self.lumobin), len(self.zbin))) + # Parameters + # Refer to [2] Table. 1 model C and Willman's section 2.4 + alpha = 2.27 # spectral index + lumo_star = 10.0**26.95 # critical luminosity + rho_l0 = 10.0**(-6.196) # normalization constant + z0 = 1.91 # center redshift + z2 = 1.378 # variance + # Calculation + for i, z in enumerate(self.zbin): + # space density revolusion + fh = np.exp(-0.5 * (z - z0)**2 / z2**2) + rho_mat[:, i] = ((rho_l0 * (10**self.lumobin / lumo_star) ** + (-alpha) * + np.exp(-lumo_star / 10.0**self.lumobin)) * + fh) + + return rho_mat + + def gen_lobe(self): + """ + Calculate lobe parameters + + References + ---------- + [1] Wilman et al., + "A semi-empirical simulation of the extragalactic radio continuum + sky for next generation radio telescopes", + 2008, MNRAS, 388, 1335-1348. + http://adsabs.harvard.edu/abs/2008MNRAS.388.1335W + + Return + ------ + lobe: list + lobe = [lobe_maj, lobe_min, lobe_ang], which represent the major + and minor axes and the rotation angle. + """ + D0 = 1 # [Mpc] + self.lobe_maj = 0.5 * np.random.uniform(0, D0 * (1 + self.z)**(-1.4)) + self.lobe_min = self.lobe_maj * np.random.uniform(0.2, 1) + self.lobe_ang = np.random.uniform(0, np.pi) / np.pi * 180 + + # Transform to pixel + self.lobe_maj = self.param.get_angle(self.lobe_maj) + self.lobe_min = self.param.get_angle(self.lobe_min) + lobe = [self.lobe_maj, self.lobe_min, self.lobe_ang] + + return lobe + + def gen_single_ps(self): + """ + Generate single point source, and return its data as a list. + + """ + # Redshift and luminosity + self.z, self.lumo = self.get_lumo_redshift() + self.lumo_sr = self.lumo + # angular diameter distance + self.param = PixelParams(self.z) + self.dA = self.param.dA + # W/Hz/Sr to Jy + dA = self.dA * 3.0856775814671917E+22 # Mpc to meter + self.lumo = self.lumo / dA**2 / (10.0**-24) # [Jy] + # Position + x = np.random.uniform(0, 1) + self.lat = (np.arccos(2 * x - 1) / np.pi * 180 - 90) # [deg] + self.lon = np.random.uniform(0, np.pi * 2) / np.pi * 180 # [deg] + # lobe + lobe = self.gen_lobe() + # Area + self.area = np.pi * self.lobe_maj * self.lobe_min + + ps_list = [self.z, self.dA, self.lumo, self.lat, self.lon, self.area] + ps_list.extend(lobe) + + return ps_list + + def draw_single_ps(self, freq): + """ + Designed to draw the elliptical lobes of FRI and FRII + + Prameters + --------- + nside: int and dyadic + self.ps_catalog: pandas.core.frame.DataFrame + Data of the point sources + ps_type: int + Class type of the point soruces + freq: float + frequency + """ + # Init + resolution = self.resolution / 60 # [degree] + npix = hp.nside2npix(self.nside) + hpmap = np.zeros((npix,)) + num_ps = self.ps_catalog.shape[0] + # Gen flux list + Tb_list = self.calc_Tb(freq) + ps_lobe = Tb_list[:, 1] + # Iteratively draw ps + for i in range(num_ps): + # Parameters + c_lat = self.ps_catalog['Lat (deg)'][i] # core lat [deg] + c_lon = self.ps_catalog['Lon (deg)'][i] # core lon [au.deg] + lobe_maj = self.ps_catalog['lobe_maj (rad)'][ + i] * 180 / np.pi # [deg] + lobe_min = self.ps_catalog['lobe_min (rad)'][ + i] * 180 / np.pi # [deg] + lobe_ang = self.ps_catalog['lobe_ang (deg)'][ + i] / 180 * np.pi # [rad] + # Offset to the core, refer to Willman Sec2.5.vii + offset = lobe_maj * 2 * np.random.uniform(0.2, 0.8) + # Lobe1 + lobe1_lat = (lobe_maj / 2 + offset) * np.cos(lobe_ang) + lobe1_lat = c_lat + lobe1_lat + lobe1_lon = (lobe_maj / 2 + offset) * np.sin(lobe_ang) + lobe1_lon = c_lon + lobe1_lon + # draw + # Fill with ellipse + lon, lat, gridmap = grid.make_grid_ellipse( + (lobe1_lon, lobe1_lat), (lobe_maj, lobe_min), + resolution, lobe_ang / np.pi * 180) + indices, values = grid.map_grid_to_healpix( + (lon, lat, gridmap), self.nside) + hpmap[indices] += ps_lobe[i] + + # lobe1_hotspot + lobe1_hot_lat = (lobe_maj + offset) * np.cos(lobe_ang) + lobe1_hot_lat = (c_lat + 90 + lobe1_lat) / 180 * np.pi + lobe1_hot_lon = (lobe_maj + offset) * np.sin(lobe_ang) + lobe1_hot_lon = (c_lon + lobe1_lon) / 180 * np.pi + if lobe1_hot_lat < 0: + lobe1_hot_lat += np.pi + elif lobe1_hot_lat > np.pi: + lobe1_hot_lat -= np.pi + lobe1_hot_index = hp.ang2pix( + self.nside, lobe1_hot_lat, lobe1_hot_lon) + hpmap[lobe1_hot_index] += Tb_list[i, 2] + + # Lobe2 + lobe2_lat = (lobe_maj / 2) * np.cos(lobe_ang + np.pi) + lobe2_lat = c_lat + lobe2_lat + lobe2_lon = (lobe_maj / 2) * np.sin(lobe_ang + np.pi) + lobe2_lon = c_lon + lobe2_lon + # draw + # Fill with ellipse + lon, lat, gridmap = grid.make_grid_ellipse( + (lobe2_lon, lobe2_lat), (lobe_maj, lobe_min), + resolution, lobe_ang / np.pi * 180) + indices, values = grid.map_grid_to_healpix( + (lon, lat, gridmap), self.nside) + hpmap[indices] += ps_lobe[i] + + # lobe2_hotspot + lobe2_hot_lat = (lobe_maj + offset) * np.cos(lobe_ang + np.pi) + lobe2_hot_lat = (c_lat + 90 + lobe1_lat) / 180 * np.pi + lobe2_hot_lon = (lobe_maj + offset) * np.sin(lobe_ang + np.pi) + lobe2_hot_lon = (c_lon + lobe1_lon) / 180 * np.pi + if lobe2_hot_lat < 0: + lobe2_hot_lat += np.pi + elif lobe2_hot_lat > np.pi: + lobe2_hot_lat -= np.pi + lobe2_hot_index = hp.ang2pix( + self.nside, lobe2_hot_lat, lobe2_hot_lon) + hpmap[lobe2_hot_index] += Tb_list[i, 2] + + # Core + pix_tmp = hp.ang2pix(self.nside, + (self.ps_catalog['Lat (deg)'] + 90) / + 180 * np.pi, self.ps_catalog['Lon (deg)'] / + 180 * np.pi) + ps_core = Tb_list[:, 0] + hpmap[pix_tmp] += ps_core + + return hpmap + + def draw_ps(self, freq): + """ + Read csv ps list file, and generate the healpix structure vector + with the respect frequency. + """ + # Init + num_freq = len(freq) + npix = hp.nside2npix(self.nside) + hpmaps = np.zeros((npix, num_freq)) + + # Gen ps_catalog + self.gen_catalog() + # get hpmaps + for i in range(num_freq): + hpmaps[:, i] = self.draw_single_ps(freq[i]) + + return hpmaps + + def calc_single_Tb(self, area, freq): + """ + Calculate brightness temperatur of a single ps + + Parameters + ------------ + area: `~astropy.units.Quantity` + Area of the PS, e.g., `1.0*au.sr` + freq: `~astropy.units.Quantity` + Frequency, e.g., `1.0*au.MHz` + + Return + ------ + Tb:`~astropy.units.Quantity` + Average brightness temperature, e.g., `1.0*au.K` + """ + # Init + freq_ref = 151 # [MHz] + freq = freq # [MHz] + # Luminosity at 151MHz + lumo_151 = self.lumo # [Jy] + # Calc flux + # core-to-extend ratio + ang = self.lobe_ang / 180 * np.pi + x = np.random.normal(self.xmed, 0.5) + beta = np.sqrt((self.gamma**2 - 1) / self.gamma) + B_theta = 0.5 * ((1 - beta * np.cos(ang))**-2 + + (1 + beta * np.cos(ang))**-2) + ratio_obs = 10**x * B_theta + # Core + lumo_core = ratio_obs / (1 + ratio_obs) * lumo_151 + a0 = (np.log10(lumo_core) - 0.07 * + np.log10(freq_ref * 10.0E-3) + + 0.29 * np.log10(freq_ref * 10.0E-3) * + np.log10(freq_ref * 10.0E-3)) + lgs = (a0 + 0.07 * np.log10(freq * 10.0E-3) - 0.29 * + np.log10(freq * 10.0E-3) * + np.log10(freq * 10.0E-3)) + flux_core = 10**lgs # [Jy] + # core area + npix = hp.nside2npix(self.nside) + core_area = 4 * np.pi / npix # [sr] + Tb_core = convert.Fnu_to_Tb_fast(flux_core, core_area, freq) # [K] + # lobe + lumo_lobe = lumo_151 * (1 - ratio_obs) / (1 + ratio_obs) # [Jy] + flux_lobe = (freq / freq_ref)**(-0.75) * lumo_lobe + Tb_lobe = convert.Fnu_to_Tb_fast(flux_lobe, area, freq) # [K] + + # hotspots + # Willman Eq. (3) + f_hs = (0.4 * (np.log10(self.lumo_sr) - 25.5) + + np.random.uniform(-0.5, 0.5)) + Tb_hotspot = Tb_lobe * (1 + f_hs) + Tb = [Tb_core, Tb_lobe, Tb_hotspot] + + return Tb + + def calc_Tb(self, freq): + """ + Calculate the surface brightness temperature of the point sources. + + Parameters + ------------ + area: `~astropy.units.Quantity` + Area of the PS, e.g., `1.0*au.sr` + freq: `~astropy.units.Quantity` + Frequency, e.g., `1.0*au.MHz` + + Return + ------ + Tb_list: list + Point sources brightness temperature + """ + # Tb_list + num_ps = self.ps_catalog.shape[0] + Tb_list = np.zeros((num_ps, 3)) + # Iteratively calculate Tb + for i in range(num_ps): + ps_area = self.ps_catalog['Area (sr)'][i] # [sr] + Tb_list[i, :] = self.calc_single_Tb(ps_area, freq) + + return Tb_list |