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