obsarray 0.2.5__tar.gz → 0.2.7__tar.gz

{obsarray-0.2.5 → obsarray-0.2.7}/.gitignore

@@ -77,7 +77,7 @@ instance/
 
 # Sphinx documentation
 docs/_build/
-docs/content/generated/
+docs/content/user/generated/
 
 # PyBuilder
 target/

{obsarray-0.2.5/obsarray.egg-info → obsarray-0.2.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: obsarray
-Version: 0.2.5
+Version: 0.2.7
 Summary: Measurement data handling in Python
 Home-page: https://github.com/comet-toolkit/obsarray
 Author: CoMet Toolkit Team

{obsarray-0.2.5 → obsarray-0.2.7}/obsarray/__init__.py

@@ -8,6 +8,7 @@ from obsarray import unc_accessor, flag_accessor
 from obsarray.err_corr import err_corr_forms
 from obsarray.templater.template_util import create_ds
 from obsarray.templater.dstemplater import DSTemplater
+from obsarray.templater.dswriter import DSWriter
 
 __version__ = get_versions()["version"]
 del get_versions

{obsarray-0.2.5 → obsarray-0.2.7}/obsarray/_version.py

@@ -8,11 +8,11 @@ import json
 
 version_json = '''
 {
- "date": "2024-02-14T16:24:15+0000",
+ "date": "2024-04-02T11:59:05+0100",
  "dirty": false,
  "error": null,
- "full-revisionid": "a4c0efeceef26dd8201830bc88caab5689f25595",
- "version": "v0.2.5"
+ "full-revisionid": "4f32df4b9da131ab66376b319a8036975d891233",
+ "version": "v0.2.7"
 }
 '''  # END VERSION_JSON
 

obsarray-0.2.7/obsarray/err_corr.py

@@ -0,0 +1,298 @@
+"""err_corr_forms - module for the defintion of error-correlation parameterisation forms"""
+
+import abc
+from typing import Callable, Type, Union, List
+import numpy as np
+from comet_maths.linear_algebra.matrix_conversion import expand_errcorr_dims
+
+__author__ = "Sam Hunt <sam.hunt@npl.co.uk>"
+__all__ = ["err_corr_forms", "register_err_corr_form", "BaseErrCorrForm"]
+
+
+class ErrCorrForms:
+    """
+    Container for error-correlation parameterisation form definition objects
+    """
+
+    def __init__(self):
+        self._forms = {}
+
+    def __setitem__(self, form_name, form_cls):
+        if not issubclass(form_cls, BaseErrCorrForm):
+            raise TypeError(
+                "form must be subclass of " + str(BaseErrCorrForm.__class__)
+            )
+
+        self._forms[form_name] = form_cls
+
+    def __getitem__(self, name):
+        return self._forms[name]
+
+    def __delitem__(self, name):
+        del self._forms[name]
+
+    def keys(self):
+        return self._forms.keys()
+
+
+err_corr_forms = ErrCorrForms()
+
+
+# placeholder currently
+class BaseErrCorrForm(abc.ABC):
+    """
+    Base class for error-correlation parameterisation form defintions
+    """
+
+    is_random = False
+    is_systematic = False
+
+    def __init__(self, xarray_obj, unc_var_name, dims, params, units):
+        self._obj = xarray_obj
+        self._unc_var_name = unc_var_name
+        self.dims = dims if isinstance(dims, list) else [dims]
+        self.params = params if isinstance(params, list) else [params]
+        self.units = units
+
+    def __str__(self):
+        """Custom __str__"""
+
+        return self.form + " " + str(self.params)
+
+    def __repr__(self):
+        """Custom  __repr__"""
+        return str(self)
+
+    @property
+    @abc.abstractmethod
+    def form(self) -> str:
+        """Form name"""
+        pass
+
+    def get_varshape_errcorr(self):
+        """
+        return shape of uncertainty variable, including only dimensions which are included in the current error correlation form.
+
+        :return: shape of included dimensions
+        """
+        all_dims = self._obj[self._unc_var_name].dims
+        all_dims_sizes = self._obj.sizes
+
+        return tuple([all_dims_sizes[dim] for dim in all_dims if dim in self.dims])
+
+    def get_sliced_dim_sizes_uncvar(self, sli: tuple) -> dict:
+        """
+        Return dictionary with sizes of sliced dimensions of unc variable, including all dimensions.
+
+        :param sli: slice (tuple with slice for each dimension)
+        :return: dictionary with shape of included sliced dimensions
+        """
+        uncvar_dims = self._obj[self._unc_var_name][sli].dims
+        uncvar_shape = self._obj[self._unc_var_name][sli].shape
+        return {
+            uncvar_dims[idim]: uncvar_shape[idim] for idim in range(len(uncvar_dims))
+        }
+
+    def get_sliced_dim_sizes_errcorr(self, sli: tuple) -> dict:
+        """
+        Return dictionary with sizes of sliced dimensions of unc variable, including only dimensions which are
+        included in the current error correlation form.
+
+        :param sli: slice (tuple with slice for each dimension)
+        :return: dictionary with shape of included sliced dimensions
+        """
+        uncvar_sizes = self.get_sliced_dim_sizes_uncvar(sli)
+        sliced_dims = self.get_sliced_dims_errcorr(sli)
+
+        return {dim: uncvar_sizes[dim] for dim in sliced_dims}
+
+    def get_sliced_dims_errcorr(self, sli: tuple) -> list:
+        """
+        Return dimensions which are within the slice and included in the current error correlation form.
+
+        :param sli: slice (tuple with slice for each dimension)
+        :return: list with sliced dimensions
+        """
+        all_dims = self._obj[self._unc_var_name].dims
+        return [
+            all_dims[idim]
+            for idim in range(len(all_dims))
+            if (isinstance(sli[idim], slice) and all_dims[idim] in self.dims)
+        ]
+
+    def get_sliced_shape_errcorr(self, sli: tuple) -> tuple:
+        """
+        return shape of sliced uncertainty variable, including only dimensions which are included in the current error correlation form.
+
+        :param sli: slice (tuple with slice for each dimension)
+        :return: shape of included sliced dimensions
+        """
+        uncvar_sizes = self.get_sliced_dim_sizes_uncvar(sli)
+        sliced_dims = self.get_sliced_dims_errcorr(sli)
+
+        return tuple([uncvar_sizes[dim] for dim in sliced_dims])
+
+    def slice_errcorr_matrix(self, err_corr_matrix, variable_shape, sli) -> np.ndarray:
+        """
+        Slice the provided error correlation matrix (typically the error correlation matrix of the
+        BaseErrCorrForm) using the
+
+        :param err_corr_matrix: error correlation matrix to be sliced
+        :param variable_shape: tuple with the length of the dimensions in the error correlation matrix (in correct order for flattening)
+        :param sli: slice of observation variable to return error-correlation matrix for
+        :return: sliced error correlation matrix
+        """
+        mask_array = np.ones(variable_shape, dtype=bool)
+        mask_array[sli] = False
+
+        return np.delete(
+            np.delete(err_corr_matrix, mask_array.ravel(), 0), mask_array.ravel(), 1
+        )
+
+    @abc.abstractmethod
+    def build_matrix(self, sli: Union[np.ndarray, tuple]) -> np.ndarray:
+        """
+        Returns uncertainty effect error-correlation matrix, populated with error-correlation values defined
+        in this parameterisation
+
+        :param sli: slice of observation variable to return error-correlation matrix for
+
+        :return: populated error-correlation matrix
+        """
+        pass
+
+    def build_dot_matrix(self, sli: Union[np.ndarray, tuple]) -> np.ndarray:
+        """
+        Returns expanded error correlation matrix for use in dot product with error correlation
+        in other dimensions.
+
+        The (sliced) error correlation matrix for this BaseErrCorrForm is expanded from its current
+        (sliced) dimensions (which often don't include all dimensions of the associated uncertainty
+        variable) to the dimensions of the full (sliced) error correlation (i.e. all dimensions of
+        the uncertainty).
+        The returned matrix is not meaningfull unless combined in a dot product with the expanded
+        matrices of other error correlation matrices (together spanning all uncertainty dimensions).
+
+        :param sli: slice of observation variable to return error-correlation matrix for
+        :return: expanded matrix for use in dot product with error correlation in other dimensions.
+        """
+        return expand_errcorr_dims(
+            in_corr=self.build_matrix(sli),
+            in_dim=self.get_sliced_dims_errcorr(sli),
+            out_dim=list(self._obj[self._unc_var_name][sli].dims),
+            dim_sizes=self.get_sliced_dim_sizes_uncvar(sli),
+        )
+
+
+def register_err_corr_form(form_name: str) -> Callable:
+    """
+    Decorator for registering error-correlation parmaterisation form definition to package definition container
+
+    :param form_name: name of error-correlation parmaterisation form e.g. "random"
+    :return: decorator function
+    """
+
+    def decorator(form_cls: Type) -> Type:
+        err_corr_forms[form_name] = form_cls
+        return form_cls
+
+    return decorator
+
+
+@register_err_corr_form("random")
+class RandomCorrelation(BaseErrCorrForm):
+
+    form = "random"
+    is_random = True
+
+    def build_matrix(self, sli: tuple) -> np.ndarray:
+        """
+        Returns uncertainty effect error-correlation matrix, populated with error-correlation values defined
+        in this parameterisation
+
+        :param sli: slice of observation variable to return error-correlation matrix for
+
+        :return: populated error-correlation matrix
+        """
+
+        # evaluate correlation over matrices in form defintion
+        dim_lens = self.get_sliced_shape_errcorr(sli)
+        n_elems = int(np.prod(dim_lens))
+
+        submatrix = np.eye(n_elems)
+
+        return submatrix
+
+
+@register_err_corr_form("systematic")
+class SystematicCorrelation(BaseErrCorrForm):
+
+    form = "systematic"
+    is_systematic = True
+
+    def build_matrix(self, sli: tuple) -> np.ndarray:
+        """
+        Returns uncertainty effect error-correlation matrix, populated with error-correlation values defined
+        in this parameterisation
+
+        :param sli: slice of observation variable to return error-correlation matrix for
+
+        :return: populated error-correlation matrix
+        """
+
+        # evaluate correlation over matrices in form defintion
+        dim_lens = self.get_sliced_shape_errcorr(sli)
+        n_elems = int(np.prod(dim_lens))
+
+        submatrix = np.ones((n_elems, n_elems))
+
+        return submatrix
+
+
+@register_err_corr_form("err_corr_matrix")
+class ErrCorrMatrixCorrelation(BaseErrCorrForm):
+
+    form = "err_corr_matrix"
+
+    def build_matrix(self, sli: tuple) -> np.ndarray:
+        """
+        Returns uncertainty effect error-correlation matrix, populated with error-correlation values defined
+        in this parameterisation
+
+        :param sli: slice of observation variable to return error-correlation matrix for
+
+        :return: populated error-correlation matrix
+        """
+        all_dims = self._obj[self._unc_var_name].dims
+
+        sli_submatrix = tuple(
+            [sli[i] for i in range(len(all_dims)) if all_dims[i] in self.dims]
+        )
+
+        submatrix = self.slice_errcorr_matrix(
+            self._obj[self.params[0]], self.get_varshape_errcorr(), sli_submatrix
+        )
+
+        return submatrix
+
+
+@register_err_corr_form("ensemble")
+class EnsembleCorrelation(BaseErrCorrForm):
+
+    form = "ensemble"
+
+    def build_matrix(self, sli: tuple) -> np.ndarray:
+        """
+        Returns uncertainty effect error-correlation matrix, populated with error-correlation values defined
+        in this parameterisation
+
+        :param sli: slice of observation variable to return error-correlation matrix for
+
+        :return: populated error-correlation matrix
+        """
+
+        raise NotImplementedError
+
+
+if __name__ == "__main__":
+    pass

{obsarray-0.2.5 → obsarray-0.2.7}/obsarray/flag_accessor.py

@@ -194,12 +194,12 @@ class FlagVariable:
         )
 
         if flag_meaning not in flag_meanings:
