add update_dataset functions

Author: mjreno

.docs/Notebooks/netcdf01_tutorial.py

@@ -242,44 +242,12 @@ def create_sim(ws):
     return sim
 
 
-# ## Create helper function to update dataset
-#
-# This function updates an xarray dataset to add variables described
-# in a FloPy provided dictionary.
-#
-# The dimmap variable relates NetCDF dimension names to a value.
-
-
-# A subroutine that can update an xarray dataset with package
-# netcdf information stored in a dict
-def add_netcdf_vars(dataset, nc_info, dimmap):
-    def _data_shape(shape):
-        dims_l = []
-        for d in shape:
-            dims_l.append(dimmap[d])
-
-        return dims_l
-
-    for v in nc_info:
-        varname = nc_info[v]["varname"]
-        data = np.full(
-            _data_shape(nc_info[v]["netcdf_shape"]),
-            nc_info[v]["attrs"]["_FillValue"],
-            dtype=nc_info[v]["xarray_type"],
-        )
-        var_d = {varname: (nc_info[v]["netcdf_shape"], data)}
-        dataset = dataset.assign(var_d)
-        for a in nc_info[v]["attrs"]:
-            dataset[varname].attrs[a] = nc_info[v]["attrs"][a]
-
-    return dataset
-
-
 # ## Create simulation workspace
 
 # create temporary directories
-temp_dir = TemporaryDirectory()
-workspace = Path(temp_dir.name)
+# temp_dir = TemporaryDirectory()
+# workspace = Path(temp_dir.name)
+workspace = Path("./working")
 
 # ## Write and run baseline simulation
 
@@ -323,49 +291,39 @@ def _data_shape(shape):
 # First, retrieve and store the netcdf info dictionary and display
 # its contents. Then, in the following step, update the dataset with
 # the model scoped attributes defined in the dictionary.
+#
+# These 2 operations can also be accomplised by calling `update_dataset()`
+# on the model object. Analogous functions for the package are shown
+# below.
 
 # get model netcdf info
 nc_info = gwf.netcdf_info()
 pprint(nc_info)
 
-# update dataset with required attributes
+# update dataset directly with required attributes
 for a in nc_info["attrs"]:
     ds.attrs[a] = nc_info["attrs"][a]
 
-# ## Map dataset dimension names to values
-
-# define dimensional info
-dimmap = {
-    "time": sum(gwf.modeltime.nstp),
-    "z": gwf.modelgrid.nlay,
-    "y": gwf.modelgrid.nrow,
-    "x": gwf.modelgrid.ncol,
-}
-
-# ## Access package NetCDF attributes
-#
-# Access package scoped NetCDF details by storing the dictionary returned
-# from `netcdf_info()`. We need to set package variable attributes that are
-# stored in the package netcdf info dict, but we also need other information
-# that is relevant to creating the variables themselves.
+# ## Update the dataset with supported `DIS` arrays
 #
-# The contents of the info dictionary are shown and then, in the following
-# step, the dictionary and the dataset are passed to a helper routine that
-# create the intended array variables.
+# Add NetCDF supported data arrays in package to dataset. Internally, this call
+# uses a `netcdf_info()` package dictionary to determine candidate variables
+# and relevant information about them. Alternatively, this dictionary can
+# be directly accessed, updated, and passed to the `update_dataset()` function.
+# That workflow will be demonstrated in the `NPF` package update which follows.
 
-# get dis package netcdf info
+# update dataset with `DIS` arrays
 dis = gwf.get_package("dis")
-nc_info = dis.netcdf_info()
-pprint(nc_info)
-
-# create dis dataset variables
-ds = add_netcdf_vars(ds, nc_info, dimmap)
+ds = dis.update_dataset(ds)
 
 # ## Update array data
 #
 # We have created dataset array variables for the package but they do not yet
 # define the expected input data for MODFLOW 6. We will take advantage of the
 # existing simulation objects and update the dataset.
+#
+# Default dataset variable names are defined in the package `netcdf_info()`
+# dictionary.
 
 # update dataset from dis arrays
 ds["dis_delr"].values = dis.delr.get_data()
@@ -378,7 +336,7 @@ def _data_shape(shape):
 #
 # MODFLOW 6 input data for the package is now in the dataset. Once the NetCDF
 # file is generated, we need to configure MODFLOW 6 so that it looks to that
-# file for the package array input. The ASCII file will no longer defined the
+# file for the package array input. The ASCII file will no longer define the
 # arrays- instead the array names will be followed by the NETCDF keyword.
 #
 # We will simply overwrite the entire MODFLOW 6 `DIS` package input file with the
@@ -404,21 +362,46 @@ def _data_shape(shape):
 with open(workspace / "netcdf" / "uzf01.dis", "r") as fh:
     print(fh.read())
 
