Land Diagnostics using ADF

lib/adf_config.py

@@ -21,7 +21,7 @@
 import copy
 
 #+++++++++++++++++++++++++++++++++++++++++++++++++
-#import non-standard python modules, including ADF
+#import non-standard python modules, including ADF:
 #+++++++++++++++++++++++++++++++++++++++++++++++++
 
 import yaml

lib/adf_dataset.py

@@ -1,5 +1,6 @@
 from pathlib import Path
 import xarray as xr
+import uxarray as ux
 
 import warnings # use to warn user about missing files
 
@@ -47,7 +48,7 @@ class AdfData:
     def __init__(self, adfobj):
         self.adf = adfobj  # provides quick access to the AdfDiag object
         # paths 
-        self.model_rgrid_loc = adfobj.get_basic_info("cam_regrid_loc", required=True)
+        self.model_rgrid_loc = adfobj.get_basic_info("cam_climo_regrid_loc", required=True)
 
         # variables (and info for unit transform)
         # use self.adf.diag_var_list and self.adf.self.adf.variable_defaults
@@ -185,15 +186,30 @@ def load_climo_da(self, case, variablename):
         return self.load_da(fils, variablename, add_offset=add_offset, scale_factor=scale_factor)
 
 
-    def load_climo_file(self, case, variablename):
-        """Return Dataset for climo of variablename"""
+    def load_climo_dataset(self, case, field):
+        """Return a data set to be used as reference (aka baseline) for variable field."""
+        fils = self.get_climo_file(case, field)
+        if not fils:
+            warnings.warn(f"WARNING: Did not find climo file(s) for case: {case}, variable: {field}")
+            return None
+        return self.load_dataset(fils)
+
+    def load_climo_file(self, case, variablename, grid='regular'):
+        """
+        Return Dataset for climo of variablename
+        uses grid flag to determine if reading in a regular or unstructured grid
+        returns a xarry or uxarray dataset, respectively
+        """
         fils = self.get_climo_file(case, variablename)
         if not fils:
             warnings.warn(f"WARNING: Did not find climo file for variable: {variablename}. Will try to skip.")
             return None
-        return self.load_dataset(fils)
-
+        if grid == 'regular':
+            return self.load_dataset(fils)
+        elif grid == 'unstructured':
+            return self.load_ux_dataset(fils)
 
+
     def get_climo_file(self, case, variablename):
         """Retrieve the climo file path(s) for variablename for a specific case."""
         a = self.adf.get_cam_info("cam_climo_loc", required=True) # list of paths (could be multiple cases)
@@ -209,6 +225,15 @@ def load_reference_climo_da(self, case, variablename):
         fils = self.get_reference_climo_file(variablename)
         return self.load_da(fils, variablename, add_offset=add_offset, scale_factor=scale_factor)
 
+    def load_reference_climo_dataset(self, case, field):
+        """Return a data set to be used as reference (aka baseline) for variable field."""
+        fils = self.get_reference_climo_file(self, field)
+        if not fils:
+            warnings.warn(f"WARNING: Did not find climo file(s) for case: {case}, variable: {field}")
+            return None
+        return self.load_dataset(fils)
+
+
     def get_reference_climo_file(self, var):
         """Return a list of files to be used as reference (aka baseline) for variable var."""
         if self.adf.compare_obs:
@@ -223,14 +248,13 @@ def get_reference_climo_file(self, var):
 
     #------------------
 
-
     # Regridded files
     #------------------
 
     # Test case(s)
     def get_regrid_file(self, case, field):
         """Return list of test regridded files"""
-        model_rg_loc = Path(self.adf.get_basic_info("cam_regrid_loc", required=True))
+        model_rg_loc = Path(self.adf.get_basic_info("cam_climo_regrid_loc", required=True))
         rlbl = self.ref_labels[field]  # rlbl = "reference label" = the name of the reference data that defines target grid
         return sorted(model_rg_loc.glob(f"{rlbl}_{case}_{field}_regridded.nc"))
 
@@ -264,7 +288,7 @@ def get_ref_regrid_file(self, case, field):
             else:
                 fils = []
         else:
-            model_rg_loc = Path(self.adf.get_basic_info("cam_regrid_loc", required=True))
+            model_rg_loc = Path(self.adf.get_basic_info("cam_climo_regrid_loc", required=True))
             fils = sorted(model_rg_loc.glob(f"{case}_{field}_baseline.nc"))
         return fils
 
@@ -296,6 +320,8 @@ def load_reference_regrid_da(self, case, field):
 
     # DataSet and DataArray load
     #---------------------------
