Exemple #1
0
def run():
    xall, yall = np.loadtxt(gpr.get_com_file(0), skiprows=1, usecols=(0, 1), unpack=True)  # 2*[Rscale]
    # calculate 2D radius on the skyplane
    R = np.sqrt(xall ** 2 + yall ** 2)  # [Rscale]
    # set number and size of (linearly spaced) bins
    Rmin = 0.0  # [Rscale]
    Rmax = max(r) if gpr.rprior < 0 else 1.0 * gpr.rprior  # [Rscale]
    print("Rmax [Rscale] = ", Rmax)
    R = R[(R < Rmax)]

    # determine radius once and for all
    # this must not be changed between readout and gravlite run
    # if you wish to change: set gp.getnewdata = True in gl_params.py
    if gp.lograd:
        print(gpr.nbins, " bins in log spacings")
        Binmin, Binmax, Rbin = bin_r_log(Rmax / gpr.nbins, Rmax, gpr.nbins)
    elif gp.consttr:
        print(len(R) / gpr.nbins, " particles per bin")
        Binmin, Binmax, Rbin = bin_r_const_tracers(R, len(R) / gpr.nbins)
    else:
        print(gpr.nbins, " bins in linear spacings")
        Binmin, Binmax, Rbin = bin_r_linear(Rmin, Rmax, gpr.nbins)

    # volume of a circular ring from binmin to binmax
    vol = np.zeros(gpr.nbins)
    for k in range(gpr.nbins):
        vol[k] = 4.0 * np.pi / 3.0 * (Binmax[k] ** 3 - Binmin[k] ** 3)  # [Rscale^3]

    for comp in range(gpr.ncomp):
        print("#######  working on component ", comp)
        print("input: ", gpr.get_com_file(comp) + "_3D")
        # start from data centered on COM already:
        if gfile.bufcount(gpr.get_com_file(comp) + "_3D") < 2:
            continue
        x, y, z, v = np.loadtxt(
            gpr.get_com_file(comp) + "_3D", skiprows=1, usecols=(0, 1, 2, 3), unpack=True
        )  # 3*[Rscale], [km/s]

        # calculate 2D radius on the skyplane
        r = np.sqrt(x ** 2 + y ** 2)  # [Rscale]

        # set maximum radius (if gpr.rprior is set)
        rmax = max(r) if gpr.rprior < 0 else 1.0 * gpr.rprior  # [Rscale]
        print("rmax [Rscale] = ", rmax)
        sel = r <= rmax
        x = x[sel]
        y = y[sel]
        z = z[sel]
        v = v[sel]
        r = r[sel]  # [Rscale]
        totmass = 1.0 * len(x)  # [munit], munit = 1/star

        rs = r  # + possible starting offset, [Rscale]
        vlos = v  # + possible starting offset, [km/s]

        print("output density: ")
        print(gpr.get_ntracer_file(comp) + "_3D")
        tr = open(gpr.get_ntracer_file(comp) + "_3D", "w")
        print(totmass, file=tr)
        tr.close()

        print(gpr.get_dens_file(comp) + "_3D")
        de = open(gpr.get_dens_file(comp) + "_3D", "w")
        print("rbin", "binmin", "binmax", "nu(r)/nu(0)", "error", file=de)

        print(gpr.get_enc_mass_file(comp) + "_3D")
        em = open(gpr.get_enc_mass_file(comp) + "_3D", "w")
        print("rbin", "binmin", "binmax", "M(<r)", "error", file=em)

        # gpr.n=30 iterations for getting random picked radius values
        density = np.zeros((gpr.nbins, gpr.n))
        a = np.zeros((gpr.nbins, gpr.n))  # shared by density, siglos, kappa calcs
        for k in range(gpr.n):
            rsi = gpr.Rerror * np.random.randn(len(rs)) + rs  # [Rscale]
            vlosi = gpr.vrerror * np.random.randn(len(vlos)) + vlos  # [km/s]
            for i in range(gpr.nbins):
                ind1 = np.argwhere(np.logical_and(rsi >= Binmin[i], rsi < Binmax[i])).flatten()  # [1]
                density[i][k] = (1.0 * len(ind1)) / vol[i] * totmass  # [munit/Rscale^2]
                vlos1 = vlosi[ind1]  # [km/s]
                a[i][k] = 1.0 * len(ind1)  # [1]

        # output density
        dens0 = np.sum(density[0]) / (1.0 * gpr.n)  # [munit/Rscale^3]
        print("dens0 = ", dens0, " [munit/Rscale^3]")
        crscale = open(gpr.get_params_file(comp) + "_3D", "r")
        Rscale = np.loadtxt(crscale, comments="#", skiprows=1, unpack=False)
        crscale.close()

        cdens = open(gpr.get_params_file(comp) + "_3D", "a")
        print(dens0, file=cdens)  # [munit/Rscale^3]
        print(dens0 / Rscale ** 3, file=cdens)  # [munit/pc^3]
        print(totmass, file=cdens)  # [munit]
        cdens.close()

        ab0 = np.sum(a[0]) / (1.0 * gpr.n)  # [1]
        denserr0 = dens0 / np.sqrt(ab0)  # [munit/Rscale^3]
        p_dens = np.zeros(gpr.nbins)
        p_edens = np.zeros(gpr.nbins)
        for b in range(gpr.nbins):
            dens = np.sum(density[b]) / (1.0 * gpr.n)  # [munit/Rscale^3]
            ab = np.sum(a[b]) / (1.0 * gpr.n)  # [1]
            denserr = dens / np.sqrt(ab)  # [munit/Rscale^3]
            denserror = np.sqrt((denserr / dens0) ** 2 + (dens * denserr0 / (dens0 ** 2)) ** 2)  # [1]
            if math.isnan(denserror):
                denserror = 0.0  # [1]
                p_dens[b] = p_dens[b - 1]  # [1]
                p_edens[b] = p_edens[b - 1]  # [1]
            else:
                p_dens[b] = dens / dens0  # [1]
                p_edens[b] = denserror  # [1] #100/rbin would be artificial guess

            print(Rbin[b], Binmin[b], Binmax[b], p_dens[b], p_edens[b], file=de)  # [Rscale], 2*[dens0]
            indr = r < Binmax[b]
            menclosed = 1.0 * np.sum(indr) / totmass  # for normalization to 1  # [totmass]
            merror = menclosed / np.sqrt(ab)  # artificial menclosed/10 # [totmass]
            print(Rbin[b], Binmin[b], Binmax[b], menclosed, merror, file=em)  # [rscale], 2*[totmass]
            # TODO: check: take rbinmax for MCMC?
        de.close()
        em.close()

        if not gpr.showplots:
            continue
        # plot density
        ion()
        subplot(111)
        print("rbin = ", Rbin)
        print("p_dens = ", p_dens)
        print("p_edens = ", p_edens)

        plot(Rbin, p_dens, "b", lw=1)
        lbound = p_dens - p_edens
        lbound[lbound < 1e-6] = 1e-6
        ubound = p_dens + p_edens
        fill_between(Rbin, lbound, ubound, alpha=0.5, color="r")
        yscale("log")
        xlim([0, gpr.rprior])
        ylim([np.min(lbound), np.max(ubound)])
        xlabel(r"$r [r_c]$")
        ylabel(r"$\nu(r)/\nu(0)$")
        savefig(gpr.get_dens_png(i) + "_3D.png")
        ioff()
        show()
        clf()
