Spike burst-pause dynamics of Purkinje cells regulate sensorimotor adaptation (Luque et al 2019)

 Download zip file   Auto-launch 
Help downloading and running models
Accession:256140
"Cerebellar Purkinje cells mediate accurate eye movement coordination. However, it remains unclear how oculomotor adaptation depends on the interplay between the characteristic Purkinje cell response patterns, namely tonic, bursting, and spike pauses. Here, a spiking cerebellar model assesses the role of Purkinje cell firing patterns in vestibular ocular reflex (VOR) adaptation. The model captures the cerebellar microcircuit properties and it incorporates spike-based synaptic plasticity at multiple cerebellar sites. ..."
Reference:
1 . Luque NR, Naveros F, Carrillo RR, Ros E, Arleo A (2019) Spike burst-pause dynamics of Purkinje cells regulate sensorimotor adaptation. PLoS Comput Biol 15:e1006298 [PubMed]
Model Information (Click on a link to find other models with that property)
Model Type: Neuron or other electrically excitable cell; Realistic Network;
Brain Region(s)/Organism: Cerebellum;
Cell Type(s): Cerebellum Purkinje GABA cell; Cerebellum interneuron granule GLU cell; Vestibular neuron; Abstract integrate-and-fire leaky neuron;
Channel(s): I K; I Na,t; I L high threshold; I M;
Gap Junctions:
Receptor(s): AMPA; Gaba;
Gene(s):
Transmitter(s):
Simulation Environment: EDLUT; NEURON; MATLAB;
Model Concept(s): Activity Patterns; Sleep; Long-term Synaptic Plasticity; Vestibular;
Implementer(s): Luque, Niceto R. [nluque at ugr.es];
Search NeuronDB for information about:  Cerebellum Purkinje GABA cell; Cerebellum interneuron granule GLU cell; AMPA; Gaba; I Na,t; I L high threshold; I K; I M;
/
LuqueEtAl2019
EDLUT
Articulo purkinje
CASE_B
include
m4
src
README *
AUTHORS.txt *
CASE_A.ncb
CASE_A.vcproj
CASE_B.ncb
CASE_B.sln *
CASE_B.suo
configure *
configure.ac *
COPYING.txt *
Doxyfile *
flags.makefile.in *
INSTALL *
makefile.in *
noout2par.m *
rules.makefile.in *
static-variables.makefile *
varlog_reduced_VOR.m *
                            
%NOOUT2PAR plots a raster plot of the neural network activity
%   This script reads the simulation spikes processed during the whole 
%   simulation from the activity output file and plot them.
%   NOOUT2PAR var_type t_ini t_end only reads the spikes from
%   time t_ini to t_end (in seconds)
%   NOOUT2PAR var_type t_ini t_end neu_ini neu_end only reads the spikes of 
%   neurons from neu_ini to neu_end and in time from t_ini to t_end
%   var_type specifies how the activity will be plotted.
%   var_type must be: ra
%    ra: Displais a normal raster plot of the activity
%        (the whole specified period of the simulation is plotted)
%   example to generate a raster plot of simulation activity in the time interval 0 1: noout2par ra 0 1
%
%   See also NOOUTBIG2.

%   Copyright (C) 2014 by Richard R. Carrillo and Niceto R. Luque 
%   $Revision: 1.1 $  $Date: 31/11/2015 $

%   This program is free software; you can redistribute it and/or modify
%   it under the terms of the GNU General Public License as published by
%   the Free Software Foundation; either version 3 of the License, or
%   (at your option) any later version.
function noout2par(varargin)

LOG_FILE='OutputActivity.dat'; % log file name
single_exec_dur=1; % trajectoy duration in seconds
sim_slot_time=2e-3; % simulation slot length in seconds

nargs=nargin;
if nargin > 0
   v=varargin{1};
   if ~isequal(v,'ra') && ~isequal(v,'ra')
      display('Incorrect value of the first argument');
      nargs=0;
   end
