cloudnetpy 1.49.9__py3-none-any.whl → 1.87.3__py3-none-any.whl

cloudnetpy/model_evaluation/tests/unit/test_grid_methods.py

@@ -39,16 +39,16 @@ PRODUCT = "iwc"
         ("lwc", ("lwc_ecmwf", "lwc_ecmwf", "lwc_adv_ecmwf")),
     ],
 )
-def test_generate_regrid_product(model_file, obs_file, product, variables):
+def test_generate_regrid_product(model_file, obs_file, product, variables) -> None:
     obs = ObservationManager(product, str(obs_file))
     model = ModelManager(str(model_file), MODEL, OUTPUT_FILE, product)
     ProductGrid(model, obs)
     for var in variables:
-        assert var in model.data.keys()
+        assert var in model.data
 
 
 @pytest.mark.parametrize("key, value", [("iwc", 3), ("lwc", 1), ("cf", 2)])
-def test_get_method_storage(key, value, model_file, obs_file):
+def test_get_method_storage(key, value, model_file, obs_file) -> None:
     obs = ObservationManager(key, str(obs_file))
     model = ModelManager(str(model_file), MODEL, OUTPUT_FILE, key)
     obj = ProductGrid(model, obs)
@@ -57,7 +57,7 @@ def test_get_method_storage(key, value, model_file, obs_file):
 
 
 @pytest.mark.parametrize("key, value", [("iwc", 3), ("lwc", 1), ("cf", 2)])
-def test_get_method_storage_adv(key, value, model_file, obs_file):
+def test_get_method_storage_adv(key, value, model_file, obs_file) -> None:
     obs = ObservationManager(key, str(obs_file))
     model = ModelManager(str(model_file), MODEL, OUTPUT_FILE, key)
     obj = ProductGrid(model, obs)
@@ -66,34 +66,34 @@ def test_get_method_storage_adv(key, value, model_file, obs_file):
 
 
 @pytest.mark.parametrize("name", ["cf_V", "cf_A"])
-def test_cf_method_storage(name, model_file, obs_file):
+def test_cf_method_storage(name, model_file, obs_file) -> None:
     obs = ObservationManager(PRODUCT, str(obs_file))
     model = ModelManager(str(model_file), MODEL, OUTPUT_FILE, PRODUCT)
     obj = ProductGrid(model, obs)
     x, y = obj._cf_method_storage()
-    assert name in x.keys()
+    assert name in x
 
 
 @pytest.mark.parametrize("name", ["cf_V_adv", "cf_A_adv"])
-def test_cf_method_storage_adv(name, model_file, obs_file):
+def test_cf_method_storage_adv(name, model_file, obs_file) -> None:
     obs = ObservationManager(PRODUCT, str(obs_file))
     model = ModelManager(str(model_file), MODEL, OUTPUT_FILE, PRODUCT)
     obj = ProductGrid(model, obs)
     x, y = obj._cf_method_storage()
-    assert name in y.keys()
+    assert name in y
 
 
 @pytest.mark.parametrize("name", ["iwc", "iwc_att", "iwc_rain"])
-def test_iwc_method_storage(name, model_file, obs_file):
+def test_iwc_method_storage(name, model_file, obs_file) -> None:
     obs = ObservationManager(PRODUCT, str(obs_file))
     model = ModelManager(str(model_file), MODEL, OUTPUT_FILE, PRODUCT)
     obj = ProductGrid(model, obs)
     x, y = obj._iwc_method_storage()
-    assert name in x.keys()
+    assert name in x
 
 
 @pytest.mark.parametrize("name", ["iwc_adv", "iwc_att_adv", "iwc_rain_adv"])
-def test_iwc_method_storage_adv(name, model_file, obs_file):
+def test_iwc_method_storage_adv(name, model_file, obs_file) -> None:
     obs = ObservationManager(PRODUCT, str(obs_file))
     model = ModelManager(str(model_file), MODEL, OUTPUT_FILE, PRODUCT)
     obj = ProductGrid(model, obs)
@@ -101,7 +101,7 @@ def test_iwc_method_storage_adv(name, model_file, obs_file):
     assert name in y
 
 
-def test_product_method_storage(model_file, obs_file):
+def test_product_method_storage(model_file, obs_file) -> None:
     obs = ObservationManager("lwc", str(obs_file))
     model = ModelManager(str(model_file), MODEL, OUTPUT_FILE, "lwc")
     obj = ProductGrid(model, obs)
@@ -109,7 +109,7 @@ def test_product_method_storage(model_file, obs_file):
     assert "lwc" in x
 
 
-def test_product_method_storage_adv(model_file, obs_file):
+def test_product_method_storage_adv(model_file, obs_file) -> None:
     obs = ObservationManager("lwc", str(obs_file))
     model = ModelManager(str(model_file), MODEL, OUTPUT_FILE, "lwc")
     obj = ProductGrid(model, obs)
@@ -117,146 +117,139 @@ def test_product_method_storage_adv(model_file, obs_file):
     assert "lwc_adv" in y
 
 
-def test_regrid_cf_area(model_file, obs_file):
+def test_regrid_cf_area(model_file, obs_file) -> None:
     obs = ObservationManager(PRODUCT, str(obs_file))
     model = ModelManager(str(model_file), MODEL, OUTPUT_FILE, PRODUCT)
     obj = ProductGrid(model, obs)
     data = ma.array([[1, 1, 1], [0, 1, 1], [0, 0, 1], [0, 0, 0]])
-    d = {"cf_A": np.zeros((1, 1))}
+    d = {"cf_A": ma.zeros((1, 1))}
     d = obj._regrid_cf(d, 0, 0, data)
     x = d["cf_A"]
     assert x[0, 0] == 0.75
 
 
