support modifying netcdf storage

Author: mjreno

autotest/regression/test_mf6_netcdf.py

@@ -1593,21 +1593,20 @@ def plot(
         return axes
 
     def _set_storage_netcdf(self, nc_dataset, create=False):
-        storage = self._get_storage_obj()
-        package_dim = self.data_dimensions.package_dim
-        m = package_dim.model_dim[0].model_name
-        # TODO: fix, this won't work for multi-packages #NETCDF-DEV
-        p = self.structure.get_package()
-        n = self.structure.name.lower()
-        input_tag = f"{m}/{p}/{n}".lower()
-
         if create:
             # add array to netcdf dataset
-            data = self._get_data()
-            nc_dataset.create_array(p, n, data, self.structure.shape)
+            # TODO: fix, this won't work for multi-packages #NETCDF-DEV
+            nc_dataset.create_array(
+                self.structure.get_package(),
+                self.structure.name.lower(),
+                self._get_data(),
+                self.structure.shape,
+                self.structure.longname,
+            )
 
+        storage = self._get_storage_obj()
         storage._set_storage_netcdf(
-            nc_dataset, input_tag, self.structure.layered, storage.layer_storage.get_total_size() - 1
+            nc_dataset, self.structure.layered, storage.layer_storage.get_total_size() - 1
         )
 
 

examples/data/mf6/netcdf/test_gwf_sto01_mesh/gwf_sto01/gwf_sto01.in.nc

@@ -73,9 +73,7 @@ class LayerStorage:
         whether the data is stored in a binary file
     nc_dataset : ModelNetCDFDataset or None
         model netcdf dataset
-    nc_input_tag : str
-        parameter netcdf file input tag
-    nc_layered : bool  #NETCDF-DEV verify this is needed
+    nc_layered : bool
         array storage data is layered
 
     Methods
@@ -122,7 +120,6 @@ def __init__(
         self.iprn = None
         self.binary = False
         self.nc_dataset = None
-        self.nc_input_tag = None
         self.nc_layered = False
 
     def set_internal_constant(self):
@@ -212,6 +209,8 @@ class DataStorage:
         what internal type is the data stored in (ndarray, recarray, scalar)
     layered : bool
         is the data layered
+    netcdf : bool
+        is the data stored in netcdf
     pre_data_comments : string
         any comments before the start of the data
     comments : dict
@@ -1026,6 +1025,9 @@ def _set_array(
 
         success = False
         if preserve_record:
+            if self.netcdf and isinstance(data, list):
+                # TODO: is this a kludge? #NETCDF-DEV
+                data = self._to_ndarray(data, layer)
             if isinstance(data, np.ndarray):
                 # try to store while preserving the structure of the
                 # existing record
@@ -1126,16 +1128,24 @@ def _set_array_layer(self, data, layer, multiplier, key, preserve_record):
                 self.layer_storage[layer].data_storage_type
                 == DataStorageType.external_file
             ):
-                self.store_external(
-                    self.layer_storage[layer].fname,
-                    layer,
-                    self.layer_storage[layer].factor,
-                    self.layer_storage[layer].iprn,
-                    data=data,
-                    do_not_verify=True,
-                    binary=self.layer_storage[layer].binary,
-                    preserve_record=preserve_record,
-                )
+                if self.netcdf:
+                    self.store_netcdf(
+                        layer,
+                        self.layer_storage[layer].factor,
+                        self.layer_storage[layer].iprn,
+                        data=data,
+                    )
+                else:
+                    self.store_external(
+                        self.layer_storage[layer].fname,
+                        layer,
+                        self.layer_storage[layer].factor,
+                        self.layer_storage[layer].iprn,
+                        data=data,
+                        do_not_verify=True,
+                        binary=self.layer_storage[layer].binary,
+                        preserve_record=preserve_record,
+                    )
             else:
                 self.store_internal(
                     data,
@@ -1152,7 +1162,15 @@ def _set_array_layer(self, data, layer, multiplier, key, preserve_record):
                 data[0], data_type
             ):
                 # store data as const
-                self.store_internal(data, layer, True, multiplier, key=key)
+                if self.netcdf:
+                    self.store_netcdf(
+                        layer,
+                        self.layer_storage[layer].factor,
+                        self.layer_storage[layer].iprn,
+                        data=data,
+                    )
+                else:
+                    self.store_internal(data, layer, True, multiplier, key=key)
                 return True
 
         # look for internal and open/close data
@@ -1861,6 +1879,28 @@ def store_external(
             layer_new, fp_relative, print_format, binary
         )
 
+    def store_netcdf(
+        self,
+        layer=None,
+        multiplier=None,
+        print_format=None,
+        data=None,
+    ):
+        file_access = MFFileAccessArray(
+            self.data_dimensions.structure,
+            self.data_dimensions,
+            self._simulation_data,
+            self._data_path,
+            self._stress_period,
+        )
+        file_access.set_netcdf_array(
+            self.layer_storage[layer].nc_dataset,
+            self.data_dimensions.structure.get_package(),
+            self.data_dimensions.structure.name,
+            data,
+            layer[0],
+        )
+
     def set_ext_file_attributes(self, layer, file_path, print_format, binary):
         # point to the external file and set flags
         self.layer_storage[layer].fname = file_path
@@ -1880,12 +1920,11 @@ def point_to_existing_external_file(self, arr_line, layer):
         self.set_ext_file_attributes(layer, data_file, print_format, binary)
         self.layer_storage[layer].factor = multiplier
 
-    def _set_storage_netcdf(self, nc_dataset, input_tag, layered, layer):
+    def _set_storage_netcdf(self, nc_dataset, layered, layer):
         self.netcdf = True
         is_layered = layered and layer > 0
         for idx in self.layer_storage.indexes():
             self.layer_storage[idx].nc_dataset = nc_dataset
-            self.layer_storage[idx].nc_input_tag = input_tag
             self.layer_storage[idx].nc_layered = is_layered
             self.layer_storage[
                 idx
@@ -2010,9 +2049,10 @@ def external_to_internal(
                 # TODO: ensure multiplier only set by open/close #NETCDF-DEV
                 for idx in self.layer_storage.indexes():
                     data_out = (
-                        file_access.load_netcdf_array(
+                        file_access.read_netcdf_array(
                             self.layer_storage[layer].nc_dataset,
-                            self.layer_storage[layer].nc_input_tag,
+                            self.data_dimensions.structure.get_package(),
+                            self.data_dimensions.structure.name,
                             idx[0],
                         )
                 )
@@ -2479,9 +2519,10 @@ def _build_full_data(self, apply_multiplier=False):
                     else:
                         nc_layer = -1
                     data_out = (
-                        file_access.load_netcdf_array(
+                        file_access.read_netcdf_array(
                             self.layer_storage[layer].nc_dataset,
-                            self.layer_storage[layer].nc_input_tag,
+                            self.data_dimensions.structure.get_package(),
+                            self.data_dimensions.structure.name,
                             nc_layer,
                         )
                         * mult

flopy/mf6/data/mfdataarray.py

@@ -467,13 +467,24 @@ def read_binary_data_from_file(
             fd.close()
             return bin_data
 
-    def load_netcdf_array(
+    def read_netcdf_array(
         self,
         nc_dataset,
-        nc_tag,
+        package,
+        param,
         layer,
     ):
-        return nc_dataset.array(nc_tag, layer + 1)
+        return nc_dataset.array(package, param, layer)
+
+    def set_netcdf_array(
+        self,
+        nc_dataset,
+        package,
+        param,
+        data,
+        layer,
+    ):
+        nc_dataset.set_array(package, param, data, layer)
 
     def get_data_string(self, data, data_type, data_indent=""):
         layer_data_string = [str(data_indent)]

flopy/mf6/data/mfdatastorage.py

@@ -1425,7 +1425,6 @@ def __init__(self, data_item, model_data, package_type, dfn_list):
             or "nodes" in data_item.shape
             or len(data_item.layer_dims) > 1
         )
-        # TODO: only gwf, gwt, gwe models NETCDF-DEV
         self.netcdf = (
             ("ncol" in data_item.shape
             or "nrow" in data_item.shape

flopy/mf6/data/mffileaccess.py

@@ -182,10 +182,10 @@ def build_dfn_string(dfn_list, header, package_abbr, flopy_dict):
         # process each line in a data item
         for line in data_item:
             line = line.strip()
-            # do not include the description of longname
+            # do not include the description
             if not line.lower().startswith(
                 "description"
-            ) and not line.lower().startswith("longname"):
+            ):
                 line = line.replace('"', "'")
                 line_length += len(line) + 4
                 if not first_line: