Repository: IMMM-SFA/mosartwmpy (language: python)

Issue:
remove `h5netcdf` dependency



Discussion / hints:
@cheginit, upon looking into this some more, the reason `h5netcdf` is used is because the `engine=netcdf4` doesn't allow reading from bit streams or file-like objects, such as directly out of a zipped file. I think the strategy for saving a grid state needs a little work anyway, so i'll save this ticket for a refactor in the future.
In my experience, `scipy` handles bytes better. Here's how I use it for converting a list of byte responses (for example, from `r.content()`) to `xarray`:
```python
import io

ds = xr.open_mfdataset((io.BytesIO(r) for r in resp), engine="scipy", coords="minimal")
```
i see, that does limit one to NETCDF3, but it doesn't change the file size in this case, so i will implement. thanks!
That's right. It converts it to NETCDF3_64BIT that fortunately can handle large netcdf files.

Fix patch:
diff --git a/.github/workflows/build_linux.yml b/.github/workflows/build_linux.yml
index dbcf5a4..c4cefde 100644
--- a/.github/workflows/build_linux.yml
+++ b/.github/workflows/build_linux.yml
@@ -12,7 +12,7 @@ jobs:
 
       env:
         OS: ${{ matrix.os }}
-        PYTHON: '3.9'
+        PYTHON: '3.7'
 
       steps:
 
@@ -21,15 +21,14 @@ jobs:
         - name: Set up Python
           uses: actions/setup-python@master
           with:
-            python-version: 3.9
+            python-version: 3.7
 
         - name: Install dependencies
           run: |
             python -m pip install --upgrade pip
-            pip install -r requirements.txt
-            python setup.py install
+            pip install .
 
-        - name: Test and generate coverage report
+        - name: Test
           run: |
             pip install pytest
             pytest
diff --git a/.github/workflows/build_osx.yml b/.github/workflows/build_osx.yml
index 46a1735..fcb003f 100644
--- a/.github/workflows/build_osx.yml
+++ b/.github/workflows/build_osx.yml
@@ -12,7 +12,7 @@ jobs:
 
       env:
         OS: ${{ matrix.os }}
-        PYTHON: '3.9'
+        PYTHON: '3.7'
 
       steps:
 
@@ -21,13 +21,12 @@ jobs:
         - name: Set up Python
           uses: actions/setup-python@master
           with:
-            python-version: 3.9
+            python-version: 3.7
 
         - name: Install dependencies
           run: |
             python -m pip install --upgrade pip
-            pip install -r requirements.txt
-            python setup.py install
+            pip install .
 
         - name: Test and generate coverage report
           run: |
diff --git a/.github/workflows/build_windows.yml b/.github/workflows/build_windows.yml
index 6806e45..a1841d7 100644
--- a/.github/workflows/build_windows.yml
+++ b/.github/workflows/build_windows.yml
@@ -1,7 +1,6 @@
 name: windows
 
-#on: [push]
-on: workflow_dispatch
+on: [push]
 
 jobs:
   build:
@@ -13,7 +12,7 @@ jobs:
 
       env:
         OS: ${{ matrix.os }}
-        PYTHON: '3.9'
+        PYTHON: '3.7'
 
       steps:
 
@@ -22,23 +21,20 @@ jobs:
         - name: Set up Python
           uses: actions/setup-python@master
           with:
-            python-version: 3.9
+            python-version: 3.7
 
         - name: Install dependencies
           run: |
             python -m pip install --upgrade pip
-            curl -O https://download.lfd.uci.edu/pythonlibs/w4tscw6k/numpy-1.20.3+mkl-cp39-cp39-win_amd64.whl
-            pip install numpy-1.20.3+mkl-cp39-cp39-win_amd64.whl
-            curl -O https://download.lfd.uci.edu/pythonlibs/w4tscw6k/GDAL-3.3.0-cp39-cp39-win_amd64.whl
-            pip install GDAL-3.3.0-cp39-cp39-win_amd64.whl
-            curl -O https://download.lfd.uci.edu/pythonlibs/w4tscw6k/rasterio-1.2.4-cp39-cp39-win_amd64.whl
-            pip install rasterio-1.2.4-cp39-cp39-win_amd64.whl
-            pip install -r requirements.txt
-            python setup.py install
-            pip install numpy --upgrade
-            pip install python-benedict --upgrade
-
-        - name: Test and generate coverage report
+            curl -O https://download.lfd.uci.edu/pythonlibs/q4trcu4l/numpy-1.20.3+mkl-cp37-cp37m-win_amd64.whl
+            pip install numpy-1.20.3+mkl-cp37-cp37m-win_amd64.whl
+            curl -O https://download.lfd.uci.edu/pythonlibs/q4trcu4l/GDAL-3.3.0-cp37-cp37m-win_amd64.whl
+            pip install GDAL-3.3.0-cp37-cp37m-win_amd64.whl
+            curl -O https://download.lfd.uci.edu/pythonlibs/q4trcu4l/rasterio-1.2.4-cp37-cp37m-win_amd64.whl
+            pip install rasterio-1.2.4-cp37-cp37m-win_amd64.whl
+            pip install .
+
+        - name: Test
           run: |
             pip install pytest
             pytest
