SCH-832 mulitple schism studies

Author: dwr-psandhu

pydelmod/schismstudy.py

@@ -4,6 +4,7 @@
 import schimpy
 import pandas as pd
 import schimpy.station as station
+from schimpy import param as schimpyparam
 import schimpy.schism_yaml as schism_yaml
 import schimpy.batch_metrics as schism_metrics
 import cartopy.crs as ccrs
@@ -12,6 +13,7 @@
 import geopandas as gpd
 import param
 import diskcache
+import datetime
 
 # use logging
 import logging
@@ -105,27 +107,40 @@ class SchismStudy(param.Parameterized):
     def __init__(
         self,
         base_dir=".",
+        output_dir="outputs",
+        param_nml_file="param.nml",
         flux_xsect_file="flow_station_xsects.yaml",
         station_in_file="station.in",
         flux_out="flux.out",
-        reftime="2020-01-01",
+        reftime=None,
         **kwargs,
     ):
         self.base_dir = pathlib.Path(base_dir)
+        self.param_nml_file = self.interpret_file_relative_to(
+            self.base_dir, pathlib.Path(param_nml_file)
+        )
+        self.output_dir = self.interpret_file_relative_to(
+            self.base_dir, pathlib.Path(output_dir)
+        )
         try:
             self.cache = diskcache.Cache(self.base_dir / ".cache-schismstudy")
         except:
             logger.warning("Could not create cache. Using temporary cache.")
             self.cache = diskcache.Cache()
-        self.reftime = pd.Timestamp(reftime)
+        if not reftime:
+            nml = schimpyparam.read_params(self.param_nml_file)
+            self.reftime = nml.run_start
+            self.endtime = nml.run_start + datetime.timedelta(days=nml["rnday"])
+        else:
+            self.reftime = pd.Timestamp(reftime)
         self.flux_xsect_file = self.interpret_file_relative_to(
             self.base_dir, pathlib.Path(flux_xsect_file)
         )
         self.station_in_file = self.interpret_file_relative_to(
             self.base_dir, pathlib.Path(station_in_file)
         )
         self.flux_out = self.interpret_file_relative_to(
-            self.base_dir, pathlib.Path(flux_out)
+            self.output_dir, pathlib.Path(flux_out)
         )
         super().__init__(**kwargs)
         stations = read_station_in(self.station_in_file)
