dapper 1.5.0__tar.gz → 1.6.0__tar.gz

dapper-1.6.0/PKG-INFO

@@ -0,0 +1,83 @@
+Metadata-Version: 2.1
+Name: dapper
+Version: 1.6.0
+Summary: DAPPER benchmarks the performance of data assimilation (DA) methods.
+Author: Patrick N. Raanes
+Author-email: patrick.n.raanes@gmail.com
+Project-URL: Documentation, https://nansencenter.github.io/DAPPER/
+Project-URL: Source, https://github.com/nansencenter/DAPPER
+Project-URL: Tracker, https://github.com/nansencenter/DAPPER/issues
+Keywords: data-assimilation enkf kalman-filtering state-estimation particle-filter kalman bayesian-methods bayesian-filter chaos
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Science/Research
+Classifier: Topic :: Scientific/Engineering :: Mathematics
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENCE.txt
+Requires-Dist: scipy>=1.10
+Requires-Dist: jupyter
+Requires-Dist: ipdb
+Requires-Dist: ipython>=5.1
+Requires-Dist: tornado~=6.3.2
+Requires-Dist: matplotlib~=3.7
+Requires-Dist: mpl-tools==0.2.50
+Requires-Dist: tqdm~=4.31
+Requires-Dist: pyyaml
+Requires-Dist: colorama~=0.4.1
+Requires-Dist: tabulate~=0.8.3
+Requires-Dist: dill==0.3.2
+Requires-Dist: patlib==0.3.5
+Requires-Dist: struct-tools==0.2.5
+Requires-Dist: multiprocessing-on-dill==3.5.0a4
+Requires-Dist: threadpoolctl<4.0.0,>=3.0.0
+Provides-Extra: qt
+Requires-Dist: PyQt5; extra == "qt"
+Requires-Dist: qtpy; extra == "qt"
+Provides-Extra: debug
+Requires-Dist: line_profiler; extra == "debug"
+Requires-Dist: pre-commit; extra == "debug"
+Requires-Dist: pdbpp>=0.10.3; extra == "debug"
+Provides-Extra: test
+Requires-Dist: tox; extra == "test"
+Requires-Dist: coverage>=5.1; extra == "test"
+Requires-Dist: pytest; extra == "test"
+Requires-Dist: pytest-cov; extra == "test"
+Requires-Dist: pytest-sugar; extra == "test"
+Requires-Dist: pytest-benchmark; extra == "test"
+Requires-Dist: pytest-clarity; extra == "test"
+Requires-Dist: pytest-xdist; extra == "test"
+Requires-Dist: pytest-timeout; extra == "test"
+Provides-Extra: lint
+Requires-Dist: flake8<5; extra == "lint"
+Requires-Dist: flakeheaven; extra == "lint"
+Requires-Dist: autopep8; extra == "lint"
+Provides-Extra: build
+Requires-Dist: twine; extra == "build"
+Requires-Dist: pdoc; extra == "build"
+Requires-Dist: jupytext; extra == "build"
+Provides-Extra: dev
+Requires-Dist: line_profiler; extra == "dev"
+Requires-Dist: pre-commit; extra == "dev"
+Requires-Dist: pdbpp>=0.10.3; extra == "dev"
+Requires-Dist: tox; extra == "dev"
+Requires-Dist: coverage>=5.1; extra == "dev"
+Requires-Dist: pytest; extra == "dev"
+Requires-Dist: pytest-cov; extra == "dev"
+Requires-Dist: pytest-sugar; extra == "dev"
+Requires-Dist: pytest-benchmark; extra == "dev"
+Requires-Dist: pytest-clarity; extra == "dev"
+Requires-Dist: pytest-xdist; extra == "dev"
+Requires-Dist: pytest-timeout; extra == "dev"
+Requires-Dist: flake8<5; extra == "dev"
+Requires-Dist: flakeheaven; extra == "dev"
+Requires-Dist: autopep8; extra == "dev"
+Requires-Dist: twine; extra == "dev"
+Requires-Dist: pdoc; extra == "dev"
+Requires-Dist: jupytext; extra == "dev"
+
+It is usually best to install from source (github),
+so that you the code is readily available to play with.
+See full README on [github](https://github.com/nansencenter/DAPPER).

{dapper-1.5.0 → dapper-1.6.0}/README.md

@@ -10,10 +10,8 @@
 
 <img src="/docs/imgs/logo_wtxt.png" align="left" width="250"/>
 
-DAPPER is a set of templates for **benchmarking** the performance of
-**data assimilation** (DA) methods.
-The tests provide experimental support and guidance for
-new developments in DA.
+DAPPER is a set of templates for **benchmarking** the performance of **data assimilation** (DA) methods.
+The numerical experiments provide support and guidance for new developments in DA.
 The typical set-up is a **synthetic (twin) experiment**, where you
 specify a dynamic model and an observational model,
 and use these to generate a synthetic truth (multivariate time series),
@@ -38,8 +36,8 @@ The [documentation](https://nansencenter.github.io/DAPPER)
 includes general guidelines and the API,
 but for any serious use you will want to read and adapt the code yourself.
 If you use it in a publication, please cite, e.g.,
-*The experiments used (inspiration from) DAPPER [ref], version 1.2.1*,
-where [ref] points to [![DOI](https://zenodo.org/badge/DOI/10.5281/zenodo.2029296.svg)](https://doi.org/10.5281/zenodo.2029296).
+*The experiments used (inspiration from) DAPPER [ref], version 1.6.0*,
+where [ref] points to [![DOI](https://zenodo.org/badge/DOI/10.5281/zenodo.10710355.svg)](https://doi.org/10.5281/zenodo.10710355).
 Lastly, for an introduction to DA theory also using Python,
 see these [tutorials](https://github.com/nansencenter/DA-tutorials).
 
@@ -128,7 +126,7 @@ Ensure the printed version is 3.9 or more.
 - If the script comes with a `requirements.txt` file, then do  
   `pip install -r path/to/requirements.txt`.
 - If not, hopefully you know the version of DAPPER needed. Run  
-  `pip install dapper==1.0.0` to get version `1.2.3` (as an example).
+  `pip install dapper==1.5.1` to get version `1.5.1` (as an example).
 
 #### *Finally*: Test the installation
 
@@ -233,9 +231,7 @@ DAPPER is aimed at research and teaching (see discussion up top).
 Example of limitations:
 
 - It is not suited for very big models (>60k unknowns).
-- Time-dependent error covariances and changes in lengths of state/obs
-  (although the `Dyn` and `Obs` models may otherwise be time-dependent).
-- Non-uniform time sequences not fully supported.
+- Non-uniform time sequences.
 
 The scope of DAPPER is restricted because
 
@@ -321,7 +317,24 @@ in the development of DAPPER.
 [26]: https://github.com/CliMA/EnsembleKalmanProcesses.jl
 
 
-## Contributors
+## Contributing
+
+### Issues and Pull requests
+
+Do not hesitate to open an issue, whether to report a problem or ask a question.
+It may take some time for us to get back to you,
+since DAPPER is primarily a volunteer effort.
+Please start by perusing the [documentation](https://nansencenter.github.io/DAPPER/dapper.html)
+and searching the issue tracker for similar items.
+
+Pull requests are very welcome.
+Examples: adding a new DA method, dynamical models,
+experimental configuration reproducing literature results,
+or improving the features and capabilities of DAPPER.
+Please keep in mind the intentional [limitations](https://github.com/nansencenter/DAPPER#similar-projects)
+and read the [developers guidelines](https://nansencenter.github.io/DAPPER/dev_guide).
+
+### Contributors
 
 Patrick N. Raanes,
 Yumeng Chen,
@@ -345,7 +358,7 @@ and the Center for Western Weather and Water Extremes (CW3E).
 <img src="./docs/imgs/CW3E-Logo-Horizontal-FullColor.png?raw=true" width="400">
 <!-- markdownlint-restore -->
 
-## Publication list
+## Publications
 
 - [Combining data assimilation and machine learning to emulate a dynamical model from sparse and noisy observations: A case study with the Lorenz 96 model](https://doi.org/10.1016/j.jocs.2020.101171)
 - [Adaptive covariance inflation in the ensemble Kalman filter by Gaussian scale mixtures](https://doi.org/10.1002/qj.3386)

{dapper-1.5.0 → dapper-1.6.0}/dapper/README.md

@@ -5,11 +5,11 @@ the docs for the various modules.
 
 ## Installation
 
-See [README/Installation](https://github.com/nansencenter/DAPPER#Installation)
+See [README/Installation](https://github.com/nansencenter/DAPPER#installation)
 
 ## Usage
 
-See [README/Getting-started](https://github.com/nansencenter/DAPPER#Getting-started)
+See [README/Getting-started](https://github.com/nansencenter/DAPPER#getting-started)
 
 ##### Examples
 
@@ -26,8 +26,8 @@ your own **model** or **method**, then
   rather than trying to squeeze everything into its templates.
 - If it is relatively simple, however, you may well want to use DAPPER.
   In that case, read this:
-    - `mods`
-    - `da_methods`
+    - `dapper.mods`
+    - `dapper.da_methods`
 
 Since the generality of DAPPER is
 [limited](https://github.com/nansencenter/DAPPER#similar-projects)

{dapper-1.5.0 → dapper-1.6.0}/dapper/__init__.py

@@ -4,12 +4,12 @@
 .. include:: ./README.md
 """
 
-__version__ = "1.5.0"
+__version__ = "1.6.0"
 
 # A parsimonious list of imports used in the examples
 from .dpr_config import rc
 from .tools.datafiles import find_latest_run, load_xps
 from .tools.rounding import round2sigfig
-from .tools.seeding import set_seed
+from .tools.seeding import rng, set_seed
 from .xp_launch import combinator, seed_and_simulate, xpList
 from .xp_process import xpSpace

{dapper-1.5.0 → dapper-1.6.0}/dapper/da_methods/README.md

@@ -1,5 +1,6 @@
-See the README section on
+Also see the section on
 [DA Methods](https://github.com/nansencenter/DAPPER#DA-Methods)
+in the main README
 for an overview of the methods included with DAPPER.
 
 ## Defining your own method

{dapper-1.5.0 → dapper-1.6.0}/dapper/da_methods/baseline.py

@@ -68,9 +68,9 @@ class OptInterp:
                 self.stats.assess(k, ko, 'f', mu=muC, Cov=PC)
 
                 # Analysis
-                H  = HMM.Obs.linear(muC, t)
-                KG  = mrdiv(PC@H.T, H@PC@H.T + HMM.Obs.noise.C.full)
-                mu = muC + KG@(yy[ko] - HMM.Obs(muC, t))
+                H  = HMM.Obs(ko).linear(muC)
+                KG  = mrdiv(PC@H.T, H@PC@H.T + HMM.Obs(ko).noise.C.full)
+                mu = muC + KG@(yy[ko] - HMM.Obs(ko)(muC))
 
                 P  = (Id - KG@H) @ PC
                 SM = fit_sigmoid(P.trace()/PC.trace(), L, k)
@@ -123,9 +123,9 @@ class Var3D:
                 self.stats.assess(k, ko, 'f', mu=mu, Cov=P)
 
                 # Analysis
-                H  = HMM.Obs.linear(mu, t)
-                KG = mrdiv(B@H.T, H@B@H.T + HMM.Obs.noise.C.full)
-                mu = mu + KG@(yy[ko] - HMM.Obs(mu, t))
+                H  = HMM.Obs(ko).linear(mu)
+                KG = mrdiv(B@H.T, H@B@H.T + HMM.Obs(ko).noise.C.full)
+                mu = mu + KG@(yy[ko] - HMM.Obs(ko)(mu))
 
                 # Re-calibrate fit_sigmoid with new W0 = Pa/B
                 P = (Id - KG@H) @ B

{dapper-1.5.0 → dapper-1.6.0}/dapper/da_methods/ensemble.py

@@ -1,7 +1,6 @@
 """The EnKF and other ensemble-based methods."""
 
 import numpy as np
-import numpy.random as rnd
 import scipy.linalg as sla
 from numpy import diag, eye, sqrt, zeros
 
@@ -11,6 +10,7 @@ from dapper.tools.linalg import mldiv, mrdiv, pad0, svd0, svdi, tinv, tsvd
 from dapper.tools.matrices import funm_psd, genOG_1
 from dapper.tools.progressbar import progbar
 from dapper.tools.randvars import GaussRV
+from dapper.tools.seeding import rng
 
 from . import da_method
 
@@ -47,7 +47,7 @@ class EnKF:
             # Analysis update
             if ko is not None:
                 self.stats.assess(k, ko, 'f', E=E)
-                E = EnKF_analysis(E, HMM.Obs(E, t), HMM.Obs.noise, yy[ko],
+                E = EnKF_analysis(E, HMM.Obs(ko)(E), HMM.Obs(ko).noise, yy[ko],
                                   self.upd_a, self.stats, ko)
                 E = post_process(E, self.infl, self.rot)
 
@@ -161,10 +161,10 @@ def EnKF_analysis(E, Eo, hnoise, y, upd_a, stats=None, ko=None):
                         v     = v - mult[0]*Yj # noqa
                         v    /= sqrt(v@v)
                     Zj  = v*sqrt(N1)  # Standardized perturbation along v
-                    Zj *= np.sign(rnd.rand()-0.5)  # Random sign
+                    Zj *= np.sign(rng.standard_normal() - 0.5)  # Random sign
                 else:
                     # The usual stochastic perturbations.
-                    Zj = mean0(rnd.randn(N))  # Un-coloured noise
+                    Zj = mean0(rng.standard_normal(N))  # Un-coloured noise
                     if 'Var1' in upd_a:
                         Zj *= sqrt(N/(Zj@Zj))
 
@@ -319,7 +319,7 @@ def add_noise(E, dt, noise, method):
         E, _, Qa12 = sqrt_core()
         if N <= Nx:
             Z  = Q12 - A.T@Qa12
-            E += sqrt(dt)*(Z@rnd.randn(Z.shape[1], N)).T
+            E += sqrt(dt)*(Z@rng.standard_normal((Z.shape[1], N))).T
 
     elif method == 'Sqrt-Dep':
         E, T, Qa12 = sqrt_core()
@@ -334,7 +334,7 @@ def add_noise(E, dt, noise, method):
             Z      = Q12 - Q_hat12
             D_hat  = A.T@(T-eye(N))
             Xi_hat = Q_hat12_inv @ D_hat
-            Xi_til = (eye(rQ) - Q_hat12_proj)@rnd.randn(rQ, N)
+            Xi_til = (eye(rQ) - Q_hat12_proj)@rng.standard_normal((rQ, N))
             D_til  = Z@(Xi_hat + sqrt(dt)*Xi_til)
             E     += D_til.T
 
@@ -382,7 +382,7 @@ class EnKS:
             if ko is not None:
                 self.stats.assess(k, ko, 'f', E=E[k])
 
-                Eo    = HMM.Obs(E[k], t)
+                Eo    = HMM.Obs(ko)(E[k])
                 y     = yy[ko]
 
                 # Inds within Lag
@@ -391,7 +391,7 @@ class EnKS:
                 EE    = E[kk]
 
                 EE    = self.reshape_to(EE)
-                EE    = EnKF_analysis(EE, Eo, HMM.Obs.noise, y,
+                EE    = EnKF_analysis(EE, Eo, HMM.Obs(ko).noise, y,
                                       self.upd_a, self.stats, ko)
                 E[kk] = self.reshape_fr(EE, HMM.Dyn.M)
                 E[k]  = post_process(E[k], self.infl, self.rot)
@@ -427,9 +427,9 @@ class EnRTS:
 
             if ko is not None:
                 self.stats.assess(k, ko, 'f', E=E[k])
-                Eo   = HMM.Obs(E[k], t)
+                Eo   = HMM.Obs(ko)(E[k])
                 y    = yy[ko]
-                E[k] = EnKF_analysis(E[k], Eo, HMM.Obs.noise, y,
+                E[k] = EnKF_analysis(E[k], Eo, HMM.Obs(ko).noise, y,
                                      self.upd_a, self.stats, ko)
                 E[k] = post_process(E[k], self.infl, self.rot)
                 self.stats.assess(k, ko, 'a', E=E[k])
@@ -468,7 +468,7 @@ def serial_inds(upd_a, y, cvR, A):
             dC = np.sum(A*A, 0)/(N-1)
         inds = np.argsort(dC)
     else:  # Default: random ordering
-        inds = rnd.permutation(len(y))
+        inds = rng.permutation(len(y))
     return inds
 
 
@@ -492,8 +492,6 @@ class SL_EAKF:
 
     def assimilate(self, HMM, xx, yy):
         N1   = self.N-1
-        R    = HMM.Obs.noise
-        Rm12 = HMM.Obs.noise.C.sym_sqrt_inv
 
         E = HMM.X0.sample(self.N)
         self.stats.assess(0, E=E)
@@ -504,14 +502,17 @@ class SL_EAKF:
 
             if ko is not None:
                 self.stats.assess(k, ko, 'f', E=E)
+                Obs  = HMM.Obs(ko)
+                R    = Obs.noise
                 y    = yy[ko]
                 inds = serial_inds(self.ordr, y, R, center(E)[0])
+                Rm12 = Obs.noise.C.sym_sqrt_inv
 
-                state_taperer = HMM.Obs.localizer(self.loc_rad, 'y2x', t, self.taper)
+                state_taperer = Obs.localizer(self.loc_rad, 'y2x', self.taper)
                 for j in inds:
                     # Prep:
                     # ------------------------------------------------------
-                    Eo = HMM.Obs(E, t)
+                    Eo = Obs(E)
                     xo = np.mean(Eo, 0)
                     Y  = Eo - xo
                     mu = np.mean(E, 0)
@@ -632,8 +633,9 @@ class LETKF:
 
                 if ko is not None:
                     self.stats.assess(k, ko, 'f', E=E)
-                    batch, taper = HMM.Obs.localizer(self.loc_rad, 'x2y', t, self.taper)
-                    E, stats = local_analyses(E, HMM.Obs(E, t), HMM.Obs.noise.C, yy[ko],
+                    Obs = HMM.Obs(ko)
+                    batch, taper = Obs.localizer(self.loc_rad, 'x2y', self.taper)
+                    E, stats = local_analyses(E, Obs(E), Obs.noise.C, yy[ko],
                                               batch, taper, pool.map, self.xN, self.g)
                     self.stats.write(stats, k, ko, "a")
                     E = post_process(E, self.infl, self.rot)
@@ -851,7 +853,7 @@ class EnKF_N:
     g: int     = 0
 
     def assimilate(self, HMM, xx, yy):
-        R, N, N1 = HMM.Obs.noise.C, self.N, self.N-1
+        N, N1 = self.N, self.N-1
 
         # Init
         E = HMM.X0.sample(N)
@@ -866,7 +868,7 @@ class EnKF_N:
             # Analysis
             if ko is not None:
                 self.stats.assess(k, ko, 'f', E=E)
-                Eo = HMM.Obs(E, t)
+                Eo = HMM.Obs(ko)(E)
                 y  = yy[ko]
 
                 mu = np.mean(E, 0)
@@ -876,6 +878,7 @@ class EnKF_N:
                 Y  = Eo-xo
                 dy = y - xo
 
+                R = HMM.Obs(ko).noise.C
                 V, s, UT = svd0(Y @ R.sym_sqrt_inv.T)
                 du       = UT @ (dy @ R.sym_sqrt_inv.T)
                 def dgn_N(l1): return pad0((l1*s)**2, N) + N1
@@ -887,7 +890,7 @@ class EnKF_N:
 
                 if self.dual:
                     # Make dual cost function (in terms of l1)
-                    def pad_rk(arr): return pad0(arr, min(N, HMM.Obs.M))
+                    def pad_rk(arr): return pad0(arr, min(N, len(y)))
                     def dgn_rk(l1): return pad_rk((l1*s)**2) + N1
 
                     def J(l1):
@@ -962,6 +965,6 @@ class EnKF_N:
                 E = post_process(E, self.infl, self.rot)
 
                 self.stats.infl[ko] = l1
-                self.stats.trHK[ko] = (((l1*s)**2 + N1)**(-1.0)*s**2).sum()/HMM.Ny
+                self.stats.trHK[ko] = (((l1*s)**2 + N1)**(-1.0)*s**2).sum()/len(y)
 
             self.stats.assess(k, ko, E=E)

{dapper-1.5.0 → dapper-1.6.0}/dapper/da_methods/extended.py

@@ -25,7 +25,6 @@ class ExtKF:
     infl: float = 1.0
 
     def assimilate(self, HMM, xx, yy):
-        R  = HMM.Obs.noise.C.full
         Q  = 0 if HMM.Dyn.noise.C == 0 else HMM.Dyn.noise.C.full
 
         mu = HMM.X0.mu
@@ -44,10 +43,11 @@ class ExtKF:
 
             if ko is not None:
                 self.stats.assess(k, ko, 'f', mu=mu, Cov=P)
-                H  = HMM.Obs.linear(mu, t)
-                KG = mrdiv(P @ H.T, H@P@H.T + R)
+                Obs = HMM.Obs(ko)
+                H  = Obs.linear(mu)
+                KG = mrdiv(P @ H.T, H@P@H.T + Obs.noise.C.full)
                 y  = yy[ko]
-                mu = mu + KG@(y - HMM.Obs(mu, t))
+                mu = mu + KG@(y - Obs(mu))
                 KH = KG@H
                 P  = (np.eye(HMM.Dyn.M) - KH) @ P
 
@@ -67,7 +67,6 @@ class ExtRTS:
     def assimilate(self, HMM, xx, yy):
         Nx = HMM.Dyn.M
 
-        R  = HMM.Obs.noise.C.full
         Q  = 0 if HMM.Dyn.noise.C == 0 else HMM.Dyn.noise.C.full
 
         mu    = np.zeros((HMM.tseq.K+1, Nx))
@@ -96,10 +95,11 @@ class ExtRTS:
 
             if ko is not None:
                 self.stats.assess(k, ko, 'f', mu=mu[k], Cov=P[k])
-                H     = HMM.Obs.linear(mu[k], t)
-                KG    = mrdiv(P[k] @ H.T, H@P[k]@H.T + R)
+                Obs   = HMM.Obs(ko)
+                H     = Obs.linear(mu[k])
+                KG    = mrdiv(P[k] @ H.T, H@P[k]@H.T + Obs.noise.C.full)
                 y     = yy[ko]
-                mu[k] = mu[k] + KG@(y - HMM.Obs(mu[k], t))
+                mu[k] = mu[k] + KG@(y - Obs(mu[k]))
                 KH    = KG@H
                 P[k]  = (np.eye(Nx) - KH) @ P[k]
                 self.stats.assess(k, ko, 'a', mu=mu[k], Cov=P[k])

{dapper-1.5.0 → dapper-1.6.0}/dapper/da_methods/other.py

@@ -31,9 +31,6 @@ class RHF:
         step     = 1/N
         cdf_grid = np.linspace(step/2, 1-step/2, N)
 
-        R    = Obs.noise
-        Rm12 = Obs.noise.C.sym_sqrt_inv
-
         E = X0.sample(N)
         stats.assess(0, E=E)
 
@@ -43,11 +40,13 @@ class RHF:
 
             if ko is not None:
                 stats.assess(k, ko, 'f', E=E)
+                Obs  = HMM.Obs(ko)
+                Rm12 = Obs.noise.C.sym_sqrt_inv
                 y    = yy[ko]
-                inds = serial_inds(self.ordr, y, R, center(E)[0])
+                inds = serial_inds(self.ordr, y, Obs.noise.C, center(E)[0])
 
                 for _, j in enumerate(inds):
-                    Eo = Obs(E, t)
+                    Eo = Obs(E)
                     xo = np.mean(Eo, 0)
                     Y  = Eo - xo
                     mu = np.mean(E, 0)
@@ -92,8 +91,7 @@ class LNETF:
     Rs: float  = 1.0
 
     def assimilate(self, HMM, xx, yy):
-        Dyn, Obs, tseq, X0, stats = HMM.Dyn, HMM.Obs, HMM.tseq, HMM.X0, self.stats
-        Rm12 = Obs.noise.C.sym_sqrt_inv
+        Dyn, tseq, X0, stats = HMM.Dyn, HMM.tseq, HMM.X0, self.stats
 
         E = X0.sample(self.N)
         stats.assess(0, E=E)
@@ -107,10 +105,11 @@ class LNETF:
                 mu = np.mean(E, 0)
                 A  = E - mu
 
-                Eo = Obs(E, t)
+                Obs = HMM.Obs(ko)
+                Eo = Obs(E)
                 xo = np.mean(Eo, 0)
-                YR = (Eo-xo)  @ Rm12.T
-                yR = (yy[ko] - xo) @ Rm12.T
+                YR = (Eo-xo)  @ Obs.noise.C.sym_sqrt_inv.T
+                yR = (yy[ko] - xo) @ Obs.noise.C.sym_sqrt_inv.T
 
                 state_batches, obs_taperer = Obs.localizer(
                     self.loc_rad, 'x2y', t, self.taper)