-            self._obj[
-                self._flag_var_name
-            ].attrs = DatasetUtil.add_flag_meaning_to_attrs(
-                self._obj[self._flag_var_name].attrs,
-                flag_meaning,
-                self._obj[self._flag_var_name].dtype,
+            self._obj[self._flag_var_name].attrs = (
+                DatasetUtil.add_flag_meaning_to_attrs(
+                    self._obj[self._flag_var_name].attrs,
+                    flag_meaning,
+                    self._obj[self._flag_var_name].dtype,
+                )
             )
 
         self[flag_meaning][:] = flag_value

{obsarray-0.2.5 → obsarray-0.2.7}/obsarray/templater/dataset_util.py

@@ -259,8 +259,8 @@ class DatasetUtil:
             attributes=attributes,
         )
 
-        #initialise flags to zero (instead of fillvalue)
-        variable.values=0*variable.values
+        # initialise flags to zero (instead of fillvalue)
+        variable.values = 0 * variable.values
 
         # add flag attributes
         variable.attrs.update(DatasetUtil.pack_flag_attrs(meanings))
@@ -290,7 +290,7 @@ class DatasetUtil:
         )
 
         if flag_masks is None:
-            flag_masks = [2 ** i for i in range(0, n_masks)]
+            flag_masks = [2**i for i in range(0, n_masks)]
 
         flag_attrs["flag_masks"] = str(flag_masks)[1:-1]
 
