Update: tests for OCX and QAA

Author: heptaflar

test/oceancolour/test_ocx.py

@@ -12,7 +12,7 @@
 from uncertaintyx.oceancolour.ocx import OCI
 
 
-def read_test_data(
+def read_owt_data(
     package: str, filename: str
 ) -> tuple[np.ndarray, np.ndarray, np.ndarray, int, int]:
     """
@@ -39,10 +39,11 @@ class OCxTest(unittest.TestCase):
     """Tests OCX model functions on optical water type classes."""
 
     def test_ci(self):
-        w, R, u, M, m = read_test_data(  # noqa : N806
+        """Tests the chlorophyll index (CI) model function."""
+        w, R, u, M, m = read_owt_data(  # noqa : N806
             "test.resources", "owt.csv"
         )
-        W = np.broadcast_to(w, R.shape)  # noqa : N806
+        W = np.broadcast_to(w, (M, m))  # noqa : N806
 
         f = CI()
         x = np.stack([W[:, [1, 4, 5]], R[:, [1, 4, 5]]], axis=1)
@@ -89,7 +90,8 @@ def test_ci(self):
         self.assertTrue(np.isfinite(y[13]))
 
     def test_oc4(self):
-        _, R, u, M, m = read_test_data(  # noqa : N806
+        """Tests the OC4 model function."""
+        _, R, u, M, m = read_owt_data(  # noqa : N806
             "test.resources", "owt.csv"
         )
 
@@ -136,10 +138,11 @@ def test_oc4(self):
         self.assertAlmostEqual(4.362, v[13], delta=0.001)
 
     def test_oci(self):
-        w, R, u, M, m = read_test_data(  # noqa : N806
+        """Tests the OCI model function."""
+        w, R, u, M, m = read_owt_data(  # noqa : N806
             "test.resources", "owt.csv"
         )
-        W = np.broadcast_to(w, R.shape)  # noqa : N806
+        W = np.broadcast_to(w, (M, m))  # noqa : N806
 
         f = OCI()
         x = np.stack([W[:, 1:], R[:, 1:]], axis=1)
@@ -164,10 +167,10 @@ def test_oci(self):
         self.assertAlmostEqual(3.427, y[13], delta=0.001)
 
         U = np.square(u)  # noqa : N806
-        V = f.lpu_x(p, x, U)  # noqa : N806
-        self.assertEqual((M,), V.shape)
+        U = f.lpu_x(p, x, U)  # noqa : N806
+        self.assertEqual((M,), U.shape)
 
-        v = np.sqrt(V)
+        v = np.sqrt(U)
         self.assertAlmostEqual(0.026, v[0], delta=0.001)
         self.assertAlmostEqual(0.024, v[1], delta=0.001)
         self.assertAlmostEqual(0.042, v[2], delta=0.001)

test/oceancolour/test_qaa.py

@@ -47,6 +47,29 @@ def matrix(result: Result, a: Any, b: Any, n: int = 1000) -> np.ndarray:
     return np.squeeze(result.ycov_p(np.linspace(a, b, n).reshape(1, n)))
 
 
+def read_owt_data(
+    package: str, filename: str
+) -> tuple[np.ndarray, np.ndarray, np.ndarray, int, int]:
+    """
+    Returns the optical water types (OWT) data table.
+
+    :param package: The package name.
+    :param filename: The filename.
+    :returns: The data table.
+    """
+    with resources.path(package, filename) as resource:
+        rows = []
+        with open(resource) as r:
+            df = pd.read_csv(r, sep=";", header=None, index_col=0)
+            for name, _ in df.items():
+                rows.append(df[name].values)
+            data = np.stack(rows, axis=-1)
+    wav = data[0, :6]
+    rrs = data[1:, :6]
+    unc = data[1:, 6:]
+    return wav, rrs, unc, rrs.shape[0], rrs.shape[1]
+
+
 def read_plot_data(
     package: str, filename: str
 ) -> tuple[np.ndarray, np.ndarray]:
@@ -108,7 +131,7 @@ def test_lee_2010_figure_2(self):
         self.assertAlmostEqual(0.1, result.punc[0], delta=0.1)
         self.assertAlmostEqual(0.1, result.punc[1], delta=0.1)
         self.assertAlmostEqual(0.1, result.punc[1], delta=0.1)
-        self.assertAlmostEqual(0.3, result.yvar_r, delta=0.1)
+        self.assertAlmostEqual(0.3, result.yvar_r.item(), delta=0.1)
 
         print()
         print("popt = ", result.popt)
@@ -155,7 +178,7 @@ def test_lee_2010_figure_3(self):
         self.assertAlmostEqual(0.001, result.punc[0], delta=0.001)
         self.assertAlmostEqual(0.001, result.punc[0], delta=0.001)
         self.assertAlmostEqual(5.0, result.punc[0], delta=5.0)
-        self.assertAlmostEqual(1.5e-05, result.yvar_r, delta=0.1e-05)
+        self.assertAlmostEqual(1.5e-05, result.yvar_r.item(), delta=0.1e-05)
 
         print()
         print("popt = ", result.popt)
@@ -272,6 +295,73 @@ def test_qaa_multiple_batches(self):
                     msg=f"{i}, {j}: assertion failed",
                 )
 
+    def test_qaa_with_owt(self):
+        """
+        Test QAA on optical water type (OWT) classes.
+        """
+        w, R, u, M, m = read_owt_data(  # noqa : N806
+            "test.resources", "owt.csv"
+        )
+        W = np.broadcast_to(w, (M, m))  # noqa : N806
+
+        f = QAA()
+        x = np.stack(
+            [
+                np.broadcast_to(W, (M, m)),
+                R,
+                np.broadcast_to(AW, (M, m)),
+                np.broadcast_to(BW, (M, m)),
+            ],
+            axis=1,
+        )
+        u = np.stack(
+            [
+                np.broadcast_to(0.5, (M, m)),
+                u,
+                np.broadcast_to(0.1 * AW, (M, m)),
+                np.broadcast_to(0.1 * BW, (M, m)),
+            ],
+            axis=1,
+        )
+        p = f.estimate()
+        y = f.eval(p, x)
+        self.assertEqual((M, 4, m), y.shape)
+
+        a = y[:, 0, :]
+        self.assertAlmostEqual(0.014, a[0, 0], delta=0.001)
+        self.assertAlmostEqual(0.015, a[0, 1], delta=0.001)
+        self.assertAlmostEqual(0.019, a[0, 2], delta=0.001)
+        self.assertAlmostEqual(0.034, a[0, 3], delta=0.001)
+        self.assertAlmostEqual(0.060, a[0, 4], delta=0.001)
+        self.assertAlmostEqual(0.291, a[0, 5], delta=0.001)
+
+        self.assertAlmostEqual(0.515, a[13, 0], delta=0.001)
+        self.assertAlmostEqual(0.391, a[13, 1], delta=0.001)
+        self.assertAlmostEqual(0.249, a[13, 2], delta=0.001)
+        self.assertAlmostEqual(0.224, a[13, 3], delta=0.001)
+        self.assertAlmostEqual(0.184, a[13, 4], delta=0.001)
+        self.assertAlmostEqual(0.514, a[13, 5], delta=0.001)
+
+        U = np.square(u)  # noqa : N806
+        U = f.lpu_x(p, x, U, True)  # noqa : N806
+        self.assertEqual((M, 4, m), U.shape)
+
+        u = np.sqrt(U)
+        ua = u[:, 0, :]
+        self.assertAlmostEqual(0.013, ua[0, 0], delta=0.001)
+        self.assertAlmostEqual(0.016, ua[0, 1], delta=0.001)
+        self.assertAlmostEqual(0.024, ua[0, 2], delta=0.001)
+        self.assertAlmostEqual(0.046, ua[0, 3], delta=0.001)
+        self.assertAlmostEqual(0.006, ua[0, 4], delta=0.001)
+        self.assertAlmostEqual(1.569, ua[0, 5], delta=0.001)
+
+        self.assertAlmostEqual(0.479, ua[13, 0], delta=0.001)
+        self.assertAlmostEqual(0.359, ua[13, 1], delta=0.001)
+        self.assertAlmostEqual(0.235, ua[13, 2], delta=0.001)
+        self.assertAlmostEqual(0.210, ua[13, 3], delta=0.001)
+        self.assertAlmostEqual(0.178, ua[13, 4], delta=0.001)
+        self.assertAlmostEqual(0.083, ua[13, 5], delta=0.001)
+
 
 if __name__ == "__main__":
     unittest.main()