OSCR

Experience and behavior modulate piriform cortex odor representation in freely moving mice.

Code ↔ Paper

5 matches between paragraphs of the paper and lines of its authors' code, computed by the harvester (lexical-v1). Click a colored paragraph or line to see its counterpart.

The 5 matches
  1. [1] § STAR★Methods › Method details › Behavioral pose estimation ↔ data_sample/responseExtraction_Behavior.m, lines 191–231 · score 0.78 · confidence cutoff, left ear, tracked points, subtracting, displacement, raw
  2. [2] § STAR★Methods › Method details › Behavioral pose estimation ↔ data_sample/responseExtraction_Behavior.m, lines 10–54 · score 0.65 · behavioral scores, behavior trace, prominence, framerate, confidence, match
  3. [3] § STAR★Methods › Method details › Response extraction ↔ data_sample/responseExtraction_Behavior.m, lines 10–54 · score 0.64 · Pre window, post odor, pre trial, peak, timepoint, shifting
  4. [4] § STAR★Methods › Method details › Lifetime sparseness and tuning ↔ Fig_S6/best_tuning_figs.m, lines 43–105 · score 0.62 · narrow tuning, median, sparseness, S6, lifetime, sparsely
  5. [5] § STAR★Methods › Method details › Calcium trace extraction ↔ data_sample/responseExtraction_Behavior.m, lines 528–604 · score 0.59 · spatial footprints, deconvolved trace, min, motion, correlation

Paper

Loaded from Europe PMC by your browser, not stored by OSCR: doi.org · Europe PMC

The paper is loaded when this pane is shown.

The authors' code

