From b02d9e8dd6c0302ffc03590759bc70b695bd7950 Mon Sep 17 00:00:00 2001 From: p147685 Date: Tue, 24 Mar 2020 15:36:46 +0100 Subject: [PATCH] Commit files. NB: matlab project has been added --- resources/SourceFilesByJBM/spm_bsm.m | 571 +++++++++++++++++++++++ resources/SourceFilesByJBM/tbx_cfg_bsm.m | 99 ++++ 2 files changed, 670 insertions(+) create mode 100644 resources/SourceFilesByJBM/spm_bsm.m create mode 100644 resources/SourceFilesByJBM/tbx_cfg_bsm.m diff --git a/resources/SourceFilesByJBM/spm_bsm.m b/resources/SourceFilesByJBM/spm_bsm.m new file mode 100644 index 0000000..532af71 --- /dev/null +++ b/resources/SourceFilesByJBM/spm_bsm.m @@ -0,0 +1,571 @@ +function[job] = spm_bsm(job) +% +% Copyright J.B.C. Marsman +% NeuroImaging Center +% University Medical Center Groningnen +% +% September 2015 +% +% Cisler 2014 +% Rissman 2004 +% Mumford 2012 + +% Camara 2008 (reward processing) + +display('== == == Beta Series Method: Running analysis == == ==') + +N = numel(job.spms); + +warning('OFF', 'MATLAB:MKDIR:DirectoryExists'); + +for spm_i = 1:N + spmfile = job.spms{spm_i}; + %% load original SPM file + load(spmfile); + + %% check for canonical HRF : + if (SPM.xBF.order ~=1 ) + warning([sprintf('Problem found in File : %s\n', spmfile) ... + 'No canonical HRF was used to model the data\n' ... + 'This model will be skipped']); + continue; + end + + if (length(SPM.Sess) > 1 ) + warning([sprintf('Problem found in File : %s\n', spmfile) ... + sprintf('Multiple sessions are not supported.\n') ... + sprintf('This model will be skipped\n')]); + continue; + end + + SPM_orig = SPM; + U_orig = SPM.Sess.U; + + target_folder = [fileparts(spmfile) filesep 'BSM']; + + %% create output folder + mkdir(target_folder); + + %% specify active columns: + + all_columns = 1:length(SPM.Sess(1).U); + if ~isempty(job.acfl) + passive_columns = eval(['all_columns( job.acfl );']); + else + passive_columns = []; + end + active_columns = setdiff(all_columns, passive_columns); + + + job.active_columns = active_columns; + job.SPM_orig = SPM_orig; + job.U_orig = U_orig; + job.target_folder = target_folder; + + %% loop for active columns: + + methods = {'Traditional BSM Rissman et al', 'Adapted BSM Rissman et al', 'Fast approach (Mumford et al)', 'Adapted fast approach','none'}; + display(sprintf('== == == Beta Series Method: Analysis Type : %s == == ==', methods{job.type})); + + switch(job.type) + case 1, %% Traditional BSM Rissman et al + BSM_type1(job); + + case 2, %% Adapted Rissman et al + BSM_type2(job); + + case 3, %% Fast approach (Mumford et al) + BSM_type3(job); + + case 4, %% Adapted Fast approach + BSM_type4(job); + + end + pwd + keyboard + save('IntermediateState','job'); + display('== == == Beta Series Method : Concatenating betas == == ==') + BSM_concat_betas(job) + return; %for now don't do the last few steps + display('== == == Beta Series Method : Regressing ROIs== == ==') + BSM_Regress_Regions(job); + display('== == == Beta Series Method : Contrasting second level betas == == ==') + BSM_Contrast_manager(job); + display('== == == Beta Series Method : Done == == ==') +end + +end + + +function[] = BSM_type1(job) +%% Traditional BSM by Rissman et al 2004 + +active_columns = job.active_columns; + + +for c = 1:length(active_columns) %% split out all columns but baseline + column = active_columns(c); + other_columns = setdiff(1:length(active_columns), column); + + display(sprintf('*) Exploding column %d...', column)); + + target_folder_c = [job.target_folder filesep sprintf('col_%04d', column)]; + mkdir(target_folder_c); + + pos_index =1; + + U_new = struct('name',[],'ons', [], 'dur',[], 'P',[], 'dt', [], 'u', [],'pst',[]); + + for i = 1:length(job.U_orig(column).ons) %% walk over all onsets within 'column' + + SPM = job.SPM_orig; % copy settings from original SPM model + target_folder_i = [target_folder_c filesep sprintf('trial_%04d', i)]; + mkdir(target_folder_i); + SPM.swd = target_folder_i; + + %% add event i from 'column' + U_new(pos_index).name{1} = sprintf('%s_%d', SPM.Sess.U(column).name{1} , i); + U_new(pos_index).ons = job.SPM_orig.Sess.U(column).ons(i) ; + U_new(pos_index).dur = job.SPM_orig.Sess.U(column).dur(i); + U_new(pos_index).P = job.SPM_orig.Sess.U(column).P; + U_new(pos_index).dt = job.SPM_orig.Sess.U(column).dt; + + %% add all other events but i from 'column' to next column + pos_index = pos_index +1; + other_trials = setdiff(1:length(job.U_orig(column).ons), i); + + U_new(pos_index).name{1} = sprintf('%s_oc', SPM.Sess.U(column).name{1}); + U_new(pos_index).ons = job.SPM_orig.Sess.U(column).ons(other_trials) ; + U_new(pos_index).dur = job.SPM_orig.Sess.U(column).dur(other_trials); + U_new(pos_index).P = job.SPM_orig.Sess.U(column).P; + U_new(pos_index).dt = job.SPM_orig.Sess.U(column).dt; + + pos_index = pos_index + 1; + + for oc = 1:length(other_columns) + other_column = other_columns(oc); + + U_new(pos_index).name{1} = 'other conds'; + U_new(pos_index).ons = [U_new(pos_index).ons job.SPM_orig.Sess.U(other_column).ons]; + + if length(job.SPM_orig.Sess.U(other_column).dur) == 1 + U_new(pos_index).dur = [U_new(pos_index).dur repmat(job.SPM_orig.Sess.U(other_column).dur, 1, length(job.SPM_orig.Sess.U(other_column).ons))]; + else + U_new(pos_index).dur = [U_new(pos_index).dur job.SPM_orig.Sess.U(other_column).dur]; + end + U_new(pos_index).P = job.SPM_orig.Sess.U(other_column).P; + U_new(pos_index).dt = job.SPM_orig.Sess.U(other_column).dt; + end + + %% store the new U structure + SPM.Sess.U = U_new; + + BSM_finalize_model(job, SPM); + + end %% end loop for trial i +end %% end loop for active columns +end + +function BSM_type2(job) +%% Adapted Rissman et al: +active_columns = job.active_columns; +for c = 1:length(active_columns) %% split out all columns but baseline + column = active_columns(c); + other_columns = setdiff(1:length(active_columns), column); + + display(sprintf('*) Exploding column %d...', column)); + + target_folder_c = [job.target_folder filesep sprintf('col_%04d', column)]; + mkdir(target_folder_c); + + pos_index =1; + + U_new = struct('name',[],'ons', [], 'dur',[], 'P',[], 'dt', [], 'u', [],'pst',[]); + + for i = 1:length(job.U_orig(column).ons) %% walk over all onsets within 'column' + + SPM = job.SPM_orig; % copy settings from original SPM model + target_folder_i = [target_folder_c filesep sprintf('trial_%04d', i)]; + mkdir(target_folder_i); + SPM.swd = target_folder_i; + + %% add event i from 'column' + U_new(pos_index).name{1} = sprintf('%s_%d', SPM.Sess.U(column).name{1} , i); + U_new(pos_index).ons = job.SPM_orig.Sess.U(column).ons(i) ; + U_new(pos_index).dur = job.SPM_orig.Sess.U(column).dur(i); + U_new(pos_index).P = job.SPM_orig.Sess.U(column).P; + U_new(pos_index).dt = job.SPM_orig.Sess.U(column).dt; + + %% add all other events but i from 'column' to next column + pos_index = pos_index +1; + other_trials = setdiff(1:length(job.U_orig(column).ons), i); + + U_new(pos_index).name{1} = sprintf('%s_oc', SPM.Sess.U(column).name{1}); + U_new(pos_index).ons = job.SPM_orig.Sess.U(column).ons(other_trials) ; + U_new(pos_index).dur = job.SPM_orig.Sess.U(column).dur(other_trials); + U_new(pos_index).P = job.SPM_orig.Sess.U(column).P; + U_new(pos_index).dt = job.SPM_orig.Sess.U(column).dt; + + pos_index = pos_index + 1; + + for oc = 1:length(other_columns) + other_column = other_columns(oc); + + U_new(pos_index).name{1} = sprintf('%s_%d', SPM.Sess.U(other_column).name{1} , i); + U_new(pos_index).ons = job.SPM_orig.Sess.U(other_column).ons; + U_new(pos_index).dur = job.SPM_orig.Sess.U(other_column).dur; + U_new(pos_index).P = job.SPM_orig.Sess.U(other_column).P; + U_new(pos_index).dt = job.SPM_orig.Sess.U(other_column).dt; + + pos_index = pos_index+ 1; + end + + %% store the new U structure + SPM.Sess.U = U_new; + + BSM_finalize_model(job, SPM); + end %% end loop for trial i + +end %% end loop for active columns +end + + + +function BSM_type3(job) +%% Fast approach + +active_columns = job.active_columns; + +for c = 1:length(active_columns) %% split out all columns but baseline + column = active_columns(c); + other_columns = setdiff(1:length(active_columns), column); + + display(sprintf('*) Exploding column %d...', column)); + + target_folder_c = [job.target_folder filesep sprintf('col_%04d', column)]; + mkdir(target_folder_c); + + pos_index =1; + + SPM = job.SPM_orig; + SPM.swd = target_folder_c; + U_new = struct('name',[],'ons', [], 'dur',[], 'P',[], 'dt', [], 'u', [],'pst',[]); + + for i = 1:length(job.U_orig(column).ons) %% walk over all onsets within 'column' + + %% add event i from 'column' + U_new(pos_index).name{i} = sprintf('%s_%d', SPM.Sess.U(column).name{1} , i); + U_new(pos_index).ons = job.SPM_orig.Sess.U(column).ons(i) ; + U_new(pos_index).dur = job.SPM_orig.Sess.U(column).dur(i); + U_new(pos_index).P = job.SPM_orig.Sess.U(column).P; + U_new(pos_index).dt = job.SPM_orig.Sess.U(column).dt; + + %% add all other events but i from 'column' to next column + pos_index = pos_index +1; + end + + for oc = 1:length(other_columns) + other_column = other_columns(oc); + + U_new(pos_index).name{1} = sprintf('%s_%d', SPM.Sess.U(other_column).name{1} , i); + U_new(pos_index).ons = job.SPM_orig.Sess.U(other_column).ons; + U_new(pos_index).dur = job.SPM_orig.Sess.U(other_column).dur; + U_new(pos_index).P = job.SPM_orig.Sess.U(other_column).P; + U_new(pos_index).dt = job.SPM_orig.Sess.U(other_column).dt; + + pos_index = pos_index+ 1; + end + + %% store the new U structure + SPM.Sess.U = U_new; + + BSM_finalize_model(job, SPM); + + %% end loop for active columns +end +end + +function BSM_type4(job) +active_columns = job.active_columns; + +%% Adapted Fast approach +for c = 1:length(active_columns) %% split out all columns but baseline + column = active_columns(c); + other_columns = setdiff(1:length(active_columns), column); + + display(sprintf('*) Exploding column %d...', column)); + + target_folder_c = [job.target_folder filesep sprintf('col_%04d', column)]; + mkdir(target_folder_c); + + pos_index =1; + + SPM = job.SPM_orig; + SPM.swd = target_folder_c; + U_new = struct('name',[],'ons', [], 'dur',[], 'P',[], 'dt', [], 'u', [],'pst',[]); + + for i = 1:length(job.U_orig(column).ons) %% walk over all onsets within 'column' + + %% add event i from 'column' + U_new(pos_index).name{i} = sprintf('%s_%d', SPM.Sess.U(column).name{1} , i); + U_new(pos_index).ons = job.SPM_orig.Sess.U(column).ons(i) ; + U_new(pos_index).dur = job.SPM_orig.Sess.U(column).dur(i); + U_new(pos_index).P = job.SPM_orig.Sess.U(column).P; + U_new(pos_index).dt = job.SPM_orig.Sess.U(column).dt; + + %% add all other events but i from 'column' to next column + pos_index = pos_index +1; + end + + for oc = 1:length(other_columns) + other_column = other_columns(oc); + + U_new(pos_index).name{1} = 'other conds'; + U_new(pos_index).ons = [U_new(pos_index).ons job.SPM_orig.Sess.U(other_column).ons]; + + if length(job.SPM_orig.Sess.U(other_column).dur) == 1 + U_new(pos_index).dur = [U_new(pos_index).dur repmat(job.SPM_orig.Sess.U(other_column).dur, 1, length(job.SPM_orig.Sess.U(other_column).ons))]; + else + U_new(pos_index).dur = [U_new(pos_index).dur M_orig.Sess.U(other_column).dur]; + end + U_new(pos_index).P = job.SPM_orig.Sess.U(other_column).P; + U_new(pos_index).dt = job.SPM_orig.Sess.U(other_column).dt; + end + + + %% store the new U structure + SPM.Sess.U = U_new; + + BSM_finalize_model(job, SPM); + + %% end loop for active columns +end +end + +function BSM_finalize_model(job, SPM) + +U = spm_get_ons(SPM,1); +SPM.Sess(1).U = U; +[X,Xn,Fc] = spm_Volterra(SPM.Sess.U,SPM.xBF.bf,SPM.xBF.Volterra); + +k = SPM.nscan(1); +fMRI_T = SPM.xBF.T; +fMRI_T0 = SPM.xBF.T0; + +X = X((0:(k - 1))*fMRI_T + fMRI_T0 + 32,:); +% and orthogonalise (within trial type) +for i = 1:length(Fc) + X(:,Fc(i).i) = spm_orth(X(:,Fc(i).i)); +end + +Xname={}; +for i = 1:size(X,2) + Xname{end + 1} = [sprintf('Sn(%i) ',1) SPM.Sess(1).U(i).name{1}]; +end + +%% reinstate motion parameters +if (job.keepr) + C = job.SPM_orig.Sess(1).C.C; + Cname = job.SPM_orig.Sess(1).C.name; + + X = [X spm_detrend(C)]; + Xname = {Xname{:} Cname{:}}; +end + + +%% reinstate baseline column +X(:,end+1) = 1; +SPM.xX.X = X; + +SPM.xX.iB = size(X,2); +SPM.xX.iC = 1:size(X,2)-1; +Xname{end+1} = [sprintf('Sn(%i) ',1) 'constant']; +SPM.xX.name = Xname; + +try + SPM.xX = rmfield(SPM.xX, 'W'); +catch +end +save([SPM.swd filesep 'SPM.mat'], 'SPM'); + +%% estimate model: +matlabbatch{1}.spm.stats.fmri_est.spmmat = {[SPM.swd filesep 'SPM.mat']}; +matlabbatch{1}.spm.stats.fmri_est.method.Classical = 1; +spm_jobman('run', matlabbatch); +end + +%% Concatenate betas per condition in a Beta series 4D file +function BSM_concat_betas(job) +active_columns = job.active_columns; +target_folder = job.target_folder; +if (job.type < 3) + + for c = 1:length(active_columns) %% split out all columns but baseline + + column = active_columns(c); + target_folder_c = [target_folder filesep sprintf('col_%04d', column)]; + beta_files = spm_select('FPListRec', target_folder_c, 'beta_0001.nii'); + + matlabbatch{1}.spm.util.cat.vols = cellstr(beta_files); + matlabbatch{1}.spm.util.cat.name = [target_folder_c filesep 'betas.nii']; + matlabbatch{1}.spm.util.cat.dtype = 4; + spm_jobman('run', matlabbatch); + + if (job.keepfl == 0) + + to_delete = spm_select('FPListRec', target_folder_c, '^*.*'); + items = ~regexp(to_delete, 'betas.nii'); + to_delete = to_delete(items); + spm_unlink(to_delete); %% throw away all files + end + end + +else + + for c = 1:length(active_columns) %% split out all columns but baseline + column = active_columns(c); + beta_for_cond_c = 1:length(job.U_orig(column).ons); + target_folder_c = [target_folder filesep sprintf('col_%04d', column)]; + beta_files = {}; %% empty beta_files + for i =1:length(job.U_orig(column).ons) + beta_files{i} = spm_select('FPList', target_folder_c, sprintf('^beta_%04d.nii', i)); + end + + matlabbatch{1}.spm.util.cat.vols = beta_files'; + matlabbatch{1}.spm.util.cat.name = [target_folder_c filesep 'betas.nii']; + matlabbatch{1}.spm.util.cat.dtype = 4; + spm_jobman('run', matlabbatch); + + if (job.keepfl == 0) + display('*) Cleaning up ...'); + to_delete = cellstr(spm_select('FPListRec', target_folder_c, '^*.*')); + items_to_retain = ~cellfun(@isempty,regexp(to_delete, 'betas')); + to_delete(find(items_to_retain)) = []; + + for f = 1:length(to_delete) + spm_unlink(to_delete{f}); %% throw away all files + end + end + + end +end +end + +%% Step 3: Use Betas series files for GLM on a ROI timecourse (average Beta series extracted for a ROI) +%% Organized now as follows : / BSM / / col_000n +function[] = BSM_Regress_Regions(job) +target_folder = job.target_folder; +active_columns = job.active_columns; + +for r = 1:length(job.rois) + ROI(r).volume = spm_read_vols(spm_vol(job.rois{r})); + ROI(r).ind = find(ROI(r).volume); + [ROI(r).x ROI(r).y ROI(r).z] = ind2sub(size(ROI(r).volume), ROI(r).ind); +end +for r = 1:length(job.rois) + + if (isempty(ROI(r).ind)) + ROI(r) = []; + warning([sprintf(' %d ) Problem found for ROI : ''%s'', no active voxels.\n',r, job.rois{r}) ... + sprintf('This ROI will be skipped\n')]); + else + display(sprintf(' %d ) ROI ''%s'' contains %d voxels', r, job.rois{r}, length(ROI(r).ind))); + end + +end + +for r = 1:length(job.rois) + for c = 1:length(job.active_columns) + column = active_columns(c); + target_folder_c = [target_folder filesep sprintf('col_%04d', column)]; + + betas = cellstr(spm_select('ExtFPList', target_folder_c, 'betas.nii', 1:999)); + B = zeros(1, length(betas)); + + for b = 1:length(betas) + H = spm_vol(betas{b}); + B(b) = mean(spm_sample_vol(H, ROI(r).x, ROI(r).y, ROI(r).z,0)); + end + + [base roiname ext]= fileparts(job.rois{r}); + target_folder_r = [target_folder filesep roiname filesep sprintf('col_%04d', column)]; + mkdir(target_folder_r); + + matlabbatch{1}.spm.stats.factorial_design.dir = { target_folder_r}; + matlabbatch{1}.spm.stats.factorial_design.des.t1.scans = betas; + matlabbatch{1}.spm.stats.factorial_design.cov.c = B; + matlabbatch{1}.spm.stats.factorial_design.cov.cname = roiname; + matlabbatch{1}.spm.stats.factorial_design.cov.iCFI = 1; + matlabbatch{1}.spm.stats.factorial_design.cov.iCC = 1; + matlabbatch{1}.spm.stats.factorial_design.multi_cov = struct('files', {}, 'iCFI', {}, 'iCC', {}); + matlabbatch{1}.spm.stats.factorial_design.masking.tm.tm_none = 1; + matlabbatch{1}.spm.stats.factorial_design.masking.im = 1; + matlabbatch{1}.spm.stats.factorial_design.masking.em = {''}; + matlabbatch{1}.spm.stats.factorial_design.globalc.g_omit = 1; + matlabbatch{1}.spm.stats.factorial_design.globalm.gmsca.gmsca_no = 1; + matlabbatch{1}.spm.stats.factorial_design.globalm.glonorm = 1; + + matlabbatch{2}.spm.stats.fmri_est.spmmat(1) = cfg_dep('Factorial design specification: SPM.mat File', substruct('.','val', '{}',{1}, '.','val', '{}',{1}, '.','val', '{}',{1}), substruct('.','spmmat')); + matlabbatch{2}.spm.stats.fmri_est.write_residuals = 0; + matlabbatch{2}.spm.stats.fmri_est.method.Classical = 1; + + matlabbatch{3}.spm.stats.con.spmmat(1) = cfg_dep('Model estimation: SPM.mat File', substruct('.','val', '{}',{2}, '.','val', '{}',{1}, '.','val', '{}',{1}), substruct('.','spmmat')); + matlabbatch{3}.spm.stats.con.consess{1}.tcon.name = 'r'; + matlabbatch{3}.spm.stats.con.consess{1}.tcon.weights = [0 1]; + matlabbatch{3}.spm.stats.con.consess{1}.tcon.sessrep = 'none'; + matlabbatch{3}.spm.stats.con.consess{2}.tcon.name = '-r'; + matlabbatch{3}.spm.stats.con.consess{2}.tcon.weights = [0 -1]; + matlabbatch{3}.spm.stats.con.consess{2}.tcon.sessrep = 'none'; + matlabbatch{3}.spm.stats.con.delete = 0; + + spm_jobman('run', matlabbatch); + end +end + +end + +%% Step 4: Contrast Second level Betas for each ROI +function[] = BSM_Contrast_manager(job) +target_folder = job.target_folder; +for r = 1:length(job.rois) + [base roiname ext]= fileparts(job.rois{r}); + target_folder_final = [target_folder filesep roiname filesep 'results']; + mkdir(target_folder_final); + + for c1 = 1:length(job.active_columns) + for c2 = setdiff(1:length(job.active_columns),c1) + + betafile_c1 = spm_select('FPList', [target_folder filesep roiname filesep sprintf('col_%04d', c1)], 'beta_0002.nii'); + betafile_c2 = spm_select('FPList', [target_folder filesep roiname filesep sprintf('col_%04d', c2)], 'beta_0002.nii'); + + col1 = job.active_columns(c1); + col2 = job.active_columns(c2); + + matlabbatch{1}.spm.util.imcalc.input = { betafile_c1; betafile_c2 }; + matlabbatch{1}.spm.util.imcalc.output = sprintf('con_%04d_minus_%04d.nii', col1, col2); + matlabbatch{1}.spm.util.imcalc.outdir = { target_folder_final}; + matlabbatch{1}.spm.util.imcalc.expression = 'i1 - i2'; + matlabbatch{1}.spm.util.imcalc.var = struct('name', {}, 'value', {}); + matlabbatch{1}.spm.util.imcalc.options.dmtx = 0; + matlabbatch{1}.spm.util.imcalc.options.mask = 0; + matlabbatch{1}.spm.util.imcalc.options.interp = 1; + matlabbatch{1}.spm.util.imcalc.options.dtype = 4; + + matlabbatch{2}.spm.util.imcalc.input = { betafile_c1; betafile_c2 }; + matlabbatch{2}.spm.util.imcalc.output = sprintf('con_%04d_minus_%04d.nii', col2, col1); + matlabbatch{2}.spm.util.imcalc.outdir = { target_folder_final}; + matlabbatch{2}.spm.util.imcalc.expression = 'i2 - i1'; + matlabbatch{2}.spm.util.imcalc.var = struct('name', {}, 'value', {}); + matlabbatch{2}.spm.util.imcalc.options.dmtx = 0; + matlabbatch{2}.spm.util.imcalc.options.mask = 0; + matlabbatch{2}.spm.util.imcalc.options.interp = 1; + matlabbatch{2}.spm.util.imcalc.options.dtype = 4; + + spm_jobman('run', matlabbatch); + end + end + display(sprintf(' *) Results for roi %s are stored in : %s', roiname, job.target_folder_final)); + end + display(' *) These are difference in beta images and can be viewed via mricron or xjview'); + +end \ No newline at end of file diff --git a/resources/SourceFilesByJBM/tbx_cfg_bsm.m b/resources/SourceFilesByJBM/tbx_cfg_bsm.m new file mode 100644 index 0000000..dff144e --- /dev/null +++ b/resources/SourceFilesByJBM/tbx_cfg_bsm.m @@ -0,0 +1,99 @@ +function bsmr = tbx_cfg_bsm +% MATLABBATCH Configuration file for toolbox 'BSM' +%_______________________________________________________________________ +% Copyright (C) 2015 NeuroImaging Center Groningen + +% Jan-Bernard Marsman + +if ~isdeployed + addpath(fullfile(spm('Dir'),'toolbox','BSM')); +end + + +spms = cfg_files; +spms.tag = 'spms'; +spms.name = 'SPM models'; +spms.help = {'Select SPM models for Beta Series correlation.'}; +spms.filter = 'any'; +spms.ufilter = '^SPM.mat'; +spms.num = [1 Inf]; + + +rois = cfg_files; +rois.tag = 'rois'; +rois.name = 'Regions of Interest'; +rois.help = {'Select ROIs for Beta Series Correlation.'}; +rois.filter = 'image'; +rois.ufilter = '.nii'; +rois.num = [1 Inf]; + + +acfl = cfg_entry; +acfl.tag = 'acfl'; +acfl.name = 'Exclude columns from BSM models'; +acfl.help = {'Exclude columns from BSM models. Leave empty when all conditions should be taken into account. If you have a varying number of columns it is also possible to use the keyword end, in that case use single quotes around the entry (e.g., ''7:end'' '}; +acfl.val = {[]}; + +target = cfg_entry; +target.tag = 'target'; +target.name = 'Output folder'; +target.help = {'If specific target location is preferred, specify here. If it is not specified the default location',... + 'will be used, i.e. /BSM'}; +target.val = {'BSM'}; + + +keepfl = cfg_menu; +keepfl.tag = 'keepfl'; +keepfl.name = 'Save Intermediate GLM models'; +keepfl.help = {'Do you want to save the intermediate GLMs (only the beta is used...'}; +keepfl.labels = { + 'Yes' + 'No' + }'; +keepfl.values = { 1 0 }; +keepfl.val = {1}; + + +keepr = cfg_menu; +keepr.tag = 'keepr'; +keepr.name = 'Retain motion regressors'; +keepr.help = {'Do you want to keep the motion regressors'}; +keepr.labels = { + 'Yes' + 'No' + }'; +keepr.values = { 1 0 }; +keepr.val = {1}; + +type = cfg_menu; +type.tag = 'type'; +type.name = 'Type of Beta Series modelling'; +type.help = {'Types of modelling : ',... + '1) Traditional Rissman et al (2004): One model per event comprising two columns: one event column, other conditions other events)',... + '2) Traditional Rissman et al (2004) adapted: One model per event comprising N+1 columns: one event column, other events, conditions in different columns',... + '3) Faster approach Mumford et al(2012); :One model per condition, all events from a single condition separated in columns, other conditions modeled as original'}; + +type.labels = { + 'Traditional Rissman et al (2004)',... + 'Adapted Rissman et al (2004)',... + 'Fast approach',... + 'Adapted Fast approach'}; +type.values = { 1 2 3 4}; +type.val = {3}; + +bsm = cfg_exbranch; +bsm.tag = 'bsm'; +bsm.name = 'Beta Series Modelling (BSM)'; +bsm.val = { spms rois acfl type keepfl keepr }; +bsm.help = {'Beta Series correlations: Consists of four parts: 1) Estimation of models with separate betas per event. 2) Concatenation of beta series 3) Regress Per ROI timecourse on the beta series 4) Calculate contrast of betas from regression models in step 3.'}; +bsm.prog = @spm_bsm; + + +bsmr = cfg_choice; +bsmr.tag = 'bsmr'; +bsmr.name = 'BSM'; +bsmr.help = {''}; +bsmr.values = {bsm}; + + +