Changeset 27875 for issm/trunk

Timestamp:

08/10/23 18:34:53 (20 months ago)

Author:

musselman

Message:

Added support in matlab read/write_netCDF files for multidimensional structure arrays.

Location:

issm/trunk/src/m/contrib/musselman

Files:

• read_netCDF.m (modified) (7 diffs)
• write_netCDF.m (modified) (7 diffs)

issm/trunk/src/m/contrib/musselman/read_netCDF.m

@@ -17 +17 @@
 
 function model_copy = read_netCDF(filename)
-    fprintf('NetCDF42C v1.1.13\n');
+    fprintf('NetCDF42C v1.1.14\n');
 
     % make a model framework to fill that is in the scope of this file
@@ -109 +109 @@
         for variable = variables
             [varname, xtype, dimids, numatts] = netcdf.inqVar(group_location_in_file, variable);
-            copy_variable_data_to_new_model(group_location_in_file,varname, xtype);
+
+            % keep an eye out for nested structs:
+            if strcmp(varname, 'this_is_a_nested')
+                is_nested = true;
+                copy_nested_struct(group_location_in_file)
+            else
+                is_nested = false;
+                copy_variable_data_to_new_model(group_location_in_file,varname, xtype);
+            end
         end
     catch ME
@@ -117 +125 @@
     % try to find groups in current level, if it doesn't work it's because there is nothing there
     try
-        % search for nested groups in the current level to feed back to this function
-        groups = netcdf.inqGrps(group_location_in_file);
-        if not(isempty(groups))
-            for group = groups
-                %disp('found nested group!!')
-                group_id = netcdf.inqNcid(group_location_in_file, netcdf.inqGrpName(group));
-                %disp(netcdf.inqGrpNameFull(group_id))
-                walk_nested_groups(group);
-            end
-        end
-    catch
-    end
-end
+        % if it's not a nested struct, keep searching for subgroups
+        if isnested
+            % do nothing
+        else
+            % search for nested groups in the current level to feed back to this function
+            groups = netcdf.inqGrps(group_location_in_file);
+            if not(isempty(groups))
+                for group = groups
+                    %disp('found nested group!!')
+                    group_id = netcdf.inqNcid(group_location_in_file, netcdf.inqGrpName(group));
+                    %disp(netcdf.inqGrpNameFull(group_id))
+                    walk_nested_groups(group);
+                end
+            end
+        end
+    catch % no nested groups here
+    end
+end
+
+
+
+function copy_nested_struct(group_location_in_file)
+    global model_copy;
+    global NCData;
+    %{
+        A common multidimensional struct array is the 1xn md.results.TransientSolution struct. 
+        The process to recreate is as follows:
+            1. Get the name of the struct from group variable name_of_struct
+            2. Get the fieldnames from the subgroups 
+            3. Recreate the struct with fieldnames 
+            4. Populate the fields with their respective values
+    %}
+
+    % step 1
+    varid = netcdf.inqVarID(group_location_in_file, 'name_of_struct');
+    name_of_struct = netcdf.getVar(group_location_in_file, varid)';
+
+    % step 2
+    subgroups = netcdf.inqGrps(group_location_in_file); % numerical cell array with ID's of subgroups
+    % get single subgroup's data
+    single_subgroup_ID = subgroups(1);
+    subgroup_varids = netcdf.inqVarIDs(single_subgroup_ID);
+    fieldnames = {};
+    for variable = subgroup_varids
+        [varname, xtype, dimids, numatts] = netcdf.inqVar(single_subgroup_ID, variable);
+        fieldnames{end+1} = varname;
+    end
+
+    % step 3
+    address_in_model = strrep(netcdf.inqGrpNameFull(group_location_in_file), '/', '');
+    % we cannot assign a variable to represent this object as MATLAB treats all variables as copies
+    % and not pointers to the same memory address
+    % this means that if address_in_model is more than 1 item, we need to modify the code. For now, 
+    % we just hope this will do
+    
+    model_copy.(address_in_model).(name_of_struct) = struct();
+    
+    % for every fieldname in the subgroup, create an empty field
+    for fieldname = string(fieldnames)
+        model_copy.(address_in_model).(name_of_struct).(fieldname) = {};
+    end
+
+    % use repmat to make the struct array multidimensional along the fields axis
+    number_of_dimensions = numel(subgroups);
+    model_copy.(address_in_model).(name_of_struct) = repmat(model_copy.(address_in_model).(name_of_struct), 1, number_of_dimensions);
+    
+    % step 4
+    % for every layer of the multidimensional struct array, populate the fields
+    for current_layer = 1:number_of_dimensions
+        % choose subgroup
+        current_layer_subgroup_ID = subgroups(current_layer);
+        % get all vars
+        current_layer_subgroup_varids = netcdf.inqVarIDs(current_layer_subgroup_ID);
+        % get individual vars and set fields at layer current_layer
+        for varid = current_layer_subgroup_varids
+            [varname, xtype, dimids, numatts] = netcdf.inqVar(current_layer_subgroup_ID, varid);
+            data = netcdf.getVar(current_layer_subgroup_ID, varid);
+
+            % netcdf uses Row Major Order but MATLAB uses Column Major Order so we need to transpose all arrays w/ more than 1 dim
+            if all(size(data)~=1) || xtype == 2
+                data = data.';
+            end
+            
+            % set the field
+            model_copy.(address_in_model).(name_of_struct)(current_layer).(varname) = data;
+            %address_to_struct_in_model = setfield(address_to_struct_in_model(current_layer), varname, data)
+        end
+        model_copy.(address_in_model).(name_of_struct)(current_layer);
+        fprintf("Successfully saved layer %s to multidimension struct array\n", num2str(current_layer))
+    end
+    fprintf('Successfully recreated multidimensional structure array %s in md.%s\n', name_of_struct, address_in_model)
+end
+
+
+
 
 %{
@@ -142 +232 @@
     %disp(varname)
     % this is an inversion band-aid
-    if strcmp(varname, 'inversion_class_name')
+    if strcmp(varname, 'inversion_class_name') || strcmp(varname, 'name_of_struct') || strcmp(varname, 'solution')
         % we don't need this
     else
@@ -149 +239 @@
             %disp(netcdf.inqGrpNameFull(group_location_in_file))
             %disp(class(netcdf.inqGrpNameFull(group_location_in_file)))
-            adress_to_attr = strrep(netcdf.inqGrpNameFull(group_location_in_file), '/', '.');
-            
-            data = netcdf.getVar(group_location_in_file, netcdf.inqVarID(group_location_in_file, varname));
-            
-    
-            % matlab needs to know that ' ' = char()
+            address_to_attr = strrep(netcdf.inqGrpNameFull(group_location_in_file), '/', '.');
+            varid = netcdf.inqVarID(group_location_in_file, varname);
+            data = netcdf.getVar(group_location_in_file, varid);
+            
+    
+            % if we have an empty string
             if xtype == 2 && isempty(all(data))
                 data = cell(char());
+            % if we have an empty cell-char array
             elseif numel(data) == 1 && xtype == 3 && data == -32767
                 data = cell(char());
             end
-            % band-aid for cell-char-arrays:
+            % band-aid for some cell-char-arrays:
             if xtype == 2 && strcmp(data, 'default')
                 data = {'default'};
@@ -168 +259 @@
             if all(size(data)~=1) || xtype == 2
                 data = data.';
+            end
+
+            % if we have a list of strings
+            if xtype == 2
+                try
+                    if strcmp(netcdf.getAtt(group, varid, "type_is"), 'cell_array_of_strings')
+                        data = cellstr(data)
+                    end
+                catch
+                    % no attr found so we pass
+                end
             end
             
@@ -174 +276 @@
             %xtype
             if xtype == 10
-                arg_to_eval = ['model_copy', adress_to_attr, '.', varname, ' = ' , 'double(data);'];
+                arg_to_eval = ['model_copy', address_to_attr, '.', varname, ' = ' , 'double(data);'];
                 eval(arg_to_eval);
                 %disp('saved int64 as int16')
             else
-                arg_to_eval = ['model_copy', adress_to_attr, '.', varname, ' = ' , 'data;'];
+                arg_to_eval = ['model_copy', address_to_attr, '.', varname, ' = ' , 'data;'];
                 eval(arg_to_eval);
             end

issm/trunk/src/m/contrib/musselman/write_netCDF.m

@@ -11 +11 @@
 
 function write_netCDF(model_var, filename)
-    disp('MATLAB C2NetCDF4 v1.1.13');
+    disp('MATLAB C2NetCDF4 v1.1.14');
     % model_var = class object to be saved
     % filename = path and name to save file under
@@ -179 +179 @@
             % there are 2 cases: the location is a struct, the location is a class
             if isstruct(model_subclass)
+                % if the current field is a nested struct assume it has valuable data that needs to be saved
+                if isstruct(location_of_child) && any(size(location_of_child) > 1)
+                    create_group(location_of_child, list_of_layers);
+                
                 % this would mean that the layer above the layer we're interested in is a struct, so
                 % we can navigate our empty model as such
-                if isfield(empty_model_subclass, current_child)
+                elseif isfield(empty_model_subclass, current_child)
                     % the layer we're interested in does exist, we just need to compare states
                     location_of_child_in_empty_model = empty_model_subclass.(current_child);
+
                     % if the current attribute is a numerical array assume it has valuable data that needs to be saved
                     if isnumeric(location_of_child) && logical(numel(location_of_child) > 1)
@@ -264 +269 @@
     % first we make the group at the highest level (ie, inversion)
     group_name = list_of_layers{1};
+    variable_name = list_of_layers{end};
     
     % if the group is already made, get it's ID instead of creating it again
@@ -284 +290 @@
         end
     end
-    % if the object is not a variable, we have nothing to save
+    % we may be dealing with an object
     try
         % if this line works, we're still dealing with a struct and need lower levels
         if isempty(fieldnames(location_of_child))
             % do nothing
+        elseif isstruct(location_of_child) && any(size(location_of_child) > 1)
+            % we have a nested struct
+            copy_nested_struct(variable_name, location_of_child, group)
         end
     catch
-        % if that line doesn't work, it means we're dealing with data
-        % Lastly, handle the variable(s)
-        variable_name = list_of_layers{end};
+        % if that line doesn't work, it means we're dealing with raw data
+        % not a nested struct, so we can pass
         create_var(variable_name, location_of_child, group);
     end
 end
+
+
+
+function copy_nested_struct(parent_struct_name, address_of_struct, group)
+    %{
+        This function takes a struct of structs and saves them to netcdf. 
+
+        To do this, we get the number of dimensions (substructs) of the parent struct.
+        Next, we iterate through each substruct and record the data. 
+        For each substruct, we create a subgroup of the main struct.
+        For each variable, we create dimensions that are assigned to each subgroup uniquely.
+    %}
+
+    disp("Beginning transfer of nested MATLAB struct to the NetCDF")
+
+    % make sure other systems can flag the nested struct type
+    dimID = netcdf.defDim(group, 'struct', 6);
+    string_var = netcdf.defVar(group, 'this_is_a_nested', "NC_CHAR", dimID);
+    uint_method=uint8('struct').';
+    method_ID = char(uint_method);
+    netcdf.putVar(group, string_var, method_ID);
+
+    % make sure other systems know the name of the parent struct
+    uint_method=uint8(parent_struct_name).';
+    method_ID = char(uint_method);
+    dimID = netcdf.defDim(group, 'struct_name', [numel(method_ID)]);
+    string_var = netcdf.defVar(group, 'name_of_struct', "NC_CHAR", dimID);
+    netcdf.putVar(group, string_var, method_ID);
+    
+    % 'a' will always be 1 and is not useful to us
+    [a, no_of_dims] = size(address_of_struct);
+
+    for substruct = 1:no_of_dims
+        % we start by making subgroups with nice names like "TransientSolution_substruct_44"
+        name_of_subgroup = [parent_struct_name, '_substruct_', num2str(substruct)];
+        subgroup = netcdf.defGrp(group, name_of_subgroup);
+
+        % do some housekeeping to keep track of the current layer
+        current_substruct = address_of_struct(substruct);
+        substruct_fields = fieldnames(current_substruct)'; % transpose because matlab only interates over n x 1 arrays
+        
+        % now we need to iterate over each variable of the nested struct and save it to this new subgroup
+        for variable_name = string(substruct_fields)
+            address_of_child = current_substruct.(variable_name);
+            create_var(variable_name, address_of_child, subgroup);
+        end
+    end
+    fprintf('Succesfully transferred nested MATLAB struct %s to the NetCDF\n', parent_struct_name)
+end
+
 
 
@@ -338 +396 @@
     
     % This first conditional statement will catch numeric arrays (matrices) of any dimension and save them
-    if any(size(address_of_child)>1) && ~ischar(address_of_child)
+    if any(size(address_of_child)>1) && ~iscellstr(address_of_child) && ~ischar(address_of_child)
         write_numeric_array_to_netcdf(variable_name, address_of_child, group);
 
@@ -349 +407 @@
         variable = netcdf.defVar(group, variable_name, "NC_DOUBLE", intdim);
 
-    % or a list of strings -- this needs work as it can only handle a list of 1 string
-    elseif iscell(address_of_child) && ischar(address_of_child{1})
-        for i = 1:numel(address_of_child)
-            write_string_to_netcdf(variable_name, address_of_child{i}, group, true);
-        end
+    % or a list of strings
+    elseif iscellstr(address_of_child) || iscell(address_of_child) && ischar(address_of_child{1})
+        write_cell_with_strings(variable_name, address_of_child, group)
         
     % or an empty list
@@ -396 +452 @@
     end
 
-    disp(['Successfully transferred data from ', variable_name, ' to the NetCDF']);
-end
-
-
-
-
-function write_string_to_netcdf(variable_name, address_of_child, group, list)
+    fprintf('Successfully transferred data from %s to the NetCDF\n', variable_name);
+end
+
+
+function write_cell_with_strings(variable_name, address_of_child, group)
+    %{
+    Write cell array (ie {'one' 'two' 'three'}) to netcdf
+    %}
+    global NetCDF
+    
+    if isempty(address_of_child)
+        % if the char array is empty, save an empty char
+        name_of_dimension = ['char', num2str(0)];
+        try
+            dimID = netcdf.defDim(group, name_of_dimension, 0);
+        catch
+            dimID = netcdf.inqDimID(group, name_of_dimension);
+        end
+        % Now we can make a variable in this dimension:
+        string_var = netcdf.defVar(group, variable_name, "NC_CHAR", [dimID]);
+        % we leave empty now
+    else
+        % covert data to char array
+        method_ID = char(address_of_child);
+    
+        % make dimensions
+        [rows, cols] = size(method_ID);
+        
+        IDDim1 = netcdf.defDim(group,'cols',cols);
+        IDDim2 = netcdf.defDim(group,'rows',rows);
+    
+        % create the variable slot
+        IDVarId = netcdf.defVar(group,variable_name,'NC_CHAR', [IDDim1 IDDim2]);
+    
+        % save the variable
+        netcdf.putVar(group, IDVarId, method_ID'); %transpose
+    
+        % tell other platforms that this is a cell of strings
+        netcdf.putAtt(group, IDVarId, 'type_is','cell_array_of_strings');
+    end
+end
+
+
+function write_string_to_netcdf(variable_name, address_of_child, group)
     % netcdf and strings don't get along.. we have to do it 'custom':
     global NetCDF;
-    % If 'list' is not provided, assume it is false
-    if nargin < 4
-        list = false;
-    end
+
     the_string_to_save = address_of_child;