def create_plot_binary(dist=100.0, num_sys=100, bins=25): """ Create a set of random binaries and plot the distribution of resulting theta vs pm Parameters ---------- dist : float Distance to the population for angular (rather than physical) units (pc) num_sys : float Number of random binaries to generate bins : int Number of bins for contours Returns ------- None """ global binary_set if binary_set is None or len(binary_set) != num_sys: generate_binary_set(num_sys=num_sys, dist=dist) fig, ax1 = plt.subplots(1,1, figsize=(6,4)) # Plot limits xmin, xmax = 0.0, 5000.0 ymin, ymax = 0.0, 3.0 ax1.set_xlim(xmin, xmax) ax1.set_ylim(ymin, ymax) # Plot labels ax1.set_xlabel("Projected separation (AU)") ax1.set_ylabel("Proper motion difference (km/s)") # Plot distribution contourf_kwargs = {'bins':bins} corner.hist2d(binary_set['proj_sep']*c.Rsun_to_cm/c.AU_to_cm, binary_set['pm'], nbins=bins, range=([xmin,xmax],[ymin,ymax]), **contourf_kwargs) # Add angular separation at dist axis ax2 = ax1.twiny() xticks = np.linspace(xmin,xmax,6) angles = (xticks * c.AU_to_cm)/(dist * c.pc_to_cm) * (180.0 * 3600.0 / np.pi) ax2.set_xticks(angles) ax2.set_xlabel('Angular separation at distance of ' + str(dist) + ' pc (arcsec)') # Add proper motion at dist axis ax3 = ax1.twinx() yticks = np.linspace(ymin, ymax, 7) def pm_at_dist(pm, dist=100.0): return (pm * 1.0e5)/(dist * c.pc_to_cm) * (1.0e3 * 180.0 * 3600.0 / np.pi) * c.day_to_sec*365.25 ax3.set_ylim(0.0, pm_at_dist(ax1.get_ylim()[1], dist=dist)) ax3.set_ylabel('Proper motion at distance of ' + str(dist) + ' pc (mas/yr)') plt.tight_layout() plt.show()
def _run_hist2d(nm, N=50000, seed=1234, **kwargs): # Generate some fake data. np.random.seed(seed) x = np.random.randn(N) y = np.random.randn(N) fig, ax = pl.subplots(1, 1, figsize=(8, 8)) corner.hist2d(x, y, ax=ax, **kwargs)
def test_Mh_SFR(run, theta, nsnap0=15, sigma_smhm=0.2, downsampled='14'): ''' Take a look at the M_h SFR relationship ''' subcat_sim = abcee.model(run, theta, nsnap0=nsnap0, sigma_smhm=sigma_smhm, downsampled=downsampled) isSF = np.where(subcat_sim['gclass'] == 'sf') fig = plt.figure() sub = fig.add_subplot(111) DFM.hist2d(subcat_sim['halo.m'][isSF], subcat_sim['sfr'][isSF], weights=subcat_sim['weights'][isSF], levels=[0.68, 0.95], range=[[10., 15.], [-4., 2.]], color='#1F77B4', plot_datapoints=True, fill_contours=False, plot_density=False, ax=sub) plt.show()
def _run_hist2d(nm, N=50000, seed=1234, **kwargs): print(" .. {0}".format(nm)) if not os.path.exists(FIGURE_PATH): os.makedirs(FIGURE_PATH) # Generate some fake data. np.random.seed(seed) x = np.random.randn(N) y = np.random.randn(N) fig, ax = pl.subplots(1, 1, figsize=(8, 8)) corner.hist2d(x, y, ax=ax, **kwargs) fig.savefig(os.path.join(FIGURE_PATH, "hist2d_{0}.png".format(nm))) pl.close(fig)
def whatsThatFeature(survey='2MASS', quantile=0.05, dataFilename='All.npz', iter='10th', ngauss=128): if survey == '2MASS': mag1 = 'J' mag2 = 'K' absmag = 'J' xlabel = r'$(J-K_s)^C$' ylabel = r'$M_J^C$' xlim = [-0.25, 1.25] ylim = [6, -6] dustEBV = 0.0 tgas, twoMass, Apass, bandDictionary, indices = testXD.dataArrays() color = testXD.colorArray(mag1, mag2, dustEBV, bandDictionary) file = 'posteriorParallax.' + str(ngauss) + 'gauss.dQ' + str( quantile) + '.' + iter + '.' + survey + '.' + dataFilename data = np.load(file) parallax = data['mean'] notnans = ~np.isnan(parallax) parallax = parallax[notnans] absMagKinda, apparentMagnitude = testXD.absMagKindaArray( absmag, dustEBV, bandDictionary, tgas['parallax']) apparentMagnitudeGood = apparentMagnitude[notnans] absMagKinda = parallax * 10.**(0.2 * apparentMagnitudeGood) figFeature, axFeature = plt.subplots() x = color[notnans] y = testXD.absMagKinda2absMag(absMagKinda) im = corner.hist2d(x, y, ax=axFeature, levels=None, bins=200, no_fill_contours=True, plot_density=False, color=contourColor, rasterized=True, plot_contours=False) axFeature.set_xlim(xlim) axFeature.set_ylim(ylim) axFeature.set_xlabel(xlabel) axFeature.set_ylabel(ylabel) lowerMainSequence = (0.45, 5.5) upperMainSequence = (-0.225, 2) binarySequence = (0.75, 4) redClump = (0.35, -2) redGiantBranch = (1.0, -2) turnOff = (0.0, 3.5) features = [ lowerMainSequence, upperMainSequence, binarySequence, redClump, redGiantBranch, turnOff ] labels = [ 'lower MS', 'upper MS', 'binary sequence', 'red clump', 'RGB', 'MS turn off', 'subgiant branch' ] for l, f in zip(labels, features): axFeature.text(f[0], f[1], l, fontsize=15) figFeature.savefig('whatsThatFeature.pdf', format='pdf')
def plot_beam_pos(postdata, frb_data, radius, bins=50, color="blue"): xposmin = -2; xposmax = 2; yposmin = -2; yposmax = 2; beamx = frb_data.xpos_new beamy = frb_data.ypos_new beam_name = frb_data.beam fig = plt.figure(figsize=(8, 8)) main_ax = plt.axes((0.1, 0.1, 0.6, 0.6)) # [left, bottom, width, height] corner.hist2d(postdata[:,0], postdata[:,1], bins=bins, color=color, plot_datapoints=False, \ smooth=True, plot_density=True, plot_contours=False, ax=main_ax) for ibeam in range(len(beamx)): circ = plt.Circle((beamx[ibeam], beamy[ibeam]), radius=radius[ibeam], fill=False, \ linestyle="--", ec="k") main_ax.annotate("beam " + beam_name[ibeam], xy=(beamx[ibeam], beamy[ibeam]), \ verticalalignment='center', horizontalalignment='center') main_ax.add_patch(circ) main_ax.set_xlim(xposmin, xposmax) main_ax.set_ylim(yposmin, yposmax) plt.xlabel(r'$\Delta \alpha \, Cos (\delta)$ (deg)', size="large") plt.ylabel(r'$\Delta \delta $ (deg)', size="large") postx_ax = plt.axes((0.1, 0.7, 0.6, 0.2), sharex=main_ax) postx_ax.hist(postdata[:,0], bins=bins, density=True, edgecolor='blue', lw=0.5) postx_ax.set_xlim(xposmin, xposmax) plt.ylabel(r'$\rho $ (arb.)', size="large") postx_ax.get_yaxis().set_ticks([]) plt.setp(postx_ax.xaxis.get_ticklabels(), visible=False) posty_ax = plt.axes((0.7, 0.1, 0.2, 0.6), sharey=main_ax) posty_ax.hist(postdata[:,1], bins=bins, orientation="horizontal", normed=True, \ edgecolor='blue', lw=0.5) posty_ax.set_ylim(yposmin, yposmax) plt.xlabel(r'$\rho $ (arb.)', size="large") posty_ax.get_xaxis().set_ticks([]) plt.setp(posty_ax.yaxis.get_ticklabels(), visible=False) return fig
def obs_tauV(): ''' examine optical depth tauV(Mstar) for SDSS data assuming face on (theta=0) slab dust model tau_V = A_V / 1.086 ''' # read data dat_dir = os.environ['GALPOPFM_DIR'] fsdss = os.path.join(dat_dir, 'obs', 'tinker_SDSS_centrals_M9.7.valueadd.hdf5') sdss = h5py.File(fsdss, 'r') # get attenuation A_V AV_sdss = sdss['AV'][...] mstar_sdss = sdss['MASS'][...] * 0.7**2 # there should be some cut here cut = AV_sdss > 0. AV_sdss = AV_sdss[cut] mstar_sdss = mstar_sdss[cut] # get tauV tauV = AV_sdss/1.086 sensible_tau = (tauV > 0.) & (tauV < 10.) import corner as DFM fig = plt.figure() sub = fig.add_subplot(111) DFM.hist2d(np.log10(mstar_sdss)[sensible_tau], tauV[sensible_tau], color='k', levels=[0.68, 0.95], range=[[8.5, 11.], [0., 4.]], plot_datapoints=True, fill_contours=False, plot_density=True, ax=sub) # overplot tauV(msta) within our prior marr = np.linspace(8, 12, 20) _tauv = (marr-10.) + 1.5 sub.plot(marr, _tauv, c='C1', ls='--') sub.set_xlabel(r'$\log\,M_*$', fontsize=20) sub.set_ylabel(r'$\tau_V = A_V/1.086$', fontsize=20) fig.savefig(os.path.join(dat_dir, 'obs', 'sdss.tauV_mstar.png'), bbox_inches='tight') return None
def CMplot(table,r,g,ext='mag_forced_cmodel', axis=None,plotpoints = True,**kwargs): """ plot color-magnitude diagram for a sample of galaxies given in table. """ y = table[g+ext] - table[r+ext] x = table[r+ext] if axis is None: axis = [[np.nanmin(x), np.nanmax(x)], [np.nanmin(y), np.nanmax(y)]] if plotpoints: obj = plt.scatter(x, y,s=1,**kwargs) plt.axis(axis.flatten()) else: obj = corner.hist2d(x, y,range=axis,bins=100,plot_datapoints=False,smooth=0.5,levels=[0.683,0.955]) plt.xlabel(r + ' [mag]') plt.ylabel(g + ' - ' + r + ' [mag]') return obj
def walkers(nwalkers, x, y, model, theta, conditions=None, var2=0.01, mov=100, d=1, tol=1. * 10**-3, mode=False): result = [] error = [] par = [] for i in range(nwalkers): theta, nwalk, y0 = walk(x, y, model, theta, conditions, var2, mov, d, tol, mode) par.append(theta) nwalk = np.array(nwalk).reshape((len(nwalk), len(nwalk[i]))) error.append(y0) for k in range(nwalk.shape[1]): sub = '$\\theta _{' + str(k) + '}$' plt.plot(range(len(nwalk[:, k])), nwalk[:, k], '-', label=sub) plt.ylabel('$\\theta$') plt.xlabel('iterations') #plt.legend() plt.show() if (nwalk.shape[1] == 2): fig = corner.hist2d(nwalk[:, 0], nwalk[:, 1], range=None, bins=18, smooth=True, plot_datapoints=True, plot_density=True) plt.ylabel('$\\theta_{1}$') plt.xlabel('$\\theta_{0}$') plt.savefig("1401.png") return (par, error)
mpl.rcParams['ytick.minor.width'] = 1.2 mpl.rcParams['ytick.major.pad'] = 8 mpl.rcParams['ytick.labelsize'] = 'large' mpl.rcParams['font.family'] = 'sans-serif' mpl.rcParams['font.weight'] = 500 mpl.rcParams['font.size'] = 16 # if we want to plot gamma-Rc and p-Rout in two panels # from matplotlib import gridspec # fig = plt.figure(figsize=(10, 5)) # gs = gridspec.GridSpec(1, 2, width_ratios=[1, 1]) # ax = plt.subplot(gs[0]), plt.subplot(gs[1]) fig, ax = plt.subplots(1, 1, figsize=(5, 5)) levels = 1.-np.exp(-0.5*np.arange(1., 3.1, 1)**2.) # correspond to 1, 2 and 3 sigma for a 2D hystogram hist2d(flatchain[:, 0], flatchain[:, 2], ax=ax, bins=30, levels=levels, plot_datapoints=False, smooth=1.5, plot_contours=True, fill_contours=True, plot_density=False, color='#2D89E5') # add point for best-fit model ax.plot(bestfit_pars[0], bestfit_pars[2], marker='*', markerfacecolor='#FFFF66', markeredgecolor='#FFFF66', markersize=16) if headers['fit']['sigma_prescription'] == 'g': ax.set_xlabel(r'$\gamma$', fontsize=20) ax.set_ylabel(r'$R_c$', fontsize=20) elif headers['fit']['sigma_prescription'] == 'pl': ax.set_xlabel(r'$p$', fontsize=20) ax.set_ylabel(r'$R_{\mathrm{out}}$', fontsize=20) # set axes limits ax.set_ylim(0, 300.) yticks = np.arange(0, 301, 100, dtype='int')
def plot_dterms(modelinfo, station, burnin=0, print_dterms=True, levels=None, smooth=1.0): """ Plot right and left D-terms for a single station Args: modelinfo (dict): dmc modelinfo dictionary station (str): the station whose D-terms to plot burnin (int): length of burn-in print_dterms (bool): flag to print the D-terms and uncertainties on the plot levels (list): a list of contour levels to plot smooth (float): amount by which to KDE smooth the histograms Returns: dtermplot: figure containing the D-term plot """ # contour levels if levels is None: levels = [ 1.0 - np.exp(-0.5 * (1.1775**2.0)), 1.0 - np.exp(-0.5 * (2.146**2.0)), 1.0 - np.exp(-0.5 * (3.035**2.0)) ] ################################################### # organize chain info trace = modelinfo['trace'] stations = modelinfo['stations'] # get index for requested station istat = (stations == station) # read D-terms Dterm_reals_R = trace['right_Dterm_reals'][burnin:] Dterm_reals_L = trace['left_Dterm_reals'][burnin:] Dterm_imags_R = trace['right_Dterm_imags'][burnin:] Dterm_imags_L = trace['left_Dterm_imags'][burnin:] # remove divergences div_mask = np.invert(trace[burnin:].diverging) Dterm_reals_R = Dterm_reals_R[div_mask] Dterm_reals_L = Dterm_reals_L[div_mask] Dterm_imags_R = Dterm_imags_R[div_mask] Dterm_imags_L = Dterm_imags_L[div_mask] ################################################### # make figure dtermplot = plt.figure(figsize=(6, 6)) ax = dtermplot.add_axes([0.18, 0.18, 0.8, 0.8]) # add axis lines ax.plot([-10, 10], [0, 0], 'k--', alpha=0.5, zorder=-10) ax.plot([0, 0], [-10, 10], 'k--', alpha=0.5, zorder=-10) # plot contours corner.hist2d(Dterm_reals_R[:, istat], Dterm_imags_R[:, istat], fig=dtermplot, levels=levels, color='cornflowerblue', fill_contours=True, plot_datapoints=False, plot_density=False, plot_contours=True, smooth=smooth) corner.hist2d(Dterm_reals_L[:, istat], Dterm_imags_L[:, istat], fig=dtermplot, levels=levels, color='salmon', fill_contours=True, plot_datapoints=False, plot_density=False, plot_contours=True, smooth=smooth) # axis labels ax.set_xlabel('Real part') ax.set_ylabel('Imaginary part') # axis ranges limit = np.max( np.array([ np.max(np.abs(Dterm_reals_R[:, istat])), np.max(np.abs(Dterm_imags_R[:, istat])), np.max(np.abs(Dterm_reals_L[:, istat])), np.max(np.abs(Dterm_imags_L[:, istat])) ])) ax.set_xlim(-1.1 * limit, 1.1 * limit) ax.set_ylim(-1.1 * limit, 1.1 * limit) for tick in ax.get_xticklabels(): tick.set_rotation(45) tick.set_ha('right') # print out D-term values and uncertainties if print_dterms: realpart_R = np.percentile(Dterm_reals_R[:, istat], 50.0) realpart_R_lo = np.percentile(Dterm_reals_R[:, istat], 50.0) - np.percentile( Dterm_reals_R[:, istat], 15.87) realpart_R_hi = np.percentile(Dterm_reals_R[:, istat], 84.13) - np.percentile( Dterm_reals_R[:, istat], 50.0) realpart_L = np.percentile(Dterm_reals_L[:, istat], 50.0) realpart_L_lo = np.percentile(Dterm_reals_L[:, istat], 50.0) - np.percentile( Dterm_reals_L[:, istat], 15.87) realpart_L_hi = np.percentile(Dterm_reals_L[:, istat], 84.13) - np.percentile( Dterm_reals_L[:, istat], 50.0) imagpart_R = np.percentile(Dterm_imags_R[:, istat], 50.0) imagpart_R_lo = np.percentile(Dterm_imags_R[:, istat], 50.0) - np.percentile( Dterm_imags_R[:, istat], 15.87) imagpart_R_hi = np.percentile(Dterm_imags_R[:, istat], 84.13) - np.percentile( Dterm_imags_R[:, istat], 50.0) imagpart_L = np.percentile(Dterm_imags_L[:, istat], 50.0) imagpart_L_lo = np.percentile(Dterm_imags_L[:, istat], 50.0) - np.percentile( Dterm_imags_L[:, istat], 15.87) imagpart_L_hi = np.percentile(Dterm_imags_L[:, istat], 84.13) - np.percentile( Dterm_imags_L[:, istat], 50.0) str1 = r'$\rm{Re}(D_R) = ' + str(np.round( realpart_R, 5)) + r'_{-' + str( np.round(realpart_R_lo, 5)) + r'}^{+' + str( np.round(realpart_R_hi, 5)) + r'}$' str2 = r'$\rm{Im}(D_R) = ' + str(np.round( imagpart_R, 5)) + r'_{-' + str( np.round(imagpart_R_lo, 5)) + r'}^{+' + str( np.round(imagpart_R_hi, 5)) + r'}$' str3 = r'$\rm{Re}(D_L) = ' + str(np.round( realpart_L, 5)) + r'_{-' + str( np.round(realpart_L_lo, 5)) + r'}^{+' + str( np.round(realpart_L_hi, 5)) + r'}$' str4 = r'$\rm{Im}(D_L) = ' + str(np.round( imagpart_L, 5)) + r'_{-' + str( np.round(imagpart_L_lo, 5)) + r'}^{+' + str( np.round(imagpart_L_hi, 5)) + r'}$' strhere = str1 + '\n' + str2 + '\n' + str3 + '\n' + str4 ax.text(-1.05 * limit, 1.05 * limit, strhere, ha='left', va='top', fontsize=8) return dtermplot
def plot_corner(samples, labels=("dt", 'dm'), bnames=('', ), axhist=None, **kwargs): """ To plot a data set in a multi-dimensional space. Parameters ---------- :param samples: The samples. This should be a 1- or 2-dimensional array. For a 1-D array this results in a simple histogram. For a 2-D array, the zeroth axis is the list of samples and the next axis are the dimensions of the space (see corner.corner). :param labels: the labels Default: ("td", 'dm') :param bnames: the band names. Used for error labels :param bins :param axhist: axes to plot hist2d :return: fig """ # from matplotlib import pyplot as plt import corner # plt.hist(sample_dt, bins=50, histtype="stepfilled", alpha=0.3) # # samples = sampler.chain[:, nburn:, :].reshape((-1, ndim)) # fig = corner.corner(samples, labels=["$delay$", "$dm$", "$lnf$"], # truths=[dt, dm, lnf]) lw = kwargs.get('lw', 2) bins = kwargs.get('bins', 30) alpha = kwargs.get('alpha', 1.) istex = kwargs.get('istex', False) title_fmt = kwargs.get('title_fmt', '.2f') quantiles = kwargs.get('quantiles', [0.16, 0.5, 0.84]) figsize = kwargs.get('figsize', (16, 12)) verbose = kwargs.get('verbose', False) if isinstance(labels, str): labels = [labels] if istex: labels += tuple(r'$\sigma_m(\mathrm{{{}}})$'.format(bn) for bn in bnames) else: labels += tuple('sig+{}'.format(bn) for bn in bnames) hist_kwargs = dict(lw=lw, alpha=0.5) fig = corner.corner(samples, labels=labels, bins=bins, hist_kwargs=hist_kwargs, quantiles=quantiles, show_titles=True, title_fmt=title_fmt, verbose=verbose, title_kwargs={"fontsize": 12}, label_kwargs={ 'labelpad': 1, 'fontsize': 14 }, fontsize=8) fig.set_size_inches(figsize) if axhist is not None: corner.hist2d(samples[:, 0], samples[:, 1], ax=axhist) return fig
def explore_distances(name): ''' ''' dat_dir = os.environ['GALPOPFM_DIR'] if name == 'simba': fhdf5 = os.path.join(dat_dir, 'sed', 'simba.hdf5') else: raise NotImplementedError f = h5py.File(fhdf5, 'r') sed = {} sed['wave'] = f['wave'][...] sed['sed_neb'] = f['sed_neb'][...] sed['sed_noneb'] = f['sed_noneb'][...] sed['sed_onlyneb'] = sed['sed_neb'] - sed['sed_noneb'] # only nebular emissoins sed['logmstar'] = f['logmstar'][...] sed['censat'] = f['censat'][...] f.close() # only keep centrals cens = sed['censat'].astype(bool) theta = np.array([1., 1.5, 1./0.44]) sed_dusty = dustFM.Attenuate( theta, sed['wave'], sed['sed_noneb'][cens,:], sed['sed_onlyneb'][cens,:], sed['logmstar'][cens], dem='slab_calzetti') # magnitudes F_mag_dust = measureObs.AbsMag_sed(sed['wave'], sed_dusty, band='galex_fuv') N_mag_dust = measureObs.AbsMag_sed(sed['wave'], sed_dusty, band='galex_nuv') R_mag_dust = measureObs.AbsMag_sed(sed['wave'], sed_dusty, band='r_sdss') FUV_NUV_dust = F_mag_dust - N_mag_dust #a_fuv_dust = measureObs.A_FUV(F_mag, N_mag, R_mag) wlim = (sed['wave'] > 4e3) & (sed['wave'] < 7e3) # balmer measurements Ha_dust, Hb_dust = measureObs.L_em(['halpha', 'hbeta'], sed['wave'][wlim], sed_dusty[:,wlim]) HaHb_dust = Ha_dust/Hb_dust # read in SDSS measurements fsdss = os.path.join(dat_dir, 'obs', 'tinker_SDSS_centrals_M9.7.valueadd.hdf5') sdss = h5py.File(fsdss, 'r') F_mag_sdss = sdss['ABSMAG'][...][:,0] N_mag_sdss = sdss['ABSMAG'][...][:,1] R_mag_sdss = sdss['ABSMAG'][...][:,4] FUV_NUV_sdss = F_mag_sdss - N_mag_sdss #a_fuv_sdss = measureObs.A_FUV(F_mag_sdss, N_mag_sdss, R_mag_sdss) #print(a_fuv) #print(a_fuv_sdss) Haflux_sdss = sdss['HAFLUX'][...] Hbflux_sdss = sdss['HBFLUX'][...] Ha_sdss = Haflux_sdss * (4.*np.pi * (sdss['Z'][...] * 2.9979e10/2.2685e-18)**2) * 1e-17 Hb_sdss = Hbflux_sdss * (4.*np.pi * (sdss['Z'][...] * 2.9979e10/2.2685e-18)**2) * 1e-17 HaHb_sdss = Ha_sdss/Hb_sdss HaHb_I = 2.86 # intrinsic balmer ratio fig = plt.figure(figsize=(11,5)) # Mr - Balmer ratio sub = fig.add_subplot(121) DFM.hist2d(R_mag_sdss, np.log10(HaHb_sdss/HaHb_I), color='k', levels=[0.68, 0.95], range=[[-15, -24], [-0.1, 0.5]], plot_datapoints=True, fill_contours=False, plot_density=False, ax=sub) DFM.hist2d(R_mag_dust, np.log10(HaHb_dust/HaHb_I), color='C1', levels=[0.68, 0.95], range=[[-15, -24], [-0.1, 0.5]], plot_datapoints=True, fill_contours=False, plot_density=False, ax=sub) #subscatter(R_mag_sdss, np.log10(HaHb_sdss/HaHb_I), c='k', s=0.1, label='SDSS') #sub.scatter(R_mag_dust, np.log10(HaHb_dust/HaHb_I), c='C1', s=0.05, label='SIMBA dust') rmid_sdss, med_sdss = dustInfer.median_alongr(R_mag_sdss, np.log10(HaHb_sdss/HaHb_I), rmin=-16, rmax=-24, nbins=16) rmid_dust, med_dust = dustInfer.median_alongr(R_mag_dust, np.log10(HaHb_dust/HaHb_I), rmin=-16, rmax=-24, nbins=16) print(rmid_sdss, med_sdss) sub.scatter(rmid_sdss, med_sdss, c='k', s=30, marker='x', label='SDSS') sub.scatter(rmid_dust, med_dust, c='C1', s=30, marker='x', label='SIMBA dust') sub.legend(loc='upper left', fontsize=15, handletextpad=0.2) sub.set_xlabel(r'$M_r$', fontsize=20) sub.set_xlim(-15, -24) sub.set_ylabel(r'$\log (H_\alpha/H_\beta)/(H_\alpha/H_\beta)_I$', fontsize=20) sub.set_ylim(-0.1, 0.5) # Mr - A_FUV sub = fig.add_subplot(122) DFM.hist2d(R_mag_sdss, FUV_NUV_sdss, color='k', levels=[0.68, 0.95], range=[[-15, -24], [-0.5, 2.5]], plot_datapoints=True, fill_contours=False, plot_density=False, ax=sub) DFM.hist2d(R_mag_dust, FUV_NUV_dust, color='C1', levels=[0.68, 0.95], range=[[-15, -24], [-0.5, 2.5]], plot_datapoints=True, fill_contours=False, plot_density=False, ax=sub) rmid_sdss, med_sdss = dustInfer.median_alongr(R_mag_sdss, FUV_NUV_sdss, rmin=-16, rmax=-24, nbins=16) rmid_dust, med_dust = dustInfer.median_alongr(R_mag_dust, FUV_NUV_dust, rmin=-16, rmax=-24, nbins=16) sub.scatter(rmid_sdss, med_sdss, c='k', s=30, marker='x') sub.scatter(rmid_dust, med_dust, c='C1', s=30, marker='x') sub.set_xlabel(r'$M_r$', fontsize=20) sub.set_xlim(-16, -24) sub.set_ylabel(r'$FUV - NUV$', fontsize=20) sub.set_ylim(-0.5, 2.5) ffig = fhdf5.replace('.hdf5', '.explore_distance.png') fig.savefig(ffig, bbox_inches='tight') # -- kNN divergence --- #from skl_groups.features import Features #from skl_groups.divergences import KNNDivergenceEstimator #X_sdss = np.vstack([R_mag_sdss, FUV_NUV_sdss, np.log10(HaHb_sdss/HaHb_I)]).T #X_dust = np.vstack([R_mag_dust, FUV_NUV_dust, np.log10(HaHb_dust/HaHb_I)]).T # #kNN = KNNDivergenceEstimator(div_funcs=['kl'], Ks=5, version='slow', clamp=False, n_jobs=1) #feat = Features([X_sdss, X_dust]) #div_knn = kNN.fit_transform(feat) #print(div_knn[0][0][0][1]) return None
plt.rc('font', family='serif') direc = '/users/annaho/Data/LAMOST/Label_Transfer' f = pyfits.open("%s/table_for_paper.fits" %direc) a = f[1].data f.close() feh = a['cannon_m_h'] am = a['cannon_alpha_m'] snr = a['snrg'] choose = snr > 20 print(sum(choose)) print(len(choose)) fig, ax = plt.subplots(1,1, sharex=True, sharey=True, figsize=(8,5)) hist2d(feh[choose], am[choose], ax=ax, bins=100, range=[[-2.2,.9],[-0.2,0.5]]) ax.set_xlabel("[Fe/H] (dex)" + " from Cannon/LAMOST", fontsize=16) fig.text( 0.04, 0.5, r"$\mathrm{[\alpha/M]}$" + " (dex) from Cannon/LAMOST", fontsize=16, va = 'center', rotation='vertical') label = r"Objects with SNR \textgreater 20" props = dict(boxstyle='round', facecolor='white') ax.tick_params(axis='x', labelsize=16) ax.tick_params(axis='y', labelsize=16) ax.text(0.05, 0.85, label, horizontalalignment='left', verticalalignment='bottom', transform=ax.transAxes, fontsize=16, bbox=props) #plt.show() plt.savefig("feh_alpha.png")
def plot_mcmc_chain_with_prior(directory, use_prior=False, only_first_star=True, plot_true_parameters=True, plot_only_SSP_parameter=True): ''' This routine takes the output from 'restructure_chain' function and plots the result in a corner plot set_scale and use_scale can be used to put different PDFs on the same scale, in the sense that the plot is shown with the same axis range. In the paper this is used to plot the Posterior in comparison to the prior distribution. ''' how_many_ssp_parameters = 3 if plot_true_parameters: true_parameters = [-2.37, -2.75, -1.2] true_parameters = np.array(true_parameters) if use_prior: from Chempy.cem_function import gaussian prior = [[-2.3, 0.3], [-2.75, 0.3], [-0.8, 0.3], [-0.3, 0.3], [0.55, 0.1], [0.5, 0.1]] prior = np.array(prior) import corner plt.clf() text_size = 16 cor_text = 22 plt.rc('font', family='serif', size=text_size) plt.rc('xtick', labelsize=text_size) plt.rc('ytick', labelsize=text_size) plt.rc('axes', labelsize=text_size, lw=1.0) plt.rc('lines', linewidth=1) plt.rcParams['ytick.major.pad'] = '8' plt.rcParams['text.latex.preamble'] = [r"\usepackage{libertine}"] params = { 'text.usetex': True, 'font.size': 10, 'font.family': 'libertine', 'text.latex.unicode': True, } plt.rcParams.update(params) positions = np.load('%sposteriorPDF.npy' % (directory)) parameter_names = np.load("%sparameter_names.npy" % (directory)) posterior = np.load('%sposteriorvalues.npy' % (directory)) positions_max = np.load('%sbest_parameter_values.npy' % (directory)) if only_first_star: positions = positions[:, :6] parameter_names = parameter_names[:6] positions_max = positions_max[0][:6] if plot_only_SSP_parameter: positions = positions[:, :how_many_ssp_parameters] parameter_names = parameter_names[:how_many_ssp_parameters] positions_max = positions_max[:how_many_ssp_parameters] nparameter = len(positions[0]) cor_matrix = np.zeros(shape=(nparameter, nparameter)) for i in range(nparameter): for j in range(nparameter): cor_matrix[i, j] = np.corrcoef( (positions[:, i], positions[:, j]))[1, 0] np.save('%scor_matrix' % (directory), cor_matrix) #fig, axes = plt.subplots(nrows=nparameter, ncols=nparameter,figsize=(14.69,8.0), dpi=300)#,sharex=True, sharey=True) fig, axes = plt.subplots(nrows=nparameter, ncols=nparameter, figsize=(5.69, 3.0), dpi=300) #,sharex=True, sharey=True) left = 0.1 # the left side of the subplots of the figure right = 0.925 # the right side of the subplots of the figure bottom = 0.075 # the bottom of the subplots of the figure top = 0.97 # the top of the subplots of the figure wspace = 0.0 # the amount of width reserved for blank space between subplots hspace = 0.0 # the amount of height reserved for white space between subplots plt.subplots_adjust(left=left, bottom=bottom, right=right, top=top, wspace=wspace, hspace=hspace) alpha = 0.5 alpha_more = 0.8 alpha_less = 0.1 lw = 2 for i in range(nparameter): for j in range(nparameter): axes[i, j].locator_params(nbins=4) if j == 1: axes[i, j].locator_params(nbins=4) if i == j: counts, edges = np.histogram(positions[:, j], bins=20) max_count = float(np.max(counts)) counts = np.divide(counts, max_count) axes[i, j].bar(edges[:-1], align='edge', height=counts, width=edges[1] - edges[0], color='grey', alpha=alpha, linewidth=0, edgecolor='blue') if use_prior: xmin = prior[i][0] - 3.5 * prior[i][1] xmax = prior[i][0] + 3.5 * prior[i][1] x_axe = np.linspace(xmin, xmax, 100) y_axe = gaussian(x_axe, prior[i][0], prior[i][1]) axes[i, j].set_xlim((xmin, xmax)) axes[i, j].plot(x_axe, y_axe / max(y_axe), c="k", linestyle='--', alpha=1, lw=lw) else: axes[i, j].set_xlim(min(positions[:, j]), max(positions[:, j])) axes[i, j].set_ylim(0, 1.05) if j != 0: plt.setp(axes[i, j].get_yticklabels(), visible=False) axes[i, j].vlines(np.percentile(positions[:, j], 15.865), axes[i, j].get_ylim()[0], axes[i, j].get_ylim()[1], color='k', alpha=alpha, linewidth=lw, linestyle='dashed') axes[i, j].vlines(np.percentile(positions[:, j], 100 - 15.865), axes[i, j].get_ylim()[0], axes[i, j].get_ylim()[1], color='k', alpha=alpha, linewidth=lw, linestyle='dashed') axes[i, j].vlines(np.percentile(positions[:, j], 50), axes[i, j].get_ylim()[0], axes[i, j].get_ylim()[1], color='k', alpha=alpha, linewidth=lw) axes[i, j].text(0.5, 1.03, r'$%.2f_{-%.2f}^{+%.2f}$' % (np.percentile(positions[:, j], 50), np.percentile(positions[:, j], 50) - np.percentile(positions[:, j], 15.865), np.percentile(positions[:, j], 100 - 15.865) - np.percentile(positions[:, j], 50)), fontsize=text_size, ha="center", transform=axes[i, j].transAxes) if plot_true_parameters: if i < 3: axes[i, j].vlines(true_parameters[i], axes[i, j].get_ylim()[0], axes[i, j].get_ylim()[1], color='r', alpha=alpha, linewidth=lw, linestyle='solid') if i > j: if j != 0: plt.setp(axes[i, j].get_yticklabels(), visible=False) corner.hist2d(positions[:, j], positions[:, i], ax=axes[i, j], bins=15, levels=(1 - np.exp(-0.5), 1 - np.exp(-2.0), 1 - np.exp(-4.5))) #axes[i,j].plot(positions_max[:,j],positions_max[:,i],'kx',markersize = 10,mew=2.5) #im = axes[i,j].scatter(positions[:,j],positions[:,i],c='k',edgecolor='None',s=45,marker='o',alpha=alpha_less,rasterized=True)#,vmin=0,vmax=vmax) #axes[i,j].hist2d(positions[:,j],positions[:,i],cmap = my_cmap, vmin=1) if use_prior: xmin = prior[j][0] - 3.5 * prior[j][1] xmax = prior[j][0] + 3.5 * prior[j][1] axes[i, j].set_xlim((xmin, xmax)) a_length = 3. * prior[j][1] b_length = 3. * prior[i][1] parametric = np.linspace(0, 2 * np.pi, 100) x_axis = a_length * np.cos(parametric) + prior[j][0] ymin = prior[i][0] - 3.5 * prior[i][1] ymax = prior[i][0] + 3.5 * prior[i][1] axes[i, j].set_ylim((ymin, ymax)) y_axis = b_length * np.sin(parametric) + prior[i][0] axes[i, j].plot(x_axis, y_axis, c="k", linestyle='--', alpha=1, lw=lw) #axes[i,j].set_ylim(borders[t][1]) else: axes[i, j].set_xlim(min(positions[:, j]), max(positions[:, j])) axes[i, j].set_ylim(min(positions[:, i]), max(positions[:, i])) if plot_true_parameters: #if i < 3: # axes[i,j].hlines(true_parameters[i],axes[i,j].get_xlim()[0],axes[i,j].get_xlim()[1], color = 'r',alpha=alpha,linewidth = lw,linestyle = 'solid') #if j < 3: # axes[i,j].vlines(true_parameters[j],axes[i,j].get_ylim()[0],axes[i,j].get_ylim()[1], color = 'r',alpha=alpha,linewidth = lw,linestyle = 'solid') if i < 3 and j < 3: axes[i, j].plot(true_parameters[j], true_parameters[i], 'rx', lw=lw, alpha=1) if j > i: correlation_coefficient = np.corrcoef( (positions[:, i], positions[:, j])) axes[i, j].text(0.6, 0.5, "%.2f" % (correlation_coefficient[1, 0]), fontsize=cor_text, ha="center", transform=axes[i, j].transAxes) axes[i, j].axis('off') if i == nparameter - 1: axes[i, j].set_xlabel(parameter_names[j]) if j == 0: axes[i, j].set_ylabel(parameter_names[i]) if nparameter >= 2: axes[0, 1].set_title( 'best posterior = %.2f, obtained at %s and %d evals (4992 total)' % (np.max(posterior), str(positions_max), len(posterior))) fig.savefig('%sparameter_space_sorted.png' % (directory), dpi=300, bbox_inches='tight')
def main(): train_covar = covar_gen(args.covar, args.n_train_points).astype(np.float32) train_data_clean = data_gen(args.data, args.n_train_points)[0].astype(np.float32) # plt.scatter(train_data_clean[:, 0], train_data_clean[:, 1]) train_data = np.zeros_like(train_data_clean) for i in range(args.n_train_points): train_data[i] = train_data_clean[i] + np.random.multivariate_normal( mean=np.zeros((2, )), cov=train_covar[i]) # plt.scatter(train_data[:, 0], train_data[:, 1]) # plt.show() train_covar = torch.from_numpy(train_covar) train_data = torch.from_numpy(train_data.astype(np.float32)) train_dataset = DeconvDataset(train_data, train_covar) train_loader = DataLoader(train_dataset, batch_size=args.batch_size, shuffle=True) test_data_clean = torch.from_numpy( data_gen(args.data, args.n_test_points)[0].astype(np.float32)) eval_covar = covar_gen(args.covar, args.n_eval_points).astype(np.float32) eval_data_clean = data_gen(args.data, args.n_eval_points)[0].astype(np.float32) eval_data = np.zeros_like(eval_data_clean) for i in range(args.n_eval_points): eval_data[i] = eval_data_clean[i] + np.random.multivariate_normal( mean=np.zeros((2, )), cov=eval_covar[i]) eval_covar = torch.from_numpy(eval_covar) eval_data = torch.from_numpy(eval_data.astype(np.float32)) eval_dataset = DeconvDataset(eval_data, eval_covar) eval_loader = DataLoader(eval_dataset, batch_size=args.test_batch_size, shuffle=False) if args.infer == 'true_data': model = SVIFlowToy(dimensions=2, objective=args.objective, posterior_context_size=args.posterior_context_size, batch_size=args.batch_size, device=device, maf_steps_prior=args.flow_steps_prior, maf_steps_posterior=args.flow_steps_posterior, maf_features=args.maf_features, maf_hidden_blocks=args.maf_hidden_blocks, K=args.K) else: model = SVIFlowToyNoise( dimensions=2, objective=args.objective, posterior_context_size=args.posterior_context_size, batch_size=args.batch_size, device=device, maf_steps_prior=args.flow_steps_prior, maf_steps_posterior=args.flow_steps_posterior, maf_features=args.maf_features, maf_hidden_blocks=args.maf_hidden_blocks, K=args.K) message = 'Total number of parameters: %s' % (sum( p.numel() for p in model.parameters())) logger.info(message) optimizer = torch.optim.Adam(params=model.parameters(), lr=args.lr) #training scheduler = list(map(int, args.eval_based_scheduler.split(','))) epoch = 0 best_model = copy.deepcopy(model.state_dict()) best_eval_loss = compute_eval_loss(model, eval_loader, device, args.n_eval_points) n_epochs_not_improved = 0 model.train() while n_epochs_not_improved < scheduler[-1] and epoch < args.n_epochs: for batch_idx, data in enumerate(train_loader): data[0] = data[0].to(device) data[1] = data[1].to(device) loss = -model.score(data).mean() optimizer.zero_grad() loss.backward(retain_graph=True) optimizer.step() model.eval() eval_loss = compute_eval_loss(model, eval_loader, device, args.n_eval_points) if eval_loss < best_eval_loss: best_model = copy.deepcopy(model.state_dict()) best_eval_loss = eval_loss n_epochs_not_improved = 0 else: n_epochs_not_improved += 1 lr_scheduler(n_epochs_not_improved, optimizer, scheduler, logger) if (epoch + 1) % args.test_freq == 0: if args.infer == 'true_data': test_loss_clean = -model.model._prior.log_prob( test_data_clean.to(device)).mean() else: test_loss_clean = -model.model._likelihood.log_prob( test_data_clean.to(device)).mean() message = 'Epoch %s:' % ( epoch + 1 ), 'train loss = %.5f' % loss, 'eval loss = %.5f' % eval_loss, 'test loss (clean) = %.5f' % test_loss_clean logger.info(message) else: message = 'Epoch %s:' % ( epoch + 1), 'train loss = %.5f' % loss, 'eval loss = %.5f' % eval_loss logger.info(message) if (epoch + 1) % args.viz_freq == 0: if args.infer == 'true_data': samples = model.model._prior.sample( 1000).detach().cpu().numpy() else: samples = model.model._likelihood.sample( 1000).detach().cpu().numpy() corner.hist2d(samples[:, 0], samples[:, 1]) fig_filename = args.dir + 'out/' + name + '_corner_fig_' + str( epoch + 1) + '.png' plt.savefig(fig_filename) plt.close() plt.scatter(samples[:, 0], samples[:, 1]) fig_filename = args.dir + 'out/' + name + '_scatter_fig_' + str( epoch + 1) + '.png' plt.savefig(fig_filename) plt.close() model.train() epoch += 1 model.load_state_dict(best_model) model.eval() if args.infer == 'true_data': test_loss_clean = -model.model._prior.log_prob( test_data_clean.to(device)).mean() else: test_loss_clean = -model.model._likelihood.log_prob( test_data_clean.to(device)).mean() message = 'Final test loss (clean) = %.5f' % test_loss_clean logger.info(message) torch.save(model.state_dict(), args.dir + 'models/' + name + '.model') logger.info('Training has finished.') if args.data.split('_')[0] == 'mixture' or args.data.split( '_')[0] == 'gaussian': kl_points = data_gen(args.data, args.n_kl_points)[0].astype(np.float32) if args.infer == 'true_data': model_log_prob = model.model._prior.log_prob( torch.from_numpy(kl_points.astype( np.float32)).to(device)).mean() else: model_log_prob = model.model._likelihood.log_prob( torch.from_numpy(kl_points.astype( np.float32)).to(device)).mean() data_log_prob = compute_data_ll(args.data, kl_points).mean() approximate_KL = data_log_prob - model_log_prob message = 'KL div %.5f:' % approximate_KL logger.info(message)
def Illustris_SFH(): ''' Figure that uses Illustris SFHs to justify our model of galaxies ''' # read in illustris SFH file from Tijske dat = h5py.File(UT.dat_dir()+'binsv2all1e8Msunh_z0.hdf5', 'r') # formed stellar mass is in a grid of time bins and metallicity t_bins = np.array([0.0, 0.005, 0.015, 0.025, 0.035, 0.045, 0.055, 0.065, 0.075, 0.085, 0.095, 0.125,0.175,0.225,0.275,0.325,0.375,0.425,0.475,0.55,0.65,0.75,0.85,0.95,1.125,1.375,1.625,1.875,2.125,2.375,2.625,2.875,3.125,3.375,3.625,3.875,4.25,4.75,5.25,5.75,6.25,6.75,7.25,7.75,8.25,8.75,9.25,9.75,10.25,10.75,11.25,11.75,12.25,12.75,13.25,13.75]) galpop = {} galpop['M*'] = dat['CurrentStellarMass'].value.flatten() * 1e10 # current stellar mass # calculate SFRs # first sum up all the metallicities so you have delta M* in a grid of galaxies and time # then average SFR over the 0.015 Gyr time period sfh_grid = dat['FormedStellarMass'].value dM_t = np.sum(sfh_grid, axis=1) #galpop['sfr'] = (1e10 * (dM_t[:,0] + dM_t[:,1])/(0.015 * 1e9)).flatten() sfhs = np.zeros((len(galpop['M*']), len(t_bins)-2)) t_mid = np.zeros(len(t_bins)-2) # z=0 SFR averaged over 150Myr sfhs[:,0] = (1e10 * (dM_t[:,0] + dM_t[:,1])/(0.015 * 1e9)).flatten() sfhs[:,1:] = 10.*(dM_t[:,2:-1]/(t_bins[3:] - t_bins[2:-1])) t_mid[0] = 0.0075 t_mid[1:] = 0.5 *(t_bins[3:] + t_bins[2:-1]) # stellar mass one timestep ago M_t_1 = np.zeros((len(galpop['M*']), len(t_bins)-1)) M_t_1[:,0] = galpop['M*'] - 1e10 * (dM_t[:,0] + dM_t[:,1]) for i in range(1,M_t_1.shape[1]): M_t_1[:,i] = M_t_1[:,i-1] - 1e10 * dM_t[:,i+1] # stellar mass history at t_mid Msh = 0.5 * (M_t_1[:,:-1] + M_t_1[:,1:]) # calculate delta log SFR for galaxies by fitting SFMS every 10 time bins dlogsfrs, t_skip = [], [] for i in range(len(t_mid)-12): fSFMS = fstarforms() fit_logm_i, fit_logsfr_i = fSFMS.fit(np.log10(Msh[:,i]), np.log10(sfhs[:,i]), method='gaussmix', fit_range=[9.0, 10.5], dlogm=0.2) sfms_fit_i = fSFMS.powerlaw(logMfid=10.5) fig = plt.figure() sub = fig.add_subplot(111) DFM.hist2d(np.log10(Msh[:,i]), np.log10(sfhs[:,i]), levels=[0.68, 0.95], range=[[9., 12.], [-3., 2.]], bins=16, ax=sub) sub.scatter(fit_logm_i, fit_logsfr_i, c='r', marker='x') sub.text(0.95, 0.1, '$t_\mathrm{cosmic} = '+str(13.75 - t_mid[i])+'$', ha='right', va='center', transform=sub.transAxes, fontsize=20) m_arr = np.linspace(9.0, 12.0, 20) sub.plot(m_arr, sfms_fit_i(m_arr), c='k', lw=2, ls='--') fig.savefig(''.join([UT.fig_dir(), 'illustris.sfms.', str(i), '.png']), bbox_inches='tight') plt.close() if fSFMS._powerlaw_m < 0.5 or fSFMS._powerlaw_m > 1.5 or len(fit_logm_i) < 3: continue dlogsfrs.append(np.log10(sfhs[:,i]) - sfms_fit_i(np.log10(Msh[:,i]))) t_skip.append(t_mid[i]) # now fit SFMS at z ~ 0 fSFMS = fstarforms() fit_logm, fit_logsfr = fSFMS.fit(np.log10(galpop['M*']), np.log10(sfhs[:,0]), method='gaussmix', fit_range=[9.0, 10.5], dlogm=0.2) sfms_fit = fSFMS.powerlaw(logMfid=10.5) # star-forming galaxies at z ~ 0 z0sf = ((np.log10(sfhs[:,0]) > sfms_fit(np.log10(galpop['M*']))-0.5) & (np.log10(galpop['M*']) > 10.5) & (np.log10(galpop['M*']) < 10.6)) #z0q = ((np.log10(sfhs[:,0]) < sfms_fit(np.log10(galpop['M*']))-0.9) & # (np.log10(galpop['M*']) > 10.5) & (np.log10(galpop['M*']) < 10.6)) fig = plt.figure() sub = fig.add_subplot(111) for i in np.arange(len(z0sf))[z0sf]: sub.plot(t_bins[-1] - t_skip, np.array(dlogsfrs)[:,i], c='k', alpha=0.1, lw=0.1) z0sf = ((np.log10(sfhs[:,0]) > sfms_fit(np.log10(galpop['M*']))-0.1) & (np.log10(galpop['M*']) > 10.5) & (np.log10(galpop['M*']) < 10.6)) for ii, i in enumerate(np.random.choice(np.arange(len(z0sf))[z0sf], 10)): sub.plot(t_bins[-1] - t_skip, np.array(dlogsfrs)[:,i], lw=1, c='C'+str(ii)) sub.set_xlim([11., 13.75]) sub.set_xlabel('$t_\mathrm{cosmic}$ [Gyr]', fontsize=25) sub.set_ylim([-.6, .6]) sub.set_yticks([-0.4, 0., 0.4]) sub.set_ylabel('$\Delta$ log $(\;\mathrm{SFR}\;[M_\odot/\mathrm{yr}]\;)$', fontsize=25) fig.savefig(''.join([UT.tex_dir(), 'figs/illustris_sfh.pdf']), bbox_inches='tight', dpi=150) plt.close() return None
def qaplotABC(run, T, sumstat=['smf'], nsnap0=15, sigma_smhm=0.2, downsampled='20', theta=None, figure=None): ''' Quality assurance plot for ABC runs. Plot summary statistic(s), SMHMR, SFMS ''' # first compare data summary statistics to Sim(median theta) if theta is None: abcout = ABC.readABC(run, T) # median theta theta_med = [UT.median(abcout['theta'][:, i], weights=abcout['w'][:]) for i in range(len(abcout['theta'][0]))] else: theta_med = theta # summary statistics of data sumdata = ABC.dataSum(sumstat=sumstat) # summary statistics of model subcat_sim = ABC.model(run, theta_med, nsnap0=nsnap0, downsampled=downsampled) sumsim = ABC.modelSum(subcat_sim, sumstat=sumstat) theta_info = ABC.Theta() sim_lbl = ', \n'.join([ttt+'='+str(round(tm,2)) for ttt, tm in zip(theta_info['label'], theta_med)]) fig = plt.figure(figsize=(5*(len(sumstat)+5),4)) mbin = np.arange(8.1, 11.9, 0.1) - 2.*np.log10(0.7) for i_s, stat in enumerate(sumstat): if stat == 'smf': sub = fig.add_subplot(1, len(sumstat)+5, i_s+1) # Li-White SMF marr, phi, phierr = Obvs.dataSMF(source='li-white') phi *= (1. - np.array([Obvs.f_sat(mm, 0.05) for mm in marr])) # sallite fraction # central SMF phierr *= np.sqrt(1./(1.-np.array([Obvs.f_sat(mm, 0.05) for mm in marr]))) #sub.errorbar(marr, phi, phierr, fmt='.k', label='Data') sub.fill_between(marr, phi-phierr, phi+phierr, color='k', alpha=0.5, linewidth=0, label='Data') #sub.plot(0.5*(mbin[1:]+mbin[:-1]), sumdata[0], c='k', ls='--', label='Data') sub.plot(0.5*(mbin[1:]+mbin[:-1]), sumsim[0], c='C0', label='Sim.')# \n'+sim_lbl) # SF central SMF isSF = (subcat_sim['galtype'] == 'sf') fsfs = np.clip(Evol.Fsfms(marr), 0., 1.) fsfs_errscale = np.ones(len(marr)) fsfs_errscale[fsfs < 1.] = np.sqrt(1./(1.-fsfs[fsfs < 1.])) sub.errorbar(marr, fsfs * phi, fsfs_errscale * phierr, fmt='.k') # data mmm, smf_sf = Obvs.getMF(subcat_sim['m.star'][isSF], weights=subcat_sim['weights'][isSF]) sub.plot(mmm, smf_sf, c='C0', ls='--') sub.set_xlabel('$log\;M_*$', fontsize=25) sub.set_xlim([9., 12.]) sub.set_ylabel('$\Phi$', fontsize=25) sub.set_ylim([1e-6, 10**-1.75]) sub.set_yscale('log') sub.legend(loc='lower left', fontsize=20) else: raise NotImplementedError # SHMR panel of SF galaxies sub = fig.add_subplot(1,len(sumstat)+5,len(sumstat)+1) # SMHMR panel of SF galaxies isSF = ((subcat_sim['galtype'] == 'sf') & (subcat_sim['weights'] > 0.)) # only SF galaxies # SHAM SMHMR DFM.hist2d(subcat_sim['m.max'][isSF], subcat_sim['m.sham'][isSF], weights=subcat_sim['weights'][isSF], levels=[0.68, 0.95], range=[[10., 14.], [9., 12.]], color='k', plot_datapoints=True, fill_contours=False, plot_density=True, ax=sub) # model DFM.hist2d(subcat_sim['m.max'][isSF], subcat_sim['m.star'][isSF], weights=subcat_sim['weights'][isSF], levels=[0.68, 0.95], range=[[10., 14.], [9., 12.]], color='C0', plot_datapoints=False, fill_contours=False, plot_density=False, ax=sub) DFM.hist2d(subcat_sim['halo.m'][isSF], subcat_sim['m.star'][isSF], weights=subcat_sim['weights'][isSF], levels=[0.68, 0.95], range=[[10., 14.], [9., 12.]], color='C1', plot_datapoints=True, fill_contours=False, plot_density=True, ax=sub) sub.plot([0.,0.], [0.,0.], c='k', lw=2, label='SHAM') sub.plot([0.,0.], [0.,0.], c='C1', lw=2, label='model') sub.legend(loc='lower right', fontsize=15) sub.set_xlabel('$log\;M_{halo}$', fontsize=25) sub.set_xlim([10.5, 14]) sub.set_ylabel('$log\,M_*$', fontsize=25) sub.set_ylim([9.0, 11.5]) # scatter in the SHMR panel of SF galaxies sub = fig.add_subplot(1,len(sumstat)+5,len(sumstat)+2) isSF = np.where(subcat_sim['galtype'] == 'sf') # only SF galaxies smhmr = Obvs.Smhmr() # simulation m_mid, mu_mhalo, sig_mhalo, cnts = smhmr.Calculate(subcat_sim['halo.m'][isSF], subcat_sim['m.star'][isSF], dmhalo=0.2, weights=subcat_sim['weights'][isSF]) enough = (cnts > 20) sub.plot(m_mid[enough], sig_mhalo[enough], c='C0', lw=2, label='($M_{h}$)') sig_sim = sig_mhalo[np.argmin(np.abs(m_mid-12.))] m_mid, mu_mhalo, sig_mhalo, cnts = smhmr.Calculate(subcat_sim['m.max'][isSF], subcat_sim['m.star'][isSF], dmhalo=0.2, weights=subcat_sim['weights'][isSF]) enough = (cnts > 20) sub.plot(m_mid[enough], sig_mhalo[enough], c='#1F77B4', ls=':', lw=1, label='($M_{max}$)') # SHAM "data" m_mid, mu_mhalo, sig_mhalo, cnts = smhmr.Calculate(subcat_sim['halo.m'][isSF], subcat_sim['m.sham'][isSF], dmhalo=0.2, weights=subcat_sim['weights'][isSF]) enough = (cnts > 20) sub.plot(m_mid[enough], sig_mhalo[enough], c='k', ls='--') sig_dat = sig_mhalo[np.argmin(np.abs(m_mid-12.))] # mark sigma_M*(M_h = 10^12) sub.text(0.95, 0.95, ''.join(['$\sigma^{(s)}_{M_*}(M_h = 10^{12} M_\odot) = ', str(round(sig_sim,2)), '$ \n', '$\sigma^{(d)}_{M_*}(M_h = 10^{12} M_\odot) = ', str(round(sig_dat,2)), '$']), fontsize=15, ha='right', va='top', transform=sub.transAxes) sub.legend(loc='lower left', fontsize=15) sub.set_xlabel('$log\;M_{halo}$', fontsize=25) sub.set_xlim([10.6, 15.]) sub.set_ylabel('$\sigma_{log\,M_*}$', fontsize=25) sub.set_ylim([0., 0.6]) # SFMS panel tt = ABC._model_theta(run, theta_med) sub = fig.add_subplot(1, len(sumstat)+5, len(sumstat)+3) DFM.hist2d( subcat_sim['m.star'][isSF], subcat_sim['sfr'][isSF], weights=subcat_sim['weights'][isSF], levels=[0.68, 0.95], range=[[8., 12.], [-4., 2.]], color='#1F77B4', plot_datapoints=True, fill_contours=False, plot_density=True, ax=sub) sub.set_xlabel('$\log\;M_*$', fontsize=25) sub.set_xlim([8., 12.]) sub.set_ylabel('$\log\;\mathrm{SFR}$', fontsize=25) sub.set_ylim([-4., 2.]) # dSFR as a function of t_cosmic sub = fig.add_subplot(1, len(sumstat)+5, len(sumstat)+4) mbins = np.linspace(9., 12., 10) i_r = [] # select random SF galaxies over mass bins for i_m in range(len(mbins)-1): inmbin = np.where( (subcat_sim['galtype'] == 'sf') & (subcat_sim['nsnap_start'] == nsnap0) & (subcat_sim['weights'] > 0) & (subcat_sim['m.star'] > mbins[i_m]) & (subcat_sim['m.star'] <= mbins[i_m+1])) if len(inmbin[0]) > 0: i_r.append(np.random.choice(inmbin[0], size=1)[0]) i_r = np.array(i_r) # calculate d(logSFR) = logSFR - logSFR_MS dlogsfrs = np.zeros((len(i_r), nsnap0-1)) for i_snap in range(1, nsnap0): snap_str = '' if i_snap != 1: snap_str = '.snap'+str(i_snap) sfr = subcat_sim['sfr'+snap_str][i_r] sfr_ms = SFH.SFR_sfms(subcat_sim['m.star'+snap_str][i_r], UT.z_nsnap(i_snap), tt['sfms']) dlogsfrs[:,i_snap-1] = sfr - sfr_ms for i in range(dlogsfrs.shape[0]): sub.plot(UT.t_nsnap(range(1, nsnap0))[::-1], dlogsfrs[i,:][::-1]) for i in range(1, nsnap0): sub.vlines(UT.t_nsnap(i), -1., 1., color='k', linestyle='--', linewidth=0.5) sub.set_xlim([UT.t_nsnap(nsnap0-1), UT.t_nsnap(1)]) #sub.set_xticks([13., 12., 11., 10., 9.]) sub.set_xlabel('$t_\mathrm{cosmic}$ [Gyr]', fontsize=25) sub.set_ylim([-1., 1.]) sub.set_yticks([-0.9, -0.6, -0.3, 0., 0.3, 0.6, 0.9]) sub.set_ylabel('$\Delta \log\,\mathrm{SFR}$', fontsize=25) sub = fig.add_subplot(1, len(sumstat)+5, len(sumstat)+5) mbins = np.linspace(9., 12., 20) fq = np.zeros(len(mbins)-1) fq_sham = np.zeros(len(mbins)-1) for im in range(len(mbins)-1): inmbin = ((subcat_sim['m.star'] > mbins[im]) & (subcat_sim['m.star'] < mbins[im+1]) & (subcat_sim['weights'] > 0)) inmbin0 = ((subcat_sim['m.sham'] > mbins[im]) & (subcat_sim['m.sham'] < mbins[im+1]) & (subcat_sim['weights'] > 0)) if np.sum(inmbin) > 0: fq[im] = np.sum(subcat_sim['weights'][inmbin & (subcat_sim['galtype'] == 'sf')])/np.sum(subcat_sim['weights'][inmbin]) if np.sum(inmbin0) > 0: fq_sham[im] = np.sum(subcat_sim['weights'][inmbin0 & (subcat_sim['galtype'] == 'sf')])/np.sum(subcat_sim['weights'][inmbin0]) sub.plot(0.5*(mbins[1:] + mbins[:-1]), 1.-fq, c='C1') sub.plot(0.5*(mbins[1:] + mbins[:-1]), 1.-fq_sham, c='k', ls='--') sub.set_xlim([9., 12.]) sub.set_ylim([0., 1.]) fig.subplots_adjust(wspace=.3) if theta is None: fig_name = ''.join([UT.dat_dir(), 'abc/', run, '/', 'qaplot.t', str(T), '.', run, '.png']) fig.savefig(fig_name, bbox_inches='tight') plt.close() else: if figure is None: plt.show() else: fig.savefig(figure, bbox_inches='tight') plt.close() return None
for j in range(len(fspot)): # load posteriors dat = np.load('posteriors/' + name + '_' + fspot[j] + '.age-mass.posterior.npz') logM, logAGE = dat['logM'], dat['logAGE'] all_logM = np.append(all_logM, logM) all_logAGE = np.append(all_logAGE, logAGE) # corner plot if j == 0: corner.hist2d(logM, logAGE, plot_datapoints=False, bins=nbins, ax=ax0, levels=[levs[0]], range=prange, no_fill_contours=True, plot_density=False, color=lcol[j]) qf00 = corner.quantile(logAGE, quants) else: corner.hist2d(logM, logAGE, plot_datapoints=False, bins=nbins, levels=[levs[0]], range=prange, no_fill_contours=True, plot_density=False, color=lcol[j],
def create_plot_binary(dist=100.0, num_sys=100, bins=25): """ Create a set of random binaries and plot the distribution of resulting theta vs pm Parameters ---------- dist : float Distance to the population for angular (rather than physical) units (pc) num_sys : float Number of random binaries to generate bins : int Number of bins for contours Returns ------- None """ global binary_set if binary_set is None or len(binary_set) != num_sys: generate_binary_set(num_sys=num_sys, dist=dist) fig, ax1 = plt.subplots(1, 1, figsize=(6, 4)) # Plot limits xmin, xmax = 0.0, 5000.0 ymin, ymax = 0.0, 3.0 ax1.set_xlim(xmin, xmax) ax1.set_ylim(ymin, ymax) # Plot labels ax1.set_xlabel("Projected separation (AU)") ax1.set_ylabel("Proper motion difference (km/s)") # Plot distribution contourf_kwargs = {'bins': bins} corner.hist2d(binary_set['proj_sep'] * c.Rsun_to_cm / c.AU_to_cm, binary_set['pm'], nbins=bins, range=([xmin, xmax], [ymin, ymax]), **contourf_kwargs) # Add angular separation at dist axis ax2 = ax1.twiny() xticks = np.linspace(xmin, xmax, 6) angles = (xticks * c.AU_to_cm) / (dist * c.pc_to_cm) * (180.0 * 3600.0 / np.pi) ax2.set_xticks(angles) ax2.set_xlabel('Angular separation at distance of ' + str(dist) + ' pc (arcsec)') # Add proper motion at dist axis ax3 = ax1.twinx() yticks = np.linspace(ymin, ymax, 7) def pm_at_dist(pm, dist=100.0): return (pm * 1.0e5) / (dist * c.pc_to_cm) * ( 1.0e3 * 180.0 * 3600.0 / np.pi) * c.day_to_sec * 365.25 ax3.set_ylim(0.0, pm_at_dist(ax1.get_ylim()[1], dist=dist)) ax3.set_ylabel('Proper motion at distance of ' + str(dist) + ' pc (mas/yr)') plt.tight_layout() plt.show()
\usepackage{lmodern} '''.split())) plt.rc('font', family='serif') f = pyfits.open("../make_lamost_catalog/table_for_paper.fits") a = f[1].data f.close() feh = a['cannon_m_h'] am = a['cannon_alpha_m'] snr = a['snrg'] choose = snr > 50 fig, axarr = plt.subplots(2,1, sharex=True, sharey=True, figsize=(8,10)) hist2d(feh[choose], am[choose], ax=axarr[0], bins=100, range=[[-2.2,.9],[-0.2,0.5]]) hist2d(feh, am, ax=axarr[1], bins=100, range=[[-2.2,.9],[-0.2,0.5]]) axarr[1].set_xlabel("[Fe/H] (dex)" + " from Cannon/LAMOST", fontsize=16) #axarr[1].set_ylabel(r"$\mathrm{[\alphaup/M]}$" + " (dex) from Cannon/LAMOST", fontsize=16) fig.text(0.04, 0.5, r"$\mathrm{[\alphaup/M]}$" + " (dex) from Cannon/LAMOST", fontsize=16, va = 'center', rotation='vertical') labels = [r"Objects with SNR \textgreater 50", r"All Objects"] props = dict(boxstyle='round', facecolor='white') for i,ax in enumerate(axarr): ax.tick_params(axis='x', labelsize=16) ax.tick_params(axis='y', labelsize=16) ax.text(0.05, 0.85, labels[i], horizontalalignment='left', verticalalignment='bottom', transform=ax.transAxes, fontsize=16, bbox=props) #plt.show() plt.savefig("feh_alpha.png")
def qaplotABC(runs=['test0', 'randomSFH_0.5gyr'], Ts=[14, 11]): ''' Figure that illustrates how the ABC fitting works using two different runs overplotted on it each other ''' nsnap0 = 15 sigma_smhm = 0.2 sumstat = ['smf'] # summary statistics of data (i.e. the SMF) subcat_dat = ABC.Data(nsnap0=nsnap0, sigma_smhm=sigma_smhm) # 'data' sumdata = ABC.SumData(sumstat, info=True, nsnap0=nsnap0, sigma_smhm=sigma_smhm) subcat_sims, sumsims = [], [] for run, T in zip(runs, Ts): # get median theta from ABC runs abcout = ABC.readABC(run, T) theta_med = [np.median(abcout['theta'][:,i]) for i in range(abcout['theta'].shape[1])] # read in Model(theta_med) abc_dir = UT.dat_dir()+'abc/'+run+'/model/' # directory where all the ABC files are stored f = h5py.File(''.join([abc_dir, 'model.theta_median0.t', str(T), '.hdf5']), 'r') subcat_sim = {} for key in f.keys(): subcat_sim[key] = f[key].value subcat_sims.append(subcat_sim) sumsims.append(ABC.SumSim(sumstat, subcat_sim, info=True)) colors = ['#EE6A50', '#1F77B4'] #labels = [r'model($\theta_\mathrm{median}$)', r'model($\theta_\mathrm{median}$)'] labels = [None for r in runs] if 'test0' in runs: labels[runs.index('test0')] = 'No duty cycle' if 'randomSFH_1gyr' in runs: labels[runs.index('randomSFH_1gyr')] = '$t_\mathrm{duty} = 1$ Gyr' if 'randomSFH_0.5gyr' in runs: labels[runs.index('randomSFH_0.5gyr')] = '$t_\mathrm{duty} = 0.5$ Gyr' fig = plt.figure(figsize=(16,5)) _, _, phi_err = Obvs.MF_data(source='li-white', m_arr=sumdata[0][0]) # get uncertainties of central SMF phi_err *= np.sqrt(1./(1.-np.array([Obvs.f_sat(mm, 0.05) for mm in sumdata[0][0]]))) # now scale err by f_cen # --- SMF panel --- sub = fig.add_subplot(1,3,1) sub.errorbar(sumdata[0][0], sumdata[0][1], yerr=phi_err, fmt='.k', label=r'$\Phi_\mathrm{cen}^{\footnotesize \mathrm{Li}\&\mathrm{White}(2009)}$') #label='$f_\mathrm{cen} \Phi^{\mathrm{Li}\&\mathrm{White}(2009)}$') for i_s, sumsim in enumerate(sumsims): if i_s == len(sumsims)-1: sub.plot(sumsim[0][0], sumsim[0][1], c=colors[i_s], ls='--')#, label=r'model($\theta_\mathrm{median}$)') else: sub.plot(sumsim[0][0], sumsim[0][1], c=colors[i_s])#, label=r'model($\theta_\mathrm{median}$)') sub.set_xlim([9.5, 11.75]) sub.set_xlabel('log $(\; M_*\; [M_\odot]\;)$', fontsize=25) sub.set_ylim([1e-5, 10**-1.75]) sub.set_yscale('log') sub.set_ylabel('log $(\;\Phi\; / \mathrm{Mpc}^{-3}\,\mathrm{dex}^{-1}\;)$', fontsize=25) sub.legend(loc='lower left', prop={'size':20}) # --- SFMS panel --- sub = fig.add_subplot(1,3,2) #gc = Cat.Observations('group_catalog', Mrcut=18, position='central') #gc_cat = gc.Read() #sub.scatter(gc_cat['mass'], gc_cat['sfr'], s=2) for i_s, subcat_sim in enumerate(subcat_sims): isSF = np.where(subcat_sim['gclass'] == 'sf') # only SF galaxies DFM.hist2d( subcat_sim['m.star'][isSF], subcat_sim['sfr'][isSF], weights=subcat_sim['weights'][isSF], levels=[0.68, 0.95], range=[[9., 12.], [-3., 1.]], color=colors[i_s], bins=20, plot_datapoints=False, fill_contours=False, plot_density=True, ax=sub) # observations #m_arr = np.arange(8., 12.1, 0.1) #sfr_arr = SFH.SFR_sfms(m_arr, UT.z_nsnap(1), subcat_sim['theta_sfms']) #sub.plot(m_arr, sfr_arr+0.3, ls='--', c='k') #sub.plot(m_arr, sfr_arr-0.3, ls='--', c='k') sub.set_xlim([9., 11.5]) sub.set_xticks([9., 10., 11.]) sub.set_xlabel('log $(\; M_*\; [M_\odot]\;)$', fontsize=25) sub.set_ylim([-2.5, 1.]) sub.set_yticks([-2., -1., 0., 1.]) sub.set_ylabel('log $(\;\mathrm{SFR}\;[M_\odot/\mathrm{yr}])$', fontsize=25) # --- sigma_logM* panel --- sub = fig.add_subplot(1,3,3) smhmr = Obvs.Smhmr() # simulation mhalo_bin = np.linspace(10., 15., 11) for i_s, subcat_sim in enumerate(subcat_sims): abc_dir = UT.dat_dir()+'abc/'+runs[i_s]+'/model/' # directory where all the ABC files are stored isSF = np.where(subcat_sim['gclass'] == 'sf') # only SF galaxies m_mid, mu_mhalo, sig_mhalo, cnts = smhmr.Calculate( subcat_sim['halo.m'][isSF], subcat_sim['m.star'][isSF], dmhalo=0.5, weights=subcat_sim['weights'][isSF], m_bin=mhalo_bin) #sub.plot(m_mid, sig_mhalo, c='#1F77B4', lw=2, label='Model') for i in range(1000): f = h5py.File( ''.join([abc_dir, 'model.theta', str(i), '.t', str(Ts[i_s]), '.hdf5']), 'r') subcat_sim_i = {} for key in f.keys(): subcat_sim_i[key] = f[key].value #subcat_sim_i = ABC.model(run, theta_i, # nsnap0=nsnap0, sigma_smhm=sigma_smhm, downsampled='14') isSF = np.where(subcat_sim_i['gclass'] == 'sf') # only SF galaxies m_mid_i, _, sig_mhalo_i, cnt_i = smhmr.Calculate(subcat_sim_i['halo.m'][isSF], subcat_sim_i['m.star'][isSF], dmhalo=0.5, weights=subcat_sim_i['weights'][isSF], m_bin=mhalo_bin) #sub.plot(m_mid_i, sig_mhalo_i, c='k', lw=1, alpha=0.1) if i == 0: sig_mhalos = np.zeros((1000, len(cnt_i))) counts = np.zeros((1000, len(cnt_i))) sig_mhalos[i,:] = sig_mhalo_i counts[i,:] = cnt_i sig_mhalo_low = np.zeros(len(m_mid)) sig_mhalo_high = np.zeros(len(m_mid)) for im in range(len(m_mid)): if np.mean(counts[:,im]) > 50.: above_zero = np.where(counts[:,im] > 0) sig_mhalo_low[im], sig_mhalo_high[im] = np.percentile((sig_mhalos[:,im])[above_zero], [16, 84])#, axis=0) above_zero = np.where(sig_mhalo_high > 0) sub.fill_between(m_mid[above_zero], sig_mhalo_low[above_zero], sig_mhalo_high[above_zero], color=colors[i_s], linewidth=0, alpha=0.3, label=labels[i_s]) sub.set_xlim([11.5, 13.25]) sub.set_xlabel('log $(\; M_\mathrm{halo}\; [M_\odot]\;)$', fontsize=25) sub.set_ylim([0., 0.6]) sub.set_ylabel('$\sigma_{\mathrm{log}\,M_*}$', fontsize=27) sub.legend(loc='lower left', prop={'size': 20}) sub.text(0.95, 0.9, r'model($\theta_\mathrm{median}$)', ha='right', va='center', transform=sub.transAxes, fontsize=20) fig.subplots_adjust(wspace=0.3) fig.savefig(''.join([UT.tex_dir(), 'figs/qaplot_abc.pdf']), bbox_inches='tight', dpi=150) plt.close() return None
def compareSimpleGaia(ngauss=128, quantile=0.05, iter='10th', survey='2MASS', dataFilename='All.npz', contourColor='k'): setup_text_plots(fontsize=16, usetex=True) tgas, twoMass, Apass, bandDictionary, indices = testXD.dataArrays() xdgmm = XDGMM(filename=xdgmmFilename) absmag = 'J' mag1 = 'J' mag2 = 'K' xlabel = '$(J-K)^C$' ylabel = r'$M_J^C$' xlim = [-0.25, 1.25] ylim = [6, -6] ndim = 2 data = np.load(dustFile) dustEBV = data['ebv'] absMagKinda, apparentMagnitude = testXD.absMagKindaArray(absmag, dustEBV, bandDictionary, tgas['parallax']) color = testXD.colorArray(mag1, mag2, dustEBV, bandDictionary) color_err = np.sqrt(bandDictionary[mag1]['array'][bandDictionary[mag1]['err_key']]**2. + bandDictionary[mag2]['array'][bandDictionary[mag2]['err_key']]**2.) postFile = 'posteriorParallax.' + str(ngauss) + 'gauss.dQ' + str(quantile) + '.' + iter + '.' + survey + '.' + dataFilename yim = (-1, 5) for file in ['posteriorSimple.npz', postFile]: data = np.load(file) posterior = data['posterior'] samples = np.zeros(np.shape(posterior)[0]) xparallaxMAS = np.logspace(-2, 2, np.shape(posterior)[1]) for i, p in enumerate(posterior): try: samples[i] = testXD.samples(xparallaxMAS, p, 1, plot=False)[0] except IndexError: samples[i] = -999 mean = data['mean'] var = data['var'] absMag = testXD.absMagKinda2absMag(mean*10.**(0.2*apparentMagnitude)) absMagSample = testXD.absMagKinda2absMag(samples*10.**(0.2*apparentMagnitude)) neg = tgas['parallax'] < 0 fig, ax = plt.subplots(1, 2) ax[0].plot(data['mean'][~neg], mean[~neg] - tgas['parallax'][~neg], 'ko', markersize=0.5) ax[0].plot(data['mean'][neg], mean[neg] - tgas['parallax'][neg], 'ro', markersize=0.5) ax[0].set_xscale('log') ax[1].plot(data['mean'][~neg], np.log(var[~neg]) - np.log(tgas['parallax_error'][~neg]**2.), 'ko', markersize=0.5) ax[1].plot(data['mean'][neg], np.log(var[neg]) - np.log(tgas['parallax_error'][neg]**2.), 'ro', markersize=0.5) ax[1].set_xscale('log') ax[0].set_xlabel(r'$E[\varpi]$', fontsize=18) ax[1].set_xlabel(r'$E[\varpi]$', fontsize=18) ax[0].set_ylabel(r'$E[\varpi] - \varpi$', fontsize=18) ax[1].set_ylabel(r'$\mathrm{ln} \, \tilde{\sigma}_{\varpi}^2 - \mathrm{ln} \, \sigma_{\varpi}^2$', fontsize=18) plt.tight_layout() #if file == 'posteriorSimple.npz': ax[0].set_ylim(-5, 5) ax[1].set_ylim(-6, 2) ax[0].set_xlim(1e-1, 1e1) ax[1].set_xlim(1e-1, 1e2) fig.savefig(file.split('.')[0] + '_Comparison2Gaia.png') notnans = ~np.isnan(var) & ~np.isnan(tgas['parallax_error']) print 'The median of the differences of the logs: ', np.median(np.log(var[notnans]) - np.log(tgas['parallax_error'][notnans]**2.)) cNorm = plt.matplotlib.colors.Normalize(vmin=-6, vmax=6) fig, ax = plt.subplots(1, 2, figsize=(14, 7)) x = color[notnans] y = np.log(var[notnans]) - np.log(tgas['parallax_error'][notnans]**2.) levels = 1.0 - np.exp(-0.5 * np.arange(1.0, 2.1, 1.0) ** 2) #(counts, xedges, yedges, Image) = ax[0].hist2d(x, y, bins=100, cmap='Greys', norm=cNorm) #figcount, axcounts = plt.subplots() #nonzero = counts > 0 #axcounts.hist(np.log10(counts[nonzero]), log=True) #axcounts.set_xlabel('log counts') #figcount.savefig('counts.png') norm = plt.matplotlib.colors.Normalize(vmin=-1.5, vmax=1) cmap = 'inferno' ax[0].scatter(x, y, c=y, s=1, lw=0, alpha=0.05, norm=norm, cmap=cmap) corner.hist2d(x, y, bins=200, ax=ax[0], levels=levels, no_fill_contours=True, plot_density=False, plot_data=False, color=contourColor) #ax[0].scatter(color[notnans], np.log(var[notnans]) - np.log(tgas['parallax_error'][notnans]**2.), lw=0, s=1, alpha=0.5, c=tesXD.absMagKinda2absMag(absMagKinda[notnans]), norm=cNorm, cmap='plasma') ax[0].set_xlabel(r'$(J-K)^c$', fontsize=18) ax[0].set_ylim(-6, 2) ax[0].set_xlim(-0.5, 2) ax[0].set_ylabel(r'$\mathrm{ln} \, \tilde{\sigma}_{\varpi}^2 - \mathrm{ln} \, \sigma_{\varpi}^2$', fontsize=18) #ax[0].errorbar(color, np.log(var[notnans]) - np.log(tgas['parallax_error'][notnans]**2.), fmt="none", zorder=0, lw=0.5, mew=0, color='grey') cNorm = plt.matplotlib.colors.Normalize(vmin=0.1, vmax=2) ax[1].scatter(x, absMag[notnans], s=1, lw=0, c=y, alpha=0.05, norm=norm, cmap=cmap) ax[1].set_xlim(xlim) ax[1].set_ylim(ylim) ax[1].set_xlabel(xlabel, fontsize=18) ax[1].set_ylabel(ylabel, fontsize=18) #ax[1].hist(np.log(var[notnans]) - np.log(tgas['parallax_error'][notnans]**2.), bins=100, histtype='step', lw=2, log=True, color='black') #ax[1].set_xlabel(r'$\mathrm{ln} \, \tilde{\sigma}_{\varpi}^2 - \mathrm{ln} \, \sigma_{\varpi}^2$', fontsize=18) #ax[1].set_xlim(-6, 2) #ax[1].set_ylim(1,) fig.savefig('deltaLogVariance_' + file.split('.')[0] + '.png') figVarDiff = plt.figure(figsize=(14,7)) ax1 = figVarDiff.add_subplot(121) ax2 = figVarDiff.add_subplot(122) ax1.scatter(x, absMag[notnans], s=1, lw=0, c=y, alpha=0.05, norm=norm, cmap=cmap) ax2.scatter(x, absMag[notnans], s=1, lw=0, c=tgas['parallax_error'][notnans]**2., alpha=0.05, cmap=cmap) titles = ["Colored by change in variance", "Colored by observed variance"] ax = [ax1, ax2] for i in range(2): ax[i].set_xlim(xlim) ax[i].set_ylim(ylim[0], ylim[1]*1.1) ax[i].text(0.05, 0.95, titles[i], ha='left', va='top', transform=ax[i].transAxes, fontsize=18) ax[i].set_xlabel(xlabel, fontsize = 18) #if i in (1, 3): #ax[i].yaxis.set_major_formatter(plt.NullFormatter()) #else: ax[i].set_ylabel(ylabel, fontsize = 18) figVarDiff.savefig('denoisedVariance_' + file.split('.')[0] + '.png') figVarDiff.clf() ax1 = figVarDiff.add_subplot(121) ax2 = figVarDiff.add_subplot(122) ax1.scatter(x, absMag[notnans], s=1, lw=0, c=y, alpha=0.05, norm=norm, cmap=cmap) ax2.scatter(x, absMagSample[notnans], s=1, lw=0, c=tgas['parallax_error'][notnans]**2., alpha=0.05, cmap=cmap) titles = ["Colored by change in variance", "Colored by observed variance"] ax = [ax1, ax2] for i in range(2): ax[i].set_xlim(xlim) ax[i].set_ylim(ylim[0], ylim[1]*1.1) ax[i].text(0.05, 0.95, titles[i], ha='left', va='top', transform=ax[i].transAxes, fontsize=18) ax[i].set_xlabel(xlabel, fontsize = 18) #if i in (1, 3): #ax[i].yaxis.set_major_formatter(plt.NullFormatter()) #else: ax[i].set_ylabel(ylabel, fontsize = 18) figVarDiff.savefig('denoisedVarianceSamples_' + file.split('.')[0] + '.png')
plt.xlabel('log(R151)') plt.legend(loc='lower right') plt.savefig('DR14vsTSB_R151vsR51.pdf', dpi=700) #plt.show() return # Make 2D histograms and overlay scatter plot training set binaries on the histogram plt.figure(figsize=(8, 8)) #Overplot the training set binaries by scatter plot plt.scatter(dr14XR, dr14R2, s=6, marker='^', label='DR14 Stars') #Corner is the package that generates the 2D histogram corner.hist2d(kcXR, kcR2, bins=150, plot_contours=True, fill_contours=True, smooth=1.2, plot_datapoints=True) plt.xlabel('max log(x-range)', fontsize=15) plt.ylabel('min log($R_{101}/R_{51}$)', fontsize=15) plt.legend(loc='lower right') plt.ylim(-1, 0.2) plt.xlim(-1, 0.2) plt.savefig('dr14vsTSB(XR_vs_R2).pdf', dpi=800, bbox='tight') plt.show() '''#Generate histograms to find the number of most densely populated region # XR vs R101 plt.figure(figsize=(8,8)) plt.hist2d(dr14XR,dr14R101,bins=(50,50), norm=colors.LogNorm(),cmap=plt.cm.BuPu) plt.colorbar()
def plot_mcmc_chain(directory, set_scale=False, use_scale=False, only_first_star=True): ''' This routine takes the output from 'restructure_chain' function and plots the result in a corner plot set_scale and use_scale can be used to put different PDFs on the same scale, in the sense that the plot is shown with the same axis range. In the paper this is used to plot the Posterior in comparison to the prior distribution. ''' import corner plt.clf() text_size = 16 cor_text = 22 positions = np.load('%sposteriorPDF.npy' % (directory)) parameter_names = np.load("%sparameter_names.npy" % (directory)) if only_first_star: positions = positions[:, :6] parameter_names = parameter_names[:6] nparameter = len(positions[0]) cor_matrix = np.zeros(shape=(nparameter, nparameter)) for i in range(nparameter): for j in range(nparameter): cor_matrix[i, j] = np.corrcoef( (positions[:, i], positions[:, j]))[1, 0] np.save('%scor_matrix' % (directory), cor_matrix) fig, axes = plt.subplots(nrows=nparameter, ncols=nparameter, figsize=(14.69, 8.0), dpi=300) #,sharex=True, sharey=True) left = 0.1 # the left side of the subplots of the figure right = 0.925 # the right side of the subplots of the figure bottom = 0.075 # the bottom of the subplots of the figure top = 0.97 # the top of the subplots of the figure wspace = 0.0 # the amount of width reserved for blank space between subplots hspace = 0.0 # the amount of height reserved for white space between subplots plt.subplots_adjust(left=left, bottom=bottom, right=right, top=top, wspace=wspace, hspace=hspace) alpha = 0.5 alpha_more = 0.8 alpha_less = 0.1 lw = 2 if set_scale: borders = [] if use_scale: borders = np.load(directory + 'prior_borders.npy', encoding='bytes', allow_pickle=True) t = 0 for i in range(nparameter): for j in range(nparameter): axes[i, j].locator_params(nbins=4) if j == 1: axes[i, j].locator_params(nbins=4) if i == j: counts, edges = np.histogram(positions[:, j], bins=10) max_count = float(np.max(counts)) counts = np.divide(counts, max_count) axes[i, j].bar(edges[:-1], align='edge', height=counts, width=edges[1] - edges[0], color='grey', alpha=alpha, linewidth=0, edgecolor='blue') if use_scale: axes[i, j].set_xlim(borders[t][0]) axes[i, j].plot(borders[t][2], borders[t][3], c="k", linestyle='--', alpha=1, lw=lw) t += 1 else: axes[i, j].set_xlim(min(positions[:, j]), max(positions[:, j])) axes[i, j].set_ylim(0, 1.05) if j != 0: plt.setp(axes[i, j].get_yticklabels(), visible=False) if set_scale: borders.append([ axes[i, j].get_xlim(), axes[i, j].get_ylim(), edges[:-1], counts ]) axes[i, j].vlines(np.percentile(positions[:, j], 15.865), axes[i, j].get_ylim()[0], axes[i, j].get_ylim()[1], color='k', alpha=alpha, linewidth=lw, linestyle='dashed') axes[i, j].vlines(np.percentile(positions[:, j], 100 - 15.865), axes[i, j].get_ylim()[0], axes[i, j].get_ylim()[1], color='k', alpha=alpha, linewidth=lw, linestyle='dashed') axes[i, j].vlines(np.percentile(positions[:, j], 50), axes[i, j].get_ylim()[0], axes[i, j].get_ylim()[1], color='k', alpha=alpha, linewidth=lw) axes[i, j].text(0.5, 1.03, r'$%.2f_{-%.2f}^{+%.2f}$' % (np.percentile(positions[:, j], 50), np.percentile(positions[:, j], 50) - np.percentile(positions[:, j], 15.865), np.percentile(positions[:, j], 100 - 15.865) - np.percentile(positions[:, j], 50)), fontsize=text_size, ha="center", transform=axes[i, j].transAxes) if i > j: if j != 0: plt.setp(axes[i, j].get_yticklabels(), visible=False) corner.hist2d(positions[:, j], positions[:, i], ax=axes[i, j], bins=15, levels=(1 - np.exp(-0.5), 1 - np.exp(-2.0), 1 - np.exp(-4.5))) #axes[i,j].plot(positions_max[:,j],positions_max[:,i],'kx',markersize = 10,mew=2.5) #im = axes[i,j].scatter(positions[:,j],positions[:,i],c='k',edgecolor='None',s=45,marker='o',alpha=alpha_less,rasterized=True)#,vmin=0,vmax=vmax) #axes[i,j].hist2d(positions[:,j],positions[:,i],cmap = my_cmap, vmin=1) if use_scale: axes[i, j].set_xlim(borders[t][0]) axes[i, j].set_ylim(borders[t][1]) #axes[i,j].plot( borders[t][2], borders[t][3], "k",linestyle = '--', alpha=1, lw = lw ) t += 1 else: axes[i, j].set_xlim(min(positions[:, j]), max(positions[:, j])) axes[i, j].set_ylim(min(positions[:, i]), max(positions[:, i])) if set_scale: borders.append( [axes[i, j].get_xlim(), axes[i, j].get_ylim(), i, j]) if j > i: correlation_coefficient = np.corrcoef( (positions[:, i], positions[:, j])) axes[i, j].text(0.6, 0.5, "%.2f" % (correlation_coefficient[1, 0]), fontsize=cor_text, ha="center", transform=axes[i, j].transAxes) axes[i, j].axis('off') if i == nparameter - 1: axes[i, j].set_xlabel(parameter_names[j]) if j == 0: axes[i, j].set_ylabel(parameter_names[i]) #if nparameter>3: # axes[0,3].set_title('vmax = %.2f, obtained at %s' %(vmax,str(positions_max))) # #axes[0,1].set_title('vmax = %.2f, obtained at %s and %d evals thrown out' %(vmax,str(positions_max),throw_out)) fig.savefig('%sparameter_space_sorted.png' % (directory), dpi=300, bbox_inches='tight') if set_scale: np.save('%sprior_borders' % (directory), borders)
def ABCvsMCMC_contour(obvs, nwalkers=100, nburns=9000, sigma=False): ''' Plots that compare the ABC posteriors to the MCMC posteriors ''' if obvs == 'nbargmf': abc_dir = ''.join([ ut.dat_dir(), 'paper/ABC', obvs, '/run1/', ]) abc_theta_file = lambda tt: ''.join( [abc_dir, 'nbar_gmf_theta_t', str(tt), '.ABCnbargmf.dat']) tf = 8 mcmc_dir = ''.join([ut.dat_dir(), 'paper/']) mcmc_filename = ''.join([mcmc_dir, 'nbar_gmf.mcmc.mcmc_chain.p']) elif obvs == 'nbarxi': abc_dir = ''.join([ ut.dat_dir(), 'paper/ABC', obvs, '/', ]) abc_theta_file = lambda tt: ''.join( [abc_dir, 'nbar_xi_theta_t', str(tt), '.abc.dat']) tf = 9 mcmc_dir = ''.join([ut.dat_dir(), 'paper/']) mcmc_filename = ''.join([mcmc_dir, 'nbar_xi.mcmc.mcmc_chain.p']) else: raise ValueError prior_min, prior_max = PriorRange('first_try') prior_range = np.zeros((len(prior_min), 2)) prior_range[:, 0] = prior_min prior_range[:, 1] = prior_max # true HOD parameter true_dict = Data.data_hod_param(Mr=21) truths = [ true_dict['logM0'], # log M0 np.log(true_dict['sigma_logM']), # log(sigma) true_dict['logMmin'], # log Mmin true_dict['alpha'], # alpha true_dict['logM1'] # log M1 ] mcmc_sample = pickle.load(open(mcmc_filename, 'rb'))[nburns * nwalkers:, :] abc_sample = np.loadtxt(abc_theta_file(tf)) par_labels = [ r'$\mathtt{log}\;\mathcal{M}_{0}$', r'$\mathtt{log}\;\sigma_\mathtt{log\;M}$', r'$\mathtt{log}\;\mathcal{M}_\mathtt{min}$', r'$\alpha$', r'$\mathtt{log}\;\mathcal{M}_{1}$' ] prettyplot() pretty_colors = prettycolors() fig = plt.figure(1, figsize=(20, 6)) gs = gridspec.GridSpec(1, 3) # first panel for i in [0, 1, 2]: plot_range = np.zeros((2, 2)) if i == 0: col_pair = [2, 3] plot_range[0, 0] = 12.5 plot_range[0, 1] = 13.0 plot_range[1, 0] = prior_range[3, 0] plot_range[1, 1] = prior_range[3, 1] elif i == 2: col_pair = [4, 2] plot_range[0, 0] = 13.6 plot_range[0, 1] = 14.2 plot_range[1, 0] = 12.5 plot_range[1, 1] = 13.0 elif i == 1: col_pair = [3, 4] plot_range[0, 0] = prior_range[3, 0] plot_range[0, 1] = prior_range[3, 1] plot_range[1, 0] = 13.6 plot_range[1, 1] = 14.2 if i == 2: mcmc_label = r'$\mathcal{L}^\mathtt{Gauss}$ MCMC' abc_label = 'ABC-PMC' else: mcmc_label = None abc_label = None mcmc_par1 = mcmc_sample[:, col_pair[0]] mcmc_par2 = mcmc_sample[:, col_pair[1]] abc_par1 = abc_sample[:, col_pair[0]] abc_par2 = abc_sample[:, col_pair[1]] ax = plt.subplot(gs[i]) if sigma: lvls = [1 - np.exp(-0.5), 1 - np.exp(-0.125)] else: lvls = [0.68, 0.95] corner.hist2d(mcmc_par1, mcmc_par2, bins=20, range=plot_range, ax=ax, plot_datapoints=False, levels=lvls, color='#1F77B4', fill_contours=True, smooth=1.0, label=mcmc_label) corner.hist2d(abc_par1, abc_par2, bins=20, range=plot_range, ax=ax, levels=lvls, color='#FF7F0E', fill_contours=True, smooth=1.0, label=abc_label) ax.scatter(np.repeat(truths[col_pair[0]], 2), np.repeat(truths[col_pair[1]], 2), s=100, marker='*', c='k', lw=0, label=None) #ax.axvline(truths[i_col], color='k', ls='--', linewidth=3) #ax.set_xticklabels([]) ax.set_xlim([plot_range[0, 0], plot_range[0, 1]]) ax.set_ylim([plot_range[1, 0], plot_range[1, 1]]) if i == 2: thick_line1 = mlines.Line2D([], [], ls='-', c='#FF7F0E', linewidth=12, alpha=0.5, label='ABC-PMC') ax.legend(loc='upper right', handles=[thick_line1], frameon=False, fontsize=25, handletextpad=0.1, scatteryoffsets=[0.5]) elif i == 1: thick_line2 = mlines.Line2D( [], [], ls='-', c='#1F77B4', linewidth=12, alpha=0.5, label='$\mathcal{L}^\mathtt{Gauss}$ \nMCMC') ax.legend(loc='upper right', handles=[thick_line2], frameon=False, fontsize=25, handletextpad=0.1, scatteryoffsets=[0.5]) ax.set_xlabel(par_labels[col_pair[0]], fontsize=25, labelpad=15) ax.set_ylabel(par_labels[col_pair[1]], fontsize=25) if sigma: sigma_str = '.true1sigma' else: sigma_str = '' fig.subplots_adjust(wspace=0.3) fig_name = ''.join([ ut.fig_dir(), 'paper.ABCvsMCMC.contour', '.', obvs, sigma_str, '.pdf' ]) fig.savefig(fig_name, bbox_inches='tight', dpi=150) return None
def plot_element_correlation(directory): ''' This is an experimental plotting routine. It can read the mcmc folder content and plot element / parameter / posterior correlations. For that the name-list of the blobs needs to be provided which can be generated running Chempy in the 'testing_output' mode. ''' import corner where_to_cut = 500 blobs = np.load('%sflatblobs.npy' % (directory)) positions = np.load('%sflatchain.npy' % (directory)) posterior = np.load('%sflatlnprobability.npy' % (directory)) positions = np.reshape(positions, (-1, len(positions[0, 0])))[-where_to_cut:] posterior = np.hstack(posterior)[-where_to_cut:] blobs = np.swapaxes(blobs, 0, 1) blobs = np.reshape(blobs, (-1, len(blobs[0, 0])))[-where_to_cut:] blobs = np.concatenate((blobs, positions, posterior[:, None]), axis=1) names = [ 'He', 'C', 'N', 'O', 'F', 'Ne', 'Na', 'Mg', 'Al', 'Si', 'P', 'S', 'Ar', 'K', 'Ca', 'Ti', 'V', 'Cr', 'Mn', 'Fe', 'Co', 'Ni', 'IMF', 'NIa' ] # Elements of ProtoSun run names = ['m-%s' % item for item in names] names = np.append(names, 'v-posterior') parameter_names = ['O', 'Mg', 'Si', 'Fe'] parameter_names = ['m-%s' % item for item in parameter_names] parameter_names = [names[-1]] + parameter_names parameter_names += [names[-3]] parameter_names += [names[-2]] nparameter = len(parameter_names) positions = np.zeros(shape=(len(posterior), nparameter)) #print(parameter_names) #print(names) #print(positions.shape) #print(blobs.shape) names = np.array(names) for i, item in enumerate(parameter_names): positions[:, i] = blobs[:, np.where(names == item)[0][0]] parameter_names = [item[2:] for item in parameter_names] fig, axes = plt.subplots(nrows=nparameter, ncols=nparameter, figsize=(14.69, 8.0), dpi=300) #,sharex=True, sharey=True) left = 0.1 # the left side of the subplots of the figure right = 0.925 # the right side of the subplots of the figure bottom = 0.075 # the bottom of the subplots of the figure top = 0.97 # the top of the subplots of the figure wspace = 0.0 # the amount of width reserved for blank space between subplots hspace = 0.0 # the amount of height reserved for white space between subplots plt.subplots_adjust(left=left, bottom=bottom, right=right, top=top, wspace=wspace, hspace=hspace) alpha = 0.5 alpha_more = 0.8 alpha_less = 0.2 lw = 2 t = 0 text_size = 14 cor_text = 18 for i in range(nparameter): for j in range(nparameter): axes[i, j].locator_params(nbins=4) if j == 1: axes[i, j].locator_params(nbins=4) if i == j: counts, edges = np.histogram(positions[:, j], bins=10) max_count = float(np.max(counts)) counts = np.divide(counts, max_count) axes[i, j].bar(edges[:-1], align='edge', height=counts, width=edges[1] - edges[0], color='grey', alpha=alpha, linewidth=0, edgecolor='blue') axes[i, j].set_xlim(min(positions[:, j]), max(positions[:, j])) axes[i, j].set_ylim(0, 1.05) if j != 0: plt.setp(axes[i, j].get_yticklabels(), visible=False) axes[i, j].vlines(np.percentile(positions[:, j], 15.865), axes[i, j].get_ylim()[0], axes[i, j].get_ylim()[1], color='k', alpha=alpha, linewidth=lw, linestyle='dashed') axes[i, j].vlines(np.percentile(positions[:, j], 100 - 15.865), axes[i, j].get_ylim()[0], axes[i, j].get_ylim()[1], color='k', alpha=alpha, linewidth=lw, linestyle='dashed') axes[i, j].vlines(np.percentile(positions[:, j], 50), axes[i, j].get_ylim()[0], axes[i, j].get_ylim()[1], color='k', alpha=alpha, linewidth=lw) axes[i, j].text(0.5, 1.03, r'$%.2f_{-%.2f}^{+%.2f}$' % (np.percentile(positions[:, j], 50), np.percentile(positions[:, j], 50) - np.percentile(positions[:, j], 15.865), np.percentile(positions[:, j], 100 - 15.865) - np.percentile(positions[:, j], 50)), fontsize=text_size, ha="center", transform=axes[i, j].transAxes) if i > j: if j != 0: plt.setp(axes[i, j].get_yticklabels(), visible=False) corner.hist2d(positions[:, j], positions[:, i], ax=axes[i, j], bins=15, levels=(1 - np.exp(-0.5), 1 - np.exp(-2.0), 1 - np.exp(-4.5))) axes[i, j].set_ylim(-0.2, 0.2) if parameter_names[j] == '[He/H]': axes[i, j].set_xlim(0.01, 0.06) #axes[i,j].plot(0.05,0.04,marker=r"$\odot$", mec = 'red') else: axes[i, j].set_xlim(-0.2, 0.2) #axes[i,j].plot(0.04,0.04,marker=r"$\odot$", mec = 'red') axes[i, j].set_xlim(min(positions[:, j]), max(positions[:, j])) axes[i, j].set_ylim(min(positions[:, i]), max(positions[:, i])) if j > i: correlation_coefficient = np.corrcoef( (positions[:, i], positions[:, j])) axes[i, j].text(0.6, 0.5, "%.2f" % (correlation_coefficient[1, 0]), fontsize=cor_text, ha="center", transform=axes[i, j].transAxes) axes[i, j].axis('off') if i == nparameter - 1: axes[i, j].set_xlabel(parameter_names[j]) if j == 0: axes[i, j].set_ylabel(parameter_names[i]) #axes[0,3].set_title('vmax = %.2f, obtained at %s and %d evals thrown out' %(vmax,str(positions_max),throw_out)) #axes[0,1].set_title('vmax = %.2f, obtained at %s and %d evals thrown out' %(vmax,str(positions_max),throw_out)) fig.savefig('%selement_correlations.png' % (directory), dpi=300, bbox_inches='tight')
def PoolEvolution(obvs): ''' Demostrative plot for the evolution of the pool. Illustrate the pool evolution for log M_min versus log M_1, which has the starkest evolution from its prior. ''' if obvs == 'nbargmf': result_dir = ''.join([ ut.dat_dir(), 'paper/ABC', obvs, '/run1/', ]) theta_file = lambda tt: ''.join( [result_dir, 'nbar_gmf_theta_t', str(tt), '.ABCnbargmf.dat']) t_list = [0, 1, 2, 3, 5, 8] elif obvs == 'nbarxi': result_dir = ''.join([ut.dat_dir(), 'paper/ABC', obvs, '/']) theta_file = lambda tt: ''.join( [result_dir, 'nbar_xi_theta_t', str(tt), '.abc.dat']) t_list = [0, 1, 2, 3, 7, 9] else: raise ValueError prior_min, prior_max = PriorRange('first_try') prior_range = np.zeros((2, 2)) prior_range[:, 0] = np.array([prior_min[2], prior_min[4]]) prior_range[:, 1] = np.array([prior_max[2], prior_max[4]]) # true HOD parameter true_dict = Data.data_hod_param(Mr=21) true_pair = [true_dict['logMmin'], true_dict['logM1']] prettyplot() pretty_colors = prettycolors() fig = plt.figure(figsize=(12, 8)) all_fig = fig.add_subplot(111) for i_t, t in enumerate(t_list): sub = fig.add_subplot(2, len(t_list) / 2, i_t + 1) theta_Mmin, theta_M1 = np.loadtxt(theta_file(t), unpack=True, usecols=[2, 4]) corner.hist2d(theta_Mmin, theta_M1, bins=20, range=prior_range, levels=[0.68, 0.95], color='c', fill_contours=True, smooth=1.0) t_label = r"$\mathtt{t = " + str(t) + "}$" sub.text(13.0, 15.0, t_label, fontsize=25) if i_t == len(t_list) - 1: true_label = r'$``\mathtt{true}"$' else: true_label = None plt.scatter(np.repeat(true_pair[0], 2), np.repeat(true_pair[1], 2), s=75, marker='*', c='k', lw=0, label=true_label) if i_t == len(t_list) - 1: plt.legend(loc='lower left', scatterpoints=1, markerscale=2.5, handletextpad=-0.25, scatteryoffsets=[0.5]) if i_t == 0: sub.set_xticklabels([]) sub.set_yticklabels([13., 13.5, 14., 14.5, 15., 15.5]) elif (i_t > 0) and (i_t < len(t_list) / 2): sub.set_xticklabels([]) sub.set_yticklabels([]) elif i_t == len(t_list) / 2: sub.set_yticklabels([13., 13.5, 14., 14.5, 15.]) elif i_t > len(t_list) / 2: sub.set_yticklabels([]) all_fig.set_xticklabels([]) all_fig.set_yticklabels([]) all_fig.set_ylabel(r'$\mathtt{log}\;\mathcal{M}_\mathtt{1}$', fontsize=30, labelpad=50) all_fig.set_xlabel(r'$\mathtt{log}\;\mathcal{M}_\mathtt{min}$', fontsize=30, labelpad=25) fig.subplots_adjust(hspace=0.0) fig_name = ''.join( [ut.fig_dir(), 'paper_ABC_poolevolution', '.', obvs, '.pdf']) fig.savefig(fig_name, bbox_inches='tight', dpi=150) plt.close()
from astropy.table import Table import astropy.units as u import matplotlib.pyplot as plt import numpy as np import corner from astropy.stats import median_absolute_deviation as mad t = Table.read('/mnt/ephem/ephem/erosolow/cohrs/cohrs_withlines.fits') fig = plt.figure(figsize=(4.5,3.5)) ax = fig.add_subplot(111) idx = np.isfinite(np.log10((t['13co10'])/t['12co32'])) t2 = t[idx] corner.hist2d(np.log10(t[idx]['flux']), np.log10((t[idx]['13co10'])/t[idx]['12co32']), ax=ax) # ax.scatter(t['flux'], t['13co10']/t['12co32'], edgecolor='k', # facecolor='gray', alpha=0.2) ax.set_ylim(-3,0) ax.set_xlabel(r'$\log_{10}[F_{\mathrm{CO(3-2)}}/(\mathrm{K\ km\ s^{-1}\ pc^{2}})]$') ax.set_ylabel(r'$\log_{10}[F_{\mathrm{{}^{13}CO(1-0)}}/F_{\mathrm{CO(3-2)}}]$') plt.tight_layout() #ax.set_xscale("log", nonposx='clip') #ax.set_yscale("log", nonposy='clip') idx2 = t2['flux']>1e3 print(np.median(t2[idx2]['13co10']/t2[idx2]['12co32'])) print(mad(np.log(t2[idx2]['13co10']/t2[idx2]['12co32']))) count = idx2.sum() print('Number of clouds: {0}'.format(count))
ra_J0045 = coor_J0045.ra.degree dec_J0045 = coor_J0045.dec.degree # Load pickled data sampler = pickle.load( open( INDATA("J0045_MCMC_sampler.obj"), "rb" ) ) #init_params_J0045 = pickle.load( open( INDATA("J0045_pop_synth_init_conds.obj"), "rb" ) ) #HMXB_J0045 = pickle.load( open( INDATA("J0045_pop_synth_HMXB.obj"), "rb" ) ) # Specific distribution plots plt.rc('font', size=18) # M1 vs M2 M1 = sampler.flatchain.T[0] M2 = sampler.flatchain.T[1] corner.hist2d(M1, M2) plt.xlabel(r'$M_1\ ({\rm M_{\odot}})$', fontsize=22) plt.ylabel(r'$M_2\ ({\rm M_{\odot}})$', fontsize=22) plt.savefig('../figures/J0045_M1_M2.pdf') #plt.show() # V_k vs theta v_k = sampler.flatchain.T[4] theta = sampler.flatchain.T[5] corner.hist2d(v_k, theta) plt.xlabel(r'$v_k\ ({\rm km/s})$', fontsize=22) plt.ylabel(r'$\theta$', fontsize=22) plt.savefig('../figures/J0045_vk_theta.pdf') #plt.show() # t_b histogram t_b = sampler.flatchain.T[9] plt.hist(t_b, histtype='step', color='k', bins=50)
def plot_sample(x, y, samplex, sampley, xdgmm, xlabel='x', ylabel='y', xerr=None, yerr=None, ylim=(6, -6), xlim=(0.5, 1.5), errSubsample=1.2e6, thresholdScatter=0.1, binsScatter=200, c='black', norm=None, cmap=None, contourColor='k', posterior=False, ind=None, plot_contours=True, sdss5=False, whatsThatFeature=False, rasterized=False): prng = np.random.RandomState(1234567890) setup_text_plots(fontsize=16, usetex=True) plt.clf() alpha = 0.1 alpha_points = 0.01 figData = plt.figure(figsize=(12, 5.5)) figPrior = plt.figure(figsize=(12, 5.5)) for fig in [figData, figPrior]: fig.subplots_adjust(left=0.1, right=0.95, bottom=0.15, top=0.95, wspace=0.1, hspace=0.1) ax1 = figData.add_subplot(121) levels = 1.0 - np.exp(-0.5 * np.arange(1.0, 2.1, 1.0)**2) cNorm = plt.matplotlib.colors.LogNorm(vmin=3, vmax=1e5) #ax1.hist2d(x, y, bins=100, norm=cNorm, cmap='Greys') if sdss5: plot_contours = False im = corner.hist2d(x, y, ax=ax1, levels=levels, bins=200, no_fill_contours=True, plot_density=False, color=contourColor, rasterized=rasterized, plot_contours=plot_contours) #im = ax1.scatter(x, y, s=1, lw=0, c=c, alpha=alpha, norm=norm, cmap=cmap) ax2 = figData.add_subplot(122) if ind is None: ind = prng.randint(0, len(x), size=errSubsample) #ax2.scatter(x[ind], y[ind], s=1, lw=0, c='black', alpha=alpha_points) ax2.errorbar(x[ind], y[ind], xerr=xerr[ind], yerr=[yerr[0][ind], yerr[1][ind]], fmt="none", zorder=0, mew=0, ecolor='black', alpha=0.5, elinewidth=0.5) ax3 = figPrior.add_subplot(121) #ax3.hist2d(x, y, bins=100, norm=cNorm, cmap='Greys') #kdeDensity(ax3, samplex, sampley, threshold=thresholdScatter, bins=binsScatter, s=1, lw=0, alpha=alpha) corner.hist2d(samplex, sampley, ax=ax3, levels=levels, bins=200, no_fill_contours=True, plot_density=False, color=contourColor, rasterized=rasterized, plot_contours=False) ax3.scatter(samplex, sampley, s=1, lw=0, c='k', alpha=alpha) ax4 = figPrior.add_subplot(122) for i in range(xdgmm.n_components): points = drawEllipse.plotvector(xdgmm.mu[i], xdgmm.V[i]) ax4.plot(points[0, :], absMagKinda2absMag(points[1, :]), 'k-', alpha=xdgmm.weights[i] / np.max(xdgmm.weights)) #draw_ellipse(xdgmm.mu[i], xdgmm.V[i], scales=[2], ax=ax4, # ec='None', fc='gray', alpha=xdgmm.weights[i]/np.max(xdgmm.weights)*0.1) #xlim = ax4.get_xlim() #ylim = ylim #ax3.get_ylim() titles = [ "Observed Distribution", "Obs+Noise Distribution", "Extreme Deconvolution\n resampling", "Extreme Deconvolution\n cluster locations" ] if posterior: titles = [ "De-noised Expectation Values", "Posterior Distributions", "Extreme Deconvolution\n resampling", "Extreme Deconvolution\n cluster locations" ] if sdss5: titles = ['', '', '', ''] ax = [ax1, ax2, ax3, ax4] for i in range(4): ax[i].set_xlim(xlim) ax[i].set_ylim(ylim[0], ylim[1] * 1.1) #ax[i].xaxis.set_major_locator(plt.MultipleLocator([-1, 0, 1])) #ax[i].yaxis.set_major_locator(plt.MultipleLocator([3, 4, 5, 6])) ax[i].text(0.05, 0.95, titles[i], ha='left', va='top', transform=ax[i].transAxes, fontsize=18) #if i in (0, 1): # ax[i].xaxis.set_major_formatter(plt.NullFormatter()) #else: ax[i].set_xlabel(xlabel, fontsize=18) if i in (1, 3): ax[i].yaxis.set_major_formatter(plt.NullFormatter()) else: ax[i].set_ylabel(ylabel, fontsize=18) #ax[3].text(0.05, 0.95, titles[3], # ha='left', va='top', transform=ax[3].transAxes) #ax[3].set_ylabel(r'$\varpi10^{0.2*m_G}$', fontsize=18) #ax[3].set_xlim(-2, 3) #ax[3].set_ylim(3, -1) #ax[3].yaxis.tick_right() #ax[3].yaxis.set_label_position("right") #plt.tight_layout() """ if norm is not None: figData.subplots_adjust(left=0.2, right=0.95) cbar_ax = figData.add_axes([0.01, 0.125, 0.02, 0.75]) cb = figData.colorbar(im, cax=cbar_ax) #cb = plt.colorbar(im, ax=axes[2]) cb.set_label(r'$ln \, \tilde{\sigma}_{\varpi}^2 - ln \, \sigma_{\varpi}^2$', fontsize=20) cb.set_clim(-7, 2) """ figData.savefig('plot_sample.data.pdf', format='pdf') figPrior.savefig('plot_sample.prior.pdf', format='pdf')
# if we want to plot gamma-Rc and p-Rout in two panels # from matplotlib import gridspec # fig = plt.figure(figsize=(10, 5)) # gs = gridspec.GridSpec(1, 2, width_ratios=[1, 1]) # ax = plt.subplot(gs[0]), plt.subplot(gs[1]) fig, ax = plt.subplots(1, 1, figsize=(5, 5)) levels = 1. - np.exp(-0.5 * np.arange( 1., 3.1, 1)**2.) # correspond to 1, 2 and 3 sigma for a 2D hystogram hist2d(flatchain[:, 0], flatchain[:, 2], ax=ax, bins=30, levels=levels, plot_datapoints=False, smooth=1.5, plot_contours=True, fill_contours=True, plot_density=False, color='#2D89E5') # add point for best-fit model ax.plot(bestfit_pars[0], bestfit_pars[2], marker='*', markerfacecolor='#FFFF66', markeredgecolor='#FFFF66', markersize=16) if headers['fit']['sigma_prescription'] == 'g':
def ABCvsMCMC_contour(obvs, nwalkers=100, nburns=9000, sigma=False): ''' Plots that compare the ABC posteriors to the MCMC posteriors ''' if obvs == 'nbargmf': abc_dir = ''.join([ut.dat_dir(), 'paper/ABC', obvs, '/run1/',]) abc_theta_file = lambda tt: ''.join([abc_dir, 'nbar_gmf_theta_t', str(tt), '.ABCnbargmf.dat']) tf = 8 mcmc_dir = ''.join([ut.dat_dir(), 'paper/']) mcmc_filename = ''.join([mcmc_dir, 'nbar_gmf.mcmc.mcmc_chain.p']) elif obvs == 'nbarxi': abc_dir = ''.join([ut.dat_dir(), 'paper/ABC', obvs, '/',]) abc_theta_file = lambda tt: ''.join([abc_dir, 'nbar_xi_theta_t', str(tt), '.abc.dat']) tf = 9 mcmc_dir = ''.join([ut.dat_dir(), 'paper/']) mcmc_filename = ''.join([mcmc_dir, 'nbar_xi.mcmc.mcmc_chain.p']) else: raise ValueError prior_min, prior_max = PriorRange('first_try') prior_range = np.zeros((len(prior_min),2)) prior_range[:,0] = prior_min prior_range[:,1] = prior_max # true HOD parameter true_dict = Data.data_hod_param(Mr=21) truths = [ true_dict['logM0'], # log M0 np.log(true_dict['sigma_logM']), # log(sigma) true_dict['logMmin'], # log Mmin true_dict['alpha'], # alpha true_dict['logM1'] # log M1 ] mcmc_sample = pickle.load(open(mcmc_filename, 'rb'))[nburns*nwalkers:,:] abc_sample = np.loadtxt(abc_theta_file(tf)) par_labels = [ r'$\mathtt{log}\;\mathcal{M}_{0}$', r'$\mathtt{log}\;\sigma_\mathtt{log\;M}$', r'$\mathtt{log}\;\mathcal{M}_\mathtt{min}$', r'$\alpha$', r'$\mathtt{log}\;\mathcal{M}_{1}$' ] prettyplot() pretty_colors = prettycolors() fig = plt.figure(1, figsize=(20,6)) gs = gridspec.GridSpec(1, 3) # first panel for i in [0, 1, 2]: plot_range = np.zeros((2,2)) if i == 0: col_pair = [2, 3] plot_range[0, 0] = 12.5 plot_range[0, 1] = 13.0 plot_range[1, 0] = prior_range[3, 0] plot_range[1, 1] = prior_range[3, 1] elif i == 2: col_pair = [4, 2] plot_range[0, 0] = 13.6 plot_range[0, 1] = 14.2 plot_range[1, 0] = 12.5 plot_range[1, 1] = 13.0 elif i == 1: col_pair = [3, 4] plot_range[0, 0] = prior_range[3, 0] plot_range[0, 1] = prior_range[3, 1] plot_range[1, 0] = 13.6 plot_range[1, 1] = 14.2 if i == 2: mcmc_label = r'$\mathcal{L}^\mathtt{Gauss}$ MCMC' abc_label = 'ABC-PMC' else: mcmc_label = None abc_label = None mcmc_par1 = mcmc_sample[:,col_pair[0]] mcmc_par2 = mcmc_sample[:,col_pair[1]] abc_par1 = abc_sample[:, col_pair[0]] abc_par2 = abc_sample[:, col_pair[1]] ax = plt.subplot(gs[i]) if sigma: lvls = [1-np.exp(-0.5), 1-np.exp(-0.125)] else: lvls = [0.68, 0.95] corner.hist2d(mcmc_par1, mcmc_par2, bins=20, range=plot_range, ax = ax, plot_datapoints=False, levels=lvls, color='#1F77B4', fill_contours=True, smooth=1.0, label=mcmc_label) corner.hist2d(abc_par1, abc_par2, bins=20, range=plot_range, ax = ax, levels=lvls, color='#FF7F0E', fill_contours=True, smooth=1.0, label=abc_label) ax.scatter(np.repeat(truths[col_pair[0]],2), np.repeat(truths[col_pair[1]],2), s=100, marker='*', c='k', lw=0, label=None) #ax.axvline(truths[i_col], color='k', ls='--', linewidth=3) #ax.set_xticklabels([]) ax.set_xlim([plot_range[0, 0] , plot_range[0, 1]]) ax.set_ylim([plot_range[1, 0] , plot_range[1, 1]]) if i == 2: thick_line1 = mlines.Line2D([], [], ls='-', c='#FF7F0E', linewidth=12, alpha=0.5, label='ABC-PMC') ax.legend(loc='upper right', handles=[thick_line1], frameon=False, fontsize=25, handletextpad=0.1, scatteryoffsets=[0.5]) elif i == 1: thick_line2 = mlines.Line2D([], [], ls='-', c='#1F77B4', linewidth=12, alpha=0.5, label='$\mathcal{L}^\mathtt{Gauss}$ \nMCMC') ax.legend(loc='upper right', handles=[thick_line2], frameon=False, fontsize=25, handletextpad=0.1, scatteryoffsets=[0.5]) ax.set_xlabel(par_labels[col_pair[0]], fontsize=25, labelpad=15) ax.set_ylabel(par_labels[col_pair[1]], fontsize=25) if sigma: sigma_str = '.true1sigma' else: sigma_str = '' fig.subplots_adjust(wspace=0.3) fig_name = ''.join([ut.fig_dir(), 'paper.ABCvsMCMC.contour', '.', obvs, sigma_str, '.pdf']) fig.savefig(fig_name, bbox_inches='tight', dpi=150) return None
def PoolEvolution(obvs): ''' Demostrative plot for the evolution of the pool. Illustrate the pool evolution for log M_min versus log M_1, which has the starkest evolution from its prior. ''' if obvs == 'nbargmf': result_dir = ''.join([ut.dat_dir(), 'paper/ABC', obvs, '/run1/',]) theta_file = lambda tt: ''.join([result_dir, 'nbar_gmf_theta_t', str(tt), '.ABCnbargmf.dat']) t_list = [0, 1, 2, 3, 5, 8] elif obvs == 'nbarxi': result_dir = ''.join([ut.dat_dir(), 'paper/ABC', obvs, '/']) theta_file = lambda tt: ''.join([result_dir, 'nbar_xi_theta_t', str(tt), '.abc.dat']) t_list = [0, 1, 2, 3, 7, 9] else: raise ValueError prior_min, prior_max = PriorRange('first_try') prior_range = np.zeros((2,2)) prior_range[:,0] = np.array([prior_min[2], prior_min[4]]) prior_range[:,1] = np.array([prior_max[2], prior_max[4]]) # true HOD parameter true_dict = Data.data_hod_param(Mr=21) true_pair = [true_dict['logMmin'], true_dict['logM1']] prettyplot() pretty_colors = prettycolors() fig = plt.figure(figsize=(12,8)) all_fig = fig.add_subplot(111) for i_t, t in enumerate(t_list): sub = fig.add_subplot(2, len(t_list)/2, i_t+1) theta_Mmin, theta_M1 = np.loadtxt(theta_file(t), unpack=True, usecols=[2, 4]) corner.hist2d(theta_Mmin, theta_M1, bins=20, range=prior_range, levels=[0.68, 0.95], color='c', fill_contours=True, smooth=1.0) t_label = r"$\mathtt{t = "+str(t)+"}$" sub.text(13.0, 15.0, t_label, fontsize=25) if i_t == len(t_list) - 1: true_label = r'$``\mathtt{true}"$' else: true_label = None plt.scatter(np.repeat(true_pair[0],2), np.repeat(true_pair[1],2), s=75, marker='*', c='k', lw=0, label=true_label) if i_t == len(t_list) - 1: plt.legend(loc='lower left', scatterpoints=1, markerscale=2.5, handletextpad=-0.25, scatteryoffsets=[0.5]) if i_t == 0: sub.set_xticklabels([]) sub.set_yticklabels([13., 13.5, 14., 14.5, 15., 15.5]) elif (i_t > 0) and (i_t < len(t_list)/2): sub.set_xticklabels([]) sub.set_yticklabels([]) elif i_t == len(t_list)/2: sub.set_yticklabels([13., 13.5, 14., 14.5, 15.]) elif i_t > len(t_list)/2: sub.set_yticklabels([]) all_fig.set_xticklabels([]) all_fig.set_yticklabels([]) all_fig.set_ylabel( r'$\mathtt{log}\;\mathcal{M}_\mathtt{1}$', fontsize=30, labelpad=50) all_fig.set_xlabel( r'$\mathtt{log}\;\mathcal{M}_\mathtt{min}$', fontsize=30, labelpad=25) fig.subplots_adjust(hspace=0.0) fig_name = ''.join([ut.fig_dir(), 'paper_ABC_poolevolution', '.', obvs, '.pdf']) fig.savefig(fig_name, bbox_inches='tight', dpi=150) plt.close()
f = pyfits.open("%s/table_for_paper.fits" % direc) a = f[1].data f.close() feh = a['cannon_m_h'] am = a['cannon_alpha_m'] snr = a['snrg'] choose = snr > 20 print(sum(choose)) print(len(choose)) fig, ax = plt.subplots(1, 1, sharex=True, sharey=True, figsize=(8, 5)) hist2d(feh[choose], am[choose], ax=ax, bins=100, range=[[-2.2, .9], [-0.2, 0.5]]) ax.set_xlabel("[Fe/H] (dex)" + " from Cannon/LAMOST", fontsize=16) fig.text(0.04, 0.5, r"$\mathrm{[\alpha/M]}$" + " (dex) from Cannon/LAMOST", fontsize=16, va='center', rotation='vertical') label = r"Objects with SNR \textgreater 20" props = dict(boxstyle='round', facecolor='white') ax.tick_params(axis='x', labelsize=16) ax.tick_params(axis='y', labelsize=16) ax.text(0.05, 0.85,
# # # Save current HMXB parameters as an object # HMXB = np.array([HMXB_ra, HMXB_dec, HMXB_Porb, HMXB_ecc, HMXB_M2, HMXB_vsys, HMXB_Lx, HMXB_theta]) # pickle.dump( HMXB, open( INDATA("SMC_MCMC_HMXB.obj"), "wb" ) ) # # print "Finished calculating forward evolution." # HMXB Orbital period vs. eccentricity fig, ax = plt.subplots(3, 1, figsize=(6,8)) plt.rc('font', size=14) plt_range = ([0, 4], [0,1]) corner.hist2d(np.log10(HMXB[2]), HMXB[3], ax=ax[0], bins=40, range=plt_range, plot_datapoints=False) ax[0].set_xlabel(r"${\rm log}\ P_{\rm orb}\ {\rm (days)}$", size=16) ax[0].set_ylabel(r"$e$", size=16) ax[0].set_xticks([0,1,2,3,4]) ax[0].set_yticks([0,0.25,0.5,0.75,1.0]) plt_range = ([8, 24], [0,80]) corner.hist2d(HMXB[4], HMXB[5], ax=ax[1], bins=40, range=plt_range, plot_datapoints=False) ax[1].set_xlabel(r"$M_2\ ({\rm M}_{\odot})$", size=16) ax[1].set_ylabel(r"$v_{\rm sys}\ {\rm (km\ s}^{-1})$", size=16) ax[1].set_xticks([8,12,16,20,24]) ax[1].set_yticks([0,20, 40, 60, 80]) # Get flight time from birth time and M1 lifetime load_sse.load_sse()
tab = Table.read( fourteenB_HI_data_wGBT_path( "tables/hi_co_gaussfit_column_densities_perpix.fits")) # Don't consider the "bad fits" that are probably due to multiple components good_pts = np.logical_and(~tab['multicomp_flag_HI'], ~tab['multicomp_flag_CO']) good_pts = np.logical_and(good_pts, tab["sigma_HI"] > 3800) # Minimum CO line width of one channel. good_pts = np.logical_and(good_pts, tab["sigma_CO"] >= 2600) ax2 = fig.add_axes((0.15, 0.1, 0.8, 0.35)) hist2d(tab['sigma_HI'][good_pts] / 1000., np.array(tab['sigma_CO'])[good_pts] / 1000., bins=13, data_kwargs={"alpha": 0.5}, ax=ax2) plt.xlabel(r"$\sigma_{\rm HI}$ (km/s)") plt.ylabel(r"$\sigma_{\rm CO}$ (km/s)") # From line_ratios_analysis.py slope_ratio = 0.56318 plt.plot([4, 12], [4. * slope_ratio, 12. * slope_ratio], '--', color=sb.color_palette()[1], linewidth=3, label='Ratio Fit', alpha=0.8) # plt.plot([4, 12], [4, 12], '-.', linewidth=3, alpha=0.6,
def logSFR_initiate(SHsnaps, indices, theta_sfh=None, theta_sfms=None, testing=False): ''' initiate log SFR function for Evolver.Evolve() method ''' nsnap0 = SHsnaps['metadata']['nsnap0'] mu_sfr0 = SFR_sfms(SHsnaps['m.star0'][indices], UT.z_nsnap(SHsnaps['nsnap_start'][indices]), theta_sfms) if theta_sfh['name'] == 'constant_offset': # constant d_logSFR F_sfr = _logSFR_dSFR sfr_kwargs = {'dSFR': SHsnaps['sfr0'][indices] - mu_sfr0, # offset 'theta_sfms': theta_sfms} elif theta_sfh['name'] == 'corr_constant_offset': # constant d_logSFR (assigned based on halo accretion rate) #dSFR0 = SHsnaps['sfr0'][indices] - mu_sfr # now rank order it based on halo accretion rate dMhalo = SHsnaps['halo.m'][indices] - SHsnaps['halo.m0'][indices] m_kind = SHsnaps[theta_sfh['m.kind']+'0'][indices] # how do we bin the SFRs? dm_kind = theta_sfh['dm.kind'] # bins to rank order # scatter from noise -- subtract intrinsic assembly bias scatter from sig_SFMS sig_noise = np.sqrt(0.3**2 - theta_sfh['sig_abias']**2) # slow and inefficient dsfr = np.repeat(-999., len(dMhalo)) for nn in np.arange(1, 21): started = np.where(SHsnaps['nsnap_start'][indices] == nn)[0] m_kind_bin = np.arange(m_kind[started].min(), m_kind[started].max()+dm_kind, dm_kind) ibin = np.digitize(m_kind[started], m_kind_bin) for i in np.unique(ibin): inbin = np.where(ibin == i) isort = np.argsort(dMhalo[started[inbin]]) dsfr[started[inbin[0][isort]]] = \ np.sort(np.random.randn(len(inbin[0]))) * theta_sfh['sig_abias'] assert dsfr.min() != -999. if sig_noise > 0.: dsfr += sig_noise * np.random.randn(len(dMhalo)) # correct initial SFR to match long-term assembly bias SHsnaps['sfr0'][indices] = mu_sfr0 + dsfr F_sfr = _logSFR_dSFR sfr_kwargs = {'dSFR': dsfr, 'theta_sfms': theta_sfms} elif theta_sfh['name'] == 'random_step': # completely random # amplitude is sampled randomly from a Gaussian with sig_logSFR = 0.3 # time steps are sampled randomly from a unifrom distribution [dt_min, dt_max] if 'dt_min' not in theta_sfh: raise ValueError if 'dt_max' not in theta_sfh: raise ValueError # Random step function duty cycle del_t_max = UT.t_nsnap(1) - UT.t_nsnap(nsnap0) #'nsnap_start'][indices].max()) # the range of the steps tshift_min = theta_sfh['dt_min'] tshift_max = theta_sfh['dt_max'] # get the times when the amplitude changes n_col = int(np.ceil(del_t_max/tshift_min))+1 # number of columns n_gal = len(indices) tshift = np.zeros((n_gal, n_col)) tshift[:,1:] = np.random.uniform(tshift_min, tshift_max, size=(n_gal, n_col-1)) tsteps = np.cumsum(tshift , axis=1) + np.tile(UT.t_nsnap(SHsnaps['nsnap_start'][indices]), (n_col, 1)).T del tshift # make sure everything evolves properly until the end assert tsteps[range(n_gal), n_col-1].min() > UT.t_nsnap(1) dlogSFR_amp = np.random.randn(n_gal, n_col) * theta_sfh['sigma'] dlogSFR_amp[:,0] = SHsnaps['sfr0'][indices] - mu_sfr0 F_sfr = _logSFR_dSFR_tsteps sfr_kwargs = {'dlogSFR_amp': dlogSFR_amp, 'tsteps': tsteps,'theta_sfms': theta_sfms} elif theta_sfh['name'] == 'random_step_fluct': # completely random amplitude that is sampled from a Gaussian with sig_logSFR # EXCEPT each adjacent timesteps have alternating sign amplitudes # time steps have width specified tduty dt_tot= UT.t_nsnap(1) - UT.t_nsnap(nsnap0) # total cosmic time of evolution tduty = theta_sfh['tduty'] # dutycycle time # get the times when the amplitude changes n_col = int(np.ceil(dt_tot / tduty))+2 # number of columns n_gal = len(indices) # number of galaxies tshift = np.tile(tduty, (n_gal, n_col)) tshift[:,0] = 0. tshift[:,1] = np.random.uniform(0., tduty, n_gal) tsteps = np.cumsum(tshift , axis=1) + np.tile(UT.t_nsnap(SHsnaps['nsnap_start'][indices]), (n_col, 1)).T del tshift # make sure everything evolves properly until the end assert tsteps[range(n_gal), n_col-1].min() > UT.t_nsnap(1) # dlogSFR absolute amplitue dlogSFR_amp = np.abs(np.random.randn(n_gal, n_col)) * theta_sfh['sigma'] dlogSFR_amp[:,0] = SHsnaps['sfr0'][indices] - mu_sfr0 # dlogSFR at nsnap_start # now make every other time step has fluctuating signs! pos = dlogSFR_amp[:,0] >= 0. neg = ~pos fluct = np.ones(n_col-1) fluct[2 * np.arange(int(np.ceil(float(n_col-1)/2.)))] *= -1. dlogSFR_amp[pos,1:] *= fluct dlogSFR_amp[neg,1:] *= -1. * fluct # testing the distribution of delta SFR if testing: for i in range(n_col): print('std of dlogSFR amp = %f' % np.std(dlogSFR_amp)) plt.hist(dlogSFR_amp[:,i], range=(-1., 1.), linewidth=2, histtype='step', density=True, label='Step '+str(i)) plt.legend() plt.xlabel(r'$\Delta\log\,\mathrm{SFR}$', fontsize=20) plt.xlim([-1., 1.]) plt.savefig(''.join([UT.fig_dir(), 'random_step_fluct_test.png']), bbox_inches='tight') F_sfr = _logSFR_dSFR_tsteps sfr_kwargs = {'dlogSFR_amp': dlogSFR_amp, 'tsteps': tsteps,'theta_sfms': theta_sfms} elif theta_sfh['name'] == 'random_step_abias_dt': # SFH where the amplitude w.r.t. the SFS is correlated with halo mass growth over # tdyn(t). The amplitude is sampled at every time step specified by `tduty` dt_tot= UT.t_nsnap(1) - UT.t_nsnap(nsnap0) # total cosmic time of evolution tduty = theta_sfh['tduty'] # dutycycle time sigma_int = np.sqrt(theta_sfh['sigma_tot']**2 - theta_sfh['sigma_corr']**2) # intrinsic sigma # get the times when the amplitude changes n_col = int(np.ceil(dt_tot / tduty))+2 # number of columns n_gal = len(indices) # number of galaxies tshift = np.tile(tduty, (n_gal, n_col)) tshift[:,0] = 0. tshift[:,1] = np.random.uniform(0., tduty, n_gal) tsteps = np.cumsum(tshift , axis=1) + \ np.tile(UT.t_nsnap(SHsnaps['nsnap_start'][indices]), (n_col, 1)).T del tshift # M_h of the galaxies throughout the snapshots Mh_snaps = np.zeros((n_gal, nsnap0+9), dtype=np.float32) Mh_snaps[:,0] = SHsnaps['halo.m'][indices] Mm_snaps = np.zeros((n_gal, nsnap0+9), dtype=np.float32) Mm_snaps[:,0] = SHsnaps['m.max'][indices] for isnap in range(2, nsnap0+10): Mh_snaps[:,isnap-1] = SHsnaps['halo.m.snap'+str(isnap)][indices] Mm_snaps[:,isnap-1] = SHsnaps['m.max.snap'+str(isnap)][indices] t_snaps = UT.t_nsnap(range(1, nsnap0+10)) # now we need to use these M_h to calculate the halo growth rates # at every time step t_i over the range t_i - dt_dMh to t_i. This means # we need to get M_h at both t_i and t_i-dt_dMh... f_dMh = np.zeros(tsteps.shape, dtype=np.float32) # growth rate of halos over t_i and t_i - dt_Mh #Mh_ts = np.zeros(tsteps.shape, dtype=np.float32) Mm_ts = np.zeros(tsteps.shape, dtype=np.float32) iii, iiii = 0, 0 for i_g in range(n_gal): in_sim = (Mm_snaps[i_g,:] > 0.) t_snaps_i = t_snaps[in_sim] Mh_snaps_i = np.power(10., Mh_snaps[i_g, in_sim]) Mm_snaps_i = np.power(10., Mm_snaps[i_g, in_sim]) t_i = tsteps[i_g,:] # t_i t_imdt = t_i - UT.tdyn_t(t_i) # t_i - tdyn #t_imdt = tsteps[i_g,:] - theta_sfh['dt_dMh'] # t_i - dt_dMh Mh_ti = np.interp(t_i, t_snaps_i[::-1], Mh_snaps_i[::-1]) Mh_timdt = np.interp(t_imdt, t_snaps_i[::-1], Mh_snaps_i[::-1]) f_dMh[i_g,:] = Mh_ti / Mh_timdt #1. - Mh_timdt / #Mh_ts[i_g,:] = np.log10(Mh_ti) Mm_ti = np.interp(t_i, t_snaps_i[::-1], Mm_snaps_i[::-1]) Mm_ts[i_g,:] = np.log10(Mm_ti) if testing: if (SHsnaps['nsnap_start'][indices][i_g] == 15) and (iii < 10): fig = plt.figure(figsize=(8,4)) sub = fig.add_subplot(121) sub.plot(t_snaps_i, Mh_snaps_i/Mh_snaps_i[0], c='k', ls='--') sub.fill_between([t_imdt[0], t_i[0]], [0., 0.], [1.2, 1.2], color='C0') sub.fill_between([t_imdt[-2], t_i[-2]], [0., 0.], [1.2, 1.2], color='C1') sub.vlines(UT.t_nsnap(15), 0., 1.2) sub.vlines(UT.t_nsnap(1), 0., 1.2) sub.set_xlim([0., 14.]) sub.set_ylim([0., 1.2]) sub = fig.add_subplot(122) sub.plot(t_i, f_dMh[i_g,:], c='k', ls='--') sub.scatter([t_i[0]], [f_dMh[i_g,0]], c='C0') sub.scatter([t_i[-2]], [f_dMh[i_g,-2]], c='C1') sub.vlines(UT.t_nsnap(15), -0.2, 5.) sub.vlines(UT.t_nsnap(1), -0.2, 5.) sub.set_xlim([0., 14.]) sub.set_ylim([0., 5.]) fig.savefig(''.join([UT.fig_dir(), 'abiastest', str(iii), '.png']), bbox_inches='tight') plt.close() iii += 1 if in_sim[15]: if Mh_snaps_i[0] < Mh_snaps_i[14]: if iiii > 10: continue fig = plt.figure(figsize=(8,4)) sub = fig.add_subplot(121) sub.plot(t_snaps_i, Mh_snaps_i/Mh_snaps_i[0], c='k', ls='--') sub.fill_between([t_imdt[0], t_i[0]], [0., 0.], [1.2, 1.2], color='C0') sub.fill_between([t_imdt[-2], t_i[-2]], [0., 0.], [1.2, 1.2], color='C1') sub.vlines(UT.t_nsnap(15), 0., 1.2) sub.vlines(UT.t_nsnap(1), 0., 1.2) sub.set_xlim([0., 14.]) sub.set_ylim([0., 1.2]) sub = fig.add_subplot(122) sub.plot(t_i, f_dMh[i_g,:], c='k', ls='--') sub.scatter([t_i[0]], [f_dMh[i_g,0]], c='C0') sub.scatter([t_i[-2]], [f_dMh[i_g,-2]], c='C1') sub.vlines(UT.t_nsnap(15), -0.2, 1.) sub.vlines(UT.t_nsnap(1), -0.2, 1.) sub.set_xlim([0., 14.]) sub.set_ylim([0., 5.]) sub.text(0.05, 0.05, r'$\log\,M_h='+str(round(np.log10(Mh_snaps_i[0]),2))+'$', fontsize=15, ha='left', va='bottom', transform=sub.transAxes) fig.savefig(''.join([UT.fig_dir(), 'weird_abiastest', str(iiii), '.png']), bbox_inches='tight') plt.close() iiii += 1 # calculate the d(log SFR) amplitude at t_steps # at each t_step, for a given halo mass bin of 0.2 dex, # rank order the SFRs and the halo growth rate dlogSFR_amp = np.zeros(f_dMh.shape, dtype=np.float32) dlogMh = 0.1 for ii in range(f_dMh.shape[1]): f_dMh_i = f_dMh[:,ii] Mh_ti = Mm_ts[:,ii] mh_bins = np.arange(Mh_ti.min(), Mh_ti.max(), dlogMh) #mh_bins = np.linspace(Mh_ti.min(), Mh_ti.max(), 100) if testing: fig = plt.figure(1, figsize=(4*np.int(np.ceil(float(len(mh_bins))/3.)+1.), 8)) for i_m in range(len(mh_bins)-1): inbin = ((Mh_ti >= mh_bins[i_m]) & (Mh_ti < mh_bins[i_m]+dlogMh)) #inbin = ((Mh_ti >= mh_bins[i_m]) & (Mh_ti < mh_bins[i_m+1])) n_bin = np.sum(inbin) isort = np.argsort(-1. * f_dMh_i[inbin]) irank = np.zeros(n_bin) irank[isort] = (np.arange(n_bin) + 0.5)/np.float(n_bin) # i_rank = 1/2 (1 - erf(x/sqrt(2))) # x = (SFR - avg_SFR)/sigma_SFR # dSFR = sigma_SFR * sqrt(2) * erfinv(1 - 2 i_rank) dlogSFR_amp[inbin, ii] = \ theta_sfh['sigma_corr'] * 1.41421356 * erfinv(1. - 2. * irank) if testing: sub = fig.add_subplot(3, np.int(np.ceil(np.float(len(mh_bins))/3.)+1), i_m+1) sub.scatter(f_dMh_i[inbin], 0.3 * np.random.randn(n_bin), c='k', s=2) sub.scatter(f_dMh_i[inbin], dlogSFR_amp[inbin, ii] + sigma_int * np.random.randn(n_bin), c='r', s=2, lw=0) sub.set_xlim([-0.5, 1.]) sub.set_ylim([-1., 1.]) if testing: plt.savefig(''.join([UT.fig_dir(), 'random_step_abias_dt_test', str(ii), '.png']), bbox_inches='tight') plt.close() fig = plt.figure(figsize=(8,4)) sub = fig.add_subplot(121) DFM.hist2d(Mh_ti, f_dMh_i, levels=[0.68, 0.95], range=[[10., 14.],[0., 10.]], color='k', plot_datapoints=False, fill_contours=False, plot_density=True, ax=sub) sub.set_xlim([10., 14.]) sub = fig.add_subplot(122) DFM.hist2d(Mh_ti, dlogSFR_amp[:,ii], levels=[0.68, 0.95], range=[[10., 14.],[-1., 1.]], color='k', plot_datapoints=False, fill_contours=False, plot_density=True, ax=sub) sub.set_xlim([10., 14.]) fig.savefig(''.join([UT.fig_dir(), 'abias_fdMh', str(ii), '.png']), bbox_inches='tight') plt.close() del f_dMh del Mm_ts # add in intrinsic scatter dlogSFR_int = np.random.randn(n_gal, n_col) * sigma_int dlogSFR_amp += dlogSFR_int SHsnaps['sfr0'][indices] = mu_sfr0 + dlogSFR_amp[:,0] # change SFR_0 so that it's assembly biased as well F_sfr = _logSFR_dSFR_tsteps sfr_kwargs = {'dlogSFR_amp': dlogSFR_amp, 'tsteps': tsteps,'theta_sfms': theta_sfms} else: raise NotImplementedError return F_sfr, sfr_kwargs
def priorSample(ngauss=128, quantile=0.5, iter='8th', survey='2MASS', dataFilename='All.npz', Nsamples=1.2e6, xdgmmFilename='xdgmm.fit', xlabel='X', ylabel='Y', contourColor='k'): setup_text_plots(fontsize=16, usetex=True) xdgmm = XDGMM(filename=xdgmmFilename) figPrior = plt.figure(figsize=(12, 5.5)) figPrior.subplots_adjust(left=0.1, right=0.95, bottom=0.15, top=0.95, wspace=0.1, hspace=0.1) sample = xdgmm.sample(Nsamples) negParallax = sample[:, 1] < 0 nNegP = np.sum(negParallax) while nNegP > 0: sampleNew = xdgmm.sample(nNegP) sample[negParallax] = sampleNew negParallax = sample[:, 1] < 0 nNegP = np.sum(negParallax) samplex = sample[:, 0] sampley = testXD.absMagKinda2absMag(sample[:, 1]) ax3 = figPrior.add_subplot(121) alpha = 0.1 xlim = [-0.25, 1.25] ylim = [6, -6] levels = 1.0 - np.exp(-0.5 * np.arange(1.0, 2.1, 1.0)**2) corner.hist2d(samplex, sampley, ax=ax3, levels=levels, bins=200, plot_datapoints=False, no_fill_contours=True, plot_density=False, color=contourColor) ax3.scatter(samplex, sampley, s=1, lw=0, c='k', alpha=alpha) ax4 = figPrior.add_subplot(122) for i in range(xdgmm.n_components): points = drawEllipse.plotvector(xdgmm.mu[i], xdgmm.V[i]) ax4.plot(points[0, :], testXD.absMagKinda2absMag(points[1, :]), 'k-', alpha=xdgmm.weights[i] / np.max(xdgmm.weights)) titles = [ "Extreme Deconvolution\n resampling", "Extreme Deconvolution\n cluster locations" ] ax = [ax3, ax4] for i in range(2): ax[i].set_xlim(xlim) ax[i].set_ylim(ylim[0], ylim[1] * 1.1) ax[i].text(0.05, 0.95, titles[i], ha='left', va='top', transform=ax[i].transAxes, fontsize=18) ax[i].set_xlabel(xlabel, fontsize=18) if i in (1, 3): ax[i].yaxis.set_major_formatter(plt.NullFormatter()) else: ax[i].set_ylabel(ylabel, fontsize=18) figPrior.savefig('prior_ngauss' + str(ngauss) + '.png')
def corner_plot(s, labels, extents, bf, truth): """ Plotting function to visualise the gaussian peaks found by the sampler function. 2D contour plots of tq against tau are plotted along with kernelly smooth histograms for each parameter. :s: Array of shape (#, 2) for either the smooth or disc produced by the emcee EnsembleSampler in the sample function of length determined by the number of walkers which resulted at the specified peak. :labels: List of x and y axes labels i.e. disc or smooth parameters :extents: Range over which to plot the samples, list shape [[xmin, xmax], [ymin, ymax]] :bf: Best fit values for the distribution peaks in both tq and tau found from mapping the samples. List shape [(tq, poserrtq, negerrtq), (tau, poserrtau, negerrtau)] :truth: Known t and tau values - generally for test data RETURNS: :fig: The figure object """ x, y = s[:,0], s[:,1] fig = P.figure(figsize=(6.25,6.25)) ax2 = P.subplot2grid((3,3), (1,0), colspan=2, rowspan=2) ax2.set_xlabel(labels[0]) ax2.set_ylabel(labels[1]) corner.hist2d(x, y, ax=ax2, bins=100, extent=extents, plot_contours=True) ax2.axvline(x=bf[0][0], linewidth=1) ax2.axhline(y=bf[1][0], linewidth=1) ax2.axvline(x=truth[0], c='r', linewidth=1) ax2.axhline(y=truth[1], c='r', linewidth=1) [l.set_rotation(45) for l in ax2.get_xticklabels()] [j.set_rotation(45) for j in ax2.get_yticklabels()] ax2.tick_params(axis='x', labeltop='off') ax1 = P.subplot2grid((3,3), (0,0),colspan=2) #ax1.hist(x, bins=100, range=(extents[0][0], extents[0][1]), normed=True, histtype='step', color='k') den = kde.gaussian_kde(x[np.logical_and(x>=extents[0][0], x<=extents[0][1])]) pos = np.linspace(extents[0][0], extents[0][1], 750) ax1.plot(pos, den(pos), 'k-', linewidth=1) ax1.axvline(x=bf[0][0], linewidth=1) ax1.axvline(x=bf[0][0]+bf[0][1], c='b', linestyle='--') ax1.axvline(x=bf[0][0]-bf[0][2], c='b', linestyle='--') ax1.set_xlim(extents[0][0], extents[0][1]) ax1.axvline(x=truth[0], c='r', linewidth=1) # ax12 = ax1.twiny() # ax12.set_xlim((extent[0][0], extent[0][1]) #ax12.set_xticks(np.array([1.87, 3.40, 6.03, 8.77, 10.9, 12.5])) #ax12.set_xticklabels(np.array([3.5, 2.0 , 1.0, 0.5, 0.25, 0.1])) # [l.set_rotation(45) for l in ax12.get_xticklabels()] # ax12.tick_params(axis='x', labelbottom='off') # ax12.set_xlabel(r'$z$') ax1.tick_params(axis='x', labelbottom='off', labeltop='off') ax1.tick_params(axis='y', labelleft='off') ax3 = P.subplot2grid((3,3), (1,2), rowspan=2) ax3.tick_params(axis='x', labelbottom='off') ax3.tick_params(axis='y', labelleft='off') #ax3.hist(y, bins=100, range=(extents[1][0], extents[1][1]), normed=True, histtype='step',color='k', orientation ='horizontal') den = kde.gaussian_kde(y[np.logical_and(y>=extents[1][0], y<=extents[1][1])]) pos = np.linspace(extents[1][0], extents[1][1], 750) ax3.plot(den(pos), pos, 'k-', linewidth=1) ax3.axhline(y=bf[1][0], linewidth=1) ax3.axhline(y=bf[1][0]+bf[1][1], c='b', linestyle='--') ax3.axhline(y=bf[1][0]-bf[1][2], c='b', linestyle='--') ax3.set_ylim(extents[1][0], extents[1][1]) ax3.axhline(y=truth[1], c='r', linewidth=1) P.tight_layout() P.subplots_adjust(wspace=0.0) P.subplots_adjust(hspace=0.0) return fig
def Evolve(sfh='constant_offset'): sh = Cat.CentralSubhalos( sigma_smhm=0.2, smf_source='li-march', nsnap0=15) shcat = sh.Read(downsampled='20') tt = Evo.defaultTheta(sfh) t0 = time.time() shcat = Evo.Evolve(shcat, tt) print('Evolve takes %f sec' % (time.time()-t0)) nsnap0 = shcat['metadata']['nsnap0'] isSF = (shcat['galtype'] == 'sf') fig = plt.figure(figsize=(12,4)) # stellar mass function sub = fig.add_subplot(131) for n in range(2, nsnap0)[::-1]: # identify SF population at snapshot smf_sf = Obvs.getMF(shcat['m.star.snap'+str(n)][isSF], weights=shcat['weights'][isSF]) sub.plot(smf_sf[0], smf_sf[1], lw=2, c='b', alpha=0.05 * (21. - n)) smf_sf = Obvs.getMF(shcat['m.star'][isSF], weights=shcat['weights'][isSF]) sub.plot(smf_sf[0], smf_sf[1], lw=3, c='b', ls='-', label='Integrated') smf_sf_msham = Obvs.getMF(shcat['m.sham'][isSF], weights=shcat['weights'][isSF]) sub.plot(smf_sf_msham[0], smf_sf_msham[1], lw=3, c='k', ls='--', label='SHAM') sub.set_xlabel('Stellar Masses $(\mathcal{M}_*)$', fontsize=25) sub.set_xlim([9., 11.5]) sub.set_ylim([1e-5, 10**-1.75]) sub.set_yscale('log') sub.set_ylabel('log $\Phi$', fontsize=25) sub.legend(loc='upper right', prop={'size': 20}) sub = fig.add_subplot(132) # Star Forming Sequence DFM.hist2d( shcat['m.star'][isSF], shcat['sfr'][isSF], weights=shcat['weights'][isSF], levels=[0.68, 0.95], range=[[9., 12.], [-3., 1.]], bins=20, plot_datapoints=False, fill_contours=False, plot_density=True, ax=sub) sub.set_xlabel('log $(\; M_*\; [M_\odot]\;)$', fontsize=25) sub.set_xlim([9., 11.5]) sub.set_xticks([9., 10., 11.]) sub.set_ylabel('log $(\;\mathrm{SFR}\;[M_\odot/\mathrm{yr}])$', fontsize=25) sub.set_ylim([-2.5, 1.]) sub.set_yticks([-2., -1., 0., 1.]) # stellar to halo mass relation sub = fig.add_subplot(133) smhmr = Obvs.Smhmr() m_mid, mu_mstar, sig_mstar, cnts = smhmr.Calculate(shcat['halo.m'][isSF], shcat['m.star'][isSF]) sub.errorbar(m_mid, mu_mstar, yerr=sig_mstar) sub.fill_between(m_mid, mu_mstar - 0.2, mu_mstar + 0.2, color='k', alpha=0.25, linewidth=0, edgecolor=None) sub.set_xlabel('Halo Mass $(\mathcal{M}_{halo})$', fontsize=25) sub.set_xlim([11., 14.]) sub.set_ylabel('Stellar Mass $(\mathcal{M}_*)$', fontsize=25) sub.set_ylim([9., 12.]) fig.tight_layout(pad=0.4, w_pad=0.5, h_pad=1.0) fig.savefig(''.join([UT.fig_dir(), 'evolver.', sfh, '.png']), bbox_inches='tight') plt.close() return None
def groupcatSFMS(mrange=[10.6,10.8]): '''Figure of the z~0 group catalog. Panel a) SFR-M* relation Panel b) P(SSFR) with SFMS fitting ''' # Read in Jeremy's group catalog with Mr_cut = -18 gc = Cat.Observations('group_catalog', Mrcut=18, position='central') gc_cat = gc.Read() fig = plt.figure(figsize=(10,5)) # fit the SFMS using lettalkaboutquench sfms fitting _fSFMS = fstarforms() _fit_logm, _fit_logsfr = _fSFMS.fit(gc_cat['mass'], gc_cat['sfr'], method='gaussmix', fit_range=None) logsfr_ms = _fSFMS.powerlaw(logMfid=10.5) print _fSFMS._powerlaw_m print _fSFMS._powerlaw_c fSFMS = fstarforms() fit_logm, _ = fSFMS.fit(gc_cat['mass'], gc_cat['sfr'], method='gaussmix', fit_range=mrange) _, fit_fsfms = fSFMS.frac_SFMS() i_fit = np.abs(fit_logm - np.mean(mrange)).argmin() # log SFR - log M* highlighting where the SFMS lies sub1 = fig.add_subplot(1,2,1) DFM.hist2d(gc_cat['mass'], gc_cat['sfr'], color='#ee6a50', levels=[0.68, 0.95], range=[[9., 12.], [-3.5, 1.5]], plot_datapoints=True, fill_contours=False, plot_density=True, ax=sub1) gc = Cat.Observations('group_catalog', Mrcut=18, position='central') gc_cat = gc.Read() #sub1.vlines(mrange[0], -5., 2., color='k', linewidth=2, linestyle='--') #sub1.vlines(mrange[1], -5., 2., color='k', linewidth=2, linestyle='--') #sub1.fill_between(mrange, [2.,2.], [-5.,-5], color='#1F77B4', alpha=0.25) sub1.fill_between(mrange, [2.,2.], [-5.,-5], color='k', linewidth=0, alpha=0.25) print _fit_logm, _fit_logsfr sub1.plot(np.linspace(9.8, 11., 10), logsfr_ms(np.linspace(9.8, 11., 10)), c='k', linestyle='--') sub1.set_xticks([9., 10., 11., 12.]) sub1.set_xlabel('log$(\; M_*\; [M_\odot]\;)$', fontsize=20) sub1.set_yticks([-3., -2., -1., 0., 1.]) sub1.set_ylabel('log$(\; \mathrm{SFR}\; [M_\odot/\mathrm{yr}]\;)$', fontsize=20) sub1.text(0.95, 0.1, 'SDSS central galaxies', ha='right', va='center', transform=sub1.transAxes, fontsize=20) # P(log SSFR) sub2 = fig.add_subplot(1,2,2) inmbin = np.where((gc_cat['mass'] > mrange[0]) & (gc_cat['mass'] < mrange[1])) bedge, pp = np.histogram(gc_cat['ssfr'][inmbin], range=[-14., -9.], bins=32, normed=True) pssfr = UT.bar_plot(pp, bedge) sub2.plot(pssfr[0], pssfr[1], c='k', lw=2) # overplot GMM component for SFMS gmm_weights = fSFMS._gmix_weights[i_fit] gmm_means = fSFMS._gmix_means[i_fit] gmm_vars = fSFMS._gmix_covariances[i_fit] icomp = gmm_means.argmax() xx = np.linspace(-14., -9, 100) sub2.fill_between(xx, np.zeros(len(xx)), gmm_weights[icomp]*MNorm.pdf(xx, gmm_means[icomp], gmm_vars[icomp]), color='#1F77B4', linewidth=0) for i_comp in range(len(gmm_vars)): if i_comp == 0: gmm_tot = gmm_weights[i_comp]*MNorm.pdf(xx, gmm_means[i_comp], gmm_vars[i_comp]) else: gmm_tot += gmm_weights[i_comp]*MNorm.pdf(xx, gmm_means[i_comp], gmm_vars[i_comp]) #sub2.plot(xx, gmm_tot, color='r', linewidth=2) sub2.set_xlim([-13.25, -9.5]) sub2.set_xticks([-10., -11., -12., -13.][::-1]) #sub2.set_xlim([-9.5, -13.25]) #sub2.set_xticks([-10., -11., -12., -13.]) sub2.set_xlabel('log$(\; \mathrm{SSFR}\; [\mathrm{yr}^{-1}]\;)$', fontsize=20) sub2.set_ylim([0., 1.5]) sub2.set_yticks([0., 0.5, 1., 1.5]) sub2.set_ylabel('$p\,(\;\mathrm{log}\; \mathrm{SSFR}\;)$', fontsize=20) # mass bin sub2.text(0.5, 0.9, '$'+str(mrange[0])+'< \mathrm{log}\, M_* <'+str(mrange[1])+'$', ha='center', va='center', transform=sub2.transAxes, fontsize=20) sub2.text(0.9, 0.33, '$f_\mathrm{SFMS}='+str(round(fit_fsfms[i_fit],2))+'$', ha='right', va='center', transform=sub2.transAxes, fontsize=20) fig.subplots_adjust(wspace=.3) fig.savefig(''.join([UT.tex_dir(), 'figs/groupcat.pdf']), bbox_inches='tight', dpi=150) plt.close() return None
def plot_slice_2d(core, x_pars, y_pars, titles, ncols=3, bins=30, color='k', title='', suptitle='', cmap='gist_rainbow', fontsize=17, publication_params=False, save=False, show=True, thin=1, plot_datapoints=True, xlabel='', ylabel='', plot_density=False, plot_contours=True, no_fill_contours=True, data_kwargs={ 'alpha': 0.008, 'color': (0.12156, 0.466667, 0.70588, 1.0) }, contour_kwargs={ 'linewidths': 0.8, 'colors': 'k', 'levels': [150, 350] }, **kwargs): """Function to plot 2d histograms of sliced analyses.""" L = len(x_pars) if len(x_pars) != len(y_pars): raise ValueError('Lists x_pars and y_pars must be the same length!') nrows = int(L // ncols) if L % ncols > 0: nrows += 1 fig = plt.figure() # figsize=[6,8]) for ii, (x_par, y_par, ti) in enumerate(zip(x_pars, y_pars, titles)): cell = ii + 1 axis = fig.add_subplot(nrows, ncols, cell) corner.hist2d(core.get_param(x_par, to_burn=True)[::thin], core.get_param(y_par, to_burn=True)[::thin], bins=bins, ax=axis, color=color, plot_datapoints=plot_datapoints, no_fill_contours=no_fill_contours, plot_density=plot_density, plot_contours=plot_contours, data_kwargs=data_kwargs, contour_kwargs=contour_kwargs, **kwargs) axis.set_title(ti) # axis.set_xlabel(x_par.decode()) # axis.set_ylabel(y_par.decode()) axis.set_xlim((0, 7)) xticks = np.linspace(0, 7, 8) yticks = np.linspace(-18, -13, 6) axis.set_xticks(xticks) # Set inner xticks null if cell <= ((nrows - 1) * ncols): empty_x_labels = [''] * len(xticks) axis.set_xticklabels(empty_x_labels) elif (cell == (ncols * (nrows - 1))) and (L != ncols * nrows): empty_x_labels = [''] * len(xticks) axis.set_xticklabels(empty_x_labels) # Set inner yticks null if (cell % ncols != 1): empty_y_labels = [''] * len(yticks) axis.set_yticklabels(empty_y_labels) axis.set_ylim((-18, -13)) fig.tight_layout(pad=0.4) fig.suptitle(suptitle, y=1.05, fontsize=19) fig.text(0.5, -0.02, xlabel, ha='center', usetex=False) fig.text(-0.02, 0.5, ylabel, va='center', rotation='vertical', usetex=False) if save: plt.savefig(save, bbox_inches='tight') if show: plt.show() plt.close()
axHistY = plt.subplot(gs1[3]) axHistY.set_ylim(TAUMIN,TAUMAX) axHistY.xaxis.set_major_formatter( NullFormatter() ) axHistY.yaxis.set_major_formatter( NullFormatter() ) #axHistY.plot([0,1000],[tau_mcmc[0],tau_mcmc[0]],color='blue') #axPic = plt.subplot(gs1[1]) #axPic.imshow(img) #axPic.axis('off') #perform smoothing of data #unsmooth = N.histogram(x,bins=BINS,weights=weighted,range=[TQMIN,TQMAX])[0] #x = N.transpose(lowess(unsmooth, N.arange(TQMAX/BINS,TQMAX+TQMAX/BINS,TQMAX/BINS), is_sorted=True, frac=0.025, it=0))[1] #print(x) #plot histogram c.hist2d(x,y,ax=axScatter,weights=weighted,range=[[TQMIN,TQMAX],[TAUMIN,TAUMAX]],bins=BINS,max_n_ticks=8,normed=True,smooth=2) axScatter.text(0.5,0.5,r'$0.5<z<1.0$') axScatter.text(0.5,0.3,r'$\log(1+\delta)<-0.25$') #axScatter.hist2d(x,y,weights=weighted,range=[[TQMIN,TQMAX],[TAUMIN,TAUMAX]],bins=150,normed=True) #axScatter.plot([tq_mcmc[0],tq_mcmc[0]],[0,5],color='blue') #axScatter.plot([0,100],[tau_mcmc[0],tau_mcmc[0]],color='blue') #perform smoothing of data #unsmooth = np.histogram(x,bins=BINS,weights=weighted,range=[TQMIN,TQMAX])[0] #weighted = smooth(weighted) axHistY.plot(yweights,N.arange(TAUMAX/BINS,TAUMAX + TAUMAX/BINS,TAUMAX/BINS),color='Black') axHistX.plot(N.arange(TQMAX/BINS,TQMAX + TQMAX/BINS,TQMAX/BINS),xweights,color='Black')
# raw_input("{0}, {1}?".format(y,x)) # p.clf() good_pts = np.logical_and(good_pts, tab["sigma_HI"] > 3800) # Minimum CO line width of one channel. good_pts = np.logical_and(good_pts, tab["sigma_CO"] >= 2600) # Show that the Gaussian model is a decent representation # twocolumn_twopanel_figure() cpal = sb.color_palette() ax1 = plt.subplot(121) hist2d(tab["coldens_CO_gauss"][good_pts] / (inc * co21_mass_conversion).value, tab["coldens_CO_FWHM"][good_pts] / (inc * co21_mass_conversion).value, data_kwargs={"alpha": 0.6}, ax=ax1) # plt.plot([0, 60], [0, 60], c=cpal[0], linewidth=3, linestyle='dashed') plt.plot([0, 15], [0, 15], c=cpal[0], linewidth=3, linestyle='dashed') plt.grid() # plt.xlabel("Gaussian Fit $\Sigma_{\mathrm{H2}}$ (M$_{\odot}$ pc$^{-2}$)") # plt.ylabel("FWHM $\Sigma_{\mathrm{H2}}$ (M$_{\odot}$ pc$^{-2}$)") plt.xlabel("CO Integrated Intensity\nfrom Gaussian Fit (K km s$^{-1}$)") plt.ylabel("CO Integrated Intensity\nin FWHM fit window\n(K km s$^{-1}$)") ax2 = plt.subplot(122) hist2d(tab["coldens_HI_gauss"][good_pts] / (inc * hi_mass_conversion).value, tab["coldens_HI_FWHM"][good_pts] / (inc * hi_mass_conversion).value, data_kwargs={"alpha": 0.6}, ax=ax2) # plt.plot([0, 25], [0, 25], c=cpal[0], linewidth=3, linestyle='dashed')
gs = GridSpec(3,3,figure=fig,height_ratios=[0.1,1,1], width_ratios=[1,1,0.15]) ax = [[],[],[],[]] ax[0].append(plt.subplot(gs[0,0])) ax[0].append(plt.subplot(gs[0,1])) ax[0].append(plt.subplot(gs[0,2])) ax[1].append(plt.subplot(gs[1,0])) ax[1].append(plt.subplot(gs[1,1])) ax[1].append(plt.subplot(gs[1,2])) ax[2].append(plt.subplot(gs[2,:])) qRan = (-2,2) wRan = (-2,2) hist2d(samples[:,0],samples[:,1],ax=ax[1][0],bins=30,plot_datapoints=False) ax[1][0].set_xlabel('$Q$') ax[1][0].set_ylabel('$W$') ax[1][0].set_xlim((0,2)) ax[1][0].set_ylim((-2,-0.5)) hist2d(samples[:,0],samples[:,1],ax=ax[1][1],bins=100, plot_datapoints=False,range=[qRan, wRan]) ax[1][1].set_xlabel('$Q$') ax[1][1].set_ylabel('$W$') lims = [ax[1][0].get_xlim(), ax[1][0].get_ylim()] rect = Rectangle((lims[0][0], lims[1][0]), lims[0][1]-lims[0][0], lims[1][1]-lims[1][0], linestyle='dashed',fill=False) ax[1][1].add_patch(rect) ax[1][1].scatter((1,),(1,)) ax[1][1].scatter((1,),(-1,)) ax[1][1].scatter((-1,),(1,))
def dataViz(survey='2MASS', ngauss=128, quantile=0.05, dataFilename='All.npz', iter='10th', Nsamples=3e5, contourColor='k', dustFile='dust.npz', sdss5=False, whatsThatFeature=False): if survey == 'APASS': mag1 = 'B' mag2 = 'V' absmag = 'G' xlabel='B-V' ylabel = r'M$_\mathrm{G}$' xlim = [-0.2, 2] ylim = [9, -2] if survey == '2MASS': mag1 = 'J' mag2 = 'K' absmag = 'J' xlabel = r'$(J-K)^C$' ylabel = r'$M_J^C$' xlim = [-0.25, 1.25] ylim = [6, -6] xdgmmFilename = 'xdgmm.' + str(ngauss) + 'gauss.dQ' + str(quantile) + '.' + iter + '.' + survey + '.' + dataFilename + '.fit' tgas, twoMass, Apass, bandDictionary, indices = testXD.dataArrays() dustEBV = 0.0 color = testXD.colorArray(mag1, mag2, dustEBV, bandDictionary) absMagKinda, apparentMagnitude = testXD.absMagKindaArray(absmag, dustEBV, bandDictionary, tgas['parallax']) color_err = np.sqrt(bandDictionary[mag1]['array'][bandDictionary[mag1]['err_key']]**2. + bandDictionary[mag2]['array'][bandDictionary[mag2]['err_key']]**2.) absMagKinda_err = tgas['parallax_error']*10.**(0.2*bandDictionary[absmag]['array'][bandDictionary[absmag]['key']]) xdgmm = XDGMM(filename=xdgmmFilename) sample = xdgmm.sample(Nsamples) negParallax = sample[:,1] < 0 nNegP = np.sum(negParallax) while nNegP > 0: sampleNew = xdgmm.sample(nNegP) sample[negParallax] = sampleNew negParallax = sample[:,1] < 0 nNegP = np.sum(negParallax) positive = absMagKinda > 0 y = absMagKinda[positive] yplus = y + absMagKinda_err[positive] yminus = y - absMagKinda_err[positive] parallaxErrGoesNegative = yminus < 0 absMagYMinus = testXD.absMagKinda2absMag(yminus) absMagYMinus[parallaxErrGoesNegative] = -50. yerr_minus = testXD.absMagKinda2absMag(y) - absMagYMinus yerr_plus = testXD.absMagKinda2absMag(yplus) - testXD.absMagKinda2absMag(y) #yerr_minus = testXD.absMagKinda2absMag(yplus) - testXD.absMagKinda2absMag(y) #yerr_plus = testXD.absMagKinda2absMag(y) - absMagYMinus """ testfig, testax = plt.subplots(3) testax[0].scatter(testXD.absMagKinda2absMag(y), y, s=1) testax[0].set_xlabel('absMag') testax[0].set_ylabel('absMagKinda') testax[1].scatter(testXD.absMagKinda2absMag(y), absMagYMinus, s=1) testax[1].set_xlabel('absMag') testax[1].set_ylabel('absMag Minus') testax[2].scatter(testXD.absMagKinda2absMag(y), testXD.absMagKinda2absMag(yplus), s=1) testax[2].set_xlabel('absMag') testax[2].set_ylabel('absMag Plus') plt.show() """ dp.plot_sample(color[positive], testXD.absMagKinda2absMag(y), sample[:,0], testXD.absMagKinda2absMag(sample[:,1]), xdgmm, xerr=color_err[positive], yerr=[yerr_minus, yerr_plus], xlabel=xlabel, ylabel=ylabel, xlim=xlim, ylim=ylim, errSubsample=2.4e3, thresholdScatter=2., binsScatter=200, contourColor=contourColor) dataFile = 'data_noDust.pdf' priorFile = 'prior_' + str(ngauss) +'gauss.pdf' os.rename('plot_sample.data.pdf', dataFile) os.rename('plot_sample.prior.pdf', priorFile) #import pdb; pdb.set_trace() data = np.load(dustFile) dustEBV = data['ebv'] color = testXD.colorArray(mag1, mag2, dustEBV, bandDictionary) absMagKinda, apparentMagnitude = testXD.absMagKindaArray(absmag, dustEBV, bandDictionary, tgas['parallax']) cNorm = plt.matplotlib.colors.Normalize(vmin=-6, vmax=2) posteriorFile = 'posteriorParallax.' + str(ngauss) + 'gauss.dQ' + str(quantile) + '.' + iter + '.' + survey + '.' + dataFilename for file in [posteriorFile]:#, 'posteriorSimple.npz']: data = np.load(file) parallax = data['mean'] parallax_err = np.sqrt(data['var']) notnans = ~np.isnan(parallax) & ~np.isnan(parallax_err) parallax = parallax[notnans] parallax_err = parallax_err[notnans] apparentMagnitudeGood = apparentMagnitude[notnans] c = np.log(data['var']) - np.log(tgas['parallax_error']**2.) absMagKinda = parallax*10.**(0.2*apparentMagnitudeGood) absMagKinda_err = parallax_err*10.**(0.2*apparentMagnitudeGood) y = absMagKinda yplus = y + absMagKinda_err yminus = y - absMagKinda_err parallaxErrGoesNegative = yminus < 0 absMagYMinus = testXD.absMagKinda2absMag(yminus) absMagYMinus[parallaxErrGoesNegative] = -50. absMag = testXD.absMagKinda2absMag(y) yerr_minus = absMag - absMagYMinus yerr_plus = testXD.absMagKinda2absMag(yplus) - absMag #notnan = ~np.isnan(color[notnans]) & ~np.isnan(absMag) contourColor = 'k' ascii.write([color[notnans], absMag, color_err[notnans], yerr_minus, yerr_plus, c[notnans]], 'cmdExpectation.txt', names=['color', 'absMag', 'color_err', 'absMag_errMinus', 'absMag_errPlus', 'logDeltaVar']) if whatsThatFeature & (file == posteriorFile): figFeature, axFeature = plt.subplots() x = color[notnans] y = absMag #levels = 1.0 - np.exp(-0.5 * np.arange(1.0, 2.1, 1.0) ** 2) im = corner.hist2d(x, y, ax=axFeature, levels=None, bins=200, no_fill_contours=True, plot_density=False, color=contourColor, rasterized=True, plot_contours=False) axFeature.set_xlim(xlim) axFeature.set_ylim(ylim) axFeature.set_xlabel(xlabel) axFeature.set_ylabel(ylabel) lowerMainSequence = (0.45, 5.5) upperMainSequence = (-0.225, 2) binarySequence = (0.75, 4) redClump = (0.35, -2) redGiantBranch = (1.0, -2) turnOff = (0.0, 3.5) features = [lowerMainSequence, upperMainSequence, binarySequence, redClump, redGiantBranch, turnOff] labels = ['lower MS', 'upper MS', 'binary sequence', 'red clump', 'RGB', 'MS turn off'] for l, f in zip(labels, features): axFeature.text(f[0], f[1], l, fontsize=15) figFeature.savefig('whatsThatFeature.pdf', format='pdf')
def assignHalo(nsnap=15): # read in subhalo catalog cat = Cat.CentralSubhalos(sigma_smhm=0.2, smf_source='li-march', nsnap0=15) sh = cat.Read() # read in Louis's catalog cat = LA2016.catalogAbramson2016() i_z = np.argmin(np.abs(cat['REDSHIFT'] - UT.z_nsnap(nsnap))) # index that best match to snapshot mstar = np.log10(cat['MSTEL_T'][:,i_z]) # M* @ z ~ zsnap ws = LA2016.matchSMF(mstar, UT.z_nsnap(nsnap), logM_range=[9., 12.]) # get the weights to match SMF # assign Mhalo, Mmax to Louis's catalog mhalo, mmax, i_halo = LA2016.assignHalo(mstar, nsnap, sh, logM_range=[9., 12.], dlogMs=0.2) # now lets compare the resulting SHMRs fig = plt.figure(figsize=(20,5)) # first a scatter plot sub = fig.add_subplot(141) sub.scatter(sh['halo.m.snap'+str(nsnap)], sh['m.sham.snap'+str(nsnap)], c='k', s=1, label='TreePM SHAM') sub.scatter(mhalo, mstar, c='C1', s=2, label='weighted Abramson+(2016)') sub.set_xlabel('log\,$M_h$', fontsize=25) sub.set_xlim([11., 14.]) sub.set_ylabel('log\,$M_*$', fontsize=25) sub.set_ylim([9., 12.]) sub.legend(loc=(0., 0.8), markerscale=5, handletextpad=0., frameon=True, fontsize=15) # a DFM contour plot sub = fig.add_subplot(142) DFM.hist2d(sh['halo.m.snap'+str(nsnap)], sh['m.sham.snap'+str(nsnap)], levels=[0.68, 0.95], range=[[11., 15.], [9., 12.]], color='k', bins=20, plot_datapoints=False, fill_contours=False, plot_density=False, ax=sub) DFM.hist2d(mhalo, mstar, weights=ws, levels=[0.68, 0.95], range=[[11., 15.], [9., 12.]], color='C1', bins=20, plot_datapoints=False, fill_contours=False, plot_density=False, ax=sub) sub.set_xlabel('log\,$M_h$', fontsize=25) sub.set_xlim([11., 14.]) sub.set_ylim([9., 12.]) # SHMR plot smhmr = Obvs.Smhmr() sub = fig.add_subplot(143) mbin = np.arange(11., 15., 0.2) ms_nonzero = (sh['m.sham.snap'+str(nsnap)] > 0.) m_mid, mu_logMs, sig_logMs, _ = smhmr.Calculate(sh['halo.m.snap'+str(nsnap)][ms_nonzero], sh['m.sham.snap'+str(nsnap)][ms_nonzero], m_bin=mbin) sub.errorbar(m_mid, mu_logMs, sig_logMs, fmt='.k') m_mid, mu_logMs, sig_logMs, _ = smhmr.Calculate(mhalo, mstar, weights=ws, m_bin=mbin) sub.errorbar(m_mid[m_mid > 11.8], mu_logMs[m_mid > 11.8], sig_logMs[m_mid > 11.8], fmt='.C1') sub.set_xlabel('log $M_h$', fontsize=25) sub.set_xlim([11., 14.]) #sub.set_ylabel('log $M_*$', fontsize=25) sub.set_ylim([9., 12.]) #sub.set_ylim([0., 0.5]) sub = fig.add_subplot(144) mbin = np.arange(9., 12., 0.2) m_mid, mu_logMs, sig_logMs, _ = smhmr.Calculate(sh['m.sham.snap'+str(nsnap)], sh['halo.m.snap'+str(nsnap)], m_bin=mbin) sub.errorbar(m_mid, mu_logMs, sig_logMs, fmt='.k') m_mid, mu_logMs, sig_logMs, _ = smhmr.Calculate(mstar, mhalo, weights=ws, m_bin=mbin) sub.errorbar(m_mid, mu_logMs, sig_logMs, fmt='.C1') sub.set_xlabel('log $M_*$', fontsize=25) sub.set_xlim([9., 12.]) sub.set_ylabel('log $M_h$', fontsize=25) sub.set_ylim([11., 14.]) ffig = ''.join([UT.fig_dir(), 'catalogAbramson.SHMRsnap', str(nsnap), '.png']) fig.savefig(ffig, bbox_inches="tight") plt.close() return None
plt.rc('font', size=10) ################# Posterior plots ################## plt.rc('font', size=8) fig, ax = plt.subplots(2,5, figsize=(14,6)) for i in np.arange(10): a = np.int(i/5) b = i%5 xmin = np.min(sampler.chain[:,:,i]) xmax = np.max(sampler.chain[:,:,i]) corner.hist2d(sampler.chain[:,:,i], sampler.lnprobability, ax=ax[a,b], bins=30, range=((xmin,xmax),(-50,0)), plot_datapoints=False) ax[a,b].set_xlabel(labels[i]) ax[a,b].set_ylim(-30,0) plt.tight_layout() plt.savefig('../figures/J0045_posterior_params_multiburn.pdf') ################# Chains plot ##################### fig, ax = plt.subplots(sampler1.dim, 5, sharex=False, figsize=(18.0,20.0)) for i in range(sampler1.dim): for j in np.arange(len(sampler1.chain[...])): chain1 = sampler1.chain[...,i][j] ax[i,0].plot(chain1, alpha=0.25, color='k', drawstyle='steps')
yloc = plt.MaxNLocator(3) ax[i].yaxis.set_major_locator(yloc) # ax[i].set_yticks(fontsize=8) fig.subplots_adjust(hspace=0) plt.yticks(fontsize = 8) plt.savefig('../figures/sys2_chains.pdf', rasterized=True) # Likelihood as a function of each parametersplt.rc('font', size=8) fig, ax = plt.subplots(2,5, figsize=(14,6)) labels = [r"$M_1$", r"$M_2$", r"$A$", r"$e$", r"$v_k$", r"$\theta$", r"$\phi$", r"$\alpha_{\rm b}$", r"$\delta_{\rm b}$", r"$t_{\rm b}$"] for i in np.arange(10): a = np.int(i/5) b = i%5 corner.hist2d(sampler.chain[:,:,i], sampler.lnprobability, ax=ax[a,b], bins=20) ax[a,b].set_xlabel(labels[i]) plt.tight_layout() plt.savefig('../figures/sys2_likelihoods.pdf') # Corner plot plt.rc('font', size=18) labels = [r"$M_1$", r"$M_2$", r"$A$", r"$e$", r"$v_k$", r"$\theta$", r"$\phi$", r"$\alpha_{\rm b}$", r"$\delta_{\rm b}$", r"$t_{\rm b}$"] truths = [M1_true, M2_true, A_true, ecc_true, v_k_true, theta_true, phi_true, ra_true, dec_true, t_b_true] fig = corner.corner(sampler.flatchain, labels=labels, truths=truths) ax2 = plt.subplot2grid((5,5), (0,3), colspan=2, rowspan=2) ra_out = sampler.flatchain.T[7] dec_out = sampler.flatchain.T[8]