From fab813d252f8d04cca9702a4f36a0433e6ba6cab Mon Sep 17 00:00:00 2001 From: Santiago Soler Date: Mon, 2 Feb 2026 17:16:22 -0800 Subject: [PATCH 01/47] Draft Wires classes Start drafting classes to slice models with multiple components. These wires are intended to be used to convert a model dictionary into a 1D model array, and to slice a portion of the model array. --- src/inversion_ideas/__init__.py | 2 + src/inversion_ideas/wires.py | 118 ++++++++++++++++++++++++++++++++ 2 files changed, 120 insertions(+) create mode 100644 src/inversion_ideas/wires.py diff --git a/src/inversion_ideas/__init__.py b/src/inversion_ideas/__init__.py index f2c2269..8f01401 100644 --- a/src/inversion_ideas/__init__.py +++ b/src/inversion_ideas/__init__.py @@ -23,6 +23,7 @@ ) from .regularization import Flatness, Smallness, SparseSmallness, TikhonovZero from .simulations import wrap_simulation +from .wires import Wiring __all__ = [ "ChiTarget", @@ -43,6 +44,7 @@ "SparseSmallness", "TikhonovZero", "UpdateSensitivityWeights", + "Wiring", "__version__", "base", "conjugate_gradient", diff --git a/src/inversion_ideas/wires.py b/src/inversion_ideas/wires.py new file mode 100644 index 0000000..0ab97e6 --- /dev/null +++ b/src/inversion_ideas/wires.py @@ -0,0 +1,118 @@ +""" +Model wiring. +""" + +from numbers import Integral + +import numpy as np + +from .typing import Model + + +class Wires: + + def __init__(self, **kwargs): + self._slices = {} + + current_index = 0 + for key, value in kwargs.items(): + if not isinstance(key, str): + # TODO: Add msg + raise TypeError() + + if isinstance(value, Integral): + slice_ = slice(current_index, int(value)) + current_index = value + else: + # TODO: Add msg + raise TypeError() + + self._slices[key] = WireSlice(subset=key, slice=slice_, wires=self) + + self._size = sum([slice_.size for slice_ in self._slices.values()]) + + @property + def size(self) -> int: + """ + Total size of the model that can be sliced. + """ + return self._size + + def keys(self): + """ + Return keys in the wiring. + """ + return self._slices.keys() + + def __getattr__(self, value: str) -> "WireSlice": + return self._slices[value] + + def __getitem__(self, value: str) -> "WireSlice": + return self._slices[value] + + @classmethod + def create(cls, model_dict: dict[str, Model]): + """ + Create a ``Wiring`` object from a model dictionary. + """ + kwargs = {key: array.size for key, array in model_dict.items()} + return cls(**kwargs) + + def array_to_dict(self, model: Model): + """ + Transform a model array into a dictionary. + """ + if model.size != self.size: + # TODO: add msg + raise ValueError() + model_dict = {key: model[self[key].slice] for key in self.keys()} + return model_dict + + def dict_to_array(self, model_dict: dict[str, Model]): + """ + Ravel a model dictionary into a single 1D array. + """ + # TODO: we should run sanity checks to ensure that the model_dict is compatible + # with this wiring. + model = np.hstack([model_dict[key] for key in self.keys()]) + return model + + +class WireSlice: + """ + Wire slice used to slice a model array. + + .. important:: + + Don't instantiate this class. Use the ``Wires`` class instead. + """ + + def __init__(self, subset: str, slice: slice, wires: Wires): + if not isinstance(subset, str): + # TODO: Add msg + raise TypeError() + self._subset = subset + self._slice = slice + self._wires = wires + + @property + def subset(self) -> str: + return self._subset + + @property + def slice(self) -> slice: + return self._slice + + @property + def size(self) -> int: + return self._slice.stop - self._slice.start + + @property + def wires(self) -> Wires: + return self._wires + + def extract(self, model: Model): + if model.size != self.wires.size: + # TODO: add msg + raise ValueError() + return model[self.slice] From 4fe7b77b7185191fdf4899452825efe84b5faaf6 Mon Sep 17 00:00:00 2001 From: Santiago Soler Date: Tue, 3 Feb 2026 13:49:45 -0800 Subject: [PATCH 02/47] Add a BlockColumnMatrix custom operator Add a new `operators` submodule. --- src/inversion_ideas/__init__.py | 3 +- src/inversion_ideas/operators.py | 76 ++++++++++++++++++++++++++++++++ 2 files changed, 78 insertions(+), 1 deletion(-) create mode 100644 src/inversion_ideas/operators.py diff --git a/src/inversion_ideas/__init__.py b/src/inversion_ideas/__init__.py index 8f01401..90e90b0 100644 --- a/src/inversion_ideas/__init__.py +++ b/src/inversion_ideas/__init__.py @@ -2,7 +2,7 @@ Ideas for inversion framework. """ -from . import base, typing, utils +from . import base, operators, typing, utils from ._version import __version__ from .conditions import ChiTarget, CustomCondition, ModelChanged, ObjectiveChanged from .data_misfit import DataMisfit @@ -52,6 +52,7 @@ "create_sparse_inversion", "create_tikhonov_regularization", "get_jacobi_preconditioner", + "operators", "typing", "utils", "wrap_simulation", diff --git a/src/inversion_ideas/operators.py b/src/inversion_ideas/operators.py new file mode 100644 index 0000000..526aff2 --- /dev/null +++ b/src/inversion_ideas/operators.py @@ -0,0 +1,76 @@ +""" +Special linear operators. + +Define classes for custom linear operators. +""" + +import numpy as np +import numpy.typing as npt +from scipy.sparse.linalg import LinearOperator +from scipy.sparse import sparray + + +class BlockColumnMatrix(LinearOperator): + r""" + Represents a block column matrix. + + This ``LinearOperator`` represents a matrix with a dense or sparse block that + occupies all rows, and columns to each side of it are all zeros. + + .. math:: + + \textbf{M} = + \begin{bmatrix} + \dots & 0 & a_{11} & \dots & a_{1M} & 0 & \dots\\ + \dots & 0 & \vdots & \ddots & \vdots & 0 & \dots\\ + \dots & 0 & a_{N1} & \dots & a_{NM} & 0 & \dots\\ + \end{bmatrix} + + Parameters + ---------- + block : 2D array, LinearOperator or sparray + Matrix or linear operator that will be used + index_start : int + Row index where the first column of the ``block`` matrix should be located in + the large block matrix. + n_cols : int + Total number of columns of the large block matrix. + """ + + def __init__( + self, + block: npt.NDArray | LinearOperator | sparray, + index_start: int, + n_cols: tuple[int, int], + ): + # TODO: raise error if the block matrix has more columns than n_cols + shape = (block.shape[0], n_cols) + super().__init__(shape=shape, dtype=block.dtype) + + self.block = block + self._slice = slice(index_start, index_start + block.shape[1]) + + def _matvec(self, x): + """ + Dot product between the matrix and a vector. + """ + x_subset = x[self._slice] + return self.block @ x_subset + + def _rmatvec(self, x): + """ + Dot product between the transposed matrix and a vector. + """ + out = np.zeros(self.shape[1], dtype=self.dtype) + out[self._slice] = self.block.T @ x + return out + + def toarray(self): + """ + Return a dense ndarray representation of this blocked matrix. + """ + # TODO: raise error if the block is not an array or if it doesn't have a toarray + # method. + matrix = np.zeros(self.shape, dtype=self.dtype) + matrix[:, self._slice] = self.block + return matrix From fabbaab5f15d54cf094355b9065f076b79d8fd11 Mon Sep 17 00:00:00 2001 From: Santiago Soler Date: Tue, 3 Feb 2026 13:50:12 -0800 Subject: [PATCH 03/47] Improve some bits of the Wires and add methods Add methods to extend a matrix through a `BlockColumnMatrix` and to extend a 1D array by just filling it with zeros. --- src/inversion_ideas/__init__.py | 4 +-- src/inversion_ideas/wires.py | 57 ++++++++++++++++++++++++++++----- 2 files changed, 51 insertions(+), 10 deletions(-) diff --git a/src/inversion_ideas/__init__.py b/src/inversion_ideas/__init__.py index 90e90b0..067e4cc 100644 --- a/src/inversion_ideas/__init__.py +++ b/src/inversion_ideas/__init__.py @@ -23,7 +23,7 @@ ) from .regularization import Flatness, Smallness, SparseSmallness, TikhonovZero from .simulations import wrap_simulation -from .wires import Wiring +from .wires import Wires __all__ = [ "ChiTarget", @@ -44,7 +44,7 @@ "SparseSmallness", "TikhonovZero", "UpdateSensitivityWeights", - "Wiring", + "Wires", "__version__", "base", "conjugate_gradient", diff --git a/src/inversion_ideas/wires.py b/src/inversion_ideas/wires.py index 0ab97e6..3dc1d4e 100644 --- a/src/inversion_ideas/wires.py +++ b/src/inversion_ideas/wires.py @@ -5,6 +5,11 @@ from numbers import Integral import numpy as np +import numpy.typing as npt +from scipy.sparse import sparray +from scipy.sparse.linalg import LinearOperator + +from ..operators import BlockColumnMatrix from .typing import Model @@ -27,7 +32,7 @@ def __init__(self, **kwargs): # TODO: Add msg raise TypeError() - self._slices[key] = WireSlice(subset=key, slice=slice_, wires=self) + self._slices[key] = WireSlice(name=key, slice=slice_, wires=self) self._size = sum([slice_.size for slice_ in self._slices.values()]) @@ -51,9 +56,9 @@ def __getitem__(self, value: str) -> "WireSlice": return self._slices[value] @classmethod - def create(cls, model_dict: dict[str, Model]): + def create_from(cls, model_dict: dict[str, Model]): """ - Create a ``Wiring`` object from a model dictionary. + Create a ``Wires`` object from a model dictionary. """ kwargs = {key: array.size for key, array in model_dict.items()} return cls(**kwargs) @@ -87,17 +92,17 @@ class WireSlice: Don't instantiate this class. Use the ``Wires`` class instead. """ - def __init__(self, subset: str, slice: slice, wires: Wires): - if not isinstance(subset, str): + def __init__(self, name: str, slice: slice, wires: Wires): + if not isinstance(name, str): # TODO: Add msg raise TypeError() - self._subset = subset + self._name = name self._slice = slice self._wires = wires @property - def subset(self) -> str: - return self._subset + def name(self) -> str: + return self._name @property def slice(self) -> slice: @@ -116,3 +121,39 @@ def extract(self, model: Model): # TODO: add msg raise ValueError() return model[self.slice] + + def expand_array(self, array: npt.NDArray) -> npt.NDArray: + """ + Expand a 1D array with zeros outside the model slice. + """ + if not isinstance(array, np.ndarray): + msg = f"Invalid array of type {type(array).__name__}." + raise TypeError(msg) + if array.ndim != 1: + msg = f"Invalid array with {array.ndim} dimensions. It must be a 1D array." + raise ValueError(msg) + out = np.zeros(self.wires.size, dtype=array.dtype) + out[self.slice] = array + return out + + def expand_matrix( + self, matrix: npt.NDArray | sparray | LinearOperator + ) -> BlockColumnMatrix: + """ + Expand a matrix that operates on the model slice into a block matrix. + """ + if matrix.ndim != 2: + msg = ( + f"Invalid matrix with {matrix.ndim} dimensions. " + "It must be a 2D matrix or LinearOperator." + ) + raise ValueError(msg) + if matrix.shape[1] != self.size: + # TODO: Complete the error message + msg = f"Invalid matrix with shape '{matrix.shape}'." + raise ValueError(msg) + return BlockColumnMatrix( + block=matrix, + index_start=self.slice.start, + n_cols=self.wires.size, + ) From 66fbc48793bea7f4339ff512328d6803539c39ce Mon Sep 17 00:00:00 2001 From: Santiago Soler Date: Tue, 3 Feb 2026 15:59:31 -0800 Subject: [PATCH 04/47] Fix bugs and improve Wires --- src/inversion_ideas/wires.py | 30 ++++++++++++++++++------------ 1 file changed, 18 insertions(+), 12 deletions(-) diff --git a/src/inversion_ideas/wires.py b/src/inversion_ideas/wires.py index 3dc1d4e..9effc1c 100644 --- a/src/inversion_ideas/wires.py +++ b/src/inversion_ideas/wires.py @@ -9,8 +9,7 @@ from scipy.sparse import sparray from scipy.sparse.linalg import LinearOperator -from ..operators import BlockColumnMatrix - +from .operators import BlockColumnMatrix from .typing import Model @@ -19,20 +18,20 @@ class Wires: def __init__(self, **kwargs): self._slices = {} - current_index = 0 + current_index: int = 0 for key, value in kwargs.items(): if not isinstance(key, str): # TODO: Add msg raise TypeError() if isinstance(value, Integral): - slice_ = slice(current_index, int(value)) - current_index = value + slice_ = slice(current_index, current_index + value) + current_index += int(value) else: # TODO: Add msg raise TypeError() - self._slices[key] = WireSlice(name=key, slice=slice_, wires=self) + self._slices[key] = ModelSlice(name=key, slice=slice_, wires=self) self._size = sum([slice_.size for slice_ in self._slices.values()]) @@ -49,10 +48,13 @@ def keys(self): """ return self._slices.keys() - def __getattr__(self, value: str) -> "WireSlice": + def __getattr__(self, value: str) -> "ModelSlice": + if value not in self._slices: + # TODO: Add msg + raise AttributeError() return self._slices[value] - def __getitem__(self, value: str) -> "WireSlice": + def __getitem__(self, value: str) -> "ModelSlice": return self._slices[value] @classmethod @@ -83,9 +85,9 @@ def dict_to_array(self, model_dict: dict[str, Model]): return model -class WireSlice: +class ModelSlice: """ - Wire slice used to slice a model array. + Class used to slice a model. .. important:: @@ -112,6 +114,10 @@ def slice(self) -> slice: def size(self) -> int: return self._slice.stop - self._slice.start + @property + def full_size(self) -> int: + return self.wires.size + @property def wires(self) -> Wires: return self._wires @@ -132,7 +138,7 @@ def expand_array(self, array: npt.NDArray) -> npt.NDArray: if array.ndim != 1: msg = f"Invalid array with {array.ndim} dimensions. It must be a 1D array." raise ValueError(msg) - out = np.zeros(self.wires.size, dtype=array.dtype) + out = np.zeros(self.full_size, dtype=array.dtype) out[self.slice] = array return out @@ -155,5 +161,5 @@ def expand_matrix( return BlockColumnMatrix( block=matrix, index_start=self.slice.start, - n_cols=self.wires.size, + n_cols=self.full_size, ) From 5b825ca4259e3c07adf2a29d95a3a6fefb548d12 Mon Sep 17 00:00:00 2001 From: Santiago Soler Date: Tue, 3 Feb 2026 15:59:50 -0800 Subject: [PATCH 05/47] Add support for model_slice to DataMisfit --- src/inversion_ideas/data_misfit.py | 38 ++++++++++++++++++++++++++---- src/inversion_ideas/operators.py | 2 +- 2 files changed, 34 insertions(+), 6 deletions(-) diff --git a/src/inversion_ideas/data_misfit.py b/src/inversion_ideas/data_misfit.py index 97a4639..9fa72be 100644 --- a/src/inversion_ideas/data_misfit.py +++ b/src/inversion_ideas/data_misfit.py @@ -10,6 +10,7 @@ from .base import Objective from .typing import Model from .utils import cache_on_model +from .wires import ModelSlice class DataMisfit(Objective): @@ -82,6 +83,7 @@ def __init__( uncertainty: npt.NDArray[np.float64], simulation, *, + model_slice: ModelSlice | None = None, cache=False, build_hessian=False, ): @@ -90,6 +92,7 @@ def __init__( self.data = data self.uncertainty = uncertainty self.simulation = simulation + self.model_slice = model_slice self.cache = cache self.build_hessian = build_hessian self.set_name("d") @@ -107,9 +110,18 @@ def gradient(self, model: Model) -> npt.NDArray[np.float64]: """ Gradient vector. """ - jac = self.simulation.jacobian(model) + jac = self.simulation.jacobian( + model if self.model_slice is None else self.model_slice.extract(model) + ) weights_matrix = self.weights_matrix - return 2 * jac.T @ (weights_matrix.T @ weights_matrix @ self.residual(model)) + gradient = ( + 2 * jac.T @ (weights_matrix.T @ weights_matrix @ self.residual(model)) + ) + + if self.model_slice is not None: + gradient = self.model_slice.expand_array(gradient) + + return gradient def hessian( self, model: Model @@ -117,10 +129,17 @@ def hessian( """ Hessian matrix. """ - jac = self.simulation.jacobian(model) + jac = self.simulation.jacobian( + model if self.model_slice is None else self.model_slice.extract(model) + ) + weights_matrix = aslinearoperator(self.weights_matrix) + + if self.model_slice is not None: + jac = self.model_slice.expand_matrix(jac) + if not self.build_hessian: jac = aslinearoperator(jac) - weights_matrix = aslinearoperator(self.weights_matrix) + return 2 * jac.T @ weights_matrix.T @ weights_matrix @ jac def hessian_diagonal(self, model: Model) -> npt.NDArray[np.float64]: @@ -128,7 +147,12 @@ def hessian_diagonal(self, model: Model) -> npt.NDArray[np.float64]: Diagonal of the Hessian. """ jac = self.simulation.jacobian(model) - if isinstance(jac, LinearOperator): + if self.model_slice is not None: + msg = ( + "DataMisfit with a model_slice doesn't support `hessian_diagonal` yet." + ) + raise NotImplementedError(msg) + if isinstance(jac, LinearOperator) or self.model_slice is not None: msg = ( "`DataMisfit.hessian_diagonal()` is not implemented for simulations " "that return the jacobian as a LinearOperator." @@ -142,6 +166,8 @@ def n_params(self): """ Number of model parameters. """ + if self.model_slice is not None: + return self.model_slice.full_size return self.simulation.n_params @property @@ -176,6 +202,8 @@ def residual(self, model: Model): where :math:`\mathbf{d}` is the vector with observed data, :math:`\mathcal{F}` is the forward model, and :math:`\mathbf{m}` is the model vector. """ + if self.model_slice is not None: + model = self.model_slice.extract(model) return self.simulation(model) - self.data @property diff --git a/src/inversion_ideas/operators.py b/src/inversion_ideas/operators.py index 526aff2..e35e4b1 100644 --- a/src/inversion_ideas/operators.py +++ b/src/inversion_ideas/operators.py @@ -6,8 +6,8 @@ import numpy as np import numpy.typing as npt -from scipy.sparse.linalg import LinearOperator from scipy.sparse import sparray +from scipy.sparse.linalg import LinearOperator class BlockColumnMatrix(LinearOperator): From ec3627fac59ee12edcf80721f32711de14dccb98 Mon Sep 17 00:00:00 2001 From: Santiago Soler Date: Tue, 3 Feb 2026 16:00:15 -0800 Subject: [PATCH 06/47] Add notebook trying out gravity inversion with model slice --- ...0_gravity-inversion-with-model-slice.ipynb | 1032 +++++++++++++++++ 1 file changed, 1032 insertions(+) create mode 100644 notebooks/50_gravity-inversion-with-model-slice.ipynb diff --git a/notebooks/50_gravity-inversion-with-model-slice.ipynb b/notebooks/50_gravity-inversion-with-model-slice.ipynb new file mode 100644 index 0000000..f067863 --- /dev/null +++ b/notebooks/50_gravity-inversion-with-model-slice.ipynb @@ -0,0 +1,1032 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "c4b21011-75e3-4f3a-a357-e28fcaaabdf4", + "metadata": {}, + "source": [ + "# Gravity inversion with a model slice" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "b2d27e8b-5b33-4361-990b-8b6e724f5ac6", + "metadata": { + "execution": { + "iopub.execute_input": "2026-02-03T23:54:09.642559Z", + "iopub.status.busy": "2026-02-03T23:54:09.642196Z", + "iopub.status.idle": "2026-02-03T23:54:11.570247Z", + "shell.execute_reply": "2026-02-03T23:54:11.569377Z", + "shell.execute_reply.started": "2026-02-03T23:54:09.642530Z" + } + }, + "outputs": [], + "source": [ + "import discretize\n", + "import harmonica as hm\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "import verde as vd\n", + "from simpeg.maps import IdentityMap\n", + "from simpeg.potential_fields.gravity import (\n", + " Point,\n", + " Simulation3DIntegral,\n", + " SourceField,\n", + " Survey,\n", + ")\n", + "from simpeg.utils import depth_weighting, model_builder\n", + "\n", + "import inversion_ideas as ii" + ] + }, + { + "cell_type": "markdown", + "id": "a7a0aea4-50f4-4eea-9b6e-e907c520534e", + "metadata": {}, + "source": [ + "## Define synthetic data with two prisms" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "dfce90d3-de10-43d3-a668-696993b0f73e", + "metadata": { + "execution": { + "iopub.execute_input": "2026-02-03T23:54:11.571348Z", + "iopub.status.busy": "2026-02-03T23:54:11.570894Z", + "iopub.status.idle": "2026-02-03T23:54:11.576067Z", + "shell.execute_reply": "2026-02-03T23:54:11.575100Z", + "shell.execute_reply.started": "2026-02-03T23:54:11.571317Z" + } + }, + "outputs": [], + "source": [ + "prisms = [\n", + " (-60, -40, -10, 10, -70, -50),\n", + " (40, 60, -10, 10, -70, -50),\n", + "]\n", + "densities = np.array([-200, 200]) # SI units\n", + "\n", + "region = (-100, 100, -100, 100)\n", + "shape = (31, 31)\n", + "height = 0\n", + "coordinates = vd.grid_coordinates(region, shape=shape, extra_coords=height)" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "2403d600-451e-424e-8de9-3f824f1e2647", + "metadata": { + "execution": { + "iopub.execute_input": "2026-02-03T23:54:11.577047Z", + "iopub.status.busy": "2026-02-03T23:54:11.576794Z", + "iopub.status.idle": "2026-02-03T23:54:12.928543Z", + "shell.execute_reply": "2026-02-03T23:54:12.927448Z", + "shell.execute_reply.started": "2026-02-03T23:54:11.577021Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "stderr=np.float64(2.5745854651805945e-05)\n" + ] + } + ], + "source": [ + "gz = hm.prism_gravity(coordinates, prisms, densities, field=\"g_z\")\n", + "gz *= -1 # Invert sign to work with upward component\n", + "\n", + "# Add noise\n", + "stderr = vd.maxabs(gz) * 0.01\n", + "gz += np.random.default_rng(seed=51).normal(scale=stderr, size=gz.shape)\n", + "\n", + "print(f\"{stderr=}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "9612913a-b699-4ad4-8fe7-cbf83376f5d8", + "metadata": { + "execution": { + "iopub.execute_input": "2026-02-03T23:54:12.929455Z", + "iopub.status.busy": "2026-02-03T23:54:12.929204Z", + "iopub.status.idle": "2026-02-03T23:54:13.091225Z", + "shell.execute_reply": "2026-02-03T23:54:13.090367Z", + "shell.execute_reply.started": "2026-02-03T23:54:12.929429Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "tmp = plt.pcolormesh(*coordinates[:2], gz)\n", + "plt.gca().set_aspect(\"equal\")\n", + "plt.colorbar(tmp)\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "f6d55c30-c5c9-4376-bc6d-ece83805b2d2", + "metadata": { + "execution": { + "iopub.execute_input": "2026-02-03T23:54:13.092234Z", + "iopub.status.busy": "2026-02-03T23:54:13.091918Z", + "iopub.status.idle": "2026-02-03T23:54:13.096913Z", + "shell.execute_reply": "2026-02-03T23:54:13.096160Z", + "shell.execute_reply.started": "2026-02-03T23:54:13.092207Z" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "961" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "gz.size" + ] + }, + { + "cell_type": "markdown", + "id": "d460a7fd-9eed-497f-9b41-2de3a08f5750", + "metadata": {}, + "source": [ + "## Define SimPEG simulation" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "0edbb620-6a62-48bf-a8af-8981a76cc6f4", + "metadata": { + "execution": { + "iopub.execute_input": "2026-02-03T23:54:13.097834Z", + "iopub.status.busy": "2026-02-03T23:54:13.097562Z", + "iopub.status.idle": "2026-02-03T23:54:13.113497Z", + "shell.execute_reply": "2026-02-03T23:54:13.112535Z", + "shell.execute_reply.started": "2026-02-03T23:54:13.097813Z" + } + }, + "outputs": [ + { + "data": { + "text/html": [ + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
TensorMesh64,000 cells
MESH EXTENTCELL WIDTHFACTOR
dirnCminmaxminmaxmax
x40-100.00100.005.005.001.00
y40-100.00100.005.005.001.00
z40-200.000.005.005.001.00
\n" + ], + "text/plain": [ + "\n", + " TensorMesh: 64,000 cells\n", + "\n", + " MESH EXTENT CELL WIDTH FACTOR\n", + " dir nC min max min max max\n", + " --- --- --------------------------- ------------------ ------\n", + " x 40 -100.00 100.00 5.00 5.00 1.00\n", + " y 40 -100.00 100.00 5.00 5.00 1.00\n", + " z 40 -200.00 0.00 5.00 5.00 1.00\n" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "h = [(5.0, 40)]\n", + "mesh = discretize.TensorMesh(h=[h, h, h], origin=\"CCN\")\n", + "mesh" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "8a890b93-78ec-4681-bbb5-cc91e1448a85", + "metadata": { + "execution": { + "iopub.execute_input": "2026-02-03T23:54:13.114396Z", + "iopub.status.busy": "2026-02-03T23:54:13.114152Z", + "iopub.status.idle": "2026-02-03T23:54:13.122073Z", + "shell.execute_reply": "2026-02-03T23:54:13.120960Z", + "shell.execute_reply.started": "2026-02-03T23:54:13.114370Z" + } + }, + "outputs": [], + "source": [ + "locations = np.vstack(tuple(c.ravel() for c in coordinates)).T\n", + "receivers = Point(locations, components=\"gz\")\n", + "source = SourceField(receiver_list=[receivers])\n", + "survey = Survey(source)" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "1dd17123-2df8-45b6-9345-d5cb6f431d51", + "metadata": { + "execution": { + "iopub.execute_input": "2026-02-03T23:54:13.123154Z", + "iopub.status.busy": "2026-02-03T23:54:13.122804Z", + "iopub.status.idle": "2026-02-03T23:54:13.180907Z", + "shell.execute_reply": "2026-02-03T23:54:13.180055Z", + "shell.execute_reply.started": "2026-02-03T23:54:13.123127Z" + } + }, + "outputs": [], + "source": [ + "simulation_simpeg = Simulation3DIntegral(mesh, survey=survey, rhoMap=IdentityMap(mesh))" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "b4c9ad67-47fe-4408-b879-d99b8eec8ca2", + "metadata": { + "execution": { + "iopub.execute_input": "2026-02-03T23:54:13.181509Z", + "iopub.status.busy": "2026-02-03T23:54:13.181343Z", + "iopub.status.idle": "2026-02-03T23:54:13.185189Z", + "shell.execute_reply": "2026-02-03T23:54:13.183915Z", + "shell.execute_reply.started": "2026-02-03T23:54:13.181493Z" + } + }, + "outputs": [], + "source": [ + "def block_corners(prism):\n", + " p0 = np.array([prism[0], prism[2], prism[4]])\n", + " p1 = np.array([prism[1], prism[3], prism[5]])\n", + " return p0, p1" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "ffc07711-d8e3-49cf-9574-f2bde45ceec8", + "metadata": { + "execution": { + "iopub.execute_input": "2026-02-03T23:54:13.186006Z", + "iopub.status.busy": "2026-02-03T23:54:13.185770Z", + "iopub.status.idle": "2026-02-03T23:54:13.197920Z", + "shell.execute_reply": "2026-02-03T23:54:13.197031Z", + "shell.execute_reply.started": "2026-02-03T23:54:13.185973Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[-0.2 0.2]\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/santi/.miniforge3/envs/inversion_ideas/lib/python3.13/site-packages/simpeg/utils/model_builder.py:37: BreakingChangeWarning: Since SimPEG v0.25.0, the 'get_indices_block' function returns a single array with the cell indices, instead of a tuple with a single element. This means that we don't need to unpack the tuple anymore to access to the cell indices.\n", + "If you were using this function as in:\n", + "\n", + " ind = get_indices_block(p0, p1, mesh.cell_centers)[0]\n", + "\n", + "Make sure you update it to:\n", + "\n", + " ind = get_indices_block(p0, p1, mesh.cell_centers)\n", + "\n", + "To hide this warning, add this to your script or notebook:\n", + "\n", + " import warnings\n", + " from simpeg.utils import BreakingChangeWarning\n", + "\n", + " warnings.filterwarnings(action='ignore', category=BreakingChangeWarning)\n", + "\n", + " ind = get_indices_block(p0, p1, cell_centers)\n" + ] + } + ], + "source": [ + "model = np.zeros(mesh.n_cells)\n", + "densities_gcc = densities * 1e-3\n", + "print(densities_gcc)\n", + "\n", + "for prism, density in zip(prisms, densities_gcc, strict=True):\n", + " p0, p1 = block_corners(prism)\n", + " model = model_builder.add_block(mesh.cell_centers, model, p0, p1, density)" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "0b89b688-a595-4ff3-81e3-8bba4d4ef7c8", + "metadata": { + "execution": { + "iopub.execute_input": "2026-02-03T23:54:13.198779Z", + "iopub.status.busy": "2026-02-03T23:54:13.198579Z", + "iopub.status.idle": "2026-02-03T23:54:13.363095Z", + "shell.execute_reply": "2026-02-03T23:54:13.362380Z", + "shell.execute_reply.started": "2026-02-03T23:54:13.198760Z" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "(,)" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "mesh.plot_slice(model, normal=\"Y\", slice_loc=0)" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "ff50fbfa-9dd4-4c01-a8eb-245c3c0706a0", + "metadata": { + "execution": { + "iopub.execute_input": "2026-02-03T23:54:13.364217Z", + "iopub.status.busy": "2026-02-03T23:54:13.363890Z", + "iopub.status.idle": "2026-02-03T23:54:17.536459Z", + "shell.execute_reply": "2026-02-03T23:54:17.531891Z", + "shell.execute_reply.started": "2026-02-03T23:54:13.364190Z" + } + }, + "outputs": [], + "source": [ + "dpred = simulation_simpeg.dpred(model)" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "094b1d30-c610-44ca-968b-7257aacbaa91", + "metadata": { + "execution": { + "iopub.execute_input": "2026-02-03T23:54:17.537597Z", + "iopub.status.busy": "2026-02-03T23:54:17.537171Z", + "iopub.status.idle": "2026-02-03T23:54:17.726852Z", + "shell.execute_reply": "2026-02-03T23:54:17.725928Z", + "shell.execute_reply.started": "2026-02-03T23:54:17.537572Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "tmp = plt.pcolormesh(*coordinates[:2], dpred.reshape(coordinates[0].shape))\n", + "plt.gca().set_aspect(\"equal\")\n", + "plt.colorbar(tmp)\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "137e7314-b148-46d9-b3b6-01496aaf8da4", + "metadata": {}, + "source": [ + "## Define inversion using the new framework" + ] + }, + { + "cell_type": "markdown", + "id": "001ed1bb-6919-486b-a954-4bd54de79b4e", + "metadata": {}, + "source": [ + "Wrap SimPEG's simulation into a child of the new `Simulation` class:" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "a4303772-cfe0-45ed-90ec-c1caad768f39", + "metadata": { + "execution": { + "iopub.execute_input": "2026-02-03T23:54:17.727650Z", + "iopub.status.busy": "2026-02-03T23:54:17.727395Z", + "iopub.status.idle": "2026-02-03T23:54:17.731224Z", + "shell.execute_reply": "2026-02-03T23:54:17.730233Z", + "shell.execute_reply.started": "2026-02-03T23:54:17.727624Z" + } + }, + "outputs": [], + "source": [ + "simulation = ii.wrap_simulation(simulation_simpeg, store_jacobian=True)" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "956f31ab-ed45-432f-a788-15cf73febf14", + "metadata": { + "execution": { + "iopub.execute_input": "2026-02-03T23:54:17.732041Z", + "iopub.status.busy": "2026-02-03T23:54:17.731771Z", + "iopub.status.idle": "2026-02-03T23:54:17.759898Z", + "shell.execute_reply": "2026-02-03T23:54:17.759065Z", + "shell.execute_reply.started": "2026-02-03T23:54:17.732016Z" + } + }, + "outputs": [], + "source": [ + "dpred = simulation(model)" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "fd1dfb8c-fe88-4a46-b59e-70baaec550f7", + "metadata": { + "execution": { + "iopub.execute_input": "2026-02-03T23:54:17.760734Z", + "iopub.status.busy": "2026-02-03T23:54:17.760471Z", + "iopub.status.idle": "2026-02-03T23:54:17.960696Z", + "shell.execute_reply": "2026-02-03T23:54:17.959721Z", + "shell.execute_reply.started": "2026-02-03T23:54:17.760707Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "tmp = plt.pcolormesh(*coordinates[:2], dpred.reshape(coordinates[0].shape))\n", + "plt.gca().set_aspect(\"equal\")\n", + "plt.colorbar(tmp)\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "e916f176-b4b7-427a-847c-a282f85640a5", + "metadata": { + "execution": { + "iopub.execute_input": "2026-02-03T23:54:17.961555Z", + "iopub.status.busy": "2026-02-03T23:54:17.961328Z", + "iopub.status.idle": "2026-02-03T23:54:18.488518Z", + "shell.execute_reply": "2026-02-03T23:54:18.487730Z", + "shell.execute_reply.started": "2026-02-03T23:54:17.961537Z" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[-2.13782823e-05, -2.13372550e-05, -2.12555951e-05, ...,\n", + " -1.03258138e-07, -9.94137181e-08, -9.57099928e-08],\n", + " [-2.13691528e-05, -2.13828480e-05, -2.13554722e-05, ...,\n", + " -1.08606834e-07, -1.04571292e-07, -1.00679443e-07],\n", + " [-2.12872892e-05, -2.13554722e-05, -2.13828480e-05, ...,\n", + " -1.14213826e-07, -1.09984235e-07, -1.05900419e-07],\n", + " ...,\n", + " [-4.40011354e-06, -4.50945208e-06, -4.62019534e-06, ...,\n", + " -5.03316037e-02, -6.45257719e-03, -1.40158215e-03],\n", + " [-4.25670714e-06, -4.36399932e-06, -4.47284401e-06, ...,\n", + " -6.45257719e-03, -5.03316037e-02, -1.27241928e-02],\n", + " [-4.11623023e-06, -4.22130506e-06, -4.32805791e-06, ...,\n", + " -9.48031491e-04, -3.60945193e-03, -3.23499329e-02]],\n", + " shape=(961, 64000))" + ] + }, + "execution_count": 17, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "simulation.jacobian(model)" + ] + }, + { + "cell_type": "markdown", + "id": "2b28c265-4af8-4991-b0ad-ac99cdf42f6e", + "metadata": {}, + "source": [ + "Define a composed model: one part for densities, and another part for a dummy physical property.\n", + "\n", + "Build initial model dictionary and use it to create wires:" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "931c7ff0-0f45-40cb-8227-c78e97823f79", + "metadata": { + "execution": { + "iopub.execute_input": "2026-02-03T23:54:18.491309Z", + "iopub.status.busy": "2026-02-03T23:54:18.491072Z", + "iopub.status.idle": "2026-02-03T23:54:18.495111Z", + "shell.execute_reply": "2026-02-03T23:54:18.494309Z", + "shell.execute_reply.started": "2026-02-03T23:54:18.491287Z" + } + }, + "outputs": [], + "source": [ + "initial_model_dict = {\n", + " \"density\": np.zeros(simulation.n_params),\n", + " \"dummy\": np.zeros(3),\n", + "}\n", + "\n", + "wires = ii.Wires.create_from(initial_model_dict)" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "id": "c862c062-c7e2-4d7b-8825-109fa7072bdd", + "metadata": { + "execution": { + "iopub.execute_input": "2026-02-03T23:54:18.496030Z", + "iopub.status.busy": "2026-02-03T23:54:18.495764Z", + "iopub.status.idle": "2026-02-03T23:54:18.510577Z", + "shell.execute_reply": "2026-02-03T23:54:18.509539Z", + "shell.execute_reply.started": "2026-02-03T23:54:18.496004Z" + } + }, + "outputs": [], + "source": [ + "uncertainties = stderr * np.ones(gz.size)\n", + "data_misfit = ii.DataMisfit(gz.ravel(), uncertainties, simulation, model_slice=wires.density)" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "id": "9042f903-4d02-4abe-9de1-2dfacfb3b3a0", + "metadata": { + "execution": { + "iopub.execute_input": "2026-02-03T23:54:27.643929Z", + "iopub.status.busy": "2026-02-03T23:54:27.643726Z", + "iopub.status.idle": "2026-02-03T23:54:27.649084Z", + "shell.execute_reply": "2026-02-03T23:54:27.648496Z", + "shell.execute_reply.started": "2026-02-03T23:54:27.643912Z" + } + }, + "outputs": [], + "source": [ + "depth_weights = depth_weighting(mesh, 0) ** 2\n", + "\n", + "# Let's use a tikhonov zero for now, because I haven't implemented model slices in Smallness yet\n", + "# smallness = ii.Smallness(mesh=mesh, cell_weights=depth_weights)\n", + "\n", + "# I need to manually combine weights for the density and weights for the dummy (just zeros).\n", + "# This shouldn't be necessary if the regularization handles model slices too.\n", + "density_weights = mesh.cell_volumes * depth_weights\n", + "dummy_weights = np.zeros(wires.dummy.size)\n", + "weights = np.hstack((density_weights, dummy_weights))\n", + "\n", + "smallness = ii.TikhonovZero(n_params=wires.size, weights=weights)" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "id": "ae115d7f-6b08-4c4e-b5f3-7277c24a49e4", + "metadata": { + "execution": { + "iopub.execute_input": "2026-02-03T23:54:34.724980Z", + "iopub.status.busy": "2026-02-03T23:54:34.724684Z", + "iopub.status.idle": "2026-02-03T23:54:34.728022Z", + "shell.execute_reply": "2026-02-03T23:54:34.727250Z", + "shell.execute_reply.started": "2026-02-03T23:54:34.724953Z" + } + }, + "outputs": [], + "source": [ + "phi = data_misfit + 1e2 * smallness" + ] + }, + { + "cell_type": "markdown", + "id": "e668a336-b9bb-45c8-ac17-b102e94dd935", + "metadata": {}, + "source": [ + "Convert the initial model dict to array using the wires" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "id": "dbc4da3d", + "metadata": { + "execution": { + "iopub.execute_input": "2026-02-03T23:54:36.073034Z", + "iopub.status.busy": "2026-02-03T23:54:36.072825Z", + "iopub.status.idle": "2026-02-03T23:54:36.077563Z", + "shell.execute_reply": "2026-02-03T23:54:36.076825Z", + "shell.execute_reply.started": "2026-02-03T23:54:36.073014Z" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "array([0., 0., 0., ..., 0., 0., 0.], shape=(64003,))" + ] + }, + "execution_count": 23, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "initial_model = wires.dict_to_array(initial_model_dict)\n", + "initial_model" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "id": "463b4e7b", + "metadata": { + "execution": { + "iopub.execute_input": "2026-02-03T23:54:37.581854Z", + "iopub.status.busy": "2026-02-03T23:54:37.581585Z", + "iopub.status.idle": "2026-02-03T23:54:37.585141Z", + "shell.execute_reply": "2026-02-03T23:54:37.584222Z", + "shell.execute_reply.started": "2026-02-03T23:54:37.581829Z" + } + }, + "outputs": [], + "source": [ + "# Ignore preconditioner for now, the DataMisfit doesn't support it yet for model slices\n", + "# preconditioner = ii.get_jacobi_preconditioner(phi, initial_model)\n", + "# preconditioner" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "id": "e2dfb4e8-1996-4f3f-8b05-781fc2d4537c", + "metadata": { + "execution": { + "iopub.execute_input": "2026-02-03T23:54:38.009674Z", + "iopub.status.busy": "2026-02-03T23:54:38.009460Z", + "iopub.status.idle": "2026-02-03T23:54:59.820879Z", + "shell.execute_reply": "2026-02-03T23:54:59.816589Z", + "shell.execute_reply.started": "2026-02-03T23:54:38.009656Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Elapsed time (no preconditioner): 21.80s\n" + ] + } + ], + "source": [ + "import time\n", + "\n", + "start = time.time()\n", + "inverted_model = ii.conjugate_gradient(phi, initial_model, rtol=1e-6)\n", + "end = time.time()\n", + "print(f\"Elapsed time (no preconditioner): {end - start:.2f}s\")" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "id": "82c1ddc2-d886-4cd1-a42d-1c32af5d4465", + "metadata": { + "execution": { + "iopub.execute_input": "2026-02-03T23:56:14.078649Z", + "iopub.status.busy": "2026-02-03T23:56:14.078438Z", + "iopub.status.idle": "2026-02-03T23:56:14.082613Z", + "shell.execute_reply": "2026-02-03T23:56:14.081840Z", + "shell.execute_reply.started": "2026-02-03T23:56:14.078631Z" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "array([-0.00012583, -0.0001243 , -0.00012219, ..., 0. ,\n", + " 0. , 0. ], shape=(64003,))" + ] + }, + "execution_count": 26, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "inverted_model" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "id": "05ef6fdf-55c0-4911-9ac8-2041af49b3cd", + "metadata": { + "execution": { + "iopub.execute_input": "2026-02-03T23:56:15.148655Z", + "iopub.status.busy": "2026-02-03T23:56:15.148347Z", + "iopub.status.idle": "2026-02-03T23:56:15.154060Z", + "shell.execute_reply": "2026-02-03T23:56:15.153168Z", + "shell.execute_reply.started": "2026-02-03T23:56:15.148629Z" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "{'density': array([-0.00012583, -0.0001243 , -0.00012219, ..., -0.00049973,\n", + " 0.0006469 , -0.00042525], shape=(64000,)),\n", + " 'dummy': array([0., 0., 0.])}" + ] + }, + "execution_count": 27, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "inverted_model_dict = wires.array_to_dict(inverted_model)\n", + "inverted_model_dict" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "id": "d20f5357-efd0-42cb-a156-90fcd6b41f0b", + "metadata": { + "execution": { + "iopub.execute_input": "2026-02-03T23:56:16.474672Z", + "iopub.status.busy": "2026-02-03T23:56:16.474402Z", + "iopub.status.idle": "2026-02-03T23:56:16.479352Z", + "shell.execute_reply": "2026-02-03T23:56:16.478304Z", + "shell.execute_reply.started": "2026-02-03T23:56:16.474649Z" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "array([-0.00012583, -0.0001243 , -0.00012219, ..., -0.00049973,\n", + " 0.0006469 , -0.00042525], shape=(64000,))" + ] + }, + "execution_count": 28, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "inverted_density = inverted_model_dict[\"density\"]\n", + "inverted_density" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "id": "70b2b5ea-d6dd-4cf3-855c-9e8fd600c7cd", + "metadata": { + "execution": { + "iopub.execute_input": "2026-02-03T23:56:17.049006Z", + "iopub.status.busy": "2026-02-03T23:56:17.048797Z", + "iopub.status.idle": "2026-02-03T23:56:17.189304Z", + "shell.execute_reply": "2026-02-03T23:56:17.188241Z", + "shell.execute_reply.started": "2026-02-03T23:56:17.048988Z" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "(,)" + ] + }, + "execution_count": 29, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "mesh.plot_slice(inverted_density, normal=\"Y\", slice_loc=0)" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python [conda env:inversion_ideas]", + "language": "python", + "name": "conda-env-inversion_ideas-py" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.13.9" + }, + "widgets": { + "application/vnd.jupyter.widget-state+json": { + "state": { + "55ba46e8dd294951a0f1d35b45845b32": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "d7af4393e22548319db206cf36433dea": { + "model_module": "@jupyter-widgets/output", + "model_module_version": "1.0.0", + "model_name": "OutputModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/output", + "_model_module_version": "1.0.0", + "_model_name": "OutputModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/output", + "_view_module_version": "1.0.0", + "_view_name": "OutputView", + "layout": "IPY_MODEL_55ba46e8dd294951a0f1d35b45845b32", + "msg_id": "", + "outputs": [ + { + "data": { + "text/html": "
┏━━━━━━━━━━━┳━━━━━━━━━━┳━━━━━━━━━━┳━━━━━━━━━━┳━━━━━━━━━━┳━━━━━━━━━━┳━━━━━━━━━━┳━━━━━━━━━━━━━━━━━┓\n┃ Iteration ┃ β        ┃ φ_d      ┃ φ_m      ┃ β φ_m    ┃ φ        ┃ χ        ┃ chi_target hit? ┃\n┡━━━━━━━━━━━╇━━━━━━━━━━╇━━━━━━━━━━╇━━━━━━━━━━╇━━━━━━━━━━╇━━━━━━━━━━╇━━━━━━━━━━╇━━━━━━━━━━━━━━━━━┩\n│ 0         │ 1.00e+04 │ 1.67e+06 │ 0.00e+00 │ 0.00e+00 │ 1.67e+06 │ 1.74e+03 │ False           │\n│ 1         │ 1.00e+04 │ 4.62e+01 │ 4.30e-01 │ 4.30e+03 │ 4.35e+03 │ 4.81e-02 │ True            │\n└───────────┴──────────┴──────────┴──────────┴──────────┴──────────┴──────────┴─────────────────┘\n
\n", + "text/plain": "┏━━━━━━━━━━━┳━━━━━━━━━━┳━━━━━━━━━━┳━━━━━━━━━━┳━━━━━━━━━━┳━━━━━━━━━━┳━━━━━━━━━━┳━━━━━━━━━━━━━━━━━┓\n┃\u001b[1m \u001b[0m\u001b[1mIteration\u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1mβ \u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1mφ_d \u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1mφ_m \u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1mβ φ_m \u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1mφ \u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1mχ \u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1mchi_target hit?\u001b[0m\u001b[1m \u001b[0m┃\n┡━━━━━━━━━━━╇━━━━━━━━━━╇━━━━━━━━━━╇━━━━━━━━━━╇━━━━━━━━━━╇━━━━━━━━━━╇━━━━━━━━━━╇━━━━━━━━━━━━━━━━━┩\n│ 0 │ 1.00e+04 │ 1.67e+06 │ 0.00e+00 │ 0.00e+00 │ 1.67e+06 │ 1.74e+03 │ False │\n│ 1 │ 1.00e+04 │ 4.62e+01 │ 4.30e-01 │ 4.30e+03 │ 4.35e+03 │ 4.81e-02 │ True │\n└───────────┴──────────┴──────────┴──────────┴──────────┴──────────┴──────────┴─────────────────┘\n" + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "tabbable": null, + "tooltip": null + } + } + }, + "version_major": 2, + "version_minor": 0 + } + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} From b707be07f920a4b773cc028891154b70b5469dad Mon Sep 17 00:00:00 2001 From: Santiago Soler Date: Wed, 4 Feb 2026 11:34:55 -0800 Subject: [PATCH 07/47] Add docstring to Wires --- src/inversion_ideas/wires.py | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/src/inversion_ideas/wires.py b/src/inversion_ideas/wires.py index 9effc1c..48d0de7 100644 --- a/src/inversion_ideas/wires.py +++ b/src/inversion_ideas/wires.py @@ -14,6 +14,12 @@ class Wires: + """ + Collection of model slices. + + The ``Wires`` have capabilities for handling models with multiple physical + properties. + """ def __init__(self, **kwargs): self._slices = {} From 2ffc4ab75a5953e53cbd52fdcb9dd5cf68a211bf Mon Sep 17 00:00:00 2001 From: Santiago Soler Date: Wed, 4 Feb 2026 11:35:13 -0800 Subject: [PATCH 08/47] Add `get_column` method to the `BlockColumnMatrix` Add also a `__getitem__` method and some properties to make the arguments read-only. --- src/inversion_ideas/operators.py | 93 ++++++++++++++++++++++++++++++-- 1 file changed, 89 insertions(+), 4 deletions(-) diff --git a/src/inversion_ideas/operators.py b/src/inversion_ideas/operators.py index e35e4b1..e7b748b 100644 --- a/src/inversion_ideas/operators.py +++ b/src/inversion_ideas/operators.py @@ -47,14 +47,27 @@ def __init__( shape = (block.shape[0], n_cols) super().__init__(shape=shape, dtype=block.dtype) - self.block = block + self._block = block + self._index_start = index_start self._slice = slice(index_start, index_start + block.shape[1]) + @property + def block(self): + return self._block + + @property + def index_start(self): + return self._index_start + + @property + def slice(self): + return self._slice + def _matvec(self, x): """ Dot product between the matrix and a vector. """ - x_subset = x[self._slice] + x_subset = x[self.slice] return self.block @ x_subset def _rmatvec(self, x): @@ -62,7 +75,7 @@ def _rmatvec(self, x): Dot product between the transposed matrix and a vector. """ out = np.zeros(self.shape[1], dtype=self.dtype) - out[self._slice] = self.block.T @ x + out[self.slice] = self.block.T @ x return out def toarray(self): @@ -72,5 +85,77 @@ def toarray(self): # TODO: raise error if the block is not an array or if it doesn't have a toarray # method. matrix = np.zeros(self.shape, dtype=self.dtype) - matrix[:, self._slice] = self.block + matrix[:, self.slice] = self.block return matrix + + def get_column(self, column_index) -> npt.NDArray: + """ + Get the j-th column of the matrix. + + Parameters + ---------- + column_index : int + Index for the desired column. + + Returns + ------- + column : array + The j-th column of the matrix. + """ + # TODO: raise error if we cannot extract column from block + # (sparse array, linear operator). + axis = 1 + if not (0 <= column_index < self.shape[axis]): + msg = ( + f"index {column_index} is out of bounds for axis {axis} " + f"with size {self.shape[axis]}" + ) + raise IndexError(msg) + if self.slice.start <= column_index < self.slice.stop: + return self.block[:, column_index - self.slice.start] + return np.zeros(self.shape[0], dtype=self.dtype) + + def __getitem__(self, indices): + # TODO: raise error if block cannot be indexed + # TODO: raise error if slices? or support them. + + row, column = indices + + # Sanity checks for indices + axis = 0 + if row >= 0: + if not (0 <= row < self.shape[axis]): + msg = ( + f"index {row} is out of bounds for axis {axis} " + f"with size {self.shape[axis]}" + ) + raise IndexError(msg) + else: + if row < -self.shape[0]: + msg = ( + f"index {row} is out of bounds for axis {axis} " + f"with size {self.shape[axis]}" + ) + raise IndexError(msg) + row += self.shape[0] + + axis = 1 + if column >= 0: + if not (0 <= column < self.shape[axis]): + msg = ( + f"index {column} is out of bounds for axis {axis} " + f"with size {self.shape[axis]}" + ) + raise IndexError(msg) + else: + if column < -self.shape[axis]: + msg = ( + f"index {column} is out of bounds for axis {axis} " + f"with size {self.shape[axis]}" + ) + raise IndexError(msg) + column += self.shape[axis] + + if self.slice.start <= column < self.slice.stop: + return self.block[row, column - self.slice.start] + return np.astype(np.float64(0.0), self.dtype) From a56578f40baced7e747d0a5244995bf9722bcaf3 Mon Sep 17 00:00:00 2001 From: Santiago Soler Date: Wed, 4 Feb 2026 11:36:06 -0800 Subject: [PATCH 09/47] Support `DataMisfit.hessian_diagonal` when `model_slice` is not None --- src/inversion_ideas/data_misfit.py | 74 ++++++++++++++++++------------ 1 file changed, 45 insertions(+), 29 deletions(-) diff --git a/src/inversion_ideas/data_misfit.py b/src/inversion_ideas/data_misfit.py index 9fa72be..3e82a00 100644 --- a/src/inversion_ideas/data_misfit.py +++ b/src/inversion_ideas/data_misfit.py @@ -8,6 +8,7 @@ from scipy.sparse.linalg import LinearOperator, aslinearoperator from .base import Objective +from .operators import BlockColumnMatrix from .typing import Model from .utils import cache_on_model from .wires import ModelSlice @@ -110,17 +111,11 @@ def gradient(self, model: Model) -> npt.NDArray[np.float64]: """ Gradient vector. """ - jac = self.simulation.jacobian( - model if self.model_slice is None else self.model_slice.extract(model) - ) + jac = self._get_jacobian(model) weights_matrix = self.weights_matrix gradient = ( 2 * jac.T @ (weights_matrix.T @ weights_matrix @ self.residual(model)) ) - - if self.model_slice is not None: - gradient = self.model_slice.expand_array(gradient) - return gradient def hessian( @@ -129,36 +124,36 @@ def hessian( """ Hessian matrix. """ - jac = self.simulation.jacobian( - model if self.model_slice is None else self.model_slice.extract(model) - ) + jac = self._get_jacobian(model) weights_matrix = aslinearoperator(self.weights_matrix) - - if self.model_slice is not None: - jac = self.model_slice.expand_matrix(jac) - if not self.build_hessian: jac = aslinearoperator(jac) - return 2 * jac.T @ weights_matrix.T @ weights_matrix @ jac def hessian_diagonal(self, model: Model) -> npt.NDArray[np.float64]: """ - Diagonal of the Hessian. - """ - jac = self.simulation.jacobian(model) - if self.model_slice is not None: - msg = ( - "DataMisfit with a model_slice doesn't support `hessian_diagonal` yet." - ) - raise NotImplementedError(msg) - if isinstance(jac, LinearOperator) or self.model_slice is not None: - msg = ( - "`DataMisfit.hessian_diagonal()` is not implemented for simulations " - "that return the jacobian as a LinearOperator." + Approximated diagonal of the Hessian. + """ + jac = self._get_jacobian(model) + if isinstance(jac, LinearOperator): + # If the linear operator implements the get_column method, we could use it + # to approximate the diagonal of the hessian. + # TODO: we can transform this into a Protocol. + if not hasattr(jac, "get_column"): + msg = ( + "`DataMisfit.hessian_diagonal()` is not implemented for simulations " + "that return the jacobian as a LinearOperator." + ) + raise NotImplementedError(msg) + weights_diagonal = self.weights_matrix.diagonal() + jtj_diag = np.array( + [ + np.sum(weights_diagonal * jac.get_column(i) ** 2) + for i in range(jac.shape[1]) + ] ) - raise NotImplementedError(msg) - jtj_diag = np.einsum("i,ij,ij->j", self.weights_matrix.diagonal(), jac, jac) + else: + jtj_diag = np.einsum("i,ij,ij->j", self.weights_matrix.diagonal(), jac, jac) return 2 * jtj_diag @property @@ -235,3 +230,24 @@ def chi_factor(self, model: Model): Chi factor for the given model. """ return self(model) / self.n_data + + def _get_jacobian(self, model) -> npt.NDArray | LinearOperator | BlockColumnMatrix: + """ + Return the jacobian of the simulation. + + This private method is intended to simplify code throughout the public ones when + dealing with ``model_slice`` not ``None``. + + Parameters + ---------- + model : (n_params) array + Model array. The array must have the full size. This method will use the + ``model_slice`` to extract the relevant portion that will be passed to the + simulation. + """ + jac = self.simulation.jacobian( + model if self.model_slice is None else self.model_slice.extract(model) + ) + if self.model_slice is not None: + jac = self.model_slice.expand_matrix(jac) + return jac From e42130e162d39c13dd7752420b77528142711651 Mon Sep 17 00:00:00 2001 From: Santiago Soler Date: Wed, 4 Feb 2026 11:37:15 -0800 Subject: [PATCH 10/47] Rerun notebook --- ...0_gravity-inversion-with-model-slice.ipynb | 384 +++++++++--------- 1 file changed, 188 insertions(+), 196 deletions(-) diff --git a/notebooks/50_gravity-inversion-with-model-slice.ipynb b/notebooks/50_gravity-inversion-with-model-slice.ipynb index f067863..3ea7529 100644 --- a/notebooks/50_gravity-inversion-with-model-slice.ipynb +++ b/notebooks/50_gravity-inversion-with-model-slice.ipynb @@ -14,11 +14,11 @@ "id": "b2d27e8b-5b33-4361-990b-8b6e724f5ac6", "metadata": { "execution": { - "iopub.execute_input": "2026-02-03T23:54:09.642559Z", - "iopub.status.busy": "2026-02-03T23:54:09.642196Z", - "iopub.status.idle": "2026-02-03T23:54:11.570247Z", - "shell.execute_reply": "2026-02-03T23:54:11.569377Z", - "shell.execute_reply.started": "2026-02-03T23:54:09.642530Z" + "iopub.execute_input": "2026-02-04T19:27:54.819942Z", + "iopub.status.busy": "2026-02-04T19:27:54.819673Z", + "iopub.status.idle": "2026-02-04T19:27:56.674222Z", + "shell.execute_reply": "2026-02-04T19:27:56.673045Z", + "shell.execute_reply.started": "2026-02-04T19:27:54.819912Z" } }, "outputs": [], @@ -54,11 +54,11 @@ "id": "dfce90d3-de10-43d3-a668-696993b0f73e", "metadata": { "execution": { - "iopub.execute_input": "2026-02-03T23:54:11.571348Z", - "iopub.status.busy": "2026-02-03T23:54:11.570894Z", - "iopub.status.idle": "2026-02-03T23:54:11.576067Z", - "shell.execute_reply": "2026-02-03T23:54:11.575100Z", - "shell.execute_reply.started": "2026-02-03T23:54:11.571317Z" + "iopub.execute_input": "2026-02-04T19:27:56.674867Z", + "iopub.status.busy": "2026-02-04T19:27:56.674580Z", + "iopub.status.idle": "2026-02-04T19:27:56.679493Z", + "shell.execute_reply": "2026-02-04T19:27:56.678034Z", + "shell.execute_reply.started": "2026-02-04T19:27:56.674851Z" } }, "outputs": [], @@ -81,11 +81,11 @@ "id": "2403d600-451e-424e-8de9-3f824f1e2647", "metadata": { "execution": { - "iopub.execute_input": "2026-02-03T23:54:11.577047Z", - "iopub.status.busy": "2026-02-03T23:54:11.576794Z", - "iopub.status.idle": "2026-02-03T23:54:12.928543Z", - "shell.execute_reply": "2026-02-03T23:54:12.927448Z", - "shell.execute_reply.started": "2026-02-03T23:54:11.577021Z" + "iopub.execute_input": "2026-02-04T19:27:56.680521Z", + "iopub.status.busy": "2026-02-04T19:27:56.680191Z", + "iopub.status.idle": "2026-02-04T19:27:57.893459Z", + "shell.execute_reply": "2026-02-04T19:27:57.892530Z", + "shell.execute_reply.started": "2026-02-04T19:27:56.680493Z" } }, "outputs": [ @@ -114,17 +114,17 @@ "id": "9612913a-b699-4ad4-8fe7-cbf83376f5d8", "metadata": { "execution": { - "iopub.execute_input": "2026-02-03T23:54:12.929455Z", - "iopub.status.busy": "2026-02-03T23:54:12.929204Z", - "iopub.status.idle": "2026-02-03T23:54:13.091225Z", - "shell.execute_reply": "2026-02-03T23:54:13.090367Z", - "shell.execute_reply.started": "2026-02-03T23:54:12.929429Z" + "iopub.execute_input": "2026-02-04T19:27:57.894459Z", + "iopub.status.busy": "2026-02-04T19:27:57.894254Z", + "iopub.status.idle": "2026-02-04T19:27:58.046763Z", + "shell.execute_reply": "2026-02-04T19:27:58.045901Z", + "shell.execute_reply.started": "2026-02-04T19:27:57.894444Z" } }, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -146,11 +146,11 @@ "id": "f6d55c30-c5c9-4376-bc6d-ece83805b2d2", "metadata": { "execution": { - "iopub.execute_input": "2026-02-03T23:54:13.092234Z", - "iopub.status.busy": "2026-02-03T23:54:13.091918Z", - "iopub.status.idle": "2026-02-03T23:54:13.096913Z", - "shell.execute_reply": "2026-02-03T23:54:13.096160Z", - "shell.execute_reply.started": "2026-02-03T23:54:13.092207Z" + "iopub.execute_input": "2026-02-04T19:27:58.047478Z", + "iopub.status.busy": "2026-02-04T19:27:58.047265Z", + "iopub.status.idle": "2026-02-04T19:27:58.053037Z", + "shell.execute_reply": "2026-02-04T19:27:58.051741Z", + "shell.execute_reply.started": "2026-02-04T19:27:58.047455Z" } }, "outputs": [ @@ -183,11 +183,11 @@ "id": "0edbb620-6a62-48bf-a8af-8981a76cc6f4", "metadata": { "execution": { - "iopub.execute_input": "2026-02-03T23:54:13.097834Z", - "iopub.status.busy": "2026-02-03T23:54:13.097562Z", - "iopub.status.idle": "2026-02-03T23:54:13.113497Z", - "shell.execute_reply": "2026-02-03T23:54:13.112535Z", - "shell.execute_reply.started": "2026-02-03T23:54:13.097813Z" + "iopub.execute_input": "2026-02-04T19:27:58.053840Z", + "iopub.status.busy": "2026-02-04T19:27:58.053497Z", + "iopub.status.idle": "2026-02-04T19:27:58.063265Z", + "shell.execute_reply": "2026-02-04T19:27:58.062323Z", + "shell.execute_reply.started": "2026-02-04T19:27:58.053820Z" } }, "outputs": [ @@ -273,11 +273,11 @@ "id": "8a890b93-78ec-4681-bbb5-cc91e1448a85", "metadata": { "execution": { - "iopub.execute_input": "2026-02-03T23:54:13.114396Z", - "iopub.status.busy": "2026-02-03T23:54:13.114152Z", - "iopub.status.idle": "2026-02-03T23:54:13.122073Z", - "shell.execute_reply": "2026-02-03T23:54:13.120960Z", - "shell.execute_reply.started": "2026-02-03T23:54:13.114370Z" + "iopub.execute_input": "2026-02-04T19:27:58.064516Z", + "iopub.status.busy": "2026-02-04T19:27:58.064069Z", + "iopub.status.idle": "2026-02-04T19:27:58.069444Z", + "shell.execute_reply": "2026-02-04T19:27:58.068198Z", + "shell.execute_reply.started": "2026-02-04T19:27:58.064487Z" } }, "outputs": [], @@ -294,11 +294,11 @@ "id": "1dd17123-2df8-45b6-9345-d5cb6f431d51", "metadata": { "execution": { - "iopub.execute_input": "2026-02-03T23:54:13.123154Z", - "iopub.status.busy": "2026-02-03T23:54:13.122804Z", - "iopub.status.idle": "2026-02-03T23:54:13.180907Z", - "shell.execute_reply": "2026-02-03T23:54:13.180055Z", - "shell.execute_reply.started": "2026-02-03T23:54:13.123127Z" + "iopub.execute_input": "2026-02-04T19:27:58.070299Z", + "iopub.status.busy": "2026-02-04T19:27:58.069976Z", + "iopub.status.idle": "2026-02-04T19:27:58.128211Z", + "shell.execute_reply": "2026-02-04T19:27:58.127338Z", + "shell.execute_reply.started": "2026-02-04T19:27:58.070261Z" } }, "outputs": [], @@ -312,11 +312,11 @@ "id": "b4c9ad67-47fe-4408-b879-d99b8eec8ca2", "metadata": { "execution": { - "iopub.execute_input": "2026-02-03T23:54:13.181509Z", - "iopub.status.busy": "2026-02-03T23:54:13.181343Z", - "iopub.status.idle": "2026-02-03T23:54:13.185189Z", - "shell.execute_reply": "2026-02-03T23:54:13.183915Z", - "shell.execute_reply.started": "2026-02-03T23:54:13.181493Z" + "iopub.execute_input": "2026-02-04T19:27:58.129105Z", + "iopub.status.busy": "2026-02-04T19:27:58.128786Z", + "iopub.status.idle": "2026-02-04T19:27:58.134440Z", + "shell.execute_reply": "2026-02-04T19:27:58.133064Z", + "shell.execute_reply.started": "2026-02-04T19:27:58.129076Z" } }, "outputs": [], @@ -333,11 +333,11 @@ "id": "ffc07711-d8e3-49cf-9574-f2bde45ceec8", "metadata": { "execution": { - "iopub.execute_input": "2026-02-03T23:54:13.186006Z", - "iopub.status.busy": "2026-02-03T23:54:13.185770Z", - "iopub.status.idle": "2026-02-03T23:54:13.197920Z", - "shell.execute_reply": "2026-02-03T23:54:13.197031Z", - "shell.execute_reply.started": "2026-02-03T23:54:13.185973Z" + "iopub.execute_input": "2026-02-04T19:27:58.135470Z", + "iopub.status.busy": "2026-02-04T19:27:58.135154Z", + "iopub.status.idle": "2026-02-04T19:27:58.144758Z", + "shell.execute_reply": "2026-02-04T19:27:58.143338Z", + "shell.execute_reply.started": "2026-02-04T19:27:58.135452Z" } }, "outputs": [ @@ -347,29 +347,6 @@ "text": [ "[-0.2 0.2]\n" ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/home/santi/.miniforge3/envs/inversion_ideas/lib/python3.13/site-packages/simpeg/utils/model_builder.py:37: BreakingChangeWarning: Since SimPEG v0.25.0, the 'get_indices_block' function returns a single array with the cell indices, instead of a tuple with a single element. This means that we don't need to unpack the tuple anymore to access to the cell indices.\n", - "If you were using this function as in:\n", - "\n", - " ind = get_indices_block(p0, p1, mesh.cell_centers)[0]\n", - "\n", - "Make sure you update it to:\n", - "\n", - " ind = get_indices_block(p0, p1, mesh.cell_centers)\n", - "\n", - "To hide this warning, add this to your script or notebook:\n", - "\n", - " import warnings\n", - " from simpeg.utils import BreakingChangeWarning\n", - "\n", - " warnings.filterwarnings(action='ignore', category=BreakingChangeWarning)\n", - "\n", - " ind = get_indices_block(p0, p1, cell_centers)\n" - ] } ], "source": [ @@ -388,18 +365,18 @@ "id": "0b89b688-a595-4ff3-81e3-8bba4d4ef7c8", "metadata": { "execution": { - "iopub.execute_input": "2026-02-03T23:54:13.198779Z", - "iopub.status.busy": "2026-02-03T23:54:13.198579Z", - "iopub.status.idle": "2026-02-03T23:54:13.363095Z", - "shell.execute_reply": "2026-02-03T23:54:13.362380Z", - "shell.execute_reply.started": "2026-02-03T23:54:13.198760Z" + "iopub.execute_input": "2026-02-04T19:27:58.145702Z", + "iopub.status.busy": "2026-02-04T19:27:58.145467Z", + "iopub.status.idle": "2026-02-04T19:27:58.316506Z", + "shell.execute_reply": "2026-02-04T19:27:58.315508Z", + "shell.execute_reply.started": "2026-02-04T19:27:58.145678Z" } }, "outputs": [ { "data": { "text/plain": [ - "(,)" + "(,)" ] }, "execution_count": 11, @@ -408,7 +385,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -427,11 +404,11 @@ "id": "ff50fbfa-9dd4-4c01-a8eb-245c3c0706a0", "metadata": { "execution": { - "iopub.execute_input": "2026-02-03T23:54:13.364217Z", - "iopub.status.busy": "2026-02-03T23:54:13.363890Z", - "iopub.status.idle": "2026-02-03T23:54:17.536459Z", - "shell.execute_reply": "2026-02-03T23:54:17.531891Z", - "shell.execute_reply.started": "2026-02-03T23:54:13.364190Z" + "iopub.execute_input": "2026-02-04T19:27:58.317468Z", + "iopub.status.busy": "2026-02-04T19:27:58.317130Z", + "iopub.status.idle": "2026-02-04T19:28:01.958351Z", + "shell.execute_reply": "2026-02-04T19:28:01.957857Z", + "shell.execute_reply.started": "2026-02-04T19:27:58.317439Z" } }, "outputs": [], @@ -445,17 +422,17 @@ "id": "094b1d30-c610-44ca-968b-7257aacbaa91", "metadata": { "execution": { - "iopub.execute_input": "2026-02-03T23:54:17.537597Z", - "iopub.status.busy": "2026-02-03T23:54:17.537171Z", - "iopub.status.idle": "2026-02-03T23:54:17.726852Z", - "shell.execute_reply": "2026-02-03T23:54:17.725928Z", - "shell.execute_reply.started": "2026-02-03T23:54:17.537572Z" + "iopub.execute_input": "2026-02-04T19:28:01.958934Z", + "iopub.status.busy": "2026-02-04T19:28:01.958736Z", + "iopub.status.idle": "2026-02-04T19:28:02.102238Z", + "shell.execute_reply": "2026-02-04T19:28:02.101300Z", + "shell.execute_reply.started": "2026-02-04T19:28:01.958914Z" } }, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -493,11 +470,11 @@ "id": "a4303772-cfe0-45ed-90ec-c1caad768f39", "metadata": { "execution": { - "iopub.execute_input": "2026-02-03T23:54:17.727650Z", - "iopub.status.busy": "2026-02-03T23:54:17.727395Z", - "iopub.status.idle": "2026-02-03T23:54:17.731224Z", - "shell.execute_reply": "2026-02-03T23:54:17.730233Z", - "shell.execute_reply.started": "2026-02-03T23:54:17.727624Z" + "iopub.execute_input": "2026-02-04T19:28:02.103183Z", + "iopub.status.busy": "2026-02-04T19:28:02.102962Z", + "iopub.status.idle": "2026-02-04T19:28:02.106461Z", + "shell.execute_reply": "2026-02-04T19:28:02.105624Z", + "shell.execute_reply.started": "2026-02-04T19:28:02.103162Z" } }, "outputs": [], @@ -511,11 +488,11 @@ "id": "956f31ab-ed45-432f-a788-15cf73febf14", "metadata": { "execution": { - "iopub.execute_input": "2026-02-03T23:54:17.732041Z", - "iopub.status.busy": "2026-02-03T23:54:17.731771Z", - "iopub.status.idle": "2026-02-03T23:54:17.759898Z", - "shell.execute_reply": "2026-02-03T23:54:17.759065Z", - "shell.execute_reply.started": "2026-02-03T23:54:17.732016Z" + "iopub.execute_input": "2026-02-04T19:28:02.107179Z", + "iopub.status.busy": "2026-02-04T19:28:02.106949Z", + "iopub.status.idle": "2026-02-04T19:28:02.128896Z", + "shell.execute_reply": "2026-02-04T19:28:02.128131Z", + "shell.execute_reply.started": "2026-02-04T19:28:02.107158Z" } }, "outputs": [], @@ -529,17 +506,17 @@ "id": "fd1dfb8c-fe88-4a46-b59e-70baaec550f7", "metadata": { "execution": { - "iopub.execute_input": "2026-02-03T23:54:17.760734Z", - "iopub.status.busy": "2026-02-03T23:54:17.760471Z", - "iopub.status.idle": "2026-02-03T23:54:17.960696Z", - "shell.execute_reply": "2026-02-03T23:54:17.959721Z", - "shell.execute_reply.started": "2026-02-03T23:54:17.760707Z" + "iopub.execute_input": "2026-02-04T19:28:02.129632Z", + "iopub.status.busy": "2026-02-04T19:28:02.129387Z", + "iopub.status.idle": "2026-02-04T19:28:02.279161Z", + "shell.execute_reply": "2026-02-04T19:28:02.278380Z", + "shell.execute_reply.started": "2026-02-04T19:28:02.129608Z" } }, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -561,11 +538,11 @@ "id": "e916f176-b4b7-427a-847c-a282f85640a5", "metadata": { "execution": { - "iopub.execute_input": "2026-02-03T23:54:17.961555Z", - "iopub.status.busy": "2026-02-03T23:54:17.961328Z", - "iopub.status.idle": "2026-02-03T23:54:18.488518Z", - "shell.execute_reply": "2026-02-03T23:54:18.487730Z", - "shell.execute_reply.started": "2026-02-03T23:54:17.961537Z" + "iopub.execute_input": "2026-02-04T19:28:02.279916Z", + "iopub.status.busy": "2026-02-04T19:28:02.279713Z", + "iopub.status.idle": "2026-02-04T19:28:02.784537Z", + "shell.execute_reply": "2026-02-04T19:28:02.783854Z", + "shell.execute_reply.started": "2026-02-04T19:28:02.279883Z" } }, "outputs": [ @@ -613,11 +590,11 @@ "id": "931c7ff0-0f45-40cb-8227-c78e97823f79", "metadata": { "execution": { - "iopub.execute_input": "2026-02-03T23:54:18.491309Z", - "iopub.status.busy": "2026-02-03T23:54:18.491072Z", - "iopub.status.idle": "2026-02-03T23:54:18.495111Z", - "shell.execute_reply": "2026-02-03T23:54:18.494309Z", - "shell.execute_reply.started": "2026-02-03T23:54:18.491287Z" + "iopub.execute_input": "2026-02-04T19:28:02.785563Z", + "iopub.status.busy": "2026-02-04T19:28:02.785350Z", + "iopub.status.idle": "2026-02-04T19:28:02.789859Z", + "shell.execute_reply": "2026-02-04T19:28:02.788714Z", + "shell.execute_reply.started": "2026-02-04T19:28:02.785547Z" } }, "outputs": [], @@ -636,30 +613,32 @@ "id": "c862c062-c7e2-4d7b-8825-109fa7072bdd", "metadata": { "execution": { - "iopub.execute_input": "2026-02-03T23:54:18.496030Z", - "iopub.status.busy": "2026-02-03T23:54:18.495764Z", - "iopub.status.idle": "2026-02-03T23:54:18.510577Z", - "shell.execute_reply": "2026-02-03T23:54:18.509539Z", - "shell.execute_reply.started": "2026-02-03T23:54:18.496004Z" + "iopub.execute_input": "2026-02-04T19:28:02.791237Z", + "iopub.status.busy": "2026-02-04T19:28:02.790767Z", + "iopub.status.idle": "2026-02-04T19:28:02.797897Z", + "shell.execute_reply": "2026-02-04T19:28:02.796998Z", + "shell.execute_reply.started": "2026-02-04T19:28:02.791205Z" } }, "outputs": [], "source": [ "uncertainties = stderr * np.ones(gz.size)\n", - "data_misfit = ii.DataMisfit(gz.ravel(), uncertainties, simulation, model_slice=wires.density)" + "data_misfit = ii.DataMisfit(\n", + " gz.ravel(), uncertainties, simulation, model_slice=wires.density\n", + ")" ] }, { "cell_type": "code", - "execution_count": 21, + "execution_count": 20, "id": "9042f903-4d02-4abe-9de1-2dfacfb3b3a0", "metadata": { "execution": { - "iopub.execute_input": "2026-02-03T23:54:27.643929Z", - "iopub.status.busy": "2026-02-03T23:54:27.643726Z", - "iopub.status.idle": "2026-02-03T23:54:27.649084Z", - "shell.execute_reply": "2026-02-03T23:54:27.648496Z", - "shell.execute_reply.started": "2026-02-03T23:54:27.643912Z" + "iopub.execute_input": "2026-02-04T19:28:02.798994Z", + "iopub.status.busy": "2026-02-04T19:28:02.798702Z", + "iopub.status.idle": "2026-02-04T19:28:02.807043Z", + "shell.execute_reply": "2026-02-04T19:28:02.805985Z", + "shell.execute_reply.started": "2026-02-04T19:28:02.798961Z" } }, "outputs": [], @@ -680,15 +659,15 @@ }, { "cell_type": "code", - "execution_count": 22, + "execution_count": 21, "id": "ae115d7f-6b08-4c4e-b5f3-7277c24a49e4", "metadata": { "execution": { - "iopub.execute_input": "2026-02-03T23:54:34.724980Z", - "iopub.status.busy": "2026-02-03T23:54:34.724684Z", - "iopub.status.idle": "2026-02-03T23:54:34.728022Z", - "shell.execute_reply": "2026-02-03T23:54:34.727250Z", - "shell.execute_reply.started": "2026-02-03T23:54:34.724953Z" + "iopub.execute_input": "2026-02-04T19:28:02.808117Z", + "iopub.status.busy": "2026-02-04T19:28:02.807846Z", + "iopub.status.idle": "2026-02-04T19:28:02.812311Z", + "shell.execute_reply": "2026-02-04T19:28:02.810873Z", + "shell.execute_reply.started": "2026-02-04T19:28:02.808090Z" } }, "outputs": [], @@ -706,15 +685,15 @@ }, { "cell_type": "code", - "execution_count": 23, + "execution_count": 22, "id": "dbc4da3d", "metadata": { "execution": { - "iopub.execute_input": "2026-02-03T23:54:36.073034Z", - "iopub.status.busy": "2026-02-03T23:54:36.072825Z", - "iopub.status.idle": "2026-02-03T23:54:36.077563Z", - "shell.execute_reply": "2026-02-03T23:54:36.076825Z", - "shell.execute_reply.started": "2026-02-03T23:54:36.073014Z" + "iopub.execute_input": "2026-02-04T19:28:02.813590Z", + "iopub.status.busy": "2026-02-04T19:28:02.813240Z", + "iopub.status.idle": "2026-02-04T19:28:02.819088Z", + "shell.execute_reply": "2026-02-04T19:28:02.817832Z", + "shell.execute_reply.started": "2026-02-04T19:28:02.813567Z" } }, "outputs": [ @@ -724,7 +703,7 @@ "array([0., 0., 0., ..., 0., 0., 0.], shape=(64003,))" ] }, - "execution_count": 23, + "execution_count": 22, "metadata": {}, "output_type": "execute_result" } @@ -736,35 +715,46 @@ }, { "cell_type": "code", - "execution_count": 24, + "execution_count": 23, "id": "463b4e7b", "metadata": { "execution": { - "iopub.execute_input": "2026-02-03T23:54:37.581854Z", - "iopub.status.busy": "2026-02-03T23:54:37.581585Z", - "iopub.status.idle": "2026-02-03T23:54:37.585141Z", - "shell.execute_reply": "2026-02-03T23:54:37.584222Z", - "shell.execute_reply.started": "2026-02-03T23:54:37.581829Z" + "iopub.execute_input": "2026-02-04T19:28:02.819803Z", + "iopub.status.busy": "2026-02-04T19:28:02.819587Z", + "iopub.status.idle": "2026-02-04T19:28:03.793002Z", + "shell.execute_reply": "2026-02-04T19:28:03.791588Z", + "shell.execute_reply.started": "2026-02-04T19:28:02.819780Z" } }, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 23, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ - "# Ignore preconditioner for now, the DataMisfit doesn't support it yet for model slices\n", - "# preconditioner = ii.get_jacobi_preconditioner(phi, initial_model)\n", - "# preconditioner" + "preconditioner = ii.get_jacobi_preconditioner(phi, initial_model)\n", + "preconditioner" ] }, { "cell_type": "code", - "execution_count": 25, + "execution_count": 24, "id": "e2dfb4e8-1996-4f3f-8b05-781fc2d4537c", "metadata": { "execution": { - "iopub.execute_input": "2026-02-03T23:54:38.009674Z", - "iopub.status.busy": "2026-02-03T23:54:38.009460Z", - "iopub.status.idle": "2026-02-03T23:54:59.820879Z", - "shell.execute_reply": "2026-02-03T23:54:59.816589Z", - "shell.execute_reply.started": "2026-02-03T23:54:38.009656Z" + "iopub.execute_input": "2026-02-04T19:28:03.794143Z", + "iopub.status.busy": "2026-02-04T19:28:03.793915Z", + "iopub.status.idle": "2026-02-04T19:28:08.178633Z", + "shell.execute_reply": "2026-02-04T19:28:08.177924Z", + "shell.execute_reply.started": "2026-02-04T19:28:03.794124Z" } }, "outputs": [ @@ -772,7 +762,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "Elapsed time (no preconditioner): 21.80s\n" + "Elapsed time (no preconditioner): 4.38s\n" ] } ], @@ -780,33 +770,35 @@ "import time\n", "\n", "start = time.time()\n", - "inverted_model = ii.conjugate_gradient(phi, initial_model, rtol=1e-6)\n", + "inverted_model = ii.conjugate_gradient(\n", + " phi, initial_model, preconditioner=preconditioner\n", + ")\n", "end = time.time()\n", "print(f\"Elapsed time (no preconditioner): {end - start:.2f}s\")" ] }, { "cell_type": "code", - "execution_count": 26, + "execution_count": 25, "id": "82c1ddc2-d886-4cd1-a42d-1c32af5d4465", "metadata": { "execution": { - "iopub.execute_input": "2026-02-03T23:56:14.078649Z", - "iopub.status.busy": "2026-02-03T23:56:14.078438Z", - "iopub.status.idle": "2026-02-03T23:56:14.082613Z", - "shell.execute_reply": "2026-02-03T23:56:14.081840Z", - "shell.execute_reply.started": "2026-02-03T23:56:14.078631Z" + "iopub.execute_input": "2026-02-04T19:28:08.179556Z", + "iopub.status.busy": "2026-02-04T19:28:08.179163Z", + "iopub.status.idle": "2026-02-04T19:28:08.183476Z", + "shell.execute_reply": "2026-02-04T19:28:08.182751Z", + "shell.execute_reply.started": "2026-02-04T19:28:08.179534Z" } }, "outputs": [ { "data": { "text/plain": [ - "array([-0.00012583, -0.0001243 , -0.00012219, ..., 0. ,\n", + "array([-0.00010969, -0.00011732, -0.0001238 , ..., 0. ,\n", " 0. , 0. ], shape=(64003,))" ] }, - "execution_count": 26, + "execution_count": 25, "metadata": {}, "output_type": "execute_result" } @@ -817,27 +809,27 @@ }, { "cell_type": "code", - "execution_count": 27, + "execution_count": 26, "id": "05ef6fdf-55c0-4911-9ac8-2041af49b3cd", "metadata": { "execution": { - "iopub.execute_input": "2026-02-03T23:56:15.148655Z", - "iopub.status.busy": "2026-02-03T23:56:15.148347Z", - "iopub.status.idle": "2026-02-03T23:56:15.154060Z", - "shell.execute_reply": "2026-02-03T23:56:15.153168Z", - "shell.execute_reply.started": "2026-02-03T23:56:15.148629Z" + "iopub.execute_input": "2026-02-04T19:28:08.184233Z", + "iopub.status.busy": "2026-02-04T19:28:08.184018Z", + "iopub.status.idle": "2026-02-04T19:28:08.188655Z", + "shell.execute_reply": "2026-02-04T19:28:08.188119Z", + "shell.execute_reply.started": "2026-02-04T19:28:08.184211Z" } }, "outputs": [ { "data": { "text/plain": [ - "{'density': array([-0.00012583, -0.0001243 , -0.00012219, ..., -0.00049973,\n", - " 0.0006469 , -0.00042525], shape=(64000,)),\n", + "{'density': array([-0.00010969, -0.00011732, -0.0001238 , ..., -0.00050626,\n", + " 0.0006502 , -0.00043861], shape=(64000,)),\n", " 'dummy': array([0., 0., 0.])}" ] }, - "execution_count": 27, + "execution_count": 26, "metadata": {}, "output_type": "execute_result" } @@ -849,26 +841,26 @@ }, { "cell_type": "code", - "execution_count": 28, + "execution_count": 27, "id": "d20f5357-efd0-42cb-a156-90fcd6b41f0b", "metadata": { "execution": { - "iopub.execute_input": "2026-02-03T23:56:16.474672Z", - "iopub.status.busy": "2026-02-03T23:56:16.474402Z", - "iopub.status.idle": "2026-02-03T23:56:16.479352Z", - "shell.execute_reply": "2026-02-03T23:56:16.478304Z", - "shell.execute_reply.started": "2026-02-03T23:56:16.474649Z" + "iopub.execute_input": "2026-02-04T19:28:08.189649Z", + "iopub.status.busy": "2026-02-04T19:28:08.189300Z", + "iopub.status.idle": "2026-02-04T19:28:08.198773Z", + "shell.execute_reply": "2026-02-04T19:28:08.197891Z", + "shell.execute_reply.started": "2026-02-04T19:28:08.189625Z" } }, "outputs": [ { "data": { "text/plain": [ - "array([-0.00012583, -0.0001243 , -0.00012219, ..., -0.00049973,\n", - " 0.0006469 , -0.00042525], shape=(64000,))" + "array([-0.00010969, -0.00011732, -0.0001238 , ..., -0.00050626,\n", + " 0.0006502 , -0.00043861], shape=(64000,))" ] }, - "execution_count": 28, + "execution_count": 27, "metadata": {}, "output_type": "execute_result" } @@ -880,31 +872,31 @@ }, { "cell_type": "code", - "execution_count": 29, + "execution_count": 28, "id": "70b2b5ea-d6dd-4cf3-855c-9e8fd600c7cd", "metadata": { "execution": { - "iopub.execute_input": "2026-02-03T23:56:17.049006Z", - "iopub.status.busy": "2026-02-03T23:56:17.048797Z", - "iopub.status.idle": "2026-02-03T23:56:17.189304Z", - "shell.execute_reply": "2026-02-03T23:56:17.188241Z", - "shell.execute_reply.started": "2026-02-03T23:56:17.048988Z" + "iopub.execute_input": "2026-02-04T19:28:08.199447Z", + "iopub.status.busy": "2026-02-04T19:28:08.199216Z", + "iopub.status.idle": "2026-02-04T19:28:08.352564Z", + "shell.execute_reply": "2026-02-04T19:28:08.351314Z", + "shell.execute_reply.started": "2026-02-04T19:28:08.199424Z" } }, "outputs": [ { "data": { "text/plain": [ - "(,)" + "(,)" ] }, - "execution_count": 29, + "execution_count": 28, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] From 9e25e24714cc228815d54514115cbcb043d8fa36 Mon Sep 17 00:00:00 2001 From: Santiago Soler Date: Wed, 4 Feb 2026 13:27:12 -0800 Subject: [PATCH 11/47] Fix type hint --- src/inversion_ideas/operators.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/inversion_ideas/operators.py b/src/inversion_ideas/operators.py index e7b748b..ec7b1d1 100644 --- a/src/inversion_ideas/operators.py +++ b/src/inversion_ideas/operators.py @@ -41,7 +41,7 @@ def __init__( self, block: npt.NDArray | LinearOperator | sparray, index_start: int, - n_cols: tuple[int, int], + n_cols: int, ): # TODO: raise error if the block matrix has more columns than n_cols shape = (block.shape[0], n_cols) From 7ce5f65d81341bbb5d0e1bddda9e4d26ab109db2 Mon Sep 17 00:00:00 2001 From: Santiago Soler Date: Wed, 4 Feb 2026 14:09:06 -0800 Subject: [PATCH 12/47] Improve docstring in DataMisfit --- src/inversion_ideas/data_misfit.py | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/src/inversion_ideas/data_misfit.py b/src/inversion_ideas/data_misfit.py index 3e82a00..5ad5259 100644 --- a/src/inversion_ideas/data_misfit.py +++ b/src/inversion_ideas/data_misfit.py @@ -235,8 +235,9 @@ def _get_jacobian(self, model) -> npt.NDArray | LinearOperator | BlockColumnMatr """ Return the jacobian of the simulation. - This private method is intended to simplify code throughout the public ones when - dealing with ``model_slice`` not ``None``. + Make use of the ``model_slice`` to expand the jacobian if ``model_slice`` is not + ``None``. This private method is intended to simplify code throughout the public + ones when dealing with ``model_slice`` not ``None``. Parameters ---------- From da9c49d0cf59fbdd62d3b22c12916353a87d1ce3 Mon Sep 17 00:00:00 2001 From: Santiago Soler Date: Wed, 4 Feb 2026 14:09:34 -0800 Subject: [PATCH 13/47] Support model_slice in Smallness --- .../regularization/_mesh_based.py | 51 +++++++++++++++++-- 1 file changed, 47 insertions(+), 4 deletions(-) diff --git a/src/inversion_ideas/regularization/_mesh_based.py b/src/inversion_ideas/regularization/_mesh_based.py index 793e36f..8edcbc3 100644 --- a/src/inversion_ideas/regularization/_mesh_based.py +++ b/src/inversion_ideas/regularization/_mesh_based.py @@ -2,15 +2,20 @@ Regularization classes for mesh-based inversion problems. """ +from types import NoneType import discretize import numpy as np import numpy.typing as npt +from scipy.sparse.linalg import aslinearoperator import simpeg from scipy.sparse import dia_array, diags_array, eye_array +from inversion_ideas.operators import BlockColumnMatrix + from .._utils import prod_arrays from ..base import Objective from ..typing import Model +from ..wires import ModelSlice class _MeshBasedRegularization(Objective): @@ -24,6 +29,12 @@ class _MeshBasedRegularization(Objective): @property def n_params(self) -> int: + if (model_slice := getattr(self, "model_slice", None)) is not None: + return model_slice.full_size + return self.n_active + + @property + def n_active(self) -> int: return int(np.sum(self.active_cells)) @property @@ -48,7 +59,7 @@ def cell_weights( "It must be an array or a dictionary." ) raise TypeError(msg) - if isinstance(value, np.ndarray) and value.size != self.n_params: + if isinstance(value, np.ndarray) and value.size != self.n_active: msg = ( f"Invalid cell_weights array with '{value.size}' elements. " f"It must have '{self.n_params}' elements, " @@ -57,7 +68,7 @@ def cell_weights( raise ValueError(msg) if isinstance(value, dict): for key, array in value.items(): - if array.size != self.n_params: + if array.size != self.n_active: msg = ( f"Invalid cell_weights array '{key}' with " f"'{array.size}' elements. " @@ -81,7 +92,7 @@ class Smallness(_MeshBasedRegularization): active_cells : (n_cells) array or None, optional Array full of bools that indicate the active cells in the mesh. It must have the same amount of elements as cells in the mesh. - cell_weights : (n_params) array or dict of (n_params) arrays or None, optional + cell_weights : (n_active) array or dict of (n_active) arrays or None, optional Array with cell weights. For multiple cell weights, pass a dictionary where keys are strings and values are the different weights arrays. @@ -138,6 +149,7 @@ def __init__( active_cells: npt.NDArray[np.bool] | None = None, cell_weights: npt.NDArray | dict[str, npt.NDArray] | None = None, reference_model: Model | None = None, + model_slice: ModelSlice | None = None, ): self.mesh = mesh self.active_cells = ( @@ -145,12 +157,14 @@ def __init__( if active_cells is not None else np.ones(self.mesh.n_cells, dtype=bool) ) + # assign model_slice after active_cells so n_params is correct during __init__ + self.model_slice = model_slice # Assign the cell weights through the setter self.cell_weights = ( cell_weights if cell_weights is not None - else np.ones(self.n_params, dtype=np.float64) + else np.ones(self.n_active, dtype=np.float64) ) self.reference_model = ( @@ -172,6 +186,11 @@ def __call__(self, model: Model) -> float: model_diff = model - self.reference_model weights_matrix = self.weights_matrix cell_volumes_sqrt = self._volumes_sqrt_matrix + + if self.model_slice is not None: + weights_matrix = aslinearoperator(weights_matrix) + cell_volumes_sqrt = self.model_slice.expand_matrix(cell_volumes_sqrt) + return ( model_diff.T @ cell_volumes_sqrt.T @@ -193,6 +212,11 @@ def gradient(self, model: Model): model_diff = model - self.reference_model weights_matrix = self.weights_matrix cell_volumes_sqrt = self._volumes_sqrt_matrix + + if self.model_slice is not None: + weights_matrix = aslinearoperator(weights_matrix) + cell_volumes_sqrt = self.model_slice.expand_matrix(cell_volumes_sqrt) + return ( 2 * cell_volumes_sqrt.T @@ -213,6 +237,11 @@ def hessian(self, model: Model): # noqa: ARG002 """ weights_matrix = self.weights_matrix cell_volumes_sqrt = self._volumes_sqrt_matrix + + if self.model_slice is not None: + weights_matrix = aslinearoperator(weights_matrix) + cell_volumes_sqrt = self.model_slice.expand_matrix(cell_volumes_sqrt) + return ( 2 * cell_volumes_sqrt.T @@ -230,6 +259,20 @@ def hessian_diagonal(self, model: Model) -> npt.NDArray[np.float64]: model : (n_params) array Array with model values. """ + # Patch: compute the diagonal again, but this should be avoided + if self.model_slice is not None: + weights_matrix = self.weights_matrix + cell_volumes_sqrt = self._volumes_sqrt_matrix + hessian_diagonal = ( + 2 + * cell_volumes_sqrt.T + @ weights_matrix.T + @ weights_matrix + @ cell_volumes_sqrt + ).diagonal() + hessian_diagonal = self.model_slice.expand_array(hessian_diagonal) + return hessian_diagonal + return self.hessian(model).diagonal() @property From 09156419dd8a7dcf214b6a00ae264accc3decc53 Mon Sep 17 00:00:00 2001 From: Santiago Soler Date: Wed, 4 Feb 2026 14:10:29 -0800 Subject: [PATCH 14/47] Rerun notebook --- ...0_gravity-inversion-with-model-slice.ipynb | 304 +++++++++--------- 1 file changed, 150 insertions(+), 154 deletions(-) diff --git a/notebooks/50_gravity-inversion-with-model-slice.ipynb b/notebooks/50_gravity-inversion-with-model-slice.ipynb index 3ea7529..74a922d 100644 --- a/notebooks/50_gravity-inversion-with-model-slice.ipynb +++ b/notebooks/50_gravity-inversion-with-model-slice.ipynb @@ -14,11 +14,11 @@ "id": "b2d27e8b-5b33-4361-990b-8b6e724f5ac6", "metadata": { "execution": { - "iopub.execute_input": "2026-02-04T19:27:54.819942Z", - "iopub.status.busy": "2026-02-04T19:27:54.819673Z", - "iopub.status.idle": "2026-02-04T19:27:56.674222Z", - "shell.execute_reply": "2026-02-04T19:27:56.673045Z", - "shell.execute_reply.started": "2026-02-04T19:27:54.819912Z" + "iopub.execute_input": "2026-02-04T22:09:58.787010Z", + "iopub.status.busy": "2026-02-04T22:09:58.786798Z", + "iopub.status.idle": "2026-02-04T22:10:00.537793Z", + "shell.execute_reply": "2026-02-04T22:10:00.536759Z", + "shell.execute_reply.started": "2026-02-04T22:09:58.786984Z" } }, "outputs": [], @@ -54,11 +54,11 @@ "id": "dfce90d3-de10-43d3-a668-696993b0f73e", "metadata": { "execution": { - "iopub.execute_input": "2026-02-04T19:27:56.674867Z", - "iopub.status.busy": "2026-02-04T19:27:56.674580Z", - "iopub.status.idle": "2026-02-04T19:27:56.679493Z", - "shell.execute_reply": "2026-02-04T19:27:56.678034Z", - "shell.execute_reply.started": "2026-02-04T19:27:56.674851Z" + "iopub.execute_input": "2026-02-04T22:10:00.538588Z", + "iopub.status.busy": "2026-02-04T22:10:00.538249Z", + "iopub.status.idle": "2026-02-04T22:10:00.543227Z", + "shell.execute_reply": "2026-02-04T22:10:00.541996Z", + "shell.execute_reply.started": "2026-02-04T22:10:00.538571Z" } }, "outputs": [], @@ -81,11 +81,11 @@ "id": "2403d600-451e-424e-8de9-3f824f1e2647", "metadata": { "execution": { - "iopub.execute_input": "2026-02-04T19:27:56.680521Z", - "iopub.status.busy": "2026-02-04T19:27:56.680191Z", - "iopub.status.idle": "2026-02-04T19:27:57.893459Z", - "shell.execute_reply": "2026-02-04T19:27:57.892530Z", - "shell.execute_reply.started": "2026-02-04T19:27:56.680493Z" + "iopub.execute_input": "2026-02-04T22:10:00.544429Z", + "iopub.status.busy": "2026-02-04T22:10:00.544093Z", + "iopub.status.idle": "2026-02-04T22:10:01.808256Z", + "shell.execute_reply": "2026-02-04T22:10:01.807116Z", + "shell.execute_reply.started": "2026-02-04T22:10:00.544400Z" } }, "outputs": [ @@ -114,11 +114,11 @@ "id": "9612913a-b699-4ad4-8fe7-cbf83376f5d8", "metadata": { "execution": { - "iopub.execute_input": "2026-02-04T19:27:57.894459Z", - "iopub.status.busy": "2026-02-04T19:27:57.894254Z", - "iopub.status.idle": "2026-02-04T19:27:58.046763Z", - "shell.execute_reply": "2026-02-04T19:27:58.045901Z", - "shell.execute_reply.started": "2026-02-04T19:27:57.894444Z" + "iopub.execute_input": "2026-02-04T22:10:01.809184Z", + "iopub.status.busy": "2026-02-04T22:10:01.808949Z", + "iopub.status.idle": "2026-02-04T22:10:01.956821Z", + "shell.execute_reply": "2026-02-04T22:10:01.955868Z", + "shell.execute_reply.started": "2026-02-04T22:10:01.809159Z" } }, "outputs": [ @@ -146,11 +146,11 @@ "id": "f6d55c30-c5c9-4376-bc6d-ece83805b2d2", "metadata": { "execution": { - "iopub.execute_input": "2026-02-04T19:27:58.047478Z", - "iopub.status.busy": "2026-02-04T19:27:58.047265Z", - "iopub.status.idle": "2026-02-04T19:27:58.053037Z", - "shell.execute_reply": "2026-02-04T19:27:58.051741Z", - "shell.execute_reply.started": "2026-02-04T19:27:58.047455Z" + "iopub.execute_input": "2026-02-04T22:10:01.957765Z", + "iopub.status.busy": "2026-02-04T22:10:01.957524Z", + "iopub.status.idle": "2026-02-04T22:10:01.963031Z", + "shell.execute_reply": "2026-02-04T22:10:01.962003Z", + "shell.execute_reply.started": "2026-02-04T22:10:01.957739Z" } }, "outputs": [ @@ -183,11 +183,11 @@ "id": "0edbb620-6a62-48bf-a8af-8981a76cc6f4", "metadata": { "execution": { - "iopub.execute_input": "2026-02-04T19:27:58.053840Z", - "iopub.status.busy": "2026-02-04T19:27:58.053497Z", - "iopub.status.idle": "2026-02-04T19:27:58.063265Z", - "shell.execute_reply": "2026-02-04T19:27:58.062323Z", - "shell.execute_reply.started": "2026-02-04T19:27:58.053820Z" + "iopub.execute_input": "2026-02-04T22:10:01.964161Z", + "iopub.status.busy": "2026-02-04T22:10:01.963825Z", + "iopub.status.idle": "2026-02-04T22:10:01.972097Z", + "shell.execute_reply": "2026-02-04T22:10:01.970861Z", + "shell.execute_reply.started": "2026-02-04T22:10:01.964137Z" } }, "outputs": [ @@ -273,11 +273,11 @@ "id": "8a890b93-78ec-4681-bbb5-cc91e1448a85", "metadata": { "execution": { - "iopub.execute_input": "2026-02-04T19:27:58.064516Z", - "iopub.status.busy": "2026-02-04T19:27:58.064069Z", - "iopub.status.idle": "2026-02-04T19:27:58.069444Z", - "shell.execute_reply": "2026-02-04T19:27:58.068198Z", - "shell.execute_reply.started": "2026-02-04T19:27:58.064487Z" + "iopub.execute_input": "2026-02-04T22:10:01.973594Z", + "iopub.status.busy": "2026-02-04T22:10:01.973283Z", + "iopub.status.idle": "2026-02-04T22:10:01.978232Z", + "shell.execute_reply": "2026-02-04T22:10:01.977014Z", + "shell.execute_reply.started": "2026-02-04T22:10:01.973562Z" } }, "outputs": [], @@ -294,11 +294,11 @@ "id": "1dd17123-2df8-45b6-9345-d5cb6f431d51", "metadata": { "execution": { - "iopub.execute_input": "2026-02-04T19:27:58.070299Z", - "iopub.status.busy": "2026-02-04T19:27:58.069976Z", - "iopub.status.idle": "2026-02-04T19:27:58.128211Z", - "shell.execute_reply": "2026-02-04T19:27:58.127338Z", - "shell.execute_reply.started": "2026-02-04T19:27:58.070261Z" + "iopub.execute_input": "2026-02-04T22:10:01.979308Z", + "iopub.status.busy": "2026-02-04T22:10:01.979035Z", + "iopub.status.idle": "2026-02-04T22:10:02.037139Z", + "shell.execute_reply": "2026-02-04T22:10:02.036209Z", + "shell.execute_reply.started": "2026-02-04T22:10:01.979274Z" } }, "outputs": [], @@ -312,11 +312,11 @@ "id": "b4c9ad67-47fe-4408-b879-d99b8eec8ca2", "metadata": { "execution": { - "iopub.execute_input": "2026-02-04T19:27:58.129105Z", - "iopub.status.busy": "2026-02-04T19:27:58.128786Z", - "iopub.status.idle": "2026-02-04T19:27:58.134440Z", - "shell.execute_reply": "2026-02-04T19:27:58.133064Z", - "shell.execute_reply.started": "2026-02-04T19:27:58.129076Z" + "iopub.execute_input": "2026-02-04T22:10:02.038364Z", + "iopub.status.busy": "2026-02-04T22:10:02.038127Z", + "iopub.status.idle": "2026-02-04T22:10:02.042409Z", + "shell.execute_reply": "2026-02-04T22:10:02.041428Z", + "shell.execute_reply.started": "2026-02-04T22:10:02.038340Z" } }, "outputs": [], @@ -333,11 +333,11 @@ "id": "ffc07711-d8e3-49cf-9574-f2bde45ceec8", "metadata": { "execution": { - "iopub.execute_input": "2026-02-04T19:27:58.135470Z", - "iopub.status.busy": "2026-02-04T19:27:58.135154Z", - "iopub.status.idle": "2026-02-04T19:27:58.144758Z", - "shell.execute_reply": "2026-02-04T19:27:58.143338Z", - "shell.execute_reply.started": "2026-02-04T19:27:58.135452Z" + "iopub.execute_input": "2026-02-04T22:10:02.043265Z", + "iopub.status.busy": "2026-02-04T22:10:02.043015Z", + "iopub.status.idle": "2026-02-04T22:10:02.052163Z", + "shell.execute_reply": "2026-02-04T22:10:02.051178Z", + "shell.execute_reply.started": "2026-02-04T22:10:02.043238Z" } }, "outputs": [ @@ -365,18 +365,18 @@ "id": "0b89b688-a595-4ff3-81e3-8bba4d4ef7c8", "metadata": { "execution": { - "iopub.execute_input": "2026-02-04T19:27:58.145702Z", - "iopub.status.busy": "2026-02-04T19:27:58.145467Z", - "iopub.status.idle": "2026-02-04T19:27:58.316506Z", - "shell.execute_reply": "2026-02-04T19:27:58.315508Z", - "shell.execute_reply.started": "2026-02-04T19:27:58.145678Z" + "iopub.execute_input": "2026-02-04T22:10:02.053261Z", + "iopub.status.busy": "2026-02-04T22:10:02.052950Z", + "iopub.status.idle": "2026-02-04T22:10:02.215148Z", + "shell.execute_reply": "2026-02-04T22:10:02.214339Z", + "shell.execute_reply.started": "2026-02-04T22:10:02.053232Z" } }, "outputs": [ { "data": { "text/plain": [ - "(,)" + "(,)" ] }, "execution_count": 11, @@ -404,11 +404,11 @@ "id": "ff50fbfa-9dd4-4c01-a8eb-245c3c0706a0", "metadata": { "execution": { - "iopub.execute_input": "2026-02-04T19:27:58.317468Z", - "iopub.status.busy": "2026-02-04T19:27:58.317130Z", - "iopub.status.idle": "2026-02-04T19:28:01.958351Z", - "shell.execute_reply": "2026-02-04T19:28:01.957857Z", - "shell.execute_reply.started": "2026-02-04T19:27:58.317439Z" + "iopub.execute_input": "2026-02-04T22:10:02.216314Z", + "iopub.status.busy": "2026-02-04T22:10:02.215999Z", + "iopub.status.idle": "2026-02-04T22:10:05.549873Z", + "shell.execute_reply": "2026-02-04T22:10:05.549326Z", + "shell.execute_reply.started": "2026-02-04T22:10:02.216279Z" } }, "outputs": [], @@ -422,11 +422,11 @@ "id": "094b1d30-c610-44ca-968b-7257aacbaa91", "metadata": { "execution": { - "iopub.execute_input": "2026-02-04T19:28:01.958934Z", - "iopub.status.busy": "2026-02-04T19:28:01.958736Z", - "iopub.status.idle": "2026-02-04T19:28:02.102238Z", - "shell.execute_reply": "2026-02-04T19:28:02.101300Z", - "shell.execute_reply.started": "2026-02-04T19:28:01.958914Z" + "iopub.execute_input": "2026-02-04T22:10:05.550779Z", + "iopub.status.busy": "2026-02-04T22:10:05.550434Z", + "iopub.status.idle": "2026-02-04T22:10:05.696070Z", + "shell.execute_reply": "2026-02-04T22:10:05.695267Z", + "shell.execute_reply.started": "2026-02-04T22:10:05.550757Z" } }, "outputs": [ @@ -470,11 +470,11 @@ "id": "a4303772-cfe0-45ed-90ec-c1caad768f39", "metadata": { "execution": { - "iopub.execute_input": "2026-02-04T19:28:02.103183Z", - "iopub.status.busy": "2026-02-04T19:28:02.102962Z", - "iopub.status.idle": "2026-02-04T19:28:02.106461Z", - "shell.execute_reply": "2026-02-04T19:28:02.105624Z", - "shell.execute_reply.started": "2026-02-04T19:28:02.103162Z" + "iopub.execute_input": "2026-02-04T22:10:05.697096Z", + "iopub.status.busy": "2026-02-04T22:10:05.696814Z", + "iopub.status.idle": "2026-02-04T22:10:05.700572Z", + "shell.execute_reply": "2026-02-04T22:10:05.699668Z", + "shell.execute_reply.started": "2026-02-04T22:10:05.697075Z" } }, "outputs": [], @@ -488,11 +488,11 @@ "id": "956f31ab-ed45-432f-a788-15cf73febf14", "metadata": { "execution": { - "iopub.execute_input": "2026-02-04T19:28:02.107179Z", - "iopub.status.busy": "2026-02-04T19:28:02.106949Z", - "iopub.status.idle": "2026-02-04T19:28:02.128896Z", - "shell.execute_reply": "2026-02-04T19:28:02.128131Z", - "shell.execute_reply.started": "2026-02-04T19:28:02.107158Z" + "iopub.execute_input": "2026-02-04T22:10:05.701281Z", + "iopub.status.busy": "2026-02-04T22:10:05.701036Z", + "iopub.status.idle": "2026-02-04T22:10:05.722105Z", + "shell.execute_reply": "2026-02-04T22:10:05.721475Z", + "shell.execute_reply.started": "2026-02-04T22:10:05.701255Z" } }, "outputs": [], @@ -506,11 +506,11 @@ "id": "fd1dfb8c-fe88-4a46-b59e-70baaec550f7", "metadata": { "execution": { - "iopub.execute_input": "2026-02-04T19:28:02.129632Z", - "iopub.status.busy": "2026-02-04T19:28:02.129387Z", - "iopub.status.idle": "2026-02-04T19:28:02.279161Z", - "shell.execute_reply": "2026-02-04T19:28:02.278380Z", - "shell.execute_reply.started": "2026-02-04T19:28:02.129608Z" + "iopub.execute_input": "2026-02-04T22:10:05.722778Z", + "iopub.status.busy": "2026-02-04T22:10:05.722549Z", + "iopub.status.idle": "2026-02-04T22:10:05.868509Z", + "shell.execute_reply": "2026-02-04T22:10:05.867429Z", + "shell.execute_reply.started": "2026-02-04T22:10:05.722755Z" } }, "outputs": [ @@ -538,11 +538,11 @@ "id": "e916f176-b4b7-427a-847c-a282f85640a5", "metadata": { "execution": { - "iopub.execute_input": "2026-02-04T19:28:02.279916Z", - "iopub.status.busy": "2026-02-04T19:28:02.279713Z", - "iopub.status.idle": "2026-02-04T19:28:02.784537Z", - "shell.execute_reply": "2026-02-04T19:28:02.783854Z", - "shell.execute_reply.started": "2026-02-04T19:28:02.279883Z" + "iopub.execute_input": "2026-02-04T22:10:05.869374Z", + "iopub.status.busy": "2026-02-04T22:10:05.869124Z", + "iopub.status.idle": "2026-02-04T22:10:06.318406Z", + "shell.execute_reply": "2026-02-04T22:10:06.317548Z", + "shell.execute_reply.started": "2026-02-04T22:10:05.869349Z" } }, "outputs": [ @@ -590,11 +590,11 @@ "id": "931c7ff0-0f45-40cb-8227-c78e97823f79", "metadata": { "execution": { - "iopub.execute_input": "2026-02-04T19:28:02.785563Z", - "iopub.status.busy": "2026-02-04T19:28:02.785350Z", - "iopub.status.idle": "2026-02-04T19:28:02.789859Z", - "shell.execute_reply": "2026-02-04T19:28:02.788714Z", - "shell.execute_reply.started": "2026-02-04T19:28:02.785547Z" + "iopub.execute_input": "2026-02-04T22:10:06.319349Z", + "iopub.status.busy": "2026-02-04T22:10:06.319087Z", + "iopub.status.idle": "2026-02-04T22:10:06.323399Z", + "shell.execute_reply": "2026-02-04T22:10:06.322262Z", + "shell.execute_reply.started": "2026-02-04T22:10:06.319325Z" } }, "outputs": [], @@ -613,19 +613,17 @@ "id": "c862c062-c7e2-4d7b-8825-109fa7072bdd", "metadata": { "execution": { - "iopub.execute_input": "2026-02-04T19:28:02.791237Z", - "iopub.status.busy": "2026-02-04T19:28:02.790767Z", - "iopub.status.idle": "2026-02-04T19:28:02.797897Z", - "shell.execute_reply": "2026-02-04T19:28:02.796998Z", - "shell.execute_reply.started": "2026-02-04T19:28:02.791205Z" + "iopub.execute_input": "2026-02-04T22:10:06.324455Z", + "iopub.status.busy": "2026-02-04T22:10:06.324131Z", + "iopub.status.idle": "2026-02-04T22:10:06.328879Z", + "shell.execute_reply": "2026-02-04T22:10:06.327578Z", + "shell.execute_reply.started": "2026-02-04T22:10:06.324426Z" } }, "outputs": [], "source": [ "uncertainties = stderr * np.ones(gz.size)\n", - "data_misfit = ii.DataMisfit(\n", - " gz.ravel(), uncertainties, simulation, model_slice=wires.density\n", - ")" + "data_misfit = ii.DataMisfit(gz.ravel(), uncertainties, simulation, model_slice=wires.density)" ] }, { @@ -634,11 +632,11 @@ "id": "9042f903-4d02-4abe-9de1-2dfacfb3b3a0", "metadata": { "execution": { - "iopub.execute_input": "2026-02-04T19:28:02.798994Z", - "iopub.status.busy": "2026-02-04T19:28:02.798702Z", - "iopub.status.idle": "2026-02-04T19:28:02.807043Z", - "shell.execute_reply": "2026-02-04T19:28:02.805985Z", - "shell.execute_reply.started": "2026-02-04T19:28:02.798961Z" + "iopub.execute_input": "2026-02-04T22:10:06.330141Z", + "iopub.status.busy": "2026-02-04T22:10:06.329750Z", + "iopub.status.idle": "2026-02-04T22:10:06.337141Z", + "shell.execute_reply": "2026-02-04T22:10:06.335787Z", + "shell.execute_reply.started": "2026-02-04T22:10:06.330095Z" } }, "outputs": [], @@ -646,15 +644,15 @@ "depth_weights = depth_weighting(mesh, 0) ** 2\n", "\n", "# Let's use a tikhonov zero for now, because I haven't implemented model slices in Smallness yet\n", - "# smallness = ii.Smallness(mesh=mesh, cell_weights=depth_weights)\n", + "smallness = ii.Smallness(mesh=mesh, cell_weights=depth_weights, model_slice=wires.density)\n", "\n", "# I need to manually combine weights for the density and weights for the dummy (just zeros).\n", "# This shouldn't be necessary if the regularization handles model slices too.\n", - "density_weights = mesh.cell_volumes * depth_weights\n", - "dummy_weights = np.zeros(wires.dummy.size)\n", - "weights = np.hstack((density_weights, dummy_weights))\n", + "# density_weights = mesh.cell_volumes * depth_weights\n", + "# dummy_weights = np.zeros(wires.dummy.size)\n", + "# weights = np.hstack((density_weights, dummy_weights))\n", "\n", - "smallness = ii.TikhonovZero(n_params=wires.size, weights=weights)" + "# smallness = ii.TikhonovZero(n_params=wires.size, weights=weights)" ] }, { @@ -663,11 +661,11 @@ "id": "ae115d7f-6b08-4c4e-b5f3-7277c24a49e4", "metadata": { "execution": { - "iopub.execute_input": "2026-02-04T19:28:02.808117Z", - "iopub.status.busy": "2026-02-04T19:28:02.807846Z", - "iopub.status.idle": "2026-02-04T19:28:02.812311Z", - "shell.execute_reply": "2026-02-04T19:28:02.810873Z", - "shell.execute_reply.started": "2026-02-04T19:28:02.808090Z" + "iopub.execute_input": "2026-02-04T22:10:06.338250Z", + "iopub.status.busy": "2026-02-04T22:10:06.337876Z", + "iopub.status.idle": "2026-02-04T22:10:06.342576Z", + "shell.execute_reply": "2026-02-04T22:10:06.341101Z", + "shell.execute_reply.started": "2026-02-04T22:10:06.338210Z" } }, "outputs": [], @@ -689,11 +687,11 @@ "id": "dbc4da3d", "metadata": { "execution": { - "iopub.execute_input": "2026-02-04T19:28:02.813590Z", - "iopub.status.busy": "2026-02-04T19:28:02.813240Z", - "iopub.status.idle": "2026-02-04T19:28:02.819088Z", - "shell.execute_reply": "2026-02-04T19:28:02.817832Z", - "shell.execute_reply.started": "2026-02-04T19:28:02.813567Z" + "iopub.execute_input": "2026-02-04T22:10:06.343407Z", + "iopub.status.busy": "2026-02-04T22:10:06.343157Z", + "iopub.status.idle": "2026-02-04T22:10:06.348438Z", + "shell.execute_reply": "2026-02-04T22:10:06.347465Z", + "shell.execute_reply.started": "2026-02-04T22:10:06.343380Z" } }, "outputs": [ @@ -719,11 +717,11 @@ "id": "463b4e7b", "metadata": { "execution": { - "iopub.execute_input": "2026-02-04T19:28:02.819803Z", - "iopub.status.busy": "2026-02-04T19:28:02.819587Z", - "iopub.status.idle": "2026-02-04T19:28:03.793002Z", - "shell.execute_reply": "2026-02-04T19:28:03.791588Z", - "shell.execute_reply.started": "2026-02-04T19:28:02.819780Z" + "iopub.execute_input": "2026-02-04T22:10:06.349099Z", + "iopub.status.busy": "2026-02-04T22:10:06.348906Z", + "iopub.status.idle": "2026-02-04T22:10:07.335070Z", + "shell.execute_reply": "2026-02-04T22:10:07.334110Z", + "shell.execute_reply.started": "2026-02-04T22:10:06.349081Z" } }, "outputs": [ @@ -750,11 +748,11 @@ "id": "e2dfb4e8-1996-4f3f-8b05-781fc2d4537c", "metadata": { "execution": { - "iopub.execute_input": "2026-02-04T19:28:03.794143Z", - "iopub.status.busy": "2026-02-04T19:28:03.793915Z", - "iopub.status.idle": "2026-02-04T19:28:08.178633Z", - "shell.execute_reply": "2026-02-04T19:28:08.177924Z", - "shell.execute_reply.started": "2026-02-04T19:28:03.794124Z" + "iopub.execute_input": "2026-02-04T22:10:07.335763Z", + "iopub.status.busy": "2026-02-04T22:10:07.335594Z", + "iopub.status.idle": "2026-02-04T22:10:11.413712Z", + "shell.execute_reply": "2026-02-04T22:10:11.413122Z", + "shell.execute_reply.started": "2026-02-04T22:10:07.335748Z" } }, "outputs": [ @@ -762,7 +760,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "Elapsed time (no preconditioner): 4.38s\n" + "Elapsed time (no preconditioner): 4.07s\n" ] } ], @@ -770,9 +768,7 @@ "import time\n", "\n", "start = time.time()\n", - "inverted_model = ii.conjugate_gradient(\n", - " phi, initial_model, preconditioner=preconditioner\n", - ")\n", + "inverted_model = ii.conjugate_gradient(phi, initial_model, preconditioner=preconditioner)\n", "end = time.time()\n", "print(f\"Elapsed time (no preconditioner): {end - start:.2f}s\")" ] @@ -783,11 +779,11 @@ "id": "82c1ddc2-d886-4cd1-a42d-1c32af5d4465", "metadata": { "execution": { - "iopub.execute_input": "2026-02-04T19:28:08.179556Z", - "iopub.status.busy": "2026-02-04T19:28:08.179163Z", - "iopub.status.idle": "2026-02-04T19:28:08.183476Z", - "shell.execute_reply": "2026-02-04T19:28:08.182751Z", - "shell.execute_reply.started": "2026-02-04T19:28:08.179534Z" + "iopub.execute_input": "2026-02-04T22:10:11.414326Z", + "iopub.status.busy": "2026-02-04T22:10:11.414114Z", + "iopub.status.idle": "2026-02-04T22:10:11.420851Z", + "shell.execute_reply": "2026-02-04T22:10:11.418759Z", + "shell.execute_reply.started": "2026-02-04T22:10:11.414306Z" } }, "outputs": [ @@ -813,11 +809,11 @@ "id": "05ef6fdf-55c0-4911-9ac8-2041af49b3cd", "metadata": { "execution": { - "iopub.execute_input": "2026-02-04T19:28:08.184233Z", - "iopub.status.busy": "2026-02-04T19:28:08.184018Z", - "iopub.status.idle": "2026-02-04T19:28:08.188655Z", - "shell.execute_reply": "2026-02-04T19:28:08.188119Z", - "shell.execute_reply.started": "2026-02-04T19:28:08.184211Z" + "iopub.execute_input": "2026-02-04T22:10:11.421566Z", + "iopub.status.busy": "2026-02-04T22:10:11.421334Z", + "iopub.status.idle": "2026-02-04T22:10:11.431604Z", + "shell.execute_reply": "2026-02-04T22:10:11.430654Z", + "shell.execute_reply.started": "2026-02-04T22:10:11.421544Z" } }, "outputs": [ @@ -845,11 +841,11 @@ "id": "d20f5357-efd0-42cb-a156-90fcd6b41f0b", "metadata": { "execution": { - "iopub.execute_input": "2026-02-04T19:28:08.189649Z", - "iopub.status.busy": "2026-02-04T19:28:08.189300Z", - "iopub.status.idle": "2026-02-04T19:28:08.198773Z", - "shell.execute_reply": "2026-02-04T19:28:08.197891Z", - "shell.execute_reply.started": "2026-02-04T19:28:08.189625Z" + "iopub.execute_input": "2026-02-04T22:10:11.437271Z", + "iopub.status.busy": "2026-02-04T22:10:11.436914Z", + "iopub.status.idle": "2026-02-04T22:10:11.446289Z", + "shell.execute_reply": "2026-02-04T22:10:11.445191Z", + "shell.execute_reply.started": "2026-02-04T22:10:11.437241Z" } }, "outputs": [ @@ -876,18 +872,18 @@ "id": "70b2b5ea-d6dd-4cf3-855c-9e8fd600c7cd", "metadata": { "execution": { - "iopub.execute_input": "2026-02-04T19:28:08.199447Z", - "iopub.status.busy": "2026-02-04T19:28:08.199216Z", - "iopub.status.idle": "2026-02-04T19:28:08.352564Z", - "shell.execute_reply": "2026-02-04T19:28:08.351314Z", - "shell.execute_reply.started": "2026-02-04T19:28:08.199424Z" + "iopub.execute_input": "2026-02-04T22:10:11.446959Z", + "iopub.status.busy": "2026-02-04T22:10:11.446753Z", + "iopub.status.idle": "2026-02-04T22:10:11.625001Z", + "shell.execute_reply": "2026-02-04T22:10:11.623804Z", + "shell.execute_reply.started": "2026-02-04T22:10:11.446937Z" } }, "outputs": [ { "data": { "text/plain": [ - "(,)" + "(,)" ] }, "execution_count": 28, From 16778c1b5437f83b5a72137c8ffabf527a2089ff Mon Sep 17 00:00:00 2001 From: Santiago Soler Date: Wed, 4 Feb 2026 16:05:04 -0800 Subject: [PATCH 15/47] Use a slicer matrix in DataMisfit instead of the BlockColumnMatrix --- src/inversion_ideas/data_misfit.py | 70 +++++++++++++++++------------- src/inversion_ideas/wires.py | 11 ++++- 2 files changed, 50 insertions(+), 31 deletions(-) diff --git a/src/inversion_ideas/data_misfit.py b/src/inversion_ideas/data_misfit.py index 5ad5259..fa86bde 100644 --- a/src/inversion_ideas/data_misfit.py +++ b/src/inversion_ideas/data_misfit.py @@ -4,7 +4,7 @@ import numpy as np import numpy.typing as npt -from scipy.sparse import dia_array, diags_array, sparray +from scipy.sparse import dia_array, diags_array, sparray, eye_array from scipy.sparse.linalg import LinearOperator, aslinearoperator from .base import Objective @@ -113,8 +113,12 @@ def gradient(self, model: Model) -> npt.NDArray[np.float64]: """ jac = self._get_jacobian(model) weights_matrix = self.weights_matrix + slicer_matrix = self._get_slicer_matrix() gradient = ( - 2 * jac.T @ (weights_matrix.T @ weights_matrix @ self.residual(model)) + 2 + * slicer_matrix.T + @ jac.T + @ (weights_matrix.T @ weights_matrix @ self.residual(model)) ) return gradient @@ -126,9 +130,18 @@ def hessian( """ jac = self._get_jacobian(model) weights_matrix = aslinearoperator(self.weights_matrix) + slicer_matrix = aslinearoperator(self._get_slicer_matrix()) if not self.build_hessian: jac = aslinearoperator(jac) - return 2 * jac.T @ weights_matrix.T @ weights_matrix @ jac + return ( + 2 + * slicer_matrix.T + @ jac.T + @ weights_matrix.T + @ weights_matrix + @ jac + @ slicer_matrix + ) def hessian_diagonal(self, model: Model) -> npt.NDArray[np.float64]: """ @@ -136,25 +149,15 @@ def hessian_diagonal(self, model: Model) -> npt.NDArray[np.float64]: """ jac = self._get_jacobian(model) if isinstance(jac, LinearOperator): - # If the linear operator implements the get_column method, we could use it - # to approximate the diagonal of the hessian. - # TODO: we can transform this into a Protocol. - if not hasattr(jac, "get_column"): - msg = ( - "`DataMisfit.hessian_diagonal()` is not implemented for simulations " - "that return the jacobian as a LinearOperator." - ) - raise NotImplementedError(msg) - weights_diagonal = self.weights_matrix.diagonal() - jtj_diag = np.array( - [ - np.sum(weights_diagonal * jac.get_column(i) ** 2) - for i in range(jac.shape[1]) - ] + msg = ( + "`DataMisfit.hessian_diagonal()` is not implemented for simulations " + "that return the jacobian as a LinearOperator." ) - else: - jtj_diag = np.einsum("i,ij,ij->j", self.weights_matrix.diagonal(), jac, jac) - return 2 * jtj_diag + raise NotImplementedError(msg) + + jtj_diag = np.einsum("i,ij,ij->j", self.weights_matrix.diagonal(), jac, jac) + slicer_matrix = self._get_slicer_matrix() + return 2 * slicer_matrix.T @ jtj_diag @property def n_params(self): @@ -209,7 +212,7 @@ def weights(self) -> npt.NDArray[np.float64]: return 1 / self.uncertainty**2 @property - def weights_matrix(self) -> dia_array: + def weights_matrix(self) -> dia_array[np.float64]: """ Diagonal matrix with the square root of the regularization weights. """ @@ -231,13 +234,11 @@ def chi_factor(self, model: Model): """ return self(model) / self.n_data - def _get_jacobian(self, model) -> npt.NDArray | LinearOperator | BlockColumnMatrix: + def _get_jacobian( + self, model: Model + ) -> npt.NDArray[np.float64] | LinearOperator | BlockColumnMatrix: """ - Return the jacobian of the simulation. - - Make use of the ``model_slice`` to expand the jacobian if ``model_slice`` is not - ``None``. This private method is intended to simplify code throughout the public - ones when dealing with ``model_slice`` not ``None``. + Return the jacobian of the simulation evaluated on the passed model. Parameters ---------- @@ -249,6 +250,15 @@ def _get_jacobian(self, model) -> npt.NDArray | LinearOperator | BlockColumnMatr jac = self.simulation.jacobian( model if self.model_slice is None else self.model_slice.extract(model) ) - if self.model_slice is not None: - jac = self.model_slice.expand_matrix(jac) return jac + + def _get_slicer_matrix(self) -> dia_array[np.float64]: + """ + Return ``model_slicer.slicer_matrix`` or just a diagonal array. + """ + slicer_matrix = ( + self.model_slice.slice_matrix + if self.model_slice is not None + else eye_array(self.n_params, dtype=np.float64) + ) + return slicer_matrix diff --git a/src/inversion_ideas/wires.py b/src/inversion_ideas/wires.py index 48d0de7..8fa5cff 100644 --- a/src/inversion_ideas/wires.py +++ b/src/inversion_ideas/wires.py @@ -6,7 +6,7 @@ import numpy as np import numpy.typing as npt -from scipy.sparse import sparray +from scipy.sparse import dia_array, diags_array, sparray from scipy.sparse.linalg import LinearOperator from .operators import BlockColumnMatrix @@ -128,6 +128,15 @@ def full_size(self) -> int: def wires(self) -> Wires: return self._wires + @property + def slice_matrix(self) -> dia_array[np.float64]: + """ + Return a matrix that can be used to slice a model array. + """ + ones = np.ones(self.size) + shape = (self.size, self.full_size) + return diags_array(ones, offsets=self.slice.start, shape=shape, dtype=np.float64) + def extract(self, model: Model): if model.size != self.wires.size: # TODO: add msg From 5e09873ff4dc5f16d5c513f5cceef914d68b7f24 Mon Sep 17 00:00:00 2001 From: Santiago Soler Date: Wed, 4 Feb 2026 16:21:01 -0800 Subject: [PATCH 16/47] Make use of the slicer matrix in Smallness --- .../regularization/_mesh_based.py | 54 +++++++++---------- 1 file changed, 24 insertions(+), 30 deletions(-) diff --git a/src/inversion_ideas/regularization/_mesh_based.py b/src/inversion_ideas/regularization/_mesh_based.py index 8edcbc3..c76b5bf 100644 --- a/src/inversion_ideas/regularization/_mesh_based.py +++ b/src/inversion_ideas/regularization/_mesh_based.py @@ -186,17 +186,16 @@ def __call__(self, model: Model) -> float: model_diff = model - self.reference_model weights_matrix = self.weights_matrix cell_volumes_sqrt = self._volumes_sqrt_matrix - - if self.model_slice is not None: - weights_matrix = aslinearoperator(weights_matrix) - cell_volumes_sqrt = self.model_slice.expand_matrix(cell_volumes_sqrt) + slicer_matrix = self._get_slicer_matrix() return ( model_diff.T + @ slicer_matrix.T @ cell_volumes_sqrt.T @ weights_matrix.T @ weights_matrix @ cell_volumes_sqrt + @ slicer_matrix @ model_diff ) @@ -212,17 +211,16 @@ def gradient(self, model: Model): model_diff = model - self.reference_model weights_matrix = self.weights_matrix cell_volumes_sqrt = self._volumes_sqrt_matrix - - if self.model_slice is not None: - weights_matrix = aslinearoperator(weights_matrix) - cell_volumes_sqrt = self.model_slice.expand_matrix(cell_volumes_sqrt) + slicer_matrix = self._get_slicer_matrix() return ( 2 - * cell_volumes_sqrt.T + * slicer_matrix.T + @ cell_volumes_sqrt.T @ weights_matrix.T @ weights_matrix @ cell_volumes_sqrt + @ slicer_matrix @ model_diff ) @@ -237,17 +235,16 @@ def hessian(self, model: Model): # noqa: ARG002 """ weights_matrix = self.weights_matrix cell_volumes_sqrt = self._volumes_sqrt_matrix - - if self.model_slice is not None: - weights_matrix = aslinearoperator(weights_matrix) - cell_volumes_sqrt = self.model_slice.expand_matrix(cell_volumes_sqrt) + slicer_matrix = self._get_slicer_matrix() return ( 2 - * cell_volumes_sqrt.T + * slicer_matrix.T + @ cell_volumes_sqrt.T @ weights_matrix.T @ weights_matrix @ cell_volumes_sqrt + @ slicer_matrix ) def hessian_diagonal(self, model: Model) -> npt.NDArray[np.float64]: @@ -259,24 +256,10 @@ def hessian_diagonal(self, model: Model) -> npt.NDArray[np.float64]: model : (n_params) array Array with model values. """ - # Patch: compute the diagonal again, but this should be avoided - if self.model_slice is not None: - weights_matrix = self.weights_matrix - cell_volumes_sqrt = self._volumes_sqrt_matrix - hessian_diagonal = ( - 2 - * cell_volumes_sqrt.T - @ weights_matrix.T - @ weights_matrix - @ cell_volumes_sqrt - ).diagonal() - hessian_diagonal = self.model_slice.expand_array(hessian_diagonal) - return hessian_diagonal - return self.hessian(model).diagonal() @property - def weights_matrix(self) -> dia_array: + def weights_matrix(self) -> dia_array[np.float64]: """ Diagonal matrix with the square root of regularization weights on cells. """ @@ -290,13 +273,24 @@ def weights_matrix(self) -> dia_array: return diags_array(np.sqrt(cell_weights)) @property - def _volumes_sqrt_matrix(self) -> dia_array: + def _volumes_sqrt_matrix(self) -> dia_array[np.float64]: """ Diagonal matrix with the square root of cell volumes. """ cell_volumes = self.mesh.cell_volumes[self.active_cells] return diags_array(np.sqrt(cell_volumes)) + def _get_slicer_matrix(self) -> dia_array[np.float64]: + """ + Return ``model_slicer.slicer_matrix`` or just a diagonal array. + """ + slicer_matrix = ( + self.model_slice.slice_matrix + if self.model_slice is not None + else eye_array(self.n_params, dtype=np.float64) + ) + return slicer_matrix + class Flatness(_MeshBasedRegularization): r""" From b1899e0d91a1ce5049278555184f69f7ccc90f3a Mon Sep 17 00:00:00 2001 From: Santiago Soler Date: Wed, 4 Feb 2026 16:23:04 -0800 Subject: [PATCH 17/47] Delete the `operators` submodule I like the slicer matrix better than the linear operator. --- src/inversion_ideas/__init__.py | 3 +- src/inversion_ideas/data_misfit.py | 7 +- src/inversion_ideas/operators.py | 161 ------------------ .../regularization/_mesh_based.py | 4 - src/inversion_ideas/wires.py | 45 +---- 5 files changed, 7 insertions(+), 213 deletions(-) delete mode 100644 src/inversion_ideas/operators.py diff --git a/src/inversion_ideas/__init__.py b/src/inversion_ideas/__init__.py index 067e4cc..be22fee 100644 --- a/src/inversion_ideas/__init__.py +++ b/src/inversion_ideas/__init__.py @@ -2,7 +2,7 @@ Ideas for inversion framework. """ -from . import base, operators, typing, utils +from . import base, typing, utils from ._version import __version__ from .conditions import ChiTarget, CustomCondition, ModelChanged, ObjectiveChanged from .data_misfit import DataMisfit @@ -52,7 +52,6 @@ "create_sparse_inversion", "create_tikhonov_regularization", "get_jacobi_preconditioner", - "operators", "typing", "utils", "wrap_simulation", diff --git a/src/inversion_ideas/data_misfit.py b/src/inversion_ideas/data_misfit.py index fa86bde..5911b15 100644 --- a/src/inversion_ideas/data_misfit.py +++ b/src/inversion_ideas/data_misfit.py @@ -4,11 +4,10 @@ import numpy as np import numpy.typing as npt -from scipy.sparse import dia_array, diags_array, sparray, eye_array +from scipy.sparse import dia_array, diags_array, eye_array, sparray from scipy.sparse.linalg import LinearOperator, aslinearoperator from .base import Objective -from .operators import BlockColumnMatrix from .typing import Model from .utils import cache_on_model from .wires import ModelSlice @@ -234,9 +233,7 @@ def chi_factor(self, model: Model): """ return self(model) / self.n_data - def _get_jacobian( - self, model: Model - ) -> npt.NDArray[np.float64] | LinearOperator | BlockColumnMatrix: + def _get_jacobian(self, model: Model) -> npt.NDArray[np.float64] | LinearOperator: """ Return the jacobian of the simulation evaluated on the passed model. diff --git a/src/inversion_ideas/operators.py b/src/inversion_ideas/operators.py deleted file mode 100644 index ec7b1d1..0000000 --- a/src/inversion_ideas/operators.py +++ /dev/null @@ -1,161 +0,0 @@ -""" -Special linear operators. - -Define classes for custom linear operators. -""" - -import numpy as np -import numpy.typing as npt -from scipy.sparse import sparray -from scipy.sparse.linalg import LinearOperator - - -class BlockColumnMatrix(LinearOperator): - r""" - Represents a block column matrix. - - This ``LinearOperator`` represents a matrix with a dense or sparse block that - occupies all rows, and columns to each side of it are all zeros. - - .. math:: - - \textbf{M} = - \begin{bmatrix} - \dots & 0 & a_{11} & \dots & a_{1M} & 0 & \dots\\ - \dots & 0 & \vdots & \ddots & \vdots & 0 & \dots\\ - \dots & 0 & a_{N1} & \dots & a_{NM} & 0 & \dots\\ - \end{bmatrix} - - Parameters - ---------- - block : 2D array, LinearOperator or sparray - Matrix or linear operator that will be used - index_start : int - Row index where the first column of the ``block`` matrix should be located in - the large block matrix. - n_cols : int - Total number of columns of the large block matrix. - """ - - def __init__( - self, - block: npt.NDArray | LinearOperator | sparray, - index_start: int, - n_cols: int, - ): - # TODO: raise error if the block matrix has more columns than n_cols - shape = (block.shape[0], n_cols) - super().__init__(shape=shape, dtype=block.dtype) - - self._block = block - self._index_start = index_start - self._slice = slice(index_start, index_start + block.shape[1]) - - @property - def block(self): - return self._block - - @property - def index_start(self): - return self._index_start - - @property - def slice(self): - return self._slice - - def _matvec(self, x): - """ - Dot product between the matrix and a vector. - """ - x_subset = x[self.slice] - return self.block @ x_subset - - def _rmatvec(self, x): - """ - Dot product between the transposed matrix and a vector. - """ - out = np.zeros(self.shape[1], dtype=self.dtype) - out[self.slice] = self.block.T @ x - return out - - def toarray(self): - """ - Return a dense ndarray representation of this blocked matrix. - """ - # TODO: raise error if the block is not an array or if it doesn't have a toarray - # method. - matrix = np.zeros(self.shape, dtype=self.dtype) - matrix[:, self.slice] = self.block - return matrix - - def get_column(self, column_index) -> npt.NDArray: - """ - Get the j-th column of the matrix. - - Parameters - ---------- - column_index : int - Index for the desired column. - - Returns - ------- - column : array - The j-th column of the matrix. - """ - # TODO: raise error if we cannot extract column from block - # (sparse array, linear operator). - axis = 1 - if not (0 <= column_index < self.shape[axis]): - msg = ( - f"index {column_index} is out of bounds for axis {axis} " - f"with size {self.shape[axis]}" - ) - raise IndexError(msg) - if self.slice.start <= column_index < self.slice.stop: - return self.block[:, column_index - self.slice.start] - return np.zeros(self.shape[0], dtype=self.dtype) - - def __getitem__(self, indices): - # TODO: raise error if block cannot be indexed - # TODO: raise error if slices? or support them. - - row, column = indices - - # Sanity checks for indices - axis = 0 - if row >= 0: - if not (0 <= row < self.shape[axis]): - msg = ( - f"index {row} is out of bounds for axis {axis} " - f"with size {self.shape[axis]}" - ) - raise IndexError(msg) - else: - if row < -self.shape[0]: - msg = ( - f"index {row} is out of bounds for axis {axis} " - f"with size {self.shape[axis]}" - ) - raise IndexError(msg) - row += self.shape[0] - - axis = 1 - if column >= 0: - if not (0 <= column < self.shape[axis]): - msg = ( - f"index {column} is out of bounds for axis {axis} " - f"with size {self.shape[axis]}" - ) - raise IndexError(msg) - else: - if column < -self.shape[axis]: - msg = ( - f"index {column} is out of bounds for axis {axis} " - f"with size {self.shape[axis]}" - ) - raise IndexError(msg) - column += self.shape[axis] - - if self.slice.start <= column < self.slice.stop: - return self.block[row, column - self.slice.start] - return np.astype(np.float64(0.0), self.dtype) diff --git a/src/inversion_ideas/regularization/_mesh_based.py b/src/inversion_ideas/regularization/_mesh_based.py index c76b5bf..83f6d1b 100644 --- a/src/inversion_ideas/regularization/_mesh_based.py +++ b/src/inversion_ideas/regularization/_mesh_based.py @@ -2,16 +2,12 @@ Regularization classes for mesh-based inversion problems. """ -from types import NoneType import discretize import numpy as np import numpy.typing as npt -from scipy.sparse.linalg import aslinearoperator import simpeg from scipy.sparse import dia_array, diags_array, eye_array -from inversion_ideas.operators import BlockColumnMatrix - from .._utils import prod_arrays from ..base import Objective from ..typing import Model diff --git a/src/inversion_ideas/wires.py b/src/inversion_ideas/wires.py index 8fa5cff..d45e4e1 100644 --- a/src/inversion_ideas/wires.py +++ b/src/inversion_ideas/wires.py @@ -5,11 +5,8 @@ from numbers import Integral import numpy as np -import numpy.typing as npt -from scipy.sparse import dia_array, diags_array, sparray -from scipy.sparse.linalg import LinearOperator +from scipy.sparse import dia_array, diags_array -from .operators import BlockColumnMatrix from .typing import Model @@ -135,46 +132,12 @@ def slice_matrix(self) -> dia_array[np.float64]: """ ones = np.ones(self.size) shape = (self.size, self.full_size) - return diags_array(ones, offsets=self.slice.start, shape=shape, dtype=np.float64) + return diags_array( + ones, offsets=self.slice.start, shape=shape, dtype=np.float64 + ) def extract(self, model: Model): if model.size != self.wires.size: # TODO: add msg raise ValueError() return model[self.slice] - - def expand_array(self, array: npt.NDArray) -> npt.NDArray: - """ - Expand a 1D array with zeros outside the model slice. - """ - if not isinstance(array, np.ndarray): - msg = f"Invalid array of type {type(array).__name__}." - raise TypeError(msg) - if array.ndim != 1: - msg = f"Invalid array with {array.ndim} dimensions. It must be a 1D array." - raise ValueError(msg) - out = np.zeros(self.full_size, dtype=array.dtype) - out[self.slice] = array - return out - - def expand_matrix( - self, matrix: npt.NDArray | sparray | LinearOperator - ) -> BlockColumnMatrix: - """ - Expand a matrix that operates on the model slice into a block matrix. - """ - if matrix.ndim != 2: - msg = ( - f"Invalid matrix with {matrix.ndim} dimensions. " - "It must be a 2D matrix or LinearOperator." - ) - raise ValueError(msg) - if matrix.shape[1] != self.size: - # TODO: Complete the error message - msg = f"Invalid matrix with shape '{matrix.shape}'." - raise ValueError(msg) - return BlockColumnMatrix( - block=matrix, - index_start=self.slice.start, - n_cols=self.full_size, - ) From 6f683f854e9175cbf06590beae6e9a86b8bbe0b9 Mon Sep 17 00:00:00 2001 From: Santiago Soler Date: Wed, 4 Feb 2026 16:33:25 -0800 Subject: [PATCH 18/47] Implement model_slice in Flatness --- src/inversion_ideas/recipes.py | 5 +++ .../regularization/_mesh_based.py | 32 +++++++++++++++++-- 2 files changed, 34 insertions(+), 3 deletions(-) diff --git a/src/inversion_ideas/recipes.py b/src/inversion_ideas/recipes.py index 919f2b0..88e7de0 100644 --- a/src/inversion_ideas/recipes.py +++ b/src/inversion_ideas/recipes.py @@ -7,6 +7,8 @@ import numpy as np import numpy.typing as npt +from inversion_ideas.wires import ModelSlice + from .base import Combo, Minimizer, Objective from .conditions import ChiTarget, ObjectiveChanged from .data_misfit import DataMisfit @@ -273,6 +275,7 @@ def create_tikhonov_regularization( alpha_y: float | None = None, alpha_z: float | None = None, reference_model_in_flatness: bool = False, + model_slice: ModelSlice | None = None, ) -> Combo: """ Create a linear combination of Tikhonov (L2) regularization terms. @@ -321,6 +324,7 @@ def create_tikhonov_regularization( active_cells=active_cells, cell_weights=cell_weights, reference_model=reference_model, + model_slice=model_slice, ) if alpha_s is not None: smallness = alpha_s * smallness @@ -328,6 +332,7 @@ def create_tikhonov_regularization( kwargs = { "active_cells": active_cells, "cell_weights": cell_weights, + "model_slice": model_slice, } if reference_model_in_flatness: kwargs["reference_model"] = reference_model diff --git a/src/inversion_ideas/regularization/_mesh_based.py b/src/inversion_ideas/regularization/_mesh_based.py index 83f6d1b..8005286 100644 --- a/src/inversion_ideas/regularization/_mesh_based.py +++ b/src/inversion_ideas/regularization/_mesh_based.py @@ -370,6 +370,7 @@ def __init__( active_cells: npt.NDArray[np.bool] | None = None, cell_weights: npt.NDArray | dict[str, npt.NDArray] | None = None, reference_model: Model | None = None, + model_slice: ModelSlice | None = None, ): self.mesh = mesh self.direction = direction @@ -378,12 +379,14 @@ def __init__( if active_cells is not None else np.ones(self.mesh.n_cells, dtype=bool) ) + # assign model_slice after active_cells so n_params is correct during __init__ + self.model_slice = model_slice # Assign the cell weights through the setter self.cell_weights = ( cell_weights if cell_weights is not None - else np.ones(self.n_params, dtype=np.float64) + else np.ones(self.n_active, dtype=np.float64) ) self.reference_model = ( @@ -406,14 +409,18 @@ def __call__(self, model: Model) -> float: weights_matrix = self.weights_matrix cell_volumes_sqrt = self._volumes_sqrt_matrix cell_gradient = self._cell_gradient + slicer_matrix = self._get_slicer_matrix() + return ( model_diff.T + @ slicer_matrix.T @ cell_gradient.T @ cell_volumes_sqrt.T @ weights_matrix.T @ weights_matrix @ cell_volumes_sqrt @ cell_gradient + @ slicer_matrix @ model_diff ) @@ -430,14 +437,18 @@ def gradient(self, model: Model): weights_matrix = self.weights_matrix cell_volumes_sqrt = self._volumes_sqrt_matrix cell_gradient = self._cell_gradient + slicer_matrix = self._get_slicer_matrix() + return ( 2 - * cell_gradient.T + * slicer_matrix.T + @ cell_gradient.T @ cell_volumes_sqrt.T @ weights_matrix.T @ weights_matrix @ cell_volumes_sqrt @ cell_gradient + @ slicer_matrix @ model_diff ) @@ -453,14 +464,18 @@ def hessian(self, model: Model): # noqa: ARG002 weights_matrix = self.weights_matrix cell_gradient = self._cell_gradient cell_volumes_sqrt = self._volumes_sqrt_matrix + slicer_matrix = self._get_slicer_matrix() + return ( 2 - * cell_gradient.T + * slicer_matrix.T + @ cell_gradient.T @ cell_volumes_sqrt.T @ weights_matrix.T @ weights_matrix @ cell_volumes_sqrt @ cell_gradient + @ slicer_matrix ) def hessian_diagonal(self, model: Model) -> npt.NDArray[np.float64]: @@ -521,6 +536,17 @@ def _regularization_mesh(self): ) return self._regmesh + def _get_slicer_matrix(self) -> dia_array[np.float64]: + """ + Return ``model_slicer.slicer_matrix`` or just a diagonal array. + """ + slicer_matrix = ( + self.model_slice.slice_matrix + if self.model_slice is not None + else eye_array(self.n_params, dtype=np.float64) + ) + return slicer_matrix + class SparseSmallness(_MeshBasedRegularization): r""" From c24988ebbe98ed8abcd5414b6440a51e6ce2bdfd Mon Sep 17 00:00:00 2001 From: Santiago Soler Date: Thu, 5 Feb 2026 10:54:35 -0800 Subject: [PATCH 19/47] Make _slicer_matrix a property of DataMisfit and regs --- src/inversion_ideas/data_misfit.py | 13 +++++----- .../regularization/_mesh_based.py | 24 ++++++++----------- 2 files changed, 16 insertions(+), 21 deletions(-) diff --git a/src/inversion_ideas/data_misfit.py b/src/inversion_ideas/data_misfit.py index 5911b15..23b1925 100644 --- a/src/inversion_ideas/data_misfit.py +++ b/src/inversion_ideas/data_misfit.py @@ -112,10 +112,9 @@ def gradient(self, model: Model) -> npt.NDArray[np.float64]: """ jac = self._get_jacobian(model) weights_matrix = self.weights_matrix - slicer_matrix = self._get_slicer_matrix() gradient = ( 2 - * slicer_matrix.T + * self._slicer_matrix.T @ jac.T @ (weights_matrix.T @ weights_matrix @ self.residual(model)) ) @@ -129,7 +128,7 @@ def hessian( """ jac = self._get_jacobian(model) weights_matrix = aslinearoperator(self.weights_matrix) - slicer_matrix = aslinearoperator(self._get_slicer_matrix()) + slicer_matrix = aslinearoperator(self._slicer_matrix) if not self.build_hessian: jac = aslinearoperator(jac) return ( @@ -155,8 +154,7 @@ def hessian_diagonal(self, model: Model) -> npt.NDArray[np.float64]: raise NotImplementedError(msg) jtj_diag = np.einsum("i,ij,ij->j", self.weights_matrix.diagonal(), jac, jac) - slicer_matrix = self._get_slicer_matrix() - return 2 * slicer_matrix.T @ jtj_diag + return 2 * self._slicer_matrix.T @ jtj_diag @property def n_params(self): @@ -233,7 +231,7 @@ def chi_factor(self, model: Model): """ return self(model) / self.n_data - def _get_jacobian(self, model: Model) -> npt.NDArray[np.float64] | LinearOperator: + def _get_jacobian(self, model: Model) -> LinearOperator: """ Return the jacobian of the simulation evaluated on the passed model. @@ -249,7 +247,8 @@ def _get_jacobian(self, model: Model) -> npt.NDArray[np.float64] | LinearOperato ) return jac - def _get_slicer_matrix(self) -> dia_array[np.float64]: + @property + def _slicer_matrix(self) -> dia_array[np.float64]: """ Return ``model_slicer.slicer_matrix`` or just a diagonal array. """ diff --git a/src/inversion_ideas/regularization/_mesh_based.py b/src/inversion_ideas/regularization/_mesh_based.py index 8005286..cf8c58a 100644 --- a/src/inversion_ideas/regularization/_mesh_based.py +++ b/src/inversion_ideas/regularization/_mesh_based.py @@ -182,8 +182,7 @@ def __call__(self, model: Model) -> float: model_diff = model - self.reference_model weights_matrix = self.weights_matrix cell_volumes_sqrt = self._volumes_sqrt_matrix - slicer_matrix = self._get_slicer_matrix() - + slicer_matrix = self._slicer_matrix return ( model_diff.T @ slicer_matrix.T @@ -207,8 +206,7 @@ def gradient(self, model: Model): model_diff = model - self.reference_model weights_matrix = self.weights_matrix cell_volumes_sqrt = self._volumes_sqrt_matrix - slicer_matrix = self._get_slicer_matrix() - + slicer_matrix = self._slicer_matrix return ( 2 * slicer_matrix.T @@ -231,8 +229,7 @@ def hessian(self, model: Model): # noqa: ARG002 """ weights_matrix = self.weights_matrix cell_volumes_sqrt = self._volumes_sqrt_matrix - slicer_matrix = self._get_slicer_matrix() - + slicer_matrix = self._slicer_matrix return ( 2 * slicer_matrix.T @@ -276,7 +273,8 @@ def _volumes_sqrt_matrix(self) -> dia_array[np.float64]: cell_volumes = self.mesh.cell_volumes[self.active_cells] return diags_array(np.sqrt(cell_volumes)) - def _get_slicer_matrix(self) -> dia_array[np.float64]: + @property + def _slicer_matrix(self) -> dia_array[np.float64]: """ Return ``model_slicer.slicer_matrix`` or just a diagonal array. """ @@ -409,8 +407,7 @@ def __call__(self, model: Model) -> float: weights_matrix = self.weights_matrix cell_volumes_sqrt = self._volumes_sqrt_matrix cell_gradient = self._cell_gradient - slicer_matrix = self._get_slicer_matrix() - + slicer_matrix = self._slicer_matrix return ( model_diff.T @ slicer_matrix.T @@ -437,8 +434,7 @@ def gradient(self, model: Model): weights_matrix = self.weights_matrix cell_volumes_sqrt = self._volumes_sqrt_matrix cell_gradient = self._cell_gradient - slicer_matrix = self._get_slicer_matrix() - + slicer_matrix = self._slicer_matrix return ( 2 * slicer_matrix.T @@ -464,8 +460,7 @@ def hessian(self, model: Model): # noqa: ARG002 weights_matrix = self.weights_matrix cell_gradient = self._cell_gradient cell_volumes_sqrt = self._volumes_sqrt_matrix - slicer_matrix = self._get_slicer_matrix() - + slicer_matrix = self._slicer_matrix return ( 2 * slicer_matrix.T @@ -536,7 +531,8 @@ def _regularization_mesh(self): ) return self._regmesh - def _get_slicer_matrix(self) -> dia_array[np.float64]: + @property + def _slicer_matrix(self) -> dia_array[np.float64]: """ Return ``model_slicer.slicer_matrix`` or just a diagonal array. """ From 724eda9c056bedfea02df9dce7753c34d2cde594 Mon Sep 17 00:00:00 2001 From: Santiago Soler Date: Tue, 10 Feb 2026 12:20:26 -0800 Subject: [PATCH 20/47] Add a BlockSquareMatrix class Add a class to represent an extended hessian matrix in objective functions. --- src/inversion_ideas/wires.py | 122 ++++++++++++++++++++++++++++++++++- 1 file changed, 121 insertions(+), 1 deletion(-) diff --git a/src/inversion_ideas/wires.py b/src/inversion_ideas/wires.py index d45e4e1..52f408e 100644 --- a/src/inversion_ideas/wires.py +++ b/src/inversion_ideas/wires.py @@ -5,7 +5,9 @@ from numbers import Integral import numpy as np -from scipy.sparse import dia_array, diags_array +import numpy.typing as npt +from scipy.sparse import dia_array, diags_array, sparray +from scipy.sparse.linalg import LinearOperator from .typing import Model @@ -141,3 +143,121 @@ def extract(self, model: Model): # TODO: add msg raise ValueError() return model[self.slice] + + def expand_matrix( + self, matrix: npt.NDArray | LinearOperator | sparray + ) -> "BlockSquareMatrix": + """ + Expand a square matrix into a ``BlockSquareMatrix`` filling blocks with zeros. + + Parameters + ---------- + matrix : array, sparse array or LinearOperator + Square matrix that will be expanded + """ + return BlockSquareMatrix(block=matrix, slice_matrix=self.slice_matrix) + + +class BlockSquareMatrix(LinearOperator): + r""" + Operator that represents a square matrix with a non-zero block surrounded by zeros. + + Use this class to represent hessian matrices that are built from smaller matrices + that operate only on a subset of the entire model. Only a block of that hessian will + be non-zero (the one related to the relevant model elements for that objective + function), while the rest of the matrix will be filled of zeros. + + Parameters + ---------- + block : array, sparse array or LinearOperator + Square block matrix. + slice_matrix : dia_array + Diagonal array to represent the slicing matrix. + + Notes + ----- + + This ``LinearOperator`` represents square matrices like: + + .. math:: + + \mathbf{H} = \begin{bmatrix} + 0 & 0 & 0\\ + 0 & \mathbf{B} & 0\\ + 0 & 0 & 0 + \end{bmatrix} + + where :math:`\mathbf{B}` is a non-zero square block matrix that sits in the diagonal + of :math:`\mathbf{H}`. The matrix :math:`\mathbf{H}` can be built as: + + .. math:: + + \mathbf{H} = \mathbf{s}^T \mathbf{B} \mathbf{s} + + where :math:`\mathbf{s}` is the *slicing matrix*. + """ + + def __init__( + self, + block: npt.NDArray | LinearOperator | sparray, + slice_matrix: dia_array, + ): + # TODO: + # - [ ] raise error if the block plus the offset doesn't fit in the shape + # - [x] raise error if the block is not square + # - [x] raise error if the shape is not square + if block.shape[0] != block.shape[1]: + msg = ( + f"Invalid block matrix '{block}' with shape '{block.shape}'. " + "It must be a square matrix." + ) + raise ValueError(msg) + + if slice_matrix.shape[0] != block.shape[1]: + msg = ( + f"Invalid block '{block}' and slice_matrix '{slice_matrix}' with " + f"shapes '{block.shape}' and {slice_matrix.shape}." + ) + raise ValueError(msg) + + if slice_matrix.shape[1] <= block.shape[1]: + # TODO: improve msg + msg = "block is larger than slice matrix" + raise ValueError(msg) + + _, full_size = slice_matrix.shape + shape = (full_size, full_size) + super().__init__(shape=shape, dtype=block.dtype) + + self._block = block + self._slice_matrix = slice_matrix + + @property + def block(self): + return self._block + + @property + def slice_matrix(self) -> dia_array: + return self._slice_matrix + + def _matvec(self, x): + """ + Dot product between the matrix and a vector. + """ + result = self.slice_matrix.T @ (self.block @ (self.slice_matrix @ x)) + return result + + def _rmatvec(self, x): + """ + Dot product between the transposed matrix and a vector. + """ + result = self.slice_matrix @ (self.block.T @ (self.slice_matrix.T @ x)) + return result + + def diagonal(self): + """ + Diagonal of the matrix. + """ + # TODO: check if the block has a diagonal method (implement a protocol for it) + diagonal = self.block.diagonal() + return self.slice_matrix.T @ diagonal From 3ff0c4034abafa706a9d607663a1ef9134247b8e Mon Sep 17 00:00:00 2001 From: Santiago Soler Date: Tue, 10 Feb 2026 13:55:10 -0800 Subject: [PATCH 21/47] Add expand_array method to Wires --- src/inversion_ideas/wires.py | 24 +++++++++++++++++++++++- 1 file changed, 23 insertions(+), 1 deletion(-) diff --git a/src/inversion_ideas/wires.py b/src/inversion_ideas/wires.py index 52f408e..1d811de 100644 --- a/src/inversion_ideas/wires.py +++ b/src/inversion_ideas/wires.py @@ -144,6 +144,23 @@ def extract(self, model: Model): raise ValueError() return model[self.slice] + def expand_array(self, array: npt.NDArray) -> npt.NDArray: + """ + Expand a 1D array by filling it with extra zeros. + + Parameters + ---------- + array : (n,) array + Array that will be filled. It must have the same number of elements as the + model slice. + + Returns + ------- + array : (m,) array + Array filled with zeros on elements outside of the model slice. + """ + return self.slice_matrix.T @ array + def expand_matrix( self, matrix: npt.NDArray | LinearOperator | sparray ) -> "BlockSquareMatrix": @@ -154,6 +171,12 @@ def expand_matrix( ---------- matrix : array, sparse array or LinearOperator Square matrix that will be expanded + + Returns + ------- + block_square_matrix : BlockSquareMatrix + LinearOperator that represents the matrix filled with zeros outside of the + block. """ return BlockSquareMatrix(block=matrix, slice_matrix=self.slice_matrix) @@ -176,7 +199,6 @@ class BlockSquareMatrix(LinearOperator): Notes ----- - This ``LinearOperator`` represents square matrices like: .. math:: From 3d8ff901fc29ffd97a9aad2847a1660344a7107e Mon Sep 17 00:00:00 2001 From: Santiago Soler Date: Tue, 10 Feb 2026 14:08:32 -0800 Subject: [PATCH 22/47] Make use of ModelSlice methods in DataMisfit Ditch the _slice_matrix property and make use of the ModelSlice expand methods to expand the gradient and the hessian. --- src/inversion_ideas/data_misfit.py | 47 ++++++++++++------------------ 1 file changed, 19 insertions(+), 28 deletions(-) diff --git a/src/inversion_ideas/data_misfit.py b/src/inversion_ideas/data_misfit.py index 23b1925..bb0f3fb 100644 --- a/src/inversion_ideas/data_misfit.py +++ b/src/inversion_ideas/data_misfit.py @@ -4,7 +4,7 @@ import numpy as np import numpy.typing as npt -from scipy.sparse import dia_array, diags_array, eye_array, sparray +from scipy.sparse import dia_array, diags_array, sparray from scipy.sparse.linalg import LinearOperator, aslinearoperator from .base import Objective @@ -113,11 +113,12 @@ def gradient(self, model: Model) -> npt.NDArray[np.float64]: jac = self._get_jacobian(model) weights_matrix = self.weights_matrix gradient = ( - 2 - * self._slicer_matrix.T - @ jac.T - @ (weights_matrix.T @ weights_matrix @ self.residual(model)) + 2 * jac.T @ (weights_matrix.T @ weights_matrix @ self.residual(model)) ) + + if self.model_slice is not None: + gradient = self.model_slice.expand_array(gradient) + return gradient def hessian( @@ -128,18 +129,15 @@ def hessian( """ jac = self._get_jacobian(model) weights_matrix = aslinearoperator(self.weights_matrix) - slicer_matrix = aslinearoperator(self._slicer_matrix) if not self.build_hessian: jac = aslinearoperator(jac) - return ( - 2 - * slicer_matrix.T - @ jac.T - @ weights_matrix.T - @ weights_matrix - @ jac - @ slicer_matrix - ) + + hessian = 2 * jac.T @ weights_matrix.T @ weights_matrix @ jac + + if self.model_slice is not None: + hessian = self.model_slice.expand_matrix(hessian) + + return hessian def hessian_diagonal(self, model: Model) -> npt.NDArray[np.float64]: """ @@ -154,7 +152,12 @@ def hessian_diagonal(self, model: Model) -> npt.NDArray[np.float64]: raise NotImplementedError(msg) jtj_diag = np.einsum("i,ij,ij->j", self.weights_matrix.diagonal(), jac, jac) - return 2 * self._slicer_matrix.T @ jtj_diag + hessian_diag = 2 * jtj_diag + + if self.model_slice is not None: + hessian_diag = self.model_slice.expand_array(hessian_diag) + + return hessian_diag @property def n_params(self): @@ -246,15 +249,3 @@ def _get_jacobian(self, model: Model) -> LinearOperator: model if self.model_slice is None else self.model_slice.extract(model) ) return jac - - @property - def _slicer_matrix(self) -> dia_array[np.float64]: - """ - Return ``model_slicer.slicer_matrix`` or just a diagonal array. - """ - slicer_matrix = ( - self.model_slice.slice_matrix - if self.model_slice is not None - else eye_array(self.n_params, dtype=np.float64) - ) - return slicer_matrix From 11fcdf934f2480f5ff2d72e5177bed88c544e1c0 Mon Sep 17 00:00:00 2001 From: Santiago Soler Date: Tue, 10 Feb 2026 14:09:19 -0800 Subject: [PATCH 23/47] Use ModelSlice methods in mesh-based regularizations --- .../regularization/_mesh_based.py | 90 ++++++++----------- 1 file changed, 36 insertions(+), 54 deletions(-) diff --git a/src/inversion_ideas/regularization/_mesh_based.py b/src/inversion_ideas/regularization/_mesh_based.py index cf8c58a..4f8a92f 100644 --- a/src/inversion_ideas/regularization/_mesh_based.py +++ b/src/inversion_ideas/regularization/_mesh_based.py @@ -93,8 +93,9 @@ class Smallness(_MeshBasedRegularization): For multiple cell weights, pass a dictionary where keys are strings and values are the different weights arrays. If None, no cell weights are going to be used. - reference_model : (n_params) array or None, optional - Array with values for the reference model. + reference_model : (n_active) array or None, optional + Array with values for the reference model. It must have the same number of + elements as active cells in the mesh. Notes ----- @@ -179,18 +180,16 @@ def __call__(self, model: Model) -> float: model : (n_params) array Array with model values. """ + model = model if self.model_slice is None else self.model_slice.extract(model) model_diff = model - self.reference_model weights_matrix = self.weights_matrix cell_volumes_sqrt = self._volumes_sqrt_matrix - slicer_matrix = self._slicer_matrix return ( model_diff.T - @ slicer_matrix.T @ cell_volumes_sqrt.T @ weights_matrix.T @ weights_matrix @ cell_volumes_sqrt - @ slicer_matrix @ model_diff ) @@ -203,21 +202,24 @@ def gradient(self, model: Model): model : (n_params) array Array with model values. """ + model = model if self.model_slice is None else self.model_slice.extract(model) model_diff = model - self.reference_model weights_matrix = self.weights_matrix cell_volumes_sqrt = self._volumes_sqrt_matrix - slicer_matrix = self._slicer_matrix - return ( + gradient = ( 2 - * slicer_matrix.T - @ cell_volumes_sqrt.T + * cell_volumes_sqrt.T @ weights_matrix.T @ weights_matrix @ cell_volumes_sqrt - @ slicer_matrix @ model_diff ) + if self.model_slice is not None: + gradient = self.model_slice.expand_array(gradient) + + return gradient + def hessian(self, model: Model): # noqa: ARG002 """ Hessian matrix. @@ -229,17 +231,19 @@ def hessian(self, model: Model): # noqa: ARG002 """ weights_matrix = self.weights_matrix cell_volumes_sqrt = self._volumes_sqrt_matrix - slicer_matrix = self._slicer_matrix - return ( + hessian = ( 2 - * slicer_matrix.T - @ cell_volumes_sqrt.T + * cell_volumes_sqrt.T @ weights_matrix.T @ weights_matrix @ cell_volumes_sqrt - @ slicer_matrix ) + if self.model_slice is not None: + hessian = self.model_slice.expand_matrix(hessian) + + return hessian + def hessian_diagonal(self, model: Model) -> npt.NDArray[np.float64]: """ Diagonal of the Hessian. @@ -273,18 +277,6 @@ def _volumes_sqrt_matrix(self) -> dia_array[np.float64]: cell_volumes = self.mesh.cell_volumes[self.active_cells] return diags_array(np.sqrt(cell_volumes)) - @property - def _slicer_matrix(self) -> dia_array[np.float64]: - """ - Return ``model_slicer.slicer_matrix`` or just a diagonal array. - """ - slicer_matrix = ( - self.model_slice.slice_matrix - if self.model_slice is not None - else eye_array(self.n_params, dtype=np.float64) - ) - return slicer_matrix - class Flatness(_MeshBasedRegularization): r""" @@ -301,12 +293,12 @@ class Flatness(_MeshBasedRegularization): active_cells : (n_cells) array or None, optional Array full of bools that indicate the active cells in the mesh. It must have the same amount of elements as cells in the mesh. - cell_weights : (n_params) array or dict of (n_params) arrays or None, optional + cell_weights : (n_active) array or dict of (n_params) arrays or None, optional Array with cell weights. For multiple cell weights, pass a dictionary where keys are strings and values are the different weights arrays. If None, no cell weights are going to be used. - reference_model : (n_params) array or None, optional + reference_model : (n_active) array or None, optional Array with values for the reference model. Notes @@ -390,7 +382,7 @@ def __init__( self.reference_model = ( reference_model if reference_model is not None - else np.zeros(self.n_params, dtype=np.float64) + else np.zeros(self.n_active, dtype=np.float64) ) self.set_name(direction) @@ -403,21 +395,19 @@ def __call__(self, model: Model) -> float: model : (n_params) array Array with model values. """ + model = model if self.model_slice is None else self.model_slice.extract(model) model_diff = model - self.reference_model weights_matrix = self.weights_matrix cell_volumes_sqrt = self._volumes_sqrt_matrix cell_gradient = self._cell_gradient - slicer_matrix = self._slicer_matrix return ( model_diff.T - @ slicer_matrix.T @ cell_gradient.T @ cell_volumes_sqrt.T @ weights_matrix.T @ weights_matrix @ cell_volumes_sqrt @ cell_gradient - @ slicer_matrix @ model_diff ) @@ -430,24 +420,28 @@ def gradient(self, model: Model): model : (n_params) array Array with model values. """ + model = model if self.model_slice is None else self.model_slice.extract(model) model_diff = model - self.reference_model weights_matrix = self.weights_matrix cell_volumes_sqrt = self._volumes_sqrt_matrix cell_gradient = self._cell_gradient - slicer_matrix = self._slicer_matrix - return ( + + gradient = ( 2 - * slicer_matrix.T @ cell_gradient.T @ cell_volumes_sqrt.T @ weights_matrix.T @ weights_matrix @ cell_volumes_sqrt @ cell_gradient - @ slicer_matrix @ model_diff ) + if self.model_slice is not None: + gradient = self.model_slice.expand_array(gradient) + + return gradient + def hessian(self, model: Model): # noqa: ARG002 """ Hessian matrix. @@ -460,18 +454,18 @@ def hessian(self, model: Model): # noqa: ARG002 weights_matrix = self.weights_matrix cell_gradient = self._cell_gradient cell_volumes_sqrt = self._volumes_sqrt_matrix - slicer_matrix = self._slicer_matrix - return ( + hessian = ( 2 - * slicer_matrix.T - @ cell_gradient.T + * cell_gradient.T @ cell_volumes_sqrt.T @ weights_matrix.T @ weights_matrix @ cell_volumes_sqrt @ cell_gradient - @ slicer_matrix ) + if self.model_slice is not None: + hessian = self.model_slice.expand_matrix(hessian) + return hessian def hessian_diagonal(self, model: Model) -> npt.NDArray[np.float64]: """ @@ -531,18 +525,6 @@ def _regularization_mesh(self): ) return self._regmesh - @property - def _slicer_matrix(self) -> dia_array[np.float64]: - """ - Return ``model_slicer.slicer_matrix`` or just a diagonal array. - """ - slicer_matrix = ( - self.model_slice.slice_matrix - if self.model_slice is not None - else eye_array(self.n_params, dtype=np.float64) - ) - return slicer_matrix - class SparseSmallness(_MeshBasedRegularization): r""" From cbf618be37b71470f4ca71afb1d1a0e57119b64c Mon Sep 17 00:00:00 2001 From: Santiago Soler Date: Tue, 10 Feb 2026 14:23:03 -0800 Subject: [PATCH 24/47] Fix bug in definition of reference_model --- src/inversion_ideas/regularization/_mesh_based.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/inversion_ideas/regularization/_mesh_based.py b/src/inversion_ideas/regularization/_mesh_based.py index 4f8a92f..1cdeecc 100644 --- a/src/inversion_ideas/regularization/_mesh_based.py +++ b/src/inversion_ideas/regularization/_mesh_based.py @@ -167,7 +167,7 @@ def __init__( self.reference_model = ( reference_model if reference_model is not None - else np.zeros(self.n_params, dtype=np.float64) + else np.zeros(self.n_active, dtype=np.float64) ) self.set_name("s") From 90cc0963b4a11bbef7fd54464ce374b32b37d1eb Mon Sep 17 00:00:00 2001 From: Santiago Soler Date: Tue, 10 Feb 2026 14:23:20 -0800 Subject: [PATCH 25/47] Rerun notebook --- ...0_gravity-inversion-with-model-slice.ipynb | 388 ++++++++++-------- 1 file changed, 222 insertions(+), 166 deletions(-) diff --git a/notebooks/50_gravity-inversion-with-model-slice.ipynb b/notebooks/50_gravity-inversion-with-model-slice.ipynb index 74a922d..121decb 100644 --- a/notebooks/50_gravity-inversion-with-model-slice.ipynb +++ b/notebooks/50_gravity-inversion-with-model-slice.ipynb @@ -14,11 +14,11 @@ "id": "b2d27e8b-5b33-4361-990b-8b6e724f5ac6", "metadata": { "execution": { - "iopub.execute_input": "2026-02-04T22:09:58.787010Z", - "iopub.status.busy": "2026-02-04T22:09:58.786798Z", - "iopub.status.idle": "2026-02-04T22:10:00.537793Z", - "shell.execute_reply": "2026-02-04T22:10:00.536759Z", - "shell.execute_reply.started": "2026-02-04T22:09:58.786984Z" + "iopub.execute_input": "2026-02-10T22:21:15.017652Z", + "iopub.status.busy": "2026-02-10T22:21:15.017317Z", + "iopub.status.idle": "2026-02-10T22:21:16.780605Z", + "shell.execute_reply": "2026-02-10T22:21:16.779846Z", + "shell.execute_reply.started": "2026-02-10T22:21:15.017626Z" } }, "outputs": [], @@ -54,11 +54,11 @@ "id": "dfce90d3-de10-43d3-a668-696993b0f73e", "metadata": { "execution": { - "iopub.execute_input": "2026-02-04T22:10:00.538588Z", - "iopub.status.busy": "2026-02-04T22:10:00.538249Z", - "iopub.status.idle": "2026-02-04T22:10:00.543227Z", - "shell.execute_reply": "2026-02-04T22:10:00.541996Z", - "shell.execute_reply.started": "2026-02-04T22:10:00.538571Z" + "iopub.execute_input": "2026-02-10T22:21:16.781939Z", + "iopub.status.busy": "2026-02-10T22:21:16.781398Z", + "iopub.status.idle": "2026-02-10T22:21:16.786066Z", + "shell.execute_reply": "2026-02-10T22:21:16.785076Z", + "shell.execute_reply.started": "2026-02-10T22:21:16.781915Z" } }, "outputs": [], @@ -81,11 +81,11 @@ "id": "2403d600-451e-424e-8de9-3f824f1e2647", "metadata": { "execution": { - "iopub.execute_input": "2026-02-04T22:10:00.544429Z", - "iopub.status.busy": "2026-02-04T22:10:00.544093Z", - "iopub.status.idle": "2026-02-04T22:10:01.808256Z", - "shell.execute_reply": "2026-02-04T22:10:01.807116Z", - "shell.execute_reply.started": "2026-02-04T22:10:00.544400Z" + "iopub.execute_input": "2026-02-10T22:21:16.786730Z", + "iopub.status.busy": "2026-02-10T22:21:16.786555Z", + "iopub.status.idle": "2026-02-10T22:21:18.020986Z", + "shell.execute_reply": "2026-02-10T22:21:18.020190Z", + "shell.execute_reply.started": "2026-02-10T22:21:16.786714Z" } }, "outputs": [ @@ -114,17 +114,17 @@ "id": "9612913a-b699-4ad4-8fe7-cbf83376f5d8", "metadata": { "execution": { - "iopub.execute_input": "2026-02-04T22:10:01.809184Z", - "iopub.status.busy": "2026-02-04T22:10:01.808949Z", - "iopub.status.idle": "2026-02-04T22:10:01.956821Z", - "shell.execute_reply": "2026-02-04T22:10:01.955868Z", - "shell.execute_reply.started": "2026-02-04T22:10:01.809159Z" + "iopub.execute_input": "2026-02-10T22:21:18.022001Z", + "iopub.status.busy": "2026-02-10T22:21:18.021707Z", + "iopub.status.idle": "2026-02-10T22:21:18.168409Z", + "shell.execute_reply": "2026-02-10T22:21:18.167897Z", + "shell.execute_reply.started": "2026-02-10T22:21:18.021974Z" } }, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -146,11 +146,11 @@ "id": "f6d55c30-c5c9-4376-bc6d-ece83805b2d2", "metadata": { "execution": { - "iopub.execute_input": "2026-02-04T22:10:01.957765Z", - "iopub.status.busy": "2026-02-04T22:10:01.957524Z", - "iopub.status.idle": "2026-02-04T22:10:01.963031Z", - "shell.execute_reply": "2026-02-04T22:10:01.962003Z", - "shell.execute_reply.started": "2026-02-04T22:10:01.957739Z" + "iopub.execute_input": "2026-02-10T22:21:18.169511Z", + "iopub.status.busy": "2026-02-10T22:21:18.169180Z", + "iopub.status.idle": "2026-02-10T22:21:18.173650Z", + "shell.execute_reply": "2026-02-10T22:21:18.173044Z", + "shell.execute_reply.started": "2026-02-10T22:21:18.169486Z" } }, "outputs": [ @@ -183,11 +183,11 @@ "id": "0edbb620-6a62-48bf-a8af-8981a76cc6f4", "metadata": { "execution": { - "iopub.execute_input": "2026-02-04T22:10:01.964161Z", - "iopub.status.busy": "2026-02-04T22:10:01.963825Z", - "iopub.status.idle": "2026-02-04T22:10:01.972097Z", - "shell.execute_reply": "2026-02-04T22:10:01.970861Z", - "shell.execute_reply.started": "2026-02-04T22:10:01.964137Z" + "iopub.execute_input": "2026-02-10T22:21:18.174272Z", + "iopub.status.busy": "2026-02-10T22:21:18.174083Z", + "iopub.status.idle": "2026-02-10T22:21:18.190985Z", + "shell.execute_reply": "2026-02-10T22:21:18.190094Z", + "shell.execute_reply.started": "2026-02-10T22:21:18.174256Z" } }, "outputs": [ @@ -273,11 +273,11 @@ "id": "8a890b93-78ec-4681-bbb5-cc91e1448a85", "metadata": { "execution": { - "iopub.execute_input": "2026-02-04T22:10:01.973594Z", - "iopub.status.busy": "2026-02-04T22:10:01.973283Z", - "iopub.status.idle": "2026-02-04T22:10:01.978232Z", - "shell.execute_reply": "2026-02-04T22:10:01.977014Z", - "shell.execute_reply.started": "2026-02-04T22:10:01.973562Z" + "iopub.execute_input": "2026-02-10T22:21:18.191884Z", + "iopub.status.busy": "2026-02-10T22:21:18.191660Z", + "iopub.status.idle": "2026-02-10T22:21:18.197735Z", + "shell.execute_reply": "2026-02-10T22:21:18.196927Z", + "shell.execute_reply.started": "2026-02-10T22:21:18.191866Z" } }, "outputs": [], @@ -294,11 +294,11 @@ "id": "1dd17123-2df8-45b6-9345-d5cb6f431d51", "metadata": { "execution": { - "iopub.execute_input": "2026-02-04T22:10:01.979308Z", - "iopub.status.busy": "2026-02-04T22:10:01.979035Z", - "iopub.status.idle": "2026-02-04T22:10:02.037139Z", - "shell.execute_reply": "2026-02-04T22:10:02.036209Z", - "shell.execute_reply.started": "2026-02-04T22:10:01.979274Z" + "iopub.execute_input": "2026-02-10T22:21:18.198570Z", + "iopub.status.busy": "2026-02-10T22:21:18.198321Z", + "iopub.status.idle": "2026-02-10T22:21:18.248806Z", + "shell.execute_reply": "2026-02-10T22:21:18.248021Z", + "shell.execute_reply.started": "2026-02-10T22:21:18.198545Z" } }, "outputs": [], @@ -312,11 +312,11 @@ "id": "b4c9ad67-47fe-4408-b879-d99b8eec8ca2", "metadata": { "execution": { - "iopub.execute_input": "2026-02-04T22:10:02.038364Z", - "iopub.status.busy": "2026-02-04T22:10:02.038127Z", - "iopub.status.idle": "2026-02-04T22:10:02.042409Z", - "shell.execute_reply": "2026-02-04T22:10:02.041428Z", - "shell.execute_reply.started": "2026-02-04T22:10:02.038340Z" + "iopub.execute_input": "2026-02-10T22:21:18.249496Z", + "iopub.status.busy": "2026-02-10T22:21:18.249274Z", + "iopub.status.idle": "2026-02-10T22:21:18.253456Z", + "shell.execute_reply": "2026-02-10T22:21:18.252514Z", + "shell.execute_reply.started": "2026-02-10T22:21:18.249473Z" } }, "outputs": [], @@ -333,11 +333,11 @@ "id": "ffc07711-d8e3-49cf-9574-f2bde45ceec8", "metadata": { "execution": { - "iopub.execute_input": "2026-02-04T22:10:02.043265Z", - "iopub.status.busy": "2026-02-04T22:10:02.043015Z", - "iopub.status.idle": "2026-02-04T22:10:02.052163Z", - "shell.execute_reply": "2026-02-04T22:10:02.051178Z", - "shell.execute_reply.started": "2026-02-04T22:10:02.043238Z" + "iopub.execute_input": "2026-02-10T22:21:18.254334Z", + "iopub.status.busy": "2026-02-10T22:21:18.254078Z", + "iopub.status.idle": "2026-02-10T22:21:18.266989Z", + "shell.execute_reply": "2026-02-10T22:21:18.265814Z", + "shell.execute_reply.started": "2026-02-10T22:21:18.254309Z" } }, "outputs": [ @@ -347,6 +347,29 @@ "text": [ "[-0.2 0.2]\n" ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/santi/.miniforge3/envs/inversion_ideas/lib/python3.13/site-packages/simpeg/utils/model_builder.py:37: BreakingChangeWarning: Since SimPEG v0.25.0, the 'get_indices_block' function returns a single array with the cell indices, instead of a tuple with a single element. This means that we don't need to unpack the tuple anymore to access to the cell indices.\n", + "If you were using this function as in:\n", + "\n", + " ind = get_indices_block(p0, p1, mesh.cell_centers)[0]\n", + "\n", + "Make sure you update it to:\n", + "\n", + " ind = get_indices_block(p0, p1, mesh.cell_centers)\n", + "\n", + "To hide this warning, add this to your script or notebook:\n", + "\n", + " import warnings\n", + " from simpeg.utils import BreakingChangeWarning\n", + "\n", + " warnings.filterwarnings(action='ignore', category=BreakingChangeWarning)\n", + "\n", + " ind = get_indices_block(p0, p1, cell_centers)\n" + ] } ], "source": [ @@ -365,18 +388,18 @@ "id": "0b89b688-a595-4ff3-81e3-8bba4d4ef7c8", "metadata": { "execution": { - "iopub.execute_input": "2026-02-04T22:10:02.053261Z", - "iopub.status.busy": "2026-02-04T22:10:02.052950Z", - "iopub.status.idle": "2026-02-04T22:10:02.215148Z", - "shell.execute_reply": "2026-02-04T22:10:02.214339Z", - "shell.execute_reply.started": "2026-02-04T22:10:02.053232Z" + "iopub.execute_input": "2026-02-10T22:21:18.268171Z", + "iopub.status.busy": "2026-02-10T22:21:18.267839Z", + "iopub.status.idle": "2026-02-10T22:21:18.424560Z", + "shell.execute_reply": "2026-02-10T22:21:18.423778Z", + "shell.execute_reply.started": "2026-02-10T22:21:18.268142Z" } }, "outputs": [ { "data": { "text/plain": [ - "(,)" + "(,)" ] }, "execution_count": 11, @@ -385,7 +408,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -404,11 +427,11 @@ "id": "ff50fbfa-9dd4-4c01-a8eb-245c3c0706a0", "metadata": { "execution": { - "iopub.execute_input": "2026-02-04T22:10:02.216314Z", - "iopub.status.busy": "2026-02-04T22:10:02.215999Z", - "iopub.status.idle": "2026-02-04T22:10:05.549873Z", - "shell.execute_reply": "2026-02-04T22:10:05.549326Z", - "shell.execute_reply.started": "2026-02-04T22:10:02.216279Z" + "iopub.execute_input": "2026-02-10T22:21:18.425465Z", + "iopub.status.busy": "2026-02-10T22:21:18.425193Z", + "iopub.status.idle": "2026-02-10T22:21:22.215808Z", + "shell.execute_reply": "2026-02-10T22:21:22.212508Z", + "shell.execute_reply.started": "2026-02-10T22:21:18.425447Z" } }, "outputs": [], @@ -422,17 +445,17 @@ "id": "094b1d30-c610-44ca-968b-7257aacbaa91", "metadata": { "execution": { - "iopub.execute_input": "2026-02-04T22:10:05.550779Z", - "iopub.status.busy": "2026-02-04T22:10:05.550434Z", - "iopub.status.idle": "2026-02-04T22:10:05.696070Z", - "shell.execute_reply": "2026-02-04T22:10:05.695267Z", - "shell.execute_reply.started": "2026-02-04T22:10:05.550757Z" + "iopub.execute_input": "2026-02-10T22:21:22.216595Z", + "iopub.status.busy": "2026-02-10T22:21:22.216380Z", + "iopub.status.idle": "2026-02-10T22:21:22.378011Z", + "shell.execute_reply": "2026-02-10T22:21:22.377223Z", + "shell.execute_reply.started": "2026-02-10T22:21:22.216573Z" } }, "outputs": [ { "data": { - "image/png": "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", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAh4AAAGdCAYAAABdD3qhAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjcsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvTLEjVAAAAAlwSFlzAAAPYQAAD2EBqD+naQAAQolJREFUeJzt3QmUVOW18P1dQ0/MkzYgiEhiRDEawMuQKKAyGMVxCcR1uXCjJAYREFgqoBFwIDigryIiN3yicYBvvQaH6wQYRbkMAhcV1BCJIKgNCALdtPRUdd71PHZVunooanf1qa7h/8s6afrUrtOnTp+u2j7T9jiO4wgAAEACeBPxQwAAAEg8AABAQtHiAQAAEobEAwAAJAyJBwAASBgSDwAAkDAkHgAAIGFIPAAAQML4JQMEg0H59ttvpXnz5uLxeBr7dAAASmaty6KiIunYsaN4ve78N3NJSYmUlZU1yLGys7MlNze3QY6VbjIi8TBJR+fOnRv7NAAAcdq7d6906tTJlaSja5dmsu9AoEGO1759e9m1axfJR6ITj/fff18efPBB2bJlixQUFMiKFSvkqquuishgZ8+eLYsXL5bDhw9Lnz595IknnpCzzz47HFNaWirTpk2TF198UY4fPy4XX3yxLFy4UHXjmZYO45R5M8QbYwbquN0w4knhleqVF0f9UtXxHnePH9SFe4Luno/61lSejyeYRNdHe21cv9dcjk82rr8Pxh4aLC2R3fPmhN/PG5pp6TBJx64tXaRF8/haVAqLgtK111f2mLR6JDjxKC4ulnPPPVf+8z//U6699toajz/wwAMyf/58Wbp0qZxxxhly7733yuDBg2XHjh3hm2vy5Mny2muvybJly6Rt27YydepUufzyy20y4/P5YjqPUPeKSTq8eSQecSPxaNzEQ504kXg02rUn8Yh+eeqR2LjdXW6SjngTDzRi4nHppZfarTamtePRRx+VmTNnyjXXXGP3PfPMM5Kfny8vvPCC/P73v5ejR4/KkiVL5C9/+YtccsklNua5556z3SarV6+WoUOHunn6AIAME3CCEnDiPwbq1mhpnen72rdvnwwZMiS8LycnRwYMGCDr1q2z35tWjfLy8ogYM7CoR48e4RgAABpKUJwG2ZCEg0tN0mGYFo6qzPdfffVVOMaMDG7dunWNmNDza2PGhZgtpLCwsIHPHgCQjoL2f/EfA3Vr9I6s6v11pgvmRH14J4qZO3eutGzZMrwxowUAgAxPPMxUI6N6y8WBAwfCrSAmxowKNjNe6oqpzfTp0+34kNBmpl8BAHAiAcdpkA1JmHh07drVJharVq0K7zNJxpo1a6R///72+169eklWVlZEjJmWu3379nBMbcxYkRYtWkRsAACcCGM8UnyMx7Fjx2Tnzp0RA0o/+ugjadOmjZx66ql2quz9998vP/3pT+1m/t2kSRO5/vrrbbzpJrnhhhvsFFozldY8z6zpcc4554RnuQAAgNThauKxefNmGTRoUPj7KVOm2K9jxoyxa3fcdtttdlGw8ePHhxcQW7lyZcQCMY888oj4/X4ZMWJEeAEx89xY1/AAAEDT4hGIc1YKs1qi8zhmpGaaM7Na7CDT/zOHBcQaAguIRcUCYg14fZJsgS8WEGu8t5JgSYl8OWeGHbfnRvd56HPin39vL83jXECsqCgo3c7c59q5prqMqNUS4ngdu8VEuTheZtWe071bO25/GKiX+Nb+ct1djdH11fNT+MNY+7tV3wtuv9YMo773NfHMUE0bGZV4AAAQTUPMSmFWS3QkHgAAVGlYiX8BMST1AmIAACBz0OIBAEClQAPMaon3+emOxAMAgEqmMm381Wm5nNGQeAAAUIkxHu5jjAcAAEgYWjwAAKgUFI8EtIv31HIM1I3EAwCASkHnxy0e8T4/3dHVAgAAEoYWDwAAKgUaoKsl3uenu4xKPDzeH7fYgrVFHMTdeDUnaU5IXd9CWUvFUf4A/SvVFmtJnmtfLy7/vjT1VDyBFC8Sp5Vkt4669or6ByiOnaDlQEk83EdXCwAASJiMavEAACCaoOOxWzzifX66I/EAAKASXS3uo6sFAAAkDC0eAABUCojXbvFQjonOOCQeAABUchpgjIc5BupG4gEAQCXGeLiPMR4AACBhaPEAAKBSwPHaLR4BarVEReIBAECVyrLBODsDguolaDNLZiUePufHLSbuLpnucXtJdjX3/lAc5ZLa2nWpPcqBXK6vSq0dWBZMrmW+PS4ugW7jAy4e2+1rmaBlu13jSd34lL/2yNDEAwCAKBhc6j4GlwIAUG2MR7yb1sKFC6Vr166Sm5srvXr1kg8++CBq/Jo1a2yciT/99NNl0aJFNWJeeuklOeussyQnJ8d+XbFiRcTjc+fOlfPPP1+aN28uJ598slx11VWyY8cO1+8FEg8AABrR8uXLZfLkyTJz5kzZunWrXHDBBXLppZfKnj17ao3ftWuX/PrXv7ZxJn7GjBkyceJEm2iErF+/XkaOHCmjR4+Wjz/+2H4dMWKEbNy4MSJ5ufnmm2XDhg2yatUqqaiokCFDhkhxcbGrr9fjOOoa3imnsLBQWrZsKZ0XzRJvXm6Mz8q0MR6SPGM81KXNlWM8AsoxDMp40R6/wuUxFdrja+O1pesZ49F4tH+KSTTGI1BSIjv/NEOOHj0qLVq0ELc+J176+Axp2twX17GKiwJy7bn/iPlc+/TpIz179pQnn3wyvK979+62BcK0SlR3++23y6uvviqff/55eN9NN91kEwyTcBgm6TCv6c033wzHDBs2TFq3bi0vvvhirefx3Xff2ZYPk5BceOGF4hZaPAAAqGRmtATi3EKzYswHf9WttLS0xnUuKyuTLVu22JaGqsz369atq/X3YpKL6vFDhw6VzZs3S3l5edSYuo5pmETJaNOmjav3A4kHAAAu6Ny5s21FCW21tV4cPHhQAoGA5OfnR+w33+/bt6/W45r9tcWbrhJzvGgxdR3TdH5MmTJFfvWrX0mPHj3ETcxqAQCgQRcQ+7G/eO/evRFdLWaQZ108Hk+NRKD6vhPFV9+vOeaECRPkk08+kbVr14rbSDwAAKhkukkaagExk3ScaIxHu3btxOfz1WiJOHDgQI0Wi5D27dvXGu/3+6Vt27ZRY2o75i233GLHjLz//vvSqVMncRtdLQAAVAo4ngbZYpWdnW2nxZpZJVWZ7/v371/rc/r161cjfuXKldK7d2/JysqKGlP1mKYFxLR0/PWvf5W//e1vdjpvItDiAQBAI5oyZYqd7moSB5MwLF682E6lNTNVjOnTp8s333wjzz77rP3e7F+wYIF93rhx4+xA0iVLlkTMVpk0aZKdmTJv3jy58sor5ZVXXpHVq1dHdKWYqbQvvPCCfcys5RFqITHjUfLy8tK3xeO0006zfU7VN3NBjLFjx9Z4rG/fvo192gCANBTvjJbQpjFy5Eh59NFHZc6cOXLeeefZLo833nhDunTpYh8vKCiIWNPDtEyYx9977z0bf88998hjjz0m1157bTjGtGwsW7ZMnn76afn5z38uS5cuteuFmKm7IWb6rpnJMnDgQOnQoUN4M3FpvY6HmTdsRvSGbN++XQYPHizvvvuuvRgm8di/f7+9eFWbpjTTfULzs09d/MfY1/HQrsvhVdYXUc931x7fxdor2sn92nU2lOtUBAPK/Fm5roijXgdDeT7K43u162aUu7uOh7fCxXU8lK9Ve220dXLUf1ZOZq3LoR6TqVnHo7REvnjA/XU8/r///YU0iXMdjx+KAvLbnltdO9dU1+hdLSeddFLE93/605+kW7duMmDAgIiRwGagDAAASG2N3tVSfSGV5557Tn77299GTPkxzUlmNbUzzjjD9meZkbnRmEVaqi/cAgBAMna1ZJqkujovv/yyHDlyxHavhJj16p9//nk74vbhhx+WTZs2yUUXXVTrCnAhZpGWqou2mEVcAACIpfct3hktyh68jNPoXS1VmVG5JtHo2LFjxKCbELOamhn1awbcvP7663LNNdfUehwzAtiM9g0xLR4kHwAANL6kSTy++uorO9XHzCeOxoy4NYnHF198UWeMGRMSbYU4AADcW0AsqToTkk7SJB5m1ooZx3HZZZdFjTt06JBdhtYkIAAAJN+S6SQe0STF1QkGgzbxGDNmjF3yNeTYsWMybdo0uzjK7t277SDT4cOH2yVmr7766kY9ZwAAkKItHqaLxSyOYmazVGXWr9+2bZtdrc0MOjWtHIMGDbKLm5hV1gAAaEhBMYNDPXEfA0meeAwZMiRcWa8qs2Tr22+/3SjnBADIPHS1ZEjiAQBAMmiIdThYxyMFxngAAIDMkFEtHqaeisfnuFJ7xaut1aI9vou1V7S1XbS1WrRnrq294tGWalHWIlHn50HlK1Z3B2sLaCiPrq1foq2noqjt4qlw+Vy0tV3crtXi8tAA7WQLbbzHxeNrf7f1FTQLgKmL2tQ8BuqWUYkHAAAnWoMj3q4S1vGIjq4WAACQMLR4AABQKeh47RaPeJ+f7kg8AACoFBCP3eIR7/PTHWkZAABIGFo8AACoRFeL+0g8AACoZGbtxt/VgmjoagEAAAlDiwcAAJXoanEfiQcAAJUoEuc+Eg8AACo54om7rL05BuqWUYmHzx8Urz/oSi0Vn1dX4MLv08V7lcf3KO97TS0YbR0CR1mvoiLgU8brhipVeHTHD2hfb4z1gEI86toxOtoyP9qaGOr6KOXuxNbnXNTxSVarxXG77JC29orPvfPR1u1B8sqoxAMAgGjoanEfiQcAAJWoTus+ptMCAICEocUDAIBKAfHaLR7xPj/dkXgAAFCJrhb3kZYBAICEocUDAIBKQfHaLR7xPj/dkXgAAFBl3R7t2j3Vxfv8dEdaBgAAEoYWDwAAKjG41H0kHgAAVHIcr61QG+8xULeMSjy8vqD4YqyREmtcSJZfV/QhyxtwtbaLtnaMplaLVkBZ8KFcWaultEIZr4rWF8QIBLWFcsRdyvPx6G4ddT0Vb5l7x/a5Xdsl6N7fieEoiyw5LtdSUZY1Eu3l0Zy/k6BaLQHx2C3eY6BupGUAACBhMqrFAwCAE7XaaCtw13YM1I3EAwCASsEGGOMR7/PTHVcHAAAkDC0eAABUCorHbvGI9/npjsQDAIBKrFzqPrpaAABA5iQes2bNEo/HE7G1b98+/LjjODamY8eOkpeXJwMHDpRPP/20Uc8ZAJDeg0vj3VC3pLg6Z599thQUFIS3bdu2hR974IEHZP78+bJgwQLZtGmTTUoGDx4sRUVFjXrOAIA0HePhxLkxxiP5Ew+/328TitB20kknhVs7Hn30UZk5c6Zcc8010qNHD3nmmWfkhx9+kBdeeKGxTxsAAKRi4vHFF1/YrpSuXbvKqFGj5Msvv7T7d+3aJfv27ZMhQ4aEY3NycmTAgAGybt26Oo9XWloqhYWFERsAACfiVM5qiWczx0ASz2rp06ePPPvss3LGGWfI/v375d5775X+/fvbcRwm6TDy8/MjnmO+/+qrr+o85ty5c2X27Nk19mf5g+KLsaZKdpauMEC2T1f0Iddf7urxs7W1YJS1XTQqlLVaSgK62/KH8mxVvLIchnoVw2CFtt6GNv93ufaKsiaGup6KolaLT1lYx1fmuPpaXa/VorwVgj53a7UEsty914JZscc6yro69UV12gxIPC699NLwv8855xzp16+fdOvWzXap9O3b1+43A06rMl0w1fdVNX36dJkyZUr4e9Pi0blzZ1fOHwCQPli5NEO6Wqpq2rSpTUBM90todkuo5SPkwIEDNVpBqjLdMS1atIjYAABA40u6xMOMz/j888+lQ4cOdsyHST5WrVoVfrysrEzWrFlju2MAAGhIcc9oqdyQxF0t06ZNk+HDh8upp55qWzLMGA/TNTJmzBjbnTJ58mS5//775ac//andzL+bNGki119/fWOfOgAgzbBkegYkHl9//bX85je/kYMHD9pptGZcx4YNG6RLly728dtuu02OHz8u48ePl8OHD9vBqCtXrpTmzZs39qkDAIBUSzyWLVsW9XHT6mFWLjUbAABuYlZLBiQeAAAkCxKPDBxcCgAA0hctHgAAVKLFw30kHgAAVCLxcB9dLQAAIGEyqsXD1F/xZcVWrCDXryvi0CRLUYBCRJop45v4dfF5Pl0BDb/HvUIIFcoCEcUVutorhcq6NFqBgC4/D5TrXm+F1936H9r6GR5l/RLlraaqv+I/rrs2/hJlrZbyoKvX0vVaLX5lHaFsd2uvBFxcOMtR3pf1/jmVa3nEewzULaMSDwAAoqGrxX10tQAA0MhLpi9cuNCWCcnNzZVevXrJBx98EDXelA4xcSb+9NNPl0WLFtWIeemll+Sss86y9cvM1xUrVkQ8/v7779uVwzt27GjXzHr55ZcTch+QeAAA0IiWL19uy4PMnDlTtm7dKhdccIGt3L5nz55a43ft2iW//vWvbZyJnzFjhkycONEmGiHr16+XkSNHyujRo+Xjjz+2X0eMGCEbN24MxxQXF8u5554rCxYskETyOKbGfJoztV9atmwp5/7fqeJrkhPTcxjjkUJjPMpyVfFHSvN0xz+uO/4PP8R2j4VUFOt6PH3FuuvpL9L994W/WBUuWT/o4v2KeMZ4NO4Yj4DL8cEsxbHLSmTbn2fI0aNHXak4HvqcuPC18eJvqvsbrq6iuFTeH74w5nPt06eP9OzZU5588snwvu7du8tVV10lc+fOrRF/++23y6uvvmoLqobcdNNNNsEwCYdhkg7zmt58881wzLBhw6R169by4osv1jimafEwLSLmZ7qNFg8AAFzoajEf/FU3U329OlNxfcuWLTJkyJCI/eb7devWSW1MclE9fujQobJ582YpLy+PGlPXMROJxAMAABd07tzZtqKEttpaLw4ePCiBQEDy8/Mj9pvv9+3bV+txzf7a4isqKuzxosXUdcxEYlYLAACVHMdjt3iEnr93796IrhYzyLMupqujKjMKovq+E8VX3689ZqKQeAAAUMms4RHvOh6h55uk40RjPNq1ayc+n69GS8SBAwdqtFiEtG/fvtZ4v98vbdu2jRpT1zETia4WAAAaSXZ2tp0Wu2rVqoj95vv+/fvX+px+/frViF+5cqX07t1bsrKyosbUdcxEosUDAIBGXEBsypQpdrqrSRxMwrB48WI7ldbMVDGmT58u33zzjTz77LP2e7PfTIE1zxs3bpwdSLpkyZKI2SqTJk2SCy+8UObNmydXXnmlvPLKK7J69WpZu3ZtOObYsWOyc+fOiGm6H330kbRp00ZOPfVU1+4JEg8AAFwY4xGrkSNHyqFDh2TOnDlSUFAgPXr0kDfeeEO6dOliHzf7qq7pYRYaM4/feuut8sQTT9gFwB577DG59tprwzGmZWPZsmVy5513yl133SXdunWz64WYqbshZhbMoEGDwt+bRMYYM2aMLF26VNySUet49P7r5JjnZzfLVhSUMH152vis46r4Vsr4ZpqCGGbdEm/sBTe8ygIO5UFdflsY0K2zcaisiSr+wPHmuvjiZqr4o8W68y8r0q0Z4C3SreORdVTXo5pVpAqXrGO6+Oyi2N9yso/p7jXfcV3dHl+ptlaL7u1S+/nl+HS/q2C2so5Qri6+Ile5jkeOLr5CEW/W8fhkqfvrePzbikkNso7Hh1f/H9fONdXR4gEAQCVqtbiPxAMAgEbsask0JB4AAFRJGuIdXEriER3TaQEAQMLQ4gEAQCUzfDjeKRdpP2MjTiQeAABUWXXU/C8e8a58mu7oagEAAAlDiwcAAJWY1eI+Eg8AACqZGS2eBC+ZnmnoagEAAAlDiwcAAJXMjJa4Z7UwrSWqjEo8cv3l4vfH1sjTLKvM1dorJ2XrCly0UxbEaOPXxTfxxv56faKrb1Hm6GqLfB/Q1Ubxe3T1OSqCuvMpLs9WxR8rUdZ58Lr8LqU8vKdCF+8r1f2ArB9iv3/8xbrfrf9Y7DWHDO9xXbwnqLv3xaNrcneydPdmIE/3Fu5R1k0yf+26H6ALdzRt7uWJ+TRnjIf76GoBAAAJk1EtHgAAREOLh/tIPAAAqMSsFveReAAAUInBpRkwxmPu3Lly/vnnS/PmzeXkk0+Wq666Snbs2BERM3bsWPF4PBFb3759G+2cAQBAiiYea9askZtvvlk2bNggq1atkoqKChkyZIgUFxdHxA0bNkwKCgrC2xtvvNFo5wwASOcWD0+cW2O/iuTW6F0tb731VsT3Tz/9tG352LJli1x44YXh/Tk5OdK+fftGOEMAQKZgcGkGtHhUd/ToUfu1TZs2Efvfe+89m5CcccYZMm7cODlw4ECdxygtLZXCwsKIDQAANL6kSjwcx5EpU6bIr371K+nRo0d4/6WXXirPP/+8/O1vf5OHH35YNm3aJBdddJFNMOoaN9KyZcvw1rlz5wS+CgBAqnIaaEMSd7VUNWHCBPnkk09k7dq1EftHjhwZ/rdJSHr37i1dunSR119/Xa655poax5k+fbpNYEJMiwfJBwDgROhqyaDE45ZbbpFXX31V3n//fenUqVPU2A4dOtjE44svvqj1cTMexGwAACC5+JOhe8UkHStWrLDjOLp27XrC5xw6dEj27t1rExCNXH+F+P2x1R5o4tfVammlrNWirb3SIeuwKv5kv25cS3NvScyxWR5dvYoSZX2IFr7Yz6U+tWOOB7JU8d9nNVHFZ2fpip0c97jbMKv8dYlXW6tF96civuOxn1BWke7g3kLdveM5Xnt3bZ0qtBdH15vtydbVBZIKd/8Dy/Hqiq8Ela/X64/9+I7y0tdbQ/SV0NeS3GM8zFTa5557Tl544QW7lse+ffvsdvz4jx/kx44dk2nTpsn69etl9+7dNjkZPny4tGvXTq6++urGPn0AQDqJeyqtxx4DSdzi8eSTT9qvAwcOrDGt1iwc5vP5ZNu2bfLss8/KkSNHbCvHoEGDZPny5TZRAQCgobByaYZ0tUSTl5cnb7/9dsLOBwAApHHiAQBAsmBWi/tIPAAACGmIMRqM8UjuwaUAACBz0OIBAEAlBpe6j8QDAIAQ1vFwHV0tAAAgYWjxAACgErNa3EfiAQBAVSx57qqMSjyyvEHJ8gZiis3zlauO3cynq/nQ0veDKr6tX1fbpb2vSHc+igIduR7dVLMSr+7a5AZ1RRlKgrraKwezdCveNsvS1Qvx+3TFUTzeJKvVEtufSJivVHf+/pLYf4D3B9219xQVq+KdH3R/h1KuLBiSpXuL9eTmquK9yloqTpZPd3xtfI7ufDwBxb0TJBtIFxmVeAAAEA1dLe4j8QAAIIRZLa4j8QAAIMx0F8VbXZbqtNEwnRYAACQMLR4AAITQ1eI6Eg8AAEJIPFxHVwsAAEgYWjwAAKha0j7esvbxPj/NkXgAAFCJ6rTuo6sFAAAkDC0eAACEMLjUdRmVePi9QbvFIltRu8TI9epquzT3lajiW3l/cK32itHGG3u9kxyP7rYpdXTnUi66+hytfLr6HM2U1157L/g8ypoSbncHO27XdtH9AG9Z7D/AU6L7u5JSXV0gp/i4Lr5Cdz4ev66OkJZHWQvGm6M7H09AefyAz7V7TXtf1htjPFxHVwsAAEiYjGrxAAAgGtNgqW20rO0YqBuJBwAAIYzxcB2JBwAAIYzxcB1jPAAAQMLQ4gEAQAhdLa4j8QAAIITEw3V0tQAAgIShxQMAgBBaPFxH4gEAQAizWlxHVwsAAEiYjGrx8Ipjt1j4lAUusjwBVbxPdIUHspSFCrI9ugIgmvorWcpaLVq5nnKXr72ytojH3fik47gdr3hCUHffO+UVrtZecQK6e03LE8jRPSEQdO/a2/ooyl+uMj4Za7Wwcqn7UqbFY+HChdK1a1fJzc2VXr16yQcffNDYpwQASNcxHvFuLn/GrVmzxsaZ+NNPP10WLVpUI+all16Ss846S3JycuzXFStWxP1zMybxWL58uUyePFlmzpwpW7dulQsuuEAuvfRS2bNnT2OfGgAACf2M27Vrl/z617+2cSZ+xowZMnHiRJtohKxfv15Gjhwpo0ePlo8//th+HTFihGzcuLHeP7eheBxH2fbWCPr06SM9e/aUJ598Mryve/fuctVVV8ncuXNP+PzCwkJp2bKlXLnyt5LVNDumn9k+t1B1jp1zv1fFd8k+qIo/Pfs7VfwpPl1p+bbeXNe6WsodXfP3gaCuVPkX5S1U8R8f76KK/6iosyp+x+GTVfH7D+rO33Motns4JOc73X9f5OluNWlyQNf9kLe/JOZY/wHd36Fz6LAqPlhU5GpXi8enKxPvbdZMd/zmunindXNVfEXL2N8XjPLmWbr4ZrFfn4ryEtm04k45evSotGih+5uJRehz4tR594o3T/e6qwseL5E9t8d+rn2Un3G33367vPrqq/L555+H99100002wTAJh2GSDvOa3nzzzXDMsGHDpHXr1vLiiy/W6+dmTItHWVmZbNmyRYYMGRKx33y/bt26Wp9TWlpqL3jVDQCAE/FUGedR763yWNU/h8xnU0N8xpnkonr80KFDZfPmzVJeXh41JnTM+vzcjEk8Dh48KIFAQPLz8yP2m+/37dtX63NMpmYy19DWubPuv1gBABk+nTbezbSEd+4c8VlUWyvCwXp8xpn9tcVXVFTY40WLCR2zPj8342a1eKrN0jA9RNX3hUyfPl2mTJkS/t5kmiQfAIBE2rt3b0RXixnk2RCfcXXFV98fyzG1PzcjEo927dqJz+erkYEdOHCgRqZW9Zcb7RcMAIDbK5eapONEYzza1eMzrn379rXG+/1+adu2bdSY0DHr83MzpqslOzvbTvFZtWpVxH7zff/+/RvtvAAAaSjB02mz6/EZ169fvxrxK1eulN69e0tWVlbUmNAxG/OzNelbPAzTbWKmApmLai7m4sWL7XQfM4oXAIBUNuUEn3Fm+MA333wjzz77rP3e7F+wYIF93rhx4+xA0iVLloRnqxiTJk2SCy+8UObNmydXXnmlvPLKK7J69WpZu3ZtzD83oxMPMy3o0KFDMmfOHCkoKJAePXrIG2+8IV266KZFAgCQbCuXjjzBZ5zZV3VtDbPgl3n81ltvlSeeeEI6duwojz32mFx77bXhGNNqsWzZMrnzzjvlrrvukm7dutl1O8wU2lh/bkav49FQ87OHr7wh5nU88pXreJySc0QV3zVHt1jCaVm6+I4+3VoYbbxZriyvbpQq1/HYH9TFf1neShW/rUQ3y+njQnfX8fjuUPPkWsfjoNvreNScUlgX/3e6dTbkyFFVeLDwmKtLrHv8unUtPE3z3F3Ho6UuvryVbj2LCuU6HmXNvKp1PDa/5P46Hqfde594c+Ncx6OkRHbfOdO1c011ST/GAwAApI+U6GoBACDVZrWgdiQeAABUojqt++hqAQAACUOLBwAAIVWWPK+3eJ+f5kg8AAAIYYyH60g8AACoxBgP9zHGAwAAJAwtHgAAhNDV4joSDwAAQhpgyXTW8YiOrhYAAJAwGdXiURH0iicYW65VFtRdmpKgrkZBUUBXC+CIr4kqvqlHV1NCJPb4XI+ulkqJshzQkWCOLj7QVBV/THnttfdCQDuVzu1VDrWno/zPkaBP9wOC2bH/ACdXWeskR3fveJrq6sx4ynXnI1m6e8ejrRGSq3u9wWzd+Tg+3c0Q9Ll3r2nvy3qjq8V1GZV4AAAQFYmH6+hqAQAACUOLBwAAlVjHw320eAAAgIQh8QAAAAlDVwsAACEMLnUdiQcAAJUY4+E+Eg8AABK5tk6GY4wHAABIGFo8AAAIYYyH60g8AACoxBgP92VU4lEe9IoTYzGB4wFdTYZjAV3NhKMBXe2VJhWlqnifBFXxxU5JzLFZHt2xS5S1Tr4PNlPFf1fRXBV/uFx37Y+VZ6viKwK6Hkwn6HGz9Eo9aq/o4gM5ujOqyI39B/ia6K69t0JXt8fjV74FVujqFImy1olk615vMFcb73Otro6N9+vuBUdT5yegvfORrDIq8QAAICq6WlxH4gEAQCW6WtzHrBYAAJAwtHgAABBCV4vrSDwAAAgh8XAdXS0AACBhaPEAAKASg0vdR+IBAEAIXS2uI/EAACCExMN1jPEAAADpn3js3r1bbrjhBunatavk5eVJt27d5O6775aysrKIOI/HU2NbtGhRY502ACADxnjEuyEJu1r+/ve/SzAYlKeeekp+8pOfyPbt22XcuHFSXFwsDz30UETs008/LcOGDQt/37Jly3r9zJIKv/grYnvJP/h0NRCOePNU8VmegLip1NHVmmnijUz4GrIOTJmjqw/xfUBXq6WgrJXu+GW6eh7FylotZeXKPyvH3RoU6lotytMP6C6PBPJiP6HyCt3B/R7dtfRm616sJ6i790V5Pk6W7m8lkOd3Nz5XWasl2+Pavaa99PVGV0v6Jh4mkaiaTJx++umyY8cOefLJJ2skHq1atZL27ds3wlkCAIC0HeNx9OhRadOmTY39EyZMkHbt2sn5559vu1lMS0k0paWlUlhYGLEBAHAidLVk0KyWf/7zn/L444/Lww8/HLH/nnvukYsvvtiOA3nnnXdk6tSpcvDgQbnzzjvrPNbcuXNl9uzZCThrAEBaoasl9Vo8Zs2aVeuA0Krb5s2bI57z7bff2m6X6667Tm688caIx0yC0a9fPznvvPNs0jFnzhx58MEHo57D9OnTbetJaNu7d29Dv0wAAJAMLR6mW2TUqFFRY0477bSIpGPQoEE2uVi8ePEJj9+3b1/bdbJ//37Jz8+vNSYnJ8duAACo0OKReomHGYthtlh88803Nuno1auXnbni9Z64AWbr1q2Sm5trB5wCANCQzLyceOeZuTtPLfU12hgP09IxcOBAOfXUU+0slu+++y78WGgGy2uvvSb79u2zrSFmjMe7774rM2fOlN/97ne0aAAAkIIaLfFYuXKl7Ny5026dOnWKeMxxflx9JSsrSxYuXChTpkyxM1nMlFszxuPmm29upLMGAKQ1ulrSN/EYO3as3TRrfQAA4Caq02bQdFoAABodLR6ZtYAYAABIbxnV4lFSkSX+ithqmBzz6goDeF2uClSurHdSFMhVxed6y2OO9Xp016ZcWfyjMKCre3OorIkq/vtSXXxxma5eSCCgLY7i8hh45eEdba2WHN0PKG8S+/VR3mrqujS+HN3flSfouFqGx/Fpa6N4Xa29UpGrewEBZa2WQFbs8QGXaxpFoMibqzIq8QAAIBrGeLiPrhYAAJAwtHgAABDC4FLXkXgAAFCJrhb30dUCAAAShhYPAABC6GpxHYkHAACV6GpxH10tAAAgYWjxAAAghK4W15F4AAAQQuLhOhIPAAAqMcbDfRmVeJQHfRIMxFab4YdyXX0OraCy7kCZst5JkU9Xq8XvCYhbKpR1ZoordNe+sEz3Wo+U6mrBlJTHVt8nJFChe72Osh6JlrZ+ifJWk6DyT6UiT3Pv607e71fWCsnVXXxt7Rj3f1e61xvU1lJxOV5TF8jtvxMkTkYlHgAAREVXi+uY1QIAQCWP4zTI5pbDhw/L6NGjpWXLlnYz/z5y5EjU5ziOI7NmzZKOHTtKXl6eDBw4UD799NOImNLSUrnlllukXbt20rRpU7niiivk66+/joi57777pH///tKkSRNp1apVvV8DiQcAACni+uuvl48++kjeeustu5l/m+QjmgceeEDmz58vCxYskE2bNkn79u1l8ODBUlRUFI6ZPHmyrFixQpYtWyZr166VY8eOyeWXXy6BwL+64cvKyuS6666TP/zhD3G9BrpaAABIga6Wzz//3CYbGzZskD59+th9//Vf/yX9+vWTHTt2yM9+9rOap+I48uijj8rMmTPlmmuusfueeeYZyc/PlxdeeEF+//vfy9GjR2XJkiXyl7/8RS655BIb89xzz0nnzp1l9erVMnToULtv9uzZ9uvSpUvjeh20eAAAUG1WS7ybUVhYGLGZ7ox4rF+/3navhJIOo2/fvnbfunXran3Orl27ZN++fTJkyJDwvpycHBkwYED4OVu2bJHy8vKIGNMt06NHjzqPGw8SDwAAXGBaDEJjMcw2d+7cuI5nEoiTTz65xn6zzzxW13MM08JRlfk+9Jj5mp2dLa1bt64zpiHR1QIAgAtdLXv37pUWLVpEtDTUxgz8DHVj1MWMzTA8Hk+t3Sm17a+q+uOxPCeWmPog8QAAwIUFxEzSUTXxqMuECRNk1KhRUWNOO+00+eSTT2T//v01Hvvuu+9qtGiEmIGkhmm56NChQ3j/gQMHws8xMWbgqJkxU7XVw8SYWSwNja4WAAAaUbt27eTMM8+MuuXm5tpBpGYg6Icffhh+7saNG+2+uhKErl272sRi1apV4X0myVizZk34Ob169ZKsrKyImIKCAtm+fbsriQctHgAApMCslu7du8uwYcNk3Lhx8tRTT9l9v/vd7+y016ozWkyiYsaTXH311barxEyVvf/+++WnP/2p3cy/zVocZmquYcaf3HDDDTJ16lRp27attGnTRqZNmybnnHNOeJaLsWfPHvn+++/tVzPN1kzlNX7yk59Is2bNYn4dJB4AAKRIrZbnn39eJk6cGJ6BYhb6MutzVGWm1ppWkJDbbrtNjh8/LuPHj7fdKWZWzMqVK6V58+bhmEceeUT8fr+MGDHCxl588cV22qzP968SEH/84x/tVNyQX/ziF/bru+++axcli5XHMaNH0pyZxmQyuu4v3i6+JrUP7qkuO6tC9TOyfbpaJ7n+clePn+3Vxfu97hVCqAjqevRKArp8WFtXp7hMF/9DiS6+/Lju/B1lvPe47nr6ipX1To6rwsWnjPeXKI6tnH3oK9O9nXl1f+biCbr7dul4lbVXdGWBRFk2SQJZ7tVeMYKKMkiB0hL5dNEM+4Eay7iJ+n5O9Bpxn/iydfWfqguUlciW/3+ma+ea6hjjAQAAEoauFgAAEtRVAhIPAAD+xYw+iHcEQvqPYIgLXS0AACBh6GoBACBFZrWkAxIPAABSYB2PdEFXCwAAyIzEw6w9b1ZVq7rdcccdETFmhbThw4dL06ZN7bKyZuEUs9wrAAANzRNsmA1J3NUyZ84cu/xrSNVlV82SrJdddpmcdNJJsnbtWjl06JCMGTPGVsx7/PHHG+mMAQBpi66W9E88zJKtoep51ZklXT/77DNbWrhjx45238MPPyxjx46V++67jxXhAABIMY0+xmPevHm2KM15551nk4mq3Sjr16+XHj16hJMOY+jQoVJaWipbtmyp85jmcbP8bdUNAIBYZ7XEuyFJWzwmTZokPXv2lNatW9syv9OnT5ddu3bJn//8Z/v4vn37JD8/P+I5JjY7O9s+VhdTlW/27Nk19pdXeCVYEVuxgqCjq1EQ8OtyuIqAsn6GT9dp6FPWXvG6+JcSUNZqKQ/oCkqUVijjy7J051+uO76j/N1KUHevaTna01G+K3h0l1MCiltT+Wcojk/3BI+upJHrffeOx+Pq71Zbq0Ubr713NOevrUtTbywglnotHrNmzaoxYLT6tnnzZht76623yoABA+TnP/+53HjjjbJo0SJZsmSJHcsRYuKrM2M8atsfYhIYU5wntJmuGgAAToQWjxRs8ZgwYYKMGjXqhLNZatO3b1/7defOnbb7xYz92LhxY0SMKelbXl5eoyWkqpycHLsBAIA0TzzMlFez1cfWrVvt1w4dOtiv/fr1s+M+CgoKwvvMgFOTVPTq1asBzxoAAGa1pPUYDzNwdMOGDTJo0CBp2bKlbNq0yXa9XHHFFXLqqafamCFDhshZZ50lo0ePlgcffFC+//57mTZtmp1+26JFi8Y6dQBAmmLJ9DROPEyrxfLly+0gUDMLpUuXLjahuO2228IxPp9PXn/9dRk/frz88pe/lLy8PLn++uvloYceaqzTBgAAqZh4mNkspsXjREzrx3//938n5JwAABmOWS3pv4AYAADJgq6WDFhADAAAZA5aPAAACKFWi+tIPAAAqERXi/voagEAAAmTUS0eQVNDI8Y6GtpaLUFlvY2AT5fzeTUFLuxS8+JarRbttTGDxDUqlLVatHVvKpS1VwLluuM7AU9S1f8Qr+4X4HiV976yVouqLJC6Vou4W6tFXTxGF65+vdoyP9q6PW7XgtHUalH+ruot6Py4xXsM1CmjEg8AAKJijIfrSDwAAKhkGpHiLdbtbr3p1McYDwAAkDC0eAAAEMLKpa4j8QAAoBLTad1HVwsAAEgYWjwAAAhhVovrSDwAAKjkcRy7xSPe56c7uloAAEDC0OIBAECIWUk43tWE3V6NOMWReAAAUImuFvdlVOIRqPCKUxFb75LH5foWAWURBE0tlfrwKI7vaGu11KemjpvxFcp1BZV1eDzKWi3qC6SkLi+irbeh/K87TW0X7blra694tfU/tL8rl2u1aGlqo9QnXlw8vpOoWi1wXUYlHgAARMWsFteReAAAEMLKpa4j8QAAoBIrl7qP6bQAACBhaPEAACCErhbXkXgAAFDJE/xxi0e8z093dLUAAICEocUDAIAQulpcR+IBAEAI63i4jq4WAACQMLR4AABQiVot7suoxMMJesSJsY6GiVUdW1nbxaOsyRBQ1mrR1F7R0tZq0RbcUNf+UNZq0dZecZS1XTzK46sLkmhpT8frbm2XoIt/J17luQeU567+s3K5Do+4fau5fO9ojq+9z+qNMR6uo6sFAAAkTEa1eAAAcMJWqnjX4XC7pSvFkXgAAFCJMR5p3NXy3nvvicfjqXXbtGlTOK62xxctWtRYpw0ASPvptE6cW2O/iOTWaC0e/fv3l4KCgoh9d911l6xevVp69+4dsf/pp5+WYcOGhb9v2bJlws4TAACkQeKRnZ0t7du3D39fXl4ur776qkyYMMG2alTVqlWriFgAAFzBrJbMmdViko6DBw/K2LFjazxmkpF27drJ+eefb7tZgkEq8AAAXBBsoA3JP7h0yZIlMnToUOncuXPE/nvuuUcuvvhiycvLk3feeUemTp1qE5Q777yzzmOVlpbaLaSwsNDVcwcAAI3U4jFr1qw6B42Gts2bN0c85+uvv5a3335bbrjhhhrHMwlGv3795LzzzrNJx5w5c+TBBx+Meg5z586140BCW/VkBgCAaLNa4t2QwBYP0y0yatSoqDGnnXZajcGjbdu2lSuuuOKEx+/bt69twdi/f7/k5+fXGjN9+nSZMmVK+HsTT/IBADghxnikXuJhxmKYLVaO49jE4z/+4z8kKyvrhPFbt26V3NxcO+C0Ljk5OXYDAADJpdHHePztb3+TXbt21drN8tprr8m+fftsV4sZ4/Huu+/KzJkz5Xe/+129Egsn6LVbjNHKYyvreWiLPmiLViQR7bVRz4HX1oKJsV5P/Wuv6MJdLKtT+QOSrD6Hi69X+6tS/65SfdBgktV2UdVqSdRUCFo80j/xMINKzZoe3bt3r/GYaQFZuHCh7TYxM1lOP/10O8bj5ptvbpRzBQCkORKP9J9O+8ILL8j//M//1PqYWTTMdK0UFRVJcXGxbNu2TSZNmiR+f6PnSwAAJNzhw4dl9OjR4ckT5t9Hjhw54ZAGM/GjY8eOtvdg4MCB8umnn0bEmJmgt9xyix0q0bRpUzvm0kz8CNm9e7ftmejatas9Rrdu3eTuu++WsrKy1Es8AABIGkm+jsf1118vH330kbz11lt2M/82yUc0DzzwgMyfP18WLFhgS5KYBTkHDx5s/6M+ZPLkybJixQpZtmyZrF27Vo4dOyaXX365BAIB+/jf//532/Pw1FNP2aTlkUcesetqzZgxQ/0aPI5JhdKcmdVip9UumiXevFyXOn/F5TEekrJSfoyHMl60x6/QjjkRd4+vjf/xfcmVePVr1b7hM8YjZcZ4BEpKZOefZsjRo0elRYsW4tbnxCVnTBG/L77JCRWBUln9j/kNfq6ff/65nHXWWbJhwwbp06eP3Wf+bcZBmsTgZz/7WY3nmI9409JhEovbb7893LphZoXOmzdPfv/739vzPOmkk+Qvf/mLjBw50sZ8++23djboG2+8YdfYqo1Z2uLJJ5+UL7/8UvU6aPEAAOBfn9QNs1UmM1W3qgtb1sf69ettchRKOkJLTJh969atq/U5ZvKGmaQxZMiQ8D4zOWPAgAHh52zZssWWLakaY5KVHj161HlcwyQsbdq0Ub8OEg8AAFxgWgyqLmZpFreMh0kgTj755Br7zT7zWF3PMaqve2W+Dz1mvpr6aa1bt64zprp//vOf8vjjj8tNN92kfh2M0gQAICToxD/H3RxDRPbu3RvR1VLXMhCzZs2S2bNnRz2kGZthVC+iGupOqW1/VdUfj+U5dcWYbhgz+eO6666TG2+8UbRIPAAA+NenbbirpN4qn2+SjljGeEyIccXvTz75xK7aXd13331X50reocrupuWiQ4cO4f0HDhwIP8fEmNkpZsZM1VYPE2OWu6iedAwaNMiOK1m8eLHUB10tAAA0onbt2smZZ54ZdTMrdpsPezOu4sMPPww/d+PGjXZf9QQhxEx/NYnFqlWrwvtMkrFmzZrwc3r16mXXzaoaU1BQINu3b4847jfffGOn4vbs2dOuOO711i+FIPEAACCsIQaWujNZtHv37raLY9y4cXY2i9nMv82016ozWkyiYqbGGqarxMxouf/+++0+k0yMHTtWmjRpYqfmGmb8iVmjwxRiNVXgzfpZ//7v/y7nnHOOXHLJJeGWDpN0mHErDz30kG1lMa0odY0BiYauFgAAUmTl0ueff14mTpwYnoFiFvoy63NUtWPHDtsKEnLbbbfJ8ePHZfz48bY7xcyKWblypTRv3jwcY9blMItzjhgxwsZefPHFsnTpUvH5fPZxE79z5067derUqdrL1b3ezFrH44nZsa/j4fY6G66vy+EkzwlpT0W57of2Dlavy6Fdh0S9roVy3Qzt9VSvW+Ly+QddPBf1GjAuHz+F/2wTso6H6Nbx+Of9CVjHo+st4vfGuY5HsFRW73rctXNNdbR4AAAQMSOlYWa1oHYkHgAAhDjBH7d4xPv8NMfgUgAAkDC0eAAAkCKDS9MBiQcAACGM8XAdiQcAACG0eLiOMR4AACBhaPEAACDEzqaNd4wHlzMaEg8AAELoanEdXS0AACBhMqrFQ7UujEe5DLTrS6BrJc8JOW4vY61d0lwd7/Y600lGe/pe3S/McfPeVP+uXI7PMG4use4k6j+Tg+YmCjbAMVCXjEo8AACIiq4W19HVAgAAEoYWDwAAQmjxcB2JBwAAIaxc6jq6WgAAQMLQ4gEAQCXHCdotHvE+P92ReAAAUHWMh+1uiQPVaaMi8QAAICJpIPFwE2M8AABAwtDiAQBA1VVHPXGO0WCMR1QkHgAAhNDV4rqMSjxMTY9Y63poaw6oewQ9KVz0QXlx1C9VHe/yL8tJ8V+ti/Uz6nP5PW7W59C+VifJ4pONy2WHVPcOAwPSRkYlHgAAROMEg+LE2dXCdNpGzCHvu+8+6d+/vzRp0kRatWpVa8yePXtk+PDh0rRpU2nXrp1MnDhRysrKImK2bdsmAwYMkLy8PDnllFNkzpw54jBdCQDg1pLp8W5onBYPk0Bcd9110q9fP1myZEmNxwOBgFx22WVy0kknydq1a+XQoUMyZswYm1Q8/vjjNqawsFAGDx4sgwYNkk2bNsk//vEPGTt2rE1Upk6d6ubpAwCAVEo8Zs+ebb8uXbq01sdXrlwpn332mezdu1c6duxo9z388MM2sTCtJS1atJDnn39eSkpK7DFycnKkR48eNvmYP3++TJkyRTyaDmMAAKIxi4fFO1CLFo/kHa6zfv16m0iEkg5j6NChUlpaKlu2bAnHmG4Wk3RUjfn2229l9+7dtR7XPN+0lFTdAAA4IdtVEoxzo6slaROPffv2SX5+fsS+1q1bS3Z2tn2srpjQ96GY6ubOnSstW7YMb507d3btNQAAABcTj1mzZtnujWjb5s2bYz5ebV0lZoxH1f3VY0IDS+vqZpk+fbocPXo0vJmuHAAATsQJOg2yoQHHeEyYMEFGjRoVNea0006L6Vjt27eXjRs3Ruw7fPiwlJeXh1s1TEz1lo0DBw7Yr9VbQkJMt0zVrhkAAGJfdZSVS5Mq8TBTXs3WEMxsFzOItKCgQDp06BAecGqShl69eoVjZsyYYWfImC6YUIwZFxJrggMAQCxsi0Wcg0tZ7qERx3iYNTo++ugj+9VMnTX/NtuxY8fs40OGDJGzzjpLRo8eLVu3bpV33nlHpk2bJuPGjbMzWozrr7/eJiJmpsv27dtlxYoVcv/99zOjBQCAFOTqdNo//vGP8swzz4S//8UvfmG/vvvuuzJw4EDx+Xzy+uuvy/jx4+WXv/ylXSDMJBoPPfRQ+DlmcOiqVavk5ptvlt69e9vBp2Yardm02WewpCT257g9Szfp1tVWyLQl05WtrrEuy1/vJdl14SLK81Ev2ujm9XF7ufpki082rr8Pxh4aLC1JSGtChVMad5G3CilvsPNJRx4nA9qEvv76a2a2AEAaMJMFOnXq1ODHNetFde3atc7ZklpmfOKuXbskNze3QY6XTjIi8QgGg3bdj+bNm0fMhDHre5iptuZGDnXtoGFxjROD68w1Tvd72XxUFRUV2fF9Xq87owRM8lG9ZEd9mTGJJB0ZXCTO3KTRMmRzc5N4uItrnBhcZ65xOt/LpuvdTSZRIFlwH4WGAQBAwpB4AACAhMnoxMNM07377rtZbIxrnPK4l7nG6YJ7Of1lxOBSAACQHDK6xQMAACQWiQcAAEgYEg8AAJAwJB4AACBhMiLxMBVw+/fvL02aNJFWrVrVGmMK2Q0fPlyaNm1qq+9OnDixxgp227ZtkwEDBtiaMqeccorMmTOHKoRRmOrBZqXYqtsdd9yhvu6IbuHChXapZ7Pwkanq/MEHH3DJ6mnWrFk17lmz9HWIGYtvYszqmeZ9wNSc+vTTT7neJ/D+++/bv3Nz3cw1ffnllyMej+W6lpaWyi233GLfJ8z7xRVXXGHLYSD1ZETiYT7IrrvuOvnDH/5Q6+Omcu5ll10mxcXFsnbtWlm2bJm89NJLMnXq1IhlfAcPHmz/MDZt2iSPP/64LWY3f/78BL6S1GOSs4KCgvB25513qq47olu+fLlMnjxZZs6caSs8X3DBBXLppZfahA71c/bZZ0fcs+Y/OEIeeOAB+ze/YMEC+z5gkhLzvmCW8kbdzN/4ueeea69bbWK5ruY+N9XJzfuEeb8wVc4vv/xy+z6CFONkkKefftpp2bJljf1vvPGG4/V6nW+++Sa878UXX3RycnKco0eP2u8XLlxon1tSUhKOmTt3rtOxY0cnGAwm6BWkli5dujiPPPJInY/Hct0R3b/92785N910U8S+M88807njjju4dPVw9913O+eee26tj5m/8/bt2zt/+tOfwvvM+4F5X1i0aBHXO0bmY2fFihWq63rkyBEnKyvLWbZsWTjGvG+Y94+33nqLa59iMqLF40TWr18vPXr0sK0ZIUOHDrVNe1u2bAnHmG4Ws7hN1RhTfG737t2Nct6pYN68edK2bVs577zzbJdX1W6UWK476maupblOQ4YMidhvvl+3bh2Xrp6++OILe0+a7qtRo0bJl19+afebSqOmcmnV623eD8z7Ate7/mK5ruY+Ly8vj4gxvyPz/sG1Tz0ZUSTuRMxNn5+fH7GvdevWtrpgqESy+WrGLFQVeo55zLxJIdKkSZOkZ8+e9lp++OGHMn36dPsm8+c//znm6466HTx40DYzV7+G5nuuX/306dNHnn32WTnjjDNk//79cu+999rxYWa8Qeia1na9v/rqK27VeorlupoY875g3h+qx3Cvpx5vOg0Cq75t3rw55uOZ+OpMq2DV/dVjQou+1vbcdKW57rfeeqv9r5af//zncuONN8qiRYtkyZIlcujQIdV1R3S13Zdcv/ox42OuvfZaOeecc+SSSy6R119/3e5/5plnuN5JeB9zr6emlG3xmDBhgm0GjaZ6C0VdzECmjRs3Ruw7fPiwbdoLZeEmpnpmfeDAgVoz9XQWz3Xv27ev/bpz507b/RLLdUfdzOh+n89X633J9WsYZvaESUJM98tVV11l95nr3aFDB653AwnNGop2XU2M6Vo07w9VWz1MjGmRQmrxpvKb7plnnhl1M9MLY9GvXz/Zvn27HcEesnLlStvPaKYnhmLMlLCqYxRMjOlnjDXBSQfxXHcz68IIvbnEct1RN9P0bK7TqlWrIvab73kzbhhmvNHnn39u71nTnWo+AKteb/N+sGbNGq53HGK5ruY+z8rKiogx7xvm/YN7PQU5GeCrr75ytm7d6syePdtp1qyZ/bfZioqK7OMVFRVOjx49nIsvvtj53//9X2f16tVOp06dnAkTJoSPYUZV5+fnO7/5zW+cbdu2OX/961+dFi1aOA899FAjvrLktW7dOmf+/Pn2On/55ZfO8uXL7QygK664IhwTy3VHdGaUvxntv2TJEuezzz5zJk+e7DRt2tTZvXs3l64epk6d6rz33nv2nt2wYYNz+eWXO82bNw9fTzPzwsy2MH//5n3AvB906NDBKSws5HpHYd5rQ++75mMn9N5g3ptjva5m9pZ5fzDvE+b94qKLLrIzkMz7CFJLRiQeY8aMsTd79e3dd98Nx5g/gMsuu8zJy8tz2rRpYz/8qk6dNT755BPnggsusNM9zfSvWbNmMZW2Dlu2bHH69Olj30xyc3Odn/3sZ3aqYnFxcURcLNcd0T3xxBN26nJ2drbTs2dPZ82aNVyyeho5cqT9wDPJnEmUr7nmGufTTz+NmPpp7mPz92/eBy688EL7QYnozHttbe/B5r051ut6/Phx+/5g3ifM+4VJCvfs2cOlT0Ee83+N3eoCAAAyQ8qO8QAAAKmHxAMAACQMiQcAAEgYEg8AAJAwJB4AACBhSDwAAEDCkHgAAICEIfEAAAAJQ+IBAAAShsQDAAAkDIkHAABIGBIPAAAgifL/AHRXDAAff/z9AAAAAElFTkSuQmCC", "text/plain": [ "
" ] @@ -470,11 +493,11 @@ "id": "a4303772-cfe0-45ed-90ec-c1caad768f39", "metadata": { "execution": { - "iopub.execute_input": "2026-02-04T22:10:05.697096Z", - "iopub.status.busy": "2026-02-04T22:10:05.696814Z", - "iopub.status.idle": "2026-02-04T22:10:05.700572Z", - "shell.execute_reply": "2026-02-04T22:10:05.699668Z", - "shell.execute_reply.started": "2026-02-04T22:10:05.697075Z" + "iopub.execute_input": "2026-02-10T22:21:22.379059Z", + "iopub.status.busy": "2026-02-10T22:21:22.378813Z", + "iopub.status.idle": "2026-02-10T22:21:22.382252Z", + "shell.execute_reply": "2026-02-10T22:21:22.381343Z", + "shell.execute_reply.started": "2026-02-10T22:21:22.379033Z" } }, "outputs": [], @@ -488,11 +511,11 @@ "id": "956f31ab-ed45-432f-a788-15cf73febf14", "metadata": { "execution": { - "iopub.execute_input": "2026-02-04T22:10:05.701281Z", - "iopub.status.busy": "2026-02-04T22:10:05.701036Z", - "iopub.status.idle": "2026-02-04T22:10:05.722105Z", - "shell.execute_reply": "2026-02-04T22:10:05.721475Z", - "shell.execute_reply.started": "2026-02-04T22:10:05.701255Z" + "iopub.execute_input": "2026-02-10T22:21:22.383079Z", + "iopub.status.busy": "2026-02-10T22:21:22.382862Z", + "iopub.status.idle": "2026-02-10T22:21:22.408246Z", + "shell.execute_reply": "2026-02-10T22:21:22.407519Z", + "shell.execute_reply.started": "2026-02-10T22:21:22.383061Z" } }, "outputs": [], @@ -506,17 +529,17 @@ "id": "fd1dfb8c-fe88-4a46-b59e-70baaec550f7", "metadata": { "execution": { - "iopub.execute_input": "2026-02-04T22:10:05.722778Z", - "iopub.status.busy": "2026-02-04T22:10:05.722549Z", - "iopub.status.idle": "2026-02-04T22:10:05.868509Z", - "shell.execute_reply": "2026-02-04T22:10:05.867429Z", - "shell.execute_reply.started": "2026-02-04T22:10:05.722755Z" + "iopub.execute_input": "2026-02-10T22:21:22.408931Z", + "iopub.status.busy": "2026-02-10T22:21:22.408710Z", + "iopub.status.idle": "2026-02-10T22:21:22.573880Z", + "shell.execute_reply": "2026-02-10T22:21:22.573090Z", + "shell.execute_reply.started": "2026-02-10T22:21:22.408908Z" } }, "outputs": [ { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAh4AAAGdCAYAAABdD3qhAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjcsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvTLEjVAAAAAlwSFlzAAAPYQAAD2EBqD+naQAAR/BJREFUeJzt3X10VNXZP/zvmUkyCZgML5FMUiJEq1UaqiV4h6RFoEqACkh1KZR154a7SkslYgwsbYTWQIWIIvqrCNS7PLzUF3jWg1R6S2mCCsiPgJAGBWqp1ECiZAhgyISYzCQz+/mDmalDkmGuzJyZvHw/a521yJlrzuw5OZO52HuffWlKKQUiIiKiMDBEugFERETUezDxICIiorBh4kFERERhw8SDiIiIwoaJBxEREYUNEw8iIiIKGyYeREREFDZMPIiIiChsoiLdgHBwuVw4e/Ys4uPjoWlapJtDRERCSik0NDQgJSUFBoM+/2dubm6Gw+EIybFiYmIQGxsbkmP1NL0i8Th79ixSU1Mj3QwiIgpSdXU1Bg8eHPLjNjc3I23IdbDWOkNyPIvFgsrKSiYf7dA18di3bx9eeOEFlJeXo6amBtu3b8e0adO8jyulsGTJErz22muoq6tDZmYmXn31VXz3u9/1xtjtdixcuBBvvfUWmpqacPfdd2PNmjWiCy8+Ph4A8K0VT8MQ4EWg9O4Y0brxSvXCkyN+q+J44S9LenyXLFxz6dse8aUpbI8mfL+6nh/pudH9WtM5vqvR/e9g4KEuezNOr1jq/Xseag6HA9ZaJyrLhyAhPrgeFVuDC2kZZ+BwOJh4tEPXxKOxsRG33347/vu//xsPPPBAm8eff/55rFq1Chs3bsQtt9yCZ599FuPHj8fJkye9F1d+fj7+/Oc/Y8uWLRg4cCAWLFiAyZMno7y8HEajMaB2eIZXDLGxMMQx8QgaEw+/dE88xO1n4tFdjt/l6Px3sDN/Z/UeLk+INwSdeJB/uiYekyZNwqRJk9p9TCmFl19+GYsWLcL9998PANi0aROSkpLw5ptv4he/+AXq6+uxfv16/PGPf8Q999wDAHj99deRmpqK3bt3Y8KECXo2n4iIehmncsEZZMLoVNLsvXeJWFpXWVkJq9WKnJwc7z6TyYQxY8bgwIEDAIDy8nK0tLT4xKSkpCA9Pd0bQ0REFCouqJBs1LGITS61Wq0AgKSkJJ/9SUlJOHPmjDcmJiYG/fv3bxPjeX577HY77Ha792ebzRaqZhMRUQ/mgks6etjuMahjER/Iunq8Til1zTG8a8UUFxfDbDZ7N97RQkRE1DVELPGwWCwA0Kbnora21tsLYrFY4HA4UFdX12FMewoLC1FfX+/dqqurQ9x6IiLqiZxKhWSjjkUs8UhLS4PFYkFpaal3n8PhwN69e5GdnQ0AyMjIQHR0tE9MTU0Njh8/7o1pj8lkQkJCgs9GRER0LZzjoT9d53hcvnwZp06d8v5cWVmJo0ePYsCAAbjhhhuQn5+P5cuX4+abb8bNN9+M5cuXo0+fPpg5cyYAwGw24+GHH8aCBQswcOBADBgwAAsXLsTw4cO9d7kQERFR96Fr4nHkyBGMGzfO+3NBQQEAYNasWdi4cSOefPJJNDU14dFHH/UuIFZSUuKzQMxLL72EqKgoPPTQQ94FxDZu3BjwGh5ERESBckHBGWSPBXs8/NOU6vmDUTab7cok0/+zlAuIhQIXEPOLC4hd6/hcQKzb6EILiLmam/H50qdRX1+vy/C553viX/+wID7IBcQaGly46Varbm3t7npFrRYPZVBQhgD/Egg/cL2r9pzsr6k4tZV+GYi/KKW/XFm4NA/SPQftxl/G0t+t+FrQ+732MuJrXxLPO1R7jF6VeBAREfkTirtSeFeLf0w8iIiI3FwIvnOFnTP+RXwBMSIiIuo92ONBRETk5gzBXS3BPr+nY+JBRETk5lQIQXXa0LSlp2LiQURE5MY5HvrjHA8iIiIKG/Z4EBERubmgwRnkymkuvVde6+aYeBAREbm51JUt2GNQxzjUQkRERGHDHg8iIiI3ZwiGWoJ9fk/XqxIPzXBlCyxYWsRB2hhhvJi0r0+/Buld1EwJX0D+TqXFWrrOue+ULlSETnPKmtLlisRJdbFLR1x7RfwCgmOH6VYRJh7641ALERERhU2v6vEgIiLyx6U0uKRdPe0cgzrGxIOIiMiNQy3641ALERERhQ17PIiIiNycMMAZ5P/JhXOiex0mHkRERG4qBHM8FOd4+MXEg4iIyI1zPPTHOR5EREQUNuzxICIicnMqA5wqyDkerNXiFxMPIiIiNxc0uIIcDHCJl6DtXXpX4mFUV7aA6Ltkuqb3kuxi+n1QlHBJbem61JpwIpfuq1JLJ5ZJl4LWeZlvTccl0AHZMujiY+t9LsO0bLdu9C7toGN8tz/35NW7Eg8iIiI/OLlUf5xcSkRE5OaZ4xHsJrVmzRqkpaUhNjYWGRkZ+PDDD/3G7927FxkZGYiNjcWNN96IdevWtYnZtm0bhg0bBpPJhGHDhmH79u0+jxcXF+POO+9EfHw8Bg0ahGnTpuHkyZPitksx8SAiIoqgrVu3Ij8/H4sWLUJFRQVGjx6NSZMmoaqqqt34yspK/PjHP8bo0aNRUVGBp59+GvPnz8e2bdu8MWVlZZg+fTpyc3Px8ccfIzc3Fw899BAOHTrkjdm7dy/mzZuHgwcPorS0FK2trcjJyUFjY6Ou71dTSlzDu9ux2Wwwm81IXVcEQ1xsgM/qbXM89COe4yEubS6c4+EUzmEQxkN6/Fad51RIjy+Nl5au5xyPyJF+FLvQHA9nczNOPfc06uvrkZCQIHyha/N8T2z7+Bb0jTcGdazGBiceuP2fAbc1MzMTI0aMwNq1a737brvtNkybNg3FxcVt4p966ins2LEDn376qXff3Llz8fHHH6OsrAwAMH36dNhsNvzlL3/xxkycOBH9+/fHW2+91W47zp8/j0GDBmHv3r246667An6/UuzxICIicnO5l0wPZvPcFWOz2Xw2u93e5vUcDgfKy8uRk5Pjsz8nJwcHDhxot41lZWVt4idMmIAjR46gpaXFb0xHxwSA+vp6AMCAAQOucZaCw8SDiIhIB6mpqTCbzd6tvd6LCxcuwOl0IikpyWd/UlISrFZru8e1Wq3txre2tuLChQt+Yzo6plIKBQUF+OEPf4j09PSA32Nn8K4WIiIit9AsIHZlDK+6utpnqMVkMnX4HE3zHXdSSrXZd634q/dLjpmXl4dPPvkE+/fv7/A1Q4WJBxERkZvrG0MlnT/GlSQgISHhmnM8EhMTYTQa2/RE1NbWtumx8LBYLO3GR0VFYeDAgX5j2jvmY489hh07dmDfvn0YPHiw/zcXAhxqISIicnMqLSRboGJiYpCRkYHS0lKf/aWlpcjOzm73OVlZWW3iS0pKMHLkSERHR/uN+eYxlVLIy8vD22+/jffffx9paWkBtzsY7PEgIiKKoIKCAuTm5mLkyJHIysrCa6+9hqqqKsydOxcAUFhYiC+//BKbN28GcOUOltWrV6OgoABz5sxBWVkZ1q9f73O3yuOPP4677roLK1aswH333Yd33nkHu3fv9hlKmTdvHt5880288847iI+P9/aQmM1mxMXF6fZ+I97jMXToUGia1mabN28eAGD27NltHhs1alSEW01ERD1RsHe0eDaJ6dOn4+WXX8bSpUtxxx13YN++fdi5cyeGDBkCAKipqfFZ0yMtLQ07d+7Enj17cMcdd+C3v/0tfve73+GBBx7wxmRnZ2PLli3YsGEDvve972Hjxo3YunUrMjMzvTFr165FfX09xo4di+TkZO+2devWIM+ifxFfx+P8+fNwOv99Y//x48cxfvx4fPDBBxg7dixmz56Nc+fOYcOGDd6YmJgY0e0+nvuzb3jtN4Gv4yFdl8MgrC8ivt9denwda69Ib+6XrrMhXCvB5RTmz8J1RZR4HQxhe4THN0jXzWjRdx0PQ6soXLaOh/C9Ss+NtE6O+GOl91/XLrYuh3hOpmQdD3szPnte/3U8/p+/fR99glzH4+sGJ342okK3tnZ3ER9quf76631+fu6553DTTTdhzJgx3n0mkwkWiyXcTSMiIqIQi/hQyzc5HA68/vrr+NnPfuZzy8+ePXswaNAg3HLLLZgzZw5qa2v9Hsdut7dZuIWIiOhaIjHU0tt0qbPzpz/9CZcuXcLs2bO9+yZNmoQ33ngD77//Pl588UUcPnwYP/rRj9pdAc6juLjYZ9GW1NTUMLSeiIi6OxeCv7Olu6+sr7eID7V80/r16zFp0iSkpKR4902fPt377/T0dIwcORJDhgzBu+++i/vvv7/d4xQWFqKgoMD7s81mY/JBRETUBXSZxOPMmTPYvXs33n77bb9xycnJGDJkCD777LMOY0wmk98V4oiIiNoTmgXEutRgQpfTZRKPDRs2YNCgQbj33nv9xl28eBHV1dVITk4OU8uIiKi3CM2S6Uw8/OkSZ8flcmHDhg2YNWsWoqL+nQtdvnwZCxcuRFlZGU6fPo09e/ZgypQpSExMxE9+8pMItpiIiIg6o0v0eOzevRtVVVX42c9+5rPfaDTi2LFj2Lx5My5duoTk5GSMGzcOW7duRXx8fIRaS0REPZULGlzSBUzaOQZ1rEskHjk5OWhvHbO4uDj89a9/jUCLiIioN+JQi/66ROJBRETUFYRiHQ6u4+Efzw4RERGFTa/q8dAMCpoxsOIJ0torBmmtFunxday9Ashqu0hrtUhbLq29oklLtQhrkYjzc5fwHYuHg6UFNIRHl9YvkdZTEdR20XSsAwN0oraL3rVadJ4aIB0BkMZLP4uS40t/t53lUhpc4qI2bY9BHetViQcREZE/rhAMtXAdD/94doiIiChs2ONBRETk5lIGuIK8KyXY5/d0TDyIiIjcnNDgDHKyTbDP7+mYlhEREVHYsMeDiIjIjUMt+mPiQURE5OZE8EMlYbrzt9tiWkZERERhwx4PIiIiNw616I+JBxERkRuLxOmPiQcREZGbghZ0WXvF22n96lWJhzHKBUNUYIUopLVUjAZZgYsooyzeIDy+JrzuJbVgpHUIlLBeRavTKIyX/e+iVZMd3yl9vwHWA/LQxLVjZKRlfqQ1McT1UVr0ie1MW8TxXaxWi7gkiLTskLT2iuyjJWqPtG4PdV29KvEgIiLyh0Mt+mPiQURE5MbqtPpjWkZERERhwx4PIiIiNycMcAb5f/Jgn9/TMfEgIiJy41CL/piWERERUdiwx4OIiMjNBQNcQf6fPNjn93RMPIiIiNycShOv3dPeMahjTMuIiIgobNjjQURE5MbJpfpj4kFEROSmQlCdVnHlUr96VeJhMLpgDLBGSqBxHtFRsqIP0QZZvLS2i7R2jKRWi5RTWPChRVirxd4qjBdFQ1wQw+mSFsqRhYsJ26PJLh1xPRWDQ79jG/Wu7eLS73MCAEpYZEn6/SatpSIsawTp6ZG0X4WpVosTGpxBFnkL9vk9HdMyIiIiCpte1eNBRETkj0sFP0dD546xbo+JBxERkZsrBHM8gn1+T8ezQ0RERGHDHg8iIiI3FzS4gpwcGuzzezomHkRERG5cuVR/HGohIiKisIl44lFUVARN03w2i8XifVwphaKiIqSkpCAuLg5jx47FiRMnIthiIiLqqTyTS4PdqGNd4ux897vfRU1NjXc7duyY97Hnn38eq1atwurVq3H48GFYLBaMHz8eDQ0NEWwxERH1RC5o3mXTO71xjodfXSLxiIqKgsVi8W7XX389gCu9HS+//DIWLVqE+++/H+np6di0aRO+/vprvPnmmxFuNREREUl1icTjs88+Q0pKCtLS0jBjxgx8/vnnAIDKykpYrVbk5OR4Y00mE8aMGYMDBw50eDy73Q6bzeazERERXYty39USzKbY4+FXxO9qyczMxObNm3HLLbfg3LlzePbZZ5GdnY0TJ07AarUCAJKSknyek5SUhDNnznR4zOLiYixZsqTN/ugoF4wB1lSJiZYVBogxyoo+xEbJikpIjx8jrQUjrO0i0Sqs1dLslF2WX7fEiOKF5TDEqxi6WqX1NqT5v861V4Q1McT1VAS1WozCwjpGh2zJSOl71b1Wi/BScAlrqUhrtTij9b3WXNGBxyphXZ3OYnVa/UU88Zg0aZL338OHD0dWVhZuuukmbNq0CaNGjQIAaFd9Uyil2uz7psLCQhQUFHh/ttlsSE1NDXHLiYiop+HKpfrrcmenb9++GD58OD777DPv3S2eng+P2traNr0g32QymZCQkOCzERERUeR1ucTDbrfj008/RXJyMtLS0mCxWFBaWup93OFwYO/evcjOzo5gK4mIqCcK+o6WEAzV9HQRH2pZuHAhpkyZghtuuAG1tbV49tlnYbPZMGvWLGiahvz8fCxfvhw333wzbr75Zixfvhx9+vTBzJkzI910IiLqYbhkuv4innh88cUX+OlPf4oLFy7g+uuvx6hRo3Dw4EEMGTIEAPDkk0+iqakJjz76KOrq6pCZmYmSkhLEx8dHuOVEREQkFfHEY8uWLX4f1zQNRUVFKCoqCk+DiIio1+JdLfqLeOJBRETUVTDx0F+Xm1xKREREPRd7PIiIiNzY46E/Jh5ERERuTDz0x6EWIiIiCpte1eMRE90KY3RgxQpio2RFHPpECwpQALhOGN8nShYfZ5QV0IjS9CuE0CosENHYKqu9YhPWpZFyOmX5ubNF9n5bDfrW/5DWz9CE9UuEl5qo/kpUk+zcRDULa7W0yE6O9FxKiWu1RAnrCMXoW3vFqeP/9JXwuuz06yD4dTj0/UR3f70q8SAiIvKHQy3641ALERGRW6SWTF+zZg3S0tIQGxuLjIwMfPjhh37j9+7di4yMDMTGxuLGG2/EunXr2sRs27YNw4YNg8lkwrBhw7B9+3afx/ft24cpU6YgJSUFmqbhT3/6k7jdncHEg4iIKIK2bt2K/Px8LFq0CBUVFRg9ejQmTZqEqqqqduMrKyvx4x//GKNHj0ZFRQWefvppzJ8/H9u2bfPGlJWVYfr06cjNzcXHH3+M3NxcPPTQQzh06JA3prGxEbfffjtWr16t+3v8Jk0p1eOHo2w2G8xmM27//xbA2McU0HM4xyN0dJ/j4YgVxV+yx8mO3yQ7/tdfB3aNebQ2ykY8jY2y8xnVIPv/RVSjKBzRX8viowTxnOPhn95zPJw6x7uiBcd2NOPYH55GfX29LhXHPd8Td/35UUT1lX2Gr9baaMe+KWsCbmtmZiZGjBiBtWvXevfddtttmDZtGoqLi9vEP/XUU9ixYwc+/fRT7765c+fi448/RllZGQBg+vTpsNls+Mtf/uKNmThxIvr374+33nqrzTE1TcP27dsxbdo0yVvtFPZ4EBERuYVyqMVms/lsdnvbmdUOhwPl5eXIycnx2Z+Tk4MDBw6028aysrI28RMmTMCRI0fQ0tLiN6ajY4YTEw8iIiIdpKamwmw2e7f2ei8uXLgAp9OJpKQkn/1JSUmwWq3tHtdqtbYb39raigsXLviN6eiY4cS7WoiIiNyU0qCCvCvF8/zq6mqfoRaTqeMhHE3zfU2lVJt914q/er/0mOHCxIOIiMjNBS3odTw8z09ISLjmHI/ExEQYjcY2PRG1tbVteiw8LBZLu/FRUVEYOHCg35iOjhlOHGohIiKKkJiYGGRkZKC0tNRnf2lpKbKzs9t9TlZWVpv4kpISjBw5EtHR0X5jOjpmOLHHg4iIyC0SC4gVFBQgNzcXI0eORFZWFl577TVUVVVh7ty5AIDCwkJ8+eWX2Lx5M4Ard7CsXr0aBQUFmDNnDsrKyrB+/Xqfu1Uef/xx3HXXXVixYgXuu+8+vPPOO9i9ezf279/vjbl8+TJOnTrl/bmyshJHjx7FgAEDcMMNNwRzCvxi4kFEROQWyjkegZo+fTouXryIpUuXoqamBunp6di5cyeGDBkCAKipqfFZ0yMtLQ07d+7EE088gVdffRUpKSn43e9+hwceeMAbk52djS1btmDx4sX49a9/jZtuuglbt25FZmamN+bIkSMYN26c9+eCggIAwKxZs7Bx48bOvPWA9Kp1PEa+nR/w/dnXxQgKSgBIkMZHN4ni+wnjr5MUxAAQawh83Q+DcDGDFpcsv7U5ZetsXHT0EcXXNsXL4huvE8XXN8ra72iQrRlgaJCt4xFdLxtRjW4QhSP6siw+piHwPzkxl2XXmrFJth6N0S5dx0P251L6/aWMst+VK0ZYRyhWFt8aK1zHwySLbxXEOx3N+GSj/ut4/Mf2x0OyjsdHP/k/urW1u2OPBxERkRtrteiPiQcREZFbJIZaehsmHkRERG4qBD0eTDz84+20REREFDbs8SAiInJTAIK95aLH37ERJCYeREREbi5o0EK0cim1j0MtREREFDbs8SAiInLjXS36Y+JBRETk5lIaNK7joSsOtRAREVHYsMeDiIjITakQ3NXC21r86lWJR2xUC6KiAuvkuS7aITq2tPbK9TGyAheJwoIYA6Jk8X0Mgb9fI2T1LRxKVlvkK6esNkqUJqvP0eqStaexJUYUf7lZWOfBoPNfKeHhtVZZvNEue4HorwO/fqIaZb/bqMuB1xwCAEOTLF5zya59aLIudxUtuzadcbI/4ZqwbhIga4/0Zg4l6XNvCc+3Oed46I9DLURERBQ2varHg4iIyB/2eOiPiQcREZEb72rRHxMPIiIiN04u1V/E53gUFxfjzjvvRHx8PAYNGoRp06bh5MmTPjGzZ8+Gpmk+26hRoyLUYiIiIuqsiCcee/fuxbx583Dw4EGUlpaitbUVOTk5aGxs9ImbOHEiampqvNvOnTsj1GIiIuqprvR4aEFukX4XXVvEh1p27drl8/OGDRswaNAglJeX46677vLuN5lMsFgs4W4eERH1Ipxcqr+I93hcrb6+HgAwYMAAn/179uzBoEGDcMstt2DOnDmora3t8Bh2ux02m81nIyIiosjrUomHUgoFBQX44Q9/iPT0dO/+SZMm4Y033sD777+PF198EYcPH8aPfvQj2O32do9TXFwMs9ns3VJTU8P1FoiIqBtTIdqoYxEfavmmvLw8fPLJJ9i/f7/P/unTp3v/nZ6ejpEjR2LIkCF49913cf/997c5TmFhIQoKCrw/22w2Jh9ERHRNHGrRX5dJPB577DHs2LED+/btw+DBg/3GJicnY8iQIfjss8/afdxkMsFkEi5bTURERLqLeOKhlMJjjz2G7du3Y8+ePUhLS7vmcy5evIjq6mokJyeLXis2qhVRUYHVHugTJavV0k9Yq0VaeyU5uk4UPyhKNq8l3tAccGy0JqtX0SysD5FgDLwtgLx2TJMzWhT/VXQfUXxMtKzYSZOmb8es8NcFg7RWi+yjAmNT4A2KbpAd3GCTXTtaU/vDtR1qlZ4c2Wi2FiOrC4RWff+DpQyy/7m7hO/XEBX48ZXw1HdaKMZKONbiV8TneMybNw+vv/463nzzTcTHx8NqtcJqtaKp6coX+eXLl7Fw4UKUlZXh9OnT2LNnD6ZMmYLExET85Cc/iXDriYioRwn6VloN4FCLXxHv8Vi7di0AYOzYsT77N2zYgNmzZ8NoNOLYsWPYvHkzLl26hOTkZIwbNw5bt25FfHx8BFpMREQ9FVcu1V/EEw91jd9QXFwc/vrXv4apNURERKSniCceREREXQXvatEfEw8iIiKPUMzRYOLhV8QnlxIREVHvwR4PIiIiN04u1R8TDyIiIg+u46E7DrUQERFR2LDHg4iIyI13teiPiQcREdE3cahEV70q8Yg2uBBtcAYUG2dsER37OqOs5oPZ+LUofmCUrLaLxdggijcLCnTEarJsvtkgOzexLllRhmaXrPbKhWjZirfXRcvqhUQZZcVRNEMXq9US2EfEy2iXtT+qOfAXMHwtO/daQ6MoXn0t+xyiRVgwJFr2J1aLjRXFG4S1VFR0YLWqvMeXxptk7dGcgmvHxWygp+hViQcREZE/HGrRHxMPIiIiD97VojsmHkRERF6aewv2GNQR3k5LREREYcMeDyIiIg8OteiOiQcREZEHEw/dcaiFiIiIwoY9HkRERB5KC76sPW+n9YuJBxERkRur0+qPQy1EREQUNuzxICIi8uDkUt31qsQjyuBClCGwwhUxgtolABBrkNV2iTc2i+L7GWQ1JSS1VwBggCHweicmTXbZ2JWsLS2Q1efoZ5TV57hOeO6l14JRE/7V0Xs4WNoccW0X2QsYHIG/gNYs+1zBLqsLpBqbZPGtsvZoUbI6QlKasBaMwSRrj+YUHt8pq+0iudak12WncY6H7jjUQkRERGHTq3o8iIiI/NHUlS3YY1DHmHgQERF5cI6H7ph4EBEReXCOh+44x4OIiIjChj0eREREHhxq0R0TDyIiIg8mHrrjUAsRERGFDXs8iIiIPNjjoTsmHkRERB68q0V3HGohIiKisOlVPR4GKBgC7AMzCvvKojWnKN4IWeGBaGGhghhNlnFL6q9EC2u1SMVqsnoY8nMvrC0iXIZQGt/lSJsvjhc8wSW77lWLrK6OtPaKcsquNSnNaZI9wSksYCKs1665hL9cYXxXrNXClUv11216PNasWYO0tDTExsYiIyMDH374YaSbREREPY0K0SYk/Y7bu3cvMjIyEBsbixtvvBHr1q1rE7Nt2zYMGzYMJpMJw4YNw/bt24N+3VDoFonH1q1bkZ+fj0WLFqGiogKjR4/GpEmTUFVVFemmERERBUX6HVdZWYkf//jHGD16NCoqKvD0009j/vz52LZtmzemrKwM06dPR25uLj7++GPk5ubioYcewqFDhzr9uqGiKSXse4uAzMxMjBgxAmvXrvXuu+222zBt2jQUFxdf8/k2mw1msxn3lfwM0X1jAnpNS6xN1MbU2K9E8UNiLojib4w5L4r/llFWWn6gITbgWOlQS4uSdX/XumSlyj9rSRDFf9w0RBR/tCFVFH+ybpAo/twFWfu1i4Fdwx6m87L/X8TJLjX0qZUNP8Sdaw44NqpW9jlUF+tE8a6GBtnxhUMtmlFWJt5w3XWy48fL4lX/eFF8qznwvwsA0BIfLYu/LvDz09rSjMPbF6O+vh4JCbLPTCA83xM3rHgWhjjZ+76aq6kZVU8F3lbpd9xTTz2FHTt24NNPP/Xumzt3Lj7++GOUlZUBAKZPnw6bzYa//OUv3piJEyeif//+eOuttzr1uqHS5Xs8HA4HysvLkZOT47M/JycHBw4caPc5drsdNpvNZyMiIroWDf+e59HpzX2sq7+H7HZ7m9frzHdcWVlZm/gJEybgyJEjaGlp8RvjOWZnXjdUunziceHCBTidTiQlJfnsT0pKgtVqbfc5xcXFMJvN3i01VfY/ViIi6qU8t9MGuwFITU31+S5qrxehM99xVqu13fjW1lZcuHDBb4znmJ153VDpNne1aFfdpaGUarPPo7CwEAUFBd6fbTYbkw8iIgqr6upqn6EWk6nju5Yk33EdxV+9P5BjSl83FLp84pGYmAij0dgmA6utrW2TqXmYTCa/v2AiIqJ2hXDl0oSEhGvO8ejMd5zFYmk3PioqCgMHDvQb4zlmZ143VLr8UEtMTAwyMjJQWlrqs7+0tBTZ2dkRahUREfVIYb6dtjPfcVlZWW3iS0pKMHLkSERHR/uN8Rwzkt+tXb7HAwAKCgqQm5uLkSNHIisrC6+99hqqqqowd+7cSDeNiIgoKNf6jissLMSXX36JzZs3A7hyB8vq1atRUFCAOXPmoKysDOvXr/ferQIAjz/+OO666y6sWLEC9913H9555x3s3r0b+/fvD/h19dItEo/p06fj4sWLWLp0KWpqapCeno6dO3diyBDZbZFERET+RGLl0mt9x9XU1PisrZGWloadO3fiiSeewKuvvoqUlBT87ne/wwMPPOCNyc7OxpYtW7B48WL8+te/xk033YStW7ciMzMz4NfVS7dYxyNYnvuzp5Q8HPA6HknCdTy+Zbokik8zyRZLGBoti08xytbCGGAI/P57yfLqAGAXruNxziWL/7ylnyj+WLNsovHHNn3X8Th/Uba2gu7reMiWmOnEOh5tbynsSNR52TobuFQvCnfZLovipUusa1GydS20vnGyeOk6HmZZfEs/2XoWrcJ1PBzXBX5ttrY048g2/dfxGPrsMhhig1zHo7kZpxcv0q2t3V2Xn+NBREREPUe3GGohIiIKixDe1ULtY+JBRETkxuq0+uNQCxEREYUNezyIiIg8vrHkeVDHoA4x8SAiIvLgHA/dMfEgIiJy4xwP/XGOBxEREYUNezyIiIg8ONSiOyYeREREHiEYamHi4R+HWoiIiChselWPR6vLAM0VWK7lcMlOTbNLVqOgwSmrBXDJ2EcU31eT1ZQAAo+P1WS1VJqF5YAuuUyyeGdfUfxl4bmXXgtO6a10ev/vSNoc4X9HXEbZC7hiAn8BFSusdWKSXTtaX1mdGa1F1h5Ey64dTVojJFb2fl0xsvYoo+xicBlF4aJrTXpddhqHWnTXqxIPIiIiv5h46I5DLURERBQ27PEgIiJy4zoe+mOPBxEREYUNEw8iIiIKGw61EBEReXByqe6YeBAREblxjof+mHgQERF9ExMHXXGOBxEREYUNezyIiIg8OMdDd0w8iIiI3DjHQ3+9KvFocRmgAiwm0OSU1WS47JTVTKh3ymqv9Gm1i+KNcIniG1VzwLHRmuzYzcJaJ1+5rhPFn2+NF8XXtcjO/eWWGFF8q1M2gqlcslonwtIrnai9Iot3mmQtao0N/AWMfWTn3tAqq9ujRQn/BLbK6hRBWOsEMbL364qVxst+uZK6OgDgipJdC0pS58cpvfKpq+pViQcREZFfHGrRHRMPIiIiNw616I93tRAREVHYsMeDiIjIg0MtumPiQURE5MHEQ3ccaiEiIqKwYY8HERGRGyeX6o+JBxERkQeHWnTHxIOIiMiDiYfuOMeDiIiIwiZiicfp06fx8MMPIy0tDXFxcbjpppvwzDPPwOFw+MRpmtZmW7duXYRaTUREPZlnjkewG3UsYkMt//jHP+ByufD73/8e3/72t3H8+HHMmTMHjY2NWLlypU/shg0bMHHiRO/PZrO5U6/Z3BqFqNbA3vLXRlkNhEuGOFF8tOYUxUvZlazWTB+D49pBbtI6MA4lqw/xlVNWq6XG0U92fIesnkejsFaLo0X4sVL61qAQ12oRNt8pOz1wxgXeoJZW2cGjNNm5NMTI3qzmkl37ELZHRcs+K844WfvF8bHCWi0xsvcrudakp77TONSiu4glHhMnTvRJJm688UacPHkSa9eubZN49OvXDxaLJdxNJCIiohDrUnM86uvrMWDAgDb78/LykJiYiDvvvBPr1q2D6xqpr91uh81m89mIiIiuhUMt+usyd7X861//wiuvvIIXX3zRZ/9vf/tb3H333YiLi8N7772HBQsW4MKFC1i8eHGHxyouLsaSJUv0bjIREfU0HGrRXch7PIqKitqdEPrN7ciRIz7POXv2LCZOnIgHH3wQjzzyiM9jixcvRlZWFu644w4sWLAAS5cuxQsvvOC3DYWFhaivr/du1dXVoX6bRERE1Akh7/HIy8vDjBkz/MYMHTrU+++zZ89i3LhxyMrKwmuvvXbN448aNQo2mw3nzp1DUlJSuzEmkwkmk0nUbiIiIvZ46C/kiUdiYiISExMDiv3yyy8xbtw4ZGRkYMOGDTAYrt0BU1FRgdjYWPTr1y/IlhIREfnS3Fuwx6CORWyOx9mzZzF27FjccMMNWLlyJc6fP+99zHMHy5///GdYrVZkZWUhLi4OH3zwARYtWoSf//zn7NEgIiLqhiKWeJSUlODUqVM4deoUBg8e7POYUlf6qaKjo7FmzRoUFBTA5XLhxhtvxNKlSzFv3rxINJmIiHo6DrXoLmKJx+zZszF79my/MVev9UFERKQnVqfVX5e5nZaIiCji2OOhuy61gBgRERH1bL2qx6O5NRpRrYHVMLlskBUGMOjct9YirHfS4IwVxccaWgKONWiyc9MiLP5hc8rq3lx09BHFf2WXxTc6ZPVCnE5pcRSd58ALD6+ktVpMshdo6RP4+RFeauK6NEaT7HOluWSfc2kZHmWU1kaRxUtrr7TGyt6AU1irxRkdeLxT55pGPthjoatelXgQERH5wzke+uNQCxEREYUNezyIiIg8OLlUd0w8iIiI3DjUoj8OtRAREVHYsMeDiIjIg0MtumPiQURE5MahFv1xqIWIiIjChj0eREREHhxq0R0TDyIiIg8mHrpj4kFEROTGOR7661WJR4vLCJczsNoMX7fI6nNIuYR1BxzCeicNRlmtlijNKYqXaBXWmWlslZ17m0P2Xi/ZZbVgmlsCq+/j4WyVvV8lrEciJa1fIrzU4BJ+VFrjJNe+rPFRUcJaIbGyky+tHSMl/13J3q9LWktF53hJXSC9PycUPr0q8SAiIvKLQy26410tREREbppSIdn0UldXh9zcXJjNZpjNZuTm5uLSpUt+n6OUQlFREVJSUhAXF4exY8fixIkTPjF2ux2PPfYYEhMT0bdvX0ydOhVffPGFT8yyZcuQnZ2NPn36oF+/fp1+D0w8iIiIuomZM2fi6NGj2LVrF3bt2oWjR48iNzfX73Oef/55rFq1CqtXr8bhw4dhsVgwfvx4NDQ0eGPy8/Oxfft2bNmyBfv378fly5cxefJkOJ3/HoZ3OBx48MEH8ctf/jKo98ChFiIiIo8uPNTy6aefYteuXTh48CAyMzMBAP/zP/+DrKwsnDx5Et/5znfaNkUpvPzyy1i0aBHuv/9+AMCmTZuQlJSEN998E7/4xS9QX1+P9evX449//CPuueceAMDrr7+O1NRU7N69GxMmTAAALFmyBACwcePGoN4HezyIiIjcPHe1BLsBgM1m89nsdntQbSsrK4PZbPYmHQAwatQomM1mHDhwoN3nVFZWwmq1Iicnx7vPZDJhzJgx3ueUl5ejpaXFJyYlJQXp6ekdHjcYTDyIiIh0kJqa6p2LYTabUVxcHNTxrFYrBg0a1Gb/oEGDYLVaO3wOACQlJfnsT0pK8j5mtVoRExOD/v37dxgTShxqISIi8gjhUEt1dTUSEhK8u00mU7vhRUVF3mGMjhw+fBgAoGltb1lWSrW7/5uufjyQ5wQS0xlMPIiIiNxCuYBYQkKCT+LRkby8PMyYMcNvzNChQ/HJJ5/g3LlzbR47f/58mx4ND4vFAuBKr0ZycrJ3f21trfc5FosFDocDdXV1Pr0etbW1yM7Ovmb7pTjUQkREFEGJiYm49dZb/W6xsbHIyspCfX09PvroI+9zDx06hPr6+g4ThLS0NFgsFpSWlnr3ORwO7N271/ucjIwMREdH+8TU1NTg+PHjuiQe7PEgIiLy6MJ3tdx2222YOHEi5syZg9///vcAgJ///OeYPHmyzx0tt956K4qLi/GTn/wEmqYhPz8fy5cvx80334ybb74Zy5cvR58+fTBz5kwAgNlsxsMPP4wFCxZg4MCBGDBgABYuXIjhw4d773IBgKqqKnz11VeoqqqC0+nE0aNHAQDf/va3cd111wX8Pph4EBERuXX1Wi1vvPEG5s+f770DZerUqVi9erVPzMmTJ1FfX+/9+cknn0RTUxMeffRR1NXVITMzEyUlJYiPj/fGvPTSS4iKisJDDz2EpqYm3H333di4cSOMxn+XgPjNb36DTZs2eX/+/ve/DwD44IMPMHbs2IDfg6aUjkusdRE2mw1msxm3vfUUjH3an9xztZjoVtFrxBhltU5io1p0PX6MQRYfZdCvEEKrSzai1+yU5cPSujqNDln8182y+JYmWfuVMN7QJDufxkZhvZMmUTiMwvioZsGxhXcfGh2yP2cG2cccmkvfP5fKIKy9IisLBGHZJDij9au9AgAuQRkkp70ZJ9Y9jfr6+oDmTUh5vicyHloGY4ys/tPVnI5mlP+/i3Rra3fHOR5EREQUNhxqISIi+gaWtdcXEw8iIiIPpa5swR6DOsShFiIiIgob9ngQERG5dfW7WnoCJh5EREQeXXgdj56CQy1EREQUNhFNPIYOHQpN03y2X/3qVz4xVVVVmDJlCvr27YvExETMnz8fDocjQi0mIqKeTHOFZqOORXyoZenSpZgzZ473528uu+p0OnHvvffi+uuvx/79+3Hx4kXMmjULSim88sorkWguERH1ZBxq0V3EE4/4+Hhv9byrlZSU4O9//zuqq6uRkpICAHjxxRcxe/ZsLFu2jCvCERERdTMRn+OxYsUKDBw4EHfccQeWLVvmM4xSVlaG9PR0b9IBABMmTIDdbkd5eXmHx7Tb7bDZbD4bERHRtXjuagl2o45FtMfj8ccfx4gRI9C/f3989NFHKCwsRGVlJf7whz8AAKxWK5KSknye079/f8TExMBqtXZ43OLiYixZsqTN/pZWA1ytgRUrcClZjQJnlCyHa3UK62cYZYOGRmHtFYOOnxSnsFZLi1NWUMIe4O/UG+8QFIgA4GyRHV8Jf7dwya41KSVtjvCvgiY7nXAKLk3hxxDKKHuCJitppPvYvdKEtVGEv1tprRZpvPTakbRfWpem07iAmO5C3uNRVFTUZsLo1duRI0cAAE888QTGjBmD733ve3jkkUewbt06rF+/HhcvXvQeT2vng6iUane/R2FhIerr671bdXV1qN8mERH1QOzx0F/Iezzy8vIwY8YMvzFDhw5td/+oUaMAAKdOncLAgQNhsVhw6NAhn5i6ujq0tLS06Qn5JpPJBJMpsCq0REREFD4hTzwSExORmJjYqedWVFQAAJKTkwEAWVlZWLZsGWpqarz7SkpKYDKZkJGREZoGExERefCuFt1FbI5HWVkZDh48iHHjxsFsNuPw4cN44oknMHXqVNxwww0AgJycHAwbNgy5ubl44YUX8NVXX2HhwoWYM2cO72ghIqKQ45Lp+otY4mEymbB161YsWbIEdrsdQ4YMwZw5c/Dkk096Y4xGI9599108+uij+MEPfoC4uDjMnDkTK1eujFSziYiIKAgRSzxGjBiBgwcPXjPuhhtuwP/+7/+GoUVERNTr8a4W3UV8ATEiIqKugkMt+ov4AmJERETUe7DHg4iIyIN3teiOiQcREZEbh1r0x6EWIiIiCpte1ePhchqAAOtoSGu1uIT1NpxGWc5nkBS4ACAs+SCq1SI9N9IJ3q3CWi3SujetwtorzhbZ8ZVTWC9E5/ofMMh+AcogvPaFtVpE/xsU12qRxYtrtYiLx8jCxe9XWuZHWrdH71owklotwt9Vp7nUlS3YY1CHelXiQURE5BfneOiOiQcREZGbhhDM8QhJS3ouzvEgIiKisGGPBxERkQdXLtUdEw8iIiI33k6rPw61EBERUdiwx4OIiMiDd7XojokHERGRm6YUtCDnaAT7/J6OQy1EREQUNuzxICIi8nC5t2CPQR1i4kFEROTGoRb99arEw9lqgGoNbHRJ07m+hVNYBEFSS6UzNMHxlbRWi7AtLmHtFXF8q3BdQWEdHk1Yq0XviWji8iLSehvC/91JartI2y6tvWKQ1v+Q/q50rtUiJamN0pl46eC95PgqXLVaSHe9KvEgIiLyi3e16I6JBxERkQdXLtUdEw8iIiI3rlyqP95OS0RERGHDHg8iIiIPDrXojokHERGRm+a6sgV7DOoYh1qIiIgobNjjQURE5MGhFt0x8SAiIvLgOh6641ALERERhQ17PIiIiNxYq0V/vSrxUC4NKsA6GkpYn0MJa7towpoMTuGKNJLaK1LSWi3Sghvi2h/CWi3S2itKWNtFEx5fXJBEStocab0NYW0Xya9X+jkxCNvuFLZd/LHS+/tH70tN52tHcnzpddZpnOOhOw61EBERUdj0qh4PIiIivxRk3XIdHYM6xMSDiIjIjXM89BexoZY9e/ZA07R2t8OHD3vj2nt83bp1kWo2ERH1ZAr/nufR6S3Sb6Jri1iPR3Z2Nmpqanz2/frXv8bu3bsxcuRIn/0bNmzAxIkTvT+bzeawtJGIiIhCK2KJR0xMDCwWi/fnlpYW7NixA3l5edCumsrer18/n1giIiJd8K4W3XWZu1p27NiBCxcuYPbs2W0ey8vLQ2JiIu68806sW7cOLhcr8BARkQ5cIdqoQ11mcun69esxYcIEpKam+uz/7W9/i7vvvhtxcXF47733sGDBAly4cAGLFy/u8Fh2ux12u937s81m063dREREFLiQ93gUFRV1OGnUsx05csTnOV988QX++te/4uGHH25zvMWLFyMrKwt33HEHFixYgKVLl+KFF17w24bi4mKYzWbvdnUyQ0RE1B7PXS3BbtSxkPd45OXlYcaMGX5jhg4d6vPzhg0bMHDgQEydOvWaxx81ahRsNhvOnTuHpKSkdmMKCwtRUFDg/dlmszH5ICKia+McD92FPPFITExEYmJiwPFKKWzYsAH/9V//hejo6GvGV1RUIDY2Fv369eswxmQywWQyBdwGIiIiCo+Iz/F4//33UVlZ2e4wy5///GdYrVZkZWUhLi4OH3zwARYtWoSf//znnUoslMsA5Qp0dEmWsUpru4hrqUiLVnQh0nMjvgdeWgsmwHo9HvLaK7JwHcvquF9A33hxfQ4d36/0VyX+XXX3SYNdrLaLqFZLuG6FYI+H7iKeeKxfvx7Z2dm47bbb2jwWHR2NNWvWoKCgAC6XCzfeeCOWLl2KefPmRaClRETU4zHx0F3Eb6d988038X//7/9t97GJEyeioqICDQ0NaGxsxLFjx/D4448jKiri+RIREVHY1dXVITc313vzRG5uLi5duuT3OUopFBUVISUlBXFxcRg7dixOnDjhE2O32/HYY48hMTERffv2xdSpU/HFF194Hz99+jQefvhhpKWlIS4uDjfddBOeeeYZOBwO8XuIeOJBRETUZXTxdTxmzpyJo0ePYteuXdi1axeOHj2K3Nxcv895/vnnsWrVKqxevRqHDx+GxWLB+PHj0dDQ4I3Jz8/H9u3bsWXLFuzfvx+XL1/G5MmT4XQ6AQD/+Mc/4HK58Pvf/x4nTpzASy+9hHXr1uHpp58WvwdNqZ7fJ2Sz2a7cVruuCIa42ACfJR38FYaL53jIwruSbj/HQxgP6fFbpXNOROHy40vjnaJwUbz4vUr/4HOOh19daY6Hs7kZp557GvX19UhISBC+0LV5vifuuaUAUcbgbk5oddqx+5+rQt7WTz/9FMOGDcPBgweRmZkJADh48CCysrLwj3/8A9/5znfaPEcphZSUFOTn5+Opp54CcKV3IykpCStWrMAvfvEL1NfX4/rrr8cf//hHTJ8+HQBw9uxZpKamYufOnZgwYUK77XnhhRewdu1afP7556L3wR4PIiIij6ALxP17jojNZvPZvrmwZWeUlZXBbDZ7kw7gyhITZrMZBw4caPc5lZWVsFqtyMnJ8e4zmUwYM2aM9znl5eVoaWnxiUlJSUF6enqHxwWA+vp6DBgwQPw+mHgQERHpIDU11Wcxy+Li4qCOZ7VaMWjQoDb7Bw0aBKvV2uFzALRZ9yopKcn7mNVqRUxMDPr3799hzNX+9a9/4ZVXXsHcuXPF74OzNImIiDxcKvh73F1Xnl9dXe0z1NLRMhBFRUVYsmSJ30MePnwYANoUUQWuDKe0t/+brn48kOd0FHP27FlMnDgRDz74IB555BG/x2gPEw8iIiKPEN5Om5CQENAcj0BX/P7kk09w7ty5No+dP3++w5W8PZXdrVYrkpOTvftra2u9z7FYLHA4HKirq/Pp9aitrUV2drbP8c6ePYtx48YhKysLr7322jXfW3s41EJERBRBiYmJuPXWW/1usbGxyMrKQn19PT766CPvcw8dOoT6+vo2CYJHWloaLBYLSktLvfscDgf27t3rfU5GRgaio6N9YmpqanD8+HGf43755ZcYO3YsRowYgQ0bNsBg6FwKwcSDiIjIKxQTS/W5WfS2227DxIkTMWfOHBw8eBAHDx7EnDlzMHnyZJ87Wm699VZs374dwJUhlvz8fCxfvhzbt2/H8ePHMXv2bPTp0wczZ84EAJjNZjz88MNYsGAB3nvvPVRUVOA///M/MXz4cNxzzz0ArvR0jB07FqmpqVi5ciXOnz8Pq9Xa4RwQfzjUQkRE5NHFVy594403MH/+fO8dKFOnTsXq1at9Yk6ePIn6+nrvz08++SSamprw6KOPoq6uDpmZmSgpKUF8fLw35qWXXkJUVBQeeughNDU14e6778bGjRthNBoBACUlJTh16hROnTqFwYMH+7yedFWO3rWOx6tLAl/HQ+91NnRfl0P6a9WxQdKmCNf9kF7B4nU5pOuQiNe1EK6bIT2f4nVLZIcXt1+wFoa4LeI1YHQ+vlQX+tgCYVjHQ8DZ3Ix/LQ/DOh5pjyHKEOQ6Hi47dle+oltbuzv2eBAREXm4QjBU4urx/58PChMPIiIiD+W6sgV7DOoQJ5cSERFR2LDHg4iIyKOLTy7tCZh4EBEReXCOh+6YeBAREXmwx0N3nONBREREYcMeDyIiIg+FEPR4hKQlPRYTDyIiIg8OteiOQy1EREQUNr2qx0O0LowmXAZa9yXQpbpOg8TJv3QZa+mS5uJ4Wbh8nekuRtp8g+wXpvS8NsW/K53jexk9l1hX4fpvsssF+YXU3jGoI70q8SAiIvKLQy2641ALERERhQ17PIiIiDzY46E7Jh5EREQeXLlUdxxqISIiorBhjwcREZGbUi6oIMvaB/v8no6JBxERkYdSwQ+VcI6HX0w8iIiIPFQI5ngw8fCLczyIiIgobNjjQURE5OFyAVqQczQ4x8MvJh5EREQeHGrRXa9KPDSXFnBdD2nNAfFlpnXjC1N4csRvVRyv8y9LWjumq/1qdayfAchPv6Sukbg+h/S96n5tCuO7Gp3LDomuHU4M6DF6VeJBRETkj3K5oIIcauHttP7pmkMuW7YM2dnZ6NOnD/r169duTFVVFaZMmYK+ffsiMTER8+fPh8Ph8Ik5duwYxowZg7i4OHzrW9/C0qVLodiVRUREoeZZMj3YjTqka4+Hw+HAgw8+iKysLKxfv77N406nE/feey+uv/567N+/HxcvXsSsWbOglMIrr7wCALDZbBg/fjzGjRuHw4cP45///Cdmz56Nvn37YsGCBXo2n4iIiEJM18RjyZIlAICNGze2+3hJSQn+/ve/o7q6GikpKQCAF198EbNnz8ayZcuQkJCAN954A83Nzdi4cSNMJhPS09Pxz3/+E6tWrUJBQQE0yYAxERGRPy4V/EQt9nj4FdHpOmVlZUhPT/cmHQAwYcIE2O12lJeXe2PGjBkDk8nkE3P27FmcPn263ePa7XbYbDafjYiI6JqUunI7bFAbEw9/Ipp4WK1WJCUl+ezr378/YmJiYLVaO4zx/OyJuVpxcTHMZrN3S01N1aH1REREJCVOPIqKiqBpmt/tyJEjAR+vvaESpZTP/qtjPBNLOxpmKSwsRH19vXerrq4OuD1ERNR7KZcKyUYdE8/xyMvLw4wZM/zGDB06NKBjWSwWHDp0yGdfXV0dWlpavL0aFoulTc9GbW0tALTpCfEwmUw+QzNEREQBUS4AXLlUT+LEIzExEYmJiSF58aysLCxbtgw1NTVITk4GcGXCqclkQkZGhjfm6aefhsPhQExMjDcmJSUl4ASHiIgoEMqloIKcXMrlHvzTdY5HVVUVjh49iqqqKjidThw9ehRHjx7F5cuXAQA5OTkYNmwYcnNzUVFRgffeew8LFy7EnDlzkJCQAACYOXMmTCYTZs+ejePHj2P79u1Yvnw572ghIiLqhnS9nfY3v/kNNm3a5P35+9//PgDggw8+wNixY2E0GvHuu+/i0UcfxQ9+8APExcVh5syZWLlypfc5ZrMZpaWlmDdvHkaOHIn+/fujoKAABQUFAbfDk326mpsDf47eOU2XW1dboLctmS7sNQ10WX4v6ZLssnBA2B7xoo16nh+9l6vvavFdje5/BwMPddmv/P3WuzehVdmDHippRUuIWtMzaaoX9Al98cUXvLOFiKgHqK6uxuDBg0N+3ObmZqSlpXV4t6SUxWJBZWUlYmNjQ3K8nqRXJB4ulwtnz55FfHy8z/CMzWZDamoqqqurvUM7FFo8x+HB86w/nuPw6Og8K6XQ0NCAlJQUGAz6zBJobm5uU7Kjs2JiYph0dKBXFIkzGAx+M+SEhAT+IdEZz3F48Dzrj+c4PNo7z2azWdfXjI2NZbIQBiw0TERERGHDxIOIiIjCplcnHiaTCc888wwXG9MRz3F48Dzrj+c4PHiee75eMbmUiIiIuoZe3eNBRERE4cXEg4iIiMKGiQcRERGFDRMPIiIiCptekXgsW7YM2dnZ6NOnD/r169duTFVVFaZMmYK+ffsiMTER8+fPb7OC3bFjxzBmzBjExcXhW9/6FpYuXcoqhH4MHToUmqb5bL/61a98YgI57+TfmjVrkJaWhtjYWGRkZODDDz+MdJO6raKiojbXrMVi8T6ulEJRURFSUlIQFxeHsWPH4sSJExFscfewb98+TJkyBSkpKdA0DX/60598Hg/kvNrtdjz22GNITExE3759MXXqVHzxxRdhfBcUKr0i8XA4HHjwwQfxy1/+st3HnU4n7r33XjQ2NmL//v3YsmULtm3bhgULFnhjbDYbxo8fj5SUFBw+fBivvPIKVq5ciVWrVoXrbXRLS5cuRU1NjXdbvHix97FAzjv5t3XrVuTn52PRokWoqKjA6NGjMWnSJFRVVUW6ad3Wd7/7XZ9r9tixY97Hnn/+eaxatQqrV6/G4cOHYbFYMH78eDQ0NESwxV1fY2Mjbr/9dqxevbrdxwM5r/n5+di+fTu2bNmC/fv34/Lly5g8eTKcTme43gaFiupFNmzYoMxmc5v9O3fuVAaDQX355ZfefW+99ZYymUyqvr5eKaXUmjVrlNlsVs3Nzd6Y4uJilZKSolwul+5t746GDBmiXnrppQ4fD+S8k3//8R//oebOneuz79Zbb1W/+tWvItSi7u2ZZ55Rt99+e7uPuVwuZbFY1HPPPefd19zcrMxms1q3bl2YWtj9AVDbt2/3/hzIeb106ZKKjo5WW7Zs8cZ8+eWXymAwqF27doWt7RQavaLH41rKysqQnp6OlJQU774JEybAbrejvLzcGzNmzBifRW0mTJiAs2fP4vTp0+FucrexYsUKDBw4EHfccQeWLVvmM4wSyHmnjjkcDpSXlyMnJ8dnf05ODg4cOBChVnV/n332GVJSUpCWloYZM2bg888/BwBUVlbCarX6nG+TyYQxY8bwfAchkPNaXl6OlpYWn5iUlBSkp6fz3HdDvaJI3LVYrVYkJSX57Ovfvz9iYmK8JZKtViuGDh3qE+N5jtVqRVpaWlja2p08/vjjGDFiBPr374+PPvoIhYWFqKysxB/+8AcAgZ136tiFCxfgdDrbnMOkpCSev07KzMzE5s2bccstt+DcuXN49tlnkZ2djRMnTnjPaXvn+8yZM5Fobo8QyHm1Wq2IiYlB//7928TwWu9+um2PR3uTwK7ejhw5EvDxNE1rs08p5bP/6hjlnlja3nN7Ksl5f+KJJzBmzBh873vfwyOPPIJ169Zh/fr1uHjxovd4gZx38q+965Lnr3MmTZqEBx54AMOHD8c999yDd999FwCwadMmbwzPtz46c1557runbtvjkZeXhxkzZviNubqHoiMWiwWHDh3y2VdXV4eWlhZvFm6xWNpk1rW1tQDaZuo9WTDnfdSoUQCAU6dOYeDAgQGdd+pYYmIijEZju9clz19o9O3bF8OHD8dnn32GadOmAbjyv+/k5GRvDM93cDx3Dfk7rxaLBQ6HA3V1dT69HrW1tcjOzg5vgylo3bbHIzExEbfeeqvfLTY2NqBjZWVl4fjx46ipqfHuKykpgclkQkZGhjdm3759PnMUSkpKkJKSEnCC0xMEc94rKioAwPvHJZDzTh2LiYlBRkYGSktLffaXlpbyj3GI2O12fPrpp0hOTkZaWhosFovP+XY4HNi7dy/PdxACOa8ZGRmIjo72iampqcHx48d57rujCE5sDZszZ86oiooKtWTJEnXdddepiooKVVFRoRoaGpRSSrW2tqr09HR19913q7/97W9q9+7davDgwSovL897jEuXLqmkpCT105/+VB07dky9/fbbKiEhQa1cuTJSb6tLO3DggFq1apWqqKhQn3/+udq6datKSUlRU6dO9cYEct7Jvy1btqjo6Gi1fv169fe//13l5+ervn37qtOnT0e6ad3SggUL1J49e9Tnn3+uDh48qCZPnqzi4+O95/O5555TZrNZvf322+rYsWPqpz/9qUpOTlY2my3CLe/aGhoavH93AXj/Npw5c0YpFdh5nTt3rho8eLDavXu3+tvf/qZ+9KMfqdtvv121trZG6m1RJ/WKxGPWrFkKQJvtgw8+8MacOXNG3XvvvSouLk4NGDBA5eXl+dw6q5RSn3zyiRo9erQymUzKYrGooqIi3krbgfLycpWZmanMZrOKjY1V3/nOd9QzzzyjGhsbfeICOe/k36uvvqqGDBmiYmJi1IgRI9TevXsj3aRua/r06So5OVlFR0erlJQUdf/996sTJ054H3e5XOqZZ55RFotFmUwmddddd6ljx45FsMXdwwcffNDu3+BZs2YppQI7r01NTSovL08NGDBAxcXFqcmTJ6uqqqoIvBsKlqYUl94kIiKi8Oi2czyIiIio+2HiQURERGHDxIOIiIjChokHERERhQ0TDyIiIgobJh5EREQUNkw8iIiIKGyYeBAREVHYMPEgIiKisGHiQURERGHDxIOIiIjChokHERERhc3/D3RXDADVTLt6AAAAAElFTkSuQmCC", + "image/png": "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", "text/plain": [ "
" ] @@ -538,11 +561,11 @@ "id": "e916f176-b4b7-427a-847c-a282f85640a5", "metadata": { "execution": { - "iopub.execute_input": "2026-02-04T22:10:05.869374Z", - "iopub.status.busy": "2026-02-04T22:10:05.869124Z", - "iopub.status.idle": "2026-02-04T22:10:06.318406Z", - "shell.execute_reply": "2026-02-04T22:10:06.317548Z", - "shell.execute_reply.started": "2026-02-04T22:10:05.869349Z" + "iopub.execute_input": "2026-02-10T22:21:22.574554Z", + "iopub.status.busy": "2026-02-10T22:21:22.574328Z", + "iopub.status.idle": "2026-02-10T22:21:23.243878Z", + "shell.execute_reply": "2026-02-10T22:21:23.243085Z", + "shell.execute_reply.started": "2026-02-10T22:21:22.574536Z" } }, "outputs": [ @@ -590,11 +613,11 @@ "id": "931c7ff0-0f45-40cb-8227-c78e97823f79", "metadata": { "execution": { - "iopub.execute_input": "2026-02-04T22:10:06.319349Z", - "iopub.status.busy": "2026-02-04T22:10:06.319087Z", - "iopub.status.idle": "2026-02-04T22:10:06.323399Z", - "shell.execute_reply": "2026-02-04T22:10:06.322262Z", - "shell.execute_reply.started": "2026-02-04T22:10:06.319325Z" + "iopub.execute_input": "2026-02-10T22:21:23.244557Z", + "iopub.status.busy": "2026-02-10T22:21:23.244380Z", + "iopub.status.idle": "2026-02-10T22:21:23.247707Z", + "shell.execute_reply": "2026-02-10T22:21:23.246908Z", + "shell.execute_reply.started": "2026-02-10T22:21:23.244541Z" } }, "outputs": [], @@ -613,11 +636,11 @@ "id": "c862c062-c7e2-4d7b-8825-109fa7072bdd", "metadata": { "execution": { - "iopub.execute_input": "2026-02-04T22:10:06.324455Z", - "iopub.status.busy": "2026-02-04T22:10:06.324131Z", - "iopub.status.idle": "2026-02-04T22:10:06.328879Z", - "shell.execute_reply": "2026-02-04T22:10:06.327578Z", - "shell.execute_reply.started": "2026-02-04T22:10:06.324426Z" + "iopub.execute_input": "2026-02-10T22:21:23.248570Z", + "iopub.status.busy": "2026-02-10T22:21:23.248342Z", + "iopub.status.idle": "2026-02-10T22:21:23.263092Z", + "shell.execute_reply": "2026-02-10T22:21:23.262319Z", + "shell.execute_reply.started": "2026-02-10T22:21:23.248552Z" } }, "outputs": [], @@ -632,11 +655,11 @@ "id": "9042f903-4d02-4abe-9de1-2dfacfb3b3a0", "metadata": { "execution": { - "iopub.execute_input": "2026-02-04T22:10:06.330141Z", - "iopub.status.busy": "2026-02-04T22:10:06.329750Z", - "iopub.status.idle": "2026-02-04T22:10:06.337141Z", - "shell.execute_reply": "2026-02-04T22:10:06.335787Z", - "shell.execute_reply.started": "2026-02-04T22:10:06.330095Z" + "iopub.execute_input": "2026-02-10T22:21:23.263933Z", + "iopub.status.busy": "2026-02-10T22:21:23.263704Z", + "iopub.status.idle": "2026-02-10T22:21:23.274949Z", + "shell.execute_reply": "2026-02-10T22:21:23.274135Z", + "shell.execute_reply.started": "2026-02-10T22:21:23.263915Z" } }, "outputs": [], @@ -646,13 +669,17 @@ "# Let's use a tikhonov zero for now, because I haven't implemented model slices in Smallness yet\n", "smallness = ii.Smallness(mesh=mesh, cell_weights=depth_weights, model_slice=wires.density)\n", "\n", - "# I need to manually combine weights for the density and weights for the dummy (just zeros).\n", - "# This shouldn't be necessary if the regularization handles model slices too.\n", - "# density_weights = mesh.cell_volumes * depth_weights\n", - "# dummy_weights = np.zeros(wires.dummy.size)\n", - "# weights = np.hstack((density_weights, dummy_weights))\n", + "flatness_x, flatness_y, flatness_z = tuple(\n", + " ii.Flatness(\n", + " mesh, direction=direction, cell_weights=depth_weights, model_slice=wires.density\n", + " )\n", + " for direction in (\"x\", \"y\", \"z\")\n", + ")\n", "\n", - "# smallness = ii.TikhonovZero(n_params=wires.size, weights=weights)" + "alpha_x, alpha_y, alpha_z = 1e-2, 1e-2, 1e-2\n", + "regularization = (\n", + " smallness + alpha_x * flatness_x + alpha_y * flatness_y + alpha_z * flatness_z\n", + ").flatten()" ] }, { @@ -661,11 +688,11 @@ "id": "ae115d7f-6b08-4c4e-b5f3-7277c24a49e4", "metadata": { "execution": { - "iopub.execute_input": "2026-02-04T22:10:06.338250Z", - "iopub.status.busy": "2026-02-04T22:10:06.337876Z", - "iopub.status.idle": "2026-02-04T22:10:06.342576Z", - "shell.execute_reply": "2026-02-04T22:10:06.341101Z", - "shell.execute_reply.started": "2026-02-04T22:10:06.338210Z" + "iopub.execute_input": "2026-02-10T22:22:37.539647Z", + "iopub.status.busy": "2026-02-10T22:22:37.539368Z", + "iopub.status.idle": "2026-02-10T22:22:37.542739Z", + "shell.execute_reply": "2026-02-10T22:22:37.541968Z", + "shell.execute_reply.started": "2026-02-10T22:22:37.539621Z" } }, "outputs": [], @@ -687,11 +714,11 @@ "id": "dbc4da3d", "metadata": { "execution": { - "iopub.execute_input": "2026-02-04T22:10:06.343407Z", - "iopub.status.busy": "2026-02-04T22:10:06.343157Z", - "iopub.status.idle": "2026-02-04T22:10:06.348438Z", - "shell.execute_reply": "2026-02-04T22:10:06.347465Z", - "shell.execute_reply.started": "2026-02-04T22:10:06.343380Z" + "iopub.execute_input": "2026-02-10T22:22:38.248710Z", + "iopub.status.busy": "2026-02-10T22:22:38.248511Z", + "iopub.status.idle": "2026-02-10T22:22:38.252618Z", + "shell.execute_reply": "2026-02-10T22:22:38.252002Z", + "shell.execute_reply.started": "2026-02-10T22:22:38.248692Z" } }, "outputs": [ @@ -717,11 +744,11 @@ "id": "463b4e7b", "metadata": { "execution": { - "iopub.execute_input": "2026-02-04T22:10:06.349099Z", - "iopub.status.busy": "2026-02-04T22:10:06.348906Z", - "iopub.status.idle": "2026-02-04T22:10:07.335070Z", - "shell.execute_reply": "2026-02-04T22:10:07.334110Z", - "shell.execute_reply.started": "2026-02-04T22:10:06.349081Z" + "iopub.execute_input": "2026-02-10T22:22:38.568958Z", + "iopub.status.busy": "2026-02-10T22:22:38.568752Z", + "iopub.status.idle": "2026-02-10T22:22:39.326392Z", + "shell.execute_reply": "2026-02-10T22:22:39.325752Z", + "shell.execute_reply.started": "2026-02-10T22:22:38.568941Z" } }, "outputs": [ @@ -745,14 +772,43 @@ { "cell_type": "code", "execution_count": 24, + "id": "b7d8d1fc-af33-4658-bd94-a0ad75665bd3", + "metadata": { + "execution": { + "iopub.execute_input": "2026-02-10T22:22:39.327817Z", + "iopub.status.busy": "2026-02-10T22:22:39.327530Z", + "iopub.status.idle": "2026-02-10T22:22:39.954617Z", + "shell.execute_reply": "2026-02-10T22:22:39.953804Z", + "shell.execute_reply.started": "2026-02-10T22:22:39.327791Z" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "<64003x64003 BlockSquareMatrix with dtype=float64>" + ] + }, + "execution_count": 24, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "data_misfit.hessian(initial_model)" + ] + }, + { + "cell_type": "code", + "execution_count": 25, "id": "e2dfb4e8-1996-4f3f-8b05-781fc2d4537c", "metadata": { "execution": { - "iopub.execute_input": "2026-02-04T22:10:07.335763Z", - "iopub.status.busy": "2026-02-04T22:10:07.335594Z", - "iopub.status.idle": "2026-02-04T22:10:11.413712Z", - "shell.execute_reply": "2026-02-04T22:10:11.413122Z", - "shell.execute_reply.started": "2026-02-04T22:10:07.335748Z" + "iopub.execute_input": "2026-02-10T22:22:39.955147Z", + "iopub.status.busy": "2026-02-10T22:22:39.954973Z", + "iopub.status.idle": "2026-02-10T22:22:44.455342Z", + "shell.execute_reply": "2026-02-10T22:22:44.454122Z", + "shell.execute_reply.started": "2026-02-10T22:22:39.955131Z" } }, "outputs": [ @@ -760,7 +816,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "Elapsed time (no preconditioner): 4.07s\n" + "Elapsed time (no preconditioner): 4.49s\n" ] } ], @@ -775,15 +831,15 @@ }, { "cell_type": "code", - "execution_count": 25, + "execution_count": 26, "id": "82c1ddc2-d886-4cd1-a42d-1c32af5d4465", "metadata": { "execution": { - "iopub.execute_input": "2026-02-04T22:10:11.414326Z", - "iopub.status.busy": "2026-02-04T22:10:11.414114Z", - "iopub.status.idle": "2026-02-04T22:10:11.420851Z", - "shell.execute_reply": "2026-02-04T22:10:11.418759Z", - "shell.execute_reply.started": "2026-02-04T22:10:11.414306Z" + "iopub.execute_input": "2026-02-10T22:22:44.457914Z", + "iopub.status.busy": "2026-02-10T22:22:44.456088Z", + "iopub.status.idle": "2026-02-10T22:22:44.465712Z", + "shell.execute_reply": "2026-02-10T22:22:44.464550Z", + "shell.execute_reply.started": "2026-02-10T22:22:44.457886Z" } }, "outputs": [ @@ -794,7 +850,7 @@ " 0. , 0. ], shape=(64003,))" ] }, - "execution_count": 25, + "execution_count": 26, "metadata": {}, "output_type": "execute_result" } @@ -805,27 +861,27 @@ }, { "cell_type": "code", - "execution_count": 26, + "execution_count": 27, "id": "05ef6fdf-55c0-4911-9ac8-2041af49b3cd", "metadata": { "execution": { - "iopub.execute_input": "2026-02-04T22:10:11.421566Z", - "iopub.status.busy": "2026-02-04T22:10:11.421334Z", - "iopub.status.idle": "2026-02-04T22:10:11.431604Z", - "shell.execute_reply": "2026-02-04T22:10:11.430654Z", - "shell.execute_reply.started": "2026-02-04T22:10:11.421544Z" + "iopub.execute_input": "2026-02-10T22:22:44.467501Z", + "iopub.status.busy": "2026-02-10T22:22:44.466609Z", + "iopub.status.idle": "2026-02-10T22:22:44.488420Z", + "shell.execute_reply": "2026-02-10T22:22:44.487023Z", + "shell.execute_reply.started": "2026-02-10T22:22:44.467472Z" } }, "outputs": [ { "data": { "text/plain": [ - "{'density': array([-0.00010969, -0.00011732, -0.0001238 , ..., -0.00050626,\n", - " 0.0006502 , -0.00043861], shape=(64000,)),\n", + "{'density': array([-0.00010969, -0.00011732, -0.0001238 , ..., -0.00050627,\n", + " 0.00065019, -0.00043858], shape=(64000,)),\n", " 'dummy': array([0., 0., 0.])}" ] }, - "execution_count": 26, + "execution_count": 27, "metadata": {}, "output_type": "execute_result" } @@ -837,26 +893,26 @@ }, { "cell_type": "code", - "execution_count": 27, + "execution_count": 28, "id": "d20f5357-efd0-42cb-a156-90fcd6b41f0b", "metadata": { "execution": { - "iopub.execute_input": "2026-02-04T22:10:11.437271Z", - "iopub.status.busy": "2026-02-04T22:10:11.436914Z", - "iopub.status.idle": "2026-02-04T22:10:11.446289Z", - "shell.execute_reply": "2026-02-04T22:10:11.445191Z", - "shell.execute_reply.started": "2026-02-04T22:10:11.437241Z" + "iopub.execute_input": "2026-02-10T22:22:48.762255Z", + "iopub.status.busy": "2026-02-10T22:22:48.762050Z", + "iopub.status.idle": "2026-02-10T22:22:48.766388Z", + "shell.execute_reply": "2026-02-10T22:22:48.765620Z", + "shell.execute_reply.started": "2026-02-10T22:22:48.762237Z" } }, "outputs": [ { "data": { "text/plain": [ - "array([-0.00010969, -0.00011732, -0.0001238 , ..., -0.00050626,\n", - " 0.0006502 , -0.00043861], shape=(64000,))" + "array([-0.00010969, -0.00011732, -0.0001238 , ..., -0.00050627,\n", + " 0.00065019, -0.00043858], shape=(64000,))" ] }, - "execution_count": 27, + "execution_count": 28, "metadata": {}, "output_type": "execute_result" } @@ -868,31 +924,31 @@ }, { "cell_type": "code", - "execution_count": 28, + "execution_count": 29, "id": "70b2b5ea-d6dd-4cf3-855c-9e8fd600c7cd", "metadata": { "execution": { - "iopub.execute_input": "2026-02-04T22:10:11.446959Z", - "iopub.status.busy": "2026-02-04T22:10:11.446753Z", - "iopub.status.idle": "2026-02-04T22:10:11.625001Z", - "shell.execute_reply": "2026-02-04T22:10:11.623804Z", - "shell.execute_reply.started": "2026-02-04T22:10:11.446937Z" + "iopub.execute_input": "2026-02-10T22:22:49.101217Z", + "iopub.status.busy": "2026-02-10T22:22:49.101017Z", + "iopub.status.idle": "2026-02-10T22:22:49.255379Z", + "shell.execute_reply": "2026-02-10T22:22:49.254629Z", + "shell.execute_reply.started": "2026-02-10T22:22:49.101200Z" } }, "outputs": [ { "data": { "text/plain": [ - "(,)" + "(,)" ] }, - "execution_count": 28, + "execution_count": 29, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] From d7b832c68e535adaa1ad410fbc04ca494f16f6fb Mon Sep 17 00:00:00 2001 From: Santiago Soler Date: Tue, 10 Feb 2026 14:48:37 -0800 Subject: [PATCH 26/47] Define a support_model_slice decorator Use the decorator in the DataMisfit and the mesh-based regularizations. --- src/inversion_ideas/data_misfit.py | 55 +++++-------------- .../regularization/_mesh_based.py | 26 +++------ src/inversion_ideas/utils.py | 55 +++++++++++++++++++ 3 files changed, 75 insertions(+), 61 deletions(-) diff --git a/src/inversion_ideas/data_misfit.py b/src/inversion_ideas/data_misfit.py index bb0f3fb..ea14274 100644 --- a/src/inversion_ideas/data_misfit.py +++ b/src/inversion_ideas/data_misfit.py @@ -9,7 +9,7 @@ from .base import Objective from .typing import Model -from .utils import cache_on_model +from .utils import cache_on_model, support_model_slice from .wires import ModelSlice @@ -97,67 +97,54 @@ def __init__( self.build_hessian = build_hessian self.set_name("d") + @support_model_slice @cache_on_model def __call__(self, model: Model) -> float: # TODO: # Cache invalidation: we should clean the cache if data or uncertainties change. # Or they should be immutable. - residual = self.residual(model) + residual = self.simulation(model) - self.data weights_matrix = self.weights_matrix return residual.T @ weights_matrix.T @ weights_matrix @ residual + @support_model_slice def gradient(self, model: Model) -> npt.NDArray[np.float64]: """ Gradient vector. """ - jac = self._get_jacobian(model) + jac = self.simulation.jacobian(model) weights_matrix = self.weights_matrix - gradient = ( - 2 * jac.T @ (weights_matrix.T @ weights_matrix @ self.residual(model)) - ) - - if self.model_slice is not None: - gradient = self.model_slice.expand_array(gradient) - + residual = self.simulation(model) - self.data + gradient = 2 * jac.T @ (weights_matrix.T @ weights_matrix @ residual) return gradient + @support_model_slice def hessian( self, model: Model ) -> npt.NDArray[np.float64] | sparray | LinearOperator: """ Hessian matrix. """ - jac = self._get_jacobian(model) + jac = self.simulation.jacobian(model) weights_matrix = aslinearoperator(self.weights_matrix) if not self.build_hessian: jac = aslinearoperator(jac) + return 2 * jac.T @ weights_matrix.T @ weights_matrix @ jac - hessian = 2 * jac.T @ weights_matrix.T @ weights_matrix @ jac - - if self.model_slice is not None: - hessian = self.model_slice.expand_matrix(hessian) - - return hessian - + @support_model_slice def hessian_diagonal(self, model: Model) -> npt.NDArray[np.float64]: """ Approximated diagonal of the Hessian. """ - jac = self._get_jacobian(model) + jac = self.simulation.jacobian(model) if isinstance(jac, LinearOperator): msg = ( "`DataMisfit.hessian_diagonal()` is not implemented for simulations " "that return the jacobian as a LinearOperator." ) raise NotImplementedError(msg) - jtj_diag = np.einsum("i,ij,ij->j", self.weights_matrix.diagonal(), jac, jac) - hessian_diag = 2 * jtj_diag - - if self.model_slice is not None: - hessian_diag = self.model_slice.expand_array(hessian_diag) - - return hessian_diag + return 2 * jtj_diag @property def n_params(self): @@ -233,19 +220,3 @@ def chi_factor(self, model: Model): Chi factor for the given model. """ return self(model) / self.n_data - - def _get_jacobian(self, model: Model) -> LinearOperator: - """ - Return the jacobian of the simulation evaluated on the passed model. - - Parameters - ---------- - model : (n_params) array - Model array. The array must have the full size. This method will use the - ``model_slice`` to extract the relevant portion that will be passed to the - simulation. - """ - jac = self.simulation.jacobian( - model if self.model_slice is None else self.model_slice.extract(model) - ) - return jac diff --git a/src/inversion_ideas/regularization/_mesh_based.py b/src/inversion_ideas/regularization/_mesh_based.py index 1cdeecc..5239010 100644 --- a/src/inversion_ideas/regularization/_mesh_based.py +++ b/src/inversion_ideas/regularization/_mesh_based.py @@ -11,6 +11,7 @@ from .._utils import prod_arrays from ..base import Objective from ..typing import Model +from ..utils import support_model_slice from ..wires import ModelSlice @@ -171,6 +172,7 @@ def __init__( ) self.set_name("s") + @support_model_slice def __call__(self, model: Model) -> float: """ Evaluate the regularization on a given model. @@ -180,7 +182,6 @@ def __call__(self, model: Model) -> float: model : (n_params) array Array with model values. """ - model = model if self.model_slice is None else self.model_slice.extract(model) model_diff = model - self.reference_model weights_matrix = self.weights_matrix cell_volumes_sqrt = self._volumes_sqrt_matrix @@ -193,6 +194,7 @@ def __call__(self, model: Model) -> float: @ model_diff ) + @support_model_slice def gradient(self, model: Model): """ Gradient vector. @@ -202,7 +204,6 @@ def gradient(self, model: Model): model : (n_params) array Array with model values. """ - model = model if self.model_slice is None else self.model_slice.extract(model) model_diff = model - self.reference_model weights_matrix = self.weights_matrix cell_volumes_sqrt = self._volumes_sqrt_matrix @@ -214,12 +215,9 @@ def gradient(self, model: Model): @ cell_volumes_sqrt @ model_diff ) - - if self.model_slice is not None: - gradient = self.model_slice.expand_array(gradient) - return gradient + @support_model_slice def hessian(self, model: Model): # noqa: ARG002 """ Hessian matrix. @@ -238,10 +236,6 @@ def hessian(self, model: Model): # noqa: ARG002 @ weights_matrix @ cell_volumes_sqrt ) - - if self.model_slice is not None: - hessian = self.model_slice.expand_matrix(hessian) - return hessian def hessian_diagonal(self, model: Model) -> npt.NDArray[np.float64]: @@ -386,6 +380,7 @@ def __init__( ) self.set_name(direction) + @support_model_slice def __call__(self, model: Model) -> float: """ Evaluate the regularization on a given model. @@ -395,7 +390,6 @@ def __call__(self, model: Model) -> float: model : (n_params) array Array with model values. """ - model = model if self.model_slice is None else self.model_slice.extract(model) model_diff = model - self.reference_model weights_matrix = self.weights_matrix cell_volumes_sqrt = self._volumes_sqrt_matrix @@ -411,6 +405,7 @@ def __call__(self, model: Model) -> float: @ model_diff ) + @support_model_slice def gradient(self, model: Model): """ Gradient vector. @@ -420,12 +415,10 @@ def gradient(self, model: Model): model : (n_params) array Array with model values. """ - model = model if self.model_slice is None else self.model_slice.extract(model) model_diff = model - self.reference_model weights_matrix = self.weights_matrix cell_volumes_sqrt = self._volumes_sqrt_matrix cell_gradient = self._cell_gradient - gradient = ( 2 @ cell_gradient.T @@ -436,12 +429,9 @@ def gradient(self, model: Model): @ cell_gradient @ model_diff ) - - if self.model_slice is not None: - gradient = self.model_slice.expand_array(gradient) - return gradient + @support_model_slice def hessian(self, model: Model): # noqa: ARG002 """ Hessian matrix. @@ -463,8 +453,6 @@ def hessian(self, model: Model): # noqa: ARG002 @ cell_volumes_sqrt @ cell_gradient ) - if self.model_slice is not None: - hessian = self.model_slice.expand_matrix(hessian) return hessian def hessian_diagonal(self, model: Model) -> npt.NDArray[np.float64]: diff --git a/src/inversion_ideas/utils.py b/src/inversion_ideas/utils.py index 3b8bc1d..57eab89 100644 --- a/src/inversion_ideas/utils.py +++ b/src/inversion_ideas/utils.py @@ -10,6 +10,8 @@ import numpy.typing as npt from scipy.sparse import sparray +from inversion_ideas.wires import ModelSlice + __all__ = [ "cache_on_model", "get_logger", @@ -158,3 +160,56 @@ def get_sensitivity_weights( sensitivty_weights[sensitivty_weights < vmin] = vmin return sensitivty_weights + + +def support_model_slice(func): + """ + Apply a ``model_slice`` to the input and output of a method. + + This decorator will take the full model passed to the decorated method, extract only + the relevant slice for the instance based on its ``model_slice``, and then extend + the result if it's a 1D array or a 2D matrix, filling non-relevant elements with + zeros. + + .. important:: + + Use this decorator only for methods that take the ``model`` as the first + argument. + + .. important:: + + The instance needs to have a ``model_slice`` attribute. If it's None, then the + method will run without any modification. + """ + + @functools.wraps(func) + def wrapper(self, model, *args, **kwargs): + if not hasattr(self, "model_slice"): + # TODO: add msg + raise AttributeError() + + if self.model_slice is None: + return func(self, model, *args, **kwargs) + + model_slice: ModelSlice = self.model_slice + model_reduced = model_slice.extract(model) + result = func(self, model_reduced, *args, **kwargs) + + if isinstance(result, float): + return result + + if hasattr(result, "ndim"): + if result.ndim == 1: + result = model_slice.expand_array(result) + elif result.ndim == 2: + result = model_slice.expand_matrix(result) + else: + # TODO: add msg + raise ValueError() + else: + # TODO: add msg + raise TypeError() + + return result + + return wrapper From c9e723929bcf321ad3bb60626978364664c5007a Mon Sep 17 00:00:00 2001 From: Santiago Soler Date: Tue, 10 Feb 2026 14:50:13 -0800 Subject: [PATCH 27/47] Rerun notebook --- ...0_gravity-inversion-with-model-slice.ipynb | 308 +++++++++--------- 1 file changed, 157 insertions(+), 151 deletions(-) diff --git a/notebooks/50_gravity-inversion-with-model-slice.ipynb b/notebooks/50_gravity-inversion-with-model-slice.ipynb index 121decb..10928d8 100644 --- a/notebooks/50_gravity-inversion-with-model-slice.ipynb +++ b/notebooks/50_gravity-inversion-with-model-slice.ipynb @@ -14,11 +14,11 @@ "id": "b2d27e8b-5b33-4361-990b-8b6e724f5ac6", "metadata": { "execution": { - "iopub.execute_input": "2026-02-10T22:21:15.017652Z", - "iopub.status.busy": "2026-02-10T22:21:15.017317Z", - "iopub.status.idle": "2026-02-10T22:21:16.780605Z", - "shell.execute_reply": "2026-02-10T22:21:16.779846Z", - "shell.execute_reply.started": "2026-02-10T22:21:15.017626Z" + "iopub.execute_input": "2026-02-10T22:47:20.427308Z", + "iopub.status.busy": "2026-02-10T22:47:20.426922Z", + "iopub.status.idle": "2026-02-10T22:47:22.228165Z", + "shell.execute_reply": "2026-02-10T22:47:22.227411Z", + "shell.execute_reply.started": "2026-02-10T22:47:20.427282Z" } }, "outputs": [], @@ -54,11 +54,11 @@ "id": "dfce90d3-de10-43d3-a668-696993b0f73e", "metadata": { "execution": { - "iopub.execute_input": "2026-02-10T22:21:16.781939Z", - "iopub.status.busy": "2026-02-10T22:21:16.781398Z", - "iopub.status.idle": "2026-02-10T22:21:16.786066Z", - "shell.execute_reply": "2026-02-10T22:21:16.785076Z", - "shell.execute_reply.started": "2026-02-10T22:21:16.781915Z" + "iopub.execute_input": "2026-02-10T22:47:22.229313Z", + "iopub.status.busy": "2026-02-10T22:47:22.228850Z", + "iopub.status.idle": "2026-02-10T22:47:22.233668Z", + "shell.execute_reply": "2026-02-10T22:47:22.232855Z", + "shell.execute_reply.started": "2026-02-10T22:47:22.229286Z" } }, "outputs": [], @@ -81,11 +81,11 @@ "id": "2403d600-451e-424e-8de9-3f824f1e2647", "metadata": { "execution": { - "iopub.execute_input": "2026-02-10T22:21:16.786730Z", - "iopub.status.busy": "2026-02-10T22:21:16.786555Z", - "iopub.status.idle": "2026-02-10T22:21:18.020986Z", - "shell.execute_reply": "2026-02-10T22:21:18.020190Z", - "shell.execute_reply.started": "2026-02-10T22:21:16.786714Z" + "iopub.execute_input": "2026-02-10T22:47:22.234497Z", + "iopub.status.busy": "2026-02-10T22:47:22.234266Z", + "iopub.status.idle": "2026-02-10T22:47:23.503430Z", + "shell.execute_reply": "2026-02-10T22:47:23.502649Z", + "shell.execute_reply.started": "2026-02-10T22:47:22.234472Z" } }, "outputs": [ @@ -114,11 +114,11 @@ "id": "9612913a-b699-4ad4-8fe7-cbf83376f5d8", "metadata": { "execution": { - "iopub.execute_input": "2026-02-10T22:21:18.022001Z", - "iopub.status.busy": "2026-02-10T22:21:18.021707Z", - "iopub.status.idle": "2026-02-10T22:21:18.168409Z", - "shell.execute_reply": "2026-02-10T22:21:18.167897Z", - "shell.execute_reply.started": "2026-02-10T22:21:18.021974Z" + "iopub.execute_input": "2026-02-10T22:47:23.504311Z", + "iopub.status.busy": "2026-02-10T22:47:23.504089Z", + "iopub.status.idle": "2026-02-10T22:47:23.650692Z", + "shell.execute_reply": "2026-02-10T22:47:23.649895Z", + "shell.execute_reply.started": "2026-02-10T22:47:23.504293Z" } }, "outputs": [ @@ -146,11 +146,11 @@ "id": "f6d55c30-c5c9-4376-bc6d-ece83805b2d2", "metadata": { "execution": { - "iopub.execute_input": "2026-02-10T22:21:18.169511Z", - "iopub.status.busy": "2026-02-10T22:21:18.169180Z", - "iopub.status.idle": "2026-02-10T22:21:18.173650Z", - "shell.execute_reply": "2026-02-10T22:21:18.173044Z", - "shell.execute_reply.started": "2026-02-10T22:21:18.169486Z" + "iopub.execute_input": "2026-02-10T22:47:23.651444Z", + "iopub.status.busy": "2026-02-10T22:47:23.651218Z", + "iopub.status.idle": "2026-02-10T22:47:23.655364Z", + "shell.execute_reply": "2026-02-10T22:47:23.654561Z", + "shell.execute_reply.started": "2026-02-10T22:47:23.651378Z" } }, "outputs": [ @@ -183,11 +183,11 @@ "id": "0edbb620-6a62-48bf-a8af-8981a76cc6f4", "metadata": { "execution": { - "iopub.execute_input": "2026-02-10T22:21:18.174272Z", - "iopub.status.busy": "2026-02-10T22:21:18.174083Z", - "iopub.status.idle": "2026-02-10T22:21:18.190985Z", - "shell.execute_reply": "2026-02-10T22:21:18.190094Z", - "shell.execute_reply.started": "2026-02-10T22:21:18.174256Z" + "iopub.execute_input": "2026-02-10T22:47:23.656000Z", + "iopub.status.busy": "2026-02-10T22:47:23.655825Z", + "iopub.status.idle": "2026-02-10T22:47:23.672077Z", + "shell.execute_reply": "2026-02-10T22:47:23.671191Z", + "shell.execute_reply.started": "2026-02-10T22:47:23.655984Z" } }, "outputs": [ @@ -273,11 +273,11 @@ "id": "8a890b93-78ec-4681-bbb5-cc91e1448a85", "metadata": { "execution": { - "iopub.execute_input": "2026-02-10T22:21:18.191884Z", - "iopub.status.busy": "2026-02-10T22:21:18.191660Z", - "iopub.status.idle": "2026-02-10T22:21:18.197735Z", - "shell.execute_reply": "2026-02-10T22:21:18.196927Z", - "shell.execute_reply.started": "2026-02-10T22:21:18.191866Z" + "iopub.execute_input": "2026-02-10T22:47:23.673015Z", + "iopub.status.busy": "2026-02-10T22:47:23.672771Z", + "iopub.status.idle": "2026-02-10T22:47:23.679589Z", + "shell.execute_reply": "2026-02-10T22:47:23.679040Z", + "shell.execute_reply.started": "2026-02-10T22:47:23.672997Z" } }, "outputs": [], @@ -294,11 +294,11 @@ "id": "1dd17123-2df8-45b6-9345-d5cb6f431d51", "metadata": { "execution": { - "iopub.execute_input": "2026-02-10T22:21:18.198570Z", - "iopub.status.busy": "2026-02-10T22:21:18.198321Z", - "iopub.status.idle": "2026-02-10T22:21:18.248806Z", - "shell.execute_reply": "2026-02-10T22:21:18.248021Z", - "shell.execute_reply.started": "2026-02-10T22:21:18.198545Z" + "iopub.execute_input": "2026-02-10T22:47:23.680432Z", + "iopub.status.busy": "2026-02-10T22:47:23.680233Z", + "iopub.status.idle": "2026-02-10T22:47:23.734282Z", + "shell.execute_reply": "2026-02-10T22:47:23.733445Z", + "shell.execute_reply.started": "2026-02-10T22:47:23.680413Z" } }, "outputs": [], @@ -312,11 +312,11 @@ "id": "b4c9ad67-47fe-4408-b879-d99b8eec8ca2", "metadata": { "execution": { - "iopub.execute_input": "2026-02-10T22:21:18.249496Z", - "iopub.status.busy": "2026-02-10T22:21:18.249274Z", - "iopub.status.idle": "2026-02-10T22:21:18.253456Z", - "shell.execute_reply": "2026-02-10T22:21:18.252514Z", - "shell.execute_reply.started": "2026-02-10T22:21:18.249473Z" + "iopub.execute_input": "2026-02-10T22:47:23.734860Z", + "iopub.status.busy": "2026-02-10T22:47:23.734698Z", + "iopub.status.idle": "2026-02-10T22:47:23.738293Z", + "shell.execute_reply": "2026-02-10T22:47:23.737432Z", + "shell.execute_reply.started": "2026-02-10T22:47:23.734844Z" } }, "outputs": [], @@ -333,11 +333,11 @@ "id": "ffc07711-d8e3-49cf-9574-f2bde45ceec8", "metadata": { "execution": { - "iopub.execute_input": "2026-02-10T22:21:18.254334Z", - "iopub.status.busy": "2026-02-10T22:21:18.254078Z", - "iopub.status.idle": "2026-02-10T22:21:18.266989Z", - "shell.execute_reply": "2026-02-10T22:21:18.265814Z", - "shell.execute_reply.started": "2026-02-10T22:21:18.254309Z" + "iopub.execute_input": "2026-02-10T22:47:23.739068Z", + "iopub.status.busy": "2026-02-10T22:47:23.738875Z", + "iopub.status.idle": "2026-02-10T22:47:23.750876Z", + "shell.execute_reply": "2026-02-10T22:47:23.750223Z", + "shell.execute_reply.started": "2026-02-10T22:47:23.739049Z" } }, "outputs": [ @@ -388,18 +388,18 @@ "id": "0b89b688-a595-4ff3-81e3-8bba4d4ef7c8", "metadata": { "execution": { - "iopub.execute_input": "2026-02-10T22:21:18.268171Z", - "iopub.status.busy": "2026-02-10T22:21:18.267839Z", - "iopub.status.idle": "2026-02-10T22:21:18.424560Z", - "shell.execute_reply": "2026-02-10T22:21:18.423778Z", - "shell.execute_reply.started": "2026-02-10T22:21:18.268142Z" + "iopub.execute_input": "2026-02-10T22:47:23.751617Z", + "iopub.status.busy": "2026-02-10T22:47:23.751393Z", + "iopub.status.idle": "2026-02-10T22:47:23.907723Z", + "shell.execute_reply": "2026-02-10T22:47:23.907001Z", + "shell.execute_reply.started": "2026-02-10T22:47:23.751600Z" } }, "outputs": [ { "data": { "text/plain": [ - "(,)" + "(,)" ] }, "execution_count": 11, @@ -427,11 +427,11 @@ "id": "ff50fbfa-9dd4-4c01-a8eb-245c3c0706a0", "metadata": { "execution": { - "iopub.execute_input": "2026-02-10T22:21:18.425465Z", - "iopub.status.busy": "2026-02-10T22:21:18.425193Z", - "iopub.status.idle": "2026-02-10T22:21:22.215808Z", - "shell.execute_reply": "2026-02-10T22:21:22.212508Z", - "shell.execute_reply.started": "2026-02-10T22:21:18.425447Z" + "iopub.execute_input": "2026-02-10T22:47:23.908310Z", + "iopub.status.busy": "2026-02-10T22:47:23.908139Z", + "iopub.status.idle": "2026-02-10T22:47:27.861067Z", + "shell.execute_reply": "2026-02-10T22:47:27.860510Z", + "shell.execute_reply.started": "2026-02-10T22:47:23.908294Z" } }, "outputs": [], @@ -445,11 +445,11 @@ "id": "094b1d30-c610-44ca-968b-7257aacbaa91", "metadata": { "execution": { - "iopub.execute_input": "2026-02-10T22:21:22.216595Z", - "iopub.status.busy": "2026-02-10T22:21:22.216380Z", - "iopub.status.idle": "2026-02-10T22:21:22.378011Z", - "shell.execute_reply": "2026-02-10T22:21:22.377223Z", - "shell.execute_reply.started": "2026-02-10T22:21:22.216573Z" + "iopub.execute_input": "2026-02-10T22:47:27.861862Z", + "iopub.status.busy": "2026-02-10T22:47:27.861637Z", + "iopub.status.idle": "2026-02-10T22:47:28.019060Z", + "shell.execute_reply": "2026-02-10T22:47:28.018222Z", + "shell.execute_reply.started": "2026-02-10T22:47:27.861840Z" } }, "outputs": [ @@ -493,11 +493,11 @@ "id": "a4303772-cfe0-45ed-90ec-c1caad768f39", "metadata": { "execution": { - "iopub.execute_input": "2026-02-10T22:21:22.379059Z", - "iopub.status.busy": "2026-02-10T22:21:22.378813Z", - "iopub.status.idle": "2026-02-10T22:21:22.382252Z", - "shell.execute_reply": "2026-02-10T22:21:22.381343Z", - "shell.execute_reply.started": "2026-02-10T22:21:22.379033Z" + "iopub.execute_input": "2026-02-10T22:47:28.019656Z", + "iopub.status.busy": "2026-02-10T22:47:28.019472Z", + "iopub.status.idle": "2026-02-10T22:47:28.022888Z", + "shell.execute_reply": "2026-02-10T22:47:28.022022Z", + "shell.execute_reply.started": "2026-02-10T22:47:28.019640Z" } }, "outputs": [], @@ -511,11 +511,11 @@ "id": "956f31ab-ed45-432f-a788-15cf73febf14", "metadata": { "execution": { - "iopub.execute_input": "2026-02-10T22:21:22.383079Z", - "iopub.status.busy": "2026-02-10T22:21:22.382862Z", - "iopub.status.idle": "2026-02-10T22:21:22.408246Z", - "shell.execute_reply": "2026-02-10T22:21:22.407519Z", - "shell.execute_reply.started": "2026-02-10T22:21:22.383061Z" + "iopub.execute_input": "2026-02-10T22:47:28.023420Z", + "iopub.status.busy": "2026-02-10T22:47:28.023253Z", + "iopub.status.idle": "2026-02-10T22:47:28.050523Z", + "shell.execute_reply": "2026-02-10T22:47:28.050042Z", + "shell.execute_reply.started": "2026-02-10T22:47:28.023403Z" } }, "outputs": [], @@ -529,11 +529,11 @@ "id": "fd1dfb8c-fe88-4a46-b59e-70baaec550f7", "metadata": { "execution": { - "iopub.execute_input": "2026-02-10T22:21:22.408931Z", - "iopub.status.busy": "2026-02-10T22:21:22.408710Z", - "iopub.status.idle": "2026-02-10T22:21:22.573880Z", - "shell.execute_reply": "2026-02-10T22:21:22.573090Z", - "shell.execute_reply.started": "2026-02-10T22:21:22.408908Z" + "iopub.execute_input": "2026-02-10T22:47:28.051139Z", + "iopub.status.busy": "2026-02-10T22:47:28.050943Z", + "iopub.status.idle": "2026-02-10T22:47:28.231175Z", + "shell.execute_reply": "2026-02-10T22:47:28.230316Z", + "shell.execute_reply.started": "2026-02-10T22:47:28.051117Z" } }, "outputs": [ @@ -561,11 +561,11 @@ "id": "e916f176-b4b7-427a-847c-a282f85640a5", "metadata": { "execution": { - "iopub.execute_input": "2026-02-10T22:21:22.574554Z", - "iopub.status.busy": "2026-02-10T22:21:22.574328Z", - "iopub.status.idle": "2026-02-10T22:21:23.243878Z", - "shell.execute_reply": "2026-02-10T22:21:23.243085Z", - "shell.execute_reply.started": "2026-02-10T22:21:22.574536Z" + "iopub.execute_input": "2026-02-10T22:47:28.232057Z", + "iopub.status.busy": "2026-02-10T22:47:28.231819Z", + "iopub.status.idle": "2026-02-10T22:47:28.884243Z", + "shell.execute_reply": "2026-02-10T22:47:28.883633Z", + "shell.execute_reply.started": "2026-02-10T22:47:28.232034Z" } }, "outputs": [ @@ -613,11 +613,11 @@ "id": "931c7ff0-0f45-40cb-8227-c78e97823f79", "metadata": { "execution": { - "iopub.execute_input": "2026-02-10T22:21:23.244557Z", - "iopub.status.busy": "2026-02-10T22:21:23.244380Z", - "iopub.status.idle": "2026-02-10T22:21:23.247707Z", - "shell.execute_reply": "2026-02-10T22:21:23.246908Z", - "shell.execute_reply.started": "2026-02-10T22:21:23.244541Z" + "iopub.execute_input": "2026-02-10T22:47:28.884899Z", + "iopub.status.busy": "2026-02-10T22:47:28.884720Z", + "iopub.status.idle": "2026-02-10T22:47:28.888565Z", + "shell.execute_reply": "2026-02-10T22:47:28.887533Z", + "shell.execute_reply.started": "2026-02-10T22:47:28.884882Z" } }, "outputs": [], @@ -636,17 +636,19 @@ "id": "c862c062-c7e2-4d7b-8825-109fa7072bdd", "metadata": { "execution": { - "iopub.execute_input": "2026-02-10T22:21:23.248570Z", - "iopub.status.busy": "2026-02-10T22:21:23.248342Z", - "iopub.status.idle": "2026-02-10T22:21:23.263092Z", - "shell.execute_reply": "2026-02-10T22:21:23.262319Z", - "shell.execute_reply.started": "2026-02-10T22:21:23.248552Z" + "iopub.execute_input": "2026-02-10T22:47:28.889196Z", + "iopub.status.busy": "2026-02-10T22:47:28.889023Z", + "iopub.status.idle": "2026-02-10T22:47:28.896318Z", + "shell.execute_reply": "2026-02-10T22:47:28.895569Z", + "shell.execute_reply.started": "2026-02-10T22:47:28.889179Z" } }, "outputs": [], "source": [ "uncertainties = stderr * np.ones(gz.size)\n", - "data_misfit = ii.DataMisfit(gz.ravel(), uncertainties, simulation, model_slice=wires.density)" + "data_misfit = ii.DataMisfit(\n", + " gz.ravel(), uncertainties, simulation, model_slice=wires.density\n", + ")" ] }, { @@ -655,11 +657,11 @@ "id": "9042f903-4d02-4abe-9de1-2dfacfb3b3a0", "metadata": { "execution": { - "iopub.execute_input": "2026-02-10T22:21:23.263933Z", - "iopub.status.busy": "2026-02-10T22:21:23.263704Z", - "iopub.status.idle": "2026-02-10T22:21:23.274949Z", - "shell.execute_reply": "2026-02-10T22:21:23.274135Z", - "shell.execute_reply.started": "2026-02-10T22:21:23.263915Z" + "iopub.execute_input": "2026-02-10T22:47:28.897231Z", + "iopub.status.busy": "2026-02-10T22:47:28.897001Z", + "iopub.status.idle": "2026-02-10T22:47:28.909028Z", + "shell.execute_reply": "2026-02-10T22:47:28.908283Z", + "shell.execute_reply.started": "2026-02-10T22:47:28.897205Z" } }, "outputs": [], @@ -667,7 +669,9 @@ "depth_weights = depth_weighting(mesh, 0) ** 2\n", "\n", "# Let's use a tikhonov zero for now, because I haven't implemented model slices in Smallness yet\n", - "smallness = ii.Smallness(mesh=mesh, cell_weights=depth_weights, model_slice=wires.density)\n", + "smallness = ii.Smallness(\n", + " mesh=mesh, cell_weights=depth_weights, model_slice=wires.density\n", + ")\n", "\n", "flatness_x, flatness_y, flatness_z = tuple(\n", " ii.Flatness(\n", @@ -688,11 +692,11 @@ "id": "ae115d7f-6b08-4c4e-b5f3-7277c24a49e4", "metadata": { "execution": { - "iopub.execute_input": "2026-02-10T22:22:37.539647Z", - "iopub.status.busy": "2026-02-10T22:22:37.539368Z", - "iopub.status.idle": "2026-02-10T22:22:37.542739Z", - "shell.execute_reply": "2026-02-10T22:22:37.541968Z", - "shell.execute_reply.started": "2026-02-10T22:22:37.539621Z" + "iopub.execute_input": "2026-02-10T22:47:28.909795Z", + "iopub.status.busy": "2026-02-10T22:47:28.909592Z", + "iopub.status.idle": "2026-02-10T22:47:28.913097Z", + "shell.execute_reply": "2026-02-10T22:47:28.912169Z", + "shell.execute_reply.started": "2026-02-10T22:47:28.909778Z" } }, "outputs": [], @@ -714,11 +718,11 @@ "id": "dbc4da3d", "metadata": { "execution": { - "iopub.execute_input": "2026-02-10T22:22:38.248710Z", - "iopub.status.busy": "2026-02-10T22:22:38.248511Z", - "iopub.status.idle": "2026-02-10T22:22:38.252618Z", - "shell.execute_reply": "2026-02-10T22:22:38.252002Z", - "shell.execute_reply.started": "2026-02-10T22:22:38.248692Z" + "iopub.execute_input": "2026-02-10T22:47:28.913971Z", + "iopub.status.busy": "2026-02-10T22:47:28.913727Z", + "iopub.status.idle": "2026-02-10T22:47:28.921478Z", + "shell.execute_reply": "2026-02-10T22:47:28.920609Z", + "shell.execute_reply.started": "2026-02-10T22:47:28.913945Z" } }, "outputs": [ @@ -744,11 +748,11 @@ "id": "463b4e7b", "metadata": { "execution": { - "iopub.execute_input": "2026-02-10T22:22:38.568958Z", - "iopub.status.busy": "2026-02-10T22:22:38.568752Z", - "iopub.status.idle": "2026-02-10T22:22:39.326392Z", - "shell.execute_reply": "2026-02-10T22:22:39.325752Z", - "shell.execute_reply.started": "2026-02-10T22:22:38.568941Z" + "iopub.execute_input": "2026-02-10T22:47:28.922140Z", + "iopub.status.busy": "2026-02-10T22:47:28.921902Z", + "iopub.status.idle": "2026-02-10T22:47:29.708055Z", + "shell.execute_reply": "2026-02-10T22:47:29.707351Z", + "shell.execute_reply.started": "2026-02-10T22:47:28.922124Z" } }, "outputs": [ @@ -775,11 +779,11 @@ "id": "b7d8d1fc-af33-4658-bd94-a0ad75665bd3", "metadata": { "execution": { - "iopub.execute_input": "2026-02-10T22:22:39.327817Z", - "iopub.status.busy": "2026-02-10T22:22:39.327530Z", - "iopub.status.idle": "2026-02-10T22:22:39.954617Z", - "shell.execute_reply": "2026-02-10T22:22:39.953804Z", - "shell.execute_reply.started": "2026-02-10T22:22:39.327791Z" + "iopub.execute_input": "2026-02-10T22:47:29.709123Z", + "iopub.status.busy": "2026-02-10T22:47:29.708830Z", + "iopub.status.idle": "2026-02-10T22:47:30.301400Z", + "shell.execute_reply": "2026-02-10T22:47:30.300807Z", + "shell.execute_reply.started": "2026-02-10T22:47:29.709093Z" } }, "outputs": [ @@ -804,11 +808,11 @@ "id": "e2dfb4e8-1996-4f3f-8b05-781fc2d4537c", "metadata": { "execution": { - "iopub.execute_input": "2026-02-10T22:22:39.955147Z", - "iopub.status.busy": "2026-02-10T22:22:39.954973Z", - "iopub.status.idle": "2026-02-10T22:22:44.455342Z", - "shell.execute_reply": "2026-02-10T22:22:44.454122Z", - "shell.execute_reply.started": "2026-02-10T22:22:39.955131Z" + "iopub.execute_input": "2026-02-10T22:47:30.302181Z", + "iopub.status.busy": "2026-02-10T22:47:30.301998Z", + "iopub.status.idle": "2026-02-10T22:47:34.903899Z", + "shell.execute_reply": "2026-02-10T22:47:34.902994Z", + "shell.execute_reply.started": "2026-02-10T22:47:30.302162Z" } }, "outputs": [ @@ -816,7 +820,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "Elapsed time (no preconditioner): 4.49s\n" + "Elapsed time (no preconditioner): 4.60s\n" ] } ], @@ -824,7 +828,9 @@ "import time\n", "\n", "start = time.time()\n", - "inverted_model = ii.conjugate_gradient(phi, initial_model, preconditioner=preconditioner)\n", + "inverted_model = ii.conjugate_gradient(\n", + " phi, initial_model, preconditioner=preconditioner\n", + ")\n", "end = time.time()\n", "print(f\"Elapsed time (no preconditioner): {end - start:.2f}s\")" ] @@ -835,11 +841,11 @@ "id": "82c1ddc2-d886-4cd1-a42d-1c32af5d4465", "metadata": { "execution": { - "iopub.execute_input": "2026-02-10T22:22:44.457914Z", - "iopub.status.busy": "2026-02-10T22:22:44.456088Z", - "iopub.status.idle": "2026-02-10T22:22:44.465712Z", - "shell.execute_reply": "2026-02-10T22:22:44.464550Z", - "shell.execute_reply.started": "2026-02-10T22:22:44.457886Z" + "iopub.execute_input": "2026-02-10T22:47:34.904705Z", + "iopub.status.busy": "2026-02-10T22:47:34.904436Z", + "iopub.status.idle": "2026-02-10T22:47:34.912563Z", + "shell.execute_reply": "2026-02-10T22:47:34.911611Z", + "shell.execute_reply.started": "2026-02-10T22:47:34.904676Z" } }, "outputs": [ @@ -865,11 +871,11 @@ "id": "05ef6fdf-55c0-4911-9ac8-2041af49b3cd", "metadata": { "execution": { - "iopub.execute_input": "2026-02-10T22:22:44.467501Z", - "iopub.status.busy": "2026-02-10T22:22:44.466609Z", - "iopub.status.idle": "2026-02-10T22:22:44.488420Z", - "shell.execute_reply": "2026-02-10T22:22:44.487023Z", - "shell.execute_reply.started": "2026-02-10T22:22:44.467472Z" + "iopub.execute_input": "2026-02-10T22:47:34.913406Z", + "iopub.status.busy": "2026-02-10T22:47:34.913089Z", + "iopub.status.idle": "2026-02-10T22:47:34.937032Z", + "shell.execute_reply": "2026-02-10T22:47:34.935709Z", + "shell.execute_reply.started": "2026-02-10T22:47:34.913318Z" } }, "outputs": [ @@ -897,11 +903,11 @@ "id": "d20f5357-efd0-42cb-a156-90fcd6b41f0b", "metadata": { "execution": { - "iopub.execute_input": "2026-02-10T22:22:48.762255Z", - "iopub.status.busy": "2026-02-10T22:22:48.762050Z", - "iopub.status.idle": "2026-02-10T22:22:48.766388Z", - "shell.execute_reply": "2026-02-10T22:22:48.765620Z", - "shell.execute_reply.started": "2026-02-10T22:22:48.762237Z" + "iopub.execute_input": "2026-02-10T22:47:34.944173Z", + "iopub.status.busy": "2026-02-10T22:47:34.938130Z", + "iopub.status.idle": "2026-02-10T22:47:34.952209Z", + "shell.execute_reply": "2026-02-10T22:47:34.950516Z", + "shell.execute_reply.started": "2026-02-10T22:47:34.944113Z" } }, "outputs": [ @@ -928,18 +934,18 @@ "id": "70b2b5ea-d6dd-4cf3-855c-9e8fd600c7cd", "metadata": { "execution": { - "iopub.execute_input": "2026-02-10T22:22:49.101217Z", - "iopub.status.busy": "2026-02-10T22:22:49.101017Z", - "iopub.status.idle": "2026-02-10T22:22:49.255379Z", - "shell.execute_reply": "2026-02-10T22:22:49.254629Z", - "shell.execute_reply.started": "2026-02-10T22:22:49.101200Z" + "iopub.execute_input": "2026-02-10T22:47:34.954212Z", + "iopub.status.busy": "2026-02-10T22:47:34.953168Z", + "iopub.status.idle": "2026-02-10T22:47:35.127163Z", + "shell.execute_reply": "2026-02-10T22:47:35.126443Z", + "shell.execute_reply.started": "2026-02-10T22:47:34.954180Z" } }, "outputs": [ { "data": { "text/plain": [ - "(,)" + "(,)" ] }, "execution_count": 29, From b2fe79ff6285e637101a42092b2a95cca2125fac Mon Sep 17 00:00:00 2001 From: Santiago Soler Date: Tue, 10 Feb 2026 15:24:23 -0800 Subject: [PATCH 28/47] Add a HasDiagonal protocol Use it in the BlockSquareMatrix.diagonal() method to check if the block has a diagonal method. --- src/inversion_ideas/typing.py | 11 ++++++++++- src/inversion_ideas/wires.py | 6 ++++-- 2 files changed, 14 insertions(+), 3 deletions(-) diff --git a/src/inversion_ideas/typing.py b/src/inversion_ideas/typing.py index f907550..8c04fe0 100644 --- a/src/inversion_ideas/typing.py +++ b/src/inversion_ideas/typing.py @@ -2,7 +2,7 @@ Custom types used for type hints. """ -from typing import Protocol, TypeAlias +from typing import Protocol, TypeAlias, runtime_checkable import numpy as np import numpy.typing as npt @@ -35,3 +35,12 @@ def update_irls(self, model: Model) -> None: def activate_irls(self, model_previous: Model) -> None: raise NotImplementedError + + +@runtime_checkable +class HasDiagonal(Protocol): + """ + Protocol to define an object that implements the ``diagonal`` method. + """ + + def diagonal(self) -> npt.NDArray: ... diff --git a/src/inversion_ideas/wires.py b/src/inversion_ideas/wires.py index 1d811de..02be367 100644 --- a/src/inversion_ideas/wires.py +++ b/src/inversion_ideas/wires.py @@ -9,7 +9,7 @@ from scipy.sparse import dia_array, diags_array, sparray from scipy.sparse.linalg import LinearOperator -from .typing import Model +from .typing import HasDiagonal, Model class Wires: @@ -280,6 +280,8 @@ def diagonal(self): """ Diagonal of the matrix. """ - # TODO: check if the block has a diagonal method (implement a protocol for it) + if not isinstance(self.block, HasDiagonal): + # TODO: Add msg + raise TypeError() diagonal = self.block.diagonal() return self.slice_matrix.T @ diagonal From f04ff22a5d33f93e6ca160b161668c122948d1a6 Mon Sep 17 00:00:00 2001 From: Santiago Soler Date: Wed, 11 Feb 2026 14:21:23 -0800 Subject: [PATCH 29/47] Add a MultiSlice class --- src/inversion_ideas/wires.py | 98 ++++++++++++++++++++++++++++++++++++ 1 file changed, 98 insertions(+) diff --git a/src/inversion_ideas/wires.py b/src/inversion_ideas/wires.py index 02be367..0d584e8 100644 --- a/src/inversion_ideas/wires.py +++ b/src/inversion_ideas/wires.py @@ -181,6 +181,104 @@ def expand_matrix( return BlockSquareMatrix(block=matrix, slice_matrix=self.slice_matrix) +class MultiSlice: + """ + Multiple slices. + + .. important:: + + Don't instantiate this class. Use the ``Wires`` class instead. + """ + + def __init__(self, slices: dict[str, slice], wires: Wires): + self._slices = slices + self._wires = wires + + @property + def names(self) -> list[str]: + """ + Slices names. + """ + return list(self.slices.keys()) + + @property + def slices(self) -> dict[str, slice]: + return self._slices + + @property + def wires(self) -> Wires: + return self._wires + + @property + def size(self) -> int: + return sum(s.stop - s.start for s in self.slices.values()) + + @property + def full_size(self) -> int: + return self.wires.size + + @property + def slice_matrix(self) -> dia_array[np.float64]: + """ + Return a matrix that can be used to slice a model array. + """ + if not self.slices: + # Add msg and choose right error type for empty slices + raise ValueError() + + shape = (self.size, self.full_size) + s = 0 + row = 0 + for slice_ in self.slices.values(): + offset = slice_.start - row + index_start = row if offset >= 0 else row + offset + length = slice_.stop - slice_.start + diagonal = np.zeros(self.size, dtype=np.float64) + diagonal[index_start : index_start + length] = 1.0 + s += diags_array(diagonal, offsets=offset, shape=shape, dtype=np.float64) + row += length + return s + + def extract(self, model: Model): ... + + # These two could be inherited + def expand_array(self, array: npt.NDArray) -> npt.NDArray: + """ + Expand a 1D array by filling it with extra zeros. + + Parameters + ---------- + array : (n,) array + Array that will be filled. It must have the same number of elements as the + model slice. + + Returns + ------- + array : (m,) array + Array filled with zeros on elements outside of the model slice. + """ + return self.slice_matrix.T @ array + + def expand_matrix( + self, matrix: npt.NDArray | LinearOperator | sparray + ) -> "BlockSquareMatrix": + """ + Expand a square matrix into a ``BlockSquareMatrix`` filling blocks with zeros. + + Parameters + ---------- + matrix : array, sparse array or LinearOperator + Square matrix that will be expanded + + Returns + ------- + block_square_matrix : BlockSquareMatrix + LinearOperator that represents the matrix filled with zeros outside of the + block. + """ + return BlockSquareMatrix(block=matrix, slice_matrix=self.slice_matrix) + + class BlockSquareMatrix(LinearOperator): r""" Operator that represents a square matrix with a non-zero block surrounded by zeros. From ddfc4118de76fa5081f1c880d9062a676049c958 Mon Sep 17 00:00:00 2001 From: Santiago Soler Date: Wed, 11 Feb 2026 14:23:25 -0800 Subject: [PATCH 30/47] Add a base class for model slices to avoid repetition --- src/inversion_ideas/wires.py | 143 ++++++++++++++++------------------- 1 file changed, 67 insertions(+), 76 deletions(-) diff --git a/src/inversion_ideas/wires.py b/src/inversion_ideas/wires.py index 0d584e8..8967f5e 100644 --- a/src/inversion_ideas/wires.py +++ b/src/inversion_ideas/wires.py @@ -2,6 +2,7 @@ Model wiring. """ +from abc import ABC, abstractmethod from numbers import Integral import numpy as np @@ -90,7 +91,65 @@ def dict_to_array(self, model_dict: dict[str, Model]): return model -class ModelSlice: +class _BaseModelSlice(ABC): + """ + Base class for a ModelSlice. + """ + + @property + @abstractmethod + def size(self) -> int: ... + + @property + @abstractmethod + def full_size(self) -> int: ... + + @property + @abstractmethod + def wires(self) -> Wires: ... + + @property + @abstractmethod + def slice_matrix(self) -> dia_array[np.float64]: ... + + def expand_array(self, array: npt.NDArray) -> npt.NDArray: + """ + Expand a 1D array by filling it with extra zeros. + + Parameters + ---------- + array : (n,) array + Array that will be filled. It must have the same number of elements as the + model slice. + + Returns + ------- + array : (m,) array + Array filled with zeros on elements outside of the model slice. + """ + return self.slice_matrix.T @ array + + def expand_matrix( + self, matrix: npt.NDArray | LinearOperator | sparray + ) -> "BlockSquareMatrix": + """ + Expand a square matrix into a ``BlockSquareMatrix`` filling blocks with zeros. + + Parameters + ---------- + matrix : array, sparse array or LinearOperator + Square matrix that will be expanded + + Returns + ------- + block_square_matrix : BlockSquareMatrix + LinearOperator that represents the matrix filled with zeros outside of the + block. + """ + return BlockSquareMatrix(block=matrix, slice_matrix=self.slice_matrix) + + +class ModelSlice(_BaseModelSlice): """ Class used to slice a model. @@ -144,44 +203,8 @@ def extract(self, model: Model): raise ValueError() return model[self.slice] - def expand_array(self, array: npt.NDArray) -> npt.NDArray: - """ - Expand a 1D array by filling it with extra zeros. - - Parameters - ---------- - array : (n,) array - Array that will be filled. It must have the same number of elements as the - model slice. - - Returns - ------- - array : (m,) array - Array filled with zeros on elements outside of the model slice. - """ - return self.slice_matrix.T @ array - - def expand_matrix( - self, matrix: npt.NDArray | LinearOperator | sparray - ) -> "BlockSquareMatrix": - """ - Expand a square matrix into a ``BlockSquareMatrix`` filling blocks with zeros. - - Parameters - ---------- - matrix : array, sparse array or LinearOperator - Square matrix that will be expanded - Returns - ------- - block_square_matrix : BlockSquareMatrix - LinearOperator that represents the matrix filled with zeros outside of the - block. - """ - return BlockSquareMatrix(block=matrix, slice_matrix=self.slice_matrix) - - -class MultiSlice: +class MultiSlice(_BaseModelSlice): """ Multiple slices. @@ -239,44 +262,12 @@ def slice_matrix(self) -> dia_array[np.float64]: row += length return s - def extract(self, model: Model): ... - - # These two could be inherited - def expand_array(self, array: npt.NDArray) -> npt.NDArray: - """ - Expand a 1D array by filling it with extra zeros. - - Parameters - ---------- - array : (n,) array - Array that will be filled. It must have the same number of elements as the - model slice. - - Returns - ------- - array : (m,) array - Array filled with zeros on elements outside of the model slice. - """ - return self.slice_matrix.T @ array - - def expand_matrix( - self, matrix: npt.NDArray | LinearOperator | sparray - ) -> "BlockSquareMatrix": - """ - Expand a square matrix into a ``BlockSquareMatrix`` filling blocks with zeros. - - Parameters - ---------- - matrix : array, sparse array or LinearOperator - Square matrix that will be expanded - - Returns - ------- - block_square_matrix : BlockSquareMatrix - LinearOperator that represents the matrix filled with zeros outside of the - block. - """ - return BlockSquareMatrix(block=matrix, slice_matrix=self.slice_matrix) + def extract(self, model: Model): + if model.size != self.wires.size: + # TODO: add msg + raise ValueError() + parts = [model[s] for s in self.slices.values()] + return np.hstack(parts) class BlockSquareMatrix(LinearOperator): From 0f0bd003041d3c2e5015d1397d087d1a255a277e Mon Sep 17 00:00:00 2001 From: Santiago Soler Date: Wed, 11 Feb 2026 14:37:19 -0800 Subject: [PATCH 31/47] Allow to get MultiSlice from Wires --- src/inversion_ideas/wires.py | 11 +++++++++-- 1 file changed, 9 insertions(+), 2 deletions(-) diff --git a/src/inversion_ideas/wires.py b/src/inversion_ideas/wires.py index 8967f5e..6876586 100644 --- a/src/inversion_ideas/wires.py +++ b/src/inversion_ideas/wires.py @@ -4,6 +4,7 @@ from abc import ABC, abstractmethod from numbers import Integral +from typing import Sequence import numpy as np import numpy.typing as npt @@ -22,7 +23,7 @@ class Wires: """ def __init__(self, **kwargs): - self._slices = {} + self._slices: dict[str, ModelSlice] = {} current_index: int = 0 for key, value in kwargs.items(): @@ -60,7 +61,13 @@ def __getattr__(self, value: str) -> "ModelSlice": raise AttributeError() return self._slices[value] - def __getitem__(self, value: str) -> "ModelSlice": + def __getitem__(self, value: str | Sequence[str]) -> "ModelSlice | MultiSlice": + if not isinstance(value, str): + if not isinstance(value, Sequence): + # TODO: add msg + raise TypeError() + slices = {name: self._slices[name].slice for name in value} + return MultiSlice(slices=slices, wires=self) return self._slices[value] @classmethod From 053b182082a4f1d6ef130fb1f0c8be975648bd50 Mon Sep 17 00:00:00 2001 From: Santiago Soler Date: Wed, 11 Feb 2026 15:41:51 -0800 Subject: [PATCH 32/47] Fix style --- src/inversion_ideas/data_misfit.py | 4 ++-- src/inversion_ideas/utils.py | 4 ++-- src/inversion_ideas/wires.py | 2 +- 3 files changed, 5 insertions(+), 5 deletions(-) diff --git a/src/inversion_ideas/data_misfit.py b/src/inversion_ideas/data_misfit.py index f932a2f..7c3961a 100644 --- a/src/inversion_ideas/data_misfit.py +++ b/src/inversion_ideas/data_misfit.py @@ -8,9 +8,9 @@ from scipy.sparse.linalg import LinearOperator, aslinearoperator from .base import Objective -from .utils import support_model_slice -from .wires import ModelSlice from .typing import Model +from .utils import support_model_slice +from .wires import ModelSlice, SparseArray class DataMisfit(Objective): diff --git a/src/inversion_ideas/utils.py b/src/inversion_ideas/utils.py index ab4f339..475e396 100644 --- a/src/inversion_ideas/utils.py +++ b/src/inversion_ideas/utils.py @@ -9,10 +9,10 @@ import numpy as np import numpy.typing as npt -from .typing import SparseArray - from inversion_ideas.wires import ModelSlice +from .typing import SparseArray + __all__ = [ "cache_on_model", "get_logger", diff --git a/src/inversion_ideas/wires.py b/src/inversion_ideas/wires.py index 6876586..95065d9 100644 --- a/src/inversion_ideas/wires.py +++ b/src/inversion_ideas/wires.py @@ -3,8 +3,8 @@ """ from abc import ABC, abstractmethod +from collections.abc import Sequence from numbers import Integral -from typing import Sequence import numpy as np import numpy.typing as npt From d500b1c8b53f9fd2255f2fda8aba714126808006 Mon Sep 17 00:00:00 2001 From: Santiago Soler Date: Wed, 11 Feb 2026 15:47:17 -0800 Subject: [PATCH 33/47] Fix import --- src/inversion_ideas/data_misfit.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/inversion_ideas/data_misfit.py b/src/inversion_ideas/data_misfit.py index 7c3961a..0b7d7a1 100644 --- a/src/inversion_ideas/data_misfit.py +++ b/src/inversion_ideas/data_misfit.py @@ -8,9 +8,9 @@ from scipy.sparse.linalg import LinearOperator, aslinearoperator from .base import Objective -from .typing import Model +from .typing import Model, SparseArray from .utils import support_model_slice -from .wires import ModelSlice, SparseArray +from .wires import ModelSlice class DataMisfit(Objective): From b2633372d89058d526ecdb3ca8bfc8a52d52afb9 Mon Sep 17 00:00:00 2001 From: Santiago Soler Date: Wed, 11 Feb 2026 15:49:53 -0800 Subject: [PATCH 34/47] Update type hints --- src/inversion_ideas/data_misfit.py | 4 ++-- src/inversion_ideas/recipes.py | 5 ++--- src/inversion_ideas/regularization/_mesh_based.py | 6 +++--- src/inversion_ideas/utils.py | 4 ++-- 4 files changed, 9 insertions(+), 10 deletions(-) diff --git a/src/inversion_ideas/data_misfit.py b/src/inversion_ideas/data_misfit.py index 0b7d7a1..42488ae 100644 --- a/src/inversion_ideas/data_misfit.py +++ b/src/inversion_ideas/data_misfit.py @@ -10,7 +10,7 @@ from .base import Objective from .typing import Model, SparseArray from .utils import support_model_slice -from .wires import ModelSlice +from .wires import ModelSlice, MultiSlice class DataMisfit(Objective): @@ -80,7 +80,7 @@ def __init__( uncertainty: npt.NDArray[np.float64], simulation, *, - model_slice: ModelSlice | None = None, + model_slice: ModelSlice | MultiSlice | None = None, build_hessian=False, ): # TODO: Check that the data and uncertainties have the size as ndata in the diff --git a/src/inversion_ideas/recipes.py b/src/inversion_ideas/recipes.py index 1bcedc5..7d7ef31 100644 --- a/src/inversion_ideas/recipes.py +++ b/src/inversion_ideas/recipes.py @@ -7,8 +7,6 @@ import numpy as np import numpy.typing as npt -from inversion_ideas.wires import ModelSlice - from .base import Combo, Minimizer, Objective from .conditions import ChiTarget, ObjectiveChanged from .data_misfit import DataMisfit @@ -18,6 +16,7 @@ from .preconditioners import JacobiPreconditioner from .regularization import Flatness, Smallness from .typing import Model, Preconditioner +from .wires import ModelSlice, MultiSlice def create_l2_inversion( @@ -275,7 +274,7 @@ def create_tikhonov_regularization( alpha_y: float | None = None, alpha_z: float | None = None, reference_model_in_flatness: bool = False, - model_slice: ModelSlice | None = None, + model_slice: ModelSlice | MultiSlice | None = None, ) -> Combo: """ Create a linear combination of Tikhonov (L2) regularization terms. diff --git a/src/inversion_ideas/regularization/_mesh_based.py b/src/inversion_ideas/regularization/_mesh_based.py index 5239010..9a389f2 100644 --- a/src/inversion_ideas/regularization/_mesh_based.py +++ b/src/inversion_ideas/regularization/_mesh_based.py @@ -12,7 +12,7 @@ from ..base import Objective from ..typing import Model from ..utils import support_model_slice -from ..wires import ModelSlice +from ..wires import ModelSlice, MultiSlice class _MeshBasedRegularization(Objective): @@ -147,7 +147,7 @@ def __init__( active_cells: npt.NDArray[np.bool] | None = None, cell_weights: npt.NDArray | dict[str, npt.NDArray] | None = None, reference_model: Model | None = None, - model_slice: ModelSlice | None = None, + model_slice: ModelSlice | MultiSlice | None = None, ): self.mesh = mesh self.active_cells = ( @@ -354,7 +354,7 @@ def __init__( active_cells: npt.NDArray[np.bool] | None = None, cell_weights: npt.NDArray | dict[str, npt.NDArray] | None = None, reference_model: Model | None = None, - model_slice: ModelSlice | None = None, + model_slice: ModelSlice | MultiSlice | None = None, ): self.mesh = mesh self.direction = direction diff --git a/src/inversion_ideas/utils.py b/src/inversion_ideas/utils.py index 475e396..e7e6813 100644 --- a/src/inversion_ideas/utils.py +++ b/src/inversion_ideas/utils.py @@ -9,7 +9,7 @@ import numpy as np import numpy.typing as npt -from inversion_ideas.wires import ModelSlice +from inversion_ideas.wires import ModelSlice, MultiSlice from .typing import SparseArray @@ -191,7 +191,7 @@ def wrapper(self, model, *args, **kwargs): if self.model_slice is None: return func(self, model, *args, **kwargs) - model_slice: ModelSlice = self.model_slice + model_slice: ModelSlice | MultiSlice = self.model_slice model_reduced = model_slice.extract(model) result = func(self, model_reduced, *args, **kwargs) From e8ffcf62902455573ecc7f777d7907a229c1f73a Mon Sep 17 00:00:00 2001 From: Santiago Soler Date: Wed, 11 Feb 2026 16:55:39 -0800 Subject: [PATCH 35/47] Use SparseArray type alias in wires.py --- src/inversion_ideas/wires.py | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/src/inversion_ideas/wires.py b/src/inversion_ideas/wires.py index 95065d9..e7644df 100644 --- a/src/inversion_ideas/wires.py +++ b/src/inversion_ideas/wires.py @@ -8,10 +8,10 @@ import numpy as np import numpy.typing as npt -from scipy.sparse import dia_array, diags_array, sparray +from scipy.sparse import dia_array, diags_array from scipy.sparse.linalg import LinearOperator -from .typing import HasDiagonal, Model +from .typing import HasDiagonal, Model, SparseArray class Wires: @@ -137,7 +137,7 @@ def expand_array(self, array: npt.NDArray) -> npt.NDArray: return self.slice_matrix.T @ array def expand_matrix( - self, matrix: npt.NDArray | LinearOperator | sparray + self, matrix: npt.NDArray | LinearOperator | SparseArray ) -> "BlockSquareMatrix": """ Expand a square matrix into a ``BlockSquareMatrix`` filling blocks with zeros. @@ -317,7 +317,7 @@ class BlockSquareMatrix(LinearOperator): def __init__( self, - block: npt.NDArray | LinearOperator | sparray, + block: npt.NDArray | LinearOperator | SparseArray, slice_matrix: dia_array, ): # TODO: From 4b67f24b0bfd51764cfcce57ad0309a1504ec601 Mon Sep 17 00:00:00 2001 From: Santiago Soler Date: Wed, 11 Feb 2026 17:01:03 -0800 Subject: [PATCH 36/47] Remove TODO comment --- src/inversion_ideas/wires.py | 4 ---- 1 file changed, 4 deletions(-) diff --git a/src/inversion_ideas/wires.py b/src/inversion_ideas/wires.py index e7644df..afd5043 100644 --- a/src/inversion_ideas/wires.py +++ b/src/inversion_ideas/wires.py @@ -320,10 +320,6 @@ def __init__( block: npt.NDArray | LinearOperator | SparseArray, slice_matrix: dia_array, ): - # TODO: - # - [ ] raise error if the block plus the offset doesn't fit in the shape - # - [x] raise error if the block is not square - # - [x] raise error if the shape is not square if block.shape[0] != block.shape[1]: msg = ( f"Invalid block matrix '{block}' with shape '{block.shape}'. " From fd3bdedc35f9b70357c02fdc86b4e31d2f8997e5 Mon Sep 17 00:00:00 2001 From: Santiago Soler Date: Wed, 11 Feb 2026 17:02:37 -0800 Subject: [PATCH 37/47] Add more TODO comments --- src/inversion_ideas/wires.py | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/src/inversion_ideas/wires.py b/src/inversion_ideas/wires.py index afd5043..d3b62a8 100644 --- a/src/inversion_ideas/wires.py +++ b/src/inversion_ideas/wires.py @@ -166,6 +166,8 @@ class ModelSlice(_BaseModelSlice): """ def __init__(self, name: str, slice: slice, wires: Wires): + # TODO: Check that the slice has slice.start < slice.stop, no negative numbers, + # no None as start/stop, and step == 1. if not isinstance(name, str): # TODO: Add msg raise TypeError() @@ -221,6 +223,9 @@ class MultiSlice(_BaseModelSlice): """ def __init__(self, slices: dict[str, slice], wires: Wires): + # TODO: Check that the slices have slice.start < slice.stop, no negative + # numbers, no None as start/stop, and step == 1. + # TODO: check that keys in slices dict are all strings self._slices = slices self._wires = wires From ac847de5fb997f3957d9d6747a66e456aa884b28 Mon Sep 17 00:00:00 2001 From: Santiago Soler Date: Thu, 12 Feb 2026 13:50:44 -0800 Subject: [PATCH 38/47] Fix comment in regularizations --- src/inversion_ideas/regularization/_mesh_based.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/inversion_ideas/regularization/_mesh_based.py b/src/inversion_ideas/regularization/_mesh_based.py index 9a389f2..168616c 100644 --- a/src/inversion_ideas/regularization/_mesh_based.py +++ b/src/inversion_ideas/regularization/_mesh_based.py @@ -155,7 +155,7 @@ def __init__( if active_cells is not None else np.ones(self.mesh.n_cells, dtype=bool) ) - # assign model_slice after active_cells so n_params is correct during __init__ + # assign model_slice after active_cells so n_active is correct during __init__ self.model_slice = model_slice # Assign the cell weights through the setter @@ -363,7 +363,7 @@ def __init__( if active_cells is not None else np.ones(self.mesh.n_cells, dtype=bool) ) - # assign model_slice after active_cells so n_params is correct during __init__ + # assign model_slice after active_cells so n_active is correct during __init__ self.model_slice = model_slice # Assign the cell weights through the setter From c5c002671212ff76d1a335c2d8a7c6c48c9025c9 Mon Sep 17 00:00:00 2001 From: Santiago Soler Date: Tue, 14 Apr 2026 11:57:29 -0700 Subject: [PATCH 39/47] Move `BlockSquareMatrix` class to `operators` --- src/inversion_ideas/operators.py | 105 ++++++++++++++++++++++++++++++- src/inversion_ideas/wires.py | 105 +------------------------------ 2 files changed, 106 insertions(+), 104 deletions(-) diff --git a/src/inversion_ideas/operators.py b/src/inversion_ideas/operators.py index 04cae29..41e3c98 100644 --- a/src/inversion_ideas/operators.py +++ b/src/inversion_ideas/operators.py @@ -4,9 +4,10 @@ import numpy as np import numpy.typing as npt +from scipy.sparse import dia_array from scipy.sparse.linalg import LinearOperator -from inversion_ideas.typing import HasDiagonal, SparseArray +from .typing import HasDiagonal, SparseArray def get_diagonal(operator: npt.NDArray | SparseArray | LinearOperator): @@ -101,3 +102,105 @@ def _get_standard_basis(ndim: int, dtype=np.float64): vector = np.zeros(ndim, dtype=dtype) vector[i] = 1 yield vector + + +class BlockSquareMatrix(LinearOperator): + r""" + Operator that represents a square matrix with a non-zero block surrounded by zeros. + + Use this class to represent hessian matrices that are built from smaller matrices + that operate only on a subset of the entire model. Only a block of that hessian will + be non-zero (the one related to the relevant model elements for that objective + function), while the rest of the matrix will be filled of zeros. + + Parameters + ---------- + block : array, sparse array or LinearOperator + Square block matrix. + slice_matrix : dia_array + Diagonal array to represent the slicing matrix. + + Notes + ----- + This ``LinearOperator`` represents square matrices like: + + .. math:: + + \mathbf{H} = \begin{bmatrix} + 0 & 0 & 0\\ + 0 & \mathbf{B} & 0\\ + 0 & 0 & 0 + \end{bmatrix} + + where :math:`\mathbf{B}` is a non-zero square block matrix that sits in the diagonal + of :math:`\mathbf{H}`. The matrix :math:`\mathbf{H}` can be built as: + + .. math:: + + \mathbf{H} = \mathbf{s}^T \mathbf{B} \mathbf{s} + + where :math:`\mathbf{s}` is the *slicing matrix*. + """ + + def __init__( + self, + block: npt.NDArray | LinearOperator | SparseArray, + slice_matrix: dia_array, + ): + if block.shape[0] != block.shape[1]: + msg = ( + f"Invalid block matrix '{block}' with shape '{block.shape}'. " + "It must be a square matrix." + ) + raise ValueError(msg) + + if slice_matrix.shape[0] != block.shape[1]: + msg = ( + f"Invalid block '{block}' and slice_matrix '{slice_matrix}' with " + f"shapes '{block.shape}' and {slice_matrix.shape}." + ) + raise ValueError(msg) + + if slice_matrix.shape[1] <= block.shape[1]: + # TODO: improve msg + msg = "block is larger than slice matrix" + raise ValueError(msg) + + _, full_size = slice_matrix.shape + shape = (full_size, full_size) + super().__init__(shape=shape, dtype=block.dtype) + + self._block = block + self._slice_matrix = slice_matrix + + @property + def block(self): + return self._block + + @property + def slice_matrix(self) -> dia_array: + return self._slice_matrix + + def _matvec(self, x): + """ + Dot product between the matrix and a vector. + """ + result = self.slice_matrix.T @ (self.block @ (self.slice_matrix @ x)) + return result + + def _rmatvec(self, x): + """ + Dot product between the transposed matrix and a vector. + """ + result = self.slice_matrix @ (self.block.T @ (self.slice_matrix.T @ x)) + return result + + def diagonal(self): + """ + Diagonal of the matrix. + """ + if not isinstance(self.block, HasDiagonal): + # TODO: Add msg + raise TypeError() + diagonal = self.block.diagonal() + return self.slice_matrix.T @ diagonal diff --git a/src/inversion_ideas/wires.py b/src/inversion_ideas/wires.py index d3b62a8..7ff6f00 100644 --- a/src/inversion_ideas/wires.py +++ b/src/inversion_ideas/wires.py @@ -11,7 +11,8 @@ from scipy.sparse import dia_array, diags_array from scipy.sparse.linalg import LinearOperator -from .typing import HasDiagonal, Model, SparseArray +from .operators import BlockSquareMatrix +from .typing import Model, SparseArray class Wires: @@ -280,105 +281,3 @@ def extract(self, model: Model): raise ValueError() parts = [model[s] for s in self.slices.values()] return np.hstack(parts) - - -class BlockSquareMatrix(LinearOperator): - r""" - Operator that represents a square matrix with a non-zero block surrounded by zeros. - - Use this class to represent hessian matrices that are built from smaller matrices - that operate only on a subset of the entire model. Only a block of that hessian will - be non-zero (the one related to the relevant model elements for that objective - function), while the rest of the matrix will be filled of zeros. - - Parameters - ---------- - block : array, sparse array or LinearOperator - Square block matrix. - slice_matrix : dia_array - Diagonal array to represent the slicing matrix. - - Notes - ----- - This ``LinearOperator`` represents square matrices like: - - .. math:: - - \mathbf{H} = \begin{bmatrix} - 0 & 0 & 0\\ - 0 & \mathbf{B} & 0\\ - 0 & 0 & 0 - \end{bmatrix} - - where :math:`\mathbf{B}` is a non-zero square block matrix that sits in the diagonal - of :math:`\mathbf{H}`. The matrix :math:`\mathbf{H}` can be built as: - - .. math:: - - \mathbf{H} = \mathbf{s}^T \mathbf{B} \mathbf{s} - - where :math:`\mathbf{s}` is the *slicing matrix*. - """ - - def __init__( - self, - block: npt.NDArray | LinearOperator | SparseArray, - slice_matrix: dia_array, - ): - if block.shape[0] != block.shape[1]: - msg = ( - f"Invalid block matrix '{block}' with shape '{block.shape}'. " - "It must be a square matrix." - ) - raise ValueError(msg) - - if slice_matrix.shape[0] != block.shape[1]: - msg = ( - f"Invalid block '{block}' and slice_matrix '{slice_matrix}' with " - f"shapes '{block.shape}' and {slice_matrix.shape}." - ) - raise ValueError(msg) - - if slice_matrix.shape[1] <= block.shape[1]: - # TODO: improve msg - msg = "block is larger than slice matrix" - raise ValueError(msg) - - _, full_size = slice_matrix.shape - shape = (full_size, full_size) - super().__init__(shape=shape, dtype=block.dtype) - - self._block = block - self._slice_matrix = slice_matrix - - @property - def block(self): - return self._block - - @property - def slice_matrix(self) -> dia_array: - return self._slice_matrix - - def _matvec(self, x): - """ - Dot product between the matrix and a vector. - """ - result = self.slice_matrix.T @ (self.block @ (self.slice_matrix @ x)) - return result - - def _rmatvec(self, x): - """ - Dot product between the transposed matrix and a vector. - """ - result = self.slice_matrix @ (self.block.T @ (self.slice_matrix.T @ x)) - return result - - def diagonal(self): - """ - Diagonal of the matrix. - """ - if not isinstance(self.block, HasDiagonal): - # TODO: Add msg - raise TypeError() - diagonal = self.block.diagonal() - return self.slice_matrix.T @ diagonal From 15304781f7efa88aa9c4dd034e43bbfdf7b98187 Mon Sep 17 00:00:00 2001 From: Santiago Soler Date: Tue, 14 Apr 2026 12:13:07 -0700 Subject: [PATCH 40/47] Instantiate variable as empty diagonal array --- src/inversion_ideas/wires.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/inversion_ideas/wires.py b/src/inversion_ideas/wires.py index 7ff6f00..701221c 100644 --- a/src/inversion_ideas/wires.py +++ b/src/inversion_ideas/wires.py @@ -263,7 +263,7 @@ def slice_matrix(self) -> dia_array[np.float64]: raise ValueError() shape = (self.size, self.full_size) - s = 0 + s = dia_array(shape) row = 0 for slice_ in self.slices.values(): offset = slice_.start - row From 539b6db8be775331f3b356644e726a211ebb6825 Mon Sep 17 00:00:00 2001 From: Santiago Soler Date: Tue, 14 Apr 2026 12:43:30 -0700 Subject: [PATCH 41/47] Extend docs for `Wires` --- src/inversion_ideas/wires.py | 130 ++++++++++++++++++++++++++++++++++- 1 file changed, 129 insertions(+), 1 deletion(-) diff --git a/src/inversion_ideas/wires.py b/src/inversion_ideas/wires.py index 701221c..43d1545 100644 --- a/src/inversion_ideas/wires.py +++ b/src/inversion_ideas/wires.py @@ -21,6 +21,103 @@ class Wires: The ``Wires`` have capabilities for handling models with multiple physical properties. + + Parameters + ---------- + kwargs : dict + Keyword arguments. Each key represents the label of a portion of the model, and + its value should be an integer with the number of elements of that portion of + the model. + + Examples + -------- + Define a :class:`~inversion_ideas.Wires` object with two physical properties + (density and susceptibility), that hold different amount of model values for each. + + >>> import numpy as np + >>> wires = Wires(density=3, susceptibility=4) + >>> wires.size + 7 + >>> wires.keys() + dict_keys(['density', 'susceptibility']) + + Slice a model using the wires + ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + + Define a model with 3 values for density and 4 for susceptibility: + + >>> model = np.array([0.1, 0.2, -0.1, 1e-3, 1e-2, 1e-1, 0.3]) + + Slice the model to get the density values: + + >>> wires.density.extract(model) + array([ 0.1, 0.2, -0.1]) + + Slice the model to get the susceptibility values: + + >>> wires.susceptibility.extract(model) + array([0.001, 0.01 , 0.1 , 0.3 ]) + + Convert a model to a *model dictionary* + ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + + >>> wires.array_to_dict(model) + {'density': array([ 0.1, 0.2, -0.1]), 'susceptibility': array([0.001, 0.01 , 0.1 , 0.3 ])} + + + Define a :class:`~inversion_ideas.Wires` object from a model dictionary + ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + + >>> model_dict = { + ... "conductivity": np.array([1e-4, 1e-2, 1e-1]), + ... "density": np.array([-0.3, 0.15, 0.01]), + ... } + >>> wires = Wires.from_dict(model_dict) + >>> wires.keys() + dict_keys(['conductivity', 'density']) + + We can use this ``Wires`` object to convert the model dictionary into an array: + + >>> model = wires.dict_to_array(model_dict) + >>> model + array([ 1.0e-04, 1.0e-02, 1.0e-01, -3.0e-01, 1.5e-01, 1.0e-02]) + + Defining multiple model slices + ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + + Let's say we have a model for the parameters of a sphere: + + >>> model_sphere = { + ... "radius": np.array([10.0]), + ... "center": np.array([0.0, 0.0, -15.0]), + ... "density": np.array([0.2]), + ... "susceptibility": np.array([1e-2]), + ... "conductivity": np.array([1e-3]), + ... } + + We can create a ``Wires`` object from it: + + >>> wires = Wires.from_dict(model_sphere) + + We can access each individual ``ModelSlice`` as an attribute: + + >>> wires.center # doctest: +SKIP + + Or by indexing it: + + >>> wires["center"] # doctest: +SKIP + + And we can use these to extract pieces of the model array: + + >>> model = wires.dict_to_array(model_sphere) + >>> wires["center"].extract(model) + array([ 0., 0., -15.]) + + We can also extract multiple slices: + + >>> wires["radius", "center", "density"].extract(model) + array([ 10. , 0. , 0. , -15. , 0.2]) + """ def __init__(self, **kwargs): @@ -72,9 +169,18 @@ def __getitem__(self, value: str | Sequence[str]) -> "ModelSlice | MultiSlice": return self._slices[value] @classmethod - def create_from(cls, model_dict: dict[str, Model]): + def from_dict(cls, model_dict: dict[str, Model]): """ Create a ``Wires`` object from a model dictionary. + + Parameters + ---------- + model_dict : dict + Dictionary with string labels and 1d arrays as values. + + Returns + ------- + Wires """ kwargs = {key: array.size for key, array in model_dict.items()} return cls(**kwargs) @@ -82,6 +188,18 @@ def create_from(cls, model_dict: dict[str, Model]): def array_to_dict(self, model: Model): """ Transform a model array into a dictionary. + + Parameters + ---------- + model : (n_params) array + Array with model values. + + Returns + ------- + dict + Dictionary with string labels and 1d arrays as values. + Each pair of key-value in the dictionary represents a portion of the model + array. """ if model.size != self.size: # TODO: add msg @@ -92,6 +210,16 @@ def array_to_dict(self, model: Model): def dict_to_array(self, model_dict: dict[str, Model]): """ Ravel a model dictionary into a single 1D array. + + Parameters + ---------- + model_dict : dict + Dictionary with string labels and 1d arrays as values. + + Returns + ------- + array + 1D array with model values. """ # TODO: we should run sanity checks to ensure that the model_dict is compatible # with this wiring. From 428d732c7a02734821f63210bf2977ae5ed8a349 Mon Sep 17 00:00:00 2001 From: Santiago Soler Date: Tue, 14 Apr 2026 15:59:36 -0700 Subject: [PATCH 42/47] Decorate `hessian_approx` and `hessian_diagonal` Decorate `hessian_approx` and `hessian_diagonal` methods in `Smallness` and `Flatness` --- .../regularization/_mesh_based.py | 22 ++++++++++++++++++- 1 file changed, 21 insertions(+), 1 deletion(-) diff --git a/src/inversion_ideas/regularization/_mesh_based.py b/src/inversion_ideas/regularization/_mesh_based.py index 886a194..eab553a 100644 --- a/src/inversion_ideas/regularization/_mesh_based.py +++ b/src/inversion_ideas/regularization/_mesh_based.py @@ -17,7 +17,7 @@ from .._utils import prod_arrays from ..base import Objective -from ..typing import Model +from ..typing import Model, SparseArray from ..utils import support_model_slice from ..wires import ModelSlice, MultiSlice @@ -245,6 +245,16 @@ def hessian(self, model: Model): # noqa: ARG002 ) return hessian + @support_model_slice + def hessian_approx(self, model: Model) -> npt.NDArray[np.float64] | SparseArray: + # Override parent method to decorate it + return super().hessian_approx(model) + + @support_model_slice + def hessian_diagonal(self, model: Model) -> npt.NDArray[np.float64]: + # Override parent method to decorate it + return super().hessian_diagonal(model) + @property def weights_matrix(self) -> dia_array[np.float64]: """ @@ -451,6 +461,16 @@ def hessian(self, model: Model): # noqa: ARG002 ) return hessian + @support_model_slice + def hessian_approx(self, model: Model) -> npt.NDArray[np.float64] | SparseArray: + # Override parent method to decorate it + return super().hessian_approx(model) + + @support_model_slice + def hessian_diagonal(self, model: Model) -> npt.NDArray[np.float64]: + # Override parent method to decorate it + return super().hessian_diagonal(model) + @property def weights_matrix(self) -> dia_array[np.float64]: """ From de7e134d346f9b524a64b6d5f4d9233b23c9a484 Mon Sep 17 00:00:00 2001 From: Santiago Soler Date: Tue, 14 Apr 2026 16:20:05 -0700 Subject: [PATCH 43/47] Revert "Decorate `hessian_approx` and `hessian_diagonal`" This reverts commit 428d732c7a02734821f63210bf2977ae5ed8a349. --- .../regularization/_mesh_based.py | 22 +------------------ 1 file changed, 1 insertion(+), 21 deletions(-) diff --git a/src/inversion_ideas/regularization/_mesh_based.py b/src/inversion_ideas/regularization/_mesh_based.py index eab553a..886a194 100644 --- a/src/inversion_ideas/regularization/_mesh_based.py +++ b/src/inversion_ideas/regularization/_mesh_based.py @@ -17,7 +17,7 @@ from .._utils import prod_arrays from ..base import Objective -from ..typing import Model, SparseArray +from ..typing import Model from ..utils import support_model_slice from ..wires import ModelSlice, MultiSlice @@ -245,16 +245,6 @@ def hessian(self, model: Model): # noqa: ARG002 ) return hessian - @support_model_slice - def hessian_approx(self, model: Model) -> npt.NDArray[np.float64] | SparseArray: - # Override parent method to decorate it - return super().hessian_approx(model) - - @support_model_slice - def hessian_diagonal(self, model: Model) -> npt.NDArray[np.float64]: - # Override parent method to decorate it - return super().hessian_diagonal(model) - @property def weights_matrix(self) -> dia_array[np.float64]: """ @@ -461,16 +451,6 @@ def hessian(self, model: Model): # noqa: ARG002 ) return hessian - @support_model_slice - def hessian_approx(self, model: Model) -> npt.NDArray[np.float64] | SparseArray: - # Override parent method to decorate it - return super().hessian_approx(model) - - @support_model_slice - def hessian_diagonal(self, model: Model) -> npt.NDArray[np.float64]: - # Override parent method to decorate it - return super().hessian_diagonal(model) - @property def weights_matrix(self) -> dia_array[np.float64]: """ From ef3cdce5c30501a5b2b651612e39b98473cf1809 Mon Sep 17 00:00:00 2001 From: Santiago Soler Date: Tue, 14 Apr 2026 16:26:10 -0700 Subject: [PATCH 44/47] Remove decorators from DataMisfit `hessian_approx` and `hessian_diagonal` They call other methods that already implement the reduction of the model. --- src/inversion_ideas/data_misfit.py | 10 ++++++++-- 1 file changed, 8 insertions(+), 2 deletions(-) diff --git a/src/inversion_ideas/data_misfit.py b/src/inversion_ideas/data_misfit.py index c016850..aaf98ab 100644 --- a/src/inversion_ideas/data_misfit.py +++ b/src/inversion_ideas/data_misfit.py @@ -152,7 +152,6 @@ def hessian( weights_matrix = aslinearoperator(self.weights_matrix) return 2 * jac.T @ weights_matrix.T @ weights_matrix @ jac - @support_model_slice def hessian_approx(self, model: Model) -> npt.NDArray[np.float64] | SparseArray: """ Approximated version of the Hessian. @@ -190,7 +189,6 @@ def hessian_approx(self, model: Model) -> npt.NDArray[np.float64] | SparseArray: return self.hessian(model) # type: ignore[return-value] return diags_array(self.hessian_diagonal(model)) - @support_model_slice def hessian_diagonal(self, model: Model) -> npt.NDArray[np.float64]: """ Get the main diagonal of the Hessian. @@ -216,6 +214,10 @@ def hessian_diagonal(self, model: Model) -> npt.NDArray[np.float64]: if self.build_hessian: return self.hessian(model).diagonal() + # Extract model slice (if model_slice is not None) + if self.model_slice is not None: + model = self.model_slice.extract(model) + jac = self.simulation.jacobian(model) if isinstance(jac, LinearOperator): if not self.estimate_hessian_diagonal: @@ -246,6 +248,10 @@ def hessian_diagonal(self, model: Model) -> npt.NDArray[np.float64]: diagonal = get_diagonal(hessian) else: diagonal = 2 * np.einsum("i,ij,ij->j", self.weights, jac, jac) + + # Extend diagonal of the Hessian if model_slice is not None + if self.model_slice is not None: + diagonal = self.model_slice.expand_array(diagonal) return diagonal @property From 7953d5b9ed5381479ddd028adca3d4423fb64769 Mon Sep 17 00:00:00 2001 From: Santiago Soler Date: Tue, 14 Apr 2026 16:37:14 -0700 Subject: [PATCH 45/47] Don't crop model or modify output if model is already reduced Edit the decorator so it doesn't reduce the model nor expand the output of the method if the model is already reduced. --- src/inversion_ideas/data_misfit.py | 10 ++-------- src/inversion_ideas/utils.py | 20 ++++++++++++++++++-- 2 files changed, 20 insertions(+), 10 deletions(-) diff --git a/src/inversion_ideas/data_misfit.py b/src/inversion_ideas/data_misfit.py index aaf98ab..c016850 100644 --- a/src/inversion_ideas/data_misfit.py +++ b/src/inversion_ideas/data_misfit.py @@ -152,6 +152,7 @@ def hessian( weights_matrix = aslinearoperator(self.weights_matrix) return 2 * jac.T @ weights_matrix.T @ weights_matrix @ jac + @support_model_slice def hessian_approx(self, model: Model) -> npt.NDArray[np.float64] | SparseArray: """ Approximated version of the Hessian. @@ -189,6 +190,7 @@ def hessian_approx(self, model: Model) -> npt.NDArray[np.float64] | SparseArray: return self.hessian(model) # type: ignore[return-value] return diags_array(self.hessian_diagonal(model)) + @support_model_slice def hessian_diagonal(self, model: Model) -> npt.NDArray[np.float64]: """ Get the main diagonal of the Hessian. @@ -214,10 +216,6 @@ def hessian_diagonal(self, model: Model) -> npt.NDArray[np.float64]: if self.build_hessian: return self.hessian(model).diagonal() - # Extract model slice (if model_slice is not None) - if self.model_slice is not None: - model = self.model_slice.extract(model) - jac = self.simulation.jacobian(model) if isinstance(jac, LinearOperator): if not self.estimate_hessian_diagonal: @@ -248,10 +246,6 @@ def hessian_diagonal(self, model: Model) -> npt.NDArray[np.float64]: diagonal = get_diagonal(hessian) else: diagonal = 2 * np.einsum("i,ij,ij->j", self.weights, jac, jac) - - # Extend diagonal of the Hessian if model_slice is not None - if self.model_slice is not None: - diagonal = self.model_slice.expand_array(diagonal) return diagonal @property diff --git a/src/inversion_ideas/utils.py b/src/inversion_ideas/utils.py index 37b4f23..25a209b 100644 --- a/src/inversion_ideas/utils.py +++ b/src/inversion_ideas/utils.py @@ -244,13 +244,29 @@ def wrapper(self, model, *args, **kwargs): # TODO: add msg raise AttributeError() - if self.model_slice is None: + # Get model slice + model_slice: ModelSlice | MultiSlice = self.model_slice + + # Don't modify the model or the output if the object has no model_slice + if model_slice is None: return func(self, model, *args, **kwargs) - model_slice: ModelSlice | MultiSlice = self.model_slice + # Don't modify the model or the output if the model is already the reduced one + if model.size != model_slice.full_size: + if model.size != model_slice.size: + msg = ( + f"Invalid model of size '{model.size}'. " + f"It should be the full model (size of {model_slice.full_size}) " + f"or the reduced model (size of {model_slice.size})." + ) + raise ValueError(msg) + return func(self, model, *args, **kwargs) + + # Reduce the model and compute the output of the function with it model_reduced = model_slice.extract(model) result = func(self, model_reduced, *args, **kwargs) + # Extend the outputs, depending on type if isinstance(result, float): return result From 0bf994cc9b66e546b4f08170d79d7189888a7f6b Mon Sep 17 00:00:00 2001 From: Santiago Soler Date: Tue, 14 Apr 2026 17:18:29 -0700 Subject: [PATCH 46/47] Improve decorator Add optional arguments to enable or disable reduction of the model and expansion of the return. Update some methods in `DataMisfit` to make use of the new features. For example, the `residual` method now is configured to reduce the model, but not expand its output. Restore decorator to `hessian_approx` and `hessian_diagonal` methods in the `DataMisfit`. --- src/inversion_ideas/data_misfit.py | 5 +- src/inversion_ideas/utils.py | 122 ++++++++++++++++++----------- 2 files changed, 77 insertions(+), 50 deletions(-) diff --git a/src/inversion_ideas/data_misfit.py b/src/inversion_ideas/data_misfit.py index c016850..fc7ec27 100644 --- a/src/inversion_ideas/data_misfit.py +++ b/src/inversion_ideas/data_misfit.py @@ -114,7 +114,7 @@ def __init__( @support_model_slice def __call__(self, model: Model) -> float: - residual = self.simulation(model) - self.data + residual = self.residual(model) weights_matrix = self.weights_matrix return residual.T @ weights_matrix.T @ weights_matrix @ residual @@ -264,6 +264,7 @@ def n_data(self): """ return self.data.size + @support_model_slice(expand_return=False) def residual(self, model: Model): r""" Residual vector. @@ -289,8 +290,6 @@ def residual(self, model: Model): where :math:`\mathbf{d}` is the vector with observed data, :math:`\mathcal{F}` is the forward model, and :math:`\mathbf{m}` is the model vector. """ - if self.model_slice is not None: - model = self.model_slice.extract(model) return self.simulation(model) - self.data @property diff --git a/src/inversion_ideas/utils.py b/src/inversion_ideas/utils.py index 25a209b..cc45701 100644 --- a/src/inversion_ideas/utils.py +++ b/src/inversion_ideas/utils.py @@ -5,6 +5,7 @@ import functools import hashlib import logging +import warnings import numpy as np import numpy.typing as npt @@ -218,14 +219,14 @@ def get_sensitivity_weights( return sensitivty_weights -def support_model_slice(func): +def support_model_slice(func_=None, *, extract_model=True, expand_return=True): """ Apply a ``model_slice`` to the input and output of a method. This decorator will take the full model passed to the decorated method, extract only - the relevant slice for the instance based on its ``model_slice``, and then extend - the result if it's a 1D array or a 2D matrix, filling non-relevant elements with - zeros. + the relevant slice for the instance based on its ``model_slice`` (if needed), and + then extend the result if it's a 1D array or a 2D square matrix, filling + non-relevant elements with zeros. .. important:: @@ -236,55 +237,82 @@ def support_model_slice(func): The instance needs to have a ``model_slice`` attribute. If it's None, then the method will run without any modification. + + Parameters + ---------- + extract_model : bool, optional + If True, the ``model`` argument will be reduced using the ``model_slice`` + attribute of the object before being passed to the decorated function. + If False, the ``model`` argument will be passed as is to the decorated function. + expand_return : bool, optional + If True, 1D arrays and 2D square matrices returned by the decorated function + will be expanded to match the size of the full ``model``. + If False, the original output of the decorated function will be returned. """ + if not extract_model and not expand_return: + # TODO: improve message. Check stacklevel. + msg = "Don't decorate the function" + warnings.warn(msg, stacklevel=2) - @functools.wraps(func) - def wrapper(self, model, *args, **kwargs): - if not hasattr(self, "model_slice"): - # TODO: add msg - raise AttributeError() - - # Get model slice - model_slice: ModelSlice | MultiSlice = self.model_slice - - # Don't modify the model or the output if the object has no model_slice - if model_slice is None: - return func(self, model, *args, **kwargs) - - # Don't modify the model or the output if the model is already the reduced one - if model.size != model_slice.full_size: - if model.size != model_slice.size: - msg = ( - f"Invalid model of size '{model.size}'. " - f"It should be the full model (size of {model_slice.full_size}) " - f"or the reduced model (size of {model_slice.size})." - ) - raise ValueError(msg) - return func(self, model, *args, **kwargs) - - # Reduce the model and compute the output of the function with it - model_reduced = model_slice.extract(model) - result = func(self, model_reduced, *args, **kwargs) - - # Extend the outputs, depending on type - if isinstance(result, float): - return result + def support_model_slice_decorator(func): - if hasattr(result, "ndim"): - if result.ndim == 1: - result = model_slice.expand_array(result) - elif result.ndim == 2: - result = model_slice.expand_matrix(result) - else: + @functools.wraps(func) + def wrapper(self, model, *args, **kwargs): + if not hasattr(self, "model_slice"): # TODO: add msg - raise ValueError() - else: - # TODO: add msg - raise TypeError() + raise AttributeError() - return result + # Get model slice + model_slice: ModelSlice | MultiSlice = self.model_slice - return wrapper + # Don't modify the model or the output if the object has no model_slice + if model_slice is None: + return func(self, model, *args, **kwargs) + + # Don't modify the model or the output if the model is already the + # reduced one + if model.size != model_slice.full_size: + if model.size != model_slice.size: + msg = ( + f"Invalid model of size '{model.size}'. " + f"It should be the full model " + f"(size of {model_slice.full_size}) " + f"or the reduced model (size of {model_slice.size})." + ) + raise ValueError(msg) + return func(self, model, *args, **kwargs) + + # Extract model using the model slice + # ----------------------------------- + if extract_model: + # Reduce the model and compute the output of the function with it + model_reduced = model_slice.extract(model) + result = func(self, model_reduced, *args, **kwargs) + else: + # Don't reduce the model, just compute the result of the function + result = func(self, model, *args, **kwargs) + + # Extend return of function + # ------------------------- + if expand_return: + if hasattr(result, "ndim"): + if result.ndim == 1: + result = model_slice.expand_array(result) + elif result.ndim == 2: + result = model_slice.expand_matrix(result) + else: + # TODO: add msg + raise ValueError() + else: + # TODO: add msg + raise TypeError() + return result + + return wrapper + + if func_ is None: + return support_model_slice_decorator + return support_model_slice_decorator(func_) class Counter: From 9f09f976720b2b1721d9e4b2e8210f3d16256c0b Mon Sep 17 00:00:00 2001 From: Santiago Soler Date: Tue, 14 Apr 2026 17:21:20 -0700 Subject: [PATCH 47/47] Update notebook --- ...0_gravity-inversion-with-model-slice.ipynb | 397 +++++++++--------- 1 file changed, 202 insertions(+), 195 deletions(-) diff --git a/notebooks/50_gravity-inversion-with-model-slice.ipynb b/notebooks/50_gravity-inversion-with-model-slice.ipynb index 10928d8..3f61b36 100644 --- a/notebooks/50_gravity-inversion-with-model-slice.ipynb +++ b/notebooks/50_gravity-inversion-with-model-slice.ipynb @@ -14,11 +14,11 @@ "id": "b2d27e8b-5b33-4361-990b-8b6e724f5ac6", "metadata": { "execution": { - "iopub.execute_input": "2026-02-10T22:47:20.427308Z", - "iopub.status.busy": "2026-02-10T22:47:20.426922Z", - "iopub.status.idle": "2026-02-10T22:47:22.228165Z", - "shell.execute_reply": "2026-02-10T22:47:22.227411Z", - "shell.execute_reply.started": "2026-02-10T22:47:20.427282Z" + "iopub.execute_input": "2026-04-15T00:20:28.888718Z", + "iopub.status.busy": "2026-04-15T00:20:28.888537Z", + "iopub.status.idle": "2026-04-15T00:20:30.607377Z", + "shell.execute_reply": "2026-04-15T00:20:30.606281Z", + "shell.execute_reply.started": "2026-04-15T00:20:28.888699Z" } }, "outputs": [], @@ -54,11 +54,11 @@ "id": "dfce90d3-de10-43d3-a668-696993b0f73e", "metadata": { "execution": { - "iopub.execute_input": "2026-02-10T22:47:22.229313Z", - "iopub.status.busy": "2026-02-10T22:47:22.228850Z", - "iopub.status.idle": "2026-02-10T22:47:22.233668Z", - "shell.execute_reply": "2026-02-10T22:47:22.232855Z", - "shell.execute_reply.started": "2026-02-10T22:47:22.229286Z" + "iopub.execute_input": "2026-04-15T00:20:30.608178Z", + "iopub.status.busy": "2026-04-15T00:20:30.607862Z", + "iopub.status.idle": "2026-04-15T00:20:30.612379Z", + "shell.execute_reply": "2026-04-15T00:20:30.611261Z", + "shell.execute_reply.started": "2026-04-15T00:20:30.608160Z" } }, "outputs": [], @@ -81,11 +81,11 @@ "id": "2403d600-451e-424e-8de9-3f824f1e2647", "metadata": { "execution": { - "iopub.execute_input": "2026-02-10T22:47:22.234497Z", - "iopub.status.busy": "2026-02-10T22:47:22.234266Z", - "iopub.status.idle": "2026-02-10T22:47:23.503430Z", - "shell.execute_reply": "2026-02-10T22:47:23.502649Z", - "shell.execute_reply.started": "2026-02-10T22:47:22.234472Z" + "iopub.execute_input": "2026-04-15T00:20:30.613390Z", + "iopub.status.busy": "2026-04-15T00:20:30.613133Z", + "iopub.status.idle": "2026-04-15T00:20:31.726634Z", + "shell.execute_reply": "2026-04-15T00:20:31.725722Z", + "shell.execute_reply.started": "2026-04-15T00:20:30.613370Z" } }, "outputs": [ @@ -114,17 +114,17 @@ "id": "9612913a-b699-4ad4-8fe7-cbf83376f5d8", "metadata": { "execution": { - "iopub.execute_input": "2026-02-10T22:47:23.504311Z", - "iopub.status.busy": "2026-02-10T22:47:23.504089Z", - "iopub.status.idle": "2026-02-10T22:47:23.650692Z", - "shell.execute_reply": "2026-02-10T22:47:23.649895Z", - "shell.execute_reply.started": "2026-02-10T22:47:23.504293Z" + "iopub.execute_input": "2026-04-15T00:20:31.727573Z", + "iopub.status.busy": "2026-04-15T00:20:31.727355Z", + "iopub.status.idle": "2026-04-15T00:20:31.863772Z", + "shell.execute_reply": "2026-04-15T00:20:31.862693Z", + "shell.execute_reply.started": "2026-04-15T00:20:31.727557Z" } }, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -146,11 +146,11 @@ "id": "f6d55c30-c5c9-4376-bc6d-ece83805b2d2", "metadata": { "execution": { - "iopub.execute_input": "2026-02-10T22:47:23.651444Z", - "iopub.status.busy": "2026-02-10T22:47:23.651218Z", - "iopub.status.idle": "2026-02-10T22:47:23.655364Z", - "shell.execute_reply": "2026-02-10T22:47:23.654561Z", - "shell.execute_reply.started": "2026-02-10T22:47:23.651378Z" + "iopub.execute_input": "2026-04-15T00:20:31.864447Z", + "iopub.status.busy": "2026-04-15T00:20:31.864275Z", + "iopub.status.idle": "2026-04-15T00:20:31.869152Z", + "shell.execute_reply": "2026-04-15T00:20:31.868131Z", + "shell.execute_reply.started": "2026-04-15T00:20:31.864429Z" } }, "outputs": [ @@ -183,11 +183,11 @@ "id": "0edbb620-6a62-48bf-a8af-8981a76cc6f4", "metadata": { "execution": { - "iopub.execute_input": "2026-02-10T22:47:23.656000Z", - "iopub.status.busy": "2026-02-10T22:47:23.655825Z", - "iopub.status.idle": "2026-02-10T22:47:23.672077Z", - "shell.execute_reply": "2026-02-10T22:47:23.671191Z", - "shell.execute_reply.started": "2026-02-10T22:47:23.655984Z" + "iopub.execute_input": "2026-04-15T00:20:31.870162Z", + "iopub.status.busy": "2026-04-15T00:20:31.869910Z", + "iopub.status.idle": "2026-04-15T00:20:31.891564Z", + "shell.execute_reply": "2026-04-15T00:20:31.890484Z", + "shell.execute_reply.started": "2026-04-15T00:20:31.870142Z" } }, "outputs": [ @@ -273,11 +273,11 @@ "id": "8a890b93-78ec-4681-bbb5-cc91e1448a85", "metadata": { "execution": { - "iopub.execute_input": "2026-02-10T22:47:23.673015Z", - "iopub.status.busy": "2026-02-10T22:47:23.672771Z", - "iopub.status.idle": "2026-02-10T22:47:23.679589Z", - "shell.execute_reply": "2026-02-10T22:47:23.679040Z", - "shell.execute_reply.started": "2026-02-10T22:47:23.672997Z" + "iopub.execute_input": "2026-04-15T00:20:31.892988Z", + "iopub.status.busy": "2026-04-15T00:20:31.892672Z", + "iopub.status.idle": "2026-04-15T00:20:31.913954Z", + "shell.execute_reply": "2026-04-15T00:20:31.913159Z", + "shell.execute_reply.started": "2026-04-15T00:20:31.892961Z" } }, "outputs": [], @@ -294,11 +294,11 @@ "id": "1dd17123-2df8-45b6-9345-d5cb6f431d51", "metadata": { "execution": { - "iopub.execute_input": "2026-02-10T22:47:23.680432Z", - "iopub.status.busy": "2026-02-10T22:47:23.680233Z", - "iopub.status.idle": "2026-02-10T22:47:23.734282Z", - "shell.execute_reply": "2026-02-10T22:47:23.733445Z", - "shell.execute_reply.started": "2026-02-10T22:47:23.680413Z" + "iopub.execute_input": "2026-04-15T00:20:31.914848Z", + "iopub.status.busy": "2026-04-15T00:20:31.914682Z", + "iopub.status.idle": "2026-04-15T00:20:31.977687Z", + "shell.execute_reply": "2026-04-15T00:20:31.976613Z", + "shell.execute_reply.started": "2026-04-15T00:20:31.914832Z" } }, "outputs": [], @@ -312,11 +312,11 @@ "id": "b4c9ad67-47fe-4408-b879-d99b8eec8ca2", "metadata": { "execution": { - "iopub.execute_input": "2026-02-10T22:47:23.734860Z", - "iopub.status.busy": "2026-02-10T22:47:23.734698Z", - "iopub.status.idle": "2026-02-10T22:47:23.738293Z", - "shell.execute_reply": "2026-02-10T22:47:23.737432Z", - "shell.execute_reply.started": "2026-02-10T22:47:23.734844Z" + "iopub.execute_input": "2026-04-15T00:20:31.978500Z", + "iopub.status.busy": "2026-04-15T00:20:31.978309Z", + "iopub.status.idle": "2026-04-15T00:20:31.982155Z", + "shell.execute_reply": "2026-04-15T00:20:31.981086Z", + "shell.execute_reply.started": "2026-04-15T00:20:31.978468Z" } }, "outputs": [], @@ -333,11 +333,11 @@ "id": "ffc07711-d8e3-49cf-9574-f2bde45ceec8", "metadata": { "execution": { - "iopub.execute_input": "2026-02-10T22:47:23.739068Z", - "iopub.status.busy": "2026-02-10T22:47:23.738875Z", - "iopub.status.idle": "2026-02-10T22:47:23.750876Z", - "shell.execute_reply": "2026-02-10T22:47:23.750223Z", - "shell.execute_reply.started": "2026-02-10T22:47:23.739049Z" + "iopub.execute_input": "2026-04-15T00:20:31.983121Z", + "iopub.status.busy": "2026-04-15T00:20:31.982955Z", + "iopub.status.idle": "2026-04-15T00:20:31.994057Z", + "shell.execute_reply": "2026-04-15T00:20:31.992890Z", + "shell.execute_reply.started": "2026-04-15T00:20:31.983104Z" } }, "outputs": [ @@ -347,29 +347,6 @@ "text": [ "[-0.2 0.2]\n" ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/home/santi/.miniforge3/envs/inversion_ideas/lib/python3.13/site-packages/simpeg/utils/model_builder.py:37: BreakingChangeWarning: Since SimPEG v0.25.0, the 'get_indices_block' function returns a single array with the cell indices, instead of a tuple with a single element. This means that we don't need to unpack the tuple anymore to access to the cell indices.\n", - "If you were using this function as in:\n", - "\n", - " ind = get_indices_block(p0, p1, mesh.cell_centers)[0]\n", - "\n", - "Make sure you update it to:\n", - "\n", - " ind = get_indices_block(p0, p1, mesh.cell_centers)\n", - "\n", - "To hide this warning, add this to your script or notebook:\n", - "\n", - " import warnings\n", - " from simpeg.utils import BreakingChangeWarning\n", - "\n", - " warnings.filterwarnings(action='ignore', category=BreakingChangeWarning)\n", - "\n", - " ind = get_indices_block(p0, p1, cell_centers)\n" - ] } ], "source": [ @@ -388,18 +365,18 @@ "id": "0b89b688-a595-4ff3-81e3-8bba4d4ef7c8", "metadata": { "execution": { - "iopub.execute_input": "2026-02-10T22:47:23.751617Z", - "iopub.status.busy": "2026-02-10T22:47:23.751393Z", - "iopub.status.idle": "2026-02-10T22:47:23.907723Z", - "shell.execute_reply": "2026-02-10T22:47:23.907001Z", - "shell.execute_reply.started": "2026-02-10T22:47:23.751600Z" + "iopub.execute_input": "2026-04-15T00:20:31.995416Z", + "iopub.status.busy": "2026-04-15T00:20:31.995060Z", + "iopub.status.idle": "2026-04-15T00:20:32.131562Z", + "shell.execute_reply": "2026-04-15T00:20:32.130652Z", + "shell.execute_reply.started": "2026-04-15T00:20:31.995391Z" } }, "outputs": [ { "data": { "text/plain": [ - "(,)" + "(,)" ] }, "execution_count": 11, @@ -408,7 +385,7 @@ }, { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAlQAAAHFCAYAAAA0SmdSAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjcsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvTLEjVAAAAAlwSFlzAAAPYQAAD2EBqD+naQAALXdJREFUeJzt3Qt4FNX9//FvAuTCJeESTABDglDrJVKQoEnQAiIXHwQtFUFaCy2CFlKUYMsthSQCEQRqpUVEEGi1FbXSiqJiNNhSEIEGRalSlEu4o2BiaZNgMr/ne/7d/WdzDyck2d3363mGsDMnm5k9m9lPzjlzJsBxHEcAAABw0QIv/lsBAABAoAIAAKgDtFABAABYIlABAABYIlABAABYIlABAABYIlABAABYIlABAABYIlABAABYIlABaJR27Ngh3/ve96Rz584SHBwskZGRkpiYKNOmTfMo169fP7OUFhAQIGlpafW6vx9//LFMmjTJ7GOLFi3MPmzZsqXCsl9//bVMmTJFOnXqZI7tyiuvlEWLFklxcXG97jOAukOgAtDovPbaa5KUlCT5+fkmaGzevFl+/etfS58+fWT9+vXVfv/27dvlvvvuk/q0a9cu+fOf/yxt27aVAQMGVFrum2++kYEDB8qzzz4rs2bNkldffVWGDRsmM2bMkKlTp9brPgOoOwHcyw9AY9O3b185duyYfPLJJ9K0aVOPbSUlJRIY+P//FnS1TlXWGlRfSu/XSy+9JCNHjpTs7OxyrWfPP/+83HPPPfKnP/1JRowY4V5///33y6pVq2Tfvn3y7W9/u973H4AdWqgANDpffvmlRERElAtTqnSYqkxFXX4a0CZOnCjR0dESFBQkHTt2lLvuuktOnTrlLqMtYg8//LB06dLFlNEuuYceekjOnz9f7c+syX6pv//972b/brvtNo/1t99+uwllGzZsqNHzAGhcyp+tAKCB6Tgkba3RcUY/+MEP5Prrr5dmzZpd9PNpmOrdu7dcuHDBdLN1797dhLY333xTzp07Z8Zn/ec//zEtY0ePHnWX0XFRc+bMkb1790pWVpYJQraKiopM+Cp7PDqWSn344YfWPwNA/SNQAWh0Hn30UdPdt2zZMrNo+NBApGONkpOTpWXLlrV6Pg1FX3zxhXzwwQdy9dVXu9fffffd7v8/8cQTJszoYPj4+HizTsdCaSuVtmS98cYb5VqVLsY111xjBp+/9957ctNNN7nXb9261XzVoAfA+9DlB6DRadeunfztb3+TnTt3mnB1xx13yP79+2XmzJly3XXXmXBUG6+//rr079/fI0yVpYPD4+LipEePHmbguGsZPHhwlVfs1Za2uOnAde1+1PD21VdfyR//+EcT6GrTdQigceE3F0CjpS1F06dPlxdffFGOHz9uroI7dOiQufKvNs6cOSOXX355lWV0LJW2UGlrWOmlVatW4jhOrUNcZXRsmLZ2qYSEBGnTpo387Gc/k6VLl5p12iIGwPvQ5QfAK2i4mTt3rvzqV7+Sjz76qFbf2759ezM2qrqgExoaKs8880yl2+uKdl/q1XwaDnXA+7e+9S3ZvXu32fbd7363zn4OgPpDoALQ6Jw4cUI6dOhQbv0///lP81Wv0KsNHfv0+9//Xj799NNKpyTQq+wWLFhguhv1Kr/6EBsba75qC9iSJUvMcel0CwC8D4EKQKOj45a0i04HoV911VVmOoE9e/aY0KED0h988MFaPV9GRoYZR6WtP3oFn47D0rFL2vWWkpJifoZOj6BzQ2kZ7VrUq/z05x45csRMLKoztN94442V/gy9SnDTpk3m/zrgXL377rumq1BnTi89oH327NlmHzQ06vNrq5iOp9IJTbWVDID3IVABaHRSU1PlL3/5i+ne09aqwsJCEz5uvfVWMzC9qsHlFdFxSe+//77pMtRB7nolnXYD6lV2OkBcaejRgfC6feXKlXLw4EETbvTWN/pzXa1JlTl9+nS51iXXXFgxMTGme89Fp2rQsWEnT56UsLAwM12DBioNWQC8EzOlAwAAWOIqPwAAAEsEKgAAAEsEKgAAAEt+G6iWL19uLo0OCQmRXr16mcGoAAAAF8MvA9X69evNJdJ66XJOTo7cfPPN5pJmvXwZAACgtvzyKj+dS0bvXv/kk0+61+ll2HfeeadkZmY26L4BAADv43fzUBUVFZlbPMyYMcNj/aBBg2Tbtm0Vfo/OgaOLi072d/bsWTOjst40FQAANH7ahvT111+buxLU9Y3I/S5Q6azFxcXFEhkZ6bFeH+skexXRVqv09PR62kMAAHAp5ebmVnvD9Nryu0DlUrZlSVNrZa1NOjOz3p7CJS8vz8yeHJ2eKoEhIZd8XwEAgL2SggLJnTtPWrVqJXXN7wKV3jG+SZMm5Vqj9LYRZVutXIKDg81SloYpAhUAAN7lUgzX8bur/IKCgsw0CW+99ZbHen2clJTUYPsFAAC8l9+1UCntvrv33nslPj5eEhMTzY1QdcqEBx54oKF3DQAAeCG/DFSjRo0yd5vPyMgwd7KPi4uTTZs2mTvCAwAA1JZfBio1adIkswAAANjyuzFUAAAAdY1ABQAAYIlABQAAYIlABQAAYIlABQAAYIlABQAAYIlABQAAYIlABQAAYIlABQAAYIlABQAAYIlABQAAYIlABQAAYIlABQAAYIlABQAAYIlABQAAYIlABQAAYIlABQAAYIlABQAAYIlABQAAYIlABQAAYIlABQAAYIlABQAAYIlABQAAYIlABQAAYIlABQAAYIlABQAAYIlABQAAYIlABQAAYIlABQAAYIlABQAAYIlABQAAYIlABQAAYIlABQAAYIlABQAAYIlABQAAYMlnAtWhQ4dk/Pjx0qVLFwkNDZWuXbvK3LlzpaioyKNcQEBAuWXFihUNtt8AAMD7NRUf8cknn0hJSYk89dRT0q1bN/noo49kwoQJcv78eVm8eLFH2TVr1siQIUPcj8PDwxtgjwEAgK/wmUClAal0SLriiivk008/lSeffLJcoGrdurVERUU1wF4CAABf5DNdfhXJy8uTtm3bllufnJwsERER0rt3b9Pdpy1bVSksLJT8/HyPBQAAwOdaqMr67LPPZNmyZbJkyRKP9Y888ogMGDDAjLN6++23Zdq0afLFF19Iampqpc+VmZkp6enp9bDXAADAGwU4juNII5aWllZtmNm5c6fEx8e7Hx8/flz69u1rllWrVlX5vRq4MjIyTGtWVS1UurhoC1V0dLTELJwngSEhtToeAADQMEoKCuTw9FTzmR8WFuZfLVTaPTd69Ogqy8TGxnqEqf79+0tiYqKsXLmy2udPSEgwAenUqVMSGRlZYZng4GCzAAAAeGWg0rFOutTEsWPHTJjq1auXuZIvMLD6IWI5OTkSEhJiBqoDAAD4ZKCqKW2Z6tevn3Tu3Nlc1XfmzBn3NtcVfRs3bpSTJ0+a1isdQ5WdnS2zZ8+WiRMn0gIFAAAums8Eqs2bN8uBAwfMcvnll3tscw0Ta9asmSxfvlxSUlLMlX06tYKOn5o8eXID7TUAAPAFjX5QemOkY650MlAGpQMA4D0u5aB0n56HCgAAoD4QqAAAACwRqAAAACwRqAAAACwRqAAAACwRqAAAACwRqAAAACwRqAAAACwRqAAAACwRqAAAACwRqAAAACwRqAAAACwRqAAAACwRqAAAACwRqAAAACwRqAAAACwRqAAAACwRqAAAACwRqAAAACwRqAAAACwRqAAAACwRqAAAACwRqAAAACwRqAAAACwRqAAAACwRqAAAACwRqAAAACwRqAAAACwRqAAAACwRqAAAACwRqAAAACwRqAAAACwRqAAAACwRqAAAACwRqAAAACz5VKCKjY2VgIAAj2XGjBkeZY4cOSLDhg2TFi1aSEREhEyZMkWKiooabJ8BAID3ayo+JiMjQyZMmOB+3LJlS/f/i4uLZejQodK+fXvZunWrfPnllzJ27FhxHEeWLVvWQHsMAAC8nc8FqlatWklUVFSF2zZv3iz79u2T3Nxc6dixo1m3ZMkSGTdunMyfP1/CwsLqeW8BAIAv8KkuP7Vw4UJp166d9OjRw4Sk0t1527dvl7i4OHeYUoMHD5bCwkLZvXt3A+0xAADwdj7VQvXggw/K9ddfL23atJH3339fZs6cKQcPHpRVq1aZ7SdPnpTIyEiP79GyQUFBZltlNHDp4pKfn38JjwIAAHibRh+o0tLSJD09vcoyO3fulPj4eJk6dap7Xffu3U1Yuuuuu9ytVkoHqpelY6gqWu+SmZlZ7T6g4XR96D2vf/k/ezyhoXcBaJQO3P2UeLtuL9zf0LuAetDoA1VycrKMHj262qv7KpKQ8P8+pA4cOGAClY6t2rFjh0eZc+fOyYULF8q1XJWmLV0pKSkeLVTR0dG1PBIAAOCrGn2g0qkNdLkYOTk55muHDh3M18TERDOu6sSJE+51OlA9ODhYevXqVenz6HZdAAAAvDJQ1ZQOOH/vvfekf//+Eh4ebroBtQtw+PDh0rlzZ1Nm0KBBcs0118i9994rjz32mJw9e1YefvhhM80CV/gBAADx90ClLUjr1683Y510AHlMTIwJSr/4xS/cZZo0aSKvvfaaTJo0Sfr06SOhoaEyZswYWbx4cYPuOwAA8G4+E6j06j5toaqOtla9+uqr9bJPAADAP/jcPFQAAAD1jUAFAABgiUAFAABgiUAFAABgiUAFAABgiUAFAABgiUAFAABgiUAFAABgiUAFAABgiUAFAABgiUAFAABgiUAFAABgiUAFAABgiUAFAABgiUAFAABgiUAFAABgiUAFAABgiUAFAABgiUAFAABgiUAFAABgiUAFAABgiUAFAABgiUAFAABgiUAFAABgiUAFAABgiUAFAABgiUAFAABgiUAFAABgiUAFAABgiUAFAABgqantEwAN7bPHExp6FwBcIt1euJ/XFl6BFioAAABLBCoAAABLBCoAAABLBCoAAABLPhOotmzZIgEBARUuO3fudJeraPuKFSsadN8BAIB385mr/JKSkuTEiRMe6375y19KVlaWxMfHe6xfs2aNDBkyxP04PDy83vYTAAD4Hp8JVEFBQRIVFeV+fOHCBXnllVckOTnZtEKV1rp1a4+yAAAANnymy68sDVNffPGFjBs3rtw2DVkRERHSu3dv091XUlLSIPsIAAB8g8+0UJW1evVqGTx4sERHR3usf+SRR2TAgAESGhoqb7/9tkybNs0Er9TU1Eqfq7Cw0Cwu+fn5l3TfAQCAd2n0LVRpaWmVDjZ3Lbt27fL4nqNHj8qbb74p48ePL/d8GpwSExOlR48eJkxlZGTIY489VuU+ZGZmmnFWrqVsSAMAAP4twHEcRxoxbT3SpSqxsbESEhLi0Qq1bNkyOXbsmDRr1qzK7/373/8uN910k5w8eVIiIyNr3EKloSpm4TwJLPVzAQBA41VSUCCHp6dKXl6ehIWF+VeXn4510qWmNB/qVXw/+tGPqg1TKicnx4QxHahemeDgYLMAAAB4ZaCqrXfeeUcOHjxYYXffxo0bTUuUdvnpGKrs7GyZPXu2TJw4kcAEAAAuWlNfHIyuc1JdffXV5bZpi9Xy5cslJSXFXNl3xRVXmDFUkydPbpB9BQAAvsHnAtUf/vCHSrfpZJ6lJ/QEAADwi6v8AAAAGjsCFQAAgCUCFQAAgCUCFQAAgCUCFQAAgCUCFQAAgCUCFQAAgCUCFQAAgCUCFQAAgCUCFQAAgCUCFQAAgCUCFQAAgCUCFQAAgCUCFQAAgCUCFQAAgCUCFQAAgCUCFQAAgCUCFQAAgCUCFQAAgCUCFQAAgCUCFQAAgCUCFQAAgCUCFQAAgCUCFQAAgCUCFQAAgCUCFQAAgCUCFQAAgCUCFQAAgCUCFQAAgCUCFQAAgCUCFQAAgCUCFQAAgCUCFQAAgCUCFQAAgCUCFQAAgCUCFQAAgL8Eqvnz50tSUpI0b95cWrduXWGZI0eOyLBhw6RFixYSEREhU6ZMkaKiIo8ye/fulb59+0poaKh06tRJMjIyxHGcejoKAADgi5qKl9BgNHLkSElMTJTVq1eX215cXCxDhw6V9u3by9atW+XLL7+UsWPHmrC0bNkyUyY/P18GDhwo/fv3l507d8r+/ftl3LhxJoBNmzatAY4KAAD4bQvVLbfcIunp6eXWnzt3zmy7FPTnTZ06Va677roKt2/evFn27dsnzz77rPTs2VNuvfVWWbJkiTz99NMmSKnnnntOCgoKZO3atRIXFycjRoyQWbNmydKlS2mlAgAA9RuotmzZIr/5zW/kzjvvlPPnz3u0Ir377rvSELZv325CUseOHd3rBg8eLIWFhbJ79253Ge3uCw4O9ihz/PhxOXToUKXPrc+hoaz0AgAAYD2GKisrS06ePCkJCQlVhpH6ovsSGRnpsa5NmzYSFBRktlVWxvXYVaYimZmZEh4e7l6io6MvyTEAAAA/C1QdOnQwrVHdu3eX3r17m1ar2kpLS5OAgIAql127dtX4+bR8WTqGqvT6smVcA9Ir+l6XmTNnSl5ennvJzc2t8T4BAADfd1GD0l3hQ7vOdFzSvHnzZMiQITJ9+vRaPU9ycrKMHj26yjKxsbE1eq6oqCjZsWNHuTFdFy5ccLdCaZmyLVGnT582X8u2XJWmx1m6mxAAAMA6UJWdZiA1NVWuvvpqc1VdbejUBrrUBb36T6dWOHHihGk9cw1U1yDUq1cvdxkdhK5jvbQr0FVGx13VNLgBAADUSZffwYMHzfQEpX3/+983LUTPPPOMXAo6x9SePXvMV50iQf+vy7///W+zfdCgQXLNNdfIvffeKzk5OfL222/Lww8/LBMmTJCwsDBTZsyYMSZg6VQJH330kWzYsEEWLFggKSkpVXb5AQAAVCXA8ZJZLTUErVu3rtz67Oxs6devn/m/hq1JkybJO++8Yybu1AC1ePFij+46ndhz8uTJ8v7775tB6w888IDMmTOnVoFKr/LTwekxC+dJYEhIHR0hAAC4lEoKCuTw9FQzHtrV2OJ3gaoxIVABAOB9Si5hoPKaW88AAAA0VgQqAAAASwQqAAAASwQqAAAASwQqAAAASwQqAAAASwQqAAAASwQqAAAASwQqAAAASwQqAAAASwQqAAAASwQqAAAASwQqAAAASwQqAAAASwQqAAAASwQqAAAASwQqAAAASwQqAAAASwQqAAAASwQqAAAASwQqAAAASwQqAAAASwQqAAAASwQqAAAASwQqAAAASwQqAAAASwQqAAAASwQqAAAASwQqAAAASwQqAAAASwQqAAAASwQqAAAASwQqAAAASwQqAAAASwQqAAAAfwlU8+fPl6SkJGnevLm0bt263PYPPvhA7rnnHomOjpbQ0FC5+uqr5de//rVHmUOHDklAQEC55Y033qjHIwEAAL6mqXiJoqIiGTlypCQmJsrq1avLbd+9e7e0b99enn32WROqtm3bJhMnTpQmTZpIcnKyR9msrCy59tpr3Y/btm1bL8cAAAB8k9cEqvT0dPN17dq1FW7/yU9+4vH4iiuukO3bt8vLL79cLlC1a9dOoqKiLuHeAgAAf+I1XX4XIy8vr8LWp+HDh8tll10mffr0kZdeeqna5yksLJT8/HyPBQAAwOcDlbZOvfDCC3L//fe717Vs2VKWLl1qQtSmTZtkwIABMmrUKNNNWJXMzEwJDw93L9qlCAAA0CgCVVpaWoWDxEsvu3btqvXzfvzxx3LHHXfInDlzZODAge71ERERMnXqVLnhhhskPj5eMjIyZNKkSbJo0aIqn2/mzJmmtcu15ObmXtTxAgAA39SgY6h0bNPo0aOrLBMbG1ur59y3b5/ccsstMmHCBElNTa22fEJCgqxatarKMsHBwWYBAABodIFKW4x0qSvaMqVhauzYsWaahZrIycmRDh061Nk+AAAA/+M1V/kdOXJEzp49a74WFxfLnj17zPpu3bqZsVEapvr37y+DBg2SlJQUOXnypNmu0ybodApq3bp10qxZM+nZs6cEBgbKxo0b5YknnpCFCxc26LEBAADv5jWBSsdDaSBy0VCksrOzpV+/fvLiiy/KmTNn5LnnnjOLS0xMjJnQ02XevHly+PBhE7SuvPJKeeaZZ+SHP/xhPR8NAADwJQGO4zgNvRPeRqdN0Kv9YhbOk8CQkIbeHQAAUAMlBQVyeHqqucAsLCxM6pLPTpsAAABQXwhUAAAAlghUAAAAlghUAAAAlghUAAAAlghUAAAAlghUAAAAlghUAAAAlghUAAAAlghUAAAAlghUAAAAlghUAAAAlghUAAAAlghUAAAAlghUAAAAlghUAAAAlghUAAAAlghUAAAAlghUAAAAlghUAAAAlghUAAAAlghUAAAAlghUAAAAlghUAAAAlghUAAAAlghUAAAAlghUAAAAlghUAAAAlghUAAAAlghUAAAAlghUAAAAlghUAAAAlghUAAAAlghUAAAAlghUAAAA/hKo5s+fL0lJSdK8eXNp3bp1hWUCAgLKLStWrPAos3fvXunbt6+EhoZKp06dJCMjQxzHqaejAAAAvqipeImioiIZOXKkJCYmyurVqystt2bNGhkyZIj7cXh4uPv/+fn5MnDgQOnfv7/s3LlT9u/fL+PGjZMWLVrItGnTLvkxAAAA3+Q1gSo9Pd18Xbt2bZXltPUqKiqqwm3PPfecFBQUmOcIDg6WuLg4E6qWLl0qKSkppkULAADAZ7v8aio5OVkiIiKkd+/epruvpKTEvW379u2mu0/DlMvgwYPl+PHjcujQoUqfs7Cw0LRulV4AAAB8MlA98sgj8uKLL0pWVpaMHj3adOMtWLDAvf3kyZMSGRnp8T2ux7qtMpmZmabr0LVER0dfwqMAAADepkEDVVpaWoUDyUsvu3btqvHzpaammjFWPXr0MGFKB5w/9thjHmXKduu5BqRX1d03c+ZMycvLcy+5ubm1PlYAAOC7mjZ095y2JFUlNjb2op8/ISHBdM+dOnXKtETp2KqyLVGnT582X8u2XJWmXYSluwkBAAAaTaDSsU66XCo5OTkSEhLinmZBW69mzZplrhgMCgoy6zZv3iwdO3a0Cm4AAMC/ec1VfkeOHJGzZ8+ar8XFxbJnzx6zvlu3btKyZUvZuHGjaX3S0KRzTGVnZ8vs2bNl4sSJ7talMWPGmKsFdaoEDVb/+te/zBirOXPmcIUfAADw/UCloWfdunXuxz179jRfNTj169dPmjVrJsuXLzfTH+iVfVdccYUZQzV58mT39+iA8rfeesusi4+PlzZt2pjyugAAAFysAIdpwmtNx2VpOItZOE8CQ0Iu+sUHAAD1p6SgQA5PTzUXmIWFhdXpc/vUtAkAAAANgUAFAABAoAIAAGhYtFABAABYIlABAABYIlABAABYIlABAABYIlABAABYIlABAABYIlABAABYIlABAABYIlABAABYIlABAABYIlABAABYIlABAABYIlABAABYIlABAABYIlABAABYIlABAABYIlABAABYIlABAABYIlABAABYIlABAABYIlABAABYIlABAABYIlABAABYIlABAABYIlABAABYIlABAABYIlABAABYIlABAABYIlABAABYIlABAABYIlABAABYIlABAAD4S6CaP3++JCUlSfPmzaV169bltq9du1YCAgIqXE6fPm3KHDp0qMLtb7zxRgMcEQAA8BVNxUsUFRXJyJEjJTExUVavXl1u+6hRo2TIkCEe68aNGycFBQVy2WWXeazPysqSa6+91v24bdu2l3DPAQCAr/OaQJWenu5uiapIaGioWVzOnDkj77zzToXhq127dhIVFXUJ9xYAAPgTr+nyq63f/e53pnvwrrvuKrdt+PDhptWqT58+8tJLLzXI/gEAAN/hNS1UtfXMM8/ImDFjPFqtWrZsKUuXLjVBKjAwUF555RXTVbhu3Tr54Q9/WOlzFRYWmsUlPz//ku8/AADwHg3aQpWWllbpQHLXsmvXrlo/7/bt22Xfvn0yfvx4j/UREREydepUueGGGyQ+Pl4yMjJk0qRJsmjRoiqfLzMzU8LDw91LdHR0rfcJAAD4rgZtoUpOTpbRo0dXWSY2NrbWz7tq1Srp0aOH9OrVq9qyCQkJpnxVZs6cKSkpKR4tVIQqAADQKAKVthjpUpf+/e9/ywsvvGBalWoiJydHOnToUGWZ4OBgswAAAHj1GKojR47I2bNnzdfi4mLZs2ePWd+tWzczNspl/fr18s0338gPfvCDcs+hY6WaNWsmPXv2NGOoNm7cKE888YQsXLiwXo8FAAD4Fq8JVHPmzDGByEVDkcrOzpZ+/fq51+s0CSNGjJA2bdpU+Dzz5s2Tw4cPS5MmTeTKK680g9erGpAOAABQnQDHcZxqS8GDjqHSwekxC+dJYEgIrw4AAF6gpKBADk9Plby8PAkLC6vT5/bZeagAAADqC4EKAADAEoEKAADAEoEKAADAEoEKAADAEoEKAADAEoEKAADAEoEKAADAEoEKAADAEoEKAADAEoEKAADAEoEKAADAEoEKAADAEoEKAADAEoEKAADAEoEKAADAEoEKAADAEoEKAADAEoEKAADAEoEKAADAEoEKAADAEoEKAADAEoEKAADAEoEKAADAEoEKAADAEoEKAADAEoEKAADAEoEKAADAEoEKAADAEoEKAADAEoEKAADAEoEKAADAEoEKAADAEoEKAADAEoEKAADAHwLVoUOHZPz48dKlSxcJDQ2Vrl27yty5c6WoqMij3JEjR2TYsGHSokULiYiIkClTppQrs3fvXunbt695nk6dOklGRoY4jlPPRwQAAHxJU/ECn3zyiZSUlMhTTz0l3bp1k48++kgmTJgg58+fl8WLF5syxcXFMnToUGnfvr1s3bpVvvzySxk7dqwJS8uWLTNl8vPzZeDAgdK/f3/ZuXOn7N+/X8aNG2cC2LRp0xr4KAEAgLcKcLy0eeaxxx6TJ598Uj7//HPz+PXXX5fbb79dcnNzpWPHjmbd888/bwLT6dOnJSwszJSfOXOmnDp1SoKDg02ZRx991ASuo0ePSkBAQI1+tgaz8PBwiVk4TwJDQi7hUQIAgLpSUlAgh6enSl5enskFftflVxF9Mdq2bet+vH37domLi3OHKTV48GApLCyU3bt3u8tod58rTLnKHD9+3HQrAgAA+GyXX1mfffaZaVVasmSJe93JkyclMjLSo1ybNm0kKCjIbHOViY2N9Sjj+h7dpmO0KqKhTJfSYc6VdAEAgHdwfW5fis65Bg1UaWlpkp6eXmUZHesUHx/vfqytSUOGDJGRI0fKfffd51G2oi47fdFKry9bxvWiVtXdl5mZWeF+5s6dV+W+AwCAxkfHWevQHZ8JVMnJyTJ69Ogqy5RuUdIwpQPKExMTZeXKlR7loqKiZMeOHR7rzp07JxcuXHC3QmkZV2uVi46vUmVbt0rTcVcpKSnux1999ZXExMSYqwrrukIaMx07Fh0dbcap1XXfc2PGcVPf/oD3Oe9zf5CXlyedO3f2GDLkE4FKpzbQpSaOHTtmwlSvXr1kzZo1EhjoOfxLQ9b8+fPlxIkT0qFDB7Nu8+bNZryUfo+rzKxZs8xUCtoV6Cqj467KdgWWps9RetyVi4YpfwoWLnrMHLf/oL79C/XtX/y1vgPLZIg6eU7xAtoy1a9fP9M6otMknDlzxrQ0lW5tGjRokFxzzTVy7733Sk5Ojrz99tvy8MMPm+kVXG+WMWPGmGCkV/7p1AsbNmyQBQsWmNanml7hBwAA4JWD0rUV6cCBA2a5/PLLKxwD1aRJE3nttddk0qRJ0qdPHzNxpwYo1zxVrhalt956SyZPnmzGZemgdQ1TpbvzAAAAfDJQaYuSLtXRftFXX321yjLXXXed/PWvf7XaH23l0pnaK+oG9GUcN/XtD3if8z73B7zPg+v8NfXaiT0BAAAaC68YQwUAANCYEagAAAAsEagAAAAsEagAAAAsEaiqoBOFJiUlSfPmzaV169YVltHZ0ocNGyYtWrQwk5ROmTLFTBxa2t69e81NmXUqh06dOklGRsYluY/QpbBlyxYzR1dFi94WyKWi7StWrBBvppO9lj2mGTNm1Lr+vYneJHz8+PHmvpb6fu3atau5orXsMflifavly5ebYw8JCTETAv/tb38TX6K30erdu7e0atVKLrvsMrnzzjvl008/9SijV1SXrduEhATxZnqbs7LHpHfOcNHzsZbRSZ71fa/zHn788cfi7So6h+miUwf5Ul3/9a9/NedhrT89hj//+c8e22tSv3q/3p/97GfmPK7n8+HDh8vRo0d9b9qEhqIfInrPQJ1hffXq1eW2FxcXy9ChQ6V9+/aydetWc2+gsWPHmsrTmze7bucwcOBAM8u7BpD9+/ebN7FW2LRp06Sx00Cps8+X9stf/lKysrI87rGodAZ7vc+iiy/clkfDr04O69KyZcta1b+3+eSTT6SkpESeeuop6datm5kAV4///PnzHnO6+WJ9r1+/Xh566CETqnQuO30NbrvtNtm3b5+ZksUXvPvuu+bDVEPVN998I7NnzzaTIusx6jnJRetV69fFdWcJb3bttdea85aLzl3osmjRIlm6dKmsXbtWrrzySpk3b545b2vY1PDprfQzR89TLvr7rMeln2u+VNfnz5+X73znO/LjH/9Yvv/975fbXpP61d/9jRs3yvPPPy/t2rUzn8+333677N692+O9UiWdNgFVW7NmjRMeHl5u/aZNm5zAwEDn2LFj7nV//OMfneDgYCcvL888Xr58ufnegoICd5nMzEynY8eOTklJide99EVFRc5ll13mZGRkeKzXt9KGDRscXxITE+P86le/qnR7TerfFyxatMjp0qWLz9f3DTfc4DzwwAMe66666ipnxowZjq86ffq0qct3333XvW7s2LHOHXfc4fiSuXPnOt/5zncq3Kbn4aioKOfRRx91r9PztZ63V6xY4fiSBx980Onatav7s8cX61rKnJtqUr9fffWV06xZM+f55593l9Hzup7f33jjjRr/bLr8LGzfvl3i4uJMM6LL4MGDTdOhplpXGe3uKz0JqJbR2+lo94q3eeWVV+SLL76ocKJVvdm1NpfqX7/a/aMtHd5u4cKF5q+VHj16mC7g0l1fNal/X7mZaEU3EvWl+tZ61TrT1prS9PG2bdvEV2ndqrL1q1392iWof81rC6XrJvLe7F//+pf5XdUu3dGjR8vnn39u1h88eNDcxqx03ev5Ws/bvlT3+h5/9tln5Sc/+YnHrdZ8sa5Lq0n96u/+hQsXPMroe0XP77V5D9DlZ0ErKTIy0mOd3s5Gm0xd9xnUr2VvvOz6Ht2mv9zeRLs+NTTofRVLe+SRR2TAgAGmf1rvo6jNpRq8UlNTxVs9+OCDcv3115s6ff/992XmzJnml3PVqlU1rn9v99lnn5nuyyVLlvh0feu+a9dI2frUx75Sl2XpH/N6262bbrrJfHC4aDendgnFxMSY97t28d9yyy3mQ8db7w5x4403yu9+9zsTGk6dOmW6fHQ4g46jcdVvRXV/+PBh8RU6ruirr77y+GPYF+u6rJrUr5bR87aev21+//0uUOnAtPT09Gr7ncuOD6pMRTdV1hNV6fVly7gGpDfkDZkv5nXQAXpvvvmmvPDCC+XKlv4g1dYc1/ijxvYBW5vjnjp1qntd9+7dzS/bXXfd5W61qmn9NwYXU9/aiqrjK/SEe99993llfddWRb+rja0u64q2MH744Ydm/F9po0aNcv9fg5a+J/QDV++VOmLECPFGGhxK335Mx8XqBRfr1q1zD8L29brXP4b1dSjdou6LdV2Zi6nf2r4H/C5Q6UlEm3urUrZFqTJ6lciOHTs81p07d840HbrSsJYpm3BdTaplE3Njfx104KIGCb36oTp6ktIB+frXYEMeZ13Wv+vEqzfp1tehJvXvrcetYUovpNAPnpUrV3ptfdeUdl3qwNOKfle98Xiqo1czafe9Xh1V9obzZXXo0MF8yGqXma/QAfgarPSY9EpHpXWvx+qLda8tMTog/+WXX/a7uo7639WcVdWvltEuUT1/l26l0jLakllTfheo9MSpS13QDxsdV6NXwbkqavPmzaapVC+5dpWZNWuWqSzX1RNaRv9KqGlwawyvgyZ1DVQ/+tGPpFmzZtWWz8nJMZeeVzbdhDfWvx6TctV1TerfG4/72LFjJkzpMWidBwYGem1915T+burxvvXWW/K9733PvV4f33HHHeIr9PdYw9SGDRvM2JmaDDnQq1dzc3M9Poy8nY5z/Oc//yk333yzeQ30A1XrumfPnma7nq/1ikhtjfYF+nus46T0qmR/q+suNahf/d3XzzUtc/fdd5t1el7XqyL1CsEaq7Oh9T7o8OHDTk5OjpOenu60bNnS/F+Xr7/+2mz/5ptvnLi4OGfAgAHOP/7xDycrK8u5/PLLneTkZPdz6NUDkZGRzj333OPs3bvXefnll52wsDBn8eLFjjfRY9O3y759+8pte+WVV5yVK1ea4ztw4IDz9NNPm2OcMmWK4622bdvmLF261NT3559/7qxfv95cmTl8+HB3mZrUv7fRK1u6devm3HLLLc7Ro0edEydOuBdfrm+lV/jolT6rV6827/OHHnrIadGihXPo0CHHV/z0pz81Vzdt2bLFo27/85//mO16bps2bZp5/x88eNDJzs52EhMTnU6dOjn5+fmOt9Jj0mPW3+X33nvPuf32251WrVq561avANPXRc/P+r7W83WHDh28+phdiouLnc6dOzvTp0/3WO9Ldf3111+7P5/1c8p17tbP8JrWr17hq+dvPY/r+VzPgXplqJ7na4pAVQW9pFQrp+yibzwXrbChQ4c6oaGhTtu2bc2HaekpEtSHH37o3HzzzeZyer18My0tzeumTNA3YFJSUoXbXn/9dadHjx4mdDZv3tyEjMcff9y5cOGC4612797t3HjjjeaXMCQkxPn2t79tLr0+f/68R7ma1L+3TRFS0Xu+9N9evljfLr/97W/NdBlBQUHO9ddf7zGdgC+orG613pUGq0GDBjnt27c34VI/iPU8eOTIEcebjRo1ynyA6jHpH0YjRoxwPv74Y/d2PR/r77een/U8/d3vftd88PqCN99809Txp59+6rHel+o6Ozu7wve1Hk9N6/e///2vOX/reVzP5xq6a/taBOg/l6ahDQAAwD8wDxUAAIAlAhUAAIAlAhUAAIAlAhUAAIAlAhUAAIAlAhUAAIAlAhUAAIAlAhUAAIAlAhUAAIAlAhUAAIAlAhUAv3fmzBlzR/oFCxa4X4sdO3ZIUFCQbN682e9fHwDV415+ACAimzZtkjvvvFO2bdsmV111lfTs2VOGDh0qjz/+OK8PgGoRqADgfyZPnixZWVnSu3dv+eCDD2Tnzp0SEhLC6wOgWgQqAPif//73vxIXFye5ubmya9cu6d69O68NgBphDBUA/M/nn38ux48fl5KSEjl8+DCvC4Aao4UKAESkqKhIbrjhBunRo4cZQ7V06VLZu3evREZG8voAqBaBCgBE5Oc//7m89NJLZuxUy5YtpX///tKqVSt59dVXeX0AVIsuPwB+b8uWLeZqvt///vcSFhYmgYGB5v9bt26VJ5980u9fHwDVo4UKAADAEi1UAAAAlghUAAAAlghUAAAAlghUAAAAlghUAAAAlghUAAAAlghUAAAAlghUAAAAlghUAAAAlghUAAAAlghUAAAAlghUAAAAYuf/AL3XHs+HR5vXAAAAAElFTkSuQmCC", + "image/png": "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", "text/plain": [ "
" ] @@ -427,11 +404,11 @@ "id": "ff50fbfa-9dd4-4c01-a8eb-245c3c0706a0", "metadata": { "execution": { - "iopub.execute_input": "2026-02-10T22:47:23.908310Z", - "iopub.status.busy": "2026-02-10T22:47:23.908139Z", - "iopub.status.idle": "2026-02-10T22:47:27.861067Z", - "shell.execute_reply": "2026-02-10T22:47:27.860510Z", - "shell.execute_reply.started": "2026-02-10T22:47:23.908294Z" + "iopub.execute_input": "2026-04-15T00:20:32.132354Z", + "iopub.status.busy": "2026-04-15T00:20:32.132160Z", + "iopub.status.idle": "2026-04-15T00:20:35.359609Z", + "shell.execute_reply": "2026-04-15T00:20:35.359008Z", + "shell.execute_reply.started": "2026-04-15T00:20:32.132334Z" } }, "outputs": [], @@ -445,17 +422,17 @@ "id": "094b1d30-c610-44ca-968b-7257aacbaa91", "metadata": { "execution": { - "iopub.execute_input": "2026-02-10T22:47:27.861862Z", - "iopub.status.busy": "2026-02-10T22:47:27.861637Z", - "iopub.status.idle": "2026-02-10T22:47:28.019060Z", - "shell.execute_reply": "2026-02-10T22:47:28.018222Z", - "shell.execute_reply.started": "2026-02-10T22:47:27.861840Z" + "iopub.execute_input": "2026-04-15T00:20:35.360705Z", + "iopub.status.busy": "2026-04-15T00:20:35.360209Z", + "iopub.status.idle": "2026-04-15T00:20:35.499179Z", + "shell.execute_reply": "2026-04-15T00:20:35.498295Z", + "shell.execute_reply.started": "2026-04-15T00:20:35.360682Z" } }, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -493,11 +470,11 @@ "id": "a4303772-cfe0-45ed-90ec-c1caad768f39", "metadata": { "execution": { - "iopub.execute_input": "2026-02-10T22:47:28.019656Z", - "iopub.status.busy": "2026-02-10T22:47:28.019472Z", - "iopub.status.idle": "2026-02-10T22:47:28.022888Z", - "shell.execute_reply": "2026-02-10T22:47:28.022022Z", - "shell.execute_reply.started": "2026-02-10T22:47:28.019640Z" + "iopub.execute_input": "2026-04-15T00:20:35.499824Z", + "iopub.status.busy": "2026-04-15T00:20:35.499637Z", + "iopub.status.idle": "2026-04-15T00:20:35.503696Z", + "shell.execute_reply": "2026-04-15T00:20:35.502404Z", + "shell.execute_reply.started": "2026-04-15T00:20:35.499809Z" } }, "outputs": [], @@ -511,11 +488,11 @@ "id": "956f31ab-ed45-432f-a788-15cf73febf14", "metadata": { "execution": { - "iopub.execute_input": "2026-02-10T22:47:28.023420Z", - "iopub.status.busy": "2026-02-10T22:47:28.023253Z", - "iopub.status.idle": "2026-02-10T22:47:28.050523Z", - "shell.execute_reply": "2026-02-10T22:47:28.050042Z", - "shell.execute_reply.started": "2026-02-10T22:47:28.023403Z" + "iopub.execute_input": "2026-04-15T00:20:35.504439Z", + "iopub.status.busy": "2026-04-15T00:20:35.504223Z", + "iopub.status.idle": "2026-04-15T00:20:35.528635Z", + "shell.execute_reply": "2026-04-15T00:20:35.527125Z", + "shell.execute_reply.started": "2026-04-15T00:20:35.504420Z" } }, "outputs": [], @@ -529,17 +506,17 @@ "id": "fd1dfb8c-fe88-4a46-b59e-70baaec550f7", "metadata": { "execution": { - "iopub.execute_input": "2026-02-10T22:47:28.051139Z", - "iopub.status.busy": "2026-02-10T22:47:28.050943Z", - "iopub.status.idle": "2026-02-10T22:47:28.231175Z", - "shell.execute_reply": "2026-02-10T22:47:28.230316Z", - "shell.execute_reply.started": "2026-02-10T22:47:28.051117Z" + "iopub.execute_input": "2026-04-15T00:20:35.531489Z", + "iopub.status.busy": "2026-04-15T00:20:35.530333Z", + "iopub.status.idle": "2026-04-15T00:20:35.678148Z", + "shell.execute_reply": "2026-04-15T00:20:35.676954Z", + "shell.execute_reply.started": "2026-04-15T00:20:35.531459Z" } }, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -561,11 +538,11 @@ "id": "e916f176-b4b7-427a-847c-a282f85640a5", "metadata": { "execution": { - "iopub.execute_input": "2026-02-10T22:47:28.232057Z", - "iopub.status.busy": "2026-02-10T22:47:28.231819Z", - "iopub.status.idle": "2026-02-10T22:47:28.884243Z", - "shell.execute_reply": "2026-02-10T22:47:28.883633Z", - "shell.execute_reply.started": "2026-02-10T22:47:28.232034Z" + "iopub.execute_input": "2026-04-15T00:20:35.679103Z", + "iopub.status.busy": "2026-04-15T00:20:35.678870Z", + "iopub.status.idle": "2026-04-15T00:20:36.133418Z", + "shell.execute_reply": "2026-04-15T00:20:36.132548Z", + "shell.execute_reply.started": "2026-04-15T00:20:35.679085Z" } }, "outputs": [ @@ -613,11 +590,11 @@ "id": "931c7ff0-0f45-40cb-8227-c78e97823f79", "metadata": { "execution": { - "iopub.execute_input": "2026-02-10T22:47:28.884899Z", - "iopub.status.busy": "2026-02-10T22:47:28.884720Z", - "iopub.status.idle": "2026-02-10T22:47:28.888565Z", - "shell.execute_reply": "2026-02-10T22:47:28.887533Z", - "shell.execute_reply.started": "2026-02-10T22:47:28.884882Z" + "iopub.execute_input": "2026-04-15T00:20:36.134333Z", + "iopub.status.busy": "2026-04-15T00:20:36.134163Z", + "iopub.status.idle": "2026-04-15T00:20:36.138268Z", + "shell.execute_reply": "2026-04-15T00:20:36.137203Z", + "shell.execute_reply.started": "2026-04-15T00:20:36.134318Z" } }, "outputs": [], @@ -627,7 +604,7 @@ " \"dummy\": np.zeros(3),\n", "}\n", "\n", - "wires = ii.Wires.create_from(initial_model_dict)" + "wires = ii.Wires.from_dict(initial_model_dict)" ] }, { @@ -636,11 +613,11 @@ "id": "c862c062-c7e2-4d7b-8825-109fa7072bdd", "metadata": { "execution": { - "iopub.execute_input": "2026-02-10T22:47:28.889196Z", - "iopub.status.busy": "2026-02-10T22:47:28.889023Z", - "iopub.status.idle": "2026-02-10T22:47:28.896318Z", - "shell.execute_reply": "2026-02-10T22:47:28.895569Z", - "shell.execute_reply.started": "2026-02-10T22:47:28.889179Z" + "iopub.execute_input": "2026-04-15T00:20:36.139241Z", + "iopub.status.busy": "2026-04-15T00:20:36.139044Z", + "iopub.status.idle": "2026-04-15T00:20:36.157061Z", + "shell.execute_reply": "2026-04-15T00:20:36.155797Z", + "shell.execute_reply.started": "2026-04-15T00:20:36.139225Z" } }, "outputs": [], @@ -657,11 +634,11 @@ "id": "9042f903-4d02-4abe-9de1-2dfacfb3b3a0", "metadata": { "execution": { - "iopub.execute_input": "2026-02-10T22:47:28.897231Z", - "iopub.status.busy": "2026-02-10T22:47:28.897001Z", - "iopub.status.idle": "2026-02-10T22:47:28.909028Z", - "shell.execute_reply": "2026-02-10T22:47:28.908283Z", - "shell.execute_reply.started": "2026-02-10T22:47:28.897205Z" + "iopub.execute_input": "2026-04-15T00:20:36.158271Z", + "iopub.status.busy": "2026-04-15T00:20:36.157926Z", + "iopub.status.idle": "2026-04-15T00:20:36.176136Z", + "shell.execute_reply": "2026-04-15T00:20:36.175047Z", + "shell.execute_reply.started": "2026-04-15T00:20:36.158229Z" } }, "outputs": [], @@ -692,11 +669,11 @@ "id": "ae115d7f-6b08-4c4e-b5f3-7277c24a49e4", "metadata": { "execution": { - "iopub.execute_input": "2026-02-10T22:47:28.909795Z", - "iopub.status.busy": "2026-02-10T22:47:28.909592Z", - "iopub.status.idle": "2026-02-10T22:47:28.913097Z", - "shell.execute_reply": "2026-02-10T22:47:28.912169Z", - "shell.execute_reply.started": "2026-02-10T22:47:28.909778Z" + "iopub.execute_input": "2026-04-15T00:20:36.176980Z", + "iopub.status.busy": "2026-04-15T00:20:36.176794Z", + "iopub.status.idle": "2026-04-15T00:20:36.186181Z", + "shell.execute_reply": "2026-04-15T00:20:36.184841Z", + "shell.execute_reply.started": "2026-04-15T00:20:36.176948Z" } }, "outputs": [], @@ -718,11 +695,11 @@ "id": "dbc4da3d", "metadata": { "execution": { - "iopub.execute_input": "2026-02-10T22:47:28.913971Z", - "iopub.status.busy": "2026-02-10T22:47:28.913727Z", - "iopub.status.idle": "2026-02-10T22:47:28.921478Z", - "shell.execute_reply": "2026-02-10T22:47:28.920609Z", - "shell.execute_reply.started": "2026-02-10T22:47:28.913945Z" + "iopub.execute_input": "2026-04-15T00:20:36.187245Z", + "iopub.status.busy": "2026-04-15T00:20:36.186983Z", + "iopub.status.idle": "2026-04-15T00:20:36.201664Z", + "shell.execute_reply": "2026-04-15T00:20:36.200474Z", + "shell.execute_reply.started": "2026-04-15T00:20:36.187222Z" } }, "outputs": [ @@ -745,14 +722,44 @@ { "cell_type": "code", "execution_count": 23, + "id": "924519fa-44b5-4ff5-b0d4-803882ed41a8", + "metadata": { + "execution": { + "iopub.execute_input": "2026-04-15T00:20:36.202912Z", + "iopub.status.busy": "2026-04-15T00:20:36.202582Z", + "iopub.status.idle": "2026-04-15T00:20:36.807675Z", + "shell.execute_reply": "2026-04-15T00:20:36.806315Z", + "shell.execute_reply.started": "2026-04-15T00:20:36.202885Z" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "array([423.61352886, 438.46600803, 452.99571158, ..., 0. ,\n", + " 0. , 0. ], shape=(64003,))" + ] + }, + "execution_count": 23, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "data_misfit.hessian_diagonal(initial_model)" + ] + }, + { + "cell_type": "code", + "execution_count": 24, "id": "463b4e7b", "metadata": { "execution": { - "iopub.execute_input": "2026-02-10T22:47:28.922140Z", - "iopub.status.busy": "2026-02-10T22:47:28.921902Z", - "iopub.status.idle": "2026-02-10T22:47:29.708055Z", - "shell.execute_reply": "2026-02-10T22:47:29.707351Z", - "shell.execute_reply.started": "2026-02-10T22:47:28.922124Z" + "iopub.execute_input": "2026-04-15T00:20:36.808656Z", + "iopub.status.busy": "2026-04-15T00:20:36.808399Z", + "iopub.status.idle": "2026-04-15T00:20:37.387391Z", + "shell.execute_reply": "2026-04-15T00:20:37.386434Z", + "shell.execute_reply.started": "2026-04-15T00:20:36.808635Z" } }, "outputs": [ @@ -763,7 +770,7 @@ "\twith 64003 stored elements (1 diagonals) and shape (64003, 64003)>" ] }, - "execution_count": 23, + "execution_count": 24, "metadata": {}, "output_type": "execute_result" } @@ -775,15 +782,15 @@ }, { "cell_type": "code", - "execution_count": 24, + "execution_count": 25, "id": "b7d8d1fc-af33-4658-bd94-a0ad75665bd3", "metadata": { "execution": { - "iopub.execute_input": "2026-02-10T22:47:29.709123Z", - "iopub.status.busy": "2026-02-10T22:47:29.708830Z", - "iopub.status.idle": "2026-02-10T22:47:30.301400Z", - "shell.execute_reply": "2026-02-10T22:47:30.300807Z", - "shell.execute_reply.started": "2026-02-10T22:47:29.709093Z" + "iopub.execute_input": "2026-04-15T00:20:37.388213Z", + "iopub.status.busy": "2026-04-15T00:20:37.387995Z", + "iopub.status.idle": "2026-04-15T00:20:37.824695Z", + "shell.execute_reply": "2026-04-15T00:20:37.823884Z", + "shell.execute_reply.started": "2026-04-15T00:20:37.388190Z" } }, "outputs": [ @@ -793,7 +800,7 @@ "<64003x64003 BlockSquareMatrix with dtype=float64>" ] }, - "execution_count": 24, + "execution_count": 25, "metadata": {}, "output_type": "execute_result" } @@ -804,15 +811,15 @@ }, { "cell_type": "code", - "execution_count": 25, + "execution_count": 26, "id": "e2dfb4e8-1996-4f3f-8b05-781fc2d4537c", "metadata": { "execution": { - "iopub.execute_input": "2026-02-10T22:47:30.302181Z", - "iopub.status.busy": "2026-02-10T22:47:30.301998Z", - "iopub.status.idle": "2026-02-10T22:47:34.903899Z", - "shell.execute_reply": "2026-02-10T22:47:34.902994Z", - "shell.execute_reply.started": "2026-02-10T22:47:30.302162Z" + "iopub.execute_input": "2026-04-15T00:20:37.825523Z", + "iopub.status.busy": "2026-04-15T00:20:37.825340Z", + "iopub.status.idle": "2026-04-15T00:20:46.383990Z", + "shell.execute_reply": "2026-04-15T00:20:46.383442Z", + "shell.execute_reply.started": "2026-04-15T00:20:37.825506Z" } }, "outputs": [ @@ -820,7 +827,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "Elapsed time (no preconditioner): 4.60s\n" + "Elapsed time (no preconditioner): 8.55s\n" ] } ], @@ -837,26 +844,26 @@ }, { "cell_type": "code", - "execution_count": 26, + "execution_count": 27, "id": "82c1ddc2-d886-4cd1-a42d-1c32af5d4465", "metadata": { "execution": { - "iopub.execute_input": "2026-02-10T22:47:34.904705Z", - "iopub.status.busy": "2026-02-10T22:47:34.904436Z", - "iopub.status.idle": "2026-02-10T22:47:34.912563Z", - "shell.execute_reply": "2026-02-10T22:47:34.911611Z", - "shell.execute_reply.started": "2026-02-10T22:47:34.904676Z" + "iopub.execute_input": "2026-04-15T00:20:46.384850Z", + "iopub.status.busy": "2026-04-15T00:20:46.384520Z", + "iopub.status.idle": "2026-04-15T00:20:46.389090Z", + "shell.execute_reply": "2026-04-15T00:20:46.388455Z", + "shell.execute_reply.started": "2026-04-15T00:20:46.384826Z" } }, "outputs": [ { "data": { "text/plain": [ - "array([-0.00010969, -0.00011732, -0.0001238 , ..., 0. ,\n", + "array([-0.00123436, -0.00105846, -0.00090402, ..., 0. ,\n", " 0. , 0. ], shape=(64003,))" ] }, - "execution_count": 26, + "execution_count": 27, "metadata": {}, "output_type": "execute_result" } @@ -867,27 +874,27 @@ }, { "cell_type": "code", - "execution_count": 27, + "execution_count": 28, "id": "05ef6fdf-55c0-4911-9ac8-2041af49b3cd", "metadata": { "execution": { - "iopub.execute_input": "2026-02-10T22:47:34.913406Z", - "iopub.status.busy": "2026-02-10T22:47:34.913089Z", - "iopub.status.idle": "2026-02-10T22:47:34.937032Z", - "shell.execute_reply": "2026-02-10T22:47:34.935709Z", - "shell.execute_reply.started": "2026-02-10T22:47:34.913318Z" + "iopub.execute_input": "2026-04-15T00:20:46.389690Z", + "iopub.status.busy": "2026-04-15T00:20:46.389501Z", + "iopub.status.idle": "2026-04-15T00:20:46.416993Z", + "shell.execute_reply": "2026-04-15T00:20:46.416244Z", + "shell.execute_reply.started": "2026-04-15T00:20:46.389668Z" } }, "outputs": [ { "data": { "text/plain": [ - "{'density': array([-0.00010969, -0.00011732, -0.0001238 , ..., -0.00050627,\n", - " 0.00065019, -0.00043858], shape=(64000,)),\n", + "{'density': array([-0.00123436, -0.00105846, -0.00090402, ..., -0.00049355,\n", + " 0.00065683, -0.00043417], shape=(64000,)),\n", " 'dummy': array([0., 0., 0.])}" ] }, - "execution_count": 27, + "execution_count": 28, "metadata": {}, "output_type": "execute_result" } @@ -899,26 +906,26 @@ }, { "cell_type": "code", - "execution_count": 28, + "execution_count": 29, "id": "d20f5357-efd0-42cb-a156-90fcd6b41f0b", "metadata": { "execution": { - "iopub.execute_input": "2026-02-10T22:47:34.944173Z", - "iopub.status.busy": "2026-02-10T22:47:34.938130Z", - "iopub.status.idle": "2026-02-10T22:47:34.952209Z", - "shell.execute_reply": "2026-02-10T22:47:34.950516Z", - "shell.execute_reply.started": "2026-02-10T22:47:34.944113Z" + "iopub.execute_input": "2026-04-15T00:20:46.417664Z", + "iopub.status.busy": "2026-04-15T00:20:46.417455Z", + "iopub.status.idle": "2026-04-15T00:20:46.423410Z", + "shell.execute_reply": "2026-04-15T00:20:46.422088Z", + "shell.execute_reply.started": "2026-04-15T00:20:46.417641Z" } }, "outputs": [ { "data": { "text/plain": [ - "array([-0.00010969, -0.00011732, -0.0001238 , ..., -0.00050627,\n", - " 0.00065019, -0.00043858], shape=(64000,))" + "array([-0.00123436, -0.00105846, -0.00090402, ..., -0.00049355,\n", + " 0.00065683, -0.00043417], shape=(64000,))" ] }, - "execution_count": 28, + "execution_count": 29, "metadata": {}, "output_type": "execute_result" } @@ -930,31 +937,31 @@ }, { "cell_type": "code", - "execution_count": 29, + "execution_count": 30, "id": "70b2b5ea-d6dd-4cf3-855c-9e8fd600c7cd", "metadata": { "execution": { - "iopub.execute_input": "2026-02-10T22:47:34.954212Z", - "iopub.status.busy": "2026-02-10T22:47:34.953168Z", - "iopub.status.idle": "2026-02-10T22:47:35.127163Z", - "shell.execute_reply": "2026-02-10T22:47:35.126443Z", - "shell.execute_reply.started": "2026-02-10T22:47:34.954180Z" + "iopub.execute_input": "2026-04-15T00:20:46.426870Z", + "iopub.status.busy": "2026-04-15T00:20:46.426579Z", + "iopub.status.idle": "2026-04-15T00:20:46.580476Z", + "shell.execute_reply": "2026-04-15T00:20:46.579223Z", + "shell.execute_reply.started": "2026-04-15T00:20:46.426842Z" } }, "outputs": [ { "data": { "text/plain": [ - "(,)" + "(,)" ] }, - "execution_count": 29, + "execution_count": 30, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -984,7 +991,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.13.9" + "version": "3.14.3" }, "widgets": { "application/vnd.jupyter.widget-state+json": {