コード例 #1
0
ファイル: grh_siglos2D.py プロジェクト: sofiasi/darcoda
def foo_pool(k):
  rsi  = gpr.rerror*np.random.randn(len(rs))+rs
  vzsi = gpr.vrerror*np.random.randn(len(vzs))+vzs
  locdisp=[]; loca = []
  for i in range(gpr.bins):
    ind1 = np.argwhere( np.logical_and(rsi > binmin[i], rsi < binmax[i])).flatten()
    vz1  = vzsi[ind1]
    locdisp.append(meanbiweight(vz1,ci_perc=68.4,ci_mean=True,ci_std=True)[1])
    loca.append(len(ind1))
  return locdisp,loca
コード例 #2
0
ファイル: grh_Siglos.py プロジェクト: sofiasi/darcoda
 def foo_pool(k):
     Rsi  = gpr.Rerror  * np.random.randn(len(Rs))+Rs
     vzsi = gpr.vrerror * np.random.randn(len(vzs))+vzs
     locdisp=[]; loca = []
     for b in range(gpr.bins):
         ind1 = np.argwhere( np.logical_and(Rsi > Binmin[b],\
                                            Rsi <= Binmax[b])).flatten()
         vz1  = vzsi[ind1]
         locdisp.append(meanbiweight(vz1,\
                                     ci_perc=68.4,ci_mean=True,\
                                     ci_std=True)[1])
         loca.append(len(ind1))
     return locdisp,loca