@@ -333,7 +333,7 @@ class DatasetUtil:
 
         # check if variable for available flags
         max_n_flags = numpy.iinfo(dtype).bits
-        all_flag_masks = [2 ** i for i in range(0, max_n_flags)]
+        all_flag_masks = [2**i for i in range(0, max_n_flags)]
         available_flag_masks = list(set(all_flag_masks) - set(flag_masks))
 
         if not available_flag_masks:
@@ -434,6 +434,10 @@ class DatasetUtil:
 
         if fill_value is not None:
             encoding_dict.update({"_FillValue": fill_value})
+        else:
+            encoding_dict.update(
+                {"_FillValue": DatasetUtil.get_default_fill_value(dtype)}
+            )
 
         variable.encoding = encoding_dict
 
@@ -524,8 +528,8 @@ class DatasetUtil:
 
         flags_ds = DatasetUtil.unpack_flags(da)
 
-        flags = flags if flags is not None else flags_ds.variables
-        mask_flags = [flags_ds[flag].values for flag in flags]
+        flags = flags if flags is not None else flags_ds.data_vars
+        mask_flags = numpy.array([flags_ds[flag].values for flag in flags])
 
         return numpy.logical_or.reduce(mask_flags)
 
@@ -546,8 +550,8 @@ class DatasetUtil:
 
         flags_ds = DatasetUtil.unpack_flags(da)
 
