Make behavior what's permuted instead of data

Author: pollaro

+nla/+edge/+permutationMethods/+tree/PermutationNode.m

@@ -2,10 +2,10 @@
     %PERMUTATIONNODE Node which defines one grouping of each permutatino tree
     %
     % node = permutationNode(level, input_data, permutation_groups)
-    % node = One grouping of data for each permutation group. Each group contains the data (functional connectivity)
-    %   along with the index (column) the data is located and the original column
+    % node = One grouping of data for each permutation group. Each group contains the data to be permuted
+    %   along with the index (column)
     % level = The level of the tree. 0 is the root, 1 the first column of permutation groups, 2 the next...
-    % input_data = The input data. Currently, this is the functional connectivity
+    % input_data = The input data to be permuted
     % permutation_groups = the columns from the csv file that characterizes the permutation groupings
     %   Each column of the data is 1 permutation grouping. 
     %   Each row is one subject/data entry
@@ -16,12 +16,12 @@
         children = [] % Nodes that descend from the current node. The column to the right of the current level in permutation groups
         level = 0 % 0 is root, initial_data
         parent = false % if false, this is the root of the tree. If not, this is the node that came before
-        data_with_indexes = {} % The data. 3 cell object. {data (some big array), current index, original index}
+        data_with_indexes = {} % The data. 2 cell object. {data (some big array), original index}
         permutation_groups = [] % The groups that descend off of this one
     end
 
     properties (SetAccess = immutable)
-        original_data % matrix of size input_data.length x 3 with each row [data_value, current_index, original_index]
+        original_data % matrix of size input_data.length x 3 with each row [data_value, original_index]
     end
 
     methods
@@ -32,29 +32,25 @@
 
             if isequal(level, 0)
                 obj.permutation_groups = permutation_groups;
-                obj.original_data = {input_data, [1:size(input_data, 2)], [1:size(input_data, 2)]};
+                obj.original_data = {input_data, [1:size(input_data)]'};
                 obj.data_with_indexes = obj.original_data;
             else
                 size_permutation_groups = size(permutation_groups);
                 if size_permutation_groups(2) > 1
                     obj.permutation_groups = permutation_groups(:, 2:end);
                 end
-                functional_connectivity = input_data{1};
-                index_length = size(input_data{2}, 2);
-                current_index = [1:index_length];
-                original_index = input_data{3};
-                obj.original_data = {functional_connectivity, current_index, original_index};
+                obj.original_data = {input_data{1}, input_data{2}};
                 obj.data_with_indexes = obj.original_data;
             end
+
             if ~isempty(obj.permutation_groups)
                 group_numbers = unique(obj.permutation_groups(:, 1));
                 for group_number = 1:numel(group_numbers)
                     group_indexes = (obj.permutation_groups(:, 1) == group_numbers(group_number));
                     temp_permutation_groups = obj.permutation_groups(group_indexes, :);
                     group_input_data = obj.data_with_indexes{1};
                     group_current_indexes = obj.data_with_indexes{2};
-                    group_original_indexes = obj.data_with_indexes{3};
-                    group_data = {group_input_data(:, group_indexes), group_current_indexes(group_indexes), group_original_indexes(group_indexes)};
+                    group_data = {group_input_data, group_current_indexes(group_indexes)};
                     obj.children = [obj.children obj.createNodes(obj.level + 1, temp_permutation_groups, group_data, obj)];
                 end
             end

+nla/+edge/+permutationMethods/MultiLevel.m

@@ -32,31 +32,41 @@
                 input_struct.permutation_groups = [];
             end
             obj.permutation_tree = nla.edge.permutationMethods.tree.PermutationTree(...
-                input_struct.func_conn.v, input_struct.permutation_groups...
+                input_struct.behavior, input_struct.permutation_groups...
             );
             tree_root = obj.permutation_tree.root_node;
             obj = obj.depthFirstSearch(tree_root);
         end
 
         function permuted_input_struct = permute(obj, orig_input_struct)
             permuted_input_struct = orig_input_struct;
-            permuted_transposed_functional_connectivity = zeros(size(orig_input_struct.func_conn.v'));
-
+            permuted_behavior = orig_input_struct.behavior(:,:);
             for node_index = 1:numel(obj.terminal_nodes)
                 node = obj.terminal_nodes(node_index);
                 current_indexes = node.data_with_indexes{2};
-                original_indexes = node.data_with_indexes{3};
-                data = node.data_with_indexes{1}'; % transpose to match dimensions of indexes
-                
+                data = node.data_with_indexes{1};
                 permuted_indexes = nla.helpers.permuteVector(current_indexes);
-                sorted_original_indexes = sort(original_indexes, 2);
-                original_indexes = original_indexes(permuted_indexes);
-                data = data(permuted_indexes, :);
-                node.data_with_indexes = {data', current_indexes, original_indexes};
-                permuted_transposed_functional_connectivity(sorted_original_indexes, :) = data;
+                permuted_behavior(current_indexes) = data(permuted_indexes);
             end
+            permuted_input_struct.behavior = permuted_behavior;
+            % permuted_transposed_functional_connectivity = zeros(size(orig_input_struct.func_conn.v'));
+
+            % for node_index = 1:numel(obj.terminal_nodes)
+            %     node = obj.terminal_nodes(node_index);
+            %     current_indexes = node.data_with_indexes{2};
+            %     original_indexes = node.data_with_indexes{3};
+            %     data = node.data_with_indexes{1}'; % transpose to match dimensions of indexes
+                
+            %     permuted_indexes = nla.helpers.permuteVector(current_indexes);
+            %     sorted_original_indexes = sort(original_indexes, 2);
+            %     original_indexes = original_indexes(permuted_indexes);
+            %     data = data(permuted_indexes, :);
+            %     node.data_with_indexes = {data', current_indexes, original_indexes};
+            %     permuted_transposed_functional_connectivity(sorted_original_indexes, :) = data;
+            % end
 
-            permuted_input_struct.func_conn.v = permuted_transposed_functional_connectivity';
+            % permuted_input_struct.func_conn.v = permuted_transposed_functional_connectivity';
+            
         end
 
         function obj = depthFirstSearch(obj, node_input)