def make_xiell_fixedbias(self, f, bvec, apar=1, aperp=1, ngauss=4, kmin=1e-3, kmax=0.8, nk=100, nmax=5): kv, p0k, p2k, p4k = self.make_pell_fixedbias(f, bvec, apar=apar, aperp=aperp, ngauss=ngauss, kmin=kmin, kmax=kmax, nk=nk, nmax=nmax) damping = np.exp(-(self.kint / 10)**2) p0int = loginterp(kv, p0k)(self.kint) * damping p2int = loginterp(kv, p2k)(self.kint) * damping p4int = loginterp(kv, p4k)(self.kint) * damping ss0, xi0 = self.sphr.sph(0, p0int) ss2, xi2 = self.sphr.sph(2, p2int) xi2 *= -1 ss4, xi4 = self.sphr.sph(4, p0int) return (ss0, xi0), (ss2, xi2), (ss4, xi4)
def compute_cumulants(self, b1, b2, bs, b3, alpha, alpha_v, alpha_s0, alpha_s2, s2fog): ''' Calculate velocity moments and turn into cumulants. ''' # Compute each moment self.pars = np.array([b1, b2, bs, b3, alpha, alpha_v, alpha_s0, alpha_s2, s2fog]) self.kv = self.pktable[:,0] self.pzel = self.pktable[:,-1] self.peft = self.pktable[:,1] + b1*self.pktable[:,2] + b1**2*self.pktable[:,3]\ + b2*self.pktable[:,4] + b1*b2*self.pktable[:,5] + b2**2 * self.pktable[:,6]\ + bs*self.pktable[:,7] + b1*bs*self.pktable[:,8] + b2*bs*self.pktable[:,9]\ + bs**2*self.pktable[:,10] + b3*self.pktable[:,11] + b1*b3*self.pktable[:,12] + alpha* self.kv**2 * self.pzel _integrand = loginterp(self.kv, self.peft)(self.kint) #at some point turn into theory extrapolation _integrand = self.weight * _integrand + (1-self.weight) * ((1+b1)**2 * self.plin) qint, xi = self.sph_gsm.sph(0,_integrand*self.window) self.xieft = np.interp(self.rint, qint, xi) self.vkeft = self.vktable[:,1] + b1*self.vktable[:,2] + b1**2*self.vktable[:,3]\ + b2*self.vktable[:,4] + b1*b2*self.vktable[:,5] \ + bs*self.vktable[:,7] + b1*bs*self.vktable[:,8] + b3 * self.vktable[:,11]\ + alpha_v * self.kv * self.pzel _integrand = loginterp(self.kv, self.vkeft)(self.kint) _integrand = self.weight * _integrand + (1-self.weight) * (-2 * (1+b1) * self.plin/self.kint) qint, xi = self.sph_gsm.sph(1,_integrand*self.window) self.veft = np.interp(self.rint, qint, xi) self.s0keft = self.s0[:,1] + b1*self.s0[:,2] + b1**2*self.s0[:,3]\ + b2*self.s0[:,4] \ + bs*self.s0[:,7] \ + alpha_s0 * self.pzel self.s2keft = self.s2[:,1] + b1*self.s2[:,2] + b1**2*self.s2[:,3]\ + b2*self.s2[:,4] \ + bs*self.s2[:,7] \ + alpha_s2 * self.pzel _integrand = loginterp(self.kv, self.s0keft)(self.kint) _integrand = self.weight * _integrand + (1-self.weight) * (-2./3 * self.plin/self.kint**2) qint, xi = self.sph_gsm.sph(0,_integrand * self.window) self.s0eft = np.interp(self.rint, qint, xi) _integrand = loginterp(self.kv, self.s2keft)(self.kint) _integrand = self.weight * _integrand + (1-self.weight) * (-4./3 * self.plin/self.kint**2) qint2, xi = self.sph_gsm.sph(2,_integrand * self.window); xi *=-1 self.s2eft = np.interp(self.rint, qint2, xi) self.s0eft += (self.Xddot + self.Xloopddot + 2*b1*self.X10ddot + 2*bs*self.Xs2ddot)[-1] + s2fog #add in 0-lag term
def update_power_spectrum(self, k, p): # Updates the power spectrum and various q functions. Can continually compute for new cosmologies without reloading FFTW self.k = k self.p = p self.pint = loginterp(k, p)( self.kint) * np.exp(-(self.kint / self.cutoff)**2) self.setup_powerspectrum()
def xi_l_n(self, l, n, _int=None, IR_cut='all', extrap=False, qmin=1e-3, qmax=1000, side='both'): ''' Calculates the generalized correlation function xi_l_n, which is xi when l = n = 0 If _int is None assume integrating the power spectrum. ''' if _int is None: integrand = self.p * self.k**n else: integrand = _int * self.k**n if IR_cut is not 'all': if IR_cut == 'gt': integrand *= self.ir_greater elif IR_cut == 'lt': integrand *= self.ir_less qs, xint = self.sph.sph(l, integrand) if extrap: qrange = (qs > qmin) * (qs < qmax) return loginterp(qs[qrange], xint[qrange], side=side)(self.qv) else: return np.interp(self.qv, qs, xint)
def __init__(self, *args, kmin = 3e-3, kmax=0.5, nk = 100, kswitch=1e-2, jn = 5, cutoff=20, **kw): ''' Same keywords and arguments as the other two classes for now. ''' # Setup ffts etc. VelocityMoments.__init__(self, *args, third_order=True, **kw) self.kmin, self.kmax, self.nk = kmin, kmax, nk self.kv = np.logspace(np.log10(kmin), np.log10(kmax), nk); self.nk = nk self.kint = np.logspace(-5,3,4000) self.plin = loginterp(self.k, self.p)(self.kint) self.sph_gsm = SphericalBesselTransform(self.kint,L=3,fourier=True) self.rint = np.logspace(-3,5,4000) self.rint = self.rint[(self.rint>0.1)*(self.rint<600)] #actual range of integration self.window = tukey(4000) self.weight = 0.5 * (1 + np.tanh(3*np.log(self.kint/kswitch))) self.weight[self.weight < 1e-3] = 0 self.pars = np.array([0,0,0,0, 0,0,0,0, 0]) self.peft = None self.veft = None self.s0eft = None self.s2eft = None self.setup_velocity_moments()
def __init__(self, *args, kmin=1e-2, kmax=0.5, nk=100, **kw): # Initialize the velocity class KEVelocityMoments.__init__(self, *args, **kw) self.nk, self.kmin, self.kmax = nk, kmin, kmax self.make_tables(kmin=kmin, kmax=kmax, nk=nk) self.kv = self.pktable[:, 0] self.plin = loginterp(self.k, self.p)(self.kv) # Now convert to EPT table self.convert_ptable() self.convert_vtable() self.convert_stable() if self.beyond_gauss: self.convert_gtable()
def __init__(self, k, p, third_order = True, shear=True, one_loop=True,\ kIR = None, cutoff=10, jn=5, N = 2000, threads=1, extrap_min = -5, extrap_max = 3): self.N = N self.extrap_max = extrap_max self.extrap_min = extrap_min self.kIR = kIR self.cutoff = cutoff self.kint = np.logspace(extrap_min, extrap_max, self.N) self.qint = np.logspace(-extrap_max, -extrap_min, self.N) self.third_order = third_order self.shear = shear or third_order self.one_loop = one_loop self.k = k self.p = p self.pint = loginterp(k, p)( self.kint) * np.exp(-(self.kint / self.cutoff)**2) self.setup_powerspectrum() self.pktables = {} if self.third_order: self.num_power_components = 13 elif self.shear: self.num_power_components = 11 else: self.num_power_components = 7 self.jn = jn self.threads = threads self.sph = SphericalBesselTransform(self.qint, L=self.jn, ncol=self.num_power_components, threads=self.threads) self.sph1 = SphericalBesselTransform(self.qint, L=self.jn, ncol=1, threads=self.threads) self.sphr = SphericalBesselTransformNP(self.kint, L=5, fourier=True)
def compute_xi_real(self, rr, b1, b2, bs, b3, alpha, alpha_v, alpha_s0, alpha_s2, s2fog): ''' Compute the real-space correlation function at rr. ''' # This is just the zeroth moment: self.kv = self.pktable[:,0] self.pzel = self.pktable[:,-1] self.peft = self.pktable[:,1] + b1*self.pktable[:,2] + b1**2*self.pktable[:,3]\ + b2*self.pktable[:,4] + b1*b2*self.pktable[:,5] + b2**2 * self.pktable[:,6]\ + bs*self.pktable[:,7] + b1*bs*self.pktable[:,8] + b2*bs*self.pktable[:,9]\ + bs**2*self.pktable[:,10] + b3*self.pktable[:,11] + b1*b3*self.pktable[:,12] + alpha* self.kv**2 * self.pzel _integrand = loginterp(self.kv, self.peft)(self.kint) #at some point turn into theory extrapolation _integrand = self.weight * _integrand + (1-self.weight) * ((1+b1)**2 * self.plin) qint, xi = self.sph_gsm.sph(0,_integrand) xir = Spline(qint,xi)(rr) return xir
def combine_bias_terms_xiell(self,bvec,method='loginterp'): ''' Same as above but further transform the pkells into xiells. Again, the paramters f, AP are assumed to be what was input into p{ell}ktable. ''' kv, p0, p2, p4 = self.combine_bias_terms_pkell(bvec) if method == 'loginterp': damping = np.exp(-(self.kint/10)**2) p0int = loginterp(kv, p0)(self.kint) * damping p2int = loginterp(kv, p2)(self.kint) * damping p4int = loginterp(kv, p4)(self.kint) * damping elif method == 'gauss_poly': # Add a point at k = 0 to the spline in k taper nicely frac = 1 p0int = gaussian_poly_extrap( self.kint,\ np.concatenate(([0], kv)),\ np.concatenate(([0], p0)), frac=frac) p2int = gaussian_poly_extrap( self.kint,\ np.concatenate(([0], kv)),\ np.concatenate(([0], p2)), frac=frac ) p4int = gaussian_poly_extrap( self.kint,\ np.concatenate(([0], kv)),\ np.concatenate(([0], p4)), frac=frac ) elif method == 'min_cut': # Start log extrapolating when p_ell is below a threshold value: ftol = 1e-4 damping = np.exp(-(self.kint/10)**2) pints = [np.zeros_like(self.kint), np.zeros_like(self.kint), np.zeros_like(self.kint),] for ii, pp in enumerate([p0,p2,p4]): iis = np.arange(len(kv)) pval = np.max(pp) try: zero_crossing = np.where(np.diff(np.sign(pp)))[0][0] except: zero_crossing = len(pp) cross_min = pp > (ftol * pval) # union is where we interpolate where_int = (iis < zero_crossing) * cross_min ktemp, ptemp = kv[where_int], pp[where_int] pints[ii] += loginterp(ktemp, ptemp)(self.kint) * damping p0int, p2int, p4int = pints ss0, xi0 = self.sphr.sph(0,p0int) ss2, xi2 = self.sphr.sph(2,p2int); xi2 *= -1 ss4, xi4 = self.sphr.sph(4,p4int) return (ss0, xi0), (ss2, xi2), (ss4, xi4)
def __init__(self, k, p, pnw=None, *args, rbao=110, kmin=1e-2, kmax=0.5, nk=100, **kw): self.nk, self.kmin, self.kmax = nk, kmin, kmax self.rbao = rbao self.ept = EPT(k, p, kmin=kmin, kmax=kmax, nk=nk, **kw) if pnw is None: knw = self.ept.kint Nfilter = np.ceil( np.log(7) / np.log(knw[-1] / knw[-2]) ) // 2 * 2 + 1 # filter length ~ log span of one oscillation from k = 0.01 #print(Nfilter) pnw = savgol_filter(self.ept.pint, int(Nfilter), 4) else: knw, pnw = k, pnw self.ept_nw = EPT(knw, pnw, kmin=kmin, kmax=kmax, nk=nk, **kw) self.beyond_gauss = self.ept.beyond_gauss self.kv = self.ept.kv self.plin = loginterp(k, p)(self.kv) self.plin_nw = loginterp(knw, pnw)(self.kv) self.plin_w = self.plin - self.plin_nw self.sigma_squared_bao = np.interp( self.rbao, self.ept_nw.qint, self.ept_nw.Xlin + self.ept_nw.Ylin / 3.) self.damp_exp = -0.5 * self.kv**2 * self.sigma_squared_bao self.damp_fac = np.exp(self.damp_exp) self.plin_ir = self.plin_nw + self.plin_w * self.damp_exp self.pktable_nw = self.ept_nw.pktable_ept self.pktable_w = self.damp_fac[:, None] * ( (self.ept.pktable_ept - self.pktable_nw) - self.damp_exp[:, None] * (self.ept.pktable_ept_linear - self.ept_nw.pktable_ept_linear)) self.pktable_w[:, 0] = self.kv self.pktable = self.pktable_nw + self.pktable_w self.pktable[:, 0] = self.kv self.vktable_nw = self.ept_nw.vktable_ept self.vktable_w = self.damp_fac[:, None] * ( (self.ept.vktable_ept - self.vktable_nw) - self.damp_exp[:, None] * (self.ept.vktable_ept_linear - self.ept_nw.vktable_ept_linear)) self.vktable_w[:, 0] = self.kv self.vktable = self.vktable_nw + self.vktable_w self.vktable[:, 0] = self.kv self.s0ktable_nw = self.ept_nw.s0ktable_ept self.s0ktable_w = self.damp_fac[:, None] * ( (self.ept.s0ktable_ept - self.s0ktable_nw) - self.damp_exp[:, None] * (self.ept.s0ktable_ept_linear - self.ept_nw.s0ktable_ept_linear)) self.s0ktable_w[:, 0] = self.kv self.s0ktable = self.s0ktable_nw + self.s0ktable_w self.s0ktable[:, 0] = self.kv self.s2ktable_nw = self.ept_nw.s2ktable_ept self.s2ktable_w = self.damp_fac[:, None] * ( (self.ept.s2ktable_ept - self.s2ktable_nw) - self.damp_exp[:, None] * (self.ept.s2ktable_ept_linear - self.ept_nw.s2ktable_ept_linear)) self.s2ktable_w[:, 0] = self.kv self.s2ktable = self.s2ktable_nw + self.s2ktable_w self.s2ktable[:, 0] = self.kv if self.beyond_gauss: self.g1ktable_nw = self.ept_nw.g1ktable_ept self.g1ktable_w = self.damp_fac[:, None] * ( self.ept.g1ktable_ept - self.ept_nw.g1ktable_ept) self.g1ktable_w[:, 0] = self.kv self.g1ktable = self.g1ktable_nw + self.g1ktable_w self.g1ktable[:, 0] = self.kv self.g3ktable_nw = self.ept_nw.g3ktable_ept self.g3ktable_w = self.damp_fac[:, None] * ( self.ept.g3ktable_ept - self.ept_nw.g3ktable_ept) self.g3ktable_w[:, 0] = self.kv self.g3ktable = self.g3ktable_nw + self.g3ktable_w self.g3ktable[:, 0] = self.kv self.k0_nw, self.k2_nw, self.k4_nw = self.ept_nw.k0, self.ept_nw.k2, self.ept_nw.k4 self.k0_w = self.damp_fac * (self.ept.k0 - self.ept_nw.k0) self.k2_w = self.damp_fac * (self.ept.k2 - self.ept_nw.k2) self.k4_w = self.damp_fac * (self.ept.k4 - self.ept_nw.k4) self.k0 = self.k0_nw + self.k0_w self.k2 = self.k2_nw + self.k2_w self.k4 = self.k4_nw + self.k4_w