Exemple #2
0
def run():
    print('input: ',gpr.get_com_file(0))
    # start from data centered on COM already:
    x,y,v = np.loadtxt(gpr.get_com_file(0),\
                       skiprows=1,usecols=(0,1,2),unpack=True) #[rscale], [rscale], [km/s]
    
    # calculate 2D radius on the skyplane
    r = np.sqrt(x**2+y**2) #[rscale]
    
    # set number and size of (linearly spaced) bins
    rmin = 0. #[rscale]
    rmax = max(r) if gpr.rprior<0 else 1.0*gpr.rprior #[rscale]
        
    print('rmax [rscale] = ', rmax)
    sel = (r<rmax)
    x = x[sel]; y = y[sel]; v = v[sel] #[rscale]
    totmass = 1.*len(x) #[munit], munit = 1/star
    
    if gp.lograd:
        # space logarithmically in radius
        binmin, binmax, rbin = bin_r_log(rmax/gpr.nbins, rmax, gpr.nbins)
    elif gp.consttr:
        binmin, binmax, rbin = bin_r_const_tracers(r, len(r)/gpr.nbins)
    else:
        binmin, binmax, rbin = bin_r_linear(rmin, rmax, gpr.nbins)
            
    #volume of a circular bin from binmin to binmax
    vol = np.zeros(gpr.nbins)
    for k in range(gpr.nbins):
        vol[k] = np.pi*(binmax[k]**2-binmin[k]**2) # [rscale**2]
            
    # rs = gpr.rerror*np.random.randn(len(r))+r
    rs = r  #[rscale] # if no initial offset is whished
    
    print('output: ')
    print(gpr.get_ntracer_file(0))
    tr = open(gpr.get_ntracer_file(0),'w')
    print(totmass, file=tr)
    tr.close()

    print(gpr.get_dens_file(0))
    de = open(gpr.get_dens_file(0),'w')
    print(gpr.get_enc_mass_file(0))
    em = open(gpr.get_enc_mass_file(0),'w')
    
    print('r','nu(r)/nu(0)','error', file=de)
    print('r','M(<r)','error', file=em)

    # 30 iterations for getting random picked radius values
    density = np.zeros((gpr.nbins,gpr.n))
    a       = np.zeros((gpr.nbins,gpr.n))
    for k in range(gpr.n):
        rsi = gpr.rerror * np.random.randn(len(rs)) + rs # [rscale]
        for j in range(gpr.nbins):
            ind1 = np.argwhere(np.logical_and(rsi>=binmin[j],rsi<binmax[j])).flatten() # [1]
            density[j][k] = (1.*len(ind1))/vol[j]*totmass # [munit/rscale**2]
            a[j][k] = 1.*len(ind1) #[1]
            
    dens0 = np.sum(density[0])/(1.*gpr.n) # [munit/rscale**2]
    print('dens0 = ',dens0,'[munit/rscale**2]')
    crscale = open(gpr.get_params_file(0),'r')
    rscale = np.loadtxt(crscale, comments='#', skiprows=1, unpack=False)
    crscale.close()

    cdens = open(gpr.get_params_file(0),'a')
    print(dens0, file=cdens)               # [munit/rscale**2]
    print(dens0/rscale**2, file=cdens)      # [munit/pc**2]
    print(totmass, file=cdens)             # [munit]
    cdens.close()
    
    ab0   = np.sum(a[0])/(1.*gpr.n)     # [1]
    denserr0 = dens0/np.sqrt(ab0)       # [munit/rscale**2]

    p_dens  = np.zeros(gpr.nbins);  p_edens = np.zeros(gpr.nbins)
    
    for b in range(gpr.nbins):
        dens = np.sum(density[b])/(1.*gpr.n) # [munit/rscale**2]
        ab   = np.sum(a[b])/(1.*gpr.n)       # [1]
        denserr = dens/np.sqrt(ab)       # [munit/rscale**2]
        denserror = np.sqrt((denserr/dens0)**2+(dens*denserr0/(dens0**2))**2) #[1]
        if(math.isnan(denserror)):
            denserror = 0. # [1]
            ## [PS]: TODO: change bin sizes to include same number of
            ##             stars in each bin, not assigning wrong density as below
            p_dens[b] = p_dens[b-1]  # [1]
            p_edens[b]= p_edens[b-1] # [1]
        else:
            p_dens[b] = dens/dens0   # [1]
            p_edens[b]= denserror    # [1] #100/rbin would be artificial guess

    for b in range(gpr.nbins):
        print(rbin[b],p_dens[b],p_edens[b], file=de) # [rscale], [dens0], [dens0]
        indr = (r<binmax[b])
        menclosed = 1.0*np.sum(indr)/totmass # /totmass for normalization to 1 at last bin #[totmass]
        merror = menclosed/np.sqrt(ab) # artificial menclosed/10 gives good approximation #[totmass]
        print(rbin[b],menclosed,merror, file=em) # [rscale], [totmass], [totmass]
        # TODO: check: take rbinmax for MCMC?
    de.close()
    em.close()


    if not gpr.showplots: return
    ion(); subplot(111)
    print('rbin = ',rbin)
    print('p_dens = ',p_dens)
    print('p_edens = ',p_edens)

    plot(rbin,p_dens,'b',linewidth=3)
    lbound = p_dens-p_edens; lbound[lbound<1e-6] = 1e-6
    ubound = p_dens+p_edens; 
    fill_between(rbin,lbound,ubound,alpha=0.5,color='r')
    # xscale('log'); 
    yscale('log')
    xlim([np.min(rbin),np.max(rbin)])
    ylim([np.min(lbound),np.max(ubound)])
    # ylim([1e-3,3.])#ylim([1e-6,2*np.max(p_dens)])
    # ylim([0,1])
    xlabel(r'$r [r_c]$')
    ylabel(r'$\nu(r)/\nu(0)$')
    # plt.legend(['\rho','\rho'],'lower left')
    # title(fil)
    # axes().set_aspect('equal')
    savefig(gpr.get_dens_png(0))
    if gpr.showplots:
        ioff(); show(); clf()
