Changeset 27874

Timestamp:

08/08/23 11:26:37 (20 months ago)

Author:

musselman

Message:

Fixed bugs so that read/write files function interchangeably on inversion notebooks

Location:

issm/trunk/src/m/contrib/musselman

Files:

• read_netCDF.m (modified) (5 diffs)
• read_netCDF_commit.py (modified) (4 diffs)
• write_netCDF.m (modified) (14 diffs)
• write_netCDF_commit.py (modified) (6 diffs)

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

@@ -17 +17 @@
 
 function model_copy = read_netCDF(filename)
-    fprintf('NetCDF42C v1.1.12\n');
+    fprintf('NetCDF42C v1.1.13\n');
 
     % make a model framework to fill that is in the scope of this file
@@ -39 +39 @@
         catch
         end % 'results' group doesn't exist 
-
 
         % see if inversion is in there, if it is we may have to instantiate some classes
@@ -84 +83 @@
     global NCData;
     inversionGroup = netcdf.inqNcid(NCData, "inversion");
-    varid = netcdf.inqVarID(inversionGroup,'inversion_class_name')
+    varid = netcdf.inqVarID(inversionGroup, 'inversion_class_name');
     inversion_class = convertCharsToStrings(netcdf.getVar(inversionGroup, varid,'char'));
-    if inversion_class == 'm1qn3inversion'
+    if strcmp(inversion_class, 'm1qn3inversion')
         model_copy.inversion = m1qn3inversion();
         disp('Successfully created inversion class instance: m1qn3inversion')
-    elseif inversion_class == 'taoinversion'
+    elseif strcmp(inversion_class, 'taoinversion')
         model_copy.inversion = taoinversion();
         disp('Successfully created inversion class instance: taoinversion')
     else
+        disp('No inversion class was found')
     end
 end
@@ -109 +109 @@
         for variable = variables
             [varname, xtype, dimids, numatts] = netcdf.inqVar(group_location_in_file, variable);
-            %disp(varname)
             copy_variable_data_to_new_model(group_location_in_file,varname, xtype);
         end
-    catch
+    catch ME
+        rethrow(ME)
     end
 
@@ -141 +141 @@
     global NCData;
     %disp(varname)
