Changeset 27889

Timestamp:

08/30/23 15:08:57 (19 months ago)

Author:

musselman

Message:

Removed global vars from all files. Updated read log statements to use "load" instead of "save"

Location:

issm/trunk/src/m/contrib/musselman

Files:

• README.txt (modified) (1 diff)
• read_netCDF.m (modified) (18 diffs)
• read_netCDF.py (modified) (14 diffs)
• write_netCDF.m (modified) (29 diffs)
• write_netCDF.py (modified) (19 diffs)

issm/trunk/src/m/contrib/musselman/README.txt

@@ -37 +37 @@
         Verbose examples:
             write_netCDF(md, adress_to_save/../filename.nc, verbose = true);
+            
+          or:
+
+            write_netCDF(md, adress_to_save/../filename.nc, verbose);
             md = read_netCDF(adress_to_file/../filename.nc, verbose = true);
 

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

@@ -16 +16 @@
 
 
-function model_copy = read_netCDF(filename)
+function model_copy = read_netCDF(filename, varargin)
     if nargin > 1
         verbose = true;
@@ -27 +27 @@
     end
     % make a model framework to fill that is in the scope of this file
-    global model_copy;
     model_copy = model();
 
@@ -37 +36 @@
 
         % Open the given netCDF4 file
-        global NCData;
         NCData = netcdf.open(filename, 'NOWRITE');
         % Remove masks from netCDF data for easy conversion: NOT WORKING
@@ -44 +42 @@
         % see if results is in there, if it is we have to instantiate some classes
         try
-            results_group_id = netcdf.inqNcid(NCData, "results", verbose);
-            make_results_subclasses(verbose);
+            results_group_id = netcdf.inqNcid(NCData, "results");
+            model_copy = make_results_subclasses(model_copy, NCData, verbose);
         catch
         end % 'results' group doesn't exist 
@@ -52 +50 @@
         try
             inversion_group_id = netcdf.inqNcid(NCData, "inversion");
-            check_inversion_class(verbose);
+            model_copy = check_inversion_class(model_copy, NCData, verbose);
         catch
         end % 'inversion' group doesn't exist 
@@ -61 +59 @@
             %disp(netcdf.inqGrpNameFull(group_id))
             % hand off first level to recursive search
-            walk_nested_groups(group_id, verbose);
+            model_copy = walk_nested_groups(group_id, model_copy, NCData, verbose);
         end
         
@@ -75 +73 @@
 
 
-function make_results_subclasses(verbose)
-    global model_copy;
-    global NCData;
+function model_copy = make_results_subclasses(model_copy, NCData, verbose)
     resultsGroup = netcdf.inqNcid(NCData, "results");
     variables = netcdf.inqVarIDs(resultsGroup);
@@ -90 +86 @@
         %model_copy.results = setfield(model_copy.results, class_instance, class_instance_name);
     end
+    model_copy = model_copy;
     if verbose
         disp('Successfully recreated results structs:')
@@ -99 +96 @@
 
 
-function check_inversion_class(verbose)
+function model_copy = check_inversion_class(model_copy, NCData, verbose)
     % get the name of the inversion class: either inversion or m1qn3inversion or taoinversion
-    global model_copy;
-    global NCData;
     inversionGroup = netcdf.inqNcid(NCData, "inversion");
     varid = netcdf.inqVarID(inversionGroup, 'inversion_class_name');
@@ -121 +116 @@
         end
     end
-end
-
-
-function walk_nested_groups(group_location_in_file, verbose)
-    global model_copy;
-    global NCData;    
+    model_copy = model_copy;
+end
+
+
+function model_copy = walk_nested_groups(group_location_in_file, model_copy, NCData, verbose)  
     % we search the current group level for variables by getting this struct
     variables = netcdf.inqVarIDs(group_location_in_file); 
@@ -137 +131 @@
         if strcmp(varname, 'this_is_a_nested')
             is_nested = true;
-            copy_nested_struct(group_location_in_file, verbose)
+            model_copy = copy_nested_struct(group_location_in_file, model_copy, NCData, verbose);
         elseif strcmp(varname, 'solution')
             % band-aid pass..
         else
-            copy_variable_data_to_new_model(group_location_in_file, varname, xtype, verbose);
+            model_copy = copy_variable_data_to_new_model(group_location_in_file, varname, xtype, model_copy, NCData, verbose);
         end
     end
@@ -157 +151 @@
                 group_id = netcdf.inqNcid(group_location_in_file, netcdf.inqGrpName(group));
                 %disp(netcdf.inqGrpNameFull(group_id))
