コード例 #1
0
ファイル: ConvertABF.py プロジェクト: bejar/PeaksPipeline
def convert_from_ABF_to_HDF5(experiment):
    """
    Convierte los ficheros del experimento desde ABF y los graba en un fichero HDF5
    :param experiment:
    :return:
    """

    # Asumimos que el fichero no existe todavia
    f = experiment.open_experiment_data(mode='w')

    nsig = experiment.abfsensors
    datafiles = experiment.datafiles

    for dataf in datafiles:
        # Leemos los datos del fichero ABF
        print('Reading: ', dataf, '...')
        data = AxonIO(experiment.dpath + experiment.name + '/' + dataf + '.abf')

        bl = data.read_block(lazy=False, cascade=True)
        dim = bl.segments[0].analogsignals[0].shape[0]
        matrix = np.zeros((len(nsig), dim))

        for i, j in enumerate(nsig):
            matrix[i][:] = bl.segments[0].analogsignals[j][:].magnitude

        # Los guardamos en el almacenamiento del experimento
        print('Saving: ', dataf, '...')
        experiment.save_raw_data(f, dataf, matrix.T)

        del matrix
        del bl

    datainfo.close_experiment_data(f)
コード例 #2
0
ファイル: test_axonio.py プロジェクト: msenoville/python-neo
 def test_read_protocol(self):
     for f in self.files_to_test:
         filename = self.get_filename_path(f)
         reader = AxonIO(filename=filename)
         bl = reader.read_block(lazy=True)
         if bl.annotations['abf_version']>=2.:
             reader.read_protocol()
コード例 #3
0
def convert_from_ABF_to_HDF5(experiment):
    """
    Convierte los ficheros del experimento desde ABF y los graba en un fichero HDF5
    :param experiment:
    :return:
    """

    # Asumimos que el fichero no existe todavia
    f = experiment.open_experiment_data(mode='w')

    nsig = experiment.abfsensors
    datafiles = experiment.datafiles

    for dataf in datafiles:
        # Leemos los datos del fichero ABF
        print('Reading: ', dataf, '...')
        data = AxonIO(experiment.dpath + experiment.name + '/' + dataf +
                      '.abf')

        bl = data.read_block(lazy=False)
        dim = bl.segments[0].analogsignals[0].shape[0]
        matrix = np.zeros((len(nsig), dim))

        for i, j in enumerate(nsig):
            tmpmat = bl.segments[0].analogsignals[j][:].magnitude
            matrix[i][:] = tmpmat.reshape(tmpmat.shape[0])

        # Los guardamos en el almacenamiento del experimento
        print('Saving: ', dataf, '...')
        experiment.save_raw_data(f, dataf, matrix.T)

        del matrix
        del bl

    datainfo.close_experiment_data(f)
コード例 #4
0
 def test_read_protocol(self):
     for f in self.files_to_test:
         filename = self.get_filename_path(f)
         reader = AxonIO(filename=filename)
         bl = reader.read_block(lazy=True)
         if bl.annotations['abf_version'] >= 2.:
             reader.read_protocol()
コード例 #5
0
ファイル: ChannelSlider.py プロジェクト: anzalks/Thesis-work
def exp_tracef(Injectcurr=150e-12):
    global flnme
    global exp_sampdur
    global exp_samprate
    global exp_samppoints
    global exp_trace_injend
    global exp_trace_injstart
    stim1391 = ['Cell 3 of 181016.abf', 'cell 4 of 61016.abf', 'cell 4 of 111016.abf', 'cell 4 of 131016.abf', 'Cell 4 of 181016.abf', 'cell 5 of 61016.abf', 'Cell 5 of 181016.abf']
    # flnme = 'Cell 3 of 10717.abf'
    flnme = 'cell 4 of 61016.abf'
    exp_tracefile = f'../../Raw_data/Deepanjali_data/WT step input cells/{flnme}'
    reader = AxonIO(filename=exp_tracefile)
    currno = int(Injectcurr*1e12/25+4)
    seg = reader.read_block().segments[currno] # 10 means 150pA current
    exp_trace = seg.analogsignals[0]
    exp_samprate = float(exp_trace.sampling_rate)
    exp_sampdur = float(exp_trace.t_stop) - float(exp_trace.t_start)
    exp_samppoints = int(exp_samprate*exp_sampdur)
    if flnme in stim1391:
        exp_trace_injstart = 139.1e-3
        exp_trace_injend = 639.1e-3
    else:
        exp_trace_injstart = 81.4e-3
        exp_trace_injend = 581.4e-3
    exp_trace = np.array(exp_trace).flatten()
    return exp_trace