+    # TODO, make uxarray options fo all of these fuctions.  
+    # What's the most robust way to handle this?
 
     # Load DataSet
     def load_dataset(self, fils):
@@ -310,7 +336,8 @@ def load_dataset(self, fils):
             if not Path(sfil).is_file():
                 warnings.warn(f"Expecting to find file: {sfil}")
                 return None
-            ds = xr.open_dataset(sfil)
+            mesh = '/glade/campaign/cesm/cesmdata/inputdata/share/meshes/ne30pg3_ESMFmesh_cdf5_c20211018.nc'
+            ds = ux.open_dataset(mesh, sfil)
         if ds is None:
             warnings.warn(f"invalid data on load_dataset")
         return ds

lib/adf_diag.py

@@ -67,6 +67,30 @@
     print("Please install module, e.g. 'pip install Cartopy'.")
     sys.exit(1)
 
+# Check if "uxarray" is present in python path:
+try:
+    import uxarray as ux
+except ImportError:
+    print("uxarray module does not exist in python path.")
+    print("Please install module, e.g. 'pip install uxarray'.")
+    sys.exit(1)
+
+# Check if "esmpy" is present in python path:
+try:
+    import esmpy as esmpy
+except ImportError:
+    print("xesmf module does not exist in python path.")
+    print("Please install module, e.g. 'pip install esmpy'.")
+    sys.exit(1)
+
+# Check if "xesmf" is present in python path:
+try:
+    import xesmf as xesmf
+except ImportError:
+    print("xesmf module does not exist in python path.")
+    print("Please install module, e.g. 'pip install xesmf'.")
+    sys.exit(1)
+
 # pylint: enable=unused-import
 
 # +++++++++++++++++++++++++++++
@@ -714,19 +738,41 @@ def call_ncrcat(cmd):
                         ts_outfil_str
                     ]
 
-                    # Step 3: Create the ncatted command to remove the history attribute
+                    # Step 3a: Optional, add additional variables to clm2.h0 files 
+                    cmd_add_clm_h0_fields = [
+                        "ncks", "-A", "-v", "area,landfrac,landmask",
+                        hist_files[0],
+                        ts_outfil_str
+                    ]
+
+                    # Step 3b: Optional, add additional variables to clm2.h1 files 
+                    cmd_add_clm_h1_fields = [
+                        "ncrcat", "-A", "-v", "pfts1d_ixy,pfts1d_jxy,pfts1d_itype_veg,lat,lon",
+                        hist_files,
+                        ts_outfil_str
+                    ]
+
+                     # Step 3c: Create the ncatted command to remove the history attribute
                     cmd_remove_history = [
                         "ncatted", "-O", "-h",
                         "-a", "history,global,d,,",
                         ts_outfil_str
                     ]
-
+
+
                     # Add to command list for use in multi-processing pool:
                     # -----------------------------------------------------
                     # generate time series files
                     list_of_commands.append(cmd)
                     # Add global attributes: user, original hist file loc(s) and all filenames
                     list_of_ncattend_commands.append(cmd_ncatted)
+
+                    # TODO, add some logic to control if these are done
+                    # add time invariant information to clm2.h0 fields
+                    list_of_hist_commands.append(cmd_add_clm_h0_fields)
+                    # add time varrying information to clm2.h1 fields
+                    #list_of_hist_commands.append(cmd_add_clm_h1_fields)
+
                     # Remove the `history` attr that gets tacked on (for clean up)
                     # NOTE: this may not be best practice, but it the history attr repeats
                     #       the files attrs so the global attrs become obtrusive...

lib/adf_variable_defaults.yaml

@@ -1932,6 +1932,24 @@ RESTOM:
   pct_diff_contour_levels: [-100,-75,-50,-40,-30,-20,-10,-8,-6,-4,-2,0,2,4,6,8,10,20,30,40,50,75,100]
   pct_diff_colormap: "PuOr_r"
 
+SNOWDP:
+  colormap: "Blues"
+  contour_levels_range: [-150, 50, 10]
+  diff_colormap: "BrBG"
+  diff_contour_range: [-20, 20, 2]
+  scale_factor: 1
+  add_offset: 0
+  new_unit: "Wm$^{-2}$"
+  mpl:
+    colorbar:
+      label : "Wm$^{-2}$"
+  obs_file: "CERES_EBAF_Ed4.1_2001-2020.nc"
+  obs_name: "CERES_EBAF_Ed4.1"
+  obs_var_name: "toa_cre_sw_mon"
+  obs_scale_factor: 1
+  obs_add_offset: 0
+  category: "TOA energy flux"
+
 SWCF:
   colormap: "Blues"
   contour_levels_range: [-150, 50, 10]