pyteda 0.2.0__tar.gz → 0.2.5__tar.gz

pyteda-0.2.5/PKG-INFO

@@ -0,0 +1,196 @@
+Metadata-Version: 2.4
+Name: pyteda
+Version: 0.2.5
+Summary: TEDA: Toy models and ensemble-based Data Assimilation methods for education and experimentation
+Author-email: "Elías D. Niño-Ruiz" <elias.d.nino@gmail.com>
+License: MIT
+Keywords: data assimilation,EnKF,education,Lorenz96,Python
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Education
+Classifier: Topic :: Scientific/Engineering :: Atmospheric Science
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+Requires-Dist: numpy
+Requires-Dist: scipy
+Requires-Dist: matplotlib
+Requires-Dist: scikit-learn
+
+# 🧠 TEDA – Toolbox for Ensemble Data Assimilation
+
+We are thrilled to present TEDA, a cutting-edge Python toolbox designed to facilitate the teaching and learning of ensemble-based data assimilation (DA). TEDA caters to the needs of educators and learners alike, offering a comprehensive platform to explore the captivating world of meteorological anomalies, climate change, and DA methodologies.
+
+TEDA stands out as an exceptional resource in the landscape of DA software, as it prioritizes the educational experience. While operational software tends to focus on practical applications, TEDA empowers undergraduate and graduate students by providing an intuitive platform to grasp the intricacies of ensemble-based DA concepts and foster enthusiasm for scientific exploration.
+
+Equipped with a diverse range of features and functionalities, TEDA enriches the learning process by offering powerful visualization tools. Students can delve into error statistics, model errors, observational errors, error distributions, and the dynamic evolution of errors. These visualizations provide multiple perspectives on numerical results, enabling students to develop a deep understanding of ensemble-based DA principles.
+
+TEDA offers numerous ensemble-based DA methods, allowing students to explore an extensive range of techniques. From the stochastic ensemble Kalman filter (EnKF) to dual EnKF formulations, EnKF via Cholesky decomposition, EnKF based on modified Cholesky decomposition, EnKF based on B-localization, and beyond, TEDA equips learners with a comprehensive toolkit to study and compare various DA methodologies.
+
+TEDA's foundation is rooted in the Object-Oriented Programming (OOP) paradigm, enabling effortless integration of new techniques and models. This ensures that TEDA remains at the forefront of the rapidly evolving field of ensemble-based DA, allowing educators and researchers to incorporate the latest advancements into their teaching and experimentation.
+
+Embark on a captivating journey of discovery and knowledge with TEDA as it unveils the secrets of data assimilation. Simulate various DA scenarios, experiment with different model configurations, and witness firsthand the transformative impact of ensemble-based DA methods on forecast accuracy and data analysis.
+
+Unlock your true potential in the realm of data assimilation with TEDA. Whether you are an enthusiastic student or a dedicated educator, TEDA stands as your ultimate companion in unraveling the complexities of ensemble-based DA.
+
+Keywords: Data Assimilation, Ensemble Kalman Filter, Education, Python.
+
+### 🧪 Toy Models for Data Assimilation
+
+To enhance the learning experience, **TEDA** is built around **toy models** that exhibit chaotic behavior under specific configurations. These models are ideal for experimenting with and validating various Data Assimilation (DA) techniques in a hands-on, controlled setting.
+
+Currently, TEDA includes the **Lorenz 96 model** (40 variables), a well-known benchmark in DA research.
+
+> 📌 *Support for other classic chaotic systems like the Duffing equation and Lorenz 63 may be added in future versions.*
+
+---
+
+## 📦 Installation
+
+Aquí tienes una versión mejor redactada y estructurada para la sección de instalación y uso rápido:
+
+---
+
+## 🚀 Installation and Quick Start
+
+### ✅ From PyPI
+
+To install the latest stable version:
+
+```bash
+pip install pyteda
+```
+
+### 🧪 From Source (for development)
+
+Clone the repository and install in editable mode:
+
+```bash
+git clone https://github.com/your-username/pyteda.git
+cd pyteda
+pip install -e .
+```
+
+### 🛠️ Recommended Setup: Virtual Environment
+
+We suggest using a virtual environment to manage dependencies:
+
+```bash
+python -m venv venv
+source venv/bin/activate  # On Windows: venv\Scripts\activate
+```
+
+Install all required dependencies:
+
+```bash
+pip install -r requirements.txt
+```
+
+---
+
+## 📁 Example Usage
+
+You can run a complete simulation workflow using:
+
+```bash
+python examples/basic_template.py
+```
+
+Or explore the file directly: [`examples/basic_template.py`](examples/basic_template.py)
+
+---
+
+### ▶️ Run the basic example
+
+Once installed, you can run the full example with:
+
+```bash
+python -m examples.basic_template
+```
+
+This will initialize the Lorenz96 model, run an ensemble-based data assimilation simulation, and display the log-relative errors for both the background and analysis states.
+
+---
+
+### Supported Methods
+
+The `pyteda` package supports a wide range of ensemble-based data assimilation methods including EnKF, LETKF, ETKF, and shrinkage-based filters. All methods are accessible via the `AnalysisFactory`.
+
+📄 See [Supported Methods](docs/index.md) for a full list and references.
+
+---
+
+## 🚀 Quickstart
+
+Here's a minimal example using the **LETKF** method with the built-in Lorenz96 model:
+
+```python
+from pyteda.simulation import Simulation
+from pyteda.models import Lorenz96
+from pyteda.background import Background
+from pyteda.observation import Observation
+from pyteda.analysis.analysis_factory import AnalysisFactory
+
+model = Lorenz96()
+background = Background(model, ensemble_size=20)
+observation = Observation(m=32, std_obs=0.01)
+
+analysis = AnalysisFactory("letkf", model=model).create_analysis()
+
+params = {'obs_freq': 0.1, 'obs_times': 10, 'inf_fact': 1.04}
+sim = Simulation(model, background, analysis, observation, params=params)
+sim.run()
+
+errb, erra = sim.get_errors()
+```
+
+📈 For visualization and full working examples, check the [`examples/`](examples/) folder.
+
+---
+
+## 🎓 Citation
+
+If you use **TEDA** in your teaching or research, please cite:
+
+**Nino-Ruiz, E.D., Valbuena, S.R. (2022)**
+*TEDA: A Computational Toolbox for Teaching Ensemble Based Data Assimilation*.
+[📖 ICCS 2022, Springer](https://doi.org/10.1007/978-3-031-08760-8_60)
+
+```bibtex
+@inproceedings{nino2022teda,
+  title={TEDA: A Computational Toolbox for Teaching Ensemble Based Data Assimilation},
+  author={Nino-Ruiz, Elias D. and Valbuena, Sebastian Racedo},
+  booktitle={Computational Science – ICCS 2022},
+  series={Lecture Notes in Computer Science},
+  volume={13353},
+  pages={787--801},
+  year={2022},
+  publisher={Springer, Cham},
+  doi={10.1007/978-3-031-08760-8_60}
+}
+```
+
+---
+
+## 📚 More Resources
+
+* 🧪 Explore [examples/](examples/) to try different filters and models.
+* 📖 Full documentation available in the `docs/` folder.
+* ➕ Want to add your own method? TEDA supports [custom DA methods via registry](docs/custom_methods.md).
+
+---
+
+[![PyPI version](https://badge.fury.io/py/pyteda.svg)](https://pypi.org/project/pyteda/)
+[![Cite TEDA](https://img.shields.io/badge/Cite-TEDA-blue.svg)](https://doi.org/10.1007/978-3-031-08760-8_60)
+
+---
+
+## Developed by
+
+* Elías D. Niño-Ruiz
+* [https://enino84.github.io/](https://enino84.github.io/)
+* elias.d.nino@gmail.com
+

pyteda-0.2.5/README.md

@@ -0,0 +1,174 @@
+# 🧠 TEDA – Toolbox for Ensemble Data Assimilation
+
+We are thrilled to present TEDA, a cutting-edge Python toolbox designed to facilitate the teaching and learning of ensemble-based data assimilation (DA). TEDA caters to the needs of educators and learners alike, offering a comprehensive platform to explore the captivating world of meteorological anomalies, climate change, and DA methodologies.
+
+TEDA stands out as an exceptional resource in the landscape of DA software, as it prioritizes the educational experience. While operational software tends to focus on practical applications, TEDA empowers undergraduate and graduate students by providing an intuitive platform to grasp the intricacies of ensemble-based DA concepts and foster enthusiasm for scientific exploration.
+
+Equipped with a diverse range of features and functionalities, TEDA enriches the learning process by offering powerful visualization tools. Students can delve into error statistics, model errors, observational errors, error distributions, and the dynamic evolution of errors. These visualizations provide multiple perspectives on numerical results, enabling students to develop a deep understanding of ensemble-based DA principles.
+
+TEDA offers numerous ensemble-based DA methods, allowing students to explore an extensive range of techniques. From the stochastic ensemble Kalman filter (EnKF) to dual EnKF formulations, EnKF via Cholesky decomposition, EnKF based on modified Cholesky decomposition, EnKF based on B-localization, and beyond, TEDA equips learners with a comprehensive toolkit to study and compare various DA methodologies.
+
+TEDA's foundation is rooted in the Object-Oriented Programming (OOP) paradigm, enabling effortless integration of new techniques and models. This ensures that TEDA remains at the forefront of the rapidly evolving field of ensemble-based DA, allowing educators and researchers to incorporate the latest advancements into their teaching and experimentation.
+
+Embark on a captivating journey of discovery and knowledge with TEDA as it unveils the secrets of data assimilation. Simulate various DA scenarios, experiment with different model configurations, and witness firsthand the transformative impact of ensemble-based DA methods on forecast accuracy and data analysis.
+
+Unlock your true potential in the realm of data assimilation with TEDA. Whether you are an enthusiastic student or a dedicated educator, TEDA stands as your ultimate companion in unraveling the complexities of ensemble-based DA.
+
+Keywords: Data Assimilation, Ensemble Kalman Filter, Education, Python.
+
+### 🧪 Toy Models for Data Assimilation
+
+To enhance the learning experience, **TEDA** is built around **toy models** that exhibit chaotic behavior under specific configurations. These models are ideal for experimenting with and validating various Data Assimilation (DA) techniques in a hands-on, controlled setting.
+
+Currently, TEDA includes the **Lorenz 96 model** (40 variables), a well-known benchmark in DA research.
+
+> 📌 *Support for other classic chaotic systems like the Duffing equation and Lorenz 63 may be added in future versions.*
+
+---
+
+## 📦 Installation
+
+Aquí tienes una versión mejor redactada y estructurada para la sección de instalación y uso rápido:
+
+---
+
+## 🚀 Installation and Quick Start
+
+### ✅ From PyPI
+
+To install the latest stable version:
+
+```bash
+pip install pyteda
+```
+
+### 🧪 From Source (for development)
+
+Clone the repository and install in editable mode:
+
+```bash
+git clone https://github.com/your-username/pyteda.git
+cd pyteda
+pip install -e .
+```
+
+### 🛠️ Recommended Setup: Virtual Environment
+
+We suggest using a virtual environment to manage dependencies:
+
+```bash
+python -m venv venv
+source venv/bin/activate  # On Windows: venv\Scripts\activate
+```
+
+Install all required dependencies:
+
+```bash
+pip install -r requirements.txt
+```
+
+---
+
+## 📁 Example Usage
+
+You can run a complete simulation workflow using:
+
+```bash
+python examples/basic_template.py
+```
+
+Or explore the file directly: [`examples/basic_template.py`](examples/basic_template.py)
+
+---
+
+### ▶️ Run the basic example
+
+Once installed, you can run the full example with:
+
+```bash
+python -m examples.basic_template
+```
+
+This will initialize the Lorenz96 model, run an ensemble-based data assimilation simulation, and display the log-relative errors for both the background and analysis states.
+
+---
+
+### Supported Methods
+
+The `pyteda` package supports a wide range of ensemble-based data assimilation methods including EnKF, LETKF, ETKF, and shrinkage-based filters. All methods are accessible via the `AnalysisFactory`.
+
+📄 See [Supported Methods](docs/index.md) for a full list and references.
+
+---
+
+## 🚀 Quickstart
+
+Here's a minimal example using the **LETKF** method with the built-in Lorenz96 model:
+
+```python
+from pyteda.simulation import Simulation
+from pyteda.models import Lorenz96
+from pyteda.background import Background
+from pyteda.observation import Observation
+from pyteda.analysis.analysis_factory import AnalysisFactory
+
+model = Lorenz96()
+background = Background(model, ensemble_size=20)
+observation = Observation(m=32, std_obs=0.01)
+
+analysis = AnalysisFactory("letkf", model=model).create_analysis()
+
+params = {'obs_freq': 0.1, 'obs_times': 10, 'inf_fact': 1.04}
+sim = Simulation(model, background, analysis, observation, params=params)
+sim.run()
+
+errb, erra = sim.get_errors()
+```
+
+📈 For visualization and full working examples, check the [`examples/`](examples/) folder.
+
+---
+
+## 🎓 Citation
+
+If you use **TEDA** in your teaching or research, please cite:
+
+**Nino-Ruiz, E.D., Valbuena, S.R. (2022)**
+*TEDA: A Computational Toolbox for Teaching Ensemble Based Data Assimilation*.
+[📖 ICCS 2022, Springer](https://doi.org/10.1007/978-3-031-08760-8_60)
+
+```bibtex
+@inproceedings{nino2022teda,
+  title={TEDA: A Computational Toolbox for Teaching Ensemble Based Data Assimilation},
+  author={Nino-Ruiz, Elias D. and Valbuena, Sebastian Racedo},
+  booktitle={Computational Science – ICCS 2022},
+  series={Lecture Notes in Computer Science},
+  volume={13353},
+  pages={787--801},
+  year={2022},
+  publisher={Springer, Cham},
+  doi={10.1007/978-3-031-08760-8_60}
+}
+```
+
+---
+
+## 📚 More Resources
+
+* 🧪 Explore [examples/](examples/) to try different filters and models.
+* 📖 Full documentation available in the `docs/` folder.
+* ➕ Want to add your own method? TEDA supports [custom DA methods via registry](docs/custom_methods.md).
+
+---
+
+[![PyPI version](https://badge.fury.io/py/pyteda.svg)](https://pypi.org/project/pyteda/)
+[![Cite TEDA](https://img.shields.io/badge/Cite-TEDA-blue.svg)](https://doi.org/10.1007/978-3-031-08760-8_60)
+
+---
+
+## Developed by
+
+* Elías D. Niño-Ruiz
+* [https://enino84.github.io/](https://enino84.github.io/)
+* elias.d.nino@gmail.com
+

{pyteda-0.2.0 → pyteda-0.2.5}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "pyteda"
-version = "0.2.0"
+version = "0.2.5"
 description = "TEDA: Toy models and ensemble-based Data Assimilation methods for education and experimentation"
 readme = "README.md"
 requires-python = ">=3.7"

{pyteda-0.2.0 → pyteda-0.2.5}/pyteda/analysis/analysis_enkf_modified_cholesky.py

@@ -52,6 +52,9 @@ class AnalysisEnKFModifiedCholesky(Analysis):
         D[0, 0] = 1 / np.var(DX[0, :])  # We are estimating D^{-1}
         for i in range(1, n):
             ind_prede = self.model.get_pre(i, self.r)
+            if len(ind_prede) == 0:
+                D[i, i] = 1 / np.var(y)
+                continue
             y = DX[i, :]
             X = DX[ind_prede, :].T
             lr_fit = lr.fit(X, y)

{pyteda-0.2.0 → pyteda-0.2.5}/pyteda/analysis/analysis_lenkf.py

@@ -24,7 +24,8 @@ class AnalysisLEnKF(Analysis):
 
     def local_analysis_LEnKF(self, Xb, H, R, y, n, N, i, r):
         # Subdomain decomposition
-        si = [(i+j) % n for j in range(-r, r+1)]
+        si = si = self.model.get_ngb(i, r) #[(i+j) % n for j in range(-r, r+1)]
+        center_index = np.where(si == i)[0][0]  # Index of the center element in the subdomain
         Xbi = Xb[:, si]
         Pbi = np.cov(Xbi.T)
         yz = np.zeros((n,))
@@ -49,7 +50,7 @@ class AnalysisLEnKF(Analysis):
         else:
             Xai = Xbi
 
-        return Xai
+        return Xai, center_index  # Return the analysis state and the index of the center element in the subdomain
 
     def perform_assimilation(self, background, observation):
         """
@@ -76,8 +77,8 @@ class AnalysisLEnKF(Analysis):
 
         Xa = np.zeros((ensemble_size, n))  # Local analysis for each model component i
         for i in range(0, n):
-            Xai = self.local_analysis_LEnKF(Xb, H, R, y, n, ensemble_size, i, self.r)
-            Xa[:, i] = Xai[:, self.r]  #
+            Xai, center_index = self.local_analysis_LEnKF(Xb, H, R, y, n, ensemble_size, i, self.r)
+            Xa[:, i] = Xai[:, center_index]
 
         self.Xa = Xa.T
 

{pyteda-0.2.0 → pyteda-0.2.5}/pyteda/analysis/analysis_letkf.py

@@ -23,7 +23,8 @@ class AnalysisLETKF(Analysis):
 
     def local_analysis_LETKF(self, Xb, H, R, y, n, N, i, r):
         # Subdomain decomposition
-        si = [(i+j) % n for j in range(-r, r+1)]
+        si = self.model.get_ngb(i, r) #[(i+j) % n for j in range(-r, r+1)]
+        center_index = np.where(si == i)[0][0]  # Index of the center element in the subdomain
         Xbi = Xb[:, si].T
         xbi = np.mean(Xbi, axis=1).reshape(-1,1)
         DXi = Xbi - xbi
@@ -66,7 +67,7 @@ class AnalysisLETKF(Analysis):
         else:
             Xai = Xbi.T
 
-        return Xai
+        return Xai, center_index
 
     def perform_assimilation(self, background, observation):
         """
@@ -93,8 +94,9 @@ class AnalysisLETKF(Analysis):
 
         Xa = np.zeros((ensemble_size, n))  # Local analysis for each model component i
         for i in range(0, n):
-            Xai = self.local_analysis_LETKF(Xb, H, R, y, n, ensemble_size, i, self.r)
-            Xa[:, i] = Xai[:, self.r]
+            Xai, center_index = self.local_analysis_LETKF(Xb, H, R, y, n, ensemble_size, i, self.r)
+            Xa[:, i] = Xai[:, center_index]
+            #Xa[:, i] = Xai[:, self.r]
 
         self.Xa = Xa.T
 

{pyteda-0.2.0 → pyteda-0.2.5}/pyteda/models/__init__.py

@@ -6,3 +6,4 @@ Created on Thu Oct 22 00:43:05 2020
 """
 
 from .lorenz96 import Lorenz96
+from .quasi_geostrophic import QGModel

pyteda-0.2.5/pyteda/models/quasi_geostrophic.py

@@ -0,0 +1,178 @@
+import numpy as np
+from scipy.fft import fft2, ifft2, fftfreq
+from .model import Model
+
+class QGModel(Model):
+    """Barotropic QG model with periodic BCs and state vector [q, psi]."""
+
+    def __init__(self, N=64, L=1.0, dt=0.001, F=1600.0,
+                 r=1e-2, rkb=1e-1, rkh=1e-5, rkh2=1e-8):
+        self.N = N
+        self.L = L
+        self.dt = dt
+        self.F = F
+        self.r = r
+        self.rkb = rkb
+        self.rkh = rkh
+        self.rkh2 = rkh2
+        self.n = 2 * N * N  # state = [q, psi]
+        self._L = None
+
+        x = np.linspace(0, L, N, endpoint=False)
+        y = np.linspace(0, L, N, endpoint=False)
+        self.X, self.Y = np.meshgrid(x, y)
+        self.dx = self.dy = L / N
+
+        kx = fftfreq(N, d=self.dx) * 2 * np.pi
+        ky = fftfreq(N, d=self.dy) * 2 * np.pi
+        self.KX, self.KY = np.meshgrid(kx, ky)
+        self.K2 = self.KX**2 + self.KY**2
+        self.K2[0, 0] = 1e-10
+        self.K4 = self.K2**2
+
+    def laplacian(self, psi):
+        return ifft2(-self.K2 * fft2(psi)).real
+
+    def biharmonic(self, psi):
+        return ifft2(self.K4 * fft2(psi)).real
+
+    def arakawa_jacobian(self, psi, q):
+        def jp(f): return np.roll(f, -1, axis=0)
+        def jm(f): return np.roll(f, 1, axis=0)
+        def kp(f): return np.roll(f, -1, axis=1)
+        def km(f): return np.roll(f, 1, axis=1)
+
+        j1 = (jp(psi) - jm(psi)) * (kp(q) - km(q)) - (kp(psi) - km(psi)) * (jp(q) - jm(q))
+        j2 = kp(psi)*(jp(q)-q) - km(psi)*(q-jm(q)) - jp(psi)*(kp(q)-q) + jm(psi)*(q-km(q))
+        j3 = jp(psi)*(kp(q)-km(q)) - jm(psi)*(kp(q)-km(q)) - kp(psi)*(jp(q)-jm(q)) + km(psi)*(jp(q)-jm(q))
+        return (j1 + j2 + j3) / (12 * self.dx * self.dy)
+
+    def forcing(self):
+        return 2 * np.pi * np.sin(2 * np.pi * self.Y)
+
+    def propagate(self, x0, T, just_final_state=True):
+        q = x0[:self.N**2].reshape((self.N, self.N)).copy()
+        psi_hat = fft2(q) / (self.K2 + self.F)
+        psi_hat[0, 0] = 0.0
+        psi = ifft2(psi_hat).real
+
+        t = T[0]
+        t_end = T[-1]
+
+        while t < t_end:
+            t += self.dt
+            zeta = self.laplacian(psi)
+            q = zeta - self.F * psi
+            j = self.arakawa_jacobian(psi, q)
+            dqdt = -psi.copy()
+            dqdt += -self.r * j
+            dqdt += -self.rkb * zeta
+            dqdt += self.rkh * self.laplacian(zeta)
+            dqdt += -self.rkh2 * self.biharmonic(zeta)
+            dqdt += self.forcing()
+
+            q += self.dt * dqdt
+            psi_hat = fft2(q) / (self.K2 + self.F)
+            psi_hat[0, 0] = 0.0
+            psi = ifft2(psi_hat).real
+
+        if just_final_state:
+            return np.concatenate([q.flatten(), psi.flatten()])
+        return None
+
+    def get_initial_condition(self, seed=42, T=np.arange(0, 25, 0.01)):
+        np.random.seed(seed)
+        psi0 = 1e-4 * np.random.randn(self.N, self.N)
+        q0 = self.laplacian(psi0) - self.F * psi0
+        return self.propagate(np.concatenate([q0.flatten(), psi0.flatten()]), T)
+
+    def get_number_of_variables(self):
+        return self.n
+
+    def get_ngb(self, i, r, cross=False):
+        N = self.N
+        n_grid = N * N
+
+        var_index = 0 if i < n_grid else 1  # 0 = q, 1 = psi
+        i_local = i % n_grid
+        iy, ix = divmod(i_local, N)
+
+        neighbors = []
+        for dy in range(-r, r + 1):
+            y = (iy + dy) % N
+            for dx in range(-r, r + 1):
+                x = (ix + dx) % N
+                base = y * N + x
+
+                # Add same variable neighbor
+                neighbors.append(base + var_index * n_grid)
+
+                if cross:
+                    # Add cross-variable neighbor
+                    neighbors.append(base + (1 - var_index) * n_grid)
+
+        return np.array(sorted(set(neighbors)), dtype=int)  # Remove duplicates if cross=True
+
+
+    def create_decorrelation_matrix(self, r, cross=False, cross_scale=1.0):
+        N = self.N
+        n = N * N
+        total_n = 2 * n
+        L = np.zeros((total_n, total_n))
+
+        for i in range(total_n):
+            iy1, ix1 = divmod(i % n, N)
+            var1 = 0 if i < n else 1  # 0: q, 1: psi
+
+            for j in range(i, total_n):
+                iy2, ix2 = divmod(j % n, N)
+                var2 = 0 if j < n else 1  # 0: q, 1: psi
+
+                dx = min(abs(ix1 - ix2), N - abs(ix1 - ix2))
+                dy = min(abs(iy1 - iy2), N - abs(iy1 - iy2))
+                dij2 = dx**2 + dy**2
+
+                if var1 == var2:
+                    scale = 1.0
+                elif cross:
+                    scale = cross_scale
+                else:
+                    scale = 0.0
+
+                val = np.exp(-dij2 / (2 * r**2)) * scale
+                L[i, j] = L[j, i] = val
+
+        self._L = L
+
+
+    def get_decorrelation_matrix(self):
+        return self._L
+    
+    def get_pre(self, i, r, cross=False):
+        N = self.N
+        n = N * N
+        total_n = 2 * n
+
+        if i < n:
+            offset = 0  # q
+        else:
+            offset = n  # psi
+            i_base = i - n
+        i_base = i % n
+
+        iy, ix = divmod(i_base, N)
+        neighbors = []
+
+        for dy in range(-r, r + 1):
+            y = (iy + dy) % N
+            for dx in range(-r, r + 1):
+                x = (ix + dx) % N
+                j_base = y * N + x
+
+                for block_offset in [0, n]:  # q and psi blocks
+                    j = j_base + block_offset
+                    if j < i:
+                        if cross or block_offset == offset:
+                            neighbors.append(j)
+
+        return np.array(neighbors, dtype=int)