pyDeltaRCM 2.1.9__tar.gz → 2.2.0__tar.gz

{pydeltarcm-2.1.9/pyDeltaRCM.egg-info → pydeltarcm-2.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyDeltaRCM
-Version: 2.1.9
+Version: 2.2.0
 Summary: Python version of original Matlab DeltaRCM.
 Author-email: Andrew Moodie <amoodie@tamu.edu>
 Maintainer-email: Andrew Moodie <amoodie@tamu.edu>

{pydeltarcm-2.1.9 → pydeltarcm-2.2.0}/docs/source/conf.py

@@ -113,5 +113,7 @@ linkcheck_ignore = [
     r'https://doi.org/10.1029/2021GL095053',
     r'https://doi.org/10.1029/2018GL079405',
     r'https://doi.org/10.1029/2022JF006762',
-    r'https://doi.org/10.1086/626637'
-]
+    r'https://doi.org/10.1086/626637',
+    r'https://doi.org/10.1029/2023JE008183',
+    r'https://doi.org/10.1029/2023je008183'
+]

{pydeltarcm-2.1.9 → pydeltarcm-2.2.0}/docs/source/examples/custom_saving.rst

@@ -17,11 +17,11 @@ For example, ``self._save_fig_list['active_layer'] = ['active_layer']`` will pro
 When adding variables or metadata to be initialized and subsequently saved in the output netCDF, the key-value pair relationship is as follows.
 The key added to ``self._save_var_list`` is the name of the variable as it will be recorded in the netCDF file, this *does not* have to correspond to the name of an attribute in the model.
 To add a variable to the metadata, a key must be added to ``self._save_var_list['meta']``.
-The expected value for a given key is a list containing strings indicating the model attribute to be saved, its units, the variable type, and lastly the variable dimensions (e.g., ``['active_layer', 'fraction', 'f4', ('time', 'x', 'y')]`` for the active layer).
+The expected value for a given key is a list containing strings indicating the model attribute to be saved, its units, the variable type, and lastly the variable dimensions (e.g., ``['active_layer', 'fraction', 'f4', ('seconds', 'x', 'y')]`` for the active layer).
 
 .. important::
 
-    The dimensions of the custom variable being specified must match *exactly* with one of the three standard dimensions: `x`, `y`, `time`.
+    The dimensions of the custom variable being specified must match *exactly* with one of the three standard dimensions: `x`, `y`, `seconds`.
     Use of an invalid dimension will result in an error.
 
 An example of using the hook and creating a model subclass to customize the figures, gridded variables, and metadata being saved is provided below.
@@ -48,14 +48,19 @@ An example of using the hook and creating a model subclass to customize the figu
     ...         self._save_fig_list['active_layer'] = ['active_layer']
     ...
     ...         # save the active layer grid each save_dt w/ a short name
-    ...         self._save_var_list['actlay'] = ['active_layer', 'fraction',
-    ...                                          'f4', ('time',
-    ...                                                 'x', 'y')]
+    ...         self._save_var_list['actlay'] = [
+    ...             'active_layer', 'fraction',
+    ...             'f4', ('seconds', 'x', 'y'),
+    ...             'channel_bottom__sediment__active_layer'
+    ...             ]
     ...
     ...         # save number of water parcels w/ a long name
-    ...         self._save_var_list['meta']['water_parcels'] = ['Np_water',
-    ...                                                         'parcels',
-    ...                                                         'i8', ()]
+    ...         self._save_var_list['meta']['water_parcels'] = [
+    ...             'Np_water',
+    ...             'parcels',
+    ...             'i8', (),
+    ...             'model_water__number_parcels'
+    ...             ]
 
 Next, we instantiate the model class.
 
@@ -83,4 +88,4 @@ For simplicity we will just check that the appropriate parameters were added to
     {'active_layer': ['active_layer']}
 
     >>> print(mdl._save_var_list)
-    {'meta': {'water_parcels': ['Np_water', 'parcels', 'i8', ()]}, 'actlay': ['active_layer', 'fraction', 'f4', ('time', 'x', 'y')]}
+    {'meta': {'water_parcels': ['Np_water', 'parcels', 'i8', (), 'model_water__number_parcels']}, 'actlay': ['active_layer', 'fraction', 'f4', ('seconds', 'x', 'y'), 'channel_bottom__sediment__active_layer']}