-        flags = flags if flags is not None else flags_ds.variables
-        mask_flags = [flags_ds[flag].values for flag in flags]
+        flags = flags if flags is not None else flags_ds.data_vars
+        mask_flags = numpy.array([flags_ds[flag].values for flag in flags])
 
         return numpy.logical_and.reduce(mask_flags)
 

{obsarray-0.2.5 → obsarray-0.2.7}/obsarray/templater/dswriter.py

@@ -81,7 +81,8 @@ class DSWriter:
                         )
                     }
                 )
-                ds[var_name].attrs.pop("_FillValue")
+                if "_FillValue" in ds[var_name].attrs:
+                    ds[var_name].attrs.pop("_FillValue")
             encoding.update({var_name: var_encoding})
 
         ds.to_netcdf(path, format="netCDF4", engine="netcdf4", encoding=encoding)

{obsarray-0.2.5 → obsarray-0.2.7}/obsarray/templater/template_util.py

@@ -159,6 +159,7 @@ class TemplateUtil:
 
             if "encoding" in var_attrs:
                 du.add_encoding(variable, **var_attrs["encoding"])
+                variable.attrs.pop("_FillValue")
 
         return variable
 

obsarray-0.2.7/obsarray/test/test_err_corr_forms.py

@@ -0,0 +1,251 @@
+"""test_err_corr_forms - tests for obsarray.err_corr_forms"""
+
+import unittest
+import numpy as np
+from obsarray.err_corr import (
+    BaseErrCorrForm,
+    ErrCorrForms,
+    RandomCorrelation,
+    SystematicCorrelation,
+    ErrCorrMatrixCorrelation,
+)
+from obsarray.test.test_unc_accessor import create_ds
+
+__author__ = "Sam Hunt <sam.hunt@npl.co.uk>"
+__all__ = []
+
+
+class TestErrCorrForms(unittest.TestCase):
+    def setUp(self):
+        class ErrCorrFormDef(BaseErrCorrForm):
+            def form(self):
+                pass
+
+        self.ErrCorrFormDef = ErrCorrFormDef
+
+    def test___setitem__(self):
+        err_corr_forms = ErrCorrForms()
+        err_corr_forms["test"] = self.ErrCorrFormDef
+
+        self.assertCountEqual(list(err_corr_forms._forms.keys()), ["test"])
+
+    def test___setitem___not_valid_cls(self):
+        class InvalidErrCorrFormDef:
+            pass
+
+        err_corr_forms = ErrCorrForms()
+        self.assertRaises(
+            TypeError, err_corr_forms.__setitem__, "test", InvalidErrCorrFormDef
+        )
+
+    def test___getitem__(self):
+        err_corr_forms = ErrCorrForms()
+        err_corr_forms._forms["test"] = "test"
+        self.assertEqual("test", err_corr_forms["test"])
+
+    def test___delitem__(self):
+        err_corr_forms = ErrCorrForms()
+        err_corr_forms._forms["test"] = "test"
+
+        del err_corr_forms._forms["test"]
+
+        self.assertTrue("test" not in err_corr_forms._forms)
+
+    def test_keys(self):
+        err_corr_forms = ErrCorrForms()
+        err_corr_forms._forms["test"] = "test"
+
+        self.assertCountEqual(["test"], err_corr_forms.keys())
+
+
+class TestBaseErrCorrForm(unittest.TestCase):
+    def setUp(self) -> None:
+        self.ds = create_ds()
+
+        class BasicErrCorrForm(BaseErrCorrForm):
+            form = "basic"
+
+            def build_matrix(self, sli):
+                full_matrix = np.arange(144).reshape((12, 12))
+                return self.slice_errcorr_matrix(full_matrix, (2, 2, 3), sli)
+
+        self.BasicErrCorrForm = BasicErrCorrForm
+
+    def test_get_varshape_errcorr(self):
+        basicerrcorr = self.BasicErrCorrForm(
+            self.ds, "u_ran_temperature", ["x", "y", "time"], [], []
+        )
+        shape = basicerrcorr.get_varshape_errcorr()
+        np.testing.assert_equal(shape, (2, 2, 3))
+
+    def test_slice_full_cov_full(self):
+        basicerrcorr = self.BasicErrCorrForm(
+            self.ds, "u_ran_temperature", ["x"], [], []
+        )
+
+        full_matrix = np.arange(144).reshape((12, 12))
+        slice_matrix = basicerrcorr.build_matrix(
+            (slice(None), slice(None), slice(None))
+        )
+
+        np.testing.assert_equal(full_matrix, slice_matrix)
+
+    def test_get_sliced_dim_sizes_uncvar(self):
+        basicerrcorr = self.BasicErrCorrForm(
+            self.ds, "u_ran_temperature", ["x"], [], []
+        )
+        dim_sizes = basicerrcorr.get_sliced_dim_sizes_uncvar(
+            (slice(None), 0, slice(0, 2, 1))
+        )
+        assert dim_sizes == {"x": 2, "time": 2}
+
+    def test_get_sliced_dim_sizes_errcorr(self):
+        basicerrcorr = self.BasicErrCorrForm(
+            self.ds, "u_ran_temperature", ["x"], [], []
+        )
+        dim_sizes = basicerrcorr.get_sliced_dim_sizes_errcorr(
+            (slice(None), 0, slice(0, 2, 1))
+        )
+        assert dim_sizes == {"x": 2}
+
+    def test_get_sliced_dims_errcorr(self):
+        basicerrcorr = self.BasicErrCorrForm(
+            self.ds, "u_ran_temperature", ["x"], [], []
+        )
+        dims = basicerrcorr.get_sliced_dims_errcorr((slice(None), 0, slice(0, 2, 1)))
+        assert dims == ["x"]
+
+    def test_get_sliced_shape_errcorr(self):
+        basicerrcorr = self.BasicErrCorrForm(
+            self.ds, "u_ran_temperature", ["x"], [], []
+        )
+        shape = basicerrcorr.get_sliced_shape_errcorr((slice(None), 0, slice(0, 2, 1)))
+        assert shape == (2,)
+        basicerrcorr = self.BasicErrCorrForm(
+            self.ds, "u_ran_temperature", ["x", "time"], [], []
+        )
+        shape = basicerrcorr.get_sliced_shape_errcorr((slice(None), 0, slice(0, 2, 1)))
+        assert shape == (2, 2)
+
+    def test_slice_errcorr_matrix(self):
+        basicerrcorr = self.BasicErrCorrForm(
+            self.ds, "u_ran_temperature", ["x", "y", "z"], [], []
+        )
+
+        full_matrix = np.arange(144).reshape((12, 12))
+        slice_matrix = basicerrcorr.slice_errcorr_matrix(
+            full_matrix, (2, 2, 3), (slice(None), slice(None), 0)
+        )
+
+        exp_slice_matrix = np.array(
+            [[0, 3, 6, 9], [36, 39, 42, 45], [72, 75, 78, 81], [108, 111, 114, 117]]
+        )
+
+        np.testing.assert_equal(slice_matrix, exp_slice_matrix)
+
+    def test_slice_full_cov_slice(self):
+        basicerrcorr = self.BasicErrCorrForm(
+            self.ds, "u_ran_temperature", ["x", "y", "z"], [], []
+        )
+
+        slice_matrix = basicerrcorr.build_dot_matrix((slice(None), slice(None), 0))
+
+        exp_slice_matrix = np.array(
+            [[0, 3, 6, 9], [36, 39, 42, 45], [72, 75, 78, 81], [108, 111, 114, 117]]
+        )
+
+        np.testing.assert_equal(slice_matrix, exp_slice_matrix)
+
+
+class TestRandomUnc(unittest.TestCase):
+    def setUp(self) -> None:
+        self.ds = create_ds()
+
+    def test_build_matrix_1stdim(self):
+        rc = RandomCorrelation(self.ds, "u_ran_temperature", ["x"], [], [])
+
+        ecrm = rc.build_dot_matrix((slice(None), slice(None), slice(None)))
+
+        np.testing.assert_equal(ecrm, np.eye(12))
+
+    def test_build_matrix_2nddim(self):
+        rc = RandomCorrelation(self.ds, "u_ran_temperature", ["y"], [], [])
+
+        ecrm = rc.build_dot_matrix((slice(None), slice(None), slice(None)))
+
+        np.testing.assert_equal(ecrm, np.eye(12))
+
+
+class TestSystematicUnc(unittest.TestCase):
+    def setUp(self) -> None:
+        self.ds = create_ds()
+
+    def build_matrix_1stdim(self):
+        rc = SystematicCorrelation(self.ds, "u_sys_temperature", ["x"], [], [])
+
+        ecrm = rc.build_dot_matrix((slice(None), slice(None), slice(None)))
+        # np.testing.assert_equal(ecrm, np.ones((12, 12)))
+
+        return ecrm
+
+    def build_matrix_2nddim(self):
+        rc = SystematicCorrelation(self.ds, "u_sys_temperature", ["y"], [], [])
+
+        ecrm = rc.build_dot_matrix((slice(None), slice(None), slice(None)))
+        # np.testing.assert_equal(ecrm, np.ones((12, 12)))
+
+        return ecrm
+
+    def build_matrix_3ddim(self):
+        rc = SystematicCorrelation(self.ds, "u_sys_temperature", ["time"], [], [])
+
+        ecrm = rc.build_dot_matrix((slice(None), slice(None), slice(None)))
+        # np.testing.assert_equal(ecrm, np.ones((12, 12)))
+
+        return ecrm
+
+    def test_build_dot_matrix(self):
+        x = self.build_matrix_1stdim()
+        y = self.build_matrix_2nddim()
+        time = self.build_matrix_3ddim()
+        print(x.dot(y), x, y)
+        np.testing.assert_equal((x.dot(y)).dot(time), np.ones((12, 12)))
+
+
+class TestErrCorrMatrixCorrelation(unittest.TestCase):
+    def setUp(self) -> None:
+        self.ds = create_ds()
+
+    def test_build_matrix_full(self):
+        ec = ErrCorrMatrixCorrelation(
+            self.ds,
+            "u_str_temperature",
+            ["x", "time"],
+            ["err_corr_str_temperature"],
+            [],
+        )
+
+        ecrm = ec.build_matrix((slice(None), slice(None), slice(None)))
+        np.testing.assert_equal(ecrm, np.ones((6, 6)))
+
+    def test_build_matrix_sliced(self):
+        ec = ErrCorrMatrixCorrelation(
+            self.ds,
+            "u_str_temperature",
+            ["x", "time"],
+            ["err_corr_str_temperature"],
+            [],
+        )
+
+        ecrm = ec.build_matrix((0, slice(None), slice(None)))
+        np.testing.assert_equal(ecrm, np.ones((3, 3)))
+
+        ecrm = ec.build_matrix((slice(None), 0, slice(None)))
+        np.testing.assert_equal(ecrm, np.ones((6, 6)))
+
+        ecrm = ec.build_matrix((slice(None), slice(None), 0))
+        np.testing.assert_equal(ecrm, np.ones((2, 2)))
+
+
+if __name__ == "main":
+    unittest.main()