コード例 #3
0
ファイル: grt_siglos.py プロジェクト: hasanmoudud/darcoda
def run(gp):
    import gr_params
    gpr = gr_params.grParams(gp)

    for pop in range(2):
        # get radius, used for all binning
        print('input: ', gp.files.get_com_file(pop))
        if gf.bufcount(gp.files.get_com_file(pop))<2:
            return
        x,y,vlos = np.loadtxt(gp.files.get_com_file(pop), skiprows=1, unpack=True) #2*[rscale], [km/s]
        # totmass_tracers = 1.*len(x)  # [Munit], [Munit], where each star is weighted with the same mass
        r = np.sqrt(x*x+y*y) # [rscale]

        #set binning
        #gp.nipol = (max - min)*N^(1/3)/(2*(Q3-Q1)) #(method of wand)
        rmin = 0.                                       # [rscale]
        rmax = max(r) if gp.maxR < 0 else 1.0*gp.maxR # [rscale]

        binmin, binmax, rbin = gh.determine_radius(r, rmin, rmax, gp) # [rscale0]

        # offset from the start!
        rs = gpr.Rerr*np.random.randn(len(r))+r #[rscale]
        vlos = gpr.vrerr*np.random.randn(len(vlos))+vlos #[km/s]
        vfil = open(gp.files.sigfiles[pop], 'w')
        print('r', 'sigma_r(r)', 'error', file=vfil)

        # 30 iterations for drawing a given radius in bin
        dispvelocity = np.zeros((gp.nipol,gpr.n))
        a = np.zeros((gp.nipol,gpr.n))
        p_dvlos = np.zeros(gp.nipol)
        p_edvlos = np.zeros(gp.nipol)

        for k in range(gpr.n):
            rsi = gpr.Rerr*np.random.randn(len(rs))+rs #[rscale]
            vlosi = gpr.vrerr*np.random.randn(len(vlos))+vlos #[km/s]
            for i in range(gp.nipol):
                ind1 = np.argwhere(np.logical_and(rsi>binmin[i],rsi<binmax[i])).flatten()
                a[i][k] = len(ind1) #[1]
                vlos1 = vlosi[ind1] #[km/s]
                if(len(ind1)<=1):
                    dispvelocity[i][k] = dispvelocity[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

        for i in range(gp.nipol):
            dispvel = np.sum(dispvelocity[i])/gpr.n #[km/s]
            ab = np.sum(a[i])/(1.*gpr.n) #[1]
            if ab == 0:
                dispvelerr = p_edvlos[i-1] #[km/s]
                # attention! uses last error
            else:
                dispvelerr = dispvel/np.sqrt(ab) #[km/s]
            p_dvlos[i] = dispvel      #[km/s]
            p_edvlos[i]= dispvelerr #[km/s]

        maxsiglos = max(p_dvlos) #[km/s]
        print('maxsiglos = ',maxsiglos,'[km/s]')
        fpars = open(gp.files.get_scale_file(pop),'a')
        print(maxsiglos, file=fpars)          #[km/s]
        fpars.close()
        #import shutil
        #shutil.copy2(gp.files.get_scale_file(0), gp.files.get_scale_file(1))

        for i in range(gp.nipol):
            #             [rscale]  [maxsiglos]                  [maxsiglos]
            print(rbin[i], binmin[i], binmax[i], np.abs(p_dvlos[i]/maxsiglos),np.abs(p_edvlos[i]/maxsiglos), file=vfil) #/np.sqrt(n))
        vfil.close()
コード例 #4
0
ファイル: grh_MCMCbin.py プロジェクト: sofiasi/darcoda
def run():
    # determine radius once and for all from all tracers
    R, Phi, vzall = np.loadtxt(gpr.fileposspherical[0],
                               comments='#',unpack=True) # 2*[Rscale], [km/s]
    # 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)                   # [Rscale]
    R = R[(R<=Rmax)]                                  # [Rscale]

    # 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:
        Binmin, Binmax, Rbin = bin_r_log(Rmax/gpr.nbins, Rmax, gpr.nbins)
        print(gpr.nbins,' bins in log spacings')
    elif gp.consttr:
        Binmin, Binmax, Rbin = bin_r_const_tracers(R, len(R)/gpr.nbins)
        print(len(R)/gpr.nbins,' particles per bin')
    else:
        Binmin, Binmax, Rbin = bin_r_linear(Rmin, Rmax, gpr.nbins)
        print(gpr.nbins, ' bins in linear spacings')


    # 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('grh_MCMCbin: input: ',gpr.fileposspherical[comp])
        # start from data centered on COM already:
        if gfile.bufcount(gpr.fileposspherical[comp])<2: continue
        R, Phi, v = np.loadtxt(gpr.fileposspherical[comp],\
                               comments='#',unpack=True)
                               # [Rscale], [1], [km/s]
        
        # 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)
        R = R[sel]; v = v[sel] # [Rscale], [km/s]
        totmass = 1.*len(R) # [munit], munit = 1/star
            
        Rs = R                   # + possible starting offset, [Rscale]
        vlos = v                 # + possible starting offset, [km/s]
        
        print('grh_MCMCbin: output density: ')
        print(gpr.get_ntracer_file(comp))
        tr = open(gpr.get_ntracer_file(comp),'w')
        print(totmass, file=tr)
        tr.close()

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

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


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


        print('grh_MCMCbin: output kurtosis: ',gpr.filekappa[comp])
        kappafil = open(gpr.filekappa[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))
        # 'a' 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='#', unpack=False) # [pc]
        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()

        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]
                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], [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]
        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):
            #     [Rscale] [Rscale]  [Rscale]   [maxvlos]                  [maxvlos]
            print(Rbin[b],Binmin[b],Binmax[b], np.abs(p_dvlos[b]/maxvlos),np.abs(p_edvlos[b]/maxvlos), file=sigfil)
            # 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) # 3*[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,'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(comp))
        # from gl_analytic import Sigma_anf
        # plot(Rbin, Sigma_anf(Rbin*Rscale))  # Sigma_anf argument in [pc] !

        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([0.,1.5*max(p_dvlos)])
        xlim([0,3])
        savefig(gpr.get_siglos_png(comp))
        # from gl_analytic import sig_los_anf
        # plot(Rbin,sig_los_anf(Rbin*Rscale)) # argument must be [pc] !

        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,3])
        savefig(gpr.get_kurtosis_png(comp))
        ioff();show();clf()
