def proportion_(dataset, filename):
""" 统计每个release中各个数量模型的比例
:returns: 返回 List[tuple]
"""
data = convert2numpy(dataset)
statics = Statistics(data[1])
max_bug = statics.max_()
number_instance = statics.numberInstance()
unique, counts = np.unique(data[1], return_counts=True)
counter = dict(zip(unique, counts))
print(counter)
res = dict()
for i in range(max_bug + 1):
if i>=9:
break
if i in counter:
res[str(i)] = np.around(counter[i]/number_instance*100.0, decimals=4)
else:
res[str(i)] = 0
if max_bug>8:
sum_=0
for j in range(9, max_bug+1):
if j in counter:
sum_+=counter[j]
# 令999代表大于8的模块
res['999'] = np.around(sum_/number_instance*100.0, decimals=4)
return res
# uncomment if convert to List[tuple]
proportion = dict2tuple(res)
return proportion
pass
def ps_21_2h(k, z21, params, singlek=False):
'''
2-halo 21-cm power-spectrum
Args:
k,wavenumber (h/Mpc)
z21, redshift
params, parameters,
singlek, bool. If True, avoid generating interpolated ps
for entire redshift.
Returns:
2-halo term for 21cm emission power spectrum
K^2 Mpc^3/h^3
'''
if not singlek:
splkey('ps_21_2h', z21) + dict2tuple(params)
if not splkey in SPLINE_DICT:
kaxis = np.logspace(K_PERP_INTERP_MIN, K_PERP_INTERP_MAX, NPTS)
psvals = np.zeros_like(kaxis)
for knum, kval in enumerate(kaxis):
psvals[knum]=np.abs(ps_integral(kval,z21,params,1.,0.))**2.\
*power_lin(kval,z21)
SPLINE_DICT[splkey] = interp.interp1d(np.log(kaxis),
np.log(psvals))
return np.exp(SPLINE_DICT[splkey](np.log(k)))
else:
return np.abs(ps_integral(k, z21, 1., 0., params))**2. * power_lin(
k, z21)
def read(self, arg):
newresult = {}
f = open(self.arg_id(arg), "r")
for line in f.readlines():
line = line.strip().split()
if len(line) % 2 == 1 or len(line) < 2:
# Fail
utils.fail(self.arg_id(arg))
f.close()
return
new_key = {k: v for k, v in arg}
# parse line
for i in xrange(0, len(line) - 2, 2):
i_name = line[i]
i_value = float(line[i + 1])
new_key[i_name] = i_value
new_key["name"] = line[-2]
newresult[utils.dict2tuple(new_key)] = float(line[-1])
# Merge result with newresult
for k in newresult.keys():
self.result[k] = newresult[k]
f.close()
def ps_21tau_2h(k, z21, params, singlek=False):
'''
2-halo power-spectrum for 21-tau cross term
Args:
k,wavenumber (h/Mpc)
z21,redshift
params, parameters
singlek, bool, if True, only perform calculation for single
k at fixed redshift.
Returns:
2-halo term for 21-tau cross-power spectrum (K Mpc^3/h^3)
'''
if not singlek:
splkey = ('ps_21tau_2h', z21) + dict2tuple(params)
if not SPLINE_DICT.has_key(splkey):
kaxis = np.logspace(K_PERP_INTERP_MIN, K_PERP_INTERP_MAX, NPTS)
psvals = np.zeros_like(kaxis)
for knum, kval in enumerate(kaxis):
psvals[knum]=ps_intergral(kval,z21,1.,1.,params)\
*ps_integral(kval,z21,1.,0.,params)*power_lin(kval,z21)
SPLINE_DICT[splkey] = interp.interp1d(np.log(kaxis),
np.log(psvals))
return np.exp(SPLINE_DICT[splkey](np.log(k)))
else:
return ps_integral(k,z21,1.,1.,params)*ps_integral(k,z21,1.,0.,params)\
*power_lin(k,z21)
def bias_hits(z21, params):
'''
bias of MHI/(Vhalo*Ts)
Args:
z21, float, redshift
params, dictionary of parameters.
Returns:
bias of \int_vhalo rho_HI(r)/T_s(r)
'''
splkey = ('bias_hits') + dict2tuple(params)
if not SPLINE_DICT.has_key(splkey):
zvals = np.linspace(0, MAXZ, INTERP_Z)
biasvals = np.zeros_like(zvals)
for znum, zval in enumerate(zvals):
def g(x, bp=1.):
rv = hi_helpers.rVir(10.**x, zval)
rs=rv/HI_HELPERS['CSHIFUNC'](10.**x,zval,params)\
*(1.+zval)/1e3
rt = params['RT'] * (1. + zval) / 1e3
rht = rs * rt / (rs + rt)
volratio = hi_helpers.expvol(rv, rht) / hi_helpers.expvol(
rv, rs)
return HI_HELPERS['MHIFUNC'](10.**x,zvals,params)\
/TS_HELPERS['TSFUNC'](10.**x,zvals,params)*volratio\
*massfunc(10.**x,zval)*bias(10.**x,zval)**bp
numer = integrate.quad(lambda x: g(x, 1.), M_INTERP_MIN,
M_INTERP_MAX)[0]
denom = integrate.quad(lambda x: g(x, 0.), M_INTERP_MIN,
M_INTERP_MAX)[0]
biasvals[znum] = numer / denom
SPLINE_DICT[splkey] = interp.interp1d(zvals, np.log(biasvals))
return np.exp(SPLINE_DICT[splkey](z21))
def ps_tau_2h(k, z21, params, singlek=False):
'''
2-halo power-spectrum for tau
Args:
k,wavenumber (h/Mpc)
z21, redshift
params, parameters
singlek, bool. If True, avoid generating interpolated ps
for entire redshift
Returns:
2-halo term for tau power-spectrum (Mpc^3/h^3)
'''
if not singlek:
splkey = ('ps_tau_2h', z21) + dict2tuple(params)
if not SPLINE_DICT.has_key(splkey):
kaxis = np.logspace(K_PERP_INTERP_MIN, K_PERP_INTERP_MAX, NPTS)
psvals = np.zeros_like(kaxis)
for knum, kval in enumerate(kaxis):
psvals[knum]=np.abs(ps_integral(kval,z21,1.,1.,params))**2.\
*power_lin(kval,z21)
SPLINE_DICT[splkey] = interp.interp1d(np.log(kaxis),
np.log(psvals))
return np.exp(SPLINE_DICT[splkey](np.log(k)))
else:
return p.abs(ps_integral(k,z21,1.,1.,params))**2.\
*power_lin(k,z21)
def dn_dsobs_dz(z, sobs, params):
'''
compute the number of absorption features
with depth sobs, per redshift interval and solid angle on the sky
Args:
z, redshift
sobs, observation flux
params, dictionaryt of parameters
Returns:
number of systems per observed flux bin per Sr between z and z+dz for
model params (Sr^-1 Jy^-1)
'''
splkey = ('dn_dsobs_dz', z) + dict2tuple(params)
if not SPLINE_DICT.has_key(splkey):
svals = np.logspace(S_INTERP_MIN, S_INTERP_MAX, N_INTERP_SNR)
dndsdomegavals = np.zeros_like(svals)
for snum, sval in enumerate(svals):
g=lambda x: dn_dlogtau_dz(10.**x,z,params)\
*dn_dlogs_domega(sval/10.**x,z,singles=False)/(sval/10.**x)\
/np.log(10.)
dndsdomegavals[snum]\
=integrate.quad(g,np.log10(sval)-S_INTERP_MAX,TAU_INTERP_MAX)[0]
SPLINE_DICT[splkey] = interp.interp1d(np.log(svals),
np.log(dndsdomegavals))
return np.exp(SPLINE_DICT[splkey].ev(np.log(svals)))
def r_tau(tau, m, z, params, recompute=False, dtau=0):
'''
Compute the radius of a halo within which all LoSs subtend a maximum.
tau'>tau.
Args:
tau: minimum tau within radius r.
m: virial mass of halo.
z, redshift
params, dictionary of model parameters
dlogtau, order of derivative with respect to logtau
Returns:
r, radius in comoving Mpc/h within which all otpical depths are
greater than tau.
'''
assert dtau in [0., 1., 0, 1]
splkey = ('r_tau', z) + dict2tuple(params)
if not splkey in SPLINE_DICT or recompute:
maxis = np.logspace(M_INTERP_MIN, M_INTERP_MAX, N_INTERP_M)
tauaxis = np.logspace(TAU_INTERP_MIN, TAU_INTERP_MAX, N_INTERP_RTAU)
rvals = np.ones((N_INTERP_M, N_INTERP_RTAU)) * 10.**R_INTERP_MIN
raxis = np.logspace(R_INTERP_MIN, 0., N_INTERP_RTAU)
for mnum, mval in enumerate(maxis):
#print '%.1e'%(mval)
#r0=R_INTERP_MIN
rv = rVir(mval, z)
#print 'mval=%e'%mval
#if tau_gaussian(rv*10.**r0,mval,z,F21,params)>10.**TAU_INTERP_MIN:
# for taunum,tauval in enumerate(tauaxis):
# g=lambda x:np.abs(np.log(tau_gaussian(rv*10.**x,
# mval,z,F21,params)/tauval))
# g=lambda x:np.abs(np.log(tau_gaussian(rv*10.**x,
# mval,z,F21,params)/tauval/10.**x/rv))
# g=lambda x:np.abs(1.-tauval/tau_gaussian(10.**x*rv,mval,z,F21,params))/10.**x/rv)
#r0=secant_method(g,r0)
#res=op.minimize(g,x0=[r0],bounds=[[r0,r0+.1]],method='SLSQP')
# res=op.minimize(g,x0=[r0],method='SLSQP',bounds=[[r0,0.]])
# r0=res.x[0]
#print r0
# rvals[mnum,taunum]=10.**r0
#First compute tau for regularly gridded r-values
taus = tau_gaussian(raxis * rv, mval, z, F21, params)
temp_spline = interp.interp1d(taus,
raxis,
bounds_error=False,
fill_value=0.)
rvals[mnum, :] = temp_spline(tauaxis)
#Now compute r for regularly gridded tau
SPLINE_DICT[splkey]=\
interp.RectBivariateSpline(np.log(maxis),
np.log(tauaxis),rvals)
if dtau == 1:
#return dr/dtau
return SPLINE_DICT[splkey].ev(np.log(m), np.log(tau),
dy=int(dtau)) / tau * rVir(m, z)
else:
return SPLINE_DICT[splkey].ev(np.log(m), np.log(tau)) * rVir(m, z)
def ps_radio(kperp, z21, params):
'''
The power spectrum of known radio point sources
Args:
kperp, wavenumber perpindicular to line of sight (h/Mpc)
z21, redshift where wavelength is 21cm.
params, dictionary of parameters.
Returns:
power spectrum (K^2 h^3/Mpc^3)
'''
splkey = ('ps_radio') + dict2tuple(params)
if not mkey in SPLINE_DICT.keys():
if params['INCLUDE_ARCADE']:
arccoeff = 0.
else:
arccoeff = 1.
kperpvals = np.logspace(K_PERP_INTERP_MIN, KPERP_INTERP_MAX,
NINTERP_KPERP)
psqvals = np.zeros_like(kperpvals)
prefactor=(C/F21*(1+z21)/(1e3*KPC))**4/(64.*PI*PI*KBOLTZMANN**2.)\
*LITTLEH*1e-3*C/cosmo.H0
freq_obs = F21 / (1. + z21)
for k, kp in enumerate(kperpvals):
g=lambda x: 1./((1+x)**2.*cosmo.Ez(x))\
*(arccoeff*params['ARCADE_BIAS']\
*RADIO_BACKGROUND_MODELS['emiss_arc_const'](x,params)\
*(freq_obs*(1+x)/1e9)**(-params['ARCADE_POW'])\
+RADIO_BACKGROUND_MODELS['emiss_agn_fast'](z21,x)\
*bias(params['MEFF_AGN'],x)\
+RADIO_BACKGROUND_MODELS['emiss_sfg_fast'](z21,x)\
*bias(params['MEFF_SFG'],x))**2.\
*power_lin(kp,x)
psqvals[k] = integrate.quad(g, z21, MAXZ)[0] * prefactor
SPLINE_DICT[splkey]\
=interp.interp1d(np.log(kperpvals),np.log(psqvals))
zf = 1.
if type(kperp) == np.ndarray:
kmax = kperp > KPERP_INTERP_MAX
kmin = kperp < KPERP_INTERP_MAX
kint = np.logical_and(kperp >= K_PERP_INTERP_MIN,
kperp <= KPERP_INTERP_MAX)
output = np.zeros_like(kperp)
output[kmax] = 0.
output[kmin]=\
np.exp(SPLINE_DICT[splkey](np.log(KPERP_INTERP_MIN)))
output[kint]=\
np.exp(SPLINE_DICT[splkey](np.log(kperp[kint])))
return output
else:
if kperp > K_PERP_INTERP_MIN:
zf = 0.
kperp = K_PERP_INTERP_MAX
if kperp < K_PERP_INTERP_MIN:
kperp = K_PERP_INTERP_MIN
return zf * np.exp(SPLINE_DICT[splkey](np.log(kperp)))
def corr_radio(rperp, z21, params):
'''
3d background quasar correlation function at redshift z.
which is assumed to be only a function of rperp (no r_parallel)
Args:
rperp, float, perpindicular to line-of-sight distance (Mpc/h)
z21, float,redshift
params, parameters
'''
splkey = ('corr_radio', z21) + dict2tuple(params)
if splkey not in SPLINE_DICT.keys():
g = lambda x: ps_radio(x, z, params)
#two factors of x to integrate by dlogx
#don't multiply by 2*PI since this is divided out by fourier convention
raxis, cvals = fftlogbessel(g,
nrperp,
K_PERP_INTERP_MIN - 1,
K_PERP_INTERP_MAX + 1,
tdir=-1)
#print raxis.min()
#print(minlog)
#print('raxis.min='+str(raxis.min()))
SPLINE_DICT[splkey] = interp.interp1d(np.log(raxis), cvals)
if isinstance(r, np.ndarray):
rmin = r < 10**minlog
rmax = r > 10**maxlog
rint = np.logical_and(r >= 10.**K_PERP_INTERP_MIN,
r <= 10.**K_PERP_INTERP_MAX)
output = np.zeros_like(r)
output[rmin] = SPLINE_DICT[splkey](np.log(10**K_PERP_INTERP_MIN))
output[rmax] = 0.
output[rint] = SPLINE_DICT[splkey](np.log(r[rint]))
return output
else:
if r < 10.**K_PERP_INTERP_MIN:
zf = 1.
r = 10.**K_PERP_INTERP_MIN
elif r > 10.**K_PERP_INTERP_MAX:
zf = 0.
r = 10.**K_PERP_INTERP_MAX
else:
zf = 1.
return zf * SPLINE_DICT[splkey](np.log(r))
def dn_dr(snr, channel_width, z, params, singlesnr=False):
'''
number of absorbers per comoving LoS distance interval where fractional flux
difference is larger than snr times the noise level.
Args:
snr, signal to noise ratio
z, redshift
params, dictionary of model parameters
Returns:
comoving number density of absorbers per line-of-sight interval (h/Mpc)
'''
if not singlesnr:
splkey = ('dn_dr', channel_width, z) + dict2tuple(params)
if not SPLINE_DICT.has_key(splkey):
snrvals = np.logspace(SNR_INTERP_MIN, SNR_INTERP_MAX, N_INTERP_SNR)
dndrvals = np.zeros_like(snrvals)
for snrnum, snrval in enumerate(snrvals):
g = lambda x: massfunc(10.**x,z)\
*sigma_tau(tau_limit(snrval,10.**x,z,channel_width,params),
10.**x,z,params)
dndrvals[snrnum] = integrate.quad(g, M_INTERP_MIN,
M_INTERP_MAX)[0]
SPLINE_DICT[splkey] = interp.interp1d(np.log(snrvals), dndrvals)
sf = 1.
if type(snr) == np.ndarray:
snr[snr < 10.**SNR_INTERP_MIN] = SNR_INTERP_MIN
snr[snr >= 10.**SNR_INTERP_MAX] = 10.**SNR_INTERP_MAX
output = SPLINE_DICT[splkey](np.log(snr))
output[snr < 10.**SNR_INTERP_MIN] = 0.
else:
if snr < 10.**SNR_INTERP_MIN:
snr = 10.**SNR_INTERP_MIN
sf = 0.
elif snr >= 10.**SNR_INTERP_MAX:
sf = 1.
snr = 10.**SNR_INTERP_MAX
output = SPLINE_DICT[splkey](np.log(snr))
return sf * output
else:
g = lambda x: massfunc(10.**x,z)\
*sigma_tau(tau_limit(snr,10.**x,z,channel_width,params),
10.**x,z,params)
return integrate.quad(g, M_INTERP_MIN, M_INTERP_MAX)[0]
def rho_hi(z21, params):
'''
comoving density of HI in Msolar*h^3/Mpc^3
Args:
z21, float, redshift
params, dictionary of parameters
Returns:
comoving density of HI in Msolar*h^3/Mpc^3
'''
splkey = ('rho', 'hi') + dict2tuple(params)
if not SPLINE_DICT.has_key(splkey):
zvals = np.linspace(0, MAXZ, NINTERP_Z)
rhovals = np.zeros_like(zvals)
for znum, zval in enumerate(zvals):
g=lambda x: HI_HELPERS[params['MHIFUNC']](10.**x,zval,params)\
*massfunc(10.**x,zval)
rhovals[znum] = integrate.quad(g, M_INTERP_MIN, M_INTERP_MAX)[0]
SPLINE_DICT[splkey] = interp.interp1d(zvals, np.log(rhovals))
return np.exp(SPLINE_DICT[splkey](z21))
def group_except(self, variables):
result = {}
svariables = set(variables)
for key in self.data.keys():
new_keys = {}
value = self.data[key]
for k, v in key:
if not k in variables:
new_keys[k] = v
new_keys = utils.dict2tuple(new_keys)
if not new_keys in result:
result[new_keys] = []
result[new_keys].append(value)
result2 = Result(self.conf)
result2.data = result
return result2
def bias_hi(z21, params):
'''
bias of HI
Args:
z21, float, redshift
params, dictionary of parameters.
Returns:
bias of HI (unitless)
'''
splkey = ('bias', 'hi') + dict2tuple(params)
if not SPLINE_DICT.has_key(splkey):
zvals = np.linspace(0, MAXZ, NINTERP_Z)
biasvals = np.zeros_like(zvals)
for znum, zval in enumerate(zvals):
g=lambda x:HI_HELPERS[params['MHIFUNC']](10.**x,zval,params)\
*massfunc(10.**x,zval)*bias(10.**x,zval)
biasvals[znum]=integrate.quad(g,M_INTERP_MIN,M_INTERP_MAX)[0]\
/rho_hi(zval,params)
SPLINE_DICT[splkey] = interp.interp1d(zvals, np.log(biasvals))
return np.exp(SPLINE_DICT[splkey](z21))
def dn_dz_tau(tau, z, params):
'''
number of absorbers per redshift interval with optical depths greater than
tau.
Args:
tau, optical depth
z, redshift
params, dictionary of model parameters
Returns: number of absorbers per redshift interval (along LoS) with optical
depths greater than tau
'''
splkey = ('dn_dz_tau', z) + dict2tuple(params)
if not SPLINE_DICT.has_key(splkey):
tauvals = np.logspace(TAU_INTERP_MIN, TAU_INTERP_MAX, N_INTERP_TAU)
dnvals = np.zeros_like(tauvals)
for taunum, tauval in enumerate(tauvals):
g=lambda x:sigma_tau(tauval,10.**x,z,params)*massfunc(10.**x,z)\
*C*1e-3/COSMO.Hz(z)*LITTLEH
dnvals[taunum] = integrate.quad(g, M_INTERP_MIN, M_INTERP_MAX)[0]
SPLINE_DICT[splkey] = interp.interp1d(np.log(tauvals), dnvals)
return SPLINE_DICT[splkey](np.log(tau))
def d_tau_variance_dm(m, z, params):
'''
\int dsigma/dtau (tau|m,z) tau^2 dtau
Args:
m, mass (msolar/h)
z, redshift
channel_width, channel size in Hz
Returns:
second moment of optical depth weighted by area at optical depth
(Mpc/h)^2
'''
splkey = ('tau_variance_int', z) + dict2tuple(params)
if not SPLINE_DICT.has_key(splkey):
maxis = np.logspace(M_INTERP_MIN, M_INTERP_MAX, N_INTERP_M)
varvals = np.zeros_like(maxis)
for mnum, mval in enumerate(maxis):
g=lambda x: np.abs(dsigma_dtau(10.**x,mval,z))*10.**(3.*x)\
/rline(mval,z,channel_width,params)/(channel_width*C/F21*1e-3)**2.
varvals[mnum] = integrate.quad(g, TAU_INTERP_MIN,
TAU_INTERP_MAX)[0]
SPLINE_DICT[splkey] = interp.interp1d(np.log(maxis), np.log(varvals))
return np.exp(SPLINE_DICT[splkey](np.log(m)))
def mTb(z21, params):
'''
mean brightness temperature from 21cm emission
Args:
z21, float, redshift
params, dictionary of parameters
Returns:
mean brightness temperature (K)
'''
splkey = ('mTb', '21cm') + dict2tuple(params)
if splkey not in SPLINE_DICT.keys():
zvals = np.linspace(0., MAXZ, NINTERP_Z)
mtbvals = np.zeros_like(zvals)
if params['INCLUDE_ARCADE']:
acoeff = 1.
else:
acoeff = 0.
for znum, zval in enumerate(zvals):
def g(x):
rv = hi_helpers.rVir(10.**x, zval)
rs=rv/HI_HELPERS[params['CSHIFUNC']](10.**x,zval,params)\
*(1.+zval)/1e3
rt = params['RT'] * (1. + zval) / 1e3
rht = rs * rt / (rs + rt)
volratio = hi_helpers.exp_vol(rv, rht) / hi_helpers.exp_vol(
rv, rs)
return massfunc(10.**x,zval)\
*(HI_HELPERS[params['MHIFUNC']](10.**x,zval,params)-(1.+zval)\
*volratio*(TCMB+rb.tb_agn_fast(zval)+rb.tb_sfg_fast(zval)\
+acoeff*rb.tb_arc_const(F21/(1.+zval),params))\
/TS_MODELS[params['TS0_FUNC']](10.**x,zval,params))
mtbvals[znum] = mTb_emiss(zval, 1.) * integrate.quad(
g, M_INTERP_MIN, M_INTERP_MAX)[0]
SPLINE_DICT[splkey] = interp.interp1d(zvals, np.log(mtbvals))
return np.exp(SPLINE_DICT[splkey](z21))
def dn_dlogtau_dz(tau, z, params, recompute=False):
'''
compute the number of optical depth features per redshift interval
per optical depth interval.
Args:
z, redshift
tau, optical depth
params, model parameters
Returns:
average number of optical depth features between tau and tau+d_tau
and redshift z and dz in a los on the sky.
'''
splkey = ('dn_dlogtau_domega_dz', z) + dict2tuple(params)
if not SPLINE_DICT.has_key(splkey) or recompute:
tauvals = np.logspace(TAU_INTERP_MIN, TAU_INTERP_MAX, N_INTERP_TAU)
dnvals = np.zeros_like(tauvals)
for taunum, tauval in enumerate(tauvals):
g=lambda x: massfunc(10.**x,z)*dsigma_dtau(tauval,10.**x,z,params)\
*tauval*np.log(10.)
dnvals[taunum]=integrate.quad(g,M_INTERP_MIN,M_INTERP_MAX)[0]\
*1e-3*C/COSMO.Hz(z)*LITTLEH
print dnvals
SPLINE_DICT[splkey] = interp.interp1d(np.log(tauvals), dnvals)
return SPLINE_DICT[splkey](np.log(tau))
os.system('python segment_partition.py')
MAX_ROUND = 10
if __name__ == '__main__':
G = utils.create_network_topo_with_old_flows()
flowinfo = utils.get_flowinfo()
CL = utils.search_potential_congested_links()
global_D = utils.create_dependency_graph(utils.get_dependency(CL))
init_update = utils.update_alone_nodes(G, global_D)
transition_info = {}
for CNid in global_D.nodes():
for nf_dict in utils.map_id_to_CN(CNid):
nf, fid = utils.dict2tuple(nf_dict)
if not transition_info.has_key(fid):
transition_info[fid] = {nf: flowinfo[fid]}
else:
transition_info[fid].update({nf: flowinfo[fid]})
tmp_result = {}
count = 0
rest_nf = None
tmp_result[count] = map(lambda nf_tup: (utils.tuple2dict(nf_tup), flowinfo[nf_tup[1]]), init_update)
while True:
count += 1
print 'Round', count
tmp_result[count] = []
def tau_gaussian(b,
m,
z,
offset,
params,
dlogr=0,
integrated=False,
units='Hz',
singler=False):
'''
optical depth profile for a halo of mass m
Args:
b (impact parameter in comoving Mpc/h)
m, virial mass of halo (msol/h)
offset, halo rest-frame frequency (Hz)
or velocity (km/sec)
params, dictionary of parameters
singler, evaluate at single r value
(rather than evaluating interp tables)
Returns:
optical depth
'''
sigma_v = sigma_line(m, z, params)
if not singler:
splkey = ('tau_gaussian', z) + dict2tuple(params)
if splkey not in SPLINE_DICT:
maxis = np.logspace(M_INTERP_MIN, M_INTERP_MAX, N_INTERP_M)
raxis = np.logspace(R_INTERP_MIN, 0, N_INTERP_TAU)
taumaxvals = np.zeros((N_INTERP_M, N_INTERP_TAU))
for mnum, mval in enumerate(maxis):
for rnum, rval in enumerate(raxis):
taumaxvals[mnum,rnum]\
=NHIDT2TAU\
*nhidt(rval*rVir(mval,z),
mval,z,params)
SPLINE_DICT[splkey]\
=interp.RectBivariateSpline(np.log(maxis),
np.log(raxis),
taumaxvals)
r = b / rVir(m, z)
sf = 1.
if isinstance(r, np.ndarray):
r[r < 10.**R_INTERP_MIN] = 10.**R_INTERP_MIN
output = np.zeros_like(r)
output[r <= 1.] = SPLINE_DICT[splkey].ev(np.log(m),
np.log(r[r <= 1.]),
dy=dlogr)
output[r > 1.] = 0.
else:
if r < 10.**R_INTERP_MIN:
r = 10.**R_INTERP_MIN
elif r > 1.:
r = 1.
sf = 0.
output = sf * SPLINE_DICT[splkey].ev(
np.log(m), np.log(r), dy=dlogr)
else:
output = NHIDT2TAU * nhidt(b, m, z, params)
if integrated:
return output
else:
if units == 'Hz':
freq = offset
velocity = np.abs(freq / F21 - 1.) * C * 1e-3
else:
velocity = offset
output = output * np.exp(-(velocity / sigma_v)**2. / 2.)
output = output * C * 1e-3 / np.sqrt(2. * PI) / sigma_v / F21
return output
