def draw_go_pmid_histogram(go_cats, species, onto='all'):
xaxis = []
yaxis = []
for (pmid_list, avg) in go_cats:
xaxis.append(avg)
yaxis.append(len(pmid_list))
pylab.bar(xaxis, yaxis, align='center')
pylab.gcf().subplots_adjust(bottom=0.25)
pylab.xticks(xaxis, xaxis, rotation=90)
if onto.lower() == 'all':
pylab.title("Number of papers per GO Category across all GO subontologies")
elif onto.lower() == 'mf':
pylab.title("Number of papers per GO Category across GO Molecular Function")
elif onto.lower() == 'bp':
pylab.title("Number of papers per GO Category across GO Biological Process")
elif onto.lower() == 'cc':
pylab.title("Number of papers per GO Category across GO Cellular Component")
pylab.xlabel("Average number of GO terms")
pylab.ylabel('Number of PMIDs')
pylab.grid(True)
pylab.tight_layout()
pylab.savefig(os.path.join(CURR_PATH,"Cohesion/"+species+"/goPmid_"+species+"_"+onto+".png"))
pylab.close()
def draw(self, axes=None, loc=2):
if axes == None:
axes = p.gca()
if self.box != None and self.box in axes.artists:
del axes.artists[ axes.artists.index(self.box) ]
#key_areas = [ mpl.offsetbox.TextArea(k, textprops=self.textprops) for k in self.datadict.keys() ]
#val_areas = [ mpl.offsetbox.TextArea(self.datadict[k], textprops=self.textprops) for k in self.datadict.keys() ]
key_areas = [ mpl.offsetbox.TextArea(k, textprops=self.textprops) for k in list(self.datadict.keys()) ]
val_areas = [ mpl.offsetbox.TextArea(self.datadict[k], textprops=self.textprops) for k in list(self.datadict.keys()) ]
key_vpack = mpl.offsetbox.VPacker(children=key_areas, align="left", pad=0, sep=0)
val_vpack = mpl.offsetbox.VPacker(children=val_areas, align="right", pad=0, sep=0)
hpack = mpl.offsetbox.HPacker(children=[key_vpack, val_vpack], align="top", pad=0,sep=4)
globchildren = []
if self.title != None:
#titlearea = mpl.offsetbox.TextArea(self.title, textprops=self.titleprops)
titlearea = mpl.offsetbox.TextArea(self.title)
globchildren.append(titlearea)
globchildren.append(hpack)
globvpack = mpl.offsetbox.VPacker(children=globchildren, align="center", pad=0, sep=1)
self.box = mpl.offsetbox.AnchoredOffsetbox(loc=loc, child=globvpack)
self.box.patch.set_facecolor(self.facecolor)
self.box.patch.set_edgecolor(self.edgecolor)
self.box.patch.set_alpha(self.alpha)
axes.add_artist( self.box )
if p.isinteractive():
p.gcf().canvas.draw()
def trimmedReadLenHisto(readLenFileName, readLenHistoFileName):
f = open(readLenFileName)
title = f.readline()
data = f.readlines()
f.close()
title=title.strip('\n')
titlelist=title.split('\t')
column = -1
for b in range(0,len(titlelist)):
if titlelist[b] == 'trimLen':
column=b
if column == -1:
print "ERROR: trimmedReadLenHisto: %s doesn't contain a valid title" % readLenFileName
a = [float(i.strip().split('\t')[column]) for i in data]
# establish a dynamic X axis scale based on data size
mode = findMode(a)
graph_max_x = math.trunc(mode/100.0+0.5) * 100 + 100
if graph_max_x < 400:
graph_max_x = 400
pylab.clf()
pylab.gcf().set_size_inches((8.0,4.0))
pylab.gcf().set_size_inches((8,4))
pylab.hist(a, bins=graph_max_x, range=(0,graph_max_x),color='#2D4782',histtype='stepfilled')
pylab.title('Read Length Histogram')
pylab.xlabel('Read Length')
pylab.ylabel('Count')
pylab.savefig(readLenHistoFileName)
def hpSNR(metrics, charType):
for k, v in metrics.iteritems():
title = str(k)
e = v[charType].strip().split(",")
hp = []
snr = []
for i in e:
k = i.split(":")
key = k[0].strip()
value = k[1].strip()
hp.append(key)
snr.append(float(value))
pylab.clf()
pylab.xlabel("HP")
pylab.ylabel("SNR")
pylab.title("%s_%s" % (charType, title))
pylab.gcf().set_size_inches((8, 4))
xaxis = [i for i in range(len(hp))]
ymax = int(max(snr)) + 1
xlen = int(len(hp)) + 1
pylab.axis([0, xlen, 0, ymax])
pylab.xticks(range(len(hp)))
pylab.bar(xaxis, snr, width=0.5, linewidth=0, color="r", alpha=0.5, align="center")
# pylab.legend()
pylab.savefig(path.join(os.getcwd(), "%s_%s.png" % (charType, title)))
pylab.clf()
def plot_cumulative_boxes_scale(annotations, dataset_name):
# model_height = 128
object_height = 48 # the expected height of the pedestrian inside the detection box
boxes_scales = []
for filename, boxes in annotations:
for box in boxes:
height = box.max_corner.y - box.min_corner.y
scale = height / float(object_height)
boxes_scales.append(scale)
boxes_log_scales = [math.log(x)/math.log(2) for x in boxes_scales]
min_log_scale = int(round(min(boxes_log_scales)))
max_log_scale = int(round(max(boxes_log_scales)))
if True:
print("min/max scale in dataset %s == %.4f/%.4f" \
% (dataset_name, min(boxes_scales), max(boxes_scales)))
num_boxes_per_scale = pylab.zeros((max_log_scale - min_log_scale)+1)
log_scales_range = range(min_log_scale, max_log_scale+1)
for index, log_scale in enumerate(log_scales_range):
num_boxes_per_scale[index] = len([x for x in boxes_log_scales if round(x) >= log_scale])
if False:
# create a new figure
pylab.figure()
pylab.gcf().set_facecolor("w") # set white background
#scales_cumsum = pylab.cumsum(boxes_scales)
#pylab.plot(scales_cumsum)
pylab.hist(#boxes_scales,
boxes_log_scales,
bins=10,
#cumulative= True,
normed=True,
histtype = "stepfilled")
pylab.title("Cumulative histogram of the annotated windows scales\n Dataset: " + dataset_name)
pylab.xlabel("Annotated window scale octave")
pylab.ylabel("Percent of annotated windows")
# create a new figure
pylab.figure()
pylab.gcf().set_facecolor("w") # set white background
pylab.plot(log_scales_range, num_boxes_per_scale)
pylab.xlabel("Annotated window scale octave")
pylab.ylabel("Number of annotated windows")
pylab.title("Number of annotated windows per scale octave\n Dataset: " + dataset_name)
pylab.grid(True)
pylab.xticks(log_scales_range)
#pylab.yticks(yticks)
pylab.xlim([log_scales_range[0] - 0.5, log_scales_range[-1] + 0.5])
return
def show_barlines(page):
import pylab
for i, barlines in enumerate(page.barlines):
sd = page.staves.staff_dist[i]
for j, barline_range in enumerate(barlines):
barline_x = int(barline_range.mean())
staff_y = page.staves.staff_y(i, barline_x)
repeats = page.repeats[i][j]
if repeats:
# Draw thick bar
pylab.fill_between([barline_x - sd/4,
barline_x + sd/4],
staff_y - sd*2,
staff_y + sd*2,
color='g')
for letter, sign in (('L', -1), ('R', +1)):
if letter in repeats:
# Draw thin bar
bar_x = barline_x + sign * sd/2
pylab.plot([bar_x, bar_x],
[staff_y - sd*2,
staff_y + sd*2],
color='g')
for y in (-1, +1):
circ = pylab.Circle((bar_x + sign*sd/2,
staff_y + y*sd/2),
sd/4,
color='g')
pylab.gcf().gca().add_artist(circ)
else:
pylab.plot([barline_x, barline_x],
[staff_y - sd*2,
staff_y + sd*2],
color='g')
def testeps(d):
M.clf()
M.pcolor(d)
M.axis('tight')
M.colorbar()
M.gcf().set_size_inches((7.5,6.))
M.savefig('test.png',dpi=240)
def after_step(self, rbm, trainer, i):
it = i + 1
save = it in self.expt.save_after
display = it in self.expt.show_after
if save:
if self.expt.save_particles:
storage.dump(trainer.fantasy_particles, self.expt.pcd_particles_file(it))
storage.dump(rbm, self.expt.rbm_file(it))
if hasattr(trainer, 'avg_rbm'):
storage.dump(trainer.avg_rbm, self.expt.avg_rbm_file(it))
storage.dump(time.time() - self.t0, self.expt.time_file(it))
if 'particles' in self.subset and (save or display):
fig = rbm_vis.show_particles(rbm, trainer.fantasy_particles, self.expt.dataset, display=display,
figtitle='PCD particles ({} updates)'.format(it))
if display:
pylab.gcf().canvas.draw()
if save:
misc.save_image(fig, self.expt.pcd_particles_figure_file(it))
if 'gibbs_chains' in self.subset and (save or display):
fig = diagnostics.show_chains(rbm, trainer.fantasy_particles, self.expt.dataset, display=display,
figtitle='Gibbs chains (iteration {})'.format(it))
if save:
misc.save_image(fig, self.expt.gibbs_chains_figure_file(it))
if 'objective' in self.subset:
self.log_prob_tracker.update(rbm, trainer.fantasy_particles)
if display:
pylab.gcf().canvas.draw()
def p_h(data):
P.gcf().set_size_inches(10, 5)
x = np.arange(1, len(data[0]) + 1, 1)
for y in data:
P.plot(x, y)
P.ylabel("Number of heads - Number of tails")
P.xlabel("Number of coin tosses")
def plot_collinearity(motifs, best_Z):
"""Plot the cooccurrences of motifs.
"""
import scipy.cluster.hierarchy as hier
# from scipy.stats import pearsonr
M = len(motifs)
cooccurrences = numpy.ones((M, M))
for m1 in xrange(M):
for m2 in xrange(M):
# both = sum(numpy.logical_and(m1seqs, m2seqs))
# cooccurrences[m1,m2] = both/float(sum(m2seqs))
cooccurrences[m1, m2] = \
numpy.sqrt(sum(best_Z[m1] * best_Z[m2])) \
/ numpy.linalg.norm(best_Z[m2])
# rho, _ = pearsonr(best_Z[m1], best_Z[m2])
# cooccurrences[m1, m2] = rho
Y = hier.centroid(cooccurrences)
index = hier.fcluster(Y, -1) - 1
cooccurrences = cooccurrences[index, :]
cooccurrences = cooccurrences[:, index]
pylab.pcolor(cooccurrences)
pylab.colorbar()
ax = pylab.gca()
ax.set_xticks([])
# ax.set_xticks(.5 + numpy.arange(M))
# ax.set_xticklabels(motifs)
ax.set_yticks(.5 + numpy.arange(M))
ax.set_yticklabels(numpy.asarray(motifs)[index])
ax.set_xlim((0, M))
ax.set_ylim((0, M))
for line in ax.yaxis.get_ticklines():
line.set_markersize(0)
pylab.gcf().subplots_adjust(left=.27, bottom=.02, top=.98, right=.99)
def analyze_year():
fname = path + "/stretch/data_stretching_oneref_%s_%03d_5swin.npz"
k = 0
corrs = []
datess = []
stretchs = []
while k <= 60:
if not os.path.exists(fname % (station, k)):
k += 1
continue
print "k", k
npzfile = np.load(fname % (station, k))
corr, stretch, dates = npzfile["corr"], npzfile["stretch"], npzfile["dates"]
corr = corr[:, 1]
stretch = stretch[:, 1]
corrs.append(corr)
datess.append(dates)
stretchs.append(stretch)
k += 1
datess = np.hstack(datess)
corrs = np.hstack(corrs)
stretchs = np.hstack(stretchs)
stretchs = smooth2(stretchs, 48 * 3)
# stretchs, datess = smooth(stretchs, datess, 48)
plt.plot(datess, stretchs)
plt.gcf().autofmt_xdate()
xfmt = mpl.dates.DateFormatter("%y-%m-%d %H:%M")
plt.gca().xaxis.set_major_formatter(xfmt)
plt.savefig(path + "/plots/year_%s_TIQ_5swin.pdf" % station)
plt.show()
def plotDepth():
sns.set_style("whitegrid", {"grid.color": "1", 'axes.linewidth': .5, "grid.linewidth": ".09"})
sns.set_context("notebook", font_scale=1.4, rc={"lines.linewidth": 2.5})
d = pd.read_pickle(utl.outpath + 'real/CD.F59.df').xs('D', level='READ', axis=1)
(d.min(1) > 50).sum()
(d > 50).sum().sum()
z = pd.Series(np.ndarray.flatten(d.values))
fontsize = 6
mpl.rcParams.update({'font.size': fontsize})
plt.figure(figsize=(6, 4), dpi=300);
plt.subplot(2, 2, 1);
z.value_counts().sort_index().plot()
plt.xlim([0, 200]);
plt.xlabel('Depth');
plt.ylabel('Number of Measurments' + '\n (out of {:.1f}M)'.format(z.shape[0] / 1e6));
plt.ticklabel_format(axis='y', style='sci', scilimits=(0, 0))
plt.title('Scaled PDF')
pplt.annotate('(A)', xpad=0.85, ypad=0.45, fontsize=fontsize)
plt.axvline(50, linestyle='--', linewidth=1, color='k')
pplt.setSize(plt.gca(), fontsize)
plt.subplot(2, 2, 2);
z.value_counts().sort_index().cumsum().plot()
plt.xlim([0, 200])
plt.ylim([-3e5, 2.05 * 1e7])
plt.xlabel('Depth');
plt.title('Scaled CDF')
pplt.annotate('(B)', xpad=0.85, ypad=0.45, fontsize=fontsize)
plt.axvline(50, linestyle='--', linewidth=1, color='k')
pplt.setSize(plt.gca(), fontsize)
plt.subplot(2, 2, 3);
d.min(1).value_counts().sort_index().plot()
plt.xlim([0, 100]);
plt.xlabel('Minimum Depth of each Variant');
plt.ylabel('Number of Variants' + '\n (out of {:.1f}M)'.format(d.shape[0] / 1e6));
plt.ticklabel_format(axis='y', style='sci', scilimits=(0, 0))
plt.rc('font', size=fontsize)
pplt.annotate('(C)', xpad=0.85, ypad=0.45, fontsize=fontsize)
plt.axvline(50, linestyle='--', linewidth=1, color='k')
pplt.setSize(plt.gca(), fontsize)
plt.subplot(2, 2, 4);
d.min(1).value_counts().sort_index().cumsum().plot()
plt.xlim([0, 60])
plt.ylim([0.25 * -1e5, plt.ylim()[1]])
plt.xlabel('Minimum Depth of each Variant');
plt.ticklabel_format(axis='y', style='sci', scilimits=(0, 0))
pplt.annotate('(D)', xpad=0.85, ypad=0.45, fontsize=fontsize)
plt.axvline(50, linestyle='--', linewidth=1, color='k')
pplt.setSize(plt.gca(), fontsize)
plt.gcf().subplots_adjust(bottom=0.15)
plt.gcf().tight_layout(h_pad=0.1)
fontsize = 6
mpl.rc('font', **{'family': 'serif', 'serif': ['Computer Modern'], 'size': fontsize});
mpl.rc('text', usetex=True)
mpl.rcParams.update({'font.size': 1})
pplt.savefig('depth', 300)
plt.show()
def plotDepthHeterogenocity():
dpi = 300
sns.set_style("whitegrid", {"grid.color": "0.9", 'axes.linewidth': .5, "grid.linewidth": ".09"})
_, ax = plt.subplots(2, 2, sharex=True, figsize=(6, 4), dpi=dpi)
d = pd.read_pickle(utl.outpath + 'real/CD.F59.df').xs('D', level='READ', axis=1)
std = d.std(1)
loc = [std.idxmax(), (std == std.quantile(0.52)).replace({False: None}).dropna().index[0],
(std == std.median()).replace({False: None}).dropna().index[-1],
(std == std.quantile(0.8)).replace({False: None}).dropna().index[0]]
ax = ax.reshape(-1)
fontsize = 6
for i, pos in enumerate(loc):
eg = d.loc[pos]
[eg[r].dropna().plot(marker='o', ax=ax[i], markersize=5) for r in range(3)];
plt.xticks(d.columns.get_level_values('GEN').unique());
plt.xlabel('');
plt.ylabel('')
print 'position={}:{}'.format(eg.name[0], eg.name[1]), get_axis_limits()
if i in [0, 2]: ax[i].set_ylabel('Read Depth')
if i > 1: ax[i].set_xlabel('Generation')
if i == 0: ax[i].legend(['Replicate 1', 'Replicate 2', 'Replicate 3'], loc='upper center',
prop={'size': fontsize})
yrang = pplt.get_axis_limits(upper=True, ax=ax[i])[1] - pplt.get_axis_limits(upper=False, ax=ax[i])[1]
ax[i].set_ylim([min(0, ax[i].get_ylim()[0] - 0.05 * yrang), ax[i].get_ylim()[1] + 0.03 * yrang])
ax[i].set_xlim([-2, 61]);
ax[i].set_title('{}:{}'.format(eg.name[0], eg.name[1]))
pplt.setSize(ax[i], fontsize)
mpl.rc('font', **{'family': 'serif', 'serif': ['Computer Modern']});
mpl.rc('text', usetex=True)
plt.gcf().subplots_adjust(bottom=0.15)
pplt.savefig('depthHetero', dpi)
plt.show()
def plot_signal(t, u, fig_title='', file_name=''):
"""
Plot a signal.
Parameters
----------
t : ndarray of floats
Times (in s) at which the signal is defined.
u : ndarray of floats
Signal samples.
fig_title : string
Plot title.
file_name : string
File in which to save the plot.
"""
p.clf()
# Set the plot window title:
p.gcf().canvas.set_window_title(fig_title)
p.plot(t, u)
p.xlabel('t (s)')
p.ylabel('u(t)')
p.title(fig_title)
# Make the x axis exactly correspond to the plotted signal's time range:
p.gca().set_xlim(min(t), max(t))
p.draw_if_interactive()
if file_name:
p.savefig(file_name)
def demo_envelopes():
for i, demo in enumerate(demos):
try:
prev = subplot(len(demos), 1, i+1, sharex=prev, sharey=prev)
except NameError:
prev = subplot(len(demos), 1, i+1)
title(repr(demo).strip('{}').replace("'", ""))
prev.yaxis.set_visible(False)
prev.xaxis.set_visible(False)
# Generate carrier of appropriate length for the trial
#carrier = np.random.normal(size=demo['trial_dur']*fs)
carrier = np.random.uniform(low=-1, high=1, size=demo['trial_dur']*fs)
t, waveform, trial_trigs, set_trigs = generate_waveform(carrier, **demo)
#fill_between(t, waveform, -waveform)
plot(t, waveform, 'k')
for trig in set_trigs:
axvline(trig/fs, color='b', lw=5)
#for trig in trial_trigs:
# axvline(trig/fs, color='b', lw=2.5)
trig_times = np.true_divide(trial_trigs, fs)
plot(trig_times, np.ones(len(trig_times)), 'ro')
prev.xaxis.set_visible(True)
gcf().subplots_adjust(left=0.05, right=0.95, bottom=0.05, top=0.95,
hspace=0.5)
axis(xmin=-1, ymin=-1.1, ymax=1.1)
show()
def plotPowerCLR(recompute=False):
if recompute:
mc = pd.read_pickle('{}ROC/{}'.format(utl.outpath, 'MarkovChain'))
hmm = f(pd.read_pickle('{}ROC/{}'.format(utl.outpath, 'HMM')))
a = pd.concat([mc, hmm]);
print a
a = a[a.index.get_level_values('coverage') != np.inf]
df = pd.DataFrame(a.groupby(level=range(6)).apply(lambda x: x[x >= x.quantile(Qcoverage[x.name[0]])].mean()))[0]
# df = pd.DataFrame(a.groupby(level=range(6)).apply(lambda x: x[x >= x.quantile(0.99)].mean()))
df = getPower(df, groupbyLevels=range(4))
df.to_pickle(utl.outpath + 'ROC/PowerCLR.df')
else:
df = pd.read_pickle(utl.outpath + 'ROC/PowerCLR.df')
reload(pplt)
info = pplt.getNameColorMarker(df)
info.loc[info.index.get_level_values('method') == 'HMM', 'marker'] = '--o'
info.loc[info.index.get_level_values('method') == 'MarkovChain', 'marker'] = '--s'
info.loc[info.index.get_level_values('method') == 'HMM', 'color'] = 'r'
info.loc[info.index.get_level_values('method') == 'MarkovChain', 'color'] = 'darkblue'
# info.loc[info.index.get_level_values('q')==0.99,'color']='r'
# info.loc[info.index.get_level_values('q')==1,'color']='darkblue'
fig, axes = plt.subplots(2, 3, sharey=True, sharex=True, figsize=(6, 2.5), dpi=dpi);
pplt.setStyle(lw=1);
pplt.plotOnePower(df.xs(0.005, level='nu0'), info, axes[0], legendSubplot=0, ylabel='Hard');
pplt.plotOnePower(df.xs(0.1, level='nu0'), info, axes[1], ylabel='Soft');
[pplt.annotate('({})'.format(list('ABCDEF')[j]), ax=x, fontsize=7) for j, x in enumerate(axes.reshape(-1))]
plt.gcf().subplots_adjust(bottom=0.15)
pplt.savefig('powerCLR', dpi=dpi)
plt.show()
def plot_figure(list, dates, brand):
# Here is for zero padding
y = []
#pre_key = sorted(list)[0][0]
#for key, value in sorted(list):
# num_zero = key - pre_key
# if num_zero >1 and num_zero <= 30:
# for i in xrange(1, num_zero):
# y.append(0)
# pre_key = key
# y.append(value)
#x = np.arange(0,len(y),1)
x = [dt.datetime.strptime(d,'%m/%d/%Y').date() for d in dates]
x = sorted(x)
for key, value in sorted(list):
y.append(value)
pl.gca().xaxis.set_major_formatter(mdates.DateFormatter('%m/%d/%Y'))
pl.gca().xaxis.set_major_locator(mdates.DayLocator(interval=4))
pl.plot(x,y)
pl.title("Total Metioned Posts Per Day: " + brand)
pl.ylabel("Number of Posts")
pl.gcf().autofmt_xdate()
pl.show()
def timeplot(*args,**kwargs):
import matplotlib.pyplot as plt
import matplotlib.ticker
def HMSFormatter(value, loc):
h = value // 3600
m = (value - h * 3600) // 60
s = value % 60
return "%02d:%02d:%02d" % (h,m,s)
def HMSFormatter2(value, loc):
h = value // 3600
m = (value - h * 3600) // 60
s = value % 60
ms=value%1
return "%02d:%02d.%03d" % (m,s,ms*1000)
t=args[0]
if max(t)<10: # use ms
gca().xaxis.set_major_formatter(matplotlib.ticker.FuncFormatter(HMSFormatter2))
else:
gca().xaxis.set_major_formatter(matplotlib.ticker.FuncFormatter(HMSFormatter))
plot(*args,**kwargs)
gcf().autofmt_xdate()
def plotBottleneck(maxGen=None,obs=False,mean=True,color='blue'):
exit()
def plotOne(df, ax, method):
m=df.mean(1)
s=df.std(1)
# plt.locator_params(nbins=4);
m.plot(ax=ax, legend=False, linewidth=3, color=color)
x=m.index.values
m=m.values;s=s.values
ax.fill_between(x, m - 2 * s, m + 2 * s, color=color, alpha=0.3)
ax.set_ylabel(method.strip())
ax.set_ylim([-0.1, ax.get_ylim()[1]])
pplt.setSize(ax)
dfn = \
pd.read_pickle(path + 'nu{}.s{}.df'.format(0.005, 0.0))
fig, ax = plt.subplots(3, 1, sharex=True, figsize=(4, 3), dpi=300)
plotOne(dfn['tajimaD'], ax[0], "Tajima's $D$");
plt.xlabel('Generations')
plotOne(dfn['HAF'], ax[1], "Fay Wu's $H$");
plt.xlabel('Generations')
plotOne(dfn['SFSelect'], ax[2], 'SFSelect');
plt.xlabel('Generations')
plt.gcf().subplots_adjust(bottom=0.25)
mpl.rc('font', **{'family': 'serif', 'serif': ['Computer Modern']});
mpl.rc('text', usetex=True)
pplt.savefig('bottleneck', 300)
plt.show()
def plotScalingFactor():
r=2*1e-8
l = 5e4
dpi = 300
j = 0
for nu0 in [0.005, 0.1]:
for s in [0.025, 0.1]:
t = np.arange(0, 2 * (utl.logit(0.995) - utl.logit(nu0)) / s + 1., 1)
fig, ax = plt.subplots(2, 1, figsize=(5.5, 2.5), dpi=dpi, sharex=True);
nu(t, s=s, nu0=nu0).plot(color='k', legend=False, ax=ax[0])
pplt.annotate(r'$s$={}, $\nu_0=${} ({} Sweep)'.format(s, nu0, ('Soft', 'Hard')[nu0 == 0.005]), fontsize=7,
ax=ax[0])
pplt.setSize(ax=ax[0], fontsize=6)
ax[0].set_ylabel(r'$\nu_t$')
#
H0 = H(t[0], s=s, nu0=nu0)
Ht = H(t, s=s, nu0=nu0)
df = pd.DataFrame([np.log(Ht / H0), -2 * r * t * l], columns=t, index=['log(Growth)', r'log(Decay)']).T
df['log(Growth) + log(Decay)'] = df.sum(1)
df.plot(ax=ax[1], grid=True, linewidth=2);
ax[1].set_xlabel('Generations');
ax[1].set_ylabel('Log(Scaling Factor)')
ax[1].axvline(df.iloc[1:, 2].abs().idxmin(), color='k', linestyle='--', linewidth=0.5)
# if j != 3:
# ax[1].legend_.remove()
# else:
ax[1].legend(['log(Growth)', r'log(Decay)', 'log(Growth) + log(Decay)'], bbox_to_anchor=(1.45, .75),
prop={'size': 6})
pplt.setSize(ax[1], fontsize=6)
plt.tight_layout(pad=0.1, rect=[0, 0, 0.7, 1])
plt.gcf().subplots_adjust(bottom=0.15)
pplt.savefig('decayFactors{}'.format(j), dpi=dpi)
j += 1
def show_profile(var='d',func=None,log=True,col=None):
# pick variable
if func: data_y = func(data)
else: data_y = data[var]
# pick colour
if col == None: color = color_list[var]
elif col <= 0: color = color_palette(abs(col))
else: color = col
# pick axes
print "axes = ", pylab.gcf().axes
if pylab.gcf().axes != []:
plot = pylab.gcf().axes[0]
else:
plot = pylab.axes()
#plot.set_xlabel(legend["r"])
plot.set_xlabel("r, pc")
if not func: plot.set_ylabel(legend[var])
# plot
rpc = data.points * output.info['unit_length'].express(C.pc)
if log: plot.semilogy(rpc,data_y,color=color)
else: plot.plot( rpc,data_y,color=color)
print max(rpc[-1])
pylab.xlim([0, 8])
pylab.gcf().canvas.draw()
return data_y
def plotNumVariants(depth):
plt.figure(figsize=(7, 5), dpi=300)
depth.apply(lambda x: x.dropna().size / 1000.0).unstack("POP").plot.bar(ax=plt.gca())
plt.gcf().subplots_adjust(bottom=0.30)
plt.ylabel(r"Num of variants ($\times$1000)")
renameLegend(ax=plt.gca())
plt.savefig(pathPlots + "numVariants.pdf")
def expvaluecollection(evc, show=True, **kwargs):
"""
Visualize a :class:`pycppqed.expvalues.ExpectationValueCollection`.
*Usage*
>>> import numpy as np
>>> T = np.linspace(0,10)
>>> d = (np.sin(T), np.cos(T))
>>> titles = ("<x>", "<y>")
>>> evc = pycppqed.expvalues.ExpectationValueCollection(d, T, titles)
>>> evc.plot()
*Arguments*
* *evc*
A :class:`pycppqed.expvalues.ExpectationValueCollection`.
* *show* (optional):
If True pylab.show() is called finally. This means a plotting
window will pop up automatically. (Default is True)
* Any other arguments that the pylab plotting command can use.
"""
if evc.subsystems:
import pylab
for sysname, data in evc.subsystems.iteritems():
pylab.figure()
_expvalues(data.evtrajectories, show=False, **kwargs)
if hasattr(pylab, "suptitle"): # For old versions not available.
pylab.suptitle(sysname)
pylab.gcf().canvas.set_window_title(sysname)
if show:
pylab.show()
else:
titles = ["(%s) %s" % (i, title) for i, title in enumerate(evc.titles)]
_expvalues(evc.evtrajectories, titles, show=show, **kwargs)
def plot_shaded_lines(my_xticks, y1, y2, error1, error2, ylab, xlab, filename):
plt.figure(figsize=(6,6))
from matplotlib import rcParams
rcParams.update({'figure.autolayout': True})
x = range(0, len(y1))
plt.plot(x, y1, 'k-', color="blue", label='men')
plt.fill_between(x, y1-error1, y1+error1, facecolor='blue', alpha=.2)
plt.plot(x, y2, 'k-', color="red", label='women')
plt.fill_between(x, y2-error2, y2+error2, facecolor='red', alpha=.2)
#if isinstance(x, (int, long, float, complex)):
# plt.xlim(np.min(x), np.max(x))
plt.gcf().subplots_adjust(bottom=0.3)
plt.xticks(x, my_xticks)
plt.xticks(rotation=70, fontsize=14)
plt.yticks(fontsize=14)
#plt.setp(ax.get_xticklabels(), rotation='vertical', fontsize=14)
plt.ylabel(ylab, fontsize=14)
plt.xlabel(xlab, fontsize=14)
plt.legend()
plt.savefig(filename)
def acquire_masks(self):
im1 = self.cam2.get()
pl.imshow(im1, cmap='gray')
pl.title('Select Eye')
pts_eye = pl.ginput(n=0, timeout=0)
pts_eye = np.array(pts_eye, dtype=np.int32)
mask_eye = np.zeros(im1.shape, dtype=np.int32)
cv2.fillConvexPoly(mask_eye, pts_eye, (1,1,1), lineType=cv2.LINE_AA)
pl.clf()
im2 = self.cam2.get()
pl.imshow(im2, cmap='gray')
pl.title('Select Wheel')
pl.gcf().canvas.draw()
pts_wheel = pl.ginput(n=0, timeout=0)
pts_wheel = np.array(pts_wheel, dtype=np.int32)
mask_wheel = np.zeros(im2.shape, dtype=np.int32)
cv2.fillConvexPoly(mask_wheel, pts_wheel, (1,1,1), lineType=cv2.LINE_AA)
pl.close()
self.mask = np.array([mask_eye, mask_wheel])
self.mask_flat = self.mask.reshape((2,-1))
return self.mask
def compare_expvaluecollections(coll1, coll2, show=True, **kwargs):
"""
Plot all subsystems of two ExpectationValueCollections.
*Arguments*
* *coll1*
First :class:`pycppqed.expvalues.ExpectationValue.Collection`.
* *coll2*
Second :class:`pycppqed.expvalues.ExpectationValue.Collection`.
* *show* (optional):
If True pylab.show() is called finally. This means a plotting
window will pop up automatically. (Default is True)
* Any other arguments that the pylab plotting command can use.
This function allows a fast comparison between two sets of expectation
values that were obtained by different calculations.
"""
import pylab
s1 = coll1.subsystems
s2 = coll2.subsystems
assert len(s1) == len(s2)
for i in range(len(s1)):
pylab.figure()
_compare_expvaluesubsystems(s1.values()[i], s2.values()[i],
show=False, **kwargs)
title = "%s vs. %s" % (s1.keys()[i], s2.keys()[i])
if hasattr(pylab, "suptitle"): # For old versions not available.
pylab.suptitle(title)
pylab.gcf().canvas.set_window_title(title)
if show:
pylab.show()
def show_chains(rbm, state, dataset, num_particles=20, num_samples=20, show_every=10, display=True,
figname='Gibbs chains', figtitle='Gibbs chains'):
samples = gnp.zeros((num_particles, num_samples, state.v.shape[1]))
state = state[:num_particles, :, :]
for i in range(num_samples):
samples[:, i, :] = rbm.vis_expectations(state.h)
for j in range(show_every):
state = rbm.step(state)
npix = dataset.num_rows * dataset.num_cols
rows = [vm.hjoin([samples[i, j, :npix].reshape((dataset.num_rows, dataset.num_cols)).as_numpy_array()
for j in range(num_samples)],
normalize=False)
for i in range(num_particles)]
grid = vm.vjoin(rows, normalize=False)
if display:
pylab.figure(figname)
pylab.matshow(grid, cmap='gray', fignum=False)
pylab.title(figtitle)
pylab.gcf().canvas.draw()
return grid
def plot(self, key, graph_data, num, row, col, ax):
pylab.subplots_adjust(wspace=.5, hspace=.5)
pylab.title("Region %s" % str(key))
pylab.setp(ax.get_yticklabels(), visible=False)
pylab.setp(ax.get_xticklabels(), visible=False)
pylab.gcf().set_size_inches((row+col, row+col))
h = pylab.hist(graph_data, bins=self.bins)
def cycles_vs_align_len(classData, blastPath, floworder):
pylab.clf()
l = []
c = []
for rowcol,leng,dif,seq in classData:
t = template.deseqify(remove_spaces(seq), floworder)
l.append(dif)
c.append(len(t)/4)
pylab.scatter(l,c)
if "/" in blastPath:
p = blastPath.strip().split("/")[-1]
path = p.strip().split(".")[0]
else:
path = blastPath.strip().split(",")[0]
if 'blastn' in path:
pretitle = 'Relaxed Blast'
if 'megablast' in path:
pretitle = 'Strict Blast'
pylab.title("%s Number of Flows vs. Alignment Length" % pretitle)
pylab.xlabel("Length")
pylab.ylabel("Flows")
pylab.gcf().set_size_inches((8,4))
pylab.axis([0,max(l)+10,0,max(c)+10])
#x = [2.2*i for i in range(max(l))]
#pylab.plot(x)
pylab.savefig("alignment_vs_cycles_%s.png" % path)
pylab.clf()
def plot_compare(t, u, v, fig_title='', file_name=''):
"""
Compare two signals and plot the difference between them.
Parameters
----------
t : ndarray of floats
Times (s) at which the signal is defined.
u, v : ndarrays of floats
Signal samples.
fig_title : string
Plot title.
file_name : string
File in which to save the plot.
"""
p.clf()
p.gcf().canvas.set_window_title(fig_title)
p.subplot(211)
p.plot(t, u, 'b', t, v, 'r')
p.xlabel('t (s)')
p.ylabel('u(t)')
p.title(fig_title)
p.gca().set_xlim(min(t), max(t))
p.subplot(212)
p.plot(t, 20*np.log10(abs(u-v)))
p.xlabel('t (s)')
p.ylabel('error (dB)')
p.gca().set_xlim(min(t), max(t))
p.draw_if_interactive()
if file_name:
p.savefig(file_name)
if next_event_arg < len(singles):
collision_disk, direction = singles[next_event_arg]
vel[collision_disk][direction] *= -1.0
else:
a, b = pairs[next_event_arg - len(singles)]
del_x = [pos[b][0] - pos[a][0], pos[b][1] - pos[a][1]]
abs_x = math.sqrt(del_x[0] ** 2 + del_x[1] ** 2)
e_perp = [c / abs_x for c in del_x]
del_v = [vel[b][0] - vel[a][0], vel[b][1] - vel[a][1]]
scal = del_v[0] * e_perp[0] + del_v[1] * e_perp[1]
for k in range(2):
vel[a][k] += e_perp[k] * scal
vel[b][k] -= e_perp[k] * scal
pylab.subplots_adjust(left=0.10, right=0.90, top=0.90, bottom=0.10)
pylab.gcf().set_size_inches(6, 6)
img = 0
if not os.path.exists(output_dir): os.makedirs(output_dir)
N=4
histo_data = []
conf_a = ((0.30, 0.30), (0.30, 0.70), (0.70, 0.30), (0.70,0.70))
conf_b = ((0.20, 0.20), (0.20, 0.80), (0.75, 0.25), (0.75,0.75))
conf_c = ((0.30, 0.20), (0.30, 0.80), (0.70, 0.20), (0.70,0.70))
configurations = [conf_a, conf_b, conf_c]
hits = {conf_a: 0, conf_b: 0, conf_c: 0}
del_xy = 0.10
pos = [[0.25, 0.25], [0.75, 0.25], [0.25, 0.75], [0.75, 0.75]]
vel = [[0.21, 0.12], [0.71, 0.18], [-0.23, -0.79], [0.78, 0.1177]]
PyCont['EQ2'].display((bifPar, 'xB'), axes=(4, 1, 2), stability=True)
PyCont['EQ3'].display((bifPar, 'xB'), axes=(4, 1, 2), stability=True)
plt.title('')
plt.ylabel('$x_B^*$', fontsize=18)
plt.xlabel('')
#plt.xlim([15,35])
PyCont['EQ1'].display((bifPar, 'BM'), axes=(4, 1, 3), stability=True)
PyCont['EQ2'].display((bifPar, 'BM'), axes=(4, 1, 3), stability=True)
PyCont['EQ3'].display((bifPar, 'BM'), axes=(4, 1, 3), stability=True)
plt.title('')
plt.ylabel('$z^*$', fontsize=18)
#plt.xlim([15,35])
PyCont['EQ1'].display((bifPar, 'xM'), axes=(4, 1, 4), stability=True)
PyCont['EQ2'].display((bifPar, 'xM'), axes=(4, 1, 4), stability=True)
PyCont['EQ3'].display((bifPar, 'xM'), axes=(4, 1, 4), stability=True)
plt.title('')
plt.ylabel('$x_M^*$', fontsize=18)
#plt.xlim([15,35])
plt.xlabel('$\\beta_T$', fontsize=18)
PyCont.plot.toggleLabels('off')
PyCont.plot.togglePoints('off')
PyCont.plot.togglePoints(visible='on', bylabel='H1')
fig = plt.gcf()
fig.set_size_inches(3, 5)
plt.tight_layout()
#plt.savefig("met-bif-bT-mixed.pdf")
else:
fmt = "%.3f"
numpy.savetxt(opts["--output"], mat.filled(0), fmt=fmt)
else:
font_kwargs = {
"family": opts["--font-family"],
"size": float(opts["--font-size"])
}
init_pylab(font_kwargs)
# hide all the spines i.e. no axes are drawn
init_spines(hidden=["top", "bottom", "left", "right"])
pylab.gcf().set_figwidth(float(opts["--width-inches"]))
pylab.gcf().set_figheight(float(opts["--height-inches"]))
pylab.xlim(0, len(residues))
pylab.ylim(0, len(residues))
pylab.xlabel(opts["--xlabel"])
pylab.ylabel(opts["--ylabel"])
ax, fig = pylab.gca(), pylab.gcf()
if opts["--show-frame"]:
init_spines(hidden=[])
if opts["cmap"] or opts["hbmap"]:
map_obj = pylab.pcolormesh(mat,
def diagnose_interactions(df):
print("\n=== Interactions table, original shape={} ===\n".format(df.shape))
df = df.copy()
df['ITEM_ID'] = df['ITEM_ID'].astype(str)
df['USER_ID'] = df['USER_ID'].astype(str)
df.index = df["TIMESTAMP"].values.astype("datetime64[s]")
na_rate = df[INTERACTIONS_REQUIRED_FIELDS].isnull().any(axis=1).mean()
print("missing rate in fields", INTERACTIONS_REQUIRED_FIELDS, na_rate)
if na_rate > NA_RATE_THRESHOLD:
warnings.warn(
"High data missing rate for required fields ({:.1%})!".format(
na_rate))
df = df.dropna(subset=INTERACTIONS_REQUIRED_FIELDS)
print("dropna shape", df.shape)
dup_rate = (df.groupby(INTERACTIONS_REQUIRED_FIELDS).size() -
1.0).sum() / df.shape[0]
print("duplication rate", dup_rate)
if dup_rate > DUP_RATE_THRESHOLD:
warnings.warn("""
High duplication rate ({:.1%})!
Only one event can be taken at the same (user,item,timestamp) index.
""".format(dup_rate))
df = df.drop_duplicates(subset=INTERACTIONS_REQUIRED_FIELDS)
print("drop_duplicates shape", df.shape)
repeat_rate = (df.groupby(["USER_ID", "ITEM_ID"]).size() -
1.0).sum() / df.shape[0]
print("user item repeat rate", repeat_rate)
if repeat_rate > REPEAT_RATE_THRESHOLD:
warnings.warn("""
High rate of repeated consumptions ({:.1%})!
We would not do anything, but it may beneficial to
(1) consider keeping only the last interaction between the same user-item pair,
(2) consider if the ITEM_IDs have collisions, and/or
(3) use high-order hierarchical models.
""".format(repeat_rate))
summary = describe_dataframe(df, 'interactions table')
print("\n=== Hourly activity pattern ===")
print(df.groupby(df.index.hour).size())
print("\n=== Day of week activity pattern ===")
print(df.groupby(df.index.dayofweek).size())
plot_patterns = {
"date": df.index.date,
"hour": df.index.hour,
"dayofweek": df.index.dayofweek
}
for k, v in plot_patterns.items():
pl.plot(df.groupby(v).size(), '.-')
pl.gcf().autofmt_xdate()
pl.title("Activity pattern by %s" % k)
pl.grid()
pl.show()
print("\n=== Temporal shift analysis ===\n")
print(
"Sorting and removing repeated user-items for temporal shift analysis..."
)
df.sort_index(inplace=True, kind='mergesort')
df_dedup = df.drop_duplicates(['USER_ID', 'ITEM_ID'], keep='last')
print("\n=== Temporal shift - retrain frequency ===\n")
for method in TEMPORAL_LOSS_METHODS:
bootstrap_avg = []
past_fut_avg = []
for freq in RETRAIN_FREQUENCY:
_, _, _bs_avg, loss_fmt = compute_bootstrap_loss(
df_dedup, freq, method)
_, _, _ts_avg, loss_fmt = compute_temporal_loss(
df_dedup, freq, method, 1)
bootstrap_avg.append(_bs_avg)
past_fut_avg.append(_ts_avg)
pl.plot(RETRAIN_FREQUENCY,
bootstrap_avg,
'.--',
label='same-period bootstrap')
pl.plot(RETRAIN_FREQUENCY,
past_fut_avg,
'.-',
label='lagged popularity')
pl.legend()
pl.xlabel('retrain frequency')
pl.title(method + ' loss at different frequencies')
pl.grid()
pl.gca().yaxis.set_major_formatter(
pl.FuncFormatter(lambda y, _: loss_fmt.format(y)))
pl.show()
print("\n=== Temporal shift - history cutoffs ===\n")
for method in TEMPORAL_LOSS_METHODS:
for freq in TEMPORAL_FREQUENCY:
bootstrap_loss, _, avg_loss, loss_fmt = compute_bootstrap_loss(
df_dedup, freq, method)
pl.plot(bootstrap_loss.iloc[-TEMPORAL_PLOT_LIMIT:],
'.--',
label='boostrap baseline={}'.format(
loss_fmt.format(avg_loss)))
for hist_len in ROLLING_HISTORY_LEN:
temporal_loss, df_wgt, avg_loss, loss_fmt = compute_temporal_loss(
df_dedup, freq, method, hist_len)
pl.plot(temporal_loss.iloc[-TEMPORAL_PLOT_LIMIT:],
'.-',
label='hist={} * {}, avg={}'.format(
hist_len, freq, loss_fmt.format(avg_loss)))
pl.gca().yaxis.set_major_formatter(
pl.FuncFormatter(lambda y, _: loss_fmt.format(y)))
pl.title('{} {} from rolling history (lower is better)'.format(
freq, method))
pl.grid()
pl.gcf().autofmt_xdate()
pl.legend(loc='upper left')
pl.twinx()
pl.plot(df_wgt.iloc[-TEMPORAL_PLOT_LIMIT:],
color='grey',
lw=3,
ls='--',
alpha=0.5)
pl.legend(['activity density'], loc='upper right')
pl.show()
print("\n=== session time delta describe ===")
user_time_delta = df.groupby('USER_ID')["TIMESTAMP"].transform(
pd.Series.diff).dropna()
user_time_delta.sort_values(ascending=False, inplace=True)
print(user_time_delta.describe())
plot_loglog(user_time_delta, 'session time delta', show=False)
for k, v in TIMEDELTA_REFERENCES:
if pl.ylim()[0] < v < pl.ylim()[1]:
pl.plot(pl.xlim(), [v, v], '--')
pl.text(pl.xlim()[0], v, k)
pl.show()
user_time_span = df.groupby('USER_ID')["TIMESTAMP"].apply(
lambda x: max(x) - min(x))
user_time_span.sort_values(ascending=False, inplace=True)
print("=== user time span describe ===")
print(user_time_span.describe())
plot_loglog(user_time_span, 'user time span', show=False)
for k, v in TIMEDELTA_REFERENCES:
if pl.ylim()[0] < v < pl.ylim()[1]:
pl.plot(pl.xlim(), [v, v], '--')
pl.text(pl.xlim()[0], v, k)
pl.show()
def analyze_boundaries(annot_dir, trim, annotators):
"""Analyzes the annotated boundaries.
Parameters
----------
annot_dir: str
Path to the annotations directory where all the jams file reside.
trim: boolean
Whether to trim the first and last boundaries.
annotators: dict
Dictionary containing the names and e-mail addresses of the 5
different annotators.
"""
jams_files = glob.glob(os.path.join(annot_dir, "*.jams"))
dtype = [('P3', float), ('R3', float), ('F3', float), ('P05', float),
('R05', float), ('F05', float), ('D', float), ('DevA2E', float),
('DevE2A', float), ('track_id', '<U400')]
track_ids = get_track_ids(annot_dir)
mma_humans_file = "mma_experiment_humans.pk"
mgp_humans_file = "mgp_experiment_humans.pk"
# Compute the MMA human results
logging.info("Computing the MMA...")
#mma_results = []
#for jam_file in jams_files:
#mma_file = compute_mma_results(jam_file, annotators, trim, 250)
#mma_results.append(np.mean(mma_file, axis=0))
#for i in xrange(len(track_ids)):
#mma_results[i] = mma_results[i].tolist()
#mma_results[i].append(track_ids[i])
#mma_results[i] = tuple(mma_results[i])
#mma_results = np.asarray(mma_results, dtype=dtype)
#pickle.dump(mma_results, open(mma_humans_file, "w"))
mma_results = pickle.load(open(mma_humans_file, "r"))
# Compute the MGP human results (not really necessary)
#logging.info("Computing the MGP...")
#mgp_results = compute_mgp(jams_files, annotators, trim)
#mgp_results = mgp_results.tolist()
#for i in xrange(len(track_ids)):
#mgp_results[i].append(track_ids[i])
#mgp_results[i] = tuple(mgp_results[i])
#mgp_results = np.asarray(mgp_results, dtype=dtype)
#pickle.dump(mgp_results, open(mgp_humans_file, "w"))
#mgp_results = pickle.load(open(mgp_humans_file, "r"))
# Get MGP machine results
mgp_results_machine = pickle.load(
open("../notes/mgp_experiment_machine.pk", "r"))
mgp_results_machine = np.sort(mgp_results_machine, order="track_id")
mma_results = np.sort(mma_results, order='track_id')
for mgp_res, mma_res in zip(mgp_results_machine, mma_results):
print mgp_res["F3"], mma_res["F3"], mgp_res["track_id"], \
mma_res["track_id"]
# Plot results
figsize = (4, 4)
plt.figure(1, figsize=figsize, dpi=120, facecolor='w', edgecolor='k')
plt.scatter(mgp_results_machine["F3"], mma_results["F3"])
plt.plot([0, 1], [0, 1])
plt.gca().set_ylabel("Human MMA$_{F3}$ results")
plt.gca().set_xlabel("Machine MGP$_{F3}$ results")
plt.gca().set_xticks(np.arange(0, 1.1, .1))
plt.gca().set_yticks(np.arange(0, 1.1, .1))
plt.gca().set_xlim(0, 1)
plt.gca().set_ylim(0, 1)
plt.gcf().subplots_adjust(bottom=0.12, left=0.15)
alpha = 0.3
# Best-humans, worse-machines
circle = mpatches.Circle([0.3, 0.79],
0.1,
ec="none",
color="g",
alpha=alpha)
plt.gca().add_artist(circle)
# Best-humans, worse-machines
ellipse = mpatches.Ellipse([0.84, 0.84],
0.1,
0.26,
ec="none",
color="r",
alpha=alpha)
plt.gca().add_artist(ellipse)
# Worse-humans, worse-machines
rectangle = mpatches.Rectangle([0.2, 0.3],
0.2,
0.2,
ec="none",
color="m",
alpha=alpha)
plt.gca().add_artist(rectangle)
plt.show()
def normaliza(wave, flux):
"""
Normaliza
=====
La función hace un ploteo interactivo de wave (eje x) y flux (eje y). En ese ploteo se pueden marcar
puntos que conformarán el continuum de nuestro espectro, normalizar el espectro a partir del continuum
y guardar en un archivo txt los datos del eje x e y del espectrograma normalizado
Parameters
----------
-wave: array de la longitud de onda de nuestro espectro
-flux: array de la luminosidad de nuestro espectro
Returns
----------
Archivo .txt con los datos de longitud de onda y luminosidad
Notes
---------
Estos arrays deben ser del mismo tamaño.
"""
if wave.shape != flux.shape:
raise Exception(
"Los arrays de longitud de onda y de luminosidad deben tener el mismo tamaño"
)
def onclick(event):
"""
Donde el usuario haga click con el boton izquierdo del raton,
se ploteara un pto del continuum de su eleccion.
El tamaño del punto esta determinado por ms.
Picker es un parámetro de área que se usa en la función onpick
"""
if event.button == 1:
plt.plot(event.xdata,
event.ydata,
'r.',
ms=10,
picker=5,
label='nuevoPunto')
plt.draw()
def onpick(event):
"""
Si el usuario hace click con el boton derecho del raton
cerca (rango determinado por el parámetro picker de onclick)
de un punto creado anteriormente, se eliminará el mismo
(o los que estén en el rango)
"""
if event.mouseevent.button == 3:
if hasattr(
event.artist,
'get_label') and event.artist.get_label() == 'nuevoPunto':
event.artist.remove()
def ontype(event):
"""
Cuando el usuario pulse "enter" tras haber seleccionado los puntos
deseados de continuum, se creará un spline de tercer grado que representa
el continuum. Se pueden añadir más puntos después y al volver a pulsar
"enter" se actualizará el spline.
Cuando pulse "n" se realizará la normalización respecto del spline o continuum.
Si pulsa "g" los valores de Luminosidad relativa y longitud de onda se guardarán en un
archivo .txt de nombre normalizacion.
Si pulsa "r" se volverá a la forma original del espectro eliminando los puntos y spline.
Si pulsa "a" el programa hace la normalización automáticamente, sun necesidad de crear
manualmente el continuum.
Si pulsa "t" el programa realiza la normalización de forma teórica con la función de Plank
para cuerpos oscuros.
"""
# Ploteo Continuum
if event.key == 'enter':
new_pto_coord = []
for artist in plt.gca().get_children():
if hasattr(artist,
'get_label') and artist.get_label() == 'nuevoPunto':
new_pto_coord.append(artist.get_data())
elif hasattr(
artist,
'get_label') and artist.get_label() == 'continuum':
artist.remove()
new_pto_coord = np.array(new_pto_coord)[..., 0]
sort_array = np.argsort(new_pto_coord[:, 0])
x, y = new_pto_coord[sort_array].T
spline = splrep(x, y, k=3)
continuum = splev(wave, spline)
plt.plot(wave, continuum, 'r-', lw=2, label='continuum')
# Temperatura de la estrella. Obtenida con la Ley de Wien para cuerpos negros
max_lux = np.amax(continuum)
wave_index_max = np.where(continuum == np.amax(continuum))
temperatura = 29000000.0 / float(wave[wave_index_max])
print("Temperatura aproximada de la estrella (K) =", temperatura)
# Normalizacion
elif event.key == 'n':
continuum = None
for artist in plt.gca().get_children():
if hasattr(artist,
'get_label') and artist.get_label() == 'continuum':
continuum = artist.get_data()[1]
break
if continuum is not None:
plt.cla()
plt.plot(wave,
flux / continuum,
'k-',
label='normalizacion',
lw=0.3)
# Guardado de "seguridad" por si el usuario no guarda la normalización
for artist in plt.gca().get_children():
if hasattr(
artist,
'get_label') and artist.get_label() == 'normalizacion':
datos_normalizar = np.array(artist.get_data())
np.savetxt("normalizacion.txt", datos_normalizar.T)
break
# Normalizado Teórico
elif event.key == 't':
data = np.zeros_like((wave, flux))
data[0, :], data[1, :] = flux, wave
auxList = []
# Temperatura de la estrella. Obtenida con la Ley de Wien para cuerpos negros
pseudocontinuum = medfilt(data[0, :], 301)
pseudocontinuumNoError = pseudocontinuum[50:-50]
max_lux = max(pseudocontinuum)
wave_index_max = np.amin(np.where(pseudocontinuum == max_lux))
wave_max = data[1, wave_index_max]
temperatura = 29000000.0 / float(wave_max)
print("Temperatura aproximada de la estrella (K) =", temperatura)
# Obtención del espectro de cuerpo oscuro y noramliación de la función.
continuum = plank(data[1, :], temperatura - 100)
continuum_noError = continuum[50:-50]
normData = data[0, 50:-50] / pseudocontinuumNoError
plt.cla()
plt.plot(data[1, 50:-50],
normData,
'k-',
lw=0.3,
label='normalizacion')
# Guardado de "seguridad" por si el usuario no guarda la normalización
for artist in plt.gca().get_children():
if hasattr(
artist,
'get_label') and artist.get_label() == 'normalizacion':
datos_normalizar = np.array(artist.get_data())
np.savetxt("normalizacion.txt", datos_normalizar.T)
break
# Normalizado Automático
elif event.key == 'a':
data = np.zeros_like((wave, flux))
data[0, :], data[1, :] = flux, wave
auxList = []
pseudocontinuum = medfilt(data[0, :], 301) + 0.06
pseudocontinuumNoError = pseudocontinuum[50:-50]
normData = data[0, 50:-50] / pseudocontinuumNoError
plt.cla()
plt.plot(data[1, 50:-50],
normData,
'k-',
lw=0.3,
label='normalizacion')
# Temperatura de la estrella. Obtenida con la Ley de Wien para cuerpos negros
max_lux = max(pseudocontinuum)
wave_index_max = np.amin(np.where(pseudocontinuum == max_lux))
wave_max = data[1, wave_index_max]
temperatura = 29000000.0 / float(wave_max)
print("Temperatura aproximada de la estrella (K) =", temperatura)
# Guardado de "seguridad" por si el usuario no guarda la normalización
for artist in plt.gca().get_children():
if hasattr(
artist,
'get_label') and artist.get_label() == 'normalizacion':
datos_normalizar = np.array(artist.get_data())
np.savetxt("normalizacion.txt", datos_normalizar.T)
break
# Guardado del espectrograma normalizado.
elif event.key == 'g':
for artist in plt.gca().get_children():
if hasattr(
artist,
'get_label') and artist.get_label() == 'normalizacion':
datos_normalizar = np.array(artist.get_data())
np.savetxt("normalizacion.txt", datos_normalizar.T)
print(
'Se ha guardado la normalización en el archivo normalizacion.txt'
)
break
# Reinicio del proceso, vuelve a plotear el espectrograma original
elif event.key == 'r':
plt.cla()
plt.plot(wave, flux, 'k-', lw=0.3)
plt.draw()
#Conectamos las funciones interactivas con sus respectivos eventos
plt.gcf().canvas.mpl_connect('key_press_event', ontype)
plt.gcf().canvas.mpl_connect('button_press_event', onclick)
plt.gcf().canvas.mpl_connect('pick_event', onpick)
spectrum = plt.plot(wave, flux, 'k-', lw=0.3)
plt.show()
return
haploid_color = '#08519c'
#pylab.figure(1,figsize=(7, 2))
#fig = pylab.gcf()
# make three panels panels
#outer_grid = gridspec.GridSpec(1,2, width_ratios=[1,1],wspace=0.275)
# When it 1 then 2
#pylab.figure(1,figsize=(4.5, 2))
#fig = pylab.gcf()
#outer_grid = gridspec.GridSpec(1,2, width_ratios=[3,1.3],wspace=0.4)
#right_grid = gridspec.GridSpecFromSubplotSpec(2,1, height_ratios=[1,1],hspace=0.5,subplot_spec=outer_grid[1])
pylab.figure(1,figsize=(5, 3))
fig = pylab.gcf()
outer_grid = gridspec.GridSpec(1,1)
pylab.figure(2,figsize=(5, 3))
fig2 = pylab.gcf()
outer_grid2 = gridspec.GridSpec(1,1)
###########################################
#
# Do calculations and plotting for panel D (dN/dS vs dS)
#
###########################################
syn_differences = {}
def plot_hodograph(data, parameters, fname=None, web=False, fixed=False, archive=False):
img_title = "%s VWP valid %s" % (data.rid, data['time'].strftime("%d %b %Y %H%M UTC"))
if fname is not None:
img_file_name = fname
else:
img_file_name = "%s_vad.png" % data.rid
u, v = vec2comp(data['wind_dir'], data['wind_spd'])
sat_age = 6 * 3600
if fixed or len(u) == 0:
# TJT
ctr_u, ctr_v = 20, 0
#ctr_u, ctr_v = 20, 20
size = 120
#size = 100
else:
ctr_u = u.mean()
ctr_v = v.mean()
size = max(u.max() - u.min(), v.max() - v.min()) + 20
size = max(120, size)
min_u = ctr_u - size / 2
max_u = ctr_u + size / 2
min_v = ctr_v - size / 2
max_v = ctr_v + size / 2
now = datetime.utcnow()
img_age = now - data['time']
age_cstop = min(_total_seconds(img_age) / sat_age, 1) * 0.4
age_color = mpl.cm.get_cmap('hot')(age_cstop)[:-1]
age_str = "Image created on %s (%s old)" % (now.strftime("%d %b %Y %H%M UTC"), _fmt_timedelta(img_age))
pylab.figure(figsize=(10, 7.5), dpi=150)
fig_wid, fig_hght = pylab.gcf().get_size_inches()
fig_aspect = fig_wid / fig_hght
axes_left = 0.05
axes_bot = 0.05
axes_hght = 0.9
axes_wid = axes_hght / fig_aspect
pylab.axes((axes_left, axes_bot, axes_wid, axes_hght))
_plot_background(min_u, max_u, min_v, max_v)
_plot_data(data, parameters)
_plot_param_table(parameters, web=web)
pylab.xlim(min_u, max_u)
pylab.ylim(min_v, max_v)
pylab.xticks([])
pylab.yticks([])
if not archive:
pylab.title(img_title, color=age_color)
pylab.text(0., -0.01, age_str, transform=pylab.gca().transAxes, ha='left', va='top', fontsize=9, color=age_color)
else:
pylab.title(img_title)
if web:
web_brand = "http://www.autumnsky.us/vad/"
pylab.text(1.0, -0.01, web_brand, transform=pylab.gca().transAxes, ha='right', va='top', fontsize=9)
pylab.savefig(img_file_name, dpi=pylab.gcf().dpi)
pylab.close()
if web:
bounds = {'min_u':min_u, 'max_u':max_u, 'min_v':min_v, 'max_v':max_v}
print(json.dumps(bounds))
P = []
for i in range(0, swarmsize):
P.append(Particle())
gBest_fitness = float('inf')
gBest_position = [None] * len(P[0].getCurrPosition())
# matplotlib inline
import time
import pylab as pl
from IPython import display
if (D == 1):
pl.plot(function_to_predict["X"], function_to_predict["Y"])
display.clear_output(wait=True)
display.display(pl.gcf())
time.sleep(1.0)
if (D == 2):
ax = plt.axes(projection='3d')
ax.plot3D(
function_to_predict["X"], function_to_predict["Y"],
function_to_predict["Z"], 'o'
) #,function_to_predict["X"], function_to_predict["Y"], function_to_predict["Z"], '-o')
display.clear_output(wait=True)
display.display(pl.gcf())
time.sleep(1.0)
#PSO
old_y = []
def main():
assert args.train_filename is not None
# モデル
model = ithmm.model()
if model.load(os.path.join(args.model, "ithmm.model")) == False:
raise Exception("モデルが見つかりません.")
# 単語辞書
dictionary = ithmm.dictionary()
dictionary.load(os.path.join(args.model, "ithmm.dict"))
tagger = treetaggerwrapper.TreeTagger(TAGLANG="en")
all_types_of_pos = set()
state_sequence_array_true = [] # 真の品詞列
state_sequence_array_viterbi = [] # ビタビアルゴリズムによる推定
def append(f):
for i, line in enumerate(f):
line = line.strip() # 改行を消す
results = tagger.tag_text(line) # 形態素解析
word_ids = []
state_sequence_true = []
for result_str in results:
pos, word = parse_tagger_result_str(result_str)
all_types_of_pos.add(pos)
word_ids.append(dictionary.string_to_word_id(word))
state_sequence_true.append(pos)
state_sequence_array_true.append(state_sequence_true)
state_sequence_viterbi = model.viterbi_decode(word_ids)
assert len(state_sequence_viterbi) == len(state_sequence_true)
state_sequence_array_viterbi.append(state_sequence_viterbi)
# 読み込み
if args.train_filename.endswith(".txt"):
with codecs.open(args.train_filename, "r", "utf-8") as f:
append(f)
else:
train_dir = args.train_filename
files = os.listdir(train_dir)
for filename in files:
with codecs.open(os.path.join(train_dir, filename), "r",
"utf-8") as f:
append(f)
# モデルの予測品詞と正解品詞の対応関係
num_occurrence_of_pos_for_tag = {}
for state_sequence_true, state_sequence_viterbi in zip(
state_sequence_array_true, state_sequence_array_viterbi):
for pos_true, tag_viterbi in zip(state_sequence_true,
state_sequence_viterbi):
if tag_viterbi not in num_occurrence_of_pos_for_tag:
num_occurrence_of_pos_for_tag[tag_viterbi] = {}
if pos_true not in num_occurrence_of_pos_for_tag[tag_viterbi]:
num_occurrence_of_pos_for_tag[tag_viterbi][pos_true] = 0
num_occurrence_of_pos_for_tag[tag_viterbi][pos_true] += 1
tags = model.get_all_states()
# 存在しない部分を0埋め
for tag, occurrence in num_occurrence_of_pos_for_tag.items():
for pos in all_types_of_pos:
if pos not in occurrence:
occurrence[pos] = 0
for tag in tags:
if tag not in num_occurrence_of_pos_for_tag:
num_occurrence_of_pos_for_tag[tag] = {}
for pos in all_types_of_pos:
num_occurrence_of_pos_for_tag[tag][pos] = 0
# 正解品詞ごとに正規化
for pos in all_types_of_pos:
z = 0
for tag, occurrence in num_occurrence_of_pos_for_tag.items():
z += occurrence[pos]
if z > 0:
for tag, occurrence in num_occurrence_of_pos_for_tag.items():
occurrence[pos] = float(occurrence[pos]) / float(z)
fig = pylab.gcf()
fig.set_size_inches(len(tags) + 3, len(all_types_of_pos))
pylab.clf()
dataframe = pd.DataFrame(num_occurrence_of_pos_for_tag)
ax = sns.heatmap(dataframe, annot=False, fmt="f", linewidths=0)
ax.tick_params(labelsize=20)
plt.yticks(rotation=0)
plt.xticks(rotation=90)
plt.xlabel(u"予測タグ")
plt.ylabel(u"正解品詞")
heatmap = ax.get_figure()
heatmap.savefig("{}/pos.png".format(args.model))
def curvedEarthAxes(rect=111,
fig=None,
minground=0.,
maxground=2000,
minalt=0,
maxalt=500,
Re=6371.,
nyticks=5,
nxticks=4):
""" Create curved axes in ground-range and altitude
**Args**:
* [**rect**]: subplot spcification
* [**fig**]: A pylab.figure object (default to gcf)
* [**maxground**]: maximum ground range [km]
* [**minalt**]: lowest altitude limit [km]
* [**maxalt**]: highest altitude limit [km]
* [**Re**]: Earth radius
**Returns**:
* **ax**: matplotlib.axes object containing formatting
* **aax**: matplotlib.axes object containing data
**Example**:
::
import numpy as np
from utils import plotUtils
ax, aax = plotUtils.curvedEarthAxes()
th = np.linspace(0, ax.maxground/ax.Re, 50)
r = np.linspace(ax.Re+ax.minalt, ax.Re+ax.maxalt, 20)
Z = exp( -(r - 300 - ax.Re)**2 / 100**2 ) * np.cos(th[:, np.newaxis]/th.max()*4*np.pi)
x, y = np.meshgrid(th, r)
im = aax.pcolormesh(x, y, Z.T)
ax.grid()
written by Sebastien, 2013-04
"""
from matplotlib.transforms import Affine2D, Transform
import mpl_toolkits.axisartist.floating_axes as floating_axes
from matplotlib.projections import polar
from mpl_toolkits.axisartist.grid_finder import FixedLocator, DictFormatter
import numpy as np
from pylab import gcf
ang = maxground / Re
minang = minground / Re
angran = ang - minang
angle_ticks = [(0, "{:.0f}".format(minground))]
while angle_ticks[-1][0] < angran:
tang = angle_ticks[-1][0] + 1. / nxticks * angran
angle_ticks.append((tang, "{:.0f}".format((tang - minang) * Re)))
grid_locator1 = FixedLocator([v for v, s in angle_ticks])
tick_formatter1 = DictFormatter(dict(angle_ticks))
altran = maxalt - minalt
alt_ticks = [(minalt + Re, "{:.0f}".format(minalt))]
while alt_ticks[-1][0] < Re + maxalt:
alt_ticks.append(
(1. / nyticks * altran + alt_ticks[-1][0],
"{:.0f}".format(altran * 1. / nyticks + alt_ticks[-1][0] - Re)))
_ = alt_ticks.pop()
grid_locator2 = FixedLocator([v for v, s in alt_ticks])
tick_formatter2 = DictFormatter(dict(alt_ticks))
tr_rotate = Affine2D().rotate(np.pi / 2 - ang / 2)
tr_shift = Affine2D().translate(0, Re)
tr = polar.PolarTransform() + tr_rotate
grid_helper = floating_axes.GridHelperCurveLinear(
tr,
extremes=(0, angran, Re + minalt, Re + maxalt),
grid_locator1=grid_locator1,
grid_locator2=grid_locator2,
tick_formatter1=tick_formatter1,
tick_formatter2=tick_formatter2,
)
if not fig: fig = gcf()
ax1 = floating_axes.FloatingSubplot(fig, rect, grid_helper=grid_helper)
# adjust axis
ax1.axis["left"].label.set_text(r"ALt. [km]")
ax1.axis["bottom"].label.set_text(r"Ground range [km]")
ax1.invert_xaxis()
ax1.minground = minground
ax1.maxground = maxground
ax1.minalt = minalt
ax1.maxalt = maxalt
ax1.Re = Re
fig.add_subplot(ax1, transform=tr)
# create a parasite axes whose transData in RA, cz
aux_ax = ax1.get_aux_axes(tr)
aux_ax.patch = ax1.patch # for aux_ax to have a clip path as in ax
ax1.patch.zorder = 0.9 # but this has a side effect that the patch is
# drawn twice, and possibly over some other
# artists. So, we decrease the zorder a bit to
# prevent this.
return ax1, aux_ax
for i in range(len(names))[::-1]:
axes[i].set_position([l0, b0 + hh * i, ww, hh])
# Resize labels/ticks
for i in range(len(axes)):
ax = axes[i]
ax.tick_params(axis='both',
which='major',
labelsize=20,
size=8.,
width=1.5,
pad=8.)
ax.tick_params(axis='both',
which='minor',
labelsize=20,
size=5.,
width=1.5)
if i != 0: ax.tick_params(axis='x', which='major', labelbottom='off')
axes[0].set_xlabel(r"$k \,[\mathrm{Mpc}^{-1}]$",
fontdict={'fontsize': 'xx-large'},
labelpad=10.)
#ax.set_ylabel(r"$P(k)$", fontdict={'fontsize':'20'})
# Set size
P.gcf().set_size_inches(8.5, 10.)
P.savefig('ska-fbao.pdf', transparent=True)
P.show()
if row[3] != '0':
gene_number.append(row[0])
expression_in_exp_form.append(float(row[1]))
total_intron_length.append(float(row[3]))
transcript_lengths.append(float(row[4]))
### Setting font size for all graphs in this program
size_font = 16
### Combined control data and intron length data for density operation
### and compute the density values as variable z
comb = [expression_in_exp_form, total_intron_length]
z = gaussian_kde(comb)(comb)
### Plot Data
plt.figure(5, figsize=(9, 6.75))
fig = pylab.gcf()
plt.scatter(expression_in_exp_form,
total_intron_length,
c=z,
s=50,
edgecolors='')
fig.canvas.set_window_title('')
plt.title('C. Elegan - Total Intron Length vs Gene Expression',
fontsize=size_font)
plt.ylabel('Total Intron Length (nucleotides)', fontsize=size_font)
plt.xlabel('Expression (number of expression sequence tag hits)',
fontsize=size_font)
plt.grid()
plt.show(block=True)
def _get_fig(fi=None):
if fi is not None:
myfig = PL.figure(fi)
else:
myfig = PL.gcf()
return myfig
plot_stiffness_field(k_cart_list[-1],plottitle='end')
str_parts = fname.split('.')
if d.has_key('strategy'):
addon = ''
if opt.xy:
addon = '_xy'
if opt.xz:
addon = '_xz'
fig_name = str_parts[0]+'_'+d['strategy']+addon+'.png'
else:
fig_name = str_parts[0]+'_res.png'
if expt_plot:
f = pl.gcf()
curr_size = f.get_size_inches()
f.set_size_inches(curr_size[0]*2,curr_size[1]*2)
f.savefig(fig_name)
if show_fig:
pl.show()
else:
print '################################'
print 'show_fig is FALSE'
if not(expt_plot):
pl.savefig(fig_name)
if xyz_flag:
plot_cartesian(traj, xaxis=0,yaxis=1,zaxis=2)
mlab.show()
def mollview(map=None,
fig=None,
rot=None,
coord=None,
unit='',
xsize=800,
title='Mollweide view',
nest=False,
min=None,
max=None,
flip='astro',
remove_dip=False,
remove_mono=False,
gal_cut=0,
format='%g',
format2='%g',
cbar=True,
cmap=None,
notext=False,
norm=None,
hold=False,
margins=None,
sub=None):
"""Plot an healpix map (given as an array) in Mollweide projection.
Input:
- map : an ndarray containing the map
if None, use map with inf value (white map), useful for
overplotting
Parameters:
- fig: a figure number. Default: create a new figure
- rot: rotation, either 1,2 or 3 angles describing the rotation
Default: None
- coord: either one of 'G', 'E' or 'C' to describe the coordinate
system of the map, or a sequence of 2 of these to make
rotation from the first to the second coordinate system.
Default: None
- unit: a text describing the unit. Default: ''
- xsize: the size of the image. Default: 800
- title: the title of the plot. Default: 'Mollweide view'
- nest: if True, ordering scheme is NEST. Default: False (RING)
- min: the minimum range value
- max: the maximum range value
- flip: 'astro' (default, east towards left, west towards right) or 'geo'
- remove_dip: if True, remove the dipole+monopole
- remove_mono: if True, remove the monopole
- gal_cut: galactic cut for the dipole/monopole fit
- format: the format of the scale label. Default: '%g'
- format2: format of the pixel value under mouse. Default: '%g'
- cbar: display the colorbar. Default: True
- notext: if True, no text is printed around the map
- norm: color normalization, hist= histogram equalized color mapping, log=
logarithmic color mapping, default: None (linear color mapping)
- hold: if True, replace the current Axes by a MollweideAxes.
use this if you want to have multiple maps on the same
figure. Default: False
- sub: use a part of the current figure (same syntax as subplot).
Default: None
- margins: either None, or a sequence (left,bottom,right,top)
giving the margins on left,bottom,right and top
of the axes. Values are relative to figure (0-1).
Default: None
"""
# Create the figure
if not (hold or sub):
f = pylab.figure(fig, figsize=(8.5, 5.4))
extent = (0.02, 0.05, 0.96, 0.9)
elif hold:
f = pylab.gcf()
left, bottom, right, top = npy.array(f.gca().get_position()).ravel()
extent = (left, bottom, right - left, top - bottom)
f.delaxes(f.gca())
else: # using subplot syntax
f = pylab.gcf()
if hasattr(sub, '__len__'):
nrows, ncols, idx = sub
else:
nrows, ncols, idx = sub / 100, (sub % 100) / 10, (sub % 10)
if idx < 1 or idx > ncols * nrows:
raise ValueError('Wrong values for sub: %d, %d, %d' %
(nrows, ncols, idx))
c, r = (idx - 1) % ncols, (idx - 1) / ncols
if not margins:
margins = (0.01, 0.0, 0.0, 0.02)
extent = (c * 1. / ncols + margins[0],
1. - (r + 1) * 1. / nrows + margins[1],
1. / ncols - margins[2] - margins[0],
1. / nrows - margins[3] - margins[1])
extent = (extent[0] + margins[0], extent[1] + margins[1],
extent[2] - margins[2] - margins[0],
extent[3] - margins[3] - margins[1])
#extent = (c*1./ncols, 1.-(r+1)*1./nrows,1./ncols,1./nrows)
#f=pylab.figure(fig,figsize=(8.5,5.4))
# Starting to draw : turn interactive off
wasinteractive = pylab.isinteractive()
pylab.ioff()
try:
if map is None:
map = npy.zeros(12) + npy.inf
cbar = False
ax = PA.HpxMollweideAxes(f,
extent,
coord=coord,
rot=rot,
format=format2,
flipconv=flip)
f.add_axes(ax)
if remove_dip:
map = pixelfunc.remove_dipole(map,
gal_cut=gal_cut,
nest=nest,
copy=True,
verbose=True)
elif remove_mono:
map = pixelfunc.remove_monopole(map,
gal_cut=gal_cut,
nest=nest,
copy=True,
verbose=True)
ax.projmap(map,
nest=nest,
xsize=xsize,
coord=coord,
vmin=min,
vmax=max,
cmap=cmap,
norm=norm)
if cbar:
im = ax.get_images()[0]
b = im.norm.inverse(npy.linspace(0, 1, im.cmap.N + 1))
v = npy.linspace(im.norm.vmin, im.norm.vmax, im.cmap.N)
if matplotlib.__version__ >= '0.91.0':
cb = f.colorbar(ax.get_images()[0],
ax=ax,
orientation='horizontal',
shrink=0.5,
aspect=25,
ticks=PA.BoundaryLocator(),
pad=0.05,
fraction=0.1,
boundaries=b,
values=v,
format=format)
else:
# for older matplotlib versions, no ax kwarg
cb = f.colorbar(ax.get_images()[0],
orientation='horizontal',
shrink=0.5,
aspect=25,
ticks=PA.BoundaryLocator(),
pad=0.05,
fraction=0.1,
boundaries=b,
values=v,
format=format)
ax.set_title(title)
if not notext:
ax.text(0.86,
0.05,
ax.proj.coordsysstr,
fontsize=14,
fontweight='bold',
transform=ax.transAxes)
if cbar:
cb.ax.text(0.5,
-1.0,
unit,
fontsize=14,
transform=cb.ax.transAxes,
ha='center',
va='center')
f.sca(ax)
finally:
pylab.draw()
if wasinteractive:
pylab.ion()
seg = segs[ii]
if seg.timebase[0] > start_time:
# print("normalise = %s" % normalise)
if (normalise != 0) and (normalise != '0'):
# the old code used to change seg, even at the beginning of a long chain.
seg_proc = seg.subtract_mean().normalise(normalise, separate)
else:
seg_proc = seg.subtract_mean()
outsvd = seg_proc.svd()
ax_list = outsvd.svdplot(hold=hold, init_but_list=init_but_list)
try: # plotting mag
if verbose: print(outsvd.history)
if plot_mag and (seg_proc.scales is not None):
fig = pl.gcf()
oldtop = fig.subplotpars.top
fig.subplots_adjust(top=0.65)
ax = pl.axes([0.63, 0.75, 0.35, 0.15])
# ax=pl.subplot(8,2,-2) # try to put plot on top: doesn't work in new version
xticks = range(len(seg_proc.scales))
if pyfusion.VERBOSE > 3:
print('scales', len(seg_proc.scales), seg_proc.scales)
pl.bar(xticks, seg_proc.scales, align='center')
ax.set_xticks(xticks)
# still confused - sometimes the channels are the names bdb
try:
seg_proc.channels[0].name
names = [sgch.name for sgch in seg_proc.channels]
except:
names = seg_proc.channels
def scaling():
procs_mpi = numpy.zeros(4, numpy.int)
avg_mpi = numpy.zeros(4, numpy.float64)
procs_omp6 = numpy.zeros(4, numpy.int)
avg_omp6 = numpy.zeros(4, numpy.float64)
procs_omp12 = numpy.zeros(4, numpy.int)
avg_omp12 = numpy.zeros(4, numpy.float64)
# all the following is 768^3 timings, with one block per MPI task
# pure MPI
procs_mpi[:] = [1728, 4096, 13824, 32768]
avg_mpi[:] = [39.6, 21.1, 16.3, 30.3]
# 6 OpenMP threads per MPI task
procs_omp6[:] = [1296, 3072, 10368, 24576]
avg_omp6[:] = [60.1, 26.7, 9.9, 6.5]
# 12 OpenMP threads per MPI task
procs_omp12[:] = [2592, 6144, 20736, 49152]
avg_omp12[:] = [57.3, 22.5, 8.3, 4.9]
ax = pylab.subplot(111)
ax.set_xscale('log')
ax.set_yscale('log')
pylab.plot(procs_mpi,
avg_mpi,
ms=6,
mew=0,
marker="s",
c="r",
ls="solid",
label=r"pure MPI")
ptemp = numpy.arange(2) * procs_mpi[len(procs_mpi) - 1] + float(
procs_mpi[0])
pylab.plot(ptemp,
avg_mpi[0] * (procs_mpi[0] / ptemp),
"r:",
label="_nolegend_")
pylab.plot(procs_omp6,
avg_omp6,
ms=6,
mew=0,
marker="o",
c="b",
ls="solid",
label=r"6 OpenMP threads / MPI task")
ptemp = numpy.arange(2) * procs_omp6[len(procs_omp6) - 1] + float(
procs_omp6[0])
pylab.plot(ptemp,
avg_omp6[0] * (procs_omp6[0] / ptemp),
"b:",
label="_nolegend_")
pylab.plot(procs_omp12,
avg_omp12,
ms=6,
mew=0,
marker="^",
c="g",
ls="solid",
label=r"12 OpenMP threads / MPI task")
ptemp = numpy.arange(2) * procs_omp12[len(procs_omp12) - 1] + float(
procs_omp12[0])
pylab.plot(ptemp,
avg_omp12[0] * (procs_omp12[0] / ptemp),
"g:",
label="_nolegend_")
pylab.xlabel("# of processors")
pylab.ylabel("time to advance timestep")
leg = pylab.legend(loc=3)
ltext = leg.get_texts()
pylab.setp(ltext, fontsize='small')
leg.draw_frame(0)
pylab.axis([1000, 100000, 1, 100])
pylab.title(r"MAESTRO WD convection (768^3) scaling on Jaguar XT5",
fontsize=11)
f = pylab.gcf()
f.set_size_inches(6.0, 6.0)
pylab.savefig("jaguar_xt5_scaling.eps")
# Fix ticks
if j == 1:
axes[i].yaxis.tick_right()
axes[i].yaxis.set_label_position("right")
if i % 2 == 1:
for tick in axes[i].xaxis.get_major_ticks():
tick.label1.set_visible(False)
if i % 2 == 1: j += 1
# Hide alternating ticks
kk = 0
for tick in axes[i].yaxis.get_major_ticks():
if kk % 2 == 1:
tick.label1.set_visible(False)
tick.label2.set_visible(False)
kk += 1
# Manually add shared x label
P.figtext(0.5, 0.02, "$z$", fontdict={'size': 'xx-large'})
# Legend
P.legend(bbox_to_anchor=[0.93, -0.04], frameon=False)
# Set size
P.gcf().set_size_inches(10., 7.)
if not PLOT_DIFFERENT_MEASURES:
#pass
P.savefig('fig06-zfns.pdf', transparent=True)
#P.savefig('BINGO-zfns.pdf', transparent=True)
P.show()
ax.text(max(ticks_array) + offset_border, -7.5, "IL", ha='left', fontsize=6)
ax.text(max(ticks_array) + offset_border, -15, "RL", ha='left', fontsize=6)
ax.text(max(ticks_array) + offset_border, -23, "reward", ha='left', fontsize=6)
pl.axvline(max(ticks_array) + offset_border - 0.32,
ymin=-0.25,
ymax=0,
color='k',
clip_on=False,
lw=0.5)
# ax.set_xticks(x_pos + bar_width / dist_bars)
# ax.set_xticklabels(model_names, rotation=40)
ax.set_ylabel("ratio in [\%]")
ax.legend((success_bars[0], timeout_bars[0], crash_bars[0]),
("success", "timeout", "crash"),
ncol=1,
fancybox=True,
framealpha=0.5,
bbox_to_anchor=(0.15, 1.7))
# pl.tight_layout()
pl.gcf().subplots_adjust(bottom=0.17,
top=0.65,
left=0.065,
right=0.95,
hspace=0.12)
# data.plot.bar(stacked=True)
pl.show(block=False)
fig.savefig("figures/test_map_eval.pdf")
else:
while data_lengths[-i] < L_series[L_series_index]:
L_series_index += 1
data_lengths_binned.append(0)
data_lengths_binned[-1] += data_non_cumul[-i]
for i in range(1, len(L_series)):
data_lengths_binned[i] *= 1.0 / (total_length *
(-L_series[i] + L_series[i - 1]))
data_lengths_binned[0] *= 1.0 / total_length
# print 'total length:', total_length
return data_lengths_binned, total_length
YRI_lengths_binned, total_length = bin_dataset(open(tractfile))
plt.loglog(L_series, YRI_lengths_binned, label=tractfile)
plt.loglog(L_series[:-1], y5, label='Inferred history')
plt.legend(loc='lower left')
plt.xlabel('IBS tract length (L)')
plt.ylim(ymin=10**(-16))
plt.xlim(xmin=1)
plt.xlim(xmax=10**6)
plt.xscale('log')
plt.yscale('log')
F = pylab.gcf()
F.set_size_inches(6.83, 7)
rc('font', **{'family': 'sans-serif', 'sans-serif': ['Arial'], 'size': 5})
plt.savefig(output_file, dpi=300, format='pdf')
return (dataNorth, dataSouth)
if __name__ == '__main__':
(path, run, t0, t1) = parseArgs()
(dataNorth, dataSouth) = extractQuantities(path, run, t0, t1)
# --- Dump a pickle!
print(
'Serializing pyLTR.TimeSeries object of MIX data using the Python Pickle package.'
)
filename = os.path.join(path, 'mixSparTimeSeries.pkl')
print(('Writing ' + filename))
fh = open(filename, 'wb')
pickle.dump([dataNorth, dataSouth], fh, protocol=2)
fh.close()
# --- Make a plot of everything
print('Creating summary plot of MIX time series data.')
filename = os.path.join(path, 'mixSparTimeSeries.png')
print(('Writing ' + filename))
pyLTR.Graphics.TimeSeries.MultiPlotN([dataNorth, dataSouth], 'datetime',
['ispar', 'hp', 'aspar'], ['r', 'b'],
['North', 'South'])
pylab.gcf().autofmt_xdate()
pylab.title(os.path.join(path, run))
pylab.savefig(filename, dpi=1200)
def do_plot_final_hist(Controller, xTandemInput, xtPpmNew, isFinalPlots):
lims = Controller.updatedSettings['plottingPars']['plotting range, ppm']
lims = tuple([float(i) for i in lims.split(',')])
binSize = float(Controller.updatedSettings['plottingPars']['histogram bin size, ppm'])
dSetName = Controller.updatedSettings['spectra dataset']
dirName = Controller.updatedSettings['spectra directory']
pathName = os.path.join(dirName, dSetName) + '_HIST.png'
ppmInd = list(xTandemInput[0]).index('massErrorPpm')
xtPpmOld = array([float(i[ppmInd]) for i in xTandemInput[1:]])
bins = arange(lims[0], lims[1] + binSize, binSize)
if isFinalPlots:
figure(num=None, figsize=(10, 5))
subplots_adjust(top=0.875, bottom=0.175, left=0.1, right=0.925, wspace=0.1)
# some info in the bottom left corner
fineprint = 'dataset: %s\ntotal number of identifications: %s\nbin size: %s ppm' \
% (dSetName, len(xTandemInput), binSize)
t = gcf().text(0.05, 0.075, fineprint,
horizontalalignment='left',
verticalalignment='top',
fontproperties=FontProperties(size=6))
# go through NEW ppm error
mean1, stdev1, portion1, mean2, stdev2 = do_em_norm_n_fixed_norm(xtPpmNew)
dist1 = portion1 * dnorm(bins, mean1, stdev1)
dist2 = (1 - portion1) * dnorm(bins, mean2, stdev2)
total = binSize * len(xtPpmNew) * (dist1 + dist2)
#
meanMAD = median(xtPpmNew)
stdevMAD = 1.4826 * median(abs(xtPpmNew - meanMAD))
totalMAD = binSize * len(xtPpmNew) * dnorm(bins, meanMAD, stdevMAD)
# plot histogram with NEW
yLim = None
statParsNew = dict(zip(['Exp.Max.', 'Robust'],
[dict(zip(['mean', 'stdev'], [mean1, stdev1])),
dict(zip(['mean', 'stdev'], [meanMAD, stdevMAD]))]
)
)
totalEMNew, totalMADNew = total, totalMAD
if isFinalPlots:
yLim, binCountNew = subHist(122, xtPpmNew, bins, lims, total, mean1, stdev1, totalMAD, meanMAD, stdevMAD,
'refined', yLim)
# go through OLD ppm error
mean1, stdev1, portion1, mean2, stdev2 = do_em_norm_n_fixed_norm(xtPpmOld)
dist1 = portion1 * dnorm(bins, mean1, stdev1)
dist2 = (1 - portion1) * dnorm(bins, mean2, stdev2)
total = binSize * len(xtPpmOld) * (dist1 + dist2)
#
meanMAD = median(xtPpmOld)
stdevMAD = 1.4826 * median(abs(xtPpmOld - meanMAD))
totalMAD = binSize * len(xtPpmOld) * dnorm(bins, meanMAD, stdevMAD)
# plot histogram with OLD
statParsOri = dict(zip(['Exp.Max.', 'Robust'],
[dict(zip(['mean', 'stdev'], [mean1, stdev1])),
dict(zip(['mean', 'stdev'], [meanMAD, stdevMAD]))]
)
)
if isFinalPlots:
totalEMOri, totalMADOri = total, totalMAD
yLim, binCountOri = subHist(121, xtPpmOld, bins, lims, total, mean1, stdev1, totalMAD, meanMAD, stdevMAD,
'original', yLim)
if isFinalPlots:
savefig(str(pathName))
clf()
# KEEP GOING AND MAKE RESIDUAL ERROR
# SCATTER PLOTS
if isFinalPlots:
dimensions = Controller.allDimensions
for dim in dimensions:
ind = list(xTandemInput[0]).index(dim)
par = array([float(i[ind]) for i in xTandemInput[1:]])
#
# some info in the bottom left corner
fineprint = 'dataset: %s' \
% (dSetName)
t = gcf().text(0.05, 0.075, fineprint,
horizontalalignment='left',
verticalalignment='top',
fontproperties=FontProperties(size=6))
#
bothScatterPlots(par, xtPpmOld, xtPpmNew, lims, dim)
#
pathName = os.path.join(dirName, dSetName) + '_%s.png' % dim
savefig(str(pathName))
clf()
# pass the statistics
statPars = {}
statPars['new'] = statParsNew
statPars['ori'] = statParsOri
Controller.statPars = statPars
# save the histograms as text
# bins - array
# binCountNew - array
# binCountOri - array
# totalEMNew, totalMADNew
# totalEMOri, totalMADOri
if isFinalPlots:
# The binCountOri and binCountNew arrays are likely 1 item shorter than bins
# The while loops correct for this
while len(binCountOri) < len(bins):
binCountOri = append(binCountOri, [0])
while len(binCountNew) < len(bins):
binCountNew = append(binCountNew, [0])
data = vstack((bins, binCountOri, totalEMOri, totalMADOri, binCountNew, totalEMNew, totalMADNew)).T
data = around(data, 1)
titles = ['MassErrorBin (ppm)', 'Original', 'OriginalFitEM', 'OriginalFitRobust',
'Refined', 'RefinedFitEM', 'RefinedFitRobust']
data = vstack((titles, data))
histTxtPath = os.path.join(dirName, dSetName) + '_HIST.txt'
savetxt(histTxtPath, data, fmt='%s', delimiter='\t')
xp, yp = map(lon, lat)
s = pylab.text(xp, yp, "+Y", color="b", zorder=10)
# <<< point on +x >>>
x = 1
y = 0
z = 0
(lon, lat) = convert_xyz_to_lonlat(x, y, z)
xp, yp = map(lon, lat)
s = pylab.text(xp, yp, "+X", color="b", zorder=10)
f = pylab.gcf()
f.set_size_inches(6.0, 8.0)
pylab.savefig("test_sphere_proj_octant.png")
#-----------------------------------------------------------------------------
# full sphere data
#-----------------------------------------------------------------------------
pylab.clf()
# see http://www.scipy.org/Cookbook/Matplotlib/Maps
# here, the lat_0 and lon_0 specify the point directly under
# the viewer (only needed for some projections)
print labels[k]
for i in range(len(err)):
print "%3.3f %4.4f" % (zc[i], err[i])
# Subplot labels
P.gca().tick_params(axis='both', which='major', labelsize=18, width=1.5, size=8., pad=7.)
P.gca().tick_params(axis='both', which='minor', labelsize=18, width=1.5, size=5.)
# Set axis limits
P.xlim((-0.02, 2.5))
P.ylim((0., 0.045))
P.xlabel('$z$', labelpad=10., fontdict={'fontsize':'xx-large'})
P.ylabel("$\sigma_{D_V}/D_V$", labelpad=15., fontdict={'fontsize':'xx-large'})
## Set tick locations
P.gca().yaxis.set_major_locator(matplotlib.ticker.MultipleLocator(0.01))
P.gca().yaxis.set_minor_locator(matplotlib.ticker.MultipleLocator(0.005))
leg = P.legend(loc='upper right', prop={'size':'medium'}, frameon=True, ncol=2)
leg.get_frame().set_alpha(0.8)
leg.get_frame().set_edgecolor('w')
# Set size
P.gcf().set_size_inches(9.5, 6.8)
P.tight_layout()
P.savefig(filename, transparent=True)
P.show()
]
fileroot = [
"evol_std_solar_m", "evol_std_.2solar_m", "evol_std_2solar_m"
]
filemass = massarr[imass]
filename = location[metalicity] + fileroot[metalicity] + filemass
DataIn = np.genfromtxt(filename, dtype="float", unpack=True)
Teff = 10**DataIn[6, :]
L = DataIn[5, :]
pylab.plot(Teff / 10**4, L, color='black')
pylab.xlim([7, 0])
pylab.title(titles[metalicity])
#show all of the tracks that have been plotted
#then save the image
pylab.ylabel("Log[L]")
#pylab.title("Evolutionary tracks for solar metalicity stars")
if metalicity == 0:
pylab.xlabel(r"T$_{\rm eff}$ [x10$^5$]")
pylab.gcf().subplots_adjust(bottom=0.27)
saveLoc = "../../Images/"
saveName = "Evol_solar.png"
pylab.savefig("OldTracks.ps")
#pylab.show()
import pylab as pl
import matplotlib.pyplot as plt
import numpy as np
import random
import math
rnumber = random.randint(0, 100)
X = np.linspace(rnumber - 10, rnumber + 10, 360, endpoint=True)
Y = np.sin(X)
plt.xlabel('Number generated: ' + str(rnumber))
plt.ylabel('Sinus for Number')
plt = pl.gcf()
plt.canvas.set_window_title('Random Number Sinus Plotter')
pl.plot(rnumber, math.sin(rnumber), 'o')
pl.plot(X, Y)
pl.show()
clip.plot.scatter(c='trailingWorstDrawdown',
y='futureMaxLoss',
ax=axlo,
**same)
clip.plot.scatter(c='trailingWorstDrawdown',
y='futureMaxGain',
ax=axhi,
**same)
axlo.tick_params(axis='x', bottom=True, labelbottom=True)
axlo.set_xlabel('Trailing {}-session pct change'.format(trailingShort)) # ??
axlo.set_ylabel('Future {}-session lowest pct change'.format(future))
axhi.set_ylabel('Future {}-session highest pct change'.format(future))
axhi.set_title('S&P500, 1928–present (data: Yahoo Finance)')
[
x.set_ylabel('Trailing {}-session worst drawdown'.format(trailingLong))
for x in plt.gcf().get_axes()[2:]
]
axlo.tick_params(axis='x', bottom=True, labelbottom=True)
axlo.xaxis.get_label().set_visible(True)
# clip.plot.hexbin(x='trailingPctChange', y='futureMaxLoss')
# Plotting the worst loss over a period (for potential put strategy)
predWindows = [21]
futureWindow = 9 + 1
worstdf, predcols, current = makePredictorDataframeMaxLoss(
spx, predWindows, futureWindow, rollworst)
bestdf, _, _ = makePredictorDataframeMaxLoss(spx, predWindows, futureWindow,
rollbest)
print('CURRENTLY', current)
def cartview(map=None,
fig=None,
rot=None,
zat=None,
coord=None,
unit='',
xsize=800,
ysize=None,
lonra=None,
latra=None,
title='Cartesian view',
nest=False,
remove_dip=False,
remove_mono=False,
gal_cut=0,
min=None,
max=None,
flip='astro',
format='%.3g',
cbar=True,
cmap=None,
norm=None,
aspect=None,
hold=False,
sub=None,
margins=None,
notext=False):
"""Plot an healpix map (given as an array) in Cartesian projection.
Input:
- map : an ndarray containing the map.
if None, use map with inf value (white map), useful for
overplotting
Parameters:
- fig: a figure number. Default: create a new figure
- rot: rotation, either 1,2 or 3 angles describing the rotation
Default: None
- coord: either one of 'G', 'E' or 'C' to describe the coordinate
system of the map, or a sequence of 2 of these to make
rotation from the first to the second coordinate system.
Default: None
- unit: a text describing the unit. Default: ''
- xsize: the size of the image. Default: 200
- lonra: range in longitude. Default: [-180,180]
- latra: range in latitude. Default: [-90,90]
- title: the title of the plot. Default: 'Mollweide view'
- nest: if True, ordering scheme is NEST. Default: False (RING)
- min: the minimum range value
- max: the maximum range value
- flip: 'astro' (default, east towards left, west towards right) or 'geo'
- remove_dip: if True, remove the dipole+monopole
- remove_mono: if True, remove the monopole
- gal_cut: galactic cut for the dipole/monopole fit
- format: the format of the scale. Default: '%.3g'
- hold: if True, replace the current Axes by a MollweideAxes.
use this if you want to have multiple maps on the same
figure. Default: False
- sub: use a part of the current figure (same syntax as subplot).
Default: None
- margins: either None, or a sequence (left,bottom,right,top)
giving the margins on left,bottom,right and top
of the axes. Values are relative to figure (0-1).
Default: None
- notext: True: do not add resolution info text
Default=False
"""
if not (hold or sub):
f = pylab.figure(fig, figsize=(8.5, 5.4))
if not margins:
margins = (0.075, 0.05, 0.075, 0.05)
extent = (0.0, 0.0, 1.0, 1.0)
elif hold:
f = pylab.gcf()
left, bottom, right, top = npy.array(
pylab.gca().get_position()).ravel()
if not margins:
margins = (0.0, 0.0, 0.0, 0.0)
extent = (left, bottom, right - left, top - bottom)
f.delaxes(pylab.gca())
else: # using subplot syntax
f = pylab.gcf()
if hasattr(sub, '__len__'):
nrows, ncols, idx = sub
else:
nrows, ncols, idx = sub / 100, (sub % 100) / 10, (sub % 10)
if idx < 1 or idx > ncols * nrows:
raise ValueError('Wrong values for sub: %d, %d, %d' %
(nrows, ncols, idx))
c, r = (idx - 1) % ncols, (idx - 1) / ncols
if not margins:
margins = (0.01, 0.0, 0.0, 0.02)
extent = (c * 1. / ncols + margins[0],
1. - (r + 1) * 1. / nrows + margins[1],
1. / ncols - margins[2] - margins[0],
1. / nrows - margins[3] - margins[1])
extent = (extent[0] + margins[0], extent[1] + margins[1],
extent[2] - margins[2] - margins[0],
extent[3] - margins[3] - margins[1])
#f=pylab.figure(fig,figsize=(5.5,6))
# Starting to draw : turn interactive off
wasinteractive = pylab.isinteractive()
pylab.ioff()
try:
if map is None:
map = npy.zeros(12) + npy.inf
cbar = False
if zat and rot:
raise ValueError('Only give rot or zat, not both')
if zat:
rot = npy.array(zat, dtype=npy.float64)
rot.resize(3)
rot[1] -= 90
ax = PA.HpxCartesianAxes(f,
extent,
coord=coord,
rot=rot,
format=format,
flipconv=flip)
f.add_axes(ax)
if remove_dip:
map = pixelfunc.remove_dipole(map,
gal_cut=gal_cut,
nest=nest,
copy=True)
elif remove_mono:
map = pixelfunc.remove_monopole(map,
gal_cut=gal_cut,
nest=nest,
copy=True)
ax.projmap(map,
nest=nest,
coord=coord,
vmin=min,
vmax=max,
xsize=xsize,
ysize=ysize,
lonra=lonra,
latra=latra,
cmap=cmap,
norm=norm,
aspect=aspect)
if cbar:
if matplotlib.__version__ >= '0.91.0':
cb = f.colorbar(ax.get_images()[0],
ax=ax,
orientation='horizontal',
shrink=0.5,
aspect=25,
ticks=PA.BoundaryLocator(),
pad=0.08,
fraction=0.1,
format=format)
else:
cb = f.colorbar(ax.get_images()[0],
orientation='horizontal',
shrink=0.5,
aspect=25,
ticks=PA.BoundaryLocator(),
pad=0.08,
fraction=0.1,
format=format)
ax.set_title(title)
if not notext:
ax.text(-0.07,
0.6,
ax.proj.coordsysstr,
fontsize=14,
fontweight='bold',
rotation=90,
transform=ax.transAxes)
if cbar:
cb.ax.text(1.05,
0.30,
unit,
fontsize=14,
fontweight='bold',
transform=cb.ax.transAxes,
ha='left',
va='center')
f.sca(ax)
finally:
if wasinteractive:
pylab.ion()
pylab.draw()
def plot_ndpanel(panel,
func=None,
xlim='auto',
ylim='auto',
row_labels='auto',
col_labels='auto',
row_name='auto',
col_name='auto',
pass_slicing_meta_to_func=False,
subplot_xlabel=None,
subplot_ylabel=None,
row_name_pad=40.0,
col_name_pad=40.0,
hspace=0,
wspace=0,
hide_tick_labels=True,
hide_tick_lines=False,
legend=None,
legend_title=None,
grid_kwargs={},
**kwargs):
"""Use to visualize mutli-dimensional data stored in N-dimensional pandas panels.
Given an nd-panel of shape (.., .., .., rows, cols), the function creates a 2d grid of subplot
of shape (rows, cols). subplot i, j calls func parameter with an (n-2) nd panel
that corresponds to (..., .., .., i, j).
Parameters
---------------
panel : pandas Panel (3d-5d.. indexing is hard coded at the moment)
items : time series generated along this axis
major : rows
minor : cols
func : function that accepts a slice of a panel (two dimensions less than input panel)
{_graph_grid_layout}
pass_slicing_meta_to_func : [False | True]
Changes the arguments that are passed to the provided function.
If False: func(data_slice, **kwargs) (Default)
If True: func(data_slice, row=row, col=col, row_value=row_value, col_value=col_value, **kwargs)
grid_kwargs : dict
kwargs to be passed to the create_grid_layout method. See its documentation for further details.
legend : None, tuple
If provided as tuple, must be a 2-d tuple corresponding to a subplot position.
If legend=(2, 4), then the legend will drawn using the labels of the lines provided
in subplot in 2nd row and 4th column.
A better name could be subplot_source_for_legend?
legend_title : str, None
If provided, used as title for the legend.
Returns
---------------
Reference to main axis and to subplot axes.
Examples
----------------
if a is a panel:
plot_panel(a, func=plot, marker='o');
Code that could be useful
---------------------------
# Checks number of arguments function accepts
if func.func_code.co_argcount == 1:
func(data)
else:
func(data, ax)
"""
auto_col_name, auto_col_labels, auto_row_name, auto_row_labels = extract_annotation(
panel)
shape = panel.values.shape
rowNum, colNum = shape[-2], shape[
-1] # Last two are used for setting up the size
ndim = len(shape)
if ndim < 2 or ndim > 5:
raise Exception('Only dimensions between 2 and 5 are supported')
if row_labels == 'auto':
row_labels = auto_row_labels
if col_labels == 'auto':
col_labels = auto_col_labels
# Figure out xlimits and y limits
axis = '' # used below to autoscale subplots
if xlim == 'auto':
xlim = None
axis += 'x'
if ylim == 'auto':
ylim = None
axis += 'y'
ax_main, ax_subplots = create_grid_layout(
rowNum=rowNum,
colNum=colNum,
row_labels=row_labels,
col_labels=col_labels,
xlabel=subplot_xlabel,
ylabel=subplot_ylabel,
hide_tick_labels=hide_tick_labels,
hide_tick_lines=hide_tick_lines,
xlim=xlim,
ylim=ylim,
hspace=hspace,
wspace=wspace,
**grid_kwargs)
nrange = arange(ndim)
nrange = list(
nrange[(nrange - 2) %
ndim]) # Moves the last two dimensions to the first two
if not isinstance(panel, pandas.DataFrame):
panel = panel.transpose(*nrange)
for (row, col), ax in numpy.ndenumerate(ax_subplots):
plt.sca(ax)
data_slice = panel.iloc[row].iloc[col]
row_value = panel.axes[0][row]
col_value = panel.axes[1][col]
if pass_slicing_meta_to_func:
func(data_slice,
row=row,
col=col,
row_value=row_value,
col_value=col_value,
**kwargs)
else:
func(data_slice, **kwargs)
autoscale_subplots(ax_subplots, axis)
plt.sca(ax_main)
if legend is not None:
items, labels = ax_subplots[legend].get_legend_handles_labels()
# lines = ax_subplots[legend].lines
# l = pl.legend(lines , map(lambda x : x.get_label(), lines),
l = pl.legend(items,
labels,
bbox_to_anchor=(0.9, 0.5),
bbox_transform=pl.gcf().transFigure,
loc='center left',
numpoints=1,
frameon=False)
if legend_title is not None:
l.set_title(legend_title)
if row_name == 'auto':
row_name = auto_row_name
if col_name == 'auto':
col_name = auto_col_name
if row_name is not None:
pl.xlabel(col_name, labelpad=col_name_pad)
if col_name is not None:
pl.ylabel(row_name, labelpad=row_name_pad)
#####
# Placing ticks on the top left subplot
ax_label = ax_subplots[0, -1]
pl.sca(ax_label)
if subplot_xlabel:
xticks = numpy.array(pl.xticks()[0], dtype=object)
xticks[1::2] = ''
ax_label.set_xticklabels(xticks, rotation=90, size='small')
if subplot_ylabel:
yticks = numpy.array(pl.yticks()[0], dtype=object)
yticks[1::2] = ''
ax_label.set_yticklabels(yticks, rotation=0, size='small')
pl.sca(ax_main)
return ax_main, ax_subplots