コード例 #6
0
def convert_from_ABF_to_HDF5(experiment):
    """
    Convierte los ficheros del experimento desde ABF y los graba en un fichero HDF5
    :param experiment:
    :return:
    """

    # Asumimos que el fichero no existe todavia
    f = h5py.File(
        experiment.dpath + experiment.name + '/' + experiment.name + '.hdf5',
        'r+')

    nsig = [s for s, _ in experiment.extrasensors]

    datafiles = experiment.datafiles

    for dataf in datafiles:
        # Leemos los datos del fichero ABF
        print('Reading: ', dataf, '...')
        data = AxonIO(experiment.dpath + experiment.name + '/' + dataf +
                      '.abf')

        bl = data.read_block(lazy=False, cascade=True)
        dim = bl.segments[0].analogsignals[0].shape[0]
        matrix = np.zeros((len(nsig), dim))

        for i, j in enumerate(nsig):
            matrix[i][:] = bl.segments[0].analogsignals[j][:].magnitude

        # Los guardamos en una carpeta del fichero HDF5 para el fichero dentro de /Raw
        print('Saving: ', dataf, '...')
        dgroup = f[dataf]

        if dataf + '/RawExtra' in f:
            del f[dataf + '/RawExtra']
        dgroup.create_dataset('RawExtra',
                              matrix.T.shape,
                              dtype='f',
                              data=matrix.T,
                              compression='gzip')
        del matrix
        del bl

        f[dataf + '/RawExtra'].attrs['Sampling'] = experiment.sampling
        f[dataf + '/RawExtra'].attrs['Sensors'] = [
            s for _, s in experiment.extrasensors
        ]
        f.flush()
    f.close()
コード例 #7
0
def convert_from_ABF_to_HDF5(experiment):
    """
    Convierte los ficheros del experimento desde ABF y los graba en un fichero HDF5
    :param experiment:
    :return:
    """

    # Asumimos que el fichero no existe todavia
    f = h5py.File(experiment.dpath + experiment.name + "/" + experiment.name + ".hdf5", "r+")

    nsig = [s for s, _ in experiment.extrasensors]

    datafiles = experiment.datafiles

    for dataf in datafiles:
        # Leemos los datos del fichero ABF
        print("Reading: ", dataf, "...")
        data = AxonIO(experiment.dpath + experiment.name + "/" + dataf + ".abf")

        bl = data.read_block(lazy=False, cascade=True)
        dim = bl.segments[0].analogsignals[0].shape[0]
        matrix = np.zeros((len(nsig), dim))

        for i, j in enumerate(nsig):
            matrix[i][:] = bl.segments[0].analogsignals[j][:].magnitude

        # Los guardamos en una carpeta del fichero HDF5 para el fichero dentro de /Raw
        print("Saving: ", dataf, "...")
        dgroup = f[dataf]

        if dataf + "/RawExtra" in f:
            del f[dataf + "/RawExtra"]
        dgroup.create_dataset("RawExtra", matrix.T.shape, dtype="f", data=matrix.T, compression="gzip")
        del matrix
        del bl

        f[dataf + "/RawExtra"].attrs["Sampling"] = experiment.sampling
        f[dataf + "/RawExtra"].attrs["Sensors"] = [s for _, s in experiment.extrasensors]
        f.flush()
    f.close()
