def spk_plot_pS(filepath, deltaT, datapath, sampling_rate=25000, str_leg='Data'): """Plots the avalanche size distribution for a single hdf5 dataset, and a single deltaT Args: filepath (str): Path to the .hdf5 dataset deltaT (int): Binsize to use, *in timesteps* datatype (str): 'coarse', 'sub' or 'both' (compares both sampling types) str_leg (str, optional): plot legend threshold (int, optional): Threshold in standard deviations of the signal (for coarse) bw_filter (bool, optional): Toggles butterworth filtering (for coarse) timesteps (None, optional): Length of the dataset in timesteps channels (None, optional): Number of channels in the dataset """ file = h5py.File(filepath, 'r') data_spk = file[datapath][:] #Loads and thresholds data data_th = avalanche.analyze_sim_raw(filepath, threshold, datatype, bw_filter, timesteps, channels) #Bins data data_binned = avalanche.bin_data(data=data_th, binsize=deltaT) #Gets S and plots it S = avalanche.get_S(data_binned) plot.pS(S, label=str_leg)
def sim_plot_pS(filepath, deltaT, datatype, str_leg='Data', threshold=3, bw_filter=True, timesteps=None, channels=None, save_fig=None, show_error=True, color='k', lineType='-', zorder=2): """Plots the avalanche size distribution for a single hdf5 dataset, and a single deltaT. If [filepath] is a list, averages over datasets. Args: filepath (str): Path to the .hdf5 dataset deltaT (int): Binsize to use, *in timesteps* datatype (str): 'coarse', 'sub' str_leg (str, optional): plot legend threshold (int, optional): Threshold in standard deviations of the signal (for coarse) bw_filter (bool, optional): Toggles butterworth filtering (for coarse) timesteps (None, optional): Length of the dataset in timesteps channels (None, optional): Number of channels in the dataset color (str, optional): plot color """ if type(filepath) is not list: filepath = [filepath] nreps = len(filepath) S_list = [] for filepath_file in filepath: #Loads and thresholds data data_th = avalanche.analyze_sim_raw(filepath_file, threshold, datatype, bw_filter, timesteps, channels) #Bins data data_binned = avalanche.bin_data(data=data_th, binsize=deltaT) #Gets S and plots it S_list.append(avalanche.get_S(data_binned)) plot.pS_mean(S_list, label=str_leg, lineType=lineType, color=color, show_error=show_error, zorder=zorder) #Sets up figure fig = plt.gcf() ax = plt.gca() ax.set_xlim([1, 500]) ax.set_ylim([1e-6, 1]) if save_fig is not None: #Saves figure png and pickled data fig.savefig(save_fig + '.pdf', bbox_inches="tight") with open(save_fig + '.pkl', 'wb') as file: pickle.dump(fig, file)
def save_plot(data_dir, filename, threshold, datatype, reps, binsize, bw_filter): #Save location if bw_filter: fig_dir = data_dir + 'plot_filtered/' else: fig_dir = data_dir + 'plot_unfiltered/' #Plots results plt.figure() plt.title(filename) plt.xlabel('S') plt.ylabel('p(S)') plt.yscale('log') plt.xscale('log') plt.xlim(1, 1e3) plt.ylim(1e-5, 1) X = np.arange(5, 64) Y = np.power(X, -1.5) Y = 5 * Y / np.sum(Y) plt.plot(X, Y, linestyle='--', color='black', label=r'$p(S)~S^{-1.5}$') #Runs analysis for all binsizes for bs in binsize: print(filename + ' ,running for b = {}'.format(bs)) S_list = [] for rep in range(reps): #Creates filepath filepath = data_dir + filename + '_r{:02d}.hdf5'.format(rep) #Analyzes rep data_thresholded = avalanche.analyze_sim_raw(filepath=filepath, threshold=threshold, datatype=datatype, bw_filter=bw_filter) data_binned = avalanche.bin_data(data=data_thresholded, binsize=bs) S_list.append(avalanche.get_S(data_binned)) plot.pS_mean(S_list, label='bs = {}'.format(bs)) #Creates save dir if not os.path.exists(fig_dir): os.makedirs(fig_dir) #Saves fig str_fig = fig_dir + datatype + '_pS_' + filename + '_th{}'.format( threshold) + '.png' plt.savefig(str_fig) plt.close()
def save_ps_alpha(data_dir, filename, binsize, bw_filter, reps=None, xmax=50): #Parameters timescale = 2 #Definitions if bw_filter: dir_threshold = 'thresholded_filtered/' savedata_dir = 'analyzed_filtered/' else: dir_threshold = 'thresholded_unfiltered/' savedata_dir = 'analyzed_unfiltered/' datatypes = ['coarse', 'sub'] #Loads file file_path = data_dir + dir_threshold + filename + '.hdf5' file = h5py.File(file_path, 'r') #Gets reps from file if reps is None: reps = file['coarse'].shape[0] #Analyzes both 'coarse' and 'sub' for datatype in datatypes: #Defines alpha matrix alpha_fit = np.zeros((len(binsize), reps)) #Runs the analysis for each b for k in range(len(binsize)): #Obtains S for each repetition for rep in range(reps): #Loads data, bins it and fits the avalanches data_thresholded = file[datatype][rep, :] data_binned = avalanche.bin_data(data=data_thresholded, binsize=binsize[k]) S = avalanche.get_S(data_binned) fit = powerlaw.Fit(S, discrete=True, estimate_discrete=False, xmin=1, xmax=xmax) alpha_fit[k, rep] = fit.alpha #Obtains mean and STD alpha_mean = np.mean(alpha_fit, axis=1) alpha_std = np.std(alpha_fit, axis=1) X = timescale * np.array(binsize) #Saves plot data str_savefolder = data_dir + savedata_dir + filename + '_rep{:02d}/'.format( reps) if not os.path.exists(str_savefolder): os.makedirs(str_savefolder) str_savefile = 'alpha_' + datatype + '.tsv' str_save = str_savefolder + str_savefile np.savetxt(str_save, (X, alpha_mean, alpha_std), delimiter='\t', header='b\talpha_mean\talpha_std')
def save_ps(data_dir, filename, binsize, bw_filter, reps=None): """Saves avalanche-size distribution data, using the thresholded .hdf5 files generated by save_thresholded. Args: data_dir (str): Location to search for hdf5 datasets filename (str): dataset name format binsize (list): Bin-sizes (in timesteps) to use for the avalanches bw_filter (bool): Whether to bandpass the coarse signal with a butterworth 4th order filter reps (None, optional): Number of repetitions to use """ #Definitions if bw_filter: dir_threshold = 'thresholded_filtered/' saveplot_dir = 'analyzed_filtered/' else: dir_threshold = 'thresholded_unfiltered/' saveplot_dir = 'analyzed_unfiltered/' datatypes = ['coarse', 'sub'] #Loads file file_path = data_dir + dir_threshold + filename + '.hdf5' file = h5py.File(file_path, 'r') #Gets reps from file if reps is None: reps = file['coarse'].shape[0] #Runs the analysis for each b for k in range(len(binsize)): #Analyzes both 'coarse' and 'sub' for datatype in datatypes: #Obtains S for each repetition S_list = [] for rep in range(reps): #Loads data, analyzes and bins it data_thresholded = file[datatype][rep, :] data_binned = avalanche.bin_data(data=data_thresholded, binsize=binsize[k]) S_list.append(avalanche.get_S(data_binned)) #Gets largest avalanche from the list (+1 for zero_index) S_max = int(max([Si.max() for Si in S_list]) + 1) #Obtains pS pS = np.zeros((len(S_list), S_max)) for i in range(len(S_list)): for j in range(S_max): pS[i, j] = np.sum(S_list[i] == j + 1) pS[i, :] = pS[i, :] / np.sum(pS[i, :]) #Obtains mean and STD pS_mean = np.mean(pS, axis=0) pS_std = np.std(pS, axis=0) X = np.arange(S_max) + 1 #Saves plot data str_savefolder = data_dir + saveplot_dir + filename + '_rep{:02d}/'.format( reps) if not os.path.exists(str_savefolder): os.makedirs(str_savefolder) str_savefile = 'pS_' + datatype + '_b{:02d}.tsv'.format(binsize[k]) str_save = str_savefolder + str_savefile np.savetxt(str_save, (X, pS_mean, pS_std), delimiter='\t', header='S\tpS_mean\tpS_std')
def sim_plot_deltaT(filepath, deltaT, datatype, threshold=3, S_fit_max=50, bw_filter=True, timesteps=None, channels=None, save_fig=None): """Plots p(S), m_av and fits p(S)~S^-alpha, for a list of binsizes. If [filepath] is a list, averages over datasets. Args: filepath (str): Path to the .hdf5 dataset deltaT (int): Vector of binsizes (in timesteps) datatype (str): 'coarse' or 'sub' threshold (int, optional): Threshold in standard deviations of the signal (for coarse) S_fit_max (int, optional): Limit on the power law fit range (default 50) bw_filter (bool, optional): Whether to use a Butterworth filter to bandpass the signal (for coarse) timesteps (None, optional): Number of timesteps to use (default extracts from dataset) channels (None, optional): Number of electrode channels to use (default extracts from dataset) save_fig (str, optional): Saves the figure under fig/[save_fig].png """ if type(filepath) is not list: filepath = [filepath] #Parameters timescale_ms = 2 #length of a timestep, in ms fig_dir = 'fig/' #Lets avoid list shenenigans deltaT = np.array(deltaT) nbins = deltaT.size nreps = len(filepath) S_list = [] deltaT_ms = np.array(timescale_ms * deltaT) alpha_exp = np.zeros((nreps, nbins)) m_av = np.zeros((nreps, nbins)) #Runs analysis for each dataset for j in range(nreps): S_list_rep = [] #Loads and thresholds data data_th = avalanche.analyze_sim_raw(filepath[j], threshold, datatype, bw_filter, timesteps, channels) #Bins data for each deltaT and calculates observables for i in range(nbins): data_binned = avalanche.bin_data(data=data_th, binsize=deltaT[i]) #Obtains avalanche list S S = avalanche.get_S(data_binned) #Saves S to list S_list_rep.append(S) #Calculates alpha_exp fit = powerlaw.Fit(S, discrete=True, estimate_discrete=False, xmin=1, xmax=S_fit_max) alpha_exp[j, i] = fit.alpha #Calculates m_av m_av[j, i] = fitting.m_avalanche(data_binned) #Appends S list from each repetition to pS S_list.append(S_list_rep) #Sets up subplots fig = plt.figure(constrained_layout=True) gs = fig.add_gridspec(2, 3) ax_alpha = fig.add_subplot(gs[0, 2]) ax_mav = fig.add_subplot(gs[1, 2]) ax_ps = fig.add_subplot(gs[0:2, 0:2]) #Plots pS_mean for each binsize for k in range(nbins): #Rebuild S_list for each binsize S_bin = [] for j in range(nreps): S_bin.append(S_list[j][k]) #Gets largest avalanche from the list (+1 for zero_index) S_max = int(max([Si.max() for Si in S_bin]) + 1) #Obtains pS pS = np.zeros((nreps, S_max)) for i in range(nreps): for j in range(S_max): pS[i, j] = np.sum(S_bin[i] == j) pS[i, :] = pS[i, :] / np.sum(pS[i, :]) #Obtains mean and STD pS_mean = np.mean(pS, axis=0) pS_std = np.std(pS, axis=0) pS_up = pS_mean + pS_std / 2 pS_dw = pS_mean - pS_std / 2 #Plots pS_mean str_leg = r'$\Delta$t = {:d} ms'.format(timescale_ms * deltaT[k]) plt.fill_between(range(S_max), pS_up, pS_dw, alpha=0.25, lw=0) plt.plot(range(S_max), pS_mean, label=str_leg) #Plots alpha_exp alpha_exp_mean = np.mean(alpha_exp, axis=0) alpha_exp_std = np.std(alpha_exp, axis=0) ax_alpha.errorbar(deltaT_ms, alpha_exp_mean, yerr=alpha_exp_std / 2, fmt='o-', color='k', fillstyle='full') #Plots m_av m_av_mean = np.mean(m_av, axis=0) m_av_std = np.std(m_av, axis=0) ax_mav.errorbar(deltaT_ms, m_av_mean, yerr=m_av_std / 2, fmt='o-', color='k', fillstyle='full') #Beatifies plots ax_ps.set_xlabel('S') ax_ps.set_ylabel('p(S)') ax_ps.set_xlim(1, 1e3) ax_ps.set_yscale('log') ax_ps.set_xscale('log') ax_ps.legend() ax_ps.set_title(datatype + '-sampled') ax_alpha.set_xlabel(r'$\Delta$t (ms)') ax_alpha.set_ylabel(r'$\alpha$') ax_alpha.set_xscale('log') ax_alpha.set_xticks([1, 10]) ax_alpha.set_xlim([1, 64]) ax_alpha.plot([1, 100], [1.5, 1.5], '--') ax_mav.set_xlabel(r'$\Delta$t (ms)') ax_mav.set_ylabel(r'$m_{av}$') ax_mav.set_xscale('log') ax_mav.set_xticks([1, 10]) ax_alpha.set_xlim([1, 64]) ax_mav.plot([1, 100], [1, 1], '--') # #Fix the horrible ticks # for ax in [ax_mav,ax_alpha]: # for axis in [ax.xaxis, ax.yaxis]: # formatter = matplotlib.ticker.ScalarFormatter() # formatter.set_scientific(False) # axis.set_major_formatter(formatter) if save_fig is not None: fig_path = fig_dir + '/'.join(save_fig.split('/')[:-1]) + '/' if not os.path.exists(fig_path): os.makedirs(fig_path) ax_ps.set_title(save_fig) ax_ps.set_ylabel(datatype + '-sampled p(S)') str_save = fig_dir + save_fig + '_' + datatype + '.png' fig.savefig(str_save, bbox_inches="tight")