-    % putting try/catch here so that any errors generated while copying data are logged and not lost by the try/catch in walk_nested_groups
-    try
-        %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), '/', '.');
-        % netcdf uses Row Major Order but MATLAB uses Column Major Order so we need to transpose all arrays w/ more than 1 dim
-        data = netcdf.getVar(group_location_in_file, netcdf.inqVarID(group_location_in_file, varname));
-        
-        if all(size(data)~=1)
-            data = data.';
+    % this is an inversion band-aid
+    if strcmp(varname, 'inversion_class_name')
+        % we don't need this
+    else
+        % putting try/catch here so that any errors generated while copying data are logged and not lost by the try/catch in walk_nested_groups function
+        try
+            %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()
+            if xtype == 2 && isempty(all(data))
+                data = cell(char());
+            elseif numel(data) == 1 && xtype == 3 && data == -32767
+                data = cell(char());
+            end
+            % band-aid for cell-char-arrays:
+            if xtype == 2 && strcmp(data, 'default')
+                data = {'default'};
+            end
+            
+            % 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
+            
+            % the issm c compiler does not work with int64 datatypes, so we need to convert those to int16
+            % reference this (very hard to find) link for netcdf4 datatypes: https://docs.unidata.ucar.edu/netcdf-c/current/netcdf_8h_source.html
+            %xtype
+            if xtype == 10
+                arg_to_eval = ['model_copy', adress_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;'];
+                eval(arg_to_eval);
+            end
+            
+            full_addy = netcdf.inqGrpNameFull(group_location_in_file);
+            %disp(xtype)
+            %class(data)
+            fprintf('Successfully saved %s to %s\n', varname, full_addy);
+        catch e %e is an MException struct
+            fprintf(1,'There was an error with %s! \n', varname)
+            fprintf('The message was:\n%s\n',e.message);
+            fprintf(1,'The identifier was:\n%s\n',e.identifier);
+            disp()
+            % more error handling...
         end
-        
-        % the issm c compiler does not work with int64 datatypes, so we need to convert those to int16
-        % reference this (very hard to find) link for netcdf4 datatypes: https://docs.unidata.ucar.edu/netcdf-c/current/netcdf_8h_source.html
-        %xtype
-        if xtype == 10
-            arg_to_eval = ['model_copy', adress_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;'];
-            eval(arg_to_eval);
-        end
-        
-        full_addy = netcdf.inqGrpNameFull(group_location_in_file);
-        %disp(xtype)
-        %class(data)
-        fprintf('Successfully saved %s to %s\n', varname, full_addy);
-    catch e %e is an MException struct
-        fprintf(1,'The identifier was:\n%s',e.identifier);
-        fprintf(1,'There was an error! The message was:\n%s',e.message);
-        % more error handling...
     end
 end

issm/trunk/src/m/contrib/musselman/read_netCDF_commit.py ¶

@@ -24 +24 @@
 
 def read_netCDF(filename):
-    print('NetCDF42C v1.1.12')
+    print('NetCDF42C v1.1.13')
 
     # check if path exists
@@ -54 +54 @@
     # walk through each group looking for subgroups and variables
     for group in NCData.groups.keys():
-        # have to send a custom name to this function: filename.groups['group']
-        name = "NCData.groups['" + str(group) + "']"
-        walk_nested_groups(name)
+        if 'debris' in group:
+            pass
+        else:
+            # have to send a custom name to this function: filename.groups['group']
+            name = "NCData.groups['" + str(group) + "']"
+            walk_nested_groups(name)
     
+    print("Model Successfully Recreated.")
     return model_copy
 
@@ -116 +120 @@
     if str(location_of_variable_in_model + '.' + variable_name) =='results.solutionstep':
         pass
+    # qmu band-aid
+    elif 'qmu.statistics.method' in str(location_of_variable_in_model + '.' + variable_name):
+        pass
     # handle any strings:
     elif 'char' in eval(location_of_variable_in_file + '.dimensions[0]'):
@@ -151 +158 @@
 
 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+

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

@@ -11 +11 @@
 
 function write_netCDF(model_var, filename)
-    disp('MATLAB C2NetCDF4 v1.1.12');
+    disp('MATLAB C2NetCDF4 v1.1.13');
     % model_var = class object to be saved
     % filename = path and name to save file under
@@ -30 +30 @@
     try
         % if results had meaningful data, save the name of the subclass and class instance
-        NetCDF.groups('results');
+        netcdf.inqNcid(NetCDF,'results');
         results_subclasses_bandaid(model_var);
         % otherwise, ignore
@@ -41 +41 @@
 
 
+
 function make_NetCDF(filename)
+    % matlab can't handle input in the jupyter interface, so we just yell at the user to rename
+    % their file if needed
     % If file already exists delete / rename it
     if exist(filename, 'file') == 2
         fprintf('File %s already exists\n', filename);
+        disp('Please rename your file.')
+        return
     
         % If so, inquire for a new name or to delete the existing file
-        newname = input('Give a new name or input "delete" to replace: ', 's');
-
-        if strcmpi(newname, 'delete')
-            delete(filename);
-        else
-            fprintf('New file name is %s\n', newname);
-            filename = newname;
-        end
-    end
-    % Otherwise create the file and define it globally so other functions can call it
-    global NetCDF;
-    NetCDF = netcdf.create(filename, 'NETCDF4');
-    netcdf.putAtt(NetCDF, netcdf.getConstant('NC_GLOBAL'), 'history', ['Created ', datestr(now)]);
-    netcdf.defDim(NetCDF, 'Unlim', netcdf.getConstant('NC_UNLIMITED')); % unlimited dimension
-    netcdf.defDim(NetCDF, 'float', 1);     % single integer dimension
-    netcdf.defDim(NetCDF, 'int', 1);       % single float dimension
-    
-
-    fprintf('Successfully created %s\n', filename);
-end
-
+        %newname = input('Give a new name or input "delete" to replace: ', 's');
+
+        %if strcmpi(newname, 'delete')
+            %delete filename;
+        %else
+            %fprintf('New file name is %s\n', newname);
+            %filename = newname;
+        %end
+    else
+        % Otherwise create the file and define it globally so other functions can call it
+        global NetCDF;
+        NetCDF = netcdf.create(filename, 'NETCDF4');
+        netcdf.putAtt(NetCDF, netcdf.getConstant('NC_GLOBAL'), 'history', ['Created ', datestr(now)]);
+        netcdf.defDim(NetCDF, 'Unlim', netcdf.getConstant('NC_UNLIMITED')); % unlimited dimension
+        netcdf.defDim(NetCDF, 'float', 1);     % single integer dimension
+        netcdf.defDim(NetCDF, 'int', 1);       % single float dimension
+    
+        fprintf('Successfully created %s\n', filename);
+    end
+end
+
+
+%{
+    Since python uses subclass instances and MATLAB uses fields, we need to guess which subclass instance python will need
+    given the name of the sub-field in MATLAB. We make this guess based on the name of the MATLAB subfield that will contain
+    the name of the python subclass instance. For example, md.results.StressbalanceSolution is an subfield in MATLAB,
+    but a class instance of solution(). Notice that StressbalanceSolution contains the name "Solution" in it. This is what
+    we will save to the netCDF file for python to pick up.
+%}
 
 function results_subclasses_bandaid(model_var)
-    % Since the results class may have nested classes within it,
-    % we need to record the name of the nested class instance variable as it appears in the model that we're trying to save
+    global NetCDF;
+    % The results class may have nested fields within it, so we need to record the name of 
+    % the nested field as it appears in the model that we're trying to save
     quality_control = {};
     
@@ -86 +100 @@
         class_instance_name = class_instance_names{i};
         
-        % Check to see which class its from and record that info in the NetCDF to recreate structure later
         % Check to see if there is a solutionstep class instance
-        if isa(results_var.(class_instance_name), 'solutionstep')
+        if contains(class_instance_name, 'solutionstep',IgnoreCase=true)
             quality_control{end+1} = 1;
-            write_string_to_netcdf('variable_name', 'solutionstep', 'address_of_child', class_instance_name, 'group', groupid);
+            write_string_to_netcdf('solutionstep', class_instance_name, groupid);
+            disp('Successfully stored class python subclass instance: solutionstep')
         end
         
         % Check to see if there is a solution class instance
-        if isa(results_var.(class_instance_name), 'solution')
+        if contains(class_instance_name, 'solution',IgnoreCase=true)
             quality_control{end+1} = 1;
-            write_string_to_netcdf('variable_name', 'solution', 'address_of_child', class_instance_name, 'group', groupid);
+            write_string_to_netcdf('solution', class_instance_name, groupid);
+            disp('Successfully stored class python subclass instance: solution')
         end
         
         % Check to see if there is a resultsdakota class instance
-        if isa(results_var.(class_instance_name), 'resultsdakota')
+        if contains(class_instance_name, 'resultsdakota',IgnoreCase=true)
             quality_control{end+1} = 1;
-            write_string_to_netcdf('variable_name', 'resultsdakota', 'address_of_child', class_instance_name, 'group', groupid);
+            write_string_to_netcdf('resultsdakota', class_instance_name, groupid);
+            disp('Successfully stored class python subclass instance: resultsdakota')
         end
     end
@@ -137 +153 @@
     % model_subclass is an object (ie, md.mesh.elements)
     % list_of_layers is a cell array of subclasses/attributes/fields so that we can copy the structure into netcdf (ie, {'mesh', 'elements'})
-    % Use try/except since model_subclass is either a subclass w/ fields or it's not, no unknown exceptions
+    % need to check if inversion or m1qn3inversion or taoinversion class
+    if numel(given_list_of_layers) == 1
+        if strcmp(given_list_of_layers{1}, 'inversion')
+            create_group(model_subclass, given_list_of_layers);
+            check_inversion_class(model_subclass);
+        end
+    end
+    
+    % Use try/except since model_subclass is either a subclass/struct w/ props/fields or it's not, no unknown exceptions
     try 
         % look for children - this is where the catch would be called
         children = fieldnames(model_subclass);
+
+        % if there are children, loop through them and see if we need to save any data
         for child = 1:numel(children)
             % record our current location
@@ -151 +177 @@
             
             % if the empty model does not have this attribute, it's because it's new so we save it to netcdf
-            try
-                location_of_child_in_empty_model = empty_model_subclass.(current_child);
-            catch
-                % empty model didn't have the attr, so we save it to netcdf
-                create_group(location_of_child, list_of_layers);
-            end
-            
-            % 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)
-                create_group(location_of_child, list_of_layers);
-                % i don't think I need this line but it's in my python code...
-                % walk_through_subclasses(location_of_child)
-            % if the attributes are identical we don't need to save anything
-            elseif (all(isnan(location_of_child)) && all(isnan(location_of_child_in_empty_model))) || isempty(setxor(location_of_child, location_of_child_in_empty_model))
-                walk_through_subclasses(location_of_child, location_of_child_in_empty_model, list_of_layers);
-            % if the attributes are not the same we need to save ours
-            else
-                create_group(location_of_child, list_of_layers);
-                walk_through_subclasses(location_of_child, location_of_child_in_empty_model, list_of_layers);
+            % there are 2 cases: the location is a struct, the location is a class
+            if isstruct(model_subclass)
+                % 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)
+                    % 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)
+                        create_group(location_of_child, list_of_layers);
+                    % if the attributes are identical we don't need to save anything
+                    elseif (all(isnan(location_of_child)) && all(isnan(location_of_child_in_empty_model))) || isempty(setxor(location_of_child, location_of_child_in_empty_model))
+                        walk_through_subclasses(location_of_child, location_of_child_in_empty_model, list_of_layers);
+                    % if the attributes are not the same we need to save ours
+                    else
+                        % THE ORDER OF THESE LINES IS CRITICAL
+                        walk_through_subclasses(location_of_child, location_of_child_in_empty_model, list_of_layers);
+                        create_group(location_of_child, list_of_layers);
+                    end
+                % this would mean that the layer we're interested in is not fundamental to the model architecture
+                % and thus needs to be saved to the netcdf
+                else
+                    walk_through_subclasses(location_of_child, empty_model_subclass, list_of_layers);
+                    create_group(location_of_child, list_of_layers);
+                end
+            % this would mean it's not a struct, and must be a class/subclass
+            % we now check the state of the class property
+            else 
+                try
+                    if isprop(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)
+                            create_group(location_of_child, list_of_layers);
+                        
+                        elseif iscell(location_of_child)
+                            % if the attributes are identical we don't need to save anything
+                            if isempty(setxor(location_of_child, location_of_child_in_empty_model))
+                                % pass
+                            else
+                            % otherwise we need to save
+                                walk_through_subclasses(location_of_child, empty_model_subclass, list_of_layers);
+                                create_group(location_of_child, list_of_layers);
+                            end
+                        elseif (all(isnan(location_of_child)) && all(isnan(location_of_child_in_empty_model)))
+                            walk_through_subclasses(location_of_child, location_of_child_in_empty_model, list_of_layers);
+                        % if the attributes are not the same we need to save ours
+                        else
+                            % THE ORDER OF THESE LINES IS CRITICAL
+                            walk_through_subclasses(location_of_child, location_of_child_in_empty_model, list_of_layers);
+                            create_group(location_of_child, list_of_layers);
+                        end
+                    else
+                        walk_through_subclasses(location_of_child, empty_model_subclass, list_of_layers);
+                        create_group(location_of_child, list_of_layers);
+                    end
+                catch
+                    walk_through_subclasses(location_of_child, empty_model_subclass, list_of_layers);
+                    create_group(location_of_child, list_of_layers);
+                end
             end
         end