-# def test_regrid_cf_none(model_file, obs_file):
-#     obs = ObservationManager(PRODUCT, str(obs_file))
-#     model = ModelManager(str(model_file), MODEL, OUTPUT_FILE, PRODUCT)
-#     obj = ProductGrid(model, obs)
-#     data = np.array([])
-#     d = {"cf_A": np.zeros((1, 1))}
-#     d = obj._regrid_cf(d, 0, 0, data)
-#     x = d["cf_A"]
-#     assert np.isnan(x[0, 0])
-
-
-def test_regrid_cf_area_masked(model_file, obs_file):
+def test_regrid_cf_area_masked(model_file, obs_file) -> None:
     obs = ObservationManager(PRODUCT, str(obs_file))
     model = ModelManager(str(model_file), MODEL, OUTPUT_FILE, PRODUCT)
     obj = ProductGrid(model, obs)
     data = ma.array([[1, 1, 1], [0, 1, 1], [0, 0, 1], [0, 0, 0]])
     data[1, :] = ma.masked
-    d = {"cf_A": np.zeros((1, 1))}
+    d = {"cf_A": ma.zeros((1, 1))}
     d = obj._regrid_cf(d, 0, 0, data)
     x = d["cf_A"]
     assert round(x[0, 0], 3) == 0.667
 
 
-def test_regrid_cf_area_all_masked(model_file, obs_file):
+def test_regrid_cf_area_all_masked(model_file, obs_file) -> None:
     obs = ObservationManager(PRODUCT, str(obs_file))
     model = ModelManager(str(model_file), MODEL, OUTPUT_FILE, PRODUCT)
     obj = ProductGrid(model, obs)
     data = ma.array([[1, 1, 1], [0, 1, 1], [0, 0, 1], [0, 0, 0]])
     data[:, :] = ma.masked
-    d = {"cf_A": np.zeros((1, 1))}
+    d = {"cf_A": ma.zeros((1, 1))}
     d = obj._regrid_cf(d, 0, 0, data)
     x = d["cf_A"]
-    testing.assert_equal(x, np.nan)
+    testing.assert_equal(x, ma.masked)
 
 
-def test_regrid_cf_area_nan(model_file, obs_file):
+def test_regrid_cf_area_nan(model_file, obs_file) -> None:
     obs = ObservationManager(PRODUCT, str(obs_file))
     model = ModelManager(str(model_file), MODEL, OUTPUT_FILE, PRODUCT)
     obj = ProductGrid(model, obs)
-    data = ma.array([[1, np.nan, 1], [0, 1, 1], [np.nan, 0, 1], [0, 0, 0]])
-    d = {"cf_A": np.zeros((1, 1))}
+    data = ma.array([[1, 99, 1], [0, 1, 1], [99, 0, 1], [0, 0, 0]])
+    data = ma.masked_where(data == 99, data)
+    d = {"cf_A": ma.zeros((1, 1))}
     d = obj._regrid_cf(d, 0, 0, data)
     x = d["cf_A"]
     assert x[0, 0] == 0.75
 
 
-def test_regrid_cf_area_all_nan(model_file, obs_file):
+def test_regrid_cf_area_all_nan(model_file, obs_file) -> None:
     obs = ObservationManager(PRODUCT, str(obs_file))
     model = ModelManager(str(model_file), MODEL, OUTPUT_FILE, PRODUCT)
     obj = ProductGrid(model, obs)
     data = ma.array(
         [
-            [np.nan, np.nan, np.nan],
-            [np.nan, np.nan, np.nan],
-            [np.nan, np.nan, np.nan],
-            [np.nan, np.nan, np.nan],
-        ]
+            [1, 1, 1],
+            [1, 1, 1],
+            [1, 1, 1],
+            [1, 1, 1],
+        ],
+        mask=True,
     )
-    d = {"cf_A": np.zeros((1, 1))}
+    d = {"cf_A": ma.zeros((1, 1))}
     d = obj._regrid_cf(d, 0, 0, data)
     x = d["cf_A"]
-    testing.assert_equal(x, 0.0)
+    testing.assert_equal(x, ma.masked)
 
 
-def test_regrid_cf_volume(model_file, obs_file):
+def test_regrid_cf_volume(model_file, obs_file) -> None:
     obs = ObservationManager(PRODUCT, str(obs_file))
     model = ModelManager(str(model_file), MODEL, OUTPUT_FILE, PRODUCT)
     obj = ProductGrid(model, obs)
     data = ma.array([[1, 1, 1], [0, 1, 1], [0, 0, 1], [0, 0, 0]])
-    d = {"cf_V": np.zeros((1, 1))}
+    d = {"cf_V": ma.zeros((1, 1))}
     d = obj._regrid_cf(d, 0, 0, data)
     x = d["cf_V"]
     assert x[0, 0] == 0.5
 
 
-def test_regrid_cf_volume_nan(model_file, obs_file):
+def test_regrid_cf_volume_nan(model_file, obs_file) -> None:
     obs = ObservationManager(PRODUCT, str(obs_file))
     model = ModelManager(str(model_file), MODEL, OUTPUT_FILE, PRODUCT)
     obj = ProductGrid(model, obs)
-    data = ma.array([[1, np.nan, 1], [0, 1, 1], [np.nan, 0, 1], [0, 0, 0]])
-    d = {"cf_V": np.zeros((1, 1))}
+    data = ma.array([[1, 99, 1], [0, 1, 1], [99, 0, 1], [0, 0, 0]])
+    data = ma.masked_where(data == 99, data)
+    d = {"cf_V": ma.zeros((1, 1))}
     d = obj._regrid_cf(d, 0, 0, data)
     x = d["cf_V"]
     assert x[0, 0] == 0.5
 
 
