Properly arranged directory

Author: fabriciocravo

power_calculator_test_script.m

@@ -14,11 +14,11 @@
 create_test_fc_data_set()
 create_test_fc_atlas()
 
-% edge_based_tests('test_hcp_fc.mat')
+edge_based_tests('test_hcp_fc.mat')
 
-% network_based_tests('test_hcp_fc.mat')
+network_based_tests('test_hcp_fc.mat')
 
-% data_inference_from_contrast_test()
+data_inference_from_contrast_test()
 
 test_power_calculation_from_gt_and_data()
 

power_calculator_tools/atlas_data_set_map.m

@@ -0,0 +1,32 @@
+function atlas_file = atlas_data_set_map(Params)
+    
+    atlas_ok = ~isnan(Params.atlas_file);
+    
+    atlas_file = NaN;
+
+    disp(Params.data_set)
+
+    if atlas_ok
+        atlas_file = Params.atlas_file;
+    else
+
+        switch Params.data_set
+
+            case 'hcp_fc'
+
+                atlas_file = './atlas_storage/map268_subnetwork.mat';
+            
+            case 'test_hcp_fc'
+
+                atlas_file = './atlas_storage/test_hcp_fc_atlas.mat';
+
+        end
+
+    end
+       
+    %% Maybe we remove this? - Not everything requires an atlas
+    if isnan(atlas_file)
+        error('No atlas file found')
+    end
+
+end 

test_scripts/.DS_Store

@@ -0,0 +1,11 @@
+function Params = common_test_setup(data_set_name)
+    
+    %% Remove output folder if it exists
+    if isfolder('./test_power_calculator/')
+        rmdir('./test_power_calculator/', 's'); % 's' removes all subfolders and files
+    end
+
+    Params = setparams();
+    Params = setup_global_test_parameters(Params, data_set_name);
+
+end

test_scripts/common_test_setup.m

@@ -0,0 +1,18 @@
+function create_test_fc_atlas()
+    
+    % Define ROI mappings
+    % newroi, oldroi, category, label, hemisphere
+    newroi = [1; 2; 3; 4; 5];
+    oldroi = [1; 2; 3; 4; 5];
+    category = [1; 1; 1; 1; 2];
+    label = ['Ef'; 'Ef'; 'Ef'; 'Ef'; 'Nf'];
+    hemiphere = ['L'; 'L'; 'L'; 'L'; 'R'];
+
+    %% Convert to table
+    % For now only map is available as an attribute
+    map = table(newroi, oldroi, category, label, hemiphere);
+
+    % Save to file (optional)
+    save('./atlas_storage/test_hcp_fc_atlas.mat', 'map');
+
+end

test_scripts/create_test_fc_atlas.m

@@ -10,32 +10,42 @@ function create_test_fc_data_set()
     %% Definition of the tast dataset description
     nodes = 5;
     variables = 10; % 5*(5 - 1)/2
-    subject_number = 20; % 20 subs is enough
+    subject_number = 50; % 50 subs is enough - since the matrices are quite small there should be no issues
 
     %% Define study info - this is the test dataset to mimic hcp
     study_info.dataset = 'test_hcp';
     study_info.map = 'fc';
     study_info.test = 't';
-    study_info.mask = triu(ones(nodes), 1);
-
+    study_info.mask = logical(triu(ones(nodes), 1));
+    
+    outcome.test1.sub_ids = NaN;
+    outcome.test1.score = NaN;
+    outcome.test1.score_label = NaN;
     outcome.test1.contrast = {'TASK', 'REST'};
     outcome.test1.category = 'cognitive';
 
+    brain_data.TASK.motion = NaN;
+    brain_data.REST.motion = NaN;
 
-    brain_data.TASK = zeros(variables, subject_number);
-    for i = 1:subject_number
-        brain_data.TASK(:, i) = [1, 1, 1, 1, 1, 0.5, 0.2, 0.8, 0, 0];
-    end
+    brain_data.TASK.sub_ids = (1:subject_number)' + 100000;
+    brain_data.REST.sub_ids = (1:subject_number)' + 100000;
 
+    brain_data.TASK.data = zeros(variables, subject_number);
     for i = 1:subject_number
