%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