def plot_wiggle(self,figsize=[5,10],fill=True,perc=100,scale=1,subplot=False):
# plot wiggle traces
# figsize=[5,10]: matplotlib figure size [inch]
# fill=True: fill values greater than zero
# perc=100: percent clip
# scale=1: scale trace plots
plotdata=self.data
plotdata=perc_clip(plotdata,perc)
print("min=%s max=%s"%(plotdata.min(),plotdata.max()))
maxval=np.abs(plotdata).max()
ns=pk.get_ns(self)
dt=pk.get_dt(self)
ntr=pk.get_ntr(self)
t=np.arange(ns)*dt
if not subplot: plt.figure(figsize=figsize)
for itr in range(ntr):
trace=plotdata[itr,:]
x=itr+trace/maxval*scale
plt.plot(x,t,'k-',linewidth=0.5)
if fill: plt.fill_betweenx(t,x,itr,where=x>itr,color='black',linewidth=0.)
plt.xlim([-2,ntr+1])
plt.ylim([t[-1],t[0]])
plt.gca().xaxis.tick_top()
plt.gca().xaxis.set_label_position('top')
if subplot: return
plt.xlabel('Trace number',fontsize='large')
plt.ylabel('Time (s)',fontsize='large')
def plot_fill(llr_cur, tkey, asimov_llr, hist_vals, bincen, fit_gauss, **kwargs):
"""
Plots fill between the asimov llr value and the histogram values
which represent an LLR distribution.
"""
validate_key(tkey)
expr = 'bincen < asimov_llr' if 'true_N' in tkey else 'bincen > asimov_llr'
plt.fill_betweenx(
hist_vals, bincen, x2=asimov_llr, where=eval(expr), **kwargs)
pvalue = (1.0 - float(np.sum(llr_cur > asimov_llr))/len(llr_cur)
if 'true_N' in tkey else
(1.0 - float(np.sum(llr_cur < asimov_llr))/len(llr_cur)))
sigma_fit = np.fabs(asimov_llr - fit_gauss[1])/fit_gauss[2]
#logging.info(
# " For tkey: %s, gaussian computed mean (of alt MH): %.3f and sigma: %.3f"
# %(tkey,fit_gauss[1],fit_gauss[2]))
pval_gauss = 1.0 - norm.cdf(sigma_fit)
sigma_1side = np.sqrt(2.0)*erfinv(1.0 - pval_gauss)
mctrue_row = [tkey,asimov_llr,llr_cur.mean(),pvalue,pval_gauss,sigma_fit,
sigma_1side]
return mctrue_row
def plot_vawig(axhdl, data, t, excursion):
import numpy as np
import matplotlib.pyplot as plt
[ntrc, nsamp] = data.shape
t = np.hstack([0, t, t.max()])
for i in range(0, ntrc):
tbuf = excursion * data[i,:] / np.max(np.abs(data)) + i
tbuf = np.hstack([i, tbuf, i])
axhdl.plot(tbuf, t, color='black', linewidth=0.5)
plt.fill_betweenx(t, tbuf, i, where=tbuf>i, facecolor=[0.6,0.6,1.0], linewidth=0)
plt.fill_betweenx(t, tbuf, i, where=tbuf<i, facecolor=[1.0,0.7,0.7], linewidth=0)
axhdl.set_xlim((-excursion, ntrc+excursion))
axhdl.xaxis.tick_top()
axhdl.xaxis.set_label_position('top')
axhdl.invert_yaxis()
def plot_xy(self, x, y, xerror=[], yerror=[], title=' ', xLabel=' ', yLabel=' '):
"""
Simple X vs Y plot
Inputs:
------
- x = 1D array
- y = 1D array
Keywords:
--------
- xerror = error on 'x', 1D array
- yerror = error on 'y', 1D array
- title = plot title, string
- xLabel = title of the x-axis, string
- yLabel = title of the y-axis, string
"""
fig = plt.figure(figsize=(18,10))
plt.rc('font',size='22')
self._fig = plt.plot(x, y, label=title)
scale = 1
ticks = ticker.FuncFormatter(lambda lon, pos: '{0:g}'.format(lon/scale))
plt.ylabel(yLabel)
plt.xlabel(xLabel)
if not yerror==[]:
#plt.errorbar(x, y, yerr=yerror, fmt='o', ecolor='k')
plt.fill_between(x, y-yerror, y+yerror,
alpha=0.2, edgecolor='#1B2ACC', facecolor='#089FFF', antialiased=True)
if not xerror==[]:
#plt.errorbar(x, y, xerr=xerror, fmt='o', ecolor='k')
plt.fill_betweenx(y, x-xerror, x+xerror,
alpha=0.2, edgecolor='#1B2ACC', facecolor='#089FFF', antialiased=True)
plt.show()
def plot_posteriors(model_params,plotfile,nbins=30,names=None):
import matplotlib
import matplotlib.pyplot as plt
#----get array dimensions (number of parameters)----
npar = model_params.shape[1]
#----loop through parameters----
for p in xrange(npar):
#--skip iteration column or if parameter is fixed--
if (max(model_params[:,p]) != min(model_params[:,p])) and p != 0:
y = model_params[:,p]
y_hist, x_bin = np.histogram(y,bins=nbins)
fig,ax=plt.subplots()
plt.bar(x_bin[:-1],y_hist,width=x_bin[1]-x_bin[0])
if names != None:
plt.xlabel(names[p])
ymin,ymax = ax.get_ylim()
#-plot median and 1sigma range-
med = np.median(y)
sig = np.std(y)
plt.plot([med,med],[ymin,ymax],color='red',linestyle='-')
plt.fill_betweenx([0.0,ymax],[med-sig,med-sig],[med+sig,med+sig],color='red',alpha=0.2)
#-save plot-
plotfile.savefig()
plt.close()
def make_group_cumdist_fig(LD,group_by,pcol):
'''Make a plot showing the cumulative distribution of the within-group avg of a
specified response variable. compared to the cum dist expected by chance.
INPUTS:
LD: pandas dataframe
group_by: column to groupby for computing avgs.
pcol: name of response variable column.
OUTPUTS:
fig: figure handle'''
name_legend_map = {'counts': 'Number of loans (thousands)',
'ROI': 'Average ROI (%)',
'int_rate': 'interest rate (%)',
'default_prob': 'default probability',
'dti': 'Debt-to-income ratio',
'emp_length': 'employment length (months)',
'annual_inc': 'annual income ($)'}
min_group_loans = 100 #only use states with at least this many loans
good_groups = LD.groupby(group_by).filter(lambda x: x[pcol].count() >= min_group_loans)
n_groups = len(good_groups[group_by].unique())
group_stats = good_groups.groupby(group_by)[pcol].agg(['mean','sem'])
group_stats.sort_values(by='mean',inplace=True)
ov_avg = good_groups[pcol].mean()
#compute bootstrap estimates of null distribution of group-avgs
boot_samps = 500 #number of bootstrap samples to use when estimating null dist
shuff_avgs = np.zeros((boot_samps,n_groups))
shuff_data = good_groups.copy()
for cnt in xrange(boot_samps):
shuff_data[pcol] = np.random.permutation(shuff_data[pcol].values)
shuff_avgs[cnt,:] = shuff_data.groupby(group_by)[pcol].mean().sort_values()
yax = np.arange(n_groups)
rmean = np.mean(shuff_avgs,axis=0)
rsem = np.std(shuff_avgs,axis=0)
#plot avg and SEM of within-state returns
fig, ax1 = plt.subplots(1,1,figsize=(6.0,5.0))
if group_by == 'zip3':
ax1.errorbar(group_stats['mean'].values,yax)
else:
ax1.errorbar(group_stats['mean'],yax,xerr=group_stats['sem'])
plt.fill_betweenx(yax, rmean-rsem, rmean+rsem,facecolor='r',alpha=0.5,linewidth=0)
plt.yticks(yax, group_stats.index,fontsize=6)
ax1.plot(rmean,yax,'r')
plt.legend(['Measured-avgs','Shuffled-avgs'],loc='best')
if group_by == 'zip3':
plt.ylabel('Zip codes',fontsize=16)
else:
plt.ylabel('States',fontsize=16)
plt.xlabel(name_legend_map[pcol],fontsize=16)
plt.xlim(np.min(group_stats['mean']),np.max(group_stats['mean']))
plt.ylim(0,n_groups)
ax1.axvline(ov_avg,color='k',ls='dashed')
plt.tight_layout()
return fig
def plot_mutation_rate_violins(libraries, out_prefix, nucleotides_to_count='ATCG', exclude_constitutive=False):
#Makes violin plots of raw mutation rates
data = []
labels = []
for library in libraries:
labels.append(library.lib_settings.sample_name)
data.append([math.log10(val) for val in library.list_mutation_rates(subtract_background=False, subtract_control=False,
nucleotides_to_count=nucleotides_to_count,
exclude_constitutive=exclude_constitutive) if val>0])
colormap = uniform_colormaps.viridis
fig = plt.figure(figsize=(5,8))
ax1 = fig.add_subplot(111)
# Hide the grid behind plot objects
ax1.yaxis.grid(True, linestyle='-', which='major', color='lightgrey', alpha=0.5)
ax1.set_axisbelow(True)
#ax1.set_xlabel(ylabel)
plt.subplots_adjust(left=0.1, right=0.95, top=0.9, bottom=0.25)
pos = range(1,len(libraries)+1) # starts at 1 to play nice with boxplot
dist = max(pos)-min(pos)
w = min(0.15*max(dist,1.0),0.5)
for library,p in zip(libraries,pos):
d = [math.log10(val) for val in library.list_mutation_rates(subtract_background=False, subtract_control=False,
nucleotides_to_count=nucleotides_to_count,
exclude_constitutive=exclude_constitutive) if val>0]
k = stats.gaussian_kde(d) #calculates the kernel density
m = k.dataset.min() #lower bound of violin
M = k.dataset.max() #upper bound of violin
x = numpy.arange(m,M,(M-m)/100.) # support for violin
v = k.evaluate(x) #violin profile (density curve)
v = v/v.max()*w #scaling the violin to the available space
plt.fill_betweenx(x,p,v+p,facecolor=colormap((p-1)/float(len(libraries))),alpha=0.3)
plt.fill_betweenx(x,p,-v+p,facecolor=colormap((p-1)/float(len(libraries))),alpha=0.3)
if True:
bplot = plt.boxplot(data,notch=1)
plt.setp(bplot['boxes'], color='black')
plt.setp(bplot['whiskers'], color='black')
plt.setp(bplot['fliers'], color='red', marker='.')
per50s = []
i = 1
for datum in data:
#per50s.append(stats.scoreatpercentile(datum, 50))
t = stats.scoreatpercentile(datum, 50)
per50s.append(t)
#ax1.annotate(str(round(t,3)), xy=(i+0.1, t), xycoords='data', arrowprops=None, fontsize='small', color='black')
i+= 1
#ax1.set_xticks([0.0, 0.5, 1.0, 1.5])
#ax1.set_yscale('log')
ax1.set_ylabel('log10 mutation rate')
ax1.set_ylim(-5, 0)
xtickNames = plt.setp(ax1, xticklabels=labels)
plt.setp(xtickNames, rotation=90, fontsize=6)
plt.savefig(out_prefix+'_logviolin.pdf', transparent='True', format='pdf')
plt.clf()
def seismic_wiggle(section, dt=0.004, ranges=None, scale=1.,
color='k', normalize=False):
"""
Plot a seismic section (numpy 2D array matrix) as wiggles.
Parameters:
* section : 2D array
matrix of traces (first dimension time, second dimension traces)
* dt : float
sample rate in seconds (default 4 ms)
* ranges : (x1, x2)
min and max horizontal values (default trace number)
* scale : float
scale factor multiplied by the section values before plotting
* color : tuple of strings
Color for filling the wiggle, positive and negative lobes.
* normalize :
True to normalizes all trace in the section using global max/min
data will be in the range (-0.5, 0.5) zero centered
.. warning::
Slow for more than 200 traces, in this case decimate your
data or use ``seismic_image``.
"""
npts, ntraces = section.shape # time/traces
if ntraces < 1:
raise IndexError("Nothing to plot")
if npts < 1:
raise IndexError("Nothing to plot")
t = numpy.linspace(0, dt*npts, npts)
amp = 1. # normalization factor
gmin = 0. # global minimum
toffset = 0. # offset in time to make 0 centered
if normalize:
gmax = section.max()
gmin = section.min()
amp = (gmax-gmin)
toffset = 0.5
pyplot.ylim(max(t), 0)
if ranges is None:
ranges = (0, ntraces)
x0, x1 = ranges
# horizontal increment
dx = float((x1-x0)/ntraces)
pyplot.xlim(x0, x1)
for i, trace in enumerate(section.transpose()):
tr = (((trace-gmin)/amp)-toffset)*scale*dx
x = x0+i*dx # x positon for this trace
pyplot.plot(x+tr, t, 'k')
pyplot.fill_betweenx(t, x+tr, x, tr > 0, color=color)
def arc(arc):
plt.imshow(arc.data, aspect='auto', interpolation='none',
extent=[arc.times[0].to(u.s).value, arc.times[-1].to(u.s).value,
arc.latitude[0].to(u.degree), arc.latitude[-1].to(u.degree)])
plt.xlim(0, arc.times[-1])
_label = 'first data point (time=' + fmt + ')'
plt.axvline(arc.offset, label=_label %arc.offset, color='w')
plt.fill_betweenx([arc.latitude[0], arc.latitude[-1]],
arc.offset, hatch='X', facecolor='w', label='not observed')
plt.ylabel('degrees of arc from first measurement')
plt.xlabel('time since originating event (seconds)')
plt.title('arc: ' + arc.title)
plt.legend(framealpha=0.5)
plt.show()
def drawhigh(cid,filesize,view,threshold,high,lowlimit=0,highlimit=0):
avgview=sum(view[5:-5])/len(view)
highdur=map(lambda x:(x[0],x[-1]),high)
# 图像设置
plt.figure(figsize=(15,7)) # figsize()设置的宽高比例是是15:7，图片的尺寸会根据这个比例进行调节
#plt.xlim(-3,19)
ylow=min(view)-500 #y轴下限
yhigh=max(view)+500 #y轴上限
plt.ylim(ylow,yhigh)
plt.grid(which='both')
#绘制结果数据
plt.plot(range(1,len(view)+1),view,'bo-',ms=1,lw=0.5,label='origin') # 原始图像
if lowlimit and highlimit:
plt.axhline(y=lowlimit,lw=3,ls='-',color='m',label='lowlimit') # 低限
plt.axhline(y=highlimit,lw=3,ls='-',color='m',label='highlimit') # 高限
plt.axhline(y=avgview,lw=1,ls='--',color='b',label='mean') # 均值
#plt.axhline(y=avgview*adjustv,lw=1,ls='--',color='g',label='mean*1.2') # 均值*adjustv
plt.axhline(y=threshold,lw=2,ls='--',color='r',label='threshold=1.2*mean') # 阈值
plt.legend(loc='upper right')
plt.xlabel('time (s)')
plt.ylabel('views')
# 标注高潮区间
for item in highdur:
#plt.axvline(x=item[0],lw=2)
#plt.axvline(x=item[1],lw=2)
plt.annotate('',xy=(item[1],threshold),xytext=(item[0],threshold),arrowprops=dict(arrowstyle="->",connectionstyle="arc3",color='g'))
plt.fill_betweenx([ylow,yhigh],item[0], item[1], linewidth=1, alpha=0.2, color='r')
plt.show()
# 结果保存
'''
resultpath='D:\\hot_pic2'
if not os.path.exists(resultpath):
os.mkdir(resultpath)
fname=os.path.join(resultpath,cid+'.'+str(filesize)+'.jpg')
print fname
plt.savefig(fname,dpi = 300)
plt.close()
'''
return 0;
def show_distr(x,y, vertical=False, label=None, color='blue', linecolor='k', quantile=False):
var_2d=np.copy(y)
if vertical:
var_2d=np.copy(x)
mid=np.nanmean(var_2d, axis=0)
lower=mid - np.nanstd(var_2d, axis=0)
upper=mid + np.nanstd(var_2d, axis=0)
if quantile:
lower=np.nanpercentile(var_2d,25,axis=0)
upper=np.nanpercentile(var_2d,75,axis=0)
if vertical:
plt.fill_betweenx(y,lower,upper, color=color)
plt.plot(mid,y,color=linecolor, linewidth=2)
else:
plt.fill_between(x,lower,upper, color=color)
plt.plot(x,mid,color=linecolor, linewidth=2)
def plot_airmass(objectlist,obsvat,date):
#ax = plt.subplot(111)
for obj in objectlist:
altdata = compute_alt_plot(obj[0],obj[1],obsvat,date)
plt.plot(altdata[:,0],altdata[:,1])
morn_twilight,even_twilight = functions.calc_twilight(obsvat,date)
plt.fill_betweenx([0,90],[morn_twilight.datetime(),morn_twilight.datetime()],x2=[even_twilight.datetime(),even_twilight.datetime()],color="0.5")
locs,labels = plt.xticks()
plt.setp(labels,rotation=45)
plt.ylim(0,90)
plt.show()
def peek(self):
plt.imshow(self.data, aspect='auto', interpolation='none',
extent=[self.times[0].to(u.s).value,
self.times[-1].to(u.s).value,
self.latitude[0].to(u.degree).value,
self.latitude[-1].to(u.degree).value])
plt.xlim(0, self.times[-1].to(u.s).value)
if self.times[0].to(u.s).value > 0.0:
plt.fill_betweenx([self.latitude[0].to(u.degree).value,
self.latitude[-1].to(u.degree).value],
self.times[0].to(u.s).value,
hatch='X', facecolor='w', label='not observed')
plt.ylabel('degrees of arc from first measurement')
plt.xlabel('time since originating event (seconds)')
plt.title('arc: ' + self.title)
plt.legend(framealpha=0.5)
plt.show()
return None
def plotBootROC(rocDfL, labelL=None, aucL=None, ciParam='fpr'):
"""Plot of ROC curves with confidence intervals.
Parameters
----------
rocDfL : list of pd.DataFrames
Each DataFram is one model and must include columns
fpr_est, tpr_est, fpr_lb, fpr_ub
labelL : list of str
Names of each model for legend
aucL : list of floats
AUC scores of each model for legend"""
if labelL is None and aucL is None:
labelL = ['Model %d' % i for i in range(len(rocDfL))]
elif labelL is None:
labelL = ['Model %d (AUC = %0.2f [%0.2f, %0.2f])' % (i, auc[0], auc[1], auc[2]) for i, auc in enumerate(aucL)]
else:
labelL = ['%s (AUC = %0.2f [%0.2f, %0.2f])' % (label, auc[0], auc[1], auc[2]) for label, auc in zip(labelL, aucL)]
colors = sns.color_palette('Set1', n_colors=len(rocDfL))
plt.cla()
plt.gca().set_aspect('equal')
for i, (rocDf, label) in enumerate(zip(rocDfL, labelL)):
if ciParam == 'fpr':
plt.fill_betweenx(rocDf['tpr_est'], rocDf['fpr_lb'], rocDf['fpr_ub'], alpha=0.3, color=colors[i])
elif ciParam == 'tpr':
plt.fill_between(rocDf['fpr_est'], rocDf['tpr_lb'], rocDf['tpr_ub'], alpha=0.3, color=colors[i])
plt.plot(rocDf['fpr_est'], rocDf['tpr_est'],'-', color=colors[i], lw=2)
# plt.plot(rocDf['fpr_est'], rocDf['tpr_lb'], '.--', color=colors[i], lw=1)
# plt.plot(rocDf['fpr_est'], rocDf['tpr_ub'], '.--', color=colors[i], lw=1)
# plt.plot(rocDf['fpr_lb'], rocDf['tpr_est'], '--', color=colors[i], lw=1)
# plt.plot(rocDf['fpr_ub'], rocDf['tpr_est'], '--', color=colors[i], lw=1)
plt.plot([0, 1], [0, 1], '--', color='gray', label='Chance')
plt.xlim([0, 1])
plt.ylim([0, 1])
plt.xlabel('False Positive Rate')
plt.ylabel('True Positive Rate')
plt.title('ROC')
plt.legend([plt.Line2D([0, 1], [0, 1], color=c, lw=2) for c in colors], labelL, loc='lower right', fontsize=10)
plt.show()
def gen_fill(tail_num, deg_left, deg_right):
if tail_num == 3:
plt.fill_betweenx(mlab.normpdf(x,mean,sigma),deg_left,x, where = ( x <= deg_left))
plt.fill_betweenx(mlab.normpdf(x,mean,sigma), x,deg_right, where = ( x >= deg_right))
plt.draw()
plt.show()
elif tail_num == 2: #right
plt.fill_betweenx(mlab.normpdf(x,mean,sigma), x,deg_right, where = ( x >= deg_right))
plt.draw()
plt.show()
elif tail_num == 1 :
plt.fill_betweenx(mlab.normpdf(x,mean,sigma),deg_left,x, where = ( x <= deg_left))
plt.draw()
plt.show()
def plot_wiggle(data,zz=1,skip=1,gain=1,alpha=0.7,black=False):
'''
Wiggle plot of generic 2D numpy array.
INPUT
data: 2D numpy array
zz: vertical sample rate in depth or time
skip: interval to choose traces to draw
gain: multiplier applied to each trace
'''
[n_samples,n_traces]=data.shape
t=range(n_samples)
plt.figure(figsize=(9.6,6))
for i in range(0, n_traces,skip):
trace=gain*data[:,i] / np.max(np.abs(data))
plt.plot(i+trace,t,color='k', linewidth=0.5)
if black==False:
plt.fill_betweenx(t,trace+i,i, where=trace+i>i, facecolor=[0.6,0.6,1.0], linewidth=0)
plt.fill_betweenx(t,trace+i,i, where=trace+i<i, facecolor=[1.0,0.7,0.7], linewidth=0)
else:
plt.fill_betweenx(t,trace+i,i, where=trace+i>i, facecolor='black', linewidth=0, alpha=alpha)
locs,labels=plt.yticks()
plt.yticks(locs,[n*zz for n in locs.tolist()])
plt.grid()
plt.gca().invert_yaxis()
def plot_vawig(axhdl, data, t, excursion, highlight=None):
import numpy as np
import matplotlib.pyplot as plt
[ntrc, nsamp] = data.shape
t = np.hstack([0, t, t.max()])
for i in range(0, ntrc):
tbuf = excursion * data[i] / np.max(np.abs(data)) + i
tbuf = np.hstack([i, tbuf, i])
if i == highlight:
lw = 2
else:
lw = 0.5
axhdl.plot(tbuf, t, color='black', linewidth=lw)
plt.fill_betweenx(t,
tbuf,
i,
where=tbuf > i,
facecolor=[0.6, 0.6, 1.0],
linewidth=0)
plt.fill_betweenx(t,
tbuf,
i,
where=tbuf < i,
facecolor=[1.0, 0.7, 0.7],
linewidth=0)
axhdl.set_xlim((-excursion, ntrc + excursion))
axhdl.xaxis.tick_top()
axhdl.xaxis.set_label_position('top')
axhdl.invert_yaxis()
def plotear2(X,V):
try:
varvals = un.nominal_values(V)
varerr = un.std_devs(V)
varmenos = varvals - varerr
varmas = varvals + varerr
xerr = un.std_devs(X) / 2
x = un.nominal_values(X)
# plt.errorbar(x,varvals,xerr=xerr,yerr=varerr,fmt='o')
plt.plot(x,varvals,'ok')
plt.fill_between(x,varmenos,varmas,color='k', alpha=0.3)
plt.fill_betweenx(varvals, x-xerr,x+xerr,color='k',alpha=0.3)
except TypeError:
print('no andan lo errores')
plt.plot(S,var,'.')
# plt.title(medicion.split('.')[0].replace('_',' '))
# plt.legend(loc='best')
plt.ylabel(r'$Voltaje\ (V)$')
plt.xlabel(r'$\Delta T\ estacionario\ (K)$')
def plot_mean_sigma_all_days(var, nsigma, xlabel, xlim1, xlim2):
mean = var.mean(dim='launch_time')
sigma = var.std(dim='launch_time')
alt = var.alt.values
if True:
plt.figure(figsize=(8, 10))
plt.plot(mean, alt, linewidth=4, color='black',
label='mean') #label='$\mu$')
plt.fill_betweenx(alt,
mean,
mean - (nsigma * sigma),
color='lightgrey',
alpha=0.6,
label='1$\sigma$')
plt.fill_betweenx(alt,
mean,
mean + (nsigma * sigma),
color='lightgrey',
alpha=0.6)
plt.gca().spines['right'].set_visible(False)
plt.gca().spines['top'].set_visible(False)
plt.xlabel(xlabel)
plt.ylabel('Altitude / m')
plt.ylim([0, 4000])
plt.xlim([xlim1, xlim2])
#plt.legend(loc='best')
# remove yticks and ylabel
if False:
plt.tick_params(bottom=True,
labelbottom=True,
left=False,
labelleft=False)
plt.ylabel('')
if False:
plt.axvline(x=0, color='black')
def map_of_rois(acti, roi_tensor, path):
""" Make a map of ROIs and an histogram of the # of NaNs per trials
Arguments:
acti {array} -- activation tensor
roi_tensor {array} -- mask of ROIs
Keyword Arguments:
None
Returns:
None
"""
N, T, K = acti.shape
plt.imshow(tca.make_map(roi_tensor, np.ones(roi_tensor.shape[2])), cmap='hot')
fig = plt.figure(figsize=(12,12))
fig.add_subplot(2,2,1)
nan_per_trial = pd.Series(np.isnan(acti[0,:,:]).sum(axis=0))
nan_per_trial.plot(kind = 'bar', color = 'blue', width = 1)
plt.xticks(nan_per_trial.index[::40], nan_per_trial.index[::40], rotation = 'vertical')
plt.xlabel('Trials')
plt.ylabel('Number of NaN')
fig.add_subplot(2,2,2)
nan_per_timeframe = pd.Series(np.isnan(acti[0,:,:]).sum(axis=1))
nan_per_timeframe.plot(kind='bar', color='blue', width=1)
plt.xticks(nan_per_trial.index[0:T:15], rotation='horizontal')
plt.xlabel('Time')
plt.fill_betweenx([0, 1.2 * np.max(nan_per_timeframe)], 105, 135, facecolor='red', alpha=0.5)
plt.tight_layout()
plt.savefig(os.path.join(path, 'map_of_rois.png'))
def PlotGather(data,
ntraces,
nsample,
dt,
scale=1,
displaytext='Display',
normalize=True):
if (ntraces > 100):
ntraces = 100 #numero maximo de tracos por display
t = range(0, nsample * dt, dt)
plt.figure()
plt.title(displaytext)
plt.ylabel('t (ms)')
t = np.asarray(t)
if normalize == True:
f = NormalizationFactor(data, ntraces, 2)
else:
f = 1
for i in range(0, ntraces, 1):
tr = data.T[i]
#tr = (tr / f[i]) * scale
tr = (tr / f) * scale
#print shape(tr), shape(t)
#reshape(t, (nsample,1))
plt.plot(i + tr, t, 'k')
plt.fill_betweenx(t, i, i + tr, tr >= 0, color='k')
plt.ylim(nsample * dt, 0)
plt.xlim(-1, ntraces)
plt.show()
def plot_silhouette(data, metric, predictions, k):
if data.ndim == 1:
data = data.to_frame()
score_per_sample = silhouette_samples(data, predictions, metric=metric)
y_lower = 10
for i in range(k):
ith_cluster_silhouette_values = \
score_per_sample[predictions == i]
ith_cluster_silhouette_values.sort()
size_cluster_i = ith_cluster_silhouette_values.shape[0]
y_upper = y_lower + size_cluster_i
color = cm.nipy_spectral(float(i) / k)
plt.fill_betweenx(np.arange(y_lower, y_upper),
0,
ith_cluster_silhouette_values,
facecolor=color,
edgecolor=color,
alpha=0.7)
plt.text(-0.05, y_lower + 0.5 * size_cluster_i, str(i))
y_lower = y_upper + 10
plt.title("The silhouette plot for the various clusters.")
plt.xlabel("The silhouette coefficient values")
plt.ylabel("Cluster label")
# The vertical line for average silhouette score of all the values
score = silhouette_score(data, predictions, metric=metric)
plt.axvline(x=score, color="red", linestyle="--")
plt.yticks([])
plt.xticks(np.arange(-1, +1, 0.1))
plt.show()
def sil(matr, y_pred, n_clusters):
print("Computing the silhouette scores")
silhouette_avg = silhouette_score(matr, y_pred)
print("Overall silhouette average: %s" % silhouette_avg)
sample_silhouette_values = silhouette_samples(matr, y_pred)
plt.figure(20)
y_lower = 10
for i in range(n_clusters):
print("Cluster # %s" % i)
# Aggregate the silhouette scores for samples belonging to
# cluster i, and sort them
ith_cluster_silhouette_values = \
sample_silhouette_values[y_pred == i]
ith_cluster_silhouette_values.sort()
size_cluster_i = ith_cluster_silhouette_values.shape[0]
y_upper = y_lower + size_cluster_i
color = cm.spectral(float(i) / n_clusters)
plt.fill_betweenx(np.arange(y_lower, y_upper),
0,
ith_cluster_silhouette_values,
facecolor=color,
edgecolor=color,
alpha=0.7)
# Label the silhouette plots with their cluster numbers at the middle
plt.text(-0.05, y_lower + 0.5 * size_cluster_i, str(i))
# Compute the new y_lower for next plot
y_lower = y_upper + 10 # 10 for the 0 samples
plt.savefig(out_dir + 'Silhouette_Plot_' + str(n_clusters) +
'clusters_2.png')
plt.close()
def NAC_fitting_plot(dG_c, NAC_bulkRange, results_dir, sels, protein, mol):
"""Plots the N_theoretic and P_enzyme in the same plot with the y-axis.
Requires the ranges_bulk and dG_c dataframe"""
fig, ax = plt.subplots(sharey=True)
N_adjusted, N_sim = dG_c.filter(like='bulk'), dG_c.filter(
like='P_{enzyme}')
colors = plt.rcParams['axes.prop_cycle'].by_key()['color'][:len(N_sim.
columns)]
fig = N_adjusted.plot(kind='line', style="--", color=colors)
fig.set_xlim(1, NAC_bulkRange[-1] + 20)
fig.set_ylim(-10,
np.max(N_sim.values) +
2) #this is to avoid plotting large negatives in x --> 0
#fig.legend(ncol=1, bbox_to_anchor=(1.12, 0.5), loc='center left')
N_sim.plot(kind='line', legend=False, ax=fig, color=colors)
fig.set_ylabel('ln N')
fig.set_xlabel(r'$d_{NAC}$ ($\AA$)')
#Show region used for fitting
plt.axvline = (NAC_bulkRange[0])
plt.axvline = (NAC_bulkRange[-1])
plt.fill_betweenx(plt.ylim(),
NAC_bulkRange[0],
NAC_bulkRange[-1],
alpha=0.5,
color='gray')
plt.xscale('log')
plt.savefig('{}/dG_nac{}-fitting-{}-{}.png'.format(results_dir, len(sels),
protein, mol),
bbox_inches="tight",
dpi=600)
plt.clf()
def plot_clustering(n_clusters, cluster_labels, X):
plt.figure()
sample_silhouette_values = silhouette_samples(X, cluster_labels)
y_lower = 10
for i in range(n_clusters):
# Aggregate the silhouette scores for samples belonging to
# cluster i, and sort them
ith_cluster_silhouette_values = \
sample_silhouette_values[cluster_labels == i]
ith_cluster_silhouette_values.sort()
size_cluster_i = ith_cluster_silhouette_values.shape[0]
y_upper = y_lower + size_cluster_i
color = plt.spectral(float(i) / n_clusters)
plt.fill_betweenx(np.arange(y_lower, y_upper),
0, ith_cluster_silhouette_values,
facecolor=color, edgecolor=color, alpha=0.7)
# Label the silhouette plots with their cluster numbers at the middle
plt.text(-0.05, y_lower + 0.5 * size_cluster_i, str(i))
# Compute the new y_lower for next plot
y_lower = y_upper + 10 # 10 for the 0 samples
plt.set_title("The silhouette plot for the various clusters.")
plt.set_xlabel("The silhouette coefficient values")
plt.set_ylabel("Cluster label")
# The vertical line for average silhouette score of all the values
plt.axvline(x=silhouette_avg, color="red", linestyle="--")
plt.set_yticks([]) # Clear the yaxis labels / ticks
plt.set_xticks([-0.1, 0, 0.2, 0.4, 0.6, 0.8, 1])
plt.show()
def update( costScl = 1.95, c1 = 2, c2 = 3, b1 = 4, b2 = 12, b3 = 18, b4 = 3):
model.c1 = c1
model.c2 = c2
model.b1 = b1
model.b2 = b2
model.b3 = b3
model.b4 = b4
solver.solve(model)
mncost = model.cost()
cost = mncost*costScl
plt.figure(figsize=(6,6))
plt.plot(d, (cost-c1*d)/(c2+0.0001), 'k--', lw = 3, label = 'cost')
plt.plot(b1 * np.ones_like(d), d, lw=3, label='Plant 1',color='b')
plt.fill_betweenx(d, 0, b1, alpha=0.1,color='b')
plt.plot(d, b2/2*np.ones_like(d), lw=3, label='Plant 2',color='r')
plt.fill_between(d, 0, b2/2, alpha=0.1,color='r')
plt.plot(d, (b3-3*d)/2, lw=3, label='Plant 3',color='g')
plt.fill_between(d, 0, (b3-3*d)/2, alpha=0.1,color='g')
plt.plot(d, b4-d, lw=3, label = 'Min Prod', color='y')
plt.fill_between(d,b4-d,12,alpha=0.1,color='y')
plt.plot(np.zeros_like(d), d, lw=3, label='d non-negative',color='c')
plt.plot(d, np.zeros_like(d), lw=3, label='w non-negative',color='m')
plt.xlabel('batches of doors', fontsize=16)
plt.ylabel('batches of windows', fontsize=16)
plt.xlim(-0.05, 12)
plt.ylim(-0.05, 12)
plt.legend(loc = 'upper right',fontsize=12)
plt.text( 6.2, 6.4, f'Cost = ${1000*cost:,.2f}', fontsize = 12)
plt.show()
def plot_bore(df, figsize=(11, 8), show=True, dpi=100):
df = df.copy()
fig = plt.figure(figsize=figsize, dpi=dpi)
v = df[["G", "S", "L", "C", "P"]].values
v[:, 2] += df["SI"].values
v[np.argwhere(v.sum(1) < 0)] = np.nan
c = ["#a76b29", "#578E57", "#0078C1", "#DBAD4B", "#708090"]
for i in range(5):
plt.fill_betweenx(
-np.repeat(df["depth_top"], 2),
np.zeros(v.shape[0] * 2),
np.roll(np.repeat(np.cumsum(v, axis=1)[:, -(i + 1)], 2), 1),
color=c[i],
)
legend_dict = {
"Gravel": "#708090",
"Sand": "#DBAD4B",
"Loam": "#0078C1",
"Clay": "#578E57",
"Peat": "#a76b29",
}
patch_list = []
for key in legend_dict:
data_key = mpatches.Patch(color=legend_dict[key], label=key)
patch_list.append(data_key)
plt.legend(handles=patch_list, bbox_to_anchor=(1, 1), loc="upper left")
if show:
plt.show()
return fig
def swiggle(seismic, time, isFilled = True, fillColor = 'blue'):
if seismic.ndim == 1:
plt.plot(seismic,time,color=fillColor,alpha=.5)
plt.fill_betweenx(time, 0, seismic, seismic>0, color='blue', alpha=.25)
plt.gca().invert_yaxis()
else:
nTimes, nGathers = seismic.shape
for iGather in range(nGathers):
# print(iGather)
# plt.figure(1)
# plt.figure(figsize=(8,6))
plt.axes([0.1+0.18*iGather,0.1,.1,.8])
# plt.plot(seismic[:,iGather]+iGather,time,color='blue',alpha=.5)
# plt.fill_betweenx(time, iGather, seismic[:,iGather]+iGather, seismic[:,iGather]>0, color='blue', alpha=.25)
plt.plot(seismic[:,iGather],time,color=fillColor,alpha=.5)
plt.fill_betweenx(time, 0, seismic[:,iGather], seismic[:,iGather]>0, color=fillColor, alpha=.25)
plt.gca().invert_yaxis()
# plt.plot(seismic(:,0),time)
# plt.plot(seismic(:,1) * 3,time)
# plt.gca().invert_yaxis()
# plt.show()
def pick_wigb(data,t_axis,offsets,filename,amx):
''' This function enables picking and saving on a seismic wiggle plot
data: Is a matrix of seismic data where the columns are the seismic traces
t_axis: Is your time axis
offsets: vector of each trace offset
filename: Is the output filename
amx: is a screen gain to the data'''
amx2=amx*np.max(data)
i=0
for offset in offsets:
x=np.divide(data[:,i],amx2)+offset
i=i+1
plt.plot(x,t_axis,'k')
plt.fill_betweenx(t_axis,offset,x,where=(x>offset),color='k')
plt.ylabel('Time (s)')
plt.xlabel('Offset (m)')
plt.gca().invert_yaxis()
plt.xlim((offsets[0]-1.,offsets[-1]+1.))
picks = plt.ginput( n=0, timeout=0, show_clicks=True, mouse_add=1, mouse_pop=3, mouse_stop=2)
np.savetxt(filename, picks)
plt.show()
def graphEpiInfDetailed(frame, saveloc: str):
"""Represents the epifaunal to infaunal proportions by displaying foram
proportions by their respective environment. Requires a dataframe object
as input. """
holder = dfProportion(frame) * 100
# holder.iloc[0] gets the first row
epifaunal = holder.iloc[0]
infShallow = holder.iloc[1] + epifaunal
infDeep = holder.iloc[2] + infShallow
infUndetermined = holder.iloc[3] + infDeep
plt.figure(dpi=200, figsize=(3, 12))
yaxis = [x + 1 for x in range(len(holder.T))]
plt.title("Detailed Epifaunal to Infaunal proportions")
plt.ylabel("Sample number")
plt.xlabel("Percentage")
plt.plot(epifaunal, yaxis, '#52A55C', label='Epifaunal')
plt.plot(infShallow, yaxis, '#236A62', label='Inf. Shallow')
plt.plot(infDeep, yaxis, '#2E4372', label='Inf. Deep')
plt.plot(infUndetermined, yaxis, '#535353', label='Inf. Undetermined')
plt.fill_betweenx(yaxis, epifaunal, facecolor='#52A55C')
plt.fill_betweenx(yaxis, epifaunal, infShallow, facecolor='#236A62')
plt.fill_betweenx(yaxis, infShallow, infDeep, facecolor='#2E4372')
plt.fill_betweenx(yaxis, infDeep, infUndetermined, facecolor='#535353')
plt.gca().yaxis.set_major_locator(MaxNLocator(integer=True))
plt.yticks(yaxis)
plt.gca().set_xlim(0, 100)
plt.gca().set_ylim(1, len(yaxis))
plt.subplot(111).legend(loc='upper center',
bbox_to_anchor=(0.5, -0.05),
fancybox=True,
shadow=True,
ncol=5,
borderaxespad=2)
savename = "/Detailed Epi-Infaunal.svg"
plt.savefig(saveloc + savename)
def _make_square(df, i):
x_mean = df.ages.mean()
y_mean = df.heights.mean()
x = df.iloc[i].ages
y = df.iloc[i].heights
alpha = .1
if x > x_mean and y > y_mean:
plt.fill_betweenx(x1=x_mean,
x2=x,
y=(y_mean, y),
alpha=alpha,
color='b')
elif x < x_mean and y < y_mean:
plt.fill_betweenx(x1=x,
x2=x_mean,
y=(y, y_mean),
alpha=alpha,
color='b')
elif x < x_mean and y > y_mean:
plt.fill_betweenx(x1=x,
x2=x_mean,
y=(y_mean, y),
alpha=alpha,
color='r')
else:
plt.fill_betweenx(x1=x_mean,
x2=x,
y=(y, y_mean),
alpha=alpha,
color='r')
def plot_wiggle(data, zz=1, skip=1, gain=1, alpha=0.7, black=False):
'''
Wiggle plot of generic 2D numpy array.
INPUT
data: 2D numpy array
zz: vertical sample rate in depth or time
skip: interval to choose traces to draw
gain: multiplier applied to each trace
'''
[n_samples, n_traces] = data.shape
t = range(n_samples)
plt.figure(figsize=(9.6, 6))
for i in range(0, n_traces, skip):
trace = gain * data[:, i] / np.max(np.abs(data))
plt.plot(i + trace, t, color='k', linewidth=0.5)
if black == False:
plt.fill_betweenx(t,
trace + i,
i,
where=trace + i > i,
facecolor=[0.6, 0.6, 1.0],
linewidth=0)
plt.fill_betweenx(t,
trace + i,
i,
where=trace + i < i,
facecolor=[1.0, 0.7, 0.7],
linewidth=0)
else:
plt.fill_betweenx(t,
trace + i,
i,
where=trace + i > i,
facecolor='black',
linewidth=0,
alpha=alpha)
locs, labels = plt.yticks()
plt.yticks(locs, [n * zz for n in locs.tolist()])
plt.grid()
plt.gca().invert_yaxis()
def plot_dDAR():
lam_mu = 0.3+np.arange(2200)/1000
lam_mu_ref = 0.55
zeta_deg = 10*np.arange(8)
plt.ylim([-3,5])
##
## mark X-SHOOTER arms
plt.fill_betweenx(plt.ylim(),0.3,0.55,color="blue",alpha=0.3)
plt.fill_betweenx(plt.ylim(),0.55,1.0,color="green",alpha=0.3)
plt.fill_betweenx(plt.ylim(),1.0,2.5,color="red",alpha=0.3)
for z in zeta_deg:
am = 1/np.sin(np.deg2rad(90-z))
plt.plot(lam_mu, dDAR(z, lam_mu, lam_mu_ref), label="{0} deg, airmass {1:5.2f}".format(z,am))
plt.legend()
plt.title("Differential atmospheric refraction w.r.t. {0:5.2f} micron".format(lam_mu_ref))
plt.xlabel("Wavelength in micron")
plt.ylabel("Differential atmospheric refraction in arcsec")
plt.text(2.4, -2.5, "Paranal standard conditions: 11.5 deg C, 743 hPa, 14.5 % RH", fontsize=9, ha="right")
def ftir_method_plots():
'''
look at ftir profile vs a priori
plot averaging kernal summary
mean AK for column and profiles
'''
pname_prof = 'Figs/FTIR_apriori.png'
pname_AK = 'Figs/FTIR_midday_AK.png'
# Read FTIR output
ftir=campaign.Wgong()
# Resample FTIR to just midday averages
middatas=ftir.resample_middays()
### Mean profile and apriori
# Plot mean profile vs mean a priori
plt.close()
alts = ftir.alts
for i, (prof, c) in enumerate(zip([middatas['VMR'], middatas['VMR_apri']],['k','teal'] )):
# Convert ppmv to ppbv and plot profiles
mean = 1000*np.nanmean(prof,axis=0)
lq = 1000*np.nanpercentile(prof, 25, axis=0)
uq = 1000*np.nanpercentile(prof, 75, axis=0)
plt.fill_betweenx(alts, lq, uq, alpha=0.5, color=c)
plt.plot(mean,alts,label=['x$_{ret}$','x$_{apri}$'][i],linewidth=2,color=c)
plt.ylim([0,50])
plt.ylabel('altitude [km]')
plt.xlabel('HCHO [ppbv]')
plt.legend(fontsize=14)
plt.title('FTIR mean profile')
plt.savefig(pname_prof)
print("Saved ",pname_prof)
plt.close()
### Mean averaging kernal summarised
# check plot of VC_AK
# [dates, levels]
plt.close()
plt.figure(figsize=(12,12))
ax0=plt.subplot(1,2,1)
OAK=middatas['VC_AK']
mean = np.nanmean(OAK,axis=0)
lq = np.nanpercentile(OAK,25, axis=0)
uq = np.nanpercentile(OAK,75, axis=0)
plt.fill_betweenx(ftir.alts,lq,uq, label='IQR')
plt.plot(mean, ftir.alts,color='k',linewidth=2, label='mean')
plt.title("$\Omega$ sensitivity to HCHO")
plt.legend()
plt.ylabel('altitude [km]')
# also check average AK
AAK = np.nanmean(middatas['VMR_AK'],axis=0)
colors=pp.get_colors('gist_ncar',48) # gist_ncar
plt.subplot(1,2,2, sharey=ax0)
for i in np.arange(0,48,1):
sample = int((i%6)==0)
label=[None,ftir.alts[47-i]][sample]
linestyle=['--','-'][sample]
linewidth=[1,2][sample]
alpha=[.5,1][sample]
plt.plot(AAK[47-i],ftir.alts, color=colors[i], alpha=alpha,
label=label,linestyle=linestyle,linewidth=linewidth)
plt.legend(title='altitude')
plt.title('Mean averaging kernal')
#plt.colorbar()
plt.ylim([-1,81])
plt.savefig(pname_AK)
print('Saved ',pname_AK)
plt.xlim([-0.1, 1])
y_lower = 10
for i in range(n_clusters):
ith_cluster_silhouette_values = sample_silhouette_values[cluster_labels == i]
ith_cluster_silhouette_values.sort()
size_cluster_i = ith_cluster_silhouette_values.shape[0]
y_upper = y_lower + size_cluster_i
color = cm.spectral(float(i) / n_clusters)
plt.fill_betweenx(np.arange(y_lower, y_upper),
0, ith_cluster_silhouette_values,
facecolor=color, edgecolor=color, alpha=0.7)
plt.text(-0.05, y_lower + 0.5 * size_cluster_i, str(i))
y_lower = y_upper + 10
plt.xlabel("Silhouette coefficient values")
plt.ylabel("Cluster label")
plt.axvline(x=silhouette_avg, color="red", linestyle="--")
plt.savefig('Silhouette '+str(n_clusters-1))
plt.show()
y_max=15,
x_label='frequency [Hz]',
y_label='PSD [V**2/Hz]',
line_style='--',
line_width=2,
line_color='black',
institute_label='NIST Cartesian Geometry',
data_label='Exp',
plot_title='Sandia 1 m Helium Plume Puffing Frequency',
show_legend=True,
legend_location='right')
# add error to measuered puffing freq
plt.fill_betweenx(PSDmeas,
np.array([1.19, 1.19]),
np.array([1.53, 1.53]),
color='lightgrey',
figure=fh)
fh = macfp.plot_to_fig(f1p5,
Pxx_den_1p5,
plot_type='linear',
x_min=0,
x_max=4,
y_min=0,
y_max=15,
x_label='frequency [Hz]',
y_label='PSD [V**2/Hz]',
data_label='FDS $\Delta x=1.5$ cm',
line_style='-',
line_width=1,
def plot_tpl(uniq_c):
print(uniq_c)
template_name, ruleset_name = uniq_c
data_template = fits.open(path_2_template(template_name))
x_template = data_template[1].data['LAMBDA']
y_template = data_template[1].data['FLUX_DENSITY']
ok = (y_template > 1e-18)
selection = (template == template_name) & (ruleset == ruleset_name)
N_used = len(selection.nonzero()[0])
if N_used > 1:
print('N in catalog', N_used)
MAG = hd[1].data['MAG'][selection]
TEXP_B = hd[1].data['TEXP_B'][selection]
TEXP_G = hd[1].data['TEXP_G'][selection]
TEXP_D = hd[1].data['TEXP_D'][selection]
# one plot per template
# A4 figure
fig = p.figure(0, (8.2, 11.7), frameon=False)
# template
fig.add_subplot(
411,
title='template=' + template_name,
xlabel='wavelength [Angstrom]',
ylabel=r'Flux [$f_\lambda$ erg cm$^{-2}$ s$^{-1}$ A$^{-1}$]',
ylim=((n.median(y_template[ok]) / 10,
n.median(y_template[ok]) * 10)),
xlim=((3600, 9400)),
yscale='log')
p.grid()
p.plot(x_template[ok], y_template[ok], color='black', lw=1)
ys = [n.min(y_template[ok]), n.max(y_template[ok])]
p.fill_betweenx(ys,
x1=[4200.0, 4200.0],
x2=[5000.0, 5000.0],
alpha=0.1,
color='b')
p.fill_betweenx(ys,
x1=[5500.0, 5500.0],
x2=[6700.0, 6700.0],
alpha=0.1,
color='g')
p.fill_betweenx(ys,
x1=[7200.0, 7200.0],
x2=[9000.0, 9000.0],
alpha=0.1,
color='r')
# exposure time tracks
fig.add_subplot(412,
title='ruleset=' + ruleset_name,
xlabel='MAG',
ylabel='TEXP [minutes]',
yscale='log')
p.plot(MAG,
TEXP_B,
color='r',
marker='x',
ls='',
label=r'bright N$_{fh}$=' +
str(n.round(n.sum(TEXP_B) / 60., 1)),
rasterized=True)
p.plot(MAG,
TEXP_G,
color='g',
marker='+',
ls='',
label=r'grey N$_{fh}$=' + str(n.round(n.sum(TEXP_G) / 60., 1)),
rasterized=True)
p.plot(MAG,
TEXP_D,
color='b',
marker='^',
ls='',
label=r'dark N$_{fh}$=' + str(n.round(n.sum(TEXP_D) / 60., 1)),
rasterized=True)
p.grid()
p.legend(frameon=False, loc=0)
# statistics in catalog
fig.add_subplot(413, xlabel='MAG', ylabel='Counts (N)', yscale='log')
p.hist(MAG,
bins=n.arange(n.min(MAG) - 0.1,
n.max(MAG) + 0.1, 0.1),
histtype='step',
lw=2)
p.grid()
fig.add_subplot(414,
xlabel='MAG',
ylabel='N x TEXP (hours)',
yscale='log')
p.hist(MAG,
weights=TEXP_D / 60.,
bins=n.arange(n.min(MAG) - 0.1,
n.max(MAG) + 0.1, 0.1),
histtype='step',
label=r'bright',
lw=2)
p.hist(MAG,
weights=TEXP_G / 60.,
bins=n.arange(n.min(MAG) - 0.1,
n.max(MAG) + 0.1, 0.1),
histtype='step',
label=r'grey',
lw=2)
p.hist(MAG,
weights=TEXP_B / 60.,
bins=n.arange(n.min(MAG) - 0.1,
n.max(MAG) + 0.1, 0.1),
histtype='step',
label=r'dark',
lw=2)
p.legend(frameon=False, loc=0)
p.grid()
p.savefig(
os.path.join(output_folder,
ruleset_name + '_' + template_name[:-5] + '.png'))
p.tight_layout()
p.clf()
else:
print('not used')
galq[3] = 1908
galq[4] = 2799
galq[5] = 4341
galq[6] = 4862
galq[7] = 5000
galq[8] = 6564
# Redshift
z = N.arange(0., 1., 0.01)
plt.figure(1, figsize=(11, 9), dpi=80, facecolor='w', edgecolor='k')
plt.clf()
for ii in range(7):
x, y = U.get_data(root_to_filts + filters[ii], (0, 1))
plt.plot(x, y, '-', lw=1, color=colores[:, ii])
plt.fill_betweenx(y, x, 0, color=colores[:, ii], alpha=0.1)
plt.grid()
plt.xlabel('Wavelength [$\AA$]', size=25, labelpad=5)
plt.ylabel('$z$', size=35)
plt.xlim(3500, 9500)
plt.ylim(0.01, 1.)
plt.plot(galw[2] * (1 + z), z, '--', color='black', alpha=0.95)
plt.plot(galw[5] * (1 + z), z, '-', color='black', alpha=0.95)
plt.xticks(fontsize=20)
plt.yticks(fontsize=20)
"""
qsoline = []
qsoline.append('Ly-alpha: 1215$\AA$')
qsoline.append('$N_{V}$: 1240$\AA$')
qsoline.append('$C_{IV}$: 1549$\AA$')
qsoline.append('$C_{III}$: 1908$\AA$')
def escut(image, pos_file, fwhm, peak):
# input image file name, file name with matched source positions, **np.array of fwhm measurements for each source
import numpy as np
import matplotlib.pyplot as plt
from scipy import stats
from pyraf import iraf
# import sewpy
import os
from matplotlib.path import Path
iraf.images(_doprint=0)
iraf.tv(_doprint=0)
iraf.ptools(_doprint=0)
iraf.noao(_doprint=0)
iraf.digiphot(_doprint=0)
iraf.photcal(_doprint=0)
iraf.apphot(_doprint=0)
iraf.imutil(_doprint=0)
iraf.unlearn(iraf.phot, iraf.datapars, iraf.photpars, iraf.centerpars,
iraf.fitskypars)
iraf.apphot.phot.setParam('interactive', "no")
iraf.apphot.phot.setParam('verify', "no")
iraf.datapars.setParam('datamax', 50000.)
iraf.datapars.setParam('gain', "gain")
iraf.datapars.setParam('ccdread', "rdnoise")
iraf.datapars.setParam('exposure', "exptime")
iraf.datapars.setParam('airmass', "airmass")
iraf.datapars.setParam('filter', "filter")
iraf.datapars.setParam('obstime', "time-obs")
# iraf.datapars.setParam('obstime',"date-obs")
iraf.datapars.setParam('sigma', "INDEF")
iraf.photpars.setParam('zmag', 0.)
iraf.centerpars.setParam('cbox', 9.)
iraf.centerpars.setParam('maxshift', 3.)
iraf.fitskypars.setParam('salgorithm', "median")
iraf.fitskypars.setParam('dannulus', 10.)
# clean up the indefs so we can actually do stats, but reassign them to 99999 so we don't lose track of things
# keep a separate list without them to do the median (we need floats)
indefs = np.where(fwhm == 'INDEF')
good = np.where(fwhm != 'INDEF')
fwhm[indefs] = 99.999
fwhm = fwhm.astype(float)
fwhm_good = fwhm[good].astype(float)
indefs = np.where(peak == 'INDEF')
peak[indefs] = -999.999
peak = peak.astype(float)
peak_good = peak[good].astype(float)
if not os.path.isfile(image[0:-5] + '.txdump'):
# findavgfwhm = sewpy.SEW(
# params = ["X_IMAGE", "Y_IMAGE", "FWHM_IMAGE", "FLAGS"],
# config = {"DETECT_THRESH":200.0},
# sexpath = "sex"
# )
#
# out = findavgfwhm(image)["table"]
#
# fwhms = out['FWHM_IMAGE'] # This is an astropy table.
# flags = out['FLAGS']
# get a really rough estimate of the stellar FWHM in the image to set apertures
# use the input fwhm measurement
# ap1x = fwhm_est
# xpos = datatable['X_IMAGE']
# ypos = datatable['Y_IMAGE']
# fwhm = datatable['FWHM_IMAGE']
# flags = datatable['FLAGS']
# idno = datatable['NUMBER']
ap1x = np.median(
fwhm_good
) # only use isolated detections of stars, this is the 1x aperture
# print ap1x
ap2x = 2.0 * ap1x
# these = [ i for i,id in enumerate(idno) if (flags[i] == 0)]
# with open(image[0:-5]+'.escut.pos','w+') as f:
# for j in range(len(xpos)):
# print >> f, xpos[j], ypos[j], fwhm[j], idno[j]
iraf.datapars.setParam('fwhmpsf', ap1x)
iraf.photpars.setParam('apertures', repr(ap1x) + ', ' + repr(ap2x))
iraf.fitskypars.setParam('annulus', 4. * ap1x)
iraf.apphot.phot(image=image,
coords=pos_file,
output=image[0:-5] + '.phot')
with open(image[0:-5] + '.txdump', 'w+') as txdump_out:
iraf.ptools.txdump(
textfiles=image[0:-5] + '.phot',
fields=
"id,mag,merr,msky,stdev,rapert,xcen,ycen,ifilter,xairmass,image",
expr=
'MAG[1] != INDEF && MERR[1] != INDEF && MAG[2] != INDEF && MERR[2] != INDEF',
headers='no',
Stdout=txdump_out)
mag1x, mag2x = np.loadtxt(image[0:-5] + '.txdump',
usecols=(1, 2),
unpack=True)
iraf_id = np.loadtxt(image[0:-5] + '.txdump',
usecols=(0, ),
dtype=int,
unpack=True)
# idno = np.loadtxt(image[0:-5]+'.escut.pos', usecols=(3,), dtype=int, unpack=True)
xpos, ypos = np.loadtxt(pos_file, usecols=(0, 1), unpack=True)
keepIndex = iraf_id - 1
xpos, ypos, fwhm, peak = xpos[keepIndex], ypos[keepIndex], fwhm[
keepIndex], peak[keepIndex]
# print idno.size, iraf_id.size, xpos.size
diff = mag2x - mag1x
diffCut = diff
magCut = mag2x
xCut = xpos #[good]
yCut = ypos #[good]
idCut = iraf_id
fwhmCut = fwhm #_good
peakCut = peak
print(peakCut.size, magCut.size, diffCut.size)
print(diffCut.size, 0, np.median(diffCut), diffCut.std())
nRemoved = 1
# plt.clf()
# plt.scatter(peakCut, magCut, edgecolor='none')
# plt.savefig('peaktest.pdf')
plt.clf()
# plt.hlines(bin_edges, -2, 1, colors='red', linestyle='dashed')
plt.scatter(diff, mag2x, edgecolor='none', facecolor='black', s=4)
# plt.scatter(diffCut, magCut, edgecolor='none', facecolor='blue', s=4)
magdiff = list(
zip(magCut.tolist(), diffCut.tolist(), peakCut.tolist(),
idCut.tolist()))
dtype = [('mag', float), ('diff', float), ('peak', float), ('id', int)]
magdiff = np.array(magdiff, dtype=dtype)
magSort = np.sort(magdiff, order='peak')
peakRange = (magSort['peak'] > 20000.0) & (magSort['peak'] < 40000.0)
peakVal = np.median((magSort['diff'])[np.where(peakRange)])
# peakVal = np.median(diffCut)
print(peakVal)
plt.scatter((magSort['diff'])[np.where(peakRange)],
(magSort['mag'])[np.where(peakRange)],
edgecolor='none',
facecolor='blue',
s=4)
while nRemoved != 0:
nBefore = diffCut.size
diffCheck = np.where(
abs(peakVal - diffCut) < 2.0 *
diffCut.std()) #[i for i,d in enumerate(diff) if (-0.5 < d < 0.0)]
#
diffCut = diffCut[diffCheck]
nRemoved = nBefore - diffCut.size
magCut = magCut[diffCheck]
xCut = xCut[diffCheck]
yCut = yCut[diffCheck]
idCut = idCut[diffCheck]
fwhmCut = fwhmCut[diffCheck]
print(diffCut.size, nRemoved, np.median(diffCut), diffCut.std())
if 0.05 < diffCut.std() < 0.06:
nRemoved = 0
# plt.fill_betweenx(bin_centers, bin_meds+3.0*bin_stds, bin_meds-3.0*bin_stds, facecolor='red', edgecolor='none', alpha=0.4, label='2x RMS sigma clipping region')
# with open('escutSTD_i.pos','w+') as f:
# for i,blah in enumerate(xCut):
# print >> f, xCut[i], yCut[i], diffCut[i]
bin_meds, bin_edges, binnumber = stats.binned_statistic(magCut,
diffCut,
statistic='median',
bins=24,
range=(-12, 0))
bin_stds, bin_edges, binnumber = stats.binned_statistic(magCut,
diffCut,
statistic=np.std,
bins=24,
range=(-12, 0))
bin_width = (bin_edges[1] - bin_edges[0])
bin_centers = bin_edges[1:] - bin_width / 2
# print bin_meds, bin_stds
bin_hw = np.zeros_like(bin_stds)
for i, bin_std in enumerate(bin_stds):
if bin_std > 0.025:
bin_hw[i] = 3.0 * bin_std
else:
bin_hw[i] = 0.075
# print len(binnumber)
# for i,bin_hwi in enumerate(bin_hw):
left_edge = np.array(list(zip(peakVal - bin_hw, bin_centers)))
right_edge = np.flipud(np.array(list(zip(peakVal + bin_hw, bin_centers))))
# print left_edge, right_edge
verts = np.vstack((left_edge, right_edge))
# print verts
# verts = np.delete(verts, np.array([0,1,2,22,23,24,25,45,46,47]), axis=0)
# DON'T USE A PATH BECAUSE APPARENTLY IT CAN SELECT THE INVERSE SET!! WTF
# print verts
esRegion = Path(verts)
sources = esRegion.contains_points(list(zip(diff, mag2x)))
# print sources
with open('escutREG_i.pos', 'w+') as f:
for i, blah in enumerate(xpos[sources]):
print((xpos[sources])[i], (ypos[sources])[i], (diff[sources])[i],
file=f)
magCut2 = mag2x[sources]
magCut1 = mag1x[sources]
fwhmCut = fwhm[sources]
xCut = xpos[sources]
yCut = ypos[sources]
diffCut = diff[sources]
# find the sources that are in the std method but not the region method
# print idCut, idno[sources]
# extrasSTD = np.setdiff1d(idno[sources], idCut)
# print extrasSTD.size
# print extrasSTD
# with open('escutUNIQUE.pos','w+') as f:
# for i,blah in enumerate(extrasSTD):
# print >> f, xpos[blah-1], ypos[blah-1]
# fwhmcheck = np.loadtxt('testfwhmREG.log', usecols=(10,), unpack=True)
fwhmchk2 = np.where((magCut2 < -4) & (fwhmCut < 90.0))
print(np.median(fwhmCut[fwhmchk2]), np.std(fwhmCut[fwhmchk2]))
fwchk = np.where(
np.abs(fwhmCut - np.median(fwhmCut[fwhmchk2])) > 10.0 *
np.std(fwhmCut[fwhmchk2]))
drop = np.abs(fwhmCut - np.median(fwhmCut[fwhmchk2])) > 10.0 * np.std(
fwhmCut[fwhmchk2])
keep = np.abs(fwhmCut - np.median(fwhmCut[fwhmchk2])) <= 10.0 * np.std(
fwhmCut[fwhmchk2])
with open('escutVBAD_i.pos', 'w+') as f:
for i, blah in enumerate(xCut[fwchk]):
print((xCut[fwchk])[i], (yCut[fwchk])[i], file=f)
with open('escut_i.pos', 'w+') as f:
for i, blah in enumerate(xCut):
if not drop[i]:
print(xCut[i],
yCut[i],
magCut2[i],
fwhmCut[i],
magCut1[i],
file=f)
with open('escut_g.pos', 'w+') as f:
for i, blah in enumerate(xCut):
if not drop[i]:
print(xCut[i],
yCut[i],
magCut2[i],
fwhmCut[i],
magCut1[i],
file=f)
plt.fill_betweenx(bin_centers,
peakVal + bin_hw,
peakVal - bin_hw,
facecolor='red',
edgecolor='none',
alpha=0.4,
label='2x RMS sigma clipping region')
plt.scatter(diffCut[fwchk],
magCut2[fwchk],
edgecolor='none',
facecolor='red',
s=4)
plt.ylim(0, -12)
plt.xlabel('$m_{2x} - m_{1x}$')
plt.ylabel('$m_{2x}$')
plt.xlim(-2, 1)
plt.savefig('testmagiraf.pdf')
plt.clf()
plt.scatter(magCut2, fwhmCut, edgecolor='none', facecolor='black')
plt.scatter(magCut2[fwchk],
fwhmCut[fwchk],
edgecolor='none',
facecolor='red')
plt.hlines([np.median(fwhmCut)], -12, 0, colors='red', linestyle='dashed')
plt.hlines([
np.median(fwhmCut) + fwhmCut.std(),
np.median(fwhmCut) - fwhmCut.std()
],
-12,
0,
colors='red',
linestyle='dotted')
plt.ylim(0, 20)
plt.xlim(-12, 0)
plt.ylabel('fwhm')
plt.xlabel('$m_{2x}$')
plt.savefig('fwhmcheck.pdf')
return fwhmCut[keep]
def plot_llr_distributions(llr_nmh, llr_imh, nbins, plot_gauss=True, imh_true=False):
"""Plots LLR distributions-expects llr_nmh and llr_imh to be type
Series. Also plots vertical line signifying the mean of the
hierarchy assumed to be given in nature, and the percentage of
trials from the opposite hierarchy with LLR beyond the mean.
"""
fig = plt.figure(figsize=(9, 8))
label_text = r"$\log ( \mathcal{L}(data: IH|IH) / \mathcal{L}( data: IH|NH) )$"
llr_imh.hist(bins=nbins, histtype="step", lw=2, color="b", label=label_text)
hist_vals_imh, bincen_imh = plot_error(llr_imh, nbins, fmt=".b", lw=2)
if plot_gauss:
fit_imh = plot_gauss_fit(llr_imh, hist_vals_imh, bincen_imh, color="b", lw=2)
label_text = r"$\log ( \mathcal{L}(data: NH|IH) / \mathcal{L}(data: NH|NH) )$"
llr_nmh.hist(bins=nbins, histtype="step", lw=2, color="r", label=label_text)
hist_vals_nmh, bincen_nmh = plot_error(llr_nmh, nbins, fmt=".r", lw=2)
if plot_gauss:
fit_nmh = plot_gauss_fit(llr_nmh, hist_vals_nmh, bincen_nmh, color="r", lw=2)
if imh_true:
mean_val = llr_nmh.mean()
pvalue = 1.0 - float(np.sum(llr_imh > mean_val)) / len(llr_imh)
else:
mean_val = llr_imh.mean()
pvalue = float(np.sum(llr_nmh > mean_val)) / len(llr_nmh)
ymax = max(hist_vals_nmh) if imh_true else max(hist_vals_imh)
bincen = bincen_imh if imh_true else bincen_nmh
vline = plt.vlines(mean_val, 1, ymax, colors="k", linewidth=2, label=("pval = %.4f" % pvalue))
sigma_1side = np.sqrt(2.0) * erfinv(1.0 - pvalue)
sigma_2side = norm.isf(pvalue)
print " Using non-gauss fit: "
print " pvalue: %.5f" % pvalue
print " sigma 1 sided (erfinv): %.4f" % sigma_1side
print " sigma 2 sided (isf) : %.4f" % sigma_2side
sigma_fit_imh = (fit_imh[1] - fit_nmh[1]) / fit_imh[2]
sigma_fit_nmh = (fit_imh[1] - fit_nmh[1]) / fit_nmh[2]
pval_imh = 1.0 - norm.cdf(sigma_fit_imh)
pval_nmh = 1.0 - norm.cdf(sigma_fit_nmh)
sigma_1side_imh = np.sqrt(2.0) * erfinv(1.0 - pval_imh)
sigma_1side_nmh = np.sqrt(2.0) * erfinv(1.0 - pval_nmh)
print "\n\n pval IMH: %.5f, pval NMH: %.5f" % (pval_imh, pval_nmh)
print " sigma gauss fit (IMH true): %.4f/%.4f" % (sigma_fit_imh, sigma_1side_imh)
print " sigma gauss fit (NMH true): %.4f/%.4f" % (sigma_fit_nmh, sigma_1side_nmh)
sigma_error_nmh = np.sqrt(1.0 + 0.5 * (2.0 / sigma_1side_nmh) ** 2) / np.sqrt(len(llr_nmh))
sigma_error_imh = np.sqrt(1.0 + 0.5 * (2.0 / sigma_1side_imh) ** 2) / np.sqrt(len(llr_imh))
logging.info("total trials: %d", len(llr_nmh))
logging.info(" nmh sigma error: %f" % sigma_error_nmh)
logging.info(" imh sigma error: %f" % sigma_error_imh)
if imh_true:
plt.fill_betweenx(hist_vals_imh, bincen, x2=mean_val, where=bincen < mean_val, alpha=0.5, hatch="xx")
else:
plt.fill_betweenx(hist_vals_nmh, bincen, x2=mean_val, where=bincen > mean_val, alpha=0.5, hatch="xx")
if args.present:
plt.ylabel("# Trials")
plt.xlabel("LLR value")
else:
plt.ylabel("# Trials", fontsize="x-large")
plt.xlabel("LLR value", fontsize="x-large")
return
for ii, (condition, color, eve_id) in enumerate(zip(X, colors, event_ids)):
# extract time course at cluster vertices
condition = condition[:, :, inds_v]
# normally we would normalize values across subjects but
# here we use data from the same subject so we're good to just
# create average time series across subjects and vertices.
mean_tc = condition.mean(axis=2).mean(axis=0)
std_tc = condition.std(axis=2).std(axis=0)
plt.plot(times, mean_tc.T, color=color, label=eve_id)
plt.fill_between(times,
mean_tc + std_tc,
mean_tc - std_tc,
color='gray',
alpha=0.5,
label='')
ymin, ymax = mean_tc.min() - 5, mean_tc.max() + 5
plt.xlabel('Time (ms)')
plt.ylabel('Activation (F-values)')
plt.xlim(times[[0, -1]])
plt.ylim(ymin, ymax)
plt.fill_betweenx((ymin, ymax),
times[inds_t[0]],
times[inds_t[-1]],
color='orange',
alpha=0.3)
plt.legend()
plt.title('Interaction between stimulus-modality and location.')
plt.show()
chain_0 = trace_0[1000:]
varnames = ['alpha', 'beta', 'bd']
pm.traceplot(chain_0, varnames)
plt.savefig('img505.png', dpi=300, figsize=(5.5, 5.5))
plt.figure()
pm.summary(chain_0, varnames)
theta = chain_0['theta'].mean(axis=0)
idx = np.argsort(x_0)
plt.plot(x_0[idx], theta[idx], color='b', lw=3)
plt.axvline(chain_0['bd'].mean(), ymax=1, color='r')
bd_hpd = pm.hpd(chain_0['bd'])
plt.fill_betweenx([0, 1], bd_hpd[0], bd_hpd[1], color='r', alpha=0.5)
plt.plot(x_0, y_0, 'o', color='k')
theta_hpd = pm.hpd(chain_0['theta'])[idx]
plt.fill_between(x_0[idx],
theta_hpd[:, 0],
theta_hpd[:, 1],
color='b',
alpha=0.5)
plt.xlabel(x_n, fontsize=16)
plt.ylabel(r'$\theta$', rotation=0, fontsize=16)
plt.savefig('img506.png', dpi=300, figsize=(5.5, 5.5))
plt.figure()
fontsize=9)
ax.annotate("Hypervolume: " + str(round(hv, 2)), (0.10, 0.44),
fontsize=9,
color='blue')
new_pfx = pfx[:1]
new_pfy = pfy[:1]
for i in xrange(1, len(pfx) - 2):
new_pfx.append(pfx[i])
new_pfx.append(pfx[i + 1])
for u in xrange(1, len(pfy) - 2):
new_pfy.append(pfy[u])
new_pfy.append(pfy[u])
new_pfx.extend(pfx[len(pfx) - 1:])
new_pfy.extend(pfy[len(pfy) - 1:])
plt.fill_betweenx(new_pfy, new_pfx, facecolor='blue', alpha=0.2)
plt.xlabel('Ziel 1', size=9)
plt.ylabel('Ziel 2', size=9)
plt.title('')
plt.grid(False)
plt.subplots_adjust(bottom=0.19, left=0.18)
plt.show()
count = 20
random.seed(18.9654)
ref_point2d = [0.0, 0.0]
set2d = np.zeros((count, 2))
for i in range(count):
for u in range(2):
rand = random.random()
set2d[i, u] = rand if (rand > ref_point2d) or (
cb.set_label('Brightness contrast, log10(Shell / BG)')
plt.xlabel('Projected distance from Trapezium, D / arcmin')
plt.ylabel('Bowshock radius, r0 / arcsec')
plt.text(0.05, 0.05, 'Symbol size indicates shell relative thickness, H',
transform=ax.transAxes, fontsize='x-small')
ax.set_xlim(0.05, 20.0)
ax.set_ylim(0.3, 11.0)
ax.set_xscale('log')
ax.set_yscale('log')
fig.savefig(pltfile)
figlist.append('[[file:luis-programas/{0}][{0}]]'.format(pltfile))
pltfile = 'will-PA-vs-PA.pdf'
fig = plt.figure(figsize=(7,6))
ax = fig.add_subplot(111, axisbg="#eeeeee")
plt.fill_betweenx([-90.0, 90.0], [0.0, 0.0], [90.0, 90.0], zorder=-10, alpha=0.05)
plt.fill_betweenx([-90.0, 90.0], [180.0, 180.0], [270.0, 270.0], zorder=-10, alpha=0.05)
plt.fill_betweenx([-90.0, 90.0], [360.0, 360.0], [450.0, 450.0], zorder=-10, alpha=0.05)
plt.text(45.0, -80.0, 'NE\nquadrant', ha='center', fontsize='x-small')
plt.text(135.0, -80.0, 'SE\nquadrant', ha='center', fontsize='x-small')
plt.text(225.0, -80.0, 'SW\nquadrant', ha='center', fontsize='x-small')
plt.text(315.0, -80.0, 'NW\nquadrant', ha='center', fontsize='x-small')
plt.axhline(zorder=-5)
plt.scatter(PA_star[m], dPA[m], s=20*tab['R_out'][m], c=D60[m], cmap=plt.cm.hot, alpha=0.6)
label_sources(tab['Object'], PA_star, dPA, np.abs(dPA) > 45.0, allmask=m)
cb = plt.colorbar()
cb.set_label('Projected distance from Trapezium, D / arcmin')
plt.xlabel('PA of source from Trapezium, deg')
plt.ylabel('Angle between bowshock axis and radial direction, deg')
ax.set_xlim(-30.0, 375.0)
ax.set_ylim(-90.0, 90.0)
def plot_fitting_results(self):
"""
Plotting model fitting results.
"""
data_dates = [self.ref_date + timedelta(days=t) for t in self.times]
if self.hospital_times is not None:
hosp_dates = [
self.ref_date + timedelta(days=float(t))
for t in self.hospital_times
]
model_dates = [
self.ref_date + timedelta(days=t + self.fit_results['t0'])
for t in self.t_list
]
# Don't display the zero-inflated error bars
cases_err = np.array(self.cases_stdev)
cases_err[self.observed_new_cases == 0] = 0
death_err = deepcopy(self.deaths_stdev)
death_err[self.observed_new_deaths == 0] = 0
if self.hosp_stdev is not None:
hosp_stdev = deepcopy(self.hosp_stdev)
hosp_stdev[hosp_stdev > 1e5] = 0
plt.figure(figsize=(18, 12))
plt.errorbar(data_dates,
self.observed_new_cases,
yerr=cases_err,
marker='o',
linestyle='',
label='Observed Cases Per Day',
color='steelblue',
capsize=3,
alpha=.4,
markersize=10)
plt.errorbar(data_dates,
self.observed_new_deaths,
yerr=death_err,
marker='d',
linestyle='',
label='Observed Deaths Per Day',
color='firebrick',
capsize=3,
alpha=.4,
markersize=10)
plt.plot(model_dates,
self.mle_model.results['total_new_infections'],
label='Estimated Total New Infections Per Day',
linestyle='--',
lw=4,
color='steelblue')
plt.plot(model_dates,
self.fit_results['test_fraction'] *
self.mle_model.results['total_new_infections'],
label='Estimated Tested New Infections Per Day',
color='steelblue',
lw=4)
plt.plot(model_dates,
self.mle_model.results['total_deaths_per_day'],
label='Model Deaths Per Day',
color='firebrick',
lw=4)
if self.hospitalization_data_type is HospitalizationDataType.CUMULATIVE_HOSPITALIZATIONS:
new_hosp_observed = self.hospitalizations[
1:] - self.hospitalizations[:-1]
plt.errorbar(hosp_dates[1:],
new_hosp_observed,
yerr=hosp_stdev,
marker='s',
linestyle='',
label='Observed New Hospitalizations Per Day',
color='darkseagreen',
capsize=3,
alpha=1)
predicted_hosp = (self.mle_model.results['HGen_cumulative'] +
self.mle_model.results['HICU_cumulative'])
predicted_hosp = predicted_hosp[1:] - predicted_hosp[:-1]
plt.plot(model_dates[1:],
self.fit_results['hosp_fraction'] * predicted_hosp,
label='Estimated Total New Hospitalizations Per Day',
linestyle='-.',
lw=4,
color='darkseagreen',
markersize=10)
elif self.hospitalization_data_type is HospitalizationDataType.CURRENT_HOSPITALIZATIONS:
plt.errorbar(hosp_dates,
self.hospitalizations,
yerr=hosp_stdev,
marker='s',
linestyle='',
label='Observed Total Current Hospitalizations',
color='darkseagreen',
capsize=3,
alpha=.5,
markersize=10)
predicted_hosp = (self.mle_model.results['HGen'] +
self.mle_model.results['HICU'])
plt.plot(model_dates,
self.fit_results['hosp_fraction'] * predicted_hosp,
label='Estimated Total Current Hospitalizations',
linestyle='-.',
lw=4,
color='darkseagreen')
plt.plot(model_dates,
self.fit_results['hosp_fraction'] *
self.mle_model.results['HICU'],
label='Estimated ICU Occupancy',
linestyle=':',
lw=6,
color='black')
plt.plot(model_dates,
self.fit_results['hosp_fraction'] *
self.mle_model.results['HGen'],
label='Estimated General Occupancy',
linestyle=':',
lw=4,
color='black',
alpha=0.4)
plt.yscale('log')
y_lim = plt.ylim(.8e0)
start_intervention_date = self.ref_date + timedelta(
days=self.fit_results['t_break'] + self.fit_results['t0'])
stop_intervention_date = start_intervention_date + timedelta(days=14)
plt.fill_betweenx([y_lim[0], y_lim[1]],
[start_intervention_date, start_intervention_date],
[stop_intervention_date, stop_intervention_date],
alpha=0.2,
label='Estimated Intervention')
running_total = timedelta(days=0)
for i_label, k in enumerate(('symptoms_to_hospital_days',
'hospitalization_length_of_stay_general',
'hospitalization_length_of_stay_icu')):
end_time = timedelta(days=self.SEIR_kwargs[k])
x = start_intervention_date + running_total
y = 1.5**(i_label + 1)
plt.errorbar(x=[x],
y=[y],
xerr=[[timedelta(days=0)], [end_time]],
marker='',
capsize=8,
color='k',
elinewidth=3,
capthick=3)
plt.text(x + (end_time + timedelta(days=2)),
y,
k.replace('_', ' ').title(),
fontsize=14)
running_total += end_time
if self.SEIR_kwargs['beds_ICU'] > 0:
plt.hlines(self.SEIR_kwargs['beds_ICU'],
*plt.xlim(),
color='k',
linestyles='-',
linewidths=6,
alpha=0.2)
plt.text(data_dates[0] + timedelta(days=5),
self.SEIR_kwargs['beds_ICU'] * 1.1,
'Available ICU Capacity',
color='k',
alpha=0.5,
fontsize=15)
plt.ylim(*y_lim)
plt.xlim(min(model_dates[0], data_dates[0]),
data_dates[-1] + timedelta(days=150))
plt.xticks(rotation=30, fontsize=14)
plt.yticks(fontsize=14)
plt.legend(loc=4, fontsize=14)
plt.grid(which='both', alpha=.5)
plt.title(self.display_name, fontsize=20)
for i, (k, v) in enumerate(self.fit_results.items()):
fontweight = 'bold' if k in ('R0', 'Reff') else 'normal'
if np.isscalar(v) and not isinstance(v, str):
plt.text(1.05,
.7 - 0.032 * i,
f'{k}={v:1.3f}',
transform=plt.gca().transAxes,
fontsize=15,
alpha=.6,
fontweight=fontweight)
else:
plt.text(1.05,
.7 - 0.032 * i,
f'{k}={v}',
transform=plt.gca().transAxes,
fontsize=15,
alpha=.6,
fontweight=fontweight)
output_file = get_run_artifact_path(self.fips,
RunArtifact.MLE_FIT_REPORT)
plt.savefig(output_file, bbox_inches='tight')
plt.close()
self.mle_model.plot_results()
plt.savefig(output_file.replace('mle_fit_results', 'mle_fit_model'),
bbox_inches='tight')
plt.close()
def horiz_plot(v_coord, orography, style_args):
y = v_coord.points
x = orography.points
return plt.fill_betweenx(y, x, **style_args)
import matplotlib.pyplot as plt
inds_t, inds_v = [(clusters[cluster_ind]) for ii, cluster_ind in
enumerate(good_cluster_inds)][0] # first cluster
times = np.arange(X[0].shape[1]) * tstep * 1e3
plt.clf()
colors = ['y', 'b', 'g', 'purple']
event_ids = ['l_aud', 'r_aud', 'l_vis', 'r_vis']
for ii, (condition, color, eve_id) in enumerate(zip(X, colors, event_ids)):
# extract time course at cluster vertices
condition = condition[:, :, inds_v]
# normally we would normalize values across subjects but
# here we use data from the same subject so we're good to just
# create average time series across subjects and vertices.
mean_tc = condition.mean(axis=2).mean(axis=0)
std_tc = condition.std(axis=2).std(axis=0)
plt.plot(times, mean_tc.T, color=color, label=eve_id)
plt.fill_between(times, mean_tc + std_tc, mean_tc - std_tc, color='gray',
alpha=0.5, label='')
plt.xlabel('Time (ms)')
plt.ylabel('Activation (F-values)')
plt.xlim(times[[0, -1]])
plt.fill_betweenx(np.arange(*plt.ylim()), times[inds_t[0]],
times[inds_t[-1]], color='orange', alpha=0.3)
plt.legend()
plt.title('Interaction between stimulus-modality and location.')
plt.show()
d_dos = data[:, 3]
# check if orbital is in plotting list
if f'{el}_s' in list_dos_plot:
plt.plot(s_dos, energies, label=f'{el}' + '($\it{s}$)')
if f'{el}_p' in list_dos_plot:
plt.plot(p_dos, energies, label=f'{el}' + '($\it{p}$)')
if f'{el}_d' in list_dos_plot:
plt.plot(d_dos, energies, label=f'{el}' + '($\it{d}$)')
data_tot = np.loadtxt(dos_path + 'DOS_total.dat', dtype='f')
energies = data_tot[:, 0]
tot_dos = data_tot[:, 1]
#plt.plot(tot_dos, energies, label = 'total')
plt.fill_betweenx(energies, tot_dos, alpha=0.25, color='k')
plt.xlabel('DOS (a.u.)')
# axes
ax = plt.gca()
plt.yticks([])
# legend on right side of plot
#ax.legend(loc='center left', bbox_to_anchor=(1, 0.5))
plt.ylim(ymin, ymax)
plt.xlim(0, 9)
plt.legend()
#plt.show()
plt.savefig('dos_bs.pdf')
def hybridRasterBp(x,
names=None,
ax=None,
makeviolin=False,
cols=None,
rastsep=0.3,
Nkde=200,
kdepad=None,
kdew=0.8,
marker='x'):
'''
Create a boxplot with a raster plot to one side of the data contained in x.
If makeviolin is True then a kernel density estimate will be computed and
plotted down one side of the boxplot. If the matplotlib axis ax is not
specified, then the current axis will be used. The names used on the x-axis
can be specified in names, otherwise numbers will be used. A dictionary of
colours can be specified in cols, otherwise a cycle based on the default
matplotlib cycle will be used. rastsep specifies the horizontal seperation
between the raster plot and the left side of the boxplot, this can be
increased to move the raster points to the left or right. Nkde is used to
specify the resolution of the kernel density plot, should a higher resolution
is required. kdew specifies what fraction of the distance between the right
side of the boxplot and the raster plot should be used for the violin plot.
This does nothing if the violin plot is disabled. The default of 0.8
correspond to 80% of rastsep, which seems to give reasonable results. The
marker used in the scatter plot can be specified via the marker argument.
The argument x is expected to have entries (Nplots,Nobs)
'''
if ax is None:
ax = gca()
if names is None:
names = arange(len(x))
if cols is None:
cols = dict([
k for k in izip(names,
cycle([u'b', u'g', u'r', u'c', u'm', u'y', u'k']))
])
##############################################################################
# BOXPLOT
##############################################################################
bp = ax.boxplot(x, showfliers=False)
bx, cp, fl, mu, md, wh = (bp['boxes'], bp['caps'], bp['fliers'],
bp['means'], bp['medians'], bp['whiskers'])
ax.set_xticklabels(names)
# Colour the whiskers and boxes
for l, n0 in zip(bx, names):
x0, y0 = l.get_data()
xr = (x0[1] + x0[0]) / 2
xl = x0[0]
x1 = array([xl, xr, xr, xl, xl])
l.set_data(x1, y0)
l.set_color('k')
ax.add_patch(
patches.Rectangle(
(xl, y0[-1]), # (x,y)
xr - xl, # width
y0[-2] - y0[-1], # height
alpha=0.6,
edgecolor=None,
facecolor=cols[n0]))
for l in md:
x0, y0 = l.get_data()
xr = (x0[1] + x0[0]) / 2
xl = x0[0]
x1 = array([xl, xr])
l.set_data(x1, y0)
l.set_color('k')
for l in cp:
x0, y0 = l.get_data()
xr = (x0[1] + x0[0]) / 2
xl = x0[0]
x1 = array([xl, xr])
l.set_data(x1, y0)
l.set_color('k')
for l in wh:
l.set_color('k')
l.set_linestyle("-")
##############################################################################
# RASTER PLOT
##############################################################################
for i, (ix, n) in enumerate(zip(x, names)):
ax.scatter((1 + i) * ones_like(ix) + rastsep,
ix,
edgecolor=cols[n],
facecolor=cols[n],
marker=marker)
##############################################################################
# VIOLIN PLOT
##############################################################################
if makeviolin:
# Estimate limits for the kde
ymx = None
ymn = None
xmx = None
kdests = list()
for i, (ix, n) in enumerate(zip(x, names)):
if ymn is None or ymn > min(ix):
ymn = min(ix)
if ymx is None or ymx < max(ix):
ymx = max(ix)
if kdepad is None:
kdepad = (ymx - ymn) * 0.3
yr = linspace(ymn - kdepad, ymx + kdepad, Nkde)
for i, (ix, n) in enumerate(zip(x, names)):
kdests.append(gaussian_kde(ix))
nxmx = kdests[-1](yr).max()
if xmx is None or nxmx > xmx:
xmx = nxmx
# Plot lines and fill between them bsaed on the kernel density estimate
for i, (ix, n, gkde) in enumerate(zip(x, names, kdests)):
fill_betweenx(yr, (1 + i) * ones_like(yr),
(1 + i) + ((kdew * rastsep) / xmx) * gkde(yr),
color=cols[n],
zorder=10,
alpha=0.15)
plot(1 + i + ((kdew * rastsep) / xmx) * gkde(yr),
yr,
c=cols[n],
alpha=0.6,
lw=2,
zorder=-9)
plot(1 + i * ones_like(yr), yr, c='k', alpha=0.6, lw=2, zorder=-9)
return (bp)
def plot_vertical_fam_loss_by_route(fam='LOx',
ref_spec='O3',
wd=None,
Mechanism='Halogens',
rm_strat=False,
weight_by_molecs=True,
CODE_wd=None,
full_vertical_grid=True,
dpi=320,
suffix='',
save_plot=True,
show_plot=False,
limit_plotted_alititude=True,
lw=16,
Ox_loss_dict=None,
fontsize=10,
cmap=plt.cm.jet,
verbose=True,
debug=False):
"""
Plot vertical odd oxygen (Ox) loss via route (chemical family)
Parameters
-------
fam (str): tagged family to track (already compiled in KPP mechanism)
ref_spec (str): reference species to normalise to
wd (str): working directory ("wd") of model output
CODE_wd (str): root of code directory containing the tagged KPP mechanism
Mechanism (str): name of the KPP mechanism (and folder) of model output
weight_by_molecs (bool): weight grid boxes by number of molecules
rm_strat (bool): (fractionally) replace values in statosphere with zeros
debug, verbose (bool): switches to turn on/set verbosity of output to screen
full_vertical_grid (bool): use the full vertical grid for analysis
limit_plotted_alititude (bool): limit the plotted vertical extend to troposphere
suffix (str): suffix in filename for saved plot
dpi (int): resolution to use for saved image (dots per square inch)
Ox_loss_dict (dict), dictionary of Ox loss variables/data (from get_Ox_loss_dicts)
Returns
-------
(None)
Notes
-----
- AC_tools includes equivlent functions for smvgear mechanisms
"""
# - Local variables/ Plot extraction / Settings
if isinstance(Ox_loss_dict, type(None)):
Ox_loss_dict = AC.get_Ox_loss_dicts(
wd=wd,
CODE_wd=CODE_wd,
fam=fam,
ref_spec=ref_spec,
Mechanism=Mechanism,
rm_strat=rm_strat,
weight_by_molecs=weight_by_molecs,
full_vertical_grid=full_vertical_grid,
)
# extract variables from data/variable dictionary
sorted_fam_names = Ox_loss_dict['sorted_fam_names']
fam_dict = Ox_loss_dict['fam_dict']
ars = Ox_loss_dict['ars']
RR_dict_fam_stioch = Ox_loss_dict['RR_dict_fam_stioch']
RR_dict = Ox_loss_dict['RR_dict']
tags2_rxn_num = Ox_loss_dict['tags2_rxn_num']
tags = Ox_loss_dict['tags']
tags_dict = Ox_loss_dict['tags_dict']
Data_rc = Ox_loss_dict['Data_rc']
# Combine to a single array
arr = np.array(ars)
if debug:
print((arr.shape))
# - Process data for plotting
fam_tag = [fam_dict[i] for i in tags]
fam_ars = []
for fam_ in sorted_fam_names:
# Get indices for routes of family
fam_ind = [n for n, i in enumerate(fam_tag) if (i == fam_)]
if debug:
print((fam_ind, len(fam_ind)))
# Select these ...
fam_ars += [arr[fam_ind, ...]]
# Recombine and sum by family...
if debug:
print(([i.shape for i in fam_ars], len(fam_ars)))
arr = np.array([i.sum(axis=0) for i in fam_ars])
if debug:
print((arr.shape))
# - Plot up as a stack-plot...
# Normalise to total and conver to % (*100)
arr = (arr / arr.sum(axis=0)) * 100
# Add zeros array to beginning (for stack/area plot )
arr_ = np.vstack((np.zeros((1, arr.shape[-1])), arr))
# Setup figure
fig, ax = plt.subplots(figsize=(9, 6),
dpi=dpi,
facecolor='w',
edgecolor='w')
# Plot by family
for n, label in enumerate(sorted_fam_names):
# Print out some summary stats
if verbose:
print(n,
label,
arr[:n, 0].sum(axis=0),
arr[:n + 1, 0].sum(axis=0),
end=' ')
print(arr[:n, :].sum(), arr[:n + 1, :].sum())
print([i.shape for i in (Data_rc['alt'], arr)])
# Fill between X
plt.fill_betweenx(Data_rc['alt'],
arr[:n, :].sum(axis=0),
arr[:n + 1, :].sum(axis=0),
color=cmap(1. * n / len(sorted_fam_names)))
# Plot the line too
plt.plot(
arr[:n, :].sum(axis=0),
Data_rc['alt'],
label=label,
color=cmap(1. * n / len(sorted_fam_names)),
alpha=0,
lw=lw,
)
# Beautify the plot
plt.xlim(0, 100)
xlabel = '% of total O$_{\\rm x}$ loss'
plt.xlabel(xlabel, fontsize=fontsize * .75)
plt.yticks(fontsize=fontsize * .75)
plt.xticks(fontsize=fontsize * .75)
plt.ylabel('Altitude (km)', fontsize=fontsize * .75)
leg = plt.legend(loc='upper center', fontsize=fontsize)
# Update lengnd line sizes ( + update line sizes)
for legobj in leg.legendHandles:
legobj.set_linewidth(lw / 2)
legobj.set_alpha(1)
plt.ylim(Data_rc['alt'][0], Data_rc['alt'][-1])
# Limit plot y axis to 12km?
if limit_plotted_alititude:
plt.ylim(Data_rc['alt'][0], 12)
# Show plot or save?
if save_plot:
filename = 'Ox_loss_plot_by_vertical_{}_{}'.format(Mechanism, suffix)
plt.savefig(filename, dpi=dpi)
if show_plot:
plt.show()
def main(sta1,
sta2,
filterid,
components,
mov_stack=1,
show=True,
outfile=None):
db = connect()
maxlag = float(get_config(db, 'maxlag'))
start, end, datelist = build_movstack_datelist(db)
dtt_lag = get_config(db, "dtt_lag")
dtt_v = float(get_config(db, "dtt_v"))
dtt_minlag = float(get_config(db, "dtt_minlag"))
dtt_width = float(get_config(db, "dtt_width"))
dtt_sides = get_config(db, "dtt_sides")
minCoh = float(get_config(db, "dtt_mincoh"))
maxErr = float(get_config(db, "dtt_maxerr"))
maxDt = float(get_config(db, "dtt_maxdt"))
def plot_lags(minlag, maxlag):
plt.axhline(minlag, c='g')
plt.axhline(-minlag, c='g')
plt.axhline(maxlag, c='g')
plt.axhline(-maxlag, c='g')
if sta2 < sta1:
print("Stations STA1 STA2 should be sorted alphabetically")
return
sta1 = check_stations_uniqueness(db, sta1)
sta2 = check_stations_uniqueness(db, sta2)
pair = "%s_%s" % (sta1, sta2)
station1 = sta1.split(".")
station2 = sta2.split(".")
station1 = get_station(db, station1[0], station1[1])
station2 = get_station(db, station2[0], station2[1])
if dtt_lag == "static":
minlag = dtt_minlag
else:
minlag = get_interstation_distance(station1, station2,
station1.coordinates) / dtt_v
print(minlag)
maxlag2 = minlag + dtt_width
print("New Data for %s-%s-%i-%i" % (pair, components, filterid, mov_stack))
id = []
alldt = []
allcoh = []
for day in datelist:
fname = os.path.join('MWCS', "%02i" % filterid,
"%03i_DAYS" % mov_stack, components, pair,
'%s.txt' % day)
if os.path.isfile(fname):
df = pd.read_csv(fname,
delimiter=' ',
header=None,
index_col=0,
names=['t', 'dt', 'err', 'coh'])
alldt.append(df["dt"])
allcoh.append(df["coh"])
id.append(day)
del df
print(len(alldt[0]))
alldt = pd.DataFrame(alldt, index=pd.DatetimeIndex(id))
allcoh = pd.DataFrame(allcoh, index=pd.DatetimeIndex(id))
alldt = alldt.resample('D').mean()
allcoh = allcoh.resample('D').mean()
xextent = (date2num(id[0]), date2num(id[-1]), -maxlag, maxlag)
gs = gridspec.GridSpec(2, 2, width_ratios=[3, 1], height_ratios=[1, 1])
plt.figure()
ax1 = plt.subplot(gs[0])
im = plt.imshow(alldt.T,
extent=xextent,
aspect="auto",
interpolation='none',
origin='lower',
cmap=cm.seismic)
cscale = np.nanpercentile(alldt, q=99)
im.set_clim((cscale * -1, cscale))
cb = plt.colorbar()
cb.set_label('dt')
plt.ylabel("Lag Time (s)")
plt.axhline(0, lw=0.5, c='k')
plt.grid()
plt.title('%s : %s : dt' % (sta1, sta2))
plot_lags(minlag, maxlag2)
plt.setp(ax1.get_xticklabels(), visible=False)
print(type(alldt))
print(alldt)
plt.subplot(gs[1], sharey=ax1)
plt.plot(alldt.mean(axis=0), alldt.columns, c='k')
plt.grid()
plot_lags(minlag, maxlag2)
plt.axvline(-maxDt, c='r', ls='--')
plt.axvline(maxDt, c='r', ls='--')
plt.xlabel('dt')
plt.ylabel("Lag Time (s)")
ax2 = plt.subplot(gs[2], sharex=ax1, sharey=ax1)
plt.imshow(allcoh.T,
extent=xextent,
aspect="auto",
interpolation='none',
origin='lower',
cmap='hot',
vmin=minCoh,
vmax=1)
cb = plt.colorbar()
cb.set_label('mean coherence')
plt.ylabel("Lag Time (s)")
plt.axhline(0, lw=0.5, c='k')
plt.grid()
locator = AutoDateLocator()
ax2.xaxis.set_major_locator(locator)
ax2.xaxis.set_major_formatter(AutoDateFormatter(locator))
plt.setp(plt.xticks()[1], rotation=30, ha='right')
plt.title('%s : %s : mean coherence' % (sta1, sta2))
plot_lags(minlag, maxlag2)
plt.subplot(gs[3], sharey=ax1)
m = allcoh.mean(axis=0)
s = allcoh.std(axis=0)
plt.plot(m, allcoh.columns, c='k')
plt.fill_betweenx(
allcoh.columns,
m - s,
m + s,
color='silver',
)
plt.grid()
plot_lags(minlag, maxlag2)
plt.axvline(minCoh, c='r', ls='--')
plt.xlabel('Coherence')
plt.ylabel("Lag Time (s)")
name = '%s-%s f%i m%i' % (sta1, sta2, filterid, mov_stack)
name = name.replace('_', '.')
plt.suptitle(name)
if outfile:
if outfile.startswith("?"):
pair = pair.replace(':', '-')
outfile = outfile.replace(
'?', '%s-%s-f%i-m%i' % (pair, components, filterid, mov_stack))
outfile = "mwcs " + outfile
print("output to:", outfile)
plt.savefig(outfile)
if show:
plt.show()
def plot_reliability(data1, data2, nbins=10, cor='', maintitle="My Title", name_fig="diagram_att_T42.png", first=True, fig=None):
'''
Plot attribute diagram
Usage: attributediagr(data1,data2, nbins, maintitle)
Inputs:
data1: Vector of forecast probabilities for the event of
interest (e.g. precip. in the upper tercile)
data2: Vector of binary observations for the event of
interest (e.g. precip. in the upper tercile)
nbins: number of probability bins
maintitle: String containing the text for the reliability diagram title
Author: Caio Coelho <*****@*****.**>
Python implemantation: Arthur Costa <*****@*****.**>
'''
pf = data1
probfcsts = np.array(pf)
aux = probfcsts
probfcsts = probfcsts[ aux != np.NaN ]
binobs = data2
binobs = np.array(binobs)
binobs = binobs[aux != np.NaN]
aux1 = binobs
binobs = binobs[aux1 != np.NaN]
probfcsts = probfcsts[ aux1 != np.NaN ]
obar = np.nanmean(binobs)
n = len(probfcsts)
h1 = np.histogram(probfcsts, bins=np.arange(0., 1.+1./nbins, 1./nbins))[0]
g1 = np.histogram(probfcsts[binobs == 1], bins=np.arange(0., 1.+1./nbins, 1./nbins))[0]
h1 = np.array(h1).astype(float)
g1 = np.array(g1).astype(float)
obari = g1/h1
obari[obari == np.NaN] = 0
# Computes reliability,resolution and uncertainty components of the
# Brier score
yi = np.arange((1. / nbins) / 2., 1. + 1. / nbins, 1. / nbins)[:-1]
reliab = np.nansum(h1 * ((yi - obari)**2)) / n
resol = np.nansum(h1 * ((obari - obar)**2)) / n
uncert = obar * (1 - obar)
bs = reliab - resol + uncert
if first:
fig = plt.figure()
ax = fig.add_subplot(111)
ax.bar(yi * 100, h1 / n * 100., (yi[1] - yi[0]) * 100, edgecolor=cor, linewidth=3, color='none', align='center')
ax.plot(yi * 100, obari * 100, marker='o', markersize=7, markeredgecolor=cor, color=cor, linewidth=3)
# ax.plot([0, 100], [0, 100], color='gray')
if first:
x_plot = np.arange(101)
y_plot = (x_plot + (obar * 100)) / 2
plt.fill_betweenx(x_plot, 2 * y_plot - (obar * 100), x2=obar * 100, color="gray", alpha=0.5)
plt.fill_between(x_plot, x_plot, y_plot, color="gray", alpha=0.5)
plt.axhline(obar * 100, color='gray', ls='--')
plt.axvline(obar * 100, color='gray', ls='--')
# plt.plot(range(-10, 110),(range(-10, 110) + (obar * 100)) / 2, color='g', ls='--')
plt.plot(range(-10, 110),(range(-10, 110) + (obar * 100)) / 2, color='gray', ls='--')
#~ plt.text(05, 95, "Rel: " + str(round(reliab,2)))
#~ plt.text(05, 90, "Res: " + str(round(resol,2)))
#~ plt.text(05, 85, "Unc: " + str(round(uncert,2)))
#~ plt.text(05, 80, "BS: " + str(round(bs,2)))
plt.text(05, 95, "ACIMA", color='blue')
plt.text(05, 90, "NORMAL", color='y')
plt.text(05, 85, "ABAIXO", color='red')
plt.axis((0, 100, 0, 100))
plt.ylabel(u'Frequência Relativa Observada (%)')
plt.xlabel(u'Probabilidade da Previsão (%)')
plt.title(maintitle)
return fig, ax
# 图像设置
plt.figure(figsize=(15,7)) # figsize()设置的宽高比例是是15:7，图片的尺寸会根据这个比例进行调节
lowlimit=min(view)-500 #y轴下限
highlimit=max(view)+500 #y轴上限
plt.ylim(lowlimit,highlimit)
plt.grid(which='both')
# 绘制原始数据
plt.plot(range(1,len(view)+1),view,color='y',lw=0.5,label='origin')
plt.legend(loc='upper right')
plt.xlabel('time (s)')
plt.ylabel('views')
# 当存在高潮区间的时候标注高潮区间
if high:
for item in high:
plt.annotate('',xy=(item[1],1000),xytext=(item[0],1000),arrowprops=dict(arrowstyle="->",connectionstyle="arc3"))
plt.fill_betweenx([lowlimit,highlimit],item[0], item[1], linewidth=1, alpha=0.2, color='r')
# 结果保存（能不能不保存，直接获取图像数据显示）
despath='D:\\hot_pic1'
if not os.path.exists(despath):
os.makekdirs(despath)
fname=os.path.join(despath,cid+'.'+str(filesize)+'.jpg')
plt.savefig(fname,dpi = 300)
plt.close()
if __name__ == "__main__":
app.run()
#dbx=DBO()
#dbx.GET()
def Profile(self, coord_sys, axis, var, step):
""" Plots stress/strain in LCS or MCS against Z vector. """
# Sets plot dimension
fig = plt.figure()
#plt.figure(figsize=(10, 8))
Z = clt.assemble_Z(self.lam)
X = {
"inf": np.zeros((self.num_layers)),
"sup": np.zeros((self.num_layers))
}
Y = {
"inf": np.zeros((self.num_layers)),
"sup": np.zeros((self.num_layers))
}
P = np.zeros((self.num_layers * 2, 2))
# Sets the proper names
if coord_sys == "MCS":
if axis == 0:
axis_name = "1"
elif axis == 1:
axis_name = "2"
else:
axis_name = "6"
else:
if axis == 0:
axis_name = "x"
elif axis == 1:
axis_name = "y"
else:
axis_name = "xy"
# Formats the plot
plt.title('Profile ' + coord_sys + '-' + axis_name + ' ' + var)
plt.xlabel(var + ' (' + coord_sys + '-' + axis_name + ')')
plt.ticklabel_format(style='sci', axis='x', scilimits=(0, 0))
plt.ylabel('Z coordinate')
plt.grid(True)
# Iterates the layers, add data to plot
for layer in range(self.num_layers):
X["inf"][layer] = self.res[step][coord_sys][var]["inf"][axis][
layer]
Y["inf"][layer] = Z[layer]
X["sup"][layer] = self.res[step][coord_sys][var]["sup"][axis][
layer]
Y["sup"][layer] = Z[layer + 1]
P[layer * 2] = [X["inf"][layer], Y["inf"][layer]]
P[layer * 2 + 1] = [X["sup"][layer], Y["sup"][layer]]
plt.fill_betweenx([P[layer * 2, 1], P[layer * 2 + 1, 1]],
[P[layer * 2, 0], P[layer * 2 + 1, 0]],
hatch="//",
facecolor="none",
edgecolor="r",
lw=1.0)
# Adds main lines
plt.plot(P[:, 0], P[:, 1], color="r", lw=2.5)
plt.plot([0] * (self.num_layers + 1), Z, color="b", lw=2.5)
# Displays the plot
if self.display:
plt.show()
if self.save:
fig.savefig("plots/profile.png")
plt.close(fig)
"""
plt.vlines(confLevel95,
ymin=0,
ymax=1.8,
color='red',
label=r'$\alpha = 0.05$' + ' level')
#Creates a vertical line where the 99% critical value occurs
plt.vlines(confLevel99,
ymin=0,
ymax=1.8,
color='purple',
label=r'$\alpha = 0.01$' + ' level')
plt.fill_betweenx(yChi,
xChi,
criticalChi,
where=xChi > criticalChi,
color='orange')
plt.legend()
plt.show()
#Summary Statistics for Raw Height Data
#The statistics table has the following measures:
# 1. Mean
# 2. Variance
def oplotCentralRegion(plt, minR, maxR, minSM, maxSM, smLimit):
# add shaded region on left to show central area
plt.fill_betweenx(((smLimit-minSM)/(maxSM-minSM),1),0,(0-minR)/(maxR-minR),color='gray',alpha=0.1)
plt.clf()
plt.title(u'Diagramm 3.1: Phasengang eines RC-Glieds')
plt.xlabel('Wechselstromfrequenz der Eingangsspannung $f \, [kHz]$')
plt.ylabel(ur'Phasenverschiebung der Ausgangsspannung $\Phi \, [^\circ]$')
plt.xscale('log')
xspace = np.logspace(0.2,1)*const.kilo
yspace = np.linspace(0,90)
plt.ylim(yspace[0], yspace[-1])
plt.xlim(xspace[0]/const.kilo, xspace[-1]/const.kilo)
papstats.plot_data(f/const.kilo, phi, label='Messpunkte')
extrapolater = ip.UnivariateSpline(unp.nominal_values(f), unp.nominal_values(phi), k=3)
plt.plot(xspace/const.kilo, extrapolater(xspace), label='Extrapolation', color='b')
plt.axhline(45, color='black', label='$\Phi = 45^\circ$')
plt.axvline(f_G_theo.n/const.kilo, label='Theoretische Grenzfrequenz $f_G^{theo}$\nmit Fehlerbereich', color='g')
plt.fill_betweenx(yspace, (f_G_theo.n-f_G_theo.s)/const.kilo, (f_G_theo.n+f_G_theo.s)/const.kilo, color='g', alpha=0.2)
f_G_phas = unc.ufloat(3.09, 0.2)*const.kilo
plt.axvline(f_G_phas.n/const.kilo, color='r', label='Grenzfrequenz $'+papstats.pformat(f_G_phas/const.kilo, unit='kHz', label='f_G^{phas}')+'$\nnach Extrapolation mit Fehlerbereich')
plt.fill_betweenx(yspace, (f_G_phas.n-f_G_phas.s)/const.kilo, (f_G_phas.n+f_G_phas.s)/const.kilo, color='r', alpha=0.2)
plt.legend()
papstats.savefig_a4('3.1.png')
#####
print "# 4: Frequenzgang eines Serienschwingkreises"
#####
data = np.loadtxt('4.txt', skiprows=1, converters=dict.fromkeys(range(1,6), unc.ufloat_fromstr), dtype=object)
R, f_R, df, U_E, U_A = np.array(data[:,0], dtype=float), data[:,1]*const.kilo, (data[:,3]-data[:,2])*const.kilo, data[:,4], data[:,5]
R = R * unc.ufloat(1, 0.05)
def display_final(self):
mpl.figure(self.label+' thinning')
mpl.plot(self.tau, self.depth_mid, color=self.color_opt, label='Corrected +/-$\sigma$')
mpl.plot(self.tau_model, self.depth_mid, color=self.color_mod, label='Model')
mpl.fill_betweenx(self.depth_mid, self.tau-self.sigma_tau, self.tau+self.sigma_tau, color=self.color_ci)
# mpl.plot(self.tau+self.sigma_tau, self.depth_mid, color='k', linestyle='-', label='+/- 1 sigma')
# mpl.plot(self.tau-self.sigma_tau, self.depth_mid, color='k', linestyle='-')
x1,x2,y1,y2 = mpl.axis()
mpl.axis((x1,x2,self.depth_min,self.depth_max))
mpl.legend(loc=4)
mpl.ylim(mpl.ylim()[::-1])
pp=PdfPages(self.label+'/thinning.pdf')
pp.savefig(mpl.figure(self.label+' thinning'))
pp.close()
mpl.figure(self.label+' accumulation')
if show_initial:
mpl.step(self.age, np.concatenate((self.a_init, np.array([self.a_init[-1]]))), color=self.color_init, where='post', label='Initial')
mpl.step(self.age, np.concatenate((self.a_model, np.array([self.a_model[-1]]))), color=self.color_mod, where='post', label='Model')
mpl.step(self.age, np.concatenate((self.a, np.array([self.a[-1]]))), color=self.color_opt, where='post', label='Corrected +/-$\sigma$')
mpl.fill_between(self.age[:-1], self.a-self.sigma_a, self.a+self.sigma_a, color=self.color_ci)
x1,x2,y1,y2 = mpl.axis()
mpl.axis((self.age_min,x2,y1,y2))
mpl.legend()
pp=PdfPages(self.label+'/accumulation.pdf')
pp.savefig(mpl.figure(self.label+' accumulation'))
pp.close()
mpl.figure(self.label+' LIDIE')
mpl.step(self.age, self.LIDIE_model, color=self.color_mod,where='post', label='Model')
mpl.step(self.age, self.LIDIE, color=self.color_opt, where='post', label='Corrected +/-$\sigma$')
mpl.fill_between(self.age, self.LIDIE-self.sigma_LIDIE, self.LIDIE+self.sigma_LIDIE, color=self.color_ci)
x1,x2,y1,y2 = mpl.axis()
mpl.axis((self.age_min,x2,y1,y2))
mpl.legend()
pp=PdfPages(self.label+'/LIDIE.pdf')
pp.savefig(mpl.figure(self.label+' LIDIE'))
pp.close()
mpl.figure(self.label+' ice age')
mpl.plot(self.age, self.depth, color=self.color_opt, label='Corrected +/-$\sigma$')
mpl.plot(self.age_model, self.depth, color=self.color_mod, label='Model')
mpl.fill_betweenx(self.depth, self.age-self.sigma_age, self.age+self.sigma_age , color=self.color_ci)
# mpl.plot(self.age-self.sigma_age, self.depth, color='k', linestyle='-')
mpl.plot(self.sigma_age*10, self.depth, color=self.color_sigma, label='$\sigma$ x10')
x1,x2,y1,y2 = mpl.axis()
mpl.axis((x1,x2,self.depth_min,self.depth_max))
mpl.legend()
x1,x2,y1,y2 = mpl.axis()
mpl.axis((self.age_min,x2,y2,y1))
pp=PdfPages(self.label+'/ice_age.pdf')
pp.savefig(mpl.figure(self.label+' ice age'))
pp.close()
mpl.figure(self.label+' gas age')
mpl.plot(self.gage, self.depth, color=self.color_opt, label='Corrected +/-$\sigma$')
mpl.plot(self.gage_model, self.depth, color=self.color_mod, label='Model')
mpl.fill_betweenx(self.depth, self.gage-self.sigma_gage, self.gage+self.sigma_gage , color=self.color_ci)
# mpl.plot(self.gage+self.sigma_gage, self.depth, color='k', linestyle='-', label='+/- 1 sigma')
# mpl.plot(self.gage-self.sigma_gage, self.depth, color='k', linestyle='-')
mpl.plot(self.sigma_gage*10, self.depth, color=self.color_sigma, label='$\sigma$ x10')
x1,x2,y1,y2 = mpl.axis()
mpl.axis((x1,x2,self.depth_min,self.depth_max))
mpl.legend()
x1,x2,y1,y2 = mpl.axis()
mpl.axis((self.age_min,x2,y2,y1))
pp=PdfPages(self.label+'/gas_age.pdf')
pp.savefig(mpl.figure(self.label+' gas age'))
pp.close()
mpl.figure(self.label+' Ddepth')
mpl.plot(self.Ddepth_model, self.depth, color=self.color_mod, label='Model')
mpl.plot(self.Ddepth, self.depth, color=self.color_opt, label='Corrected +/-$\sigma$')
mpl.fill_betweenx(self.depth, self.Ddepth-self.sigma_Ddepth, self.Ddepth+self.sigma_Ddepth, color=self.color_ci)
# mpl.plot(self.Ddepth+self.sigma_Ddepth, self.depth, color='k', linestyle='-', label='+/- 1 sigma')
# mpl.plot(self.Ddepth-self.sigma_Ddepth, self.depth, color='k', linestyle='-')
x1,x2,y1,y2 = mpl.axis()
mpl.axis((x1,x2,self.depth_min,self.depth_max))
mpl.legend(loc=4)
mpl.ylim(mpl.ylim()[::-1])
pp=PdfPages(self.label+'/Ddepth.pdf')
pp.savefig(mpl.figure(self.label+' Ddepth'))
pp.close()
enumerate(good_cluster_inds)][0] # first cluster
times = np.arange(X[0].shape[1]) * tstep * 1e3
plt.figure()
colors = ['y', 'b', 'g', 'purple']
event_ids = ['l_aud', 'r_aud', 'l_vis', 'r_vis']
for ii, (condition, color, eve_id) in enumerate(zip(X, colors, event_ids)):
# extract time course at cluster vertices
condition = condition[:, :, inds_v]
# normally we would normalize values across subjects but
# here we use data from the same subject so we're good to just
# create average time series across subjects and vertices.
mean_tc = condition.mean(axis=2).mean(axis=0)
std_tc = condition.std(axis=2).std(axis=0)
plt.plot(times, mean_tc.T, color=color, label=eve_id)
plt.fill_between(times, mean_tc + std_tc, mean_tc - std_tc, color='gray',
alpha=0.5, label='')
ymin, ymax = mean_tc.min() - 5, mean_tc.max() + 5
plt.xlabel('Time (ms)')
plt.ylabel('Activation (F-values)')
plt.xlim(times[[0, -1]])
plt.ylim(ymin, ymax)
plt.fill_betweenx((ymin, ymax), times[inds_t[0]],
times[inds_t[-1]], color='orange', alpha=0.3)
plt.legend()
plt.title('Interaction between stimulus-modality and location.')
plt.show()
def main(sta1, sta2, filterid, components, mov_stack=1, show=True, outfile=None):
db = connect()
maxlag = float(get_config(db, "maxlag"))
start, end, datelist = build_movstack_datelist(db)
dtt_lag = get_config(db, "dtt_lag")
dtt_v = float(get_config(db, "dtt_v"))
dtt_minlag = float(get_config(db, "dtt_minlag"))
dtt_width = float(get_config(db, "dtt_width"))
dtt_sides = get_config(db, "dtt_sides")
minCoh = float(get_config(db, "dtt_mincoh"))
maxErr = float(get_config(db, "dtt_maxerr"))
maxDt = float(get_config(db, "dtt_maxdt"))
def plot_lags(minlag, maxlag):
plt.axhline(minlag, c="g")
plt.axhline(-minlag, c="g")
plt.axhline(maxlag, c="g")
plt.axhline(-maxlag, c="g")
sta1 = sta1.replace(".", "_")
sta2 = sta2.replace(".", "_")
if sta2 > sta1: # alphabetical order filtering!
pair = "%s_%s" % (sta1, sta2)
station1 = sta1.split("_")
station2 = sta2.split("_")
station1 = get_station(db, station1[0], station1[1])
station2 = get_station(db, station2[0], station2[1])
if dtt_lag == "static":
minlag = dtt_minlag
else:
minlag = get_interstation_distance(station1, station2, station1.coordinates) / dtt_v
print(minlag)
maxlag2 = minlag + dtt_width
print("New Data for %s-%s-%i-%i" % (pair, components, filterid, mov_stack))
format = "matrix"
alldf = []
id = []
alldt = []
allcoh = []
for day in datelist:
fname = os.path.join("MWCS", "%02i" % filterid, "%03i_DAYS" % mov_stack, components, pair, "%s.txt" % day)
# ~ print fname
if os.path.isfile(fname):
df = pd.read_csv(fname, delimiter=" ", header=None, index_col=0, names=["t", "dt", "err", "coh"])
alldt.append(df["dt"])
allcoh.append(df["coh"])
id.append(day)
del df
print(len(alldt[0]))
alldt = pd.DataFrame(alldt, index=pd.DatetimeIndex(id))
allcoh = pd.DataFrame(allcoh, index=pd.DatetimeIndex(id))
crange = [np.amin(alldt.values), np.amax(alldt.values)]
alldt = alldt.resample("D", how="mean")
allcoh = allcoh.resample("D", how="mean")
xextent = (date2num(id[0]), date2num(id[-1]), -maxlag, maxlag)
gs = gridspec.GridSpec(2, 2, width_ratios=[3, 1], height_ratios=[1, 1])
plt.figure()
ax = plt.subplot(gs[0])
plt.imshow(
alldt.T,
extent=xextent,
aspect="auto",
interpolation="none",
origin="lower",
cmap=cmap_center_point_adjust(cm.seismic, crange, 0),
)
cb = plt.colorbar()
cb.set_label("dt")
plt.ylabel("Lag Time (s)")
plt.axhline(0, lw=0.5, c="k")
plt.grid()
ax.xaxis.set_major_locator(YearLocator())
ax.xaxis.set_major_formatter(DateFormatter("%Y-%m-%d"))
plt.title("%s : %s : dt" % (sta1, sta2))
plot_lags(minlag, maxlag2)
plt.subplot(gs[1])
plt.plot(alldt.mean(axis=0), alldt.columns, c="k")
plt.grid()
plot_lags(minlag, maxlag2)
plt.axvline(-maxDt, c="r", ls="--")
plt.axvline(maxDt, c="r", ls="--")
plt.xlabel("dt")
plt.ylabel("Lag Time (s)")
ax = plt.subplot(gs[2], sharex=ax, sharey=ax)
plt.imshow(
allcoh.T,
extent=xextent,
aspect="auto",
interpolation="none",
origin="lower",
cmap="hot",
vmin=minCoh,
vmax=1,
)
# ~ plt.imshow(allcoh.T, extent=xextent,aspect="auto",interpolation='none',origin='lower',cmap='hot')
cb = plt.colorbar()
cb.set_label("mean coherence")
plt.ylabel("Lag Time (s)")
plt.axhline(0, lw=0.5, c="k")
plt.grid()
ax.xaxis.set_major_locator(YearLocator())
ax.xaxis.set_major_formatter(DateFormatter("%Y-%m-%d"))
plt.title("%s : %s : mean coherence" % (sta1, sta2))
plot_lags(minlag, maxlag2)
plt.subplot(gs[3])
m = allcoh.mean(axis=0)
s = allcoh.std(axis=0)
plt.plot(m, allcoh.columns, c="k")
plt.fill_betweenx(allcoh.columns, m - s, m + s, color="silver")
plt.grid()
plot_lags(minlag, maxlag2)
plt.axvline(minCoh, c="r", ls="--")
plt.xlabel("Coherence")
plt.ylabel("Lag Time (s)")
name = "%s-%s f%i m%i" % (sta1, sta2, filterid, mov_stack)
name = name.replace("_", ".")
plt.suptitle(name)
if outfile:
if outfile.startswith("?"):
pair = pair.replace(":", "-")
outfile = outfile.replace("?", "%s-%s-f%i-m%i" % (pair, components, filterid, mov_stack))
outfile = "mwcs " + outfile
print("output to:", outfile)
plt.savefig(outfile)
if show:
plt.show()