コード例 #8
0
ファイル: Channel_slider.py プロジェクト: anzalks/Thesis-work
def exp_tracef(currno=10):
    global flnme
    global exp_trace
    global exp_sampdur
    global exp_samprate
    global exp_samppoints
    global exp_trace_injend
    global exp_trace_injstart

    stim1391 = ['Cell 3 of 181016.abf', 'cell 4 of 61016.abf', 'cell 4 of 111016.abf', 'cell 4 of 131016.abf', 'Cell 4 of 181016.abf', 'cell 5 of 61016.abf', 'Cell 5 of 181016.abf']
    exp_tracefile = Exp_tracedir+flnme
    reader = AxonIO(filename=exp_tracefile)
    seg = reader.read_block().segments[currno] # 10 means 15pA current
    exp_trace = seg.analogsignals[0]
    exp_samprate = float(exp_trace.sampling_rate)
    exp_sampdur = float(exp_trace.t_stop) - float(exp_trace.t_start)
    exp_samppoints = int(exp_samprate*exp_sampdur)
    if flnme in stim1391:
        exp_trace_injstart = 139.1e-3
        exp_trace_injend = 639.1e-3
    else:
        exp_trace_injstart = 81.4e-3
        exp_trace_injend = 581.4e-3
    exp_trace = np.array(exp_trace).flatten()
コード例 #9
0
 def test_annotations(self):
     reader = AxonIO(filename=self.get_filename_path('File_axon_2.abf'))
     bl = reader.read_block()
     ev = bl.segments[0].events[0]
     assert 'comments' in ev.annotations
コード例 #10
0
from neo.io import AxonIO
import os
from allensdk.ephys.ephys_extractor import EphysSweepFeatureExtractor
from allensdk.core.cell_types_cache import CellTypesCache

filename = 'Cell 6 of 171117.abf'
seg_no = 17  #0 is -100pA, 4 is 0pA, 20 is 400pA. Now extrapolate
stim_start = 81.4e-3  #in s
stim_stop = 581.4e-3  #in s

Actualstim_start = seg_no * 2 + stim_start
Actualstim_stop = seg_no * 2 + stim_stop
Inputcurr = seg_no * 25 - 100  #in pA

reader = AxonIO(filename='Deepanjali data/WT step input cells/' + filename)
Vtrace = reader.read_block().segments[seg_no].analogsignals[0]

i = np.zeros(int((Vtrace.t_stop - Vtrace.t_start) * Vtrace.sampling_rate))
i[int(stim_start * Vtrace.sampling_rate):int(stim_stop *
                                             Vtrace.sampling_rate)] = Inputcurr
i = np.array(i)
v = np.array([float(V) for V in Vtrace])
t = np.linspace(0, float(Vtrace.t_stop - Vtrace.t_start),
                int((Vtrace.t_stop - Vtrace.t_start) * Vtrace.sampling_rate))
t = np.array(t)

sweep_ext = EphysSweepFeatureExtractor(t=t, v=v, i=i, filter=5)
sweep_ext.process_spikes()

sweep_ext.spike_feature_keys()  #Lists all the features that can be extracted
sweep_ext.spike_feature("width")  #Extracts AP width
import glob
#change directory as needed
flydir = 'C:\\Users\\rancher\\Desktop\\S328_.5stim\\'

from neo.io import AxonIO

abf_name_list = glob.glob(flydir + '*.abf')

for i in abf_name_list:
    abf_name = i.replace('.abf','')
    abf_name = abf_name.replace(flydir,'')
    localfile = flydir + abf_name + '.abf' #change file name as needed
    
    r = AxonIO(localfile)
    
    bl = r.read_block(lazy=False, cascade=True)
    
    # Get info from channels:
    l_amp = np.asarray(bl.segments[0].analogsignals[3])*60/np.pi #Left wing from Kinefly
    r_amp = np.asarray(bl.segments[0].analogsignals[4])*60/np.pi #Right wing from Kinefly
    wbf = np.asarray(bl.segments[0].analogsignals[0])*100. #wing beat frequency from wing beat analyzer
