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
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
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()
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()
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()
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
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()
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)