Exemple #3
0
def run():
    xall,yall = np.loadtxt(gpr.get_com_file(0), skiprows=1, usecols=(0,1), unpack=True) # 2*[Rscale]
    # calculate 2D radius on the skyplane
    R = np.sqrt(xall**2+yall**2) # [Rscale]
    # set number and size of (linearly spaced) bins
    Rmin = 0. #[rscale]
    Rmax = max(R) if gpr.rprior<0 else 1.0*gpr.rprior # [Rscale]
    print('Rmax [Rscale] = ', Rmax)
    R = R[(R<Rmax)]

    # determine radius once and for all
    # this must not be changed between readout and gravlite run
    # if you wish to change: set gp.getnewdata = True in gl_params.py
    if gp.lograd:
        print(gpr.nbins,' bins in log spacings')
        Binmin, Binmax, Rbin = bin_r_log(Rmax/gpr.nbins, Rmax, gpr.nbins)
    elif gp.consttr:
        print(len(R)/gpr.nbins,' particles per bin')
        Binmin, Binmax, Rbin = bin_r_const_tracers(R, len(R)/gpr.nbins)
    else:
        print(gpr.nbins, ' bins in linear spacings')
        Binmin, Binmax, Rbin = bin_r_linear(Rmin, Rmax, gpr.nbins)


    # volume of a circular ring from binmin to binmax
    Vol = np.zeros(gpr.nbins)
    for k in range(gpr.nbins):
        Vol[k] = np.pi*(Binmax[k]**2-Binmin[k]**2) # [Rscale^2]


    for comp in range(gpr.ncomp):
        print('#######  working on component ',comp)
        print('input: ',gpr.get_com_file(comp))
        # start from data centered on COM already:
        if gfile.bufcount(gpr.get_com_file(comp))<2: continue
        x,y,v = np.loadtxt(gpr.get_com_file(comp),\
                           skiprows=1,usecols=(0,1,2),unpack=True) #[rscale], [rscale], [km/s]

        # calculate 2D radius on the skyplane
        R = np.sqrt(x**2+y**2) #[rscale]
        
        # set maximum radius (if gpr.rprior is set)
        Rmax = max(R) if gpr.rprior<0 else 1.0*gpr.rprior # [Rscale]
        print('Rmax [Rscale] = ', Rmax)
        sel = (R<=Rmax)
        x = x[sel]; y = y[sel]; v = v[sel]; R = R[sel] # [Rscale]
        totmass = 1.*len(x) # [munit], munit = 1/star
            
        Rs = R                   # + possible starting offset, [Rscale]
        vlos = v                 # + possible starting offset, [km/s]
        
        print('output density: ')
        print(gpr.get_ntracer_file(comp))
        tr = open(gpr.get_ntracer_file(comp),'w')
        print(totmass, file=tr)
        tr.close()

        print(gpr.get_dens_file(comp))
        de = open(gpr.get_dens_file(comp),'w')
        print('Rbin [Rscale]','Binmin [Rscale]','Binmax [Rscale]','Nu(R)/Nu(0) [1]','error [1]', file=de)

        print(gpr.get_enc_mass_file(comp))
        em = open(gpr.get_enc_mass_file(comp),'w')
        print('R [Rscale]','Binmin [Rscale]','Binmax [Rscale]','M(<Binmax) [Msun]','error [Msun]', file=em)


        print('output siglos: ',gpr.get_siglos_file(comp))
        sigfil = open(gpr.get_siglos_file(comp),'w')
        print('R [Rscale]','Binmin [Rscale]','Binmax [Rscale]','sigma_r(R) [km/s]','error [km/s]', file=sigfil)


        print('output kurtosis: ',gpr.get_kurtosis_file(comp))
        kappafil = open(gpr.get_kurtosis_file(comp),'w')
        print('R [Rscale]','Binmin [Rscale]','Binmax [Rscale]','kappa_los(R) [1]','error [1]', file=kappafil)


        # gpr.n=30 iterations for getting random picked radius values
        Density = np.zeros((gpr.nbins,gpr.n))
        dispvelocity = np.zeros((gpr.nbins,gpr.n))
        mom4         = np.zeros((gpr.nbins,gpr.n))
        a            = np.zeros((gpr.nbins,gpr.n)) # shared by density, siglos, kappa calcs
        for k in range(gpr.n):
            Rsi = gpr.Rerror * np.random.randn(len(Rs)) + Rs # [Rscale]
            vlosi = gpr.vrerror * np.random.randn(len(vlos)) + vlos # [km/s]
            for i in range(gpr.nbins):
                ind1 = np.argwhere(np.logical_and(Rsi >= Binmin[i],Rsi<Binmax[i])).flatten() # [1]
                Density[i][k] = (1.*len(ind1))/Vol[i]*totmass # [munit/rscale**2]
                vlos1 = vlosi[ind1] # [km/s]

                if(len(ind1)<=1):
                    dispvelocity[i][k] = dispvelocity[i-1][k]
                    mom4[i][k] = mom4[i-1][k]
                    # attention! should be 0, uses last value
                else:
                    dispvelocity[i][k] = meanbiweight(vlos1,ci_perc=68.4,ci_mean=True,ci_std=True)[1]
                                        # [km/s], see BiWeight.py
                    mom4[i][k] = kurtosis(vlos1, axis=0, fisher=False, bias=False) # [1]

                a[i][k] = 1.*len(ind1) #[1]

        # output density
        Dens0 = np.sum(Density[0])/(1.*gpr.n) # [munit/Rscale^2]
        print('Dens0 = ', Dens0, '[munit/Rscale^2]')
        crscale = open(gpr.get_params_file(comp),'r')
        Rscale = np.loadtxt(crscale, comments='#', skiprows=1, unpack=False)
        crscale.close()

        cdens = open(gpr.get_params_file(comp),'a')
        print(Dens0, file=cdens)               # [munit/Rscale^2]
        Dens0pc = Dens0/Rscale**2              # [munis/pc^2]
        print(Dens0pc, file=cdens)             # [munit/pc^2]
        print(totmass, file=cdens)             # [munit]
        cdens.close()

        ab0   = np.sum(a[0])/(1.*gpr.n)     # [1]
        Denserr0 = Dens0/np.sqrt(ab0)       # [munit/Rscale^2]
        P_dens  = np.zeros(gpr.nbins);  P_edens = np.zeros(gpr.nbins)
        for b in range(gpr.nbins):
            Dens = np.sum(Density[b])/(1.*gpr.n) # [munit/Rscale^2]
            ab   = np.sum(a[b])/(1.*gpr.n)       # [1]
            Denserr = Dens/np.sqrt(ab)       # [munit/Rscale^2]
            # TODO: too small? offset in nu?
            Denserror = np.sqrt((Denserr/Dens0)**2+(Dens*Denserr0/(Dens0**2))**2) # [1]
            if(math.isnan(Denserror)):
                Denserror = 0. # [1]
                P_dens[b] = P_dens[b-1]  # [1]
                P_edens[b]= P_edens[b-1] # [1]
            else:
                P_dens[b] = Dens/Dens0   # [1]
                P_edens[b]= Denserror    # [1] #100/rbin would be artificial guess

            print(Rbin[b], Binmin[b], Binmax[b], P_dens[b], P_edens[b], file=de)
            # 3*[rscale], [dens0], [dens0]
            indr = (R<Binmax[b])
            Menclosed = 1.0*np.sum(indr)/totmass # for normalization to 1  #[totmass]
            Merror = Menclosed/np.sqrt(ab) # or artificial Menclosed/10 #[totmass]
            print(Rbin[b], Binmin[b], Binmax[b], Menclosed, Merror, file=em) # [Rscale], 2* [totmass]
            # TODO: check: take rbinmax for MCMC?
        de.close()
        em.close()


        # output siglos
        p_dvlos = np.zeros(gpr.nbins);        p_edvlos = np.zeros(gpr.nbins)
        for b in range(gpr.nbins):
            dispvel = np.sum(dispvelocity[b])/gpr.n #[km/s]
            ab = np.sum(a[b])/(1.*gpr.n) #[1]
            if ab == 0:
                dispvelerror = p_edvlos[b-1] #[km/s]
                # attention! uses last error
            else:
                dispvelerror = dispvel/np.sqrt(ab) #[km/s]
            p_dvlos[b] = dispvel      #[km/s]
            p_edvlos[b]= dispvelerror #[km/s]

        maxvlos = max(p_dvlos) #[km/s]
        print('maxvlos = ', maxvlos, '[km/s]')
        fpars = open(gpr.get_params_file(comp),'a')
        print(maxvlos, file=fpars)          #[km/s]
        fpars.close()
        
        for b in range(gpr.nbins):
            print(Rbin[b], Binmin[b], Binmax[b], np.abs(p_dvlos[b]/maxvlos),np.abs(p_edvlos[b]/maxvlos), file=sigfil)
            # 3*[rscale], 2*[maxvlos]
            # TODO: check uncommented /np.sqrt(n))
        sigfil.close()


        # output kurtosis kappa
        p_kappa = np.zeros(gpr.nbins) # needed for plotting later
        p_ekappa = np.zeros(gpr.nbins)
        for b in range(gpr.nbins):
            kappavel = np.sum(mom4[b])/gpr.n #[1]
            ab = np.sum(a[b])/(1.*gpr.n) #[1]
            if ab == 0:
                kappavelerror = p_edvlos[b-1] #[1]
                # attention! uses last error
            else:
                kappavelerror = np.abs(kappavel/np.sqrt(ab)) #[1]
            p_kappa[b] = kappavel
            p_ekappa[b] = kappavelerror
            
            print(Rbin[b],Binmin[b],Binmax[b], kappavel, kappavelerror, file=kappafil) # [rscale], 2*[1]
            # TODO: /np.sqrt(n))
        kappafil.close()


    
        if not gpr.showplots: continue
        # plot density
        ion(); subplot(111)
        print('Rbin = ', Rbin)
        print('P_dens = ', P_dens)
        print('P_edens = ', P_edens)

        plot(Rbin, P_dens*Dens0pc, 'b', lw=1)
        lbound = (P_dens-P_edens)*Dens0pc; lbound[lbound<1e-6] = 1e-6
        ubound = (P_dens+P_edens)*Dens0pc
        fill_between(Rbin, lbound, ubound, alpha=0.5, color='r')
        yscale('log')
        # xlim([0, gpr.rprior])
        # ylim([np.min(lbound),np.max(ubound)])
        xlabel(r'$R [R_c]$')
        ylabel(r'$\nu_{2D}(R) [\mathrm{Msun/pc/pc}]$')
        savefig(gpr.get_dens_png(i))
        ioff(); show(); clf()

        # plot siglos
        ion(); subplot(111)
        print('Rbin = ',Rbin,' Rscale')
        print('p_dvlos = ',p_dvlos,' km/s')
        print('p_edvlos = ',p_edvlos, 'km/s')
        plot(Rbin, p_dvlos, 'b', lw=1)
        fill_between(Rbin, p_dvlos-p_edvlos, p_dvlos+p_edvlos, alpha=0.5, color='r')
        # [rscale],2*[km/s]

        xlabel(r'$R [\mathrm{Rscale}]$')
        ylabel(r'$\langle\sigma_{\mathrm{LOS}}\rangle [\mathrm{km/s}]$')
        ylim([-1, 30])
        # xlim([0, 3])
        savefig(gpr.get_siglos_png(comp))
        ioff(); show(); clf()


        # plot kappa
        ion(); subplot(111)
        print('Rbin = ', Rbin, ' Rscale')
        print('p_kappa = ', p_kappa)
        print('p_ekappa = ', p_ekappa)
        plot(Rbin, p_kappa, 'b', lw=1)
        fill_between(Rbin, p_kappa-p_ekappa, p_kappa+p_ekappa, alpha=0.5, color='r')
        # [rscale], 2*[1]
        xlabel(r'$R [\mathrm{Rscale}]$')
        ylabel(r'$\langle\kappa_{\mathrm{LOS}}\rangle [1]$')
        ylim([0, 5.])
        # xlim([0, gpr.rprior])
        savefig(gpr.get_kurtosis_png(comp))
        ioff(); show(); clf()
