def test_fit_gaussian_2d(self):
import matplotlib.pylab as plt
# Create the gaussian data
Xin, Yin = plt.mgrid[0:201, 0:201]
data = self._gaussian(3, 100, 100, 20, 40)(Xin, Yin) + \
np.random.random(Xin.shape)
plt.clf()
ax2 = plt.axes([0, 0.52, 1.0, 0.4])
ax2.matshow(data, cmap=plt.cm.gist_earth_r)
params = ap.fitGaussianImage(data)
fit = self._gaussian(*params)
ax2.contour(fit(*np.indices(data.shape)), cmap=plt.cm.cool)
(height, x, y, width_x, width_y) = params
plt.text(0.95, 0.05, """
x : %.1f
y : %.1f
width_x : %.1f
width_y : %.1f""" %(x, y, width_x, width_y),
fontsize=16, horizontalalignment='right',
verticalalignment='bottom', transform=ax2.transAxes)
ax1 = plt.axes([0, 0.08, 1.0, 0.4])
def propagate_el_den_TB(Nx=50, Ny=40, mu=0.05, frame_num=100):
ham = envtb.ldos.hamiltonian.HamiltonianTB(Ny, Nx)
wf_final = wf_init_from_electron_density(ham, mu = mu)
maxel = 1.2 * np.max(wf_final.wf1d)
wf_final.plot_wave_function(maxel)
plt.axes().set_aspect('equal')
plt.savefig('../../../../Desktop/pics_2d/TB/0%d_2d.png' % 0)
plt.close()
for i in xrange(frame_num):
potential = envtb.ldos.potential.Potential1DFromFunction(
lambda x: -5. * (Ny/2 - x) * 2. / Ny * np.sin(0.1 * i))
ham2 = ham.apply_potential(potential)
envtb.ldos.plotter.Plotter().plot_potential(
ham2, ham, maxel = 5, minel = -5)
plt.axes().set_aspect('equal')
plt.savefig('../../../../Desktop/pics_2d/TB/pot%03d_2d.png' % i)
plt.close()
wf_init = wf_final
wf_final = propagate_wave_function(wf_init, ham2, maxel = maxel,
file_out = '../../../../Desktop/pics_2d/TB/f%03d_2d.png' % i)
return None
def display_grid(grid, **kwargs):
fig = plt.figure()
plt.axes().set_aspect('equal')
if kwargs.get('mark_core_cells', True):
core_cell_coords = grid._cell_nodes[1:-1, 1:-1]
cellx, celly = core_cell_coords[:, :, 0], core_cell_coords[:, :, 1]
plt.plot(cellx, celly, '-o', np.transpose(cellx), np.transpose(celly), '-o', color='red')
if kwargs.get('mark_boundary_cells', True):
boundary_cell_coords = grid._cell_nodes[0, :], \
grid._cell_nodes[-1, :], \
grid._cell_nodes[1:-1, 0], \
grid._cell_nodes[1:-1, -1]
for coords in boundary_cell_coords:
plt.plot(coords[:, 0], coords[:, 1], '-x', color='blue')
if kwargs.get('show', False):
plt.show()
f = BytesIO()
plt.savefig(f)
return f
def propagate_gauss_graphene(Nx=30, Ny=30, frame_num=100):
ham = envtb.ldos.hamiltonian.HamiltonianGraphene(Ny, Nx)
ic = Nx/2 * Ny + Ny/2 + 2
wf_final = wf_init_gaussian_wave_packet(
ham.coords, ic, p0=[1.0, 0.0], sigma=7.)
maxel = 0.8 * np.max(wf_final.wf1d)
wf_final.plot_wave_function(maxel)
plt.axes().set_aspect('equal')
plt.savefig('../../../../Desktop/pics_2d/graphene/0%d_2d.png' % 0)
plt.close()
dt_new = 0.5
NK_new = 12
for i in xrange(frame_num):
print 'frame %(i)d' % vars()
wf_init = wf_final
wf_final, dt_new, NK_new = propagate_wave_function(
wf_init, ham, NK=NK_new, dt=dt_new, maxel = maxel, regime='SIL',
file_out = '../../../../Desktop/pics_2d/graphene/f%03d_2d.png'
% i)
return None
def plot_fig(data):
nullfmt = NullFormatter()
x, y = data[:, 0], data[:, 1]
left, width = 0.1, 0.65
bottom, height = 0.1, 0.65
bottom_h = left_h = left + width + 0.02
rect_scatter = [left, bottom, width, height]
rect_histx = [left, bottom_h, width, 0.2]
rect_histy = [left_h, bottom, 0.2, height]
plt.figure(1, figsize=(8, 8))
axScatter = plt.axes(rect_scatter)
plt.xlabel("eruptions")
plt.ylabel("waiting")
axHistx = plt.axes(rect_histx)
axHisty = plt.axes(rect_histy)
axHistx.xaxis.set_major_formatter(nullfmt)
axHisty.yaxis.set_major_formatter(nullfmt)
axScatter.scatter(x, y)
# now determine nice limits by hand:
axHistx.hist(x, bins=20)
axHisty.hist(y, bins=20, orientation="horizontal")
plt.savefig("Scatter_Plot.png")
plt.show()
def plot(frame,dirname,clim=None,axis_limits=None):
if not os.path.exists('./figures'):
os.makedirs('./figures')
try:
sol=Solution(frame,file_format='petsc',read_aux=False,path='./saved_data/'+dirname+'/_p/',file_prefix='claw_p')
except IOError:
'Data file not found; please unzip the files in saved_data/.'
return
x=sol.state.grid.x.centers; y=sol.state.grid.y.centers
mx=len(x); my=len(y)
mp=sol.state.num_eqn
yy,xx = np.meshgrid(y,x)
p=sol.state.q[0,:,:]
if clim is not None:
pl.pcolormesh(xx,yy,p,cmap=cm.RdBu_r)
else:
pl.pcolormesh(xx,yy,p,cmap=cm.Reds)
pl.title("t= "+str(sol.state.t),fontsize=20)
pl.xticks(size=20); pl.yticks(size=20)
cb = pl.colorbar();
if clim is not None:
pl.clim(clim[0],clim[1]);
imaxes = pl.gca(); pl.axes(cb.ax)
pl.yticks(fontsize=20); pl.axes(imaxes)
pl.axis('equal')
if axis_limits is None:
pl.axis([np.min(x),np.max(x),np.min(y),np.max(y)])
else:
pl.axis([axis_limits[0],axis_limits[1],axis_limits[2],axis_limits[3]])
pl.savefig('./figures/'+dirname+'.png')
pl.close()
def plot_p(frame):
sol=Solution(frame,file_format='petsc',read_aux=False,path='./_output/_p/',file_prefix='claw_p')
x=sol.state.grid.x.centers; y=sol.state.grid.y.centers
mx=len(x); my=len(y)
mp=sol.state.num_eqn
yy,xx = np.meshgrid(y,x)
p=sol.state.q[0,:,:]
fig = pl.figure(figsize=(8, 3.5))
#pl.title("t= "+str(sol.state.t),fontsize=20)
pl.xticks(size=20); pl.yticks(size=20)
pl.xlabel('x',fontsize=20); pl.ylabel('y',fontsize=20)
#pl.pcolormesh(xx,yy,p_subxy,cmap=cm.OrRd)
pl.pcolormesh(xx,yy,p,cmap='RdBu_r')
pl.autoscale(tight=True)
cb = pl.colorbar(ticks=[0.5,1,1.5,2]);
#pl.clim(ticks=[0.5,1,1.5,2])
imaxes = pl.gca(); pl.axes(cb.ax)
pl.yticks(fontsize=20); pl.axes(imaxes)
#pl.xticks(fontsize=20); pl.axes(imaxes)
#pl.axis('equal')
pl.axis('tight')
fig.tight_layout()
pl.savefig('./_plots_to_paper/sound-speed_FV_t'+str(frame)+'_pcolor.png')
pl.close()
def _stacking(self, star_list, x_list, y_list):
"""
:param star_list:
:return:
"""
n_stars = len(star_list)
shifteds = []
for i in range(n_stars):
xc, yc = x_list[i], y_list[i]
data = star_list[i]
x_shift = int(xc) - xc
y_shift = int(yc) - yc
shifted = interp.shift(data, [-y_shift, -x_shift], order=1)
shifteds.append(shifted)
print('=== object ===', i)
import matplotlib.pylab as plt
fig, ax1 = plt.subplots()
im = ax1.matshow(np.log10(shifted), origin='lower')
plt.axes(ax1)
fig.colorbar(im)
plt.show()
combined = sum(shifteds)
new=np.empty_like(combined)
max_pix = np.max(combined)
p = combined[combined>=max_pix/10**6] #in the SIS regime
new[combined < max_pix/10**6] = 0
new[combined >= max_pix/10**6] = p
kernel = util.kernel_norm(new)
return kernel
def propagate_gauss_graphene_W90(Nx=30, Ny=20, magnetic_B=None,
frame_num=100):
ham_w90 = define_zigzag_ribbon_w90(
"../../exampledata/02_graphene_3rdnn/graphene3rdnnlist.dat",
Ny, Nx, magnetic_B=magnetic_B)
ham = envtb.ldos.hamiltonian.HamiltonianFromW90(ham_w90, Nx)
ic = ham.Nx/2 * ham.Ny + ham.Ny/2 + 2
wf_final = wf_init_gaussian_wave_packet(ham.coords, ic, sigma = 10.)
maxel = 0.8 * np.max(wf_final.wf1d)
wf_final.plot_wave_function(maxel)
plt.axes().set_aspect('equal')
plt.savefig('../../../../Desktop/pics_2d/grapheneW90/0%d_2d.png' % 0)
plt.close()
for i in xrange(frame_num):
wf_init = wf_final
wf_final = propagate_wave_function(wf_init, ham, maxel=maxel,
file_out='../../../../Desktop/pics_2d/grapheneW90/f%03d_2d.png' % i)[0]
return None
def plot_decision_surface(axes, clusters, X, Y=None):
import matplotlib.pylab as pylab
import numpy as np
def kmeans_predict(clusters, X):
from ..core import distance
dist_m = distance.minkowski_dist(clusters, X)
print 'dist_m:', dist_m.shape
pred = np.argmin(dist_m, axis=0)
print 'pred:', pred.shape
return pred
# step size in the mesh
h = (np.max(X, axis=0) - np.min(X, axis=0)) / 100.0
# create a mesh to plot in
x_min = np.min(X, axis=0) - 1
x_max = np.max(X, axis=0) + 1
xx, yy = np.meshgrid(np.arange(x_min[0], x_max[0], h[0]),
np.arange(x_min[1], x_max[1], h[1]))
Z = kmeans_predict(clusters, np.c_[xx.ravel(), yy.ravel()])
# Put the result into a color plot
Z = Z.reshape(xx.shape)
pylab.set_cmap(pylab.cm.Paired)
pylab.axes(axes)
pylab.contourf(xx, yy, Z, cmap=pylab.cm.Paired)
pylab.xlim(np.min(xx), np.max(xx))
pylab.ylim(np.min(yy), np.max(yy))
#pylab.axis('off')
# Plot also the training points
if Y is not None:
pylab.scatter(X[:,0], X[:,1], c=Y)
else:
pylab.scatter(X[:,0], X[:,1])
pylab.scatter(clusters[:,0], clusters[:,1], s=200, marker='x', color='white')
def __init__(self, ax, collection, mmc, img):
self.colornormalizer = Normalize(vmin=0, vmax=1, clip=False)
self.scat = plt.scatter(img[:, 0], img[:, 1], c=mmc.classvec)
plt.gray()
plt.setp(ax.get_yticklabels(), visible=False)
ax.yaxis.set_tick_params(size=0)
plt.setp(ax.get_xticklabels(), visible=False)
ax.xaxis.set_tick_params(size=0)
self.img = img
self.canvas = ax.figure.canvas
self.collection = collection
#self.alpha_other = alpha_other
self.mmc = mmc
self.prevnewclazz = None
self.xys = collection
self.Npts = len(self.xys)
self.lockedset = set([])
self.lasso = LassoSelector(ax, onselect=self.onselect)#, lineprops = {:'prism'})
self.lasso.disconnect_events()
self.lasso.connect_event('button_press_event', self.lasso.onpress)
self.lasso.connect_event('button_release_event', self.onrelease)
self.lasso.connect_event('motion_notify_event', self.lasso.onmove)
self.lasso.connect_event('draw_event', self.lasso.update_background)
self.lasso.connect_event('key_press_event', self.onkeypressed)
#self.lasso.connect_event('button_release_event', self.onrelease)
self.ind = []
self.slider_axis = plt.axes(slider_coords, visible = False)
self.slider_axis2 = plt.axes(obj_fun_display_coords, visible = False)
self.in_selection_slider = None
newws = list(set(range(len(self.collection))) - self.lockedset)
self.mmc.new_working_set(newws)
self.lasso.line.set_visible(False)
def plotLFP ():
print('Plotting LFP power spectral density...')
colorspsd=array([[0.42,0.67,0.84],[0.42,0.83,0.59],[0.90,0.76,0.00],[0.90,0.32,0.00],[0.34,0.67,0.67],[0.42,0.82,0.83],[0.90,0.59,0.00],[0.33,0.67,0.47],[1.00,0.85,0.00],[0.71,0.82,0.41],[0.57,0.67,0.33],[1.00,0.38,0.60],[0.5,0.2,0.0],[0.0,0.2,0.5]])
lfpv=[[] for c in range(len(sim.lfppops))]
# Get last modified .mat file if no input and plot
for c in range(len(sim.lfppops)):
lfpv[c] = sim.lfps[:,c]
lfptot = sum(lfpv)
# plot pops separately
plotPops = 0
if plotPops:
figure() # Open a new figure
for p in range(len(sim.lfppops)):
psd(lfpv[p],Fs=200, linewidth= 2,color=colorspsd[p])
xlabel('Frequency (Hz)')
ylabel('Power')
h=axes()
h.set_yticklabels([])
legend(['L2/3','L5A', 'L5B', 'L6'])
# plot overall psd
figure() # Open a new figure
psd(lfptot,Fs=200, linewidth= 2)
xlabel('Frequency (Hz)')
ylabel('Power')
h=axes()
h.set_yticklabels([])
show()
def plot_p_leading_order(frame):
mat = scipy.io.loadmat('sound-speed_2D-wave.mat')
T=5; nt=T/0.5
pp=mat['U'][nt,:,:]
xx=mat['xx']
yy=mat['yy']
fig=pl.figure(figsize=(8, 3.5))
#pl.title("t= "+str(sol.state.t),fontsize=20)
pl.xticks(size=20); pl.yticks(size=20)
pl.xlabel('x',fontsize=20); pl.ylabel('y',fontsize=20)
#pl.pcolormesh(xx,yy,p_subxy,cmap=cm.OrRd)
pl.pcolormesh(xx,yy,pp,cmap='RdBu_r')
pl.autoscale(tight=True)
cb = pl.colorbar(ticks=[0.5,1,1.5,2]);
#pl.clim(ticks=[0.5,1,1.5,2])
imaxes = pl.gca(); pl.axes(cb.ax)
pl.yticks(fontsize=20); pl.axes(imaxes)
#pl.xticks(fontsize=20); pl.axes(imaxes)
#pl.axis('equal')
pl.axis('tight')
fig.tight_layout()
pl.savefig('./_plots_to_paper/sound-speed_LO_t'+str(frame)+'_pcolor.png')
pl.close()
def plot(self, data, topn):
""" Plot data fit and residuals """
from matplotlib import pylab as pl
pl.axes([0.1, 0.4, 0.8, 0.4]) # leave room above the axes for the table
self.fit_plot(data, topn=topn)
pl.axes([0.1, 0.05, 0.8, 0.3])
self.residual_plot(data, topn=topn)
def newCreateAndSaveMultilineFig(xDataList, yDataList, xLabel="", yLabel="",
figFileRoot="", fileExt='.png', xMin=0,
xMax=0, yMin=0, yMax=0, legendFlag=1,
legendFont=12, traceNameList=[],
legLoc=(0, 0)):
"""This subroutine saves a figure with multiple lines."""
figFileName = figFileRoot + fileExt
colorDict = createColorDictWithDashes()
if xMax == 0:
curMax = 0
for n in range(0, len(xDataList)):
if type(xDataList[n]) == list:
if max(xDataList[n]) > curMax:
curMax = max(xDataList[n])
else:
if xDataList[n].any() > curMax:
curMax = max(xDataList[n])
xMax = curMax
if yMax == 0:
curMax = 0
for n in range(0, len(yDataList)):
if type(yDataList[n]) == list:
if max(yDataList[n]) > curMax:
curMax = max(yDataList[n])
else:
if yDataList[n].any() > curMax:
curMax = max(yDataList[n])
yMax = curMax
plt.axes([0.1, 0.1, 0.71, 0.8])
if traceNameList == []:
for n in range(0, len(xDataList)):
traceNameList.append("Trace_" + str(n))
for n in range(0, len(xDataList)):
xData = convert_list_to_array(xDataList[n])
yData = convert_list_to_array(yDataList[n])
tempPlot = plt.plot(
xData, yData, colorDict[str(n + 1)], hold="True",
label=traceNameList[n])
plt.xlabel(xLabel)
plt.ylabel(yLabel)
plt.xlim(xMin, xMax)
plt.ylim(yMin, yMax)
plt.rc("legend", fontsize=legendFont)
if legendFlag == 1:
if legLoc != (0, 0):
print(legLoc)
plt.legend(loc=legLoc)
else:
plt.legend()
plt.savefig(figFileName, dpi=300)
plt.clf()
def plot_scatter(x,y,show=1,nbins=100,xrange=None,yrange=None,title="",xtitle="",ytitle=""):
from matplotlib.ticker import NullFormatter
# the random data
nullfmt = NullFormatter() # no labels
# definitions for the axes
left, width = 0.1, 0.65
bottom, height = 0.1, 0.65
bottom_h = left_h = left+width+0.02
rect_scatter = [left, bottom, width, height]
rect_histx = [left, bottom_h, width, 0.2]
rect_histy = [left_h, bottom, 0.2, height]
# start with a rectangular Figure
fig = plt.figure(figsize=(8,8))
axScatter = plt.axes(rect_scatter)
axHistx = plt.axes(rect_histx)
axHisty = plt.axes(rect_histy)
# no labels
axHistx.xaxis.set_major_formatter(nullfmt)
axHisty.yaxis.set_major_formatter(nullfmt)
# now determine nice limits by hand:
binwidth = np.array([x.max() - x.min(), y.max() - y.min()]).max() / nbins
if xrange == None:
xrange = np.array((x.min(), x.max()))
if yrange == None:
yrange = np.array((y.min(), y.max()))
# the scatter plot:
axScatter.scatter(x, y, marker='.', edgecolor='b', s=.1)
axScatter.set_xlabel(xtitle)
axScatter.set_ylabel(ytitle)
axScatter.set_xlim( xrange )
axScatter.set_ylim( yrange )
bins_x = np.arange(xrange[0], xrange[1] + binwidth, binwidth)
axHistx.hist(x, bins=nbins)
axHisty.hist(y, bins=nbins, orientation='horizontal')
axHistx.set_xlim( axScatter.get_xlim() )
axHistx.set_title(title)
axHisty.set_ylim( axScatter.get_ylim() )
if show: plt.show()
return fig
def save_wave_function_pic(self, pic_out, maxel=None, figuresize=(20,10), **kwrds):
if figuresize:
plt.figure(figsize=figuresize) # in inches!
self.plot_wave_function(maxel)
plt.axes().set_aspect('equal')
plt.savefig(pic_out)
plt.close()
return None
def image(Z,xnew,ynew,my_cmap=None,aspect='equal'):
"""
Creates pretty image. You need to specify:
"""
imshow(log10(Z),extent=[xnew[0],xnew[-1],ynew[0],ynew[-1]], cmap=my_cmap)
pylab.axes().set_aspect('equal')
colorbar()
circle2=Circle((0,0),1,color='k')
gca().add_artist(circle2)
savefig('tmp.png',transparent=True,dpi=150)
def plot_q(frame,file_prefix='claw',path='./_output/',plot_pcolor=True,plot_slices=True,slices_xlimits=None):
import sys
sys.path.append('.')
import sw_eqns
sol=Solution(frame,file_format='petsc',read_aux=False,path=path,file_prefix=file_prefix)
x=sol.state.grid.x.centers; y=sol.state.grid.y.centers
mx=len(x); my=len(y)
h=sol.state.q[0,:,:]
b=sw_eqns.bathymetry(x,y)[0,:,:]
eta=h+b
yy,xx = np.meshgrid(y,x)
if frame < 10:
str_frame = "000"+str(frame)
elif frame < 100:
str_frame = "00"+str(frame)
elif frame < 1000:
str_frame = "0"+str(frame)
else:
str_frame = str(frame)
if plot_pcolor:
pl.pcolormesh(xx,yy,eta)
pl.title("t= "+str(sol.state.t),fontsize=20)
pl.xlabel('x',fontsize=20); pl.ylabel('y',fontsize=20)
pl.xticks(size=20); pl.yticks(size=20)
cb = pl.colorbar();
#pl.clim(colorbar_min,colorbar_max);
imaxes = pl.gca(); pl.axes(cb.ax)
pl.yticks(fontsize=20); pl.axes(imaxes)
pl.axis([np.min(x),np.max(x),np.min(y),np.max(y)])
pl.savefig('./_plots/eta_'+str_frame+'.png')
#pl.show()
pl.close()
if plot_slices:
pl.figure(figsize=(8,3))
pl.plot(x,eta[:,3*my/4.],'-r',lw=1)
pl.plot(x,eta[:,my/4.],'--b',lw=1)
#pl.plot(x,b[:,my/4],'-k',lw=1)
#pl.plot(x,b[:,3*my/4],'--k',lw=1)
pl.title("t= "+str(sol.state.t),fontsize=20)
pl.xlabel('x',fontsize=20)
pl.ylabel('Surface',fontsize=20)
pl.xticks(size=20); pl.yticks(size=20)
#pl.ylim([0.9998,1.0002])
pl.xlim([0.0,20])
if slices_xlimits is not None:
pl.axis([slices_xlimits[0],slices_xlimits[1],np.min(p),np.max(p)])
pl.savefig('./_plots/eta_'+str_frame+'_slices.png')
pl.close()
def ana():
pl.figure()
pl.clf()
pl.axes([0.16,0.2,0.95-0.15,0.95-0.2])
pl.plot(x,y1,'g:',label=r'$\psi$')
pl.plot(x,y2,'-b',label=r'$\psi^*\psi$')
pl.xlabel(r'$y$ [nm]')
pl.ylabel(r'$\pi$ [arb. units]')
ax = pl.gca()
ax.yaxis.set_label_coords(xshift, 0.5)
# pl.legend()
pl.savefig('images/analytical3.pdf',transparent='true')
def plot_p(frame,file_prefix='claw_p',path='./_output/_p',plot_slices=True,plot_pcolor=True,slices_limits=None,xshift=0.0,name='',title=True):
sol_ref=Solution(frame+450,file_format='petsc',read_aux=False,path='_output/reference/_p/',file_prefix=file_prefix)
sol=Solution(frame,file_format='petsc',read_aux=False,path=path,file_prefix=file_prefix)
x=sol.state.grid.x.centers; y=sol.state.grid.y.centers
x=x+xshift
mx=len(x); my=len(y)
yy,xx = np.meshgrid(y,x)
if frame < 10:
str_frame = "00"+str(frame)
elif frame < 100:
str_frame = "0"+str(frame)
else:
str_frame = str(frame)
p=sol.state.q[0,:,:]
p_ref=sol_ref.state.q[0,:,:]
if plot_pcolor:
pl.pcolormesh(xx,yy,p,cmap=cm.OrRd)
pl.title("t= "+str(sol.state.t),fontsize=20)
pl.xlabel('x',fontsize=20); pl.ylabel('y',fontsize=20)
pl.xticks(size=20); pl.yticks(size=20)
cb = pl.colorbar();
#pl.clim(colorbar_min,colorbar_max);
imaxes = pl.gca(); pl.axes(cb.ax)
pl.yticks(fontsize=20); pl.axes(imaxes)
pl.axis([np.min(x),np.max(x),np.min(y),np.max(y)])
#pl.axis([0.25,60.25,0.25,60.25])
pl.savefig('./_plots_to_paper/co-interaction_'+str_frame+name+'.png')
#pl.show()
pl.close()
if plot_slices:
pl.figure(figsize=(8,3))
pl.gcf().subplots_adjust(left=0.10)
# plot reference
pl.plot(x,p_ref[:,my/4.],'--b',linewidth=1)
pl.plot(x,p_ref[:,3*my/4.],'--r',linewidth=1)
# plot solution of interaction
pl.plot(x,p[:,3*my/4.],'-r',linewidth=2)
pl.plot(x,p[:,my/4.],'-b',linewidth=2)
pl.title("t= "+str(sol.state.t),fontsize=20)
pl.xlabel('x',fontsize=20)
if title:
pl.ylabel('Stress',fontsize=20)
pl.xticks(size=20); pl.yticks(size=20)
if slices_limits is not None:
pl.axis([slices_limits[0]+xshift,slices_limits[1]+xshift,slices_limits[2],slices_limits[3]])
pl.savefig('./_plots_to_paper/co-interaction_'+str_frame+name+'.eps')
pl.close()
def plot_wave_function(self, maxel=None, **kwrds):
'''
The funciton plots the wave function
In:
maxel: maximum value
**kwrds: keywords for the plot function
Return:
None
'''
envtb.ldos.plotter.Plotter().plot_density(
np.abs(self.wf1d), self.coords, max_el=maxel, **kwrds)
plt.axes().set_aspect('equal')
def overlay():
pl.figure()
pl.clf()
pl.axes([0.16,0.2,0.95-0.15,0.95-0.2])
pl.plot(x,y4,'-b',label='$n1_{ana}$')
pl.plot(x,y3,'r2',label='$n1_{sim}$',markersize=3)
pl.xlabel(r'$y$ [nm]')
pl.ylabel(r'$n$ [1/m$^2$] $\times 10^{17}$')
ax = pl.gca()
ax.yaxis.set_label_coords(xshift, 0.5)
locs,labels = pl.yticks()
pl.yticks(locs, map(lambda x: r"$ %.1f $" % x, locs*1e-17))
# pl.text(-0.17, 0.9, r'$\times 10^{17}$', fontsize=10, transform = pl.gca().transAxes)
# pl.legend()
pl.savefig('images/overlay1.pdf',transparent='true')
def error():
pl.figure()
pl.clf()
error=(y4-y3)*100/(sum(y3)/len(x))
pl.axes([0.16,0.2,0.95-0.15,0.95-0.2])
pl.plot(x,error,'-r',label=r'Error')
pl.xlabel(r'$y$ [nm]')
pl.ylabel(r'relative error [\%]')
ax = pl.gca()
ax.yaxis.set_label_coords(xshift, 0.5)
# locs,labels = pl.yticks()
# pl.yticks(locs, map(lambda x: r"$ %.1f $" % x, locs*1))
# pl.text(-0.19, 0.86, r'$\times 10^{-1}$', fontsize=10, transform = pl.gca().transAxes)
# pl.legend()
pl.savefig('images/error3.pdf',transparent='true')
def plot_peak_isoerror(
epsilon=[0.5, 0.2, 0.1, 0.05, 0.01, 0.001],
wlim=(pi / 32, pi / 4),
fmt="-",
ax=None,
legend=True,
degrees=False,
**kwargs
):
"""Plot iso-error (iso-epsilon) curves of feedback peak across cue size
Additional keyword arguments are passed to error.gamma().
"""
epsilon = np.asarray(epsilon)
if ax is None:
f = plt.figure()
ax = plt.axes()
else:
f = ax.get_figure()
sigma = np.linspace(wlim[0], wlim[1], N)
# Plot width curves
conv = degrees and 180 / pi or 1.0
for eps in epsilon:
plt.plot(conv * sigma, gamma(sigma=sigma, epsilon=eps, **kwargs), fmt, label=r"$\epsilon=%.3f$" % eps)
# Set axis attributes
plt.title(r"$A/\sigma,\epsilon$")
plt.xlabel(r"$\sigma$")
plt.ylabel("A")
plt.xlim(xmin=conv * wlim[0], xmax=conv * wlim[1])
if legend:
plt.legend()
return f
def validate(X_test, y_test, pipe, title, fileName):
print('Test Accuracy: %.3f' % pipe.score(X_test, y_test))
y_predict = pipe.predict(X_test)
confusion_matrix = np.zeros((9,9))
for p,r in zip(y_predict, y_test):
confusion_matrix[p-1,r-1] = confusion_matrix[p-1,r-1] + 1
print (confusion_matrix)
confusion_normalized = confusion_matrix.astype('float') / confusion_matrix.sum(axis=1)[:, np.newaxis]
print (confusion_normalized)
pylab.clf()
pylab.matshow(confusion_normalized, fignum=False, cmap='Blues', vmin=0.0, vmax=1.0)
ax = pylab.axes()
ax.set_xticks(range(len(families)))
ax.set_xticklabels(families, fontsize=4)
ax.xaxis.set_label_position('top')
ax.xaxis.set_ticks_position("top")
ax.set_yticks(range(len(families)))
ax.set_yticklabels(families, fontsize=4)
pylab.title(title)
pylab.colorbar()
pylab.grid(False)
pylab.grid(False)
pylab.savefig(fileName, dpi=900)
def plot_alpha_vs_peak(peaks=[0.1, 0.25, 0.5, 1, 2, 5], tlim=(-5, 5), ax=None, norm=True, legend=True, **kwargs):
"""Plot alpha (phase error) across time for different peak feedback gains
Additional keyword arguments are passed to error.alpha().
"""
peaks = np.asarray(peaks)
if ax is None:
f = plt.figure()
ax = plt.axes()
else:
f = ax.get_figure()
t = np.linspace(tlim[0], tlim[1], N)
# Plot time curves
for peak in peaks:
err = alpha(t, A=peak, **kwargs)
if norm:
err /= err[0]
plt.plot(t, err, "-", label="A = %.2f" % peak)
# Set axis attributes
plt.title(r"$\alpha(t)$")
plt.xlabel("t (s)")
plt.ylabel("error")
plt.xlim(tlim)
if legend:
plt.legend()
return f
def plot_peak_isowidth(
width=[pi / 32, pi / 16, pi / 8, pi / 4, pi / 2], elim=(0.001, 0.9), fmt="-", ax=None, legend=True, **kwargs
):
"""Plot iso-width (iso-sigma) curves of feedback peak across phase error
Additional keyword arguments are passed to error.gamma().
"""
width = np.asarray(width)
if ax is None:
f = plt.figure()
ax = plt.axes()
else:
f = ax.get_figure()
eps = np.linspace(elim[0], elim[1], N)
# Plot width curves
for sigma in width:
plt.plot(eps, gamma(sigma=sigma, epsilon=eps, **kwargs), fmt, label=r"$\sigma=%.3f$" % sigma)
# Set axis attributes
plt.title(r"$A/\epsilon,\sigma$")
plt.xlabel(r"$\epsilon$")
plt.ylabel("A")
plt.xlim(elim)
if legend:
plt.legend()
return f
def plot_alpha_vs_width(
widths=[pi / 24, pi / 12, pi / 9, pi / 6, pi / 4, pi / 2], tlim=(-5, 5), ax=None, norm=True, legend=True, **kwargs
):
"""Plot alpha (phase error) across time for different cue sizes (widths)
Additional keyword arguments are passed to error.alpha().
"""
widths = np.asarray(widths)
if ax is None:
f = plt.figure()
ax = plt.axes()
else:
f = ax.get_figure()
t = np.linspace(tlim[0], tlim[1], N)
# Plot time curves
for width in widths:
err = alpha(t, sigma=width, **kwargs)
if norm:
err /= err[0]
plt.plot(t, err, "-", label=r"$\sigma = %.3f$" % width)
# Set axis attributes
plt.title(r"$\alpha(t)$")
plt.xlabel("t (s)")
plt.ylabel("error")
plt.xlim(tlim)
if legend:
plt.legend()
return f
def plotWeightChanges():
if f.usestdp:
# create plot
figh = figure(figsize=(1.2*8,1.2*6))
figh.subplots_adjust(left=0.02) # Less space on left
figh.subplots_adjust(right=0.98) # Less space on right
figh.subplots_adjust(top=0.96) # Less space on bottom
figh.subplots_adjust(bottom=0.02) # Less space on bottom
figh.subplots_adjust(wspace=0) # More space between
figh.subplots_adjust(hspace=0) # More space between
h = axes()
# create data matrix
wcs = [x[-1][-1] for x in f.allweightchanges] # absolute final weight
wcs = [x[-1][-1]-x[0][-1] for x in f.allweightchanges] # absolute weight change
pre,post,recep = zip(*[(x[0],x[1],x[2]) for x in f.allstdpconndata])
ncells = int(max(max(pre),max(post))+1)
wcmat = zeros([ncells, ncells])
for iwc,ipre,ipost,irecep in zip(wcs,pre,post,recep):
wcmat[int(ipre),int(ipost)] = iwc *(-1 if irecep>=2 else 1)
# plot
imshow(wcmat,interpolation='nearest',cmap=bicolormap(gap=0,mingreen=0.2,redbluemix=0.1,epsilon=0.01))
xlabel('post-synaptic cell id')
ylabel('pre-synaptic cell id')
h.set_xticks(f.popGidStart)
h.set_yticks(f.popGidStart)
h.set_xticklabels(f.popnames)
h.set_yticklabels(f.popnames)
h.xaxif.set_ticks_position('top')
xlim(-0.5,ncells-0.5)
ylim(ncells-0.5,-0.5)
clim(-abs(wcmat).max(),abs(wcmat).max())
colorbar()
def _plot_seasonality(self, alpha, plot_kwargs):
#two_tailed_alpha = int(alpha / 2 * 100)
periods = list(set([float(i.split("_")[1]) for i in self.seasonality]))
additive_ts, multiplicative_ts = self._fit_seasonality()
all_seasonalities = [('additive', additive_ts)]
if len(self.multiplicative_data):
all_seasonalities.append(('multiplicative', multiplicative_ts))
for sn, ts in all_seasonalities:
if (sn == 'multiplicative' and np.sum(ts) == 1) or (sn == 'additive' and np.sum(ts) == 0):
continue
ddf = pd.DataFrame(
np.vstack([
np.percentile(ts[:, :, self.skip_first:], 50, axis=-1),
np.percentile(ts[:, :, self.skip_first:], alpha / 2 * 100, axis=-1),
np.percentile(ts[:, :, self.skip_first:], (1 - alpha / 2) * 100, axis=-1)
]).T,
columns=["%s_%s" % (p, l) for l in ['mid', 'low', 'high'] for p in periods[::-1]]
)
ddf.loc[:, 'ds'] = self.data['ds']
for period in periods:
if int(period) == 0:
step = int(self.data['ds'].diff().mean().total_seconds() // float(period))
else:
step = int(period)
graph = ddf.head(step)
if period == 7:
ddf.loc[:, 'dow'] = [i for i in ddf['ds'].dt.weekday]
graph = ddf[['dow', '%s_low' % period, '%s_mid' % period, '%s_high' % period]].groupby(
'dow').mean().sort_values('dow')
graph.loc[:, 'ds'] = [['Sun', 'Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat', 'Sun'][i]
for i in graph.index]
graph = graph.sort_index()
plt.figure(**plot_kwargs)
graph.plot(
y="%s_mid" % period,
x='ds',
color='C0',
legend=False,
ax=plt.gca()
)
plt.grid()
if period == 7:
plt.xticks(range(7), graph['ds'].values)
plt.fill_between(
np.arange(0, 7),
graph["%s_low" % period].values.astype(float),
graph["%s_high" % period].values.astype(float),
alpha=.3,
)
else:
plt.fill_between(
graph['ds'].values,
graph["%s_low" % period].values.astype(float),
graph["%s_high" % period].values.astype(float),
alpha=.3,
)
plt.title("Model Seasonality (%s) for period: %s days" % (sn, period))
plt.axes().xaxis.label.set_visible(False)
plt.show()
def correlator_online(fileinput='input.txt',dark_file='default',mask_file='default',plot='yes'):
global datreg, nq, corf, n, sl, sr, nchannels, nchannels2, index_in_q, lind, dt, norm, srr, sll, nc, oneq, I_avg, I_avg2, lm1, lm2, lm1b, lm2b, ax1,ax1b, ax2, ax2b, ccd_img, ttdata,tcalc_cum, tplot_cum, tread_cum, tdrop_cum, tI_avg,q_2tcf, I_avgs, rch, rcr,totsaxs,input_info,l,y,v, sst, xnq, wtotmask
time1=time.time()
p.rc('image',origin = 'lower')
p.rc('image',interpolation = 'nearest')
print 'reading input...'
input_info=get_input(fileinput)
##########################processing input file###############################
dir= input_info['dir']
dir_dark= input_info['dark dir']
if dir_dark=='none':
dir_dark=dir
file_prefix=input_info['file_prefix']
ext = input_info['file_suffix']
#####New version has capabilities of reading also .gz files####
if ext == '.edf.gz':
dataread=EdfFile.EdfGzipFile
else:
dataread=EdfFile.EdfFile
##################################################
firstfile=int(input_info['n_first_image'])
lastfile=int(input_info['n_last_image'])+1
firstdark=input_info['n_first_dark']
if firstdark.lower() != 'none':
firstdark=int(input_info['n_first_dark'])
lastdark=int(input_info['n_last_dark'])+1
geometry=input_info['geometry'].lower()
tolerance=float32(float(input_info['tolerance']))
avgt = input_info['lag time'].lower()
dt=find_lagt(avgt,input_info,dataread)
print 'lag time =', dt
q_2tcf=(input_info['q for TRC']).lower()
if q_2tcf!='none':
q_2tcf=int(q_2tcf)
out_dir=get_dir(input_info['output directory'])
out_prefix=get_prefix(input_info['output filename prefix'])
out_tot=out_dir+out_prefix
print '...done'
##################end processing input file###################################
firstname=dir+file_name(file_prefix,ext,firstfile)
f=dataread(firstname)
ccd_info=f.GetStaticHeader(0)
ncol=int(ccd_info['Dim_1'])
nrows=int(ccd_info['Dim_2'])
static=out_tot+'static.edf'
static_data=asfarray(loadedf(static),dtype=float32)
if input_info['n_first_dark'].lower()=='none':
print 'not using darks'
tot_darks=0*static_data
else:
print 'using darks'
if dark_file=='default':
dark_file=out_tot+'dark.edf'
print 'using dark file:', dark_file
tot_darks=asfarray(loadedf(dark_file),dtype=float32)
toplot=static_data+.001 #to avoid zeros in plotting logarithm###
print '...done'
print '...reading mask'
if mask_file=='default':
mask_file=out_tot+'mask.edf'
print 'using mask file:', mask_file
totmask=loadedf(mask_file,0)+loadedf(mask_file,1)
wtotmask=where(totmask==0)
p.ion()
fileq=out_tot+'qmask.edf'
q=loadedf(fileq)
maxval=int(amax(q)+2)
detector=input_info['detector']
flatfield_file=input_info['flatfield file']
if detector=='medipix':
flat_field=flatfield(detector,flatfield_file)
else:
flat_field=1.0
print '...done'
if geometry=='saxs':
print '...correcting static for baseline'
xbeam=int(input_info['x direct beam'])
ybeam=int(input_info['y direct beam'])
static_data=rad_average(static_data,totmask,xbeam,ybeam)
qaxis_list=[]
npix_per_q=[]
oneq=[]
index_in_q=[]
firstq=float32(float(input_info['first q']))
deltaq=float32(float(input_info['delta q']))
stepq=float32(float(input_info['step q']))
qvalue=firstq+deltaq/2
static_corrected=ones(shape(static_data),dtype=float32)
q*=abs(totmask-1)
for i in range(2,maxval,2):
indices=where(q==i)
index_in_q.append(indices)#gives the indices of pixels that are not masked at this q
if geometry=='saxs':
static_corrected[indices]=mean(static_data[indices])/static_data[indices]
npixel=len(static_data[indices])
npix_per_q.append(npixel)
oneq.append(ones((1,npixel)))
qaxis_list.append(qvalue)
qvalue+=deltaq+stepq
print '...done'
nq=len(npix_per_q)
xnq=xrange(nq)
tmpdat=loadtxt(out_tot+'1Dstatic.dat')
qaxis=tmpdat[:,0]
I_q=tmpdat[:,1]
del tmpdat
##FINISHED INITIALIZING PART OF THE CODE######
##START MAIN PART FOR CORRELATION#####
nchannels=16.
nchannels2=nchannels/2
nfile=lastfile-firstfile
datregt=[]
datreg=[]
rch=int(ceil(log(nfile/nchannels)/log(2))+1)
###2time
if q_2tcf!='none':
ttdata=zeros((nfile,npix_per_q[q_2tcf-1]),dtype=float32)
###2time
for ir in xrange(rch):
for iq in xnq:
datregt.append(zeros((npix_per_q[iq],nchannels),dtype=float32))
datreg.append(datregt)
datregt=[]
del datregt
rcr=nchannels+nchannels2*ceil(log(nfile/nchannels)/log(2))
corf=zeros((nq,rcr),dtype=float32)
lag=zeros((1,rcr),dtype=float32)
data_shape=p.shape(toplot)
smatr=zeros(data_shape,dtype=float32)
matr=zeros(data_shape,dtype=float32)
sl=zeros((nq,rcr),dtype=float32)
sr=zeros((nq,rcr),dtype=float32)
norm=zeros((1,rcr),dtype=float32)
sll=[]
srr=[]
sst=[]
for ir in xrange(rch):
if ir==0:
lag[0,:nchannels]=dt*arange(1,nchannels+1,1)
norm[0,:nchannels]=1./arange(nfile-2,nfile-nchannels-2,-1)
else:
lag[0,nchannels2*(ir+1):nchannels2*(ir+2)]=(dt*2**ir)*arange(1+nchannels2,nchannels+1)
norm[0,nchannels2*(ir+1):nchannels2*(ir+2)]=1./arange((nfile-1)/(2**ir)-nchannels2-1,(nfile-1)/(2**ir)-nchannels-1,-1)
sll.append(zeros((nq,nchannels),dtype=float32))
srr.append(zeros((nq,nchannels),dtype=float32))
sst.append(arange(nq)*0.0)
#END of declaring and initializing variables####
#READING FILES
filenames=[]
for k in xrange(firstfile,lastfile):
filenames.append(file_name(file_prefix,ext,k))
n=0
lind=npix_per_q
if plot!='no':
ax1=p.axes([0.11, 0.08, 0.75, 0.57])
ax1.set_xlabel('t [sec]')
ax1.set_ylabel('g^2(q,t)')
ax1b=p.twinx(ax1)
ax1b.yaxis.tick_right()
ax2=p.axes([0.11, 0.73, 0.75, 0.19])
ax2.xaxis.tick_bottom()
ax2.set_xlabel('t [sec]')
ax2.set_ylabel('I(q,t) [a.u.]')
ax2b=p.gcf().add_axes(ax2.get_position(),frameon=False)
ax2b.xaxis.tick_top()
ax2b.yaxis.tick_right()
ax2b.xaxis.set_label_position('top')
ax2b.set_xlabel('Image no.')
label1='q= %2.1e 1/Ang' % qaxis_list[0]
label2='q= %2.1e 1/Ang' % qaxis_list[nq/2]
lm1,=ax1.semilogx((1,),(1,),'ro-',label=label1)
lm1b,=ax1b.semilogx((1,),(1,),'bo-',label=label2)
ax1.legend(loc='lower left')
ax1b.legend(loc=(0.02,0.1))
lm2,=ax2.plot((1,),(1,),'r-')
lm2b,=ax2b.plot((1,),(1,),'b-')
p.setp(ax1.get_yticklabels(), color='r')
p.setp(ax1b.get_yticklabels(), color='b')
p.setp(ax2.get_yticklabels(), color='r')
p.setp(ax2b.get_yticklabels(), color='b')
tplot_cum=0
tread_cum=0
tdrop_cum=0
tcalc_cum=0
I_avg=zeros((1,nfile),float32)
I_avg2=zeros((1,nfile),float32)
I_avgs=zeros((nq,nfile),float32)
tI_avg=zeros((1,nfile),float32)
mon=zeros((1,nfile),int)
totsaxs=0*static_data
detector=input_info['detector'].lower()
Mythread=Thread
#Mythread=Process
checkfile=os.path.exists
n=0
firstdata=dir+filenames[n]
f=dataread(firstdata)
dread(f,n,tot_darks,flat_field,static_corrected)
goodsize=os.path.getsize(dir+filenames[n])
nnfile=nfile-1
stop=0
if input_info['normalize'].lower()!= 'none':
print "normalizing to ", input_info['normalize']
else:
print "not normalizing"
while n<nnfile:
#nc=n+1.
nc=n+1
ccd_imgn=ccd_img
file=filenames[n+1]
tempfile=dir+file
wait=0
t0=time.time()
while checkfile(tempfile) is False:
p.draw()
sys.stdout.write(50*'\x08')
sys.stdout.write('waiting for file'+ file+'...')
sys.stdout.flush()
t1=time.time()
wait+=t1-t0
time.sleep(1)
t0=t1
if wait>10*dt:
print nfile
ans=raw_input('\n will this file ever arrive? (y/N)')
if ans.lower()=='y':
print '\n keep waiting...\n'
time.sleep(3*dt)
wait=0
else:
stop=1
nfile=n+1
break
if stop==1:
break
if ext=='.edf': #cannot do the check for gz files as their size are not to be equal.
filesize=os.path.getsize(tempfile)
while filesize!=goodsize:
sys.stdout.write(50*'\x08')
sys.stdout.write('file '+ file+'still not ready...')
sys.stdout.flush()
time.sleep(2)
filesize=os.path.getsize(tempfile)
tmf=dataread(tempfile)
thrd=Mythread(target=dread,args=([tmf,n+1,tot_darks,flat_field,static_corrected]))
thcor=Mythread(target=correlator,args=([0,ccd_imgn]))
mon[0,n]= monitor
#for plot. TO be faster, I only updated plot each nchannels files.
if nc%nchannels==0:
pct=float32(n)/float32(nfile)*100
sys.stdout.write(50*'\x08')
sys.stdout.write('read '+str(int(pct))+'% of files'+32*' ')
sys.stdout.flush()
if plot!='no':
ttplot(corf,sr,sl,norm,n+1, I_avg[0,:n+1], I_avg2[0,:n+1],lag)
#thplot.join()
#thplot=Mythread(target=ttplot,args=([corf,sr,sl,norm,n+1, I_avg[0,:n+1], I_avg2[0,:n+1]]))
#thplot.start()
thrd.start()
thcor.start()
thrd.join()
thcor.join()
n+=1
#END OF MAIN LOOP
#calculate 2 times correlation function
sys.stdout.write(50*'\x08')
sys.stdout.flush()
print "read 100% of files"
#calculate correlation functions
if stop==1:
print nfile, shape(I_avgs)
tI_avg=tI_avg[:,:nfile]
mon=mon[:,:nfile]
I_avgs=I_avgs[:,:nfile]
rch=int(ceil(log(nfile/nchannels)/log(2))+1)
for ir in xrange(rch):
if ir==0:
norm[0,:nchannels]=1./arange(nfile-2,nfile-nchannels-2,-1)
else:
norm[0,nchannels2*(ir+1):nchannels2*(ir+2)]=1./arange((nfile-1)/(2**ir)-nchannels2-1,(nfile-1)/(2**ir)-nchannels-1,-1)
indt=int(nchannels+nchannels2*log(nfile/nchannels)/log(2))-2
cc=zeros((indt,nq+1),float32)
q_title='#q values:'
trace_title='#file_no. , time, monitor, q values:'
for cindex in xnq:
q_title=q_title+' '+str(qaxis_list[cindex])
trace_title=trace_title+' '+str(qaxis_list[cindex])
cc[:,cindex+1]=corf[cindex,:indt]/(sl[cindex,:indt]*sr[cindex,:indt])/\
norm[0,:indt]
cc[:,0]=lag[0,:indt]
q_title=q_title+'\n'
trace_title=trace_title+'\n'
del indt
f=open(out_tot+'cf.dat','w')
f.write(q_title)
savetxt(f, cc)
f.close()
del cc
f=open(out_tot+'trace.dat','w')
f.write(trace_title)
traces=zeros((nfile,nq+3),float32)
traces[:,0]=tI_avg/dt+firstfile
traces[:,1]=tI_avg
traces[:,2]=mon
traces[:,3:]=transpose(I_avgs[:,:])
savetxt(f,traces)
f.close()
del traces
static=out_tot+'static.edf'
totsaxs=totsaxs/nfile-tot_darks
totsaxs[totsaxs<=0]=0
saveedf(static,totsaxs)
del static
del totsaxs
del tot_darks
print 'correlation functions are saved to ', out_tot+'cf.dat'
print 'traces are saved to ', out_tot+'trace.dat'
if input_info['normalize'].lower()!= 'none':
print "data normalized to ", input_info['normalize']
else:
print "data not normalized"
if input_info['dropletize'].lower()=='yes':
print "data dropletized: !!!!CAUTION this is valid only for andor 13 micron and dark subtracted images (adu per photon = 1930 +/- 100, zero photon = 0 +/- 200)"
#if plot!='no':
# p.hold(True)
# raw_input('Press enter to close window')
# p.close()
p.hold(True)
p.close()
if q_2tcf!='none':
print "calculating time resolved cf and chi4..."
if nfile>6000: #this is for 4 GB RAM PC
nfile=6000
n=6000
if q_2tcf!='none':
lind2=npix_per_q[q_2tcf-1]/16
l=arange(5)*0
y=[]
v=[]
for i in range(5):
y.append([])
v.append([])
ib=0
for i in xrange(16):
sys.stdout.write(50*'\x08')
sys.stdout.write('done '+str(int(i/16.*100))+'% of data'+32*' ')
sys.stdout.flush()
ie=ib+lind2
y[0].append(trc(ttdata[:n-1,ib:ie]))
v[0].append(vartrc(y[0][-1]))
if l[0]==1:
recurf(0)
else:
l[0]+=1
ib+=lind2
vm=[]
for i in range(4,-1,-1):
vm.append(mean(v[i],0))
vm=array(vm)
del ttdata
del v
sys.stdout.write(50*'\x08')
sys.stdout.flush()
file_2times=out_tot+'2times_q_'+str(q_2tcf)+'.edf'
ytrc.write(file_2times,y[4][0])
print 'Time resolved CF is saved to '+ out_tot+'2times_q_'+str(q_2tcf)+'.edf'
N=array([[1],[2],[4],[8],[16]])/float(npix_per_q[q_2tcf-1])
data=concatenate((N,vm),1).T
#print 'number of pixels ',lind[ttcf_par]
#print 'q value=', qv[ttcf_par]
p0=[0.0,1.0]
it=range(len(data[1:,0]))
p1=zeros((len(data[1:,0]),len(p0)+1))
p1[:,0]=(asfarray(it)+1.0)*dt
xdata=data[0,:]
for i in it:
ydata=data[i+1,:]
p1[i,1:],success=leastsq(errfunc,p0,args=(xdata,ydata))
outfile=out_tot+'fitchi4_q_'+str(q_2tcf)+'.dat'
f=open(outfile,'w')
f.write("#time chi4 error q value:"+str(qaxis_list[q_2tcf-1])+"\n")
savetxt(f,p1)
f.close()
print 'file is saved to '+outfile
print "saving results..."
time2=time.time()
print 'elapsed time', time2-time1
if plot!='no':
print 'elapsed time for plotting', tplot_cum
print 'elapsed time for reading', tread_cum-tdrop_cum
if input_info['dropletize'].lower()=='yes':
print 'elapsed time for dropletizing', tdrop_cum
print 'elapsed time for correlating', tcalc_cum
print 'calculations have finished:)'
# Use the outermost moon to calculate the length of one full orbit duration
orbit_duration = math.sqrt(
(4 * math.pi**2 * thirdmoon.px**3) / (G * (thirdmoon.mass + planet.mass)))
orbit_duration = orbit_duration * 1.005
# Run simulation. Make sure to add/remove the moons you want to simulate!
ttv_array, tdv_array = run_sim(R_star, transit_duration,
[planet, firstmoon, secondmoon, thirdmoon])
# Output information
print 'TTV amplitude =', numpy.amax(ttv_array), \
'[min] = ', numpy.amax(ttv_array) * 60, '[sec]'
print 'TDV amplitude =', numpy.amax(tdv_array), \
'[min] = ', numpy.amax(tdv_array) * 60, '[sec]'
ax = plt.axes()
plt.plot(ttv_array, tdv_array, color='k')
plt.rc('font', **{'family': 'serif', 'serif': ['Computer Modern']})
plt.rc('text', usetex=True)
plt.tick_params(axis='both', which='major', labelsize=16)
plt.xlabel('transit timing variation [minutes]', fontsize=16)
plt.ylabel('transit duration variation [minutes]', fontsize=16)
ax.tick_params(direction='out')
plt.ylim([numpy.amin(tdv_array) * 1.2, numpy.amax(tdv_array) * 1.2])
plt.xlim([numpy.amin(ttv_array) * 1.2, numpy.amax(ttv_array) * 1.2])
plt.plot((0, 0), (numpy.amax(tdv_array) * 10., numpy.amin(tdv_array) * 10.),
'k',
linewidth=0.5)
plt.plot((numpy.amin(ttv_array) * 10., numpy.amax(ttv_array) * 10.), (0, 0),
'k',
linewidth=0.5)
if opts.show:
pylab.show()
else:
pylab.close()
##Plotting waterfall
if opts.verb: print 'Plotting occupancy waterfall'
#Set-up plot format
left, width = 0.1, 0.65
bottom, height = 0.1, 0.65
bottom_h = left_h = left + width + 0.02
rect_imshow = [left, bottom, width, height]
rect_histx = [left, bottom_h, width, 0.2]
rect_histy = [left_h, bottom, 0.2, height]
pylab.figure(1, figsize=(8, 8))
axImshow = pylab.axes(rect_imshow)
axHistx = pylab.axes(rect_histx)
axHisty = pylab.axes(rect_histy)
axHistx.xaxis.set_major_formatter(nullfmt)
axHisty.yaxis.set_major_formatter(nullfmt)
#actuallly interact with data
axImshow.imshow(flg_arr,
aspect='auto',
interpolation='nearest',
cmap='binary',
extent=[100., 200., t_arr[len(t_arr) - 1], t_arr[0]])
axHistx.plot(fqs, pcnt_f)
axHistx.fill_between(fqs, 0, pcnt_f, color='blue', alpha=0.3)
axHisty.plot(pcnt_t, tms, 'b-')
#!/usr/bin/env python
import matplotlib
matplotlib.rcParams.update({'font.size': 22})
nprocs = [1, 2, 4, 8, 16, 32]
# exLaplace3d 512 20
times = [2 * 60 + 21.4, 60 + 23.4, 48.4, 29.6, 19.7, 15.1]
speedup = [times[0] / t for t in times]
from matplotlib import pylab
pylab.plot(nprocs, speedup, 'ko', nprocs, speedup, 'b-', [1, 10], [1, 10],
'c--')
pylab.title('Pan Ivy Bridge exLaplace3d 512 20')
pylab.xlabel('number of MPI processes')
pylab.ylabel('speedup')
pylab.axes([1, 32, 1, 10])
pylab.show()
lon = nc.variables['lon'][:]
lat = nc.variables['lat'][:]
nc.close()
cmap = plt.cm.Spectral_r
cmaplist = [cmap(i) for i in range(cmap.N)]
cmap = mpl.colors.LinearSegmentedColormap.from_list('Custom cmap', cmaplist,
cmap.N)
# define the bins and normalize
bounds = np.linspace(0, 42, 7)
norm = mpl.colors.BoundaryNorm(bounds, cmap.N)
projection = ccrs.PlateCarree(central_longitude=180)
ax = plt.axes(projection=projection)
ax.set_global()
ax.coastlines(resolution='50m', lw=0.5, zorder=4)
gl = ax.gridlines(draw_labels=True,
linestyle='--',
xlocs=[-120, -60, 0, 60, 120, 180, 240],
zorder=6)
gl.xlabels_top = gl.ylabels_right = False
gl.xformatter = LONGITUDE_FORMATTER
gl.yformatter = LATITUDE_FORMATTER
# ax.add_feature(cartopy.feature.LAND, facecolor='0.5', zorder=3)
ax.add_feature(cfeature.NaturalEarthFeature(
'physical',
'land',
'50m',
p = sns.lineplot(x=data.index, y=data, color='b')
p.tick_params(labelsize=10, rotation=45)
plt.setp(p.lines, linewidth=2)
ani = animation.FuncAnimation(fig, animate, frames=45, repeat=True)
ani.save('load.mp4', writer=writer)
# alternative animation
series_ani = joined
series_ani_onemon = series_ani['2010-01']
series_ani_onemon = pd.concat([pd.Series(series_ani_onemon.values),
pd.Series(range(series_ani_onemon.shape[0]))],
axis=1)
fig = plt.figure(figsize=(16, 10))
ax = plt.axes(xlim=(0, 47), ylim=(6.5, 14.5))
ax.set_xlabel('Hour', fontsize=20)
ax.set_ylabel('GW', fontsize=20)
ax.tick_params(labelsize=15)
line, = ax.plot([], [], lw=2)
def init():
line.set_data([], [])
return line,
# x_data, y_data = [], []
def animate(i): # called sequentially, staring with 0
idx_start = int(i) + 48
x = list(range(0, 48))
y = list(series_ani_onemon.iloc[:, 0][(idx_start-48):idx_start].values)
plt.plot(idc2010_hi_x,
idc2010_hi_y,
linewidth=2,
label='IDC2010-HI High Noise Model')
plt.plot(idc2010_li_x,
idc2010_li_y,
linewidth=2,
label='IDC2010-LI Low Noise Model')
plt.xlim(0.01, 50) # Hz
plt.xscale('log')
title = 'AM.BKSVL.01.BDF'
subtitle = 'Microbarometer Power Spectral Density. 24 hours @ %.1f SPS. AD7746 CAPCHOP=0.' % (
fs)
titlestr = r'\begin{center}{\textbf{%s\\}}%s\end{center}' % (title, subtitle)
plt.title(titlestr)
plt.xlabel('Frequency (Hz)')
plt.ylabel('dB Pa\u00b2/Hz')
plt.axes().xaxis.grid(True, which='both')
plt.axes().yaxis.grid(True)
plt.legend()
at = AnchoredText(
'RMS noise @ 1 Hz: %.2f \u00b5Pa\u00b2/Hz (%.1f dB Pa\u00b2/Hz)\n' \
'Bandlimited RMS noise 0.5 - 2 Hz: %.1f milliPascal\n' \
'Bandlimited RMS noise 0.1 - 50 Hz: %.1f milliPascal' \
% (noise_1hz*1e6, noise_1hz_db, noise_nb*1e3, noise_wb*1e3),
frameon=True, loc='lower left')
at.patch.set_ec('lightgrey')
at.patch.set_alpha(0.75)
plt.gca().add_artist(at)
plt.show()
ax2.text(pos[tick], medians[tick] + 0.1, median_labels[tick],
horizontalalignment='center', size='medium', color = color[i], weight='semibold')
i+=1
x1, x2, x3 = 0, 1, 2
ax2.text(x1, matrix_box.min().min().round()-0.5 , "1971-2000", ha='center', va='bottom', size='medium', color='black', weight='semibold')
ax2.text((x2+x3)*.5, matrix_box.min().median()-0.5 , "2071-2100", ha='center', va='bottom', size='medium', color='black', weight='semibold')
ax2.set(xlabel='')
plt.yticks( fontsize=14)
plt.savefig('K:/PROJETS/PROJET_CLIMHUNOR/figures/Mean_tasmax/VI_MONTH_'+m+'_Mean_tasmax.png', bbox_inches='tight', format='png', dpi=1000)
plt.show()
plt.close()
fig = plt.figure(figsize=(28,16))
ax = plt.axes(projection=ccrs.PlateCarree())
ax.set_extent([-72,-64,47,51])
ax.add_feature(cfeature.OCEAN.with_scale('50m')) # couche ocean
ax.add_feature(cfeature.LAND.with_scale('50m')) # couche land
ax.add_feature(cfeature.LAKES.with_scale('50m')) # couche lac
ax.add_feature(cfeature.BORDERS.with_scale('50m')) # couche frontieres
ax.add_feature(cfeature.RIVERS.with_scale('50m')) # couche rivières
coast = cfeature.NaturalEarthFeature(category='physical', scale='10m', # ajout de la couche cotière
facecolor='none', name='coastline')
ax.add_feature(coast, edgecolor='black')
states_provinces = cfeature.NaturalEarthFeature(
category='cultural',
name='admin_1_states_provinces_lines',
def forceChain(self,
axis=(0, 2),
alpha=numpy.pi / 4,
plot_stress=True,
plot_parts=False,
peters=True,
threshold=1):
""" Computes the force chain based on an algorithm published in Phys. Rev. E. 72, 041307 (2005):
'Characterization of force chains in granular material'.
@ axis: a tuple of size 2 that specifies the two axis to use for computing the force chain, e.g. axis=(0,1) -> (x,y)
@ alpha: the angle (in radians) that controls the deviation of the force chain. A value of 0 means a perfectly linear chain.
Thus, alpha is a measure of the 'curvature' of the force chain. See page 5 of the paper cited above.
"""
stress = numpy.zeros((self._Particles.natoms, 2, 2))
stress_prin = numpy.zeros((self._Particles.natoms,
3)) # 2 stress components + angle = 4 dims
coords = numpy.array(
[self._Particles.x, self._Particles.y, self._Particles.z])
x, y = coords[axis[0]], coords[axis[1]]
# Compute net stresses on all particles
for contact in self._overlaps:
i, j = int(contact[1]), int(contact[2])
overlap = self._Particles.radius[i] + self._Particles.radius[
j] + numpy.array([x[i] - x[j], y[i] - y[j]])
vi = 4.0 / 3.0 * numpy.pi * self._Particles.radius[i]**3.0
vj = 4.0 / 3.0 * numpy.pi * self._Particles.radius[j]**3.0
stress_i = numpy.outer(
self._model.normalForce(overlap, self._Particles.radius[i]),
overlap) / vi
stress_j = numpy.outer(
self._model.normalForce(overlap, self._Particles.radius[j]),
overlap) / vj
stress[i] += stress_i
stress[j] += stress_j
# Faster to loop over all particles
for i in range(self._Particles.natoms):
# Compute principal stress
stress_i = stress[i]
stress_p = 0.5 * (stress_i[0, 0] + stress_i[1, 1]) + numpy.sqrt( (0.5 * (stress_i[0, 0] - \
stress_i[1, 1]))**2.0 + stress_i[0, 1] )
if stress_i[0, 0] - stress_i[
1, 1]: # otherwise this is prolly a boundary particle
# Compute angle
stress_prin[i,2] = 0.5 * numpy.arctan( 2.0 * stress_i[0,1] / (stress_i[0,0] \
- stress_i[1,1]) )
# compute principal stress
stress_prin[i, 0] = stress_p * numpy.cos(stress_prin[i, 2])
stress_prin[i, 1] = stress_p * numpy.sin(stress_prin[i, 2])
stress_norm = norm(stress_prin[:, :-1], axis=1)
if not peters: # plot all particle stresses
indices = numpy.where(stress_norm > 0)[0]
Particles = self._Particles[indices]
coords = numpy.array([Particles.x, Particles.y, Particles.z])
x, y = coords[axis[0]], coords[axis[1]]
stress_prin = stress_prin[indices, :]
stress_norm = stress_norm[indices]
stress_norm /= stress_norm.max() * 0.3
plt.axes()
for i in range(coords.shape[1]):
theta = stress_prin[i, -1]
xi = [
x[i] - Particles.radius[i] * numpy.cos(theta),
x[i] + Particles.radius[i] * numpy.cos(theta)
]
yi = [
y[i] - Particles.radius[i] * numpy.sin(theta),
y[i] + Particles.radius[i] * numpy.sin(theta)
]
if plot_stress:
plt.plot(xi, yi, linewidth=stress_norm[i], color='black')
if plot_parts:
circle = plt.Circle((x[i], y[i]),
radius=Particles.radius[i],
fill=False,
color='blue',
linewidth=0.5,
linestyle='dotted')
plt.gca().add_patch(circle)
circle = plt.Circle((x[i], y[i]),
radius=Particles.radius[i],
fill=False,
color='blue',
linewidth=0.5,
linestyle='dotted')
plt.gca().add_patch(circle)
plt.axis('scaled')
plt.show()
return stress_prin
else: # use Peters' algorithm for computing force chain propagation
# Section V. THE ALGORITHM (page 4)
# Step 1: filter out particles with less than the mean principal stress
indices = numpy.where(
stress_norm >= threshold * stress_norm.mean(axis=0))[0]
stress_norm = stress_norm[indices]
# Step 2: filter out particles which are in contact with 1 or less 'highly stressed' particles
# Construct an nns list
coords = self._coords[indices, :][:, axis]
stress_prin = stress_prin[indices, :]
radii = self._Particles.radius[indices]
tree = spatial.cKDTree(coords)
nns = tree.query_ball_point(
coords, self._Particles[indices].radius.max() * 2.0)
self._nns = [[] for i in range(len(nns))]
# Update the nns indices so that only overlapping neighbors remain
count = 0
for ns in nns:
for index in ns:
if index != count:
dist = norm(coords[index] - coords[count])
if dist <= (radii[index] + radii[count]):
self._nns[count].append(index)
self._nns[count].insert(0, count)
count += 1
cosAlpha = numpy.cos(alpha)
chain = []
# Step 3: Remove overlapping particles with 2 or less neighbors
remInd = []
for nns in self._nns:
if len(
nns
) <= 2: # select only particles surrounded by 2 or more highly stressed particles
remInd.append(nns)
for ind in remInd:
self._nns.remove(ind)
# Step 4: compute the force chain per particle and make plots if requested by the user
plt.axes()
for nns in self._nns:
index = nns[0]
# Begin loop over each neighboring particle
for ni in nns[1:]:
# check for angle compliance
angle_i = stress_prin[index, -1]
angle_j = stress_prin[ni, -1]
dist = coords[ni] - coords[index]
term1 = numpy.fabs(numpy.dot(dist,
stress_prin[index, :-1]))
term2 = norm(dist) * stress_norm[index]
term3 = numpy.fabs(numpy.dot(-dist, stress_prin[ni, :-1]))
term4 = norm(-dist) * stress_norm[ni]
# Search in the forward direction
if (term1 <= term2) and (cosAlpha * term2) < term1:
if (term3 <= term4) and (cosAlpha * term4) < term3:
chain.append((index, ni))
x = [coords[index, 0], coords[ni, 0]]
y = [coords[index, 1], coords[ni, 1]]
if plot_stress:
plt.plot(x,
y,
linewidth=max(
1.2 * stress_norm[i] /
stress_norm.max(), 0.01),
color='black')
if plot_parts:
circle = plt.Circle(
(coords[index, 0], coords[index, 1]),
radius=radii[index],
fill=False,
color='blue',
linewidth=0.5,
linestyle='dotted')
plt.gca().add_patch(circle)
circle = plt.Circle(
(coords[ni, 0], coords[ni, 1]),
radius=radii[ni],
fill=False,
color='blue',
linewidth=0.5,
linestyle='dotted')
plt.gca().add_patch(circle)
# Search in the reverse direction
# I dont understand what Im doing here
#if (term1 <= term2) and (-cosAlpha * term2) > term1: # TODO: double check the math on this one
#if (term3 <= term4) and (-cosAlpha * term4) > term3: # TODO: double check the math on this one
#chain.append((index,ni))
#print (index,ni)
print('Natoms highly stressed = {} out of {} particles'.format(
len(chain), self._Particles.natoms))
plt.axis('scaled')
plt.show()
return chain, stress_prin
print "integral"
print f(2, 2, 2)
na = np.ogrid[0:1:24j]
nb = np.ogrid[0:1:12j]
nc = np.ogrid[0:1:6j]
# 24 12 6
na3 = na.reshape((24, 1, 1))
nb3 = nb.reshape((1, 12, 1))
nc3 = nc.reshape((1, 1, 6))
print f(na3, nb3, nc3).mean() # 0.1931 ...
print str(na3.ravel().data)
'''
from matplotlib import pyplot as plt
data = np.loadtxt('/Users/ahnyoungho/GitHub/scipy-lecture-notes/data/populations.txt')
print data.T
year, hares, lynxes, carrots = data.T
plt.axes([0.2, 0.1, 0.5, 0.8])
plt.plot(year, hares, year, lynxes, year, carrots)
plt.legend(('Hare', 'Lynx', 'Carrot'), loc=(1.05, 0.5))
#plt.show()
print data
sub_pop = data[:,1:] # without year
print sub_pop.mean(axis=0)
print np.argmax(sub_pop, axis=1)
print np.argmin(sub_pop, axis=1)
# -*- coding: utf-8 -*- """ Created on Sat Feb 9 14:44:27 2019 @author: adrie """ import matplotlib.pylab as plt from matplotlib.animation import FuncAnimation fig = plt.figure(facecolor = 'k') ax = plt.axes(facecolor = 'k') def DistanceEuclidienne(A,B): xa,ya = A xb,yb = B return (((xa - xb)**2) + ((ya - yb)**2))**0.5 def FindC(A,B): xa,ya = A xb,yb = B xc = xa + (xb - xa)/2 - (yb - ya)/2 yc = ya + (xb - xa)/2 + (yb - ya)/2 return xc,yc def Plotable(l): lx,ly = [],[]
yData = delete(yData, Indx, 0)
thisline.set_data(xData, yData)
pylab.draw()
if thisline == MaximaGraph:
MaxMask = delete(MaxMask, Indx, 0)
if thisline == MinimaGraph:
MinMask = delete(MinMask, Indx, 0)
cid = Fig.canvas.mpl_connect('pick_event', on_pick)
axcolor = 'lightgoldenrodyellow'
resetax = pylab.axes([0.85, 0.10, 0.1, 0.04])
button = Button(resetax, 'Reset', color=axcolor, hovercolor='0.975')
def reset(event):
global MaxMask
global MinMask
MaxMask = arange(len(MaximaData))
MinMask = arange(len(MinimaData))
MaximaGraph.set_data(MaximaIndx, MaximaData)
MinimaGraph.set_data(MinimaIndx, MinimaData)
button.on_clicked(reset)
dmin = 0.5 * 10**(-1)
dmax = 2 * 10**4
# Customisation
plt.rc('path', simplify=True)
plt.rc('savefig', dpi=300, format='png')
plt.rc('axes', linewidth=lw, labelpad=lblpad)
plt.rc('xtick', labelsize=tick, direction='inout')
plt.rc('xtick.major', size=tickh, width=lw, pad=pad)
plt.rc('ytick', labelsize=tick, direction='inout')
plt.rc('ytick.major', size=tickh, width=lw, pad=pad)
# Set up the plot
plt.figure(figsize=(24, 12))
ax = plt.axes(xlim=(tmin, tmax)) #,ylim=(dmin,dmax))
ax.plot(t, deltap, ls='solid', lw=1, color='b')
ax.plot(t, deltan, ls='solid', lw=1, color='r')
ax.hlines(0., tmin, tmax, linestyles='dashed', lw=1.2)
#ax.set_xscale('log')
ax.set_yscale('log')
# Set axes labels
plt.xlabel('t/tdyn', size=txt)
plt.ylabel(r'$\delta$', size=1.3 * txt)
# Set plot titles
ax.set_title('Growth Rate - ' + File, size=1.5 * txt)
def stacking(self,
star_list,
mean_list,
mean,
psf_type,
restrict_psf=None,
symmetry=1,
inverse_shift=True,
vmax=None,
vmin=None,
verbose=True):
"""
:param star_list:
:return:
"""
num_stars = len(star_list)
if restrict_psf is None:
restrict_psf = [True] * num_stars
shifteds = []
mean_list_select = []
for i in range(num_stars):
if restrict_psf[i] is True:
data = star_list[i] - mean
if psf_type == 'gaussian' or psf_type == 'pixel':
amp, sigma, center_x, center_y = mean_list[i]
elif psf_type == 'moffat':
amp, alpha, beta, center_x, center_y = mean_list[i]
else:
raise ValueError('psf type %s not valid' % psf_type)
data[data < 0] = 0
if inverse_shift is True:
shifted = util.de_shift_kernel(data,
shift_x=-center_x - 0.5,
shift_y=-center_y - 0.,
iterations=10)
else:
shifted = interp.shift(data,
[-center_y - 0.5, -center_x - 0.5],
order=1)
sym_shifted = util.symmetry_average(shifted, symmetry)
shifteds.append(sym_shifted)
mean_list_select.append(mean_list[i])
if verbose is True:
print('=== object ===', i, center_x, center_y)
import matplotlib.pylab as plt
fig, ax1 = plt.subplots()
im = ax1.matshow(np.log10(sym_shifted),
origin='lower',
vmax=vmax,
vmin=vmin)
#v_max = np.max(np.nan_to_num(np.log10(sym_shifted)))
#v_min = np.min(np.nan_to_num(np.log10(sym_shifted)))
#v_min = max(v_max-5, v_min)
#im = ax1.matshow(np.log10(sym_shifted), origin='lower',vmin=v_min, vmax=v_max)
plt.axes(ax1)
fig.colorbar(im)
plt.show()
combined = sum(shifteds)
mean_list_select = np.mean(mean_list_select[:])
"""
new = np.empty_like(combined)
max_pix = np.max(combined)
p = combined[combined >= max_pix/10**6] #in the SIS regime
new[combined < max_pix/10**6] = 0
new[combined >= max_pix/10**6] = p
"""
kernel = util.kernel_norm(combined)
return kernel, mean_list_select, restrict_psf, shifteds
import numpy as np
import matplotlib.pylab as plt
from mpl_toolkits import mplot3d
data = np.genfromtxt("difusionfijas.dat")
x = data[:, 0]
y = data[:, 1]
X, Y = np.meshgrid(x, y)
foto1 = data[:, 2:103]
foto2 = data[:, 103:204]
foto3 = data[:, 204:305]
fig = plt.figure()
ax = plt.axes(projection='3d')
ax.plot_surface(Y,
X,
foto1,
rstride=1,
cstride=1,
cmap='viridis',
edgecolor='none')
ax.set_xlabel('x(m)')
ax.set_ylabel('y(m)')
ax.set_zlabel('T(Celcius)')
ax.set_title('frontera fija t=0')
plt.savefig("difusionFijas0.png")
fig = plt.figure()
ax = plt.axes(projection='3d')
ax.plot_surface(Y,
X,
# 只要程序处于活动状态，就不断的模拟随机漫步
while True:
# 创建一个RandomWalk实例，并将其包含的点都绘制出来
rw = RandomWalk(5000)
rw.fill_walk()
# 设置绘制窗口尺寸
plt.figure(dpi=128, figsize=(10, 6))
plt.plot(rw.x_values, rw.y_values, linewidth=1)
# 突出起点和终点
plt.scatter(0, 0, c='green', edgecolors='none', s=100)
plt.scatter(rw.x_values[-1],
rw.y_values[-1],
c='red',
edgecolors='none',
s=100)
# 隐藏坐标轴
plt.axes().get_xaxis().set_visible(False)
plt.axes().get_yaxis().set_visible(False)
plt.show()
# 保存图片
# plt.savefig('water_visual2.png', bbox_inches='tight')
keep_running = input("Make anther walk? (y/n):")
if keep_running == 'n':
break
def drawFig(self, img_grid):
# figure properties
fig = pb.figure(figsize=(10, 6))
row_length = len(out_row_vals)
col_length = len(out_col_vals)
gs = matplotlib.gridspec.GridSpec(
row_length, col_length, wspace=.05,
hspace=.05) # +1 for the colormap area
"""figure processing"""
img_grid_list = img_grid.tolist()
# get min and max to set up colormap scale, and loop all again to plot images
MIN = pb.array(img_grid).min()
MAX = pb.array(img_grid).max()
for out_row_index in range(len(out_row_vals)):
for out_col_index in range(len(out_col_vals)):
ax = fig.add_subplot(gs[row_length - 1 - out_row_index,
out_col_index])
ax.hold(True)
img_grid_list[out_row_index][out_col_index] = ax.contourf(
img_grid[out_row_index][out_col_index],
levels=pb.linspace(MIN, MAX, 50),
extent=[
in_col_vals.min(),
in_col_vals.max(),
in_row_vals.min(),
in_row_vals.max()
],
vmin=MIN,
vmax=MAX)
# set ticks and labels of axis (no number in legend for graphs not on borders):
# for the x axis:
xticks = in_col_vals
ax.set_xticks(xticks)
if (out_row_index > 0): #< row_length - 1):
ax.set_xticklabels([])
else:
ax.set_xlabel(in_col_label + "\n\n" + out_col_label + "=" +
str(out_col_vals[out_col_index])
) # , fontsize='xx-large')
ax.set_xticklabels(map(
str, xticks)) # , fontsize='xx-large') #in_col_val
# for the y axis:
yticks = in_row_vals # from in_row_val
ax.set_yticks(yticks)
if (out_col_index > 0):
ax.set_yticklabels([])
else:
ax.set_ylabel(
"|" + out_row_label + "|=" +
str(out_row_vals[out_row_index]) + ' ' +
in_row_label,
rotation='horizontal') # , fontsize='xx-large')
ax.set_yticklabels(map(
str, yticks)) # , fontsize='xx-large') #in_row_val
# setup colorbar
ax = pb.axes([0.92, 0.1, 0.01,
0.8]) # guess [left, bottom, width, heigth]. in percents
cbar = pb.colorbar(img_grid_list[0][0], ax) # , ticks=ticksValues)
pb.ion()
return fig
def energies_on_path(path, TB, n_pts, n_orb=1):
E = zeros((n_orb, n_pts * (len(path) - 1)))
for i in range(len(path) - 1, 0, -1):
energies = energies_on_bz_path(TB, path[i - 1], path[i], n_pts)
for orb in range(n_orb):
E[orb, (i - 1) * n_pts:(i) * n_pts] = energies[orb, :]
print "index of point #" + str(i - 1) + " = " + str((i - 1) * n_pts)
return E
E_1 = energies_on_path(path_1, TB_1, n_pts, 1)
E_2 = energies_on_path(path_2, TB_2, n_pts, 2)
E_4 = energies_on_path(path_4, TB_4, n_pts, 4)
from matplotlib import pylab as plt
plt.plot(E_1[0], '--k', linewidth=4, label="1 at/unit cell")
plt.plot(E_2[0], '-.g', linewidth=4, label="2 ats/unit cell")
plt.plot(E_2[1], '-.g', linewidth=4)
plt.plot(E_4[0], '-r', label="4 ats/unit cell")
plt.plot(E_4[1], '-r')
plt.plot(E_4[2], '-r')
plt.plot(E_4[3], '-r')
plt.grid()
plt.legend()
plt.axes().set_xticks([0, 50, 100, 150])
plt.axes().set_xticklabels([r'$\Gamma_1$', r'$M_1$', r'$X_1$', r'$\Gamma_1$'])
plt.ylabel(r"$\epsilon$")
def plot_end_pos(end_poses):
for end_pos in end_poses:
plt.figure()
ax = plt.axes(projection='3d')
ax.plot(end_pos[0], end_pos[1], end_pos[2], '-b')
plt.show()
def slice_rasterize(mesh):
#print("Current model: {0} \n".format(mesh))
print("Current model centroid {0} \n".format(mesh.centroid))
'''
# facets are groups of coplanar adjacent faces
# set each facet to a random color
# colors are 8 bit RGBA by default (n, 4) np.uint8
for facet in mesh.facets:
mesh.visual.face_colors[facet] = trimesh.visual.random_color()
# preview mesh in an opengl window if you installed pyglet with pip
mesh.show()
'''
# Take a bunch of parallel slices,
# slice the mesh into evenly spaced chunks along z
# this takes the (2,3) bounding box and slices it into [minz, maxz]
heights = heights_generator(mesh, 0.125, 2)
print(heights)
print(mesh.bounds)
print("Scanning model along Z depth axis with {0} parallel planes...\n".format(len(heights)))
#print(mesh.bounds[0][2])
#print(mesh.bounds[0])
# construct a set of scanning plane origins
#plane_origin_array = np.array([mesh.bounds[0],]*len(heights))
plane_origin_array = np.array([mesh.centroid,]*len(heights))
#plane_origin_array = repeat(mesh.centroid[newaxis,:], 3, 0)
plane_origin_array[:,2] = heights
#print(plane_origin_array[0])
fig = plt.figure()
#plt.axes().set_aspect('equal', 'datalim')
plt.axes().set_aspect('equal')
offset_x = abs(mesh.bounds[0][0] - mesh.bounds[1][0]) * 0.15
offset_y = abs(mesh.bounds[0][1] - mesh.bounds[1][1]) * 0.15
for idx, value in enumerate(plane_origin_array):
#print("plane {0} is {1} \n".format(idx))
# get a single cross section of the mesh
slice_3d = mesh.section(plane_origin = plane_origin_array[idx], plane_normal = [0,0,1])
print("plane {0} is {1} \n".format(idx, slice_3d))
# the section will be in the original mesh frame
#slice.show()
if not (slice_3d is None):
# we can move the 3D curve to a Path2D object easily
slice_2D, to_3D = slice_3d.to_planar()
#slice_2D.show()
#(slice_2D + slice_2D.medial_axis()).show()
#Save 2d slice as image file
filename = save_path + 'slice_' + str(idx).zfill(4) + '.png'
#for p in slice_2D.polygons_full:
for p in slice_2D.polygons_closed:
if not (p is None):
plt.plot(*(p.exterior.xy),'k')
for r in p.interiors:
plt.plot(*zip(*r.coords), 'b')
#plt.axes().set_aspect('equal')
plt.xlim([mesh.bounds[0][0] - offset_x, mesh.bounds[1][0] + offset_x])
plt.ylim([mesh.bounds[0][1] - offset_y, mesh.bounds[1][1] + offset_y])
plt.axis('off')
plt.savefig(filename)
plt.cla()
plt.close()
'''
other_envs_bs < clone_fit) / len(other_envs_bs)
bs_stat = bs_stat / len(evol_env_bs)
competition_stat_bs.append(bs_stat)
col_stat.append(stat)
#col_stat.append(numpy.percentile(competition_stat_bs,50))
col_stat_err.append([
stat - numpy.percentile(competition_stat_bs, 5),
numpy.percentile(competition_stat_bs, 95) - stat
])
###Construct axes to plot
fig = pt.figure(figsize=(6, 5.8))
ax = pt.axes([.16, .16, .74, .74])
cb_ax = pt.axes([.94, .16, .04, .74])
ax_v = pt.axes([0, .16, .14, .74])
ax_h = pt.axes([.16, 0., .74, .14])
row_stat_err = numpy.array(row_stat_err).T
col_stat_err = numpy.array(col_stat_err).T
ax_v.barh(numpy.arange(8),
numpy.array(row_stat)[::-1],
.7,
xerr=row_stat_err[::-1],
color='grey')
ax_h.bar(numpy.arange(8), col_stat, .7, yerr=col_stat_err, color='grey')
ax_v.set_ylim(-.5, 7.5)
plt.fill_between(px3,py3,py4,color='c')
plt.fill_between(px5,py5,py6,color='c')
plt.plot(px1,py1, 'k-', linewidth=1.0,label=r"$pp$")
plt.plot(px2,py2, 'k--', linewidth=1.0,label=r"$\bar{p}p$")
plt.xlabel(r"$\sqrt{s}$ [GeV]", fontdict=font)
plt.ylabel(r"$\sigma_{tot}(s)$ [mb]", fontdict=font)
leg = plt.legend(loc=4, ncol=1, shadow=False, fancybox=False, frameon=False, numpoints=1)
leg.get_frame().set_alpha(0.5)
###########################################
sub_axes = plt.axes([.2, .55, .35, .35])
plt.grid(False)
plt.semilogx()
plt.xlim(5000,15000)
plt.ylim(90,120)
plt.errorbar(x1,y1,yerr=erry1,fmt='wo',ecolor='k', capthick=0.5)
plt.errorbar(x2,y2,yerr=erry2,fmt='ko',ecolor='k', capthick=0.5)
plt.errorbar(x3,y3,yerr=erry3,fmt='bs',ecolor='b', markeredgecolor='blue', capthick=0.5)
plt.errorbar(x4,y4,yerr=erry4,fmt='r^',ecolor='r', markeredgecolor='red', capthick=0.5)
plt.fill_between(px3,py3,py4,color='c')
plt.fill_between(px5,py5,py6,color='c')
plt.plot(px1,py1, 'k-', linewidth=1.0)
plt.plot(px2,py2, 'k--', linewidth=1.0)
def plot_3d(
self,
x_axis: Union[int, str, Embedding] = 0,
y_axis: Union[int, str, Embedding] = 1,
z_axis: Union[int, str, Embedding] = 2,
x_label: Optional[str] = None,
y_label: Optional[str] = None,
z_label: Optional[str] = None,
title: Optional[str] = None,
color: str = None,
axis_metric: Optional[Union[str, Callable, Sequence]] = None,
annot: bool = True,
):
"""
Creates a 3d visualisation of the embedding.
Arguments:
x_axis: the x-axis to be used, must be given when dim > 3; if an integer, the corresponding
dimension of embedding is used.
y_axis: the y-axis to be used, must be given when dim > 3; if an integer, the corresponding
dimension of embedding is used.
z_axis: the z-axis to be used, must be given when dim > 3; if an integer, the corresponding
dimension of embedding is used.
x_label: an optional label used for x-axis; if not given, it is set based on value of `x_axis`.
y_label: an optional label used for y-axis; if not given, it is set based on value of `y_axis`.
z_label: an optional label used for z-axis; if not given, it is set based on value of `z_axis`.
title: an optional title for the plot.
color: the property to user for the color
axis_metric: the metric used to project each embedding on the axes; only used when the corresponding
axis is a string or an `Embedding` instance. It could be a string (`'cosine_similarity'`,
`'cosine_distance'` or `'euclidean'`), or a callable that takes two vectors as input and
returns a scalar value as output. To set different metrics of the three different axes,
you can pass a list/tuple of size three that describes the metrics you're interested in.
By default (`None`), normalized scalar projection (i.e. `>` operator) is used.
annot: drawn points should be annotated
**Usage**
```python
from whatlies.language import SpacyLanguage
from whatlies.transformers import Pca
words = ["prince", "princess", "nurse", "doctor", "banker", "man", "woman",
"cousin", "neice", "king", "queen", "dude", "guy", "gal", "fire",
"dog", "cat", "mouse", "red", "bluee", "green", "yellow", "water",
"person", "family", "brother", "sister"]
lang = SpacyLanguage("en_core_web_sm")
emb = lang[words]
emb.transform(Pca(3)).plot_3d(annot=True)
emb.transform(Pca(3)).plot_3d("king", "dog", "red")
emb.transform(Pca(3)).plot_3d("king", "dog", "red", axis_metric="cosine_distance")
```
"""
if isinstance(x_axis, str):
x_axis = self[x_axis]
if isinstance(y_axis, str):
y_axis = self[y_axis]
if isinstance(z_axis, str):
z_axis = self[z_axis]
if isinstance(axis_metric, (list, tuple)):
x_axis_metric = axis_metric[0]
y_axis_metric = axis_metric[1]
z_axis_metric = axis_metric[2]
else:
x_axis_metric = axis_metric
y_axis_metric = axis_metric
z_axis_metric = axis_metric
# Determine axes values and labels
if isinstance(x_axis, int):
x_val = self.to_X()[:, x_axis]
x_lab = "Dimension " + str(x_axis)
else:
x_axis_metric = Embedding._get_plot_axis_metric_callable(
x_axis_metric)
x_val = self.compare_against(x_axis, mapping=x_axis_metric)
x_lab = x_axis.name
x_lab = x_label if x_label is not None else x_lab
if isinstance(y_axis, int):
y_val = self.to_X()[:, y_axis]
y_lab = "Dimension " + str(y_axis)
else:
y_axis_metric = Embedding._get_plot_axis_metric_callable(
y_axis_metric)
y_val = self.compare_against(y_axis, mapping=y_axis_metric)
y_lab = y_axis.name
y_lab = y_label if y_label is not None else y_lab
if isinstance(z_axis, int):
z_val = self.to_X()[:, z_axis]
z_lab = "Dimension " + str(z_axis)
else:
z_axis_metric = Embedding._get_plot_axis_metric_callable(
z_axis_metric)
z_val = self.compare_against(z_axis, mapping=z_axis_metric)
z_lab = z_axis.name
z_lab = z_label if z_label is not None else z_lab
# Save relevant information in a dataframe for plotting later.
plot_df = pd.DataFrame({
"x_axis":
x_val,
"y_axis":
y_val,
"z_axis":
z_val,
"name": [v.name for v in self.embeddings.values()],
"original": [v.orig for v in self.embeddings.values()],
})
# Deal with the colors of the dots.
if color:
plot_df["color"] = [
getattr(v, color) if hasattr(v, color) else ""
for v in self.embeddings.values()
]
color_map = {k: v for v, k in enumerate(set(plot_df["color"]))}
color_val = [
color_map[k] if not isinstance(k, float) else k
for k in plot_df["color"]
]
else:
color_val = None
ax = plt.axes(projection="3d")
ax.scatter3D(plot_df["x_axis"],
plot_df["y_axis"],
plot_df["z_axis"],
c=color_val,
s=25)
# Set the labels, titles, text annotations.
ax.set_xlabel(x_lab)
ax.set_ylabel(y_lab)
ax.set_zlabel(z_lab)
if annot:
for i, row in plot_df.iterrows():
ax.text(row["x_axis"], row["y_axis"], row["z_axis"] + 0.05,
row["original"])
if title:
ax.set_title(label=title)
return ax
fig = plt.figure(figsize=(7, 7))
ax = fig.add_subplot(111)
M, target = 200, 100
ax.plot(mean[:M], 'b', lw=2)
ax.plot(mean[:M] + std[:M], 'r', ls='--', lw=1.3)
ax.plot(mean[:M] - std[:M], 'r', ls='--', lw=1.3)
# ax.plot(median[:M], 'k', lw=2)
# ax.plot(mmad[:M], 'm', lw=2)
ax.set_xlabel('Epochs')
ax.set_ylabel('Mean (SD)')
plt.xticks([0, 50, 100, 150, 200],
('0', '2500', '5000', '7500', '10000'))
plt.title('Evolution of' + r'$\mathbb{E}\{w_f\}$')
bx = plt.axes([.19, .70, .15, .15], axisbg='y')
W = np.load(base + 'weights000000.npy')[target].reshape(n, n)
bx.imshow(W, interpolation='bicubic', cmap=plt.cm.Purples)
plt.title(r'epoch=0')
plt.setp(bx, xticks=[], yticks=[])
cx = plt.axes([.27, .45, .15, .15], axisbg='y')
W = np.load(base + 'weights002500.npy')[target].reshape(n, n)
cx.imshow(W, interpolation='bicubic', cmap=plt.cm.Purples)
plt.title(r'epoch=2500')
plt.setp(cx, xticks=[], yticks=[])
dx = plt.axes([.63, .3, .15, .15], axisbg='y')
W = np.load(base + 'weights007500.npy')[target].reshape(n, n)
dx.imshow(W, interpolation='bicubic', cmap=plt.cm.Purples)
plt.title(r'epoch=7500')
def _plot_seasonality(self, alpha: float, plot_kwargs: bool):
# two_tailed_alpha = int(alpha / 2 * 100)
periods = list(set([float(i.split("_")[1]) for i in self.seasonality]))
additive_ts, multiplicative_ts = self._fit_seasonality()
all_seasonalities = [("additive", additive_ts)]
if len(self.multiplicative_data):
all_seasonalities.append(("multiplicative", multiplicative_ts))
for sn, ts in all_seasonalities:
if (sn == "multiplicative"
and np.sum(ts) == 1) or (sn == "additive"
and np.sum(ts) == 0):
continue
ddf = pd.DataFrame(
np.vstack([
np.percentile(ts[:, :, self.skip_first:], 50, axis=-1),
np.percentile(ts[:, :, self.skip_first:],
alpha / 2 * 100,
axis=-1),
np.percentile(ts[:, :, self.skip_first:],
(1 - alpha / 2) * 100,
axis=-1),
]).T,
columns=[
"%s_%s" % (p, l) for l in ["mid", "low", "high"]
for p in periods[::-1]
],
)
ddf.loc[:, "ds"] = self.data["ds"]
for period in periods:
if int(period) == 0:
step = int(self.data["ds"].diff().mean().total_seconds() //
float(period))
else:
step = int(period)
graph = ddf.head(step)
if period == 7:
ddf.loc[:, "dow"] = [i for i in ddf["ds"].dt.weekday]
graph = (ddf[[
"dow",
"%s_low" % period,
"%s_mid" % period,
"%s_high" % period,
]].groupby("dow").mean().sort_values("dow"))
graph.loc[:, "ds"] = [[
"Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat", "Sun"
][i] for i in graph.index]
graph = graph.sort_index()
plt.figure(**plot_kwargs)
graph.plot(y="%s_mid" % period,
x="ds",
color="C0",
legend=False,
ax=plt.gca())
plt.grid()
if period == 7:
plt.xticks(range(7), graph["ds"].values)
plt.fill_between(
np.arange(0, 7),
graph["%s_low" % period].values.astype(float),
graph["%s_high" % period].values.astype(float),
alpha=0.3,
)
else:
plt.fill_between(
graph["ds"].values,
graph["%s_low" % period].values.astype(float),
graph["%s_high" % period].values.astype(float),
alpha=0.3,
)
plt.title("Model Seasonality (%s) for period: %s days" %
(sn, period))
plt.axes().xaxis.label.set_visible(False)
plt.show()
#------
rho = [0.1, 1]
r2, z2 = eqm.rho2rz(rho, t_in=3, coord_in='rho_pol')
n_theta = len(r2[0][0])
theta = np.linspace(0, 2 * np.pi, 1000)
r1, z1 = eqm.rhoTheta2rz(rho,
theta,
t_in=3,
coord_in='rho_pol',
n_line=1000)
plt.figure(5, figsize=(10, 12))
plt.axes().set_aspect('equal')
plt.plot(r2[0][0], z2[0][0], 'go')
plt.plot(r1[0, :, 0], z1[0, :, 0], 'r+')
R, Z = np.meshgrid(eqm.Rmesh, eqm.Zmesh)
plt.plot(R, Z, ",k")
#plt.figure(6, figsize=(10, 12))
plt.axes().set_aspect('equal')
plt.plot(r2[0][1], z2[0][1], 'go')
plt.plot(r1[0, :, 1], z1[0, :, 1], 'r+')
rgrid, zgrid, theta_star = eqm.mag_theta_star(3)
plt.figure()
plt.pcolor(rgrid, zgrid, theta_star)
def plot_results(
self,
datasource,
from_date,
to_date,
num_cpus=1,
num_gpus=0,
x_dim=-1,
y_dim=-1,
output=None,
):
"""
# Arguments:
models (tuple): encoder and decoder models
data (tuple): test data and label
model_name (string): which model is using this function
"""
global g_mc_batch_size
# Agg = Anti-grain geometry engine
# running inside a Docker image. No Xwindow
import matplotlib
matplotlib.use('Agg')
import matplotlib.pyplot as plt
period = self.build_date_range(from_date, to_date)
logging.info("plot_results(%s) range=%s", self.name, period)
self.load(num_cpus, num_gpus)
_, latent_dim = self._encoder_model.outputs[0].get_shape()
# Build history time range
# Extra data are required to predict first buckets
_window = self._window - 1
hist = DateRange(
period.from_ts - _window * self.bucket_interval,
period.to_ts,
)
# Prepare dataset
nb_buckets = int((hist.to_ts - hist.from_ts) / self.bucket_interval)
dataset = np.full((nb_buckets, ), np.nan, dtype=float)
# Fill dataset
logging.info("extracting data for range=%s", hist)
data = datasource.get_times_data(self, hist.from_ts, hist.to_ts)
# Only a subset of history will be used for computing the prediction
X_until = None # right bound for prediction
i = None
for i, (_, val, timeval) in enumerate(data):
dataset[i] = val
dt = make_datetime(timeval)
ts = dt.timestamp()
if ts < period.to_ts:
X_until = i + 1
if i is None:
raise errors.NoData("no data found for time range {}".format(hist))
self.apply_defaults(dataset)
nb_buckets_found = i + 1
if nb_buckets_found < nb_buckets:
dataset = np.resize(dataset, (nb_buckets_found, ))
logging.info("found %d time periods", nb_buckets_found)
norm_dataset = self.scale_dataset(dataset)
X_miss_val, X_test = self._format_dataset(norm_dataset[:X_until])
if len(X_test) == 0:
raise errors.LoudMLException("not enough data for prediction")
# display a 2D plot of the digit classes in the latent space
z_mean, _, _ = self._encoder_model.predict([X_test, X_miss_val],
batch_size=g_mc_batch_size)
if x_dim < 0 or y_dim < 0:
mses = []
for (x, y) in itertools.combinations(range(0, latent_dim), 2):
_mean = np.mean(z_mean, axis=0)[[x, y]]
mse = ((z_mean[:, [x, y]] - _mean)**2).mean(axis=0)
mses.append([x, y, mse[0] + mse[1]])
mses = sorted(mses, key=lambda x: x[2])
x_dim = mses[0][0]
y_dim = mses[0][1]
excl = [x for x in range(latent_dim) if x != x_dim and x != y_dim]
plt.figure(figsize=(12, 10))
if latent_dim > 3:
ax = plt.axes(projection='3d')
ax.set_zticks([])
else:
ax = plt.axes()
# Hide grid lines
ax.grid(False)
# Hide axes ticks
ax.set_xticks([])
ax.set_yticks([])
if latent_dim > 3:
zc = np.array(
[[z_mean[i, excl[0]], z_mean[i, excl[1]], z_mean[i, excl[2]]]
for i, _ in enumerate(z_mean)])
# (x-min(x))/(max(x)-min(x)). RGBA values should be within 0-1 range
zc = (zc - np.min(zc, axis=0)) / \
(np.max(zc, axis=0) - np.min(zc, axis=0))
if latent_dim > 5:
ax.set_zlabel("z[{}]".format(excl[3]))
ax.scatter(z_mean[:, x_dim],
z_mean[:, y_dim],
z_mean[:, excl[3]],
c=zc)
else:
zc[:, 0] = 0
ax.set_zlabel("z[{}]".format(excl[0]))
ax.scatter(z_mean[:, x_dim],
z_mean[:, y_dim],
z_mean[:, excl[0]],
c=zc)
else:
plt.scatter(z_mean[:, x_dim],
z_mean[:, y_dim],
c=z_mean[:, excl[0]])
plt.colorbar()
plt.xlabel("z[{}]".format(x_dim))
plt.ylabel("z[{}]".format(y_dim))
if output is None:
plt.show()
else:
plt.savefig(output)
def main():
'''
command line arguments: how many inner streamlines to ignore and how many to count in
'''
#command line args
if len(sys.argv) != 2:
ignore, count = 3, 3
else:
ignore = int(sys.argv[1])
count = int(sys.argv[2])
#What to plot:
#[streamlines, magnetopause, poynting vectors, surface]
plotting = [False, False, False, True]
streams = make_streamlines()
pause_by_slice, pause_by_x = get_magnetopause(streams, ignore, count)
ax = plt.axes(projection='3d',
xlabel='X (Re)',
ylabel='Y (Re)',
zlabel='Z (Re)')
if plotting[0]: #plot streamlines
for s in np.arange(0, len(streams.streamlines)):
stream_pos = streams.streamlines[s]
ax.scatter(stream_pos[:, 0], stream_pos[:, 1], stream_pos[:, 2])
if plotting[1]: #plot magnetopause by coordinates
coords = []
for sl in pause_by_slice:
if len(sl) == 0:
continue #if slice is empty(works on nested lists?)
sl = np.array(sl)
ax.plot3D(sl[:, 0], sl[:, 1], sl[:, 2])
coords.append([sl[:, 0], sl[:, 1], sl[:, 2]])
for plane in pause_by_x:
plane = np.array(plane)
ax.plot3D(plane[:, 0], plane[:, 1], plane[:, 2])
if plotting[2]: #plot Poynting vetors (not working!)
coords = np.array(coords)
poynting = np.array(poynting)
ax.quiver(coords[:, 0], coords[:, 1], coords[:, 2], P[:, 0], P[:, 1],
P[:, 2])
if plotting[3]: #plot surface
print('Making the surface...')
verts, faces = make_surface(pause_by_x)
verts = np.array(verts)
ax.plot_trisurf(verts[:, 0],
verts[:, 1],
faces,
verts[:, 2],
linewidth=0.2,
antialiased=True)
plt.savefig('magnetopause3d.png')
#save 2d projection
#ax.view_init(azim=45, elev=0)
#plt.savefig('magnetopause3dprojection.png')
print('Ready!')
tmin = min(t) - max(t) / 50.
tmax = max(t) + max(t) / 50.
# Customisation
plt.rc('path', simplify=True)
plt.rc('savefig', dpi=300, format='png')
plt.rc('axes', linewidth=lw, labelpad=lblpad)
plt.rc('xtick', labelsize=tick, direction='inout')
plt.rc('xtick.major', size=tickh, width=lw, pad=pad)
plt.rc('ytick', labelsize=tick, direction='inout')
plt.rc('ytick.major', size=tickh, width=lw, pad=pad)
# Set up the plot
plt.figure(figsize=(24, 12))
ax = plt.axes(xlim=(tmin, tmax), ylim=(dtmin, dtmax))
plot = ax.plot(t, dt, marker='.', linestyle='none', markersize=s)
ax.yaxis.set_major_formatter(mtick.FormatStrFormatter('%.2e'))
ax.axhline(y=min(dt), linestyle='dashed', color='k', lw=lw)
#ax.set_yscale('log')
#ax.set_xscale('log')
# Set axes labels
plt.xlabel('t/tdyn', size=txt)
plt.ylabel('dt [Gyr]', size=txt)
# Set plot titles
ax.set_title('Timestep', size=1.5 * txt)
print '====Plots Generated==='
# Save the figure