def plot_allan_variance(xs: np.ndarray, ys: np.ndarray) -> plt.axes: from mpl_toolkits.axes_grid.inset_locator import (inset_axes, InsetPosition, mark_inset) _, _ax = plt.subplots() _ax.plot(xs, ys, '.') _ax.set_ylabel(f'Variance' + r' $\langle [x(t + \delta t) - x(t)]^2 \rangle$ $[nm^2]$', fontsize=font_size) # _ax.set_ylabel(f'Distance' + r' $abs(x(t + \delta t) - x(t))$ $[nm]$', fontsize=font_size) _ax.set_xlabel(f'Time step' + r' $\delta t[s]$', fontsize=font_size) _ax.set_yscale('log') # _ax.set_xscale('log') _ax.grid(True) # Inset _ax2 = plt.axes([0, 0, 1, 1]) # Manually set the position and relative size of the inset axes within ax1 ip = InsetPosition(_ax, [0.6, 0.1, 0.3, 0.3]) _ax2.set_axes_locator(ip) # Mark the region corresponding to the inset axes on ax1 and draw lines # in grey linking the two axes. mark_inset(_ax, _ax2, loc1=2, loc2=4, fc="none", ec='0.5') xs2 = [] ys2 = [] for i, x in enumerate(xs): if x < 0.007: xs2.append(xs[i]) ys2.append(ys[i]) _ax2.plot(xs2, ys2, '.') _ax2.set_yscale('log') _ax2.set_xscale('log') _ax2.set_ylim(_ax.get_ylim()) _ax2.grid(True) return _ax
def zoommap(vals, title, label): fig = plt.figure(figsize=(12,8)) plt.subplots_adjust(left=0.05,right=0.95,top=0.90,bottom=0.05, wspace=0.15,hspace=0.05) ax = plt.subplot(211) m = Basemap(projection = 'mill', llcrnrlat = -45, llcrnrlon = -160, urcrnrlat= 82, urcrnrlon = 170, resolution = 'c') m.drawcoastlines(linewidth = 0.5) plt.subplots_adjust(left=0.05,right=0.95,top=0.90,bottom=0.05, wspace=0.15,hspace=0.05) for row in vals: x,y = m(vals.lon.values, vals.lat.values) m.scatter(x,y, s = 20, color = vals.color.values) ax.text(0.03,0.95, label, size = 12, horizontalalignment='center', verticalalignment='center', transform=ax.transAxes) plt.title(title, fontsize = 12) #Zoom Europe axins_1 = zoomed_inset_axes(ax, 2, loc=2, bbox_to_anchor=(0.42, 0.48), bbox_transform=ax.figure.transFigure) axins_1.scatter(x, y, s = 20, c = vals.color.values) m.drawcoastlines(linewidth = 0.5) x2,y2 = m(-12,35) x3,y3 = m(40,65) axins_1.set_xlim(x2,x3) axins_1.set_ylim(y2,y3) axes = mark_inset(ax, axins_1, loc1=1, loc2=2, linewidth=1) #Zoom Australia axins_2 = zoomed_inset_axes(ax, 2.2, loc=3, bbox_to_anchor=(0.61, 0.255), bbox_transform=ax.figure.transFigure) axins_2.scatter(x, y, s = 20, c = vals.color.values) m.drawcoastlines(linewidth = 0.5) x2,y2 = m(110,-43) x3,y3 = m(155,-10) axins_2.set_xlim(x2,x3) axins_2.set_ylim(y2,y3) axes = mark_inset(ax, axins_2, loc1=1, loc2=2,linewidth=1) #Zoom US axins_3 = zoomed_inset_axes(ax, 1.6, loc=3, bbox_to_anchor=(0.21, 0.25), bbox_transform=ax.figure.transFigure) axins_3.scatter(x, y, s = 20, c = vals.color.values) m.drawcoastlines(linewidth = 0.5) x2,y2 = m(-130,22) x3,y3 = m(-60,63) axins_3.set_xlim(x2,x3) axins_3.set_ylim(y2,y3) axes = mark_inset(ax, axins_3, loc1=1, loc2=2, linewidth=1) return(fig, axes)
#%% # Plot all the baselines sns.set_style("white") sns.set_context("paper", font_scale=3) fig, ax1 = plt.subplots(figsize=(15, 10)) pt_colors = ["r", "b", "g", "k", "m", "c"] ax2 = plt.axes([0, 0, 1, 1]) # Manually set the position and relative size of the inset axes within ax1 ip = InsetPosition(ax1, [0.1, 0.1, 0.7, 0.4]) ax2.set_axes_locator(ip) # Mark the region corresponding to the inset axes on ax1 and draw lines # in grey linking the two axes. mark_inset(ax1, ax2, loc1=2, loc2=4, fc="none", ec="0.5", linestyle="dotted") for pp, pt in enumerate(pt_list): do_condit = do_presence[pt][0] do_rec_side = do_presence[pt][1] stim_side = "Bilateral" print(f"{pt} with {condit}") t_vect = SGs[pt][condit][do_rec_side]["T"] f_vect = SGs[pt][condit][do_rec_side]["F"] sg_data = SGs[pt][do_condit][do_rec_side]["SG"] # find indices for times baseline_start_idx = ephys_meta[pt][do_condit]["Configurations"][stim_side][ "Baseline" ][0]
data /= 8. data = data ** .25 data[np.isnan(data)] = 0 extent = [0., 192., 0., 192.] im = grid[i].imshow(data, extent=extent, interpolation="nearest") grid[i].text(10, 170, letters[i], fontsize=20, color="white") data_zoom = data[135:155, 80:100,] axins = zoomed_inset_axes(grid[i], 2, loc=3) # zoom = 6 extent = [80., 100., 192. - 155., 192. - 135, ] im2 = axins.imshow(data_zoom, extent=extent, interpolation="nearest") im2.set_clim([data.min(), data.max()]) plt.xticks(visible=False) plt.yticks(visible=False) im.set_clim([0., .3]) im2.set_clim([0., .15]) mark_inset(grid[i], axins, loc1=2, loc2=4, fc="none", ec="0.5") fontsize=20 posx = 10 posy = 170 grid[-1].text(posx, posy, "(a): PL", fontsize=fontsize, color="black") posy -= 25 grid[-1].text(posx, posy, "(b): PLI", fontsize=fontsize, color="black") posy -= 25 grid[-1].text(posx, posy, "(c): ACI", fontsize=fontsize, color="black") posy -= 25 grid[-1].text(posx, posy, "(d): HCI", fontsize=fontsize, color="black") posy -= 25 grid[-1].text(posx, posy, "(e): NOC", fontsize=fontsize, color="black") grid[0].set_xticks(())
axis.text(i + subextent[0] + 0.5, j + subextent[2] + 0.5, c, weight='demibold', horizontalalignment='center', verticalalignment='center', color=_determine_ideal_value(c, ma=array.max())) if __name__ == '__main__': tux = skimage.io.imread('./tux_icon-33px.png') fig, ax = plt.subplots(figsize=(5, 5)) extent0 = [0, 33, 0, 36] ax.imshow(tux, extent=extent0, interpolation='nearest') axins = zoomed_inset_axes(ax, 3.4, loc=3) extent1 = [18, 23, 18, 23] overlay_numbers(axins, tux, extent0, extent1, interpolation='none') axins.set_xlim(*extent1[:2]) axins.set_ylim(*extent1[2:]) plt.xticks(visible=False) plt.yticks(visible=False) plt.gca().xaxis.set_major_locator(plt.NullLocator()) plt.gca().yaxis.set_major_locator(plt.NullLocator()) mark_inset(ax, axins, loc1=2, loc2=4, fc="none", ec="0.5") ax.axis('off') fig.tight_layout() fig.savefig('./tux_inset.png', dpi=150) # plt.show()
def show_coord_topo_zoom(windpark, show = True): """Plot the topology of a given windpark Topographic Map with farms see: http://matplotlib.org/basemap/users/examples.html Basemap Parameters ---------- windpark : Windpark A given windpark to show the topology. """ plt.clf() turbines = windpark.get_turbines() target = windpark.get_target() radius = windpark.get_radius() #pack latitude and longitude in lists rel_input_lat = [] rel_input_lon = [] for row in turbines: rel_input_lat.append(np.float64(row.latitude)) rel_input_lon.append(np.float64(row.longitude)) targetcoord = [0.0, 0.0] targetcoord[0] = np.float64(target.latitude) targetcoord[1] = np.float64(target.longitude) graddiff = (800/111.0) + 0.5 # degree in km... 800km fig = plt.figure(figsize=(11.7,8.3)) plt.title("Location of the farm") #Custom adjust of the subplots plt.subplots_adjust(left=0.05,right=0.95,top=0.90,bottom=0.05,wspace=0.15,hspace=0.05) ax = plt.subplot(111) m = Basemap(projection='lcc', lon_0=targetcoord[1], lat_0=targetcoord[0],\ llcrnrlon = targetcoord[1]-graddiff*2, llcrnrlat = targetcoord[0]-graddiff ,\ urcrnrlon = targetcoord[1]+graddiff, urcrnrlat = targetcoord[0]+graddiff ,\ rsphere=6371200., resolution = None, area_thresh=1000) # Target x_target,y_target = m(targetcoord[1],targetcoord[0]) # Input Farms rel_inputs_lon, rel_inputs_lat = m(rel_input_lon, rel_input_lat) # labels = [left,right,top,bottom] parallels = np.arange(int(targetcoord[0]-7), int(targetcoord[0]+7), 2.) m.drawparallels(parallels,labels=[False,True,True,False]) meridians = np.arange(int(targetcoord[1]-7), int(targetcoord[1]+7), 2.) m.drawmeridians(meridians,labels=[True,False,False,True]) # plot farms in the radius m.plot(x_target, y_target, 'bo') # m.plot(rel_inputs_lon, rel_inputs_lat, 'r*') #m.bluemarble() m.shadedrelief() # we define the inset_axes, with a zoom of 2 and at location 2 (upper left corner) # axins = zoomed_inset_axes(ax, 40, loc=2) axins = inset_axes(ax, width="65%", # width = 30% of parent_bbox height="65%", # height : 1 inch loc=3) # plot farms in the radius m.plot(x_target, y_target, 'bo') m.plot(rel_inputs_lon, rel_inputs_lat, 'r*') #m.bluemarble() m.shadedrelief() #m.etopo() #m.drawcoastlines() graddiff_park = (radius/(111.0*0.7)) # degree in km x,y = m(targetcoord[1]-graddiff_park,targetcoord[0]-graddiff_park) x2,y2 = m(targetcoord[1]+graddiff_park,targetcoord[0]+graddiff_park) axins.set_xlim(x,x2) # and we apply the limits of the zoom plot to the inset axes axins.set_ylim(y,y2) # idem plt.xticks(visible=False) # we hide the ticks plt.yticks(visible=False) mark_inset(ax, axins, loc1=1, loc2=4, fc="none", ec="0.9", linewidth = 3) # we draw the "zoom effect" on the main map (ax), joining cornder 1 & 3 plt.title("Selected Wind Farms") if(show): plt.show()
def displacement(ofile, timestep, Natoms, matrix0, Type, Time, frontname, pathtodatabase, systemsize): ''' timestep,system_size,matrix0 contain the initial information about the system. we have to go through sortedfiles to find information about the particles at later timesteps. ''' factor = 10**(-8) # conversionfactor from [A^2/ps] -> [m^2/s] Lx = systemsize[1] - systemsize[0] Ly = systemsize[3] - systemsize[2] Lz = systemsize[5] - systemsize[4] halfsystemsize = 0.5 * (Lx + Ly + Lz) / 3.0 # half of average system size time = [] for t in Time: time.append(timestep * t / 1000.0) # to picoseconds #time.append(t) MSDX = [] MSDY = [] MSDZ = [] MSD = [] D_local = [] dt = (time[1] - time[0]) for T in Time: path = frontname + '.%r.txt' % (T) print path msdx = 0 msdy = 0 msdz = 0 msd = 0 filename = os.path.abspath(os.path.join(pathtodatabase, path)) t, Natoms, system_size, matrix, readstructure, entries, types = readfile( filename) counter = 0 for i in range(Natoms): if (matrix['type'][i] == Type): ID = matrix['id'][i] initial_index = None for j in range(Natoms): k = matrix0['id'][j] if (k == ID): initial_index = j break dx = matrix['x'][i] - matrix0['x'][initial_index] dy = matrix['y'][i] - matrix0['y'][initial_index] dz = matrix['z'][i] - matrix0['z'][initial_index] msdx += (dx)**2 msdy += (dy)**2 msdz += (dz)**2 ######################################## # MINIMUM IMAGE CONVENTION # if (dx < -halfsystemsize): dx = dx + Lx if (dx > halfsystemsize): dx = dx - Lx if (dy < -halfsystemsize): dy = dy + Ly if (dy > halfsystemsize): dy = dy - Ly if (dz < -halfsystemsize): dz = dz + Lz if (dz > halfsystemsize): dz = dz - Lz ######################################## msd += dx**2 + dy**2 + dz**2 counter += 1 D_local.append((msd / (counter * 6 * T))) MSDX.append(msdx / (6 * counter)) MSDY.append(msdy / (6 * counter)) MSDZ.append(msdz / (6 * counter)) MSD.append(msd / (6 * counter)) # ballistic_end = 100ps degree = 1 start = int(round(len(MSD) / 5.0)) p = np.polyfit(time[start:], MSD[start:], degree) # last 4/5 of the dataset f = np.polyval(p, time) d_mean_lastpart = p[ 0] #*10**(-8) # to get [m^2/s]. [A^2/ps] = 10**(-8)[m^2/s] p1 = np.polyfit(time[0:start], MSD[0:start], degree) f1 = np.polyval(p1, time) d_mean_firstpart = p1[ 0] #*10**(8) # to get [m^2/s]. [A^2/ps] = 10**(-8)[m^2/s] p2 = np.polyfit(time[0:int(round(start / 2.0))], MSD[0:int(round(start / 2.0))], degree) f2 = np.polyval(p2, time) d_mean_initpart = p2[ 0] #*10**(8) # to get [m^2/s]. [A^2/ps] = 10**(-8)[m^2/s] p3 = np.polyfit(time[0:100], MSD[0:100], degree) f3 = np.polyval(p3, time) d_mean_actual = p3[ 0] #*10**(8) # to get [m^2/s]. [A^2/ps] = 10**(-8)[m^2/s] print "#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#" print " Nvalues in estimate 1 = 100" print " Nvalues in estimate 2 = %g" % (int(round(start / 2.0))) print " Nvalues in estimate 3 = %g" % (int(round(start))) print " Nvalues in estimate 4 = %g" % (len(time[start:])) ############################################################################### # plotting #plt.close('all') plt.figure() # Figure 1 Title = 'Mean square displacement' legends = ['$msd_{x}$', '$msd_{y}$', '$msd_{z}$', '$msd$'] #['$msd$']# Ylabel = 'mean square displacement $ [A^2] $' Xlabel = 'time $ [ps] $' pltname = 'MSD_bulkwater' linestyles = ['--r', '--y', '--k', 'o-b'] #['--r'] # plt.hold(True) plt.plot(time, MSDX, linestyles[0]) plt.plot(time, MSDY, linestyles[1]) plt.plot(time, MSDZ, linestyles[2]) plt.plot(time, MSD, linestyles[3], markevery=10) plt.title(Title) plt.xlabel(Xlabel) plt.ylabel(Ylabel) plt.legend(legends, loc='lower right') plt.hold(False) write_to_file(ofile, Title, Xlabel, Ylabel, pltname, legends, linestyles, [time], [MSDX, MSDY, MSDZ, MSD]) from mpl_toolkits.axes_grid.inset_locator import zoomed_inset_axes, inset_axes, mark_inset plt.figure() ax = plt.axes() # Figure 2 Title = 'Mean square displacement' legends = [ 'MSD', '$f_1 %.3f $' % (d_mean_actual), '$f_2 %.3f $' % (d_mean_initpart), '$f_3 %.3f $' % (d_mean_firstpart), '$f_4 %.3f $' % (d_mean_lastpart) ] pltname = 'MSD_bulkwater_mean' Xlabel = 'time $ [ps] $' Ylabel = 'mean square displacement $ [A^2] $' linestyles = ['b-', '--y', '--r', '--m', '--y'] plt.hold(True) plt.plot(time, MSD, linestyles[0]) plt.plot(time[0:int(round(len(f) / 8.0))], f3[0:int(round(len(f) / 8.0))], linestyles[1]) # very first part plt.plot(time[0:int(round(len(f) / 6.0))], f2[0:int(round(len(f) / 6.0))], linestyles[2]) # initpart plt.plot(time[0:int(round(len(f) / 5.0))], f1[0:int(round(len(f) / 5.0))], linestyles[3]) # firstpart plt.plot(time, f, linestyles[4]) # lastpart plt.hold(False) plt.xlabel(Xlabel) plt.ylabel(Ylabel) plt.legend(legends, loc='lower right') plt.title(Title) ax.spines['top'].set_visible(False) ax.spines['right'].set_visible(False) ax.get_xaxis().tick_bottom() ax.get_yaxis().tick_left() axin = inset_axes(ax, width="30%", height="35%", loc=8) plt.hold(True) axin.plot(time, MSD, linestyles[0]) axin.plot(time, f3, linestyles[1], linewidth=3.0) axin.plot(time, f2, linestyles[2]) #axin.plot(time,f1,linestyles[3]) plt.hold(False) axin.set_xlim(500, 520) ya = 0.0 yb = 4.0 Npoints = 4 points = np.linspace(ya, yb, Npoints) axin.set_ylim(ya, yb) axin.set_xticks([]) axin.set_yticks(points) mark_inset(ax, axin, loc1=3, loc2=4, fc="none", ec="0.5") write_to_file(ofile, Title, Xlabel, Ylabel, pltname, legends, linestyles, [time], [MSD, f]) print "#################################################################" print "# Diffusion estimate f1 : D = %.10f " % (d_mean_actual) print "# Diffusion estimate f2 : D = %.10f " % (d_mean_initpart) print "# Diffusion estimate f3 : D = %.10f " % (d_mean_firstpart) print "# Diffusion estimate f4 : D = %.10f " % (d_mean_lastpart) plt.figure() # Figure 3 Title = 'Time evolution of the local diffusion constant. $ D=(msd/6dt) $' legends = ['$D(t)$'] linestyles = ['-y'] pltname = 'Diffusion_bulkwater' Ylabel = 'displacement $ [ %g m^2/s]$' % factor plt.hold(True) plt.plot(time, D_local, linestyles[0]) plt.hold(False) plt.legend(legends, loc='upper right') plt.title(Title) plt.xlabel(Xlabel) plt.ylabel(Ylabel) write_to_file(ofile, Title, Xlabel, Ylabel, pltname, legends, linestyles, [time], [D_local]) plt.show()
fontsize=12, color='black', transform=plt.gcf().transFigure, bbox=dict(facecolor='white', edgecolor='blue', pad=8.0), ha='center', va='center') # Create a set of inset Axes: these should fill the bounding box allocated to # them. ax2 = plt.axes([0, 0, 1, 1]) # Manually set the position and relative size of the inset axes within ax1 ip = InsetPosition(ax1, [0.75, 0.7, 0.3, 0.4]) ax2.set_axes_locator(ip) # Mark the region corresponding to the inset axes on ax1 and draw lines # in grey linking the two axes. mark_inset(ax1, ax2, loc1=2, loc2=4, fc="none", ec='0.5') # The data into the ax2 ax2.hist(data_14_degrees['M'][condition_mass_14], bins=1000, weights=None, histtype='step', align='mid', orientation='vertical', color='r', label='M measured') ax2.hist(data_14_degrees['Qi'][condition_mass_14] * data_14_degrees['M_Q'][condition_mass_14], bins=1000, weights=None, histtype='step',
# formatting the plot ax.xaxis.set_minor_locator(pylab.MultipleLocator(5)) ax.yaxis.set_minor_locator(pylab.MultipleLocator(0.1)) ax.grid(b=True,which="minor",axis='x') ax.grid(b=True,which="minor",axis='y') ax.set_xticks(range(1850,2030,10)) ax.set_xlim(1843,2021) ax.set_ylim(-1.03,0.89) ax.set_xlabel("Year") legend = ax.legend(loc="upper left",fontsize=14) frame = legend.get_frame() frame.set_facecolor('1.0') ax.set_ylabel("Anomaly") # adding an inset axis to view the downturn at the end better inset_axes = zoomed_inset_axes(ax, 3, loc=4) inset_axes.scatter(df2.Date,df2.Anomaly,s=15,marker='o',facecolor="1.0",lw=0.5,edgecolor="0.0") inset_axes.plot(df2.Date[s12:-e12],yr1LP2,'-y',label='Annual LP') inset_axes.plot(df2.Date[s152:-e152],yr15LP2,'-g',label='>15 yr LP') inset_axes.plot(df2.Date[s752:-e752],yr75LP2,'-b',label='>30 yr LP') inset_axes.plot(df2.Date,yr15SG2,'--r',label='S-G 15 yr') x1, x2, y1, y2 = 2000, 2015, 0.3, 0.6 inset_axes.set_xlim(x1, x2) inset_axes.set_ylim(y1, y2) inset_axes.set_xticks([]) inset_axes.set_yticks([]) inset_axes.set_axis_bgcolor("1.0") ax.set_title("HadCrut4 Monthly Anomaly Smoothing by CTRM and Savitsky-Golay") mark_inset(ax, inset_axes, loc1=1, loc2=2, fc="none", ec="0.0"); pylab.show()
def plots(XX, XF, X_update, up_a, xposition, mode, mode_title): font_size = 18 font = {'size': font_size} plt.rc('text', usetex=True) plt.rc('font', family='serif') matplotlib.rc('font', **font) plt.rc('xtick', labelsize=30) plt.rc('ytick', labelsize=30) plt.figure(figsize=(13, 10)) ax = plt.subplot(111) if mode == 'Longitudinal': lb = ['$u$', '$w$', '$q$', '$\\theta$'] elif mode == 'Lateral_directional': lb = ['$v$', '$p$', '$r$', '$\phi$'] line1 = [] for i in range(4): line1.append(0) line1[i], = ax.plot(XX[i, :], alpha=0.35, label=lb[i]) l4, = ax.plot(la.norm(X_update, axis=0), color='b', linewidth=2.5, label='$\|x_t\|$ LQR for $\hat{A}$') l1, = ax.plot(la.norm(XX, axis=0), color='k', linewidth=2.5, label='$\|x_t\|$ DGR ON') l2, = ax.plot(la.norm(XF, axis=0), color='r', linewidth=2.5, label='$\|x_t\|$ DGR OFF') l3, = ax.plot(up_a, color='g', linewidth=2.5, label='Upper Bound') box = ax.get_position() first_legend = plt.legend(handles=[l1, l2, l3, l4], loc='upper right', prop={'size': 24}) leg = plt.gca().add_artist(first_legend) second_legend = plt.legend(handles=line1, prop={'size': 24}, loc='lower right', bbox_to_anchor=(0.98, 0.39), borderaxespad=0) leg = plt.gca().add_artist(second_legend) ax.axvline(x=xposition, color='gray', linestyle='--', linewidth=3.0) plt.xlim(0, 130) plt.ylim(-10, 75) plt.xlabel('Iteration $t$', fontsize=30) plt.title(mode_title, fontsize=30) plt.grid() plt.show() # Inner Plot # Create a set of inset Axes: these should fill the bounding box allocated to # them. ax2 = plt.axes([0, 0, 1, 1]) # Manually set the position and relative size of the inset axes within ax1 ip = InsetPosition(ax, [0.32, 0.43, 0.5, 0.2]) ax2.set_axes_locator(ip) # Mark the region corresponding to the inset axes on ax1 and draw lines # in grey linking the two axes. mark_inset(ax, ax2, loc1=3, loc2=4, fc="none", ec='y', linewidth=2.0) ax2.set_title('zoom in', size=25) ax2.set(ylim=([-0.5, 3]), xlim=([xposition, 130])) ax2.plot(la.norm(X_update, axis=0), color='b', linewidth=2.5) ax2.plot(la.norm(XX, axis=0), color='k', linewidth=2.5) ax2.plot(up_a, color='g', linewidth=2.5, label='Upper Bound') line1 = [] lb = ['$u$', '$w$', '$q$', '$\\theta$', '$v$', '$p$', '$r$', '$\phi$'] for i in range(4): line1.append(0) line1[i], = ax2.plot(XX[i, :], alpha=0.35, label=lb[i])
ax2.plot(vtx[2, 0], vtx[2, 1], 'bs', markersize=10) plt.axis('equal') plt.axis('off') # plt.title('Grain %d \n'%grain_id+r' $\Delta$g = %.3f$^\circ$'%(mis_ang_deg[-1]),fontsize=22) plt.title(r' $\Delta$g = %.3f$^\circ$' % (mis_ang_deg[-1]), fontsize=22) plt.text(-0.08, -0.08, '(0001)', fontsize=16) plt.text(0.9, -0.08, r'(10$\bar{1}$0)', fontsize=16) plt.text(0.65, 0.49, r'(11$\bar{2}$0)', fontsize=16) ax_in = plt.axes([0, 0, 1, 1]) ip = InsetPosition(ax2, [0.25, -0.5, 0.5, 0.5]) ax_in.set_axes_locator(ip) for i in range(len(pts)): ax_in.plot(pts[i, 0], pts[i, 1], 'o', color=cmaplist[colornums[i]]) # plt.axis([0.29,0.32,0.02,0.035]) mark_inset(ax2, ax_in, loc1=1, loc2=2, fc="none", ec='0.5') plt.axis('equal') ax_in.set_xticklabels('') ax_in.set_yticklabels('') #%% # fig2.savefig('/Users/rachellim/Documents/Research/CHESS_Jun17/2020-08-03/figs/ipfs/grain%d_ipf.jpg'%grain_id, # bbox_inches='tight',dpi=300)
data[np.isnan(data)] = 0 extent = [0., 192., 0., 192.] im = grid[i].imshow(data, extent=extent, interpolation="nearest") grid[i].text(10, 170, letters[i], fontsize=20, color="white") data_zoom = data[135:155, 80:100, ] axins = zoomed_inset_axes(grid[i], 2, loc=3) # zoom = 6 extent = [ 80., 100., 192. - 155., 192. - 135, ] im2 = axins.imshow(data_zoom, extent=extent, interpolation="nearest") im2.set_clim([data.min(), data.max()]) plt.xticks(visible=False) plt.yticks(visible=False) im.set_clim([0., .3]) im2.set_clim([0., .3]) mark_inset(grid[i], axins, loc1=2, loc2=4, fc="none", ec="0.5") grid[0].set_xticks(()) grid[0].set_yticks(()) plt.subplots_adjust(left=0., right=1., top=.99, bottom=.01, wspace=0., hspace=0.) plt.show() fig.savefig(out_fname)
def show_coord_topo_zoom(windpark, show=True): """Plot the topology of a given windpark Topographic Map with farms see: http://matplotlib.org/basemap/users/examples.html Basemap Parameters ---------- windpark : Windpark A given windpark to show the topology. """ plt.clf() turbines = windpark.get_turbines() target = windpark.get_target() radius = windpark.get_radius() #pack latitude and longitude in lists rel_input_lat = [] rel_input_lon = [] for row in turbines: rel_input_lat.append(np.float64(row.latitude)) rel_input_lon.append(np.float64(row.longitude)) targetcoord = [0.0, 0.0] targetcoord[0] = np.float64(target.latitude) targetcoord[1] = np.float64(target.longitude) graddiff = (800 / 111.0) + 0.5 # degree in km... 800km fig = plt.figure(figsize=(11.7, 8.3)) plt.title("Location of the farm") #Custom adjust of the subplots plt.subplots_adjust(left=0.05, right=0.95, top=0.90, bottom=0.05, wspace=0.15, hspace=0.05) ax = plt.subplot(111) m = Basemap(projection='lcc', lon_0=targetcoord[1], lat_0=targetcoord[0],\ llcrnrlon = targetcoord[1]-graddiff*2, llcrnrlat = targetcoord[0]-graddiff ,\ urcrnrlon = targetcoord[1]+graddiff, urcrnrlat = targetcoord[0]+graddiff ,\ rsphere=6371200., resolution = None, area_thresh=1000) # Target x_target, y_target = m(targetcoord[1], targetcoord[0]) # Input Farms rel_inputs_lon, rel_inputs_lat = m(rel_input_lon, rel_input_lat) # labels = [left,right,top,bottom] parallels = np.arange(int(targetcoord[0] - 7), int(targetcoord[0] + 7), 2.) m.drawparallels(parallels, labels=[False, True, True, False]) meridians = np.arange(int(targetcoord[1] - 7), int(targetcoord[1] + 7), 2.) m.drawmeridians(meridians, labels=[True, False, False, True]) # plot farms in the radius m.plot(x_target, y_target, 'bo') # m.plot(rel_inputs_lon, rel_inputs_lat, 'r*') #m.bluemarble() m.shadedrelief() # we define the inset_axes, with a zoom of 2 and at location 2 (upper left corner) # axins = zoomed_inset_axes(ax, 40, loc=2) axins = inset_axes( ax, width="65%", # width = 30% of parent_bbox height="65%", # height : 1 inch loc=3) # plot farms in the radius m.plot(x_target, y_target, 'bo') m.plot(rel_inputs_lon, rel_inputs_lat, 'r*') #m.bluemarble() m.shadedrelief() #m.etopo() #m.drawcoastlines() graddiff_park = (radius / (111.0 * 0.7)) # degree in km x, y = m(targetcoord[1] - graddiff_park, targetcoord[0] - graddiff_park) x2, y2 = m(targetcoord[1] + graddiff_park, targetcoord[0] + graddiff_park) axins.set_xlim( x, x2) # and we apply the limits of the zoom plot to the inset axes axins.set_ylim(y, y2) # idem plt.xticks(visible=False) # we hide the ticks plt.yticks(visible=False) mark_inset( ax, axins, loc1=1, loc2=4, fc="none", ec="0.9", linewidth=3 ) # we draw the "zoom effect" on the main map (ax), joining cornder 1 & 3 plt.title("Selected Wind Farms") if (show): plt.show()
def make_rq(data_dir): # set plotting style mpl.rcParams['font.size']=10 mpl.rcParams['legend.fontsize']='small' mpl.rcParams['figure.autolayout']=True mpl.rcParams['figure.figsize']=[8.0,6.0] # ================================================================== # define DAQ and other parameters #wsize = 12500 # size of event window in samples. 1 sample = 2 ns. #read event window width from the folder name if data_dir.find("3us") != -1: event_window = 3 if data_dir.find("25us") != -1: event_window = 25 # in us. wsize = int(500 * event_window) # samples per waveform # 12500 for 25 us vscale = (2000.0/16384.0) # = 0.122 mV/ADCC, vertical scale tscale = (8.0/4096.0) # = 0.002 µs/sample, time scale save_avg_wfm = False # get the average waveform passing some cut and save to file post_trigger = 0.5 # Was 0.2 for data before 11/22/19 trigger_time_us = event_window*(1-post_trigger) trigger_time = int(trigger_time_us/tscale) n_sipms = 8 n_channels = n_sipms+1 # includes sum # define top, bottom channels n_top = int((n_channels-1)/2) top_channels=np.array(range(n_top),int) bottom_channels=np.array(range(n_top,2*n_top),int) # sphe sizes in mV*sample ns_to_sample = 1024./2000. #convert spe size unit from mV*ns to mV*sample spe = {} with open(data_dir+"spe.txt", 'r') as file: for line in file: (key, val) = line.split() spe[key] = float(val)*ns_to_sample chA_spe_size = spe["ch0"]#29.02 chB_spe_size = spe["ch1"]#30.61 chC_spe_size = spe["ch2"]#28.87 chD_spe_size = spe["ch3"]#28.86*1.25 # scale factor (0.7-1.4) empirical as of Dec 9, 2020 chE_spe_size = spe["ch4"]#30.4 chF_spe_size = spe["ch5"]#30.44 chG_spe_size = spe["ch6"]#30.84 chH_spe_size = spe["ch7"]#30.3*1.8 # scale factor (1.6-2.2) empirical as of Dec 9, 2020 spe_sizes = [chA_spe_size, chB_spe_size, chC_spe_size, chD_spe_size, chE_spe_size, chF_spe_size, chG_spe_size, chH_spe_size] # ================================================================== #load in raw data t_start = time.time() block_size = 3000 n_block = 500 max_evts = n_block*block_size#5000 # 25000 # -1 means read in all entries; 25000 is roughly the max allowed in memory on the DAQ computer max_pts = -1 # do not change if max_evts > 0: max_pts = wsize * max_evts load_dtype = "int16" # pulse RQs to save # RQs to add: # Pulse level: channel areas (fracs; max fracs), TBA, rise time? (just difference of AFTs...) # Event level: drift time; S1, S2 area # Pulse class (S1, S2, other) # max number of pulses per event max_pulses = 4 p_start = np.zeros(( max_evts, max_pulses), dtype=int) p_end = np.zeros(( max_evts, max_pulses), dtype=int) p_found = np.zeros(( max_evts, max_pulses), dtype=int) #center of mass center_top_x = np.zeros(( max_evts, max_pulses)) center_top_y = np.zeros(( max_evts, max_pulses)) center_bot_x = np.zeros(( max_evts, max_pulses)) center_bot_y = np.zeros(( max_evts, max_pulses)) p_area = np.zeros(( max_evts, max_pulses)) p_max_height = np.zeros(( max_evts, max_pulses)) p_min_height = np.zeros(( max_evts, max_pulses)) p_width = np.zeros(( max_evts, max_pulses)) p_afs_2l = np.zeros((max_evts, max_pulses) ) p_afs_2r = np.zeros((max_evts, max_pulses) ) p_afs_1 = np.zeros((max_evts, max_pulses) ) p_afs_25 = np.zeros((max_evts, max_pulses) ) p_afs_50 = np.zeros((max_evts, max_pulses) ) p_afs_75 = np.zeros((max_evts, max_pulses) ) p_afs_99 = np.zeros((max_evts, max_pulses) ) p_hfs_10l = np.zeros((max_evts, max_pulses) ) p_hfs_50l = np.zeros((max_evts, max_pulses) ) p_hfs_10r = np.zeros((max_evts, max_pulses) ) p_hfs_50r = np.zeros((max_evts, max_pulses) ) p_mean_time = np.zeros((max_evts, max_pulses) ) p_rms_time = np.zeros((max_evts, max_pulses) ) # Channel level (per event, per pulse, per channel) p_start_ch = np.zeros((max_evts, max_pulses, n_channels-1), dtype=int) p_end_ch = np.zeros((max_evts, max_pulses, n_channels-1), dtype=int ) p_area_ch = np.zeros((max_evts, max_pulses, n_channels-1) ) p_area_ch_frac = np.zeros((max_evts, max_pulses, n_channels-1) ) p_area_top = np.zeros((max_evts, max_pulses)) p_area_bottom = np.zeros((max_evts, max_pulses)) p_tba = np.zeros((max_evts, max_pulses)) p_class = np.zeros((max_evts, max_pulses), dtype=int) # Event-level variables n_pulses = np.zeros(max_evts, dtype=int) n_s1 = np.zeros(max_evts, dtype=int) n_s2 = np.zeros(max_evts, dtype=int) sum_s1_area = np.zeros(max_evts) sum_s2_area = np.zeros(max_evts) drift_Time = np.zeros(max_evts) drift_Time_AS = np.zeros(max_evts) # for multi-scatter drift time, defined by the first S2. s1_before_s2 = np.zeros(max_evts, dtype=bool) n_wfms_summed = 0 avg_wfm = np.zeros(wsize) # Temporary, for testing low area, multiple-S1 events dt = np.zeros(max_evts) small_weird_areas = np.zeros(max_evts) big_weird_areas = np.zeros(max_evts) n_golden = 0 inn="" inn="" # used to control hand scan empty_evt_ind = np.zeros(max_evts) for j in range(n_block): ch_data = [] for ch_ind in range(n_sipms): ch_data.append(np.fromfile(data_dir + "wave"+str(ch_ind)+".dat", dtype=load_dtype, offset = block_size*wsize*j, count=wsize*block_size)) #t_end_load = time.time() #print("Time to load files: ", t_end_load-t_start) # scale waveforms to get units of mV/sample # then for each channel ensure we # have an integer number of events array_dtype = "float32" # using float32 reduces memory for big files, otherwise implicitly converts to float64 # matrix of all channels including the sum waveform v_matrix_all_ch = [] for ch_ind in range(n_sipms): V = vscale * ch_data[ch_ind].astype(array_dtype) / spe_sizes[ch_ind] V = V[:int(len(V) / wsize) * wsize] V = V.reshape(int(V.size / wsize), wsize) # reshape to make each channel's matrix of events v_matrix_all_ch.append(V) if ch_ind==0: v_sum = np.copy(V) else: v_sum += V v_matrix_all_ch.append(v_sum) # create a time axis in units of µs: x = np.arange(0, wsize, 1) t = tscale*x t_matrix = np.repeat(t[np.newaxis,:], V.size/wsize, 0) # Note: if max_evts != -1, we won't load in all events in the dataset n_events = int(v_matrix_all_ch[0].shape[0]) if n_events == 0: break # perform baseline subtraction for full event (separate from pulse-level baseline subtraction): baseline_start = int(0./tscale) baseline_end = np.min((int(wsize*0.2), 1000)) # baseline subtracted (bls) waveforms saved in this matrix: v_bls_matrix_all_ch = np.zeros( np.shape(v_matrix_all_ch), dtype=array_dtype) # dims are (chan #, evt #, sample #) #t_end_wfm_fill = time.time() #print("Time to fill all waveform arrays: ", t_end_wfm_fill - t_end_load) #print("Events to process: ",n_events) for i in range(0, n_events): sum_baseline = np.mean( v_matrix_all_ch[-1][i,baseline_start:baseline_end] ) #avg ~us, avoiding trigger baselines = [ np.mean( ch_j[i,baseline_start:baseline_end] ) for ch_j in v_matrix_all_ch ] sum_data = v_matrix_all_ch[-1][i,:] - sum_baseline ch_data = [ch_j[i,:]-baseline_j for (ch_j,baseline_j) in zip(v_matrix_all_ch,baselines)] v_bls_matrix_all_ch[:,i,:] = ch_data # ================================================================== # ================================================================== # now setup for pulse finding on the baseline-subtracted sum waveform #check mark #print("Running pulse finder on {:d} events...".format(n_events)) # use for coloring pulses pulse_class_colors = np.array(['blue', 'green', 'red', 'magenta', 'darkorange']) pulse_class_labels = np.array(['Other', 'S1-like LXe', 'S1-like gas', 'S2-like', 'Merged S1/S2']) pc_legend_handles=[] for class_ind in range(len(pulse_class_labels)): pc_legend_handles.append(mpl.patches.Patch(color=pulse_class_colors[class_ind], label=str(class_ind)+": "+pulse_class_labels[class_ind])) for i in range(j*block_size, j*block_size+n_events): if (i)%2000==0: print("Event #",i) # Find pulse locations; other quantities for pf tuning/debugging start_times, end_times, peaks, data_conv, properties = pf.findPulses( v_bls_matrix_all_ch[-1,i-j*block_size,:], max_pulses , SPEMode=False) # Sort pulses by start times, not areas startinds = np.argsort(start_times) n_pulses[i] = len(start_times) if (n_pulses[i] < 1): #print("No pulses found for event {0}; skipping".format(i)) empty_evt_ind[i] = i #continue for m in startinds: if m >= max_pulses: continue p_start[i,m] = start_times[m] p_end[i,m] = end_times[m] # Individual channel pulse locations, in case you want this info # Can't just ":" the the first index in data, findPulses doesn't like it, so have to loop #for j in range(n_channels-1): # start_times_ch, end_times_ch, peaks_ch, data_conv_ch, properties_ch = pf.findPulses( v_bls_matrix_all_ch[j,i,:], max_pulses ) # Sorting by start times from the sum of channels, not each individual channel # for k in startinds: # if k >= len(start_times_ch): # continue # p_start_ch[i,k,j] = start_times_ch[k] # p_end_ch[i,k,j] = end_times_ch[k] # More precisely estimate baselines immediately before each pulse baselines_precise = pq.GetBaselines(p_start[i,:n_pulses[i]], p_end[i,:n_pulses[i]], v_bls_matrix_all_ch[:,i-j*block_size,:]) # Calculate interesting quantities, only for pulses that were found for pp in range(n_pulses[i]): # subtract out more precise estimate of baseline for better RQ estimates baselines_pulse = baselines_precise[pp] # array of baselines per channel, for this pulse v_pulse_bls = np.array([ch_j - baseline_j for (ch_j, baseline_j) in zip(v_bls_matrix_all_ch[:,i-j*block_size,:], baselines_pulse)]) # Version w/o pulse-level baseline subtraction #v_pulse_bls = v_bls_matrix_all_ch[:,i-j*block_size,:] # copied from above, for reference #sum_data = v_matrix_all_ch[-1][i, :] - sum_baseline #ch_data = [ch_j[i, :] - baseline_j for (ch_j, baseline_j) in zip(v_matrix_all_ch, baselines)] # Area, max & min heights, width, pulse mean & rms p_area[i,pp] = pq.GetPulseArea(p_start[i,pp], p_end[i,pp], v_pulse_bls[-1] ) p_max_height[i,pp] = pq.GetPulseMaxHeight(p_start[i,pp], p_end[i,pp], v_pulse_bls[-1] ) p_min_height[i,pp] = pq.GetPulseMinHeight(p_start[i,pp], p_end[i,pp], v_pulse_bls[-1] ) p_width[i,pp] = p_end[i,pp] - p_start[i,pp] #(p_mean_time[i,pp], p_rms_time[i,pp]) = pq.GetPulseMeanAndRMS(p_start[i,pp], p_end[i,pp], v_bls_matrix_all_ch[-1,i,:]) # Area and height fractions (p_afs_2l[i,pp], p_afs_1[i,pp], p_afs_25[i,pp], p_afs_50[i,pp], p_afs_75[i,pp], p_afs_99[i,pp]) = pq.GetAreaFraction(p_start[i,pp], p_end[i,pp], v_pulse_bls[-1] ) (p_hfs_10l[i,pp], p_hfs_50l[i,pp], p_hfs_10r[i,pp], p_hfs_50r[i,pp]) = pq.GetHeightFractionSamples(p_start[i,pp], p_end[i,pp], v_pulse_bls[-1] ) # Areas for individual channels and top bottom p_area_ch[i,pp,:] = pq.GetPulseAreaChannel(p_start[i,pp], p_end[i,pp], v_pulse_bls ) p_area_ch_frac[i,pp,:] = p_area_ch[i,pp,:]/p_area[i,pp] p_area_top[i,pp] = sum(p_area_ch[i,pp,top_channels]) p_area_bottom[i,pp] = sum(p_area_ch[i,pp,bottom_channels]) p_tba[i, pp] = (p_area_top[i, pp] - p_area_bottom[i, pp]) / (p_area_top[i, pp] + p_area_bottom[i, pp]) center_top_x[i,pp] = (p_area_ch[i,pp,1]+p_area_ch[i,pp,3]-p_area_ch[i,pp,0]-p_area_ch[i,pp,2])/p_area_top[i,pp] center_top_y[i,pp] = (p_area_ch[i,pp,0]+p_area_ch[i,pp,1]-p_area_ch[i,pp,2]-p_area_ch[i,pp,3])/p_area_top[i,pp] center_bot_x[i,pp] = (p_area_ch[i,pp,5]+p_area_ch[i,pp,7]-p_area_ch[i,pp,4]-p_area_ch[i,pp,6])/p_area_bottom[i,pp] center_bot_y[i,pp] = (p_area_ch[i,pp,4]+p_area_ch[i,pp,5]-p_area_ch[i,pp,6]-p_area_ch[i,pp,7])/p_area_bottom[i,pp] # Pulse classifier, work in progress p_class[i,:] = pc.ClassifyPulses(p_tba[i, :], (p_afs_50[i, :]-p_afs_2l[i, :])*tscale, n_pulses[i], p_area[i,:]) # Event level analysis. Look at events with both S1 and S2. index_s1 = (p_class[i,:] == 1) + (p_class[i,:] == 2) # S1's index_s2 = (p_class[i,:] == 3) + (p_class[i,:] == 4) # S2's n_s1[i] = np.sum(index_s1) n_s2[i] = np.sum(index_s2) if n_s1[i] > 0: sum_s1_area[i] = np.sum(p_area[i, index_s1]) if n_s2[i] > 0: sum_s2_area[i] = np.sum(p_area[i, index_s2]) if n_s1[i] == 1: if n_s2[i] == 1: drift_Time[i] = tscale*(p_start[i, np.argmax(index_s2)] - p_start[i, np.argmax(index_s1)]) drift_Time_AS[i] = tscale*(p_start[i, np.argmax(index_s2)] - p_start[i, np.argmax(index_s1)]) if n_s2[i] > 1: s1_before_s2[i] = np.argmax(index_s1) < np.argmax(index_s2) drift_Time_AS[i] = tscale*(p_start[i, np.argmax(index_s2)] - p_start[i, np.argmax(index_s1)]) #For multi-scatter events. if drift_Time[i]>0: n_golden += 1 # ============================================================= # draw the waveform and the pulse bounds found # Code to allow skipping to another event index for plotting plot_event_ind = i try: plot_event_ind = int(inn) if plot_event_ind < i: inn = '' plot_event_ind = i print("Can't go backwards! Continuing to next event.") except ValueError: plot_event_ind = i # Condition to plot now includes this rise time calc, not necessary riseTimeCondition = ((p_afs_50[i,:n_pulses[i]]-p_afs_2l[i,:n_pulses[i]] )*tscale < 0.6)*((p_afs_50[i,:n_pulses[i]]-p_afs_2l[i,:n_pulses[i]] )*tscale > 0.2) po_test = np.any((p_area[i,:]>5.0e4)*((p_afs_50[i,:]-p_afs_2l[i,:] )*tscale<1.0)) # Condition to skip the individual plotting, hand scan condition #plotyn = drift_Time[i]<2 and drift_Time[i]>0 and np.any((p_tba[i,:]>-0.75)*(p_tba[i,:]<-0.25)*(p_area[i,:]<3000)*(p_area[i,:]>1400))#np.any((p_tba[i,:]>-0.91)*(p_tba[i,:]<-0.82)*(p_area[i,:]<2800)*(p_area[i,:]>1000))# True#np.any(p_class[i,:]==4)#False#np.any(p_area[i,:]>1000) and #plotyn = drift_Time[i]>2.5 and (center_bot_y[i,0]**2+center_bot_x[i,0]**2) <0.1 plotyn = drift_Time[i]>1 #np.any((p_class[i,:] == 3) + (p_class[i,:] == 4))#np.any((p_tba[i,:]>-0.75)*(p_tba[i,:]<-0.25)*(p_area[i,:]<3000)*(p_area[i,:]>1000)) #plotyn = np.any((p_tba[i,:]>-1)*(p_tba[i,:]<-0.25)*(p_area[i,:]<30000)*(p_area[i,:]>3000))#np.any((np.log10(p_area[i,:])>3.2)*(np.log10(p_area[i,:])<3.4) )#False# # Pulse area condition areaRange = np.sum((p_area[i,:] < 50)*(p_area[i,:] > 5)) if areaRange > 0: dt[i] = abs(p_start[i,1] - p_start[i,0]) # For weird double s1 data weird_areas =[p_area[i,0], p_area[i,1] ] small_weird_areas[i] = min(weird_areas) big_weird_areas[i] = max(weird_areas) # Condition to include a wfm in the average add_wfm = np.any((p_area[i,:]>5000)*(p_tba[i,:]<-0.75))*(n_s1[i]==1)*(n_s2[i]==0) if add_wfm and save_avg_wfm: plotyn = add_wfm # in avg wfm mode, plot the events which will go into the average avg_wfm += v_bls_matrix_all_ch[-1,i-j*block_size,:] n_wfms_summed += 1 # Both S1 and S2 condition s1s2 = (n_s1[i] == 1)*(n_s2[i] == 1) if inn == 's': sys.exit() if not inn == 'q' and plot_event_ind == i and plotyn: fig = pl.figure(1,figsize=(10, 3.5)) pl.rc('xtick', labelsize=10) pl.rc('ytick', labelsize=10) ax = pl.subplot() ch_labels = ['A','B','C','D','E','F','G','H'] ch_colors = [pl.cm.tab10(ii) for ii in range(n_channels)] #pl.plot(t,v_bls_matrix_all_ch[-1,i,:],'blue') #pl.plot( x*tscale, v_bls_matrix_all_ch[-1,i-j*block_size,:],'blue' ) #pl.xlim([0,wsize]) #pl.xlim([0,event_window]) trigger_time_us = 12 # for some reason seems to be consistently closer to 12 than 12.5 pl.xlim([start_times[0]*tscale-3-trigger_time_us,end_times[1]*tscale+1.5-trigger_time_us]) #pl.ylim( [-1, 1.01*np.max(v_bls_matrix_all_ch[-1,i-j*block_size,:])]) pl.ylim( [-1, 1.1*np.max(v_bls_matrix_all_ch[:-1,i-j*block_size,:])]) pl.xlabel('Time ($\mu$s)') #pl.xlabel('Samples') pl.ylabel('phd/sample') #pl.title("Sum, event "+ str(i)) pl.grid(b=True,which='major',color='lightgray',linestyle='--') #pl.legend(handles=pc_legend_handles) dead_channels = [2,7] for i_chan in range(n_channels - 1): if i_chan in dead_channels: continue pl.plot(t-trigger_time_us, v_bls_matrix_all_ch[i_chan, i - j * block_size, :], color=ch_colors[i_chan], label=ch_labels[i_chan]) # pl.plot( x, v_bls_matrix_all_ch[i_chan,i,:],color=ch_colors[i_chan],label=ch_labels[i_chan] ) #pl.xlim([trigger_time_us - 8, trigger_time_us + 8]) # pl.xlim([wsize/2-4000,wsize/2+4000]) #pl.ylim([-5, 3000 / chA_spe_size]) #pl.xlabel('Time (us)') # pl.xlabel('Samples') #pl.ylabel('phd/sample') #pl.legend() for pulse in range(len(start_times)): class_name = "S1" if p_class[i,pulse] == 3 or p_class[i,pulse] == 4: class_name = "S2" ax.axvspan(start_times[pulse] * tscale-trigger_time_us, end_times[pulse] * tscale-trigger_time_us, alpha=0.1, color=pulse_class_colors[p_class[i, pulse]]) ax.text((end_times[pulse]) * tscale+0.1-trigger_time_us, 0.9 * ax.get_ylim()[1], class_name, fontsize=10, color=pulse_class_colors[p_class[i, pulse]]) ax.text((end_times[pulse]) * tscale+0.1-trigger_time_us, 0.84 * ax.get_ylim()[1], 'Area = {:.1f} phd'.format(p_area[i, pulse]), fontsize=10, color=pulse_class_colors[p_class[i, pulse]]) ax.text((end_times[pulse]) * tscale+0.1-trigger_time_us, 0.73 * ax.get_ylim()[1], '$A_{{TB}}$ = {:.1f}'.format(p_tba[i, pulse]), fontsize=10, color=pulse_class_colors[p_class[i, pulse]]) #ax.axhline( 0.276, 0, wsize, linestyle='--', lw=1, color='orange') # Draw drift time w/ arrow arrow_alpha = 0.8 head_length = 0.1 pl.arrow(start_times[0] * tscale-trigger_time_us, 0.5 * ax.get_ylim()[1], drift_Time[i]-head_length, 0, head_width=1.2, head_length=head_length, width=0.05, color='b', alpha=arrow_alpha) ax.text(start_times[0] * tscale-trigger_time_us + drift_Time[i]/5, 0.57 * ax.get_ylim()[1], r'Drift time={:.1f} $\mu$s'.format(drift_Time[i]), fontsize=10, color='b') # Create a set of inset Axes: these should fill the bounding box allocated to # them. from mpl_toolkits.axes_grid.inset_locator import (inset_axes, InsetPosition, mark_inset) ax2 = pl.axes([0, 0, 1, 1]) # Manually set the position and relative size of the inset axes within ax1 ip = InsetPosition(ax, [0.05, 0.43, 0.25, 0.5]) ax2.set_axes_locator(ip) #ax2.set_ylabel('phd/sample') #ax2.set_xlabel('Time (us)') # Mark the region corresponding to the inset axes on ax1 and draw lines # in grey linking the two axes. mark_inset(ax, ax2, loc1=1, loc2=3, fc="none", ec='0.5') ax2.grid(b=True,which='major',color='lightgray',linestyle='--') # Plot data in inset inset_start = start_times[0] inset_end = end_times[0] for i_chan in range(n_channels - 1): if i_chan in dead_channels: continue ax2.plot(t[inset_start:inset_end]-trigger_time_us, v_bls_matrix_all_ch[i_chan, i - j * block_size, inset_start:inset_end], color=ch_colors[i_chan], label=ch_labels[i_chan]) #ax2.plot(t[inset_start:inset_end],v_bls_matrix_all_ch[-1,i,inset_start:inset_end],'blue') #ax2.xlim((start_times[0]*tscale-1,end_times[0]*tscale+1)) #ax2.ylim((start_times[0]*tscale-1,end_times[0]*tscale+1)) #ax2.legend(loc=0) # Debugging of pulse finder debug_pf = False if debug_pf and n_pulses[i]>0: pl.plot(t_matrix[i-j*block_size, :], data_conv, 'red') pl.plot(t_matrix[i-j*block_size, :], np.tile(0., np.size(data_conv)), 'gray') pl.vlines(x=peaks*tscale, ymin=data_conv[peaks] - properties["prominences"], ymax=data_conv[peaks], color="C1") pl.hlines(y=properties["width_heights"], xmin=properties["left_ips"]*tscale, xmax=properties["right_ips"]*tscale, color="C1") #print("pulse heights: ", data_conv[peaks] ) #print("prominences:", properties["prominences"]) pl.draw() pl.show(block=0) inn = input("Press enter to continue, q to stop plotting, evt # to skip to # (forward only)") fig.clf() # end of pulse finding and plotting event loop if save_avg_wfm: avg_wfm /= n_wfms_summed np.savetxt(data_dir+'average_waveform.txt',avg_wfm) print("Average waveform saved") n_events = i t_end = time.time() print("total number of events processed:", n_events) print("Time used: {}".format(t_end-t_start)) print("empty events: {0}".format(np.sum(empty_evt_ind>0))) # pl.hist(empty_evt_ind[empty_evt_ind>0], bins=1000) # pl.xlabel('Empty event index') # pl.show() #create a dictionary with all RQs list_rq = {} list_rq['center_top_x'] = center_top_x list_rq['center_top_y'] = center_top_y list_rq['center_bot_x'] = center_bot_x list_rq['center_bot_y'] = center_bot_y list_rq['n_s1'] = n_s1 list_rq['n_s2'] = n_s2 list_rq['s1_before_s2'] = s1_before_s2 list_rq['n_pulses'] = n_pulses list_rq['n_events'] = n_events list_rq['p_area'] = p_area list_rq['p_class'] = p_class list_rq['drift_Time'] = drift_Time list_rq['drift_Time_AS'] = drift_Time_AS list_rq['p_max_height'] = p_max_height list_rq['p_min_height'] = p_min_height list_rq['p_width'] = p_width list_rq['p_afs_2l'] = p_afs_2l list_rq['p_afs_50'] = p_afs_50 list_rq['p_area_ch'] = p_area_ch list_rq['p_area_ch_frac'] = p_area_ch_frac list_rq['p_area_top'] = p_area_top list_rq['p_area_bottom'] = p_area_bottom list_rq['p_tba'] = p_tba list_rq['p_start'] = p_start list_rq['p_end'] = p_end list_rq['sum_s1_area'] = sum_s1_area list_rq['sum_s2_area'] = sum_s2_area #list_rq[''] = #add more rq #remove zeros in the end of each RQ array. for rq in list_rq.keys(): if rq != 'n_events': list_rq[rq] = list_rq[rq][:n_events] rq = open(data_dir + "rq.npz",'wb') np.savez(rq, **list_rq) rq.close()
figure() d = NormalDistr(2, 1) * NormalDistr(2, 1) demo_distr(d) #show() figure() d = NormalDistr(3, 1) * NormalDistr(3, 1) d.plot() d.hist() ax = gca() axins = zoomed_inset_axes(ax, 6, loc=1) d.plot(xmin=-1.5, xmax=1.5) axins.set_xlim(-1.5, 1.5) xticks(rotation="vertical") axins.set_ylim(0, 0.01) mark_inset(ax, axins, loc1=2, loc2=4, fc="none", ec="0.5") #show() figure() d = NormalDistr(4, 1) * NormalDistr(4, 1) d.plot() d.hist() ax = gca() axins = zoomed_inset_axes(ax, 12000, loc=1) d.plot(xmin=-.001, xmax=.001) axins.set_xlim(-.001, .001) xticks(rotation="vertical") axins.set_ylim(0.000072, 0.000075) mark_inset(ax, axins, loc1=2, loc2=4, fc="none", ec="0.5") #show()
## just passing transform=ax.transAxes as an argument to add_axes() does nothing. ## So you need to do some complicated jugglery ## (from http://matplotlib.1069221.n5.nabble.com/Adding-custom-axes-within-a-subplot-td20316.html) Bbox = matplotlib.transforms.Bbox.from_bounds(.75, .6, .5, .5) trans = ax1.transAxes + fig.transFigure.inverted() l, b, w, h = matplotlib.transforms.TransformedBbox(Bbox,trans).bounds axinset = fig.add_axes([l, b, w, h]) axinset.plot(timevec,mit_responses[1][0]*1e3,color='r',linewidth=plot_linewidth,label='Lateral') ## thin frame for loc, spine in axinset.spines.items(): # items() returns [(key,value),...] spine.set_linewidth(axes_linewidth) axinset.set_xlim(910,975) axinset.set_ylim(-71.5,-70) axinset.set_xticks([]) axinset.set_yticks([]) mark_inset(ax1, axinset, loc1=2, loc2=4, fc="none", ec="0.5", linewidth=axes_linewidth) ## mitral B ax1 = fig.add_subplot(2,2,2) ax1.plot((tmin,tmax),(Vrest,Vrest),linestyle='dashed',linewidth=plot_linewidth,color=(0.5,0.5,0.5)) ax1.plot(timevec,mit_responses[1][1]*1e3,color='g',linewidth=plot_linewidth,label='Lateral') beautify_plot(ax1,x0min=False,y0min=False,xticksposn='none',yticksposn='none') ax1.set_xlim(tmin,tmax) ax1.set_ylim(Vmin,Vmax) ax1.set_yticks([]) axes_labels(ax1,'','') ax2 = fig.add_subplot(2,2,4) ax2.plot((tmin,tmax),(Vrest,Vrest),linestyle='dashed',linewidth=plot_linewidth,color=(0.5,0.5,0.5)) ax2.plot(timevec,mit_responses[0][1]*1e3,color='g',linewidth=plot_linewidth,label='Recurrent') beautify_plot(ax2,x0min=False,y0min=False,xticksposn='bottom',yticksposn='none') ax2.set_xlim(tmin,tmax)
fig, ax = plt.subplots(figsize=(8,6)) axin1 = ax.inset_axes( [20, 12, 8, 4], transform=ax.transData) axin1.plot(col_x_arr,col_y_arr, "r--") #axin1.plot(col_x_arr,col_y2_arr,'b--') axin1.set_xlim(0 , 5.0) axin1.set_ylim(0, 2.0) axin1.set(facecolor='white') #axin1.grid(which='major', color='gray',linestyle='-') #Plot Gridlines in Subgrid axin1.spines['bottom'].set_color('black') axin1.spines['top'].set_color('black') axin1.spines['right'].set_color('black') axin1.spines['left'].set_color('black') #Marklines to trace inset mark_inset(ax, axin1, loc1=2, loc2=4, fc="none", ec='0.5') #Main Plot line1=ax.plot(col_x_arr,col_y_arr) #line2=ax.plot(col_x_arr,col_y2_arr) ax.set_title('Matplotlib') ax.set(facecolor='white') ax.grid(which='major', color='lightgray',linestyle='-') ax.spines['bottom'].set_color('black') ax.spines['top'].set_color('black') ax.spines['right'].set_color('black') ax.spines['left'].set_color('black') #ax.legend(loc=0) #Legend if available plt.setp(line1, color='r', linewidth=2.0) #plt.setp(line2, color='b', linewidth=2.0)
def zoommap(vals, title, label): fig = plt.figure(figsize=(12, 8)) plt.subplots_adjust(left=0.05, right=0.95, top=0.90, bottom=0.05, wspace=0.15, hspace=0.05) ax = plt.subplot(211) m = Basemap(projection='mill', llcrnrlat=-45, llcrnrlon=-160, urcrnrlat=82, urcrnrlon=170, resolution='c') x, y = m(lons, lats) m.drawcoastlines(linewidth=0.5) plt.subplots_adjust(left=0.05, right=0.95, top=0.90, bottom=0.05, wspace=0.15, hspace=0.05) cmap = matplotlib.colors.ListedColormap( ['#d73027', '#fc8d59', '#fee090', '#e0f3f8', '#91bfdb', '#4575b4']) bounds = [0, 0.3, 0.5, 0.7, 0.8, 0.9, 1.0] norm = matplotlib.colors.BoundaryNorm(bounds, cmap.N) m.scatter(x, y, s=40, c=vals, cmap=cmap, norm=norm) plt.colorbar(orientation="vertical", boundaries=bounds, spacing='proportional', ticks=bounds) ax.text(0.03, 0.95, label, size=12, horizontalalignment='center', verticalalignment='center', transform=ax.transAxes) plt.title(title, fontsize=14) #Zoom Europe axins_1 = zoomed_inset_axes(ax, 2, loc=2, bbox_to_anchor=(0.396, 0.48), bbox_transform=ax.figure.transFigure) axins_1.scatter(x, y, s=20, c=vals, cmap=cmap, norm=norm) m.drawcoastlines(linewidth=0.5) x2, y2 = m(-12, 35) x3, y3 = m(40, 65) axins_1.set_xlim(x2, x3) axins_1.set_ylim(y2, y3) axes = mark_inset(ax, axins_1, loc1=1, loc2=2, linewidth=1) #Zoom Australia axins_2 = zoomed_inset_axes(ax, 2.2, loc=3, bbox_to_anchor=(0.59, 0.255), bbox_transform=ax.figure.transFigure) axins_2.scatter(x, y, s=20, c=vals, cmap=cmap, norm=norm) m.drawcoastlines(linewidth=0.5) x2, y2 = m(110, -43) x3, y3 = m(155, -10) axins_2.set_xlim(x2, x3) axins_2.set_ylim(y2, y3) axes = mark_inset(ax, axins_2, loc1=1, loc2=2, linewidth=1) #Zoom US axins_3 = zoomed_inset_axes(ax, 1.6, loc=3, bbox_to_anchor=(0.19, 0.25), bbox_transform=ax.figure.transFigure) axins_3.scatter(x, y, s=20, c=vals, cmap=cmap, norm=norm) m.drawcoastlines(linewidth=0.5) x2, y2 = m(-130, 22) x3, y3 = m(-60, 63) axins_3.set_xlim(x2, x3) axins_3.set_ylim(y2, y3) axes = mark_inset(ax, axins_3, loc1=1, loc2=2, linewidth=1) return (fig, axes)
ax1 = plt.gca() x_max = 4.0 x_min = 2.0 ann_mask = numpy.logical_and(r_ann >= x_min, r_ann <= x_max) gfmc_mask = numpy.logical_and(r_gfmc >= x_min, r_gfmc <= x_max) # bottom, left, width, height ax2 = plt.axes([0, 2., 2., 0.2]) # Manually set the position and relative size of the inset axes within ax1 ip = InsetPosition(ax1, [0.35, 0.25, 0.5, 0.5]) ax2.set_axes_locator(ip) # Mark the region corresponding to the inset axes on ax1 and draw lines # in grey linking the two axes. mark_inset(ax1, ax2, loc1=3, loc2=1, fc="black", alpha=0.5, ec='black') ax2.fill_between(r_gfmc[gfmc_mask], rho_gfmc[gfmc_mask] - drho_gfmc[gfmc_mask], rho_gfmc[gfmc_mask] + drho_gfmc[gfmc_mask], alpha=0.75) ax2.plot(r_gfmc[gfmc_mask], rho_gfmc[gfmc_mask], lw=3) ax2.errorbar( r_ann[ann_mask], rho_ann[ann_mask], yerr=drho_ann[ann_mask], # label="Error x10", ls="none", marker='o', ms=7, # color='orange'
## just passing transform=ax.transAxes as an argument to add_axes() does nothing. ## So you need to do some complicated jugglery ## (from http://matplotlib.1069221.n5.nabble.com/Adding-custom-axes-within-a-subplot-td20316.html) Bbox = matplotlib.transforms.Bbox.from_bounds(0.75, 0.6, 0.5, 0.5) trans = ax1.transAxes + fig.transFigure.inverted() l, b, w, h = matplotlib.transforms.TransformedBbox(Bbox, trans).bounds axinset = fig.add_axes([l, b, w, h]) axinset.plot(timevec, mit_responses[1][0] * 1e3, color="r", linewidth=plot_linewidth, label="Lateral") ## thin frame for loc, spine in axinset.spines.items(): # items() returns [(key,value),...] spine.set_linewidth(axes_linewidth) axinset.set_xlim(910, 975) axinset.set_ylim(-71.5, -70) axinset.set_xticks([]) axinset.set_yticks([]) mark_inset(ax1, axinset, loc1=2, loc2=4, fc="none", ec="0.5", linewidth=axes_linewidth) ## mitral B ax1 = fig.add_subplot(2, 2, 2) ax1.plot((tmin, tmax), (Vrest, Vrest), linestyle="dashed", linewidth=plot_linewidth, color=(0.5, 0.5, 0.5)) ax1.plot(timevec, mit_responses[1][1] * 1e3, color="g", linewidth=plot_linewidth, label="Lateral") beautify_plot(ax1, x0min=False, y0min=False, xticksposn="none", yticksposn="none") ax1.set_xlim(tmin, tmax) ax1.set_ylim(Vmin, Vmax) ax1.set_yticks([]) axes_labels(ax1, "", "") ax2 = fig.add_subplot(2, 2, 4) ax2.plot((tmin, tmax), (Vrest, Vrest), linestyle="dashed", linewidth=plot_linewidth, color=(0.5, 0.5, 0.5)) ax2.plot(timevec, mit_responses[0][1] * 1e3, color="g", linewidth=plot_linewidth, label="Recurrent") beautify_plot(ax2, x0min=False, y0min=False, xticksposn="bottom", yticksposn="none") ax2.set_xlim(tmin, tmax)
def displacement(ofile,timestep,Natoms,matrix0,Type,Time,frontname,pathtodatabase,systemsize): ''' timestep,system_size,matrix0 contain the initial information about the system. we have to go through sortedfiles to find information about the particles at later timesteps. ''' factor = 10**(-8) # conversionfactor from [A^2/ps] -> [m^2/s] Lx = systemsize[1] -systemsize[0] Ly = systemsize[3] -systemsize[2] Lz = systemsize[5] -systemsize[4] halfsystemsize = 0.5*(Lx+Ly+Lz)/3.0 # half of average system size time = [] for t in Time: time.append(timestep*t/1000.0) # to picoseconds #time.append(t) MSDX = [];MSDY = [];MSDZ = [];MSD = [];D_local = [] dt = (time[1]-time[0]) for T in Time: path = frontname + '.%r.txt' % (T) print path msdx = 0; msdy = 0; msdz = 0; msd = 0 filename = os.path.abspath(os.path.join(pathtodatabase,path)) t, Natoms, system_size, matrix, readstructure, entries, types = readfile(filename) counter = 0 for i in range(Natoms): if (matrix['type'][i] == Type): ID = matrix['id'][i] initial_index = None for j in range(Natoms): k = matrix0['id'][j] if (k == ID): initial_index = j break dx = matrix['x'][i] - matrix0['x'][initial_index] dy = matrix['y'][i] - matrix0['y'][initial_index] dz = matrix['z'][i] - matrix0['z'][initial_index] msdx += (dx)**2 msdy += (dy)**2 msdz += (dz)**2 ######################################## # MINIMUM IMAGE CONVENTION # if (dx < -halfsystemsize): dx = dx + Lx if (dx > halfsystemsize): dx = dx - Lx if (dy < -halfsystemsize): dy = dy + Ly if (dy > halfsystemsize): dy = dy - Ly if (dz < -halfsystemsize): dz = dz + Lz if (dz > halfsystemsize): dz = dz - Lz ######################################## msd += dx**2 + dy**2 + dz**2 counter += 1 D_local.append((msd/(counter*6*T))) MSDX.append(msdx/(6*counter));MSDY.append(msdy/(6*counter));MSDZ.append(msdz/(6*counter));MSD.append(msd/(6*counter)) # ballistic_end = 100ps degree = 1 start = int(round(len(MSD)/5.0)) p = np.polyfit(time[start:],MSD[start:],degree) # last 4/5 of the dataset f = np.polyval(p,time) d_mean_lastpart = p[0]#*10**(-8) # to get [m^2/s]. [A^2/ps] = 10**(-8)[m^2/s] p1 = np.polyfit(time[0:start],MSD[0:start],degree) f1 = np.polyval(p1,time) d_mean_firstpart = p1[0]#*10**(8) # to get [m^2/s]. [A^2/ps] = 10**(-8)[m^2/s] p2 = np.polyfit(time[0:int(round(start/2.0))],MSD[0:int(round(start/2.0))],degree) f2 = np.polyval(p2,time) d_mean_initpart = p2[0]#*10**(8) # to get [m^2/s]. [A^2/ps] = 10**(-8)[m^2/s] p3 = np.polyfit(time[0:100],MSD[0:100],degree) f3 = np.polyval(p3,time) d_mean_actual = p3[0]#*10**(8) # to get [m^2/s]. [A^2/ps] = 10**(-8)[m^2/s] print "#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#" print " Nvalues in estimate 1 = 100" print " Nvalues in estimate 2 = %g" % (int(round(start/2.0))) print " Nvalues in estimate 3 = %g" % (int(round(start))) print " Nvalues in estimate 4 = %g" % (len(time[start:])) ############################################################################### # plotting #plt.close('all') plt.figure() # Figure 1 Title = 'Mean square displacement' legends = ['$msd_{x}$','$msd_{y}$','$msd_{z}$','$msd$']#['$msd$']# Ylabel = 'mean square displacement $ [A^2] $' Xlabel = 'time $ [ps] $' pltname = 'MSD_bulkwater' linestyles = ['--r','--y','--k','o-b']#['--r'] # plt.hold(True) plt.plot(time,MSDX,linestyles[0]) plt.plot(time,MSDY,linestyles[1]) plt.plot(time,MSDZ,linestyles[2]) plt.plot(time,MSD,linestyles[3],markevery=10) plt.title(Title) plt.xlabel(Xlabel) plt.ylabel(Ylabel) plt.legend(legends,loc='lower right') plt.hold(False) write_to_file(ofile,Title,Xlabel,Ylabel,pltname,legends,linestyles,[time],[MSDX,MSDY,MSDZ,MSD]) from mpl_toolkits.axes_grid.inset_locator import zoomed_inset_axes, inset_axes, mark_inset plt.figure() ax = plt.axes() # Figure 2 Title = 'Mean square displacement' legends = ['MSD','$f_1 %.3f $' % (d_mean_actual),'$f_2 %.3f $' % (d_mean_initpart),'$f_3 %.3f $' % (d_mean_firstpart),'$f_4 %.3f $' % (d_mean_lastpart)] pltname = 'MSD_bulkwater_mean' Xlabel = 'time $ [ps] $' Ylabel = 'mean square displacement $ [A^2] $' linestyles = ['b-','--y','--r','--m','--y'] plt.hold(True) plt.plot(time,MSD,linestyles[0]) plt.plot(time[0:int(round(len(f)/8.0))],f3[0:int(round(len(f)/8.0))],linestyles[1]) # very first part plt.plot(time[0:int(round(len(f)/6.0))],f2[0:int(round(len(f)/6.0))],linestyles[2]) # initpart plt.plot(time[0:int(round(len(f)/5.0))],f1[0:int(round(len(f)/5.0))],linestyles[3]) # firstpart plt.plot(time,f,linestyles[4]) # lastpart plt.hold(False) plt.xlabel(Xlabel) plt.ylabel(Ylabel) plt.legend(legends,loc='lower right') plt.title(Title) ax.spines['top'].set_visible(False) ax.spines['right'].set_visible(False) ax.get_xaxis().tick_bottom() ax.get_yaxis().tick_left() axin = inset_axes(ax, width="30%", height="35%", loc=8) plt.hold(True) axin.plot(time,MSD,linestyles[0]) axin.plot(time,f3,linestyles[1],linewidth=3.0) axin.plot(time,f2,linestyles[2]) #axin.plot(time,f1,linestyles[3]) plt.hold(False) axin.set_xlim(500, 520) ya = 0.0 yb = 4.0 Npoints = 4 points = np.linspace(ya,yb,Npoints) axin.set_ylim(ya, yb) axin.set_xticks([]) axin.set_yticks(points) mark_inset(ax, axin, loc1=3, loc2=4, fc="none", ec="0.5") write_to_file(ofile,Title,Xlabel,Ylabel,pltname,legends,linestyles,[time],[MSD,f]) print "#################################################################" print "# Diffusion estimate f1 : D = %.10f " % (d_mean_actual) print "# Diffusion estimate f2 : D = %.10f " % (d_mean_initpart) print "# Diffusion estimate f3 : D = %.10f " % (d_mean_firstpart) print "# Diffusion estimate f4 : D = %.10f " % (d_mean_lastpart) plt.figure() # Figure 3 Title = 'Time evolution of the local diffusion constant. $ D=(msd/6dt) $' legends = ['$D(t)$']; linestyles = ['-y'] pltname = 'Diffusion_bulkwater' Ylabel = 'displacement $ [ %g m^2/s]$' % factor plt.hold(True) plt.plot(time,D_local,linestyles[0]) plt.hold(False) plt.legend(legends,loc='upper right') plt.title(Title) plt.xlabel(Xlabel) plt.ylabel(Ylabel) write_to_file(ofile,Title,Xlabel,Ylabel,pltname,legends,linestyles,[time],[D_local]) plt.show()
ax.plot(t2, np2, c='k', lineStyle='--', label='$\epsilon_p=0.06$') ax.plot(t3, np3, c='k', lineStyle='-.', label='$\epsilon_p=0.12$') ax.plot(t4, np4, c='k', lineStyle=':', label='$\epsilon_p=0.18$') ax.plot(t5, np5, c='k', lineStyle=(0, (5, 5)), label='$\epsilon_p=0.24$') ip = InsetPosition(ax, [0.2, 0.2, 0.5, 0.45]) ax2 = plt.axes([0, 0, 1, 1]) ax2.set_axes_locator(ip) ax2.plot(t1[t1 >= 0.6], np1[t1 >= 0.6], c='k', lineStyle='-') ax2.plot(t2[t2 >= 0.6], np2[t2 >= 0.6], c='k', lineStyle='--') ax2.plot(t3[t3 >= 0.6], np3[t3 >= 0.6], c='k', lineStyle='-.') ax2.plot(t4[t4 >= 0.6], np4[t4 >= 0.6], c='k', lineStyle=':') ax2.plot(t5[t5 >= 0.6], np5[t5 >= 0.6], c='k', lineStyle=(0, (5, 5))) # inset plot # mark_inset(ax, ax2, loc1=1, loc2=3, fc="none", ec='r', lw='0.5') #ax2.plot #---------------------------axis control------------------------# ax.set_xlabel("$t\ (s)$") ax.set_ylabel("Particle number") #ax[0,0].set_xlim(0,0.6) ax2.set_xlim(0.6, 1.0) ax2.axes.get_xaxis().set_visible(False) ax2.axes.get_yaxis().set_visible(False) #ax.set_ylim(0.,0.8) #majorLocator = MultipleLocator(1) #majorFormatter = FormatStrFormatter('%d')