-        brain_data.REST(:, i) = [-1, -1, -1, -1, -1, 0.5, 0.2, 0.8, 0, 0];
+        brain_data.TASK.data(:, i) = [1, 1, 1, 1, 1, 1, 0.2, 0.8, 0.5, 0];
     end
 
+    brain_data.REST.data = zeros(variables, subject_number);
+    for i = 1:subject_number
+        brain_data.REST.data(:, i) = [-1, -1, -1, -1, -1, -1, 0.2, 0.8, 0.5, 0];
+    end
+
     data_dir = './data/';
     mkdir(data_dir);
 
-    file_name = './data/test_hpc_fc.mat';
+    file_name = './data/test_hcp_fc.mat';
 
     save(file_name, 'brain_data', 'study_info', 'outcome');
 
-end
+end
+

test_scripts/create_test_fc_data_set.m

@@ -0,0 +1,25 @@
+function data_inference_from_contrast_test()
+
+    % Run tests for different subject configurations
+    % total overlap - t test case
+    [TestData, BrainData, RP] = test_test_type_inference(...
+        [1, 2, 3, 4, 5, 6, 7, 8], [5, 6, 7, 8, 1, 2, 3, 4]); % High overlap
+    test_data_retrieval(TestData, BrainData, RP);
+
+    % High Overlap - `t` test case (should classify as `t`)
+    % High overlap, but not identical
+    [TestData, BrainData, RP] = test_test_type_inference(...
+        [1, 2, 3, 4, 5, 6, 7, 8], [4, 5, 6, 7, 8, 9, 10, 11]); 
+    test_data_retrieval(TestData, BrainData, RP);
+    
+    % No overlap t2 test case
+    [TestData, BrainData, RP] = test_test_type_inference(...
+        [1, 2, 3, 4, 5, 6, 7, 8], [9, 10, 11, 12, 13, 14, 15, 16]); % No overlap
+    test_data_retrieval(TestData, BrainData, RP);
+
+    % `t` vs `t2` (Partial Overlap)
+    [TestData, BrainData, RP] = test_test_type_inference(...
+        [1, 2, 3, 4, 5, 6, 7, 8], [5, 6, 7, 8, 9, 10, 11, 12]);
+    test_data_retrieval(TestData, BrainData, RP);
+
+end

test_scripts/data_inference_from_contrast_test.m

@@ -0,0 +1,44 @@
+function edge_based_tests(data_set_name)
+
+    Params = common_test_setup(data_set_name);
+    
+    stat_method_cell = {'Parametric_Bonferroni', 'Parametric_FDR', 'Size', 'TFCE'};
+
+    Params.all_cluster_stat_types = stat_method_cell;
+    
+    Params = setup_global_test_parameters(Params, data_set_name);
+    
+    rep_cal_function(Params)
+    
+    ResData = unite_results_from_directory('directory', './test_power_calculator/');
+
+    for i = 1:length(stat_method_cell)
+        method = stat_method_cell{i};
+
+        % The query is based on how the dataset is created
+        query = {'testing', 'test_hcp', 'REST_TASK', method, 'subs_40', 'brain_data'};
+    
+        brain_data = getfield(ResData, query{:});
+    
+        pvals = brain_data.pvals_all;
+
+        % I think I need to add the power calculator scripts too - just to
+        % make sure 
+
+        % Ensure first row is all zeros
+        error_effect = sprintf('Network-Level Test Failed in Method %s: Effect not detected', method);
+        error_non_effect = sprintf('Network-Level Test Failed in Method %s: Effect detected', method);
+
+        % Check for significant p-values where an effect is expected (rows 1 to 6)
+        for row = 1:6
+            assert(all(pvals(row, :) <= 0.05), error_effect);
+        end
+
+        % Check for non-significant p-values where no effect is expected (rows 7 to 10)
+        for row = 7:10
+            assert(all(pvals(row, :) == 1), error_non_effect);
+        end
+     
+    end
+
+end

test_scripts/edge_based_tests.m

