Exemple #1
0
def H0_to_theta(hubble, omega_nu, omnuh2, omega_m, ommh2, omega_c, omch2,
                omega_b, ombh2, omega_lambda, omlamh2):
    h = hubble / 100.
    if np.isnan(omnuh2):
        omnuh2 = omega_nu * h**2
    if np.isnan(omega_m):
        omega_m = ommh2 / h**2
    if np.isnan(omega_b):
        omega_b = ombh2 / h**2
    if np.isnan(omega_lambda):
        omega_lambda = omlamh2 / h**2
    if np.isnan(omega_c):
        omega_c = omch2 / h**2
    if np.isnan(omega_m):
        omega_m = omega_c + omega_b + omega_nu
    if np.isnan(omega_m):
        omega_m = (omch2 + ombh2 + omnuh2) / h**2

    if np.isnan([omnuh2, hubble, omega_m, omega_lambda, omega_b]).any():
        return np.nan

    m_nu = 93.14 * omnuh2 * units.eV
    cosmo = LambdaCDM(hubble,
                      omega_m,
                      omega_lambda,
                      m_nu=m_nu / 3,
                      Ob0=omega_b,
                      Tcmb0=2.7255,
                      Neff=3.046)

    ombh2 = cosmo.Ob0 * cosmo.h**2
    omdmh2 = cosmo.Om0 * cosmo.h**2

    zstar = 1048 * (1 + 0.00124 * ombh2**(-0.738)) * (
        1 + (0.0783 * ombh2**(-0.238) / (1 + 39.5 * ombh2**0.763)) *
        (omdmh2 + ombh2)**(0.560 / (1 + 21.1 * ombh2**1.81)))
    astar = 1 / (1 + zstar)
    rs = scipy.integrate.romberg(dsound_da,
                                 1e-8,
                                 astar,
                                 rtol=5e-5,
                                 args=(cosmo, ),
                                 divmax=10)  # in Mpc
    DA = cosmo.angular_diameter_distance(zstar).to("Mpc").value / astar
    return rs / DA
