Beispiel #1
0
def up_remove_with_to_few_ipsps(save_folder, save_file, spw_file, to_remove, reanalize = False):
    fold_mng.create_folder(save_folder)
    
    # check if this file already exists
    exists = fold_mng.file_exists(save_folder, save_file)

    if reanalize or not exists:
        # load the data        
        ispw.update_remove_with_to_few_ipsps(save_folder = save_folder, save_file = save_file, spw_file = spw_file, to_remove = to_remove)
    else:
        print 'Initiated SPWs were already saved'    
    gc.collect()      
Beispiel #2
0
def up_spws_spikes_ampl(save_folder, save_file = 'data.npz', load_spwsspike = 'SPWs_spikes.npz', load_spikefile = 'spikes_params.npz', reanalize = False):
    """ Finds which of the spikes detected is of the same amplitude as coresponding highest spike - it returns only the highest amplitude spikes"""
    
    fold_mng.create_folder(save_folder)
    
    # check if this file already exists
    exists = fold_mng.file_exists(save_folder, save_file)
    if reanalize or not exists:      
        ispw.update_SPW_spikes_ampl(load_spikefile, load_spwsspike, save_folder, save_file)  
    else:
        print 'spws were already analysed'        
    gc.collect()       
Beispiel #3
0
def up_add_missing_electrodes_SPW(save_folder, save_file, spw_file, data_file, reanalize = False, expected_min_ipsp_ampl = 30):
    fold_mng.create_folder(save_folder)
    
    # check if this file already exists
    exists = fold_mng.file_exists(save_folder, save_file)

    if reanalize or not exists:
        # load the data        
        ispw.update_add_missing_electrodes_SPW(save_folder = save_folder, save_file = save_file, spw_file = spw_file, data_file = data_file)
    else:
        print 'Initiated SPWs were already saved'    
    gc.collect()      
Beispiel #4
0
def up_expikes_params(save_folder, save_file = 'spw_data.npz', load_datafile = 'spw_data.npz', load_spikefile = 'spikefile.npz', reanalize = False):
    """ finds different parameters of the spike and returns them in ms"""
    # check if folder already exists
    fold_mng.create_folder(save_folder)
    
    # check if this file already exists
    exists = fold_mng.file_exists(save_folder, save_file)
    if reanalize or not exists:       
        ispw.update_expikes_params(load_datafile, load_spikefile, save_folder, save_file = save_file)  
    else:
        print 'spikes parameters were already calculated'
    gc.collect()
Beispiel #5
0
def equalize_number_spws(save_folder, save_file, induc_spont, load_distances, reanalize):
    fold_mng.create_folder(save_folder)
    
    # check if this file already exists
    exists = fold_mng.file_exists(save_folder, save_file)

    if reanalize or not exists:
        # load the data        
        ispw.update_equalize_number_spws(save_folder = save_folder, save_file = save_file, induc_spont = induc_spont, load_distances = load_distances)
    else:
        print 'Initiated SPWs were already saved'    
    gc.collect()      
Beispiel #6
0
def up_intraSpikes(save_folder, save_file = 'intra_spikes.npz', load_file = 'data_intra.npz', reanalize = False):
    """ finds the spikes in the intracellular data"""
    # check if folder already exists
    fold_mng.create_folder(save_folder)
    # check if this file already exists
    exists = fold_mng.file_exists(save_folder, save_file)
    if reanalize or not exists:
        # load the data
        ispw.update_intraSpikes(save_folder, save_file = save_file, load_file = load_file, pulse_len = 500)
    else:
        print 'intracellular spikes were already found previously'    
    gc.collect()    
Beispiel #7
0
def up_extraspikes(save_folder, filter_folder,  save_file = "ex_spikes", load_file = "data_dspl.npz", spikes_filter = 'filter_', reanalize = False):
    """ finding extracellular spikes in the data """
    # check if folder already exists
    fold_mng.create_folder(save_folder)
    
    # check if this file already exists
    exists = fold_mng.file_exists(save_folder, save_file)
    if reanalize or not exists:  
        ispw.update_extraspikes(data_load = load_file, filter_folder = filter_folder, save_folder = save_folder, save_file = save_file, save_filter = spikes_filter)
    else:
        print 'spikes were already found'
    gc.collect()
Beispiel #8
0
def up_datafile(filename, save_folder, save_file = 'data.npz', ext_electrodes = [1], intr_electrode = 1, reanalize = False):
    """ updates only the datafile for the given values """
    # check if folder already exists
    fold_mng.create_folder(save_folder)
    
    # check if this file already exists
    exists = fold_mng.file_exists(save_folder, save_file)
    if reanalize or not exists:
        ispw.update_datafile(filename, ext_electrodes, save_folder, data_file = save_file)
    else:
        print 'raw data file already exists'
    gc.collect()
Beispiel #9
0
def up_group_ipsps(save_folder, ipsps_groups, load_spwsipsp, load_datafile, save_file, reanalize):
    """ groups the IPSPs and assigns to them groups"""
    fold_mng.create_folder(save_folder)
    
    # check if this file already exists
    exists = fold_mng.file_exists(save_folder, save_file)
    if reanalize or not exists:
        fig_fold_name = 'SPW_IPSPs/'
        fold_mng.create_folder(save_folder + fig_fold_name)
        # load the data   
        ispw.update_ipsps_groups(save_folder, ipsps_groups, load_spwsipsp, load_datafile, save_file)
    gc.collect()
Beispiel #10
0
def up_fill_gap_between_ipsp_groups(save_folder, save_file, spw_file, data_file, reanalize = False):
    fold_mng.create_folder(save_folder)
    
    # check if this file already exists
    exists = fold_mng.file_exists(save_folder, save_file)

    if reanalize or not exists:
        # load the data        
        ispw.update_fill_gap_between_ipsp_groups(save_folder = save_folder, save_file = save_file, spw_file = spw_file, data_file = data_file)
    else:
        print 'Initiated SPWs were already saved'    
    gc.collect()  
Beispiel #11
0
def up_induc_spont_spw(save_folder, save_file = 'i_s_spws', load_distances = 'distances.npz', load_spwfile = 'spws.npz', max_init_dist = 10, reanalize = False, ext = '.pdf'):
    """ it finds which spws are initiated and which are sponteneaus"""
    fold_mng.create_folder(save_folder)
    
    # check if this file already exists
    exists = fold_mng.file_exists(save_folder, save_file)

    if reanalize or not exists:
        # load the data        
        ispw.update_induc_spont_spw(save_folder = save_folder, save_file = save_file, load_distances = load_distances, load_spwfile = load_spwfile, max_dist =max_init_dist, ext = ext)
    else:
        print 'Initiated SPWs were already saved'    
    gc.collect()       
Beispiel #12
0
def up_remove_too_small_spws(save_folder, save_file, load_datafile, load_spwsipsp, min_ampl, reanalize = False, ext = '.pdf'):
    """analyse all the ipsps and correct them"""
    # check if folder already exists
    fold_mng.create_folder(save_folder)
    
    # check if this file already exists
    exists = fold_mng.file_exists(save_folder, save_file)
    if reanalize or not exists:
        fig_fold_name = 'SPW_IPSPs/'
        fold_mng.create_folder(save_folder + fig_fold_name)
          
        ispw.update_remove_too_small_spws(load_datafile, load_spwsipsp, min_ampl, save_folder, save_file, ext)  
    gc.collect() 
Beispiel #13
0
def up_spws_ipsp_beg(save_folder, filter_folder, save_fig = 'spw_ipsp', save_file = 'save_it.npz', load_datafile = 'data.npz', load_spwsipsp = 'spws.npz', load_spwsspike = 'spw_spike.npz', reanalize = False, ext = '.pdf', expected_min_ipsp_ampl = 30):       
    """analyse the ipsps in each SPWs - finds the beginnings, and removes those which are not correct"""
    # check if folder already exists
    fold_mng.create_folder(save_folder)
    
    # check if this file already exists
    exists = fold_mng.file_exists(save_folder, save_file)
    if reanalize or not exists:
        fig_fold_name = 'SPW_IPSPs/'
        fold_mng.create_folder(save_folder + fig_fold_name)
        # load the data   (save_folder, ipsps_groups, load_spwsipsp, load_datafile, save_file)
        ispw.update_spws_ipsp_beg(load_datafile, filter_folder, load_spwsipsp, load_spwsspike, save_folder, fig_fold_name + save_fig, save_file, ext, expected_min_ipsp_ampl)  
    gc.collect()
Beispiel #14
0
def up_spws_beg(save_folder, save_fig = 'spw_ipsp', save_file = 'save_it.npz', load_datafile = 'data.npz', load_spwsipsp = 'spws.npz', load_spwsspike = 'spw_spike.npz', reanalize = False, ext = '.pdf', expected_min_ipsp_ampl= 30): 
    """analyse the beginning of each SPW - finds the beginnings - time and location"""
    # check if folder already exists
    fold_mng.create_folder(save_folder)
    
    # check if this file already exists
    exists = fold_mng.file_exists(save_folder, save_file)
    if reanalize or not exists:
        fig_fold_name = 'SPW_IPSPs/'
        fold_mng.create_folder(save_folder + fig_fold_name)
          
        ispw.update_spws_beg(load_datafile, load_spwsipsp, load_spwsspike, save_folder, fig_fold_name + save_fig, save_file, ext, expected_min_ipsp_ampl = expected_min_ipsp_ampl)  
    gc.collect()
Beispiel #15
0
def up_divide_to_groups(load_datafile, load_spwsipsp, save_folder, save_file, reanalize): 
    """analyse the beginning of each SPW - finds the beginnings - time and location"""
    # check if folder already exists
    fold_mng.create_folder(save_folder)
    
    # check if this file already exists
    exists = fold_mng.file_exists(save_folder, save_file)
    if reanalize or not exists:
        fig_fold_name = 'SPW_IPSPs/'
        fold_mng.create_folder(save_folder + fig_fold_name)
          
        ispw.divide_to_groups(load_datafile, load_spwsipsp, save_folder, save_file)  
    gc.collect()
Beispiel #16
0
def up_spws_first_max(save_folder, save_file, spws, datafile, reanalize = False):
    """ alignes spws on the first maximum within the window"""
 # check if folder already exists
    fold_mng.create_folder(save_folder)
    
    # check if this file already exists
    exists = fold_mng.file_exists(save_folder, save_file)
    if reanalize or not exists:
        fig_fold_name = 'SPW_IPSPs/'
        fold_mng.create_folder(save_folder + fig_fold_name)
          
        ispw.update_spws_first_max(save_folder, spws, datafile, save_file, window = [-1, 3])
    gc.collect()
Beispiel #17
0
def up_correct_ipsps(save_folder, save_fig = 'spw_ipsp', save_file = 'save_it.npz', load_datafile = 'data.npz', load_spwsipsp = 'spws.npz', load_spwsspike = 'spw_spike.npz', reanalize = False, ext = '.pdf'):
    """analyse all the ipsps and correct them"""
    # check if folder already exists
    fold_mng.create_folder(save_folder)
    
    # check if this file already exists
    exists = fold_mng.file_exists(save_folder, save_file)
    if reanalize or not exists:
        fig_fold_name = 'SPW_IPSPs/'
        fold_mng.create_folder(save_folder + fig_fold_name)
          
        ispw.corect_ipsps(load_datafile, load_spwsipsp, load_spwsspike, save_folder, fig_fold_name + save_fig, save_file, ext)  
    gc.collect()    
Beispiel #18
0
def up_SPW_ipsp(save_folder, filter_folder, save_file = 'spws_params.npz', load_datafile = "data_movavg.npz", load_waves = 'spws.npz', load_spikes = 'spws_potential', induced_dist = 7, reanalize = False):
    """ it finds the characteristics of each spw"""
    # check if folder already exists
    fold_mng.create_folder(save_folder)
    
    # check if this file already exists
    exists = fold_mng.file_exists(save_folder, save_file)
    if reanalize or not exists:
        # load the data        
        ispw.update_SPW_ipsp(load_datafile, filter_folder, load_waves, load_spikes, save_folder, save_file)
    else:
        print 'spws were already analysed'    
    gc.collect()
Beispiel #19
0
def up_intrafile(filename, save_folder, save_file = 'data_intra.npz', int_electrodes = [1], reanalize = False):
    """ read intracellular data"""
    # check if folder already exists
    fold_mng.create_folder(save_folder)
    
    # check if this file already exists
    exists = fold_mng.file_exists(save_folder, save_file)
    if reanalize or not exists:
        # load the data
        ispw.update_datafile(filename, int_electrodes, save_folder, data_file = save_file)
    else:
        print 'raw intracellular data was already loaded'    
    gc.collect()
Beispiel #20
0
def up_spikes_ampl(save_folder, save_file ='spikes_in_spws', load_spike_file = 'spikes.npz', reanalize = False):
    """ finds all the spikes for the given spw"""
    # check if folder already exists
    fold_mng.create_folder(save_folder)
    
    # check if this file already exists
    exists = fold_mng.file_exists(save_folder, save_file)
    if reanalize or not exists:
        # load the data   
        ispw.update_spikes_ampls(save_folder, save_file, load_spike_file)
    else:
        print 'origins of spikes were already calculated'
    gc.collect()    
Beispiel #21
0
def up_highWaves(save_folder, filter_folder, save_file = "data_movavg.npz", load_datafile = 'data.npz', reanalize = False):
    """ it subtracts moving average from the data"""
    # check if folder already exists
    fold_mng.create_folder(save_folder)
    
    # check if this file already exists
    exists = fold_mng.file_exists(save_folder, save_file)
    if reanalize or not exists:
        # load the data       
        ispw.update_highWaves(load_datafile, filter_folder, save_folder, data_file = save_file, atten_len = 25)
    else:
        print 'raw data was already moved to the baseline' 
    gc.collect()
Beispiel #22
0
def up_databas(save_folder, save_file = "data_dspl.npz", load_file = 'data.npz', reanalize = False):
    """ it downsamples the data taken from the given file and saves it in another file"""
    # check if folder already exists
    fold_mng.create_folder(save_folder)
    
    # check if this file already exists
    exists = fold_mng.file_exists(save_folder, save_file)
    if reanalize or not exists:
        # load the data
        ispw.update_databas(data_load = load_file, save_folder = save_folder, data_file = save_file)
    else:
        print 'raw data was already moved to the baseline'    
    gc.collect()
Beispiel #23
0
def up_merge_close_groups(save_folder, save_file, spw_file, data_file, reanalize = False):
    """ it merges too close groups of IPSPs, it chooses the one which is lower if there are
    two on the same electrode"""
    fold_mng.create_folder(save_folder)
    
    # check if this file already exists
    exists = fold_mng.file_exists(save_folder, save_file)

    if reanalize or not exists:
        # load the data        
        ispw.update_merge_close_groups(save_folder = save_folder, save_file = save_file, spw_file = spw_file, data_file = data_file)
    else:
        print 'Initiated SPWs were already saved'    
    gc.collect()    
Beispiel #24
0
def up_highWaves_numb(save_folder, save_file = 'spws_params.npz', load_spwsfile = 'spws_potential', reanalize = False):
    """ it finds the characteristics of each spw"""
    # check if folder already exists
    fold_mng.create_folder(save_folder)
    
    # check if this file already exists
    exists = fold_mng.file_exists(save_folder, save_file)
    if reanalize or not exists:   
        # load spike params
       
        ispw.update_highWaves_numb(load_spwsfile, save_folder, save_file)
    else:
        print 'spws were already analysed'    
    gc.collect()
Beispiel #25
0
def up_dist_SpwfromSpike(save_folder, save_file = 'spw_dist.npz', load_intrafile = 'intra_data.npz', load_spwfile = 'spw_data.npz', spikes = 'all', reanalize = False):
    """ it finds the distance intracellular spike to each spw"""
    # check if folder already exists
    fold_mng.create_folder(save_folder)
    
    # check if this file already exists
    exists = fold_mng.file_exists(save_folder, save_file)

    if reanalize or not exists:
        # load the data        
        ispw.update_dist_SPWfromSpike(save_folder = save_folder, save_file = save_file, load_intrafile = load_intrafile, load_spwfile = load_spwfile, max_dist = 15, spikes = spikes)
    else:
        print 'distances of spws to intracellular spikes were already calculated'    
    gc.collect()    
Beispiel #26
0
def up_spws(save_folder, save_file = 'spw_data.npz', load_file = 'spw_data.npz', reanalize = False):
    """ updates details of the spws"""
    # check if folder already exists
    fold_mng.create_folder(save_folder)
    
    # check if this file already exists
    exists = fold_mng.file_exists(save_folder, save_file)
    if reanalize or not exists:
        npzfile = np.load(save_folder + load_file)
        data = npzfile['data']
        fs = npzfile['fs']        
        npzfile.close()
        
        spw_idxs, spw_maxs, starts_spw, ends_spw, lengths_spw, fs_spws = ispw.update_spws(data, fs = fs, save_folder = save_folder, save_file = save_file) 
    else:
        print 'raw data was already filtered' 
    gc.collect()
Beispiel #27
0
def up_filtered(save_folder, save_file = 'spw_data.npz', load_file = "data_dspl.npz", freq = [1.5, 500.0], reanalize = False):
    """ filteres the data from the given file to given frequencies"""
    # check if folder already exists
    fold_mng.create_folder(save_folder)
    
    # check if this file already exists
    exists = fold_mng.file_exists(save_folder, save_file)
    if reanalize or not exists:
        npzfile = np.load(save_folder + load_file)
        data = npzfile['data']
        fs = npzfile['fs']        
        npzfile.close()
        
        data_filt, freq, fs_data = ispw.update_filtered(data, fs, save_folder, freq, data_file = save_file)   
    else:
        print 'raw data was already filtered' 
    gc.collect()
Beispiel #28
0
            ex_electr = range(intra, 8+intra)
            print 'intra ' + str(intra)
            update_all_plots_one_cell(filename, save_folder, ex_electr, intra, cell = all[nex][0])
    
    if sum_up_all == 1:
        names = ['max_2_', 'min_3_', 'all_', 'min_2_', 'max_1_'] # depending on max number of IPSPs used it should be added before
        # name of the file: spws_file, distances, equal_init_spont
        name_used = names[2]
        

        spike = False
        ampl_synch = True
        cum_change_var = False
        
        solutions_folder = get_save_folder() + 'solutions/'
        fold_mng.create_folder(solutions_folder)
        
        if cum_change_var:
            # gather all the cumulative change of variance and plot them on one plot
            file_name = name_used + 'cum_change_variance.npz'
            
            all_var_spont = []
            all_var_init = []
            
            for nex in range(len(all)):
                #import pdb; pdb.set_trace()
                filename, save_folder, intra  = find_folders(all[nex][0], all[nex][1], all[nex][2])
                # check if it exists:       
                exists = fold_mng.file_exists(save_folder, file_name)

                if exists:  
Beispiel #29
0
def update_all_plots_one_cell(filename, save_folder, ext_electrodes = [1, 2, 3, 4, 5, 6, 7], intr_electrode = 1, data_part = 'all', cell = 1):
    """ work on given data file"""
    ext = '.eps'
    #================files which were previously analysed =======================
    names = ['max_2_', 'min_3_', 'all_', 'min_2_', 'max_1_'] # depending on max number of IPSPs used it should be added before
     # name of the file: spws_file, distances, equal_init_spont
    name_used = names[2]
    
    spws_file = name_used + 'SPWs_ipsps_final.npz'
    distances = name_used + 'spw_dist2first.npz'
    type_of_choice = "minimum" #"take_smaller" #set_number" "minimum"
    #equal_init_spont = type_of_choice + name_used + 'induc_spont_equal.npz'
    equal_init_spont = name_used + 'induc_spont_spw.npz'
    
    raw_data = "data_bas.npz"
    intra_data = 'data_baseintra.npz'
    spike_file = 'spikes_largest.npz'
    intra_spike_file = 'intra_spikes.npz'
    all_spikes = 'spikes.npz'
    #==============================================================
    #import pdb; pdb.set_trace()
    plots_folder = 'plots/' + name_used
    print 'working on: ' +  filename
    
    #solutions_folder = 'plots/'
    delete_old = False #!!!! it will delete all the previously saved plots so be careful!
    run_all_functions = True
    
    if delete_old: # !!!!!!
        fold_mng.remove_folder(save_folder + plots_folder)
        
    win = [0, 0]
    
    if intr_electrode == 1:     
        
        plot_name_ipsps_2_dist = 'numIPSP_distance'
        save_plot_in = plots_folder+plot_name_ipsps_2_dist + '/'
        if not run_all_functions:
            """ plots relation between distance from the spike and number of ipsp groups in a SPW """
            fold_mng.create_folder(save_folder + save_plot_in)
            analyser.plot_noIpsps2distance(save_folder,save_plot_in , save_plots = plot_name_ipsps_2_dist, spw_file = spws_file, dist_file = distances, ext = ext)
        
        dist_spw2psike = 'dist_spw2spike'
        save_plot_in = plots_folder+ dist_spw2psike + '/'
        if not run_all_functions:
            """ plots relation between distance from the spike and number of ipsp groups in a SPW"""
            fold_mng.create_folder(save_folder + save_plot_in)
            analyser.plot_dist_spw2spike(save_folder, save_plot_in, save_plots = dist_spw2psike, dist_file = distances, ext = ext)

        firing_rate = name_used + 'firing_rate'
        save_plot_in = plots_folder+ firing_rate + '/'
        if not run_all_functions:
            fold_mng.create_folder(save_folder + save_plot_in)
            analyser.plot_fr_after_spike(save_folder, plot_folder = save_plot_in, 
                                      plot_file = firing_rate, intra_spikes = intra_spike_file,
                                      spike_data = spike_file , ext = ext, win = win)

        firing_rate_and_spws = name_used + 'firing_rate_and_spws'
        save_plot_in = plots_folder+ firing_rate_and_spws + '/'
        if not run_all_functions:
            fold_mng.create_folder(save_folder + save_plot_in)
            analyser.plot_fr_after_spike_and_distances_after_spike(save_folder, plot_folder = save_plot_in,  
                                      plot_file = firing_rate_and_spws, intra_spikes = intra_spike_file, dist_file = distances,
                                      spike_data = spike_file , ext = ext)

        separateSPWs = 'separate_SPWs'
        if not run_all_functions:
            analyser.plot_different_SPWs(save_folder, save_plot_in, save_plots = separateSPWs, data_file = raw_data, intra_data_file = intra_data, induc_spont = equal_init_spont, intra_spikes = intra_spike_file, ext = '.png')
        
        alignedSPWs = 'aligned_SPWs'
        highest_peak = 'highest_peak.npz'
        save_plot_in = plots_folder+ alignedSPWs + '/'
        if not run_all_functions:
            fold_mng.create_folder(save_folder + save_plot_in)
            analyser.plot_alignedSPW(save_folder, save_file = highest_peak, plot_folder = save_plot_in, save_plots = alignedSPWs, data_file = raw_data, intra_data_file = intra_data, induc_spont = equal_init_spont, intra_spikes = intra_spike_file, ext = '.png')

        
        spikePerElectrode = name_used + 'spike_per_electrode'
        hist_spike_bins = name_used + 'all_dists_hist.npz'
        save_name_max_electr = name_used + 'max_electr_origin.npz'
        save_plot_in = plots_folder+ spikePerElectrode + '/'
        if not run_all_functions: 
            fold_mng.create_folder(save_folder + save_plot_in)
            analyser.plot_spike(save_folder, save_plot_in, save_plots = spikePerElectrode, 
                            save_file = hist_spike_bins, save_name_max_electr = save_name_max_electr, 
                            spike_data = spike_file, spw_data = equal_init_spont, 
                            ext = ext, win = win)
            
        #import pdb; pdb.set_trace()
        group_per_isps_all = name_used + 'group_per_isps_all.npz'
        if not run_all_functions: # ok
            analyser.plot_spw_ipsps_no_groups_all(save_folder, save_file = group_per_isps_all, data_file = raw_data, 
                                              spw_data = equal_init_spont, ext = ext)#



        
        groups_w_firing_rate = name_used + 'groups_w_firing_rate'
        save_plot_in = plots_folder+ groups_w_firing_rate + '/'
        if not run_all_functions:
            fold_mng.create_folder(save_folder + save_plot_in)
            analyser.plot_groups_w_fr(save_folder, plot_folder = save_plot_in, 
                                      plot_file = groups_w_firing_rate, data_file = raw_data, 
                                      spw_groups = group_per_isps_all, spw_details = equal_init_spont,
                                      spike_data = all_spikes , ext = '.eps', win = win)
                                    # spikes_largest           
        
        cumulative_plot = 'cumulative_plot'
        save_plot_in = plots_folder+ cumulative_plot + '/'
        save_file = name_used + 'cum_change_variance.npz'
        if not run_all_functions:
            fold_mng.create_folder(save_folder + save_plot_in)
            #import pdb; pdb.set_trace()
            analyser.cum_distribution_funct(save_folder, save_file, plot_folder = save_plot_in, plot_file = cumulative_plot, data_file = raw_data, 
                                      spw_details = equal_init_spont,
                                      #spw_details = highest_peak,
                                      ext = '.png', win = win, cell = cell)
        
        #import pdb; pdb.set_trace() 
#
        
        plot_ampl_synch = 'ampl_synchrony'
        save_file = name_used + 'ampl_sync_dat'
        save_plot_in = plots_folder+ plot_ampl_synch + '/'
        if run_all_functions: # ok
            fold_mng.create_folder(save_folder + save_plot_in)
            analyser.plot_amplitude_vs_synchrony(save_folder, save_file, 
                                                 plot_folder = save_plot_in, 
                                                 plot_file = plot_ampl_synch, 
                                                 data_file = raw_data,
                                                 spw_details = equal_init_spont, ext = ext)