def calc_aA_sim(RvR,filename,snap_gc): # Calculate the action angle variables for a simulation and store if not os.path.exists(filename): aAI= actionAngleIsochroneApprox(pot=lp,b=0.8) nbatch= 20 multiOut= multi.parallel_map(\ lambda x: aAI.actionsFreqsAngles(RvR[x*nbatch:(x+1)*nbatch,0]/R0, RvR[x*nbatch:(x+1)*nbatch,1]/V0, RvR[x*nbatch:(x+1)*nbatch,2]/V0, RvR[x*nbatch:(x+1)*nbatch,3]/R0, RvR[x*nbatch:(x+1)*nbatch,4]/V0, RvR[x*nbatch:(x+1)*nbatch,5]), range(len(snap_gc)//nbatch), numcores=25) acfs= numpy.reshape(numpy.swapaxes(numpy.array(multiOut),0,1), (9,numpy.prod(numpy.array(multiOut).shape)//9)) # Write to file csvfile= open(filename,'w') writer= csv.writer(csvfile,delimiter=',') for jj in range(len(acfs[0])): writer.writerow([acfs[0][jj],acfs[1][jj],acfs[2][jj], acfs[3][jj],acfs[4][jj],acfs[5][jj], acfs[6][jj],acfs[7][jj],acfs[8][jj]]) csvfile.flush() csvfile.close() else: acfs= numpy.loadtxt(filename,delimiter=',').T return acfs
def calc_aA_sim(RvR, filename, snap_gc): # Calculate the action angle variables for a simulation and store if not os.path.exists(filename): aAI = actionAngleIsochroneApprox(pot=lp, b=0.8) nbatch = 20 multiOut= multi.parallel_map(\ lambda x: aAI.actionsFreqsAngles(RvR[x*nbatch:(x+1)*nbatch,0]/R0, RvR[x*nbatch:(x+1)*nbatch,1]/V0, RvR[x*nbatch:(x+1)*nbatch,2]/V0, RvR[x*nbatch:(x+1)*nbatch,3]/R0, RvR[x*nbatch:(x+1)*nbatch,4]/V0, RvR[x*nbatch:(x+1)*nbatch,5]), range(len(snap_gc)//nbatch), numcores=25) acfs = numpy.reshape(numpy.swapaxes(numpy.array(multiOut), 0, 1), (9, numpy.prod(numpy.array(multiOut).shape) // 9)) # Write to file csvfile = open(filename, 'w') writer = csv.writer(csvfile, delimiter=',') for jj in range(len(acfs[0])): writer.writerow([ acfs[0][jj], acfs[1][jj], acfs[2][jj], acfs[3][jj], acfs[4][jj], acfs[5][jj], acfs[6][jj], acfs[7][jj], acfs[8][jj] ]) csvfile.flush() csvfile.close() else: acfs = numpy.loadtxt(filename, delimiter=',').T return acfs
def plotCombinedPDF(options,args): if options.sample.lower() == 'g': npops= 62 elif options.sample.lower() == 'k': npops= 54 if options.sample.lower() == 'g': savefile= open('binmapping_g.sav','rb') elif options.sample.lower() == 'k': savefile= open('binmapping_k.sav','rb') fehs= pickle.load(savefile) afes= pickle.load(savefile) savefile.close() #First calculate the derivative properties if not options.group is None: gafes, gfehs, legend= getMultiComparisonBins(options) else: legend= None if not options.multi is None: PDFs= multi.parallel_map((lambda x: calcAllPDFs(x,options,args)), range(npops), numcores=numpy.amin([options.multi, npops, multiprocessing.cpu_count()])) else: PDFs= [] for ii in range(npops): PDFs.append(calcAllPDFs(ii,options,args)) #Go through and combine combined_lnpdf= numpy.zeros((options.nrds,options.nfhs)) for ii in range(npops): if not options.group is None: if numpy.amin((gfehs-fehs[ii])**2./0.1+(gafes-afes[ii])**2./0.0025) > 0.001: continue combined_lnpdf+= PDFs[ii] alogl= combined_lnpdf-numpy.nanmax(combined_lnpdf) #Now plot bovy_plot.bovy_print() bovy_plot.bovy_dens2d(numpy.exp(alogl).T, origin='lower',cmap='gist_yarg', interpolation='nearest', xrange=[1.9,3.5],yrange=[-1./32.,1.+1./32.], xlabel=r'$R_d\ (\mathrm{kpc})$',ylabel=r'$f_h$') if not legend is None: bovy_plot.bovy_text(legend,top_left=True, size=14.) bovy_plot.bovy_end_print(options.outfilename) #Calculate and print derived properties derivProps= rawDerived(alogl,options, vo=options.fixvc/_REFV0,zh=options.fixzh, dlnvcdlnr=options.dlnvcdlnr) for key in derivProps.keys(): if not '_err' in key: print key, derivProps[key], derivProps[key+'_err'], \ derivProps[key]/derivProps[key+'_err'] return None
def calc_avg_rcmks(parser): options,args= parser.parse_args() njks= 101 nmks= 101 jks= numpy.linspace(0.5,0.8,njks) mks= numpy.linspace(-0.5,-3.,nmks) if options.basti: zs= numpy.array([0.004,0.008,0.01,0.0198,0.03,0.04]) zsolar= 0.019 elif options.parsec: zs= numpy.arange(0.0005,0.06005,0.0005) # zs= numpy.array([0.01,0.02]) zsolar= 0.019 else: zs= numpy.arange(0.0005,0.03005,0.0005) # zs= numpy.array([0.01,0.02]) zsolar= 0.019 if not os.path.exists(options.outfilename): logpz= localzdist(zs,zsolar=zsolar) logmkp= numpy.zeros((len(zs),njks,nmks)) logp= numpy.zeros((len(zs),njks,nmks)) funcargs= (zs,options,njks,jks,nmks,mks,logpz) multOut= multi.parallel_map((lambda x: indiv_calc(x, *funcargs)), range(len(zs)), numcores=numpy.amin([64,len(zs), multiprocessing.cpu_count()])) for ii in range(len(zs)): logmkp[ii,:,:]= multOut[ii][0,:,:] logp[ii,:,:]= multOut[ii][1,:,:] save_pickles(options.outfilename,logmkp,logp) else: savefile= open(options.outfilename,'rb') logmkp= pickle.load(savefile) logp= pickle.load(savefile) savefile.close() indx= numpy.isnan(logp) logp[indx]= -numpy.finfo(numpy.dtype(numpy.float64)).max logmkp[indx]= -numpy.finfo(numpy.dtype(numpy.float64)).max #Average the peak, so calculate the peak for ii in range(len(zs)): for jj in range(njks): maxmkindx= numpy.argmax(logp[ii,jj,:]) totlogp= maxentropy.logsumexp(logp[ii,jj,:]) logmkp[ii,jj,:]= logmkp[ii,jj,maxmkindx]-logp[ii,jj,maxmkindx]+totlogp logp[ii,jj,:]= totlogp avgmk= numpy.exp(maxentropy.logsumexp(logmkp.flatten())\ -maxentropy.logsumexp(logp.flatten())) solindx= numpy.argmin(numpy.fabs(zs-0.017)) avgmksolar= numpy.exp(maxentropy.logsumexp(logmkp[solindx,:,:].flatten())\ -maxentropy.logsumexp(logp[solindx,:,:].flatten())) print "Average mk: %f" % (-avgmk) print "Average mk if solar: %f" % (-avgmksolar) return -avgmk
def calc_effsel(args,options,sample=None): # Work-horse function to compute the effective selection function, # sample is a data sample of stars to consider for the (JK,Z) sampling # Setup selection function selectFile= '../savs/selfunc-nospdata.sav' if os.path.exists(selectFile): with open(selectFile,'rb') as savefile: apo= pickle.load(savefile) else: # Setup selection function apo= apogee.select.apogeeSelect() # Delete these because they're big and we don't need them del apo._specdata del apo._photdata save_pickles(selectFile,apo) # Get the full data sample for the locations (need all locations where # stars could be observed, so the whole sample, not just the subsample # being analyzed) data= get_rcsample() locations= list(set(list(data['LOCATION_ID']))) # Load the dust map and setup the effective selection function if options.dmap.lower() == 'green15': dmap3d= mwdust.Green15(filter='2MASS H') elif options.dmap.lower() == 'marshall06': dmap3d= mwdust.Marshall06(filter='2MASS H') elif options.dmap.lower() == 'drimmel03': dmap3d= mwdust.Drimmel03(filter='2MASS H') elif options.dmap.lower() == 'sale14': dmap3d= mwdust.Sale14(filter='2MASS H') elif options.dmap.lower() == 'zero': dmap3d= mwdust.Zero(filter='2MASS H') # Sample the M_H distribution if options.samplemh: if sample is None: sample= data MH= sample['H0']-sample['RC_DM'] MH= numpy.random.permutation(MH)[:1000] # do 1,000 max else: MH= -1.49 apof= apogee.select.apogeeEffectiveSelect(apo,dmap3d=dmap3d,MH=MH) # Distances at which to calculate the effective selection function distmods= numpy.linspace(options.dm_min,options.dm_max,options.ndm) ds= 10.**(distmods/5-2.) # Now compute all selection functions out= multi.parallel_map((lambda x: _calc_effsel_onelocation(\ locations[x],apof,apo,ds)), range(len(locations)), numcores=numpy.amin([len(locations), multiprocessing.cpu_count(),options.multi])) # Save out out= numpy.array(out) save_pickles(args[0],locations,out,distmods,ds) return None
def calc_effsel(args, options, sample=None): # Work-horse function to compute the effective selection function, # sample is a data sample of stars to consider for the (JK,Z) sampling # Setup selection function selectFile = '../savs/selfunc-nospdata.sav' if os.path.exists(selectFile): with open(selectFile, 'rb') as savefile: apo = pickle.load(savefile) else: # Setup selection function apo = apogee.select.apogeeSelect() # Delete these because they're big and we don't need them del apo._specdata del apo._photdata save_pickles(selectFile, apo) # Get the full data sample for the locations (need all locations where # stars could be observed, so the whole sample, not just the subsample # being analyzed) data = get_rcsample() locations = list(set(list(data['LOCATION_ID']))) # Load the dust map and setup the effective selection function if options.dmap.lower() == 'green15': dmap3d = mwdust.Green15(filter='2MASS H') elif options.dmap.lower() == 'marshall06': dmap3d = mwdust.Marshall06(filter='2MASS H') elif options.dmap.lower() == 'drimmel03': dmap3d = mwdust.Drimmel03(filter='2MASS H') elif options.dmap.lower() == 'sale14': dmap3d = mwdust.Sale14(filter='2MASS H') elif options.dmap.lower() == 'zero': dmap3d = mwdust.Zero(filter='2MASS H') # Sample the M_H distribution if options.samplemh: if sample is None: sample = data MH = sample['H0'] - sample['RC_DM'] MH = numpy.random.permutation(MH)[:1000] # do 1,000 max else: MH = -1.49 apof = apogee.select.apogeeEffectiveSelect(apo, dmap3d=dmap3d, MH=MH) # Distances at which to calculate the effective selection function distmods = numpy.linspace(options.dm_min, options.dm_max, options.ndm) ds = 10.**(distmods / 5 - 2.) # Now compute all selection functions out= multi.parallel_map((lambda x: _calc_effsel_onelocation(\ locations[x],apof,apo,ds)), range(len(locations)), numcores=numpy.amin([len(locations), multiprocessing.cpu_count(),options.multi])) # Save out out = numpy.array(out) save_pickles(args[0], locations, out, distmods, ds) return None
def plot_distanceintegral(savename,plotname,rmcenter=False, onlygreen=False): if os.path.exists(savename): with open(savename,'rb') as savefile: area= pickle.load(savefile) else: # For samping over the absolute magnitude distribution iso= gaia_rc.load_iso() Gsamples= gaia_rc.sample_Gdist(iso,n=_NGSAMPLES) # l and b of the pixels theta, phi= healpy.pixelfunc.pix2ang(_NSIDE, numpy.arange(healpy.pixelfunc.nside2npix(_NSIDE)), nest=False) cosb= numpy.sin(theta) area= multi.parallel_map(lambda x: distanceIntegrand(\ dust._GREEN15DISTS[x],cosb,Gsamples,rmcenter,onlygreen), range(len(dust._GREEN15DISTS)), numcores=numpy.amin([16, len(dust._GREEN15DISTS), multiprocessing.cpu_count()])) save_pickles(savename,area) # Plot the power spectrum if True: psdx, psd= signal.periodogram(area*dust._GREEN15DISTS**3./numpy.sum(area*dust._GREEN15DISTS**3.), fs=1./(dust._GREEN15DISTMODS[1]-dust._GREEN15DISTMODS[0]), detrend=lambda x: x,scaling='spectrum') bovy_plot.bovy_print(fig_height=3.) matplotlib.rcParams['text.latex.preamble']=[r"\usepackage{yfonts}"] bovy_plot.bovy_plot(psdx[1:],psd[1:], 'k-',loglog=True, xlabel=r'$2\pi\,k_\mu\,(\mathrm{mag}^{-1})$', ylabel=r'$P_k$', xrange=[0.04,4.]) bovy_plot.bovy_text(r'$\mathrm{normalized}\ D^3\,\nu_*(\mu|\theta)\,\textswab{S}(\mu)$', bottom_left=True,size=16.) bovy_plot.bovy_end_print(plotname) else: bovy_plot.bovy_print(fig_height=3.) matplotlib.rcParams['text.latex.preamble']=[r"\usepackage{yfonts}"] bovy_plot.bovy_plot(dust._GREEN15DISTMODS, area*dust._GREEN15DISTS**3., 'k-', xlabel=r'$\mu\,(\mathrm{mag}^{-1})$', ylabel=r'$D^3\,\nu_*(\mu|\theta)\,\textswab{S}(\mu)$') bovy_plot.bovy_end_print(plotname) spl= interpolate.InterpolatedUnivariateSpline(dust._GREEN15DISTMODS, area*dust._GREEN15DISTS**3., k=5) fthder= [spl.derivatives(dm)[4] for dm in dust._GREEN15DISTMODS] print "Simpson error= %g, volume= %g" % (0.5**4./180.*numpy.mean(numpy.fabs(fthder))/integrate.simps(area*dust._GREEN15DISTS**3.,dx=0.5),numpy.sum(area*dust._GREEN15DISTS**3.)) return None
def plotRdsz(options,args): #Go through all of the bins if options.sample.lower() == 'g': npops= 62 elif options.sample.lower() == 'k': npops= 30 if not options.multi is None: dummy= multi.parallel_map((lambda x: plotRdsz_single(x,options,args)), range(npops), numcores=numpy.amin([options.multi, npops, multiprocessing.cpu_count()])) else: for ii in range(npops): plotRdsz_single(ii,options,args)
def plot_distanceareaintegral(savename, plotname, rmcenter=False, onlygreen=False): if os.path.exists(savename): with open(savename, 'rb') as savefile: area = pickle.load(savefile) else: # For samping over the absolute magnitude distribution iso = gaia_rc.load_iso() Gsamples = gaia_rc.sample_Gdist(iso, n=_NGSAMPLES) # l and b of the pixels theta, phi = healpy.pixelfunc.pix2ang( _NSIDE, numpy.arange(healpy.pixelfunc.nside2npix(_NSIDE)), nest=False) cosb = numpy.sin(theta) area= multi.parallel_map(lambda x: distanceAreaIntegrand(\ dust._GREEN15DISTS[x],cosb,Gsamples,rmcenter,onlygreen), range(len(dust._GREEN15DISTS)), numcores=numpy.amin([16, len(dust._GREEN15DISTS), multiprocessing.cpu_count()])) save_pickles(savename, area) # Plot the power spectrum area = numpy.array(area) if True: psdthis = ((area.T * dust._GREEN15DISTS**3.).T / numpy.sum( (area.T * dust._GREEN15DISTS**3.), axis=1)) psdx, psd = signal.periodogram( psdthis, fs=1. / (dust._GREEN15DISTMODS[1] - dust._GREEN15DISTMODS[0]), detrend=lambda x: x, scaling='spectrum', axis=0) bovy_plot.bovy_print(fig_height=3.) matplotlib.rcParams['text.latex.preamble'] = [r"\usepackage{yfonts}"] healpy.visufunc.mollview(numpy.log10(psd[-2]), nest=False, xsize=4000, min=-10., max=-3., cmap='gist_yarg', title="") bovy_plot.bovy_end_print(plotname) return None
def plot_pdfs_x(plotfilename): lp= potential.LogarithmicHaloPotential(q=0.9,normalize=1.) aAI= actionAngleIsochroneApprox(b=0.8,pot=lp) obs= numpy.array([1.56148083,0.35081535,-1.15481504, 0.88719443,-0.47713334,0.12019596]) sdft= streamdf(_SIGV/220.,progenitor=Orbit(obs),pot=lp,aA=aAI, leading=False,nTrackChunks=_NTRACKCHUNKS, vsun=[0.,30.24*8.,0.], tdisrupt=4.5/bovy_conversion.time_in_Gyr(220.,8.), multi=_NTRACKCHUNKS) #Calculate the density as a function of l, p(l) txs= numpy.linspace(3.,12.4,_NLS) tlogps= multi.parallel_map((lambda x: sdft.callMarg([txs[x]/8.,None,None,None,None,None], interp=True,ngl=_NGL, nsigma=3)), range(_NLS), numcores=numpy.amin([_NLS, multiprocessing.cpu_count()])) tlogps= numpy.array(tlogps) tlogps[numpy.isnan(tlogps)]= -100000000000000000. tps= numpy.exp(tlogps-logsumexp(tlogps)) tps/= numpy.nansum(tps)*(txs[1]-txs[0]) bovy_plot.bovy_print() bovy_plot.bovy_plot(txs,tps,'k-',lw=1.5, xlabel=r'$X\,(\mathrm{kpc})$', ylabel=r'$p(X)$', xrange=[3.,12.4], yrange=[0.,1.2*numpy.nanmax(tps)]) bovy_plot.bovy_plot(txs,tps,'k-',lw=1.5,overplot=True) #Also plot the stream histogram #Read stream data= numpy.loadtxt(os.path.join(_STREAMSNAPDIR,'gd1_evol_hitres_01312.dat'), delimiter=',') aadata= numpy.loadtxt(os.path.join(_STREAMSNAPAADIR, 'gd1_evol_hitres_aa_01312.dat'), delimiter=',') thetar= aadata[:,6] thetar= (numpy.pi+(thetar-numpy.median(thetar))) % (2.*numpy.pi) indx= thetar-numpy.pi < -(5.*numpy.median(numpy.fabs(thetar-numpy.median(thetar)))) data= data[indx,:] bovy_plot.bovy_hist(data[:,1],bins=20,range=[3.,12.4], histtype='step',normed=True, overplot=True, lw=1.5,color='k') bovy_plot.bovy_end_print(plotfilename)
def calculate_bin_error(samples, fehbin, agebin, nbin, iso_grid, type='brokenexpflare', loggcut=[1.8, 3.0], teffcut=[4000, 5000], n_sampling=1000, progress=True, mp=True, fitIndx=None, weights='padova', distance_cut=False, lowermass=None): randsamples = np.random.permutation(samples.T)[:n_sampling] m_sample = np.zeros(np.shape(randsamples)[0]) if multi == False: for ii, params in enumerate(randsamples): if progress == True: print '' + str(round(float(ii) / float(n_sampling) * 100, 2)) + '% complete!' m = calc_normalisation(params, nbin, iso_grid, fehbin=fehbin, agebin=agebin, loggcut=loggcut, teffcut=teffcut, type=type, verbose=False, fitIndx=fitIndx, gridfile=gridfile, weights=weights, distance_cut=distance_cut, lowermass=lowermass)[0] m_sample[ii] = m if mp == True: m_sample= multi.parallel_map((lambda x: calc_normalisation(randsamples[x], nbin, iso_grid, fehbin=fehbin, agebin=agebin,loggcut=loggcut, teffcut=teffcut, type=type, verbose=False, fitIndx=fitIndx, distance_cut=distance_cut, lowermass=lowermass)[0]),\ range(np.shape(randsamples)[0]),numcores=numpy.amin([np.shape(randsamples)[0], multiprocessing.cpu_count()/2])) median = np.percentile(m_sample, 50) lowerr = np.percentile(m_sample, 16) uperr = np.percentile(m_sample, 84) return m_sample, median, lowerr, uperr
def calc_actions(snapfile=None): #Directories snapdir= 'snaps/' basefilename= snapfile.split('.')[0] nsnap= len(glob.glob(os.path.join(snapdir,basefilename+'_*.dat'))) print "Processing %i snapshots ..." % nsnap #Setup potential lp= potential.LogarithmicHaloPotential(normalize=1.,q=0.9) if False: aA= actionAngleStaeckel(pot=lp,delta=1.20,c=True) snapaadir= 'snaps_aas/' else: aA= actionAngleIsochroneApprox(pot=lp,b=0.8) snapaadir= 'snaps_aai/' #Run each snapshot if True: calcThese= [] for ii in range(nsnap): csvfilename= os.path.join(snapaadir,basefilename+'_aa_%s.dat' % str(ii).zfill(5)) if os.path.exists(csvfilename): #Don't recalculate those that have already been calculated nstart= int(subprocess.check_output(['wc','-l',csvfilename]).split(' ')[0]) if nstart < 10000: calcThese.append(ii) else: calcThese.append(ii) nsnap= len(calcThese) if len(calcThese) == 0: print "All done with everything ..." return None args= (aA,snapdir,basefilename,snapaadir) print "Using %i cpus ..." % (numpy.amin([64,nsnap, multiprocessing.cpu_count()])) dummy= multi.parallel_map((lambda x: indiv_calc_actions(x, *args)), calcThese, # range(nsnap), numcores=numpy.amin([64,nsnap, multiprocessing.cpu_count()])) return None
def plot_distanceareaintegral(savename,plotname,rmcenter=False, onlygreen=False): if os.path.exists(savename): with open(savename,'rb') as savefile: area= pickle.load(savefile) else: # For samping over the absolute magnitude distribution iso= gaia_rc.load_iso() Gsamples= gaia_rc.sample_Gdist(iso,n=_NGSAMPLES) # l and b of the pixels theta, phi= healpy.pixelfunc.pix2ang(_NSIDE, numpy.arange(healpy.pixelfunc.nside2npix(_NSIDE)), nest=False) cosb= numpy.sin(theta) area= multi.parallel_map(lambda x: distanceAreaIntegrand(\ dust._GREEN15DISTS[x],cosb,Gsamples,rmcenter,onlygreen), range(len(dust._GREEN15DISTS)), numcores=numpy.amin([16, len(dust._GREEN15DISTS), multiprocessing.cpu_count()])) save_pickles(savename,area) # Plot the power spectrum area= numpy.array(area) if True: psdthis= ((area.T*dust._GREEN15DISTS**3.).T/numpy.sum((area.T*dust._GREEN15DISTS**3.),axis=1)) psdx, psd= signal.periodogram(psdthis, fs=1./(dust._GREEN15DISTMODS[1]-dust._GREEN15DISTMODS[0]), detrend=lambda x: x,scaling='spectrum', axis=0) bovy_plot.bovy_print(fig_height=3.) matplotlib.rcParams['text.latex.preamble']=[r"\usepackage{yfonts}"] healpy.visufunc.mollview(numpy.log10(psd[-2]), nest=False, xsize=4000,min=-10.,max=-3., cmap='gist_yarg', title="") bovy_plot.bovy_end_print(plotname) return None
def plot1d(options,args): """Make a plot of a quantity's best-fit vs. FeH and aFe""" if options.sample.lower() == 'g': npops= 62 elif options.sample.lower() == 'k': npops= 54 if options.sample.lower() == 'g': savefile= open('binmapping_g.sav','rb') elif options.sample.lower() == 'k': savefile= open('binmapping_k.sav','rb') fehs= pickle.load(savefile) afes= pickle.load(savefile) savefile.close() #First calculate the derivative properties if not options.multi is None: derivProps= multi.parallel_map((lambda x: calcAllDerivProps(x,options,args)), range(npops), numcores=numpy.amin([options.multi, npops, multiprocessing.cpu_count()])) else: derivProps= [] for ii in range(npops): derivProps.append(calcAllDerivProps(ii,options,args)) #Load into plotthis plotthis= numpy.zeros(npops)+numpy.nan for ii in range(npops): if numpy.log(monoAbundanceMW.hr(fehs[ii],afes[ii], k=(options.sample.lower() == 'k')) /8.) > -0.5 \ or (options.sample.lower() == 'g' and ii < 6) \ or (options.sample.lower() == 'k' and ii < 7): continue plotthis[ii]= derivProps[ii][options.subtype.lower()] #Now plot bovy_plot.bovy_print() monoAbundanceMW.plotPixelFunc(fehs,afes,plotthis, zlabel=labels[options.subtype.lower()]) bovy_plot.bovy_end_print(options.outfilename) return None
def create_frames(options,args): # First reload the model with open('gd1pepper%isampling.pkl' % options.nsnap,'rb') as savefile: sdf_pepper_leading= pickle.load(savefile) with open('gd1pepper%isampling_trailing.pkl' % options.nsnap,'rb') as savefile: sdf_pepper_trailing= pickle.load(savefile) # Output times timpacts= sdf_pepper_leading._uniq_timpact # Sample unperturbed aAt numpy.random.seed(1) Oml,anglel,dtl= super(streampepperdf,sdf_pepper_leading)._sample_aAt(\ options.nparticles) Omt,anglet,dtt= super(streampepperdf,sdf_pepper_trailing)._sample_aAt(\ options.nparticles) # Setup progenitor prog= sdf_pepper_leading._progenitor().flip() prog.integrate(numpy.linspace(0.,9./bovy_conversion.time_in_Gyr(V0,R0), 10001),sdf_pepper_leading._pot) prog.flip() # Setup impacts if options.single: # Hit the leading arm and the trailing arm 1 Gyr later m= options.singlemimpact/bovy_conversion.mass_in_1010msol(V0,R0)/1000. t= timpacts[\ numpy.argmin(\ numpy.fabs(\ numpy.array(timpacts)\ -options.singletimpact\ /bovy_conversion.time_in_Gyr(V0,R0)))] sdf_pepper_leading.set_impacts(\ impactb=[0.5*simulate_streampepper.rs(options.singlemimpact*10.**7.)], subhalovel=numpy.array([[-25.,155.,30.]])/V0, impact_angle=[0.2], timpact=[t], GM=[m],rs=[simulate_streampepper.rs(options.singlemimpact*10.**7.)]) # Trailing m= options.singlemimpact/bovy_conversion.mass_in_1010msol(V0,R0)/1000. t= timpacts[\ numpy.argmin(\ numpy.fabs(\ numpy.array(timpacts)\ -(options.singletimpact+1.)\ /bovy_conversion.time_in_Gyr(V0,R0)))] sdf_pepper_trailing.set_impacts(\ impactb=[1.*simulate_streampepper.rs(options.singlemimpact*10.**7.)], subhalovel=numpy.array([[-25.,155.,30.]])/V0, impact_angle=[-0.3], timpact=[t], GM=[m],rs=[simulate_streampepper.rs(options.singlemimpact*10.**7.)]) elif options.pepper: # Sampling functions massrange=[options.Mmin,options.Mmax] plummer= False Xrs= 5. nsubhalo= simulate_streampepper.nsubhalo rs= simulate_streampepper.rs dNencdm= simulate_streampepper.dNencdm sample_GM= lambda: (10.**((-0.5)*massrange[0])\ +(10.**((-0.5)*massrange[1])\ -10.**((-0.5)*massrange[0]))\ *numpy.random.uniform())**(1./(-0.5))\ /bovy_conversion.mass_in_msol(V0,R0) rate_range= numpy.arange(massrange[0]+0.5,massrange[1]+0.5,1) rate= numpy.sum([dNencdm(sdf_pepper_leading,10.**r,Xrs=Xrs, plummer=plummer) for r in rate_range]) rate= options.timescdm*rate sample_rs= lambda x: rs(x*bovy_conversion.mass_in_1010msol(V0,R0)*10.**10., plummer=plummer) # Pepper both sdf_pepper_leading.simulate(rate=rate,sample_GM=sample_GM, sample_rs=sample_rs,Xrs=Xrs) print numpy.amax(sdf_pepper_leading._GM)*bovy_conversion.mass_in_1010msol(V0,R0) sdf_pepper_trailing.simulate(rate=rate,sample_GM=sample_GM, sample_rs=sample_rs,Xrs=Xrs) print numpy.amax(sdf_pepper_trailing._GM)*bovy_conversion.mass_in_1010msol(V0,R0) else: # Hit both with zero sdf_pepper_leading.set_impacts(\ impactb=[0.], subhalovel=numpy.array([[-25.,155.,30.]])/V0, impact_angle=[0.2], timpact=[timpacts[0]], GM=[0.],rs=[1.]) sdf_pepper_trailing.set_impacts(\ impactb=[0.], subhalovel=numpy.array([[-25.,155.,30.]])/V0, impact_angle=[-0.2], timpact=[timpacts[0]], GM=[0.],rs=[1.]) # Now make all frames dum= multi.parallel_map( (lambda x: _plot_one_frame(x,options,prog,timpacts, sdf_pepper_leading,sdf_pepper_trailing, Oml,Omt,anglel,anglet,dtl,dtt)), range(len(timpacts)), numcores=numpy.amin([len(timpacts),30])) return None
def volume(self, vol_func, xyz=False, MJ=None, JK=None, ndists=101, linearDist=False, relative=False, ncpu=None): """ NAME: volume PURPOSE: Compute the effective volume of a spatial volume under this effective selection function INPUT: vol_func - function of (a) (ra/deg,dec/deg,dist/kpc) (b) heliocentric Galactic X,Y,Z if xyz that returns 1. inside the spatial volume under consideration and 0. outside of it, should be able to take array input of a certain shape and return an array with the same shape xyz= (False) if True, vol_func is a function of X,Y,Z (see above) MJ= (object-wide default) absolute magnitude in J or an array of samples of absolute magnitudes in J for the tracer population JK= (object-wide default) J-Ks color or an array of samples of the J-Ks color relative= (False) if True, compute the effective volume completeness = effective volume / true volume; computed using the same integration grid, so will be more robust against integration errors (especially due to the finite HEALPix grid for the angular integration). For simple volumes, a more precise effective volume can be computed by using relative=True and multiplying in the correct true volume ndists= (101) number of distances to use in the distance integration linearDist= (False) if True, integrate in distance rather than distance modulus ncpu= (None) if set to an integer, use this many CPUs to compute the effective selection function (only for non-zero extinction) OUTPUT effective volume HISTORY: 2017-01-18 - Written - Bovy (UofT/CCA) """ # Pre-compute coordinates for integrand evaluation if not hasattr(self,'_ra_cen_4vol') or \ (hasattr(self,'_ndists_4vol') and (ndists != self._ndists_4vol or linearDist != self._linearDist_4vol)): theta,phi= healpy.pix2ang(\ _BASE_NSIDE,numpy.arange(_BASE_NPIX)\ [True^self._tgasSel._exclude_mask_skyonly],nest=True) self._ra_cen_4vol = 180. / numpy.pi * phi self._dec_cen_4vol = 90. - 180. / numpy.pi * theta if linearDist: dists = numpy.linspace(0.001, 10., ndists) dms = 5. * numpy.log10(dists) + 10. self._deltadm_4vol = dists[1] - dists[0] else: dms = numpy.linspace(0., 18., ndists) self._deltadm_4vol = (dms[1] - dms[0]) * numpy.log(10.) / 5. self._dists_4vol = 10.**(0.2 * dms - 2.) self._tiled_dists3_4vol= numpy.tile(\ self._dists_4vol**(3.-linearDist),(len(self._ra_cen_4vol),1)) self._tiled_ra_cen_4vol = numpy.tile(self._ra_cen_4vol, (len(self._dists_4vol), 1)).T self._tiled_dec_cen_4vol = numpy.tile(self._dec_cen_4vol, (len(self._dists_4vol), 1)).T lb = bovy_coords.radec_to_lb(phi, numpy.pi / 2. - theta) l = numpy.tile(lb[:, 0], (len(self._dists_4vol), 1)).T.flatten() b = numpy.tile(lb[:, 1], (len(self._dists_4vol), 1)).T.flatten() XYZ_4vol= \ bovy_coords.lbd_to_XYZ(l,b, numpy.tile(self._dists_4vol, (len(self._ra_cen_4vol),1)).flatten()) self._X_4vol = numpy.reshape( XYZ_4vol[:, 0], (len(self._ra_cen_4vol), len(self._dists_4vol))) self._Y_4vol = numpy.reshape( XYZ_4vol[:, 1], (len(self._ra_cen_4vol), len(self._dists_4vol))) self._Z_4vol = numpy.reshape( XYZ_4vol[:, 2], (len(self._ra_cen_4vol), len(self._dists_4vol))) # Cache effective-selection function MJ, JK = self._parse_mj_jk(MJ, JK) new_hash = hashlib.md5(numpy.array([MJ, JK])).hexdigest() if not hasattr(self,'_vol_MJ_hash') or new_hash != self._vol_MJ_hash \ or (hasattr(self,'_ndists_4vol') and (ndists != self._ndists_4vol or linearDist != self._linearDist_4vol)): # Need to update the effective-selection function if isinstance(self._dmap3d, mwdust.Zero): #easy bc same everywhere effsel_4vol = self(self._dists_4vol, self._ra_cen_4vol[0], self._dec_cen_4vol[0], MJ=MJ, JK=JK) self._effsel_4vol = numpy.tile(effsel_4vol, (len(self._ra_cen_4vol), 1)) else: # Need to treat each los separately if ncpu is None: self._effsel_4vol = numpy.empty( (len(self._ra_cen_4vol), len(self._dists_4vol))) for ii,(ra_cen, dec_cen) \ in enumerate(tqdm.tqdm(zip(self._ra_cen_4vol, self._dec_cen_4vol))): self._effsel_4vol[ii] = self(self._dists_4vol, ra_cen, dec_cen, MJ=MJ, JK=JK) else: multiOut= multi.parallel_map(\ lambda x: self(self._dists_4vol, self._ra_cen_4vol[x], self._dec_cen_4vol[x],MJ=MJ,JK=JK), range(len(self._ra_cen_4vol)), numcores=ncpu) self._effsel_4vol = numpy.array(multiOut) self._vol_MJ_hash = new_hash self._ndists_4vol = ndists self._linearDist_4vol = linearDist out = 0. if xyz: out= numpy.sum(\ self._effsel_4vol\ *vol_func(self._X_4vol,self._Y_4vol,self._Z_4vol)\ *self._tiled_dists3_4vol) else: out= numpy.sum(\ self._effsel_4vol\ *vol_func(self._ra_cen_4vol,self._dec_cen_4vol, self._dists_4vol)\ *self._tiled_dists3_4vol) if relative: if not hasattr(self, '_tgasEffSelUniform'): tgasSelUniform = tgasSelectUniform(comp=1.) self._tgasEffSelUniform = tgasEffectiveSelect(tgasSelUniform) true_volume = self._tgasEffSelUniform.volume(vol_func, xyz=xyz, ndists=ndists, linearDist=linearDist, relative=False) else: true_volume = 1. return out*healpy.nside2pixarea(_BASE_NSIDE)*self._deltadm_4vol\ /true_volume
def plot_distanceintegral_smallpatch(savename, plotname): if os.path.exists(savename): with open(savename, 'rb') as savefile: area = pickle.load(savefile) else: # Load the patch hpIndx, dmap = read_patch() # For samping over the absolute magnitude distribution iso = gaia_rc.load_iso() Gsamples = gaia_rc.sample_Gdist(iso, n=_NGSAMPLES) # l and b of the pixels theta, phi = healpy.pixelfunc.pix2ang(_NSIDE_HIRES, hpIndx, nest=False) cosb = numpy.sin(theta) area= multi.parallel_map(lambda x: distanceIntegrandHires(\ _HIRESGREEN15DISTS[x],theta,phi,cosb,Gsamples,dmap), range(len(_HIRESGREEN15DISTS)), numcores=numpy.amin([16, len(_HIRESGREEN15DISTS), multiprocessing.cpu_count()])) save_pickles(savename, area) # Plot the power spectrum if True: psdx, psd = signal.periodogram( area * _HIRESGREEN15DISTS**3. / numpy.sum(area * _HIRESGREEN15DISTS**3.), fs=1. / (_HIRESGREEN15DISTMODS[1] - _HIRESGREEN15DISTMODS[0]), detrend=lambda x: x, scaling='spectrum') bovy_plot.bovy_print(fig_height=3.) matplotlib.rcParams['text.latex.preamble'] = [r"\usepackage{yfonts}"] bovy_plot.bovy_plot(psdx[1:], psd[1:], 'k-', loglog=True, xlabel=r'$2\pi\,k_\mu\,(\mathrm{mag}^{-1})$', ylabel=r'$P_k$', xrange=[0.04, 4.]) bovy_plot.bovy_text( r'$\mathrm{normalized}\ D^3\,\nu_*(\mu|\theta)\,\textswab{S}(\mu)$', bottom_left=True, size=16.) bovy_plot.bovy_end_print(plotname) else: bovy_plot.bovy_print(fig_height=3.) matplotlib.rcParams['text.latex.preamble'] = [r"\usepackage{yfonts}"] bovy_plot.bovy_plot( _HIRESGREEN15DISTMODS, area * _HIRESGREEN15DISTS**3., 'k-', xlabel=r'$\mu\,(\mathrm{mag}^{-1})$', ylabel=r'$D^3\,\nu_*(\mu|\theta)\,\textswab{S}(\mu)$') bovy_plot.bovy_end_print(plotname) spl = interpolate.InterpolatedUnivariateSpline(_HIRESGREEN15DISTMODS, area * _HIRESGREEN15DISTS**3., k=5) fthder = [spl.derivatives(dm)[4] for dm in _HIRESGREEN15DISTMODS] print "Simpson error= ", 0.5**4. / 180. * numpy.mean( numpy.fabs(fthder)) / integrate.simps(area * _HIRESGREEN15DISTS**3., dx=0.5) return None
def __init__(self, pot=None, zmax=3. / 8., gamma=1., Rmax=3., nR=25, nEz=25, nEr=25, nLz=25, numcores=1, **kwargs): """ NAME: __init__ PURPOSE: initialize an actionAngleAdiabaticGrid object INPUT: pot= potential or list of potentials (planarPotentials) zmax= zmax for building Ez grid Rmax = Rmax for building grids gamma= (default=1.) replace Lz by Lz+gamma Jz in effective potential nEz=, nEr=, nLz, nR= grid size numcores= number of cpus to use to parallellize +scipy.integrate.quad keywords OUTPUT: HISTORY: 2012-07-27 - Written - Bovy (IAS@MPIA) """ if pot is None: raise IOError("Must specify pot= for actionAngleAxi") self._gamma = gamma self._pot = pot self._zmax = zmax self._Rmax = Rmax self._Rmin = 0.01 #Set up the actionAngleAdiabatic object that we will use to interpolate self._aA = actionAngleAdiabatic(pot=self._pot, gamma=self._gamma) #Build grid for Ez, first calculate Ez(zmax;R) function self._Rs = numpy.linspace(self._Rmin, self._Rmax, nR) self._EzZmaxs = numpy.array([ galpy.potential.evaluatePotentials(r, self._zmax, self._pot) - galpy.potential.evaluatePotentials(r, 0., self._pot) for r in self._Rs ]) self._EzZmaxsInterp = interpolate.InterpolatedUnivariateSpline( self._Rs, numpy.log(self._EzZmaxs), k=3) y = numpy.linspace(0., 1., nEz) jz = numpy.zeros((nR, nEz)) jzEzzmax = numpy.zeros(nR) if numcores > 1: thisRs = (numpy.tile(self._Rs, (nEz, 1)).T).flatten() thisEzZmaxs = (numpy.tile(self._EzZmaxs, (nEz, 1)).T).flatten() thisy = (numpy.tile(y, (nR, 1))).flatten() jz = multi.parallel_map( ( lambda x: self._aA.Jz( thisRs[x], 0., 1., #these two r dummies 0., math.sqrt(2. * thisy[x] * thisEzZmaxs[x]), **kwargs)[0]), range(nR * nEz), numcores=numcores) jz = numpy.reshape(jz, (nR, nEz)) jzEzzmax[0:nR] = jz[:, nEz - 1] else: for ii in range(nR): for jj in range(nEz): #Calculate Jz jz[ii, jj] = self._aA.Jz( self._Rs[ii], 0., 1., #these two r dummies 0., math.sqrt(2. * y[jj] * self._EzZmaxs[ii]), **kwargs)[0] if jj == nEz - 1: jzEzzmax[ii] = jz[ii, jj] for ii in range(nR): jz[ii, :] /= jzEzzmax[ii] #First interpolate Ez=Ezmax self._jzEzmaxInterp = interpolate.InterpolatedUnivariateSpline( self._Rs, numpy.log(jzEzzmax + 10.**-5.), k=3) self._jz = jz self._jzInterp = interpolate.RectBivariateSpline(self._Rs, y, jz, kx=3, ky=3, s=0.) #JR grid self._Lzmin = 0.01 self._Lzs= numpy.linspace(self._Lzmin, self._Rmax\ *galpy.potential.vcirc(self._pot, self._Rmax), nLz) self._Lzmax = self._Lzs[-1] #Calculate ER(vr=0,R=RL) self._RL = numpy.array( [galpy.potential.rl(self._pot, l) for l in self._Lzs]) self._RLInterp = interpolate.InterpolatedUnivariateSpline(self._Lzs, self._RL, k=3) self._ERRL = numpy.array([ galpy.potential.evaluatePotentials(self._RL[ii], 0., self._pot) + self._Lzs[ii]**2. / 2. / self._RL[ii]**2. for ii in range(nLz) ]) self._ERRLmax = numpy.amax(self._ERRL) + 1. self._ERRLInterp = interpolate.InterpolatedUnivariateSpline( self._Lzs, numpy.log(-(self._ERRL - self._ERRLmax)), k=3) self._Ramax = 99. self._ERRa = numpy.array([ galpy.potential.evaluatePotentials(self._Ramax, 0., self._pot) + self._Lzs[ii]**2. / 2. / self._Ramax**2. for ii in range(nLz) ]) self._ERRamax = numpy.amax(self._ERRa) + 1. self._ERRaInterp = interpolate.InterpolatedUnivariateSpline( self._Lzs, numpy.log(-(self._ERRa - self._ERRamax)), k=3) y = numpy.linspace(0., 1., nEr) jr = numpy.zeros((nLz, nEr)) jrERRa = numpy.zeros(nLz) if numcores > 1: thisRL = (numpy.tile(self._RL, (nEr - 1, 1)).T).flatten() thisLzs = (numpy.tile(self._Lzs, (nEr - 1, 1)).T).flatten() thisERRL = (numpy.tile(self._ERRL, (nEr - 1, 1)).T).flatten() thisERRa = (numpy.tile(self._ERRa, (nEr - 1, 1)).T).flatten() thisy = (numpy.tile(y[0:-1], (nLz, 1))).flatten() mjr = multi.parallel_map((lambda x: self._aA.JR( thisRL[x], numpy.sqrt(2. * (thisERRa[x] + thisy[x] * (thisERRL[x] - thisERRa[x]) - galpy.potential. evaluatePotentials(thisRL[x], 0., self._pot)) - thisLzs[x]**2. / thisRL[x]**2.), thisLzs[x] / thisRL[x], 0., 0., **kwargs)[0]), range((nEr - 1) * nLz), numcores=numcores) jr[:, 0:-1] = numpy.reshape(mjr, (nLz, nEr - 1)) jrERRa[0:nLz] = jr[:, 0] else: for ii in range(nLz): for jj in range(nEr - 1): #Last one is zero by construction try: jr[ii, jj] = self._aA.JR( self._RL[ii], numpy.sqrt(2. * (self._ERRa[ii] + y[jj] * (self._ERRL[ii] - self._ERRa[ii]) - galpy.potential.evaluatePotentials( self._RL[ii], 0., self._pot)) - self._Lzs[ii]**2. / self._RL[ii]**2.), self._Lzs[ii] / self._RL[ii], 0., 0., **kwargs)[0] except UnboundError: raise if jj == 0: jrERRa[ii] = jr[ii, jj] for ii in range(nLz): jr[ii, :] /= jrERRa[ii] #First interpolate Ez=Ezmax self._jr = jr self._jrERRaInterp = interpolate.InterpolatedUnivariateSpline( self._Lzs, numpy.log(jrERRa + 10.**-5.), k=3) self._jrInterp = interpolate.RectBivariateSpline(self._Lzs, y, jr, kx=3, ky=3, s=0.) return None
def plotVelComparisonDFMulti(options,args): #Read data etc. print "Reading the data ..." raw= read_rawdata(options) #Bin the data binned= pixelAfeFeh(raw,dfeh=options.dfeh,dafe=options.dafe) #Map the bins with ndata > minndata in 1D fehs, afes= [], [] for ii in range(len(binned.fehedges)-1): for jj in range(len(binned.afeedges)-1): data= binned(binned.feh(ii),binned.afe(jj)) if len(data) < options.minndata: continue #print binned.feh(ii), binned.afe(jj), len(data) fehs.append(binned.feh(ii)) afes.append(binned.afe(jj)) nabundancebins= len(fehs) fehs= numpy.array(fehs) afes= numpy.array(afes) gafes, gfehs, left_legend= getMultiComparisonBins(options) M= len(gfehs) if options.andistances: distancefacs= numpy.zeros_like(fehs) gdistancefacs= numpy.zeros_like(gfehs) for jj in range(M): #Find pop corresponding to this bin ii= numpy.argmin((gfehs[jj]-fehs)**2./0.1+(gafes[jj]-afes)**2./0.0025) print ii #Get the relevant data data= binned(fehs[ii],afes[ii]) distancefacs[ii]= AnDistance.AnDistance(data.dered_g-data.dered_r, data.feh) gdistancefacs[jj]= distancefacs[ii] options.fixdm= numpy.log10(distancefacs[ii])*5. #Apply distance factor to the data newraw= read_rawdata(options) newbinned= pixelAfeFeh(newraw,dfeh=options.dfeh,dafe=options.dafe) thisdataIndx= binned.callIndx(fehs[ii],afes[ii]) binned.data.xc[thisdataIndx]= newbinned.data.xc[thisdataIndx] binned.data.yc[thisdataIndx]= newbinned.data.yc[thisdataIndx] binned.data.zc[thisdataIndx]= newbinned.data.zc[thisdataIndx] binned.data.plate[thisdataIndx]= newbinned.data.plate[thisdataIndx] binned.data.dered_r[thisdataIndx]= newbinned.data.dered_r[thisdataIndx] else: distancefacs=numpy.ones_like(fehs) gdistancefacs=numpy.ones_like(gfehs) ##########POTENTIAL PARAMETERS#################### potparams1= numpy.array([numpy.log(2.5/8.),options.fixvc/220., numpy.log(400./8000.),0.2,0.]) if options.group.lower() == 'aenhanced': potparams2= numpy.array([numpy.log(2.8/8.),options.fixvc/220., numpy.log(400./8000.),0.266666666,0.]) potparams3= numpy.array([numpy.log(2.8/8.),options.fixvc/220., numpy.log(400./8000.),0.8,0.]) elif options.group.lower() == 'aintermediate': potparams2= numpy.array([numpy.log(3.0/8.),options.fixvc/220., numpy.log(400./8000.),0.3333333333333,0.]) potparams3= numpy.array([numpy.log(3.0/8.),options.fixvc/220., numpy.log(400./8000.),0.933333333333,0.]) elif options.group.lower() == 'apoor': potparams2= numpy.array([numpy.log(2.6/8.),options.fixvc/220., numpy.log(400./8000.),0.4,0.]) potparams3= numpy.array([numpy.log(2.6/8.),options.fixvc/220., numpy.log(400./8000.),1.0,0.]) options.potential= 'dpdiskplhalofixbulgeflatwgasalt' #Check whether fits exist, if not, pop removeBins= numpy.ones(M,dtype='bool') for jj in range(M): #Find pop corresponding to this bin pop= numpy.argmin((gfehs[jj]-fehs)**2./0.1+(gafes[jj]-afes)**2./0.0025) #Load savefile if not options.init is None: #Load initial parameters from file savename= options.init spl= savename.split('.') newname= '' for ll in range(len(spl)-1): newname+= spl[ll] if not ll == len(spl)-2: newname+= '.' newname+= '_%i.' % pop newname+= spl[-1] if not os.path.exists(newname): removeBins[jj]= False else: raise IOError("base filename not specified ...") if numpy.sum(removeBins) == 0: raise IOError("None of the group bins have been fit ...") elif numpy.sum(removeBins) < M: #Some bins have not been fit yet, and have to be remove gfehs= list((numpy.array(gfehs))[removeBins]) gafes= list((numpy.array(gafes))[removeBins]) print "Only using %i bins out of %i ..." % (numpy.sum(removeBins),M) M= len(gfehs) data= [] zs= [] velps= numpy.zeros((len(binned.data),options.nv)) velps[:,:]= numpy.nan velps2= numpy.zeros((len(binned.data),options.nv)) velps2[:,:]= numpy.nan velps3= numpy.zeros((len(binned.data),options.nv)) velps3[:,:]= numpy.nan cumulndata= 0 if options.type.lower() == 'vz': if options.group == 'aenhanced': vs= numpy.linspace(-180.,180.,options.nv) xrange=[-180.,180.] bins= 39 elif options.group == 'aintermediate': vs= numpy.linspace(-150.,150.,options.nv) xrange=[-150.,150.] bins= 33 else: # options.group == 'aenhanced': vs= numpy.linspace(-120.,120.,options.nv) xrange=[-140.,140.] bins= 26 xlabel=r'$V_Z\ (\mathrm{km\,s}^{-1})$' elif options.type.lower() == 'vr': if options.group == 'aenhanced': vs= numpy.linspace(-220.,220.,options.nv) xrange=[-220.,220.] bins= 39 else: # options.group == 'aenhanced': vs= numpy.linspace(-150.,150.,options.nv) xrange=[-150.,150.] bins= 26 xlabel=r'$V_R\ (\mathrm{km\,s}^{-1})$' elif options.type.lower() == 'vt': if options.group == 'aenhanced': vs= numpy.linspace(0.01,350.,options.nv) xrange=[0.,350.] bins= 39 else: # options.group == 'aenhanced': vs= numpy.linspace(0.01,350.,options.nv) xrange=[0.,350.] bins= 39 xlabel=r'$V_T\ (\mathrm{km\,s}^{-1})$' alts= True if not options.multi is None: #Generate list of temporary files tmpfiles= [] for jj in range(M): tfile, tmpfile= tempfile.mkstemp() os.close(tfile) #Close because it's open tmpfiles.append(tmpfile) try: dummy= multi.parallel_map((lambda x: run_calc_model_multi(x,M,gfehs,gafes,fehs,afes,options, vs, potparams1,potparams2,potparams3, distancefacs, binned,alts,True,tmpfiles)), range(M), numcores=numpy.amin([M, multiprocessing.cpu_count(), options.multi])) #Now read all of the temporary files for jj in range(M): tmpfile= open(tmpfiles[jj],'rb') tvelps= pickle.load(tmpfile) if tvelps is None: continue tvelps2= pickle.load(tmpfile) tvelps3= pickle.load(tmpfile) data.extend(pickle.load(tmpfile)) zs.extend(pickle.load(tmpfile)) tndata= pickle.load(tmpfile) velps[cumulndata:cumulndata+tndata,:]= tvelps velps2[cumulndata:cumulndata+tndata,:]= tvelps2 velps3[cumulndata:cumulndata+tndata,:]= tvelps3 cumulndata+= tndata tmpfile.close() finally: for jj in range(M): os.remove(tmpfiles[jj]) else: for jj in range(M): try: tvelps, tvelps2, tvelps3, tdata, tzs, tndata= run_calc_model_multi(jj,M,gfehs,gafes,fehs,afes,options, vs, potparams1,potparams2,potparams3, distancefacs, binned,alts, False,None) except TypeError: continue velps[cumulndata:cumulndata+tndata,:]= tvelps velps2[cumulndata:cumulndata+tndata,:]= tvelps2 velps3[cumulndata:cumulndata+tndata,:]= tvelps3 data.extend(tdata) zs.extend(tzs) cumulndata+= tndata bovy_plot.bovy_print() bovy_plot.bovy_hist(data,bins=26,normed=True,color='k', histtype='step', xrange=xrange,xlabel=xlabel) plotp= numpy.nansum(velps[:cumulndata,:],axis=0)/cumulndata print numpy.sum(plotp)*(vs[1]-vs[0]) bovy_plot.bovy_plot(vs,plotp,'k-',overplot=True) if alts: plotp= numpy.nansum(velps2,axis=0)/cumulndata bovy_plot.bovy_plot(vs,plotp,'k--',overplot=True) plotp= numpy.nansum(velps3,axis=0)/cumulndata bovy_plot.bovy_plot(vs,plotp,'k:',overplot=True) if not left_legend is None: bovy_plot.bovy_text(left_legend,top_left=True,size=_legendsize) bovy_plot.bovy_text(r'$\mathrm{full\ subsample}$' +'\n'+ '$%i \ \ \mathrm{stars}$' % len(data),top_right=True, size=_legendsize) bovy_plot.bovy_end_print(args[0]+'model_data_g_'+options.group+'_'+options.type+'dist_all.'+options.ext) if options.all: return None #Plot zranges #First determine the ranges that have nstars in them rranges_nstars= 1000 zs= numpy.array(zs) data= numpy.array(data) tdata_z= sorted(numpy.fabs(zs)) nbins= numpy.ceil(len(tdata_z)/float(rranges_nstars)) rranges_nstars= int(numpy.floor(float(len(tdata_z))/nbins)) accum= rranges_nstars zranges= [0.0] while accum < len(tdata_z): zranges.append(tdata_z[accum]) accum+= rranges_nstars zranges.append(5.0) print zranges #zranges= [0.5,1.,1.5,2.,3.,4.] nzranges= len(zranges)-1 sigzsd= numpy.empty(nzranges) esigzsd= numpy.empty(nzranges) sigzs1= numpy.empty(nzranges) sigzs2= numpy.empty(nzranges) sigzs3= numpy.empty(nzranges) for ii in range(nzranges): indx= (numpy.fabs(zs) >= zranges[ii])*(numpy.fabs(zs) < zranges[ii+1]) plotp= numpy.nansum(velps[indx,:],axis=0)/numpy.sum(indx) yrange= [0.,1.35*numpy.nanmax(plotp)] bovy_plot.bovy_print() bovy_plot.bovy_hist(data[indx],bins=26,normed=True,color='k', histtype='step', yrange=yrange, xrange=xrange,xlabel=xlabel) sigzsd[ii]= numpy.std(data[indx][(numpy.fabs(data[indx]) < 100.)]) esigzsd[ii]= sigzsd[ii]/numpy.sqrt(float(len(data[indx][(numpy.fabs(data[indx]) < 100.)]))) sigzs1[ii]= numpy.sqrt(numpy.sum(vs**2.*plotp)/numpy.sum(plotp)-(numpy.sum(vs*plotp)/numpy.sum(plotp))**2.) bovy_plot.bovy_plot(vs,plotp,'k-',overplot=True) if alts: plotp= numpy.nansum(velps2[indx,:],axis=0)/numpy.sum(indx) sigzs2[ii]= numpy.sqrt(numpy.sum(vs**2.*plotp)/numpy.sum(plotp)-(numpy.sum(vs*plotp)/numpy.sum(plotp))**2.) bovy_plot.bovy_plot(vs,plotp,'k--',overplot=True) plotp= numpy.nansum(velps3[indx,:],axis=0)/numpy.sum(indx) sigzs3[ii]= numpy.sqrt(numpy.sum(vs**2.*plotp)/numpy.sum(plotp)-(numpy.sum(vs*plotp)/numpy.sum(plotp))**2.) bovy_plot.bovy_plot(vs,plotp,'k:',overplot=True) bovy_plot.bovy_text(r'$ %i\ \mathrm{pc} \leq |Z| < %i\ \mathrm{pc}$' % (int(1000*zranges[ii]),int(1000*zranges[ii+1])), # +'\n'+ # '$%i \ \ \mathrm{stars}$' % (numpy.sum(indx)), top_right=True, size=_legendsize) bovy_plot.bovy_end_print(args[0]+'model_data_g_'+options.group+'_'+options.type+'dist_z%.1f_z%.1f.' % (zranges[ii],zranges[ii+1])+options.ext) #Plot velocity dispersion as a function of |Z| bovy_plot.bovy_print() bovy_plot.bovy_plot((((numpy.roll(zranges,-1)+zranges)/2.)[:-1]),sigzsd, 'ko', xlabel=r'$|Z|\ (\mathrm{kpc})$', ylabel=r'$\sigma_z\ (\mathrm{km\,s}^{-1})$', xrange=[0.,4.], yrange=[0.,60.]) pyplot.errorbar(((numpy.roll(zranges,-1)+zranges)/2.)[:-1],sigzsd, yerr=esigzsd, marker='o',color='k',linestyle='none') bovy_plot.bovy_plot((((numpy.roll(zranges,-1)+zranges)/2.)[:-1]),sigzs1, 'r+',overplot=True,ms=10.) bovy_plot.bovy_plot((((numpy.roll(zranges,-1)+zranges)/2.)[:-1]),sigzs2, 'cx',overplot=True,ms=10.) bovy_plot.bovy_plot((((numpy.roll(zranges,-1)+zranges)/2.)[:-1]),sigzs3, 'gd',overplot=True,ms=10.) bovy_plot.bovy_end_print(args[0]+'model_data_g_'+options.group+'_'+options.type+'dist_szvsz.' +options.ext) return None
def astro_sampling(parser): options, args = parser.parse_args() if options.basti: zs = numpy.array([0.004, 0.008, 0.01, 0.0198, 0.03, 0.04]) elif options.parsec: zs = numpy.arange(0.0005, 0.06005, 0.0005) # zs= numpy.arange(0.0005,0.06005,0.005) else: zs = numpy.arange(0.0005, 0.03005, 0.0005) # zs= numpy.arange(0.0005,0.03005,0.005) if os.path.exists(args[0]): savefile = open(args[0], "rb") plotthis = pickle.load(savefile) zs = pickle.load(savefile) lages = pickle.load(savefile) savefile.close() dlages = lages[1] - lages[0] if options.type == "massperrc": savefile = open(args[1], "rb") plotthis /= pickle.load(savefile) savefile.close() if options.type == "mass" and len(args) == 3: # Also load mass_coarseage and omega savefile = open(args[1], "rb") masscoarse = pickle.load(savefile) savefile.close() savefile = open(args[2], "rb") omega = pickle.load(savefile) savefile.close() else: nages = 31 if options.type == "omega" or options.type == "numfrac" or options.coarseage: nages = 16 lages = numpy.linspace(-1.0, 1.0, nages) dlages = lages[1] - lages[0] plotthis = numpy.zeros((len(zs), nages)) multOut = multi.parallel_map( lambda x: _calc_one(zs[x], options, nages, lages, dlages), range(len(zs)), numcores=32 ) for ii in range(len(zs)): plotthis[ii, :] = multOut[ii] # Save savefile = open(args[0], "wb") pickle.dump(plotthis, savefile) pickle.dump(zs, savefile) pickle.dump(lages, savefile) savefile.close() # Plot # Fist cut out youngest ages, since they are irrelevant if _CUTLOWAGE: aindx = lages > numpy.log10(0.8) lages = lages[aindx] plotthis = plotthis[:, aindx] if options.type == "mass": vmin, vmax = 0.5, 2.3 vmin2, vmax2 = 0.5, 2.0 zlabel = r"$\langle M_{\mathrm{RC}} \rangle \,(M_\odot)$" # cmap= 'gist_yarg' cmap = "jet" elif options.type == "omega": vmin, vmax = 0.0, 0.03 vmin2, vmax2 = 0.0, 0.015 if options.allapogee: vmin, vmax = 0.0, 0.035 zlabel = r"$\mathrm{Mass\ fraction\ in}\ (J-K_s)_0 > 0.5\ \mathrm{giants\ (\%)}$" elif options.redapogee: vmin, vmax = 0.0, 0.005 vmin2, vmax2 = 0.0, 0.003 zlabel = r"$\mathrm{Mass\ fraction\ in}\ (J-K_s)_0 > 0.8\ \mathrm{giants\ (\%)}$" else: zlabel = r"$\mathrm{Mass\ fraction\ in\ RC\ stars\ (\%)}$" # cmap= 'gist_yarg' cmap = "jet" plotthis *= 100.0 elif options.type == "numfrac": vmin, vmax = 0.0, 0.005 vmin2, vmax2 = 0.0, 0.004 zlabel = r"$\mathrm{Number\ fraction\ in\ RC\ stars\ (\%)}$" # cmap= 'gist_yarg' cmap = "jet" plotthis *= 100.0 elif options.type == "massperrc": vmin, vmax = 0.0, 50000.0 vmin2, vmax2 = 0.0, 25000.0 zlabel = r"$\mathrm{Stellar\ population\ mass\ per\ RC\ star}\,(M_\odot)$" # cmap= 'gist_yarg' cmap = "jet" if options.redapogee: vmin, vmax = 0.0, 100000.0 vmin2, vmax2 = 0.0, 200000.0 zlabel = r"$\mathrm{Mass\ fraction\ in}\ (J-K_s)_0 > 0.8\ \mathrm{giants\ (\%)}$" print numpy.nanmin(plotthis), numpy.nanmax(plotthis) if options.basti: # Remap the Zs zs = numpy.array([0.004, 0.008, 0.01, 0.0198, 0.03, 0.04]) regularzs = numpy.arange(0.0005, 0.03005, 0.0005) / 0.019 * 0.0198 regularplotthis = numpy.zeros((nages, len(regularzs))) for jj in range(len(regularzs)): # Find z thisindx = numpy.argmin(numpy.fabs(regularzs[jj] - zs)) for ii in range(nages): regularplotthis[ii, jj] = plotthis[ii, thisindx] zs = regularzs plotthis = regularplotthis if options.remapz: zs = zs[:-1] plotthis = plotthis[:-1, :] fehs = numpy.linspace(-1.05, isodist.Z2FEH(zs[-1], zsolar=0.017), len(zs)) fehzs = isodist.FEH2Z(fehs, zsolar=0.017) new_plotthis = numpy.empty_like(plotthis) for ii in range(plotthis.shape[1]): goodz = True - numpy.isnan(plotthis[:, ii]) tip = interpolate.InterpolatedUnivariateSpline(zs[goodz], plotthis[goodz, ii], k=3) new_plotthis[:, ii] = tip(fehzs) try: new_plotthis[fehs < numpy.nanmax(isodist.Z2FEH(zs[True - goodz], zsolar=0.017)), ii] = numpy.nan except ValueError: continue plotthis = new_plotthis xlabel = r"$[\mathrm{Fe/H}]\,(\mathrm{dex})$" else: xlabel = r"$Z$" bovy_plot.bovy_print(fig_height=7.0, fig_width=6.0) fig = pyplot.gcf() left, bottom, width, height = 0.1, 0.1, 0.8, 0.6 axBottom = pyplot.axes([left, bottom, width, height]) fig.sca(axBottom) if options.remapz: xlimits = [fehs[0], fehs[-1]] else: xlimits = [zs[0], zs[-1]] ylimits = [lages[0] - dlages, lages[-1] + dlages] bovy_plot.bovy_dens2d( plotthis.T, origin="lower", cmap=cmap, xrange=xlimits, yrange=ylimits, vmin=vmin, vmax=vmax, interpolation="nearest", colorbar=True, shrink=0.9, zlabel=zlabel, overplot=True, ) extent = xlimits + ylimits pyplot.axis(extent) bovy_plot._add_axislabels(xlabel, r"$\log_{10}\,\mathrm{Age} / 1\,\mathrm{Gyr}$") bovy_plot._add_ticks() left, bottom, width, height = 0.1, 0.68, 0.64, 0.2 axTop = pyplot.axes([left, bottom, width, height]) fig.sca(axTop) # Plot the average over SFH lages = numpy.linspace(-1.0, 1.0, 16) if _CUTLOWAGE: aindx = lages > numpy.log10(0.8) lages = lages[aindx] if options.type == "mass": omega = omega[:, aindx] masscoarse = masscoarse[:, aindx] mtrend = numpy.zeros(len(zs)) exppage = 10.0 ** lages * numpy.exp((10.0 ** (lages + 2.0)) / 800.0) # e.g., Binney (2010) exexppage = 10.0 ** lages * numpy.exp((10.0 ** (lages + 2.0)) / 100.0) # e.g., Binney (2010) page = 10.0 ** lages if options.type == "massperrc": mtrend = 1.0 / (numpy.sum(page * 1.0 / plotthis, axis=1) / numpy.sum(page)) expmtrend = 1.0 / (numpy.sum(exppage * 1.0 / plotthis, axis=1) / numpy.sum(exppage)) exexpmtrend = 1.0 / (numpy.sum(exexppage * 1.0 / plotthis, axis=1) / numpy.sum(exexppage)) elif options.type == "mass" and len(args) == 3: if options.remapz: omega = omega[:-1, :] masscoarse = masscoarse[:-1, :] mtrend = numpy.nansum(page * omega, axis=1) / numpy.nansum(page * omega / masscoarse, axis=1) expmtrend = numpy.nansum(exppage * omega, axis=1) / numpy.nansum(exppage * omega / masscoarse, axis=1) exexpmtrend = numpy.nansum(exexppage * omega, axis=1) / numpy.nansum(exexppage * omega / masscoarse, axis=1) else: mtrend = numpy.sum(page * plotthis, axis=1) / numpy.sum(page) expmtrend = numpy.sum(exppage * plotthis, axis=1) / numpy.sum(exppage) exexpmtrend = numpy.sum(exexppage * plotthis, axis=1) / numpy.sum(exexppage) if options.remapz: zs = fehs pyplot.plot(zs, mtrend, "k-") pyplot.plot(zs, expmtrend, "k--") pyplot.plot(zs, exexpmtrend, "k-.") pyplot.ylim(vmin2, vmax2) pyplot.xlim(xlimits[0], xlimits[1]) nullfmt = NullFormatter() # no labels thisax = pyplot.gca() thisax.xaxis.set_major_formatter(nullfmt) bovy_plot._add_ticks() if options.type == "mass": pyplot.ylabel(zlabel) if options.basti: pyplot.annotate( r"$\mathrm{BaSTI}$", (0.5, 1.08), xycoords="axes fraction", horizontalalignment="center", verticalalignment="top", size=16.0, ) elif options.imfmodel == "kroupa2003": pyplot.annotate( r"$\mathrm{Padova, Kroupa\ (2003)\ IMF}$", (0.5, 1.08), xycoords="axes fraction", horizontalalignment="center", verticalalignment="top", size=16.0, ) elif "expsfh" in args[0]: pyplot.annotate( r"$\mathrm{Padova, p(\mathrm{Age}) \propto e^{\mathrm{Age}/(8\,\mathrm{Gyr})}}$", (0.5, 1.08), xycoords="axes fraction", horizontalalignment="center", verticalalignment="top", size=16.0, ) elif options.parsec: pass # pyplot.annotate(r'$\mathrm{PARSEC}$', # (0.5,1.08),xycoords='axes fraction', # horizontalalignment='center', # verticalalignment='top',size=16.) else: pyplot.annotate( r"$\mathrm{Padova}$", (0.5, 1.08), xycoords="axes fraction", horizontalalignment="center", verticalalignment="top", size=16.0, ) bovy_plot.bovy_end_print(options.outfilename) return None
def __init__(self, RZPot=None,rgrid=(0.01,2.,101),zgrid=(0.,0.2,101),logR=False, interpPot=False,interpRforce=False,interpzforce=False, interpDens=False, interpvcirc=False, interpdvcircdr=False, interpepifreq=False,interpverticalfreq=False, use_c=False,enable_c=False,zsym=True, numcores=None): """ NAME: __init__ PURPOSE: Initialize an interpRZPotential instance INPUT: RZPot - RZPotential to be interpolated rgrid - R grid to be given to linspace zgrid - z grid to be given to linspace logR - if True, rgrid is in the log of R interpPot, interpRfoce, interpzforce, interpDens,interpvcirc, interpeopifreq, interpverticalfreq, interpdvcircdr= if True, interpolate these functions use_c= use C to speed up the calculation enable_c= enable use of C for interpolations zsym= if True (default), the potential is assumed to be symmetric around z=0 (so you can use, e.g., zgrid=(0.,1.,101)). numcores= if set to an integer, use this many cores (only used for vcirc, dvcircdR, epifreq, and verticalfreq; NOT NECESSARILY FASTER, TIME TO MAKE SURE) OUTPUT: instance HISTORY: 2010-07-21 - Written - Bovy (NYU) 2013-01-24 - Started with new implementation - Bovy (IAS) """ Potential.__init__(self,amp=1.) self.hasC= True self._origPot= RZPot self._rgrid= numpy.linspace(*rgrid) self._logR= logR if self._logR: self._rgrid= numpy.exp(self._rgrid) self._logrgrid= numpy.log(self._rgrid) self._zgrid= numpy.linspace(*zgrid) self._interpPot= interpPot self._interpRforce= interpRforce self._interpzforce= interpzforce self._interpDens= interpDens self._interpvcirc= interpvcirc self._interpdvcircdr= interpdvcircdr self._interpepifreq= interpepifreq self._interpverticalfreq= interpverticalfreq self._enable_c= enable_c*ext_loaded self._zsym= zsym if interpPot: if use_c*ext_loaded: self._potGrid, err= calc_potential_c(self._origPot,self._rgrid,self._zgrid) else: from galpy.potential import evaluatePotentials potGrid= numpy.zeros((len(self._rgrid),len(self._zgrid))) for ii in range(len(self._rgrid)): for jj in range(len(self._zgrid)): potGrid[ii,jj]= evaluatePotentials(self._rgrid[ii],self._zgrid[jj],self._origPot) self._potGrid= potGrid if self._logR: self._potInterp= interpolate.RectBivariateSpline(self._logrgrid, self._zgrid, self._potGrid, kx=3,ky=3,s=0.) else: self._potInterp= interpolate.RectBivariateSpline(self._rgrid, self._zgrid, self._potGrid, kx=3,ky=3,s=0.) if enable_c*ext_loaded: self._potGrid_splinecoeffs= calc_2dsplinecoeffs_c(self._potGrid) if interpRforce: if use_c*ext_loaded: self._rforceGrid, err= calc_potential_c(self._origPot,self._rgrid,self._zgrid,rforce=True) else: from galpy.potential import evaluateRforces rforceGrid= numpy.zeros((len(self._rgrid),len(self._zgrid))) for ii in range(len(self._rgrid)): for jj in range(len(self._zgrid)): rforceGrid[ii,jj]= evaluateRforces(self._rgrid[ii],self._zgrid[jj],self._origPot) self._rforceGrid= rforceGrid if self._logR: self._rforceInterp= interpolate.RectBivariateSpline(self._logrgrid, self._zgrid, self._rforceGrid, kx=3,ky=3,s=0.) else: self._rforceInterp= interpolate.RectBivariateSpline(self._rgrid, self._zgrid, self._rforceGrid, kx=3,ky=3,s=0.) if enable_c*ext_loaded: self._rforceGrid_splinecoeffs= calc_2dsplinecoeffs_c(self._rforceGrid) if interpzforce: if use_c*ext_loaded: self._zforceGrid, err= calc_potential_c(self._origPot,self._rgrid,self._zgrid,zforce=True) else: from galpy.potential import evaluatezforces zforceGrid= numpy.zeros((len(self._rgrid),len(self._zgrid))) for ii in range(len(self._rgrid)): for jj in range(len(self._zgrid)): zforceGrid[ii,jj]= evaluatezforces(self._rgrid[ii],self._zgrid[jj],self._origPot) self._zforceGrid= zforceGrid if self._logR: self._zforceInterp= interpolate.RectBivariateSpline(self._logrgrid, self._zgrid, self._zforceGrid, kx=3,ky=3,s=0.) else: self._zforceInterp= interpolate.RectBivariateSpline(self._rgrid, self._zgrid, self._zforceGrid, kx=3,ky=3,s=0.) if enable_c*ext_loaded: self._zforceGrid_splinecoeffs= calc_2dsplinecoeffs_c(self._zforceGrid) if interpDens: if False: raise NotImplementedError("Using C to calculate an interpolation grid for the density is not supported currently") self._densGrid, err= calc_dens_c(self._origPot,self._rgrid,self._zgrid) else: from galpy.potential import evaluateDensities densGrid= numpy.zeros((len(self._rgrid),len(self._zgrid))) for ii in range(len(self._rgrid)): for jj in range(len(self._zgrid)): densGrid[ii,jj]= evaluateDensities(self._rgrid[ii],self._zgrid[jj],self._origPot) self._densGrid= densGrid if self._logR: self._densInterp= interpolate.RectBivariateSpline(self._logrgrid, self._zgrid, numpy.log(self._densGrid+10.**-10.), kx=3,ky=3,s=0.) else: self._densInterp= interpolate.RectBivariateSpline(self._rgrid, self._zgrid, numpy.log(self._densGrid+10.**-10.), kx=3,ky=3,s=0.) if False: self._densGrid_splinecoeffs= calc_2dsplinecoeffs_c(self._densGrid) if interpvcirc: from galpy.potential import vcirc if not numcores is None: self._vcircGrid= multi.parallel_map((lambda x: vcirc(self._origPot,self._rgrid[x])), range(len(self._rgrid)),numcores=numcores) else: self._vcircGrid= numpy.array([vcirc(self._origPot,r) for r in self._rgrid]) if self._logR: self._vcircInterp= interpolate.InterpolatedUnivariateSpline(self._logrgrid,self._vcircGrid,k=3) else: self._vcircInterp= interpolate.InterpolatedUnivariateSpline(self._rgrid,self._vcircGrid,k=3) if interpdvcircdr: from galpy.potential import dvcircdR if not numcores is None: self._dvcircdrGrid= multi.parallel_map((lambda x: dvcircdR(self._origPot,self._rgrid[x])), range(len(self._rgrid)),numcores=numcores) else: self._dvcircdrGrid= numpy.array([dvcircdR(self._origPot,r) for r in self._rgrid]) if self._logR: self._dvcircdrInterp= interpolate.InterpolatedUnivariateSpline(self._logrgrid,self._dvcircdrGrid,k=3) else: self._dvcircdrInterp= interpolate.InterpolatedUnivariateSpline(self._rgrid,self._dvcircdrGrid,k=3) if interpepifreq: from galpy.potential import epifreq if not numcores is None: self._epifreqGrid= multi.parallel_map((lambda x: epifreq(self._origPot,self._rgrid[x])), range(len(self._rgrid)),numcores=numcores) else: self._epifreqGrid= numpy.array([epifreq(self._origPot,r) for r in self._rgrid]) indx= True-numpy.isnan(self._epifreqGrid) if numpy.sum(indx) < 4: if self._logR: self._epifreqInterp= interpolate.InterpolatedUnivariateSpline(self._logrgrid[indx],self._epifreqGrid[indx],k=1) else: self._epifreqInterp= interpolate.InterpolatedUnivariateSpline(self._rgrid[indx],self._epifreqGrid[indx],k=1) else: if self._logR: self._epifreqInterp= interpolate.InterpolatedUnivariateSpline(self._logrgrid[indx],self._epifreqGrid[indx],k=3) else: self._epifreqInterp= interpolate.InterpolatedUnivariateSpline(self._rgrid[indx],self._epifreqGrid[indx],k=3) if interpverticalfreq: from galpy.potential import verticalfreq if not numcores is None: self._verticalfreqGrid= multi.parallel_map((lambda x: verticalfreq(self._origPot,self._rgrid[x])), range(len(self._rgrid)),numcores=numcores) else: self._verticalfreqGrid= numpy.array([verticalfreq(self._origPot,r) for r in self._rgrid]) if self._logR: self._verticalfreqInterp= interpolate.InterpolatedUnivariateSpline(self._logrgrid,self._verticalfreqGrid,k=3) else: self._verticalfreqInterp= interpolate.InterpolatedUnivariateSpline(self._rgrid,self._verticalfreqGrid,k=3) return None
def calc_model(params,options,data,vs,normintstuff=None): out= numpy.zeros((len(data),options.nv)) #Model vo= get_vo(params,options,1) ro= get_ro(params,options) pot= setup_potential(params,options,1) aA= setup_aA(pot,options) dfparams= get_dfparams(params,0,options,log=False) if options.dfmodel.lower() == 'qdf': #Normalize hr= dfparams[0]/ro sr= dfparams[1]/vo sz= dfparams[2]/vo hsr= dfparams[3]/ro hsz= dfparams[4]/ro #Setup qdf= quasiisothermaldf(hr,sr,sz,hsr,hsz,pot=pot,aA=aA,cutcounter=True) if not params[6] == 0.: print "Calculating normalization of qdf ..." normalization_qdf= calc_normint(qdf,0,normintstuff,params,1,options, -numpy.finfo(numpy.dtype(numpy.float64)).max) print "Calculating normalization of outliers ..." normalization_out= calc_normint(qdf,0,normintstuff,params,1,options, 0.,fqdf=0.) else: normalization_qdf= 0. normalization_out= 1. #Get coordinates R= ((ro*_REFR0-data.xc)**2.+data.yc**2.)**(0.5)/ro/_REFR0 z= (data.zc+_ZSUN)/ro/_REFR0 if 'vr' in options.type.lower() or 'vt' in options.type.lower(): cov_vxvyvz= numpy.zeros((len(data),3,3)) cov_vxvyvz[:,0,0]= data.vxc_err**2. cov_vxvyvz[:,1,1]= data.vyc_err**2. cov_vxvyvz[:,2,2]= data.vzc_err**2. cov_vxvyvz[:,0,1]= data.vxvyc_rho*data.vxc_err*data.vyc_err cov_vxvyvz[:,0,2]= data.vxvzc_rho*data.vxc_err*data.vzc_err cov_vxvyvz[:,1,2]= data.vyvzc_rho*data.vyc_err*data.vzc_err #Rotate vxvyvz to vRvTvz cosphi= (_REFR0*ro-data.xc)/R/ro/_REFR0 sinphi= data.yc/R/ro/_REFR0 for rr in range(len(data.xc)): rot= numpy.array([[cosphi[rr],sinphi[rr]], [-sinphi[rr],cosphi[rr]]]) sxy= cov_vxvyvz[rr,0:2,0:2] sRT= numpy.dot(rot,numpy.dot(sxy,rot.T)) cov_vxvyvz[rr,0:2,0:2]= sRT else: cov_vxvyvz= None # FOR MULTI if not options.multi is None: multOut= multi.parallel_map((lambda x: _calc_model_one(x,R,z,vs,qdf,options,data,params,cov_vxvyvz,vo,norm=normalization_qdf/normalization_out/12.)), range(len(data)), numcores=numpy.amin([len(data), multiprocessing.cpu_count(), options.multi])) for ii in range(len(data)): out[ii,:]= multOut[ii] else: for ii in range(len(data)): if options.type.lower() == 'vz': #thisp= numpy.array([qdf.pvz(v/_REFV0/vo,R[ii],z[ii],ngl=options.ngl,gl=True) for v in vs]) thisp= qdf.pvz(vs/_REFV0/vo,R[ii]+numpy.zeros(len(vs)),z[ii]+numpy.zeros(len(vs)),ngl=options.ngl,gl=True) if not params[6] == 0.: thisp+= params[6]*normalization_qdf/normalization_out/12./_SZHALO*_REFV0*vo*numpy.exp(-0.5*vs**2./_SZHALO**2.)*vo**2./numpy.sqrt(2.*math.pi) ndimage.filters.gaussian_filter1d(thisp, data.vzc_err[ii]/(vs[1]-vs[0]), output=thisp) elif options.type.lower() == 'vr': thisp= numpy.array([qdf.pvR(v/_REFV0/vo,R[ii],z[ii],ngl=options.ngl,gl=True) for v in vs]) ndimage.filters.gaussian_filter1d(thisp, numpy.sqrt(cov_vxvyvz[ii,0,0])/(vs[1]-vs[0]), output=thisp) elif options.type.lower() == 'vt': if options.fitdvt: dvt= get_dvt(params,options) else: dvt= 0. thisp= numpy.array([qdf.pvT(v/_REFV0/vo+dvt/vo,R[ii],z[ii],ngl=options.ngl,gl=True) for v in vs]) ndimage.filters.gaussian_filter1d(thisp, numpy.sqrt(cov_vxvyvz[ii,1,1])/(vs[1]-vs[0]), output=thisp) out[ii,:]= thisp/numpy.sum(thisp)/(vs[1]-vs[0]) return out
def generate(locations, type='exp', sample='lowlow', extmap='green15', nls=101, nmock=1000, H0=-1.49, _dmapg15=None, ncpu=1): """ NAME: generate PURPOSE: generate mock data following a given density INPUT: locations - locations to be included in the sample type= ('exp') type of density profile to sample from sample= ('lowlow') for selecting mock parameters extmap= ('green15') extinction map to use ('marshall06' and others use Green15 to fill in unobserved regions) nls= (101) number of longitude bins to use for each field nmock= (1000) number of mock data points to generate H0= (-1.49) absolute magnitude (can be array w/ sampling spread) ncpu= (1) number of cpus to use to compute the probability OUTPUT: mockdata recarray with tags 'RC_GALR_H', 'RC_GALPHI_H', 'RC_GALZ_H' HISTORY: 2015-04-03 - Written - Bovy (IAS) """ if isinstance(H0, float): H0 = [H0] # Setup the density function and its initial parameters rdensfunc = fitDens._setup_densfunc(type) mockparams = _setup_mockparams_densfunc(type, sample) densfunc = lambda x, y, z: rdensfunc(x, y, z, params=mockparams) # Setup the extinction map global dmap global dmapg15 if _dmapg15 is None: dmapg15 = mwdust.Green15(filter='2MASS H') else: dmapg15 = _dmapg15 if isinstance(extmap, mwdust.DustMap3D.DustMap3D): dmap = extmap elif extmap.lower() == 'green15': dmap = dmapg15 elif extmap.lower() == 'marshall06': dmap = mwdust.Marshall06(filter='2MASS H') elif extmap.lower() == 'sale14': dmap = mwdust.Sale14(filter='2MASS H') elif extmap.lower() == 'drimmel03': dmap = mwdust.Drimmel03(filter='2MASS H') # Use brute-force rejection sampling to make no approximations # First need to estimate the max probability to use in rejection; # Loop through all locations and compute sampling probability on grid in # (l,b,D) # First restore the APOGEE selection function (assumed pre-computed) global apo selectFile = '../savs/selfunc-nospdata.sav' if os.path.exists(selectFile): with open(selectFile, 'rb') as savefile: apo = pickle.load(savefile) # Now compute the necessary coordinate transformations and evaluate the # maximum probability distmods = numpy.linspace(7., 15.5, 301) ds = 10.**(distmods / 5 - 2.) nbs = nls lnprobs = numpy.empty((len(locations), len(distmods), nbs, nls)) radii = [] lcens, bcens = [], [] lnprobs = multi.parallel_map(lambda x: _calc_lnprob( locations[x], nls, nbs, ds, distmods, H0, densfunc), range(len(locations)), numcores=numpy.amin([ len(locations), multiprocessing.cpu_count(), ncpu ])) lnprobs = numpy.array(lnprobs) for ll, loc in enumerate(locations): lcen, bcen = apo.glonGlat(loc) rad = apo.radius(loc) radii.append(rad) # save for later lcens.append(lcen[0]) bcens.append(bcen[0]) maxp = (numpy.exp(numpy.nanmax(lnprobs)) - 10.**-8.) * 1.1 # Just to be sure # Now generate mock data using rejection sampling nout = 0 arlocations = numpy.array(locations) arradii = numpy.array(radii) arlcens = numpy.array(lcens) arbcens = numpy.array(bcens) out = numpy.recarray((nmock, ), dtype=[('RC_DIST_H', 'f8'), ('RC_DM_H', 'f8'), ('RC_GALR_H', 'f8'), ('RC_GALPHI_H', 'f8'), ('RC_GALZ_H', 'f8')]) while nout < nmock: nnew = 2 * (nmock - nout) # nnew new locations locIndx = numpy.floor( numpy.random.uniform(size=nnew) * len(locations)).astype('int') newlocations = arlocations[locIndx] # Point within these locations newds_coord = numpy.random.uniform(size=nnew) newds= 10.**((newds_coord*(numpy.amax(distmods)-numpy.amin(distmods))\ +numpy.amin(distmods))/5.-2.) newdls_coord = numpy.random.uniform(size=nnew) newdls= newdls_coord*2.*arradii[locIndx]\ -arradii[locIndx] newdbs_coord = numpy.random.uniform(size=nnew) newdbs= newdbs_coord*2.*arradii[locIndx]\ -arradii[locIndx] newr2s = newdls**2. + newdbs**2. keepIndx = newr2s < arradii[locIndx]**2. newlocations = newlocations[keepIndx] newds_coord = newds_coord[keepIndx] newdls_coord = newdls_coord[keepIndx] newdbs_coord = newdbs_coord[keepIndx] newds = newds[keepIndx] newdls = newdls[keepIndx] newdbs = newdbs[keepIndx] newls = newdls + arlcens[locIndx][keepIndx] newbs = newdbs + arbcens[locIndx][keepIndx] # Reject? tps = numpy.zeros_like(newds) for nloc in list(set(newlocations)): lindx = newlocations == nloc pindx = arlocations == nloc coord = numpy.array([ newds_coord[lindx] * (len(distmods) - 1.), newdbs_coord[lindx] * (nbs - 1.), newdls_coord[lindx] * (nls - 1.) ]) tps[lindx]= \ numpy.exp(ndimage.interpolation.map_coordinates(\ lnprobs[pindx][0], coord,cval=-10., order=1))-10.**-8. XYZ = bovy_coords.lbd_to_XYZ(newls, newbs, newds, degree=True) Rphiz = bovy_coords.XYZ_to_galcencyl(XYZ[:, 0], XYZ[:, 1], XYZ[:, 2], Xsun=define_rcsample._R0, Ysun=0., Zsun=define_rcsample._Z0) testp = numpy.random.uniform(size=len(newds)) * maxp keepIndx = tps > testp if numpy.sum(keepIndx) > nmock - nout: rangeIndx = numpy.zeros(len(keepIndx), dtype='int') rangeIndx[keepIndx] = numpy.arange(numpy.sum(keepIndx)) keepIndx *= (rangeIndx < nmock - nout) out['RC_DIST_H'][nout:nout + numpy.sum(keepIndx)] = newds[keepIndx] out['RC_DM_H'][nout:nout+numpy.sum(keepIndx)]= newds_coord[keepIndx]*(numpy.amax(distmods)-numpy.amin(distmods))\ +numpy.amin(distmods) out['RC_GALR_H'][nout:nout + numpy.sum(keepIndx)] = Rphiz[0][keepIndx] out['RC_GALPHI_H'][nout:nout + numpy.sum(keepIndx)] = Rphiz[1][keepIndx] out['RC_GALZ_H'][nout:nout + numpy.sum(keepIndx)] = Rphiz[2][keepIndx] nout = nout + numpy.sum(keepIndx) return (out, lnprobs)
def create_frames(options, args): # First reload the model with open('gd1pepper%isampling.pkl' % options.nsnap, 'rb') as savefile: sdf_pepper_leading = pickle.load(savefile) with open('gd1pepper%isampling_trailing.pkl' % options.nsnap, 'rb') as savefile: sdf_pepper_trailing = pickle.load(savefile) # Output times timpacts = sdf_pepper_leading._uniq_timpact # Sample unperturbed aAt numpy.random.seed(1) Oml,anglel,dtl= super(streampepperdf,sdf_pepper_leading)._sample_aAt(\ options.nparticles) Omt,anglet,dtt= super(streampepperdf,sdf_pepper_trailing)._sample_aAt(\ options.nparticles) # Setup progenitor prog = sdf_pepper_leading._progenitor().flip() prog.integrate( numpy.linspace(0., 9. / bovy_conversion.time_in_Gyr(V0, R0), 10001), sdf_pepper_leading._pot) prog.flip() # Setup impacts if options.single: # Hit the leading arm and the trailing arm 1 Gyr later m = options.singlemimpact / bovy_conversion.mass_in_1010msol( V0, R0) / 1000. t= timpacts[\ numpy.argmin(\ numpy.fabs(\ numpy.array(timpacts)\ -options.singletimpact\ /bovy_conversion.time_in_Gyr(V0,R0)))] sdf_pepper_leading.set_impacts(\ impactb=[0.5*simulate_streampepper.rs(options.singlemimpact*10.**7.)], subhalovel=numpy.array([[-25.,155.,30.]])/V0, impact_angle=[0.2], timpact=[t], GM=[m],rs=[simulate_streampepper.rs(options.singlemimpact*10.**7.)]) # Trailing m = options.singlemimpact / bovy_conversion.mass_in_1010msol( V0, R0) / 1000. t= timpacts[\ numpy.argmin(\ numpy.fabs(\ numpy.array(timpacts)\ -(options.singletimpact+1.)\ /bovy_conversion.time_in_Gyr(V0,R0)))] sdf_pepper_trailing.set_impacts(\ impactb=[1.*simulate_streampepper.rs(options.singlemimpact*10.**7.)], subhalovel=numpy.array([[-25.,155.,30.]])/V0, impact_angle=[-0.3], timpact=[t], GM=[m],rs=[simulate_streampepper.rs(options.singlemimpact*10.**7.)]) elif options.pepper: # Sampling functions massrange = [options.Mmin, options.Mmax] plummer = False Xrs = 5. nsubhalo = simulate_streampepper.nsubhalo rs = simulate_streampepper.rs dNencdm = simulate_streampepper.dNencdm sample_GM= lambda: (10.**((-0.5)*massrange[0])\ +(10.**((-0.5)*massrange[1])\ -10.**((-0.5)*massrange[0]))\ *numpy.random.uniform())**(1./(-0.5))\ /bovy_conversion.mass_in_msol(V0,R0) rate_range = numpy.arange(massrange[0] + 0.5, massrange[1] + 0.5, 1) rate = numpy.sum([ dNencdm(sdf_pepper_leading, 10.**r, Xrs=Xrs, plummer=plummer) for r in rate_range ]) rate = options.timescdm * rate sample_rs = lambda x: rs(x * bovy_conversion.mass_in_1010msol(V0, R0) * 10.**10., plummer=plummer) # Pepper both sdf_pepper_leading.simulate(rate=rate, sample_GM=sample_GM, sample_rs=sample_rs, Xrs=Xrs) print numpy.amax( sdf_pepper_leading._GM) * bovy_conversion.mass_in_1010msol(V0, R0) sdf_pepper_trailing.simulate(rate=rate, sample_GM=sample_GM, sample_rs=sample_rs, Xrs=Xrs) print numpy.amax( sdf_pepper_trailing._GM) * bovy_conversion.mass_in_1010msol( V0, R0) else: # Hit both with zero sdf_pepper_leading.set_impacts(\ impactb=[0.], subhalovel=numpy.array([[-25.,155.,30.]])/V0, impact_angle=[0.2], timpact=[timpacts[0]], GM=[0.],rs=[1.]) sdf_pepper_trailing.set_impacts(\ impactb=[0.], subhalovel=numpy.array([[-25.,155.,30.]])/V0, impact_angle=[-0.2], timpact=[timpacts[0]], GM=[0.],rs=[1.]) # Now make all frames dum = multi.parallel_map((lambda x: _plot_one_frame( x, options, prog, timpacts, sdf_pepper_leading, sdf_pepper_trailing, Oml, Omt, anglel, anglet, dtl, dtt)), range(len(timpacts)), numcores=numpy.amin([len(timpacts), 30])) return None
def __init__(self,pot=None,delta=None,Rmax=5., nE=25,npsi=25,nLz=30,numcores=1, **kwargs): """ NAME: __init__ PURPOSE: initialize an actionAngleStaeckelGrid object INPUT: pot= potential or list of potentials delta= focus of prolate confocal coordinate system (can be Quantity) Rmax = Rmax for building grids (natural units) nE=, npsi=, nLz= grid size numcores= number of cpus to use to parallellize ro= distance from vantage point to GC (kpc; can be Quantity) vo= circular velocity at ro (km/s; can be Quantity) OUTPUT: instance HISTORY: 2012-11-29 - Written - Bovy (IAS) """ actionAngle.__init__(self, ro=kwargs.get('ro',None),vo=kwargs.get('vo',None)) if pot is None: raise IOError("Must specify pot= for actionAngleStaeckelGrid") self._pot= pot if delta is None: raise IOError("Must specify delta= for actionAngleStaeckelGrid") if ext_loaded and 'c' in kwargs and kwargs['c']: self._c= True else: self._c= False self._delta= delta if _APY_LOADED and isinstance(self._delta,units.Quantity): self._delta= self._delta.to(units.kpc).value/self._ro self._Rmax= Rmax self._Rmin= 0.01 #Set up the actionAngleStaeckel object that we will use to interpolate self._aA= actionAngleStaeckel.actionAngleStaeckel(pot=self._pot,delta=self._delta,c=self._c) #Build grid self._Lzmin= 0.01 self._Lzs= numpy.linspace(self._Lzmin, self._Rmax\ *galpy.potential.vcirc(self._pot, self._Rmax), nLz) self._Lzmax= self._Lzs[-1] self._nLz= nLz #Calculate E_c(R=RL), energy of circular orbit self._RL= numpy.array([galpy.potential.rl(self._pot,l) for l in self._Lzs]) self._RLInterp= interpolate.InterpolatedUnivariateSpline(self._Lzs, self._RL,k=3) self._ERL= _evaluatePotentials(self._pot,self._RL, numpy.zeros(self._nLz))\ +self._Lzs**2./2./self._RL**2. self._ERLmax= numpy.amax(self._ERL)+1. self._ERLInterp= interpolate.InterpolatedUnivariateSpline(self._Lzs, numpy.log(-(self._ERL-self._ERLmax)),k=3) self._Ramax= 200./8. self._ERa= _evaluatePotentials(self._pot,self._Ramax,0.) +self._Lzs**2./2./self._Ramax**2. #self._EEsc= numpy.array([self._ERL[ii]+galpy.potential.vesc(self._pot,self._RL[ii])**2./4. for ii in range(nLz)]) self._ERamax= numpy.amax(self._ERa)+1. self._ERaInterp= interpolate.InterpolatedUnivariateSpline(self._Lzs, numpy.log(-(self._ERa-self._ERamax)),k=3) y= numpy.linspace(0.,1.,nE) self._nE= nE psis= numpy.linspace(0.,1.,npsi)*numpy.pi/2. self._npsi= npsi jr= numpy.zeros((nLz,nE,npsi)) jz= numpy.zeros((nLz,nE,npsi)) u0= numpy.zeros((nLz,nE)) jrLzE= numpy.zeros((nLz)) jzLzE= numpy.zeros((nLz)) #First calculate u0 thisLzs= (numpy.tile(self._Lzs,(nE,1)).T).flatten() thisERL= (numpy.tile(self._ERL,(nE,1)).T).flatten() thisERa= (numpy.tile(self._ERa,(nE,1)).T).flatten() thisy= (numpy.tile(y,(nLz,1))).flatten() thisE= _invEfunc(_Efunc(thisERa,thisERL)+thisy*(_Efunc(thisERL,thisERL)-_Efunc(thisERa,thisERL)),thisERL) if isinstance(self._pot,galpy.potential.interpRZPotential) and hasattr(self._pot,'_origPot'): u0pot= self._pot._origPot else: u0pot= self._pot if self._c: mu0= actionAngleStaeckel_c.actionAngleStaeckel_calcu0(thisE,thisLzs, u0pot, self._delta)[0] else: if numcores > 1: mu0= multi.parallel_map((lambda x: self.calcu0(thisE[x], thisLzs[x])), range(nE*nLz), numcores=numcores) else: mu0= list(map((lambda x: self.calcu0(thisE[x], thisLzs[x])), range(nE*nLz))) u0= numpy.reshape(mu0,(nLz,nE)) thisR= self._delta*numpy.sinh(u0) thisv= numpy.reshape(self.vatu0(thisE.flatten(),thisLzs.flatten(), u0.flatten(), thisR.flatten()),(nLz,nE)) self.thisv= thisv #reshape thisLzs= numpy.reshape(thisLzs,(nLz,nE)) thispsi= numpy.tile(psis,(nLz,nE,1)).flatten() thisLzs= numpy.tile(thisLzs.T,(npsi,1,1)).T.flatten() thisR= numpy.tile(thisR.T,(npsi,1,1)).T.flatten() thisv= numpy.tile(thisv.T,(npsi,1,1)).T.flatten() mjr, mlz, mjz= self._aA(thisR, #R thisv*numpy.cos(thispsi), #vR thisLzs/thisR, #vT numpy.zeros(len(thisR)), #z thisv*numpy.sin(thispsi), #vz fixed_quad=True) if isinstance(self._pot,galpy.potential.interpRZPotential) and hasattr(self._pot,'_origPot'): #Interpolated potentials have problems with extreme orbits indx= (mjr == 9999.99) indx+= (mjz == 9999.99) #Re-calculate these using the original potential, hopefully not too slow tmpaA= actionAngleStaeckel.actionAngleStaeckel(pot=self._pot._origPot,delta=self._delta,c=self._c) mjr[indx], dum, mjz[indx]= tmpaA(thisR[indx], #R thisv[indx]*numpy.cos(thispsi[indx]), #vR thisLzs[indx]/thisR[indx], #vT numpy.zeros(numpy.sum(indx)), #z thisv[indx]*numpy.sin(thispsi[indx]), #vz fixed_quad=True) jr= numpy.reshape(mjr,(nLz,nE,npsi)) jz= numpy.reshape(mjz,(nLz,nE,npsi)) for ii in range(nLz): jrLzE[ii]= numpy.nanmax(jr[ii,(jr[ii,:,:] != 9999.99)])#:,:]) jzLzE[ii]= numpy.nanmax(jz[ii,(jz[ii,:,:] != 9999.99)])#:,:]) jrLzE[(jrLzE == 0.)]= numpy.nanmin(jrLzE[(jrLzE > 0.)]) jzLzE[(jzLzE == 0.)]= numpy.nanmin(jzLzE[(jzLzE > 0.)]) for ii in range(nLz): jr[ii,:,:]/= jrLzE[ii] jz[ii,:,:]/= jzLzE[ii] #Deal w/ 9999.99 jr[(jr > 1.)]= 1. jz[(jz > 1.)]= 1. #Deal w/ NaN jr[numpy.isnan(jr)]= 0. jz[numpy.isnan(jz)]= 0. #First interpolate the maxima self._jr= jr self._jz= jz self._u0= u0 self._jrLzE= jrLzE self._jzLzE= jzLzE self._jrLzInterp= interpolate.InterpolatedUnivariateSpline(self._Lzs, numpy.log(jrLzE+10.**-5.),k=3) self._jzLzInterp= interpolate.InterpolatedUnivariateSpline(self._Lzs, numpy.log(jzLzE+10.**-5.),k=3) #Interpolate u0 self._logu0Interp= interpolate.RectBivariateSpline(self._Lzs, y, numpy.log(u0), kx=3,ky=3,s=0.) #spline filter jr and jz, such that they can be used with ndimage.map_coordinates self._jrFiltered= ndimage.spline_filter(numpy.log(self._jr+10.**-10.),order=3) self._jzFiltered= ndimage.spline_filter(numpy.log(self._jz+10.**-10.),order=3) # Check the units self._check_consistent_units() return None
def generate(locations, type='exp', sample='lowlow', extmap='green15', nls=101, nmock=1000, H0=-1.49, _dmapg15=None, ncpu=1): """ NAME: generate PURPOSE: generate mock data following a given density INPUT: locations - locations to be included in the sample type= ('exp') type of density profile to sample from sample= ('lowlow') for selecting mock parameters extmap= ('green15') extinction map to use ('marshall06' and others use Green15 to fill in unobserved regions) nls= (101) number of longitude bins to use for each field nmock= (1000) number of mock data points to generate H0= (-1.49) absolute magnitude (can be array w/ sampling spread) ncpu= (1) number of cpus to use to compute the probability OUTPUT: mockdata recarray with tags 'RC_GALR_H', 'RC_GALPHI_H', 'RC_GALZ_H' HISTORY: 2015-04-03 - Written - Bovy (IAS) """ if isinstance(H0,float): H0= [H0] # Setup the density function and its initial parameters rdensfunc= fitDens._setup_densfunc(type) mockparams= _setup_mockparams_densfunc(type,sample) densfunc= lambda x,y,z: rdensfunc(x,y,z,params=mockparams) # Setup the extinction map global dmap global dmapg15 if _dmapg15 is None: dmapg15= mwdust.Green15(filter='2MASS H') else: dmapg15= _dmapg15 if isinstance(extmap,mwdust.DustMap3D.DustMap3D): dmap= extmap elif extmap.lower() == 'green15': dmap= dmapg15 elif extmap.lower() == 'marshall06': dmap= mwdust.Marshall06(filter='2MASS H') elif extmap.lower() == 'sale14': dmap= mwdust.Sale14(filter='2MASS H') elif extmap.lower() == 'drimmel03': dmap= mwdust.Drimmel03(filter='2MASS H') # Use brute-force rejection sampling to make no approximations # First need to estimate the max probability to use in rejection; # Loop through all locations and compute sampling probability on grid in # (l,b,D) # First restore the APOGEE selection function (assumed pre-computed) global apo selectFile= '../savs/selfunc-nospdata.sav' if os.path.exists(selectFile): with open(selectFile,'rb') as savefile: apo= pickle.load(savefile) # Now compute the necessary coordinate transformations and evaluate the # maximum probability distmods= numpy.linspace(7.,15.5,301) ds= 10.**(distmods/5-2.) nbs= nls lnprobs= numpy.empty((len(locations),len(distmods),nbs,nls)) radii= [] lcens, bcens= [], [] lnprobs= multi.parallel_map(lambda x: _calc_lnprob(locations[x],nls,nbs, ds,distmods, H0, densfunc), range(len(locations)), numcores=numpy.amin([len(locations), multiprocessing.cpu_count(),ncpu])) lnprobs= numpy.array(lnprobs) for ll, loc in enumerate(locations): lcen, bcen= apo.glonGlat(loc) rad= apo.radius(loc) radii.append(rad) # save for later lcens.append(lcen[0]) bcens.append(bcen[0]) maxp= (numpy.exp(numpy.nanmax(lnprobs))-10.**-8.)*1.1 # Just to be sure # Now generate mock data using rejection sampling nout= 0 arlocations= numpy.array(locations) arradii= numpy.array(radii) arlcens= numpy.array(lcens) arbcens= numpy.array(bcens) out= numpy.recarray((nmock,), dtype=[('RC_DIST_H','f8'), ('RC_DM_H','f8'), ('RC_GALR_H','f8'), ('RC_GALPHI_H','f8'), ('RC_GALZ_H','f8')]) while nout < nmock: nnew= 2*(nmock-nout) # nnew new locations locIndx= numpy.floor(numpy.random.uniform(size=nnew)*len(locations)).astype('int') newlocations= arlocations[locIndx] # Point within these locations newds_coord= numpy.random.uniform(size=nnew) newds= 10.**((newds_coord*(numpy.amax(distmods)-numpy.amin(distmods))\ +numpy.amin(distmods))/5.-2.) newdls_coord= numpy.random.uniform(size=nnew) newdls= newdls_coord*2.*arradii[locIndx]\ -arradii[locIndx] newdbs_coord= numpy.random.uniform(size=nnew) newdbs= newdbs_coord*2.*arradii[locIndx]\ -arradii[locIndx] newr2s= newdls**2.+newdbs**2. keepIndx= newr2s < arradii[locIndx]**2. newlocations= newlocations[keepIndx] newds_coord= newds_coord[keepIndx] newdls_coord= newdls_coord[keepIndx] newdbs_coord= newdbs_coord[keepIndx] newds= newds[keepIndx] newdls= newdls[keepIndx] newdbs= newdbs[keepIndx] newls= newdls+arlcens[locIndx][keepIndx] newbs= newdbs+arbcens[locIndx][keepIndx] # Reject? tps= numpy.zeros_like(newds) for nloc in list(set(newlocations)): lindx= newlocations == nloc pindx= arlocations == nloc coord= numpy.array([newds_coord[lindx]*(len(distmods)-1.), newdbs_coord[lindx]*(nbs-1.), newdls_coord[lindx]*(nls-1.)]) tps[lindx]= \ numpy.exp(ndimage.interpolation.map_coordinates(\ lnprobs[pindx][0], coord,cval=-10., order=1))-10.**-8. XYZ= bovy_coords.lbd_to_XYZ(newls,newbs,newds,degree=True) Rphiz= bovy_coords.XYZ_to_galcencyl(XYZ[:,0],XYZ[:,1],XYZ[:,2], Xsun=define_rcsample._R0, Ysun=0., Zsun=define_rcsample._Z0) testp= numpy.random.uniform(size=len(newds))*maxp keepIndx= tps > testp if numpy.sum(keepIndx) > nmock-nout: rangeIndx= numpy.zeros(len(keepIndx),dtype='int') rangeIndx[keepIndx]= numpy.arange(numpy.sum(keepIndx)) keepIndx*= (rangeIndx < nmock-nout) out['RC_DIST_H'][nout:nout+numpy.sum(keepIndx)]= newds[keepIndx] out['RC_DM_H'][nout:nout+numpy.sum(keepIndx)]= newds_coord[keepIndx]*(numpy.amax(distmods)-numpy.amin(distmods))\ +numpy.amin(distmods) out['RC_GALR_H'][nout:nout+numpy.sum(keepIndx)]= Rphiz[0][keepIndx] out['RC_GALPHI_H'][nout:nout+numpy.sum(keepIndx)]= Rphiz[1][keepIndx] out['RC_GALZ_H'][nout:nout+numpy.sum(keepIndx)]= Rphiz[2][keepIndx] nout= nout+numpy.sum(keepIndx) return (out,lnprobs)
def plot_vs_jkz(parser): options,args= parser.parse_args() if options.basti: zs= numpy.array([0.004,0.008,0.01,0.0198,0.03,0.04]) elif options.parsec: zs= numpy.arange(0.0005,0.06005,0.0005) else: zs= numpy.arange(0.0005,0.03005,0.0005) if os.path.exists(args[0]): savefile= open(args[0],'rb') plotthis= pickle.load(savefile) jks= pickle.load(savefile) zs= pickle.load(savefile) savefile.close() else: njks= 101 jks= numpy.linspace(0.5,0.8,njks) plotthis= numpy.zeros((njks,len(zs))) funcargs= (zs,options,njks,jks) multOut= multi.parallel_map((lambda x: indiv_calc(x, *funcargs)), range(len(zs)), numcores=numpy.amin([64,len(zs), multiprocessing.cpu_count()])) for ii in range(len(zs)): plotthis[:,ii]= multOut[ii] #Save save_pickles(args[0],plotthis,jks,zs) #Plot if options.type == 'sig': if options.band.lower() == 'age': if options.relative: raise NotImplementedError("relative age not implemented yet") else: vmin, vmax= 0.,.5 zlabel= r'$\mathrm{FWHM} / 2\sqrt{2\,\ln 2}$' else: if options.relative: vmin, vmax= 0.8,1.2 zlabel= r'$\mathrm{FWHM}/\mathrm{FWHM}_{\mathrm{fiducial}}$' else: vmin, vmax= 0., 0.4 zlabel= r'$\mathrm{FWHM} / 2\sqrt{2\,\ln 2}$' elif options.type == 'mode': if options.band.lower() == 'age': if options.relative: raise NotImplementedError("relative age not implemented yet") else: vmin, vmax= 0.,1. zlabel= r'$\Delta\displaystyle\arg\!\max_{\substack{\log_{10}\mathrm{Age}}}{p(\log_{10}\mathrm{Age}|[J-K_s]_0)}$' else: if options.relative: vmin, vmax= -0.05,0.05 zlabel= r'$\Delta\displaystyle\arg\!\max_{\substack{K_s}}{p(M_{K_s}|[J-K_s]_0)}$' else: vmin, vmax= -1.8, -1.5 if options.band.lower() == 'h': zlabel= r'$\displaystyle\arg\!\max_{\substack{H}}{p(M_{H}|[J-K_s]_0)}$' else: zlabel= r'$\displaystyle\arg\!\max_{\substack{K_s}}{p(M_{K_s}|[J-K_s]_0)}$' if options.basti:#Remap the Zs zs= numpy.array([0.004,0.008,0.01,0.0198,0.03,0.04]) regularzs= numpy.arange(0.0005,0.04005,0.0005) njks= len(jks) regularplotthis= numpy.zeros((njks,len(regularzs))) for jj in range(len(regularzs)): #Find z thisindx= numpy.argmin(numpy.fabs(regularzs[jj]-zs)) for ii in range(njks): regularplotthis[ii,jj]= plotthis[ii,thisindx] zs= regularzs plotthis= regularplotthis if options.relative and os.path.exists(options.infilename): savefile= open(options.infilename,'rb') plotthisrel= pickle.load(savefile) savefile.close() if options.basti: plotthisrel= plotthisrel[:,:80] elif not options.parsec: plotthisrel= plotthisrel[:,:60] if options.type == 'mode': plotthis-= plotthisrel elif options.type == 'sig': plotthis/= plotthisrel bovy_plot.bovy_print() if options.type == 'sig': plotthis[numpy.isnan(plotthis)]= vmax if options.relative: #Only plot between the cuts for ii in range(plotthis.shape[0]): indx= zs >= rcmodel.jkzcut(jks[ii],upper=True) indx+= zs <= rcmodel.jkzcut(jks[ii],upper=False) plotthis[ii,indx]= numpy.nan bovy_plot.bovy_dens2d(plotthis.T,origin='lower',cmap='jet', xrange=[jks[0],jks[-1]], yrange=[zs[0],zs[-1]], vmin=vmin,vmax=vmax, xlabel=r'$(J-K_s)_0$', ylabel=r'$Z$', interpolation='nearest', colorbar=True, shrink=0.78, zlabel=zlabel) #Overplot cuts bovy_plot.bovy_plot(jks,rcmodel.jkzcut(jks), 'w--',lw=2.,overplot=True) bovy_plot.bovy_plot(jks,rcmodel.jkzcut(jks,upper=True), 'w--',lw=2.,overplot=True) if options.basti: pyplot.annotate(r'$\mathrm{BaSTI}$', (0.5,1.08),xycoords='axes fraction', horizontalalignment='center', verticalalignment='top',size=16.) elif not options.parsec: pyplot.annotate(r'$\mathrm{Padova}$', (0.5,1.08),xycoords='axes fraction', horizontalalignment='center', verticalalignment='top',size=16.) elif options.imfmodel == 'kroupa2003': pyplot.annotate(r'$\mathrm{Kroupa\ (2003)\ IMF}$', (0.5,1.08),xycoords='axes fraction', horizontalalignment='center', verticalalignment='top',size=16.) elif 'expsfh' in args[0]: pyplot.annotate(r'$\mathrm{p(\mathrm{Age}) \propto e^{\mathrm{Age}/(8\,\mathrm{Gyr})}}$', (0.5,1.08),xycoords='axes fraction', horizontalalignment='center', verticalalignment='top',size=16.) elif not options.eta is None: pyplot.annotate(r'$\eta_{\mathrm{Reimers}} = %.1f$' % options.eta, (0.5,1.08),xycoords='axes fraction', horizontalalignment='center', verticalalignment='top',size=16.) elif False: pyplot.annotate(r'$\mathrm{Padova}$', (0.5,1.08),xycoords='axes fraction', horizontalalignment='center', verticalalignment='top',size=16.) bovy_plot.bovy_end_print(options.outfilename) return None
def __init__(self, RZPot=None,rgrid=(numpy.log(0.01),numpy.log(20.),101), zgrid=(0.,1.,101),logR=True, interpPot=False,interpRforce=False,interpzforce=False, interpDens=False, interpvcirc=False, interpdvcircdr=False, interpepifreq=False,interpverticalfreq=False, ro=None,vo=None, use_c=False,enable_c=False,zsym=True, numcores=None): """ NAME: __init__ PURPOSE: Initialize an interpRZPotential instance INPUT: RZPot - RZPotential to be interpolated rgrid - R grid to be given to linspace as in rs= linspace(*rgrid) zgrid - z grid to be given to linspace as in zs= linspace(*zgrid) logR - if True, rgrid is in the log of R so logrs= linspace(*rgrid) interpPot, interpRforce, interpzforce, interpDens,interpvcirc, interpepifreq, interpverticalfreq, interpdvcircdr= if True, interpolate these functions use_c= use C to speed up the calculation of the grid enable_c= enable use of C for interpolations zsym= if True (default), the potential is assumed to be symmetric around z=0 (so you can use, e.g., zgrid=(0.,1.,101)). numcores= if set to an integer, use this many cores (only used for vcirc, dvcircdR, epifreq, and verticalfreq; NOT NECESSARILY FASTER, TIME TO MAKE SURE) ro=, vo= distance and velocity scales for translation into internal units (default from configuration file) OUTPUT: instance HISTORY: 2010-07-21 - Written - Bovy (NYU) 2013-01-24 - Started with new implementation - Bovy (IAS) """ if isinstance(RZPot,interpRZPotential): from galpy.potential import PotentialError raise PotentialError('Cannot setup interpRZPotential with another interpRZPotential') # Propagate ro and vo roSet= True voSet= True if ro is None: if isinstance(RZPot,list): ro= RZPot[0]._ro roSet= RZPot[0]._roSet else: ro= RZPot._ro roSet= RZPot._roSet if vo is None: if isinstance(RZPot,list): vo= RZPot[0]._vo voSet= RZPot[0]._voSet else: vo= RZPot._vo voSet= RZPot._voSet Potential.__init__(self,amp=1.,ro=ro,vo=vo) # Turn off physical if it hadn't been on if not roSet: self._roSet= False if not voSet: self._voSet= False self._origPot= RZPot self._rgrid= numpy.linspace(*rgrid) self._logR= logR if self._logR: self._rgrid= numpy.exp(self._rgrid) self._logrgrid= numpy.log(self._rgrid) self._zgrid= numpy.linspace(*zgrid) self._interpPot= interpPot self._interpRforce= interpRforce self._interpzforce= interpzforce self._interpDens= interpDens self._interpvcirc= interpvcirc self._interpdvcircdr= interpdvcircdr self._interpepifreq= interpepifreq self._interpverticalfreq= interpverticalfreq self._enable_c= enable_c*ext_loaded self.hasC= self._enable_c self._zsym= zsym if interpPot: if use_c*ext_loaded: self._potGrid, err= calc_potential_c(self._origPot,self._rgrid,self._zgrid) else: from galpy.potential import evaluatePotentials potGrid= numpy.zeros((len(self._rgrid),len(self._zgrid))) for ii in range(len(self._rgrid)): for jj in range(len(self._zgrid)): potGrid[ii,jj]= evaluatePotentials(self._origPot,self._rgrid[ii],self._zgrid[jj]) self._potGrid= potGrid if self._logR: self._potInterp= interpolate.RectBivariateSpline(self._logrgrid, self._zgrid, self._potGrid, kx=3,ky=3,s=0.) else: self._potInterp= interpolate.RectBivariateSpline(self._rgrid, self._zgrid, self._potGrid, kx=3,ky=3,s=0.) if enable_c*ext_loaded: self._potGrid_splinecoeffs= calc_2dsplinecoeffs_c(self._potGrid) if interpRforce: if use_c*ext_loaded: self._rforceGrid, err= calc_potential_c(self._origPot,self._rgrid,self._zgrid,rforce=True) else: from galpy.potential import evaluateRforces rforceGrid= numpy.zeros((len(self._rgrid),len(self._zgrid))) for ii in range(len(self._rgrid)): for jj in range(len(self._zgrid)): rforceGrid[ii,jj]= evaluateRforces(self._origPot,self._rgrid[ii],self._zgrid[jj]) self._rforceGrid= rforceGrid if self._logR: self._rforceInterp= interpolate.RectBivariateSpline(self._logrgrid, self._zgrid, self._rforceGrid, kx=3,ky=3,s=0.) else: self._rforceInterp= interpolate.RectBivariateSpline(self._rgrid, self._zgrid, self._rforceGrid, kx=3,ky=3,s=0.) if enable_c*ext_loaded: self._rforceGrid_splinecoeffs= calc_2dsplinecoeffs_c(self._rforceGrid) if interpzforce: if use_c*ext_loaded: self._zforceGrid, err= calc_potential_c(self._origPot,self._rgrid,self._zgrid,zforce=True) else: from galpy.potential import evaluatezforces zforceGrid= numpy.zeros((len(self._rgrid),len(self._zgrid))) for ii in range(len(self._rgrid)): for jj in range(len(self._zgrid)): zforceGrid[ii,jj]= evaluatezforces(self._origPot,self._rgrid[ii],self._zgrid[jj]) self._zforceGrid= zforceGrid if self._logR: self._zforceInterp= interpolate.RectBivariateSpline(self._logrgrid, self._zgrid, self._zforceGrid, kx=3,ky=3,s=0.) else: self._zforceInterp= interpolate.RectBivariateSpline(self._rgrid, self._zgrid, self._zforceGrid, kx=3,ky=3,s=0.) if enable_c*ext_loaded: self._zforceGrid_splinecoeffs= calc_2dsplinecoeffs_c(self._zforceGrid) if interpDens: from galpy.potential import evaluateDensities densGrid= numpy.zeros((len(self._rgrid),len(self._zgrid))) for ii in range(len(self._rgrid)): for jj in range(len(self._zgrid)): densGrid[ii,jj]= evaluateDensities(self._origPot,self._rgrid[ii],self._zgrid[jj]) self._densGrid= densGrid if self._logR: self._densInterp= interpolate.RectBivariateSpline(self._logrgrid, self._zgrid, numpy.log(self._densGrid+10.**-10.), kx=3,ky=3,s=0.) else: self._densInterp= interpolate.RectBivariateSpline(self._rgrid, self._zgrid, numpy.log(self._densGrid+10.**-10.), kx=3,ky=3,s=0.) if interpvcirc: from galpy.potential import vcirc if not numcores is None: self._vcircGrid= multi.parallel_map((lambda x: vcirc(self._origPot,self._rgrid[x])), list(range(len(self._rgrid))),numcores=numcores) else: self._vcircGrid= numpy.array([vcirc(self._origPot,r) for r in self._rgrid]) if self._logR: self._vcircInterp= interpolate.InterpolatedUnivariateSpline(self._logrgrid,self._vcircGrid,k=3) else: self._vcircInterp= interpolate.InterpolatedUnivariateSpline(self._rgrid,self._vcircGrid,k=3) if interpdvcircdr: from galpy.potential import dvcircdR if not numcores is None: self._dvcircdrGrid= multi.parallel_map((lambda x: dvcircdR(self._origPot,self._rgrid[x])), list(range(len(self._rgrid))),numcores=numcores) else: self._dvcircdrGrid= numpy.array([dvcircdR(self._origPot,r) for r in self._rgrid]) if self._logR: self._dvcircdrInterp= interpolate.InterpolatedUnivariateSpline(self._logrgrid,self._dvcircdrGrid,k=3) else: self._dvcircdrInterp= interpolate.InterpolatedUnivariateSpline(self._rgrid,self._dvcircdrGrid,k=3) if interpepifreq: from galpy.potential import epifreq if not numcores is None: self._epifreqGrid= numpy.array(multi.parallel_map((lambda x: epifreq(self._origPot,self._rgrid[x])), list(range(len(self._rgrid))),numcores=numcores)) else: self._epifreqGrid= numpy.array([epifreq(self._origPot,r) for r in self._rgrid]) indx= True^numpy.isnan(self._epifreqGrid) if numpy.sum(indx) < 4: if self._logR: self._epifreqInterp= interpolate.InterpolatedUnivariateSpline(self._logrgrid[indx],self._epifreqGrid[indx],k=1) else: self._epifreqInterp= interpolate.InterpolatedUnivariateSpline(self._rgrid[indx],self._epifreqGrid[indx],k=1) else: if self._logR: self._epifreqInterp= interpolate.InterpolatedUnivariateSpline(self._logrgrid[indx],self._epifreqGrid[indx],k=3) else: self._epifreqInterp= interpolate.InterpolatedUnivariateSpline(self._rgrid[indx],self._epifreqGrid[indx],k=3) if interpverticalfreq: from galpy.potential import verticalfreq if not numcores is None: self._verticalfreqGrid= multi.parallel_map((lambda x: verticalfreq(self._origPot,self._rgrid[x])), list(range(len(self._rgrid))),numcores=numcores) else: self._verticalfreqGrid= numpy.array([verticalfreq(self._origPot,r) for r in self._rgrid]) if self._logR: self._verticalfreqInterp= interpolate.InterpolatedUnivariateSpline(self._logrgrid,self._verticalfreqGrid,k=3) else: self._verticalfreqInterp= interpolate.InterpolatedUnivariateSpline(self._rgrid,self._verticalfreqGrid,k=3) return None
def _determine_impact_coordtransform(self,deltaAngleTrackImpact, nTrackChunksImpact, timpact,impact_angle): """Function that sets up the transformation between (x,v) and (O,theta)""" # Integrate the progenitor backward to the time of impact self._gap_progenitor_setup() # Sign of delta angle tells us whether the impact happens to the # leading or trailing arm, self._sigMeanSign contains this info if impact_angle > 0.: self._gap_leading= True else: self._gap_leading= False if (self._gap_leading and not self._leading) \ or (not self._gap_leading and self._leading): raise ValueError('Modeling leading (trailing) impact for trailing (leading) arm; this is not allowed because it is nonsensical in this framework') self._impact_angle= numpy.fabs(impact_angle) self._gap_sigMeanSign= 1. if (self._gap_leading and self._progenitor_Omega_along_dOmega/self._sigMeanSign < 0.) \ or (not self._gap_leading and self._progenitor_Omega_along_dOmega/self._sigMeanSign > 0.): self._gap_sigMeanSign= -1. # Determine how much orbital time is necessary for the progenitor's orbit at the time of impact to cover the part of the stream near the impact; we cover the whole leading (or trailing) part of the stream if nTrackChunksImpact is None: #default is floor(self._deltaAngleTrackImpact/0.15)+1 self._nTrackChunksImpact= int(numpy.floor(self._deltaAngleTrackImpact/0.15))+1 else: self._nTrackChunksImpact= nTrackChunksImpact dt= self._deltaAngleTrackImpact\ /self._progenitor_Omega_along_dOmega\ /self._sigMeanSign*self._gap_sigMeanSign self._gap_trackts= numpy.linspace(0.,2*dt,2*self._nTrackChunksImpact-1) #to be sure that we cover it #Instantiate an auxiliaryTrack, which is an Orbit instance at the mean frequency of the stream, and zero angle separation wrt the progenitor; prog_stream_offset is the offset between this track and the progenitor at zero angle (same as in streamdf, but just done at the time of impact rather than the current time) prog_stream_offset=\ _determine_stream_track_single(self._aA, self._gap_progenitor, self._timpact, # around the t of imp self._progenitor_angle-self._timpact*self._progenitor_Omega, self._gap_sigMeanSign, self._dsigomeanProgDirection, lambda da: super(streamgapdf,self).meanOmega(da,offset_sign=self._gap_sigMeanSign,tdisrupt=self._tdisrupt-self._timpact), 0.) #angle = 0 auxiliaryTrack= Orbit(prog_stream_offset[3]) if dt < 0.: self._gap_trackts= numpy.linspace(0.,-2.*dt,2.*self._nTrackChunksImpact-1) #Flip velocities before integrating auxiliaryTrack= auxiliaryTrack.flip() auxiliaryTrack.integrate(self._gap_trackts,self._pot) if dt < 0.: #Flip velocities again auxiliaryTrack._orb.orbit[:,1]= -auxiliaryTrack._orb.orbit[:,1] auxiliaryTrack._orb.orbit[:,2]= -auxiliaryTrack._orb.orbit[:,2] auxiliaryTrack._orb.orbit[:,4]= -auxiliaryTrack._orb.orbit[:,4] #Calculate the actions, frequencies, and angle for this auxiliary orbit acfs= self._aA.actionsFreqs(auxiliaryTrack(0.),maxn=3) auxiliary_Omega= numpy.array([acfs[3],acfs[4],acfs[5]]).reshape(3\ ) auxiliary_Omega_along_dOmega= \ numpy.dot(auxiliary_Omega,self._dsigomeanProgDirection) # compute the transformation using _determine_stream_track_single allAcfsTrack= numpy.empty((self._nTrackChunksImpact,9)) alljacsTrack= numpy.empty((self._nTrackChunksImpact,6,6)) allinvjacsTrack= numpy.empty((self._nTrackChunksImpact,6,6)) thetasTrack= numpy.linspace(0.,self._deltaAngleTrackImpact, self._nTrackChunksImpact) ObsTrack= numpy.empty((self._nTrackChunksImpact,6)) ObsTrackAA= numpy.empty((self._nTrackChunksImpact,6)) detdOdJps= numpy.empty((self._nTrackChunksImpact)) if self._multi is None: for ii in range(self._nTrackChunksImpact): multiOut= _determine_stream_track_single(self._aA, auxiliaryTrack, self._gap_trackts[ii]*numpy.fabs(self._progenitor_Omega_along_dOmega/auxiliary_Omega_along_dOmega), #this factor accounts for the difference in frequency between the progenitor and the auxiliary track, no timpact bc gap_tracks is relative to timpact self._progenitor_angle-self._timpact*self._progenitor_Omega, self._gap_sigMeanSign, self._dsigomeanProgDirection, lambda da: super(streamgapdf,self).meanOmega(da,offset_sign=self._gap_sigMeanSign,tdisrupt=self._tdisrupt-self._timpact), thetasTrack[ii]) allAcfsTrack[ii,:]= multiOut[0] alljacsTrack[ii,:,:]= multiOut[1] allinvjacsTrack[ii,:,:]= multiOut[2] ObsTrack[ii,:]= multiOut[3] ObsTrackAA[ii,:]= multiOut[4] detdOdJps[ii]= multiOut[5] else: multiOut= multi.parallel_map(\ (lambda x: _determine_stream_track_single(self._aA, auxiliaryTrack, self._gap_trackts[x]*numpy.fabs(self._progenitor_Omega_along_dOmega/auxiliary_Omega_along_dOmega), #this factor accounts for the difference in frequency between the progenitor and the auxiliary track, no timpact bc gap_tracks is relative to timpact self._progenitor_angle-self._timpact*self._progenitor_Omega, self._gap_sigMeanSign, self._dsigomeanProgDirection, lambda da: super(streamgapdf,self).meanOmega(da,offset_sign=self._gap_sigMeanSign,tdisrupt=self._tdisrupt-self._timpact), thetasTrack[x])), range(self._nTrackChunksImpact), numcores=numpy.amin([self._nTrackChunksImpact, multiprocessing.cpu_count(), self._multi])) for ii in range(self._nTrackChunksImpact): allAcfsTrack[ii,:]= multiOut[ii][0] alljacsTrack[ii,:,:]= multiOut[ii][1] allinvjacsTrack[ii,:,:]= multiOut[ii][2] ObsTrack[ii,:]= multiOut[ii][3] ObsTrackAA[ii,:]= multiOut[ii][4] detdOdJps[ii]= multiOut[ii][5] #Repeat the track calculation using the previous track, to get closer to it for nn in range(self.nTrackIterations): if self._multi is None: for ii in range(self._nTrackChunksImpact): multiOut= _determine_stream_track_single(self._aA, Orbit(ObsTrack[ii,:]), 0., self._progenitor_angle-self._timpact*self._progenitor_Omega, self._gap_sigMeanSign, self._dsigomeanProgDirection, lambda da: super(streamgapdf,self).meanOmega(da,offset_sign=self._gap_sigMeanSign,tdisrupt=self._tdisrupt-self._timpact), thetasTrack[ii]) allAcfsTrack[ii,:]= multiOut[0] alljacsTrack[ii,:,:]= multiOut[1] allinvjacsTrack[ii,:,:]= multiOut[2] ObsTrack[ii,:]= multiOut[3] ObsTrackAA[ii,:]= multiOut[4] detdOdJps[ii]= multiOut[5] else: multiOut= multi.parallel_map(\ (lambda x: _determine_stream_track_single(self._aA,Orbit(ObsTrack[x,:]),0., self._progenitor_angle-self._timpact*self._progenitor_Omega, self._gap_sigMeanSign, self._dsigomeanProgDirection, lambda da: super(streamgapdf,self).meanOmega(da,offset_sign=self._gap_sigMeanSign,tdisrupt=self._tdisrupt-self._timpact), thetasTrack[x])), range(self._nTrackChunksImpact), numcores=numpy.amin([self._nTrackChunksImpact, multiprocessing.cpu_count(), self._multi])) for ii in range(self._nTrackChunksImpact): allAcfsTrack[ii,:]= multiOut[ii][0] alljacsTrack[ii,:,:]= multiOut[ii][1] allinvjacsTrack[ii,:,:]= multiOut[ii][2] ObsTrack[ii,:]= multiOut[ii][3] ObsTrackAA[ii,:]= multiOut[ii][4] detdOdJps[ii]= multiOut[ii][5] #Store the track self._gap_thetasTrack= thetasTrack self._gap_ObsTrack= ObsTrack self._gap_ObsTrackAA= ObsTrackAA self._gap_allAcfsTrack= allAcfsTrack self._gap_alljacsTrack= alljacsTrack self._gap_allinvjacsTrack= allinvjacsTrack self._gap_detdOdJps= detdOdJps self._gap_meandetdOdJp= numpy.mean(self._gap_detdOdJps) self._gap_logmeandetdOdJp= numpy.log(self._gap_meandetdOdJp) #Also calculate _ObsTrackXY in XYZ,vXYZ coordinates self._gap_ObsTrackXY= numpy.empty_like(self._gap_ObsTrack) TrackX= self._gap_ObsTrack[:,0]*numpy.cos(self._gap_ObsTrack[:,5]) TrackY= self._gap_ObsTrack[:,0]*numpy.sin(self._gap_ObsTrack[:,5]) TrackZ= self._gap_ObsTrack[:,3] TrackvX, TrackvY, TrackvZ=\ bovy_coords.cyl_to_rect_vec(self._gap_ObsTrack[:,1], self._gap_ObsTrack[:,2], self._gap_ObsTrack[:,4], self._gap_ObsTrack[:,5]) self._gap_ObsTrackXY[:,0]= TrackX self._gap_ObsTrackXY[:,1]= TrackY self._gap_ObsTrackXY[:,2]= TrackZ self._gap_ObsTrackXY[:,3]= TrackvX self._gap_ObsTrackXY[:,4]= TrackvY self._gap_ObsTrackXY[:,5]= TrackvZ return None
def plotbestr(options,args): """Make a plot of a quantity's best-fit vs. FeH and aFe""" if options.sample.lower() == 'g': npops= 62 elif options.sample.lower() == 'k': npops= 54 if options.sample.lower() == 'g': savefile= open('binmapping_g.sav','rb') elif options.sample.lower() == 'k': savefile= open('binmapping_k.sav','rb') fehs= pickle.load(savefile) afes= pickle.load(savefile) savefile.close() #First calculate the derivative properties if not options.multi is None: derivProps= multi.parallel_map((lambda x: calcAllSurfErr(x,options,args)), range(npops), numcores=numpy.amin([options.multi, npops, multiprocessing.cpu_count()])) else: derivProps= [] for ii in range(npops): derivProps.append(calcAllSurfErr(ii,options,args)) #If a second argument is given, this gives a set of rs at which also to calculate the surface density if len(args) > 1: if os.path.exists(args[1]): surffile= open(args[1],'rb') altsurfrs= pickle.load(surffile) surffile.close() calcExtra= True else: raise IOError("extra savefilename with surface-densities has to exist when it is specified") else: calcExtra= False if not calcExtra: #Fiducial, for which we also calculate everything at the mean radius of each MAP #Load g orbits orbitsfile= 'gOrbitsNew.sav' savefile= open(orbitsfile,'rb') orbits= pickle.load(savefile) savefile.close() #Cut to S/N, logg, and EBV indx= (orbits.sna > 15.)*(orbits.logga > 4.2)*(orbits.ebv < 0.3) orbits= orbits[indx] #Load the orbits into the pixel structure pix= pixelAfeFeh(orbits,dfeh=0.1,dafe=0.05) #Now calculate meanr rmean= numpy.zeros(npops) for ii in range(npops): data= pix(fehs[ii],afes[ii]) vals= data.densrmean*8. if False:#True: rmean[ii]= numpy.mean(vals) else: rmean[ii]= numpy.median(vals) #Load into plotthis plotthis= numpy.zeros(npops)+numpy.nan plotthis_y= numpy.zeros(npops)+numpy.nan plotthis_y_err= numpy.zeros(npops)+numpy.nan plotthiskz_y= numpy.zeros(npops)+numpy.nan plotthiskz_y_err= numpy.zeros(npops)+numpy.nan altplotthis= numpy.zeros(npops)+numpy.nan altplotthis_y= numpy.zeros(npops)+numpy.nan altplotthis_y_err= numpy.zeros(npops)+numpy.nan altplotthiskz_y= numpy.zeros(npops)+numpy.nan altplotthiskz_y_err= numpy.zeros(npops)+numpy.nan for ii in range(npops): if numpy.log(monoAbundanceMW.hr(fehs[ii],afes[ii], k=(options.sample.lower() == 'k')) /8.) > -0.5 \ or (options.sample.lower() == 'g' and (ii < 0 or ii == 50)) \ or (options.sample.lower() == 'k' and ii < 7): continue #Determine best-r #indx= numpy.argmin(derivProps[ii][:,2]/numpy.fabs(derivProps[ii][:,1])) indx= numpy.argmin(numpy.fabs(derivProps[ii][:,2])) if indx == 0: indx= int(numpy.floor(numpy.random.uniform()*10)) plotthis[ii]= derivProps[ii][indx,0] plotthis_y[ii]= derivProps[ii][indx,1] plotthis_y_err[ii]= derivProps[ii][indx,3] plotthiskz_y[ii]= derivProps[ii][indx,4] plotthiskz_y_err[ii]= derivProps[ii][indx,5] if calcExtra: indx= numpy.argmin(numpy.fabs(derivProps[ii][:,0]-altsurfrs[ii])) altplotthis[ii]= derivProps[ii][indx,0] altplotthis_y[ii]= derivProps[ii][indx,1] altplotthis_y_err[ii]= derivProps[ii][indx,3] altplotthiskz_y[ii]= derivProps[ii][indx,4] altplotthiskz_y_err[ii]= derivProps[ii][indx,5] else: indx= numpy.argmin(numpy.fabs(derivProps[ii][:,0]-rmean[ii])) altplotthis[ii]= derivProps[ii][indx,0] altplotthis_y[ii]= derivProps[ii][indx,1] altplotthis_y_err[ii]= derivProps[ii][indx,3] altplotthiskz_y[ii]= derivProps[ii][indx,4] altplotthiskz_y_err[ii]= derivProps[ii][indx,5] #Now plot bovy_plot.bovy_print() monoAbundanceMW.plotPixelFunc(fehs,afes,plotthis, zlabel=r'$R_\Sigma\ (\mathrm{kpc})$') bovy_plot.bovy_end_print(options.outfilename) bovy_plot.bovy_print() print plotthis, plotthis_y bovy_plot.bovy_plot(plotthis,plotthis_y,'ko', xlabel=r'$R\ (\mathrm{kpc})$', ylabel=r'$\Sigma(R,|Z| \leq 1.1\,\mathrm{kpc})\ (M_\odot\,\mathrm{pc}^{-2})$', xrange=[4.,10.], yrange=[10,1050.],#,numpy.nanmin(plotthis_y)-10., # numpy.nanmax(plotthis_y)+10.], semilogy=True) pyplot.errorbar(plotthis, plotthis_y, yerr=plotthis_y_err, elinewidth=1.,capsize=3,zorder=0, color='k',linestyle='none') trs= numpy.linspace(4.3,9.,1001) pyplot.plot(trs,72.*numpy.exp(-(trs-8.)/3.),'k--') pyplot.plot(trs,72.*numpy.exp(-(trs-8.)/2.),'k-.') pyplot.plot(trs,72.*numpy.exp(-(trs-8.)/4.),'k:') #Fit exponential #indx= (plotthis < 8.) #plotthis= plotthis[indx] #plotthis_y= plotthis_y[indx] #plotthis_y_err= plotthis_y_err[indx] exp_params= optimize.fmin_powell(expcurve, numpy.log(numpy.array([72.,2.5])), args=(plotthis,plotthis_y,plotthis_y_err)) pyplot.plot(trs,numpy.exp(exp_params[0]-(trs-8.)/numpy.exp(exp_params[1])), 'k-',lw=2.) print numpy.exp(exp_params) bovy_plot.bovy_end_print(options.outfilename.replace('.png','_rvssurf.png')) #Save if calcExtra: save_pickles(options.outfilename.replace('.png','_rvssurf.sav'), plotthis,plotthis_y,plotthis_y_err, plotthiskz_y,plotthiskz_y_err, altplotthis,altplotthis_y,altplotthis_y_err, altplotthiskz_y,altplotthiskz_y_err) else: save_pickles(options.outfilename.replace('.png','_rvssurf.sav'), plotthis,plotthis_y,plotthis_y_err, plotthiskz_y,plotthiskz_y_err, altplotthis,altplotthis_y,altplotthis_y_err, altplotthiskz_y,altplotthiskz_y_err) return None
def plotbestz(options,args): """Make a plot of a quantity's best-fit vs. FeH and aFe""" if options.sample.lower() == 'g': npops= 62 elif options.sample.lower() == 'k': npops= 54 if options.sample.lower() == 'g': savefile= open('binmapping_g.sav','rb') elif options.sample.lower() == 'k': savefile= open('binmapping_k.sav','rb') fehs= pickle.load(savefile) afes= pickle.load(savefile) savefile.close() #First calculate the derivative properties if not options.multi is None: derivProps= multi.parallel_map((lambda x: calcAllSurfErrZ(x,options,args)), range(npops), numcores=numpy.amin([options.multi, npops, multiprocessing.cpu_count()])) else: derivProps= [] for ii in range(npops): derivProps.append(calcAllSurfErrZ(ii,options,args)) #Load into plotthis plotthis= numpy.zeros(npops)+numpy.nan plotthis_y= numpy.zeros(npops)+numpy.nan plotthis_y_err= numpy.zeros(npops)+numpy.nan for ii in range(npops): if numpy.log(monoAbundanceMW.hr(fehs[ii],afes[ii], k=(options.sample.lower() == 'k')) /8.) > -0.5 \ or (options.sample.lower() == 'g' and ii < 6) \ or (options.sample.lower() == 'k' and ii < 7): continue #Determine best-r #indx= numpy.argmin(derivProps[ii][:,2]/numpy.fabs(derivProps[ii][:,1])) indx= numpy.argmin(numpy.fabs(derivProps[ii][:,2])) plotthis[ii]= derivProps[ii][indx,0] plotthis_y[ii]= derivProps[ii][indx,1] plotthis_y_err[ii]= derivProps[ii][indx,3] #Now plot bovy_plot.bovy_print() print plotthis, plotthis_y bovy_plot.bovy_plot(plotthis,plotthis_y,'ko', xlabel=r'$Z\ (\mathrm{kpc})$', ylabel=r'$\Sigma(R_0,|Z|)\ (M_\odot\,\mathrm{pc}^{-2})$', xrange=[0.,5.], yrange=[10.,1050.],#,numpy.nanmin(plotthis_y)-10., # numpy.nanmax(plotthis_y)+10.], semilogy=True) pyplot.errorbar(plotthis, plotthis_y, yerr=plotthis_y_err, elinewidth=1.,capsize=3,zorder=0, color='k',linestyle='none') #trs= numpy.linspace(4.3,9.,1001) #pyplot.plot(trs,72.*numpy.exp(-(trs-8.)/3.),'k--') #pyplot.plot(trs,72.*numpy.exp(-(trs-8.)/2.),'k-.') #pyplot.plot(trs,72.*numpy.exp(-(trs-8.)/4.),'k:') bovy_plot.bovy_end_print(options.outfilename.replace('.png','_zvssurf.png')) return None
def __init__(self,pot=None,zmax=1.,gamma=1.,Rmax=5., nR=16,nEz=16,nEr=31,nLz=31,numcores=1, **kwargs): """ NAME: __init__ PURPOSE: initialize an actionAngleAdiabaticGrid object INPUT: pot= potential or list of potentials zmax= zmax for building Ez grid Rmax = Rmax for building grids gamma= (default=1.) replace Lz by Lz+gamma Jz in effective potential nEz=, nEr=, nLz, nR= grid size numcores= number of cpus to use to parallellize c= if True, use C to calculate actions +scipy.integrate.quad keywords OUTPUT: HISTORY: 2012-07-27 - Written - Bovy (IAS@MPIA) """ if pot is None: #pragma: no cover raise IOError("Must specify pot= for actionAngleAxi") if kwargs.has_key('c') and kwargs['c']: self._c= True kwargs.pop('c') else: self._c= False if kwargs.has_key('c'): kwargs.pop('c') self._gamma= gamma self._pot= pot self._zmax= zmax self._Rmax= Rmax self._Rmin= 0.01 #Set up the actionAngleAdiabatic object that we will use to interpolate self._aA= actionAngleAdiabatic(pot=self._pot,gamma=self._gamma, c=self._c) #Build grid for Ez, first calculate Ez(zmax;R) function self._Rs= numpy.linspace(self._Rmin,self._Rmax,nR) self._EzZmaxs= galpy.potential.evaluatePotentials(self._Rs,self._zmax*numpy.ones(nR),self._pot)\ -galpy.potential.evaluatePotentials(self._Rs,numpy.zeros(nR),self._pot) self._EzZmaxsInterp= interpolate.InterpolatedUnivariateSpline(self._Rs,numpy.log(self._EzZmaxs),k=3) y= numpy.linspace(0.,1.,nEz) jz= numpy.zeros((nR,nEz)) jzEzzmax= numpy.zeros(nR) thisRs= (numpy.tile(self._Rs,(nEz,1)).T).flatten() thisEzZmaxs= (numpy.tile(self._EzZmaxs,(nEz,1)).T).flatten() thisy= (numpy.tile(y,(nR,1))).flatten() if self._c: jz= self._aA(thisRs, numpy.zeros(len(thisRs)), numpy.ones(len(thisRs)),#these two r dummies numpy.zeros(len(thisRs)), numpy.sqrt(2.*thisy*thisEzZmaxs), **kwargs)[2] jz= numpy.reshape(jz,(nR,nEz)) jzEzzmax[0:nR]= jz[:,nEz-1] else: if numcores > 1: jz= multi.parallel_map((lambda x: self._aA(thisRs[x],0.,1.,#these two r dummies 0.,math.sqrt(2.*thisy[x]*thisEzZmaxs[x]), _justjz=True, **kwargs)[2]), range(nR*nEz),numcores=numcores) jz= numpy.reshape(jz,(nR,nEz)) jzEzzmax[0:nR]= jz[:,nEz-1] else: for ii in range(nR): for jj in range(nEz): #Calculate Jz jz[ii,jj]= self._aA(self._Rs[ii],0.,1.,#these two r dummies 0.,numpy.sqrt(2.*y[jj]*self._EzZmaxs[ii]), _justjz=True,**kwargs)[2] if jj == nEz-1: jzEzzmax[ii]= jz[ii,jj] for ii in range(nR): jz[ii,:]/= jzEzzmax[ii] #First interpolate Ez=Ezmax self._jzEzmaxInterp= interpolate.InterpolatedUnivariateSpline(self._Rs,numpy.log(jzEzzmax+10.**-5.),k=3) self._jz= jz self._jzInterp= interpolate.RectBivariateSpline(self._Rs, y, jz, kx=3,ky=3,s=0.) #JR grid self._Lzmin= 0.01 self._Lzs= numpy.linspace(self._Lzmin, self._Rmax\ *galpy.potential.vcirc(self._pot, self._Rmax), nLz) self._Lzmax= self._Lzs[-1] #Calculate ER(vr=0,R=RL) self._RL= numpy.array([galpy.potential.rl(self._pot,l) for l in self._Lzs]) self._RLInterp= interpolate.InterpolatedUnivariateSpline(self._Lzs, self._RL,k=3) self._ERRL= galpy.potential.evaluatePotentials(self._RL,numpy.zeros(nLz),self._pot) +self._Lzs**2./2./self._RL**2. self._ERRLmax= numpy.amax(self._ERRL)+1. self._ERRLInterp= interpolate.InterpolatedUnivariateSpline(self._Lzs, numpy.log(-(self._ERRL-self._ERRLmax)),k=3) self._Ramax= 99. self._ERRa= galpy.potential.evaluatePotentials(self._Ramax,0.,self._pot) +self._Lzs**2./2./self._Ramax**2. self._ERRamax= numpy.amax(self._ERRa)+1. self._ERRaInterp= interpolate.InterpolatedUnivariateSpline(self._Lzs, numpy.log(-(self._ERRa-self._ERRamax)),k=3) y= numpy.linspace(0.,1.,nEr) jr= numpy.zeros((nLz,nEr)) jrERRa= numpy.zeros(nLz) thisRL= (numpy.tile(self._RL,(nEr-1,1)).T).flatten() thisLzs= (numpy.tile(self._Lzs,(nEr-1,1)).T).flatten() thisERRL= (numpy.tile(self._ERRL,(nEr-1,1)).T).flatten() thisERRa= (numpy.tile(self._ERRa,(nEr-1,1)).T).flatten() thisy= (numpy.tile(y[0:-1],(nLz,1))).flatten() if self._c: mjr= self._aA(thisRL, numpy.sqrt(2.*(thisERRa+thisy*(thisERRL-thisERRa)-galpy.potential.evaluatePotentials(thisRL,numpy.zeros((nEr-1)*nLz),self._pot))-thisLzs**2./thisRL**2.), thisLzs/thisRL, numpy.zeros(len(thisRL)), numpy.zeros(len(thisRL)), **kwargs)[0] jr[:,0:-1]= numpy.reshape(mjr,(nLz,nEr-1)) jrERRa[0:nLz]= jr[:,0] else: if numcores > 1: mjr= multi.parallel_map((lambda x: self._aA(thisRL[x], numpy.sqrt(2.*(thisERRa[x]+thisy[x]*(thisERRL[x]-thisERRa[x])-galpy.potential.evaluatePotentials(thisRL[x],0.,self._pot))-thisLzs[x]**2./thisRL[x]**2.), thisLzs[x]/thisRL[x], 0.,0., _justjr=True, **kwargs)[0]), range((nEr-1)*nLz), numcores=numcores) jr[:,0:-1]= numpy.reshape(mjr,(nLz,nEr-1)) jrERRa[0:nLz]= jr[:,0] else: for ii in range(nLz): for jj in range(nEr-1): #Last one is zero by construction try: jr[ii,jj]= self._aA(self._RL[ii], numpy.sqrt(2.*(self._ERRa[ii]+y[jj]*(self._ERRL[ii]-self._ERRa[ii])-galpy.potential.evaluatePotentials(self._RL[ii],0.,self._pot))-self._Lzs[ii]**2./self._RL[ii]**2.), self._Lzs[ii]/self._RL[ii], 0.,0., _justjr=True, **kwargs)[0] except UnboundError: #pragma: no cover raise if jj == 0: jrERRa[ii]= jr[ii,jj] for ii in range(nLz): jr[ii,:]/= jrERRa[ii] #First interpolate Ez=Ezmax self._jr= jr self._jrERRaInterp= interpolate.InterpolatedUnivariateSpline(self._Lzs, numpy.log(jrERRa+10.**-5.),k=3) self._jrInterp= interpolate.RectBivariateSpline(self._Lzs, y, jr, kx=3,ky=3,s=0.) return None
def plot2d(options,args): """Make a plot of a quantity's best-fit vs. FeH and aFe""" if options.sample.lower() == 'g': npops= 62 elif options.sample.lower() == 'k': npops= 54 if options.sample.lower() == 'g': savefile= open('binmapping_g.sav','rb') elif options.sample.lower() == 'k': savefile= open('binmapping_k.sav','rb') fehs= pickle.load(savefile) afes= pickle.load(savefile) savefile.close() #First calculate the derivative properties if not options.multi is None: derivProps= multi.parallel_map((lambda x: calcAllDerivProps(x,options,args)), range(npops), numcores=numpy.amin([options.multi, npops, multiprocessing.cpu_count()])) else: derivProps= [] for ii in range(npops): derivProps.append(calcAllDerivProps(ii,options,args)) xprop= options.subtype.split(',')[0] yprop= options.subtype.split(',')[1] if xprop == 'fracfaint' or yprop == 'fracfaint': #Read the data print "Reading the data ..." raw= read_rawdata(options) #Bin the data binned= pixelAfeFeh(raw,dfeh=0.1,dafe=0.05) for ii in range(npops): if numpy.log(monoAbundanceMW.hr(fehs[ii],afes[ii], k=(options.sample.lower() == 'k')) /8.) > -0.5 \ or (options.sample.lower() == 'g' and (ii == 50 or ii == 57)) \ or (options.sample.lower() == 'k' and ii < 7): continue data= binned(fehs[ii],afes[ii]) indx= (data.dered_r > 17.8) derivProps[ii]['fracfaint']= numpy.sum(indx)/float(len(indx)) derivProps[ii]['fracfaint_err']= 0. if xprop == 'nfaint' or yprop == 'nfaint': #Read the data print "Reading the data ..." raw= read_rawdata(options) #Bin the data binned= pixelAfeFeh(raw,dfeh=0.1,dafe=0.05) for ii in range(npops): if numpy.log(monoAbundanceMW.hr(fehs[ii],afes[ii], k=(options.sample.lower() == 'k')) /8.) > -0.5 \ or (options.sample.lower() == 'g' and ii < 6) \ or (options.sample.lower() == 'k' and ii < 7): continue data= binned(fehs[ii],afes[ii]) indx= (data.dered_r > 17.8) derivProps[ii]['nfaint']= numpy.sum(indx) derivProps[ii]['nfaint_err']= 0. if xprop == 'hz' or yprop == 'hz': for ii in range(npops): if numpy.log(monoAbundanceMW.hr(fehs[ii],afes[ii], k=(options.sample.lower() == 'k')) /8.) > -0.5 \ or (options.sample.lower() == 'g' and ii < 6) \ or (options.sample.lower() == 'k' and ii < 7): continue hz, hzerr= monoAbundanceMW.hz(fehs[ii],afes[ii], k=(options.sample.lower() == 'k'), err=True) derivProps[ii]['hz']= hz derivProps[ii]['hz_err']= hzerr if xprop == 'hr' or yprop == 'hr': for ii in range(npops): if numpy.log(monoAbundanceMW.hr(fehs[ii],afes[ii], k=(options.sample.lower() == 'k')) /8.) > -0.5 \ or (options.sample.lower() == 'g' and ii < 6) \ or (options.sample.lower() == 'k' and ii < 7): continue hr, hrerr= monoAbundanceMW.hr(fehs[ii],afes[ii], k=(options.sample.lower() == 'k'), err=True) derivProps[ii]['hr']= hr derivProps[ii]['hr_err']= hrerr #Load into plotthis plotthis_x= numpy.zeros(npops)+numpy.nan plotthis_y= numpy.zeros(npops)+numpy.nan plotthis_x_err= numpy.zeros(npops)+numpy.nan plotthis_y_err= numpy.zeros(npops)+numpy.nan for ii in range(npops): if numpy.log(monoAbundanceMW.hr(fehs[ii],afes[ii], k=(options.sample.lower() == 'k')) /8.) > -0.5 \ or (options.sample.lower() == 'g' and ii < 6) \ or (options.sample.lower() == 'k' and ii < 7): continue plotthis_x[ii]= derivProps[ii][xprop] plotthis_y[ii]= derivProps[ii][yprop] plotthis_x_err[ii]= derivProps[ii][xprop+'_err'] plotthis_y_err[ii]= derivProps[ii][yprop+'_err'] #Now plot bovy_plot.bovy_print(fig_width=6.) bovy_plot.bovy_plot(plotthis_x,plotthis_y, s=25.,c=afes, cmap='jet', xlabel=labels[xprop],ylabel=labels[yprop], clabel=r'$[\alpha/\mathrm{Fe}]$', xrange=ranges[xprop],yrange=ranges[yprop], vmin=0.,vmax=0.5, scatter=True,edgecolors='none', colorbar=True) colormap = cm.jet for ii in range(npops): if numpy.isnan(plotthis_x[ii]): continue pyplot.errorbar(plotthis_x[ii], plotthis_y[ii], xerr=plotthis_x_err[ii], yerr=plotthis_y_err[ii], color=colormap(_squeeze(afes[ii], numpy.amax([numpy.amin(afes)]), numpy.amin([numpy.amax(afes)]))), elinewidth=1.,capsize=3,zorder=0) bovy_plot.bovy_end_print(options.outfilename) return None
def __init__(self, pot=None, zmax=1., gamma=1., Rmax=5., nR=16, nEz=16, nEr=31, nLz=31, numcores=1, **kwargs): """ NAME: __init__ PURPOSE: initialize an actionAngleAdiabaticGrid object INPUT: pot= potential or list of potentials zmax= zmax for building Ez grid Rmax = Rmax for building grids gamma= (default=1.) replace Lz by Lz+gamma Jz in effective potential nEz=, nEr=, nLz, nR= grid size numcores= number of cpus to use to parallellize c= if True, use C to calculate actions ro= distance from vantage point to GC (kpc; can be Quantity) vo= circular velocity at ro (km/s; can be Quantity) +scipy.integrate.quad keywords OUTPUT: instance HISTORY: 2012-07-27 - Written - Bovy (IAS@MPIA) """ actionAngle.__init__(self, ro=kwargs.get('ro', None), vo=kwargs.get('vo', None)) if pot is None: #pragma: no cover raise IOError("Must specify pot= for actionAngleAxi") self._c = kwargs.pop('c', False) self._gamma = gamma self._pot = pot self._zmax = zmax self._Rmax = Rmax self._Rmin = 0.01 #Set up the actionAngleAdiabatic object that we will use to interpolate self._aA = actionAngleAdiabatic(pot=self._pot, gamma=self._gamma, c=self._c) #Build grid for Ez, first calculate Ez(zmax;R) function self._Rs = numpy.linspace(self._Rmin, self._Rmax, nR) self._EzZmaxs= _evaluatePotentials(self._pot,self._Rs, self._zmax*numpy.ones(nR))\ -_evaluatePotentials(self._pot,self._Rs,numpy.zeros(nR)) self._EzZmaxsInterp = interpolate.InterpolatedUnivariateSpline( self._Rs, numpy.log(self._EzZmaxs), k=3) y = numpy.linspace(0., 1., nEz) jz = numpy.zeros((nR, nEz)) jzEzzmax = numpy.zeros(nR) thisRs = (numpy.tile(self._Rs, (nEz, 1)).T).flatten() thisEzZmaxs = (numpy.tile(self._EzZmaxs, (nEz, 1)).T).flatten() thisy = (numpy.tile(y, (nR, 1))).flatten() if self._c: jz = self._aA( thisRs, numpy.zeros(len(thisRs)), numpy.ones(len(thisRs)), #these two r dummies numpy.zeros(len(thisRs)), numpy.sqrt(2. * thisy * thisEzZmaxs), **kwargs)[2] jz = numpy.reshape(jz, (nR, nEz)) jzEzzmax[0:nR] = jz[:, nEz - 1] else: if numcores > 1: jz = multi.parallel_map( ( lambda x: self._aA( thisRs[x], 0., 1., #these two r dummies 0., math.sqrt(2. * thisy[x] * thisEzZmaxs[x]), _justjz=True, **kwargs)[2]), range(nR * nEz), numcores=numcores) jz = numpy.reshape(jz, (nR, nEz)) jzEzzmax[0:nR] = jz[:, nEz - 1] else: for ii in range(nR): for jj in range(nEz): #Calculate Jz jz[ii, jj] = self._aA( self._Rs[ii], 0., 1., #these two r dummies 0., numpy.sqrt(2. * y[jj] * self._EzZmaxs[ii]), _justjz=True, **kwargs)[2] if jj == nEz - 1: jzEzzmax[ii] = jz[ii, jj] for ii in range(nR): jz[ii, :] /= jzEzzmax[ii] #First interpolate Ez=Ezmax self._jzEzmaxInterp = interpolate.InterpolatedUnivariateSpline( self._Rs, numpy.log(jzEzzmax + 10.**-5.), k=3) self._jz = jz self._jzInterp = interpolate.RectBivariateSpline(self._Rs, y, jz, kx=3, ky=3, s=0.) #JR grid self._Lzmin = 0.01 self._Lzs= numpy.linspace(self._Lzmin, self._Rmax\ *galpy.potential.vcirc(self._pot, self._Rmax), nLz) self._Lzmax = self._Lzs[-1] #Calculate ER(vr=0,R=RL) self._RL = numpy.array( [galpy.potential.rl(self._pot, l) for l in self._Lzs]) self._RLInterp = interpolate.InterpolatedUnivariateSpline(self._Lzs, self._RL, k=3) self._ERRL = _evaluatePotentials( self._pot, self._RL, numpy.zeros(nLz)) + self._Lzs**2. / 2. / self._RL**2. self._ERRLmax = numpy.amax(self._ERRL) + 1. self._ERRLInterp = interpolate.InterpolatedUnivariateSpline( self._Lzs, numpy.log(-(self._ERRL - self._ERRLmax)), k=3) self._Ramax = 99. self._ERRa = _evaluatePotentials( self._pot, self._Ramax, 0.) + self._Lzs**2. / 2. / self._Ramax**2. self._ERRamax = numpy.amax(self._ERRa) + 1. self._ERRaInterp = interpolate.InterpolatedUnivariateSpline( self._Lzs, numpy.log(-(self._ERRa - self._ERRamax)), k=3) y = numpy.linspace(0., 1., nEr) jr = numpy.zeros((nLz, nEr)) jrERRa = numpy.zeros(nLz) thisRL = (numpy.tile(self._RL, (nEr - 1, 1)).T).flatten() thisLzs = (numpy.tile(self._Lzs, (nEr - 1, 1)).T).flatten() thisERRL = (numpy.tile(self._ERRL, (nEr - 1, 1)).T).flatten() thisERRa = (numpy.tile(self._ERRa, (nEr - 1, 1)).T).flatten() thisy = (numpy.tile(y[0:-1], (nLz, 1))).flatten() if self._c: mjr = self._aA( thisRL, numpy.sqrt(2. * (thisERRa + thisy * (thisERRL - thisERRa) - _evaluatePotentials( self._pot, thisRL, numpy.zeros( (nEr - 1) * nLz))) - thisLzs**2. / thisRL**2.), thisLzs / thisRL, numpy.zeros(len(thisRL)), numpy.zeros(len(thisRL)), **kwargs)[0] jr[:, 0:-1] = numpy.reshape(mjr, (nLz, nEr - 1)) jrERRa[0:nLz] = jr[:, 0] else: if numcores > 1: mjr = multi.parallel_map((lambda x: self._aA( thisRL[x], numpy.sqrt(2. * (thisERRa[x] + thisy[x] * (thisERRL[x] - thisERRa[x]) - _evaluatePotentials(self._pot, thisRL[ x], 0.)) - thisLzs[x]**2. / thisRL[x]**2.), thisLzs[x] / thisRL[x], 0., 0., _justjr=True, **kwargs)[0]), range((nEr - 1) * nLz), numcores=numcores) jr[:, 0:-1] = numpy.reshape(mjr, (nLz, nEr - 1)) jrERRa[0:nLz] = jr[:, 0] else: for ii in range(nLz): for jj in range(nEr - 1): #Last one is zero by construction try: jr[ii, jj] = self._aA( self._RL[ii], numpy.sqrt(2. * (self._ERRa[ii] + y[jj] * (self._ERRL[ii] - self._ERRa[ii]) - _evaluatePotentials( self._pot, self._RL[ii], 0.)) - self._Lzs[ii]**2. / self._RL[ii]**2.), self._Lzs[ii] / self._RL[ii], 0., 0., _justjr=True, **kwargs)[0] except UnboundError: #pragma: no cover raise if jj == 0: jrERRa[ii] = jr[ii, jj] for ii in range(nLz): jr[ii, :] /= jrERRa[ii] #First interpolate Ez=Ezmax self._jr = jr self._jrERRaInterp = interpolate.InterpolatedUnivariateSpline( self._Lzs, numpy.log(jrERRa + 10.**-5.), k=3) self._jrInterp = interpolate.RectBivariateSpline(self._Lzs, y, jr, kx=3, ky=3, s=0.) # Check the units self._check_consistent_units() return None
def __init__( self, pot=None, zmax=3.0 / 8.0, gamma=1.0, Rmax=3.0, nR=25, nEz=25, nEr=25, nLz=25, numcores=1, **kwargs ): """ NAME: __init__ PURPOSE: initialize an actionAngleAdiabaticGrid object INPUT: pot= potential or list of potentials (planarPotentials) zmax= zmax for building Ez grid Rmax = Rmax for building grids gamma= (default=1.) replace Lz by Lz+gamma Jz in effective potential nEz=, nEr=, nLz, nR= grid size numcores= number of cpus to use to parallellize +scipy.integrate.quad keywords OUTPUT: HISTORY: 2012-07-27 - Written - Bovy (IAS@MPIA) """ if pot is None: raise IOError("Must specify pot= for actionAngleAxi") self._gamma = gamma self._pot = pot self._zmax = zmax self._Rmax = Rmax self._Rmin = 0.01 # Set up the actionAngleAdiabatic object that we will use to interpolate self._aA = actionAngleAdiabatic(pot=self._pot, gamma=self._gamma) # Build grid for Ez, first calculate Ez(zmax;R) function self._Rs = numpy.linspace(self._Rmin, self._Rmax, nR) self._EzZmaxs = numpy.array( [ galpy.potential.evaluatePotentials(r, self._zmax, self._pot) - galpy.potential.evaluatePotentials(r, 0.0, self._pot) for r in self._Rs ] ) self._EzZmaxsInterp = interpolate.InterpolatedUnivariateSpline(self._Rs, numpy.log(self._EzZmaxs), k=3) y = numpy.linspace(0.0, 1.0, nEz) jz = numpy.zeros((nR, nEz)) jzEzzmax = numpy.zeros(nR) if numcores > 1: thisRs = (numpy.tile(self._Rs, (nEz, 1)).T).flatten() thisEzZmaxs = (numpy.tile(self._EzZmaxs, (nEz, 1)).T).flatten() thisy = (numpy.tile(y, (nR, 1))).flatten() jz = multi.parallel_map( ( lambda x: self._aA.Jz( thisRs[x], 0.0, 1.0, # these two r dummies 0.0, math.sqrt(2.0 * thisy[x] * thisEzZmaxs[x]), **kwargs )[0] ), range(nR * nEz), numcores=numcores, ) jz = numpy.reshape(jz, (nR, nEz)) jzEzzmax[0:nR] = jz[:, nEz - 1] else: for ii in range(nR): for jj in range(nEz): # Calculate Jz jz[ii, jj] = self._aA.Jz( self._Rs[ii], 0.0, 1.0, # these two r dummies 0.0, math.sqrt(2.0 * y[jj] * self._EzZmaxs[ii]), **kwargs )[0] if jj == nEz - 1: jzEzzmax[ii] = jz[ii, jj] for ii in range(nR): jz[ii, :] /= jzEzzmax[ii] # First interpolate Ez=Ezmax self._jzEzmaxInterp = interpolate.InterpolatedUnivariateSpline( self._Rs, numpy.log(jzEzzmax + 10.0 ** -5.0), k=3 ) self._jz = jz self._jzInterp = interpolate.RectBivariateSpline(self._Rs, y, jz, kx=3, ky=3, s=0.0) # JR grid self._Lzmin = 0.01 self._Lzs = numpy.linspace(self._Lzmin, self._Rmax * galpy.potential.vcirc(self._pot, self._Rmax), nLz) self._Lzmax = self._Lzs[-1] # Calculate ER(vr=0,R=RL) self._RL = numpy.array([galpy.potential.rl(self._pot, l) for l in self._Lzs]) self._RLInterp = interpolate.InterpolatedUnivariateSpline(self._Lzs, self._RL, k=3) self._ERRL = numpy.array( [ galpy.potential.evaluatePotentials(self._RL[ii], 0.0, self._pot) + self._Lzs[ii] ** 2.0 / 2.0 / self._RL[ii] ** 2.0 for ii in range(nLz) ] ) self._ERRLmax = numpy.amax(self._ERRL) + 1.0 self._ERRLInterp = interpolate.InterpolatedUnivariateSpline( self._Lzs, numpy.log(-(self._ERRL - self._ERRLmax)), k=3 ) self._Ramax = 99.0 self._ERRa = numpy.array( [ galpy.potential.evaluatePotentials(self._Ramax, 0.0, self._pot) + self._Lzs[ii] ** 2.0 / 2.0 / self._Ramax ** 2.0 for ii in range(nLz) ] ) self._ERRamax = numpy.amax(self._ERRa) + 1.0 self._ERRaInterp = interpolate.InterpolatedUnivariateSpline( self._Lzs, numpy.log(-(self._ERRa - self._ERRamax)), k=3 ) y = numpy.linspace(0.0, 1.0, nEr) jr = numpy.zeros((nLz, nEr)) jrERRa = numpy.zeros(nLz) if numcores > 1: thisRL = (numpy.tile(self._RL, (nEr - 1, 1)).T).flatten() thisLzs = (numpy.tile(self._Lzs, (nEr - 1, 1)).T).flatten() thisERRL = (numpy.tile(self._ERRL, (nEr - 1, 1)).T).flatten() thisERRa = (numpy.tile(self._ERRa, (nEr - 1, 1)).T).flatten() thisy = (numpy.tile(y[0:-1], (nLz, 1))).flatten() mjr = multi.parallel_map( ( lambda x: self._aA.JR( thisRL[x], numpy.sqrt( 2.0 * ( thisERRa[x] + thisy[x] * (thisERRL[x] - thisERRa[x]) - galpy.potential.evaluatePotentials(thisRL[x], 0.0, self._pot) ) - thisLzs[x] ** 2.0 / thisRL[x] ** 2.0 ), thisLzs[x] / thisRL[x], 0.0, 0.0, **kwargs )[0] ), range((nEr - 1) * nLz), numcores=numcores, ) jr[:, 0:-1] = numpy.reshape(mjr, (nLz, nEr - 1)) jrERRa[0:nLz] = jr[:, 0] else: for ii in range(nLz): for jj in range(nEr - 1): # Last one is zero by construction try: jr[ii, jj] = self._aA.JR( self._RL[ii], numpy.sqrt( 2.0 * ( self._ERRa[ii] + y[jj] * (self._ERRL[ii] - self._ERRa[ii]) - galpy.potential.evaluatePotentials(self._RL[ii], 0.0, self._pot) ) - self._Lzs[ii] ** 2.0 / self._RL[ii] ** 2.0 ), self._Lzs[ii] / self._RL[ii], 0.0, 0.0, **kwargs )[0] except UnboundError: raise if jj == 0: jrERRa[ii] = jr[ii, jj] for ii in range(nLz): jr[ii, :] /= jrERRa[ii] # First interpolate Ez=Ezmax self._jr = jr self._jrERRaInterp = interpolate.InterpolatedUnivariateSpline(self._Lzs, numpy.log(jrERRa + 10.0 ** -5.0), k=3) self._jrInterp = interpolate.RectBivariateSpline(self._Lzs, y, jr, kx=3, ky=3, s=0.0) return None