MATLAB · 730 lines · 47 KB · GPL-3.0 · 4 matches

  1. clear;
  2. % Note before starting; mouse NEC273332 does not have any behavioral data,
  3. % given the current way this script is written, a behavior file is
  4. % expected, so I have supplied a dummy file in the main directory. Didn't
  5. % want to use seperate trace extraction scripts for behavior/no behahvior
  6. % and I haven't updated this code to have behavioral flags in it. Because
  7. % of this, mouse NEC273332 is removed from the behavior tables at the end
  8. % of the code before saving the output files.
  10. %% Input Parameters
  12. % ***READ THROUGH THIS SECTION FIRST***
  13. % Some alternate methods commented in the code, otherwise just change
  14. % parameters below. All input parameters are saved in a structure termed
  15. % "inputValue" and have descriptions below.
  17. % Key file for sorting trial days, framerates, animal number, etc.
  18. inputValue.KeyTable = readtable('data_sample\Key.csv');
  19. % Folder where raw files are; easy to just use the same one as the key file
  20. myFolder = '.\data_sample';
  22. % Settings for smoothing raw data if desired; toggle for choosing to use
  23. % method and set value for number of frames to smooth over
  24. inputValue.SmoothToggle = 0; % 1 to smooth; 0 to not smooth
  25. inputValue.SmoothWindow = 3; % number of frames to smooth over if toggled on
  27. % Detection settings; cutoffs for DF detection and thresholding optios if
  28. % combining with a z-cutoff; peak finder settings included
  29. % for both combined detection and for whole trace event detection
  31. inputValue.SDcutoff = 2.5; % SD cutoff in DF detection; same for excitation and inhibition as of now
  32. inputValue.Zcutoff_combinedDetect = 1.0; % z score cutoff for combined detection with DF
  33. inputValue.Zcutoff_wholeTrace = 1; % z score cutoff for whole trace peak and activeness detection
  34. inputValue.PeakDistance = 5; % min distance between peaks IN FRAMES; avoids double counting peaks at flat areas, default 5 for 1s with gcamp6s @ 5 fps
  35. inputValue.Prominence = 0.5; % measure of how high peaks stand out (z-scored) from neighbers; also avoids double counting flat areas
  37. % trace details; framerate input, inputValue.timePoints to look at for DF
  38. % calculations; specifications for pre/post windows; bin size for whole
  39. % trial activity analysis
  40. inputValue.preTrial = 2; % time for pre-trial df measurement in seconds
  41. inputValue.postTrial = 5; % time for post-trial df measurement in seconds
  42. inputValue.trialTrace_Pre = 15; % time for trace extraction pre odor in seconds
  43. inputValue.trialTrace_Post = 25; % time for trace extraction post odor in seconds
  44. inputValue.totalZ_Bins = 300; % length of time IN SECONDS for binning zPeaks across whole trace
  45. inputValue.totalZ_Bins_max = 20; % cap value to z bins to avoid mis-matched sizing; make larger than biggest possible
  46. inputValue.shifter_maxFrames = 50; % total frames to move shifter DF value past OG timepoint
  47. inputValue.shifter_pre = 2; % time for pre-trial on shifter in seconds
  48. inputValue.shifter_post = 5; % time for post-trial on shifter in seconds
  49. inputValue.preValue_shift = 15; % time before timepoints in seconds to calculate pre-window values
  50. inputValue.behaviorTrace_Pre = 25; % time for trace extraction of pre behavior in seconds
  52. % settings for behavioral scoring from DLC files
  53. inputValue.DLC_cutoff = .95; % confidence cutoff for using DLC coord values
  54. inputValue.frate_BEH = 60; % set value for behavior camera framerate; has some jitter in actuality, but this is only used for trial window determination
  56. %% Things to be done globally before loop time
  58. % Initialize empty output tables; grows as things get added with each loop;
  59. % matlab will complain about this, but i don't have a better solution as of yet
  60. OutputTable = cell2table(cell(0,42), 'VariableNames', {'Animal','BehaviorGroup','State','Day','Odor','Abs_CellNumber','CellReg_Index',...
  61. 'Abs_TrialN','Stim_TrialN','DeltaValue_Max','DeltaValue_Mean','DeltaValue_Max_Z','DeltaValue_Min','Responders_EX','Responders_IN',...
  62. 'Responders_CombinedEX','ZPeaksN_byTrial','MotionPost','MotionPre','NoseDisp','MotionCorr','Pre_DeltaValue_Mean','Pre_DeltaValue_Max_Z',...
  63. 'Pre_DeltaValue_Max','Pre_DeltaValue_Min','Pre_Responders_CombinedEX','Pre_Responders_EX','Pre_Responders_IN','Pre_ZPeaksN_byTrial',...
  64. 'Pre_MotionPost','Pre_MotionPre','Pre_NoseDisp','Pre_MotionCorr','DeltaValue_Max_adjustNose','Responders_EX_adjustNose','Responders_CombinedEX_adjustNose',...
  65. 'DeltaValue_MaxShifter','DeltaValue_MaxZShifter','Responders_CombinedEX_Shifter','Pre_DeltaValue_MaxShifter','Pre_DeltaValue_MaxZShifter','Pre_Responders_CombinedEX_Shifter'});
  66. TrialTrace_Table = cell2table(cell(0,11), 'VariableNames', {'Animal','BehaviorGroup','State','Day','Odor','Abs_CellNumber',...
  67. 'CellReg_Index','Abs_TrialN','Stim_TrialN','Ztrace_trial_final','Rawtrace_trial_final'});
  68. Pre_TrialTrace_Table = cell2table(cell(0,11), 'VariableNames', {'Animal','BehaviorGroup','State','Day','Odor','Abs_CellNumber',...
  69. 'CellReg_Index','Abs_TrialN','Stim_TrialN','Pre_Ztrace_trial_final','Pre_Rawtrace_trial_final'});
  70. WholeTrace_Table = cell2table(cell(0,9), 'VariableNames', {'Animal','BehaviorGroup','State','Day',...
  71. 'Abs_CellNumber','CellReg_Index','RecordingLength','Sum_All_PeaksN','Peaks_Bins'});
  72. BEHTrace_Table = cell2table(cell(0,9), 'VariableNames', {'Animal','BehaviorGroup','State','Day','Odor'...
  73. ,'Abs_TrialN','Stim_TrialN','Motion_trial_final','NoseDisp_trial_final'});
  74. ZTraces = {};
  75. Peaks_Array = {};
  76. Footprints_MasterTable = cell2table(cell(0,7), 'VariableNames',{'Animal','BehaviorGroup','State','Day','Abs_CellNumber','CellReg_Index','Footprint'});
  77. Behavior_Array = {};
  79. % Check to make sure that folder actually exists. Warn user if it doesn't.
  80. if ~isdir(myFolder)
  81. errorMessage = sprintf('Error: The following folder does not exist:\n%s', myFolder);
  82. uiwait(warndlg(errorMessage));
  83. return;
  84. end
  85. % Get a list of all files in the folder with the desired file name pattern.
  86. Deconvolved_Trace_Pattern = fullfile(myFolder, '*DeconTrace.csv'); % Deconvolved traces
  87. Deconvolved_Traces_List = dir(Deconvolved_Trace_Pattern);
  88. Raw_Trace_Pattern = fullfile(myFolder, '*RawTrace.csv'); % Raw traces
  89. Raw_Trace_List = dir(Raw_Trace_Pattern);
  90. Timestamp_Pattern = fullfile(myFolder, '*timeStamps.csv'); % Timestamps
  91. Timestamp_List = dir(Timestamp_Pattern);
  92. Note_Pattern = fullfile(myFolder, '*notes.csv'); % Event points with stamps
  93. Note_List = dir(Note_Pattern);
  94. Index_Pattern = fullfile(myFolder, '*index.csv'); % Deconvolved traces
  95. Index_List = dir(Index_Pattern);
  96. Footprints_Pattern = fullfile(myFolder,'*.mat'); % footprints files
  97. Footprints_List = dir(Footprints_Pattern);
  98. Behavior_Pattern = fullfile(myFolder, '*Behavior.csv'); % behavior values
  99. Behavior_List = dir(Behavior_Pattern);
  100. BehaviorStamps_Pattern = fullfile(myFolder, '*stampsBeh.csv'); % behavior stamps
  101. BehaviorStamps_List = dir(BehaviorStamps_Pattern);
  103. %% Loop through matching traces/timestamps
  104. % make sure to follow formatting guide here; organized so that files are
  105. % listed in the folder in the correct ordered to match traces with their
  106. % respective timestamps, notes, and index
  108. %typically runs to length(Deconvolved_Traces_List); alter to manual
  109. %numbers if you only want to run a specific set of animals
  110. for k = 1:length(Deconvolved_Traces_List)
  112. baseDecon_TraceName = Deconvolved_Traces_List(k).name; % base name of file
  113. fullDecon_TraceName = fullfile(myFolder, baseDecon_TraceName); % file name + relative folder directory
  114. inputValue.deconvolvedTrace = load(fullDecon_TraceName); % loaded trace
  116. baseRaw_TraceName = Raw_Trace_List(k).name; % base name of file
  117. fullRaw_TraceName = fullfile(myFolder, baseRaw_TraceName); % file name + relative folder directory
  118. inputValue.rawTrace = load(fullRaw_TraceName); % loaded file
  120. baseTimestamp_Name = Timestamp_List(k).name; % base name of file
  121. fullTimestamp_Name = fullfile(myFolder, baseTimestamp_Name); % file name + relative folder directory
  122. inputValue.timestamp = readtable(fullTimestamp_Name); % loaded file
  124. baseNote_Name = Note_List(k).name; % base name of file
  125. fullNote_Name = fullfile(myFolder, baseNote_Name); % file name + relative folder directory
  126. inputValue.notes = readtable(fullNote_Name); % loaded file
  128. baseIndex_Name = Index_List(k).name; % base name of file
  129. fullIndex_Name = fullfile(myFolder, baseIndex_Name); % file name + relative folder directory
  130. inputValue.Index = load(fullIndex_Name); % loaded file
  132. baseFootprints_Name = Footprints_List(k).name; % base name of file
  133. fullFootprints_Name = fullfile(myFolder, baseFootprints_Name); % file name + relative folder directory
  134. inputValue.Footprints = load(fullFootprints_Name); % loaded file
  136. baseBehavior_Name = Behavior_List(k).name; % base name of file
  137. fullBehavior_Name = fullfile(myFolder, baseBehavior_Name); % file name + relative folder directory
  138. inputValue.Behavior = readmatrix(fullBehavior_Name, 'NumHeaderLines', 3); % loaded file
  139. inputValue.Behavior = inputValue.Behavior(:,2:end);
  141. baseBehaviorStamps_Name = BehaviorStamps_List(k).name; % base name of file
  142. fullBehaviorStamps_Name = fullfile(myFolder, baseBehaviorStamps_Name); % file name + relative folder directory
  143. inputValue.BehaviorStamps = readtable(fullBehaviorStamps_Name); % loaded file
  145. % have to change/reformat scope timestamps based on scope version number; coded to V4,
  146. % change the column calls for the vectors if the names be different
  147. Times_Vector = table2array(inputValue.notes(:,1));
  148. Stamps_TimeVector = inputValue.timestamp.('TimeStamp_ms_');
  149. Stamps_FrameVector = inputValue.timestamp.('FrameNumber');
  151. % generates timepoints from the notes/timestamps files; adjusts frame value for downsample input
  152. for i = 1:length(Times_Vector)
  153. time_holder = Times_Vector(i);
  154. [val,idx]=min(abs(Stamps_TimeVector-time_holder));
  155. inputValue.timePoints(i) = Stamps_FrameVector(idx);
  156. end
  157. inputValue.downSampleFactor = table2array(inputValue.KeyTable(k,'StampDownsampleFactor')); % used to convert time stamps if using downsampled data
  158. inputValue.frate = table2array(inputValue.KeyTable(k,'FrameRateFinal')); %frames per second
  159. inputValue.timePoints = round(inputValue.timePoints ./ inputValue.downSampleFactor); %downsample timepoints
  161. % generates timepoints for behavior file from the notes/timestamps files
  162. Stamps_TimeVector_BEH = inputValue.BehaviorStamps.('TimeStamp_ms_');
  163. Stamps_FrameVector_BEH = inputValue.BehaviorStamps.('FrameNumber');
  164. for i = 1:length(Times_Vector)
  165. time_holder = Times_Vector(i);
  166. [val,idx]=min(abs(Stamps_TimeVector_BEH-time_holder));
  167. inputValue.timePoints_BEH(i) = Stamps_FrameVector_BEH(idx);
  168. end
  170. % Behavior stuff for total file
  171. % eudlidean displacement of all tracked components from frame to frame
  172. %avg_beh_FR = max(inputValue.BehaviorStamps.('FrameNumber')) / (max(inputValue.BehaviorStamps.('TimeStamp_ms_')) / 1000);
  173. % find total number of tracked points, initialize empty arrays
  174. total_n = (size(inputValue.Behavior,2))/3;
  175. euclid_all = zeros(length(inputValue.Behavior),total_n);
  176. log_all = zeros(length(inputValue.Behavior),total_n);
  177. % for each set of x/y points, find euclidean distance from point to
  178. % point for each frame recorded
  179. for i = 1:total_n
  180. current_coords = inputValue.Behavior(:,((3*i)-2):((3*i)-1));
  181. log_all(:,i) = inputValue.Behavior(:,(3*i)) > inputValue.DLC_cutoff;
  182. for ii = 1:(length(current_coords)-1)
  183. euc_distance_scope_point = sqrt((current_coords(ii+1,1)-current_coords(ii,1))^2 + ...
  184. (current_coords(ii+1,2)-current_coords(ii,2))^2 );
  185. euclid_scope(ii+1) = euc_distance_scope_point;
  186. end
  187. euclid_all(:,i) = euclid_scope;
  188. clear euclid_scope
  189. end
  191. % remove any points that don't meet the input confidence cutoff and
  192. % calculate average across all tracked points, sum across moving window
  193. % for downsampled version (adjusted to match scope final frate)
  194. euclid_all(log_all == 0) = NaN;
  195. average_euclid = mean(euclid_all,2,'omitNaN');
  196. euclid_down = movsum(average_euclid,(inputValue.frate_BEH/inputValue.frate));
  198. % nose displacement from either ear (use left if possible)
  199. log_nose_left = sum(inputValue.Behavior(:,[3,6]) > inputValue.DLC_cutoff,2) == 2;
  200. log_nose_right = sum(inputValue.Behavior(:,[3,9]) > inputValue.DLC_cutoff,2) == 2;
  201. displacement_nose_left = (inputValue.Behavior(:,2) - inputValue.Behavior(:,5));
  202. displacement_nose_right = (inputValue.Behavior(:,2) - inputValue.Behavior(:,8));
  203. displacement_final = zeros(length(inputValue.Behavior),1);
  204. % using left ear as default; only use right if its the only one, averaging
  205. % when both there can cause some weird jitter in the signal with it coming
  206. % and going from in frame
  207. for i = 1:length(inputValue.Behavior)
  208. if log_nose_left(i) == 1 && log_nose_right(i) == 1
  209. displacement_final(i) = displacement_nose_left(i);
  210. elseif log_nose_left(i) == 1 && log_nose_right(i) == 0
  211. displacement_final(i) = displacement_nose_left(i);
  212. elseif log_nose_left(i) == 0 && log_nose_right(i) == 1
  213. displacement_final(i) = displacement_nose_right(i);
  214. elseif log_nose_left(i) == 0 && log_nose_right(i) == 0
  215. displacement_final(i) = NaN;
  216. end
  217. end
  218. displacement_final = displacement_final .* -1;
  219. clear log_nose_left log_nose_right
  220. % Zscoring for deconvolved values; input array, sample std dev (not pop), dimension (rows = 2)
  221. Decon_Z = zscore(inputValue.deconvolvedTrace, 0, 2);
  222. Raw_Z = zscore(inputValue.rawTrace, 0, 2);
  223. % Smoothing function if used on raw data; input array, dimension (rows = 2), method, window
  224. if inputValue.SmoothToggle == 1
  225. RawTrace_PostSmooth = smoothdata(inputValue.rawTrace, 2, 'movmean', inputValue.SmoothWindow);
  226. else if inputValue.SmoothToggle == 0
  227. RawTrace_PostSmooth = inputValue.rawTrace;
  228. end
  229. end
  230. % subtract min value from all values to shift to avoid negative values
  231. RawTrace_PostSmooth = RawTrace_PostSmooth - min(RawTrace_PostSmooth, [], 2);
  233. % Peak detection from z-scored data; coded by britgod
  235. allZPeaks = zeros(size(Decon_Z)); %peak location and size saved to this array
  236. allZPeaks_logical = zeros(size(Decon_Z));
  237. allrawPeaks = zeros(size(Decon_Z));
  239. for ii = 1:size(Decon_Z, 1)
  240. [dummy_pks, dummy_locs] = findpeaks(Decon_Z(ii,:),'MinPeakHeight', inputValue.Zcutoff_wholeTrace, 'MinPeakWidth', inputValue.PeakDistance, 'MinPeakProminence', inputValue.Prominence);
  241. placeholderZ = zeros(1,length(Decon_Z));
  242. placeholderZ(dummy_locs) = dummy_pks;
  243. placeholderraw = zeros(1,length(Decon_Z));
  244. placeholderraw(dummy_locs) = Decon_Z(ii,dummy_locs);
  246. allZPeaks(ii,:) = placeholderZ;
  247. allZPeaks_logical(ii,:) = (placeholderZ >0);
  248. allrawPeaks(ii,:) = placeholderraw;
  250. clear dummy_pks dummy_locs placeholder
  251. end
  253. PeakTotal_perCell = sum(allZPeaks_logical,2);
  254. Zabove_threshold = Decon_Z > inputValue.Zcutoff_wholeTrace;
  256. % DF calculation at stimulus inputValue.timePoints for raw signal
  257. % initializing empty arrays
  258. preMean_Z = zeros(size(Decon_Z,1),size(inputValue.timePoints,2));
  259. postMaxV_Z = zeros(size(Decon_Z,1),size(inputValue.timePoints,2));
  260. pre_stdD = zeros(size(Decon_Z,1),size(inputValue.timePoints,2));
  261. preMean = zeros(size(Decon_Z,1),size(inputValue.timePoints,2));
  262. postMean = zeros(size(Decon_Z,1),size(inputValue.timePoints,2));
  263. postMaxV = zeros(size(Decon_Z,1),size(inputValue.timePoints,2));
  264. postMinV = zeros(size(Decon_Z,1),size(inputValue.timePoints,2));
  265. Responders_Zthreshold = zeros(size(Decon_Z,1),size(inputValue.timePoints,2));
  266. ZPeaksN_timepoints = zeros(size(Decon_Z,1),size(inputValue.timePoints,2));
  267. Ztrace_trial = cell(1,size(inputValue.timePoints,2));
  268. Rawtrace_trial = cell(1,size(inputValue.timePoints,2));
  269. Motion_trial = cell(1,size(inputValue.timePoints,2));
  270. NoseDisp_trial = cell(1,size(inputValue.timePoints,2));
  271. preMotion = zeros(size(Decon_Z,1),size(inputValue.timePoints,2));
  272. postMotion = zeros(size(Decon_Z,1),size(inputValue.timePoints,2));
  273. postNose = zeros(size(Decon_Z,1),size(inputValue.timePoints,2));
  274. postNose_IDX = zeros(1,size(inputValue.timePoints,2));
  276. % check for NaN in timepoints (dropped trials); fill those as NaN, then
  277. % actually pull real values from trials that were not dropped
  278. for ii = 1:size(inputValue.timePoints,2)
  279. if inputValue.timePoints(ii) == 0
  280. preMean_Z(:,ii) = NaN(size(inputValue.deconvolvedTrace,1),1);
  281. postMaxV_Z(:,ii) = NaN(size(inputValue.deconvolvedTrace,1),1);
  282. pre_stdD(:,ii) = NaN(size(inputValue.deconvolvedTrace,1),1);
  283. preMean(:,ii) = NaN(size(inputValue.deconvolvedTrace,1),1);
  284. postMean(:,ii) = NaN(size(inputValue.deconvolvedTrace,1),1);
  285. postMaxV(:,ii) = NaN(size(inputValue.deconvolvedTrace,1),1);
  286. postMinV(:,ii) = NaN(size(inputValue.deconvolvedTrace,1),1);
  287. Responders_Zthreshold(:,ii) = NaN(size(inputValue.deconvolvedTrace,1),1);
  288. ZPeaksN_timepoints(:,ii) = NaN(size(inputValue.deconvolvedTrace,1),1);
  289. Ztrace_trial{ii} = NaN(size(inputValue.deconvolvedTrace,1),((inputValue.trialTrace_Pre*inputValue.frate)+(inputValue.trialTrace_Post*inputValue.frate)));
  290. Rawtrace_trial{ii} = NaN(size(inputValue.deconvolvedTrace,1),((inputValue.trialTrace_Pre*inputValue.frate)+(inputValue.trialTrace_Post*inputValue.frate)));
  291. Motion_trial{ii} = NaN(size(inputValue.deconvolvedTrace,1),((inputValue.behaviorTrace_Pre*inputValue.frate)+(inputValue.trialTrace_Post*inputValue.frate)));
  292. NoseDisp_trial{ii} = NaN(size(inputValue.deconvolvedTrace,1),((inputValue.behaviorTrace_Pre*inputValue.frate)+(inputValue.trialTrace_Post*inputValue.frate)));
  293. preMotion(:,ii) = NaN(size(inputValue.deconvolvedTrace,1),1);
  294. postMotion(:,ii) = NaN(size(inputValue.deconvolvedTrace,1),1);
  295. postNose(:,ii) = NaN(size(inputValue.deconvolvedTrace,1),1);
  296. else
  297. % first group is taking raw or ztrace values from timepoints and
  298. % splitting to new arrays; trial measures include pre window while
  299. Ztrace_trial_holder = Decon_Z(:,(inputValue.timePoints(ii)-(inputValue.frate * inputValue.trialTrace_Pre)):(inputValue.timePoints(ii) + ((inputValue.frate * inputValue.trialTrace_Post))-1));
  300. Ztrace_trial{ii} = Ztrace_trial_holder;
  301. Rawtrace_trial_holder = RawTrace_PostSmooth(:,(inputValue.timePoints(ii)-(inputValue.frate * inputValue.trialTrace_Pre)):(inputValue.timePoints(ii) + ((inputValue.frate * inputValue.trialTrace_Post))-1));
  302. Rawtrace_trial{ii} = Rawtrace_trial_holder;
  303. Motion_trial_holder = average_euclid((inputValue.timePoints_BEH(ii)-(inputValue.frate_BEH * inputValue.behaviorTrace_Pre)):(inputValue.timePoints_BEH(ii) + ((inputValue.frate_BEH * inputValue.trialTrace_Post))-1));
  304. Motion_trial{ii} = Motion_trial_holder.';
  305. NoseDisp_trial_holder = displacement_final((inputValue.timePoints_BEH(ii)-(inputValue.frate_BEH * inputValue.behaviorTrace_Pre)):(inputValue.timePoints_BEH(ii) + ((inputValue.frate_BEH * inputValue.trialTrace_Post))-1));
  306. NoseDisp_trial{ii} = NoseDisp_trial_holder.';
  308. % second group is calculating values of interest around timepoints;
  309. % includes pre/post means, max's, responders, etc.
  310. pre_stdD(:,ii) = std(RawTrace_PostSmooth(:,((inputValue.timePoints(ii)-(inputValue.preTrial * inputValue.frate))):(inputValue.timePoints(ii)-1)), 0, 2);
  311. preMean(:,ii) = mean(RawTrace_PostSmooth(:,((inputValue.timePoints(ii)-(inputValue.preTrial * inputValue.frate))):(inputValue.timePoints(ii)-1)), 2);
  312. preMean_Z(:,ii) = mean(Raw_Z(:,((inputValue.timePoints(ii)-(inputValue.preTrial * inputValue.frate))):(inputValue.timePoints(ii)-1)), 2);
  313. postMean(:,ii) = mean(RawTrace_PostSmooth(:,(inputValue.timePoints(ii)):((inputValue.timePoints(ii)-1)+(inputValue.postTrial*inputValue.frate))), 2);
  314. [postMaxHolder,postMaxIndex] = max(RawTrace_PostSmooth(:,(inputValue.timePoints(ii)):((inputValue.timePoints(ii)-1)+(inputValue.postTrial*inputValue.frate))), [], 2);
  315. postMaxV(:,ii) = postMaxHolder;
  316. [postMaxZHolder,postMaxZIndex] = max(Raw_Z(:,(inputValue.timePoints(ii)):((inputValue.timePoints(ii)-1)+(inputValue.postTrial*inputValue.frate))), [], 2);
  317. postMaxV_Z(:,ii) = postMaxZHolder;
  318. postMinHolder = min(RawTrace_PostSmooth(:,(inputValue.timePoints(ii)):((inputValue.timePoints(ii)-1)+(inputValue.postTrial*inputValue.frate))), [], 2);
  319. postMinV(:,ii) = postMinHolder;
  320. zMaxHolder = max(Decon_Z(:,(inputValue.timePoints(ii)):((inputValue.timePoints(ii)-1)+(inputValue.postTrial*inputValue.frate))), [], 2);
  321. Responders_Zthreshold(:,ii) = zMaxHolder;
  322. ZPeaksN_timepoints(:,ii) = sum(allZPeaks_logical(:,(inputValue.timePoints(ii)):((inputValue.timePoints(ii)-1)+(inputValue.postTrial*inputValue.frate))),2);
  323. %DLC behavior things; nose displacement is an average +/- 2 frames
  324. %on either side of the displacment peak in the post trial window
  325. preMotion(:,ii) = repmat(mean(average_euclid((inputValue.timePoints_BEH(ii)-(inputValue.preTrial * inputValue.frate_BEH)):(inputValue.timePoints_BEH(ii)-1))),size(Decon_Z,1),1);
  326. postMotion(:,ii) = repmat(mean(average_euclid(inputValue.timePoints_BEH(ii):((inputValue.timePoints_BEH(ii)-1)+(inputValue.postTrial*inputValue.frate_BEH)))),size(Decon_Z,1),1);
  327. [postNose_max,postNose_max_idx] = max(displacement_final(inputValue.timePoints_BEH(ii):((inputValue.timePoints_BEH(ii)-1)+(inputValue.postTrial*inputValue.frate_BEH))));
  328. postNose(:,ii) = mean(displacement_final((inputValue.timePoints_BEH(ii)+postNose_max_idx-3):(inputValue.timePoints_BEH(ii)+postNose_max_idx+1)),'omitNaN');
  329. postNose_IDX(:,ii) = postNose_max_idx;
  330. end
  331. end
  333. % new set of timepoints for shifting delta window to time of nose
  334. % raising minus 3 frames as a small buffer to the behavior point
  336. inputValue.timePoints_BEH_New = (inputValue.timePoints_BEH + postNose_IDX);
  338. for q = 1:length(Times_Vector)
  339. time_holder = inputValue.timePoints_BEH_New(q);
  340. [val,idx]=min(abs(Stamps_FrameVector_BEH-time_holder));
  341. inputValue.times_BEH_new(q) = Stamps_TimeVector_BEH(idx);
  342. end
  344. for r = 1:length(Times_Vector)
  345. time_holder = inputValue.times_BEH_new(r);
  346. [val,idx]=min(abs(Stamps_TimeVector-time_holder));
  347. inputValue.timePoints_BEH_adjustedNose(r) = Stamps_FrameVector(idx);
  348. end
  350. % downsample new adjusted behavior timepoints to match scope frames
  351. inputValue.timePoints_BEH_adjustedNose = round(inputValue.timePoints_BEH_adjustedNose ./ inputValue.downSampleFactor);
  353. % create extra empty arrays and pull stuff of interest from any adjusted timepoints
  354. preMean_adjustNose = zeros(size(Decon_Z,1),size(inputValue.timePoints,2));
  355. postMaxV_adjustNose = zeros(size(Decon_Z,1),size(inputValue.timePoints,2));
  356. pre_stdD_adjustNose = zeros(size(Decon_Z,1),size(inputValue.timePoints,2));
  357. % check for NaN in timepoints (dropped trials); fill those as NaN, then
  358. % actually pull real values from trials that were not dropped
  359. for ii = 1:size(inputValue.timePoints,2)
  360. if inputValue.timePoints(ii) == 0
  361. preMean_adjustNose(:,ii) = NaN(size(inputValue.deconvolvedTrace,1),1);
  362. postMaxV_adjustNose(:,ii) = NaN(size(inputValue.deconvolvedTrace,1),1);
  363. pre_stdD_adjustNose(:,ii) = NaN(size(inputValue.deconvolvedTrace,1),1);
  364. else
  365. pre_stdD_adjustNose(:,ii) = std(RawTrace_PostSmooth(:,((inputValue.timePoints_BEH_adjustedNose(ii)-(inputValue.preTrial * inputValue.frate))):(inputValue.timePoints_BEH_adjustedNose(ii)-1)), 0, 2);
  366. [postMaxHolder_adjustNose,postMaxIndex_adjustNose] = max(RawTrace_PostSmooth(:,(inputValue.timePoints_BEH_adjustedNose(ii)):((inputValue.timePoints_BEH_adjustedNose(ii)-1)+(inputValue.postTrial*inputValue.frate))), [], 2);
  367. postMaxV_adjustNose(:,ii) = postMaxHolder_adjustNose;
  368. preMean_adjustNose(:,ii) = mean(RawTrace_PostSmooth(:,((inputValue.timePoints_BEH_adjustedNose(ii)-(inputValue.preTrial * inputValue.frate))):(inputValue.timePoints_BEH_adjustedNose(ii)-1)), 2);
  369. end
  370. end
  373. % calculate desired outputs
  374. deltaV_mean = postMean - preMean;
  375. deltaV_max_Z = (postMaxV_Z - preMean_Z);
  376. deltaV_max = ((postMaxV - preMean));
  377. deltaV_min = ((preMean - postMinV));
  378. delta_detect_EX = ((postMaxV - preMean) ./ (pre_stdD) > inputValue.SDcutoff);
  379. delta_detect_IN = ((preMean - postMinV) ./ (pre_stdD) > inputValue.SDcutoff);
  380. combined_detectEX = (delta_detect_EX .* (Responders_Zthreshold > inputValue.Zcutoff_combinedDetect));
  381. post_motion_corr = repmat((corr(postMotion(1,:).',postMaxV.','rows','complete')).',1,size(inputValue.timePoints,2));
  382. deltaV_max_adjustNose = (postMaxV_adjustNose-preMean);
  383. delta_detect_EX_adjustNose = ((postMaxV_adjustNose - preMean_adjustNose) ./ (pre_stdD_adjustNose) > inputValue.SDcutoff);
  384. combined_detect_EX_adjustNose = (delta_detect_EX_adjustNose .* (Responders_Zthreshold > inputValue.Zcutoff_combinedDetect));
  386. % DF calculation at time before stimulus inputValue.timePoints;
  387. % post-measure window size used to determine how long pre the normal
  388. % timepoint to set the new, pre-timepoints
  389. Pre_preMean_Z = zeros(size(Decon_Z,1),size(inputValue.timePoints,2));
  390. Pre_postMaxV_Z = zeros(size(Decon_Z,1),size(inputValue.timePoints,2));
  391. Pre__stdD = zeros(size(Decon_Z,1),size(inputValue.timePoints,2));
  392. Pre_Mean = zeros(size(Decon_Z,1),size(inputValue.timePoints,2));
  393. Pre_postMean = zeros(size(Decon_Z,1),size(inputValue.timePoints,2));
  394. Pre_postMaxV = zeros(size(Decon_Z,1),size(inputValue.timePoints,2));
  395. Pre_postMinV = zeros(size(Decon_Z,1),size(inputValue.timePoints,2));
  396. Pre_Responders_Zthreshold = zeros(size(Decon_Z,1),size(inputValue.timePoints,2));
  397. Pre_ZPeaksN_timepoints = zeros(size(Decon_Z,1),size(inputValue.timePoints,2));
  398. Pre_Ztrace_trial = cell(1,size(inputValue.timePoints,2));
  399. Pre_Rawtrace_trial = cell(1,size(inputValue.timePoints,2));
  400. Pre_preMotion = zeros(size(Decon_Z,1),size(inputValue.timePoints,2));
  401. Pre_postMotion = zeros(size(Decon_Z,1),size(inputValue.timePoints,2));
  402. Pre_postNose = zeros(size(Decon_Z,1),size(inputValue.timePoints,2));
  404. % check for NaN in timepoints (dropped trials); fill those as NaN, then
  405. % actually pull real values from trials that were not dropped
  406. for ii = 1:size(inputValue.timePoints,2)
  407. if inputValue.timePoints(ii) == 0
  408. Pre_preMean_Z(:,ii) = NaN(size(inputValue.deconvolvedTrace,1),1);
  409. Pre_postMaxV_Z(:,ii) = NaN(size(inputValue.deconvolvedTrace,1),1);
  410. Pre__stdD(:,ii) = NaN(size(inputValue.deconvolvedTrace,1),1);
  411. Pre_Mean(:,ii) = NaN(size(inputValue.deconvolvedTrace,1),1);
  412. Pre_postMean(:,ii) = NaN(size(inputValue.deconvolvedTrace,1),1);
  413. Pre_postMaxV(:,ii) = NaN(size(inputValue.deconvolvedTrace,1),1);
  414. Pre_postMinV(:,ii) = NaN(size(inputValue.deconvolvedTrace,1),1);
  415. Pre_Responders_Zthreshold(:,ii) = NaN(size(inputValue.deconvolvedTrace,1),1);
  416. Pre_ZPeaksN_timepoints(:,ii) = NaN(size(inputValue.deconvolvedTrace,1),1);
  417. Pre_Ztrace_trial{ii} = NaN(size(inputValue.deconvolvedTrace,1),((inputValue.trialTrace_Pre*inputValue.frate)+(inputValue.trialTrace_Post*inputValue.frate)));
  418. Pre_Rawtrace_trial{ii} = NaN(size(inputValue.deconvolvedTrace,1),((inputValue.trialTrace_Pre*inputValue.frate)+(inputValue.trialTrace_Post*inputValue.frate)));
  419. Pre_preMotion(:,ii) = NaN(size(inputValue.deconvolvedTrace,1),1);
  420. Pre_postMotion(:,ii) = NaN(size(inputValue.deconvolvedTrace,1),1);
  421. Pre_postNose(:,ii) = NaN(size(inputValue.deconvolvedTrace,1),1);
  422. else
  423. % first group is taking raw or ztrace values from timepoints and
  424. % splitting to new arrays; trial measures include pre window while
  425. % behavior is only the freezing window
  426. Ztrace_trial_holder = Decon_Z(:,(inputValue.timePoints(ii)-(inputValue.frate * inputValue.trialTrace_Pre)-(inputValue.frate*inputValue.postTrial)):(inputValue.timePoints(ii) + ((inputValue.frate * inputValue.trialTrace_Post))-1-(inputValue.frate*inputValue.postTrial)));
  427. Pre_Ztrace_trial{ii} = Ztrace_trial_holder;
  428. Rawtrace_trial_holder = RawTrace_PostSmooth(:,(inputValue.timePoints(ii)-(inputValue.frate * inputValue.trialTrace_Pre)-(inputValue.frate*inputValue.postTrial)):(inputValue.timePoints(ii) + ((inputValue.frate * inputValue.trialTrace_Post))-1-(inputValue.frate*inputValue.postTrial)));
  429. Pre_Rawtrace_trial{ii} = Rawtrace_trial_holder;
  431. % second group is calculating values of interest around timepoints;
  432. % includes pre/post means, max's, responders, etc.
  433. timepoints_adjusted = inputValue.timePoints(ii) - (inputValue.preValue_shift * inputValue.frate);
  434. timepoints_adjustedBEH = inputValue.timePoints_BEH(ii) - (inputValue.preValue_shift * inputValue.frate_BEH);
  435. Pre__stdD(:,ii) = std(RawTrace_PostSmooth(:,((timepoints_adjusted-(inputValue.preTrial * inputValue.frate)-(inputValue.frate*inputValue.postTrial))):(timepoints_adjusted-1-(inputValue.frate*inputValue.postTrial))), 0, 2);
  436. Pre_Mean(:,ii) = mean(RawTrace_PostSmooth(:,((timepoints_adjusted-(inputValue.preTrial * inputValue.frate)-(inputValue.frate*inputValue.postTrial))):(timepoints_adjusted-1-(inputValue.frate*inputValue.postTrial))), 2);
  437. Pre_preMean_Z(:,ii) = mean(Raw_Z(:,((timepoints_adjusted-(inputValue.preTrial * inputValue.frate)-(inputValue.frate*inputValue.postTrial))):(timepoints_adjusted-1-(inputValue.frate*inputValue.postTrial))), 2);
  438. Pre_postMean(:,ii) = mean(RawTrace_PostSmooth(:,(timepoints_adjusted-(inputValue.frate*inputValue.postTrial)):((timepoints_adjusted-1)+(inputValue.postTrial*inputValue.frate)-(inputValue.frate*inputValue.postTrial))), 2);
  439. [postMaxHolder,postMaxIndex] = max(RawTrace_PostSmooth(:,(timepoints_adjusted-(inputValue.frate*inputValue.postTrial)):((timepoints_adjusted-1)+(inputValue.postTrial*inputValue.frate)-(inputValue.frate*inputValue.postTrial))), [], 2);
  440. Pre_postMaxV(:,ii) = postMaxHolder;
  441. [postMaxZHolder,postMaxZIndex] = max(Raw_Z(:,(timepoints_adjusted-(inputValue.frate*inputValue.postTrial)):((timepoints_adjusted-1)+(inputValue.postTrial*inputValue.frate)-(inputValue.frate*inputValue.postTrial))), [], 2);
  442. Pre_postMaxV_Z(:,ii) = postMaxZHolder;
  443. postMinHolder = min(RawTrace_PostSmooth(:,(timepoints_adjusted-(inputValue.frate*inputValue.postTrial)):((timepoints_adjusted-1)+(inputValue.postTrial*inputValue.frate)-(inputValue.frate*inputValue.postTrial))), [], 2);
  444. Pre_postMinV(:,ii) = postMinHolder;
  445. zMaxHolder = max(Decon_Z(:,(timepoints_adjusted-(inputValue.frate*inputValue.postTrial)):((timepoints_adjusted-1)+(inputValue.postTrial*inputValue.frate)-(inputValue.frate*inputValue.postTrial))), [], 2);
  446. Pre_Responders_Zthreshold(:,ii) = zMaxHolder;
  447. Pre_ZPeaksN_timepoints(:,ii) = sum(allZPeaks_logical(:,(timepoints_adjusted-(inputValue.frate*inputValue.postTrial)):((timepoints_adjusted-1)+(inputValue.postTrial*inputValue.frate)-(inputValue.frate*inputValue.postTrial))),2);
  448. %DLC behavior things; nose displacement is an average +/- 2 frames
  449. %on either side of the displacment peak in the post trial window
  450. Pre_preMotion(:,ii) = repmat(mean(average_euclid((timepoints_adjustedBEH-(inputValue.preTrial * inputValue.frate_BEH)-(inputValue.frate_BEH*inputValue.postTrial)):(timepoints_adjustedBEH-1-(inputValue.frate_BEH*inputValue.postTrial)))),size(Decon_Z,1),1);
  451. Pre_postMotion(:,ii) = repmat(mean(average_euclid((timepoints_adjustedBEH-(inputValue.frate_BEH*inputValue.postTrial)):((timepoints_adjustedBEH-1)+(inputValue.postTrial*inputValue.frate_BEH)-(inputValue.frate_BEH*inputValue.postTrial)))),size(Decon_Z,1),1);
  452. [postNose_max,postNose_max_idx] = max(displacement_final((timepoints_adjustedBEH-(inputValue.frate_BEH*inputValue.postTrial)):((timepoints_adjustedBEH-1)+(inputValue.postTrial*inputValue.frate_BEH)-(inputValue.frate_BEH*inputValue.postTrial))));
  453. Pre_postNose(:,ii) = mean(displacement_final((timepoints_adjustedBEH+postNose_max_idx-3-(inputValue.frate_BEH*inputValue.postTrial)):(timepoints_adjustedBEH+postNose_max_idx+1-(inputValue.frate_BEH*inputValue.postTrial))),'omitNaN');
  454. end
  455. end
  457. % calculate stuff you want as an output
  458. Pre_deltaV_mean = Pre_postMean - Pre_Mean;
  459. Pre_deltaV_max_Z = (Pre_postMaxV_Z - Pre_preMean_Z);
  460. Pre_deltaV_max = ((Pre_postMaxV - Pre_Mean));
  461. Pre_deltaV_min = ((Pre_Mean - Pre_postMinV));
  462. Pre_delta_detect_EX = ((Pre_postMaxV - Pre_Mean) ./ (Pre__stdD) > inputValue.SDcutoff);
  463. Pre_delta_detect_IN = ((Pre_Mean - Pre_postMinV) ./ (Pre__stdD) > inputValue.SDcutoff);
  464. Pre_combined_detectEX = (Pre_delta_detect_EX .* (Pre_Responders_Zthreshold > inputValue.Zcutoff_combinedDetect));
  465. Pre_post_motion_corr = repmat((corr(Pre_postMotion(1,:).',Pre_postMaxV.','rows','complete')).',1,size(inputValue.timePoints,2));
  467. %delta shifter code; shifting along the response window x2 and calculate new deltas
  468. %based on the shift across all possible points, generates a larger cell
  469. %matrix encompassing all possible points
  470. postMaxV_shifter = cell(1,size(inputValue.timePoints,2));
  471. preMean_shifter = cell(1,size(inputValue.timePoints,2));
  472. postMaxV_Delta_shifter = cell(1,size(inputValue.timePoints,2));
  473. postMaxV_CombinedResponders_shifter = cell(1,size(inputValue.timePoints,2));
  474. deltaZ_shifter = cell(1,size(inputValue.timePoints,2));
  475. Pre_postMaxV_shifter = cell(1,size(inputValue.timePoints,2));
  476. Pre_postMaxV_CombinedResponders_shifter = cell(1,size(inputValue.timePoints,2));
  477. Pre_deltaZ_shifter = cell(1,size(inputValue.timePoints,2));
  478. wPre = inputValue.shifter_pre * inputValue.frate;
  479. wPost = inputValue.shifter_post * inputValue.frate;
  480. for ii = 1:size(inputValue.timePoints,2)
  481. if inputValue.timePoints(ii) == 0
  482. dummy = NaN(size(Decon_Z,1),inputValue.shifter_maxFrames);
  483. postMaxV_shifter{1,ii} = dummy;
  484. preMean_shifter{1,ii} = dummy;
  485. postMaxV_Delta_shifter{1,ii} = dummy;
  486. postMaxV_CombinedResponders_shifter{1,ii} = dummy;
  487. deltaZ_shifter{1,ii} = dummy;
  488. Pre_postMaxV_shifter{1,ii} = dummy;
  489. Pre_postMaxV_CombinedResponders_shifter{1,ii} = dummy;
  490. Pre_deltaZ_shifter{1,ii} = dummy;
  491. else
  492. postMaxV_shifter_now = zeros(size(Decon_Z,1),inputValue.shifter_maxFrames);
  493. preMean_shifter_now = zeros(size(Decon_Z,1),inputValue.shifter_maxFrames);
  494. preStd_shifter_now = zeros(size(Decon_Z,1),inputValue.shifter_maxFrames);
  495. Zmax_shifter_holder = zeros(size(Decon_Z,1),inputValue.shifter_maxFrames);
  496. ZpreMean_shifter_holder = zeros(size(Decon_Z,1),inputValue.shifter_maxFrames);
  497. Pre_std_shifter_holder = zeros(size(Decon_Z,1),inputValue.shifter_maxFrames);
  498. Pre_Mean_shifter_holder = zeros(size(Decon_Z,1),inputValue.shifter_maxFrames);
  499. Pre_Max_shifter_holder = zeros(size(Decon_Z,1),inputValue.shifter_maxFrames);
  500. Pre_Zmax_shifter_holder = zeros(size(Decon_Z,1),inputValue.shifter_maxFrames);
  501. Pre_ZpreMean_shifter_holder = zeros(size(Decon_Z,1),inputValue.shifter_maxFrames);
  502. for q = (1:inputValue.shifter_maxFrames)-1
  503. postMaxV_shifter_now(:,(q+1)) = max(RawTrace_PostSmooth(:,(inputValue.timePoints(ii)+q):(inputValue.timePoints(ii)+q-1+wPost)), [], 2);
  504. preMean_shifter_now(:,(q+1)) = mean(RawTrace_PostSmooth(:,(inputValue.timePoints(ii)+q-wPre):(inputValue.timePoints(ii)+q-1)), 2);
  505. preStd_shifter_now(:,(q+1)) = std(RawTrace_PostSmooth(:,(inputValue.timePoints(ii)+q-wPre):(inputValue.timePoints(ii)+q-1)), 0, 2);
  506. Zmax_shifter_holder(:,(q+1)) = max(Decon_Z(:,(inputValue.timePoints(ii)+q):(inputValue.timePoints(ii)+q-1+wPost)), [], 2);
  507. ZpreMean_shifter_holder(:,(q+1)) = mean(Decon_Z(:,(inputValue.timePoints(ii)+q-wPost-wPre):(inputValue.timePoints(ii)+q-wPost-1)), 2);
  508. timepoints_adjusted = inputValue.timePoints(ii) - (inputValue.preValue_shift * inputValue.frate);
  509. Pre_std_shifter_holder(:,(q+1)) = std(RawTrace_PostSmooth(:,(timepoints_adjusted+q-wPost-wPre-inputValue.shifter_maxFrames):(timepoints_adjusted+q-wPost-inputValue.shifter_maxFrames-1)), 0, 2);
  510. Pre_Mean_shifter_holder(:,(q+1)) = mean(RawTrace_PostSmooth(:,(timepoints_adjusted+q-wPost-wPre-inputValue.shifter_maxFrames):(timepoints_adjusted+q-wPost-inputValue.shifter_maxFrames-1)), 2);
  511. Pre_Max_shifter_holder(:,(q+1)) = max(RawTrace_PostSmooth(:,(timepoints_adjusted+q-wPost-inputValue.shifter_maxFrames):(timepoints_adjusted+q-1-inputValue.shifter_maxFrames)), [], 2);
  512. Pre_Zmax_shifter_holder(:,(q+1)) = max(Decon_Z(:,(timepoints_adjusted+q-wPost-inputValue.shifter_maxFrames):(timepoints_adjusted+q-1-inputValue.shifter_maxFrames)), [], 2);
  513. Pre_ZpreMean_shifter_holder(:,(q+1)) = mean(Decon_Z(:,(timepoints_adjusted+q-wPost-wPre-inputValue.shifter_maxFrames):(timepoints_adjusted+q-wPost-inputValue.shifter_maxFrames-1)), 2);
  514. end
  515. postMaxV_CombinedResponders_shifter{1,ii} = (((postMaxV_shifter_now - preMean_shifter_now) ./ preStd_shifter_now) >...
  516. inputValue.SDcutoff) & (Zmax_shifter_holder > inputValue.Zcutoff_combinedDetect);
  517. postMaxV_Delta_shifter{1,ii} = (postMaxV_shifter_now - preMean_shifter_now);
  518. postMaxV_shifter{1,ii} = postMaxV_shifter_now;
  519. preMean_shifter{1,ii} = preMean_shifter_now;
  520. deltaZ_shifter{1,ii} = (Zmax_shifter_holder - ZpreMean_shifter_holder);
  521. Pre_postMaxV_shifter{1,ii} = (Pre_Max_shifter_holder - Pre_Mean_shifter_holder);
  522. Pre_postMaxV_CombinedResponders_shifter{1,ii} = (((Pre_Max_shifter_holder - Pre_Mean_shifter_holder) ./ Pre_std_shifter_holder) >...
  523. inputValue.SDcutoff) & (Pre_Zmax_shifter_holder > inputValue.Zcutoff_combinedDetect);
  524. Pre_deltaZ_shifter{1,ii} = (Pre_Zmax_shifter_holder - Pre_ZpreMean_shifter_holder);
  525. end
  526. end
  528. % pull things that go into table for absolute cell #, day, behavior group, etc.
  529. Animal = cellstr(repmat(char(table2array(inputValue.KeyTable(k,'AnimalNumber'))),size(deltaV_max,1),1));
  530. Day = repmat(table2array(inputValue.KeyTable(k,'Day')),size(deltaV_max,1),1);
  531. Abs_CellNumber = transpose(1:size(deltaV_max,1));
  532. BehaviorGroup = cellstr(repmat(char(table2array(inputValue.KeyTable(k,'BehaviorGroup'))),size(deltaV_max,1),1));
  533. State = cellstr(repmat(char(table2array(inputValue.KeyTable(k,'State'))),size(deltaV_max,1),1));
  534. Footprint = num2cell(inputValue.Footprints.spatial_footprints,[2 3]);
  536. % cell reg sometimes leaves out cells that
  537. % were included in the initial spatial footprints from the final index
  538. % added this line in to resort the cell-index for the
  539. % final table and to then include a zero value for any cell that was in
  540. % the original footprints for a day but wasn't included in the final
  541. % output
  542. CellReg_Index = zeros(size(inputValue.deconvolvedTrace,1),1);
  543. for i = 1:size(inputValue.deconvolvedTrace,1)
  544. if find(inputValue.Index == i) > 0 % if the index exists, put the right number in
  545. CellReg_Index(i,:) = find(inputValue.Index == i);
  546. else % otherwise, drop a zero in to indicate it wasn't included
  547. CellReg_Index(i,:) = 0;
  548. end
  549. end
  551. % pull output values and odors for each trial, add to table with above
  552. % indentifiers for each cell
  553. for i = 1:size(deltaV_max,2)
  555. Odor = cellstr(repmat(char(table2array(inputValue.notes(i,2))),size(deltaV_max,1),1));
  556. Abs_TrialN = repmat(i,size(deltaV_max,1),1);
  558. % get absolute trial number; truncate to current
  559. % trial being looked at, then count string appearence of that odor
  560. counter_trunc = table2array(inputValue.notes(1:i,2));
  561. Stim_TrialN = repmat(sum(count(counter_trunc,table2array(inputValue.notes(i,2)))),size(deltaV_max,1),1);
  563. % add numbers into the table; fill gaps with NaN; uses
  564. % zeros for trace delta values (as those are always a number that isn't
  565. % zero. For logical indices, not converting to NaN. Max trial length
  566. % input globally at the start of the script determines the number of
  567. % columns for each table, so make sure thats right. To_add number
  568. % pulled solely from the delta frame as it should match the others.
  570. DeltaValue_MaxShifter = postMaxV_Delta_shifter{1,i};
  571. DeltaValue_MaxZShifter = deltaZ_shifter{1,i};
  572. Responders_CombinedEX_Shifter = postMaxV_CombinedResponders_shifter{1,i};
  573. DeltaValue_Mean = deltaV_mean(:,i);
  574. DeltaValue_Max_Z = deltaV_max_Z(:,i);
  575. DeltaValue_Max = deltaV_max(:,i);
  576. DeltaValue_Min = deltaV_min(:,i);
  577. Responders_CombinedEX = combined_detectEX(:,i);
  578. Responders_EX = delta_detect_EX(:,i);
  579. Responders_IN = delta_detect_IN(:,i);
  580. ZPeaksN_byTrial = ZPeaksN_timepoints(:,i);
  581. MotionPost = postMotion(:,i);
  582. MotionPre = preMotion(:,i);
  583. NoseDisp = postNose(:,i);
  584. MotionCorr = post_motion_corr(:,i);
  585. DeltaValue_Max_adjustNose = deltaV_max_adjustNose(:,i);
  586. Responders_EX_adjustNose = delta_detect_EX_adjustNose(:,i);
  587. Responders_CombinedEX_adjustNose = combined_detect_EX_adjustNose(:,i);
  590. Pre_DeltaValue_MaxShifter = Pre_postMaxV_shifter{1,i};
  591. Pre_DeltaValue_MaxZShifter = Pre_deltaZ_shifter{1,i};
  592. Pre_Responders_CombinedEX_Shifter = Pre_postMaxV_CombinedResponders_shifter{1,i};
  593. Pre_DeltaValue_Mean = Pre_deltaV_mean(:,i);
  594. Pre_DeltaValue_Max_Z = Pre_deltaV_max_Z(:,i);
  595. Pre_DeltaValue_Max = Pre_deltaV_max(:,i);
  596. Pre_DeltaValue_Min = Pre_deltaV_min(:,i);
  597. Pre_Responders_CombinedEX = Pre_combined_detectEX(:,i);
  598. Pre_Responders_EX = Pre_delta_detect_EX(:,i);
  599. Pre_Responders_IN = Pre_delta_detect_IN(:,i);
  600. Pre_ZPeaksN_byTrial = Pre_ZPeaksN_timepoints(:,i);
  601. Pre_MotionPost = Pre_postMotion(:,i);
  602. Pre_MotionPre = Pre_preMotion(:,i);
  603. Pre_NoseDisp = Pre_postNose(:,i);
  604. Pre_MotionCorr = Pre_post_motion_corr(:,i);
  607. %combine outputs, then append to final table/arrays
  608. newTableInput = table(Animal,BehaviorGroup,State,Day,Odor,Abs_CellNumber,CellReg_Index,Abs_TrialN,Stim_TrialN,...
  609. DeltaValue_Max,DeltaValue_Mean,DeltaValue_Max_Z,DeltaValue_Min,Responders_EX,Responders_IN,Responders_CombinedEX,...
  610. ZPeaksN_byTrial,MotionPost,MotionPre,NoseDisp,MotionCorr,Pre_DeltaValue_Mean,Pre_DeltaValue_Max_Z,Pre_DeltaValue_Max,...
  611. Pre_DeltaValue_Min,Pre_Responders_CombinedEX,Pre_Responders_EX,Pre_Responders_IN,Pre_ZPeaksN_byTrial,Pre_MotionPost,...
  612. Pre_MotionPre,Pre_NoseDisp,Pre_MotionCorr,DeltaValue_Max_adjustNose,Responders_EX_adjustNose,Responders_CombinedEX_adjustNose,...
  613. DeltaValue_MaxShifter,DeltaValue_MaxZShifter,Responders_CombinedEX_Shifter,Pre_DeltaValue_MaxShifter,Pre_DeltaValue_MaxZShifter,...
  614. Pre_Responders_CombinedEX_Shifter);
  615. OutputTable = [OutputTable;newTableInput];
  617. Ztrace_trial_final = num2cell(Ztrace_trial{i},2);
  618. Rawtrace_trial_final = num2cell(Rawtrace_trial{i},2);
  619. Pre_Ztrace_trial_final = num2cell(Pre_Ztrace_trial{i},2);
  620. Pre_Rawtrace_trial_final = num2cell(Pre_Rawtrace_trial{i},2);
  622. % output for trial traces
  623. new_trialTable_input = table(Animal,BehaviorGroup,State,Day,Odor,Abs_CellNumber,...
  624. CellReg_Index,Abs_TrialN,Stim_TrialN,Ztrace_trial_final,Rawtrace_trial_final);
  625. TrialTrace_Table = [TrialTrace_Table;new_trialTable_input];
  627. Pre_new_trialTable_input = table(Animal,BehaviorGroup,State,Day,Odor,Abs_CellNumber,...
  628. CellReg_Index,Abs_TrialN,Stim_TrialN,Pre_Ztrace_trial_final,Pre_Rawtrace_trial_final);
  629. Pre_TrialTrace_Table = [Pre_TrialTrace_Table;Pre_new_trialTable_input];
  631. % wipe cell arrays from each loop, will otherwise keep adding on to
  632. % prior entries
  633. clear ZTrace_trial_final Rawtrace_trial_final Pre_Ztrace_trial_final...
  634. Pre_Rawtrace_trial_final
  635. end
  637. totalPeak_Bins = floor(size(allZPeaks,2) / (inputValue.totalZ_Bins * inputValue.frate));
  639. for i = 1:totalPeak_Bins
  641. peaks_now = allZPeaks_logical(:,(i*inputValue.totalZ_Bins*inputValue.frate-...
  642. inputValue.totalZ_Bins*inputValue.frate + 1):...
  643. (i*inputValue.totalZ_Bins*inputValue.frate));
  644. sum_peaks_now = sum(peaks_now,2);
  645. Peaks_Bins{i} = sum_peaks_now;
  646. end
  648. % output of info relevant to the total traces
  649. Peaks_Bins = cell2mat(Peaks_Bins);
  650. Peaks_Bins(:,end+1:inputValue.totalZ_Bins_max) = NaN; % add to backfill for differing recording lengths
  651. RecordingLength = repmat(length(Decon_Z),size(allrawPeaks,1),1);
  652. Sum_All_PeaksN = sum(allZPeaks_logical,2);
  653. new_WholeTableInput = table(Animal,BehaviorGroup,State,Day,Abs_CellNumber,CellReg_Index,RecordingLength,Sum_All_PeaksN,Peaks_Bins);
  654. WholeTrace_Table = [WholeTrace_Table;new_WholeTableInput];
  656. % ouput of info relevant to footprints
  657. new_FootprintsInput = table(Animal,BehaviorGroup,State,Day,Abs_CellNumber,CellReg_Index,Footprint);
  658. Footprints_MasterTable = [Footprints_MasterTable;new_FootprintsInput];
  660. % behavior table input; after above loop for trial info so i can re-use
  661. % table info; don't put before any of the other ones as lable structure is
  662. % different for this table
  663. Motion_trial_final = Motion_trial.';
  664. NoseDisp_trial_final = NoseDisp_trial.';
  665. Animal = repmat(Animal(1),size(inputValue.timePoints,2),1);
  666. BehaviorGroup = repmat(BehaviorGroup(1),size(inputValue.timePoints,2),1);
  667. State = repmat(State(1),size(inputValue.timePoints,2),1);
  668. Odor = table2cell(inputValue.notes(:,2));
  669. Day = repmat(Day(1),size(inputValue.timePoints,2),1);
  670. Abs_TrialN = (1:size(inputValue.timePoints,2)).';
  671. Stim_TrialN = zeros(size(inputValue.timePoints,2),1);
  672. for i = 1:size(deltaV_max,2)
  673. counter_trunc = table2array(inputValue.notes(1:i,2));
  674. Stim_TrialN(i) = sum(count(counter_trunc,table2array(inputValue.notes(i,2))));
  675. end
  676. new_BEHinput = table(Animal,BehaviorGroup,State,Day,Odor,Abs_TrialN,Stim_TrialN,...
  677. Motion_trial_final,NoseDisp_trial_final);
  678. BEHTrace_Table = [BEHTrace_Table;new_BEHinput];
  680. clear Motion_trial_final NoseDisp_trial_final
  682. % wipe cell arrays from each loop
  683. clear Ztrace_Behavior Ztrace_trial Rawtrace_trial Rawtrace_Behavior Peaks_Bins Pre_Ztrace_trial_final Pre_Rawtrace_trial_final
  684. % wipe timepoints input to avoid leftovers from long files
  685. inputValue.timePoints = [];
  686. inputValue.timePoints_BEH = [];
  687. inputValue.timePoints_BEH_New = [];
  688. inputValue.timePoints_BEH_adjustedNose = [];
  689. inputValue.times_BEH_new = [];
  691. % output for behavior
  693. MotionIdx = average_euclid;
  694. NoseDisp = displacement_final;
  695. new_behavior_input = {MotionIdx,NoseDisp;};
  696. Behavior_Array = [Behavior_Array;new_behavior_input];
  698. % ZTrace Table; saved in order of trial appearance in list
  699. Trace = Decon_Z;
  700. new_ZTrace = {Trace};
  701. ZTraces = [ZTraces;new_ZTrace];
  703. Peaks = allZPeaks;
  704. new_Peaks = {allZPeaks};
  705. Peaks_Array = [Peaks_Array;new_Peaks];
  707. end
  709. %% any manual trimming post-running
  711. % remove animal that doesn't actual have behavioral data from those arrays
  712. BEHTrace_Table(strcmp(BEHTrace_Table.Animal,'NEC273332')==true,:) = [];
  713. Behavior_Array(1:6,:) = [];
  716. %% save final output tables/arrays
  717. save('InputParameters.mat', 'inputValue');
  718. save('OutputTable.mat','OutputTable');
  719. save('TrialTraces.mat', 'TrialTrace_Table');
  720. save('Pre_TrialTraces.mat','Pre_TrialTrace_Table');
  721. save('WholeTrace_Table.mat','WholeTrace_Table');
  722. save('ZTraces.mat','ZTraces');
  723. save('Peaks_All.mat','Peaks_Array');
  724. save('Footprints_MasterTable.mat','Footprints_MasterTable','-v7.3');
  725. save('Behavior_MasterTable.mat','Behavior_Array');
  726. save('Behavior_TraceTable.mat','BEHTrace_Table');
  728. % use '-v7.3' flag in saves after file names if they too big

responseExtraction_Behavior.m at commit 6c7b41a, under GPL-3.0 · at the source

Overview

Authors: Ian F. Chapman1,2, Martin A. Raymond1,3, Max L. Fletcher1
ORCID iDs: Ian F. Chapman
  1. Department of Anatomy & Neurobiology, University of Tennessee Health Science Center, Memphis, TN, USA
  2. Monell Chemical Senses Center, Philadelphia, PA, USA
  3. Department of Psychology, Brandeis University, Waltham, PA, USA
Institutions: University of Tennessee Health Science Center (United States); Monell Chemical Senses Center (United States); Brandeis University (United States)
Journal: iScience, volume 29, issue 6, article 115897
Dates: received 5 November 2025; accepted 22 April 2026; published online 27 April 2026
Type: Research article · Language: English
License: CC BY-NC-ND
Identifiers: DOI 10.1016/j.isci.2026.115897 · PMID 42181288 · PMCID PMC13197642 · OpenAlex W4391792311
Open access: gold, a free copy (OpenAlex)
Preprint: doi:10.1101/2024.02.08.579489
Status: code verified
Categories: mouse (organism), systems (subfield)
Methods: Connectivity, Statistics, Machine learning, fMRI & imaging
Keywords: neuroscience, behavioral neuroscience, systems neuroscience
Topic: Olfactory and Sensory Function Studies (Sensory Systems, Neuroscience), according to OpenAlex
Funding: NIH (DC013779); Monell Chemical Senses Center (T32DC000014)
Citations: not cited yet (Europe PMC); 73 references in the paper
Research resources: pAAV(AAV1).Syn.GCaMP6s.WPRE.SV40 RRID:Addgene_100843, C57BL/6 mice RRID:IMSR_JAX:000664

Abstract

The abstract is not reproduced here: the paper's license (CC BY-NC-ND) does not allow it. Read it in the paper, at the publisher or on Europe PMC.

Repositories

Its files are read in the Code ↔ Paper reader above, with 5 matches between paragraphs and lines of code.

Zenodo 19666573

License: GPL-3.0
State: the link answers, verified on 30 September 2026
Evidence: files inventoried
Size: 1 file
Software Heritage: not checked
Found in: “Data and code availability”
Not found: README, license file, CITATION.cff, environment file, tests, continuous integration, documentation
Availability: 1 check, the latest on 30 September 2026: the link answers (HTTP 200)
  • 30 September 2026: the link answers (HTTP 200)
At the source:

aharoni-lab/miniscope-daq-qt-software

License: GPL-3.0
State: the link answers, verified on 30 September 2026
Evidence: files inventoried
Commit: 7e644bf52ba5b6f4cdbe0be7f8ed52fd2f792aaa, 1 August 2026
Languages: C++ (39), C/C++ (26), Python (2), Shell (2)
Size: 195 files, 69 scripts
Software Heritage: not archived
Found in: the text, “Behavioral and imaging equipment”
Holds: README, license file, environment (conda-lock.yml, environment.yml, packaging/conda-virtual-packages.yml), tests, continuous integration
Not found: CITATION.cff, documentation
Tools: NumPy (1 file), OpenCV (1 file), TensorFlow (1 file)
Availability: 1 check, the latest on 30 September 2026: the link answers
  • 30 September 2026: the link answers
71 files
At the source: github.com/Aharoni-Lab/Miniscope-DAQ-QT-Software/wiki

ifchapman/chapman-et-al-iscience

License: GPL-3.0
State: the link answers, verified on 30 September 2026
Evidence: files inventoried
Commit: 6c7b41a57ae366fb9a24237d0946c8d459f902a5, 20 April 2026
Languages: MATLAB (46)
Size: 67 files, 46 scripts
Software Heritage: not archived
Found in: the Zenodo archive record
Holds: README, license file
Not found: CITATION.cff, environment file, tests, continuous integration, documentation
Tools: Statistics and Machine Learning Toolbox (14 files), Signal Processing Toolbox (3 files)
Availability: 1 check, the latest on 30 September 2026: the link answers
  • 30 September 2026: the link answers
48 files
At the source: github.com/ifChapman/Chapman-et-al-iScience/tree/v1.0.0

The paper's code and data availability statement is in the Data section.

Tracing map

Proposed by the machine: these links were found in the paper and verified at the source, without human review. The map will receive a Zenodo DOI once one of the paper's authors has validated it with their ORCID.

What the map holds:

  • 3 repositories of the authors' code, each at its verified commit, with its license and how the link was found in the paper;
  • 115 scripts, each with its path and the digest of its content;
  • 5 matches between paragraphs of the paper and lines of the code (method lexical-v1);
  • neither the text of the paper nor the code itself.

Its JSON (tracing-map.json) is deposited on Zenodo with its DOI once the map is validated.

Data

No dataset and no data link were found in the paper.

Code and data availability statement

The paper has a code and data availability statement. Its license (CC BY-NC-ND) does not allow reproducing it here; in short, from what the harvester recognized in it:

  • it points to the authors' code: Zenodo 19666573
  • it says that the data are available on request
  • it says that the code is available on request

Read it in the paper: doi.org/10.1016/j.isci.2026.115897.

Versions

The history of this record: each version stored by the harvester or made by a correction of its authors or of the maintainers of its code, and what changed in its facts. The texts of the paper (its abstract, its availability statements) are not part of it; versions that changed only those are not listed.

Version 1, 30 September 2026: the first record

Recorded: type, language, journal, volume, issue, pages, dates, 3 authors, 3 keywords, 2 funders, 72 references, 2 RRIDs.

Cite

This paper

Chapman, I. F., Raymond, M. A., & Fletcher, M. L. (2026). Experience and behavior modulate piriform cortex odor representation in freely moving mice. iScience, 29(6), 115897. https://doi.org/10.1016/j.isci.2026.115897

BibTeX

@article{chapman2026experience,
author = {Chapman, Ian F. and Raymond, Martin A. and Fletcher, Max L.},
title = {{Experience and behavior modulate piriform cortex odor representation in freely moving mice}},
journal = {iScience},
year = {2026},
month = apr,
volume = {29},
number = {6},
pages = {115897},
publisher = {Elsevier},
issn = {2589-0042},
doi = {10.1016/j.isci.2026.115897},
url = {https://doi.org/10.1016/j.isci.2026.115897},
pmid = {42181288},
pmcid = {PMC13197642}
}

RIS

TY - JOUR
AU - Chapman, Ian F.
AU - Raymond, Martin A.
AU - Fletcher, Max L.
TI - Experience and behavior modulate piriform cortex odor representation in freely moving mice
T2 - iScience
J2 - iScience
PY - 2026
DA - 2026/04/27
VL - 29
IS - 6
SP - 115897
SN - 2589-0042
PB - Elsevier
DO - 10.1016/j.isci.2026.115897
UR - https://doi.org/10.1016/j.isci.2026.115897
LA - en
ER -

CSL-JSON

{
"id": "10.1016/j.isci.2026.115897",
"type": "article-journal",
"title": "Experience and behavior modulate piriform cortex odor representation in freely moving mice",
"container-title": "iScience",
"author": [
{
"family": "Chapman",
"given": "Ian F."
},
{
"family": "Raymond",
"given": "Martin A."
},
{
"family": "Fletcher",
"given": "Max L."
}
],
"container-title-short": "iScience",
"volume": "29",
"issue": "6",
"page": "115897",
"DOI": "10.1016/j.isci.2026.115897",
"PMID": "42181288",
"PMCID": "PMC13197642",
"ISSN": "2589-0042",
"publisher": "Elsevier",
"URL": "https://doi.org/10.1016/j.isci.2026.115897",
"language": "en",
"issued": {
"date-parts": [
[
2026,
4,
27
]
]
}
}

The tracing map gets a citation of its own once an author has validated it and it has a DOI.

Similar papers

The papers with a page that share the most with this one: the tools found in their code, their categories, datasets, cited references and authors, the rarest counting most.

[1] doi:10.1038/s41467-026-70356-9
A topographical organization in the primary olfactory cortex.
Journal: Nature communications
In common: systems, mouse, 17 references
[2] doi:10.7554/elife.103373
Experience shapes the transformation of olfactory representations along the cortico-hippocampal pathway.
Journal: eLife
In common: mouse, 11 references
[3] doi:10.7554/elife.107905 [code]
Adult-neurogenesis allows for representational stability and flexibility in early olfactory system.
Journal: eLife
In common: 9 references
[4] doi:10.1371/journal.pcbi.1014297 [code]
Statistics of cortical representational drift can enable robust readout.
Journal: PLoS computational biology
In common: NumPy, systems, 7 references
[5] doi:10.1038/s41467-026-72445-1 [code]
Perception and neural representation of intermittent odor stimuli in mice.
Journal: Nature communications
In common: NumPy, mouse, 6 references
[6] doi:10.1038/s41467-026-75792-1 [code]
Temporal drift of sleep-wake representations in hypothalamic neuronal ensembles.
Journal: Nature communications
In common: Signal Processing Toolbox, systems, mouse, 5 references
[7] doi:10.1038/s41467-026-71356-5 [code]
Generalization of fear learning is shaped by inhibitory sensory processing in mice.
Journal: Nature communications
In common: mouse, 5 references
[8] doi:10.1038/s41593-026-02232-0 [code]
Entorhinal cortex represents task-relevant remote locations independently of CA1.
Journal: Nature neuroscience
In common: OpenCV, Signal Processing Toolbox, Statistics and Machine Learning Toolbox, 1 other tool, systems, mouse, 2 references
[9] doi:10.1038/s41593-026-02377-y [code]
Representations of the intrinsic value of information in mouse orbitofrontal cortex.
Journal: Nature neuroscience
In common: Statistics and Machine Learning Toolbox, systems, mouse, 4 references
[10] doi:10.1038/s41467-026-73001-7 [code]
Separable and integrated pleasantness coding for appetitive and aversive odors across olfactory and ventral prefrontal cortices.
Journal: Nature communications
In common: Signal Processing Toolbox, Statistics and Machine Learning Toolbox, 3 references

Contribute

The authors of this paper can claim it, correct its record and validate its tracing map, and the maintainers of its code (its owner, or a public member of its organization) correct what it says of their repository; anyone signed in can ask for its removal. Every request goes to OSCR's own machine, which answers it; your account page follows them.

Sign in with ORCID to claim this paper as one of its authors, correct its record or validate its tracing map: when the paper's metadata lists your ORCID iD, you are recognized at once. Maintainers of its code: sign in with GitHub, then claim the repository on your account page.

Request its removal

To ask OSCR to remove this record, the copies of its authors' scripts or its tracing map, use the removal request page: signed in, you say who you are, what to remove and why, then review and confirm the request. Published rules decide every request (how).

Discussion, reproductions, activity

Discussion: questions and error reports about this paper and its code, from signed-in readers and its authors. It opens with sign-in.

Reproductions: reports from readers who ran the authors' code: what they reproduced, with which environment, commit and data. It opens with sign-in.

Activity: what happens around this paper: new versions of its record, its map's validation, discussions and reproductions. It opens with sign-in.