Exemple #4
0
def run():
    Rscale = []; Dens0Rscale = []; Dens0pc = []; Totmass = []; Maxvlos = []
    rscale = []; dens0Rscale = []; dens0pc = []; totmass = []; maxvlos = []

    for comp in range(3):
        A = np.loadtxt(gp.files.get_scale_file(comp), unpack=False, skiprows=1)
        Rscale.append(A[0])
        Dens0Rscale.append(A[1])
        Dens0pc.append(A[2])
        Totmass.append(A[3])
        
        B = np.loadtxt(gp.files.get_scale_file(comp)+'_3D', unpack=False, skiprows=1)
        rscale.append(B[0])
        dens0Rscale.append(B[1])
        dens0pc.append(B[2])
        totmass.append(B[3])
        
        print('#######  working on component ',comp)
        print('input: ',gpr.get_com_file(comp)+'_3D')
        # start from data centered on COM already:
        if gfile.bufcount(gpr.get_com_file(comp)+'_3D')<2: continue
        
        
        
        Rbin,Binmin,Binmax,Dens,Denserr = np.loadtxt(gpr.get_dens_file(comp),\
                                                     skiprows=1,usecols=(0,1,2,3,4),\
                                                     unpack=True) # 3*[Rscale], [km/s]
        Rbin*=Rscale[comp]; Binmin*=Rscale[comp]; Binmax*=Rscale[comp]; Dens*=Dens0pc[comp]; Denserr*=Dens0pc[comp]
        
        
        
        rbin,binmin,binmax,dens,denserr = np.loadtxt(gpr.get_dens_file(comp)+'_3D',\
                                                     skiprows=1,usecols=(0,1,2,3,4),\
                                                     unpack=True) # 3*[Rscale], [km/s]
        rbin*=rscale[comp]; binmin*=rscale[comp]; binmax*=rscale[comp]; dens*=dens0pc[comp]; denserr*=dens0pc[comp]
        
        
        ion()
        f=figure(figsize=(6,3))
        ax1 = f.add_subplot(121)                         # Nu
        ax2 = f.add_subplot(122, sharex=ax1)             # nu
        
        ax1.plot(Rbin, Dens,'b',lw=1)
        lbound = Dens-Denserr; lbound[lbound<1e-6] = 1e-6
        ubound = Dens+Denserr; 
        ax1.fill_between(Rbin,lbound,ubound,alpha=0.5,color='r')
        ax1.set_yscale('log')
        ax1.set_xlim([0,np.max(Binmax)])
        ax1.set_ylim([np.min(lbound),np.max(ubound)])
        ax1.set_xlabel(r'$R [R_c]$')
        ax1.set_ylabel(r'$\nu_{2D}(R)/\nu_{2D}(0)$')
        
        try:
            ax1.plot(Rbin,rho_INT_Rho(Rbin,dens,denserr))
            ax1.plot(Rbin,rho_INT_Rho(Rbin,Rho_INT_rho(Rbin,Dens,Denserr),denserr))
        except Exception as detail:
            print('rho_INT_Rho giving NaN in plotting')
        draw()
        
        
        ax2.plot(rbin, dens,'b',lw=1)
        lbound = dens-denserr; lbound[lbound<1e-6] = 1e-6
        ubound = dens+denserr;
        ax2.fill_between(rbin,lbound,ubound,alpha=0.5,color='r')
        
        ax2.set_yscale('log')
        ax2.set_xlim([0,np.max(binmax)])
        ax2.set_ylim([np.min(lbound),np.max(ubound)])
        ax2.set_xlabel(r'$r [R_c]$')
        ax2.set_ylabel(r'$\nu(r)/\nu(0)$')
        ax2.yaxis.tick_right()
        ax2.yaxis.set_label_position("right")
        draw()
        
        # projNu = rho_INT_Rho(rbin, dens) # TODO: do not forget try
        # projNu = test(rbin, binmin, binmax, dens)
        # ax1.plot(rbin, projNu)
        
        ax2.plot(rbin,Rho_INT_rho(Rbin,Dens,Denserr),color='green')
        draw()
        
        pdb.set_trace()
        ioff(); show()