@@ -160,10 +175,10 @@ def __init__(
 
     def interpret_file_relative_to(self, base_dir, fpath):
         full_path = base_dir / fpath
-        if full_path.exists():
-            return full_path
-        else:
-            return fpath
+        if not full_path.exists():
+            logger.warning(f"File {full_path} does not exist. Using {fpath} instead.")
+            full_path = fpath
+        return full_path
 
     def get_unit_for_variable(self, var):
         if var in ["elev"]:
@@ -191,7 +206,9 @@ def get_catalog(self):
                 s = self.stations_gdf.copy()
                 s["variable"] = var
                 s["unit"] = self.get_unit_for_variable(var)
-                s["filename"] = str(self.base_dir / station.staout_name(var))
+                s["filename"] = self.interpret_file_relative_to(
+                    self.output_dir, station.staout_name(var)
+                )
                 s.drop(columns=["id", "subloc", "x", "y", "z"], inplace=True)
                 s.rename(columns={"station_id": "id"}, inplace=True)
                 var_stations.append(s)
@@ -252,7 +269,9 @@ def get_flux(self):
     @lru_cache(maxsize=32)
     def get_staout(self, variable, fpath=None):
         if fpath is None:
-            fpath = str(self.base_dir / station.staout_name(variable))
+            fpath = self.interpret_file_relative_to(
+                self.output_dir, station.staout_name(variable)
+            )
         if fpath in self.cache:
             logger.info(f"Using cached staout from disk: {fpath}")
             return self.cache[fpath]

pydelmod/schismui.py

@@ -21,7 +21,7 @@ def __init__(self, *studies, datastore=None, time_range=None, **kwargs):
         This is merged with the data catalog to get the station locations.
         """
         self.studies = studies
-        self.study_dir_map = {str(s.base_dir): s for s in self.studies}
+        self.study_dir_map = {str(s.output_dir): s for s in self.studies}
         self.datastore = datastore
         self.catalog = self._merge_catalogs(self.studies, self.datastore)
         self.catalog["filename"] = self.catalog["filename"].astype(str)
@@ -195,18 +195,47 @@ def get_map_marker_columns(self):
     "--station_in_file", default="station.in", help="Path to the station.in file"
 )
 @click.option("--flux_out", default="flux.out", help="Path to the flux.out file")
-@click.option("--reftime", default="2020-01-01", help="Reference time")
+@click.option("--reftime", default=None, help="Reference time")
 @click.option("--yaml_file", default=None, help="Path to the yaml file")
 def show_schism_output_ui(
     schism_dir=".",
     flux_xsect_file="flow_station_xsects.yaml",
     station_in_file="station.in",
     flux_out="flux.out",
-    reftime="2020-01-01",
+    reftime=None,
     repo_dir="screened",
     inventory_file="inventory_datasets.csv",
     yaml_file=None,
 ):
+    """
+    Shows Data UI for SCHISM output files.
+
+    This function creates a Data UI for SCHISM output files, allowing users to visualize and analyze the data.
+    It can handle multiple studies and datasets, and provides options for customizing the display.
+    The function can be run from the command line or imported as a module.
+
+    If a YAML file is provided, it will be used to create multiple studies.
+    Otherwise, a single study will be created using the provided parameters.
+
+    Example YAML file::
+
+    .. code-block:: yaml
+        \b
+        schism_studies:
+            - label: Study1
+            base_dir: "study1_directory"
+            flux_xsect_file: "study1_flow_station_xsects.yaml"
+            station_in_file: "study1_station.in"
+            output_dir: "outputs"
+            param_nml_file: "param.nml"
+            flux_out: "study1_flux.out"
+            reftime: "2020-01-01"
+            - label: Study2
+            base_dir: "study2_directory"
+        datastore:
+            repo_dir: /repo/continuous/screened
+            inventory_file: "inventory_datasets.csv"
+    """
     if yaml_file:
         # Load the YAML file and create multiple studies
         with open(yaml_file, "r") as file:
@@ -217,15 +246,21 @@ def show_schism_output_ui(
             studies.append(
                 schismstudy.SchismStudy(
                     base_dir=study_config["base_dir"],
+                    output_dir=study_config.get("output_dir", "outputs"),
+                    param_nml_file=study_config.get("param_nml_file", "param.nml"),
                     flux_xsect_file=study_config.get(
                         "flux_xsect_file", "flow_station_xsects.yaml"
                     ),
                     station_in_file=study_config.get("station_in_file", "station.in"),
                     flux_out=study_config.get("flux_out", "flux.out"),
-                    reftime=study_config.get("reftime", "2020-01-01"),
+                    reftime=reftime,
                     **study_config.get("additional_parameters", {}),
                 )
             )
+
+        datastore_config = yaml_data.get("datastore", {})
+        repo_dir = datastore_config.get("repo_dir", repo_dir)
+        inventory_file = datastore_config.get("inventory_file", inventory_file)
     else:
         # Create a single study if no YAML file is provided
         studies = [
@@ -238,12 +273,17 @@ def show_schism_output_ui(
             )
         ]
 
+    # study.reftime to study.endtime is the range of a single study
+    # Initialize the union range
+    union_start = min(study.reftime for study in studies)
+    union_end = max(study.endtime for study in studies)
+
+    # Create the union range as a single variable
+    time_range = (union_start, union_end)
+
     # Create the datastore
     ds = datastore.StationDatastore(repo_dir=repo_dir, inventory_file=inventory_file)
 
-    # Define the time range
-    time_range = (pd.Timestamp(reftime), pd.Timestamp(reftime) + pd.Timedelta(days=250))
-
     # Create the UI
     ui = DataUI(
         SchismOutputUIDataManager(