-                walk_nested_groups(group, verbose);
+                model_copy = walk_nested_groups(group, model_copy, NCData, verbose);
             end
         end
@@ -167 +161 @@
 
 
-function copy_nested_struct(group_location_in_file, verbose)
-    global model_copy;
-    global NCData;
+function model_copy = copy_nested_struct(group_location_in_file, model_copy, NCData, verbose)
     %{
         A common multidimensional struct array is the 1xn md.results.TransientSolution struct. 
@@ -235 +227 @@
         model_copy.(address_in_model).(name_of_struct)(current_layer);
         if verbose
-            fprintf("Successfully saved layer %s to multidimension struct array\n", num2str(current_layer))
-        end
-    end
+            fprintf("Successfully loaded layer %s to multidimension struct array\n", num2str(current_layer))
+        end
+    end
+    model_copy = model_copy;
     if verbose
         fprintf('Successfully recreated multidimensional structure array %s in md.%s\n', name_of_struct, address_in_model)
@@ -252 +245 @@
 %}
 
-function copy_variable_data_to_new_model(group_location_in_file, varname, xtype, verbose)
-    global model_copy;
-    global NCData;
+function model_copy = copy_variable_data_to_new_model(group_location_in_file, varname, xtype, model_copy, NCData, verbose)
     %disp(varname)
     % this is an inversion band-aid
@@ -305 +296 @@
                 arg_to_eval = ['model_copy', address_to_attr, '.', varname, ' = ' , 'double(data);'];
                 eval(arg_to_eval);
-                %disp('saved int64 as int16')
+                %disp('Loaded int64 as int16')
             else
                 arg_to_eval = ['model_copy', address_to_attr, '.', varname, ' = data;'];
@@ -315 +306 @@
                 %disp(xtype)
                 %class(data)
-                fprintf('Successfully saved %s to %s\n', varname, full_addy);
+                fprintf('Successfully loaded %s to %s\n', varname, full_addy);
             end
 
@@ -332 +323 @@
         end
     end
-end
+    model_copy = model_copy;
+end

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

@@ -34 +34 @@
 
         # open the given netCDF4 file
-        global NCData   
         NCData = Dataset(filename, 'r')
         # remove masks from numpy arrays for easy conversion
@@ -45 +44 @@
     try:
         NCData.groups['results']
-        make_results_subclasses(verbose)
+        make_results_subclasses(NCData, verbose)
     except:
         pass
@@ -52 +51 @@
     try:
         NCData.groups['inversion']
-        check_inversion_class(verbose)
+        check_inversion_class(NCData, verbose)
     except:
         pass
@@ -63 +62 @@
             # have to send a custom name to this function: filename.groups['group']
             name = "NCData.groups['" + str(group) + "']"
-            walk_nested_groups(name, verbose)
+            walk_nested_groups(name, NCData, verbose)
     
     if verbose:
-        print("Model Successfully Recreated.")
+        print("Model Successfully Loaded.")
     return model_copy
 
 
-def make_results_subclasses(verbose = False):
+def make_results_subclasses(NCData, verbose = False):
     '''
         There are 3 possible subclasses: solution, solutionstep, resultsdakota.
@@ -93 +92 @@
 
 
-def check_inversion_class(verbose = False):
+def check_inversion_class(NCData, verbose = False):
     # get the name of the inversion class: either inversion or m1qn3inversion or taoinversion
     inversion_class_is = NCData.groups['inversion'].variables['inversion_class_name'][:][...].tobytes().decode()
@@ -109 +108 @@
 
 
-def walk_nested_groups(group_location_in_file, verbose = False):
+def walk_nested_groups(group_location_in_file, NCData, verbose = False):
     # first, we enter the group by: filename.groups['group_name']
     # second we search the current level for variables: filename.groups['group_name'].variables.keys()
@@ -123 +122 @@
             matches = re.findall(pattern, group_location_in_file)
             name_of_struct = matches[-1] #eval(group_location_in_file + ".variables['solution']") 
-            copy_multidimensional_results_struct(group_location_in_file, name_of_struct)
+            copy_multidimensional_results_struct(group_location_in_file, name_of_struct, NCData)
             istruct = True
 
@@ -145 +144 @@
             variable_name = matches[-1]
             location_of_variable_in_model = '.'.join(matches[:-1])
-            copy_variable_data_to_new_model(location_of_variable_in_file, location_of_variable_in_model, variable_name, verbose=verbose)
+            copy_variable_data_to_new_model(location_of_variable_in_file, location_of_variable_in_model, variable_name, NCData, verbose=verbose)
             
     if 'istruct' in locals():
@@ -152 +151 @@
         for nested_group in eval(group_location_in_file + '.groups.keys()'):
             new_nested_group = group_location_in_file + ".groups['" + str(nested_group) + "']"
-            walk_nested_groups(new_nested_group, verbose=verbose)
+            walk_nested_groups(new_nested_group, NCData, verbose=verbose)
 
 
@@ -163 +162 @@
 '''
 