diff --git a/README.md b/README.md
index ad784bf..cf6f7ef 100644
--- a/README.md
+++ b/README.md
@@ -6,11 +6,16 @@
 
 ## getting started
 
-Ensure you have Python >= 3.9 available (consider using a [virtual environment](https://github.com/pyenv/pyenv), see the docs [here](https://mosartwmpy.readthedocs.io/en/latest/virtualenv.html) for a brief tutorial), then install `mosartwmpy` with:
+Ensure you have Python >= 3.7 available (consider using a [virtual environment](https://github.com/pyenv/pyenv), see the docs [here](https://mosartwmpy.readthedocs.io/en/latest/virtualenv.html) for a brief tutorial), then install `mosartwmpy` with:
 ```shell
 pip install mosartwmpy
 ```
 
+Alternatively, install via conda with:
+```shell
+conda install mosartwmpy
+```
+
 Download a sample input dataset spanning May 1981 by running the following and selecting option `1` for "tutorial". This will download and unpack the inputs to your current directory. Optionally specify a path to download and extract to instead of the current directory.
 
 ```shell
@@ -108,6 +113,10 @@ plt.show()
 
 ```
 
+## model coupling
+
+A common use case for `mosartwmpy` is to run coupled with output from the Community Land Model (CLM). To see an example of how to drive `mosartwmpy` with runoff from a coupled model, check out the [Jupyter notebook tutorial](https://github.com/IMMM-SFA/mosartwmpy/blob/main/notebooks/tutorial.ipynb)!
+
 ## model input
 
 Several input files in NetCDF format are required to successfully run a simulation, which are not shipped with this repository due to their large size. The grid files, reservoir files, and a small range of runoff and demand input files can be obtained using the download utility by running `python -m mosartwmpy.download` and choosing option 1 for "sample_input". Currently, all input files are assumed to be at the same resolution (for the sample files this is 1/8 degree over the CONUS). Below is a summary of the various input files:
@@ -197,31 +206,6 @@ Several input files in NetCDF format are required to successfully run a simulati
 </tbody>
 </table>
 
-Alternatively, certain model inputs can be set using the BMI interface. This can be useful for coupling `mosartwmpy` with other models. If setting an input that would typically be read from a file, be sure to disable the `read_from_file` configuration value for that input. For example:
-```python
-import numpy as np
-from mosartwmpy import Model
-
-mosart_wm = Model()
-mosart_wm.initialize()
-
-# get a list of model input variables
-mosart_wm.get_input_var_names()
-
-# disable the runoff read_from_file
-mosart_wm.config['runoff.read_from_file'] = False
-
-# set the runoff values manually (i.e. from another model's output)
-surface_runoff = np.empty(mosart_wm.get_grid_size())
-surface_runoff[:] = # <values from coupled model>
-mosart_wm.set_value('surface_runoff_flux', surface_runoff)
-
-# advance one timestep
-mosart_wm.update()
-
-# continue coupling...
-```
-
 ## model output
 
 By default, key model variables are output on a monthly basis at a daily averaged resolution to `./output/<simulation name>/<simulation name>_<year>_<month>.nc`. See the configuration file for examples of how to modify the outputs, and the `./mosartwmpy/state/state.py` file for state variable names.
diff --git a/mosartwmpy/config_defaults.yaml b/mosartwmpy/config_defaults.yaml
index be6ca37..f51f5aa 100644
--- a/mosartwmpy/config_defaults.yaml
+++ b/mosartwmpy/config_defaults.yaml
@@ -229,11 +229,11 @@ water_management:
         latitude: lat
         # streamflow field name [m3/s]
         streamflow: Qmon
-        # streamflow time resolution - 'month' or 'epiweek'
+        # streamflow time resolution - only 'month' supported so far
         streamflow_time_resolution: month
         # demand field name [m3/s]
         demand: demand
-        # demand time resolution - 'month' or 'epiweek'
+        # demand time resolution - only 'month' supported so far
         demand_time_resolution: month
         # grid id to reservoir id mapping field
         grid_to_reservoir: gridID_from_Dam
diff --git a/mosartwmpy/grid/grid.py b/mosartwmpy/grid/grid.py
index ad4d588..a8eb502 100644
--- a/mosartwmpy/grid/grid.py
+++ b/mosartwmpy/grid/grid.py
@@ -404,11 +404,11 @@ def to_files(self, path: str) -> None:
             for df in dfs:
                 names.append(f'{df["key"]}.df.nc')
                 paths.append(f'{tmpdir}/{names[-1]}')
-                df['frame'].to_xarray().to_netcdf(paths[-1], engine='h5netcdf')
+                df['frame'].to_xarray().to_netcdf(paths[-1], engine='scipy')
             for ds in xrs:
                 names.append(f'{ds["key"]}.xr.nc')
                 paths.append(f'{tmpdir}/{names[-1]}')
-                ds['data_array'].to_netcdf(paths[-1], engine='h5netcdf')
+                ds['data_array'].to_netcdf(paths[-1], engine='scipy')
             with ZipFile(path, 'w', compression=ZIP_DEFLATED, compresslevel=9) as zip:
                 for i, filename in enumerate(paths):
                     zip.write(filename, names[i])
@@ -441,13 +441,13 @@ def from_files(path: Path) -> 'Grid':
                             setattr(grid, key, npdf[key].values)
                     if filename.endswith('df.nc'):
                         key = filename.split('.')[0]
-                        ds = xr.open_dataset(file, engine='h5netcdf')
+                        ds = xr.open_dataset(file, engine='scipy')
                         df = ds.to_dataframe()
                         setattr(grid, key, df)
                         ds.close()
                     if filename.endswith('xr.nc'):
                         key = filename.split('.')[0]
-                        ds = xr.open_dataarray(file, engine='h5netcdf').load()
+                        ds = xr.open_dataarray(file, engine='scipy').load()
                         setattr(grid, key, ds)
                         ds.close()
         
diff --git a/mosartwmpy/model.py b/mosartwmpy/model.py
index 598c2ae..407223e 100644
--- a/mosartwmpy/model.py
+++ b/mosartwmpy/model.py
@@ -10,7 +10,6 @@
 from benedict import benedict
 from bmipy import Bmi
 from datetime import datetime, time, timedelta
-from epiweeks import Week
 from pathlib import Path
 from pathvalidate import sanitize_filename
 from timeit import default_timer as timer
@@ -161,6 +160,7 @@ def initialize(self, config_file_path: str = None, grid: Grid = None, state: Sta
             raise e
         
         logging.debug(f'Initialization completed in {pretty_timer(timer() - t)}.')
+        logging.info(f'Done.')
         
     def update(self) -> None:
         t = timer()
@@ -168,15 +168,19 @@ def update(self) -> None:
         # perform one timestep
         logging.debug(f'Beginning timestep {step}...')
         try:
-            # read runoff
             if self.config.get('runoff.read_from_file', False):
+                # read runoff from file
                 logging.debug(f'Reading runoff input from file.')
                 load_runoff(self.state, self.grid, self.config, self.current_time)
+            else:
+                # convert provided runoff from mm/s to m3/s
+                self.state.hillslope_surface_runoff = 0.001 * self.grid.land_fraction * self.grid.area * self.state.hillslope_surface_runoff
+                self.state.hillslope_subsurface_runoff = 0.001 * self.grid.land_fraction * self.grid.area * self.state.hillslope_subsurface_runoff
+                self.state.hillslope_wetland_runoff = 0.001 * self.grid.land_fraction * self.grid.area * self.state.hillslope_wetland_runoff
             # read demand
             if self.config.get('water_management.enabled', False):
                 if self.config.get('water_management.demand.read_from_file', False):
                     # only read new demand and compute new release if it's the very start of simulation or new time period
-                    # TODO this currently assumes monthly demand input
                     if self.current_time == datetime.combine(self.config.get('simulation.start_date'), time.min) or self.current_time == datetime(self.current_time.year, self.current_time.month, 1):
                         logging.debug(f'Reading demand rate input from file.')
                         # load the demand from file
@@ -187,8 +191,6 @@ def update(self) -> None:
                 self.state.grid_cell_supply[:] = 0
                 self.state.grid_cell_unmet_demand[:] = 0
                 # get streamflow for this time period
-                # TODO this is still written assuming monthly, but here's the epiweek for when that is relevant
-                epiweek = Week.fromdate(self.current_time).week
                 month = self.current_time.month
                 streamflow_time_name = self.config.get('water_management.reservoirs.streamflow_time_resolution')
                 self.state.reservoir_streamflow[:] = self.grid.reservoir_streamflow_schedule.sel({streamflow_time_name: month}).values
@@ -206,10 +208,16 @@ def update(self) -> None:
         except Exception as e:
             logging.exception('Failed to write output or restart file; see below for stacktrace.')
             raise e
-        # clear runoff input arrays
-        self.state.hillslope_surface_runoff[:] = 0
-        self.state.hillslope_subsurface_runoff[:] = 0
-        self.state.hillslope_wetland_runoff[:] = 0
+        if self.config.get('runoff.read_from_file', False):
+            # clear runoff input arrays
+            self.state.hillslope_surface_runoff[:] = 0
+            self.state.hillslope_subsurface_runoff[:] = 0
+            self.state.hillslope_wetland_runoff[:] = 0
+        else:
+            # convert back to mm/s
+            self.state.hillslope_surface_runoff = self.state.hillslope_surface_runoff * 1000.0 / self.grid.land_fraction / self.grid.area
+            self.state.hillslope_subsurface_runoff = self.state.hillslope_subsurface_runoff * 1000.0 / self.grid.land_fraction / self.grid.area
+            self.state.hillslope_wetland_runoff = self.state.hillslope_wetland_runoff * 1000.0 / self.grid.land_fraction / self.grid.area
 
     def update_until(self, time: float) -> None:
         # make sure that requested end time is after now
diff --git a/mosartwmpy/reservoirs/grid.py b/mosartwmpy/reservoirs/grid.py
index 4af8bd9..8dc39f6 100644
--- a/mosartwmpy/reservoirs/grid.py
+++ b/mosartwmpy/reservoirs/grid.py
@@ -57,7 +57,7 @@ def load_reservoirs(self, config: Benedict, parameters: Parameters) -> None:
     # index by grid cell
     self.reservoir_to_grid_mapping = self.reservoir_to_grid_mapping.set_index('grid_cell_id')
 
-    # prepare the month or epiweek based reservoir schedules mapped to the domain
+    # prepare the month based reservoir schedules mapped to the domain
     prepare_reservoir_schedule(self, config, parameters, reservoirs)
 
     reservoirs.close()
@@ -75,8 +75,6 @@ def prepare_reservoir_schedule(self, config: Benedict, parameters: Parameters, r
     # the reservoir streamflow and demand are specified by the time resolution and reservoir id
     # so let's remap those to the actual mosart domain for ease of use
 
-    # TODO i had wanted to convert these all to epiweeks no matter what format provided, but we don't know what year all the data came from
-
     # streamflow flux
     streamflow_time_name = config.get('water_management.reservoirs.streamflow_time_resolution')
     streamflow = reservoirs[config.get('water_management.reservoirs.streamflow')]
@@ -92,7 +90,7 @@ def prepare_reservoir_schedule(self, config: Benedict, parameters: Parameters, r
         else:
             schedule = concat([schedule, sched], dim=streamflow_time_name)
     self.reservoir_streamflow_schedule = schedule.assign_coords(
-        # if monthly, convert to 1 based month index (instead of starting from 0)
+        # convert to 1 based month index (instead of starting from 0)
         {streamflow_time_name: (streamflow_time_name, schedule[streamflow_time_name].values + (1 if streamflow_time_name == 'month' else 0))}
     ).streamflow
 
@@ -110,12 +108,11 @@ def prepare_reservoir_schedule(self, config: Benedict, parameters: Parameters, r
         else:
             schedule = concat([schedule, sched], dim=demand_time_name)
     self.reservoir_demand_schedule = schedule.assign_coords(
-        # if monthly, convert to 1 based month index (instead of starting from 0)
+        # convert to 1 based month index (instead of starting from 0)
         {demand_time_name: (demand_time_name, schedule[demand_time_name].values + (1 if demand_time_name == 'month' else 0))}
     ).demand
 
     # initialize prerelease based on long term mean flow and demand (Biemans 2011)
-    # TODO this assumes demand and flow use the same timescale :(
     flow_avg = self.reservoir_streamflow_schedule.mean(dim=streamflow_time_name)
     demand_avg = self.reservoir_demand_schedule.mean(dim=demand_time_name)
     prerelease = (1.0 * self.reservoir_streamflow_schedule)
diff --git a/mosartwmpy/reservoirs/reservoirs.py b/mosartwmpy/reservoirs/reservoirs.py
index c348368..4c0186c 100644
--- a/mosartwmpy/reservoirs/reservoirs.py
+++ b/mosartwmpy/reservoirs/reservoirs.py
@@ -1,20 +1,16 @@
 import numpy as np
 
 from datetime import datetime
-from epiweeks import Week
 from benedict.dicts import benedict as Benedict
 
 from mosartwmpy.config.parameters import Parameters
 from mosartwmpy.state.state import State
 from mosartwmpy.grid.grid import Grid
 
-# TODO in fortran mosart there is a StorCalibFlag that affects how storage targets are calculated -- code so far is written assuming that it == 0
 
 def reservoir_release(state, grid, config, parameters, current_time):
     # compute release from reservoirs
-    
-    # TODO so much logic was dependent on monthly, so still assuming monthly for now, but here's the epiweek for when that is relevant
-    epiweek = Week.fromdate(current_time).week
+
     month = current_time.month
     
     # if it's the start of the operational year for the reservoir, set it's start of op year storage to the current storage
@@ -30,9 +26,7 @@ def reservoir_release(state, grid, config, parameters, current_time):
 
 def regulation_release(state, grid, config, parameters, current_time):
     # compute the expected monthly release based on Biemans (2011)
-    
-    # TODO this is still written assuming monthly, but here's the epiweek for when that is relevant
-    epiweek = Week.fromdate(current_time).week
+
     month = current_time.month
     streamflow_time_name = config.get('water_management.reservoirs.streamflow_time_resolution')
     
@@ -77,8 +71,6 @@ def storage_targets(state: State, grid: Grid, config: Benedict, parameters: Para
 
     # TODO the logic here is really hard to follow... can it be simplified or made more readable?
 
-    # TODO this is still written assuming monthly, but here's the epiweek for when that is relevant
-    epiweek = Week.fromdate(current_time).week
     month = current_time.month
     streamflow_time_name = config.get('water_management.reservoirs.streamflow_time_resolution')
 
@@ -96,7 +88,7 @@ def storage_targets(state: State, grid: Grid, config: Benedict, parameters: Para
     )
     drop = 0 * state.reservoir_month_flood_control_start
     n_month = 0 * drop
-    for m in np.arange(1,13): # TODO assumes monthly
+    for m in np.arange(1,13):
         m_and_condition = (m >= state.reservoir_month_flood_control_start) & (m < state.reservoir_month_flood_control_end)
         m_or_condition = (m >= state.reservoir_month_flood_control_start) | (m < state.reservoir_month_flood_control_end)
         drop = np.where(
@@ -128,25 +120,6 @@ def storage_targets(state: State, grid: Grid, config: Benedict, parameters: Para
         (month >= state.reservoir_month_flood_control_end) |
         (month < state.reservoir_month_start_operations)
     )
-    # TODO this logic exists in fortran mosart but isn't used...
-    # fill = 0 * drop
-    # n_month = 0 * drop
-    # for m in np.arange(1,13): # TODO assumes monthly
-    #     m_condition = (m >= self.state.reservoir_month_flood_control_end.values) &
-    #         (self.reservoir_streamflow_schedule.sel({streamflow_time_name: m}).values > self.reservoir_streamflow_schedule.mean(dim=streamflow_time_name).values) & (
-    #             (first_condition & (m <= self.state.reservoir_month_start_operations)) |
-    #             (second_condition & (m <= 12))
-    #         )
-    #     fill = np.where(
-    #         m_condition,
-    #         fill + np.abs(self.reservoir_streamflow_schedule.mean(dim=streamflow_time_name).values - self.reservoir_streamflow_schedule.sel({streamflow_time_name: m}).values),
-    #         fill
-    #     )
-    #     n_month = np.where(
-    #         m_condition,
-    #         n_month + 1,
-    #         n_month
-    #     )
     state.reservoir_release = np.where(
         (state.reservoir_release> grid.reservoir_streamflow_schedule.mean(dim=streamflow_time_name).values) & (first_condition | second_condition),
         grid.reservoir_streamflow_schedule.mean(dim=streamflow_time_name).values,
diff --git a/mosartwmpy/utilities/download_data.py b/mosartwmpy/utilities/download_data.py
index 0575703..8b0a413 100644
--- a/mosartwmpy/utilities/download_data.py
+++ b/mosartwmpy/utilities/download_data.py
@@ -61,7 +61,7 @@ def initialize_logger(self):
         # logger console handler
         console_handler = logging.StreamHandler(sys.stdout)
         console_handler.setLevel(logging.INFO)
-        console_handler.setFormatter(logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s'))
+        console_handler.setFormatter(logging.Formatter(""))
         logger.addHandler(console_handler)
 
     @staticmethod
@@ -100,6 +100,7 @@ def fetch_zenodo(self):
                 with tqdm.wrapattr(
                     stream,
                     'write',
+                    file=sys.stdout,
                     miniters=1,
                     desc=self.url,
                     total=int(r.headers.get('content-length', 0))
diff --git a/notebooks/config.yaml b/notebooks/config.yaml
new file mode 100644
index 0000000..7230420
--- /dev/null
+++ b/notebooks/config.yaml
@@ -0,0 +1,21 @@
+simulation:
+  name: tutorial
+  start_date: 1981-05-01
+  end_date: 1981-05-31
+
+grid:
+  path: ./input/domains/mosart.nc
+  land:
+    path: ./input/domains/land.nc
+
+runoff:
+  read_from_file: true
+  path: ./input/runoff/runoff_1981_05.nc
+
+water_management:
+  enabled: true
+  demand:
+    read_from_file: true
+    path: ./input/demand/demand_1981_05.nc
+  reservoirs:
+    path: ./input/reservoirs/reservoirs.nc
diff --git a/notebooks/config_with_restart.yaml b/notebooks/config_with_restart.yaml
new file mode 100644
index 0000000..afd684e
--- /dev/null
+++ b/notebooks/config_with_restart.yaml
@@ -0,0 +1,22 @@
+simulation:
+  name: tutorial
+  restart_file: ./output/tutorial/restart_files/tutorial_restart_1981_05_15.nc 
+  start_date: 1981-05-15
+  end_date: 1981-05-31
+
+grid:
+  path: ./input/domains/mosart.nc
+  land:
+    path: ./input/domains/land.nc
+
+runoff:
+  read_from_file: true
+  path: ./input/runoff/runoff_1981_05.nc
+
+water_management:
+  enabled: true
+  demand:
+    read_from_file: true
+    path: ./input/demand/demand_1981_05.nc
+  reservoirs:
+    path: ./input/reservoirs/reservoirs.nc
diff --git a/notebooks/tutorial.ipynb b/notebooks/tutorial.ipynb
new file mode 100644
index 0000000..ab5a515
--- /dev/null
+++ b/notebooks/tutorial.ipynb
@@ -0,0 +1,487 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## `mosartwmpy` tutorial\n",
+    "\n",
+    "This tutorial will demonstrate the basic use of `mosartwmpy` in two scenarios:\n",
+    "* First, in standalone mode where all model inputs are provided from files\n",
+    "* Second, a contrived example of running the model coupled with runoff input from another model\n",
+    "\n",
+    "The use of restart files will also be demonstrated."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from mosartwmpy import Model\n",
+    "from mosartwmpy.utilities.download_data import download_data\n",
+    "from datetime import date, datetime\n",
+    "import xarray\n",
+    "import numpy as np"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Download and unpack the tutorial dataset, which covers May of 1981 (this may take a few minutes):"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Downloading example data from https://zenodo.org/record/4667171/files/mosartwmpy-tutorial-1981-05.zip?download=1\n",
+      "https://zenodo.org/record/4667171/files/mosartwmpy-tutorial-1981-05.zip?download=1: 100%|██████████| 66.0M/66.0M [00:07<00:00, 9.68MB/s]\n",
+      "Unzipped: ./input/\n",
+      "Unzipped: ./input/domains/\n",
+      "Unzipped: ./input/domains/land.nc\n",
+      "Unzipped: ./input/domains/mosart.nc\n",
+      "Unzipped: ./input/reservoirs/\n",
+      "Unzipped: ./input/reservoirs/reservoirs.nc\n",
+      "Unzipped: ./input/runoff/\n",
+      "Unzipped: ./input/runoff/runoff_1981_05.nc\n",
+      "Unzipped: ./input/demand/\n",
+      "Unzipped: ./input/demand/demand_1981_05.nc\n",
+      "Download and install complete.\n"
+     ]
+    }
+   ],
+   "source": [
+    "download_data('tutorial')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Initialize the model using the provided `config.yaml`, which has the input paths properly specified for this notebook:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Initalizing model...\n",
+      "Done.\n"
+     ]
+    }
+   ],
+   "source": [
+    "mosart_wm = Model()\n",
+    "mosart_wm.initialize('./config.yaml')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "The model is now setup to run in standalone mode, with runoff provided from file.\n",
+    "\n",
+    "Let's run for a couple weeks in this mode (this may take about 10 minutes):"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Beginning simulation for 1981-05-01 through 1981-05-14...\n",
+      "Current model time is 1981-05-01 00:00:00...\n",
+      "Simulation completed in 8 minutes and 50 seconds.\n"
+     ]
+    }
+   ],
+   "source": [
+    "mosart_wm.config[\"simulation.end_date\"] = date(1981, 5, 14)\n",
+    "mosart_wm.update_until(mosart_wm.get_end_time())"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Let's take a look at how the river channels have formed over this week.\n",
+    "\n",
+    "We will use `xarray` for the convenience plotting methods."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "<matplotlib.collections.QuadMesh at 0x18e1d8670>"
+      ]
+     },
+     "execution_count": 5,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 2 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "surface_water = xarray.DataArray(\n",
+    "    mosart_wm.get_value_ptr('surface_water_amount').reshape(mosart_wm.get_grid_shape()),\n",
+    "    dims=['latitude', 'longitude'],\n",
+    "    coords={'latitude': mosart_wm.get_grid_x(), 'longitude': mosart_wm.get_grid_y()},\n",
+    "    name='Surface Water Amount',\n",
+    "    attrs={'units': mosart_wm.get_var_units('surface_water_amount')}\n",
+    ")\n",
+    "surface_water.plot(robust=True, levels=16, cmap='winter_r')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "We can see the dominant river channels beginning to form! Since the initial conditions have no surface water, it can take a few weeks of model time to get to a good baseline, depending on the amount of rainfall."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Now let's pretend to run the model in coupled mode, as if runoff were being provided by another model such as CLM.\n",
+    "\n",
+    "First, we'll implement dummy functions that create random runoff to take the place of the coupled model:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def get_surface_runoff():\n",
+    "    # provide the surface runoff for each grid cell in mm/s\n",
+    "    data = np.random.normal(0.001, 0.001, mosart_wm.get_grid_shape())\n",
+    "    return np.where(\n",
+    "        np.logical_or(\n",
+    "            data < 0,\n",
+    "            mosart_wm.grid.\n",
+    "        ),\n",
+    "        0,\n",
+    "        data\n",
+    "    )\n",
+    "\n",
+    "def get_subsurface_runoff():\n",
+    "    # provide the subsurface runoff for each grid cell in mm/s\n",
+    "    data = np.random.normal(0.00015, 0.00015, mosart_wm.get_grid_shape())\n",
+    "    return np.where(\n",
+    "        data < 0,\n",
+    "        0,\n",
+    "        data\n",
+    "    )"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "In coupled mode, we'll need to run the model in chunks of time that correspond to the coupling period and update the coupled variables between chunks. For this example, let's say the coupling period is one day -- so we'll update the runoff variables after each day of model time. The same technique could be extended to run the coupled model between each day rather than generating synthetic data."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# first, disable reading runoff from file\n",
+    "mosart_wm.config[\"runoff.read_from_file\"] = False\n",
+    "\n",
+    "# set the end date for two weeks out\n",
+    "mosart_wm.config[\"simulation.end_date\"] = date(1981, 5, 28)\n",
+    "\n",
+    "# for each day, set the runoff and simulate for one day\n",
+    "# note that the model expects the input flattened as a 1-d array\n",
+    "while mosart_wm.get_current_time() < mosart_wm.get_end_time():\n",
+    "    # set the surface runoff from a coupled model\n",
+    "    mosart_wm.set_value('surface_runoff_flux', get_surface_runoff().flatten())\n",
+    "    # set the subsurface runoff from a coupled model\n",
+    "    mosart_wm.set_value('subsurface_runoff_flux', get_subsurface_runoff().flatten())\n",
+    "    # simulate for one day\n",
+    "    day = date.fromtimestamp(mosart_wm.get_current_time())\n",
+    "    while day == date.fromtimestamp(mosart_wm.get_current_time()):\n",
+    "        mosart_wm.update()\n",
+    "    \n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Let's see how the random rainfall affected the river channels..."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "<matplotlib.collections.QuadMesh at 0x18fa7e160>"
+      ]
+     },
+     "execution_count": 8,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 2 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "surface_water = xarray.DataArray(\n",
+    "    mosart_wm.get_value_ptr('surface_water_amount').reshape(mosart_wm.get_grid_shape()),\n",
+    "    dims=['latitude', 'longitude'],\n",
+    "    coords={'latitude': mosart_wm.get_grid_x(), 'longitude': mosart_wm.get_grid_y()},\n",
+    "    name='Surface Water Amount',\n",
+    "    attrs={'units': mosart_wm.get_var_units('surface_water_amount')}\n",
+    ")\n",
+    "surface_water.plot(robust=True, levels=16, cmap='winter_r')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Oops, looks like we flooded Canada and Mexico. Our grid isn't very well defined there (the tutorial only includes CONUS data for the most part) so it makes sense. Depending on the random data generation, you're probably seeing a lot more water across the CONUS too.\n",
+    "\n",
+    "And how about the reservoir storage?"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "<matplotlib.collections.QuadMesh at 0x18e9e1040>"
+      ]
+     },
+     "execution_count": 9,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 2 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "reservoir_water = xarray.DataArray(\n",
+    "    mosart_wm.get_value_ptr('reservoir_water_amount').reshape(mosart_wm.get_grid_shape()),\n",
+    "    dims=['latitude', 'longitude'],\n",
+    "    coords={'latitude': mosart_wm.get_grid_x(), 'longitude': mosart_wm.get_grid_y()},\n",
+    "    name='Reservoir Water Amount',\n",
+    "    attrs={'units': mosart_wm.get_var_units('reservoir_water_amount')}\n",
+    ")\n",
+    "reservoir_water.plot(robust=True, levels=16, cmap='winter_r')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Let's try restarting the simulation after the original two weeks in May, and run the second two weeks with the runoff from the file. By default, restart files are produced at the end of each model year and also at the end of each simulation. The provided `config_with_restart.yaml` file will use the restart file from 1981-05-15. You can also use a restart file like an initial conditions file by setting the start date to whatever date you choose. But in this case we'll restart where we left off."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Initalizing model...\n",
+      "Loading restart file from: `./output/tutorial/restart_files/tutorial_restart_1981_05_15.nc`.\n",
+      "Done.\n",
+      "Beginning simulation for 1981-05-15 through 1981-05-28...\n",
+      "Simulation completed in 8 minutes and 15 seconds.\n"
+     ]
+    }
+   ],
+   "source": [
+    "mosart_wm = Model()\n",
+    "mosart_wm.initialize('./config_with_restart.yaml')\n",
+    "mosart_wm.config[\"simulation.start_date\"] = date(1981, 5, 15)\n",
+    "mosart_wm.config[\"simulation.end_date\"] = date(1981, 5, 28)\n",
+    "mosart_wm.update_until(mosart_wm.get_end_time())"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Let's look at the surface water and reservoir storage again:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "<matplotlib.collections.QuadMesh at 0x1902e8a60>"
+      ]
+     },
+     "execution_count": 11,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 2 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "surface_water = xarray.DataArray(\n",
+    "    mosart_wm.get_value_ptr('surface_water_amount').reshape(mosart_wm.get_grid_shape()),\n",
+    "    dims=['latitude', 'longitude'],\n",
+    "    coords={'latitude': mosart_wm.get_grid_x(), 'longitude': mosart_wm.get_grid_y()},\n",
+    "    name='Surface Water Amount',\n",
+    "    attrs={'units': mosart_wm.get_var_units('surface_water_amount')}\n",
+    ")\n",
+    "surface_water.plot(robust=True, levels=16, cmap='winter_r')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "<matplotlib.collections.QuadMesh at 0x18fcc41c0>"
+      ]
+     },
+     "execution_count": 12,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 2 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "reservoir_water = xarray.DataArray(\n",
+    "    mosart_wm.get_value_ptr('reservoir_water_amount').reshape(mosart_wm.get_grid_shape()),\n",
+    "    dims=['latitude', 'longitude'],\n",
+    "    coords={'latitude': mosart_wm.get_grid_x(), 'longitude': mosart_wm.get_grid_y()},\n",
+    "    name='Reservoir Water Amount',\n",
+    "    attrs={'units': mosart_wm.get_var_units('reservoir_water_amount')}\n",
+    ")\n",
+    "reservoir_water.plot(robust=True, levels=16, cmap='winter_r')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "These plots make more sense than the random runoff!\n",
+    "\n",
+    "This concludes the `mosartwmpy` tutorial!"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.9.4"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}
diff --git a/requirements.txt b/requirements.txt
index b0a5c64..bf1a8b0 100644
--- a/requirements.txt
+++ b/requirements.txt
@@ -1,19 +1,1 @@
-bmipy==2.0
-dask[complete]==2021.01.1
-epiweeks==2.1.2
-h5netcdf==0.10.0
-matplotlib==3.3.3
-nc-time-axis==1.2.0
-netCDF4==1.5.4
-numexpr==2.7.2
-numpy==1.19.4
-pandas==1.1.4
-pathvalidate==2.3.0
-psutil==5.7.3
-pyarrow==3.0.0
-python-benedict==0.24.0
-regex==2020.11.13
-requests==2.25.1
-rioxarray==0.3.1
-tqdm==4.60.0
-xarray==0.16.1
\ No newline at end of file
+.[dev]
\ No newline at end of file
diff --git a/setup.py b/setup.py
index 2b1f1a6..dc51086 100644
--- a/setup.py
+++ b/setup.py
@@ -7,15 +7,9 @@ def readme():
         return f.read()
 
 
