class Clustering(object): def __init__(self,iniFile,expName,gridName,version,ClusterCosmology): Config = SafeConfigParser() Config.optionxform=str Config.read(iniFile) self.cc = ClusterCosmology bigDataDir = Config.get('general','bigDataDirectory') self.clttfile = Config.get('general','clttfile') self.constDict = dict_from_section(Config,'constants') self.clusterDict = dict_from_section(Config,'cluster_params') #version = Config.get('general','version') beam = list_from_config(Config,expName,'beams') noise = list_from_config(Config,expName,'noises') freq = list_from_config(Config,expName,'freqs') lknee = list_from_config(Config,expName,'lknee')[0] alpha = list_from_config(Config,expName,'alpha')[0] self.fsky = Config.getfloat(expName,'fsky') self.mgrid,self.zgrid,siggrid = pickle.load(open(bigDataDir+"szgrid_"+expName+"_"+gridName+ "_v" + version+".pkl",'rb')) #self.cc = ClusterCosmology(self.fparams,self.constDict,clTTFixFile=self.clttfile) self.SZProp = SZ_Cluster_Model(self.cc,self.clusterDict,rms_noises = noise,fwhms=beam,freqs=freq,lknee=lknee,alpha=alpha) self.HMF = Halo_MF(self.cc,self.mgrid,self.zgrid) self.HMF.sigN = siggrid.copy() #self.dndm_SZ = self.HMF.dn_dmz_SZ(self.SZProp) def dVdz_fine(self,zarr): DA_z = self.HMF.cc.results.angular_diameter_distance(zarr) dV_dz = DA_z**2 * (1.+zarr)**2 #NOT SURE we need this for loop for i in range (zarr.size): dV_dz[i] /= (self.HMF.cc.results.h_of_z(zarr[i])) dV_dz *= (old_div(self.HMF.cc.H0,100.))**3. # was h0 return dV_dz def ntilde(self): dndm_SZ = self.HMF.dn_dmz_SZ(self.SZProp) ans = np.trapz(dndm_SZ,dx=np.diff(self.HMF.M200,axis=0),axis=0) return ans def ntilde_interpol(self,zarr_int): ntil = self.ntilde() z_arr = self.HMF.zarr #n = len(z_arr) #k = 4 # 5th degree spline #s = 20.*(n - np.sqrt(2*n))* 1.3 # smoothing factor #ntilde_spline = UnivariateSpline(z_arr, np.log(ntil), k=k, s=s) #ans = np.exp(ntilde_spline(zarr_int)) f_int = interp1d(z_arr, np.log(ntil),kind='cubic') ans = np.exp(f_int(zarr_int)) return ans def b_eff_z(self): ''' effective linear bias wieghted by number density ''' nbar = self.ntilde() z_arr = self.HMF.zarr dndm_SZ = self.HMF.dn_dmz_SZ(self.SZProp) R = tinker.radius_from_mass(self.HMF.M200,self.cc.rhoc0om) sig = np.sqrt(tinker.sigma_sq_integral(R, self.HMF.pk, self.HMF.kh)) blin = tinker.tinker_bias(sig,200.) beff = old_div(np.trapz(dndm_SZ*blin,dx=np.diff(self.HMF.M200,axis=0),axis=0), nbar) try: a_bias = self.cc.paramDict['abias'] except KeyError: print("Using implicit a_bias value") a_bias = 1. return a_bias * beff def non_linear_scale(self,z,M200): #?Who are you? zdiff = np.abs(self.HMF.zarr - z) use_z = np.where(zdiff == np.min(zdiff))[0] R = tinker.radius_from_mass(M200,self.cc.rhoc0om) sig = np.sqrt(tinker.sigma_sq_integral(R, self.HMF.pk[use_z,:], self.HMF.kh)) #print sig[:,0],sig[0,:] print(sig.shape) print(self.HMF.kh.shape) sig1 = sig[0,:] print(sig1) sigdiff = np.abs(sig1 - 1.) use_sig = np.where(sigdiff == np.min(sigdiff))[0] print(use_sig) return old_div(1.,(R[use_sig])),sig1[use_sig],self.HMF.zarr[use_z] # norm is off by 4 pi from ps_bar def Norm_Sfunc(self): #z_arr = self.HMF.zarr #Check this nbar = self.ntilde() ans = self.HMF.dVdz*nbar**2*np.diff(self.HMF.zarr_edges) return ans def fine_sfunc(self, nsubsamples): zs = self.HMF.zarr zgridedges = self.HMF.zarr_edges fine_zgrid = np.empty((zs.size, nsubsamples)) for i in range(zs.size): fine_zgrid[i,:] = np.linspace(zgridedges[i], zgridedges[i+1], nsubsamples) fine_zgrid = fine_zgrid[1:-1] ntils = self.ntilde_interpol(fine_zgrid) dvdz = np.array([self.dVdz_fine(zs) for zs in fine_zgrid]) dz = fine_zgrid[0,1] - fine_zgrid[0,0] assert np.allclose(dz * np.ones(tuple(np.subtract(fine_zgrid.shape, (0,1)))), np.diff(fine_zgrid,axis=1), rtol=1e-3) integral = np.trapz(dvdz * ntils**2, dx=dz) return integral def v0(self, nsubsamples): zs = self.HMF.zarr zgridedges = self.HMF.zarr_edges fine_zgrid = np.empty((zs.size, nsubsamples)) for i in range(zs.size): fine_zgrid[i,:] = np.linspace(zgridedges[i], zgridedges[i+1], nsubsamples) fine_zgrid = fine_zgrid[1:-1] dvdz = np.array([self.dVdz_fine(zs) for zs in fine_zgrid]) dz = fine_zgrid[0,1] - fine_zgrid[0,0] assert np.allclose(dz * np.ones(tuple(np.subtract(fine_zgrid.shape, (0,1)))), np.diff(fine_zgrid,axis=1), rtol=1e-3) integral = np.trapz(dvdz, dx=dz) integral *= 4 * np.pi * self.fsky return integral def w_redshift_err(self, mu): ks = self.HMF.kh zs = self.HMF.zarr kr_sqr = ks[:, None]**2 * (1 - mu[None, :]**2) sigma_z = self.cc.paramDict['sigma_z'] h_z = self.HMF.cc.results.h_of_z(zs)[None, ..., None] return np.exp(-0.5*(sigma_z/h_z)**2 * kr_sqr[:, None, :]) def ps_tilde(self,mu): beff_arr = self.b_eff_z()[..., np.newaxis] mu_arr = mu[..., np.newaxis] logGrowth = self.cc.fgrowth(self.HMF.zarr) prefac = (beff_arr.T + logGrowth*mu_arr**2)**2 prefac = prefac[..., np.newaxis] pklin = self.HMF.pk # not actually pklin pklin = pklin.T pklin = pklin[..., np.newaxis] ans = np.multiply(prefac,pklin.T).T return ans * self.w_redshift_err(mu)**2 def ps_tilde_interpol(self, zarr_int, mu): ps_tils = self.ps_tilde(mu) zs = self.HMF.zarr ks = self.HMF.kh n = zs.size k = 4 # 5th degree spline s = 20.*(n - np.sqrt(2*n))* 1.3 # smoothing factor ps_interp = interp1d(zs, ps_tils, axis=1, kind='cubic') return ps_interp(zarr_int) def ps_bar(self,mu): z_arr = self.HMF.zarr nbar = self.ntilde() prefac = self.HMF.dVdz*nbar**2*np.diff(z_arr)[2]/self.Norm_Sfunc() prefac = prefac[..., np.newaxis] ans = np.multiply(prefac, self.ps_tilde(mu).T).T #for i in range(len(z_arr)): # ans[:,:,i] = self.HMF.dVdz[i]*nbar[i]**2*ps_tilde[:,:,i]*np.diff(z_arr[i])/self.Norm_Sfunc(fsky)[i] return ans def fine_ps_bar(self,mu, nsubsamples=100): zs = self.HMF.zarr ks = self.HMF.kh zgridedges = self.HMF.zarr_edges values = np.empty((ks.size, zs.size, mu.size)) fine_zgrid = np.empty((zs.size, nsubsamples)) for i in range(zs.size): fine_zgrid[i,:] = np.linspace(zgridedges[i], zgridedges[i+1], nsubsamples) fine_zgrid = fine_zgrid[1:-1] ntils = self.ntilde_interpol(fine_zgrid) dvdz = np.array([self.dVdz_fine(zs) for zs in fine_zgrid]) prefac = dvdz * ntils**2 prefac = prefac[..., np.newaxis] ps_tils = self.ps_tilde_interpol(fine_zgrid, mu) integrand = prefac * ps_tils dz = fine_zgrid[0,1] - fine_zgrid[0,0] assert np.allclose(dz * np.ones(tuple(np.subtract(fine_zgrid.shape, (0,1)))), np.diff(fine_zgrid,axis=1), rtol=1e-3) integral = np.trapz(integrand, dx=dz, axis=2) s_norm = self.fine_sfunc(nsubsamples)[..., np.newaxis] values = integral/s_norm return values def V_eff(self,mu,nsubsamples=100): V0 = self.v0( nsubsamples) V0 = np.reshape(V0, (V0.size,1)) nbar = self.ntilde()[1:-1] nbar = np.reshape(nbar, (nbar.size,1)) ps = self.fine_ps_bar(mu, nsubsamples) npfact = np.multiply(nbar, ps) frac = npfact/(1. + npfact) ans = np.multiply(frac**2,V0) return ans
class pairwise(object): def __init__(self, iniFile, kmin=1e-4, kmax=5., knum=200): Config = SafeConfigParser() Config.optionxform = str Config.read(iniFile) self.fparams = {} for (key, val) in Config.items('params'): if ',' in val: param, step = val.split(',') self.fparams[key] = float(param) else: self.fparams[key] = float(val) bigDataDir = Config.get('general', 'bigDataDirectory') self.clttfile = Config.get('general', 'clttfile') self.constDict = dict_from_section(Config, 'constants') self.clusterDict = dictFromSection(Config, 'cluster_params') version = Config.get('general', 'version') beam = listFromConfig(Config, expName, 'beams') noise = listFromConfig(Config, expName, 'noises') freq = listFromConfig(Config, expName, 'freqs') lknee = listFromConfig(Config, expName, 'lknee')[0] alpha = listFromConfig(Config, expName, 'alpha')[0] self.mgrid, self.zgrid, siggrid = pickle.load( open( bigDataDir + "szgrid_" + expName + "_" + gridName + "_v" + version + ".pkl", 'rb')) self.cc = ClusterCosmology(self.fparams, self.constDict, clTTFixFile=self.clttfile) self.HMF = Halo_MF(self.cc, self.mgrid, self.zgrid) if powerZK is None: self.kh, self.pk = self._pk_lin(self.HMF.zarr, kmin, kmax, knum) else: assert kh is not None self.kh = kh self.pk = powerZK def _pk_lin(self, zarr, kmin, kmax, knum): #Linear PK self.cc.pars.set_matter_power(redshifts=zarr, kmax=kmax) self.cc.pars.Transfer.high_precision = True self.cc.pars.Linear = model.Linear_none self.cc.results = camb.get_results(self.cc.pars) kh, z, powerZK = self.cc.results.get_matter_power_spectrum( minkh=kmin, maxkh=kmax, npoints=knum) return kh, powerZK def massWeightedbias(self, q): z_arr = self.HMF.zarr dndm_SZ = self.HMF.dn_dmz_SZ(self.SZprop) R = tinker.radius_from_mass(self.HMF.M200, self.cc.rhoc0om) sigsq = tinker.sigma_sq_integral(R, self.HMF.pk, self.HMF.kh) blin = tinker.tinker_bias(sigsq, 200.) #add loop over k for bweight / bnorm bweight = np.trapz(dndm * blin**q * self.HMF.M200, dx=np.diff(self.HMF.M200), axis=0) bnorm = np.trapz(dndm * self.HMF.M200, dx=np.diff(self.HMF.M200), axis=0) ans = old_div(bweight, bnorm) return ans def zeta(self, rad): k_arr = self.HMF.kh.copy() integ = old_div( np.trapz(k_arr**2 * self.massWeightedbias(2) * j0(k_arr * rad) * self.pk, dx=np.diff(k_arr), axis=0), (2. * np.pi**2)) return integ def zetabar(self, rad): integ = 3. * np.trapz( rad**2 * self.massWeightedbias(1) * self.zeta(rad), dx=np.diff(rad), axis=0) / rad**3 return integ def meanvel(self): Hubble = 1 fg = 1. rad_arr = np.arange(1000) * 0.1 ans = -2. / 3. * 1. / (1. + self.zarr) * Hubble * fg * ( rad_arr * self.zetabar(rad_arr) / (1. + self.zeta(rad_arr))) return ans