function [error_response] = RunNeuronErrorAnalysis(data_behavior,events,plxdata,filename)

  plot_onset = -0.5;
  plot_offset = 1;
  bin = 60;   %bin = 60 msec for stat analysis
  slide = 1;  %sliding procedure shift = 1-msec

  Error = [];
  
  if sum(data_behavior.ERROR == 1)>4   %TAKE IN ACCOUNT MORE THAN 4 ERRORS
      
       if ~isempty(find(~isnan(events.error_hold_centre), 1))
            Error = [Error events.error_hold_centre( ~isnan(events.error_hold_centre))];
       end
       if ~isempty(find(~isnan(events.error_nogo), 1))
            Error = [Error events.error_nogo( ~isnan(events.error_nogo))];
       end
       if ~isempty(find(~isnan(events.error_go_signal), 1))
            Error = [Error events.error_go_signal( ~isnan(events.error_go_signal))];
       end
       if ~isempty(find(~isnan(events.error_max_reachtime), 1))
            Error = [Error events.error_max_reachtime( ~isnan(events.error_max_reachtime))];
       end
       if ~isempty(find(~isnan(events.error_hold_endtarget), 1))
            Error = [Error events.error_hold_endtarget( ~isnan(events.error_hold_endtarget))];
       end

    %--------------  NEURONAL DATA  ---------------------------
    timestamps = plxdata.sig001a.ts .*1000;  % Neural activity   
    [sdf_error_trials] = sdf_neurons(timestamps,Error,plot_onset,plot_offset);    
    
    tscale = [plot_onset:0.001:plot_offset];
    maxy = nanmax(sdf_error_trials.mean_sdf) + 5;
     %------------------Plotting-------------------------------------
   
        [s_error,mean_error,thr_error] = make_psth_figure(timestamps,Error,filename,-0.5,1,maxy,1,'ERROR');   
    
        %------- ROC analysis ------------------------
        if ~isempty(s_error.on_ind)
            if s_error.on_ind<900
            
                
                  [m n] = size(sdf_error_trials.delta);
                  Wind_on = [1:slide:n-bin];
                  Wind_off = [bin:slide:n-1];
                
                    for k = 1:length(Wind_on)
                        delta_ERROR(:,k) = sum(sdf_error_trials.delta(:,Wind_on(k):Wind_off(k)),2);
                        
                        delta_ctl = shuffle(sdf_error_trials.delta,1);
                        delta_ctl = shuffle(delta_ctl,2);
                        delta_ctl = shuffle(delta_ctl);
            
                        delta_shuffle(:,k) = sum(delta_ctl(:,Wind_on(k):Wind_off(k)),2);
                    end
                  
                    for k = 1:length(delta_ERROR)
      
                        val = [delta_shuffle(:,k); delta_ERROR(:,k)];
                        val2 = [ones(length(delta_shuffle(:,k)),1); zeros(length(delta_ERROR(:,k)),1)];
                        val = [val val2];
     
                            if sum(val(:,1))>3
                                    AUC_ROC(k)=colAUC(val(:,1),val(:,2), 'algorithm', 'Wilcoxon', 'plot', false, 'abs', false);  
                            else
                                    AUC_ROC(k) = NaN;
                            end
     
                    clear val val2 
                    end
                  
                   Xbinned = [plot_onset:0.001:plot_onset+((length(AUC_ROC)-1)/1000)];
                   Xbinned = Xbinned + (bin/2)/1000;

                   subplot(3,3,4)
                   plot(Xbinned,AUC_ROC)
                   xlim([-0.5 0.5])
                   ylim([0 1])
                    
            end
        end
                        
               error_response.s_error = s_error; 
               error_response.sdf_error = sdf_error_trials.mean_sdf;
                         
  end
   
               error_response.s_error = NaN; 
               error_response.sdf_error = NaN;

end