-# ## Update MODFLOW 6 package input file
+# ## Access `NPF` package NetCDF attributes
 #
-# Follow the same process as above for the `NPF` package.
+# Access package scoped NetCDF details by storing the dictionary returned
+# from `netcdf_info()`. We need to set package variable attributes that are
+# stored in the package netcdf info dict, but we also need other information
+# that is relevant to creating the variables themselves.
+#
+# The contents of the info dictionary are shown and then, in the following
+# step, the dictionary and the dataset are passed to a helper routine that
+# create the intended array variables.
 
 # get npf package netcdf info
 npf = gwf.get_package("npf")
 nc_info = npf.netcdf_info()
 pprint(nc_info)
 
-# create npf dataset variables
-ds = add_netcdf_vars(ds, nc_info, dimmap)
+# ## Update package `netcdf_info` dictionary and dataset
+#
+# Here we replace the default name for the `NPF K` input parameter and add
+# the `standard_name` attribute to it's attribute dictionary.  The dictionary
+# is then passed to the `update_dataset()` function. Note the udpated name
+# is used in the subsequent block when updating the array values.
+
+# update dataset with `NPF` arrays
+nc_info["k"]["varname"] = "npf_k_updated"
+nc_info["k"]["attrs"]["standard_name"] = "soil_hydraulic_conductivity_at_saturation"
+ds = npf.update_dataset(ds, netcdf_info=nc_info)
+
+# ## Update array data
 
 # update dataset from npf arrays
 ds["npf_icelltype"].values = npf.icelltype.get_data()
-ds["npf_k"].values = npf.k.get_data()
+ds["npf_k_updated"].values = npf.k.get_data()
+
+# ## Show dataset `NPF K` parameter with udpates
+
+# print dataset npf k variable
+print(ds["npf_k_updated"])
+
+# ## Update MODFLOW 6 package input file
 
 # rewrite mf6 npf input to read from netcdf
 with open(workspace / "netcdf" / "uzf01.npf", "w") as f:
@@ -431,21 +414,13 @@ def _data_shape(shape):
 with open(workspace / "netcdf" / "uzf01.npf", "r") as fh:
     print(fh.read())
 
-# ## Update MODFLOW 6 package input file
-#
-# Follow the same process as above for the `GHBG` package. The difference is
-# that this is PERIOD input and therefore stored as timeseries data in the
-# NetCDF file. As NETCDF timeseries are defined in terms of total number of
-# simulation steps, care must be taken in the translation of FloPy period
-# data to the timeseries.
+# ## Update the dataset with supported `GHBG` arrays
 
-# get ghbg package netcdf info
+# update dataset with 'GHBG' arrays
 ghbg = gwf.get_package("ghbg_0")
-nc_info = ghbg.netcdf_info()
-pprint(nc_info)
+ds = ghbg.update_dataset(ds)
 
-# create ghbg dataset variables
-ds = add_netcdf_vars(ds, nc_info, dimmap)
+# ## Update array data
 
 # update bhead netcdf array from flopy perioddata
 # timeseries step index is first of stress period
@@ -459,17 +434,7 @@ def _data_shape(shape):
     istp = sum(gwf.modeltime.nstp[0:p])
     ds["ghbg_0_cond"].values[istp] = ghbg.cond.get_data()[p]
 
-# ## Display generated dataset
-
-# show the dataset
-print(ds)
-
-# ## Export generated dataset to NetCDF
-
-# write dataset to netcdf
-ds.to_netcdf(
-    workspace / "netcdf/uzf01.structured.nc", format="NETCDF4", engine="netcdf4"
-)
+# ## Update MODFLOW 6 package input file
 
 # rewrite mf6 ghbg input to read from netcdf
 with open(workspace / "netcdf/uzf01.ghbg", "w") as f:
@@ -486,6 +451,18 @@ def _data_shape(shape):
 with open(workspace / "netcdf" / "uzf01.ghbg", "r") as fh:
     print(fh.read())
 
+# ## Display generated dataset
+
+# show the dataset
+print(ds)
+
+# ## Export generated dataset to NetCDF
+
+# write dataset to netcdf
+ds.to_netcdf(
+    workspace / "netcdf/uzf01.structured.nc", format="NETCDF4", engine="netcdf4"
+)
+
 # ## Run MODFLOW 6 simulation with NetCDF input
 #
 # The simulation generated by this tutorial should be runnable by

.docs/Notebooks/netcdf02_tutorial.py

@@ -12,8 +12,6 @@
 #     display_name: Python 3 (ipykernel)
 #     language: python
 #     name: python3
-#   metadata:
-#     section: mf6
 # ---
 
 # # MODFLOW 6: Generate MODFLOW 6 NetCDF input from existing FloPy sim