@@ -175 +243 @@
         % If the caught error is a fieldname error, it's just saying that a variable has no fields and thus can be ignored
         if strcmp(ME.identifier, 'MATLAB:fieldnames:InvalidInput')
+            % do nothing
         % this is if we come accross instances/subfields in our model that are not fundamental to the model class (ie, taoinversion)
         elseif strcmp(ME.identifier, 'MATLAB:UndefinedFunction')
+            walk_through_subclasses(location_of_child, empty_model_subclass, given_list_of_layers);
+            create_group(location_of_child, list_of_layers);
         % If it's a different error, rethrow it to MATLAB's default error handling
         else
+            disp(ME.identifier)
+            disp(given_list_of_layers)
             rethrow(ME);
         end
@@ -196 +269 @@
         group = netcdf.defGrp(NetCDF, group_name);
     catch % group was already made
-        group = netcdf.inqNcid(NetCDF, group_name);
-    end
-    % need to check if inversion or m1qn3inversion or taoinversion class
-    if strcmp(group_name, 'inversion')
-        check_inversion_class(location_of_child);
-    end
-    
+        group = netcdf.inqNcid(NetCDF, group_name);    
+    end
+
     % if the data is nested, create nested groups to match class structure
     if numel(list_of_layers) > 2
-        for name = list_of_layers{2:end-1}
-            % again, the group levels may have already been made
+        % the string() method is really important here since matlab apparently can't handle the infinite complexity of a string without the string method.
+        for name = string(list_of_layers(2:end-1))
+            % the group levels may have already been made
             try % group hasn't been made
                 group = netcdf.defGrp(group, name);
@@ -214 +284 @@
         end
     end
-
-    % Lastly, handle the variable(s)
-    variable_name = list_of_layers{end};
-    create_var(variable_name, location_of_child, group);
-    
-end
-
-
-
+    % if the object is not a variable, we have nothing to save
+    try
+        % if this line works, we're still dealing with a struct and need lower levels
+        if isempty(fieldnames(location_of_child))
+            % do nothing
+        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};
+        create_var(variable_name, location_of_child, group);
+    end
+end
+
+
+% ironically inversion does not have the same problem as results as inversion subfields
+% are actually subclasses and not fields
 function check_inversion_class(model_var)
     global NetCDF;
@@ -229 +307 @@
     % Check if the function has already been executed
     if isempty(executed)
+        disp('Deconstructing Inversion class instance')
         % Need to make sure that we have the right inversion class: inversion, m1qn3inversion, taoinversion
         groupid = netcdf.inqNcid(NetCDF,'inversion');
@@ -234 +313 @@
         if isa(model_var, 'm1qn3inversion')
             write_string_to_netcdf('inversion_class_name', 'm1qn3inversion', groupid);
-            disp('Successfully saved inversion class instance m1qn3inversion');
+            disp('Successfully saved inversion class instance m1qn3inversion')
         elseif isa(model_var, 'taoinversion')
             write_string_to_netcdf('inversion_class_name', 'taoinversion', groupid);