pydeltarcm-2.2.0/docs/source/examples/gotcha_simulataneous_models.rst

@@ -0,0 +1,62 @@
+Instantiating and running two models iteratively on the same core is not reproducible
+=====================================================================================
+
+
+You cannot run models "simultaneously" and get reproducible results. 
+
+In an ideal world, two models with same seed should give same result,
+regardless of how they are run. But if two models are called intermittently,
+then the result is not reproducible (at least on a per-model basis) because
+the random-number generator is thrown out of sync with respect to the single
+model and seed. More explanation below.
+
+.. note::
+
+    As of 03/2026, numba does not implement random number generation as an
+    object, and so we cannot aviod this "gotcha".
+
+.. code::
+    
+        # initialize models
+        test1 = DeltaModel()
+        test2 = DeltaModel()
+
+        for _ in range(0, 5):
+            test1.update()
+            test2.update()
+
+        test1.finalize()
+        test2.finalize()
+
+        # test that gives same result (WILL FAIL)
+        difference = test1.eta - test2.eta
+        assert np.all(difference == 0)
+
+.. DEVNOTE: see test in tests/integration/test_consistent_outputs.py in TestConsistentOutputsSameSeed called test_same_models_simulataneous_not_parallel
+
+**The above code will fail to generate reproducible results.**
+
+The problem is that both test and test2 access the same underlying random
+number generator in Numba, and therefore follow different trajectories over
+time. The only way around this is to instantiate the models sequentially
+(resetting the seed via the instantiation of the second one after finishing
+the first one), or instantiating the objects in subprocesses (this is what
+the `preprocessor` does for parallel runs). 
+
+Of course, if you don't care about reproducibility at the moment (e.g., prototyping, testing approaches, etc), you can totally use the above approach. **Your final model code for analysis should be reproducible and not use this approach!** 
+
+
+The below code will work to give reproducible results.
+
+.. code::
+
+    test1 = DeltaModel(input_file=p1)
+    for _ in range(0, 5):
+        test1.update()
+        test1.finalize()
+
+    test2 = DeltaModel(input_file=p2)
+    for _ in range(0, 5):
+        test2.update()
+        test2.finalize()
+

{pydeltarcm-2.1.9 → pydeltarcm-2.2.0}/docs/source/examples/index.rst

@@ -11,6 +11,14 @@ Running the model
    basic_runs
    resume_from_checkpoint
 
+Common "gotchas"
+----------------
+
+.. toctree::
+   :maxdepth: 1
+
+   gotcha_simulataneous_models
+
 
 Modifying initial conditions
 ----------------------------

{pydeltarcm-2.1.9 → pydeltarcm-2.2.0}/docs/source/info/outputfile.rst

@@ -10,30 +10,35 @@ Gridded Variables
 
 In any given run, the saving parameters "save_<var>_grids" control whether or
 not that 2-D grid variable (e.g. velocity) is saved to the netCDF4 file. In
-the netCDF4 file, a 3-D array with the dimensions `time` :math:`\times`
+the netCDF4 file, a 3-D array with the dimensions `seconds` :math:`\times`
 `x` :math:`\times` `y` is created for each 2-D grid variable that is set to
 be saved. Note that `x` is the *downstream* coordinate, rather than the
 Cartesian `x` when displaying the grid. The appropriate units for all
 variables are stored: for example "meters per second" for the *velocity*
-grid.
+grid. All variables include a description via the `long_name` attribute.
 
-.. note::
+.. important::
    
-   The format of the output netCDF file coordinate changed in `v2.1.0`. The
-   old format is documented
-   in :attr:`~pyDeltaRCM.model.DeltaModel.legacy_netcdf`, and that input
-   parameter `legacy_netcdf` can be used to create on output netcdf file with
-   the old coordinate configuration.
+   The format of the output netCDF file coordinates changed in `v2.2.0`. The
+   old format (up to v2.1.9) is documented
+   in :attr:`~pyDeltaRCM.model.DeltaModel.legacy_netcdf`, and the input
+   parameter `legacy_netcdf` can be used to create an output netcdf file with
+   the old coordinate configuration. The output format for pyDeltaRCM v2.1.0
+   and earlier is deprecated and has been removed. Changing to the new output
+   format should be a small change for most users, with only the name of the
+   temporal dimension and the metadata subgroup changing in the new output.
 
 
 Grid Coordinates
 ================
 
-Grid coordinates are specified in the variables `time`, `x`, and `y` in the output netCDF4 file.
-These arrays are 1D arrays, which specify the location of each cell in the domain in *dimensional* coordinates (e.g., meters).
-In the downstream direction,  the distance of each cell from the inlet boundary is specified in `x` in meters.
-Similarly, the cross-domain distance is specified in `y` in meters.
-Lastly, the `time` variable is stored as a 1D array with model `time` in seconds.
+Grid coordinates are specified in the variables `seconds`, `x`, and `y` in the
+output netCDF4 file. These arrays are 1D arrays, which specify the location
+of each cell in the domain in *dimensional* coordinates (e.g., meters). In
+the downstream direction,  the distance of each cell from the inlet boundary
+is specified in `x` in meters. Similarly, the cross-domain distance is
+specified in `y` in meters. Lastly, the `seconds` variable is stored as a 1D
+array recording model elapsed time in seconds.
 
 
 Model Metadata
@@ -53,6 +58,7 @@ saved as metadata are the following:
 - Sediment concentration: `C0_percent`
 - Characteristic Velocity: `u0`
 - If subsidence is enabled:
+
   - Subsidence start time: `start_subsidence`
   - Subsidence rate: `sigma`
 
@@ -66,7 +72,7 @@ library. These libraries range from the
 to higher-level libraries such as
 `xarray <https://github.com/pydata/xarray>`_. For deltas, and specifically
 *pyDeltaRCM*, there is also a package under development called
-`DeltaMetrics <https://github.com/DeltaRCM/DeltaMetrics>`_,
+`sandplover <https://github.com/sandpiper-toolchain/sandplover>`_,
 that is being designed to help post-process and analyze *pyDeltaRCM* outputs.
 
 

{pydeltarcm-2.1.9 → pydeltarcm-2.2.0}/pyDeltaRCM/_version.py

@@ -3,4 +3,4 @@ def __version__() -> str:
     Private version declaration, gets assigned to pyDeltaRCM.__version__
     during import
     """
-    return "2.1.9"
+    return "2.2.0"

{pydeltarcm-2.1.9 → pydeltarcm-2.2.0}/pyDeltaRCM/hook_tools.py

@@ -237,7 +237,7 @@ class hook_tools(abc.ABC):
         .. note::
 
             For a vector of time-varying metadata, the dimension
-            should be specified as ('total_time').
+            should be specified as ('time').
 
         Expected format for time varying grid entries as keys within the
         `self._save_var_list` dictionary:

{pydeltarcm-2.1.9 → pydeltarcm-2.2.0}/pyDeltaRCM/init_tools.py

@@ -225,9 +225,9 @@ class init_tools(abc.ABC):
         self.out_dir = self._input_file_vars["out_dir"]
         self.verbose = self._input_file_vars["verbose"]
         if self._input_file_vars["legacy_netcdf"]:
-            self._netcdf_coords = ("total_time", "length", "width")
-        else:
             self._netcdf_coords = ("time", "x", "y")
+        else:
+            self._netcdf_coords = ("seconds", "x", "y")
 
     def process_input_to_model(self) -> None:
         """Process input file to model variables.
@@ -386,7 +386,6 @@ class init_tools(abc.ABC):
 
         # kernels for topographic smoothing
         self.kernel1 = np.array([[1, 1, 1], [1, -8, 1], [1, 1, 1]]).astype(np.int64)
-
         self.kernel2 = np.array([[1, 1, 1], [1, 0, 1], [1, 1, 1]]).astype(np.int64)
 
     def create_boundary_conditions(self) -> None:
@@ -434,7 +433,7 @@ class init_tools(abc.ABC):
 
         # at inlet
         self.qw0 = self.u0 * self.h0  # water unit input discharge
-        self.Qp_water = self.Qw0 / self._Np_water  # volume each water parcel
+        self.Qp_water = self.Qw0 / self._Np_water  # discharge each water parcel
         self.qs0 = self.qw0 * self.C0  # sed unit discharge
         self.dVs = 0.1 * self.N0**2 * self.V0  # total sed added per timestep
         self.Qs0 = self.Qw0 * self.C0  # sediment total input discharge
@@ -660,6 +659,22 @@ class init_tools(abc.ABC):
             file_path = os.path.join(directory, filename)
             _msg = "Target output NetCDF4 file: {file}".format(file=file_path)
             self.log_info(_msg, verbosity=2)