end

if nargs ~= 1 && nargs ~= 3 && nargs ~= 5
      disp('You must specify 1, 3 or 5 arguments');
      disp('noout2par plot_type [start_time end_time [first_neuron last_neuron]]');
      disp('type: help noout2par for more help');
end

if nargs == 1 % the whole file must be loaded
    disp(['loading log file: ' LOG_FILE ' completely']);
    disp(' 100%');
    activity_list=load(LOG_FILE);
else % only a part of the file must be loaded
    start_time=str2num(varargin{2});
    end_time=str2num(varargin{3});
    disp(['Partially loading activity file ' LOG_FILE ' from time ' num2str(start_time) ' to ' num2str(end_time)]);
    fid = fopen(LOG_FILE,'rt');
    if fid ~= -1
        fseek(fid,-1,'eof');
        filelength=ftell(fid); % get log file size
        findline_backwards(fid); % set file reading pointer to the line start
        last_line_txt=fgetl(fid); % load last register
        last_line=str2num(last_line_txt);
        last_file_time=last_line(1); % last register time
        tot_num_cols=length(last_line); % total number of columns in the file
        fseek(fid,fix(filelength*(start_time/last_file_time)*0.8),'bof');
        findline_backwards(fid);
        activity_list=read_file_part(fid,start_time,end_time);
        fclose(fid);
        if last_file_time < start_time
            disp('Error: The specified start_time is no included in the file')
            return
        end
    else
        disp(['Cannot open log file: ' LOG_FILE]);
        return
    end
end
if nargs == 5 % only some neurons must be plotted
    first_neu=str2num(varargin{4});
    last_neu=str2num(varargin{5});
    activity_list=activity_list(activity_list(:,2) >= first_neu & activity_list(:,2) <= last_neu,:); % remove unwanted neurons from the list
end

time_col=1;
nneu_col=time_col+1;
tot_num_cols=nneu_col+1;

reg_times=activity_list(:,time_col);
last_1exec_reg=find(reg_times > reg_times(1)+single_exec_dur,1);
if isempty(last_1exec_reg)
   last_1exec_reg=length(reg_times);
end