@@ -165,7 +163,7 @@ def create_sim(ws):
 
         uzf_spd.update({t: spd})
 
-    # Work up the GHB / GHBG boundary
+    # Work up the GHBG boundary
     ghb_ids = [(ncol - 1) + i * ncol for i in range(nrow)]
     abhead = np.full((nlay, ncpl), DNODATA, dtype=float)
     acond = np.full((nlay, ncpl), DNODATA, dtype=float)
@@ -464,16 +462,6 @@ def _data_shape(shape):
                 l
             ].flatten()
 
-# ## Display generated dataset
-
-# show the dataset
-print(ds)
-
-# ## Export generated dataset to NetCDF
-
-# write dataset to netcdf
-ds.to_netcdf(workspace / "netcdf/uzf02.layered.nc", format="NETCDF4", engine="netcdf4")
-
 # rewrite mf6 ghbg input to read from netcdf
 with open(workspace / "netcdf/uzf02.ghbg", "w") as f:
     f.write("BEGIN options\n")
@@ -487,6 +475,16 @@ def _data_shape(shape):
 with open(workspace / "netcdf" / "uzf02.ghbg", "r") as fh:
     print(fh.read())
 
+# ## Display generated dataset
+
+# show the dataset
+print(ds)
+
+# ## Export generated dataset to NetCDF
+
+# write dataset to netcdf
+ds.to_netcdf(workspace / "netcdf/uzf02.layered.nc", format="NETCDF4", engine="netcdf4")
+
 # ## Run MODFLOW 6 simulation with NetCDF input
 #
 # The simulation generated by this tutorial should be runnable by

flopy/mf6/mfmodel.py

@@ -2245,3 +2245,14 @@ def netcdf_info(self, mesh=None):
         return MFModel.netcdf_model(
             self.name, self.model_type, self.get_grid_type(), mesh
         )
+
+    def update_dataset(self, dataset, netcdf_info=None, mesh=None):
+        if netcdf_info is None:
+            nc_info = self.netcdf_info(mesh=mesh)
+        else:
+            nc_info = netcdf_info
+
+        for a in nc_info["attrs"]:
+            dataset.attrs[a] = nc_info["attrs"][a]
+
+        return dataset

flopy/mf6/mfpackage.py

@@ -3505,6 +3505,8 @@ def _add_entry(tagname, iaux=None, layer=None):
                     a["attrs"]["_FillValue"] = FILLNA_DBL
                 elif data_item.block_name == "period":
                     a["attrs"]["_FillValue"] = DNODATA
+            if data_item.longname is not None:
+                a["attrs"]["longname"] = data_item.longname
 
             # set dictionary
             attrs[key] = a
@@ -3593,6 +3595,50 @@ def netcdf_info(self, mesh=None):
 
         return attrs
 
+    def update_dataset(self, dataset, netcdf_info=None, mesh=None):
+        if netcdf_info is None:
+            nc_info = self.netcdf_info(mesh=mesh)
+        else:
+            nc_info = netcdf_info
+
+        modelgrid = self.model_or_sim.modelgrid
+        modeltime = self.model_or_sim.modeltime
+
+        if mesh is None:
+            dimmap = {
+                "time": sum(modeltime.nstp),
+                "z": modelgrid.nlay,
+                "y": modelgrid.nrow,
+                "x": modelgrid.ncol,
+            }
+        elif mesh.upper() == "LAYERED":
+            dimmap = {
+                "time": sum(gwf.modeltime.nstp),
+                "z": gwf.modelgrid.nlay,
+                "nmesh_face": gwf.modelgrid.ncpl,
+            }
+
+        def _data_shape(shape):
+            dims_l = []
+            for d in shape:
+                dims_l.append(dimmap[d])
+
+            return dims_l
+
+        for v in nc_info:
+            varname = nc_info[v]["varname"]
+            data = np.full(
+                _data_shape(nc_info[v]["netcdf_shape"]),
+                nc_info[v]["attrs"]["_FillValue"],
+                dtype=nc_info[v]["xarray_type"],
+            )
+            var_d = {varname: (nc_info[v]["netcdf_shape"], data)}
+            dataset = dataset.assign(var_d)
+            for a in nc_info[v]["attrs"]:
+                dataset[varname].attrs[a] = nc_info[v]["attrs"][a]
+
+        return dataset
+
 
 class MFChildPackages:
     """

flopy/mf6/utils/codegen/filters.py

@@ -320,7 +320,7 @@ def _meta():
 
             def __dfn():
                 def _var(var: dict) -> List[str]:
-                    exclude = ["longname", "description"]
+                    exclude = ["description"]
                     name = var["name"]
                     subpkg = dfn.get("fkeys", dict()).get(name, None)
                     if subpkg: