def extract_data(self, h5_path, h5_file = None): run = lyse.Run(h5_path, no_write=True) imaging = 'scope_Pico' name = self.name frametype = self.frametype spectrum_name = name try: sig_type = run.get_result(imaging, spectrum_name+' sig_type', h5_file = h5_file) tabledata = np.array([], dtype = []) volts = run.get_result_array(imaging, spectrum_name+' volts', h5_file = h5_file) times = run.get_result_array(imaging, spectrum_name+' times', h5_file = h5_file) warning = run.get_result(imaging, spectrum_name+' warning') except: import traceback traceback.print_exc() volts, times, warning = np.array([0.,1.]),np.array([0.,1.]),'no data in shot' tabledata, sig_type = np.array([], dtype = []), 'trace' return volts, times , tabledata, sig_type, warning
def extract_data(self, h5_path, h5_file=None): run = lyse.Run(h5_path, no_write=True) try: res = run.get_result_array(self.idx[0], self.idx[1], h5_file=h5_file) except: res = None return res
def extract_data(self, h5_path, h5_file=None): run = lyse.Run(h5_path, no_write=True) try: if len(self.idx) == 1: res = run.get_global(self.idx[0], h5_file=h5_file) else: res = run.get_result(self.idx[0], self.idx[1], h5_file=h5_file) except: raise res = None return res
def extract_data(self, h5_path , h5_file = None): run = lyse.Run(h5_path, no_write=True) imaging = self.imaging cam = self.cam try: from uncertainties import ufloat N = ufloat(*run.get_results(imaging, cam+'_Natoms', cam+'_Natoms_err', h5_file = h5_file)) Nx = ufloat(*run.get_results(imaging, cam+'_Nx', cam+'_Nx_err', h5_file = h5_file)) Ny = ufloat(*run.get_results(imaging, cam+'_Ny', cam+'_Ny_err', h5_file = h5_file)) sx = ufloat(*run.get_results(imaging, cam+'_sx', cam+'_sx_err', h5_file = h5_file)) sy = ufloat(*run.get_results(imaging, cam+'_sy', cam+'_sy_err', h5_file = h5_file)) cx = ufloat(*run.get_results(imaging, cam+'_cx', cam+'_cx_err', h5_file = h5_file)) cy = ufloat(*run.get_results(imaging, cam+'_cy', cam+'_cy_err', h5_file = h5_file)) axesx, axesy = run.get_results(imaging, cam+'_axesx', cam+'_axesy') tabledata = np.array([ (axesx,'{:.1ueS}'.format(Nx),'{:.1uS}'.format(sx),'{:.1uS}'.format(cx)), (axesy, '{:.1ueS}'.format(Ny),'{:.1uS}'.format(sy),'{:.1uS}'.format(cy)) ], dtype=[('axis',object),('N ('+'{:.1ueS}'.format(N)+')', object), ('c (mm)', object), ('s (mm)', object)]) data_img, xsum, ysum, datax_fit, datay_fit, xgrid, ygrid = run.get_result_arrays(imaging, cam+'_diff_image', cam+'_xsum', cam+'_ysum', cam+'_xfit', cam+'_yfit', cam+'_xgrid', cam+'_ygrid', h5_file = h5_file) warning = run.get_result(imaging, cam+'_warning') except: data_img, xsum, ysum, datax_fit, datay_fit, xgrid, ygrid, tabledata, warning = np.zeros((2,2)), np.arange(2), np.arange(2), np.arange(2), np.arange(2), np.arange(2), np.arange(2),np.array([['no_data_x'],['no_data_y']]), 'no data in shot' return data_img, xsum, ysum, datax_fit, datay_fit, xgrid, ygrid, tabledata, warning
def extract_data(self, h5_path, h5_file = None): run = lyse.Run(h5_path, no_write=True) imaging = 'cavity_spectrum' name = self.name frametype = self.frametype spectrum_name = name+' '+frametype try: f0 = run.get_result(imaging, spectrum_name+' f0', h5_file = h5_file) f1 = run.get_result(imaging, spectrum_name+' f1', h5_file = h5_file) duration = run.get_result(imaging, spectrum_name+' duration', h5_file = h5_file) kappa = run.get_result(imaging, spectrum_name+' kappa', h5_file = h5_file) omega0 = run.get_result(imaging, spectrum_name+' omega0', h5_file = h5_file) A = run.get_result(imaging, spectrum_name+' A', h5_file = h5_file) offset = run.get_result(imaging, spectrum_name+' offset', h5_file = h5_file) n_photons_total = run.get_result(imaging, spectrum_name+' n_photons_total', h5_file = h5_file) n_photons = run.get_result_array(imaging, spectrum_name+' n_photons', h5_file = h5_file) freqs = run.get_result_array(imaging, spectrum_name+' freqs', h5_file = h5_file) tabledata = np.array([ ('{:.0f}'.format(n_photons_total),f'{omega0/2/np.pi:.3f}',f'{(kappa/2/np.pi):.3f}') ], dtype = [('N photons', object), ('omega0/2/pi (MHz)', object), ('kappa/2/pi (MHz)', object)]) warning = run.get_result(imaging, spectrum_name+' warning') except: import traceback traceback.print_exc() freqs, n_photons, omega0, kappa, A, offset, f0, f1, duration,tabledata, warning = np.array([0.,1.]), np.array([0.,1.]), 0., 0., 0., 0.,0., 1, 1,np.arange(2,dtype = 'float64'), 'no data in shot' return freqs, n_photons, omega0, kappa, A, offset, f0, f1, duration, tabledata , warning
profile = cProfile.Profile() profile.enable() fm = lyse.figure_manager h5_paths = lyse.h5_paths() if lyse.spinning_top: # If so, use the filepath of the current shot h5_path = lyse.path else: # If not, get the filepath of the last shot of the lyse DataFrame h5_path = lyse.h5_paths().iloc[-1] if len(h5_paths): last_globals = run = lyse.Run(h5_paths.iloc[-1]).get_globals() if not hasattr(fm, 'ap'): fm.ap = AnalysisPlotPanel(h5_paths) # Imaging Methods imagings = ['fluo_imaging', 'absorption_imaging'] cams = { 'fluo_imaging': ['Cam_fluorescence', 'Cam_fluorescence_side'], 'absorption_imaging': ['Cam_absorption'] } imaging = 'fluo_imaging' for cam in cams[imaging]: plot_name = imaging + ' ' + cam
################################################################# # Load h5 ################################################################# # singleshot_data = data(path) # Is this script being run from within an interactive lyse session? if lyse.spinning_top: # If so, use the filepath of the current shot h5_path = lyse.path else: # If not, get the filepath of the last shot of the lyse DataFrame df = lyse.data() h5_path = df.filepath.iloc[-1] # Instantiate a lyse.Run object for this shot run = lyse.Run(h5_path) debug = False #run_globals['debug_abs_imaging'] use_matplotlib = False ################################################################# # Physics constants ################################################################# hbar = 1.0545718e-34 #J.s c = 299792458 #m.s-1 D2_frequency = 446.799677e12 #Hz D2_wavelength = 670.977338e-9 #m D2_linewidth = 36.898e6 #s-1 D2_Isat = 2.54e-3 #W.cm-2 m6Li = 9.988341e-27 #kg kB = 1.38064852e-23 #m2.kg.s-1.K-1
P = np.dot(BW, B.T) # The RHS of the least squares equation: orig_projs = np.dot(BW, a.T) # Solve for x: x = np.linalg.solve(P, orig_projs) # Reconstruct the target image recon = np.dot(x.T, B) return recon.reshape(ny, nx) run = lyse.Run(lyse.path) dataset = lyse.data(lyse.path) try: lyse.routine_storage.refs except: lyse.routine_storage.refs = None lyse.routine_storage.dark_frames = None with h5py.File(lyse.path) as h5file: for orientation, images in h5file["images"].iteritems(): if orientation == "bottom": for image_type, frameset in images.iteritems(): if image_type.startswith("absorption"): element = image_type.split("_")[1] isat_name = "_".join(
import lyse import numpy as np from fake_result import fake_result df = lyse.data() # Your analysis on the lyse DataFrame goes here if len(df): ix = df.iloc[-1].name[0] subdf = df.loc[ix] your_result = fake_result(subdf.x.mean()) your_condition = len(subdf) > 3 # Save sequence analysis result in latest run run = lyse.Run(h5_path=df.filepath.iloc[-1]) run.save_result(name='y', value=your_result if your_condition else np.nan)
def foo(shot_context, t, arg): print(f"hello, {arg}!") import lyse run = lyse.Run(shot_context.h5_file) run.save_result('x', 7)
interpolation='None', aspect='equal', cmap='jet') plt.colorbar(im4) OD_ROI = naive_OD[ymin:ymax, xmin:xmax] print('OD_ROI shape') print(OD_ROI.shape) ax5 = plt.subplot(235) im5 = ax5.imshow(OD_ROI, vmin=-0.1, vmax=1.5, interpolation='None', aspect='equal', cmap='jet') plt.colorbar(im5) run_instance = lyse.Run(lyse.path) print(lyse.path) sigma0 = (3 / 2 / np.pi) * 780e-9**2 atom_number = np.nansum(OD_ROI * (5.6e-6 / 6.0)**2 / sigma0) # x = np.array([dummy1,dummy2]) fitness = -atom_number # run_instance.save_result('average_counts', atom_avg) run_instance.save_result('fitness', fitness) print('Saved Cost value of ' + str(fitness))
DISABLE_AVERAGE = True # Is this script being run from within an interactive lyse session? if lyse.spinning_top: # If so, use the filepath of the current shot h5_path_and_file = lyse.path else: # If not, get the filepath of the last shot of the lyse DataFrame df = lyse.data() h5_path_and_file = df.filepath.iloc[-1] ShotId, _ = os.path.split(h5_path_and_file) # Instantiate a lyse.Run object for this shot run = lyse.Run(h5_path_and_file) # Get a dictionary of the global variables used in this shot run_globals = run.get_globals() # Extract the images 'before' and 'after' generated from camera.expose dark, bright = run.get_images('MOT_x', 'fluorescence', 'dark', 'bright') hist, bin_edges = np.histogram(bright) print(bright.min(), bright.max()) # Compute the difference of the two images, after casting them to signed integers # (otherwise negative differences wrap to 2**16 - 1 - diff) diff = bright.astype(float) - dark.astype(float)
current_grid_energy_per_n = group[('energy_spectra', 'KE_per_vortex')] energy_per_n.append(mean(current_grid_energy_per_n)) u_energy_per_n.append(sem(current_grid_energy_per_n)) current_grid_dipole_moment = group[( 'vortex_signs_classification_and_statistics', 'D')] dipole_moment.append(mean(current_grid_dipole_moment)) u_dipole_moment.append(sem(current_grid_dipole_moment)) ## If we are looking at early times, then we want to generate Fig. S1, the comparison of early-time energy spectra if i == 0: ## We make a list containing arrays with the energy spectra of each shot, for this current grid size grid_e_specs = [] for path in group['filepath']: run = lyse.Run(path, no_write=True) e_spec = run.get_result_array('energy_spectra', 'KE_per_vortex_spec') k_vec = run.get_result_array('energy_spectra', 'k_vec') grid_e_specs.append(e_spec) ## Now take that list of arrays and make it an array itself, so that we can take its average and sem across each shot at each k-vector grid_e_specs = array(grid_e_specs) grid_e_spec = mean(grid_e_specs, axis=0) u_grid_e_spec = sem(grid_e_specs, axis=0) e_specs.append(grid_e_spec) ## We're going to plot this in the loop, so that we don't have to worry about storing these values for each grid size independantly sca(spectrum_ax) col_now = next(e_spec_marker_colors) loglog(k_vec,
def plot_time_series(specify_sequence): '''Generates a figure with graphs of data vs time for a specified sequence of experiments, corresponding to a fixed grid width.''' print "Working on sequence", specify_sequence ## Get a dataframe containing only the data for the current grid sequences = [os.path.split(path)[1][0:15] for path in full_df['filepath']] df = full_df[[(sequence == specify_sequence) for sequence in sequences]] ## Throw out rejected shots df = df[df['review_vortex_locations', 'Good'] == True] grid_radius = df['vortex_beam_radius'][0] * dmd_pixel_size grid_radius_micron = grid_radius * 1e6 ## Set up worksheet for data saving worksheet = workbook.add_worksheet('%s micron grid' % grid_radius_micron) worksheet.write(0, 0, 'Time series data for %s micron grid' % grid_radius_micron, bold) for head_i, heading in enumerate(data_table_headings): worksheet.write(1, head_i, heading, bold) worksheet_spectra = workbook.add_worksheet('%s micron grid Spectra' % grid_radius_micron) worksheet_spectra.write( 0, 0, 'Kinetic energy spectra for %s micron grid' % grid_radius_micron, bold) worksheet_spectra.write(1, 0, 'Hold time:', boldshaded) worksheet_spectra.write(2, 0, 'k vector', bold) ### Set up the figure windows and axes for this grid ### fig = figure('dynamics %s' % specify_sequence, figsize=(4.75, 2.8)) ## We use gridspec to arrange the subfigures ## there are two with the same splitting, so that we can control padding better for the larger log-scale graph gs = GridSpec(5, 3, width_ratios=[2, 1, 1]) gs_log = GridSpec(5, 3, width_ratios=[2, 1, 1]) ## Create an axis for each graph class_ax = fig.add_subplot(gs[0, 0]) corr_ax = fig.add_subplot(gs[1, 0]) dm_ax = fig.add_subplot(gs[2, 0]) temp_ax = fig.add_subplot(gs[3, 0]) e_ax = fig.add_subplot(gs[4, 0]) spec_ax = fig.add_subplot(gs_log[:3, 1:3]) logN_ax = fig.add_subplot(gs_log[3:, 1]) logL_ax = fig.add_subplot(gs_log[3:, 2]) ## Set up an inset axis to place the colorbar on the energy spectrum plot in a nice position colorbar_location = [0.73, 0.8, 0.22, 0.03] col_ax = axes([0, 0, 1, 1], frameon=False) col_ip = InsetPosition(spec_ax, colorbar_location) col_ax.set_axes_locator(col_ip) ## Calculations for where to place the inset figure on the energy spectrum such that the x-axis lines up espec_x_min = 2e-2 espec_x_max = 5 espec_inset_x_min = 3.5e-2 espec_inset_x_max = 1.25 figw = log(espec_x_max) - log(espec_x_min) insetoffset = (log(espec_inset_x_min) - log(espec_x_min)) / figw insetw = (log(espec_inset_x_max) - log(espec_inset_x_min)) / figw delta_e_location = [insetoffset, .05, insetw, 0.35] delta_e_ax = axes([0, 0, 1, 1]) delta_e_ip = InsetPosition(spec_ax, delta_e_location) delta_e_ax.set_axes_locator(delta_e_ip) ## An iterator to use to cycle through colours on the energy spectra e_spec_color = iter(cm.inferno_r(np.linspace(0.1, 1, 10))) ### Create empty lists in which we can later store the average value and the uncertainty of each measurement at each hold time ## Classified vortex numbers avg_N_c = [] avg_u_N_c = [] avg_N_d = [] avg_u_N_d = [] avg_N_f = [] avg_u_N_f = [] avg_N_v = [] avg_u_N_v = [] ## Dipole moment avg_d = [] avg_u_d = [] ## Total incompressible kinetic energy per vortex avg_en = [] avg_u_en = [] ## Correlation function avg_c1 = [] avg_u_c1 = [] ## Mean nearest-neighbor vortex distance avg_mean_nearest_vortex = [] u_avg_mean_nearest_vortex = [] ## and of course, we need a time vector t_vals = [] ## Now, we group the dataframe by hold time, and for each time, add the time to t_vals, ## calculate the mean and sem of each measurement, and add them to their appropriate lists: spreadsheet_row = 0 for hold_time, group in df.groupby('vortex_spoon_wait_time'): t_vals.append(hold_time) N_v = group[('vortex_signs_classification_and_statistics', 'N_v')] avg_N_v.append(mean(N_v)) avg_u_N_v.append(sem(N_v)) ## We want the fractional populations, so before averaging, ## each absolute number of clusters has to be divided by the ## total number of vortices in that shot. N_c = group[('vortex_signs_classification_and_statistics', 'N_c')] / N_v avg_N_c.append(mean(N_c)) avg_u_N_c.append(sem(N_c)) N_d = group[('vortex_signs_classification_and_statistics', 'N_d')] / N_v avg_N_d.append(mean(N_d)) avg_u_N_d.append(sem(N_d)) N_f = group[('vortex_signs_classification_and_statistics', 'N_f')] / N_v avg_N_f.append(mean(N_f)) avg_u_N_f.append(sem(N_f)) D = group[('vortex_signs_classification_and_statistics', 'D')] avg_d.append(mean(D)) avg_u_d.append(sem(D)) eN = group[('energy_spectra', 'KE_per_vortex')] avg_en.append(mean(eN)) avg_u_en.append(sem(eN)) C_1 = group[('vortex_signs_classification_and_statistics', 'C_1')] avg_c1.append(mean(C_1)) avg_u_c1.append(sem(C_1)) mean_nearest_vortex = group[( 'vortex_signs_classification_and_statistics', 'mean_nearest_vortex')] avg_mean_nearest_vortex.append(mean(mean_nearest_vortex)) u_avg_mean_nearest_vortex.append(sem(mean_nearest_vortex)) ### Kinetic energy spectra ### ## We make a list containing arrays with the energy spectra of each shot, for this current hold time e_specs = [] for path in group['filepath']: run = lyse.Run(path, no_write=True) e_spec = run.get_result_array('energy_spectra', 'KE_per_vortex_spec') k_vec = run.get_result_array('energy_spectra', 'k_vec') e_specs.append(e_spec) ## Now take that list of arrays and make it an array itself, so that we can take its average and sem across each shot at each k-vector e_specs = array(e_specs) av_e_spec = mean(e_specs, axis=0) u_e_spec = sem(e_specs, axis=0) ## We're going to plot this in the loop, so that we don't have to worry about storing these values for each time point independantly sca(spec_ax) ## Get the colour to use in this loop from the iterator col_now = next(e_spec_color) loglog(k_vec, av_e_spec, c=col_now, label=r"$E(k)$, t = %s" % hold_time) ## We want to plot the difference from t=0.5 in the inset, so on the first loop, we will get the t=0.5 data, ## then subsequent loops will subtract this from the current time's data to get the difference. if hold_time == 0.5: initial_spec = av_e_spec delta_e_ax.plot(k_vec, zeros(shape(initial_spec)), c=col_now, label=r"$E(k)$, t = %s" % hold_time) else: delta_spec = av_e_spec - initial_spec delta_e_ax.plot(k_vec, delta_spec * 1e7, c=col_now, label=r"$E(k)$, t = %s" % hold_time) ## Add energy spectra data for this time point to the spreadsheet: for k_vec_i in range(len(k_vec)): if hold_time == 0.5: worksheet_spectra.write(k_vec_i + 3, 0, k_vec[k_vec_i]) worksheet_spectra.write(k_vec_i + 3, 2 * spreadsheet_row + 1, av_e_spec[k_vec_i], leftborder) worksheet_spectra.write(k_vec_i + 3, 2 * spreadsheet_row + 2, u_e_spec[k_vec_i], rightborder) worksheet_spectra.merge_range(1, 2 * spreadsheet_row + 1, 1, 2 * spreadsheet_row + 2, hold_time, shaded) worksheet_spectra.write(2, 2 * spreadsheet_row + 1, 'E(k)', boldleftborder) worksheet_spectra.write(2, 2 * spreadsheet_row + 2, 'sem(E(k))', boldrightborder) spreadsheet_row += 1 ##### END OF LOOP OVER TIME ##### ### Now, calculate the temperature at each hold time, based on the fraction of clusters and dipoles, and the total vortex number. beta_measured = thermometer_cdN(array(avg_N_c), array(avg_N_d), array(avg_N_v)) beta_upper_error = thermometer_cdN( array(avg_N_c) + array(avg_u_N_c), array(avg_N_d) - array(avg_u_N_d), array(avg_N_v)) beta_lower_error = thermometer_cdN( array(avg_N_c) - array(avg_u_N_c), array(avg_N_d) + array(avg_u_N_d), array(avg_N_v)) ### Now we have everything that we want to plot! ### ## First save it to the spreadsheet for time_i, hold_time in enumerate(t_vals): worksheet.write(time_i + 2, 0, hold_time) worksheet.write(time_i + 2, 1, avg_N_c[time_i]) worksheet.write(time_i + 2, 2, avg_u_N_c[time_i]) worksheet.write(time_i + 2, 3, avg_N_d[time_i]) worksheet.write(time_i + 2, 4, avg_u_N_d[time_i]) worksheet.write(time_i + 2, 5, avg_N_f[time_i]) worksheet.write(time_i + 2, 6, avg_u_N_f[time_i]) worksheet.write(time_i + 2, 7, avg_c1[time_i]) worksheet.write(time_i + 2, 8, avg_u_c1[time_i]) worksheet.write(time_i + 2, 9, avg_d[time_i]) worksheet.write(time_i + 2, 10, avg_u_d[time_i]) worksheet.write(time_i + 2, 11, beta_measured[time_i]) worksheet.write(time_i + 2, 12, beta_measured[time_i] - beta_upper_error[time_i]) worksheet.write(time_i + 2, 13, beta_lower_error[time_i] - beta_measured[time_i]) worksheet.write(time_i + 2, 14, avg_en[time_i]) worksheet.write(time_i + 2, 15, avg_u_en[time_i]) worksheet.write(time_i + 2, 16, avg_N_v[time_i]) worksheet.write(time_i + 2, 17, avg_u_N_v[time_i]) worksheet.write(time_i + 2, 18, avg_mean_nearest_vortex[time_i]) worksheet.write(time_i + 2, 19, u_avg_mean_nearest_vortex[time_i]) ## Temperature graph sca(temp_ax) temp_ax.errorbar(t_vals, beta_measured, yerr=array([ beta_measured - beta_lower_error, beta_upper_error - beta_measured ]), c='k', mfc='k', fmt="o", ms=5, mew=0, capsize=1, capthick=1, ls='-') temp_ax.axhline(y=0, c='k', ls=':', lw=0.5) temp_ax.invert_yaxis() xlim(0, 5.5) ylabel(r"$\beta$") ## Vortex number graph sca(logN_ax) logN_ax.errorbar(t_vals, avg_N_v, yerr=avg_u_N_v, c="k", fmt="o", ms=5, mew=0, capsize=1, capthick=1) logN_ax.set_xscale('log') logN_ax.set_yscale('log') ylabel("$N_v$") xlabel('Hold time (s)') ### Generate guide-to-eye lines to plot on the vortex number panel ### The values of these lines are chosen for each grid such that the lines are close to the data t_for_lines = linspace(0.4, 6, 12) ## 6.0 if specify_sequence == '20171004T121555': ## 3.5 body tn25 = 15 * t_for_lines**(-2. / 5) # 2 body tn1 = 20 * t_for_lines**(-1.) ## 11.5 elif specify_sequence == '20171006T101525': ## 3.5 body tn25 = 13 * t_for_lines**(-2. / 5) # 2 body tn1 = 30 * t_for_lines**(-1.) ##4.2 elif specify_sequence == '20171004T093812': ## 3.5 body tn25 = 11 * t_for_lines**(-2. / 5) # 2 body tn1 = 15 * t_for_lines**(-1.) ## 9.7 elif specify_sequence == '20171004T144649': ## 3.5 body tn25 = 13 * t_for_lines**(-2. / 5) # 2 body tn1 = 25 * t_for_lines**(-1.) ## 7.9 else: ## 3.5 body tn25 = 14 * t_for_lines**(-2. / 5) # 2 body tn1 = 25 * t_for_lines**(-1.) loglog(t_for_lines, tn25, c='k', lw=0.5, ls='-', zorder=-1) loglog(t_for_lines, tn1, c='k', lw=0.5, ls=':', zorder=-1) xlim(0.4, 6) ylim(3, 25) ## Mean distance graph sca(logL_ax) logL_ax.errorbar(t_vals, avg_mean_nearest_vortex, yerr=u_avg_mean_nearest_vortex, c="k", fmt="o", ms=5, mew=0, capsize=1, capthick=1) logL_ax.set_xscale('log') logL_ax.set_yscale('log') ylabel("$l_v/R_\perp$") xlabel('Hold time (s)') ### Generate guide-to-eye lines to plot on the vortex spacing panel ### The values of these lines are chosen for each grid such that the lines are close to the data ## 6.0 if specify_sequence == '20171004T121555': t12 = 0.22 * t_for_lines**(0.5) t15 = 0.23 * t_for_lines**(1. / 5) ## 11.5 elif specify_sequence == '20171006T101525': t12 = 0.22 * t_for_lines**(0.5) t15 = 0.26 * t_for_lines**(1. / 5) ## 4.2 elif specify_sequence == '20171004T093812': t12 = 0.23 * t_for_lines**(0.5) t15 = 0.27 * t_for_lines**(1. / 5) ## 9.7 elif specify_sequence == '20171004T144649': t12 = 0.22 * t_for_lines**(0.5) t15 = 0.26 * t_for_lines**(1. / 5) ##7.9 else: t12 = 0.2 * t_for_lines**(0.5) t15 = 0.25 * t_for_lines**(1. / 5) loglog(t_for_lines, t12, c='k', lw=0.5, ls=':', label=r'$t^{1/2}$', zorder=-1) loglog(t_for_lines, t15, c='k', lw=0.5, ls='-', label=r'$t^{1/5}$', zorder=-1) xlim(0.4, 6) ylim(0.18, 0.55) ## Classified populations graph sca(class_ax) class_ax.errorbar(t_vals, avg_N_f, yerr=avg_u_N_f, c=colour_free, mec=colour_free, mfc=colour_free, fmt="o", ms=5, mew=0, capsize=1, capthick=1, ls='-', label="Free vortices") class_ax.errorbar(t_vals, avg_N_d, yerr=avg_u_N_d, c=colour_dipole, mec=colour_dipole, mfc=colour_dipole, fmt="o", ms=5, mew=0, capsize=1, capthick=1, ls='-', label="Dipole vortices") class_ax.errorbar(t_vals, avg_N_c, yerr=avg_u_N_c, c=colour_cluster, mec=colour_cluster, mfc=colour_cluster, fmt="o", ms=5, mew=0, capsize=1, capthick=1, ls='-', label="Clustered vortices") ylabel("$p_i$") xlim(0, 5.5) ## Add a legend - this is done manually so that we can squash it down to the smallest possible size leg_cluster = mlines.Line2D([], [], color=colour_cluster, marker='o', ms=5, mew=0, ls='-', label='$p_c$') leg_dipole = mlines.Line2D([], [], color=colour_dipole, marker='o', ms=5, mew=0, ls='-', label='$p_d$') leg_free = mlines.Line2D([], [], color=colour_free, marker='o', ms=5, mew=0, ls='-', label='$p_f$') legend(handles=[leg_cluster, leg_dipole, leg_free], bbox_to_anchor=(0.52, 0.99), ncol=3, borderpad=0, borderaxespad=0, handletextpad=0.2, columnspacing=0.5, handlelength=1, frameon=False, handler_map={ leg_cluster: HandlerLine2D(numpoints=1, marker_pad=0), leg_dipole: HandlerLine2D(numpoints=1, marker_pad=0), leg_free: HandlerLine2D(numpoints=1, marker_pad=0) }) ## Total incompressible kinetic energy graph sca(e_ax) ylabel(r"$E_k/N_v$") e_ax.errorbar(t_vals, avg_en, yerr=avg_u_en, c="k", fmt="o", ls='-', ms=5, mew=0, capsize=1, capthick=1) xlim(0, 5.5) ## Dipole moment graph sca(dm_ax) ylabel('$d/R_\perp$') errorbar(t_vals, avg_d, yerr=avg_u_d, c="k", fmt="o", ls='-', ms=5, mew=0, capsize=1, capthick=1) xlim(0, 5.5) ## Correlation function graph sca(corr_ax) corr_ax.axhline(y=0, c='k', ls=':', lw=0.5) ylabel(r"$C_1$") errorbar(t_vals, avg_c1, yerr=avg_u_c1, c="k", fmt="o", label="$C_1$", ls='-', ms=5, mew=0, capsize=1, capthick=1) xlim(0, 5.5) #### Done plotting the data, now tidy up the figure formatting #### ## Turn off tick labels on the x-axis of the stacked graphs class_ax.xaxis.set_ticklabels([]) temp_ax.xaxis.set_ticklabels([]) corr_ax.xaxis.set_ticklabels([]) dm_ax.xaxis.set_ticklabels([]) class_ax.tick_params(axis='x', which='minor', bottom='off', top="off") temp_ax.tick_params(axis='x', which='minor', bottom='off', top="off") corr_ax.tick_params(axis='x', which='minor', bottom='off', top="off") dm_ax.tick_params(axis='x', which='minor', bottom='off', top="off") e_ax.tick_params(axis='x', which='minor', bottom='off', top="off") ## label positioning common values figlabelx = -0.19 figlabely = 0.68 labelx = -0.15 labely = -0.38 ## Fix classification graph formatting sca(class_ax) ## Add the label class_ax.yaxis.set_label_coords(labelx, 0.5) class_ax.xaxis.set_label_coords(0.5, labely) class_ax.set_title('A', fontdict=blackfont, x=figlabelx, y=figlabely) ## Set the y-axis limits and tick marks depending on the grid (values chosen to best display data and provide sensible tick marks) ## 6.0 if specify_sequence == '20171004T121555': yticks([0.2, 0.4, 0.6]) ylim(0, 0.8) ## 11.5 elif specify_sequence == '20171006T101525': yticks([0.2, 0.4, 0.6]) ylim(0, 0.8) ## 4.2 elif specify_sequence == '20171004T093812': yticks([0.2, 0.4, 0.6]) ylim(0, 0.8) ## 9.7 elif specify_sequence == '20171004T144649': yticks([0.2, 0.4, 0.6]) ylim(0, 0.8) ## 7.9 else: yticks([0.2, 0.4, 0.6]) ylim(0, 0.8) ## Fix correlation function graph formatting sca(corr_ax) ## Add the label corr_ax.yaxis.set_label_coords(labelx, 0.5) corr_ax.xaxis.set_label_coords(0.5, labely) corr_ax.set_title('B', fontdict=blackfont, x=figlabelx, y=figlabely) # since this graph has another on top of it, don't plot the top border, it will rely on the bottom border of the next graph up corr_ax.spines["top"].set_visible(False) ## Set the y-axis limits and tick marks depending on the grid (values chosen to best display data and provide sensible tick marks) ## 9.7 if specify_sequence == '20171004T144649': yticks([0, 0.2, 0.4]) ## 7.9 elif specify_sequence == '20171005T090729': yticks([-0.2, 0, 0.2, 0.4]) ## 11.5 elif specify_sequence == '20171006T101525': yticks([0.1, 0.3, 0.5]) ## 4.2 elif specify_sequence == '20171004T093812': yticks([-0.6, -0.4, -0.2, 0, 0.2]) ## 6.0 else: ylim(-0.3, 0.35) yticks([-0.2, 0, 0.2]) ## Fix dipole moment graph formatting sca(dm_ax) ## Add the label dm_ax.yaxis.set_label_coords(labelx, 0.5) dm_ax.xaxis.set_label_coords(0.5, labely) dm_ax.set_title('C', fontdict=blackfont, x=figlabelx, y=figlabely) # since this graph has another on top of it, don't plot the top border, it will rely on the bottom border of the next graph up dm_ax.spines["top"].set_visible(False) ## Set the y-axis limits and tick marks depending on the grid (values chosen to best display data and provide sensible tick marks) # 6.0 if specify_sequence == '20171004T121555': yticks([0.1, 0.2, 0.3]) ylim(0.05, 0.35) ## 11.5 elif specify_sequence == '20171006T101525': ylim(0.18, 0.38) yticks([0.2, 0.25, 0.3, 0.35]) # 4.2 elif specify_sequence == '20171004T093812': yticks([0.1, 0.2, 0.3]) ## 9.7 elif specify_sequence == '20171004T144649': yticks([0.22, 0.26, 0.3]) # 7.9 else: yticks([0.15, 0.2, 0.25, 0.3]) ## Fix temperature graph formatting sca(temp_ax) ## Add the label temp_ax.yaxis.set_label_coords(labelx, 0.5) temp_ax.xaxis.set_label_coords(0.5, labely) temp_ax.set_title('D', fontdict=blackfont, x=figlabelx, y=figlabely) # since this graph has another on top of it, don't plot the top border, it will rely on the bottom border of the next graph up temp_ax.spines["top"].set_visible(False) ## Set the y-axis limits and tick marks depending on the grid (values chosen to best display data and provide sensible tick marks) # 7.9 micron if specify_sequence == '20171005T090729': yticks([0, -0.2, -0.4, -0.6]) # 11.5 micron elif specify_sequence == '20171006T101525': ylim(-0.18, -0.78) yticks([-0.3, -0.5, -0.7]) # 4.2 micron elif specify_sequence == '20171004T093812': yticks([0.2, 0, -0.2, -0.4, -0.6]) ylim(0.4, -0.7) # 9.7 micron elif specify_sequence == '20171004T144649': ylim(-0.1, -0.75) yticks([-0.2, -0.4, -0.6]) # 6.0 micron else: ylim(0.2, -0.65) yticks([0.1, -0.1, -0.3, -0.5]) ## Fix energy graph formatting sca(e_ax) ## Add the label e_ax.yaxis.set_label_coords(labelx, 0.5) e_ax.xaxis.set_label_coords(0.5, labely) e_ax.set_title('E', fontdict=blackfont, x=figlabelx, y=figlabely) # since this graph has another on top of it, don't plot the top border, it will rely on the bottom border of the next graph up e_ax.spines["top"].set_visible(False) # also set the x-label for this graph, since it's on the bottom of the stack xlabel("Hold time (s)") ## Set the y-axis limits and tick marks depending on the grid (values chosen to best display data and provide sensible tick marks) ## 6.0 if specify_sequence == '20171004T121555': ylim(2.25, 3.35) yticks([2.4, 2.6, 2.8, 3, 3.2]) ## 7.9 elif specify_sequence == '20171005T090729': yticks([2.8, 3.0, 3.2]) ## 4.2 elif specify_sequence == '20171004T093812': yticks([2.4, 2.8, 3.2]) ## 11.5 elif specify_sequence == '20171006T101525': yticks([3.0, 3.2, 3.4, 3.6]) ## 9.7 else: yticks([3, 3.2, 3.4]) #### Now fix the spines on the stacked left-hand graphs spine_left_value = -0.8 class_ax.spines['top'].set_bounds(spine_left_value, class_ax.viewLim.intervalx[1]) class_ax.spines['bottom'].set_bounds(spine_left_value, class_ax.viewLim.intervalx[1]) corr_ax.spines['bottom'].set_bounds(spine_left_value, corr_ax.viewLim.intervalx[1]) dm_ax.spines['bottom'].set_bounds(spine_left_value, dm_ax.viewLim.intervalx[1]) temp_ax.spines['bottom'].set_bounds(spine_left_value, temp_ax.viewLim.intervalx[1]) e_ax.spines['bottom'].set_bounds(spine_left_value, e_ax.viewLim.intervalx[1]) ## Fix energy spectrum graph formatting sca(spec_ax) ylabel(r'$E(k)/N_v$') xlabel(r'$k\xi$') ## Add vertical lines: ## Note, k_vec is in units of xi # k*xi = 1 plt.axvline(x=1, c='0.5', ls=':', zorder=-3) # system size k_sys = xi * 2 * pi / (circ_radius * pixel_size * 2) plt.axvline(x=k_sys, c='0.5', ls='-', zorder=-3) # grid size k_grid_radius = xi * pi / grid_radius plt.axvline(x=k_grid_radius, c='0.5', ls='--', zorder=-3) ## Generate guides to the eye at power-law scalings minus1 = 2e-7 * k_vec**(-1) minus3 = 2e-7 * k_vec**(-3) minus53 = 1.55e-7 * k_vec**(-5. / 3) plt.loglog(k_vec, minus1, c='k', ls='-', lw=0.5, zorder=-3) plt.loglog(k_vec, minus3, c='k', ls=':', lw=0.5, zorder=-3) plt.loglog(k_vec, minus53, c='k', ls='--', lw=0.5, zorder=-3) ## Generate a temporary figure environment for using to generate a colorbar for the energy spectra. fakefig = figure('Colorbar') cbar_show = imshow(array([[0, 5]]), cmap="inferno_r") ## Go back to the spectrum axis (creating the figure above will have changed the current axis) and create the colorbar, based on the above imshow sca(spec_ax) cb = colorbar(cbar_show, cax=col_ax, ticks=[0, 5], orientation="horizontal") cb.outline.set_linewidth(0.5) cb.ax.set_xticklabels(cb.ax.get_xticklabels(), fontsize=5, y=1) plt.text(colorbar_location[0] + 0.5 * colorbar_location[2], colorbar_location[1] + 2 * colorbar_location[3], "Hold time (s)", fontsize=5, ha='center', transform=spec_ax.transAxes) ## Now format the figure itself xlim(espec_x_min, espec_x_max) ylim(1e-9, 4e-6) yticks([1e-8, 1e-7, 1e-6]) spec_ax.yaxis.set_label_coords(-0.1, 0.5) spec_ax.xaxis.set_label_coords(0.5, -0.1) spec_ax.set_title('F', fontdict=blackfont, x=-0.14, y=0.88) spec_ax.tick_params(axis='y', direction='in', pad=1) spec_ax.tick_params(axis='x', direction='in', pad=1.5) ## Fix vortex number graph formatting sca(logN_ax) logN_ax.yaxis.set_label_coords(-0.22, 0.5) logN_ax.xaxis.set_label_coords(0.5, -0.24) logN_ax.set_title('G', fontdict=blackfont, x=-0.32, y=0.8) logN_ax.xaxis.set_major_formatter(ScalarFormatter()) logN_ax.yaxis.set_major_formatter(ScalarFormatter()) yticks([4, 6, 10, 20]) xticks([0.5, 1, 2, 5]) ## Fix vortex spacing graph formatting sca(logL_ax) logL_ax.yaxis.set_label_coords(-0.22, 0.5) logL_ax.xaxis.set_label_coords(0.5, -0.24) logL_ax.set_title('H', fontdict=blackfont, x=-0.32, y=0.8) logL_ax.xaxis.set_major_formatter(ScalarFormatter()) logL_ax.yaxis.set_major_formatter(ScalarFormatter()) yticks([0.2, 0.3, 0.4, 0.5]) xticks([0.5, 1, 2, 5]) ## Fix the inset in the energy spectrum graph's formatting sca(delta_e_ax) title(r'$\Delta E(k)/N_v \times 10^7$', fontdict=tinyfont, x=0.2, y=0.9) xlim(espec_inset_x_min, espec_inset_x_max) delta_e_ax.set_xscale("log", nonposx='clip') locator_params(axis='y', nbins=4) delta_e_ax.tick_params(axis='both', length=2) delta_e_ax.tick_params(axis='x', which='minor', length=1) ## Make everything a bit smaller for this inset! for label in (delta_e_ax.get_xticklabels() + delta_e_ax.get_yticklabels()): label.set_fontsize(tinyfont['size']) [i.set_linewidth(0.5) for i in delta_e_ax.spines.itervalues()] delta_e_ax.xaxis.set_major_formatter(NullFormatter()) delta_e_ax.patch.set_alpha(0) delta_e_ax.yaxis.offsetText.set_fontsize(tinyfont['size']) delta_e_ax.tick_params(axis='y', direction='in', pad=1) ## Finally, adjust the spacing and padding on the GridSpecs to make the figure look right gs.update(left=0.085, right=0.85, top=0.995, bottom=0.1, wspace=0, hspace=0.02) gs_log.update(left=0.12, right=0.995, top=0.995, bottom=0.1, wspace=0.35, hspace=1.5) ## Make sure we've got the correct figure, before saving the pdf figure('dynamics %s' % specify_sequence) savefig(os.path.join(results_path, 'individual_run_%s.pdf' % int(grid_radius * 1e6)), transparent=True)
''' A simple script for plotting up an overview of a shot. ''' # general import lyse as ly import h5py import numpy as np import matplotlib.pyplot as plt import matplotlib.patches as patches from mpl_toolkits.axes_grid1 import make_axes_locatable #get the images r = ly.Run(ly.path, no_write=True) with h5py.File(r.h5_path) as h5_file: run_nr = int(h5_file.attrs['run number']) Fig_Title = r.h5_path #h5_file.filename png_name1 = Fig_Title[:Fig_Title.rindex('\\') + 1] png_name1 = png_name1[:-1] png_name1 = png_name1[:png_name1.rindex('\\') + 1] png_name1 = png_name1 + "Images" png_name2 = Fig_Title[Fig_Title.rindex('\\'):] png_name2 = png_name2[:-3] + ".png" png_name = png_name1 + png_name2 Note = r.get_globals()['Summary'] Fig_Title = Fig_Title + "\n" + Note orientation = 'mako' name = 'frame'