fixed writing verdat and some test cleanup

Author: ChrisBarker-NOAA

gridded/gridded.py

@@ -139,6 +139,13 @@ def __getitem__(self, key):
         """
         return self.variables[key]
 
+    def __str__(self):
+        descp = (f"gridded.Dataset with:\n"
+                 f"grid: {type(self.grid)}\n"
+                 f"variables: {list(self.variables.keys())}"
+                 )
+        return descp
+
 
     def _load_variables(self, ds):
         """

gridded/io/verdat.py

@@ -12,6 +12,13 @@
 import numpy as np
 import gridded
 
+# verdat only supports FEET or METERS
+FEET = ("foot", "ft", "feet")
+METER = ("meter", "m", "meters", "metre")
+UNITS_MAP = {u: "FEET" for u in FEET}
+UNITS_MAP.update({u: "METERS" for u in METER})
+
+
 
 def load_verdat(filename):
 
@@ -34,10 +41,7 @@ def load_verdat(filename):
             lons.append(lon)
             lats.append(lat)
             depths.append(depth)
-        # print(lons)
-        # print(lats)
-        # print(depths)
-        #read the boundaries:
+        # read the boundaries:
         line = infile.readline().strip()
         try:
             num_bounds = int(line)
@@ -88,27 +92,30 @@ def save_verdat(ds, filename, depth_var="depth"):
     :param filename: name (full or relative path) of the file to save
 
     :param depth_var="depth": name of the variable with the depths in it.
+                     if depth is None, all depths will be set to 1
 
-    The dataset must:
-
-    * Have a UGrid grid
-    * Have a variable for the depth
+    The dataset must: Have a UGrid grid
 
     If it has boundaries, they will be used. Otherwise,
     it will create them from the grid.
     """
-
-    depth = ds[depth_var]
     nodes = ds.grid.nodes
+    if depth_var is None:
+        depth = np.ones((nodes.shape[0],), dtype=np.float32)
+        depth_units = ""
+    else:
+        depth = ds[depth_var]
+        depth_units = UNITS_MAP[depth.units.strip().lower()]
     f_string = "{0:4d}, {1:10.6f}, {2:10.6f}, {3:8.3f}\n"
+
     with open(filename, 'w') as outfile:
-        outfile.write("DOGS ")
-        if depth.units:
-            outfile.write(depth.units.upper())
-        outfile.write("\n")
+        outfile.write("DOGS")
+        outfile.write(f" {depth_units}\n")
 
         depth = depth.data
         # write out the boundaries first
+        if ds.grid.boundaries is None:
+            ds.grid.build_boundaries()
         bounds, open_bounds = order_boundary_segments(ds.grid.boundaries)
         points_written = []
         i = 1
@@ -128,15 +135,14 @@ def save_verdat(ds, filename, depth_var="depth"):
         for j in range(len(nodes)):
             if j not in points_written:
                 outfile.write(f_string.format(i,
-                                              lon,
-                                              lat,
+                                              nodes[j, 0],
+                                              nodes[j, 1],
                                               depth[j]))
                 i += 1
         outfile.write(f_string.format(0, 0, 0, 0))
         outfile.write("{:d}\n".format(len(bounds)))
         i = 0
         for bound in bounds:
-            print(bound)
             i += len(bound)
             outfile.write("{:d}\n".format(i))
 

gridded/tests/get_remote_data.py

@@ -13,6 +13,8 @@
 import gridded
 from gridded import io
 
+from ..utilities import data_file_cache
+
 DATA_URL = "https://gnome.orr.noaa.gov/py_gnome_testdata/gridded_test_files/"
 
 HERE = Path(__file__).parent
@@ -90,7 +92,8 @@ def test_read_tiny():
 
 
 def test_save_verdat():
-    ds = io.load_verdat(EXAMPLES /  "tiny.verdat")
+    infilename = EXAMPLES /  "tiny.verdat"
+    ds = io.load_verdat(infilename)
 
     outfilename = OUTPUT / "tiny_out.verdat"
 
@@ -101,15 +104,16 @@ def test_save_verdat():
     assert outfilename.is_file()
 
     # Check at least a little bit if it's a valid verdat
+    orig_contents = open(infilename).readlines()
     contents = open(outfilename).readlines()
-    print(len(contents))
-
-    print(contents)
-    print(len(contents))
+    for l1, l2 in zip(orig_contents, contents):
+        norm1 = [s.strip() for s in l1.strip().split(",")]
+        norm2 = [s.strip() for s in l2.strip().split(",")]
+        print()
+        print(norm1)
+        print(norm2)
 
-    assert len(contents) == 16
-    assert contents[15] == "9\n"
-    assert contents[0] == "DOGS FEET\n"
+        assert norm1 == norm2
 
 
 def test_order_boundary_segments():
@@ -164,17 +168,27 @@ def test_order_boundary_segments_none():
     assert len(open_bounds) == 0
 
 
-def test_general_ugrid_to_verdat():
+def test_general_ugrid_to_verdat_no_depth():
     """
     Loads a regular old UGRID netCDF file, and saves it to verdat
     """
-    ugrid_file = pooch.retrieve(
-        url=(DATA_URL + "SSCOFS.ugrid.nc"),
-        known_hash="sha256:0dcea2a2fb6ad87c7cce3ebc475fd2f0430616a5019f54f4adf97391e075e939",
-    )
+    ugrid_file = data_file_cache.fetch("SSCOFS.ugrid.nc")
+    ds = gridded.Dataset.from_netCDF(ugrid_file)
+
+    outfile = OUTPUT / "SSCOFS.verdat"
+    outfile.unlink(missing_ok=True)
+
+    io.save_verdat(ds, outfile, depth_var=None)
+
+    assert outfile.is_file()
+
+    contents = open(outfile).readlines()
+
+    assert contents[0] == "DOGS \n"
 
-    assert False
 
+    assert contents[-1] == "190\n"
+    assert contents[-2] == "1\n"
 
 
 if __name__ == "__main__":

gridded/tests/test_io/__init__.py

@@ -60,35 +60,40 @@
 
 from gridded import VALID_UGRID_LOCATIONS
 
-from .utilities import get_temp_test_file
+from .utilities import data_file_cache
 
+# try:
+#     data_file = get_temp_test_file("projected_coords_ugrid.nc")
+#     if data_file is None:
+#         # skip these tests if the data file couldn't be downloaded
+#         pytestmark = pytest.mark.skip
+# except: # if anything went wrong, skip these.
+#     pytestmark = pytest.mark.skip
 
-try:
-    data_file = get_temp_test_file("projected_coords_ugrid.nc")
-    if data_file is None:
-        # skip these tests if the data file couldn't be downloaded
-        pytestmark = pytest.mark.skip
-except: # if anything went wrong, skip these.
-    pytestmark = pytest.mark.skip
-
+data_file = data_file_cache.fetch("projected_coords_ugrid.nc")
 
 def test_load():
     """
     The file should load without error
     """
-    ds = Dataset(data_file)
+    ds = Dataset.from_netCDF(data_file)
 
     assert isinstance(ds.grid, Grid_U)
 
+    print(ds.grid.nodes.max(), ds.grid.nodes.min())
+    assert ds.grid.nodes.min() > 148_000  # definitely not lat-lon
+
 
 def test_find_variables():
     """
     Does it find the variables?
     """
-    ds = Dataset(data_file)
+    ds = Dataset.from_netCDF(data_file)
 
     var_names = list(ds.variables.keys())
 
+    print(var_names)
+
     all_vars =  ['mesh2d_Numlimdt',
                  'mesh2d_czs',
                  'mesh2d_diu',