def albedo_parameter_plots(imarr, darr, params=None, plot_params=True,
ylabel='Reflectance', visible_only=True,
figsize=(12,7)):
# from matplotlib import style
# style.use('ggplot')
if params is None:
params = est_curve_params(darr, imarr)
if visible_only:
fig, axs = subplots(2, 3, figsize=figsize, sharey=False, sharex=True)
else:
fig, axs = subplots(2, 4, figsize=figsize, sharey=False, sharex=True)
for i, ax in enumerate(axs.ravel()):
if i >= imarr.shape[-1]:
# This means I've got more axes than image bands so I'll skip plotting
continue
ax.scatter(darr.compressed(),imarr[...,i].compressed(), c='gold', alpha=0.2, edgecolor='none')
cp = params[i]
plotz = np.arange(darr.min(), darr.max(), 0.2)
if plot_params:
ax.plot(plotz, myR0(plotz, *cp), c='brown')
ax.set_xlabel('Depth (m)')
ax.set_ylabel(ylabel)
btxt = "Band{b} $R_\infty = {R:.2f}$\n$A^{{toa}} = {A:.2f}$, $K_g = {Kg:.2f}$ "\
.format(b=i+1, R=cp[0], A=cp[1], Kg=cp[2])
ax.set_title(btxt)
tight_layout()
return fig
def analyse_results(k,n,outpath=None):
"""Summarise multiple results"""
if outpath != None:
os.chdir(outpath)
#add mirbase info
k = k.merge(mirbase,left_on='name',right_on='mature1')
ky1 = 'unique reads'
ky2 = 'read count' #'RC'
cols = ['name','freq','mean read count','mean_norm','total','perc','mirbase_id']
print
print ('found:')
idcols,normcols = get_column_names(k)
final = filter_expr_results(k,freq=.8,meanreads=200)
print (final[cols])
print ('-------------------------------')
print ('%s total' %len(k))
print ('%s with >=10 mean reads' %len(k[k['mean read count']>=10]))
print ('%s found in 1 sample only' %len(k[k['freq']==1]))
print ('top 10 account for %2.2f' %k['perc'][:10].sum())
fig,ax = plt.subplots(nrows=1, ncols=1, figsize=(8,6))
k.set_index('name')['total'][:10].plot(kind='barh',colormap='Spectral',ax=ax,log=True)
plt.tight_layout()
fig.savefig('srnabench_top_known.png')
#fig = plot_read_count_dists(final)
#fig.savefig('srnabench_known_counts.png')
fig,ax = plt.subplots(figsize=(10,6))
k[idcols].sum().plot(kind='bar',ax=ax)
fig.savefig('srnabench_total_persample.png')
print
k.to_csv('srnabench_known_all.csv',index=False)
return k
def plot_4_4_cdfs(df, param_name, teff_categories, age_categories, title='Somechart', figsize=(16, 4)):
"""
"""
# sequential colors..
colors = ['#fecc5c', '#fd8d3c', '#f03b20', '#bd0026']
fig1, axes1 = plt.subplots(nrows=1, ncols=4, sharex=True, sharey=True, figsize=figsize)
fig2, axes2 = plt.subplots(nrows=1, ncols=4, sharex=True, sharey=True, figsize=figsize)
fig3, axes3 = plt.subplots(nrows=1, ncols=4, sharex=True, sharey=True, figsize=figsize)
for teff_bin in xrange(len(teff_categories)):
ax = axes1[teff_bin]
ax.set_title("{} K".format(teff_categories[teff_bin]))
serieses = []
for age_bin in xrange(len(age_categories)):
series = df[(df.teff_bins == teff_bin+1) & (df.age_bins == age_bin+1)][param_name]
s = series.copy()
s.sort()
serieses.append(s)
ax.plot(np.arange(s.size)/float(s.size), s, label=age_categories[age_bin], color=colors[age_bin])
# plot the KS-score for each age-group (4choose2 graphs)
plot_ks_scores(serieses, axes2[teff_bin])
plot_ks_scores(serieses, axes3[teff_bin], log=True)
axes2[0].axes.get_yaxis().set_visible(False)
axes3[0].axes.get_yaxis().set_visible(False)
add_colorful_yticks(axes2[0], colors, len(age_categories))
fig1.suptitle(title, size='xx-large', y=1.08)
fig3.suptitle("Distribution-Pairs KS scores", size='xx-large', y=1.00)
axes1[-1].legend(loc='upper center', bbox_to_anchor=(-1.3, -0.05), fancybox=True, shadow=True, ncol=4)
fig1.tight_layout()
fig2.tight_layout()
return fig1, fig2, fig3
def iterTestRun(m, tspan):
'''
Method to perform iterations and generate plots
'''
# Test 16 random conditions - plot fft and phase diagrams
fig, axes = subplots(4, 4)
fig, axes2 = subplots(4, 4)
for i in range(0, 4):
for j in range(0, 4):
# Run model
yout = m.runModel(tspan, True)
# Plot quiver diagram
m.plotQuiver(yout, axes[i, j])
# Plot Fourier transform
freqs, aMags, rMags = m.calcFourier(yout, tspan)
# Plot FFT
axes2[i, j].plot(freqs, aMags, freqs, rMags)
if i == 0:
xlabel('Frequency (s^-1)')
if j == 3:
ylabel('Magnitude')
legend(['Activator', 'Repressor'])
def plot_pis(indices,it):
f,ax=pl.subplots(len(indices),sharex=True)
for a in range(len(indices)):
k=people[a]
x=[]
y=[]
for j in range(settings.nlabels):
for l in range(settings.nscores):
x.append(l+j*settings.nlabels-0.4)
y.append(pi(k,j,l))
ax[a].bar(x,y)
ax[a].get_yaxis().set_ticks([])
ax[a].set_ylim(0,1)
ax[0].set_xlim(-0.5,len(y)-0.5)
pl.savefig('D:\Documents\images\pi_%03d.png' %it)
f,ax=pl.subplots(len(indices),sharex=True)
for a in range(len(indices)):
i=indices[a]
x=[]
y=[]
for j in range(settings.nlabels):
x.append(j-0.4)
y.append(results[i][j])
ax[a].bar(x,y)
ax[a].get_yaxis().set_ticks([])
ax[a].set_ylim(0,1)
ax[0].set_xlim(-0.5,len(y)-0.5)
pl.savefig('D:\Documents\images\\result_%03d.png' %it)
pl.close('all')
def plot_network_representation(self):
'''
Plot the response of the network
'''
if self.W_type == 'dirichlet':
# Sorting that emphasis balance
balanced_indices_neurons = self.number_connections[:,0].argsort()[::-1]
else:
balanced_indices_neurons = np.arange(self.M)
# Plot the population response
plot_separation_y = 0.3*(np.max(self.network_representations) - np.min(self.network_representations))
fig1, ax1 = plt.subplots(1)
for r in xrange(self.R):
ax1.plot(self.network_representations[r, :, balanced_indices_neurons] + np.arange(self.K)*plot_separation_y + r*(self.K+0.5)*plot_separation_y)
ax1.autoscale(tight=True)
# Plot Hinton graphs
sf, ax = plt.subplots(self.R, 1)
for r in xrange(self.R):
hinton(self.W[r, balanced_indices_neurons].T, ax=ax[r])
def TablePlot():
index_time=0
# print [x[2] for x in RouteTablewithSeq]
pl.ion()
fig,ay=pl.subplots()
fig,ax=pl.subplots()
fig.set_tight_layout(True)
idx_row = Index(np.arange(0,nNodes))
idx_col = Index(np.arange(0,nPackets))
df = DataFrame(cache_matrix[0,:,:], index=idx_row, columns=idx_col)
# print df
normal = pl.Normalize(0, 1)
for index_time in range(len(RouteTablewithSeq_time)):
vals=cache_matrix[index_time,:,:30]
# fig = pl.figure(figsize=(15,8))
# ax = fig.add_subplot(111, frameon=True, xticks=[], yticks=[])
# print vals.shape
the_table=pl.table(cellText=vals, rowLabels=df.index, colLabels=df.columns, colWidths = [0.03]*vals.shape[1], loc='center', cellColours=pl.cm.hot(normal(vals)), fontsize=3)
the_table.alpha=0
for i in range(index_time+1):
for j in range(vals.shape[0]):
if (vals[j,i]==1):
the_table._cells[(j+1, i)]._text.set_color('white')
pl.title("Table at time: "+str(cache_time[index_time])+" Packet: "+str(index_time)+" Probability: "+str(p) )
pl.show()
pl.pause(.0005)
pl.clf()
def analyse_diff_res2(res1, res2, res3, res4):
plt.figure(95)
plt.clf()
#plt.title('Energy vs time')
f, (ax1, ax2) = plt.subplots(2, 1)
f.subplots_adjust(hspace=0.25)
ax1.plot(res3['sim'][0] / 86400, np.array(res3['sim'][4]) / 1e15,
label='Eulerian')
ax1.plot(res4['sim'][0] / 86400, np.array(res4['sim'][4]) / 1e15,
label='semi-Lagrangian')
ax1.set_xlabel('time (days)')
ax1.set_ylabel('energy (PJ)')
ax1.legend(loc='lower right')
ax2.plot(res3['sim'][0] / 86400, np.array(res3['sim'][4]) / 1e15,
label='Eulerian')
ax2.plot(res4['sim'][0] / 86400, np.array(res4['sim'][4]) / 1e15,
label='semi-Lagrangian')
ax2.set_xlim((60, 100))
ax2.set_ylim((2.65, 2.75))
ax2.set_xlabel('time (days)')
ax2.set_ylabel('energy (PJ)')
print('{}: energy_diff={}'.format(res3['res'], res3['energy_diff']))
print('{}: energy_diff={}'.format(res4['res'], res4['energy_diff']))
pd1 = (np.array(res3['sim'][4]).max() - res3['sim'][4][-1] ) / np.array(res3['sim'][4]).max() * 100
pd2 = (np.array(res4['sim'][4]).max() - res4['sim'][4][-1] ) / np.array(res4['sim'][4]).max() * 100
print('% diff 1 {}'.format(pd1))
print('% diff 2 {}'.format(pd2))
plt.savefig('writeup/figures/task_d_energy.png')
f, ((ax1, ax2), (ax3, ax4)) = plt.subplots(2, 2)
f.subplots_adjust(hspace=0.25, wspace=0.25, right=0.8)
X, Y = res1['grid']
ax1.set_title('(a) $\eta$ after 1 day - Eul.')
ax1.contourf(X/1e3, Y/1e3, res1['sim'][1], 100, vmin=-0.01, vmax=0.01)
ax2.set_title('(b) $\eta$ after 1 day - S-L')
cf2 = ax2.contourf(X/1e3, Y/1e3, res2['sim'][1], 100, vmin=-0.01, vmax=0.01)
cbar_ax1 = f.add_axes([0.85, 0.55, 0.05, 0.4])
f.colorbar(cf2, cax=cbar_ax1)
ax3.set_title('(c) $\eta$ after 100 days - Eul.')
ax3.contourf(X/1e3, Y/1e3, res3['sim'][1], 100, vmin=-0.15, vmax=0.2)
ax4.set_title('(d) $\eta$ after 100 days - S-L')
cf4 = ax4.contourf(X/1e3, Y/1e3, res4['sim'][1], 100, vmin=-0.15, vmax=0.2)
ax3.set_xlabel('x (km)')
ax4.set_xlabel('x (km)')
ax1.set_ylabel('y (km)')
ax3.set_ylabel('y (km)')
cbar_ax2 = f.add_axes([0.85, 0.05, 0.05, 0.4])
f.colorbar(cf4, cax=cbar_ax2)
plt.savefig('writeup/figures/task_d_eta.png')
def create_fig( file_name,
small=True,
marker=False,
figsize=None,
nrows=1,
ncols=1,
sharex=False,
sharey=False ):
if not isinstance( file_name, list ):
file_name = [file_name]
defaults = plot_defaults._get_defaults(small)
params = plot_defaults._get_params( small )
pylab.rcParams.update( params )
pylab.rc('font', **defaults[ 'font' ])
if figsize:
fig, axs = pylab.subplots( nrows=nrows, ncols=ncols,
sharex=sharex, sharey=sharey,
figsize=figsize)
else:
fig, axs = pylab.subplots( nrows=nrows, ncols=ncols,
sharex=sharex, sharey=sharey )
if not isinstance(axs, list) and not isinstance(axs, ndarray):
axs = [axs]
for i, f_name in enumerate(file_name):
curves = _input_from_txt(file_name = f_name, small=False)
labels = curves.keys()
labels.sort()
for label in labels:
curve = curves[ label ]
number = label.split('_')[0]
label = '_'.join( label.split('_')[1:] )
number = int(number)
curr_defaults = plot_defaults._cycle_defaults( number, small=False )
def current_default( key ):
if key in curve.keys():
return curve[ key ]
else:
if key in curr_defaults.keys():
return curr_defaults[key]
else:
if marker:
key += '_marker'
if key in curr_defaults.keys():
return curr_defaults[key]
else:
return None
axs[i].plot( curve['x'], curve['y'],
color = current_default( 'color' ),
label = label,
linewidth = current_default( 'linewidth' ),
linestyle = current_default( 'linestyle' ),
marker = current_default( 'marker' ),
markerfacecolor = current_default( 'markerfacecolor' ),
markeredgecolor = current_default( 'markeredgecolor' ),
markeredgewidth = current_default( 'markeredgewidth' ),
markersize = current_default( 'markersize' ) )
return fig
def analyze(X, Y, data, classifier, label, outDir):
#store the means for our ROC curve
meanTPRate = 0.0
meanFPRate = np.linspace(0, 1, 100)
#start with the subplot
pl.subplots()
#now lets analyze the data
for i, (train, test) in enumerate(data):
#grab the data sets for training and testing
xTrain, xTest, yTrain, yTest = X[train], X[test], Y[train], Y[test]
#print xTrain
#print yTrain
#train the model
classifier.fit(xTrain, yTrain)
#now predict on the hold out
predictions = classifier.predict(xTest)
probabilities = classifier.predict_proba(xTest)
#compute ROC and AUC
fpr, tpr, thresholds = roc_curve(yTest, probabilities[:, 1])
meanTPRate += interp(meanFPRate, fpr, tpr)
meanTPRate[0] = 0.0
rocAUC = auc(fpr,tpr)
#now plot it out
pl.plot(fpr, tpr, lw=1, label='ROC Iter %d (area = %0.2f)' % (i+1, rocAUC))
#print "P: %s\nA: %s\n" % (predictions, yTest)
#now plot the random chance line
pl.plot([0,1], [0,1], '--', color=(0.6,0.6,0.6), label='Random Chance')
#generate some stats for the mean plot
meanTPRate /= len(data)
meanTPRate[-1] = 1.0
meanAUC = auc(meanFPRate, meanTPRate)
#plot the average line
pl.plot(meanFPRate, meanTPRate, 'k--', label='Mean ROC (area = %0.2f)' % (meanAUC), lw=2)
#add some other plot parameters
pl.xlim([-0.05, 1.05])
pl.ylim([-0.05, 1.05])
pl.xlabel('False Positive Rate')
pl.ylabel('True Positive Rate')
pl.title('ROC Curve (%s)' % (label))
pl.legend(loc="lower right")
pl.savefig('%s/%s.png' % (outDir, label))
pl.close()
logging.info("%s\t%f" % (label, meanAUC))
def events_per_sim_cycle_histograms():
data = np.loadtxt("analysisData/eventsAvailableBySimCycle.csv", dtype=np.intc, delimiter = ",", skiprows=2)
trimmedData = reject_first_last_outliers(data)
fig, ax1 = pylab.subplots()
outFile = outDir + 'eventsAvailableBySimCycle-histogram-std'
pylab.title('Total LPs: %s; ' % "{:,}".format(total_lps) +
'Total Sim Cycles: %s. '% "{:,}".format(len(trimmedData)))
ax1.hist(trimmedData, bins=100, histtype='stepfilled')
ax1.set_xlabel('Number of Events')
ax1.set_ylabel('Number of Simulation Cycles')
ax2=ax1.twinx()
ax2.hist(trimmedData, bins=100, histtype='stepfilled')
ax2.set_ylabel('Percent of Simulation Cycles')
ax2.yaxis.set_major_formatter(mpl.ticker.FuncFormatter(toPercentOfTotalSimCycles))
display_graph(outFile)
# ok, so now let's build a histogram of the % of LPs with active events.
fig, ax1 = pylab.subplots()
outFile = outDir + 'percentOfLPsWithAvailableEvents'
pylab.title('Percent of LPs w/ Available Events as a Percentage of the Total Sim Cycles')
ax1.hist(trimmedData.astype(float)/float(total_lps), bins=100, histtype='stepfilled')
ax1.set_xlabel('Number of Events as a percentage of Total LPs')
ax1.set_ylabel('Number of Sim Cycles said Percentage Occurs')
# ax1 = pylab.gca()
ax1.get_xaxis().set_major_formatter(mpl.ticker.FuncFormatter(toPercent))
# ax.get_yaxis().set_major_formatter(mpl.ticker.FormatStrFormatter('%.1f%%'))
ax2=ax1.twinx()
ax2.hist(trimmedData, bins=100, histtype='stepfilled')
ax2.set_ylabel('Percent of Simulation Cycles')
ax2.yaxis.set_major_formatter(mpl.ticker.FuncFormatter(toPercentOfTotalSimCycles))
display_graph(outFile)
# ok, let's present the histogram data using pandas series/value_counts. much nicer plot.
fig, ax1 = pylab.subplots()
outFile = outDir + 'eventsAvailableBySimCycle-histogram-dual'
pylab.title('Total LPs: %s; ' % "{:,}".format(total_lps) +
'Total Sim Cycles: %s. '% "{:,}".format(len(trimmedData)))
setNumOfSimCycles(len(data)+1)
mean_events_available = np.mean(trimmedData)
data = pd.Series(trimmedData).value_counts()
data = data.sort_index()
x_values = np.array(data.keys())
y_values = np.array(data)
ax1.plot(x_values, y_values)
ax1.set_xlabel('Number of Events (Ave=%.2f)' % mean_events_available)
ax1.set_ylabel('Number of Simulation Cycles')
ax2=ax1.twinx()
ax2.plot(x_values, y_values)
ax2.set_ylabel('Percent of Simulation Cycles')
ax2.yaxis.set_major_formatter(mpl.ticker.FuncFormatter(toPercentOfTotalSimCycles))
display_graph(outFile)
return
def analyse_isomirs(iso,outpath=None):
"""Analyse isomiR results in detail"""
if iso is None:
return
if outpath != None:
os.chdir(outpath)
subcols = ['name','read','isoClass','NucVar','total','freq']
iso = iso.sort_values('total', ascending=False)
#filter very low abundance reads
iso = iso[(iso.total>10) & (iso.freq>0.5)]
top = get_top_isomirs(iso)
top.to_csv('srnabench_isomirs_dominant.csv',index=False)
print ('top isomiRs:')
print (top[:20])
print ('%s/%s with only 1 isomir' %(len(top[top.domisoperc==1]),len(top)))
print ('different dominant isomir:', len(top[top.variant!='exact'])/float(len(top)))
print ('mean dom isomir perc:', top.domisoperc.mean())
print
#stats
fig,ax = plt.subplots(1,1)
top.plot('isomirs','total',kind='scatter',logy=True,logx=True,alpha=0.8,s=50,ax=ax)
ax.set_title('no. isomiRs per miRNA vs total adundance')
ax.set_xlabel('no. isomiRs')
ax.set_ylabel('total reads')
fig.savefig('srnabench_isomir_counts.png')
fig,ax = plt.subplots(1,1)
#top.hist('domisoperc',bins=20,ax=ax)
try:
base.sns.distplot(top.domisoperc,bins=15,ax=ax,kde_kws={"lw": 2})
except:
pass
fig.suptitle('distribution of dominant isomiR share of reads')
fig.savefig('srnabench_isomir_domperc.png')
x = iso[iso.name.isin(iso.name[:28])]
bins=range(15,30,1)
ax = x.hist('length',bins=bins,ax=ax,by='name',sharex=True,alpha=0.9)
ax[-1,-1].set_xlabel('length')
fig.suptitle('isomiR length distributions')
fig.savefig('srnabench_isomir_lengths.png')
plt.close('all')
c=iso.variant.value_counts()
#c=c[c>10]
fig,ax = plt.subplots(1,1,figsize=(8,8))
c.plot(kind='pie',colormap='Spectral',ax=ax, labels=None,legend=True,
startangle=0,pctdistance=1.1,autopct='%.1f%%',fontsize=10)
ax.set_title('isomiR class distribution')
plt.tight_layout()
fig.savefig('srnabench_isomir_classes.png')
iso.to_csv('srnabench_isomirs_all.csv',index=False)
return top
def GenomeChromosomewise(df, candSNPs=None, genes=None, axes=None,outliers=None):
markerSize = 6
fontsize = 6
chrsize = df.reset_index().groupby('CHROM').POS.max()
if axes is None:
if chrsize.shape[0]>1:
_, axes = plt.subplots(int(np.ceil(chrsize.shape[0] / 2.)), 2, sharey=True, dpi=200, figsize=(10, 6));
ax = axes.reshape(-1)
else:
ax = [plt.subplots(1,1, sharey=True, dpi=200, figsize=(10, 6))[1]]
for j, (chrom, a) in enumerate(df.groupby(level=0)):
if candSNPs is not None:
try:
candSNPs.loc[chrom]
for pos in candSNPs.loc[chrom].index.values:
ax[j].axvline(pos, color='r', linewidth=0.5, alpha=0.5)
ax[j].annotate(
'{:.0f},{:.2f}'.format(candSNPs['rank'].loc[(chrom, pos)], candSNPs.nu0.loc[(chrom, pos)]),
xy=(pos, a.max()), xytext=(pos, a.max()), fontsize=fontsize - 2)
except:
pass
if genes is not None:
try:
X = genes.loc[chrom]
if len(genes.loc[chrom].shape) == 1:
X = pd.DataFrame(X).T
for _, row in X.iterrows():
ax[j].fill_between([row.start, row.end], a.min(), a.max(), color='r')
ax[j].annotate(row['name'], xy=(row.start, a.max()), xytext=(row.start, a.max()),
fontsize=fontsize - 2)
except:
pass
ax[j].scatter(a.loc[chrom].index, a.loc[chrom], s=markerSize, alpha=0.8, edgecolors='none')
if outliers is not None:
try:
ax[j].scatter(outliers.loc[chrom].index, outliers.loc[chrom], s=markerSize, c='r', alpha=0.8, edgecolors='none')
except:
pass
setSize(ax[j], fontsize)
ax[j].set_xlim([-1000, chrsize[chrom] + 1000])
# ax[j].set_title(chrom, fontsize=fontsize+2)
annotate(chrom, ax=ax[j],fontsize=fontsize+4)
ax[j].locator_params(axis='x', nbins=10)
plt.tight_layout(pad=0.1)
plt.gcf().subplots_adjust(bottom=0.1)
def PCA(df, variable_col, sample_col, value_col, pcx=1, pcy=2, point_label=False, plot_style="ggplot", **kwargs):
"""
Plot a the frequence of contribution to the variance of the principal components from a dataframe in “stacked” or “record” format.
Use matplotlib PCA implementation
* df
A pandas dataframe with a least the 3 following columns:
- variable_col = column containing variable identifiers (such as gene identifiers)
- sample_col = column containing sample identifiers (such as experimental condition)
- value_col = column containing quantitative numeric values
* variable_col
Name or index of the column containing variable identifiers
* sample_col
Name or index of the column containing sample identifiers
* value_col
Name or index of the column containing values
* pcx
Number of the component to plot on the x axis [ DEFAULT: 1 ]
* pcy
Number of the component to plot on the y axis [ DEFAULT: 2 ]
* point_label
If True the points will be labelled with their names
* plot_style
Default plot style for pyplot ('grayscale'|'bmh'|'ggplot'|'dark_background'|'classic'|'fivethirtyeight'...)[ DEFAULT: "ggplot" ]
* kwargs
Additional parameters for plot appearance derived from pylab basic plot arguments such as: title, color, alpha, fontsize, fontname, linewidths
"""
# pivot data to reorganize df
df = df.pivot(index=variable_col, columns=sample_col, values=value_col)
# Perform PCA analysis
pca_res = pl.mlab.PCA(df, standardize=True)
# Prepare plotting area and parameters
figsize = kwargs["figsize"] if "figsize" in kwargs else [10, 10]
fig, ax = pl.subplots(figsize=figsize)
pl.style.use(plot_style)
fontsize = kwargs["fontsize"] if "fontsize" in kwargs else 10
fontname = kwargs["fontname"] if "fontname" in kwargs else "Sans"
color = kwargs["color"] if "color" in kwargs else "black"
alpha = kwargs["alpha"] if "alpha" in kwargs else 1
linewidths = kwargs["linewidths"] if "linewidths" in kwargs else 3
# Extract data and plot it
df_res = pd.DataFrame(data=np.array(pca_res.Wt), index=pca_res.a.columns, columns=range(1, len(pca_res.a.columns)+1))
ax.scatter(df_res[pcx], df_res[pcy], linewidths=linewidths, edgecolor=color, color=color, alpha=alpha)
if point_label:
for name, val in df_res.iterrows():
ax.text(x=val[pcx], y=val[pcy], s=name, horizontalalignment="center", fontsize = fontsize-2, fontname=fontname)
ax.set_xlabel("PC{} ({}%)".format(pcx, round(pca_res.fracs[pcx-1]*100, 2)))
ax.set_ylabel("PC{} ({}%)".format(pcy, round(pca_res.fracs[pcy-1]*100, 2)))
ax.set_title(kwargs["title"] if "title" in kwargs else "Principal component PC{}/PC{}".format(pcx, pcy))
# Fontsize and fontname
for item in ([ax.title, ax.xaxis.label, ax.yaxis.label] + ax.get_xticklabels() + ax.get_yticklabels()):
item.set_fontsize(fontsize)
item.set_fontname(fontname)
return (df_res)
def plot_network_activity(self,
stimulus_input=None,
nb_stddev=1.,
ax_handle=None):
'''
Plot the activity of the network to a specific stimulus.
TODO This really should depend on the type of the population code...
'''
if stimulus_input is None:
stimulus_input = self.default_stimulus_input
# Get the network response
activity = self.get_network_response(stimulus_input)
# Plot it
if ax_handle is None:
f, ax_handle = plt.subplots()
ax_handle.plot(activity)
ax_handle.set_xlabel('Neuron')
ax_handle.set_ylabel('Activity')
plt.show()
def matshowN(array, axis=None, titles=None, matshow_kw=dict(), subplot_kw=dict(frame_on=False), **kwargs):
''' matshowN(array, axis=None, titles=None, subplot_kw=dict(frame_on=False), **kwargs)
Ex: f=matshowN(angle(kum.iG.cint[:]))
f.tight_layout()
basic.graphics.matshowN((residual/stdpha)**2., matshow_kw={'vmin':0, 'vmax':1})
axis: If not specified, uses the axis with minimum elements.
axis=argmin(array.shape)
'''
if axis is None:
axis=np.argmin(array.shape);
num=array.shape[axis];
lw=int(np.ceil(np.sqrt(num)));
f,axarr=P.subplots(lw,lw,sharex='col',sharey='row', subplot_kw=subplot_kw, **kwargs)
array=np.rollaxis(array, axis, 0);
k=0;
for ax in axarr.ravel():
if k >= num:
ax.set_axis_off();
continue
ax.matshow(array[k,:,:], **matshow_kw);
if titles is None:
ax.set_title(str('%d'%k));ax.set_axis_off();
else:
ax.set_title(titles[k]);ax.set_axis_off();
k=k+1;
return f;
def group_plots(ylist, ncols, x = None,
titles = None,
suptitle = None,
ylabels = None,
figsize = None,
sameyscale = True,
order='C',
imkw={}):
import pylab as pl
nrows = np.ceil(len(ylist)/float(ncols))
figsize = ifnot(figsize, (2*ncols,2*nrows))
fh, axs = pl.subplots(int(nrows), int(ncols),
sharex=True,
sharey=bool(sameyscale),
figsize=figsize)
ymin,ymax = data_range(ylist)
axlist = axs.ravel(order=order)
for i,f in enumerate(ylist):
x1 = ifnot(x, range(len(f)))
_im = axlist[i].plot(x1,f,**imkw)
if titles is not None:
pl.setp(axlist[i], title = titles[i])
if ylabels is not None:
pl.setp(axlist[i], ylabel=ylabels[i])
if suptitle:
pl.suptitle(suptitle)
return
def printHeatMap(marginals, words, outFile):
N = len(words)
words_uni = [i.decode('UTF-8') for i in words]
heatmap = np.zeros((N+1, N+1))
for chart in marginals:
heatmap[chart[0], chart[1]] = math.log(marginals[chart])
fig, ax = plt.subplots()
mask = np.tri(heatmap.shape[0], k=0)
heatmap = np.ma.array(heatmap, mask=mask)
cmap = plt.cm.get_cmap('RdBu')
cmap.set_bad('w')
im = ax.pcolor(heatmap, cmap=cmap, alpha=0.8)
font = mpl.font_manager.FontProperties(fname='/usr0/home/avneesh/spectral-scfg/data/wqy-microhei.ttf')
ax.grid(True)
ax.set_ylim([0,N])
ax.invert_yaxis()
ax.set_yticks(np.arange(heatmap.shape[1]-1)+0.5, minor=False)
ax.set_yticklabels(words_uni, minor=False, fontproperties=font)
ax.set_xticks(np.arange(heatmap.shape[0])+0.5, minor=True)
ax.set_xticklabels(np.arange(heatmap.shape[0]), minor=True)
ax.set_xticks([])
cbar = fig.colorbar(im, use_gridspec=True)
cbar.set_label('ln(sum)')
ax.set_xlabel('Span End')
ax.xaxis.set_label_position('top')
ax.xaxis.tick_top()
plt.ylabel('Span starting at word: ')
plt.tight_layout()
#ax.set_title('CKY Heat Map: Node Marginals')
fig.savefig(outFile)
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 visData(dF="dannyFull.db"):
f, ax = pl.subplots()
m = visBg(ax)
D = sq.connect(dF)
cur = D.cursor()
A = cur.execute(
"""select clg,clat,cluster
from meta
group by clg,clat,cluster"""
)
for w in A:
clg = w[0]
clat = w[1]
x, y = m(clg, clat)
cluster = w[2]
ax.plot(x, y, "s", ms=10, color=pickColor(cluster))
A = cur.execute(
"""select slg,slat
from meta
group by slg,slat"""
)
for w in A:
slg = w[0]
slat = w[1]
x, y = m(slg, slat)
ax.plot(x, y, "b*", ms=20)
ax.plot(-float("inf"), -float("inf"), "b*", label="Servers")
ax.plot(-float("inf"), -float("inf"), "bs", label="Clients")
ax.legend(loc=4)
pl.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 plot(self, theta_a, theta_e, sigma_e, y, klic, N, T, D):
# Set up an output figure
fig, ax = pylab.subplots(3, 1)
colours = ['b', 'g', 'r', 'c', 'm', 'y']
# Plot smoothed densities
for i in xrange(D):
# Plot original theta values
ax[0].plot(theta_a[:, i], ls='--', c=colours[i%len(colours)])
# Plot data-estimated theta values
ax[0].plot(theta_e[:,i], ls='-', c=colours[i%len(colours)])
# Plot data-estimated confidence intervals
ax[0].fill_between(numpy.arange(T),
theta_e[:,i] - 2*numpy.sqrt(sigma_e[:,i,i]),
theta_e[:,i] + 2*numpy.sqrt(sigma_e[:,i,i]),
color=colours[i%len(colours)], alpha=.25)
ax[1].plot(y[:,i], c=colours[i%len(colours)], ls='-')
# Set axes labels and legends
ax[0].set_ylabel('Theta')
ax[0].set_title('Smoothed densities')
ax[1].set_title('Observed pattern rates')
ax[1].set_ylabel('Rate (patterns/second)')
ax[2].set_title('KL Divergence')
ax[2].set_ylabel('Bits')
ax[2].plot(klic)
ax[2].set_xlabel('Time (ms)')
fig.tight_layout()
pylab.show()
def errorVis(e, t):
f, ax = pl.subplots(1)
ax.boxplot(e, widths=0.15)
ax.set_xticks([1, 2])
ax.set_xticklabels(t)
ax.set_ylabel("Error in km", fontsize=20)
pl.show()
def help_dcols():
""" Show a plot demonstrating all the colours """
from pylab import figure,clf,subplots,show
from matplotlib.patches import Rectangle
fig, axes = subplots(4,3)
i=0
print(axes)
for axA in axes:
for ax in axA:
patch = Rectangle([0,0],1,1,color=cols[i])
ax.add_patch(patch)
ax.set_xticks([])
ax.set_yticks([])
ax.set_xticklabels([])
ax.set_yticklabels([])
if colname[i] is not 'd_black':
ax.text(0.2,0.4,colname[i],color='k')
else:
ax.text(0.2,0.4,colname[i],color='w')
i+=1
fig.subplots_adjust(bottom=0.25,left=0.03,right=0.98,top=0.98,wspace=0.05,hspace=0.05)
fig.text(0.08,0.18,'To use: from durhamcolours import *')
fig.text(0.08,0.12,'then e.g. ax.plot(x,y,colour=d_olive)')
fig.text(0.08,0.06,"Note: no parentheses i.e. d_olive not 'd_olive'")
fig.savefig('durhamcolors.png')
fig.savefig('durhamcolors.pdf')
show()
def plot_calibration(self):
"""Plots the calibration function and data
Arguments
------------
cal: calibration instance
Returns
------------
figure
axes
calibration data graph
calibration function graph
"""
cal_function = self.calibrationFunction
bin_no = np.logspace(np.log10(self.data.bin_no.min()), np.log10(self.data.bin_no.max()), 500)
d = cal_function(bin_no)
f, a = plt.subplots()
cal_data, = a.plot(self.data.d, self.data.bin_no, 'o', label='data',)
cal_func, = a.plot(d, bin_no, label='function')
a.loglog()
a.set_xlim(0.9*self.data.d.min(), 1.1*self.data.d.max())
a.set_xlabel('Diameter (nm)')
a.set_ylim(0.9*self.data.bin_no.min(), 1.1*self.data.bin_no.max())
a.set_ylabel('bin number')
a.set_title('Calibration curve')
a.legend(loc = 2)
return f, a, cal_data, cal_func
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 plot_basis_from_samp(self, b_samp, ax=None):
""" approximate log like is just independent poissons """
B = self._beta_to_basis(b_samp)
#B /= self._dx
#B, W = self._vec_to_basis_weights(th)
if self._xdim==1:
if ax is None:
f = plt.figure()
plt.plot(self._grids[0], B.T)
plt.title('Basis')
plt.xlabel('space')
else:
ax.plot(self._grids[0], B.T)
ax.set_title("Basis")
ax.set_xlabel("X space")
elif self._xdim==2:
if ax is None:
fig, ax = plt.subplots(self._K)
for k in range(self._K):
ax[k].imshow( B[k].reshape(self._xgrid_dims).T,
origin = 'lower',
extent = self._xbbox[0]+self._xbbox[1] )
ax[k].set_title("Spatial basis, $B_%d$"%k)
else:
raise NotImplementedError
def game():
tick = 0
state = [[(list(), list()) for x in range(3)] for y in range(3)]
red_hq = HQ(TEAM.RED, 1, 0)
blue_hq = HQ(TEAM.BLUE, 1, 2)
state[0][1][TEAM.RED].append(red_hq)
state[2][1][TEAM.BLUE].append(blue_hq)
red_player_ai = RedPlayerAI(red_hq)
blue_player_ai = BluePlayerAI(blue_hq)
fig, (state_view, progress) = pl.subplots(2, 1)
while True:
if red_player_ai.hq.hp <= 0 and blue_player_ai.hq.hp <= 0:
return RESULT.DRAW
elif red_player_ai.hq.hp <= 0:
return RESULT.BLUE_WIN
elif blue_player_ai.hq.hp <= 0:
return RESULT.RED_WIN
print "R", red_player_ai.money, red_hq.hp
print "B", blue_player_ai.money, blue_hq.hp
state = red_player_ai.act(state)
state = blue_player_ai.act(state)
state = group_ai(state)
state = update(state)
red_player_ai.money += 1
blue_player_ai.money += 1
state = update(state)
draw(state_view, progress, state, tick)
tick += 1
def get_canva_genome(self) :
# plot_canva
figure, ax = plt.subplots()
addValue = 0
xticks_positions = []
chronames = []
for chromosome, dataPosi in sorted(self.data.iteritems(), key = lambda x : (len(x[0]), x[0])) :
chronames.append(chromosome)
x, y = [], []
maxposi = 0
for posi, snp in sorted(dataPosi.iteritems(), key = lambda x : x[0]) :
genome_posi = posi + addValue
snp.set_genome_posi(genome_posi)
x.append(genome_posi)
y.append(snp.abhet)
maxposi = posi if posi > maxposi else posi
ax.plot(x, y, 'o', markersize=4)
xticks_positions.append((addValue * 2 + maxposi) / 2.0)
addValue += maxposi
ax.set_xlim([0, addValue])
ax.set_xticks(xticks_positions)
ax.set_xticklabels(chronames)
canva = MplCanva(self, None, figure, ax)
canva.mpl_connect('button_press_event', self.click_pressed_genome)
self.adjust_layout()
return canva
def plotFitResult(fit, show_legend=True, show_plots=True, save_to_file=False,
foldername='', filename='', filetype='png'):
xvals = fit.xvals
yvals = fit.yvals
fit = fit.fitValues(xvals)
fig, ax = plt.subplots(1)
ax.plot(xvals, yvals, label='histogram', linewidth=3)
for n, f in enumerate(fit):
ax.plot(xvals, f, label='peak %i' % (n + 1), linewidth=6)
l2 = ax.legend(loc='upper center', bbox_to_anchor=(0.7, 1.05),
ncol=3, fancybox=True, shadow=True)
l2.set_visible(show_legend)
plt.xlabel('pixel value')
plt.ylabel('number of pixels')
if save_to_file:
p = PathStr(foldername).join(filename).setFiletype(filetype)
plt.savefig(p)
with open(PathStr(foldername).join('%s_params.csv' % filename), 'w') as f:
f.write('#x, #y, #fit\n')
for n, (x, y, ys) in enumerate(zip(xvals, yvals)):
fstr = ', '.join(str(f[n]) for f in fit)
f.write('%s, %s, %s\n' % (x, y, fstr))
if show_plots:
plt.show()
cy, cx = np.where(img_45ghz == np.max(img_45ghz))
cy += 1
cx += 0 #Small adjustments
print(
'Image 45 GHz --> center cy,cx: ({}, {})'.format(cy, cx) +
', position angle:', (90 + angle.value % 360) * u.deg)
xx = np.linspace(0, 25, 1000)
yy = xx**2 / 17
xx_, yy_ = np.dot([[np.cos(angle), np.sin(angle)],
[-np.sin(angle), np.cos(angle)]], [xx, yy])
xx2_, yy2_ = np.dot([[np.cos(angle), np.sin(angle)],
[-np.sin(angle), np.cos(angle)]], [-xx, yy])
fig, ax = pl.subplots(ncols=2, figsize=(10, 4))
ax[0].set_title('Model - 45 GHz')
ax[0].imshow(img_45ghz, origin='lower', interpolation='none')
ax[0].plot(xx_ + cx, yy_ + cy, linewidth=0.5, color='w', linestyle='--')
ax[0].plot(xx2_ + cx, yy2_ + cy, linewidth=0.5, color='w', linestyle='--')
data_on_path = img_45ghz[(yy_ + cy).astype('int'), (xx_ + cx).astype('int')]
data_on_path2 = img_45ghz[(yy2_ + cy).astype('int'), (xx2_ + cx).astype('int')]
prj_dist = (xx**2 + yy**2)**0.5
ax[1].plot(prj_dist, data_on_path, label='left arm')
ax[1].plot(prj_dist, data_on_path2, label='right arm')
core = data_on_path[:10].mean()
"""
profile = (core*(prj_dist/prj_dist[250])**-0.1 * (prj_dist >= prj_dist[250])/10.
+ core * (1-(prj_dist/prj_dist[580])**2) * (prj_dist<=prj_dist[580])
def parse_sub_skyline(skyline_sub_df,
sample,
q_value=0.05,
isotope='light',
IO=True,
output_file=None):
'''
parse_sub_skyline is a helper function to parse a sample and protein filtered skyline dataframe such that a properly
sorted and labeled dataframe is output
:param skyline_sub_df: pandas dataframe with only one sample injection and only those proteins of interest
:param sample: string of injection sample name
:param q_value: float with a optional q_value cutoff to filter your data (default 0.05)
:param isotope: string for filtering output dataframe such that columns from a particular isotope type are included (default 'light')
:param IO: bool determining if you want to display output (number of peptides, plots of filtering)
:param output_file: string determining if you want to write the dataframe to disk (default None won't write to disk)
:return: a pandas dataframe with no index, columns of peptide_modified_sequence, rt_start (seconds), rt_end (seconds), charge,
mz [note that this may only be approxiamate for modified peptides], protein_IDs
'''
if IO:
print('++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++')
print('reading peptides from skyline dataframe ' + sample)
#generate pandas file, filter, parse peptides, save encyc_rts values, save charge values, calculate mz, save proteins
filt_entries = skyline_sub_df.loc[skyline_sub_df[
isotope + ' ' + sample + ' ' + DETECT_Q_VALUE_FIELD] < q_value]
peptides = [i for i in filt_entries[PEPTIDE_MOD_SEQ_FIELD]]
rts_start = [
round(t, 2)
for t in filt_entries[isotope + ' ' + sample + ' ' + RT_START_FIELD]
]
#print(isotope+' '+sample+' '+RT_START_FIELD)
rts_end = [
round(t, 2)
for t in filt_entries[isotope + ' ' + sample + ' ' + RT_END_FIELD]
]
zs = [i for i in filt_entries[PEPTIDE_CHARGE_FIELD]]
prot_names = [i for i in filt_entries[PROTEIN_FULL_NAME_FIELD]]
mzs = [mz for mz in filt_entries[isotope + ' ' + ISOTOPE_FIND_FIELD]]
#calc number of used peptides, and make sure all the arrays are the same size
used_peptides = len(peptides)
assert used_peptides == len(rts_start)
assert used_peptides == len(rts_end)
assert used_peptides == len(zs)
assert used_peptides == len(prot_names)
assert used_peptides == len(mzs)
#make a dataframe with your newly calculated entries
pandas_dataframe = pd.DataFrame({
peptides[i]: {
'peptide_modified_sequence': peptides[i],
'rt_start': rts_start[i],
'rt_end': rts_end[i],
'charge': zs[i],
'mz': mzs[i],
'protein_IDs': prot_names[i]
}
for i in range(used_peptides)
}).T
pandas_dataframe = pandas_dataframe.sort_values(by=['rt_start'])
# show plots for q-value criteria
if IO:
skyline_sub_df.rename(columns={
isotope + ' ' + sample + ' ' + DETECT_Q_VALUE_FIELD:
'q-value'
},
inplace=True)
print(str(skyline_sub_df.shape[0]) + ' peptides identified')
print(str(len(peptides)) + ' peptides meet q-value criteria')
print(
str(skyline_sub_df.shape[0] - len(peptides)) +
' peptides fail q-value criteria')
fig, ax = pylab.subplots(
) # create a new figure with a default 111 subplot
ax.hist(skyline_sub_df['q-value'].dropna(), bins=100)
ax.vlines([q_value],
0,
ax.get_ylim()[1],
colors='red',
linestyle='dashed',
label='q-cuttoff')
#axins = zoomed_inset_axes(ax, 2, loc=1) # zoom-factor: 2.5, location: upper-left
#axins.hist(skyline_sub_df['q-value'].dropna(), bins=100)
#axins.set_xlim(0, q_value*2) # apply the x-limits
#axins.set_ylim(0, ax.get_ylim()[1]/4) # apply the x-limits
#axins.vlines([q_value], 0, ax.get_ylim()[1]/4, colors='red', linestyle='dashed', label='q-cuttoff')
#mark_inset(ax, axins, loc1=2, loc2=4, fc="none", ec="0.5")
ax.set_xlabel('q-value')
ax.set_ylabel('peptides')
pylab.show()
print('++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++')
#return the sorted dataframe
return pandas_dataframe
def anaRes(boardID, runstart, runstop):
# Read file
a = np.loadtxt('caliboutput_b{0}_R{1}R{2}.txt'.format(
boardID, runstart, runstop))
att = a[0, :]
mm = np.empty([len(att), 3])
emm = np.empty([len(att), 3])
for k in range(3):
mm[:, k] = a[2 * k + 1, :]
emm[:, k] = a[2 * k + 2, :]
sel = np.where((att > 100) & (att < 200)) #Fit range
a = 0.25
b = -63.5 - 7 #2*3.3dB attenuator insertion loss
attdB = att * a + b # ideal: att = 0dB for att=127 on both attenuators
vin = 0.262 / 2 * pow(
10, attdB / 20
) # 10^(attdB/20) attenuation & factor 1/2 because of 3 channels split
fig, (ax1, ax2) = pl.subplots(2, 1)
for k in range(3):
#pl.subplot(211)
ax1.plot(attdB,
mm[:, k],
'o',
markersize=6,
label='Channel {0}'.format(k))
#z = np.polyfit(att[sel],mm[sel,k][0],1) # Linear fit
#print 'Channel',k,', slope=',z[0],'LSB/dB Att coef'
#yth = att*z[0]+z[1]
#pl.plot(att,yth,'y--')
#pl.subplot(2,1,2)
ax2.plot(attdB,
emm[:, k],
'o',
markersize=6,
label='Channel {0}'.format(k))
#pl.subplot(2,1,1)
ax1.grid(True)
#ax1.set_xlabel('$\Sigma$attenuation indexes')
ax1.set_xlabel('Signal attenuation (dB)')
ax1.set_ylabel('Mean output level (V)')
ax1.legend(loc='best')
#ax2.subplot(2,1,2)
ax2.grid(True)
ax2.set_xlabel('Signal attenuation (dB)')
#ax2.set_xlabel('$\Sigma$attenuation indexes')
ax2.set_ylabel('StdDev (V)')
ax2.legend(loc='best')
# Now load external calib data Inout = 66MHz+100mV sine wave + att = 30dB + splitter
if 0:
f = np.loadtxt('calibExt.txt')
runex = f[:, 0]
boardex = f[:, 1]
selex = np.where(boardex == int(boardID))[0]
Vinex = f[selex, 2] * 0.001 # mV==>V
Vindaq = Vinex * pow(
10, -30. / 20) * 0.5 # Now apply attenuation (attenuator+splitter)
mex = np.empty([len(selex), 3])
emex = np.empty([len(selex), 3])
for k in range(3):
mex[:, k] = f[selex, 3 + 2 * k]
emex[:, k] = f[selex, 3 + 2 * k + 1]
for k in range(3):
z = np.polyfit(attdB[sel], mm[sel, k][0], 1) # Linear fit
yth = attdB * z[0] + z[1]
#pl.subplot(2,1,1)
fig = pl.figure(12)
pl.errorbar(attdB,
mm[:, k],
yerr=emm[:, k],
lw=2,
label='Channel {0}'.format(k))
pl.plot(attdB, yth, 'y')
print('Channel', k, ', slope=', z[0], 'V/dB')
fig3 = pl.figure(13)
sind = k + 1
sbp2 = pl.subplot(3, 1, sind)
sbp2.set_xscale('log')
pl.errorbar(vin,
mm[:, k],
yerr=emm[:, k],
lw=2,
label='Channel {0}'.format(k))
pl.errorbar(Vindaq,
mex[:, k],
yerr=emex[:, k],
lw=2,
label='ExtSin - Channel {0}'.format(k))
pl.grid(True)
if k == 2:
pl.xlabel('Signal amplitude @ channel input [Vpp]')
pl.ylabel('Mean output level [V]')
pl.legend(loc='best')
pl.figure(12)
pl.title('Board {0} R{1}-{2}'.format(boardID, runstart, runstop))
pl.xlabel('Quartz signal attenuation [dB]')
pl.ylabel('Mean output level [V]')
pl.legend(loc='best')
pl.figure(12)
pl.title('Board {0} R{1}-{2}'.format(boardID, runstart, runstop))
pl.show()
import pylab as pl
iris = datasets.load_iris()
km = KMeans(n_clusters=3)
km.fit(iris.data)
predictions = km.predict(iris.data)
colors = cycle('rgb')
labels = ["Cluster 1", "Cluster 2", "Cluster 3"]
targets = range(len(labels))
feature_index = range(len(iris.feature_names))
feature_names = iris.feature_names
combs = combinations(feature_index, 2)
f, axarr = pl.subplots(3, 2)
axarr_flat = axarr.flat
for comb, axflat in zip(combs, axarr_flat):
for target, color, label in zip(targets, colors, labels):
feature_index_x = comb[0]
feature_index_y = comb[1]
axflat.scatter(iris.data[predictions == target, feature_index_x],
iris.data[predictions == target, feature_index_y],
c=color,
label=label)
axflat.set_xlabel(feature_names[feature_index_x])
axflat.set_ylabel(feature_names[feature_index_y])
pl.show()
drt_l_mean = np.array(drt_l_mean)
drt_u_std = np.array(drt_u_std)
drt_l_std = np.array(drt_l_std)
residuals_u = (drt_u_mean - drt_in) / drt_u_std
residuals_l = (drt_l_mean - drt_in) / drt_l_std
##- Setup figures
plt.ion()
plt.rcParams.update({'font.size': 14})
colors = [
'#396AB1', '#DA7C30', '#3E9651', '#CC2529', '#535154', '#6B4C9A',
'#922428', '#948B3D'
]
##- Plot bias figure
fig, ax = plt.subplots(nrows=2, ncols=1, figsize=(8, 8))
fig.subplots_adjust(hspace=0.5)
ax[0].set_title(
fr'$\Delta r$, 1000000 realisations, rt={rt_in}, rp={rp_in}')
ax[0].plot(drt_in, drt_in, color=colors[4], ls=':')
ax[0].errorbar(drt_in,
drt_u_mean,
yerr=drt_u_std,
color=colors[0],
marker='o',
markeredgecolor=colors[0],
fmt='.',
capsize=5,
elinewidth=2,
markeredgewidth=2,
label=r'Unlensed $\xi$')
###############################################################################
# Plot pseudosection for 10 Hz
import reda.plotters.pseudoplots as PS
data_10hz = g.get_group(10)
fig, ax, cb = PS.plot_pseudosection_type2(data_10hz, column='r', log10=True)
fig, ax, cb = PS.plot_pseudosection_type2(data_10hz, column='rpha')
###############################################################################
# Plot pseudosections of all frequencies
import reda.plotters.pseudoplots as PS
import pylab as plt
with reda.CreateEnterDirectory('output_radic'):
fig, axes = plt.subplots(7,
2,
figsize=(15 / 2.54, 25 / 2.54),
sharex=True,
sharey=True)
for ax, (key, item) in zip(axes.flat, g):
fig, ax, cb = PS.plot_pseudosection_type2(item,
ax=ax,
column='r',
log10=True)
ax.set_title('f: {} Hz'.format(key))
fig.subplots_adjust(
hspace=1,
wspace=0.5,
right=0.9,
top=0.95,
)
fig.savefig('pseudosections_radic.pdf')
def plot(self,
offset=[0, 0, 0, 0],
airmassfct=True,
move_max=True,
legend=True,
all_on_one_axis=False,
additional_axes=False,
errors=False,
rayleigh=True):
"""plots ... sorry, but this is a messi function. Things should have been done different, e.g too much data
processing whith the data not put out ... need fixn
Arguments
---------
offset: list
airmassfct: bool.
If the airmass factor is included or not.
True: naturally the air-mass factor is included in the data, so this does nothing.
False: data is corrected to correct for the slant angle
rayleigh: bool or the aod part of the output of miniSASP.simulate_from_size_dist_LS.
make sure there is no airmassfkt included in this!!
all_on_one_axis: bool or axes instance
if True all is plotted in one axes. If axes instances this axis is used.
"""
m_size = 5
m_ewidht = 1.5
l_width = 2
gridspec_kw = {'wspace': 0.05}
no_axes = 4
if all_on_one_axis:
no_axes = 1
if additional_axes:
no_axes = no_axes + additional_axes
if type(all_on_one_axis).__name__ == 'AxesSubplot':
a = all_on_one_axis
f = a.get_figure()
else:
f, a = plt.subplots(1, no_axes, gridspec_kw=gridspec_kw)
columns = [
'460.3', '460.3 max', '550.4', '550.4 max', '671.2', '671.2 max',
'860.7', '860.7 max'
]
# peaks_max = [460.3, '460.3 max', 550.4, '550.4 max', 860.7, '860.7 max', 671.2,
# '671.2 max']
if not all_on_one_axis:
f.set_figwidth(15)
#################
for i in range(int(len(columns) / 2)):
col = plt_tools.wavelength_to_rgb(columns[i * 2]) * 0.8
intens = self.data[columns[i * 2]].dropna(
) # .plot(ax = a, style = 'o', label = '%s nm'%colums[i*2])
x = intens.index.get_level_values(1)
if type(rayleigh) == bool:
if rayleigh:
rayleigh_corr = 0
else:
# print('mach ick')
aodt = rayleigh[float(columns[i * 2])].loc[:, ['rayleigh']]
intenst = intens.copy()
intenst.index = intenst.index.droplevel(
['Time', 'Sunelevation'])
aodt_sit = pd.concat([aodt,
intenst]).sort_index().interpolate()
aodt_sit = aodt_sit.groupby(aodt_sit.index).mean().reindex(
intenst.index)
rayleigh_corr = aodt_sit.rayleigh.values / np.sin(
intens.index.get_level_values(2))
# return aodt
if not airmassfct:
amf_corr = np.sin(intens.index.get_level_values(2))
else:
amf_corr = 1
if not all_on_one_axis:
atmp = a[i]
else:
atmp = a
y = (offset[i] - np.log(intens) - rayleigh_corr) * amf_corr
g, = atmp.plot(y, x)
g.set_label('%s nm' % columns[i * 2])
g.set_linestyle('')
g.set_marker('o')
# g = a.get_lines()[-1]
g.set_markersize(m_size)
g.set_markeredgewidth(m_ewidht)
g.set_markerfacecolor('None')
g.set_markeredgecolor(col)
if move_max:
# sun_intensities.data.iloc[:,i*2+1].dropna().plot(ax = a)
intens = self.data[columns[i * 2 + 1]].dropna(
) # .plot(ax = a, style = 'o', label = '%s nm'%colums[i*2])
x = intens.index.values
g, = a[i].plot(offset[i] - np.log(intens), x)
# g = a.get_lines()[-1]
g.set_color(col)
# g.set_solid_joinstyle('round')
g.set_linewidth(l_width)
g.set_label(None)
if i != 0 and not all_on_one_axis:
atmp.set_yticklabels([])
if i == 4:
break
if all_on_one_axis:
a.legend()
else:
if legend:
for aa in a:
aa.legend()
if not airmassfct:
txt = 'OD'
else:
txt = 'OD * (air-mass factor)'
if all_on_one_axis:
atmp = a
else:
atmp = a[0]
atmp.set_xlabel(txt)
if not all_on_one_axis:
atmp.xaxis.set_label_coords(2.05, -0.07)
atmp.set_ylabel('Altitude (m)')
return a
man.parman.modify_polygon(pid_mag, polygon, 3)
fig, ax = man.show_parset(pid_mag)
fig.savefig('model_magnitude.jpg')
fig, ax = man.show_parset(pid_pha)
fig.savefig('model_phase.jpg')
man.configs.gen_dipole_dipole(skipc=0)
man.configs.gen_dipole_dipole(skipc=1)
man.configs.gen_dipole_dipole(skipc=2)
import pylab as plt
# conduct forward modeling
rmag_rpha_mod = man.measurements()
fig, axes = plt.subplots(2, 1)
ax = axes[0]
ax.hist(rmag_rpha_mod[:, 0], 100)
ax.set_xlabel('magnitudes')
ax = axes[1]
ax.hist(rmag_rpha_mod[:, 1], 100)
ax.set_xlabel('phases')
fig.savefig('modeled_data.jpg')
# now add syntehtic noise
# TODO
man.save_measurements('volt.dat')
tdman = crtomo.tdMan(grid=grid)
tdman.read_voltages('volt.dat')
tdman.invert()
v_k = -100
v_na = 50
v_l = -67
i_ext = 0.3
t_final = 300
dt = 0.02
# AMPA-like synaptic input pulse
tau_r = 0.5
tau_peak = 0.5
tau_d = 2.0
g_syn = 12
if __name__ == "__main__":
fig, ax = plt.subplots(2, figsize=(7, 5), sharex=True)
tau_d_q = tau_d_q_function(tau_d, tau_r, tau_peak, dt)
x0 = initial_condition(-77.71)
t = np.arange(0, t_final, dt)
sol = rk4_integrator(x0, ode, t, dt)
v = sol[:, 0]
ax[0].plot(t, v, lw=3, c="b", alpha=0.5)
ax[1].plot(t, v, lw=3, c="b", alpha=0.5)
ax[0].set_xlim(min(t), max(t))
ax[0].set_ylim(-100, 50)
ax[1].set_xlabel("time [ms]")
ax[0].set_ylabel("v [mV]")
ax[0].set_yticks(range(-100, 100, 50))
for i in range(2):
o_masl_v = obsgrid_nc.variables['ZS']
o_ta_v = obsgrid_nc.variables['Tair']
o_rr_v = obsgrid_nc.variables['Rainf']
o_sf_v = obsgrid_nc.variables['Snowf']
o_time_v = obsgrid_nc.variables['time']
o_t = o_time_v[:] #netCDF4.num2date(o_time_v[:], o_time_v.units)
o_ta = o_ta_v[:, N]
o_rr = o_rr_v[:, N]
o_sf = o_sf_v[:, N]
#t_width = datetime.timedelta(minutes=30)
width = 0.25
f, axarr = plt.subplots(3, sharex=True)
plt.hold(True)
axarr[0].axhline(273.65, color='k', linestyle="--")
axarr[0].plot(o_t, o_ta, color='r')
axarr[0].plot(a_t, a_ta, color='b')
axarr[0].set_title("OBSGRID coords: {0}, {1}\nAROME coords: {2}, {3}".format(
o_lat_v[N], o_lon_v[N], a_lat_v[N], a_lon_v[N]))
axarr[0].set_ylabel("Temperature")
axarr[1].bar(o_t + width, o_rr, width=width, color='r')
axarr[1].bar(a_t, a_rr, width=width, color='b')
axarr[1].set_ylabel("Rainfall rate")
axarr[2].bar(o_t + width, o_sf, width=width, color='r')
axarr[2].bar(a_t, a_sf, width=width, color='b')
axarr[2].set_ylabel("Snowfall rate")
# In[ ]:
# Instantiate solver
solver = TSPSolver.from_data(cities.X, cities.Y, norm="EUC_2D")
t = time.time()
tour_data = solver.solve(
time_bound=60.0, verbose=True, random_seed=42
) # solve() doesn't seem to respect time_bound for certain values?
print(time.time() - t)
print(tour_data.found_tour)
# In[ ]:
pd.DataFrame({
'Path': np.append(tour_data.tour, [0])
}).to_csv('submission.csv', index=False)
# In[ ]:
# Plot tour
lines = [[(cities.X[tour_data.tour[i]], cities.Y[tour_data.tour[i]]),
(cities.X[tour_data.tour[i + 1]], cities.Y[tour_data.tour[i + 1]])]
for i in range(0,
len(cities) - 1)]
lc = mc.LineCollection(lines, linewidths=2)
fig, ax = pl.subplots(figsize=(20, 20))
ax.set_aspect('equal')
ax.add_collection(lc)
ax.autoscale()
output = signal.convolve(sig.prueba_Dataset, lowpass_coef, mode='same')
###Filtro pasa banda###
f1, f2 = 8, 19
bandpass_coef = signal.firwin(19, [f1, f2],
pass_zero=False,
nyq=100,
window='nuttall') #pasa banda
output_pb = signal.convolve(sig.prueba_Dataset, bandpass_coef, mode='same')
###Filtro rechaza banda###
f1, f2 = 8, 19
bandpass_coef = signal.firwin(19, [f1, f2],
pass_zero=True,
nyq=100,
window='nuttall') #pasa banda
output_rb = signal.convolve(sig.prueba_Dataset, bandpass_coef, mode='same')
##Graficas filtros
f, plt_arr = plt.subplots(5, sharex=True)
plt_arr[0].plot(sig.prueba_Dataset, color='blue')
plt_arr[0].set_title('señal de entrada', color='blue')
plt_arr[1].plot(output, color='red')
plt_arr[1].set_title('señal filtrada pasa bajos', color='red')
plt_arr[2].plot(output_pa, color='green')
plt_arr[2].set_title('señal filtrada pasa altos', color='green')
plt_arr[3].plot(output_pb, color='black')
plt_arr[3].set_title('Señal filtrada pasa banda', color='black')
plt_arr[4].plot(output_rb, color='navy')
plt_arr[4].set_title('Señal filtrada rechaza banda', color='navy')
plt.show()
def dovis(my_data, n):
pylab.clf()
pylab.rc("font", size=10)
u = my_data.get_var("x-velocity")
v = my_data.get_var("y-velocity")
myg = my_data.grid
fig, axes = pylab.subplots(nrows=2, ncols=2, num=1)
pylab.subplots_adjust(hspace=0.25)
# x-velocity
ax = axes.flat[0]
img = ax.imshow(numpy.transpose(u[myg.ilo:myg.ihi + 1,
myg.jlo:myg.jhi + 1]),
interpolation="nearest",
origin="lower",
extent=[myg.xmin, myg.xmax, myg.ymin, myg.ymax])
ax.set_xlabel("x")
ax.set_ylabel("y")
ax.set_title("x-velocity")
pylab.colorbar(img, ax=ax)
# y-velocity
ax = axes.flat[1]
img = ax.imshow(numpy.transpose(v[myg.ilo:myg.ihi + 1,
myg.jlo:myg.jhi + 1]),
interpolation="nearest",
origin="lower",
extent=[myg.xmin, myg.xmax, myg.ymin, myg.ymax])
ax.set_xlabel("x")
ax.set_ylabel("y")
ax.set_title("y-velocity")
pylab.colorbar(img, ax=ax)
# vorticity
ax = axes.flat[2]
vort = myg.scratch_array()
vort[myg.ilo:myg.ihi+1,myg.jlo:myg.jhi+1] = \
0.5*(v[myg.ilo+1:myg.ihi+2,myg.jlo:myg.jhi+1] -
v[myg.ilo-1:myg.ihi,myg.jlo:myg.jhi+1])/myg.dx - \
0.5*(u[myg.ilo:myg.ihi+1,myg.jlo+1:myg.jhi+2] -
u[myg.ilo:myg.ihi+1,myg.jlo-1:myg.jhi])/myg.dy
img = ax.imshow(numpy.transpose(vort[myg.ilo:myg.ihi + 1,
myg.jlo:myg.jhi + 1]),
interpolation="nearest",
origin="lower",
extent=[myg.xmin, myg.xmax, myg.ymin, myg.ymax])
ax.set_xlabel("x")
ax.set_ylabel("y")
ax.set_title(r"$\nabla \times U$")
pylab.colorbar(img, ax=ax)
# div U
ax = axes.flat[3]
divU = myg.scratch_array()
divU[myg.ilo:myg.ihi+1,myg.jlo:myg.jhi+1] = \
0.5*(u[myg.ilo+1:myg.ihi+2,myg.jlo:myg.jhi+1] -
u[myg.ilo-1:myg.ihi,myg.jlo:myg.jhi+1])/myg.dx + \
0.5*(v[myg.ilo:myg.ihi+1,myg.jlo+1:myg.jhi+2] -
v[myg.ilo:myg.ihi+1,myg.jlo-1:myg.jhi])/myg.dy
img = ax.imshow(numpy.transpose(divU[myg.ilo:myg.ihi + 1,
myg.jlo:myg.jhi + 1]),
interpolation="nearest",
origin="lower",
extent=[myg.xmin, myg.xmax, myg.ymin, myg.ymax])
ax.set_xlabel("x")
ax.set_ylabel("y")
ax.set_title(r"$\nabla \cdot U$")
pylab.colorbar(img, ax=ax)
pylab.figtext(0.05, 0.0125, "t = %10.5f" % my_data.t)
pylab.draw()
def plot_torque_speed_curve(self,
highlight_power=None,
highlight_torque=None,
highlight_rpm=None,
embed=False,
full_title=True):
x = np.linspace(self.min_rpm, self.max_rpm / self.gear_ratio,
100) # * ureg.tpm
# y1 = np.vectorize(m.torque_continuous)(x)
# y2 = np.vectorize(m.torque_intermittent)(x)
# y1 = [m.torque_continuous(x_) for x_ in x]
# y2 = [m.torque_intermittent(x_) for x_ in x]
y1 = np.array([
self.torque_continuous(x_).to(ureg.newton * ureg.meter).magnitude
for x_ in x
]) * (ureg.newton * ureg.meter)
y2 = np.array([
self.torque_intermittent(x_).to(ureg.newton * ureg.meter).magnitude
for x_ in x
]) * (ureg.newton * ureg.meter)
fig, ax1 = pylab.subplots()
if full_title:
ax1.set_title(self.name + " Torque, Power vs. Speed", fontsize=16.)
else:
ax1.set_title("Torque, Power vs. Speed", fontsize=16.)
ax1.set_xlabel("Speed [RPM]", fontsize=12)
ax1.set_ylabel("Torque [N m]", fontsize=12)
xmin = x[0].magnitude
xmax = x[-1].magnitude
if highlight_rpm is not None:
xmin = min(xmin, highlight_rpm.m * 0.9)
if highlight_rpm is not None:
xmax = max(xmax, highlight_rpm.m * 1.1)
ax1.set_xlim([xmin, xmax])
ax2 = ax1.twinx()
ax2.set_ylabel("Power [W]", fontsize=12)
colors = [
'#aa0000ee', '#00aa00ee', '#ff0000ee', '#00ff00ee', '#aaaa00ee',
'#aa00aaee', '#00aaaaee'
]
lns = []
lns2 = []
lns += ax1.plot(x.magnitude,
y1.magnitude,
color=colors[0],
label='Continuous T')
lns2 += ax2.plot(x.magnitude, (y1 * x / 9.5488).magnitude,
color=colors[1],
label='Continuous P')
if self.torque_intermittent_define:
lns += ax1.plot(x.magnitude,
y2.magnitude,
color=colors[2],
label='Intermittent T')
lns2 += ax2.plot(x.magnitude, (y2 * x / 9.5488).magnitude,
color=colors[3],
label='Intermittent P')
#if highlight_power is not None:
# lns += [ax2.axhline(highlight_power.to('watt').magnitude, color=colors[4], label='Requested P')]
#
# if highlight_torque is not None:
# lns += [ax2.axhline(highlight_rpm.magnitude, color=colors[5], label='Requested T')]
#
# if highlight_rpm is not None:
# lns += [ax2.axvline(highlight_rpm.magnitude, color=colors[6], label='Requested RPM')]
if highlight_rpm is not None and highlight_power is not None:
ax2.scatter([highlight_rpm.magnitude],
[highlight_power.to('watt').magnitude],
label='Requested RPM,P')
ax2.scatter([highlight_rpm.magnitude * .90],
[highlight_power.to('watt').magnitude * .90],
label='90% Requested RPM,P')
ax2.scatter([highlight_rpm.magnitude * 1.10],
[highlight_power.to('watt').magnitude * 1.10],
label='110% Requested RPM,P')
ax1.set_ylim(bottom=0)
ax2.set_ylim(bottom=0)
# labs = [l.get_label() for l in lns]
# ax1.legend(lns, labs, loc='upper left')
# labs = [l.get_label() for l in lns]
ax1.legend(loc='upper left')
ax2.legend(loc='upper right')
fig.tight_layout()
if not embed:
pylab.show()
pylab.close()
return None
else:
import io
pylab.show()
imgdata = io.BytesIO()
pylab.savefig(imgdata, format='png', bbox_inches='tight')
imgdata.seek(0)
img_str = imgdata.getvalue()
pylab.close()
return img_str
for i in range(len(P)):
iself = int(ids[i])
corr = 0.
im1 = iself - 1
if im1 < 0:
im1 = len(P) - 1
corr = 1.
ip1 = iself + 1
if ip1 == len(P):
ip1 = 0
corr = 1.
idxp1 = ids_reverse[ip1]
idxm1 = ids_reverse[im1]
gradP[i] = (P[idxp1] - P[idxm1]) / (coords[idxp1, 0] - coords[idxm1, 0])
fig, ax = pl.subplots(2, 2, sharex=True)
ax[0][0].plot(coords[:, 0], rho, ".", label="gizmo-mfm")
ax[0][0].plot(x, rho_x, "-", label="stable solution")
ax[0][0].set_ylabel("$\\rho{}$ (code units)")
ax[0][0].legend(loc="best")
ax[0][1].plot(x, a, "-", label="$\\nabla{}\\Phi{}$ external")
ax[0][1].plot(coords[:, 0],
gradP / rho,
".",
label="$\\nabla{}P/\\rho{}$ gizmo-mfm")
ax[0][1].set_ylabel("force (code units)")
ax[0][1].legend(loc="best")
ax[1][0].axhline(y=uconst, label="isothermal $u$", color="k", linestyle="--")
import os
#from gatspy.periodic import LombScargleFast
import json
s = json.load(open("fbb_matplotlibrc.json"))
pl.rcParams.update(s)
impath = os.getenv("UIdata") + "/groundtest1/ESB_s119.75*"
img = glob.glob(impath + "*0000.raw")[0]
nrow, ncol = 1530, 2444
#= findsize(img)
nband = 3
print(nrow, ncol)
print(impath)
flist = glob.glob(impath + "*213949*.raw")
print(len(flist))
flist11975 = np.array(flist)[np.argsort(flist)]
print(len(flist))
#print (flist11975)
for i, f in enumerate(flist11975[50:150]):
fig, axs = pl.subplots(1, 1, figsize=(15, 15))
axs.axis('off')
axs.imshow(np.fromfile(f, dtype=np.uint8).reshape(nrow, ncol, nband),
interpolation='none')
axs.set_xlim(0, axs.get_xlim()[1])
axs.set_ylim(axs.get_ylim()[0], 0)
pl.savefig("%s_%02d.png" % (impath[:-1], i), bbox_inches='tight')
def do_solve(maxIter, solver, display, test_interval, test_iters):
# SET PLOTS DATA
train_loss_C = zeros(maxIter / display)
train_top1 = zeros(maxIter / display)
# train_top5 = zeros(maxIter/display)
val_loss_C = zeros(maxIter / test_interval)
val_top1 = zeros(maxIter / test_interval)
# val_top5 = zeros(maxIter/test_interval)
it_axes = (arange(maxIter) * display) + display
it_val_axes = (arange(maxIter) * test_interval) + test_interval
_, ax1 = subplots()
ax2 = ax1.twinx()
ax1.set_xlabel('iteration')
ax1.set_ylabel('train loss C (r), val loss C (y)')
ax2.set_ylabel(
'train TOP1 (b), val TOP1 (g)') # train TOP-5 (c), val TOP-5 (k)')
ax2.set_autoscaley_on(False)
ax2.set_ylim([0, 1])
lossC = np.zeros(maxIter)
acc1 = np.zeros(maxIter)
acc5 = np.zeros(maxIter)
#RUN TRAINING
for it in range(niter):
#st = time.time()
solver.step(1) # run a single SGD step in Caffepy()
#en = time.time()
#print "Time step: " + str((en-st))
#PLOT
if it % display == 0 or it + 1 == niter:
lossC[it] = solver.net.blobs['loss3/loss3'].data.copy()
acc1[it] = solver.net.blobs['loss3/top-1'].data.copy()
# acc5[it] = solver.net.blobs['loss3/top-5'].data.copy()
loss_disp = 'loss3C= ' + str(lossC[it]) + ' top-1= ' + str(
acc1[it])
print '%3d) %s' % (it, loss_disp)
train_loss_C[it / display] = lossC[it]
train_top1[it / display] = acc1[it]
# train_top5[it / display] = acc5[it]
ax1.plot(it_axes[0:it / display], train_loss_C[0:it / display],
'r')
ax2.plot(it_axes[0:it / display], train_top1[0:it / display], 'b')
# ax2.plot(it_axes[0:it / display], train_top5[0:it / display], 'c')
#ax1.set_ylim([0, 10])
plt.title(training_id)
plt.ion()
plt.grid(True)
plt.show()
plt.pause(0.001)
#VALIDATE
if it % test_interval == 0 and it > 0:
loss_val_C = 0
top1_val = 0
# top5_val = 0
for i in range(test_iters):
solver.test_nets[0].forward()
loss_val_C += solver.test_nets[0].blobs['loss3/loss3'].data
top1_val += solver.test_nets[0].blobs['loss3/top-1'].data
# top5_val += solver.test_nets[0].blobs['loss3/top-5'].data
loss_val_C /= test_iters
top1_val /= test_iters
# top5_val /= test_iters
print("Val loss C: {:.3f}".format(loss_val_C))
val_loss_C[it / test_interval - 1] = loss_val_C
val_top1[it / test_interval - 1] = top1_val
# val_top5[it / test_interval - 1] = top5_val
ax1.plot(it_val_axes[0:it / test_interval],
val_loss_C[0:it / test_interval], 'y')
ax2.plot(it_val_axes[0:it / test_interval],
val_top1[0:it / test_interval], 'g')
# ax2.plot(it_val_axes[0:it / test_interval], val_top5[0:it / test_interval], 'k')
#ax1.set_ylim([0, 10])
plt.title(training_id)
plt.ion()
plt.grid(True)
plt.show()
plt.pause(0.001)
title = '../../../datasets/EmotionDataset/models/training/' + training_id + str(
it) + '.png' # Save graph to disk
savefig(title, bbox_inches='tight')
return
import statsmodels.formula.api as smf
mod = smf.ols(formula='starbucks_count ~ new_homes + hotels + HC03_VC88', data=df)
res = mod.fit()
print res.summary()
############################## False positives for logit regression
logit = sm.Logit(sample['has_starbucks'], sample[['new_homes','hotels','HC03_VC88','shopping_centers']])
# fit the model
result = logit.fit()
print result.summary()
sample['predict'] = result.predict(sample[['new_homes','hotels','HC03_VC88','shopping_centers']])
predict = sample[['new_homes','hotels','HC03_VC88', 'HC03_VC96', 'shopping_centers', 'has_starbucks', 'predict', 'zip']]
predict[(predict.has_starbucks==0)&(predict.predict>0.55)].sort_values(['predict'], ascending=[0])
## Correlation matrix
import seaborn as sns
corr = df[['sq_miles', u'HC03_VC96', 'HC03_VC88',
'shopping_centers', 'new_homes', 'hotels',
'population_density', 'starbucks_count',
'airport_related', 'colleges', 'HC01_VC118',
u'HC01_VC03', u'HC01_VC103',]].corr()
plt.subplots(figsize=(13,10))
sns.heatmap(corr,
xticklabels=corr.columns.values,
yticklabels=corr.columns.values)
"GNU GPL*": 10,
"ISC": 2,
"MIT*": 215,
"MIT NoPerm": 4,
"MIT-variant": 9,
"custom C": 2,
"other (long)": 42,
"other (short)": 82
}
pcts = collections.OrderedDict(sorted(pcts.items()))
from cycler import cycler
colors = pylab.cm.gray(np.linspace(0.2,0.8,5))
pylab.rcParams['axes.prop_cycle'] = cycler(color=colors)
fig, ax = pylab.subplots(figsize=(6, 4.5), subplot_kw=dict(aspect="equal"))
def labelling(val):
a = int(val / 100 * sum(list(pcts.values())))
if val > 4:
lbl = "{:d}\n[{:.1f}%]".format(a, val)
elif a >= 3:
lbl = "{:d}".format(a)
else:
lbl = ""
print(val, a, lbl)
return lbl
wedges, texts, lbls = ax.pie(list(pcts.values()), wedgeprops=dict(width=0.5), startangle=30, autopct=labelling, pctdistance=0.75)
bbox_props = dict(boxstyle="square,pad=0.3", fc="w", ec="k", lw=0.72)
import numpy as np
import matplotlib
matplotlib.use("TkAgg") # This program works with Qt only
def exp_sin(x, A, f, z, p):
return A * np.sin(2 * np.pi * f * x + p) * np.exp(z * x)
import pylab as pl
fig, ax = pl.subplots()
x = np.linspace(1e-6, 1, 500)
pars = {"A": 1.0, "f": 2, "z": -0.2, "p": 0}
y = exp_sin(x, **pars)
line, = pl.plot(x, y)
def update(**kw):
y = exp_sin(x, **kw)
line.set_data(x, y)
ax.relim()
ax.autoscale_view()
fig.canvas.draw_idle()
from scpy2.matplotlib.gui_panel import TkSliderPanel
#fwd = mne.make_forward_solution(info, trans=trans, src=src, bem=bem, fname='fsaverage-fwd.fif', meg=False, eeg=True, mindist=5.)
fwd = mne.read_forward_solution(
r'C:\Users\nsmetanin\PycharmProjects\nfb\tests\sloreta\fsaverage-fwd-1005-2.fif',
surf_ori=True)
# inverse
from mne.minimum_norm.inverse import _assemble_kernel
inv = mne.minimum_norm.make_inverse_operator(info,
fwd,
noise_cov,
loose=0.2,
depth=0.8,
fixed=True)
lambdas = [1000, 100, 10, 1, 0.1, 0.05, 0.01, 0.005, 0.001, 0.0001]
f, axes = plt.subplots(2, len(lambdas))
f.set_size_inches(10, 3.5)
label_name = [
'caudalanteriorcingulate', 'lateraloccipital', 'posteriorcingulate'
][0]
for j, lambda2 in enumerate(lambdas):
for k, add_label in enumerate(['lh', 'rh']):
# setup roi
area = True
labels = mne.read_labels_from_annot('fsaverage', parc='aparc')
print([label.name for label in labels])
roi_label = labels[[label.name for label in labels
].index('{}-{}'.format(label_name, add_label))]
arg = None
# prepare inv
import pylab as pl
import numpy as np
import csv
with open('results.csv', 'r') as f:
reader = csv.reader(f)
entries = list(reader)
#convert data to float, skip first line which contains headers
data = [[float(c) for c in r] for r in entries[1:]]
#transpose into a numpy array
data = np.transpose(np.array(data))
#create a new figure
fig, ax1 = pl.subplots(figsize=(7, 4))
ax2 = ax1.twinx()
#plot column 0 (x) vs. column 1 (phi)
ax1.plot(data[0],
data[1],
lineWidth=2,
color='black',
marker='o',
markerFaceColor='white',
markerSize=8)
ax2.plot(data[0], data[3], '--', lineWidth=2, color='gray')
ax1.set_xlabel('x (m)')
ax1.set_ylabel('phi (V)')
# lagged mutual information
T_L = np.append(T_R, np.arange(76,300)*0.001)
T_L_ms = T_L * 1000
lagged_MI = np.load('{}/analysis/{}/lagged_MI.npy'.format(CODE_DIR, recorded_system))
tau_L = plots.get_T_avg(T_L_ms, lagged_MI, T_0_ms)
"""Plotting"""
rc('text', usetex=True)
matplotlib.rcParams['font.size'] = '15.0'
matplotlib.rcParams['xtick.labelsize'] = '15'
matplotlib.rcParams['ytick.labelsize'] = '15'
matplotlib.rcParams['legend.fontsize'] = '15'
matplotlib.rcParams['axes.linewidth'] = 0.6
fig, ((ax1,ax2),(ax3,ax4)) = plt.subplots(nrows= 2, ncols = 2 , figsize=(5.8, 3.7))
# Colors
main_red = sns.color_palette("RdBu_r", 15)[12]
main_blue = sns.color_palette("RdBu_r", 15)[1]
soft_red = sns.color_palette("RdBu_r", 15)[10]
soft_blue = sns.color_palette("RdBu_r", 15)[4]
violet = sns.cubehelix_palette(8)[4]
green = sns.cubehelix_palette(8, start=.5, rot=-.75)[3]
##########################################
########## Simulated Conventional ########
##########################################
##### x-axis ####
# unset borders
rows = {
key: uvtbl[(uvtbl['region'] == key) & (uvtbl['band'] == band)]
for key in sorted(uvtbl['region'])
}
stats = [{
"label": key,
"med": row['50%'][0],
"q1": row['25%'][0],
"q3": row['75%'][0],
"whislo": row['5%'][0],
"whishi": row['95%'][0],
"fliers": [],
} for key, row in rows.items() if len(row) > 0][::-1]
fig, axes = pl.subplots(nrows=1,
ncols=1,
figsize=(12, 12),
sharey=True)
axes.bxp(stats, vert=False)
#axes.set_title(f'{band} UV distribution overview', fontsize=fontsize)
axes.set_xlabel("Angular Scale (\")", fontsize=fontsize)
axes.set_xlim(0.1, 15)
rad_to_as = u.radian.to(u.arcsec)
def fcn(x):
return rad_to_as / x / 1000
ax1t = axes.secondary_xaxis('top', functions=(fcn, fcn))
ax1t.set_xlabel("Baseline Length (k$\lambda$)")
ax1t.set_ticks([15, 20, 30, 50, 100, 400])
savefig(
f'/orange/adamginsburg/ALMA_IMF/2017.1.01355.L/paper_figures/uvhistograms/{band}_summary_uvdistribution.pdf',
E[i] = [float(v) for v in output.split()]
print("%3d %.6e %.6e" % (n, E[i, 0], E[i, 1]))
for s in range(h.size - 1):
print("rate = %.2f %.2f" %
(np.polyfit(np.log10(h[s:]), np.log10(E[s:, 0]), 1)[0],
np.polyfit(np.log10(h[s:]), np.log10(E[s:, 1]), 1)[0]))
pad = 0.05
lbl = 0.19
dh = np.log10(h[0]) - np.log10(h[-1])
dh *= (1. + 2 * pad + lbl)
hL = 10**(np.log10(h[-1]) - pad * dh)
hR = 10**(np.log10(h[0]) + (pad + lbl) * dh)
h0 = 10**(np.log10(h[0]) + 0.02 * dh)
fig, ax = plt.subplots(tight_layout=True)
ax.loglog(h, E[:, 0], '-o', ms=4)
ax.loglog(h, E[:, 1], '-^', ms=4)
tx, ty = _buildTriangle(2.0, 0.05, h, E[:, 0])
ax.loglog(tx, ty, '-k')
ax.text(tx[1], ty[1], "2 ", ha="right", va="bottom")
ax.text(h0, E[0, 0], r"$|||p-p_h|||$")
ax.text(h0, E[0, 1], r"$|||\mathbf{u}-\mathbf{u}_h|||$")
ax.set_xlim(hL, hR)
ax.set_xlabel("Mesh size, $h$")
ax.set_ylabel("Norm of Error")
fig.savefig("convergence_%d_%d%s.png" %
(d, args.problem, "_x" if args.perturb else ""))
* ptime[iproc][3]
/ (ptime[iproc][2] - ptime[iproc][1])
)
tconv[iproc] = 1.0 / (tmax[iproc] - tmin[iproc])
tconv_in_s[iproc] = (
(tmax[iproc] - tmin[iproc])
* ptime[iproc][3]
/ (ptime[iproc][2] - ptime[iproc][1])
)
ttot_min = tmin_in_s.min()
ttot_max = tmax_in_s.max()
## make the plot
fig, ax = pl.subplots(1, 1, sharex=True)
ax.set_xlim(
ttot_min - 0.05 * (ttot_max - ttot_min),
ttot_max + 0.05 * (ttot_max - ttot_min),
)
ax.axvline(x=ttot_min, linestyle="--", color="k", linewidth=0.8)
ax.axvline(x=ttot_max, linestyle="--", color="k", linewidth=0.8)
# first plot the MPI communications (if requested)
if args.messagefile:
mname = args.messagefile
# load the MPI communication data dump
mdata = np.loadtxt(mname)
tools.showProbeSignals(probes, -1.1, 1.1, dt)
# Исключение отраженных волн из датчика падающей волны с помощью временного окна
# Временное окно равно длительности импульса + времени, необходимому волне для прохождения
# расстояния от левого края до диэлектрика (в вакууме)
probes[1].E[int(T + lay_st * dx / (300000000 * dt)):] = 0
# Формирование спектра падающей и отраженной волн
spectr1 = tools.Spectrum(probes[0].E, dt, 30e9)
spectr1.fourierTransform()
spectr2 = tools.Spectrum(probes[1].E, dt, 30e9)
spectr2.fourierTransform()
# Вывод спектров падающей и отраженной волн, нормированных к максимуму спектра падающей волны
max_Norm = max(spectr2.PF)
fig, ax = pylab.subplots()
ax.plot(spectr1.f, spectr1.PF / max_Norm)
ax.plot(spectr1.f, spectr2.PF / max_Norm)
ax.set_xlim(0, spectr1.xMax)
ax.set_xlabel('f, Гц')
ax.set_ylabel(r'|$\frac{P}{P_{max}}$|')
ax.grid()
pylab.show()
# Вывод модуля коэффициента отражения в полосе частот Fmin, Fmax
Fmin = 5e9
Fmax = 15e9
fig, ax = pylab.subplots()
ax.plot(spectr1.f, spectr1.PF / spectr2.PF)
ax.set_xlim(Fmin, Fmax)
ax.set_ylim(0, 1)
ignore_index=True)
import pylab as plt
cm = dict(
zip(['FB0', 'FB250', 'FB500', 'FBMock'],
['#3CB4E8', '#438BA8', '#002A3B', '#FE4A49']))
for comp_with in ['FB0', 'FB250', 'FB500', 'FBMock']:
contrasts = [
'{} - {}'.format(fb_type, comp_with)
for fb_type in ['FB0', 'FB250', 'FB500', 'FBMock']
if fb_type != comp_with
]
fig, axes = plt.subplots(1, 4, sharey='all', sharex='all', figsize=(8, 3))
plt.suptitle('Comparison with {} condition'.format(comp_with))
plt.subplots_adjust(wspace=0, right=0.84, bottom=0.2, top=0.8)
for j_metric_type, metric_type in enumerate(
['magnitude', 'n_spindles', 'amplitude', 'duration']):
axes[j_metric_type].set_title(r'{}, log($\beta_1$)'.format(
metric_type) if (LOG and 'ude' in metric_type
) else r'{}, $\beta_1$'.format(metric_type))
for contrast in contrasts:
fb1_type, fb2_type = contrast.split(' - ')
data = t_stat_df.query('Contrast=="{}" & metric_type=="{}"'.format(
contrast, metric_type)).copy()
if len(data) == 0:
data = t_stat_df.query(
'Contrast=="{}" & metric_type=="{}"'.format(
layer = L1Norm_layer(input_shape=inpt.shape)
# FORWARD
layer.forward(inpt)
forward_out = layer.output
print(layer)
# BACKWARD
delta = np.zeros(shape=inpt.shape, dtype=float)
layer.backward(delta, copy=True)
# Visualizations
fig, (ax1, ax2, ax3) = plt.subplots(nrows=1, ncols=3, figsize=(10, 5))
fig.subplots_adjust(left=0.1, right=0.95, top=0.95, bottom=0.15)
fig.suptitle('L1Normalization Layer')
ax1.imshow(float_2_img(inpt[0]))
ax1.set_title('Original image')
ax1.axis('off')
ax2.imshow(float_2_img(forward_out[0]))
ax2.set_title("Forward")
ax2.axis("off")
ax3.imshow(float_2_img(delta[0]))
ax3.set_title('Backward')
ax3.axis('off')
def scan_eddym(data,
lon,
lat,
levels,
date,
areamap,
mask='',
destdir='',
physics='',
eddycenter='masscenter',
maskopt='contour',
preferences=None,
mode='gaussian',
basemap=False,
checkgauss=True,
areaparms=None,
usefullfit=False,
diagnostics=False,
plotdata=False,
debug=False):
'''scan_eddym wraps the identification and Gaussian fit functions.
Function to identify each eddy using closed contours,
also this function checks if the elipse adjusted have
a consistent eccentricity, vorticty and other parameters.
Parameters
----------
args:
data: array
Sea Surface Height in cm.
lon: array|list
Longitude of data field.
lat: array|list
Latitude of data field.
levels: array|list
Discrete levels where the code will find the closed contours.
date: int | datetime
Date in julian days.
areamap: list
Section of interest [lon0,lon1,lat0,lat1].
mask: np.mask
Continent mask.
Returns
-------
eddys: dict
OrderedDict of identified eddies.
check: boolean
Status of identification.
total_contours: int
Total number of contours analysed.
Example
-------
data:
Read netCDF4 data with mask or create a mask for your data.
lon:
Import your longitude coordinates, if your grid is regular, you can use a linspace instead.
lat:
Import your latitude coordinates (same as above).
levels:
List of the levels in which ones you want to find the eddies.
date:
Date as Julian Days.
areamap:
array([[0,len(lon)],[0,len(lat)]]) Array with the index
of your area of interest.
I used some auxilar functions, each one has his respective author.
Author: Josue Martinez Moreno, 2017
'''
# Defining lists inside dictionary
ellipse_path = []
contour_path = []
mayoraxis_eddy = []
minoraxis_eddy = []
gaussianfitdict = []
gaussfit2d = []
# Data shape
shapedata = np.shape(data)
# Diagnostics to list, which allows to print multiple diagnostics at the same time.
# (Be carefull because it uses a lot of memory)
if type(diagnostics) != list:
diagnostics = [diagnostics]
# Check if data is masked
elif data is ma.masked:
print('Invalid data data, must be masked')
return
# Make sure the shape of the data is identical to the grid.
elif shapedata == [len(lat), len(lon)]:
print('Invalid data size, should be [length(lat) length(lon]')
return
#Check that area to analyze is valid
elif np.shape(areamap) == shapedata:
if np.shape(areamap) == [1, 1] | len(areamap) != len(lat):
print('Invalid areamap, using NaN for eddy surface area')
return
#Check the number of levels is valid.
elif len(levels) != 2:
print(
'Invalid len of levels, please use the function for multiple levels or use len(levels)==2'
)
return
#Saving mask for future post-processing.
if mask != '':
data = np.ma.masked_array(data, mask)
datanan = data.filled(np.nan)
# Obtain the contours of a surface (contourf), this aproach is better than the contour.
if len(np.shape(lon)) == 1 and len(np.shape(lat)) == 1:
Lon, Lat = np.meshgrid(lon, lat)
else:
Lon, Lat = lon, lat
# Extract min value and max value from the coordinates.
min_x = Lon[0, 0]
min_y = Lat[0, 0]
max_x = Lon[-1, -1]
max_y = Lat[-1, -1]
# Plot contours according to the data.
if len(shapedata) == 3:
CS=plt.contourf(lon[areamap[0,0]:areamap[0,1]],lat[areamap[1,0]:areamap[1,1]],\
datanan[date,areamap[1,0]:areamap[1,1],areamap[0,0]:areamap[0,1]],levels=levels)
else:
CS=plt.contourf(lon[areamap[0,0]:areamap[0,1]],lat[areamap[1,0]:areamap[1,1]],\
datanan[areamap[1,0]:areamap[1,1],areamap[0,0]:areamap[0,1]],levels=levels)
if preferences == None:
preferences = {'ellipse': 0.85, 'eccentricity': 0.85, 'gaussian': 0.8}
# Close the contour plot.
plt.close()
# Extracting detected contours.
CONTS = CS.allsegs[:][:]
# Define variables used in the main loop.
total_contours = 0
eddyn = 0
threshold = 7
threshold2D = 20
numverlevels = np.shape(CONTS)[0]
fiteccen = 1
areachecker = np.inf
ellipsarea = np.inf
center_eddy = [np.nan, np.nan]
center_extrem = [np.nan, np.nan]
contarea = np.inf
checkm = False
checkM = False
gaussarea = [False, 0]
gausssianfitp = [0, 0, 0, 0, 0, 0]
xx = np.nan
yy = np.nan
areastatus = {'check': None, 'contour': None, 'ellipse': None}
# Loop in contours of the levels defined.
for ii in range(0, numverlevels):
if debug == True:
print("\n *******EDDY******")
pdb.set_trace()
CONTSlvls = CONTS[ii]
numbereddies = np.shape(CONTSlvls)[0]
# Loop over all the close contours.
for jj in range(0, numbereddies):
if debug == True:
print("\n ******* EDDY N ******")
pdb.set_trace()
check = False
CONTeach = CONTSlvls[jj]
#Relevant contour values
xidmin, xidmax = find2l(lon, lon, CONTeach[:, 0].min(),
CONTeach[:, 0].max())
yidmin, yidmax = find2l(lat, lat, CONTeach[:, 1].min(),
CONTeach[:, 1].max())
if xidmin <= threshold - 1:
xidmin = +threshold - 1
elif xidmax >= len(lon) - threshold:
xidmax = len(lon) - threshold
if yidmin <= threshold - 1:
yidmin = threshold - 1
elif yidmax >= len(lat) - threshold:
yidmax = len(lat) - threshold
lon_contour = lon[xidmin - threshold + 1:xidmax + threshold]
lat_contour = lat[yidmin - threshold + 1:yidmax + threshold]
cmindex = find(CONTeach[:, 1], CONTeach[:, 1].max())
xmindex, ymindex = find2l(lon, lat, CONTeach[cmindex, 0],
CONTeach[cmindex, 1])
centertop = [
ymindex - yidmin + threshold - 2,
xmindex - xidmin + threshold - 1
]
if len(shapedata) == 3:
data4gauss = datanan[date,
yidmin - threshold + 1:yidmax + threshold,
xidmin - threshold + 1:xidmax + threshold]
data_in_contour = insideness_contour(data4gauss * 1,
centertop,
levels,
maskopt=maskopt,
diagnostics=diagnostics)
else:
data4gauss = datanan[yidmin - threshold + 1:yidmax + threshold,
xidmin - threshold + 1:xidmax + threshold]
data_in_contour = insideness_contour(data4gauss * 1,
centertop,
levels,
maskopt=maskopt,
diagnostics=diagnostics)
checkcontour = check_closecontour(CONTeach, lon_contour,
lat_contour, data4gauss)
if checkcontour == False:
xx = np.nan
yy = np.nan
center = [np.nan, np.nan]
else:
checke = False
ellipse, status, r2 = fit_ellipse(CONTeach[:, 0],
CONTeach[:, 1],
diagnostics=diagnostics)
if status == True and r2 >= preferences[
'ellipse'] and preferences['ellipse'] < 1:
checke = True
if status == True:
ellipseadjust,checke=ellipsefit(CONTeach[:,1],ellipse['ellipse'][1],\
ellipsrsquarefit=preferences['ellipse'],\
diagnostics=diagnostics)
if checke == True:
center = [ellipse['X0_in'], ellipse['Y0_in']]
phi = ellipse['phi']
axes = [ellipse['a'], ellipse['b']]
R = np.arange(0, 2.1 * np.pi, 0.1)
a, b = axes
eccen = eccentricity(a, b)
if eccen <= preferences['eccentricity']:
#Ellipse coordinates.
xx = ellipse['ellipse'][0]
yy = ellipse['ellipse'][1]
mayoraxis = ellipse['majoraxis']
minoraxis = ellipse['minoraxis']
areastatus=checkscalearea(areaparms,lon_contour,lat_contour,\
xx,yy,CONTeach[:,0],CONTeach[:,1])
if eddycenter == 'maximum':
center_eddy=contourmaxvalue(data_in_contour,lon_contour,\
lat_contour,levels,date,threshold)
center_eddy[
3] = center_eddy[3] + xidmin - threshold + 1
center_eddy[
4] = center_eddy[4] + yidmin - threshold + 1
center_extrem = center_eddy
elif eddycenter == 'masscenter':
center_eddy=centroidvalue(CONTeach[:,0],CONTeach[:,1],\
data_in_contour,lon_contour,\
lat_contour,levels,date,threshold)
center_extrem=contourmaxvalue(data_in_contour,lon_contour,\
lat_contour,levels,date)
center_extrem[
3] = center_extrem[3] + xidmin - threshold + 1
center_extrem[
4] = center_extrem[4] + yidmin - threshold + 1
checkM = False
checkm = False
if areastatus['status']:
if checkgauss == True:
if len(shapedata) == 3:
profile,checkM=extractprofeddy(mayoraxis,\
data4gauss,lon_contour,lat_contour,50,\
gaus='One',kind='linear',\
gaussrsquarefit=preferences['gaussian'],\
diagnostics=diagnostics)
if checkM == True:
profile,checkm=extractprofeddy(minoraxis,\
data4gauss,lon_contour,\
lat_contour,50,\
gaus='One',kind='linear',\
gaussrsquarefit=preferences['gaussian'],\
diagnostics=diagnostics)
else:
profile,checkM=extractprofeddy(mayoraxis,\
data4gauss,lon_contour,lat_contour,50,\
gaus='One',kind='linear',\
gaussrsquarefit=preferences['gaussian'],\
diagnostics=diagnostics)
if checkM == True:
profile,checkm=extractprofeddy(minoraxis,\
data4gauss,lon_contour,\
lat_contour,50,\
gaus='One',kind='linear',\
gaussrsquarefit=preferences['gaussian'],\
diagnostics=diagnostics)
#print(checkM,checkm)
if checkM == True and checkm == True:
if levels[0] > 0:
level = levels[0]
extremvalue = np.nanmax(
data_in_contour)
else:
level = levels[1]
extremvalue = np.nanmin(
data_in_contour)
initial_guess = [a, b, phi, 0, 0, 0]
#print("\n ---pre fit---")
#pdb.set_trace()
fixvalues=[lon_contour,lat_contour,extremvalue,\
center_extrem[0],center_extrem[1]]
gausssianfitp,R2=fit2Dcurve(data_in_contour,\
fixvalues,\
level,initial_guess=initial_guess,date='',\
mode=mode,diagnostics=diagnostics)
#gausssianfitp=initial_guess
# Buf fix for anomalous big Gaussians
#print('++++++++++',abs(gausssianfitp[0]) < 2*np.pi*(xx.max()-xx.min()))
if abs(gausssianfitp[0]) < 2 * np.pi * (
xx.max() - xx.min()
) or abs(gausssianfitp[1]) < 2 * np.pi * (
xx.max() - xx.min()):
fiteccen = eccentricity(
gausssianfitp[0], gausssianfitp[1])
gausscheck2D = checkgaussaxis2D(a,b,\
gausssianfitp[0],\
gausssianfitp[1])
#print('=======',gausscheck2D,fiteccen)
if fiteccen <= preferences[
'eccentricity'] and gausscheck2D == True:
if xidmin <= threshold2D:
xidmin = threshold2D
elif xidmax >= len(
lon) - threshold2D:
xidmax = len(lon) - threshold2D
if yidmin <= threshold2D:
xidmin = threshold2D
elif yidmax >= len(
lat) - threshold2D:
yidmax = len(lat) - threshold2D
fixvalues[0] = lon[xidmin -
threshold2D +
1:xidmax +
threshold2D]
fixvalues[1] = lat[yidmin -
threshold2D +
1:yidmax +
threshold2D]
gaussarea= gaussareacheck(fixvalues,level,\
areaparms,gausssianfitp,\
areastatus['contour'])
if gaussarea[0] == True:
check = True
else:
print(
'Checkgauss need to be True to reconstruct the field.'
)
if check == True:
if usefullfit == False and mode == 'gaussian':
gausssianfitp[-1] = 0
gausssianfitp[-2] = 0
gausssianfitp[-3] = 0
ellipse_path.append([xx, yy])
contour_path.append([CONTeach[:, 0], CONTeach[:, 1]])
mayoraxis_eddy.append([mayoraxis[0], mayoraxis[1]])
minoraxis_eddy.append([minoraxis[0], minoraxis[1]])
gaussianfitdict.append([gausssianfitp])
gaussfit2d.append([R2])
#Switch from the ellipse center to the position of
#the maximum value inside de contour
if eddyn == 0:
position_selected = [center_eddy]
position_max = [center_extrem]
position_ellipse = [center]
total_eddy = [[eddyn]]
area = [[
areastatus['contour'], areastatus['check'],
gaussarea[1]
]]
angle = [phi]
if CS.levels[0] > 0:
level = CS.levels[0]
else:
level = CS.levels[1]
levelm = [[level]]
else:
position_selected = np.vstack(
(position_selected, center_eddy))
position_max = np.vstack(
(position_max, center_extrem))
position_ellipse = np.vstack(
(position_ellipse, center))
total_eddy = np.vstack((total_eddy, eddyn))
area = np.vstack((area, [
areastatus['contour'], areastatus['check'],
gaussarea[1]
]))
angle = np.vstack((angle, phi))
if CS.levels[0] > 0:
levelprnt = CS.levels[0]
levelm = np.vstack((levelm, levelprnt))
else:
levelprnt = CS.levels[1]
levelm = np.vstack((levelm, levelprnt))
eddyn = eddyn + 1
#diagnostics=True
if ("ellipse"
in diagnostics) or ("all" in diagnostics) or (
True in diagnostics): # and check == True:
print("Eddy Number (No time tracking):", eddyn)
print("Ellipse parameters")
print("Ellipse center = ", center)
print("Mass center = ", center_eddy)
print("angle of rotation = ", phi)
print("axes (a,b) = ", axes)
print("Eccentricity (ellips,gauss) = ", eccen,
fiteccen)
print("Area (rossby,cont,ellips,gauss) = ",
areastatus['check'], areastatus['contour'],
areastatus['ellipse'], gaussarea[1])
print("Ellipse adjust = ", ellipseadjust, checke)
print("Mayor Gauss fit = ", checkM)
print("Minor Gauss fit = ", checkm)
print("2D Gauss fit (Fitness, R^2)=", gausssianfitp,
gaussfit2d)
print(
"Conditions | Area | Ellipse | Eccen | Gaussians ")
if areastatus['ellipse'] == None or areastatus[
'check'] == None or areastatus[
'contour'] == None:
print(" | ", False," | ", checke ,"| ",\
eccen <= preferences['eccentricity'] and fiteccen <= preferences['eccentricity'] ,\
" | ", checkM and checkm)
else:
print(" | ", areastatus['ellipse'] < areastatus['check'] and areastatus['contour'] < areastatus['check'] and gaussarea[0],\
" | ", checke ,"| ",
eccen <= preferences['eccentricity'] and fiteccen <= preferences['eccentricity'] ,\
" | ", checkM and checkm)
if ("all" in diagnostics) or (
True in diagnostics): #and plotdata == True:
f, (ax1, ax2) = plt.subplots(1, 2, figsize=(13, 6))
if len(shapedata) == 3:
ax1.contourf(lon[areamap[0,0]:areamap[0,1]],lat[areamap[1,0]:areamap[1,1]],\
data[date,areamap[1,0]:areamap[1,1],areamap[0,0]:areamap[0,1]])
cc=ax2.pcolormesh(lon[areamap[0,0]:areamap[0,1]],\
lat[areamap[1,0]:areamap[1,1]],\
data[date,areamap[1,0]:areamap[1,1],areamap[0,0]:areamap[0,1]],\
vmin=data[date,areamap[1,0]:areamap[1,1],areamap[0,0]:areamap[0,1]].min(),\
vmax=data[date,areamap[1,0]:areamap[1,1],areamap[0,0]:areamap[0,1]].max())
cca=ax2.contour(lon[areamap[0,0]:areamap[0,1]],\
lat[areamap[1,0]:areamap[1,1]],\
data[date,areamap[1,0]:areamap[1,1],\
areamap[0,0]:areamap[0,1]],levels=levels,cmap='jet')
ax2.clabel(cca, fontsize=9, inline=1)
else:
cca=ax1.contourf(lon[areamap[0,0]:areamap[0,1]],\
lat[areamap[1,0]:areamap[1,1]],\
datanan[areamap[1,0]:areamap[1,1],areamap[0,0]:areamap[0,1]],\
levels=levels)
ax1.plot(CONTeach[:, 0], CONTeach[:, 1], '-r')
ax2.plot(CONTeach[:, 0], CONTeach[:, 1], '-r')
ax2.pcolormesh(lon[areamap[0,0]:areamap[0,1]],\
lat[areamap[1,0]:areamap[1,1]],\
datanan[areamap[1,0]:areamap[1,1],\
areamap[0,0]:areamap[0,1]],vmin=-20,vmax=20)
plt.show()
f, (ax1, ax2) = plt.subplots(1, 2, figsize=(13, 6))
ax1.contourf(lon[areamap[0,0]:areamap[0,1]],\
lat[areamap[1,0]:areamap[1,1]],\
data[areamap[1,0]:areamap[1,1],areamap[0,0]:areamap[0,1]])
cc=ax2.pcolormesh(lon[areamap[0,0]:areamap[0,1]],\
lat[areamap[1,0]:areamap[1,1]],\
data[areamap[1,0]:areamap[1,1],areamap[0,0]:areamap[0,1]],\
vmin=data[areamap[1,0]:areamap[1,1],areamap[0,0]:areamap[0,1]].min(),\
vmax=data[areamap[1,0]:areamap[1,1],areamap[0,0]:areamap[0,1]].max())
cca=ax2.contour(lon[areamap[0,0]:areamap[0,1]],\
lat[areamap[1,0]:areamap[1,1]],\
data[areamap[1,0]:areamap[1,1],areamap[0,0]:areamap[0,1]],\
levels=levels,cmap='jet')
ax2.clabel(cca, fontsize=9, inline=1)
ax1.plot(CONTeach[:, 0], CONTeach[:, 1], '*r')
ax1.plot(xx, yy, '-b')
ax1.plot(center[0], center[1], 'ob')
f.subplots_adjust(right=0.8)
cbar_ax = f.add_axes([0.85, 0.15, 0.05, 0.7])
f.colorbar(cc, cax=cbar_ax)
ax2.plot(CONTeach[:, 0], CONTeach[:, 1], '-r')
ax2.plot(xx, yy, '-b')
ax2.plot(center[0], center[1], 'ob')
idxelipcheck, idyelipcheck = find2l(
lon, lat, center[0], center[1])
ax2.plot(lon[idxelipcheck], lat[idyelipcheck], 'om')
ax2.plot(center_eddy[0], center_eddy[1], 'oc')
ax2.plot(center_extrem[0], center_extrem[1], '*g')
ax2.set_ylim(
[CONTeach[:, 1].min(), CONTeach[:, 1].max()])
ax2.set_xlim(
[CONTeach[:, 0].min(), CONTeach[:, 0].max()])
plt.show()
plt.close()
total_contours = total_contours + 1
try:
position_selected = np.array(position_selected)
position_max = np.array(position_max)
position_ellipse = np.array(position_ellipse)
area = np.array(area)
levelm = np.array(levelm)
mayoraxis_eddy = np.array(mayoraxis_eddy)
minoraxis_eddy = np.array(minoraxis_eddy)
gaussianfitdict = np.array(gaussianfitdict)
gaussfit2d = np.array(gaussfit2d)
eddys=dict_eddym(contour_path,ellipse_path,position_selected,\
position_max,position_ellipse,\
mayoraxis_eddy,minoraxis_eddy,\
area,angle,total_eddy,levelm,gaussianfitdict,gaussfit2d)
check = True
except:
check = False
eddys = 0
#if destdir!='':
# save_data(destdir+'day'+str(date)+'_one_step_cont'+str(total_contours)+'.dat', variable)
return eddys, check, total_contours