def partial_profile(RA0,DEC0,Z,angles,
                    RIN,ROUT,ndots,h,roff,phi_off):

        ndots = int(ndots)

        cosmo = LambdaCDM(H0=100*h, Om0=0.25, Ode0=0.75)
        dl  = cosmo.angular_diameter_distance(Z).value
        KPCSCALE   = dl*(((1.0/3600.0)*np.pi)/180.0)*1000.0
        
        delta = ROUT/(3600*KPCSCALE)
        
        t0 = time.time()
        mask = (S.ra < (RA0+delta))&(S.ra > (RA0-delta))&(S.dec > (DEC0-delta))&(S.dec < (DEC0+delta))&(S.z_v > (Z+0.1))
        t1 = time.time()  
        # print(t1-t0)             
        catdata = S[mask]

        ds  = cosmo.angular_diameter_distance(catdata.z_v).value
        dls = cosmo.angular_diameter_distance_z1z2(Z, catdata.z_v).value
                
        
        BETA_array = dls/ds
        
        Dl = dl*1.e6*pc
        sigma_c = (((cvel**2.0)/(4.0*np.pi*G*Dl))*(1./BETA_array))*(pc**2/Msun)

        t2 = time.time()
        # print(RA0,DEC0,t2-t1)

        rads, theta, test1,test2 = eq2p2(np.deg2rad(catdata.ra),
                                        np.deg2rad(catdata.dec),
                                        np.deg2rad(RA0),
                                        np.deg2rad(DEC0))
        
        theta2 = (2.*np.pi - theta) +np.pi/2.
        theta_ra = theta2
        theta_ra[theta2 > 2.*np.pi] = theta2[theta2 > 2.*np.pi] - 2.*np.pi
                       
        e1     = catdata.gamma1
        e2     = -1.*catdata.gamma2
        
       
        #get tangential ellipticities 
        et = (-e1*np.cos(2*theta)-e2*np.sin(2*theta))*sigma_c
        #get cross ellipticities
        ex = (-e1*np.sin(2*theta)+e2*np.cos(2*theta))*sigma_c
        # '''
        k  = catdata.kappa*sigma_c
          
        del(e1)
        del(e2)
        
        r = np.rad2deg(rads)*3600*KPCSCALE
        r = np.sqrt(roff**2 + r**2 + 2.*roff*r*np.cos(phi_off))
        del(rads)
        
        
        Ntot = len(catdata)
        del(catdata)    
        
        bines = np.round(np.logspace(np.log10(RIN),np.log10(ROUT),num=ndots+1),0)
        dig = np.digitize(r,bines)
        
        t = np.tile(theta_ra,(3,1)).T
        an = np.tile(angles,(len(theta_ra),1))
        at     = t - an
        
        
        SIGMAwsum    = []
        DSIGMAwsum_T = []
        DSIGMAwsum_X = []
        N_inbin = []
              
        GAMMATcos_wsum = np.zeros((ndots,3))
        GAMMAXsin_wsum = np.zeros((ndots,3))
                
        COS2_2theta = np.zeros((ndots,3))
        SIN2_2theta = np.zeros((ndots,3))
                       
        for nbin in range(ndots):
                mbin = dig == nbin+1              
                
                SIGMAwsum    = np.append(SIGMAwsum,k[mbin].sum())
                DSIGMAwsum_T = np.append(DSIGMAwsum_T,et[mbin].sum())
                DSIGMAwsum_X = np.append(DSIGMAwsum_X,ex[mbin].sum())

                GAMMATcos_wsum[nbin,:] = np.sum((np.tile(et[mbin],(3,1))*np.cos(2.*at[mbin]).T),axis=1)
                GAMMAXsin_wsum[nbin,:] = np.sum((np.tile(ex[mbin],(3,1))*np.sin(2.*at[mbin]).T),axis=1)
                
                COS2_2theta[nbin,:] = np.sum((np.cos(2.*at[mbin]).T)**2,axis=1)
                SIN2_2theta[nbin,:] = np.sum((np.sin(2.*at[mbin]).T)**2,axis=1)
                               
                N_inbin = np.append(N_inbin,len(et[mbin]))
                
                index = np.arange(mbin.sum())
        
        output = {'SIGMAwsum':SIGMAwsum,'DSIGMAwsum_T':DSIGMAwsum_T,
                   'DSIGMAwsum_X':DSIGMAwsum_X,
                   'GAMMATcos_wsum': GAMMATcos_wsum, 'GAMMAXsin_wsum': GAMMAXsin_wsum,
                   'COS2_2theta_wsum':COS2_2theta,'SIN2_2theta_wsum':SIN2_2theta,
                   'N_inbin':N_inbin,'Ntot':Ntot}
        
        return output
      
      ra, dec = wcs.all_pix2world(x, y, 1)
      dra, ddec = ra-centre[0], dec-centre[1]
      dra  *= 3600.	
      ddec *= 3600.
      dist  = ang_sep(centre[0],centre[1],ra,dec).T*3600
      
      mask = dist < radius
      
      return mass[mask].sum(),std[mask].sum(),np.median(sn[mask])


folder = '../main/grid1.0/'

z = 0.397
dl  = cosmo.angular_diameter_distance(z).value 	# in kpc
kpcscale = dl*np.deg2rad(1.0/3600.0)*1000.0

r_100 = 100./kpcscale
r_200 = 200./kpcscale

S1c = [64.011542, -24.093647]
S2c = [64.016187, -24.075967]
S3c = [64.031547, -24.048917]
S4c = [64.061442, -24.053878]
S1p = [64.134196, -24.088425]

S1c_mass200 = []
S2c_mass200 = []
S3c_mass200 = []
S4c_mass200 = []
Exemple #4
0
from astropy.cosmology import LambdaCDM
import numpy as np

d = open('./c_shape').readlines()
temp = open('./sqlcl.in').readlines()
cos = LambdaCDM(H0=73, Om0=0.27, Ode0=0.73)

ra = []
dec = []
z = []
#print( d )
for i in d:
    t = i[:-1].split()
    ra.append(float(t[0]))
    dec.append(float(t[1]))
    z.append(float(t[-3]))

cl = 'dbo.fGetNearbyObjEq(%f, %f, %f) AS GN\n'
R = 5.0

for i in range(len(ra)):
    f = open('./sql/sql_%i' % (i), 'w')
    r = R / cos.angular_diameter_distance(z[i]).value / np.pi * 180 * 60
    for j in temp:
        if (j[0:3] == 'dbo'):
            f.write(cl % (ra[i], dec[i], r))
        else:
            f.write(j)
    f.close()
    #break