def main():
#seaborn.set_palette("Set2")
seaborn.set_palette("colorblind")
# Create a dataframe with one row per parameter set
dfs_paramsets = [prepare_df_density_errors(df, R32) for df in dfs]
name = "mape_liq_density"
fig, ax = plt.subplots()
axins = inset_axes(ax,
width="100%",
height="100%",
bbox_to_anchor=(0.35, 0.45, 0.25, 0.40),
bbox_transform=ax.transAxes,
loc=3)
ax.set_box_aspect(1.2)
ax.plot(
dfs_paramsets[0].sort_values(name)[name],
np.arange(1, 201, 1),
'-s',
markersize=6,
linewidth=3,
alpha=0.8,
label="LD-1",
)
ax.plot(
dfs_paramsets[1].sort_values(name)[name],
np.arange(1, 201, 1),
'-s',
markersize=6,
linewidth=3,
alpha=0.8,
label="LD-2",
)
ax.plot(
dfs_paramsets[2].sort_values(name)[name],
np.arange(1, 201, 1),
'-s',
markersize=6,
linewidth=3,
alpha=0.8,
label="LD-3",
)
ax.plot(
dfs_paramsets[3].sort_values(name)[name],
np.arange(1, 201, 1),
'-s',
markersize=6,
linewidth=3,
alpha=0.8,
label="LD-4",
)
ax.set_ylim(0, 205)
ax.set_xlim(0, 100)
ax.set_yticks([0, 50, 100, 150, 200])
ax.xaxis.set_major_locator(MultipleLocator(20))
ax.xaxis.set_minor_locator(AutoMinorLocator(2))
ax.yaxis.set_major_locator(MultipleLocator(50))
ax.yaxis.set_minor_locator(AutoMinorLocator(2))
ax.tick_params("both",
direction="in",
which="both",
length=4,
labelsize=16,
pad=10)
ax.tick_params("both", which="major", length=8)
ax.xaxis.set_ticks_position("both")
ax.yaxis.set_ticks_position("both")
ax.set_ylabel(r"$N_\mathrm{cumu.}$ parameter sets",
fontsize=20,
labelpad=20)
ax.set_xlabel("Liquid density MAPE", fontsize=20, labelpad=15)
ax.legend(fontsize=16,
loc=(-0.06, 1.05),
ncol=2,
columnspacing=1,
handletextpad=0.5)
axins.plot(
dfs_paramsets[0].sort_values(name)[name],
np.arange(1, 201, 1),
'-s',
markersize=4,
linewidth=2,
alpha=0.6,
label="LD-1",
)
axins.plot(
dfs_paramsets[1].sort_values(name)[name],
np.arange(1, 201, 1),
'-s',
markersize=4,
linewidth=2,
alpha=0.6,
label="LD-2",
)
axins.plot(
dfs_paramsets[2].sort_values(name)[name],
np.arange(1, 201, 1),
'-s',
markersize=4,
linewidth=2,
alpha=0.6,
label="LD-3",
)
axins.plot(
dfs_paramsets[3].sort_values(name)[name],
np.arange(1, 201, 1),
'-s',
markersize=4,
linewidth=2,
alpha=0.6,
label="LD-4",
)
axins.set_xlim(0, 2.5)
axins.set_ylim(0, 125)
axins.tick_params("both",
direction="in",
which="both",
length=3,
labelsize=12)
axins.tick_params("both", which="major", length=6)
axins.xaxis.set_major_locator(MultipleLocator(1))
axins.xaxis.set_minor_locator(AutoMinorLocator(2))
axins.yaxis.set_major_locator(MultipleLocator(50))
axins.yaxis.set_minor_locator(AutoMinorLocator(2))
axins.xaxis.set_ticks_position("both")
axins.yaxis.set_ticks_position("both")
fig.tight_layout()
fig.savefig("pdfs/fig2_r32-density-cumu.pdf")
f3 = np.loadtxt("freq_590_VNATrc.001")
#chdir("../process")
fig, ax = plt.subplots()
plt.minorticks_on()
p1, = plt.plot(f3[:, 0], f3[:, 2] - np.sum(f3[:, 2]) / len(f1[:, 2]))
p2, = plt.plot(f2[:, 0], f2[:, 2] - np.sum(f2[:, 2]) / len(f1[:, 2]) + 100.)
p3, = plt.plot(f1[:, 0], f1[:, 2] - np.sum(f1[:, 2]) / len(f1[:, 2]) + 100.)
plt.xlim(0.0, 1.6)
plt.ylim(-30., 30.)
plt.ylabel("Phase shift (deg)")
plt.xlabel("Time (s)")
plt.legend([p1, p2, p3], ["590 GHz", "562 GHz", "538 GHz"], loc=3)
plt.title("Motion of cryostat")
ax.xaxis.set_minor_locator(AutoMinorLocator(2))
ax.yaxis.set_minor_locator(AutoMinorLocator(2))
plt.savefig("apr6fig1.pdf")
plt.clf()
fig, ax = plt.subplots()
plt.minorticks_on()
p1, = plt.plot(f3[:, 0], f3[:, 2] - np.sum(f3[:, 2]) / len(f1[:, 2]))
p2, = plt.plot(f2[:, 0], f2[:, 2] - np.sum(f2[:, 2]) / len(f1[:, 2]))
p3, = plt.plot(f1[:, 0], f1[:, 2] - np.sum(f1[:, 2]) / len(f1[:, 2]) + 100.)
plt.xlim(0.0, 1.6)
plt.ylim(-30., 30.)
plt.ylabel("Phase shift (deg)")
plt.xlabel("Time (s)")
plt.legend([p1, p2, p3], ["590 GHz", "562 GHz", "538 GHz"], loc=3)
plt.title("Motion of cryostat")
plotName = 'Scatterplot_permodel_ToE_noise_RCP85vsPiControl_'+str(multstd)+'std'
noise = 'PiControl'
else:
title = 'Hist+RCP8.5 vs. histNat ('+str(nruns)+' runs)'
noise = 'histNat'
if runs_rcp == 'all':
plotName = 'Scatterplot_permodel_ToE_noise_RCP85vshistNat_'+str(multstd)+'std_newsignal'
else:
plotName = 'Scatterplot_permodel_ToE_noise_RCP85vshistNat_'+str(multstd)+'std_samerunsvsPiC'
ax.set_ylim([1860,2105])
ax.set_xlim([0,0.14])
ax.set_xticks(np.arange(0,0.1401,0.02))
xmajorLocator = MultipleLocator(40)
xminorLocator = AutoMinorLocator(2)
ax.yaxis.set_major_locator(xmajorLocator)
ax.yaxis.set_minor_locator(xminorLocator)
fig.delaxes(axes[-1,-1])
#plt.suptitle('ToE[>' +str(multstd)+ 'std]/noise for '+title, fontweight='bold', fontsize=14)
plt.figtext(0.38,0.03,'Noise: std('+noise+')', fontweight='bold',fontsize=15)
plt.figtext(0.007,0.63,'Time of Emergence', fontweight='bold', rotation='vertical',fontsize=15)
# Put a legend to the right of the current axis
lgd = fig.legend(l,domain_names,loc='center right', bbox_to_anchor=(0.995, 0.5), scatterpoints=1,frameon=False, markerscale=2,fontsize=14)
plt.subplots_adjust(left=0.06,right=0.8,hspace=0.13,wspace=0.1,bottom=0.12)
def plot_secondary_spectrum():
# =========================================================
# Plot
# =========================================================
# tex_preamble = [
# r"\usepackage{amsmath}",
# r"\usepackage[utf8]{inputenc}",
# r"\usepackage[T1]{fontenc}",
# ]
# font_size = 10
# params = {
# 'backend': 'pdf',
# 'font.family': 'serif',
# 'font.size': 12,
# 'text.usetex': True,
# 'text.latex.preamble': tex_preamble,
# 'axes.labelsize': font_size,
# 'legend.numpoints': 1,
# 'legend.shadow': False,
# 'legend.fontsize': font_size,
# 'xtick.labelsize': font_size,
# 'ytick.labelsize': font_size,
# 'axes.unicode_minus': True
# }
# plt.rcParams.update(params)
inch_to_cm = 2.54
golden_ratio = 1.61803
width = 29.7 # cm
# # =========================================================
# # All hists together $10^{{{:.0g}}}$
# # =========================================================
npzfile = np.load("data_sec_dist_MuMinus_standardrock_Emin_10.0_Emax_10.0.npz")
ioniz_secondary_energy = npzfile['ioniz']
brems_secondary_energy = npzfile['brems']
photo_secondary_energy = npzfile['photo']
epair_secondary_energy = npzfile['epair']
statistics = npzfile['statistics'][0]
E_min_log = npzfile['E_min'][0]
E_max_log = npzfile['E_max'][0]
spectral_index = npzfile['spectral_index'][0]
distance = npzfile['distance'][0]
medium_name = npzfile['medium_name'][0]
particle_name = npzfile['particle_name'][0]
ecut = npzfile['ecut'][0]
vcut = npzfile['vcut'][0]
fig_all = plt.figure(
figsize=(width / inch_to_cm, width / inch_to_cm / golden_ratio)
)
fig_all.suptitle(r"{:g} {} from $10^{{{:.2g}}}$ to $10^{{{:.2g}}}$ MeV from $E^{{-{:.2g}}}$ spectrum propagated {} m in {}".format(
statistics,
particle_name,
E_min_log,
E_max_log,
spectral_index,
distance,
medium_name,
))
ax_all = fig_all.add_subplot(111)
ax_all.hist(
[
ioniz_secondary_energy,
photo_secondary_energy,
brems_secondary_energy,
epair_secondary_energy,
np.concatenate((
ioniz_secondary_energy,
brems_secondary_energy,
photo_secondary_energy,
epair_secondary_energy)
)
],
histtype='step',
log=True,
bins=100,
label=['Ionization', 'Photonuclear', 'Bremsstrahlung', 'Pair Production', 'Sum']
)
# ax_all.set_ylim(ymin=0)
minor_locator = AutoMinorLocator()
ax_all.xaxis.set_minor_locator(minor_locator)
ax_all.legend()
ax_all.set_xlabel(r'energy loss / log($E$/MeV)')
ax_all.set_ylabel(r'$N$')
fig_all.savefig("all_{}_stats_{}_Emin_{}_Emax_{}_index_{}.pdf".format(
medium_name,
statistics,
E_min_log,
E_max_log,
spectral_index
))
def plot_all(enwiki_collections, geb_collections, datasets, methods,
limit_methods, base_methods, plot_folder, get_ylim):
titles = ["enwiki", "geb"]
for d in datasets:
fig, axs = plt.subplots(nrows=1, ncols=2, sharex='all')
# fig.suptitle(d)
for i, ax in enumerate(axs):
ax.set_title(titles[i])
ax.set_ylim(get_ylim(d))
cc = cycle(colors)
for m, lm in zip(methods, limit_methods):
enwiki_curve = enwiki_collections['alpha'][d][m]
enwiki_lim = enwiki_collections['alpha'][d][lm]
geb_curve = geb_collections['alpha'][d][m]
geb_lim = geb_collections['alpha'][d][lm]
c = next(cc)
axs[0].plot(alphas, enwiki_curve, color=c, label=nice_label(m))
axs[0].hlines(enwiki_lim, amin, amax, linestyles='--', color=c)
axs[0].set_xlim(-10, 6)
#axs[0].grid()
axs[0].set_xticks(np.arange(-10, 7, 2))
minor_locator = AutoMinorLocator(2)
axs[0].xaxis.set_minor_locator(minor_locator)
axs[0].set_yticks(
np.arange(min(get_ylim(d)),
max(get_ylim(d)) + 1, 2))
minor_locator = AutoMinorLocator(2)
axs[0].yaxis.set_minor_locator(minor_locator)
axs[0].set_axisbelow(True)
#ax.grid(which='major', linestyle='-', linewidth='0.5', color='gray')
#ax.grid(which='minor', linestyle='-', linewidth='0.5', color='gray')
axs[0].grid(which='major',
linestyle='-',
linewidth='1',
color='lightgray')
axs[0].grid(which='minor',
linestyle='--',
linewidth='1',
color='lightgray')
axs[1].plot(alphas, geb_curve, color=c, label=nice_label(m))
axs[1].hlines(geb_lim, amin, amax, linestyles='--', color=c)
axs[1].set_xlim(-10, 7)
axs[1].grid()
axs[1].set_xticks(np.arange(-10, 7, 2))
minor_locator = AutoMinorLocator(2)
axs[1].xaxis.set_minor_locator(minor_locator)
axs[1].set_yticks(
np.arange(min(get_ylim(d)),
max(get_ylim(d)) + 1, 2))
minor_locator = AutoMinorLocator(2)
axs[1].yaxis.set_minor_locator(minor_locator)
axs[1].set_axisbelow(True)
#ax.grid(which='major', linestyle='-', linewidth='0.5', color='gray')
#ax.grid(which='minor', linestyle='-', linewidth='0.5', color='gray')
axs[1].grid(which='major',
linestyle='-',
linewidth='1',
color='lightgray')
axs[1].grid(which='minor',
linestyle='--',
linewidth='1',
color='lightgray')
plot_base(base_methods, enwiki_collections['base'][d], axs[0])
plot_base(base_methods, geb_collections['base'][d], axs[1])
lgd = axs[0].legend(loc='upper center',
bbox_to_anchor=(1, 0.0),
ncol=4)
#plt.tight_layout()
fig.subplots_adjust(bottom=0.4) # or whatever
path = plot_folder + "/" + d + ".png"
plt.savefig(path) #, bbox_extra_artist = [lgd])
print("saved " + path)
plt.close()
subprocess.run(["convert", "-trim", path, path])
ax1 = fig.add_subplot(1, 1, 1)
# Hide the right and top spines
# ax1.spines['right'].set_visible(False)
# ax1.spines['top'].set_visible(False)
# df['mytime'] = df.index
# df['hours'] = df.mytime.dt.strftime('%H:%M')
df = df.reset_index()
# print(df)
df1 = df[ df.index > timeThreshold ]
ax1.plot(df1.index, df1['HV_voltage'], 'o',color="darkorange", markersize=5, alpha=0.65, markeredgewidth=1.5, markeredgecolor='darkorange')
# plt.ylim(0.05,0.25)
# ax1.yaxis.set_ticks(np.arange(0.05,0.25+0.05,0.05))
# minor ticks x
minor_locator = AutoMinorLocator(2)
ax1.xaxis.set_minor_locator(minor_locator)
# minor ticks y
minor_locator = AutoMinorLocator(2)
ax1.yaxis.set_minor_locator(minor_locator)
# tick font size
ax1.tick_params('x', colors='black', labelsize=12)
ax1.tick_params('y', colors='black', labelsize=12)
ax1.set_ylabel(r'\textbf{HV [-kV]}', fontsize=12)
ax1.set_xlabel(r'\textbf{Timestamp [minutes]}', fontsize=12, labelpad=2)
ax1.grid(b=True, which='major', linestyle='-')#, color='gray')
ax1.grid(b=True, which='minor', linestyle='--')#, color='gray')
# plt.plot(Tplot,cvplot, label="N={}".format(int(n)),
# color=colors[k],marker=markers[k])
WL_only=True
for i in [1]:#np.arange(len(sys.argv)):
if True:#sys.argv[i] == "me":
ax.plot(Tplot_ME,cvplot_ME/cvplot.max(),color=colors[k],marker=markers[k],
fillstyle='none', ms=15, ls="", label="ME: $N={}$".format(int(n)))
WL_only=False
ax.plot(Tplot,cvplot/cvplot.max(),alpha=1, color=colors[k],
dashes=ls_dashes[k],label="WL: $N={}$".format(int(n)),lw=3)
ax.set_xlim(0,3)
ax.set_ylim(0,1.25)
ax.tick_params(left=True,right=True,bottom=True,top=True,which='major',length=10)
ax.tick_params(right=True, direction='in',which='both',pad=10)
ax.tick_params(left=True,right=True,bottom=True,top=True,which='minor',length=5)
minor_locator_x = AutoMinorLocator(5)
minor_locator_y = AutoMinorLocator(2)
ax.xaxis.set_minor_locator(minor_locator_x)
ax.yaxis.set_minor_locator(minor_locator_y)
major_locator_x = MultipleLocator(0.5)
major_locator_y = MultipleLocator(0.2)
ax.xaxis.set_major_locator(major_locator_x)
ax.yaxis.set_major_locator(major_locator_y)
k+=1
#f.suptitle(r"Wärmekapazitäten unterschiedlich langer Einzelketten,"+
# " auf Maximum normiert\n"+
# r"bei gleicher Wechselwirkungsenergie $\epsilon=-0.4$")
plt.subplots_adjust(wspace=0.075, hspace=0.05, top=0.99,bottom=0.07,
left=0.07,right=0.98)
#plt.yticks([0,0.2,0.4,0.6,0.8,1]) #plt.yticks()[0][::2])
#plt.xticks([0,1,2,3]) #plt.xticks()[0][::2])
def plot_kappa_v_color(kappas, errs, colorkey, planck_kappas=None, act_kappas=None, transforms=None, remove_reddest=False, linfit=None, mode='color'):
fig, ax1 = plt.subplots(figsize=(8, 7))
#colors = np.arange(1, len(kappas)+1)*1/len(kappas) - 1/(2*len(kappas))
colors = range(1, len(kappas)+1)
if not remove_reddest:
lastidx = len(colors)-1
redcolor = colors[lastidx]
redkappa = kappas[lastidx]
rederr = errs[lastidx]
plt.scatter(redcolor, redkappa, edgecolors='grey', marker='s', facecolors='none')
plt.errorbar(redcolor, redkappa, yerr=rederr, fmt='none', ecolor='grey')
colors = colors[:lastidx]
kappas = kappas[:lastidx]
errs = errs[:lastidx]
ax1.scatter(colors, kappas, c='k')
ax1.errorbar(colors, kappas, yerr=errs, fmt='none', ecolor='k')
if linfit is not None:
linmod = linfit[0] * np.array(colors) + linfit[1]
ax1.plot(colors, linmod, c='k', linestyle='--')
#if offset:
#ax1.set_xlabel(r'$\langle \Delta (g-i) \rangle$', fontsize=20)
if mode == 'color':
ax1.set_xlabel('$%s$ bin' % colorkey, fontsize=20)
elif mode == 'bal':
ax1.set_xlabel('BAL bin', fontsize=20)
elif mode == 'bhmass':
ax1.set_xlabel('BH Mass bin', fontsize=20)
#else:
#plt.xlabel('$g-i$', fontsize=20)
ax1.set_ylabel(r'$\langle \kappa_{\mathrm{peak}} \rangle$', fontsize=25)
if planck_kappas is not None:
planck_kappas = np.array(planck_kappas)
ax1.scatter(colors, planck_kappas[:, 0], c='cyan', label='Planck')
ax1.errorbar(colors, planck_kappas[:, 0], yerr=planck_kappas[:, 1], fmt='none', ecolor='cyan', alpha=0.3)
if act_kappas is not None:
act_kappas = np.array(act_kappas)
ax1.scatter(colors, act_kappas[:, 0], c='pink', label='ACT')
ax1.errorbar(colors, act_kappas[:, 0], yerr=act_kappas[:, 1], ecolor='pink', fmt='none', alpha=0.3)
plt.legend()
if transforms is not None:
def forward(x):
return np.interp(x, transforms[0], transforms[1])
def inverse(x):
return np.interp(x, transforms[1], transforms[0])
secax = ax1.secondary_yaxis('right', functions=(forward, inverse))
secax.yaxis.set_minor_locator(AutoMinorLocator())
secax.set_ylabel(r'$\langle \mathrm{log}_{10}(M/h^{-1} M_{\odot})\rangle$', fontsize=20)
plt.savefig('plots/kappa_v_%s.pdf' % mode)
plt.close('all')
def plot_bias_by_bin(refnames, n_sample_bins):
plt.close('all')
fig, axs = plt.subplots(len(refnames), 1, sharex=True, figsize=(10, 7*len(refnames)))
tab = fits.open('catalogs/derived/eBOSS_QSO_binned.fits')[1].data
shift = 0.007
nboots = 5
medcolors, mederrs = [], []
for j in range(n_sample_bins):
bintab = tab[np.where(tab['bin'] == j + 1)]
medcolors.append(np.median(bintab['deltagmini']))
bootmeds = []
for k in range(nboots):
boottab = bintab[np.random.choice(len(bintab), len(bintab))]
bootmeds.append(np.median(boottab['deltagmini']))
mederrs.append(np.std(bootmeds))
medcolors = np.array(medcolors)
for i, refname in enumerate(refnames):
ngcbiases, sgcbiases, ngcbiaserrs, sgcbiaserrs = [], [], [], []
for j in range(n_sample_bins):
tmp1, tmp2 = np.load('bias/eBOSS_QSO/NGC/%s_%s.npy' % (refname, j+1), allow_pickle=True)
ngcbiases.append(tmp1)
ngcbiaserrs.append(tmp2)
axs[i].scatter(medcolors - shift, ngcbiases, c='slategray', alpha=0.2, label='NGC')
axs[i].errorbar(medcolors - shift, ngcbiases, yerr=ngcbiaserrs, fmt='none', c='slategray', alpha=0.2)
for j in range(n_sample_bins):
tmp1, tmp2 = np.load('bias/eBOSS_QSO/SGC/%s_%s.npy' % (refname, j + 1), allow_pickle=True)
sgcbiases.append(tmp1)
sgcbiaserrs.append(tmp2)
axs[i].scatter(medcolors + shift, sgcbiases, c='saddlebrown', alpha=0.2, label='SGC')
axs[i].errorbar(medcolors + shift, sgcbiases, yerr=ngcbiaserrs, fmt='none', c='saddlebrown', alpha=0.2)
avg_bias = np.average([ngcbiases, sgcbiases], weights=[1/np.array(ngcbiaserrs), 1/np.array(sgcbiaserrs)], axis=0)
avg_err = np.sqrt(np.array(ngcbiaserrs)**2 + np.array(sgcbiaserrs)**2)/2
minb, maxb = np.min([np.min(ngcbiases), np.min(sgcbiases)]), np.max([np.max(ngcbiases), np.max(sgcbiases)])
b_grid = np.linspace(minb, maxb, 20)
zs, dndz = redshift_dists.redshift_dist(tab)
masses = []
for bb in b_grid:
masses.append(clusteringModel.avg_bias_to_mass(bb, zs, dndz))
transforms = [b_grid, np.log10(masses)]
if transforms is not None:
def forward(x):
return np.interp(x, transforms[0], transforms[1])
def inverse(x):
return np.interp(x, transforms[1], transforms[0])
secax = axs[i].secondary_yaxis('right', functions=(forward, inverse))
secax.yaxis.set_minor_locator(AutoMinorLocator())
secax.set_ylabel(r'$ \mathrm{log}_{10}(M_h/h^{-1} M_{\odot})$', fontsize=30, labelpad=20)
secax.tick_params(axis='y', which='major', labelsize=25)
axs[i].scatter(medcolors, avg_bias, c='k', label='Mean')
axs[i].errorbar(medcolors, avg_bias, yerr=avg_err, fmt='none', c='k')
axs[i].set_ylabel('$b_Q$', fontsize=35, rotation=0, labelpad=25)
axs[i].legend(fontsize=20)
axs[i].tick_params(axis='both', which='major', labelsize=25)
#axs[i].set_title(refname, fontsize=20)
plt.xlabel(r'$\langle \Delta (g-i) \rangle$', fontsize=35)
plt.savefig('plots/rel_bias.pdf')
plt.close('all')
yerr=mag1sig,
linestyle='None',
color='grey',
linewidth=1,
zorder=2)
plt.axhline(y=np.median(mag1), color='k', ls=':')
xlowerlim1, xupperlim1, ylowerlim1, yupperlim1 = 56400, 57800, 17.0, 20.0
ax1.set_xlim([xlowerlim1, xupperlim1])
ax1.set_ylim([ylowerlim1, yupperlim1])
ax1.invert_yaxis()
plt.xlabel('Date (MJD)', fontsize=14)
plt.ylabel('R Magnitude', fontsize=14)
minorLocator = AutoMinorLocator()
minorLocator2 = AutoMinorLocator()
ax1.xaxis.set_minor_locator(minorLocator)
ax1.yaxis.set_minor_locator(minorLocator2)
# Shaded area to denote uncertainty of median (average of mag1sig)
ax1.add_patch(
patches.Rectangle(
(xlowerlim1, np.median(mag1) - 5 * np.average(mag1sig)), # (x, y)
xupperlim1 - xlowerlim1, # width
10 * np.average(mag1sig), # height
0.0, # angle
facecolor='lightgrey',
edgecolor='none',
zorder=1))
# Load the file
results1 = loadmat("../results/results3_1.mat")
print("results1:")
print(list(results1.keys()))
W1 = results1["W"]
error1 = 10 * np.log10(results1["errav"])
N1 = results1["ns"]
nw1 = results1["n"]
plt.figure(1)
plt.plot(np.arange(0, N1, 200), error1[::200, 0])
ax = plt.gca()
ax.set_xlim(left=0, right=N1)
ax.xaxis.set_minor_locator(AutoMinorLocator(n=5))
ax.grid(b=True, which="major", color="silver", linestyle="-")
ax.grid(b=True, which="minor", color="lightgray", linestyle="--")
ax.set_ylabel("Error (dB)")
ax.set_xlabel("Iteration")
ax.set_title("Error evolution for \(x_1\)")
ax.ticklabel_format(style="sci", axis="x", scilimits=(0, 0))
fname = f"ex3_x1_error"
plt.savefig("../results/" + fname + ".png", dpi=600, bbox_inches="tight")
plt.savefig("../report/figures/pdf/" + fname + ".pdf", bbox_inches="tight")
plt.close()
plt.figure(2)
for i in range(W1.shape[0]):
plt.plot(np.arange(0, N1 + 1, 200), W1[i, ::200], "-", linewidth=1)
ax = plt.gca()
Y_pred = reg.predict(X_poly)
print(reg.coef_)
print('Coefficient of determination: %.3f'
% r2_score(Y, Y_pred))
ax[0].plot(X, Y, linewidth=1, color="#008ae6")
ax[1].plot(X, Y, linewidth=1, color="#008ae6")
ax[0].plot(X, Y_pred, linewidth=1, color="#e60000")
ax[1].fill([0, *X, X.max()], [0, *Y, 0], color="#80ccff")
for i in range(2):
ax[i].set_ylabel('Стоимость (грн.)')
ax[i].set(xlim=(0, X.max()), ylim=(0, Y.max() * 1.25))
ticks, labels = get_ticks(dates)
ax[i].set_xticks(ticks=ticks, minor=False)
ax[i].set_xticklabels(labels=labels)
ax[i].tick_params(axis='x', which='major', labelsize = 10)
ax[i].yaxis.set_minor_locator(AutoMinorLocator())
ax[i].grid(axis='y', which='minor', color='#c7c7c7', linewidth=0.4)
ax[i].grid(axis='both', which='major', color='#a2a2a2', linewidth=0.75)
fig.set_figwidth(13)
fig.set_figheight(6)
plt.show()
#Patches
peak_patch = mpatches.Patch(color='red', label='Maximum Amplitude')
rms_patch = mpatches.Patch(color='navy', label='Mean')
plt.legend(handles=[peak_patch, rms_patch])
#For a scatter plot use this: ax.scatter(dates, highs, color = 'red', linewidth = 0.1, s=4)
ax.plot(dates, highs, color = 'red', linewidth = 0.5)
ax.xaxis.set_major_locator(hours)
ax.xaxis.set_major_formatter(h_fmt)
#ax.scatter(dates, rms, color = 'firebrick', linewidth = 0.1, s=4)
ax.plot(dates, rms, color = 'navy', linewidth = 0.5)
#minorlocator for quarter of an hour
minor_locator = AutoMinorLocator(8)
ax.xaxis.set_minor_locator(minor_locator)
plt.grid(which='minor', linestyle=':')
#Title,Label
plt.ylabel('noise level in dB', fontsize=12)
plt.title('Noise Level Protocol of ' + title_date, fontsize=15)
plt.grid(True)
#y axis
plt.ylim (
ymin = 20,
ymax = 80
)
#noise limit
def plot_map(pdata):
'''
Draw PC time series on the top, and
draw global map where dateline is on the center
'''
###--- Create a figure
fig = plt.figure()
fig.set_size_inches(6, 10) ## (xsize,ysize)
###--- Suptitle
fig.suptitle(pdata['suptit'],
fontsize=16,
y=0.97,
va='bottom',
stretch='semi-condensed')
###--- Axes setting
nk = len(pdata['tgt_nums']) # Number of data to show
left, right, top, bottom = 0.07, 0.93, 0.925, 0.1
npnx, gapx, npny, gapy = 1, 0.05, nk + 1, 0.064
lx = (right - left - gapx * (npnx - 1)) / npnx
ly = (top - bottom - gapy * (npny - 1)) / npny
ix, iy = left, top
###--- Top panel: PC time series
ax1 = fig.add_axes([ix, iy - ly, lx, ly])
colors = plt.cm.tab10(np.linspace(0.05, 0.95, 10))
for i, k in enumerate(pdata['tgt_nums']):
ax1.plot_date(pdata['mon_list'],
pdata['pc'][:, k],
fmt='-',
c=colors[i],
lw=2.5,
alpha=0.85,
label='PC{}'.format(k))
iy = iy - ly - gapy
subtit = '(a) '
ax1.set_title(subtit, fontsize=12, ha='left', x=0.0)
ax1.legend(bbox_to_anchor=(0.08, 1.02, .92, .10),
loc='lower left',
ncol=nk,
mode="expand",
borderaxespad=0.,
fontsize=10)
ax1.axhline(y=0., c='k', lw=0.8, ls='--')
ax1.grid(ls=':')
ax1.xaxis.set_major_formatter(DateFormatter('%b%Y'))
ax1.yaxis.set_minor_locator(AutoMinorLocator(2))
ax1.yaxis.set_ticks_position('both')
ax1.tick_params(axis='both', labelsize=10)
###--- Next, draw global maps
###--- Map Projection
center = 180 # Want to draw a map where dateline is on the center
proj = ccrs.PlateCarree(central_longitude=center)
data_crs = ccrs.PlateCarree()
map_extent = [0., 359.9, -61, 61] # Range to be shown
img_range = pdata['img_bound']
val_max = max(np.nanmin(pdata['ev_map']) * -1, np.nanmax(pdata['ev_map']))
val_min, val_max = val_max * -0.9, val_max * 0.9
abc = 'abcdefgh'
###--- Color map
cm = plt.cm.get_cmap('RdBu_r').copy()
cm.set_bad('0.9') # For the gridcell of NaN
props = dict(vmin=val_min,
vmax=val_max,
origin='lower',
extent=img_range,
cmap=cm,
transform=data_crs)
for i, (data, k) in enumerate(zip(pdata['ev_map'], pdata['tgt_nums'])):
ax2 = fig.add_axes([ix, iy - ly, lx, ly], projection=proj)
ax2.set_extent(map_extent, crs=data_crs)
map1 = ax2.imshow(data, **props)
subtit = '({}) EOF{}'.format(abc[i + 1], k)
vf.map_common(ax2,
subtit,
data_crs,
xloc=60,
yloc=20,
gl_lab_locator=[True, True, False, True])
iy = iy - ly - gapy
vf.draw_colorbar(fig,
ax2,
map1,
type='horizontal',
size='panel',
gap=0.06,
extend='both',
width=0.02)
##-- Seeing or Saving Pic --##
outfnm = pdata['out_fnm']
print(outfnm)
#fig.savefig(outfnm,dpi=100) # dpi: pixels per inch
fig.savefig(outfnm, dpi=150, bbox_inches='tight') # dpi: pixels per inch
# Defalut: facecolor='w', edgecolor='w', transparent=False
plt.show()
return
def pyorbit_getresults(config_in, sampler, plot_dictionary):
try:
use_tex = config_in['parameters']['use_tex']
except:
use_tex = True
if use_tex is False:
print(' LaTeX disabled')
if plot_dictionary['use_getdist']:
from getdist import plots, MCSamples
# plt.rc('font', **{'family': 'serif', 'serif': ['Computer Modern Roman']})
plt.rcParams["font.family"] = "Times New Roman"
plt.rc('text', usetex=use_tex)
sample_keyword = {
'multinest': ['multinest', 'MultiNest', 'multi'],
'polychord': ['polychord', 'PolyChord', 'polychrod', 'poly'],
'emcee': ['emcee', 'MCMC', 'Emcee']
}
if sampler in sample_keyword['emcee']:
dir_input = './' + config_in['output'] + '/emcee/'
dir_output = './' + config_in['output'] + '/emcee_plot/'
os.system('mkdir -p ' + dir_output)
mc, starting_point, population, prob, state, \
sampler_chain, sampler_lnprobability, sampler_acceptance_fraction, _ = \
emcee_load_from_cpickle(dir_input)
pars_input(config_in, mc, reload_emcee=True)
if hasattr(mc.emcee_parameters, 'version'):
emcee_version = mc.emcee_parameters['version'][0]
else:
import emcee
emcee_version = emcee.__version__[0]
mc.model_setup()
""" Required to create the right objects inside each class - if defined inside """
theta_dictionary = results_analysis.get_theta_dictionary(mc)
nburnin = int(mc.emcee_parameters['nburn'])
nthin = int(mc.emcee_parameters['thin'])
nsteps = int(sampler_chain.shape[1] * nthin)
flat_chain = emcee_flatchain(sampler_chain, nburnin, nthin)
flat_lnprob = emcee_flatlnprob(sampler_lnprobability, nburnin, nthin,
emcee_version)
flat_BiC = -2 * flat_lnprob + mc.ndim * np.log(mc.ndata)
lnprob_med = common.compute_value_sigma(flat_lnprob)
chain_med = common.compute_value_sigma(flat_chain)
chain_MAP, lnprob_MAP = common.pick_MAP_parameters(
flat_chain, flat_lnprob)
n_samplings, n_pams = np.shape(flat_chain)
print()
print('emcee version: ', emcee.__version__)
if mc.emcee_parameters['version'] == '2':
print('WARNING: upgrading to version 3 is strongly advised')
print()
print(' Reference Time Tref: {}'.format(mc.Tref))
print()
print(' Dimensions = {}'.format(mc.ndim))
print(' Nwalkers = {}'.format(mc.emcee_parameters['nwalkers']))
print()
print(' Steps: {}'.format(nsteps))
results_analysis.print_integrated_ACF(sampler_chain, theta_dictionary,
nthin)
if sampler in sample_keyword['multinest']:
plot_dictionary['lnprob_chain'] = False
plot_dictionary['chains'] = False
plot_dictionary['traces'] = False
dir_input = './' + config_in['output'] + '/multinest/'
dir_output = './' + config_in['output'] + '/multinest_plot/'
os.system('mkdir -p ' + dir_output)
mc = nested_sampling_load_from_cpickle(dir_input)
mc.model_setup()
mc.initialize_logchi2()
results_analysis.results_resumen(mc, None, skip_theta=True)
""" Required to create the right objects inside each class - if defined inside """
theta_dictionary = results_analysis.get_theta_dictionary(mc)
data_in = np.genfromtxt(dir_input + 'post_equal_weights.dat')
flat_lnprob = data_in[:, -1]
flat_chain = data_in[:, :-1]
# nsample = np.size(flat_lnprob)
n_samplings, n_pams = np.shape(flat_chain)
lnprob_med = common.compute_value_sigma(flat_lnprob)
chain_med = common.compute_value_sigma(flat_chain)
chain_MAP, lnprob_MAP = common.pick_MAP_parameters(
flat_chain, flat_lnprob)
print()
print(' Reference Time Tref: {}'.format(mc.Tref))
print()
print(' Dimensions: {}'.format(mc.ndim))
print()
print(' Samples: {}'.format(n_samplings))
if sampler in sample_keyword['polychord']:
plot_dictionary['lnprob_chain'] = False
plot_dictionary['chains'] = False
plot_dictionary['traces'] = False
dir_input = './' + config_in['output'] + '/polychord/'
dir_output = './' + config_in['output'] + '/polychord_plot/'
os.system('mkdir -p ' + dir_output)
mc = nested_sampling_load_from_cpickle(dir_input)
# pars_input(config_in, mc)
mc.model_setup()
mc.initialize_logchi2()
results_analysis.results_resumen(mc, None, skip_theta=True)
""" Required to create the right objects inside each class - if defined inside """
theta_dictionary = results_analysis.get_theta_dictionary(mc)
data_in = np.genfromtxt(dir_input + 'pyorbit_equal_weights.txt')
flat_lnprob = data_in[:, 1]
flat_chain = data_in[:, 2:]
# nsample = np.size(flat_lnprob)
n_samplings, n_pams = np.shape(flat_chain)
lnprob_med = common.compute_value_sigma(flat_lnprob)
chain_med = common.compute_value_sigma(flat_chain)
chain_MAP, lnprob_MAP = common.pick_MAP_parameters(
flat_chain, flat_lnprob)
print()
print(' Reference Time Tref: {}'.format(mc.Tref))
print()
print(' Dimensions: {}'.format(mc.ndim))
print()
print(' Samples: {}'.format(n_samplings))
print()
print(' LN posterior: {0:12f} {1:12f} {2:12f} (15-84 p) '.format(
lnprob_med[0], lnprob_med[2], lnprob_med[1]))
MAP_log_priors, MAP_log_likelihood = mc.log_priors_likelihood(chain_MAP)
BIC = -2.0 * MAP_log_likelihood + np.log(mc.ndata) * mc.ndim
AIC = -2.0 * MAP_log_likelihood + 2.0 * mc.ndim
AICc = AIC + (2.0 + 2.0 * mc.ndim) * mc.ndim / (mc.ndata - mc.ndim - 1.0)
# AICc for small sample
print()
print(' MAP log_priors = {}'.format(MAP_log_priors))
print(' MAP log_likelihood = {}'.format(MAP_log_likelihood))
print(' MAP BIC (using likelihood) = {}'.format(BIC))
print(' MAP AIC (using likelihood) = {}'.format(AIC))
print(' MAP AICc (using likelihood) = {}'.format(AICc))
MAP_log_posterior = MAP_log_likelihood + MAP_log_priors
BIC = -2.0 * MAP_log_posterior + np.log(mc.ndata) * mc.ndim
AIC = -2.0 * MAP_log_posterior + 2.0 * mc.ndim
AICc = AIC + (2.0 + 2.0 * mc.ndim) * mc.ndim / (mc.ndata - mc.ndim - 1.0)
print()
print(' MAP BIC (using posterior) = {}'.format(BIC))
print(' MAP AIC (using posterior) = {}'.format(AIC))
print(' MAP AICc (using posterior) = {}'.format(AICc))
if mc.ndata < 40 * mc.ndim:
print()
print(
' AICc suggested over AIC because NDATA ( {0:12f} ) < 40 * NDIM ( {1:12f} )'
.format(mc.ndata, mc.ndim))
else:
print()
print(
' AIC suggested over AICs because NDATA ( {0:12f} ) > 40 * NDIM ( {1:12f} )'
.format(mc.ndata, mc.ndim))
print()
print(
'****************************************************************************************************'
)
print(
'****************************************************************************************************'
)
print()
print(
' Confidence intervals (median value, 34.135th percentile from the median on the left and right side)'
)
planet_variables = results_analysis.results_resumen(mc,
flat_chain,
chain_med=chain_MAP,
return_samples=True)
print()
print(
'****************************************************************************************************'
)
print()
print(
' Parameters corresponding to the Maximum a Posteriori probability ( {} )'
.format(lnprob_MAP))
print()
results_analysis.results_resumen(mc, chain_MAP)
print()
print(
'****************************************************************************************************'
)
print()
# Computation of all the planetary variables
planet_variables_med = results_analysis.get_planet_variables(
mc, chain_med[:, 0])
star_variables = results_analysis.get_stellar_parameters(
mc, chain_med[:, 0])
planet_variables_MAP = results_analysis.get_planet_variables(mc, chain_MAP)
star_variables_MAP = results_analysis.get_stellar_parameters(mc, chain_MAP)
if plot_dictionary['lnprob_chain'] or plot_dictionary['chains']:
print(' Plot FLAT chain ')
if emcee_version == '2':
fig = plt.figure(figsize=(12, 12))
plt.xlabel('$\ln \mathcal{L}$')
plt.plot(sampler_lnprobability.T, '-', alpha=0.5)
plt.axhline(lnprob_med[0])
plt.axvline(nburnin / nthin, c='r')
plt.savefig(dir_output + 'LNprob_chain.png',
bbox_inches='tight',
dpi=300)
plt.close(fig)
else:
fig = plt.figure(figsize=(12, 12))
plt.xlabel('$\ln \mathcal{L}$')
plt.plot(sampler_lnprobability, '-', alpha=0.5)
plt.axhline(lnprob_med[0])
plt.axvline(nburnin / nthin, c='r')
plt.savefig(dir_output + 'LNprob_chain.png',
bbox_inches='tight',
dpi=300)
plt.close(fig)
print()
print(
'****************************************************************************************************'
)
print()
if plot_dictionary['full_correlation']:
corner_plot = {
'samples':
np.zeros(
[np.size(flat_chain, axis=0),
np.size(flat_chain, axis=1) + 1]),
'labels': [],
'truths': []
}
i_corner = 0
for var, var_dict in theta_dictionary.items():
corner_plot['samples'][:, i_corner] = flat_chain[:, var_dict]
corner_plot['labels'].append(re.sub('_', '-', var))
corner_plot['truths'].append(chain_med[var_dict, 0])
i_corner += 1
corner_plot['samples'][:, -1] = flat_lnprob[:]
corner_plot['labels'].append('ln-prob')
corner_plot['truths'].append(lnprob_med[0])
if plot_dictionary['use_getdist']:
print(' Plotting full_correlation plot with GetDist')
print()
print(' Ignore the no burn in error warning from getdist')
print(' since burn in has been already removed from the chains')
plt.rc('text', usetex=False)
samples = MCSamples(samples=corner_plot['samples'],
names=corner_plot['labels'],
labels=corner_plot['labels'])
g = plots.getSubplotPlotter()
g.settings.num_plot_contours = 6
g.triangle_plot(samples, filled=True)
g.export(dir_output + "all_internal_variables_corner_getdist.pdf")
print()
else:
# plotting mega-corner plot
print('Plotting full_correlation plot with Corner')
plt.rc('text', usetex=False)
fig = corner.corner(corner_plot['samples'],
labels=corner_plot['labels'],
truths=corner_plot['truths'])
fig.savefig(dir_output + "all_internal_variables_corner_dfm.pdf",
bbox_inches='tight',
dpi=300)
plt.close(fig)
plt.rc('text', usetex=use_tex)
print()
print(
'****************************************************************************************************'
)
print()
if plot_dictionary['chains']:
print(' Plotting the chains... ')
os.system('mkdir -p ' + dir_output + 'chains')
for theta_name, ii in theta_dictionary.items():
file_name = dir_output + 'chains/' + repr(
ii) + '_' + theta_name + '.png'
fig = plt.figure(figsize=(12, 12))
plt.plot(sampler_chain[:, :, ii].T, '-', alpha=0.5)
plt.axvline(nburnin / nthin, c='r')
plt.savefig(file_name, bbox_inches='tight', dpi=300)
plt.close(fig)
print()
print(
'****************************************************************************************************'
)
print()
if plot_dictionary['traces']:
print(' Plotting the Gelman-Rubin traces... ')
print()
"""
Gelman-Rubin traces are stored in the dedicated folder iniside the _plot folder
Note that the GR statistics is not robust because the wlakers are not independent
"""
os.system('mkdir -p ' + dir_output + 'gr_traces')
step_sampling = np.arange(nburnin / nthin,
nsteps / nthin,
1,
dtype=int)
for theta_name, th in theta_dictionary.items():
rhat = np.array([
GelmanRubin_v2(sampler_chain[:, :steps, th])
for steps in step_sampling
])
print(' Gelman-Rubin: {0:5d} {1:12f} {2:s} '.format(
th, rhat[-1], theta_name))
file_name = dir_output + 'gr_traces/v2_' + repr(
th) + '_' + theta_name + '.png'
fig = plt.figure(figsize=(12, 12))
plt.plot(step_sampling, rhat[:], '-', color='k')
plt.axhline(1.01, c='C0')
plt.savefig(file_name, bbox_inches='tight', dpi=300)
plt.close(fig)
print()
print(
'****************************************************************************************************'
)
print()
if plot_dictionary['common_corner']:
print(' Plotting the common models corner plots')
plt.rc('text', usetex=False)
for common_name, common_model in mc.common_models.items():
print(' Common model: ', common_name)
corner_plot = {
'var_list': [],
'samples': [],
'labels': [],
'truths': []
}
variable_values = common_model.convert(flat_chain)
variable_median = common_model.convert(chain_med[:, 0])
if len(variable_median) < 1.:
continue
"""
Check if the eccentricity and argument of pericenter were set as free parameters or fixed by simply
checking the size of their distribution
"""
for var in variable_values.keys():
if np.size(variable_values[var]) == 1:
variable_values[var] = variable_values[var] * np.ones(
n_samplings)
else:
corner_plot['var_list'].append(var)
corner_plot['samples'] = []
corner_plot['labels'] = []
corner_plot['truths'] = []
for var_i, var in enumerate(corner_plot['var_list']):
corner_plot['samples'].extend([variable_values[var]])
corner_plot['labels'].append(var)
corner_plot['truths'].append(variable_median[var])
""" Check if the semi-amplitude K is among the parameters that have been fitted.
If so, it computes the correpsing planetary mass with uncertainty """
fig = corner.corner(np.asarray(corner_plot['samples']).T,
labels=corner_plot['labels'],
truths=corner_plot['truths'])
fig.savefig(dir_output + common_name + "_corners.pdf",
bbox_inches='tight',
dpi=300)
plt.close(fig)
print()
print(
'****************************************************************************************************'
)
print()
if plot_dictionary['dataset_corner']:
print(' Dataset + models corner plots ')
print()
for dataset_name, dataset in mc.dataset_dict.items():
for model_name in dataset.models:
variable_values = dataset.convert(flat_chain)
variable_median = dataset.convert(chain_med[:, 0])
for common_ref in mc.models[model_name].common_ref:
variable_values.update(
mc.common_models[common_ref].convert(flat_chain))
variable_median.update(
mc.common_models[common_ref].convert(chain_med[:, 0]))
variable_values.update(mc.models[model_name].convert(
flat_chain, dataset_name))
variable_median.update(mc.models[model_name].convert(
chain_med[:, 0], dataset_name))
corner_plot['samples'] = []
corner_plot['labels'] = []
corner_plot['truths'] = []
for var_i, var in enumerate(variable_values):
if np.size(variable_values[var]) <= 1: continue
corner_plot['samples'].extend([variable_values[var]])
corner_plot['labels'].append(var)
corner_plot['truths'].append(variable_median[var])
fig = corner.corner(np.asarray(corner_plot['samples']).T,
labels=corner_plot['labels'],
truths=corner_plot['truths'])
fig.savefig(dir_output + dataset_name + '_' + model_name +
"_corners.pdf",
bbox_inches='tight',
dpi=300)
plt.close(fig)
print(' Dataset: ', dataset_name, ' model: ',
model_name, ' corner plot done ')
print()
print(
'****************************************************************************************************'
)
print()
if plot_dictionary['write_planet_samples']:
print(' Saving the planet variable samplings to files (with plots)')
samples_dir = dir_output + '/planet_samples/'
os.system('mkdir -p ' + samples_dir)
for common_ref, variable_values in planet_variables.items():
for variable_name, variable in variable_values.items():
rad_filename = samples_dir + common_ref + '_' + variable_name
fileout = open(rad_filename + '.dat', 'w')
for val in variable:
fileout.write('{0:f} \n'.format(val))
fileout.close()
fig = plt.figure(figsize=(10, 10))
plt.hist(variable, bins=50, color='C0', alpha=0.75, zorder=0)
perc0, perc1, perc2 = np.percentile(variable,
[15.865, 50, 84.135],
axis=0)
plt.axvline(planet_variables_med[common_ref][variable_name],
color='C1',
zorder=1,
label='Median-corresponding value')
plt.axvline(planet_variables_MAP[common_ref][variable_name],
color='C2',
zorder=1,
label='MAP-corresponding value')
plt.axvline(perc1,
color='C3',
zorder=2,
label='Median of the distribution')
plt.axvline(perc0,
color='C4',
zorder=2,
label='15.865th and 84.135th percentile')
plt.axvline(perc2, color='C4', zorder=2)
plt.xlabel(re.sub('_', '-', variable_name + '_' + common_ref))
plt.legend()
plt.ticklabel_format(useOffset=False)
plt.savefig(rad_filename + '.png',
bbox_inches='tight',
dpi=300)
plt.close(fig)
print()
print(
'****************************************************************************************************'
)
print()
if plot_dictionary['plot_models'] or plot_dictionary['write_models']:
print(' Computing the models for plot/data writing ')
bjd_plot = {'full': {'start': None, 'end': None, 'range': None}}
kinds = {}
P_minimum = 2.0 # this temporal range will be divided in 20 subsets
for key_name, key_val in planet_variables_med.items():
P_minimum = min(key_val.get('P', 2.0), P_minimum)
for dataset_name, dataset in mc.dataset_dict.items():
if dataset.kind in kinds.keys():
kinds[dataset.kind].extend([dataset_name])
else:
kinds[dataset.kind] = [dataset_name]
bjd_plot[dataset_name] = {
'start': np.amin(dataset.x),
'end': np.amax(dataset.x),
'range': np.amax(dataset.x) - np.amin(dataset.x),
}
if bjd_plot[dataset_name]['range'] < 0.1:
bjd_plot[dataset_name]['range'] = 0.1
bjd_plot[dataset_name][
'start'] -= bjd_plot[dataset_name]['range'] * 0.10
bjd_plot[dataset_name][
'end'] += bjd_plot[dataset_name]['range'] * 0.10
if dataset.kind == 'Phot':
step_size = np.min(bjd_plot[dataset_name]['range'] /
dataset.n / 10.)
else:
step_size = P_minimum / 20.
bjd_plot[dataset_name]['x_plot'] = \
np.arange(bjd_plot[dataset_name]['start'], bjd_plot[dataset_name]['end'], step_size)
if bjd_plot['full']['range']:
bjd_plot['full']['start'] = min(bjd_plot['full']['start'],
np.amin(dataset.x))
bjd_plot['full']['end'] = max(bjd_plot['full']['end'],
np.amax(dataset.x))
bjd_plot['full']['range'] = bjd_plot['full']['end'] - bjd_plot[
'full']['start']
else:
bjd_plot['full']['start'] = np.amin(dataset.x)
bjd_plot['full']['end'] = np.amax(dataset.x)
bjd_plot['full']['range'] = bjd_plot['full']['end'] - bjd_plot[
'full']['start']
bjd_plot['full']['start'] -= bjd_plot['full']['range'] * 0.10
bjd_plot['full']['end'] += bjd_plot['full']['range'] * 0.10
bjd_plot['full']['x_plot'] = np.arange(bjd_plot['full']['start'],
bjd_plot['full']['end'],
P_minimum / 20.)
for dataset_name, dataset in mc.dataset_dict.items():
if dataset.kind == 'RV':
bjd_plot[dataset_name] = bjd_plot['full']
bjd_plot['model_out'], bjd_plot[
'model_x'] = results_analysis.get_model(mc, chain_med[:, 0],
bjd_plot)
bjd_plot['MAP_model_out'], bjd_plot[
'MAP_model_x'] = results_analysis.get_model(
mc, chain_MAP, bjd_plot)
if plot_dictionary['plot_models']:
print(' Writing the plots ')
for kind_name, kind in kinds.items():
for dataset_name in kind:
try:
error_bars = np.sqrt(
mc.dataset_dict[dataset_name].e**2 +
bjd_plot['model_out'][dataset_name]['jitter']**2)
except ValueError:
error_bars = mc.dataset_dict[dataset_name].e
fig = plt.figure(figsize=(12, 12))
# Partially taken from here:
# http://www.sc.eso.org/~bdias/pycoffee/codes/20160407/gridspec_demo.html
gs = gridspec.GridSpec(2, 1, height_ratios=[3.0, 1.0])
# Also make sure the margins and spacing are apropriate
gs.update(left=0.3,
right=0.95,
bottom=0.08,
top=0.93,
wspace=0.15,
hspace=0.05)
ax_0 = plt.subplot(gs[0])
ax_1 = plt.subplot(gs[1], sharex=ax_0)
# Adding minor ticks only to x axis
minorLocator = AutoMinorLocator()
ax_0.xaxis.set_minor_locator(minorLocator)
ax_1.xaxis.set_minor_locator(minorLocator)
# Disabling the offset on top of the plot
ax_0.ticklabel_format(useOffset=False)
ax_1.ticklabel_format(useOffset=False)
ax_0.scatter(
mc.dataset_dict[dataset_name].x,
mc.dataset_dict[dataset_name].y -
bjd_plot['model_out'][dataset_name]['systematics'] -
bjd_plot['model_out'][dataset_name]
['time_independent'],
color='C0',
zorder=4,
s=16)
ax_0.errorbar(
mc.dataset_dict[dataset_name].x,
mc.dataset_dict[dataset_name].y -
bjd_plot['model_out'][dataset_name]['systematics'] -
bjd_plot['model_out'][dataset_name]
['time_independent'],
yerr=error_bars,
color='C0',
fmt='o',
ms=0,
zorder=3,
alpha=0.5)
ax_0.plot(bjd_plot[dataset_name]['x_plot'],
bjd_plot['model_x'][dataset_name]['complete'],
label='Median-corresponding model',
color='C1',
zorder=2)
ax_0.plot(
bjd_plot[dataset_name]['x_plot'],
bjd_plot['MAP_model_x'][dataset_name]['complete'],
label='MAP-corresponding model',
color='C2',
zorder=1)
ax_0.set_ylabel('Same as input data')
ax_0.legend()
ax_1.scatter(
mc.dataset_dict[dataset_name].x,
mc.dataset_dict[dataset_name].y -
bjd_plot['model_out'][dataset_name]['complete'],
color='C0',
zorder=4,
s=16)
ax_1.errorbar(
mc.dataset_dict[dataset_name].x,
mc.dataset_dict[dataset_name].y -
bjd_plot['model_out'][dataset_name]['complete'],
yerr=error_bars,
color='C0',
fmt='o',
ms=0,
zorder=3,
alpha=0.5)
ax_1.axhline(0.0, color='k', alpha=0.5, zorder=0)
ax_1.set_xlabel('Time [d] (offset as the input data)')
ax_1.set_ylabel('Residuals (wrt median model)')
plt.savefig(dir_output + 'model_' + kind_name + '_' +
dataset_name + '.png',
bbox_inches='tight',
dpi=300)
plt.close(fig)
if plot_dictionary['write_models']:
for prepend_keyword in ['', 'MAP_']:
print(' Writing the ', prepend_keyword, 'data files ')
plot_out_keyword = prepend_keyword + 'model_out'
plot_x_keyword = prepend_keyword + 'model_x'
file_keyword = prepend_keyword + 'model_files'
if prepend_keyword == '':
planet_vars = planet_variables_med
# star_vars = star_variables # leaving here, it could be useful for the future
chain_ref = chain_med[:, 0]
elif prepend_keyword == 'MAP_':
planet_vars = planet_variables_MAP
# star_vars = star_variables_MAP
chain_ref = chain_MAP
dir_models = dir_output + file_keyword + '/'
os.system('mkdir -p ' + dir_models)
for dataset_name, dataset in mc.dataset_dict.items():
for model_name in dataset.models:
if getattr(mc.models[model_name], 'systematic_model',
False):
continue
fileout = open(
dir_models + dataset_name + '_' + model_name +
'.dat', 'w')
phase = np.zeros(dataset.n)
tc_folded = np.zeros(dataset.n)
phase_plot = np.zeros(
np.size(bjd_plot[dataset_name]['x_plot']))
tc_folded_plot = np.zeros(
np.size(bjd_plot[dataset_name]['x_plot']))
for common_ref in mc.models[model_name].common_ref:
if common_ref in planet_vars:
if 'P' in planet_vars[common_ref]:
phase = (dataset.x0 /
planet_vars[common_ref]['P']) % 1
phase_plot = (
(bjd_plot[dataset_name]['x_plot'] -
mc.Tref) /
planet_vars[common_ref]['P']) % 1
if 'Tc' in planet_vars[common_ref]:
tc_folded = (dataset.x - planet_vars[common_ref]['Tc']
+ planet_vars[common_ref]['P'] / 2.) \
% planet_vars[common_ref]['P'] \
- planet_vars[common_ref]['P'] / 2.
tc_folded_plot = (bjd_plot[dataset_name]['x_plot'] - planet_vars[common_ref][
'Tc']
+ planet_vars[common_ref]['P'] / 2.) \
% planet_vars[common_ref]['P'] \
- planet_vars[common_ref]['P'] / 2.
else:
tc_folded = dataset.x0 % planet_vars[
common_ref]['P']
tc_folded_plot = (bjd_plot[dataset_name]['x_plot'] - mc.Tref) % \
planet_vars[common_ref]['P']
fileout.write(
'descriptor BJD Tc_folded pha val,+- sys mod full val_compare,+- res,+- jit \n'
)
try:
len(bjd_plot[plot_out_keyword][dataset_name]
[model_name])
except:
bjd_plot[plot_out_keyword][dataset_name][model_name] = \
bjd_plot[plot_out_keyword][dataset_name][model_name] * np.ones(dataset.n)
bjd_plot[plot_x_keyword][dataset_name][model_name] = \
bjd_plot[plot_x_keyword][dataset_name][model_name] * np.ones(dataset.n)
for x, tcf, pha, y, e, sys, mod, com, obs_mod, res, jit in zip(
dataset.x, tc_folded, phase, dataset.y,
dataset.e, bjd_plot[plot_out_keyword]
[dataset_name]['systematics'],
bjd_plot[plot_out_keyword][dataset_name]
[model_name], bjd_plot[plot_out_keyword]
[dataset_name]['complete'], dataset.y -
bjd_plot[plot_out_keyword][dataset_name]
['complete'] + bjd_plot[plot_out_keyword]
[dataset_name][model_name], dataset.y -
bjd_plot[plot_out_keyword][dataset_name]
['complete'], bjd_plot[plot_out_keyword]
[dataset_name]['jitter']):
fileout.write(
'{0:f} {1:f} {2:f} {3:f} {4:f} {5:f} {6:1f} {7:f} {8:f} {9:f} {10:f} {11:f} {12:f}'
'\n'.format(x, tcf, pha, y, e, sys, mod, com,
obs_mod, e, res, e, jit))
fileout.close()
if getattr(mc.models[model_name], 'systematic_model',
False):
continue
if getattr(mc.models[model_name], 'jitter_model',
False):
continue
fileout = open(
dir_models + dataset_name + '_' + model_name +
'_full.dat', 'w')
if model_name + '_std' in bjd_plot[plot_x_keyword][
dataset_name]:
fileout.write(
'descriptor BJD Tc_folded phase mod,+- \n')
for x, tfc, pha, mod, std in zip(
bjd_plot[dataset_name]['x_plot'],
tc_folded_plot, phase_plot,
bjd_plot[plot_x_keyword][dataset_name]
[model_name], bjd_plot[plot_x_keyword]
[dataset_name][model_name + '_std']):
fileout.write(
'{0:f} {1:f} {2:f} {3:f} {4:f} \n'.format(
x, tcf, pha, mod, std))
fileout.close()
else:
fileout.write(
'descriptor BJD Tc_folded phase mod \n')
for x, tcf, pha, mod in zip(
bjd_plot[dataset_name]['x_plot'],
tc_folded_plot, phase_plot,
bjd_plot[plot_x_keyword][dataset_name]
[model_name]):
fileout.write(
'{0:f} {1:f} {2:f} {3:f}\n'.format(
x, tcf, pha, mod))
fileout.close()
if getattr(mc.models[model_name], 'model_class',
False) == 'transit':
"""
Exceptional model writing to deal with under-sampled lightcurves, i.e. when folding the
the light curve from the model file is not good enough. Something similar is performed later
with the planetary RVs, but here we must keep into account the differences between datasets
due to limb darkening, exposure times, etc.
"""
variable_values = {}
for common_ref in mc.models[model_name].common_ref:
variable_values.update(
mc.common_models[common_ref].convert(
chain_ref))
variable_values.update(
mc.models[model_name].convert(
chain_ref, dataset_name))
fileout = open(
dir_models + dataset_name + '_' + model_name +
'_transit.dat', 'w')
x_range = np.arange(-variable_values['P'] / 2.,
variable_values['P'] / 2.,
0.01)
delta_T = variable_values['Tc'] - dataset.Tref
y_plot = mc.models[model_name].compute(
variable_values, dataset, x_range + delta_T)
fileout.write('descriptor Tc_folded mod \n')
for x, mod in zip(x_range, y_plot):
fileout.write('{0:f} {1:f} \n'.format(x, mod))
fileout.close()
fileout = open(dir_models + dataset_name + '_full.dat',
'w')
fileout.write('descriptor BJD mod \n')
for x, mod in zip(
bjd_plot[dataset_name]['x_plot'],
bjd_plot[plot_x_keyword][dataset_name]
['complete']):
fileout.write('{0:f} {1:f} \n'.format(x, mod))
fileout.close()
for model in planet_vars:
try:
RV_out = kepler_exo.kepler_RV_T0P(
bjd_plot['full']['x_plot'] - mc.Tref,
planet_vars[model]['f'], planet_vars[model]['P'],
planet_vars[model]['K'], planet_vars[model]['e'],
planet_vars[model]['o'])
fileout = open(
dir_models + 'RV_planet_' + model + '_kep.dat',
'w')
fileout.write('descriptor x_range m_kepler \n')
for x, y in zip(bjd_plot['full']['x_plot'], RV_out):
fileout.write('{0:f} {1:f} \n'.format(x, y))
fileout.close()
x_range = np.arange(-1.50, 1.50, 0.001)
RV_out = kepler_exo.kepler_RV_T0P(
x_range * planet_vars[model]['P'],
planet_vars[model]['f'], planet_vars[model]['P'],
planet_vars[model]['K'], planet_vars[model]['e'],
planet_vars[model]['o'])
fileout = open(
dir_models + 'RV_planet_' + model + '_pha.dat',
'w')
fileout.write('descriptor x_phase m_phase \n')
for x, y in zip(x_range, RV_out):
fileout.write('{0:f} {1:f} \n'.format(x, y))
fileout.close()
except:
pass
print()
print(
'****************************************************************************************************'
)
print()
if plot_dictionary['veuz_corner_files']:
print(' Writing Veusz-compatible files for personalized corner plots')
# Transit times are too lenghty for the 'tiny' corner plot, so we apply a reduction to their value
variable_with_offset = {}
veusz_dir = dir_output + '/Veuz_plot/'
if not os.path.exists(veusz_dir):
os.makedirs(veusz_dir)
all_variables_list = {}
for dataset_name, dataset in mc.dataset_dict.items():
variable_values = dataset.convert(flat_chain)
for variable_name, variable in variable_values.items():
all_variables_list[dataset_name + '_' +
variable_name] = variable
for model_name in dataset.models:
variable_values = mc.models[model_name].convert(
flat_chain, dataset_name)
for variable_name, variable in variable_values.items():
all_variables_list[dataset_name + '_' + model_name + '_' +
variable_name] = variable
for model_name, model in mc.common_models.items():
variable_values = model.convert(flat_chain)
for variable_name, variable in variable_values.items():
all_variables_list[model.common_ref + '_' +
variable_name] = variable
# Special treatment for transit time, since ti can be very long but yet very precise, making
# the axis of corner plot quite messy
if variable_name == 'Tc':
offset = np.median(variable)
variable_with_offset[model.common_ref + '_' +
variable_name] = offset
all_variables_list[model.common_ref + '_' +
variable_name] -= offset
for common_ref, variable_values in planet_variables.items():
for variable_name, variable in variable_values.items():
# Skipping the variables that have been already included in all_variables_list
if common_ref + '_' + variable_name in all_variables_list:
continue
all_variables_list[common_ref + '_' + variable_name] = variable
if variable_name == 'Tc':
offset = np.median(variable)
variable_with_offset[common_ref + '_' +
variable_name] = offset
all_variables_list[common_ref + '_' +
variable_name] -= offset
text_file = open(veusz_dir + "veusz_offsets.txt", "w")
for variable_name, offset_value in variable_with_offset.items():
text_file.write('{0:s} {1:16.9f}'.format(variable_name,
offset_value))
text_file.close()
n_int = len(all_variables_list)
output_plan = np.zeros([n_samplings, n_int], dtype=np.double)
output_names = []
for var_index, variable_name in enumerate(all_variables_list):
output_plan[:, var_index] = all_variables_list[variable_name]
output_names.extend([variable_name])
plot_truths = np.percentile(output_plan[:, :], [15.865, 50, 84.135],
axis=0)
n_bins = 30 + 1
h5f = h5py.File(veusz_dir + '_hist1d.hdf5', "w")
data_grp = h5f.create_group("hist1d")
data_lim = np.zeros([n_int, 2], dtype=np.double)
data_edg = np.zeros([n_int, n_bins], dtype=np.double)
data_skip = np.zeros(n_int, dtype=bool)
sigma_minus = plot_truths[1, :] - plot_truths[0, :]
sigma_plus = plot_truths[2, :] - plot_truths[1, :]
median_vals = plot_truths[1, :]
for ii in range(0, n_int):
if sigma_minus[ii] == 0. and sigma_plus[ii] == 0.:
data_skip[ii] = True
continue
sigma5_selection = (output_plan[:, ii] > median_vals[ii] - 5 * sigma_minus[ii]) & \
(output_plan[:, ii] < median_vals[ii] + 5 * sigma_plus[ii])
data_lim[ii, :] = [
np.amin(output_plan[sigma5_selection, ii]),
np.amax(output_plan[sigma5_selection, ii])
]
if data_lim[ii, 0] == data_lim[ii, 1]:
data_lim[ii, :] = [
np.amin(output_plan[:, ii]),
np.amax(output_plan[:, ii])
]
if data_lim[ii, 0] == data_lim[ii, 1]:
data_skip[ii] = True
continue
data_edg[ii, :] = np.linspace(data_lim[ii, 0], data_lim[ii, 1],
n_bins)
veusz_workaround_descriptor = 'descriptor'
veusz_workaround_values = ''
for ii in range(0, n_int):
if data_skip[ii]:
continue
x_data = output_plan[:, ii]
x_edges = data_edg[ii, :]
for jj in range(0, n_int):
if data_skip[jj]:
continue
y_data = output_plan[:, jj]
y_edges = data_edg[jj, :]
if ii != jj:
hist2d = np.histogram2d(x_data,
y_data,
bins=[x_edges, y_edges],
density=True)
hist1d_y = np.histogram(y_data, bins=y_edges, density=True)
Hflat = hist2d[0].flatten()
inds = np.argsort(Hflat)[::-1]
Hflat = Hflat[inds]
sm = np.cumsum(Hflat)
sm /= sm[-1]
x_edges_1d = (x_edges[1:] + x_edges[:-1]) / 2
y_edges_1d = (y_edges[1:] + y_edges[:-1]) / 2
h2d_out = np.zeros([n_bins, n_bins])
h2d_out[0, 1:] = x_edges_1d
h2d_out[1:, 0] = y_edges_1d
h2d_out[1:, 1:] = hist2d[0].T * 1. / np.amax(hist2d[0])
h2d_list = h2d_out.tolist()
h2d_list[0][0] = ''
csvfile = veusz_dir + '_hist2d___' + output_names[
ii] + '___' + output_names[jj] + '.csv'
with open(csvfile, "w") as output:
writer = csv.writer(output, lineterminator='\n')
writer.writerows(h2d_list)
hist1d = np.histogram(x_data, bins=x_edges)
hist1d_norm = hist1d[0] * 1. / n_samplings
x_edges_1d = (x_edges[1:] + x_edges[:-1]) / 2
data_grp.create_dataset(output_names[ii] + '_x',
data=x_edges_1d,
compression="gzip")
data_grp.create_dataset(output_names[ii] + '_y',
data=hist1d_norm,
compression="gzip")
# data_grp.create_dataset(output_names[ii]+'_val', data=median_vals[ii])
# data_grp.create_dataset(output_names[ii]+'_val_-', data=sigma_minus[ii])
# data_grp.create_dataset(output_names[ii]+'_val_+', data=sigma_plus[ii])
# data_grp.attrs[output_names[ii]+'_val'] = median_vals[ii]
veusz_workaround_descriptor += ' ' + output_names[ii] + ',+,-'
veusz_workaround_values += ' ' + repr(
median_vals[ii]) + ' ' + repr(sigma_plus[ii]) + ' ' + repr(
sigma_minus[ii])
text_file = open(veusz_dir + "veusz_median_sigmas.txt", "w")
text_file.write('%s \n' % veusz_workaround_descriptor)
text_file.write('%s \n' % veusz_workaround_values)
text_file.close()
print()
print(
'****************************************************************************************************'
)
print()
if len(Pi_chamber_vars) % nploty == 0:
nemptyplots = 0
else:
nemptyplots = nploty - len(Pi_chamber_vars) % nploty
emptyplots = np.arange(nploty - nemptyplots, nploty)
for empty in emptyplots:
axarr[nplotx-1, empty].axis('off')
#axes = plt.gca()
#axes.tick_params(direction='in')
for x in x_arr:
for y in y_arr:
#tics inside
axarr[x,y].tick_params(direction='in', which='both', top=1, right=1)
#minor tics
axarr[x,y].xaxis.set_minor_locator(AutoMinorLocator())
axarr[x,y].yaxis.set_minor_locator(AutoMinorLocator())
#labels and tics font size
for item in ([axarr[x,y].xaxis.label, axarr[x,y].yaxis.label] + axarr[x,y].get_xticklabels() + axarr[x,y].get_yticklabels()):
item.set_fontsize(8)
# subplot numbering
if y < nploty - nemptyplots or x < (nplotx - 1): #nonempty plots
# axarr[x,y].text(0.2, 0.875, labeldict[y + x*nploty], fontsize=8, transform=axarr[x,y].transAxes)
# rescale y range to the visible x range, note: overrides ylim!
var = Pi_chamber_vars[x*nploty + y]
if var in rescale_vars:
autoscale_y(axarr[x,y], margin=0.3)
# hide hrzntl tic labels
# if x*nploty + y < nplotx * nploty - nemptyplots - nploty:
def visualize_field(borefield):
"""
Plot the top view and 3D view of borehole positions.
Parameters
----------
borefield : list
List of boreholes in the bore field.
Returns
-------
fig : figure
Figure object (matplotlib).
"""
import matplotlib.pyplot as plt
from matplotlib.ticker import AutoMinorLocator
from mpl_toolkits.mplot3d import Axes3D
# -------------------------------------------------------------------------
# Initialize figure
# -------------------------------------------------------------------------
LW = 1.5 # Line width
bbox_props = dict(boxstyle="circle,pad=0.3", fc="white", ec="b", lw=LW)
plt.rc('figure', figsize=(160.0/25.4, 80.0*4.0/4.0/25.4))
fig = plt.figure()
# -------------------------------------------------------------------------
# Top view
# -------------------------------------------------------------------------
i = 0 # Initialize borehole index
ax0 = fig.add_subplot(121)
for borehole in borefield:
i += 1 # Increment borehole index
(x, y) = borehole.position() # Extract borehole position
# Add current borehole to the figure
ax0.plot(x, y, 'k.')
ax0.text(x, y, i, ha="center", va="center", size=9, bbox=bbox_props)
# Configure figure axes
ax0.set_xlabel('x (m)')
ax0.set_ylabel('y (m)')
ax0.set_title('Top view')
plt.axis('equal')
ax0.xaxis.set_minor_locator(AutoMinorLocator())
ax0.yaxis.set_minor_locator(AutoMinorLocator())
# -------------------------------------------------------------------------
# 3D view
# -------------------------------------------------------------------------
i = 0 # Initialize borehole index
ax1 = fig.add_subplot(122, projection='3d')
for borehole in borefield:
i += 1 # Increment borehole index
# Position of head of borehole
(x, y) = borehole.position()
# Position of bottom of borehole
x_H = x + borehole.H*np.sin(borehole.tilt)*np.cos(borehole.orientation)
y_H = y + borehole.H*np.sin(borehole.tilt)*np.sin(borehole.orientation)
z_H = borehole.D + borehole.H*np.cos(borehole.tilt)
# Add current borehole to the figure
ax1.plot(np.atleast_1d(x), np.atleast_1d(y), np.atleast_1d(borehole.D),
'ko')
ax1.plot(np.array([x, x_H]),
np.array([y, y_H]),
-np.array([borehole.D, z_H]), 'k-')
# Configure figure axes
ax1.set_xlabel('x (m)')
ax1.set_ylabel('y (m)')
ax1.set_zlabel('z (m)')
ax1.set_title('3D view')
plt.axis('equal')
ax1.xaxis.set_minor_locator(AutoMinorLocator())
ax1.yaxis.set_minor_locator(AutoMinorLocator())
ax1.zaxis.set_minor_locator(AutoMinorLocator())
plt.tight_layout(rect=[0, 0.0, 0.95, 1.0])
return fig
def run(args, graph, labels, train_idx, val_idx, test_idx, evaluator,
n_running):
evaluator_wrapper = lambda pred, labels: evaluator.eval({
"y_pred": pred,
"y_true": labels
})["rocauc"]
train_batch_size = (len(train_idx) + 9) // 10
# batch_size = len(train_idx)
train_sampler = MultiLayerNeighborSampler(
[32 for _ in range(args.n_layers)])
# sampler = MultiLayerFullNeighborSampler(args.n_layers)
train_dataloader = DataLoaderWrapper(
NodeDataLoader(
graph.cpu(),
train_idx.cpu(),
train_sampler,
batch_sampler=BatchSampler(len(train_idx),
batch_size=train_batch_size),
num_workers=10,
))
eval_sampler = MultiLayerNeighborSampler(
[100 for _ in range(args.n_layers)])
# sampler = MultiLayerFullNeighborSampler(args.n_layers)
eval_dataloader = DataLoaderWrapper(
NodeDataLoader(
graph.cpu(),
torch.cat([train_idx.cpu(),
val_idx.cpu(),
test_idx.cpu()]),
eval_sampler,
batch_sampler=BatchSampler(graph.number_of_nodes(),
batch_size=65536),
num_workers=10,
))
criterion = nn.BCEWithLogitsLoss()
model = gen_model(args).to(device)
optimizer = optim.AdamW(model.parameters(),
lr=args.lr,
weight_decay=args.wd)
lr_scheduler = optim.lr_scheduler.ReduceLROnPlateau(optimizer,
mode="max",
factor=0.75,
patience=50,
verbose=True)
total_time = 0
val_score, best_val_score, final_test_score = 0, 0, 0
train_scores, val_scores, test_scores = [], [], []
losses, train_losses, val_losses, test_losses = [], [], [], []
final_pred = None
for epoch in range(1, args.n_epochs + 1):
tic = time.time()
loss = train(args, model, train_dataloader, labels, train_idx,
criterion, optimizer, evaluator_wrapper)
toc = time.time()
total_time += toc - tic
if epoch == args.n_epochs or epoch % args.eval_every == 0 or epoch % args.log_every == 0:
train_score, val_score, test_score, train_loss, val_loss, test_loss, pred = evaluate(
args, model, eval_dataloader, labels, train_idx, val_idx,
test_idx, criterion, evaluator_wrapper)
if val_score > best_val_score:
best_val_score = val_score
final_test_score = test_score
final_pred = pred
if epoch % args.log_every == 0:
print(
f"Run: {n_running}/{args.n_runs}, Epoch: {epoch}/{args.n_epochs}, Average epoch time: {total_time / epoch:.2f}s"
)
print(
f"Loss: {loss:.4f}\n"
f"Train/Val/Test loss: {train_loss:.4f}/{val_loss:.4f}/{test_loss:.4f}\n"
f"Train/Val/Test/Best val/Final test score: {train_score:.4f}/{val_score:.4f}/{test_score:.4f}/{best_val_score:.4f}/{final_test_score:.4f}"
)
for l, e in zip(
[
train_scores, val_scores, test_scores, losses,
train_losses, val_losses, test_losses
],
[
train_score, val_score, test_score, loss, train_loss,
val_loss, test_loss
],
):
l.append(e)
lr_scheduler.step(val_score)
print("*" * 50)
print(
f"Best val score: {best_val_score}, Final test score: {final_test_score}"
)
print("*" * 50)
if args.plot:
fig = plt.figure(figsize=(24, 24))
ax = fig.gca()
ax.set_xticks(np.arange(0, args.n_epochs, 100))
ax.set_yticks(np.linspace(0, 1.0, 101))
ax.tick_params(labeltop=True, labelright=True)
for y, label in zip([train_scores, val_scores, test_scores],
["train score", "val score", "test score"]):
plt.plot(range(1, args.n_epochs + 1, args.log_every),
y,
label=label,
linewidth=1)
ax.xaxis.set_major_locator(MultipleLocator(100))
ax.xaxis.set_minor_locator(AutoMinorLocator(1))
ax.yaxis.set_major_locator(MultipleLocator(0.01))
ax.yaxis.set_minor_locator(AutoMinorLocator(2))
plt.grid(which="major", color="red", linestyle="dotted")
plt.grid(which="minor", color="orange", linestyle="dotted")
plt.legend()
plt.tight_layout()
plt.savefig(f"gat_score_{n_running}.png")
fig = plt.figure(figsize=(24, 24))
ax = fig.gca()
ax.set_xticks(np.arange(0, args.n_epochs, 100))
ax.tick_params(labeltop=True, labelright=True)
for y, label in zip([losses, train_losses, val_losses, test_losses],
["loss", "train loss", "val loss", "test loss"]):
plt.plot(range(1, args.n_epochs + 1, args.log_every),
y,
label=label,
linewidth=1)
ax.xaxis.set_major_locator(MultipleLocator(100))
ax.xaxis.set_minor_locator(AutoMinorLocator(1))
ax.yaxis.set_major_locator(MultipleLocator(0.1))
ax.yaxis.set_minor_locator(AutoMinorLocator(5))
plt.grid(which="major", color="red", linestyle="dotted")
plt.grid(which="minor", color="orange", linestyle="dotted")
plt.legend()
plt.tight_layout()
plt.savefig(f"gat_loss_{n_running}.png")
if args.save_pred:
os.makedirs("./output", exist_ok=True)
torch.save(F.softmax(final_pred, dim=1), f"./output/{n_running}.pt")
return best_val_score, final_test_score
def cal(self, vis, vis_mask, li, gi, fbl, rt, **kwargs):
"""Function that does the actual cal."""
unmasked_only = self.params['unmasked_only']
phs_only = self.params['phs_only']
save_gain = self.params['save_gain']
plot_gain = self.params['plot_gain']
phs_unit = self.params['phs_unit']
fig_prefix = self.params['fig_name']
rotate_xdate = self.params['rotate_xdate']
feed_no = self.params['feed_no']
order_bl = self.params['order_bl']
tag_output_iter = self.params['tag_output_iter']
iteration = self.iteration
num_mean = kwargs['num_mean']
inds = kwargs['inds'] # inds is the point before noise on
bls_plt = kwargs['bls_plt']
freq_plt = kwargs['freq_plt']
if rt.ps_first:
build_normal_file = kwargs['build_normal_file']
use_center_data = self.params['use_center_data']
ns_stable = self.params['ns_stable']
if np.prod(vis.shape) == 0 :
return
lfi, lbi = li # local freq and bl index
fi = gi[0] # freq idx for this cal
bl = tuple(fbl[1]) # bl for this cal
nt = vis.shape[0]
on_time = rt['ns_on'].attrs['on_time']
# off_time = rt['ns_on'].attrs['off_time']
period = rt['ns_on'].attrs['period']
# the calculated phase and amp will be at the ind just 1 before ns ON (i.e., at the ind of the last ns OFF)
valid_inds = []
phase = []
if not phs_only:
amp = []
ii_range = []
for ii, ind in enumerate(inds):
# drop the first and the last ind, as it may lead to exceptional vals
if (ind == inds[0] or ind == inds[-1]) and not rt.FRB_cal:
continue
lower = ind - num_mean
off_sec = np.ma.array(vis[lower:ind], mask=(~np.isfinite(vis[lower:ind]))&vis_mask[lower:ind])
if off_sec.count() == 0: # all are invalid values
continue
if unmasked_only and off_sec.count() < max(2, num_mean/2): # more valid sample to make stable
continue
valid = True
upper = ind + 1 + on_time
off_mean = np.ma.mean(off_sec)
if use_center_data:
if ind + 2 < upper - 1:
this_on = np.ma.masked_invalid(vis[ind+2:upper-1]) # all on signal
else:
continue
else:
this_on = np.ma.masked_invalid(vis[ind+1:upper]) # all on signal
# just to avoid the case of all invalid on values
if this_on.count() > 0:
on_mean = np.ma.mean(this_on) # mean for all valid on signals
else:
continue
diff = on_mean - off_mean
phs = np.angle(diff) # in radians
if not np.isfinite(phs):
valid = False
if not phs_only:
amp_ = np.abs(diff)
if not (np.isfinite(amp_) and amp_ > 1.0e-8): # amp_ should > 0
valid = False
if not valid:
continue
valid_inds.append(ind)
if save_gain:
rt['ns_cal_phase'].local_data[ii, lfi, lbi] = phs
phase.append( phs ) # in radians
if not phs_only:
if save_gain:
ii_range += [ii]
rt['ns_cal_amp'].local_data[ii, lfi, lbi] = amp_
amp.append( amp_ )
# not enough valid data to do the ns_cal
num_valid = len(valid_inds)
if (num_valid <= 3 and not rt.FRB_cal) or num_valid < 1:
print 'Only have %d valid points, mask all for fi = %d, bl = (%d, %d)...' % (num_valid, fbl[0], fbl[1][0], fbl[1][1])
vis_mask[:] = True # mask the vis as no ns_cal has done
return
phase = np.unwrap(phase) # unwrap 2pi discontinuity
if not phs_only:
if not rt.ps_first:
rt['ns_cal_amp'].local_data[ii_range, lfi, lbi] = rt['ns_cal_amp'].local_data[ii_range, lfi, lbi] / np.median(amp)
amp = np.array(amp) / np.median(amp) # normalize
# split valid_inds into consecutive chunks
intervals = [0] + (np.where(np.diff(valid_inds) > 5 * period)[0] + 1).tolist() + [num_valid]
itp_inds = []
itp_phase = []
if not phs_only:
itp_amp = []
for i in xrange(len(intervals) -1):
this_chunk = valid_inds[intervals[i]:intervals[i+1]]
if len(this_chunk) > 3:
itp_inds.append(this_chunk)
itp_phase.append(phase[intervals[i]:intervals[i+1]])
if not phs_only:
itp_amp.append(amp[intervals[i]:intervals[i+1]])
# if no such chunk, mask all the data
num_itp = len(itp_inds)
if num_itp == 0:
rt.interp_mask_count.append(1)
vis_mask[:] = True
else:
rt.interp_mask_count.append(0)
# get itp pairs
itp_pairs = []
for it in itp_inds:
# itp_pairs.append((max(0, it[0]-off_time), min(nt, it[-1]+period)))
itp_pairs.append((max(0, it[0]-5), min(nt, it[-1]+5))) # not to out interpolate two much, which may lead to very inaccurate values
# get mask pairs
mask_pairs = []
for i in xrange(num_itp):
if i == 0:
mask_pairs.append((0, itp_pairs[i][0]))
if i == num_itp - 1:
mask_pairs.append((itp_pairs[i][-1], nt))
else:
mask_pairs.append((itp_pairs[i][-1], itp_pairs[i+1][0]))
# set mask for inds in mask_pairs
for mp1, mp2 in mask_pairs:
vis_mask[mp1:mp2] = True
# interpolate for inds in itp_inds
all_phase = np.array([np.nan]*nt)
if rt.ps_first:
if rt.normal_index is not None:
normal_phs = None
normal_amp = None
interp_inds = np.array([])
new_amp = np.array([])
elif not ns_stable:
normal_phs = rt.normal_phs[lfi,lbi]
normal_amp = rt.normal_amp[lfi,lbi]
interp_inds = np.array([])
new_amp = np.array([])
else:
if build_normal_file:
rt.normal_phs[lfi, lbi] = rt['ns_cal_phase'].local_data[0, lfi, lbi]
rt.normal_amp[lfi, lbi] = rt['ns_cal_amp'].local_data[0, lfi, lbi]
normal_phs = rt.normal_phs[lfi,lbi]
normal_amp = rt.normal_amp[lfi,lbi]
interp_inds = np.array([])
new_amp = np.array([])
for this_inds, this_phase, (i1, i2) in zip(itp_inds, itp_phase, itp_pairs):
# no need to interpolate for auto-correlation
if bl[0] == bl[1]:
all_phase[i1:i2] = 0
if rt.ps_first:
interp_inds = np.concatenate([interp_inds, np.arange(i1,i2)])
if rt.normal_index>=i1 and rt.normal_index<i2 and rt.normal_index is not None:
normal_phs = 0
rt.normal_phs[lfi, lbi] = normal_phs
else:
f = InterpolatedUnivariateSpline(this_inds, this_phase)
this_itp_phs = f(np.arange(i1, i2))
# # make the interpolated values in the appropriate range
# this_itp_phs = np.where(this_itp_phs>np.pi, np.pi, this_itp_phs)
# this_itp_phs = np.where(this_itp_phs<-np.pi, np.pi, this_itp_phs)
all_phase[i1:i2] = this_itp_phs
# do phase cal for this range of inds
if rt.ps_first:
interp_inds = np.concatenate([interp_inds, np.arange(i1,i2)])
if rt.normal_index>=i1 and rt.normal_index<i2 and rt.normal_index is not None:
normal_phs = this_itp_phs[rt.normal_index - i1]
rt.normal_phs[lfi, lbi] = normal_phs
vis[i1:i2] = vis[i1:i2] * np.exp(-1.0J * this_itp_phs)
if rt.ps_first:
interp_inds = np.int64(interp_inds)
if normal_phs is None:
normal_phs = np.nan
warnings.warn('The transit point has been masked for fi = %d, bl = (%d, %d)... when calculating phase! Maybe the noise points are too sparse!'%(fbl[0], fbl[1][0], fbl[1][1]),TransitMasked)
vis[interp_inds] = vis[interp_inds]*np.exp(1.0J * normal_phs)
rt['ns_cal_phase'].local_data[ii_range, lfi, lbi] = rt['ns_cal_phase'].local_data[ii_range, lfi, lbi] - normal_phs
if not phs_only:
all_amp = np.array([np.nan]*nt)
for this_inds, this_amp, (i1, i2) in zip(itp_inds, itp_amp, itp_pairs):
f = InterpolatedUnivariateSpline(this_inds, this_amp)
this_itp_amp = f(np.arange(i1, i2))
all_amp[i1:i2] = this_itp_amp
# do amp cal for this range of inds
if rt.ps_first:
new_amp = np.concatenate([new_amp, this_itp_amp])
if rt.normal_index>=i1 and rt.normal_index<i2 and rt.normal_index is not None:
normal_amp = this_itp_amp[rt.normal_index - i1]
rt.normal_amp[lfi, lbi] = normal_amp
else:
vis[i1:i2] = vis[i1:i2] / this_itp_amp
if rt.ps_first:
if normal_amp is None:
normal_amp = np.nan
warnings.warn('The transit point has been masked for frequency %d baseline %d when calculating amplitude! Maybe the noise points are too sparse!'%(lfi,lbi),TransitMasked)
new_amp = new_amp / normal_amp
vis[interp_inds] = vis[interp_inds]/new_amp
rt['ns_cal_amp'].local_data[ii_range, lfi, lbi] = rt['ns_cal_amp'].local_data[ii_range, lfi, lbi] / normal_amp
if plot_gain and (bl in bls_plt and fi in freq_plt):
plt.figure()
if phs_only:
fig, ax = plt.subplots()
else:
fig, ax = plt.subplots(2, sharex=True)
ax_val = np.array([ (datetime.utcfromtimestamp(sec) + timedelta(hours=8)) for sec in rt['sec1970'][:] ])
xlabel = '%s' % ax_val[0].date()
ax_val = mdates.date2num(ax_val)
if order_bl and (bl[0] > bl[1]):
# negate phase as for the conj of vis
all_phase = np.where(np.isfinite(all_phase), -all_phase, np.nan)
phase = np.where(np.isfinite(phase), -phase, np.nan)
if phs_unit == 'degree': # default to radians
all_phase = np.degrees(all_phase)
phase = np.degrees(phase)
ylabel = r'$\Delta \phi$ / degree'
else:
ylabel = r'$\Delta \phi$ / radian'
if phs_only:
ax.plot(ax_val, all_phase)
ax.plot(ax_val[valid_inds], phase, 'ro')
ax1 = ax
else:
ax[0].plot(ax_val, all_amp)
ax[0].plot(ax_val[valid_inds], amp, 'ro')
ax[0].set_ylabel(r'$\Delta |g|$')
ax[1].plot(ax_val, all_phase)
ax[1].plot(ax_val[valid_inds], phase, 'ro')
ax1 = ax[1]
duration = (ax_val[-1] - ax_val[0])
dt = duration / nt
ext = max(0.05*duration, 5*dt)
# if phs_unit == 'degree': # default to radians
# ax1.set_ylim([-180, 180])
# ax1.set_yticks([-180, -120, -60, 0, 60, 120, 180])
# else:
# ax1.set_ylim([-np.pi, np.pi])
ax1.set_xlim([ax_val[0]-ext, ax_val[-1]+ext])
ax1.xaxis_date()
date_format = mdates.DateFormatter('%H:%M')
ax1.xaxis.set_major_formatter(date_format)
if rotate_xdate:
# set the x-axis tick labels to diagonal so it fits better
fig.autofmt_xdate()
else:
# reduce the number of tick locators
locator = MaxNLocator(nbins=6)
ax1.xaxis.set_major_locator(locator)
ax1.xaxis.set_minor_locator(AutoMinorLocator(2))
ax1.set_xlabel(xlabel)
ax1.set_ylabel(ylabel)
if feed_no:
pol = rt['bl_pol'].local_data[li[1]]
bl = tuple(rt['true_blorder'].local_data[li[1]])
if order_bl and (bl[0] > bl[1]):
bl = (bl[1], bl[0])
fig_name = '%s_%f_%d_%d_%s.png' % (fig_prefix, fbl[0], bl[0], bl[1], rt.pol_dict[pol])
else:
fig_name = '%s_%f_%d_%d.png' % (fig_prefix, fbl[0], fbl[1][0], fbl[1][1])
if tag_output_iter:
fig_name = output_path(fig_name, iteration=iteration)
else:
fig_name = output_path(fig_name)
plt.savefig(fig_name)
plt.close()
xlabel = 'Fraction' if iy == ny - 1 else ''
ylabel = 'Layers' if ix == 0 else ''
ax = fig.add_axes(this_position,
autoscalex_on=False,
autoscaley_on=False,
xscale='linear',
yscale='linear',
xlim=xRange,
ylim=yRange,
xlabel=xlabel,
ylabel=ylabel)
if iy < (ny - 1):
ax.set_xticklabels([])
if ix > 0:
ax.set_yticklabels([])
ax.xaxis.set_minor_locator(AutoMinorLocator())
x_layers = dt['numL']
layer_acc = numpy.zeros(nLayers_max)
for i in xrange(0, nSpeciesPlot):
if speciesPlot[i]['idx'][j] == None:
continue
print j, i, speciesPlot[i]['name']
y_layers = numpy.zeros(dt['nLayers'])
#y_layers[0] = dt['bin'][dt['div'][0], speciesPlot[i]['idx'][j]]/dt['N_S']
#y_layers[1:] = numpy.diff(dt['bin'][dt['div'], speciesPlot[i]['idx'][j]])/(dt['N_S'])
y_layers[0] = dt['bin'][dt['div'][0],
speciesPlot[i]['idx'][j]] / dt['N_in'][0]
y_layers[1:] = numpy.diff(
dt['bin'][dt['div'],
speciesPlot[i]['idx'][j]]) / (dt['N_in'][1:])
#y_layers = smooth(y_layers)
df4 = df4.assign(nrad=radval).loc[50].sort_values('nrad')
df4PMi = (df4.loc[df4['nrad'] <= (hmrad4[50]*2)])
df4PMo = (df4.loc[df4['nrad'] >= (hmrad4[50]*2)])
print (hmrad1[50], hmrad2[50], hmrad3[50], hmrad4[50])
#%% Plotting cumulative distribution of proper motion of stars located inside and outside of 2 x HMR for 4 snapshots
#
#from matplotlib.ticker import MaxNLocator
fnamelist =[d['fname1'],d['fname2'],d['fname3'],d['fname4']]
fig, ((ax1,ax2),(ax3,ax4)) = plt.subplots(nrows=2, ncols=2, figsize=(15.,15.))
plt.subplots_adjust(wspace=0.2)
x_minor_locator = AutoMinorLocator(2)
y_minor_locator = AutoMinorLocator(4)
legend =[]
for fname in fnamelist:
if fname[17] == 'X':
legendtitle = (r'N=1000, D=%s.%s, $\alpha_{vir}$=%s.%s, init_rad=%s pc, sim=%s' %(fname[7],fname[8],fname[22],fname[23],fname[12],fname[25:27]))
elif fname[17] == '5':
legendtitle = (r'N=500, D=%s.%s, $\alpha_{vir}$=%s.%s, init_rad=%s pc, sim=%s' %(fname[7],fname[8],fname[22],fname[23],fname[12],fname[25:27]))
elif fname[17] == '2':
legendtitle = (r'N=2000, D=%s.%s, $\alpha_{vir}$=%s.%s, init_rad=%s pc, sim=%s' %(fname[7],fname[8],fname[22],fname[23],fname[12],fname[25:27]))
elif fname[5:7] == '1r':
legendtitle = (r'D=1.6, $\alpha_{vir}$=0.3, init_rad=1 pc, sim=%s' %fname[25:27])
elif fname[5:7] == '2r':
ax2.scatter(All_read[j].loc[n].sort_values(velocity)[velocity], \
np.linspace(1/len(All_read[j].loc[n]), 1.0, len(All_read[j].loc[n])), s=0.5, \
label=(r'D=%s, $alpha_{vir}$=%s, $N_{sim}$=%s'%(\
fname[j][11:14], fname[j][15:18], fname[j][25:29])))
## chosing 2,000 stars at random
# ax2.scatter(np.sort(random.choice(All_read[j].loc[n, velocity], 2000)), \
# np.linspace(1/2000, 1.0, 2000), s=0.5, \
# label=(r'%s-velocity D=%s, $alpha_{vir}$=%s'%(velocity[0:2], \
# fname[j][11:14], fname[j][15:18])))
for ax in [ax1, ax2]:
ax.set_ylabel('Cumulative distribution', fontsize=10.)
ax.xaxis.set_minor_locator(AutoMinorLocator(2))
ax.yaxis.set_minor_locator(AutoMinorLocator(4))
ax.tick_params(which='both',
direction='in',
top=True,
right=True,
labelbottom=True)
ax.set_xlim(0.1, 10.)
ax.set_ylim(0., 1.03)
# ax.legend(loc='lower right', frameon=False, fontsize=8.)
ax.set_xscale('log')
ax.legend(title='Cluster age %s Myr'\
%(np.round(All_read[0].loc[n].iloc[0]['time'], decimals=1)),\
loc='upper left', frameon=False, fontsize=8.)
ax.set_xlabel('Proper motion [km/s]', fontsize=10.)
def plot_theory_curve():
npzfile = np.load("data_sec_dist_MuMinus_standardrock_Emin_10.0_Emax_10.0.npz")
ioniz_secondary_energy = npzfile['ioniz']
brems_secondary_energy = npzfile['brems']
photo_secondary_energy = npzfile['photo']
epair_secondary_energy = npzfile['epair']
all_secondary_energy = np.concatenate((
ioniz_secondary_energy,
brems_secondary_energy,
photo_secondary_energy,
epair_secondary_energy)
)
sum_hist = np.sum(all_secondary_energy)
print(sum_hist)
list_secondary_energies = [
ioniz_secondary_energy,
brems_secondary_energy,
photo_secondary_energy,
epair_secondary_energy,
all_secondary_energy
]
list_secondary_energies_label = [
'Ionization',
'Photonuclear',
'Bremsstrahlung',
'Pair Production',
'Sum'
]
statistics = npzfile['statistics'][0]
E_min_log = npzfile['E_min'][0]
E_max_log = npzfile['E_max'][0]
spectral_index = npzfile['spectral_index'][0]
distance = npzfile['distance'][0]
medium_name = npzfile['medium_name'][0]
particle_name = npzfile['particle_name'][0]
ecut = npzfile['ecut'][0]
vcut = npzfile['vcut'][0]
particle_def = pp.particle.MuMinusDef()
medium = pp.medium.StandardRock(1.0)
energy_cuts = pp.EnergyCutSettings(500, -1)
multiplier = 1.
lpm = False
shadow_effect = pp.parametrization.photonuclear.ShadowButkevichMikhailov()
add_pertubative = True
interpolation_def = pp.InterpolationDef()
interpolation_def.path_to_tables = "~/.local/share/PROPOSAL/tables"
ioniz = pp.parametrization.Ionization(
particle_def=particle_def,
medium=medium,
energy_cuts=energy_cuts,
multiplier=multiplier)
epair = pp.parametrization.pairproduction.EpairProductionRhoInterpolant(
particle_def=particle_def,
medium=medium,
energy_cuts=energy_cuts,
multiplier=multiplier,
lpm_effect=lpm,
interpolation_def=interpolation_def)
brems = pp.parametrization.bremsstrahlung.KelnerKokoulinPetrukhin(
particle_def=particle_def,
medium=medium,
energy_cuts=energy_cuts,
multiplier=multiplier,
lpm_effect=lpm)
photo = pp.parametrization.photonuclear.AbramowiczLevinLevyMaor97Interpolant(
particle_def=particle_def,
medium=medium,
energy_cuts=energy_cuts,
multiplier=multiplier,
shadow_effect=shadow_effect,
interpolation_def=interpolation_def)
photo2 = pp.parametrization.photonuclear.BezrukovBugaev(
particle_def=particle_def,
medium=medium,
energy_cuts=energy_cuts,
multiplier=multiplier,
add_pertubative=add_pertubative)
losses_params = [ioniz, epair, brems, photo2]
muon_energy = 10**10 # MeV
inch_to_cm = 2.54
golden_ratio = 1.61803
width = 29.7 # cm
num_bins = 100
v_bins = np.linspace(np.log10(500), np.log10(muon_energy), num_bins)
v_bins_log = np.logspace(np.log10(500./muon_energy), np.log10(1.), num_bins)
fig = plt.figure(figsize=(width / inch_to_cm, width / inch_to_cm / golden_ratio))
ax = fig.add_subplot(111)
for idx, secondary_list in enumerate(list_secondary_energies):
ax.hist(
secondary_list,
weights=np.ones(len(secondary_list))/sum_hist,
histtype='step',
log=True,
bins=v_bins,
label=list_secondary_energies_label[idx]
)
all_cross_sections = np.empty((len(losses_params), num_bins))
for idx, param in enumerate(losses_params):
all_cross_sections[idx] = np.array([param.differential_crosssection(muon_energy, v)*v for v in v_bins_log])
sum_cross_sections = np.sum(all_cross_sections, axis=0)
print(sum(all_cross_sections[np.isfinite(all_cross_sections)]))
print(sum(sum_cross_sections[np.isfinite(sum_cross_sections)]))
for cross_section in np.append(all_cross_sections, [sum_cross_sections], axis=0):
ax.plot(
v_bins,
cross_section/sum(sum_cross_sections[np.isfinite(sum_cross_sections)]),
drawstyle="steps-pre"
)
# ax.set_xscale("log")
minor_locator = AutoMinorLocator()
ax.xaxis.set_minor_locator(minor_locator)
ax.legend()
ax.set_xlabel(r'energy loss / log($E$/MeV)')
ax.set_ylabel(r'$N$')
ax.set_ylim(ymin=1e-8)
ax.set_yscale("log")
ax.legend()
fig.savefig("theory_curve.pdf")
def plot_data(data):
signal_format = 'hist' # 'line' for line above SM stack
# 'hist' for bar above SM stack
# None for signal as part of SM stack
Total_SM_label = False # for Total SM black line in plot and legend
plot_label = r'$H \rightarrow WW \rightarrow e\nu\mu\nu$'
signal_label = r'Signal ($m_H=125$ GeV)' # r''
# *******************
# general definitions (shouldn't need to change)
lumi_used = str(lumi*fraction)
signal = None
for s in samples.keys():
if s not in stack_order and s!='data': signal = s
for x_variable,hist in HWWHistograms.hist_dict.items():
h_bin_width = hist['bin_width']
h_num_bins = hist['num_bins']
h_xrange_min = hist['xrange_min']
h_log_y = hist['log_y']
h_y_label_x_position = hist['y_label_x_position']
h_legend_loc = hist['legend_loc']
h_log_top_margin = hist['log_top_margin'] # to decrease the separation between data and the top of the figure, remove a 0
h_linear_top_margin = hist['linear_top_margin'] # to decrease the separation between data and the top of the figure, pick a number closer to 1
bins = [h_xrange_min + x*h_bin_width for x in range(h_num_bins+1) ]
bin_centres = [h_xrange_min+h_bin_width/2 + x*h_bin_width for x in range(h_num_bins) ]
data_x,_ = np.histogram(data['data'][x_variable].values, bins=bins)
data_x_errors = np.sqrt(data_x)
signal_x = None
if signal_format=='line':
signal_x,_ = np.histogram(data[signal][x_variable].values,bins=bins,weights=data[signal].weight.values)
elif signal_format=='hist':
signal_x = data[signal][x_variable].values
signal_weights = data[signal].weight.values
signal_color = samples[signal]['color']
mc_x = []
mc_weights = []
mc_colors = []
mc_labels = []
mc_x_tot = np.zeros(len(bin_centres))
for s in stack_order:
mc_labels.append(s)
mc_x.append(data[s][x_variable].values)
mc_colors.append(samples[s]['color'])
mc_weights.append(data[s].weight.values)
mc_x_heights,_ = np.histogram(data[s][x_variable].values,bins=bins,weights=data[s].weight.values)
mc_x_tot = np.add(mc_x_tot, mc_x_heights)
mc_x_err = np.sqrt(mc_x_tot)
# *************
# Main plot
# *************
plt.clf()
plt.axes([0.1,0.3,0.85,0.65]) #(left, bottom, width, height)
main_axes = plt.gca()
main_axes.errorbar( x=bin_centres, y=data_x, yerr=data_x_errors, fmt='ko', label='Data')
mc_heights = main_axes.hist(mc_x,bins=bins,weights=mc_weights,stacked=True,color=mc_colors, label=mc_labels)
if Total_SM_label:
totalSM_handle, = main_axes.step(bins,np.insert(mc_x_tot,0,mc_x_tot[0]),color='black')
if signal_format=='line':
main_axes.step(bins,np.insert(signal_x,0,signal_x[0]),color=samples[signal]['color'], linestyle='--',
label=signal)
elif signal_format=='hist':
main_axes.hist(signal_x,bins=bins,bottom=mc_x_tot,weights=signal_weights,color=signal_color,label=signal)
main_axes.bar(bin_centres,2*mc_x_err,bottom=mc_x_tot-mc_x_err,alpha=0.5,color='none',hatch="////",
width=h_bin_width, label='Stat. Unc.')
main_axes.set_xlim(left=h_xrange_min,right=bins[-1])
main_axes.xaxis.set_minor_locator(AutoMinorLocator()) # separation of x axis minor ticks
main_axes.tick_params(which='both',direction='in',top=True,labeltop=False,labelbottom=False,right=True,labelright=False)
main_axes.set_ylabel(r'Events / '+str(h_bin_width)+r' GeV',fontname='sans-serif',horizontalalignment='right',y=1.0,fontsize=11)
if h_log_y:
main_axes.set_yscale('log')
smallest_contribution = mc_heights[0][0]
smallest_contribution.sort()
bottom = smallest_contribution[-2]
top = np.amax(data_x)*h_log_top_margin
main_axes.set_ylim(bottom=bottom,top=top)
main_axes.yaxis.set_major_formatter(CustomTicker())
locmin = LogLocator(base=10.0,subs=(0.1,0.2,0.3,0.4,0.5,0.6,0.7,0.8,0.9),numticks=12)
main_axes.yaxis.set_minor_locator(locmin)
else:
main_axes.set_ylim(bottom=0,top=(np.amax(data_x)+math.sqrt(np.amax(data_x)))*h_linear_top_margin)
main_axes.yaxis.set_minor_locator(AutoMinorLocator())
plt.text(0.05,0.97,'ATLAS',ha="left",va="top",family='sans-serif',transform=main_axes.transAxes,style='italic',weight='bold',fontsize=13)
plt.text(0.19,0.97,'Open Data',ha="left",va="top",family='sans-serif',transform=main_axes.transAxes,fontsize=13)
plt.text(0.05,0.9,'for education only',ha="left",va="top",family='sans-serif',transform=main_axes.transAxes,style='italic',fontsize=8)
plt.text(0.05,0.86,r'$\sqrt{s}=13\,\mathrm{TeV},\;\int L\,dt=$'+lumi_used+'$\,\mathrm{fb}^{-1}$',ha="left",va="top",family='sans-serif',transform=main_axes.transAxes)
plt.text(0.05,0.78,plot_label,ha="left",va="top",family='sans-serif',transform=main_axes.transAxes)
# Create new legend handles but use the colors from the existing ones
handles, labels = main_axes.get_legend_handles_labels()
if signal_format=='line':
handles[labels.index(signal)] = Line2D([], [], c=samples[signal]['color'], linestyle='dashed')
if Total_SM_label:
uncertainty_handle = mpatches.Patch(facecolor='none',hatch='////')
handles.append((totalSM_handle,uncertainty_handle))
labels.append('Total SM')
# specify order within legend
new_handles = [handles[labels.index('Data')]]
new_labels = ['Data']
for s in reversed(stack_order):
new_handles.append(handles[labels.index(s)])
new_labels.append(s)
if Total_SM_label:
new_handles.append(handles[labels.index('Total SM')])
new_labels.append('Total SM')
else:
new_handles.append(handles[labels.index('Stat. Unc.')])
new_labels.append('Stat. Unc.')
if signal is not None:
new_handles.append(handles[labels.index(signal)])
new_labels.append(signal_label)
main_axes.legend(handles=new_handles, labels=new_labels, frameon=False, loc=h_legend_loc)
# *************
# Data/MC ratio
# *************
plt.axes([0.1,0.1,0.85,0.2]) #(left, bottom, width, height)
ratio_axes = plt.gca()
ratio_axes.errorbar( x=bin_centres, y=data_x/mc_x_tot, yerr=data_x_errors/mc_x_tot, fmt='ko')
ratio_axes.bar(bin_centres,2*mc_x_err/mc_x_tot,bottom=1-mc_x_err/mc_x_tot,alpha=0.5,color='none',
hatch="////",width=h_bin_width)
ratio_axes.plot(bins,np.ones(len(bins)),color='k')
ratio_axes.set_xlim(left=h_xrange_min,right=bins[-1])
ratio_axes.xaxis.set_minor_locator(AutoMinorLocator()) # separation of x axis minor ticks
ratio_axes.xaxis.set_label_coords(0.9,-0.2) # (x,y) of x axis label # 0.2 down from x axis
ratio_axes.set_xlabel(labelfile.variable_labels[x_variable],fontname='sans-serif',fontsize=11)
ratio_axes.tick_params(which='both',direction='in',top=True,labeltop=False,right=True,labelright=False)
ratio_axes.set_ylim(bottom=0,top=2.5)
ratio_axes.set_yticks([0,1,2])
ratio_axes.yaxis.set_minor_locator(AutoMinorLocator())
if signal is not None:
ratio_axes.set_ylabel(r'Data/SM',fontname='sans-serif',x=1,fontsize=11)
else:
ratio_axes.set_ylabel(r'Data/MC',fontname='sans-serif',fontsize=11)
# Generic features for both plots
main_axes.yaxis.set_label_coords(h_y_label_x_position,1)
ratio_axes.yaxis.set_label_coords(h_y_label_x_position,0.5)
plt.savefig("HWW_"+x_variable+".pdf")
return signal_x,mc_x_tot
def get_plot(self, subplot=False, width=None, height=None, xmin=-6.,
xmax=6., yscale=1, colours=None, plot_total=True,
legend_on=True, num_columns=2, legend_frame_on=False,
legend_cutoff=3, xlabel='Energy (eV)', ylabel='Arb. units',
zero_to_efermi=True, dpi=400, fonts=None, plt=None,
style=None, no_base_style=False):
"""Get a :obj:`matplotlib.pyplot` object of the density of states.
Args:
subplot (:obj:`bool`, optional): Plot the density of states for
each element on separate subplots. Defaults to ``False``.
width (:obj:`float`, optional): The width of the plot.
height (:obj:`float`, optional): The height of the plot.
xmin (:obj:`float`, optional): The minimum energy on the x-axis.
xmax (:obj:`float`, optional): The maximum energy on the x-axis.
yscale (:obj:`float`, optional): Scaling factor for the y-axis.
colours (:obj:`dict`, optional): Use custom colours for specific
element and orbital combinations. Specified as a :obj:`dict` of
:obj:`dict` of the colours. For example::
{
'Sn': {'s': 'r', 'p': 'b'},
'O': {'s': '#000000'}
}
The colour can be a hex code, series of rgb value, or any other
format supported by matplotlib.
plot_total (:obj:`bool`, optional): Plot the total density of
states. Defaults to ``True``.
legend_on (:obj:`bool`, optional): Plot the graph legend. Defaults
to ``True``.
num_columns (:obj:`int`, optional): The number of columns in the
legend.
legend_frame_on (:obj:`bool`, optional): Plot a frame around the
graph legend. Defaults to ``False``.
legend_cutoff (:obj:`float`, optional): The cut-off (in % of the
maximum density of states within the plotting range) for an
elemental orbital to be labelled in the legend. This prevents
the legend from containing labels for orbitals that have very
little contribution in the plotting range.
xlabel (:obj:`str`, optional): Label/units for x-axis (i.e. energy)
ylabel (:obj:`str`, optional): Label/units for y-axis (i.e. DOS)
zero_to_efermi (:obj:`bool`, optional): Normalise the plot such
that the Fermi level is set as 0 eV.
dpi (:obj:`int`, optional): The dots-per-inch (pixel density) for
the image.
fonts (:obj:`list`, optional): Fonts to use in the plot. Can be a
a single font, specified as a :obj:`str`, or several fonts,
specified as a :obj:`list` of :obj:`str`.
plt (:obj:`matplotlib.pyplot`, optional): A
:obj:`matplotlib.pyplot` object to use for plotting.
style (:obj:`list`, :obj:`str`, or :obj:`dict`): Any matplotlib
style specifications, to be composed on top of Sumo base
style.
no_base_style (:obj:`bool`, optional): Prevent use of sumo base
style. This can make alternative styles behave more
predictably.
Returns:
:obj:`matplotlib.pyplot`: The density of states plot.
"""
plot_data = self.dos_plot_data(yscale=yscale, xmin=xmin, xmax=xmax,
colours=colours, plot_total=plot_total,
legend_cutoff=legend_cutoff,
subplot=subplot,
zero_to_efermi=zero_to_efermi)
if subplot:
nplots = len(plot_data['lines'])
plt = pretty_subplot(nplots, 1, width=width, height=height,
dpi=dpi, plt=plt)
else:
plt = pretty_plot(width=width, height=height, dpi=dpi, plt=plt)
mask = plot_data['mask']
energies = plot_data['energies'][mask]
fig = plt.gcf()
lines = plot_data['lines']
spins = [Spin.up] if len(lines[0][0]['dens']) == 1 else \
[Spin.up, Spin.down]
for i, line_set in enumerate(plot_data['lines']):
if subplot:
ax = fig.axes[i]
else:
ax = plt.gca()
for line, spin in itertools.product(line_set, spins):
if spin == Spin.up:
label = line['label']
densities = line['dens'][spin][mask]
elif spin == Spin.down:
label = ""
densities = -line['dens'][spin][mask]
ax.fill_between(energies, densities, lw=0,
facecolor=line['colour'],
alpha=line['alpha'])
ax.plot(energies, densities, label=label,
color=line['colour'])
ax.set_ylim(plot_data['ymin'], plot_data['ymax'])
ax.set_xlim(xmin, xmax)
ax.tick_params(axis='y', labelleft=False)
ax.yaxis.set_minor_locator(AutoMinorLocator(2))
ax.xaxis.set_minor_locator(AutoMinorLocator(2))
loc = 'upper right' if subplot else 'best'
ncol = 1 if subplot else num_columns
if legend_on:
ax.legend(loc=loc, frameon=legend_frame_on, ncol=ncol)
# no add axis labels and sort out ticks
if subplot:
ax.set_xlabel(xlabel)
fig.subplots_adjust(hspace=0)
plt.setp([a.get_xticklabels() for a in fig.axes[:-1]],
visible=False)
if 'axes.labelcolor' in matplotlib.rcParams:
ylabelcolor = matplotlib.rcParams['axes.labelcolor']
else:
ylabelcolor = None
fig.text(0.08, 0.5, ylabel, ha='left', color=ylabelcolor,
va='center', rotation='vertical', transform=ax.transAxes)
else:
ax.set_xlabel(xlabel)
ax.set_ylabel(ylabel)
return plt
def process(self, ts):
excl_auto = self.params['excl_auto']
plot_stats = self.params['plot_stats']
fig_prefix = self.params['fig_name']
rotate_xdate = self.params['rotate_xdate']
tag_output_iter = self.params['tag_output_iter']
ts.redistribute('baseline')
if ts.local_vis_mask.ndim == 3: # RawTimestream
if excl_auto:
bl = ts.local_bl
vis_mask = ts.local_vis_mask[:, :, bl[:, 0] != bl[:, 1]].copy()
else:
vis_mask = ts.local_vis_mask.copy()
nt, nf, lnb = vis_mask.shape
elif ts.local_vis_mask.ndim == 4: # Timestream
# suppose masks are the same for all 4 pols
if excl_auto:
bl = ts.local_bl
vis_mask = ts.local_vis_mask[:, :, 0, bl[:, 0] != bl[:, 1]].copy()
else:
vis_mask = ts.local_vis_mask[:, :, 0].copy()
nt, nf, lnb = vis_mask.shape
else:
raise RuntimeError('Incorrect vis_mask shape %s' % ts.local_vis_mask.shape)
# total number of bl
nb = mpiutil.allreduce(lnb, comm=ts.comm)
# un-mask ns-on positions
if 'ns_on' in ts.iterkeys():
vis_mask[ts['ns_on'][:]] = False
# statistics along time axis
time_mask = np.sum(vis_mask, axis=(1, 2)).reshape(-1, 1)
# gather local array to rank0
time_mask = mpiutil.gather_array(time_mask, axis=1, root=0, comm=ts.comm)
if mpiutil.rank0:
time_mask = np.sum(time_mask, axis=1)
# statistics along time axis
freq_mask = np.sum(vis_mask, axis=(0, 2)).reshape(-1, 1)
# gather local array to rank0
freq_mask = mpiutil.gather_array(freq_mask, axis=1, root=0, comm=ts.comm)
if mpiutil.rank0:
freq_mask = np.sum(freq_mask, axis=1)
if plot_stats and mpiutil.rank0:
time_fig_name = '%s_%s.png' % (fig_prefix, 'time')
if tag_output_iter:
time_fig_name = output_path(time_fig_name, iteration=self.iteration)
else:
time_fig_name = output_path(time_fig_name)
# plot time_mask
plt.figure()
fig, ax = plt.subplots()
x_vals = np.array([ datetime.fromtimestamp(s) for s in ts['sec1970'][:] ])
xlabel = '%s' % x_vals[0].date()
x_vals = mdates.date2num(x_vals)
ax.plot(x_vals, 100*time_mask/np.float(nf*nb))
ax.xaxis_date()
date_format = mdates.DateFormatter('%H:%M')
ax.xaxis.set_major_formatter(date_format)
if rotate_xdate:
# set the x-axis tick labels to diagonal so it fits better
fig.autofmt_xdate()
else:
# reduce the number of tick locators
locator = MaxNLocator(nbins=6)
ax.xaxis.set_major_locator(locator)
ax.xaxis.set_minor_locator(AutoMinorLocator(2))
ax.set_xlabel(xlabel)
ax.set_ylabel(r'RFI (%)')
plt.savefig(time_fig_name)
plt.close()
freq_fig_name = '%s_%s.png' % (fig_prefix, 'freq')
if tag_output_iter:
freq_fig_name = output_path(freq_fig_name, iteration=self.iteration)
else:
freq_fig_name = output_path(freq_fig_name)
# plot freq_mask
plt.figure()
plt.plot(ts.freq[:], 100*freq_mask/np.float(nt*nb))
plt.xlabel(r'$\nu$ / MHz')
plt.ylabel(r'RFI (%)')
plt.savefig(freq_fig_name)
plt.close()
return super(Stats, self).process(ts)
def corner_plot(self,
axes_options=dict(),
contourf_options=dict(),
figure=None,
axes=None,
bins_options=None,
credible_intervals=True,
fill_ci=True,
show_samples=False,
diagonal='cumul',
display_plot_coords=False,
labels=dict(),
bins=dict(),
filename=None,
saving_options=dict(),
align_xlabels=True,
align_ylabels=True,
cdf_levels=None,
weights=None,
rotation=0,
display_1sigma=False,
rcfile=None,
rcparams=dict()):
N = len(self.request)
# Definition of the figure and axes
if (figure == None) | (axes == None):
self._get_plot_config_scatter_plots(rcfile=rcfile,
rotation=rotation,
rcparams=rcparams)
width, lb, tr, wh_margin = self.scatter_plot_scaling()
fig, ax = plt.subplots(N, N, figsize=[width, width])
fig.subplots_adjust(left=lb,
bottom=lb,
right=tr,
top=tr,
wspace=wh_margin,
hspace=wh_margin)
else:
fig = figure
ax = axes
# Compute credible intervals
xhist, yhist, hist, hist_levels = self.get2dcontours(
cdf_levels=cdf_levels, weights=weights, **bins)
# How label are displayed
label_names = dict()
[label_names.update({a: a}) for a in self.request]
label_names.update(labels)
labels = self.request
# Range, major and minor ticks locators
ax_options = dict()
[ax_options.update({a: 4 * [None]}) for a in self.request]
ax_options.update(axes_options)
spectral_map = plt.get_cmap('Spectral')
alpha = [0.5, 0.9, 0.9, 0.9, 0.9]
s_list = [1, 5, 5, 5, 5]
dchi2_list = np.array([16, 9, 4, 1, 0])
colors = [
spectral_map(255.0 / 255.0),
spectral_map(170.0 / 255.0),
spectral_map(85.0 / 255.0),
spectral_map(0.0)
]
samples = self.sample.copy(deep=True)
samples['reject'] = 0
if cdf_levels == None:
contourf_opts = {
'colors': [(0.72, 0.72, 0.9003921568627451),
(0.36, 0.36, 0.7011764705882353),
(0.0, 0.0, 0.5019607843137255)],
'antialiased':
False
} # with blue shades
contourf_opts.update(contourf_options)
else:
if len(cdf_levels) <= 3:
contourf_opts = {
'colors': [(0.72, 0.72, 0.9003921568627451),
(0.36, 0.36, 0.7011764705882353),
(0.0, 0.0, 0.5019607843137255)],
'antialiased':
False
} # with blue shades
contourf_opts.update(contourf_options)
else:
contourf_opts = dict(contourf_options)
# Create subplots
for i in range(N):
for j in range(N):
if j > i:
ax[i][j].set_xlabel("")
ax[i][j].set_ylabel("")
ax[i][j].axes.get_xaxis().set_visible(False)
ax[i][j].axes.get_yaxis().set_visible(False)
ax[i][j].set_frame_on(False)
else:
ax[i][j].xaxis.set_minor_locator(AutoMinorLocator(2))
ax[i][j].yaxis.set_minor_locator(AutoMinorLocator(2))
ax[i][j].set_facecolor("none")
if i == N - 1:
ax[i][j].set_xlabel(rf"${label_names[labels[j]]}$",
labelpad=0)
ax[i][j].tick_params(axis='x', which='major', pad=2)
for tick in ax[i][j].get_xticklabels():
tick.set_rotation(rotation)
if rotation > 10:
tick.set_ha(
'right') # Pour la rotation de 30 deg
else:
ax[i][j].set_xlabel("")
ax[i][j].set_xticklabels([])
if j != N - 2:
ax[i][j].get_shared_x_axes().join(
ax[i][j], ax[i + 1][j])
if j == 0:
if i == 0:
ax[i][j].set_ylabel(rf"${label_names[labels[i]]}$")
else:
ax[i][j].set_ylabel(rf"${label_names[labels[i]]}$",
labelpad=0)
else:
ax[i][j].set_ylabel("")
if not i == j: ax[i][j].set_yticklabels([])
if (j <= i) and display_plot_coords:
ax[i][j].annotate(f"({i}, {j})", (0.05, 0.05),
xycoords='axes fraction',
c='k',
size=11,
weight=500,
ha="left",
va="bottom",
bbox=dict(boxstyle='square, pad=0',
fc='None',
ec='None'))
if not i == j:
if credible_intervals:
levels = np.concatenate([
hist_levels[i][j],
[hist[i][j].max() * (1 + 1e-6)]
])
if fill_ci:
ax[i][j].contourf(xhist[i][j], yhist[i][j],
hist[i][j].T, levels,
**contourf_opts)
else:
ax[i][j].contour(xhist[i][j], yhist[i][j],
hist[i][j].T, levels,
**contourf_opts)
if show_samples:
for id_dchi2 in range(len(dchi2_list) - 1):
cond = samples.reject == 1
samples.loc[cond, 'reject'] = 0
samples.loc[(
(samples.dchi2 < dchi2_list[id_dchi2 + 1])
| (samples.dchi2 >= dchi2_list[id_dchi2])),
'reject'] = 1
cond = samples.reject == 0
ax[i][j].scatter(
samples[cond][labels[j]].values,
samples[cond][labels[i]].values,
s=s_list[id_dchi2],
facecolors=colors[id_dchi2],
marker='o',
alpha=alpha[id_dchi2],
linewidths=0,
zorder=-100 + id_dchi2)
# Limits
if not ax_options[labels[j]][0] == None:
ax[i][j].set_xlim(ax_options[labels[j]][0][0],
ax_options[labels[j]][0][1])
if not ax_options[labels[i]][1] == None:
ax[i][j].set_ylim(ax_options[labels[i]][1][0],
ax_options[labels[i]][1][1])
# Ticks position and occurence
if not ax_options[labels[j]][2] == None:
ax[i][j].xaxis.set_major_locator(
MultipleLocator(ax_options[labels[j]][2][0]))
ax[i][j].xaxis.set_minor_locator(
AutoMinorLocator(ax_options[labels[j]][2][1]))
if not ax_options[labels[i]][3] == None:
ax[i][j].yaxis.set_major_locator(
MultipleLocator(ax_options[labels[i]][3][0]))
ax[i][j].yaxis.set_minor_locator(
AutoMinorLocator(ax_options[labels[i]][3][1]))
else:
if diagonal == 'chi2':
x = np.linspace(samples[labels[j]].min(),
samples[labels[j]].max(), 100)
xx = list()
yy = list()
for k in range(100 - 1):
mask = (samples[labels[j]] > x[k]) & (
samples[labels[j]] <= x[k + 1])
if mask.sum() > 0:
y = samples.loc[mask, 'dchi2']
xx.append(np.mean([x[k], x[k + 1]]))
yy.append(np.min(y))
ax[i][j].plot(xx, yy, ls='-', lw=1, c='k')
ax[i][i].yaxis.set_label_position("right")
ax[i][i].spines['left'].set_visible(False)
ax[i][i].spines['top'].set_visible(False)
ax[i][i].tick_params(which='both',
bottom=True,
top=False,
left=False,
right=True,
labelbottom=True,
labeltop=False,
labelleft=False,
labelright=True,
pad=2)
ax[i][i].set_ylabel(r"$\Delta\chi^2$")
ax[i][i].set_ylim(-0.4, 9)
ax[i][i].yaxis.set_major_locator(
MultipleLocator(2))
ax[i][i].yaxis.set_minor_locator(
AutoMinorLocator(4))
# Choose same ticks for a column
if i < N - 1:
ax[i][i].get_shared_x_axes().join(
ax[i][i], ax[i + 1][i])
elif diagonal == 'cumul':
cdf = self.cdf[labels[j]]
ax[i][i].plot(cdf[0], cdf[1], ls='-', lw=1, c='k')
if display_1sigma:
x = self.ci[labels[j]][1]
y = 0.1
xerr = np.array([[
x - self.ci[labels[j]][0],
self.ci[labels[j]][2] - x
]]).T
ax[i][i].errorbar(x,
y,
xerr=xerr,
marker='o',
ms=1,
lw=0.5,
capsize=0,
color='k')
ax[i][i].yaxis.set_label_position("right")
ax[i][i].spines['left'].set_visible(False)
ax[i][i].spines['top'].set_visible(False)
ax[i][i].tick_params(which='both',
bottom=True,
top=False,
left=False,
right=True,
labelbottom=True,
labeltop=False,
labelleft=False,
labelright=True,
pad=2)
ax[i][i].set_ylabel(r"CDF")
ax[i][i].set_ylim(0, 1.05)
ax[i][i].yaxis.set_major_locator(
MultipleLocator(0.2))
ax[i][i].yaxis.set_minor_locator(
AutoMinorLocator(4))
# Choose same ticks for a column
if i < N - 1:
ax[i][i].get_shared_x_axes().join(
ax[i][i], ax[i + 1][i])
# Limits
if not ax_options[labels[j]][0] == None:
ax[i][j].set_xlim(ax_options[labels[j]][0][0],
ax_options[labels[j]][0][1])
# Ticks position and occurence
if not ax_options[labels[j]][2] == None:
ax[i][j].xaxis.set_major_locator(
MultipleLocator(
ax_options[labels[j]][2][0]))
ax[i][j].xaxis.set_minor_locator(
AutoMinorLocator(
ax_options[labels[j]][2][1]))
if align_xlabels: fig.align_xlabels(ax[N - 1, :])
if align_ylabels: fig.align_ylabels(ax[:, 0])
if not filename == None:
opts = dict({
'transparent': False,
'bbox_inches': 'tight',
'dpi': 300,
'pad_inches': 0.01,
})
opts.update(saving_options)
fig.savefig(filename, **opts)
else:
return fig, ax
def make_1dplot_figure(bf):
fff = plt.figure(bf.title, figsize=bf.figsize)
rcParams['font.family'] = bf.fontfamily
rcParams['axes.linewidth'] = 0.5 # de-emphasize
#plt.xkcd() # ha!
# we can add in one summary boxplot per subj
if bf.boxplot_on:
ncol = 2
a, subpl = plt.subplots(bf.nsub,
ncol,
gridspec_kw={
'width_ratios': [12, 1],
'wspace': 0.05
},
sharey='row',
squeeze=True,
figsize=bf.figsize)
else:
ncol = 1
a, subpl = plt.subplots(bf.nsub, ncol, figsize=bf.figsize)
for i in range(bf.nsub):
ss = bf.all_subs[i]
ii = i + 1
# just relabel, need to account for different cases of what
# subpl is and what its shape is (if it even has a shape!
if bf.boxplot_on:
if bf.nsub > 1:
pp = subpl[i, 0]
else:
pp = subpl[0]
else:
if bf.nsub > 1:
pp = subpl[i]
else:
pp = subpl
# ----------------- Main plot: time series ---------------------
if bf.ncensor:
xoffset = 0.5 * bf.censor_width
for cc in range(bf.ncensor):
pp.add_patch(
matpat.Rectangle((bf.censor_arr[cc] - xoffset, ss.ylim[0]),
width=bf.censor_width,
height=(ss.ylim[1] - ss.ylim[0]),
facecolor=bf.censor_RGB,
lw=0,
edgecolor=None,
alpha=None))
if ss.censor_hline:
pp.axhline(y=ss.censor_hline,
c=laio.DEF_censor_hline_RGB,
ls=':',
lw=1)
if bf.see_xax:
pp.axhline(y=0, c='0.6', ls='-', lw=0.5)
#plt.axhline(y=0, c='0.5', ls=':', lw=0.75)
# the actual plot
sp = pp.plot(ss.x, ss.y, color=ss.color, lw=2)
pp.set_xlim(ss.xlim)
pp.set_ylim(ss.ylim)
pp.set_xlabel(ss.xlabel, fontsize=bf.fontsize)
pp.set_ylabel(ss.ylabel, fontsize=bf.fontsize)
# get ylabels aligned horizontally
pp.get_yaxis().set_label_coords(-0.1, 0.5)
print("++ Plotting: {}".format(ss.ylabel))
pp.xaxis.set_minor_locator(AutoMinorLocator(5))
pp.yaxis.set_minor_locator(AutoMinorLocator(2))
pp.tick_params(axis='both',
which='minor',
direction='in',
color='0.5',
bottom=True,
left=True,
right=True) #, top=True )
pp.tick_params(axis='both',
which='major',
direction='in',
color='0.5',
bottom=True,
left=True,
right=True) #, top=True )
pp.spines['bottom'].set_color('0.5')
pp.spines['top'].set_color('0.5')
pp.spines['left'].set_color('0.5')
pp.spines['right'].set_color('0.5')
# only show tick labels at very bottom
if i < bf.nsub - 1:
nlabs = len(pp.get_xticklabels())
pp.set_xticklabels([''] * nlabs)
if bf.title and not (i):
# cheating with title because tight layout doesn't know about
# suptitle
pp.set_title(bf.title, fontsize=bf.fontsize)
# ----------------- Optional plot: boxplot ---------------------
if bf.boxplot_on:
if bf.nsub > 1:
qq = subpl[i, 1]
else:
qq = subpl[1]
if ss.censor_hline:
qq.axhline(y=ss.censor_hline,
c=laio.DEF_censor_hline_RGB,
ls=':',
lw=1)
if bf.see_xax:
qq.axhline(y=0, c='0.6', ls='-', lw=0.5)
#plt.axhline(y=0, c='0.5', ls=':', lw=0.75)
# actual boxplot
sq = qq.boxplot(ss.y,
widths=0.1,
sym='.',
notch=0,
patch_artist=True)
# fun parameter-setting for boxplot
SETLW = 1.
MARKSIZE1 = 8
MARKSIZE2 = 5
flilines = sq['fliers']
for line in flilines:
line.set_color(ss.color)
line.set_markersize(MARKSIZE1)
medlines = sq['medians']
for line in medlines:
line.set_color('0.7')
line.set_linewidth(SETLW * 1.25)
boxlines = sq['boxes']
for line in boxlines:
line.set_color(ss.color)
plt.setp(sq['fliers'],
marker='.',
mew=0.3,
mec='k',
mfc=ss.color,
color=ss.color,
ms=MARKSIZE2)
plt.setp(sq['whiskers'], color=ss.color, linestyle='-', lw=SETLW)
plt.setp(sq['caps'], color=ss.color, linestyle='-', lw=SETLW)
# no xticks/labels
if 1:
qq.set_xticks([])
# stuff for y-axis ticks (on) and labels (off)
qq.yaxis.set_minor_locator(AutoMinorLocator(2))
qq.tick_params(axis='y',
which='minor',
direction='in',
color='0.5',
bottom=True,
left=True,
right=True) #, top=True )
qq.tick_params(axis='y',
which='major',
direction='in',
color='0.5',
bottom=True,
left=True,
right=True,
labelleft=False) #, top=True )
pp.spines['bottom'].set_color('0.5')
pp.spines['top'].set_color('0.5')
qq.spines['left'].set_color('0.5')
qq.spines['right'].set_color('0.5')
# finishing touches
if bf.layout == 'nospace':
fff.subplots_adjust(wspace=0.1, hspace=0.1)
#elif bf.layout == 'tight':
# plt.tight_layout()
plt.savefig(bf.fname,
dpi=bf.dpi,
facecolor=bf.bkgd_color,
bbox_inches='tight')
print("++ Done! Figure created:\n\t {}".format(bf.fname))
return 0
#Settings
#MarkEvery --
MarkEvery = [1, 5, 10, 17]
#TickSettings
DT = [600, 1800, 3600, 43200, 86400, 302400, "ByMonth"]
if DeltaT <= 7200:
DT = 600
elif DeltaT <= 21600:
DT = 1800
elif DeltaT <= 86400:
DT = 3600
elif DeltaT <= 172800:
DT = 7200
# Now Generate plots
L = AutoMinorLocator(4)
for i in CH:
plt.figure(figsize=(15, 8))
a = plt.plot(Time, Data[(i - 1)], 'bo', markersize=.01, markevery=5)
plt.axes().yaxis.set_minor_locator(L)
plt.grid(True)
plt.xlabel('Time')
plt.ylabel("Current (A)")
#plt.xticks(Locs,Ticks,rotation=30,size='small')
plt.ylim([9, 18])
#plt.xlim([WeekBefore,(T-43200)])
string = "Graph of Current vs Time for CH " + str(i)
plt.title(string)
name = "/home/pi/CH" + str(i) + ".png"
plt.savefig(name)
mag_2[mag_2['name'] == name].iloc[0, 2],
mag_2[mag_2['name'] == name].iloc[0, 1], 0.1, 1e51, 2, 800)
plt.plot(t,
1.24 * lm,
'orange',
label=r'Magnetar $M_{\rm ej}=2 M_{\odot}, B_{14}=19, P=116~ms$',
lw=2)
# plt.plot(t,valenti_bol(t,0.1,0))
ax.xaxis.set_ticks_position('both')
ax.yaxis.set_ticks_position('both')
ax.set_yscale("log")
ax.tick_params(direction='in', which='both')
# plt.gca().yaxis.set_minor_locator(AutoMinorLocator(5))
print np.max(lm)
ax.axhline(y=5.9e41, color='r', ls='--', lw=2)
plt.gca().xaxis.set_minor_locator(AutoMinorLocator(5))
plt.legend(frameon=False, fontsize=10)
plt.gca().set_xlim([-5, 150])
plt.gca().set_ylim([5e40, 3e42])
plt.xlabel(r'Time (days)', fontsize=20)
plt.ylabel(r'$ L_{\rm bol} \ (\rm \ erg \ s^{-1})$', fontsize=20)
# plt.hist(df_lfrac['lfac'].tolist(),bins=15, color='goldenrod', ec='none')
# ax.set_xlabel(r'$f$ ',fontsize=15)
# ax.set_ylabel('Count',fontsize=15)
#
# ax=f.add_subplot(gs[3,:])
# plt.hist(np.log10(lpeak_add_list),bins=15, color='gray', ec='none')
# ax.set_xlabel(r'Log $f L_{\rm p} \ (\rm erg \ s^{-1})$ ',fontsize=15)
# ax.set_ylabel('Count',fontsize=15)
# ax.set_ylim(0,6)
plt.tight_layout()