Exemple #5
0
def run():
    for comp in range(gpr.ncomp):
        print('input:',gpr.fileposspherical[comp])
        R, Phi, vlos = np.loadtxt(gpr.fileposspherical[comp],\
                                  comments='#', unpack=True)
        Totmass = 1.*len(R) # [munit], munit = 1/star
        # Rs=gpr.Rerror*np.random.randn(len(r))+r
        # Rs not changed later on, ever: misplacement, for all realizations. wanted?
        # yes, we scatter radii in foo_pool
        Rs = R;    Rmin = min(Rs);     Rmax = max(Rs)
        if gp.lograd:
            print(gpr.nbins,' bins in log spacings')
            Binmin, Binmax, Rbin = bin_r_log(Rmax/gpr.nbins, Rmax, gpr.nbins)
        elif gp.consttr:
            Binmin, Binmax, Rbin = bin_r_const_tracers(Rs, len(Rs)/gpr.nbins)
            print(len(R)/gpr.nbins,' particles per bin')
        else:
            print(gpr.nbins, ' bins in linear spacings')
            Binmin, Binmax, Rbin = bin_r_linear(Rmin, Rmax, gpr.nbins)

        # volume of a bin with height binlength, 2D
        Vol = np.zeros(gpr.bins)
        for i in range(gpr.bins):
            Vol[i] = np.pi*(Binmax[i]**2-Binmin[i]**2)

        # gpr.n=30 iterations for getting random picked radius values
        Density = np.zeros((gpr.nbins,gpr.n))
        A       = np.zeros((gpr.nbins,gpr.n)) # shared by density, siglos, kappa calcs
        for k in range(gpr.n):
            Rsi = gpr.Rerror * np.random.randn(len(Rs)) + Rs # [Rscale]
            vlosi = gpr.vrerror * np.random.randn(len(vlos)) + vlos
            for i in range(gpr.nbins):
                ind1 = np.argwhere(np.logical_and(Rsi>=Binmin[i], Rsi<Binmax[i])).flatten() # [1]
                Density[i][k] = (1.*len(ind1))/Vol[i]*Totmass # [munit/Rscale^2]
                vlos1 = vlosi[ind1]                           # [km/s]
                A[i][k] = 1.*len(ind1)                        # [1]

        # output density
        Dens0 = np.sum(Density[0])/(1.*gpr.n) # [munit/Rscale^3]
        print('Dens0 = ',Dens0,' [munit/Rscale^2]')
        crscale = open(gpr.get_params_file(comp),'r')
        Rscale = np.loadtxt(cscale, comments='#', unpack=False)
        crscale.close()

        cdens = open(gpr.get_params_file(comp),'a')
        print(Dens0,file=cdens)               # [munit/Rscale^2]
        print(Dens0/Rscale**2,file=cdens)      # [munit/pc^2]
        print(Totmass,file=cdens)             # [munit]
        cdens.close()

        print(gpr.get_dens_file(comp))
        de = open(gpr.get_dens_file(comp),'w')
        print('# Rbin [Rscale]','Binmin [Rscale]','Binmax [Rscale]',
              'Nu(R)/Nu(0) [1]','error [1]', file=de)
    
        print(gpr.get_enc_mass_file(comp))
        em = open(gpr.get_enc_mass_file(comp),'w')
        print('# R [Rscale]','Binmin [Rscale]','Binmax [Rscale]',\
              'M(<Binmax) [Msun]','error [Msun]', file=em)

    
        AB0   = np.sum(A[0])/(1.*gpr.n)     # [1]
        Denserr0 = Dens0/np.sqrt(AB0)       # [munit/Rscale^3]
        P_dens  = np.zeros(gpr.nbins);  P_edens = np.zeros(gpr.nbins)
        for b in range(gpr.nbins):
            Dens = np.sum(Density[b])/(1.*gpr.n) # [munit/Rscale^3]
            AB   = np.sum(A[b])/(1.*gpr.n)       # [1]
            Denserr = Dens/np.sqrt(AB)       # [munit/Rscale^3]
            Denserror = np.sqrt((Denserr/Dens0)**2+(Dens*Denserr0/(Dens0**2))**2) #[1]
            if(math.isnan(Denserror)):
                Denserror = 0. # [1]
                P_dens[b] = P_dens[b-1]  # [1]
                P_edens[b]= P_edens[b-1] # [1]
            else:
                P_dens[b] = Dens/Dens0   # [1]
                P_edens[b]= Denserror    # [1] #100/rbin would be artificial guess

            print(Rbin[b], Binmin[b], Binmax[b], P_dens[b], P_edens[b], file=de)
            # [Rscale], 2*[dens0]

            # normalization to 1:
            indr = (R<Binmax[b])
            menclosed = 1.0*np.sum(indr)/Totmass  # [Totmass]
            
            merror = menclosed/np.sqrt(AB) # artificial menclosed/10 # [Totmass]
            print(Rbin[b], Binmin[b], Binmax[b], menclosed, merror, file=em)
            # [rscale], 2*[Totmass]
            # TODO: check: take rbinmax for MCMC?
        de.close()
        em.close()
        
        if not gpr.showplots:
            continue
        
        # plot density
        ion(); subplot(111)
        print('Rbin = ',Rbin)
        print('P_dens = ',P_dens)
        print('P_edens = ',P_edens)
        
        plot(Rbin,P_dens,'b',lw=1)
        lbound = P_dens-P_edens; lbound[lbound<1e-6] = 1e-6
        ubound = P_dens+P_edens; 
        fill_between(Rbin, lbound, ubound, alpha=0.5, color='r')
        yscale('log')
        # xlim([0,3.])
        # ylim([np.min(lbound),np.max(ubound)])
        xlabel(r'$R [R_c]$')
        ylabel(r'$\nu_{2D}(R)/\nu_{2D}(0)$')
        savefig(gpr.get_dens_png(i))
        if gpr.showplots:
            ioff(); show(); clf()
    return