#    l_plus_r = np.asarray(bl.segments[0].analogsignals[1])*60/np.pi #from wing beat analyzer
    pattern = np.asarray(bl.segments[0].analogsignals[7])
    
    #frames = np.asarray(bl.segments[0].analogsignals[3])
    
    #amp_sum = l_amp + r_amp #use this line if we use Channel 1 l_plus_r from wing beat analyzer again
    l_plus_r = l_amp + r_amp
    amp_diff = l_amp - r_amp # Note: amp_diff is L-R
    
    fs_axon = 1.0/2000.0 #We know there are 2000 readings per second
コード例 #12
0
ファイル: test_axonio.py プロジェクト: msenoville/python-neo
 def test_annotations(self):
     reader = AxonIO(filename=self.get_filename_path('File_axon_2.abf'))
     bl = reader.read_block()
     ev = bl.segments[0].events[0]
     assert 'comments' in ev.annotations
コード例 #13
0
from tkinter.filedialog import askdirectory

Direc = '../../Raw_data/Deepanjali_data/WT step input cells/'  #Directory where all the files are stored
CurrAmp = 5  #0 is for -100pA, 1 for -75pA, and so on till 20 which is 400pA. 10 for 150pA
# flist = os.listdir(Direc)
flist = ['cell 4 of 61016.abf']

i = 0
print(os.listdir(Direc))
for filename in flist:
    i = i + 1
    print(i, end='\r')
    try:  #Try is used to skip unsupported files that may be there in the folder
        reader = AxonIO(filename=Direc + filename)
        Samprate = reader.get_signal_sampling_rate()
        seg = reader.read_block().segments[CurrAmp]
        Tdur = np.array(seg.t_stop - seg.t_start)
        plt.plot(np.linspace(0, Tdur, Samprate * Tdur),
                 seg.analogsignals[0],
                 label=f'{filename}')
        # plt.title('WT 150pA current injection for 0.5s')
        # plt.xlim([0,1])
        plt.ylim([-75, 50])
        plt.xlabel('Time (s)')
        plt.ylabel('Membrane potential (mV)')
        plt.legend()
        mng = plt.get_current_fig_manager()
        mng.resize(*mng.window.maxsize())
        plt.show()
    except:
        pass
コード例 #14
0
def binary_to_csv(filename=None):
    '''
    Writes data for given abf file into a csv format. Two .csv files will be created into csv_data folder 
    One will be meta_data, one will be time series data.
    
    These sheets are also returned as pandas data frames by this function    
    '''

    if filename is None:
        sys.exit('must specify filename and path')

    # Set up path to save csv output to
    pathtocsv = str.split(filename, '/')
    pathtocsv = "/".join(pathtocsv[:-2]) + "/csv_data/"

    #Use neo function "AxonIO" to read in the axonb binary file
    r = AxonIO(filename=filename)
    r = r.read_block()

    # for name purposes later on, remove ".abf" extension from filename
    filename = splitext(basename(filename))[0]

    # Define number of sweeps in this protocol (.abf file)
    n_sweeps = len(r.segments)
    n_channels = len(r.segments[0].analogsignals)
    # Name sweeps
    sweep_ids = []
    for i in range(0, n_sweeps):
        sweep_ids.append('sweep' + str(i + 1))

    # List the traits to hold in meta data
    meta_traits = ['fs', 'celltype', 'date']
    for i in range(0, n_channels):
        meta_traits.append('ch' + str(i + 1) + '_units')

    # create empty data frame for meta data
    meta_data = pd.DataFrame(columns=meta_traits, index=sweep_ids)

    # fill meta_data
    for i, seg in enumerate(r.segments):
        for ch in range(0, n_channels):
            meta_data['ch' + str(ch + 1) + '_units'][sweep_ids[i]] = str(
                seg.analogsignals[ch].units)[4:]
            meta_data['fs'][sweep_ids[i]] = float(
                seg.analogsignals[0].sampling_rate)
            meta_data['date'][sweep_ids[i]] = filename[-10:]
            meta_data['celltype'][sweep_ids[i]] = str.split(
                filename,
                '_')[0]  # example of using string split to get information

    # create empty data frame to hold data
    data_cols = []
    for i in range(0, n_sweeps):
        for ch in range(0, n_channels):
            data_cols.append('ch' + str(ch + 1) + '_sweep' + str(i + 1))

    # Warning about how we are handling time series
    import warnings
    #warnings.warn('If fs is same for all sweeps, hard coding time series to be the same for all sweeps within an .abf file')

    # make sure all sampling rates are the same across segments
    if len(meta_data['fs'].unique()) == 1:
        time = np.linspace(
            0,
            len(r.segments[0].analogsignals[0]) /
            float(meta_data['fs'].unique()),
            len(r.segments[0].analogsignals[0]))
    else:
        sys.exit(
            'sampling rates are different - need to figure out what to do in this case'
        )

    # initiate the data frame for data
    data = pd.DataFrame(index=time, columns=data_cols)

    # fill the data frame for data
    for s_index, seg in enumerate(r.segments):
        for ch_index, ch in enumerate(seg.analogsignals):
            data['ch' + str(ch_index + 1) + '_sweep' + str(s_index + 1)] = ch

    # Convert the data frames to .csv files
    meta_data.to_csv(pathtocsv + 'meta_data_' + str(filename) + '.csv')
    data.to_csv(pathtocsv + 'data_' + str(filename) + '.csv')
    print('saving data in csv format. Stored in csv_data folder')

    # return data frames for further processing
    return meta_data, data
