scripts/Step2_GetERPs_REVISION.m

%% Step 2 - load pre-proc'd flankers data
clear all; clc
addpath('Z:\EXPERIMENTS\Flankers t2t\');
datalocation='Y:\EEG_Data\Flankers OCDII\Processed Data\';   % Data are here
savedir='Y:\EEG_Data\Flankers OCDII\ERPs\';  % Save processed data here
cd(datalocation);

% Load up
[xls_data,xls_hdr]=xlsread('Z:\EXPERIMENTS\Flankers t2t\info.xlsx');

% Data are 60 chans * 2000 time * N epochs  |  Ref'd to linked mastoids
FILZ=dir('*_FLANKERS.mat');

for si=length(FILZ):-1:1
    
    subname=FILZ(si).name;
    subno=str2num(subname(1:3)); clc
    
    % Only run the latter on subjs pre-selected to be MUY BUENO (N=46)
    if ~isempty(find(xls_data(:,1)==subno))
        % Only run if not already done
        if 1 % ~(exist([savedir,num2str(subno),'_ERPs.mat'])==2)
            % Display
            disp(['DOING:    ',num2str(subno)]);
            
            % Get Subj Info
            tempdat=xls_data(find(xls_data(:,1)==subno),:);
            tempdat_hdr=xls_hdr(find(xls_data(:,1)==subno)+1,:);  % +1 b/c of header row
            SUBJINFO(1)=subno;
            SUBJINFO(2)=tempdat(1);
            SUBJINFO(3)=tempdat(4);
            SUBJINFO(4)=tempdat(6);
            SUBJINFO(5)=tempdat(7);
            SUBJINFO(6)=tempdat(9);
            SUBJINFO_HDR={'EEG_ID','INFO_ID','Error%','Sex','Age','OCI_Score'};
            %
            if ~isnan(tempdat(5))
                bad_ICAs_To_Remove=tempdat(5);
            elseif isnan(tempdat(5))
                bad_ICAs_To_Remove=str2num(cell2mat(tempdat_hdr(5)));
            end
            clear tempdat tempdat_hdr;
            
            % Load EEG
            load([datalocation,subname]);
            
            % Remove the bad ICAs:
            EEG = pop_subcomp( EEG, bad_ICAs_To_Remove, 0);
            
            
            % Get the good info out of the epochs
            VECTOR(1:size(EEG.epoch,2),1:13)=NaN;
            for ai=1:size(EEG.epoch,2)
                VECTOR(ai,1)=EEG.epoch(ai).TRIALNUM;
                VECTOR(ai,2)=EEG.epoch(ai).STIM;
                VECTOR(ai,3)=EEG.epoch(ai).CONGRU;
                VECTOR(ai,4)=EEG.epoch(ai).RightLeft;
                VECTOR(ai,5)=EEG.epoch(ai).RT;
                VECTOR(ai,6)=EEG.epoch(ai).ACC;
                % ^^^^^^^^^^^^^^^^^^ OOPS
                if ~isempty(EEG.epoch(ai).PREVTRIAL)
                    % ^^^^^^^^^^^^^^^^^^
                    VECTOR(ai,7)=EEG.epoch(ai).PREVTRIAL.TRIALNUM;
                    VECTOR(ai,8)=EEG.epoch(ai).PREVTRIAL.STIM;
                    VECTOR(ai,9)=EEG.epoch(ai).PREVTRIAL.CONGRU;
                    VECTOR(ai,10)=EEG.epoch(ai).PREVTRIAL.RightLeft;
                    VECTOR(ai,11)=EEG.epoch(ai).PREVTRIAL.RT;
                    VECTOR(ai,12)=EEG.epoch(ai).PREVTRIAL.ACC;
                    VECTOR(ai,13)=EEG.epoch(ai).PREVTRIAL.BlockStart;
                end
            end
            
            
            % Let's just do this for ERPs  - keep EEG.data structure unfiltered
            dims=size(EEG.data);
            FILT.data=eegfilt(EEG.data,500,[],20);
            FILT.data=reshape(FILT.data,dims(1),dims(2),dims(3));
            
            % Set Params
            tx=-2000:2:1998;
            b1=find(tx==-200);  b2=find(tx==0);
            t1=find(tx==-500);  t2=find(tx==1000);
            N2topo1=find(tx==200); N2topo2=find(tx==350);  N2toporangetot=200:2:350;
            P3topo1=find(tx==400); P3topo2=find(tx==600);  P3toporangetot=400:2:600;
            tx2disp=-500:2:1000;
            
            % Basecor your ERPs here so they are pretty.
            BASE=squeeze(  mean(FILT.data(:,b1:b2,:),2)  );
            for ai=1:dims(1)
                FILT.data(ai,:,:)=squeeze(FILT.data(ai,:,:))-repmat( BASE(ai,:),dims(2),1 );
            end
            
            % $$$$$$$$$$$$$$$$$$$ Parse condis and save ERPs $$$$$$$$$$$$$$$$$$$ %
            
            % If blockstart, then NaN the row
            VECTOR(VECTOR(:,13)==1,[3,4,9,10])=NaN;
            % If error, then NaN the row
            VECTOR(VECTOR(:,6)==0,[3,4,9,10])=NaN;
            % If post-error, then NaN the row
            temp=VECTOR(:,6)==0;
            VECTOR(logical([0;temp(1:end-1)]),[3,4,9,10])=NaN;    clear temp;
            % If RT<200 or NaN, then NaN the row
            VECTOR(VECTOR(:,5)<200,[3,4,9,10])=NaN;
            VECTOR(isnan(VECTOR(:,5)),[3,4,9,10])=NaN;
            % If any >2, all are NaN
            temp=sum((VECTOR(:,[3,4,9,10])>2)')';
            VECTOR(temp>0,[3,4,9,10])=NaN;
            % If any are NaN, all are NaN
            temp=sum(isnan(VECTOR(:,[3,4,9,10]))')';
            VECTOR(temp>0,[3,4,9,10])=NaN;
            
            for ai=1:length(VECTOR)
                if ~isnan(VECTOR(ai,3))
                    % ---------------------- congruent (1) or conflict (0)
                    if      VECTOR(ai,9)==1 && VECTOR(ai,3)==1, GRATTON=1;  %  cC
                    elseif  VECTOR(ai,9)==1 && VECTOR(ai,3)==0, GRATTON=2;  %  cI
                    elseif  VECTOR(ai,9)==0 && VECTOR(ai,3)==1, GRATTON=3;  %  iC
                    elseif  VECTOR(ai,9)==0 && VECTOR(ai,3)==0, GRATTON=4;  %  iI
                    end
                    % ---------------------- [Right=1, Left=2]
                    if      VECTOR(ai,10)==1 && VECTOR(ai,4)==1, RESPS=1; %  rR
                    elseif  VECTOR(ai,10)==2 && VECTOR(ai,4)==2, RESPS=1; %  lL
                    elseif  VECTOR(ai,10)==1 && VECTOR(ai,4)==2, RESPS=10; %  rL
                    elseif  VECTOR(ai,10)==2 && VECTOR(ai,4)==1, RESPS=10; %  lR
                    end
                    % ----------------------
                    VECTOR(ai,14)=GRATTON;
                    VECTOR(ai,15)=RESPS;
                    VECTOR(ai,16)=GRATTON.*RESPS;
                    clear GRATTON RESPS
                end
            end
            
            UNIQUES=unique(VECTOR(:,16));
            UNIQUES=UNIQUES(UNIQUES>0);
            for ai=1:8
                ERP(:,:,ai)=squeeze(mean(FILT.data(:,:,VECTOR(:,16)==UNIQUES(ai)),3));
            end
            % ---------------- single trial corr
            for ai=1:8
                for chani=1:60
                    rho=corr(squeeze(FILT.data(chani,:,VECTOR(:,16)==UNIQUES(ai)))', VECTOR(VECTOR(:,16)==UNIQUES(ai),5)  ,'type','Spearman','rows','complete');
                    ERP_Corr(chani,:,ai)=rho;
                end
            end
            % ----------------  limit based on lowest epoch count
            for ai=1:8
                TEMP_by_set{ai}=FILT.data(:,:,VECTOR(:,16)==UNIQUES(ai));
                TEMP_by_set_SIZE(ai)=size(TEMP_by_set{ai},3);
            end
            TEMP_minsize=min(TEMP_by_set_SIZE);
            % ----
            for ai=1:8
                TEMP_TRIALS=1:TEMP_by_set_SIZE(ai);
                TEMP_TRIALS=shuffle(TEMP_TRIALS);
                ERP_minsize(:,:,ai)=squeeze(mean(  TEMP_by_set{ai}(:,:,TEMP_TRIALS(1:TEMP_minsize))  ,3));
                clear TEMP_TRIALS
            end
            clear TEMP_by_set TEMP_by_set_SIZE TEMP_minsize TEMP_by_set_SIZE;
            
            
            % ------------------ Now for response locked
            for respi=1:dims(3)
                RT=VECTOR(respi,5);
                if isnan(RT)
                    response=zeros(dims(1),dims(2)) ;            % repmat(NaN,dims(1),dims(2));
                else
                    FILT_response=cat(2,FILT.data(:, floor(RT/2):end ,respi), zeros(dims(1),floor(RT/2)-1)  );
                    response=cat(2,FILT.data(:, floor(RT/2):end ,respi), zeros(dims(1),floor(RT/2)-1)  );
                end
                FILT.RESP(:,:,respi)=response;
                EEG.RESP(:,:,respi)=response;  clear FILT_response response;
            end
            % Stuff
            L_C3=26;
            R_C4=30;
            for ai=1:length(VECTOR)
                if ~isnan(VECTOR(ai,4))
                    % ---------------------- [Right=1, Left=2]
                    if      VECTOR(ai,4)==1, active_site=L_C3;  inactive_site=R_C4;  % Right response, left cortex active
                    elseif  VECTOR(ai,4)==2, active_site=R_C4;  inactive_site=L_C3;  % Left response, right cortex active
                    end
                    % ----------------------
                    FILT.RESP_ActInact(:,ai)=FILT.RESP(active_site,:,ai)-FILT.RESP(inactive_site,:,ai);
                    FILT.STIM_ActInact(:,ai)=FILT.data(active_site,:,ai)-FILT.data(inactive_site,:,ai);
                else
                    FILT.RESP_ActInact(:,ai)=repmat(NaN,1,dims(2));
                    FILT.STIM_ActInact(:,ai)=repmat(NaN,1,dims(2));
                end
            end
            % ERP-i-fy
            for ai=1:8
                ERP_RESP(:,ai)=squeeze(mean(FILT.RESP_ActInact(:,VECTOR(:,16)==UNIQUES(ai)),2));
                ERP_RESP_All(:,:,ai)=squeeze(mean(FILT.RESP(:,:,VECTOR(:,16)==UNIQUES(ai)),3));
                ERP_LRP_to_STIM(:,ai)=squeeze(mean(FILT.STIM_ActInact(:,VECTOR(:,16)==UNIQUES(ai)),2));
            end
             % ---------------- single trial corr
             for ai=1:8
                 rho=corr(squeeze(FILT.RESP_ActInact(:,VECTOR(:,16)==UNIQUES(ai)))', VECTOR(VECTOR(:,16)==UNIQUES(ai),5)  ,'type','Spearman','rows','complete');
                 ERP_RESP_Corr(:,ai)=rho;
             end
               % ----------------  limit based on lowest epoch count
            for ai=1:8
                TEMP_by_set{ai}=FILT.RESP_ActInact(:,VECTOR(:,16)==UNIQUES(ai));
                TEMP_by_set_SIZE(ai)=size(TEMP_by_set{ai},2);
            end
            TEMP_minsize=min(TEMP_by_set_SIZE);
            % ----
            for ai=1:8
                TEMP_TRIALS=1:TEMP_by_set_SIZE(ai);
                TEMP_TRIALS=shuffle(TEMP_TRIALS);
                ERP_LRP_minsize(:,ai)=squeeze(mean(  TEMP_by_set{ai}(:,TEMP_TRIALS(1:TEMP_minsize))  ,2));
                clear TEMP_TRIALS
            end
            clear TEMP_by_set TEMP_by_set_SIZE TEMP_minsize TEMP_by_set_SIZE;
            
            

            
            % ^^^^^^^^^^^^^^^^ TF
            % Setup Wavelet Params
            num_freqs=50;
            frex=logspace(.01,1.7,num_freqs);
            s=logspace(log10(3),log10(10),num_freqs)./(2*pi*frex);
            t=-2:1/EEG.srate:2;
            
            % Definte Convolution Parameters
            dims = size(EEG.data);
            n_wavelet = length(t);
            n_data = dims(2)*dims(3);
            n_convolution = n_wavelet+n_data-1;
            n_conv_pow2 = pow2(nextpow2(n_convolution));
            half_of_wavelet_size = (n_wavelet-1)/2;
            
            % same times, new baseline - also resp is -1000 to 500
            tx=-2000:2:1998;
            b1=find(tx==-300);  b2=find(tx==-200);
            t1=find(tx==-500);  t2=find(tx==1000);
            rt1=find(tx==-500); rt2=find(tx==1000);    % OK, made this like cue to get lotsa post-response activity
            
            % get FFT of data
            TF_chani=19;
            EEG_fft = fft(reshape(EEG.data(TF_chani,:,:),1,n_data),n_conv_pow2);
            RESP_fft = fft(reshape(EEG.RESP(TF_chani,:,:),1,n_data),n_conv_pow2);
            
            for fi=1:num_freqs
                
                wavelet = fft( exp(2*1i*pi*frex(fi).*t) .* exp(-t.^2./(2*(s(fi)^2))) , n_conv_pow2 );  % sqrt(1/(s(fi)*sqrt(pi))) *
                
                % convolution
                EEG_conv = ifft(wavelet.*EEG_fft);
                EEG_conv = EEG_conv(1:n_convolution);
                EEG_conv = EEG_conv(half_of_wavelet_size+1:end-half_of_wavelet_size);
                EEG_conv = reshape(EEG_conv,dims(2),dims(3));
                
                % convolution
                RESP_conv = ifft(wavelet.*RESP_fft);
                RESP_conv = RESP_conv(1:n_convolution);
                RESP_conv = RESP_conv(half_of_wavelet_size+1:end-half_of_wavelet_size);
                RESP_conv = reshape(RESP_conv,dims(2),dims(3));
                
                % Get baseline 
                BASE = mean(mean(abs(EEG_conv(b1:b2,:)).^2));
                
                for ai=1:8
                    % Get power by condi
                    temp_POWER1 = mean(abs(EEG_conv(t1:t2,VECTOR(:,16)==UNIQUES(ai))).^2,2);
                    temp_POWER2 = mean(abs(RESP_conv(rt1:rt2,VECTOR(:,16)==UNIQUES(ai))).^2,2);

                    % dB correct power by base (different time windows)
                    POWER{1}(fi,:,ai) = 10*(  log10(temp_POWER1) - log10(repmat(BASE,size(tx2disp,2),1)) ) ;
                    POWER{2}(fi,:,ai) = 10*(  log10(temp_POWER2) - log10(repmat(BASE,size(tx2disp,2),1)) ) ;
                    
                    % Get ITPC by condi (different time windows)
                    ITPC{1}(fi,:,ai) = abs(mean(exp(1i*(  angle(EEG_conv(t1:t2,VECTOR(:,16)==UNIQUES(ai)))  )),2));
                    ITPC{2}(fi,:,ai) = abs(mean(exp(1i*(  angle(RESP_conv(t1:t2,VECTOR(:,16)==UNIQUES(ai)))  )),2));
                    
                    clear temp_POWER1 temp_POWER2;
                end
                clear wavelet EEG_conv RESP_conv BASE;
            end
            % ^^^^^^^^^^^^^^^^
           

            save([savedir,num2str(subno),'_ERPs_2018_Revision.mat'],'SUBJINFO','SUBJINFO_HDR','ERP','ERP_RESP','ERP_RESP_All','VECTOR','POWER','ITPC',...
                   'ERP_LRP_to_STIM','ERP_minsize','ERP_Corr','ERP_RESP_Corr','ERP_LRP_minsize');
               
        end
        
    end
    
    clearvars -except FILZ xls_data xls_hdr si datalocation savedir;
end


%%