|
@@ -1,538 +0,0 @@
|
|
|
-%this program analyzes behavior and puts it in the Lick struct
|
|
|
-%can change what it's saved as here to later compare Int and Blocks
|
|
|
-clear all;
|
|
|
-load ('RAW.mat');
|
|
|
-load ('R_2R.mat');
|
|
|
-
|
|
|
-%which lick intervals to look at?
|
|
|
-startinterval=1;
|
|
|
-endinterval=30;
|
|
|
-
|
|
|
-%time to look at difference in licking activity
|
|
|
-earlylicks=[1 4.5];
|
|
|
-
|
|
|
-%% conduct lick analysis
|
|
|
-global Dura Tm BSIZE Tbin
|
|
|
-tic
|
|
|
-path='C:\Users\dottenh2\Documents\MATLAB\David\2Rewards Nex Files\2RLick_paper.xls';
|
|
|
-if ~exist('RAW'), load ('RAW.mat'); end
|
|
|
-
|
|
|
-%Main settings
|
|
|
-BSIZE=0.01; %Do not change
|
|
|
-Dura=[-22 20]; Tm=Dura(1):BSIZE:Dura(2);
|
|
|
-Tbin=-0.5:0.005:0.5; %window used to determine the optimal binsize
|
|
|
-MinNumTrials=5;
|
|
|
-Lick=[];Lick.Ninfo={};LL=0;NSess=0;
|
|
|
-
|
|
|
-%Smoothing
|
|
|
-Smoothing=1; %0 for raw and 1 for smoothing
|
|
|
-SmoothTYPE='lowess'; %can change this between lowess and rlowess (more robust, ignores outliers more)
|
|
|
-SmoothSPAN=50; %percentage of total data points
|
|
|
-if Smoothing~=1, SmoothTYPE='NoSmoothing';SmoothSPAN=NaN; end
|
|
|
-
|
|
|
-% List of events to analyze and analysis windows EXTRACTED from excel file
|
|
|
-[~,Erefnames]=xlsread(path,'Windows','a3:a10'); % cell that contains the event names
|
|
|
-
|
|
|
-%Finds the total number of suc vs mal sessions
|
|
|
-for i=1:length(RAW)
|
|
|
- if strcmp('NA',RAW(i).Type(1:2)) | strcmp('VP',RAW(i).Type(1:2))
|
|
|
- NSess=NSess+1;
|
|
|
- Lick.Linfo(i,1)=RAW(i).Ninfo(1,1);
|
|
|
- end
|
|
|
-end
|
|
|
-Lick.Erefnames= Erefnames;
|
|
|
-
|
|
|
-
|
|
|
-%preallocating for behavior stats
|
|
|
-Lick.RewDurR1=NaN(NSess,35);
|
|
|
-Lick.RewDurR2=NaN(NSess,35);
|
|
|
-Lick.NumLicksR1=NaN(NSess,35);
|
|
|
-Lick.NumLicksR2=NaN(NSess,35);
|
|
|
-Lick.LicksEarlyR1=NaN(NSess,35);
|
|
|
-Lick.LicksEarlyR2=NaN(NSess,35);
|
|
|
-Lick.LicksR1P1=NaN(NSess,35);
|
|
|
-Lick.LicksR1P2=NaN(NSess,35);
|
|
|
-Lick.LicksR2P1=NaN(NSess,35);
|
|
|
-Lick.LicksR2P2=NaN(NSess,35);
|
|
|
-for i=1:endinterval
|
|
|
- Lick.ILIR1{i,1}=NaN(NSess,35);
|
|
|
- Lick.ILIR2{i,1}=NaN(NSess,35);
|
|
|
-end
|
|
|
-
|
|
|
-%preallocating the result matrix
|
|
|
-for k=1:length(Erefnames)
|
|
|
- Lick.Ev(k).PSTHraw(1:NSess,1:length(Tm))=NaN(NSess,length(Tm));
|
|
|
- Lick.Ev(k).BW(1:NSess,1)=NaN;
|
|
|
- Lick.Ev(k).NumberTrials(1:NSess,1)=NaN;
|
|
|
-end
|
|
|
-
|
|
|
-for i=1:length(RAW) %loops through sessions
|
|
|
- if strcmp('NA',RAW(i).Type(1:2)) | strcmp('VP',RAW(i).Type(1:2))
|
|
|
- LL=LL+1; %lick session counter
|
|
|
- for k=1:length(Erefnames) %loops thorough the events
|
|
|
- EvInd=strcmp(Erefnames(k),RAW(i).Einfo(:,2)); %find the event id number from RAW
|
|
|
- LickInd=strcmp('Licks',RAW(i).Einfo(:,2)); %find the event id number from RAW
|
|
|
- if sum(EvInd)==0
|
|
|
- fprintf('HOWDY, CANT FIND EVENTS FOR ''%s''\n',Erefnames{k});
|
|
|
- end
|
|
|
-
|
|
|
- Lick.Ev(k).NumberTrials(LL,1)=length(RAW(i).Erast{EvInd});
|
|
|
- if ~isempty(EvInd) && Lick.Ev(k).NumberTrials(LL,1)>MinNumTrials %avoid analyzing sessions where that do not have enough trials
|
|
|
- [PSR1,N1]=MakePSR04(RAW(i).Erast(LickInd),RAW(i).Erast{EvInd},Dura,{1});% makes collpased rasters. PSR1 is a cell(neurons)
|
|
|
- if ~isempty(PSR1{1}) %to avoid errors, added on 12/28 2011
|
|
|
- %forcing 100ms bin size to keep it consistent across
|
|
|
- %sessions (no reason is should be different for licks)
|
|
|
- [PTH1,BW1,~]=MakePTH07(PSR1,repmat(N1, size(RAW(i).Erast{LickInd},1),1),{2,0,0.1});%these values force bin size to be 100ms
|
|
|
- PTH1=smooth(PTH1,SmoothSPAN,SmoothTYPE)';
|
|
|
-
|
|
|
- %------------- Fills the R.Ev(k) fields --------------
|
|
|
- Lick.Ev(k).BW(LL,1)=BW1;
|
|
|
- Lick.Ev(k).PSTHraw(LL,1:length(Tm))=PTH1;
|
|
|
- end
|
|
|
- end
|
|
|
- end
|
|
|
-
|
|
|
-
|
|
|
-
|
|
|
-
|
|
|
-
|
|
|
-%% this section finds the ILIs, number of licks, and lick duration
|
|
|
-
|
|
|
-
|
|
|
- RD1=strmatch('RD1',RAW(i).Einfo(:,2),'exact'); %finds the index of the event
|
|
|
- RD2=strmatch('RD2',RAW(i).Einfo(:,2),'exact'); %finds the index of the event
|
|
|
- RD1P1=strmatch('RD1P1',RAW(i).Einfo(:,2),'exact'); %finds the index of the event
|
|
|
- RD1P2=strmatch('RD1P2',RAW(i).Einfo(:,2),'exact'); %finds the index of the event
|
|
|
- RD2P1=strmatch('RD2P1',RAW(i).Einfo(:,2),'exact'); %finds the index of the event
|
|
|
- RD2P2=strmatch('RD2P2',RAW(i).Einfo(:,2),'exact'); %finds the index of the event
|
|
|
- Rind=strmatch('BoutEndRLast',RAW(i).Einfo(:,2),'exact'); %finds the index of the event
|
|
|
- Lind=strmatch('Licks',RAW(i).Einfo(:,2),'exact'); %finds the index of the event
|
|
|
-
|
|
|
-
|
|
|
- %trying to make the ISI calculator Peter recommended
|
|
|
- %unfortunately, there's one trial of maltodextrin with only one
|
|
|
- %lick
|
|
|
- %so I need to put this lame code in to avoid an error
|
|
|
- % NL2{1,4}=NaN(40,1);
|
|
|
- %except it doesn't work!
|
|
|
-
|
|
|
- %find durations of reward consumption for all, R1, and R2 trls
|
|
|
- RDu1=MakePSR04(RAW(i).Erast(Rind),RAW(i).Erast{RD1},[0 15],{2,'first'});
|
|
|
- RDu2=MakePSR04(RAW(i).Erast(Rind),RAW(i).Erast{RD2},[0 15],{2,'first'});
|
|
|
- Lick.RewDurR1(LL,1:length(RDu1))=cell2mat(RDu1);
|
|
|
- Lick.RewDurR2(LL,1:length(RDu2))=cell2mat(RDu2);
|
|
|
- %find number of licks for all, R1, and R2 trls
|
|
|
- NL1=MakePSR04(RAW(i).Erast(Lind),RAW(i).Erast{RD1},[0 15],{2});
|
|
|
- NL2=MakePSR04(RAW(i).Erast(Lind),RAW(i).Erast{RD2},[0 15],{2});
|
|
|
- %find number of licks in 1-3 seconds post-reward
|
|
|
- EL1=MakePSR04(RAW(i).Erast(Lind),RAW(i).Erast{RD1},[earlylicks(1) earlylicks(2)],{2});
|
|
|
- EL2=MakePSR04(RAW(i).Erast(Lind),RAW(i).Erast{RD2},[earlylicks(1) earlylicks(2)],{2});
|
|
|
- %break that down by previous reward
|
|
|
- NL1P1=MakePSR04(RAW(i).Erast(Lind),RAW(i).Erast{RD1P1},[earlylicks(1) earlylicks(2)],{2});
|
|
|
- NL1P2=MakePSR04(RAW(i).Erast(Lind),RAW(i).Erast{RD1P2},[earlylicks(1) earlylicks(2)],{2});
|
|
|
- NL2P1=MakePSR04(RAW(i).Erast(Lind),RAW(i).Erast{RD2P1},[earlylicks(1) earlylicks(2)],{2});
|
|
|
- NL2P2=MakePSR04(RAW(i).Erast(Lind),RAW(i).Erast{RD2P2},[earlylicks(1) earlylicks(2)],{2});
|
|
|
-
|
|
|
- %make lick matrices
|
|
|
- for j=1:length(NL1)
|
|
|
- Lick.NumLicksR1(LL,j)=sum(NL1{1,j}>0);
|
|
|
- Lick.LicksEarlyR1(LL,j)=sum(EL1{1,j}>0);
|
|
|
-
|
|
|
- for k=startinterval:endinterval
|
|
|
- if length(NL1{1,j})>k
|
|
|
- Lick.ILIR1{k,1}(LL,j)= NL1{1,j}(k+1,1)-NL1{1,j}(k,1);
|
|
|
- else
|
|
|
- Lick.ILIR1{k,1}(LL,j)= NaN;
|
|
|
- end
|
|
|
- end
|
|
|
- end
|
|
|
- for j=1:length(NL2)
|
|
|
- Lick.NumLicksR2(LL,j)=sum(NL2{1,j}>0);
|
|
|
- Lick.LicksEarlyR2(LL,j)=sum(EL2{1,j}>0);
|
|
|
-
|
|
|
- for k=startinterval:endinterval
|
|
|
- if length(NL2{1,j})>k
|
|
|
- Lick.ILIR2{k,1}(LL,j)= NL2{1,j}(k+1,1)-NL2{1,j}(k,1);
|
|
|
- else
|
|
|
- Lick.ILIR2{k,1}(LL,j)= NaN;
|
|
|
- end
|
|
|
- end
|
|
|
- end
|
|
|
-
|
|
|
- %now for the previous reward situation
|
|
|
- for j=1:length(NL1P1)
|
|
|
- Lick.LicksR1P1(LL,j)=sum(NL1P1{1,j}>0);
|
|
|
- end
|
|
|
- for j=1:length(NL1P2)
|
|
|
- Lick.LicksR1P2(LL,j)=sum(NL1P2{1,j}>0);
|
|
|
- end
|
|
|
- for j=1:length(NL2P1)
|
|
|
- Lick.LicksR2P1(LL,j)=sum(NL2P1{1,j}>0);
|
|
|
- end
|
|
|
- for j=1:length(NL2P2)
|
|
|
- Lick.LicksR2P2(LL,j)=sum(NL2P2{1,j}>0);
|
|
|
- end
|
|
|
-
|
|
|
- %get session and rat #
|
|
|
- Lick.Sess(LL,1:35)=i;
|
|
|
- A=char(RAW(i).Ninfo(1,1));
|
|
|
- Lick.Rat(LL,1:35)=cellstr(A(1:3));
|
|
|
-
|
|
|
- fprintf('Session # %d\n',LL);
|
|
|
- end
|
|
|
-end
|
|
|
-
|
|
|
-%% computing stats
|
|
|
-
|
|
|
-%setting up result stat matrix
|
|
|
-R_2R.BehAvs{2,1}='RewDur';
|
|
|
-R_2R.BehAvs{3,1}='NumLicks';
|
|
|
-R_2R.BehAvs{4,1}='NumLicksEarly';
|
|
|
-R_2R.BehAvs{1,2}='R1 Avg';
|
|
|
-R_2R.BehAvs{1,3}='R2 Avg';
|
|
|
-
|
|
|
-%putting all values into one row array and removing NaN, doing 3-way ANOVA
|
|
|
-%with fixed effect of reward and random effects of session nested in rat
|
|
|
-
|
|
|
-%reward duration
|
|
|
-Lick.RDR1=reshape(Lick.RewDurR1,1,numel(Lick.RewDurR1));
|
|
|
-Lick.RDR1Sess=reshape(Lick.Sess,1,numel(Lick.Sess));
|
|
|
-Lick.RDR1Rat=reshape(Lick.Rat,1,numel(Lick.Rat));
|
|
|
-Lick.RDR1Sess(isnan(Lick.RDR1))=[];
|
|
|
-Lick.RDR1Rat(isnan(Lick.RDR1))=[];
|
|
|
-Lick.RDR1(isnan(Lick.RDR1))=[];
|
|
|
-Lick.RDR2=reshape(Lick.RewDurR2,1,numel(Lick.RewDurR2));
|
|
|
-Lick.RDR2Sess=reshape(Lick.Sess,1,numel(Lick.Sess));
|
|
|
-Lick.RDR2Rat=reshape(Lick.Rat,1,numel(Lick.Rat));
|
|
|
-Lick.RDR2Sess(isnan(Lick.RDR2))=[];
|
|
|
-Lick.RDR2Rat(isnan(Lick.RDR2))=[];
|
|
|
-Lick.RDR2(isnan(Lick.RDR2))=[];
|
|
|
-[~,R_2R.RDstats,~]=anovan(cat(2,Lick.RDR1,Lick.RDR2),{(cat(2,zeros(1,length(Lick.RDR1)),ones(1,length(Lick.RDR2)))),(cat(2,Lick.RDR1Sess,Lick.RDR2Sess)),(cat(2,Lick.RDR1Rat,Lick.RDR2Rat))},'varnames',{'reward','session','rat'},'nested',[0 0 0;0 0 1;0 0 0],'random',[2 3],'display','off','model','full'); %nested ANOVA
|
|
|
-
|
|
|
-
|
|
|
-%number of licks
|
|
|
-Lick.NLR1=reshape(Lick.NumLicksR1,1,numel(Lick.NumLicksR1));
|
|
|
-Lick.NLR1Sess=reshape(Lick.Sess,1,numel(Lick.Sess));
|
|
|
-Lick.NLR1Rat=reshape(Lick.Rat,1,numel(Lick.Rat));
|
|
|
-Lick.NLR1Sess(isnan(Lick.NLR1))=[];
|
|
|
-Lick.NLR1Rat(isnan(Lick.NLR1))=[];
|
|
|
-Lick.NLR1(isnan(Lick.NLR1))=[];
|
|
|
-Lick.NLR2=reshape(Lick.NumLicksR2,1,numel(Lick.NumLicksR2));
|
|
|
-Lick.NLR2Sess=reshape(Lick.Sess,1,numel(Lick.Sess));
|
|
|
-Lick.NLR2Rat=reshape(Lick.Rat,1,numel(Lick.Rat));
|
|
|
-Lick.NLR2Sess(isnan(Lick.NLR2))=[];
|
|
|
-Lick.NLR2Rat(isnan(Lick.NLR2))=[];
|
|
|
-Lick.NLR2(isnan(Lick.NLR2))=[];
|
|
|
-[~,R_2R.LicksStats,~]=anovan(cat(2,Lick.NLR1,Lick.NLR2),{(cat(2,zeros(1,length(Lick.NLR1)),ones(1,length(Lick.NLR2)))),(cat(2,Lick.NLR1Sess,Lick.NLR2Sess)),(cat(2,Lick.NLR1Rat,Lick.NLR2Rat))},'varnames',{'reward','session','rat'},'nested',[0 0 0;0 0 1;0 0 0],'random',[2 3],'display','off','model','full'); %nested ANOVA
|
|
|
-
|
|
|
-%number of licks 1-3sec
|
|
|
-Lick.ELR1=reshape(Lick.LicksEarlyR1,1,numel(Lick.LicksEarlyR1));
|
|
|
-Lick.ELR1Sess=reshape(Lick.Sess,1,numel(Lick.Sess));
|
|
|
-Lick.ELR1Rat=reshape(Lick.Rat,1,numel(Lick.Rat));
|
|
|
-Lick.ELR1Sess(isnan(Lick.ELR1))=[];
|
|
|
-Lick.ELR1Rat(isnan(Lick.ELR1))=[];
|
|
|
-Lick.ELR1(isnan(Lick.ELR1))=[];
|
|
|
-Lick.ELR2=reshape(Lick.LicksEarlyR2,1,numel(Lick.LicksEarlyR2));
|
|
|
-Lick.ELR2Sess=reshape(Lick.Sess,1,numel(Lick.Sess));
|
|
|
-Lick.ELR2Rat=reshape(Lick.Rat,1,numel(Lick.Rat));
|
|
|
-Lick.ELR2Sess(isnan(Lick.ELR2))=[];
|
|
|
-Lick.ELR2Rat(isnan(Lick.ELR2))=[];
|
|
|
-Lick.ELR2(isnan(Lick.ELR2))=[];
|
|
|
-[~,R_2R.LicksEarlyStats,~]=anovan(cat(2,Lick.ELR1,Lick.ELR2),{(cat(2,zeros(1,length(Lick.ELR1)),ones(1,length(Lick.ELR2)))),(cat(2,Lick.ELR1Sess,Lick.ELR2Sess)),(cat(2,Lick.ELR1Rat,Lick.ELR2Rat))},'varnames',{'reward','session','rat'},'nested',[0 0 0;0 0 1;0 0 0],'random',[2 3],'display','off','model','full'); %nested ANOVA
|
|
|
-
|
|
|
-%number of licks 1-3sec
|
|
|
-Lick.NLR1P1=reshape(Lick.LicksR1P1,1,numel(Lick.LicksR1P1));
|
|
|
-Lick.NLR1P1Sess=reshape(Lick.Sess,1,numel(Lick.Sess));
|
|
|
-Lick.NLR1P1Rat=reshape(Lick.Rat,1,numel(Lick.Rat));
|
|
|
-Lick.NLR1P1Sess(isnan(Lick.NLR1P1))=[];
|
|
|
-Lick.NLR1P1Rat(isnan(Lick.NLR1P1))=[];
|
|
|
-Lick.NLR1P1(isnan(Lick.NLR1P1))=[];
|
|
|
-Lick.NLR1P2=reshape(Lick.LicksR1P2,1,numel(Lick.LicksR1P2));
|
|
|
-Lick.NLR1P2Sess=reshape(Lick.Sess,1,numel(Lick.Sess));
|
|
|
-Lick.NLR1P2Rat=reshape(Lick.Rat,1,numel(Lick.Rat));
|
|
|
-Lick.NLR1P2Sess(isnan(Lick.NLR1P2))=[];
|
|
|
-Lick.NLR1P2Rat(isnan(Lick.NLR1P2))=[];
|
|
|
-Lick.NLR1P2(isnan(Lick.NLR1P2))=[];
|
|
|
-Lick.NLR2P1=reshape(Lick.LicksR2P1,1,numel(Lick.LicksR2P1));
|
|
|
-Lick.NLR2P1Sess=reshape(Lick.Sess,1,numel(Lick.Sess));
|
|
|
-Lick.NLR2P1Rat=reshape(Lick.Rat,1,numel(Lick.Rat));
|
|
|
-Lick.NLR2P1Sess(isnan(Lick.NLR2P1))=[];
|
|
|
-Lick.NLR2P1Rat(isnan(Lick.NLR2P1))=[];
|
|
|
-Lick.NLR2P1(isnan(Lick.NLR2P1))=[];
|
|
|
-Lick.NLR2P2=reshape(Lick.LicksR2P2,1,numel(Lick.LicksR2P2));
|
|
|
-Lick.NLR2P2Sess=reshape(Lick.Sess,1,numel(Lick.Sess));
|
|
|
-Lick.NLR2P2Rat=reshape(Lick.Rat,1,numel(Lick.Rat));
|
|
|
-Lick.NLR2P2Sess(isnan(Lick.NLR2P2))=[];
|
|
|
-Lick.NLR2P2Rat(isnan(Lick.NLR2P2))=[];
|
|
|
-Lick.NLR2P2(isnan(Lick.NLR2P2))=[];
|
|
|
-[~,R_2R.LicksPrevRewStats,stats]=anovan(cat(2,Lick.NLR1P1,Lick.NLR1P2,Lick.NLR2P1,Lick.NLR2P2),{cat(2,zeros(1,length(cat(2,Lick.NLR1P1,Lick.NLR1P2))),ones(1,length(cat(2,Lick.NLR2P1,Lick.NLR2P2)))),...
|
|
|
- cat(2,zeros(1,length(Lick.NLR1P1)),ones(1,length(Lick.NLR1P2)),zeros(1,length(Lick.NLR2P1)),ones(1,length(Lick.NLR2P2))),cat(2,Lick.NLR1P1Sess,Lick.NLR1P2Sess,Lick.NLR2P1Sess,Lick.NLR2P2Sess),...
|
|
|
- cat(2,Lick.NLR1P1Rat,Lick.NLR1P2Rat,Lick.NLR2P1Rat,Lick.NLR2P2Rat)},'varnames',{'current reward','prev reward','session','rat'},'nested',[0 0 0 0;0 0 0 0;0 0 0 1;0 0 0 0],'random',[3 4],'display','off','model','full'); %nested ANOVA
|
|
|
-
|
|
|
-% %without random factor of session
|
|
|
-% [~,R_2R.LicksPrevRewStats,stats]=anovan(cat(2,Lick.NLR1P1,Lick.NLR1P2,Lick.NLR2P1,Lick.NLR2P2),{cat(2,zeros(1,length(cat(2,Lick.NLR1P1,Lick.NLR1P2))),ones(1,length(cat(2,Lick.NLR2P1,Lick.NLR2P2)))),...
|
|
|
-% cat(2,zeros(1,length(Lick.NLR1P1)),ones(1,length(Lick.NLR1P2)),zeros(1,length(Lick.NLR2P1)),ones(1,length(Lick.NLR2P2))),...
|
|
|
-% cat(2,Lick.NLR1P1Rat,Lick.NLR1P2Rat,Lick.NLR2P1Rat,Lick.NLR2P2Rat)},'varnames',{'current reward','prev reward','rat'},'random',[3],'display','off','model','full');
|
|
|
-
|
|
|
-
|
|
|
-%ILI
|
|
|
-for m=startinterval:endinterval
|
|
|
- %first get session averages so I can do an ANOVA across all ILI
|
|
|
- Lick.ILIR1sessav{m,1}=nanmean(Lick.ILIR1{m,1},2);
|
|
|
- Lick.ILIR2sessav{m,1}=nanmean(Lick.ILIR2{m,1},2);
|
|
|
- Lick.ILIsesssess{m,1}=Lick.Sess(:,1);
|
|
|
- Lick.ILIsessrat{m,1}=Lick.Rat(:,1);
|
|
|
-
|
|
|
-
|
|
|
- %now do it with all trials
|
|
|
- Lick.ILIR1{m,1}=reshape(Lick.ILIR1{m,1},1,numel(Lick.ILIR1{m,1}));
|
|
|
- Lick.ILIR1Sess{m,1}=reshape(Lick.Sess,1,numel(Lick.ILIR1{m,1}));
|
|
|
- Lick.ILIR1Rat{m,1}=reshape(Lick.Rat,1,numel(Lick.ILIR1{m,1}));
|
|
|
- Lick.ILIR1Sess{m,1}(isnan(Lick.ILIR1{m,1}))=[];
|
|
|
- Lick.ILIR1Rat{m,1}(isnan(Lick.ILIR1{m,1}))=[];
|
|
|
- Lick.ILIR1{m,1}(isnan(Lick.ILIR1{m,1}))=[];
|
|
|
- Lick.ILIR2{m,1}=reshape(Lick.ILIR2{m,1},1,numel(Lick.ILIR2{m,1}));
|
|
|
- Lick.ILIR2Sess{m,1}=reshape(Lick.Sess,1,numel(Lick.ILIR2{m,1}));
|
|
|
- Lick.ILIR2Rat{m,1}=reshape(Lick.Rat,1,numel(Lick.ILIR2{m,1}));
|
|
|
- Lick.ILIR2Sess{m,1}(isnan(Lick.ILIR2{m,1}))=[];
|
|
|
- Lick.ILIR2Rat{m,1}(isnan(Lick.ILIR2{m,1}))=[];
|
|
|
- Lick.ILIR2{m,1}(isnan(Lick.ILIR2{m,1}))=[];
|
|
|
-end
|
|
|
-
|
|
|
-%getting effects of interval #, reward, rat, and session on ILI
|
|
|
-Lick.ILIR1all=[];
|
|
|
-Lick.ILIR1all=[];
|
|
|
-Lick.ILIR1Ratall=[];
|
|
|
-Lick.ILIR1Sessall=[];
|
|
|
-Lick.ILIR1Rewall=[];
|
|
|
-Lick.ILIR1Intall=[];
|
|
|
-Lick.ILIR2all=[];
|
|
|
-Lick.ILIR2all=[];
|
|
|
-Lick.ILIR2Ratall=[];
|
|
|
-Lick.ILIR2Sessall=[];
|
|
|
-Lick.ILIR2Rewall=[];
|
|
|
-Lick.ILIR2Intall=[];
|
|
|
-
|
|
|
-%to do session averages for comparing across all intervals
|
|
|
-for m=startinterval:endinterval
|
|
|
- Lick.ILIR1all=cat(1,Lick.ILIR1all,Lick.ILIR1sessav{m,1});
|
|
|
- Lick.ILIR1Ratall=cat(1,Lick.ILIR1Ratall,Lick.ILIsessrat{m,1});
|
|
|
- Lick.ILIR1Sessall=cat(1,Lick.ILIR1Sessall,Lick.ILIsesssess{m,1});
|
|
|
- Lick.ILIR1Rewall=cat(1,Lick.ILIR1Rewall,zeros(length(Lick.ILIR1sessav{m,1}),1));
|
|
|
- Lick.ILIR1Intall=cat(1,Lick.ILIR1Intall,(m*ones(length(Lick.ILIR1sessav{m,1}),1)));
|
|
|
- Lick.ILIR2all=cat(1,Lick.ILIR2all,Lick.ILIR2sessav{m,1});
|
|
|
- Lick.ILIR2Ratall=cat(1,Lick.ILIR2Ratall,Lick.ILIsessrat{m,1});
|
|
|
- Lick.ILIR2Sessall=cat(1,Lick.ILIR2Sessall,Lick.ILIsesssess{m,1});
|
|
|
- Lick.ILIR2Rewall=cat(1,Lick.ILIR2Rewall,ones(length(Lick.ILIR2sessav{m,1}),1));
|
|
|
- Lick.ILIR2Intall=cat(1,Lick.ILIR2Intall,(m*ones(length(Lick.ILIR2sessav{m,1}),1)));
|
|
|
-end
|
|
|
-
|
|
|
-%no factor of session
|
|
|
-[~,R_2R.ILItrialstats,~]=anovan(cat(1,Lick.ILIR1all,Lick.ILIR2all),{(cat(1,Lick.ILIR1Rewall,Lick.ILIR2Rewall)),(cat(1,Lick.ILIR1Ratall,Lick.ILIR2Ratall)),(cat(1,Lick.ILIR1Intall,Lick.ILIR2Intall))},'varnames',{'reward','rat','interval'},'random',[2],'display','off','model','full');
|
|
|
-
|
|
|
-%finding values for R_2R.BehAvs
|
|
|
-R_2R.BehAvs{2,2}=mean(Lick.RDR1);
|
|
|
-R_2R.BehAvs{2,3}=mean(Lick.RDR2);
|
|
|
-R_2R.BehAvs{3,2}=mean(Lick.NLR1);
|
|
|
-R_2R.BehAvs{3,3}=mean(Lick.NLR2);
|
|
|
-R_2R.BehAvs{4,2}=mean(Lick.ELR1);
|
|
|
-R_2R.BehAvs{4,3}=mean(Lick.ELR2);
|
|
|
-
|
|
|
-%Finding ILI
|
|
|
-for m=startinterval:endinterval
|
|
|
- Lick.ILI1(m,1)=nanmean(Lick.ILIR1{m,1}(:));
|
|
|
- Lick.ILI1(m,2)=nanstd(Lick.ILIR1{m,1}(:))/sqrt(sum(~isnan(Lick.ILIR1{m,1}(:))));
|
|
|
- Lick.ILI2(m,1)=nanmean(Lick.ILIR2{m,1}(:));
|
|
|
- Lick.ILI2(m,2)=nanstd(Lick.ILIR2{m,1}(:))/sqrt(sum(~isnan(Lick.ILIR2{m,1}(:))));
|
|
|
-end
|
|
|
-
|
|
|
-%% plotting licks in each reward condition
|
|
|
-Xaxis=[-2 12];
|
|
|
-Ishow=find(Tm>=Xaxis(1) & Tm<=Xaxis(2));
|
|
|
-time1=Tm(Ishow);
|
|
|
-c=[-1000 7500];ClimE=sign(c).*abs(c).^(1/4);%ColorMapExc
|
|
|
-colormap(jet);
|
|
|
-sucrose=[1 0.6 0.1];
|
|
|
-maltodextrin=[.9 0.3 .9];
|
|
|
-water=[0.00 0.75 0.75];
|
|
|
-total=[0.3 0.1 0.8];
|
|
|
-exc=[0 113/255 188/255];
|
|
|
-inh=[240/255 0 50/255];
|
|
|
-
|
|
|
-Ev1=strcmp('RD1', Lick.Erefnames);
|
|
|
-Ev2=strcmp('RD2', Lick.Erefnames);
|
|
|
-
|
|
|
-psth1=nanmean(Lick.Ev(Ev1).PSTHraw(:,Ishow),1);
|
|
|
-sem1=nanste(Lick.Ev(Ev1).PSTHraw(:,Ishow),1); %calculate standard error of the mean
|
|
|
-up1=psth1+sem1;
|
|
|
-down1=psth1-sem1;
|
|
|
-
|
|
|
-psthE=nanmean(Lick.Ev(Ev2).PSTHraw(:,Ishow),1);
|
|
|
-semE=nanste(Lick.Ev(Ev2).PSTHraw(:,Ishow),1); %calculate standard error of the mean
|
|
|
-upE=psthE+semE;
|
|
|
-downE=psthE-semE;
|
|
|
-
|
|
|
-%plotting
|
|
|
-subplot(2,2,1);
|
|
|
-hold on;
|
|
|
-plot(time1,psth1,'Color',sucrose,'linewidth',1);
|
|
|
-plot(time1,psthE,'Color',maltodextrin,'linewidth',1);
|
|
|
-patch([time1,time1(end:-1:1)],[up1,down1(end:-1:1)],sucrose,'EdgeColor','none');alpha(0.5);
|
|
|
-patch([time1,time1(end:-1:1)],[upE,downE(end:-1:1)],maltodextrin,'EdgeColor','none');alpha(0.5);
|
|
|
-title('Mean lick rate');
|
|
|
-%plot([-2 10],[0 0],':','color','k');
|
|
|
-plot([0 0],[-2 8],':','color','k','linewidth',0.75);
|
|
|
-plot([earlylicks(1) earlylicks(2)],[7.3 7.3],'color','k','linewidth',0.75);
|
|
|
-axis([-2 12 0 7.5]);
|
|
|
-xlabel('Seconds from reward delivery');
|
|
|
-ylabel('Licks/s');
|
|
|
-legend('Sucrose trials','Maltodextrin trials');
|
|
|
-
|
|
|
-
|
|
|
-%% plotting ILI
|
|
|
-sucrose=[1 0.6 0.1];
|
|
|
-maltodextrin=[.9 0.3 .9];
|
|
|
-water=[0.00 0.75 0.75];
|
|
|
-total=[0.3 0.1 0.8];
|
|
|
-exc=[0 113/255 188/255];
|
|
|
-inh=[240/255 0 50/255];
|
|
|
-xaxis=(startinterval:endinterval);
|
|
|
-
|
|
|
-subplot(2,2,3);
|
|
|
-hold on;
|
|
|
-errorbar(xaxis,Lick.ILI1(startinterval:endinterval,1),Lick.ILI1(startinterval:endinterval,2),'*','Color',sucrose,'linewidth',1.5);
|
|
|
-errorbar(xaxis,Lick.ILI2(startinterval:endinterval,1),Lick.ILI2(startinterval:endinterval,2),'*','Color',maltodextrin,'linewidth',1.5);
|
|
|
-xlabel('Lick Interval #');
|
|
|
-ylabel('Duration (s)');
|
|
|
-title(['Interlick intervals'])
|
|
|
-axis([1 30 0.13 0.19]);
|
|
|
-legend('Sucrose trials','Maltodextrin trials','location','northwest');
|
|
|
-
|
|
|
-subplot(4,4,15);
|
|
|
-hold on;
|
|
|
-errorbar(2,nanmean(Lick.ILI1(startinterval:endinterval,1)),nanste(Lick.ILI1(startinterval:endinterval,1),1),'*','Color',sucrose,'linewidth',1.5);
|
|
|
-errorbar(2,nanmean(Lick.ILI2(startinterval:endinterval,1)),nanste(Lick.ILI2(startinterval:endinterval,1),1),'*','Color',maltodextrin,'linewidth',1.5);
|
|
|
-if R_2R.LicksEarlyStats{2,7}<0.05
|
|
|
- plot(2,nanmean(Lick.ILI2(startinterval:endinterval,1))+0.005,'*','Color','k','MarkerSize',5);
|
|
|
-end
|
|
|
-set(gca,'xtick',[]);
|
|
|
-axis([1.5 2.5 0.14 0.17]);
|
|
|
-
|
|
|
-
|
|
|
-%% plotting sucrose preferences
|
|
|
-
|
|
|
-%Plot sucrose preference
|
|
|
-
|
|
|
-%colors
|
|
|
-NAc=[0.5 0.1 0.8];
|
|
|
-VP=[0.3 0.7 0.1];
|
|
|
-
|
|
|
-%data
|
|
|
-x=[1 2];
|
|
|
-NAcPref{1}=[81.7 81.3];
|
|
|
-NAcPref{2}=[77 73.9];
|
|
|
-NAcPref{3}=[37.4 74.6];
|
|
|
-NAcPref{4}=[71 95.6];
|
|
|
-NAcPref{5}=[89 83.6];
|
|
|
-NAcPref{6}=[94 93];
|
|
|
-VPPref{1}=[59.6 78.8];
|
|
|
-VPPref{2}=[88.8 85.8];
|
|
|
-VPPref{3}=[71.2 89];
|
|
|
-VPPref{4}=[87 76.6];
|
|
|
-VPPref{5}=[85.2 84.1];
|
|
|
-
|
|
|
-subplot(2,4,3);
|
|
|
-hold on;
|
|
|
-%do the first 2 first in order to get the legend right
|
|
|
-plot(x,NAcPref{1},'Marker','o','MarkerFaceColor',NAc,'LineWidth',1,'Color',NAc);
|
|
|
-plot(x,VPPref{1},'Marker','o','MarkerFaceColor',VP,'LineWidth',1,'Color',VP);
|
|
|
-
|
|
|
-for i=2:length(NAcPref)
|
|
|
- plot(x,NAcPref{i},'Marker','o','MarkerFaceColor',NAc,'LineWidth',1,'Color',NAc);
|
|
|
-end
|
|
|
-
|
|
|
-for i=2:length(VPPref)
|
|
|
- plot(x,VPPref{i},'Marker','o','MarkerFaceColor',VP,'LineWidth',1,'Color',VP);
|
|
|
-end
|
|
|
-
|
|
|
-axis([0.7 2.2 0 100]);
|
|
|
-title('Two-bottle choice');
|
|
|
-xlabel('Initial Final');
|
|
|
-ylabel('% sucrose consumption');
|
|
|
-legend('NAc rat','VP rat','location','southeast');
|
|
|
-plot([0 3],[50 50],':','color','k','linewidth',0.75);
|
|
|
-set(gca,'xtick',[])
|
|
|
-
|
|
|
-
|
|
|
-%% licks dependent on previous trial
|
|
|
-figure;
|
|
|
-
|
|
|
-Xaxis=[-2 12];
|
|
|
-Ishow=find(Tm>=Xaxis(1) & Tm<=Xaxis(2));
|
|
|
-time1=Tm(Ishow);
|
|
|
-c=[-1000 7500];ClimE=sign(c).*abs(c).^(1/4);%ColorMapExc
|
|
|
-colormap(jet);
|
|
|
-
|
|
|
-%colors
|
|
|
-sucrose=[.95 0.55 0.15];
|
|
|
-maltodextrin=[.9 0.3 .9];
|
|
|
-water=[0.00 0.75 0.75];
|
|
|
-total=[0.3 0.1 0.8];
|
|
|
-inh=[0.1 0.021154 0.6];
|
|
|
-exc=[0.9 0.75 0.205816];
|
|
|
-NAc=[0.5 0.1 0.8];
|
|
|
-VP=[0.3 0.7 0.1];
|
|
|
-
|
|
|
-%extra colors to make a gradient
|
|
|
-sucrosem=[.98 0.8 0.35];
|
|
|
-sucrosel=[1 1 0.4];
|
|
|
-maltodextrinm=[1 0.75 1];
|
|
|
-maltodextrinl=[1 0.8 1];
|
|
|
-
|
|
|
-Ev2=strcmp('RD1P1', Lick.Erefnames);
|
|
|
-Ev1=strcmp('RD1P2', Lick.Erefnames);
|
|
|
-Ev4=strcmp('RD2P1', Lick.Erefnames);
|
|
|
-Ev3=strcmp('RD2P2', Lick.Erefnames);
|
|
|
-
|
|
|
-
|
|
|
-psth1=nanmean(Lick.Ev(Ev1).PSTHraw(:,Ishow),1);
|
|
|
-sem1=nanste(Lick.Ev(Ev1).PSTHraw(:,Ishow),1); %calculate standard error of the mean
|
|
|
-up1=psth1+sem1;
|
|
|
-down1=psth1-sem1;
|
|
|
-
|
|
|
-psthE=nanmean(Lick.Ev(Ev2).PSTHraw(:,Ishow),1);
|
|
|
-semE=nanste(Lick.Ev(Ev2).PSTHraw(:,Ishow),1); %calculate standard error of the mean
|
|
|
-upE=psthE+semE;
|
|
|
-downE=psthE-semE;
|
|
|
-
|
|
|
-psth3=nanmean(Lick.Ev(Ev3).PSTHraw(:,Ishow),1);
|
|
|
-sem3=nanste(Lick.Ev(Ev3).PSTHraw(:,Ishow),1); %calculate standard error of the mean
|
|
|
-up3=psth3+sem3;
|
|
|
-down3=psth3-sem3;
|
|
|
-
|
|
|
-psth4=nanmean(Lick.Ev(Ev4).PSTHraw(:,Ishow),1);
|
|
|
-sem4=nanste(Lick.Ev(Ev4).PSTHraw(:,Ishow),1); %calculate standard error of the mean
|
|
|
-up4=psth4+sem4;
|
|
|
-down4=psth4-sem4;
|
|
|
-
|
|
|
-%plotting
|
|
|
-subplot(1,1,1);
|
|
|
-hold on;
|
|
|
-plot(time1,psth1,'Color',sucrosem,'linewidth',1);
|
|
|
-plot(time1,psthE,'Color',sucrose,'linewidth',1);
|
|
|
-plot(time1,psth3,'Color',maltodextrinm,'linewidth',1);
|
|
|
-plot(time1,psth4,'Color',maltodextrin,'linewidth',1);
|
|
|
-patch([time1,time1(end:-1:1)],[up1,down1(end:-1:1)],sucrosem,'EdgeColor','none');alpha(0.5);
|
|
|
-patch([time1,time1(end:-1:1)],[upE,downE(end:-1:1)],sucrose,'EdgeColor','none');alpha(0.5);
|
|
|
-patch([time1,time1(end:-1:1)],[up3,down3(end:-1:1)],maltodextrinm,'EdgeColor','none');alpha(0.5);
|
|
|
-patch([time1,time1(end:-1:1)],[up4,down4(end:-1:1)],maltodextrin,'EdgeColor','none');alpha(0.5);
|
|
|
-title('Mean lick rate');
|
|
|
-%plot([-2 10],[0 0],':','color','k');
|
|
|
-plot([0 0],[-2 8],':','color','k','linewidth',0.75);
|
|
|
-axis([-2 12 0 7.5]);
|
|
|
-xlabel('Seconds post first rewarded lick');
|
|
|
-ylabel('Licks/s');
|
|
|
-legend('Sucrose after mal','Sucrose after suc','Maltodextrin after mal','Maltodextrin after suc');
|
|
|
-
|
|
|
-
|
|
|
-save('R_2R.mat','R_2R');
|