+            if not self._legacy_netcdf:
+                _sandsuet_version = "1.0.0"
+                _msg = "Output file in sandsuet version {ver} schema".format(
+                    ver=_sandsuet_version
+                )
+            else:
+                _msg = "Output file in legacy schema"
+                warnings.warn(
+                    "Creating output netcdf file in legacy schema. This format is "
+                    "provided as a convenience for users who are currently "
+                    "relying on workflows that use an old format of netcdf file. "
+                    "It will be removed in the future. Any new workflows should "
+                    "leverage the sandsuet formatted data specification "
+                    "(i.e., `legacy_netcdf=False`)."
+                )
+            self.log_info(_msg, verbosity=1)
 
             if (os.path.exists(file_path)) and (self._clobber_netcdf is False):
                 raise FileExistsError(
@@ -679,6 +694,8 @@ class init_tools(abc.ABC):
             self.output_netcdf.source = "pyDeltaRCM v{ver}".format(
                 ver=self.__pyDeltaRCM_version__
             )
+            if not self._legacy_netcdf:
+                self.output_netcdf.sandsuet_version = _sandsuet_version
 
             # create master dimensions (pulls from `self._netcdf_coords`)
             self.output_netcdf.createDimension(self._netcdf_coords[1], self.L)
@@ -686,77 +703,158 @@ class init_tools(abc.ABC):
             self.output_netcdf.createDimension(self._netcdf_coords[0], None)
 
             # create master coordinates (as netCDF variables)
-            time = self.output_netcdf.createVariable(
-                "time", "f4", (self._netcdf_coords[0],)
-            )
-            time.units = "second"
-
             if self._legacy_netcdf:
-                # old format is 2d array x and y
-                x = self.output_netcdf.createVariable(
-                    "x", "f4", self._netcdf_coords[1:]
-                )
-                y = self.output_netcdf.createVariable(
-                    "y", "f4", self._netcdf_coords[1:]
+                time = self.output_netcdf.createVariable(
+                    "time", "f4", (self._netcdf_coords[0],)
                 )
-                x[:] = self.x
-                y[:] = self.y
 
             else:
-                # new output format is 1d x and y
-                x = self.output_netcdf.createVariable("x", "f4", ("x"))
-                y = self.output_netcdf.createVariable("y", "f4", ("y"))
-                x[:] = self.xc
-                y[:] = self.yc
+                time = self.output_netcdf.createVariable(
+                    "seconds", "f4", (self._netcdf_coords[0],)
+                )
+            time.units = "second"
 
+            # new output format is 1d x and y
+            x = self.output_netcdf.createVariable("x", "f4", ("x"))
+            y = self.output_netcdf.createVariable("y", "f4", ("y"))
+            x[:] = self.xc
+            y[:] = self.yc
             x.units = "meter"
             y.units = "meter"
 
-            # set up variables for output data grids
-            def _create_grid_variable(varname, varunits, vartype="f4", vardims=()):
+            # set up function to output data grids
+            def _create_grid_variable(
+                varname, varunits, vartype="f4", vardims=(), varlong=None
+            ):
                 _v = self.output_netcdf.createVariable(varname, vartype, vardims)
                 _v.units = varunits
+                if varlong is not None:
+                    # long_name is provided, record it
+                    _v.long_name = varlong
+                else:
+                    if not self._legacy_netcdf:
+                        raise ValueError(
+                            f"long name must be provided for all variables to create a "
+                            f"sandsuet compliant data output, "
+                            f"but was not provided for variable '{varname}'."
+                        )
 
+            # loop through main output data grids
             _var_list = list(self._save_var_list.keys())
-            _var_list.remove("meta")
+            _var_list.remove("meta")  # remove group from list
             for _val in _var_list:
+                if isinstance(self._save_var_list[_val], list):
+                    ### for now, we silently convert to dictionary format
+                    # # inputs should be specified as a dictionary
+                    # warnings.warn(
+                    #     f"Specification format for output data should be `dict`, "
+                    #     f"but was `list`. Converting `list` for one or more variables "
+                    #     f"to `dict` based on item order. This compatability will "
+                    #     f"be removed in a future version."
+                    # )
+                    ###
+                    # do the conversion
+                    __inlist = self._save_var_list[_val]
+                    __varname = _val
+                    __varlong = __inlist[4] if len(__inlist) > 4 else None
+                    _vardict = dict(
+                        varname=__varname,  # use dict key as varname
+                        varunits=__inlist[1],
+                        vartype=__inlist[2],
+                        vardims=__inlist[3],
+                        varlong=__varlong,
+                    )
+                else:
+                    _vardict = self._save_var_list[_val]
+
                 _create_grid_variable(
-                    _val,
-                    self._save_var_list[_val][1],
-                    self._save_var_list[_val][2],
-                    self._save_var_list[_val][3],
+                    varname=_vardict["varname"],
+                    varunits=_vardict["varunits"],
+                    vartype=_vardict["vartype"],
+                    vardims=_vardict["vardims"],
+                    varlong=_vardict["varlong"],
                 )
 
-            # set up metadata group and populate variables
+            # find name for subgroup data and make list
+            if self._legacy_netcdf:
+                self._subgroup_name = "meta"
+            else:
+                self._subgroup_name = "auxdata"
+            self.output_netcdf.createGroup(self._subgroup_name)
+
+            # set up function to output additional data in subgroup
             def _create_meta_variable(
-                varname, varvalue, varunits, vartype="f4", vardims=()
+                varname, varvalue, varunits, vartype="f4", vardims=(), varlong=None
             ):
                 _v = self.output_netcdf.createVariable(
-                    "meta/" + varname, vartype, vardims
+                    f"{self._subgroup_name}/" + varname, vartype, vardims
                 )
                 _v.units = varunits
+                # convert string to value from model attrs
+                if isinstance(varvalue, str):
+                    varvalue = getattr(self, varvalue)
+                # fill variable
                 _v[:] = varvalue
+                if varlong is not None:
+                    # long_name is provided, record it
+                    _v.long_name = varlong
+                else:
+                    if not self._legacy_netcdf:
+                        raise ValueError(
+                            f"long name must be provided for all variables to create a "
+                            f"sandsuet compliant data output, "
+                            f"but was not provided for variable '{varname}'."
+                        )
 
-            self.output_netcdf.createGroup("meta")
+            # loop through additional data in subgroup
             for _val in self._save_var_list["meta"].keys():
-                # time-varying initialize w/ None value
-                if self._save_var_list["meta"][_val][0] is None:
-                    _create_meta_variable(
-                        _val,
-                        self._save_var_list["meta"][_val][0],
-                        self._save_var_list["meta"][_val][1],
-                        self._save_var_list["meta"][_val][2],
-                        self._save_var_list["meta"][_val][3],
+                if isinstance(self._save_var_list["meta"][_val], list):
+                    ### for now, we silently convert to dictionary format
+                    # inputs should be specified as a dictionary
+                    # warnings.warn(
+                    #     f"Specification format for output subgroup data should be `dict`, "
+                    #     f"but was `list`. Converting `list` for one or more subgroup variables "
+                    #     f"to `dict` based on item order. This compatability will "
+                    #     f"be removed in a future version."
+                    # )
+                    ###
+                    # do the conversion
+                    __inlist = self._save_var_list["meta"][_val]
+                    __varname = _val
+                    if __inlist[0] is None:
+                        warnings.warn(
+                            UserWarning(
+                                "Specifying `None` for time varying dimensions "
+                                "of model outputs will soon be deprecated. "
+                                "Change to specifying the name of the "
+                                "variable to save a string, and/or convert to "
+                                "dictionary inputs."
+                            )
+                        )
+                        __varvalue = None
+                    else:
+                        __varvalue = getattr(self, __inlist[0])
+                    __varlong = __inlist[4] if len(__inlist) > 4 else None
+                    _vardict = dict(
+                        varname=__varname,
+                        varvalue=__varvalue,
+                        varunits=__inlist[1],
+                        vartype=__inlist[2],
+                        vardims=__inlist[3],
+                        varlong=__varlong,
                     )
-                # for scalars, get the attribute and store it
+
                 else:
-                    _create_meta_variable(
-                        _val,
-                        getattr(self, self._save_var_list["meta"][_val][0]),
-                        self._save_var_list["meta"][_val][1],
-                        self._save_var_list["meta"][_val][2],
-                        self._save_var_list["meta"][_val][3],
-                    )
+                    _vardict = self._save_var_list["meta"][_val]
+
+                _create_meta_variable(
+                    varname=_vardict["varname"],
+                    varvalue=_vardict["varvalue"],
+                    varunits=_vardict["varunits"],
+                    vartype=_vardict["vartype"],
+                    vardims=_vardict["vardims"],
+                    varlong=_vardict["varlong"],
+                )
 
             _msg = "Output netCDF file created"
             self.log_info(_msg, verbosity=2)
@@ -789,17 +887,54 @@ class init_tools(abc.ABC):
         Sets up the dictionary object for the standard metadata.
         """
         # fixed metadata
-        self._save_var_list["meta"]["L0"] = ["L0", "cells", "i8", ()]
-        self._save_var_list["meta"]["N0"] = ["N0", "cells", "i8", ()]
-        self._save_var_list["meta"]["CTR"] = ["CTR", "cells", "i8", ()]
-        self._save_var_list["meta"]["dx"] = ["dx", "meters", "f4", ()]
-        self._save_var_list["meta"]["h0"] = ["h0", "meters", "f4", ()]
-        self._save_var_list["meta"]["hb"] = ["hb", "meters", "f4", ()]
+        self._save_var_list["meta"]["L0"] = [
+            "L0",
+            "cells",
+            "i8",
+            (),
+            "channel_entrance__length",
+        ]
+        self._save_var_list["meta"]["N0"] = [
+            "N0",
+            "cells",
+            "i8",
+            (),
+            "channel_entrance__width",
+        ]
+        self._save_var_list["meta"]["CTR"] = [
+            "CTR",
+            "cells",
+            "i8",
+            (),
+            "channel_entrance__y_position",
+        ]
+        self._save_var_list["meta"]["dx"] = [
+            "dx",
+            "meters",
+            "f4",
+            (),
+            "model_grid_cell_edge__length",
+        ]
+        self._save_var_list["meta"]["h0"] = [
+            "h0",
+            "meters",
+            "f4",
+            (),
+            "channel_entrance__depth",
+        ]
+        self._save_var_list["meta"]["hb"] = [
+            "hb",
+            "meters",
+            "f4",
+            (),
+            "basin_bottom_initial__depth",
+        ]
         self._save_var_list["meta"]["cell_type"] = [
             "cell_type",
             "type",
             "i8",
             self._netcdf_coords[1:],
+            "model_grid_cell__type",
         ]
         # subsidence metadata
         if self._toggle_subsidence:
@@ -808,37 +943,43 @@ class init_tools(abc.ABC):
                 "seconds",
                 "i8",
                 (),
+                "basin_bottom_vertical_rate_of_change__start_time",
             ]
             self._save_var_list["meta"]["sigma"] = [
                 "sigma",
                 "meters per timestep",
                 "f4",
                 self._netcdf_coords[1:],
+                "basin_bottom__vertical_rate_of_change",
             ]
         # time-varying metadata
         self._save_var_list["meta"]["H_SL"] = [
-            None,
+            "H_SL",
             "meters",
             "f4",
             (self._netcdf_coords[0]),
+            "basin_water_surface__elevation",
         ]
         self._save_var_list["meta"]["f_bedload"] = [
-            None,
+            "f_bedload",
             "fraction",
             "f4",
             (self._netcdf_coords[0]),
+            "channel_entrance_water_sediment_sand__volume_fraction",
         ]
         self._save_var_list["meta"]["C0_percent"] = [
-            None,
+            "C0_percent",
             "percent",
             "f4",
             (self._netcdf_coords[0]),
+            "channel_entrance__water_sediment__volume_percent",
         ]
         self._save_var_list["meta"]["u0"] = [
-            None,
+            "u0",
             "meters per second",
             "f4",
             (self._netcdf_coords[0]),
+            "channel_entrance__speed",
         ]
 
     def _load_past_etas(self, checkpoint):
@@ -1031,6 +1172,14 @@ class init_tools(abc.ABC):
                 # set object attribute for model
                 self.output_netcdf = Dataset(file_path, "r+", format="NETCDF4")
 
+                # find subgroup name, supporting legacy file format
+                if "meta" in self.output_netcdf.groups.keys():
+                    self._subgroup_name = "meta"
+                elif "auxdata" in self.output_netcdf.groups.keys():
+                    self._subgroup_name = "auxdata"
+                else:
+                    self._subgroup_name = self.output_netcdf.groups.keys()[0]
+
                 # synch netcdf file
                 self.output_netcdf.sync()