-def copy_multidimensional_results_struct(group_location_in_file, name_of_struct, verbose = False):
+def copy_multidimensional_results_struct(group_location_in_file, name_of_struct, NCData, verbose = False):
     '''
     A common multidimensional array is the 1xn md.results.TransientSolution object.
@@ -195 +194 @@
         steps.append(solutionstep_instance)
         if verbose:
-            print('Succesfully saved layer ' + str(layer) + ' to results.' + str(class_instance_name) + ' struct.')
+            print('Succesfully loaded layer ' + str(layer) + ' to results.' + str(class_instance_name) + ' struct.')
         else: pass
         layer += 1
@@ -203 +202 @@
 
 
-def copy_variable_data_to_new_model(location_of_variable_in_file, location_of_variable_in_model, variable_name, verbose = False):
+def copy_variable_data_to_new_model(location_of_variable_in_file, location_of_variable_in_model, variable_name, NCData, verbose = False):
     # as simple as navigating to the location_of_variable_in_model and setting it equal to the location_of_variable_in_file
     # NetCDF4 has a property called "_FillValue" that sometimes saves empty lists, so we have to catch those
@@ -245 +244 @@
                     setattr(eval('model_copy.' + location_of_variable_in_model), variable_name, eval(location_of_variable_in_file + '[:]'))
     except AttributeError:
-        copy_variable_data_to_new_model_dict(location_of_variable_in_file, location_of_variable_in_model, verbose=verbose)
+        copy_variable_data_to_new_model_dict(location_of_variable_in_file, location_of_variable_in_model, NCData, verbose=verbose)
 
     if verbose:
-        print('Successfully saved ' + location_of_variable_in_model + '.' + variable_name + ' to model.')
-
-
-def copy_variable_data_to_new_model_dict(location_of_variable_in_file, location_of_variable_in_model, verbose = False):
+        print('Successfully loaded ' + location_of_variable_in_model + '.' + variable_name + ' into model.')
+
+
+def copy_variable_data_to_new_model_dict(location_of_variable_in_file, location_of_variable_in_model, NCData, verbose = False):
     # as simple as navigating to the location_of_variable_in_model and setting it equal to the location_of_variable_in_file
 
@@ -300 +299 @@
                 dict_object.update({key: data})
     else:
-        print(f"Unrecognized object was saved and cannot be reconstructed: {location_of_variable_in_model}")
+        print(f"Unrecognized object was saved to NetCDF file and cannot be reconstructed: {location_of_variable_in_model}")

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

@@ -10 +10 @@
 
 
-function write_netCDF(model_var, filename)
+function write_netCDF(model_var, filename, varargin)
     if nargin > 2
         verbose = true;
@@ -19 +19 @@
         disp('MATLAB C2NetCDF4 v1.1.14');
     end
+    
     % model_var = class object to be saved
     % filename = path and name to save file under
     
     % Create a NetCDF file to write to
-    make_NetCDF(filename, verbose);
+    NetCDF = make_NetCDF(filename, verbose);
     
     % Create an instance of an empty model class to compare model_var against
-    global empty_model;
     empty_model = model();
 
     % Walk through the model_var class and compare subclass states to empty_model
-    walk_through_model(model_var, verbose);
+    walk_through_model(model_var, empty_model, NetCDF, verbose);
 
     % in order to handle some subclasses in the results class, we have to utilize this band-aid
     % there will likely be more band-aids added unless a class name library is created with all class names that might be added to a model
-    global NetCDF;
     try
         % if results had meaningful data, save the name of the subclass and class instance
         netcdf.inqNcid(NetCDF,'results');
-        results_subclasses_bandaid(model_var, verbose);
+        results_subclasses_bandaid(model_var, NetCDF, verbose);
         % otherwise, ignore
     catch
@@ -51 +50 @@
 
 
-function make_NetCDF(filename, verbose)
+function NetCDF = make_NetCDF(filename, verbose)
     % matlab can't handle input in the jupyter interface, so we just yell at the user to rename
     % their file if needed
@@ -71 +70 @@
     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)]);
@@ -81 +80 @@
             fprintf('Successfully created %s\n', filename);
         end
+
+        return 
     end
 end
@@ -93 +94 @@
 %}
 
-function results_subclasses_bandaid(model_var, verbose)
-    global NetCDF;
+function results_subclasses_bandaid(model_var, NetCDF, verbose)
+    
     % 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
@@ -120 +121 @@
             quality_control{end+1} = 1;
             solutionsteps{end+1} = class_instance_name;
-            %varname = ['solutionstep', num2str(i)]
-            %write_string_to_netcdf(varname, class_instance_name, groupid);
             if verbose
                 disp('Successfully stored class python subclass instance: solutionstep')
@@ -131 +130 @@
             quality_control{end+1} = 1;
             solutions{end+1} = class_instance_name;
-            %varname = ['solution', num2str(i)]
-            %write_string_to_netcdf(varname, class_instance_name, groupid);
             if verbose
                 disp('Successfully stored class python subclass instance: solution')
@@ -142 +139 @@
             quality_control{end+1} = 1;
             resultsdakotas{end+1} = class_instance_name;
-            %varname = ['resultsdakota', num2str(i)]
-            %write_string_to_netcdf(varname, class_instance_name, groupid);
             if verbose
                 disp('Successfully stored class python subclass instance: resultsdakota')
@@ -150 +145 @@
     end
     if ~isempty(solutionsteps)
-        write_cell_with_strings('solutionstep', solutionsteps, groupid, verbose)
+        write_cell_with_strings('solutionstep', solutionsteps, groupid, NetCDF, verbose)
     end
     if ~isempty(solutions)
-        write_cell_with_strings('solution', solutions, groupid, verbose)
+        write_cell_with_strings('solution', solutions, groupid, NetCDF, verbose)
     end
     if ~isempty(resultsdakotas)
-        write_cell_with_strings('resultsdakota', resultsdakotas, groupid, verbose)
+        write_cell_with_strings('resultsdakota', resultsdakotas, groupid, NetCDF, verbose)
     end
     
@@ -166 +161 @@
         disp(class(results_var.(class_instance_name)));
     else
-        disp('The results class was successfully stored on disk');
-    end
-end
-
-
-
-function walk_through_model(model_var, verbose)
-    global empty_model;
+        if verbose
+            disp('The results class was successfully stored on disk');
+        end
+    end
+end
+
+
+
+function walk_through_model(model_var, empty_model, NetCDF, verbose)
     % Iterate over first layer of model_var attributes and assume this first layer is only classes fundamental to the model() class
     % note that groups are the same as class instances/subfields in this context
@@ -183 +179 @@
         % Now we can recursively walk through the remaining subclasses
         list_of_layers = {groups{group}};
-        walk_through_subclasses(model_subclass, empty_model_subclass, list_of_layers, verbose);
-    end
-end
-        
-
-function walk_through_subclasses(model_subclass, empty_model_subclass, given_list_of_layers, verbose)
+        walk_through_subclasses(model_subclass, empty_model_subclass, list_of_layers, empty_model, NetCDF, verbose);
+    end
+end
+        
+
+function walk_through_subclasses(model_subclass, empty_model_subclass, given_list_of_layers, empty_model, NetCDF, verbose)
     % Recursivley iterate over each subclass' attributes and look for more subclasses and variables with relevant data
     % model_subclass is an object (ie, md.mesh.elements)
@@ -195 +191 @@
     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, verbose);
+            create_group(model_subclass, given_list_of_layers, NetCDF, verbose);
+            check_inversion_class(model_subclass, NetCDF, verbose);
         end
     end
@@ -220 +216 @@
                 % 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, verbose);
+                    create_group(location_of_child, list_of_layers, NetCDF, verbose);
                 
                 % this would mean that the layer above the layer we're interested in is a struct, so
@@ -230 +226 @@
                     % 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, verbose);
+                        create_group(location_of_child, list_of_layers, NetCDF, verbose);
                     % 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, verbose);
+                        walk_through_subclasses(location_of_child, location_of_child_in_empty_model, list_of_layers, empty_model, NetCDF, verbose);
                     % 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, verbose);
-                        create_group(location_of_child, list_of_layers, verbose);
+                        walk_through_subclasses(location_of_child, location_of_child_in_empty_model, list_of_layers, empty_model, NetCDF, verbose);
+                        create_group(location_of_child, list_of_layers, NetCDF, verbose);
                     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, verbose);
-                    create_group(location_of_child, list_of_layers, verbose);
+                    walk_through_subclasses(location_of_child, empty_model_subclass, list_of_layers, empty_model, NetCDF, verbose);
+                    create_group(location_of_child, list_of_layers, NetCDF, verbose);
                 end
             % this would mean it's not a struct, and must be a class/subclass
@@ -255 +251 @@
                         % 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, verbose);
+                            create_group(location_of_child, list_of_layers, NetCDF, verbose);
                         
                         elseif iscell(location_of_child)
@@ -263 +259 @@
                             else
                             % otherwise we need to save
-                                walk_through_subclasses(location_of_child, empty_model_subclass, list_of_layers, verbose);
-                                create_group(location_of_child, list_of_layers, verbose);
+                                walk_through_subclasses(location_of_child, empty_model_subclass, list_of_layers, empty_model, NetCDF, verbose);
+                                create_group(location_of_child, list_of_layers, NetCDF, verbose);
                             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, verbose);
+                            walk_through_subclasses(location_of_child, location_of_child_in_empty_model, list_of_layers, empty_model, NetCDF, verbose);
                         % 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, verbose);
-                            create_group(location_of_child, list_of_layers, verbose);
+                            walk_through_subclasses(location_of_child, location_of_child_in_empty_model, list_of_layers, empty_model, NetCDF, verbose);
+                            create_group(location_of_child, list_of_layers, NetCDF, verbose);
                         end
                     else
-                        walk_through_subclasses(location_of_child, empty_model_subclass, list_of_layers, verbose);
-                        create_group(location_of_child, list_of_layers, verbose);
+                        walk_through_subclasses(location_of_child, empty_model_subclass, list_of_layers, empty_model, NetCDF, verbose);
+                        create_group(location_of_child, list_of_layers, NetCDF, verbose);
                     end
                 catch
-                    walk_through_subclasses(location_of_child, empty_model_subclass, list_of_layers, verbose);
-                    create_group(location_of_child, list_of_layers, verbose);
+                    walk_through_subclasses(location_of_child, empty_model_subclass, list_of_layers, empty_model, NetCDF, verbose);
+                    create_group(location_of_child, list_of_layers, NetCDF, verbose);
                 end
             end
@@ -290 +286 @@
         % 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, verbose);
-            create_group(location_of_child, list_of_layers, verbose);
+            walk_through_subclasses(location_of_child, empty_model_subclass, given_list_of_layers, empty_model, NetCDF, verbose);
+            create_group(location_of_child, list_of_layers, NetCDF, verbose);
         % If it's a different error, rethrow it to MATLAB's default error handling
         else
@@ -302 +298 @@
         
 
-function create_group(location_of_child, list_of_layers, verbose)
-    global NetCDF;
+function create_group(location_of_child, list_of_layers, NetCDF, verbose)
     % location_of_child is an object
     % list_of_layers is a list like {'inversion', 'StressbalanceSolution','cost_functions_coefficients'}
@@ -336 +331 @@
         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, verbose)
+            copy_nested_struct(variable_name, location_of_child, group, NetCDF, verbose)
         end
     catch
         % 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, verbose);
-    end
-end
-
-
-
-function copy_nested_struct(parent_struct_name, address_of_struct, group, verbose)
+        create_var(variable_name, location_of_child, group, NetCDF, verbose);
+    end
+end
+
+
+
+function copy_nested_struct(parent_struct_name, address_of_struct, group, NetCDF, verbose)
     %{
         This function takes a struct of structs and saves them to netcdf. 
@@ -387 +382 @@
         for variable_name = string(substruct_fields)
             address_of_child = current_substruct.(variable_name);
-            create_var(variable_name, address_of_child, subgroup, verbose);
+            create_var(variable_name, address_of_child, subgroup, NetCDF, verbose);
         end
     end
@@ -399 +394 @@
 % 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, verbose)
-    global NetCDF;
+function check_inversion_class(model_var, NetCDF, verbose)
+    
     % Define a persistent variable to ensure this function is only run once
     persistent executed;
@@ -412 +407 @@
 
         if isa(model_var, 'm1qn3inversion')
-            write_string_to_netcdf('inversion_class_name', 'm1qn3inversion', groupid, verbose);
+            write_string_to_netcdf('inversion_class_name', 'm1qn3inversion', groupid, NetCDF, verbose);
             if verbose
                 disp('Successfully saved inversion class instance m1qn3inversion')
             end
         elseif isa(model_var, 'taoinversion')
-            write_string_to_netcdf('inversion_class_name', 'taoinversion', groupid, verbose);
+            write_string_to_netcdf('inversion_class_name', 'taoinversion', groupid, NetCDF, verbose);
             if verbose 
                 disp('Successfully saved inversion class instance taoinversion')
             end
         else
-            write_string_to_netcdf('inversion_class_name', 'inversion', groupid, verbose);
+            write_string_to_netcdf('inversion_class_name', 'inversion', groupid, NetCDF,  verbose);
             if verbose
                 disp('Successfully saved inversion class instance inversion')
@@ -433 +428 @@
 
 
-function create_var(variable_name, address_of_child, group, verbose)
-    global NetCDF;
+function create_var(variable_name, address_of_child, group, NetCDF, verbose)
     % There are lots of different variable types that we need to handle from the model class
     
@@ -444 +438 @@
     % This first conditional statement will catch numeric arrays (matrices) of any dimension and save them
     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, verbose);
+        write_numeric_array_to_netcdf(variable_name, address_of_child, group, NetCDF, verbose);
 
     % check if it's a string
     elseif ischar(address_of_child)
-        write_string_to_netcdf(variable_name, address_of_child, group, verbose);
+        write_string_to_netcdf(variable_name, address_of_child, group, NetCDF, verbose);
 
     % or an empty variable
@@ -456 +450 @@
     % 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, verbose)
+        write_cell_with_strings(variable_name, address_of_child, group, NetCDF, verbose)
         
     % or an empty list
@@ -503 +497 @@
 
 
-function write_cell_with_strings(variable_name, address_of_child, group, verbose)
+function write_cell_with_strings(variable_name, address_of_child, group, NetCDF, verbose)
     %{
     Write cell array (ie {'one' 'two' 'three'}) to netcdf
     %}
-    global NetCDF
     
     if isempty(address_of_child)
@@ -542 +535 @@
 
 
-function write_string_to_netcdf(variable_name, address_of_child, group, verbose)
+function write_string_to_netcdf(variable_name, address_of_child, group, NetCDF, verbose)
     % netcdf and strings don't get along.. we have to do it 'custom':
-    global NetCDF;
 
     the_string_to_save = address_of_child;
@@ -590 +582 @@
 
 
-function write_numeric_array_to_netcdf(variable_name, address_of_child, group, verbose)
-    global NetCDF;
+function write_numeric_array_to_netcdf(variable_name, address_of_child, group, NetCDF, verbose)
     % get the dimensions we'll need
     intdim = netcdf.inqDimID(NetCDF,'int');

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

@@ -35 +35 @@
     
     # Create a NetCDF file to write to
-    make_NetCDF(filename, verbose)
+    NetCDF = make_NetCDF(filename, verbose)
     
     # Create an instance of an empty md class to compare md_var against
-    global empty_model
     empty_model = model()
 
     # Walk through the md class and compare subclass states to empty_model
-    walk_through_model(md, verbose)
+    walk_through_model(md, empty_model, NetCDF, verbose)
 
     # in order to handle some subclasses in the results class, we have to utilize this band-aid
@@ -49 +48 @@
         # if results has meaningful data, save the name of the subclass and class instance
         NetCDF.groups['results']
-        results_subclasses_bandaid(md, verbose)
+        results_subclasses_bandaid(md, NetCDF, verbose)
         # otherwise, ignore
     except KeyError:
@@ -60 +59 @@
     
 
-def results_subclasses_bandaid(md, verbose = False):
+def results_subclasses_bandaid(md, NetCDF, verbose = False):
     # 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 md that we're trying to save
@@ -90 +89 @@
 
     if solutionsteps != []:
-        write_string_to_netcdf(variable_name=str('solutionstep'), address_of_child=solutionsteps, group=NetCDF.groups['results'], list=True, verbose=verbose)
+        write_string_to_netcdf(variable_name=str('solutionstep'), address_of_child=solutionsteps, group=NetCDF.groups['results'], list=True, NetCDF=NetCDF, verbose=verbose)
 
     if solutions != []:
-        write_string_to_netcdf(variable_name=str('solution'), address_of_child=solutions, group=NetCDF.groups['results'], list=True, verbose=verbose)
+        write_string_to_netcdf(variable_name=str('solution'), address_of_child=solutions, group=NetCDF.groups['results'], list=True, NetCDF=NetCDF, verbose=verbose)
 
     if resultsdakotas != []:
-        write_string_to_netcdf(variable_name=str('resultsdakota'), address_of_child=resultsdakotas, group=NetCDF.groups['results'], list=True, verbose=verbose)
+        write_string_to_netcdf(variable_name=str('resultsdakota'), address_of_child=resultsdakotas, group=NetCDF.groups['results'], list=True, NetCDF=NetCDF, verbose=verbose)
 
     
@@ -123 +122 @@
     else:
         # Otherwise create the file and define it globally so other functions can call it
-        global NetCDF
         NetCDF = Dataset(filename, 'w', format='NETCDF4')
         NetCDF.history = 'Created ' + time.ctime(time.time())
@@ -133 +131 @@
         print('Successfully created ' + filename)
 
-
-def walk_through_model(md, verbose = False):
+    return NetCDF
+
+
+def walk_through_model(md, empty_model, NetCDF, verbose= False):
     # Iterate over first layer of md_var attributes and assume this first layer is only classes
     for group in md.__dict__.keys():
@@ -143 +143 @@
 
         # Recursively walk through subclasses
-        walk_through_subclasses(address, empty_address, layers, verbose)       
-
-
-def walk_through_subclasses(address, empty_address, layers: list, verbose = False):
+        walk_through_subclasses(address, empty_address, layers, NetCDF, empty_model, verbose)       
+
+
+def walk_through_subclasses(address, empty_address, layers: list, NetCDF, empty_model, verbose = False):
     # See if we have an object with keys or a not
     try:
@@ -167 +167 @@
             # if the current object is a results.<solution> object and has the steps attr it needs special treatment
             if isinstance(address_of_child, solution) and len(address_of_child.steps) != 0:
-                create_group(address_of_child, current_layer, is_struct = True, verbose = verbose)
+                create_group(address_of_child, current_layer, is_struct = True, NetCDF=NetCDF, verbose = verbose)
 
             # if the variable is an array, assume it has relevant data (this is because the next line cannot evaluate "==" with an array)
             elif isinstance(address_of_child, np.ndarray):
-                create_group(address_of_child, current_layer, is_struct = False, verbose = verbose)
+                create_group(address_of_child, current_layer, is_struct = False, NetCDF=NetCDF, verbose = verbose)
             
             # see if the child exists in the empty md. If not, record it in the netcdf
@@ -181 +181 @@
                     # if the attributes are identical we don't need to save anything
                     if address_of_child == address_of_child_in_empty_class:
-                        walk_through_subclasses(address_of_child, address_of_child_in_empty_class, current_layer, verbose)
+                        walk_through_subclasses(address_of_child, address_of_child_in_empty_class, current_layer, NetCDF, empty_model, verbose)
     
                     # If it has been modified, record it in the NetCDF file
                     else:
-                        create_group(address_of_child, current_layer, is_struct = False, verbose = verbose)
-                        walk_through_subclasses(address_of_child, address_of_child_in_empty_class, current_layer, verbose)
+                        create_group(address_of_child, current_layer, is_struct = False, NetCDF=NetCDF, verbose = verbose)
+                        walk_through_subclasses(address_of_child, address_of_child_in_empty_class, current_layer, NetCDF, empty_model, verbose)
     
                 except KeyError: # record in netcdf and continue to walk thru md
-                    walk_through_subclasses(address_of_child, empty_address, current_layer, verbose)
-                    create_group(address_of_child, current_layer, is_struct = False, verbose = verbose)
+                    walk_through_subclasses(address_of_child, empty_address, current_layer, NetCDF, empty_model, verbose)
+                    create_group(address_of_child, current_layer, is_struct = False, NetCDF=NetCDF, verbose = verbose)
     else: pass
 
 
-def create_group(address_of_child, layers, is_struct = False, verbose = False):
+def create_group(address_of_child, layers, is_struct = False, NetCDF=None, verbose = False):
 
     # Handle the first layer of the group(s)
@@ -205 +205 @@
     # need to check if inversion or m1qn3inversion class
     if group_name == 'inversion':
-        check_inversion_class(address_of_child, verbose)
+        check_inversion_class(address_of_child, NetCDF, verbose)
     else: pass
 
@@ -220 +220 @@
     if is_struct:
         parent_struct_name = layers[-1]
-        copy_nested_results_struct(parent_struct_name, address_of_child, group, verbose)
+        copy_nested_results_struct(parent_struct_name, address_of_child, group, NetCDF, verbose)
     
     else:
         variable_name = layers[-1]
-        create_var(variable_name, address_of_child, group, verbose)
+        create_var(variable_name, address_of_child, group, NetCDF, verbose)
             
 
@@ -242 +242 @@
 
 @singleton
-def check_inversion_class(address_of_child, verbose = False):
+def check_inversion_class(address_of_child, NetCDF, verbose = False):
     # need to make sure that we have the right inversion class: inversion, m1qn3inversion, taoinversion
     if isinstance(address_of_child, m1qn3inversion):
-        write_string_to_netcdf(variable_name=str('inversion_class_name'), address_of_child=str('m1qn3inversion'), group=NetCDF.groups['inversion'], verbose = verbose)
+        write_string_to_netcdf(variable_name=str('inversion_class_name'), address_of_child=str('m1qn3inversion'), group=NetCDF.groups['inversion'], NetCDF=NetCDF, verbose = verbose)
         if verbose:
             print('Successfully saved inversion class instance ' + 'm1qn3inversion')
     elif isinstance(address_of_child, taoinversion):
-        write_string_to_netcdf(variable_name=str('inversion_class_name'), address_of_child=str('taoinversion'), group=NetCDF.groups['inversion'], verbose = verbose)
+        write_string_to_netcdf(variable_name=str('inversion_class_name'), address_of_child=str('taoinversion'), group=NetCDF.groups['inversion'], NetCDF=NetCDF, verbose = verbose)
         if verbose:
             print('Successfully saved inversion class instance ' + 'taoinversion')
     else:
-        write_string_to_netcdf(variable_name=str('inversion_class_name'), address_of_child=str('inversion'), group=NetCDF.groups['inversion'], verbose = verbose)
+        write_string_to_netcdf(variable_name=str('inversion_class_name'), address_of_child=str('inversion'), group=NetCDF.groups['inversion'], NetCDF=NetCDF, verbose = verbose)
         if verbose:
             print('Successfully saved inversion class instance ' + 'inversion')
 
 
-def copy_nested_results_struct(parent_struct_name, address_of_struct, group, verbose = False):
+def copy_nested_results_struct(parent_struct_name, address_of_struct, group, NetCDF, verbose = False):
     '''
         This function takes a solution class instance and saves the solutionstep instances from <solution>.steps to the netcdf. 
@@ -274 +274 @@
 
     # make sure other systems can flag the nested struct type
-    write_string_to_netcdf('this_is_a_nested', 'struct', group, list=False, verbose = verbose)
+    write_string_to_netcdf('this_is_a_nested', 'struct', group, list=False, NetCDF=NetCDF, verbose = verbose)
 
     # other systems know the name of the parent struct because it's covered by the results/qmu functions above
@@ -290 +290 @@
         for variable in substruct_fields:
             address_of_child = current_substruct.__dict__[variable]
-            create_var(variable, address_of_child, subgroup, verbose = verbose)
+            create_var(variable, address_of_child, subgroup, NetCDF, verbose = verbose)
     
     if verbose:
@@ -296 +296 @@
     
         
-def create_var(variable_name, address_of_child, group, verbose = False):
+def create_var(variable_name, address_of_child, group, NetCDF, verbose = False):
     # There are lots of different variable types that we need to handle from the md class
     
     # This first conditional statement will catch numpy arrays of any dimension and save them
     if isinstance(address_of_child, np.ndarray):
-        write_numpy_array_to_netcdf(variable_name, address_of_child, group, verbose=verbose)
+        write_numpy_array_to_netcdf(variable_name, address_of_child, group, NetCDF, verbose=verbose)
     
     # check if it's an int
@@ -315 +315 @@
     # or a string
     elif isinstance(address_of_child, str):
-        write_string_to_netcdf(variable_name, address_of_child, group, verbose=verbose)
+        write_string_to_netcdf(variable_name, address_of_child, group, NetCDF, verbose=verbose)
 
     #or a bool
@@ -331 +331 @@
     elif isinstance(address_of_child,list) and isinstance(address_of_child[0],str):
         for string in address_of_child:
-            write_string_to_netcdf(variable_name, string, group, list=True, verbose=verbose)
+            write_string_to_netcdf(variable_name, string, group, list=True, NetCDF=NetCDF, verbose=verbose)
 
     # or a regular list
@@ -355 +355 @@
     
 
-def write_string_to_netcdf(variable_name, address_of_child, group, list=False, verbose = False):
+def write_string_to_netcdf(variable_name, address_of_child, group, list=False, NetCDF=None, verbose = False):
     # netcdf and strings dont get along.. we have to do it 'custom':
     # if we hand it an address we need to do it this way:
@@ -431 +431 @@
 
 
-def write_numpy_array_to_netcdf(variable_name, address_of_child, group, verbose = False):
+def write_numpy_array_to_netcdf(variable_name, address_of_child, group, NetCDF, verbose = False):
     # to make a nested array in netCDF, we have to get the dimensions of the array,
     # create corresponding dimensions in the netCDF file, then we can make a variable