-def test_regrid_cf_volume_all_nan(model_file, obs_file):
+def test_regrid_cf_volume_all_nan(model_file, obs_file) -> None:
     obs = ObservationManager(PRODUCT, str(obs_file))
     model = ModelManager(str(model_file), MODEL, OUTPUT_FILE, PRODUCT)
     obj = ProductGrid(model, obs)
     data = ma.array(
         [
-            [np.nan, np.nan, np.nan],
-            [np.nan, np.nan, np.nan],
-            [np.nan, np.nan, np.nan],
-            [np.nan, np.nan, np.nan],
-        ]
+            [99, 99, 99],
+            [99, 99, 99],
+            [99, 99, 99],
+            [99, 99, 99],
+        ],
     )
-    d = {"cf_V": np.zeros((1, 1))}
+    data = ma.masked_where(data == 99, data)
+    d = {"cf_V": ma.zeros((1, 1))}
     d = obj._regrid_cf(d, 0, 0, data)
     x = d["cf_V"]
-    testing.assert_equal(x, np.nan)
+    testing.assert_equal(x, ma.masked)
 
 
-def test_regrid_cf_volume_masked(model_file, obs_file):
+def test_regrid_cf_volume_masked(model_file, obs_file) -> None:
     obs = ObservationManager(PRODUCT, str(obs_file))
     model = ModelManager(str(model_file), MODEL, OUTPUT_FILE, PRODUCT)
     obj = ProductGrid(model, obs)
     data = ma.array([[1, 1, 1], [0, 1, 1], [0, 0, 1], [0, 0, 0]])
     data[1, :] = ma.masked
-    d = {"cf_V": np.zeros((1, 1))}
+    d = {"cf_V": ma.zeros((1, 1))}
     d = obj._regrid_cf(d, 0, 0, data)
     x = d["cf_V"]
     assert round(x[0, 0], 3) == 0.444
 
 
-def test_regrid_cf_volume_all_masked(model_file, obs_file):
+def test_regrid_cf_volume_all_masked(model_file, obs_file) -> None:
     obs = ObservationManager(PRODUCT, str(obs_file))
     model = ModelManager(str(model_file), MODEL, OUTPUT_FILE, PRODUCT)
     obj = ProductGrid(model, obs)
     data = ma.array([[1, 1, 1], [0, 1, 1], [0, 0, 1], [0, 0, 0]])
     data[:, :] = ma.masked
-    d = {"cf_V": np.zeros((1, 1))}
+    d = {"cf_V": ma.zeros((1, 1))}
     d = obj._regrid_cf(d, 0, 0, data)
     x = d["cf_V"]
-    testing.assert_equal(x, np.nan)
+    testing.assert_equal(x, ma.masked)
 
 
-def test_reshape_data_to_window(model_file, obs_file):
+def test_reshape_data_to_window(model_file, obs_file) -> None:
     obs = ObservationManager(PRODUCT, str(obs_file))
     model = ModelManager(str(model_file), MODEL, OUTPUT_FILE, PRODUCT)
     obj = ProductGrid(model, obs)
@@ -281,7 +274,7 @@ def test_reshape_data_to_window(model_file, obs_file):
             [5, 6, 7, 8],
             [55, 66, 77, 88],
             [555, 666, 777, 888],
-        ]
+        ],
     )
     x = obj._reshape_data_to_window(ind, xnd, ynd)
     compare = np.array([[1, 2], [11, 22], [111, 222]])
@@ -289,7 +282,7 @@ def test_reshape_data_to_window(model_file, obs_file):
     testing.assert_array_almost_equal(x, compare)
 
 
-def test_reshape_data_to_window_middle(model_file, obs_file):
+def test_reshape_data_to_window_middle(model_file, obs_file) -> None:
     obs = ObservationManager(PRODUCT, str(obs_file))
     model = ModelManager(str(model_file), MODEL, OUTPUT_FILE, PRODUCT)
     obj = ProductGrid(model, obs)
@@ -314,7 +307,7 @@ def test_reshape_data_to_window_middle(model_file, obs_file):
             [5, 6, 7, 8],
             [55, 66, 77, 88],
             [555, 666, 777, 888],
-        ]
+        ],
     )
     x = obj._reshape_data_to_window(ind, xnd, ynd)
     compare = np.array([[222, 333], [6, 7], [66, 77]])
@@ -322,7 +315,7 @@ def test_reshape_data_to_window_middle(model_file, obs_file):
     testing.assert_array_almost_equal(x, compare)
 
 
-def test_reshape_data_to_window_empty(model_file, obs_file):
+def test_reshape_data_to_window_empty(model_file, obs_file) -> None:
     obs = ObservationManager(PRODUCT, str(obs_file))
     model = ModelManager(str(model_file), MODEL, OUTPUT_FILE, PRODUCT)
     obj = ProductGrid(model, obs)
@@ -334,7 +327,7 @@ def test_reshape_data_to_window_empty(model_file, obs_file):
             0,
             0,
             0,
-        ]
+        ],
     )
     ynd = np.array([0, 0, 0, 0])
     ind = np.array([1, 1, 0, 0], dtype=bool)
@@ -342,114 +335,120 @@ def test_reshape_data_to_window_empty(model_file, obs_file):
     assert x is None
 
 
-def test_regrid_iwc(model_file, obs_file):
+def test_regrid_iwc(model_file, obs_file) -> None:
     obs = ObservationManager(PRODUCT, str(obs_file))
     model = ModelManager(str(model_file), MODEL, OUTPUT_FILE, PRODUCT)
     obj = ProductGrid(model, obs)
     obj._obs_data = ma.array([[1, 1, 1, 1], [2, 2, 2, 2], [3, 3, 3, 3], [4, 4, 4, 3]])