-def get_requirements():
-    """Return a list of package requirements from the requirements.txt file."""
-    with open('requirements.txt') as f:
-        return f.read().split()
-
-
 setup(
     name='mosartwmpy',
-    version='0.0.4',
+    version='0.0.6',
     packages=find_packages(),
     url='https://github.com/IMMM-SFA/mosartwmpy',
     license='BSD2-Simplified',
@@ -26,8 +20,33 @@ def get_requirements():
     long_description_content_type="text/markdown",
     python_requires='>=3.7.*, <4',
     include_package_data=True,
-    install_requires=get_requirements(),
+    install_requires=[
+        'bmipy==2.0',
+        'dask[complete]==2021.5.1',
+        'matplotlib==3.4.2',
+        'nc-time-axis==1.2.0',
+        'netCDF4==1.5.6',
+        'numexpr==2.7.3',
+        'numpy==1.20.3',
+        'pandas==1.2.4',
+        'pathvalidate==2.3.0',
+        'psutil==5.8.0',
+        'pyarrow==4.0.1',
+        'python-benedict==0.24.0',
+        'regex==2021.4.4',
+        'requests==2.25.1',
+        'rioxarray==0.4.2',
+        'tqdm==4.60.0',
+        'xarray==0.18.2'
+    ],
     extras_require={
-        'dev': ['recommonmark==0.7.1', 'setuptools==54.1.2', 'sphinx==3.5.2', 'sphinx-rtd-theme==0.5.1']
+        'dev': [
+            'build==0.4.0',
+            'recommonmark==0.7.1',
+            'setuptools==54.1.2',
+            'sphinx==3.5.2',
+            'sphinx-rtd-theme==0.5.1',
+            'twine==3.4.1'
+        ]
     }
 )


Test patch:
diff --git a/mosartwmpy/tests/grid.zip b/mosartwmpy/tests/grid.zip
index 7e1a50a..2b73a98 100644
Binary files a/mosartwmpy/tests/grid.zip and b/mosartwmpy/tests/grid.zip differ