コード例 #15
0
def exp_tracef(Injectcurr=150e-12):
    global flnme
    global exp_sampdur
    global exp_samprate
    global exp_samppoints
    global exp_trace_injend
    global exp_trace_injstart
    global Vrest
    global sm_diam
    global sm_len
    global Gin
    stim1391 = [
        'Cell 3 of 181016.abf', 'cell 4 of 61016.abf', 'cell 4 of 111016.abf',
        'cell 4 of 131016.abf', 'Cell 4 of 181016.abf', 'cell 5 of 61016.abf',
        'Cell 5 of 181016.abf'
    ]
    # flnme = 'Cell 3 of 10717.abf'
    flnme = 'cell 4 of 61016.abf'
    exp_tracefile = f'../../Raw_data/Deepanjali_data/WT step input cells/{flnme}'
    reader = AxonIO(filename=exp_tracefile)
    currno = int(Injectcurr * 1e12 / 25 + 4)
    seg = reader.read_block().segments[currno]  # 10 means 150pA current
    exp_trace = seg.analogsignals[0]
    exp_samprate = float(exp_trace.sampling_rate)
    exp_sampdur = float(exp_trace.t_stop) - float(exp_trace.t_start)
    exp_samppoints = int(exp_samprate * exp_sampdur)
    if flnme in stim1391:
        exp_trace_injstart = 139.1e-3
        exp_trace_injend = 639.1e-3
    else:
        exp_trace_injstart = 81.4e-3
        exp_trace_injend = 581.4e-3

    exp_trace = np.array(exp_trace).flatten() * 1e-3
    Vrest = np.mean(
        np.array(
            reader.read_block().segments[4].analogsignals[0]).flatten()) * 1e-3
    Rinp25 = np.abs(
        np.max(
            np.array(reader.read_block().segments[5].analogsignals[0]).flatten(
            )) * 1e-3 - Vrest) / 25e-12
    Rinn25 = np.abs(
        np.min(
            np.array(reader.read_block().segments[3].analogsignals[0]).flatten(
            )) * 1e-3 - Vrest) / 25e-12
    Gin = 2 / (Rinp25 + Rinn25)
    print(Gin)

    t = np.linspace(0, exp_sampdur, int(exp_sampdur * exp_samprate))
    Vtracep25 = np.array(
        reader.read_block().segments[5].analogsignals[0]).flatten() * 1e-3
    Vtracen25 = np.array(
        reader.read_block().segments[3].analogsignals[0]).flatten() * 1e-3
    str_ind = (np.abs(t - exp_trace_injend + 100e-3)).argmin()
    stp_ind = (np.abs(t - exp_trace_injend)).argmin()
    Vtracep25_choppped = Vtracep25[:stp_ind]
    Vtracen25_choppped = Vtracen25[:stp_ind]
    vp63 = np.abs(
        np.max(
            np.array(reader.read_block().segments[5].analogsignals[0]).flatten(
            )) * 1e-3 - Vrest) * 0.63 + Vrest
    vn63 = -np.abs(
        np.min(
            np.array(reader.read_block().segments[3].analogsignals[0]).flatten(
            )) * 1e-3 - Vrest) * 0.63 + Vrest
    tau = (t[(np.abs(Vtracep25_choppped - vp63)).argmin()] - exp_trace_injstart
           + t[(np.abs(Vtracen25_choppped - vn63)).argmin()] -
           exp_trace_injstart) / 2
    tauinv = (t[len(Vtracep25_choppped) -
                (np.abs(Vtracep25_choppped[stp_ind::-1] - vp63)).argmin()] -
              exp_trace_injstart +
              t[len(Vtracep25_choppped) -
                (np.abs(Vtracep25_choppped[::-1] - vp63)).argmin()] -
              exp_trace_injstart) / 2
    Cm = (tau + tauinv) * Gin / 2
    print(Cm)
    sm_len = np.sqrt(Cm / CM / np.pi)
    sm_diam = sm_len

    return exp_trace
コード例 #16
0
import matplotlib.pyplot as plt
from scipy import signal
import pylab as pl
import numpy as np


'''
Preliminary steps to read in the data.
'''
# I commonly use the variable 'fh' as shorthand for 'file handle'. In
# programming parlance, 'handle' is an abstract reference to a resource (in this
# case, the AxonIO instance that allows you to read from the file).
fh = AxonIO(filename='PVcell3.abf')

# The block is a container for the voltage and current data stored in the file.
block = fh.read_block()

# Some information regarding the experiment has been saved in the file. We need
# to parse this information out for the analysis. A block consists of multiple
# sweeps (i.e., ,trials), known as `segments`. Each segment can contain multiple
# signals, known as `analogsignals`. For this particular data file, the number
# of channels, number of timepoints, sampling rate and sampling period are
# identical across all sweeps.
n_channels = len(block.segments[0].analogsignals)
n_sweeps = len(block.segments)
n_timepoints = len(block.segments[0].analogsignals[0].times)
sampling_rate = int(block.segments[0].analogsignals[0].sampling_rate)
sampling_period = 1.0/sampling_rate
sweep_duration = n_timepoints*sampling_period

message = '''The data contains {n_sweeps} sweeps (i.e., trials) acquired from
コード例 #17
0
ファイル: ConvertABF.py プロジェクト: bejar/PeakDataAnalysis
datafiles = [(['15514028', '15514029', '15514030',
                '15514031', '15514032', '15514033', '15514034', '15514035', '15514036', '15514037', '15514038'], 12, 10000.0)
             ]



# datafiles = [(['15514027'],
#               12, 10000.0)]

for dataf, nsig, _ in datafiles:
    for files in dataf:
        print 'Reading: ', files, '...'
        data = AxonIO(cinvesdatanew + 'e150514/' + files + '.abf')

        bl = data.read_block(lazy=False, cascade=True)

        dim = bl.segments[0].analogsignals[0].shape[0]

        print dim
        matrix = np.zeros((nsig, dim))
        # for sig in bl.segments[0].analogsignals:
        # i += 1
        #     #print sig.duration, sig.signal, len(sig.times), i
        #     print sig.name, sig.units, sig.sampling_rate, sig.dtype, sig.duration, sig.shape


        for j in range(nsig):
            matrix[j][:] = bl.segments[0].analogsignals[j][:].magnitude

        peakdata = {'data': matrix.T}