コード例 #5
0
ファイル: grw_siglos.py プロジェクト: sofiasi/darcoda
def run():
    xall,yall = np.loadtxt(gpr.get_com_file(0),skiprows=1,usecols=(0,1),unpack=True) # 2*[rcore]
    # calculate 2D radius on the skyplane
    r = np.sqrt(xall**2+yall**2) #[rcore]
    # set number and size of (linearly spaced) bins
    rmin = 0. #[rcore]
    rmax = max(r) if gpr.rprior<0 else 1.0*gpr.rprior #[rcore]
    print 'rmax [rcore] = ', rmax
    r = r[(r<rmax)]

    # determine radius once and for all
    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) # [rcore^2]


    for comp in range(gpr.ncomp):
        print 'comp = ',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,vlos = np.loadtxt(gpr.get_com_file(comp),\
                              skiprows=1,usecols=(0,1,2),unpack=True) #[rcore], [rcore], [km/s]

        # calculate 2D radius on the skyplane
        r = np.sqrt(x**2+y**2) #[rcore]
        
        # set maximum radius (if gpr.rprior is set)
        rmax = max(r) if gpr.rprior<0 else 1.0*gpr.rprior #[rcore]
        print 'rmax [rcore] = ', rmax
        sel = (r<=rmax)
        x = x[sel]; y = y[sel]; vlos = vlos[sel]; r = r[sel] #[rcore]
        totmass = 1.*len(x) #[munit], munit = 1/star

        rs = r
        # no offset from the start!
        # rs = gpr.rerror*np.random.randn(len(r))+r #[rcore]
        # vlos = gpr.vrerror*np.random.randn(len(vlos))+vlos #[km/s]



        print 'output: ',gpr.get_siglos_file(comp)
        vfil = open(gpr.get_siglos_file(comp),'w')
        print >> vfil,'r','sigma_r(r)','error'

        # 30 iterations for drawing a given radius in bin
        dispvelocity = np.zeros((gpr.nbins,gpr.n))
        a = np.zeros((gpr.nbins,gpr.n))
        p_dvlos = np.zeros(gpr.nbins)
        p_edvlos = np.zeros(gpr.nbins)

        for k in range(gpr.n):
            rsi = gpr.rerror*np.random.randn(len(rs))+rs #[rcore]
            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()
                a[i][k] = len(ind1) #[1]
                vlos1 = vlosi[ind1] #[km/s]
                if(len(ind1)<=1):
                    dispvelocity[i][k] = dispvelocity[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

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

        maxvlos = max(p_dvlos) #[km/s]
        print 'maxvlos = ',maxvlos,'[km/s]'
        fpars = open(gpr.get_params_file(comp),'a')
        print >> fpars,maxvlos          #[km/s]
        fpars.close()

        for i in range(gpr.nbins):
            #             [rcore]  [maxvlos]                  [maxvlos]
            print >> vfil,rbin[i], np.abs(p_dvlos[i]/maxvlos),np.abs(p_edvlos[i]/maxvlos) #/np.sqrt(n))
        vfil.close()

        if not gp.testplot_read: continue

        ion(); subplot(111)
        print 'rbin = ',rbin,' rcore'
        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') #[rcore],[km/s],[km/s]

        xlabel(r'$r [\mathrm{rcore}]$')
        ylabel(r'$\langle\sigma_{\mathrm{LOS}}\rangle [\mathrm{km/s}]$')
        ylim([-5,30])
        # xscale('log')
        xlim([np.min(rbin),np.max(rbin)])
        #plt.legend(['\rho','\rho'],'lower left'); #title(dwarf)
        savefig(gpr.get_siglos_png(comp))
        if gpr.showplots:
            ioff();show();clf()
コード例 #6
0
ファイル: gr_MCMCbin.py プロジェクト: PascalSteger/darcoda
def run(gp):
    import gr_params
    gpr = gr_params.grParams(gp)
    xall,yall = np.loadtxt(gp.files.get_com_file(0), skiprows=1, usecols=(0,1), unpack=True)
    # 2*[Rscale0]
    R = np.sqrt(xall**2+yall**2) # [Rscale0]
    # set number and size of (linearly spaced) bins
    Rmin = 0. #[Rscale0]
    Rmax = max(R) if gp.maxR < 0 else 1.0*gp.maxR # [Rscale0]
    R = R[(R<Rmax)] # [Rscale0]
    Binmin, Binmax, Rbin = gh.determine_radius(R, Rmin, Rmax, gp) # [Rscale0]
    gp.xipol = Rbin
    minr = min(Rbin) # [pc]
    maxr = max(Rbin) # [pc]
    gp.xepol = np.hstack([minr/8., minr/4., minr/2., Rbin, 2*maxr, 4*maxr, 8*maxr]) # [pc]
    Vol = gh.volume_circular_ring(Binmin, Binmax, gp) # [Rscale0^2]
    Rscale0 = gf.read_Xscale(gp.files.get_scale_file(0)) # [pc]
    for pop in range(gp.pops+1):
        print('#######  working on component ',pop)
        print('input: ', gp.files.get_com_file(pop))
        # exclude second condition if self-consistent approach wished
        if gp.investigate == "obs" and gp.case==1 and pop==0:
            # for Fornax, overwrite first Sigma with deBoer data
            import gr_MCMCbin_for
            gr_MCMCbin_for.run(gp)
            continue
        # start from data centered on COM already:
        if gf.bufcount(gp.files.get_com_file(pop))<2:
            continue
        # only read in data if needed: pops = 1: reuse data from pop=0 part
        if (gp.pops == 1 and pop < 1 or gp.pops == 2) or gp.investigate == 'obs':
            x,y,v = np.loadtxt(gp.files.get_com_file(pop), skiprows=1,usecols=(0,1,2),unpack=True)
            # [Rscalei], [Rscalei], [km/s]
            # calculate 2D radius on the skyplane
            R = np.sqrt(x**2+y**2) #[Rscalei]
            Rscalei = gf.read_Xscale(gp.files.get_scale_file(pop)) # [pc]
            # set maximum radius (if gp.maxR is set)
            Rmax = max(R) if gp.maxR<0 else 1.0*gp.maxR # [Rscale0]
            print('Rmax [Rscale0] = ', Rmax)
            #pdb.set_trace()
            #from pylab import clf, hist, axvline, xlim
            #clf()
            #hist(np.log10(R*Rscalei), 40)
            #for i in range(len(Rbin)):
            #    axvline(np.log10(Rbin[i]*Rscale0))
            #xlim([np.log10(min(gp.xepol*Rscale0)), np.log10(max(gp.xepol*Rscale0))])
            sel = (R * Rscalei <= Rmax * Rscale0)
            x = x[sel]
            y = y[sel]
            v = v[sel]
            R = R[sel] # [Rscalei]
            totmass_tracers = float(len(x)) # [Munit], Munit = 1/star
            Rs = R                   # + possible starting offset, [Rscalei]
            vlos = v                 # + possible starting offset, [km/s]
        tr = open(gp.files.get_ntracer_file(pop),'w')
        print(totmass_tracers, file=tr)
        tr.close()
        f_Sig, f_nu, f_mass, f_sig, f_kap, f_zeta = gf.write_headers_2D(gp, pop)
        if (gp.pops == 1 and pop < 1) or gp.pops == 2 or gp.investigate == 'obs':
            Sig_kin   = np.zeros((gp.nipol, gpr.n))
            siglos    = np.zeros((gp.nipol, gpr.n))
            if gp.usekappa:
                kappa     = np.zeros((gp.nipol, gpr.n))
            if gp.usezeta:
                v2        = np.zeros((gp.nipol, gpr.n))
                v4        = np.zeros((gp.nipol, gpr.n))
                Ntot      = np.zeros(gpr.n)
                zetaa     = np.zeros(gpr.n)
                zetab     = np.zeros(gpr.n)
            # particle selections, shared by density, siglos, kappa and zeta calculations
            tpb       = np.zeros((gp.nipol,gpr.n))
            for k in range(gpr.n):
                Rsi   = gh.add_errors(Rs,   gpr.Rerr)   # [Rscalei]
                vlosi = gh.add_errors(vlos, gpr.vrerr)   # [km/s]
                for i in range(gp.nipol):
                    ind1 = np.argwhere(np.logical_and(Rsi * Rscalei >= Binmin[i] * Rscale0, Rsi * Rscalei <  Binmax[i] * Rscale0)).flatten() # [1]
                    tpb[i][k] = float(len(ind1)) # [1]
                    Sig_kin[i][k] = float(len(ind1))*totmass_tracers/Vol[i] # [Munit/rscale**2]
                    if(len(ind1)<=1):
                        siglos[i][k] = siglos[i-1][k]
                        print('### using last value, missing data')
                        if gp.usekappa:
                            kappa[i][k] = kappa[i-1][k]
                            # attention! should be 0, uses last value
                        if gp.usezeta:
                            v2[i][k] = v2[i-1][k]
                            v4[i][k] = v4[i-1][k]
                    else:
                        siglos[i][k] = meanbiweight(vlosi[ind1], ci_perc=68.4, \
                                                    ci_mean=True, ci_std=True)[1]
                        # [km/s], see BiWeight.py
                        if gp.usekappa:
                            kappa[i][k] = kurtosis(vlosi[ind1], axis=0, \
                                                   fisher=False, bias=False) # [1]
                        if gp.usezeta:
                            ave, adev, sdev, var, skew, curt = gh.moments(vlosi[ind1])
                            v2[i][k] = var
                            v4[i][k] = (curt+3)*var**2
                Sigma = Sig_kin[:,k]
                if gp.usezeta:
                    pdb.set_trace()
                    Ntot[k] = gh.Ntot(Rbin, Sigma, gp)
                    zetaa[k] = gh.starred(Rbin, v4[:,k], Sigma, Ntot[k], gp)
                    v2denom = (gh.starred(Rbin, v2[:,k], Sigma, Ntot[k], gp))**2
                    zetaa[k] /= v2denom
                    zetab[k] = gh.starred(Rbin, v4[:,k]*Rbin**2, Sigma, Ntot[k], gp)
                    zetab[k] /= v2denom
                    zetab[k] /= (gh.starred(Rbin, Rbin, Sigma, Ntot[k], gp))**2
            if gp.investigate == 'obs' and gp.case < 5:
                Sig_phot = obs_Sig_phot(Binmin, Binmax, Rscale0, Sig_kin, gp, gpr)
            else:
                Sig_phot = Sig_kin
        # do the following for all populations
        Sig0 = np.sum(Sig_phot[0])/float(gpr.n) # [Munit/Rscale^2]
        Sig0pc = Sig0/Rscale0**2              # [munis/pc^2]
        gf.write_Sig_scale(gp.files.get_scale_file(pop), Sig0pc, totmass_tracers)

        # calculate density and mass profile, store it
        # ----------------------------------------------------------------------
        #tpb0   = np.sum(tpb[0])/float(gpr.n)     # [1]
        #Sigerr0 = Sig0/np.sqrt(tpb0)       # [Munit/Rscale^2]
        P_dens  = np.zeros(gp.nipol)
        P_edens = np.zeros(gp.nipol)
        for b in range(gp.nipol):
            Sig = np.sum(Sig_kin[b])/(1.*gpr.n) # [Munit/Rscale^2]
            tpbb   = np.sum(tpb[b])/float(gpr.n)       # [1], mean number of tracers in bin
            Sigerr = Sig/np.sqrt(tpbb)       # [Munit/Rscale^2], Poissonian error
            # compare data and analytic profile <=> get stellar
            # density or mass ratio from Matt Walker
            if(np.isnan(Sigerr)):
                P_dens[b] = P_dens[b-1]  # [1]
                P_edens[b]= P_edens[b-1] # [1]
            else:
                P_dens[b] = Sig/Sig0   # [1]
                P_edens[b]= Sigerr/Sig0 # [1]
            print(Rbin[b], Binmin[b], Binmax[b], P_dens[b], P_edens[b], file=f_Sig)
            # 3*[rscale], [dens0], [dens0]
            indr = (R<Binmax[b])
            Menclosed = float(np.sum(indr))/totmass_tracers # for normalization to 1#[totmass_tracers]
            Merr = Menclosed/np.sqrt(tpbb) # or artificial Menclosed/10 #[totmass_tracers]
            print(Rbin[b], Binmin[b], Binmax[b], Menclosed, Merr, file=f_mass) # [Rscale0], 2* [totmass_tracers]
        f_Sig.close()
        f_mass.close()
        # deproject Sig to get nu
        numedi = gip.Sig_INT_rho(Rbin*Rscalei, Sig0pc*P_dens, gp)
        #numin  = gip.Sig_INT_rho(Rbin*Rscalei, Sig0pc*(P_dens-P_edens), gp)
        numax  = gip.Sig_INT_rho(Rbin*Rscalei, Sig0pc*(P_dens+P_edens), gp)
        nu0pc  = numedi[0]
        gf.write_nu_scale(gp.files.get_scale_file(pop), nu0pc)
        nuerr  = numax-numedi
        for b in range(gp.nipol):
            print(Rbin[b], Binmin[b], Binmax[b], numedi[b]/nu0pc, nuerr[b]/nu0pc, file = f_nu)
        f_nu.close()
        # calculate and output siglos
        # --------------------------------------------
        p_dvlos = np.zeros(gp.nipol)
        p_edvlos = np.zeros(gp.nipol)
        for b in range(gp.nipol):
            sig = np.sum(siglos[b])/gpr.n #[km/s]
            tpbb = np.sum(tpb[b])/float(gpr.n) #[1]
            if tpbb == 0:
                sigerr = p_edvlos[b-1] #[km/s]
                # attention! uses last error
            else:
                # Poisson error with measurement errors
                #sigerr = sig/np.sqrt(tpbb)
                #sigerr = np.sqrt(sigerr**2+2**2) # 2km/s

                # standard deviation
                #sigerr = stddevbiweight(siglos[b])

                # Poisson error, first guess
                sigerr = sig/np.sqrt(tpbb) #[km/s]
            p_dvlos[b] = sig    #[km/s]
            p_edvlos[b]= sigerr #[km/s]
        maxsiglos = max(p_dvlos) #[km/s]
        print('maxsiglos = ', maxsiglos, '[km/s]')
        fpars = open(gp.files.get_scale_file(pop),'a')
        print(maxsiglos, file=fpars)          #[km/s]
        fpars.close()
        for b in range(gp.nipol):
            print(Rbin[b], Binmin[b], Binmax[b], np.abs(p_dvlos[b]/maxsiglos),\
                  np.abs(p_edvlos[b]/maxsiglos), file=f_sig)
            # 3*[rscale], 2*[maxsiglos]
        f_sig.close()
        # calculate and output kurtosis kappa
        # --------------------------------------------
        if gp.usekappa:
            p_kappa = np.zeros(gp.nipol) # needed for plotting later
            p_ekappa = np.zeros(gp.nipol)
            for b in range(gp.nipol):
                kappavel = np.sum(kappa[b])/gpr.n #[1]
                tpbb = np.sum(tpb[b])/float(gpr.n) #[1]
                if tpbb == 0:
                    kappavelerr = p_edvlos[b-1] #[1]
                    # attention! uses last error
                else:
                    kappavelerr = np.abs(kappavel/np.sqrt(tpbb)) #[1]
                p_kappa[b] = kappavel
                p_ekappa[b] = kappavelerr
                print(Rbin[b], Binmin[b], Binmax[b], \
                      kappavel, kappavelerr, file=f_kap)
                # [rscale], 2*[1]
            f_kap.close()
        # output zetas
        # -------------------------------------------------------------
        if gp.usezeta:
            print(np.median(zetaa), np.median(zetab), file=f_zeta)
            f_zeta.close()
        if gpr.showplots:
            gpr.show_plots_dens_2D(Rbin*Rscalei, P_dens, P_edens, Sig0pc)
            gpr.show_plots_sigma(Rbin*Rscalei, p_dvlos, p_edvlos)
            if gp.usekappa:
                gpr.show_plots_kappa(Rbin*Rscalei, p_kappa, p_ekappa)

        # overwrite Sig profile if photometric data is used
        if gp.investigate == 'obs' and gp.case==1 and pop==1 and not gp.selfconsistentnu:
            import os
            os.system('cp '+gp.files.get_scale_file(0)+' '+gp.files.get_scale_file(1))
            # replace last line with actual maxsiglos from tracer particles
            os.system("sed -i '$s/^.*/"+str(maxsiglos)+"/' "+gp.files.get_scale_file(1))
            os.system('cp '+gp.files.Sigfiles[0]+' '+gp.files.Sigfiles[1])
            continue
コード例 #7
0
ファイル: grt_siglos.py プロジェクト: sofiasi/darcoda
def run():
    # get radius, used for all binning
    print('input:')
    print(gpr.get_com_file(0))
    if gfile.bufcount(gpr.get_com_file(0))<2: return
    x,y,vlos = np.loadtxt(gpr.get_com_file(0), skiprows=1, unpack=True) #2*[rscale], [km/s]
    totmass = 1.*len(x)  # [munit], [Msun], where each star is weighted with the same mass
    r = np.sqrt(x*x+y*y) # [rscale]
    
    #set binning
    #gpr.nbins = (max - min)*N^(1/3)/(2*(Q3-Q1)) #(method of wand)
    rmin = 0.                                       # [rscale]
    rmax = max(r) if gpr.rprior<0 else 1.0*gpr.rprior # [rscale]
    
    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)
        
    # offset from the start!
    rs = gpr.rerror*np.random.randn(len(r))+r #[rscale]
    vlos = gpr.vrerror*np.random.randn(len(vlos))+vlos #[km/s]
    print('output: ',gpr.get_siglos_file(0))
    vfil = open(gpr.get_siglos_file(0),'w')
    print('r','sigma_r(r)','error', file=vfil)

    # 30 iterations for drawing a given radius in bin
    dispvelocity = np.zeros((gpr.nbins,gpr.n))
    a = np.zeros((gpr.nbins,gpr.n))
    p_dvlos = np.zeros(gpr.nbins)
    p_edvlos = np.zeros(gpr.nbins)
    
    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()
            a[i][k] = len(ind1) #[1]
            vlos1 = vlosi[ind1] #[km/s]
            if(len(ind1)<=1):
                dispvelocity[i][k] = dispvelocity[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
                
    for i in range(gpr.nbins):
        dispvel = np.sum(dispvelocity[i])/gpr.n #[km/s]
        ab = np.sum(a[i])/(1.*gpr.n) #[1]
        if ab == 0:
            dispvelerror = p_edvlos[i-1] #[km/s]
            # attention! uses last error
        else:
            dispvelerror = dispvel/np.sqrt(ab) #[km/s]
        p_dvlos[i] = dispvel      #[km/s]
        p_edvlos[i]= dispvelerror #[km/s]

    maxvlos = max(p_dvlos) #[km/s]
    print('maxvlos = ',maxvlos,'[km/s]')
    fpars = open(gpr.get_params_file(0),'a')
    print(maxvlos, file=fpars)          #[km/s]
    fpars.close()
    import shutil
    shutil.copy2(gpr.get_params_file(0), gpr.get_params_file(1))


    for i in range(gpr.nbins):
        #             [rscale]  [maxvlos]                  [maxvlos]
        print(rbin[i], np.abs(p_dvlos[i]/maxvlos),np.abs(p_edvlos[i]/maxvlos), file=vfil) #/np.sqrt(n))
    vfil.close()

    if not gpr.showplots: return

    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',linewidth=3)
    fill_between(rbin,p_dvlos-p_edvlos,p_dvlos+p_edvlos,alpha=0.5,color='r') #[rscale],[km/s],[km/s]

    xlabel(r'$r [rscale]$')
    ylabel(r'$\langle\sigma_{LOS}\rangle [km/s]$')
    ylim([-5,30])
    # xscale('log')
    xlim([np.min(rbin),np.max(rbin)])
    #plt.legend(['\rho','\rho'],'lower left'); #title(dwarf)
    savefig(gpr.get_siglos_png(0))
    if gpr.showplots:
        ioff();show();clf()
コード例 #8
0
ファイル: velocitydispersion.py プロジェクト: sofiasi/darcoda
dispvelocity=numpy.zeros((bins,n))
a=numpy.zeros((bins,n))
p_dvlos = numpy.zeros(bins)
p_edvlos= numpy.zeros(bins)

for k in range(n):
    rsi = rerror*numpy.random.randn(len(rs))+rs
    vlosi = vrerror*numpy.random.randn(len(vlos))+vlos
    for i in range(bins):
        ind1 = numpy.argwhere(numpy.logical_and(rsi>binmin[i],rsi<binmax[i])).flatten()
        a[i][k] = 1.*len(ind1)
        vlos1 = vlosi[ind1]
        if(len(ind1)<=1):
            dispvelocity[i][k] = 0.
        else:
            dispvelocity[i][k] = meanbiweight(vlos1,ci_perc=68.4,ci_mean=True,ci_std=True)[1]

for i in range(bins):
    dispvel = 1.*numpy.sum(dispvelocity[i])/n
    ab = 1.*numpy.sum(a[i])/n
    if(ab == 0):
        dispvelerror = 0.0
    else:
        dispvelerror = dispvel/numpy.sqrt(ab)
    p_dvlos[i]  = dispvel
    p_edvlos[i] = dispvelerror

maxvlos = max(p_dvlos)
d=open(dir+dwarf+'/velocitydispersionlos.txt','a')
for i in range(bins):
    print(rbin[i],p_dvlos[i],p_edvlos[i], file=d)