neu_list_rep=sort(activity_list(:,2)');

neu_list=[];
if ~isempty(neu_list_rep)
    num_spk_neus=1;
    neu_list(1)=neu_list_rep(1);
else
    num_spk_neus=0;
end
for nneu=2:length(neu_list_rep),
    if neu_list_rep(nneu-1) ~= neu_list_rep(nneu)
        num_spk_neus=num_spk_neus+1;
        neu_list(num_spk_neus)=neu_list_rep(nneu);
    end
end

disp('Creating figure...');

switch(v)
case 'ra'
    tot_spks=0;
    for nneu=1:num_spk_neus
        cur_neu_spk_times=activity_list(find(activity_list(:,2)==neu_list(nneu)),1);
        tot_spks=tot_spks+length(cur_neu_spk_times);
        line((cur_neu_spk_times*ones(1,2))',(ones(length(cur_neu_spk_times),1)*[nneu-0.25,nneu+0.25])','Color','b');
    end
    axis tight
    xlabel('time');
    ylabel('neuron number');
    set(gca,'YTick',1:num_spk_neus);
    
    % find out what ticksthin out y-axis tick labels
    neu_tick_list={neu_list(1)};
    last_included_neu=1;
    max_number_of_yticks=30; % in order not to overlap them
    max_intertick_interval=num_spk_neus/max_number_of_yticks;
    for nneu=2:num_spk_neus,
        if neu_list(nneu-1) ~= neu_list(nneu)-1 || (nneu-last_included_neu) > max_intertick_interval || nneu==num_spk_neus
            neu_tick_list{nneu}=neu_list(nneu); % include nonconsecutive neuron ticks or spaced-enough ones
            last_included_neu=nneu;
        else
            neu_tick_list{nneu}=[]; % do not show this tick
        end
    end
    set(gca,'YTickLabel',neu_tick_list);
    display(['Total number of spikes: ' num2str(tot_spks)]);
    display(['Number of spiking neurons: ' num2str(num_spk_neus)]);
end

% READ_LINE_TIME gets the time of the next register from the simulation-log file.
%    REGTIME = READ_FILE_PART(FID) advances the file position indicator in the
%    file associated with the given FID to the beginning of the next text
%    line, then read and returns that register's time.
   function regtime=read_line_time(fid)
      time_read=0;
      regtime=-1;
      while time_read==0
         [regtime,time_read]=fscanf(fid,'%g',1);
         if time_read==0
            fgetl(fid);
         end
      end
   end

% FINDLINE_BACKWARDS move the a file pointer back to the beginning of the
% previous text line.
%    FINDLINE_BACKWARDS(FID) repositions the file position indicator in the
%    file associated with the given FID. FINDLINE_BACKWARDS sets the
%    position indicator to the byte at beginning of the line before the 
%    current one.
   function findline_backwards(fid)
      newline=sprintf('\n');
      tchar=' '; % look for the current-file-line start position
      while ~isempty(tchar) && isempty(strfind(tchar,newline))
         if fseek(fid,-2,'cof')==-1
             fseek(fid,0,'bof');
             break
         end
         tchar = fscanf(fid,'%1c',1);
      end
   end

% READ_FILE_PART loads registers from the simulation-log file.
%    REGS = READ_FILE_PART(FID,STARTTIME,ENDTIME) returns the registers of
%    a file associated with file identifier FID as a MATLAB matrix. Only
%    the registers from STARTTIME to ENDTIME are loaded.
   function regs=read_file_part(fid,starttime,endtime)
      disp(' Searching for specified registers in the file...')
      while ftell(fid) > 0 && read_line_time(fid) > starttime
         findline_backwards(fid); % go back to the current line start
         fseek(fid,-1,'cof'); % jump before \n
         findline_backwards(fid); % go back to the previous line start
      end
      findline_backwards(fid);
      while read_line_time(fid) < starttime
         fgetl(fid); % jump after \n
      end
      findline_backwards(fid);      
      disp(' Loading registers from the file...')
      disp(' 00%')
      app_regs_size=ceil((endtime-starttime)/sim_slot_time);  % estimated size for regs
      regs=zeros(app_regs_size,tot_num_cols); % allocate matrix memory (for execution time optmization)
      regs_size=0;
      cur_file_time=starttime;
      tline=' ';
      while cur_file_time < endtime && ischar(tline) && ~isempty(tline)
         tline=fgetl(fid);
         if ischar(tline) && ~isempty(tline) && isempty(~strfind(tline,'%'))
            vline=str2num(tline);
            regs_size=regs_size+1;
            regs(regs_size,:)=vline;
            cur_file_time=vline(1);
            if mod(regs_size,fix(app_regs_size/100)) == 0 && cur_file_time > starttime
               new_app_regs_size=ceil(regs_size*(endtime-starttime)/(cur_file_time-starttime)); % new estimation about the size of the matrix needed to store all the registers
               if new_app_regs_size > app_regs_size
                   regs=[regs;zeros(new_app_regs_size-app_regs_size,tot_num_cols)]; % resize (extend) the matrix size
                   app_regs_size=new_app_regs_size;
               end
               progress_percentage=(cur_file_time-starttime)/(endtime-starttime)*100;
               if progress_percentage > 99
                   progress_percentage=99;
               end
               fprintf(1,'\b\b\b\b% 3.f%%',progress_percentage);
            end
         end
      end
      regs=regs(1:regs_size,:); % trim array in case of initial overdimensioning
      fprintf(1,'\b\b\b\b100%%\n');
   end

end

Loading data, please wait...