@@ -0,0 +1,76 @@
+function generate_synthetic_gt_data()
+    % Directory where synthetic ground truth files will be saved
+    output_dir = './test_power_calculator/ground_truth/';
+    
+    % Ensure directory exists
+    if ~exist(output_dir, 'dir')
+        mkdir(output_dir);
+    end
+
+    % Set fixed number of edges and networks (same as the test data)
+    num_edges = 10;   % Example: 100 edges for edge-level tests
+    num_networks = 4; % Example: 10 networks for network-level tests
+
+    % Define split points for assigning 25% and 25%-50% ranges
+    split_25_edges = round(0.25 * num_edges);
+    split_50_edges = round(0.50 * num_edges);
+    split_25_networks = round(0.25 * num_networks);
+    split_50_networks = round(0.50 * num_networks);
+
+    % Common metadata fields for both edge and network level tests
+    meta_data = struct();
+    meta_data.dataset = 'synthetic_test';
+    meta_data.map = 'mock_map';
+    meta_data.test = 'synthetic';  % Placeholder test type
+    meta_data.test_components = {'REST', 'TASK'};
+    meta_data.omnibus = 'none';
+    meta_data.subject_number = 40; % Fixed subject number for testing
+    meta_data.testing_code = 1; % Indicator for test mode
+    meta_data.run_time = rand() * 10; % Fake runtime
+    meta_data.date = '1990-04-27';
+
+    % ----- Edge-Level Ground Truth -----
+    brain_data = struct();
+    brain_data.edge_stats_all = zeros(num_edges, 1);
+    brain_data.edge_stats_all_neg = zeros(num_edges, 1);
+
+    % Assign 25% of edges as positive true positives
+    brain_data.edge_stats_all(1:split_25_edges) = abs(randn(split_25_edges, 1)) + 1e-5;
+    % Assign next 25% of edges as negative true positives
+    brain_data.edge_stats_all(split_25_edges+1:split_50_edges) = ...
+        -abs(randn(split_50_edges - split_25_edges, 1)) - 1e-5;
+
+    % Set `edge_stats_all_neg` explicitly to match but with reversed sign
+    brain_data.edge_stats_all_neg = -brain_data.edge_stats_all;
+
+
+    % Update meta_data for edge-level test
+    meta_data.test_type = 'Parametric_Bonferroni'; % Edge-level method
+
+    % Save edge-level ground truth
+    filename_edge = sprintf('%sgt_synthetic_edge.mat', output_dir);
+    save(filename_edge, 'brain_data', 'meta_data');
+    
+    % ----- Network-Level Ground Truth -----
+    brain_data = struct();
+    brain_data.cluster_stats_all = zeros(num_networks, 1);
+    brain_data.cluster_stats_all_neg = zeros(num_networks, 1);
+
+     % ----- Network-Level GT Fix -----
+    % Assign 25% of networks as positive true positives
+    brain_data.cluster_stats_all(1:split_25_networks) = abs(randn(split_25_networks, 1)) + 1e-5;
+    % Assign next 25% of networks as negative true positives
+    brain_data.cluster_stats_all(split_25_networks+1:split_50_networks) = ...
+        -abs(randn(split_50_networks - split_25_networks, 1)) - 1e-5;
+
+    % Set `cluster_stats_all_neg` explicitly to match but with reversed sign
+    brain_data.cluster_stats_all_neg = -brain_data.cluster_stats_all;
+
+    % Update meta_data for network-level test
+    meta_data.test_type = 'Constrained'; % Network-level method
+
+    % Save network-level ground truth
+    filename_network = sprintf('%sgt_synthetic_network.mat', output_dir);
+    save(filename_network, 'brain_data', 'meta_data');
+
+end

test_scripts/generate_synthetic_gt_data.m