-            disp('Successfully saved inversion class instance taoinversion');
+            disp('Successfully saved inversion class instance taoinversion')
         else
             write_string_to_netcdf('inversion_class_name', 'inversion', groupid);
-            disp('Successfully saved inversion class instance inversion');
+            disp('Successfully saved inversion class instance inversion')
         end
         % Set the persistent variable to indicate that the function has been executed
         executed = true;
-    else
-        % Code to skip execution if the function has already run
-    end
-
-
+    end
 end
 
@@ -265 +340 @@
     if any(size(address_of_child)>1) && ~ischar(address_of_child)
         write_numeric_array_to_netcdf(variable_name, address_of_child, group);
-    
-    % check if it's an int
-    elseif mod(address_of_child,1) == 0 || isinteger(address_of_child) && numel(address_of_child) == 1
+
+    % check if it's a string
+    elseif ischar(address_of_child)
+        write_string_to_netcdf(variable_name, address_of_child, group);
+
+    % or an empty variable
+    elseif isempty(address_of_child)
+        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 an empty list
+    elseif iscell(address_of_child) && isempty(address_of_child) || isa(address_of_child, 'double') && isempty(address_of_child)
         variable = netcdf.defVar(group, variable_name, "NC_INT", intdim);
+        netcdf.putVar(group,variable, -32767);
+
+    % or a bool
+    elseif islogical(address_of_child)
+        % netcdf4 can't handle bool types like true/false so we convert all to int 1/0 and add an attribute named units with value 'bool'
+        variable = netcdf.defVar(group, variable_name, 'NC_SHORT', intdim);
+        netcdf.putVar(group,variable,int8(address_of_child));
+        % make sure other systems can flag the bool type
+        netcdf.putAtt(group,variable,'units','bool');
+
+    % or a regular list
+    elseif iscell(address_of_child)
+        disp('made list w/ unlim dim')
+        variable = netcdf.defVar(group, variable_name, "NC_DOUBLE", unlimdim);
         netcdf.putVar(group,variable,address_of_child);
-    
+        
     % or a float
     elseif isfloat(address_of_child) && numel(address_of_child) == 1
         variable = netcdf.defVar(group, variable_name, "NC_DOUBLE", floatdim);
         netcdf.putVar(group,variable,address_of_child);
-
-    % or a string
-    elseif ischar(address_of_child)
-        write_string_to_netcdf(variable_name, address_of_child, group);
-
-    % or a bool
-    elseif islogical(address_of_child)
-        % netcdf4 can't handle bool types like true/false so we convert all to int 1/0 and add an attribute named units with value 'bool'
-        variable = netcdf.defVar(group, variable_name, 'NC_SHORT', 'int');
-        netcdf.putVar(group,variable,logical(address_of_child));
-        % make sure other systems can flag the bool type
-        netcdf.putAtt(group,variable,'units','bool');
-        
-    % or an empty list
-    elseif iscell(address_of_child) && isempty(address_of_child) || isa(address_of_child, 'double') && isempty(address_of_child)
+        
+    % or a int
+    elseif mod(address_of_child,1) == 0 || isinteger(address_of_child) && numel(address_of_child) == 1
         variable = netcdf.defVar(group, variable_name, "NC_SHORT", 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, list = true);