-    d = {"iwc": np.zeros((1, 1))}
-    ind = ma.array([[0, 1, 1, 1]], dtype=bool)
-    no_rain = ma.array(
-        [[0, 1, 1, 1], [0, 0, 1, 1], [0, 0, 0, 0], [0, 0, 0, 0]], dtype=bool
+    d = {"iwc": ma.zeros((1, 1))}
+    ind: ma.MaskedArray = ma.array([[0, 1, 1, 1]], dtype=bool)
+    no_rain: ma.MaskedArray = ma.array(
+        [[0, 1, 1, 1], [0, 0, 1, 1], [0, 0, 0, 0], [0, 0, 0, 0]],
+        dtype=bool,
     )
     d = obj._regrid_iwc(d, 0, 0, ind, no_rain)
     x = d["iwc"]
     testing.assert_almost_equal(x[0, 0], 1.4)
 
 
-def test_regrid_iwc_nan(model_file, obs_file):
+def test_regrid_iwc_nan(model_file, obs_file) -> None:
     obs = ObservationManager(PRODUCT, str(obs_file))
     model = ModelManager(str(model_file), MODEL, OUTPUT_FILE, PRODUCT)
     obj = ProductGrid(model, obs)
     obj._obs_data = ma.array(
-        [[1, 1, np.nan, 1], [2, np.nan, 2, 2], [3, 3, 3, 3], [4, 4, 4, np.nan]]
+        [[1, 1, 99, 1], [2, 99, 2, 2], [3, 3, 3, 3], [4, 4, 4, 99]],
     )
-    d = {"iwc": np.zeros((1, 1))}
-    ind = ma.array([[0, 1, 1, 1]], dtype=bool)
-    no_rain = ma.array(
-        [[0, 1, 1, 1], [0, 0, 1, 1], [0, 0, 0, 0], [0, 0, 0, 0]], dtype=bool
+    obj._obs_data = ma.masked_where(obj._obs_data == 99, obj._obs_data)
+    d = {"iwc": ma.zeros((1, 1))}
+    ind: ma.MaskedArray = ma.array([[0, 1, 1, 1]], dtype=bool)
+    no_rain: ma.MaskedArray = ma.array(
+        [[0, 1, 1, 1], [0, 0, 1, 1], [0, 0, 0, 0], [0, 0, 0, 0]],
+        dtype=bool,
     )
     d = obj._regrid_iwc(d, 0, 0, ind, no_rain)
     x = d["iwc"]
     testing.assert_almost_equal(x[0, 0], 1.5)
 
 
-def test_regrid_iwc_all_nan(model_file, obs_file):
+def test_regrid_iwc_all_nan(model_file, obs_file) -> None:
     obs = ObservationManager(PRODUCT, str(obs_file))
     model = ModelManager(str(model_file), MODEL, OUTPUT_FILE, PRODUCT)
     obj = ProductGrid(model, obs)
     obj._obs_data = ma.array(
         [
-            [np.nan, np.nan, np.nan, np.nan],
-            [np.nan, np.nan, np.nan, np.nan],
-            [np.nan, np.nan, np.nan, np.nan],
-            [np.nan, np.nan, np.nan, np.nan],
-        ]
-    )
-    d = {"iwc": np.zeros((1, 1))}
-    ind = ma.array([[0, 1, 1, 1]], dtype=bool)
-    no_rain = ma.array(
-        [[0, 1, 1, 1], [0, 0, 1, 1], [0, 0, 0, 0], [0, 0, 0, 0]], dtype=bool
+            [99, 99, 99, 99],
+            [99, 99, 99, 99],
+            [99, 99, 99, 99],
+            [99, 99, 99, 99],
+        ],
+    )
+    obj._obs_data = ma.masked_where(obj._obs_data == 99, obj._obs_data)
+    d = {"iwc": ma.zeros((1, 1))}
+    ind: ma.MaskedArray = ma.array([[0, 1, 1, 1]], dtype=bool)
+    no_rain: ma.MaskedArray = ma.array(
+        [[0, 1, 1, 1], [0, 0, 1, 1], [0, 0, 0, 0], [0, 0, 0, 0]],
+        dtype=bool,
     )
     d = obj._regrid_iwc(d, 0, 0, ind, no_rain)
-    x = d["iwc"]
-    testing.assert_almost_equal(x[0, 0], np.nan)
+    assert d["iwc"][0, 0].mask == True
 
 
-def test_regrid_iwc_masked(model_file, obs_file):
+def test_regrid_iwc_masked(model_file, obs_file) -> None:
     obs = ObservationManager(PRODUCT, str(obs_file))
     model = ModelManager(str(model_file), MODEL, OUTPUT_FILE, PRODUCT)
     obj = ProductGrid(model, obs)
     obj._obs_data = ma.array([[1, 1, 1, 1], [2, 2, 2, 2], [3, 3, 3, 3], [4, 4, 4, 4]])
     obj._obs_data[1, :] = ma.masked
-    d = {"iwc": np.zeros((1, 1))}
-    ind = ma.array([[0, 1, 1, 1]], dtype=bool)
-    no_rain = ma.array(
-        [[0, 1, 1, 1], [0, 0, 1, 1], [0, 0, 0, 0], [0, 0, 0, 0]], dtype=bool
+    d = {"iwc": ma.zeros((1, 1))}
+    ind: ma.MaskedArray = ma.array([[0, 1, 1, 1]], dtype=bool)
+    no_rain: ma.MaskedArray = ma.array(
+        [[0, 1, 1, 1], [0, 0, 1, 1], [0, 0, 0, 0], [0, 0, 0, 0]],
+        dtype=bool,
     )
     d = obj._regrid_iwc(d, 0, 0, ind, no_rain)
     x = d["iwc"]
     testing.assert_almost_equal(x[0, 0], 1.0)
 
 
-def test_regrid_iwc_all_masked(model_file, obs_file):
+def test_regrid_iwc_all_masked(model_file, obs_file) -> None:
     obs = ObservationManager(PRODUCT, str(obs_file))
     model = ModelManager(str(model_file), MODEL, OUTPUT_FILE, PRODUCT)
     obj = ProductGrid(model, obs)
-    obj._obs_data = ma.array([[1, 1, 1, 1], [2, 2, 2, 2], [3, 3, 3, 3], [4, 4, 4, 4]])
-    obj._obs_data[:, :] = ma.masked
-    d = {"iwc": np.zeros((1, 1))}
-    ind = ma.array([[0, 1, 1, 1]], dtype=bool)
-    no_rain = ma.array(
-        [[0, 1, 1, 1], [0, 0, 1, 1], [0, 0, 0, 0], [0, 0, 0, 0]], dtype=bool
+    obj._obs_data = ma.array(
+        [[1, 1, 1, 1], [2, 2, 2, 2], [3, 3, 3, 3], [4, 4, 4, 4]], mask=True
+    )
+    d = {"iwc": ma.zeros((1, 1))}
+    ind: ma.MaskedArray = ma.array([[0, 1, 1, 1]], dtype=bool)
+    no_rain: ma.MaskedArray = ma.array(
+        [[0, 1, 1, 1], [0, 0, 1, 1], [0, 0, 0, 0], [0, 0, 0, 0]],
+        dtype=bool,
     )
     d = obj._regrid_iwc(d, 0, 0, ind, no_rain)
-    x = d["iwc"]
-    testing.assert_almost_equal(x[0, 0], np.nan)
+    assert d["iwc"][0, 0].mask == True
 
 
-def test_regrid_iwc_none(model_file, obs_file):
+def test_regrid_iwc_none(model_file, obs_file) -> None:
     obs = ObservationManager(PRODUCT, str(obs_file))
     model = ModelManager(str(model_file), MODEL, OUTPUT_FILE, PRODUCT)
     obj = ProductGrid(model, obs)
     obj._obs_data = ma.array([[1, 1, 1, 1], [2, 2, 2, 2], [3, 3, 3, 3], [4, 4, 4, 4]])
-    d = {"iwc": np.zeros((1, 1))}
-    ind = ma.array([[0, 1, 1, 1]], dtype=bool)
-    no_rain = ma.array(
-        [[0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0]], dtype=bool
+    d = {"iwc": ma.zeros((1, 1))}
+    ind: ma.MaskedArray = ma.array([[0, 1, 1, 1]], dtype=bool)
+    no_rain: ma.MaskedArray = ma.array(
+        [[0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0]],
+        dtype=bool,
     )
     d = obj._regrid_iwc(d, 0, 0, ind, no_rain)
-    x = d["iwc"]
-    testing.assert_equal(x[0, 0], np.nan)
+    assert d["iwc"][0, 0].mask == True
 
 
-def test_regrid_iwc_att(model_file, obs_file):
+def test_regrid_iwc_att(model_file, obs_file) -> None:
     obs = ObservationManager(PRODUCT, str(obs_file))
     model = ModelManager(str(model_file), MODEL, OUTPUT_FILE, PRODUCT)
     obj = ProductGrid(model, obs)
-    d = {"iwc_att": np.zeros((1, 1))}
-    ind = ma.array([[0, 1, 1, 1]], dtype=bool)
-    no_rain = ma.array(
+    d = {"iwc_att": ma.zeros((1, 1))}
+    ind: ma.MaskedArray = ma.array([[0, 1, 1, 1]], dtype=bool)
+    no_rain: ma.MaskedArray = ma.array(
         [
             [0, 1, 1, 1],
             [0, 0, 1, 1],
@@ -465,7 +464,7 @@ def test_regrid_iwc_att(model_file, obs_file):
     testing.assert_almost_equal(x[0, 0], 0.018)
 
 
-def test_regrid_iwc_att_masked(model_file, obs_file):
+def test_regrid_iwc_att_masked(model_file, obs_file) -> None:
     obs = ObservationManager(PRODUCT, str(obs_file))
     model = ModelManager(str(model_file), MODEL, OUTPUT_FILE, PRODUCT)
     obj = ProductGrid(model, obs)
@@ -480,9 +479,9 @@ def test_regrid_iwc_att_masked(model_file, obs_file):
         ],
         dtype=bool,
     )
-    d = {"iwc_att": np.zeros((1, 1))}
-    ind = ma.array([[0, 1, 1, 1]], dtype=bool)
-    no_rain = ma.array(
+    d = {"iwc_att": ma.zeros((1, 1))}
+    ind: ma.MaskedArray = ma.array([[0, 1, 1, 1]], dtype=bool)
+    no_rain: ma.MaskedArray = ma.array(
         [
             [0, 1, 1, 1],
             [0, 0, 1, 1],
@@ -498,7 +497,7 @@ def test_regrid_iwc_att_masked(model_file, obs_file):
     testing.assert_almost_equal(x[0, 0], 0.018)
 
 
-def test_regrid_iwc_att_all_masked(model_file, obs_file):
+def test_regrid_iwc_att_all_masked(model_file, obs_file) -> None:
     obs = ObservationManager(PRODUCT, str(obs_file))
     model = ModelManager(str(model_file), MODEL, OUTPUT_FILE, PRODUCT)
     obj = ProductGrid(model, obs)
@@ -513,9 +512,9 @@ def test_regrid_iwc_att_all_masked(model_file, obs_file):
         ],
         dtype=bool,
     )
-    d = {"iwc_att": np.zeros((1, 1))}
-    ind = ma.array([[0, 1, 1, 1]], dtype=bool)
-    no_rain = ma.array(
+    d = {"iwc_att": ma.zeros((1, 1))}
+    ind: ma.MaskedArray = ma.array([[0, 1, 1, 1]], dtype=bool)
+    no_rain: ma.MaskedArray = ma.array(
         [
             [0, 1, 1, 1],
             [0, 0, 1, 1],
@@ -528,16 +527,17 @@ def test_regrid_iwc_att_all_masked(model_file, obs_file):
     )
     d = obj._regrid_iwc(d, 0, 0, ind, no_rain)
     x = d["iwc_att"]
-    testing.assert_almost_equal(x[0, 0], np.nan)
+    # Simo: not sure if this should be masked or not
+    assert x[0, 0] == 0.01
 
 
-def test_regrid_iwc_att_none(model_file, obs_file):
+def test_regrid_iwc_att_none(model_file, obs_file) -> None:
     obs = ObservationManager(PRODUCT, str(obs_file))
     model = ModelManager(str(model_file), MODEL, OUTPUT_FILE, PRODUCT)
     obj = ProductGrid(model, obs)
-    d = {"iwc_att": np.zeros((1, 1))}
-    ind = ma.array([[0, 1, 1, 1]], dtype=bool)
-    no_rain = ma.array(
+    d = {"iwc_att": ma.zeros((1, 1))}
+    ind: ma.MaskedArray = ma.array([[0, 1, 1, 1]], dtype=bool)
+    no_rain: ma.MaskedArray = ma.array(
         [
             [0, 0, 0, 0],
             [0, 0, 0, 0],
@@ -550,190 +550,212 @@ def test_regrid_iwc_att_none(model_file, obs_file):
     )
     d = obj._regrid_iwc(d, 0, 0, ind, no_rain)
     x = d["iwc_att"]
-    assert np.isnan(x[0, 0])
+    assert x[0, 0].mask == True
 
 
-def test_regrid_iwc_rain(model_file, obs_file):
+def test_regrid_iwc_rain(model_file, obs_file) -> None:
     obs = ObservationManager(PRODUCT, str(obs_file))
     model = ModelManager(str(model_file), MODEL, OUTPUT_FILE, PRODUCT)
     obj = ProductGrid(model, obs)
     obj._obs_data = ma.array([[1, 1, 1, 1], [2, 2, 2, 2], [3, 3, 3, 3], [4, 4, 4, 3]])
-    d = {"iwc_rain": np.zeros((1, 1))}
-    ind = ma.array([[0, 1, 1, 1], [0, 0, 1, 1], [0, 1, 1, 1], [0, 0, 1, 1]], dtype=bool)
-    no_rain = ma.array(
+    d = {"iwc_rain": ma.zeros((1, 1))}
+    ind: ma.MaskedArray = ma.array(
         [[0, 1, 1, 1], [0, 0, 1, 1], [0, 1, 1, 1], [0, 0, 1, 1]], dtype=bool
     )
+    no_rain: ma.MaskedArray = ma.array(
+        [[0, 1, 1, 1], [0, 0, 1, 1], [0, 1, 1, 1], [0, 0, 1, 1]],
+        dtype=bool,
+    )
     d = obj._regrid_iwc(d, 0, 0, ind, no_rain)
     x = d["iwc_rain"]
     testing.assert_almost_equal(x[0, 0], 2.3)
 
 
-def test_regrid_iwc_rain_nan(model_file, obs_file):
+def test_regrid_iwc_rain_nan(model_file, obs_file) -> None:
     obs = ObservationManager(PRODUCT, str(obs_file))
     model = ModelManager(str(model_file), MODEL, OUTPUT_FILE, PRODUCT)
     obj = ProductGrid(model, obs)
     obj._obs_data = ma.array(
         [
-            [1, np.nan, 1, 1],
-            [2, 2, 2, np.nan],
+            [1, 99, 1, 1],
+            [2, 2, 2, 99],
             [3, 3, 3, 3],
-            [np.nan, 4, 4, np.nan],
-        ]
+            [99, 4, 4, 99],
+        ],
     )
-    d = {"iwc_rain": np.zeros((1, 1))}
-    ind = ma.array([[0, 1, 1, 1], [0, 0, 1, 1], [0, 1, 1, 1], [0, 0, 1, 1]], dtype=bool)
-    no_rain = ma.array(
+    obj._obs_data = ma.masked_where(obj._obs_data == 99, obj._obs_data)
+    d = {"iwc_rain": ma.zeros((1, 1))}
+    ind: ma.MaskedArray = ma.array(
         [[0, 1, 1, 1], [0, 0, 1, 1], [0, 1, 1, 1], [0, 0, 1, 1]], dtype=bool
     )
+    no_rain: ma.MaskedArray = ma.array(
+        [[0, 1, 1, 1], [0, 0, 1, 1], [0, 1, 1, 1], [0, 0, 1, 1]],
+        dtype=bool,
+    )
     d = obj._regrid_iwc(d, 0, 0, ind, no_rain)
     x = d["iwc_rain"]
     testing.assert_almost_equal(round(x[0, 0], 3), 2.429)
 
 
-def test_regrid_iwc_rain_all_nan(model_file, obs_file):
+def test_regrid_iwc_rain_all_nan(model_file, obs_file) -> None:
     obs = ObservationManager(PRODUCT, str(obs_file))
     model = ModelManager(str(model_file), MODEL, OUTPUT_FILE, PRODUCT)
     obj = ProductGrid(model, obs)
     obj._obs_data = ma.array(
         [
-            [np.nan, np.nan, np.nan, np.nan],
-            [np.nan, np.nan, np.nan, np.nan],
-            [np.nan, np.nan, np.nan, np.nan],
-            [np.nan, np.nan, np.nan, np.nan],
-        ]
-    )
-    d = {"iwc_rain": np.zeros((1, 1))}
-    ind = ma.array([[0, 1, 1, 1], [0, 0, 1, 1], [0, 1, 1, 1], [0, 0, 1, 1]], dtype=bool)
-    no_rain = ma.array(
+            [99, 99, 99, 99],
+            [99, 99, 99, 99],
+            [99, 99, 99, 99],
+            [99, 99, 99, 99],
+        ],
+    )
+    obj._obs_data = ma.masked_where(obj._obs_data == 99, obj._obs_data)
+    d = {"iwc_rain": ma.zeros((1, 1))}
+    ind: ma.MaskedArray = ma.array(
         [[0, 1, 1, 1], [0, 0, 1, 1], [0, 1, 1, 1], [0, 0, 1, 1]], dtype=bool
     )
+    no_rain: ma.MaskedArray = ma.array(
+        [[0, 1, 1, 1], [0, 0, 1, 1], [0, 1, 1, 1], [0, 0, 1, 1]],
+        dtype=bool,
+    )
     d = obj._regrid_iwc(d, 0, 0, ind, no_rain)
     x = d["iwc_rain"]
-    testing.assert_almost_equal(x[0, 0], np.nan)
+    assert x[0, 0].mask == True
 
 
-def test_regrid_iwc_rain_masked(model_file, obs_file):
+def test_regrid_iwc_rain_masked(model_file, obs_file) -> None:
     obs = ObservationManager(PRODUCT, str(obs_file))
     model = ModelManager(str(model_file), MODEL, OUTPUT_FILE, PRODUCT)
     obj = ProductGrid(model, obs)
     obj._obs_data = ma.array([[1, 1, 1, 1], [2, 2, 2, 2], [3, 3, 3, 3], [4, 4, 4, 4]])
     obj._obs_data[2, :] = ma.masked
-    d = {"iwc_rain": np.zeros((1, 1))}
-    ind = ma.array([[0, 1, 1, 1], [0, 0, 1, 1], [0, 1, 1, 1], [0, 0, 1, 1]], dtype=bool)
-    no_rain = ma.array(
+    d = {"iwc_rain": ma.zeros((1, 1))}
+    ind: ma.MaskedArray = ma.array(
         [[0, 1, 1, 1], [0, 0, 1, 1], [0, 1, 1, 1], [0, 0, 1, 1]], dtype=bool
     )
+    no_rain: ma.MaskedArray = ma.array(
+        [[0, 1, 1, 1], [0, 0, 1, 1], [0, 1, 1, 1], [0, 0, 1, 1]],
+        dtype=bool,
+    )
     d = obj._regrid_iwc(d, 0, 0, ind, no_rain)
     x = d["iwc_rain"]
     testing.assert_almost_equal(round(x[0, 0], 3), 2.143)
 
 
-def test_regrid_iwc_rain_all_masked(model_file, obs_file):
+def test_regrid_iwc_rain_all_masked(model_file, obs_file) -> None:
     obs = ObservationManager(PRODUCT, str(obs_file))
     model = ModelManager(str(model_file), MODEL, OUTPUT_FILE, PRODUCT)
     obj = ProductGrid(model, obs)
     obj._obs_data = ma.array([[1, 3, 1, 1], [2, 2, 2, 2], [3, 3, 3, 3], [4, 4, 4, 4]])
     obj._obs_data[:, :] = ma.masked
-    d = {"iwc_rain": np.zeros((1, 1))}
-    ind = ma.array([[0, 1, 1, 1], [0, 0, 1, 1], [0, 1, 1, 1], [0, 0, 1, 1]], dtype=bool)
-    no_rain = ma.array(
+    d = {"iwc_rain": ma.zeros((1, 1))}
+    ind: ma.MaskedArray = ma.array(
         [[0, 1, 1, 1], [0, 0, 1, 1], [0, 1, 1, 1], [0, 0, 1, 1]], dtype=bool
     )
+    no_rain: ma.MaskedArray = ma.array(
+        [[0, 1, 1, 1], [0, 0, 1, 1], [0, 1, 1, 1], [0, 0, 1, 1]],
+        dtype=bool,
+    )
     d = obj._regrid_iwc(d, 0, 0, ind, no_rain)
     x = d["iwc_rain"]
-    testing.assert_equal(x[0, 0], np.nan)
+    assert x[0, 0].mask == True
 
 
-def test_regrid_product(model_file, obs_file):
+def test_regrid_product(model_file, obs_file) -> None:
     obs = ObservationManager("lwc", str(obs_file))
     model = ModelManager(str(model_file), MODEL, OUTPUT_FILE, "lwc")
     obj = ProductGrid(model, obs)
     obj._obs_data = ma.array([[1, 1, 1, 1], [2, 1, 2, 2], [3, 3, 3, 3], [4, 4, 4, 4]])
-    d = {"lwc": np.zeros((1, 1))}
-    ind = ma.array([[0, 1, 1, 1], [0, 0, 1, 1], [0, 0, 0, 0], [0, 0, 0, 0]], dtype=bool)
+    d = {"lwc": ma.zeros((1, 1))}
+    ind: ma.MaskedArray = ma.array(
+        [[0, 1, 1, 1], [0, 0, 1, 1], [0, 0, 0, 0], [0, 0, 0, 0]], dtype=bool
+    )
     d = obj._regrid_product(d, 0, 0, ind)
     x = d["lwc"]
     testing.assert_almost_equal(x[0, 0], 1.4)
 
 
-def test_regrid_product_nan(model_file, obs_file):
+def test_regrid_product_nan(model_file, obs_file) -> None:
     obs = ObservationManager("lwc", str(obs_file))
     model = ModelManager(str(model_file), MODEL, OUTPUT_FILE, "lwc")
     obj = ProductGrid(model, obs)
     obj._obs_data = ma.array(
         [
-            [1, np.nan, 1, 1],
-            [np.nan, 1, 2, 2],
-            [3, 3, np.nan, 3],
-            [4, np.nan, 4, 4],
-        ]
-    )
-    d = {"lwc": np.zeros((1, 1))}
-    ind = ma.array([[0, 1, 1, 1], [0, 0, 1, 1], [0, 0, 0, 0], [0, 0, 0, 0]], dtype=bool)
+            [1, 99, 1, 1],
+            [99, 1, 2, 2],
+            [3, 3, 99, 3],
+            [4, 99, 4, 4],
+        ],
+    )
+    obj._obs_data = ma.masked_where(obj._obs_data == 99, obj._obs_data)
+    d = {"lwc": ma.zeros((1, 1))}
+    ind: ma.MaskedArray = ma.array(
+        [[0, 1, 1, 1], [0, 0, 1, 1], [0, 0, 0, 0], [0, 0, 0, 0]], dtype=bool
+    )
     d = obj._regrid_product(d, 0, 0, ind)
     x = d["lwc"]
     testing.assert_almost_equal(x[0, 0], 1.5)
 
 
-def test_regrid_product_all_nan(model_file, obs_file):
+def test_regrid_product_all_nan(model_file, obs_file) -> None:
     obs = ObservationManager("lwc", str(obs_file))
     model = ModelManager(str(model_file), MODEL, OUTPUT_FILE, "lwc")
     obj = ProductGrid(model, obs)
-    obj._obs_data = ma.array(
+    data = ma.array(
         [
-            [np.nan, np.nan, np.nan, np.nan],
-            [np.nan, np.nan, np.nan, np.nan],
-            [np.nan, np.nan, np.nan, np.nan],
-            [np.nan, np.nan, np.nan, np.nan],
-        ]
+            [99, 99, 99, 99],
+            [99, 99, 99, 99],
+            [99, 99, 99, 99],
+            [99, 99, 99, 99],
+        ],
     )
-    d = {"lwc": np.zeros((1, 1))}
+    obj._obs_data = ma.masked_where(data == 99, data)
+    d = {"lwc": ma.zeros((1, 1))}
     ind = np.array([[0, 1, 1, 1], [0, 0, 1, 1], [0, 0, 0, 0], [0, 0, 0, 0]], dtype=bool)
     d = obj._regrid_product(d, 0, 0, ind)
-    x = d["lwc"]
-    testing.assert_almost_equal(x[0, 0], np.nan)
+    assert d["lwc"][0, 0].mask == True
 
 
-def test_regrid_product_masked(model_file, obs_file):
+def test_regrid_product_masked(model_file, obs_file) -> None:
     obs = ObservationManager("lwc", str(obs_file))
     model = ModelManager(str(model_file), MODEL, OUTPUT_FILE, "lwc")
     obj = ProductGrid(model, obs)
     obj._obs_data = ma.array([[1, 1, 1, 1], [2, 1, 2, 2], [3, 3, 3, 3], [4, 4, 4, 4]])
     obj._obs_data[2, :] = ma.masked
-    d = {"lwc": np.zeros((1, 1))}
+    d = {"lwc": ma.zeros((1, 1))}
     ind = np.array([[0, 1, 1, 1], [0, 0, 1, 1], [0, 0, 0, 0], [0, 0, 0, 0]], dtype=bool)
     d = obj._regrid_product(d, 0, 0, ind)
     x = d["lwc"]
     testing.assert_almost_equal(x[0, 0], 1.4)
 
 
-def test_regrid_product_all_masked(model_file, obs_file):
+def test_regrid_product_all_masked(model_file, obs_file) -> None:
     obs = ObservationManager("lwc", str(obs_file))
     model = ModelManager(str(model_file), MODEL, OUTPUT_FILE, "lwc")
     obj = ProductGrid(model, obs)
     obj._obs_data = ma.array([[1, 1, 1, 1], [2, 1, 2, 2], [3, 3, 3, 3], [4, 4, 4, 4]])
     obj._obs_data[:, :] = ma.masked
-    d = {"lwc": np.zeros((1, 1))}
+    d = {"lwc": ma.zeros((1, 1))}
     ind = np.array([[0, 1, 1, 1], [0, 0, 1, 1], [0, 0, 0, 0], [0, 0, 0, 0]], dtype=bool)
     d = obj._regrid_product(d, 0, 0, ind)
     x = d["lwc"]
-    testing.assert_almost_equal(x, np.nan)
+    testing.assert_almost_equal(x, ma.masked)
 
 
-def test_regrid_product_none(model_file, obs_file):
+def test_regrid_product_none(model_file, obs_file) -> None:
     obs = ObservationManager("lwc", str(obs_file))
     model = ModelManager(str(model_file), MODEL, OUTPUT_FILE, "lwc")
     obj = ProductGrid(model, obs)
     obj._obs_data = ma.array([[1, 1, 1, 1], [2, 1, 2, 2], [3, 3, 3, 3], [4, 4, 4, 4]])
-    d = {"lwc": np.zeros((1, 1))}
+    d = {"lwc": ma.zeros((1, 1))}
     ind = np.array([[0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0]], dtype=bool)
     d = obj._regrid_product(d, 0, 0, ind)
     x = d["lwc"]
-    testing.assert_almost_equal(x[0, 0], np.nan)
+    assert x[0, 0].mask == True
 
 
 @pytest.mark.parametrize("product", ["cf_A", "cf_V", "cf_A_adv", "cf_V_adv"])
-def test_append_data2object_cf(product, model_file, obs_file):
+def test_append_data2object_cf(product, model_file, obs_file) -> None:
     obs = ObservationManager("cf", str(obs_file))
     model = ModelManager(str(model_file), MODEL, OUTPUT_FILE, "cf")
     ProductGrid(model, obs)
@@ -744,7 +766,7 @@ def test_append_data2object_cf(product, model_file, obs_file):
     "product",
     ["iwc", "iwc_att", "iwc_rain", "iwc_adv", "iwc_att_adv", "iwc_rain_adv"],
 )
-def test_append_data2object_iwc(product, model_file, obs_file):
+def test_append_data2object_iwc(product, model_file, obs_file) -> None:
     obs = ObservationManager("iwc", str(obs_file))
     model = ModelManager(str(model_file), MODEL, OUTPUT_FILE, "iwc")
     ProductGrid(model, obs)
@@ -752,7 +774,7 @@ def test_append_data2object_iwc(product, model_file, obs_file):
 
 
 @pytest.mark.parametrize("product", ["lwc", "lwc_adv"])
-def test_append_data2object_lwc(product, model_file, obs_file):
+def test_append_data2object_lwc(product, model_file, obs_file) -> None:
     obs = ObservationManager("lwc", str(obs_file))
     model = ModelManager(str(model_file), MODEL, OUTPUT_FILE, "lwc")
     ProductGrid(model, obs)