@@ -0,0 +1,97 @@
+function generate_synthetic_power_data()
+    % Directory where synthetic test files will be saved
+    output_dir = './test_power_calculator/';
+    
+    % Ensure directory exists
+    if ~exist(output_dir, 'dir')
+        mkdir(output_dir);
+    end
+
+    % Define test types based on whether they are edge-level or network-level
+    edge_level_tests = {'Parametric_Bonferroni', 'Parametric_FDR', 'Size', 'TFCE'};
+    network_level_tests = {'Constrained', 'Constrained_FWER'};
+
+    % Set fixed number of edges and networks (arbitrary for synthetic testing)
+    num_edges = 10;   % Example: 100 edges for edge-level tests
+    num_networks = 4; % Example: 10 networks for network-level tests
+    n_repetitions = 100; % Number of repetitions for power calculation
+
+    % Compute split for 25% of elements
+    split_25_edges = floor(num_edges * 0.25);
+    split_25_networks = floor(num_networks * 0.25);
+
+    % Loop through each test type
+    for test_type = [edge_level_tests, network_level_tests]
+        tt = test_type{1};  % Extract string
+
+        % Generate mock brain_data structure
+        brain_data = struct();
+
+        if ismember(tt, edge_level_tests)
+            % Edge-level test: p-values should match number of edges
+            brain_data.edge_stats_all = randn(num_edges, n_repetitions);  
+            brain_data.edge_stats_all_neg = randn(num_edges, n_repetitions);
+            brain_data.cluster_stats_all = []; % Not used for edge tests
+            brain_data.cluster_stats_all_neg = [];
+
+            % Initialize arrays with non-significant values (>0.5)
+            brain_data.pvals_all = 0.6 * ones(num_edges, n_repetitions);
+            brain_data.pvals_all_neg = 0.6 * ones(num_edges, n_repetitions);
+
+            % Ensure 25% power: In 25% of repetitions, p-value is set to zero (significant)
+            for rep = 1:n_repetitions
+                if mod(rep, 4) == 0 % Every 4th repetition should have significant results
+                    brain_data.pvals_all([1, 2, 3], rep) = 0;  % Positive detections
+                    brain_data.pvals_all_neg([4, 5], rep) = 0; % Negative detections
+                end
+            end
+
+        elseif ismember(tt, network_level_tests)
+            % Network-level test: p-values should match number of networks
+            brain_data.edge_stats_all = []; % Not used for network tests
+            brain_data.edge_stats_all_neg = [];
+            brain_data.cluster_stats_all = randn(num_networks, n_repetitions);
+            brain_data.cluster_stats_all_neg = randn(num_networks, n_repetitions);
+            
+            % Initialize arrays with non-significant values (>0.5)
+            brain_data.pvals_all = 0.6 * ones(num_networks, n_repetitions);
+            brain_data.pvals_all_neg = 0.6 * ones(num_networks, n_repetitions);
+
+            % Ensure 25% power: In 25% of repetitions, p-value is set to zero (significant)
+            for rep = 1:n_repetitions
+                if mod(rep, 4) == 0 % Every 4th repetition should have significant results
+                    brain_data.pvals_all(1:split_25_networks, rep) = 0;  
+                    brain_data.pvals_all_neg(split_25_networks+1:2*split_25_networks, rep) = 0;
+                end
+            end
+        end
+
+        % Ensure mutual exclusivity: no index should be zero in both p-values
+        invalid_indices = (brain_data.pvals_all == 0 & brain_data.pvals_all_neg == 0);
+        brain_data.pvals_all(invalid_indices) = rand(sum(invalid_indices, 'all'), 1);
+        
+        % Generate mock meta_data
+        meta_data = struct();
+        meta_data.dataset = 'synthetic_test';
+        meta_data.map = 'mock_map';
+        meta_data.test = 'synthetic';  % Placeholder test type
+        meta_data.test_components = {'REST', 'TASK'};
+        meta_data.omnibus = NaN;
+        meta_data.subject_number = 40; % Single fixed subject number
+        meta_data.testing_code = 1; % Indicator for test mode
+        meta_data.test_type = tt;  % Critical test type distinction
+        meta_data.run_time = rand() * 10; % Fake runtime
+        
+        % Add critical power calculation parameters
+        meta_data.rep_parameters.pthresh_second_level = 0.05;  % FWER/FDR threshold
+        meta_data.rep_parameters.n_repetitions = n_repetitions; % Number of repetitions
+
+        % Generate filename
+        filename = sprintf('%ssynthetic_%s.mat', output_dir, tt);
+
+        % Save synthetic data
+        save(filename, 'brain_data', 'meta_data');
+
+    end
+
+end