-        end
-
-    % or a regular list
-    elseif iscell(address_of_child)
-        disp('made list w/ unlim dim')
-        variable = netcdf.defVar(group, variable_name, "NC_DOUBLE", unlimdim);
         netcdf.putVar(group,variable,address_of_child);
 
@@ -331 +411 @@
     the_string_to_save = address_of_child;
 
-    % convert string to 
-    uint_method=uint8(the_string_to_save);
-    method_ID = char(uint_method);
-    length_of_the_string = numel(method_ID);
-    
-    % Convert the string to character data using string array
-    %str_out = char(the_string_to_save)
-
-    % Determine the length of the string
-    %length_of_the_string = numel(str_out)
-
-    % Check if the dimension already exists, and if not, create it
-    name_of_dimension = ['char', num2str(length_of_the_string)];
-    try
-        dimID = netcdf.defDim(group, name_of_dimension, length_of_the_string);
-    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]);
-    
-    % Finally, we can write the variable:
-    netcdf.putVar(group, string_var, method_ID);
+    if isempty(the_string_to_save)
+        % 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
+        % convert string to 
+        uint_method=uint8(the_string_to_save).';
+        method_ID = char(uint_method);
+        length_of_the_string = numel(method_ID);
+        
+        % Convert the string to character data using string array
+        %str_out = char(the_string_to_save)
+    
+        % Determine the length of the string
+        %length_of_the_string = numel(str_out)
+    
+        % Check if the dimension already exists, and if not, create it
+        name_of_dimension = ['char', num2str(length_of_the_string)];
+        try
+            dimID = netcdf.defDim(group, name_of_dimension, length_of_the_string);
+        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]);
+        % Finally, we can write the variable (always transpose for matlab):
+        netcdf.putVar(group, string_var, method_ID);
+    end
 
     disp(['Successfully transferred data from ', variable_name, ' to the NetCDF']);
@@ -463 +555 @@
     end
 end
-

issm/trunk/src/m/contrib/musselman/write_netCDF_commit.py ¶

@@ -24 +24 @@
 
 def write_netCDF(model_var, model_name: str, filename: str):
-    print('C2NetCDF4 v1.1.12')
+    print('Python C2NetCDF4 v1.1.12')
     '''
     model_var = class object to be saved
@@ -90 +90 @@
     
         # If so, inqure for a new name or to do delete the existing file
-        newname = input('Give a new name or input "delete" to replace: ')
+        newname = input('Give a new name or "delete" to replace: ')
 
         if newname == 'delete':
@@ -134 +134 @@
             # in the framework of an empty model. If this is the case, we move to the except statement
             try:
-                # if the variable is an array, assume it has relevant data
+                # if the variable is an array, assume it has relevant data (this is because the next line cannot evaluate "==" with an array)
                 if isinstance(eval(adress_of_child), np.ndarray):
                     create_group(model_var, adress_of_child)
-                    walk_through_subclasses(model_var, adress_of_child, model_name)
+                # if the attributes are identical we don't need to save anything
                 elif eval(adress_of_child) == eval(adress_of_child_in_empty_class):
                     walk_through_subclasses(model_var, adress_of_child, model_name)
@@ -144 +144 @@
                     create_group(model_var, adress_of_child)
                     walk_through_subclasses(model_var, adress_of_child, model_name)
+            # AttributeError since the empty_model wouldn't have the same attribute as our model
             except AttributeError:
+                # THE ORDER OF THESE LINES IS CRITICAL
+                walk_through_subclasses(model_var, adress_of_child, model_name)
                 create_group(model_var, adress_of_child)
-                walk_through_subclasses(model_var, adress_of_child, model_name)
     except AttributeError: pass
     except Exception as e: print(e)
@@ -166 +168 @@
 
     # if the data is nested, create nested groups to match class structure
-    if len(levels_of_class) > 3:
+    if len(levels_of_class) > 2:
         for name in levels_of_class[2:-1]:
             group = group.createGroup(str(name))
@@ -349 +351 @@
             # write the variable:
             variable[:] = eval(adress_of_child)
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+