diff --git a/.github/workflows/tests.yml b/.github/workflows/tests.yml index 3a0cf634..b5bca57a 100644 --- a/.github/workflows/tests.yml +++ b/.github/workflows/tests.yml @@ -4,7 +4,6 @@ # - Compute test coverage and submit to coveralls.io # - Also config for macOS and/or Windows # - Also config for conda -# - Lint name: CI tests @@ -19,6 +18,19 @@ on: - '*' jobs: + lint: + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v4 + - name: Set up Python + uses: actions/setup-python@v5 + with: + python-version: "3.12" + - name: Install ruff + run: python -m pip install ruff + - name: Run ruff + run: ruff check src tests + bundled: runs-on: ubuntu-latest @@ -28,15 +40,15 @@ jobs: python-version: ["3.10", 3.11, 3.12] steps: - - uses: actions/checkout@v2 + - uses: actions/checkout@v4 - name: Set up Python ${{ matrix.python-version }} - uses: actions/setup-python@v2 + uses: actions/setup-python@v5 with: python-version: ${{ matrix.python-version }} - name: Install dependencies run: | python -m pip install --upgrade pip setuptools - python -m pip install -e . + python -m pip install -e ".[dev]" - name: Launch tests run: | - pytest + pytest --cov=src --cov-report=term diff --git a/.gitignore b/.gitignore index 84130802..dbb2afcd 100644 --- a/.gitignore +++ b/.gitignore @@ -147,3 +147,6 @@ docs-generated/ # mergetoolfiles *.orig + +# Stray test artifact +PET-test-log diff --git a/CHANGELOG.md b/CHANGELOG.md new file mode 100644 index 00000000..b3bc8876 --- /dev/null +++ b/CHANGELOG.md @@ -0,0 +1,973 @@ +# Changelog + +All notable changes to PET are recorded here. + +The format follows [Keep a Changelog](https://keepachangelog.com/en/1.1.0/), +and versions follow [Semantic Versioning](https://semver.org/spec/v2.0.0.html). + +## [Unreleased] + +### Added +- **`GenOpt` is back**, on `OptimizerBase`, together with the `CMA` covariance-matrix adaptation it uses. Both were removed during the popt restructuring — `GenOpt` by `a6938529` with nothing put in its place, `cma.py` later as code with no remaining caller — while `src/popt/README.md` went on advertising the method. It draws from `GeneralizedEnsemble`'s marginals and advances the sampling distribution along with the controls: `theta` follows its own gradient at `alpha_theta`, and the correlation matrix follows `corr_adapt`, which is either a `CMA` instance or any callable. `GeneralizedEnsemble.mutation_gradient` and `.mutation_hessian` had survived the restructuring with no consumer; this is the consumer. `mutation_gradient` gains `return_ensembles=True`, returning `(nat_grad, {'gaussian': enZ, 'objective': enF})`, so the CMA path reuses the ensemble the gradient came from instead of drawing and simulating a second one. Two fixes over the version that was removed: `alpha_corr` is read from `alpha_corr` rather than from `alpha_theta`, so it is no longer silently ignored, and the optimizer no longer runs itself from its own constructor — call `run_optimization()` or `GenOpt.minimize(...)`, as with every other optimizer here. +- **`analysis = "subspace2"`**, the ensemble-transform IES of Raanes, Stordal & Evensen (2019), on ES-MDA, LM-EnRML and GN-EnRML. It solves for the `ne × ne` transform `W` directly, starting from `W = I`, and uses the analytic data covariance through `scale_data` rather than the ensemble representation `E Eᵀ` that `subspace` uses — so it takes no SVD and reads neither `energy` nor `iteration.energy`. It is exactly `margis` with the marginalised error scale `Ratio` fixed at 1, i.e. with the data uncertainty taken as known; `tests/assimilation/test_subspace2.py` pins that identity bit-for-bit. Ported from upstream 6f313d7, with two departures: the transform is initialised at iteration 0 rather than 1 (schemes here count from 0, so the reference version never initialises and dies on the first call), and the whitened observations are recomputed every call instead of cached on the first. ES-MDA redraws its observations and their scale at every assimilation step, so the cache would drive later steps with the first step's observations whitened by the first step's factor — the run still completes and the misfit still falls, which is why it would have gone unnoticed. On the characterisation case it is the difference between a posterior misfit of 175.7 and 201.1; the cached, lower number is the wrong one. The 39 existing golden arrays are unchanged. + +### Fixed +- **A `LOCALIZATION` block that names no mode runs again.** Localization was selected by which keyword appeared in the block -- `autoadaloc`, `localanalysis`, `dist_loc`, a pickled mask file, or none of them for the parallel update -- and the rewrite replaced that with a required `name` key. Every config written before the rewrite therefore stopped at startup with `Localization config has no 'name'`, naming three strings its author had never seen, and `pet migrate` did not cover the block. The mode is now inferred from the keyword that used to select it, and an explicit `name` still wins. +- **A crashed simulation costs the optimizer its trial point, not the whole run.** `EnsembleOptimizationBase.function` raised `RuntimeError` whenever `calc_prediction` reported failure, so one control vector the simulator could not run ended the optimization and discarded every iteration before it. It now reports `inf`, which no backtracking step can improve on, so the point is rejected and the run continues from the last good iterate — the behaviour `765d637` removed. A crashed *single-point* evaluation additionally leaves `stateF` at its last good value: the gradient is `enF - repeat(stateF, nr)`, so writing `inf` there would have poisoned every later gradient with `inf`/`NaN` instead of rejecting one point. The separate abort when *every* member of a forecast fails is unchanged — there is nothing left to compute a gradient from. +- **A pickled localization file can be used again.** Those files hold plain dicts keyed by `(data_type, time, parameter)` — `taper_func`, `position`, `range` as `[radius, z_range]`, `anisotropi` as `[ratio, rotation]`, and `file` for the `import` taper. They were loaded and returned unconverted, so the first code to ask for `.taper` raised `AttributeError: 'dict' object has no attribute 'taper'` and no pickled mask file worked at all. They are now converted to `LocalizationEntry`, including older files that wrote `range` as the radius alone. +- **Distance localization builds its operator over the active cells.** `_resolve_mask` returned a mask spanning the whole grid while `_zero_mask` reduced to the active cells, so with an `actnum` a localized parameter contributed one row per grid cell and an unlocalized one a row per active cell. On a 1×10×10 field with 60 of 100 cells active and two parameters the operator came out with 160 rows where the state has 120, and nothing checked, so the mismatch surfaced far from its cause. An all-active `actnum` now gives exactly what passing none gives. +- **`autoadaloc = ` is no longer discarded.** The value is the number of noise standard deviations a correlation must clear -- `nstd` inside the old code -- and it was the value of the `autoadaloc` keyword itself. Only `cutoff` was read, so a config saying `autoadaloc = 2` silently ran at the default of 0.3: no error, a different taper, a different posterior. `cutoff`, `nstd` and `autoadaloc` are all accepted, `cutoff` first. The default stays 0.3; it was 1 before the rewrite, so a block that gave `autoadaloc` as a bare flag with no value tapers differently than it used to. + +### Breaking changes +- **`localanalysis` and the parallel update are refused while the config is read.** Both worked before the update schemes were restructured, and both need the per-subset observation machinery (`_ext_obs`, `current_state`, `pert_preddata`) that the rewrite replaced with a single `DataLayout` built once at setup. `localanalysis` previously reached a branch that left the posterior equal to the prior while still reporting a misfit, and is no longer a registered strategy; naming either now raises `ConfigError` explaining why and naming `autoadaloc` and `distance_loc` as the alternatives. Reimplementing them on the new contract is tracked separately; `analysis_tools.parallel_upd` is left in place for the dormant GIES schemes that still call it. +- **`conv_crit` in the `epf` section means a penalty magnitude, not a state change.** The outer EPF loop used to stop once no control moved more than `conv_crit` relative to its previous value; it now stops once `mean(epf['penalty']) / epf['r']` falls below it. The old test asked the wrong question: it reported success whenever the inner optimizer stalled, however badly the constraints were still violated, and refused to finish while a single control kept jittering. The default is still `1e-5`, so a config written for the old criterion loads unchanged, but the number now carries the units of the objective rather than being dimensionless — check it against your penalty's scale. The objective must write `penalty` into the `epf` dict it is handed; one that does not now raises `KeyError` instead of silently converging on the step size. Ported from upstream 5358e07 and 4b8d878. +- `max_iter` in the `iteration` section is the number of update iterations. It used to count the prior forecast as iteration 0, so `max_iter: 5` performed four updates; the same config now performs five. To keep an existing run as it was, lower `max_iter` by one. The run table, the convergence message and the `assimilation_result_{i}` files already numbered updates from 1 with the prior as 0, and are unchanged. +- `PETStateArray` is gone. The state ensemble is a plain `(nx, ne)` NumPy array; its variable layout is the ensemble's `idX` dictionary, wrapped by `misc.structures.StateLayout` (`ensemble.state_layout`), which owns what the subclass carried: `to_dict(enX)`, `member_dicts(enX)` (was `to_list_of_dicts`), `clip(enX, limits)` (was `clip_matrix`), and the constructors `StateLayout.from_dict(...)` and `StateLayout.from_prior_info(...)`, both returning `(matrix, layout)`. The subclass copied the row map onto every slice and view, so a five-row slice still claimed the full layout, and lost it on unpickling; twenty operator overrides existed only so a type checker inferred the subclass. Code that did `enX.to_dict()` or `enX.indices` now goes through the layout. +- Restart is one mechanism: the scheme's checkpoint (`RestartMixin`), driven by `restart`, `restartsave` and `restart_file` in the `[dataassim]` block and written to `_restart.pkl` (default) after the prior forecast and every accepted iteration. The ensemble no longer loads `emergency_dump` when `restart` is set; that file is written only when every realisation of a forecast fails, for inspection. A resumed run continues the interrupted one exactly: the checkpoint carries the loop's bookkeeping, the scheme's declared state (`RESTART_ATTRIBUTES`: perturbed observations, damping, the subspace `W`), and the ensemble's state, prior, forecast, scaling and random stream, so it does not depend on the random state of the resuming process. Before this, the keys never reached the scheme (every scheme passed only zero tolerances to its base), so `restartsave` pickled the ensemble and a `restart` run re-initialised the scheme from scratch. +- `EnOpt` and `SmcOpt` constructors take `(x0, fun, ...)` like `LineSearch`, `TrustRegion` and every `minimize`; they took `(fun, x, ...)`. Callers using the keyword `x=` write `x0=`. +- `OptimizerBase.update_step()` returns a `StepReport(accepted, message)` instead of a bool and commits its point through `_commit_step(x, f, jac=..., hess=...)`; the base then runs the callback, records and saves the result, logs a row (from `log_columns()`) and checks convergence. Custom optimizers built on the old contract need those four changes. +- `SmcOpt` no longer runs the optimization inside its constructor (the `autorun` option is gone); call `run_optimization()` or use `SmcOpt.minimize(...)`, which has not changed. + +- **Config: `daalg` is replaced by `scheme`.** The analysis flavour is a + parameter of an algorithm rather than a separate algorithm, so the + two-element `daalg` key has nothing left to encode. Only its second entry + ever selected the class; the first was a module hint the registry no longer + needs. + + ```toml + # before # after + [dataassim] [dataassim] + daalg = ["esmda", "esmda"] scheme = "esmda" + analysis = "approx" analysis = "approx" + ``` + + Loading a config that still uses `daalg` raises an error showing the rewrite + and naming the migration command. To migrate: + + ```sh + pet migrate my_config.toml # rewrites in place, keeps .bak + pet migrate my_config.toml --dry-run + pet convert my_case.pipt && pet migrate my_case.toml # legacy text configs + ``` + + Existing `.pipt`/`.popt` files are unaffected until converted. + +- **`pipt.loop.assimilation.Assimilate` is removed, with no shim.** Schemes own + their iteration loop now, as popt's optimizers do. The whole `pipt.loop` + package is gone, including the `pipt.loop.ensemble` compatibility shim. + + ```python + # before # after + from pipt.loop.assimilation import Assimilate + scheme = pipt_init.init_da(kd, ke, sim) scheme = ESMDA(kd, ke, sim) + Assimilate(scheme).run() result = scheme.run_assimilation() + ``` + + `pipt_init.init_da(...)` still works and still returns the scheme; only the + driver changed. `Scheme.assimilate(kd, ke, sim)` is the one-line form. + +- **`optimization_loop()` and `assimilation_loop()` are renamed** to + `run_optimization()` and `run_assimilation()`, with no aliases. `_loop` named + the mechanism rather than the job — nobody calls it because they want a loop + — and `assimilation_loop` sat awkwardly beside the `run_forecast` / + `run_prior_forecast` already on the same class. The rename affects both + packages so they keep the same shape. + + ```python + # before # after + enopt.optimization_loop() enopt.run_optimization() + esmda.assimilation_loop() esmda.run_assimilation() + ``` + + The class-level shortcuts are unchanged: `EnOpt.minimize(...)` and + `ESMDA.assimilate(...)` still construct and run in one call. + +- **Per-iteration result files renamed.** `debug_analysis_step_{i}.npz` is now + `assimilation_result_{i}.npz`, the assimilation counterpart of popt's + `optimize_result_{i}.npz`. The files were never a debugging aid — they are + the record of a run, one per iteration, with iteration 0 the prior — and the + old name said otherwise. **Post-processing that globs + `debug_analysis_step_*` must be updated**; nothing can alias a filename. + + The config key that selects them follows: `analysisdebug` is now `savedata`, + again matching popt. The old spelling still works and warns, and + `pet migrate` rewrites it in place alongside `daalg`. There is no `saveit` + switch to go with it: listing variables turns saving on and omitting the key + turns it off, so a config cannot name variables that are silently discarded. + + ```toml + # before # after + [dataassim] [dataassim] + analysisdebug = ["state", "pred_data"] savedata = ["state", "pred_data"] + ``` + + `analysis_tools.save_analysisdebug` is likewise deprecated in favour of + `save_assimilation_result`; the alias writes the new filename, not the old + one. + +- **Eighteen scheme classes collapsed into five, and the per-flavour names + removed.** `ESMDA`, `EnKF`, `ES`, `LMEnRML` and `GNEnRML` are classes taking + `analysis` as an argument, and replace both the factory functions of the + same names and the per-flavour classes (`esmda_approx`, `lmenrml_full`, + ...): each was one line pinning a flavour the constructor argument already + expresses. Use `ESMDA(..., analysis="approx")` and friends instead -- + `registry.get_scheme(scheme, analysis)` still resolves a `(scheme, + analysis)` pair for config-driven code, now to the algorithm class with + `analysis` pre-bound rather than to a stored class per combination. + + Two combinations are not aliases and keep their own classes: `esmda_hybrid` + (multilevel ES-MDA) and `gnenrml_margis` (a private, externally-implemented + strategy) are algorithms in their own right that happen to share a name, + reachable via `registry.get_scheme("esmda", "hybrid")` / + `("gnenrml", "margis")`. `esmda_geo` is gone outright: its `__init__` took + the wrong arguments and referenced an attribute the class never set, so it + could not have been constructed successfully; nothing exercised it. + + Not source-compatible: the removed classes used to *inherit* their + strategy, so `issubclass(esmda_approx, approx_update)` held. The replacement + *holds* one instead. Behaviour and numbers are unchanged -- pinned by the + characterisation suite -- only the type relationship goes. + + Each algorithm class now declares, right on the class, which flavours it + supports and which class handles each -- `ESMDA.COMPATIBLE_ANALYSES = { + "approx": approx_update, "full": full_update, "subspace": subspace_update}` + -- so reading one scheme's source shows everything it supports, with no + registry lookup needed to find out. `EnKF`/`ES` requesting `analysis="full"` + used to resolve to the `approx` strategy only through the per-flavour + classes; requesting it directly on `EnKF`/`ES` ran the (numerically + identical, more expensive) `full` strategy. `EnKF.COMPATIBLE_ANALYSES` + now points `"full"` at the same class as `"approx"`, which is what the + removed classes' docstrings already claimed ("EnKF/ES take a single step, + so full and approx coincide") but did not, in fact, apply to direct + construction. `ES` inherits the dict unchanged, so the fact lives in one + place and applies regardless of entry point. + + `register_strategy` (`pipt.update_schemes.analysis.registry`) no longer + makes a newly registered flavour automatically selectable on an existing + scheme -- each scheme's `COMPATIBLE_ANALYSES` is what a config's `analysis` + key is actually checked against. Add the flavour to a scheme's dict + directly, or register a whole `(scheme, analysis)` combination via + `pipt.update_schemes.registry.register_scheme`. + + `esmda_hybrid` (multilevel ES-MDA) moved off the mixed-in path onto this + same bound-strategy pattern: `hybrid_update` now inherits `AnalysisStrategy` + and `esmda_hybrid.COMPATIBLE_ANALYSES = {"hybrid": hybrid_update}`, in place + of `class esmda_hybrid(hybrid_update, ESMDA)`. Its calling convention + (`update(enX, enY, enE, **kwargs)`) already matched the bound shape; only + the values are lists of per-level matrices rather than single ones, which + the attribute-forwarding that binding relies on does not care about. One + consequence: `esmda_hybrid.COMPATIBLE_ANALYSES` deliberately does *not* + include `approx`/`full`/`subspace` -- those strategies expect a single + `enX`/`proj` matrix, which this scheme's per-level state never gives them; + requesting one now raises a clear error instead of the previous, unrelated + behaviour of silently running the hybrid update regardless of what + `analysis` was asked for. Verified bit-for-bit unchanged against the + pre-conversion code (no committed reference existed to pin, so this was + checked directly rather than through the characterisation suite). + `gnenrml_margis` remains the one scheme still wired up the old way -- see + below. + +- **The config's `analysis` key is no longer overridden by a default.** + `build_scheme`/`ESMDA(...)` took `analysis="approx"` as a parameter default + and never consulted the config, so a config asking for `subspace` silently + built the `approx` scheme through that entry point while `init_da` built the + right one. Precedence is now explicit argument, then config, then `"approx"`. + +- **Analysis strategies moved** from `pipt.update_schemes.update_methods_ns` to + `pipt.update_schemes.analysis`, joining the base class and registry that + already lived there. Modules are renamed to `approx`/`full`/`subspace`/ + `hybrid`/`margis`; the class names are unchanged. + + This affects code outside this repository: `enrml.py` walked + `update_methods_ns` with `pkgutil` so a private namespace package could supply + `margIS_update` alongside what shipped here. A private overlay must now + target `pipt.update_schemes.analysis`, or the module below is used instead — + silently. + + `analysis/margis.py` itself is no longer an inert placeholder: it now + carries a real port of the margIS math from an older layout, with attribute + names (`self.ne`, `self.proj`, `self.lam`, `self.scale_data`) matching this + codebase's current conventions, plus fixes against Stordal, Lorentzen & + Fossum (2023), *Marginalized iterative ensemble smoothers for data + assimilation*: + + - **`GNEnRML.calc_analysis` was missing a branch.** `margIS_update` + delivers its result via `self.W_step` (capital W) -- the ensemble + *matrix* update ("following e.g. Raanes et al. 2019" in the code this + was ported from), reconstructed as + `enX = mean(prior_enX) + prior_enX @ proj * sqrt(ne-1) @ W`. Only the + lowercase `w_step` *vector* update ("following e.g. Evensen et al. 2019", + a different reconstruction for a differently-initialised `W`) had + survived in this codebase's `GNEnRML.calc_analysis`. The first attempt + at a fix renamed `self.W_step` to `self.w_step` to match what existed -- + which was wrong, and confirmed wrong by running it: routed through the + vector-update branch, the assimilation made the misfit *worse* by five + orders of magnitude, unchanged however small the step length shrank -- + the signature of the wrong formula entirely, not a scale problem. Fixed + properly by restoring the missing `hasattr(self, 'W_step')` branch to + `GNEnRML.calc_analysis`, gamma-scaled to match the existing `w_step` + branch's convention, and reverting this file to deliver `self.W_step` as + it always did. + - **The first-call check used the wrong iteration convention.** `if + self.iteration == 1` guarded initialising `current_W`/`current_w`/`D`. + This codebase's schemes count from `self.iteration = 0` (confirmed + against `GNEnRML.__init__` and against `subspace_update`, which checks + `if self.iteration == 0` for the same reason), so initialisation never + ran and the first real call failed outright with `AttributeError: + 'AssimilationEnsemble' object has no attribute 'current_W'`. Fixed to + check `== 0`. + - **The update loop was hardcoded to 70 individual data points**, each its + own "type" of one (`M = 1`), instead of the paper's Eq. 8/9 sum over + actual data types with each type's real count as `M`. Now groups rows by + data type (`self.data_df`'s columns) instead. + - **It carried its own `scale()`**, duplicating `AnalysisStrategy.solve` -- + the same duplication `approx`/`full`/`subspace` had before they were + consolidated onto the shared base. Now inherits `AnalysisStrategy` and + calls `self.solve` directly, picking up the same robustness fix + consolidation made (`np.ndim` instead of `scaling.shape`, so a covariance + passed as a plain list or scalar works). + + That inheritance change surfaced a fifth, pre-existing bug, unrelated to + any of the above: the old `gnenrml_margis(GNEnRML, margIS_update)` listed + `GNEnRML` first, so `StrategyMixin.update` -- reachable through `GNEnRML`'s + own MRO chain -- was what plain attribute lookup actually found, not + `margIS_update.update`, regardless of what `bind_strategy` decided about + `self.strategy`. That `update` raises immediately for a mixed-in flavour, + so the scheme could not run at all, independent of anything above. + + **`gnenrml_margis` is gone.** Once `margIS_update` took the same + `(enX, enY, enE, **kwargs)` shape as every other strategy, mixing it into a + separate class was no longer the only way to wire it up -- and, as the bug + above shows, was actively worse than the alternative. `GNEnRML. + COMPATIBLE_ANALYSES` now has a `"margis"` entry like `"approx"` and friends; + `GNEnRML(..., analysis="margis")` binds `margIS_update` by ordinary + composition, the same way `ESMDA(..., analysis="approx")` binds + `approx_update`, with no MRO shadowing possible because binding never + touches the class hierarchy. `("gnenrml", "margis")` resolves through the + generic `ALGORITHMS` + `COMPATIBLE_ANALYSES` path now, not + `SPECIAL_SCHEMES` -- unlike `("esmda", "hybrid")`, which stays special + because `esmda_hybrid` really is a distinct class (multilevel ES-MDA), not + an alias for an existing one. + + Run against real data for the first time (PIPT's own `TinyBox` tutorial + case, 9 data types across 6 wells): misfit prior 1.96e10, after one + iteration 1.18e8, a 99.4% reduction -- a large, sensible improvement, not + just an absence of errors. Still not a golden reference, though: one run, + one case, no committed values pinning today's numbers the way + `test_numerical_characterisation` does for the other flavours -- see + `pipt.update_schemes.analysis.margis`. + +- **`iterinfo` hooks receive the scheme**, not the removed `Assimilate` object. + Custom `main(self)` hooks reading loop attributes need adjusting. + +- **Scheme machinery moved to `pipt.update_schemes.core`** — + `AssimilationSchemeBase`, `AnalysisBindingMixin`, `AssimilationWorkflowMixin` + — so `pipt.update_schemes` lists algorithms rather than mixing them with the + scaffolding they stand on. + +- **`log_update()` moved to the scheme base.** ES-MDA, LM-EnRML and GN-EnRML + each carried a near-identical 14-line copy differing only in the trailing + column -- `α`, `λ` and `γ` respectively. The base now builds the shared row + and calls `log_columns()`, which a scheme overrides to add its control + parameter: + + ```python + def log_columns(self, prior_run: bool = False) -> dict: + return {"λ": self.lam} + ``` + + The rendered table is unchanged, verified by capturing every row a run + logs before and after. + +- **`forecast()` takes the state to predict on.** It used to read + `ensemble.enX_temp`, falling back to `enX` -- an ambient slot a scheme had + to park its trial state in before calling, and clear afterwards. It is now + `ensemble.forecast(enX)`, and `run_forecast(state) -> state` hands back the + state actually used. `after_forecast(state) -> state` and + `remove_outliers(state) -> state` follow suit: outlier replacement resamples + members, so it returns the resampled state rather than writing it back to + whichever slot happened to be set. `enX_temp` is gone from the + scheme/ensemble contract entirely; it survives only inside the (already + unimplemented) local-analysis path. + +- **`update_step()` returns a `StepReport`, not a `bool`.** The loop needed + four things back from a step but could only see one of them in the + signature; the rest were attribute side effects a scheme could silently + forget, leaving `data_misfit` as `None` and convergence permanently + unreachable. A scheme now returns + + ```python + StepReport(accepted=..., misfit=...) # why_stop optional + ``` + + where `state` is the state the attempt produced and `misfit` is the + *per-realisation* array. The loop commits `state` when `accepted` and + clears the trial either way, so a scheme no longer has to remember + `ensemble.enX = deepcopy(enX_temp); ensemble.enX_temp = None` — forgetting + that gave a run which iterated and logged normally while returning the + prior untouched. The loop derives + `data_misfit` and `data_misfit_std` from it, so those three can no longer + disagree — as they previously could after a rejected LM-EnRML step, which + restored the scalar but left `ensemble_misfit` holding the rejected attempt. + Schemes no longer set `step_accepted`, `data_misfit`, `data_misfit_std` or + `ensemble_misfit` at all. + +- **One name for the analysis concept.** The code called the same thing an + "analysis" (the config key, `COMPATIBLE_ANALYSES`) and a "strategy" (the + base class, the registry, the bound attribute). It is now "analysis" + throughout: + + | before | after | + | --- | --- | + | `AnalysisStrategy` | `AnalysisBase` | + | `StrategyMixin` | `AnalysisBindingMixin` | + | `pipt.update_schemes.core.strategy` | `pipt.update_schemes.core.analysis_binding` | + | `STRATEGIES` | `ANALYSES` | + | `get_strategy` / `register_strategy` / `available_strategies` | `get_analysis` / `register_analysis` / `available_analyses` | + | `bind_strategy()` | `bind_analysis()` | + | `scheme.strategy` (object) + `scheme.analysis` (name) | `scheme.analysis` (object) + `scheme.analysis_name` (name) | + + Note the last row: `analysis` is both the constructor argument (a flavour + *name*) and the attribute holding the resulting object, the way + `Model(optimizer="adam").optimizer` is an optimizer instance. + `pipt.localization` keeps its own, unrelated use of "strategy". + +- **`score_prior()` is replaced by `score()`.** Every scheme spelled out its + own prior-scoring hook: the misfit expression, then the same five + assignments around it. The expression is now a `score()` method and the + bookkeeping belongs to the base, which calls it through + `record_prior_score()` before the loop. `run_prior_forecast()` went the same + way -- it wrapped a single line that now sits in the loop that used it. + + ```python + # before: once per scheme + def score_prior(self): + misfit = at.calc_objectivefun( + self.enObs, self.pred_data.to_matrix(), self.cov_data) + self.ensemble_misfit = misfit + self.data_misfit_mean = np.mean(misfit) + self.prior_data_misfit_mean = np.mean(misfit) + self.data_misfit_std = np.std(misfit) + + # after: the expression only, and only when it differs from the default + def score(self, pred_data=None): + pred = self.pred_data if pred_data is None else pred_data + return at.calc_objectivefun( + self.enObs_conv, self._as_matrix(pred), self.cov_data) + ``` + + `score()` is called for the prior *and* for every attempt inside a step, so + a scheme has one definition of its own misfit instead of two copies that + could drift. The base implements the default — perturbed observations + `enObs` against `cov_data` — so a scheme that binds those needs no override + at all; ES-MDA overrides it to score against its un-inflated `enObs_conv`, + and the EnKF family to use `scale_data`. A scheme with nothing to score + returns `None` and the base leaves its misfit bookkeeping alone. + + Prior scoring now also logs its row through `log_update(prior_run=True)` for + every scheme, so the EnKF and ES print an iteration-0 row in the run table + where they previously printed a one-line info message. + +- **The damping loop moved into `update_step()`.** LM-EnRML and GN-EnRML used + to iterate λ and γ through the *base* loop: reject the step, return + `accepted=False`, and let `run_assimilation` retry at the same iteration + number. The retry now happens inside `update_step()`, so one call is one + iteration however many attempts it takes — the shape popt's optimizers + already had, where `EnOpt.update_step` backtracks over its own step length + before returning. + + The sequence of analyses, forecasts and λ updates is unchanged, and the + numerical characterisation tests confirm the schemes produce identical + numbers. What changes is where the loop lives, and how a scheme that cannot + improve gives up: both schemes take a new `max_inner_iter` option + (default 10) in the `iteration` block and stop with `why_stop['inner_stop']` + when they exhaust it. GN-EnRML has no `gamma_min`, so previously it kept + shortening its step until the base loop's `max_rejected` valve fired after + `10 * max_iter` attempts; it now gives up after 10 consecutive failures. + + With the retries inside the step, the base loop no longer counts rejections: + `max_rejected` and its "stopped after N consecutive rejected steps" ending + are gone. A report coming back `accepted=False` now means the scheme has + exhausted its own attempts, so the run stops — asking again would only + repeat the step it just said it could not improve on. Convergence is still + checked on that final report, so a scheme that rejects *and* converges (LM- + EnRML reaching `lambda_max`) is still reported as converged. + +- **The run table is logged by the loop.** `log_update()` was called from + inside each scheme's `score_and_commit`, twelve times across five schemes, + once per *attempt*. `run_assimilation` now logs one row per accepted + iteration, and the schemes do not log at all: + + ```python + # scheme_base.run_assimilation() + if self.step_accepted: + self.log_update(success=True) + self.iteration += 1 + self.after_accepted_iteration() + ``` + + Rejected attempts no longer produce a `Failed` row — with the damping loop + inside `update_step`, those attempts are the scheme's business. The EnKF and + ES, which never called `log_update` at all, now get rows like every other + scheme. `log_columns()` is unchanged and remains how a scheme adds its + control parameter; LM-EnRML and GN-EnRML report the λ and γ the logged + iteration actually ran with, since by the time the loop logs, the scheme has + already adjusted them for the next one. + +- **One class: `AssimilationScheme`.** Schemes used to inherit a combination + of `AssimilationWorkflowMixin` and `AssimilationSchemeBase`, in that order + and no other: the mixin *overrides* five hooks (`after_analysis`, + `after_forecast`, `after_loop`, `after_accepted_iteration`, + `after_prior_forecast`) that the base declared as no-op defaults, so listing + it second silently stopped a run from saving anything. + + The split bought nothing — every shipped scheme wanted both halves — so the + two are now one class named `AssimilationScheme`, and + `pipt/update_schemes/core/workflow.py` is gone. + + ```python + # before # after + from ...core.workflow import AssimilationScheme from ...core import AssimilationScheme, StepReport + from ...core.scheme_base import StepReport + ``` + + `AssimilationSchemeBase` and `AssimilationWorkflowMixin` no longer exist + under any name. Anything subclassing the mixin on its own — a test double, + say — should subclass `AssimilationScheme` and supply an ensemble stand-in, + since `keys_da`, `save_folder` and friends are read-only views of the + ensemble rather than attributes to assign. + + The ensemble collaborator protocol grew accordingly: a scheme now always + carries the workflow, so its ensemble must also expose `keys_da`, `sim` + (for `input_dict`) and `_saving_enabled`. The module docstring lists it. + +- **LM-EnRML's damping factor is `lam_factor`, not `gamma`.** The config key + is unchanged (`lambda_factor`); only the attribute is renamed. `gamma` named + two different quantities in one file -- LM-EnRML's damping multiplier and + GN-EnRML's step length -- which is a poor trap to leave beside two classes + whose inner loops now read almost identically. A `savedata` entry or + `iterinfo` script reading `gamma` off an LM-EnRML scheme should read + `lam_factor` instead. + +- **Empty hook declarations are gone.** The five no-op `after_*` stubs + disappeared with the merge — the workflow bodies took their place — and + `_get_restart_state()` / `_set_restart_state()` moved to + `ensemble.checkpoint.RestartMixin` as defaults, so neither PIPT's schemes + nor popt's `OptimizerBase` declare an empty pair to satisfy the protocol. + Hosts that checkpoint their own state (`EnOpt`, `TrustRegion`, `LineSearch`, + `SmcOpt`) override them exactly as before. + +### Added +- Documentation: a configuration reference (`docs/configuration.md`) listing every key of the `dataassim`, `ensemble`, `optim` and `simulator` sections with meaning and default, and an architecture page (`docs/architecture.md`) describing the layers, the scheme, analysis and optimizer contracts, the data layouts, restart, random numbers, and where a new piece goes. Both are in the site navigation and linked from the README and the developer guide. `popt` exports its public API (`EnOpt`, `LineSearch`, `TrustRegion`, `SmcOpt`, `OptimizerBase`, `StepReport`, `GaussianEnsemble`, `GeneralizedEnsemble`). Every public function and class now has a docstring. +- `misc.structures.DataLayout`: the order of the data vector, derived once from the observed frame (label-major, then data type, empty cells skipped). The ensemble builds it after scaling and exposes `obs_vector`, which the schemes now use in place of `data_df.to_matrix()`; the frame remains as the view (`DataLayout.to_frame`). First step of replacing frame flattening on the analysis path. +- `seed` option in the ensemble config (`[ensemble] seed = 7` for pipt, `options['seed']` for popt). Every draw a run makes -- prior realisations, perturbed observations, outlier and crash replacement, the auto-adaptive localization's shuffle, popt's control perturbations -- now comes from the ensemble's `rng`: a private `numpy.random.RandomState(seed)` when a seed is given, so the run reproduces on its own and leaves NumPy's global state untouched; otherwise the global stream, exactly as before, so `np.random.seed(...)` before a run keeps working and every reference number is unchanged. The geostat sampler PET used for these draws is replicated draw for draw in `misc.sampling.gen_real`, which takes the stream as an argument; geostat remains a dependency for its covariance builder. + +- **Every scheme takes a ready-made `ensemble=`.** The default collaborator + is declared once, as `AssimilationScheme.ENSEMBLE_CLASS`, and built by + `build_ensemble` only when none is handed in; multilevel ES-MDA keeps its + override. Two schemes can share one prior and its forecasts, and a test can + substitute a stand-in without the config, data files and simulator a real + ensemble needs. +- **`pipt.localization.register_localization`.** Strategies are selected from + the `LOCALIZATIONS` table by the config's `name` instead of an `if`/`elif` + chain in the factory, so a new strategy is one registration call; + `available_localizations()` lists them and an unknown name reports them. + +- **`ensemble.protocols.ForwardSimulator`** writes down the simulator + contract the base ensemble drives: `input_dict` and + `run_fwd_sim(state, member_index)` are required, and the docstring lists + the optional hooks (`setup_fwd_run`, `true_order`, `datatype`, + `compute_adjoints`) and the four return shapes the ensemble accepts. It is + a runtime-checkable `Protocol`, so `isinstance(sim, ForwardSimulator)` + works, and a test holds every bundled simulator to it. Until now the + contract could only be recovered by reading `calc_prediction`. + +- **One constructor per algorithm**, with the flavour as an argument, so five + names reach what previously took eighteen: + + ```python + from pipt import ESMDA, available_schemes + scheme = ESMDA(cfg_da, cfg_en, sim, analysis="approx") + available_schemes() # every valid (scheme, analysis) pair + ``` + +- **`pipt.update_schemes.registry`** — an explicit scheme table replacing + dispatch by string surgery. Unknown keys now report the valid alternatives + instead of failing on a missing attribute. Third-party and private schemes + can join via `register_scheme()`. + +- **`AssimilationSchemeBase`** (`pipt.update_schemes.core`) — the PIPT + counterpart to popt's `OptimizerBase`, with a matching contract + (`update_step`/`run_assimilation`/`check_*_convergence`/`assimilate`). The + ensemble is a collaborator rather than a superclass. Every scheme is now + migrated onto it. + +- **`AnalysisStrategy`** (`pipt.update_schemes.analysis`) — shared base for the + approx/full/subspace flavours, the counterpart to popt's `subroutines`. + +- **`pipt.localization`** — replaces the 888-line `cov_regularization` monolith + with a package: an ABC and config builder, one module per strategy, and a + factory dispatching on a `name` attribute. + +- **`pet` command line**: `validate`, `convert`, `migrate`, `version`. + +- **`ensemble.checkpoint.RestartMixin`** — checkpoint/restart logic shared by + PIPT and POPT rather than duplicated. + +### Fixed +- Flags written as strings were read by truthiness in several places, so `scale_data = "no"` in a config enabled scaling; every flag is a boolean after the boundary. +- A NaN data variance for an observed cell was silently dropped when the covariance was assembled, leaving it one entry shorter than the observation vector; it is now reported with the cell. +- The `scale` option of `[dataassim]` (multiply the predictions of named data types by a factor) never did anything: it iterated the characters of the column names. It now scales the named rows of the prediction matrix. +- ES-MDA's restart branch referenced an undefined `loop_ind`; the step to resume at now comes from the restored iteration counter. +- `LineSearch(recompute_jac=n)` crashed with `TypeError` on its first retry: the gradient was cleared but not recomputed before the next search direction. +- popt's `save_prediction` option raised `AttributeError`: the base ensemble read `self.ensemble.keys_da`, an attribute it never had. The folder now comes from the ensemble's own options (`savefolder` or `save_folder`, default `Predictions`) and is created before writing. + +- **Six small crash and correctness fixes.** `OpenBlasSingleThread` (and the + other environment context managers) called `os.environ.unsetenv`, which does + not exist, so leaving the block raised whenever the variable had been unset + beforehand; they use `os.environ.pop`. The `lin_1d` and `nonlin_onedimmodel` + test simulators returned their shared output list, so in a serial forecast + every member aliased the last one evaluated; they return a copy. The + localization factory returned `None` for an unknown `name`, which then + failed far away on `localization.name`; it raises with the valid names. The + multilevel row batch could be zero for a single-row state. The outlier + filter called `.ndim` on empty (`None`) cells; they are left alone. And the + end-of-run summary said "Convergence was met." after every run, including + those stopped by the iteration limit; it now says which. + +- **popt: five verified bugs in the numerical subroutines.** Steihaug's + boundary step divided only the square root by the squared direction length, + so every step that hit the trust region had the wrong length. Adam, AdaMax + and Steihaug did not take the backtracking factor, and EnOpt's `TypeError` + fallback halved them on the pre-trial call with factor 1.0, before the + first attempt of every iteration; every step rule now takes `shrink`. + EnOpt's covariance step used `beta * cov` where `beta` is documented as + momentum, shrinking the covariance by `1 - beta` on every accepted step + whatever the gradient said; it is `beta * cov_step` now, like the state + step (no effect at the default `beta = 0`). `LineSearch` passed its + `lsmaxiter` option under a key the line searches never read, so the cap was + always 10. Newton-CG fell off its loop without a `return` when it reached + the iteration cap, handing `None` to a caller that took its norm. And + `clip_state` tested `lb is None` on a whole array, defaulted the upper bound + to `-inf`, and skipped clipping when every bound was 0. + +- **Distance localization placed kernels with their axes swapped.** Kernels + are built `(nx, ny)`-major like the field, but placement unpacked them as + `(ky, kx)`. Square, symmetric kernels away from the edges came out right by + coincidence; an anisotropic kernel raised a shape error everywhere, and an + isotropic one raised near any grid edge where the x and y clipping differed. + Placement now uses the kernel's own axes, with tests at the edges and for + an anisotropic kernel. Existing results for interior, isotropic kernels are + unchanged. + +- **A crashed realisation no longer crashes the run.** The forecast handed + `_replace_failed_simulations` the list of member inputs where it expected + the state matrix, so the first failed member raised `AttributeError` on + `.shape` instead of being replaced. It now receives the trial state, and a + crashed member takes both the prediction and the state of the successful + member drawn to replace it, so the two stay a matched pair. +- **The emergency dump could not pickle the ensemble** when the config asked + for no localization: the stand-in was an instance of an anonymous class + created with `type(...)`. It is now a module-level `NoLocalization` class, + so `emergency_dump` and the restart file work on the runs that need them. + +- **The `approx` and `full` analyses now apply the state scaling.** Both read + a `scale_state` attribute that nothing ever set, so the per-row prior + standard deviation the ensemble computes as `state_scaling` was silently + replaced by ones. For `approx` this cancels exactly (anomalies are divided + by it and the step multiplied back), except in the empirical-covariance + branch of distance localization, whose gain matrix now returns to physical + units like the other branches. For `full` it did not cancel: `Am` was built + from the prior anomalies *multiplied* by the standard deviation while the + anomalies and the prior misfit were left unscaled, so the regularisation + term was off by the squared standard deviation for any variable whose prior + standard deviation was not 1. `Am` is now built in the same scaled space as + the rest of the update. A test checks that rescaling one variable's units + rescales only its rows of the step. The goldens are unchanged: every prior + variance in the characterisation case is 1. + +- **EnKF and ES reported the misfit divided by sigma, not sigma squared.** + `EnKF.score` passed `scale_data` -- the square root (or Cholesky factor) of + the data covariance -- into the objective, which expects a variance. The + override is gone and the family scores with `cov_data` like every other + scheme, so its misfits are comparable with ES-MDA's and mean what the run + table says. The posterior states are unchanged (neither scheme feeds the + misfit back into its update); the ES and EnKF `data_misfit` and + `prior_data_misfit` goldens were regenerated, and the regeneration step + asserted that no state entry moved. + +- **The `subspace` analysis now whitens the predicted anomalies before its + SVD.** It took the SVD of `enY @ PI` while whitening only the residual and + the observation perturbations, so the weight-space step depended on the + units of the data: identical to the pre-refactor `gn_enrml` step when every + data variance was 1, tens of percent apart otherwise. The omission dated + from the strategy's first extraction. With `Y = self.solve(scy, enY @ PI)` + the step matches that transcription to 1e-16 under every scaling tried, and + a scale-invariance test pins it. The `esmda`, `lmenrml` and `gnenrml` + `subspace` goldens were regenerated for this change; the ten other entries + are unchanged. + +- `check_state_convergence()` was inert: `enX_old` was initialised to `None` + and never assigned, so it returned `False` for every scheme. It is the + counterpart of a criterion that works on the popt side, where each optimizer + assigns `xk_old` itself. `run_assimilation` now takes the snapshot centrally + -- one site rather than the seven a per-scheme approach would need -- and + only when `step_tol > 0`, since `enX` is `(nx, ne)` and a copy per attempt + would cost memory for schemes that never use the criterion. Every shipped + scheme still passes `step_tol=0.0`, so behaviour is unchanged; the criterion + now works for anyone who opts in. + +- `step_accepted` could disagree with what `update_step()` returned. Only the + EnRML family maintained it, so for other schemes it stayed at its default of + `True` regardless. The loop now syncs it from the return value. This matters + because a rejected step leaves `enX` untouched: without an accurate flag, + state convergence would read the resulting zero-norm as instant convergence + on every rejection. + +- A converged `LMEnRML`/`GNEnRML` run reported `no stopping reason recorded`. + Both schemes set their converged flag in `score_and_commit()` but never set + `conv_msg`, and they disable the base class's generic criteria -- which are + the only other thing that sets it. `result.message` and the closing log line + now name the criterion that fired (the data-misfit tolerance, or + `lambda_max` for LM-EnRML). + +- `LMEnRML`/`GNEnRML` re-armed a convergence criterion they had just + disabled. Both pass `step_tol=0.0` to switch off the base class's generic + state-change check, then set `self.step_tol` from config (default `0.01`) a + few lines later. Neither reads the value itself — the only consumer is the + check they opted out of. The assignment was vestigial, carried over from the + never-constructed `co_lm_enrml`/`gn_enrml`, and is removed. No behaviour + change today, because `check_state_convergence()` cannot fire at all (see + Known issues). + +- `hybrid_update` carried its own `scale()`, a duplicate of the inherited + `AnalysisBase.solve()` with the arguments in the opposite order. Removed in + favour of `solve`, which additionally accepts a covariance given as a plain + list or scalar. + +- **`savedata` could not record the prior.** Every scheme computed its + prior misfit inside the first `calc_analysis`, which runs *after* the + iteration-0 artifacts are written. So the step-0 file never + contained `ensemble_misfit`, `data_misfit` or `prior_data_misfit`; the run + printed `Cannot save ensemble_misfit, because it is a local variable!` and + carried on. Prior scoring moved to a new `score_prior()` hook that the loop + calls between the prior forecast and `after_prior_forecast`, so step 0 is + described by the same attributes as every later step. Numbers are unchanged + — the characterisation suite pins all nine scheme/flavour combinations. + + Two consequences beyond the saved files: + + - LM-EnRML and GN-EnRML no longer recompute `prior_data_misfit` from the + *rejected* forecast each time they reject their first step. The old + `iteration == 0` branch also re-clobbered `data_misfit` right after + `score_and_commit` had restored it. + - `ensemble_misfit` is now set by EnKF, ES and the multilevel hybrid too; + only ES-MDA and the EnRML pair kept it before. + +- **`save_folder` in a `dataassim` block was silently ignored.** Only the + unspaced `savefolder` was read, so a config using the underscored spelling — + which popt's optimizers accept — wrote to the default `Results` folder + instead. Both spellings are now accepted. +- **ES discarded its own update.** The posterior came back bit-identical to the + prior: the analysis ran, the forecast ran, the log reported a reduced misfit, + but the state promotion sat inside an equal-misfit branch that is essentially + never taken, so `enX_temp` was never committed. Anyone running ES was handed + their prior ensemble back. +- **`enkf` could not run at all.** `check_convergence` read + `self.full_cov_data`, which nothing assigns, so every run raised + `AttributeError` at the end of its first iteration. Commit 6401e6e rewrote the + two sibling call sites to use `scale_data` and missed this one. +- **The multilevel scheme had never completed a run.** Four faults: the level + loop iterated ensemble *sizes* while using the value as an *index*; + `treat_modeling_error` was called before `pred_data` existed; + `calc_analysis` overwrote the step `hybrid_update` had just computed with the + `None` it returns, discarding every update; and `esmda_hybrid` relied on C3 + linearisation to reach the scheme's `__init__`, which stopped happening when + schemes left the ensemble hierarchy. It now runs end to end. +- `gies/rlmmac_update.py` imported `_calc_loc` from the removed + `cov_regularization` module, so importing the GIES-RLMMAC scheme raised + `ImportError`. +- `co_lm_enrml.calc_analysis` added the imported *function* `aug_state` to an + ndarray — there is no local variable of that name — raising `TypeError` on + every run. +- `approx_update.solve` used `A.ndim` where the other two flavours used + `np.ndim(A)`, so a covariance supplied as a list or scalar raised + `AttributeError` with that flavour only. +- `convert_txt_to_yaml` opened its output in binary mode while `yaml.dump` + writes `str`, so every call raised `TypeError`. +- Two uses of `np.bool`, removed in modern NumPy. +- popt's line-search `zoom()` read `aold`/`phi_old` before binding them on the + first branch. + +### Changed +- One configuration boundary, `input_output.config`. Every reader (TOML, YAML, legacy `.pipt`/`.popt`) and every ensemble constructor now passes the sections through `normalize`: the canonical name where a key has had two spellings (`data` for `truedata`, `datavar` for `var`, `savefolder` for `save_folder`, `restart_file` for `restartfile`, `importstate` for `importstaticvar`), booleans for the yes/no flags, dictionaries for the sub-blocks the text format wrote as rows (`iteration`, `mda`, `compress`, `localization`, `multilevel`, `prior_*`), and the field conversions done once. The result is a copy: the ensemble no longer writes `datatype`, `truedataindex` and `assimindex` back into the caller's dictionary, and the helpers that rewrote `iteration`, `mda` and `compress` in place work on copies. Consumers read one name. `validate` replaces the assert-based mandatory-keyword checks: problems are reported by section and key, `pet validate` prints all of them plus keys nothing in PET reads (misspellings), and building an ensemble raises `ConfigError` listing the fatal ones instead of a `KeyError` inside the run. The legacy text reader returns three sections like the others (the third empty) and no longer asserts at read time. `is_enabled` and `list_to_dict` in `extract_tools` are the boundary's `as_flag` and `pairs_to_dict` under their old names. +- Seismic compression happens while the prediction matrix is filled: a compressed data type's raw vintage becomes its leading wavelet coefficients through the same `SparseRepresentation` that reduced the observed vintage, member by member, as the values enter `PredictedData`. The frame-based `post_process_forecast` rewrite is gone; `post_process_forecast` now only enables the `sim2seis` scaling (`scale_results.pkl`), and compression follows from `compress` alone -- a config with `compress` but without `post_process_forecast` used to leave predictions uncompressed against compressed observations. Reconstructions of compressed members are computed only when `saveforecast` will write them (`rec_results.pkl` unchanged). Checked against an AVO case: the reader reproduces a previous run's compressed observations and variances bit for bit (7376 and 7122 coefficients over two vintages), and real member vintages filled through the new path equal their direct compression. +- The ensemble builds `obs_variance` once from the layout (`(nd,)`, or `(nd, ne)` for an empirical error ensemble); the schemes, the observation perturbation and outlier detection read it. `construct_data_cov` is gone. +- The full forecast is kept as what the members returned (`member_outputs`); the `sim_data` frame is built from them when something asks for it -- saving, QA/QC, popt's objective -- and cached until the next forecast. Outlier replacement reorders the raw outputs instead of rewriting every frame cell. Adjoints are an `(nd, nx, ne)` array in layout order, scaled with the data, instead of a frame flattened on every analysis; the frame path stacked every row the simulator reported, not only the observed ones. Adjoint-based updates move at the 1e-13 level: the legacy stack was a non-contiguous array, so the member mean summed in a different order (values are identical; verified on the Van der Pol case). +- Predictions are a `PredictedData` container -- the `(nd, ne)` matrix in `DataLayout` order plus the layout -- filled directly from what each member's simulation returned, scaled as the observations were. The schemes read `pred_data.matrix`; nothing on the analysis path flattens a frame any more. `pred_data.to_frame()` is the frame view (QA/QC, inspection); `sim_data`, the full forecast, is still a frame and still what gets saved. Observations and predictions now share one row order by construction, so an unobserved cell can no longer leave the observation vector shorter than the prediction matrix. The multilevel model-error correction and outlier detection work on the matrices. In `savedata` files, `pred_data` is the matrix rather than a list of records. The seismic compression path (`post_process_forecast`) still runs on the frame and is wrapped into the container afterwards. +- `BaseEnsemble.calc_prediction` is orchestration over four named steps: `_simulator_input` (one dict per member), `_run_members` (the serial, HPC and process-pool backends), `_collect_adjoints` and `_collect_sim_data` (the output coercion and scaling). Same operations in the same order; the characterisation goldens are unchanged, and a new test pins the pooled backend against the serial one. +- `OptimizerBase` owns what the four optimizers each repeated: `minimize`, the starting evaluation (now at the start of `run_optimization()` rather than in the constructor, so an optimizer can be built without evaluating anything), the callback, result recording and saving, the iteration log, and the projected-gradient convergence check (`gtol`). `enopt.py`, `linesearch.py`, `trust_region.py` and `smcopt.py` lost about 500 lines between them. Results are unchanged: 21 deterministic cases across all optimizers, search directions and step rules give bit-identical `x`, `fun`, `nit`, `nfev`, `njev` and `nhev`. +- `LineSearch` results no longer carry `hess` after the first step: the Hessian on hand belonged to the previous iterate and was reported against the new `x`. +- The Steihaug step rule's diagnostic output (a dozen lines per CG iteration, printed unconditionally) is now emitted at `DEBUG` level on the `popt.optimization_methods.subroutines.optimizers` logger; the BFGS 'non-positive curvature' notice is a logging warning instead of a print. +- `restart_sim_results.pkl` (a saved forecast copied to that name so a restarted run can skip the forecast it had already finished) is now honoured only when `restart` is enabled; it used to be consumed by any run that found it in the working directory. Once used it is moved into the results folder as `sim_results.pkl`, where a saved forecast goes, instead of being renamed in the working directory. + +- **Library code keeps to its own logger and raises instead of exiting.** + `PetLogger` gives each log file its own named logger with its own file and + console handlers; it used to call `logging.basicConfig`, which configures + the root logger once per process and does nothing the second time, so a + second logger (popt beside pipt, or a re-run in a notebook) kept writing + into the first file and any application that had touched the root logger + got no file at all. Records still propagate, so root handlers see them. + Reading `save_folder` no longer creates the directory; it is created where + something is written. The `sys.exit` calls in the ensemble (every member + failed), the wavelet compression, the `sevenmountains` objective, popt's + ensemble base and the Steihaug subroutine are exceptions now, and the + remaining `print` calls beside a logger go through it. A `savedata` entry + naming a variable the scheme does not have is a `UserWarning`. The + Gaussian ensemble's `warnings.filterwarnings('ignore')`, which silenced + warnings for the rest of the process, is scoped to the method that needed + it. popt's EPF refresh saved its result to the working directory instead of + `savefolder`. + +- **LM-EnRML and GN-EnRML share one implementation.** `IterativeEnRML` + holds the construction, the analysis call, the retry loop inside + `update_step`, the scoring and the accept/reject bookkeeping the two + schemes had as near-verbatim copies (about 400 lines); each subclass now + supplies only how its control parameter reacts -- LM-EnRML's damping + `lambda` (grows on rejection, stops at `lambda_max`) and GN-EnRML's step + length `gamma` (scales the step, shrinks on rejection) -- through ten small + hooks. A new iterative smoother with a different damping policy is those + hooks and nothing else. Numbers, `why_stop` contents, stop messages and + the run table are unchanged, pinned by the goldens for all six LM/GN pairs; + the one visible difference is that LM-EnRML's "converged after an increase" + log line no longer carries a leading space, since both schemes log it the + same way now. + +- **Analyses return their result instead of writing it onto the scheme.** + `update()` now returns an `AnalysisResult` holding exactly one of `step` + (state space), `w_step` (ensemble-weight space, `W_0 = 0`) or `W_step` + (ensemble-transform space, `W_0 = I`), and the scheme base turns any of them + into the trial state in one place, `propose_state(result, step_scale)`. + Before, `subspace_update` and `margIS_update` assigned `scheme.w_step` / + `scheme.W_step` and returned `None`, `hybrid_update` assigned + `scheme.step`, and four copies of `calc_analysis` chose a reconstruction + with `hasattr` chains -- attributes that were never cleared, so the branch + taken depended on what an earlier flavour had left behind, and a single + letter (`w_step` vs `W_step`) selected a different formula. A plain array + is still accepted as a state-space step, so an analysis written the way + the tutorial shows keeps working. Numbers are unchanged: the goldens for + all thirteen scheme/analysis pairs pass untouched. The `approx` analysis + now raises `NotImplementedError` for the `localanalysis` and + `parallel_update` localizations instead of warning and returning nothing, + which left the posterior equal to the prior. + +- **QA/QC works again, on the current data structures.** `QAQC` was still + written against the pre-refactor layout (lists of dicts for observations, + variances and predictions), and the scheme handed it `ensemble.obs_data` + and `ensemble.datavar`, which no longer exist, so any config with `qa` or + `qc` failed at construction. It now takes the ensemble's frames and adapts + them once, per data type, into the arrays its four diagnostics use; the + diagnostics themselves (coverage, the ES-style Kalman-gain ranking, the + Mahalanobis diagnostic, update statistics) keep their algorithms. Along the + way: the closures over a dozen loop variables became methods with + arguments; the module no longer reseeds the global random state (it uses a + private generator), no longer shells out to ImageMagick (`bbox_inches` + trims the plots), and no longer needs OpenCV (one HLS colour conversion, + now a few lines of numpy, so `opencv-python` is dropped); `actnum` is read + from the config's `actnum` file rather than from the working directory; + outputs go to `QAQC/` under the run's save folder; the localization used + by the gain diagnostic is the scheme's own; and the level-2 and level-3 + Mahalanobis scores, the grid-dimension lookup for field plots and the + cross-plots with fewer than four data are fixed. Multilevel ensembles are + refused with a clear message: that branch could never run (`ne` was 0). + Unit tests cover the adapter and each diagnostic on hand-built frames, and + an end-to-end test runs `qa` and `qc` through ES-MDA and LM-EnRML. + +- The characterisation suite pins thirteen `(scheme, analysis)` pairs instead + of eight: LM-EnRML and GN-EnRML with `full` and `subspace`, and GN-EnRML with + `margis`, are now under golden reference for the first time. The reference + file was regenerated to add them; the eight existing entries moved by at + most 3e-13 relative, the floating-point noise from the `eigh` and column-sum + changes in the analysis kernel accumulated over three iterations. + +- Tests run in a temporary directory by default (a suite-wide fixture in + `tests/conftest.py`), so no test writes into the repository or the launch + directory. The three end-to-end pipeline tests are seeded and carry a + `slow` marker for `pytest -m "not slow"`. CI + reports line coverage (`pytest-cov` is in the `dev` extra). + +- **`co_lm_enrml` and `gn_enrml` are constructible and selectable again.** + Both had been left in `enrml.py` as pre-refactor bodies that could not be + constructed (a one-argument `__init__` against a three-argument parent) and + read ensemble attributes that no longer exist. Neither was a distinct + algorithm: `co_lm_enrml` only ever mixed the approximate analysis into + LM-EnRML, and `gn_enrml`'s inline weight-space update is the `subspace` + analysis with GN-EnRML's step-length schedule under the name `lambda`. They + are now thin subclasses -- `co_lm_enrml` is `LMEnRML(analysis="approx")`, + `gn_enrml` is `GNEnRML(analysis="subspace")` -- registered under their own + names so a migrated config saying `scheme = "co_lm_enrml"` or + `scheme = "gn_enrml"` runs, with a test that their results are identical to + the algorithm they alias. Asking either for a different flavour raises the + registry's usual "no such flavour" error. + +- **Packaging and import time.** `mako`, `psutil` and `six` are no longer + dependencies: nothing in PET imports the first two, and `six` served only + Python 2 shims in the vendored Eclipse reader, now written with the + standard library. `geostat` is pinned to a commit instead of tracking + `main`, so a fresh install gets the code the tests were run against. + `import pipt` no longer imports matplotlib, OpenCV or PyWavelets: QA/QC and + sparse compression import them when a run asks for them, and + `misc.structures` imports geostat only when it generates a prior. Cold + import time drops from about 0.85 s to 0.5 s. + +- **`truncSVD` keeps at least the requested energy fraction.** For + `energy=e` the rank used to be the index at which the cumulative + singular-value fraction first *reaches* `e`, which keeps everything before + that point and so always retained *less* than `e`. It is now that index plus + one, so the retained fraction is the first value at or above `e` -- the + reading anyone gives "retain 98 percent", the scikit-learn convention, and + what `full_update.ext_Am` in the same package already did, so the two + truncations inside one `full` analysis now agree. + + ``` + S = [3, 2, 1], energy = 0.8 + before: rank 1, retains 0.50 after: rank 2, retains 0.83 + ``` + + Two edge cases change with it. `energy=1` fell into the percentage branch + and meant 1 percent, keeping a single singular value; `1` and `100` now both + mean keep everything, with the fraction/percentage split at `energy > 1`. A + zero spectrum keeps everything instead of dividing by zero. + + **Every analysis keeps one more singular value than before at the same + `trunc_energy`**, so posteriors shift -- by up to 5.7 percent in the + synthetic characterisation case. No config needs changing. The + characterisation reference and the `test_lin_1d` expected values were + regenerated for this change and nothing else. The fraction is still of the + singular values themselves (the nuclear norm), not their squares; switching + to Frobenius energy would be a modelling change and is not made here. + +- **A scheme reaches its ensemble through declared properties, not + `__getattr__`.** Reads a scheme does not own (`enX`, `pred_data`, + `keys_da`, `localization`, ...) were forwarded to the ensemble by a blanket + `__getattr__`, which resolved *any* name, was invisible to `dir()`, + autocompletion and type checkers, and silently absorbed typos. Each of the + 25 names that actually crosses that boundary is now an explicit `property` + on `AssimilationSchemeBase`: 21 read-only, plus `cov_data`, `scale_data`, + `proj` and `Am`, which a scheme may legitimately compute for itself and so + have setters. Reading is unchanged (`self.enX` still works everywhere); + *assigning* a read-only one now raises `AttributeError` instead of quietly + creating a shadow the forecast would never see. Ensemble state is still + written explicitly through `self.ensemble. = ...`. + +- `logit` and `logger_name` are real `[dataassim]` options. Both were + documented on the scheme base but could never take effect: the ensemble + built its logger unconditionally, hardcoded to `assim.log`, and every scheme + overwrote the scheme-side logger with the ensemble's. The ensemble now + honours both, defaulting to `ASSIM.log`, and `logit = false` installs a + no-op logger so no file is created at all. + +- Packaging: corrected the license path (pointed at a nonexistent + `LICENSE.txt`), moved test tooling to a `dev` extra, added classifiers and a + supported-Python floor matching CI. +- CI runs a lint job, previously a `# TODO: Lint` comment. +- Removed 71 unused imports; replaced 33 bare `except:` clauses so + `KeyboardInterrupt`/`SystemExit` are no longer swallowed. `ruff check src` is + clean and enforced. +- The legacy `.pipt`/`.popt` parser's nested try/except cascade was rewritten as + named helpers with identical behaviour. + +### Removed +- `read_config.check_mand_keywords_fwd/da/opt/en`; `input_output.config.validate` is the check. +- The schemes' `max_iter` attribute. It existed only to derive `maxiter`, the loop's budget of updates, by subtracting the prior forecast the legacy loop counted as iteration 0. The config key `max_iter` and its meaning are unchanged. +- `pipt.ensembles.CompressionMixin` and its `compress_manager`, which rewrote the observation, variance and prediction frames cell by cell. +- `misc.read_input_csv`'s module-level readers (`read_data_df`, `read_var_df`, `read_data_csv`, `read_var_csv`, `convert_to_array`, `to_array_if_sequence`, 470 lines): nothing called them; `DataReader` is the reader. +- `BaseEnsemble.load()` and the `if self.restart is False:` guards around every scheme's and the ensemble's initialisation, which were always true. Construction now always initialises; a checkpoint is overlaid afterwards when `run_assimilation()` starts. + +- `opencv-python` is no longer a dependency; QA/QC was its only user. + +- `analysis_tools.screen_data`, whose only callers were the two unreachable + `screendata` branches above; it also read `cov_data.p` from the working + directory across iterations. + +- **`pipt.misc_tools.ensemble_tools` keeps only `matrix_to_dict`.** + `matrix_to_list`, `list_to_matrix` and `generate_prior_ensemble` had no + callers, and `clip_matrix` duplicated `PETStateArray.clip_matrix` line for + line; EnKF, its one caller, now clips through the state array's method like + every other scheme (checked identical on tuple, dict and list limits). + +- **Twelve unreferenced functions in `pipt.misc_tools.analysis_tools`**: + `data_mismatch`, `calc_crosscov`, `update_datavar`, + `extract_tot_empirical_cov`, `calc_kalmangain`, `calc_subspace_kalmangain`, + `compute_x`, `resample_state`, `block_diag_cov`, `calc_kalman_filter_eq`, + `subsample_state` and `get_obs_size`. Their last callers were the + pre-refactor `co_lm_enrml`/`gn_enrml` bodies; the Kalman-gain trio was the + superseded predecessor of the `analysis` package. The module's private + `_is_enabled` was a copy of `extract_tools.is_enabled` and is gone too. + +- **Dead code with no callers anywhere in the repository**, confirmed by grep + over src, tests and docs: `pipt.misc_tools.data_tools` (every function + duplicated a `PETDataFrame` method); `popt.misc_tools.basic_tools` + (duplicated `input_output.get_ecl_key_val`); the `CMA` class in + `popt.optimization_methods.subroutines`; the `lmenrmlMixIn`, + `gnenrmlMixIn`, `esmdaMixIn`, `enkfMixIn` and `esMixIn` aliases; six + functions in `popt.misc_tools.optim_tools` (`aug_optim_state`, + `update_optim_state`, `corr2BlockDiagonal`, `time_correlation`, `corr2cov` + and `get_optimize_result`, the last of which built its result with `eval` + and referenced a module that no longer exists); the empty + `pipt.update_schemes.update_methods_ns` directory; and a never-collected + plotting helper in `test_autoadaloc.py` together with the ruff exemption + that existed only for it. Code outside this repository that imported any of + these should use the surviving equivalent: the `PETDataFrame` methods for + `data_tools`, `get_ecl_key_val` for `basic_tools`, and the class names for + the aliases. + +### Known issues + +- **`use_ensemble` in the `compress` section is not supported and now says so.** It + meant: widen the leading wavelet indices with the first forecast, then + compress the observations with them. Observations are perturbed when the + scheme is built, before any forecast exists, and for this option the reader + kept the observed vintage raw while giving it the compressed-length variance, + so the two could never be used together; the perturbation step failed on the + shape mismatch. A config that enables it now gets a `ValueError` explaining + this. Supporting it means perturbing observations after the prior forecast, + the same change `screendata` needs. + +- **`screendata` is not supported and now says so.** Data screening inflates + the variance of observations the ensemble cannot reach, which needs + predictions; observations are perturbed when the scheme is built, before any + forecast has run. The two remaining calls could never have worked (they + passed four arguments to a five-argument function and read an `enPred` the + ensemble never had), so a config that enables the option now gets a + `ValueError` explaining this instead of an `AttributeError`. Supporting it + again means perturbing observations after the prior forecast, which changes + the order of random draws for every scheme. + +- **Local analysis is unsupported, and now refuses rather than misbehaving.** It is + no longer a registered strategy: naming it raises `ConfigError` while the config + is read. What it needs is `LocalAnalysisMixin` (198 lines) rewritten against the + current contract — it indexes `self.state[name]` as a dictionary, calls + `self.update()` expecting `self.step` to appear as a side effect, and needs eight + names that no longer exist anywhere (`_ext_obs`, `current_state`, `pert_preddata`, + `real_obs_data`, `obs_data_vector`, `aug_pred_data`, `enX_temp`, + `set_observations`). Earlier entries here described it as warning and returning + `None`; it did not get that far, since `LocalAnalysisLocalization.__init__` called + a `super().__init__` that takes no arguments and raised `TypeError` on + construction. +- **`es`/`enkf` with `analysis="subspace"`** raise `ValueError: Length of values + (11) does not match length of index (15)`. `esmda/subspace` is unaffected, so + the fault is in the sequential path. +- **The GIES schemes cannot be constructed.** `GIESMixIn.__init__` uses the + pre-ensemble-matrix API (`self.state`, `self.obs_data`) and calls + `self._ext_obs()`, which does not exist. Reproduced unchanged before the + Phase 8 work, so this predates it. +- `docs/tutorials/pipt/TinyBox/tutorial_pipt.ipynb` has been updated to the + current API but **not re-executed** — running it needs the OPM `flow` + simulator through the external `subsurface` package, so its stored outputs + are from the old code. +- `docs/tutorials/popt/5Spot/tutorial_popt.ipynb` targets the current API + (`popt.optimization_methods.LineSearch`, `popt.ensembles.GaussianEnsemble`) + but likewise needs `subsurface.multphaseflow.opm.flow`, which is not a + dependency of this repository, so neither notebook is executed by the docs + build or CI. diff --git a/README.md b/README.md index fcc6c21a..ee11cf9f 100644 --- a/README.md +++ b/README.md @@ -16,7 +16,7 @@ at NORCE Norwegian Research Centre AS. Before installing ensure you have python3 pre-requisites. On a Debian system run: ``` -sudo upt-get update +sudo apt-get update sudo apt-get install python3 sudo apt-get install python3-pip sudo apt-get install python3-venv @@ -41,12 +41,6 @@ python3 -m venv venv-PET source venv-PET/bin/activate ``` -Some additional features might be not part of your default installation and need to be set in the Python (virtual) environment manually: - -``` -python3 -m pip install wheel -``` - If you do not install PET inside a virtual environment, you may have to include the `--user` option in the following (to install to your local Python site packages, usually located in `~/.local`). @@ -61,6 +55,76 @@ python3 -m pip install -e . - The `-e` option installs PET such that changes to it take effect immediately (without re-installation). +To also install the tools needed for running tests and linting locally: + +```sh +python3 -m pip install -e ".[dev]" +``` + +## Documentation + +The [configuration reference](docs/configuration.md) lists every key of the +`dataassim`, `ensemble`, `optim` and `simulator` sections; the +[architecture page](docs/architecture.md) explains how a run is put together +and where a new scheme, analysis, localization, optimizer or simulator goes. + +## Command-line interface + +Installing PET also installs a `pet` command for working with config files: + +```sh +pet validate my_config.toml # check a config file for missing/invalid keys +pet convert my_case.pipt # convert a legacy .pipt/.popt file to .toml (or --to yaml) +pet migrate my_config.toml # update a config file to the current schema +pet version # print the installed PET version +``` + +### Config schema change: `daalg` becomes `scheme` + +The analysis flavour is a parameter of an algorithm, not a separate algorithm, +so the two-element `daalg` key has been replaced by a single `scheme` key: + +```toml +# before # after +[dataassim] [dataassim] +daalg = ["esmda", "esmda"] scheme = "esmda" +analysis = "approx" analysis = "approx" +``` + +`pet migrate` performs this rewrite in place, keeping the original as +`.bak`. Use `--dry-run` to preview. Loading a config that still uses +`daalg` raises an error pointing at the command. For a legacy `.pipt`/`.popt` +file, convert first and then migrate: + +```sh +pet convert my_case.pipt && pet migrate my_case.toml +``` + +The same change is reflected in the Python API, where one constructor per +algorithm now takes the flavour as an argument: + +```python +from pipt import ESMDA, available_schemes + +scheme = ESMDA(cfg_da, cfg_en, sim) # flavour comes from the config's `analysis` +result = scheme.run_assimilation() # the scheme owns its iteration loop + +available_schemes() # every valid (scheme, analysis) pair +``` + +`analysis=` overrides the config when passed. `ESMDA.assimilate(cfg_da, cfg_en, +sim)` is the one-line form for when the scheme object is not needed afterwards; +it returns the same `AssimilationResult`, whose `x` is the posterior ensemble. + +The eighteen per-flavour classes this used to produce (`esmda_approx`, +`lmenrml_full`, ...) are gone: each was a one-line subclass pinning the +flavour a constructor argument already expresses. Use `ESMDA(..., analysis= +"approx")` and friends instead. + +Running a data-assimilation or optimization job itself is still done from a +Python driver script that wires up your forward simulator/cost function -- see +the tutorials below. + ## Examples PET needs to be set up with a configuration file. See the example [repository](https://github.com/Python-Ensemble-Toolbox/Examples) for inspiration. @@ -75,8 +139,8 @@ Some basic plotting functionality is provided [here](https://github.com/Python-E ## Tutorials -- A PIPT tutorial is found [here](https://python-ensemble-toolbox.github.io/PET/tutorials/pipt/tutorial_pipt) -- A POPT tutorial is found [here](https://python-ensemble-toolbox.github.io/PET/tutorials/popt/tutorial_popt) +- A PIPT tutorial is found [here](https://python-ensemble-toolbox.github.io/PET/tutorials/pipt/TinyBox/tutorial_pipt) +- A POPT tutorial is found [here](https://python-ensemble-toolbox.github.io/PET/tutorials/popt/5Spot/tutorial_popt) ## Suggested readings: diff --git a/docs/architecture.md b/docs/architecture.md new file mode 100644 index 00000000..9a630843 --- /dev/null +++ b/docs/architecture.md @@ -0,0 +1,134 @@ +# Architecture + +PET is three layers. `ensemble` is the foundation: the base ensemble that runs +a forward simulator over the members, the checkpoint mixin, the loggers, the +`ForwardSimulator` protocol. `pipt` (data assimilation) and `popt` +(optimisation) build on it and never import each other; `ensemble` imports +neither. `misc` holds the data structures and the observed-data reader, +`input_output` the configuration boundary, `simulator` the analytical models +and the wrappers around external simulators. + +## A run + +1. **Configuration.** `input_output.read_config.read(file)` returns the + problem, simulator and ensemble sections as plain dictionaries in one + canonical form (`input_output.config.normalize`); `validate` says what a run + would fail on. A dictionary built in a script gets the same treatment when + the ensemble is constructed. See the [configuration reference](configuration.md). +2. **Ensemble.** `pipt.ensembles.AssimilationEnsemble(keys_da, keys_en, sim)` + draws or loads the prior (`(nx, ne)` array; its variable rows are a + `StateLayout`), reads the observations, fixes the **data layout** and + builds the observation vector and variance in that order, and sets up + localization and compression. It owns the random stream (`seed`). +3. **Scheme.** `ESMDA(keys_da, keys_en, sim, analysis="approx")` and the + other schemes build the ensemble (or take one passed as `ensemble=`), bind + an analysis object, and `run_assimilation()`: forecast the prior, then call + `update_step()` until a criterion fires or `maxiter` updates are done. + `ESMDA.assimilate(...)` is the one-line form. +4. **Result.** An `AssimilationResult` (`x`, `data_misfit`, + `prior_data_misfit`, `nit`, `success`, `message`, `why_stop`), a + `dict` subclass with attribute access like SciPy's `OptimizeResult`. + +## The scheme contract + +`pipt.update_schemes.core.AssimilationScheme` owns the loop, the convergence +checks (`misfit_tol`, `step_tol`, plus the scheme's own `check_convergence`), +the run table, restart, QA/QC and saving. A scheme supplies: + +- `update_step() -> StepReport(accepted, state, misfit, why_stop)`: one + iteration, retries included (LM-EnRML re-damps inside it). The loop commits + the returned state and misfit; a scheme never assigns them itself. +- `score()`: the per-member data misfit of the current forecast. +- `log_columns()`: its columns of the run table. +- Hooks: `after_prior_forecast`, `after_analysis`, `after_forecast`, + `after_accepted_iteration`, `after_loop`. +- `COMPATIBLE_ANALYSES`: the analysis flavours it accepts. +- `RESTART_ATTRIBUTES`: the attributes a checkpoint must carry for it. + +Registration is one line: `register_scheme(name, analysis, cls)` in +`pipt.update_schemes.registry` (`available_schemes()` lists every pair). The +iterative family shares `IterativeEnRML`, where LM-EnRML and GN-EnRML differ +only in ten small hooks around their control parameter. + +## Analyses + +An analysis (`pipt.update_schemes.analysis`) is a class with +`update(enX, enY, enE, **kwargs) -> AnalysisResult`, returning exactly one of +a state-space `step`, a weight-space `w_step` or a `W_step`. The scheme turns +it into a proposal with `propose_state(result, step_scale)`. The flavours are +`approx`, `full`, `subspace`, `margis` and the multilevel `hybrid`; +`register_analysis` adds one. Analyses read what they need from the scheme: +`state_scaling`, `scale_data`, `proj`, `cov_data`, `trunc_energy`, `lam`. + +## Data on the analysis path + +Everything the analyses see is a matrix in one fixed row order: + +- `DataLayout` (`misc.structures`): the order of the data vector, computed + once from the observed frame -- label-major, then data type, empty cells + skipped. The ensemble exposes `obs_vector` and `obs_variance` built from it. +- `PredictedData`: the `(nd, ne)` forecast filled directly from each member's + simulator output through the layout, scaled as the observations were, with + compressed vintages reduced on the way in. `pred_data.matrix` is what the + schemes read; `pred_data.to_frame()` is the frame view. +- Adjoints: an `(nd, nx, ne)` array in the same rows, when the simulator + computes them. +- `StateLayout`: the `{variable: (start, stop)}` rows of the state array; the + ensemble's `state_layout` converts to and from dictionaries, builds member + inputs for the simulator, and clips to the prior's limits. + +`PETDataFrame` remains as the table observed data arrive in and results are +saved as; it is built from the matrices on demand, never on the analysis path. + +## Forecast + +`BaseEnsemble.calc_prediction(enX)` runs one level: member inputs +(`_simulator_input`), a backend (`_run_members`: in sequence, a local process +pool, or the wrapper's HPC queue), crash replacement, adjoint splitting, and +the raw outputs kept as `member_outputs`. `ForecastMixin.forecast` then fills +`pred_data`, corrects multilevel levels, applies the `scale` option and saves +what was asked for. Outlier replacement (`OutlierMixin`) reorders the raw +outputs and the state together. + +A simulator is anything satisfying `ensemble.protocols.ForwardSimulator`: an +`input_dict` and `run_fwd_sim(state, member_index)` returning one dict per +report point (or a DataFrame), `False` on failure, or `(output, adjoint)`. +`simulator/vanderpol.py` is the smallest complete example. + +## Restart, random numbers, logging + +- One checkpoint per run, on `RestartMixin` (`ensemble.checkpoint`): the + loop's bookkeeping, the scheme's `RESTART_ATTRIBUTES`, and the ensemble's + state, prior, forecast, scaling and random stream, so a resumed run + continues the interrupted one exactly. Driven by `restart`, `restartsave`, + `restart_file`. +- Every draw comes from `ensemble.rng`: a private `RandomState` when the + config gives a `seed`, otherwise NumPy's global stream as before. + `misc.sampling.gen_real` is the Gaussian sampler. +- One named logger per log file (`ensemble.logger.PetLogger`); `NullLogger` + stands in when logging is off. + +## popt + +`popt.optimization_methods.OptimizerBase` has the same shape as the scheme +base: it owns the loop, the starting evaluation, the callback, result +recording, the log and the function, state and projected-gradient checks. An +optimizer implements `update_step()`, committing an improving point with +`_commit_step(x, f, jac=..., hess=...)` and returning a `StepReport(accepted, +message)`, and `log_columns()`. `EnOpt`, `LineSearch`, `TrustRegion` and +`SmcOpt` are exported from `popt`, as are the ensembles that estimate +gradients and Hessians (`GaussianEnsemble`, `GeneralizedEnsemble`). + +## Where a new piece goes + +| Adding | Do | +| --- | --- | +| a scheme | subclass `AssimilationScheme` (or `IterativeEnRML`), implement `update_step`/`score`/`log_columns`, declare `COMPATIBLE_ANALYSES`, `register_scheme` | +| an analysis | subclass `AnalysisBase`, implement `update` returning `AnalysisResult`, `register_analysis` | +| a localization | a builder taking `info` (and `rng`, `data`, ...), `register_localization` | +| an optimizer | subclass `OptimizerBase`, implement `update_step` with `_commit_step`, `log_columns` | +| a simulator | a class with `input_dict` and `run_fwd_sim`; see the protocol's docstring for the optional hooks | +| a config key | read it from the normalised section; add it to `KNOWN_DATAASSIM`/`KNOWN_ENSEMBLE` in `input_output.config` and to the [configuration reference](configuration.md) | + +The two notebooks under *Extending PIPT* in the tutorials walk through the +first two. diff --git a/docs/configuration.md b/docs/configuration.md new file mode 100644 index 00000000..4a4fc110 --- /dev/null +++ b/docs/configuration.md @@ -0,0 +1,207 @@ +# Configuration reference + +A run is described by three sections: the **problem** (`[dataassim]` for +assimilation, `[optim]` for optimisation), the **ensemble**, and the +**simulator** (`[fwdsim]` is accepted as its name too). They can be written in +TOML, YAML or the legacy `.pipt`/`.popt` text format, or built as Python +dictionaries in a script. Whichever way they arrive, `input_output.config` +normalises them once -- canonical key names, booleans for flags, dictionaries +for sub-blocks -- and everything downstream reads that one form. `pet validate +my_config.toml` reports what is missing, by section and key, and points out +keys nothing in PET reads. + +Flags accept `true`/`false`, `yes`/`no` and the Python booleans. A key marked +*presence* is on when it is present at all, whatever its value. + +## `[dataassim]` + +### The problem + +| Key | Meaning | Default | +| --- | --- | --- | +| `scheme` | Algorithm: `esmda`, `es`, `enkf`, `lmenrml`, `gnenrml`. `pipt.available_schemes()` lists every `(scheme, analysis)` pair. | required | +| `analysis` | Analysis flavour the scheme runs: `approx`, `full`, `subspace` (all schemes); `subspace2` (ES-MDA, LM-EnRML, GN-EnRML); `margis` (GN-EnRML). `subspace2` solves for the ensemble transform directly and uses the analytic data covariance, so it reads neither `energy` nor `iteration.energy`. | `approx` | +| `energy` | Truncation energy of the SVD in ES-MDA, ES and EnKF; a fraction, or a percentage when greater than 1. The iterative schemes read `iteration.energy`. | `0.98` | +| `emp_cov` | The variance file holds an ensemble of observation errors; the analyses use that empirical covariance. Flag. | off | + +### Observed data + +| Key | Meaning | Default | +| --- | --- | --- | +| `data` | Observations: a `.csv`, `.pkl` or `.npz` file with one row per report label and one column per data type. A cell may name a `.npz` file holding a vector (seismic). `truedata` is the older spelling. | required | +| `datavar` | Variance file on the same geometry. Each cell is `['abs', v]`, `['rel', percent]`, `['emp', ensemble]` or `['cd', covariance.npz]`. `var` is the older spelling. | required | +| `obsname` | Name of the report-label index (times, dates, steps). Not needed when `data` is a dict carrying `index_name`. | required | +| `datatype` | Data types to assimilate. Normally given in the simulator section and copied here. | from the data file | +| `assimindex`, `truedataindex` | Derived from the data file at load time; a value written here is replaced. | derived | +| `scale_data` | Max-min scale observations and predictions per data type before the analysis. Flag. | off | +| `scale` | `[types, factor]`: multiply the predictions of the named data types by `factor`. | none | +| `remove_outliers` | Replace members whose normalised misfit is more than four standard deviations from the mean after every forecast. *Presence.* | off | +| `actnum` | `.npz` with an `actnum` mask, used by the iterative schemes and QA/QC to map a field back to the grid. | none | + +### Iteration (`lmenrml`, `gnenrml`): the `[dataassim.iteration]` block + +| Key | Meaning | Default | +| --- | --- | --- | +| `max_iter` | Number of update iterations. The prior forecast is not one of them. | required | +| `data_misfit_tol` | Stop when the relative change of the mean data misfit is below this. | `0.01` | +| `energy` | Truncation energy of the SVD; a fraction, or a percentage when greater than 1. | `0.95` | +| `max_inner_iter` | Attempts one iteration may make (tightening the control after each rejected step) before giving up. | `10` | +| `lambda` | LM-EnRML: initial damping. `auto` sizes it from the prior misfit. | `10` | +| `lambda_max`, `lambda_min` | LM-EnRML: bounds on the damping; reaching `lambda_max` stops the run. | `1e10`, `0.01` | +| `lambda_factor` | LM-EnRML: factor the damping is divided (accepted step) or multiplied (rejected step) by. | `5` | +| `gamma` | GN-EnRML: step length. `auto` starts at `0.1`. | `0.2` | +| `gamma_max`, `gamma_factor` | GN-EnRML: bound and update factor for the step length. | `1.0`, `2.0` | + +### ES-MDA: the `[dataassim.mda]` block + +| Key | Meaning | Default | +| --- | --- | --- | +| `tot_assim_steps` | Number of inflated assimilation steps; one update each. | required | +| `inflation_param` | Inflation factor per step (a list) or one factor for all. The inverses must sum to 1. | `tot_assim_steps` for every step | + +### Localization: the `[dataassim.localization]` block + +`name` selects the strategy; `pipt.localization.available_localizations()` +lists them, `register_localization` adds one. All strategies take `field` +(grid dimensions as a list of integers) and an optional `actnum` (`.npz` mask). + +A block that gives no `name` is still understood: the mode is inferred from the +keyword that used to select it — `autoadaloc`, `localanalysis` or `dist_loc` (as a +key or as a bare value), a `.p`/`.pkl` mask file for `distance_loc`, and none of +them for the parallel update. An explicit `name` always wins. + +| `name` | Keys | Meaning | +| --- | --- | --- | +| `autoadaloc` | `threshold` (`adaptive`, `fixed`, `universal`), `cutoff`, `type` (`hard`, `soft`, `sigm`), `projection` (`rank-r`, `ensemble`), `parameters` | Auto-adaptive localization from the correlations the ensemble itself shows. `cutoff` is how many noise standard deviations a correlation must clear (default `0.3`); it is also read from `nstd`, or from the value of `autoadaloc` itself. | +| `distance_loc` | `taper_func` (`gaspari_cohn`, `furrer_bengtsson`, `region`), `entries` (list of rows or a `.csv`) | Distance-based tapering around each datum: per entry a data type, report label, parameter, radius, anisotropy and vertical range. | + +`localanalysis` and the parallel update are **not supported**: both need per-subset +observation machinery the scheme rewrite replaced, and naming either raises a +`ConfigError` saying so. Use `distance_loc` or `autoadaloc` instead. + +### Seismic compression: the `[dataassim.compress]` block + +Observed vintages named in `compress_data` are wavelet-compressed when read, +and every prediction of that data type is reduced to the same leading +coefficients as it enters the prediction matrix. + +| Key | Meaning | +| --- | --- | +| `compress_data` | Data type (or list) to compress. | +| `dim` | Grid dimensions of a vintage. | +| `mask` | One `.npz` (key `mask`) per vintage; a missing file means all cells active. | +| `level`, `wname` | Wavelet decomposition level and PyWavelets wavelet name (`db2`). | +| `threshold_rule`, `th_mult`, `use_hard_th`, `keep_ca` | `universal` or `bayesian` thresholding, its multiplier, hard vs soft thresholding, whether the approximation coefficients are kept. | +| `inactive_value`, `order`, `min_noise`, `colored_noise` | Fill value outside the mask, flatten order (`C`/`F`), noise floor per vintage, per-subband noise estimate. | +| `use_ensemble` | Not supported; refused with the reason. | + +`post_process_forecast` (flag) additionally divides `sim2seis` data types by +the factor in `scale_results.pkl`, when that file is present. + +### Restart + +| Key | Meaning | Default | +| --- | --- | --- | +| `restartsave` | Write a checkpoint after the prior forecast and every accepted iteration. Flag. | off | +| `restart` | Resume from the checkpoint instead of starting. Flag. | off | +| `restart_file` | Path of the checkpoint. `restartfile` is the older spelling. | `_restart.pkl` | + +A resumed run continues the interrupted one exactly: the checkpoint carries the +loop's bookkeeping, the scheme's state and the ensemble's state, prior, +forecast and random stream. + +### Output + +| Key | Meaning | Default | +| --- | --- | --- | +| `savefolder` | Folder for results. `save_folder` is the older spelling. | `Results` | +| `nosave` | Write no result files at all. *Presence.* | off | +| `savedata` | Attribute names saved per iteration to `assimilation_result_{i}.npz` (iteration 0 is the prior); `state` expands to one array per variable. `analysisdebug` is the deprecated spelling. | none | +| `iterinfo` | Python modules (`name.py`) whose `main(scheme)` runs after the prior and every accepted iteration. | none | +| `obsvarsave` | Also save the observed data and variance frames as `obs_data.pkl` and `obs_var.pkl`. Flag. | off | +| `qa`, `qc` | Run quality-assurance plots / quality-control statistics after the prior and every iteration. *Presence.* | off | +| `logit`, `logger_name` | Whether to log, and the log file. | on, `ASSIM.log` | + +`screendata` is not supported and says so. + +## `[ensemble]` + +| Key | Meaning | Default | +| --- | --- | --- | +| `ne` | Ensemble size. | `100` when a prior is generated | +| `state` | State variable name(s). | required (or `controls`) | +| `prior_` | Prior of each state variable; see below. | required unless `importstate` | +| `importstate` | `.npz` with one `(n, ne)` array per state variable, used instead of generating a prior. `importstaticvar` is the older spelling. | none | +| `seed` | Seed for the run's private random stream: prior, perturbed observations, outlier and crash replacement, localization shuffles. Without it NumPy's global stream is used. | none | +| `save_prior` | Write the generated prior as `prior_ensemble.npz`. Flag. | on | +| `sim_limit` | Wall-time limit passed to the simulator. | none | +| `disable_tqdm` | Hide progress bars. Flag. | off | +| `multilevel` | Multilevel ES-MDA: `levels`, `en_size` (members per level), `ml_weights` or `cov_wgt` (weights per level, normalised). | none | +| `savefolder` | Folder for popt's `save_prediction` output. | `Predictions` | + +### `[ensemble.prior_]` + +| Key | Meaning | +| --- | --- | +| `mean` | A number, a list per cell, or a `.npz` holding the mean field. | +| `var` (or `variance`) | Variance per layer. | +| `range` (or `corr_length`), `aniso`, `angle`, `vario` | Correlation length, anisotropy, angle and variogram type (`sph`, `exp`, `gau`) of a field prior. | +| `grid` | `[nx, ny, nz]`; scalars are `[1, 1, 1]`. | +| `limits` | `[lower, upper]` the realisations and every update are clipped to. | + +### popt additions + +| Key | Meaning | Default | +| --- | --- | --- | +| `controls` | `{name: {initial or mean, var/variance or std ('5%' of the range needs limits), limits}}`; values may be `.npy`, `.npz` or `.csv` files. | required | +| `natural_gradient` | Gaussian ensemble: scale the gradient by the covariance. Flag. | on | +| `num_models` | Realisations per control for robust optimisation. | `1` | +| `save_prediction` | Pickle each forecast under `savefolder` with this name. | none | +| `marginal`, `theta` | Generalized ensemble: marginal family (`BetaMC`, `Beta`, `Logistic`, `TruncGaussian`, `Gaussian`) and its parameters. | `BetaMC` | + +## `[optim]` + +Options every optimizer takes (`popt.optimization_methods.OptimizerBase`): + +| Key | Meaning | Default | +| --- | --- | --- | +| `maxiter` | Number of update iterations. | `100` | +| `ftol`, `xtol`, `gtol` | Stop on relative objective change, on state-change norm, on projected-gradient infinity norm. | `1e-5`, `1e-8`, `1e-5` | +| `transform` | Optimise in the unit cube `[0, 1]^n` (needs bounds). Flag. | off | +| `saveit`, `savefolder` | Save the result after every iteration, and where. | off, `Iteration_Results` | +| `restart`, `restartsave`, `restart_file` | Checkpointing, as for the schemes. | off, off, `_restart.pkl` | +| `logit`, `logger_name` | Whether to log, and the log file. | on, `OPTIM.log` | +| `fun0`, `jac0`, `hess0` | Starting values to reuse instead of evaluating. | none | +| `epf` | Exterior penalty: `r`, `r_factor`, `tol_factor`, `conv_crit`, `max_epf_iter`. `conv_crit` is compared against the mean penalty with `r` divided out, so the objective must write `penalty` into the `epf` dict it is handed. | none | + +Per optimizer: + +| Optimizer | Keys | +| --- | --- | +| `EnOpt` | `tol`, `alpha` (or `step_size`), `alpha_cov`, `beta`, `nesterov`, `alpha_maxiter`, `resample`, `cov_factor`, `hessian`, `normalize`, `optimizer` (`GD`, `Adam`, `AdaMax`, `Steihaug`) | +| `GenOpt` | `tol`, `alpha` (or `step_size`), `alpha_theta`, `alpha_corr`, `beta`, `nesterov`, `alpha_maxiter`, `resample`, `cov_factor`, `normalize`, `optimizer` (`GD`, `Adam`). Takes `args = (theta, corr)`, a `jac_mut` mutation gradient, and an optional `corr_adapt` (a `CMA` instance or any callable). | +| `LineSearch` | `step_size`, `step_size_max`, `step_size_adapt`, `c1`, `c2`, `rho`, `lsmaxiter`, `lsmethod` (0 backtracking, 1 Wolfe), `normalize`, `recompute_jac`, `hess0_inv` | +| `TrustRegion` | `trust_radius`, `trust_radius_max`, `trust_radius_min`, `trust_radius_cuts`, `rho_tol`, `eta1`, `eta2`, `gam1`, `gam2`, `resample`, `convergence_criteria` | +| `SmcOpt` | `tol`, `alpha`, `alpha_maxiter`, `resample`, `cov_factor`, `inflation_factor`, `survival_factor`, `best_func` | + +The constructors document each key. + +## `[simulator]` (or `[fwdsim]`) + +PET reads a few keys; the rest belong to the simulator wrapper. + +| Key | Meaning | Default | +| --- | --- | --- | +| `datatype` | Data types the simulator reports, in order. | required | +| `reporttype`, `reportpoint` | Name and values of the report labels: a list, a `.csv`/`.txt`/`.yaml` file, or `{start, end, freq}` for a date range. | required by most wrappers | +| `parallel` | Members run at once in a local process pool; `1` runs them in sequence. | `1` | +| `hpc` | Run the members through the wrapper's HPC queue in batches of `parallel`. Flag. | off | +| `compute_adjoints` | The wrapper returns `(prediction, adjoint)` per member; the adjoints reach the analysis as an `(nd, nx, ne)` array. Flag. | off | +| `saveforecast` | Save each full forecast (`sim_results.pkl`) and the reconstructed compressed vintages (`rec_results.pkl`). *Presence.* | off | + +## Legacy text files + +`.pipt`/`.popt` files keep the ensemble's keys in the `DATAASSIM` block and +lower-case every value, so data-type names written in upper case must match +lower-case columns. `pet convert my_case.pipt` writes the same content as TOML, +and `pet migrate` updates a file from `daalg` to `scheme`. diff --git a/docs/dev_guide.md b/docs/dev_guide.md index e212477c..9db250a2 100644 --- a/docs/dev_guide.md +++ b/docs/dev_guide.md @@ -1,127 +1,148 @@ # Developer guide -## Writing documentation - -The documentation is built with `mkdocs`. +## Repository layout + +PET is one repository holding two toolboxes on a shared foundation. Every +package lives under `src/`. + +| Package | Role | +| --- | --- | +| `ensemble` | The foundation both toolboxes build on: the base ensemble (prior generation, forecast orchestration), checkpoint/restart, logging. It must not import `pipt` or `popt` at module level; `tests/test_import_hygiene.py` enforces this. | +| `pipt` | Data assimilation. Schemes in `update_schemes/`, analysis flavours in `update_schemes/analysis/`, the assimilation ensemble in `ensembles/`, localization in `localization/`, numerical helpers in `misc_tools/`. | +| `popt` | Optimisation. Optimizers in `optimization_methods/`, the ensembles that estimate gradients in `ensembles/`, cost functions in `cost_functions/`. | +| `misc` | Data structures (`PETDataFrame` as the table view, `DataLayout`/`PredictedData` for the data matrices, `StateLayout` for the state's variable rows), the observed-data reader, and vendored Eclipse grid and output readers used by external simulator wrappers. | +| `input_output` | Config parsing (`.toml`, `.yaml`, and the legacy `.pipt`/`.popt` text format) and report-point handling. | +| `simulator` | Small analytical simulators used by the tests and tutorials. Reservoir simulators live in the external SimulatorWrap repository. | +| `pet_cli` | The `pet` command: `validate`, `convert`, `migrate`, `version`. | + +### How a run is put together + +The [architecture page](architecture.md) describes the layers and contracts in +full and the [configuration reference](configuration.md) every key; this is +the short version. + +A **scheme** (`pipt.update_schemes.core.AssimilationScheme`) owns the +iteration loop, the convergence checks and the checkpointing. It holds an +**ensemble** collaborator (`pipt.ensembles.AssimilationEnsemble`) that owns +the state realisations, the observed data and the forward simulator, and it +binds an **analysis** object (`pipt.update_schemes.analysis`) that computes the +update step from the state, predicted-data and perturbed-observation matrices. +Which flavours a scheme supports is declared on the class in +`COMPATIBLE_ANALYSES`; the registry (`pipt.update_schemes.registry`) derives +every selectable `(scheme, analysis)` pair from those tables. Every scheme +also accepts a ready-made `ensemble=`, so two schemes can share one prior +and a test can hand in a stand-in. Localization strategies are selected from +`pipt.localization.LOCALIZATIONS` by the config's `name`; a new one is a +call to `register_localization`. The two notebooks under *Extending PIPT* in +the tutorials walk through adding an analysis and adding a scheme. + +A forward simulator is anything satisfying `ensemble.protocols.ForwardSimulator`: +an `input_dict` and a `run_fwd_sim(state, member_index)` method, plus the +optional hooks the protocol's docstring lists. The analytical models in +`simulator/` are the smallest complete examples. + +`popt` has the same shape: an optimizer +(`popt.optimization_methods.optimizer_base.OptimizerBase`) owns its loop and is +handed `fun`/`jac`/`hess` callables, typically the methods of an ensemble from +`popt.ensembles`. A new optimizer implements `update_step()`, which commits an +improving point with `_commit_step(x, f, jac=..., hess=...)` and returns a +`StepReport`, and `log_columns()` for its row of the log. The base evaluates +the starting point, runs the callback, records and saves the result, logs, +and checks function, state and projected-gradient convergence. -- It should be written in [the syntax of markdown](https://www.markdownguide.org/cheat-sheet/). -- The syntax is further augmented by [several pymdown plugins](https://squidfunk.github.io/mkdocs-material/reference/). -- **Docstrings** are processed as above, but should also - declare parameters and return values in the [style of numpy](https://mkdocstrings.github.io/griffe/reference/docstrings/#numpydoc-style), - and `>>>` markers must follow the "Examples" section. +## Tests -!!! note - You can preview the rendered html docs by running - ```sh - mkdocs serve - ``` +The suite is `pytest`, configured in `pyproject.toml` and run in CI on +Python 3.10 to 3.12. - - Temporarily disable `mkdocs-jupyter` in `mkdocs.yml` to speed up build reloads. - - Set `validation: unrecognized_links: warn` to get warnings about linking issues. +```sh +pytest # everything, about two minutes +pytest -m "not slow" # skip the three end-to-end pipeline tests +pytest --cov=src # with line coverage (pytest-cov is in the dev extra) +ruff check src tests # lint; CI fails on findings +``` -A summary of how to add cross-reference links is given below. +Every test starts in its own temporary directory (`tests/conftest.py`), so a +test may write files freely without touching the repository. -### Linking to pages +`tests/assimilation/test_numerical_characterisation.py` pins the numbers every +shipped `(scheme, analysis)` pair produces on a small Van der Pol case. A +refactor that is meant to preserve behaviour should leave it green. When a +change to the numbers is intended, regenerate the reference deliberately and +say so in the CHANGELOG: -You should use relative page links, including the `.md` extension. -For example, `[link label](sibling-page.md)`. +```sh +python tests/assimilation/test_numerical_characterisation.py --regenerate +``` -The following works, but does not get validated! `[link label](../sibling-page)` +## Changelog -!!! hint "Why not absolute links?" +User-visible changes are recorded in `CHANGELOG.md`, following +[Keep a Changelog](https://keepachangelog.com/). A change that alters results +gets an entry that names the change and states that the reference was +regenerated for it. - The downside of relative links is that if you move/rename source **or** destination, - then they will need to be changed, whereas only the destination needs be watched - when using absolute links. +## Writing documentation - Previously, absolute links were not officially supported by MkDocs, meaning "not modified at all". - Thus, if made like so `[label](/PET/references)`, - i.e. without `.md` and including `/PET`, - then they would **work** (locally with `mkdocs serve` and with GitHub hosting). - Since [#3485](https://github.com/mkdocs/mkdocs/pull/3485) you can instead use `[label](/references)` - i.e. omitting `PET` (or whatever domain sub-dir is applied in `site_url`) - by setting `mkdocs.yml: validation: absolute_links: relative_to_docs`. - A different workaround is the [`mkdocs-site-url` plugin](https://github.com/OctoPrint/mkdocs-site-urls). +The documentation is built with `mkdocs` and the Material theme. - !!! tip "Either way" - It will not be link that your editor can follow to the relevant markdown file - (unless you create a symlink in your file system root?) - nor will GitHub's internal markdown rendering manage to make sense of it, - so my advise is not to use absolute links. +- Pages are [Markdown](https://www.markdownguide.org/cheat-sheet/), augmented + by [several pymdown extensions](https://squidfunk.github.io/mkdocs-material/reference/). +- **Docstrings** are rendered by `mkdocstrings`. Declare parameters and return + values in the [numpy style](https://mkdocstrings.github.io/griffe/reference/docstrings/#numpydoc-style), + and put `>>>` examples under an "Examples" heading. -### Linking to headers/anchors +!!! note + Preview the rendered site with + ```sh + mkdocs serve + ``` + Temporarily disable `mkdocs-jupyter` in `mkdocs.yml` to speed up reloads, + and set `validation: unrecognized_links: warn` to surface broken links. -Thanks to the `autorefs` plugin, -links to **headings** (including page titles) don't even require specifying the page path! -Syntax: `[visible label][link]` i.e. double pairs of _brackets_. Shorthand: `[link][]`. -!!! info - - Clearly, non-unique headings risk being confused with others in this way. - - The link (anchor) must be lowercase! +### Linking to pages -This facilitates linking to +Use relative page links including the `.md` extension, for example +`[link label](sibling-page.md)`; these are validated by the build. Absolute +links are not, and neither GitHub's Markdown rendering nor an editor can follow +them, so avoid them. -- **API (code reference)** items. - For example, ``[`da_methods.ensemble`][]``, - where the backticks are optional (makes the link _look_ like a code reference). -- **References**. For example ``[`bocquet2016`][]``, +### Linking to headers and API items -### Docstring injection +Thanks to the `autorefs` plugin, a heading anywhere in the site can be linked +without its page path: `[visible label][anchor]`, or the shorthand +`[anchor][]`. Anchors are lowercase. This also covers -Use the following syntax to inject the docstring of a code object. +- **API items**, for example ``[`pipt.update_schemes.esmda.ESMDA`][]``, and +- **references**, for example ``[`chen2013`][]``. -```markdown -::: da_methods.ensemble -``` +### Docstring injection -But we generally don't do so manually. -Instead it's taken care of by the reference generation via `docs/gen_ref_pages.py`. +`::: pipt.update_schemes.esmda` injects a module's rendered docstrings. This +is rarely written by hand: `docs/gen_ref_pages.py` generates one such page per +module under `src/` at build time, which is what the *Reference* section is. ### Including other files -The `pymdown` extension ["snippets"](https://facelessuser.github.io/pymdown-extensions/extensions/snippets/#snippets-notation) -enables the following syntax to include text from other files. - -`--8<-- "/path/from/project/root/filename.ext"` +The `pymdown` ["snippets"](https://facelessuser.github.io/pymdown-extensions/extensions/snippets/#snippets-notation) +extension includes text from another file: +`--8<-- "path/from/project/root/filename.ext"`. The home page includes +`README.md` this way. -### Adding to the examples +### Tutorials -Example scripts are very useful, and contributions are very desirable. As well -as showcasing some feature, new examples should make sure to reproduce some -published literature results. After making the example, consider converting -the script to the Jupyter notebook format (or vice versa) so that the example -can be run on Colab without users needing to install anything (see -`docs/examples/README.md`). This should be done using the `jupytext` plug-in (with -the `lightscript` format), so that the paired files can be kept in synch. +Tutorials are Jupyter notebooks under `docs/tutorials/`, listed in +`docs/tutorials/README.md`. The build renders their stored outputs and does +not execute them (`execute: false`): the reservoir cases need the OPM `flow` +simulator through the external `subsurface` package. ### Bibliography -In order to add new references, -insert their bibtex into `docs/bib/refs.bib`, -then run `docs/bib/bib2md.py` -which will format and add entries to `docs/references.md` -that can be cited with regular cross-reference syntax, e.g. `[bocquet2010a][]`. - -### Hosting - -The above command is run by a GitHub Actions workflow whenever -the `master` branch gets updated. -The `gh-pages` branch is no longer being used. -Instead [actions/deploy-pages](https://github.com/actions/deploy-pages) -creates an artefact that is deployed to Github Pages. - -## Tests - -The test suite is orchestrated using `pytest`. Both in **CI** and locally. -I.e. you can run the tests simply by the command - -```sh -pytest -``` - -It will discover all [appropriately named tests](https://docs.pytest.org) -in the source (see the `tests` dir). +Add new references as BibTeX to `docs/bib/refs.bib`, then run +`docs/bib/bib2md.py`, which formats them into `docs/references.md` so they can +be cited with the cross-reference syntax, e.g. `[chen2013][]`. -Use (for example) `pytest --doctest-modules some_file.py` to -*also* run any example code **within** docstrings. +## Hosting -We should also soon make use of a config file (for example `pyproject.toml`) for `pytest`. +`.github/workflows/deploy-docs.yml` builds the site and publishes it to GitHub +Pages with `mhausenblas/mkdocs-deploy-gh-pages` whenever `main` is updated. diff --git a/docs/examples/loc_entries.csv b/docs/examples/loc_entries.csv new file mode 100644 index 00000000..d25b69ec --- /dev/null +++ b/docs/examples/loc_entries.csv @@ -0,0 +1,4 @@ +gc 10 10 0 6 : 1.0 0.0 pressure 400.0 permx +gc 10 10 0 6 : 1.0 0.0 pressure 800.0 permx +gc 5 15 0 4 : 1.0 0.0 wopr pro1 400.0 permx +gc 5 15 0 4 : 2.0 30.0 wopr pro1 800.0 permx diff --git a/docs/gen_ref_pages.py b/docs/gen_ref_pages.py index 7ac92e4d..a826d538 100644 --- a/docs/gen_ref_pages.py +++ b/docs/gen_ref_pages.py @@ -14,7 +14,7 @@ root = Path(__file__).parent.parent -src = root +src = root / "src" for path in sorted(src.rglob("*.py")): # Skip "venv" and other similarly named directories @@ -55,8 +55,6 @@ # Generate index.md parts = parts[:-1] # name of parent dir path_md = path_md.with_name("index.md") - elif parts[0] == "docs": - continue # PS: Uncomment (replace `mkdocs_gen_files.open`) to view actual .md files # path_md = Path("docs", path_md) diff --git a/docs/tutorials/README.md b/docs/tutorials/README.md index 415f3f75..b4f552b2 100644 --- a/docs/tutorials/README.md +++ b/docs/tutorials/README.md @@ -2,5 +2,21 @@ Here are some tutorials. -- [`tutorial_pipt.ipynb`](pipt/tutorial_pipt): Tutorial for running PIPT -- [`tutorial_pipt.ipynb`](popt/tutorial_popt): Tutorial for running POPT +## Running PIPT and POPT + +- [`tutorial_pipt.ipynb`](pipt/TinyBox/tutorial_pipt): Tutorial for running PIPT +- [`tutorial_popt.ipynb`](popt/5Spot/tutorial_popt): Tutorial for running POPT + +## Data structures + +- [`tutorial_petdataframe.ipynb`](usefull/tutorial_petdataframe): The `PETDataFrame` container -- ragged data tables, `to_matrix()`, scaling and adjoints + +## Localization + +- [`tutorial_auto_adaptive_localization.ipynb`](pipt/localization/5SPOT_PORO/tutorial_auto_adaptive_localization): Adaptive correlation-based tapering +- [`tutorial_distance_localization.ipynb`](pipt/localization/5SPOT_PORO/tutorial_distance_localization): Distance-based tapering around wells + +## Extending PIPT + +- [`adding_an_analysis.ipynb`](pipt/extending/adding_an_analysis): Write a new analysis flavour and bind it to a scheme +- [`adding_a_scheme.ipynb`](pipt/extending/adding_a_scheme): Write a new scheme and register it for config-driven use diff --git a/docs/tutorials/pipt/3D_ESMDA.toml b/docs/tutorials/pipt/3D_ESMDA.toml deleted file mode 100644 index 8732a7c4..00000000 --- a/docs/tutorials/pipt/3D_ESMDA.toml +++ /dev/null @@ -1,36 +0,0 @@ -[ensemble] -ne = 50.0 -state = "permx" -prior_permx = [["vario", "sph"], ["mean", "priormean.npz"], ["var", 1.0], ["range", 10.0], ["aniso", 1.0], - ["angle", 0.0], ["grid", [10.0, 10.0, 2.0]]] - -[dataassim] -daalg = ["esmda", "esmda"] -analysis = "approx" -energy = 98.0 -obsvarsave = "yes" -restartsave = "no" -analysisdebug = ["pred_data", "state", "data_misfit", "prev_data_misfit"] -restart = "no" -obsname = "days" -truedataindex = [400, 800, 1200, 1600, 2000, 2400, 2800, 3200, 3600, 4000] -truedata = "true_data.csv" -assimindex = [0,1,2,3,4,5,6,7,8,9] -datatype = ["WOPR PRO1", "WOPR PRO2", "WOPR PRO3", "WWPR PRO1", "WWPR PRO2", - "WWPR PRO3", "WWIR INJ1", "WWIR INJ2", "WWIR INJ3"] -staticvar = "permx" -datavar = "var.csv" -mda = [ ["tot_assim_steps", 3], ['inflation_param', [2, 4, 4]] ] - -[fwdsim] -reporttype = "days" -reportpoint = [400, 800, 1200, 1600, 2000, 2400, 2800, 3200, 3600, 4000] -replace = "yes" -saveforecast = "yes" -sim_limit = 300.0 -rerun = 1 -runfile = "runfile" -datatype = ["WOPR PRO1", "WOPR PRO2", "WOPR PRO3", "WWPR PRO1", "WWPR PRO2", - "WWPR PRO3", "WWIR INJ1", "WWIR INJ2", "WWIR INJ3"] -parallel = 4 -startdate = "1/1/2022" diff --git a/docs/tutorials/pipt/TinyBox/CONFIG_ESMDA.toml b/docs/tutorials/pipt/TinyBox/CONFIG_ESMDA.toml new file mode 100644 index 00000000..9824d637 --- /dev/null +++ b/docs/tutorials/pipt/TinyBox/CONFIG_ESMDA.toml @@ -0,0 +1,50 @@ +[ensemble] + ne = 50 + state = "permx" + [ensemble.prior_permx] + vario = "sph" + mean = "priormean.npz" + var = 1.0 + range = 10.0 + aniso = 1.0 + angle = 0.0 + grid = [10, 10, 2] + +[dataassim] + savefolder = "Results" + scheme = "esmda" + analysis = "approx" + energy = 98.0 + obsname = "dates" + data = "data.csv" + datavar = "var.csv" + savedata = ["ensemble_misfit"] + + # ESMDA settings + [dataassim.mda] + tot_assim_steps = 5 + inflation_param = [5, 5, 5, 5, 5] + + +[simulator] + reporttype = "dates" + reportpoint = [ + 2023-02-05T00:00:00, + 2024-03-11T00:00:00, + 2025-04-15T00:00:00, + 2026-05-20T00:00:00, + 2027-06-24T00:00:00, + 2028-07-28T00:00:00, + 2029-09-01T00:00:00, + 2030-10-06T00:00:00, + 2031-11-10T00:00:00, + 2032-12-14T00:00:00, + ] + sim_limit = 300.0 + runfile = "RUNFILE" + parallel = 5 + datatype = [ + "WOPR:PRO1", "WOPR:PRO2", "WOPR:PRO3", + "WWPR:PRO1", "WWPR:PRO2", "WWPR:PRO3", + "WWIR:INJ1", "WWIR:INJ2", "WWIR:INJ3" + ] diff --git a/docs/tutorials/pipt/TinyBox/CONFIG_GNENRML_MARGIS.toml b/docs/tutorials/pipt/TinyBox/CONFIG_GNENRML_MARGIS.toml new file mode 100644 index 00000000..5616f569 --- /dev/null +++ b/docs/tutorials/pipt/TinyBox/CONFIG_GNENRML_MARGIS.toml @@ -0,0 +1,52 @@ +[ensemble] + ne = 50 + state = "permx" + [ensemble.prior_permx] + vario = "sph" + mean = "priormean.npz" + var = 1.0 + range = 10.0 + aniso = 1.0 + angle = 0.0 + grid = [10, 10, 2] + +[dataassim] + savefolder = "Results_margis" + scheme = "gnenrml" + analysis = "margis" + energy = 98.0 + obsname = "dates" + data = "data.csv" + datavar = "var.csv" + savedata = ["ensemble_misfit"] + + # GN-EnRML settings + [dataassim.iteration] + max_iter = 10 + gamma = 0.5 + gamma_factor = 5 + trunc_energy = 0.99 + + +[simulator] + reporttype = "dates" + reportpoint = [ + 2023-02-05T00:00:00, + 2024-03-11T00:00:00, + 2025-04-15T00:00:00, + 2026-05-20T00:00:00, + 2027-06-24T00:00:00, + 2028-07-28T00:00:00, + 2029-09-01T00:00:00, + 2030-10-06T00:00:00, + 2031-11-10T00:00:00, + 2032-12-14T00:00:00, + ] + sim_limit = 300.0 + runfile = "RUNFILE" + parallel = 5 + datatype = [ + "WOPR:PRO1", "WOPR:PRO2", "WOPR:PRO3", + "WWPR:PRO1", "WWPR:PRO2", "WWPR:PRO3", + "WWIR:INJ1", "WWIR:INJ2", "WWIR:INJ3" + ] diff --git a/docs/tutorials/pipt/RUNFILE.mako b/docs/tutorials/pipt/TinyBox/RUNFILE.mako similarity index 95% rename from docs/tutorials/pipt/RUNFILE.mako rename to docs/tutorials/pipt/TinyBox/RUNFILE.mako index f862215f..82e33d33 100644 --- a/docs/tutorials/pipt/RUNFILE.mako +++ b/docs/tutorials/pipt/TinyBox/RUNFILE.mako @@ -10,11 +10,11 @@ import numpy as np RUNSPEC TITLE - INVERTED 5 SPOT MODEL + TINY BOX MODEL --DIMENS -- NDIVIX NDIVIY NDIVIZ --- 60 60 5 / +-- 40 20 5 / --BLACKOIL OIL @@ -64,7 +64,7 @@ GRID INIT INCLUDE - '../Grid.grdecl' / +'../grid/Grid.grdecl' / / PERMX @@ -86,7 +86,7 @@ COPY PROPS =============================================================== INCLUDE - '../pvt.txt' / + '../grid/pvt.txt' / / REGIONS =============================================================== @@ -149,7 +149,7 @@ RPTRST ------------------- WELL SPECIFICATION DATA -------------------------- INCLUDE -'../Schdl.sch' / +'../grid/Schdl.sch' / / diff --git a/docs/tutorials/pipt/TinyBox/Results/assimilation_result_0.npz b/docs/tutorials/pipt/TinyBox/Results/assimilation_result_0.npz new file mode 100644 index 00000000..b8ffcb04 Binary files /dev/null and b/docs/tutorials/pipt/TinyBox/Results/assimilation_result_0.npz differ diff --git a/docs/tutorials/pipt/TinyBox/Results/assimilation_result_1.npz b/docs/tutorials/pipt/TinyBox/Results/assimilation_result_1.npz new file mode 100644 index 00000000..0191c91d Binary files /dev/null and b/docs/tutorials/pipt/TinyBox/Results/assimilation_result_1.npz differ diff --git a/docs/tutorials/pipt/TinyBox/Results/assimilation_result_2.npz b/docs/tutorials/pipt/TinyBox/Results/assimilation_result_2.npz new file mode 100644 index 00000000..f24ed5ee Binary files /dev/null and b/docs/tutorials/pipt/TinyBox/Results/assimilation_result_2.npz differ diff --git a/docs/tutorials/pipt/TinyBox/Results/assimilation_result_3.npz b/docs/tutorials/pipt/TinyBox/Results/assimilation_result_3.npz new file mode 100644 index 00000000..62bae0b5 Binary files /dev/null and b/docs/tutorials/pipt/TinyBox/Results/assimilation_result_3.npz differ diff --git a/docs/tutorials/pipt/TinyBox/Results/assimilation_result_4.npz b/docs/tutorials/pipt/TinyBox/Results/assimilation_result_4.npz new file mode 100644 index 00000000..0e6952d8 Binary files /dev/null and b/docs/tutorials/pipt/TinyBox/Results/assimilation_result_4.npz differ diff --git a/docs/tutorials/pipt/TinyBox/Results/assimilation_result_5.npz b/docs/tutorials/pipt/TinyBox/Results/assimilation_result_5.npz new file mode 100644 index 00000000..6e05044d Binary files /dev/null and b/docs/tutorials/pipt/TinyBox/Results/assimilation_result_5.npz differ diff --git a/docs/tutorials/pipt/TinyBox/Results/posterior_forecast.pkl b/docs/tutorials/pipt/TinyBox/Results/posterior_forecast.pkl new file mode 100644 index 00000000..b7d4a7e6 Binary files /dev/null and b/docs/tutorials/pipt/TinyBox/Results/posterior_forecast.pkl differ diff --git a/docs/tutorials/pipt/TinyBox/Results/posterior_state_estimate.npz b/docs/tutorials/pipt/TinyBox/Results/posterior_state_estimate.npz new file mode 100644 index 00000000..1789fe2a Binary files /dev/null and b/docs/tutorials/pipt/TinyBox/Results/posterior_state_estimate.npz differ diff --git a/docs/tutorials/pipt/TinyBox/Results/prior_ensemble.npz b/docs/tutorials/pipt/TinyBox/Results/prior_ensemble.npz new file mode 100644 index 00000000..49de8100 Binary files /dev/null and b/docs/tutorials/pipt/TinyBox/Results/prior_ensemble.npz differ diff --git a/docs/tutorials/pipt/TinyBox/Results/prior_forecast.pkl b/docs/tutorials/pipt/TinyBox/Results/prior_forecast.pkl new file mode 100644 index 00000000..a24042a8 Binary files /dev/null and b/docs/tutorials/pipt/TinyBox/Results/prior_forecast.pkl differ diff --git a/docs/tutorials/pipt/TinyBox/Results/why_iter_loop_stopped.pkl b/docs/tutorials/pipt/TinyBox/Results/why_iter_loop_stopped.pkl new file mode 100644 index 00000000..6de390c7 Binary files /dev/null and b/docs/tutorials/pipt/TinyBox/Results/why_iter_loop_stopped.pkl differ diff --git a/docs/tutorials/pipt/TinyBox/Results_margis/assimilation_result_0.npz b/docs/tutorials/pipt/TinyBox/Results_margis/assimilation_result_0.npz new file mode 100644 index 00000000..b8ffcb04 Binary files /dev/null and b/docs/tutorials/pipt/TinyBox/Results_margis/assimilation_result_0.npz differ diff --git a/docs/tutorials/pipt/TinyBox/Results_margis/assimilation_result_1.npz b/docs/tutorials/pipt/TinyBox/Results_margis/assimilation_result_1.npz new file mode 100644 index 00000000..1df0b8f5 Binary files /dev/null and b/docs/tutorials/pipt/TinyBox/Results_margis/assimilation_result_1.npz differ diff --git a/docs/tutorials/pipt/TinyBox/Results_margis/assimilation_result_2.npz b/docs/tutorials/pipt/TinyBox/Results_margis/assimilation_result_2.npz new file mode 100644 index 00000000..fa8e1720 Binary files /dev/null and b/docs/tutorials/pipt/TinyBox/Results_margis/assimilation_result_2.npz differ diff --git a/docs/tutorials/pipt/TinyBox/Results_margis/assimilation_result_3.npz b/docs/tutorials/pipt/TinyBox/Results_margis/assimilation_result_3.npz new file mode 100644 index 00000000..6893e0c3 Binary files /dev/null and b/docs/tutorials/pipt/TinyBox/Results_margis/assimilation_result_3.npz differ diff --git a/docs/tutorials/pipt/TinyBox/Results_margis/assimilation_result_4.npz b/docs/tutorials/pipt/TinyBox/Results_margis/assimilation_result_4.npz new file mode 100644 index 00000000..2a9a39ff Binary files /dev/null and b/docs/tutorials/pipt/TinyBox/Results_margis/assimilation_result_4.npz differ diff --git a/docs/tutorials/pipt/TinyBox/Results_margis/assimilation_result_5.npz b/docs/tutorials/pipt/TinyBox/Results_margis/assimilation_result_5.npz new file mode 100644 index 00000000..8454444a Binary files /dev/null and b/docs/tutorials/pipt/TinyBox/Results_margis/assimilation_result_5.npz differ diff --git a/docs/tutorials/pipt/TinyBox/Results_margis/assimilation_result_6.npz b/docs/tutorials/pipt/TinyBox/Results_margis/assimilation_result_6.npz new file mode 100644 index 00000000..007ebb30 Binary files /dev/null and b/docs/tutorials/pipt/TinyBox/Results_margis/assimilation_result_6.npz differ diff --git a/docs/tutorials/pipt/TinyBox/Results_margis/assimilation_result_7.npz b/docs/tutorials/pipt/TinyBox/Results_margis/assimilation_result_7.npz new file mode 100644 index 00000000..23b4735a Binary files /dev/null and b/docs/tutorials/pipt/TinyBox/Results_margis/assimilation_result_7.npz differ diff --git a/docs/tutorials/pipt/TinyBox/Results_margis/assimilation_result_8.npz b/docs/tutorials/pipt/TinyBox/Results_margis/assimilation_result_8.npz new file mode 100644 index 00000000..bae1cf09 Binary files /dev/null and b/docs/tutorials/pipt/TinyBox/Results_margis/assimilation_result_8.npz differ diff --git a/docs/tutorials/pipt/TinyBox/Results_margis/posterior_forecast.pkl b/docs/tutorials/pipt/TinyBox/Results_margis/posterior_forecast.pkl new file mode 100644 index 00000000..f28d7840 Binary files /dev/null and b/docs/tutorials/pipt/TinyBox/Results_margis/posterior_forecast.pkl differ diff --git a/docs/tutorials/pipt/TinyBox/Results_margis/posterior_state_estimate.npz b/docs/tutorials/pipt/TinyBox/Results_margis/posterior_state_estimate.npz new file mode 100644 index 00000000..b527cbb9 Binary files /dev/null and b/docs/tutorials/pipt/TinyBox/Results_margis/posterior_state_estimate.npz differ diff --git a/docs/tutorials/pipt/TinyBox/Results_margis/prior_forecast.pkl b/docs/tutorials/pipt/TinyBox/Results_margis/prior_forecast.pkl new file mode 100644 index 00000000..a24042a8 Binary files /dev/null and b/docs/tutorials/pipt/TinyBox/Results_margis/prior_forecast.pkl differ diff --git a/docs/tutorials/pipt/TinyBox/Results_margis/why_iter_loop_stopped.pkl b/docs/tutorials/pipt/TinyBox/Results_margis/why_iter_loop_stopped.pkl new file mode 100644 index 00000000..7303dd5b Binary files /dev/null and b/docs/tutorials/pipt/TinyBox/Results_margis/why_iter_loop_stopped.pkl differ diff --git a/docs/tutorials/pipt/TinyBox/data.csv b/docs/tutorials/pipt/TinyBox/data.csv new file mode 100644 index 00000000..195c8923 --- /dev/null +++ b/docs/tutorials/pipt/TinyBox/data.csv @@ -0,0 +1,11 @@ +dates,WOPR:PRO1,WWPR:PRO1,WOPR:PRO2,WWPR:PRO2,WOPR:PRO3,WWPR:PRO3,WWIR:INJ1 +2023-02-05,2578.2042319359743,-0.002049037041368184,2074.9396451059706,0.0025599072390737844,2498.9278927887867,0.004280423280700726,4532.678127501723 +2024-03-11,3253.902189794448,0.037153179563700504,2180.3340859135724,9.331133953962688e-05,3119.8577686003277,-0.008494680248984475,5147.357268773142 +2025-04-15,2454.2492832740577,0.48070203639130105,2472.084127199495,0.04473831813045719,3309.7031993067703,-0.0007257601035295953,5198.423557960116 +2026-05-20,2794.807868198391,2.9407811683760823,2663.8940657666267,0.29610046760086334,3019.9828186249642,0.025876861101430705,4343.600896097791 +2027-06-24,2427.2265802169977,12.398574330132304,2519.7082027783513,1.0968216256691883,2893.840008444232,0.12637283244891342,4485.88528256192 +2028-07-28,2412.9309607547516,30.210189174488953,2632.462884525936,3.7921174228904904,3384.9425345628133,0.41583500212203156,4538.3889258655345 +2029-09-01,2533.258322834055,79.31747248267374,2169.7079021054883,11.01924878769781,2852.6318560665195,1.0839440815589527,3969.173932966913 +2030-10-06,2179.244848437228,204.86147734586848,2309.3188559720184,24.94969035984491,3025.7317023257815,2.7377348001944313,3970.954690006117 +2031-11-10,2205.069238871487,373.32147242635176,2168.7689845399395,47.13542157012543,2416.3483915430847,7.151038152751751,4917.358690810593 +2032-12-14,1539.5350421730163,621.9935711960316,1902.1107395676108,115.84467264636838,2739.9274645198543,12.64036156000062,4709.5739154800585 diff --git a/docs/tutorials/pipt/Grid.grdecl b/docs/tutorials/pipt/TinyBox/grid/Grid.grdecl similarity index 100% rename from docs/tutorials/pipt/Grid.grdecl rename to docs/tutorials/pipt/TinyBox/grid/Grid.grdecl diff --git a/docs/tutorials/pipt/Schdl.sch b/docs/tutorials/pipt/TinyBox/grid/Schdl.sch similarity index 100% rename from docs/tutorials/pipt/Schdl.sch rename to docs/tutorials/pipt/TinyBox/grid/Schdl.sch diff --git a/docs/tutorials/pipt/pvt.txt b/docs/tutorials/pipt/TinyBox/grid/pvt.txt similarity index 100% rename from docs/tutorials/pipt/pvt.txt rename to docs/tutorials/pipt/TinyBox/grid/pvt.txt diff --git a/docs/tutorials/pipt/permx.png b/docs/tutorials/pipt/TinyBox/permx.png similarity index 100% rename from docs/tutorials/pipt/permx.png rename to docs/tutorials/pipt/TinyBox/permx.png diff --git a/docs/tutorials/pipt/TinyBox/prior_ensemble.npz b/docs/tutorials/pipt/TinyBox/prior_ensemble.npz new file mode 100644 index 00000000..49de8100 Binary files /dev/null and b/docs/tutorials/pipt/TinyBox/prior_ensemble.npz differ diff --git a/docs/tutorials/pipt/priormean.npz b/docs/tutorials/pipt/TinyBox/priormean.npz similarity index 100% rename from docs/tutorials/pipt/priormean.npz rename to docs/tutorials/pipt/TinyBox/priormean.npz diff --git a/docs/tutorials/pipt/TinyBox/tutorial_pipt.ipynb b/docs/tutorials/pipt/TinyBox/tutorial_pipt.ipynb new file mode 100644 index 00000000..c11be643 --- /dev/null +++ b/docs/tutorials/pipt/TinyBox/tutorial_pipt.ipynb @@ -0,0 +1,7122 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Tutorial for running the Python Inverse Problem Toolbox (PIPT)\n", + "\n", + "As an illustrative example we choose a small 3D-field with three producers and three (water) injectors. The figure below shows the true (data generating) permeability field and the well positions. The grid is 10x10x2, and the porosity is 0.2. The inverse problem is to find the permeability for the reservoir by assimilation produced water and oil and injected water. \n", + "\n", + "\"drawing\"\n", + "
\n", + "The first step is to load neccessary external and local modules. " + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-20T11:58:10.269810Z", + "iopub.status.busy": "2026-08-20T11:58:10.269354Z", + "iopub.status.idle": "2026-08-20T11:58:11.244893Z", + "shell.execute_reply": "2026-08-20T11:58:11.244051Z" + }, + "scrolled": false + }, + "outputs": [], + "source": [ + "# Import global modules\n", + "import numpy as np\n", + "\n", + "# Import local modules\n", + "from pipt import ESMDA # the assimilation scheme; it owns its own iteration loop\n", + "from subsurface.multphaseflow.opm import flow # the simulator we want to use\n", + "from input_output import read_config # the config reader\n", + "from pipt.pipt_init import init_da" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Set the random seed:" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-20T11:58:11.246940Z", + "iopub.status.busy": "2026-08-20T11:58:11.246682Z", + "iopub.status.idle": "2026-08-20T11:58:11.250975Z", + "shell.execute_reply": "2026-08-20T11:58:11.250080Z" + }, + "scrolled": true + }, + "outputs": [], + "source": [ + "np.random.seed(10)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Read inputfile. In this tutorial the input file is written as a .toml file, and consists of two main keys: dataassim and fwdsim. The first part contains the options for the data assimilation algorithm and the second part are options related to the forward simulation model. The description of all keys are provided in the printouts of method docstrings below." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-20T11:58:11.252687Z", + "iopub.status.busy": "2026-08-20T11:58:11.252539Z", + "iopub.status.idle": "2026-08-20T11:58:11.381535Z", + "shell.execute_reply": "2026-08-20T11:58:11.378854Z" + }, + "scrolled": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[ensemble]\n", + " ne = 50\n", + " state = \"permx\"\n", + " [ensemble.prior_permx]\n", + " vario = \"sph\"\n", + " mean = \"priormean.npz\"\n", + " var = 1.0\n", + " range = 10.0\n", + " aniso = 1.0\n", + " angle = 0.0\n", + " grid = [10, 10, 2]\n", + "\n", + "[dataassim]\n", + " savefolder = \"Results\"\n", + " scheme = \"esmda\"\n", + " analysis = \"approx\"\n", + " energy = 98.0\n", + " obsname = \"dates\"\n", + " data = \"data.csv\"\n", + " datavar = \"var.csv\"\n", + " savedata = [\"ensemble_misfit\"]\n", + "\n", + " # ESMDA settings\n", + " [dataassim.mda]\n", + " tot_assim_steps = 5\n", + " inflation_param = [5, 5, 5, 5, 5]\n", + " \n", + " \n", + "[simulator]\n", + " reporttype = \"dates\"\n", + " reportpoint = [\n", + " 2023-02-05T00:00:00,\n", + " 2024-03-11T00:00:00,\n", + " 2025-04-15T00:00:00,\n", + " 2026-05-20T00:00:00,\n", + " 2027-06-24T00:00:00,\n", + " 2028-07-28T00:00:00,\n", + " 2029-09-01T00:00:00,\n", + " 2030-10-06T00:00:00,\n", + " 2031-11-10T00:00:00,\n", + " 2032-12-14T00:00:00,\n", + " ]\n", + " sim_limit = 300.0\n", + " runfile = \"RUNFILE\"\n", + " parallel = 5\n", + " datatype = [\n", + " \"WOPR:PRO1\", \"WOPR:PRO2\", \"WOPR:PRO3\", \n", + " \"WWPR:PRO1\", \"WWPR:PRO2\", \"WWPR:PRO3\", \n", + " \"WWIR:INJ1\", \"WWIR:INJ2\", \"WWIR:INJ3\"\n", + " ]\n" + ] + } + ], + "source": [ + "!cat CONFIG_ESMDA.toml\n", + "kwda, kwsim, kwens = read_config.read('CONFIG_ESMDA.toml')\n", + "# kwda --> Data assimilation settings\n", + "# kwsim --> Simulator settings\n", + "# kwens --> Ensemble settings" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Example using ESMDA. The input and available options are given below. During assimilation, useful information is written to the screen. The same information is also written to a log-file named pet_logger.log. " + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-20T11:58:11.387487Z", + "iopub.status.busy": "2026-08-20T11:58:11.387027Z", + "iopub.status.idle": "2026-08-20T12:04:14.967044Z", + "shell.execute_reply": "2026-08-20T12:04:14.966492Z" + }, + "scrolled": false + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2026-08-20│13:58:11 : =========== Running Data Assimilation - ESMDA ===========\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1;33mSingle entry for VARIO will be copied to all 2 layers\u001b[1;m\n", + "\u001b[1;33mSingle entry for VARIANCE will be copied to all 2 layers\u001b[1;m\n", + "\u001b[1;33mSingle entry for ANISO will be copied to all 2 layers\u001b[1;m\n", + "\u001b[1;33mSingle entry for ANGLE will be copied to all 2 layers\u001b[1;m\n", + "\u001b[1;33mSingle entry for CORR_LENGTH will be copied to all 2 layers\u001b[1;m\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "26804ca9c1974cf0ac28c3b848806e4a", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + " 0%| | 0/50 [00:00 756.9\n", + " message: Maximum number of iterations reached\n", + " success: False\n", + " x: [[ 5.005e+00 4.575e+00 ... 4.212e+00 4.571e+00]\n", + " [ 5.566e+00 5.149e+00 ... 4.610e+00 4.659e+00]\n", + " ...\n", + " [ 3.639e+00 4.104e+00 ... 4.006e+00 3.290e+00]\n", + " [ 3.713e+00 3.926e+00 ... 3.899e+00 3.496e+00]]\n", + " nit: 5\n", + " why_stop: rel_data_misfit: 0.892187560800378\n", + " data_misfit: 756.8799657107337\n", + " prev_data_misfit: 7020.339872928015\n", + " data_misfit: 756.8799657107337\n", + " prior_data_misfit: 112592494809.87149\n" + ] + } + ], + "source": [ + "# There are different ways to run the assimilation. Here are three examples:\n", + "\n", + "# Option 1: Use the ESMDA class method directly\n", + "sim = flow(kwsim)\n", + "res = ESMDA.assimilate(kwda, kwens, sim)\n", + "\n", + "# Option 2: Create an instance of the ESMDA class and run the assimilation loop\n", + "# emsda = ESMDA(kwda, kwens, sim)\n", + "# res = emsda.run_assimilation()\n", + "\n", + "# Option 3: Use the init_da function to initialize the ESMDA instance and run the assimilation loop\n", + "# esmda = init_da(kwda, kwens, sim)\n", + "# res = esmda.run_assimilation()\n", + "\n", + "print(f'data misfit: {res.prior_data_misfit:.1f} -> {res.data_misfit:.1f}')\n", + "print(res)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Plot the data mismatch:" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-20T12:04:14.968182Z", + "iopub.status.busy": "2026-08-20T12:04:14.968083Z", + "iopub.status.idle": "2026-08-20T12:04:15.283332Z", + "shell.execute_reply": "2026-08-20T12:04:15.282786Z" + }, + "scrolled": false + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "from pathlib import Path\n", + "\n", + "result_folder = \"Results\"\n", + "data_misfit = []\n", + "\n", + "it = 0\n", + "while True:\n", + " file = Path(f\"{result_folder}/assimilation_result_{it}.npz\")\n", + " if not file.exists():\n", + " break\n", + " npzfile = np.load(file)\n", + " data_misfit.append(npzfile[\"ensemble_misfit\"])\n", + " it += 1\n", + "\n", + "# Make plot\n", + "plt.style.use(\"seaborn-v0_8-whitegrid\")\n", + "fig, ax = plt.subplots(figsize=(9.2, 5.2), facecolor=\"white\")\n", + "bp = ax.boxplot(\n", + " data_misfit,\n", + " positions=range(len(data_misfit)),\n", + " widths=0.56,\n", + " patch_artist=True,\n", + " showfliers=True,\n", + " boxprops=dict(facecolor=\"#4C78A8\", alpha=0.28, linewidth=1.4, edgecolor=\"#2F5D8A\"),\n", + " whiskerprops=dict(color=\"#2F5D8A\", linewidth=1.3),\n", + " capprops=dict(color=\"#2F5D8A\", linewidth=1.3),\n", + " medianprops=dict(color=\"#D62728\", linewidth=2.0),\n", + " flierprops=dict(marker=\"o\", markersize=6, markerfacecolor=\"#2F5D8A\",\n", + " markeredgecolor=\"white\", markeredgewidth=0.4, alpha=0.42),\n", + ")\n", + "\n", + "# Axis formatting\n", + "positions = range(len(data_misfit))\n", + "ax.set_xticks(positions)\n", + "ax.set_xticklabels([str(i) for i in positions], fontsize=10.5)\n", + "ax.set_xlabel(\"Iteration\", fontsize=12.5, fontweight=\"semibold\")\n", + "ax.set_ylabel(\"Data Misfit\", fontsize=12.5, fontweight=\"semibold\")\n", + "ax.set_yscale(\"log\")\n", + "y_min = max(1e-12, np.nanmin([np.nanmin(s) for s in data_misfit]) * 0.75)\n", + "y_max = np.nanmax([np.nanmax(s) for s in data_misfit]) * 5\n", + "ax.set_ylim(y_min, y_max)\n", + "ax.grid(which=\"major\", axis=\"both\", linestyle=\"--\", linewidth=0.7, alpha=0.35)\n", + "ax.grid(which=\"minor\", axis=\"y\", linestyle=\":\", linewidth=0.45, alpha=0.22)\n", + "ax.spines[\"top\"].set_visible(False)\n", + "ax.spines[\"right\"].set_visible(False)\n", + "fig.tight_layout()\n", + "plt.show()\n", + "\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Plot the prior and posterior permeability in the upper layer:" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-20T12:04:15.284580Z", + "iopub.status.busy": "2026-08-20T12:04:15.284482Z", + "iopub.status.idle": "2026-08-20T12:04:16.004567Z", + "shell.execute_reply": "2026-08-20T12:04:16.003747Z" + }, + "scrolled": false + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "def plot_field(field, label, cmapname, cmax, cmin):\n", + " nx, ny, nz = 10, 10, 2\n", + " field = field.reshape((nx, ny, nz), order='F')\n", + "\n", + " wells = {\n", + " \"INJ1\": {\"ij\": (0, 0), \"color\": \"deepskyblue\"},\n", + " \"INJ2\": {\"ij\": (4, 0), \"color\": \"deepskyblue\"},\n", + " \"INJ3\": {\"ij\": (9, 0), \"color\": \"deepskyblue\"},\n", + " \"PRO1\": {\"ij\": (0, 9), \"color\": \"crimson\"},\n", + " \"PRO2\": {\"ij\": (4, 9), \"color\": \"crimson\"},\n", + " \"PRO3\": {\"ij\": (9, 9), \"color\": \"crimson\"},\n", + " }\n", + "\n", + " # set max and min color\n", + " cmap = plt.get_cmap(cmapname)\n", + " norm = plt.Normalize(vmin=cmin, vmax=cmax)\n", + " facecolors = cmap(norm(field))\n", + " edgecolors = 'white' # uniform edge color for all voxels\n", + "\n", + " fig = plt.figure(figsize=(10, 6))\n", + " ax = fig.add_subplot(111, projection='3d')\n", + " ax.computed_zorder = False # allow manual zorder in 3D\n", + " fig.subplots_adjust(left=0.05, right=0.95, top=0.95, bottom=0.12)\n", + "\n", + " filled = np.ones((nx, ny, nz), dtype=bool)\n", + " x, y, z = np.indices(np.array(filled.shape) + 1).astype(float)\n", + " x = x / nx\n", + " y = y / ny\n", + " z = z / nz\n", + "\n", + " ax.voxels(\n", + " x, y, z, filled,\n", + " facecolors=facecolors,\n", + " edgecolors=edgecolors,\n", + " linewidth=0.5,\n", + " alpha=1.0,\n", + " zsort='max'\n", + " )\n", + "\n", + " # Very thin, taller well sticks: centered in each cell\n", + " stick_extra_above = 0.75 # taller above z=1.0 (was 0.30)\n", + " stick_size_x = 0.15 / nx # thinner\n", + " stick_size_y = 0.15 / ny # thinner\n", + "\n", + " for name, w in wells.items():\n", + " i, j = w[\"ij\"]\n", + " color = w.get(\"color\", \"black\")\n", + "\n", + " # exact cell center in normalized coordinates\n", + " cx = (i + 0.5) / nx\n", + " cy = (j + 0.5) / ny\n", + "\n", + " # bar3d expects lower-left corner, so shift by half size to keep centered\n", + " ax.bar3d(\n", + " cx - 0.5 * stick_size_x, cy - 0.5 * stick_size_y, 1.0,\n", + " stick_size_x, stick_size_y, 1.0 + stick_extra_above,\n", + " color=color, edgecolor=None, linewidth=0.8, shade=True, alpha=0.7, zsort='max',\n", + " )\n", + " ax.text(cx, cy, 1.0 + stick_extra_above + 1.2, name, color=color, fontsize=9, ha='center', zorder=1)\n", + "\n", + " ax.set_zlim(0.0, 1.0 + stick_extra_above + 0.05)\n", + "\n", + " sm = plt.cm.ScalarMappable(cmap=cmap, norm=norm)\n", + " sm.set_array([])\n", + " cbar_ax = fig.add_axes([0.15, 0.2, 0.7, 0.03])\n", + " cbar = plt.colorbar(sm, cax=cbar_ax, orientation='horizontal')\n", + " cbar.set_label(label, fontsize=11, fontweight='bold')\n", + "\n", + " ax.set_xticklabels([])\n", + " ax.set_yticklabels([])\n", + " ax.set_zticklabels([])\n", + " ax.view_init(elev=20, azim=45)\n", + " ax.set_box_aspect([nx/10, ny/10, nz/10])\n", + "\n", + " plt.show()\n", + "\n", + "\n", + "# Plot prior and posterior fields (mean of ensemble)\n", + "prior_permx = np.load('Results/prior_ensemble.npz')['permx'].mean(axis=-1)\n", + "posterior_permx = np.load('Results/posterior_state_estimate.npz')['permx'].mean(axis=-1)\n", + "#posterior_permx = res.x.mean(axis=-1)\n", + "cmax = max(prior_permx.max(), posterior_permx.max())\n", + "cmin = min(prior_permx.min(), posterior_permx.min())\n", + "plot_field(prior_permx, label='Prior log-permx (mD)', cmapname='coolwarm', cmax=cmax, cmin=cmin)\n", + "plot_field(posterior_permx, label='Posterior log-permx (mD)', cmapname='coolwarm', cmax=cmax, cmin=cmin)" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-20T12:04:16.005909Z", + "iopub.status.busy": "2026-08-20T12:04:16.005806Z", + "iopub.status.idle": "2026-08-20T12:04:16.732271Z", + "shell.execute_reply": "2026-08-20T12:04:16.731775Z" + }, + "scrolled": false + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "from misc.structures import PETDataFrame\n", + "from misc.read_input_csv import DataReader\n", + "\n", + "# Data\n", + "datainfo = {'truedata': 'data.csv', 'datavar': 'var.csv'}\n", + "reader = DataReader(datainfo)\n", + "data = reader.get_data()\n", + "var = reader.get_variance(data)\n", + "std = np.sqrt(var)\n", + "\n", + "# Prior and posterior forecasts\n", + "prior_forecast = PETDataFrame.from_pickle(\"Results/prior_forecast.pkl\")\n", + "prior_forecast.is_ensemble = True\n", + "\n", + "posterior_forecast = PETDataFrame.from_pickle(\"Results/posterior_forecast.pkl\")\n", + "posterior_forecast.is_ensemble = True\n", + "\n", + "\n", + "\n", + "def plot_rates(data, std, key, prior=None, post=None):\n", + " wells = ['PRO1', 'PRO2', 'PRO3']\n", + "\n", + " fig, ax = plt.subplots(1, 3, figsize=(15, 3.5), sharex=True, sharey=True)\n", + "\n", + " handles, labels = [], []\n", + "\n", + " for i, well in enumerate(wells):\n", + "\n", + " h = ax[i].errorbar(\n", + " data.index,\n", + " data[f'{key}:{well}'],\n", + " yerr=2 * std[f'{key}:{well}'],\n", + " fmt='o',\n", + " color='k',\n", + " capsize=3,\n", + " label=r'Data $\\pm$ 2$\\sigma$'\n", + " )\n", + "\n", + " if i == 0:\n", + " handles.append(h)\n", + " labels.append(r'Data $\\pm$ 2$\\sigma$')\n", + "\n", + " if prior is not None:\n", + " prior_ens = np.asarray(prior[f'{key}:{well}'].tolist())\n", + " h = ax[i].fill_between(\n", + " prior.index,\n", + " prior_ens.min(axis=1),\n", + " prior_ens.max(axis=1),\n", + " color='tab:blue',\n", + " alpha=0.4,\n", + " label='Prior Ensemble'\n", + " )\n", + " if i == 0:\n", + " handles.append(h)\n", + " labels.append('Prior Ensemble')\n", + "\n", + " if post is not None:\n", + " post_ens = np.asarray(post[f'{key}:{well}'].tolist())\n", + " h = ax[i].fill_between(\n", + " post.index,\n", + " post_ens.min(axis=1),\n", + " post_ens.max(axis=1),\n", + " color='tab:orange',\n", + " alpha=0.4,\n", + " label='Posterior Ensemble'\n", + " )\n", + " if i == 0:\n", + " handles.append(h)\n", + " labels.append('Posterior Ensemble')\n", + "\n", + " ax[i].set_title(well)\n", + " ax[i].grid(ls='--', alpha=0.4)\n", + "\n", + " ax[0].set_ylabel(rf'{key} [Sm$^3$/day]')\n", + "\n", + " fig.legend(\n", + " handles,\n", + " labels,\n", + " loc='lower center',\n", + " ncol=len(labels),\n", + " frameon=False\n", + " )\n", + "\n", + " plt.tight_layout(rect=[0, 0.08, 1, 1])\n", + " plt.show()\n", + "\n", + "\n", + "# Plot WOPR and WWPR\n", + "plot_rates(\n", + " data=data,\n", + " std=std,\n", + " prior=prior_forecast,\n", + " post=posterior_forecast,\n", + " key='WOPR',\n", + ")\n", + "\n", + "plot_rates(\n", + " data=data,\n", + " std=std,\n", + " prior=prior_forecast,\n", + " post=posterior_forecast,\n", + " key='WWPR',\n", + ")\n", + "\n", + "\n", + "\n", + "\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## A second scheme on the same case: GN-EnRML with the ``margis`` flavour\n", + "\n", + "ESMDA above is one scheme with one analysis flavour. PIPT separates the two: any of the five scheme classes (`EnKF`, `ES`, `ESMDA`, `LMEnRML`, `GNEnRML`) can be paired with any flavour it lists in its `COMPATIBLE_ANALYSES`. `GNEnRML` -- Gauss-Newton EnRML, damped by a step length `gamma` rather than ESMDA's fixed inflated schedule -- offers one flavour the others do not: `margis`, the marginalised iterative ensemble smoother of Stordal, Lorentzen & Fossum (2023), which treats the measurement-error variance itself as a hyperparameter and integrates it out rather than assuming it is known.\n", + "\n", + "Same grid, same wells, same prior, same observed data -- only the config's `scheme`/`analysis` keys and the `[dataassim.iteration]` block (GN-EnRML's step-length settings, in place of ESMDA's `[dataassim.mda]`) differ from `CONFIG_ESMDA.toml` above.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-20T12:04:16.733622Z", + "iopub.status.busy": "2026-08-20T12:04:16.733523Z", + "iopub.status.idle": "2026-08-20T12:04:16.853825Z", + "shell.execute_reply": "2026-08-20T12:04:16.852540Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[ensemble]\n", + " ne = 50\n", + " state = \"permx\"\n", + " [ensemble.prior_permx]\n", + " vario = \"sph\"\n", + " mean = \"priormean.npz\"\n", + " var = 1.0\n", + " range = 10.0\n", + " aniso = 1.0\n", + " angle = 0.0\n", + " grid = [10, 10, 2]\n", + "\n", + "[dataassim]\n", + " savefolder = \"Results_margis\"\n", + " scheme = \"gnenrml\"\n", + " analysis = \"margis\"\n", + " energy = 98.0\n", + " obsname = \"dates\"\n", + " data = \"data.csv\"\n", + " datavar = \"var.csv\"\n", + " savedata = [\"ensemble_misfit\"]\n", + "\n", + " # GN-EnRML settings\n", + " [dataassim.iteration]\n", + " max_iter = 10\n", + " gamma = 0.5\n", + " gamma_factor = 5\n", + " trunc_energy = 0.99\n", + "\n", + "\n", + "[simulator]\n", + " reporttype = \"dates\"\n", + " reportpoint = [\n", + " 2023-02-05T00:00:00,\n", + " 2024-03-11T00:00:00,\n", + " 2025-04-15T00:00:00,\n", + " 2026-05-20T00:00:00,\n", + " 2027-06-24T00:00:00,\n", + " 2028-07-28T00:00:00,\n", + " 2029-09-01T00:00:00,\n", + " 2030-10-06T00:00:00,\n", + " 2031-11-10T00:00:00,\n", + " 2032-12-14T00:00:00,\n", + " ]\n", + " sim_limit = 300.0\n", + " runfile = \"RUNFILE\"\n", + " parallel = 5\n", + " datatype = [\n", + " \"WOPR:PRO1\", \"WOPR:PRO2\", \"WOPR:PRO3\",\n", + " \"WWPR:PRO1\", \"WWPR:PRO2\", \"WWPR:PRO3\",\n", + " \"WWIR:INJ1\", \"WWIR:INJ2\", \"WWIR:INJ3\"\n", + " ]\n" + ] + } + ], + "source": [ + "!cat CONFIG_GNENRML_MARGIS.toml\n", + "kwda, kwsim, kwens = read_config.read('CONFIG_GNENRML_MARGIS.toml')\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Run it the same way as ESMDA above -- the class changes, nothing else about the call does:\n" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-20T12:04:16.856109Z", + "iopub.status.busy": "2026-08-20T12:04:16.855793Z", + "iopub.status.idle": "2026-08-20T12:13:45.481142Z", + "shell.execute_reply": "2026-08-20T12:13:45.480664Z" + } + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2026-08-20│15:03:43 : =========== Running Data Assimilation - GNENRML ===========\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1;33mSingle entry for VARIO will be copied to all 2 layers\u001b[1;m\n", + "\u001b[1;33mSingle entry for VARIANCE will be copied to all 2 layers\u001b[1;m\n", + "\u001b[1;33mSingle entry for ANISO will be copied to all 2 layers\u001b[1;m\n", + "\u001b[1;33mSingle entry for ANGLE will be copied to all 2 layers\u001b[1;m\n", + "\u001b[1;33mSingle entry for CORR_LENGTH will be copied to all 2 layers\u001b[1;m\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "67c00969dd6f47e1be115e6c48c8bf90", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + " 0%| | 0/50 [00:00 56729.8\n", + " message: \n", + " success: True\n", + " x: [[ 4.628e+00 4.543e+00 ... 4.607e+00 4.641e+00]\n", + " [ 4.384e+00 4.457e+00 ... 4.392e+00 3.667e+00]\n", + " ...\n", + " [ 3.516e+00 3.679e+00 ... 4.279e+00 2.941e+00]\n", + " [ 3.416e+00 3.876e+00 ... 4.779e+00 3.516e+00]]\n", + " nit: 8\n", + " why_stop: data_misfit_stop: True\n", + " data_misfit: 56729.82087772666\n", + " prev_data_misfit: 56977.181018155825\n", + " gamma: 0.032540970760065305\n", + " data_misfit: 56729.82087772666\n", + " prior_data_misfit: 112592494809.87149\n" + ] + } + ], + "source": [ + "from pipt import GNEnRML\n", + "\n", + "np.random.seed(10)\n", + "res_gn = GNEnRML.assimilate(kwda, kwens, flow(kwsim))\n", + "\n", + "print(f'data misfit: {res_gn.prior_data_misfit:.1f} -> {res_gn.data_misfit:.1f}')\n", + "print(res_gn)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Same misfit-per-iteration plot as for ESMDA, reading from `Results_margis` instead of `Results` -- the two runs were kept in separate `savefolder`s specifically so this cell and the ESMDA one above do not overwrite each other's output:\n" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-20T12:13:45.482448Z", + "iopub.status.busy": "2026-08-20T12:13:45.482357Z", + "iopub.status.idle": "2026-08-20T12:13:45.763000Z", + "shell.execute_reply": "2026-08-20T12:13:45.762237Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "result_folder = \"Results_margis\"\n", + "data_misfit_gn = []\n", + "\n", + "it = 0\n", + "while True:\n", + " file = Path(f\"{result_folder}/assimilation_result_{it}.npz\")\n", + " if not file.exists():\n", + " break\n", + " npzfile = np.load(file)\n", + " data_misfit_gn.append(npzfile[\"ensemble_misfit\"])\n", + " it += 1\n", + "\n", + "plt.style.use(\"seaborn-v0_8-whitegrid\")\n", + "fig, ax = plt.subplots(figsize=(9.2, 5.2), facecolor=\"white\")\n", + "bp = ax.boxplot(\n", + " data_misfit_gn,\n", + " positions=range(len(data_misfit_gn)),\n", + " widths=0.56,\n", + " patch_artist=True,\n", + " showfliers=True,\n", + " boxprops=dict(facecolor=\"#E45756\", alpha=0.28, linewidth=1.4, edgecolor=\"#B23A3D\"),\n", + " whiskerprops=dict(color=\"#B23A3D\", linewidth=1.3),\n", + " capprops=dict(color=\"#B23A3D\", linewidth=1.3),\n", + " medianprops=dict(color=\"#D62728\", linewidth=2.0),\n", + " flierprops=dict(marker=\"o\", markersize=6, markerfacecolor=\"#B23A3D\",\n", + " markeredgecolor=\"white\", markeredgewidth=0.4, alpha=0.42),\n", + ")\n", + "\n", + "positions = range(len(data_misfit_gn))\n", + "ax.set_xticks(positions)\n", + "ax.set_xticklabels([str(i) for i in positions], fontsize=10.5)\n", + "ax.set_xlabel(\"Iteration\", fontsize=12.5, fontweight=\"semibold\")\n", + "ax.set_ylabel(\"Data Misfit\", fontsize=12.5, fontweight=\"semibold\")\n", + "ax.set_yscale(\"log\")\n", + "y_min = max(1e-12, np.nanmin([np.nanmin(s) for s in data_misfit_gn]) * 0.75)\n", + "y_max = np.nanmax([np.nanmax(s) for s in data_misfit_gn]) * 5\n", + "ax.set_ylim(y_min, y_max)\n", + "ax.grid(which=\"major\", axis=\"both\", linestyle=\"--\", linewidth=0.7, alpha=0.35)\n", + "ax.grid(which=\"minor\", axis=\"y\", linestyle=\":\", linewidth=0.45, alpha=0.22)\n", + "ax.spines[\"top\"].set_visible(False)\n", + "ax.spines[\"right\"].set_visible(False)\n", + "ax.set_title(\"GN-EnRML / margis\", fontsize=13, fontweight=\"semibold\")\n", + "fig.tight_layout()\n", + "plt.show()\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Same two checks as for ESMDA: the permeability field itself, and the well rates it was conditioned on. `plot_field` is the exact function defined above -- reused as-is, only the ensemble it is called on changes. `prior_ensemble.npz` here is GN-EnRML's own prior draw, written fresh when its ensemble was built (a later, independent draw from ESMDA's, per the same prior distribution), not the one loaded from `Results/` above.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-20T12:13:45.765006Z", + "iopub.status.busy": "2026-08-20T12:13:45.764798Z", + "iopub.status.idle": "2026-08-20T12:13:46.479522Z", + "shell.execute_reply": "2026-08-20T12:13:46.479005Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAs8AAAIGCAYAAACrlWLLAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjYuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/P9b71AAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOz9eZxs+3nWh37XVPPQ87SnM0pH5xzJFrItjIwcy8az4iCDB2EcOdgBLMwlFwwkDAkYh/sJYwwmxoEbh09ugg0YAgkWxgPEFkaeJFs6OvPZu/fueapxzdP9Y/Wqvaq6qruqunoPOu/Xny2fPfTqX9fuXfWst573eZQ4jmMEQRAEQRAEQbgQ9WEfQBAEQRAEQRAeF0Q8C4IgCIIgCMKYiHgWBEEQBEEQhDER8SwIgiAIgiAIYyLiWRAEQRAEQRDGRMSzIAiCIAiCIIyJiGdBEARBEARBGBMRz4IgCIIgCIIwJiKeBUEQBEEQBGFMRDwLgiAIgiAIwpiIeBYEQRAEQRCEMRHxLAiCIAiCIAhjIuJZEARBEARBEMZExLMgCIIgCIIgjImIZ0EQBEEQBEEYExHPgiAIgiAIgjAmIp4FQRAEQRAEYUxEPAuCIAiCIAjCmIh4FgRBEARBEIQxEfEsCIIgCIIgCGMi4lkQBEEQBEEQxkTEsyAIgiAIgiCMiYhnQRAEQRAEQRgTEc+CIAiCIAiCMCYingVBEARBEARhTEQ8C4IgCIIgCMKYiHgWBEEQBEEQhDER8SwIgiAIgiAIYyLiWRAEQRAEQRDGRMSzIAiCIAiCIIyJiGdBEARBEARBGBMRz4IgCIIgCIIwJiKeBUEQBEEQBGFMRDwLgiAIgiAIwpiIeBYEQRAEQRCEMRHxLAiCIAiCIAhjIuJZEARBEARBEMZExLMgCIIgCIIgjImIZ0EQBEEQBEEYExHPgiAIgiAIgjAmIp4FQRAEQRAEYUxEPAuCIAiCIAjCmIh4FgRBEARBEIQxEfEsCIIgCIIgCGMi4lkQBEEQBEEQxkTEsyAIgiAIgiCMiYhnQRAEQRAEQRgTEc+CIAiCIAiCMCYingVBEARBEARhTEQ8C4IgCIIgCMKYiHgWBEEQBEEQhDER8SwIgiAIgiAIYyLiWRAEQRAEQRDGRMSzIAiCIAiCIIyJiGdBEARBEARBGBMRz4IgCIIgCIIwJiKeBUEQBEEQBGFMRDwLgiAIgiAIwpiIeBYEQRAEQRCEMRHxLAiCIAiCIAhjIuJZEARBEARBEMZExLMgCIIgCIIgjImIZ0EQBEEQBEEYExHPgiAIgiAIgjAmIp4FQRAEQRAEYUxEPAuCIAiCIAjCmIh4FgRBEARBEIQxEfEsCIIgCIIgCGMi4lkQBEEQBEEQxkTEsyAIgiAIgiCMiYhnQRAEQRAEQRgTEc+CIAiCIAiCMCYingVBEARBEARhTEQ8C4IgCIIgCMKYiHgWBEEQBEEQhDER8SwIgiAIgiAIYyLiWRAEQRAEQRDGRMSzIAiCIAiCIIyJiGdBEARBEARBGBMRz4IgCIIgCIIwJiKeBUEQBEEQBGFMRDwLgiAIgiAIwpiIeBYEQRAEQRCEMRHxLAiCIAiCIAhjIuJZEARBEARBEMZExLMgCIIgCIIgjImIZ0EQBEEQBEEYExHPgiAIgiAIgjAmIp4FQRAEQRAEYUxEPAuCIAiCIAjCmIh4FgRBEARBEIQxEfEsCIIgCIIgCGMi4lkQBEEQBEEQxkTEsyAIgiAIgiCMiYhnQRAEQRAEQRgTEc+CIAiCIAiCMCYingVBEARBEARhTEQ8C4IgCIIgCMKYiHgWBEEQBEEQhDER8SwIgiAIgiAIYyLiWRAEQRAEQRDGRMSzIAiCIAiCIIyJiGdBEARBEARBGBMRz4IgCIIgCIIwJiKeBUEQBEEQBGFMRDwLgiAIgiAIwpiIeBYEQRAEQRCEMRHxLAiCIAiCIAhjIuJZEAThEeCJX4FPHMPHXoaFX4ZDr//3P/Yy/MTu/Z/ftuG5T8HSL8N3vHT/13dd+OrPwNonH8ixBUEQ3naIeBYEQXjEmNfhT791/p95sgivvB/+2LX7v7blwFd+Bt5budLjCYIgvK0R8SwIgvCI8SdvwC824JOtyT5OU+DfvAe+efFqziUIgiCIeBYEQXjkKKnwN5+Bj78GYTz+x63nk4m0IAiCcHWIeBYEQXgE+cgyrOXgR7cf9kkEQRCELCKeBUEQHlH+zrPwVzZhz33YJxEEQRBSRDwLgiA8ojxbgu9bhx/MLA/eseFfH9//uRtDRXvwZxMEQXi7IuJZEAThEebP3YJfasJ/bCc/3/fho59PkjW8CH6uAR+oP9QjCoIgvK3QH/YBBEEQhNGUNPhbz8BHTrOc31+Dv/AEfPAzSbrG183Dd68lv/eP9uC/3wQrgiM/yYGGJNJOEARBmA1KHMcT7HILgiAIgiAIwtsXsW0IgiAIgiAIwpiIeBYEQRAEQRCEMRHxLAiCIAiCIAhjIuJZEARBEARBEMZExLMgCIIgCIIgjIlE1QmCIDwmvNRw+CdvNfnUQYeVYo4P36rzzTdqFHSZgwiCIDwoJKpOEAThMeBv/PLn+TufvkdUmUPV8wRRhO52WQq6/Pr3f+PDPp4gCMLbBpk8C4IgPAaYjoN95xUA5us1Gq02PmDWqg/3YIIgCG8z5L0+QRCExw15w1AQBOGhIeJZEARBEARBEMZExLMgCIIgCIIgjImIZ0EQBEEQBEEYExHPgiAIgiAIgjAmIp4FQRAEQRAEYUxEPAuCIDwGKCgP+wiCIAgCIp4FQRAeC0Q6C4IgPBqIeBYEYSKe+BX4xDF87GVY+GU49Pp//2Mvw0/s3v/5bRue+xQs/TJ8x0v3f/0v3YF3fCr58bW/BXfsB3J8QRAEQbgUIp4FQZiaeR3+9Fvn/5kni/DK++GPXbv/az+xC//sEH79ffDa++H5EvzxN672rIIgCIIwC0Q8C4IwNX/yBvxiAz7ZmuzjvrgCP/Ec1PTk5x+ah1es2Z9PEARBEGaNiGdBEKampMLffAY+/hqEEzRGf3EVfkf1/s//r2P43fXZn08QBEEQZo2IZ0EQLsVHlmEtBz+6Pd3H//gO/JsT+KtPzfZcgiAIgnAViHgWBOHS/J1n4a9swp472cf9pTvwN+7Bv/tiWMldxcm+AIlj4iiGOBn1TzDwFwRBEGaAiGdBEC7NsyX4vnX4wczy4B0b/vXx/Z+7MVS0+z//727D/30Mn3xvslQoDCeKIjzPw/N94igijmPCKCSOIY5j4jgmCAKi098TBEEQrhYRz4IgzIQ/dwt+qQn/sZ38fN+Hj34ethzwIvi5Bnzg1Nf8yRb8g134N++BJZk49xHHMWEY4rou3W6XdrtNp9PBtiyiKCIMQ4IgIAwDwjAkDEM6nQ6O4+C6Lr7vE4ahCGlBEIQrQn/YBxAE4QuDkgZ/6xn4yGmW8/tr8BeegA9+BjQFvm4evnst+b0f2QIzgi//zf5r/OaXJNd5u5EKZt/3e+LX930sy8K27eSH44CioKoquVwOzfWI44g4irh9+zaGYVCpVKhUKpRKJTRNQ1XV3v9XFKlZEQRBmAVKLOMJQRCEB04URQRBQBAEPcHsui6WZWFZFp7nUSwWqVQqlMtl/van3uDv/9tfAWCuVqHV6Z7+d5XP/JmP0u126XQ6tNvJ6D8V0pVKZaiQFjEtCIIwHTJ5FgRBeADEcdwTzL7v02g0yOVyBEGAZVmYpkkcx5RKJRYWFiiXy2jaxWN45XQaXavVqNVqbGxsYNs2nU6Ho6MjdnZ2KJVKVKtVyuUytm1TLpcpFouoqipTaUEQhAkR8SwIgnBFZO0YiU85+W/btjk6OgJA0zQqlQpra2uUSqVLC1lFUSiVSpRKJVZXV/E8rzeR3tvbQ1EUqtUqi4uLFAqFnoAWe4cgCMJ4iHgWBEGYIelSX9a/7Hketm1jWRaO4/RE68LCAnNzc1cqWHO5HIuLiywuLhKGIa+99hphGLK5uYmqqn32jqyIFnuHIAjCcEQ8C4IgXIJsXFw6YQ6CAMdxeoI5CAJKpRL1ep2NjQ10XWdzcxPDMCYUpzExEIYhURxPLGw1TUPTNJaXlymXy5imSafTYX9/n+3tbcrlMtVqlUqlgmEY4pMWBEEYgohnQRCujJcaDk9VcxT1L6xUzNSOkbVkpHaMVDArikK5XGZ5eZlSqYSqTvcYRFGEbdt0ux3CMEw+fxQRRRHEMb7nc3x8TLVaJZcbP/dPUZTexHltbQ3Xdel0OjSbTXZ3d3vLipVKRewdgiAIGUQ8C4IwU/79VpOfeLPFp/a7dF2fWFF4z1KZ33ezyvc8v/qwjzc16XQ5m46RtWPYtk0ul6NSqTA/P0+hUJhaYIZhiGmadLtdTNNE0zQUFFRNRUFBNwx0TSOOQVVV2u02u7u7FAoFqtUqtVptos+vKAqFQoFCocDy8jJBEPR80kdHR+i63ptIl8vlnpAWe4cgCG9HRDwLgjBTfvTnf5VPvrGFsXaDcnUOu9Pht25/ljc/5fE9/+1/8bCPNxHD4uSydgzP8yiVSr3prWEYU38uz/N6gtm2bfL5PJVKhYWFheS/tx2UgV4rRQFN13jyySd7ZSntdpvbt2/3EjjSlI1JJt+6rjM/P8/8/DxRFGGaJu12m52dHaIo6k2kq9WqxOAJgvC2Q8SzIAgzRVMUAqtD8NbnKc3NYTebAETVysM92BgMxsmlCRnpZNmyLOI4plwus7i42CsjmfZzeZ7H0dER3W4X3/cpFotUq9WphLimaczNzTE3N9cTvJ1Oh52dHcIwpFKpUKvVJm4eVFWVarVKtVoljmMcx6HdbnNyctIXg1epVMjn8yiKcmbpUBAE4QsJEc+CIMwUTbsvlrIyLY4ezT6mwTi59EdaVmLbNrquUy6XWV9fp1gsTi0IoyjCsiy63S6e53F8fEylUrm0EB9kmOBNc59932dvb4+5uTlqtdrEPulisUixWOyLwet0OhwcHPRsK5VKhWKxKC2HgiB8QSLiWRCEmaIqGXtARi9Hj1CZ6ag4uVQwu65LoVCgUqmwvLxMLpebWvgFQdCzY1iW1RPihmGwuLhIrVab8VfXT1bwrqys8Oqrr1Iqleh2u+zv75PL5Xo+6UlvDAZj8NKWw62tLYA+e8ewhUMR04IgPI6IeBYEYaZoGUEUZ7TRpHaBWZK1Y6SWjDTFIhXMYRhSLpeZm5ujXC6j69M9PaZ2jFQwp7nOlUqFpaWlnhDf3NycSDzG6f/FcSL4o2hq8Vmr1ahUKj3B2263e+dJJ9Zp7vO4aJpGvV6nXq8TxzGWZdHpdDg8PGRnZ4dyudwT0+ljIPYOQRAeR0Q8C4IwUzR1hG3jAYvn1I6RXfZL4+RSO0Ya17a6utqrq572c9m23RPMw3KdL3vdZqNJFIaJ6Dw9ZxRFeK7L5uZmbzlwnM+VCtVBwZv6pHd3dwmCoOeTHve62euXy2XK5XJfDF7acpimgkgMniAIjyMingVBmClaVoBmBPODsG1ky0rS6XLWjuE4Dvl8vrfwly64TUO6lJcK5lnmOg+7brlSPvVEK6ia1nucc7kcxWKRk5MTtre3ewt8tVqNfD4/9ucdlft82esC5PN58vk8S0tLvRi8TqfD8fFxz5+djcGTlkNBEB5lRDwLgjBTVHW40LmqyfNgOsbBwQGapvUmqUEQUCwWqdVqrK+vXypOzvf9vjg5wzAol8tcu3btUrnOQRD0Mp1TX3SlUum7bu71E+Ds9RVVYWVlhZWVFXzf7014Dw4OMAyDWq02sZ95MPc5vW66GJhet1qtUiqVJvq6h8XgdTod9vb2etaZarVKq9VifX2dQqEgPmlBEB4pRDwLgjBT+jzPmV+Pomgm1x/W7hcEQa/dr9Pp9Ly7S0tLE2ccD34uz/Podrt0u11c16VYLFIul1lZWZkoqWLwulEU0e12aTQafb7odEFxkHFEo2EYLCwssLCw0LfAt7m5CSRe5yhtJ5yA7HXTc7fbbe7evQvQ55OeJDFkVCpIo9HAtm22trZ6/ux8Pi/2DkEQHglEPAuCMFO0vsnzffl8mcnzsHY/3/d73uXsFDifz1Or1Zifn5/6cyV12IlgTqeh8/PzlMvlS+U6O47Tu67v+6iqytzc3Fi+6Ell4ig/cxiG3L17d2o/c1q+kmZG27bdm3RvbW1RLpd7151kyj+YCvLSSy9RrVaxbZvDw0MMw+jZSqTlUBCEh4mIZ0EQZkp2ypvVyzGTiedh7X6u6/YE86gp8NbW1sQiKq3DTn/MapEwm+tsmiZxHPdSN05OTlhYWKBarU5+4QlvRLJ+5larxerqKr7v9/mZU8E7qU+6VCpRKpX6fNLNZpOdnZ1e6Uvqk57k70VRFOr1Oqurq33T7u3tbeB+DF467ZYYPEEQHhQingVBmCnaCNFyUUnKqHa/dLJsWRZRFFEqlc6dAo8rmnzf7/MZpwUf169fv9Qi4bBc50qlcqZgpdFoTHTdMAyI44gojvG85PFRVJUoTGwY4wp8RVHI5XLMz8/3fNLtdptOp3Pp3OdRi4FHR0domtZXFz7OddM/M2rafXR01NdymL7zIDF4giBcJSKeBUGYKZNE1Q1r90vrsNMfmqb1psCTLqcNfi7XdXu2Cc/zKJVKlMtlVldXL7VImPVFp/7lcrncl+s8zXkdx+kJ8UajQRzHqIpCLmegulrPzvLKK6/02TAmsZakZS3ZopN2u82dO3d6nuRarTaxd3zYYmC73WZra4soinpe51HnHWXzGZx2e57XE/97e3vk8/nedfP5vLQcCoIwc0Q8C4IwU/o8z3H/f6aLasPa/dLpchonN1gqMgmp8EqLUFJhG8cx5XKZhYWFmfqX01znWq126Vzn1OaRPe/i4iILCyaqenpeRUFVFDidIj/55JO9SeygDWOSpcZRPumdnR3CMOy1BU7jk84uBqaLnZc9LyRRfUtLSywtLRGGYW/avbm5iaqqffYOaTkUBGEWiHgWBGGmZHOeez7nOPmfZqeLGic2A8dxetPlWYnPFMdx2NnZwTTN3uR6bW3tUpPrYf7ldLp8mUSPQb+1qqq9cpHseUdeX6G3aLe6utqbxLbbbXZ3dykUCj3Lw2Vyn9MkjOPj4z7BW6vVJhK82clxet40Xi89byqyJ0XTNObm5pibm+sT//v7+2xvb/cJacMwxN4hCMJUiHgWBGGmaMqpyItjoig+9TonMvrg6BglSEpLZlUqAvdtE6ZpYts2uq5Tr9dZXFyc2jYBw/3L5XL5jH95UlKbyvHxMbu7uzPzW0P/JDbrOz48PETXdcIwxHGciW4kBpMwsoI39Umnk+NJH5dcLtdnG0nPC3D79u0+n/Qk3yOjSl+azSa7u7sUi8XeJF1i8ARBmAQRz4IgzITUfxuFAfGpPSOKQqI4SqaIcUyz2WJ1oc78/PylSkWytgnTNPF9v5fskIryaaPqBoX4ZS0k6XkH86JTQbqxsTF1XvRFDPqOu90u9+7dY39/n4ODg56fObU0jMug4J2VTzo7OU5TQWzbvrRtZLD0Jb2pSK0uuq73tRwOm0iLmBYEIUXEsyAIUzOYjhEEAZ7rEMUxcRzjByGcLrkpqsrGzRvMF6YTiqNi3xYXF/tEmmVZE73lf54QX1tbm3qRMPX2ppPr1JoyNzdHpVJhe3ubcrk8tnC+r91iojC5IZlE0KWJFZqmcePGDYDekp3v+1PnPmd90unfUbvd7hO80ywyAr2boGyByqBtZNJ4PRi9zLizs0MURT2RXi6X0XVdfNKCIPQh4ll4IDzxK/Bj74B/fAD/8hhe/TJYzmiGj70M/8kcfGw9+fltG77ht+HIh6+Zh3/8Atgh/PE34N83IYrhvdXkmovThyQIE3JRu59lWdim1RPMuq4TqPcFUxBO5mMdN/YtyzjCJhV56bWzi3mlUmnqRcJBgQ/MxJri+z62bRNGyc1IGCV/BwCBn1R7jxv/Bvd9x2nSiOu6tNvtS+c+Zxf0UsGbTnfTApV0Kn3eTUN685N+PYO2kWwN+WXj9Ya1HLbb7T6Rnk6lU0uN2DseDG8u/270W+sohgFRBKpK7T//Fub+yLcBcPDHfhjzZ/8D2uJc8gFRBDmDuY9/J7Xv+IbedbxXb3PyV/8Bzq+/hFLMoxTy1D76jdT/8LehZP5Ntv/3/5uj//p/ZPEvfT/1j/1nD/ArFR43RDwLD5x5Hf70W/C/PDf6zzxZhFfeD//dbXjFSn7tL2/CiQ+f/9JkCvf7XoK/cBv+3jsezLnfroxq9+uJ5VOPceoFXj7w76dCDBSjBGNkPXue1xO12drqy9gm4P5iXips00XCy/qXU9vCJAL/IrKxeqZp4rounuf1JviGYaDpek9kZuPfUhvGuDcAWUvDKGE6jZ85K3gHFwP39vZ6i4G1Wm1iC89FNeTT2lFGnbnT6XBwcNDzplcqld7NkLQcXi3r/8dfI/fsLQCCnQO2vuGPYtxco/yNHwSg9l0fZvEv/pHen3dffovtb/yj5F94hvy7n8V7fZPtD/8xFv7r72X1H/5lFE3D39rn4A//JbzXNln5W38GgOMf+jH8N+9hPHPjwX+RwmOHiGfhgfMnb8D/cBc+2YIP1Mf/uK9fgO9dB/30tfBr5uGfH17NGd/uDLb77e/vUywWe5XYruv2RO3y8nKfqO1L2xjQysPEc7YO2zTNnr2hXq9PnbyRisqsEM/6ly+7SDjqupf1RZ9XC14/DFGU+4+tQiL2dEPnne9855ma7NR6UKvVJnoMhwnTrJ952gW+UYuBt2/fPnPd7MT5Igbj9VLbSNaOMs3jMOzMqUjf2toC7rccOo7Tm06LvePq0DdWqHz4K7H+3a/1xPMg+Xc9Re7pG3ivvEX+3c/S+B/+v1S+5auof8/v7f0Z4/oqq//gL3H3/d/J3B/9dnLveILy132Awpe9m+1v+YEH9eUIjzEinoUHTkmFv/kMfPw1+I0vAW3M15evnLv/38c+/OQB/L7lKzni245h7X5pRnKayZtaA+bm5npe0GHoI0pSAMI4XSSM+qbAs0reSL8Oy7LodDq9IpRZ+JeHFaxc5rqKohDHce+a3W639zisrKxM9DgMq8lut9s0Go1eA18qTidhlJ95e3t76kl3et10MTD9Xuh0Or3rVioVIJnqT7oYWC6Xe1F/acJG+jgUi8U+O8ok4naYSE9TTNKbqdTPnt5ASQze7In9ECU3+t+b/cu/iffGXQpf8mLy809+mpW/8+fO/Dl9fZn8Fz+H9e9+ndw7nqDwZe++sjMLX3iIeBYeCh9Zhh/fgR/dhj9+fbKP/arPwC+34KMr8Ec3ruR4bwuGtful/uXUjpHGfWmaxtraGuVy+cLr9tVz96nnmGarxVa3gW3bGIZBpVLh2rVrl0reGCxCCcOwNzG8jH85W1himiZRFM2kYCWdYLquy/7+/swehyz5fJ7l5WWWl5fP2DDiOObk5KRn1xj382X9zOvr6z1vcDrpzvqZJ7mZyHqO0+u2Wi0AXn/9dcrl8lQFKsMSNtImwoODAwzD6J130vzvQZH++uuvk8/nz1hSUp+0tBzOBu/V25j/6hdZ/Yc/1Pu19v/2rzB/5pcACA9P0G9tsPa//BWMJ68lv9bsoK0sDL2evrpI1Ghd/cGFLzhEPAsPjb/zLHzg0/BtE06Pf/GLwQrhT7wBH30Z/skLV3K8L0iiKOpr94uiCM/zemUlabtfujyXTufSXOZxuG/biInjqC+qrtXpcuvaMisrK5eKZxvlX15bW6PdbveE0TTXzQrm9OZhdXWVYrF4qYW/VNynNg9VVZmfn2dhYeFKxdSgDePVV1/F931u376Npml9sXLT+pnTCW+r1eplKKfXnWTCm143n89zdHTE008/3UvCyBaoTOOT1nW99ziksX2dToe7d+8C9AT8pFP09Nz1ep1ardaXrX18fNy7OUhj8LIiWuwdF7P7nT/YWxhU56os/fd/guKXf1Hv97Oe58bf+F+xf+UzlL7qy3q/ry3NE+wekn/3s2euHeweUfidX3Tm1wXhIkQ8Cw+NZ0vwfevwg29B+lJ1x4bPW/CNi8nP3Rgqp7/5zw7hd9bgWh5KGvzhDfjKTz+Uoz82pDaGQcHsum4vbSIIgt7b2evr60OnhqnFYJzPF/oeURQRxxFK2B9Vt7K6xvx8baqvZZgATSfBWYGWFmyMSxAEfddNJ8GXKSwZlutcKpV6At8wDO7du9druZvgyskCp5/YaiY9WyraVldXKRQKPWG6tbVFHMc9AVmtVie6Ucjn8+Tz+b5ilna7zeHh4VQT3vR7LZfLUSwWe9dN/deDwn9Sq0/qsU4bLQf94tNO0WF4DF4aCZhG96VCWloOLya7MHgR9T/67bR+4l9gfuKXKX/9VwBQ+uD7MP/lL1L+2t/V92eD3UPc336V5f/xz878zMIXPiKehYfKn7sFz/8qFNQkqm7fh49+Hj73pbCSg59rwPefWjN+6gD+9TH8+DsTn/S/OEri6oR+UjtGNh1jME4uzUi+bLU09E+BLcuieypeVU1F1zTQtN7ioB9GE30dw3zGWQE6jIvEx7BEj2Kx2PMaTzsRH5brnF34m9bmkd40tFqtJJ5OUVBUhThOSmg812NnZ2fi6fFgRFsqIPf393sLh9PkPg8rZmm3230T3mmSMHRdH+qTziaNpD8meayH+cWzU/S03rxarY6cdo/K3B4Wg5f1YKffz1kPttg7pkctFVj409/D8V/8UUofej9KzmD+B7+Hrd/zfTR/7Keof+9HUHSdYHuf/T/yQ9S+68PknpZ0DWFyRDwLD5WSBn/rGfjIS8nP31+Dv/AEfPAziUD+unn47rXk9370Wfj+1+GdnwJVgacK8BPnxN29nRg3Tq5SqbCxsTHxW96Dk+fzpsBrlj5SFIUXTK+vymecLULJFpZcJtEDribXedjUulgsksvlTr/+ZFKpaSoxSWxdHMd90+NJxemohcPB3OeL8pkHyU54s0kYu7u7BEFwoUAf9T066JNOl1oPDw/P5FRPejM0bIre6XQ4OjoaOe0ep7BmVFZ1eu70HY9qtdqb0Iu9Y3KqH/0mmj/2UzT//k8x/wN/AOPWBtf+9f/EyQ//OM3/6SdRcjpqqUDtD/6n1P7QR3oft/W1/yVRxyTY3sd//S6tv/9PqP+hj1D/3m99iF+N8KiixJNUcQmC8MgwmI4RhiGu6/YEcyq6yuVyLwFgWu7cuUOtVutNEtMpcHrt7BT4n750jz/zkz8LgFEoELhOb/L8j//w7+VLr/Uv7wxOrlVV7V130kUugP39fVRVZXFxcWgjYbroNe20fdBvnWZcVyqViXKQ79271/PJjhL36Vv8mqbxNz/5Mn/333ySKAypFHJ0bRdV01hamOMzf+YP9E2P2+32yNbAl19+mSeeeIJisTjWOX3f7y3amaZJPp+f2neckr6rkJ7VcZw+ga6qKq+88grPP//8xH9Pnuf1rmtZ1liT43HITrvb7XbftHt/f59r1671UkKmuXY6oU9tR1khLS2HgvBoIZNnQXhMGBYnFwQBjuP0BHMURZRKpUtbBaC/hc/zPI6Pj3sZyeelWGjZqLo4RuF+6EZ0+l/p5No0TSzL6pVPDPqXJyXr7W42mzMrQhk87yzyolMBub+/39dymLXSpH8Hh/c22b97j9BzicOAyLeJwphI03FMk9/+j59k+cYtllfXWFtb62sNTJvy0tSKSeclhmGcyWfO+o6H5TNfxGAxy2CBStpqaNv2xDdQuVyOpaWlkZPjac4Lw1NB0vZE3/fZ29tjbm5u4ul8eu3shD69CUpj8LIth+n3m9g7BOHhIZNnQXiEGWbHyMbJWZbVE4jlcnmqSW2WtA47/ZFe2zRNFhcXqdUuXvb7l6/u8F/9/34GAD2fJ/JcojgmBv7ut30VL1T13lQ8naxOm78MZy0kmqZhGAarq6uXErbDrBOXPW8237rT6fQJslTcR1GUvJV/9zZ2p4O/dxf3zZf4x60C/9xKJpsVXaUbJP7xmqHy4/nXMW4+S+7p5zGqdRbXr7F67XpPxA1OY/P5fG/qXSgULvW1pNeF6f3MWcIwpNVqsbOz0xOI0ySCnHfeTqdzqZzqQV555RXq9TqO4/RuBqdpZRxG6sEenPxXKhUKhUKftUOm0oLwYJDJsyA8Ygy2+4VhiOd5PcGcxsnNorIa6IlE0zSxbZtCodCLqkuvfe/evbGvdz/nOSaOIqIoJDxtFnRdn/mby5f2Lw9WV2cXCRuNBkBvejnJdYdZJ9Lii2nPm96QpLaU1NuaCti5uTnCMOTk+JijrU3cbhd/6028tz5P1Dy6fyHjqdFnd0y81z6D99pnwMjTuf4Ue8+8iF5fYH55ldWbt3rT2M9//vPUajVs2+55bdOp5yRCLyv8s4kV2Wa/aRYOU7EM8M53vrNXRnKZCvLB82anu7NI2ACo1+usr68PbWXMiv9JbyqyHuxsM+Pdu3f7srfTGxaxdwjC1SPiWRAeMhe1+1mW1RNyabTWtAtu6ecbJhLTt6Mvc+0wDPEcmygKE3uAGgJJ8oaCQn1hfqzp9bAzn1ddnRVR48bqwdmFv9QXfdmmw8Fp+GCVOZB83naT3Tdfwzc7eLdfxdt8lbh7ydIG3yW4/TLd2y+DptFZu8XBO96DvrBCbX4BVL2XXT2qfnua3Od04TBrGUkXDrPCdNKFw8HFwEHBmwr0SQTvRQkbk+ZUZxcGB5sIU5/0zs5OL6ou/Zom/beWbWbMXnt/f5/t7e0+IS0xeIJwdYh4Fh45oii6VHTa48Bgu98wO8asKqvh/lvW6Q/gjL/2PM4TpL7v901Wza4DGU8mcUR4+qHpBHqSM8+6sGRUwcplfNGjcp0H67s9z2P33l0aezv4nRbumy8R3HuD2LGm+louJAwJt9/C3H4LFIXu8jVyz7zIK4e7lGt1Vp94emj99uCUd5Lc54v8zONGv6XXyl53mOBtNpt91dup4J2E83KqdV2f2iedfs+m74qMSjFJo+omYdi108cjewOQ+qTfbi2Hb4fXEeHhIeJZeCTYNn1+8q0G/3arze2WxUopzzfdmuNjzy6wWpreD/sokZaVOI6D67pomtZnx7Btu7c4Nz8/f+mq5rRUIl1yu0xUHdwXNKltIhWgWT/wysoKW0YTVRn+onWRdh48s2EYlMvlS1dXDwr8UQUrkzBsgj9sGm6aJtt37mCeHOK3TnDf+CzB1m0IvMk+H6CHPmrgEdkBORTQcyj6mJ7lOCY82MI+2MIGugsrNJ56HuPakxQqVRav3WRldbV3IzGr3Oe0Kn1w4TC7wDdNRfag4B2s3p7GigLDc6o7nU7PujSsiXDcqLrsTcVgbXp65mxU3bgMqyIfvAHIthwmJUZx7yb0C8XeEUURR//2k2z99Cdo/NbL6Pk8C+//Ita/8atY+OCXipgWZoYsDAqPBO/6G/8cu7KIX6igqypx4KNaTVYim1/9gf/0YR9vKgbb/dIJc6PRoNPp9MRzKjzL5fKl4uSy00/TNHEcp2cXuGxU3dbWVu/js7aJ9NxZ28QvbR7ysX/4LwHQdB0lCjjdbeNHvusb+aZ3rPddOzuxncWZDw8PCcOQ+fn5K1n4y9pHUptHGquXJmTYts3h7jbdVpPQbBPHERhFwtYJ3iu/SbS7OfHnbkYqP+9X+XWvxF6okVMiXjA8/pOcyXt0e/IvplDCeO59GNeeAAUUu4NWXyRXKrNy7SaLyyvout4XK9fpdLBtu88uMe33VVaYDi4c5nI53njjDV588cWpr5ueV1GUS3mOU7I+6U6ng+d5vcdhd3eXp59+eurly9Q+k/qZYTbLlzB8UbJQKOD7Pk8++WRfDF6a4vG4CunP/Pj/xm/87X/IgpajqOpEtkOY0zmJA178/j/I+z7+sYd9ROELBJk8C48EQfsYeydpICvX6rTaie/Tmp97iKeanGy7X/ZHuoWfxskpinLp4o/086ViLq3ankX5ByQv6KkfOF1UrFarrKysnGsj0TIvvDGQfRkO47hvYmuaJr7vz+TM6XVt2+5ZBdKFv3K5PPV1s4+DaZq9Ja2szSNNyDja2cY2O4TtY/yDu8Sdk8yVFJTqPIUXvwTl/V9N1G3jvf7bhJuvjXWOOTXiW/MtvjXfwg/BmObbplwj//yXoK3dgDAgOtgk+Nwvge8A4ANOroi5cpOtjScxihUW1jZYWd9gZWXljA0j28A3rj84ZbAie7BABaDRaEw86R6MfZuV53hUkUyz2SSO477c7knfzRj0SadLktnly/TMk974DWs5PDw8xLZtXnvttd5NcHoj9DjH4DmWzT27wz1ANQzKqkbHTF5L3m2I3BFmh3w3CY8EekZAxlHQ++8wDB/GcSZi3Ha/crnc28Y/Pj6eanEOzoq51Ps4C2901t5g23YvGSItW1lYWLjwGrqW/fzxqXiOiYk5Pmnw1lt2L9N4cXHxUtPAYZNgXdcpFApsbGxMfd1h9pFKpcL169d7wigMQ05OTjjZ28axTMLGPsHhFrHVHnHVmLhzQnAqqJXyHLlnnkd571cQ2xb+W58neP23xzrfJMJZrS9ivPAl6EvrxJ5DtL9J8Fu/AIE//AM8m3DrVcKtV3F0A3PpOnvXnkEv15hbXmF143rPhjFoD5jWLpH6+8vlMmtra700icGM6kkn3YO+4LQe+7LXhcQ2sry8zPLyMp/73Oeo1+t9CSbZJsJJLRjZxyIr0lNv9yTLjIPXTr3hQRBw/fr13rT74OCgZxvLFhQ9Ti2HoZf5nlaVvkZTbUJPuSCch4hn4ZFAH0hLSAmi6GEc50KGtft5ntebLruueyZhIf260oW9SRhVKnJZL/CoPONyuczKykpPUOzs7Ix9TT0TVReFEWSi6iLiSxeWDGskzE6Cj4+PCYJgqma67I3DsISMIAg4OjzgeG8H37EJjrYJjrbBnXzhLzabhGYTAKVYxbh+i9wLXwKei3/7VfxXPwOZG8lJUJc3yD33O9AWlogdi3DvNv69lyCc8HqBT7R3G3fvNq6qYS2scXTtWbTaPLX5BVav3zrjD26322xubqIoSt+i3SQLh6kofOaZZ2Y26R6sxx513WmbCOfm5lhZWel7HO7eTd5Nu4wFIyvSZ7XMmHq0B/3oqXVka2urd+7HKQYvdPv3CGLui2c9P71tTRAGEfEsPBL0TZ4zb/QHj8jkeVicXLr8Z9s2pmkShuFYNoFxotSGZRlnl/Iu640eZvU4L8943BdJ3/exzG4vqk5RYzRFOY2qg3IlWYaalHQSnArmWTQSZh/jbOX4YGSf53ns7mzRPDjAd0yCg3uEJ7vguxN/zpFnsTuEW6/C1qtQKKMvr2O847sgDPHvvon/yq+Dd/6CobrxBLl3fDFafZ7YbCWC+a3fhHhGN6BRSHy0jXu0DYqCPbfCycYzaHPLlGs11m4+2ROJqV2i3W6zvb09VT5z+neaFXjZxsDLTnjHWWQcR5QOJoMM2kZmacEYtcy4tbXV89+P8xgPW3AcZh1JYwGzcYPpbsajaO8IBv6NZJ9n9YJMnoXZIeJZeCQwtOHTmDB8eJPn89r9UktG+rbwRT7gYdceJGtBME1z5lXbg7Fvs4jBGza5dhzuLx6pKioxyulf4wRJdWcWCce9ebhI6AzeOKR2lOxj7DgOe1v3aDeOCawu/v4mUXN/8sntNDgm4e4bsPsG5Aro82sYX/+dEEOwcwfvpV+D02g77dY7yT3zImqlRtw+Idx/C//1Q7jqPfA4Jm7s4zX2kyNXF2htPIW2uEGxXGH15pPMz8+fSe5I85kvSu4YdXM5TDxmJ7zpNSed8Gbzk7MLdqkoHZawMQ6jLBiNRqMvXi+Nqpu0Lnyw0ju1X2RLX4ZZUi5KB8mee319vXfuNAe7UCj0Ho98Pn+m5fBhpVqEWfGsKMmi7im62DaEGSLiWXgkMLKT58yT+oP2PA+2+0VR1LNjpKL5sjFn2cnzsMzhcrnM6urqTKq2s0Udl4l9y575osKSqGGinEbVxXHctzEYniPqRpW3XHaRcLAIBThz45DeuOzvbGF2TSLXxL/3KnHraHaT22nwHML9O7B/B/Qc6vwq5W/+7uT3FIX4ZJdw+xXC9vHDOyMQd07wXz1JFg5LVTq3n0Fdf5q8obF6/RZLy8usra2dm3U8TYHK4IQ3tWCki4GpMJ1FE2E2si+ddqdpJDDeuzNZC0YaVTcYrzdtVN1gSc2gJSU9c6FQGCtab9S5s9P/4+PjXk56mrzzMO0dgdfv488+3egFsW0Is0PEs/BIoOtZ28Z9rlo8j2r3S+0YlmX1vZ2fLbyYlvRz3Lt3ryfGL2tBSL+WUVF1s7B6uK7L3t4e3W63N5kaNnHXs1OnGLJfTjAwek5FT3bhb5LyllFEUUS73T63CKWXkLG/i2V2CbstvJM9UFT0uWW0m8+DYxLs34bW0cWf9KpQFJTKAvrcCkqphmK2oFQlcmyU6gL6M7+D6PAe4f4meFNE1s0KPYdy83n0hbWkGOfu5+k2D7DeWmFr9QmMUpnFtWssr671Cch2u32mQGWawpDshDddDDw6OuprIpy0entUwkY6OU5r4dM/OwmGYbCwsMDCwsKV+KSzGdjptW/fvo2qqr32wWmKRAan/2mayd7eXu+mJRXSD7rlMPTvi2eFAc/zlDGCgjAMEc/CI8Eo20YM+EGIoU9vWThzzRHtftk4udQ/uLi4SKlUunScnOM4vQmzd/rW4izEeDoZS689y6i6IAj6puKqqlKv1y+cXOta/6/HmcC66PSxH4x+S98evswiYVYk+L6P53lnbkqiKKLRaHC8t4tjWwSdE7zGPrHTv8TpnS7yqaUa+uqTKLdeBNcm3L9N3DyY6nwToagotaVEMBfKEIWgKITdE8L2MXG6oKhqqNUFtIU1jPWnkvi54x3CvdvgTL6YOjG5AurN59HmVyEKiA7v4b/0y31+8NBsEW69jqPnMJc22F1/Cr1UZX5phZWNa32+4zSL+PDwkDiO2d3dndjPPGwxMBXo01RvZxk2OW61kii0N998c+pillFT9KxPepqCGkjE7qAl5eDgANu2eeWVV/p80pNee1gMXqfT4eTkpO/mImtLuUqfdDgweY4yC+fieRZmiYhn4ZHA0O5/Kw6+sW8FIfVLiudsWUlqxxgWJ3fZmubs58sKxGw0m67rbG1tMTc3N/W105rt7BR4FlF1owpLFEVB13WWl5cvvIY+0C6YtA0mjWZHJye89VY4NPptVuc1DINcLse1a9eA5N2Lo8NDjg/28B0br3VI0Dwk9pwLrx9ZbbzT6Dm1WEVfvoly8/nETnGwSXyyO9W5h6LqqPVl9PoK5AsoUUgMhO0jgs4xDDtvFBK1Dolah6CoqJV5tPoyxspNiCKixj7R7pvnxOdNQaGMevNdaHPL4PuEh5v4n3314sbEwCPau4O7d6eX3HG4/hRaZY7a/CKr12/0JpqmabK5uUkYhty9e/dSRSe5XI6lpaWh1duXaSJMJ8e1Wo1XXnmFlZUVOp0Od+7c6YnKac47zCedCtLU5pIV/5OQnittM11aWjozoc8W1UzC4E1LtkExu9x5lTF4ZxcG7/+3XpTJszA7RDwLjwQ5/f6LSxz3P4Fafkh9wue9Ue1+ruv2BPOoWLZpyU5q0zrsYRNV74LUhFHXHla1PYuouuxU3Pf93hJTdnJ9cHAw9ufQ1fvJzsQxYXi6+Kko6LrBrVu3pn6sBxMyhp335OQEy7LY29mhcXSA79p4jX2C1vHEldhZIruDZyftb0qhgr6whnb9neC7RIf3iI62Jr+obqDWV9DnVkA3UOKYOIoIWgeJj3mS88YRUeeYqHMMKCjlOnp9Gf3Fr0gW/NrHhDtvDBS3jEmplgjm2mKSFX2wib/5eQhHZEVfxGByR32Zk/Wn0OqLVGpzzK+uoygK169f70vuSItOJk3uSBm1cJhG612mibBWqzE3Nzf0vNP6rwdrt7OC9DI15HEco6rq0Oi+TqfD/v4+uVyu93hMM0wYZUtJY/DSiXSpVOprObyMkA69/oXeKI56vjERz8IsEfEsPBL0LQwO/J7jj+d7HtbuF4ZhXzrG4HLbZe0Y2Wzg7KR2aWmpL9s5y7hRdaOunc0dnoZhxSLpVPw8i8q48XqtRoMwCuF0KUnVVDQ0QCFfLE589lELioMJGa7rsrezTevkmMCx8E72CDsnieVhxsROF3+vC4CSLyUideOZJBf5aIvo4Jz6bSOPNreKVl9GUbXkJiMM8Bv7ifCdSaJHTGw28dMc6VINvbaE/tz7k982WwQ7rxM3jzj7L+6UyjzazedQK/PEnk20dwf/rd+a/eMZx8TNA7xTO4xTXaC59iTa/Aovf8Zi5cYTveSO9GYvm9yR9TPPuolwHME7uDCYLWbJnnfQfz1NMUtWkGZzmTc3k++3cdNGhi0MDst8brfbfZP0aZJMYHgySDqRzu6UpPF909o7wkzxj6IofQsXhniehRki4ll4JBj0NCfLHgl2MFpMnBcnl/qXswkWxWLxUraGWXqMB1/ArtK/nKZ6pD9Sn/Ha2tpYftJRgj+78JfG66HnURUFRVWBRDxz6j0Mx8yqy9pezltQtCyLw71dOu0moWXinuwSdZsPNCEjdi38g0042ETJFdHrS+jv/sqkHOZom/hwE4wC2txKIphJssxj38VvHRBdkcDvO6PVxj+1biiFClptCf2Z9yWJHXaHcPtN4uY+VOfRbjyHWq4TOybh/h3CN36z9/f3IIg7J/idJLnDLdVo376JvnSdfKnM8rWbLC0vs7q62kuVGFzgmya5Y1gTYSp4sxnH0ywcptPd1dXVM/7raQtf4Gwucyr+03rz83zSF6VtXOba4zwmg0uY6cQ7XRpN/y7Sife49o7QD/o+Txa9JOJZmB0inoVHgtx54nlg8pymY6QvRIVCAc/zeoLZcZxegsV5E+BxmbXHOD1LHMdnxGe6qDjrqu1ssci0PuNUPA/LjK5UKr14PdMPelF12a8XkoXBUQzG9g2zpqSf+3BnC6vbIYhiArNFsPfW1Wcbj0Hs2fiH9+DwHmp1gdy1Z1CuPZs0BdomsWvjd44euMDvO6PTJXC6cHAHJV9MhPRT74F8kdjIEx/cxf/tfze6vvtBntVqE9z+HMHtz+EubmDaDvfuvIlh5FhaXWdldfXMAl8aK5fP5/vi2aZZOMwK3jTjOJvNnMa+zX39n2Dv5hqKYSQ3GqpK+Q9+M9Xv/VYATv6r/wHn3/4K6uIcAMUoomjoqN/9zTgfel+vLbB61EH7B/+C8LdeQynmUQp5yt/+9VS+9yOnN6Pgv/wWjT//d4mOGhBFlP/zb6H6vR/pE/+j4gDTxb3UtjHu43HRtbM+6UmfV7LJIGlZTVrPnraHpj983+89/w4T0n1pG2fEc3GicwnCeYh4Fh4J8n3iOU7ebTvVQrZ/PxEjGyfX7XZ7iyjplHbQqzstWeF52YzkQdL4vZ2dnZkuKo6q2p5VVJ3neWxvb2NZVm/hb9jjoQ+cP/uzwcnzYHNgetOzuLjYeyGOoohms8nxzha2ZRI29gkO7hKbTSiU0ZZvULj1QvIuROckaf97SCiFCrnaAmq5DsTEgY8XhgRhSC5fRskVEp+w2X64+dEpuSKU54lzBSLfJeocY9TmUd/71SieQ7B3m+hoZ3pv82WpLqBdfydKZY7Yc/APNnGtFqga5s4Cu/Or6IUSC4vLrKyv91kaUiF9+/btXmPgtE2EwxYOU89xuVwGYPF//WFyz94CINg55PBb/jj69TWKX/8BAMof/Ubq/8339a7rv3Kbg//s/8Xal76b6+96F63ffgXz+34I62PfhP8nv5PqXJ1K18X+sz9C8Pom83/tTyZLt3/oL1L7E3+Q8rd9HcHWPvu/5/vIf9mL5N7zDqDfJz24uJd6mdM/M2ne86hrzyKrGs6W1aTtjPv7+2xvb2MYBrquc+3ataExeGHmXUo187lVRUW9hEVPEAYR8Sw8EuT6ntiURHDFScjZcatDu57r8y+nZRfApTOBk081XHjOaplwMBUC6C0BXWYyPsrqcV7V9rRn1jSN+fn5Cz3Xg7GDSkY+hwOP86jmwDAMOT464nhvG8+2CI62CQ63wOn2fzLHJLz3CuG9VyBfRlu+jnHrBWIFgnaD8GQPuFqRqpZqGLUF1GI1+Z5VNVzPxXIcAu9+ZJsJqJpGoVgn/9wGSgxRc59o/04ymX5AqPUltOVbkCsQOSZe+5gws+zoNQ9RNB29VMW49izazedRAo9gf5Po8N5Ma8mHUl1Eu/FOlHKd2HMIWoeny5iZG68wIGgeEDQPQFHpVubZv7eKXixTn1tgdeNanwgb1kQ4zWJgduEw9QU3m0004Pbt21RKenLdtUWK3/S7cf6fX++J50GM555Ef+o6/it3yL3wDNGP/zTlb/kqrv3g9/VE44FqEfxX30b1v/hhou/4WmrPPU39z/whit/8weQ811fRb20QvHmvJ57PfJ4hPum9vT1arRbdbvdSS5LjZFVP08wI9E2d04n39vY2nufx+uuv9yIHK5UKuVwOTdOSkpTTb5Psc6o2w6hTQQARz8IjQj6dFJ+mDaSWhhg4brbYNbxevFI68dR1ndu3b08tnC9qyptFtvNgW16tVmNtbY07d+4wNzc31YR8nMa8ac+cTbJIF3nSbfswDFlYWLjwOurgjYCiEJP8fZ6cnLC5uTnUy+37Pvs725wc7hPYJv7hPcKj7eERbcNwTcKtVwm3XoV8CW35OvqtdwEQdJuEx7vMREgrCmq5Tq62iJIvQqwQqyqO62A5dt9bx4NEYYjVbWN12yiqRqFQIv+OL0UF4s5RUnRyiUSQUahzq2iLGz3B7DQPiM7JgY7DAL/TwO80QNXQS1Vyq7fQrj2DEgSER1uzLWWpL6FffweU6sSenQjmw3uMXGbsO2ySMmKfpoyY5RpH22voxSqVWo3Vjes9gZjNUL5sEkbqC87n8xwBa2trmIrC9vY2URRRbTTJlYoji56cT36G4M175N/3PADuf/gMC3/rT/dF1a2uruLevMnxC0/R+bn/yG5eofTuW9QajeS8h02CN7fIvfddE5250+n0puaDS5Kp4J0m83kwqzqdGg8uSk6abZ9OvNOBxuLiYm/i3bO8VKt4jkPveya+/5+XeS4XhGGIeBYeGtl2P6KQuLdUFiUxc1ESdda2bCqVZEkoO/FMX5QuSoHIMrg4l/XrXnaZcFS28+BkPFtzPcm5s/aG1OqxsbFx6ai67A1EFEVDkyyOj4+Tv6cxSHyIib85Wej0icIQRVHIFQo8/fTTvcfCdV32d7ZoHR8R2F38/U2ik93L+21di3DrNdh6DfJFtKUbGLfeRawohJ0GwaRCWlFRK3PkagsoucQ7GaFguw6OY/e9XTwucRRiW11sq4uiquQLJQrPvA9VUYg7x4k49ce8cRiCurCOtrAOep7Q6eI0D4nScpVJiEKCbpOg2wRFQSvWyC+sY6w9CVFAfLJLsHcH7O5FV+qnvnwqmGuJF7x1SHQwpmAeSUxktnDMpLjEKlZobG+iV+YolcusXrvB3NxcXxNhmvqQLgZOK/BKpRL1jQ3W19fpfvY1Wr/463T/2+/l6JVXqHa7qD/7H7A+8UkURSE8aqDfXGfxx/9b9Cc2AIhaXdSV/pvTnk3i+hoVLce1d77zvm3k1Tep/Ln/Cf17/zO8lTm0CSwYqed5cEkyrdwe5pOehFFZ1c1mk52dnamLalKbybCJd6fTwbEdgiDZuYiiiJgYBVBUFd/3H0jLofD2QMSz8EAZ1e4XB0lxSfL7AcRxL7GhMpe8TTrIuE+Avu/3ZSRfdnEuy7jZztOcOxtVl63xvuwS5HkLf6NuIMb5XNmbh+j0BkhRVDTdQAuTlkHdyOE4Dke723RaTUKzhbd7h7h1cHWJE65NuP0a4fZrkCuiLV2jcOs5YkUl7DYJTnaGp0moGlp1nlx1EcXIEZPIbctxcRyLaIbV8XEU4VhdHKuLoqjkC0UKT30xqqoSdxunU96Lha+6eB1tYRW0HKHVxjnZJ5plZXccE1otLKsFKGjFCrnqIsbSjeTvr3lAsHeb+FS8nmFuBf3aO6BUTVJKWofnx/pdksju4tpdXMDKF2ntbGLUFsgXS6fthkt9yR1ZgTduGUl6E3z03f9Nb2FQqVdZ+OE/TunD/wmu63Ks6/jf9BU0v/vrKRaLlH7y5+C3XqfwlV/Su462OEe4dwQvPHPmc4R7R+S/7N33i1laNod/9u+hffiDuN/5tb04uVTsXvRu3KDXeVjBSdr2mPqk02tPs5cxWBc+ODXOnvu8aw/zaGcn3oaho2na6WAmJAyCXmRd+tx/1S2HwtsDEc/ClXNeu18vf9l3k7fDVRVd14k1radn3GC4SEmf9KIo6ntbbpT9IH0b9DJ12HDfC2ya5tSidlj026hzz6LGe5jIn7RkZdikfFRChq7rp+8MKGiq0nsx29/d5vVPbePvbxK3jx58QoZnE+68QbjzBuQKaEvXKVx/jlhNhHTYOkSrzGNU5kDXQVEJo2Q67zh2792RqySOIxzbxLGTG5tcvkjxiXcnC09Wi2D/TqZ6W0VZvo4+vwqqRmC1sY92iS8xsZ7gpIR2B/u0OEYtVMhVaujv+vLk77V7QrDzJrGeQ7/2LBQrxK6J3zoiOrjzAM43cFrXxjvYxDvYxDLydHbucHdumVyhyNLqOssrK73FwMEyklQ8npfcsfSP/nuMZ26e+fV8Pk+hUKA8V+fac88lovRbvwrlJ3+WN3/in1L++q9IBPpXvBf7//p/KH717+z7+HD3CP+3Xyf/1/8UcLqM+J1/mtqf+C7K3/ENwP0b13a7fd82cmq/GGZHuWhR0DCMCzOfp/VJDxbVpIUyW1tblz53KpYVRSFv5PB0nTiKUBSFN998szc4ucqWQ+HtgYhnYeaMavdL4+RM08R13b5CkdWj8LTGmeRd28zz10XiGUYXfwzaD6b9elL/smmavVa7y4raYVF1o2wT0zA4uc4+3tO8DZsyGIE3LCFDVRWCICaKAjw3ebeBOMZrHOJ1r27SOBGekwjpo2209acwVm6hz6+BqhK6NpZl4zo28UNMxYjjGNexcB0LFIVcvkDp1rtRjVwy4SQmaB9jH94j9mfvlZ6EyOninC50qvkSuXIN/cWvIEZBCQO8/dtEs6wJvwSx7+Ifb+O3DvCXb2G6AXe3kjSHpaVF1lZXx07umMR+pet677qdH/wY7b/3k/gffB93Tk7QvuUDlD/+14j+7v/O/H/5+9FyBsHOASc/8Fcpf/QbMZ66DkDjT/11Kt/9n/aEM/Qv162vrw+1o2RzqidJ2chmPmdF+qBnPL1pnoRs+UpqIUsn0oPWkVwud+G5o4HXitSyUSgWee655860HKYLh+lz7SxaDoW3ByKehZmQ2jEGBbPjOD3BHIZhLwmiXC73PdEWDD17sb54MzccLl5Sz/P+/j62baNpWs+/N01MUpb0RSIVidkWvssme6TnPjw8xHGcMznJl/EvX+Xk2nVdNjc3+yLwspP8MAw5OTriaH+XwA8IfY84johjnziIQVGJC2WMFz8Enk2w+1ZSzPEwKJTRlq6jza+CZhCrKp7rYjoOmq5RLBQpVnOouoHVaXPViR0Xo1KqVMkXSsSAbVn4vkepmOQ05wtlvAuWAB8UWrmGUVtGMfJ4no9tmeQNndzKE8n3tmfjN/cTIf0wsrk1HX3xOkplgSCGpuVhHrSJ4iQic++wyb2tHQr5HHNzdTbW1/uSO9JJaZooUSwW0UmeMyah8p3fiPkP/zm1T/wq1/7I78e6adH6h3+R7o/8H1j/4KdR8gZauUjlD3wz1f/i9wLgv76J+//8BuHdPcyf/ETvWuVv/3qq3//twHg51Wns56RRdVmRPqo9MZv5PAnZ8pRRhTJRFJ0r/rPLmdnf1U7tHNnil/Qm4ODgAN/3e2cvl8ti7xAuRIknuW0WhAyj2v0cx+m1+6XCsFwun5sE8Y8+c5u/9NO/AECuWELxLNzT58GPf93v4v/9gWSbfNAyAVCv15mbm7t0GUr69mS6TJiK8WzT1bRk84xt2yaOY2q1GnNzc5fyXY9KDMlOU6a9bjYtxPd9NE3rLT+mNz5BEHB8dEjjYA/fsfFPdglO9vno52K80ylQRVfpBomw+NB6ke9f6KCU62gL66ilOrFrEey+Ba2Dqc46LkqphrZ0HXVuGVSdSFUJgpCObeO5Z6e2qqpSLJZO/+7BtU2sbvvBte2pKuVKjVy+SAw4loXtOERDvOG5XJ5SqYRuGMS+g988JDq1UzwItHIdY24FRc/jey622cX3zkbaaZpOsVggX0j+PSmBm4j+qy6NUXX0pWtQWSCKFTqWh2n755b2ABTzBvVqkWIhR7VaZWN9rVdPnQqw4+Nj2u12T1hOk9yRJTuBbbfbeJ43dQX5IKnfeG9vrydEU7F72YGD53m9M5umSaFQmKqkZhjp9H93d7dn0xvm7/6bX/Qh3NMo0GqtRqedvNOxdusm3/Oz/3jk9dPil06ng2VZvbNXKpXe2cXeIWSRybMwEWk6RiqYoyjC8zwsy+p5mPP5fM96MK4wPFOSkvlv03E5PDwcapm4e/duLy5qGkYt5WUtCNOQzY02TbOXZ5zmRm9tbVGv1ykUJq+MHVZdneYkXzaqbpiFJPWAWpZFvV5PEjL2dk4TMkz8o23C5mFfkYai3P+6svIkik/bFc0WwelSmVKuo63cRH3ixZkLaaUyj758HaW2BIpKpGo4vofZtfC8820OyZSxi2l2EyFdKDC3uIaigOfYmN3WzIW0qqqUqnWMXOFURFl0T44vnGp6not3KlZzuTzF+iqF5Rvgu/jtY0KzOdNzAmjlOYz6Yk8wtztdAu/43I8Jw/s3kaqqUSgWKCxcw1i6gRL6+K0jws7xbJZHVR19aQOlskgYK7Qtj+6xRTRmRTyA7frYbvJ9nc812ds/olTMUS6V2NhYp16vs7CwgG3b3Lx5k06n06v0zlaFT1rpnZ3ApsJu0kXGYaR+40aj0YvKHMxlTi0Ykz6P5HK5Pp90uhR4+/btiZYZh5GWp5ycnPQGJYPWkWq12p96k/lr1i644cjn872myuxC4/Hxcd8QJT272DsEEc/CuWTj5LLtfqkdw7KsmdgDCplijSiOIYqIosQTfNxoEoZrQy0TwxbvLvp6HMfpCeZZWhtGZTsP5hln//y4jIqqu2zj4UVV2+l1Dw8PsbsdXvr0rxPaXbzDLaL2aJGTPU32aMN0S7+QnkNbvXUqpE2C3TehdTTBV6Sg1BYTwVyZB1UlUlQcz8e0k5uvaYiiCNOyMC0rI6RXURTl0kJa1XRKlRpGPnlb2rYs2p3jqb3WWSFt5HKUKosUFjcg8AjaxwTdxlTXhVQwL6HoOXzXod01CbzprhdFIZZpYplm4kstFCjWV9AX1iEKCNvHBO3jydoNVR1tcQO1Or1gHoXrBRycJNP8nNFk7/CESilJkcjnDHK5HCsrK6ysrIys9J5G8GaF3TSLjMOI47jPu521Mezu7hIEQd8UfdJp92BToGmadDqd3jLjtBP69NyD1pFU6LquR9JQq/T9e9SM8c8/bKExO/XOCulhLYcipN8eiHgWzjAYJ5cK5lQsW5bV5wEulUqXDqHXVU79sTGB76NHUZKtq6qUanXW1taGftw44nnUMuEszj4s27lSqVxYWDLOE2wasTfrqLpxhHianXq0t4PZaRN2W3hHW8Tdxlg+1exXnW0YvEgOxmaT4HRKmgjpJ1GfeA+xcyqk20OEtKKi1JcxVm5AqQqKRoSC5XpYjjV2PvW4ZIW0oqqUCvn7Qtq1sTutCyfFqq5TrtTRc3miMDwVzJ2JbqjGwfc8WqcTdt0wKJfnKSysQ+gTdE4ScXoBemUevbaIoufwXCeZMM94OTE+vWmwT61e+XyBYnWR/PwqhBFRNxHS8bB2wwHB3JmhYB6F54ccN02Omya6plIt5Wm1u+TzOdZW76d2pNFsqXf3MoIXhrcFpouM2ci2SSPfhuUyt9ttTk5OzkzRJ/UyZ5cCs8uMWZ90dinwPM6L2FtaXETV1F7Jlu97iQdaUeDUZjPpc+aws3c6HU5OTnrvAqRiOp/PD51KC1+YiHgWgPPj5FJLRiqyzsswHpfU1pBOPRuHR0Sn2c7aaVxdujjtj1gYhNHieTBCbZbLhMPi2S7Kdh7n3MMqwmc1FR9HiAdBQKPR4ORgF9s0CdvH+Ec7xNaIzN4Lvj4tDtEDjyiIyaPha7mJ1u76hHRlHm3tSdQn30PsdAn3bqPoOfTl65AvJ1FzKNiOi+WYI1vdZk0cRZiWjWnZKIpKsZCnuriKqij4roPVafaEtK7nKFWraEaeMAyxLBOv3Z65YB5F4Pu0fB9oo+sGpWKNwtwqhD5ht4nfOuz9Wb26gF5duFLBPIpkmphEA4JCLp+nXJpLlhDjiNgx8Zv7qJUF1OoSIQ9GMI8iCCMaHZtGx0ZTFfYPm9Sq98jnjCRJaGV5pODVNK0v9m2S56XBFIx0QpqNfEstGJNEvvWKWQqFvszndrvdl/k8jfgftcyYXQo8zyd93rkD2+mlawDkdANLdYmjGM/3eeWVVy5lSxmWhZ2+C3B4eNjzj2dj8MTe8YWLiOe3KaPsGKl/2bKsXqpC6tOddOIw7HOmE2DTNPtsDU/dKKCpnx76cd6IqDroF6GjBOIk3utRjLr2ZbzRaVTdVVSEDxPiaUJGVoiHYcjJyTHHe7u4jp2Um4Qh4eHdpOlvSr6x5vBLeyb7dkCoqqjEPFfz+crCdOIm7jYI7A5afQV97UnUp7+YSDMIoyh5699xJk47mDVxHGHZNpZtJy+0hQL15XU4jWCMAg+za+I2J78ZmTVB4NPu+NDpoOk6pWKF4pPriQ1HUfFs84EK5tHEeK6D5yZLYEYuT6VWx7i+AMS4Xkij6+D5D+Zm6SLCKKZtOliOx1ythO3scnd7n5yhszBf59r66hnBm0anxXE8tbgbnJDatt2bdG9tbfU8wenC4SRT2MHM52Fe5mnEPyQ+6XRCPywSMLvMqF4wPQ6cs9nmqqKAplCbn+PmzZu022329vbwff/MYzIpg+8CZP8ugd71S6USuq6LveMLDBHPbyNSO0Y2HaPVatFutykUCklZyYzEW8owT225XD5jayjbzcw5+0XQKPGcis/0LcDUvzwoEKfhKmPf0va9RqPB/n4S1ZbeoFx24W+Y53pubq5v+hQEAQd7e5wc7uM7Fn5jn6Bx0KuCVgpltPk1tJVbEHiER9tEE0bKfftqzLevltiyIzbtiC+b0zBUhYkj3/QcWn0ZfW4JRcsRKxD5Do5lEoUh+eocpVKJXD5Hp5vEtz1scrn86b8dA9cPaVs2uqpSLRlUanXyXoFupzM0NeNBUyyVKRULqKqGb3XxrA5GroBRqmDkcji2kySMPAKUKjWKxQIoCl7riNB3yJdrrM+ViFHwgpiG6eF6s7XpjIuuqtSrRXI5Ay+A/VZM0wqJ4hBF8akXHVa3j6kUNeq1Ctc31ohu79D5Jz9D5HnMfe0HUJ6f64m7bFnIJOIuu3CYtWA0Go2e1SB9DZiUUV7mcabds7h2GIYj36kJ7X5LT/aP6TljaF14+piknvS0inxSYTvoH09vXg4PD3tpKbquY9s2Tz/9tMTgfQEgUXVf4KRxclk7RhAEZ/zL9Xq9F8l2mQxj6C/RsG0bwzB68Wmj3uZ77ajDN/zITwGnofZKhH2qLT70Rc/xP3/rB4B+/3I6vS4UCr3s6MuWoVxF7BuctXoAlEolFhYWLrXwl03IyPq5s5vhkKSKHB3s0zw+InAs/OMdwvYRBOe/gCqFCtrCGmp5jth3CQ/vEQ3zHc+SXAF9bgWttoSiqsSKShQGOJaJZ5tDI830Qpl8bR7VyBP4Ph1z+uXAacjn85RKZTTdwPUC2paP7Z4Vx6oC5YJOtWSgawq+l9ygReGDE3z3BbOKb1u4VpdwyE2HqunkS2WMUgUF5XTRtvPgovqAUrVGsVgCYvxuC89sEQ95rNRcgXy5hl4sE6MShNAwXWz3ah9XVYV6tUQhl8MP4aAd0+jGQxdjs5S33mDu//xX5I8aKICmqiiqij5fZ+Hbv553fO939OwMjuP0RdVd1r6VLr/FcUw+n5/agpHlvHi9arV66UFGtjwFGOqTbrz+Fj/2zd+VfJCiUCuUaNvJc+27v+qDfPOP/X+GXj99TDqdDt1ud6bxfUCfUM+Wg2UjUCUG7/FDJs9fgAzaMbLtfpZl4ThOz3ZQKpVotVqsrq5O/fnSKW0qDrMWgXHtHgUjW68dEWcbBv1k4SZdcFNVtVe1fXJy0nvyn4bz0iYueyNxntVjf3+farVKsVi89JnTx2PQc23bNkf7u7SbDULbxDvaIZowBix2ugQ7bwCnOcnza+gbzxB5DuHhXeLOycTnH4aSL6PNLaPVFhMrjqISBj52u0XgWhcuKQaOSXBaEKIXStSrc6hGDT8I6JgWwRUI6UKxSKlQQtV0HC/guOPjDMk2zhLF0LEDOnaAciqka/UFdE3F9z263TbRjBccAYrlCqVCAVVV8G0Lq3E0VDD3nTUMsDst7E4LRdXIl8osLCwlk1/Xwep2rsQq05swxzG+2cbcPxwqmPvO6jnYngMNUI0cuVKNlWoFann8KKZlelhuMJNOFlWFeqVEIZ8jiBQO2xEnBxHnrGacob25y5v3bpNTVdZyJaqKwVFgcrJzzDt++VO88Ef/4JUkd6RWg4ODA65fv96LZbus/3pYvF6n0+nF611mspu99vHxMdevX8fzvN7jUSgUqNVqeM3sOyQK2ay689I2svaLdFF6ML4v9TJPM0DJ55NEFl3XOT4+ZnFxkU6nw927d3t2m/S1WFoOHx9EPH8BcFG7n2VZvbfwa7Ua6+vrvUlAmhAxzefMpkxc1u5RzOY8x+nniIjimGY7uWsflh3dbDYnPn9aWGKaJpZl9Sbjl419G9dnDJNH7A0mZBiGQaVS4fr1673HIxXVR/u7dNstQrONf7xDNGZCxoVfn9UmOK1XTkpONlCvvYPItQgONsGczMurFKvo8yuolfnkpU5RCXwXxzQTwTwlgWMROMnH68Uyc5V6IqT9UyF9wbT9PIrFIqViCVQN1ws47Pi43lmv5TjEMXTtgO6pkC7ldarV+URIey621e3PrZ2QUrlCPpdLJsyujXlyQDTl1x5HIU63jdNto6gquWKZuYVFFFXFdT2sMRJGzj1rpUqhWEQBfLOFeXCxYB5F5Hs4rSOc1hGKZpArV1kqV4mrecIYWqaH6fgT/ZNQgVq1SCGfJ4wVjjoRJ4cRwbRf8ulj5UURd50uBT2PE7gowHHH5ld+9TMUCznW15ZZWe5P7hiMqksF7yRL3NnIt8HmxMv6r+G+YBx2ZsMwekJ60sludlqevXan02Hr9h2CMEwsEZrSly+v58abfGc93Fn7ReodH6w5n4S03CVrTbEsq1dak8YDplnYaQye2DseTUQ8P6bEcUyn00lSKU7FchiGvaKS8/zFWdIljHHIWg8GJ8CXndIWdIWYuOdjDuNkSqcqCkY+z61bt4Z+3LgiNCtqHcfpvXW2vLx8qUXIYT7jcW4ixjn34OR62JmjKEo837vb2JZJ0GngH+9OlZAxCYPZzMbKLZR8icjpEuxvwoh2O6U8hzG3glpO3imIFRXfSzzMoWvP/JyBbRKcvnWbCOm5jJA2x4qxK5XKyTsEiortBOy3fDx/OsE8ijgG0wkwnURIF3Matco8uq4SnArpcc5aLJUpFPKoiopndbGb7akF88izRhGu2cE1OyiKSq5UYm5+AUXT8TwXs9sZa3o+KJitg6OpBfPIs4Y+bvsEt32ComoYpSoLlTqLlTIh0LF8OrY/MqWjXilQLBaIIoXjbsSd44iZ7CZmv05FASX5/DHgBAq/dcfD0DwWdi1W5rYp5g1WlxdYW1vpZRBnkzvu3Llzqai67MJhVjRml+umzXwezE0enOym1x1HpA+eO3tt7uyiqSpRFBNG0WlUXYSiKqgT5DynDPOOdzqdMxPvarU61tBl2GOe2jeGedPTMrDBGLxUTIuQfriIeH5M8X2f119/nSiK+LVf+zVefPFFyuUyuVxuoinqRSJumPVg0vbAUWSn151OlyidGigKubyB7yWvUuE55xt1/kkLSyZh2mznwXMPO/M4UXVhGHJ8fMzx3g6uYxG0jghO9ohPbQsPmths4ptNUBTUyjzG+lMouSKR3SU4uIOi58gtXQcj15swu46Na3cJL7A5zJL7QlpBL5ZOhXRuqJDOCmbL8dlruPhTjxknI47BckMsNxxLSJdKFQqF5N+iZ3WxG0czF8yjzxrhml1cswuKQq5Yol6ro+oGvu9hdjqEmbOUyhUKpVJGMB8TT1KCcpmzRiFet4nXbYKqkitWqVdqzJWKRKh03ZCO6VIqGJSKRWIUTroRm9szEsxZBq1TWZ+amtxw+yHstyL2Wx6a6jG/a7N6d59iQWNpYY6NIckd6YJdOjlOfww+J10UVTes4XBWmc+jilmyTYHDRHr6PD/q3JHrnfqHFdB1dE0HxSOOIprdLnfu3Jl6agzDp+lpo+SwZJBBJo0HTK9/eHiIrus9IZ2+zl/mNUy4PPLoP2ZEUcTnPvc5fu7nfo5PfOITbG1t8a53vYv3vOc9PPHEExM/mQ2Kz1ENfLNIsID70+v0R+oxXl9fw8gZRGH6BKkCyQvMuDnPqahNz54uzy0tLU1VCTvs3IO50dNmXqfnHndyHQQBBwcHHJ6mikRhCFaLcPt1CB6cAD2XOCbqnBB1m6i1RfT1p8lVvjhZ8FN13PYxrmUSBQ87ESO+L6QVBb1QYr46j2IUkiwQRaVrug9UMI88aVZIA8V8IqQNQwNiVGLcbhurMfsJ8zSH9SwTz0oeV6NQpDY3h6olLzMKMV63iXW4RfywzxpFeGaygIiioBcrVOuLVItlUDSaFmydhLhXdMw4M+mOM/8L93OKs4QRHHUijjoeq3UF1z1ke/cYXdeYn6ty49rq0Ki6/f39XlRddnI8blTdeZnPe3t7F+YyX3TtYcUsx8fHbG9v91kkcrncheI5cO8/Dyqnf047fSyXVlaoVCp9vvFsxfmkz9+jWgizySDpj/Q5PIqisV+DhvmwO50OOzs7aJrGc889N9F5hdkj4vkx4eTkhL/9t/82v/ALv4Bt23zwgx/km7/5m/nQhz400tIwDtk2uUHROav2wHR6nXqMc7ncGb8ugKZq91MH1PtPZsEFhReO47CzszMTUTt47qxNZRbZznB/oTNtqho1ufY8j/39fU5OTnA9n07XwrKTPOMkRzhH5an3oilA+4jw8A5cwbLZWKgaWnUxiZQzCkBE7JqErWMi30VbuoZRqqLoBk775EqW4iZGVclXF9BLNSJUTMvDCyJq5QKVUg5DV2l0kl97FKhVcpTyGqDS6AS4IcyVVHKlOqqRxzWbRN7DvjFJyJVr5MsVUHVM28ELAsrFAkZlHjVXxGsfX4lNZxqM8hxGdZ5Q1bGsxJJTLuV51zWNOFZoWckE2J7lQ5uZPPevtpFsJA6wUIbluo6mwnEHfvM2mG6EQsR8+YTr95osVFSqlTI3r6/0JqDZyXFWlELy/DbpsGVY5nM2lzkV6NMsHGZFuud5vWunIr1SqZx7jdDJDBGU/sc0XyoO9Y2nU91pzw3jNShWq1WCIJjqNWNwWu+6j8iw5G2OiOfHBNM0qdVq/LW/9td43/veh67rfPrTn546ZSIIgt7dMsDBwcFM2wOnSd/QVJV00JP9/MHAItKglSRdwrisleS8hb/V1dVLZztnJ9fp4svg4+04DvuHh7SaTTzXp901sR13aBuhZbtYtouqKJSKFcpPfQkqMXFrn+jw7tVHimkGWn0RvbaMohtATBz4+MfbhK3Dvhi8qHUAqoZaW6aytAF6Ht+1sZvHED1AIa2q5KuL6KUqEQqm7dM5sQkzk0DT6aIApYLOUj2Prmu4bsBJ13vgk+i5co5iIRHMbStg6zjCz9xMduxkIl0uGMyXVynMK8Seg2e2HqglBiBXrpOvVEDRsB2Ho6bZd+NrO4n6zOcNqvVVCoZB7Dt4nZOeL/1BYZTnMGqLoGrYrk+j6eBn8uSt07MWcjqVcoF3ruvEKJiOwm4zxLzsQ5t5XGKlXz4rp6U69SKszmnoukKzC5/fhs7A/UYMnJhwYkZARK3Y4tpWm+W6RrlU4Oa1Zebn588kd5imye3bt3u+3WkmsMNymdvtNvfu3QO41MJhLpc7I9JbrWTH4s033xyaChL03TgqfUvSWiaVZJgHO2t3Saf006RrDGtQTIV6OtxJLRjTvmN5mcGNMDtEPD8m3Lhxgz/1p/5U36+lU+NxSYWhaZp9/mXLsrh169aVZCRPkr6h6xr0XpTuP9n6QdhXWJIVtYZhoKoqi4uLU597nGKRaUhvUIYlZDQaDXK5XK+cZn//gE63g+t6tDsmjjv+mCuKY7qWS9dykyWU4jylZ9dRopCouUt8eG/qr+EMeg69voxWX0RRNYhj4sDDP9glbF8ghKOQqLlH1NxLhHR9mdrCOmgGvudgt46vRvCrOoX6AlqxmkTFWR7dE/vcKueY/gW+Ul5nuV5A11QcP+Ck4xFcgZBWgVolT6mgE8fQMgOOjqNz332Jga4T03XCU9GfY76yQsnQiH0Hv9skmDIR5CLylTq5UiURoUME8zBc18c99UPkcwaVyhLlhXVi38PrJE2SV4FeqpGrLoBm4LgejabdJ5iH4XgBjtcFIGfoVMsFnl1LhLTtK+w2Ijr2FEk2A9/nqc5TFKhXNZ66odO24bVdaE4QPNO2ob0d8/J2QCnfZWPLZG3+LqVCjuvryywvL7KwsMDe3h7PPvtsz3Oc1kunQnpSYZedvm5sbPSlSFx24TAV6eVymVdffZX19fWhxSz+OZNnPT988DFOusZlsqqzNwFbW1u92Nh0wTN7E3DZfgXhwSLi+THmomW/UcIwfXtJ13WiKOLkZLqs3jAM+xbnUv/ytE15WaGqKPfTNyzb4e7du0PF+NHREeEFL9aDDPNGT7rwN4pxEzKCIKDZanFvawvHcel0LVzv8gbLKIpomw5t00HTVCqlZYrvvI4a+kQn29NVbucKiWA+zWAmhti38RoHp7nRU4jIKCRq7BE19kDT0eZWqC2ugabj2TZO5+RSQlrVDXK1RbRCmTCCru3RPbKIpoplPCukl2p5dE3B8QKaZnApIa0C9UqeYiG1CYQcHQUE4RRnBUwnwnQAQsp5nfnyEqV5jchzCMzWpYV0vlJDL1ZQNB3H9ThqXSyYR+F6fu/7PmcYVMoLlBZWIfDxuw1883LthnqxQq66CEYO1/U57Hh4/nR2Ec8POG4mQtrQNSqlPE+t5JICmUBhtxHTtmLG+lvLfG8rCmgq6HHy99dxdf7Dq4x3nXOwXHhjL+aNvZC8YbO2dY9rC9uUCjqFnEoURX0T2HRBLZvckVoZJnlOzHqZR9lGBgtOxiEdFI0Suzt37xGGIYqiotKfzqmN8XlGNTNms6ov45NOrSmrq6vEcdx753dnZ+fCZcmUdE9GePiIeH6MUVX1zOQ5ffss/ZEKw1FLc+kTwLj/IIe1B1YqlUtnJENSbxvHUWKfCPzT9A0VRVV4+umnhz6BjxtVN+uFv5TU6tHpdDBNsy8hI71BAXo3KQcHh9iOg2XbdE0b3786y0IYRrS6Nq2uja5rVGsb5FeeQPFd4qOtxEoxAqVQRq8vo1bnEysIEJ1Wec8qN/r+QQPC4x3C4x3QDfS5VWqL66CquLaF224wTq23qufI1xdR8yXCKKZt+ZhH5kyPejZSTmeplksm0l5AsxsQjNGWoQL1ap5i/lQwmwGHR+FUgvk8TDc6tRhElDJCOvYcfKtNMKbvOF+poRUqqJqG5Ti0OxbBBVPbSfF8n5PTMhvD0KkU5yjVVyAM8M0mfrc51nW0QplcbRHFyON5AUemN3UW9yj8IKTRtqBtoWsq5VKeJ5byKIqKF8J+I6ZhjW4aVOMITT31O6sKYRT3Ej3sUL20cB7E9WHzMGbzMMTQQlZqcNh8mXJRY3lxjmvrK73kjlTYtdtttre3L1W7fZ6XORv3No4gjeO47zVgUOwe1eqnrwcRgR/gK+HpfoiKXpisTAaSdI3l5WWWl5fP+KSnaSHMLgymg6bBmLpsoklWqAuPHiKeH2NS4bi3t4fjOBiGgWVZ6LpOpVJhY2PjQkGb/t4o+8d5PuBx2wPPI2ttCIOAKIpRVAVdN9A0D1CSvOcRk4/zxPPgwl+6qDgLb3SapX1eQkYYhhwcHHB0dITjepiWjWnaU0/pLkMQhDQ6FnQsDEOnunCT/PrTKJ5NeLhJ3GmgFKsYixsohTJKHIGiEFltnMYBsdni8rOwcQ7qEx5tER5tgZ7DmF8lv7IOioprm7jt/ndJ1FyeQm0RJVckCGOalofVma1gHkWShBFguZmJdD0jpDtBn19fVaFeTgRzlArmdjB90caEWG6M5cbcF9KLlOY0Yt/FN1tnhHRad61oOrbj0u7OXjCPwvcDGn4AmBi6TqVYo1RbgihMhHSn0ffn1XyRQm0JcgV8L+DE9HC8y02txyUII1odm1bHRlMTIX19MceNJYUgUtlvx5x0IhRgfV6lWlTZzMccxskAOgJyfVF1V/v2vR/CdgO2GyGaErJYPeDG0hG10v3kjlTYZZM7UivDZSwYWRtDWlY1uLg3SpBemBAShvfFqWGghDFxHBBFAYcnJ+zt7U1lSYGLs6rH8XePOv+omLphpTLTNNIKV4OI58eQOI557bXX+Gf/7J/xa7/2a9y+fZvv+q7v4ru+67umKv0YFleX+pfN0/zbcrk8Ex8wjC4sKRULNLuJwS+Ja0qeaMIxo+qAvkVFx3FmJvQHs52BoQU0SULGIftHDcLAJ458jk9aD0Uwj8L3A05OJ961SonarXdD6KGGPqgaYfOQoLFPfEXe07EJPMLDe4SH98AoJEJ69TooKmGsgJ4jCCJOLBe7ZT4IaT+SYdaO5fk82ulUUVGUnmA+aAcTVTlfBf1CWmOulAhpogCFGEXVsB2XTvdiX/BV4wcBjU4AHRNd16iUapSqixCHEMcoqoEXhBxbLk7zwQjmUYRRRLtr0+7aqKpCuZhjY67IxpyKriqYrsJvbYLbiPpdSUo2qu5yz68TnTeGgzYctJPkjmfWTjg+OUZVDarVMjdPI/AGrQyzyHzWdb1v4fAiQXqReA6ztjdFQVFB01RAZWF5Cd/32dzcRFGUS3mNh2VVD/q7U/tF1ic9blRdNqYuLcJJ67wBlpaW2NjYmOjMwuwR8fwY8Ru/8Rt84hOf4Bd+4Rc4Pj7m3e9+N9/wDd/AN33TN7G8vDz1dVVV7W00Z/3LF7UTjstgdrTv+xSLRWq1Wl9hSS7bApV5jgwGCwUGrh0EAYeHhzMvQxnX6uG6Lnv7hxw32lhOyF4j4KQbowBLNZWV+gKaEuE6Nh1z+trpWVHIG9QKOQxDQ4ljIs/BdkM0XcNQdciVHjlfnZIvQnmeSMvjBSFBEFHUkyGdrmnEPALRd6coCuSMpAEsiBS6dky5oKCpkDdUFPvRuZECyOkqhp78k7P8pNWzkFPRdR0tCB+6eB5E0zRQFIJQwfMjigXQNZW8oeG4j873QRTFKIpKECr4ocpeAxaqCu+5FXOvFmGp9G6i+v69XXI4MSlzJXhiGcp5aNnw25vQcXxqxSbrW22WairlUpGb15J2w9TKMCzzedrkjvPKU4IgGMsfHfqZJWul/zGtLSxw48aNkV7jdLI7TbrGsKzqbEtgeu00YnQSNE07Y6cRHg1EPD8m+L7PD//wD/PCCy/w5//8n+fLv/zLeeutt9A0bWrhnL5tFkURW1tbE7cTnkcURX3pG9ns6FF3+3rfr93/3FF41tedXrvT6RBFEYZhzKQMJX1MBj3dg1YPy7LY3Tuk2e7StUN2GwEtkzMex71mzF4zJqfDar3EwmIZhQjHMjHtq0lAGERRFIp5g2rRwFATP2UUny7R2f4Zj24hb1C7+R50XUMxGwS7b4H34EW/Wl1CWb4B+TKeH9CxPZzO/clio5N4uWulHDeWK0RRRMsK6M40kHfMs55aMgo5nSiCphmy37o/YT7qhKgKVIsK1xZ1NFXBdCOO2+EDs21kqZc15opg6CqW43HSifD87EE8CjmNajFPrVIhDHwsx8WeIAVmVuiaSq1SIpfLEQYhbcvrxd4BNDt2shxbyLGxVAUFLNunbTojPcdXSbWUp1AsEUYK2ycKm2/B/ePGqArMt5L2SEODWFfQosQfHcdcuW0DoJyDp1ahWkwWC7cbMY0BXda2oW1HvLoTUcp3WN82WalvUirmub6+xPLyUp8FI9uId5nkjlGCtNlsEgQBt2/fHrpwGGYabRT6xbN26nke9BoPy2SeZpkxZdAn3W636XQ6HBwk+yWappHL5cb2SQ97XB61wcbbFRHPjwmGYfDTP/3Tfb82bGHwPLL+ZdM0e5YJRVFYWUkWRi5DdlJrWVYSmzbBUp6eueuPM+I5iKIzzYTptWu1Go7jsL6+PvW5R9lIslaPdBt9Z++IrmnRsiL2GgHtMTWlF8C945h7xzHFHKzOVVhaqhJHAZZpzlyUKIpCqZCjWjDQNYU4TgRzy/YxbZ/wnO8bx/VxXD9ZiMvnqT75XjQV6BwT7r0FV9gQqM6toCzeIM4V8bxEMLvt0W/FB0HISdsGbAxdo1rKMV+pEEYRLSv5Wq/srCrMVQrkczphmMTKZQXzIFEMLSumZQUPRUjXShrzpVQw+5x0wwHB3I/jhTheCPinQjppkwvDAMtysK+wrEFVVeqVEvlcjjCK6Foux63WSC97GEa0TIeW6aCd2iVWF6uoioLl+LRM+0pjz8vFPKVigQiN/UbM7U11ZBZ0FIPlRPR2hRXQAP1UM6/Oa7QL0JnxvXVOh6dWYhYqCm4A2ycxr+6eveEfhuXCm/sRb+5H5I2A1W2L9fltSgWD9dVFVleWhnqCL2uTyPqBi8Uiu7u71Gq1oQuHwUBBUFZkDlsYPC+TedJlxmHout7XEvj6668TRdFEPmnh0UXE82PMODnPw/zLg7aGO3fuTO1jnuVSnqHdfwJJ8h2SWB7fC3njjTfJ5882E7bbbRxnsleZtMQlFcxpBfmgjSRNyNjdP8ayXU46IQetkO4lX9RsD+4cxNwhplJQWZ+vsVRViMIk5s6bMoFDVVXKBYNKwUBLiwOimIbpYTn+ubnGw4jjpCzCcrxTMV6h+syX3i9i2d+cScGJOr+OsniN2CgkTYqWj9ea3LvqZ4R0ksmbZ76Sx/cD2naAPYO39HVVpVbOJYI5immaIbtNf2JhlhXSmgrVosr1JQNVSaLmjjuzEdK1knoqmDUsN6DRDXDPEcyjuC+kPfI5jWohx0qlnEykXQ/bubyQVlWVarlIoZAnjqBjOZy02xNP2sIopm26tE038R0XcqwuJELadn1aXffcm8dxKRYMysUiqDqHLfjslkLbhj7P2Sgynz+MwQuTybOiQKRovHBDQVFiLBc2DyfLes6iqvDkcsxKTSGMYbcBtw/jS3nuXR/uHsXcPQowtIDlrW02FnYpF3SWl+a5tr7SZ8FIkztSm8S0yR1p2sbgtDtdODw5OiKMItR0CT4rnosXJ1YMLjOmk/Sjo6NLtSdC8r2tqipLS0tUKpWeLWXQJ12r1cayGkpJysNHxPNjjKqqBENqjrNxdd1u90L/8rhxb3C1LXyGpiWiOY7xgzDJb1YUVEVh/fp1auXSmY8Z9+yjSlwWFhbOJGQcHh6ye3CC7fgctUIO2+Fsq3kzdB14fTe5UaiXNNbn56jXIQg8Op3uhbFn6dvV5XwivGIUgjCi6XjYjj+zt/jiOMa0XUw7FSTzlN+xjkpIfLJLdDRZo6G6eA1lYYNYz+O4Ph3Tw/dnt+yVZPIm/zbyOZ1ywWCxVsbzQzoTCmldVamXDfI5gyArmGf07mkYQdOMaJpJfFm1oHB90UBVoXsqpCcRO7WiynxZ6U2YG90I15/dlNj1QtzTiXTeOBXSi+VkIu262Pb4n0tVoFIuUcjliE6/x1qd9lR53MOIopiO5dKx0iZOg5X55DnQ8RIhPU60YEo+p1Mtl1BUnZMOvHJbodGd4mDxQElK+v9j2G6ovPnbMfUS3FxWeOcGqGqM6yvcOYxpdC/OvbmxGLMxr6AosN9S+Mzm/Si8WeKHsNOI2WmEaGrIYnmPa0uHVIsaC/NVrm+s9WwS6e7LsBKScUTj4MLgYALGa7oBcbK0Gfk+ahgki4OKgl4oTPR1jWohvEx7YrowOMyW0ul0ej5pial7PBDx/BiTbiDDfa+uaZp9cXXj+Jez1xnGqPSNSdoDz7t2ukzoe+5ptrOCoqin1z2dImjDv1XPE8+jEjIGS1w8z2P/4IiDowa243PQCjlqR3gPePeoZSXTSEWBhYrB2twCeR1836XdMXvvMui6RrVUoGhoqEpMHCv4YUjb9nEc/8pTJ7KCRFOTIpbSO6+jRAHR8Rbx0daQj1JRlq+hzm8Qawa249Ht+PjB1VdIu16A6wWAnTTaFXUWq2XcIKRt+adCsB9dU6mVDQo5Az+IaZkhOzMUzKMII2haMU3LR1OhVlS4sWigqMlE+qgTDr1HqRaTCXPO0LB7gvnqF/1cP0w+TycR0pWMkLbdpD5+GNVykWI+n7QjWi5tszvxOyOTkjRxenSt9J0Ug6W5Epqq4vohra49tH49p2tUK0VUzaBtKXxmE47al5z8Df4lZp/DTtM2WhZ8djP59UoBbizDM2sKmhrjB3DvCA47920Xa3NwfRFyGhx2FD6/FXOFrqUzhBEcdOCgE6IoIfOlY67dazJXVqlVK9y4tkK1WmV1dbWvPCUrGs9L7jhv4U5VVVSU03QNQNcJvdPhQRyzf3IEC9MtBWaXGTc2NnrRfZNOjYelhWRtKekS5rCYutQ7Ljw6iHh+TInjmLt37/Lv//2/5zd+4zcwDIMf+qEfOtNmNw7DBGhWeI4zvZ707Nlrp8uE5UKhJ5iVgevbfsTckOHB4NkHEzLSm4hhCRk7u/u02x1sN2D7OOKkGz+U5a1B4hiOO3DcidFUWKrmub5YAGJUYlRNRYlCPNelbXsPNWEgjCJaXYdW10HXNCrVDYrLT6IELvHxFugGyvw6sZbDshy6bZcgmK7hbRbcb7Szyed06sUcRq2A54d0nYBSXidv6Pjh6YS5cfWCeRRhBA0zpmHeF9I3T60dXTvCDWLqpWTC7Lg+TSvC9a7+ZmQUqZA+7vjkDXVASHuoqkIxnwMUTMvlsNElfEgPbvJOiodpe6fefoPFehlNU5PvBculWMih6TlMR+GlrWSCO7NdrcF67ux/a2efW7sOvHwv5uV7UMrDtUV4clXhyVVQlGQh+aQLb+zGdB/et0CPOIYTE07MEAipFRtc226yXIVCqcTNa2tDkzs6nQ77+/vk8/meTSId/gyWpAwS+vfvFDRV7aWWxHFMsVbl6OjoTLzepO+UZotZ0huAwalxeu7BqfFF54fRMXWbm5tAMvFeWFigMOEkXZg9Ip4fI8Iw5NOf/jQ///M/zy/8wi+ws7PDu9/9bj784Q/zNV/zNVOnbqRPTNnCkkmn1xeRWkkGq7zX1tZ6m8elwltk/YLJuZL/tkf4gFPfd7PZ7J07n8/3kj1yuVxfQsbe/iGtdhfTCTloJi+cSzWNjQWFUh62jh8NAQ3JJvxqXaVWUkhc4ApBDFoYY5ruIxF7lyUIQ9odmwgoFwvEq88kRStRRKtt9SUkPAq4XkAYRdTKRYxcnpqeR1PBcQOO2gGPUOpZT0gHUch8WaNSMijGoCkxluPR7PhjdDA+OFw/wvUjgghq5Rxl3UBBIY5CuraL+RASUUaRePt9HC+kXi2SyxWoVHJoKrStmFd3FI5nHXkeZ98VUE6nkqc/U89/WbZceH0Hjtoxz99IxLTtQaWg8M5rsNeA/XbMo5IwuFyF64sKOR12mzHN7S6be7dZqibJHdc2llk69RovLi72YlMHy1MuIiues69ViqKwcfMGeqGA53m0221arRa7u7uXqtw+b2q8v79PLpfrKzeZNKpuMKbOsixardbYHy9cLSKeHyM+/vGP85nPfIav+qqv4gd/8Ae5ceMGtm3z9NNPT31Nz/Pwff+0OvqAQqFAuVxmaWmpT3hOw6CVJI19yy78Zcnp999OU1CSuKHTn7sDvsTUd91ut3tPtsMSMrrdLrv7h3S7Fh075KDl07H7x0cNM1namq+oPH9DQwEO2xE7/SVmV44C1EqwNqdSKaSCGTpWyEk3xPaScxsaLFbzrCwl02jTsjCthzduUlWolksUCzliwLQ9do7uTxXzhka9kme+ViIIAlpd59RG8XDQdZVKqUDOMHCD5K3mlh32FrbqRYWlmkHOULC9kJNO+MAtPFnKBZX5koJh6LStiLeONDqnw3tDU1iq6CzPG2hqjOMGtLreQxXStbJBJa+haiody2fnyME/rR3PGSrVgsbqUp0oDLFdn+7D/N4FatUi+XyBIFLZa0UcdyLCKPn3WC/B8zciijkF0455fU/lYBb6ZWDi3vdUeI6toFKAd16D+Uoiou8cJBPnGDC0mOU6bMwrbCxAHCsctmN2m/ED//6tFuHJZYVSLom82zyM+tJH2nbInYOQvO6zvGOxMrdFsWCwsbrIysry0PKUVDhub28PTe4IMwOW/tcWBe10CpzL5VhaWmJpaWlo5fa08XowfGrcbre5c+dOzxqZvg5O+s5t+s5vei5ZGHz4iHh+jPjrf/2vUywWe56te/fuYVmTTR+HJU1omkahUODGjRuXWviD0bFv41hJcn1Rdf0vLrYf4DhO79q+71MqlahUKjQaDW7cuAEkgrnRaJwmZNi0zJDDdnDapjaaMIKjdsRRO8LQYKmq8cVPqAQR7DUijq6obE9VYK6cTJhLp+/yRTE0zYCTboTrnz23H8JeM2SvCXlDYblaYnW5QhQFdLv2A8niTaLECuTzOeIYOpZH89gc+ja864ccNJLv00JOo14qsDin4/s+rY6D9wBGZIauUikXMQwD14s57CYv6oPHjeMk2aBpgaoktoiVuoGhg+1GHD2gXOasYO7YEZsn2mmSQ7+w8kPYbWnstpKbqqUKrMwbqEp8uhD3YCbStZJBuaChaSpdy2e/5eMHZ78XPD/i2IfjTkhOV6kWdVaXkqmc7bp0R+W7zZhqpUgpnyc8FZgHB5xZHIxJvxeShd5aEd6xEfHeJxUsN+aNPZXdaW+wM8VPZ2qoB4RVXofnrifC2AsU7h7By9tnv3f9EHZOYOcktXvFbCwofNEthRg46cTsNGKcK/JBF3R4YgXqJQXHh91GROuClyc3gK2TiK2TCEPzWdyxWZvbpVjQWVmaZ31tpc8HncaUDis4CTPL82rmMdV0bajYHFW5PYsWwuzUOL323bt32d/fZ3d3t9dAOI0HW3g0EPH8GFGpVPp+ftGiX0rWY2yayeJZamsolUq9KJ5phPOgGB/VHjgO/ZPn06D707i6t+5tUbNKZ4pWXNel0WhweHTE/v4xtutx0gk47gRTv0j4Iew2Q3abIcWcwlJN48aSguMlT/SdS1p2kym3wmpdoXD6kIdRzHEnomlONuV0/Zitk8RXWMorLFfLrNaqhKFPu2NNHXs3/Nwq9Woxyd6N4yR7t2tOtOiVRJ4lD2Axr1OvlzF0Ddf1aHVtghkqU0PXqJTzGHoO149PJ8zx2L7VKIaGqdAw05sclY1FHU0Dywk5bgeXEtJf8yd+CGtxjljTII5RVYX2V38p3Q9/BR0Hqn/nn7H0uVdwK2WeApQoJtI1Xv3dv5vN9/2O3nWq+we8+G//LYt37xEaBqGhc+9L30frG7+c5YU8qhKh/8arLP7Uz6G5PqgKd7/uAxx+yfPTHx6oFHWqRQNdVzHtgMN2cG5u9CBekEx5jztBIqRPJ9JxGGJ7AR1ztkHHlVKBUqlIHCscdyLeOlJO/62NN8VLSkMSIV0twpMrEe++peB4MW/uqWyfjH+WOD7ncdJ0VBXeuR6zsZjc2G+fwH98XRnbihFGsN+C/VZSyrJYhY0FhXffTL7WphWzcxKPzKIeF12Fm0sxS9Vk0LDfjNg8jKfaE0iGAjF7zQBNCZjf3mX93iHlgsbCfJ1yMYdhGKyvr/cVnBweHrK9vY3VTZZOFbV/MjuOOB1sOJxlC6GqqpTLZQCeeeaZnr87PfekHmyZOj8aiHh+jDlPPIdh2CeY03/Aq6urZ9qNJomqg4vF+LR30jld5VQuE4QBYRicvpWuUqrN8dRT13sTAN/3OTg4ZP/oBMfxeX2rw3EnnHkck+3F3DtKBGiloHB9UaNgKHTsmK3j8ac4ugaLFYWVukLOAOIkg/mwHdI0o5n4Ey03ZtNNhHSloLBSqzJvKMmTdcecKJKrd25dpV4pJu1uYUTb8jhsd2ayOGW7SWScokAxpzNXLaFrKq7r0zLdiQqAUnKGTqWYRzcMHD9mvw1tZ3zBPIooTt4eP+kmcXJzJdhYNNBOc5mPusNTMC7i1T/2Byg8vUzO0HC3mzz1V/5n3lAX2XnheeZCuP1lX8pnv/7ren++trfPh37s79NcX6O1sUH14JCv+vs/zue+9vfwKx/9TlBVis0mv/Mf/xSl/UN+4yO/l7Ln8bU/+k/Z/m8+hv/0Brxyl3f81Z+g9cwNvLnqROctF3SqBQ3D0DBtn6O2P1Vu9CBeEHHcheNuiKGrVAtqYu2IImzHp2tNJ6TLxTyFfC6JluuGbG6D48eMK5hH0bE5tX/FVApwcznihZsKnh9z+0Bl8/CCC2S+IZXMWTQVXrylUH8xZq8Bv/6mcmnvfRTDYRsO20n11HwlEdLPX1NAiek4sH0cT1TKcm0+Zn1eRVHgsAUvbc3mOSwljOGoA0edAEUJqJcOWJ/XqBZVWh2bG9dWe/Go6eLef4hj4jgiCmICPzj1GKuoU1RuD2shTMVutoVw3IFT+vqqquqZYpZZebCFB4uI58eYVEim+ZGjCktGeYxTxilbGbXwN0yMT0qakOFaVpLtfOp41jXt1PSsoOjGqWA+4rjRwnYDDttJJNdlAv8noevEdJ1E7NVLCs+sa+iqQsOM2R6yaJjTYamqsFxTSIfqfhiz3whpWVd77uSs4amHV2WpPoehJSkj7a55rtAzdJ1aNfEEB2FE23SxWrMRzMOIY7DcAOtUSJfyOotzZVRFwXE9Ol3nXOtBztCplPLoeiKY9zrJhPCqchzCCI67CsfdZPI2X1a4sZhDUeKk4KQdnnveUj7JYQYo5lTunui0bAVYQH/hRVZff52dF4ZPhdtrq3SWFqnvH9Da2OD5n/95tt7zbt76ne/v/Rl7bo5f+c5v5xv+xt/ita/4AG65wqd+/+9jx7hJbgeWN27xRDHPNd+mUV6gaZ5/B1jM69SKKjlDx3Z9TswQx7u6DDQ/iE5vVEIMXUmE9GKdOI6wxhDSxbxBqZhH1QyaZsjWoUZiq76at8e7TvLvDWJKeVibi3jnNQU/iNk8VHlrf8gHZf4B6pqCGidyPorh9omO9erViKaY9CYw+dcxV4L1BYV3biSZ0LYHW8fR0FKWpSrcOF38O+nC67vRlVlA+s4cQ9NMKu8hpFo84c5Oi/mKRrlU5Ma1Febm5lBQ0DSNmGTaHMcxUZSI6P39fWq12sSL74MthGm6RrPZZGdnp/cu60WZzOnr65k9n3M82OmiZK1Wu/RrrDB7RDw/xiiKwtbWFj/7sz/LZz/7WT7+8Y8zPz9/ZnFunOsMmzwPpm8YhkG5XJ5J+sag0M/n85TyOVQtWdhTVZVYUZJJQhjx8pt3qDYOOWh6tK3p3hacFcmTeUwzs2j4wo3khfmwnUw75qsq5bxCEIR4QczuSUjbjh74uRMPb0zztMlurmywOL+ApsZYtkOnm1gocoZOrVLEyBn4fkjbcrEbzpVnRg87r+kEmE6QlLHkNZYWayjE2I5H+/R95lxOp1zMY+gGthex207eDXjQ5w2iJFP3sBNjaDBfUrixnAjpjh1x0gmJuS+Yc4aGacfcO1F5F3DnSKOj3v93pIYh0TlWp+U336J6eMTxzcTjv/LWW/zq7/t9Z/6cU6/TuH6N1dff4I0P/C52nk/EuBeA8kufx9Vy/FbuOvOuzupCDpUIyw1onQrpQk6lXjKS3Gg3oGnF2O6M+6LHwA9iTrphT0hX8iori3WIIyzXp3tq7ciffj9oeo6OHfHWkXraBPpg/aSWmzT4cRhTzMFKPeLpdYUwTFr53tpXiSIw1IhQP7Wn6eB79z3MbvTgqprve7qhWoD1eYVn11Q0FSwvZr8ZszKnUM5B24G7h9FDj8JLpv6pVc3jzm6XxapKt9MljCI0VUXXtN47oEY+h+u63L59u9cUOK0gzefz5PP5M2J3WCZz9tppxvN5n2+UBztb551OpYWHj4jnx4xsXN3P/uzPsr+/z3vf+15+z+/5PbzrXe+ayrectX+kC3+maWLb9kQLfxcxuEw42Ew4v20nPuc4xg98Qt8n3TnqOgEHTY+m+RBV8xDCCLp2jKHFzJdVVueS4hKIubvv0XaiK5vYTkoYceoxjdA1uLZQYG21TBTF6GrMUcvCajy8DOZBoiimYwd07ABNVZivFlhfLRNFoBCzeRSdCuZHYyLjh3DQUTjoJLm7G/Mqz2wYSXKDAm/uxTQtZaTAr+4fcP1zn+NXPvrR3q89+au/xsbnPw9AodPFXFjgV/7ARzEXFwHI2Q5OtTL0ena1Si6zULzx0ku871/8n8SKyqe+49uwtDxWE7abkDdUbi6o3ForJI+vErPfcLDdB9iycQF+ENMIQhpmiK4pLFR1NlYXem2Eb+6lNdYPTnyeh+3B5mHM5mFMwUji2t6xkVRjf/afRphRIpiVYCA/ekQh1FXTcaCzG/PabhJ/9+QKPLOe+Kz9EJrdCOvRSRgEkpuV7ZMQTQkJfJ8wCAmVCN1JKthVVSWXy3Hz5s3eu6eDgnTSpsCUrNgdlq6RrfNO3x0el0EPdlrnvb+/f2b3SXg4iHh+jPiZn/kZ/vJf/stEUcSHPvQhfuAHfoDl5WWee+65qYVtmu/sOA537tzB87xePej6+vpEC3/Drp22B2YTMur1et8yYZrT3Dw5wQ8C4hhCLyQOYoJTYXTQDqgvaWzMKzh+xG7j6iqzx6GUV1io6FSKKjEKKjG2F9I2XYIwZq5isLGosRyo7LfCM/F4D4taUWGxqmLoSdzZW3fB8VWuL0QsVStUyxFdy8Z8kNVk51DI6VSKBpqm03XgrUNwAoW1WsjGvEpYizixFI47j8bjW87DSjURo10n5rfugOWrbNQDbiwqXJsPOTY1dpvJn/+Kn/hfiXQNJYrxikU+/eEPc/TkE73rZT3P7/qFX2T59m323/Fs7/edcpliu01rY+PMWYrtNkdP3L/WzgsvsPPCC8zf2+Ir/tE/4pe+52N4T2xwfSGknE8W35K34hUWyyGL1TzzlQjTCWmZj0botaErzJd18jkd14+4cxjg+jBXirm1pHEzjjnuKuw2lEci9zqnJ1aHSiFJoHjpHnQchdiN0FMtpYFPpihFfXjpC4YGz6zBQhUcDz57J1mUXJ1XWJ/TuLaYPK/vN2OOu/EDs8wN4/pCzFJNI4piDtoRjpsm4cQ4fkTgh6hqhOP5bG7eZW1ttTe93djY6AnS3d3dSy8FDmYypyJ9e3ubKIooFovEcUwYhhNfO1vnvbq6Kukcjwginh8jXnzxRX7kR36E9773vei6TrPZ5M0335xo2Q/667a73S5hGKKqKsvLyzOp27Ztm06nc2aZMBv5E4Yhx8fH7O4fYzsujW7A7pHTWzpRBr4k04vYPExewGtFhWsLOjldoeOE7J5EDyQ+rFJQmK8YlAsKcVL5gO0GdEwP2+s/wEHT46CZeFqXagbXF1UcL2K3GfKgu0LmyioLFRVdVWlZMa/tqmc8ja/tqry2C9Wixs2FEmtLEIUBbdPFecAhscW8TrmYQ1N1uk7EW4famYnt7SOd20dQzqus1wOe21AJgogjM/FHPkhKOVitxuRzGl0n5q1DleOu2jdNfONA540DKOc1rs35fNHN5N/Byz/wn3OnOF650Wtf8QGe/tSnWP/8y+w+/y4ADp55mhuf/Rx7zz3X92cLrRbz2zv8+rd+hPLJCbX9fXbflXyM/fR13Kev8d7jN9j/klX22wpvHijE8f0J/nZTO51IayxXYGPJgCjCdB+8kNZUmK8aFHMaXghHnYjWcf87Ovtthf3TmMmFUsS7b2rEJL703ebZNuyrRFXhxgLMlRX8UOXeCXz2Hv1C0417y805RcE4fcqNYtBzGg+y30QliZhbn0/OeO8YXt6i7zn19n7M7f3kZmBtDjYWVNbmk0Xco07MUTue+bL2MJaqsD6voqkxJx14dTvofd4o8wArKEQxRGGMHSj8h9/eZe3uIaXT5I5rG6s9QZpdCkxbCKdZCux97szC4fr6Oo7jcHR0RBRFvPLKK5e69rCKb+HhIOL5MeLGjRu9PGO4H8EzTipB+pZVOgXOLvylzUjTeqnGXSYMgoCDg0MOjho4brKpf9LNRLPF2SeF/jfjg8wrZduOadsBqpL4jZ9eSyqLj7sBB63ZTSAVoFpUWKgaFHLK6fliLCcRlcMymAexvYjto8QkWCmoXF8wMDSFrhOx27g60b9QUZkvq6iqSsuEl7eV05zg8594Oza8tJ0Iu/mywc1FnfVa8nfX7Nr4V3TgYl6nXDDQNIOOHfPmgUrTUrjoLXjTTYQpB1AtqmzUQ9avqXhBxEFrsgSBSSjlYKWW5FabbsztI5Wj7sX1zaYLr+0bvLYP7wB0JeKLbkEQxuy3lHPzxMNcjpe++qv5on/9M+y941liXeelr/4QX/N3/x7P/vIneePLfyexplFsNnn/T/4Tbn/pl/z/2fuzGEmye70T/J1j5vu+hceee1VlrWQVySKryOJ2ydtq8bZajR6NerofhJmWZgYaSNOa1jxomSugW4IE9cvMhQQIgxb6RQLU0+oHAbelS4pXt4rkZZFFVrFYS1aukbGH7/tmbmZnHo67Z0Rm7OEemUn6ByRQWRlhYeHuZvad//kWmuk00VyO1//V/487f+ev4Lmaxc3VCNzb5KMvvkFu+/DXt9eHjYrBRgX8HoNMRLKQ8aJcl2bXpj4hIi3FgDD7TBxXUWwoVktDr8PBn+G+A7mGINfQRDoRghcXDUBRbsJWVUyMSM8lIBMRuEqwXYGb2+JgQrkrqq7vPCgclBKuLxuEr+nzvZsTTEo5s5CExaRenGxX4We3OdIAaNmwVtT6bdOAbAwWUpJMRDsey03I19yxlrKEfbCYHhSutOF+3t5311G5u1/sXWkm0hjI1ayBgbpLdrNEOGAQj4VZnJ8dTXV3J2Cc1BS4H4aGw3g8TrfbZXl5+VSGwymePEzJ81OMISk9iDwft2670WiceHo91Hgddexer0ehUKJYqeqEjFqfanN/0mg+bLDY/bvsk4vqqgcaXo+ha7afX5TYjpZ5nEYfLYWebCciHvwePY1TuDTbfRptC2uf4ofjotl1aXZ7g59hcCVrIqSg2nLJV90zbzOnIpowCyGpNOGTDXEm8qgzjrULPx3xsJgwSHoVVr9PrdU9MwkZEWbTQ72tuFsw9nX5HxeNDtzs6AVlPCiZj7ssJgVdyyVX58x6zYAXslGF36MJ8/3BhPksJtB7BYOakkQDsJjQE+l+32Gnsf+teeULr/HMT37CMz/5U25+/S3aySR//H/9P/PS93/AMz/+Ca5hYHs93PviF1n/2pe5nHSJLWfId7/H0j/9V6jBhXfjrbfIXb16onPt9mG9LFgvg98jyYQNFtIelOvStlyqzbOzPL2zI3GRlJsuG2dYYPYdyNchX3fwGDpZ4sVFvViotGCrIs4sO8hEIRNRGIYkXxf8ckUcK4FC7bp4hHiwq+K68NGWiRSC2ZjicxcUHlPvptzNiTNL1ZJhuJzVxSvFBvx6lVPfI2xH509vlnWW9EwMFlKC5xb0NVhvK3aqp0vk8JqwnNLDi14fdmou9fbhF9qe13TXl4rd5VsjA3Uf6BPxd1ndqhINGoTDQZbms8RisT0JGPV6fWQKHFZunzS5Yzgx3m043F3nPTz2UIN9mobDKc4XQp2UNU3xxKDT6fDpp58yPz8/MhH0+/0Rqe10Ovh8vtEW0kF1281mk1KpxIULFw79ecc9dqfTYSdXpFqr0+7pSuxa6+ikiY8aHf7VJ9ocZXh9SKtLf0Ch37x0mT+TTRzrdQl4BTMxQ+s4j6GPNiTEgpJEWEtBFALlujQ6fRrtPrYzuUvEkIJEyCAaMlFKT9hKjeM/0dMRSTxkgNC6382yPHPxweHnCzMRl4WkwmMq+laf2hFRcrsR9JsE/V4Mw6TWUuzUjSNbyM4CASRCLgtxRcAnaPdcdmocOzs3MJBkDCfMG2VJsXE2wnwU4kFNpBNhSbfvsFM3jy1FMSUsJl3iQa1Hzdeh3JIT1ab6PZAJOyQjEuW6tCyX2gmIdDSks6MRkkrLodw6ZGI7BpgGJIJ6d0YAlTZslcWxSXo8BLNRhccjKdUVm1VjkOxxfKj/z+/Tq+owaBkI43aao38L/l/+Lu7M3OjvhoRsTLGQAK9HT1/v5sSxr/OQD67MQjQwmNwW9IR4UtCLbW2QjAb03xtdTaQPa2IXwEJSkY4YuEqRr7mUm8dPVir87f8GdzB9DviDdLr6xhJZWCb4f/tvj/z+oA8yMZNk2CAY8LMwlyaVSo12eHebAhuNBoZh7GkhPIzsVqtVyuUyly9f3vffHz72bsNgMBjcE0vr8XjO5EWaYjyYvgNPMYYpGTdu3OBnP/sZX/ziF0kkEiPD3+zs7LEbi/ZbQyml9iRk9Hq9UULG7mMPZRvbuQKNRotm1yFf7Z84OsyzK7LLcG1w+kjDg4vYd/J8EDqW2lcf3ew6bA300aaEeFgyEzNxlS5ncR1FtdGj0emfmxFGb0nbFBs2XlObEGcWTJ0HXXMfMRpKIB2TxIImSunigw9X5WCqOvlJhePCdk2O6qDnYoK5hBcpXLo9i/o+492Q30PQ70EOCPOdnEHtnEI9FJo8lgctgamwLnjweqDVVezUeISo+b0wOyDM7Z5itWRMnDDvho4P09dWImSwlOhzMSXoWIrt2rCm+wGkhMWESzKkcJWgUFN8WpHn4gOAwUS6YrBegYBXa6QX0kGUa9PqqVH83W5Eg9psK6VBteWwUoSe7XIen2HbgUIDCoPUmXgQri9IpIBKS7G1z2sX8sF8QhHwat/A7Zx5pl0SDrmfPVzP7bh6Sr5VYVS7/fyi/pxqGQOPXE8j419Yvz+refhV/dFK70lA7SplAX0OCynBlayBKRWdPmyW3NHEOxOB2bjEMAY65i375IsnpUbE2TYMLFMPFFDq2AbMdg9W8zareRufp8f9nSaZ6Dp+v5f52TSZdHpP5fbQFLixsYFS6tDkjqO0yg/XeQ/NjBsbG7iuOzp2MBg8VaLWFOPHlDw/hbBtm/fff5/vf//7/Lt/9++o1+u89tprfPe73+XKlSuncvMOyfMwIWNImG3bJhgMEo/HCYfDjxz7s88+450f/YTly89S6/lp9U5/d45ISRiXdquOrdRAjiLwBwLE5Okeqrv10fMJyfNLJrYjBr8zoKBS79Ds2I81OxrAshU7Vb2dGPBKMhGDxZRJt6foOYqQ18BVepp4NzfcHn58W3t9B9bKBmtlrYedjwtmkn5wHWzXwZQSKU2qbcWt3KOk77zhKig0JIWGJiGZiMOFlJ5EtiyFRO9atC1YKxkUzpEwH4RKCyotDwJIhhWLCZvLGU2kLVsSDehrpFB3ubFlDEjH4/tMdKwHn4mA1yQTcQfSDgfLcfFKgeExqLcc1spyYLR9fOdrO8MmO51+EQ/B9QWFlDplQgIhv57yrhUNSs2DowZPgj0Sg4f/8ZCpoq7dFuRqjGq3r8zqqWmrq1//RFh/1teLcGOTsTb/nQa7S1liQVhOCy5lJaZUGEIPEO7k7EOn0kfBdV1IJKlXiri2TaercNw+Xo+PyEz2xMfr9WGz5LBZcvAYFvc267jNH9Fqt/k//R//ElLKUXLH7ii57e1tbNvek8lsGMaJouqklHsMh51OZyTtUEpxfWD8neLxYkqenyKUSiX+h//hf+CP//iPMQyDb37zm/ylv/SX+MY3vkE2e/IbxG44jkMul6PZbKKUIhQKkU6n9yRk7Id6vc6HH9/kzr01QkEfM/OX8MWXQZ48Om8h4OW//dJr/Gpnh19t7yAEvDST5ZXZLL5TblNFAjATNfF5tF7wzo5Lx1LMRAWJkKBnO/T6519echR6totlS7wmeEyJlArDgGoDNspyrIaccaDbh3bfpN+38XlNHMfEZ0Kn51JsPH7i/DAcF2odg1jAIRIQSCSmCY7rUm1JCmfUMo8bCqg0BdGAQcDrYBrGQE4kafcc6l3jXNIOToKOBdW2JOh1CPl185vpkfT7Lh3beCSh5nHDdrW22Gdqc6/PHA4vFR1LUO+OhzgDHOoslce71w1rtz0GLKUgMPCbGRK6XT1JfdzEeTdMCdGAIuRTWH3FVsOlbyuSYcnlrIFSUGm57FTVif0U0jDI/j//HrH796j/8qf0tjbwL10g9uY38WZO92xUSiGtEvmdW9ypVijXuyxkY4983e4oudnZWd3iWq9TKpVGyR3DxsOTQghBMBgkGAwyOzuLZT1hQdu/xZiS56cIvV6P2dlZ/uk//ad87nOfQwjBBx98cKqM590JGUPCDDA7O3ui5iWv14urJNvFNtBmO18nGbtFJBIms3AVEZhFnCAc3pSSL8zP84V9cmuPi3hIkI6YeE1dnbtZdqk/JH9YLynWS4qgTzAX9zHrF7Q7fSote6Ia58NgSkhHPQR9Bo6CctNlq+qMHoBS6CroL1wGIQXbZcX9ojzXGK6HMReH+YSWnNRaivulvfrPaMBgLuZwNSto9RRrJWNiCRjHQcALy0lH5+5aitWCYKdmjGQ6fo9kKWnz+hWFcl22qyarpcdr3LmQgWykjxSC9aLinRsmulhPIIVOebg66xIJCNqWYqsqz6U2+SCEfFpGEvILepZNte2Srz146Ps8kohfMLtg0rcVxZY2Bz5OzMYEkYDWhm+UBB+ty9F15zEgG3N5ZdnBNLSRdiUvj62b3w9qt2zjoXutMo/eOUyG4PKM1kAXG/DBijbMgp5kpyKwnIEXlvTC9n4ecrXTn+9pIYBMVLGUBr9HUW25rBX36pi3Ki5bFRevqdOTri8YCAG1lst2RZ1IfuS/eBn/xf11xcc+Z7tFu3SHUmGTesuiXOuNzmH5iF1dIQR+vx+/38/MzMwouaNUKtHv97l79+6Z0jVM05waCZ8QTMnzU4T5+Xn++l//63v+nxDiWFF18GhChsfjGemXt7e3TzW99ng8yF2SilbXodVtIvNNtnNlYhEfiWSG+Ow18D66ah8X0hFJImxgSv0QWSu6xzLxtHtwN6f1G/GgwWzCxGNAvdWn3p68lMM0IBP1EPAZOI4mzOtlZ1/Ntaug1FSUmjamoX/nN67pKepaSbJZnuy5DjGfgLm4jdeUVFuK+8WDDVP1DtQ7unI9HnK5mHYIeAW1jmK1aJwLyfN7YDmlyWXXUqzmJTu1/U103T7czpnczkHQZ3AhZfPGMwLbUWxVTDbO6TVeTMFczMaUgs2iy5/eNEfkaDdcBZtlyWZZVyovJF2uZF2Cfi0/2ayIc9ml8Hs0YY4GwbJdai2HQn3/+1Kv79LrQ7Hh4PNIogHBXNyjiXRTnBuRzkQlsQCAZKeiuLlt7BsL13f0bs9GWV+vszGXl5ZdPIai0hLcz0u6J32Nd00hxcPCjQMmz0EvXJ1VRALQ6AhubO5v/FMMpSj678mwJtLPLWij7FoBtionPN8TQsszFLGgThnK19wjd0YsG3JVl1xVa9ETIckz8waGhEZHsVUZbwTeHqg+dn2N4vY9mq0uhUp738WRPCFx9Xq9pNNpHMfBsizC4fA0XeM3BFPy/JTjILPfEPslZEQikT112/2+fmKcJIB9aCbs9XoY+0yWXQWVhkWlYbGRa5Da2iYc9JGZWyKQvASG/xS/7V7MRCXxsIEUUGvDSu5s9bHaqKVjl9IRDwtpL0q5VBp9Wr3x7X96TUhHvPh9erpVarislfYnzAfBdmCn6rJTdfF5YCZqcHlGTxzv5QWlQ/KCT4OFpCZzHlNQaSlWCsbA7X/MzwtQaUkqI+Oe4vqCwpRa13u/cPy0g+PA79ET5khQ0LVgrSB4v3qy1Il2D25smdzY0vKfCxmHN58RWH2XtbI59knefAIW4n1MU7JdVvzs1jCJ5NHrK1DJ040kUOYD85DjwlpRslaUmAYsplyuZBV+r86X3qqOl0h7TVhIuMSDWrdaazmsFpwT1dH3+i6FPhTqu4h0zINlu5SagvIp4iYPQzwkSIUEhiEp1ODD1ZOl09gPEelszOXFJVfHybVhJX+8qf+eyfPDYpBd91OPAVeyepLctWAlD7mqONGiXmuO9X/HQ7CUhmtzmqxulHQpyjgQ8MJiSpGNQa+vKDQcCvXTHct2oFB3KdRdDAnx4MBwaECrp9iuuGeO7VNKIbo5Sls3aTQaFGtdWh3ncGmOENRqNSKRyInqtpVSGIZxZJ33YckdSqlTST+mmAym5Pkpx8Pkeb+EjKPSN05CmB82EwIYxuE3EduBXLlDrtxhM18nHb9HKBRkZuEqRmQeIY5ncJQSslFJLGSAgnJLcWf7dDmih0Gb8hT5usJrwkzMy4WYwLIdKo0+3f7JWZ7PI8lETHxerVcuNlxqRWcsk+1eH9ZLDqBrlpeTiufmDBodxb2CeeIYrSEWkzA7JMxNncN8FlPPENq4Jyg0tFQlE3F4eVkghKJQF2yU5Kkyr/3mcMKsX5PVguSD+3Isus9GBz5eG2RIhyQX0zbXZgWdrstKyXPq6K/ZOCzG+3g9klzF5b27JpUDjhWsFFj86F2Sq59hthsIBI35i+w883l2rr20J1XAduB+XnI/rwnYctrhclanjDS6Or3hNIsVY5DskQjp+0GtbbNeHI9n4FEiLZmLm1i2S7GpF22nga5MF3g9kkpT8cmGORYNvs451js+poSZmMsLi1p+UGvDSkEeTPAOecGEaXIho8hGXVwlWCvCJyMZydmmk9VdDZzRACxl4K3n9e+yVdYxdieBKXUKyUIKFDpm887OeAme4z7YcZMCokHBctrA54FOT0fgnUQKJvo16vnbVEt5qs0e1aZ17EW1lIJcLsfGxsaeOu+jouMeNgw+nK7RarVoNBrHSu6Y4snANOf5Kcevf/1rfD4fGxsbeDwe4vE4tm0TCoUIh8PHqtt2HIe7d+/um9QxdBLv1kYPncDBYJD19XX+3//kn1OonCy3SQiIBE0S0QDRWILU/DXwJR8h8qaEbNwgEtB1x6WGzkJ+HIa5oA/m4oKQH9pdm0rzcH10wCtJRUy8HonVHxDmjjrRZO4siAYgHRF4TT2Jvlcwj3zdRnIBQ1BuKvJ148zlIseF14RsxCEdE7iOYqdmsFU9/Ht8A8IcHRDmtaJguzoewnwcpCOKixmHWFDQ7CpWCuaRMXzpCFxI2fg8gkLN5W7OPNZOwdz/9++QdhRRJRBSIh2HjpSUXIvC679L47VvHXkMnwnLGYdLM5pU13ta2nGY8kuiCVIq4iKAetum0XXPLc7R75VE/ZKgXxPpQlMcWYDkN3VpR8CrF5FrRYNy63y2xU0JmajLYlLh9QjqHcVKfu911P+H/w8cS39QzFAUu1VHCjAMwZv//A/YqijWSwbdc7r2wn49kZ4ZKOs2S1onvd9bLIBMTLGcAp9HUWm5VFvHz2MeFwQQCQrSEUnAK+j2Fbmqu39uvNvDqq5Q3LlPo21RqnZO/AwRwBdfWuZv/rf/zcgUWK/X6Xa7o8rtaDS674Bqc3MT0zSPlEYqpUbpGvV6nX6/PyLpQyLt8/lOnKg1xfgxnTw/pbAsi3fffZd/9a/+Fe+99x62bfNX/spf4c/9uT+3J1T9OBh+7XAddVDd9tzc3CPaLI/Hg2Gc/KGkFNRbNvVWAyPXILGTJxLykp5ZIJ69wtxMhLBPb7MXG4qN0tGauUnjgT4aYkGDuYE+utHuU2tpfXTQJ0lFPHhMbSjK1xwaR20FTghab6yQQhEPwqsXbYSAnZpgNW+MHozLKcjuIsx3cudHmHfDsnfnBcNs1OFLlwVWX7FRNUYaTq8JFwaE2bJhtSD41ZgmzCdFsSEoNkyEgJmoy6WMTcgvqLf11H8oCUiG4GK6j98rKdVdPrxvDra0j3+dNpwe1Z5mBtFAnFa/jjN4F497CfZsuL1tcHtbS1suZByuzYAhXWodyXblAWGajcNM2MEwBPV2X5u3HoOZtmu5dC0X6jZ+ryThlyzETXp9l2LrAZE2pTb+hXx64rtWFOeazz2E7cJ2VbJdHUQiRl2em3fwewT1NqwUJdWBbEMICJiKrqGH0bYrefvT8580NrtwY0P/CflgMQ1vXtf36Z2qlouE/Xt1zDs197GmeSh0i2G9rU8i4hdkopILGS1PylUsSvlNitt3aDbbFKsd2r3Tr/iEANNjHmgKrNVqbG9v71u5fVxJ5O50jWw2+0hyRzqdZmlp6dS/wxTjw5Q8P2X44Q9/yB/+4R/y9ttvE4lE+PznP8/f+Bt/g+9+97tnDk+v1+t0Op1D67YfhmmaewyDp4HjQrHapVjtspmrs5BbZ9XrJT13BRm+gBJPXih8rQ2GUGQTkljISzjgxTTAdhQ7VYdG58nJknMVlFtQbmkjTjIEX3te0O8rPB7Bdtnlds44s4ZwnOhYsFI0WCkOpmIJh2fmdLKI7cLtTcGH9+VjX1ANoRTkapJcTZdtzMYdPnfBwZQCIaHScPl4zSBfE6gTEOaD0HLtEXE+Lbp9uLllcHNL75JcmnH43EWJq3QldK1pkavrOLEnBQ8T6VRQspzyYDugENzZ1u/DeRXEHAXHhZ2qZKc6zBZ3eXHR5eemTpFQgOUIrGGizhnvpeNAqwc3N/WfRAiuzWtph+vq36HWdinWT1+bPik0ujrTX1gVarlblIo5un3IlXtjWUAJAab56LNoaAo8rM673++fOF3jYZLe6/WOHQ4wxeQxJc9PEfr9Pv/yX/5LXnzxRf6n/+l/4sUXX+TGjRsYhnEq4mzb9kiOAZo8RyIR0un0gVXeD8Pj8ZzYgXwYLBvanS5bGy3COx+Qjt0gGo2SmHsG15dFiMer/0pHIBOTeAxBrQW3thg1jflMXUk7GxckQtrs0rGeHOKRiQoiPl0/fnPdZasiWU67zKcEIZ/Dds2gcswa6POA19DpEfEg9B3BzU1Fpy9ZTjlcmxdkYg43t05ejTxJxIJwbdYm4odKQ3FrSxLwulydF7x62WWnIvhk48nK6V5Mw7NzNkG/ZKfislM3SYVssnEvM6ZDu6+onKBu+zwQD5mD7GjJSh6aPYNs1OZyVjIXt1krmeRPaVabBEwJV2ZdUmFF1wKr747IqN8DtgGOAzzm+xtoI+R8QpuEHQWbZUb3Ba8pyMYMLmZ1slGz67JTcR4/kbbbtEv3KOY3qLcsKvUO0aCHVne8iUmeI7TNpmmSTCZJJpMjU2CtVqPVatHtdrFte9QUeNJ0Da/XOzUMPkGYkuenCB6Ph//xf/wf9/w/KeWJVqO7zYTdbndUt93pdJibmzvx6tg0zbGS5yEU0Gg7NNotjFyLZK5ELOwjkc4STl/DNScXe/cwZqKQjkoMKai24LNN9jUc9Wy4m9Ptf2G/wYW0wVLKpdHVk5rHMSWdiQoifoGrJOtFl1/ekTQ7MDQeFWqSX96FTEzwzLzD8qAGeqP8eKQbpoTllCIaVDrZoAQ3NvcWgBQbJlLo7fCXLzj4PVCs6ynqWbJ3T4uwXxPmWBCaHcXNDcFmSeCq4XUhubMNPg9cyrp8/XmFIRUbZclnG49nSjoTg+cXbSJBSbWpuFvw7NGKVlomd/I6rm8x3mchFUC5Dm3Lpdp6PMw/GjCJBAyElOTrirsFc49ZuNLSj7NYUDIft3l2XtLpudwvmiPJz3lCAhcyitm4i+MK7ufh1/f1Z9njKJSrJ9Oqq6e6pgFer+C5iy738nJ/7e6EIIT+TCyltCxqpwYfrT/qa7Rsnc6xXtKa+ZmY5OKMxGNAq+eyU3XOb2Ho2vQb6xS27tFqdyhW2nT7u05YjLeOXAjweI8/pNptCrx37x6BQADXdVlbWwPYk64xNQU+fZiS56ccR+U8K6Xo9Xojwtzv9wkEAsRiMebn50cu4XK5fOItIdd16Xa7E2/XdVwoVC0KVQvvToN0YpNI0Et69iKe2CWUPHvs3cOYjUMqbCAllJrwyQYnmnA2u/p7QJIKCy6kDW2uabqUm5NrNJRAOiYI+wSuK1gvKH5xWw7O/eAbdKGmibQUMJeEZ+cdQgFBoyvYKD3YVp4ETKkjruIBvZW9WRZ8unl4Y547kkkMtK5xl9efcTAkbFcEd7YnS0qDXnhmziYe0tXNtzZhoyhw3IMvhl4fPtuQfLYBQZ/gyqzLt1/RaTmrebi9dbqUkeMiEYYXl1ziEUGjrVgvmZTXD7942z24lfNwKwdhv8Fi0mEh7cV1HVodh/qE5UlBnyQe8mAYknJT8en20ekxtTbU2vq+Fg9KFpIO1xcE7Z7OFp80kZ5PwGJSa8U3iooff7aPJOqhCaIzINKuFKwVBVdnXcJ+vUi/l5sckY6HYDkN0aC+z93JcWzy23f0VHqYNpKJSRZTupmxbemJ9LgXs0opVDdPaes29XqNcq1Lq2Pv6ymR4vAix5NCAFIa9Hq9UxWcBAIB4vE48/Pzozrvra0tHMfZk65xlBlwmgf9ZGBKnp9ySClHkXFDDB27Q8LsOA6hUIhkMnlg+oaU8lhbQo7jPGImHLdMTwgxqMV99N8sG7YKHaDDxs5HpBN3iISDOq0jsADHjL17GBLIxiEV0d9fbOrJy0kyYA9CqSkoNcGQgmxMcCEjEQKKdeeR5sPTQKInx6EBYV7LK94ryFEL3UngKtgs6cmpx9CTsyvzCo8BlTZsnjJG7mGYEhYHkgzb1TFZN7eMU02tbPdB9q7PhIW4w1evOyilWC8a3MuP5wPq98Izsw6JsKLbg9vb8ONPOVWEWLsHH61KPlrVpRdX51x+91Xo24p7OYN7ubGcMpEAvLjsko7qn7leEnyyJU9FKppd+GzLgC2IBiSLScFi2qO3p7vaGDsO+DySRMjA49GRcrdzxkgadVLo7PZBxGCQEZFuDYj0uPLQEyG4lHEI+AT5GvzynnEw4VVqb0nK7jdDSLYqgq2Kvq9mY4orWXdQjKJTO84qrQp6darOTByaXcVmWXDnjJ8324Xtiv5jSF3gNJ+S+D3QsVxyVedsnop+g3r+DuXiDrVmj1qzd2Tai4Sxtq8KAaYhuXPnzkjLHI1GD/UEDbHbMPhwnXe32x1ppE8agTfF48P0nXnKMSS93W6XQqGAx+Oh1WqNIuVmZmaOlb5xWNnKbm10u93G5/MRDodJpVITqQt1laYiRz3fWz2X1k4LKVrEchUSUT/xeJLY7LM45qOxdw9DSl0vnQjph2u+Dr9aZWLGOcdl9GD0mbCQgKuzYNnqxPpoKbQkI+QT2APCvJKXgxzm8bwffQfu7Aju7Oj0i8tZnWOrUBSaBrnqyY5nDjKC46EHWsqb26cjzAehZ8O9osG94oAkJG2+9aLAsl1W8p4TtzB6Tbg255AO63jE21uKn34m6Y/xnBsd+OCe5IN7usTjmXmb//hVScdyubNjsl7UX/dIE90B8HvhpSWXbGK4zS64tTPe1Il6Bz7dHMokDJaSNotpL46jp9Gt7slYiykhGfHg85q0e3C/JCm3xFgnh7uJdCKoWEo6PD8g0vcLxomzukM+uDLjEA7odJUbG5JC4+j3SCl9De2LXfcsV8F2VbBd1UR6Jqa4NOPyckDLg+6dgEh7DJhP6qm47Sq2KvD+imAS24aOq6vAc7VBIVJEspCQBHw6yztXdY43lHAtutVVClsrNNs9yrX2ie4ViqOfISeBEBCORHjuuedoNBrU63VWVlZG8ozDmgIfznl+cExBIBAgEAjsSdcol8tsbm4SDAaJxWJEIpEzBwJMMV5MyfNTjFarxY9+9CPefvttPvjgA65fv85//9//9/tGyh2Fh8nzw82Efr9/RMaHzYS7v3esUINnyDHvfLrN0KbSaOLZaZLayWtZR3YJX+IKygiOvtaQ+gESDxm6DKUGH9znXGqid6Nnw72C5F5hEAGVFCymtAHnIH20lJowB70CxxGs5hX3C+MlzAehY+mihk/WdUnBtTmHV5YFfVsdajSUEpYGpRrugDDf2jkfbXLbgls7Jrd2IBrQBO+5BUG763In5zmw/cyU8MycQyaq6Dtwd1vxi1tyUN082de52oKf35ZwW+vsn523eemCpNVx+VDCQS+bKeFzl1xt8nJhoyz42Z3z0VPvlkkkQgZLSYPFNNi2Q61j0zkgHkxKSIY9+L3mQAIgKJxTtFylLai0B7XxQcVy2uGFRUGrOyDSB3yeHxj/oGMp7uUE25WTnbNwH7q4d90/DzJEuwp2qoKdqhjEIg6I9AU9PV7JP0r+hYBsTE+ZPaYiV4WP1ndr8ScPV0Ghrv8IAamwZD4hWU5Dz3Yp1Jy9BSeui9PZprB5m2ajRanWoX3KdlcBqHFOngGfz4thGMTjceLxOK7rjpoCV1dXEULs2xR43Kg6n89HJpMhk8lgWdaIpG9vb+P3+8lms/j945cpTnFyTMnzU4ZqtcoPf/hDfvCDH/CTn/yE2dlZXnvtNf7gD/6Al19++dTGAyEElmVRKpUeaSacm5s7dPtoEobB0x6x78BOqctOqct67lMyiRUioQCLFy5z+dIlhPSwU9XGvsdhLtsPzS58uqXft2RYcCEl8Xmg3VPk6w7piCDkFdiO4H7e5X5+2Fz2eLRv9Tb88u7BRsOuvbuFDjYrcPucCPOB59yBTwaT0mTY4GLG5uULgnpLcWvHpNWFq7MOMzGF48K9bcX7d+WgpOLxvM7FOhTrEgFkExKPqcAc7MxIcNBkzpDw7KKiC/xiZbyT/JOi0oJKS093kyHJUsoglQbbcai2bLqWSyJsEvKZOEqwXYVc3XhsecGKR4n0hYzDC0u69OZ+waDagosZRTbu4o6Mf6ePSRQP/bJ7ePcx7qU6FlGQqz0g0hdnXF5ahlZXUW0bRIMQ8CrKTbiTE1j249fJKgXFhv4jgMSASM8nFcVikbt3blEpF6k2etRb1tkXUUKN1UMgBPgf0jrvrtVWStFqtajX6480BTqOc+Jns9frJZVKkUqlRhF4UxnHk4PpO/GU4e/+3b/L9vY23/nOd/ibf/Nv4vF4qFQqXL58+cTH2m0m7PV6o6akeDx+LOPCEGLMomfFsZ4hR6JrKdZzbYRo02o1ufXZDSLRKOGZ63Rl9okzXngkpEIuHkNh2ZJSXbCQ8GAYik/WYCUHSj1ZzVJDo6HXhDefh+sLQ0mn4Ferciw1yONGuQnlpokh4HMXXb7yrG5HcxzBOx8xmEg/OZ8NBexUINkTOH3wmLrtUgx2S2wXVnKSfunJ+myUW4Jyy0AIeHFRMpf0DAiR4uaWpHTKSvNJ4WEifW1W8bmLejElUPzqvnFi2c9+EO7e1c3DmucTnfOASDe7ggszMJ9UOEphGlr/Hwu4NDoG5SdkUDCEAuqNNtWtO5Tza3Q7HXp9l3JjfFuA476CBeD3H2wUHJaJDQvFhk2B29vbOI5DLpcjkUgQiURO3BBomibxeHzgB3py7k2/zZiS56cMf/AHf7Dn7+vr6yfKfnzYTOi6LqFQCK/XSyQSIZlMnvicJnExj/OQSkG/77CS72MabTLbJRIRL/H0HGb8WfoiOr4fdkJ4TbiQdkkEFX1HsJqD9+8aA4kAfHgf/F7BlVnFn3lVT1BvrDM2o9NZYEq4vqRYSClQgpUdxY8/dunbcDGreHZB4TEV+brgXs6YaJLESXAxrZhPOEgp2C4rPtnQteWzMcXrz4HHUKwV4KP74onJY746B12/oudqE1Sjo7AtLX0wDbg042Au2NzLmXSfkHOeiekacr9XUmq6fLCqUyeSIcViwuFqVn+eV4uPJxZxP8SCsJR0CHgFhZriRzcMGh0dV3lxRk+k6x3FzS2DymnJv33wGyROMJ30GLpSezGldcybZfjZ7b03zkRIsph0uDYn6A52hh7nokUoG09vjfLObZqtDrlyh1ZPG7WFerKyxB+GlBLvMXXHDzcFfvrpp3i9XgqFApubm1NT4G8Apu/aU47j5DwrpWi32yPCvJ+ZcGtr61Qk2LIsDCmIBA2a7fHUUE8yB952YLvcZ7vcx791h7n0BpGgj0T2EnbgMq44eQTRSeE14WLaJR7UJrT7OXj/zsGa2q4Fn6wJPlmDWAiemVe8HtHTyJsb40kEOS5MCc8tKpYy+n26v6P44a/EI7rr21uC21s6ku3qnMvrV8FVis2KycYYpncnxXIaFhIOhhTkqy4frJqDc36AzYpks6JJyULC4c98AVCKuznBp2vjde4f65xn4LkFF79XspG3qfTAGpBMaejp3TDi7P3biuQlh+cvKPxeQbkluJc3zj1DOh6CyxmbkF9Sb7vcLxmD3YcHk7ZSU0+dpYBU2OWZWQefR1DrwP2CPHf/QcCrr8ewX9c939zH+KdlEsYgD1lxfUEnYNRaAyJ9kgSMw4S4R0yehYC5BFzIgNdUbFfgw9WDdcyVlhjJaBIhmE84XJ3VEqutyuRj+0A/f3xOnmbhMxr1KvlKj1rL2SPLkIIj0zMeJzwGJKM+2u32gea/w6CUIpPJ4PV6HzEFhkKhkfTjKFPgdOr85GBKnp9yHBQx57runkg5KeVoO2k/M+FhaRu7sV9utO0opBDMJExsFxot+0wTO22uOP33HxfdPqxsdxF0iWx/yGzyJpFwmGj2WbrmwljbvrwmXEq7xIIKyxbcz+n85ZO+TrUWvHdb5y7MxBVffEZPpld2FPd2mEgRi5RwfUETZoD7OU2YjxOF1+5pfeiv70MsJHh2oc+bzxj0bK0nneTDeyEJS0kbjynI1xS/XjOPzLsG/RreLxrcL+r2t6WUw5/7sqDfd7m5Jbi9Oblznk3AC0su4YBkp+zwp59ArqI/JAuHkAvHhc/W4bN1F78Xri0IXl7SNdvFpmClYEyM/Id8cCXrEAsK2pZisyyptgWKw7emXQWFhqTQGMSbhRXX5x08BtTagpXi5JoYTQkXMzoqsdvXxr+dYxj/lIJcVZAbGPeyMcX1RYewXyduHIdIC+ch2caev+x/PSXDcHEGYiFFsQ63tk+uY96tR4+H9ALxSlZPpLcqBoUxX4um28Cp36Ja2KTS7FOsWgfen05iED8vSAGRoEHQq6vfOz0LpRSfffbZiXKZhxg+cw8zBQYCgRGRPk2W9BTnhyl5fsoxXAG7rovruqMJc6vVwjRNwuEwCwsLR2ZRHla2MozCGxJm27YJhUKkUilCoRCmaVKo6+/1e3TklCF1DW2zY594oqDU+SpOFXriVG93MGSHxFaJVMxHLJ4ikHmBnkicasXvM/UDOhaAnq1Y2YH3RoT5bL+hYvgQ18RjOQPffFmTqFtbsFE82wRfSnhuQbE8IMyrOcV/+FAMyOfpzr3Wgp/fknBLMROH64t9npuTNLqKu/mjyy+Og7k4LKdsfB5Jse7y8YZJ4wy6625fmx1v70DYL1lO2rx0UdDuuHyyJkcxcmdBKgIvXnCJhQTlmssvb8NWcf/ih2OdswUfrSg+WnEI+eHZJXj1gl6Q5uuS1eLZF4VeE65mXZIRvXuyVYHbudMnOTgu5OqCXF1gSMhEXF5cdDANKDcFa0U5lqKepZRiJqJLilbz8OF949Sxg2qUgGGMouSeX3QI+QW1luKzrf2znsXD99k9kucH703IBxdmdGFTva3YKAtu74znzlhtQXVIpIN6In15QKS3q8apq82lshDtu1R27lFvdclXrGPtJIgxtwEOj3kaBLyCaNDAkNDsOmxV9Ill4j7m5uZYXl7eN5c5Go3uS6SHz9X9ptUPmwKHRDqfzz+SJT3Fk4UpeX7KUalU+OEPf8g//sf/mDt37vDP/tk/G12MXq/32KTv4Qn2ftrocDhMJpN5JDd6d9pGtw9bZf2UiwQgFfUAimbHpdNzj0UIJjJ5Fse7MzsuFOsuxXoH7/YGme0d4mEf8cwSMvostgge+v1+j94CjgahN4iy+nlJ0J+g291xYSUnWMnpjN/LWcWLr+r84JPoo6WEZ+c1YRYS1nKK//BrsafOe1zIVyFf1Y2Gi2l4btEmFBBUm4Lb+ZNNHIfa2oBXUG4obmyZA9Iy3spbnYpiwpaOOnxmweZLzwqqDZcPVyXF2vGPFQnCKxddkhFBveny8X3Fen78BKLVhfdvw/u3HaJBuL7s8KXLOqZxp3YyCY2UcDnjko0rXBe2q7B6f/xxeI4LOzXJTk3ruWciLi8tO0ihifRq8WQ/MxuDuZiNaUg2S4qf3hy/xtp9iEhn44oXlx1CPkF1IO0YEemHo+p23RWFlFzOah2z4yrWS/De3cnkMQ+xO/86NiDSl2YEvb4m0rmjPtfKxWtvUd2+QaPRpFDp0uiebJAsxOMdPHsMiIVMvKaib0Oxbj/yGZNS4vF49uQyDwtOSqUSW1tbeyQYQy3z8Ll61LPYNE0SiQSJRALHcR7Jko5Go8zMzEzk95/i5JiS56cQm5ub/OAHP+AHP/gBH3zwAVeuXOHrX/86f/tv/20uXrx4qmMOJ8+tVotGo0Grpfcew+Ew2WyWYDB44MV/UNpGowONjoOUOt8zEpTYjqDR7h9Kjlzljv9RoQRCqBNNYy0bNos2m0Wb0PZnZJP3iISCxLPP0PdfQAl9+fi9WpIRCeip38oO/Kwk6Dvnr0/rWvDpuuDTdf0gvLag9dG5Cny2yUBq8QC7CbOUOjv6Tz6aDGHeD66CtYJgraBTJC7NuLyy5GIakG8IVg4wGqYicCltExyQk9s75pmb104CPbkzEegSiNeuaqJUqLn8akXS2GfiGPBpwjwT03nCn6y6rOY4t5i2eht+9hn87DOHZETw/AWL168Y9B2tRT+IJC2nFAtJHbWVqyl+vT45OcXDsB3Yqkq2qprgzERdPnfBQQgo1AVrZbmvHCUWhOWkNisWaooPVsyJVVw/DFfpivjtioGUMBvT5D/oE1RacKfssHs9K9C7R4bUGeqGoQ7VMU8SOrP7AZGeiztczGgivVMz2Kk++FqvW6Fd+JRapUCp3qPSdE+tWx53lfZxf2YkYBD0aVlGtWUfWpBlSPGIuc/v9+P3+5mZmcGyLOr1OtVqla2tLYLB4Kg4BU6mVz4oS/q0UbRTjB9T8vyU4V/8i3/BP/gH/4DXX3+d733ve/z+7/8+jUaDixcvPlJechwMCXOr1cKyLFqt1qHa6P1w1AXtuhwo62h07Ecffur0W24HQhyvtfAgtHpwb9tCCovYzntk4r9mJpPh8pWr+MNpVnKSjZJ4bHm1+6HWhl/s1kdf0w/EtSJYlmIxrR8Iq3nF2x8JGh3F44xo69twa0twa0tHsT1sNGz1hmY0rS+9lzcoNR+vgUYBxYag2DAHdcrw1gsKrynYKilurAuuLbjMJ3Su+GerLu/8mrE2FJ4G5Ybixx8D2MzEBS9ctPjyVYNuX7FWMvGZsJSy8XokxYbLjW3jsWaLg9aiD02dXhNmoy6vXXRRyiVfNyg1BMtpZ2D8g882jGM1/k0SrgtbFclWRS9UZ+MuVzIWN8wH96KgV1Hv64VC05I0qk+GKWw3kY4G9ET684s97q3cZfX+fWqtHsVqfyz57QL33MjzA1mGotl1R7KMoyClONTQ5/V6SafTpNNp+v0+9Xqder3Ozs4OAMVi8VRa5mGWdDgcnpLnJwhT8vyU4c//+T/P9773PWKxGKBLUxqNxoni6hzH2WMmNE0TwzAIBoMsLCycWN9rGuaxieluWUc0AJmYB1c9kHUAKBRSGjDGcDPHccdiSnEVVJqKSrOLZW1xZ2WTWMRPNDGH1/8cNpGxnO+4IIGr83AhozAMbVSsdwTPLGiZzq/uKdYL4lxa3U6CodFwswRfelZwdVZnMaMkn27KA9sBHyd0nbLe5n5mzuXCrGRxBgwpubVu87NP3XNPvzgO8lVF/lewmHH4+isGL19QCKDXl3y2JWh0n6z8aNC7QmtlPZG+NitZTMF8QiGE5M423N5+Mgjobrgu1NqSYFOXc7tK/z9XgSG0VMow5IEtko8LQjn0qqv86uYtGq02wrW4lx/vDUOp8RaaPIw9sgxnf1nGUZDicPK85+d5PCP5ZKvV4v79+7Tb7T1a5lgshs/nO/bz9iTP+Ckmjyl5fsoQDO7V3O42DB4Gx3FG+uV2u43H4yESiYy00ZVKhW63e2Li7LouhqEjnE56bdc7UO84GFJvfUcHsg7HsSdT+T3eI9K3bbZKcHe7Rch/h8XMGrFIgHDqMnUuY6uT7wSMC9fmtVnRNAQbRZef3JDU2zB8Fe5uK/xenR/88iVBowMf39dO/seNeBheuahIRbVB8fa2blNzFaSjgqtZm+vzOm/3Tm48RsNx4GJGsZBwkEKwXVH89JZJtw8+DyzEBf/7b5nYtsunq/DRypPBolNRvTiZSRp0LMVmRdHoatlULAiXZ1z8HkG9Dasl+cTkMS8mFbNRTbh2KnBzW2I7OnZuLubwnVcEtq1YLRrcyz3ec/WY+nznEro19M6t/ijHHaDdVVh9PZkO+gXPX3VodOBewThURjBJKKUIqCKtwifUaxUKlR7Vll7ALqfH//MEk4mCjAYNQgNZRq1lUzjD6ymPmUj1MIQQGIbBhQsX9miZ7969i8fjGWmkj7PTO42qe3IwJc9POYbkeb+Lut/vjzTMnU4Hv98/Mv09LPE4KPJuPzw8uZaGPNNU13EhX9N3zoAHUlGJz6MwpEG97Ywn/1NMQAoy0FGD1hLfXLcQwiIZ/hXzmRtEwhH8iWep2AuoMcbeHYSrc3Ax4+AxJRtFlz/9TFJrwUHGua4FH68KPl7V+dHPLQjeeF6TkU9X1bmS0mgQXr6kmIlL2j1tgPxgVT7y3uvKai2RmI27PDfnEPBqI9nt3PlpcYdYTMJy2sE0BLmqy6/WHs2P7vXhXsHkXgGCPoOljM3nrpq0uy4f3oM7m+dLpEN+eP05yeKMpO8o8nX4ZEMTjCEUQyOZjmRLBBXPzbl4TJ0dfL94/gUyM1GYj+vPd76m+PW68UiSQ8fSpPNeQadVzMVdvjunzbsrBYO1wvmc69A0uJTS7YS3t1w+uqfvdaGazd75pRpldpeakn/zrvYgXFtwCPr1IvH+ORFpD02c6mdUS5us1S2KNfuReLlJ8LdxHtPvFUQCJko5CDi2LOMoCKH9RtVq9USTY22A11+zn5a5Vqtx//59pJTEYjGi0eihHqMpngxMyfNTjmE0znDybFnWaMLc7XYJBAKEw2FmZ2cP3XI6Kud5v8l1KBRibm4On9c3tqlup6+LB4J+gcBmNmGiFNTailb39CRDTUBH7e5zTKWg1FCUGl1Mo0s2USab8BGNz+CGrtOw42M9hysDwuw1JZsll5/ePJwwH4RaC352S0+AsgnF688JAj5Y2YbbW2oiRCnkh1cuKbIJoQlmXvLrtUcJ835w1QMtqW5ac3ntkosUilxNcC8nJ7YNPBuDCxkHv0dQbCg+XjdoHCM/GrQc5eaOyc0diAYMnr3g8JUXDKoNh1/ectkqTeacvSa89qzk6rx+XQp1xY0tjmVKU2pYta1NbYmgy0uLOlKu1BSsFsXE5CixACynHAI+SaWluLVz/J2GVg/u5CR3chD2w1zM5bkF6PQUK3mDjQm81qkILKYUYR+s5V1+9JF6NKrtkKg6hJ6g39uBezsK09BE+pkFh8BA679SeHTRcBYI1cfbu0c1d5d8s8N22TqcqD+B6gHTgFjIg8dQdCzB/R2XS7MG1fb4blxSCq5cuUK/36fZbO6ZHMdisQPjYA8qVRlqmaPR6Mh7VK/XWVtbAxj9WygUQko5reZ+wjAlz085hBBsbm7yv/1v/xvvvfce/+V/+V/y8ssvE41GmZ+fP3b1537k2bbtPYTZ5/MRDAaJx+N4PB6EEDq+x+sZKzHV+ltBu+fQ7jmDsHoPiZBuH6u33VORuUncdg47pu3AZtFhs9gm4L3PQnqTRNRHOHmBtvkMPfd02Z2Xs3ApqwnzVtnlZzcl1VMQ5v2ggJ2KYKeiidKFGfj25wWuC5+tK9YLZ4tT83vhlUswl9QGsJW85JNNeSajZd+BeznJvdygLS7j8JVnde75emk8jYapCFwaNOdVmi63tk2qZ0xvqHfgkw29+E2GBF963iUSEOQrDr/4zN0nYvCwT9uj/yYlvHJZcv2CwDAEpYbi1ijd4/R5zMWmoNjURSPJsMvnLmhTar4B66Wji0aOgt/zIL2m1YO1kkGldbart9mF210JuYH5Lenw/JJOPbmbM9ipnP7YIb/Oj85EIV91+dUdNZBI7Q9xSFTdw8VMu4m0x1AszwyItPdsjYxKufidHRr5T2k2GuTKPeqdk6URjROneXeFgJBPEPJLlBJsl93BfXAyJVsCbQr0+XxEIhFmZ2dHO7u74+QenhzvnjwfBCklkUiESCTC/Pz8iEhvbm7iuu6oyjuRSIz/F5viVJiS56cQSik+/fRTvv/97/NHf/RHbGxs8PnPf54//+f/PN/+9rdP1Uw0jKobrqqbzeZI6hEMBkkmk5imOSLMu/94Pd6x3qyUAkM+uIu7Cmot/YTwmpAMa7Le7kGjo471sJ7E5PkkedQdC+5s9WGrTyz0CYuZO0TCIQLJZ6i6y0e2sV3OwsWsg29ImG9Jqk0Yd5bxbjju8MHNI/roT1YVhWPmGntNLclYTOsJ5Wpe8Pank5FYdCy4sWlwYxOiQcmVGYevPSfoWi4rBfNEjYaxoG7OiwT0xO9+3qDUEkziNdeTXZ0RnI7AN1+T+D2wUXB57zP3kYjBR/Hgg3h9WfLSZUHAJyg3FSsjicV4LwDbhXxdkK/r6X86rPjCJRdXKXaqgo3K8V8nU8KFtCIZUlgObJYFN7bOTsT3g/ZaPIhju5BxePmCoNlR3NkxyB/jc+01YSGlmItrzfJn6y4/u3G8n39YSQqHpCn0Hbi7rf0KHlNxIQPPLij8vkEjY14emXzhVTWs8qfUKzlWahbluvNkmFhP8NH0eXRhkZSCekvx2Qa4D31QxASiscWuqLrhoCkcDhMKhQBGBWVra2sIIfZMlU8yMRZCEA6HR6lXnU5nFIGXTCbH+0tNcWpMyfNThnv37vFf/9f/NZVKhW9+85v8tb/214jFYiwvLxOPx091zKHUw7IsVlZWCAQCBINBUqnUiDALIfaQ593wej1jvU8p9ejNcHSuNli2JtJBr2Q2buAoaLTVoWamSYSwKU5HyGstqLV6GLJHOvpz5lIfEo4mMOIvULNSo4NenIHLWQefV7JdcnnvlqQyYcJ8EB7WRz+7IPjK9YE+ek0NcqEfwJTw8kVYmtGZKWsFwTufGmOJtTou6m344L4mSemo5GrW4fmFodHQ2Hf7P+SDa1mHaEgvztaLkkJTnNtEzlW6BTBf15P/2bjge28YGELxs3+tz2m/U0lF4a2vSqIhSb2t2KqJc42W6zuwXRNs18DnEaTDLq9fgb6t2K4ZbFf3/77FhCIbU4MdD3i/YEykYv4g7I5jiwcVV2YdPndJL5Zubxt7pv9aZ69YHOiYb225fHSXk3sydk2eHSmxDYNRxMYxvRF9G+5sw51thdeE5RnFc/PaBFxtC1YKDxanhuohW7epFFaoN3vkK/0zyT4eh3LAlBAKSHymoGvBWkHfkw76fEvGn06xmwDvllAopVBKEQwGCQaDZLPZEZFeX19HKYWUkkajMZJgnORnDo/rOE9QDuoUU/L8tCGbzfL3//7f59VXX8Xn8+G6Lh988MGJbxS9Xm80Ye71eqNp9eLi4h6SrJM0HiXMu+H1jXfyrHnz0b9P23JpWy5SQjhgEg8JeraeRj8y1ZxQhPFZfm/HhVzVJVft4PN0mEvmScV9LC1d4PKVK1TaAX5xW1J+TIT5IOiabf3f2YTiy88JYkFYL2iytDSjX+z1Ivz4pjF4yD1eaKOhnuzOJlyem9dGw1JDsF6UXJhxSIa1uW+tKPhoYzJTz5PAcWGzLNks60mnlHoHQAGGR8c+moYmdctzgnJHslaBx5nFDPo1HOYxB7yCTMRhOaWLNjYrOplnaPwr1BQf7WP8exyotgXVtoEA4iHFcwsuIb/WSEup2zBvbx6gYz4BXCmxDRPLtXHsHhIFKDyGB7wn3zW0bLizBXe2NJG+MKO4Pm9TKWyyev8eO5Ua+UqPZueJlCsfCCEg6BWE/ALHFRRqDIYHx/vegwYwp4U84Ga/H5EeDqBmZmbI5XI0m809EozT5DZP9c5PFqbk+SlDKBTiK1/5yujvQyPBUeRZKbWHMPf7fQKBAJFIhJmZGZRS7OzssLW1RTQaJR6PH7t0xecdP3k+yeFcF+oDY4jPFKQi+mPd6kFzIOtQHK07O/F5uuOjtL0+3M/Z3M/Z9LqfcePmXWIRP6HkFUxxCVsdL1/0vCCBZxYVV+Y0gdupQl8JLswKHFeXnWyVx183fVa4CrbKkmIdXlhyWUgJZmKaHG2W4M6OmGje7Glh2YCtS3hMA3w+gTsgcK6rjXvyCYns242OBWslQaQFF9KCa3P6A2H1Bbe25bm2Qh4XCuj2BW1L4PNAp6+otmEurri+LEhF4MN76tSNha1rr0F8BvnJjxBrH4PVhexFrOfepHvtC6df+ihFyKxQXr/BH39Spt7oIg0dmzhOTOKS3v07D2UZhhTU2oqbm+LEMXbjyPR/5JjHILpDIu26LrVajVqtRrfbJZ1Ok0wm6Xa7NJtNtre3cRyHcDhMLBYjHA6PzP9HHX+KJwNT8vwbgOHF+jCUUqOLtdlsYts2wWCQWCxGIBAYEe/hhPny5ct0u12q1Sqrq6v4fD7i8TjRaPTQC9vvH1/ahj5vTj0869mKXnO3rMPEUdoIM37ZxoOounGibyturPeQokcq+gHzmU+JhqOYsetUrOy5xN4dhGsLcG1O4fEI8lX4aN3YE822NWh/W0y6XF+EVldwc0vsY347fxgSnp1zWUxrmcB2Bd69Lek7wyxmhzefE9iOy1rJZHMMRsNxwGvC1azLfZ+i09cLgL6tcBxNEoSAxQRE5xTbNXFuNdRHwWvCQlIR8Qm6fZfNyoP4w5APLqRdrs9Lml3FStGk0Tn8eJOGx4CZmI7E6/UVG2XBnRwM7xy5mkAKyERc3npZE+udssuv7nLyWMfMEu43/g8AOLaNHGhpT3OPCphtIuoOzcoGW+s9NgsWXQuSEUhGn5wdq6MQC0p8HkHP0rtYZ5EdSTF+ki+POBWlFJ1Oh2q1Sr1ex+v1Eo/HWVxcxDAMlFL4fD78fj+pVGokl8zlcmxsbIyIdCQSeeR5O5xoT/HkYEqefwOwe/I8vICHhNl13VFCxn6E+WFJRigUIhQK4TjOyKSQy+WIRCLE4/F98yf9Pt94J8/ueIiulnVYSAmxgMlMFDqWoNJiLNrbSZgQd8NVUKgpCrUuHrPLbKLETNJHJJ6l77tOw45O7ofvwuVZeGbexe/T2+yfbu6vFx7CsnXs3L28JkmXs4rXrigKNcmtbY5hfhsfBHBlVnFxxsUwBLkq/Gr1Ue21zmLW+cBhv2Qh4XAlK2j3XO7lzYF05vwggStZl/mkQqCotmz6jnpEX6uU/lOs29hNm2xEcjFt0LYUWxVBq7fv4Sd33hIW4op4SCdFFBsum+VHC5RaPWj1FOAQDQiembXxmpr43y8Y51bGIoVOUpmNgxCK7TK8f1+gDojwcxXk6pLcQJOeicC3Pq+J92bJ5dd3OfG5y2MmIu2GKW1S5hqd6h1qjQ43d7qPJHwIMZmdn3Hd8qSASECnnwgB1aYY23U2mSzq/Rci/X5/NGW2bZtYLMbFixfx+/0Pff8DaQfo5I5kMkk6ncayLBqNBsVikc3NTUKh0EjecdzErCnOF9N35TcAruvy85//nJ/97GdcvXqVN954g1AoRDKZHLUWDUmyaZrH0lkZhkEikSCRSNDtdqnVamxubo6C3IdxdQA+nxcpx7dP5jLe7SnXhb6jEG4PA5hL+FBK0uhqw9BpS1gUh5rjT439fvO+DesFh/VCm6BvhaWZTeJRH+HEJWpcwXJPrpU8DBdm4NkFl6BfUmoobu6cbjLY6sGNTW19T4YVr17WU971gmAlz8SKNoZmS68pyNcUH28cv2Si2YWb2wZsQyIkuZB2eHFJUGvp3OBJEtLlNCynbEwD6i2bzZLCdgbX1RGXV6c3rLjXkXrLSQOvR1LvKDYrky01yUYhHVUIBKWm4vbOo0T/INQ7inpHJ9dEA/D8gsJjCsrNvca3cSIe1IQ56FPka/DphqDvnOye47iwU5Ps1LShbSYK3/kCGEKxXoSP7p1NG/0IlCLlz6Oan9Fs1Pk436VQcw+UNBw1KX1cCHghEdKvWbML9/NwaYaxLlDFBCbPYtcLqpSi0WhQq9VoNpuEQiHS6TSRSOTI5+t+GmmPx0MikSCZTGLbNo1Gg0qlwtbW1ohIh0KhUyVpTTEZTMnzUwrLsvjpT3/KH/3RH/H9738fwzB48803ee2111haWtoTKWcYxomMCQ/D7/fj9/uZmZkZ3TDu3LlDKBQaaaNnEn4ct0u796RuLekxsd3vY9v6aRz2eomlfdiOvnGflBRNavJ81CvY7g3aDLGIh3/N0sxNIuEQvsRzlPsLuEfE3h2ExRRcX3IJBSSVpuJu3hyrBKA8mCxJAdmY4qvX9WTs7o5gs3T2KdlCEq7OOQS9urzk5vbhE/LjoNKCSkub3DIRlxcWXXweKDbg7pgaDWfjOkPa7xU02zb5qotl7/diHP/D1uq6tLouQuhJ+rWsiSEFlbZiuzKeUpNkSL+PHkNQabncL5ytTEeXIUGt7SKFjpF75YKBIaDYENwvyDOdd9CrX+tECKptxf2C1jWPA7YLW1XJVnUg/4i6/Edf1LKu1Zzio/t6AXwaRDwN/P2bNOs73F/psV2yj/U6C/HoxP9xwWPo9zPk0wvmXIU9C4uxE90x/u6GhFTUS8Dno9frUa1WqdVqo0HSUQVkh5/no0TaNE3i8TiJRGLUtTDUTkcikfH8UlOcGUJNhTRPFWzb5u/9vb/Hv/23/5ZoNMp3vvMdrly5wrVr15iZmSEYDGIYxpkJ81Ho9/tUq1Wq1Sq2bVOv1/npuz9nc2ubRtum2nLPVHyxkIRKc3xjm6BPYgoby3r0mFIKvF4/Qpp0LE2YjvNwigcH06cxG3KeWxB8un6yY5oSMnHJXMpHJJZEhV6gaiWOZPezCXhh2SUalFRbLhtl81xNXFoX6zIb1xKDW5viRFnMMzF4Zl5nMVdbis2yQW3C2llTQjbmspAcbPVXJPfzJzMaJkJwNWsTCQhaXYda26VrHX6Ezf/X79Nr6TfHFwqN/htg4c/9p/je+uqh329IiAQk8ZCemZSagp0qJzpv3dSnCPgEzY5LsQkda7KPEENCPCRIhSUoyNUFayV5LBOZx4BsDDK7dMxnLbc5CbwmZKMus3FNju7n4OMVdeQiwCstEsYKrcoK1XqXjVzvxAvBbELg94tjJ1QcFxczsHaMdkYhIOLXpFkpnZRRPeDecmUWPtsY3zlGAvreUGqdbrUlgKBPkAibhENBXv38yzz77LP62IOykklWaO+WYVqWRb1ep91uc/Xq1WMb+aeYLKaT56cMhmFw/fp1/sJf+Au89NJLCCHY2NigVCqRy+UwTXMkq5jERTY0IdbrdRqNxkhTHQwG+d3v/g4ej4fNzU3e/tGfUq3VqdRtmr3H11y1G+KAyZ3rKrpdzbhM02R+IOuod/Qk7KCJqKsmszV6mvux7cJ22WW73MHv3WQhlSMZ9xFJLNIynqXjBEdfm4nBi8susbCk0VGsFw3Ka5Mp/zgKlq1bBlcG+uhLWcWrVxTFuuTW1v5GrEQInlt0iIcEjY5ioyzP3EB3Etjugyg2vwfmBkbDvq1YLxsHGg3Dfrg26xAPQc9yqLYcCrXzuzAcF6otl2rLwjQE0YDgxSUTx4VCQ5ed7Ie9xj9FoeHSLJ7baeO4w8p7B4+h3/8vXTZwFWxXBeulvZ/bYdHMbFznMW9VDtcxTxKWDetlyXpZy5WyUZf/5A2B4yjubcMna2q0CBC4pHxb2LVbNJpNfrXTpdw8/b3TkDyWbLqAVw8WPIb2N9zPP9pI/jAmMnk+hZnba0A8bBIOenj++nN8+fUv4bouXq8X0zRHJWJKKWzbPnZKxkkxlIVUq1Xa7TZCCGKx2ER+1hSnw3Ty/BsC13VpNpsUCgVqtdootD0ejx9Lh3UYhibERqNBvV7Hdd1Rleju0HfHcUYXfLfbxTRN3nvvF/z6o09odvqU6/axjXqLSSiPcfIc8Eq80qFnHd/No2+YXvqONhk+LOuIBMAQsFka7yV0fRE+WRvPsaIBWMp6iUaCLF+8ytXLF+jaJuslSakhntjc10RYcSGtBhIMwf0cXJ13SYb1pHOjJCk1n6zzD/thIeGQigjaPcW9vEGrC9fmXNIRhe24VFsOrY57qvM+6+T5IHhNQSwkiQRMen1Frq6rn7XxT2A7imLDpdZ5cmQAMGgbDQniIUnfhkbXwOcB01DkarBTFedauHIS+D0wG3OYiUK5XObWrduUinl2Sl1yZedMu3ZDzKcEpjneSbsQWpe//tDk2dwly+j3oVDn2B4D0Kbkm2OcPMdCkIy4x9pF08ZFSSxkMjOT4Ztf/xqJRALXdYnFYsRisT3mv16vN3oW9nq9kSZ5v5SMk2KYdlWv13EcZ5TMkU6np8bBJwzTd+M3BFLKkTvXtm1KpRKlUomtrS0MwxhlNz/sAD4IQ8I8nDArpUZ1oaFQaN/tKsMwiMfjxONxer0etVqN1157lS984TUajQb/4e0fsbOdo9qyqbfdUxv1TgN1ijpAy7KwLAspJemwj0x0r6zDdeFJv5/VO/DJfQspLLrtD7hz8xMi0SjB9Au4MvtE5oZ6TZiNKcJ+RgkTr10DUwpW8oKd2pNF4oYYGg2NHLy85PLqJR2Jp1zFVtmiO2F5w2lh2YpCzaFQc5iNm1yaMQevr2C96FDrPKnnDZW2NhqGAxKEou9oE2A6ouhYxokkQOeJvtVh7e4tPiys0Wp16DuCG/fHGzEyibQNAaMxsdbTQyyg/15pwM5p4x3HfJ7H8a/7PZCMeAiH/Hzpi6/xwvPPY1nWyMsTiUT2vT/6fD58Pt8oJaNer1OpVNje3iYUCo0GS8clu8Nkq1qtRqfTQUpJIpEgnU4TDodP8dtPcR54wh/9U5wGpmmSzWbJZrO0Wi0KhQLVapVKpYLf7x+tpvfLkmy32yPCDFrfdRhhPgg+n4+ZmRkymQzNZhO/389//B99F5/Px2c3b/Luu+9Rb7Yp1+1ziaU6S0mK67r7yjq6fcYyIToPuAp6fZfVrS4eo0s6WiIZ8xJPziHjz2PxeI0opoTLMy6ZuF6UbJbhXkGOXt/7Rb0NPJ90+dIVXWKxWjhf/epRWE65zCcUUkKxoVgva2NePKiYiXrxmtDuORTr9olLHyYJrYM2ME1JteWws93HsiHsE6QigvmkQbvnkqsquudYr34QTAnxsCQWkHT6sFkW1Ld3f4WWpMzHHZ6ZFbR6itWi8dg/K0LZmL01qju3aDTb5Cs9Wj09rfXK8S9QhBj/zswwV3wu/kCWsVo4WpZxGCaVybzfKZkSYiGDSNDk8qWLfO2rb+LxeEbmv1gsdiLzn9frJZ1O74mbq9Vq7OzsEAwGRxPph4m0fqboKfNQ/hgKhVheXiaZTE7lGU8BpuT5Nxy7c5srlcpIG53P50eyi/fff58/+ZM/4atf/SoXL14kEomwsLAwFkOEEGK0Erdtm1qtxrPPPMOVy5dxXZef/Om73L59h0bbptJ0JrbNOq5JpW3bo7QOv8+H9Hq4OifIVxX1x1zycBSG72Tfge2Kw3alQ2DrHtnEOtGwn/jMZfqBq7icjyFFAhcyirmEDvbeqcD7K8aBZs2+A6sFyWoBgj5YSimeW1DUWpLV4snzdceBuTgspXQkXrnpci8vBtKkB9dNpaVlP4aEZEiykPJhCGi0HUrNx8NGA15JKqKj7Jpdl62qovPQC9/sKZo9hRAuEb9gMSXxmIJGx2WnerTpbZwQAmIBSSKsa9O3K3AvLw68rusdqHekrtoOwnLa4bpP0OzASlGeOYXluFBK4XeLNHKf0KhXyVe61Ntqz0RYx6qNnzxLwdjeo2FaRniwcVmonUyWcRgmkQqy+5gCCPkF8bCHRCzKW197g8XFRfr9/mhHdhjpehZ4vV5SqRSpVIp+v7+HSP/rf/2vmZ+f5zvf+Q7BYJBqtYplWZimOSLfgUDg7L/4FOeGKXn+LYFhGKOLtNFo8P3vf58f/OAHvPfee3g8Ht544w2effZZlpeXJ7aVb5omqVRqVFNarVb52lff4Btf/xr5fJ4/efvHlMoVKk0bxtzcp5Q6MOT+tLD6ffxSgtNjMeUDYdDsaiI91nzXcWGft7Vjwf1cH5HrE93+kGzyJpFIiMjMdTpyASbQZrichvmEg2kIclXFh2vGiV+vdg9ubun86HgIrs66BLyCXE2wWWaiWtdUBC6mHQJeQa3tsl4StK2jazGHxrxCQ0tT0mHJhawP11HUOw611mS3MUwD0lGTgM+ga7nkG4rmMUbJSg2zmJ1BhJzg8oxESqi1FbmqmlilecgnSIYNndddV3y8IU6026OASltQaQuEgGRIcS3r4PfqXYuVgqQ7gUWXRzXpV25QK22x2uhRrB0+GJhI5fUZJ7piUGISH3iNKw0o1mEpPT7iDPqqGffvb8hBKk7cJBzw8vJLL/DFL34B27ZHu69HNeeeBR6Ph2QySTKZxLIsLl++zB/+4R/yT/7JP+HatWu89dZbfO973+OZZ56ZaCrWFJPD1DD4W4Rqtco//If/kH//7/894XCY7373u7zxxhvMzs7SbrdHuuZ4PL7HCDhJuK67R+/l8Xh4/4Nf8cEHH9DpWtTbFv19M29PBnMQ09XpjG88LKXE7/fRbj84psc0MT0+HCUoNxSlhjixtnuchsHdeGEZ7heOXhgZElIRSSruJRbP4E2+QE8kzvSz5xKwPJjQFhqKrYox9rIRKWAmqlhMAWhTYa4+nqlWxA+XZ3QkXqvnUqgLGmOaXga9kIkoYiGB1XeoNF3avUc/NJu///v0mgcYBv/T/xTf1x41DEogFTUIBYxBaoVLrTOe9BtzECGXDBu4SlFpuhTGoDH2eyARMgj5JdWWbkrsjHkxqhM51Eh+UGlx5kIWqSxk5x6Vnbs0ml3yVetYJDPiB6lc1gqn/9n74eKslrWclOgOS0y8pjZJ56oPiqR08oqWaowLWo4Fd7aP/tqjoBeIgnRMMpvN8Dvf/iaRSASl1CiF6ryKRizLGmVC27Y9Sr/68MMP+ff//t/z3nvv8eKLL/KX//Jf5nd+53fO5ZymGB+mk+ffIti2zeLiIv/8n//zUczdEP1+n0KhQLlcZmNjA9M0R1tak7zZSClHJsPhzeZzr7zM5155mU6nw9tvv8PG5ibNjkWrY5/aAHP0XPA0B3UfOWbftukPZB3JkJdM1EvPhlxV0egc/wwmMY05LhwX8jWXfK2Lb2udmfg28YiPeGYZN/gstjje9mImChcyekJbaSpu7hinaik8LlwFOzVtKPQYgvnEA330WlGcOL/a74ErWR0tZ/UhV4fVokKN+ZPUtmC1JKAEEb/BTEySTQi6PYdS43iFGA8jETaIBg0QgnLTYSfnjN2ga7ta211s2HhNSIQE1xcMbFtRairKreN/gvfomC3YrIiBDGoyu2Cugnxdx/OZUhPpV5ZdpFAUG4LV4jELWZSLz96itnODRqNJvtqj0T6hCEOcTTN8EOQJ5BCmoSfM2qSrZRn7LW6HmudxYhxtgNEgzCVNopEAb37lizz33LP0er3RMCgcDp+LOdp13X0j5jKZDOFwGCklL730Ev/Vf/VfUS6X+eEPfziSAU7xdGE6eZ5iD4aRd6VSiWq1iuu6BAKBkfv4PIwMSilarRbVapVms4nX6+XevXv85E9/SqPRpN62jiyUeBhSQjxg0O6M1zUUCgZotQ9nhFJKvF4t62h0IF+D3iGTtOuLcGN9/E75Fy/oSuzTIuyH2aSXSDhINPssPXMZJfauvxMhuDTjEPYLam3FRvnxG7WCXq2PToYV1bbWTB+kjzYlXM66ZCJa01uoKyotMfb34igIoY2G2ajAY0K76/Cr//vfpnvI5Dn93bf2GP8qrbM1/p0WAa8gEYJIwKDXdyk01L6Lpv10zMXmwTrm88CwHTAb08vXXE2yXny0AMfrVukUP6VeyVOqWVSazqn1xbEAOI7L5pizsy/PSxodDowHHZaYxEP675Xm0RXZfo8uVhrnlNzn0YUm93ZO/n3ZhCQRNrn2zBW+9uZXkFKOGvpisdi5xbt1u10qlQqNRgPHcQgEAiP98zRi7jcT03d1ij14OPKuXC5TKpXY3t4ml8vtMVhMCkIIwuEw4XB41F54+fJllpaWAHj3Zz/js89u0u5aNNp9bOfop63rMqEh1tEH3Z3WEfSYXJ314riSUkNRbj4q6xjVfo+bRKizzd+bXbizpWPvEts/J5P4kGg0TmzueS4upIiHJM2ulkuUW09OBnPbgpvbj+qj83XBVlnXJi9nXObi+oyLDcVnW8MK68cT5afUXqNhKiwxDYEh934shBhIEGJay7yf8e+80bGUlgpUbEI+QSosWExKOpYiV3MxpSAeMvCYgnxN8fH6eOrCx4G+s7sARzATdfnSVYHtKjYKPQqbd6nk71Nr9ijU+ocugk+CSSwYDupIeViWsZo/vrFwIua+E3ytFJCICLIJg1Qyzre/+TVmZmZwHIdIJDI2899xMHw2Dauzh1GtmUyGUCg08Z8/xePFlDxPcSBM02RmZoaZmRna7TaFQoFKpUK1WsXn8xGPx4lGoxNdWZumSTKZJJFI0O12qdVqfPn11/nqm29SKpX4k7ffoVAo0uxYtHvOoTf2JyHRuN+36fc1uUmHfczEPPT6kKvtlXU8Ced6EFw1bHzr4jF2eLZVY+eOIJ6eR8au0xdPbjZptQUBj2Qx6TAfl6QjeprW6inu5ngkKeNJgONqiUGvr/9bSl1sYg82gVwXdiounvITwkB3odVTtHoKv0cxEzO4NKMbDY1BnF+h8eQQ54fR7cNaUbG1sUYtd4tWs0au6hxYMX1aTCKPeXTcwWurI9r0pPkwWcZxjjmJZIyjfv+QH2aTBrGwl9c+/wqvvvo5+v0+fr9/9Bw6L49Op9MZRcwNfUIXLlwgkUhMI+Z+izAlz1McC8FgkAsXLrC0tESlUqFYLO6JvIvFYgSDwYndwIQQBAIBAoEAMzMzNBoNTNPk9773Z/H5fHz00cf84pe/pNXuUm/1sMZgMjzeiZ3+W3tWD+ghpWQ55UOJB5rgiQxOJnDMvgOtVof1Evi27pBNrhIJBYhnL2MHrqLE8TNTJ4lUGJZTNgGfpFRXfLLx4LX2GLCQFFya0bnduZoamxlwXJBSn6c7uLz6zoBIDyfPUYntOx0hmhS0odAgFpL0+op8TdEaGCENqTW2Ly9JhNCNdGslee7ymP2glMLrlKjnPqVRrVCs9ai1XGZiOtd47JiQwWFYYhIJ6h9RacLtyhmPCWM/14MIuceAdFySjhosLS7wzW98lWBQR38MnznnZf7r9/uj5j/LsvB4PMzMzJBOp49dPDbFbxam5HmKE0FKOdJydbtdisUi5XKZer2Ox+MZOZpPEjR/mnMYBtpblkWtVuP5569z/fpz9Pt93n7nR6yurtHqWrQ6/XNtMjwNXNels0vWYUgf1+YFhbpO63iSCjX2g1L6odqx4P5OHyH6RLd/xUzyBpFwhMjs83SNubFHBR6FiP+B/rreVtzNm1T20XT2HbhfkNwf5EcvpxVLKaWTBmqPN3YwG4V0VL++76IJswKkq1/3oWKp1oblsMFiStDpuezU3Meid96tY1ZKp3vc3nIe4VuOC6UmlJouHgOSIfjCZXAc2Klp6cR5w1At+uWbVAqbVBs9SnV7T7ycYDLyinEfV09pJQGvwlWCtRPIMo6COKB85EzHZG8mcywEs0mTWDTIW1/9MlevXt1j/jtpYddpMfT/1Go1ms0mQgii0ShLS0vnNume4snFlDxPcWr4/X4WFxeZn5+nXq9TLBYplUoUi8VRxenQYTwpeL1eMpkM6XSadrtNtVrlW9/8Bl6vl9XVVX78kz+lVmvQaPcmMnkd9yH7fRufx4NoF5kPhZmNBenasFMRE02qOBMeehGU0mSu1u5hyh7JnZ+QjHmJJWbwJp+nL+MTOxW/CZezDvGgzl5eL0oKjeOb0No9+GxT66MTIV3iEvIrqi1tHjwPiUEypCP3PKag2nJZyenilSFx3g+9vuBeHoRQxIKChYSJx4RGV5GrORNfgO3OY660XFby7rEXrX1HJ5nk6i4+ExJheP2KoNdXbFUl+frkzluoPqK9Qnn7Ls1Wh3zl4Hi5caRC7Htczk5IPSbMxAWJsJbB5Gvg8+rM83FiEkNyIcAw4ELWIB42ef76M7zxldcBnZccjUbP1fzX6/VGU2bbtvH5fMzPz5NOpyc6FJri6cKUPE9xZuyOm+v3+6Np9ObmJoZhnEu+phBiT5tirVZDCMHc3ByGYfDee7/go48/QiDodDs4T/Q4WkddqXYVqOI3PVxKJ3CFh3obckekdZw7lEIcsIywXchXHfLVDr6tVWYSW8TCPhIzF3FD13DE2bc8TaknzOkw9B3Beknw6YY8845DpaVNe1IIZmKKi5kHWt1ya8zTQh/MxRVBr27826xAu3cCg+fgy5TSuu5qS2FIbQy7nNG3+VrHpVAf3+fe7xEkQpKQX9LouGxVzj7t7tmwU4WdqkPAC+mwy6WMQbun2KjIE8cN7gelXLz9HNWdGzTqdQrVHo1jZl9PrMzkFG+LEHqhMZOQGBIqTcWtMWQlH/Uzx/W5lxKSIUEyKkkmonz3O98mnU5j2/bImO73+89lyuw4zihirtPpjJ5p6XT63DoPpni6MCXPU4wVHo+Hubk55ubmaDabFAoFqtUq5XKZQCAw8WYn0G2Kw3anTqdDqVTi1Vc/z+c//zl2dnZ47733KJVKdDpdepbFk5fWKBDsSquw+6hGHgEkfCHicxFsZWhZR/38Y9QehTgWx+v1YT3fZz3fJ7z1MdnkbSLhILHZZ+l5lkEc/zMhgeWMIht1UQg2y4Kf7ciJNAu6Cnaqgp2qGOijFc/OKWwHdmrq1FXPXhMWEoqwX5sBC3VY6YyP3DouFBua7HtNSIYFz8x5sB2XcktRbZ38Zz2sYy7WFRvlyTQjdizYKANo6c1iwuGZWUmjo1gtyRPru02nTqd4g2o5R7neo9o4WbycGMeI+IDjnuQaDvl1RFvQp5NN1ooMWhf3XoSTChc66+0y5IOZhEEk5OWFF57j5RdfxOPx4PV6SSaTxGKxcyOrQ/NfvV7HdV2CwSBLS0skk8lpxNwUh2L66ZhiYhjGzTmOQ7lcplgssrOzMzIZJhKJiUTeKaXo9XrU63Xq9fooxsjj8RAMBpmdncXn83Hjxg1+/vOf0263abXb2Cfp/Z0kDnk6ub0W9FoYSObDUWbjQboWbFeheYISlnHjpD+52YXmVg8peiS2f0Y6/iui8STBzAt0RerAadNCEubjDoYh2Kko3l85ebX3WaD10YL7BTHSRy+nFC1LF+EcdS5SwHxcZ+s6ribMGyU18QWQNZrounqiGxFk5z30+g6FunsoEX1Yx1xsuOT30TFPEs2uXqQIHCIBuJZV+Dw6yu9+8eBmQKF60LhLeWeFerN75ni5Se1XHfVaegzIxAWJiHjwuSnDYVfeJN4fecoDewxIxSSJsMGli8t8/a2v4vV6EUIQiUQQQtBqtcjlcjSbTaLRKJFIZCIkehgxV61W6fV6o2FLJpMZGRKnmOIoTMnzFBOHYRhkMhkymQydTmcUeVer1fD5fCPz31lW+rsJc6PRwLZtwuEw2Wz2kW23fr9PrVbj2Wef5dq1aziOw49//GPu3btHt9uj0+3iPkaXnoJjxG24uK0qWtbh5XI6his81NqCXJVzNYudZRK1O/bOu71FeitPPOIjkVlARp+jL0JkIrra2+fRJsqP141TT3vHiUf10S4hP9RakG8odq/FZqKKdASkENpEt/34Ito6FqyXgJJL2C/IRA0Wk4KW5ZLfZTQM+QTJiIHXEFSaJ9MxTwoKqHeg3lFIoYgF4aVFLQEoNXRih+04mN1NKjs3aTSaFKq9J+LzchAE+8s2hNCym5mExDC0FOf2hGUZR+Ekum8hdPPfTNwkHg3z9bfe5MKFZSzLGqVlPGz+G97Dh90C4XCYaDR6Zu+M67q0221qtdqeiLm5uTkSicRUljHFiTFtGJziscB1XarVKsVikUajMSpGicfjJ4q82z1h7vf7J7rZKqVGN9RhWsj29jbvvPMO1WqNdqeNZR0+pgqHgjRbY24tDPhRrQrKPsC5dAiEL4TyRbBdg+IwrWNwhb94AVby459OX0hrHfY4CXvQC9mkl2wmztLyBWpcoNJ+8s06UsC1OcVyWtF3FK6rEEI3/pWa4kxTz/J/97fotXRciDcYxmo/iA6Z+U/+dxhvfO3UxxYCYkHIxgReU5NR24F7Ofexpo0cF4ZQRM0am6s3qdebrG7XqLXGS/YXkoNFx5gxE4V8xaU20HMHfTotI+jXC52dCqeSI12bg3u58Z5rMqyrvIuHmDj9XpiJG0RDHl564Tqvv/5FHMfB6/WOmv+OI9t7+N4eiUSIRCInItLDiLlarUa/38fj8YzSoqYRc1OcBdPJ8xSPBVLKkS7ZsiwKhQLlcpn19fWRwzoej+P1eh/53l6vR6PRGGVuhsNhMpnMiacTu02G2WyWer2OlJL/7D/7zzBNk/ff/4Bf//pDOp0u7U4HxzkfWYdCHWPyfMD3DmQdJpK5SIzZRICOpSUOkyr/mMTqu23Byo6F6+S5cbfATPIjIpEooczzdOTsuZiIToKQD67NOSRC0LUcNksOVt8lGjSJBiHk01rdJ8roOYBpQDosSIS1capQsbAdl1DA5MqMF8dVlFp66v/Ewe7QLN6hmNug3urS6/WRQlBuPFmfj0Mh9GJlLiVIRnQ0ZX4ky3iyIA8wNxpSN/+loiaz2Qzf/uZbxONxbNseNf+dlKz6fL5RktKQSOfz+T0T6f3MfMOIuWq1SqvVGkXMpdPpacTcFGPDlDxP8djh9XpZWFhgbm6ORqMxSusolUoEg0Hi8TiFQoF/9+/+HV6vl7feeotQKEQqlSIcDo/FfGgYBolEgkQiMYoq+tznXuHVVz9Ps9nk7bffYWt7i26nS7fXm6zJcCyHdlGtClAhYHq5nImB8JKN6UrwSRjrJgFdU62otLqYRpf0dolkzEs8OYsZe56eiD62c/OacDXrMhNTOK5LtWmzmnP3vH2Vpk2laeMxBemIyXLGoNWFnWPoo0+EE3JFKbTuOh0RSOHSaPfYKe3dOqi3+tRbfTymJBwwyS55BmUnUHucsYmuTb+xRm7zLs1mh3K9M3ot/R7wmU8PcQ779S7LQkpSbT9+WcaReMgwGPbDTMIkGvbzlS9/geevX6fX6401qlQIgd/vx+/3k8lk6Ha7NBqNUUnXv/23/5a33nqLL3/5y7RarZHPxe/3TyPmppgYpuR5iicGu8tPbNvm448/5n/9X/9XfvSjH7G2tsYrr7zCf/Ff/Bdcu3ZtomkdPp+PbDbLzMwMzWYTn8/Hd7/7Hfx+P7du3eLdd9+l2WzSak+GQegZ8RgJgG2hGgXMxCx+o89y2ofjarNVvXP8DOTDMLFB8K7j2g7sVBx2Kh38myvMJjeJhn3EZy5hB67iMPm2MQlcyrrMJ1ykgFrbZr3gHGn469uKQq0PtT4Br2QpZeIxJdUW5Ot79dEH47AX+XhvQCQAmajAbypaHYtStX+Mc3epNCwqDQu/1yAdMVlMmbR7Om3koFzkcUIpBd0ChY2bNBpVyvUeza7zyGd3QmV9Y4XP1AsXv0c3FnYtbebsWE8+6ZcChIT5lCQeNrl65RJvfe1NDMNASkkkEmFpaWliZHV302wmkxklN/2jf/SP6Ha7fPGLX+Q73/kO3/72t0kkEhM5hymmgKnmeYonEP/L//K/8D//z/8zn376KV/+8pf51re+xYsvvojjOLiue26Rd7sxNBnWajVs20YIwU9+8hNu3bpFt9ej0xmfyTDg9yG6dZQ1XpeTmZil1Xygk/X5gwjDQ68vKDU5NQlaSmmz1iS0sctpuF84+N8FmhBmkz4ikTCRmefoGov6CT9GLCThQtrGa0KjbVPvuNjO2W6dAggHJLGQByEGjZLNgw2Y5f/ub9NrNYB9NM9/7i9gfOWr+37fMF0jEoBur0+jbZ353AGCPoNw0ItpaEnKdnV8TXYj9JvUcrcoF3eoNbrU2oc3hga84DEkhfr4iehiEtZOqXk2JEQD+rPqOLBdUSON8+U5Qb46/uvnmTm4OybN83CnIpuQxKIRvv2tbzA3NzfSIg+9Kuchp1JK0e12qVQqNBoNXNfF5/Oxs7PDu+++yx/90R9hWRa/+7u/y1/9q3+VbDY78XOa4rcP08nzFE8c1tbW+M//8/+c73znO3umB8PIu1KptCfybqinm6SWzePxkE6nSaVSo2zQr3zlK3z9618nl8vxzjvvUCqX6bQ79KyzjeLUIaUjZ8auloNeVxsdpWEwHw+ghEGzA+WWOOYkdPI46lk8Sl/Y7GHIHsntn5KO+4jFUvhSL9AhceoHejIMV7I2Yb+g1e1Tbrj0+uObNSig0XFpdHpICdGgwfUFj27cqyrqZ9jY8BiQiugUENuxabT6bLfG+6a2ew7tXgchIOg3uTbrBQTVtiJXPUOsm2vRrdwnv7VCs9Wl3OieyIz6JI2Dwj5dN20IKDcUn+Qf/RrByXKej40x3EKCPsjGdSbz5195iS984fOj1r14PH6uAwzbtkcDjF6vh2mapNNp0uk0gUCAF198kd/5nd/hb/2tv8X777/PD37wA4rF4pQ8TzERTCfPUzyV6HQ6I220bdt7nNznFW7vuu4oL7Tb7eLxePjwww/54IMP6HQ6tNqnMxn6vV4Mq4lrjVcWYsaztNvtQ/XapseH6fHhqOPLOhaTUG7p7edxYzkD9/chHEfBZ2otZizsI55ZQoWfxeboDNfdxr9e36HatOlY53uL9JiCeMgk6Ddod2F7oI8+avLseeOrJEKQigokLo22Rbt7jpmFgCEFIb9JODgwGjYFxcbRr59SLm57m/zGLZqNJqV6h05PnViCEfAKDCkoTcAweNzJ825ZRrurc7wPI/9X5nSN9rgXrM/Mw92dk3+fOVh4paImC/OzfPMbXyMSieC67khWd15JFa7r0mq1qNVqNJtNlFJEIhHS6TTxeHxq/pvisWE6eZ7iqUQgEGBpaYmFhQVqtRrFYpF8Pk+hUCAcDo8yRCd5c91dS97r9ajVarz44ou89NJLdLtd3nnnHdbX1+l0u3S7JzAZCjFBEfHhsPs97L5uzEgGA6QiXqw+lJriQFnH5HI8To+eDesFm/WCTXjrM7Kpe7rNcOYaPc9FlHhw6xsa/zIxF9dV+xr/zhP76aO9puSnBlg8qukVAmaigpl5tI65crSOeVJwXEW93afeHhgN/SbZxYHRsM6j03SrSnnrJtVKkUqjS6Ntn+ncder2+X8ad8sybAdyFUX1mFXi4gkQao/kTwmTWCTAm2+8zrPPPkO32x3dT4dlJucBy7JGzX/9fh+v10s2myWTyeybwDTFFOeNKXme4qmGlHKUkmFZFsVikVKpxMbGBqZpEovFDoy8Gyd8Ph8zMzNkMhmazSa1Wo1vfetb+P1+VlZW+MlPfkK90aDd7tDvHy5uVBOjoyd7QlvdDtB5IOvAoNGFyhMk6zgOmj1obllIYRHf/gUz8Y+IRGPMX3iOqxcyGFJQa9lsHMP4d97oWC6d8mDVohTGYC1oGuDIBwa5Tq/HTumYbO2c0Lddqk2LalMbDTMRk6WUSana4u7dexRz6zSaPSrN3tOR/rLPJRny6SmzIaDcVHy6enIePDHZxjHg88BMTBILe3ju2au8+caXkVKOzH+Li4vnllThui6NRoNqtUq73UYIQSwWI51OT6xtcIopTospeZ7iNwZer5f5+XlmZ2dpNpuj7OjdkXfjirY7CMO62UgkMtLoXbhwgYWFBaSUvPvuu9y4cYNut0e709nfZKjUBEe5Jx9zuY5DdyARCHp8RFM+7IGso9HWso4nLHZ5X7hK607LjS4eo0urUWLlpod0epbU/BUMz5NdzTt614QuBdk9sXTHYACcJDpdi/zOBptrKzSbDVwl2SxNpvZvYkLEwXG9A1lGwKNbJle2Fb0zqGOEOF/yLAUkwoJM3CCdSvCtb3yNbDaLZVmjfP1AIHBuU+ZutzuaMg8j5hYXF0mlUucmwZtiipNi+smc4jcOUkqi0SjRaBTbtimVSpRKJba2tjAMg0gkQiKRmLhuzzRNUqkUyWRy9ID40pe+xJtvvkmpVOLtt9+mUCjQ6XTpWdZeWcckHlzDgfYZHtS7ZR3pYIBMRE/0n4aYrd3oO9Dr9dkptckV6sQ21giHgswuXCCcXEIaT0YurJSQjpqEfJKcIeihUC44rpaYgF6wJaJe4kk/9ZZN+yxMboxQStHv1FlfvUOtVqXeaNPt9fF6JIjJPHomxffkoMhkOa3TMnZOIMs4CpM654cPG/JBNmEQDft47dXP8ernX8GyLPx+P/F4nEgkcm7mP8dx9vhFDMMgHo+TyWQIhULncg5TTHEWTMnzFL/RME2TbDZLNpul1WpRLBapVCpUq1X8fv8o8m6SE47d2aTZbJZGo4FhGHzve9/D5/Px0Ucf8Ytf/IJ2pzMw9MGkZBvjlFf2BrIOfzBIMmySCAuaHai2xNgiy86DkvcdRbHaoVjtsFOokIjeJhwJM790FW84gxhz7N1xkAgbRIMGoGi2LXaaFo7j7jtVVUpRbfSQzS7hoI9kzEfPcqg2Lfpjz447GrbVobC9SiG/TbPdodHqjYg+TF7eO87jB326ttwQoFzFjbUzpIg8BngMSEcliajBhaVFvvmNr+H3+1FKEQqFWFhYwOebfD46aFnGcIgwjJgLhUIsLy+TTCbPjbhPMcU4MCXPU/zWYFjFvbi4SKVSoVQqjVqqhpF3gUBg4ibDoWN9aIq5fv06169fp9/v86Mf/YiVlRWcnsTqtcF98sWgylX07D5928HnNVlKe3FcqLSg2XnsXqiDsQ8z71ou28UGstRge6dENOInkUwzu3gVwzfZNsNIwCAekpiGoNmxKFa7OIeFGj+EXt+hV9PxgwGfSSrqwzAkna5NtWUxphjyfeE6fWrlbbbWV2m1O9QbbfoHnPuk/XFnPbbX1IQ54IVWR3F7zaFjwStXjKeCOItBJrPXK/ncMxG+/rU3uHz50sj8N5SvnZcsY3dGvmVZj0TMTTHF04gpeZ7itw6GYYxu3t1udxR5V6/X8Xq9I93fpI0yXq93ZDJstVpUq1XeeustvvGNb3Dv3j3e+/nPaDUbWM0abrfNeCjHZB+YPcumZ9lIIBH0koqY9PpQaU6mROUsOOyVcBU0OxbNjkW+1GB7a5tQ0E92bon4zDLSHI/kx+eRJCMGfq+k2+tTa3awxuCe6/RsOj0bKQQBv8lcMoBSgmZHJ2GMA0opuo0yG2t3qTfq1BptescOZH6y6u2l0GkTwxKTrYJNsf7QF00oFmNcV2TAOygxCZlcuXyJN994Ha/Xi2maRKNRlpaWzjXGc3hPa7VaKKWIRqMsLi4Si8Wm5r8pnnpMyfMUv9UYmlPm5+ep1+ujtI5isUgoFBpNaSZ9sxdCjCpuAa5cucLFixcxTZNf/uIXfPzRr7E6LaxmDWWfLlBZTciIqJR6ZIrlAu2uBViYpmQ27gUkjS5UWxzaEndeOK6xzHYU5XqHcr1DrlgjHr1LOBRibukKwdgsQp5su3moYw76JI7j0mh3qdQmo1N2laLV6dPq9DENSdDvYTETxHZcGm2b1ilyoO1ei+31e5RKBRqtDu1O74SGt8kt4E5Kb4PeXSUmdYcPN9WBE/onsRLBkDqTORM3yM5k+J1vvUUikaDf72MYBrZt77mvTBrD3bRhE6vP52N2dpZ0Oj2NmJviNwpT8jzFFOzNbO73+yMSvbm5OZrcxOPxsekDhxWz9Xqder0+Cv9fWloabWV2u11qtRqff/VVvvilL1Gv13nnT/4DO9vbWO06drsJ6vGz0KN2f23bpWnrZAW/12Q57cF2BdUmNLtPsKxjH1i2S77colBpsVMoE4sEiMUSzC9fw/DHD90K36Njblnkmta5tuHZjku91aPe6uH1GIQCXhKREFZf66OtQ/TRjtOnnFtnZ2udVrtDo9UZS8X32CGOviQ8xgNZRruruLPu0O6dz+mNC5EAzCYNYmE/X/7SF3jppRfo9XoEAoGRj0NKiW3b1Ot1arUaOzs7hEIhYrHYWFOHHMeh2WzuiZiLx+Ok0+lzGTxMMcXjwJQ8TzHFQ/B4PMzNze0xGVarVcrlMoFA4EzO9F6vNyLMtm0TiUSYm5sjFAo9QryGJsOZmRkajQYej4fv/kd/Br/fz82bN/nZT/+UdqtJr1FBWceI/VLqsZeZjGQdAhJhL+moqdvzmtB7wmQdh0EpaHdt2t2GlnXs5IiE/KRn5kjPXUF69AJI65gNTINT6Zj3/dlC0BMCxzQwThm4bfUdrL42fAZ8JsmoD9OQtHsO1WYP19Vb7+16gY3VezRbTWr1NtaYAr4ntWg46PP9iCyjaFOsTeYcJgWvCTNxSTJicvnSBb7x9a+OpGVD89/D013TNEkmkySTSSzLol6vUyqV2N7ePnOZVLfbpVKpUK/XcV2XQCAwjZib4rcG00/4FFMcgGFRwDCzeZgZvb29TS6X25OJehj6/f5o+mNZFuFwmEwmc+ypzMMmw1qtxtWrV7l8+TJKKX7y4x9z5/Yt+p0mVqsOzmFb8eOnz6chQq6CdkfLOjymZG4g66h3oNZ+MmQdx4XjQq3Zo9bskSvp2LtMKsHS4iLB6AK1Zm8sOmY3FKDVadHvWxgdhdPvIw0Dv8eLCJ5eg71bH+33mQQNi5XVu2xsblFvtun0+uc6IT8TxN6djKB3kJYhodxw+XDTPbVxcqLR6wdADsx/2YRJMh7lW9/8KouLi/R6vZH5b7+F937wer17vB71ep1cLofjOEQiEaLR6JHH2j3JHkbMJZNJ0un0NGJuit8qCPUkCrmmmOIJRrvdplAoUKlUcBwHn89HPB7fE3k3JMqtVotOp0MoFCIajY4tS1UpRbvdHsU+eb1ednZ2+NHbf0KlXMZq1XC6rT3M1ogk6dkujj1efa3X56PvyrEQRL/XxON5IOtIRmAlP4aT3AdXsopKczLj7njYg+s6hIJBI4UiPQAAPblJREFULce5cJlgJHGmhAPXcSj98lfk332P1sYWRsBP+pWXmP36m/hSyTOdr93vkd9eI7ezTbPV0WSzPpkSE7/XwFHy0aruMSASEChXIsRAltFTrO2MR5bxyhWTGxvjf1w+tyS4s733/wV9MJswiIU9vPLSC7z++hexbRuPx/PIveYsGMrHarUa9bp2SA4lH+l0Giml3oFot6nVajQaDZRShMNhUqkUiURiGjE3xW8lpuR5iilOCdd1qVQqFItFms0mnU6HDz/8kHfeeYePPvqI3//93+fNN9+ceI707sKBXq+Hz+fj/fd/wa8++IBeu4XVqKJsCyOcoOeosZNnj8+HoyQ9a3yxelJCwOdFSIOuJShNQNYxSfIcDZpYloXtuDrxIuAjEgqSymSYX7yIx3e2NkOn38c4YxqM69rUSnk2N1ZpNtvUm03sge45EvJTa53OmHoUJkGehYCgVxDxC1xXsF6wKVTHd3yAV66a3Fgf/+Py+pLg9rauXE9HBOm4yfxslm9/661R0dNwl8vv908sYm64IK/Vavy1v/bXqNfrfO1rX+ONN95gbm4Or9c7mjJPumBqiimedEzJ8xRTnAHdbpe3336bf/Nv/g3vvPMOc3NzfOUrX+FrX/sa165dO5fIu4fPZ1h1K6Wk3W7zztt/wubGBrbdp9PtYffHSxg1eTZOEFN2fMTCAZqdPgGfB4Wg0dH50eOQdUySPMdCJr2eJs+7YRiScChIKBhgbn6RdHYBwzy/z4dSik6zyvrqPa29b7ToWY++BpMmz7ark1fOCp8HogEDKaDWViglaDRt8tWzH/thTIo8v3BBgjCIRgJ89Stf5LnnnqPb7RIMBkf+ivMy3bmuS7PZJJ/P8+677/Knf/qnvP/++8zPz/N7v/d7/N7v/R7Ly8vnci5TTPEkY0qep5jilLh9+zZ/8S/+RZLJJH/2z/5Zvve973H58uVR5N0wReM8I++GGD4EhzmrgUCA999/nw8//JBOu0273Robifb4fLjKoDsh8lxpPNhzD3iNgaxDmwybZyBgkyXPBr1e/xHyvBse0yAaDRMOhVi6cJlwLDWxz0ff6rC1fp9SIU+j1abT6eEecuuPhv1Um08meTYlhP0Sn0fQtWC7Ap3Bqc4nod4c/9QZ4JWrBjfWx3Msv0enZSSjesr8Z//s7yKEGCVVxGKxc4126/V6o0X3MGIulUqRTqexLIs//uM/5g//8A/58Y9/zF/8i3+Rv/N3/s65ndsUUzyJmJLnKaY4JSzLYm1tjStXruy7ldrv9ymVSpRKpZG5JhqNkkgkzq0Sd3getVqNarWKO3BLvfvuu3z22Wd0ux267fbo/58GHq8PJQw6vfGT52jYT7XxKImTEgJ+D4Y06FinS+uYKHkOmvSsRyfP+0EI8Pt8RMJB4okkSxcu4fWfvQHOtW1KhS22Ntdptds0m+1jnQ9MevJs0nfFiRY+Q1lGyCdxFRRq+j1/GHMJTZ4nkaRxVvIsBaSigtmkSToV59vf/Bqzs7NYlkUkEhklX5xX85/jODQaDarVKp1OZxTXmclkCAaD+y7khovxhYWFcznHKaZ4UjElz1NMcQ5oNpsUCoURgd2dx3pehpvdmsZ6vY7P56NQKPD2n/wJxVKRTruNZVknjs/weLwo6aEzgay5g8jzbnhNic/nAQT1NlSPmdZxXprnk8CQgmAwQDgUIJudY2ZuGdN7/IWW67q06iXWV1doNpvUGy2s/skXNRMnz46geQwTn8+jp8ymFNTaiu2KODQtYy4BtYZN6eF2wDHgtOQ57If5tEks7OULr73CF157deRNGKbonKfprtPpjKbMrusSDAZJpVKkUqmp+W+KKY6JKXmeYopzhOM4o8i7Vqs1isMbTqPPS9YxNBkOI6f8fj8ffvghv/zlL+i0O7TbrWMbCz0eL8rw0JlA//ZxyPNuBHwDWYdztKxjsuTZwLIOl20cBdOURMNhQqEgi0sXiaUySPmo8VQpRb/XYmN1hXK5RLPZptPrnSle7nGSZ1NCyC/xewS9PmyVH8gyjsJ8Eio1m3JjfOc7xEnIs8fQmcyZuMnS0jzf/uZbBINBHMchFouNzH/nBdu2qdVq1Go1er3enoi5YPBs5tUppvhtxJQ8TzHFY0Kn06FYLFIul7FtG6/XO9I7nmfJwFDvWKvVkFLS6/X40TvvcH91lV63S7fTQR1S22Z6PGB4nwjyPISUEPR7kENZRwMeVpU86eR5N3xeD9FIiGg0xtLFSwRCcVzbIr+zwc72Fq12h1arjXOynuwDMUnyHPCaWA+RZwEEfVqWoRQU6lA6BQGeFHkWwMtHGAYFEA/DfMpDPBbkra9+hWvXro6iKh+H72EYZ9lsNkctpul0mng8Pm3+m2KKM2BKnqeY4jHDdV2q1SrFYpFGo4EQ4sztX6eBUmpkMmw2mwQCAe7fv8+Pf/Qj6o06nVabfv9RQmV6PAjDS/sJIs+74fVIfF4t66i1H5SwTJw89/uj6LdxYRh75/d5BskSTfpj/hlwfuTZZ0I4IDGFoN7RsoyzrDcWklCs2lT30UOfBVLAS5f3z3kOeP//7d15fBRlnj/wT/V9pNOdTne4x4ORgCRcookIKBhHRV0P1GFcnQHcUccL2QVfzMioo+u1iqPLqOt9j+si4gWiP0UEOb0QEfDgUG5zdafvq+r3R6iym1QnlaS7E8Ln/XrNa2JV9VNPVdPw6SfP8y2gT6keJQ4jjh8yCGNPORmSJClziJ1OZ0Er7iQSCeXLcCKRgNFoVBb/FXKtBVFPxvBM1I3E43HU1taioaEB8XgcBoNB+TVvIVffy09F9Pl8SCaTMBgMWLt2LTZv3oxoJIJIJAwx1VzX2WAwQjB03/CcLn1ah8kgoSGQn/DssOmRyEN4Vtq3WxAMR/P25L+8hmezAXqdHjpd87SMfY3IyUNMAKBfKVDbkIQ/lJv2ZDodUHGMAVsPhme9DvAUC+jlNqDMW4qaiePh9XoRi8VQXFwMp9MJm81WsMV/h1bXEQQBxcXF8Hq9BS11R3SkYHgm6oZEUUQgEEBdXR38fj8kSeqSuq+SJCkLjAKBAIxGI3w+H5YvX44DBw4gGgkjlRIh6I2HRXiW6XRAsb15FC6RlBCOpXI25QFgeFZjNuphNukhQEAwAvxYl/tg2d8D/Fyf+/Cs1wFDjzFgT73UvPjPYUbViaMwYvgwZfGf/OS/Qi66i8ViaGxsRFNTE1KpFCwWi7L4r5Cj3URHmsJNrCQizXQ6nbISP5lMor6+HnV1ddi7d69S8q4Qi44EQYDNZoPNZoMoisrDVyZNmgSz2YzNmzdj7Zo1iMbiSCRTeZlCkA+iCEiSgJ/qAbtZQEmRDnpBQiQuIhpP5SSU5nPMsUADmp1m0OtgMRmg1wnwh4Bt+4DebgF5KAkOoPme5/A7EIDmih/9vQbYLAbUjDkKEyeMg9lsVipV9OnTp6CL/9IX+8ol5kpKSuDxeFBUVFSwfhAdyTjyTHQYCYVCSsk7eaSpq0a85NrRkiQhEAhg9eo12Lt3LyKxOMKRGMQcpJh8jTzLbe+qz9zmLpJQZAZESUIklkI82bFrcNj0SCYSefsyUVxkQSDUPUeedYIAs0kPk6F5seaeeiCUVvWkX6mAREq9TnNnDfAA+2qTCHTy0d86AXAX69C/zAinw4qTThqJweXlEEVRWY/gcDgKOi1DfnpoIBCAKIqw2+0oLS2F2+1miTmiAuPIM9FhxG63w263Z5S8279/Pw4cOJAxGp3PaR2SJCEejyORSEAURRgMBrjdbpxxRg0sFgv27t2L5R9/DJ/Pj3A4mpcnD+ZLQ1BAQxAwGQS47ToUWSXEkxIisWT7FrLleUiiOw55mIx6WEx6iKKAn/1Sq4/Izlf/BQCd+bpitwD9y4xwO00YVnE8Tj75JKRSKeh0Ouj1esRiMSQSiYNTcpJ5nxohl5jz+XzKGgiPxwOPxwOr1ZrXcxNRdgzPRIchvV4Pr9cLr9ebUfLO7/fDZDIpUz5y9Y+7JEmIRqPKA1YEQYDT6cQxxxyjrOCX/6GXJAkXT54Mo9GIzz77DF99tRGRaAyhcDRnpdvyLZ4E9vsBQECRWYDLboJOkBCNi4gmcjOtoycw6AVYTEbodAKaQsD2fUDzYHsrI7JCHr9bCGh34wY90MutR59SI/r09qLm9FNRUlKCeDyurDOwWq0QBEFZi+D3+/Hzzz/DZrMpo9C5Gv0VRRGhUAh+vz+jxFy/fv1YYo6om+C0DaIeQhRF+P1+1NXVKQFXri/b0ZJ38XhcebhCKpVSKgnIYUKNHLTlp5gZDAYEg0EsX/4x9u7di3A0hkg0AS1/9RQXWeAPxPMSttSmbbRGB6CkSIJdw7QOh1WPZDJ/0za6csGgTgDMJgNMBj2iCWBvPdo1TaK/R0A0AfhyvKgPAI7yAj/tT2qq3uEqEjCglxGuYivGnHwiKiuGKg8MkhfmthaIk8mkMvc4Fosp0zmKijr2aPV4PK6UmJPrvrvdbni93oJW2iGitjE8E/VA8XhcGY2OxWIwGAwoLi5GSUlJm/8Qq4WC4uLiDj3gQR6p8/l8CIfDsFqt+Pbbb7FmzVoEQyEEQ1Ekkqmsry8ussAfjOclJLY3PKczGQB3EWA2qE/r6Inh2WRsXvwnigJq/RIO+Do23zff4fnHfcmsTyS0mJofle0tMWLgscdgwmljYTAYIEmSUpO5I7WQ5TUA8iOvHQ5Hm18ygZafD/k3Oh6PhyXmiLoxhmeiHkyu/yqXvJMrBBz6q+Z4PI5wOIxAIKA8IMXpdOZ0IaI8ii0vMgSAVatW4bvvvkckGkM4EmtRLq74YIjLx99SziILfupgeE7nsABOG6ATJETiKcTiIuxWPVI9IDzL0zLkahm764FWvutoMsAjIBxvflhNrh1dBuzYm0Q0LTzrdIDHqUM/rxGlbidqJo5Dv379EI1GUVRUpDz5LxeL/+TSjnKQ1uv1Ss1nu92uHJf+mxl54a/H40FpaWlBny5KRB3D8Ex0hJBL3tXX1yMSaf49+7Zt27Bs2TKsWbMGN910E04//XQUFxfn9dfEkiQhFAopTzK0WCw4cOAAPvpoORoaGhCKxBCLJSDh8AjPsvRpHQIkxBPJvC2WzGd4FgQBDrsZkiR0aFpGWwZ4BYSjgD+HbcqOKQO27UkilgAcVqB/LyNcDjNGjaxE1UmjkUgkYDAYlFHmfAbV9LnLV199NWw2GyZOnIjq6mpYLBbo9Xq4XC54vd6MYE1E3R/DM9ERRJIkbN26FQsXLsTixYshiiJOPvlkTJgwASNHjoTL5SroyJc8RUSuJmA2m/HllxvwxZdfIBKJQpIk+AKxwyI8pytzAkadCIMeSCZFROOJnJTuk+UjPJuMBphNBohS8wjs1ztz13a6X3kFBKNAUx7C87G9BYQiIrwuI/r164OaieNRXFyMRCKRUY2m0CXmfvrpJyxbtgyffPIJvvvuO5x44om46KKLcMYZZ8BmsxWkL0SUOwzPREeIvXv34qqrrsKePXvwm9/8Bueddx5OPPFEBAIB1NfXIxgMNo86HpyvabPZCjrnUv5Vtt/vh8FgQCQSwZIlS1BX34BINI5wJJHTB2DkMzx7i4H6puaA6C4CvE4JekFCPJ5ELNH50ehchWe9XnewWoYOwSiwt0FAUgQG9QW++TE//zT8qkxAIJK70WwBQLEN6OPWw24zYdwp1aioGIpIJJIx/aiQf5YTiYSy0FYuMScv/mtoaMA777yDt956C3v27MH111+PK6+8smB9I6LOY3gmOkKEQiGsW7cO1dXVqqNd0WhUWWSYSCRgNBrhdDrhcrkK+qhfeZ62z+dDKBSCzWbDtm3bsPKTVQgEggiGY4jFOznxFvkNzx5H80NAmtLm9ep0QB+XBKcNECUR0VgCqQ6W7utMeBYEoblahlGPeELAfp+AQDTzmOP6AJt/6t7h2WIEepXo4HIYMHjQrzF+3CnKiLL857aQVSrkaRrydCQAKC4uhsfjgdPpbBHeJUnCt99+i0QigcrKyoL1k4g6j+GZiDLIj+GWS95JkqSUvOtIxY3OSCQSymi0KIrQ6XRYs2YtNm/Zgkg0jmA4hlSqY3+FFTo8p7OagL4lEiwmCYmkiFg7p3V0JDybjAaYTAZAElAfAH5uyj51IZ/h+agyAU0dDM86AXA7gF4lBnhKS3D6hHHo1asX4vG4svjPbrcXbFoG0FxpQ178l0wmYTab4Xa74fF4WGKOqIdieCairBKJBOrq6lBfX59R8s7lcnWopFdHSZKEcDisPJ7YbDajvr4eH320HLV1dQiF44jEEu0Kk10ZntOlT+uIxZOIa5jWoTU86/U6mE1G6HU6BGMHp2VoGLTPd3j2h4FgtO1jZUUWoLdbD2eRCaNHjcAJJ4xEPB6H0WhUHk9fyLn6qVRKeVhKOByGTqdTSswV+gsmERUewzMRtUkURYTDYdTW1sLn80EURVitVk0Pk8i1VCqlLDKMxWKwWq3YuHEj1n/6GcLhCAKhmKYScZ2p89wWjwNoDLavHJteB/QukeC0tj2to7XwLAiA2WiE0aRHIiFgv19o9yhvPsPz0WUCGkNAqI0HmRj1QJlLh9JiPX71q/6omXgqLBYLksmk8gTNQi7+A4BIJKKMMsufAY/HA7fbzRJzREcQhmciapdUKqWUvJNH3eTRaKvVWtC+yI8M9/v90Ol0iMfjWLFyJXbs2IlINI5QJPt0iLyOPBcBjaGO1zK2mYA+bgkW48FpHbEExLS/qtXCs9Ggh9lsBHBwWoa/46Eyr+G5l4DGoHp4FgTAZQN6uw1wFdtx2qljMHDgQITDYdjtdqU+eSFHdtMfGhSNRqHX61FSUgKv18tKGURHKIZnIuqwcDisLDJMpVIwm83KqGAhR+IkSVKe1BYKhWC1WrFr1y58/PEK+JuaEAi1XGTYncNzutIiCV5n80NY5GkdcnjW6ZqnZRh0OgRjAvY2AInOr6UseHi2moDeJTo4i4wYOnQwxo6phiiKEARBqclc6MV/4XAYfr8fgUAAkiShqKgIpaWlKCkpKehvWoio+2F4JqJOE0URPp8PdXV1CAQCEARBWcBV6JJ3cpkweXqJwWDAunXr8fWmTYhEYwiGYkimJBQXWbC7HsjHX4ClRc2Pn87lU/QMB6d1FFsBnU6CJAHx5MFqGTmumZzP8HxMr+aR8VgSKHUIKHPpUVbmwRmnnwqPx4NoNAqHw6H82SnktIz0BapyxRl58Z/FYilYP4ioe2N4JqKcisViyiLD9JJ3hR49lB+VLM9RNZvN8Pv9WPbRcuzfvx/JpIjd9RLy8QTtfITndIP6Atv3Iy99B/Ibngf108FkFFBkt+Lk6hMwfNgwRCKRjN9aFHJk99DSiIIgKCXmCl0fmogODwzPRJQXoigiEAigrq4Ofr9fKXnXFfNW5UWG8rxVq9WKTz5Zhc1bv0MwFEV9IIVwGwvY2iPv4bkPsO0A0MEy0W3KdXg2H6zJXOo0oHeZF2efVQOr1QpRFDOe/FdIcok5v9+vTDkqLS2Fx+MpaF1zIjr8MDwTUd4lEgllkaG86Kq4uBglJSUFLXkniiIaGhrQ2NiIZDIJQRCQTCaxeu06/PDDdgTCSTQExE7PGy4tAvwhwJen8HxcH2B7Nw/PzTWZBfQpNaDE5cCEU8egb9++SKVSEAQBdrsdXq+3oKFZLjHn8/kQiUSg0+ngcrmUxX8cZSYiLRieiaiggsEg6urq0NjYqJT7kh+hnI9f18s1ov1+P5qammAymZTzyY8EDwaDsFgs2LdvH5YtX4mGRh8aAkkEIujQU/w8juaRZ18o55cDoHuHZ7sF6FtqgMthxPBhQ3Fy9UlIJpNKUC0uLkY8HlcW48nTNfJZqzkSiaCxsRGBQACiKMJms6G0tBSlpaVc/EdE7cbwTERdIpVKoaGhAfX19QiFQtDpdMpCMYvF0ulRwHg8rvxaXpKkjNrAh0omk8oiw2QyCaPRiM8//wJfbNiIYDiO+qYUognt5z7SwrNBD5Q5dSgr0aNv31444/TT4HQ6EYvFUFxcDKfTqbr4L30kOBqNZjzJsrMLBeX31O/3IxaLQa/XK4v/WGKOiDqD4ZmIulwkElFK3iWTSZhMJqVEWXtGIw+d21xUVASn06k5jMmLDOVRaqPRiFAohA8/+hh7du+FL5SCLyS2GVqPlPDstAP9PAY4HVaMPaUKQ48foiz+k0eZtY7syqPR8qPY5dDdngehyCXm5N8mSJIEh8MBj8cDl8vFaRlElBMMz0TUbYiiCL/fj9ra2oySd06nE3a7XTX8SJKEUCikBKZcVW0QRVEJ4pFIBDabDd999x1WfrIG/kAYDYFk1kdMlxY1LxY8XMPzoD7AN1nCs8UI9C7Vw11swKBfD8Rpp54CvV4PURThdDo7/ej29CopgUBAqdZSXFycdSFfevCWK7yUlpbC6/UWtMILER0ZGJ6JqFuKx+NKybt4PA6DwaCEM5PJhE2bNuH777/H0KFDIQiCEpjzsQAxfQoIAAiCgE9WrcGWLd82LzIMphBP/nJ8TwvPOgEoLW5e/FfqdqJm4nj07dsXkUhEqeedi6kWh5Irtvj9foRCIQSDQezduxc1Nc3VOtL3yX8GPB5Pwau5ENGRheGZiLq19JJ3P/30E1atWoWVK1di7969OPvsszF79uyCPUzj0FFuq9WKAwcOYNlHK1BbV4/GQApNEQkl9p4RnossQF+PAS6HCSeMGoYTR5+Q8UXG6XQWrKxbIpHA2rVrcd9996GhoQHV1dUYN24chg8fDo/HA4/HU9CnWhLRkYvhmYi6tXg8jo8++giLFi3CypUrMXToUIwZMwYnnHACHA5Hl9UJTiaTaGpqgs/nQyKRgNlsxoYNG/HpZ58jFovigE/EAV9+zp3P8GzQA4P6CtDpDOjfvy/OOP1U2O12xONx5V5brdaCPvkvfS57OBzG9u3bsW7dOqxYsQJOpxMXXHABzj//fAwYMKBgfSKiIxfDMxF1azfeeCM2b97cIiCFQiHU1tbC5/MhlUrBYrG0e5FaLkiSpJS8a2pqgsFggN/vx4qVq7Frz140NCXxs19CItl2W1rlOjwLAJw2oJfbAFexDSOHV+CEE0YhEolk3NdCToUQRVG5r3KJObvdjtLSUrjdbuj1+owvVp988gkWL16Mo446qmB9JKIjE8MzEXVr8XgcRqMx60hnKpVCY2Mj6urqlLmvDocDJSUlOSl51x7yFBOfz4dwOAybzYYdO3bgo49XodEfxIGGJHzhjtWOTper8GwxAr1K9HAVGTBk8HEYN3YMgOYvBHK1k0I+xAbILBsoTxGRS8xZrdasr4vH41wcSEQFwfBMRD1GNBpVFhnKJe8KPTdXJleA8Pl8kCQJBoMBq9asxddfb4E/mMD+xhQi8Y613ZnwrNcB7iIBZS49vF43aiaeil69eiEcDsPhcLSrtF+uiKKIUCgEv9+fUWLO6/XC6XRy8R8RdSsMz0TU48gl7+rq6tDU1AQASlWIbCXv8kVeZCg/Uc9isaCxsRH/74Pl2H+gFj/7k6hvktoVhDsSnossQG+3Hk67GSedNAojRwxHLBaDwWDoUE3tXEivYiJ/2SktLYXH4+EoMhF1WwzPRNSjJRIJ1NbWoqGhQQmL8sK3Qk9JSKVSGVMSrFYrvv76G6xe+ymaghHsa0ghEGm7Ha3h2WgAypwC3A4Djj56ACaeNh5WqxWJRCJjoWWhR5nTp7bIJea8Xi+Kioo4ykxE3R7DMxEdEURRRDAYRF1dnfIUO5vNBqfTCYfDUdBFhgCUxXB+vx8GgwGJRAIfffwJtm3bgYZAEj/7xIza0elaC8+CALgOLv4rKS7CaaeegoEDj0UoFILNZoPL5eqSOsjpiypTqRSsVitKS0tRWlrKEnNEdFhheCaiI04ymURDQwPq6+sRDoeh0+kyyrAVkhzqfT6fEnB3796ND5atQGNjEw74kmgMAmLa39Rq4dlq+mXxX2XFEJwy5mSkUikAyHi4TCHJI+3y49L1ej1cLhe8Xi/sdntB+0JElCsMz0R0RAuHw6itrUVjYyNSqRTMZrNSmq3QI6KJREIZjRZFESaTCWvXfYovN2xUFhmGY7+EZwAodQjwuvTo3cuLM04/DW63G9FoNGOOd6GnZaQ/XluSJBQVFaG0tBQlJSUFH+EnIso1hmciIjSHPrnkXTAYVEreOZ1O2Gy2gi8yDIfDSgA1m80IBAL44MPl2L13P5KJBEToUVxkwZjqE1FZWYFIJAKTydSlwV8eZZbLC8ol5gr9ABsionxieCYiOoRc8q6hoQGJRAJGo1GZ+lDoknfy0/V8Ph9isRhsNhs2btyIgQMHwmQyIZlMKuX4umLxX/rjyuUvHF6vt+APVSEiKhSGZyKiLERRRFNTk1LyTpIk2O12uFyugleGkCQJDQ0NaGxsRCKRgCAIKCoqgtfrLXjVkFgspiz+SyaTMJvNSom5Qn+5ICIqNIZnIiINEomE8gCWWCwGvV6vjEbnM7zKQdXv90On08HpdKK4uBixWEx5qEghAn0qlVJKzEUiEeh0OrhcLpSWlrLEHBEdURieiYjaQRRFZZGhz+eDKIqwWq1KCbhcLIg7dKqGw+GAy+WCzWZrMS0jfa5xKpXKqN+cC/Liv6amJqW8X2lpKdxuN0vMEdERieGZiKiDUqkU6uvrM0reORwOlJSUtLvknbxI0O/3o6mpKaPqh5ZALklSRtCVFw86nc52B/pkMpkR3vV6PUpKSuD1emGz2drVFhFRT8PwTESUA5FIRCl5J88DlhfytTZCK48cy6PYuRg5Tp9iEY1GlaohrZWtk0fU5ceIyyXmPB4PSkpKOC2DiOgghmciohwSRRE+nw91dXUIBALKwj552oVOp0M0GsWOHTtgt9sRCoXyOmdZnhvt8/kgCAJMJhN0Oh0GDBgAILO2tFxZhCXmiIiyY3gmIsqTeDyO2tpaNDQ0IB6PY8+ePVi+fDlWrFiBAQMG4OGHH4bT6SxIhQpJkhAMBrF06VLcd999OP744zFx4kSMHDkSZrMZxcXF8Hg8LDFHRNQGhmciojzy+/14++23sWDBAuzYsQMnnXQSTjvtNIwaNQolJSVwOBwFC6ty5Y6dO3dixYoVWLFiBRobG3HOOefgkksuQWVlZUHrRBMRHY4YnomI8uSRRx7B448/jiFDhmDy5MmYNGkSLBaLUvIuGo1Cr9fnvEJGOrlyh9/vzygx5/V6Ybfb8dVXX2HhwoVYvHgx+vXrh2eeeQZerzfn/SAi6ikYnomI8mTDhg2w2+047rjjVPcHg0HU1dWhsbFRKXkn13HubMm7SCSCxsZGBAIBpcScx+OB2+1WbTscDmP16tUYO3Ys5zoTEbWC4ZmIqIulUik0NDSgvr4eoVBIKXknj0ZrndaRTCaVms+xWAwGg0EpMdfe0nlERKSO4ZmIqBuJRCKoq6tDQ0MDkslkRr1mtZJ3cok5n8+HYDAISZLgcDjg8Xjgcrm4+I+IKMcYnomIuiFRFOH3+1FXV4empial5J1crzmZTCoPREkkEjCZTHC73fB6vTCZTF3dfSKiHovhmYiom4vH48oiw3g8DkEQIEkSBEGA0+mEx+MpaNUOIqIjGcMzEdFhQhRFBINB7N27Fw6HA7169Wr16YVERJR7DM9ERERERBrxd3xERERERBoxPBMRERERacTwTERERESkEcMzEREREZFGDM9ERERERBoxPBMRERERacTwTERERESkEcMzEREREZFGDM9ERERERBoxPBMRERERacTwTERERESkEcMzEREREZFGDM9ERERERBoxPBMRERERacTwTERERESkEcMzEREREZFGDM9ERERERBoxPBMRERERacTwTERERESkEcMzEREREZFGDM9ERERERBoxPBMRERERacTwTERERESkEcMzEREREZFGDM9ERERERBoxPBMRERERacTwTERERESkEcMzEREREZFGDM9ERERERBoxPBMRERERacTwTERERESkEcMzEREREZFGDM9ERERERBoxPBMRERERacTwTERERESkEcMzEREREZFGDM9ERERERBoxPBMRERERacTwTERERESkEcMzEREREZFGDM9ERERERBoxPBMRERERacTwTERERESkEcMzEREREZFGDM9ERERERBoxPBMRERERacTwTERERESkEcMzEREREZFGDM9ERERERBoxPBMRERERacTwTERERESkEcMzEREREZFGDM9ERERERBoxPBMRERERacTwTERERESkkUHrgfF4HMlkMp99ISIiIiLqMgaDASaTqfVjtDQUj8fx2ecbYTYJOekYEREREVF3o9PpMHTo0FYDtKbwnEwmYTYJeGFhFAfqRAhCc4gWdGlhWvhlBoi8P/0YnZDl2LQ21NoVMtpFi9cJbZxXbVuL7arnzfKzTq1f2c7Rxn6o9DdtIo3q/iz9Un0rMva3o49pbWW+byrnVWkL2fql0sfMa2zjvEjbr3ZeDdfzy/70c6n3Uf4PXcuutGxX13KbLsuxciNZ7w2krP1u+bPUar/SzwGVdnUqbaXTQUrb33p/hGzHyufN2lba9lZe3/JY+edftmW757/c0/RrbNluxp+xtP1QOW9Gv9LPi5bnyDw22+vElueSVO6NfNyh55JU+iipH5t5G8TW+5jRrtjiXG2dF9nakn9OP1alrWZi1n63eJ3Srkq/07enX4Oo3l/5GCHjetvob3pb2fqreqz6PVVe19a1Z7seKeOFB/dLabtb74OkqY+tX7tyDlH99ZJK36Us55LE1u9Ntv7Kfch8G8S0H1XuDdTvqXyspOW88rGiyvtwyOuU7qj169CfpZbtqv0sZbt3bbQl5uJYseU9F1MqbaVav4aM60k/bzJtf9rECLk9KW1/+nmhsl0+1nB0P7j+dh2SyWTnw7PsQJ2I3ftECLrmf6Iygl76X/jp2+XwnHEsWj02PdxlDX1q4Tn9dXIf23h98zl0re5XC4uCru3wrGsjwKtdW5vnzdoWWmzXdB/lIJftvKpfHFoPz1n7lfG6ltuyhWfVwJslPOtU+qC6P6MtqB4r9y1ryE1vQ8p+rmyvy76/ubGMIJjlZ50SCrPtT9+uFhBb7s/oo4bAq9zTNo7V0pbchlrobz5AJZiqhP5sx6qF4PQ2sgbINsNzB4/N+Fls+XrVYCq02Na8vWVQTr8FWQPxwfYy/oxl7E9v4yApy7HKedWDj3rwF9vYD9WAn/46qNxHZLk3SlsaAnHbx6b1VzVAtnEOUb0t1SCcrS05TGRsa6MP2cKzSjDNGp5Vtmccq3YOteCLQ0OdSnhWCa6ZfVQPo2p9UDtX+vaMMNtGH7KdV217Zr9bf132tlpvNyOYquxvT1vIEmiV+5C2TWjr2JR6u3IbGeE5pX7tSshNOzYjPCdablfb1rxdbPVYLbhgkIiIiIhII4ZnIiIiIiKNGJ6JiIiIiDRieCYiIiIi0ojhmYiIiIhII4ZnIiIiIiKNGJ6JiIiIiDRieCYiIiIi0ojhmYiIiIhII4ZnIiIiIiKNGJ6JiIiIiDRieCYiIiIi0ojhmYiIiIhII4ZnIiIiIiKNDO05uJenOWsLgtD8/zrhl52CkPZj2s8H43n6oUh/WVp8FwQp67YWPx9sUMjoQvp5JZVtWfooiG3sb3k9Qlons5+jjf1ouT3j2tX2Z+mXTu2eZuxvRx/T2tJl3GCV86q0hWz9Uulj5jW2cV6k7Vc7r4br+WV/+rnU+yj/h65lV1q2q2u5TZflWLmRrPcGUsttWX+WWvYr7efMb8ctj83oI6RDD4UubVu2cyhve7ZjJanlfpVryGhL5X60PFb+Oa3f6dI7IR+T9nop/XVCyzbS90sq5816vRn9UTs22+vEFn2R7136scpxh55LUumjpH5sxuWqvT/p/Uq/Tcpr0l8vtNgvSBk3P62ttL835f5mbSt9h9CiX0i7D1C9v+l/btSOTb+wtP1Cy3ua/j4g7Z6q3fOMtjKuTaUPonpbUDtftraU+5h2QLZ2lfOm/dnOcj3yz5KmPqpdT/puscV5018vqfRdynIuSWz93mTrr9yHzLdBTPtR5d5A/Z7Kx0pazisfK6q8D4e8TumOWr8O/Vlq2a7az1K2e9dGW2I7js3WrnLP0u95SuXzlcr2+l9+1qndx2RaH5K/bJbbk9L2Z5wjbbt4yLGGo/tBC03h2WAwQKfT4feTLZoa7Ti1fwxFtQOJqNDU/+7vEfg3T2vSI6u+y3oBIPs3OCLqdoRD/h84PKY76HQ6GAytx2NByvh6l108HkcymWz7QCIiIiKiw5DBYIDJZGr1GM3hmYiIiIjoSHc4jKATEREREXULDM9ERERERBoxPBMRERERacTw3MW2bNmCqVOnYvTo0aiursaMGTPw888/qx77/PPPY8KECRg2bBguueQSfPPNNwXuLeWK1vd94cKFGDx4MCorKzP+V1dX1wW9ply6++67UV5ennU/P+89U2vvOz/vPc+ECRNQUVGR8X7eeeedqsfyM38YkajLRKNR6eSTT5b+8Y9/SLFYTKqtrZUuu+wy6U9/+lOLY99//31pxIgR0po1a6RwOCzNnz9fOuWUU6RQKNQFPafOaM/7/uyzz0rTpk3rgl5SPm3evFk68cQTpUGDBqnu5+e9Z2rrfefnvecZNWqU9Pnnn7d5HD/zhxeOPHehaDSKmTNn4uqrr4bJZILH48FZZ52FH374ocWxCxYswMUXX4zq6mpYrVZcd911EAQBH374YRf0nDqjPe+73++H0+nsgl5SvoiiiNtuuw3Tpk3Legw/7z2Plvedn/eeJZVKIRQKaXpP+Zk/vDA8dyGn04lLLrkEBoMBkiRh+/btWLRoEc4+++wWx27evBlDhw5V/lsQBAwePJi/1jkMted9b2pqwo8//oiLLroIJ5xwAi688EJ8/PHHXdBrypX//d//hcViwXnnnZf1GH7eex4t7zs/7z1LU1MTJEnC/PnzMXbsWIwdOxZz585FMBhscSw/84cXhuduYM+ePaioqMCkSZNQWVmJGTNmtDimsbERLpcrY5vT6URDQ0OBekm5puV9d7lccLvduPvuu7Fy5Uqcf/75uO6667Bt27Yu6DF1Vl1dHR555BHcfvvtrR7Hz3vPovV95+e9Z4nH4xg6dCgqKyuxdOlSvPDCC/jqq69U/xzwM394YXjuBvr164dNmzZh6dKl2L59O2bPnt3iGEFQfxZttu3U/Wl532+44QY89dRTGDx4MGw2G6ZOnYrBgwfjrbfe6oIeU2fdc889uPTSS3Hssce2ehw/7z2L1vedn/eepVevXnj99ddx5ZVXoqioCMceeyxmzZqFxYsXIx6PZxzLz/zhheG5mxAEAUcffTRuvvlmvPPOOy2+bZaUlMDn82Vsa2xshNvtLmAvKdfaet/V9O/fH7W1tQXoHeXSmjVrsGnTJlxzzTVtHsvPe8/RnvddDT/vPUv//v0hiiLq6+sztvMzf3hheO5Ca9asQU1NDZLJpLJNFEUAgF6vzzi2srISmzZtUv47lUph8+bNGDZsWGE6SznTnvf98ccfx+rVqzO27dixAwMGDMh/Rymn3nrrLezfvx/jx49HVVUVLrroIgBAVVUVFi9enHEsP+89R3ved37ee5atW7fi3nvvzdi2fft2mEwmlJWVZWznZ/7wwvDchSoqKhCJRDBv3jxEIhE0NDRg/vz5GD16NJxOJ8466yx89tlnAIApU6Zg4cKFWLt2LUKhEB588EFYLBZMnDixi6+C2qs973tjYyPuuOMO7Ny5E/F4HM8++yx++ukn5R9gOnzMmTMH7733Ht588028+eabeOKJJwAAb775JiZOnMjPew/Vnvedn/eepaSkBK+++iqeeOIJxONx7Ny5Ew8//DB+97vfQa/X8zN/GDN0dQeOZA6HA0899RTuu+8+jBs3DgaDAVVVVbjrrrsANI84hMNhAMD48eNx8803489//jPq6+tRUVGBJ554AmazuSsvgTqgPe/7v//7v0MURVx++eWIRCIoLy/Hc889h169enXlJVAHOJ3OjJJV8m8eevfuDYCf956qPe87P+89S69evfDEE0/ggQcewGOPPYaSkhJMmjQJN954IwB+5g9ngiRJUld3goiIiIjocMBpG0REREREGjE8ExERERFpxPBMRERERKQRwzMRERERkUYMz0REREREGjE8ExERERFpxPBMRERERKQRwzMRHTHmz5+P8vJyzJkzJy/tz5kzB+Xl5Zg/f35e2u/JJEnClClTUF5ejg8++CDv53v22WdRXl6OGTNm5P1cRNSz8AmDRNQu5eXlGf8tCAI8Hg+GDBmCa665BieccEJOz7d69WpMmzYNL7zwAqqqqjrV1sSJE9G7d28cffTRuekc5cz//d//4csvv8S4ceNQU1PT4XauuOIKrF+/Xvlvk8mEsrIynHjiiZg6dSoGDx6sHLdw4UIsXboUK1euxLhx4zp9DUR0ZGB4JqIOue6669CnTx8kk0ls2rQJr732GlavXo1XXnkFw4YNy9l5li5d2uk25AepDh06FEOHDu10e6lUCnq9vtPtdFeFvj5RFPHkk08CAP74xz/mpM1JkyZhzJgxaGxsxIYNG7Bo0SK8/fbbuOuuu3DBBRfAYDDgD3/4A+bOnYsnn3yS4ZmINOO0DSLqkDPOOAOXXHIJfve73+Guu+7ChAkTkEwmsXjxYuWYf/7znzjvvPNQWVmJUaNGYdq0afj8888z2nn66adx9tlnY/jw4aiqqsI111yDbdu2AWgeKX711VcBAL///e9xxRVXAABCoRDuuOMOjB07FhUVFTjzzDOxYMECpU15esZtt92GmTNnorKyElu3blWdttHQ0IBbbrlFaWv8+PG4/fbb0dTUpBwzceJElJeXY+HChTjrrLMwefJkzfdp165duOmmm1BdXY2KigqcfvrpePDBBxGLxZRjduzYgcsvvxyVlZWYOHEi3njjDUyePBnl5eVYt25d1rbvv/9+lJeX429/+xseeughnHLKKRg+fDhmzJiBYDCoHLdz505cd911GD16NCorKzFlyhR88cUXyv4rrrgC5eXleP755zF58mSMGTMm47pXrFiB6dOnY9iwYTj33HOxceNGfPDBB6ipqcHIkSMxc+ZMhMNhAMDs2bNRXl6OO+64Q2lfns5y6623ql7HunXrsGvXLvTr10/57cLrr7+O8vJyXHPNNXjttdcwduxYjBo1CnfeeSeCwSBuuukmjBgxAjU1Nfjoo49atDl8+HBccskluOqqq/Doo4/i3nvvRTKZxK233or9+/cDAM4991wYjUasW7cOe/bsafO9JCICGJ6JKEecTieA5lFLAPjv//5v/O1vf0MgEMCNN96Iiy++GOvXr8cf/vAHbNq0CUDzr+r/67/+C71798bNN9+MK664AuvWrcO0adOQSCQwa9YsuFwuAMD06dNx5ZVXAgD+/Oc/4+WXX8bw4cNx8803w+PxYO7cuXj33Xcz+vTee+8hGAxi9uzZ8Hq9LfocjUbxr//6r3jttddQUVGBWbNm4aijjsIrr7yC6dOnQxTFjOMfeughnHnmmZg6daqme1JbW4spU6bg3Xffxbhx4zBr1iwUFxfj8ccfx6xZs5Tj/uM//gOffvophg4dissvvxzPPfccdu7c2Wb7ZrMZALBkyRJs3rwZ06ZNQ0lJCZYuXYqHHnpIucbp06dj2bJlmDx5MmbOnIkDBw7gyiuvxO7duzPa+5//+R+MGDECN954Y8b2e+65B6NHj0Z5eTm+//57zJkzB08++SSmTJkCs9mMJUuW4OWXXwYA3HbbbTjqqKPwz3/+E+vXr8eKFSuwaNEi/PrXv8Zf/vIX1euQv1CpTfnZsmUL3n33XVx88cWIRCJ46aWXMHXqVPTt2xennXYadu3ahTlz5iAajbZ6ry688EIMGTIEsVhM+W2G1WpFRUUFAOCzzz5r9fVERDJO2yCiDvH5fKitrYUoitiwYQPee+89AEBNTQ3C4TCeeuopAMDDDz+M4cOHA2gO1i+99BKeeeYZPPjgg9i6dSsAoKqqCpdeeimMRiNqamqU0Dpp0iQ88MAD8Pl8OO2001BVVYUff/wR7733HlwuF2699VbodDpUVVXhX/7lX/Diiy/i7LPPVvqo0+nw6KOPwmg0ql7D22+/je3bt2PgwIF47LHHIAgCLrvsMowfPx5ff/01Vq1alfHr/LPPPhszZ87UfI9efvll1NXVYdy4cbj//vsBAOeccw4mTJiA999/H9u3b0c8Hsc333wDo9GIRx99FG63GxMmTMBZZ53VZvuCIAAALBYLHnvsMej1egwcOBDXXHMN3njjDcydOxdvv/029uzZg3HjxuHf/u3fAAA2mw233XYbXnvtNdx0001Ke6NGjcJf//rXFuepqanBtddei9GjR+OKK67Atm3b8MYbb2DIkCEIh8N45JFHsGHDBgBAUVERHnzwQUyZMgW33HILkskkzGYz/v73v8Nisahex44dOwAAAwcObLGvsbERDz30EBwOBz7//HOsX78eZWVluPnmmxGLxfDhhx/C5/Nh586dynzmbAYPHowtW7ZkfDH59a9/jS+//BLbt29v9bVERDKGZyLqkENHX202G+bOnYvq6mps3LgRsVgMBoMhY/5zZWUlACih+YILLsCiRYvw97//HY8//jgqKipQVVWF3/72t1kD7w8//ACgObyPHz8+Y5/crmzw4MFZ2wGAb775BgAwYsQIJYiaTCaUl5dj7dq12Lp1a0Z4lvuvldz+yJEjlW1erxe9e/fGrl27sHXrVqV/ffv2hdvtBgAcc8wxcLlc8Pl8AJq/dNTW1iptmEwm5VigeYqCPEf5+OOPBwAEAgH4/X7lfq1cuRJjx47N6N+h9yvb9Q0ZMgQA0KdPH2Xbcccdl7EtfZpLRUUFbrzxRsybNw8A8Ne//hWDBg1SbRsA/H4/gF9+e5Guf//+cDgcGeeSz202m+F2u7F///6M82eTSCQANN8/mXxO+V4TEbWF4ZmIOuTWW2/FgAEDIAgCHA4HBg8e3GJkURAESJKkBNP07QAwbNgwLF26FO+++y4+++wzbNiwAevXr8eCBQuwcOFCeDyeFueVX9urVy/853/+p+o+WbaRzmxtyuQFhodut1qtmtprT/vZzpVu3759OP3005X/Pumkk/Diiy+qHps+1USn0yntjh8/XpkzLpOnxMiy3S85bKb30WBo/ucj28LCb7/9VvlZnqbTEelffnQ6Xca5088v38dsJEnCli1bADSPNh+qtftPRJSO4ZmIOmTUqFHKiOShBg4cCLPZjFgsho0bN2LEiBEAoCxSk+eZ/vDDD9i1axemTp2KqVOnQpIkzJo1C++88w4+/fTTjCkYcig89thjATSPFI4YMQLFxcUIhUL44osvMkZGtZArb3zxxRdKyI9EIsqIrNzPjho6dChWrFiRsUhy//792LdvHwRBQEVFBQKBAABgz5498Pl8cLlc2LlzZ8ZIqMfjUapRAC1D79dffw1RFKHT6ZTRbpfLBYfDoUyF8Pv9ykj97t27sXv3bpSVlXXq+rJ588038c4772Ds2LGIRqNYtGgRxo0bh3POOUf1eHn0Vx6BzocFCxZg27ZtcDgcGVNi5BFrtVFvIiI1DM9ElHN2ux3Tp0/HY489hpkzZ+Lyyy/H7t27sWDBAthsNlx11VUAgEcffRSLFy/G+eefjxEjRiAcDuOLL76A0WhUgq3T6cSePXvw9NNPY+/evZg8eTJ+85vf4P3338dVV12FM888E8uWLcP69etx/fXX44YbbtDcz3PPPRdPPfUUtm/fjj/96U+orq7G0qVL4ff7UV1djerq6k7dh8suuwyvvvoqPvnkE8yZMweDBg3C66+/jlQqhcmTJ2PAgAEAgEGDBuG7777DtddeizPOOANvv/02bDabUsHCYrG0mKKSzu/3K3OSX3jhBQDApZdeqlzjI488gq+++gqzZ8/GoEGD8Oqrr2LPnj145pln0Lt3705d46F2796NO+64A3a7HXfeeSdisRjOP/983HbbbRgxYgT69evX4jXyFyJ5ikkufPXVV1iwYAHC4TA2bNiAJUuWwGQy4d5770VxcbFy3Pfff5/RByKitjA8E1FezJgxAx6PB6+88oqyWGz8+PGYOXOmMhp65513wul0Yvny5ViyZAnsdjvKy8tx991341e/+hUA4Nprr8Xtt9+ODRs2wGw2Y/LkybjnnnvgdrvxwQcfYN68eejbty9mz56tVOPQymq14uWXX8a8efPw8ccfY+XKlSgrK8P06dNbVJzoiLKyMrzyyit48MEHsWzZMrzzzjvo168fZs6cqSzeA4B58+bhL3/5CzZu3Ii6ujrcdNNNuP/++xEOhzXVW66pqUFpaSmefPJJxONxXHTRRbjuuuuUa3z66adx//3348MPP8T777+P4447DrfccgtOPvnkTl9julQqhVmzZiEYDOL2229H3759AQDXX3895s2bh1mzZuGll15qcU2jR48GgBZlDDtjyZIlWLJkCfR6PTweD8477zz88Y9/zHjITyQSUUbq5T4QEbVFkNqaKEZERHm1b98+HDhwAIMGDVJGnKuqqhCPx5VAr2b+/Pn4xz/+gQsvvBD33ntvgXudO6Io4swzz8RPP/2E5557LuehPpsFCxZg7ty5qKqqUkbsiYjawjrPRERdbMaMGfjtb3+Lq6++Gs899xxuuOEGxONxnHrqqXmbl9yd6HQ6ZSQ+fW53PiWTSTz//PMAcvdUQyI6MjA8ExF1sUceeQTnn38+duzYgXnz5uHHH3/EtGnT8MADD3R11wrm0ksvxciRI7Fq1Sq8//77eT/fiy++iO+//x5nnnkmH81NRO3CaRtERERERBpx5JmIiIiISCOGZyIiIiIijRieiYiIiIg0YngmIiIiItKI4ZmIiIiISCOGZyIiIiIijRieiYiIiIg0YngmIiIiItKI4ZmIiIiISCOGZyIiIiIijRieiYiIiIg0YngmIiIiItKI4ZmIiIiISCOGZyIiIiIijRieiYiIiIg0YngmIiIiItKI4ZmIiIiISCOGZyIiIiIijRieiYiIiIg0+v/7tyOBRIUXVwAAAABJRU5ErkJggg==", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Plot prior and posterior fields (mean of ensemble) for the GN-EnRML/margis run\n", + "prior_permx_gn = np.load('prior_ensemble.npz')['permx'].mean(axis=-1)\n", + "posterior_permx_gn = res_gn.x.mean(axis=-1)\n", + "cmax_gn = max(prior_permx_gn.max(), posterior_permx_gn.max())\n", + "cmin_gn = min(prior_permx_gn.min(), posterior_permx_gn.min())\n", + "plot_field(prior_permx_gn, label='Prior log-permx (mD)', cmapname='coolwarm', cmax=cmax, cmin=cmin)\n", + "plot_field(posterior_permx_gn, label='Posterior log-permx (mD)', cmapname='coolwarm', cmax=cmax, cmin=cmin)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "And the well rates, using `plot_rates` from above unchanged, reading `Results_margis`'s forecasts in place of `Results`'s:\n" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-20T12:13:46.480824Z", + "iopub.status.busy": "2026-08-20T12:13:46.480711Z", + "iopub.status.idle": "2026-08-20T12:13:47.220817Z", + "shell.execute_reply": "2026-08-20T12:13:47.220424Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "prior_forecast_gn = PETDataFrame.from_pickle(\"Results_margis/prior_forecast.pkl\")\n", + "prior_forecast_gn.is_ensemble = True\n", + "\n", + "posterior_forecast_gn = PETDataFrame.from_pickle(\"Results_margis/posterior_forecast.pkl\")\n", + "posterior_forecast_gn.is_ensemble = True\n", + "\n", + "plot_rates(\n", + " data=data,\n", + " std=std,\n", + " prior=prior_forecast_gn,\n", + " post=posterior_forecast_gn,\n", + " key='WOPR',\n", + ")\n", + "\n", + "plot_rates(\n", + " data=data,\n", + " std=std,\n", + " prior=prior_forecast_gn,\n", + " post=posterior_forecast_gn,\n", + " key='WWPR',\n", + ")\n" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "venv-PET (3.12.3.final.0)", + "language": "python", + "name": "python3" + }, + "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.12.3" + }, + "widgets": { + "application/vnd.jupyter.widget-state+json": { + "state": { + "01e1213a44454436abafeca43574cc22": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_08983d3b75e54ee596f7afe6965e7707", + "placeholder": "​", + "style": "IPY_MODEL_75bdfadf1e234eecb1b3dbb2de011328", + "tabbable": null, + "tooltip": null, + "value": " 50/50 [01:15<00:00,  1.59s/member]" + } + }, + "08983d3b75e54ee596f7afe6965e7707": { + "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 + } + }, + "0924d85e149d46a7b71560d0cd817fa7": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_3276eea641a04f07b92c25e072c61879", + "IPY_MODEL_85597f78be7644f0ba6057fdc8f753f9", + "IPY_MODEL_9b32345981444f4c934e9f0809270da7" + ], + "layout": "IPY_MODEL_df18f1a39f6b4daaba1afb144142b0f4", + "tabbable": null, + "tooltip": null + } + }, + "0e8f89d99e2643ddb98d9e6f0f1115d8": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_d0de9ccb8c6543ab98ab652c7fd86281", + "placeholder": "​", + "style": "IPY_MODEL_a0a2be6b817d4de88ad5defb7c0c7837", + "tabbable": null, + "tooltip": null, + "value": " 50/50 [01:00<00:00,  1.21s/member]" + } + }, + "0ed9cc28dfba4ef0b9ad94a242407ff9": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "10d3ec8bddae4778a71aeb438222de83": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_bdb35dc2318849c78cd07ddc0c520cb8", + "placeholder": "​", + "style": "IPY_MODEL_c5650e87e6d24ee5905716d99ffd207f", + "tabbable": null, + "tooltip": null, + "value": " 50/50 [01:07<00:00,  2.02s/member]" + } + }, + "11060065bf714fc0a6f40dafea87e098": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_458c41f67e514771ac87c329ab3cf32b", + "IPY_MODEL_b68dd9f2336043c59ff07d7ffb0d74dc", + "IPY_MODEL_b26c92effb394eb6995e070f78a0f04f" + ], + "layout": "IPY_MODEL_c255eaf7afb34ee9bb5e3af9881a0209", + "tabbable": null, + "tooltip": null + } + }, + "11b33768c1244a008fb17c601b167f52": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "123707f619ac436984b664551fa4014f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "130761a0ddd54164a07195a4e7a1bb70": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": "#285475", + "description_width": "" + } + }, + "133f7748da484fb9bdc19dd664796f5c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_b5c18eb8ee064799b9c12c83ca57d113", + "IPY_MODEL_583c1df5191c4b739a43b6ccb1eccc77", + "IPY_MODEL_68f9bffb8f5d46e597bd43103923e174" + ], + "layout": "IPY_MODEL_630b8eb9a0bf41ae9acb15a651802923", + "tabbable": null, + "tooltip": null + } + }, + "14bdf822f52f4a9e96c4ca38e1521949": { + "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": "2", + "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 + } + }, + "1613a6cc6b5b419886b3d3d84e4b2fa6": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_69e679c286ce48d1a9c70bc7e7c31b1c", + "placeholder": "​", + "style": "IPY_MODEL_283aeec9628e4a839f2bfedbd29618c7", + "tabbable": null, + "tooltip": null, + "value": " 50/50 [01:00<00:00,  1.11s/member]" + } + }, + "1622720c5a81435e94cc33f713e9b93c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "17856d0e760344138d0efe0e59307c75": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_ef6b0ad2d1154f839aae1adcc4f39881", + "IPY_MODEL_c3c4fb661f27426e9929aa8ea1977806", + "IPY_MODEL_63e4166498ab46daa8c1b0307ecc13b6" + ], + "layout": "IPY_MODEL_4628d4f059c7442b888f06c0c00e41db", + "tabbable": null, + "tooltip": null + } + }, + "1a5996ecbdac4574b1248837ea02f7c1": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "201bd02cdac641f4abefdd466c3ed8df": { + "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 + } + }, + "206ec578b05f4fe2b69d2f6010b3262e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_43dbb8823fff4a31b8198b66ca5e3434", + "max": 50, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_fda2280226604412957928b2158916f2", + "tabbable": null, + "tooltip": null, + "value": 50 + } + }, + "20c8e30cb00149318fb8e23b5173699c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": "#285475", + "description_width": "" + } + }, + "2462feba103c48679bc09354a26194dd": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "2561209f573149558a48d999558307bd": { + "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 + } + }, + "26804ca9c1974cf0ac28c3b848806e4a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_d89ce4c0e20549fd998c5ecfdb6e661e", + "IPY_MODEL_35abc73b3530446594055af4edab9cf9", + "IPY_MODEL_dd07918f0a8b414ba1eea7eb2d603470" + ], + "layout": "IPY_MODEL_87200ea757b54d38a5fee35dee2938c0", + "tabbable": null, + "tooltip": null + } + }, + "283aeec9628e4a839f2bfedbd29618c7": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "2a72dda652254b5788d0fb0a38f8faa6": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_2561209f573149558a48d999558307bd", + "placeholder": "​", + "style": "IPY_MODEL_11b33768c1244a008fb17c601b167f52", + "tabbable": null, + "tooltip": null, + "value": " 50/50 [01:04<00:00,  1.31s/member]" + } + }, + "2adca1bbe2b642c8927225347390d715": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "2b831edc2e464cfaae556a1cef462674": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "2d35bf4a51434626824f4def92922ba4": { + "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 + } + }, + "2d64fbaa27aa4cce9607eac37723e2f3": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "2eae401fa6cc4218989bb6f1f9b97772": { + "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 + } + }, + "3276eea641a04f07b92c25e072c61879": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_f1719420bf91470fa8b1c9e3ee566e96", + "placeholder": "​", + "style": "IPY_MODEL_cfce8e606c3140b1bbc713b956566c96", + "tabbable": null, + "tooltip": null, + "value": "100%" + } + }, + "33a1f63cd55b4975b786eadb9439f7fd": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "352322ff263d4f25a4869bea170ffb68": { + "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 + } + }, + "35a0efed7a5247268cf8f5595fe1ec64": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_9833d32a50d54a3492232c3ad8a44109", + "placeholder": "​", + "style": "IPY_MODEL_1a5996ecbdac4574b1248837ea02f7c1", + "tabbable": null, + "tooltip": null, + "value": " 50/50 [00:58<00:00,  1.26s/member]" + } + }, + "35abc73b3530446594055af4edab9cf9": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_7cd16b3f48f54b3c854d748f3b6ba364", + "max": 50, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_537f34385fd347d7937bfd0fabe473a8", + "tabbable": null, + "tooltip": null, + "value": 50 + } + }, + "36b22d35e88243ed84a6f36303618c1b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_5786a94ea7004df6b656742f87de6efc", + "placeholder": "​", + "style": "IPY_MODEL_0ed9cc28dfba4ef0b9ad94a242407ff9", + "tabbable": null, + "tooltip": null, + "value": "100%" + } + }, + "384d21d346a444ce98d14e40b4e35749": { + "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 + } + }, + "39be030fd9644a5eb35e15cdc3cf4ec9": { + "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 + } + }, + "3e6af9b7f2184704aa9c6cfd6de7e5b8": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_b2d0befa969c4c9b978911b2744a1fcb", + "IPY_MODEL_cc643eb345814d9ca6912ecfcfb23fbe", + "IPY_MODEL_79dcd6d21cf54b7c8d175b07527ccf42" + ], + "layout": "IPY_MODEL_4807f977faea40fd8605af16e6df0d1e", + "tabbable": null, + "tooltip": null + } + }, + "414c8409573c41f5907c96aea0bb074a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_4fac34c1b07c4ffc8b26e9b6dd461bf0", + "IPY_MODEL_5ee8b4c0d6a44a8eaf1e0b0f8b81aa7f", + "IPY_MODEL_10d3ec8bddae4778a71aeb438222de83" + ], + "layout": "IPY_MODEL_7c6aeeab8d3f4b8194681414e703c2b6", + "tabbable": null, + "tooltip": null + } + }, + "43dbb8823fff4a31b8198b66ca5e3434": { + "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": "2", + "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 + } + }, + "458c41f67e514771ac87c329ab3cf32b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_c931a099e5564930a4c68990121c2ec4", + "placeholder": "​", + "style": "IPY_MODEL_7e27afb4c7874f059cde04076fc9d166", + "tabbable": null, + "tooltip": null, + "value": "100%" + } + }, + "4628d4f059c7442b888f06c0c00e41db": { + "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": "inline-flex", + "flex": null, + "flex_flow": "row wrap", + "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": "110px" + } + }, + "475431069ba142c293ddcfc4fd3ac05c": { + "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 + } + }, + "478ca2dea8bf42029b5085a12960a070": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": "#285475", + "description_width": "" + } + }, + "4807f977faea40fd8605af16e6df0d1e": { + "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": "inline-flex", + "flex": null, + "flex_flow": "row wrap", + "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": "110px" + } + }, + "4bbe2f0bc9bf4cc8989b7cb03f797857": { + "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": "inline-flex", + "flex": null, + "flex_flow": "row wrap", + "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": "110px" + } + }, + "4dd2064c1e994ae682658f4e73ba2095": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": "#285475", + "description_width": "" + } + }, + "4fac34c1b07c4ffc8b26e9b6dd461bf0": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_b2a3115505b84d518446cc148ca8c33d", + "placeholder": "​", + "style": "IPY_MODEL_b4f01642f9644718add629bcbcdbf6e9", + "tabbable": null, + "tooltip": null, + "value": "100%" + } + }, + "4fe5dfd218d34141bed57d5ad954d333": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "537f34385fd347d7937bfd0fabe473a8": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": "#285475", + "description_width": "" + } + }, + "54d0293d7e86427280d3e8febfcd5f77": { + "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": "2", + "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 + } + }, + "550b6b6be1d546a0b9a1341966b10d5f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_71414ddb38a545cb9d2c158b48e5cf07", + "max": 50, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_4dd2064c1e994ae682658f4e73ba2095", + "tabbable": null, + "tooltip": null, + "value": 50 + } + }, + "5783dd68a2ca41b49fb452f80ee913f2": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_14bdf822f52f4a9e96c4ca38e1521949", + "max": 50, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_d2eee8655d034c95bc6c825f7a4c41ef", + "tabbable": null, + "tooltip": null, + "value": 50 + } + }, + "5786a94ea7004df6b656742f87de6efc": { + "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 + } + }, + "583c1df5191c4b739a43b6ccb1eccc77": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_63267553657e4d42b205ac52c5f2e1b7", + "max": 50, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_20c8e30cb00149318fb8e23b5173699c", + "tabbable": null, + "tooltip": null, + "value": 50 + } + }, + "5a86e464758e468cbf5d126d726094f1": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_54d0293d7e86427280d3e8febfcd5f77", + "max": 50, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_8d9b29982d74439fbd2d7741ee7a06f0", + "tabbable": null, + "tooltip": null, + "value": 50 + } + }, + "5b132f7755504bc393a50f091f3fa6e9": { + "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 + } + }, + "5bd06ac2252a48a38023fc790ab7ebe8": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_abb4d90e9fb1486899ea5bb5c49c73a1", + "IPY_MODEL_550b6b6be1d546a0b9a1341966b10d5f", + "IPY_MODEL_35a0efed7a5247268cf8f5595fe1ec64" + ], + "layout": "IPY_MODEL_feb12119c51641ea875d1a952ac3d33c", + "tabbable": null, + "tooltip": null + } + }, + "5dc20b3cb0854f7dbf04a107b89e4e7a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": "#285475", + "description_width": "" + } + }, + "5ee8b4c0d6a44a8eaf1e0b0f8b81aa7f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_d65fbb9be95248d2aa206cfc444bad7c", + "max": 50, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_9ef6687aa6f34863b650348eb255f282", + "tabbable": null, + "tooltip": null, + "value": 50 + } + }, + "630b8eb9a0bf41ae9acb15a651802923": { + "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": "inline-flex", + "flex": null, + "flex_flow": "row wrap", + "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": "110px" + } + }, + "63267553657e4d42b205ac52c5f2e1b7": { + "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": "2", + "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 + } + }, + "63e4166498ab46daa8c1b0307ecc13b6": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_e5039ef76ac0424c9b00e3186e90e918", + "placeholder": "​", + "style": "IPY_MODEL_e44c0d724aaf4d94a411fb63f4466db3", + "tabbable": null, + "tooltip": null, + "value": " 50/50 [01:02<00:00,  1.28s/member]" + } + }, + "64b7303c506546f1b8f4b6f048b69ea1": { + "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": "2", + "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 + } + }, + "68f9bffb8f5d46e597bd43103923e174": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_dff9c0eb7534495db89e4b25b9c7d085", + "placeholder": "​", + "style": "IPY_MODEL_da8c2ae5f69f47aaa114064720aaf9ee", + "tabbable": null, + "tooltip": null, + "value": " 50/50 [00:58<00:00,  1.26s/member]" + } + }, + "69e679c286ce48d1a9c70bc7e7c31b1c": { + "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 + } + }, + "6a32108836354991ac27f72db064f126": { + "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": "inline-flex", + "flex": null, + "flex_flow": "row wrap", + "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": "110px" + } + }, + "6a6f7a5cf1d342a4b8924b700666fba3": { + "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": "2", + "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 + } + }, + "6b30a9cb63074ae29d10fcd61756a518": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": "#285475", + "description_width": "" + } + }, + "6b69a49648b84f128f7b3d0baa974f3b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "6b8f785576b340319981b8f5d94bd7d6": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_b9c456c08f8a4facba5d4b0b4be7a66e", + "placeholder": "​", + "style": "IPY_MODEL_2d64fbaa27aa4cce9607eac37723e2f3", + "tabbable": null, + "tooltip": null, + "value": "100%" + } + }, + "6d798e5bfb7e4cb6b5ca01f5dfe6c510": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_e1fb366a52b34de197af74eab00d387a", + "IPY_MODEL_9831159576994a9fb7eefe58f96c613d", + "IPY_MODEL_768cf0ce94a748688d65d7aedf4fd8f7" + ], + "layout": "IPY_MODEL_4bbe2f0bc9bf4cc8989b7cb03f797857", + "tabbable": null, + "tooltip": null + } + }, + "71414ddb38a545cb9d2c158b48e5cf07": { + "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": "2", + "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 + } + }, + "7587dcfc7f41486abb396775da7660fa": { + "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": "inline-flex", + "flex": null, + "flex_flow": "row wrap", + "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": "110px" + } + }, + "75bdfadf1e234eecb1b3dbb2de011328": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "75d29d891d4b450c93d044203703ae18": { + "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": "inline-flex", + "flex": null, + "flex_flow": "row wrap", + "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": "110px" + } + }, + "768cf0ce94a748688d65d7aedf4fd8f7": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_bea486d0275946e490dcae7cf2829935", + "placeholder": "​", + "style": "IPY_MODEL_da04c3a78e65413296925c1fd76221fe", + "tabbable": null, + "tooltip": null, + "value": " 50/50 [01:00<00:00,  1.27s/member]" + } + }, + "783689f2486d4939ada7b566af6532de": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "79dcd6d21cf54b7c8d175b07527ccf42": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_896005b2495e414681f10dcefcc15e1c", + "placeholder": "​", + "style": "IPY_MODEL_783689f2486d4939ada7b566af6532de", + "tabbable": null, + "tooltip": null, + "value": " 50/50 [01:06<00:00,  1.04s/member]" + } + }, + "7bb488d009664b0c8ae2c43d5d202480": { + "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 + } + }, + "7c24db5964d34f54913be51fd172857d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_9ac0c8d566bd4c39b2bf2204118982b2", + "placeholder": "​", + "style": "IPY_MODEL_2adca1bbe2b642c8927225347390d715", + "tabbable": null, + "tooltip": null, + "value": "100%" + } + }, + "7c6aeeab8d3f4b8194681414e703c2b6": { + "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": "inline-flex", + "flex": null, + "flex_flow": "row wrap", + "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": "110px" + } + }, + "7cd16b3f48f54b3c854d748f3b6ba364": { + "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": "2", + "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 + } + }, + "7e27afb4c7874f059cde04076fc9d166": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "809f813b1efb472dbff901d438416b29": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_d110dd3b58f74b92b3fca12541c9bf45", + "placeholder": "​", + "style": "IPY_MODEL_1622720c5a81435e94cc33f713e9b93c", + "tabbable": null, + "tooltip": null, + "value": "100%" + } + }, + "81f4660efa524a3faf163ab2767b1e97": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "824b7f2b2dbd411f9dbcda87af84e3e1": { + "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 + } + }, + "839f3c31458f404fa2ea5133e44e5193": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_6b8f785576b340319981b8f5d94bd7d6", + "IPY_MODEL_9b112c5969264e27b667b15a46dddb2b", + "IPY_MODEL_dc8c1fff14e34f4e952f12739d6069cd" + ], + "layout": "IPY_MODEL_a0ae42a43fbe4256b594aff63bce3719", + "tabbable": null, + "tooltip": null + } + }, + "85597f78be7644f0ba6057fdc8f753f9": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_6a6f7a5cf1d342a4b8924b700666fba3", + "max": 50, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_add919c69b134465a19b3fe1a182d898", + "tabbable": null, + "tooltip": null, + "value": 50 + } + }, + "87200ea757b54d38a5fee35dee2938c0": { + "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": "inline-flex", + "flex": null, + "flex_flow": "row wrap", + "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": "110px" + } + }, + "896005b2495e414681f10dcefcc15e1c": { + "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 + } + }, + "89a5b058a9c2496b8481bf7f8bea1298": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "89d9b148965444b4934f0eedccf2328a": { + "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 + } + }, + "8b62b46b9a3245e3a18c942e85d021c2": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_ad71bcfc47374db89c26b661d445343e", + "max": 50, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_6b30a9cb63074ae29d10fcd61756a518", + "tabbable": null, + "tooltip": null, + "value": 50 + } + }, + "8d9b29982d74439fbd2d7741ee7a06f0": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": "#285475", + "description_width": "" + } + }, + "92767ae95c3742e8844cdaf85539371f": { + "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 + } + }, + "93625d511e654a2fa090544c7b37cce7": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": "#285475", + "description_width": "" + } + }, + "94a1e72511474cccbd491b45b603358b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "9831159576994a9fb7eefe58f96c613d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_a0d1b686393344ab91cccd0dd703a6f2", + "max": 50, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_9f00207bf96540cc904627d17342170f", + "tabbable": null, + "tooltip": null, + "value": 50 + } + }, + "9833d32a50d54a3492232c3ad8a44109": { + "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 + } + }, + "99195a7b8062422ea789b42170cf0c3f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_475431069ba142c293ddcfc4fd3ac05c", + "placeholder": "​", + "style": "IPY_MODEL_a6f0bf4227ea41b18d507a09f989f82d", + "tabbable": null, + "tooltip": null, + "value": "100%" + } + }, + "9ac0c8d566bd4c39b2bf2204118982b2": { + "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 + } + }, + "9b112c5969264e27b667b15a46dddb2b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_64b7303c506546f1b8f4b6f048b69ea1", + "max": 50, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_93625d511e654a2fa090544c7b37cce7", + "tabbable": null, + "tooltip": null, + "value": 50 + } + }, + "9b32345981444f4c934e9f0809270da7": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_89d9b148965444b4934f0eedccf2328a", + "placeholder": "​", + "style": "IPY_MODEL_4fe5dfd218d34141bed57d5ad954d333", + "tabbable": null, + "tooltip": null, + "value": " 50/50 [00:59<00:00,  1.40s/member]" + } + }, + "9e667d9b2e814d48a0f2cf546842a549": { + "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": "2", + "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 + } + }, + "9ef6687aa6f34863b650348eb255f282": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": "#285475", + "description_width": "" + } + }, + "9f00207bf96540cc904627d17342170f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": "#285475", + "description_width": "" + } + }, + "a0a2be6b817d4de88ad5defb7c0c7837": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "a0ae42a43fbe4256b594aff63bce3719": { + "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": "inline-flex", + "flex": null, + "flex_flow": "row wrap", + "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": "110px" + } + }, + "a0d1b686393344ab91cccd0dd703a6f2": { + "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": "2", + "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 + } + }, + "a4e57bd5e52941c0b247965dee2c9232": { + "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 + } + }, + "a6f0bf4227ea41b18d507a09f989f82d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "abb4d90e9fb1486899ea5bb5c49c73a1": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_2eae401fa6cc4218989bb6f1f9b97772", + "placeholder": "​", + "style": "IPY_MODEL_2b831edc2e464cfaae556a1cef462674", + "tabbable": null, + "tooltip": null, + "value": "100%" + } + }, + "acd94192627c48c29e264479e9a39e13": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "ad71bcfc47374db89c26b661d445343e": { + "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": "2", + "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 + } + }, + "add919c69b134465a19b3fe1a182d898": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": "#285475", + "description_width": "" + } + }, + "ae4ee3cf360b4b838c75ba794b9dd9c9": { + "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": "inline-flex", + "flex": null, + "flex_flow": "row wrap", + "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": "110px" + } + }, + "b0fa20a8e7d34c2e95127e80b54fce35": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_36b22d35e88243ed84a6f36303618c1b", + "IPY_MODEL_5a86e464758e468cbf5d126d726094f1", + "IPY_MODEL_0e8f89d99e2643ddb98d9e6f0f1115d8" + ], + "layout": "IPY_MODEL_c4ef5bd9575246039b3543afe31ce1fd", + "tabbable": null, + "tooltip": null + } + }, + "b26c92effb394eb6995e070f78a0f04f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_201bd02cdac641f4abefdd466c3ed8df", + "placeholder": "​", + "style": "IPY_MODEL_89a5b058a9c2496b8481bf7f8bea1298", + "tabbable": null, + "tooltip": null, + "value": " 50/50 [00:58<00:00,  1.18s/member]" + } + }, + "b2a3115505b84d518446cc148ca8c33d": { + "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 + } + }, + "b2d0befa969c4c9b978911b2744a1fcb": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_5b132f7755504bc393a50f091f3fa6e9", + "placeholder": "​", + "style": "IPY_MODEL_81f4660efa524a3faf163ab2767b1e97", + "tabbable": null, + "tooltip": null, + "value": "100%" + } + }, + "b3cdfe0152f548458c0bc3019cd6b428": { + "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": "2", + "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 + } + }, + "b4f01642f9644718add629bcbcdbf6e9": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "b51fa43ecc5545a3889a9198d647ccca": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_7c24db5964d34f54913be51fd172857d", + "IPY_MODEL_c91a165837784fbfbd90bdc204ad2e4d", + "IPY_MODEL_cbdca36e3c244602a5b4d637dba5c36c" + ], + "layout": "IPY_MODEL_7587dcfc7f41486abb396775da7660fa", + "tabbable": null, + "tooltip": null + } + }, + "b5c18eb8ee064799b9c12c83ca57d113": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_39be030fd9644a5eb35e15cdc3cf4ec9", + "placeholder": "​", + "style": "IPY_MODEL_d730e633c8cf46629c374d8227ea9630", + "tabbable": null, + "tooltip": null, + "value": "100%" + } + }, + "b68dd9f2336043c59ff07d7ffb0d74dc": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_bca7e8f8943b46d3a2607e3455fca0b1", + "max": 50, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_130761a0ddd54164a07195a4e7a1bb70", + "tabbable": null, + "tooltip": null, + "value": 50 + } + }, + "b9c456c08f8a4facba5d4b0b4be7a66e": { + "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 + } + }, + "bca7e8f8943b46d3a2607e3455fca0b1": { + "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": "2", + "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 + } + }, + "bdb35dc2318849c78cd07ddc0c520cb8": { + "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 + } + }, + "be316cf353494289817387971d1b6acb": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_d8c355e4db8b4a1383788e42f3e21e77", + "IPY_MODEL_5783dd68a2ca41b49fb452f80ee913f2", + "IPY_MODEL_01e1213a44454436abafeca43574cc22" + ], + "layout": "IPY_MODEL_75d29d891d4b450c93d044203703ae18", + "tabbable": null, + "tooltip": null + } + }, + "bea486d0275946e490dcae7cf2829935": { + "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 + } + }, + "c255eaf7afb34ee9bb5e3af9881a0209": { + "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": "inline-flex", + "flex": null, + "flex_flow": "row wrap", + "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": "110px" + } + }, + "c32fb56ba7e14ca9981c120f4bb4a482": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_809f813b1efb472dbff901d438416b29", + "IPY_MODEL_8b62b46b9a3245e3a18c942e85d021c2", + "IPY_MODEL_2a72dda652254b5788d0fb0a38f8faa6" + ], + "layout": "IPY_MODEL_6a32108836354991ac27f72db064f126", + "tabbable": null, + "tooltip": null + } + }, + "c3c4fb661f27426e9929aa8ea1977806": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_ea972fafb01d4f5bbc17470b2ed47998", + "max": 50, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_478ca2dea8bf42029b5085a12960a070", + "tabbable": null, + "tooltip": null, + "value": 50 + } + }, + "c4ef5bd9575246039b3543afe31ce1fd": { + "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": "inline-flex", + "flex": null, + "flex_flow": "row wrap", + "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": "110px" + } + }, + "c5650e87e6d24ee5905716d99ffd207f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "c91a165837784fbfbd90bdc204ad2e4d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_9e667d9b2e814d48a0f2cf546842a549", + "max": 50, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_5dc20b3cb0854f7dbf04a107b89e4e7a", + "tabbable": null, + "tooltip": null, + "value": 50 + } + }, + "c931a099e5564930a4c68990121c2ec4": { + "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 + } + }, + "cbdca36e3c244602a5b4d637dba5c36c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_384d21d346a444ce98d14e40b4e35749", + "placeholder": "​", + "style": "IPY_MODEL_123707f619ac436984b664551fa4014f", + "tabbable": null, + "tooltip": null, + "value": " 50/50 [00:59<00:00,  1.01s/member]" + } + }, + "cc643eb345814d9ca6912ecfcfb23fbe": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_b3cdfe0152f548458c0bc3019cd6b428", + "max": 50, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_f56247bb6e4c42fc96743acc38f63206", + "tabbable": null, + "tooltip": null, + "value": 50 + } + }, + "cfce8e606c3140b1bbc713b956566c96": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "d0de9ccb8c6543ab98ab652c7fd86281": { + "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 + } + }, + "d110dd3b58f74b92b3fca12541c9bf45": { + "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 + } + }, + "d2eee8655d034c95bc6c825f7a4c41ef": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": "#285475", + "description_width": "" + } + }, + "d65fbb9be95248d2aa206cfc444bad7c": { + "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": "2", + "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 + } + }, + "d730e633c8cf46629c374d8227ea9630": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "d89ce4c0e20549fd998c5ecfdb6e661e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_352322ff263d4f25a4869bea170ffb68", + "placeholder": "​", + "style": "IPY_MODEL_acd94192627c48c29e264479e9a39e13", + "tabbable": null, + "tooltip": null, + "value": "100%" + } + }, + "d8c355e4db8b4a1383788e42f3e21e77": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_92767ae95c3742e8844cdaf85539371f", + "placeholder": "​", + "style": "IPY_MODEL_94a1e72511474cccbd491b45b603358b", + "tabbable": null, + "tooltip": null, + "value": "100%" + } + }, + "da04c3a78e65413296925c1fd76221fe": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "da8c2ae5f69f47aaa114064720aaf9ee": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "dc8c1fff14e34f4e952f12739d6069cd": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_2d35bf4a51434626824f4def92922ba4", + "placeholder": "​", + "style": "IPY_MODEL_6b69a49648b84f128f7b3d0baa974f3b", + "tabbable": null, + "tooltip": null, + "value": " 50/50 [00:59<00:00,  1.27member/s]" + } + }, + "dca41931aa01454cb4d7f8cdb36d1541": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_99195a7b8062422ea789b42170cf0c3f", + "IPY_MODEL_206ec578b05f4fe2b69d2f6010b3262e", + "IPY_MODEL_1613a6cc6b5b419886b3d3d84e4b2fa6" + ], + "layout": "IPY_MODEL_ae4ee3cf360b4b838c75ba794b9dd9c9", + "tabbable": null, + "tooltip": null + } + }, + "dd07918f0a8b414ba1eea7eb2d603470": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_7bb488d009664b0c8ae2c43d5d202480", + "placeholder": "​", + "style": "IPY_MODEL_33a1f63cd55b4975b786eadb9439f7fd", + "tabbable": null, + "tooltip": null, + "value": " 50/50 [00:59<00:00,  1.39s/member]" + } + }, + "df18f1a39f6b4daaba1afb144142b0f4": { + "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": "inline-flex", + "flex": null, + "flex_flow": "row wrap", + "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": "110px" + } + }, + "dff9c0eb7534495db89e4b25b9c7d085": { + "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 + } + }, + "e1fb366a52b34de197af74eab00d387a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_a4e57bd5e52941c0b247965dee2c9232", + "placeholder": "​", + "style": "IPY_MODEL_2462feba103c48679bc09354a26194dd", + "tabbable": null, + "tooltip": null, + "value": "100%" + } + }, + "e44c0d724aaf4d94a411fb63f4466db3": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "e5039ef76ac0424c9b00e3186e90e918": { + "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 + } + }, + "ea972fafb01d4f5bbc17470b2ed47998": { + "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": "2", + "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 + } + }, + "ef6b0ad2d1154f839aae1adcc4f39881": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_824b7f2b2dbd411f9dbcda87af84e3e1", + "placeholder": "​", + "style": "IPY_MODEL_fb71544da5004e7d9979f683dde56a78", + "tabbable": null, + "tooltip": null, + "value": "100%" + } + }, + "f1719420bf91470fa8b1c9e3ee566e96": { + "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 + } + }, + "f56247bb6e4c42fc96743acc38f63206": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": "#285475", + "description_width": "" + } + }, + "fb71544da5004e7d9979f683dde56a78": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "fda2280226604412957928b2158916f2": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": "#285475", + "description_width": "" + } + }, + "feb12119c51641ea875d1a952ac3d33c": { + "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": "inline-flex", + "flex": null, + "flex_flow": "row wrap", + "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": "110px" + } + } + }, + "version_major": 2, + "version_minor": 0 + } + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/docs/tutorials/pipt/TinyBox/var.csv b/docs/tutorials/pipt/TinyBox/var.csv new file mode 100644 index 00000000..311405f0 --- /dev/null +++ b/docs/tutorials/pipt/TinyBox/var.csv @@ -0,0 +1,11 @@ +dates,WOPR:PRO1,WWPR:PRO1,WOPR:PRO2,WWPR:PRO2,WOPR:PRO3,WWPR:PRO3,WWIR:INJ1 +2023-02-05,"['abs', 64714.51555940867]","['abs', 2.5e-05]","['abs', 53006.20364159585]","['abs', 2.5e-05]","['abs', 75572.02344114544]","['abs', 2.5e-05]","['abs', 228295.31299497845]" +2024-03-11,"['abs', 72005.52490141928]","['abs', 2.5e-05]","['abs', 59489.10357463897]","['abs', 2.5e-05]","['abs', 84904.68326119422]","['abs', 2.5e-05]","['abs', 232533.7455611825]" +2025-04-15,"['abs', 74420.87898800136]","['abs', 0.0029635718717032945]","['abs', 62011.39569939673]","['abs', 2.5e-05]","['abs', 88789.40616603433]","['abs', 2.5e-05]","['abs', 234231.7060986424]" +2026-05-20,"['abs', 74611.04253666938]","['abs', 0.09251302936114372]","['abs', 63107.241773977876]","['abs', 0.0007906031215186094]","['abs', 90782.60214096308]","['abs', 2.5e-05]","['abs', 234865.08211899758]" +2027-06-24,"['abs', 72723.10451214077]","['abs', 1.3532305885950429]","['abs', 63461.174605322485]","['abs', 0.013603748416790611]","['abs', 91984.77374912798]","['abs', 0.00016005909757269346]","['abs', 233902.86990098003]" +2028-07-28,"['abs', 68082.18687784435]","['abs', 12.463081029571041]","['abs', 63341.70655803919]","['abs', 0.14424784817602815]","['abs', 92835.3355427766]","['abs', 0.0016736278241652608]","['abs', 230388.84388504986]" +2029-09-01,"['abs', 59420.88245888293]","['abs', 82.06356681084495]","['abs', 62875.476794462804]","['abs', 1.120348366509652]","['abs', 93673.44690725567]","['abs', 0.012652009782756438]","['abs', 223720.96276749615]" +2030-10-06,"['abs', 48049.90297704935]","['abs', 472.5608325339854]","['abs', 61308.383524160985]","['abs', 7.005920003679094]","['abs', 94415.72009954992]","['abs', 0.07597206624582725]","['abs', 214715.6213507867]" +2031-11-10,"['abs', 37061.043856203556]","['abs', 1799.204850735106]","['abs', 57011.8800444752]","['abs', 32.43802708799253]","['abs', 94799.04237365723]","['abs', 0.38099257542716264]","['abs', 205006.57133285762]" +2032-12-14,"['abs', 28670.046089086034]","['abs', 4556.822680347599]","['abs', 49997.92515309535]","['abs', 153.62188954786924]","['abs', 94529.79603996516]","['abs', 1.6433666978100612]","['abs', 196207.7551467857]" diff --git a/docs/tutorials/pipt/extending/adding_a_scheme.ipynb b/docs/tutorials/pipt/extending/adding_a_scheme.ipynb new file mode 100644 index 00000000..895f0b19 --- /dev/null +++ b/docs/tutorials/pipt/extending/adding_a_scheme.ipynb @@ -0,0 +1,9569 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "c78d4a9d", + "metadata": {}, + "source": [ + "# Adding a new scheme\n", + "\n", + "A **scheme** owns the *iteration policy*: how many steps to take, whether to\n", + "accept or reject one, how to damp, and when to stop. The per-iteration\n", + "mathematics belongs to the analysis instead — see\n", + "[Adding a new analysis](adding_an_analysis.ipynb).\n", + "\n", + "Roughly:\n", + "\n", + "| | owns |\n", + "| --- | --- |\n", + "| analysis | one step: ensemble + predictions -> update |\n", + "| scheme | the loop around it: accept/reject, damping, stopping |\n", + "| ensemble | the data: state realisations, observations, simulator |" + ] + }, + { + "cell_type": "markdown", + "id": "3a839553", + "metadata": {}, + "source": [ + "## What you inherit\n", + "\n", + "Concrete schemes subclass `AssimilationScheme`, one class holding both the\n", + "algorithm core and the run workflow (artifact saving, diagnostics, outlier\n", + "handling):" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "aee642f1", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-28T12:56:28.341575Z", + "iopub.status.busy": "2026-08-28T12:56:28.341366Z", + "iopub.status.idle": "2026-08-28T12:56:29.176691Z", + "shell.execute_reply": "2026-08-28T12:56:29.175967Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " AssimilationScheme\n", + " AnalysisBindingMixin\n", + " RestartMixin\n", + " ABC\n", + " object\n" + ] + } + ], + "source": [ + "from pipt.update_schemes.core import AssimilationScheme\n", + "\n", + "for c in AssimilationScheme.__mro__:\n", + " print(\" \", c.__name__)" + ] + }, + { + "cell_type": "markdown", + "id": "5a149fd6", + "metadata": {}, + "source": [ + "That one class gives you the iteration loop, convergence bookkeeping, restart\n", + "handling, the run table, the result object, analysis binding, the ensemble\n", + "façade, and the artifacts a run writes.\n", + "\n", + "## What the base calls, and when\n", + "\n", + "`run_assimilation()` drives this sequence. Everything marked **▸** is yours to\n", + "override; each already does something sensible, so you override only what you\n", + "want to change.\n", + "\n", + "```\n", + "run_assimilation()\n", + "│\n", + "├─ run_forecast(prior) forecast the prior ensemble\n", + "│ └─ after_forecast(state) ▸ may resample members; returns state\n", + "├─ record_prior_score() scores the prior, through your score()\n", + "├─ after_prior_forecast() ▸ prior QA/QC, prior artifacts\n", + "│\n", + "├─ while iteration < maxiter:\n", + "│ ├─ update_step() ▸ REQUIRED — returns a StepReport\n", + "│ ├─ log_update() one row per accepted iteration\n", + "│ ├─ after_accepted_iteration()▸ savedata, QA/QC — accepted steps only\n", + "│ ├─ check_misfit_convergence() generic; on unless misfit_tol = 0\n", + "│ ├─ check_state_convergence() generic; on unless step_tol = 0\n", + "│ └─ check_convergence() ▸ your own stopping criterion\n", + "│\n", + "└─ after_loop(converged) ▸ posterior, stop reason, summary\n", + "```\n", + "\n", + "The two generic criteria are **on by default** (`misfit_tol=0.01`,\n", + "`step_tol=1e-8`). Every shipped scheme passes `0.0` for both, because it\n", + "decides for itself in `check_convergence()` — do the same unless you want\n", + "them, or a scheme that merely stops moving the state will report itself\n", + "converged.\n", + "\n", + "`update_step()` is the only one you must write. **One call is one iteration.**\n", + "If your scheme retries — backtracking a step length, re-damping, resampling —\n", + "that loop goes *inside* `update_step()`, the way `EnOpt.update_step` in popt\n", + "backtracks over its own step length before returning. LM-EnRML and GN-EnRML\n", + "iterate their λ and γ there.\n", + "\n", + "The `StepReport` you return then describes the iteration as a whole. Set\n", + "`accepted=False` when you have run out of attempts: the loop takes that as\n", + "\"this scheme has nothing better to offer\", leaves the state uncommitted and\n", + "stops the run — it will not ask again for a step you just said you could not\n", + "find.\n", + "\n", + "If you stop on your own criterion, set `self.conv_msg` when you do — the two\n", + "generic checks set it themselves, but yours is the only thing that can explain\n", + "your own stop, and a run that ends without one reports no stopping reason.\n", + "\n", + "### What is *not* on that list\n", + "\n", + "There is no `after_analysis` hook on the base. That point exists only *inside*\n", + "`update_step()`, and the base does not dictate the shape of your step — it\n", + "calls `update_step()` and nothing within it. `AssimilationWorkflowMixin`\n", + "declares and implements one for schemes that inherit `AssimilationScheme`, and\n", + "the scheme calls it from its own step, as the example below does." + ] + }, + { + "cell_type": "markdown", + "id": "bbe063fb", + "metadata": {}, + "source": [ + "## What `update_step()` must report\n", + "\n", + "The base does not inspect *how* you take a step, but it needs to know what the\n", + "step produced. That is the return value:\n", + "\n", + "```python\n", + "@dataclass(slots=True)\n", + "class StepReport:\n", + " accepted: bool # keep this step, or retry?\n", + " state: Any # the state this attempt produced\n", + " misfit: np.ndarray # per-realisation data misfit, as of now\n", + " why_stop: dict | None = None # merged into result.why_stop\n", + "```\n", + "\n", + "The three required fields are positional, so leaving one out is a `TypeError`\n", + "where you wrote it — not a `None` surfacing three iterations later. The loop\n", + "commits `state` when `accepted`, and discards it otherwise.\n", + "\n", + "The loop derives the scalars from the one array:\n", + "\n", + "```python\n", + "self.ensemble_misfit = misfit\n", + "self.data_misfit_mean = float(misfit.mean())\n", + "self.data_misfit_std = float(misfit.std())\n", + "```\n", + "\n", + "so those three can no longer drift apart, which they could when each scheme\n", + "assigned them separately.\n", + "\n", + "**\"As of now\" is deliberate.** A scheme that rejects a step reports the misfit\n", + "it wants the loop to record — for LM-EnRML that is the *last accepted* one,\n", + "restored when it backs off, because that is what the next comparison is\n", + "against.\n", + "\n", + "### Still yours to do\n", + "\n", + "| do | why |\n", + "| --- | --- |\n", + "| `self.prev_data_misfit_mean = self.data_misfit_mean` before reporting | the relative-change test compares against it |\n", + "| — | the base records the prior misfit for you, from `score()` |\n", + "| pass the trial state to `self.run_forecast(state)` | it returns the state actually forecast |\n", + "| call `self.after_analysis()` | the workflow hook between analysis and forecast |\n", + "\n", + "```python\n", + "enX_trial = self.enX + step # a local value; nothing is parked\n", + "enX_trial = self.run_forecast(enX_trial) # may come back with members resampled\n", + "return StepReport(accepted=True, state=enX_trial, misfit=misfit)\n", + "```\n", + "\n", + "You do **not** commit the state, or set `self.step_accepted` — the loop does\n", + "both from the report, committing `state` when `accepted` and discarding it\n", + "otherwise. The trial state never touches the ensemble at all: it is a local\n", + "value you pass to `run_forecast` and hand back in the report.\n", + "\n", + "`data_misfit_mean`, `data_misfit_std` and `ensemble_misfit` are likewise\n", + "derived from the report, so you need not maintain them. But the loop only\n", + "does that *after* `update_step` returns, so if you want a value **during** the\n", + "step — to decide whether to accept, as LM-EnRML does — compute it yourself\n", + "with `self.score()`. The loop then records the same number.\n", + "\n", + "The run table is the loop's too: it logs one row per accepted iteration, so\n", + "you do not call `log_update()` yourself. Override `log_columns()` if you want\n", + "your control parameter in it.\n", + "\n", + "### One definition of the misfit: `score()`\n", + "\n", + "`score(pred_data=None)` returns the per-realisation data misfit of a forecast.\n", + "The base implements the one every shipped scheme uses,\n", + "\n", + "```python\n", + "at.calc_objectivefun(self.enObs, self.pred_data.matrix, self.cov_data)\n", + "```\n", + "\n", + "so a scheme that binds `enObs` and `cov_data` in `__init__` — as the example\n", + "below does — gets it for nothing. Override it only if you score differently:\n", + "ES-MDA scores against its *un-inflated* perturbations, the EnKF family against\n", + "the Cholesky factor rather than the full covariance.\n", + "\n", + "It is called in two places, which is the reason it exists:\n", + "\n", + "- **the prior**, by `record_prior_score()`, after the prior forecast and\n", + " before the loop. That is what makes `prior_data_misfit_mean` the *prior's*\n", + " misfit — computing it on the first pass through `update_step` instead would\n", + " record the misfit after one step and label it the prior.\n", + "- **every attempt inside your step**, wherever you need a number to decide on." + ] + }, + { + "cell_type": "markdown", + "id": "bb2b769e", + "metadata": {}, + "source": [ + "## The façade rule\n", + "\n", + "Reads of ensemble state go through the scheme; **writes go to the ensemble\n", + "explicitly**:\n", + "\n", + "```python\n", + "x = self.enX # read -- a property on the scheme\n", + "self.ensemble.list_states = [...] # write -- explicit, via the ensemble\n", + "```\n", + "\n", + "A read-only property has no setter, so a stray `self.enX = ...` raises rather\n", + "than silently creating a copy the forecast never sees.\n", + "\n", + "The state you are *working on* is not written to the ensemble at all. A trial\n", + "state stays a local value: you pass it to `run_forecast` and return it in the\n", + "`StepReport`, and the loop commits it to `ensemble.enX` if the step was\n", + "accepted. Four names are the\n", + "exception and *do* have setters, because a scheme may legitimately compute\n", + "them itself: `cov_data`, `scale_data`, `proj`, `Am`." + ] + }, + { + "cell_type": "markdown", + "id": "173669ff", + "metadata": {}, + "source": [ + "## A worked example\n", + "\n", + "A smoother that takes a fixed fraction of each analysis step and never\n", + "rejects — simpler than LM-EnRML, but a complete scheme." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "a837ccbb", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-28T12:56:29.178674Z", + "iopub.status.busy": "2026-08-28T12:56:29.178426Z", + "iopub.status.idle": "2026-08-28T12:56:29.188963Z", + "shell.execute_reply": "2026-08-28T12:56:29.188369Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "defined FixedStepSmoother\n" + ] + } + ], + "source": [ + "from copy import deepcopy\n", + "import numpy as np\n", + "import pipt.misc_tools.analysis_tools as at\n", + "from geostat.decomp import Cholesky\n", + "from pipt.ensembles import AssimilationEnsemble\n", + "from pipt.update_schemes.core import AssimilationScheme, StepReport\n", + "from pipt.update_schemes.analysis.approx import approx_update\n", + "\n", + "\n", + "class FixedStepSmoother(AssimilationScheme):\n", + " \"\"\"Iterative smoother taking a fixed fraction of each analysis step.\"\"\"\n", + "\n", + " ENSEMBLE_CLASS = AssimilationEnsemble\n", + " COMPATIBLE_ANALYSES = {\"approx\": approx_update}\n", + "\n", + " def __init__(self, keys_da, keys_en, sim, analysis=None):\n", + "\n", + " # Initialize the ensemble class\n", + " ensemble = self.ENSEMBLE_CLASS(keys_da, keys_en, sim)\n", + "\n", + " # Initialize the base class\n", + " super().__init__(\n", + " ensemble, \n", + " misfit_tol=0.0, # zero tolerances switch off generic criteria\n", + " step_tol=0.0 # zero tolerances switch off generic criteria\n", + " )\n", + "\n", + " # Set up the analysis method for this scheme (will be approx_update)\n", + " self.bind_analysis(self.resolve_analysis(analysis, keys_da))\n", + "\n", + " # Set up the scheme-specific parameters\n", + " opts = self.keys_da.get(\"iteration\", {})\n", + " self.maxiter = opts.get(\"max_iter\", 5)\n", + " self.gamma = opts.get(\"gamma\", 0.5) # fixed step length\n", + " self.lam = 0.0 # no damping -- but the analysis reads it\n", + " self.trunc_energy = self.keys_da.get(\"energy\", 0.98)\n", + " self.iteration = self.ensemble.iteration = 0\n", + " self.prev_data_misfit_mean = None\n", + "\n", + " # The ensemble does not build these; the scheme owns them.\n", + " self.ensemble.prior_enX = deepcopy(self.enX)\n", + " self.ensemble.list_states = list(self.idX)\n", + " self.ensemble.list_datatypes = self.keys_da[\"datatype\"]\n", + " self.vecObs = self.obs_vector\n", + " self.enObs = self.ensemble.perturb_observations(self.vecObs)\n", + " self.cov_data = self.obs_variance\n", + "\n", + " # No score() override: the base's default is\n", + " # calc_objectivefun(enObs, pred_data, cov_data), and __init__ bound both\n", + " # of those above. The base scores the prior with it before the loop, and\n", + " # update_step() below calls it for each iteration.\n", + "\n", + " def update_step(self) -> StepReport:\n", + " # Prediction ensemble matrix\n", + " self.enPred = self.pred_data.matrix\n", + "\n", + " # Calulate step\n", + " step = self.update(\n", + " enX=self.enX, \n", + " enY=self.enPred, \n", + " enE=self.enObs\n", + " )\n", + "\n", + " # A local proposal -- nothing is written to the ensemble until the\n", + " # loop commits what we report.\n", + " enX_trial = self.enX + self.gamma * step\n", + " self.after_analysis()\n", + "\n", + " # Forecast it. run_forecast hands back the state actually used (can be resampled by outlier replacement).\n", + " enX_trial = self.run_forecast(enX_trial)\n", + "\n", + " # Score the forecast -- the same score() the base used on the prior\n", + " self.prev_data_misfit_mean = self.data_misfit_mean\n", + " data_misfit = self.score()\n", + "\n", + " return StepReport(\n", + " accepted=True, \n", + " state=enX_trial,\n", + " misfit=data_misfit\n", + " )\n", + "\n", + " def log_columns(self, prior_run: bool = False) -> dict:\n", + " \"\"\"One trailing column in the run table: our fixed step length.\n", + "\n", + " ES-MDA reports its inflation factor here and LM-EnRML its damping;\n", + " the rest of the row -- iteration, status, misfit, change -- is the\n", + " base's, which also decides when to log one.\n", + " \"\"\"\n", + " return {\"γ\": self.gamma}\n", + "\n", + " def check_convergence(self) -> bool:\n", + " return False # Run the full schedule (all iterations)\n", + "\n", + "print(\"defined\", FixedStepSmoother.__name__)" + ] + }, + { + "cell_type": "markdown", + "id": "956ea858", + "metadata": {}, + "source": [ + "## A case to run it on" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "fd5a8af4", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-28T12:56:29.190608Z", + "iopub.status.busy": "2026-08-28T12:56:29.190442Z", + "iopub.status.idle": "2026-08-28T12:56:29.235221Z", + "shell.execute_reply": "2026-08-28T12:56:29.234454Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "case ready: 60-cell state, 11 observations, ne=50\n" + ] + } + ], + "source": [ + "import os, tempfile\n", + "from copy import deepcopy\n", + "import numpy as np\n", + "from misc.structures import PETDataFrame\n", + "from simulator.simple_models import lin_1d\n", + "\n", + "# A 60-cell state observed at every 5th position. Pure numpy, runs instantly.\n", + "STATE_SIZE = 60\n", + "CFG_SIM = {\"reporttype\": \"position\", \"reportpoint\": list(range(5, STATE_SIZE, 5)),\n", + " \"datatype\": [\"value\"],\n", + " # NOTE: >1 is deliberate. lin_1d returns a shared internal object from\n", + " # run_fwd_sim, so a sequential run aliases every member onto the same\n", + " # prediction and the ensemble collapses to zero spread.\n", + " \"parallel\": 4}\n", + "\n", + "CFG_ENS = {\"ne\": 50, \"state\": \"x\",\n", + " \"prior_x\": {\"vario\": \"sph\", \"mean\": [0.0] * STATE_SIZE, \"var\": 1.0,\n", + " \"range\": 20.0, \"aniso\": 1.0, \"angle\": 0.0,\n", + " \"grid\": [STATE_SIZE, 1]}}\n", + "\n", + "def cfg_da(analysis, **iteration):\n", + " # Only what FixedStepSmoother actually reads. The Levenberg-Marquardt\n", + " # keys (lambda, lambda_factor, ...) belong to schemes that damp; this one\n", + " # takes a fixed fraction of each step instead.\n", + " it = {\"max_iter\": 20, \"gamma\": 0.5}\n", + " it.update(iteration)\n", + " return {\"scheme\": \"custom\", \"analysis\": analysis, \"energy\": 0.95,\n", + " \"obsname\": \"position\", \"data\": \"true_data.pkl\", \"datavar\": \"var.pkl\",\n", + " \"iteration\": it}\n", + "\n", + "def make_truth():\n", + " \"\"\"Write the synthetic observations the schemes below assimilate.\n", + "\n", + " Returns the true state, so the plots can compare against it.\n", + " \"\"\"\n", + " np.random.seed(10)\n", + " sim = lin_1d(CFG_SIM); sim.setup_fwd_run()\n", + " state = {\"x\": np.random.multivariate_normal(np.zeros(STATE_SIZE), np.eye(STATE_SIZE))}\n", + " pred = PETDataFrame.from_records(sim.run_fwd_sim(state, 0), index=CFG_SIM[\"reportpoint\"])\n", + " data, var = pred.copy(), pred.copy()\n", + " for c in data.columns:\n", + " data[c] = data[c].apply(np.squeeze)\n", + " var[c] = var[c].apply(lambda _: [\"abs\", 1.0])\n", + " data.to_pickle(\"true_data.pkl\"); var.to_pickle(\"var.pkl\")\n", + " return state[\"x\"]\n", + "\n", + "os.chdir(tempfile.mkdtemp()) # keep run artifacts out of the docs tree\n", + "TRUE_STATE = make_truth()\n", + "OBS_AT = CFG_SIM[\"reportpoint\"]\n", + "print(f\"case ready: {STATE_SIZE}-cell state, {len(OBS_AT)} observations, ne={CFG_ENS['ne']}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "a6bed280", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-28T12:56:29.237520Z", + "iopub.status.busy": "2026-08-28T12:56:29.237211Z", + "iopub.status.idle": "2026-08-28T12:56:31.473923Z", + "shell.execute_reply": "2026-08-28T12:56:31.473499Z" + } + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2026-08-28│14:56:29 : =========== Running Data Assimilation - CUSTOM ===========\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "068c9a6e209646f087f3dbcd4c5fcebf", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + " 0%| | 0/50 [00:00 6.24 iterations=20\n", + "stopped because: Maximum number of iterations reached\n" + ] + } + ], + "source": [ + "np.random.seed(10)\n", + "res = FixedStepSmoother.assimilate(cfg_da(\"approx\"), deepcopy(CFG_ENS),\n", + " lin_1d(CFG_SIM), analysis=\"approx\")\n", + "print(f\"misfit {res.prior_data_misfit:7.2f} -> {res.data_misfit:6.2f}\"\n", + " f\" iterations={res.nit}\")\n", + "print(\"stopped because:\", res.message)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "b4e4d967", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-28T12:56:31.475252Z", + "iopub.status.busy": "2026-08-28T12:56:31.475146Z", + "iopub.status.idle": "2026-08-28T12:56:31.678082Z", + "shell.execute_reply": "2026-08-28T12:56:31.677523Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "\n", + "fig, ax = plt.subplots(figsize=(10, 4))\n", + "ax.plot(TRUE_STATE, \"k-\", lw=2, label=\"true state\")\n", + "ax.plot(np.asarray(res.x).mean(axis=-1), \"--\", lw=1.8, c=\"tab:green\",\n", + " label=\"posterior mean -- FixedStepSmoother\")\n", + "ax.scatter(OBS_AT, TRUE_STATE[OBS_AT], c=\"crimson\", zorder=5, s=25, label=\"observed\")\n", + "ax.set_xlabel(\"state index\"); ax.set_ylabel(\"value\")\n", + "ax.set_title(\"A scheme written from scratch, assimilating real observations\")\n", + "ax.legend(fontsize=8); plt.tight_layout(); plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "2d7295cf", + "metadata": {}, + "source": [ + "## Making it available from a config\n", + "\n", + "The class works directly, as above. To reach it the way the built-in schemes\n", + "are reached — by name from a config's `scheme` / `analysis` keys — register\n", + "the combination:" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "2b8f5b02", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-28T12:56:31.679382Z", + "iopub.status.busy": "2026-08-28T12:56:31.679271Z", + "iopub.status.idle": "2026-08-28T12:56:31.682422Z", + "shell.execute_reply": "2026-08-28T12:56:31.681729Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "registry resolves to: \n", + "('fixedstep', 'approx') in available_schemes(): True\n" + ] + } + ], + "source": [ + "from pipt.update_schemes import registry\n", + "\n", + "registry.register_scheme(\"fixedstep\", \"approx\", FixedStepSmoother, overwrite=True)\n", + "\n", + "ctor = registry.get_scheme(\"fixedstep\", \"approx\")\n", + "print(\"registry resolves to:\", ctor.func.__name__ if hasattr(ctor, \"func\") else ctor)\n", + "print(\"('fixedstep', 'approx') in available_schemes():\",\n", + " (\"fixedstep\", \"approx\") in registry.available_schemes())" + ] + }, + { + "cell_type": "markdown", + "id": "bb3ee5e5", + "metadata": {}, + "source": [ + "## Checklist\n", + "\n", + "**Wiring**\n", + "\n", + "1. Subclass `AssimilationScheme`.\n", + "2. Set `ENSEMBLE_CLASS` and `COMPATIBLE_ANALYSES`.\n", + "3. In `__init__`: build the ensemble, call `super().__init__(...)`, then\n", + " `bind_analysis(resolve_analysis(...))`. Set what the analyses read\n", + " (`lam`, `trunc_energy`) and what the ensemble does not build for you\n", + " (`cov_data`, the observation vector).\n", + "\n", + "**The step**\n", + "\n", + "4. Implement `update_step()`, returning\n", + " `StepReport(accepted=..., state=..., misfit=...)` — `misfit` being the\n", + " per-realisation array. One call is one iteration: any retry loop over a\n", + " step length or damping parameter belongs inside it.\n", + "5. Inside it: call `self.after_analysis()`, pass the trial state to\n", + " `self.run_forecast(state)`, and report the state it hands back — that is\n", + " the one with any resampled members.\n", + "6. Set `self.prev_data_misfit_mean` before reporting the new misfit; the\n", + " relative-change test compares against it.\n", + "\n", + "**Easy to forget**\n", + "\n", + "7. Bind `enObs` and `cov_data` in `__init__` so the base's `score()` works —\n", + " that is what makes `prior_data_misfit_mean` the *prior's* misfit, since the\n", + " base scores the prior with it before the loop. Score some other way and\n", + " `score()` is the one method to override; leave the scheme with nothing to\n", + " score and the run dies in the closing summary with `NoneType > float`.\n", + "8. Override `check_convergence()` if the scheme stops on its own criterion,\n", + " and set `self.conv_msg` when it fires — otherwise the run reports no\n", + " stopping reason.\n", + "\n", + "**Optional**\n", + "\n", + "9. Override `log_columns()` to add your control parameter to the run table,\n", + " the way ES-MDA reports `α` and LM-EnRML `λ`. The rows themselves are the\n", + " loop's job — one per accepted iteration — so there is no `log_update()`\n", + " call for you to make.\n", + "10. `register_scheme(...)` if it should be reachable from a config.\n", + "\n", + "You never set `step_accepted` and never commit the state — the loop does both\n", + "from the report, along with `data_misfit_mean`, `data_misfit_std` and\n", + "`ensemble_misfit` once `update_step` returns." + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "venv-PET (3.12.3.final.0)", + "language": "python", + "name": "python3" + }, + "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.12.3" + }, + "widgets": { + "application/vnd.jupyter.widget-state+json": { + "state": { + "01d940561a964aa1a8e3dbdbbdfda101": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "05128e8391f74979a13418cf1888a00f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": "#285475", + "description_width": "" + } + }, + "0635ce168c5d4f118f4d8ee546135df4": { + "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": "inline-flex", + "flex": null, + "flex_flow": "row wrap", + "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": "110px" + } + }, + "068c9a6e209646f087f3dbcd4c5fcebf": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_6b2e7d039cd84c52b88515b439d8df41", + "IPY_MODEL_37ebd67f67184fb6951c8b5047bfde57", + "IPY_MODEL_54a5a5e420754f81ad23a5feeb517adc" + ], + "layout": "IPY_MODEL_36a28fb103654f16b3997f90244f5e91", + "tabbable": null, + "tooltip": null + } + }, + "06aa5630d7a24fc49e7cc7d0c3efaff0": { + "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 + } + }, + "07adccfd45404be1898982a04e81528f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_f65592161bfb49ac812ed2a3ab8a3c9f", + "placeholder": "​", + "style": "IPY_MODEL_f77006b071ae45af9d805740421532a6", + "tabbable": null, + "tooltip": null, + "value": " 50/50 [00:00<00:00, 774.87member/s]" + } + }, + "0839c1aea0ba42e2a90cc06988a4d086": { + "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": "inline-flex", + "flex": null, + "flex_flow": "row wrap", + "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": "110px" + } + }, + "0869143f90a240438477a2eea5138607": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "0b77aa0c66054dfc8c888f7b44d1ad05": { + "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 + } + }, + "0cf0ca03a49741cd9cbdc76ce368c5a1": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "0d423318aafb405e900e98c2dfcfe933": { + "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 + } + }, + "0d67f98d12db45d996f734631a1defee": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "0d8a60538336441ea0639273ad019d2b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_a50eaeff6d304ea4b7a9b9b510d43f64", + "IPY_MODEL_e3d0a44e682440b5ad84e419ef555328", + "IPY_MODEL_b3532ad3987646b6bfc3d3cd1c2593d2" + ], + "layout": "IPY_MODEL_2160a8ac5be4487c9eeab7ac0ab7da2e", + "tabbable": null, + "tooltip": null + } + }, + "0da1cde4235b42eb9df3ed4fac35581e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_e40d498c4891429ea551bed7466a2db6", + "max": 50.0, + "min": 0.0, + "orientation": "horizontal", + "style": "IPY_MODEL_a9be3c79b1d241f2aecb927fbf22fcbd", + "tabbable": null, + "tooltip": null, + "value": 50.0 + } + }, + "0e0798657e1c4dd78dcbbadab5b2c5a6": { + "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 + } + }, + "0fa31ad9e73f484396836a0b3e9fbd12": { + "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": "2", + "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 + } + }, + "10428edf608f4a7f9897571bfa0087ec": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_19c2c08dc7ad4c2fb68acd844547a8df", + "placeholder": "​", + "style": "IPY_MODEL_1779fc6ae57949008c8db5db762038ec", + "tabbable": null, + "tooltip": null, + "value": " 50/50 [00:00<00:00, 847.56member/s]" + } + }, + "11ce79a564864379b407db86ae60f103": { + "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 + } + }, + "13377971088b4d2e8c91fb0bb5e808b2": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_55c7c0ab59a14782abfde75466241250", + "placeholder": "​", + "style": "IPY_MODEL_f87d5ac42738409db92770cdb51e6198", + "tabbable": null, + "tooltip": null, + "value": " 50/50 [00:00<00:00, 873.15member/s]" + } + }, + "140f84c565504f5382b1ff8542623f4f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "163e0c4b0ae440dfb4d8541491d71c18": { + "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 + } + }, + "173546301df1453caa33df8f2562151f": { + "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 + } + }, + "1749598de2604775815987ba828d4237": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "175a39c344cd44579d5fd9cfea9b000e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_f7dfd3b8248549188315fc101f7b9e06", + "max": 50.0, + "min": 0.0, + "orientation": "horizontal", + "style": "IPY_MODEL_3dcdf151cc794fbb8b3a260c1d770d93", + "tabbable": null, + "tooltip": null, + "value": 50.0 + } + }, + "1779fc6ae57949008c8db5db762038ec": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "1832a47f09204296adc3694e6705d785": { + "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 + } + }, + "186d91e988c24817b936aad60a6c49d3": { + "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": "2", + "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 + } + }, + "196697e778894bdba10c682187446d1f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "19c2c08dc7ad4c2fb68acd844547a8df": { + "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 + } + }, + "1a6aa4419371497080481c4b605cff8a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_1fb56c63bb334cdc8f1d506fb35e0c95", + "IPY_MODEL_59fb0b5eb9c24fa1809b30b8aa655a5f", + "IPY_MODEL_28e4b64445194aa7a4b3c1d5445d5901" + ], + "layout": "IPY_MODEL_be45d566c0424db8a5a2870f753a09e5", + "tabbable": null, + "tooltip": null + } + }, + "1ae27156b1464a3f980e430bcf9117d0": { + "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 + } + }, + "1b25fcb730064d66934cd0d9719f0dae": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_72711bdd585d4f8eb5db7bd176f8754e", + "placeholder": "​", + "style": "IPY_MODEL_cffcdbd2281447c2bc0e1e5c95b24f92", + "tabbable": null, + "tooltip": null, + "value": " 50/50 [00:00<00:00, 799.09member/s]" + } + }, + "1b6199ccb576487fa6df553672d5de3c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_c49526424440466d897dcea322ed4000", + "placeholder": "​", + "style": "IPY_MODEL_a1aa039cbcea4017b0003327f4d6db33", + "tabbable": null, + "tooltip": null, + "value": "100%" + } + }, + "1b92bf14ccd24543b3bcd1e0e49cdafd": { + "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": "inline-flex", + "flex": null, + "flex_flow": "row wrap", + "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": "110px" + } + }, + "1f2c014cc96e44b19a8069840c9c2c28": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "1fb56c63bb334cdc8f1d506fb35e0c95": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_cde70242afe34e6f88b94321431ec156", + "placeholder": "​", + "style": "IPY_MODEL_edba730184f746b5b5c0768aec60af43", + "tabbable": null, + "tooltip": null, + "value": "100%" + } + }, + "1fe4a9657c05450e94133246348a48aa": { + "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": "2", + "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 + } + }, + "20e828a0084a417d806eca59dcab0d14": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_eade46797e8e49bdb1c4a145416b1402", + "placeholder": "​", + "style": "IPY_MODEL_add7cfc3c61a40599b51382e977b713b", + "tabbable": null, + "tooltip": null, + "value": "100%" + } + }, + "2160a8ac5be4487c9eeab7ac0ab7da2e": { + "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": "inline-flex", + "flex": null, + "flex_flow": "row wrap", + "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": "110px" + } + }, + "21b14d85808049db97d573f07c6e6ace": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_743c3f0a1d3c494c9d916dc3c8798a4c", + "IPY_MODEL_0da1cde4235b42eb9df3ed4fac35581e", + "IPY_MODEL_699068abe70e4b8abe5e9a910e50f1d3" + ], + "layout": "IPY_MODEL_368369d2abcc4801a622b4a0b0edd561", + "tabbable": null, + "tooltip": null + } + }, + "225a2380506d4f149dbd7ccea21877ec": { + "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": "2", + "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 + } + }, + "22ce8b3621e3467b8cca222a15c0020e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_4e8f34b4db7c4d6a806b9c3890490c5a", + "IPY_MODEL_3d0a9459eebe49529d236bf3cb7b825a", + "IPY_MODEL_29c83aae1ab140bc9d285dee4e673af5" + ], + "layout": "IPY_MODEL_b20959983fe24e999050f47974557815", + "tabbable": null, + "tooltip": null + } + }, + "250d0952eb674708980875bd946d49fa": { + "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": "2", + "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 + } + }, + "257072728c9b4d1d956a9f9d97548973": { + "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 + } + }, + "2600359b21cc4942b437442812ff2dd1": { + "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 + } + }, + "26fdb16608f243aabb24e4add6e94653": { + "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 + } + }, + "277c98d8993a419899c28550ccc6a7c3": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "28e4b64445194aa7a4b3c1d5445d5901": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_11ce79a564864379b407db86ae60f103", + "placeholder": "​", + "style": "IPY_MODEL_196697e778894bdba10c682187446d1f", + "tabbable": null, + "tooltip": null, + "value": " 50/50 [00:00<00:00, 726.57member/s]" + } + }, + "29c83aae1ab140bc9d285dee4e673af5": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_a4dc3e986a4d47449bf3b9e2bc106dce", + "placeholder": "​", + "style": "IPY_MODEL_277c98d8993a419899c28550ccc6a7c3", + "tabbable": null, + "tooltip": null, + "value": " 50/50 [00:00<00:00, 892.33member/s]" + } + }, + "2b0ae42f91d142e3ac8691a97040ee56": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "2bbb601665564fbe962820dcf95666c1": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_0fa31ad9e73f484396836a0b3e9fbd12", + "max": 50.0, + "min": 0.0, + "orientation": "horizontal", + "style": "IPY_MODEL_e284823d27eb4879af4f408d8bcac69d", + "tabbable": null, + "tooltip": null, + "value": 50.0 + } + }, + "2bce1f9ec5ee450ab33acd302fcfdc78": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_df7c47ffdb1540a292b6f61c76d3a6ac", + "placeholder": "​", + "style": "IPY_MODEL_8a6f2e265424425f94e833990f22c3a8", + "tabbable": null, + "tooltip": null, + "value": "100%" + } + }, + "2d769a221cb54085906300b0a7fa8781": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_5e0dd719045443229f461c875fb007f9", + "placeholder": "​", + "style": "IPY_MODEL_140f84c565504f5382b1ff8542623f4f", + "tabbable": null, + "tooltip": null, + "value": "100%" + } + }, + "2db5f58ce3374847a5ab935120374591": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_2bce1f9ec5ee450ab33acd302fcfdc78", + "IPY_MODEL_2bbb601665564fbe962820dcf95666c1", + "IPY_MODEL_7df6cd84d0bd4d14854891761d6399fd" + ], + "layout": "IPY_MODEL_40d7e65e2b4a446a96131434ec3b2cd9", + "tabbable": null, + "tooltip": null + } + }, + "31c4553b67d5491e8f0acaf180f2551f": { + "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": "inline-flex", + "flex": null, + "flex_flow": "row wrap", + "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": "110px" + } + }, + "3494878d36b7425b9bc5c616ea7e7b9e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_67ab031fc06f4086984e811851b500d4", + "IPY_MODEL_b00684aaa7c840fca02226a4e3654887", + "IPY_MODEL_1b25fcb730064d66934cd0d9719f0dae" + ], + "layout": "IPY_MODEL_e7713a3be59b4ddcaa2bf270347f407f", + "tabbable": null, + "tooltip": null + } + }, + "368369d2abcc4801a622b4a0b0edd561": { + "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": "inline-flex", + "flex": null, + "flex_flow": "row wrap", + "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": "110px" + } + }, + "36a28fb103654f16b3997f90244f5e91": { + "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": "inline-flex", + "flex": null, + "flex_flow": "row wrap", + "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": "110px" + } + }, + "36f5fd7c05fd4d33a6503334c555fca9": { + "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": "2", + "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 + } + }, + "37ebd67f67184fb6951c8b5047bfde57": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_66b13e41668d4a0c91d657d26e92d573", + "max": 50.0, + "min": 0.0, + "orientation": "horizontal", + "style": "IPY_MODEL_e370b1a97dab418286f3baade04e412f", + "tabbable": null, + "tooltip": null, + "value": 50.0 + } + }, + "39f5358d8124419a8ccb80fa49fe1884": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_8560a7e86e9b4746bfb67099c3133d02", + "placeholder": "​", + "style": "IPY_MODEL_903284b8f0c44bfd82d3144f5c02673e", + "tabbable": null, + "tooltip": null, + "value": " 50/50 [00:00<00:00, 782.15member/s]" + } + }, + "3a65fdc810f546afa53e8427ca6b689b": { + "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": "2", + "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 + } + }, + "3a85c921dd914354a99efed229449590": { + "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": "2", + "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 + } + }, + "3bfb9bda6da74f8e95b8231bce1bb962": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_9ecdfce8284b4df7a9d5f22252991d78", + "IPY_MODEL_5382defb5e294e11a0c0af2d1a51f0a9", + "IPY_MODEL_cdeb25e65fc74394ad2f83de4c5f235a" + ], + "layout": "IPY_MODEL_507ef50b6de54be3a7ae5bed4d1476f6", + "tabbable": null, + "tooltip": null + } + }, + "3d0a9459eebe49529d236bf3cb7b825a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_3a65fdc810f546afa53e8427ca6b689b", + "max": 50.0, + "min": 0.0, + "orientation": "horizontal", + "style": "IPY_MODEL_c8d2da14c1e942ce96736ced9e41d87a", + "tabbable": null, + "tooltip": null, + "value": 50.0 + } + }, + "3d6791f4be88468cb7aa3dd81803e781": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "3d9b586ecc4546f6b3c3827f27fe38f2": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "3dcdf151cc794fbb8b3a260c1d770d93": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": "#285475", + "description_width": "" + } + }, + "40d7e65e2b4a446a96131434ec3b2cd9": { + "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": "inline-flex", + "flex": null, + "flex_flow": "row wrap", + "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": "110px" + } + }, + "4532ed8b3f4f4970886382fd88014488": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_f2edabe430ba43f9a5e6913f22735c4f", + "placeholder": "​", + "style": "IPY_MODEL_5d401dc3b74e49348eaa838bd3300de9", + "tabbable": null, + "tooltip": null, + "value": " 50/50 [00:00<00:00, 913.33member/s]" + } + }, + "45a2d7239f57427eb24a718b171ebb23": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_f0dd0e311c9d4fb885309ccc054195d8", + "placeholder": "​", + "style": "IPY_MODEL_6bb3f6d0e6b34cccb8f4a61857afb007", + "tabbable": null, + "tooltip": null, + "value": " 50/50 [00:00<00:00, 682.99member/s]" + } + }, + "47a39ff3ebdc457daf15c61fdda2bda4": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_8d3d1d9761cc41219dc6364cb00daed6", + "placeholder": "​", + "style": "IPY_MODEL_3d9b586ecc4546f6b3c3827f27fe38f2", + "tabbable": null, + "tooltip": null, + "value": " 50/50 [00:00<00:00, 832.75member/s]" + } + }, + "489db73ab4fb420cb58aa218438c95f9": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_c6c4c68085b54bcbadf1fd8c167cbafe", + "IPY_MODEL_5187c3b471704612a362cd241c65b452", + "IPY_MODEL_07adccfd45404be1898982a04e81528f" + ], + "layout": "IPY_MODEL_0839c1aea0ba42e2a90cc06988a4d086", + "tabbable": null, + "tooltip": null + } + }, + "48a9cd92189a45b7a183f151520eeb99": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": "#285475", + "description_width": "" + } + }, + "4a15b5b8609947d485db13d1adda5103": { + "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": "2", + "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 + } + }, + "4aa2be5dbb364b2fa5aa12315c4db618": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_173546301df1453caa33df8f2562151f", + "placeholder": "​", + "style": "IPY_MODEL_62db6a0213bd4ea88834118882b028f9", + "tabbable": null, + "tooltip": null, + "value": "100%" + } + }, + "4b74b444aa3946b7828cd2b75bdd2fde": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_afe0080106fd4b12bb220bdc25df2a62", + "placeholder": "​", + "style": "IPY_MODEL_59e68172ad924ee799d073df28e83b0e", + "tabbable": null, + "tooltip": null, + "value": " 50/50 [00:00<00:00, 677.35member/s]" + } + }, + "4c7dfe4361094100b5d1cecf4ebee1fe": { + "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": "inline-flex", + "flex": null, + "flex_flow": "row wrap", + "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": "110px" + } + }, + "4ce95bee73bd4274be1f3056d007db9b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "4d486dee1d554502a7e7ed090de90fa1": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "4e8f34b4db7c4d6a806b9c3890490c5a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_c80f61196a2a4d789c9334fdb7517abf", + "placeholder": "​", + "style": "IPY_MODEL_a9b51b8dce364dd1a3d3852d81887303", + "tabbable": null, + "tooltip": null, + "value": "100%" + } + }, + "507ef50b6de54be3a7ae5bed4d1476f6": { + "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": "inline-flex", + "flex": null, + "flex_flow": "row wrap", + "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": "110px" + } + }, + "508af90930a44044a34cf9e727fc32f6": { + "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 + } + }, + "508c9c3505f64d2d9d14cd97fbb7c037": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_508af90930a44044a34cf9e727fc32f6", + "placeholder": "​", + "style": "IPY_MODEL_3d6791f4be88468cb7aa3dd81803e781", + "tabbable": null, + "tooltip": null, + "value": " 50/50 [00:00<00:00, 740.93member/s]" + } + }, + "50e114885bff4f63a990a4ebb5f0f5e4": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_1ae27156b1464a3f980e430bcf9117d0", + "placeholder": "​", + "style": "IPY_MODEL_0cf0ca03a49741cd9cbdc76ce368c5a1", + "tabbable": null, + "tooltip": null, + "value": "100%" + } + }, + "50f76fea29d7455eac9c98d984ff3b4c": { + "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": "inline-flex", + "flex": null, + "flex_flow": "row wrap", + "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": "110px" + } + }, + "5187c3b471704612a362cd241c65b452": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_3a85c921dd914354a99efed229449590", + "max": 50.0, + "min": 0.0, + "orientation": "horizontal", + "style": "IPY_MODEL_6abeb6e403084b6a84d8eb44ccba7ec9", + "tabbable": null, + "tooltip": null, + "value": 50.0 + } + }, + "5382defb5e294e11a0c0af2d1a51f0a9": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_9e03f2b9972047ff88cdce1b6f00bee3", + "max": 50.0, + "min": 0.0, + "orientation": "horizontal", + "style": "IPY_MODEL_f51bc035bbcf45cf80aced83995af96c", + "tabbable": null, + "tooltip": null, + "value": 50.0 + } + }, + "53ce8765bf3f46d89e8278f73430c078": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "54a5a5e420754f81ad23a5feeb517adc": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_61dc1f9a2f114c48a729772b3412997b", + "placeholder": "​", + "style": "IPY_MODEL_d40530f66d1d42bdbfcc1533c5f5e6c2", + "tabbable": null, + "tooltip": null, + "value": " 50/50 [00:00<00:00, 871.38member/s]" + } + }, + "55c7c0ab59a14782abfde75466241250": { + "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 + } + }, + "59dfb90322dd4a4098c591ab09573c50": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": "#285475", + "description_width": "" + } + }, + "59e68172ad924ee799d073df28e83b0e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "59fb0b5eb9c24fa1809b30b8aa655a5f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_1fe4a9657c05450e94133246348a48aa", + "max": 50.0, + "min": 0.0, + "orientation": "horizontal", + "style": "IPY_MODEL_85178a4ab92d480494ab8af414d5c185", + "tabbable": null, + "tooltip": null, + "value": 50.0 + } + }, + "5a7b8b2cce2540aca7a5f3af731cb1f2": { + "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": "inline-flex", + "flex": null, + "flex_flow": "row wrap", + "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": "110px" + } + }, + "5aa1adf8cae24b9b8aac0e12968911de": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": "#285475", + "description_width": "" + } + }, + "5bb715c2bca849f4b60c301a9b055cb8": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_ad15feebe6fc40ff9861d924053bb315", + "IPY_MODEL_6451cda5bd274cb0b797b96785d5ddeb", + "IPY_MODEL_c1c4246d213a497089738249e1343a16" + ], + "layout": "IPY_MODEL_31c4553b67d5491e8f0acaf180f2551f", + "tabbable": null, + "tooltip": null + } + }, + "5c90354dff5a474d8caa12db29693ee3": { + "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": "inline-flex", + "flex": null, + "flex_flow": "row wrap", + "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": "110px" + } + }, + "5cfbe09a2bf2473fbff9093879d6b071": { + "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": "inline-flex", + "flex": null, + "flex_flow": "row wrap", + "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": "110px" + } + }, + "5d401dc3b74e49348eaa838bd3300de9": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "5dc56b3f43bc4ae3b6faa4a4ed4150e4": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_67b87f1fdaae46be96f7711a9131206f", + "placeholder": "​", + "style": "IPY_MODEL_83a3dc0e738541879437407912c93904", + "tabbable": null, + "tooltip": null, + "value": " 50/50 [00:00<00:00, 827.59member/s]" + } + }, + "5e0dd719045443229f461c875fb007f9": { + "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 + } + }, + "6195895035fa432b80540a737a941af0": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "61dc1f9a2f114c48a729772b3412997b": { + "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 + } + }, + "62db6a0213bd4ea88834118882b028f9": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "6451cda5bd274cb0b797b96785d5ddeb": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_84779a311f1b4d4ab6a2fc16f1682ed3", + "max": 50.0, + "min": 0.0, + "orientation": "horizontal", + "style": "IPY_MODEL_edc692237fcf4efab7f46d136b3ec00f", + "tabbable": null, + "tooltip": null, + "value": 50.0 + } + }, + "66b13e41668d4a0c91d657d26e92d573": { + "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": "2", + "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 + } + }, + "67ab031fc06f4086984e811851b500d4": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_f9b846f6f2454780a727f94b29f93f4c", + "placeholder": "​", + "style": "IPY_MODEL_6195895035fa432b80540a737a941af0", + "tabbable": null, + "tooltip": null, + "value": "100%" + } + }, + "67b87f1fdaae46be96f7711a9131206f": { + "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 + } + }, + "6829acac35b2437faaa2f042e03573f4": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_b8805d2f363d4eb0867aaedeeb197a58", + "IPY_MODEL_175a39c344cd44579d5fd9cfea9b000e", + "IPY_MODEL_45a2d7239f57427eb24a718b171ebb23" + ], + "layout": "IPY_MODEL_1b92bf14ccd24543b3bcd1e0e49cdafd", + "tabbable": null, + "tooltip": null + } + }, + "699068abe70e4b8abe5e9a910e50f1d3": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_163e0c4b0ae440dfb4d8541491d71c18", + "placeholder": "​", + "style": "IPY_MODEL_53ce8765bf3f46d89e8278f73430c078", + "tabbable": null, + "tooltip": null, + "value": " 50/50 [00:00<00:00, 859.44member/s]" + } + }, + "6abeb6e403084b6a84d8eb44ccba7ec9": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": "#285475", + "description_width": "" + } + }, + "6b2e7d039cd84c52b88515b439d8df41": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_ea9ffc6ce48d4d4b895cf5c05c006325", + "placeholder": "​", + "style": "IPY_MODEL_e9cedb65a35849d18ad933cbe215c527", + "tabbable": null, + "tooltip": null, + "value": "100%" + } + }, + "6bb3f6d0e6b34cccb8f4a61857afb007": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "6d81e29b50a541c3ae8316b4f0a258e9": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": "#285475", + "description_width": "" + } + }, + "6d905674bd99489889e5849d66b438c8": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": "#285475", + "description_width": "" + } + }, + "6f8e28bf67e141df889e3e256751f26e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_92af1aa023bd4aac8dd2dedd8a4af028", + "IPY_MODEL_efc6065f452640588093c78c143e2cd1", + "IPY_MODEL_b3fdbfa7d1fd4e9ea00b55e2f006b2d0" + ], + "layout": "IPY_MODEL_0635ce168c5d4f118f4d8ee546135df4", + "tabbable": null, + "tooltip": null + } + }, + "7184db3ef3c14da9918e576ede941034": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": "#285475", + "description_width": "" + } + }, + "71c308f425434f82a76c391a0d712049": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_f85eb8a6710b4d7c9223cae3737059b3", + "max": 50.0, + "min": 0.0, + "orientation": "horizontal", + "style": "IPY_MODEL_d1c67222de624c2fa026dcf31cb091dc", + "tabbable": null, + "tooltip": null, + "value": 50.0 + } + }, + "72711bdd585d4f8eb5db7bd176f8754e": { + "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 + } + }, + "743c3f0a1d3c494c9d916dc3c8798a4c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_06aa5630d7a24fc49e7cc7d0c3efaff0", + "placeholder": "​", + "style": "IPY_MODEL_1f2c014cc96e44b19a8069840c9c2c28", + "tabbable": null, + "tooltip": null, + "value": "100%" + } + }, + "7609445effa444ac8b265b8670761ddb": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_9d33dd132ab24c5185069d8238639134", + "IPY_MODEL_f2cd621ec023498da52f01e85d763b70", + "IPY_MODEL_4b74b444aa3946b7828cd2b75bdd2fde" + ], + "layout": "IPY_MODEL_5cfbe09a2bf2473fbff9093879d6b071", + "tabbable": null, + "tooltip": null + } + }, + "766c366138c94545b221c60cfefe8452": { + "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": "2", + "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 + } + }, + "77572900ba854a459ae8541957e6f21c": { + "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": "inline-flex", + "flex": null, + "flex_flow": "row wrap", + "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": "110px" + } + }, + "7df65b69280842aebaf0388c2b26d6d0": { + "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": "2", + "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 + } + }, + "7df6cd84d0bd4d14854891761d6399fd": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_0e0798657e1c4dd78dcbbadab5b2c5a6", + "placeholder": "​", + "style": "IPY_MODEL_a0e8e84bb12447e5b825735b3e0a180f", + "tabbable": null, + "tooltip": null, + "value": " 50/50 [00:00<00:00, 634.78member/s]" + } + }, + "7fa54ae31705410ea0cc3bc7320cc0d9": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "83a3dc0e738541879437407912c93904": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "84779a311f1b4d4ab6a2fc16f1682ed3": { + "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": "2", + "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 + } + }, + "85178a4ab92d480494ab8af414d5c185": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": "#285475", + "description_width": "" + } + }, + "8560a7e86e9b4746bfb67099c3133d02": { + "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 + } + }, + "86efb839508a4885be60a8cfa720bdef": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_1b6199ccb576487fa6df553672d5de3c", + "IPY_MODEL_99eac504635e4da88dceda2633401fba", + "IPY_MODEL_8ac43b8a36b94699b0cf9654bcda702c" + ], + "layout": "IPY_MODEL_5c90354dff5a474d8caa12db29693ee3", + "tabbable": null, + "tooltip": null + } + }, + "8a6f2e265424425f94e833990f22c3a8": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "8ac43b8a36b94699b0cf9654bcda702c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_b969a15d9b024a0fb71be75071aafe48", + "placeholder": "​", + "style": "IPY_MODEL_4d486dee1d554502a7e7ed090de90fa1", + "tabbable": null, + "tooltip": null, + "value": " 50/50 [00:00<00:00, 764.61member/s]" + } + }, + "8b48a5799151484c8aa39e26b5b39708": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": "#285475", + "description_width": "" + } + }, + "8cfa4bcf27d24045a83d6854d5bced29": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_26fdb16608f243aabb24e4add6e94653", + "placeholder": "​", + "style": "IPY_MODEL_1749598de2604775815987ba828d4237", + "tabbable": null, + "tooltip": null, + "value": "100%" + } + }, + "8d1c41da15f04d899382221629c11fa3": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_225a2380506d4f149dbd7ccea21877ec", + "max": 50.0, + "min": 0.0, + "orientation": "horizontal", + "style": "IPY_MODEL_5aa1adf8cae24b9b8aac0e12968911de", + "tabbable": null, + "tooltip": null, + "value": 50.0 + } + }, + "8d3d1d9761cc41219dc6364cb00daed6": { + "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 + } + }, + "903284b8f0c44bfd82d3144f5c02673e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "90a1047bd2e54c548bf5d23d8189b00b": { + "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": "2", + "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 + } + }, + "92735b86e56f4284b7f8d722b7a61945": { + "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 + } + }, + "92af1aa023bd4aac8dd2dedd8a4af028": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_257072728c9b4d1d956a9f9d97548973", + "placeholder": "​", + "style": "IPY_MODEL_998a701b16da4afb958bc5fe31a808e6", + "tabbable": null, + "tooltip": null, + "value": "100%" + } + }, + "97e26a3c43064015bcf64639f9272f77": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_99ed4cae955b4a1bacab7e9fc02befc3", + "IPY_MODEL_b2b8c19e07e8494c883b107fbc3bcab3", + "IPY_MODEL_5dc56b3f43bc4ae3b6faa4a4ed4150e4" + ], + "layout": "IPY_MODEL_4c7dfe4361094100b5d1cecf4ebee1fe", + "tabbable": null, + "tooltip": null + } + }, + "998a701b16da4afb958bc5fe31a808e6": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "99eac504635e4da88dceda2633401fba": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_186d91e988c24817b936aad60a6c49d3", + "max": 50.0, + "min": 0.0, + "orientation": "horizontal", + "style": "IPY_MODEL_dffe51f537514dba9ffd1edacc6c301a", + "tabbable": null, + "tooltip": null, + "value": 50.0 + } + }, + "99ed4cae955b4a1bacab7e9fc02befc3": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_f27c7f2dbad54d158158c421708070ee", + "placeholder": "​", + "style": "IPY_MODEL_f80640cee4374bfdacdfd917706d5faa", + "tabbable": null, + "tooltip": null, + "value": "100%" + } + }, + "9cfd0bc8bdce4ee498f53bb879c13352": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_f83d302c90574de7b3405d54ed6a46a4", + "IPY_MODEL_71c308f425434f82a76c391a0d712049", + "IPY_MODEL_39f5358d8124419a8ccb80fa49fe1884" + ], + "layout": "IPY_MODEL_50f76fea29d7455eac9c98d984ff3b4c", + "tabbable": null, + "tooltip": null + } + }, + "9d33dd132ab24c5185069d8238639134": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_0b77aa0c66054dfc8c888f7b44d1ad05", + "placeholder": "​", + "style": "IPY_MODEL_2b0ae42f91d142e3ac8691a97040ee56", + "tabbable": null, + "tooltip": null, + "value": "100%" + } + }, + "9e03f2b9972047ff88cdce1b6f00bee3": { + "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": "2", + "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 + } + }, + "9ecdfce8284b4df7a9d5f22252991d78": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_1832a47f09204296adc3694e6705d785", + "placeholder": "​", + "style": "IPY_MODEL_0d67f98d12db45d996f734631a1defee", + "tabbable": null, + "tooltip": null, + "value": "100%" + } + }, + "a0e8e84bb12447e5b825735b3e0a180f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "a1aa039cbcea4017b0003327f4d6db33": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "a4dc3e986a4d47449bf3b9e2bc106dce": { + "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 + } + }, + "a50eaeff6d304ea4b7a9b9b510d43f64": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_ac75d07f1bc74407939ebafb73125e87", + "placeholder": "​", + "style": "IPY_MODEL_4ce95bee73bd4274be1f3056d007db9b", + "tabbable": null, + "tooltip": null, + "value": "100%" + } + }, + "a6ea0b4944244487bb07f95788156fc4": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "a9b51b8dce364dd1a3d3852d81887303": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "a9be3c79b1d241f2aecb927fbf22fcbd": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": "#285475", + "description_width": "" + } + }, + "ac75d07f1bc74407939ebafb73125e87": { + "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 + } + }, + "ad15feebe6fc40ff9861d924053bb315": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_cfe6aeafb29d4d8d99e203d74d0f8e62", + "placeholder": "​", + "style": "IPY_MODEL_f4b1e8694e5e4f04995db32d27f32143", + "tabbable": null, + "tooltip": null, + "value": "100%" + } + }, + "add7cfc3c61a40599b51382e977b713b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "afe0080106fd4b12bb220bdc25df2a62": { + "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 + } + }, + "b00684aaa7c840fca02226a4e3654887": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_250d0952eb674708980875bd946d49fa", + "max": 50.0, + "min": 0.0, + "orientation": "horizontal", + "style": "IPY_MODEL_dd265c2718e549b0ac956833eb767239", + "tabbable": null, + "tooltip": null, + "value": 50.0 + } + }, + "b0db8a87e20047d99692cd939086906a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "b20959983fe24e999050f47974557815": { + "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": "inline-flex", + "flex": null, + "flex_flow": "row wrap", + "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": "110px" + } + }, + "b2b8c19e07e8494c883b107fbc3bcab3": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_de2b04d183ae433888a195cddc939613", + "max": 50.0, + "min": 0.0, + "orientation": "horizontal", + "style": "IPY_MODEL_8b48a5799151484c8aa39e26b5b39708", + "tabbable": null, + "tooltip": null, + "value": 50.0 + } + }, + "b3532ad3987646b6bfc3d3cd1c2593d2": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_2600359b21cc4942b437442812ff2dd1", + "placeholder": "​", + "style": "IPY_MODEL_0869143f90a240438477a2eea5138607", + "tabbable": null, + "tooltip": null, + "value": " 50/50 [00:00<00:00, 718.57member/s]" + } + }, + "b3fdbfa7d1fd4e9ea00b55e2f006b2d0": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_e17ed58bee09411ebdf9f91d763dec9a", + "placeholder": "​", + "style": "IPY_MODEL_01d940561a964aa1a8e3dbdbbdfda101", + "tabbable": null, + "tooltip": null, + "value": " 50/50 [00:00<00:00, 836.34member/s]" + } + }, + "b77ebe5b38ce45359c7ed491ad5bc85d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_4a15b5b8609947d485db13d1adda5103", + "max": 50.0, + "min": 0.0, + "orientation": "horizontal", + "style": "IPY_MODEL_fa397ad312cd4aebaa7b06ba6b75c8c4", + "tabbable": null, + "tooltip": null, + "value": 50.0 + } + }, + "b8805d2f363d4eb0867aaedeeb197a58": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_e0ab9546a2cb40cb9f624d63f1c69846", + "placeholder": "​", + "style": "IPY_MODEL_a6ea0b4944244487bb07f95788156fc4", + "tabbable": null, + "tooltip": null, + "value": "100%" + } + }, + "b8abe9b0e8944b57a75d85fd5befac00": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "b969a15d9b024a0fb71be75071aafe48": { + "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 + } + }, + "be45d566c0424db8a5a2870f753a09e5": { + "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": "inline-flex", + "flex": null, + "flex_flow": "row wrap", + "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": "110px" + } + }, + "c0dae2a841574b5ea19dedcbb15e1872": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_20e828a0084a417d806eca59dcab0d14", + "IPY_MODEL_f0ea8e04e4294fcf878355052e9b86f3", + "IPY_MODEL_4532ed8b3f4f4970886382fd88014488" + ], + "layout": "IPY_MODEL_f6c013bee0034ad5991f43d95689212d", + "tabbable": null, + "tooltip": null + } + }, + "c1c4246d213a497089738249e1343a16": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_c7bc149701b34bcd9586b0ba50fef378", + "placeholder": "​", + "style": "IPY_MODEL_efcc367dc053433097d84756462e4ec9", + "tabbable": null, + "tooltip": null, + "value": " 50/50 [00:00<00:00, 813.89member/s]" + } + }, + "c476843d1c064d0b8fd69ebc09948144": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_50e114885bff4f63a990a4ebb5f0f5e4", + "IPY_MODEL_8d1c41da15f04d899382221629c11fa3", + "IPY_MODEL_10428edf608f4a7f9897571bfa0087ec" + ], + "layout": "IPY_MODEL_d973ca3d2af74b26b2a2bc136b5411ce", + "tabbable": null, + "tooltip": null + } + }, + "c49526424440466d897dcea322ed4000": { + "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 + } + }, + "c5f522d6c63a487ab47513cf89f9674f": { + "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": "2", + "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 + } + }, + "c6ba5c7c9b0546d89ac477dea8bd78f8": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_4aa2be5dbb364b2fa5aa12315c4db618", + "IPY_MODEL_df838ffba28646468ca6c3b5766138b5", + "IPY_MODEL_47a39ff3ebdc457daf15c61fdda2bda4" + ], + "layout": "IPY_MODEL_5a7b8b2cce2540aca7a5f3af731cb1f2", + "tabbable": null, + "tooltip": null + } + }, + "c6c4c68085b54bcbadf1fd8c167cbafe": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_fd14fce7f65742f4aa4f9846f1d48f9f", + "placeholder": "​", + "style": "IPY_MODEL_b0db8a87e20047d99692cd939086906a", + "tabbable": null, + "tooltip": null, + "value": "100%" + } + }, + "c7bc149701b34bcd9586b0ba50fef378": { + "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 + } + }, + "c80f61196a2a4d789c9334fdb7517abf": { + "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 + } + }, + "c8d2da14c1e942ce96736ced9e41d87a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": "#285475", + "description_width": "" + } + }, + "cde70242afe34e6f88b94321431ec156": { + "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 + } + }, + "cdeb25e65fc74394ad2f83de4c5f235a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_92735b86e56f4284b7f8d722b7a61945", + "placeholder": "​", + "style": "IPY_MODEL_7fa54ae31705410ea0cc3bc7320cc0d9", + "tabbable": null, + "tooltip": null, + "value": " 50/50 [00:00<00:00, 823.78member/s]" + } + }, + "cfe6aeafb29d4d8d99e203d74d0f8e62": { + "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 + } + }, + "cffcdbd2281447c2bc0e1e5c95b24f92": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "d1c67222de624c2fa026dcf31cb091dc": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": "#285475", + "description_width": "" + } + }, + "d40530f66d1d42bdbfcc1533c5f5e6c2": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "d973ca3d2af74b26b2a2bc136b5411ce": { + "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": "inline-flex", + "flex": null, + "flex_flow": "row wrap", + "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": "110px" + } + }, + "dd265c2718e549b0ac956833eb767239": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": "#285475", + "description_width": "" + } + }, + "ddbb7c4f47b14986bfffb2c6fe9d3021": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_7df65b69280842aebaf0388c2b26d6d0", + "max": 50.0, + "min": 0.0, + "orientation": "horizontal", + "style": "IPY_MODEL_59dfb90322dd4a4098c591ab09573c50", + "tabbable": null, + "tooltip": null, + "value": 50.0 + } + }, + "de2b04d183ae433888a195cddc939613": { + "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": "2", + "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 + } + }, + "df7c47ffdb1540a292b6f61c76d3a6ac": { + "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 + } + }, + "df838ffba28646468ca6c3b5766138b5": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_c5f522d6c63a487ab47513cf89f9674f", + "max": 50.0, + "min": 0.0, + "orientation": "horizontal", + "style": "IPY_MODEL_7184db3ef3c14da9918e576ede941034", + "tabbable": null, + "tooltip": null, + "value": 50.0 + } + }, + "dffe51f537514dba9ffd1edacc6c301a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": "#285475", + "description_width": "" + } + }, + "e0ab9546a2cb40cb9f624d63f1c69846": { + "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 + } + }, + "e17ed58bee09411ebdf9f91d763dec9a": { + "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 + } + }, + "e21aeeb97ac24fde9b3194e92eef9f86": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_2d769a221cb54085906300b0a7fa8781", + "IPY_MODEL_b77ebe5b38ce45359c7ed491ad5bc85d", + "IPY_MODEL_508c9c3505f64d2d9d14cd97fbb7c037" + ], + "layout": "IPY_MODEL_77572900ba854a459ae8541957e6f21c", + "tabbable": null, + "tooltip": null + } + }, + "e26b3f49acaf4a57a6edcca6ad040eba": { + "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": "inline-flex", + "flex": null, + "flex_flow": "row wrap", + "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": "110px" + } + }, + "e284823d27eb4879af4f408d8bcac69d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": "#285475", + "description_width": "" + } + }, + "e370b1a97dab418286f3baade04e412f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": "#285475", + "description_width": "" + } + }, + "e3d0a44e682440b5ad84e419ef555328": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_36f5fd7c05fd4d33a6503334c555fca9", + "max": 50.0, + "min": 0.0, + "orientation": "horizontal", + "style": "IPY_MODEL_05128e8391f74979a13418cf1888a00f", + "tabbable": null, + "tooltip": null, + "value": 50.0 + } + }, + "e40d498c4891429ea551bed7466a2db6": { + "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": "2", + "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 + } + }, + "e7713a3be59b4ddcaa2bf270347f407f": { + "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": "inline-flex", + "flex": null, + "flex_flow": "row wrap", + "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": "110px" + } + }, + "e9cedb65a35849d18ad933cbe215c527": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "ea9ffc6ce48d4d4b895cf5c05c006325": { + "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 + } + }, + "eade46797e8e49bdb1c4a145416b1402": { + "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 + } + }, + "edba730184f746b5b5c0768aec60af43": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "edc692237fcf4efab7f46d136b3ec00f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": "#285475", + "description_width": "" + } + }, + "efc6065f452640588093c78c143e2cd1": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_f4df6f46e4eb435b9bce22fa857736f6", + "max": 50.0, + "min": 0.0, + "orientation": "horizontal", + "style": "IPY_MODEL_6d905674bd99489889e5849d66b438c8", + "tabbable": null, + "tooltip": null, + "value": 50.0 + } + }, + "efcc367dc053433097d84756462e4ec9": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "f0dd0e311c9d4fb885309ccc054195d8": { + "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 + } + }, + "f0ea8e04e4294fcf878355052e9b86f3": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_90a1047bd2e54c548bf5d23d8189b00b", + "max": 50.0, + "min": 0.0, + "orientation": "horizontal", + "style": "IPY_MODEL_48a9cd92189a45b7a183f151520eeb99", + "tabbable": null, + "tooltip": null, + "value": 50.0 + } + }, + "f27c7f2dbad54d158158c421708070ee": { + "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 + } + }, + "f2cd621ec023498da52f01e85d763b70": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_766c366138c94545b221c60cfefe8452", + "max": 50.0, + "min": 0.0, + "orientation": "horizontal", + "style": "IPY_MODEL_6d81e29b50a541c3ae8316b4f0a258e9", + "tabbable": null, + "tooltip": null, + "value": 50.0 + } + }, + "f2edabe430ba43f9a5e6913f22735c4f": { + "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 + } + }, + "f4b1e8694e5e4f04995db32d27f32143": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "f4df6f46e4eb435b9bce22fa857736f6": { + "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": "2", + "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 + } + }, + "f51bc035bbcf45cf80aced83995af96c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": "#285475", + "description_width": "" + } + }, + "f65592161bfb49ac812ed2a3ab8a3c9f": { + "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 + } + }, + "f6c013bee0034ad5991f43d95689212d": { + "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": "inline-flex", + "flex": null, + "flex_flow": "row wrap", + "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": "110px" + } + }, + "f77006b071ae45af9d805740421532a6": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "f7dfd3b8248549188315fc101f7b9e06": { + "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": "2", + "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 + } + }, + "f802cbb2d8a04a16a92fac7dbf75171e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_8cfa4bcf27d24045a83d6854d5bced29", + "IPY_MODEL_ddbb7c4f47b14986bfffb2c6fe9d3021", + "IPY_MODEL_13377971088b4d2e8c91fb0bb5e808b2" + ], + "layout": "IPY_MODEL_e26b3f49acaf4a57a6edcca6ad040eba", + "tabbable": null, + "tooltip": null + } + }, + "f80640cee4374bfdacdfd917706d5faa": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "f83d302c90574de7b3405d54ed6a46a4": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_0d423318aafb405e900e98c2dfcfe933", + "placeholder": "​", + "style": "IPY_MODEL_b8abe9b0e8944b57a75d85fd5befac00", + "tabbable": null, + "tooltip": null, + "value": "100%" + } + }, + "f85eb8a6710b4d7c9223cae3737059b3": { + "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": "2", + "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 + } + }, + "f87d5ac42738409db92770cdb51e6198": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "f9b846f6f2454780a727f94b29f93f4c": { + "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 + } + }, + "fa397ad312cd4aebaa7b06ba6b75c8c4": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": "#285475", + "description_width": "" + } + }, + "fd14fce7f65742f4aa4f9846f1d48f9f": { + "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 + } + } + }, + "version_major": 2, + "version_minor": 0 + } + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/docs/tutorials/pipt/extending/adding_an_analysis.ipynb b/docs/tutorials/pipt/extending/adding_an_analysis.ipynb new file mode 100644 index 00000000..bb590eca --- /dev/null +++ b/docs/tutorials/pipt/extending/adding_an_analysis.ipynb @@ -0,0 +1,5694 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "96fc1f40", + "metadata": {}, + "source": [ + "# Adding a new analysis\n", + "\n", + "An **analysis** computes the state update for one assimilation iteration. It is\n", + "the piece that turns the current ensemble and its predicted data into a step.\n", + "\n", + "The analysis is a *parameter* of a scheme, not a scheme of its own:\n", + "\n", + "```python\n", + "ESMDA(cfg_da, cfg_en, sim, analysis=\"approx\")\n", + "```\n", + "\n", + "so adding one means writing a class and listing it, not copying a scheme.\n", + "This notebook writes a working analysis end to end and runs it against a\n", + "built-in one." + ] + }, + { + "cell_type": "markdown", + "id": "d7958850", + "metadata": {}, + "source": [ + "## The contract\n", + "\n", + "One method:\n", + "\n", + "```python\n", + "def update(self, enX, enY, enE, **kwargs) -> np.ndarray | None\n", + "```\n", + "\n", + "| argument | shape | meaning |\n", + "| --- | --- | --- |\n", + "| `enX` | `(nx, ne)` | current state ensemble |\n", + "| `enY` | `(nd, ne)` | predicted data for that state |\n", + "| `enE` | `(nd, ne)` | perturbed observations |\n", + "\n", + "Return the step to add to the state, shape `(nx, ne)` — or `None` if you\n", + "deliver the result by assignment instead (see the last section).\n", + "\n", + "`AnalysisBase` also gives you two helpers that handle a covariance supplied\n", + "either as a full matrix or as just its diagonal:" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "8c50aaca", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-24T09:33:02.644139Z", + "iopub.status.busy": "2026-08-24T09:33:02.643749Z", + "iopub.status.idle": "2026-08-24T09:33:03.435375Z", + "shell.execute_reply": "2026-08-24T09:33:03.434260Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(self, enX, enY, enE, **kwargs)\n", + "['solve', 'sqrtm', 'scheme']\n", + "\n", + "Apply ``A⁻¹ B``, supporting both matrix (2-D) and diagonal (1-D) ``A``.\n", + "\n", + "``np.ndim`` is used rather than ``A.ndim`` so that plain lists and\n", + "scalars -- which a covariance can still be when it comes straight from a\n", + "config file -- are handled instead of raising ``AttributeError``.\n" + ] + } + ], + "source": [ + "import inspect\n", + "from pipt.update_schemes.analysis import AnalysisBase\n", + "\n", + "print(inspect.signature(AnalysisBase.update))\n", + "print([m for m in (\"solve\", \"sqrtm\", \"scheme\") if hasattr(AnalysisBase, m)])\n", + "print(\"\\n\" + inspect.getdoc(AnalysisBase.solve))" + ] + }, + { + "cell_type": "markdown", + "id": "deea04c8", + "metadata": {}, + "source": [ + "## Where the rest of the context comes from\n", + "\n", + "Everything else is read off `self.scheme`. That is a *façade*: some of these\n", + "names are the scheme's own and some belong to its ensemble, but the scheme\n", + "exposes both as properties, so an analysis never has to know which.\n", + "\n", + "| read | typically |\n", + "| --- | --- |\n", + "| `scheme.lam` | LM damping (0 for ES-MDA) |\n", + "| `scheme.trunc_energy` | SVD truncation energy |\n", + "| `scheme.iteration` | 0-based iteration counter |\n", + "| `scheme.proj` | centering/normalising projection, `(ne, ne)` |\n", + "| `scheme.cov_data`, `scheme.scale_data` | data covariance and its factor |\n", + "| `scheme.prior_enX`, `scheme.state_scaling` | prior state and its scaling |\n", + "| `scheme.keys_da`, `scheme.localization` | config and localization |\n", + "\n", + "If you need something no existing analysis uses, read it off `self.scheme`\n", + "too — and if the scheme does not expose it yet, adding one property there is\n", + "the whole change." + ] + }, + { + "cell_type": "markdown", + "id": "387eeae4", + "metadata": {}, + "source": [ + "## A worked example\n", + "\n", + "A damped Kalman gain, formed directly rather than through the truncated SVD\n", + "that `approx`/`full` use. Same textbook update, different numerics:\n", + "\n", + "$$\\mathrm{step} = X\\,\\tilde{Y}^{\\mathsf T}\\big(\\tilde{Y}\\tilde{Y}^{\\mathsf T} + (1+\\lambda)I\\big)^{-1}\\tilde{D}$$\n", + "\n", + "where $X$ are state anomalies and $\\tilde{Y}, \\tilde{D}$ are data anomalies\n", + "and innovations scaled to unit data covariance." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "201cf50d", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-24T09:33:03.437516Z", + "iopub.status.busy": "2026-08-24T09:33:03.437159Z", + "iopub.status.idle": "2026-08-24T09:33:03.442147Z", + "shell.execute_reply": "2026-08-24T09:33:03.441602Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(, )\n" + ] + } + ], + "source": [ + "import numpy as np\n", + "from pipt.update_schemes.analysis import AnalysisBase\n", + "\n", + "\n", + "class ridge_update(AnalysisBase):\n", + " \"\"\"Damped Kalman gain, formed directly instead of via a truncated SVD.\"\"\"\n", + "\n", + " def update(self, enX, enY, enE, **kwargs):\n", + " scheme = self.scheme\n", + "\n", + " PI = scheme.proj # (ne, ne)\n", + " scy = scheme.scale_data # Cholesky factor of C_d\n", + "\n", + " X = enX @ PI # state anomalies (nx, ne)\n", + " Ys = self.solve(scy, enY @ PI) # scaled data anomalies (nd, ne)\n", + " D = self.solve(scy, enE - enY) # scaled innovations (nd, ne)\n", + "\n", + " A = Ys @ Ys.T + (1.0 + scheme.lam) * np.eye(Ys.shape[0])\n", + " return X @ Ys.T @ np.linalg.solve(A, D)\n", + "\n", + "print(ridge_update.__mro__[:2])" + ] + }, + { + "cell_type": "markdown", + "id": "b697f49b", + "metadata": {}, + "source": [ + "## Wiring it in\n", + "\n", + "`COMPATIBLE_ANALYSES` maps a flavour name to its class, per scheme. To offer a\n", + "new flavour on an existing scheme, subclass and extend the dict:" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "3d34f6d2", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-24T09:33:03.443722Z", + "iopub.status.busy": "2026-08-24T09:33:03.443491Z", + "iopub.status.idle": "2026-08-24T09:33:03.448073Z", + "shell.execute_reply": "2026-08-24T09:33:03.447585Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "flavours on LMEnRML : ['approx', 'full', 'subspace']\n", + "flavours on RidgeEnRML: ['approx', 'full', 'ridge', 'subspace']\n" + ] + } + ], + "source": [ + "from pipt import LMEnRML\n", + "\n", + "class RidgeEnRML(LMEnRML):\n", + " COMPATIBLE_ANALYSES = {**LMEnRML.COMPATIBLE_ANALYSES, \"ridge\": ridge_update}\n", + "\n", + "print(\"flavours on LMEnRML :\", sorted(LMEnRML.COMPATIBLE_ANALYSES))\n", + "print(\"flavours on RidgeEnRML:\", sorted(RidgeEnRML.COMPATIBLE_ANALYSES))" + ] + }, + { + "cell_type": "markdown", + "id": "05426529", + "metadata": {}, + "source": [ + "Asking for a flavour a scheme does not have fails immediately, and says what\n", + "is available — rather than failing later inside the numerics:" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "247a7efd", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-24T09:33:03.449547Z", + "iopub.status.busy": "2026-08-24T09:33:03.449403Z", + "iopub.status.idle": "2026-08-24T09:33:03.452280Z", + "shell.execute_reply": "2026-08-24T09:33:03.451823Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "LMEnRML has no 'ridge' -- as expected\n", + "RidgeEnRML resolves 'ridge' -> ridge_update\n" + ] + } + ], + "source": [ + "try:\n", + " LMEnRML.COMPATIBLE_ANALYSES[\"ridge\"]\n", + "except KeyError:\n", + " print(\"LMEnRML has no 'ridge' -- as expected\")\n", + "\n", + "scheme_cls = RidgeEnRML\n", + "print(\"RidgeEnRML resolves 'ridge' ->\", scheme_cls.COMPATIBLE_ANALYSES[\"ridge\"].__name__)" + ] + }, + { + "cell_type": "markdown", + "id": "efee2c1c", + "metadata": {}, + "source": [ + "## A case to try it on\n", + "\n", + "A 60-cell state observed at every 5th position — instant to run." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "030b9d61", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-24T09:33:03.454240Z", + "iopub.status.busy": "2026-08-24T09:33:03.454097Z", + "iopub.status.idle": "2026-08-24T09:33:03.493393Z", + "shell.execute_reply": "2026-08-24T09:33:03.492947Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "case ready: 60-cell state, 11 observations, ne=50\n" + ] + } + ], + "source": [ + "import os, tempfile\n", + "from copy import deepcopy\n", + "import numpy as np\n", + "from misc.structures import PETDataFrame\n", + "from simulator.simple_models import lin_1d\n", + "\n", + "# A 60-cell state observed at every 5th position. Pure numpy, runs instantly.\n", + "STATE_SIZE = 60\n", + "CFG_SIM = {\"reporttype\": \"position\", \"reportpoint\": list(range(5, STATE_SIZE, 5)),\n", + " \"datatype\": [\"value\"],\n", + " # NOTE: >1 is deliberate. lin_1d returns a shared internal object from\n", + " # run_fwd_sim, so a sequential run aliases every member onto the same\n", + " # prediction and the ensemble collapses to zero spread.\n", + " \"parallel\": 4}\n", + "\n", + "CFG_ENS = {\"ne\": 50, \"state\": \"x\",\n", + " \"prior_x\": {\"vario\": \"sph\", \"mean\": [0.0] * STATE_SIZE, \"var\": 1.0,\n", + " \"range\": 20.0, \"aniso\": 1.0, \"angle\": 0.0,\n", + " \"grid\": [STATE_SIZE, 1]}}\n", + "\n", + "def cfg_da(analysis, **iteration):\n", + " it = {\"max_iter\": 6, \"data_misfit_tol\": 1e-3, \"lambda\": 5.0,\n", + " \"lambda_factor\": 4.0, \"lambda_max\": 1e8}\n", + " it.update(iteration)\n", + " return {\"scheme\": \"custom\", \"analysis\": analysis, \"energy\": 0.95,\n", + " \"obsname\": \"position\", \"data\": \"true_data.pkl\", \"datavar\": \"var.pkl\",\n", + " \"iteration\": it}\n", + "\n", + "def make_truth():\n", + " \"\"\"Write the synthetic observations the schemes below assimilate.\n", + "\n", + " Returns the true state, so the plots can compare against it.\n", + " \"\"\"\n", + " np.random.seed(10)\n", + " sim = lin_1d(CFG_SIM); sim.setup_fwd_run()\n", + " state = {\"x\": np.random.multivariate_normal(np.zeros(STATE_SIZE), np.eye(STATE_SIZE))}\n", + " pred = PETDataFrame.from_records(sim.run_fwd_sim(state, 0), index=CFG_SIM[\"reportpoint\"])\n", + " data, var = pred.copy(), pred.copy()\n", + " for c in data.columns:\n", + " data[c] = data[c].apply(np.squeeze)\n", + " var[c] = var[c].apply(lambda _: [\"abs\", 1.0])\n", + " data.to_pickle(\"true_data.pkl\"); var.to_pickle(\"var.pkl\")\n", + " return state[\"x\"]\n", + "\n", + "os.chdir(tempfile.mkdtemp()) # keep run artifacts out of the docs tree\n", + "TRUE_STATE = make_truth()\n", + "OBS_AT = CFG_SIM[\"reportpoint\"]\n", + "print(f\"case ready: {STATE_SIZE}-cell state, {len(OBS_AT)} observations, ne={CFG_ENS['ne']}\")" + ] + }, + { + "cell_type": "markdown", + "id": "f2675117", + "metadata": {}, + "source": [ + "Now run the built-in `full` flavour and the new `ridge` one on identical inputs:" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "fd9b08eb", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-24T09:33:03.495620Z", + "iopub.status.busy": "2026-08-24T09:33:03.495461Z", + "iopub.status.idle": "2026-08-24T09:33:04.826497Z", + "shell.execute_reply": "2026-08-24T09:33:04.826057Z" + } + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2026-08-24│11:33:03 : =========== Running Data Assimilation - CUSTOM ===========\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "d01f1b45c8c749148c5210669145cd79", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + " 0%| | 0/50 [00:00 1.25\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "0873aa7b72194974b61ff6254285e327", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + " 0%| | 0/50 [00:00 0.3125\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "6e80ec08c8674c58b8d19a9d0d0933e1", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + " 0%| | 0/50 [00:00 0.078125\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "56be1ad2c003480e857794d3a7c5cd00", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + " 0%| | 0/50 [00:00 0.01953125\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "512ef1af35a5478eb56939672eb23586", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + " 0%| | 0/50 [00:00 0.0048828125\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2026-08-24│11:33:04 : Maximum iterations reached without convergence.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2026-08-24│11:33:04 : \n", + " Convergence was met. Obj. function reduced from 30.0 to 14.1\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2026-08-24│11:33:04 : Assimilation finished after 5 iteration(s): Maximum number of iterations reached\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2026-08-24│11:33:04 : =========== Running Data Assimilation - CUSTOM ===========\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "full (built-in) misfit 29.98 -> 14.11 iterations=5\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "81652f391438477bad3bb2e7134e54c6", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + " 0%| | 0/50 [00:00 1.25\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "566bbd01b90e4c0ab76b0b60e0142dde", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + " 0%| | 0/50 [00:00 0.3125\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "a53d2b5b21ee4205af4f2cac90a96b48", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + " 0%| | 0/50 [00:00 0.078125\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "4b16486b7b3144d388e2e20c51815894", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + " 0%| | 0/50 [00:00 0.01953125\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "82e4715da4174b74b114906133fa530d", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + " 0%| | 0/50 [00:00 0.0048828125\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2026-08-24│11:33:04 : Maximum iterations reached without convergence.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2026-08-24│11:33:04 : \n", + " Convergence was met. Obj. function reduced from 30.0 to 5.9\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2026-08-24│11:33:04 : Assimilation finished after 5 iteration(s): Maximum number of iterations reached\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "ridge (new) misfit 29.98 -> 5.94 iterations=5\n" + ] + } + ], + "source": [ + "results = {}\n", + "for label, cls, flavour in [(\"full (built-in)\", LMEnRML, \"full\"),\n", + " (\"ridge (new)\", RidgeEnRML, \"ridge\")]:\n", + " np.random.seed(10)\n", + " res = cls.assimilate(cfg_da(flavour), deepcopy(CFG_ENS),\n", + " lin_1d(CFG_SIM), analysis=flavour)\n", + " results[label] = res\n", + " print(f\"{label:16} misfit {res.prior_data_misfit:7.2f} -> {res.data_misfit:6.2f}\"\n", + " f\" iterations={res.nit}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "c117d96e", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-24T09:33:04.827974Z", + "iopub.status.busy": "2026-08-24T09:33:04.827866Z", + "iopub.status.idle": "2026-08-24T09:33:05.046707Z", + "shell.execute_reply": "2026-08-24T09:33:05.046081Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "\n", + "fig, ax = plt.subplots(figsize=(10, 4))\n", + "ax.plot(TRUE_STATE, \"k-\", lw=2, label=\"true state\")\n", + "for label, res in results.items():\n", + " ax.plot(np.asarray(res.x).mean(axis=-1), \"--\", lw=1.8, label=f\"posterior mean -- {label}\")\n", + "ax.scatter(OBS_AT, TRUE_STATE[OBS_AT], c=\"crimson\", zorder=5, s=25, label=\"observed\")\n", + "ax.set_xlabel(\"state index\"); ax.set_ylabel(\"value\")\n", + "ax.set_title(\"Both flavours recover the state where it is observed\")\n", + "ax.legend(fontsize=8); plt.tight_layout(); plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "803f18e3", + "metadata": {}, + "source": [ + "## Steps that are not in state space\n", + "\n", + "Some analyses do not compute a state-space step at all. `subspace_update`\n", + "solves in ensemble-weight space and returns `AnalysisResult(w_step=...)`;\n", + "`margIS_update` returns `AnalysisResult(W_step=...)`. The scheme's\n", + "`propose_state` then reconstructs the state, with a different formula for each:\n", + "\n", + "| returns | reconstruction |\n", + "| --- | --- |\n", + "| a step (or `AnalysisResult(step=...)`) | `enX + step` |\n", + "| `AnalysisResult(w_step=...)` | `prior_enX @ (I + W / sqrt(ne-1))` |\n", + "| `AnalysisResult(W_step=...)` | `mean(prior_enX) + prior_enX @ proj @ W * sqrt(ne-1)` |\n", + "\n", + "These are **not** interchangeable — the two `W`s are defined differently (one\n", + "starts at zero, the other at the identity). State the analysis keeps between\n", + "iterations (a cached matrix, the current `W`) lives on `self.scheme`, not on\n", + "`self`; the result itself is returned, never assigned.\n", + "\n", + "## Checklist\n", + "\n", + "1. Subclass `AnalysisBase`, implement `update(enX, enY, enE, **kwargs)`.\n", + "2. Read context off `self.scheme`; use `self.solve` / `self.sqrtm` for\n", + " covariances that may be diagonal.\n", + "3. Return the step -- a plain array, or an `AnalysisResult` with `step`,\n", + " `w_step` or `W_step` set.\n", + "4. List it in the scheme's `COMPATIBLE_ANALYSES`.\n", + "5. Run it against a built-in flavour on a case you understand — a new analysis\n", + " that runs without erroring is not the same as one that is correct." + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "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.12.3" + }, + "widgets": { + "application/vnd.jupyter.widget-state+json": { + "state": { + "01c1fe8fed5b4bffb2ccbf0455100bd6": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": "#285475", + "description_width": "" + } + }, + "01ce5d16467b47bb8c408bec48ddfc77": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "06a9e8161848402796375f266e1088c4": { + "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 + } + }, + "0873aa7b72194974b61ff6254285e327": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_620695c84f8e4ebca915618a3212b427", + "IPY_MODEL_76830ebf127244af9618b5503b0fb2f4", + "IPY_MODEL_aa8527a55fb549c4aa054e3050dfc8c5" + ], + "layout": "IPY_MODEL_7a840350315a4dca84e3946257c69113", + "tabbable": null, + "tooltip": null + } + }, + "08d0e44fd8b2416892e2c802724bad3d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_291ede309bb94096b3f06c86d93965ba", + "IPY_MODEL_9998aec270b64922ada1a7eaef30845d", + "IPY_MODEL_8f650fa4ea3947a8bcb7f65c420a4713" + ], + "layout": "IPY_MODEL_948e374bc7cb4d1ca17a0af0914f2cfd", + "tabbable": null, + "tooltip": null + } + }, + "096f94466015453fb565ef7d0743a4ef": { + "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 + } + }, + "0b2de11cbfab4f6087dcc0f4f3974fd3": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_b8e8608586c54385ad6490d5e00e4210", + "placeholder": "​", + "style": "IPY_MODEL_558882d84c5b4ad39174e0f721cc51d6", + "tabbable": null, + "tooltip": null, + "value": "100%" + } + }, + "12488283810144649915ce281c77b949": { + "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": "2", + "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 + } + }, + "17011d2b92014de9a712002a3a90d042": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "1bbcd9bb11fe4a14809e8a3b9ace1598": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_7562bf824f8c4a22958f4f68bb6543a7", + "placeholder": "​", + "style": "IPY_MODEL_776e23a6ec0941b08555d777a592b1d5", + "tabbable": null, + "tooltip": null, + "value": "100%" + } + }, + "1d5ecfa2da17421dac77821070eaa427": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "2291ed69779d480db5d8154bfabbbefc": { + "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 + } + }, + "291ede309bb94096b3f06c86d93965ba": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_651d0085f222407e853903bf519a3a3e", + "placeholder": "​", + "style": "IPY_MODEL_f30cfd8ced7e4993b10c21e76fd5c50b", + "tabbable": null, + "tooltip": null, + "value": "100%" + } + }, + "2a1eeeee48f345bd95931ed323d9b88a": { + "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": "inline-flex", + "flex": null, + "flex_flow": "row wrap", + "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": "110px" + } + }, + "2a7c4868014a45a0840e4c298283bf21": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "2d3070fba03f4c9f8bb3b11c3b0d835e": { + "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": "inline-flex", + "flex": null, + "flex_flow": "row wrap", + "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": "110px" + } + }, + "2eeb676ce2e54489949950ff8d4feff3": { + "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": "2", + "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 + } + }, + "2f23c48a75f2433496bf35e46ccea6e5": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "2fd47aa066a04029b752a12cd3618f44": { + "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 + } + }, + "3026ff698e7948f1aa3b3cecde6ec17e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "305355934cb946d4a4775472d9d5e92c": { + "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 + } + }, + "30914a3d846643019c183b9a99f2d661": { + "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 + } + }, + "3197077ac3e3431c9f42c99b790e338d": { + "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 + } + }, + "34e310e0256749a4ae154a38089fa206": { + "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": "inline-flex", + "flex": null, + "flex_flow": "row wrap", + "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": "110px" + } + }, + "34f38ac4f8ff4c808c763df6b7e56196": { + "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": "2", + "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 + } + }, + "36a9540209fd44ba8a4001b3939f365e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_5c9bca35f8ce43909d4a3fa1c4eadbec", + "placeholder": "​", + "style": "IPY_MODEL_e765c54a4a0141549a1f3aec77db0d44", + "tabbable": null, + "tooltip": null, + "value": "100%" + } + }, + "372806bb24214526a504a9ea9ae0e30b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_36a9540209fd44ba8a4001b3939f365e", + "IPY_MODEL_98869b0730674e86a19bdd233c51361a", + "IPY_MODEL_95c493987322495ba3dd0fc6ab88b498" + ], + "layout": "IPY_MODEL_4ffc09f2974f40a4a77fd54cf8d8d81b", + "tabbable": null, + "tooltip": null + } + }, + "3855d245bafe4391bbf5fbdb8518c23a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "3c4478582d0748c4a01749ec48509ad4": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "4284ba7f226d42798296df6bf1118b91": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": "#285475", + "description_width": "" + } + }, + "4b16486b7b3144d388e2e20c51815894": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_74386948254f475d8746d5a70779d659", + "IPY_MODEL_8302a143544b4f5f8e7de2f9aaa258fc", + "IPY_MODEL_c2b2c9ea72d2486cadb0993ad8b1d0c4" + ], + "layout": "IPY_MODEL_77ba1e9dcb3a4d86899fb506293d8454", + "tabbable": null, + "tooltip": null + } + }, + "4c1605c417ab41cfb63ede5131b47012": { + "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": "2", + "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 + } + }, + "4c944c713b374f48af3dedbaacc28a57": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": "#285475", + "description_width": "" + } + }, + "4ccc08479d4e460ab06b2236e0515919": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_06a9e8161848402796375f266e1088c4", + "placeholder": "​", + "style": "IPY_MODEL_d3b33f51cc8148f6b2a68a2d82da6582", + "tabbable": null, + "tooltip": null, + "value": "100%" + } + }, + "4ef1cf19e8fb457cb6b06289f918b6f2": { + "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": "inline-flex", + "flex": null, + "flex_flow": "row wrap", + "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": "110px" + } + }, + "4ffc09f2974f40a4a77fd54cf8d8d81b": { + "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": "inline-flex", + "flex": null, + "flex_flow": "row wrap", + "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": "110px" + } + }, + "512ef1af35a5478eb56939672eb23586": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_fcdf7c075bc54024beb752743b65d134", + "IPY_MODEL_c573796821ff4b0c870cdb92dd99a6ce", + "IPY_MODEL_eddc91fb8bfa4f0aa769d0c7187c73b3" + ], + "layout": "IPY_MODEL_cbf17f2943504daab370f591a737f004", + "tabbable": null, + "tooltip": null + } + }, + "51c3473cab914238b30f005773ae5e85": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_096f94466015453fb565ef7d0743a4ef", + "placeholder": "​", + "style": "IPY_MODEL_e21fa2c8ae414251a65f521366a34eec", + "tabbable": null, + "tooltip": null, + "value": " 50/50 [00:00<00:00, 826.04member/s]" + } + }, + "558882d84c5b4ad39174e0f721cc51d6": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "566bbd01b90e4c0ab76b0b60e0142dde": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_c986510110d548419e56ae68ea77b9db", + "IPY_MODEL_8f3a00630b9240eaa9d6dfe2b88518bc", + "IPY_MODEL_f0a6e1bab91145c5af645ea5ae3b6ecc" + ], + "layout": "IPY_MODEL_4ef1cf19e8fb457cb6b06289f918b6f2", + "tabbable": null, + "tooltip": null + } + }, + "56be1ad2c003480e857794d3a7c5cd00": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_0b2de11cbfab4f6087dcc0f4f3974fd3", + "IPY_MODEL_d6c2c2896ead4a87907490022d9ea0e7", + "IPY_MODEL_bd89502aecc54c93a1dda2beb0111b1f" + ], + "layout": "IPY_MODEL_bc7dee419ca84e62813412570debf765", + "tabbable": null, + "tooltip": null + } + }, + "594910044fec4291a703d0025e218bea": { + "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": "inline-flex", + "flex": null, + "flex_flow": "row wrap", + "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": "110px" + } + }, + "5c9bca35f8ce43909d4a3fa1c4eadbec": { + "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 + } + }, + "5d66f186176c473fb4104f358ead2885": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_2291ed69779d480db5d8154bfabbbefc", + "placeholder": "​", + "style": "IPY_MODEL_3855d245bafe4391bbf5fbdb8518c23a", + "tabbable": null, + "tooltip": null, + "value": "100%" + } + }, + "608d094a34d64da08e4cd3d0aac98698": { + "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": "2", + "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 + } + }, + "620695c84f8e4ebca915618a3212b427": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_6799c5714f77482c94fdd6a53e754a32", + "placeholder": "​", + "style": "IPY_MODEL_e328364718954e8c84b5c525e22a12f4", + "tabbable": null, + "tooltip": null, + "value": "100%" + } + }, + "62bdbe662c0743738f7586cf0c065970": { + "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 + } + }, + "62da06b8f5064af2af9e6bf8f42f9595": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "6415d713c8ab42128ceac547fafaa819": { + "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": "2", + "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 + } + }, + "651d0085f222407e853903bf519a3a3e": { + "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 + } + }, + "6799c5714f77482c94fdd6a53e754a32": { + "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 + } + }, + "68fcc4785b2d47adb54bf4324e193cf5": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_f24ec019bc144a87b6a0c43fac53d347", + "max": 50.0, + "min": 0.0, + "orientation": "horizontal", + "style": "IPY_MODEL_4284ba7f226d42798296df6bf1118b91", + "tabbable": null, + "tooltip": null, + "value": 50.0 + } + }, + "698b841432364ccf8c3c98848505ce40": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "6e80ec08c8674c58b8d19a9d0d0933e1": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_1bbcd9bb11fe4a14809e8a3b9ace1598", + "IPY_MODEL_aac57dd2563849f19b6f386a8054dac8", + "IPY_MODEL_7613389329614ecb9dbd0016caf9dd8d" + ], + "layout": "IPY_MODEL_34e310e0256749a4ae154a38089fa206", + "tabbable": null, + "tooltip": null + } + }, + "6f0fbdd235464ae98e878ec10bd82e95": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_2fd47aa066a04029b752a12cd3618f44", + "placeholder": "​", + "style": "IPY_MODEL_3c4478582d0748c4a01749ec48509ad4", + "tabbable": null, + "tooltip": null, + "value": " 50/50 [00:00<00:00, 845.23member/s]" + } + }, + "741f37093b8a4565ba4837d5c3fba3c9": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_d15683a3c4ec4cf2be078375b36f4499", + "placeholder": "​", + "style": "IPY_MODEL_c959152f65634b9f80868583b7b15399", + "tabbable": null, + "tooltip": null, + "value": " 50/50 [00:00<00:00, 824.16member/s]" + } + }, + "74386948254f475d8746d5a70779d659": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_e8367d7b036e439e90e722bf18e0c63d", + "placeholder": "​", + "style": "IPY_MODEL_e60a6e4165184befb055d7d4e5aa3940", + "tabbable": null, + "tooltip": null, + "value": "100%" + } + }, + "7562bf824f8c4a22958f4f68bb6543a7": { + "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 + } + }, + "75f9fdf80e6740e6b2bcad09dfb17a85": { + "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": "inline-flex", + "flex": null, + "flex_flow": "row wrap", + "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": "110px" + } + }, + "7613389329614ecb9dbd0016caf9dd8d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_3197077ac3e3431c9f42c99b790e338d", + "placeholder": "​", + "style": "IPY_MODEL_2a7c4868014a45a0840e4c298283bf21", + "tabbable": null, + "tooltip": null, + "value": " 50/50 [00:00<00:00, 812.90member/s]" + } + }, + "76830ebf127244af9618b5503b0fb2f4": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_12488283810144649915ce281c77b949", + "max": 50.0, + "min": 0.0, + "orientation": "horizontal", + "style": "IPY_MODEL_abe7649426cc414c8edba6c30e34710b", + "tabbable": null, + "tooltip": null, + "value": 50.0 + } + }, + "776e23a6ec0941b08555d777a592b1d5": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "777dd001048c4eaa95ba238312e22627": { + "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 + } + }, + "77ba1e9dcb3a4d86899fb506293d8454": { + "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": "inline-flex", + "flex": null, + "flex_flow": "row wrap", + "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": "110px" + } + }, + "7940990a80654f6bbf7700688bbbb757": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_f2a7b2c65fa14a92be8d0304140d65cd", + "max": 50.0, + "min": 0.0, + "orientation": "horizontal", + "style": "IPY_MODEL_843c6ffa9eb9432b84e9b3b679107987", + "tabbable": null, + "tooltip": null, + "value": 50.0 + } + }, + "796a4b69c2a644a0953d737bba4f3df3": { + "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 + } + }, + "798b550e06a54a2aa30a6a15f4c52e62": { + "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": "2", + "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 + } + }, + "7a840350315a4dca84e3946257c69113": { + "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": "inline-flex", + "flex": null, + "flex_flow": "row wrap", + "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": "110px" + } + }, + "80d0a1dc680a4b109ea80a9e20e4d814": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": "#285475", + "description_width": "" + } + }, + "81652f391438477bad3bb2e7134e54c6": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_5d66f186176c473fb4104f358ead2885", + "IPY_MODEL_7940990a80654f6bbf7700688bbbb757", + "IPY_MODEL_bbe86859856d4f1a809fe8932dff5312" + ], + "layout": "IPY_MODEL_2a1eeeee48f345bd95931ed323d9b88a", + "tabbable": null, + "tooltip": null + } + }, + "82e4715da4174b74b114906133fa530d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_cff875dfcf6e43d2957768d9b2c024e5", + "IPY_MODEL_68fcc4785b2d47adb54bf4324e193cf5", + "IPY_MODEL_741f37093b8a4565ba4837d5c3fba3c9" + ], + "layout": "IPY_MODEL_2d3070fba03f4c9f8bb3b11c3b0d835e", + "tabbable": null, + "tooltip": null + } + }, + "8302a143544b4f5f8e7de2f9aaa258fc": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_34f38ac4f8ff4c808c763df6b7e56196", + "max": 50.0, + "min": 0.0, + "orientation": "horizontal", + "style": "IPY_MODEL_4c944c713b374f48af3dedbaacc28a57", + "tabbable": null, + "tooltip": null, + "value": 50.0 + } + }, + "843c6ffa9eb9432b84e9b3b679107987": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": "#285475", + "description_width": "" + } + }, + "8ba3589dc65a4d488907a693a2c77127": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": "#285475", + "description_width": "" + } + }, + "8f3a00630b9240eaa9d6dfe2b88518bc": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_2eeb676ce2e54489949950ff8d4feff3", + "max": 50.0, + "min": 0.0, + "orientation": "horizontal", + "style": "IPY_MODEL_a3d36d7b0ebc4dcebd2f340363854c40", + "tabbable": null, + "tooltip": null, + "value": 50.0 + } + }, + "8f650fa4ea3947a8bcb7f65c420a4713": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_dbfab87d8a1647e4be2c56de947d7a2e", + "placeholder": "​", + "style": "IPY_MODEL_3026ff698e7948f1aa3b3cecde6ec17e", + "tabbable": null, + "tooltip": null, + "value": " 50/50 [00:00<00:00, 834.66member/s]" + } + }, + "90bcf9410ee44b04bee7cc2087864067": { + "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 + } + }, + "948e374bc7cb4d1ca17a0af0914f2cfd": { + "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": "inline-flex", + "flex": null, + "flex_flow": "row wrap", + "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": "110px" + } + }, + "950162989f304f61993d1e11e1512d12": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": "#285475", + "description_width": "" + } + }, + "95c493987322495ba3dd0fc6ab88b498": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_ac454eaff46941a9a069d6a6bc5ff6e9", + "placeholder": "​", + "style": "IPY_MODEL_1d5ecfa2da17421dac77821070eaa427", + "tabbable": null, + "tooltip": null, + "value": " 50/50 [00:00<00:00, 818.45member/s]" + } + }, + "98869b0730674e86a19bdd233c51361a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_f860b569575340e1ae5f5ba5d349f7ce", + "max": 50.0, + "min": 0.0, + "orientation": "horizontal", + "style": "IPY_MODEL_b2ac419604514889b4718f6e38d8aafe", + "tabbable": null, + "tooltip": null, + "value": 50.0 + } + }, + "9998aec270b64922ada1a7eaef30845d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_df616fa1b022487fb50b5eed9fed909c", + "max": 50.0, + "min": 0.0, + "orientation": "horizontal", + "style": "IPY_MODEL_ca38f21f4cb840cc876a72ff8c5cf39f", + "tabbable": null, + "tooltip": null, + "value": 50.0 + } + }, + "9df6e0a21fd841c48e8e0c055c8f2186": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "a3d36d7b0ebc4dcebd2f340363854c40": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": "#285475", + "description_width": "" + } + }, + "a53d2b5b21ee4205af4f2cac90a96b48": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_db43d8405ade4efdac54c672dfafa1a0", + "IPY_MODEL_db63224516d840a98543ab3c2e397e14", + "IPY_MODEL_51c3473cab914238b30f005773ae5e85" + ], + "layout": "IPY_MODEL_75f9fdf80e6740e6b2bcad09dfb17a85", + "tabbable": null, + "tooltip": null + } + }, + "a898613ef8e9475b85f2390a8da6d5bb": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_c98030fb0f074510be4ad72e6e7bf7c6", + "max": 50.0, + "min": 0.0, + "orientation": "horizontal", + "style": "IPY_MODEL_8ba3589dc65a4d488907a693a2c77127", + "tabbable": null, + "tooltip": null, + "value": 50.0 + } + }, + "aa8527a55fb549c4aa054e3050dfc8c5": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_90bcf9410ee44b04bee7cc2087864067", + "placeholder": "​", + "style": "IPY_MODEL_01ce5d16467b47bb8c408bec48ddfc77", + "tabbable": null, + "tooltip": null, + "value": " 50/50 [00:00<00:00, 825.35member/s]" + } + }, + "aac57dd2563849f19b6f386a8054dac8": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_6415d713c8ab42128ceac547fafaa819", + "max": 50.0, + "min": 0.0, + "orientation": "horizontal", + "style": "IPY_MODEL_80d0a1dc680a4b109ea80a9e20e4d814", + "tabbable": null, + "tooltip": null, + "value": 50.0 + } + }, + "abe7649426cc414c8edba6c30e34710b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": "#285475", + "description_width": "" + } + }, + "ac454eaff46941a9a069d6a6bc5ff6e9": { + "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 + } + }, + "b2ac419604514889b4718f6e38d8aafe": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": "#285475", + "description_width": "" + } + }, + "b8e8608586c54385ad6490d5e00e4210": { + "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 + } + }, + "bbe86859856d4f1a809fe8932dff5312": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_305355934cb946d4a4775472d9d5e92c", + "placeholder": "​", + "style": "IPY_MODEL_9df6e0a21fd841c48e8e0c055c8f2186", + "tabbable": null, + "tooltip": null, + "value": " 50/50 [00:00<00:00, 798.94member/s]" + } + }, + "bc7dee419ca84e62813412570debf765": { + "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": "inline-flex", + "flex": null, + "flex_flow": "row wrap", + "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": "110px" + } + }, + "bd89502aecc54c93a1dda2beb0111b1f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_796a4b69c2a644a0953d737bba4f3df3", + "placeholder": "​", + "style": "IPY_MODEL_2f23c48a75f2433496bf35e46ccea6e5", + "tabbable": null, + "tooltip": null, + "value": " 50/50 [00:00<00:00, 835.58member/s]" + } + }, + "bdc1367b07e94c11b1b1613c35b30829": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "c2b2c9ea72d2486cadb0993ad8b1d0c4": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_df1b86cf0b924767a3861b97faf81692", + "placeholder": "​", + "style": "IPY_MODEL_17011d2b92014de9a712002a3a90d042", + "tabbable": null, + "tooltip": null, + "value": " 50/50 [00:00<00:00, 788.68member/s]" + } + }, + "c573796821ff4b0c870cdb92dd99a6ce": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_798b550e06a54a2aa30a6a15f4c52e62", + "max": 50.0, + "min": 0.0, + "orientation": "horizontal", + "style": "IPY_MODEL_01c1fe8fed5b4bffb2ccbf0455100bd6", + "tabbable": null, + "tooltip": null, + "value": 50.0 + } + }, + "c959152f65634b9f80868583b7b15399": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "c98030fb0f074510be4ad72e6e7bf7c6": { + "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": "2", + "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 + } + }, + "c986510110d548419e56ae68ea77b9db": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_f7ffbb85a42941d0a5ef1703f503b3c3", + "placeholder": "​", + "style": "IPY_MODEL_62da06b8f5064af2af9e6bf8f42f9595", + "tabbable": null, + "tooltip": null, + "value": "100%" + } + }, + "ca38f21f4cb840cc876a72ff8c5cf39f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": "#285475", + "description_width": "" + } + }, + "cbf17f2943504daab370f591a737f004": { + "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": "inline-flex", + "flex": null, + "flex_flow": "row wrap", + "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": "110px" + } + }, + "ce75c8e56a184807acf143f60124aa43": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": "#285475", + "description_width": "" + } + }, + "cff875dfcf6e43d2957768d9b2c024e5": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_777dd001048c4eaa95ba238312e22627", + "placeholder": "​", + "style": "IPY_MODEL_698b841432364ccf8c3c98848505ce40", + "tabbable": null, + "tooltip": null, + "value": "100%" + } + }, + "d01f1b45c8c749148c5210669145cd79": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_4ccc08479d4e460ab06b2236e0515919", + "IPY_MODEL_a898613ef8e9475b85f2390a8da6d5bb", + "IPY_MODEL_6f0fbdd235464ae98e878ec10bd82e95" + ], + "layout": "IPY_MODEL_594910044fec4291a703d0025e218bea", + "tabbable": null, + "tooltip": null + } + }, + "d15683a3c4ec4cf2be078375b36f4499": { + "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 + } + }, + "d2f7bfd5533447a2bf0258b22601e2c2": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "d3b33f51cc8148f6b2a68a2d82da6582": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "d6c2c2896ead4a87907490022d9ea0e7": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_608d094a34d64da08e4cd3d0aac98698", + "max": 50.0, + "min": 0.0, + "orientation": "horizontal", + "style": "IPY_MODEL_950162989f304f61993d1e11e1512d12", + "tabbable": null, + "tooltip": null, + "value": 50.0 + } + }, + "db43d8405ade4efdac54c672dfafa1a0": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_62bdbe662c0743738f7586cf0c065970", + "placeholder": "​", + "style": "IPY_MODEL_f5444bb4c09d4e92840a3db467378001", + "tabbable": null, + "tooltip": null, + "value": "100%" + } + }, + "db63224516d840a98543ab3c2e397e14": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_4c1605c417ab41cfb63ede5131b47012", + "max": 50.0, + "min": 0.0, + "orientation": "horizontal", + "style": "IPY_MODEL_ce75c8e56a184807acf143f60124aa43", + "tabbable": null, + "tooltip": null, + "value": 50.0 + } + }, + "dbfab87d8a1647e4be2c56de947d7a2e": { + "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 + } + }, + "df1b86cf0b924767a3861b97faf81692": { + "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 + } + }, + "df616fa1b022487fb50b5eed9fed909c": { + "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": "2", + "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 + } + }, + "e0b06740fb0e4436bd6b2a6b7dae3bce": { + "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 + } + }, + "e21fa2c8ae414251a65f521366a34eec": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "e328364718954e8c84b5c525e22a12f4": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "e60a6e4165184befb055d7d4e5aa3940": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "e765c54a4a0141549a1f3aec77db0d44": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "e8367d7b036e439e90e722bf18e0c63d": { + "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 + } + }, + "eddc91fb8bfa4f0aa769d0c7187c73b3": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_e0b06740fb0e4436bd6b2a6b7dae3bce", + "placeholder": "​", + "style": "IPY_MODEL_d2f7bfd5533447a2bf0258b22601e2c2", + "tabbable": null, + "tooltip": null, + "value": " 50/50 [00:00<00:00, 819.90member/s]" + } + }, + "f0a6e1bab91145c5af645ea5ae3b6ecc": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_f34ce5bd6ea2456fa1453dcf5d4af1e7", + "placeholder": "​", + "style": "IPY_MODEL_bdc1367b07e94c11b1b1613c35b30829", + "tabbable": null, + "tooltip": null, + "value": " 50/50 [00:00<00:00, 832.76member/s]" + } + }, + "f24ec019bc144a87b6a0c43fac53d347": { + "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": "2", + "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 + } + }, + "f2a7b2c65fa14a92be8d0304140d65cd": { + "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": "2", + "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 + } + }, + "f30cfd8ced7e4993b10c21e76fd5c50b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "f34ce5bd6ea2456fa1453dcf5d4af1e7": { + "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 + } + }, + "f5444bb4c09d4e92840a3db467378001": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "f7ffbb85a42941d0a5ef1703f503b3c3": { + "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 + } + }, + "f860b569575340e1ae5f5ba5d349f7ce": { + "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": "2", + "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 + } + }, + "fcdf7c075bc54024beb752743b65d134": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_30914a3d846643019c183b9a99f2d661", + "placeholder": "​", + "style": "IPY_MODEL_fe5df146dcf345bb8e95431c5e770c8c", + "tabbable": null, + "tooltip": null, + "value": "100%" + } + }, + "fe5df146dcf345bb8e95431c5e770c8c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + } + }, + "version_major": 2, + "version_minor": 0 + } + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/docs/tutorials/pipt/jupyter_kernel.png b/docs/tutorials/pipt/jupyter_kernel.png deleted file mode 100644 index 90975fab..00000000 Binary files a/docs/tutorials/pipt/jupyter_kernel.png and /dev/null differ diff --git a/docs/tutorials/pipt/localization/5SPOT_PORO/tutorial_auto_adaptive_localization.ipynb b/docs/tutorials/pipt/localization/5SPOT_PORO/tutorial_auto_adaptive_localization.ipynb new file mode 100644 index 00000000..750b3bc6 --- /dev/null +++ b/docs/tutorials/pipt/localization/5SPOT_PORO/tutorial_auto_adaptive_localization.ipynb @@ -0,0 +1,359 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "07395e64", + "metadata": {}, + "source": [ + "# Auto-Adaptive Localization in PET\n", + "\n", + "**`AutoAdaptiveLocalization`** suppresses spurious sample correlations between state parameters and observations by estimating a noise threshold from shuffled ensembles and setting correlations below it to zero (or tapering them smoothly).\n", + "\n", + "This tutorial covers:\n", + "1. The maths behind correlation thresholding\n", + "2. The three threshold modes: `adaptive`, `fixed`, `universal`\n", + "3. The three taper types: `hard`, `soft`, `sigm`\n", + "4. How to configure it in a TOML file\n", + "5. Visualising the taper matrix on a synthetic example" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "54cd934d", + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "from pipt.localization import AutoAdaptiveLocalization" + ] + }, + { + "cell_type": "markdown", + "id": "6b6aa5e2", + "metadata": {}, + "source": [ + "## 1. Synthetic ensemble\n", + "\n", + "We build one illustrative synthetic case used in all sections: a 50x50 state field with one observation and a known localized Gaussian influence pattern. This makes taper behavior visually easy to interpret across threshold and taper options." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "816038bf", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "X shape: (2500, 120), Y shape: (1, 120)\n", + "Shared case: n=50, ne=120, center=(16, 14)\n" + ] + } + ], + "source": [ + "rng = np.random.default_rng(42)\n", + "n = 50\n", + "ne = 120\n", + "nx_ny = n * n\n", + "n_obs = 1\n", + "\n", + "# Shared synthetic case for the whole tutorial\n", + "X = 0.8 * rng.standard_normal((nx_ny, ne))\n", + "Y = 0.8 * rng.standard_normal((n_obs, ne))\n", + "\n", + "# Known localized Gaussian influence centered near the upper-left region\n", + "yy, xx = np.meshgrid(np.arange(n), np.arange(n), indexing=\"ij\")\n", + "cy, cx = 16, 14\n", + "dist2 = (yy - cy) ** 2 + (xx - cx) ** 2\n", + "influence = np.exp(-dist2 / (2 * 7.0**2)).reshape(-1)\n", + "influence /= influence.max()\n", + "\n", + "# Inject one latent signal into X and Y with spatially varying strength\n", + "signal = rng.standard_normal(ne)\n", + "X += (2.5 * influence)[:, None] * signal[None, :]\n", + "Y[0] += 2.5 * signal\n", + "\n", + "print(f\"X shape: {X.shape}, Y shape: {Y.shape}\")\n", + "print(f\"Shared case: n={n}, ne={ne}, center=({cy}, {cx})\")" + ] + }, + { + "cell_type": "markdown", + "id": "7df37c09", + "metadata": {}, + "source": [ + "## 2. Threshold modes\n", + "\n", + "| Mode | Formula | When to use |\n", + "|------|---------|-------------|\n", + "| `adaptive` *(default)* | `cutoff × σ_noise` | General purpose; `cutoff` tunes sensitivity |\n", + "| `fixed` | `cutoff` directly | When you want a hard, reproducible cut-off |\n", + "| `universal` | `√(2 log N) × σ_noise` | Automatic; no `cutoff` tuning needed |\n", + "\n", + "`σ_noise` is estimated column-wise from shuffled correlations using the MAD estimator." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "ba7f3001", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, axes = plt.subplots(1, 3, figsize=(15, 4))\n", + "\n", + "for ax, (mode, kw) in zip(axes, [\n", + " (\"adaptive\", {\"threshold\": \"adaptive\", \"cutoff\": 0.5}),\n", + " (\"fixed\", {\"threshold\": \"fixed\", \"cutoff\": 0.5}),\n", + " (\"universal\", {\"threshold\": \"universal\", \"cutoff\": 0.5}),\n", + "]):\n", + " loc = AutoAdaptiveLocalization({\"name\": \"autoadaloc\", \"field\": [n, n], **kw})\n", + " taper = loc(X, Y, parameters=[\"PORO\"], prior_info={\"PORO\": {\"active\": nx_ny}})\n", + " im = ax.imshow(taper[:, 0].reshape(n, n), cmap=\"hot_r\", vmin=0, vmax=1)\n", + " ax.set_title(f\"threshold='{mode}'\")\n", + " plt.colorbar(im, ax=ax, fraction=0.046)\n", + "\n", + "plt.suptitle(\"Taper masks on the shared localized synthetic case\")\n", + "plt.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "e797c822", + "metadata": {}, + "source": [ + "## 3. Taper types (illustrative case)\n", + "\n", + "Once the threshold is known, three strategies apply.\n", + "To make the differences obvious, we build a synthetic case with a known localized Gaussian influence around one observation.\n", + "\n", + "| Type | Shape | Notes |\n", + "|------|-------|-------|\n", + "| `hard` *(default)* | Binary 0/1 | Fastest; sharp cut-off |\n", + "| `soft` | Smooth rational function | Gradual transition around threshold |\n", + "| `sigm` | Sigmoid | Smooth transition; steeper than `soft` near the threshold |\n", + "\n", + "In the profile plots, the dashed black line is the injected influence pattern (normalized), used as a visual reference." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "cb2f08d4", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Reuse the same shared synthetic case from Section 1\n", + "raw_corr = np.abs(AutoAdaptiveLocalization.corr_matrix(X, Y)[:, 0]).reshape(n, n)\n", + "\n", + "fig0, ax0 = plt.subplots(1, 2, figsize=(10, 4))\n", + "im0 = ax0[0].imshow(influence.reshape(n, n), cmap=\"viridis\", vmin=0, vmax=1)\n", + "ax0[0].set_title(\"Injected influence (ground truth)\")\n", + "ax0[0].set_xticks([])\n", + "ax0[0].set_yticks([])\n", + "plt.colorbar(im0, ax=ax0[0], fraction=0.046)\n", + "\n", + "im1 = ax0[1].imshow(raw_corr, cmap=\"magma\", vmin=0, vmax=1)\n", + "ax0[1].set_title(\"Raw |corr(X, Y0)|\")\n", + "ax0[1].set_xticks([])\n", + "ax0[1].set_yticks([])\n", + "plt.colorbar(im1, ax=ax0[1], fraction=0.046)\n", + "\n", + "plt.suptitle(\"Illustrative synthetic case for taper comparison\")\n", + "plt.tight_layout()\n", + "plt.show()\n", + "\n", + "# Compare taper types using a fixed threshold\n", + "fig, axes = plt.subplots(2, 3, figsize=(15, 8), sharex=\"row\")\n", + "for j, ttype in enumerate([\"hard\", \"soft\", \"sigm\"]):\n", + " loc = AutoAdaptiveLocalization({\n", + " \"name\": \"autoadaloc\",\n", + " \"field\": [n, n],\n", + " \"threshold\": \"fixed\",\n", + " \"cutoff\": 0.4,\n", + " \"type\": ttype,\n", + " })\n", + "\n", + " taper = loc(\n", + " X,\n", + " Y,\n", + " parameters=[\"PORO\"],\n", + " prior_info={\"PORO\": {\"active\": nx_ny}},\n", + " )\n", + "\n", + " taper2d = taper[:, 0].reshape(n, n)\n", + "\n", + " # Row 1: spatial taper map\n", + " im = axes[0, j].imshow(taper2d, cmap=\"bone_r\", vmin=0, vmax=1)\n", + " axes[0, j].set_title(f\"type='{ttype}'\")\n", + " axes[0, j].set_xticks([])\n", + " axes[0, j].set_yticks([])\n", + " plt.colorbar(im, ax=axes[0, j], fraction=0.046)\n", + "\n", + " # Row 2: center-row profile against injected influence\n", + " taper_line = taper2d[cy, :]\n", + " ref_line = influence.reshape(n, n)[cy, :]\n", + " axes[1, j].plot(taper_line, lw=2, label=\"taper\")\n", + " axes[1, j].plot(ref_line, \"k--\", lw=1.5, label=\"injected influence (ref)\")\n", + " axes[1, j].set_ylim(-0.05, 1.05)\n", + " axes[1, j].set_xlabel(\"grid x\")\n", + " if j == 0:\n", + " axes[1, j].set_ylabel(\"value\")\n", + " if j == 2:\n", + " axes[1, j].legend(loc=\"lower left\", frameon=False)\n", + "\n", + "plt.suptitle(\"Taper comparison on a known localized pattern\")\n", + "plt.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "96b0b10f", + "metadata": {}, + "source": [ + "## 4. Effect of `cutoff`\n", + "\n", + "Higher `cutoff` → stricter suppression → sparser taper. Lower values let more correlations through." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "4238aa5e", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "cutoffs = [0.0, 0.2, 0.5, 0.8, 1.0]\n", + "fig, axes = plt.subplots(1, len(cutoffs), figsize=(16, 4))\n", + "\n", + "for ax, c in zip(axes, cutoffs):\n", + " loc = AutoAdaptiveLocalization({\n", + " \"name\": \"autoadaloc\", \"field\": [n, n],\n", + " \"threshold\": \"fixed\", \"cutoff\": c,\n", + " })\n", + " taper = loc(X, Y, parameters=[\"PORO\"], prior_info={\"PORO\": {\"active\": nx_ny}})\n", + " density = taper[:, 0].mean()\n", + " im = ax.imshow(taper[:, 0].reshape(n, n), cmap=\"bone_r\", vmin=0, vmax=1)\n", + " ax.set_title(f\"cutoff={c} (density={density:.2f})\")\n", + " plt.colorbar(im, ax=ax, fraction=0.046)\n", + "\n", + "plt.suptitle(\"Sensitivity to cutoff on the shared synthetic case\")\n", + "plt.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "25c8e622", + "metadata": {}, + "source": [ + "## 5. TOML / YAML configuration\n", + "\n", + "**TOML:**\n", + "```toml\n", + "[dataassim.localization]\n", + "name = \"autoadaloc\"\n", + "field = [1, 50, 50] # [nz, nx, ny]\n", + "threshold = \"adaptive\" # default\n", + "cutoff = 1.5\n", + "type = \"hard\" # default\n", + "```\n", + "\n", + "**YAML:**\n", + "```yaml\n", + "dataassim:\n", + " localization:\n", + " name: autoadaloc\n", + " field: [1, 50, 50]\n", + " threshold: adaptive # default\n", + " cutoff: 1.5\n", + " type: hard # default\n", + "```\n", + "\n", + "All keys are optional except `name` and `field`. The minimal block is:\n", + "\n", + "```toml\n", + "[dataassim.localization]\n", + "name = \"autoadaloc\"\n", + "field = [50, 50]\n", + "```\n", + "```yaml\n", + "dataassim:\n", + " localization:\n", + " name: autoadaloc\n", + " field: [50, 50]\n", + "```" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "venv-PET (3.12.3.final.0)", + "language": "python", + "name": "python3" + }, + "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.12.3" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/docs/tutorials/pipt/localization/5SPOT_PORO/tutorial_distance_localization.ipynb b/docs/tutorials/pipt/localization/5SPOT_PORO/tutorial_distance_localization.ipynb new file mode 100644 index 00000000..a438f3f7 --- /dev/null +++ b/docs/tutorials/pipt/localization/5SPOT_PORO/tutorial_distance_localization.ipynb @@ -0,0 +1,478 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "a2cda7ed", + "metadata": {}, + "source": [ + "# Distance-Based Localization in PET\n", + "\n", + "**`DistanceLocalization`** builds a sparse localization operator by placing a spatial kernel around each observation's well location. Only state cells within kernel range receive non-zero weights.\n", + "\n", + "This tutorial covers:\n", + "1. The three kernel types: `gc` (Gaspari-Cohn), `fb` (Furrer-Bengtsson), `region`\n", + "2. Configuring entries (Python dict, CSV file, TOML)\n", + "3. `radius`, wildcards, and multiple entries\n", + "4. Visualising the tapering matrix" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "b513b257", + "metadata": {}, + "outputs": [], + "source": [ + "import pandas as pd\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "from misc.structures import PETDataFrame\n", + "from pipt.localization import DistanceLocalization" + ] + }, + { + "cell_type": "markdown", + "id": "383d844c", + "metadata": {}, + "source": [ + "## 1. Build synthetic observed data\n", + "\n", + "To keep this tutorial self-contained, we create synthetic observation data for two wells (`WOPR:W1`, `WOPR:W2`) at a few report times.\n", + "These synthetic values are only used to demonstrate localization setup and plotting." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "1c5f2132", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Synthetic data:\n", + " WOPR:W1 WOPR:W2\n", + "time \n", + "2005-01-01 1200.0 900.0\n", + "2005-01-15 1150.0 940.0\n", + "2005-02-01 1090.0 980.0\n", + "\n", + "\n", + "Well 1: WOPR:W1 at (14, 14)\n", + "Well 2: WOPR:W2 at (34, 34)\n" + ] + } + ], + "source": [ + "# Two synthetic wells (not at corners) used throughout the tutorial\n", + "well1_name, well1_x, well1_y = \"WOPR:W1\", 14, 14\n", + "well2_name, well2_x, well2_y = \"WOPR:W2\", 34, 34\n", + "\n", + "dates = pd.to_datetime([\"2005-01-01\", \"2005-01-15\", \"2005-02-01\"])\n", + "synthetic_df = pd.DataFrame(\n", + " {\n", + " well1_name: [1200.0, 1150.0, 1090.0],\n", + " well2_name: [900.0, 940.0, 980.0],\n", + " },\n", + " index=dates,\n", + ")\n", + "synthetic_df.index.name = \"time\"\n", + "\n", + "# Build PETDataFrame\n", + "data = PETDataFrame.from_pandas(synthetic_df)\n", + "\n", + "print(\"Synthetic data:\")\n", + "print(data)\n", + "print('\\n')\n", + "print(f\"Well 1: {well1_name} at ({well1_x}, {well1_y})\")\n", + "print(f\"Well 2: {well2_name} at ({well2_x}, {well2_y})\")" + ] + }, + { + "cell_type": "markdown", + "id": "bedc066d", + "metadata": {}, + "source": [ + "## 2. Kernel types\n", + "\n", + "| Kernel | Tag | Profile | Compact support |\n", + "|--------|-----|---------|-----------------|\n", + "| Gaspari-Cohn | `gc` | Smooth polynomial | `2 × radius` cells |\n", + "| Furrer-Bengtsson | `fb` | Ensemble-size aware | `radius` cells |\n", + "| Region | `region` | Binary (0/1) | 1 cell (point mask) |\n", + "\n", + "For this comparison, Well 1 is at `(14, 14)` on a 50×50×1 grid.\n", + "In all spatial maps below, the red `x` marks the observation (measurement) location used to center the localization kernel." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "89a971f9", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, axes = plt.subplots(1, 3, figsize=(15, 5))\n", + "\n", + "for ax, taper_tag in zip(axes, [\"gc\", \"fb\", \"region\"]):\n", + " loc = DistanceLocalization(\n", + " info={\n", + " \"name\": \"distance_loc\",\n", + " \"field\": [1, 50, 50],\n", + " \"entries\": [\n", + " {\"taper\": taper_tag, \"x\": well1_x, \"y\": well1_y, \"radius\": 15,\n", + " \"data_type\": well1_name, \"time\": \"2005-01-01\", \"param\": \"PORO\"},\n", + " ],\n", + " },\n", + " data=data,\n", + " parameters=[\"PORO\"],\n", + " prior_info={\"PORO\": {\"nx\": 50, \"ny\": 50, \"nz\": 1}},\n", + " )\n", + " T = loc(curr_data=[well1_name], curr_time=[pd.Timestamp(\"2005-01-01\")])\n", + " mask = T.toarray()[:, 0].reshape(50, 50, order=\"F\")\n", + " im = ax.imshow(mask, cmap=\"bone_r\", origin=\"lower\", vmin=0, vmax=1)\n", + " ax.scatter([well1_x], [well1_y], c=\"tomato\", s=40, marker=\"x\", linewidths=1.8)\n", + " ax.text(\n", + " well1_x + 1, well1_y + 1, well1_name,\n", + " color=\"tomato\", fontsize=9, weight=\"bold\",\n", + " bbox={\"facecolor\": \"white\", \"alpha\": 0.7, \"edgecolor\": \"none\", \"pad\": 1},\n", + " )\n", + " ax.set_title(f\"taper='{taper_tag}' radius=15\")\n", + " plt.colorbar(im, ax=ax, fraction=0.046)\n", + "\n", + "plt.suptitle(f\"Kernel types — {well1_name} at ({well1_x}, {well1_y})\")\n", + "plt.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "d3439624", + "metadata": {}, + "source": [ + "## 3. Effect of `radius`\n", + "\n", + "`radius` is the kernel half-radius in grid cells. Gaspari-Cohn support extends to `2 × radius`." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "3f57e289", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "radii = [5, 15, 25, 40]\n", + "fig, axes = plt.subplots(1, len(radii), figsize=(16, 4))\n", + "\n", + "for ax, r in zip(axes, radii):\n", + " loc = DistanceLocalization(\n", + " info={\n", + " \"name\": \"distance_loc\",\n", + " \"field\": [1, 50, 50],\n", + " \"entries\": [{\"taper\": \"gc\", \"x\": well1_x, \"y\": well1_y, \"radius\": r}],\n", + " },\n", + " data=data,\n", + " parameters=[\"PORO\"],\n", + " prior_info={\"PORO\": {\"nx\": 50, \"ny\": 50, \"nz\": 1}},\n", + " )\n", + " T = loc(curr_data=[well1_name], curr_time=[pd.Timestamp(\"2005-01-01\")])\n", + " mask = T.toarray()[:, 0].reshape(50, 50, order=\"F\")\n", + " im = ax.imshow(mask, cmap=\"bone_r\", origin=\"lower\", vmin=0, vmax=1)\n", + " ax.scatter([well1_x], [well1_y], c=\"tomato\", s=40, marker=\"x\", linewidths=1.8)\n", + " ax.text(\n", + " well1_x + 1, well1_y + 1, well1_name,\n", + " color=\"tomato\", fontsize=8, weight=\"bold\",\n", + " bbox={\"facecolor\": \"white\", \"alpha\": 0.7, \"edgecolor\": \"none\", \"pad\": 1},\n", + " )\n", + " ax.set_title(f\"radius={r}\")\n", + " plt.colorbar(im, ax=ax, fraction=0.046)\n", + "\n", + "plt.suptitle(f\"Gaspari-Cohn — well at ({well1_x}, {well1_y})\")\n", + "plt.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "f1120902", + "metadata": {}, + "source": [ + "## 4. Two synthetic wells — per-observation entries\n", + "\n", + "Each entry targets one `data_type`. Here we use two synthetic wells, `WOPR:W1` and `WOPR:W2`, with different kernels and radii.\n", + "Omitting `time` and `param` applies the entry to all times and parameters." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "9125f11f", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "loc = DistanceLocalization(\n", + " info={\n", + " \"name\": \"distance_loc\",\n", + " \"field\": [1, 50, 50],\n", + " \"entries\": [\n", + " {\"taper\": \"gc\", \"x\": well1_x, \"y\": well1_y, \"radius\": 20, \"data_type\": well1_name},\n", + " {\"taper\": \"fb\", \"x\": well2_x, \"y\": well2_y, \"radius\": 30, \"data_type\": well2_name},\n", + " ],\n", + " },\n", + " data=data,\n", + " parameters=[\"PORO\"],\n", + " prior_info={\"PORO\": {\"nx\": 50, \"ny\": 50, \"nz\": 1}},\n", + ")\n", + "\n", + "T = loc(curr_data=[well1_name, well2_name], curr_time=[pd.Timestamp(\"2005-01-01\")])\n", + "T = T.toarray()\n", + "\n", + "obs_xy = [(well1_x, well1_y), (well2_x, well2_y)]\n", + "obs_names = [well1_name, well2_name]\n", + "titles = [\n", + " f\"{well1_name} gc r=20\",\n", + " f\"{well2_name} fb r=30\",\n", + "]\n", + "\n", + "fig, axes = plt.subplots(1, 2, figsize=(12, 5))\n", + "for ax, col, title, (ox, oy), obs_name in zip(axes, [0, 1], titles, obs_xy, obs_names):\n", + " im = ax.imshow(T[:, col].reshape(50, 50, order=\"F\"),\n", + " cmap=\"bone_r\", origin=\"lower\", vmin=0, vmax=1)\n", + " ax.scatter([ox], [oy], c=\"tomato\", s=40, marker=\"x\", linewidths=1.8)\n", + " ax.text(\n", + " ox + 1, oy + 1, obs_name,\n", + " color=\"tomato\", fontsize=9, weight=\"bold\",\n", + " bbox={\"facecolor\": \"white\", \"alpha\": 0.7, \"edgecolor\": \"none\", \"pad\": 1},\n", + " )\n", + " ax.set_title(title)\n", + " plt.colorbar(im, ax=ax, fraction=0.046)\n", + "\n", + "plt.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "f642e919", + "metadata": {}, + "source": [ + "## 5. 3D case (layered reservoir)\n", + "\n", + "Yes, distance-based localization also works in 3D.\n", + "This example uses a 6-layer grid and places one observation in the middle layer. We visualize several horizontal slices and one vertical profile through the well to show decay in both lateral and vertical directions." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "467a9bde", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(9600, 1)\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# 3D example: one synthetic observation localized in a layered grid\n", + "nz, nx, ny = 6, 40, 40\n", + "well_x, well_y, well_z = 20, 20, 2\n", + "\n", + "loc3d = DistanceLocalization(\n", + " info={\n", + " \"name\": \"distance_loc\",\n", + " \"field\": [nz, nx, ny],\n", + " \"entries\": [\n", + " {\n", + " \"taper\": \"gc\",\n", + " \"x\": well_x, \"y\": well_y, \"z\": well_z,\n", + " \"radius\": 9,\n", + " \"z_range\": 1,\n", + " \"data_type\": well1_name,\n", + " \"time\": \"2005-01-01\",\n", + " \"param\": \"PORO\",\n", + " },\n", + " ],\n", + " },\n", + " data=data,\n", + " parameters=[\"PORO\"],\n", + " prior_info={\"PORO\": {\"nx\": nx, \"ny\": ny, \"nz\": nz}},\n", + ")\n", + "\n", + "T3 = loc3d(curr_data=[well1_name], curr_time=[pd.Timestamp(\"2005-01-01\")]).toarray()\n", + "print(T3.shape)\n", + "mask3d = T3[:, 0].reshape(nx, ny, nz, order=\"F\")\n", + "\n", + "# Show horizontal slices across layers\n", + "slice_layers = [0, 2, 5]\n", + "fig, axes = plt.subplots(1, len(slice_layers), figsize=(14, 4))\n", + "for ax, k in zip(axes, slice_layers):\n", + " im = ax.imshow(mask3d[:, :, k].T, cmap=\"bone_r\", origin=\"lower\", vmin=0, vmax=1)\n", + " ax.set_title(f\"layer z={k}\")\n", + " ax.scatter([well_x], [well_y], c=\"tomato\", s=35, marker=\"x\")\n", + " ax.text(\n", + " well_x + 1, well_y + 1, well1_name,\n", + " color=\"tomato\", fontsize=9, weight=\"bold\",\n", + " bbox={\"facecolor\": \"white\", \"alpha\": 0.7, \"edgecolor\": \"none\", \"pad\": 1},\n", + " )\n", + " plt.colorbar(im, ax=ax, fraction=0.046)\n", + "\n", + "plt.suptitle(\"3D Gaspari-Cohn localization slices\")\n", + "plt.tight_layout()\n", + "plt.show()\n", + "\n", + "# Vertical profile through the well location\n", + "vertical = mask3d[well_x, well_y, :]\n", + "plt.figure(figsize=(5, 3.5))\n", + "plt.plot(np.arange(nz), vertical, marker=\"o\", lw=2)\n", + "plt.axvline(well_z, color=\"tomato\", ls=\"--\", lw=1.5, label=\"measurement layer\")\n", + "plt.xlabel(\"z layer\")\n", + "plt.ylabel(\"taper value\")\n", + "plt.ylim(-0.05, 1.05)\n", + "plt.title(f\"Vertical taper profile at {well1_name} (x={well_x}, y={well_y})\")\n", + "plt.grid(alpha=0.3)\n", + "plt.legend(frameon=False)\n", + "plt.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "995ca046", + "metadata": {}, + "source": [ + "## 6. CSV file and TOML / YAML configuration\n", + "\n", + "**`loc_entries.csv`** — one row per entry, space-separated:\n", + "```\n", + "# taper x y z radius z_range aniso rotation data_type time param\n", + "gc 14 14 0 20 : 1.0 0.0 WOPR:W1 2005-01-01 PORO\n", + "fb 34 34 0 30 : 1.0 0.0 WOPR:W2 2005-01-01 PORO\n", + "```\n", + "Use `*` in `data_type`, `time`, or `param` to match all values.\n", + "\n", + "---\n", + "\n", + "**TOML** — reference the CSV or use inline entries:\n", + "```toml\n", + "[dataassim.localization]\n", + "name = \"distance_loc\"\n", + "field = [1, 50, 50] # [nz, nx, ny]\n", + "entries = \"loc_entries.csv\"\n", + "```\n", + "Or inline:\n", + "```toml\n", + "[dataassim.localization]\n", + "name = \"distance_loc\"\n", + "field = [1, 50, 50]\n", + "entries = [\n", + " {taper=\"gc\", x=14, y=14, radius=20, data_type=\"WOPR:W1\"},\n", + " {taper=\"fb\", x=34, y=34, radius=30, data_type=\"WOPR:W2\"},\n", + "]\n", + "```\n", + "\n", + "---\n", + "\n", + "**YAML** — equivalent configuration:\n", + "```yaml\n", + "dataassim:\n", + " localization:\n", + " name: distance_loc\n", + " field: [1, 50, 50]\n", + " entries: loc_entries.csv\n", + "```\n", + "Or inline:\n", + "```yaml\n", + "dataassim:\n", + " localization:\n", + " name: distance_loc\n", + " field: [1, 50, 50]\n", + " entries:\n", + " - {taper: gc, x: 14, y: 14, radius: 20, data_type: \"WOPR:W1\"}\n", + " - {taper: fb, x: 34, y: 34, radius: 30, data_type: \"WOPR:W2\"}\n", + "```\n", + "\n", + "Optional entry fields: `z=0`, `z_range=\":\"`, `aniso=1.0`, `rotation=0.0`, `time=\"*\"`, `param=\"*\"`" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "venv-PET (3.12.3.final.0)", + "language": "python", + "name": "python3" + }, + "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.12.3" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/docs/tutorials/pipt/true_data.csv b/docs/tutorials/pipt/true_data.csv deleted file mode 100644 index 7b71d33b..00000000 --- a/docs/tutorials/pipt/true_data.csv +++ /dev/null @@ -1,10 +0,0 @@ -3206.1643,1987.9631,1065.9841,0.13173291,3.8683615e-06,1.1263041e-07,5623.6016,1885.6818,1257.3524 -3266.9717,2012.8158,1047.4318,2.4454727,0.000111172936,2.884899e-06,6115.081,1974.2863,1251.7607 -3289.8975,2104.009,1104.5723,18.57857,0.0014210797,3.2323213e-05,6162.225,2003.3813,1260.366 -3153.4924,2199.685,1172.2677,84.85923,0.01113214,0.00021175515,6067.3267,1989.0044,1247.8177 -2804.8997,2298.32,1227.9575,302.24408,0.06683203,0.0009664455,5910.1406,1955.4485,1228.9327 -2377.446,2370.2407,1263.4275,692.1582,0.32635704,0.0034318906,5794.84,1931.1086,1212.0724 -1959.8289,2413.9614,1283.7205,1123.388,1.2904354,0.01007478,5721.0337,1922.3533,1202.4875 -1585.4658,2429.8596,1294.185,1587.4271,4.191758,0.025624914,5686.736,1923.3035,1197.3948 -1308.9434,2411.0825,1296.4686,2011.7366,11.3020115,0.058260355,5696.123,1937.3766,1200.2947 -1097.5681,2360.5327,1295.3679,2390.4883,25.935778,0.120828636,5716.646,1954.3308,1205.7493 diff --git a/docs/tutorials/pipt/tutorial_pipt.ipynb b/docs/tutorials/pipt/tutorial_pipt.ipynb deleted file mode 100644 index 5e015952..00000000 --- a/docs/tutorials/pipt/tutorial_pipt.ipynb +++ /dev/null @@ -1,774 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Tutorial for running the Python Inverse Problem Toolbox (PIPT)\n", - "\n", - "As an illustrative example we choose a small 3D-field with three producers and three (water) injectors. The figure below shows the true (data generating) permeability field and the well positions. The grid is 10x10x2, and the porosity is 0.2. The inverse problem is to find the permeability for the reservoir by assimilation produced water and oil and injected water. \n", - "\n", - "\"drawing\"\n", - "
\n", - "The first step is to load neccessary external and local modules. " - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "metadata": { - "scrolled": false - }, - "outputs": [ - { - "data": { - "text/html": [ - "" - ], - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "# Set width\n", - "from IPython.display import display, HTML\n", - "display(HTML(\"\"))\n", - "\n", - "# Import global modules\n", - "import numpy as np\n", - "from glob import glob\n", - "import os\n", - "import matplotlib.pyplot as plt \n", - "\n", - "# Import local modules\n", - "from pipt.loop.ensemble import Ensemble # this class contains the data\n", - "from pipt.loop.assimilation import Assimilate # this class contains the iterative assimilation loop\n", - "from subsurface.multphaseflow.opm import flow # the simulator we want to use\n", - "from input_output import read_config # functions for reading input\n", - "from pipt import pipt_init # script for initializing the module with the data assimilation method \n", - "from plot_objective_function import combined # plot the data mismatch\n", - "from plot_parameters import plot_layer, export_to_grid # plot the parameters\n", - "from plot_data import plot_prod # plot the production data" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Set the random seed:" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": { - "scrolled": true - }, - "outputs": [], - "source": [ - "np.random.seed(10) " - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Remove old results and folders, if present:" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": { - "scrolled": true - }, - "outputs": [], - "source": [ - "for folder in glob('En_*'):\n", - " shutil.rmtree(folder)\n", - "for file in glob('debug_analysis_step_*'):\n", - " os.remove(file)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Read inputfile. In this tutorial the input file is written as a .toml file, and consists of two main keys: dataassim and fwdsim. The first part contains the options for the data assimilation algorithm and the second part are options related to the forward simulation model. The description of all keys are provided in the printouts of method docstrings below." - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": { - "scrolled": false - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[ensemble]\r\n", - "ne = 50.0\r\n", - "state = \"permx\"\r\n", - "prior_permx = [[\"vario\", \"sph\"], [\"mean\", \"priormean.npz\"], [\"var\", 1.0], [\"range\", 10.0], [\"aniso\", 1.0],\r\n", - " [\"angle\", 0.0], [\"grid\", [10.0, 10.0, 2.0]]]\r\n", - " \r\n", - "[dataassim]\r\n", - "daalg = [\"esmda\", \"esmda\"]\r\n", - "analysis = \"approx\"\r\n", - "energy = 98.0\r\n", - "obsvarsave = \"yes\"\r\n", - "restartsave = \"no\"\r\n", - "analysisdebug = [\"pred_data\", \"state\", \"data_misfit\", \"prev_data_misfit\"]\r\n", - "restart = \"no\"\r\n", - "obsname = \"days\"\r\n", - "truedataindex = [400, 800, 1200, 1600, 2000, 2400, 2800, 3200, 3600, 4000]\r\n", - "truedata = \"true_data.csv\"\r\n", - "assimindex = [0,1,2,3,4,5,6,7,8,9]\r\n", - "datatype = [\"WOPR PRO1\", \"WOPR PRO2\", \"WOPR PRO3\", \"WWPR PRO1\", \"WWPR PRO2\",\r\n", - " \"WWPR PRO3\", \"WWIR INJ1\", \"WWIR INJ2\", \"WWIR INJ3\"]\r\n", - "staticvar = \"permx\"\r\n", - "datavar = \"var.csv\"\r\n", - "mda = [ [\"tot_assim_steps\", 3], ['inflation_param', [2, 4, 4]] ]\r\n", - "\r\n", - "[fwdsim]\r\n", - "reporttype = \"days\"\r\n", - "reportpoint = [400, 800, 1200, 1600, 2000, 2400, 2800, 3200, 3600, 4000]\r\n", - "replace = \"yes\"\r\n", - "saveforecast = \"yes\"\r\n", - "sim_limit = 300.0\r\n", - "rerun = 1\r\n", - "runfile = \"runfile\"\r\n", - "datatype = [\"WOPR PRO1\", \"WOPR PRO2\", \"WOPR PRO3\", \"WWPR PRO1\", \"WWPR PRO2\",\r\n", - " \"WWPR PRO3\", \"WWIR INJ1\", \"WWIR INJ2\", \"WWIR INJ3\"]\r\n", - "parallel = 4\r\n", - "startdate = \"1/1/2022\"\r\n" - ] - } - ], - "source": [ - "!cat 3D_ESMDA.toml\n", - "kd, kf, ke = read_config.read_toml('3D_ESMDA.toml')" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Initialize the simulator with simulator keys." - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": { - "scrolled": false - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - " The inputs are all optional, but in the same fashion as the other simulators a system must be followed.\n", - " The input_dict can be utilized as a single input. Here all nescessary info is stored. Alternatively,\n", - " if input_dict is not defined, all the other input variables must be defined.\n", - "\n", - " Parameters\n", - " ----------\n", - " input_dict : dict, optional\n", - " Dictionary containing all information required to run the simulator.\n", - "\n", - " - parallel: number of forward simulations run in parallel\n", - " - simoptions: options for the simulations\n", - " - mpi: option to use mpi (always use > 2 cores)\n", - " - sim_path: Path to the simulator\n", - " - sim_flag: Flags sent to the simulator (see simulator documentation for all possibilities)\n", - " - sim_limit: maximum number of seconds a simulation can run before being killed\n", - " - runfile: name of the simulation input file\n", - " - reportpoint: these are the dates the simulator reports results\n", - " - reporttype: this key states that the report poins are given as dates\n", - " - datatype: the data types the simulator reports\n", - "\n", - " filename : str, optional\n", - " Name of the .mako file utilized to generate the ECL input .DATA file. Must be in uppercase for the\n", - " ECL simulator.\n", - "\n", - " options : dict, optional\n", - " Dictionary with options for the simulator.\n", - "\n", - " Returns\n", - " -------\n", - " initial_object : object\n", - " Initial object from the class ecl_100.\n", - " \n" - ] - } - ], - "source": [ - "sim = flow(kf)\n", - "print(flow.__init__.__doc__)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Print the Ensemble options:" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - " Parameters\n", - " ----------\n", - " keys_da : dict\n", - " Options for the data assimilation class\n", - "\n", - " - daalg: spesification of the method, first the main type (e.g., \"enrml\"), then the solver (e.g., \"gnenrml\")\n", - " - analysis: update flavour (\"approx\", \"full\" or \"subspace\")\n", - " - energy: percent of singular values kept after SVD\n", - " - obsvarsave: save the observations as a file (default false)\n", - " - restart: restart optimization from a restart file (default false)\n", - " - restartsave: save a restart file after each successful iteration (defalut false)\n", - " - analysisdebug: specify which class variables to save to the result files\n", - " - truedataindex: order of the simulated data (for timeseries this is points in time)\n", - " - obsname: unit for truedataindex (for timeseries this is days or hours or seconds, etc.)\n", - " - truedata: the data, e.g., provided as a .csv file\n", - " - assimindex: index for the data that will be used for assimilation\n", - " - datatype: list with the name of the datatypes\n", - " - staticvar: name of the static variables\n", - " - datavar: data variance, e.g., provided as a .csv file\n", - "\n", - " keys_en : dict\n", - " Options for the ensemble class\n", - "\n", - " - ne: number of perturbations used to compute the gradient\n", - " - state: name of state variables passed to the .mako file\n", - " - prior_: the prior information the state variables, including mean, variance and variable limits\n", - "\n", - " sim : callable\n", - " The forward simulator (e.g. flow)\n", - " \n" - ] - } - ], - "source": [ - "print(Ensemble.__init__.__doc__)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Example using ESMDA. The input and available options are given below. During assimilation, useful information is written to the screen. The same information is also written to a log-file named pet_logger.log. " - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": { - "scrolled": false - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1;33mSingle entry for VARIO will be copied to all 2 layers\u001b[1;m\n", - "\u001b[1;33mSingle entry for VAR will be copied to all 2 layers\u001b[1;m\n", - "\u001b[1;33mSingle entry for ANISO will be copied to all 2 layers\u001b[1;m\n", - "\u001b[1;33mSingle entry for ANGLE will be copied to all 2 layers\u001b[1;m\n", - "\u001b[1;33mSingle entry for RANGE will be copied to all 2 layers\u001b[1;m\n", - "\n", - " The class is initialized by passing the keywords and simulator object upwards in the hierarchy.\n", - "\n", - " Parameters\n", - " ----------\n", - " keys_da['mda']: list\n", - " - tot_assim_steps: total number of iterations in MDA, e.g., 3\n", - " - inflation_param: covariance inflation factors, e.g., [2, 4, 4]\n", - "\n", - " keys_en : dict\n", - "\n", - " sim : callable\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "\r", - "Iterations (Obj. func. val: ): 0%| | 0/4 [00:00Plot the data mismatch:" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "metadata": { - "scrolled": false - }, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "combined()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Plot the prior and posterior permeability in the upper layer:" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "metadata": { - "scrolled": false - }, - "outputs": [ - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAgsAAAGzCAYAAAChLlRLAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/OQEPoAAAACXBIWXMAAA9hAAAPYQGoP6dpAAA71klEQVR4nO3de3wU5b3H8e8mgU2MSTBRctEAEVEuIigoRTiCmppGRKgoB0/QgFasBjVQEWgFBIEUpJrDpaRai6iglSqoVPAgItQWwk184Y1LGyBCE7RAFoIJye6cPyhbV5Jhwm52dsnn/XrN6+U+88zMb5eY/eX3PM+MwzAMQwAAAPWIsDsAAAAQ2kgWAACAKZIFAABgimQBAACYIlkAAACmSBYAAIApkgUAAGCKZAEAAJgiWQAAAKZIFmCrYcOGqU2bNnaHAT/07dtXffv2tTsMAI2IZAFn7aWXXpLD4fBu0dHRuvzyyzVy5EiVl5fbHR7O0nvvvaennnrK7jCCYuPGjXr44YfVrVs3NWvWTA6Hw+6QgJBEsgC/TZkyRa+88ormzp2r66+/XvPnz1fPnj11/PjxMx77wgsvaMeOHUGIEla99957mjx5st1hBMV7772n3//+93I4HLr00kvtDgcIWSQL8Ft2draGDh2qn/3sZ3rppZeUn5+vkpISvf322/UeU1lZKUlq1qyZnE5nQOLweDyqqqoKyLkCzUrihMA708/EQw89pIqKCm3evFk//vGPgxgZEF5IFhBwN910kySppKRE0sl5Ceeff77+/ve/69Zbb1VcXJxycnK8+344Z6GyslK/+MUvlJ6eLqfTqSuuuEKzZs3SDx+Q6nA4NHLkSC1atEidOnWS0+nUypUrGxTrU089JYfDoa+++kqDBw9WfHy8kpKS9Nhjj9X5JfPqq6+qW7duiomJUWJiooYMGaLS0lKfPn379tWVV16pLVu26IYbbtB5552nX/7yl9qzZ48cDodmzZqlefPm6dJLL9V5552nW265RaWlpTIMQ08//bQuueQSxcTEaMCAATp06JD3vB9++KEiIiI0ceJEn+stXrxYDodD8+fPN32vf/nLX3TXXXepVatWcjqdSk9P16hRo/Tdd995+wwbNkzz5s3zfr6ntoY4ceKEJk6cqG7duikhIUGxsbH6r//6L61Zs8bbxzAMtWnTRgMGDDjt+KqqKiUkJOjBBx/0tlVXV2vSpEm67LLLvLE/8cQTqq6u9jm2oT8TycnJiomJadD7A5qiKLsDwLnn73//uyQpKSnJ21ZbW6usrCz17t1bs2bN0nnnnVfnsYZh6Pbbb9eaNWt0//33q2vXrnr//fc1ZswY7d+/X88995xP/w8//FBvvPGGRo4cqQsvvPCsJ0sOHjxYbdq0UUFBgTZs2KDZs2fr8OHDevnll719pk2bpgkTJmjw4MH62c9+pm+++UZz5szRDTfcoE8++UQtWrTw9v3Xv/6l7OxsDRkyREOHDlVycrJ336JFi3TixAk98sgjOnTokGbOnKnBgwfrpptu0kcffaSxY8dq9+7dmjNnjh5//HH94Q9/kHQyCXv44YdVUFCggQMH6pprrtE///lPPfLII8rMzNTPf/5z0/e4ZMkSHT9+XA899JCSkpK0ceNGzZkzR19//bWWLFkiSXrwwQd14MABrVq1Sq+88spZfZYul0u///3vdffdd+uBBx7Q0aNH9eKLLyorK0sbN25U165d5XA4NHToUM2cOVOHDh1SYmKi9/h3331XLpdLQ4cOlXSyOnD77bfr448/1ogRI9ShQwdt375dzz33nHbu3Klly5b5XD9QPxMAvscAztKCBQsMScYHH3xgfPPNN0Zpaanx+uuvG0lJSUZMTIzx9ddfG4ZhGLm5uYYkY9y4caedIzc312jdurX39bJlywxJxtSpU3363XnnnYbD4TB2797tbZNkREREGJ9//vlZv4dJkyYZkozbb7/dp/3hhx82JBmffvqpYRiGsWfPHiMyMtKYNm2aT7/t27cbUVFRPu19+vQxJBlFRUU+fUtKSgxJxkUXXWQcOXLE2z5+/HhDktGlSxejpqbG23733XcbzZs3N6qqqrxtlZWVxmWXXWZ06tTJqKqqMvr162fEx8cbe/fuPeN7PX78+GltBQUFhsPh8Dk+Ly/PaMivhj59+hh9+vTxvq6trTWqq6t9+hw+fNhITk427rvvPm/bjh07DEnG/PnzffrefvvtRps2bQyPx2MYhmG88sorRkREhPGXv/zFp19RUZEhyfjrX//qbfPnZ6Kh7xtoShiGgN8yMzN10UUXKT09XUOGDNH555+vpUuX6uKLL/bp99BDD53xXO+9954iIyP16KOP+rT/4he/kGEYWrFihU97nz591LFjR7/fQ15ens/rRx55xBuPJL311lvyeDwaPHiwvv32W++WkpKidu3a+ZTYJcnpdGr48OF1Xuuuu+5SQkKC93WPHj0kSUOHDlVUVJRP+4kTJ7R//35v23nnnaeXXnpJX375pW644Qb9+c9/1nPPPadWrVqd8T1+v9xeWVmpb7/9Vtdff70Mw9Ann3xyxuOtioyMVPPmzSWdrAocOnRItbW16t69u7Zu3ertd/nll6tHjx5atGiRt+3QoUNasWKFcnJyvMMfS5YsUYcOHdS+fXufz/7UcNcPP/tA/UwA+A+GIeC3efPm6fLLL1dUVJSSk5N1xRVXKCLCNw+NiorSJZdccsZz7d27V2lpaYqLi/Np79Chg3f/92VkZPgZ/Unt2rXzed22bVtFRERoz549kqRdu3bJMIzT+p3SrFkzn9cXX3yx9wvzh374xX4qcUhPT6+z/fDhwz7tvXr10kMPPaR58+YpKytL9913n8k7+499+/Zp4sSJeuedd047Z0VFhaVzWLVw4UL95je/0VdffaWamhpv+w//ve69916NHDlSe/fuVevWrbVkyRLV1NTonnvu8fbZtWuXvvzyS1100UV1XuvgwYM+rwP1MwHgP0gW4LfrrrtO3bt3N+3jdDpPSyACobEmp/1wUp/H45HD4dCKFSsUGRl5Wv/zzz/fclx1HW/WbvxgYmd1dbU++ugjSSfnhxw/frzeOSCnuN1u/fjHP9ahQ4c0duxYtW/fXrGxsdq/f7+GDRsmj8djenxDvPrqqxo2bJgGDhyoMWPGqGXLloqMjFRBQYF3PsspQ4YM0ahRo7Ro0SL98pe/1Kuvvqru3bvriiuu8PbxeDzq3Lmznn322Tqv98MkiwmLQOCRLCCktG7dWh988IGOHj3qU1346quvvPsbw65du3z+It29e7c8Ho93clzbtm1lGIYyMjJ0+eWXN0oMVk2aNElffvmlZs2apbFjx2rcuHGaPXu26THbt2/Xzp07tXDhQt17773e9lWrVp3W198bE/3pT3/SpZdeqrfeesvnXJMmTTqtb2Jiovr166dFixYpJydHf/3rX1VYWOjTp23btvr000918803c9MkwCbMWUBIufXWW+V2uzV37lyf9ueee04Oh0PZ2dmNct1TywVPmTNnjiR5r3fHHXcoMjJSkydPPu0vfcMw9K9//atR4vqh4uJizZo1S/n5+frFL36hMWPGaO7cuVq7dq3pcaeqFt+P3TAM/e///u9pfWNjYyVJR44cOasY67pWcXGx1q9fX2f/e+65R1988YXGjBmjyMhIDRkyxGf/4MGDtX//fr3wwgunHfvdd99579kBoPFQWUBI6d+/v2688Ub96le/0p49e9SlSxf93//9n95++23l5+erbdu2ls4zbNgwLVy4UCUlJZaWzpWUlOj222/XT37yE61fv16vvvqq/ud//kddunSRdPKv26lTp2r8+PHas2ePBg4cqLi4OJWUlGjp0qUaMWKEHn/8cX/e+hlVVVUpNzdX7dq107Rp0yRJkydP1rvvvqvhw4dr+/bt3i/6H2rfvr3atm2rxx9/XPv371d8fLzefPPN0+YuSFK3bt0kSY8++qiysrLq/AI3c9ttt+mtt97ST3/6U/Xr108lJSUqKipSx44ddezYsdP69+vXT0lJSVqyZImys7PVsmVLn/333HOP3njjDf385z/XmjVr1KtXL7ndbn311Vd644039P77759xGKw+e/fu9S4R3bx5syRp6tSpkk5Wsb4/dwJo0uxahoHwd2rp5KZNm0z75ebmGrGxsfXu+/7SScMwjKNHjxqjRo0y0tLSjGbNmhnt2rUznnnmGe9SulMkGXl5eXWed9CgQUZMTIxx+PBh09hOLZ384osvjDvvvNOIi4szLrjgAmPkyJHGd999d1r/N9980+jdu7cRGxtrxMbGGu3btzfy8vKMHTt2ePv06dPH6NSp02nHnlo6+cwzz/i0r1mzxpBkLFmyxKf9h5/vqFGjjMjISKO4uNin3+bNm42oqCjjoYceMn2vX3zxhZGZmWmcf/75xoUXXmg88MADxqeffmpIMhYsWODtV1tbazzyyCPGRRddZDgcjjMuJ/zh0kmPx2NMnz7daN26teF0Oo2rr77aWL58eZ3/1qecWqq6ePHiOvefOHHCmDFjhtGpUyfD6XQaF1xwgdGtWzdj8uTJRkVFhbef2c9EXU599nVt339PQFPnMIwf1FSBc0BycrLuvfdePfPMM6b9nnrqKU2ePFnffPONLrzwwiBFhx8aNWqUXnzxRZWVlZ1xsiaA4GPOAs45n3/+ub777juNHTvW7lBgQVVVlV599VUNGjSIRAEIUcxZwDmnU6dOcrlcdoeBMzh48KA++OAD/elPf9K//vUvPfbYY3aHBKAeJAsAbPHFF18oJydHLVu21OzZs9W1a1e7QwJQD+YsAAAAU8xZAAAApkgWAACAqZCbs+DxeHTgwAHFxcVxa1cAgCnDMHT06FGlpaU1yvNnTqmqqtKJEyf8Pk/z5s0VHR0dgIiCK+SShQMHDpz2YBgAAMyUlpZaerLt2aiqqtJFMTE6/f6jDZeSkqKSkpKwSxhCLlk49fCg83Z+KscPHlMcKio/TrI7BHOv2h2AidV2B3AGo+wO4Ax22h2AiT9utjuCM+hkdwBnUGh3ACbG2x2ACZek9NMeax9IJ06c0DFJYyQ5/ThPtaRnysp04sQJkgV/nRp6cMTFyREfmsmCzou3OwJzzewOwESojyyF+v+/ze0OwEzdz6UIHSH+/21I//CF+mfn/9NSrXAqtP+VGlPIJQsAAISiZvLvbzF3oAKxAckCAAAWRMm/L81w/sIN59gBAAiaKPlXWagNVCA24D4LAADAFJUFAAAsYBgCAACY8neCI8MQAADgnEVlAQAACxiGAAAApvxdDVETqEBswDAEAAAwRWUBAAALmvIwRIMrC+vWrVP//v2VlpYmh8OhZcuW+ew3DEMTJ05UamqqYmJilJmZqV27dgUqXgAAbNEsAFu4anCyUFlZqS5dumjevHl17p85c6Zmz56toqIiFRcXKzY2VllZWaqqqvI7WAAAEHwNropkZ2crOzu7zn2GYaiwsFBPPvmkBgwYIEl6+eWXlZycrGXLlmnIkCH+RQsAgE38rQ40qcqCmZKSEpWVlSkzM9PblpCQoB49emj9+vV1HlNdXS2Xy+WzAQAQaqICsIWrgCYLZWVlkqTk5GSf9uTkZO++HyooKFBCQoJ3S09PD2RIAAAExKmlk2e7kSz4Yfz48aqoqPBupaWldocEAAC+J6CJTkpKiiSpvLxcqamp3vby8nJ17dq1zmOcTqecTmcgwwAAIOBYOhkgGRkZSklJ0erVq71tLpdLxcXF6tmzZyAvBQBAUDXlpZMNTnSOHTum3bt3e1+XlJRo27ZtSkxMVKtWrZSfn6+pU6eqXbt2ysjI0IQJE5SWlqaBAwcGMm4AABAkDU4WNm/erBtvvNH7evTo0ZKk3NxcvfTSS3riiSdUWVmpESNG6MiRI+rdu7dWrlyp6OjowEUNAECQNeVhiAbH3rdvXxmGUe9+h8OhKVOmaMqUKX4FBgBAKPH3QVLhnCzYvhoCAACEtnBOdAAACBqGIQAAgClu9wwAAFAPKgsAAFjAMAQAADDVlFdDhHPsAAAEDXMWAAAA6kFlAQAAC5izAAAATEVFSs0cfhxvSHIHLJygYhgCAACYorIAAIAFUVFSVBOtLIRsslD5jyTp/Hi7w6hTwa2j7A7B1Pg1z9kdQv0uszuAM/i13QGcQQ+7AzBzld0BnMEcuwMwd/UkuyOoV9utn9sdQr08rmMqSQjOtZr5OQzRrP5nMIY8hiEAAAhR69atU//+/ZWWliaHw6Fly5Z599XU1Gjs2LHq3LmzYmNjlZaWpnvvvVcHDhzwOcehQ4eUk5Oj+Ph4tWjRQvfff7+OHTvWoDhIFgAAsCAqyv+toSorK9WlSxfNmzfvtH3Hjx/X1q1bNWHCBG3dulVvvfWWduzYodtvv92nX05Ojj7//HOtWrVKy5cv17p16zRixIiGvfeGhw4AQNPTLFJq5sef2M08DT8mOztb2dnZde5LSEjQqlWrfNrmzp2r6667Tvv27VOrVq305ZdfauXKldq0aZO6d+8uSZozZ45uvfVWzZo1S2lpaZbioLIAAEAQuVwun626ujpg566oqJDD4VCLFi0kSevXr1eLFi28iYIkZWZmKiIiQsXFxZbPS7IAAIAVkQHYJKWnpyshIcG7FRQUBCS8qqoqjR07Vnfffbfi408uECgrK1PLli19+kVFRSkxMVFlZWWWz80wBAAAVkTJvz+x/z0MUVpa6v0ylySn0+lXWNLJyY6DBw+WYRiaP3++3+f7IZIFAACsCFCyEB8f75Ms+OtUorB37159+OGHPudOSUnRwYMHffrX1tbq0KFDSklJsXwNhiEAAAhTpxKFXbt26YMPPlBSUpLP/p49e+rIkSPasmWLt+3DDz+Ux+NRjx7Wb9xCZQEAACsCVFloiGPHjmn37t3e1yUlJdq2bZsSExOVmpqqO++8U1u3btXy5cvldru98xASExPVvHlzdejQQT/5yU/0wAMPqKioSDU1NRo5cqSGDBlieSWERLIAAIA1EfJOUgyWzZs368Ybb/S+Hj16tCQpNzdXTz31lN555x1JUteuXX2OW7Nmjfr27StJWrRokUaOHKmbb75ZERERGjRokGbPnt2gOEgWAAAIUX379pVh1H+faLN9pyQmJmrx4sV+xUGyAACAFVHyr7Lgx3Ml7EayAACAFU04WWA1BAAAMEVlAQAAK753F8amhmQBAAArGIYAAACoG5UFAACsiFST/dZsom8bAIAG8nfOwplviRCySBYAALAiSk32W5M5CwAAwFQTzZEAAGigJlxZaKJvGwCABmrCyQLDEAAAwFQTzZEAAGggfx9R7QlUIMFHsgAAgBX+DkOE8dJJhiEAAIApKgsAAFjRhCsLJAsAAFjh7x0cw3jOAsMQAADAFJUFAACsYBgCAACY8vepk2E8DEGyAACAFf7OWfDnWJsxZwEAAJiisgAAgBX+zllgGAIAgHMcyUIIGqeQjW583+fsDsHcR3YHYKKb3QGcwSd2B3AGM+wOwERVjN0RmPv9E3ZHYCrp9/vtDqFef3+vk90h1O+4y+4ImoQQ/ToGACDEUFkAAACm/H3qZBgvKQjj0AEAQDBQWQAAwAp/hyHcgQok+EgWAACwogknCwxDAAAAUwFPFtxutyZMmKCMjAzFxMSobdu2evrpp2UYYfwEDQAAIgOwhamAD0PMmDFD8+fP18KFC9WpUydt3rxZw4cPV0JCgh599NFAXw4AgOBowsMQAU8W/va3v2nAgAHq16+fJKlNmzZ67bXXtHHjxkBfCgCA4PH3qZO1gQok+AI+DHH99ddr9erV2rlzpyTp008/1ccff6zs7Ow6+1dXV8vlcvlsAAAgdAS8sjBu3Di5XC61b99ekZGRcrvdmjZtmnJycursX1BQoMmTJwc6DAAAAsvfYYgwXn8Y8MrCG2+8oUWLFmnx4sXaunWrFi5cqFmzZmnhwoV19h8/frwqKiq8W2lpaaBDAgDAf0xwDJwxY8Zo3LhxGjJkiCSpc+fO2rt3rwoKCpSbm3taf6fTKafTGegwAABAgAQ8WTh+/LgiInwLFpGRkfJ4wvgJGgAAMAwROP3799e0adP05z//WXv27NHSpUv17LPP6qc//WmgLwUAQPBEBWBroHXr1ql///5KS0uTw+HQsmXLfPa/9dZbuuWWW5SUlCSHw6Ft27addo6qqirl5eUpKSlJ559/vgYNGqTy8vIGxRHwZGHOnDm688479fDDD6tDhw56/PHH9eCDD+rpp58O9KUAADinVVZWqkuXLpo3b169+3v37q0ZM2bUe45Ro0bp3Xff1ZIlS7R27VodOHBAd9xxR4PiCHhRJC4uToWFhSosLAz0qQEAsI8Nj6jOzs6u99YDknTPPfdIkvbs2VPn/oqKCr344otavHixbrrpJknSggUL1KFDB23YsEE/+tGPLMXBsyEAALAiQMMQP7y3UHV1daOFvGXLFtXU1CgzM9Pb1r59e7Vq1Urr16+3fB6SBQAAgig9PV0JCQneraCgoNGuVVZWpubNm6tFixY+7cnJySorK7N8njCemwkAQBAFaDVEaWmp4uPjvc3hcPsAkgUAAKzw98ZK/z42Pj7eJ1loTCkpKTpx4oSOHDniU10oLy9XSkqK5fMwDAEAgBU2LJ30V7du3dSsWTOtXr3a27Zjxw7t27dPPXv2tHweKgsAAISoY8eOaffu3d7XJSUl2rZtmxITE9WqVSsdOnRI+/bt04EDBySdTASkkxWFlJQUJSQk6P7779fo0aOVmJio+Ph4PfLII+rZs6fllRASyQIAANb4+4jqsxjC2Lx5s2688Ubv69GjR0uScnNz9dJLL+mdd97R8OHDvftPPWph0qRJeuqppyRJzz33nCIiIjRo0CBVV1crKytLv/3tbxsUB8kCAABW2HC75759+8owjHr3Dxs2TMOGDTM9R3R0tObNm1fvjZ2sYM4CAAAwRWUBAAArArQaIhyRLAAAYAVPnQQAAKhbGOc5AAAEUROuLIRx6AAABJENT50MFWEcOgAACAYqCwAAWMEwBAAAMEWyAAAATDXh+ywwZwEAAJiisnA2VtodwBk0szsAEzF2B2AuobrM7hBMVeRYf/580P2X3QGYO3/ut3aHYKq2NoT/7GxhdwAmgvn7jmEIAABgyoanToYKhiEAAIApKgsAAFjBMAQAADDFaggAAIC6UVkAAMAKhiEAAIApVkMAAADUjcoCAABWNOEJjiQLAABYwZwFAABgqgknC8xZAAAApsI4zwEAIIiacGUhjEMHACB4jAjJ8GOSohHGtfwwDh0AAAQDlQUAACxwR53c/Dk+XIVx6AAABE9TThYYhgAAAKbCOM8BACB4aiMdqo10+HG8IckIXEBBRLIAAIAF7qgouaPOPllwRxmSagIXUBAxDAEAAExRWQAAwAJ3ZKTcfgxDuCPDt7JAsgAAgAUeRcqts08WPGE6X0EiWQAAwJJaRarWj2ShNoyTBeYsAAAAU1QWAACwwK1Iuf34G9stTwCjCS6SBQAALPA/WTj7IQy7MQwBAABMkSwAAGDBycqCf1tDrVu3Tv3791daWpocDoeWLVvms98wDE2cOFGpqamKiYlRZmamdu3a5dPn0KFDysnJUXx8vFq0aKH7779fx44da1AcJAsAAFhgR7JQWVmpLl26aN68eXXunzlzpmbPnq2ioiIVFxcrNjZWWVlZqqqq8vbJycnR559/rlWrVmn58uVat26dRowY0aA4mLMAAECIys7OVnZ2dp37DMNQYWGhnnzySQ0YMECS9PLLLys5OVnLli3TkCFD9OWXX2rlypXatGmTunfvLkmaM2eObr31Vs2aNUtpaWmW4qCyAACABW5F/vteC2e3naosuFwun626uvqs4ikpKVFZWZkyMzO9bQkJCerRo4fWr18vSVq/fr1atGjhTRQkKTMzUxERESouLrZ8LZIFAAAscCvK702S0tPTlZCQ4N0KCgrOKp6ysjJJUnJysk97cnKyd19ZWZlatmzpsz8qKkqJiYnePlYwDAEAgAVuRZzVvIP/HH9SaWmp4uPjve1Op9PPyBoflQUAAIIoPj7eZzvbZCElJUWSVF5e7tNeXl7u3ZeSkqKDBw/67K+trdWhQ4e8faxolGRh//79Gjp0qJKSkhQTE6POnTtr8+bNjXEpAACCwo7VEGYyMjKUkpKi1atXe9tcLpeKi4vVs2dPSVLPnj115MgRbdmyxdvnww8/lMfjUY8ePSxfK+DDEIcPH1avXr104403asWKFbrooou0a9cuXXDBBQ06T9flGxQZHxvo8AJiS8dedodgLtruAEz8ye4AzFXstp5p2+IbuwMwscfuAMwde/dCu0Mwd3Zz3ILi/JXf2h1CvQzXUVUG6VqnJiqe/fENd+zYMe3evdv7uqSkRNu2bVNiYqJatWql/Px8TZ06Ve3atVNGRoYmTJigtLQ0DRw4UJLUoUMH/eQnP9EDDzygoqIi1dTUaOTIkRoyZIjllRBSIyQLM2bMUHp6uhYsWOBty8jICPRlAAA4523evFk33nij9/Xo0aMlSbm5uXrppZf0xBNPqLKyUiNGjNCRI0fUu3dvrVy5UtHR//mrcdGiRRo5cqRuvvlmRUREaNCgQZo9e3aD4nAYhhHQZ2Z27NhRWVlZ+vrrr7V27VpdfPHFevjhh/XAAw/U2b+6utpn2YjL5VJ6erq6VrxPZeFshXJlwfrkW3t0tTuAMwjlykKoa2F3AGdAZeGsGK6jqky9VBUVFT6TBgPJ5XIpISFBH1R0Vmz82VcWKl1uZSZsb9RYG0vA5yz84x//0Pz589WuXTu9//77euihh/Too49q4cKFdfYvKCjwWUKSnp4e6JAAAPBbqM1ZCKaAJwsej0fXXHONpk+frquvvlojRozwjpXUZfz48aqoqPBupaWlgQ4JAAD4IeBzFlJTU9WxY0eftg4dOujNN9+ss7/T6QyLNaYAgKbN3+qA+8xdQlbAk4VevXppx44dPm07d+5U69atA30pAACCxv+bMgV0imBQBXwYYtSoUdqwYYOmT5+u3bt3a/HixXr++eeVl5cX6EsBAIAgCHhl4dprr9XSpUs1fvx4TZkyRRkZGSosLFROTk6gLwUAQND4f5+F8K0sNMqzIW677TbddtttjXFqAABs8f2HQZ3d8eGLB0kBAGCBx88Jjp4wrizwICkAAGCKygIAABb4v3QyfCsLJAsAAFhQqwg/Jzh6AhhNcDEMAQAATFFZAADAAv9XQzAMAQDAOc3/OQsMQwAAgHMUlQUAACxoypUFkgUAACxw+3m753BOFhiGAAAApqgsAABgAashAACAKbci/JyzEL6PkiJZAADAAv8nOJ79sXZjzgIAADBFZQEAAAuacmWBZAEAAAv8XzoZvskCwxAAAMAUlQUAACzwf+lk+N6UiWQBAAALmvKcBYYhAACAKSoLAABY4P9NmcL373OSBQAALKj1czWEP8faLXzTHAAAEBRUFgAAsMD/1RA8GwIAgHOax8/VEJ4wHoYI2WThYn2tZjrP7jDq9PgXP7U7BFORIZy9vqv+dodg6n1l2R2CqYPvtbI7hPq9bncAZ/AnuwM4g0y7A6jfsa8vtDuE+h1rHrRLsXQSAACgHiFbWQAAIJSwdBIAAJiqVaQiWToJAABwOioLAABY4P/SyfD9yg3fyAEACKKmvHSSYQgAAELU0aNHlZ+fr9atWysmJkbXX3+9Nm3a5N1vGIYmTpyo1NRUxcTEKDMzU7t27Qp4HCQLAABYcOo+C/5sDfWzn/1Mq1at0iuvvKLt27frlltuUWZmpvbv3y9JmjlzpmbPnq2ioiIVFxcrNjZWWVlZqqqqCuh7J1kAAMCCUw+S8meTJJfL5bNVV1fXeb3vvvtOb775pmbOnKkbbrhBl112mZ566ilddtllmj9/vgzDUGFhoZ588kkNGDBAV111lV5++WUdOHBAy5YtC+h7J1kAACCI0tPTlZCQ4N0KCgrq7FdbWyu3263o6Gif9piYGH388ccqKSlRWVmZMjP/c/vPhIQE9ejRQ+vXrw9ozExwBADAgpNDCf6shjhZWSgtLVV8fLy33el01tk/Li5OPXv21NNPP60OHTooOTlZr732mtavX6/LLrtMZWVlkqTk5GSf45KTk737AoXKAgAAFgRqzkJ8fLzPVl+yIEmvvPKKDMPQxRdfLKfTqdmzZ+vuu+9WRERwv75JFgAAsMCOCY5t27bV2rVrdezYMZWWlmrjxo2qqanRpZdeqpSUFElSeXm5zzHl5eXefYFCsgAAQIiLjY1VamqqDh8+rPfff18DBgxQRkaGUlJStHr1am8/l8ul4uJi9ezZM6DXZ84CAAAW2HFTpvfff1+GYeiKK67Q7t27NWbMGLVv317Dhw+Xw+FQfn6+pk6dqnbt2ikjI0MTJkxQWlqaBg4ceNZx1oVkAQAAC2oVKUeQHyRVUVGh8ePH6+uvv1ZiYqIGDRqkadOmqVmzZpKkJ554QpWVlRoxYoSOHDmi3r17a+XKlaetoPAXyQIAACFq8ODBGjx4cL37HQ6HpkyZoilTpjRqHCQLAABY4FakIgKwdDIckSwAAGDByWTh7L/wwzlZYDUEAAAwRWUBAAALmnJlgWQBAAAL7FgNESoYhgAAAKaoLAAAYIFHUX49SMoTxl+54Rs5AABB5PZzGII5CwAAnOPcivAzWQjfkf/wjRwAAAQFlQUAACw4uZqhaa6GIFkAAMACt6Lk8Ot2z+H7ldvowxC//vWvvY/RBAAA4adR05xNmzbpd7/7na666qrGvAwAAI3Oo0i/VjR4wngYotEqC8eOHVNOTo5eeOEFXXDBBY11GQAAgsL972TBny1cNVqykJeXp379+ikzM9O0X3V1tVwul88GAABCR6MMQ7z++uvaunWrNm3adMa+BQUFmjx5cmOEAQBAwLj9XA1BZeF7SktL9dhjj2nRokWKjo4+Y//x48eroqLCu5WWlgY6JAAA/FarCNUq0o8tfG9tFPDKwpYtW3Tw4EFdc8013ja3261169Zp7ty5qq6uVmTkf7Irp9Mpp9MZ6DAAAECABDxZuPnmm7V9+3aftuHDh6t9+/YaO3asT6JgZvHL9ys+JtDRBcgUuwM4gzS7A6hf8vpyu0Mwla7QrmxNvySEf/iW2x3AGXS3O4AzuMLuAEx8ZXcAJo4H71In75PQNO+zEPDI4+LidOWVV/q0xcbGKikp6bR2AADCRVOesxC+aQ4AAEHk8TNZCOf7LAQlWfjoo4+CcRkAANAIqCwAAGBBrSIVQWUBAADUx61IGX58bYZzshC+iz4BAEBQUFkAAMCCk5UFhiEAAEA9mnKywDAEAAAwRWUBAAAL3J5IGR4/Kgt+HGs3kgUAACxw10bKU3v2X/iGH8fajWEIAABgisoCAAAWuGuj5Kg9+69Nw49j7Ra+kQMAEETu2gg5/BqGCN9iPskCAAAWuGsj/UwWmLMAAADOUVQWAACwoLY2Uo6apllZIFkAAMACwx0lw+3H16Y/x9qMYQgAAGCKZAEAACtqI/3fGsDtdmvChAnKyMhQTEyM2rZtq6efflqGYXj7GIahiRMnKjU1VTExMcrMzNSuXbsC/c5JFgAAsCTIycKMGTM0f/58zZ07V19++aVmzJihmTNnas6cOd4+M2fO1OzZs1VUVKTi4mLFxsYqKytLVVVVAX3r4TuAAgDAOexvf/ubBgwYoH79+kmS2rRpo9dee00bN26UdLKqUFhYqCeffFIDBgyQJL388stKTk7WsmXLNGTIkIDFQmUBAAAr3A6p1o/N7ZAkuVwun626urrOy11//fVavXq1du7cKUn69NNP9fHHHys7O1uSVFJSorKyMmVmZnqPSUhIUI8ePbR+/fqAvnUqCwAAWFH7782f4yWlp6f7NE+aNElPPfXUad3HjRsnl8ul9u3bKzIyUm63W9OmTVNOTo4kqaysTJKUnJzsc1xycrJ3X6CQLAAAEESlpaWKj4/3vnY6nXX2e+ONN7Ro0SItXrxYnTp10rZt25Sfn6+0tDTl5uYGK1xJJAsAAFgToMpCfHy8T7JQnzFjxmjcuHHeuQedO3fW3r17VVBQoNzcXKWkpEiSysvLlZqa6j2uvLxcXbt29SPQ0zFnAQAAK2oDsDXA8ePHFRHh+zUdGRkpj8cjScrIyFBKSopWr17t3e9yuVRcXKyePXs2+O2ZobIAAIAVtZJq/Dy+Afr3769p06apVatW6tSpkz755BM9++yzuu+++yRJDodD+fn5mjp1qtq1a6eMjAxNmDBBaWlpGjhwoB+Bno5kAQCAEDRnzhxNmDBBDz/8sA4ePKi0tDQ9+OCDmjhxorfPE088ocrKSo0YMUJHjhxR7969tXLlSkVHRwc0FpIFAACscP978+f4BoiLi1NhYaEKCwvr7eNwODRlyhRNmTLFj8DOjGQBAAArAjTBMRwxwREAAJiisgAAgBVNuLJAsgAAgBVNOFlgGAIAAJiisgAAgBVu+Vcd8Gclhc1CNln48N4fKTY+NMPL/OnHdodganmS3RHUr/+KjXaHYOp49nl2h2Cq21V/tTuEem2Z28vuEMwdszsAc83vdNkdQr36J75rdwj1qnEd1zvBuhjDEAAAAHULzT/dAQAINU24skCyAACAFTXy79kQ/hxrM5IFAACsCPLtnkMJcxYAAIApKgsAAFjB0kkAAGCqCU9wZBgCAACYorIAAIAVTbiyQLIAAIAVTThZYBgCAACYorIAAIAVrIYAAACmGIYAAACoG5UFAACsqJEU6efxYYpkAQAAK5rwsyFIFgAAsII5CwAAAHWjsgAAgBUsnQQAAKZq5d8ER4YhAADAuSrgyUJBQYGuvfZaxcXFqWXLlho4cKB27NgR6MsAABBcNQHYwlTAk4W1a9cqLy9PGzZs0KpVq1RTU6NbbrlFlZWVgb4UAADB4w7AFqYCPmdh5cqVPq9feukltWzZUlu2bNENN9wQ6MsBAIBG1ugTHCsqKiRJiYmJde6vrq5WdXW197XL5WrskAAAaLgmvBqiUSc4ejwe5efnq1evXrryyivr7FNQUKCEhATvlp6e3pghAQBwdmoDsIWpRk0W8vLy9Nlnn+n111+vt8/48eNVUVHh3UpLSxszJAAA0ECNNgwxcuRILV++XOvWrdMll1xSbz+n0ymn09lYYQAAEBg1khx+Hh+mAp4sGIahRx55REuXLtVHH32kjIyMQF8CAIDg40FSgZOXl6fFixfr7bffVlxcnMrKyiRJCQkJiomJCfTlAAAIjlr5N3jPnIX/mD9/vioqKtS3b1+lpqZ6tz/+8Y+BvhQAAAiCRhmGAADgnNOEl07yICkAAKzwd4JiGE9w5EFSAACEoDZt2sjhcJy25eXlSZKqqqqUl5enpKQknX/++Ro0aJDKy8sbJRaSBQAArAjysyE2bdqkf/7zn95t1apVkqS77rpLkjRq1Ci9++67WrJkidauXasDBw7ojjvu8Pdd1olhCAAArKiVf/dZaOB8h4suusjn9a9//Wu1bdtWffr0UUVFhV588UUtXrxYN910kyRpwYIF6tChgzZs2KAf/ehHfgR6upBNFu7zLFCEJ87uMOr0fOIDdodg6jKtsDuEeu3Lbml3CKaOK7SX916h0H3ce8z/HLc7BFNXabvdIZj6Vkl2h1Cvbbra7hDq5dYxu0NosB8+A8nKzQlPnDihV199VaNHj5bD4dCWLVtUU1OjzMxMb5/27durVatWWr9+fcCTBYYhAACwIkDPhkhPT/d5JlJBQcEZL71s2TIdOXJEw4YNkySVlZWpefPmatGihU+/5ORk7/2NAilkKwsAAIQUf2+q9O/jS0tLFR8f72228siDF198UdnZ2UpLS/MziLNDsgAAQBDFx8f7JAtnsnfvXn3wwQd66623vG0pKSk6ceKEjhw54lNdKC8vV0pKSiDDlcQwBAAA1gR5NcQpCxYsUMuWLdWvXz9vW7du3dSsWTOtXr3a27Zjxw7t27dPPXv2PLsLmaCyAACAFQEahmgIj8ejBQsWKDc3V1FR//nKTkhI0P3336/Ro0crMTFR8fHxeuSRR9SzZ8+AT26USBYAALDGhmThgw8+0L59+3Tfffedtu+5555TRESEBg0apOrqamVlZem3v/2tn0HWjWQBAIAQdcstt9T7zKXo6GjNmzdP8+bNa/Q4SBYAALCiVpI/z0rkQVIAAJzj/P2yD+NkgdUQAADAFJUFAACsYBgCAACYasLJAsMQAADAFJUFAACsqJXk8eN4f461GckCAABWuOXfMEQYJwsMQwAAAFNUFgAAsKJW/v2JHcaVBZIFAACsIFkAAACmatRkkwXmLAAAAFNUFgAAsMIj/1ZD+HOszUgWAACwolaSw4/jwzhZYBgCAACYorIAAIAVTbiyQLIAAIAVNWqyyQLDEAAAwBSVBQAArHCryVYWSBYAALAqjL/w/cEwBAAAMEWyAAAATJEsAAAAUyQLAADAFMkCAAAwxWoIAAAsqfn35s/x4YlkAQAAS2r/vflzfHhiGAIAAJgK2crCkIjX5YyItjuMOt1RusLuEExNtjsAE5OSD9odgqm/lJ9ndwimfqbf2x1CvQ471tsdgqk7brc7AnOr3u5tdwj12qkr7A6hXt/phMYE7WoMQwAAAFMMQwAAANSJygIAAJbUyr+hhPCtLJAsAABgSdOds8AwBAAAMEVlAQAAS5ruBEeSBQAALGHOAgAAMNV0KwvMWQAAAKaoLAAAYAmrIQAAgKnaAGwNs3//fg0dOlRJSUmKiYlR586dtXnzZu9+wzA0ceJEpaamKiYmRpmZmdq1a5c/b7JOJAsAAISgw4cPq1evXmrWrJlWrFihL774Qr/5zW90wQUXePvMnDlTs2fPVlFRkYqLixUbG6usrCxVVVUFNBaGIQAAsCS4qyFmzJih9PR0LViwwNuWkZHh/W/DMFRYWKgnn3xSAwYMkCS9/PLLSk5O1rJlyzRkyBA/YvVFZQEAAEsCMwzhcrl8turq6jqv9s4776h79+6666671LJlS1199dV64YUXvPtLSkpUVlamzMxMb1tCQoJ69Oih9esD+xTYRksW5s2bpzZt2ig6Olo9evTQxo0bG+tSAACEjfT0dCUkJHi3goKCOvv94x//0Pz589WuXTu9//77euihh/Too49q4cKFkqSysjJJUnJyss9xycnJ3n2B0ijDEH/84x81evRoFRUVqUePHiosLFRWVpZ27Nihli1bNsYlAQBoZIFZDVFaWqr4+Hhvq9PprLO3x+NR9+7dNX36dEnS1Vdfrc8++0xFRUXKzc31I46Ga5TKwrPPPqsHHnhAw4cPV8eOHVVUVKTzzjtPf/jDHxrjcgAABEFghiHi4+N9tvqShdTUVHXs2NGnrUOHDtq3b58kKSUlRZJUXl7u06e8vNy7L1ACniycOHFCW7Zs8RlDiYiIUGZmZp1jKNXV1aeN3wAA0NT16tVLO3bs8GnbuXOnWrduLenkZMeUlBStXr3au9/lcqm4uFg9e/YMaCwBTxa+/fZbud1uy2MoBQUFPmM36enpgQ4JAIAAOLUa4my3hq2GGDVqlDZs2KDp06dr9+7dWrx4sZ5//nnl5eVJkhwOh/Lz8zV16lS988472r59u+69916lpaVp4MCBAXi//2H70snx48dr9OjR3tcul4uEAQAQgoL7bIhrr71WS5cu1fjx4zVlyhRlZGSosLBQOTk53j5PPPGEKisrNWLECB05ckS9e/fWypUrFR0d7Uecpwt4snDhhRcqMjLS8hiK0+msd7wGAIDQEfzbPd9222267bbb6t3vcDg0ZcoUTZkyxY+4zizgwxDNmzdXt27dfMZQPB6PVq9eHfAxFAAA0PgaZRhi9OjRys3NVffu3XXdddepsLBQlZWVGj58eGNcDgCAIGi6D5JqlGThv//7v/XNN99o4sSJKisrU9euXbVy5crTJj0CABA+gjtnIZQ02gTHkSNHauTIkY11egAAECS2r4YAACA8BPdBUqGEZAEAAEua7jAET50EAACmqCwAAGBJjfz72mQ1BAAA5ziGIQAAAOpEZQEAAEtYDQEAAEw13WEIkgUAACypkRTp5/HhiTkLAADAVMhVFgzDkCSdcFXbHEn9XEftjsBcld0BmHB57I7A3HFXaGf+lSFcxjxudwBnEOL/tKp0he6/7Xc6YXcI9apynYzt1HdH46qUf0MJofu9diYOIzifsGVff/210tPT7Q4DABBGSktLdckllzTKuauqqpSRkaGysjK/z5WSkqKSkhJFR0cHILLgCblkwePx6MCBA4qLi5PD4fD7fC6XS+np6SotLVV8fHwAIjy38PnUj8+mfnw25vh86hfoz8YwDB09elRpaWmKiGi8kfWqqiqdOOF/haV58+ZhlyhIITgMERER0SjZYXx8PP/TmuDzqR+fTf34bMzx+dQvkJ9NQkJCQM5jJjo6Oiy/5AOFCY4AAMAUyQIAADB1zicLTqdTkyZNktPptDuUkMTnUz8+m/rx2Zjj86kfn014CrkJjgAAILSc85UFAADgH5IFAABgimQBAACYIlkAAACmSBYAAICpcz5ZmDdvntq0aaPo6Gj16NFDGzdutDsk2xUUFOjaa69VXFycWrZsqYEDB2rHjh12hxWSfv3rX8vhcCg/P9/uUELG/v37NXToUCUlJSkmJkadO3fW5s2b7Q7Ldm63WxMmTFBGRoZiYmLUtm1bPf3000F6wFHoWbdunfr376+0tDQ5HA4tW7bMZ79hGJo4caJSU1MVExOjzMxM7dq1y55gcUbndLLwxz/+UaNHj9akSZO0detWdenSRVlZWTp48KDdodlq7dq1ysvL04YNG7Rq1SrV1NTolltuUWVlpd2hhZRNmzbpd7/7na666iq7QwkZhw8fVq9evdSsWTOtWLFCX3zxhX7zm9/oggsusDs0282YMUPz58/X3Llz9eWXX2rGjBmaOXOm5syZY3dotqisrFSXLl00b968OvfPnDlTs2fPVlFRkYqLixUbG6usrCxVVYXyc3ObMOMcdt111xl5eXne126320hLSzMKCgpsjCr0HDx40JBkrF271u5QQsbRo0eNdu3aGatWrTL69OljPPbYY3aHFBLGjh1r9O7d2+4wQlK/fv2M++67z6ftjjvuMHJycmyKKHRIMpYuXep97fF4jJSUFOOZZ57xth05csRwOp3Ga6+9ZkOEOJNztrJw4sQJbdmyRZmZmd62iIgIZWZmav369TZGFnoqKiokSYmJiTZHEjry8vLUr18/n58fSO+88466d++uu+66Sy1bttTVV1+tF154we6wQsL111+v1atXa+fOnZKkTz/9VB9//LGys7Ntjiz0lJSUqKyszOf/r4SEBPXo0YPfzyEq5J46GSjffvut3G63kpOTfdqTk5P11Vdf2RRV6PF4PMrPz1evXr105ZVX2h1OSHj99de1detWbdq0ye5QQs4//vEPzZ8/X6NHj9Yvf/lLbdq0SY8++qiaN2+u3Nxcu8Oz1bhx4+RyudS+fXtFRkbK7XZr2rRpysnJsTu0kFNWViZJdf5+PrUPoeWcTRZgTV5enj777DN9/PHHdocSEkpLS/XYY49p1apVTfpxtPXxeDzq3r27pk+fLkm6+uqr9dlnn6moqKjJJwtvvPGGFi1apMWLF6tTp07atm2b8vPzlZaW1uQ/G4S/c3YY4sILL1RkZKTKy8t92svLy5WSkmJTVKFl5MiRWr58udasWaNLLrnE7nBCwpYtW3Tw4EFdc801ioqKUlRUlNauXavZs2crKipKbrfb7hBtlZqaqo4dO/q0dejQQfv27bMpotAxZswYjRs3TkOGDFHnzp11zz33aNSoUSooKLA7tJBz6ncwv5/DxzmbLDRv3lzdunXT6tWrvW0ej0erV69Wz549bYzMfoZhaOTIkVq6dKk+/PBDZWRk2B1SyLj55pu1fft2bdu2zbt1795dOTk52rZtmyIjI+0O0Va9evU6bZntzp071bp1a5siCh3Hjx9XRITvr9TIyEh5PB6bIgpdGRkZSklJ8fn97HK5VFxc3OR/P4eqc3oYYvTo0crNzVX37t113XXXqbCwUJWVlRo+fLjdodkqLy9Pixcv1ttvv624uDjvGGFCQoJiYmJsjs5ecXFxp83diI2NVVJSEnM6JI0aNUrXX3+9pk+frsGDB2vjxo16/vnn9fzzz9sdmu369++vadOmqVWrVurUqZM++eQTPfvss7rvvvvsDs0Wx44d0+7du72vS0pKtG3bNiUmJqpVq1bKz8/X1KlT1a5dO2VkZGjChAlKS0vTwIED7Qsa9bN7OUZjmzNnjtGqVSujefPmxnXXXWds2LDB7pBsJ6nObcGCBXaHFpJYOunr3XffNa688krD6XQa7du3N55//nm7QwoJLpfLeOyxx4xWrVoZ0dHRxqWXXmr86le/Mqqrq+0OzRZr1qyp8/dMbm6uYRgnl09OmDDBSE5ONpxOp3HzzTcbO3bssDdo1MthGE309mIAAMCSc3bOAgAACAySBQAAYIpkAQAAmCJZAAAApkgWAACAKZIFAABgimQBAACYIlkAAACmSBYAAIApkgUAAGCKZAEAAJj6f9eHmXJuhohVAAAAAElFTkSuQmCC", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "export_to_grid('permx')\n", - "plot_layer('permx', [2, 10, 10])" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "metadata": { - "scrolled": false - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "WOPR PRO1\n" - ] - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAoYAAAH5CAYAAAAcFv/wAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/OQEPoAAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOzdeZxN9f/A8dfdZt8MYxaGGbuxk2VkjVBpQyUq5BsKiRLaUCL6JWmhUsjSIimylCXJkkSMJfswDLObfbtz7+f3x7inuWaGGWbMGO/n43Efc+7nfO45n3Oca97zWXVKKYUQQgghhLjt6cu6AEIIIYQQonyQwFAIIYQQQgASGAohhBBCiMskMBRCCCGEEIAEhkIIIYQQ4jIJDIUQQgghBCCBoRBCCCGEuEwCQyGEEEIIAUhgKIQQQgghLpPAUAhRLEFBQQwePPi6PtulSxe6dOlSpLyDBw8mKCjous5T1DKmpqbyv//9Dz8/P3Q6HS+88MJ1nU+UvSufrTNnzqDT6Vi0aFGZlUmIW5EEhkKUkO+++w6dTseqVavy7WvWrBk6nY7ffvst374aNWrQvn17uzSz2czcuXNp3bo17u7uuLm50bp1a+bOnYvZbM53jKCgIHQ6nfaqWrUqHTt2zFeWLl262OVzdnamadOmzJkzB6vVeoN3oPguXLjAlClT2L9//00/N8D06dNZtGgRzz77LEuWLOHJJ58sk3LcqHXr1jFlypSbcq4jR44wZcoUzpw5c828s2bNQqfT8c8//9ilK6WoVKkSOp2O8PBwu32ZmZk4OjoyYMCAkix2sU2ZMsXuu+Li4kJISAivvfYaycnJWr5FixbZ5TMajVSrVo3BgwcTGRlZ4LGVUixZsoROnTrh5eWFi4sLTZo04c033yQtLS1f/r/++ovnnnuOVq1aYTKZ0Ol0pXbdQhjLugBCVBQdOnQAYPv27Tz88MNaenJyMocOHcJoNLJjxw66du2q7Tt37hznzp2jf//+WlpaWhr33Xcfv//+O71792bw4MHo9Xo2bNjAmDFj+OGHH1i7di2urq5252/evDkvvvgikBtwffrpp/Tp04d58+YxYsQILV/16tWZMWMGAHFxcSxfvpyxY8cSGxvL22+/fc3rPHbsGHr99f1N+euvv9q9v3DhAlOnTiUoKIjmzZvb7fv8889LPVjdsmUL7dq1Y/LkyaV6ntK2bt06Pv7445sSHB45coSpU6fSpUuXa9bo5v1OtGjRQks/fPgwiYmJ2nciODhY27dnzx6ys7O1z5a1efPm4ebmRmpqKr/++itvv/02W7ZsYceOHXYB2ptvvklwcDCZmZn8+eefLFq0iO3bt3Po0CGcnJy0fBaLhQEDBvDdd9/RsWNHpkyZgouLC3/88QdTp05lxYoVbNq0CV9fX+0z69atY8GCBTRt2pRatWpx/Pjxm3oPxG1GCSFKTHBwsGrTpo1d2oYNG5ROp1OPP/646tmzp92+5cuXK0D99NNPWtqwYcMUoD788MN8x//oo48UoEaMGGGXXrNmTXXffffZpV28eFG5urqqevXqaWmdO3dWjRo1ssuXkZGhatasqdzd3VVOTk7xLvgG7dmzRwFq4cKFJXrcmjVrqkGDBl0zX3BwcL77diPMZrPKysoqseMV1ciRI9XN+u98xYoVClC//fbbNfNmZWUpJycn9eijj9qlz58/X1WuXFn17NlTDR8+3G7f9OnTFaAOHDhQrHJ17txZde7cWXsfHh5+Q8/W5MmTFaBiY2Pt0vv06aMAtXPnTqWUUgsXLlSA2rNnj12+CRMmKEB9++23dum263vppZfynXP16tVKr9erXr162aVHRUWp9PR0pdTN/bcWtydpShaiBHXo0IF//vmHjIwMLW3Hjh00atSIe+65hz///NOuFsxW63DnnXcCcP78eb744gvuuusuRo0ale/4I0eOpGvXrixYsIDz589ftSx+fn40bNgwX1PdlZycnGjdujUpKSnExMRc8xqv7L9na0rbsWMH48aNw8fHB1dXVx5++GFiY2PtPpu3H9jWrVtp3bo1AEOGDNGa4mx9wgrqY/h///d/tG/fnsqVK+Ps7EyrVq34/vvvr1nmK23dulVrxly7dq12blvzaExMDEOHDsXX1xcnJyeaNWvG4sWL7Y5h68P2f//3f8yZM4fatWvj6OjIkSNHADh69CiPPvooPj4+ODs7U79+fV599VXt82fPnuW5556jfv36ODs7U7lyZR555JF8TbRms5mpU6dSt25dnJycqFy5Mh06dGDjxo3affr4448B7Jo0i6so5Vm0aBGPPPIIAF27dtXOtXXr1gKP6eDgQOvWrdmxY4dd+o4dOwgNDeXOO+8scJ+XlxeNGzcGwGq1MmfOHBo1aoSTkxO+vr4MHz6cS5cuFfsazWYzR48e5eLFi8X+rM1dd90FcM3vVceOHQE4deqUlpaRkcG7775LvXr1tFr7vO6//34GDRrEhg0b+PPPP7V0X19fnJ2dr7vMQhSHBIZClKAOHTpgNpvZvXu3lrZjxw7at29P+/btSUpK4tChQ3b7GjRoQOXKlQFYv349FouFp556qtBzPPXUU+Tk5LBhw4arlsVsNnPu3Dnt2FdjC3K8vLyumbcwo0eP5sCBA0yePJlnn32WNWvWFBjc2jRs2JA333wTgGHDhrFkyRKt31VhPvjgA1q0aMGbb77J9OnTMRqNPPLII6xdu7ZYZW3YsCFLliyhSpUqNG/eXDu3j48PGRkZdOnShSVLljBw4EDeffddPD09GTx4MB988EG+Yy1cuJAPP/yQYcOG8d577+Ht7U1YWBht27Zly5YtPPPMM3zwwQc89NBDrFmzRvvcnj172LlzJ/3792fu3LmMGDGCzZs306VLF9LT07V8U6ZMYerUqXTt2pWPPvqIV199lRo1arBv3z4Ahg8fzt133w2gXceSJUuKdT+KWp5OnTrx/PPPA/DKK69o52rYsGGhx+3QoQORkZF2AWbe74StWRly+97t3LmT0NBQrbvC8OHDGT9+PHfeeScffPABQ4YMYdmyZfTs2bPA/rZXExkZScOGDZk0aVKxPpeXLdC71vfKdr2VKlXS0rZv386lS5cYMGAARmPBPbls3/2ff/75ussoxA0p6ypLISqSw4cPK0C99dZbSqncpkVXV1e1ePFipZRSvr6+6uOPP1ZKKZWcnKwMBoN65plntM+/8MILClD//PNPoefYt2+fAtS4ceO0tJo1a6oePXqo2NhYFRsbqw4cOKD69++vADV69GgtX+fOnVWDBg20fEePHlXjx49XQJGbVK9sprU1pXXv3l1ZrVYtfezYscpgMKjExES78+dt7rtaU/KgQYNUzZo17dJszWk22dnZqnHjxuquu+66ahmvdi1XXvecOXMUoJYuXWp3ntDQUOXm5qaSk5OVUv81VXp4eKiYmBi7Y3Tq1Em5u7urs2fP2qXnvT9XXotSSu3atUsB6quvvtLSmjVrds1/m5JoXixqeYrTlKyUUmvXrlWAWrJkiVIqt4sDoH7//XeVkpKiDAaDWrt2rVJKqUOHDilAvf3220oppf744w8FqGXLltkdc8OGDfnSi9KUbEsryrNha0o+duyYio2NVeHh4erTTz9Vjo6OytfXV6WlpSml/nv+N23apGJjY9W5c+fU999/r3x8fJSjo6M6d+6cdkzbs7Vq1apCz5uQkKAA1adPnwL3S1OyKG1SYyhECWrYsCGVK1dm+/btABw4cIC0tDRt1HH79u21prNdu3ZhsVjsOtmnpKQA4O7uXug5bPvyjoyE3IEdPj4++Pj40KxZM1asWMGTTz7JzJkz7fIdPXpUy9egQQPeffddHnjggRue1mPYsGF2TZgdO3bEYrFw9uzZGzpuXnmb0y5dukRSUhIdO3bUas9Kwrp16/Dz8+Pxxx/X0kwmE88//zypqan8/vvvdvn79u2Lj4+P9j42NpZt27bx9NNPU6NGDbu8ee9P3msxm83Ex8dTp04dvLy87K7Hy8uLw4cPc+LEiRK7xoIUtTzF1b59e/R6vfad2LFjByaTidatW+Pm5kbTpk2174Ttp+07sWLFCjw9Pbn77ruJi4vTXq1atcLNza3AUf5XExQUhFKqWM96/fr18fHxITg4mOHDh1OnTh3Wrl2Li4uLXb7u3bvj4+NDYGAg/fr1w9XVldWrV1O9enUtz418v4W4WWRUshAlSKfT0b59e7Zt24bVamXHjh1UrVqVOnXqALm/JD/66CMg/y9B+O+Xgu0XSEEK++XStm1bpk2bpk2t0bBhwwKbhoOCgrQRv6dOneLtt98mNjbWbuTk9bgyCLI1oV1PX7DC/Pzzz0ybNo39+/eTlZWlpZfk9B1nz56lbt26+UZe25pLrwx0846oBTh9+jSA1keuMBkZGcyYMYOFCxcSGRmJUkrbl5SUpG2/+eabPPjgg9SrV4/GjRvTq1cvnnzySZo2bVr8iyuB8hSXl5cXjRo1sgv+WrRooQWief9Y2rFjBw4ODrRp0waAEydOkJSURNWqVQs8dlH6xN6olStX4uHhgclkonr16tSuXbvAfB9//DH16tUjKSmJL7/8km3btuHo6GiX50a+30LcLBIYClHCOnTowJo1azh48KDWl8qmffv2jB8/nsjISLZv305AQAC1atXS9tuCj7CwsHzTt9iEhYUBEBISYpdepUoVunfvfs3yubq62uW78847admyJa+88gpz584t8nVeyWAwFJieN8C4EX/88QcPPPAAnTp14pNPPsHf3x+TycTChQtZvnx5iZzjelzvoIDRo0ezcOFCXnjhBUJDQ/H09ESn09G/f3+7AUqdOnXi1KlT/PTTT/z6668sWLCA999/n/nz5/O///2vpC6jyOW5Hh06dGD+/PkkJiYW+J348ssvMZvNbN++nVatWml/pFitVqpWrcqyZcsKPG7emtrS0qlTJ6pUqXLNfG3atOGOO+4A4KGHHqJDhw4MGDCAY8eO4ebmBth/vx966KECj1PY91uIm0UCQyFKWN6523bs2GG3mkarVq1wdHRk69at7N69m3vvvdfus/fccw8Gg4ElS5YUOgDlq6++wmg00qtXrxIpb9OmTXniiSf49NNPeemll/LV/JWm4tT0rVy5EicnJ3755Re7mpiFCxeWaJlq1qxJWFgYVqvVrtbw6NGj2v6rsQX6eQcZFeT7779n0KBBvPfee1paZmamNhAjL29vb4YMGcKQIUNITU2lU6dOTJkyRQsMS6LGtKjluZ5zdejQgXnz5rFp0yb++ecfxo8fr+1r3749GRkZrF27ltOnT9O3b19tX+3atdm0aRN33nnnLTUq12AwMGPGDG3A0MSJE4Hc++Dl5cXy5ct59dVXC/xj6quvvgKgd+/eN7XMQthIH0MhStgdd9yBk5MTy5YtIzIy0q52xNHRkZYtW/Lxxx+TlpaWbxLfwMBAhgwZwqZNm5g3b16+Y8+fP58tW7YwdOhQu75LN+rll1/GbDYze/bsEjtmUdgm6S4oGLqSwWBAp9NhsVi0tDNnzvDjjz+WaJnuvfdeoqKi+Pbbb7W0nJwcPvzwQ9zc3OjcufNVP+/j40OnTp348ssviYiIsNuXt/bUYDDkq0398MMP7a4PID4+3u69m5sbderUsWtKL859LExRy3M957I957Nnz8ZsNtt9J4KCgvD392fWrFl2eQEeffRRLBYLb731Vr5j5uTkFPt6S2K6mqLq0qULbdq0Yc6cOWRmZgLg4uLCSy+9xLFjx+ymLrJZu3YtixYtomfPnrRr167UyyhEQaTGUIgSZpu77Y8//sDR0ZFWrVrZ7W/fvr1WK1PQ6g7vv/8+R48e5bnnnmPDhg1azeAvv/zCTz/9ROfOne1qdUpCSEgI9957LwsWLOD1118v0hQ3JaF27dp4eXkxf/583N3dcXV1pW3btvn67QHcd999zJ49m169ejFgwABiYmL4+OOPqVOnjtb8VhKGDRvGp59+yuDBg9m7dy9BQUF8//337Nixgzlz5hSp79fcuXPp0KEDLVu2ZNiwYQQHB3PmzBnWrl2rLf/Xu3dvlixZgqenJyEhIezatYtNmzblu/chISF06dKFVq1a4e3tzd9//833339vNxWQ7Rl7/vnn6dmzJwaDQVtNZ/DgwSxevJjw8PCrrlRS1PI0b94cg8HAzJkzSUpKwtHRkbvuuqvQfoCQ2/80MDCQXbt2ERQUREBAgN3+9u3bs3LlSrs5PQE6d+7M8OHDmTFjBvv376dHjx6YTCZOnDjBihUr+OCDD+jXr1/h/xBXsE1XM2jQoJuyhvL48eN55JFHWLRokbb60MSJE/nnn3+YOXMmu3btom/fvjg7O7N9+3aWLl1Kw4YN882ZefbsWW0Kor///huAadOmAbk12LfqUo6inCrDEdFCVFiTJk1SgGrfvn2+fT/88IMCrrrSSFZWlnr//fdVq1atlKurq3JxcVEtW7ZUc+bMUdnZ2fnyFzTtSkEKWvnEZuvWrQpQkydPvuoxCpuu5sqVH3777bd805pcOaWIUkr99NNPKiQkRBmNRrvpRQqaruaLL75QdevWVY6OjqpBgwZq4cKF2rQiVyvj1a6loPsWHR2thgwZoqpUqaIcHBxUkyZN8k2pY5v65N133y3w2IcOHVIPP/yw8vLyUk5OTqp+/frq9ddf1/ZfunRJO4ebm5vq2bOnOnr0aL6yT5s2TbVp00Z5eXkpZ2dn1aBBA/X222/bPQc5OTlq9OjRysfHR+l0Orv70bdvX+Xs7KwuXbp01XtR1PIopdTnn3+uatWqpQwGQ5Gnrnn88ccVoAYMGJBv3+zZsxWgGjZsWOBnP/vsM9WqVSvl7Oys3N3dVZMmTdTLL7+sLly4oOUprelqrlz55EqFPf9KKWWxWFTt2rVV7dq17b7rFotFLVy4UN15553Kw8NDOTk5qUaNGqmpU6eq1NTUfMexfZcKel35fRLiRumUKqGe4UIIIcodX19fnnrqKd59992yLooQ4hYggaEQQlRQhw8fJjQ0lNOnTxdpZK0QQkhgKIQQQgghABmVLIQQQgghLpPAUAghhBBCABIYCiGEEEKIyyQwFEIIIYQQgExwXSRWq5ULFy7g7u5eIktPCSGEEELcLEopUlJSCAgIsFvqsyASGBbBhQsXCAwMLOtiCCGEEEJct3Pnzl1zOVUJDIvAtgTWuXPn8PDwKOPSCCGEEEIUXXJyMoGBgUVa0lMCwyKwNR97eHhIYCiEEEKIW1JRusPJ4BMhhBBCCAFIYCiEEEIIIS6TwLCc+fPPPzlz5gxWq7WsiyKEEEKI24wEhuVIamoqoaGhBAcHk5KSoqUvX76cIUOG8OOPP9rlP3fuHNnZ2Te5lEIIIYSoqGTwSTmSkJBAtWrVSEtL49y5c0RFRWE0Glm3bh3Lli2jSpUqdO7cGZPJRGZmJjVq1AByRxvZRhqtWbOGv/76i+7du9O5c2ft2Dk5ORiN8s8thBBCiMKVaY2hxWLh9ddfJzg4GGdnZ2rXrs1bb72FUkrLo5TijTfewN/fH2dnZ7p3786JEyfsjpOQkMDAgQPx8PDAy8uLoUOHkpqaapcnLCyMjh074uTkRGBgILNmzbop11gc1apVY8OGDWzbtg0As9lMRkYGXbt2ZcyYMTRp0oTIyEjOnDnD33//jdFoxNnZmQsXLnD69GkiIiJYsWIF06ZNY/369aSmppKZmUliYiIODg74+fmRkZGhnW/r1q189tlnhIWFldUlCyGEEKIcKdMqpJkzZzJv3jwWL15Mo0aN+PvvvxkyZAienp48//zzAMyaNYu5c+eyePFigoODef311+nZsydHjhzByckJgIEDB3Lx4kU2btyI2WxmyJAhDBs2jOXLlwO5NWo9evSge/fuzJ8/n4MHD/L000/j5eXFsGHDyuz6C3PlcPK2bdvStm1bu7Tq1auzd+9eUlJSMJvNmM1mAJo2bcpjjz1GcHAwZ86cAeDMmTMopUhNTeXixYuYTCaMRiNffvklS5Ys4ZVXXqF+/foYjUbS09Np0KABAQEBbN++HUdHRwD27dtHdHQ0jRo10moqhRBCCFGx6FTe6rmbrHfv3vj6+vLFF19oaX379sXZ2ZmlS5eilCIgIIAXX3yRl156CYCkpCR8fX1ZtGgR/fv3599//yUkJIQ9e/Zwxx13ALBhwwbuvfdezp8/T0BAAPPmzePVV18lKioKBwcHACZOnMiPP/7I0aNHr1nO5ORkPD09SUpKKtV5DC0WC//++2+JH9dqtZKQkEBiYiJ16tTR0r/++mt27tzJQw89RLdu3QA4e/YsvXv3xs3NjSNHjmhB5EsvvcTixYt5/fXXmTJlCnq9npSUFO6++24CAgL47rvvtKbqU6dOkZ6eTs2aNWXeRyGEEKKMFSeOKdOm5Pbt27N582aOHz8OwIEDB9i+fTv33HMPAOHh4URFRdG9e3ftM56enrRt25Zdu3YBsGvXLry8vLSgEKB79+7o9Xp2796t5enUqZMWFAL07NmTY8eOcenSpXzlysrKIjk52e51K9Pr9VSpUsUuKAR4/PHH+fDDD7WgEMDPz49vvvmG999/n6SkJOLi4oiKisLFxYUGDRrg6urKkSNHOHLkCDt37mT37t1s2rSJuLg44uLiSEpKYtq0aTRt2pQ5c+Zox01JSaFfv36MGTOGqKiom3XpQgghhCiGMm1KnjhxIsnJyTRo0ACDwYDFYuHtt99m4MCBAFoA4evra/c5X19fbV9UVBRVq1a12280GvH29rbLExwcnO8Ytn2VKlWy2zdjxgymTp1aQld5a3F0dKRRo0b50p977jmee+457b3VasXT05M5c+aQkZFBXFycti8jI0O7p//++y9Go5GzZ8+ycuVKvLy8mDp1KkopdDod0dHR+Pj4XHNRbyGEEEKUvjINDL/77juWLVvG8uXLadSoEfv37+eFF14gICCAQYMGlVm5Jk2axLhx47T3tjUGhT03Nze72kab1157jddeew2lFBaLBYvFgoODAxMnTqRSpUqcP3+emJgYPD096du3L2fPnmXp0qV2o6iFEEIIcfOVaWA4fvx4Jk6cSP/+/QFo0qQJZ8+eZcaMGQwaNAg/Pz8AoqOj8ff31z4XHR1N8+bNgdymz5iYGLvj5uTkkJCQoH3ez8+P6Ohouzy297Y8eTk6OmqDLsT1yzuIxtvbW6sJBsjOzub06dMcPHiQlJQUvL29tSl1wsPDMRgMMshFCCGEuMnKtP0uPT09XxOiwWDQVv0IDg7Gz8+PzZs3a/uTk5PZvXs3oaGhAISGhpKYmMjevXu1PFu2bMFqtWojeUNDQ9m2bZs2chdg48aN1K9fP18zsrh53N3d2bJlC1988QU6nY6jR49y5swZ3njjDWrWrFkupxQSQgghKrIyDQzvv/9+3n77bdauXcuZM2dYtWoVs2fP5uGHHwZya5xeeOEFpk2bxurVqzl48CBPPfUUAQEBPPTQQwA0bNiQXr168cwzz/DXX3+xY8cORo0aRf/+/QkICABgwIABODg4MHToUA4fPsy3337LBx98YNdcLMqGo6MjrVu31t6npqZy4cIFAG0FGKUUFy5cYMWKFXbzMAohhBCiZJXpdDUpKSm8/vrrrFq1ipiYGAICAnj88cd54403tBHESikmT57MZ599RmJiIh06dOCTTz6hXr162nESEhIYNWoUa9asQa/X07dvX+bOnYubm5uWJywsjJEjR7Jnzx6qVKnC6NGjmTBhQpHKeatPV3Mrsg0q0uv1GAwGli5dyvTp0+nVqxfr168v6+IJIYQQt4zixDFlGhjeKiQwLHvffPMNX375JSNGjGD48OF4eXkBMGXKFB599FGaN2+eb2JwIYQQQkhgWOIkMCwfrFYrFosFk8kEwB9//MFzzz1HQEAAERERGAyGMi6hEEIIUf7cMhNcC1Ecer1eCwoBvLy86NGjB7179yYiIoJLly5hsVgYOnQon3zyCSkpKWVYWiGEEOLWIzWGRSA1hreOU6dO8dBDD2E0Grlw4QI+Pj5lXSQhhBCiTBUnjinTeQyFKGmVK1fmpZde0pboy87OxsvLi+effx6z2czEiRMJCQkp62IKIYQQ5ZLUGBaB1Bje2tLS0ujcuTNZWVns2LGD9u3bA7lrYjs4OMigFSGEEBWa9DEUIg8XFxcWLFjA8OHDcXd35+TJk8TGxjJ16lTq16/Pt99+W9ZFFEIIIcoFaUoWFZ5Op6N58+baMoqZmZlkZmayYsUKTp48SUpKChaLBYPBQHp6OqmpqVStWrVsCy2EEEKUAakxFLetpUuX8vbbb9OsWTOOHj1KREQES5YsISAggOeee66siyeEEELcdBIYituWq6srDzzwAM7OziilSE5O5o8//sBiseDs7ExqaipKKZRSbNq0yW6tbSGEEKIiksEnRSCDT24vZ86cwc3NjSpVqmA0Gjl9+jT33XcfQUFBnDx5UibSFkIIcUuRwSdC3ICgoCCqVKkCQE5ODseOHcPb25umTZuSkJBAdnY2AF999RXHjh0ry6IKIYQQJUpqDItAagxFTk4Oqamp2hrN6enptG/fHovFQnh4OEFBQWVaPiGEEKIwMsG1ECXMaDRqQSFAdHQ07du3Jzk5GZ1OR1JSEu7u7ixYsACj0ciDDz5I5cqVy67AQgghxHWQGsMikBpDUZicnByMxty/r6xWK927dyc2Npbt27fTrl07DAYDa9euZfr06fTo0YPJkydrnz169Cje3t74+PjIJNtCCCFKjdQYCnGT2IJCyJ0f8dFHH2XXrl1akK/X6/njjz/YuXMnPj4+xMTEYDKZMJlM3HXXXVy8eJE9e/Zwxx13ALB7925Wr15N27ZteeCBB8rqsoQQQtymJDAUooS4uLgwYsQIRowYoaVZrVa6dOmCj48PVapUISYmBsitHbZYLOh0OjIyMjh58iQmk0mrXezXrx/dunXDZDJhNBpp2LAhBoOBn376ibp16wJw+vRpTp06Rb169ahZs2aZXLMQQoiKRQJDIUpZ9erVqV69ul2awWBg8+bNmM1mjEajthpLYGAgjz32GE2bNiU8PBwAs9nMiRMntLkWL168iMlkYtmyZbzxxhv079+f5cuXa83RTz75JG5ubkyePBk/Pz8gd7CMwWDA0dHx5l68EEKIW4oEhkKUIZPJZPc+NDSU0NBQuzSDwcDq1au1gDA+Ph6A7Oxsateujbe3N4cPH8ZkMqGUYtmyZSilGDNmDC4uLphMJj788EMmTpzIiBEjmDdvnnbsjz/+mCpVqtC7d29cXV1L/4KFEEKUaxIYClHO6fV6goKC8k2J89hjj/HYY49p781mM1lZWbz++utER0djNpuJiIgA4NChQwDa9Dq2IHL06NEopTh79ixOTk7o9XoWLFjAwoULGTBgAKNGjdKO/88//+Dv74+vr68MlhFCiApKAkMhKhBHR0ceeeSRfOkvv/wyw4YNAyAtLQ3IHaV2zz33EBcXR1JSEsnJydpgmV27dtGyZUuio6O1ILJVq1YopYiOjqZq1apAbh9KvV7myRdCiIpCAkMhbgM6nY5KlSrZpXl4eDBz5ky7NKvVyqOPPkqLFi2oUaMGsbGxAMTGxuLj40NKSgqxsbGkpaXh5eXFzJkz2bVrF6+99hp33333TbseIYQQpUMCQyGEnYKarX18fNi8eTM5OTkopUhLSyM1NZUlS5Zw4cIFoqKiUEqh0+nIyspCp9Ph4OBQNhcghBDiukkbkBCiyPLO26jT6Vi8eDHjxo0jJCSEo0ePcvHiRRYtWoS/vz/vvPNOGZZUCCHE9ZDAUAhx3fz8/BgyZAiOjo5YLBbi4+NZuXIlCQkJJCcnk52dDYBSilOnTpVxaYUQQlyLNCULIUrUu+++y+7du6lTpw7Hjx/HxcWFY8eOce+999KjRw82bNggo5qFEKKcKvMaw8jISJ544gkqV66Ms7MzTZo04e+//9b2K6V444038Pf3x9nZme7du3PixAm7YyQkJDBw4EA8PDzw8vJi6NChpKam2uUJCwujY8eOODk5ERgYyKxZs27K9QlxuzEYDLRv314buZyens62bdvQ6/V4enqSkpKC1WoFYOvWrWRkZJRlcYUQQuRRpjWGly5d4s4776Rr166sX78eHx8fTpw4YTd6ctasWcydO5fFixcTHBzM66+/Ts+ePTly5AhOTk4ADBw4kIsXL7Jx40bMZjNDhgxh2LBhLF++HMidlqNHjx50796d+fPnc/DgQZ5++mm8vLy0KTyEEKVn4MCB9OzZk6ysLCIiIjAYDGRmZtKtWzfc3d05ffo03t7eZV1MIYS47emUUqqsTj5x4kR27NjBH3/8UeB+pRQBAQG8+OKLvPTSSwAkJSXh6+vLokWL6N+/P//++y8hISHs2bOHO+64A4ANGzZw7733cv78eQICApg3bx6vvvoqUVFR2kjJiRMn8uOPP3L06NF8583KyiIrK0t7n5ycTGBgIElJSXh4eJT0bdBYLBb+/fffUju+EOXJvn37mDhxIn5+fqxfvx4vLy8cHR1ZvXo1tWvXplGjRmVdRCGEqBCSk5Px9PQsUhxTpk3Jq1ev5o477uCRRx6hatWqtGjRgs8//1zbHx4eTlRUFN27d9fSPD09adu2Lbt27QJg165deHl5aUEhQPfu3dHr9ezevVvL06lTJ7vpM3r27MmxY8e4dOlSvnLNmDEDT09P7RUYGFji1y7E7a5ly5Zs2LCB2bNnExsby4kTJzh69ChDhgyhcePGbNu2rayLKIQQt50yDQxPnz7NvHnzqFu3Lr/88gvPPvsszz//PIsXLwYgKioKAF9fX7vP+fr6avuioqK0vkw2RqMRb29vuzwFHSPvOfKaNGkSSUlJ2uvcuXMlcLVCiCvp9XqqVKmivY+KiqJZs2b4+flRrVo1kpKSsFqtrF69miVLluTrOyyEEKJkXVcfw0GDBjF06FA6dep0Qye3Wq3ccccdTJ8+HYAWLVpw6NAh5s+fz6BBg27o2DfC0dERR0fHMju/ELerKlWqMHfuXMxmMxkZGZw7dw69Xs/rr79OWFgYH3zwAc8//3xZF1MIISqs66oxTEpKonv37tStW5fp06cTGRl5XSf39/cnJCTELq1hw4ZEREQAuXOkAURHR9vliY6O1vb5+fkRExNjtz8nJ4eEhAS7PAUdI+85hBDlh8lk0rbNZjMdOnQgODiYVq1aERUVRWZmJr///jvjxo0jLCysDEsqhBAVy3UFhj/++CORkZE8++yzfPvttwQFBXHPPffw/fffYzabi3ycO++8k2PHjtmlHT9+nJo1awIQHByMn58fmzdv1vYnJyeze/duQkNDAQgNDSUxMZG9e/dqebZs2YLVaqVt27Zanm3bttmVbePGjdSvXz/f+rFCiPLFYDDw7LPPsnr1ajw9PYmLi+PkyZPMnj2b999/n08//bSsiyiEEBXGdfcx9PHxYdy4cRw4cECbzPbJJ58kICCAsWPH5ptrsCBjx47lzz//ZPr06Zw8eZLly5fz2WefMXLkSCB3ya0XXniBadOmsXr1ag4ePMhTTz1FQEAADz30EJBbw9irVy+eeeYZ/vrrL3bs2MGoUaPo378/AQEBAAwYMAAHBweGDh3K4cOH+fbbb/nggw8YN27c9V6+EKKM3XPPPfTo0YOOHTty5swZLl26xPHjx+natSuLFi0q6+IJIcQt6YbnMbTNH7hx40YMBgP33nsvBw8eJCQkhFmzZjF27NhCP9u6dWtWrVrFpEmTePPNNwkODmbOnDkMHDhQy/Pyyy+TlpbGsGHDSExMpEOHDmzYsEGbwxBg2bJljBo1im7duqHX6+nbty9z587V9nt6evLrr78ycuRIWrVqRZUqVXjjjTdkDkMhbmEdOnSgQ4cOAKSmppKamsq8efPYunUrer2eQYMGaSusKKVktRUhhCiC65rH0Gw2s3r1ahYuXMivv/5K06ZN+d///seAAQO0+XFWrVrF008/XeB0MLea4sz/cyNkHkMhbszFixdZu3Yt9erV46677sLT0xMHBwfuuOMO7r33XmbNmoWrq2tZF1MIIW6q4sQx11Vj6O/vj9Vq5fHHH+evv/6iefPm+fJ07doVLy+v6zm8EEJcF39/f/73v/8BuYPQ4uPj2bBhA2fOnOHnn39m9uzZWt7U1FTc3NzKqqhCCFEuXVeN4ZIlS3jkkUfsmnMrsptRY5ienq4N6smrqM1fBeW7Mq0oeUr7nDqdDldXV7y8vPDy8sLT09NuBKoQJS0nJ4fdu3eTnp7O3XffjYuLC56ennTs2BEvLy8WLlxI/fr1y7qYQghRaooTx5Tpkni3ipsRGJ4/f/62XWHFzc0NT09Pu2DRtl1YmrOzs/QZE9ftzJkzPPjgg5hMJk6ePElAQAB6vZ7IyEgqV6582/zRK4S4PZR6UzLA33//zXfffUdERATZ2dl2+3744YfrPexty9HRkc6dO2tzOEJuh/miKEq+kjzWjZxTKUVmZiYZGRlkZGQA/w0cKM58mCaT6arBo6enJ5UqVbJLc3d3x2AwFPkcouIKCgpi06ZNHDlyhMTERFJSUvD09GT48OFs376dL7/8kj59+gC5E/Hr9WW6SJQQQtw01xUYfvPNNzz11FP07NmTX3/9lR49enD8+HGio6N5+OGHS7qMtwUfHx9+/vln3nvvvbIuyk1jtVrJzMwkPT2djIwMu58Fpdl+WiwWzGYzsbGxxMbGFvl8Op0ODw+PQgPHggJLLy8vuzW2RcXh4+ND586dgdyBX9HR0YSFhZGUlESVKlVISUnBwcGBr7/+mrFjx/LYY48xf/587fM7d+6kcuXK1KpVS7pDCCEqjOsKDKdPn87777/PyJEjcXd354MPPiA4OJjhw4fj7+9f0mUUFZRer8fFxQUXF5cif0YpRXZ2dqFBY2GBZVZWFkopbf3r4nB2ds4XPOYNHK8MKCtXrlysaxLlg8lk4ueff+bQoUN4e3tz9uxZAPbs2UNiYiKXLl3i/PnzODg4YDKZuP/++0lISODAgQM0bdoUyA0WN27cSPv27bn77rvL8nKEEOK6XFdgeOrUKe677z4AHBwcSEtLQ6fTMXbsWO666y6mTp1aooUUwkan02lrWRdn1LvFYilSbeSVeZRSWrP3xYsXi3y+mjVr0qRJE5o0aULTpk2pX7++1CrdAvR6vRbk2QwePJi7774bBwcHEhMTAcjKyqJy5craHx0nTpzAZDKxatUq/u///o8nnniCDh064ODggMFgIDQ0lEqVKrFgwQJt4v3ExER0Oh2enp43+zKFEKJQ1xUYVqpUiZSUFACqVavGoUOHaNKkCYmJiaSnp5doAYUoCQaDATc3t2JNT2K1WsnKyipWM3dGRgZms5mzZ89y9uxZfv75ZyD3D6gGDRrQtGlTLWCsXr26DKC5BTg7O1OnTh27NEdHR3744Qdt4uysrCyysrIICgqib9++NG7cmFOnTgGQkZHBn3/+CeTOPpCQkICDgwNz5sxh6tSpPPfcc3z88cfasRcuXEj16tXp1KkTjo6ON+9ChRCC6wwMO3XqxMaNG2nSpAmPPPIIY8aMYcuWLWzcuJFu3bqVdBmFKBN6vR5nZ2ecnZ3x9vYu8ufS09OJjIwkMjKS8+fPExkZSUZGBmFhYYSFhWn5KlWqROPGjbVaxcaNG0vt0S3mysC+c+fOWr9FG4PBwOeff05UVBSZmZlcuHAByF0XHsBoNBIeHo7JZCI7O5unn34agPj4eBwcHNDpdCxbtozNmzfz0EMP8cADD2jHlhVdhBAl7bqmq0lISCAzM5OAgACsViuzZs1i586d1K1bl9dee41KlSqVRlnLzM1a+SQ1NfW2Gnxyu1BKkZCQYBcoRkVFYbFY8uUNCgqya4KuV6+eNEFXYLbBVO7u7gDExsYydepUEhMTWbp0KTqdDgcHB15//XW+/fZbJkyYwCuvvIKDgwPZ2dn4+fkRHBzM33//jbOzMwAnTpwgMzOTWrVqySovQghA5jEscRIYipKWk5NDVFSUXbCYkJCQL5+DgwMNGzbUgkVpgr49/fnnnxw4cIC2bdtqK00dP36cvn374unpycGDB7VBMePGjWPx4sVMnjyZKVOmALkB6LRp0wgODmbo0KEy/Y4Qt5lSn8cwKSmJjRs3cubMGXQ6HbVq1aJbt26lGjQJUZEYjUaqV69O9erVadu2LfBfE7QtULQ1QR84cIADBw5on/X29s7XBC3fvYqtXbt2tGvXzi6tVq1arF27lkuXLtmNtM/IyNDWiD527BgODg6Eh4czY8YMPD09GThwoDYo5uWXX2bbtm2MHz+efv36AZCZmcnOnTupXr069erVu6nXKYQoe8UODJcuXcqoUaNITk62S/f09GT+/Pk89thjJVY4IW4nLi4u1K1bl7p16wL/NUHbAsXz588TFRVFQkIC27ZtY9u2bdpng4KC7Aa2SBN0xWc0GqlRowY1atSwS3/99dd5/fXXUUphNpsxm81kZWXRv39/dDodp0+fBnL70O7atYu//vqLiIgIoqKiMJlMnDhxgm7duuHt7U1cXJxWO/3ee+9x8OBBBg8eTJcuXQC0+UR9fX1l8nghKohiNSXv27ePtm3bMnDgQMaOHUuDBg1QSnHkyBHmzJnDN998w549e2jWrFlplvmmk6ZkUV6YzWatCdoWLF66dClfPkdHR60J2larWK1aNWmCFnaOHz/OuXPnCAkJ0eagPXz4MJMmTcLT05MlS5ZgNBoxmUwMGTKEP/74g7lz5/LEE09gMpk4evQorVu3pmrVqkRHR2vHXbp0KefOnaN37940adIEkIEyQpSlUutjOGTIEFJTU1mxYkWB+/v164eHhwdffvll8UpczklgKMqztLS0fKOgMzMz8+Xz9va266soTdCiOH7//XdOnDjBXXfdRa1atQD466+/eOaZZ6hTpw5r1qzBZDJhMpkYOHAg27ZtY968eTz11FOYTCaOHDlCx44dadq0Kdu3b9eOu3nzZlJSUmjTpo02x6MQomSVWh/DHTt28MknnxS6f8SIETz33HPFOaQQ4ga5urpSr149rT+YUor4+Ph8o6ATEhL4/fff+f3337XPBgcHa7WKTZo0oW7dutIELQpU0FQ8bdq0Yd++faSmppKdnU12djYA7du3x8vLC29vb63peufOnaSkpBAfH8/Zs2cxmUwYjUbeeustfv/9dxYsWMDgwYPR6/UcPXqUQYMG0bhxY7uKhn///RedTkfNmjW1UdhCiJJVrMDwwoULV+2MXK9ePSIjI2+4UEKI66fT6ahSpQpVqlTRunXYmqDzDmy5dOkS4eHhhIeHs3r1aiC3CTokJMRuyhx/f39pAhSFMhgM+ebfHDhwYL58bdq0YfXq1WRnZ2sLJAAEBgbSpEkTHBwc+Pfff9Hr9ezYsYM9e/aQlpam9X00Go0899xzbN26lcWLF/PUU08BuStxvfnmmzRo0IBJkyZpx01KSsLV1RWj8brGWApx2yrWNyY9PR0nJ6dC9zs6OhbYhCWEKFsmk4nAwEACAwO1NFsTdN5gMTMzk3/++Yd//vlHy1e5cuV8TdC2efeEKCpHR0eCg4PzpU+YMMHuvdVqpV69enzwwQcYDAbi4uK0fUop3NzcMJvNHD16FKPRyPbt2/nqq69o1KgRI0aM0ILIhx9+mD/++IOvvvqKxx9/HEALNIODg2XKHiEKUew/pX755ZdCV2ewrSMqhCj/rmyCtlqt+UZBR0dHEx8fz9atW9m6dSuANkVV06ZNadasGU2bNqV27dryi1aUmMqVK3PXXXflS//oo4+A3AAxJyeHnJwcfHx8GDNmDB4eHnYtVhEREeTk5GAwGIiMjMTJyYlt27bRp08fWrZsyd69e7W8Bw4coGrVqvj5+UntuLjtFWvwSVH+49fpdAWu6HArk8En4nZlNpu5ePGiXc1iQX8Aurm5aU3PtmBRlvcTZclisRAdHU2VKlVwcHAA4Mcff+Stt97irrvu4pNPPsHJyQlHR0fatm3LyZMn2bx5sxaQRkZGEh4eTuPGjfHy8irDKxHixpXa4BOr1XpDBRNC3FpMJlO+ufJSU1OJjIzk3LlzWrCYmprKrl272LVrl5bPNrdis2bNaNasGXXq1JG57sRNYzAY8o1yfuihh+jduzdpaWnaKycnB6vVil6vx9HRkbNnz+Lk5MSyZcuYMGECvXv3Zs2aNdoxfvrpJ61fpAzUEhVRsQLDN954gwcffJBWrVqVVnmEEOWcm5sb9evXp379+kBuzUxMTAznz5/XXvHx8Zw5c4YzZ85oA1tcXFzy1SpWtHXVRflnNBrtarONRiM//fQTmZmZODo6kpKSQkpKCpcuXcLX1xc/Pz9OnDiBk5MTer2eRx99lOzsbE6fPq31mdy7dy/h4eG0bt2amjVrltWlCVEiihUYnj9/nnvuuQcHBwfuv/9+HnjgAbp166ZV0wshbj8GgwF/f3/8/f1p3bo1kDtQzRYknjt3jsjISNLT09m9eze7d+/WPlujRg0tSGzWrBl169aVUaSiTFw5sHLgwIEMHDgQq9VKVlYWWVlZxMfH07RpUy5evEhaWhqnTp3C0dGRzz77jM8++4wxY8bw/vvvo9PpsFqtvPfeezRq1Ii7775bahfFLaNYfQwhtzl5x44drFmzhp9++omLFy9y99138+CDD9K7d2+8vb1Lq6xlRvoYCnFjrFYrsbGxWqB4/vx5u9GmNk5OTjRu3NguWKxcuXIZlFiIolu8eDG//PILAwcO5IEHHsDR0ZHo6Gjat2+Pg4MDycnJODo6ArBq1SrOnz/P3XffTYMGDcq45OJ2UWornxTk33//1YLEvXv30qZNGx544AEef/xxqlWrVuTjvPPOO0yaNIkxY8YwZ84cIHcx9xdffJFvvvmGrKwsevbsySeffIKvr6/2uYiICJ599ll+++033NzcGDRoEDNmzLCrddi6dSvjxo3j8OHDBAYG8tprrzF48OAil00CQyFKXkZGhl3z8/nz58nKysqXr1q1alo/xWbNmsk60OKWcPbsWT7++GNycnKYPXs2RqMRJycnhg0bxsaNG3n//fd5/vnn0ev1xMTEMGPGDJo1a1as301CFFWpDT4pSMOGDWnYsCEvv/wyMTExrFmzRutT9NJLLxXpGHv27OHTTz+ladOmduljx45l7dq1rFixAk9PT0aNGkWfPn3YsWMHkNu36b777sPPz4+dO3dy8eJFbfml6dOnAxAeHs59993HiBEjWLZsGZs3b+Z///sf/v7+9OzZ80YvXwhxnZydnalbty5169YFcmsV4+Li7Jqg4+LitDkW161bB+TOh9eoUSMtUGzatCk+Pj5leSlC5FOzZk1mzZqlvc/JySE1NZXmzZuTk5ODn58fR44cwcHBgb/++os5c+ZQt25dHn/8cRwcHNDpdMycOZOkpCSefPJJGjZsWIZXI24nN1xjeKNSU1Np2bIln3zyCdOmTaN58+bMmTOHpKQkfHx8WL58Of369QPg6NGjNGzYkF27dtGuXTvWr19P7969uXDhglaLOH/+fCZMmEBsbCwODg5MmDCBtWvXcujQIe2c/fv3JzExkQ0bNhSpjFJjKETZyMzMtBsBff78+QIn0Q8ICLAb1NKwYUOpVRS3jBMnTrBq1So8PDwYMWIEOp0OR0dHevXqxalTp1i1ahX33nsvJpOJffv2MWvWLDp16sTIkSPLuujiFlGqNYYLFizgjz/+oEuXLgwZMoRvv/2WKVOmkJWVxZNPPsnUqVOLdbyRI0dy33330b17d6ZNm6al7927F7PZTPfu3bW0Bg0aUKNGDS0w3LVrF02aNLFrWu7ZsyfPPvsshw8fpkWLFuzatcvuGLY8L7zwQqFlsnU0tklOTi7WNQkhSoaTkxO1a9emdu3aQG6tYnx8vF2tYkxMDBcuXODChQvaH3sODg6EhITYBYt+fn5leSlCFKpu3bq8/PLL2nulFJmZmQwYMIBjx47h5eXF8ePH0ev1rF27lu+++45Lly4xaNAgHBwcMJlMNG/enJSUFH744QeaN28OwPHjx9mxYwcNGzakXbt2ZXR14lZTrMBwzpw5vPbaa/Ts2ZNXX32VCxcu8P777zN27FgsFgvvvfce1apVY9iwYUU63jfffMO+ffvYs2dPvn1RUVE4ODjkm1jU19eXqKgoLU/eoNC237bvanmSk5PJyMgocCH2GTNmFDvAFUKUPr1ej4+PDz4+PrRo0QLI/UPONgG3rWYxIyOD/fv3s3//fu2zvr6+doNaGjZsqA0IEKI8evTRR+3eW61WmjRpwrhx4/D39+fMmTPavhMnTpCRkcGlS5c4f/48RqOR1atXM378eHr37s3KlSsxGo3o9Xo6depEZmYmixYtIiQkBIAzZ85w6NAh6tSpI4NibnPFCgw//fRTPvvsMwYMGMA///xDmzZtmD9/PkOHDgVyO4nPmzevSIHhuXPnGDNmDBs3brzq+stlYdKkSYwbN057n5ycbLfGrBCi/HB0dKRWrVrUqlULyK1tSUhIsGt+jo6OJjo6ml9//ZVff/0VyJ28u2HDhnaTcMuSaKK8y9sv10YpxcqVK4mLi8PLy0tbnchkMnHnnXdSq1Ytjh8/DuSuTvb333+TkZFBfHw8Fy9exGQysXLlSl566SXuv/9+Vq1ahV6vR6fT8cADD5CTk8PcuXOpU6cOABcuXCAiIoKaNWvi7+9/U69flL5iBYZnz56lQ4cOALRo0QKDwWBXPd25c+ciDzjZu3cvMTExtGzZUkuzWCxs27aNjz76iF9++YXs7GwSExPtag2jo6O1JiE/Pz/++usvu+NGR0dr+2w/bWl583h4eBRYWwi5v2ikJkGIW5NOp6Ny5cpUrlxZa1LLysriwoULdk3Q6enphIWFERYWxtKlSwHw8fHRahVr1apF5cqV8fb2xtvbu9z9ASuEjU6nIzAwMF8FRrdu3ejWrZtdmtVq5YsvviA2NhZXV1fi4+MByM7OpmHDhvj6+vLvv/+i0+kwGo1s3LiRzMxMYmNj8fT0xGg08s033/Diiy/y4IMPsmrVKu2PqSeffBKdTsdbb72lTfQdHx9PQkICAQEBuLq63oS7IW5UsQJDFxcX0tLStPc+Pj64ubnZ5cnJySnSsbp168bBgwft0oYMGUKDBg2YMGECgYGBmEwmNm/eTN++fQE4duwYERERhIaGAhAaGsrbb79NTEwMVatWBWDjxo14eHho1eOhoaHaaEabjRs3ascQQlR8jo6OBAcHaytVKKW0JjdbzWJUVBSxsbFs2rSJTZs25TuGq6urFiTmDRht27Zg1NvbGw8PjyKtLS/EzabT6WjSpEm+9Pvvv5/7779fe6+UIisri/fee4+4uDgcHBy0SpbExEQCAgJwd3fnyJEjGI1GDAYDK1asICsri9GjR+Pu7o7JZOKrr75i3LhxPPzww/zwww/a8Z9//nmMRiMvvfSStnRhSkoKFosFT09PqbkvQ8UKDBs0aEBYWJg2bP7cuXN2+48ePUpQUFCRjuXu7k7jxo3t0lxdXalcubKWPnToUMaNG6f9Rzt69GhCQ0O1WsoePXoQEhLCk08+yaxZs4iKiuK1115j5MiRWo3fiBEj+Oijj3j55Zd5+umn2bJlC9999x1r164tzqULISoQnU6nBXa2abKys7O5ePGiFigmJSVp6+laLBZt+8r/9wpiNBqpVKnSNQNJW5q0UIjyyNYf8UqPPvqo1v9RKYXZbCYzM5PJkycTExODXq/nwoULQG6zs7OzMw4ODhw9ehSj0YjRaOSzzz4jKyuLJ554Ajc3N4xGI1988QVjx47l0Ucf5dtvv9XON2bMGKxWK2+88YY2NdWhQ4f4888/qVevnl0Zw8LCMBqN1K5dW/teKaUk0CyGYgWGM2fOvGpVcEREBMOHD7/hQtm8//776PV6+vbtazfBtY3BYODnn3/m2WefJTQ0FFdXVwYNGsSbb76p5QkODmbt2rWMHTuWDz74gOrVq7NgwQKZw1AIYcfBwYGaNWvmW+vWVnOSmpqqBYd5X1emZ2ZmkpOTQ2xsLLGxsUU6t5ubW6EB5JXBpIeHh/ySE+WOwWCwq3G0GTRoEIMGDSInJ8fuNXr0aOLi4lBKERERAeQOoIHcP6xOnDiB0WjEZDLx2WefkZmZqU3+rdfr+emnn3jttdd45JFHaNGiBXq9Hr1eT7du3YiLi+Off/6hSZMm6PV6FixYwHPPPUefPn3sAs4HH3yQhIQEPvvsM63C66+//uKrr76iSZMmdvHMDz/8QEZGBnfffbfWQpmUlMS5c+fw8vKievXqpXJfy0KZz2N4K5B5DIUQRZWTk0N6enqBQWNBwaTVai3W8Y1G41WDxyu3ZS17cSvJzMzEbDbj7u6upX3++edkZGQwdOhQrXJq8+bNrFq1itatWzNo0CAt7/33309iYiJff/21FqwtW7aMd955h3vuuUercNLr9bRr1464uDjWr19Po0aN0Ov1fPfdd4wbN47u3buzfPlybRBO69atOX36NL/++ivt27dHr9ezatUqBg4cSIcOHdi6dauWt02bNhw9epQff/yRu+66C4CdO3cyYcIEmjZtyscff6yVd86cOVSrVo1HHnmkVO/rTV35JDU1Nd9/bKUZPAkhRHlmNBrx8PAo0v+DtvnqCqt9vDKYzMrKIicnh5iYGGJiYopUHnd390KDxipVqti9ZICNKGtOTk75nsNnnnkmX76CBtYArFmzJl9a37596d69O0ajEbPZrKW//fbbpKWlaQET5E6WP3z4cGrUqGE3cLVJkyb4+PiQmZlJeHg4kDsdXqVKlXBwcODff//V8sbFxZGSksKFCxc4ceIEer2eAwcOsH37djIyMjh37pwWRC5atIg2bdqUemBYHNdVYxgeHs6oUaPYunWr3SoEtnZ8i8VSooUsa1JjKIQoD3Jycq7ZlJ33VdzaSHd393zBYpUqVfDx8aFy5cratqenpwyuEaIQcXFxpKen4+Pjo81+Eh0dTVhYGG5ubnaDX5cvX079+vXtaj1LQ6nXGD7xxBMopfjyyy/x9fWV/i5CCHETGI1GPD098fT0vGZepRQZGRlXbcpOTU0lNTVVGw2akpJCSkqKViNytXLkDRTzbl8ZVMrAGnG7qVKlSr40X19f7r777nzpAwYMwNvb+2YUq8iuKzA8cOAAe/fupX79+iVdHlHBuSclUTkhgXhvb1KK8MvtVlPRr0/cOnQ6HS4uLri4uGgjOQtja9K2BYp5A8Yr32dkZJCTk6NNGn4ttlpIWwBZUPBoq4WUSgYhyt51BYatW7fm3LlzEhiKYmmxbx+916xBrxRWnY6f77+ff/JMcH6rq+jXJyounU6Hs7Mzzs7O1wwibc3ZhQWPedOKWwt5tWbsvAGlDKgRovRcV2C4YMECRowYQWRkJI0bN8ZkMtntt80LJopHFxlJUHh4haxtck9K0oImAL1S9F6zhpO1a1eIa63o1yeETVGbs/PWQl4teExNTdVqIaOiorR17q/Gw8NDCxSvVgspU/sIUXzXFRjGxsZy6tQphgwZoqXpdLoKO/jkpvjiC1yGDWOQ1Voha5sqJyRoQZONXim8ExIqROBU0a8vL2kuF0VxPbWQBTVdXxlQWiwWkpOTSU5O5tSpU1c9rl6vx2AwYDAY0Ol0dj9tU5bYXsXNc+W+a+0v6PhX5r2eMhgMBm3lEdvk0Xlf10o3mUx2eQwGAyaTCaPRKEH1beq6AsOnn36aFi1a8PXXX8vgk5Jw/jwMG4bu8gjCiljbFO/tjVWnswuerDodCeWs0+31qujXZyPN5aI0FKcWMiMjo0h9ITMzM7FarVitVrspSkTR6fX6AgPGwgLJoqQXJ2i1vapUqUKtWrXw9/fHYDCU9W2p8K4rMDx79iyrV6+mTp06JV2e29OJE2CwQg8gK/elz1I04hDnnGpgtjqQbXUgW5nItjqQo0zArRWMp3h68vP99+cLKipK4FvRrw+kuVyUvbwDamyrTxTGNtG4UgqlFFartcDtW32fLfi1Wq1YLJbr3i5o5jqr1Up2djbZ2dml9U9aLI6OjtSsWZNatWppa5/XqlWLmjVryhycJei6AsO77rqLAwcOSGBYUurWBQ8dPGn/xezJxgKzKwXZygGz1XQ5YMwNHM1W03/bl4PIK4NK8+X92da8702Xj+eAovTmJvunZUtO1q6Nd0ICCRWwGbKiX9/t1Fwubn22icZF0ZRUgFnQ9o0eIykpifj4eLKysjh+/DjHjx+3K7tOpyMgIEALFm0BY3BwcLmbCuZWcF2B4f3338/YsWM5ePAgTZo0yTf45IEHHiiRwt02qleHme+hdr6IzlGhHOGSfyXMbiYc9Nk46LJx0Gdj0ucAoNOBoy4bR302kFaiRTFbjVpQaQs68wag5stBpV2AqQoIQLWANfe99fKjluLpWaGDiIp8fbdLc7kQtyNbH8byymq1cunSJeLi4uxesbGxZGZmEhkZSWRkJNu3b7f7nJeXV4EBY0BAgDRLF+K6Vj652sNTEQef3KyVT9KOHWPFjBlXqW2yYtKZc4NFvRkHXTYmffbl4NF8OXi0BZKX32tBpVkLMHPTzVrQadKb0etKd8lsi9JrNZpWpceq9Ch0KHQFbysdVq6yrS7nz7N95ecVeqx5t7V8ebYv57cWtn35swVv5+azcsW20mPBQI7VgEUZc7fV5W2Vf5tSrKUtadLHUAhRniilSEtLyxcwxsXFkZiYWOjnHBwcqFmzZr6AsWbNmri4uNy8CwC8vb0JCAgo1XOU+sonxV1mSRSNqlaNs8HBV8mhx6wcMVscSSvR2Fth1OVoQWRxgk6T3nxFraZ9AGrQ5T4rBp0VgyELJ7JKsuAVgkXpsSjD5UDRWKxtCwYsVmNusEluwJlj23eD21b0XNmXtaI3l9vIyGshbg06nQ43Nzfc3NwICgqy25ednU18fHyBQWN2djYnTpzgxIkT+Y55ZbO07VW5cuXbYrBtsQLDXbt2ER8fT+/evbW0r776ismTJ5OWlsZDDz3Ehx9+KEsg3XJ05CgTOcpEhtW1RI+sJwcHvdkuqNRjRafLrWfT67Q6uv+2dVq9XJ5thU53ud5Qp9UV/ret0+oM7ba1z9vOV9h2nnLoLn9er9PqAgve1ml1knbbep0Vg86ivYy6nCu27f+wMuisl9PK18hJpSg0KM1RuV0OzFpXgtznJ7ebQW66+XK6+Srptn05ykh5qTmVWlEhKgYHBwf8/f3x9/e3S7darSQmJhbYLJ2RkcGFCxe4cOECO3bssPuch4dHvhrGWrVqERAQgNF4XfVs5VKxruTNN9+kS5cuWmB48OBBhg4dyuDBg2nYsCHvvvsuAQEBTJkypTTKKm5BVoxkWo1kWp3LuijliPVyMJiDUWfBgOW/bV3+7dyAsnjbVwakBgoKUO23jboc8v4xrNOBUWfByM3pGmK2GrWBU/8FkTcefNrSLcrItUbzy8hrISo+vV6Pt7c33t7e1KtXz25fQc3SsbGxJCYmkpyczIEDBzhw4IDdZ0wmk12ztC1gDAoKuunN0iWhWIHh/v37eeutt7T333zzDW3btuXzzz8HIDAwkMmTJ0tgKMRV6S83HxspH5NA/EeHpUgBam7XA/PlrgO5P3PfZ2vpeX86FJJuG1AFYNLn2L0vaValyxdwXhl4OrpmoR+kIBvIBNJBn65obvyH8841yLQ6kmV10n7mBptCiIrC1dUVV1dXatasaZduNpvzNUvHxsYSHx+P2Wzm5MmTnDx5Mt/x/Pz88k2vU96bpYv1v9qlS5fw9fXV3v/+++/cc8892nvbGspCiFuTwoBZGTCX7lgkjQ4rxmsEmFdLN14j8Mzbz1WvU3lG8xfCHSigD/hdbC0we47VQKbViSyro/1Pi30Aqf0sIN2iTAUeWwhRfphMJvz8/PDz87NLt1qtJCUl5QsY4+LiSE9P15Z53Llzp93n3N3dtWCxUaNG9OjRg86dO9/MSypUsQJDX19fwsPDCQwMJDs7m3379jF16lRtf0pKSr6pa4QQojAqz4Cq9FI6hx4LxmIEnjWiIqh39jg6J1AuEFOzKlmVHHHSZ+Koz8r9acgNLo16C276NNxuYNqoHKshf2CZL8CU4FKI8kiv11OpUiUqVapE3bp17falp6cXGDAmJiaSkpJCWFgYYWFh/PTTT4SHh9+ageG9997LxIkTmTlzJj/++CMuLi507NhR2x8WFkbt2rVLvJBCCHG9rBjIthrIxomidJfc6Qjuvkm5I69N3qSkeeabLlSHFQd9Fk76LBz1mbk/DZn27/OkawFl3p+G3BH6Rr0Foz4d1xsIjYsWXOavvcywOpNhcSHT6kh5GfwjREXh4uJCjRo1qFGjhl262WwmISHBboT0XXfdVUalzK9YgeFbb71Fnz596Ny5M25ubixevBgHBwdt/5dffkmPHj1KvJBCCHEzXWuicoWeLKszWTc0qMqKoz77cqB4fcGloz4rd5DQDQaXVqUj0+pEusWFDIszGVZn0i0uZFqcSbc4k2HNTb9y26wcuNWW5xSirJlMJnx9fbWueSEhITzyyCNlXKr/FCswrFKlCtu2bSMpKQk3N7d8s4avWLECNze3Ei2gEEJUTHqyrE5kWW9kjdfc4LKgQPLKADO3ljL3Z6WsS7jnpKBzBZxz+1+6GDJwMWQU6+w5VsPlWsf/gskMi+29S24gWcC2DNoRovy6rm+nZyF/ScuahEIIcTP9F1wmF/ET7klJvDBnDtpiR0awusOSEU9i9TTgYsjA2ZCBsyEdF/1/286Xt10ub+fWUlpw16fibkwtVqmzrabLtY4u/wWWl7fTC9nOsDihkCXMhCht8mebEELcRionJNitd00O6C+BuqAnwjGoiEdRmHRmLWB0sQWPhozLwWTudu6+/7adDRnodery6klmPE1FDWdzZVic8tdO5gks0/NuX96XWyMrzd1CFJUEhkIIcRuJ9/bGqtPZBYdWnY6EYrX46HInEc9xIBmvYnzOiqM+KzeQ1F8OJK/YdroimHQxpGsDdZwNmTgbMoFLRT6jRentaidzA0oX0i8Hj7npebYtLmRYnZDBOOJ2JYGhEELcRlI8Pfn5/vvzLft3c1Z2+W/QziWKHojqsOQGhfr0/5q6824X0NTtbMjAQW/GoLPiZkzDzVj0KYXyDsaxvTIKCSLT89RUSlO3qAjKNDCcMWMGP/zwA0ePHsXZ2Zn27dszc+ZM6tevr+XJzMzkxRdf5JtvviErK4uePXvyySef2E20HRERwbPPPstvv/2Gm5sbgwYNYsaMGXZrF27dupVx48Zx+PBhAgMDee211xg8ePDNvFwhhCgX/mnZkpO1a+dOyePtXe6X+1MYSLe4km5xJb4YS4obdGZctBrIdFwM6ZcH2aRfDizTtWDSFlA6GbKuGIwTX+TzZVj+G9mdbnXJEzzamrqvDCqdsUr9jChnyvSJ/P333xk5ciStW7cmJyeHV155hR49enDkyBFcXV0BGDt2LGvXrmXFihV4enoyatQo+vTpoy1ubbFYuO+++/Dz82Pnzp1cvHiRp556CpPJxPTp0wEIDw/nvvvuY8SIESxbtozNmzfzv//9D39/f3r27Flm1y+EEGXlWlPyVAQWZSLFYiLF4lHkz+jJyRMs2geRtr6ULlrfSltwmQnkbeouuiyLgxZE/jequ6AgMrdmMt3iIhOai1KlU0rdpMWvri02NpaqVavy+++/06lTJ5KSkvDx8WH58uX069cPgKNHj9KwYUN27dpFu3btWL9+Pb179+bChQtaLeL8+fOZMGECsbGxODg4MGHCBNauXcuhQ4e0c/Xv35/ExEQ2bNhwzXIlJyfj6elJUlISHh5F/w+muFJTU3nvvfdK7fhCCHG7cE9KonJCAvE3oUbU1tTtoi+sZjIjT3q63UCc65FtNdnVTGZYnMnUBuU42w/Kufwz0+os0wSVUzdjHsPixDHl6ilJSkoC/pv2Zu/evZjNZrp3767ladCgATVq1NACw127dtGkSRO7puWePXvy7LPPcvjwYVq0aMGuXbvsjmHL88ILLxRYjqysLLKysrT3ycnFGzknhBCi7LTYty9fH8p/WrYstfPlbeqmyE3dVpz0mcWqmXQxpOcZ1Z2ElympWOW0TRP030hu53zTBRW0P0dqKG8r5SYwtFqtvPDCC9x55500btwYgKioKBwcHPDy8rLL6+vrS1RUlJYnb1Bo22/bd7U8ycnJZGRk4Oxsv3rBjBkz7NaAFkIIcWtwT0rSgkIAvVL0XrOGk7Vrl7Omcz2ZVhcyrS4kFDmYVJdHddsHkU7afJP/TQtkt63PQKfjv2mCijzrZS6z1ZgvWMzME0CmFxJsyso4t6ZyExiOHDmSQ4cOsX379rIuCpMmTWLcuHHa++TkZAIDA8uwREIIIYoi3zyN5AaH3gkJ5SwwvB46bULz4ozqzq2dzMoXLDrnGeFdUDBpa+426XMw6VPwMKYUq7S2qYIKatr+b9slX1qW1REJKMtOuQgMR40axc8//8y2bduoXr26lu7n50d2djaJiYl2tYbR0dH4+flpef766y+740VHR2v7bD9taXnzeHh45KstBHB0dMTR0bFErk0IIcTNUzLzNFY0ejKtuf0Miz4DJIDCQZ9VYDBpWxXHqYBg0sWQjkFnva6pgiB3uiD7/pFOZFqdyLI4aduZVkcy87zPuy9HGZHA8vqVaWColGL06NGsWrWKrVu3EhwcbLe/VatWmEwmNm/eTN++fQE4duwYERERhIaGAhAaGsrbb79NTEwMVatWBWDjxo14eHgQEhKi5Vm3bp3dsTdu3KgdQwghRMVQtvM0VjQ6sq1OZFudSMqpVIzP2VbGyRtMphdSW2n/06TPQa9TuBrTcSX9ukqdYzWQZXX8L4i8HDRm2b0vZL/FiezbvAm8TAPDkSNHsnz5cn766Sfc3d21PoGenp44Ozvj6enJ0KFDGTduHN7e3nh4eDB69GhCQ0Np164dAD169CAkJIQnn3ySWbNmERUVxWuvvcbIkSO1Wr8RI0bw0Ucf8fLLL/P000+zZcsWvvvuO9auXVtm1y6EEKJ03GrzNFY8eVfGKd69N+rMWp9Jl8sBo5MhEyd97stRn6m9d9Rn5abn2a/TcXkd7+sPLG0TnGddUSuZr9bSYh9c2gLPLKsj6hZeOadMA8N58+YB0KVLF7v0hQsXapNPv//+++j1evr27Ws3wbWNwWDg559/5tlnnyU0NBRXV1cGDRrEm2++qeUJDg5m7dq1jB07lg8++IDq1auzYMECmcNQCCEqqNthnsabOSXPzZKjTKRaTKQWY+7J/1hx0GdrQaKTPuvqQWWefbYA06Cz2k9wfp0DsjMtjoXXWl5RY1nVmgPJzcGj7vWdrISVq3kMyyuZx1AIIUR5crOn5Lk9qMs1lvZBpeMVtZJO+iwcCwgqnfSZmPQ513fqoIHQfmnJXk4et+w8hkIIIYS4ultnSp5bjY4c5UCqxYFUC8WYk/I/enJwMmQVWEuZN+B0zBNQejqDl1utEr+a6yWBYTlhNpvZtGkTERERODg4aC9HR0eMRiM63e3bEVYIIcR/KvaUPLc2K0bSLcbcyc6LKCQkhEealu7KJ8UhgWE5ERcXx8MPP1zgPp1OZxcsXhk4Frbvavsl2BRCiFuTTMkjSpMEhuWExWKhWbNmJCQkkJ6eTnp6OhkZGUDutD5XLtN3o2zB5tUCy+IGnUZjxXuclFJYrVaUUsXevpG0kjpOaZ1Pp9NhNBoxmUw3/NO2bTQa0etv3ZF8txqr1Sr3+xZ1O03JUxEH2JR3Fe83+S2qevXq7N27l3///VdLs1gsZGZmaoFiWlqatl3Qy7Y/IyOj0PyZmZlA6QSber2+SIGl7fzFCVauN++Nfk7cXAaDoUSCzaL+NBgMN1xm27NitVqxWCz5XmWVfq3PKKXQ6XR2wXlpb0srRcm5HabkkQE2ZUMCw3LMYDDg6uqKq2vR+ypci8ViKTBwzMjIyBdIFiXQTE9P14JLq9VKZmamFnzeLgwGAzqdDoPBgF6v116Fvb9avqLuu9qx85alOPmK87m8f1hkZmZqP/NuF7S/oLScnP9G8dkCl5vFFhgVFDjqdLoiB1q3KqUU2dnZZGdn35TzXavWuCS3SyLoL+8q8pQ8MsCm7EhgeJsxGAy4ubnh5uZWYsfMycmxCywLCyTT0tK05vHCgp2rBSvFDZ6u95hFOV/eY4gbY7FYCgwgCwskC8tX1GA0by15aQVGV9Z8luR2SQZOZrOZrKwsMjIytHtj2y7sXhd3O2/gn5OTY/e+NOn1eq2LgtFoxGAwFLh9tX0lkU+v10tN6XW4nQbYOMfHw2+/Qd26kGdZ4LIigaG4YUajEXd3d9zd3cu6KOIWZDAYcHFxwcXF5aacz2q1kp2dfdXgMjMzM19tYnG25Q+G/+Tk5BQaPN5IwFnYto3t3/lm1YZeTWkGpCaTCUdHx3yvW73G9HYZYNNi3z7uW7MGlAK9Hj77DIYOLdMySWAohLit6PV6nJyccHJywrOC1TyUR7YgpiS7xBTGVgOcN1i0/RFgqx21BYu2l22fbfvK/Vfms+Up7HjZ2dn5akVvZk2pjdFoLDBgLO6rrPqG3g4DbGzN5Tpb8Gu1wvDh0LNnmdYcSmAohBCiQtDpdFpAU5ZBv8Vi0YLEawWk1wo0r5XP1o0nNTWVtLQ0rauELRhNS0u7oWvR6/UlEmCaTKZi16RX9AE2BTWXY7HAyZMSGAohhBAVhcFgwNnZGWdn55t+brPZbBcoXvnzavtSU1Pt8kFuk3xGRobWP/xGXG9Q6eDsjNFsxpSUVKFGuRfUXI7BAHXqlF2hkMBQCCGEqDBMJhNeXl54eXnd0HGsVivp6elFCiKv9dM2cr+kp0jLOyCrtF6l2VdTay7/+Wf0VmtuUPjpp2U+AEUCw3IkJyeH5cuX4+Liwn333YfJZAJyV0VJS0ujUqVK11z8WgghhLhRer2+RGawUEqRmZlZ7KAyb76MjAyt32jevppmsxmz+ToWNC4G2+j20go8/2zUCNWjBw82apRbU1gORiXrlLqygVtcKTk5GU9PT5KSkko1MEtISKBy5coAHDt2DKPRiNVq5Z133uGLL75g0KBBvPTSS0BuH5auXbvi4uLCt99+q/Wn+eWXX/jtt9+48847uf/++7Vjr1ixAkdHR7p3766N/rx06RKpqal4enpKwCmEEKLcs/WxzMzMtAsYi/L+Wvvypt3sBQ6eeuopFi9eXGrHL04cIzWG5YhOp6Nfv35kZGRQr149Lb1q1ap4eHgQHBxMo0aNUEqRmJjIpUuXuHTpEg0bNsTBwQGr1cr58+dZu3YtgYGBVK1aFavVSk5ODm+++SYAPXv2xMXFBavVyqpVq3j//ffp06cPU6dO1c537733AvDll1/i5+cHwB9//MH69etp1aoVffv21fKuWbMGgC5dumjT1SQnJ5OcnIyHh4cEnEIIIUqMraatJOfivZJSCrPZrAWKtvk9ixOE5v3s1QJRG0dHx1K7nuKSwLAcqVSpEitWrMiXPn36dKZPn6691+l0eHp6cujQIVJSUqhUqZLWCbdfv34EBgbSokULqlatCuT26+jTpw+pqamEhIRoHaKrVKmCm5sbgYGBWsCZk5PD+fPnUUpRu3ZtqlSpgtVqJSoqijVr1uDm5oaPj4+2BNiMGTNISUlh8+bNWiD6yy+/8Oabb3L33Xcze/ZsrdyPPvooaWlpfPjhh9SqVQuAnTt38vXXX9OsWTP+97//aXkXL15Meno6Dz/8sBacXrhwgbCwMPz8/GjevLmW99y5cyilqFq1Kk5OTiX0ryGEEOJ2pNPptCVcS3N0u20FKScnJ6qXgyZkGwkMb1EGg4FGjRrlS7/zzju588477dIcHR1ZuXJlvryvvPIKr7zyivbeNqHv/v37SUtLIzAwEKMx9xG57777cHd3JyQkBF9fX+0zPXv2JCkpiSZNmuDj4wPkBpwuLi4EBATQqFEjLYi8ePEiiYmJBAYGEhQUhFKKjRs3snXrVlxdXfH399fWnf3666+JjIykd+/eeHl5oZRi06ZNjB8/ng4dOrBo0SJtTePRo0dz6tQpvvzyS9q0aYNSis2bN/PSSy/RqlUrFixYoJV30qRJREREMH78eC24PH78OF999RWBgYEMHz5cy7thwwbi4+Pp1KkTgYGBACQlJXHkyBE8PDzs7n9SUhIALi4uWt9QIYQQojA6nQ4nJye8vb1veLBQSZLAUNjR6XQ0bdo0X3qbNm1o06ZNvvSCajhHjx7N6NGjUUppS8cZDAa2bt1KSkoKDRo00Gote/XqpdVa2vpXAgwZMoS4uDiaNGmi/SVVv359OnXqROvWraldu7aWt1KlSri5uRESEqLVfIaFhZGTk4OzszP16tXDarWilOLMmTMcOnQIDw8PAgMDUUpx8OBBfvrpJ1q0aMHrr7+uBafffvstf//9N7Vr19YC3IMHDzJs2DBq1arF+vXrteD05ZdfZufOnUyfPl3r2/nvv/8ybNgwqlevztdff62V94MPPuDAgQMMHjyYTp06ARATE8Mnn3yCh4cH48aN0/Ju27aNiIgIWrduTf369QHIyMhgz549ODk52f2bxMfHk52djaen501bRUQIIUTFIoGhKDVXzjHVrFmzfHkaNmxIw4YN86W/9dZb+dLuuece7rnnnnzpe/bsyXfePn36cO7cOfR6PQ4ODtq++fPnEx8fT2hoqNZE0Lp1a9555x2qVq2qNb9Dbl/L2rVr07JlS2rUqAHAxYsXadKkCbVq1bLrB2qrJaxTpw4hISEopYiPjycxMZHKlStTp04dLTiNiIhgz549DB48mOrVq6OUIi4ujpUrV+Lr68s777yj5V2/fj0///wzb775Jq1bt9byjhw5EldXV/bv368FsnPnzuWHH37ghRdeYOjlJZXi4uK4++67cXJyYufOndq/yYIFC/j111/p168fjz76KACZmZm89tprODg4MHXqVO2adu7cSVhYGC1atKBt27ZA7lQW69atw2g00q1bNy1vZGQk0dHRVK1a1a5pJDIyEoPBgI+Pjzb9g8ViQafTyfJxQghRjkhgKCqkwvpsXNnMDrnB3IQJE/Kl5x2QYxMaGkpYWFi+9K1bt5KTk2MX6LRu3ZrDhw9rzQU2b7zxBk8//TRt2rTRmg/q16/PtGnTcHZ2tgtOu3fvjpubG+3atdOCU6vVSqtWrXB2dqZOnolQK1WqhKOjIzVr1qRx48YopQgPD9dWQKhfv74WRKakpPDvv/+ilKJGjRpaIPvLL78A8Pnnn6PX61FKsW/fPj799FOee+45evbsiVKKjIwMJk2aBMD+/fu1Gso1a9bw8ccfM3DgQN544w2tRvXee+/FarXy22+/4ePjg1KKRYsWMWfOHB566CG7PwR69+5NZmYmixcvplq1akBus/5XX31FaGgoo0ePtruXaWlpvPjiiwQEBABw4MABNmzYQL169Xj44Ye1vCtXriQ9PZ1evXpp3R4uXrxIWFgYPj4+tGzZUst79OhRsrOzqVWrltbJPT09nfj4eJydnalSpYqWNz09XeuTdKuvTyuEEBIYClFCbP0xbVxcXAgJCcmXr6Dg1N/fn1dffTVf+pgxYxgzZoxdWnBwMH///Xe+vAsWLLDrT6nT6ahRowbnzp0jOzvbrub0xRdfpF+/ftSpU0cbOW4ymZg7dy7Z2dl2/Ui7deuGUopu3bppwXZGRgbdu3fHbDZTv359LfCtXbs2devWpX79+lqNqtVqxcnJCbPZTKNGjbTA0NvbG8jtk9qgQQMtiIyOjiYzM5OgoCAtaLVYLBw8eJAGDRpoaZDb1B4fH8/kyZO1Pqq//PILS5cupVevXjzzzDNa3gULFnD+/Hk6dOhAnTp1UEqxZcsWXnrpJdq3b8+SJUuA3A7hkyZN4uTJkyxevJh27dqhlGLPnj2MGjWK5s2bs2zZMu24Q4cO5dChQ3z00Ud07twZgD///JPnn3+e+vXra8cFGD9+PIcOHWLSpElaN4Jjx47x5ptv4u/vz//93/9peefNm8fRo0cZMGCAVlMbFRXF/Pnz8fT0ZOzYsVredevWcerUKbp06UKTJk2A3NkB1qxZg5OTk91MAmFhYVy8eJH69esTFBQE5A5Q27t3L0aj0a57QmRkJImJiVStWlULpi0WC5GRkej1eqpVq6bVQqenp5Odna2tQ227l1arFb1ef8uvUiHElWz/B9iebduqM7YBojYXLlwgMzMTPz8/7Y/opKQkTp06hbOzc4G/E8qSBIZCVGBGo7HAmtOQkJB8QauLi4tdbZzNI488wiOPPGKX5uzszMaNG/PlHTt2rF3AArkTxF65XqtOp2P8+PE8++yz2vJWNrt37yY7O5ugoCBtCodHHnmEhg0bEhAQYDcF0v/93/+RmppKw4YNqVSpEgAdO3Zk4sSJNGzYUBvRDtC3b19iYmJo3LixNpioQYMGdO7cmVatWmkj5SE3+M7JyaFBgwZagHvs2DHc3NyoXLmy3b2zNaPXqlVL60Zw5swZMjIy0Ol02ueVUiQnJ3P+/HkqVaqknS8yMpKwsDAyMjKoWbOmFiAfO3aMLVu20K9fP602NCYmhpUrVxIQEMA777yj5d22bRtr166lVq1adOnSRasBfuedd/D09OTpp5/WfomtXLmSH374gVdeecVu+qvhw4djMpk4cuSIVt5FixbxzTffMHr0aEaOHAlAamoq9913H5AbZNpqyD/55BMWL17MkCFDtH6yZrOZVq1aAbldEmxTWn366acsWrSIRx55xK5Pba9evVBKsWzZMq1WdtWqVSxdupRu3brx3HPPaXlHjBhBdnY2M2bM0P6Q2bZtG99//z2tWrVi0KBBWt7p06eTmprK888/rz0T+/btY/Xq1dSvX5/HH39cyztv3jySkpJ48skntRrro0ePsm7dOmrUqEG/fv20vN988w0JCQk88MAD2vfs7NmzbNy4kapVq/LAAw9oeTds2EBcXBydO3fWnr+oqCi2bduGl5cXPXr00PLu3LmTuLg4WrVqpZUhMTGRP//8ExcXF+2PCsitIY+Li9O+H5D7R8Hu3btxdHS0y7t//36ioqJo2LAhNWvWBCAtLY2tW7diNBrp2bOnXd5z587RsGFDrWUiIyODX375BZ1Ox4MPPmiX9/Tp0zRo0ED7bpjNZn788UcA+vTpo9Wm79+/n6NHj9KgQQNtAKBtwCHkzqxh+94fOHCAAwcOUL9+fe2PI8h91nJycnj66ae1Gv2dO3eyadMmmjZtykMPPaTlffXVV0lLS+PVV1/V/rjZvHkzS5YsoXXr1tpzDbl/5MXGxjJnzhzt+7l+/Xreeecd2rZty6xZs7S8vXv35uzZsyxZskS7js2bNzN+/Hhat27NokWLtIBx9OjRHD9+nC+//JI777wTnU7H4cOHGT58OE2bNmXTpk2UK0pcU1JSkgJUUlJSWRdFCFHOZGZmqpSUFJWdna2lpaenq9OnT6uIiAi7vIcPH1Y7d+5UcXFxWlpcXJxavXq12rhxo13e9evXq08//VQdO3ZMS7tw4YKaNm2aev/99+3yfv7552rUqFHqjz/+0NLOnTunHnvsMTVkyBC7vNOmTVOdO3dW3377rZYWGRmpmjZtqlq1amWXd+LEiap69epqzpw5WlpsbKxyd3dXLi4uymq1aukvvPCCAtSkSZOUUkpZrVaVmpqqAAWoxMRElZOTo8xms5o4caIC1MiRI1VWVpbKzMxUGRkZWt7w8HCVnp6u0tLS1JQpUxSgBg0apFJSUlRKSopKTk5WLi4uClAHDhxQiYmJKjExUc2YMUMBqk+fPiohIUHFx8er+Ph45ePjowD1xx9/qLi4OBUXF6dmz56tANWrVy8VGxurYmJiVExMjKpRo4YC1Lp161R0dLSKjo5W8+bNU4Dq2LGjioqKUhcvXlQXL15U9evXV4BasWKFunDhgrpw4YL68ssvFaBatmypIiMj1fnz59X58+dV8+bNFaAWLlyozp07p86dO6eWL1+uANWwYUMVERGhIiIi1NmzZ1W7du0UoD788EN15swZdebMGbVy5UoFqBo1aqjw8HAVHh6uTp8+rbp27aoANXPmTHX69GkVHh6u1q5dqwDl4+Oj5Q0PD1f33nuvAtTUqVO1427dulUByt3dXUs7c+aM6tevnwLUxIkT1dmzZ9XZs2fVX3/9pQBlMBi0tLNnz6pBgwYpQI0ZM0a7jkOHDmn/nidOnNDSR4wYoQA1bNgw7T6Eh4dreQ8ePKjOnTunzp8/r8aNG6cA9dRTT6nIyEjtHptMJgWoffv2af9GkydPVoB69NFHVVxcnPZv7+npqQD1119/ac/J//3f/ylAPfjggyolJUWlpqaq1NRUFRAQoAC1Y8cOlZGRoTIyMtSCBQsUoHr06KGys7OV2WxWZrNZ1atXTwHq999/V1arVVmtVrVixQrtOcmrY8eOytvbW23evFlL27p1q6pbt67q06ePuhmKE8dIjaEQQtwAR0fHfJPTOjs7ExwcnC9vQV0LKleubLdKkU2vXr3ypRXW5SDvHKA21atX55tvvsmX/uqrr+Y7RkBAAAcOHMiXd8aMGcyYMcMurUqVKiQnJ+fLO3v2bN59913tvU6nw8XFhbi4OKxWKx4eHloNyksvvcTTTz+Np6en1sVBKcXff/+NxWKhWrVqWk3sU089RWhoKAEBAXaTGi9dupTs7Gxq166Nq6srkDutVqVKlahdu7ZWgwy5/YXT0tJo0KCBNvtBly5dmDZtGnXr1rXrMzp69GguXbpE48aNtf6+bdu25cUXX6ROnTp23SyeeOIJLly4QNOmTfH39wegefPmPP3009SqVUurwYPcGqYGDRrQtGlTrXYxJCSEhx56iKCgIK0WEaBTp054enrStGlTrWYvJSWFzp07ExAQoHUBAGjZsiWZmZmEhIRoz1xOTg4dO3bE29vbLm+bNm1IT0+nSZMm2nFtA8hcXFy0NIB27dqRnJxM8+bNtf7Nbm5u3HPPPRgMBi0NcvteJyQk0Lp1a+060tPTtZq7GjVqaP/Od955J7GxsbRv3167DxaLRRsEFxQUpP07t2/fnosXL9KpUye7ezly5EiUUgQFBWn/zj179kSv19OsWTO7GS7ee+89cnJyqFOnjta8++CDD1KjRg2qV69u90x99913WCwWmjRponWH6NOnD23btsXDw8NuKrLt27cD4OXlpT3Xffr0IScnJ9+Aum3btnGlzp07c/z48Xzp5YEsiVcEN2tJPCGEEEKIklacOOa2mifi448/JigoCCcnJ9q2bctff/1V1kUSQgghhCg3bpvA8Ntvv2XcuHFMnjyZffv20axZM3r27ElMTExZF00IIYQQoly4bQLD2bNn88wzzzBkyBBCQkKYP38+Li4ufPnll2VdNCGEEEKIcuG2CAyzs7PZu3cv3bt319L0ej3du3dn165d+fJnZWWRnJxs9xJCCCGEqOhui1HJcXFxWCwWu9FkAL6+vhw9ejRf/hkzZhS46oUEiEIIIYS41djil6KMN74tAsPimjRpkt2kq5GRkYSEhNhNJyCEEEIIcStJSUmxW5WlILdFYFilShUMBgPR0dF26dHR0XYrI9hcOS+Zm5sb586dw93dvVwu65ScnExgYCDnzp2T6XSuIPemcHJvCif3pnBybwon96Zwcm8KdzPujVKKlJQUu/kgC3NbBIYODg60atWKzZs3axNuWq1WNm/ezKhRo675eb1eX+CyYuWNh4eHfOEKIfemcHJvCif3pnBybwon96Zwcm8KV9r35lo1hTa3RWAIMG7cOAYNGsQdd9xBmzZtmDNnDmlpaQwZMqSsiyaEEEIIUS7cNoHhY489RmxsLG+88QZRUVE0b96cDRs25BuQIoQQQghxu7ptAkOAUaNGFanp+Fbj6OjI5MmT863XKuTeXI3cm8LJvSmc3JvCyb0pnNybwpW3eyNrJQshhBBCCOA2meBaCCGEEEJcmwSGQgghhBACkMBQCCGEEEJcJoGhEEIIIYQAJDAst6ZMmYJOp7N7NWjQQNufmZnJyJEjqVy5Mm5ubvTt2zffyi4RERHcd999uLi4ULVqVcaPH09OTs7NvpQbtm3bNu6//34CAgLQ6XT8+OOPdvuVUrzxxhv4+/vj7OxM9+7dOXHihF2ehIQEBg4ciIeHB15eXgwdOpTU1FS7PGFhYXTs2BEnJycCAwOZNWtWaV/aDbvWvRk8eHC+56hXr152eSrivZkxYwatW7fG3d2dqlWr8tBDD3Hs2DG7PCX1Hdq6dSstW7bE0dGROnXqsGjRotK+vBtSlHvTpUuXfM/NiBEj7PJUxHszb948mjZtqk00HBoayvr167X9t+szA9e+N7frM1OQd955B51OxwsvvKCl3VLPjhLl0uTJk1WjRo3UxYsXtVdsbKy2f8SIESowMFBt3rxZ/f3336pdu3aqffv22v6cnBzVuHFj1b17d/XPP/+odevWqSpVqqhJkyaVxeXckHXr1qlXX31V/fDDDwpQq1atstv/zjvvKE9PT/Xjjz+qAwcOqAceeEAFBwerjIwMLU+vXr1Us2bN1J9//qn++OMPVadOHfX4449r+5OSkpSvr68aOHCgOnTokPr666+Vs7Oz+vTTT2/WZV6Xa92bQYMGqV69etk9RwkJCXZ5KuK96dmzp1q4cKE6dOiQ2r9/v7r33ntVjRo1VGpqqpanJL5Dp0+fVi4uLmrcuHHqyJEj6sMPP1QGg0Ft2LDhpl5vcRTl3nTu3Fk988wzds9NUlKStr+i3pvVq1ertWvXquPHj6tjx46pV155RZlMJnXo0CGl1O37zCh17Xtzuz4zV/rrr79UUFCQatq0qRozZoyWfis9OxIYllOTJ09WzZo1K3BfYmKiMplMasWKFVrav//+qwC1a9cupVRuwKDX61VUVJSWZ968ecrDw0NlZWWVatlL05XBj9VqVX5+furdd9/V0hITE5Wjo6P6+uuvlVJKHTlyRAFqz549Wp7169crnU6nIiMjlVJKffLJJ6pSpUp292bChAmqfv36pXxFJaewwPDBBx8s9DO3y72JiYlRgPr999+VUiX3HXr55ZdVo0aN7M712GOPqZ49e5b2JZWYK++NUrm/5PP+UrvS7XJvlFKqUqVKasGCBfLMFMB2b5SSZ0YppVJSUlTdunXVxo0b7e7HrfbsSFNyOXbixAkCAgKoVasWAwcOJCIiAoC9e/diNpvp3r27lrdBgwbUqFGDXbt2AbBr1y6aNGlit7JLz549SU5O5vDhwzf3QkpReHg4UVFRdvfC09OTtm3b2t0LLy8v7rjjDi1P9+7d0ev17N69W8vTqVMnHBwctDw9e/bk2LFjXLp06SZdTenYunUrVatWpX79+jz77LPEx8dr+26Xe5OUlASAt7c3UHLfoV27dtkdw5bHdoxbwZX3xmbZsmVUqVKFxo0bM2nSJNLT07V9t8O9sVgsfPPNN6SlpREaGirPTB5X3hub2/2ZGTlyJPfdd1++a7jVnp3bauWTW0nbtm1ZtGgR9evX5+LFi0ydOpWOHTty6NAhoqKicHBwwMvLy+4zvr6+REVFARAVFZVvuT/be1ueisB2LQVda957UbVqVbv9RqMRb29vuzzBwcH5jmHbV6lSpVIpf2nr1asXffr0ITg4mFOnTvHKK69wzz33sGvXLgwGw21xb6xWKy+88AJ33nknjRs3Biix71BheZKTk8nIyMDZ2bk0LqnEFHRvAAYMGEDNmjUJCAggLCyMCRMmcOzYMX744QegYt+bgwcPEhoaSmZmJm5ubqxatYqQkBD2799/2z8zhd0buL2fGYBvvvmGffv2sWfPnnz7brX/byQwLKfuuecebbtp06a0bduWmjVr8t1335XrL4coX/r3769tN2nShKZNm1K7dm22bt1Kt27dyrBkN8/IkSM5dOgQ27dvL+uilDuF3Zthw4Zp202aNMHf359u3bpx6tQpateufbOLeVPVr1+f/fv3k5SUxPfff8+gQYP4/fffy7pY5UJh9yYkJOS2fmbOnTvHmDFj2LhxI05OTmVdnBsmTcm3CC8vL+rVq8fJkyfx8/MjOzubxMREuzzR0dH4+fkB4Ofnl2/Ek+29LU9FYLuWgq41772IiYmx25+Tk0NCQsJtd79q1apFlSpVOHnyJFDx782oUaP4+eef+e2336hevbqWXlLfocLyeHh4lPs/4Aq7NwVp27YtgN1zU1HvjYODA3Xq1KFVq1bMmDGDZs2a8cEHH8gzQ+H3piC30zOzd+9eYmJiaNmyJUajEaPRyO+//87cuXMxGo34+vreUs+OBIa3iNTUVE6dOoW/vz+tWrXCZDKxefNmbf+xY8eIiIjQ+nuEhoZy8OBBu1/6GzduxMPDQ6v6rwiCg4Px8/OzuxfJycns3r3b7l4kJiayd+9eLc+WLVuwWq3af16hoaFs27YNs9ms5dm4cSP169cv902lxXH+/Hni4+Px9/cHKu69UUoxatQoVq1axZYtW/I1hZfUdyg0NNTuGLY8eftdlTfXujcF2b9/P4Ddc1MR701BrFYrWVlZt/UzUxjbvSnI7fTMdOvWjYMHD7J//37tdccddzBw4EBt+5Z6dkp0KIsoMS+++KLaunWrCg8PVzt27FDdu3dXVapUUTExMUqp3KHvNWrUUFu2bFF///23Cg0NVaGhodrnbUPfe/Toofbv3682bNigfHx8bsnpalJSUtQ///yj/vnnHwWo2bNnq3/++UedPXtWKZU7XY2Xl5f66aefVFhYmHrwwQcLnK6mRYsWavfu3Wr79u2qbt26dlOyJCYmKl9fX/Xkk0+qQ4cOqW+++Ua5uLiU6ylZlLr6vUlJSVEvvfSS2rVrlwoPD1ebNm1SLVu2VHXr1lWZmZnaMSrivXn22WeVp6en2rp1q930Genp6VqekvgO2aaPGD9+vPr333/Vxx9/XO6n17jWvTl58qR688031d9//63Cw8PVTz/9pGrVqqU6deqkHaOi3puJEyeq33//XYWHh6uwsDA1ceJEpdPp1K+//qqUun2fGaWufm9u52emMFeO0r6Vnh0JDMupxx57TPn7+ysHBwdVrVo19dhjj6mTJ09q+zMyMtRzzz2nKlWqpFxcXNTDDz+sLl68aHeMM2fOqHvuuUc5OzurKlWqqBdffFGZzeabfSk37LffflNAvtegQYOUUrlT1rz++uvK19dXOTo6qm7duqljx47ZHSM+Pl49/vjjys3NTXl4eKghQ4aolJQUuzwHDhxQHTp0UI6OjqpatWrqnXfeuVmXeN2udm/S09NVjx49lI+PjzKZTKpmzZrqmWeesZsOQamKeW8KuieAWrhwoZanpL5Dv/32m2revLlycHBQtWrVsjtHeXStexMREaE6deqkvL29laOjo6pTp44aP3683Zx0SlXMe/P000+rmjVrKgcHB+Xj46O6deumBYVK3b7PjFJXvze38zNTmCsDw1vp2dEppVTJ1kEKIYQQQohbkfQxFEIIIYQQgASGQgghhBDiMgkMhRBCCCEEIIGhEEIIIYS4TAJDIYQQQggBSGAohBBCCCEuk8BQCCGEEEIAEhgKIYQQQojLJDAUQgghhBCABIZCCFEiBg8ejE6nQ6fTYTKZ8PX15e677+bLL7/EarWWdfGEEKJIJDAUQogS0qtXLy5evMiZM2dYv349Xbt2ZcyYMfTu3ZucnJyyLp4QQlyTBIZCCFFCHB0d8fPzo1q1arRs2ZJXXnmFn376ifXr17No0SIAZs+eTZMmTXB1dSUwMJDnnnuO1NRUANLS0vDw8OD777+3O+6PP/6Iq6srKSkpZGdnM2rUKPz9/XFycqJmzZrMmDHjZl+qEKKCksBQCCFK0V133UWzZs344YcfANDr9cydO5fDhw+zePFitmzZwssvvwyAq6sr/fv3Z+HChXbHWLhwIf369cPd3Z25c+eyevVqvvvuO44dO8ayZcsICgq62ZclhKigjGVdACGEqOgaNGhAWFgYAC+88IKWHhQUxLRp0xgxYgSffPIJAP/73/9o3749Fy9exN/fn5iYGNatW8emTZsAiIiIoG7dunTo0AGdTkfNmjVv+vUIISouqTEUQohSppRCp9MBsGnTJrp160a1atVwd3fnySefJD4+nvT0dADatGlDo0aNWLx4MQBLly6lZs2adOrUCcgd5LJ//37q16/P888/z6+//lo2FyWEqJCkxlAIIUrZv//+S3BwMGfOnKF37948++yzvP3223h7e7N9+3aGDh1KdnY2Li4uQG6t4ccff8zEiRNZuHAhQ4YM0QLLli1bEh4ezvr169m0aROPPvoo3bt3z9cvURSdxWLBbDaXdTGEuGEGgwGj0aj9f3E9JDAUQohStGXLFg4ePMjYsWPZu3cvVquV9957D70+t8Hmu+++y/eZJ554gpdffpm5c+dy5MgRBg0aZLffw8ODxx57jMcee4x+/frRq1cvEhIS8Pb2vinXVJGkpqZy/vx5lFJlXRQhSoSLiwv+/v44ODhc1+clMBRCiBKSlZVFVFQUFouF6OhoNmzYwIwZM+jduzdPPfUUhw4dwmw28+GHH3L//fezY8cO5s+fn+84lSpVok+fPowfP54ePXpQvXp1bd/s2bPx9/enRYsW6PV6VqxYgZ+fH15eXjfxSisGi8XC+fPncXFxwcfH54ZqWYQoa0opsrOziY2NJTw8nLp162p/gBaHBIZCCFFCNmzYgL+/P0ajkUqVKtGsWTPmzp3LoEGD0Ov1NGvWjNmzZzNz5kwmTZpEp06dmDFjBk899VS+Yw0dOpTly5fz9NNP26W7u7sza9YsTpw4gcFgoHXr1qxbt+66fgHc7sxmM0opfHx8cHZ2LuviCHHDnJ2dMZlMnD17luzsbJycnIp9DJ2S+nMhhCh3lixZwtixY7lw4cJ1NwmJq8vMzCQ8PJzg4ODr+gUqRHl0o8+11BgKIUQ5kp6ezsWLF3nnnXcYPny4BIVCiJtKAkMhhChHZs2axdtvv02nTp2YNGlSWRdHXM3583DiBNStC3n6gZaGrVu38sILL7B///5SPU9pOXToUKkct3HjxkXKd+LECQYNGkRcXByenp4sWrSIRo0aFZj3+eefZ/Xq1Zw9e5Z//vmH5s2bF+k4xTlHce3fv5+jR4/Sv39/LU2n03Hp0qUS718snVKEEKIcmTJlCmazmc2bN+Pm5lbWxRGF+eILqFkT7ror9+cXX5R1icRVDB8+nGHDhnH8+HEmTJjA4MGDC83br18/tm/fXuDk8Vc7TnHOUVz79+/nm2++KbHjXY30MRRCCHFbuu6+WOfP5waDVut/aQYDnDlTIjWHv/zyC5MmTSInJ4dKlSoxb948YmJiGDVqFC1btmTfvn04OjryxRdf0Lx5c06cOMHgwYNJTU3FarXy4IMPMm3atBsuR0kqyxrDmJgY6tSpQ0JCAkajEaUU/v7+bN++nTp16hT6uaCgIH788UetxvBqx/Hw8CjyOaZMmcLBgwe5dOkSFy5coG7duixatIjKlSuTnZ3Nq6++yvr16zEYDPj7+/PVV19xxx13kJSURHBwMO3atWP+/PmF1hjeaB9DqTEUQgghiuPECfugEMBigZMnb/jQMTExDBgwgMWLFxMWFsawYcPo168fSikOHz7MoEGDOHToEBMmTKB///4opfjoo4/o3bs3Bw4c4ODBg4wbN+6Gy1GRnDt3TpstAHKbYGvUqEFERESJHae45/jjjz9Yvnw5R48eJTAwUOs2MmPGDI4fP87evXs5cOAAS5YsoWrVqrz55pt07dqV/fv3FzjFVUmSwFAIIYQojrp14crpgQwGuErtU1Ht3r2bJk2a0KRJEwAGDhzIhQsXiIyMJCgoiG7dugHw6KOPEhUVxblz5+jUqROff/45r776Kr/++qvMaXkLuO+++/Dz8wNg2LBh2lroP//8M2PGjMHR0REAHx+fm142CQyFEEKI4qheHT77LDcYhNyfn35a6gNQrqTT6dDpdPTt25cdO3ZQv359rfZQ/CcwMJCLFy+Sk5MD5E4EHRERQY0aNfjqq69o3rw5zZs3Z+HChdd9nKvtK4ryNLm6BIZCCCFEcQ0dmtun8Lffcn8OHVoih23Xrh0HDx7U+uR98803VKtWjWrVqnHmzBl+++03AL7//nt8fX2pXr06J06cwNfXl6eeeopZs2bx559/lkhZKoqqVavSsmVLli5dCsDKlSupXr06derU4amnnmL//v3s37+fIUOGXPdxrravIOvWrSM6OhqABQsW0L17dwAeeOABPvjgA7KysgCIjY0FcpfBTEpKusE7UTQy+EQIIcRtqbxOcL1hwwZeeeWVAgeftGrVin379uHg4MCCBQto0aIFM2bMYOnSpTg4OGC1Wnn11Vd59NFHy/oyypVjx44xePBg4uPj8fDwYOHChVpz/ZWGDx/O2rVriYqKonLlyri7u3Pycv/Rqx2nqOeYMmUKhw4d4tKlS0RGRhY4+GTdunWYTCYCAgJYt24dSUlJ3HPPPaSmptK+fftSHXwigaEQQojbUnkNDEXFNmXKFBITE5kzZ06pHF9GJQshhBBCiBIhK58IIYQQQtwkU6ZMKesiXJXUGAohhBBCCEACQyGEEEIIcZkEhkIIIYQQApDAUAghhBBCXCaDT4QQQghRqqZOnVoqx508eXKpHPd2JjWGQgghhKjQnn/+eYKCgtDpdOzfv99u34kTJ2jfvj316tWjdevWHD58uNDjbNiwgTvuuIOmTZvSrl07Dhw4oO2LiYmhV69e1K1bl8aNG7Nt27YSK/+ZM2eYP3++XVpQUFC+aykJEhgKIYQQAEpBTlrpvmRNiTLRr18/tm/fTs2aNfPtGz58OMOGDeP48eNMmDCBwYMHF3iMS5cuMXDgQBYvXkxYWBjvvvsuAwcO1PZPnDiRdu3aceLECRYuXMiAAQMwm80lUv6CAsPSIk3JQgghBIAlHb5zK91zPJoKRterZtHpdEybNo3Vq1cTHR3NnDlz+Pfff1m5ciVJSUl8/vnndOnSBYBffvmFt956i4yMDAwGAzNnzqRr165ERUXx+OOPk5ycTGZmJl27dmXu3Lno9XoWLVrE0qVL8fHx4dChQzg6OvLdd99Rq1at0r32MtSpU6cC02NiYvj777/59ddfAejbty+jRo3i5MmT+dY5PnXqFJUrV6ZRo0YAdOzYkYiICPbt20fLli357rvvtKXzWrduTUBAAL///ru2DrLNokWL+Oqrr3Bzc+PkyZNUqVKFr776iqCgIABmzpzJ0qVL0ev1ODs7s2XLFkaMGMHZs2dp3rw5NWrUYPXq1SV5e+xIjaEQQghRzri5ubF7926++OILnnjiCfz9/fn777+ZPn0648ePB+D06dNMmTKFdevWsXfvXpYvX86AAQPIysrCy8uLNWvWsHfvXsLCwjhz5gzfffeddvw9e/Ywffp0Dh48SPfu3Zk5c2ZZXWqZOnfuHP7+/hiNufVkOp2OGjVqEBERkS9v3bp1iY+PZ+fOnQCsXr2alJQUzpw5Q3x8PGazGT8/Py1/UFBQgccB2LFjBzNnzuTIkSP07t2bYcOGAbB48WJWrlzJ9u3bOXDgAOvXr8fR0ZH58+dTv3599u/fX6pBIUiNoRBCCJHL4JJbo1fa5yiCxx57DIA77riDtLQ0+vfvD0CbNm04ceIEkNvf7eTJk3a1YXq9noiICKpVq8aECRPYvn07SiliYmJo3LixdpzQ0FCCg4O17Q8//LDELrGi8vT05Pvvv2fSpEmkpqYSGhpKSEiIFlQWR/v27WnYsCEAw4YN47XXXsNisfDzzz8zYsQIPD09AahUqVKJXkNRSGAohBBCAOh012zmvVmcnJwAMBgM+d7n5OQAoJTi7rvvZvny5fk+P23aNGJiYti9ezdOTk6MGzeOzMzMfMe/8pi3m8DAQC5evEhOTg5GoxGlFBEREdSoUYOvvvqK2bNnAzBmzBiGDBlC165d6dq1KwBZWVn4+fkREhJC5cqVMRqNREVFabWGZ86coUaNGmV2bddLmpKFEEKIW1DPnj3ZtGkTYWFhWtpff/0F5A6U8PPzw8nJiaioKFasWFFWxSzXqlatSsuWLVm6dCkAK1eupHr16tSpU4ennnqK/fv3s3//foYMGQLAxYsXtc++9dZb3HXXXVpfxEceeUQbILJnzx4iIyPp3LlzgefdtWsXR48eBWDBggV07doVg8HAAw88wPz580lKSgIgMTERi8WCh4eHllbapMZQCCGEuAXVqVOH5cuXM3z4cNLT08nOzqZFixYsX76cMWPG0K9fPxo1akRAQEC+ARA3W1nPNzh8+HDWrl1LVFQUPXv2xN3dXRso8umnnzJ48GCmT5+Oh4cHCxcuLPQ4b7zxBn/88Qc5OTmEhobyxRdfaPtmzpzJ/7N339FRFW8Dx7+7m+ym90oISWgBAoReQglIR0CKCgpIU5SiCIqK/hRREdFXEFCwoIAFUaQJAgLSpEhvIRACJEAICYH0XnbeP2IurIBSEurzOSfH7L2zc2eGu9nHmTsz/fv3p0qVKhiNRr7//nusra2vmk9YWBivvvoqx48fx93dnW+//RaA/v37Ex8fT1hYGFZWVtjb27Nu3Tpq165NSEgINWvWpGLFimX6nKFOKZk7L4QQ4sGTm5tLTEwMQUFBFkOrQpSluXPnsnTpUpYuXVom+d/qfS1DyUIIIYQQApAeQyGEEA8o6TEU9yPpMRRCCCFugfSPiPuJ2Wy+pffL5BMhhBAPJGtra3Q6HUlJSXh6eqLT6e50kYS4aUop8vPzSUpKQq/XYzQabyofGUoWQgjxwMrMzCQuLk56DcV9w87ODl9fXwkMhRBCiJtRVFREQUHBnS6GELfMYDBgZWV1S73fEhgKIYQQQghAJp8IIYQQQoi/SWAohBBCCCEACQyFEEIIIcTfJDAUQgghhBCABIZCCCGEEOJvEhgKIYQQQghAAkMhhBBCCPE3CQyFEEIIIQQggaEQQgghhPibBIZCCCGEEAKQwFAIIYQQQvxNAkMhxC0rLCzklVdewd/fH71eT/fu3QHQ6XS8/fbbZXrtVq1a0apVq5suo7j3DBw4kMDAQItjt+NeE+JBIIGhEGXo559/RqfTsWTJkivOhYaGotPp2LBhwxXnKlSoQFhYmMWxgoICpk+fTsOGDXF0dMTBwYGGDRsyffp0CgoKrsgjMDAQnU6n/Xh5edGiRYsrytKqVSuLdLa2ttSuXZtPPvkEs9l8XfX85ptv+Oijj3j00UeZN28eo0ePvq733U73Qhmvx7Zt23j77bdJTU0t82vFx8fz9ttvs3///v9MW5r3+u02d+5ci8+AjY0NVatWZeTIkSQmJmrpNm7caJHOYDDg5eXFo48+ypEjR66Z/4oVK+jYsSPu7u5a3i+//DIXL168Im1UVBSjR48mLCwMGxsbdDodsbGxZVFtIa7K6k4XQIj7WfPmzQHYsmULPXr00I6np6cTERGBlZUVW7dupXXr1tq5M2fOcObMGfr06aMdy8rK4uGHH2bTpk106dKFgQMHotfrWb16NaNGjWLx4sX89ttv2NvbW1y/Tp06vPTSS0Dxl/wXX3xBz549mTVrFs8995yWrnz58kyaNAmACxcuMH/+fEaPHk1SUhITJ078z3quX78ePz8/pk6danE8JycHK6u748/Mtcp4r9m2bRsTJkxg4MCBuLi4lOm14uPjmTBhAoGBgdSpU+df05bWvX4nvfPOOwQFBZGbm8uWLVuYNWsWK1euJCIiAjs7Oy3dCy+8QMOGDSkoKODgwYN8/vnnbNy4kYiICHx8fCzyfPnll/n4448JDQ3l1Vdfxc3Njb179/Lpp5+yYMEC/vjjD4KDg7X027dvZ/r06dSoUYPq1atfV1AuRKlSQogyFRQUpBo1amRxbPXq1Uqn06knnnhCdejQweLc/PnzFaCWLVumHRs6dKgC1IwZM67I/9NPP1WAeu655yyOBwQEqIcfftji2Llz55S9vb2qWrWqdiw8PFyFhIRYpMvJyVEBAQHK0dFRFRYW/mcdW7dufUUet0t4eLgKDw//z3SlXcaioiKVk5NTavldr48++kgBKiYmpsyvtWvXLgWoOXPmXFf60rjXr8eAAQNUQECAxTFAjR8//obyKTFnzhwFqF27dlkcHzNmjALU/PnzlVJKbdiwQQFq4cKFFulmzZqlADV58mSL4yX169279xWfox07dig7OztVq1YtVVBQoB2/ePGiSk9PV0rd3n9rIUrIULIQZax58+bs27ePnJwc7djWrVsJCQmhU6dO/PXXXxZDtlu3bkWn09GsWTMA4uLi+Prrr3nooYcYOXLkFfmPGDGC1q1bM3v2bOLi4v61LD4+PlSvXp2YmJh/TWdjY0PDhg3JyMjg/Pnz10wXGxurDREePnxYG2LbuHEjcOVzX2+//TY6nY7jx49rPV7Ozs4MGjSI7Oxsi7znzJnDQw89hJeXFyaTiRo1ajBr1qx/LffNlDErK4uXXnoJf39/TCYTwcHB/N///R9KKYt8dDodI0eO5IcffiAkJASTycTq1asBOHv2LEOGDKFcuXKYTCaCgoIYNmwY+fn5ACQnJ/Pyyy9Tq1YtHBwccHJyolOnThw4cOCK8s6YMYOQkBDs7OxwdXWlQYMGzJ8/X2u/sWPHAhAUFKTV5UaHGq+nPBs3bqRhw4YADBo0SLvW3Llzr5nvrd7rAN9//z3169fH1tYWNzc3+vTpw5kzZ26ofiWOHj3K6dOnb+q9AA899BDAf35eWrRoAcCJEycsjk+YMAFXV1e+/PJLDAaDxblGjRrx6quvcujQIX755RftuJubG46OjjddZiFulQSGQpSx5s2bU1BQwI4dO7RjW7duJSwsjLCwMNLS0oiIiLA4V61aNdzd3QFYtWoVRUVFPPXUU9e8xlNPPUVhYaEWqFxLQUEBZ86c0fL+NyUB1b8NV3p6evLdd99RrVo1ypcvz3fffcd3331H9erV/zXvxx9/nIyMDCZNmsTjjz/O3LlzmTBhgkWaWbNmERAQwOuvv87HH3+Mv78/w4cP57PPPvvPsl9vGZVSdOvWjalTp9KxY0emTJlCcHAwY8eOZcyYMVfktX79ekaPHk3v3r2ZNm0agYGBxMfH06hRIxYsWEDv3r2ZPn06/fv3Z9OmTVqwe/LkSZYuXUqXLl2YMmUKY8eO5dChQ4SHhxMfH6/l/9VXX/HCCy9Qo0YNPvnkEyZMmECdOnW0e6dnz5488cQTAEydOlWri6en5w21yfWUp3r16rzzzjsADB06VLtWy5Ytr5nvrd7rEydO5KmnnqJKlSpMmTKFF198kT/++IOWLVve1DOV1atX/9fPzX8pCfT+6/NSEpi7urpqx6Kjo4mKiuKRRx7Bycnpqu8rKduKFStuuoxClLo73WUpxP3u8OHDClDvvvuuUkqpgoICZW9vr+bNm6eUUsrb21t99tlnSiml0tPTlcFgUM8884z2/hdffFEBat++fde8xt69exWgxowZox0LCAhQ7du3V0lJSSopKUkdOHBA9enTRwHq+eef19KFh4eratWqaemOHj2qxo4dq4ArhqKv5WrD0UpdObw3fvx4BajBgwdbpOvRo4dyd3e3OJadnX1Ffh06dFAVK1a84trXM5R8tTIuXbpUAeq9996zOP7oo48qnU6njh8/blEXvV6vDh8+bJH2qaeeUnq9/ophSKWUMpvNSimlcnNzVVFRkcW5mJgYZTKZ1DvvvKMde+SRR/5zuLs0hhevtzw3OpR8K/d6bGysMhgMauLEiRZ5Hjp0SFlZWVkcv96hZOC67o2SoeR169appKQkdebMGbVgwQLl7u6ubG1tVVxcnFLq0lDyN998o5KSklR8fLxavXq1qly5stLpdGrnzp1aniX31tSpU//12k5OTqpevXpXPSdDyeJOkB5DIcpY9erVcXd3Z8uWLQAcOHCArKwsbSZmWFgYW7duBYofPC8qKtIe5AfIyMgA+NfhpZJz6enpFsfXrFmDp6cnnp6ehIaGsnDhQvr378/kyZMt0h09elRLV61aNT766CO6dev2r8OGt+LyiS9QPBR38eJFi/Lb2tpqv6elpXHhwgXCw8M5efIkaWlppVKOlStXYjAYeOGFFyyOv/TSSyilWLVqlcXx8PBwatSoob02m80sXbqUrl270qBBgyvy1+l0AJhMJvT64j+3RUVFXLx4EQcHB4KDg9m7d6+W3sXFhbi4OHbt2lUq9buW6y3PjbqVe33x4sWYzWYef/xxLly4oP34+PhQpUqVq85o/i9KKe2RgevRtm1bPD098ff3p0+fPjg4OLBkyRL8/Pws0g0ePBhPT0/KlStHx44dSUtL47vvvtOG3uH6Prcl5//5uRXiTro7pgsKcR/T6XSEhYWxefNmzGYzW7duxcvLi8qVKwPFX5affvopgPaleXlgWPLFUvJFczXX+hJq3Lgx7733HjqdDjs7O6pXr37VoeHAwEC++uorzGYzJ06cYOLEiSQlJWFjY3PzFf8XFSpUsHhdMgSXkpKiDbtt3bqV8ePHs3379iueP0xLS8PZ2fmWy3Hq1CnKlSt3RbuVDIWfOnXK4nhQUJDF66SkJNLT06lZs+a/XsdsNjNt2jRmzpxJTEwMRUVF2rnLhylfffVV1q1bR6NGjahcuTLt27fnySeftHgGrzRcb3lu1K3c69HR0SilqFKlylXztra2vulyXa/PPvuMqlWrYmVlhbe3N8HBwVoAfbm33nqLFi1akJmZyZIlS1iwYMEV6a7nc1ty3svLq/QqIcQtksBQiNugefPmLF++nEOHDmnPXJUICwtj7NixnD17li1btlCuXDkqVqyonS8JUg4ePHjNJUMOHjwIYNGbBeDh4UHbtm3/s3z29vYW6Zo1a0a9evV4/fXXmT59+nXX83r980H8EurvCR8nTpygTZs2VKtWjSlTpuDv74/RaGTlypVMnTr1utdXLG2X92LeiPfff58333yTwYMH8+677+Lm5oZer+fFF1+0qEv16tWJiopixYoVrF69mkWLFjFz5kzeeuutK57BvBXXW56bcbP3utlsRqfTsWrVqqveHw4ODrdUruvRqFGjq/b8/lOtWrW0z0v37t3Jzs7mmWeeoXnz5vj7+wOWn9trOXXqFOnp6Vd8boW4kyQwFOI2uHyNt61bt/Liiy9q5+rXr4/JZGLjxo3s2LGDzp07W7y3U6dOGAwGvvvuu2s+SP/tt99iZWVFx44dS6W8tWvXpl+/fnzxxRe8/PLLV/TwlbXly5eTl5fHr7/+anHtmxlO/DcBAQGsW7eOjIwMi17Do0ePauf/jaenJ05OThYTKq7ml19+oXXr1nz99dcWx1NTU/Hw8LA4Zm9vT+/evenduzf5+fn07NmTiRMnMm7cOG3B41t1veW5mWvd7L1eqVIllFIEBQVRtWrVG77unfTBBx+wZMkSJk6cyOeffw5A1apVqVq1KkuXLmXatGlXHVL+9ttvAejSpcttLa8Q/0aeMRTiNmjQoAE2Njb88MMPnD171qIXxWQyUa9ePT777DOysrIshpEB/P39GTRoEOvWrbvqci2ff/4569evZ8iQIZQvX77UyvzKK69QUFDAlClTSi3P61XSY6QuWzImLS2NOXPmlOp1OnfuTFFRkTa8WWLq1KnodDo6der0r+8v2Vpv+fLl7N69+4rzJeU3GAxXLH+zcOFCzp49a3HsnzthGI1GatSogVJK292mZBHzW9n55HrLczPXutl7vWfPnhgMBiZMmHBF2ZRSV90l5L/c6nI116tSpUr06tWLuXPnkpCQoB1/6623SElJ4bnnnrMYrgfYs2cPkydPpmbNmvTq1avMyyjE9ZIeQyFuA6PRSMOGDfnzzz8xmUzUr1/f4nxYWBgff/wxwBWBIRQHKkePHmX48OGsXr1a6xn8/fffWbZsGeHh4dr7S0uNGjXo3Lkzs2fP5s0337ylZ89uVPv27TEajXTt2pVnn32WzMxMvvrqK7y8vDh37lypXadr1660bt2aN954g9jYWEJDQ1mzZg3Lli3jxRdfpFKlSv+Zx/vvv8+aNWsIDw9n6NChVK9enXPnzrFw4UK2bNmCi4sLXbp04Z133mHQoEGEhYVx6NAhfvjhB4tHBkrq7ePjQ7NmzfD29ubIkSN8+umnPPzww1qPU8m988Ybb9CnTx+sra3p2rUr9vb2vP3220yYMIENGzb86/7R11ueSpUq4eLiwueff46joyP29vY0btz4imctL3ez93qlSpV47733GDduHLGxsXTv3h1HR0diYmJYsmQJQ4cO5eWXX/7Pf4/LVa9enfDw8BuagHKzxo4dy88//8wnn3zCBx98AEDfvn3ZtWsX06ZNIzIykr59++Lq6srevXv55ptvcHd355dffrF4fjItLY0ZM2YAl57D/PTTT3FxccHFxeWqa5kKUaruzGRoIR4848aNU4AKCwu74tzixYsV8K87jeTl5ampU6eq+vXrK3t7e2VnZ6fq1aunPvnkE5Wfn39F+qvtfHI111pqRimlNm7ceF07StzocjVJSUkW6UqWC7l8WY5ff/1V1a5dW9nY2KjAwEA1efJk9c0331yR7laWq1FKqYyMDDV69GhVrlw5ZW1trapUqaI++ugjbamZy+syYsSIq+Z96tQp9dRTTylPT09lMplUxYoV1YgRI1ReXp5Sqnh5mJdeekn5+voqW1tb1axZM7V9+/Yryv7FF1+oli1bKnd3d2UymVSlSpXU2LFjVVpamsX13n33XeXn56f0er1Fe7z00ktKp9OpI0eO/GtbXG95lFJq2bJlqkaNGsrKyuq6l665lXt90aJFqnnz5sre3l7Z29uratWqqREjRqioqCgtTVktV3O1JYcud62dT0q0atVKOTk5qdTUVIvjS5cuVe3atVOurq7KZDKpypUrq5deeumKz4FSxcsGAVf9+WedhSgLOqX+0WcvhBDintSoUSMCAgJYuHDhnS6KEOIeJYGhEELcB9LT0/H09GT//v3/ufOMEEJciwSGQgghhBACkFnJQgghhBDibxIYCiGEEEIIQAJDIYQQQgjxNwkMhRBCCCEEIAtcXxez2Ux8fDyOjo6lsh2VEEIIIcTtopQiIyODcuXKodf/e5+gBIbXIT4+XtsYXQghhBDiXnTmzJn/3DpVAsPrULIV1ZkzZ3BycrrDpRFCCCGEuH7p6en4+/tr8cy/kcDwOpQMHzs5OUlgKIQQQoh70vU8DieTT4QQQgghBCCBoRBCCCGE+JsMJQvxL0p2jCzpfs/MzCQ+Ph5ra2uCgoK0dBs2bODChQu0bNkSb29v7b0yi10IIcS9RHoMxV1LKcXlW3mnpaURHR3N2bNnLdKtXr2aX375hYyMDO3Y3r17mThxIj///LNF2hdeeIHevXsTExOjHVu+fDmhoaEMGzbMIm1ISAh6vZ7t27ejlKKoqIjly5cTHBzMgAEDyM3NJScnh6ysLEaNGsXjjz/Otm3bSEtLIzc3lz///BNvb2+eeOIJi3xTU1ORLcqFEELcjaTHUJS6uLg4jh8/jre3N9WrVwegoKCAUaNGkZKSwhdffKFN4vn666/59NNP6d69O+PHj9fycHNzIzU1ldjYWPz9/VFK8eWXX/LKK6/wxBNP8M0332iBY9++fUlOTmbnzp1UqVIFpRSbNm3if//7H506dSI8PFxLu2TJEuLi4ujXrx96vR6lFCdOnODgwYM4ODgQHR2N2WxGKUV+fj4AR48e1cqbkpKCo6MjSimOHz+ulbdy5coYjUbUmTMkL1pEXoUKrN+yhfPnz3P27FkSEhIwmUyYTCbatGlDdHQ0v/76K61atdLyTUpKomLFilhZycdSCCHEnSHfQMKC2WwmISGBlJQUatSooQ2Frl+/no0bN9KkSRM6d+4MQHZ2NvXq1SMlJYWYmBhsbW0pKipixowZfPjhhzz77LNMnjyZoqIiCgsL+fLLLykqKmLMmDF4e3tjNpuJjo5m//79BAUFER0djVIKs9lMQUEBSikOHTpEeno6UDyM6+DgQE5OjkVQVrNmTTIzM0lKSsLW1hYAd3d3evXqRbVq1UhKStLSPvPMM+Tm5uLo6Kj1MIaGhvLFF1/g5uZGXl6elvarr74CwNnZWTvWsmVLtm3bdkW7vfPOO7guXky50aPRmc0ovZ6nxo2j+oIFAFy4cAEo7gU9duwYmZmZFBUVER8fj8lk4pdffuG5556jbdu2rF27Vsv3999/x9vbmxo1amA0Gm/2n1UIIYS4LhIY3ocKCgooLCzUgqTc3FwWLVpESkoKI0aM0IK9zz//nB9++IE+ffowYsQIoDj48vPzA4qDGZPJRFFREStWrGDq1KkMGTKE0NBQLdg7fvw4RUVF7NixA09PTwBMJhOBgYHo9XrOnDmjlWvkyJF45efjsGsX2VWrUujjQ3h4OBUrVsTb29siKFuyZAlWVla4uLhoxx577DEee+yxK+r72WefXXGsXr161KtX74rjPXv2vOKYp6enVvbLeXh4XNm412CVkEC5CRPQmc0A6MxmgiZNIv/33yn08dHS6XQ6Nm/ezOnTp3F3dyc5ORmAmJgYbGxs8PDw4MSJE5hMJoxGI7179yYtLY0DBw5Qu3ZtAPbt28eePXto3LgxtWrVuu4yCiGEEP9FAsN7wIkTJzhx4gQBAQEEBwcDxc/bjRkzhvT0dH7++Wct2Bs9ejSffPIJ//vf/3jrrbcoKioiNTWVfv36AdCtWzct2IuMjGTLli0EBQXRrl07LdgzGo3Y2tpy6NAhLTiqXLkyvXv3pnr16qSkpGhlmzNnDnZ2dhYB3OOPP87jjz9+RT3GurlpwZPS64kfPx569rzqrjI+lwVTZa1k2LjkmcHc3Fztp+R1Xl7eNc/l5uZS9exZPvg7KCyhM5vZ9u235DVtiq+vL76+vtjb22NtbU2lSpUs0vbr148nn3xSyzcnJ4fs7GwqVapEbGwsRUVFHD9+HJPJxPfff8+UKVMYNGgQs2fP1rY3eumllwgICGDQoEHXtYipEEII8U86JU/B/6f09HScnZ1JS0sr0wWuExISaNq0KdnZ2SQkJGgTHkaOHKk9X/faa69RVFREenq6FlxERkZiNBoxm818/PHHfPHFFzzxxBO8/vrrQHHg8+yzz+Lg4MDbb7+t1SEqKopTp04RFBRElSpVtHKYzeb/3EvxRlklJBDcoYPWowag9Hqi/tGjdjmlFIWFheTk5JCXl/evgdt/vb5aYHf5+Vv9GPgBpwDDZccKgUDg8qkyTk5OWpB4tR8PD4//bPulS5eyatUqOnbsSI8ePTAajWRlZWk9pOfPn8fNzQ2DwcDcuXPZsGEDjz/+OA8//PAt1VEIIcS96UbiGOkxvIvYXrxIYGws0cCePXuwsbEBirfkq1q1KjqdTpuRq5TihRdewMnJiaysLIqKigAYMGAA/fr1w8HBQctXp9Px5ZdfXnG94OBgrQfycjcbFObl5ZGRkUFmZiaZmZlkZGSQlZVFRkYGXocPU+0qPWqfjR7NXzY21wzsSup1u+j1eoxGK5zsrHGyt8LJzgpHOwOOtsU/DrZ67G30ONjosDfpsLcBO6MOO5PiYG46oekX0OvBnAKrdR60yzRxLC6XyFOZpGbkkZ6eTnp6OlFRUVe9vpWVFT4+PpQrVw4fHx98fX0tfvf19aV79+50795de09+fj4ZGRk8/fTTpKSkkJiYSGJiIlZWVixevJjly5cTGBhIeHg4JpOJrKwsmjdvTvXq1fnxxx+1yS6yvI4QQgjpMbwOt6XH8OuvUUOHFg+z6nTEvfUWaY8+WjbX+gelFLm5uVowd3lgV/L71Y798/eCgoJrXuN6e9SuRafTYW1tja2NFc521jjaG3C+LGhzsNXjYKPHXgvYdFrAZmcEG2uFrbXC1tqMjbUZk5UZk6EIG6tCjIYijPpCjIZCrHUFWOsLb6U5rymz0I6LOfYkZtoQn2bF6YtwMrGI6LP5RJ7K5FRCJtfzaXRzc7MIHsuVK2fR6+jq6qoFeDt27GD//v00b96ckJAQACIiInjiiSfw8vLi8OHD2mzpZ599lo0bNzJx4kSefPJJAAoLC0lPT8fNza1M2kQIIUTZkx7De01cHPwdFALolKL8u++S1bz5NYdZSyilyMnJ0YK0mw3sCgtLLxgyGo3Y25nwdDbi5WLE3cmAh5MVi1UmvbIuoLcBsxH2+HvymYcTttYKG2szNtYKG6ui4qDNqgiToRCjvuiygK0Agy6/1Mp5PQrMVhQoawrM1hQoa/LN1uQXWZFfZCC30EBeoZ7cQj05BQZyC3Rk54NZgY9TET6OubjbZuNinYZJn4+DVTYOjtkEOAK+V14r32xNSp4D57PsSMiw5kyyntjzZo6fKyAqLocjp9LJyS0kOTmZ5ORkIiMjr1pmk8l0xRD18ePHycrKwtfXFz8/P2bOnElWVhYJCQna+/bu3UtsbCzp6emcP38ek8lEZGQkYWFh1KhRg8OHD2tpL168iKura6k/ciCEEOLOksDwbhAdDVcZZl33+ecccHXVhmSvFthdPoxcGkwmEzY2NtjaGPFwNuHpbIWHsxVuDnrcHfW42utwsQdnW4WTjRlHmyIcjIXYGwuxt8rD1iofG0MuJn3Gv15HDzQmCUj613TXYlY6LVi7PHDL+ztoyyssDtxyC/XkFujJydeR83fglp0P2XmQlavIylNk5prJzFFk5haRkV1EenYR6dmFZOYUkp9fSH5+PgUF+RQU3FxbOzo6EODrSXB5Gyr5WhPkqae8m8LXKR9P+xxcjek4WmVi1BfgbZuCt20KtTyAIMt8zEpHeoEjF3LsScwwcjbVilMX4GRiIdFn8zgcm0nCxSzy8vKIjY0lNjb2quXR6XR4eHjg6+vLunXrtOCxd+/e9OrVC39/fxITE9HpdPz1118A2NracurUqeL748IFPhw8mM3nzvHe3Lm0adPmhttECCHE3UmGkq9DmQ8lx8WhAgIsJmbcyDArFH/ZlwR1JpMJW1sTbo7WeDpb4+5owM1Rj6uDDjd7Hc62Cmc7haOpCAfT34GddT62VvnYGnKx0ediY8j774teh3yzNblFNuSYbcktMpFTaCSn0Kq4p61AT06BnpyC4qAtJ19HVp4qDtryioO2rFxFZo6ZjJyi4p+/A7fs3ALy8wsoKLD8uZ1sbW2xtbUtDqT//q+NjQ16vZ7z589z7tw5bZHsf2MymfBydybY344q5UxU9DZQwUNRzrkQb4dc3GyycLZKw0r/30FpTpENF3MdOJ9ly7k0K05f1BGbZCY6Pp+oMzlEx6VTUPDf+djZ2WlD1R4eHri6ulK1alVaHDtG2Ny56JSiCDj1xhsETJiAwWDQ1pG8/PlWIYQQd96NxDESGF6H2/GMYdb06ZhGjcKK4qBwvLcXGyp44e5YPAzraq/D1UGHix242Ckcbcw4mopwNBVib12AnXX+3wHd34GdPpfSmEdQYLYi12xzKbgz25BTaCQz34rMPCvScvSk5UBqFiRnKi6mF3EhvZAL6YUkpeaTkXVp+ZXSmP17vYxGoxaw/TN4u/y/lwd0Vzt+rWMmk+k/J2qYzWaSk5M5d+6cxU98fDwJCQnEx8eTlpb2n3XR6/W4uDhRsZxDca+jjzWBnjr8XIvwcczHwzYbV2Matobc/8yr0GwgtcCRpGw7EjOMxKUYOJWkOJFQ+PdwdSYp6TlXfe/VnhM16/Uc+/137IOD+eCDD5g3bx4ffvghw4cP/8+yCCGEuD3kGcN7kP2QHhRV+JL0C6ewNhbyriEJve78LedbaDYUB3b/CO5yi0xk5VuTkWcgPVdPanZxcHcxw8zFDDMX0gu4kFZARla+Ftjl5KSRk5Nwyz1zBoPhioDsRoI0Gxsb7OzsrjhWktZkMpXatnIlW+mVPEuXmprKkSNHMJlM1KhRQ0u3cOFCEhIS6Nmzp7ZAeEpKCvv378fX15f27dtfNf/s7OyrBowlx86fP09RURHJyakkJ6eyO+Lq5bS3t6eclw/VyttRqZw1Fb0M+LspfJ0L8LLPxc2UjqNVBlb6IjxMqXiYUqnuClS4Mq+MAnsu5jr8PUnGwOkLOmLOF2FzMh3DsWTIupRWbzbzzlNP4dOnD5s3byYrKwtnZ2fy8vIwmUykp6dz4cIFKlaseFPtL4QQ4vaSwPBuobfGkH0YJzvLw0VKT26RzRXBXd7fv2cXGouDu5zi4C4lS1n03KVl5lksmpyTk6L9fiu9dzqdDkdHR5ydnXFycsLZ2Vn7/Z+vS34veW00Gst8WZS0tDTOnj2Lra0tQUGXHtZbuHAhKSkp9OzZU1u8e/v27Xz77bdUq1aNUaNGaWl79OjBiRMn+P7776lTpw56vZ5du3YxZswYmjRpwo8//oher0ev17Nw4UKOHDlC27ZtqVevHkVFRezZs4fRo0cTEhLCwoULtecTx40bR3x8PKNGjaJevXpUqlQJFxcXCgsLCQ0NtVhCqLCwkKSkJItg8Z9BZE5ODllZWUTHZBEdc/X2sLa2xs3Vjarl7ala3oZK3lZU8AA/l0K8HfNwt8nCxToNo74AR+ssHK2zCLzGJBlyKH7GYQsUboXN585xdupUdDodoaGhxMfHc/jwYVxcXFi0aBGvvPIKzz77LJ9//vkt/qsKIYQoaxIY3iUKDc6cqziLBUtWk5JZHNwVB3b55ORcWt+vOKi7qAV31/MM278xGo03FNSV/NfR0bFUZqSW9CjZ2tri63spClm8eDGZmZn07NlTe2Zt8+bNLF68mNDQUAYNGqSl7dKlC4mJifz8888EBQWh1+tZu3YtEyZMoH379syaNQuDwYBer+frr7/m7NmzdO7cGW9vb60OW7ZswcrKSnu/Xq/HZDKhlMLLy0vrHYyLi6Ny5cpUqlSJwMBArQx9+/YlMTGRkJAQbXs9Pz8/mjZtSo0aNahevbq2YHd0dDRRUVG4uLjg7e1NYWEhu3bt4vnnn6dmzZr8/PPPWhA5fvx4zp07xwsvvECXLl0AtBnJPj4+VKpUifT09H8NHC9evEhBQQGJ5y+SeP4if+698t+hONAvniRT3d+ueLjaS0d5VzO+Tvl42BVPknGwygJboHLxj66/nh/ifPlibT4LNiZx4MABDhw4gLOzM507dyYtLQ2dToePjw+ZmZnY29tjNpv5888/admypcxqFkKIu4wEhneJ2NNnqdJ02E2/39HR8ZpB3eUB3T/PlSyifTPMZjNHjx4lIyOD+vXra8O327Zt488//6R27dp06tRJS9ulSxfS09NZunQpHh4e6HQ6Fi1axJQpU+jVqxeTJ0/WgrL/+7//IyMjg0ceeQRPT0/0ej1ZWVn88ccf2Nvba3sx6/V6ioqKyM3NxcfHh5CQEHQ6HSEhIZQvX57y5ctbDGOW7D1cqVIlLYBr06YNc+bMoUKFCtjb22tpV69eXdzTdtkafm3btiU6OvqKtnjjjTeuONa2bVvatm2rvS5Zi3Hu3LnExcXRrFkz3N3dAShXrhwNGjSgZs2aVK9eHbPZTGFhIUePHuXYsWM4OTnh5eVFYWEhO3fuZNiwYdSsWZOffvpJ+7f88ccfSUhIYOTIkdq+yikpKURERGiB8dUCx4SE4scD0tMzOJSewaGrr72NjY0N3h5eNPM10r1GEc2b5OLrlEJ4wFnCn4YZ/RxZdsiV/1t8kSOn0/jxxx8BCAoKIjk5mb179+Lt7c2BAwfo3bs3devWZc+ePbKothBC3EVk8sl1uB2TT5KTk/Hx8fnXodlr9eA5OjpiMBj++yL/cP78eeLj43Fzc6NCheKHzfLz85k5cyYZGRm89tprWFtbAzBv3jy+/fZbunXrxqhRo9DpdCilqFWrFgC7du3Cy8sLg8HAZ599xqRJk+jbty8zZszAYDBgMBgoV64c6enpHDlyhKpVq6LX6/niiy94/fXXefzxx5k1a5ZWtkGDBlFQUMCkSZO0vZQPHz7Mn3/+SZUqVSyWSDl27BhGo5Fy5cphNBpv+t/gbrRlyxZOnz5Nhw4dtCBy1apVjBs3jtq1a/Ptt99qe1zXqlWL6Oholi1bRuPGjSksLGTVqlU888wz1KpVix9//FF7fODtt9/m/PnzDB8+nBo1anDx4kWioqI4ePCgtn3g5UFkRsbVlx/q0MiTkZ3saFMpAdu/Z7KbFRy+6Mu8LVbM/PUsOXnFs+2trKxo2bIl3t7eLF++nO7duzNt2jScnZ0xGAysWLGC8PBw2edZCCFK2T0zK3nWrFnMmjVLW28tJCSEt956S+tlys3N5aWXXmLBggXk5eXRoUMHZs6cibe3t5bH6dOnGTZsGBs2bMDBwYEBAwYwadIki8kHGzduZMyYMRw+fBh/f3/+97//MXDgwOsu5+0IDEv2RT569Oh1pS8oKOD48eNkZmbSsGFD7fimTZv466+/aNSoEa1btwYgMzOTxx9/nIyMDNavX4+1tTV6vZ4pU6bw9ddfM2TIEN58801tWK8kSIyKitKGW6dMmcLbb7/NwIED+frrr7W01apVw2AwsHr1ai2A27x5M6tWraJRo0b06NFDK9vu3buxs7OjcuXK910AdzfYsGEDZ86coXPnztrzkytWrODVV1+lbt26fPfdd1pPZM2aNTl+/DjLli2jUaNGFBYWsnLlSp599llq167NDz/8oOX7zjvvkJiYSNeuXbGzs+PcuXNs3bqVzZs3a0PeDrYGRnQrR/+wAkI8Li2anVVowx8nfJixMpt1uy9NpnJxcaFdu3b06dOH4OBgUlNTad68OQ4ODsTFxeHs7HybWk0IIe5/NxTHqDvo119/Vb/99ps6duyYioqKUq+//rqytrZWERERSimlnnvuOeXv76/++OMPtXv3btWkSRMVFhamvb+wsFDVrFlTtW3bVu3bt0+tXLlSeXh4qHHjxmlpTp48qezs7NSYMWNUZGSkmjFjhjIYDGr16tXXXc60tDQFqLS0tNKr/FVcvHhRPf3006pv377q0KFD2s+wYcOUt7e3GjNmjDp06JCKiIhQ27ZtU4ACVFRUlDp16pSKi4tTw4YNU4AaNmyYSk5OVmlpaSo1NVVLe+7cOWU2m5VSSk2dOlVVrFhRvf322xblGDt2rBo/frxKTU3VjsXFxandu3er+Pj4Mm0DcXv8/vvvavbs2SopKUk7tmzZMlWlShX1xBNPKLPZrAoKClROTo6qVKmSAtSvv/6q4uPj1enTp9WCBQuUq6uratKkiapcubJ2fwGqdkVHNXdMBZX8jYNSP6D9nPrCU300NEiV97K3SF+jRg3Vr18/VaFCBRUWFqYSEhJUbm6uUkqppUuXquPHj9+pZhJCiPvCjcQxdzQwvBpXV1c1e/ZslZqaqqytrdXChQu1c0eOHFGA2r59u1JKqZUrVyq9Xq8SEhK0NLNmzVJOTk4qLy9PKaXUK6+8okJCQiyu0bt3b9WhQ4frLtPtCgyTkpK0L8uEhASVmpqq0tPT1ahRoxSgRo8erYqKirQvbV9fX1W9enWLAG7lypXq1VdfVb/99ptF3tu2bVMRERGqoKCgTOsg7j8rVqxQs2bNUufPn9eOldyTjz32mIqMjFQ//vij6t27t3JwcNDuYb0O9VRbb/XnB36q4DuDFiDmf2eltnwYoAZ1qqCsrPRaeisrK9W6dWv12WefqX379qmIiAjl6OioALV79+472AJCCHFvu5E45q55xrCoqIiFCxcyYMAA9u3bR0JCAm3atCElJQUXFxctXUBAAC+++CKjR4/mrbfe4tdff2X//v3a+ZiYGCpWrMjevXupW7cuLVu2pF69enzyySdamjlz5vDiiy9ec3HhvLw88vIu7fyRnp6Ov79/mQ4lQ3EbjBkzBmdnZ15//XVtYkhsbCwXLlygfPny+PzH3slC3A4FBQXa4wOhoaFkZmZy7NgxmjRpQmBgIO7u7uzcuVN7ptHH1ZoxPb3p0zALf8cULZ/kPGd+O+rJtF/T2HP00vaInp6etGrVihMnTpCUlMSff/6Ju7s79vb2rFq1CpPJROvWrWVWsxBCXId7aoHrQ4cO0bRpU3Jzc3FwcGDJkiXUqFGD/fv3YzQaLYJCAG9vbxISip9hSkhIsHjesOR8ybl/S5Oenk5OTg62trZXlGnSpElMmDChtKp43QwGA9OmTbvieGBgoMXSKELcadbW1nTt2lV77ejoSHR0NIWFhbi4uPDjjz9y/Phxfv311+LFvxMTeeXrOF75Gh6q48yoLg60q3IBN1Ma/UPT6FcbjqSWZ/5ftnz2axxJSUksXLgQgJo1a/L111/TqVMnXFxcGDNmDFFRUcydO5cBAwbcqSYQQoj70h0PDIODg9m/fz9paWn88ssvDBgwgE2bNt3RMo0bN44xY8Zor0t6DIUQ19anTx+aNGnCxYsXCQoKonz58oSEhDB//nycnJyoX78+27dvZ/3+NNbvT8PWCMO6eDOopZmanknUcI3jvU7wejtbNp2uwudr81mx5QwRERFERETw4YcfEh4ejo+PD8nJyYSGhpKcnIyzszPbtm0jKiqKxx57TCauCCHELbjjgaHRaKRy5coA1K9fn127djFt2jR69+5Nfn4+qampFr2GiYmJ2nCqj48PO3futMgvMTFRO1fy35Jjl6dxcnK6am8hgMlkwmQylUr9hHiQXN67bW1tTVpaGgaDASsrK+bNm8f58+dZuXIl8+fP5+jRo0xZnMiUxVDd38TLPdzpXicNN1MWnSpG0+lZONPfm6UH3Zi+LInjpy+wZs0aoLjXf+bMmXTv3p2AgAAmTpzI77//TlRUFB999NEdbAEhhLi33XUP6JjNZvLy8qhfvz7W1tb88ccf2rmoqChOnz5N06ZNAWjatCmHDh3i/PlLy2CsXbsWJycnbaeKpk2bWuRRkqYkDyFE2alevTpnz55l48aN+Pv7U69ePV588UXt+dmHHnoILy8vjpzJY8j0eDyHZPHkl65sjvWh0KzH3y6R55scIXJiKtunVGZYj2BsbU0kJiby1Vdf8fDDD/PUU0+h0+kIDAykRYsWJCQkkJeXx9GjR/nf//531QXJhRBCXENZz4T5N6+99pratGmTiomJUQcPHlSvvfaa0ul0as2aNUqp4uVqKlSooNavX692796tmjZtqpo2baq9v2S5mvbt26v9+/er1atXK09Pz6suVzN27Fh15MgR9dlnn921y9UI8SDIzs5WrVq1UtbW1ioqKkpFR0erWbNmqSZNmiiDwaDNUvZy1qv3B3irU7NcLJa9uTjHRf34Rg3VvF6A0ul0WnqTyaS6deumvvnmG3XgwAE1dOhQBahu3brd6SoLIcQddc8sVzN48GAVEBCgjEaj8vT0VG3atNGCQqWUysnJUcOHD1eurq7Kzs5O9ejRQ507d84ij9jYWNWpUydla2urPDw81EsvvXTFkiwbNmxQderUUUajUVWsWFHNmTPnhsopgaEQpe/yNRTz8/PVY489pgDVqFEjVb16dYu1DluG2KrF43xU9jyjFiCav0cdmRmg3nm6lvL1drNI7+fnpzp37qwaNmyoZsyYoU6fPq3S09NVSkqK6t+/v1qzZo22nqcQQtzv7snlau5mt2PnEyEedG+88QazZ8/m559/Jjg4mL/++ot58+axevVqcnNzAbA1wjMd3BjSWkdt74vae7OLbNkaX5HZGxTLNp6wWG6qUaNGdO/enbZt27Jq1SrGjx9PtWrViIyMlH2ahRAPhHtmS7x7hQSGQtwehYWFGAwGbS/uN998k4kTJxIcHIy3tzdbtmzBbC7eezm4nBVjerjxaL1M3GyytTzicnz57Yg3s1alcPDIaW0tRXt7e5o0aYJOp6Nx48YMGjQIV1dXHB0d6du3L+3ataNfv37XnJQmhBD3KgkMS5kEhkLcGcuWLWP69OkMHDiQrl27cuzYMb777jvmzJlDVlYWAHod9Gxqz4hOdjQPvIiVvjhwLDBbcSC5MvN32DBvdSzJyalavgEBATzyyCN07dqVuLg4Bg0ahKOjI+fOncPe3v5OVFUIIcqMBIalTAJDIe4e33//Pf3798fT05MWLVrw+++/a0GipxO80NWNp5oVUsE5XXtPcr4rG88E8sWaPDbsiKagoAAAnU5H/fr18fb2xt/fn1GjRuHi4oJLZibfjBuHc4MGPPrii7J8lRDiniaBYSmTwFCIu0dUVBRffPEF5cuXZ/jw4cTHx7Nw4UImT55MSsql7faaVbNmdDdnOoWkYWdVHAialY7ozCCWHXJn9qpEok+e1tI7OjrSqVMnxjg702j2bHRKUQQkTJiA31tv3e5qCiFEqZHAsJRJYCjE3W3Pnj00aNAAo9FI//79WbVqFfHx8UDxhJVBbRwZ2taKUJ9LgWN2kS07zwczb4uBJRuOk5aWhh9wCjBclrfS68k6fBj74GD+/PNPateufcVWnUIIcTeTwLCUSWAoxN0tMzOTRYsWcfbsWV577TVSU1NZvXo1L7/8MomJidqElSo+OsZ0d+XxBjm42eZo74/LKce6k/7sWZLIjCOxV+Qf+dln5IeF0apVK5RSbNu2jZCQkNtVPSGEuCUSGJYyCQyFuPekpKTg7e1NQUEBI0eOZPPmzRw8eBAonrDySEMTIx+2p2XF1EsTVoqssNpWiG4TcKQ4n0KgloMDdbp0YceOHQDs3LkTd3d3dDodhYWFWFnd8d1FhRDimiQwLGUSGApx71FKcfDgQdasWcPYsWPJzc1l586djBw5ksOHD2u9iB6OMKKzEwNbmgl0ybyUwVkw/wovHbDjk4zi5XDs7Ox45JFHeO655/D29sbDw4OOHTsSGhrKxIkT8fb2vhNVFUKIfyWBYSmTwFCI+4NSimrVqnHs2DFGjhzJ0aNH2bhxI4WFhQA0qaJn9CPOdKuZgY118bGL+W78FBHExB9OE5+QBICNjQ2PPfYYDRo0YNSoUdjb2xMTE4Onp+cdq5sQQlyLBIalTAJDIe4fmZmZLFmyhMcffxxra2tOnjzJ6NGj+e2337TFsB1tYWw3W17oUISzKR+AlAJnFh+pwnvzzxJ75hwARqOR5s2bU69ePQYPHoy7uzvu7u5MmzaN5s2b06hRoztWTyGEKCGBYSmTwFCI+9uQIUP45ptvGDJkCHl5efz666+kp6djZ4IxXWwZ08mMq23xNnvphY4sOxbMuz+eI/rkWQCsrKzo2rUrTz/9NABdunRBKUV0dDSVK1e+Y/USQgiQwLDUSWAoxP3v4MGD+Pj44OXlxYULF3j55ZeZN28eADbW8HxnW17povCwK963ObPQnt9OVuO9BReIiDoFgF6vp1WrVkDx4tnffvstHh4eGI1GTpw4QcWKFWV/ZiHEbXcjcYz+NpVJCCHuarVr18bLywsADw8P7fc6depg5+jGR8ty8BuWy4vzbUnMtMPBKoveVfew443zLH63HnVrVsRsNrN+/Xo2bNiATqdj27ZtHDt2jKioKBo1akTdunU5c+bMnaymEEL8K+kxvA7SYyjEg0cpxaZNmwgMDMTFxYWpU6cyffp0UlNTsTLA023t+F93HX5Oxdvx5RaZ+COuBu/9kslfe6O1fFq1akXz5s2ZMmUK3t7eHDx4EAcHhztVLSHEA0iGkkuZBIZCCIDnn3+eTz/9FCsrKwoLC9HrYOBDtrzV04oAlwwA8sxGNsXXYOKiXP7cFaVNaGnQoAEPP/wwjz76KI6Ojnh4eNC3b1/atm3L008/jY2NzZ2smhDiPlbmgeGAAQMYMmQILVu2vOlC3kskMBRCAOzatYt33nmHgQMHEhkZyfTp07lw4QI6HfRtacfbj1lRyTUdgAKzFVsSQ5i0tIA/th3V1k2sV68ezz77LEVFRQwfPhx7e3tiY2Px8PC4k1UTQtzHyjww7N69OytXriQgIIBBgwYxYMAA/Pz8brrAdzsJDIUQV5OZmclTTz3FkiVLtGOPhdnybm8TwR6pABSaDfyVVIPJy2HV5kiKiooAqFmzJjVq1MDPz48RI0bg6emJo6MjixcvplWrVri7u9+JKgkh7kNlPvlk6dKlnD17lmHDhvHTTz8RGBhIp06d+OWXXygoKLipQgshxL3GwcGBypUro9Pp6NixI56enizclkO1Ual0n2ZHxHk3rPRFNPc+xNIhh9k6pRq92odibW1NREQEP//8MytXrmTZsmXExsayfv16Hn/8cQIDA0lISLjT1RNCPIBK5RnDvXv3MmfOHGbPno2DgwP9+vVj+PDhVKlSpTTKeMdJj6EQ4t8cOXIEf39/dDod06dP56OPPiIlJQWATvXteP8JW+r4XgTArHTsS6nOlN9N/LLmMPn5xQtoV6xYkY4dO/LHH3/g7e3NkiVLcHFxQa/Xk52djZ2d3R2rnxDi3nZbl6s5d+4ca9euZe3atRgMBjp37syhQ4eoUaMGU6dOvdXshRDirle9enUcHBywt7dn3LhxhIWFAcVb563ak03dly/SdrIdO896otcp6rtF8n2ffeyaGsSgHvUxmUycPHmSmTNnkpWVRVhYGKdOneLYsWOcPn2aypUrM2DAAC3YFEKIsnJTPYYFBQX8+uuvzJkzhzVr1lC7dm2efvppnnzySS0SXbJkCYMHD74v/pBJj6EQ4kbExMTwwQcfMHz4cNasWcOUKVO0oeHmNWyZ3N+JsAqJWvrDaVX4dKMz85YfJicnBwBfX18GDx6Mo6Mjr732GgEBAURFRWEyme5InYQQ964yn3zi4eGB2WzmiSee4JlnnqFOnTpXpElNTaVu3brExMTcaPZ3HQkMhRC3Iicnh4cffpgNGzZoxxpVteXDAc60CEhA//dmKMcyKjLrTw9mL4skMzMTAE9PT9q3b0/jxo1p06YN7u7uuLm5MXbsWB599FGaN29+J6okhLiHlHlg+N133/HYY489MOtuSWAohLhVb775Jh9//DFPPvkkK1eu5Ny5cwDUrWTLhwNcaV3xHAZd8Z/jE1mBzN7uzcxFkaSnF6+P6OrqylNPPUWfPn04ePAgzz77LLa2tpw9exZXV9c7Vi8hxN1PFrguZRIYCiFKQ1JSEh4eHuTn5zNr1iwmTJhAamoqALUC7Zg80JV2lc5hpS9e8/BUdnnm7CrP9IVHSUkpTufo6Ei3bt1IT0/H09OTd955B09PT4xGI3v27KFu3bro9bLbqRDiktsSGO7evZuff/6Z06dPa7PqSixevPhmsrxrSWAohCgLjRo1YteuXTg5OZGeXrwwdrC/LR8O9KBT1Xis9cVrHsbllOPbvRWY+nM0Fy4Uz262s7OjT58+PPXUU7i7u5OWlkZ4eDjBwcFs375d/lYJITRlPit5wYIFhIWFceTIEZYsWUJBQQGHDx9m/fr1ODs731ShhRDiQbNmzRomTpzI8ePHmT59OuXLlyfqTA6PvHuGaq9Ys+hwBfLNVpS3jef1Zn9xcLIV/zeqKT4+XmRnZ/PNN9/QsWNHJk+ezPr167G1tcXDwwNra2vtGjIoJIS4ETfVY1i7dm2effZZRowYgaOjIwcOHCAoKIhnn30WX19fJkyYUBZlvWOkx1AIcTvk5+fTsGFDDh48qB0L8Lblg0He9KgRj8lQPDqTlOfBz5FVmLwgljNxxc8qWltb8/DDD9O9e3fq16+vLZ/ToUMH+vfvz/Dhw2VGsxAPqDIfSra3t+fw4cMEBgbi7u7Oxo0bqVWrFkeOHOGhhx7SHqq+X0hgKIS4HZRSTJ06lf/7v//jmWeeYe7cuZw+fRqAch42fDDQl0drx2NryAPgYr4bi44GM/mnOE7GngHAysqKLl268PTTT7Njxw7effddAgICOHbsGEaj8dLF4uIgOhqqVIHy5W97XYUQt0+ZDyW7urqSkVE8U87Pz4+IiAigeIma7Ozsm8lSCCEeeDqdjjFjxnD69GkmTJhAdHQ0s2bNwsnJifgLuTz1fzFUHK1nzp5KZBXa4m5MZmjt7ex5O525/2tCtSpBFBYWsnTpUrp168bOnTsZPnw4I0eO5PTp06SlpWE2m/njySdRAQHw0EMQEABff32nqy6EuEvcVI/hk08+SYMGDRgzZgzvvvsuM2bM4JFHHmHt2rXUq1dPJp8IIUQpMZvNhIaGEhERgaenJ0lJSQB4uNjw3oDyPFn3HI7WWQCkFzjyW0wIkxZe4FDkcS2Ptm3b8swzz1CjRg0i16yh10svYbj8IgYDxMZKz6EQ96kyH0pOTk4mNzeXcuXKYTab+fDDD9m2bRtVqlThf//73323ppYEhkKIOyk/P5/FixfTs2dP5s2bx6RJk7TNA1wcTbw7oAL9GyTgbF08kpNZaM/vp2syaWEqew5Gafm0bNmSgQEBDPruuyuuceyLL6j89NOy1I0Q9yFZx7CUSWAohLib5OfnExQURHx8vHbM2dGG8f0CGNjoHK7G4qVvsotsWRdXiw8WZ/LXniMopfADToFFj6HS6wlQCruqVdm1axeOjo63tT5CiLJV5s8YpqWl8csvv/B///d/fPzxxyxZskRbg0sIIUTZsrKy4v/+7/8ICwvj008/pVKlSqRl5DJmVhT+I3L5cFM1LuS5YmfIoVvATta/cIKVHzQgvGktzun1DAUK/87LrNOx7rHHSLG3x8PDA7i0xE3JtnxCiAfHDfcYfv/994wcOfKKQNDZ2ZnPP/+c3r17l2oB7wbSYyiEuJsVFRXx/fffM2LECLKyip83tLcz8doTFXkmLAlvmwsA5JmNbEmszYe/FhK19RCBRUUcBwq9venVqxfh4eHUqFEDo9GInZ0d9evXJywsjK+++koLGoUQ954yG0reu3cvjRs3pm/fvowePZpq1aqhlCIyMpJPPvmEBQsWsGvXLkJDQ2+5EncTCQyFEHe73NxcWrZsya5du6hQoYK2zI2trYmxfSrxbLMLlLM9D0CB2YrtF0KZsc6aVRsPacGkjY0N3bp1o2/fvsTFxTFixAj8/f2JiorC1tb2jtVNCHFryiwwHDRoEJmZmSxcuPCq5x999FGcnJz45ptvbqzEdzkJDIUQ9wKlFPv27SM0NJQFCxbwzjvvcOzYMQCMRmvG9K7K8JbJ+NsVrzVrVjoOZ1Tnh93uzF0RRWLieS2v5s2b06ZNG/z8/GjatClOTk64ubnRq1cvGjVqxJgxY+67iYZC3K/KLDCsWrUqM2fOpG3btlc9v27dOoYPH679IbpfSGAohLgXpaen4+vra7G+rMlkZGSvqgwLT6eSw2nt+NnccqyIrsiny85z+Gi09pxhpUqV6NevH126dCEyMpIBAwZgY2PD6dOn8fT0vO11EkLcuDILDB0cHIiMjKRChQpXPX/69GmqV6+uDUvcLyQwFELcqzZv3sy3335L69atee+99zh69ChQvIXek51CGNamgPpuR7HSFwGQUejA5nM1+XR1Puu3RZCfX7wNn4uLC7169cLPz4/s7GwGDx6Mm5sbbm5uTJo0iapVq9KrVy+LfZqFEHeHMgsM9Xo9CQkJeHl5XfV8YmIi5cqVo6io6MZKfJeTwFAIcT8wm838/PPPDBw4kLy84m319Ho9zRsEM6abPQ/5H8XRqngmcqHZwP7UGnyz1YEfVx8hNTUVKJ4RXbL/ckhICImJiXTo0IGioiL2799/3z1jLsT9oEwDw3nz5uHs7HzV86mpqQwaNEgCQyGEuEulpKQwcOBA1q5dS61atdi5c6d2rlKQP6N6+tGj+mnK215aIzE2uwKLIsrz6dIzxJ46ox2vV68ePXr04OzZs5w8eZKZM2fi4eGBk5MTy5cvp2LFitSsWfO21k8IcaUyDQz/i06nk8BQCCHucufPn8fLy4tdu3bx4YcfsmjRIu25Qjc3NwY8HMyApmnUcjqCXld8PKXAhXWnqzFteQbb9xzBbDYD4OfnxxNPPEHPnj1xdHSkqKiItm3bcuHCBdatW0ebNm3uWD2FELLzSamTwFAIcT9LT0+nQoUKpKWlYW9vb7F8TafwWgxvpyPM6xB2hhwA8s3W7LpQg5l/WLHkj0hycoqP29nZ0b17dzp16sS3337LkSNH2LJlC97e3tjY2HD06FHKlSsnf0eFuM3KLDB86623eOSRR6hfv/4tF/JeIoGhEOJ+l56ezu+//06nTp346quvmDZtGqdOnQKKR4Ia1A1hZBc3OgQexdt0aVmbY5kVmb/bk1nLTnD+/AUtfXh4OL1796ZZs2bodDrs7Ox47LHHiI6OZuHChXTo0OGO1FOIB1GZBYaDBw9mxYoVGI1GunbtSrdu3WjTpg1Go/GWC303k8BQCPGgSU9Px8/P74pt8QIDAxjSpSKP1jxLsMMxdLri40l5Hvx2vCJTl17kYOQJLX1wcDD9+vUjLCyMZ555hjNnznDw4EGqVKmCwWAgIyMDBwcHdCUZCSFKXZkOJZvNZrZu3cry5ctZtmwZ586do127djzyyCN06dIFNze3Wyr83UgCQyHEg0YpxZo1a5g/fz5Dhw5lypQpLFu2THuG3NXVlZ7tQxnULIsGLgcwGYqXtckpsmFrQjWmrSri9y1HKSgoAIqfW+zduzcNGzakYcOG6PV6XF1dGTNmDIcOHWLGjBm0bt36jtVXiPvZbX3G8MiRI1qQuGfPHho1akS3bt144okn8PPzu5Ws7xoSGAohBMTGxtKwYUMuXLigHbO1taVl0zo8285ES5+DuBuTgb93VUmrwpxtjny9/Bjp6RlA8fqJnTt3pn///lSoUIF27dqRlpbGpk2baNGihfQcClEG7tjkk/Pnz7N8+XJ+/fVXWrRowcsvv1xaWd9REhgKIUTxfszjxo1j/vz5DBs2jG+++YYzZ4qXr9Hr9dSqGcIzD/vRseIxKtmd1N4Xn+vDksPlmbIonpOnLi2D06hRI3r16kVhYSHdunXDZDLh7u7OF198wb59+xg3bhx169a97fUU4n4js5JLmQSGQghxSX5+PkajkcLCQhYuXMjIkSNJTk7WzgcGBvJY++o8HppIqNNBrPWFAGQW2rP+TFU+/jWLLbuPa8vd+Pv707dvX7p3747JZKJ9+/YkJSUxb948nnrqqTtSRyHuJzcSx/z3woT/MHv2bAYMGMCcOXMA+Omnn6hevToVK1Zk/PjxN5TXpEmTaNiwIY6Ojnh5edG9e3eioqIs0uTm5jJixAjc3d1xcHCgV69eJCYmWqQ5ffo0Dz/8MHZ2dnh5eTF27FgKCwst0mzcuJF69ephMpmoXLkyc+fOvdGqCyGEAG3CoZWVlbZNHkCrVq0wGAzExsby0Zer6PjWKZ5a3JrfE1uRVuCEg1UW3YL2sf6F4+yYWpXB3WtjY2PDmTNn+OCDD2jXrh2ffPIJEyZMoF+/ftSqVYszZ86QnZ3N8uXLeeeddzh//vy/FU0IcavUDZg6daqyt7dXPXv2VL6+vuq9995T7u7u6r333lMTJkxQTk5O6osvvrju/Dp06KDmzJmjIiIi1P79+1Xnzp1VhQoVVGZmppbmueeeU/7+/uqPP/5Qu3fvVk2aNFFhYWHa+cLCQlWzZk3Vtm1btW/fPrVy5Url4eGhxo0bp6U5efKksrOzU2PGjFGRkZFqxowZymAwqNWrV19XOdPS0hSg0tLSrrtuQgjxoCgqKlLbtm1TSil1/PhxNXz4cGU0GhWgAGVra6tahTdT377bRZ2a7a/UD2g/sV+VV+8/V1d5ebpp6fV6vWrXrp369ttv1cGDB9WhQ4dUvXr1FKDefPPNO1xbIe49NxLH3FBgWK1aNfXDDz8opZTau3evsrKyUrNnz9bOz549W9WvX/8Gi3vJ+fPnFaA2bdqklFIqNTVVWVtbq4ULF2ppjhw5ogC1fft2pZRSK1euVHq9XiUkJGhpZs2apZycnFReXp5SSqlXXnlFhYSEWFyrd+/eqkOHDtdVLgkMhRDi+uXn5ytPT08FKDe3SwGfwWBQoaGh6v2Xe6r9s2qrwu/1WoCYMtdJzf9fHVU3JEBLD6iQkBD1/vvvq/fff1/Vq1dPbd68WSUmJqqCggIVGRmpFi1apAoLC+90lYW4q91IHHNDQ8mnTp2iefPmANStWxeDwUCTJk208+Hh4Zw4ceJab/9PaWlpANqSN3v27KGgoIC2bdtqaapVq0aFChXYvn07ANu3b6dWrVp4e3traTp06EB6ejqHDx/W0lyeR0makjz+KS8vj/T0dIsfIYQQ18fa2pq//vqLN954g7Nnz/Ltt99Sv359ioqKOHDgAK//32J6fJjBC388wsYLLckqtMPFOp0nqu9nx2tn2fx/NXi0XXWsrKw4fPgwr7/+Op988on2/XP+/HmioqIYP348vXr14oUXXriyEHFxsGFD8X+FENfthgJDOzs7baskAE9PTxwcHCzS/PPZvutlNpt58cUXadasmbbpekJCAkajERcXF4u03t7eJCQkaGkuDwpLzpec+7c06enp2lZOl5s0aRLOzs7aj7+//03VSQghHlQVK1bkvffew8bGhv79+7Nz506qVKkCFO+MEhMTw8w5S3js3Uj6Lwpn0dkunMv1wVpfSAvfSBYOPMLhT/0Y91QtHB3tOX/+PNOnT6ddu3a8/fbbHD9+HC8vL1xcXGjdujXp6ekopUhJSeHce+9BQAA89FDxf7/++g63hhD3jhsKDKtVq8bBgwe112fOnCEgIEB7ffToUQIDA2+qICNGjCAiIoIFCxbc1PtL07hx40hLS9N+SpZjEEIIcXOUUrz88svUqVOHbdu2MXToUBwcHLhw4QJLfl1F//F/0GdeFWYe601kZnXMSkdVx1O83+EQJ6eZ+Orl2lQK8CIvL49FixbRvXt39u3bxzvvvEOVKlU4ffo0x44d46vx4/F68034e8YzZjM8+6z0HApxnW4oMJw8eTLBwcHXPH/69GmeffbZGy7EyJEjWbFiBRs2bKB8+fLacR8fH/Lz80lNTbVIn5iYiI+Pj5bmn7OUS17/VxonJydsbW2vKI/JZMLJycniRwghxM0zGAwMHTqUffv20aRJE7744gtiY2OpVasWADk5OWze/CcvvPcLfWeZeHPXE2xLCSOnyAYPUzJP1z1IxLtp/D6pBm2bVESn07Ft2zZeeOEFevTowc8//0x6ejq5hw5h+OfFi4q4uGPHba+zEPeiGwoMmzVrRp06da55fvjw4YwcOfK681NKMXLkSJYsWcL69esJCgqyOF+/fn2sra35448/tGNRUVGcPn2apk2bAtC0aVMOHTpksYTB2rVrcXJyokaNGlqay/MoSVOShxBCiNvP1dWVatWqodPpeOutt6hTpw5FRUXs37+f96fNp/+UBEau68aKxM4k5XtgY8ijfYVI1ow8yYEZgYx4tDpGozUxMTG8++67tG3blgwfH8z/2D3FrNdT7/HHGTZs2B2qqRD3jlte4DozM1NbpLTE9fawDR8+nPnz57Ns2TKLnkhnZ2etJ2/YsGGsXLmSuXPn4uTkxPPPPw/Atm3bACgqKqJOnTqUK1eODz/8kISEBPr378/TTz/N+++/D0BMTAw1a9ZkxIgRDB48mPXr1/PCCy/w22+/0aFDh/8spyxwLYQQZefMmTP4+/tjNptZt24dI0aM4Pjx49p5Dw8Pwpo2oWdTB8I8dlPF/tK5czmeLNjvzUc/x3HufCoAT+t0fK4UBkDp9cxp0oQh27YxatQoPvjgA2xsbIDiSSxeXl63s6pC3BFlvvNJTEwMI0eOZOPGjeTm5mrHlVLodDptk/X/cq09MefMmcPAgQOB4gWuX3rpJX788Ufy8vLo0KEDM2fO1IaJoXi29LBhw9i4cSP29vYMGDCADz74ACsrKy3Nxo0bGT16NJGRkZQvX54333xTu8Z/kcBQCCFuD6UUNWrU4OjRo7Rq1Ypdu3Zpkx7t7Oxo2LAhnZtXpHW5CEKd9mPUFwCQVWjLmpOBfLA4nZ2HzuIHVAaoVIlmvXtTo0YNypUrh6enJ3Z2dpw9e5ZWrVrRvXt3Fi5ciF5/w/s9CHHPKPPAsFmzZiilGDVqFN7e3lcEeOHh4Tea5V1NAkMhhLh9srKymD9/PoMGDeLixYvMnDmTGTNmkJKSAhQ/r1i7dm1aN6tLh8pxNHLZgYt18XJnRUrP3qQgpv+u48e1MVpHRclWe7169aJevXp89913fPTRR3Tp0oWFCxdqvYipqalXrIQhxL2uzANDBwcH9uzZ868TUe4nEhgKIcSdo5SiYcOG7NmzBy8vL4tnyitVqkSzsMZ0rl1IY5cdBNqd0s6dzvJl0QF3pi9NIPbsBe14YGAgPXv2JDQ0FBcXFypWrIitrS06nY5atWoRHh7OTz/9hKOj422tpxBlpUz3SgZo2LChLOEihBDitpkyZQo9evTgwIED2vPhOp2OEydO8O1383n+ww2MWh7KpyeGsC+9DoVmAxXszzE6LIKoD9LY/FFVBjxcBWtrK2JjY5kyZQpDhgzh008/ZcuWLWRmZrJkyRKys7M5ffo0BsOluc2Xr98rxP3upnoMT5w4wXPPPUe/fv2oWbMm1tbWFudr165dagW8G0iPoRBC3F3MZjPdunXjt99+w8rKSttcwc7OjkaNGhHepDrNfKOp67QPD+NF7X3nc91ZccSb6cuTORCVoB339fWlR48eNGzYECsrK+rUqYOtrS1OTk40bNiQqlWrMnv2bCpUqHDb6yrErSrzoeS//vqLJ598ktjY2EsZ6XQ3PPnkXiGBoRBC3H3eeustZsyYwffff8/WrVuZO3cu586dA8DKyopatWpRv349mlYyU9dlHyEOh7XJKkVKz6GLFfh2mzVfLj9NVnYeUPxd1qxZM3r16kV4eDhHjhyhb9++ODs7ExMTg4uLCzqdjry8PEwm0x2ruxA3oswDwxo1alC9enVeeeWVq04+uXw3lPuBBIZCCHF3ys7Oxs7ODij+W92vXz9WrFjB5V9tHh4e1KlTh4Z1gmla7jR1nfZS3vasdj69wIG1J8ox47csNu29dNzNzY1HHnmEsLAw8vPzadmyJTY2Nri6uvLoo4+i1+v55JNPtEW6hbhblXlgaG9vz4EDB6hcufJNF/JeIoGhEELcGzp37syqVasYPXo00dHRrFu3TltWTafTUbFiRerUqUPLUHcauh2ituMB7K2ytfdHp/vx0y47pi05y4WUS8cbNGhAz549adeuHenp6bRr1w6AyMhIqlatik6no7Cw0GKZNCHuFmUeGHbt2pWBAwfSq1evmy7kvUQCQyGEuDcopdiwYQMtWrRAr9dz5swZXnvtNX755ReLx5xMJhM1a9akft1aPBScRT3nfVSyO4FeV/yVmFtk4s8z5fl8TT5LNp+h5JvS0dGRLl260LJlS5KTk+nWrRsmkwk3Nzdef/11oqKimDhxIs2aNbsT1Rfiqm4kjrmp/7Xp2rUro0eP5tChQ9SqVeuKySfdunW7mWyFEEKIW6LT6XjooYe014GBgej1eoqKihg8eDAmk4mlS5dy7tw59uzZw549e1jk7l7ci9igNc3LnaCO0z7cjCm0CzxBu6EQ38+DxftdmLIkkZj4DH788Ud+/PFHQkJCyMvLo1OnTmRkZLBgwQLS09PJyMjQnrkv+a8Q94qb6jH8txXiZfKJEEKIu0lRURHr16/Xdj9JT0/n008/5c0330Sn02nbupYMNdetE0rHerY0dDtIdYcjWOuLZzwXmg3sSfTj640wd3UcBYXF77OxsaFTp06Eh4dz9uxZ+vfvrz2LOGfOHH799Vdef/11OnXqdKeaQDzgyrzH8J97IwshhBB3K4PBoD0TCODs7IyVlRVKKbp27UqTJk1YtGgRe/bs4cSJE5w4cYLlK4qHmps26EPH4GTqOu+jnM05GvuepvETMLmXI79FejJlWQr7jqWwZMkSlixZQuXKldHpdHTp0oW8vDy+/PJLjh8/zokTJ6QXUdwTbqjHcPv27Vy8eJEuXbpox7799lvGjx9PVlYW3bt3Z8aMGffdFH7pMRRCiPtPZGQker2eatWqkZOTw4YNG+jatSsGg4GCggItnfvfQ80dG/vQwi+a2o4HsTUUT2hRCiKTy/HdNis+XXaWrJziETNra2vatGlDmzZtOH36NH379sXV1RU3Nzf+/PNPPvzwQ8aMGcNjjz12R+ouHixltvPJO++8w+HDh7XXhw4dYsiQIbRt25bXXnuN5cuXM2nSpJsrtRBCCHEb1ahRg2rVqgFga2tLUVERBoOBmjVrMn/+fLp164aNjQ0XL17kjz/+4JVJ8+k75SKDl3fkp7junMiuiE4HIe7xfND1NOc/t+bXtwJoW9+DgoICVq9ezdixY1m8eDE//PADcXFxJCQkMGPGDP766y+2bt3KTTzNJUSZuqEeQ19fX5YvX06DBg0AeOONN9i0aRNbtmwBYOHChYwfP57IyMiyKe0dIj2GQgjxYLhw4QLx8fHUrl2bgoICTp06Rb169cjNzbXoRSyZ1dymSSU6BSdQ12k/ztbp2vlTGR4s2GnHlMUJnE/NB4qfz2/ZsiVt27YlMTGRjh07UrlyZVxdXUlISGDIkCEMGzaMQYMG3fZ6i/tbmT1jmJKSgre3t/Z606ZNFg/Tyh7KQggh7mUeHh54eHgAxcPBBQUFGI1GTCYTixYt4qeffmLZsmWcPXtWm9U8282NenXr06u5K819o6hmf5QAxwu82gbGtLZi29/L3vy06TwbN25k48aNeHp6kpubS48ePfD39+ejjz5i165deHl5MXDgQHkGUdwxN9RjGBAQwHfffUfLli3Jz8/HxcWF5cuX06ZNG6B4aDk8PJzk5OQyK/CdID2GQgjx4MrLyyMqKoratWtjNptJTU0lLCyM48ePo9frtZ5EnU5HUFAQzRtV57EGeTR0O4i36byWT1KuE0v2O/PR4iSOn83Vjjdu3JgOHTqQlpZGaGgoYWFhuLq6otfr6dGjB/369WPIkCFXLp4dFwfR0VClCpQvf1vaQtybyqzHsHPnzrz22mtMnjyZpUuXYmdnR4sWLbTzBw8epFKlSjdXaiGEEOIuZDKZqF27NlA8HGw0GjEYDCil2LRpE5s2bWLRokXs3r2bkydPcvLkSX5aYiIkpAaPtGhCp6pnqeUYgadNOkObpPN0Yx37E334ZqPiq1WJ7Nixgx07duDs7EzXrl1xdXWlcuXK/PTTT2zZsoULFy7wzDPPWBbq669h6FAwm0Gvhy+/hCFD7kDriPvNDfUYXrhwgZ49e7JlyxYcHByYN28ePXr00M63adOGJk2aMHHixDIp7J0iPYZCCCEup5QiKiqKatWqoZQiOzubxx9/nJUrV+Lk5ER6+qXnDd3c3GhcvxZ9W9rQzOcogXantHOZBbasPOLGx0tT2RmVpR0PDQ2lU6dO5Obm4uPjQ/fu3XF1dcXZ2ZlhXbsye9069Jd/fRsMEBsrPYfiqsp8S7y0tDQcHBwwGAwWx5OTk3FwcMBoNN5olnc1CQyFEEL8G6UUvXr1YunSpaxYsYK0tDR++uknfv/9d4u9moOCgujYrDKP1c+kvutBHK0ytTyOp7jz7VZrpi9LJC27+KvZ3t6eTp060atXL0JCQvjrr7+YP3QoG65WiA0boFWrsq+suOeUeWD4oJHAUAghxPU4c+YM5cuXR6fTkZeXxxtvvMHHH3+Mm5ubxfP3RqOR0Foh9H3Ig/aVzlDV4RgGXfHmEflFVmw86cm03zJZuStDe09wcDCdOnXCOSODt775xqLHsAgY1Lo1r86YQUhIyG2rr7g3lPnOJ0IIIYS4kr+/v/a7yWTCzs4Oe3t7Jk6cSK1atZg/fz5Lly4lPj6eXXv2sWtP8VBz6yZh9G+pI8z7CJ7GC7Svco72L8K5LKfiZW+WJBEVFUVUVBQmkwm3WrUYGRGB3mxG6fU8azbz3YYNjNPrMZvN6PV6oqKiyMvLo1atWjLLWVw36TG8DtJjKIQQ4mZlZmZiZWWFjY0NRUVFzJs3jyFDhuDk5ER+fr7FUHNgYACPP1SBR+umUds5EqO+eMZzkdKx66wns37PY/6mNAqLwA9o6uGBd7NmuIeGYjab6d27NzqdDgcHB958802+++473njjDd5777072ALiTpMeQyGEEOIu4eDgoP1uMBgwmUz4+/vTp08fnn32WRYuXMiSJUvYuXMnMTGxTP46lqlGIw3qVGdIO0faBp2mgu0ZmpQ/T5MhML2fLUsOOPHxkmR+OX0Bli2DZcuwsbFhy5YttGzZkhYtWpCdnY2NjQ1Vq1bl/PnzODk5ERcXx1tvvUXPnj159NFH72CriLuV9BheB+kxFEIIUZqKiorIzc3F3t4epRTbt2+nWbNmWFlZ4eXlRXx8vJbWzc2NruGVeapZEY08j+JgdWn28rFkd36PMPLDxlR2ROVYXCM4OJiwsDDCw8OpU6cOBoOB77//nsmTJ9OqVSvWr1+vDTEnJyfj5uZ2eyovbjuZfFLKJDAUQghRlrZu3cpLL71E+fLl+fzzz1m7di0LFy7kt99+Iz+/eEs9nU5H5YoBDO7oTfdaF6nqcAK97tJXeHKuPX+edGbxjjwWbr5ITv6l/F1cXGjWrBlVqlQhKSmJ2rVr07VrV20lkcqVK1OpUiV+//13ix3OxP1BAsNSJoGhEEKI2yEvLw+TyQRAfHw8QUFB5OfnU6tWLQ4dOqSlMxqNhDeqypPhDjStcJGKdjFY6wu18/lmKw4murNyv57v/kjm+Lk87Zxeryc0NNRiyHngwIF4enoSERGBk5MTRqOR5cuXY21tTevWrbUyiXuTBIalTAJDIYQQt1tMTAwvv/wyp0+fZu3atURERLBgwQJ+/PFHi6VvTCYTNYKD6NHUhTbVc6jhEouLdZpFXqczXNl4zJ6f/sxk9e5UzJd98/v4+NCoUSMqV65M7969sbOzw8bGhkceeYTIyEjmzZvHU089dbuqLcqABIalTAJDIYQQd0phYaG2T3Jubi6VK1fm7NmzNGrUiOjoaFJSUizS+/r60KGxH13q6Wjgm4i/bZzFkHNmgQ0749z4dbeZ79cncTG9SDtnNBpp2LAhzZo1IyIigr1797JkyRIqVKiAo6MjK1as4IsvvuCZZ56hb9++t6cBxC2TwLCUSWAohBDibpCRkcH//vc/Vq5cyY4dO8jOzuavv/7is88+Y+/evRZb8QHY2tpSv2YgvcLsaVUlk2CnWGwNudr5IqUjKtmTtYeLJ7Dsisq0eH9QUBDh4eG0bNmSOnXq8MYbb7Bq1SpGjx7NRx99pO0ZvWvXLho0aIBer78t7SBujASGpUwCQyGEEHcTpZTFotUdOnRgzZo1vPDCC3h7e/Pnn3+yZcsWMjMvBXo6nY4K/uXo3syLTqFF1PU6h5cpySLfpBwntsQ4s/ivPH75M4nc/EshgoODA3Xq1MHJyYlHH32Uhg0bYm9vT2xsLA899BBBQUFER0dfsV2uuPMkMCxlEhgKIYS4m+3du5cVK1bwxBNPUKlSJbKzs1m+fDlPPvkkzs7O+Pj4EBUVZfEee3t7whtUoGdjG5pXTKWS/Wms9JeGlfOKrDmQ6MnKA3q+++MiJ89ZLodTs2ZNWrZsidFoZPbs2TRu3JgffvgBR0dHbG1teeedd/D396dXr144OzvflnYQVyeBYSmTwFAIIcS9Zv78+YwaNYpOnToxdepUoqOj+f3335k1axYXL16ksPDSLGa9Xk9wJT8ebeFK+5ACQj3O4GhlOawcm+7Bxmg7ftqSxe+7LnJ59ODm5kajRo1o3749TZs2xcrKirCwMAoKCoiMjKR69eoA5OfnYzQar78ScXEQHQ1VqkD58rfUHg8yCQxLmQSGQggh7kVFRUVkZGTg4uICFC+B4+fnB8C0adPYu3cvf/75JydPnrR4n5OTI12alad7AwNNKlzE3+6cxfn0Ajt2nnHn1z1mflh/nuT0Au2clZUVoaGhmEwmlFJ89dVXODo64ujoyNtvv83q1at59913efzxx/+98F9/DUOHgtkMej18+SUMGXLrjfIAksCwlElgKIQQ4n6QmZnJsmXLiIyMZOLEieTn55ORkUHfvn35/fffqVixIvHx8dr+zVC8jV/9ED8eb+7EQ9VyqOF6BpP+0urZhUrP0YterI00MX9jGrujUi2uWb58eVq2bEnLli354IMPiI2NZe7cufTp0weTyURSUhJbtmyhXbt2l7YPjIuDgIDioPBSQSA2VnoOb4IEhqVMAkMhhBD3sy5durBy5UpWrFhBtWrVWL9+PUuXLmX9+vXk5Fg+W+jl4cKj4d50qaujYblEPEyWy+Uk5riwJcaFxX/lsejPRPLyLwV3JpOJSpUq0a1bN9q0aUNAQABLly7llVdeoXnz5vz555/FCTdsgIceurKgGzZAq1alXf37ngSGpUwCQyGEEPe7pKQkXFxcsLa2BuD999/njTfeoHHjxrRq1YrNmzeze/duCgosh41bN/DjsTBbwitnUskpHoPuUiCYW2RiX4IXqw7q+e6PC8Sey7K4ZnBwMF5eXkRFRdGnTx/Gjh2Lk5MTNhcuYKhUCYv5zdJjeNMkMCxlEhgKIYR40ERERLBw4UJq165Njx49yMrKIiYmhvr166PT6XB2dubChQsW7wkq78YTrTzoWLuIut7ncLDK1s4pBTEZXmyMtuenP7NYu/u8xQQWZ2dnmjdvTosWLXB0dGTPiBF8AVgBymBA98UXrCpXDrPZTLNmzbTnJsV/k8CwlElgKIQQQsC+ffto06YNjo6O7N69m71797JmzRoWLlxIXFwcl4cUJpM1jzQrR88mRpoFplHe/rxFXqn5DuyM8+DXPWbmr08kJf3Sfs46nY7y5ctT19OTUQ8/jG+LFtgHB9OrVy92797N3LlzGTBgAABpaWkkJCRQtWpVi7UdxSUSGJYyCQyFEEKIYkVFRZw5c4bAwEAAzGYzNWrUICoqioEDB5Kamsqff/7JxYsXLd5Xp6oHT4S70C4kjxD3BIz6S0PSBWYDR5J9WHvYxPxNaeyNsnyvjY0NISEhZGVlkZKSwvTp02nQoAF2dnasXLmSIUOG8NBDD/HHH39YlFMW2y4mgWEpk8BQCCGEuDqlFN999x0rV67k888/x9bWlrS0NN5//32mTZuGq6srqampFr2JTvZG+jzkwyMNDDTxv4ibyXIrv/hsd7bGuLBkRz6/bj9PVnbePy9LUFAQderUIScnh/Xr1/P4448zadIk7OzssLW1JTg4GF9fX3766SctiH1QSWBYyiQwFEIIIW7MK6+8wkcffcSrr75Kv379WL16NRs2bGDdunXk5+dbpG1V15M+LRxoHZxDZedE9LpLoUm+2ZpTGZ4cjLdja1QRv+9OIzIm+YrrOTo6UqdOHerUqYOfnx+vvfYaRqOR6Oho3NzcsLW15euvv2bz5s089dRTtG/fvszb4G4hgWEpk8BQCCGEuHEJCQnodDq8vb1RSrF161ZatGiBnZ0dffv2ZevWrURGRlq8x8/Dlr5tPOhSB+qXS8LOKveKfJPznYi64MLuGCvWH8pmza4ksnOLLNLo9Xr8/Pxo0aKFFjC+//77bNy4kUmTJjFmzBiMRiMZGRl8/PHHhIWF0a5du/vyOUUJDEuZBIZCCCHErYuNjeWrr77CbDYzceJEMjMzOXnyJD169ODs2bMYDAaLxbX1emhey4M2dRxoUkkR4pOJr91F9P+I3QrNBk5nunPwrC1bjhaxencqh2Mz+ScXFxfc3d1p1aoVbdq0ISQkhIiICPr27UtAQAAxMTFaYPjXX3/h5eVFUFDQPR8sSmBYyiQwFEIIIcpGXl4e5cuX58KFC2zfvp1Tp06xdu1afv/9d+Li4q5I7+FspH0DN8JDTNQPKCDYPQUH65wr0qXn23H0ggu7YgysP5jNmj3JZOZYhjwmk4mgoCAKCgoIDAzk7bffxs/PDzs7O1q1asXRo0dZsWIFDz/8MAA5OTkYDIYb2+/5LiCBYSmTwFAIIYQoO4WFhezZs4fGjRsDxTOKn3vuOWbPnk14eDiBgYEcOnSIw4cPk5d35USU0EoOtK/nTFiwntByOVRwSrZYaBvArHScyXAt7lWMKmT1rlQOncrjn1FQYGAgtWrVYt++fSQkJLB582YqVKiAnZ0d8+fP56WXXuK5557jk08+KZ3Kx8VBdDRUqVJmi3ffSBxjVSYlEEIIIYS4TlZWVlpQCMX7M3fq1Im0tDT69+9P586dyc3N5eDBg4SFhWEwGOjSpQuHDx/mxIkTHDiRyYETl4aObY3Qtp4brWvb0ahiETW80nE1ZRHglEyAE3StDpO7Q1ahiaNJzsW9igeyWLs3ndjYWGJjY7W8OnToQGhoKHXq1OHQoUPk5eVhNptJSkrCzs4Oa2trGjduTJ06dfjkk09wdna+/op//TUMHVq8J7ReD19+CUOGlEKL3jzpMbwO0mMohBBC3HkHDx7k5ZdfxmAwsHz5cnJyckhMTOTRRx/lwIEDVK1alZSUFJKSkq54b5C3NR0auNCyhpG6/nlUck3FWl94RbqzmU4ciLNly9FC1uxJY19MIebLIiWdTkelSpVo0KABderUwdHRkREjRuDo6MipU6dwcHDA2tqab7/9ljNnztCzZ0+qV69+ZWXi4iAgoDgoLFFG2/7JUHIpk8BQCCGEuHt16dKFdevWsW7dOkJCQjh58iRz5szhs88+w8HBgcLCQotJLQBWBgirbk/bOg40raqnlm8m3nYZV+SdW2RFVJITO0/qWX8gm/UHszlvuewizs7O+Pn58fDDD1OnTh1q1arF008/zc6dO5k1axbPPvssOp2Oixcvsm7dOpo1a0b56Gh46KErK7NhA7RqVYqtI4FhqZPAUAghhLi75efnYzAYtN1OPvvsM55//nl69+7NtGnTOHDgADt27ODDDz8kLy+PgoIC/hkCeTpB+3outKppQ4OgQoI90rC1KrjiWolZ9hyIsynuVdybzt4YRcFlq+WYTCa8vLywsrKiX79+tG/fHj8/PzZs2MCQIUOoXbs2B377TXoM/2nz5s189NFH7Nmzh3PnzrFkyRK6d++unVdKMX78eL766itSU1Np1qwZs2bNokqVKlqa5ORknn/+eZYvX45er6dXr15MmzYNBwcHLc3BgwcZMWIEu3btwtPTk+eff55XXnnlusspgaEQQghx70lPTycjIwM/Pz+geF9lFxcXAPbu3cuxY8fYtWsXK1euJDo6msJCy6FlvQ5qB1rRob4zzYIN1Cmfi59j+hXL5RQU6Tl2wZGdJ3X8cSCLzZEFnLHc1Y+AgAC8vLyIi4vTnkf0Wr4c51dfRVdUVBwUfvFFmTxjeM9MPsnKyiI0NJTBgwfTs2fPK85/+OGHTJ8+nXnz5hEUFMSbb75Jhw4diIyMxMbGBoC+ffty7tw51q5dS0FBAYMGDWLo0KHMnz8fKG6M9u3b07ZtWz7//HMOHTrE4MGDcXFxYejQobe1vkIIIYS4fZycnCwCIWdnZ+Lj4zl48CB169albt269O7dm/Pnz3PkyBGGDh1KvXr12L17N/v27WPfvn3sjylkf8ylKM/JFsJr2tIm1J7GlSHEOwNHYx4h3mmEeMOgpsXpknNM7I+zYcuRQtYdyGJPzClOnToFwLlz59iyZQu1a9em49NP80hICLV69CizWck34q4ZStbpdBY9hkopypUrx0svvcTLL78MFEf63t7ezJ07lz59+nDkyBFq1KjBrl27aNCgAQCrV6+mc+fOxMXFUa5cOWbNmsUbb7xBQkKCtu7Qa6+9xtKlSzl69Oh1lU16DIUQQoj7V0xMDNu2bSM0NJSaNWuilGLHjh00bdoUBwcHXn/9dfbu3cvBgweJjo6+Ygi6sg+0q+tEeIiRegEFVHTJwKC3XC6nyKzjxEV7dp7Usf5ANluiiohOKD736KOPsnDhwjKr3z3TY/hvYmJiSEhIoG3bttoxZ2dnGjduzPbt2+nTpw/bt2/HxcVFCwoB2rZti16vZ8eOHfTo0YPt27fTsmVLi8UoO3TowOTJk0lJScHV1fWKa+fl5Vmsk5Senn5FGiGEEELcH4KCgggKCtJe63Q6goKCmDlzJllZWbz88ssopcjNzSU8PJxdu3bRuXNnCgoKOHToEMcTEji+Kp1Zq4rfb2uERpUNtKvrSFhVPaF+2bjZ5lLVM5OqntDv75V50vOsOZzggPKzvwO1vrq7NjBMSCgOo729vS2Oe3t7a+cSEhLw8vKyOG9lZYWbm5tFmsv/sS/PMyEh4aqB4aRJk5gwYULpVEQIIYQQ9xxvb2+GDRumvdbpdNja2tKvXz8qVKjApEmTqFixIrm5uXz++ee8/PLLeHh4UKlSJSIiItgUmcWmyFTt/X5u0KqmDQ/VtqVRRTNVPTJwMhXQNCAFKurvQA2v7q4NDO+kcePGMWbMGO11eno6/v7+d7BEQgghhLgbvPDCC7zwwgvaa3t7e2rWrEn79u2pU6eOtgf0/v376datGxkZGVSoUIGzZ8/yw+ZcfthcvGyOtQFCA6BDfReCGyn6N7lTNbJ01waGPj4+ACQmJuLr66sdT0xMpE6dOlqa8+fPW7yvsLCQ5ORk7f0+Pj4kJiZapCl5XZLmn0wmEyaTqVTqIYQQQoj7W4cOHejQoYP22sXFhfr16xMSEsKhQ4c4cOAA2dnZ7Ny5k2nTprFx40asTXbsPpnN7pOpPOduQ/87WP7L3T19l/8QFBSEj48Pf/zxh3YsPT1dexgUoGnTpqSmprJnzx4tzfr16zGbzdrWOk2bNmXz5s0UFFxah2jt2rUEBwdfdRhZCCGEEOJWOTo6sn37dlJTU3FxcaFcuXJ0796d2rVro9Pp+N///kdkZCTz58/n6aefvtPF1dzRWcmZmZkcP34cgLp16zJlyhRat26Nm5sbFSpUYPLkyXzwwQcWy9UcPHjQYrmaTp06kZiYyOeff64tV9OgQQNtuZq0tDSCg4Np3749r776KhEREQwePJipU6de93I1MitZCCGEEKUlIyODoqIibU3FsnbPLHC9ceNGWrdufcXxAQMGMHfuXG2B6y+//JLU1FSaN2/OzJkzqVq1qpY2OTmZkSNHWixwPX369GsucO3h4cHzzz/Pq6++et3llMBQCCGEEPeqeyYwvFdIYCiEEEKIe9WNxDF37TOGQgghhBDi9pLAUAghhBBCABIYCiGEEEKIv9216xjeTUoew5St8YQQQghxrymJX65nWokEhtchIyMDQHY/EUIIIcQ9KyMjA2dn539NI7OSr4PZbCY+Ph5HR0d0Ot2dLs4VSrbsO3PmjMya/gdpm2uTtrk2aZtrk7a5Nmmba5O2ubbb0TZKKTIyMihXrhx6/b8/RSg9htdBr9dTvnz5O12M/+Tk5CQfuGuQtrk2aZtrk7a5Nmmba5O2uTZpm2sr67b5r57CEjL5RAghhBBCABIYCiGEEEKIv0lgeB8wmUyMHz8ek8l0p4ty15G2uTZpm2uTtrk2aZtrk7a5Nmmba7vb2kYmnwghhBBCCEB6DIUQQgghxN8kMBRCCCGEEIAEhkIIIYQQ4m8SGAohhBBCCEACw7vW22+/jU6ns/ipVq2adj43N5cRI0bg7u6Og4MDvXr1IjEx0SKP06dP8/DDD2NnZ4eXlxdjx46lsLDwdlfllm3evJmuXbtSrlw5dDodS5cutTivlOKtt97C19cXW1tb2rZtS3R0tEWa5ORk+vbti5OTEy4uLgwZMoTMzEyLNAcPHqRFixbY2Njg7+/Phx9+WNZVu2X/1TYDBw684j7q2LGjRZr7sW0mTZpEw4YNcXR0xMvLi+7duxMVFWWRprQ+Qxs3bqRevXqYTCYqV67M3Llzy7p6t+R62qZVq1ZX3DfPPfecRZr7sW1mzZpF7dq1tYWGmzZtyqpVq7TzD+o9A//dNg/qPXM1H3zwATqdjhdffFE7dk/dO0rclcaPH69CQkLUuXPntJ+kpCTt/HPPPaf8/f3VH3/8oXbv3q2aNGmiwsLCtPOFhYWqZs2aqm3btmrfvn1q5cqVysPDQ40bN+5OVOeWrFy5Ur3xxhtq8eLFClBLliyxOP/BBx8oZ2dntXTpUnXgwAHVrVs3FRQUpHJycrQ0HTt2VKGhoeqvv/5Sf/75p6pcubJ64okntPNpaWnK29tb9e3bV0VERKgff/xR2draqi+++OJ2VfOm/FfbDBgwQHXs2NHiPkpOTrZIcz+2TYcOHdScOXNURESE2r9/v+rcubOqUKGCyszM1NKUxmfo5MmTys7OTo0ZM0ZFRkaqGTNmKIPBoFavXn1b63sjrqdtwsPD1TPPPGNx36SlpWnn79e2+fXXX9Vvv/2mjh07pqKiotTrr7+urK2tVUREhFLqwb1nlPrvtnlQ75l/2rlzpwoMDFS1a9dWo0aN0o7fS/eOBIZ3qfHjx6vQ0NCrnktNTVXW1tZq4cKF2rEjR44oQG3fvl0pVRww6PV6lZCQoKWZNWuWcnJyUnl5eWVa9rL0z+DHbDYrHx8f9dFHH2nHUlNTlclkUj/++KNSSqnIyEgFqF27dmlpVq1apXQ6nTp79qxSSqmZM2cqV1dXi7Z59dVXVXBwcBnXqPRcKzB85JFHrvmeB6Vtzp8/rwC1adMmpVTpfYZeeeUVFRISYnGt3r17qw4dOpR1lUrNP9tGqeIv+cu/1P7pQWkbpZRydXVVs2fPlnvmKkraRim5Z5RSKiMjQ1WpUkWtXbvWoj3utXtHhpLvYtHR0ZQrV46KFSvSt29fTp8+DcCePXsoKCigbdu2Wtpq1apRoUIFtm/fDsD27dupVasW3t7eWpoOHTqQnp7O4cOHb29FylBMTAwJCQkWbeHs7Ezjxo0t2sLFxYUGDRpoadq2bYter2fHjh1ampYtW2I0GrU0HTp0ICoqipSUlNtUm7KxceNGvLy8CA4OZtiwYVy8eFE796C0TVpaGgBubm5A6X2Gtm/fbpFHSZqSPO4F/2ybEj/88AMeHh7UrFmTcePGkZ2drZ17ENqmqKiIBQsWkJWVRdOmTeWeucw/26bEg37PjBgxgocffviKOtxr945VqeYmSk3jxo2ZO3cuwcHBnDt3jgkTJtCiRQsiIiJISEjAaDTi4uJi8R5vb28SEhIASEhIsLjBSs6XnLtflNTlanW9vC28vLwszltZWeHm5maRJigo6Io8Ss65urqWSfnLWseOHenZsydBQUGcOHGC119/nU6dOrF9+3YMBsMD0TZms5kXX3yRZs2aUbNmTYBS+wxdK016ejo5OTnY2tqWRZVKzdXaBuDJJ58kICCAcuXKcfDgQV599VWioqJYvHgxcH+3zaFDh2jatCm5ubk4ODiwZMkSatSowf79+x/4e+ZabQMP9j0DsGDBAvbu3cuuXbuuOHev/b2RwPAu1alTJ+332rVr07hxYwICAvj555/v6g+HuLv06dNH+71WrVrUrl2bSpUqsXHjRtq0aXMHS3b7jBgxgoiICLZs2XKni3LXuVbbDB06VPu9Vq1a+Pr60qZNG06cOEGlSpVudzFvq+DgYPbv309aWhq//PILAwYMYNOmTXe6WHeFa7VNjRo1Huh75syZM4waNYq1a9diY2Nzp4tzy2Qo+R7h4uJC1apVOX78OD4+PuTn55OammqRJjExER8fHwB8fHyumPFU8rokzf2gpC5Xq+vlbXH+/HmL84WFhSQnJz9w7VWxYkU8PDw4fvw4cP+3zciRI1mxYgUbNmygfPny2vHS+gxdK42Tk9Nd/z9w12qbMurCUgAAB+JJREFUq2ncuDGAxX1zv7aN0WikcuXK1K9fn0mTJhEaGsq0adPknuHabXM1D9I9s2fPHs6fP0+9evWwsrLCysqKTZs2MX36dKysrPD29r6n7h0JDO8RmZmZnDhxAl9fX+rXr4+1tTV//PGHdj4qKorTp09rz3s0bdqUQ4cOWXzpr127FicnJ63r/34QFBSEj4+PRVukp6ezY8cOi7ZITU1lz549Wpr169djNpu1P15NmzZl8+bNFBQUaGnWrl1LcHDwXT9UeiPi4uK4ePEivr6+wP3bNkopRo4cyZIlS1i/fv0VQ+Gl9Rlq2rSpRR4laS5/7upu819tczX79+8HsLhv7se2uRqz2UxeXt4Dfc9cS0nbXM2DdM+0adOGQ4cOsX//fu2nQYMG9O3bV/v9nrp3SnUqiyg1L730ktq4caOKiYlRW7duVW3btlUeHh7q/PnzSqniqe8VKlRQ69evV7t371ZNmzZVTZs21d5fMvW9ffv2av/+/Wr16tXK09PznlyuJiMjQ+3bt0/t27dPAWrKlClq37596tSpU0qp4uVqXFxc1LJly9TBgwfVI488ctXlaurWrat27NihtmzZoqpUqWKxJEtqaqry9vZW/fv3VxEREWrBggXKzs7url6SRal/b5uMjAz18ssvq+3bt6uYmBi1bt06Va9ePVWlShWVm5ur5XE/ts2wYcOUs7Oz2rhxo8XyGdnZ2Vqa0vgMlSwfMXbsWHXkyBH12Wef3fXLa/xX2xw/fly98847avfu3SomJkYtW7ZMVaxYUbVs2VLL435tm9dee01t2rRJxcTEqIMHD6rXXntN6XQ6tWbNGqXUg3vPKPXvbfMg3zPX8s9Z2vfSvSOB4V2qd+/eytfXVxmNRuXn56d69+6tjh8/rp3PyclRw4cPV66ursrOzk716NFDnTt3ziKP2NhY1alTJ2Vra6s8PDzUSy+9pAoKCm53VW7Zhg0bFHDFz4ABA5RSxUvWvPnmm8rb21uZTCbVpk0bFRUVZZHHxYsX1RNPPKEcHByUk5OTGjRokMrIyLBIc+DAAdW8eXNlMpmUn5+f+uCDD25XFW/av7VNdna2at++vfL09FTW1tYqICBAPfPMMxbLISh1f7bN1doEUHPmzNHSlNZnaMOGDapOnTrKaDSqihUrWlzjbvRfbXP69GnVsmVL5ebmpkwmk6pcubIaO3asxZp0St2fbTN48GAVEBCgjEaj8vT0VG3atNGCQqUe3HtGqX9vmwf5nrmWfwaG99K9o1NKqdLtgxRCCCGEEPciecZQCCGEEEIAEhgKIYQQQoi/SWAohBBCCCEACQyFEEIIIcTfJDAUQgghhBCABIZCCCGEEOJvEhgKIYQQQghAAkMhhBBCCPE3CQyFEEIIIQQggaEQQpSKgQMHotPp0Ol0WFtb4+3tTbt27fjmm28wm813unhCCHFdJDAUQohS0rFjR86dO0dsbCyrVq2idevWjBo1ii5dulBYWHiniyeEEP9JAkMhhCglJpMJHx8f/Pz8qFevHq+//jrLli1j1apVzJ07F4ApU6ZQq1Yt7O3t8ff3Z/jw4WRmZgKQlZWFk5MTv/zyi0W+S5cuxd7enoyMDPLz8xk5ciS+vr7Y2NgQEBDApEmTbndVhRD3KQkMhRCiDD300EOEhoayePFiAPR6PdOnT+fw4cPMmzeP9evX88orrwBgb29Pnz59mDNnjkUec+bM4dFHH8XR0ZHp06fz66+/8vPPPxMVFcUPP/xAYGDg7a6WEOI+ZXWnCyCEEPe7atWqcfDgQQBefPFF7XhgYCDvvfcezz33HDNnzgTg6aefJiwsjHPnzuHr68v58+dZuXIl69atA+D06dNUqVKF5s2bo9PpCAgIuO31EULcv6THUAghyphSCp1OB8C6deto06YNfn5+ODo60r9/fy5evEh2djYAjRo1IiQkhHnz5gHw/fffExAQQMuWLYHiSS779+8nODiYF154gTVr1tyZSgkh7ksSGAohRBk7cuQIQUFBxMbG0qVLF2rXrs2iRYvYs2cPn332GQD5+fla+qefflp7JnHOnDkMGjRICyzr1atHTEwM7777Ljk5OTz++OM8+uijt71OQoj7kwSGQghRhtavX8+hQ4fo1asXe/bswWw28/HHH9OkSROqVq1KfHz8Fe/p168fp06dYvr06URGRjJgwACL805OTvTu3ZuvvvqKn376iUWLFpGcnHy7qiSEuI/JM4ZCCFFK8vLySEhIoKioiMTERFavXs2kSZPo0qULTz31FBERERQUFDBjxgy6du3K1q1b+fzzz6/Ix9XVlZ49ezJ27Fjat29P+fLltXNTpkzB19eXunXrotfrWbhwIT4+Pri4uNzGmgoh7lfSYyiEEKVk9erV+Pr6EhgYSMeOHdmwYQPTp09n2bJlGAwGQkNDmTJlCpMnT6ZmzZr88MMP11xqZsiQIeTn5zN48GCL446Ojnz44Yc0aNCAhg0bEhsby8qVK9Hr5c+5+P/27NiGQSAIoug4oQZKoDNiQjo4XRv0Bh2QHsklji0ZJN6rYMKvXfjdp7XW7h4BwLdt27IsS/Z9zzAMd88BXsIrGeBBzvPMcRwppWSeZ1EI/JXfA8CD1FozTVPGccy6rnfPAV7GKxkAgCQuhgAAdMIQAIAkwhAAgE4YAgCQRBgCANAJQwAAkghDAAA6YQgAQJLkApRMDdIIi1NNAAAAAElFTkSuQmCC", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "WOPR PRO2\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "WOPR PRO3\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "WWPR PRO1\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "WWPR PRO2\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "WWPR PRO3\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "WWIR INJ1\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "WWIR INJ2\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "WWIR INJ3\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "plot_prod()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Setting up the .mako file\n", - "The data assimilation relies on a .mako file for writing the current state variables to the flow simulator input. In this case, the flow simulator is opm-flow [opm-projects.org](opm-projects.org), and the input file is provided as a text file (.DATA file). The .mako file is created by replacing the keywords PERMX in the .DATA file with: \n", - " \n", - " PERMX\n", - " % for i in range(0, len(permx)):\n", - " % if permx[i] < 6:\n", - " ${\"%.3f\" %(np.exp(permx[i]))}\n", - " % else:\n", - " ${\"%.3f\" %(np.exp(6))}\n", - " % endif\n", - " % endfor\n", - " /" - ] - }, - { - "attachments": { - "jupyter_kernel.png": { - "image/png": "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" - } - }, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Running locally\n", - "\n", - "It is recommended to run the notebook from a virtual environment. Follow these steps to run this notebook on your own computer: \n", - " \n", - "*Step 1: Create virtual environment as normal*\n", - "\n", - " python3 -m venv pet_venv\n", - "\n", - "Then activate the environment using:\n", - "\n", - " source pet_venv/bin/activate\n", - "\n", - "*Step 2: Install Jupyter Notebook into virtual environment*\n", - "\n", - " python3 -m pip install ipykernel\n", - "\n", - "*Step 3: Install PET in the virtual environment, see [PET installation](https://github.com/Python-Ensemble-Toolbox/PET)*\n", - " \n", - "*Step 4: Install Plotting in the virtual environment, see [Plotting installation](https://github.com/Python-Ensemble-Toolbox/Plotting)*\n", - "\n", - "*Step 5: Allow Jupyter access to the kernel within the virtual environment*\n", - "\n", - " python3 -m ipykernel install --user --name=pet_venv\n", - "\n", - "Start jupyter notebook, and load tutorial_popt.ipynb (this file). On the jupyter notebook toolbar, select ‘Kernel’ and ‘Change Kernel’. The new kernel is now be available in the list for selection:\n", - " \n", - "![jupyter_kernel.png](attachment:jupyter_kernel.png)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "pet_ecalc_venv", - "language": "python", - "name": "pet_ecalc_venv" - }, - "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.8.10" - } - }, - "nbformat": 4, - "nbformat_minor": 4 -} diff --git a/docs/tutorials/pipt/var.csv b/docs/tutorials/pipt/var.csv deleted file mode 100644 index 5e3d97c4..00000000 --- a/docs/tutorials/pipt/var.csv +++ /dev/null @@ -1,10 +0,0 @@ -ABS,64,ABS,64,ABS,64,ABS,64,ABS,64,ABS,64,ABS,64,ABS,64,ABS,64 -ABS,64,ABS,64,ABS,64,ABS,64,ABS,64,ABS,64,ABS,64,ABS,64,ABS,64 -ABS,64,ABS,64,ABS,64,ABS,64,ABS,64,ABS,64,ABS,64,ABS,64,ABS,64 -ABS,64,ABS,64,ABS,64,ABS,64,ABS,64,ABS,64,ABS,64,ABS,64,ABS,64 -ABS,64,ABS,64,ABS,64,ABS,64,ABS,64,ABS,64,ABS,64,ABS,64,ABS,64 -ABS,64,ABS,64,ABS,64,ABS,64,ABS,64,ABS,64,ABS,64,ABS,64,ABS,64 -ABS,64,ABS,64,ABS,64,ABS,64,ABS,64,ABS,64,ABS,64,ABS,64,ABS,64 -ABS,64,ABS,64,ABS,64,ABS,64,ABS,64,ABS,64,ABS,64,ABS,64,ABS,64 -ABS,64,ABS,64,ABS,64,ABS,64,ABS,64,ABS,64,ABS,64,ABS,64,ABS,64 -ABS,64,ABS,64,ABS,64,ABS,64,ABS,64,ABS,64,ABS,64,ABS,64,ABS,64 diff --git a/docs/tutorials/popt/3WELL.mako b/docs/tutorials/popt/3WELL.mako deleted file mode 100644 index bc590e96..00000000 --- a/docs/tutorials/popt/3WELL.mako +++ /dev/null @@ -1,249 +0,0 @@ -<%! -import numpy as np -import datetime as dt -%> --- *------------------------------------------* --- * * --- * base grid model with input parameters * --- * * --- *------------------------------------------* -RUNSPEC - -TITLE - 3 WELL MODEL - -DIMENS --- NDIVIX NDIVIY NDIVIZ - 100 100 1 / - --- Gradient option --- AJGRADNT - --- Gradients readeable --- UNCODHMD - ---BLACKOIL -OIL -WATER - -METRIC - -TABDIMS --- NTSFUN NTPVT NSSFUN NPPVT NTFIP NRPVT NTENDP - 1 1 35 30 5 30 1 / - -EQLDIMS --- NTEQUL NDRXVD NDPRVD - 1 5 100 / - -WELLDIMS --- NWMAXZ NCWMAX NGMAXZ MWGMAX - 10 1 2 20 / - -VFPPDIMS --- MXMFLO MXMTHP MXMWFR MXMGFR MXMALQ NMMVFT - 10 10 10 10 1 1 / - -VFPIDIMS --- MXSFLO MXSTHP NMSVFT - 10 10 1 / - -AQUDIMS --- MXNAQN MXNAQC NIFTBL NRIFTB NANAQU NCAMAX - 0 0 1 36 2 200/ - -START - 09 FEB 1994 / - -NSTACK - 25 / - -NOECHO - -GRID -INIT - -INCLUDE -'../TRUEPERMX.INC' -/ - - -COPY - 'PERMX' 'PERMY' / - 'PERMX' 'PERMZ' / -/ - -DX - 10000*10 / -DY - 10000*10 / -DZ - 10000*10 / - -TOPS - 10000*2355 / - -PORO - 10000*0.18 / - - -PROPS =============================================================== - --- Two-phase (water-oil) rel perm curves --- Sw Krw Kro Pcow -SWOF - 0.1500 0.0 1.0000 0.0 - 0.2000 0.0059 0.8521 0.0 - 0.2500 0.0237 0.7160 0.0 - 0.3000 0.0533 0.5917 0.0 - 0.3500 0.0947 0.4793 0.0 - 0.4000 0.1479 0.3787 0.0 - 0.4500 0.2130 0.2899 0.0 - 0.5000 0.2899 0.2130 0.0 - 0.5500 0.3787 0.1479 0.0 - 0.6000 0.4793 0.0947 0.0 - 0.6500 0.5917 0.0533 0.0 - 0.7000 0.7160 0.0237 0.0 - 0.7500 0.8521 0.0059 0.0 - 0.8000 1.0000 0.0 0.0 -/ - ---PVCDO --- REF.PRES. FVF COMPRESSIBILITY REF.VISC. VISCOSIBILITY --- 234 1.065 6.65e-5 5.0 1.9e-3 / - --- In a e300 run we must use PVDO -PVDO - 220 1.065 5.0 - 240 1.06499 5.0 / - -DENSITY -912.0 1000.0 0.8266 -/ - -PVTW -234.46 1.0042 5.43E-05 0.5 1.11E-04 / - - --- ROCK COMPRESSIBILITY --- --- REF. PRES COMPRESSIBILITY -ROCK - 235 0.00045 / - - - -REGIONS =============================================================== - -ENDBOX - -SOLUTION =============================================================== - - --- DATUM DATUM OWC OWC GOC GOC RSVD RVVD SOLN --- DEPTH PRESS DEPTH PCOW DEPTH PCOG TABLE TABLE METH -EQUIL - 2355.00 200.46 3000 0.00 2355.0 0.000 0 0 / - - -RPTSOL -'PRES' 'SWAT' / - -RPTRST - BASIC=2 / - - - -SUMMARY ================================================================ - -RUNSUM - -EXCEL - ---RPTONLY -FOPT -FGPT -FWPT -FWIT - -WWIR - 'INJ-1' -/ - -WOPR - 'PRO-1' -/ - -WWPR - 'PRO-1' -/ - -SCHEDULE ============================================================= - - -RPTSCHED - 'NEWTON=2' / - -RPTRST - BASIC=2 / - --- AJGWELLS --- 'INJ-1' 'WWIR' / --- 'PRO-1' 'WLPR' / ---/ - --- AJGPARAM --- 'PERMX' 'PORO' / - -------------------- WELL SPECIFICATION DATA -------------------------- -WELSPECS -'INJ-1' 'G' 1 1 2357 WATER 1* 'STD' 3* / -'INJ-2' 'G' 100 1 2357 WATER 1* 'STD' 3* / -'PRO-1' 'G' 100 100 2357 OIL 1* 'STD' 3* / -/ -COMPDAT --- RADIUS SKIN -'INJ-1' 1 1 1 1 'OPEN' 2* 0.15 1* 5.0 / -'INJ-2' 100 1 1 1 'OPEN' 2* 0.15 1* 5.0 / -'PRO-1' 100 100 1 1 'OPEN' 2* 0.15 1* 5.0 / -/ - -WCONINJE ---'INJ-1' WATER 'OPEN' BHP 2* 300 / ---'INJ-1' WATER 'OPEN' BHP 2* 250 / -'INJ-1' WATER 'OPEN' BHP 2* ${injbhp[0]} / -'INJ-2' WATER 'OPEN' BHP 2* ${injbhp[1]} / -/ - -WCONPROD - --'PRO-1' 'OPEN' BHP 5* 100 / - 'PRO-1' 'OPEN' BHP 5* ${prodbhp[0]} / -/ - - ---------------------- PRODUCTION SCHEDULE ---------------------------- - - - -DATES - 1 JAN 1995 / - / - -DATES -- Generated : Petrel - 1 JAN 1996 / - / - -DATES -- Generated : Petrel - 1 JAN 1997 / - / - -DATES -- Generated : Petrel - 1 JAN 1998 / - / - -DATES -- Generated : Petrel - 1 JAN 1999 / - / - - - diff --git a/docs/tutorials/popt/5Spot/5SPOT.mako b/docs/tutorials/popt/5Spot/5SPOT.mako new file mode 100644 index 00000000..38ccbac4 --- /dev/null +++ b/docs/tutorials/popt/5Spot/5SPOT.mako @@ -0,0 +1,283 @@ + +------------------------------------------------------------------------------- +-- DATAFILE FOR ECLIPSE TESTING +------------------------------------------------------------------------------- + + +---------------------------- Runspec Section ---------------------------------- +--NOECHO + +RUNSPEC + +TITLE + 50x50x1=2,500 Eclipse test example + +DIMENS + 50 50 1 / + +-- Phases present + +OIL + +WATER + +GAS + +DISGAS + +-- Units + +METRIC + +-- Table dimension + +TABDIMS + +-- NoSatTabl MaxNodesSatTab MaxFIPReg MaxSatEndpointsDepthTab +-- NoPVTTab MaxPressNodes MaxRsRvNodes + 1 1 20 200 1 200 1 / + + +-- Well dimension + +WELLDIMS +-- MaxNo MaxPerf MaxGroup MaxWell/Group + 5 1 5 5 / + + +START + 1 'JAN' 2000 / + + +--FMTOUT + +--UNIFIN +--UNIFOUT + +--NOSIM + +NSTACK + 10 / + +------------------------------- Grid Section ---------------------------------- + +GRID + +-- Including the indiviual grid file + +INCLUDE + '../include/50X50X1.COORD' / + +INCLUDE + '../include/50X50X1.ZCORN' / + +--INCLUDE +-- 'TRUE_PORO' / + +PORO +2500*0.2 +/ + +INCLUDE + '../include/PERMX' / + +--PERMX +--2500*500 +--/ + +COPY + PERMX PERMY / + PERMX PERMZ / +/ + +MULTIPLY + PERMZ 0.001 / +/ + +--GRIDFILE +-- 2 1 / + +--NOGGF + +INIT + +NEWTRAN + + +------------------------------- Edit Section ---------------------------------- + + +------------------------------ Properties Section ----------------------------- + + +PROPS + +ROCK +-- RefPressure Compressibility +-- for PoreVol Calc +--BARSA 1/BARSA + 300 1.450E-05 / + +INCLUDE + '../include/ALL.PVO' / + +INCLUDE + '../include/ALL.RCP' / + + + +------------------------------- Regions Section ------------------------------- + + +------------------------------ Solution Section ------------------------------- + +SOLUTION + +EQUIL +2000.000 200.00 2280.00 .000 2000.000 .000 1 0 0 / + +PBVD + 1 10 + 1000 10 / + +--RPTSOL +-- RESTART / + +--RPTRST +-- BASIC=2 / + + +------------------------------- Summary Section ------------------------------- + +SUMMARY + +------------------------------------------------ +--Output of production data/pressure for FIELD: +------------------------------------------------ + +FOPR +FWPR +FLPR +FLPT +FOPT +FGPT +FWPT +FPR +FWIT + +------------------------------------------------- +-- Gas and oil in place: +------------------------------------------------- + +FOIP +FGIP + +----------------------------------------- +--Output of production data for all wells: +----------------------------------------- +WOPR +WWPR +WGPR +WWCT +WGOR +WTHP +/ +WWIR + 'INJ1' + 'INJ2' + 'INJ3' + 'INJ4' +/ +WBHP + 'INJ1' + 'INJ2' + 'INJ3' + 'INJ4' +/ +WPI + 'INJ1' + 'INJ2' + 'INJ3' + 'INJ4' +/ + + +FVIR +FVPR +RPTONLY + +RUNSUM + +SEPARATE + +RPTSMRY + 1 / + +DATE + + +TCPU + +------------------------------ Schedule Section ------------------------------- + +SCHEDULE + +SKIPREST + +RPTRST + BASIC=5 DEN/ + +WELSPECS + INJ1 G1 2 2 2000 WATER / + INJ2 G1 49 2 2000 WATER / + INJ3 G1 2 49 2000 WATER / + INJ4 G1 49 49 2000 WATER / + PROD G1 25 25 2000 WATER / +/ + +COMPDAT +--Name I J K1 K2 STATUS 2* RW + INJ1 2 2 1 1 OPEN 2* 0.25 / + INJ2 49 2 1 1 OPEN 2* 0.25 / + INJ3 2 49 1 1 OPEN 2* 0.25 / + INJ4 49 49 1 1 OPEN 2* 0.25 / + PROD 25 25 1 1 OPEN 2* 0.25 / +/ + +--WPIMULT +-- INJ1 0.025 1* 1* 1* 1* 1* / +-- INJ3 0.025 1* 1* 1* 1* 1*/ +--/ + + +WCONPROD +PROD OPEN BHP 5* 150 / +/ + +<% +import pandas as pd +years = pd.date_range('2000-01-01', '2008-01-01', freq='YS').to_pydatetime() +report = pd.date_range('2000-01-01', '2008-01-01', freq='MS').to_pydatetime() +index = 0 +%> + +%for date in report[:-1]: + +%if date in years: +${'WCONINJE'} +${f'INJ1 WATER OPEN RATE {rate_inj1[index]} 1* 500.0 /'} +${f'INJ2 WATER OPEN RATE {rate_inj2[index]} 1* 500.0 /'} +${f'INJ3 WATER OPEN RATE {rate_inj3[index]} 1* 500.0 /'} +${f'INJ4 WATER OPEN RATE {rate_inj4[index]} 1* 500.0 /'} +${'/'} +<% index = index + 1 %> +%endif + +${'TSTEP'} +${f'{pd.Period(str(date)).days_in_month} /'} + +%endfor + +END + + diff --git a/docs/tutorials/popt/5Spot/build_tutorial.py b/docs/tutorials/popt/5Spot/build_tutorial.py new file mode 100644 index 00000000..1e227a4a --- /dev/null +++ b/docs/tutorials/popt/5Spot/build_tutorial.py @@ -0,0 +1,348 @@ +"""Generate docs/tutorials/popt/5Spot/tutorial_popt.ipynb. + +Written as a generator rather than by hand-editing JSON so the cell sources stay +readable and reviewable in one place. +""" + +import json +from pathlib import Path + +OUT = Path("docs/tutorials/popt/5Spot/tutorial_popt.ipynb") + + +def md(source): + return {"cell_type": "markdown", "metadata": {}, "source": source.splitlines(keepends=True)} + + +def code(source): + return { + "cell_type": "code", + "execution_count": None, + "metadata": {}, + "outputs": [], + "source": source.splitlines(keepends=True), + } + + +cells = [] + +# ---------------------------------------------------------------------- +cells.append(md("""\ +# Tutorial for running the Python Optimization Toolbox (POPT) + +As an illustrative example we choose a 2D five-spot pattern: one producer at the centre of the field and four (water) injectors, one at each corner. The figure below shows the permeability field and the well positions. The grid is 50x50, and the porosity is 0.2. The optimization problem is to find the water injection rate for each injector, one value per year of the eight-year production period, that maximizes the net present value (NPV). + +drawing +
+POPT mirrors PIPT: an *ensemble* object owns the control perturbations and the gradient estimate, and an *optimizer* owns its own iteration loop. The first step is to load the necessary external and local modules. +""")) + +cells.append(code("""\ +# Import global modules +import os +import shutil +from glob import glob +import numpy as np +import pandas as pd +import matplotlib.pyplot as plt + +# Import local modules +from input_output import read_config # the config reader +from popt.ensembles import GaussianEnsemble # control perturbations and gradients +from popt.optimization_methods import LineSearch # the optimizer; it owns its own loop +from subsurface.multphaseflow.opm import flow # the simulator we want to use +""")) + +# ---------------------------------------------------------------------- +cells.append(md("""\ +Set the random seed: +""")) + +cells.append(code("""\ +np.random.seed(10_08_1997) +""")) + +# ---------------------------------------------------------------------- +cells.append(md("""\ +Each simulator call runs in its own En_<member> folder, which it creates with os.mkdir — so a folder left behind by an interrupted run makes the next one fail with FileExistsError. PET clears them when an ensemble is constructed, but not between runs, so we define a helper and call it before each optimization. That keeps the run cells safe to re-execute on their own. +""")) + +cells.append(code("""\ +def clean_run_folders(*result_folders): + \"\"\"Remove simulator scratch folders, and any results being replaced.\"\"\" + for folder in glob('En_*'): + shutil.rmtree(folder, ignore_errors=True) + for folder in result_folders: + shutil.rmtree(folder, ignore_errors=True) +""")) + +# ---------------------------------------------------------------------- +cells.append(md("""\ +Read the input file. In this tutorial the input file is written as a .toml file, and consists of three main keys: ensemble, optim and simulator. The first contains keys related to the ensemble of control perturbations, the second the options for the optimization algorithm, and the third the options for the forward simulation model. + +The ensemble.controls table lists the control variables directly: each entry names one .mako placeholder, together with its mean, standard deviation and bounds. This is a simpler alternative to PIPT's prior_<name> tables — there is no need for a separate state list, since the keys of controls already give the names. +""")) + +cells.append(code("""\ +!cat init_optim.toml +ko, kf, ke = read_config.read('init_optim.toml') +# ko --> Optimization settings +# kf --> Simulator settings +# ke --> Ensemble settings +""")) + +# ---------------------------------------------------------------------- +cells.append(md("""\ +Set the initial controls. The filename given as mean in the input file above must exist before the ensemble is built, and its arrays must match the .mako placeholders rate_inj1–rate_inj4. Each array holds one rate per year of the eight-year schedule, so all four injectors start at a flat 200 Sm3/day. +""")) + +cells.append(code("""\ +rate = 8 * [200] +np.savez( + 'initrates.npz', + rate_inj1=rate, + rate_inj2=rate, + rate_inj3=rate, + rate_inj4=rate, +) +""")) + +# ---------------------------------------------------------------------- +cells.append(md("""\ +Define the objective function. This is the one piece POPT does not supply: you hand it any callable that takes the simulated data and returns a scalar to be **minimized**. Here it is the discounted net present value, with the economic constants read from the npv_const block of the input file. + +Note the obj_scaling of -1e9: the negative sign turns maximizing NPV into a minimization, and the 1e9 puts the value in billions so the optimizer works on a sensible scale. +""")) + +cells.append(code("""\ +DEFAULT_ECON = { + 'wop': 400.0, # Oil price: $/Sm3 + 'wgp': 0.4, # Gas price: $/Sm3 + 'wwp': 20.0, # Cost of water production per unit volume + 'wwi': 10.0, # Cost of water injection per unit volume + 'disc': 0.08, # Discount rate per year +} + + +def npv(pred_data: pd.DataFrame, **kwargs): + \"\"\"Discounted net present value of one simulated production profile.\"\"\" + # Economic parameters, from the config's npv_const block if present + input_dict = kwargs.get('input_dict', {}) + econ = dict(input_dict.get('npv_const', DEFAULT_ECON)) + scaling_factor = econ.pop('obj_scaling', 1.0) + + # Incremental volumes per report step + vol_oil = pred_data['FOPT'].diff() + vol_gas = pred_data['FGPT'].diff() + vol_water_prod = pred_data['FWPT'].diff() + vol_water_inj = pred_data['FWIT'].diff() + + # Time in years since the start of the run + time_index = pred_data.index.to_numpy() + years = (time_index - time_index[0]) / np.timedelta64(365, 'D') + + # Revenue, cost, and discounting + revenue = vol_oil * econ['wop'] + vol_gas * econ['wgp'] + operating_cost = vol_water_prod * econ['wwp'] + vol_water_inj * econ['wwi'] + discount_factor = (1.0 + econ['disc']) ** years + + return ((revenue - operating_cost) / discount_factor).sum() / scaling_factor +""")) + +# ---------------------------------------------------------------------- +cells.append(md("""\ +Initialize the ensemble with the ensemble keys, the simulator and the objective function, then extract the initial control vector (x0), its covariance (cov) and the bounds. The ensemble is what turns a non-differentiable simulator into something gradient-based methods can use: it perturbs the controls, runs the simulator on each perturbation, and forms an ensemble approximation of the gradient. +""")) + +cells.append(code("""\ +sim = flow(kf) +ensemble = GaussianEnsemble(ke, sim, npv) + +x0 = ensemble.get_state() +cov = ensemble.get_cov() +bounds = ensemble.get_bounds() + +print(f'controls: {x0}') +print(f'bounds: {bounds[0]} ... (x{len(bounds)})') +""")) + +# ---------------------------------------------------------------------- +cells.append(md("""\ +Run the optimization with LineSearch, using BFGS as the search direction. During the run, useful information is written to the screen and to a log file. As in PIPT, there are two ways to do this — the class-level shortcut that constructs and runs in one call, or an instance you keep and drive yourself. + +The other supported method values are 'GD' (steepest descent, needs only the gradient) and 'Newton-CG' (needs a Hessian as well, passed as hess=ensemble.hessian). BFGS builds a curvature estimate from successive gradients, so it needs no Hessian. +""")) + +cells.append(code("""\ +clean_run_folders(ko.get('savefolder', 'Results')) + +# There are two ways to run the optimization: + +# Option 1: the class-level shortcut, when the optimizer object is not needed afterwards +res_bfgs = LineSearch.minimize( + x0=x0, + fun=ensemble.function, + method='BFGS', + jac=ensemble.gradient, + args=(cov,), + bounds=bounds, + **ko, +) + +# Option 2: keep the optimizer, then run it +# ls = LineSearch(x0=x0, fun=ensemble.function, method='BFGS', jac=ensemble.gradient, +# args=(cov,), bounds=bounds, **ko) +# res_bfgs = ls.run_optimization() + +print(f'NPV: {-res_bfgs.fun:.4f} billion $ after {res_bfgs.nit} iterations') +print(res_bfgs) +""")) + +# ---------------------------------------------------------------------- +cells.append(md("""\ +Plot the objective function against iteration. The optimizer writes one file per iteration, optimize_result_{i}.npz, into the folder named by the savefolder key — the counterpart of PIPT's assimilation_result_{i}.npz. Saving happens only when saveit is true. +""")) + +cells.append(code("""\ +def read_npv_history(folder): + \"\"\"Collect the NPV, in million $, at each iteration from the saved result files.\"\"\" + values = [] + it = 0 + while True: + file = f'{folder}/optimize_result_{it}.npz' + if not os.path.exists(file): + break + info = np.load(file) + # 'fun' is the objective value at that iteration, in billion $ with a flipped sign + # (obj_scaling = -1e9). Undo both to get NPV in million $. + values.append(-1000.0 * float(np.mean(info['fun']))) + it += 1 + return values + + +npv_bfgs = read_npv_history(ko.get('savefolder', 'Results')) + +plt.style.use('seaborn-v0_8-whitegrid') +fig, ax = plt.subplots(figsize=(9.2, 5.2), facecolor='white') +ax.plot(npv_bfgs, 's-', color='#4C78A8', linewidth=2, markersize=7, label='BFGS') +ax.set_xlabel('Iteration no.', size=13) +ax.set_ylabel('NPV [million $]', size=13) +ax.set_title('Objective function', size=14) +ax.set_xticks(range(len(npv_bfgs))) +ax.legend(fontsize=12) +fig.tight_layout() +plt.show() +""")) + +# ---------------------------------------------------------------------- +cells.append(md("""\ +The same problem with a different search direction. method='GD' takes a plain steepest-descent step instead of the BFGS quasi-Newton direction — simpler, and it does not accumulate curvature information across iterations, so its step sizes are driven entirely by step_size_adapt rather than an approximated Hessian. Everything else — the ensemble, the objective, the bounds — is reused unchanged, which is the point of keeping the optimizer separate from the ensemble. + +Both runs start from the same x0 captured above, so the comparison is fair. Note that ensemble.get_state() would not do here: it returns the ensemble's current controls, which the first optimization has already moved. +""")) + +cells.append(code("""\ +from copy import deepcopy + +ko_gd = deepcopy(ko) +ko_gd['savefolder'] = 'Results_gd' # keep the BFGS files for the comparison below + +clean_run_folders(ko_gd['savefolder']) + +res_gd = LineSearch.minimize( + x0=x0, + fun=ensemble.function, + method='GD', + jac=ensemble.gradient, + args=(cov,), + bounds=bounds, + **ko_gd, +) + +print(f'NPV: {-res_gd.fun:.4f} billion $ after {res_gd.nit} iterations') +""")) + +# ---------------------------------------------------------------------- +cells.append(md("""\ +Compare the two: +""")) + +cells.append(code("""\ +npv_gd = read_npv_history(ko_gd['savefolder']) + +fig, ax = plt.subplots(figsize=(9.2, 5.2), facecolor='white') +ax.plot(npv_bfgs, 's-', color='#4C78A8', linewidth=2, markersize=7, label='BFGS') +ax.plot(npv_gd, 'o--', color='#E45756', linewidth=2, markersize=7, label='GD') +ax.set_xlabel('Iteration no.', size=13) +ax.set_ylabel('NPV [million $]', size=13) +ax.set_title('BFGS vs. GD', size=14) +ax.legend(fontsize=12) +fig.tight_layout() +plt.show() +""")) + +# ---------------------------------------------------------------------- +cells.append(md("""\ +## Setting up the .mako file +The optimization relies on a .mako file for writing the current control variables to the flow simulator input. In this case, the flow simulator is opm-flow [opm-projects.org](opm-projects.org), and the input file is provided as a text file (.DATA file). Once a year, the .mako file writes a WCONINJE block that sets that year's rate for each injector: + + WCONINJE + INJ1 WATER OPEN RATE ${rate_inj1[index]} 1* 500.0 / + INJ2 WATER OPEN RATE ${rate_inj2[index]} 1* 500.0 / + INJ3 WATER OPEN RATE ${rate_inj3[index]} 1* 500.0 / + INJ4 WATER OPEN RATE ${rate_inj4[index]} 1* 500.0 / + / + +The names rate_inj1–rate_inj4 are the keys of the ensemble.controls table in the input file, so the .mako placeholders and the config have to agree. The producer's bottom-hole pressure is fixed for the whole run and is not a control. +""")) + +# ---------------------------------------------------------------------- +cells.append(md("""\ +## Running locally + +It is recommended to run the notebook from a virtual environment. Follow these steps to run this notebook on your own computer: + +*Step 1: Create virtual environment as normal* + + python3 -m venv pet_venv + +Then activate the environment using: + + source pet_venv/bin/activate + +*Step 2: Install Jupyter Notebook into virtual environment* + + python3 -m pip install ipykernel + +*Step 3: Install PET in the virtual environment, see [PET installation](https://github.com/Python-Ensemble-Toolbox/PET)* + +*Step 4: Allow Jupyter access to the kernel within the virtual environment* + + python3 -m ipykernel install --user --name=pet_venv + +Start jupyter notebook, and load tutorial_popt.ipynb (this file). On the jupyter notebook toolbar, select 'Kernel' and 'Change Kernel'. +""")) + +notebook = { + "cells": cells, + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3", + }, + "language_info": { + "codemirror_mode": {"name": "ipython", "version": 3}, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + }, + }, + "nbformat": 4, + "nbformat_minor": 4, +} + +OUT.write_text(json.dumps(notebook, indent=1) + "\n") +print(f"wrote {OUT} with {len(cells)} cells") diff --git a/docs/tutorials/popt/5Spot/include/50X50X1.COORD b/docs/tutorials/popt/5Spot/include/50X50X1.COORD new file mode 100644 index 00000000..52b465d4 --- /dev/null +++ b/docs/tutorials/popt/5Spot/include/50X50X1.COORD @@ -0,0 +1,2604 @@ +COORD + 0.000 -0.000 2000.000 0.000 -0.000 2001.000 + 100.000 -0.000 2000.000 100.000 -0.000 2001.000 + 200.000 -0.000 2000.000 200.000 -0.000 2001.000 + 300.000 -0.000 2000.000 300.000 -0.000 2001.000 + 400.000 -0.000 2000.000 400.000 -0.000 2001.000 + 500.000 -0.000 2000.000 500.000 -0.000 2001.000 + 600.000 -0.000 2000.000 600.000 -0.000 2001.000 + 700.000 -0.000 2000.000 700.000 -0.000 2001.000 + 800.000 -0.000 2000.000 800.000 -0.000 2001.000 + 900.000 -0.000 2000.000 900.000 -0.000 2001.000 + 1000.000 -0.000 2000.000 1000.000 -0.000 2001.000 + 1100.000 -0.000 2000.000 1100.000 -0.000 2001.000 + 1200.000 -0.000 2000.000 1200.000 -0.000 2001.000 + 1300.000 -0.000 2000.000 1300.000 -0.000 2001.000 + 1400.000 -0.000 2000.000 1400.000 -0.000 2001.000 + 1500.000 -0.000 2000.000 1500.000 -0.000 2001.000 + 1600.000 -0.000 2000.000 1600.000 -0.000 2001.000 + 1700.000 -0.000 2000.000 1700.000 -0.000 2001.000 + 1800.000 -0.000 2000.000 1800.000 -0.000 2001.000 + 1900.000 -0.000 2000.000 1900.000 -0.000 2001.000 + 2000.000 -0.000 2000.000 2000.000 -0.000 2001.000 + 2100.000 -0.000 2000.000 2100.000 -0.000 2001.000 + 2200.000 -0.000 2000.000 2200.000 -0.000 2001.000 + 2300.000 -0.000 2000.000 2300.000 -0.000 2001.000 + 2400.000 -0.000 2000.000 2400.000 -0.000 2001.000 + 2500.000 -0.000 2000.000 2500.000 -0.000 2001.000 + 2600.000 -0.000 2000.000 2600.000 -0.000 2001.000 + 2700.000 -0.000 2000.000 2700.000 -0.000 2001.000 + 2800.000 -0.000 2000.000 2800.000 -0.000 2001.000 + 2900.000 -0.000 2000.000 2900.000 -0.000 2001.000 + 3000.000 -0.000 2000.000 3000.000 -0.000 2001.000 + 3100.000 -0.000 2000.000 3100.000 -0.000 2001.000 + 3200.000 -0.000 2000.000 3200.000 -0.000 2001.000 + 3300.000 -0.000 2000.000 3300.000 -0.000 2001.000 + 3400.000 -0.000 2000.000 3400.000 -0.000 2001.000 + 3500.000 -0.000 2000.000 3500.000 -0.000 2001.000 + 3600.000 -0.000 2000.000 3600.000 -0.000 2001.000 + 3700.000 -0.000 2000.000 3700.000 -0.000 2001.000 + 3800.000 -0.000 2000.000 3800.000 -0.000 2001.000 + 3900.000 -0.000 2000.000 3900.000 -0.000 2001.000 + 4000.000 -0.000 2000.000 4000.000 -0.000 2001.000 + 4100.000 -0.000 2000.000 4100.000 -0.000 2001.000 + 4200.000 -0.000 2000.000 4200.000 -0.000 2001.000 + 4300.000 -0.000 2000.000 4300.000 -0.000 2001.000 + 4400.000 -0.000 2000.000 4400.000 -0.000 2001.000 + 4500.000 -0.000 2000.000 4500.000 -0.000 2001.000 + 4600.000 -0.000 2000.000 4600.000 -0.000 2001.000 + 4700.000 -0.000 2000.000 4700.000 -0.000 2001.000 + 4800.000 -0.000 2000.000 4800.000 -0.000 2001.000 + 4900.000 -0.000 2000.000 4900.000 -0.000 2001.000 + 5000.000 -0.000 2000.000 5000.000 -0.000 2001.000 + 0.000 100.000 2000.000 0.000 100.000 2001.000 + 100.000 100.000 2000.000 100.000 100.000 2001.000 + 200.000 100.000 2000.000 200.000 100.000 2001.000 + 300.000 100.000 2000.000 300.000 100.000 2001.000 + 400.000 100.000 2000.000 400.000 100.000 2001.000 + 500.000 100.000 2000.000 500.000 100.000 2001.000 + 600.000 100.000 2000.000 600.000 100.000 2001.000 + 700.000 100.000 2000.000 700.000 100.000 2001.000 + 800.000 100.000 2000.000 800.000 100.000 2001.000 + 900.000 100.000 2000.000 900.000 100.000 2001.000 + 1000.000 100.000 2000.000 1000.000 100.000 2001.000 + 1100.000 100.000 2000.000 1100.000 100.000 2001.000 + 1200.000 100.000 2000.000 1200.000 100.000 2001.000 + 1300.000 100.000 2000.000 1300.000 100.000 2001.000 + 1400.000 100.000 2000.000 1400.000 100.000 2001.000 + 1500.000 100.000 2000.000 1500.000 100.000 2001.000 + 1600.000 100.000 2000.000 1600.000 100.000 2001.000 + 1700.000 100.000 2000.000 1700.000 100.000 2001.000 + 1800.000 100.000 2000.000 1800.000 100.000 2001.000 + 1900.000 100.000 2000.000 1900.000 100.000 2001.000 + 2000.000 100.000 2000.000 2000.000 100.000 2001.000 + 2100.000 100.000 2000.000 2100.000 100.000 2001.000 + 2200.000 100.000 2000.000 2200.000 100.000 2001.000 + 2300.000 100.000 2000.000 2300.000 100.000 2001.000 + 2400.000 100.000 2000.000 2400.000 100.000 2001.000 + 2500.000 100.000 2000.000 2500.000 100.000 2001.000 + 2600.000 100.000 2000.000 2600.000 100.000 2001.000 + 2700.000 100.000 2000.000 2700.000 100.000 2001.000 + 2800.000 100.000 2000.000 2800.000 100.000 2001.000 + 2900.000 100.000 2000.000 2900.000 100.000 2001.000 + 3000.000 100.000 2000.000 3000.000 100.000 2001.000 + 3100.000 100.000 2000.000 3100.000 100.000 2001.000 + 3200.000 100.000 2000.000 3200.000 100.000 2001.000 + 3300.000 100.000 2000.000 3300.000 100.000 2001.000 + 3400.000 100.000 2000.000 3400.000 100.000 2001.000 + 3500.000 100.000 2000.000 3500.000 100.000 2001.000 + 3600.000 100.000 2000.000 3600.000 100.000 2001.000 + 3700.000 100.000 2000.000 3700.000 100.000 2001.000 + 3800.000 100.000 2000.000 3800.000 100.000 2001.000 + 3900.000 100.000 2000.000 3900.000 100.000 2001.000 + 4000.000 100.000 2000.000 4000.000 100.000 2001.000 + 4100.000 100.000 2000.000 4100.000 100.000 2001.000 + 4200.000 100.000 2000.000 4200.000 100.000 2001.000 + 4300.000 100.000 2000.000 4300.000 100.000 2001.000 + 4400.000 100.000 2000.000 4400.000 100.000 2001.000 + 4500.000 100.000 2000.000 4500.000 100.000 2001.000 + 4600.000 100.000 2000.000 4600.000 100.000 2001.000 + 4700.000 100.000 2000.000 4700.000 100.000 2001.000 + 4800.000 100.000 2000.000 4800.000 100.000 2001.000 + 4900.000 100.000 2000.000 4900.000 100.000 2001.000 + 5000.000 100.000 2000.000 5000.000 100.000 2001.000 + 0.000 200.000 2000.000 0.000 200.000 2001.000 + 100.000 200.000 2000.000 100.000 200.000 2001.000 + 200.000 200.000 2000.000 200.000 200.000 2001.000 + 300.000 200.000 2000.000 300.000 200.000 2001.000 + 400.000 200.000 2000.000 400.000 200.000 2001.000 + 500.000 200.000 2000.000 500.000 200.000 2001.000 + 600.000 200.000 2000.000 600.000 200.000 2001.000 + 700.000 200.000 2000.000 700.000 200.000 2001.000 + 800.000 200.000 2000.000 800.000 200.000 2001.000 + 900.000 200.000 2000.000 900.000 200.000 2001.000 + 1000.000 200.000 2000.000 1000.000 200.000 2001.000 + 1100.000 200.000 2000.000 1100.000 200.000 2001.000 + 1200.000 200.000 2000.000 1200.000 200.000 2001.000 + 1300.000 200.000 2000.000 1300.000 200.000 2001.000 + 1400.000 200.000 2000.000 1400.000 200.000 2001.000 + 1500.000 200.000 2000.000 1500.000 200.000 2001.000 + 1600.000 200.000 2000.000 1600.000 200.000 2001.000 + 1700.000 200.000 2000.000 1700.000 200.000 2001.000 + 1800.000 200.000 2000.000 1800.000 200.000 2001.000 + 1900.000 200.000 2000.000 1900.000 200.000 2001.000 + 2000.000 200.000 2000.000 2000.000 200.000 2001.000 + 2100.000 200.000 2000.000 2100.000 200.000 2001.000 + 2200.000 200.000 2000.000 2200.000 200.000 2001.000 + 2300.000 200.000 2000.000 2300.000 200.000 2001.000 + 2400.000 200.000 2000.000 2400.000 200.000 2001.000 + 2500.000 200.000 2000.000 2500.000 200.000 2001.000 + 2600.000 200.000 2000.000 2600.000 200.000 2001.000 + 2700.000 200.000 2000.000 2700.000 200.000 2001.000 + 2800.000 200.000 2000.000 2800.000 200.000 2001.000 + 2900.000 200.000 2000.000 2900.000 200.000 2001.000 + 3000.000 200.000 2000.000 3000.000 200.000 2001.000 + 3100.000 200.000 2000.000 3100.000 200.000 2001.000 + 3200.000 200.000 2000.000 3200.000 200.000 2001.000 + 3300.000 200.000 2000.000 3300.000 200.000 2001.000 + 3400.000 200.000 2000.000 3400.000 200.000 2001.000 + 3500.000 200.000 2000.000 3500.000 200.000 2001.000 + 3600.000 200.000 2000.000 3600.000 200.000 2001.000 + 3700.000 200.000 2000.000 3700.000 200.000 2001.000 + 3800.000 200.000 2000.000 3800.000 200.000 2001.000 + 3900.000 200.000 2000.000 3900.000 200.000 2001.000 + 4000.000 200.000 2000.000 4000.000 200.000 2001.000 + 4100.000 200.000 2000.000 4100.000 200.000 2001.000 + 4200.000 200.000 2000.000 4200.000 200.000 2001.000 + 4300.000 200.000 2000.000 4300.000 200.000 2001.000 + 4400.000 200.000 2000.000 4400.000 200.000 2001.000 + 4500.000 200.000 2000.000 4500.000 200.000 2001.000 + 4600.000 200.000 2000.000 4600.000 200.000 2001.000 + 4700.000 200.000 2000.000 4700.000 200.000 2001.000 + 4800.000 200.000 2000.000 4800.000 200.000 2001.000 + 4900.000 200.000 2000.000 4900.000 200.000 2001.000 + 5000.000 200.000 2000.000 5000.000 200.000 2001.000 + 0.000 300.000 2000.000 0.000 300.000 2001.000 + 100.000 300.000 2000.000 100.000 300.000 2001.000 + 200.000 300.000 2000.000 200.000 300.000 2001.000 + 300.000 300.000 2000.000 300.000 300.000 2001.000 + 400.000 300.000 2000.000 400.000 300.000 2001.000 + 500.000 300.000 2000.000 500.000 300.000 2001.000 + 600.000 300.000 2000.000 600.000 300.000 2001.000 + 700.000 300.000 2000.000 700.000 300.000 2001.000 + 800.000 300.000 2000.000 800.000 300.000 2001.000 + 900.000 300.000 2000.000 900.000 300.000 2001.000 + 1000.000 300.000 2000.000 1000.000 300.000 2001.000 + 1100.000 300.000 2000.000 1100.000 300.000 2001.000 + 1200.000 300.000 2000.000 1200.000 300.000 2001.000 + 1300.000 300.000 2000.000 1300.000 300.000 2001.000 + 1400.000 300.000 2000.000 1400.000 300.000 2001.000 + 1500.000 300.000 2000.000 1500.000 300.000 2001.000 + 1600.000 300.000 2000.000 1600.000 300.000 2001.000 + 1700.000 300.000 2000.000 1700.000 300.000 2001.000 + 1800.000 300.000 2000.000 1800.000 300.000 2001.000 + 1900.000 300.000 2000.000 1900.000 300.000 2001.000 + 2000.000 300.000 2000.000 2000.000 300.000 2001.000 + 2100.000 300.000 2000.000 2100.000 300.000 2001.000 + 2200.000 300.000 2000.000 2200.000 300.000 2001.000 + 2300.000 300.000 2000.000 2300.000 300.000 2001.000 + 2400.000 300.000 2000.000 2400.000 300.000 2001.000 + 2500.000 300.000 2000.000 2500.000 300.000 2001.000 + 2600.000 300.000 2000.000 2600.000 300.000 2001.000 + 2700.000 300.000 2000.000 2700.000 300.000 2001.000 + 2800.000 300.000 2000.000 2800.000 300.000 2001.000 + 2900.000 300.000 2000.000 2900.000 300.000 2001.000 + 3000.000 300.000 2000.000 3000.000 300.000 2001.000 + 3100.000 300.000 2000.000 3100.000 300.000 2001.000 + 3200.000 300.000 2000.000 3200.000 300.000 2001.000 + 3300.000 300.000 2000.000 3300.000 300.000 2001.000 + 3400.000 300.000 2000.000 3400.000 300.000 2001.000 + 3500.000 300.000 2000.000 3500.000 300.000 2001.000 + 3600.000 300.000 2000.000 3600.000 300.000 2001.000 + 3700.000 300.000 2000.000 3700.000 300.000 2001.000 + 3800.000 300.000 2000.000 3800.000 300.000 2001.000 + 3900.000 300.000 2000.000 3900.000 300.000 2001.000 + 4000.000 300.000 2000.000 4000.000 300.000 2001.000 + 4100.000 300.000 2000.000 4100.000 300.000 2001.000 + 4200.000 300.000 2000.000 4200.000 300.000 2001.000 + 4300.000 300.000 2000.000 4300.000 300.000 2001.000 + 4400.000 300.000 2000.000 4400.000 300.000 2001.000 + 4500.000 300.000 2000.000 4500.000 300.000 2001.000 + 4600.000 300.000 2000.000 4600.000 300.000 2001.000 + 4700.000 300.000 2000.000 4700.000 300.000 2001.000 + 4800.000 300.000 2000.000 4800.000 300.000 2001.000 + 4900.000 300.000 2000.000 4900.000 300.000 2001.000 + 5000.000 300.000 2000.000 5000.000 300.000 2001.000 + 0.000 400.000 2000.000 0.000 400.000 2001.000 + 100.000 400.000 2000.000 100.000 400.000 2001.000 + 200.000 400.000 2000.000 200.000 400.000 2001.000 + 300.000 400.000 2000.000 300.000 400.000 2001.000 + 400.000 400.000 2000.000 400.000 400.000 2001.000 + 500.000 400.000 2000.000 500.000 400.000 2001.000 + 600.000 400.000 2000.000 600.000 400.000 2001.000 + 700.000 400.000 2000.000 700.000 400.000 2001.000 + 800.000 400.000 2000.000 800.000 400.000 2001.000 + 900.000 400.000 2000.000 900.000 400.000 2001.000 + 1000.000 400.000 2000.000 1000.000 400.000 2001.000 + 1100.000 400.000 2000.000 1100.000 400.000 2001.000 + 1200.000 400.000 2000.000 1200.000 400.000 2001.000 + 1300.000 400.000 2000.000 1300.000 400.000 2001.000 + 1400.000 400.000 2000.000 1400.000 400.000 2001.000 + 1500.000 400.000 2000.000 1500.000 400.000 2001.000 + 1600.000 400.000 2000.000 1600.000 400.000 2001.000 + 1700.000 400.000 2000.000 1700.000 400.000 2001.000 + 1800.000 400.000 2000.000 1800.000 400.000 2001.000 + 1900.000 400.000 2000.000 1900.000 400.000 2001.000 + 2000.000 400.000 2000.000 2000.000 400.000 2001.000 + 2100.000 400.000 2000.000 2100.000 400.000 2001.000 + 2200.000 400.000 2000.000 2200.000 400.000 2001.000 + 2300.000 400.000 2000.000 2300.000 400.000 2001.000 + 2400.000 400.000 2000.000 2400.000 400.000 2001.000 + 2500.000 400.000 2000.000 2500.000 400.000 2001.000 + 2600.000 400.000 2000.000 2600.000 400.000 2001.000 + 2700.000 400.000 2000.000 2700.000 400.000 2001.000 + 2800.000 400.000 2000.000 2800.000 400.000 2001.000 + 2900.000 400.000 2000.000 2900.000 400.000 2001.000 + 3000.000 400.000 2000.000 3000.000 400.000 2001.000 + 3100.000 400.000 2000.000 3100.000 400.000 2001.000 + 3200.000 400.000 2000.000 3200.000 400.000 2001.000 + 3300.000 400.000 2000.000 3300.000 400.000 2001.000 + 3400.000 400.000 2000.000 3400.000 400.000 2001.000 + 3500.000 400.000 2000.000 3500.000 400.000 2001.000 + 3600.000 400.000 2000.000 3600.000 400.000 2001.000 + 3700.000 400.000 2000.000 3700.000 400.000 2001.000 + 3800.000 400.000 2000.000 3800.000 400.000 2001.000 + 3900.000 400.000 2000.000 3900.000 400.000 2001.000 + 4000.000 400.000 2000.000 4000.000 400.000 2001.000 + 4100.000 400.000 2000.000 4100.000 400.000 2001.000 + 4200.000 400.000 2000.000 4200.000 400.000 2001.000 + 4300.000 400.000 2000.000 4300.000 400.000 2001.000 + 4400.000 400.000 2000.000 4400.000 400.000 2001.000 + 4500.000 400.000 2000.000 4500.000 400.000 2001.000 + 4600.000 400.000 2000.000 4600.000 400.000 2001.000 + 4700.000 400.000 2000.000 4700.000 400.000 2001.000 + 4800.000 400.000 2000.000 4800.000 400.000 2001.000 + 4900.000 400.000 2000.000 4900.000 400.000 2001.000 + 5000.000 400.000 2000.000 5000.000 400.000 2001.000 + 0.000 500.000 2000.000 0.000 500.000 2001.000 + 100.000 500.000 2000.000 100.000 500.000 2001.000 + 200.000 500.000 2000.000 200.000 500.000 2001.000 + 300.000 500.000 2000.000 300.000 500.000 2001.000 + 400.000 500.000 2000.000 400.000 500.000 2001.000 + 500.000 500.000 2000.000 500.000 500.000 2001.000 + 600.000 500.000 2000.000 600.000 500.000 2001.000 + 700.000 500.000 2000.000 700.000 500.000 2001.000 + 800.000 500.000 2000.000 800.000 500.000 2001.000 + 900.000 500.000 2000.000 900.000 500.000 2001.000 + 1000.000 500.000 2000.000 1000.000 500.000 2001.000 + 1100.000 500.000 2000.000 1100.000 500.000 2001.000 + 1200.000 500.000 2000.000 1200.000 500.000 2001.000 + 1300.000 500.000 2000.000 1300.000 500.000 2001.000 + 1400.000 500.000 2000.000 1400.000 500.000 2001.000 + 1500.000 500.000 2000.000 1500.000 500.000 2001.000 + 1600.000 500.000 2000.000 1600.000 500.000 2001.000 + 1700.000 500.000 2000.000 1700.000 500.000 2001.000 + 1800.000 500.000 2000.000 1800.000 500.000 2001.000 + 1900.000 500.000 2000.000 1900.000 500.000 2001.000 + 2000.000 500.000 2000.000 2000.000 500.000 2001.000 + 2100.000 500.000 2000.000 2100.000 500.000 2001.000 + 2200.000 500.000 2000.000 2200.000 500.000 2001.000 + 2300.000 500.000 2000.000 2300.000 500.000 2001.000 + 2400.000 500.000 2000.000 2400.000 500.000 2001.000 + 2500.000 500.000 2000.000 2500.000 500.000 2001.000 + 2600.000 500.000 2000.000 2600.000 500.000 2001.000 + 2700.000 500.000 2000.000 2700.000 500.000 2001.000 + 2800.000 500.000 2000.000 2800.000 500.000 2001.000 + 2900.000 500.000 2000.000 2900.000 500.000 2001.000 + 3000.000 500.000 2000.000 3000.000 500.000 2001.000 + 3100.000 500.000 2000.000 3100.000 500.000 2001.000 + 3200.000 500.000 2000.000 3200.000 500.000 2001.000 + 3300.000 500.000 2000.000 3300.000 500.000 2001.000 + 3400.000 500.000 2000.000 3400.000 500.000 2001.000 + 3500.000 500.000 2000.000 3500.000 500.000 2001.000 + 3600.000 500.000 2000.000 3600.000 500.000 2001.000 + 3700.000 500.000 2000.000 3700.000 500.000 2001.000 + 3800.000 500.000 2000.000 3800.000 500.000 2001.000 + 3900.000 500.000 2000.000 3900.000 500.000 2001.000 + 4000.000 500.000 2000.000 4000.000 500.000 2001.000 + 4100.000 500.000 2000.000 4100.000 500.000 2001.000 + 4200.000 500.000 2000.000 4200.000 500.000 2001.000 + 4300.000 500.000 2000.000 4300.000 500.000 2001.000 + 4400.000 500.000 2000.000 4400.000 500.000 2001.000 + 4500.000 500.000 2000.000 4500.000 500.000 2001.000 + 4600.000 500.000 2000.000 4600.000 500.000 2001.000 + 4700.000 500.000 2000.000 4700.000 500.000 2001.000 + 4800.000 500.000 2000.000 4800.000 500.000 2001.000 + 4900.000 500.000 2000.000 4900.000 500.000 2001.000 + 5000.000 500.000 2000.000 5000.000 500.000 2001.000 + 0.000 600.000 2000.000 0.000 600.000 2001.000 + 100.000 600.000 2000.000 100.000 600.000 2001.000 + 200.000 600.000 2000.000 200.000 600.000 2001.000 + 300.000 600.000 2000.000 300.000 600.000 2001.000 + 400.000 600.000 2000.000 400.000 600.000 2001.000 + 500.000 600.000 2000.000 500.000 600.000 2001.000 + 600.000 600.000 2000.000 600.000 600.000 2001.000 + 700.000 600.000 2000.000 700.000 600.000 2001.000 + 800.000 600.000 2000.000 800.000 600.000 2001.000 + 900.000 600.000 2000.000 900.000 600.000 2001.000 + 1000.000 600.000 2000.000 1000.000 600.000 2001.000 + 1100.000 600.000 2000.000 1100.000 600.000 2001.000 + 1200.000 600.000 2000.000 1200.000 600.000 2001.000 + 1300.000 600.000 2000.000 1300.000 600.000 2001.000 + 1400.000 600.000 2000.000 1400.000 600.000 2001.000 + 1500.000 600.000 2000.000 1500.000 600.000 2001.000 + 1600.000 600.000 2000.000 1600.000 600.000 2001.000 + 1700.000 600.000 2000.000 1700.000 600.000 2001.000 + 1800.000 600.000 2000.000 1800.000 600.000 2001.000 + 1900.000 600.000 2000.000 1900.000 600.000 2001.000 + 2000.000 600.000 2000.000 2000.000 600.000 2001.000 + 2100.000 600.000 2000.000 2100.000 600.000 2001.000 + 2200.000 600.000 2000.000 2200.000 600.000 2001.000 + 2300.000 600.000 2000.000 2300.000 600.000 2001.000 + 2400.000 600.000 2000.000 2400.000 600.000 2001.000 + 2500.000 600.000 2000.000 2500.000 600.000 2001.000 + 2600.000 600.000 2000.000 2600.000 600.000 2001.000 + 2700.000 600.000 2000.000 2700.000 600.000 2001.000 + 2800.000 600.000 2000.000 2800.000 600.000 2001.000 + 2900.000 600.000 2000.000 2900.000 600.000 2001.000 + 3000.000 600.000 2000.000 3000.000 600.000 2001.000 + 3100.000 600.000 2000.000 3100.000 600.000 2001.000 + 3200.000 600.000 2000.000 3200.000 600.000 2001.000 + 3300.000 600.000 2000.000 3300.000 600.000 2001.000 + 3400.000 600.000 2000.000 3400.000 600.000 2001.000 + 3500.000 600.000 2000.000 3500.000 600.000 2001.000 + 3600.000 600.000 2000.000 3600.000 600.000 2001.000 + 3700.000 600.000 2000.000 3700.000 600.000 2001.000 + 3800.000 600.000 2000.000 3800.000 600.000 2001.000 + 3900.000 600.000 2000.000 3900.000 600.000 2001.000 + 4000.000 600.000 2000.000 4000.000 600.000 2001.000 + 4100.000 600.000 2000.000 4100.000 600.000 2001.000 + 4200.000 600.000 2000.000 4200.000 600.000 2001.000 + 4300.000 600.000 2000.000 4300.000 600.000 2001.000 + 4400.000 600.000 2000.000 4400.000 600.000 2001.000 + 4500.000 600.000 2000.000 4500.000 600.000 2001.000 + 4600.000 600.000 2000.000 4600.000 600.000 2001.000 + 4700.000 600.000 2000.000 4700.000 600.000 2001.000 + 4800.000 600.000 2000.000 4800.000 600.000 2001.000 + 4900.000 600.000 2000.000 4900.000 600.000 2001.000 + 5000.000 600.000 2000.000 5000.000 600.000 2001.000 + 0.000 700.000 2000.000 0.000 700.000 2001.000 + 100.000 700.000 2000.000 100.000 700.000 2001.000 + 200.000 700.000 2000.000 200.000 700.000 2001.000 + 300.000 700.000 2000.000 300.000 700.000 2001.000 + 400.000 700.000 2000.000 400.000 700.000 2001.000 + 500.000 700.000 2000.000 500.000 700.000 2001.000 + 600.000 700.000 2000.000 600.000 700.000 2001.000 + 700.000 700.000 2000.000 700.000 700.000 2001.000 + 800.000 700.000 2000.000 800.000 700.000 2001.000 + 900.000 700.000 2000.000 900.000 700.000 2001.000 + 1000.000 700.000 2000.000 1000.000 700.000 2001.000 + 1100.000 700.000 2000.000 1100.000 700.000 2001.000 + 1200.000 700.000 2000.000 1200.000 700.000 2001.000 + 1300.000 700.000 2000.000 1300.000 700.000 2001.000 + 1400.000 700.000 2000.000 1400.000 700.000 2001.000 + 1500.000 700.000 2000.000 1500.000 700.000 2001.000 + 1600.000 700.000 2000.000 1600.000 700.000 2001.000 + 1700.000 700.000 2000.000 1700.000 700.000 2001.000 + 1800.000 700.000 2000.000 1800.000 700.000 2001.000 + 1900.000 700.000 2000.000 1900.000 700.000 2001.000 + 2000.000 700.000 2000.000 2000.000 700.000 2001.000 + 2100.000 700.000 2000.000 2100.000 700.000 2001.000 + 2200.000 700.000 2000.000 2200.000 700.000 2001.000 + 2300.000 700.000 2000.000 2300.000 700.000 2001.000 + 2400.000 700.000 2000.000 2400.000 700.000 2001.000 + 2500.000 700.000 2000.000 2500.000 700.000 2001.000 + 2600.000 700.000 2000.000 2600.000 700.000 2001.000 + 2700.000 700.000 2000.000 2700.000 700.000 2001.000 + 2800.000 700.000 2000.000 2800.000 700.000 2001.000 + 2900.000 700.000 2000.000 2900.000 700.000 2001.000 + 3000.000 700.000 2000.000 3000.000 700.000 2001.000 + 3100.000 700.000 2000.000 3100.000 700.000 2001.000 + 3200.000 700.000 2000.000 3200.000 700.000 2001.000 + 3300.000 700.000 2000.000 3300.000 700.000 2001.000 + 3400.000 700.000 2000.000 3400.000 700.000 2001.000 + 3500.000 700.000 2000.000 3500.000 700.000 2001.000 + 3600.000 700.000 2000.000 3600.000 700.000 2001.000 + 3700.000 700.000 2000.000 3700.000 700.000 2001.000 + 3800.000 700.000 2000.000 3800.000 700.000 2001.000 + 3900.000 700.000 2000.000 3900.000 700.000 2001.000 + 4000.000 700.000 2000.000 4000.000 700.000 2001.000 + 4100.000 700.000 2000.000 4100.000 700.000 2001.000 + 4200.000 700.000 2000.000 4200.000 700.000 2001.000 + 4300.000 700.000 2000.000 4300.000 700.000 2001.000 + 4400.000 700.000 2000.000 4400.000 700.000 2001.000 + 4500.000 700.000 2000.000 4500.000 700.000 2001.000 + 4600.000 700.000 2000.000 4600.000 700.000 2001.000 + 4700.000 700.000 2000.000 4700.000 700.000 2001.000 + 4800.000 700.000 2000.000 4800.000 700.000 2001.000 + 4900.000 700.000 2000.000 4900.000 700.000 2001.000 + 5000.000 700.000 2000.000 5000.000 700.000 2001.000 + 0.000 800.000 2000.000 0.000 800.000 2001.000 + 100.000 800.000 2000.000 100.000 800.000 2001.000 + 200.000 800.000 2000.000 200.000 800.000 2001.000 + 300.000 800.000 2000.000 300.000 800.000 2001.000 + 400.000 800.000 2000.000 400.000 800.000 2001.000 + 500.000 800.000 2000.000 500.000 800.000 2001.000 + 600.000 800.000 2000.000 600.000 800.000 2001.000 + 700.000 800.000 2000.000 700.000 800.000 2001.000 + 800.000 800.000 2000.000 800.000 800.000 2001.000 + 900.000 800.000 2000.000 900.000 800.000 2001.000 + 1000.000 800.000 2000.000 1000.000 800.000 2001.000 + 1100.000 800.000 2000.000 1100.000 800.000 2001.000 + 1200.000 800.000 2000.000 1200.000 800.000 2001.000 + 1300.000 800.000 2000.000 1300.000 800.000 2001.000 + 1400.000 800.000 2000.000 1400.000 800.000 2001.000 + 1500.000 800.000 2000.000 1500.000 800.000 2001.000 + 1600.000 800.000 2000.000 1600.000 800.000 2001.000 + 1700.000 800.000 2000.000 1700.000 800.000 2001.000 + 1800.000 800.000 2000.000 1800.000 800.000 2001.000 + 1900.000 800.000 2000.000 1900.000 800.000 2001.000 + 2000.000 800.000 2000.000 2000.000 800.000 2001.000 + 2100.000 800.000 2000.000 2100.000 800.000 2001.000 + 2200.000 800.000 2000.000 2200.000 800.000 2001.000 + 2300.000 800.000 2000.000 2300.000 800.000 2001.000 + 2400.000 800.000 2000.000 2400.000 800.000 2001.000 + 2500.000 800.000 2000.000 2500.000 800.000 2001.000 + 2600.000 800.000 2000.000 2600.000 800.000 2001.000 + 2700.000 800.000 2000.000 2700.000 800.000 2001.000 + 2800.000 800.000 2000.000 2800.000 800.000 2001.000 + 2900.000 800.000 2000.000 2900.000 800.000 2001.000 + 3000.000 800.000 2000.000 3000.000 800.000 2001.000 + 3100.000 800.000 2000.000 3100.000 800.000 2001.000 + 3200.000 800.000 2000.000 3200.000 800.000 2001.000 + 3300.000 800.000 2000.000 3300.000 800.000 2001.000 + 3400.000 800.000 2000.000 3400.000 800.000 2001.000 + 3500.000 800.000 2000.000 3500.000 800.000 2001.000 + 3600.000 800.000 2000.000 3600.000 800.000 2001.000 + 3700.000 800.000 2000.000 3700.000 800.000 2001.000 + 3800.000 800.000 2000.000 3800.000 800.000 2001.000 + 3900.000 800.000 2000.000 3900.000 800.000 2001.000 + 4000.000 800.000 2000.000 4000.000 800.000 2001.000 + 4100.000 800.000 2000.000 4100.000 800.000 2001.000 + 4200.000 800.000 2000.000 4200.000 800.000 2001.000 + 4300.000 800.000 2000.000 4300.000 800.000 2001.000 + 4400.000 800.000 2000.000 4400.000 800.000 2001.000 + 4500.000 800.000 2000.000 4500.000 800.000 2001.000 + 4600.000 800.000 2000.000 4600.000 800.000 2001.000 + 4700.000 800.000 2000.000 4700.000 800.000 2001.000 + 4800.000 800.000 2000.000 4800.000 800.000 2001.000 + 4900.000 800.000 2000.000 4900.000 800.000 2001.000 + 5000.000 800.000 2000.000 5000.000 800.000 2001.000 + 0.000 900.000 2000.000 0.000 900.000 2001.000 + 100.000 900.000 2000.000 100.000 900.000 2001.000 + 200.000 900.000 2000.000 200.000 900.000 2001.000 + 300.000 900.000 2000.000 300.000 900.000 2001.000 + 400.000 900.000 2000.000 400.000 900.000 2001.000 + 500.000 900.000 2000.000 500.000 900.000 2001.000 + 600.000 900.000 2000.000 600.000 900.000 2001.000 + 700.000 900.000 2000.000 700.000 900.000 2001.000 + 800.000 900.000 2000.000 800.000 900.000 2001.000 + 900.000 900.000 2000.000 900.000 900.000 2001.000 + 1000.000 900.000 2000.000 1000.000 900.000 2001.000 + 1100.000 900.000 2000.000 1100.000 900.000 2001.000 + 1200.000 900.000 2000.000 1200.000 900.000 2001.000 + 1300.000 900.000 2000.000 1300.000 900.000 2001.000 + 1400.000 900.000 2000.000 1400.000 900.000 2001.000 + 1500.000 900.000 2000.000 1500.000 900.000 2001.000 + 1600.000 900.000 2000.000 1600.000 900.000 2001.000 + 1700.000 900.000 2000.000 1700.000 900.000 2001.000 + 1800.000 900.000 2000.000 1800.000 900.000 2001.000 + 1900.000 900.000 2000.000 1900.000 900.000 2001.000 + 2000.000 900.000 2000.000 2000.000 900.000 2001.000 + 2100.000 900.000 2000.000 2100.000 900.000 2001.000 + 2200.000 900.000 2000.000 2200.000 900.000 2001.000 + 2300.000 900.000 2000.000 2300.000 900.000 2001.000 + 2400.000 900.000 2000.000 2400.000 900.000 2001.000 + 2500.000 900.000 2000.000 2500.000 900.000 2001.000 + 2600.000 900.000 2000.000 2600.000 900.000 2001.000 + 2700.000 900.000 2000.000 2700.000 900.000 2001.000 + 2800.000 900.000 2000.000 2800.000 900.000 2001.000 + 2900.000 900.000 2000.000 2900.000 900.000 2001.000 + 3000.000 900.000 2000.000 3000.000 900.000 2001.000 + 3100.000 900.000 2000.000 3100.000 900.000 2001.000 + 3200.000 900.000 2000.000 3200.000 900.000 2001.000 + 3300.000 900.000 2000.000 3300.000 900.000 2001.000 + 3400.000 900.000 2000.000 3400.000 900.000 2001.000 + 3500.000 900.000 2000.000 3500.000 900.000 2001.000 + 3600.000 900.000 2000.000 3600.000 900.000 2001.000 + 3700.000 900.000 2000.000 3700.000 900.000 2001.000 + 3800.000 900.000 2000.000 3800.000 900.000 2001.000 + 3900.000 900.000 2000.000 3900.000 900.000 2001.000 + 4000.000 900.000 2000.000 4000.000 900.000 2001.000 + 4100.000 900.000 2000.000 4100.000 900.000 2001.000 + 4200.000 900.000 2000.000 4200.000 900.000 2001.000 + 4300.000 900.000 2000.000 4300.000 900.000 2001.000 + 4400.000 900.000 2000.000 4400.000 900.000 2001.000 + 4500.000 900.000 2000.000 4500.000 900.000 2001.000 + 4600.000 900.000 2000.000 4600.000 900.000 2001.000 + 4700.000 900.000 2000.000 4700.000 900.000 2001.000 + 4800.000 900.000 2000.000 4800.000 900.000 2001.000 + 4900.000 900.000 2000.000 4900.000 900.000 2001.000 + 5000.000 900.000 2000.000 5000.000 900.000 2001.000 + 0.000 1000.000 2000.000 0.000 1000.000 2001.000 + 100.000 1000.000 2000.000 100.000 1000.000 2001.000 + 200.000 1000.000 2000.000 200.000 1000.000 2001.000 + 300.000 1000.000 2000.000 300.000 1000.000 2001.000 + 400.000 1000.000 2000.000 400.000 1000.000 2001.000 + 500.000 1000.000 2000.000 500.000 1000.000 2001.000 + 600.000 1000.000 2000.000 600.000 1000.000 2001.000 + 700.000 1000.000 2000.000 700.000 1000.000 2001.000 + 800.000 1000.000 2000.000 800.000 1000.000 2001.000 + 900.000 1000.000 2000.000 900.000 1000.000 2001.000 + 1000.000 1000.000 2000.000 1000.000 1000.000 2001.000 + 1100.000 1000.000 2000.000 1100.000 1000.000 2001.000 + 1200.000 1000.000 2000.000 1200.000 1000.000 2001.000 + 1300.000 1000.000 2000.000 1300.000 1000.000 2001.000 + 1400.000 1000.000 2000.000 1400.000 1000.000 2001.000 + 1500.000 1000.000 2000.000 1500.000 1000.000 2001.000 + 1600.000 1000.000 2000.000 1600.000 1000.000 2001.000 + 1700.000 1000.000 2000.000 1700.000 1000.000 2001.000 + 1800.000 1000.000 2000.000 1800.000 1000.000 2001.000 + 1900.000 1000.000 2000.000 1900.000 1000.000 2001.000 + 2000.000 1000.000 2000.000 2000.000 1000.000 2001.000 + 2100.000 1000.000 2000.000 2100.000 1000.000 2001.000 + 2200.000 1000.000 2000.000 2200.000 1000.000 2001.000 + 2300.000 1000.000 2000.000 2300.000 1000.000 2001.000 + 2400.000 1000.000 2000.000 2400.000 1000.000 2001.000 + 2500.000 1000.000 2000.000 2500.000 1000.000 2001.000 + 2600.000 1000.000 2000.000 2600.000 1000.000 2001.000 + 2700.000 1000.000 2000.000 2700.000 1000.000 2001.000 + 2800.000 1000.000 2000.000 2800.000 1000.000 2001.000 + 2900.000 1000.000 2000.000 2900.000 1000.000 2001.000 + 3000.000 1000.000 2000.000 3000.000 1000.000 2001.000 + 3100.000 1000.000 2000.000 3100.000 1000.000 2001.000 + 3200.000 1000.000 2000.000 3200.000 1000.000 2001.000 + 3300.000 1000.000 2000.000 3300.000 1000.000 2001.000 + 3400.000 1000.000 2000.000 3400.000 1000.000 2001.000 + 3500.000 1000.000 2000.000 3500.000 1000.000 2001.000 + 3600.000 1000.000 2000.000 3600.000 1000.000 2001.000 + 3700.000 1000.000 2000.000 3700.000 1000.000 2001.000 + 3800.000 1000.000 2000.000 3800.000 1000.000 2001.000 + 3900.000 1000.000 2000.000 3900.000 1000.000 2001.000 + 4000.000 1000.000 2000.000 4000.000 1000.000 2001.000 + 4100.000 1000.000 2000.000 4100.000 1000.000 2001.000 + 4200.000 1000.000 2000.000 4200.000 1000.000 2001.000 + 4300.000 1000.000 2000.000 4300.000 1000.000 2001.000 + 4400.000 1000.000 2000.000 4400.000 1000.000 2001.000 + 4500.000 1000.000 2000.000 4500.000 1000.000 2001.000 + 4600.000 1000.000 2000.000 4600.000 1000.000 2001.000 + 4700.000 1000.000 2000.000 4700.000 1000.000 2001.000 + 4800.000 1000.000 2000.000 4800.000 1000.000 2001.000 + 4900.000 1000.000 2000.000 4900.000 1000.000 2001.000 + 5000.000 1000.000 2000.000 5000.000 1000.000 2001.000 + 0.000 1100.000 2000.000 0.000 1100.000 2001.000 + 100.000 1100.000 2000.000 100.000 1100.000 2001.000 + 200.000 1100.000 2000.000 200.000 1100.000 2001.000 + 300.000 1100.000 2000.000 300.000 1100.000 2001.000 + 400.000 1100.000 2000.000 400.000 1100.000 2001.000 + 500.000 1100.000 2000.000 500.000 1100.000 2001.000 + 600.000 1100.000 2000.000 600.000 1100.000 2001.000 + 700.000 1100.000 2000.000 700.000 1100.000 2001.000 + 800.000 1100.000 2000.000 800.000 1100.000 2001.000 + 900.000 1100.000 2000.000 900.000 1100.000 2001.000 + 1000.000 1100.000 2000.000 1000.000 1100.000 2001.000 + 1100.000 1100.000 2000.000 1100.000 1100.000 2001.000 + 1200.000 1100.000 2000.000 1200.000 1100.000 2001.000 + 1300.000 1100.000 2000.000 1300.000 1100.000 2001.000 + 1400.000 1100.000 2000.000 1400.000 1100.000 2001.000 + 1500.000 1100.000 2000.000 1500.000 1100.000 2001.000 + 1600.000 1100.000 2000.000 1600.000 1100.000 2001.000 + 1700.000 1100.000 2000.000 1700.000 1100.000 2001.000 + 1800.000 1100.000 2000.000 1800.000 1100.000 2001.000 + 1900.000 1100.000 2000.000 1900.000 1100.000 2001.000 + 2000.000 1100.000 2000.000 2000.000 1100.000 2001.000 + 2100.000 1100.000 2000.000 2100.000 1100.000 2001.000 + 2200.000 1100.000 2000.000 2200.000 1100.000 2001.000 + 2300.000 1100.000 2000.000 2300.000 1100.000 2001.000 + 2400.000 1100.000 2000.000 2400.000 1100.000 2001.000 + 2500.000 1100.000 2000.000 2500.000 1100.000 2001.000 + 2600.000 1100.000 2000.000 2600.000 1100.000 2001.000 + 2700.000 1100.000 2000.000 2700.000 1100.000 2001.000 + 2800.000 1100.000 2000.000 2800.000 1100.000 2001.000 + 2900.000 1100.000 2000.000 2900.000 1100.000 2001.000 + 3000.000 1100.000 2000.000 3000.000 1100.000 2001.000 + 3100.000 1100.000 2000.000 3100.000 1100.000 2001.000 + 3200.000 1100.000 2000.000 3200.000 1100.000 2001.000 + 3300.000 1100.000 2000.000 3300.000 1100.000 2001.000 + 3400.000 1100.000 2000.000 3400.000 1100.000 2001.000 + 3500.000 1100.000 2000.000 3500.000 1100.000 2001.000 + 3600.000 1100.000 2000.000 3600.000 1100.000 2001.000 + 3700.000 1100.000 2000.000 3700.000 1100.000 2001.000 + 3800.000 1100.000 2000.000 3800.000 1100.000 2001.000 + 3900.000 1100.000 2000.000 3900.000 1100.000 2001.000 + 4000.000 1100.000 2000.000 4000.000 1100.000 2001.000 + 4100.000 1100.000 2000.000 4100.000 1100.000 2001.000 + 4200.000 1100.000 2000.000 4200.000 1100.000 2001.000 + 4300.000 1100.000 2000.000 4300.000 1100.000 2001.000 + 4400.000 1100.000 2000.000 4400.000 1100.000 2001.000 + 4500.000 1100.000 2000.000 4500.000 1100.000 2001.000 + 4600.000 1100.000 2000.000 4600.000 1100.000 2001.000 + 4700.000 1100.000 2000.000 4700.000 1100.000 2001.000 + 4800.000 1100.000 2000.000 4800.000 1100.000 2001.000 + 4900.000 1100.000 2000.000 4900.000 1100.000 2001.000 + 5000.000 1100.000 2000.000 5000.000 1100.000 2001.000 + 0.000 1200.000 2000.000 0.000 1200.000 2001.000 + 100.000 1200.000 2000.000 100.000 1200.000 2001.000 + 200.000 1200.000 2000.000 200.000 1200.000 2001.000 + 300.000 1200.000 2000.000 300.000 1200.000 2001.000 + 400.000 1200.000 2000.000 400.000 1200.000 2001.000 + 500.000 1200.000 2000.000 500.000 1200.000 2001.000 + 600.000 1200.000 2000.000 600.000 1200.000 2001.000 + 700.000 1200.000 2000.000 700.000 1200.000 2001.000 + 800.000 1200.000 2000.000 800.000 1200.000 2001.000 + 900.000 1200.000 2000.000 900.000 1200.000 2001.000 + 1000.000 1200.000 2000.000 1000.000 1200.000 2001.000 + 1100.000 1200.000 2000.000 1100.000 1200.000 2001.000 + 1200.000 1200.000 2000.000 1200.000 1200.000 2001.000 + 1300.000 1200.000 2000.000 1300.000 1200.000 2001.000 + 1400.000 1200.000 2000.000 1400.000 1200.000 2001.000 + 1500.000 1200.000 2000.000 1500.000 1200.000 2001.000 + 1600.000 1200.000 2000.000 1600.000 1200.000 2001.000 + 1700.000 1200.000 2000.000 1700.000 1200.000 2001.000 + 1800.000 1200.000 2000.000 1800.000 1200.000 2001.000 + 1900.000 1200.000 2000.000 1900.000 1200.000 2001.000 + 2000.000 1200.000 2000.000 2000.000 1200.000 2001.000 + 2100.000 1200.000 2000.000 2100.000 1200.000 2001.000 + 2200.000 1200.000 2000.000 2200.000 1200.000 2001.000 + 2300.000 1200.000 2000.000 2300.000 1200.000 2001.000 + 2400.000 1200.000 2000.000 2400.000 1200.000 2001.000 + 2500.000 1200.000 2000.000 2500.000 1200.000 2001.000 + 2600.000 1200.000 2000.000 2600.000 1200.000 2001.000 + 2700.000 1200.000 2000.000 2700.000 1200.000 2001.000 + 2800.000 1200.000 2000.000 2800.000 1200.000 2001.000 + 2900.000 1200.000 2000.000 2900.000 1200.000 2001.000 + 3000.000 1200.000 2000.000 3000.000 1200.000 2001.000 + 3100.000 1200.000 2000.000 3100.000 1200.000 2001.000 + 3200.000 1200.000 2000.000 3200.000 1200.000 2001.000 + 3300.000 1200.000 2000.000 3300.000 1200.000 2001.000 + 3400.000 1200.000 2000.000 3400.000 1200.000 2001.000 + 3500.000 1200.000 2000.000 3500.000 1200.000 2001.000 + 3600.000 1200.000 2000.000 3600.000 1200.000 2001.000 + 3700.000 1200.000 2000.000 3700.000 1200.000 2001.000 + 3800.000 1200.000 2000.000 3800.000 1200.000 2001.000 + 3900.000 1200.000 2000.000 3900.000 1200.000 2001.000 + 4000.000 1200.000 2000.000 4000.000 1200.000 2001.000 + 4100.000 1200.000 2000.000 4100.000 1200.000 2001.000 + 4200.000 1200.000 2000.000 4200.000 1200.000 2001.000 + 4300.000 1200.000 2000.000 4300.000 1200.000 2001.000 + 4400.000 1200.000 2000.000 4400.000 1200.000 2001.000 + 4500.000 1200.000 2000.000 4500.000 1200.000 2001.000 + 4600.000 1200.000 2000.000 4600.000 1200.000 2001.000 + 4700.000 1200.000 2000.000 4700.000 1200.000 2001.000 + 4800.000 1200.000 2000.000 4800.000 1200.000 2001.000 + 4900.000 1200.000 2000.000 4900.000 1200.000 2001.000 + 5000.000 1200.000 2000.000 5000.000 1200.000 2001.000 + 0.000 1300.000 2000.000 0.000 1300.000 2001.000 + 100.000 1300.000 2000.000 100.000 1300.000 2001.000 + 200.000 1300.000 2000.000 200.000 1300.000 2001.000 + 300.000 1300.000 2000.000 300.000 1300.000 2001.000 + 400.000 1300.000 2000.000 400.000 1300.000 2001.000 + 500.000 1300.000 2000.000 500.000 1300.000 2001.000 + 600.000 1300.000 2000.000 600.000 1300.000 2001.000 + 700.000 1300.000 2000.000 700.000 1300.000 2001.000 + 800.000 1300.000 2000.000 800.000 1300.000 2001.000 + 900.000 1300.000 2000.000 900.000 1300.000 2001.000 + 1000.000 1300.000 2000.000 1000.000 1300.000 2001.000 + 1100.000 1300.000 2000.000 1100.000 1300.000 2001.000 + 1200.000 1300.000 2000.000 1200.000 1300.000 2001.000 + 1300.000 1300.000 2000.000 1300.000 1300.000 2001.000 + 1400.000 1300.000 2000.000 1400.000 1300.000 2001.000 + 1500.000 1300.000 2000.000 1500.000 1300.000 2001.000 + 1600.000 1300.000 2000.000 1600.000 1300.000 2001.000 + 1700.000 1300.000 2000.000 1700.000 1300.000 2001.000 + 1800.000 1300.000 2000.000 1800.000 1300.000 2001.000 + 1900.000 1300.000 2000.000 1900.000 1300.000 2001.000 + 2000.000 1300.000 2000.000 2000.000 1300.000 2001.000 + 2100.000 1300.000 2000.000 2100.000 1300.000 2001.000 + 2200.000 1300.000 2000.000 2200.000 1300.000 2001.000 + 2300.000 1300.000 2000.000 2300.000 1300.000 2001.000 + 2400.000 1300.000 2000.000 2400.000 1300.000 2001.000 + 2500.000 1300.000 2000.000 2500.000 1300.000 2001.000 + 2600.000 1300.000 2000.000 2600.000 1300.000 2001.000 + 2700.000 1300.000 2000.000 2700.000 1300.000 2001.000 + 2800.000 1300.000 2000.000 2800.000 1300.000 2001.000 + 2900.000 1300.000 2000.000 2900.000 1300.000 2001.000 + 3000.000 1300.000 2000.000 3000.000 1300.000 2001.000 + 3100.000 1300.000 2000.000 3100.000 1300.000 2001.000 + 3200.000 1300.000 2000.000 3200.000 1300.000 2001.000 + 3300.000 1300.000 2000.000 3300.000 1300.000 2001.000 + 3400.000 1300.000 2000.000 3400.000 1300.000 2001.000 + 3500.000 1300.000 2000.000 3500.000 1300.000 2001.000 + 3600.000 1300.000 2000.000 3600.000 1300.000 2001.000 + 3700.000 1300.000 2000.000 3700.000 1300.000 2001.000 + 3800.000 1300.000 2000.000 3800.000 1300.000 2001.000 + 3900.000 1300.000 2000.000 3900.000 1300.000 2001.000 + 4000.000 1300.000 2000.000 4000.000 1300.000 2001.000 + 4100.000 1300.000 2000.000 4100.000 1300.000 2001.000 + 4200.000 1300.000 2000.000 4200.000 1300.000 2001.000 + 4300.000 1300.000 2000.000 4300.000 1300.000 2001.000 + 4400.000 1300.000 2000.000 4400.000 1300.000 2001.000 + 4500.000 1300.000 2000.000 4500.000 1300.000 2001.000 + 4600.000 1300.000 2000.000 4600.000 1300.000 2001.000 + 4700.000 1300.000 2000.000 4700.000 1300.000 2001.000 + 4800.000 1300.000 2000.000 4800.000 1300.000 2001.000 + 4900.000 1300.000 2000.000 4900.000 1300.000 2001.000 + 5000.000 1300.000 2000.000 5000.000 1300.000 2001.000 + 0.000 1400.000 2000.000 0.000 1400.000 2001.000 + 100.000 1400.000 2000.000 100.000 1400.000 2001.000 + 200.000 1400.000 2000.000 200.000 1400.000 2001.000 + 300.000 1400.000 2000.000 300.000 1400.000 2001.000 + 400.000 1400.000 2000.000 400.000 1400.000 2001.000 + 500.000 1400.000 2000.000 500.000 1400.000 2001.000 + 600.000 1400.000 2000.000 600.000 1400.000 2001.000 + 700.000 1400.000 2000.000 700.000 1400.000 2001.000 + 800.000 1400.000 2000.000 800.000 1400.000 2001.000 + 900.000 1400.000 2000.000 900.000 1400.000 2001.000 + 1000.000 1400.000 2000.000 1000.000 1400.000 2001.000 + 1100.000 1400.000 2000.000 1100.000 1400.000 2001.000 + 1200.000 1400.000 2000.000 1200.000 1400.000 2001.000 + 1300.000 1400.000 2000.000 1300.000 1400.000 2001.000 + 1400.000 1400.000 2000.000 1400.000 1400.000 2001.000 + 1500.000 1400.000 2000.000 1500.000 1400.000 2001.000 + 1600.000 1400.000 2000.000 1600.000 1400.000 2001.000 + 1700.000 1400.000 2000.000 1700.000 1400.000 2001.000 + 1800.000 1400.000 2000.000 1800.000 1400.000 2001.000 + 1900.000 1400.000 2000.000 1900.000 1400.000 2001.000 + 2000.000 1400.000 2000.000 2000.000 1400.000 2001.000 + 2100.000 1400.000 2000.000 2100.000 1400.000 2001.000 + 2200.000 1400.000 2000.000 2200.000 1400.000 2001.000 + 2300.000 1400.000 2000.000 2300.000 1400.000 2001.000 + 2400.000 1400.000 2000.000 2400.000 1400.000 2001.000 + 2500.000 1400.000 2000.000 2500.000 1400.000 2001.000 + 2600.000 1400.000 2000.000 2600.000 1400.000 2001.000 + 2700.000 1400.000 2000.000 2700.000 1400.000 2001.000 + 2800.000 1400.000 2000.000 2800.000 1400.000 2001.000 + 2900.000 1400.000 2000.000 2900.000 1400.000 2001.000 + 3000.000 1400.000 2000.000 3000.000 1400.000 2001.000 + 3100.000 1400.000 2000.000 3100.000 1400.000 2001.000 + 3200.000 1400.000 2000.000 3200.000 1400.000 2001.000 + 3300.000 1400.000 2000.000 3300.000 1400.000 2001.000 + 3400.000 1400.000 2000.000 3400.000 1400.000 2001.000 + 3500.000 1400.000 2000.000 3500.000 1400.000 2001.000 + 3600.000 1400.000 2000.000 3600.000 1400.000 2001.000 + 3700.000 1400.000 2000.000 3700.000 1400.000 2001.000 + 3800.000 1400.000 2000.000 3800.000 1400.000 2001.000 + 3900.000 1400.000 2000.000 3900.000 1400.000 2001.000 + 4000.000 1400.000 2000.000 4000.000 1400.000 2001.000 + 4100.000 1400.000 2000.000 4100.000 1400.000 2001.000 + 4200.000 1400.000 2000.000 4200.000 1400.000 2001.000 + 4300.000 1400.000 2000.000 4300.000 1400.000 2001.000 + 4400.000 1400.000 2000.000 4400.000 1400.000 2001.000 + 4500.000 1400.000 2000.000 4500.000 1400.000 2001.000 + 4600.000 1400.000 2000.000 4600.000 1400.000 2001.000 + 4700.000 1400.000 2000.000 4700.000 1400.000 2001.000 + 4800.000 1400.000 2000.000 4800.000 1400.000 2001.000 + 4900.000 1400.000 2000.000 4900.000 1400.000 2001.000 + 5000.000 1400.000 2000.000 5000.000 1400.000 2001.000 + 0.000 1500.000 2000.000 0.000 1500.000 2001.000 + 100.000 1500.000 2000.000 100.000 1500.000 2001.000 + 200.000 1500.000 2000.000 200.000 1500.000 2001.000 + 300.000 1500.000 2000.000 300.000 1500.000 2001.000 + 400.000 1500.000 2000.000 400.000 1500.000 2001.000 + 500.000 1500.000 2000.000 500.000 1500.000 2001.000 + 600.000 1500.000 2000.000 600.000 1500.000 2001.000 + 700.000 1500.000 2000.000 700.000 1500.000 2001.000 + 800.000 1500.000 2000.000 800.000 1500.000 2001.000 + 900.000 1500.000 2000.000 900.000 1500.000 2001.000 + 1000.000 1500.000 2000.000 1000.000 1500.000 2001.000 + 1100.000 1500.000 2000.000 1100.000 1500.000 2001.000 + 1200.000 1500.000 2000.000 1200.000 1500.000 2001.000 + 1300.000 1500.000 2000.000 1300.000 1500.000 2001.000 + 1400.000 1500.000 2000.000 1400.000 1500.000 2001.000 + 1500.000 1500.000 2000.000 1500.000 1500.000 2001.000 + 1600.000 1500.000 2000.000 1600.000 1500.000 2001.000 + 1700.000 1500.000 2000.000 1700.000 1500.000 2001.000 + 1800.000 1500.000 2000.000 1800.000 1500.000 2001.000 + 1900.000 1500.000 2000.000 1900.000 1500.000 2001.000 + 2000.000 1500.000 2000.000 2000.000 1500.000 2001.000 + 2100.000 1500.000 2000.000 2100.000 1500.000 2001.000 + 2200.000 1500.000 2000.000 2200.000 1500.000 2001.000 + 2300.000 1500.000 2000.000 2300.000 1500.000 2001.000 + 2400.000 1500.000 2000.000 2400.000 1500.000 2001.000 + 2500.000 1500.000 2000.000 2500.000 1500.000 2001.000 + 2600.000 1500.000 2000.000 2600.000 1500.000 2001.000 + 2700.000 1500.000 2000.000 2700.000 1500.000 2001.000 + 2800.000 1500.000 2000.000 2800.000 1500.000 2001.000 + 2900.000 1500.000 2000.000 2900.000 1500.000 2001.000 + 3000.000 1500.000 2000.000 3000.000 1500.000 2001.000 + 3100.000 1500.000 2000.000 3100.000 1500.000 2001.000 + 3200.000 1500.000 2000.000 3200.000 1500.000 2001.000 + 3300.000 1500.000 2000.000 3300.000 1500.000 2001.000 + 3400.000 1500.000 2000.000 3400.000 1500.000 2001.000 + 3500.000 1500.000 2000.000 3500.000 1500.000 2001.000 + 3600.000 1500.000 2000.000 3600.000 1500.000 2001.000 + 3700.000 1500.000 2000.000 3700.000 1500.000 2001.000 + 3800.000 1500.000 2000.000 3800.000 1500.000 2001.000 + 3900.000 1500.000 2000.000 3900.000 1500.000 2001.000 + 4000.000 1500.000 2000.000 4000.000 1500.000 2001.000 + 4100.000 1500.000 2000.000 4100.000 1500.000 2001.000 + 4200.000 1500.000 2000.000 4200.000 1500.000 2001.000 + 4300.000 1500.000 2000.000 4300.000 1500.000 2001.000 + 4400.000 1500.000 2000.000 4400.000 1500.000 2001.000 + 4500.000 1500.000 2000.000 4500.000 1500.000 2001.000 + 4600.000 1500.000 2000.000 4600.000 1500.000 2001.000 + 4700.000 1500.000 2000.000 4700.000 1500.000 2001.000 + 4800.000 1500.000 2000.000 4800.000 1500.000 2001.000 + 4900.000 1500.000 2000.000 4900.000 1500.000 2001.000 + 5000.000 1500.000 2000.000 5000.000 1500.000 2001.000 + 0.000 1600.000 2000.000 0.000 1600.000 2001.000 + 100.000 1600.000 2000.000 100.000 1600.000 2001.000 + 200.000 1600.000 2000.000 200.000 1600.000 2001.000 + 300.000 1600.000 2000.000 300.000 1600.000 2001.000 + 400.000 1600.000 2000.000 400.000 1600.000 2001.000 + 500.000 1600.000 2000.000 500.000 1600.000 2001.000 + 600.000 1600.000 2000.000 600.000 1600.000 2001.000 + 700.000 1600.000 2000.000 700.000 1600.000 2001.000 + 800.000 1600.000 2000.000 800.000 1600.000 2001.000 + 900.000 1600.000 2000.000 900.000 1600.000 2001.000 + 1000.000 1600.000 2000.000 1000.000 1600.000 2001.000 + 1100.000 1600.000 2000.000 1100.000 1600.000 2001.000 + 1200.000 1600.000 2000.000 1200.000 1600.000 2001.000 + 1300.000 1600.000 2000.000 1300.000 1600.000 2001.000 + 1400.000 1600.000 2000.000 1400.000 1600.000 2001.000 + 1500.000 1600.000 2000.000 1500.000 1600.000 2001.000 + 1600.000 1600.000 2000.000 1600.000 1600.000 2001.000 + 1700.000 1600.000 2000.000 1700.000 1600.000 2001.000 + 1800.000 1600.000 2000.000 1800.000 1600.000 2001.000 + 1900.000 1600.000 2000.000 1900.000 1600.000 2001.000 + 2000.000 1600.000 2000.000 2000.000 1600.000 2001.000 + 2100.000 1600.000 2000.000 2100.000 1600.000 2001.000 + 2200.000 1600.000 2000.000 2200.000 1600.000 2001.000 + 2300.000 1600.000 2000.000 2300.000 1600.000 2001.000 + 2400.000 1600.000 2000.000 2400.000 1600.000 2001.000 + 2500.000 1600.000 2000.000 2500.000 1600.000 2001.000 + 2600.000 1600.000 2000.000 2600.000 1600.000 2001.000 + 2700.000 1600.000 2000.000 2700.000 1600.000 2001.000 + 2800.000 1600.000 2000.000 2800.000 1600.000 2001.000 + 2900.000 1600.000 2000.000 2900.000 1600.000 2001.000 + 3000.000 1600.000 2000.000 3000.000 1600.000 2001.000 + 3100.000 1600.000 2000.000 3100.000 1600.000 2001.000 + 3200.000 1600.000 2000.000 3200.000 1600.000 2001.000 + 3300.000 1600.000 2000.000 3300.000 1600.000 2001.000 + 3400.000 1600.000 2000.000 3400.000 1600.000 2001.000 + 3500.000 1600.000 2000.000 3500.000 1600.000 2001.000 + 3600.000 1600.000 2000.000 3600.000 1600.000 2001.000 + 3700.000 1600.000 2000.000 3700.000 1600.000 2001.000 + 3800.000 1600.000 2000.000 3800.000 1600.000 2001.000 + 3900.000 1600.000 2000.000 3900.000 1600.000 2001.000 + 4000.000 1600.000 2000.000 4000.000 1600.000 2001.000 + 4100.000 1600.000 2000.000 4100.000 1600.000 2001.000 + 4200.000 1600.000 2000.000 4200.000 1600.000 2001.000 + 4300.000 1600.000 2000.000 4300.000 1600.000 2001.000 + 4400.000 1600.000 2000.000 4400.000 1600.000 2001.000 + 4500.000 1600.000 2000.000 4500.000 1600.000 2001.000 + 4600.000 1600.000 2000.000 4600.000 1600.000 2001.000 + 4700.000 1600.000 2000.000 4700.000 1600.000 2001.000 + 4800.000 1600.000 2000.000 4800.000 1600.000 2001.000 + 4900.000 1600.000 2000.000 4900.000 1600.000 2001.000 + 5000.000 1600.000 2000.000 5000.000 1600.000 2001.000 + 0.000 1700.000 2000.000 0.000 1700.000 2001.000 + 100.000 1700.000 2000.000 100.000 1700.000 2001.000 + 200.000 1700.000 2000.000 200.000 1700.000 2001.000 + 300.000 1700.000 2000.000 300.000 1700.000 2001.000 + 400.000 1700.000 2000.000 400.000 1700.000 2001.000 + 500.000 1700.000 2000.000 500.000 1700.000 2001.000 + 600.000 1700.000 2000.000 600.000 1700.000 2001.000 + 700.000 1700.000 2000.000 700.000 1700.000 2001.000 + 800.000 1700.000 2000.000 800.000 1700.000 2001.000 + 900.000 1700.000 2000.000 900.000 1700.000 2001.000 + 1000.000 1700.000 2000.000 1000.000 1700.000 2001.000 + 1100.000 1700.000 2000.000 1100.000 1700.000 2001.000 + 1200.000 1700.000 2000.000 1200.000 1700.000 2001.000 + 1300.000 1700.000 2000.000 1300.000 1700.000 2001.000 + 1400.000 1700.000 2000.000 1400.000 1700.000 2001.000 + 1500.000 1700.000 2000.000 1500.000 1700.000 2001.000 + 1600.000 1700.000 2000.000 1600.000 1700.000 2001.000 + 1700.000 1700.000 2000.000 1700.000 1700.000 2001.000 + 1800.000 1700.000 2000.000 1800.000 1700.000 2001.000 + 1900.000 1700.000 2000.000 1900.000 1700.000 2001.000 + 2000.000 1700.000 2000.000 2000.000 1700.000 2001.000 + 2100.000 1700.000 2000.000 2100.000 1700.000 2001.000 + 2200.000 1700.000 2000.000 2200.000 1700.000 2001.000 + 2300.000 1700.000 2000.000 2300.000 1700.000 2001.000 + 2400.000 1700.000 2000.000 2400.000 1700.000 2001.000 + 2500.000 1700.000 2000.000 2500.000 1700.000 2001.000 + 2600.000 1700.000 2000.000 2600.000 1700.000 2001.000 + 2700.000 1700.000 2000.000 2700.000 1700.000 2001.000 + 2800.000 1700.000 2000.000 2800.000 1700.000 2001.000 + 2900.000 1700.000 2000.000 2900.000 1700.000 2001.000 + 3000.000 1700.000 2000.000 3000.000 1700.000 2001.000 + 3100.000 1700.000 2000.000 3100.000 1700.000 2001.000 + 3200.000 1700.000 2000.000 3200.000 1700.000 2001.000 + 3300.000 1700.000 2000.000 3300.000 1700.000 2001.000 + 3400.000 1700.000 2000.000 3400.000 1700.000 2001.000 + 3500.000 1700.000 2000.000 3500.000 1700.000 2001.000 + 3600.000 1700.000 2000.000 3600.000 1700.000 2001.000 + 3700.000 1700.000 2000.000 3700.000 1700.000 2001.000 + 3800.000 1700.000 2000.000 3800.000 1700.000 2001.000 + 3900.000 1700.000 2000.000 3900.000 1700.000 2001.000 + 4000.000 1700.000 2000.000 4000.000 1700.000 2001.000 + 4100.000 1700.000 2000.000 4100.000 1700.000 2001.000 + 4200.000 1700.000 2000.000 4200.000 1700.000 2001.000 + 4300.000 1700.000 2000.000 4300.000 1700.000 2001.000 + 4400.000 1700.000 2000.000 4400.000 1700.000 2001.000 + 4500.000 1700.000 2000.000 4500.000 1700.000 2001.000 + 4600.000 1700.000 2000.000 4600.000 1700.000 2001.000 + 4700.000 1700.000 2000.000 4700.000 1700.000 2001.000 + 4800.000 1700.000 2000.000 4800.000 1700.000 2001.000 + 4900.000 1700.000 2000.000 4900.000 1700.000 2001.000 + 5000.000 1700.000 2000.000 5000.000 1700.000 2001.000 + 0.000 1800.000 2000.000 0.000 1800.000 2001.000 + 100.000 1800.000 2000.000 100.000 1800.000 2001.000 + 200.000 1800.000 2000.000 200.000 1800.000 2001.000 + 300.000 1800.000 2000.000 300.000 1800.000 2001.000 + 400.000 1800.000 2000.000 400.000 1800.000 2001.000 + 500.000 1800.000 2000.000 500.000 1800.000 2001.000 + 600.000 1800.000 2000.000 600.000 1800.000 2001.000 + 700.000 1800.000 2000.000 700.000 1800.000 2001.000 + 800.000 1800.000 2000.000 800.000 1800.000 2001.000 + 900.000 1800.000 2000.000 900.000 1800.000 2001.000 + 1000.000 1800.000 2000.000 1000.000 1800.000 2001.000 + 1100.000 1800.000 2000.000 1100.000 1800.000 2001.000 + 1200.000 1800.000 2000.000 1200.000 1800.000 2001.000 + 1300.000 1800.000 2000.000 1300.000 1800.000 2001.000 + 1400.000 1800.000 2000.000 1400.000 1800.000 2001.000 + 1500.000 1800.000 2000.000 1500.000 1800.000 2001.000 + 1600.000 1800.000 2000.000 1600.000 1800.000 2001.000 + 1700.000 1800.000 2000.000 1700.000 1800.000 2001.000 + 1800.000 1800.000 2000.000 1800.000 1800.000 2001.000 + 1900.000 1800.000 2000.000 1900.000 1800.000 2001.000 + 2000.000 1800.000 2000.000 2000.000 1800.000 2001.000 + 2100.000 1800.000 2000.000 2100.000 1800.000 2001.000 + 2200.000 1800.000 2000.000 2200.000 1800.000 2001.000 + 2300.000 1800.000 2000.000 2300.000 1800.000 2001.000 + 2400.000 1800.000 2000.000 2400.000 1800.000 2001.000 + 2500.000 1800.000 2000.000 2500.000 1800.000 2001.000 + 2600.000 1800.000 2000.000 2600.000 1800.000 2001.000 + 2700.000 1800.000 2000.000 2700.000 1800.000 2001.000 + 2800.000 1800.000 2000.000 2800.000 1800.000 2001.000 + 2900.000 1800.000 2000.000 2900.000 1800.000 2001.000 + 3000.000 1800.000 2000.000 3000.000 1800.000 2001.000 + 3100.000 1800.000 2000.000 3100.000 1800.000 2001.000 + 3200.000 1800.000 2000.000 3200.000 1800.000 2001.000 + 3300.000 1800.000 2000.000 3300.000 1800.000 2001.000 + 3400.000 1800.000 2000.000 3400.000 1800.000 2001.000 + 3500.000 1800.000 2000.000 3500.000 1800.000 2001.000 + 3600.000 1800.000 2000.000 3600.000 1800.000 2001.000 + 3700.000 1800.000 2000.000 3700.000 1800.000 2001.000 + 3800.000 1800.000 2000.000 3800.000 1800.000 2001.000 + 3900.000 1800.000 2000.000 3900.000 1800.000 2001.000 + 4000.000 1800.000 2000.000 4000.000 1800.000 2001.000 + 4100.000 1800.000 2000.000 4100.000 1800.000 2001.000 + 4200.000 1800.000 2000.000 4200.000 1800.000 2001.000 + 4300.000 1800.000 2000.000 4300.000 1800.000 2001.000 + 4400.000 1800.000 2000.000 4400.000 1800.000 2001.000 + 4500.000 1800.000 2000.000 4500.000 1800.000 2001.000 + 4600.000 1800.000 2000.000 4600.000 1800.000 2001.000 + 4700.000 1800.000 2000.000 4700.000 1800.000 2001.000 + 4800.000 1800.000 2000.000 4800.000 1800.000 2001.000 + 4900.000 1800.000 2000.000 4900.000 1800.000 2001.000 + 5000.000 1800.000 2000.000 5000.000 1800.000 2001.000 + 0.000 1900.000 2000.000 0.000 1900.000 2001.000 + 100.000 1900.000 2000.000 100.000 1900.000 2001.000 + 200.000 1900.000 2000.000 200.000 1900.000 2001.000 + 300.000 1900.000 2000.000 300.000 1900.000 2001.000 + 400.000 1900.000 2000.000 400.000 1900.000 2001.000 + 500.000 1900.000 2000.000 500.000 1900.000 2001.000 + 600.000 1900.000 2000.000 600.000 1900.000 2001.000 + 700.000 1900.000 2000.000 700.000 1900.000 2001.000 + 800.000 1900.000 2000.000 800.000 1900.000 2001.000 + 900.000 1900.000 2000.000 900.000 1900.000 2001.000 + 1000.000 1900.000 2000.000 1000.000 1900.000 2001.000 + 1100.000 1900.000 2000.000 1100.000 1900.000 2001.000 + 1200.000 1900.000 2000.000 1200.000 1900.000 2001.000 + 1300.000 1900.000 2000.000 1300.000 1900.000 2001.000 + 1400.000 1900.000 2000.000 1400.000 1900.000 2001.000 + 1500.000 1900.000 2000.000 1500.000 1900.000 2001.000 + 1600.000 1900.000 2000.000 1600.000 1900.000 2001.000 + 1700.000 1900.000 2000.000 1700.000 1900.000 2001.000 + 1800.000 1900.000 2000.000 1800.000 1900.000 2001.000 + 1900.000 1900.000 2000.000 1900.000 1900.000 2001.000 + 2000.000 1900.000 2000.000 2000.000 1900.000 2001.000 + 2100.000 1900.000 2000.000 2100.000 1900.000 2001.000 + 2200.000 1900.000 2000.000 2200.000 1900.000 2001.000 + 2300.000 1900.000 2000.000 2300.000 1900.000 2001.000 + 2400.000 1900.000 2000.000 2400.000 1900.000 2001.000 + 2500.000 1900.000 2000.000 2500.000 1900.000 2001.000 + 2600.000 1900.000 2000.000 2600.000 1900.000 2001.000 + 2700.000 1900.000 2000.000 2700.000 1900.000 2001.000 + 2800.000 1900.000 2000.000 2800.000 1900.000 2001.000 + 2900.000 1900.000 2000.000 2900.000 1900.000 2001.000 + 3000.000 1900.000 2000.000 3000.000 1900.000 2001.000 + 3100.000 1900.000 2000.000 3100.000 1900.000 2001.000 + 3200.000 1900.000 2000.000 3200.000 1900.000 2001.000 + 3300.000 1900.000 2000.000 3300.000 1900.000 2001.000 + 3400.000 1900.000 2000.000 3400.000 1900.000 2001.000 + 3500.000 1900.000 2000.000 3500.000 1900.000 2001.000 + 3600.000 1900.000 2000.000 3600.000 1900.000 2001.000 + 3700.000 1900.000 2000.000 3700.000 1900.000 2001.000 + 3800.000 1900.000 2000.000 3800.000 1900.000 2001.000 + 3900.000 1900.000 2000.000 3900.000 1900.000 2001.000 + 4000.000 1900.000 2000.000 4000.000 1900.000 2001.000 + 4100.000 1900.000 2000.000 4100.000 1900.000 2001.000 + 4200.000 1900.000 2000.000 4200.000 1900.000 2001.000 + 4300.000 1900.000 2000.000 4300.000 1900.000 2001.000 + 4400.000 1900.000 2000.000 4400.000 1900.000 2001.000 + 4500.000 1900.000 2000.000 4500.000 1900.000 2001.000 + 4600.000 1900.000 2000.000 4600.000 1900.000 2001.000 + 4700.000 1900.000 2000.000 4700.000 1900.000 2001.000 + 4800.000 1900.000 2000.000 4800.000 1900.000 2001.000 + 4900.000 1900.000 2000.000 4900.000 1900.000 2001.000 + 5000.000 1900.000 2000.000 5000.000 1900.000 2001.000 + 0.000 2000.000 2000.000 0.000 2000.000 2001.000 + 100.000 2000.000 2000.000 100.000 2000.000 2001.000 + 200.000 2000.000 2000.000 200.000 2000.000 2001.000 + 300.000 2000.000 2000.000 300.000 2000.000 2001.000 + 400.000 2000.000 2000.000 400.000 2000.000 2001.000 + 500.000 2000.000 2000.000 500.000 2000.000 2001.000 + 600.000 2000.000 2000.000 600.000 2000.000 2001.000 + 700.000 2000.000 2000.000 700.000 2000.000 2001.000 + 800.000 2000.000 2000.000 800.000 2000.000 2001.000 + 900.000 2000.000 2000.000 900.000 2000.000 2001.000 + 1000.000 2000.000 2000.000 1000.000 2000.000 2001.000 + 1100.000 2000.000 2000.000 1100.000 2000.000 2001.000 + 1200.000 2000.000 2000.000 1200.000 2000.000 2001.000 + 1300.000 2000.000 2000.000 1300.000 2000.000 2001.000 + 1400.000 2000.000 2000.000 1400.000 2000.000 2001.000 + 1500.000 2000.000 2000.000 1500.000 2000.000 2001.000 + 1600.000 2000.000 2000.000 1600.000 2000.000 2001.000 + 1700.000 2000.000 2000.000 1700.000 2000.000 2001.000 + 1800.000 2000.000 2000.000 1800.000 2000.000 2001.000 + 1900.000 2000.000 2000.000 1900.000 2000.000 2001.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2001.000 + 2100.000 2000.000 2000.000 2100.000 2000.000 2001.000 + 2200.000 2000.000 2000.000 2200.000 2000.000 2001.000 + 2300.000 2000.000 2000.000 2300.000 2000.000 2001.000 + 2400.000 2000.000 2000.000 2400.000 2000.000 2001.000 + 2500.000 2000.000 2000.000 2500.000 2000.000 2001.000 + 2600.000 2000.000 2000.000 2600.000 2000.000 2001.000 + 2700.000 2000.000 2000.000 2700.000 2000.000 2001.000 + 2800.000 2000.000 2000.000 2800.000 2000.000 2001.000 + 2900.000 2000.000 2000.000 2900.000 2000.000 2001.000 + 3000.000 2000.000 2000.000 3000.000 2000.000 2001.000 + 3100.000 2000.000 2000.000 3100.000 2000.000 2001.000 + 3200.000 2000.000 2000.000 3200.000 2000.000 2001.000 + 3300.000 2000.000 2000.000 3300.000 2000.000 2001.000 + 3400.000 2000.000 2000.000 3400.000 2000.000 2001.000 + 3500.000 2000.000 2000.000 3500.000 2000.000 2001.000 + 3600.000 2000.000 2000.000 3600.000 2000.000 2001.000 + 3700.000 2000.000 2000.000 3700.000 2000.000 2001.000 + 3800.000 2000.000 2000.000 3800.000 2000.000 2001.000 + 3900.000 2000.000 2000.000 3900.000 2000.000 2001.000 + 4000.000 2000.000 2000.000 4000.000 2000.000 2001.000 + 4100.000 2000.000 2000.000 4100.000 2000.000 2001.000 + 4200.000 2000.000 2000.000 4200.000 2000.000 2001.000 + 4300.000 2000.000 2000.000 4300.000 2000.000 2001.000 + 4400.000 2000.000 2000.000 4400.000 2000.000 2001.000 + 4500.000 2000.000 2000.000 4500.000 2000.000 2001.000 + 4600.000 2000.000 2000.000 4600.000 2000.000 2001.000 + 4700.000 2000.000 2000.000 4700.000 2000.000 2001.000 + 4800.000 2000.000 2000.000 4800.000 2000.000 2001.000 + 4900.000 2000.000 2000.000 4900.000 2000.000 2001.000 + 5000.000 2000.000 2000.000 5000.000 2000.000 2001.000 + 0.000 2100.000 2000.000 0.000 2100.000 2001.000 + 100.000 2100.000 2000.000 100.000 2100.000 2001.000 + 200.000 2100.000 2000.000 200.000 2100.000 2001.000 + 300.000 2100.000 2000.000 300.000 2100.000 2001.000 + 400.000 2100.000 2000.000 400.000 2100.000 2001.000 + 500.000 2100.000 2000.000 500.000 2100.000 2001.000 + 600.000 2100.000 2000.000 600.000 2100.000 2001.000 + 700.000 2100.000 2000.000 700.000 2100.000 2001.000 + 800.000 2100.000 2000.000 800.000 2100.000 2001.000 + 900.000 2100.000 2000.000 900.000 2100.000 2001.000 + 1000.000 2100.000 2000.000 1000.000 2100.000 2001.000 + 1100.000 2100.000 2000.000 1100.000 2100.000 2001.000 + 1200.000 2100.000 2000.000 1200.000 2100.000 2001.000 + 1300.000 2100.000 2000.000 1300.000 2100.000 2001.000 + 1400.000 2100.000 2000.000 1400.000 2100.000 2001.000 + 1500.000 2100.000 2000.000 1500.000 2100.000 2001.000 + 1600.000 2100.000 2000.000 1600.000 2100.000 2001.000 + 1700.000 2100.000 2000.000 1700.000 2100.000 2001.000 + 1800.000 2100.000 2000.000 1800.000 2100.000 2001.000 + 1900.000 2100.000 2000.000 1900.000 2100.000 2001.000 + 2000.000 2100.000 2000.000 2000.000 2100.000 2001.000 + 2100.000 2100.000 2000.000 2100.000 2100.000 2001.000 + 2200.000 2100.000 2000.000 2200.000 2100.000 2001.000 + 2300.000 2100.000 2000.000 2300.000 2100.000 2001.000 + 2400.000 2100.000 2000.000 2400.000 2100.000 2001.000 + 2500.000 2100.000 2000.000 2500.000 2100.000 2001.000 + 2600.000 2100.000 2000.000 2600.000 2100.000 2001.000 + 2700.000 2100.000 2000.000 2700.000 2100.000 2001.000 + 2800.000 2100.000 2000.000 2800.000 2100.000 2001.000 + 2900.000 2100.000 2000.000 2900.000 2100.000 2001.000 + 3000.000 2100.000 2000.000 3000.000 2100.000 2001.000 + 3100.000 2100.000 2000.000 3100.000 2100.000 2001.000 + 3200.000 2100.000 2000.000 3200.000 2100.000 2001.000 + 3300.000 2100.000 2000.000 3300.000 2100.000 2001.000 + 3400.000 2100.000 2000.000 3400.000 2100.000 2001.000 + 3500.000 2100.000 2000.000 3500.000 2100.000 2001.000 + 3600.000 2100.000 2000.000 3600.000 2100.000 2001.000 + 3700.000 2100.000 2000.000 3700.000 2100.000 2001.000 + 3800.000 2100.000 2000.000 3800.000 2100.000 2001.000 + 3900.000 2100.000 2000.000 3900.000 2100.000 2001.000 + 4000.000 2100.000 2000.000 4000.000 2100.000 2001.000 + 4100.000 2100.000 2000.000 4100.000 2100.000 2001.000 + 4200.000 2100.000 2000.000 4200.000 2100.000 2001.000 + 4300.000 2100.000 2000.000 4300.000 2100.000 2001.000 + 4400.000 2100.000 2000.000 4400.000 2100.000 2001.000 + 4500.000 2100.000 2000.000 4500.000 2100.000 2001.000 + 4600.000 2100.000 2000.000 4600.000 2100.000 2001.000 + 4700.000 2100.000 2000.000 4700.000 2100.000 2001.000 + 4800.000 2100.000 2000.000 4800.000 2100.000 2001.000 + 4900.000 2100.000 2000.000 4900.000 2100.000 2001.000 + 5000.000 2100.000 2000.000 5000.000 2100.000 2001.000 + 0.000 2200.000 2000.000 0.000 2200.000 2001.000 + 100.000 2200.000 2000.000 100.000 2200.000 2001.000 + 200.000 2200.000 2000.000 200.000 2200.000 2001.000 + 300.000 2200.000 2000.000 300.000 2200.000 2001.000 + 400.000 2200.000 2000.000 400.000 2200.000 2001.000 + 500.000 2200.000 2000.000 500.000 2200.000 2001.000 + 600.000 2200.000 2000.000 600.000 2200.000 2001.000 + 700.000 2200.000 2000.000 700.000 2200.000 2001.000 + 800.000 2200.000 2000.000 800.000 2200.000 2001.000 + 900.000 2200.000 2000.000 900.000 2200.000 2001.000 + 1000.000 2200.000 2000.000 1000.000 2200.000 2001.000 + 1100.000 2200.000 2000.000 1100.000 2200.000 2001.000 + 1200.000 2200.000 2000.000 1200.000 2200.000 2001.000 + 1300.000 2200.000 2000.000 1300.000 2200.000 2001.000 + 1400.000 2200.000 2000.000 1400.000 2200.000 2001.000 + 1500.000 2200.000 2000.000 1500.000 2200.000 2001.000 + 1600.000 2200.000 2000.000 1600.000 2200.000 2001.000 + 1700.000 2200.000 2000.000 1700.000 2200.000 2001.000 + 1800.000 2200.000 2000.000 1800.000 2200.000 2001.000 + 1900.000 2200.000 2000.000 1900.000 2200.000 2001.000 + 2000.000 2200.000 2000.000 2000.000 2200.000 2001.000 + 2100.000 2200.000 2000.000 2100.000 2200.000 2001.000 + 2200.000 2200.000 2000.000 2200.000 2200.000 2001.000 + 2300.000 2200.000 2000.000 2300.000 2200.000 2001.000 + 2400.000 2200.000 2000.000 2400.000 2200.000 2001.000 + 2500.000 2200.000 2000.000 2500.000 2200.000 2001.000 + 2600.000 2200.000 2000.000 2600.000 2200.000 2001.000 + 2700.000 2200.000 2000.000 2700.000 2200.000 2001.000 + 2800.000 2200.000 2000.000 2800.000 2200.000 2001.000 + 2900.000 2200.000 2000.000 2900.000 2200.000 2001.000 + 3000.000 2200.000 2000.000 3000.000 2200.000 2001.000 + 3100.000 2200.000 2000.000 3100.000 2200.000 2001.000 + 3200.000 2200.000 2000.000 3200.000 2200.000 2001.000 + 3300.000 2200.000 2000.000 3300.000 2200.000 2001.000 + 3400.000 2200.000 2000.000 3400.000 2200.000 2001.000 + 3500.000 2200.000 2000.000 3500.000 2200.000 2001.000 + 3600.000 2200.000 2000.000 3600.000 2200.000 2001.000 + 3700.000 2200.000 2000.000 3700.000 2200.000 2001.000 + 3800.000 2200.000 2000.000 3800.000 2200.000 2001.000 + 3900.000 2200.000 2000.000 3900.000 2200.000 2001.000 + 4000.000 2200.000 2000.000 4000.000 2200.000 2001.000 + 4100.000 2200.000 2000.000 4100.000 2200.000 2001.000 + 4200.000 2200.000 2000.000 4200.000 2200.000 2001.000 + 4300.000 2200.000 2000.000 4300.000 2200.000 2001.000 + 4400.000 2200.000 2000.000 4400.000 2200.000 2001.000 + 4500.000 2200.000 2000.000 4500.000 2200.000 2001.000 + 4600.000 2200.000 2000.000 4600.000 2200.000 2001.000 + 4700.000 2200.000 2000.000 4700.000 2200.000 2001.000 + 4800.000 2200.000 2000.000 4800.000 2200.000 2001.000 + 4900.000 2200.000 2000.000 4900.000 2200.000 2001.000 + 5000.000 2200.000 2000.000 5000.000 2200.000 2001.000 + 0.000 2300.000 2000.000 0.000 2300.000 2001.000 + 100.000 2300.000 2000.000 100.000 2300.000 2001.000 + 200.000 2300.000 2000.000 200.000 2300.000 2001.000 + 300.000 2300.000 2000.000 300.000 2300.000 2001.000 + 400.000 2300.000 2000.000 400.000 2300.000 2001.000 + 500.000 2300.000 2000.000 500.000 2300.000 2001.000 + 600.000 2300.000 2000.000 600.000 2300.000 2001.000 + 700.000 2300.000 2000.000 700.000 2300.000 2001.000 + 800.000 2300.000 2000.000 800.000 2300.000 2001.000 + 900.000 2300.000 2000.000 900.000 2300.000 2001.000 + 1000.000 2300.000 2000.000 1000.000 2300.000 2001.000 + 1100.000 2300.000 2000.000 1100.000 2300.000 2001.000 + 1200.000 2300.000 2000.000 1200.000 2300.000 2001.000 + 1300.000 2300.000 2000.000 1300.000 2300.000 2001.000 + 1400.000 2300.000 2000.000 1400.000 2300.000 2001.000 + 1500.000 2300.000 2000.000 1500.000 2300.000 2001.000 + 1600.000 2300.000 2000.000 1600.000 2300.000 2001.000 + 1700.000 2300.000 2000.000 1700.000 2300.000 2001.000 + 1800.000 2300.000 2000.000 1800.000 2300.000 2001.000 + 1900.000 2300.000 2000.000 1900.000 2300.000 2001.000 + 2000.000 2300.000 2000.000 2000.000 2300.000 2001.000 + 2100.000 2300.000 2000.000 2100.000 2300.000 2001.000 + 2200.000 2300.000 2000.000 2200.000 2300.000 2001.000 + 2300.000 2300.000 2000.000 2300.000 2300.000 2001.000 + 2400.000 2300.000 2000.000 2400.000 2300.000 2001.000 + 2500.000 2300.000 2000.000 2500.000 2300.000 2001.000 + 2600.000 2300.000 2000.000 2600.000 2300.000 2001.000 + 2700.000 2300.000 2000.000 2700.000 2300.000 2001.000 + 2800.000 2300.000 2000.000 2800.000 2300.000 2001.000 + 2900.000 2300.000 2000.000 2900.000 2300.000 2001.000 + 3000.000 2300.000 2000.000 3000.000 2300.000 2001.000 + 3100.000 2300.000 2000.000 3100.000 2300.000 2001.000 + 3200.000 2300.000 2000.000 3200.000 2300.000 2001.000 + 3300.000 2300.000 2000.000 3300.000 2300.000 2001.000 + 3400.000 2300.000 2000.000 3400.000 2300.000 2001.000 + 3500.000 2300.000 2000.000 3500.000 2300.000 2001.000 + 3600.000 2300.000 2000.000 3600.000 2300.000 2001.000 + 3700.000 2300.000 2000.000 3700.000 2300.000 2001.000 + 3800.000 2300.000 2000.000 3800.000 2300.000 2001.000 + 3900.000 2300.000 2000.000 3900.000 2300.000 2001.000 + 4000.000 2300.000 2000.000 4000.000 2300.000 2001.000 + 4100.000 2300.000 2000.000 4100.000 2300.000 2001.000 + 4200.000 2300.000 2000.000 4200.000 2300.000 2001.000 + 4300.000 2300.000 2000.000 4300.000 2300.000 2001.000 + 4400.000 2300.000 2000.000 4400.000 2300.000 2001.000 + 4500.000 2300.000 2000.000 4500.000 2300.000 2001.000 + 4600.000 2300.000 2000.000 4600.000 2300.000 2001.000 + 4700.000 2300.000 2000.000 4700.000 2300.000 2001.000 + 4800.000 2300.000 2000.000 4800.000 2300.000 2001.000 + 4900.000 2300.000 2000.000 4900.000 2300.000 2001.000 + 5000.000 2300.000 2000.000 5000.000 2300.000 2001.000 + 0.000 2400.000 2000.000 0.000 2400.000 2001.000 + 100.000 2400.000 2000.000 100.000 2400.000 2001.000 + 200.000 2400.000 2000.000 200.000 2400.000 2001.000 + 300.000 2400.000 2000.000 300.000 2400.000 2001.000 + 400.000 2400.000 2000.000 400.000 2400.000 2001.000 + 500.000 2400.000 2000.000 500.000 2400.000 2001.000 + 600.000 2400.000 2000.000 600.000 2400.000 2001.000 + 700.000 2400.000 2000.000 700.000 2400.000 2001.000 + 800.000 2400.000 2000.000 800.000 2400.000 2001.000 + 900.000 2400.000 2000.000 900.000 2400.000 2001.000 + 1000.000 2400.000 2000.000 1000.000 2400.000 2001.000 + 1100.000 2400.000 2000.000 1100.000 2400.000 2001.000 + 1200.000 2400.000 2000.000 1200.000 2400.000 2001.000 + 1300.000 2400.000 2000.000 1300.000 2400.000 2001.000 + 1400.000 2400.000 2000.000 1400.000 2400.000 2001.000 + 1500.000 2400.000 2000.000 1500.000 2400.000 2001.000 + 1600.000 2400.000 2000.000 1600.000 2400.000 2001.000 + 1700.000 2400.000 2000.000 1700.000 2400.000 2001.000 + 1800.000 2400.000 2000.000 1800.000 2400.000 2001.000 + 1900.000 2400.000 2000.000 1900.000 2400.000 2001.000 + 2000.000 2400.000 2000.000 2000.000 2400.000 2001.000 + 2100.000 2400.000 2000.000 2100.000 2400.000 2001.000 + 2200.000 2400.000 2000.000 2200.000 2400.000 2001.000 + 2300.000 2400.000 2000.000 2300.000 2400.000 2001.000 + 2400.000 2400.000 2000.000 2400.000 2400.000 2001.000 + 2500.000 2400.000 2000.000 2500.000 2400.000 2001.000 + 2600.000 2400.000 2000.000 2600.000 2400.000 2001.000 + 2700.000 2400.000 2000.000 2700.000 2400.000 2001.000 + 2800.000 2400.000 2000.000 2800.000 2400.000 2001.000 + 2900.000 2400.000 2000.000 2900.000 2400.000 2001.000 + 3000.000 2400.000 2000.000 3000.000 2400.000 2001.000 + 3100.000 2400.000 2000.000 3100.000 2400.000 2001.000 + 3200.000 2400.000 2000.000 3200.000 2400.000 2001.000 + 3300.000 2400.000 2000.000 3300.000 2400.000 2001.000 + 3400.000 2400.000 2000.000 3400.000 2400.000 2001.000 + 3500.000 2400.000 2000.000 3500.000 2400.000 2001.000 + 3600.000 2400.000 2000.000 3600.000 2400.000 2001.000 + 3700.000 2400.000 2000.000 3700.000 2400.000 2001.000 + 3800.000 2400.000 2000.000 3800.000 2400.000 2001.000 + 3900.000 2400.000 2000.000 3900.000 2400.000 2001.000 + 4000.000 2400.000 2000.000 4000.000 2400.000 2001.000 + 4100.000 2400.000 2000.000 4100.000 2400.000 2001.000 + 4200.000 2400.000 2000.000 4200.000 2400.000 2001.000 + 4300.000 2400.000 2000.000 4300.000 2400.000 2001.000 + 4400.000 2400.000 2000.000 4400.000 2400.000 2001.000 + 4500.000 2400.000 2000.000 4500.000 2400.000 2001.000 + 4600.000 2400.000 2000.000 4600.000 2400.000 2001.000 + 4700.000 2400.000 2000.000 4700.000 2400.000 2001.000 + 4800.000 2400.000 2000.000 4800.000 2400.000 2001.000 + 4900.000 2400.000 2000.000 4900.000 2400.000 2001.000 + 5000.000 2400.000 2000.000 5000.000 2400.000 2001.000 + 0.000 2500.000 2000.000 0.000 2500.000 2001.000 + 100.000 2500.000 2000.000 100.000 2500.000 2001.000 + 200.000 2500.000 2000.000 200.000 2500.000 2001.000 + 300.000 2500.000 2000.000 300.000 2500.000 2001.000 + 400.000 2500.000 2000.000 400.000 2500.000 2001.000 + 500.000 2500.000 2000.000 500.000 2500.000 2001.000 + 600.000 2500.000 2000.000 600.000 2500.000 2001.000 + 700.000 2500.000 2000.000 700.000 2500.000 2001.000 + 800.000 2500.000 2000.000 800.000 2500.000 2001.000 + 900.000 2500.000 2000.000 900.000 2500.000 2001.000 + 1000.000 2500.000 2000.000 1000.000 2500.000 2001.000 + 1100.000 2500.000 2000.000 1100.000 2500.000 2001.000 + 1200.000 2500.000 2000.000 1200.000 2500.000 2001.000 + 1300.000 2500.000 2000.000 1300.000 2500.000 2001.000 + 1400.000 2500.000 2000.000 1400.000 2500.000 2001.000 + 1500.000 2500.000 2000.000 1500.000 2500.000 2001.000 + 1600.000 2500.000 2000.000 1600.000 2500.000 2001.000 + 1700.000 2500.000 2000.000 1700.000 2500.000 2001.000 + 1800.000 2500.000 2000.000 1800.000 2500.000 2001.000 + 1900.000 2500.000 2000.000 1900.000 2500.000 2001.000 + 2000.000 2500.000 2000.000 2000.000 2500.000 2001.000 + 2100.000 2500.000 2000.000 2100.000 2500.000 2001.000 + 2200.000 2500.000 2000.000 2200.000 2500.000 2001.000 + 2300.000 2500.000 2000.000 2300.000 2500.000 2001.000 + 2400.000 2500.000 2000.000 2400.000 2500.000 2001.000 + 2500.000 2500.000 2000.000 2500.000 2500.000 2001.000 + 2600.000 2500.000 2000.000 2600.000 2500.000 2001.000 + 2700.000 2500.000 2000.000 2700.000 2500.000 2001.000 + 2800.000 2500.000 2000.000 2800.000 2500.000 2001.000 + 2900.000 2500.000 2000.000 2900.000 2500.000 2001.000 + 3000.000 2500.000 2000.000 3000.000 2500.000 2001.000 + 3100.000 2500.000 2000.000 3100.000 2500.000 2001.000 + 3200.000 2500.000 2000.000 3200.000 2500.000 2001.000 + 3300.000 2500.000 2000.000 3300.000 2500.000 2001.000 + 3400.000 2500.000 2000.000 3400.000 2500.000 2001.000 + 3500.000 2500.000 2000.000 3500.000 2500.000 2001.000 + 3600.000 2500.000 2000.000 3600.000 2500.000 2001.000 + 3700.000 2500.000 2000.000 3700.000 2500.000 2001.000 + 3800.000 2500.000 2000.000 3800.000 2500.000 2001.000 + 3900.000 2500.000 2000.000 3900.000 2500.000 2001.000 + 4000.000 2500.000 2000.000 4000.000 2500.000 2001.000 + 4100.000 2500.000 2000.000 4100.000 2500.000 2001.000 + 4200.000 2500.000 2000.000 4200.000 2500.000 2001.000 + 4300.000 2500.000 2000.000 4300.000 2500.000 2001.000 + 4400.000 2500.000 2000.000 4400.000 2500.000 2001.000 + 4500.000 2500.000 2000.000 4500.000 2500.000 2001.000 + 4600.000 2500.000 2000.000 4600.000 2500.000 2001.000 + 4700.000 2500.000 2000.000 4700.000 2500.000 2001.000 + 4800.000 2500.000 2000.000 4800.000 2500.000 2001.000 + 4900.000 2500.000 2000.000 4900.000 2500.000 2001.000 + 5000.000 2500.000 2000.000 5000.000 2500.000 2001.000 + 0.000 2600.000 2000.000 0.000 2600.000 2001.000 + 100.000 2600.000 2000.000 100.000 2600.000 2001.000 + 200.000 2600.000 2000.000 200.000 2600.000 2001.000 + 300.000 2600.000 2000.000 300.000 2600.000 2001.000 + 400.000 2600.000 2000.000 400.000 2600.000 2001.000 + 500.000 2600.000 2000.000 500.000 2600.000 2001.000 + 600.000 2600.000 2000.000 600.000 2600.000 2001.000 + 700.000 2600.000 2000.000 700.000 2600.000 2001.000 + 800.000 2600.000 2000.000 800.000 2600.000 2001.000 + 900.000 2600.000 2000.000 900.000 2600.000 2001.000 + 1000.000 2600.000 2000.000 1000.000 2600.000 2001.000 + 1100.000 2600.000 2000.000 1100.000 2600.000 2001.000 + 1200.000 2600.000 2000.000 1200.000 2600.000 2001.000 + 1300.000 2600.000 2000.000 1300.000 2600.000 2001.000 + 1400.000 2600.000 2000.000 1400.000 2600.000 2001.000 + 1500.000 2600.000 2000.000 1500.000 2600.000 2001.000 + 1600.000 2600.000 2000.000 1600.000 2600.000 2001.000 + 1700.000 2600.000 2000.000 1700.000 2600.000 2001.000 + 1800.000 2600.000 2000.000 1800.000 2600.000 2001.000 + 1900.000 2600.000 2000.000 1900.000 2600.000 2001.000 + 2000.000 2600.000 2000.000 2000.000 2600.000 2001.000 + 2100.000 2600.000 2000.000 2100.000 2600.000 2001.000 + 2200.000 2600.000 2000.000 2200.000 2600.000 2001.000 + 2300.000 2600.000 2000.000 2300.000 2600.000 2001.000 + 2400.000 2600.000 2000.000 2400.000 2600.000 2001.000 + 2500.000 2600.000 2000.000 2500.000 2600.000 2001.000 + 2600.000 2600.000 2000.000 2600.000 2600.000 2001.000 + 2700.000 2600.000 2000.000 2700.000 2600.000 2001.000 + 2800.000 2600.000 2000.000 2800.000 2600.000 2001.000 + 2900.000 2600.000 2000.000 2900.000 2600.000 2001.000 + 3000.000 2600.000 2000.000 3000.000 2600.000 2001.000 + 3100.000 2600.000 2000.000 3100.000 2600.000 2001.000 + 3200.000 2600.000 2000.000 3200.000 2600.000 2001.000 + 3300.000 2600.000 2000.000 3300.000 2600.000 2001.000 + 3400.000 2600.000 2000.000 3400.000 2600.000 2001.000 + 3500.000 2600.000 2000.000 3500.000 2600.000 2001.000 + 3600.000 2600.000 2000.000 3600.000 2600.000 2001.000 + 3700.000 2600.000 2000.000 3700.000 2600.000 2001.000 + 3800.000 2600.000 2000.000 3800.000 2600.000 2001.000 + 3900.000 2600.000 2000.000 3900.000 2600.000 2001.000 + 4000.000 2600.000 2000.000 4000.000 2600.000 2001.000 + 4100.000 2600.000 2000.000 4100.000 2600.000 2001.000 + 4200.000 2600.000 2000.000 4200.000 2600.000 2001.000 + 4300.000 2600.000 2000.000 4300.000 2600.000 2001.000 + 4400.000 2600.000 2000.000 4400.000 2600.000 2001.000 + 4500.000 2600.000 2000.000 4500.000 2600.000 2001.000 + 4600.000 2600.000 2000.000 4600.000 2600.000 2001.000 + 4700.000 2600.000 2000.000 4700.000 2600.000 2001.000 + 4800.000 2600.000 2000.000 4800.000 2600.000 2001.000 + 4900.000 2600.000 2000.000 4900.000 2600.000 2001.000 + 5000.000 2600.000 2000.000 5000.000 2600.000 2001.000 + 0.000 2700.000 2000.000 0.000 2700.000 2001.000 + 100.000 2700.000 2000.000 100.000 2700.000 2001.000 + 200.000 2700.000 2000.000 200.000 2700.000 2001.000 + 300.000 2700.000 2000.000 300.000 2700.000 2001.000 + 400.000 2700.000 2000.000 400.000 2700.000 2001.000 + 500.000 2700.000 2000.000 500.000 2700.000 2001.000 + 600.000 2700.000 2000.000 600.000 2700.000 2001.000 + 700.000 2700.000 2000.000 700.000 2700.000 2001.000 + 800.000 2700.000 2000.000 800.000 2700.000 2001.000 + 900.000 2700.000 2000.000 900.000 2700.000 2001.000 + 1000.000 2700.000 2000.000 1000.000 2700.000 2001.000 + 1100.000 2700.000 2000.000 1100.000 2700.000 2001.000 + 1200.000 2700.000 2000.000 1200.000 2700.000 2001.000 + 1300.000 2700.000 2000.000 1300.000 2700.000 2001.000 + 1400.000 2700.000 2000.000 1400.000 2700.000 2001.000 + 1500.000 2700.000 2000.000 1500.000 2700.000 2001.000 + 1600.000 2700.000 2000.000 1600.000 2700.000 2001.000 + 1700.000 2700.000 2000.000 1700.000 2700.000 2001.000 + 1800.000 2700.000 2000.000 1800.000 2700.000 2001.000 + 1900.000 2700.000 2000.000 1900.000 2700.000 2001.000 + 2000.000 2700.000 2000.000 2000.000 2700.000 2001.000 + 2100.000 2700.000 2000.000 2100.000 2700.000 2001.000 + 2200.000 2700.000 2000.000 2200.000 2700.000 2001.000 + 2300.000 2700.000 2000.000 2300.000 2700.000 2001.000 + 2400.000 2700.000 2000.000 2400.000 2700.000 2001.000 + 2500.000 2700.000 2000.000 2500.000 2700.000 2001.000 + 2600.000 2700.000 2000.000 2600.000 2700.000 2001.000 + 2700.000 2700.000 2000.000 2700.000 2700.000 2001.000 + 2800.000 2700.000 2000.000 2800.000 2700.000 2001.000 + 2900.000 2700.000 2000.000 2900.000 2700.000 2001.000 + 3000.000 2700.000 2000.000 3000.000 2700.000 2001.000 + 3100.000 2700.000 2000.000 3100.000 2700.000 2001.000 + 3200.000 2700.000 2000.000 3200.000 2700.000 2001.000 + 3300.000 2700.000 2000.000 3300.000 2700.000 2001.000 + 3400.000 2700.000 2000.000 3400.000 2700.000 2001.000 + 3500.000 2700.000 2000.000 3500.000 2700.000 2001.000 + 3600.000 2700.000 2000.000 3600.000 2700.000 2001.000 + 3700.000 2700.000 2000.000 3700.000 2700.000 2001.000 + 3800.000 2700.000 2000.000 3800.000 2700.000 2001.000 + 3900.000 2700.000 2000.000 3900.000 2700.000 2001.000 + 4000.000 2700.000 2000.000 4000.000 2700.000 2001.000 + 4100.000 2700.000 2000.000 4100.000 2700.000 2001.000 + 4200.000 2700.000 2000.000 4200.000 2700.000 2001.000 + 4300.000 2700.000 2000.000 4300.000 2700.000 2001.000 + 4400.000 2700.000 2000.000 4400.000 2700.000 2001.000 + 4500.000 2700.000 2000.000 4500.000 2700.000 2001.000 + 4600.000 2700.000 2000.000 4600.000 2700.000 2001.000 + 4700.000 2700.000 2000.000 4700.000 2700.000 2001.000 + 4800.000 2700.000 2000.000 4800.000 2700.000 2001.000 + 4900.000 2700.000 2000.000 4900.000 2700.000 2001.000 + 5000.000 2700.000 2000.000 5000.000 2700.000 2001.000 + 0.000 2800.000 2000.000 0.000 2800.000 2001.000 + 100.000 2800.000 2000.000 100.000 2800.000 2001.000 + 200.000 2800.000 2000.000 200.000 2800.000 2001.000 + 300.000 2800.000 2000.000 300.000 2800.000 2001.000 + 400.000 2800.000 2000.000 400.000 2800.000 2001.000 + 500.000 2800.000 2000.000 500.000 2800.000 2001.000 + 600.000 2800.000 2000.000 600.000 2800.000 2001.000 + 700.000 2800.000 2000.000 700.000 2800.000 2001.000 + 800.000 2800.000 2000.000 800.000 2800.000 2001.000 + 900.000 2800.000 2000.000 900.000 2800.000 2001.000 + 1000.000 2800.000 2000.000 1000.000 2800.000 2001.000 + 1100.000 2800.000 2000.000 1100.000 2800.000 2001.000 + 1200.000 2800.000 2000.000 1200.000 2800.000 2001.000 + 1300.000 2800.000 2000.000 1300.000 2800.000 2001.000 + 1400.000 2800.000 2000.000 1400.000 2800.000 2001.000 + 1500.000 2800.000 2000.000 1500.000 2800.000 2001.000 + 1600.000 2800.000 2000.000 1600.000 2800.000 2001.000 + 1700.000 2800.000 2000.000 1700.000 2800.000 2001.000 + 1800.000 2800.000 2000.000 1800.000 2800.000 2001.000 + 1900.000 2800.000 2000.000 1900.000 2800.000 2001.000 + 2000.000 2800.000 2000.000 2000.000 2800.000 2001.000 + 2100.000 2800.000 2000.000 2100.000 2800.000 2001.000 + 2200.000 2800.000 2000.000 2200.000 2800.000 2001.000 + 2300.000 2800.000 2000.000 2300.000 2800.000 2001.000 + 2400.000 2800.000 2000.000 2400.000 2800.000 2001.000 + 2500.000 2800.000 2000.000 2500.000 2800.000 2001.000 + 2600.000 2800.000 2000.000 2600.000 2800.000 2001.000 + 2700.000 2800.000 2000.000 2700.000 2800.000 2001.000 + 2800.000 2800.000 2000.000 2800.000 2800.000 2001.000 + 2900.000 2800.000 2000.000 2900.000 2800.000 2001.000 + 3000.000 2800.000 2000.000 3000.000 2800.000 2001.000 + 3100.000 2800.000 2000.000 3100.000 2800.000 2001.000 + 3200.000 2800.000 2000.000 3200.000 2800.000 2001.000 + 3300.000 2800.000 2000.000 3300.000 2800.000 2001.000 + 3400.000 2800.000 2000.000 3400.000 2800.000 2001.000 + 3500.000 2800.000 2000.000 3500.000 2800.000 2001.000 + 3600.000 2800.000 2000.000 3600.000 2800.000 2001.000 + 3700.000 2800.000 2000.000 3700.000 2800.000 2001.000 + 3800.000 2800.000 2000.000 3800.000 2800.000 2001.000 + 3900.000 2800.000 2000.000 3900.000 2800.000 2001.000 + 4000.000 2800.000 2000.000 4000.000 2800.000 2001.000 + 4100.000 2800.000 2000.000 4100.000 2800.000 2001.000 + 4200.000 2800.000 2000.000 4200.000 2800.000 2001.000 + 4300.000 2800.000 2000.000 4300.000 2800.000 2001.000 + 4400.000 2800.000 2000.000 4400.000 2800.000 2001.000 + 4500.000 2800.000 2000.000 4500.000 2800.000 2001.000 + 4600.000 2800.000 2000.000 4600.000 2800.000 2001.000 + 4700.000 2800.000 2000.000 4700.000 2800.000 2001.000 + 4800.000 2800.000 2000.000 4800.000 2800.000 2001.000 + 4900.000 2800.000 2000.000 4900.000 2800.000 2001.000 + 5000.000 2800.000 2000.000 5000.000 2800.000 2001.000 + 0.000 2900.000 2000.000 0.000 2900.000 2001.000 + 100.000 2900.000 2000.000 100.000 2900.000 2001.000 + 200.000 2900.000 2000.000 200.000 2900.000 2001.000 + 300.000 2900.000 2000.000 300.000 2900.000 2001.000 + 400.000 2900.000 2000.000 400.000 2900.000 2001.000 + 500.000 2900.000 2000.000 500.000 2900.000 2001.000 + 600.000 2900.000 2000.000 600.000 2900.000 2001.000 + 700.000 2900.000 2000.000 700.000 2900.000 2001.000 + 800.000 2900.000 2000.000 800.000 2900.000 2001.000 + 900.000 2900.000 2000.000 900.000 2900.000 2001.000 + 1000.000 2900.000 2000.000 1000.000 2900.000 2001.000 + 1100.000 2900.000 2000.000 1100.000 2900.000 2001.000 + 1200.000 2900.000 2000.000 1200.000 2900.000 2001.000 + 1300.000 2900.000 2000.000 1300.000 2900.000 2001.000 + 1400.000 2900.000 2000.000 1400.000 2900.000 2001.000 + 1500.000 2900.000 2000.000 1500.000 2900.000 2001.000 + 1600.000 2900.000 2000.000 1600.000 2900.000 2001.000 + 1700.000 2900.000 2000.000 1700.000 2900.000 2001.000 + 1800.000 2900.000 2000.000 1800.000 2900.000 2001.000 + 1900.000 2900.000 2000.000 1900.000 2900.000 2001.000 + 2000.000 2900.000 2000.000 2000.000 2900.000 2001.000 + 2100.000 2900.000 2000.000 2100.000 2900.000 2001.000 + 2200.000 2900.000 2000.000 2200.000 2900.000 2001.000 + 2300.000 2900.000 2000.000 2300.000 2900.000 2001.000 + 2400.000 2900.000 2000.000 2400.000 2900.000 2001.000 + 2500.000 2900.000 2000.000 2500.000 2900.000 2001.000 + 2600.000 2900.000 2000.000 2600.000 2900.000 2001.000 + 2700.000 2900.000 2000.000 2700.000 2900.000 2001.000 + 2800.000 2900.000 2000.000 2800.000 2900.000 2001.000 + 2900.000 2900.000 2000.000 2900.000 2900.000 2001.000 + 3000.000 2900.000 2000.000 3000.000 2900.000 2001.000 + 3100.000 2900.000 2000.000 3100.000 2900.000 2001.000 + 3200.000 2900.000 2000.000 3200.000 2900.000 2001.000 + 3300.000 2900.000 2000.000 3300.000 2900.000 2001.000 + 3400.000 2900.000 2000.000 3400.000 2900.000 2001.000 + 3500.000 2900.000 2000.000 3500.000 2900.000 2001.000 + 3600.000 2900.000 2000.000 3600.000 2900.000 2001.000 + 3700.000 2900.000 2000.000 3700.000 2900.000 2001.000 + 3800.000 2900.000 2000.000 3800.000 2900.000 2001.000 + 3900.000 2900.000 2000.000 3900.000 2900.000 2001.000 + 4000.000 2900.000 2000.000 4000.000 2900.000 2001.000 + 4100.000 2900.000 2000.000 4100.000 2900.000 2001.000 + 4200.000 2900.000 2000.000 4200.000 2900.000 2001.000 + 4300.000 2900.000 2000.000 4300.000 2900.000 2001.000 + 4400.000 2900.000 2000.000 4400.000 2900.000 2001.000 + 4500.000 2900.000 2000.000 4500.000 2900.000 2001.000 + 4600.000 2900.000 2000.000 4600.000 2900.000 2001.000 + 4700.000 2900.000 2000.000 4700.000 2900.000 2001.000 + 4800.000 2900.000 2000.000 4800.000 2900.000 2001.000 + 4900.000 2900.000 2000.000 4900.000 2900.000 2001.000 + 5000.000 2900.000 2000.000 5000.000 2900.000 2001.000 + 0.000 3000.000 2000.000 0.000 3000.000 2001.000 + 100.000 3000.000 2000.000 100.000 3000.000 2001.000 + 200.000 3000.000 2000.000 200.000 3000.000 2001.000 + 300.000 3000.000 2000.000 300.000 3000.000 2001.000 + 400.000 3000.000 2000.000 400.000 3000.000 2001.000 + 500.000 3000.000 2000.000 500.000 3000.000 2001.000 + 600.000 3000.000 2000.000 600.000 3000.000 2001.000 + 700.000 3000.000 2000.000 700.000 3000.000 2001.000 + 800.000 3000.000 2000.000 800.000 3000.000 2001.000 + 900.000 3000.000 2000.000 900.000 3000.000 2001.000 + 1000.000 3000.000 2000.000 1000.000 3000.000 2001.000 + 1100.000 3000.000 2000.000 1100.000 3000.000 2001.000 + 1200.000 3000.000 2000.000 1200.000 3000.000 2001.000 + 1300.000 3000.000 2000.000 1300.000 3000.000 2001.000 + 1400.000 3000.000 2000.000 1400.000 3000.000 2001.000 + 1500.000 3000.000 2000.000 1500.000 3000.000 2001.000 + 1600.000 3000.000 2000.000 1600.000 3000.000 2001.000 + 1700.000 3000.000 2000.000 1700.000 3000.000 2001.000 + 1800.000 3000.000 2000.000 1800.000 3000.000 2001.000 + 1900.000 3000.000 2000.000 1900.000 3000.000 2001.000 + 2000.000 3000.000 2000.000 2000.000 3000.000 2001.000 + 2100.000 3000.000 2000.000 2100.000 3000.000 2001.000 + 2200.000 3000.000 2000.000 2200.000 3000.000 2001.000 + 2300.000 3000.000 2000.000 2300.000 3000.000 2001.000 + 2400.000 3000.000 2000.000 2400.000 3000.000 2001.000 + 2500.000 3000.000 2000.000 2500.000 3000.000 2001.000 + 2600.000 3000.000 2000.000 2600.000 3000.000 2001.000 + 2700.000 3000.000 2000.000 2700.000 3000.000 2001.000 + 2800.000 3000.000 2000.000 2800.000 3000.000 2001.000 + 2900.000 3000.000 2000.000 2900.000 3000.000 2001.000 + 3000.000 3000.000 2000.000 3000.000 3000.000 2001.000 + 3100.000 3000.000 2000.000 3100.000 3000.000 2001.000 + 3200.000 3000.000 2000.000 3200.000 3000.000 2001.000 + 3300.000 3000.000 2000.000 3300.000 3000.000 2001.000 + 3400.000 3000.000 2000.000 3400.000 3000.000 2001.000 + 3500.000 3000.000 2000.000 3500.000 3000.000 2001.000 + 3600.000 3000.000 2000.000 3600.000 3000.000 2001.000 + 3700.000 3000.000 2000.000 3700.000 3000.000 2001.000 + 3800.000 3000.000 2000.000 3800.000 3000.000 2001.000 + 3900.000 3000.000 2000.000 3900.000 3000.000 2001.000 + 4000.000 3000.000 2000.000 4000.000 3000.000 2001.000 + 4100.000 3000.000 2000.000 4100.000 3000.000 2001.000 + 4200.000 3000.000 2000.000 4200.000 3000.000 2001.000 + 4300.000 3000.000 2000.000 4300.000 3000.000 2001.000 + 4400.000 3000.000 2000.000 4400.000 3000.000 2001.000 + 4500.000 3000.000 2000.000 4500.000 3000.000 2001.000 + 4600.000 3000.000 2000.000 4600.000 3000.000 2001.000 + 4700.000 3000.000 2000.000 4700.000 3000.000 2001.000 + 4800.000 3000.000 2000.000 4800.000 3000.000 2001.000 + 4900.000 3000.000 2000.000 4900.000 3000.000 2001.000 + 5000.000 3000.000 2000.000 5000.000 3000.000 2001.000 + 0.000 3100.000 2000.000 0.000 3100.000 2001.000 + 100.000 3100.000 2000.000 100.000 3100.000 2001.000 + 200.000 3100.000 2000.000 200.000 3100.000 2001.000 + 300.000 3100.000 2000.000 300.000 3100.000 2001.000 + 400.000 3100.000 2000.000 400.000 3100.000 2001.000 + 500.000 3100.000 2000.000 500.000 3100.000 2001.000 + 600.000 3100.000 2000.000 600.000 3100.000 2001.000 + 700.000 3100.000 2000.000 700.000 3100.000 2001.000 + 800.000 3100.000 2000.000 800.000 3100.000 2001.000 + 900.000 3100.000 2000.000 900.000 3100.000 2001.000 + 1000.000 3100.000 2000.000 1000.000 3100.000 2001.000 + 1100.000 3100.000 2000.000 1100.000 3100.000 2001.000 + 1200.000 3100.000 2000.000 1200.000 3100.000 2001.000 + 1300.000 3100.000 2000.000 1300.000 3100.000 2001.000 + 1400.000 3100.000 2000.000 1400.000 3100.000 2001.000 + 1500.000 3100.000 2000.000 1500.000 3100.000 2001.000 + 1600.000 3100.000 2000.000 1600.000 3100.000 2001.000 + 1700.000 3100.000 2000.000 1700.000 3100.000 2001.000 + 1800.000 3100.000 2000.000 1800.000 3100.000 2001.000 + 1900.000 3100.000 2000.000 1900.000 3100.000 2001.000 + 2000.000 3100.000 2000.000 2000.000 3100.000 2001.000 + 2100.000 3100.000 2000.000 2100.000 3100.000 2001.000 + 2200.000 3100.000 2000.000 2200.000 3100.000 2001.000 + 2300.000 3100.000 2000.000 2300.000 3100.000 2001.000 + 2400.000 3100.000 2000.000 2400.000 3100.000 2001.000 + 2500.000 3100.000 2000.000 2500.000 3100.000 2001.000 + 2600.000 3100.000 2000.000 2600.000 3100.000 2001.000 + 2700.000 3100.000 2000.000 2700.000 3100.000 2001.000 + 2800.000 3100.000 2000.000 2800.000 3100.000 2001.000 + 2900.000 3100.000 2000.000 2900.000 3100.000 2001.000 + 3000.000 3100.000 2000.000 3000.000 3100.000 2001.000 + 3100.000 3100.000 2000.000 3100.000 3100.000 2001.000 + 3200.000 3100.000 2000.000 3200.000 3100.000 2001.000 + 3300.000 3100.000 2000.000 3300.000 3100.000 2001.000 + 3400.000 3100.000 2000.000 3400.000 3100.000 2001.000 + 3500.000 3100.000 2000.000 3500.000 3100.000 2001.000 + 3600.000 3100.000 2000.000 3600.000 3100.000 2001.000 + 3700.000 3100.000 2000.000 3700.000 3100.000 2001.000 + 3800.000 3100.000 2000.000 3800.000 3100.000 2001.000 + 3900.000 3100.000 2000.000 3900.000 3100.000 2001.000 + 4000.000 3100.000 2000.000 4000.000 3100.000 2001.000 + 4100.000 3100.000 2000.000 4100.000 3100.000 2001.000 + 4200.000 3100.000 2000.000 4200.000 3100.000 2001.000 + 4300.000 3100.000 2000.000 4300.000 3100.000 2001.000 + 4400.000 3100.000 2000.000 4400.000 3100.000 2001.000 + 4500.000 3100.000 2000.000 4500.000 3100.000 2001.000 + 4600.000 3100.000 2000.000 4600.000 3100.000 2001.000 + 4700.000 3100.000 2000.000 4700.000 3100.000 2001.000 + 4800.000 3100.000 2000.000 4800.000 3100.000 2001.000 + 4900.000 3100.000 2000.000 4900.000 3100.000 2001.000 + 5000.000 3100.000 2000.000 5000.000 3100.000 2001.000 + 0.000 3200.000 2000.000 0.000 3200.000 2001.000 + 100.000 3200.000 2000.000 100.000 3200.000 2001.000 + 200.000 3200.000 2000.000 200.000 3200.000 2001.000 + 300.000 3200.000 2000.000 300.000 3200.000 2001.000 + 400.000 3200.000 2000.000 400.000 3200.000 2001.000 + 500.000 3200.000 2000.000 500.000 3200.000 2001.000 + 600.000 3200.000 2000.000 600.000 3200.000 2001.000 + 700.000 3200.000 2000.000 700.000 3200.000 2001.000 + 800.000 3200.000 2000.000 800.000 3200.000 2001.000 + 900.000 3200.000 2000.000 900.000 3200.000 2001.000 + 1000.000 3200.000 2000.000 1000.000 3200.000 2001.000 + 1100.000 3200.000 2000.000 1100.000 3200.000 2001.000 + 1200.000 3200.000 2000.000 1200.000 3200.000 2001.000 + 1300.000 3200.000 2000.000 1300.000 3200.000 2001.000 + 1400.000 3200.000 2000.000 1400.000 3200.000 2001.000 + 1500.000 3200.000 2000.000 1500.000 3200.000 2001.000 + 1600.000 3200.000 2000.000 1600.000 3200.000 2001.000 + 1700.000 3200.000 2000.000 1700.000 3200.000 2001.000 + 1800.000 3200.000 2000.000 1800.000 3200.000 2001.000 + 1900.000 3200.000 2000.000 1900.000 3200.000 2001.000 + 2000.000 3200.000 2000.000 2000.000 3200.000 2001.000 + 2100.000 3200.000 2000.000 2100.000 3200.000 2001.000 + 2200.000 3200.000 2000.000 2200.000 3200.000 2001.000 + 2300.000 3200.000 2000.000 2300.000 3200.000 2001.000 + 2400.000 3200.000 2000.000 2400.000 3200.000 2001.000 + 2500.000 3200.000 2000.000 2500.000 3200.000 2001.000 + 2600.000 3200.000 2000.000 2600.000 3200.000 2001.000 + 2700.000 3200.000 2000.000 2700.000 3200.000 2001.000 + 2800.000 3200.000 2000.000 2800.000 3200.000 2001.000 + 2900.000 3200.000 2000.000 2900.000 3200.000 2001.000 + 3000.000 3200.000 2000.000 3000.000 3200.000 2001.000 + 3100.000 3200.000 2000.000 3100.000 3200.000 2001.000 + 3200.000 3200.000 2000.000 3200.000 3200.000 2001.000 + 3300.000 3200.000 2000.000 3300.000 3200.000 2001.000 + 3400.000 3200.000 2000.000 3400.000 3200.000 2001.000 + 3500.000 3200.000 2000.000 3500.000 3200.000 2001.000 + 3600.000 3200.000 2000.000 3600.000 3200.000 2001.000 + 3700.000 3200.000 2000.000 3700.000 3200.000 2001.000 + 3800.000 3200.000 2000.000 3800.000 3200.000 2001.000 + 3900.000 3200.000 2000.000 3900.000 3200.000 2001.000 + 4000.000 3200.000 2000.000 4000.000 3200.000 2001.000 + 4100.000 3200.000 2000.000 4100.000 3200.000 2001.000 + 4200.000 3200.000 2000.000 4200.000 3200.000 2001.000 + 4300.000 3200.000 2000.000 4300.000 3200.000 2001.000 + 4400.000 3200.000 2000.000 4400.000 3200.000 2001.000 + 4500.000 3200.000 2000.000 4500.000 3200.000 2001.000 + 4600.000 3200.000 2000.000 4600.000 3200.000 2001.000 + 4700.000 3200.000 2000.000 4700.000 3200.000 2001.000 + 4800.000 3200.000 2000.000 4800.000 3200.000 2001.000 + 4900.000 3200.000 2000.000 4900.000 3200.000 2001.000 + 5000.000 3200.000 2000.000 5000.000 3200.000 2001.000 + 0.000 3300.000 2000.000 0.000 3300.000 2001.000 + 100.000 3300.000 2000.000 100.000 3300.000 2001.000 + 200.000 3300.000 2000.000 200.000 3300.000 2001.000 + 300.000 3300.000 2000.000 300.000 3300.000 2001.000 + 400.000 3300.000 2000.000 400.000 3300.000 2001.000 + 500.000 3300.000 2000.000 500.000 3300.000 2001.000 + 600.000 3300.000 2000.000 600.000 3300.000 2001.000 + 700.000 3300.000 2000.000 700.000 3300.000 2001.000 + 800.000 3300.000 2000.000 800.000 3300.000 2001.000 + 900.000 3300.000 2000.000 900.000 3300.000 2001.000 + 1000.000 3300.000 2000.000 1000.000 3300.000 2001.000 + 1100.000 3300.000 2000.000 1100.000 3300.000 2001.000 + 1200.000 3300.000 2000.000 1200.000 3300.000 2001.000 + 1300.000 3300.000 2000.000 1300.000 3300.000 2001.000 + 1400.000 3300.000 2000.000 1400.000 3300.000 2001.000 + 1500.000 3300.000 2000.000 1500.000 3300.000 2001.000 + 1600.000 3300.000 2000.000 1600.000 3300.000 2001.000 + 1700.000 3300.000 2000.000 1700.000 3300.000 2001.000 + 1800.000 3300.000 2000.000 1800.000 3300.000 2001.000 + 1900.000 3300.000 2000.000 1900.000 3300.000 2001.000 + 2000.000 3300.000 2000.000 2000.000 3300.000 2001.000 + 2100.000 3300.000 2000.000 2100.000 3300.000 2001.000 + 2200.000 3300.000 2000.000 2200.000 3300.000 2001.000 + 2300.000 3300.000 2000.000 2300.000 3300.000 2001.000 + 2400.000 3300.000 2000.000 2400.000 3300.000 2001.000 + 2500.000 3300.000 2000.000 2500.000 3300.000 2001.000 + 2600.000 3300.000 2000.000 2600.000 3300.000 2001.000 + 2700.000 3300.000 2000.000 2700.000 3300.000 2001.000 + 2800.000 3300.000 2000.000 2800.000 3300.000 2001.000 + 2900.000 3300.000 2000.000 2900.000 3300.000 2001.000 + 3000.000 3300.000 2000.000 3000.000 3300.000 2001.000 + 3100.000 3300.000 2000.000 3100.000 3300.000 2001.000 + 3200.000 3300.000 2000.000 3200.000 3300.000 2001.000 + 3300.000 3300.000 2000.000 3300.000 3300.000 2001.000 + 3400.000 3300.000 2000.000 3400.000 3300.000 2001.000 + 3500.000 3300.000 2000.000 3500.000 3300.000 2001.000 + 3600.000 3300.000 2000.000 3600.000 3300.000 2001.000 + 3700.000 3300.000 2000.000 3700.000 3300.000 2001.000 + 3800.000 3300.000 2000.000 3800.000 3300.000 2001.000 + 3900.000 3300.000 2000.000 3900.000 3300.000 2001.000 + 4000.000 3300.000 2000.000 4000.000 3300.000 2001.000 + 4100.000 3300.000 2000.000 4100.000 3300.000 2001.000 + 4200.000 3300.000 2000.000 4200.000 3300.000 2001.000 + 4300.000 3300.000 2000.000 4300.000 3300.000 2001.000 + 4400.000 3300.000 2000.000 4400.000 3300.000 2001.000 + 4500.000 3300.000 2000.000 4500.000 3300.000 2001.000 + 4600.000 3300.000 2000.000 4600.000 3300.000 2001.000 + 4700.000 3300.000 2000.000 4700.000 3300.000 2001.000 + 4800.000 3300.000 2000.000 4800.000 3300.000 2001.000 + 4900.000 3300.000 2000.000 4900.000 3300.000 2001.000 + 5000.000 3300.000 2000.000 5000.000 3300.000 2001.000 + 0.000 3400.000 2000.000 0.000 3400.000 2001.000 + 100.000 3400.000 2000.000 100.000 3400.000 2001.000 + 200.000 3400.000 2000.000 200.000 3400.000 2001.000 + 300.000 3400.000 2000.000 300.000 3400.000 2001.000 + 400.000 3400.000 2000.000 400.000 3400.000 2001.000 + 500.000 3400.000 2000.000 500.000 3400.000 2001.000 + 600.000 3400.000 2000.000 600.000 3400.000 2001.000 + 700.000 3400.000 2000.000 700.000 3400.000 2001.000 + 800.000 3400.000 2000.000 800.000 3400.000 2001.000 + 900.000 3400.000 2000.000 900.000 3400.000 2001.000 + 1000.000 3400.000 2000.000 1000.000 3400.000 2001.000 + 1100.000 3400.000 2000.000 1100.000 3400.000 2001.000 + 1200.000 3400.000 2000.000 1200.000 3400.000 2001.000 + 1300.000 3400.000 2000.000 1300.000 3400.000 2001.000 + 1400.000 3400.000 2000.000 1400.000 3400.000 2001.000 + 1500.000 3400.000 2000.000 1500.000 3400.000 2001.000 + 1600.000 3400.000 2000.000 1600.000 3400.000 2001.000 + 1700.000 3400.000 2000.000 1700.000 3400.000 2001.000 + 1800.000 3400.000 2000.000 1800.000 3400.000 2001.000 + 1900.000 3400.000 2000.000 1900.000 3400.000 2001.000 + 2000.000 3400.000 2000.000 2000.000 3400.000 2001.000 + 2100.000 3400.000 2000.000 2100.000 3400.000 2001.000 + 2200.000 3400.000 2000.000 2200.000 3400.000 2001.000 + 2300.000 3400.000 2000.000 2300.000 3400.000 2001.000 + 2400.000 3400.000 2000.000 2400.000 3400.000 2001.000 + 2500.000 3400.000 2000.000 2500.000 3400.000 2001.000 + 2600.000 3400.000 2000.000 2600.000 3400.000 2001.000 + 2700.000 3400.000 2000.000 2700.000 3400.000 2001.000 + 2800.000 3400.000 2000.000 2800.000 3400.000 2001.000 + 2900.000 3400.000 2000.000 2900.000 3400.000 2001.000 + 3000.000 3400.000 2000.000 3000.000 3400.000 2001.000 + 3100.000 3400.000 2000.000 3100.000 3400.000 2001.000 + 3200.000 3400.000 2000.000 3200.000 3400.000 2001.000 + 3300.000 3400.000 2000.000 3300.000 3400.000 2001.000 + 3400.000 3400.000 2000.000 3400.000 3400.000 2001.000 + 3500.000 3400.000 2000.000 3500.000 3400.000 2001.000 + 3600.000 3400.000 2000.000 3600.000 3400.000 2001.000 + 3700.000 3400.000 2000.000 3700.000 3400.000 2001.000 + 3800.000 3400.000 2000.000 3800.000 3400.000 2001.000 + 3900.000 3400.000 2000.000 3900.000 3400.000 2001.000 + 4000.000 3400.000 2000.000 4000.000 3400.000 2001.000 + 4100.000 3400.000 2000.000 4100.000 3400.000 2001.000 + 4200.000 3400.000 2000.000 4200.000 3400.000 2001.000 + 4300.000 3400.000 2000.000 4300.000 3400.000 2001.000 + 4400.000 3400.000 2000.000 4400.000 3400.000 2001.000 + 4500.000 3400.000 2000.000 4500.000 3400.000 2001.000 + 4600.000 3400.000 2000.000 4600.000 3400.000 2001.000 + 4700.000 3400.000 2000.000 4700.000 3400.000 2001.000 + 4800.000 3400.000 2000.000 4800.000 3400.000 2001.000 + 4900.000 3400.000 2000.000 4900.000 3400.000 2001.000 + 5000.000 3400.000 2000.000 5000.000 3400.000 2001.000 + 0.000 3500.000 2000.000 0.000 3500.000 2001.000 + 100.000 3500.000 2000.000 100.000 3500.000 2001.000 + 200.000 3500.000 2000.000 200.000 3500.000 2001.000 + 300.000 3500.000 2000.000 300.000 3500.000 2001.000 + 400.000 3500.000 2000.000 400.000 3500.000 2001.000 + 500.000 3500.000 2000.000 500.000 3500.000 2001.000 + 600.000 3500.000 2000.000 600.000 3500.000 2001.000 + 700.000 3500.000 2000.000 700.000 3500.000 2001.000 + 800.000 3500.000 2000.000 800.000 3500.000 2001.000 + 900.000 3500.000 2000.000 900.000 3500.000 2001.000 + 1000.000 3500.000 2000.000 1000.000 3500.000 2001.000 + 1100.000 3500.000 2000.000 1100.000 3500.000 2001.000 + 1200.000 3500.000 2000.000 1200.000 3500.000 2001.000 + 1300.000 3500.000 2000.000 1300.000 3500.000 2001.000 + 1400.000 3500.000 2000.000 1400.000 3500.000 2001.000 + 1500.000 3500.000 2000.000 1500.000 3500.000 2001.000 + 1600.000 3500.000 2000.000 1600.000 3500.000 2001.000 + 1700.000 3500.000 2000.000 1700.000 3500.000 2001.000 + 1800.000 3500.000 2000.000 1800.000 3500.000 2001.000 + 1900.000 3500.000 2000.000 1900.000 3500.000 2001.000 + 2000.000 3500.000 2000.000 2000.000 3500.000 2001.000 + 2100.000 3500.000 2000.000 2100.000 3500.000 2001.000 + 2200.000 3500.000 2000.000 2200.000 3500.000 2001.000 + 2300.000 3500.000 2000.000 2300.000 3500.000 2001.000 + 2400.000 3500.000 2000.000 2400.000 3500.000 2001.000 + 2500.000 3500.000 2000.000 2500.000 3500.000 2001.000 + 2600.000 3500.000 2000.000 2600.000 3500.000 2001.000 + 2700.000 3500.000 2000.000 2700.000 3500.000 2001.000 + 2800.000 3500.000 2000.000 2800.000 3500.000 2001.000 + 2900.000 3500.000 2000.000 2900.000 3500.000 2001.000 + 3000.000 3500.000 2000.000 3000.000 3500.000 2001.000 + 3100.000 3500.000 2000.000 3100.000 3500.000 2001.000 + 3200.000 3500.000 2000.000 3200.000 3500.000 2001.000 + 3300.000 3500.000 2000.000 3300.000 3500.000 2001.000 + 3400.000 3500.000 2000.000 3400.000 3500.000 2001.000 + 3500.000 3500.000 2000.000 3500.000 3500.000 2001.000 + 3600.000 3500.000 2000.000 3600.000 3500.000 2001.000 + 3700.000 3500.000 2000.000 3700.000 3500.000 2001.000 + 3800.000 3500.000 2000.000 3800.000 3500.000 2001.000 + 3900.000 3500.000 2000.000 3900.000 3500.000 2001.000 + 4000.000 3500.000 2000.000 4000.000 3500.000 2001.000 + 4100.000 3500.000 2000.000 4100.000 3500.000 2001.000 + 4200.000 3500.000 2000.000 4200.000 3500.000 2001.000 + 4300.000 3500.000 2000.000 4300.000 3500.000 2001.000 + 4400.000 3500.000 2000.000 4400.000 3500.000 2001.000 + 4500.000 3500.000 2000.000 4500.000 3500.000 2001.000 + 4600.000 3500.000 2000.000 4600.000 3500.000 2001.000 + 4700.000 3500.000 2000.000 4700.000 3500.000 2001.000 + 4800.000 3500.000 2000.000 4800.000 3500.000 2001.000 + 4900.000 3500.000 2000.000 4900.000 3500.000 2001.000 + 5000.000 3500.000 2000.000 5000.000 3500.000 2001.000 + 0.000 3600.000 2000.000 0.000 3600.000 2001.000 + 100.000 3600.000 2000.000 100.000 3600.000 2001.000 + 200.000 3600.000 2000.000 200.000 3600.000 2001.000 + 300.000 3600.000 2000.000 300.000 3600.000 2001.000 + 400.000 3600.000 2000.000 400.000 3600.000 2001.000 + 500.000 3600.000 2000.000 500.000 3600.000 2001.000 + 600.000 3600.000 2000.000 600.000 3600.000 2001.000 + 700.000 3600.000 2000.000 700.000 3600.000 2001.000 + 800.000 3600.000 2000.000 800.000 3600.000 2001.000 + 900.000 3600.000 2000.000 900.000 3600.000 2001.000 + 1000.000 3600.000 2000.000 1000.000 3600.000 2001.000 + 1100.000 3600.000 2000.000 1100.000 3600.000 2001.000 + 1200.000 3600.000 2000.000 1200.000 3600.000 2001.000 + 1300.000 3600.000 2000.000 1300.000 3600.000 2001.000 + 1400.000 3600.000 2000.000 1400.000 3600.000 2001.000 + 1500.000 3600.000 2000.000 1500.000 3600.000 2001.000 + 1600.000 3600.000 2000.000 1600.000 3600.000 2001.000 + 1700.000 3600.000 2000.000 1700.000 3600.000 2001.000 + 1800.000 3600.000 2000.000 1800.000 3600.000 2001.000 + 1900.000 3600.000 2000.000 1900.000 3600.000 2001.000 + 2000.000 3600.000 2000.000 2000.000 3600.000 2001.000 + 2100.000 3600.000 2000.000 2100.000 3600.000 2001.000 + 2200.000 3600.000 2000.000 2200.000 3600.000 2001.000 + 2300.000 3600.000 2000.000 2300.000 3600.000 2001.000 + 2400.000 3600.000 2000.000 2400.000 3600.000 2001.000 + 2500.000 3600.000 2000.000 2500.000 3600.000 2001.000 + 2600.000 3600.000 2000.000 2600.000 3600.000 2001.000 + 2700.000 3600.000 2000.000 2700.000 3600.000 2001.000 + 2800.000 3600.000 2000.000 2800.000 3600.000 2001.000 + 2900.000 3600.000 2000.000 2900.000 3600.000 2001.000 + 3000.000 3600.000 2000.000 3000.000 3600.000 2001.000 + 3100.000 3600.000 2000.000 3100.000 3600.000 2001.000 + 3200.000 3600.000 2000.000 3200.000 3600.000 2001.000 + 3300.000 3600.000 2000.000 3300.000 3600.000 2001.000 + 3400.000 3600.000 2000.000 3400.000 3600.000 2001.000 + 3500.000 3600.000 2000.000 3500.000 3600.000 2001.000 + 3600.000 3600.000 2000.000 3600.000 3600.000 2001.000 + 3700.000 3600.000 2000.000 3700.000 3600.000 2001.000 + 3800.000 3600.000 2000.000 3800.000 3600.000 2001.000 + 3900.000 3600.000 2000.000 3900.000 3600.000 2001.000 + 4000.000 3600.000 2000.000 4000.000 3600.000 2001.000 + 4100.000 3600.000 2000.000 4100.000 3600.000 2001.000 + 4200.000 3600.000 2000.000 4200.000 3600.000 2001.000 + 4300.000 3600.000 2000.000 4300.000 3600.000 2001.000 + 4400.000 3600.000 2000.000 4400.000 3600.000 2001.000 + 4500.000 3600.000 2000.000 4500.000 3600.000 2001.000 + 4600.000 3600.000 2000.000 4600.000 3600.000 2001.000 + 4700.000 3600.000 2000.000 4700.000 3600.000 2001.000 + 4800.000 3600.000 2000.000 4800.000 3600.000 2001.000 + 4900.000 3600.000 2000.000 4900.000 3600.000 2001.000 + 5000.000 3600.000 2000.000 5000.000 3600.000 2001.000 + 0.000 3700.000 2000.000 0.000 3700.000 2001.000 + 100.000 3700.000 2000.000 100.000 3700.000 2001.000 + 200.000 3700.000 2000.000 200.000 3700.000 2001.000 + 300.000 3700.000 2000.000 300.000 3700.000 2001.000 + 400.000 3700.000 2000.000 400.000 3700.000 2001.000 + 500.000 3700.000 2000.000 500.000 3700.000 2001.000 + 600.000 3700.000 2000.000 600.000 3700.000 2001.000 + 700.000 3700.000 2000.000 700.000 3700.000 2001.000 + 800.000 3700.000 2000.000 800.000 3700.000 2001.000 + 900.000 3700.000 2000.000 900.000 3700.000 2001.000 + 1000.000 3700.000 2000.000 1000.000 3700.000 2001.000 + 1100.000 3700.000 2000.000 1100.000 3700.000 2001.000 + 1200.000 3700.000 2000.000 1200.000 3700.000 2001.000 + 1300.000 3700.000 2000.000 1300.000 3700.000 2001.000 + 1400.000 3700.000 2000.000 1400.000 3700.000 2001.000 + 1500.000 3700.000 2000.000 1500.000 3700.000 2001.000 + 1600.000 3700.000 2000.000 1600.000 3700.000 2001.000 + 1700.000 3700.000 2000.000 1700.000 3700.000 2001.000 + 1800.000 3700.000 2000.000 1800.000 3700.000 2001.000 + 1900.000 3700.000 2000.000 1900.000 3700.000 2001.000 + 2000.000 3700.000 2000.000 2000.000 3700.000 2001.000 + 2100.000 3700.000 2000.000 2100.000 3700.000 2001.000 + 2200.000 3700.000 2000.000 2200.000 3700.000 2001.000 + 2300.000 3700.000 2000.000 2300.000 3700.000 2001.000 + 2400.000 3700.000 2000.000 2400.000 3700.000 2001.000 + 2500.000 3700.000 2000.000 2500.000 3700.000 2001.000 + 2600.000 3700.000 2000.000 2600.000 3700.000 2001.000 + 2700.000 3700.000 2000.000 2700.000 3700.000 2001.000 + 2800.000 3700.000 2000.000 2800.000 3700.000 2001.000 + 2900.000 3700.000 2000.000 2900.000 3700.000 2001.000 + 3000.000 3700.000 2000.000 3000.000 3700.000 2001.000 + 3100.000 3700.000 2000.000 3100.000 3700.000 2001.000 + 3200.000 3700.000 2000.000 3200.000 3700.000 2001.000 + 3300.000 3700.000 2000.000 3300.000 3700.000 2001.000 + 3400.000 3700.000 2000.000 3400.000 3700.000 2001.000 + 3500.000 3700.000 2000.000 3500.000 3700.000 2001.000 + 3600.000 3700.000 2000.000 3600.000 3700.000 2001.000 + 3700.000 3700.000 2000.000 3700.000 3700.000 2001.000 + 3800.000 3700.000 2000.000 3800.000 3700.000 2001.000 + 3900.000 3700.000 2000.000 3900.000 3700.000 2001.000 + 4000.000 3700.000 2000.000 4000.000 3700.000 2001.000 + 4100.000 3700.000 2000.000 4100.000 3700.000 2001.000 + 4200.000 3700.000 2000.000 4200.000 3700.000 2001.000 + 4300.000 3700.000 2000.000 4300.000 3700.000 2001.000 + 4400.000 3700.000 2000.000 4400.000 3700.000 2001.000 + 4500.000 3700.000 2000.000 4500.000 3700.000 2001.000 + 4600.000 3700.000 2000.000 4600.000 3700.000 2001.000 + 4700.000 3700.000 2000.000 4700.000 3700.000 2001.000 + 4800.000 3700.000 2000.000 4800.000 3700.000 2001.000 + 4900.000 3700.000 2000.000 4900.000 3700.000 2001.000 + 5000.000 3700.000 2000.000 5000.000 3700.000 2001.000 + 0.000 3800.000 2000.000 0.000 3800.000 2001.000 + 100.000 3800.000 2000.000 100.000 3800.000 2001.000 + 200.000 3800.000 2000.000 200.000 3800.000 2001.000 + 300.000 3800.000 2000.000 300.000 3800.000 2001.000 + 400.000 3800.000 2000.000 400.000 3800.000 2001.000 + 500.000 3800.000 2000.000 500.000 3800.000 2001.000 + 600.000 3800.000 2000.000 600.000 3800.000 2001.000 + 700.000 3800.000 2000.000 700.000 3800.000 2001.000 + 800.000 3800.000 2000.000 800.000 3800.000 2001.000 + 900.000 3800.000 2000.000 900.000 3800.000 2001.000 + 1000.000 3800.000 2000.000 1000.000 3800.000 2001.000 + 1100.000 3800.000 2000.000 1100.000 3800.000 2001.000 + 1200.000 3800.000 2000.000 1200.000 3800.000 2001.000 + 1300.000 3800.000 2000.000 1300.000 3800.000 2001.000 + 1400.000 3800.000 2000.000 1400.000 3800.000 2001.000 + 1500.000 3800.000 2000.000 1500.000 3800.000 2001.000 + 1600.000 3800.000 2000.000 1600.000 3800.000 2001.000 + 1700.000 3800.000 2000.000 1700.000 3800.000 2001.000 + 1800.000 3800.000 2000.000 1800.000 3800.000 2001.000 + 1900.000 3800.000 2000.000 1900.000 3800.000 2001.000 + 2000.000 3800.000 2000.000 2000.000 3800.000 2001.000 + 2100.000 3800.000 2000.000 2100.000 3800.000 2001.000 + 2200.000 3800.000 2000.000 2200.000 3800.000 2001.000 + 2300.000 3800.000 2000.000 2300.000 3800.000 2001.000 + 2400.000 3800.000 2000.000 2400.000 3800.000 2001.000 + 2500.000 3800.000 2000.000 2500.000 3800.000 2001.000 + 2600.000 3800.000 2000.000 2600.000 3800.000 2001.000 + 2700.000 3800.000 2000.000 2700.000 3800.000 2001.000 + 2800.000 3800.000 2000.000 2800.000 3800.000 2001.000 + 2900.000 3800.000 2000.000 2900.000 3800.000 2001.000 + 3000.000 3800.000 2000.000 3000.000 3800.000 2001.000 + 3100.000 3800.000 2000.000 3100.000 3800.000 2001.000 + 3200.000 3800.000 2000.000 3200.000 3800.000 2001.000 + 3300.000 3800.000 2000.000 3300.000 3800.000 2001.000 + 3400.000 3800.000 2000.000 3400.000 3800.000 2001.000 + 3500.000 3800.000 2000.000 3500.000 3800.000 2001.000 + 3600.000 3800.000 2000.000 3600.000 3800.000 2001.000 + 3700.000 3800.000 2000.000 3700.000 3800.000 2001.000 + 3800.000 3800.000 2000.000 3800.000 3800.000 2001.000 + 3900.000 3800.000 2000.000 3900.000 3800.000 2001.000 + 4000.000 3800.000 2000.000 4000.000 3800.000 2001.000 + 4100.000 3800.000 2000.000 4100.000 3800.000 2001.000 + 4200.000 3800.000 2000.000 4200.000 3800.000 2001.000 + 4300.000 3800.000 2000.000 4300.000 3800.000 2001.000 + 4400.000 3800.000 2000.000 4400.000 3800.000 2001.000 + 4500.000 3800.000 2000.000 4500.000 3800.000 2001.000 + 4600.000 3800.000 2000.000 4600.000 3800.000 2001.000 + 4700.000 3800.000 2000.000 4700.000 3800.000 2001.000 + 4800.000 3800.000 2000.000 4800.000 3800.000 2001.000 + 4900.000 3800.000 2000.000 4900.000 3800.000 2001.000 + 5000.000 3800.000 2000.000 5000.000 3800.000 2001.000 + 0.000 3900.000 2000.000 0.000 3900.000 2001.000 + 100.000 3900.000 2000.000 100.000 3900.000 2001.000 + 200.000 3900.000 2000.000 200.000 3900.000 2001.000 + 300.000 3900.000 2000.000 300.000 3900.000 2001.000 + 400.000 3900.000 2000.000 400.000 3900.000 2001.000 + 500.000 3900.000 2000.000 500.000 3900.000 2001.000 + 600.000 3900.000 2000.000 600.000 3900.000 2001.000 + 700.000 3900.000 2000.000 700.000 3900.000 2001.000 + 800.000 3900.000 2000.000 800.000 3900.000 2001.000 + 900.000 3900.000 2000.000 900.000 3900.000 2001.000 + 1000.000 3900.000 2000.000 1000.000 3900.000 2001.000 + 1100.000 3900.000 2000.000 1100.000 3900.000 2001.000 + 1200.000 3900.000 2000.000 1200.000 3900.000 2001.000 + 1300.000 3900.000 2000.000 1300.000 3900.000 2001.000 + 1400.000 3900.000 2000.000 1400.000 3900.000 2001.000 + 1500.000 3900.000 2000.000 1500.000 3900.000 2001.000 + 1600.000 3900.000 2000.000 1600.000 3900.000 2001.000 + 1700.000 3900.000 2000.000 1700.000 3900.000 2001.000 + 1800.000 3900.000 2000.000 1800.000 3900.000 2001.000 + 1900.000 3900.000 2000.000 1900.000 3900.000 2001.000 + 2000.000 3900.000 2000.000 2000.000 3900.000 2001.000 + 2100.000 3900.000 2000.000 2100.000 3900.000 2001.000 + 2200.000 3900.000 2000.000 2200.000 3900.000 2001.000 + 2300.000 3900.000 2000.000 2300.000 3900.000 2001.000 + 2400.000 3900.000 2000.000 2400.000 3900.000 2001.000 + 2500.000 3900.000 2000.000 2500.000 3900.000 2001.000 + 2600.000 3900.000 2000.000 2600.000 3900.000 2001.000 + 2700.000 3900.000 2000.000 2700.000 3900.000 2001.000 + 2800.000 3900.000 2000.000 2800.000 3900.000 2001.000 + 2900.000 3900.000 2000.000 2900.000 3900.000 2001.000 + 3000.000 3900.000 2000.000 3000.000 3900.000 2001.000 + 3100.000 3900.000 2000.000 3100.000 3900.000 2001.000 + 3200.000 3900.000 2000.000 3200.000 3900.000 2001.000 + 3300.000 3900.000 2000.000 3300.000 3900.000 2001.000 + 3400.000 3900.000 2000.000 3400.000 3900.000 2001.000 + 3500.000 3900.000 2000.000 3500.000 3900.000 2001.000 + 3600.000 3900.000 2000.000 3600.000 3900.000 2001.000 + 3700.000 3900.000 2000.000 3700.000 3900.000 2001.000 + 3800.000 3900.000 2000.000 3800.000 3900.000 2001.000 + 3900.000 3900.000 2000.000 3900.000 3900.000 2001.000 + 4000.000 3900.000 2000.000 4000.000 3900.000 2001.000 + 4100.000 3900.000 2000.000 4100.000 3900.000 2001.000 + 4200.000 3900.000 2000.000 4200.000 3900.000 2001.000 + 4300.000 3900.000 2000.000 4300.000 3900.000 2001.000 + 4400.000 3900.000 2000.000 4400.000 3900.000 2001.000 + 4500.000 3900.000 2000.000 4500.000 3900.000 2001.000 + 4600.000 3900.000 2000.000 4600.000 3900.000 2001.000 + 4700.000 3900.000 2000.000 4700.000 3900.000 2001.000 + 4800.000 3900.000 2000.000 4800.000 3900.000 2001.000 + 4900.000 3900.000 2000.000 4900.000 3900.000 2001.000 + 5000.000 3900.000 2000.000 5000.000 3900.000 2001.000 + 0.000 4000.000 2000.000 0.000 4000.000 2001.000 + 100.000 4000.000 2000.000 100.000 4000.000 2001.000 + 200.000 4000.000 2000.000 200.000 4000.000 2001.000 + 300.000 4000.000 2000.000 300.000 4000.000 2001.000 + 400.000 4000.000 2000.000 400.000 4000.000 2001.000 + 500.000 4000.000 2000.000 500.000 4000.000 2001.000 + 600.000 4000.000 2000.000 600.000 4000.000 2001.000 + 700.000 4000.000 2000.000 700.000 4000.000 2001.000 + 800.000 4000.000 2000.000 800.000 4000.000 2001.000 + 900.000 4000.000 2000.000 900.000 4000.000 2001.000 + 1000.000 4000.000 2000.000 1000.000 4000.000 2001.000 + 1100.000 4000.000 2000.000 1100.000 4000.000 2001.000 + 1200.000 4000.000 2000.000 1200.000 4000.000 2001.000 + 1300.000 4000.000 2000.000 1300.000 4000.000 2001.000 + 1400.000 4000.000 2000.000 1400.000 4000.000 2001.000 + 1500.000 4000.000 2000.000 1500.000 4000.000 2001.000 + 1600.000 4000.000 2000.000 1600.000 4000.000 2001.000 + 1700.000 4000.000 2000.000 1700.000 4000.000 2001.000 + 1800.000 4000.000 2000.000 1800.000 4000.000 2001.000 + 1900.000 4000.000 2000.000 1900.000 4000.000 2001.000 + 2000.000 4000.000 2000.000 2000.000 4000.000 2001.000 + 2100.000 4000.000 2000.000 2100.000 4000.000 2001.000 + 2200.000 4000.000 2000.000 2200.000 4000.000 2001.000 + 2300.000 4000.000 2000.000 2300.000 4000.000 2001.000 + 2400.000 4000.000 2000.000 2400.000 4000.000 2001.000 + 2500.000 4000.000 2000.000 2500.000 4000.000 2001.000 + 2600.000 4000.000 2000.000 2600.000 4000.000 2001.000 + 2700.000 4000.000 2000.000 2700.000 4000.000 2001.000 + 2800.000 4000.000 2000.000 2800.000 4000.000 2001.000 + 2900.000 4000.000 2000.000 2900.000 4000.000 2001.000 + 3000.000 4000.000 2000.000 3000.000 4000.000 2001.000 + 3100.000 4000.000 2000.000 3100.000 4000.000 2001.000 + 3200.000 4000.000 2000.000 3200.000 4000.000 2001.000 + 3300.000 4000.000 2000.000 3300.000 4000.000 2001.000 + 3400.000 4000.000 2000.000 3400.000 4000.000 2001.000 + 3500.000 4000.000 2000.000 3500.000 4000.000 2001.000 + 3600.000 4000.000 2000.000 3600.000 4000.000 2001.000 + 3700.000 4000.000 2000.000 3700.000 4000.000 2001.000 + 3800.000 4000.000 2000.000 3800.000 4000.000 2001.000 + 3900.000 4000.000 2000.000 3900.000 4000.000 2001.000 + 4000.000 4000.000 2000.000 4000.000 4000.000 2001.000 + 4100.000 4000.000 2000.000 4100.000 4000.000 2001.000 + 4200.000 4000.000 2000.000 4200.000 4000.000 2001.000 + 4300.000 4000.000 2000.000 4300.000 4000.000 2001.000 + 4400.000 4000.000 2000.000 4400.000 4000.000 2001.000 + 4500.000 4000.000 2000.000 4500.000 4000.000 2001.000 + 4600.000 4000.000 2000.000 4600.000 4000.000 2001.000 + 4700.000 4000.000 2000.000 4700.000 4000.000 2001.000 + 4800.000 4000.000 2000.000 4800.000 4000.000 2001.000 + 4900.000 4000.000 2000.000 4900.000 4000.000 2001.000 + 5000.000 4000.000 2000.000 5000.000 4000.000 2001.000 + 0.000 4100.000 2000.000 0.000 4100.000 2001.000 + 100.000 4100.000 2000.000 100.000 4100.000 2001.000 + 200.000 4100.000 2000.000 200.000 4100.000 2001.000 + 300.000 4100.000 2000.000 300.000 4100.000 2001.000 + 400.000 4100.000 2000.000 400.000 4100.000 2001.000 + 500.000 4100.000 2000.000 500.000 4100.000 2001.000 + 600.000 4100.000 2000.000 600.000 4100.000 2001.000 + 700.000 4100.000 2000.000 700.000 4100.000 2001.000 + 800.000 4100.000 2000.000 800.000 4100.000 2001.000 + 900.000 4100.000 2000.000 900.000 4100.000 2001.000 + 1000.000 4100.000 2000.000 1000.000 4100.000 2001.000 + 1100.000 4100.000 2000.000 1100.000 4100.000 2001.000 + 1200.000 4100.000 2000.000 1200.000 4100.000 2001.000 + 1300.000 4100.000 2000.000 1300.000 4100.000 2001.000 + 1400.000 4100.000 2000.000 1400.000 4100.000 2001.000 + 1500.000 4100.000 2000.000 1500.000 4100.000 2001.000 + 1600.000 4100.000 2000.000 1600.000 4100.000 2001.000 + 1700.000 4100.000 2000.000 1700.000 4100.000 2001.000 + 1800.000 4100.000 2000.000 1800.000 4100.000 2001.000 + 1900.000 4100.000 2000.000 1900.000 4100.000 2001.000 + 2000.000 4100.000 2000.000 2000.000 4100.000 2001.000 + 2100.000 4100.000 2000.000 2100.000 4100.000 2001.000 + 2200.000 4100.000 2000.000 2200.000 4100.000 2001.000 + 2300.000 4100.000 2000.000 2300.000 4100.000 2001.000 + 2400.000 4100.000 2000.000 2400.000 4100.000 2001.000 + 2500.000 4100.000 2000.000 2500.000 4100.000 2001.000 + 2600.000 4100.000 2000.000 2600.000 4100.000 2001.000 + 2700.000 4100.000 2000.000 2700.000 4100.000 2001.000 + 2800.000 4100.000 2000.000 2800.000 4100.000 2001.000 + 2900.000 4100.000 2000.000 2900.000 4100.000 2001.000 + 3000.000 4100.000 2000.000 3000.000 4100.000 2001.000 + 3100.000 4100.000 2000.000 3100.000 4100.000 2001.000 + 3200.000 4100.000 2000.000 3200.000 4100.000 2001.000 + 3300.000 4100.000 2000.000 3300.000 4100.000 2001.000 + 3400.000 4100.000 2000.000 3400.000 4100.000 2001.000 + 3500.000 4100.000 2000.000 3500.000 4100.000 2001.000 + 3600.000 4100.000 2000.000 3600.000 4100.000 2001.000 + 3700.000 4100.000 2000.000 3700.000 4100.000 2001.000 + 3800.000 4100.000 2000.000 3800.000 4100.000 2001.000 + 3900.000 4100.000 2000.000 3900.000 4100.000 2001.000 + 4000.000 4100.000 2000.000 4000.000 4100.000 2001.000 + 4100.000 4100.000 2000.000 4100.000 4100.000 2001.000 + 4200.000 4100.000 2000.000 4200.000 4100.000 2001.000 + 4300.000 4100.000 2000.000 4300.000 4100.000 2001.000 + 4400.000 4100.000 2000.000 4400.000 4100.000 2001.000 + 4500.000 4100.000 2000.000 4500.000 4100.000 2001.000 + 4600.000 4100.000 2000.000 4600.000 4100.000 2001.000 + 4700.000 4100.000 2000.000 4700.000 4100.000 2001.000 + 4800.000 4100.000 2000.000 4800.000 4100.000 2001.000 + 4900.000 4100.000 2000.000 4900.000 4100.000 2001.000 + 5000.000 4100.000 2000.000 5000.000 4100.000 2001.000 + 0.000 4200.000 2000.000 0.000 4200.000 2001.000 + 100.000 4200.000 2000.000 100.000 4200.000 2001.000 + 200.000 4200.000 2000.000 200.000 4200.000 2001.000 + 300.000 4200.000 2000.000 300.000 4200.000 2001.000 + 400.000 4200.000 2000.000 400.000 4200.000 2001.000 + 500.000 4200.000 2000.000 500.000 4200.000 2001.000 + 600.000 4200.000 2000.000 600.000 4200.000 2001.000 + 700.000 4200.000 2000.000 700.000 4200.000 2001.000 + 800.000 4200.000 2000.000 800.000 4200.000 2001.000 + 900.000 4200.000 2000.000 900.000 4200.000 2001.000 + 1000.000 4200.000 2000.000 1000.000 4200.000 2001.000 + 1100.000 4200.000 2000.000 1100.000 4200.000 2001.000 + 1200.000 4200.000 2000.000 1200.000 4200.000 2001.000 + 1300.000 4200.000 2000.000 1300.000 4200.000 2001.000 + 1400.000 4200.000 2000.000 1400.000 4200.000 2001.000 + 1500.000 4200.000 2000.000 1500.000 4200.000 2001.000 + 1600.000 4200.000 2000.000 1600.000 4200.000 2001.000 + 1700.000 4200.000 2000.000 1700.000 4200.000 2001.000 + 1800.000 4200.000 2000.000 1800.000 4200.000 2001.000 + 1900.000 4200.000 2000.000 1900.000 4200.000 2001.000 + 2000.000 4200.000 2000.000 2000.000 4200.000 2001.000 + 2100.000 4200.000 2000.000 2100.000 4200.000 2001.000 + 2200.000 4200.000 2000.000 2200.000 4200.000 2001.000 + 2300.000 4200.000 2000.000 2300.000 4200.000 2001.000 + 2400.000 4200.000 2000.000 2400.000 4200.000 2001.000 + 2500.000 4200.000 2000.000 2500.000 4200.000 2001.000 + 2600.000 4200.000 2000.000 2600.000 4200.000 2001.000 + 2700.000 4200.000 2000.000 2700.000 4200.000 2001.000 + 2800.000 4200.000 2000.000 2800.000 4200.000 2001.000 + 2900.000 4200.000 2000.000 2900.000 4200.000 2001.000 + 3000.000 4200.000 2000.000 3000.000 4200.000 2001.000 + 3100.000 4200.000 2000.000 3100.000 4200.000 2001.000 + 3200.000 4200.000 2000.000 3200.000 4200.000 2001.000 + 3300.000 4200.000 2000.000 3300.000 4200.000 2001.000 + 3400.000 4200.000 2000.000 3400.000 4200.000 2001.000 + 3500.000 4200.000 2000.000 3500.000 4200.000 2001.000 + 3600.000 4200.000 2000.000 3600.000 4200.000 2001.000 + 3700.000 4200.000 2000.000 3700.000 4200.000 2001.000 + 3800.000 4200.000 2000.000 3800.000 4200.000 2001.000 + 3900.000 4200.000 2000.000 3900.000 4200.000 2001.000 + 4000.000 4200.000 2000.000 4000.000 4200.000 2001.000 + 4100.000 4200.000 2000.000 4100.000 4200.000 2001.000 + 4200.000 4200.000 2000.000 4200.000 4200.000 2001.000 + 4300.000 4200.000 2000.000 4300.000 4200.000 2001.000 + 4400.000 4200.000 2000.000 4400.000 4200.000 2001.000 + 4500.000 4200.000 2000.000 4500.000 4200.000 2001.000 + 4600.000 4200.000 2000.000 4600.000 4200.000 2001.000 + 4700.000 4200.000 2000.000 4700.000 4200.000 2001.000 + 4800.000 4200.000 2000.000 4800.000 4200.000 2001.000 + 4900.000 4200.000 2000.000 4900.000 4200.000 2001.000 + 5000.000 4200.000 2000.000 5000.000 4200.000 2001.000 + 0.000 4300.000 2000.000 0.000 4300.000 2001.000 + 100.000 4300.000 2000.000 100.000 4300.000 2001.000 + 200.000 4300.000 2000.000 200.000 4300.000 2001.000 + 300.000 4300.000 2000.000 300.000 4300.000 2001.000 + 400.000 4300.000 2000.000 400.000 4300.000 2001.000 + 500.000 4300.000 2000.000 500.000 4300.000 2001.000 + 600.000 4300.000 2000.000 600.000 4300.000 2001.000 + 700.000 4300.000 2000.000 700.000 4300.000 2001.000 + 800.000 4300.000 2000.000 800.000 4300.000 2001.000 + 900.000 4300.000 2000.000 900.000 4300.000 2001.000 + 1000.000 4300.000 2000.000 1000.000 4300.000 2001.000 + 1100.000 4300.000 2000.000 1100.000 4300.000 2001.000 + 1200.000 4300.000 2000.000 1200.000 4300.000 2001.000 + 1300.000 4300.000 2000.000 1300.000 4300.000 2001.000 + 1400.000 4300.000 2000.000 1400.000 4300.000 2001.000 + 1500.000 4300.000 2000.000 1500.000 4300.000 2001.000 + 1600.000 4300.000 2000.000 1600.000 4300.000 2001.000 + 1700.000 4300.000 2000.000 1700.000 4300.000 2001.000 + 1800.000 4300.000 2000.000 1800.000 4300.000 2001.000 + 1900.000 4300.000 2000.000 1900.000 4300.000 2001.000 + 2000.000 4300.000 2000.000 2000.000 4300.000 2001.000 + 2100.000 4300.000 2000.000 2100.000 4300.000 2001.000 + 2200.000 4300.000 2000.000 2200.000 4300.000 2001.000 + 2300.000 4300.000 2000.000 2300.000 4300.000 2001.000 + 2400.000 4300.000 2000.000 2400.000 4300.000 2001.000 + 2500.000 4300.000 2000.000 2500.000 4300.000 2001.000 + 2600.000 4300.000 2000.000 2600.000 4300.000 2001.000 + 2700.000 4300.000 2000.000 2700.000 4300.000 2001.000 + 2800.000 4300.000 2000.000 2800.000 4300.000 2001.000 + 2900.000 4300.000 2000.000 2900.000 4300.000 2001.000 + 3000.000 4300.000 2000.000 3000.000 4300.000 2001.000 + 3100.000 4300.000 2000.000 3100.000 4300.000 2001.000 + 3200.000 4300.000 2000.000 3200.000 4300.000 2001.000 + 3300.000 4300.000 2000.000 3300.000 4300.000 2001.000 + 3400.000 4300.000 2000.000 3400.000 4300.000 2001.000 + 3500.000 4300.000 2000.000 3500.000 4300.000 2001.000 + 3600.000 4300.000 2000.000 3600.000 4300.000 2001.000 + 3700.000 4300.000 2000.000 3700.000 4300.000 2001.000 + 3800.000 4300.000 2000.000 3800.000 4300.000 2001.000 + 3900.000 4300.000 2000.000 3900.000 4300.000 2001.000 + 4000.000 4300.000 2000.000 4000.000 4300.000 2001.000 + 4100.000 4300.000 2000.000 4100.000 4300.000 2001.000 + 4200.000 4300.000 2000.000 4200.000 4300.000 2001.000 + 4300.000 4300.000 2000.000 4300.000 4300.000 2001.000 + 4400.000 4300.000 2000.000 4400.000 4300.000 2001.000 + 4500.000 4300.000 2000.000 4500.000 4300.000 2001.000 + 4600.000 4300.000 2000.000 4600.000 4300.000 2001.000 + 4700.000 4300.000 2000.000 4700.000 4300.000 2001.000 + 4800.000 4300.000 2000.000 4800.000 4300.000 2001.000 + 4900.000 4300.000 2000.000 4900.000 4300.000 2001.000 + 5000.000 4300.000 2000.000 5000.000 4300.000 2001.000 + 0.000 4400.000 2000.000 0.000 4400.000 2001.000 + 100.000 4400.000 2000.000 100.000 4400.000 2001.000 + 200.000 4400.000 2000.000 200.000 4400.000 2001.000 + 300.000 4400.000 2000.000 300.000 4400.000 2001.000 + 400.000 4400.000 2000.000 400.000 4400.000 2001.000 + 500.000 4400.000 2000.000 500.000 4400.000 2001.000 + 600.000 4400.000 2000.000 600.000 4400.000 2001.000 + 700.000 4400.000 2000.000 700.000 4400.000 2001.000 + 800.000 4400.000 2000.000 800.000 4400.000 2001.000 + 900.000 4400.000 2000.000 900.000 4400.000 2001.000 + 1000.000 4400.000 2000.000 1000.000 4400.000 2001.000 + 1100.000 4400.000 2000.000 1100.000 4400.000 2001.000 + 1200.000 4400.000 2000.000 1200.000 4400.000 2001.000 + 1300.000 4400.000 2000.000 1300.000 4400.000 2001.000 + 1400.000 4400.000 2000.000 1400.000 4400.000 2001.000 + 1500.000 4400.000 2000.000 1500.000 4400.000 2001.000 + 1600.000 4400.000 2000.000 1600.000 4400.000 2001.000 + 1700.000 4400.000 2000.000 1700.000 4400.000 2001.000 + 1800.000 4400.000 2000.000 1800.000 4400.000 2001.000 + 1900.000 4400.000 2000.000 1900.000 4400.000 2001.000 + 2000.000 4400.000 2000.000 2000.000 4400.000 2001.000 + 2100.000 4400.000 2000.000 2100.000 4400.000 2001.000 + 2200.000 4400.000 2000.000 2200.000 4400.000 2001.000 + 2300.000 4400.000 2000.000 2300.000 4400.000 2001.000 + 2400.000 4400.000 2000.000 2400.000 4400.000 2001.000 + 2500.000 4400.000 2000.000 2500.000 4400.000 2001.000 + 2600.000 4400.000 2000.000 2600.000 4400.000 2001.000 + 2700.000 4400.000 2000.000 2700.000 4400.000 2001.000 + 2800.000 4400.000 2000.000 2800.000 4400.000 2001.000 + 2900.000 4400.000 2000.000 2900.000 4400.000 2001.000 + 3000.000 4400.000 2000.000 3000.000 4400.000 2001.000 + 3100.000 4400.000 2000.000 3100.000 4400.000 2001.000 + 3200.000 4400.000 2000.000 3200.000 4400.000 2001.000 + 3300.000 4400.000 2000.000 3300.000 4400.000 2001.000 + 3400.000 4400.000 2000.000 3400.000 4400.000 2001.000 + 3500.000 4400.000 2000.000 3500.000 4400.000 2001.000 + 3600.000 4400.000 2000.000 3600.000 4400.000 2001.000 + 3700.000 4400.000 2000.000 3700.000 4400.000 2001.000 + 3800.000 4400.000 2000.000 3800.000 4400.000 2001.000 + 3900.000 4400.000 2000.000 3900.000 4400.000 2001.000 + 4000.000 4400.000 2000.000 4000.000 4400.000 2001.000 + 4100.000 4400.000 2000.000 4100.000 4400.000 2001.000 + 4200.000 4400.000 2000.000 4200.000 4400.000 2001.000 + 4300.000 4400.000 2000.000 4300.000 4400.000 2001.000 + 4400.000 4400.000 2000.000 4400.000 4400.000 2001.000 + 4500.000 4400.000 2000.000 4500.000 4400.000 2001.000 + 4600.000 4400.000 2000.000 4600.000 4400.000 2001.000 + 4700.000 4400.000 2000.000 4700.000 4400.000 2001.000 + 4800.000 4400.000 2000.000 4800.000 4400.000 2001.000 + 4900.000 4400.000 2000.000 4900.000 4400.000 2001.000 + 5000.000 4400.000 2000.000 5000.000 4400.000 2001.000 + 0.000 4500.000 2000.000 0.000 4500.000 2001.000 + 100.000 4500.000 2000.000 100.000 4500.000 2001.000 + 200.000 4500.000 2000.000 200.000 4500.000 2001.000 + 300.000 4500.000 2000.000 300.000 4500.000 2001.000 + 400.000 4500.000 2000.000 400.000 4500.000 2001.000 + 500.000 4500.000 2000.000 500.000 4500.000 2001.000 + 600.000 4500.000 2000.000 600.000 4500.000 2001.000 + 700.000 4500.000 2000.000 700.000 4500.000 2001.000 + 800.000 4500.000 2000.000 800.000 4500.000 2001.000 + 900.000 4500.000 2000.000 900.000 4500.000 2001.000 + 1000.000 4500.000 2000.000 1000.000 4500.000 2001.000 + 1100.000 4500.000 2000.000 1100.000 4500.000 2001.000 + 1200.000 4500.000 2000.000 1200.000 4500.000 2001.000 + 1300.000 4500.000 2000.000 1300.000 4500.000 2001.000 + 1400.000 4500.000 2000.000 1400.000 4500.000 2001.000 + 1500.000 4500.000 2000.000 1500.000 4500.000 2001.000 + 1600.000 4500.000 2000.000 1600.000 4500.000 2001.000 + 1700.000 4500.000 2000.000 1700.000 4500.000 2001.000 + 1800.000 4500.000 2000.000 1800.000 4500.000 2001.000 + 1900.000 4500.000 2000.000 1900.000 4500.000 2001.000 + 2000.000 4500.000 2000.000 2000.000 4500.000 2001.000 + 2100.000 4500.000 2000.000 2100.000 4500.000 2001.000 + 2200.000 4500.000 2000.000 2200.000 4500.000 2001.000 + 2300.000 4500.000 2000.000 2300.000 4500.000 2001.000 + 2400.000 4500.000 2000.000 2400.000 4500.000 2001.000 + 2500.000 4500.000 2000.000 2500.000 4500.000 2001.000 + 2600.000 4500.000 2000.000 2600.000 4500.000 2001.000 + 2700.000 4500.000 2000.000 2700.000 4500.000 2001.000 + 2800.000 4500.000 2000.000 2800.000 4500.000 2001.000 + 2900.000 4500.000 2000.000 2900.000 4500.000 2001.000 + 3000.000 4500.000 2000.000 3000.000 4500.000 2001.000 + 3100.000 4500.000 2000.000 3100.000 4500.000 2001.000 + 3200.000 4500.000 2000.000 3200.000 4500.000 2001.000 + 3300.000 4500.000 2000.000 3300.000 4500.000 2001.000 + 3400.000 4500.000 2000.000 3400.000 4500.000 2001.000 + 3500.000 4500.000 2000.000 3500.000 4500.000 2001.000 + 3600.000 4500.000 2000.000 3600.000 4500.000 2001.000 + 3700.000 4500.000 2000.000 3700.000 4500.000 2001.000 + 3800.000 4500.000 2000.000 3800.000 4500.000 2001.000 + 3900.000 4500.000 2000.000 3900.000 4500.000 2001.000 + 4000.000 4500.000 2000.000 4000.000 4500.000 2001.000 + 4100.000 4500.000 2000.000 4100.000 4500.000 2001.000 + 4200.000 4500.000 2000.000 4200.000 4500.000 2001.000 + 4300.000 4500.000 2000.000 4300.000 4500.000 2001.000 + 4400.000 4500.000 2000.000 4400.000 4500.000 2001.000 + 4500.000 4500.000 2000.000 4500.000 4500.000 2001.000 + 4600.000 4500.000 2000.000 4600.000 4500.000 2001.000 + 4700.000 4500.000 2000.000 4700.000 4500.000 2001.000 + 4800.000 4500.000 2000.000 4800.000 4500.000 2001.000 + 4900.000 4500.000 2000.000 4900.000 4500.000 2001.000 + 5000.000 4500.000 2000.000 5000.000 4500.000 2001.000 + 0.000 4600.000 2000.000 0.000 4600.000 2001.000 + 100.000 4600.000 2000.000 100.000 4600.000 2001.000 + 200.000 4600.000 2000.000 200.000 4600.000 2001.000 + 300.000 4600.000 2000.000 300.000 4600.000 2001.000 + 400.000 4600.000 2000.000 400.000 4600.000 2001.000 + 500.000 4600.000 2000.000 500.000 4600.000 2001.000 + 600.000 4600.000 2000.000 600.000 4600.000 2001.000 + 700.000 4600.000 2000.000 700.000 4600.000 2001.000 + 800.000 4600.000 2000.000 800.000 4600.000 2001.000 + 900.000 4600.000 2000.000 900.000 4600.000 2001.000 + 1000.000 4600.000 2000.000 1000.000 4600.000 2001.000 + 1100.000 4600.000 2000.000 1100.000 4600.000 2001.000 + 1200.000 4600.000 2000.000 1200.000 4600.000 2001.000 + 1300.000 4600.000 2000.000 1300.000 4600.000 2001.000 + 1400.000 4600.000 2000.000 1400.000 4600.000 2001.000 + 1500.000 4600.000 2000.000 1500.000 4600.000 2001.000 + 1600.000 4600.000 2000.000 1600.000 4600.000 2001.000 + 1700.000 4600.000 2000.000 1700.000 4600.000 2001.000 + 1800.000 4600.000 2000.000 1800.000 4600.000 2001.000 + 1900.000 4600.000 2000.000 1900.000 4600.000 2001.000 + 2000.000 4600.000 2000.000 2000.000 4600.000 2001.000 + 2100.000 4600.000 2000.000 2100.000 4600.000 2001.000 + 2200.000 4600.000 2000.000 2200.000 4600.000 2001.000 + 2300.000 4600.000 2000.000 2300.000 4600.000 2001.000 + 2400.000 4600.000 2000.000 2400.000 4600.000 2001.000 + 2500.000 4600.000 2000.000 2500.000 4600.000 2001.000 + 2600.000 4600.000 2000.000 2600.000 4600.000 2001.000 + 2700.000 4600.000 2000.000 2700.000 4600.000 2001.000 + 2800.000 4600.000 2000.000 2800.000 4600.000 2001.000 + 2900.000 4600.000 2000.000 2900.000 4600.000 2001.000 + 3000.000 4600.000 2000.000 3000.000 4600.000 2001.000 + 3100.000 4600.000 2000.000 3100.000 4600.000 2001.000 + 3200.000 4600.000 2000.000 3200.000 4600.000 2001.000 + 3300.000 4600.000 2000.000 3300.000 4600.000 2001.000 + 3400.000 4600.000 2000.000 3400.000 4600.000 2001.000 + 3500.000 4600.000 2000.000 3500.000 4600.000 2001.000 + 3600.000 4600.000 2000.000 3600.000 4600.000 2001.000 + 3700.000 4600.000 2000.000 3700.000 4600.000 2001.000 + 3800.000 4600.000 2000.000 3800.000 4600.000 2001.000 + 3900.000 4600.000 2000.000 3900.000 4600.000 2001.000 + 4000.000 4600.000 2000.000 4000.000 4600.000 2001.000 + 4100.000 4600.000 2000.000 4100.000 4600.000 2001.000 + 4200.000 4600.000 2000.000 4200.000 4600.000 2001.000 + 4300.000 4600.000 2000.000 4300.000 4600.000 2001.000 + 4400.000 4600.000 2000.000 4400.000 4600.000 2001.000 + 4500.000 4600.000 2000.000 4500.000 4600.000 2001.000 + 4600.000 4600.000 2000.000 4600.000 4600.000 2001.000 + 4700.000 4600.000 2000.000 4700.000 4600.000 2001.000 + 4800.000 4600.000 2000.000 4800.000 4600.000 2001.000 + 4900.000 4600.000 2000.000 4900.000 4600.000 2001.000 + 5000.000 4600.000 2000.000 5000.000 4600.000 2001.000 + 0.000 4700.000 2000.000 0.000 4700.000 2001.000 + 100.000 4700.000 2000.000 100.000 4700.000 2001.000 + 200.000 4700.000 2000.000 200.000 4700.000 2001.000 + 300.000 4700.000 2000.000 300.000 4700.000 2001.000 + 400.000 4700.000 2000.000 400.000 4700.000 2001.000 + 500.000 4700.000 2000.000 500.000 4700.000 2001.000 + 600.000 4700.000 2000.000 600.000 4700.000 2001.000 + 700.000 4700.000 2000.000 700.000 4700.000 2001.000 + 800.000 4700.000 2000.000 800.000 4700.000 2001.000 + 900.000 4700.000 2000.000 900.000 4700.000 2001.000 + 1000.000 4700.000 2000.000 1000.000 4700.000 2001.000 + 1100.000 4700.000 2000.000 1100.000 4700.000 2001.000 + 1200.000 4700.000 2000.000 1200.000 4700.000 2001.000 + 1300.000 4700.000 2000.000 1300.000 4700.000 2001.000 + 1400.000 4700.000 2000.000 1400.000 4700.000 2001.000 + 1500.000 4700.000 2000.000 1500.000 4700.000 2001.000 + 1600.000 4700.000 2000.000 1600.000 4700.000 2001.000 + 1700.000 4700.000 2000.000 1700.000 4700.000 2001.000 + 1800.000 4700.000 2000.000 1800.000 4700.000 2001.000 + 1900.000 4700.000 2000.000 1900.000 4700.000 2001.000 + 2000.000 4700.000 2000.000 2000.000 4700.000 2001.000 + 2100.000 4700.000 2000.000 2100.000 4700.000 2001.000 + 2200.000 4700.000 2000.000 2200.000 4700.000 2001.000 + 2300.000 4700.000 2000.000 2300.000 4700.000 2001.000 + 2400.000 4700.000 2000.000 2400.000 4700.000 2001.000 + 2500.000 4700.000 2000.000 2500.000 4700.000 2001.000 + 2600.000 4700.000 2000.000 2600.000 4700.000 2001.000 + 2700.000 4700.000 2000.000 2700.000 4700.000 2001.000 + 2800.000 4700.000 2000.000 2800.000 4700.000 2001.000 + 2900.000 4700.000 2000.000 2900.000 4700.000 2001.000 + 3000.000 4700.000 2000.000 3000.000 4700.000 2001.000 + 3100.000 4700.000 2000.000 3100.000 4700.000 2001.000 + 3200.000 4700.000 2000.000 3200.000 4700.000 2001.000 + 3300.000 4700.000 2000.000 3300.000 4700.000 2001.000 + 3400.000 4700.000 2000.000 3400.000 4700.000 2001.000 + 3500.000 4700.000 2000.000 3500.000 4700.000 2001.000 + 3600.000 4700.000 2000.000 3600.000 4700.000 2001.000 + 3700.000 4700.000 2000.000 3700.000 4700.000 2001.000 + 3800.000 4700.000 2000.000 3800.000 4700.000 2001.000 + 3900.000 4700.000 2000.000 3900.000 4700.000 2001.000 + 4000.000 4700.000 2000.000 4000.000 4700.000 2001.000 + 4100.000 4700.000 2000.000 4100.000 4700.000 2001.000 + 4200.000 4700.000 2000.000 4200.000 4700.000 2001.000 + 4300.000 4700.000 2000.000 4300.000 4700.000 2001.000 + 4400.000 4700.000 2000.000 4400.000 4700.000 2001.000 + 4500.000 4700.000 2000.000 4500.000 4700.000 2001.000 + 4600.000 4700.000 2000.000 4600.000 4700.000 2001.000 + 4700.000 4700.000 2000.000 4700.000 4700.000 2001.000 + 4800.000 4700.000 2000.000 4800.000 4700.000 2001.000 + 4900.000 4700.000 2000.000 4900.000 4700.000 2001.000 + 5000.000 4700.000 2000.000 5000.000 4700.000 2001.000 + 0.000 4800.000 2000.000 0.000 4800.000 2001.000 + 100.000 4800.000 2000.000 100.000 4800.000 2001.000 + 200.000 4800.000 2000.000 200.000 4800.000 2001.000 + 300.000 4800.000 2000.000 300.000 4800.000 2001.000 + 400.000 4800.000 2000.000 400.000 4800.000 2001.000 + 500.000 4800.000 2000.000 500.000 4800.000 2001.000 + 600.000 4800.000 2000.000 600.000 4800.000 2001.000 + 700.000 4800.000 2000.000 700.000 4800.000 2001.000 + 800.000 4800.000 2000.000 800.000 4800.000 2001.000 + 900.000 4800.000 2000.000 900.000 4800.000 2001.000 + 1000.000 4800.000 2000.000 1000.000 4800.000 2001.000 + 1100.000 4800.000 2000.000 1100.000 4800.000 2001.000 + 1200.000 4800.000 2000.000 1200.000 4800.000 2001.000 + 1300.000 4800.000 2000.000 1300.000 4800.000 2001.000 + 1400.000 4800.000 2000.000 1400.000 4800.000 2001.000 + 1500.000 4800.000 2000.000 1500.000 4800.000 2001.000 + 1600.000 4800.000 2000.000 1600.000 4800.000 2001.000 + 1700.000 4800.000 2000.000 1700.000 4800.000 2001.000 + 1800.000 4800.000 2000.000 1800.000 4800.000 2001.000 + 1900.000 4800.000 2000.000 1900.000 4800.000 2001.000 + 2000.000 4800.000 2000.000 2000.000 4800.000 2001.000 + 2100.000 4800.000 2000.000 2100.000 4800.000 2001.000 + 2200.000 4800.000 2000.000 2200.000 4800.000 2001.000 + 2300.000 4800.000 2000.000 2300.000 4800.000 2001.000 + 2400.000 4800.000 2000.000 2400.000 4800.000 2001.000 + 2500.000 4800.000 2000.000 2500.000 4800.000 2001.000 + 2600.000 4800.000 2000.000 2600.000 4800.000 2001.000 + 2700.000 4800.000 2000.000 2700.000 4800.000 2001.000 + 2800.000 4800.000 2000.000 2800.000 4800.000 2001.000 + 2900.000 4800.000 2000.000 2900.000 4800.000 2001.000 + 3000.000 4800.000 2000.000 3000.000 4800.000 2001.000 + 3100.000 4800.000 2000.000 3100.000 4800.000 2001.000 + 3200.000 4800.000 2000.000 3200.000 4800.000 2001.000 + 3300.000 4800.000 2000.000 3300.000 4800.000 2001.000 + 3400.000 4800.000 2000.000 3400.000 4800.000 2001.000 + 3500.000 4800.000 2000.000 3500.000 4800.000 2001.000 + 3600.000 4800.000 2000.000 3600.000 4800.000 2001.000 + 3700.000 4800.000 2000.000 3700.000 4800.000 2001.000 + 3800.000 4800.000 2000.000 3800.000 4800.000 2001.000 + 3900.000 4800.000 2000.000 3900.000 4800.000 2001.000 + 4000.000 4800.000 2000.000 4000.000 4800.000 2001.000 + 4100.000 4800.000 2000.000 4100.000 4800.000 2001.000 + 4200.000 4800.000 2000.000 4200.000 4800.000 2001.000 + 4300.000 4800.000 2000.000 4300.000 4800.000 2001.000 + 4400.000 4800.000 2000.000 4400.000 4800.000 2001.000 + 4500.000 4800.000 2000.000 4500.000 4800.000 2001.000 + 4600.000 4800.000 2000.000 4600.000 4800.000 2001.000 + 4700.000 4800.000 2000.000 4700.000 4800.000 2001.000 + 4800.000 4800.000 2000.000 4800.000 4800.000 2001.000 + 4900.000 4800.000 2000.000 4900.000 4800.000 2001.000 + 5000.000 4800.000 2000.000 5000.000 4800.000 2001.000 + 0.000 4900.000 2000.000 0.000 4900.000 2001.000 + 100.000 4900.000 2000.000 100.000 4900.000 2001.000 + 200.000 4900.000 2000.000 200.000 4900.000 2001.000 + 300.000 4900.000 2000.000 300.000 4900.000 2001.000 + 400.000 4900.000 2000.000 400.000 4900.000 2001.000 + 500.000 4900.000 2000.000 500.000 4900.000 2001.000 + 600.000 4900.000 2000.000 600.000 4900.000 2001.000 + 700.000 4900.000 2000.000 700.000 4900.000 2001.000 + 800.000 4900.000 2000.000 800.000 4900.000 2001.000 + 900.000 4900.000 2000.000 900.000 4900.000 2001.000 + 1000.000 4900.000 2000.000 1000.000 4900.000 2001.000 + 1100.000 4900.000 2000.000 1100.000 4900.000 2001.000 + 1200.000 4900.000 2000.000 1200.000 4900.000 2001.000 + 1300.000 4900.000 2000.000 1300.000 4900.000 2001.000 + 1400.000 4900.000 2000.000 1400.000 4900.000 2001.000 + 1500.000 4900.000 2000.000 1500.000 4900.000 2001.000 + 1600.000 4900.000 2000.000 1600.000 4900.000 2001.000 + 1700.000 4900.000 2000.000 1700.000 4900.000 2001.000 + 1800.000 4900.000 2000.000 1800.000 4900.000 2001.000 + 1900.000 4900.000 2000.000 1900.000 4900.000 2001.000 + 2000.000 4900.000 2000.000 2000.000 4900.000 2001.000 + 2100.000 4900.000 2000.000 2100.000 4900.000 2001.000 + 2200.000 4900.000 2000.000 2200.000 4900.000 2001.000 + 2300.000 4900.000 2000.000 2300.000 4900.000 2001.000 + 2400.000 4900.000 2000.000 2400.000 4900.000 2001.000 + 2500.000 4900.000 2000.000 2500.000 4900.000 2001.000 + 2600.000 4900.000 2000.000 2600.000 4900.000 2001.000 + 2700.000 4900.000 2000.000 2700.000 4900.000 2001.000 + 2800.000 4900.000 2000.000 2800.000 4900.000 2001.000 + 2900.000 4900.000 2000.000 2900.000 4900.000 2001.000 + 3000.000 4900.000 2000.000 3000.000 4900.000 2001.000 + 3100.000 4900.000 2000.000 3100.000 4900.000 2001.000 + 3200.000 4900.000 2000.000 3200.000 4900.000 2001.000 + 3300.000 4900.000 2000.000 3300.000 4900.000 2001.000 + 3400.000 4900.000 2000.000 3400.000 4900.000 2001.000 + 3500.000 4900.000 2000.000 3500.000 4900.000 2001.000 + 3600.000 4900.000 2000.000 3600.000 4900.000 2001.000 + 3700.000 4900.000 2000.000 3700.000 4900.000 2001.000 + 3800.000 4900.000 2000.000 3800.000 4900.000 2001.000 + 3900.000 4900.000 2000.000 3900.000 4900.000 2001.000 + 4000.000 4900.000 2000.000 4000.000 4900.000 2001.000 + 4100.000 4900.000 2000.000 4100.000 4900.000 2001.000 + 4200.000 4900.000 2000.000 4200.000 4900.000 2001.000 + 4300.000 4900.000 2000.000 4300.000 4900.000 2001.000 + 4400.000 4900.000 2000.000 4400.000 4900.000 2001.000 + 4500.000 4900.000 2000.000 4500.000 4900.000 2001.000 + 4600.000 4900.000 2000.000 4600.000 4900.000 2001.000 + 4700.000 4900.000 2000.000 4700.000 4900.000 2001.000 + 4800.000 4900.000 2000.000 4800.000 4900.000 2001.000 + 4900.000 4900.000 2000.000 4900.000 4900.000 2001.000 + 5000.000 4900.000 2000.000 5000.000 4900.000 2001.000 + 0.000 5000.000 2000.000 0.000 5000.000 2001.000 + 100.000 5000.000 2000.000 100.000 5000.000 2001.000 + 200.000 5000.000 2000.000 200.000 5000.000 2001.000 + 300.000 5000.000 2000.000 300.000 5000.000 2001.000 + 400.000 5000.000 2000.000 400.000 5000.000 2001.000 + 500.000 5000.000 2000.000 500.000 5000.000 2001.000 + 600.000 5000.000 2000.000 600.000 5000.000 2001.000 + 700.000 5000.000 2000.000 700.000 5000.000 2001.000 + 800.000 5000.000 2000.000 800.000 5000.000 2001.000 + 900.000 5000.000 2000.000 900.000 5000.000 2001.000 + 1000.000 5000.000 2000.000 1000.000 5000.000 2001.000 + 1100.000 5000.000 2000.000 1100.000 5000.000 2001.000 + 1200.000 5000.000 2000.000 1200.000 5000.000 2001.000 + 1300.000 5000.000 2000.000 1300.000 5000.000 2001.000 + 1400.000 5000.000 2000.000 1400.000 5000.000 2001.000 + 1500.000 5000.000 2000.000 1500.000 5000.000 2001.000 + 1600.000 5000.000 2000.000 1600.000 5000.000 2001.000 + 1700.000 5000.000 2000.000 1700.000 5000.000 2001.000 + 1800.000 5000.000 2000.000 1800.000 5000.000 2001.000 + 1900.000 5000.000 2000.000 1900.000 5000.000 2001.000 + 2000.000 5000.000 2000.000 2000.000 5000.000 2001.000 + 2100.000 5000.000 2000.000 2100.000 5000.000 2001.000 + 2200.000 5000.000 2000.000 2200.000 5000.000 2001.000 + 2300.000 5000.000 2000.000 2300.000 5000.000 2001.000 + 2400.000 5000.000 2000.000 2400.000 5000.000 2001.000 + 2500.000 5000.000 2000.000 2500.000 5000.000 2001.000 + 2600.000 5000.000 2000.000 2600.000 5000.000 2001.000 + 2700.000 5000.000 2000.000 2700.000 5000.000 2001.000 + 2800.000 5000.000 2000.000 2800.000 5000.000 2001.000 + 2900.000 5000.000 2000.000 2900.000 5000.000 2001.000 + 3000.000 5000.000 2000.000 3000.000 5000.000 2001.000 + 3100.000 5000.000 2000.000 3100.000 5000.000 2001.000 + 3200.000 5000.000 2000.000 3200.000 5000.000 2001.000 + 3300.000 5000.000 2000.000 3300.000 5000.000 2001.000 + 3400.000 5000.000 2000.000 3400.000 5000.000 2001.000 + 3500.000 5000.000 2000.000 3500.000 5000.000 2001.000 + 3600.000 5000.000 2000.000 3600.000 5000.000 2001.000 + 3700.000 5000.000 2000.000 3700.000 5000.000 2001.000 + 3800.000 5000.000 2000.000 3800.000 5000.000 2001.000 + 3900.000 5000.000 2000.000 3900.000 5000.000 2001.000 + 4000.000 5000.000 2000.000 4000.000 5000.000 2001.000 + 4100.000 5000.000 2000.000 4100.000 5000.000 2001.000 + 4200.000 5000.000 2000.000 4200.000 5000.000 2001.000 + 4300.000 5000.000 2000.000 4300.000 5000.000 2001.000 + 4400.000 5000.000 2000.000 4400.000 5000.000 2001.000 + 4500.000 5000.000 2000.000 4500.000 5000.000 2001.000 + 4600.000 5000.000 2000.000 4600.000 5000.000 2001.000 + 4700.000 5000.000 2000.000 4700.000 5000.000 2001.000 + 4800.000 5000.000 2000.000 4800.000 5000.000 2001.000 + 4900.000 5000.000 2000.000 4900.000 5000.000 2001.000 + 5000.000 5000.000 2000.000 5000.000 5000.000 2001.000 + / + diff --git a/docs/tutorials/popt/5Spot/include/50X50X1.ZCORN b/docs/tutorials/popt/5Spot/include/50X50X1.ZCORN new file mode 100644 index 00000000..9a686803 --- /dev/null +++ b/docs/tutorials/popt/5Spot/include/50X50X1.ZCORN @@ -0,0 +1,3402 @@ +ZCORN + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 2000.000 2000.000 + 2000.000 2000.000 2000.000 2000.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 2001.000 2001.000 + 2001.000 2001.000 2001.000 2001.000 + / diff --git a/docs/tutorials/popt/5Spot/include/ALL.PVO b/docs/tutorials/popt/5Spot/include/ALL.PVO new file mode 100644 index 00000000..bc831f45 --- /dev/null +++ b/docs/tutorials/popt/5Spot/include/ALL.PVO @@ -0,0 +1,325 @@ + +-- Blackoil Tables for sample ZI at T= 50.00000 Deg C +-- With Peng-Robinson (3-Parameter) EoS +-- And Lohrenz-Bray-Clark Viscosity Correlation + +-- ECLIPSE 100 DENSITY data +-- Surface densities of Oil, Water and Gas: + +-- Units of METRIC + +DENSITY + 732.44803 1000.00000 0.93841 / + +-- 1 Stage separator at +-- Pressures 1.01325 +-- Temperatures 20.00000 +-- Pressures in BARSA Temperatures in Deg C + +--ECLIPSE 100 PVDG data +--(Differential liberation) +--Units are METRIC +--Method used : Whitson and Torp + +PVDG + +-- PRES BG VISC +-- BARSA RM3/SM3 CPOISE + + 1.01325 1.0840058 0.0089508 + 10.00000 0.1024721 0.0101596 + 20.00000 0.0495635 0.0108532 + 30.00000 0.0321958 0.0113443 + 40.00000 0.0235539 0.0117763 + 50.00000 0.0183847 0.0122129 + 60.00000 0.0149493 0.0126903 + 70.00000 0.0125046 0.0132358 + 80.00000 0.0106797 0.0138743 + 90.00000 0.0092686 0.0146316 + 94.09777 0.0087798 0.0149823 + 100.00000 0.0081570 0.0155178 + 110.00000 0.0072847 0.0165026 + 120.00000 0.0065932 0.0175665 + 130.00000 0.0060395 0.0186838 + 140.00000 0.0055916 0.0198291 + 150.00000 0.0052253 0.0209798 + 160.00000 0.0049225 0.0221186 + 170.00000 0.0046693 0.0232335 + 180.00000 0.0044552 0.0243170 + 190.00000 0.0042722 0.0253652 + 200.00000 0.0041142 0.0263768 + / + +--ECLIPSE 100 PVTO data +--(Differential liberation) +--Units are METRIC +--Method used : Whitson and Torp + +PVTO + +-- RS PRES BO VISC +-- SM3/SM3 BARSA RM3/SM3 CPOISE + + 0.00000 1.01325 1.03047 0.45443 --Saturated + 10.00000 1.02921 0.45948 + 20.00000 1.02783 0.46506 + 30.00000 1.02649 0.47058 + 40.00000 1.02518 0.47607 + 50.00000 1.02391 0.48151 + 60.00000 1.02266 0.48691 + 70.00000 1.02145 0.49227 + 80.00000 1.02026 0.49759 + 90.00000 1.01910 0.50286 + 94.09777 1.01863 0.50501 + 100.00000 1.01796 0.50810 + 110.00000 1.01685 0.51330 + 120.00000 1.01576 0.51846 + 130.00000 1.01470 0.52358 + 140.00000 1.01365 0.52867 + 150.00000 1.01263 0.53372 + 160.00000 1.01163 0.53873 + 170.00000 1.01065 0.54371 + 180.00000 1.00969 0.54866 + 190.00000 1.00874 0.55357 + 200.00000 1.00782 0.55845 / + 77.27831 10.00000 1.32872 0.22825 --Saturated + 20.00000 1.32474 0.23294 + 30.00000 1.32093 0.23759 + 40.00000 1.31726 0.24221 + 50.00000 1.31373 0.24680 + 60.00000 1.31033 0.25135 + 70.00000 1.30705 0.25587 + 80.00000 1.30389 0.26036 + 90.00000 1.30083 0.26482 + 94.09777 1.29960 0.26664 + 100.00000 1.29787 0.26925 + 110.00000 1.29501 0.27365 + 120.00000 1.29223 0.27803 + 130.00000 1.28954 0.28238 + 140.00000 1.28693 0.28670 + 150.00000 1.28439 0.29100 + 160.00000 1.28193 0.29528 + 170.00000 1.27953 0.29953 + 180.00000 1.27720 0.30375 + 190.00000 1.27494 0.30796 + 200.00000 1.27273 0.31214 / + 135.91959 20.00000 1.53829 0.19348 --Saturated + 30.00000 1.53286 0.19778 + 40.00000 1.52768 0.20204 + 50.00000 1.52272 0.20628 + 60.00000 1.51796 0.21048 + 70.00000 1.51340 0.21465 + 80.00000 1.50901 0.21880 + 90.00000 1.50478 0.22292 + 94.09777 1.50309 0.22460 + 100.00000 1.50071 0.22701 + 110.00000 1.49678 0.23108 + 120.00000 1.49299 0.23512 + 130.00000 1.48932 0.23914 + 140.00000 1.48577 0.24314 + 150.00000 1.48234 0.24712 + 160.00000 1.47901 0.25107 + 170.00000 1.47578 0.25500 + 180.00000 1.47265 0.25892 + 190.00000 1.46961 0.26281 + 200.00000 1.46665 0.26668 / + 179.16206 30.00000 1.68572 0.17283 --Saturated + 40.00000 1.67910 0.17685 + 50.00000 1.67279 0.18084 + 60.00000 1.66677 0.18479 + 70.00000 1.66101 0.18872 + 80.00000 1.65550 0.19262 + 90.00000 1.65020 0.19649 + 94.09777 1.64810 0.19808 + 100.00000 1.64512 0.20035 + 110.00000 1.64023 0.20417 + 120.00000 1.63552 0.20798 + 130.00000 1.63099 0.21176 + 140.00000 1.62661 0.21552 + 150.00000 1.62238 0.21926 + 160.00000 1.61829 0.22298 + 170.00000 1.61433 0.22669 + 180.00000 1.61049 0.23037 + 190.00000 1.60678 0.23404 + 200.00000 1.60318 0.23769 / + 219.49794 40.00000 1.82006 0.15668 --Saturated + 50.00000 1.81222 0.16045 + 60.00000 1.80477 0.16418 + 70.00000 1.79767 0.16790 + 80.00000 1.79090 0.17158 + 90.00000 1.78442 0.17524 + 94.09777 1.78185 0.17673 + 100.00000 1.77823 0.17887 + 110.00000 1.77228 0.18249 + 120.00000 1.76658 0.18608 + 130.00000 1.76109 0.18965 + 140.00000 1.75582 0.19320 + 150.00000 1.75073 0.19674 + 160.00000 1.74582 0.20025 + 170.00000 1.74108 0.20375 + 180.00000 1.73650 0.20723 + 190.00000 1.73207 0.21069 + 200.00000 1.72778 0.21414 / + 260.42208 50.00000 1.95472 0.14292 --Saturated + 60.00000 1.94553 0.14645 + 70.00000 1.93682 0.14996 + 80.00000 1.92855 0.15345 + 90.00000 1.92067 0.15690 + 94.09777 1.91755 0.15831 + 100.00000 1.91316 0.16034 + 110.00000 1.90598 0.16375 + 120.00000 1.89911 0.16714 + 130.00000 1.89252 0.17052 + 140.00000 1.88620 0.17387 + 150.00000 1.88012 0.17721 + 160.00000 1.87428 0.18053 + 170.00000 1.86864 0.18383 + 180.00000 1.86321 0.18712 + 190.00000 1.85796 0.19039 + 200.00000 1.85289 0.19365 / + 303.60507 60.00000 2.09598 0.13079 --Saturated + 70.00000 2.08526 0.13411 + 80.00000 2.07512 0.13740 + 90.00000 2.06552 0.14067 + 94.09777 2.06172 0.14200 + 100.00000 2.05640 0.14391 + 110.00000 2.04771 0.14713 + 120.00000 2.03943 0.15033 + 130.00000 2.03152 0.15351 + 140.00000 2.02395 0.15668 + 150.00000 2.01669 0.15982 + 160.00000 2.00973 0.16296 + 170.00000 2.00303 0.16607 + 180.00000 1.99659 0.16917 + 190.00000 1.99039 0.17226 + 200.00000 1.98441 0.17534 / + 350.28606 70.00000 2.24844 0.11992 --Saturated + 80.00000 2.23593 0.12303 + 90.00000 2.22414 0.12611 + 94.09777 2.21949 0.12737 + 100.00000 2.21299 0.12917 + 110.00000 2.20243 0.13221 + 120.00000 2.19240 0.13522 + 130.00000 2.18286 0.13822 + 140.00000 2.17375 0.14120 + 150.00000 2.16505 0.14416 + 160.00000 2.15673 0.14711 + 170.00000 2.14875 0.15005 + 180.00000 2.14110 0.15297 + 190.00000 2.13374 0.15588 + 200.00000 2.12666 0.15877 / + 401.69515 80.00000 2.41658 0.11006 --Saturated + 90.00000 2.40195 0.11297 + 94.09777 2.39622 0.11416 + 100.00000 2.38821 0.11586 + 110.00000 2.37525 0.11872 + 120.00000 2.36300 0.12156 + 130.00000 2.35139 0.12438 + 140.00000 2.34037 0.12718 + 150.00000 2.32987 0.12997 + 160.00000 2.31986 0.13274 + 170.00000 2.31030 0.13549 + 180.00000 2.30115 0.13824 + 190.00000 2.29238 0.14097 + 200.00000 2.28396 0.14369 / + 459.28262 90.00000 2.60570 0.10107 --Saturated + 94.09777 2.59852 0.10219 + 100.00000 2.58852 0.10379 + 110.00000 2.57242 0.10648 + 120.00000 2.55729 0.10915 + 130.00000 2.54302 0.11179 + 140.00000 2.52953 0.11442 + 150.00000 2.51675 0.11704 + 160.00000 2.50460 0.11964 + 170.00000 2.49304 0.12222 + 180.00000 2.48201 0.12479 + 190.00000 2.47148 0.12735 + 200.00000 2.46140 0.12990 / + 484.94227 94.09777 2.69027 0.09762 --Psat + 100.00000 2.67927 0.09918 + 110.00000 2.66160 0.10180 + 120.00000 2.64504 0.10440 + 130.00000 2.62946 0.10698 + 140.00000 2.61476 0.10955 + 150.00000 2.60086 0.11209 + 160.00000 2.58767 0.11462 + 170.00000 2.57514 0.11714 + 180.00000 2.56321 0.11964 + 190.00000 2.55182 0.12213 + 200.00000 2.54094 0.12461 / + 487.76708 100.00000 2.69029 0.09756 --Generated + 110.00000 2.67596 0.09963 + 120.00000 2.66014 0.10206 + 130.00000 2.64469 0.10455 + 140.00000 2.62989 0.10707 + 150.00000 2.61578 0.10959 + 160.00000 2.60235 0.11210 + 170.00000 2.58956 0.11461 + 180.00000 2.57735 0.11710 + 190.00000 2.56569 0.11959 + 200.00000 2.55454 0.12206 / + 492.58097 110.00000 2.69031 0.09746 --Generated + 120.00000 2.67524 0.09971 + 130.00000 2.65991 0.10213 + 140.00000 2.64501 0.10460 + 150.00000 2.63071 0.10709 + 160.00000 2.61704 0.10958 + 170.00000 2.60397 0.11207 + 180.00000 2.59149 0.11456 + 190.00000 2.57956 0.11704 + 200.00000 2.56814 0.11952 / + 497.44237 120.00000 2.69034 0.09737 --Generated + 130.00000 2.67514 0.09970 + 140.00000 2.66014 0.10212 + 150.00000 2.64564 0.10458 + 160.00000 2.63172 0.10706 + 170.00000 2.61839 0.10954 + 180.00000 2.60564 0.11202 + 190.00000 2.59343 0.11450 + 200.00000 2.58174 0.11697 / + 502.35174 130.00000 2.69037 0.09727 --Generated + 140.00000 2.67527 0.09965 + 150.00000 2.66057 0.10208 + 160.00000 2.64640 0.10454 + 170.00000 2.63281 0.10701 + 180.00000 2.61978 0.10948 + 190.00000 2.60730 0.11196 + 200.00000 2.59534 0.11442 / + 507.30957 140.00000 2.69039 0.09717 --Generated + 150.00000 2.67549 0.09958 + 160.00000 2.66108 0.10202 + 170.00000 2.64722 0.10448 + 180.00000 2.63392 0.10694 + 190.00000 2.62117 0.10941 + 200.00000 2.60894 0.11188 / + 512.31632 150.00000 2.69042 0.09708 --Generated + 160.00000 2.67576 0.09950 + 170.00000 2.66164 0.10195 + 180.00000 2.64807 0.10440 + 190.00000 2.63504 0.10687 + 200.00000 2.62255 0.10933 / + 517.37249 160.00000 2.69045 0.09698 --Generated + 170.00000 2.67606 0.09942 + 180.00000 2.66221 0.10187 + 190.00000 2.64891 0.10432 + 200.00000 2.63615 0.10678 / + 522.47856 170.00000 2.69047 0.09688 --Generated + 180.00000 2.67636 0.09933 + 190.00000 2.66278 0.10178 + 200.00000 2.64975 0.10424 / + 527.63502 180.00000 2.69050 0.09679 --Generated + 190.00000 2.67666 0.09924 + 200.00000 2.66335 0.10169 / + 532.84238 190.00000 2.69053 0.09669 --Generated + 200.00000 2.67695 0.09914 / + 538.10112 200.00000 2.69055 0.09659 --Generated + 210.00000 2.67698 0.09905 / + / + + +PVTW +-- Pref Bw Cw Vw Cvw +-- BARSA RM3/SM3 1/BARS CPOISE 1/BARS + 200.00000 1.01754 2.41829E-05 0.01 6.80341E-05 + / + diff --git a/docs/tutorials/popt/5Spot/include/ALL.RCP b/docs/tutorials/popt/5Spot/include/ALL.RCP new file mode 100644 index 00000000..43b10142 --- /dev/null +++ b/docs/tutorials/popt/5Spot/include/ALL.RCP @@ -0,0 +1,42 @@ + +-- SWOF generated by program SCAL.EXE at 11:33:57 on 09 Dec 97 + +SWOF + +-- Table 1 +-- Data from record KrPc(OW) (ID=5) + +--Sw Krw Kro Pc + 0.150000 0.000000 1.00000 1.00000 + 0.216667 0.000617284 0.624295 0.528479 + 0.283333 0.00493827 0.365950 0.435765 + 0.350000 0.0166667 0.197531 0.382160 + 0.416667 0.0395062 0.0952598 0.347229 + 0.483333 0.0771605 0.0390184 0.315025 + 0.550000 0.133333 0.0123457 0.282821 + 0.616667 0.211728 0.00243865 0.250617 + 0.683333 0.316049 0.000152416 0.218418 + 0.750000 0.450000 0.000000 0.186255 + 1.00000 1.00000 0.000000 0.000000 +/ + +-- SGOF generated by program SCAL.EXE at 11:33:57 on 09 Dec 97 + +SGOF + +-- Table 1 +-- Data from record KrPc(OG) (ID=6) + +--Sg Krg Kro Pc + 0.000000 0.000000 1.00000 0.000000 + 0.0500000 0.000000 0.593292 0.0523257 + 0.111111 0.000823045 0.292653 0.0696509 + 0.172222 0.00658436 0.131341 0.0845766 + 0.233333 0.0222222 0.0520860 0.0996870 + 0.294444 0.0526749 0.0174435 0.114797 + 0.355556 0.102881 0.00457271 0.129908 + 0.416667 0.177778 0.000813843 0.148709 + 0.477778 0.282305 7.14484e-005 0.167694 + 0.538889 0.421399 1.11638e-006 0.190079 + 0.600000 0.600000 0.000000 0.220960 +/ diff --git a/docs/tutorials/popt/5Spot/include/PERMX b/docs/tutorials/popt/5Spot/include/PERMX new file mode 100644 index 00000000..ec22f581 --- /dev/null +++ b/docs/tutorials/popt/5Spot/include/PERMX @@ -0,0 +1,2502 @@ +PERMX +538.6 +247.75 +117.15 +175.7 +115.75 +379.8 +256.2 +302.25 +164.9 +188.75 +825.95 +1436.0 +563.7 +241.55 +177.35 +250.5 +453.7 +128.8 +185.05 +310.35 +285.5 +55.5 +195.55 +313.6 +754.9 +1214.0 +512.35 +312.4 +266.35 +224.0 +264.45 +325.3 +279.7 +540.85 +951.45 +1145.7 +831.4 +1494.6 +340.8 +213.65 +135.2 +311.65 +191.6 +284.0 +264.15 +244.15 +146.1 +333.2 +238.3 +366.6 +434.7 +253.4 +130.4 +234.3 +160.7 +177.75 +331.55 +311.5 +224.1 +576.35 +667.1 +900.35 +581.65 +215.1 +352.95 +419.25 +353.85 +151.05 +369.7 +436.8 +235.5 +55.2 +246.25 +250.0 +730.0 +1004.3 +628.35 +569.45 +436.8 +182.2 +313.75 +286.75 +339.05 +594.75 +1290.35 +734.35 +1030.9 +1608.75 +683.3 +408.5 +298.6 +268.05 +207.35 +280.3 +366.55 +141.3 +162.55 +347.95 +359.6 +329.65 +400.0 +374.55 +226.05 +211.85 +147.85 +184.65 +362.05 +332.9 +351.75 +759.7 +821.65 +1210.5 +723.2 +347.65 +230.95 +573.65 +120.95 +179.45 +369.4 +452.75 +125.6 +179.6 +154.3 +80.2 +851.05 +1298.1 +495.1 +474.5 +182.85 +180.85 +372.7 +227.5 +294.1 +1290.8 +1381.15 +550.5 +1143.1 +1062.45 +1164.85 +786.25 +775.45 +489.75 +346.65 +231.75 +196.5 +413.8 +170.7 +339.0 +431.1 +400.6 +700.95 +403.1 +335.65 +176.1 +162.9 +175.4 +286.45 +297.85 +350.25 +421.15 +1112.05 +1018.95 +731.55 +279.25 +193.7 +137.75 +286.0 +107.9 +361.75 +343.4 +251.15 +212.05 +211.95 +238.75 +760.7 +817.2 +1015.7 +414.0 +174.65 +258.5 +561.9 +387.85 +463.45 +896.6 +985.6 +551.9 +522.0 +436.15 +575.55 +573.9 +628.25 +319.9 +258.9 +257.15 +247.35 +160.0 +208.4 +502.75 +390.5 +196.35 +476.3 +576.85 +585.55 +327.1 +127.0 +98.3 +199.95 +203.9 +416.65 +470.5 +1204.2 +389.4 +239.65 +302.1 +157.5 +167.75 +333.5 +288.4 +334.45 +203.95 +178.6 +205.1 +141.2 +434.85 +477.0 +1205.4 +517.4 +457.0 +216.4 +269.5 +511.15 +410.5 +867.05 +934.45 +502.05 +252.35 +415.15 +693.95 +722.5 +686.0 +838.35 +423.9 +598.5 +613.05 +497.7 +329.85 +41.6 +333.3 +563.35 +359.45 +447.15 +400.3 +399.95 +212.2 +250.25 +178.5 +161.15 +248.95 +351.4 +732.65 +1366.15 +705.4 +230.25 +215.9 +61.45 +270.85 +205.6 +408.7 +197.15 +390.2 +246.4 +149.2 +208.2 +184.75 +411.55 +1087.0 +896.2 +980.65 +201.55 +218.2 +444.65 +389.05 +974.25 +480.8 +878.1 +166.25 +271.75 +183.0 +825.55 +673.05 +1155.35 +798.9 +469.75 +911.95 +425.95 +111.35 +180.1 +407.55 +525.65 +441.0 +411.9 +404.05 +193.65 +157.85 +225.75 +218.7 +309.7 +144.35 +541.3 +436.1 +1136.85 +765.05 +200.85 +365.65 +236.45 +153.7 +415.45 +433.2 +193.1 +250.5 +271.45 +193.9 +139.85 +528.85 +797.15 +1043.95 +855.6 +792.3 +259.9 +178.15 +377.1 +842.45 +1266.1 +778.95 +266.85 +222.1 +226.9 +175.5 +238.25 +448.95 +582.7 +542.45 +725.8 +439.9 +256.1 +224.55 +165.95 +229.0 +355.95 +373.45 +507.25 +231.0 +491.75 +344.25 +238.1 +219.65 +391.5 +159.95 +220.2 +1029.15 +1476.5 +1053.95 +234.0 +222.75 +170.55 +240.8 +376.15 +377.25 +231.85 +258.7 +207.85 +248.2 +476.75 +283.3 +435.45 +1173.6 +497.9 +249.45 +284.6 +439.5 +636.7 +621.45 +1099.5 +365.8 +211.05 +148.75 +204.75 +234.9 +242.45 +440.2 +517.25 +611.05 +1048.55 +459.0 +214.3 +315.35 +127.95 +309.1 +274.2 +322.75 +975.45 +416.75 +349.25 +187.3 +321.4 +423.35 +524.4 +153.45 +174.35 +1064.15 +1035.75 +310.25 +253.6 +392.9 +135.9 +159.25 +429.05 +387.7 +178.6 +206.1 +392.85 +342.2 +282.75 +122.35 +502.7 +998.5 +623.6 +196.55 +155.25 +405.8 +499.45 +916.8 +511.7 +327.65 +382.85 +115.0 +239.25 +189.75 +156.45 +154.45 +302.15 +611.6 +1255.55 +491.7 +571.75 +429.8 +179.75 +246.65 +229.6 +424.05 +1182.4 +257.15 +580.5 +361.35 +474.7 +414.2 +463.7 +290.75 +181.0 +549.55 +823.1 +770.65 +340.55 +236.5 +176.2 +249.8 +430.65 +340.15 +117.95 +240.1 +487.35 +387.35 +226.05 +203.35 +512.85 +944.7 +908.5 +638.4 +211.85 +399.65 +1096.65 +1330.9 +720.2 +196.05 +199.4 +228.9 +204.85 +354.75 +358.45 +251.15 +239.95 +536.9 +1042.15 +1529.4 +612.5 +422.45 +259.7 +94.45 +176.4 +252.95 +895.6 +823.55 +532.9 +380.1 +416.25 +388.9 +355.05 +248.8 +291.05 +1119.9 +1092.1 +422.2 +356.55 +253.05 +235.5 +257.15 +346.5 +175.7 +192.8 +318.4 +556.05 +379.05 +187.65 +193.95 +856.95 +870.7 +965.1 +557.95 +136.15 +540.85 +1421.8 +527.5 +524.4 +358.8 +339.25 +214.5 +357.15 +280.8 +238.7 +406.8 +219.15 +514.7 +772.05 +1606.85 +420.5 +572.1 +234.45 +110.95 +144.5 +251.8 +1063.65 +1254.5 +787.1 +415.75 +233.9 +199.5 +484.05 +178.2 +238.7 +475.3 +1055.75 +640.9 +484.0 +181.45 +232.6 +345.0 +458.2 +272.75 +133.85 +418.7 +417.05 +319.3 +199.6 +279.25 +582.35 +1404.2 +1281.15 +421.85 +246.15 +307.95 +1083.15 +465.55 +307.75 +350.65 +369.25 +354.05 +195.4 +259.8 +217.45 +223.7 +307.15 +273.25 +498.1 +1200.6 +802.1 +1019.5 +389.4 +150.1 +100.75 +180.9 +1174.1 +1125.9 +467.2 +536.55 +295.3 +488.95 +286.9 +332.5 +366.6 +340.2 +1550.6 +892.15 +511.75 +481.85 +350.5 +424.8 +451.55 +267.45 +223.5 +360.35 +308.1 +331.6 +274.3 +266.35 +700.1 +957.4 +1024.3 +472.6 +289.3 +507.5 +1393.9 +428.2 +220.85 +219.65 +245.35 +364.75 +297.95 +322.4 +361.7 +243.4 +302.1 +232.65 +606.0 +844.8 +776.05 +324.75 +353.4 +235.15 +212.05 +223.3 +900.5 +1275.05 +844.35 +515.65 +230.8 +277.05 +277.65 +252.25 +530.15 +264.9 +1372.5 +605.7 +519.75 +473.75 +136.4 +287.9 +166.25 +214.45 +309.5 +254.05 +380.35 +183.0 +212.15 +177.7 +649.15 +1300.55 +499.7 +604.15 +444.65 +458.05 +1395.15 +354.9 +377.15 +239.45 +148.95 +305.3 +548.8 +204.25 +354.1 +269.65 +241.85 +229.8 +231.5 +486.65 +888.5 +647.6 +289.6 +267.7 +257.15 +356.95 +846.2 +1750.0 +794.2 +629.45 +435.75 +252.0 +415.3 +336.75 +536.15 +490.55 +1048.45 +767.95 +384.15 +529.5 +423.6 +397.8 +187.4 +202.7 +281.8 +370.25 +205.2 +284.95 +317.9 +203.05 +607.95 +1021.35 +871.25 +344.45 +600.5 +1106.0 +1207.45 +278.85 +332.25 +276.85 +194.85 +336.0 +294.75 +529.7 +260.85 +297.6 +333.15 +197.9 +323.9 +963.4 +798.15 +509.2 +259.3 +408.2 +414.15 +266.35 +381.35 +1593.0 +937.65 +1018.75 +605.25 +195.4 +293.7 +238.15 +531.1 +442.1 +878.85 +1082.9 +639.35 +355.15 +379.7 +186.55 +259.05 +191.55 +200.25 +424.3 +235.55 +287.3 +195.05 +243.45 +272.3 +761.15 +512.1 +468.55 +305.75 +805.25 +679.75 +394.3 +501.5 +281.65 +89.7 +195.75 +340.25 +357.1 +400.8 +454.3 +329.35 +168.95 +197.6 +654.05 +934.25 +668.0 +761.25 +585.2 +576.65 +230.0 +815.25 +874.75 +1334.2 +1471.2 +682.6 +593.45 +206.7 +160.85 +180.55 +221.9 +641.65 +1003.15 +530.4 +271.1 +215.45 +106.25 +232.9 +218.3 +197.35 +434.65 +458.4 +294.45 +166.1 +288.25 +408.3 +482.9 +600.15 +529.4 +935.75 +1302.15 +734.05 +345.2 +521.2 +312.75 +152.8 +257.85 +305.05 +298.9 +68.7 +266.8 +154.0 +131.5 +113.0 +306.25 +342.35 +482.8 +850.95 +806.0 +606.7 +440.3 +774.2 +791.55 +950.6 +896.4 +770.65 +476.45 +335.0 +200.75 +118.65 +149.4 +783.05 +1158.45 +476.0 +228.4 +124.35 +124.85 +204.15 +84.1 +427.4 +527.45 +364.1 +324.55 +255.15 +126.65 +454.35 +863.7 +582.85 +794.8 +926.6 +1076.45 +562.75 +372.3 +410.1 +344.55 +354.5 +231.6 +262.25 +224.75 +607.6 +194.3 +142.9 +147.25 +164.85 +389.45 +435.8 +782.3 +810.1 +781.05 +929.65 +220.2 +387.7 +1006.15 +507.75 +1047.85 +969.45 +244.5 +761.55 +221.35 +79.4 +384.35 +501.45 +1065.3 +1045.6 +161.5 +168.6 +256.25 +336.0 +297.1 +287.55 +405.5 +517.15 +541.15 +322.85 +209.5 +673.1 +697.75 +1156.9 +510.95 +1344.75 +795.25 +248.75 +357.0 +306.95 +157.35 +263.45 +157.2 +136.3 +162.15 +220.75 +277.0 +159.85 +279.45 +305.65 +186.05 +221.6 +684.3 +422.0 +847.6 +695.55 +867.65 +862.65 +1248.95 +409.0 +425.05 +1171.75 +1223.2 +435.2 +173.6 +108.55 +247.05 +612.65 +656.65 +951.75 +289.65 +97.25 +152.45 +323.55 +244.55 +365.95 +315.0 +421.9 +315.5 +231.25 +335.15 +381.0 +504.2 +1143.6 +311.3 +526.5 +882.35 +341.8 +286.5 +116.55 +212.8 +448.45 +285.3 +145.0 +178.4 +583.9 +547.95 +332.35 +243.2 +243.6 +148.65 +375.55 +370.95 +673.95 +607.8 +803.55 +777.9 +1381.25 +856.05 +550.8 +226.3 +680.55 +788.9 +736.05 +867.3 +216.0 +337.7 +762.6 +620.0 +777.2 +154.45 +102.75 +130.0 +204.5 +301.05 +302.8 +448.0 +257.8 +233.5 +149.45 +539.3 +220.45 +1079.9 +976.15 +783.8 +908.5 +894.65 +487.05 +199.1 +132.05 +256.15 +296.35 +119.0 +302.1 +129.2 +232.9 +501.65 +455.45 +274.05 +155.05 +238.3 +261.1 +273.9 +565.7 +839.7 +560.9 +461.75 +1366.85 +1164.45 +487.65 +225.85 +356.85 +750.6 +588.4 +990.3 +526.95 +536.95 +305.05 +851.7 +449.5 +440.8 +266.3 +134.75 +128.55 +160.55 +370.8 +218.85 +185.6 +174.85 +465.45 +442.75 +623.25 +774.05 +1003.65 +773.2 +656.45 +1092.6 +390.65 +170.05 +205.05 +241.15 +280.85 +229.3 +357.95 +71.75 +332.85 +264.25 +436.85 +217.7 +431.05 +232.3 +191.75 +246.05 +297.35 +357.95 +631.75 +681.6 +1193.5 +1016.45 +405.05 +182.25 +415.55 +480.7 +598.65 +797.1 +782.15 +814.2 +475.05 +889.45 +838.5 +543.5 +290.75 +378.25 +226.8 +300.4 +353.7 +175.4 +99.9 +156.75 +453.9 +151.15 +312.25 +1166.75 +1102.8 +799.05 +547.85 +1149.05 +329.15 +189.05 +332.95 +365.6 +265.3 +283.25 +296.1 +200.45 +132.6 +186.3 +617.15 +302.7 +494.8 +189.25 +73.75 +235.55 +150.2 +330.3 +562.6 +502.25 +979.4 +790.9 +298.65 +185.85 +410.55 +367.55 +345.8 +582.05 +993.85 +445.25 +497.4 +1326.2 +464.1 +740.35 +323.45 +209.45 +269.9 +216.8 +555.35 +257.6 +261.2 +163.2 +258.85 +99.25 +333.45 +504.8 +1351.0 +559.2 +975.1 +1351.6 +359.1 +228.15 +312.1 +218.6 +152.0 +259.05 +327.05 +199.35 +214.75 +215.65 +283.65 +218.8 +478.3 +347.85 +223.95 +279.8 +527.75 +429.65 +267.1 +491.35 +1549.3 +352.55 +219.0 +231.75 +408.4 +283.6 +166.65 +356.1 +1173.65 +1261.2 +430.65 +929.65 +798.6 +428.45 +398.75 +114.85 +264.4 +206.65 +240.55 +300.1 +206.85 +282.1 +138.95 +169.6 +339.25 +456.4 +699.25 +970.45 +1131.15 +1224.95 +219.1 +255.15 +276.95 +269.85 +142.45 +205.9 +476.3 +370.25 +448.1 +147.75 +106.5 +161.0 +354.3 +204.25 +264.2 +109.45 +449.0 +244.55 +658.6 +590.85 +585.25 +763.55 +119.45 +217.4 +240.45 +83.1 +194.8 +567.5 +884.85 +827.7 +838.45 +1055.45 +824.3 +250.45 +280.9 +227.45 +153.7 +320.5 +437.95 +352.3 +196.3 +271.0 +193.3 +102.65 +316.1 +758.75 +752.2 +1112.65 +386.45 +951.3 +696.05 +199.3 +236.65 +194.35 +279.5 +226.05 +374.65 +437.9 +407.2 +260.85 +231.25 +154.5 +184.65 +411.85 +198.05 +126.5 +398.95 +422.8 +466.3 +831.8 +852.95 +494.8 +186.5 +252.95 +328.75 +228.95 +231.4 +411.45 +454.6 +753.25 +1320.85 +1750.0 +750.15 +245.35 +322.7 +307.5 +210.45 +247.25 +395.9 +332.25 +194.15 +180.75 +161.6 +141.05 +297.15 +425.05 +473.85 +1180.25 +898.3 +1019.45 +591.75 +370.15 +360.85 +505.55 +183.8 +258.7 +162.15 +251.4 +357.75 +99.65 +66.6 +262.55 +471.25 +703.4 +395.85 +573.4 +915.9 +486.3 +697.8 +310.55 +492.8 +537.3 +126.35 +188.15 +396.25 +287.0 +380.1 +517.1 +305.1 +485.15 +1067.8 +1750.0 +481.2 +537.0 +285.05 +423.9 +248.15 +152.8 +332.25 +583.95 +231.7 +244.6 +287.2 +150.3 +346.75 +480.55 +777.6 +1195.65 +1291.0 +1664.6 +787.55 +247.4 +416.8 +478.15 +240.2 +121.5 +108.7 +278.8 +248.65 +121.05 +188.75 +602.0 +462.5 +366.8 +352.7 +787.25 +774.3 +312.1 +780.85 +791.15 +544.9 +395.35 +108.1 +150.6 +352.55 +476.5 +233.3 +219.8 +360.85 +476.2 +1181.8 +1750.0 +1051.8 +758.5 +406.3 +467.7 +270.6 +246.0 +253.55 +217.2 +264.35 +292.8 +291.4 +175.5 +184.3 +186.95 +321.55 +667.9 +1019.8 +1498.55 +841.55 +222.65 +238.35 +580.8 +153.55 +104.1 +178.6 +368.05 +236.1 +388.3 +376.5 +814.25 +763.4 +1028.7 +547.5 +592.25 +438.6 +549.0 +480.2 +305.9 +330.3 +239.95 +125.25 +165.05 +375.55 +373.8 +156.15 +180.5 +215.4 +356.7 +826.35 +1562.15 +1128.5 +801.4 +358.3 +412.0 +164.6 +280.15 +162.3 +339.05 +133.65 +245.3 +350.9 +174.15 +138.75 +163.2 +271.15 +750.5 +1557.4 +1750.0 +1019.55 +461.75 +172.9 +384.7 +315.55 +172.9 +216.05 +370.5 +257.75 +509.7 +349.7 +880.85 +819.15 +539.85 +714.3 +638.8 +596.65 +765.25 +463.05 +386.6 +276.55 +138.35 +101.25 +168.25 +171.5 +131.9 +120.65 +386.25 +346.05 +752.8 +923.5 +753.5 +1384.9 +822.65 +1141.5 +452.45 +205.85 +239.8 +129.6 +275.45 +101.8 +200.15 +210.95 +261.55 +88.45 +124.8 +322.85 +816.3 +1195.0 +1202.2 +1541.8 +402.45 +330.9 +236.75 +396.3 +174.4 +336.6 +645.45 +402.65 +637.35 +663.8 +1051.6 +1014.75 +584.55 +504.85 +453.4 +491.25 +588.85 +372.95 +154.8 +180.15 +190.5 +222.9 +256.95 +168.25 +181.6 +231.4 +517.95 +410.2 +1396.9 +406.0 +418.4 +233.3 +868.45 +941.0 +395.25 +409.55 +283.8 +305.4 +413.15 +295.6 +177.2 +304.25 +344.5 +208.15 +217.15 +372.85 +413.0 +885.75 +1130.05 +1428.7 +826.85 +290.7 +227.8 +305.55 +150.55 +641.2 +635.5 +678.65 +821.05 +449.65 +576.15 +771.55 +338.7 +496.15 +401.1 +376.35 +325.45 +220.35 +233.85 +278.75 +273.15 +134.05 +270.8 +198.2 +167.3 +202.15 +454.7 +698.9 +885.5 +861.45 +479.3 +478.4 +367.5 +751.6 +764.55 +348.5 +247.2 +260.25 +205.15 +352.25 +224.35 +340.1 +272.0 +488.35 +95.0 +359.25 +607.55 +762.8 +1750.0 +1494.8 +565.05 +353.5 +240.55 +180.9 +234.4 +879.0 +986.9 +802.85 +961.85 +335.1 +414.15 +327.7 +455.0 +327.75 +339.4 +292.6 +358.35 +159.3 +228.9 +581.8 +386.7 +88.95 +316.35 +191.4 +189.6 +351.35 +566.65 +792.15 +1080.75 +504.75 +429.65 +208.0 +548.15 +828.15 +868.9 +445.25 +222.2 +181.7 +355.35 +360.6 +264.35 +111.8 +155.1 +400.65 +182.5 +141.9 +204.05 +900.55 +1566.7 +1350.55 +761.85 +405.4 +154.1 +83.8 +257.55 +596.4 +791.3 +557.5 +648.95 +592.25 +350.0 +597.75 +348.35 +207.3 +237.8 +384.9 +137.75 +346.7 +398.15 +645.7 +356.1 +125.75 +110.75 +235.4 +154.15 +377.5 +770.1 +1028.25 +738.75 +464.35 +227.65 +102.95 +216.2 +518.15 +1370.3 +609.05 +462.5 +194.6 +381.45 +278.05 +139.6 +198.65 +291.65 +358.15 +189.25 +136.45 +294.65 +358.1 +1315.85 +1607.1 +609.85 +509.95 +113.65 +143.9 +512.0 +540.05 +1275.0 +544.1 +392.7 +437.0 +200.35 +305.85 +568.2 +271.7 +263.65 +270.9 +256.1 +183.7 +324.7 +488.35 +359.1 +80.5 +60.4 +157.05 +362.1 +788.45 +762.75 +939.95 +449.35 +473.3 +142.35 +100.1 +215.85 +406.25 +1282.7 +1010.3 +557.6 +428.15 +359.25 +258.45 +197.6 +341.25 +223.5 +505.75 +252.1 +354.4 +224.35 +349.2 +1109.9 +1444.9 +1519.0 +323.0 +108.0 +220.6 +574.35 +754.0 +1287.75 +706.6 +676.15 +357.85 +197.3 +368.0 +213.7 +315.8 +121.45 +380.3 +282.0 +184.45 +325.8 +471.55 +489.55 +265.7 +183.05 +280.95 +456.6 +773.05 +988.0 +1003.25 +546.7 +483.9 +105.15 +96.65 +100.6 +248.9 +1090.35 +1015.6 +735.05 +444.95 +207.4 +150.85 +272.4 +381.7 +302.5 +317.8 +124.7 +169.0 +246.7 +293.05 +1121.1 +1659.9 +1662.6 +319.9 +253.85 +186.05 +864.9 +966.35 +1635.25 +470.3 +330.55 +182.7 +96.2 +340.0 +430.1 +507.25 +412.6 +313.5 +255.8 +303.45 +336.95 +239.45 +246.75 +383.6 +169.0 +248.7 +515.55 +331.15 +1303.9 +510.5 +355.3 +356.75 +116.5 +253.85 +122.5 +379.1 +384.25 +1493.95 +955.5 +766.1 +234.6 +204.5 +261.15 +686.15 +240.3 +149.5 +216.25 +194.9 +143.05 +450.3 +730.65 +1750.0 +1198.05 +428.4 +260.9 +393.1 +366.0 +1021.75 +872.45 +552.45 +248.0 +119.65 +143.35 +272.1 +207.65 +499.85 +82.8 +116.0 +243.95 +473.3 +206.9 +227.2 +285.5 +344.5 +267.4 +645.75 +467.1 +1099.75 +1262.85 +574.25 +264.9 +271.55 +236.35 +191.8 +263.45 +365.35 +585.4 +920.0 +905.15 +479.2 +278.1 +223.25 +160.65 +284.65 +165.9 +283.35 +257.75 +124.65 +377.45 +326.5 +1114.1 +1337.75 +1750.0 +564.0 +358.35 +225.05 +644.7 +1215.5 +626.15 +317.5 +272.25 +277.25 +51.8 +334.15 +179.9 +322.1 +104.8 +115.85 +375.0 +339.8 +327.35 +222.6 +402.05 +665.85 +378.35 +247.35 +613.95 +1024.7 +505.0 +250.45 +178.75 +235.05 +203.8 +248.35 +253.65 +351.95 +593.85 +1110.25 +978.6 +683.35 +247.65 +136.8 +374.85 +172.5 +221.7 +187.05 +334.8 +219.6 +168.55 +789.25 +957.7 +1670.9 +1021.95 +887.55 +626.05 +302.9 +675.4 +1290.85 +556.55 +233.75 +216.4 +186.85 +145.4 +216.1 +266.0 +165.75 +98.5 +204.65 +502.85 +557.45 +186.5 +254.6 +267.15 +477.85 +297.1 +520.8 +1358.45 +1250.3 +405.55 +235.65 +332.1 +225.65 +351.0 +255.1 +371.4 +421.35 +268.4 +933.3 +1354.65 +533.65 +343.15 +112.55 +260.15 +266.65 +454.3 +287.7 +134.35 +222.45 +180.65 +414.25 +577.3 +1512.9 +846.35 +704.2 +762.45 +387.15 +807.8 +1104.5 +1056.9 +158.9 +303.95 +249.25 +215.55 +193.8 +223.0 +170.1 +200.55 +304.6 +488.95 +325.35 +254.65 +198.9 +116.95 +201.2 +321.35 +556.9 +1215.9 +795.5 +189.55 +194.8 +201.4 +240.9 +272.4 +337.0 +130.45 +423.1 +359.4 +651.3 +1375.2 +765.0 +184.3 +100.6 +317.5 +368.0 +409.45 +259.95 +187.65 +124.2 +159.3 +657.3 +1096.05 +855.4 +609.95 +874.55 +430.65 +596.2 +679.8 +630.65 +836.0 +486.45 +312.2 +179.9 +151.25 +136.55 +246.3 +263.85 +292.25 +220.85 +246.4 +356.7 +112.5 +347.75 +220.1 +213.85 +235.6 +542.25 +1017.2 +522.2 +391.85 +241.2 +168.15 +215.45 +201.85 +188.65 +301.1 +428.4 +399.6 +435.95 +927.15 +223.25 +184.5 +76.05 +443.2 +329.9 +448.1 +273.9 +272.8 +100.1 +237.75 +767.15 +663.6 +958.9 +323.15 +801.2 +774.9 +408.2 +652.2 +1188.4 +1035.35 +739.15 +251.75 +286.7 +149.0 +162.9 +242.2 +358.3 +418.75 +156.65 +296.95 +217.1 +138.3 +710.25 +256.35 +143.0 +301.9 +366.35 +960.55 +452.85 +226.5 +277.3 +228.9 +249.7 +166.05 +338.75 +234.1 +328.6 +348.7 +490.9 +1331.55 +931.15 +370.7 +106.7 +155.75 +397.95 +370.45 +100.5 +166.6 +227.1 +451.9 +1366.85 +950.15 +283.75 +516.9 +823.1 +1012.8 +295.0 +689.5 +1184.3 +893.7 +385.3 +383.5 +220.95 +80.6 +131.8 +434.8 +220.35 +237.15 +107.0 +323.7 +321.65 +153.95 +519.15 +276.55 +140.45 +443.0 +760.6 +607.05 +185.6 +280.7 +255.7 +321.5 +389.05 +127.4 +266.2 +184.05 +234.1 +311.7 +494.4 +1429.75 +584.7 +240.35 +108.95 +361.05 +435.15 +445.1 +166.65 +206.1 +269.05 +656.15 +1422.95 +769.9 +291.95 +433.5 +416.4 +1346.35 +758.15 +319.8 +726.35 +942.4 +700.65 +438.45 +165.45 +167.25 +217.4 +252.45 +166.8 +100.95 +296.0 +308.8 +284.05 +129.7 +344.55 +328.45 +219.65 +646.65 +937.65 +357.3 +345.35 +329.65 +293.2 +229.0 +295.7 +224.45 +231.4 +126.15 +129.45 +241.9 +782.7 +924.25 +749.95 +195.75 +297.5 +275.95 +280.55 +172.95 +259.25 +307.05 +511.9 +906.2 +881.4 +814.9 +509.3 +273.45 +314.9 +919.1 +795.85 +753.3 +876.5 +991.5 +714.9 +281.2 +149.1 +131.8 +310.45 +210.8 +86.75 +125.5 +169.15 +255.05 +677.35 +312.25 +334.55 +215.45 +168.25 +447.55 +1226.3 +754.8 +339.3 +332.95 +303.75 +323.55 +138.55 +237.7 +170.5 +135.45 +137.75 +382.9 +686.15 +1047.0 +583.55 +373.05 +237.7 +269.0 +174.1 +263.25 +324.45 +411.15 +746.7 +911.4 +637.8 +556.75 +161.9 +101.6 +335.2 +758.55 +943.2 +754.7 +753.85 +580.4 +385.15 +454.7 +155.1 +244.25 +406.15 +274.65 +158.15 +182.1 +242.95 +333.8 +158.75 +97.9 +422.8 +312.25 +303.05 +690.4 +1232.8 +765.9 +423.55 +398.25 +398.3 +282.15 +74.15 +168.9 +245.8 +137.45 +121.85 +463.0 +945.45 +1141.8 +470.8 +394.75 +270.4 +183.45 +191.05 +291.55 +553.3 +860.35 +821.15 +423.35 +520.85 +395.35 +150.25 +165.35 +231.85 +842.25 +940.55 +765.8 +881.0 +761.65 +665.4 +293.55 +204.15 +229.15 +449.55 +516.3 +193.25 +182.85 +104.45 +150.9 +275.65 +63.75 +230.65 +174.65 +192.1 +637.8 +818.65 +588.25 +431.45 +262.65 +208.0 +483.95 +237.0 +126.8 +205.7 +241.1 +478.3 +566.35 +485.4 +940.6 +463.7 +298.45 +313.15 +288.2 +347.1 +382.1 +736.9 +970.55 +894.0 +475.8 +398.25 +270.3 +308.45 +65.25 +198.85 +788.25 +752.3 +956.5 +1004.25 +913.1 +835.85 +274.9 +114.9 +235.65 +245.65 +431.75 +575.3 +193.6 +199.5 +250.3 +186.15 +356.85 +230.85 +563.8 +252.55 +803.7 +1266.6 +865.7 +224.1 +195.7 +221.95 +516.95 +110.15 +112.55 +180.35 +238.3 +256.9 +447.35 +870.05 +857.0 +605.05 +293.65 +295.85 +319.6 +206.2 +631.4 +538.3 +817.75 +788.95 +510.75 +184.7 +273.35 +133.2 +201.35 +163.95 +542.05 +914.35 +1006.45 +1229.65 +1335.25 +913.75 +395.75 +202.05 +158.9 +330.2 +344.9 +387.1 +181.65 +60.4 +267.4 +227.5 +511.25 +/ diff --git a/docs/tutorials/popt/5Spot/init_optim.toml b/docs/tutorials/popt/5Spot/init_optim.toml new file mode 100644 index 00000000..4c704b1e --- /dev/null +++ b/docs/tutorials/popt/5Spot/init_optim.toml @@ -0,0 +1,34 @@ +[ensemble] + ne = 10 + natural_gradient = false + [ensemble.controls] + rate_inj1 = {mean='initrates.npz', std='5%', limits=[0, 500]} + rate_inj2 = {mean='initrates.npz', std='5%', limits=[0, 500]} + rate_inj3 = {mean='initrates.npz', std='5%', limits=[0, 500]} + rate_inj4 = {mean='initrates.npz', std='5%', limits=[0, 500]} + +[optim] + transform = true + maxiter = 10 + step_size_adapt = 2 + savefolder = 'Results' + saveit = true + +[simulator] + parallel = 5 + runfile = '5SPOT' + datatype = ['FOPT', 'FGPT', 'FWPT', 'FWIT'] + reporttype = 'dates' + + [simulator.reportpoint] + start = '2000-02-01' + end = '2008-01-01' + freq = 'MS' + + [simulator.npv_const] + wop = 400 + wgp = 0.4 + wwp = 20 + wwi = 10 + disc = 0.08 + obj_scaling = -1.0e9 diff --git a/docs/tutorials/popt/5Spot/permx.png b/docs/tutorials/popt/5Spot/permx.png new file mode 100644 index 00000000..2e99f485 Binary files /dev/null and b/docs/tutorials/popt/5Spot/permx.png differ diff --git a/docs/tutorials/popt/5Spot/tutorial_popt.ipynb b/docs/tutorials/popt/5Spot/tutorial_popt.ipynb new file mode 100644 index 00000000..8d7284df --- /dev/null +++ b/docs/tutorials/popt/5Spot/tutorial_popt.ipynb @@ -0,0 +1,1972 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Tutorial for running the Python Optimization Toolbox (POPT)\n", + "\n", + "As an illustrative example we choose a 2D five-spot pattern: one producer at the centre of the field and four (water) injectors, one at each corner. The figure below shows the permeability field and the well positions. The grid is 50x50, and the porosity is 0.2. The optimization problem is to find the water injection rate for each injector, one value per year of the eight-year production period, that maximizes the net present value (NPV).\n", + "\n", + "\"drawing\"\n", + "
\n", + "POPT mirrors PIPT: an *ensemble* object owns the control perturbations and the gradient estimate, and an *optimizer* owns its own iteration loop. The first step is to load the necessary external and local modules.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "# Import global modules\n", + "import os\n", + "import shutil\n", + "from glob import glob\n", + "import numpy as np\n", + "import pandas as pd\n", + "import matplotlib.pyplot as plt\n", + "\n", + "# Import local modules\n", + "from input_output import read_config # the config reader\n", + "from popt.ensembles import GaussianEnsemble # control perturbations and gradients\n", + "from popt.optimization_methods import LineSearch # the optimizer; it owns its own loop\n", + "from subsurface.multphaseflow.opm import flow # the simulator we want to use\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Set the random seed:\n" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "np.random.seed(10_08_1997)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Each simulator call runs in its own En_<member> folder, which it creates with os.mkdir — so a folder left behind by an interrupted run makes the next one fail with FileExistsError. PET clears them when an ensemble is constructed, but not between runs, so we define a helper and call it before each optimization. That keeps the run cells safe to re-execute on their own.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "def clean_run_folders(*result_folders):\n", + " \"\"\"Remove simulator scratch folders, and any results being replaced.\"\"\"\n", + " for folder in glob('En_*'):\n", + " shutil.rmtree(folder, ignore_errors=True)\n", + " for folder in result_folders:\n", + " shutil.rmtree(folder, ignore_errors=True)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Read the input file. In this tutorial the input file is written as a .toml file, and consists of three main keys: ensemble, optim and simulator. The first contains keys related to the ensemble of control perturbations, the second the options for the optimization algorithm, and the third the options for the forward simulation model.\n", + "\n", + "The ensemble.controls table lists the control variables directly: each entry names one .mako placeholder, together with its mean, standard deviation and bounds. This is a simpler alternative to PIPT's prior_<name> tables — there is no need for a separate state list, since the keys of controls already give the names.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[ensemble]\n", + " ne = 10\n", + " natural_gradient = false\n", + " [ensemble.controls]\n", + " rate_inj1 = {mean='initrates.npz', std='5%', limits=[0, 500]}\n", + " rate_inj2 = {mean='initrates.npz', std='5%', limits=[0, 500]}\n", + " rate_inj3 = {mean='initrates.npz', std='5%', limits=[0, 500]}\n", + " rate_inj4 = {mean='initrates.npz', std='5%', limits=[0, 500]}\n", + "\n", + "[optim]\n", + " transform = true\n", + " maxiter = 10\n", + " step_size_adapt = 2\n", + " savefolder = 'Results'\n", + " saveit = true\n", + "\n", + "[simulator]\n", + " parallel = 5\n", + " runfile = '5SPOT'\n", + " datatype = ['FOPT', 'FGPT', 'FWPT', 'FWIT']\n", + " reporttype = 'dates'\n", + "\n", + " [simulator.reportpoint]\n", + " start = '2000-02-01'\n", + " end = '2008-01-01'\n", + " freq = 'MS'\n", + "\n", + " [simulator.npv_const]\n", + " wop = 400\n", + " wgp = 0.4\n", + " wwp = 20\n", + " wwi = 10\n", + " disc = 0.08\n", + " obj_scaling = -1.0e9\n" + ] + } + ], + "source": [ + "!cat init_optim.toml\n", + "ko, kf, ke = read_config.read('init_optim.toml')\n", + "# ko --> Optimization settings\n", + "# kf --> Simulator settings\n", + "# ke --> Ensemble settings\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Set the initial controls. The filename given as mean in the input file above must exist before the ensemble is built, and its arrays must match the .mako placeholders rate_inj1–rate_inj4. Each array holds one rate per year of the eight-year schedule, so all four injectors start at a flat 200 Sm3/day.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "rate = 8 * [200]\n", + "np.savez(\n", + " 'initrates.npz',\n", + " rate_inj1=rate,\n", + " rate_inj2=rate,\n", + " rate_inj3=rate,\n", + " rate_inj4=rate,\n", + ")\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Define the objective function. This is the one piece POPT does not supply: you hand it any callable that takes the simulated data and returns a scalar to be **minimized**. Here it is the discounted net present value, with the economic constants read from the npv_const block of the input file.\n", + "\n", + "Note the obj_scaling of -1e9: the negative sign turns maximizing NPV into a minimization, and the 1e9 puts the value in billions so the optimizer works on a sensible scale.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "DEFAULT_ECON = {\n", + " 'wop': 400.0, # Oil price: $/Sm3\n", + " 'wgp': 0.4, # Gas price: $/Sm3\n", + " 'wwp': 20.0, # Cost of water production per unit volume\n", + " 'wwi': 10.0, # Cost of water injection per unit volume\n", + " 'disc': 0.08, # Discount rate per year\n", + "}\n", + "\n", + "\n", + "def npv(pred_data: pd.DataFrame, **kwargs):\n", + " \"\"\"Discounted net present value of one simulated production profile.\"\"\"\n", + " # Economic parameters, from the config's npv_const block if present\n", + " input_dict = kwargs.get('input_dict', {})\n", + " econ = dict(input_dict.get('npv_const', DEFAULT_ECON))\n", + " scaling_factor = econ.pop('obj_scaling', 1.0)\n", + "\n", + " # Incremental volumes per report step\n", + " vol_oil = pred_data['FOPT'].diff()\n", + " vol_gas = pred_data['FGPT'].diff()\n", + " vol_water_prod = pred_data['FWPT'].diff()\n", + " vol_water_inj = pred_data['FWIT'].diff()\n", + "\n", + " # Time in years since the start of the run\n", + " time_index = pred_data.index.to_numpy()\n", + " years = (time_index - time_index[0]) / np.timedelta64(365, 'D')\n", + "\n", + " # Revenue, cost, and discounting\n", + " revenue = vol_oil * econ['wop'] + vol_gas * econ['wgp']\n", + " operating_cost = vol_water_prod * econ['wwp'] + vol_water_inj * econ['wwi']\n", + " discount_factor = (1.0 + econ['disc']) ** years\n", + "\n", + " return ((revenue - operating_cost) / discount_factor).sum() / scaling_factor\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Initialize the ensemble with the ensemble keys, the simulator and the objective function, then extract the initial control vector (x0), its covariance (cov) and the bounds. The ensemble is what turns a non-differentiable simulator into something gradient-based methods can use: it perturbs the controls, runs the simulator on each perturbation, and forms an ensemble approximation of the gradient.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "controls: [200. 200. 200. 200. 200. 200. 200. 200. 200. 200. 200. 200. 200. 200.\n", + " 200. 200. 200. 200. 200. 200. 200. 200. 200. 200. 200. 200. 200. 200.\n", + " 200. 200. 200. 200.]\n", + "bounds: (0, 500) ... (x32)\n" + ] + } + ], + "source": [ + "sim = flow(kf)\n", + "ensemble = GaussianEnsemble(ke, sim, npv)\n", + "\n", + "x0 = ensemble.get_state()\n", + "cov = ensemble.get_cov()\n", + "bounds = ensemble.get_bounds()\n", + "\n", + "print(f'controls: {x0}')\n", + "print(f'bounds: {bounds[0]} ... (x{len(bounds)})')\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Run the optimization with LineSearch, using BFGS as the search direction. During the run, useful information is written to the screen and to a log file. As in PIPT, there are two ways to do this — the class-level shortcut that constructs and runs in one call, or an instance you keep and drive yourself.\n", + "\n", + "The other supported method values are 'GD' (steepest descent, needs only the gradient) and 'Newton-CG' (needs a Hessian as well, passed as hess=ensemble.hessian). BFGS builds a curvature estimate from successive gradients, so it needs no Hessian.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2026-08-20│09:04:45 : ========== Starting Line Search Minimization (BFGS) ==========\n", + "2026-08-20│09:04:45 : \n", + " \n", + "USER-SPECIFIED OPTIONS:\n", + " transform: True\n", + " maxiter: 10\n", + " step_size_adapt: 2\n", + " savefolder: Results\n", + " saveit: True\n", + " datatype: ['FOPT', 'FGPT', 'FWPT', 'FWIT']\n", + "\n", + "2026-08-20│09:04:45 : Computing initial function value...\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "0b81c44e82bf4e5a801f4eb8b71c5ee3", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + " 0%| | 0/1 [00:00 5.136e+01\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "fd39f543969b4c83907f51adc56f90cc", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + " 0%| | 0/1 [00:00 1.028e+01\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "cbd077f4c1da4503824b6ac5611a201b", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + " 0%| | 0/1 [00:00 3.240e-01\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "a9d8a7248c7c4ab9838f525f63f69ca7", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + " 0%| | 0/1 [00:00 1.331e-01\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "ec047ba7ed8a4821a28b3a8535919e4e", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + " 0%| | 0/1 [00:00 9.827e+00\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "0ee446d6e2e343b8b938f1668128f68f", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + " 0%| | 0/1 [00:00 3.187e+00\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "7903a41ebcf1421698c47bf82f99a4e0", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + " 0%| | 0/1 [00:00 2.391e+00\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "dd1b88494cbc4f96b6d3878bd6a63ead", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + " 0%| | 0/1 [00:00 7.885e-01\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "bb34742493e34787b97f5e45939c6381", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + " 0%| | 0/1 [00:00 3.044e-01\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "02f2529c9c224e83bd00d7ae6f7227eb", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + " 0%| | 0/1 [00:00 5.690e-01\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "133cf82f70354e859f0a3f7869539f37", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + " 0%| | 0/1 [00:00 3.847e-01\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "18e9cb3e21ff43c28a14a3f63111df2b", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + " 0%| | 0/1 [00:00 3.377e-01\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "07f82fe227be47afb701d6226b057421", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + " 0%| | 0/1 [00:00 3.176e-01\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "718c4605c743423c92e569305f656d5e", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + " 0%| | 0/1 [00:00 3.097e-01\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "3941fc394a5d45c48e2a9183f2d4f2aa", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + " 0%| | 0/1 [00:00 3.065e-01\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "d312306e4a524d1ba6361094f901f3e6", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + " 0%| | 0/1 [00:00 3.083e-01\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "b7c794d90f654ace86145bcbecaa1c4d", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + " 0%| | 0/1 [00:00Plot the objective function against iteration. The optimizer writes one file per iteration, optimize_result_{i}.npz, into the folder named by the savefolder key — the counterpart of PIPT's assimilation_result_{i}.npz. Saving happens only when saveit is true.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAA44AAAH9CAYAAABV3iLSAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjYuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/P9b71AAAACXBIWXMAAA9hAAAPYQGoP6dpAABu90lEQVR4nO3deViU9f7/8dfAsIggiAgKaKYmLnDSQnHNJTO10kpJW3+WndSszOPJ1PLkOacyK46l2eK3U5aejpap2WabZSrmUicDRdwXwA1RkR1m5vcHMoIgzijjDMPzcV1eMTOfue/3jZ9kXrzvz30bLBaLRQAAAAAAXICHswsAAAAAALg2giMAAAAAoFoERwAAAABAtQiOAAAAAIBqERwBAAAAANUiOAIAAAAAqkVwBAAAAABUi+AIAAAAAKgWwREAAAAAUC2CIwDA6e6//35FRUXZNDYqKkr333+/gyuqzJ4aa9rPP/+sgQMHKiYmRs8//7xTariYjRs3KioqSnPnznV2KQAABzA6uwAAgHspKirSJ598om+//VapqanKyclRcHCwWrZsqSFDhujWW2+Vt7f3JW//9ddfV3BwcA1WXNmWLVt08OBB3XnnndbnHn/8cWVlZTl0vxcydepU5eXlacqUKU4Lr+d78803NWTIEEVGRkqSrrnmGr3++utq3bq1kysDADiCwWKxWJxdBADAPaSlpWns2LHatWuXbrjhBvXs2VONGjVSVlaW1q5dq59//lkdOnTQ3LlzFRERYX3f/fffr02bNik1NdWJ1Z/z9NNPKyMjQwsXLnR2KTpx4oS6d++uAQMGuEw379ChQ+rfv78+/PBDxcXFObscAMAVQMcRAFAjCgoKNHbsWB04cEBvvvmmbrzxxgqvP/DAA/r+++/15JNP6rHHHtPHH38sLy8vJ1VbvaSkJDVq1MjZZUiS8vPzJUn169d3ciXnJCUlObsEAMAVxhpHAECNWLx4sXbt2qXx48dXCo1l+vfvr7Fjx2r79u36+OOPK71+6tQpTZ48WXFxcfrTn/6kkSNH6vfff68wpqo1jseOHdOzzz6rXr16KTo6Wj179tTTTz+ttLS0SvtISUnRmDFjFBsbq+uuu04jR47UTz/9JKm0YxoVFaU9e/Zo06ZNioqK0pQpUyRVXOM4e/ZsRUVF6ccff6y0/aysLLVv314PPfTQJdVX3ty5c63fy+XLl1vrKauzrLbyyk5nLdv2nj17FBUVpdmzZ+vXX3/VyJEj1bFjR2sNJ0+erPD+kpISvf3227r55psVExOjfv366fnnn7eOmzJliiZOnCip9JcBZfu60BrHjRs36sEHH1RsbKyio6N18803KyEhQXl5edYxhYWFioqK0l//+lft2bNHDz30kK677jp17dpVjz76qDIyMqr9PgEAHI/gCACoEStXrpSXl5fuvffeasc98MAD8vLy0ueff17ptUmTJslgMGjq1KkaPXq0tm/froceekiHDx++4PaysrJ011136fvvv9eIESP0/PPPa9iwYVq9erXuuusuHT161Dp2x44duueee7Rr1y6NHTtWU6dOlYeHh8aOHauvvvpKjRo10uuvvy5Jat26tV5//fUqj2fQoEGSpO+++67Saz/88INMJpNuueUWu+uraj/PPfecJKlLly4XrKc6ZetJ9+3bpwkTJqhnz576+9//ru7du2vFihV65plnKoyfOnWqZs+erY4dO2rGjBkaMmSIli5dqtGjR6ugoED33nuvBg4cKKl03efrr79+we7sTz/9pAcffFAZGRl6/PHH9dxzzyk6Olrz58/XmDFjZDabK9R48uRJjR49Wm3bttVzzz2n2267TatXr9a4cePsOmYAQM3jVFUAwGUrLi7Wjh071K5dOwUEBFQ7tkGDBmrTpo2Sk5NlsVhkMBisrzVt2rTCVUObNWumqVOnavHixdYu1/neeOMNZWZm6rPPPlOrVq2sz/fq1Uv33nuv/u///k/PPvusJOmVV16R2WzWRx99pCZNmkiSbrvtNvXv31//+te/NHjwYGsoCg4Otn59vrZt26ply5ZavXq1TCaTPD09ra9988038vb21k033WR3fedr3bq1fH19JUkRERHWei7WqSyv7Pv7zTffaMmSJerYsaMkaejQofrjjz/0888/q6ioSN7e3vr999+1cuVK3XfffZo+fbp1Gw0bNtSLL76oVatW6fbbb7deAKdz587VrnF88cUX5efnp//+97/WCxrFx8erQYMG+uijj7R69Wr179/fWuO6des0e/ZsDR482Frj3r17tW7dOh06dEjNmjWz+bgBADWLjiMA4LKdPn1aJpNJjRs3tml8aGioiouLK50mOXz48AqPBwwYIIPBoC1btlxwW998842uueYaNW7cWNnZ2dY/bdq0UdOmTbV27VpJUl5enhITExUbG2sNjZLk6+ur9957T2+88Ya1A2aLwYMH6+TJk/r111+tz2VnZ+uXX37RDTfcoAYNGthVn6PFxMRYQ2OZtm3bVvh7KOug3nrrrRXGDRs2TEuWLFHPnj1t3t/u3bt14MAB3XjjjZWugjts2DBJpbcZKa9Ro0bWbm75GqXS030BAM5DxxEAcNmMxtIfJ7ZeqLssoJXv1EmqdCsHf39/BQUFXfBU1dOnTyszM1OZmZnq3LlzlWN8fHwkSQcOHJDZbK6ya9WmTRub6i5v8ODBeuONN/Ttt9+qS5cukqTVq1eruLjYepqqPfU5WvPmzSs9V9bNLC4ullR6OmtVY/39/SuFzosp21b5LmuZFi1aSCr9OymvWbNmFTrQ5WssKSmxa/8AgJpFcAQAXLagoCB5e3tXuxaxvGPHjsnHx0eBgYEVnvfz86s01tfXV4WFhVVup+yKox07dtRf/vKXKseUBZHc3FxJNRfUWrVqpTZt2uiHH36wnmr67bffys/PT3379rW7Pkez5d6ZZResqYnvUXXbqlevnqRz358yl3N/TwCAYxEcAQA1omPHjvr111+VmZmpkJCQC447deqUdu3aVeXauIKCgkrhMT8/X/7+/lVuq+wWFSaT6aL3EywbW/5qnpdr8ODBeu2115ScnKyrr75a69at04ABA6zByJ76akpZ9/BSlH3vc3NzL/g9t1XZsZ86darSa2WBsapfFAAAXBNrHAEANWLIkCEymUz697//Xe24RYsWqaSkREOHDq30WtnpjWXOnDmjU6dOKTIyssptBQQEKDQ0VHv27KkyEGZlZVm/bt68uTw8PLRnz55K4zZt2qRPPvnkgp3NCym7iMvq1av1888/q7CwsML6QHvqs0fZ/S+rConp6emXtE1JuvrqqyVJe/furfB8Tk6OPvnkE/322292b6uq73fZcy1btrzUUgEAVxjBEQBQI+6880517NhRH3zwgVasWFHlmO+//15vv/224uLiNGTIkEqvf/LJJxUef/XVV5JkXUNYlZtvvll5eXlatmxZhedTU1PVq1cvzZ8/X1JpB6x79+76/fffKwSjoqIiPfPMM3rrrbesp1V6eHjYFCKvuuoqdejQQYmJifrhhx8UFBSkHj16XFJ99mjYsKGMRmOloL13715t3brV7u2V6d+/vyTp008/rfD8119/rWeffda6JtHDo/TjQ3Xfo1atWqlVq1b66aefdPz48QqvLV26tML+AACuj1NVAQA1wtPTU3PmzNHjjz+up59+WsuXL1e/fv3UqFEjnTx5Uj///LN+/vlnxcXF6bXXXquwts9iscjLy0spKSn6y1/+om7duiktLU3vvfeegoKCNHLkyAvu99FHH9X333+vl156SWlpaWrfvr0OHjyoRYsWKSgoqEIHcNKkSbrnnnv00EMP6aGHHpKfn59WrFihgwcPWu/fKEmRkZHatm2b5s6dqyZNmig+Pv6C+x80aJBmz56tffv26eabb7Z2Ay+lPlt5e3urZ8+e+umnn/TGG2+oV69eOnDggN544w11795d69ats/lCReV16tRJt956qz7//HN5enqqR48e2rt3rz744AN16NDBetGfsg7w22+/rd27d6t3795Vbu+ZZ57RI488ovvuu08PPPCA/P39tW7dOq1cuVI333yzunfvbneNAADnIDgCAGpMWFiYFi1apC+++EIrV67Uu+++q5MnT6pRo0Zq3bq1EhISNGjQoEpXUy0qKpKHh4feeust/fOf/9Qrr7yiwsJCdezYUdOmTbvgDeal0vstfvzxx5o7d66+/PJLLVq0SMHBwerTp4/Gjx+v8PBw69j27dvrP//5j15//XXNmTNHZrNZbdq00fz58yuEn6efflozZszQBx98oBtuuOGiwfHVV1/VqVOnrMHqUuuzx4svvqiZM2fqv//9r/7v//5Pbdq00YwZM7Rx40atW7fuktc6vvTSS2rVqpU+++wzffnllwoNDdWdd96pxx9/3HrxmoEDB+rrr7/WL7/8oiNHjujaa6+tcls9evTQBx98oDfffFP/+te/VFhYqObNm+svf/mLHnrooUuqDwDgHAbLpfxKEgAAJ4mKilKXLl20cOFCZ5cCAECdwRpHAECtkZOTI4mrcQIAcKVxqioAoFZYu3atvv/+e0lSmzZtnFwNAAB1C8ERAFArvPvuu/rf//6nbt26adSoUc4uBwCAOoU1jgAAAACAarHGEQAAAABQrTp3qmpJSYlOnz4tHx8f6w2MAQAAAKCuMZvNKiwsVGBgoIzG6qNhnQuOp0+f1v79+51dBgAAAAC4hBYtWlR7z2SpDgZHHx8fSaXfnHr16jm5mnNMJpN27typNm3aVLoxNnC5mF9wNOYYHI05BkdifsHRXHWO5efna//+/daMVJ06FxzLTk+tV6+eS90HzGQySSq9N5krTSa4B+YXHI05BkdjjsGRmF9wNFefY7Ys4WORHwAAAACgWgRHAAAAAEC1CI4AAAAAgGoRHAEAAAAA1SI4AgAAAACqRXAEAAAAAFSL4AgAAAAAqBbBEQAAAABQLYIjAAAAAKBaBEcAAAAAQLUIjgAAAACAahmdXQAAAAAAuJNjp3KVnVtofWw2m5VxskABGSfl4XGud9egvo9Cg+o7o0S7ERwd6PwJcyEN6vuoUYDvFagIAAAAgCMdO5WrsQlfqbjEXPnFH9IqPPQyeujtSYNrRXgkODpItRPmPF5GD7355MArUJU0ZcoULV++3PrY09NTwcHBateunf785z+rS5cukqS5c+fqjTfeuOB27rjjDr300kvWx/v27dO///1vbdiwQceOHZOPj4+aNm2qfv36afTo0WrQoEGF9x85ckTvvvuu1q5dq6NHj8rT01NNmzZV//79NW7cOPn4+NTwkQMAAACOl51baFMGkKTiErOycwsJjnWZ3RMm7+KdyZoSHByslStXSiptmx8+fFjz5s3Tww8/rE8//VTXXHONdezq1avl7e1daRu+vuc6pD/99JMmTJig2NhYzZgxQy1btlR+fr42b96sN954Q19++aUWL16skJAQSVJWVpaGDx+upk2batq0aWrZsqWKior0yy+/6NVXX9WOHTv09ttvO/i7AAAAAMBWBMc6yMPDQ40bN7Y+DgsL08yZM9WjRw/9/PPPFYJjSEhItd2/48ePa9KkSerXr5/+9a9/yWAwWF9r3bq1evXqpWHDhumLL77QqFGjJEmrVq3S8ePH9dFHH6l58+bW8a1atZLRaNSKFSuUlZWl4ODgGjxqAAAAwDYWi0VFJSYVFZf+KTz7p6jYpKKSssclVb5+9GSus8t3CJcJjikpKZo1a5aSk5NlNBoVFxenZ555RqGhoVq1apXefPNNHTx4UIGBgbrllls0adIkeXp6SpL27Nmjv/3tb0pOTlbDhg01atQoa0iBbSwWiyRV2V2szpIlS1RQUKCpU6dWCI1lIiMjtX79ehmN56ZacXGxJKmgoKDS+BEjRmjEiBF21QAAAGAPd7xwibuzWCwqMZkrh7eiEmvAqxDubAh4pe8rqfS+wrPbQ0UuERwLCws1evRo3XvvvZo/f76ys7M1YcIEzZgxQ+PGjdPTTz+tOXPmqFevXtq5c6cefPBBhYaGatSoUSooKNAjjzyisWPH6r333tPvv/+uGTNmqFevXmrVqlWN1rku6ZD+812S8gtLLjq2xGTbaapl/vHBOpnNJfL+Nv2iY+v5GHXfTTHqEdPMrn1cyPHjx/XCCy+oSZMmuvXWW+167+bNmxUVFaXQ0NALjikfGiWpR48e8vLy0kMPPaTHHntMffr0UZMmTS6pdgCAe+KDPRzFXS9c4gwmk1mFJSYVFpnKhbcSa0CzNeAVnvfesufKb7eo2CTz2UYHnMMlgmNBQYEmTpyoO+64Q0ajUSEhIRo4cKAWLlwoPz8/JSQkqHfv3pKktm3bKjY2Vrt375Ykff3112rVqpXi4+MlSXFxcfr6668vuk+TySSTyb7fJCxbk6K042fsPDrbnC774Zifb9P4T39OUdf24Xbvx2Kx6MSJE+rYsaOk0h/EhYWFioyMVEJCgho0aCCTySSzufQf04t9n44dO6aWLVva9b28+uqrNWvWLL3wwgt67rnnJJV2JuPi4nTbbbdZL9CDmlP292PvnAdsxRxDTTp+Kk+PvrbK5g/2bz45UI2D/K5QdajtTp3Jt+s6FKfO5Neaq9+bzZYK4ax8KLMGsxLzeeHsXKArKjFXCnhlwe/8Ll5RsUkms3sEOW+jh7y9POVt9JSPt1HeRk95e3mUPvbylLeXsfS/Rk95e5U953nuPV7lnjd6KvN0nt787Deb9282m53289Oe/bpEcAwMDLQGP4vFon379mn58uUaNGiQWrVqZe0clpSUaMuWLdq8ebNefvllSdKWLVvUokULPfHEE1q/fr3CwsL02GOPafDgwdXuc+fOnXbX2bGZj05me6nQhn9sTGaL8gpt7zr6+XjI06PyqZ5V8TF6qGOkj37//Xebt18mKytL/v7++vvf/2597syZM0pOTtZDDz2k++67TzfeeKOOHDkiSeratWuV27nnnnt00003qbi4WCdPnqxUy7Rp03T48OEKz73//vvWr5s0aaLZs2dr+/bt2rZtm7Zv365ly5bp008/VY8ePfToo49WeeorLk9SUpKzS4CbY46hJmScLLDrg/3m//2h8Ia144M9nC/jZOWlMtVJTU3VmWOXNr8sFotKzBYVmywqMVlUbDKX/rek3Nfm0sclJnOFcee+Pvfahb4uG+cuQc7TQzJ6esjL0yCjp0FeFb42WF8r/3VV47w8PS76HqOnQR52f+Y0nf1TjkVSUemfkpwrN8euJJcIjmXS09M1YMAAmUwmjRgxQhMmTLC+tmLFCk2dOlW+vr6aNm2abrjhBknS0aNH9ccff+jVV1/Vyy+/rC+//FKTJk1Sy5Yt1bZt2wvuq02bNvLzs++3kx07SvfaeCbnnoyTmvTmDzZv+++jeiv3xCHFxMRY1246QnBwsLy9vTVwYMXbf8THx6tRo0Z6//339fDDD1tPHf3kk0/k5eVV5XYCAgLUokULHTlyxNrBLPPuu+9a1zJ+//33SkhIqDRGkmJjY61fHz16VC+88IK+//57jRgxQv3797/Mo0UZk8mkpKQkh88v1F3MMdSkgIyTlTqL1YmKilKr8IYOrAjOYrFYZLFIZotFFotFZkvZc6Vfm81lX5eOs1hKw1Pl9517fMbjtCTb51dGnq/OWLzLrZer3Hk7t16uYqevuMQkdzi70sPDUGVn7fzOW/lunM/53TnjubE+5bZR+thYYYytzRRXVZv+DcvLy7O5oeZSwTEiIkLJyck6cOCApk+frqeeekoJCQmSpNtvv1233HKLtm7dqkmTJslkMmnkyJEqKSlRnz59rEFy2LBh+vjjj/Xll19WGxw9PT0d+uGm/PoLm8Z7lo53dF0Gg0EGg6HKfXTo0EGFhYU6dOiQtf4WLVpUe1XV3r1764UXXtDBgwd19dVXW59v1uzc+suy23CU7bOkpEQ5OTkKCgqqsK3w8HC99NJLio2N1a5du3TzzTdf8nGiao6eXwBzDDXB7p+hHh7y9PS0hoWyoGA+PzyYKwePc8+f917zeWOsz6lSEDm3/fLbrvhey9mQUza2uuBTfl/lA5PZYpGlqrrKH6fZ1v2ryuM8F7xUqS5T+drNlfdfXe2WKvZly/fUFULXFxt2O7uESgwGVQhdPhc6bdLrvDHG84JbucDm4105zJVtw+hp3/+Tdd2l/hvmDPbs16WCo1QabFq0aKHJkydr+PDheuaZZ6y3ZfDy8lJsbKweeOABLVq0SCNHjlRgYKACAgIqbCMiIkKZmZnOKL9WK/ttQ1hYmM3vGTJkiObPn6+///3vmj9/fpVXZS1bj1rmjjvukI+Pjz7++ONK/2Olp6fbXQMAoG77y7zvJMklQgbqruo6alUGPO9zXTlbA17ZY6OnB0t6XFiD+j7yMnrYdMq9l9FDDepfuEnjSlwiOG7YsEHTp0/XqlWrrFfgLLs4y5IlS5SamqrXXnvNOt5kMlkDR4cOHbR69eoK20tPT1evXr2uTPEXYPeE8fORYy67U5nZbNbx48etj7Ozs7Vp0yb9+9//1pAhQ+y6wmlgYKBmz56t8ePH695779Ujjzyitm3bymw2KzU1VZ988onWrl2rP//5z9b3jB8/XpMmTdLYsWP1//7f/1Pz5s1VXFysbdu2ae7cuWrVqpVuueWWGj1mAEDtUFhcoqQ9x+x6D4HROQyG0l/4e5z9YzDo7H/Pfe3hYTg75txZTx4e5x5b3+dhqPxe6/hy773Avjw9DOXGqNx+DBXr9DDoTF6hNmy7+FXsy4wa9CddFRp4XiiseGqlt9FTHrX89ErUnNCg+np70uBKV4ZOTU1VVFRUrb0ytEsEx+joaOXn5yshIUFPPPGE8vPzNXfuXMXGxiouLk7z5s3T119/rZtuukn79u3T4sWLNXToUEmlp7C+9dZbWrx4se68806tWrVK27Zt0yuvvOLUY6pqwlxIg/o+ahTgK9v/Cbs8WVlZ6tmzp/VxQECAmjVrpr/+9a+666677N5ebGysVqxYoQ8//FD/+te/dPjwYRkMBjVt2lRdu3bV559/rmuuucY6fuDAgWrcuLEWLVqkZ599VpmZmfLw8FCzZs00cOBAPfzww3avPwUA1F4FRSXaknpY65MOaUvqYRUUXfy2V+VFNg5QPR8veZwNIOVDxvkhxFBujIeh6gBT6b0XDD9VBJiyr88LR1UFmPLvrbb2qvZfLlBVd5zlt1/xvRfbf+Xw5XFebbW147U7Pcuu4HhtqzC1jgh2YEVwR6FB9SsEQpPJpDPHfNUqvGGtXdJhsFhc4/d0KSkpmjVrlpKTk2U0GhUXF6dp06YpLCxMq1at0ltvvaWDBw8qKChIgwcP1oQJE6ynRW7evFkvvPCC9u3bp+bNm+upp56yrnk8X15enlJSUtSuXTuXCicmk0m///67OnbsWGsnE1wX8wuOxhyDvfIKirVpR4YSk9P0687Dl3Wz7dmP3cQHe9hsd3qWJr7xnc3jmV+oCa76c9KebOQSHUdJateunRYsWFDlawMHDqx0FdDyOnfurBUrVjimMAAAUCNy8ou0KSVd65PT9NvOIyoxVV7OEVDPW+1bhGhjSoYTKgQAXIjLBEcAAOB+snMLtTElXeuT0rR1z9Eqw2KQv4+6dYhU9+hIRV8dqv1HThEc4TDueuESwNEIjgAAoEadPFOgX7anKTE5TX/sPSZzFTclDw7wVffoSHWPbqb2LULked7FIvhgD0dx1wuXAI5GcAQAAJftRHa+NiSnKXFbmrbtOy5zFZdQCAn0U4/o0s5i2+YhF7wKJR/s4WjueOESwNEIjgAA4JIcO5WrDclpWp+cph0HM6u8LUZYw/rqEdNMPaIjdU1ksM1X4uSDPQC4FoIjAACw2ZGsHCUmpykx+ZBSD2VVOSa8kb96xDRT9+hItQpvWGtv2wAAOIfgCAAAqpV+/IwStx3S+qQ07ck4WeWYZqEN1CO6mXrEROqqsEDCIgC4GYIjAACo5ODR01p/trO4/8jpKsdc3TTo7JrFZmoW2uAKVwgAuJIIjgAAQBaLRfuPnNb65ENKTE7ToWPZVY5rHdFQ3aNL1yyGhwRc4SoBAM5CcAQAoI6yWCzak3FS65PStD75kA6fyKlyXFSzRuoRE6luHSLVJNj/ClcJAHAFBEcAAOoQi8WinYeytD75kNYnp+nYydxKYwwGqd1VIeoR3UzdOkSqcZCfEyoFALgSgiMAAG7ObLYo5WCmEpMOKXFbujJP51Ua42EwKPrqxuoeXdpZDG5QzwmVAgBcFcERAAA3ZDKbtX1/ptYnHdKGbWnKOlNQaYyHh0F/ahmqHjHN1LV9hIL8fZ1QKQCgNiA4AgDgJkpMZiXtPab1yYf0y7Z0nc4trDTG6Omhjq3D1CM6Ul3aRahBfR8nVAoAqG0IjgAA1GLFJSZt3X1UidvS9Mu2dJ3JL6o0xsvooevaNFX3DpHq0i5c/vW8nVApAKA2IzgCAFDLFBWb9L9dR7Q++ZA2pWQot6C40hhvL0/FRjVVj+hmim3bVH4+Xk6oFADgLgiOAADUAgVFJfptZ2lY3JySofyikkpjfL2N6tI2XN1jInV9m6by9ebHPACgZvATBQAAF5VfWKwtqYe1PumQtqQeVmGxqdIYPx8vdWkXrh4xzdTpmjD5ePGjHQBQ8/jpAgCAC8ktKNKmlAwlJqfpt51HVFRSOSz61/NW1/YR6h4dqY6tw+Rl9HRCpQCAuoTgCACAk53JK9TGlAytTzqk33cfVYnJXGlMg/o+6tY+Qt2jm+lPrUJl9PRwQqUAgLqK4AgAgBOczinQL9vTlZicpq17jspktlQa0zDAV906RKpHdKQ6tGgsT8IiAMBJCI4AAFwhJ8/ka8O2dK1PPqTkvcdltlQOi40a1FP36Ej1iG6mtlc1kqcHYREA4HwERwAAHCjzdJ4Sk9OUuC1N2/cfVxVZUaFBfuoe00w9oiPVJrKRPDwMV75QAACqQXAEAKCGHTuZq8TkNK1PPqQdB09UOaZpsL+6x5R2FltHNJTBQFgEALgugiMAADUgI/OMErelaX3SIe1OP1nlmIjGAeoZ3Uw9YiLVokkQYREAUGsQHAEAuERpx7O1PjlNiUmHtPfwqSrHtGgSqO4dItU9ppmahzYgLAIAaiWCIwAANrJYLDp49HRpWExO04Gjp6sc1zI8SD2im6l7dKQiGze4wlUCAFDzCI4AAFTDYrFo3+FTWn92zWL68TNVjmsTGazu0ZHqHt1MTRv5X+EqAQBwLIIjAADnsVgs2pWWZb3AzZGs3CrHtbuqkbpHN1P3DpEKbVj/ClcJAMCVQ3AEAECS2WxR6qETSkw+pPXJaTp+Kq/SGINB6tCicWlnsUOkGgX6OaFSAACuPIIjAKDOMpnNSjmQqfVJpfdZzMrOrzTGw8OgmKtD1SMmUl3bR6hhQD0nVAoAgHMRHAEAdYrJZFby/uNan3RIG7al61ROQaUxnh4GXds6TD2imymufYQC6/s4oVIAAFwHwREA4PZKTGb9seeo1ien6Zft6crOLaw0xujpoU7XNFGP6EjFtY+Qfz1vJ1QKAIBrIjgCANxScYlJ/9t1VInbDmnj9gzl5BdVGuNt9NT1UU3UPbqZurQNl5+vlxMqBQDA9REcAQBuo7C4RL/tPKLE5DRtSslQXmFxpTE+Xp6KbRuuHtGRio1qqno+hEUAAC6G4AgAqNUKikr0a+phrU8+pM07DqugqKTSmHo+RnVpG64eMc3U6Zom8vXmxx8AAPbgJycAoNbJKyjW5h0ZWp+cpl93HlZRsanSmPq+XoprF6EeMZHq2LqJvL08nVApAADugeAIAKgVcvKLtCklXYnJafpt1xEVl5grjQmo562uHSLUI7qZ/tQqVF5GwiIAADWB4AgAcFnZuYXamJKu9Ulp2rrnqEpMlcNikL+PunWIVPfoSEVfHSqjp4cTKgUAwL0RHAEALuVUToE2bEtTYnKa/th7TGazpdKY4ABfdY+OVPfoZmrfIkSeHoRFAAAcieAIAHC6E9n5+mVbmtYnp2nbvuMyWyqHxZBAP3WPjlSP6Ei1bR4iDw+DEyoFAKBuIjgCAOx27FSusnMLrY/NZrMyThYoIOOkPMp1/xrU91FoUP0qt3H8VJ4Skw8pcVuaUg5kqoqsqLCG9dUjppl6REfqmshgGQyERQAAnIHgCACwy7FTuRqb8FWVF6fRD2kVHnoZPfT2pMHW8HgkK0eJyWlKTD6k1ENZVW4/vJG/esQ0U/foSLUKb0hYBADABRAcAQB2yc4trDo0VqG4xKy96Se15vcDWp+Upj0ZJ6sc1yy0gXpEN1OPmEhdFRZIWAQAwMUQHAEADvXCovVVPn910yD1OHuBm2ahDa5wVQAAwB4ERwDAFdM6oqG6R5euWQwPCXB2OQAAwEYERwCAzUwmszJP5dn1nqvCAnXj9S3UrUOkmgT7O6gyAADgSARHAEAFFotFp3IKlJ55RunHzyg984wyMs8oLfOMjmblqsRk2/rGMk/Gd1HriGAHVQsAAK4EgiMA1FF5hcXKyDyjjMwcpR/PLg2KZx/nFRY7uzwAAOBCXCY4pqSkaNasWUpOTpbRaFRcXJyeeeYZhYaGatWqVXrzzTd18OBBBQYG6pZbbtGkSZPk6elZYRtHjx7VwIED9dBDD+nxxx930pEAgOsoMZl1NCv3bCjMtgbD9OPZyjpTYNe2vI2eCg/xV2B9H23dc8xBFQMAAFfkEsGxsLBQo0eP1r333qv58+crOztbEyZM0IwZMzRu3Dg9/fTTmjNnjnr16qWdO3fqwQcfVGhoqEaNGlVhO88//zyXcAdQ51gsFmWdKSg9nfR4tjIyzyg9M0cZmWd0JCtHJrPF5m0ZDFJoUH1FNA5QRMjZP40DFB4SoJAGfvLwMGh3epYmvvGdA48IAAC4GpcIjgUFBZo4caLuuOMOGY1GhYSEaODAgVq4cKH8/PyUkJCg3r17S5Latm2r2NhY7d69u8I21qxZoz179qhfv37OOAQAcLi8gmLr6aTpx8+cDYil/80vKrFrW4H1fRQeEqDIs6GwLCQ2CfaXt5fnxTcAAADqFJcIjoGBgYqPj5dU+pvzffv2afny5Ro0aJBatWqlVq1aSZJKSkq0ZcsWbd68WS+//LL1/QUFBfrHP/6hmTNnatmyZTbt02QyyWQy1fzBXKKyWlypJrgP5lftUVxi1tGTOaWnk549rTTjRGlAPJVTaNe2vL08Fd7IXxEhAQoP8Vd4o7Pdw0b+8q/nfcH3XWye+Pt6ycvooeKSi18kx8voIX9fL+YeLhv/jsGRmF9wNFedY/bUY7BYLLafw+Rg6enpGjBggEwmk0aMGKHnnntOHh4ekqQVK1Zo6tSp8vX11bRp06xBU5ISEhJ0/PhxvfTSS5oyZYoiIiIuuMYxLy9PKSkpV+R4AKAqFotF2fkmncgp0okzxTpxpkgncop1IqdYJ3OLZc+/ygZJQfW9FBLgpUb+XmoU4G39b0A9T3k46PT9U3nFyiu8+A8bPx9PBfl5OaQGAABQM9q1ayc/P79qx7hEx7FMRESEkpOTdeDAAU2fPl1PPfWUEhISJEm33367brnlFm3dulWTJk2SyWTSyJEjtXv3bi1fvlwrV660a19t2rS56DfnSjKZTEpKSlJMTEyli/4Al4v55Rw5+UXKOJFT7pTSHOvjwmL7fuMY5O9T2jEs6x6GBCgixF9hDf3lZfRw0BHYjjkGR2OOwZGYX3A0V51jeXl52rlzp01jXSo4SpLBYFCLFi00efJkDR8+XM8884yCg0vv/+Xl5aXY2Fg98MADWrRokUaOHKkZM2boySeftI6xlaenp0v9pZVx1brgHphfNa+4xKTDJ3LK3cri3H/tPbXU19uo8BB/RYY0sAbDiMYNFB7ir/q+Fz611JUwx+BozDE4EvMLjuZqc8yeWlwiOG7YsEHTp0/XqlWrZDSWlmQ2l66dWbJkiVJTU/Xaa69Zx5tMJnl4eCg9PV2bN2/Wrl279Morr0gqTc0eHh5avXq1li9ffsWPBYD7MZstyszOKw2Fx89UCInHTubJbMe5pR4eBjVpWF8RjRsowto5DFBE4wYKDvDlytAAAMAluURwjI6OVn5+vhISEvTEE08oPz9fc+fOVWxsrOLi4jRv3jx9/fXXuummm7Rv3z4tXrxYQ4cOVZMmTbRmzZoK25o5c6aaNGmihx9+2ElHA6C2OpNXaA2EaeWvWnoiR0V2nloaHOBbGgrL39YipIHCguvL6On8U0sBAADs4RLBMSAgQO+++65mzZqlXr16yWg0Ki4uTi+88ILCwsL06quv6q233tK0adMUFBSkwYMHa9y4cfL09FSTJk0qbKtevXry9/dX48aNnXQ0AFxZUbFJh0+U3uewtHN47r6H2bn2nVpaz8dYLhQGWINieEiA/Hy4IAwAAHAfLhEcpdIr+SxYsKDK1wYOHKiBAwfatJ2XXnqpBqsCUBuZzRYdP51X7l6H2dagePxUrl1XLfX0MKjJ2VtalA+IkY0DFOTPqaUAAKBucJngCAD2Op1baD2dtGztYUbmGWWcOGPTPQbLa9Sg3tm1hgHn1h2GBCisYX15cmopAACo4wiOAFxaQVGJDpe7pUX5gHgmv8iubfn5eFVcc3g2JIY38lc9Ti0FAAC4IIIjAKczmc06fiqv0hVLS08tzbNrW0ZPDzVtVHq10siQct3DxgEKrO/DqaUAAACXgOAI4IqwWCzKzi1UWrlQWBYUD5/IUYnJvlNLQwL9rIEwolxADA3y49RSAACAGkZwBNzQsVO5Fa4QajablXGyQAEZJ+XhcS5UNajvo9Cg+jW674KiknO3sTjvtha5BcV2bau+r5ciy9YcNm5w9hRTfzVtFCBfb/75AgAAuFL45AW4mWOncjU24auqLw7zQ1qFh15GD709abDd4dFkMuvoydxzncNyQTHzdL5d2zJ6eig8xP/c1UrLdQ8bcGopAACASyA4Am4mO7fQ5iuKFpeYlZ1bWGVwtFgsOpVTePZWFmeUkZmj9OOlXx/JyrXr1FKDQWoc6FdhvWFZUGwc5CdPD04tBQAAcGUER6COKywq0e70rNJgaD29NFsZmTnKK7Tv1NIAP+8K9zksC4pNG/nLx4t/bgAAAGorPskBddyU+T/aNd7b6KnwEP8K9zosC4sN6vs4qEoAAAA4E8ERQCUGgxQaVL/K7mFIoJ88PFh3CAAAUJcQHIE6rkWTILWOaFhh3WHTYH95e3k6uzQAAAC4CIIjUMdNGN5ZrSOCnV0GAAAAXBiXMgQAAAAAVIvgCAAAAACoFsERAAAAAFAtgiPgZhrU95GX0bb/tb2MHtxCAwAAABfFxXEANxMaVF+T7uqqlz5KlCQ1auCrKXd3067duxQVFSUPj3OhskF9H4UG1XdWqQAAAKglCI6AG1q1aY/16/tuitE1zRop98QhtQpvKE9PbrMBAAAA+3CqKuBmdhzI1O+7j0qSwhrWV59OLZxbEAAAAGo9giPgZv77wzbr13f1bS+jJ/+bAwAA4PLwiRJwIzsOZuq3XUckSaEN66vfdS2cWxAAAADcAsERcCMVu43t6DYCAACgRvCpEnATOw+d0G87z3Ybg/zUj7WNAAAAqCEER8BNlO82xvdtLy8jV08FAABAzSA4Am5g56ET2pJ6WJLUOMhPN7K2EQAAADWI4Ai4gQrdxj7t6DYCAACgRhEcgVpuV1qWtdsYEuin/tdf7eSKAAAA4G4IjkAtt3g13UYAAAA4FsERqMV2p2dpU0qGJCkksJ5uiqXbCAAAgJpHcARqscXl1jYO7023EQAAAI5BcARqqT0ZJ7XxbLexUYN6GtC5pZMrAgAAgLsiOAK1FN1GAAAAXCkER6AW2ptxUr9sT5ckBdNtBAAAgIMRHIFaqPyVVIf3bitvL7qNAAAAcByCI1DL7Dt8Shu2ne02Bvjq5s6tnFwRAAAA3B3BEahlyncbh/VuR7cRAAAADkdwBGqRfYdPKTE5TZLUMMBXN3dhbSMAAAAcj+AI1CJLyncbb2grHy+jE6sBAABAXUFwBGqJA0dOaf3ZbmOQv68GxrG2EQAAAFcGwRGoJRav3m79mm4jAAAAriSCI1ALHDh6WuuTD0mSgvx96DYCAADgiiI4ArXAktXbZLGUfn3nDW3l6023EQAAAFcOwRFwcQePnta6pNJuY2B9Hw2Ka+3kigAAAFDXEBwBF7fkx+10GwEAAOBUBEfAhR06lq21fxyUJDWo76PBXek2AgAA4MojOAIurMLaxl5RdBsBAADgFARHwEWlHc/W2j9K1zbSbQQAAIAzERwBF7Vk9XaZz7Yb7+gVpXo+Xk6uCAAAAHWVywTHlJQUjRo1SrGxseratasmTJigY8eOSZJWrVqlIUOGqGPHjurdu7defvllmUwm63s/+ugjDRgwQJ06ddJtt92m77//3lmHAdSI9ONn9PPW0rWNAX7euoVuIwAAAJzIJYJjYWGhRo8erc6dOysxMVFffPGFMjMzNWPGDCUlJenpp5/WpEmT9Ntvv+mdd97R8uXLtXDhQknSt99+q3/961+aNWuWNm/erIceekhPPvmkDh486OSjAi7dkh+30W0EAACAy3CJ4FhQUKCJEydqzJgx8vb2VkhIiAYOHKjdu3fLz89PCQkJ6t27tzw8PNS2bVvFxsZq9+7d1vdOmjRJnTp1ktFo1B133CF/f39t3brVyUcFXJqMzDNa8/vZbmM9b93S7RonVwQAAIC6ziUu0RgYGKj4+HhJksVi0b59+7R8+XINGjRIrVq1UqtWrSRJJSUl2rJlizZv3qyXX35ZkjRkyJAK28rOzlZOTo6aNm1a7T5NJlOF012drawWV6oJzrF49blu45Ae18jH6HHZ84L5BUdjjsHRmGNwJOYXHM1V55g99RgslrKL/Ttfenq6BgwYIJPJpBEjRui5556Th0dpU3TFihWaOnWqfH19NW3aNGvQLM9isVjXRn700UfW95aXl5enlJQUhx8LcClO5BTpjW8OymKRfL089OTgFvL1cokTAwAAAOCm2rVrJz8/v2rHuFRwlErD34EDBzR9+nSFhoYqISHB+lpxcbG2bt2qSZMmady4cRo5cmSF16ZMmaKdO3dqwYIFatSoUZXbLwuObdq0ueg350oymUxKSkpSTEyMPD09nV0OnGTOp5u1+n8HJEn33NhBd/VtVyPbZX7B0ZhjcDTmGByJ+QVHc9U5lpeXp507d9oUHF3iVNXyDAaDWrRoocmTJ2v48OF65plnFBwcLEny8vJSbGysHnjgAS1atMgaHAsKCvToo4+qqKhI//nPf9SgQYOL7sfT09Ol/tLKuGpdcLzDJ3L009krqdb39dKQnm1qfC4wv+BozDE4GnMMjsT8gqO52hyzpxaXOAduw4YN6t+/v0pKSqzPmc1mSdKSJUv05JNPVhhvMpmsp6FaLBZNnDhR3t7eeu+992wKjYAr+uSn7TKbS08AuL1nlOr7eju5IgAAAKCUSwTH6Oho5efnKyEhQfn5+crKytLcuXMVGxuruLg4ff/99/r6669VUlKiXbt2afHixbrxxhslSZ9//rlSU1M1e/ZseXvzQRu105GsHP3w235Jpd3G23pwJVUAAAC4Dpc4VTUgIEDvvvuuZs2apV69esloNCouLk4vvPCCwsLC9Oqrr+qtt97StGnTFBQUpMGDB2vcuHGSpE8//VRHjhxRly5dKmxz6NChev75551xOIDdPv7xXLdxaI82dBsBAADgUlwiOEqlV/JZsGBBla8NHDhQAwcOrPK1Dz74wIFVAY53JCtHqyt0G9s4tyAAAADgPC5xqipQl33yU4pM5rL7NraRfz26jQAAAHAtBEfAiY6ezNUPv+6TJPn5eGkI3UYAAAC4IIIj4ESf/LTd2m28rcc1dBsBAADgkgiOgJMcO5mrH37dL0mq52PUULqNAAAAcFEER8BJPvkpRSWm0vuVDuneRgF+Pk6uCAAAAKgawRFwgmOncvX92bWN9XyMGtqTbiMAAABcF8ERcIKl5bqNt3a7hm4jAAAAXBrBEbjCjp/K03dbznYbvY26vWeUkysCAAAAqme0ZdADDzxwWTsxGAz64IMPLmsbgLtYuqZct7H7NWpQn24jAAAAXJtNHcdNmzYpJydHFovF7j85OTnatGmTo48DqBUyT+fp2817JUm+3kYNpdsIAACAWsCmjqMk/fOf/1SHDh3s3kFSUpLuuusuu98HuKNPy3Ubb+nWWoF0GwEAAFAL2NRx7NChg+rVq3dJO/Dz81P79u0v6b2AOzlxOk/flOs23kG3EQAAALWETR3HTz/9VCaTSWvWrFHv3r0rvJaUlKRPPvlEhw8fVrNmzfTAAw+oRYsW1tdbtWqlTz/9tEaLBmqjpWt2qLjkbLexa2sF+vs6uSIAAADANjZ1HDMzM3XnnXdq7NixOnbsmPX51atXa8SIEVq5cqVOnDihlStXatiwYTpw4IDDCgZqoxPZ+fpm8x5Jko+Xp+7oRbcRAAAAtYdNwTEhIUFHjhxRQkKCgoODrc/PmjVLTZo00TfffKNly5bp22+/VZMmTTRnzhyHFQzURsvWpFi7jYPpNgIAAKCWsSk4JiYmatKkSRo8eLCMxtKzW7dt26YDBw7owQcfVFhYmCQpODhY99xzj/73v/85rmKglsnKzteqTaVrG729PHXnDW2dXBEAAABgH5vWOB4/flw//vhjhUC4f/9+GQwGJSYmavv27dbnMzIydPToUU2dOlX9+/fXjTfeWPNVA7XIpz/vUFGJSVJptzGIbiMAAABqGZuCo4eHhxo1aqQmTZpYn1u3bp3CwsIq3aIjPz9fBoNBERERatCgQc1WC9QyJ8/ka9XG0rWN3l6eurMX3UYAAADUPjYFxyZNmqhz584aOnSoJOnIkSN6++239cADD+ixxx6rMPbdd9/VH3/8Uel5oC5aVq7bOKhLKzUMoNsIAACA2sem4NinTx+9/vrr8vLyksVi0dtvvy0PDw/Fx8dXGLd37159+OGH6tWrl0OKBWqTk2cK9FVZt9HoqWG96TYCAACgdrIpOD7++ONKTU3VX/7yF0mSv7+/Zs6cqauvvto6Zt68eXrrrbcUEhKi8ePHO6ZaoBZZtnaHiopLu40D41qpYUA9J1cEAAAAXBqbgmNgYKAWLlyotLQ0nTp1SldffbXq169fYUzLli310EMP6f7771fjxo0dUixQW5zKKdBXv+yWdLbbyJVUAQAAUIvZFBzLREZGKjIyssrXBg0apEGDBtVIUUBtt3xtqrXbeHOXlgpuQLcRAAAAtZdN93EEYLtTOQX6csMuSZKX0UPDerdzckUAAADA5SE4AjVsxdpUFZZ1Gzu3UiO6jQAAAKjlCI5ADTqdW6gvz65tNHp6aDhXUgUAAIAbIDgCNWjF2lQVFJVIkm7u3FKNAv2cXBEAAABw+QiOQA05nVuoL86ubTR6emh4H9Y2AgAAwD3YdVVVSSopKdHChQuVmJio06dPy2w2VxpjMBj0ySef1EiBQG3x2bpz3cYBnVsqhG4jAAAA3ITdwfFf//qX3nvvPXl5eSk4OFienp6OqAuoVbJzC/VFYrluI1dSBQAAgBuxOzh+9dVXGjZsmJ577jl5e3s7oiag1vls/U7ln+023hR7tRoH0W0EAACA+7B7jeOpU6c0bNgwQiNw1pm8Qn2euFMSaxsBAADgnuwOjm3atNGRI0ccUQtQK322bqfyC0u7jf2vv1qhQfWdXBEAAABQs+wOjpMnT9Zbb72lPXv2OKIeoFbJyS/S5+XWNsbTbQQAAIAbsnuN48cffyw/Pz8NGTJEV111lRo1aiSDwVBhjMFg0AcffFBjRQKu6rN1O5VXWCxJuvH6FgptSLcRAAAA7sfu4LhhwwZ5eXkpLCxMBQUFSk9Pd0RdgMvLyS/SyvWlaxs9PQyK79PeyRUBAAAAjmF3cFy7dq0j6gBqnZXry3cbr1YY3UYAAAC4KbuDY3l5eXk6ceKEJKlx48by9fWtkaIAV1e528jaRgAAALivSwqOP/30k+bOnauUlBRZLBZJkoeHhzp16qQnn3xSsbGxNVok4Go+T9yl3ILSbmO/61qoSbC/kysCAAAAHMfu4LhmzRqNGzdOoaGhGjp0qEJDQyVJR48e1bp16zRq1Ch98MEHuv7662u8WMAV5BYU6bN1qZIkDw+D7urL2kYAAAC4N7uD4zvvvKOuXbtq/vz58vLyqvBaQUGBRo0apTfeeEPvv/9+jRUJuJLP15frNnai2wgAAAD3Z/d9HFNSUnTfffdVCo2S5OvrqwcffFB//PFHjRQHuJq8gmJ9dnZtI91GAAAA1BV2B0ez2VxlaCxTv359lZSUXFZRgKv6fMMu5eQXSZL6drpKTRvRbQQAAID7szs4tmzZUitXrrzg6ytWrFDLli0vqyjAFeUVFGvF2nJrG7lvIwAAAOoIu9c43nPPPZo+fbqysrJ04403KiwsTMXFxTp69KhWrVqlrVu36sUXX3RErYBTfVGu29jn2qsUHhLg5IoAAACAK8Pu4BgfH6/Tp0/rrbfeUmJiogwGgyTJYrGoQYMGmjJliu64444aLxRwprzCct1Gg0Ej+tFtBAAAQN1xSfdxfPjhh3XfffcpOTlZR48elcFgUFhYmGJiYuTt7V3TNQJO9+WG3TpzttvYu2Nzuo0AAACoUy4pOEqlV1CNjY2tyVoAl5RfWKzla3dIOttt7NvByRUBAAAAV5ZNwXHq1Kl6/PHHFR4erqlTp150vMFgYJ0j3MaXv+zWmbzSbuMN1zZXRGO6jQAAAKhbbAqOy5cv13333afw8HAtX778ouMvJTimpKRo1qxZSk5OltFoVFxcnJ555hmFhoZq1apVevPNN3Xw4EEFBgbqlltu0aRJk+Tp6SlJ+uCDD7RgwQKdOHFCUVFRmjFjhjp0oCuEy1fabSxd22gwiPs2AgAAoE6yKTju2LGjyq9rSmFhoUaPHq17771X8+fPV3Z2tiZMmKAZM2Zo3LhxevrppzVnzhz16tVLO3fu1IMPPqjQ0FCNGjVK3333nV577TW99dZbuvbaa/Xvf/9bY8aM0bfffis/P78arxV1y1e/7FZ2bqEk6YY/NVez0AZOrggAAAC48i55jWNNKigo0MSJE3XHHXfIaDQqJCREAwcO1MKFC+Xn56eEhAT17t1bktS2bVvFxsZq9+7dkqRPPvlEw4cPV9euXSVJ48eP15IlS/TDDz/otttuu+A+TSaTTCaT4w/ORmW1uFJNdV1BUUmFbuPw3m1r7d8P8wuOxhyDozHH4EjMLziaq84xe+qxKTi+8cYbdhVgMBg0fvx4m8cHBgYqPj5eUultPfbt26fly5dr0KBBatWqlVq1aiVJKikp0ZYtW7R582a9/PLLkqTt27dr8ODBFfbdtm1bbdu2rdrguHPnTruO6UpJSkpydgk4a33qSZ0+223sEOmvExl7dSLDyUVdJuYXHI05BkdjjsGRmF9wtNo8x1wiOJZJT0/XgAEDZDKZNGLECE2YMMH62ooVKzR16lT5+vpq2rRpuuGGGyRJJ0+eVFBQUIXtBAYGKisrq9p9tWnTxqVOZTWZTEpKSlJMTIx17Sacp6CoRLO//lpSabdxzB3da/VpqswvOBpzDI7GHIMjMb/gaK46x/Ly8mxuqNkUHH/44YfLKshWERERSk5O1oEDBzR9+nQ99dRTSkhIkCTdfvvtuuWWW7R161ZNmjRJJpNJI0eOlMFgqHJbF3q+jKenp0v9pZVx1brqmm+37LJ2G3vGNFOLpg2dXFHNYH7B0ZhjcDTmGByJ+QVHc7U5Zk8tNgXHiIiISy7GXgaDQS1atNDkyZM1fPhwPfPMMwoODpYkeXl5KTY2Vg888IAWLVqkkSNHqmHDhjp16lSFbZw8eVJt2rS5YjXDvRQUlWjZz6UXgTIYpBH9uEIvAAAA6jabguOKFSvs3vDtt99u89gNGzZo+vTpWrVqlYzG0pLMZrMkacmSJUpNTdVrr71mHW8ymeTh4SFJiomJUXJysnV/JpNJ27dv1/Dhw+2uGZCkVZv26FROabexe3QzXRUW6OSKAAAAAOeyKThOmTJFBoNBFovFpo0aDAa7gmN0dLTy8/OVkJCgJ554Qvn5+Zo7d65iY2MVFxenefPm6euvv9ZNN92kffv2afHixRo6dKgkaeTIkZowYYL69++vmJgYvfnmm/L19VW/fv1s3j9QprD4XLdRku7ux30bAQAAAJuC44cffujQIgICAvTuu+9q1qxZ6tWrl4xGo+Li4vTCCy8oLCxMr776qt566y1NmzZNQUFBGjx4sMaNGydJuuGGGzR58mRNnTpVJ06cUHR0tObPny8fHx+H1gz3tGrjHp08UyBJ6hEdqauaBDm3IAAAAMAF2BQcu3Tp4ug61K5dOy1YsKDK1wYOHKiBAwde8L1333237r77bgdVhrqisLhEn5brNo68kbWNAAAAgGRjcNy8ebM6dOggPz8/bd682aYNd+7c+bIKA660bzbttXYbu3WIVAu6jQAAAIAkG4Pj/fffr08//VQdOnTQ/fffX+2tLiwWiwwGg1JSUmqsSMDRiopN+nTNuTl7942sbQQAAADK2BQcZ86cqcjISOvXgLv5ZvMeZVm7jRG62k3u2wgAAADUBJuC4x133FHl14A7KCo2aemacmsbuW8jAAAAUIFNwbEqubm5OnPmjPV+i+cLDw+/5KKAK+m7LXuVlZ0vSYprH6GW4XQbAQAAgPLsDo47d+7U5MmTlZqaWu041jiiNiguMemTn8qvbaTbCAAAAJzP7uD4t7/9TQcPHtSQIUPUpEkTeXl5OaIu4Ir4dvNenSjrNrYLVyu6jQAAAEAldgfH1NRUPffcc7r99tsdUA5w5RSXmLS03JVUuW8jAAAAUDUPe98QEhKi0NBQR9QCXFHf/7pPmadLu42d24ardUSwkysCAAAAXJPdwfGRRx7RggULVFRU5Ih6gCuiuMSkj39kbSMAAABgC7tPVY2Pj9fvv/+uG264QR07dlTDhpXXhBkMBr344os1UiDgCKXdxjxJUmxUU10TSbcRAAAAuBC7g2NCQoI+/fRTSdJPP/1U5RiCI1wZV1IFAAAA7GN3cFy6dKkGDBigp556Sk2bNpXReMm3ggScYvVv+3X8VGm38fo2TdWmWSMnVwQAAAC4NrtTX0FBge677z41a9bMEfUADlW6tnG79THdRgAAAODi7L44TteuXbVz505H1AI43Or/7dexs93G69o0UVRzuo0AAADAxdjdcfzb3/6mZ599Vrm5uerRo4eCg6u+qEh4ePhlFwfUpBKTmSupAgAAAJfA7uDYt29fGQwGJSYm6rXXXrvguJSUlAu+BjjDj//br2MncyVJna5porbNQ5xcEQAAAFA72B0cx4wZI6PRKIPB4Ih6AIcoMZm1ZDVrGwEAAIBLYVNwzMnJUf369WUwGDRx4kS7dmCxWJSbmyt/f/9LKhCoCT/9b7+Onu02dmwdpnZX0W0EAAAAbGXTxXE6d+6s7du3X3xgFbZt26bOnTtf0nuBmmBibSMAAABwWWwKjhaLhVNTUWv99PsBHc7KkVTabWzforGTKwIAAABqF5vXOA4bNsyRdQAOYTpvbeNIuo0AAACA3WwKjo899pij6wAcYs3Wc93GP7UKVQe6jQAAAIDdCI5wW+d3G1nbCAAAAFwam9Y4ArXRz38cVMaJs93GlqGKvjrUyRUBAAAAtRPBEW7JZGZtIwAAAFBTCI5wS2u3HlR65hlJUvTVjRXTkm4jAAAAcKkIjnA7JrNZi39kbSMAAABQU2wKjjk5OY6uA6gx6/44pPTjpd3GDnQbAQAAgMtmU3Ds1auXpk6dqt9++83R9QCXxWQ2a/HqbdbHd9/YQQaDwYkVAQAAALWfTcExOjpaK1as0L333qvBgwfr/fffV1ZWlqNrA+y2PilNaWe7je1bhOhPdBsBAACAy2ZTcFy4cKG+++47PfrooyoqKtKsWbPUu3dvTZgwQevWrXN0jYBNzGYL3UYAAADAAWy+OE5kZKQef/xxff/99/rwww916623au3atfrzn/+sfv366Y033tDhw4cdWStQrfXJh3ToWLYkqd1VIbq2VZiTKwIAAADcwyVdVbVLly6aOXOmEhMTNXPmTEVGRmrevHnq37+/Hn74YX377bc1XSdQLbqNAAAAgOMYL+fNvr6+uv3223X77bfr2LFj+uqrr/Tmm28qMTFR27dvv/gGgBqSuC1NB4+WdhvbNm+kjq3pNgIAAAA15bKCoySZzWatXbtWK1eu1Jo1a5STk6OYmJiaqA2widls0eIf6DYCAAAAjnLJwXH37t1atmyZVq5cqRMnTqhBgwa6/fbbFR8fr6ioqJqsEajWhm1pOnD0tCQpqlkjdbqmiZMrAgAAANyLXcExOztbn3/+uZYvX65t20o7PJ07d9bTTz+tm2++Wd7e3g4pErgQ1jYCAAAAjmdTcFyzZo2WLVumH3/8UUVFRWrcuLH+/Oc/Kz4+Xs2aNXN0jcAF/bI9XfuPlHYb20QG67o2dBsBAACAmmZTcBwzZow8PT3Vq1cvxcfHq0+fPvL09HR0bUC16DYCAAAAV4ZNwfHJJ5/UnXfeqdDQUEfXA9hsY0q69h0+JUm6JjJY10c1dW5BAAAAgJuyKTiOHTtWklRUVKRdu3bJbDbrmmuuka+vr0OLAy7EYuFKqgAAAMCVYvPFcRYsWKA5c+YoPz9fkuTt7a0HH3xQTz75pKNqAy5oY0qG9p7tNraOaKhYuo0AAACAw9gUHL/66iu99NJLio6OVu/evWU0GrVlyxa988478vHx0bhx4xxdJ2BlsVj03x+SrY/vvjGabiMAAADgQDYFx4ULF6p37956++23K3xAnz17tt5//32NGTNGHh4eDisSKG9TSob2ZpySVNpt7NyWbiMAAADgSDalvR07dig+Pr5SV+fuu+9Wdna20tLSHFIccL7SbuO5tY0j+7G2EQAAAHA0m4Jjfn6+mjSpfH+8sufy8vJqtirgAjbvOKw9GSclSS3Dg9SlXbiTKwIAAADcn83nl9LVgbOxthEAAABwDpdZmJiSkqJRo0YpNjZWXbt21YQJE3Ts2DFJ0saNGxUfH69OnTqpb9++mjdvnvV9ZrNZr7/+uvr27atOnTrptttu01dffeWsw4ADbUk9rN3pZ7uNTYMUR7cRAAAAuCJsvh3Hb7/9pszMzCpf+/XXX3X06NEKz/Xu3dvmIgoLCzV69Gjde++9mj9/vrKzszVhwgTNmDFD06dP19ixYzVlyhQNGzZMO3fu1P/7f/9PkZGRGjp0qD766CMtXbpUH374oa666ir9/PPPGj9+vFq2bKm2bdvaXANcW6W1jdy3EQAAALhibA6OL7744gVf++c//2n9EG+xWGQwGJSSkmJzEQUFBZo4caLuuOMOGY1GhYSEaODAgVq4cKEyMzMVHx+vESNGSJLat2+vbt26acuWLRo6dKhSUlJ03XXX6eqrr5Yk9enTRw0aNFBqamq1wdFkMslkMtlco6OV1eJKNbmSX3ce1q60LElSiyaBim3ThO+VHZhfcDTmGByNOQZHYn7B0Vx1jtlTj03BcebMmZdcjC0CAwMVHx8vqTR47tu3T8uXL9egQYMUExOjmJiYCuMzMjKsobBPnz567rnntGPHDrVu3Vo//fSTCgsL1aVLl2r3uXPnTscczGVKSkpydgkux2Kx6L0fz125t8vV9fTHH1udWFHtxfyCozHH4GjMMTgS8wuOVpvnmE3B8Y477nB0HZKk9PR0DRgwQCaTSSNGjNCECRMqjVm4cKEOHTqkYcOGSZJuuukm7dixQ0OHDpUk+fr6atasWWratPp7+7Vp00Z+fn41fxCXyGQyKSkpSTExMfL09HR2OS7lt51HlJ61R5J0VVigRg7qIQ8PTlO1B/MLjsYcg6Mxx+BIzC84mqvOsby8PJsbajafqnolREREKDk5WQcOHND06dP11FNPKSEhwfr6okWLNGfOHM2fP19hYWGSpBUrVmj58uVavny5WrdurQ0bNugvf/mLwsPD9ac//emC+/L09HSpv7QyrlqXs1gsFi358dxpz3ff2EFeXi41bWsV5hccjTkGR2OOwZGYX3A0V5tj9tRi0yfwqVOn2lWAwWCodk3kxd7bokULTZ48WcOHD9czzzyj4OBgzZ49W8uXL9eiRYsUFRVlHb9w4ULdddddat++vaTSi/LExcVpxYoV1QZH1A7/23VUqYdOSCrtNnbrEOnkigAAAIC6x6bguHHjRps3ePjwYUnVX0znfBs2bND06dO1atUqGY2lJZnNZkmlKfj999/XV199pcWLFys8vOItGCwWi3VsmZKSEnl4uMydRnCJLBaLFq8+d9/GkTd24BRVAAAAwAlsCo6rV6++6Jg9e/bon//8pzIyMtSjRw+7ioiOjlZ+fr4SEhL0xBNPKD8/X3PnzlVsbKyys7M1Z84c/fe//60UGiWpb9++Wrp0qW666Sa1bNlSmzZt0oYNG/TAAw/YVQNcz++7jyrlQGm3sXlYA3Wn2wgAAAA4xWUvFsvLy9PcuXO1cOFChYaG6vXXX9fNN99s1zYCAgL07rvvatasWerVq5eMRqPi4uL0wgsvaOnSpcrPz7dedbVMeHi4vvnmG40dO1YlJSUaM2aMsrKyFB4erhkzZqhnz56Xe2hwokr3bexHtxEAAABwlssKjitXrtQrr7yi06dP689//rPGjh0rHx+fS9pWu3bttGDBgkrPjx8/XuPHj7/g+7y8vDRx4kRNnDjxkvYL1/THnmNKOZApSWoW2kDdo+k2AgAAAM5yScExNTVV//jHP/Trr7+qb9++mjZtmpo1a1bTtaGOslgs+uiHcmsb+3WQJ2tWAQAAAKexKzieOXNGr7/+uhYvXqyIiAi988476t27t6NqQx31x95j2r6/tNsY2ThAPWLoNgIAAADOZHNwXLp0qRISElRQUKAnnnhCDz74oLy8vBxZG+qo8msbR9BtBAAAAJzOpuA4YsQI/fHHHxo0aJCefvpphYWFObou1FFJe49p277jkqSIxgHq9SdOgQYAAACczabguHXrVknS119/ra+//vqi4w0Gg7Zv3355laFO+uj7cmsb+7an2wgAAAC4AJuC42OPPeboOgAl7T2m5LJuY0iAel3b3MkVAQAAAJAIjnAhi8utbbyLbiMAAADgMvhkDpeQvO+Y/th7TJIU3shfvek2AgAAAC6D4AiXUPFKqu3l6cnUBAAAAFwFn87hdNv2H9cfe0q7jU0b+av3tVc5uSIAAAAA5REc4XSV1jbSbQQAAABcCp/Q4VTb9x/X77uPSpKaBvurb0e6jQAAAICrITjCqf5bodvYjm4jAAAA4IL4lA6n2XEg09ptDGtYX306tXBuQQAAAACqRHCE0/z3vLWNRrqNAAAAgEvikzqcYsfBTP2264gkKbRhffW7roVzCwIAAABwQQRHOMX5axvpNgIAAACui0/ruOJ2Hjqh33ae7TYG+akfaxsBAAAAl0ZwxBVXvtsY37e9vIyeTqwGAAAAwMUQHHFF7Tx0QltSD0uSGgf56UbWNgIAAAAuj+CIK6pCt7FPO7qNAAAAQC1AcMQVsysty9ptDAn0U//rr3ZyRQAAAABsQXDEFbN4Nd1GAAAAoDYiOOKK2J2epU0pGZKkkMB6uimWbiMAAABQWxAccUUsLre2cXhvuo0AAABAbUJwhMPtyTipjWe7jY0a1NOAzi2dXBEAAAAAexAc4XB0GwEAAIDajeAIh9qbcVK/bE+XJAXTbQQAAABqJYIjHKr8lVSH924rby+6jQAAAEBtQ3CEw+w7fEobtp3tNgb46ubOrZxcEQAAAIBLQXCEw5TvNg7r3Y5uIwAAAFBLERzhEPsOn1JicpokqWGAr27uwtpGAAAAoLYiOMIhlpTvNt7QVj5eRidWAwAAAOByEBxR4w4cOaX1Z7uNQf6+GhjH2kYAAACgNiM4osYtXr3d+vWw3nQbAQAAgNqO4IgadeDoaa1PPiTpbLexC91GAAAAoLYjOKJGLVm9TRZL6dd33hAlX2+6jQAAAEBtR3BEjTl49LTWJZV2GwPr+2hQXGsnVwQAAACgJhAcUWOW/Li9XLexLd1GAAAAwE0QHFEjDh3L1to/Dkoq7TYO7kq3EQAAAHAXBEfUiPJrG+/oxdpGAAAAwJ0QHHHZ0o5na+0fpWsbG9BtBAAAANwOwRGXbcnq7TKfbTfe0StK9Xy8nFwRAAAAgJpEcMRlST9+Rj9vLV3bGODnrVvoNgIAAABuh+CIy7Lkx210GwEAAAA3R3DEJcvIPKM1v5/tNtbz1i3drnFyRQAAAAAcgeCIS1Z+bePtvaLkR7cRAAAAcEsER1ySjMwz+mnrAUmSfz1v3Uq3EQAAAHBbLhMcU1JSNGrUKMXGxqpr166aMGGCjh07JknauHGj4uPj1alTJ/Xt21fz5s2r8N49e/bo3nvv1bXXXqs+ffpowYIFTjiCuuXjn7bLbD7bbezZRn6+dBsBAAAAd+USwbGwsFCjR49W586dlZiYqC+++EKZmZmaMWOGDh8+rLFjx2r48OHavHmz5s2bpwULFuizzz6TJBUUFOiRRx7R7bffrk2bNmnWrFlasmSJ9uzZ4+Sjcl+HT+Tox/+Vdhvr+3rp1u50GwEAAAB35hLBsaCgQBMnTtSYMWPk7e2tkJAQDRw4ULt371ZmZqbi4+M1YsQIGY1GtW/fXt26ddOWLVskSV9//bVatWql+Ph4+fj4KC4uzvocHOPjH8t3G6NU39fbyRUBAAAAcCSjswuQpMDAQMXHx0uSLBaL9u3bp+XLl2vQoEGKiYlRTExMhfEZGRlq27atJGnLli1q0aKFnnjiCa1fv15hYWF67LHHNHjw4Gr3aTKZZDKZHHNAl6CsFleqqSpHsnK0+n/7JZV2Gwd3beXyNaP2zC/UXswxOBpzDI7E/IKjueocs6celwiOZdLT0zVgwACZTCaNGDFCEyZMqDRm4cKFOnTokIYNGyZJOnr0qP744w+9+uqrevnll/Xll19q0qRJatmypTVcVmXnzp0OO47LkZSU5OwSqvXZlmPWbmPnlgHatWObkyuCPVx9fqH2Y47B0ZhjcCTmFxytNs8xlwqOERERSk5O1oEDBzR9+nQ99dRTSkhIsL6+aNEizZkzR/Pnz1dYWJgkqaSkRH369NENN9wgSRo2bJg+/vhjffnll9UGxzZt2sjPz8+xB2QHk8mkpKQkxcTEyNPT09nlVOloVq7+WFa6dtTP10sP39FT/vU4TbU2qA3zC7UbcwyOxhyDIzG/4GiuOsfy8vJsbqi5VHCUJIPBoBYtWmjy5MkaPny4nnnmGQUHB2v27Nlavny5Fi1apKioKOv4wMBABQQEVNhGRESEMjMzq92Pp6enS/2llXHVuiTp07WpMp3tNg7t0UaB/vWcXBHs5crzC+6BOQZHY47BkZhfcDRXm2P21OISF8fZsGGD+vfvr5KSEutzZrNZUunBvP/++/rqq6+0ePHiCqFRkjp06KBt2yqeLpmenq6IiAjHF16HHD2Zqx9+3SdJ8vPx0pAebZxcEQAAAIArxSWCY3R0tPLz85WQkKD8/HxlZWVp7ty5io2NVXZ2tubMmaO5c+cqPDy80ntvv/12paamavHixSoqKtLKlSu1bds2DRkyxAlH4r4++Wm7tdt4W49rOEUVAAAAqENc4lTVgIAAvfvuu5o1a5Z69eolo9GouLg4vfDCC1q6dKny8/OtV10tEx4erm+++UahoaGaP3++XnjhBc2cOVPNmzfXm2++qebNmzvpaNzPsZO5+uHX/ZJKu41D6TYCAAAAdYpLBEdJateunRYsWFDp+fHjx2v8+PHVvrdz585asWKFYwqDPvkpRSWm0lOHb+t+jQL8fJxcEQAAAIArySVOVYXrOnYqV9+fXdtYz8eooT3pNgIAAAB1DcER1Vpartt4aze6jQAAAEBdRHDEBR0/lafvtpztNnobdXvPqIu8AwAAAIA7IjjigpauKddt7H6NGtSn2wgAAADURQRHVCnzdJ6+3bxXkuTrbdRQuo0AAABAnUVwRJU+LddtvKVbawXSbQQAAADqLIIjKjlxOk/flOs23kG3EQAAAKjTCI6oZOmaHSouOdtt7Npagf6+Tq4IAAAAgDMRHFHBiex8fbN5jyTJx8tTd/Si2wgAAADUdQRHVLBsTYq12ziYbiMAAAAAERxRTlZ2vlZtKl3b6O3lqTtvaOvkigAAAAC4AoIjrD79eYeKSkySSruNQXQbAQAAAIjgiLNOnsnXqo2laxu9vTx1Zy+6jQAAAABKERwhSVpWrts4qEsrNQyg2wgAAACgFMEROnmmQF+VdRuNnhrWm24jAAAAgHMIjtCytTtUVFzabRwY10oNA+o5uSIAAAAAroTgWMedyinQV7/slnS228iVVAEAAACch+BYxy1fm2rtNt7cpaWCG9BtBAAAAFARwbEOO5VToC837JIkeRk9NKx3OydXBAAAAMAVERzrsBVrU1VY1m3s3EqN6DYCAAAAqALBsY46nVuoL8+ubTR6emg4V1IFAAAAcAEExzpqxdpUFRSVSJIGdmmpRoF+Tq4IAAAAgKsiONZBp3ML9cXZtY1GT9Y2AgAAAKgewbEO+mzduW7jgM4tFUK3EQAAAEA1CI51THZuob5IPNdtHE63EQAAAMBFEBzrmM/W71T+2W7jTbFXq3EQ3UYAAAAA1SM41iFn8gr1eeJOSWe7jX3oNgIAAAC4OIJjHfLZup3KLyztNva//mqFBtV3ckUAAAAAagOCYx2Rk1+kz8utbYyn2wgAAADARgTHOuKzdTuVV1gsSbrx+hYKbUi3EQAAAIBtCI51QE5+kVauL13b6OlhUHyf9k6uCAAAAEBtQnCsA1auL99tvFphdBsBAAAA2IHg6OYqdxtZ2wgAAADAPgRHN/d54i7lFpR2G/td10JNgv2dXBEAAACA2obg6MZyC4r02bpUSZKHh0F39WVtIwAAAAD7ERzd2Ofry3UbO9FtBAAAAHBpCI5uKregSJ+dXdtItxEAAADA5SA4uqkvEncpJ79IktS301Vq2ohuIwAAAIBLQ3B0Q3kFxVqxrly3kfs2AgAAALgMBEc39MWGc93GPtdepfCQACdXBAAAAKA2Izi6mbzCYq1Ye/ZKqgaDRvSj2wgAAADg8hAc3cyXG3bpzNluY++Ozek2AgAAALhsBEc3kl9YrOXlu419Ozi5IgAAAADugODoRr78ZbfO5JV2G2+4trkiGtNtBAAAAHD5CI5u4vxuI/dtBAAAAFBTCI5u4qtfdis7t1CS1OtPzdQstIGTKwIAAADgLgiObqCgqMTabTQYpBH9WNsIAAAAoOYQHN3AV7/s1umybmNMc7qNAAAAAGqUywTHlJQUjRo1SrGxseratasmTJigY8eOSZI2btyo+Ph4derUSX379tW8efOq3MbRo0fVqVMnzZ0790qW7lSl3cYdksq6jaxtBAAAAFCzXCI4FhYWavTo0ercubMSExP1xRdfKDMzUzNmzNDhw4c1duxYDR8+XJs3b9a8efO0YMECffbZZ5W28/zzz8tgMDjhCJzn6427dSqntNvYM6aZmocFOrkiAAAAAO7GJYJjQUGBJk6cqDFjxsjb21shISEaOHCgdu/erczMTMXHx2vEiBEyGo1q3769unXrpi1btlTYxpo1a7Rnzx7169fPSUdx5RUUlWjZz+W7jaxtBAAAAFDzjM4uQJICAwMVHx8vSbJYLNq3b5+WL1+uQYMGKSYmRjExMRXGZ2RkqG3bttbHBQUF+sc//qGZM2dq2bJlNu3TZDLJZDLV3EFcprJa7Knp6192WbuN3TpEKjLE36WOCa7jUuYXYA/mGByNOQZHYn7B0Vx1jtlTj0sExzLp6ekaMGCATCaTRowYoQkTJlQas3DhQh06dEjDhg2zPjdv3jx17txZXbp0sTk47ty5s8bqrklJSUk2jSs2mfXxjwesj69tatDvv//uoKrgLmydX8ClYo7B0ZhjcCTmFxytNs8xlwqOERERSk5O1oEDBzR9+nQ99dRTSkhIsL6+aNEizZkzR/Pnz1dYWJgkaffu3Vq+fLlWrlxp177atGkjPz+/Gq3/cphMJiUlJSkmJkaenp4XHb8ycZdyCkp/Q9C9Q4Ru7h3n6BJRi9k7vwB7McfgaMwxOBLzC47mqnMsLy/P5oaaSwVHSTIYDGrRooUmT56s4cOH65lnnlFwcLBmz56t5cuXa9GiRYqKirKOnzFjhp588kkFBwfbtR9PT0+X+ksrY0tdhcXn7tsoSXf3j3bJY4HrcdV5D/fBHIOjMcfgSMwvOJqrzTF7anGJ4LhhwwZNnz5dq1atktFYWpLZbJZUejDvv/++vvrqKy1evFjh4eHW96Wnp2vz5s3atWuXXnnlFUmlqdnDw0OrV6/W8uXLr/zBXAHfbNqrk2cKJJWubWzRJMi5BQEAAABway4RHKOjo5Wfn6+EhAQ98cQTys/P19y5cxUbG6vs7GzNmTNH//3vfyuERklq0qSJ1qxZU+G5mTNnqkmTJnr44Yev5CFcMUXFJn26JsX6+O4buW8jAAAAAMdyieAYEBCgd999V7NmzVKvXr1kNBoVFxenF154QUuXLlV+fr71qqtlwsPD9c0336hJkyYVnq9Xr578/f3VuHHjK3kIV8w3m/coy9ptjNDVTRs6uSIAAAAA7s4lgqMktWvXTgsWLKj0/Pjx4zV+/Hibt/PSSy/VYFWupajYpKVrdlgfj+S+jQAAAACuAA9nFwDbfbdlr7Ky8yVJce0j1DKcbiMAAAAAxyM41hLFJSZ98lP5tY10GwEAAABcGQTHWuLbzXt1oqzb2C5creg2AgAAALhCCI61QHGJSUvLXUl1JN1GAAAAAFcQwbEW+P7Xfco8Xdpt7Nw2XK0jgp1cEQAAAIC6hODo4opLTPr4R9Y2AgAAAHAegqOLK+025kmSYqOa6ppIuo0AAAAAriyCowvjSqoAAAAAXAHB0YWt/m2/jp86121s06yRkysCAAAAUBcRHF1U6drG7dbHdBsBAAAAOAvB0UWt/t9+HTvbbbyuTRO6jQAAAACchuDogkpMZq6kCgAAAMBlEBxd0I//269jJ3MlSddd00Rtm4c4uSIAAAAAdRnB0cWUmMxaspq1jQAAAABcB8HRxaz5/aCOnu02dmwdprZX0W0EAAAA4FxGZxdQVx07lavs3ELrY7PZrLQTBVr+a7L1uRv+1FzHTuUqNKi+M0oEAAAAAEkER6c4dipXYxO+UnGJudpxc5ZtlpfRQ29PGkx4BAAAAOA0nKrqBNm5hRcNjWWKS8wVOpMAAAAAcKURHAEAAAAA1SI4AgAAAACqRXAEAAAAAFSL4AgAAAAAqBbBEQAAAABQLYIjAAAAAKBaBEcAAAAAQLUIjgAAAACAahEcnaBBfR95GW371nsZPdSgvo+DKwIAAACACzM6u4C6KDSovt6eNFjZuYXW58xms1JTUxUVFSUPj3OhskF9H4UG1XdGmQAAAAAgieDoNKFB9SsEQpPJpDPHfNUqvKE8PT2dWBkAAAAAVMSpqgAAAACAahEcAQAAAADVIjgCAAAAAKpFcAQAAAAAVIvgCAAAAACoFsERAAAAAFAtgiMAAAAAoFoERwAAAABAtQiOAAAAAIBqERwBAAAAANUiOAIAAAAAqmV0dgFXmtlsliTl5+c7uZKKTCaTJCkvL0+enp5OrgbuhvkFR2OOwdGYY3Ak5hcczVXnWFkmKstI1TFYLBaLowtyJSdOnND+/fudXQYAAAAAuIQWLVqoUaNG1Y6pc8GxpKREp0+flo+Pjzw8OFMXAAAAQN1kNptVWFiowMBAGY3Vn4xa54IjAAAAAMA+tNwAAAAAANUiOAIAAAAAqkVwBAAAAABUi+DoZGlpaRo9erQ6duyobt266ZVXXrHpcriAPdauXavu3btr4sSJzi4FbigtLU3jxo1Tly5d1K1bN02ePFmnT592dllwEykpKRo1apRiY2PVtWtXTZgwQceOHXN2WXBTL774oqKiopxdBtxM3759FR0drZiYGOuff/7zn84uy24ERyeyWCx67LHH1LBhQ61Zs0b/+c9/9PXXX2vBggXOLg1u5P/+7//0/PPP66qrrnJ2KXBT48aNU1BQkH788UetXLlS+/bt08svv+zssuAGCgsLNXr0aHXu3FmJiYn64osvlJmZqRkzZji7NLihlJQUrVixwtllwA1lZ2frww8/VFJSkvXP9OnTnV2W3QiOTpSUlKTU1FQ9++yzCgwMVMuWLfXII49oyZIlzi4NbsTHx0dLly4lOMIhzpw5o+joaP31r39V/fr11bhxY91+++3asmWLs0uDGygoKNDEiRM1ZswYeXt7KyQkRAMHDtTu3budXRrcjNls1nPPPacHH3zQ2aXAzZhMJuXm5iowMNDZpVw2gqMTbd++XREREQoKCrI+1759e+3fv185OTnOKwxu5YEHHlBAQICzy4CbCggI0MyZMyvcNDg9PV1NmzZ1YlVwF4GBgYqPj5fRaJTFYtHevXu1fPlyDRo0yNmlwc0sXrxYvr6+uu2225xdCtxMdna2LBaL5s6dq549e6pnz5569tlna+VnfYKjE508ebLSbx/KHp88edIZJQHAZUlKStJ//vMffmuPGpWenq7o6GgNHjxYMTExmjBhgrNLghvJzMzUvHnzOAUaDlFUVKQOHTooJiZGq1at0ocffqitW7fWyvlGcAQA1Ihff/1Vo0eP1uTJk9W7d29nlwM3EhERoeTkZK1atUp79+7VU0895eyS4EZmzpypu+66Sy1btnR2KXBDYWFhWrZsmUaPHi1/f3+1bNlSf/3rX/Xll1+qqKjI2eXZheDoRI0aNdKpU6cqPFfWaQwODnZCRQBwaX788UeNGTNGzz33nO69915nlwM3ZDAY1KJFC02ePFlffPGFsrKynF0S3MCGDRuUnJyssWPHOrsU1CGRkZEym806ceKEs0uxC8HRiWJiYpSRkVHhtNQ//vhDrVu3Vv369Z1YGQDY7rffftPTTz+tOXPm6JZbbnF2OXAjGzZsUP/+/VVSUmJ9ruyWVZ6ens4qC25k5cqVOnLkiG644QbFxcXpzjvvlCTFxcXpyy+/dHJ1cAc7duzQSy+9VOG5vXv3ytvbW6GhoU6q6tIQHJ2oXbt2+tOf/qTnn39e2dnZSk1N1fz58/ltPYBao6SkRM8++6wmTJig7t27O7scuJno6Gjl5+crISFB+fn5ysrK0ty5cxUbG+sWVyiE802ZMkXffPONPvvsM3322WeaP3++JOmzzz5Tv379nFwd3EHDhg21ZMkSzZ8/X0VFRdq/f79ef/113X333bXuF2AGi8VicXYRddmRI0f0t7/9TRs3blT9+vV1zz336LHHHnN2WXAjMTExkmT9jb3RaJRUehET4HJt2bJF9957r7y9vSu9tmrVKkVERDihKriTlJQUzZo1S8nJyTIajYqLi9O0adMUFhbm7NLghtLS0nTjjTcqNTXV2aXAjWzevFmvvvqqdu7cqYYNG2rw4MF64oknqvzZ6coIjgAAAACAanGqKgAAAACgWgRHAAAAAEC1CI4AAAAAgGoRHAEAAAAA1SI4AgAAAACqRXAEAAAAAFSL4AgAAAAAqBbBEQAAAABQLYIjAKBWW7ZsmaKiovTjjz86u5QLuv/++9WvXz9nlwEAwCUjOAIA3E5SUpKioqJcZt9///vf9dZbbzmlHgAAaoLR2QUAAFDTfv311xrbVlFRkby9vS9r3y1btqyxegAAcAY6jgAAt3L//fdr5syZkqSoqCjdf//91tc2bNig++67T506ddK1116r+Ph4ffvtt5XeP3ToUK1atUo9e/bU6NGjra8tW7ZMd955p66//np17txZ99xzjzZs2HDRfVd1quqWLVs0atQoXX/99YqJidEtt9yi9957TxaLxTpm0qRJuuGGG3TkyBE9+uijuv766xUXF6fHH39cR48erfb7MHv2bEVFRSkrK0tTpkxRly5dFBsbqwcffFB79+6tMDYjI0N//etf1b17d0VHR6tPnz76xz/+oezs7It+vwEAdQPBEQDgVv7+97+rb9++kqSlS5fq73//uyRpzZo1Gj16tPz9/fXaa69pzpw5atq0qR5//HF98cUXFbZRUFCgt99+WzNmzNDUqVMlScuXL9fUqVPVrl07vfnmm3r11VdVXFysP//5z0pNTa123+f79ddfNWrUKGVnZ+uf//yn3n77bXXu3FmzZs3Syy+/bB1nNBpVXFysxx9/XJ07d9Y777yjcePG6bvvvtPf/va3ar8Pnp6ekqS//vWvatq0qebNm6epU6fqt99+0xNPPGEdd/r0ad19991at26dnnjiCf373//W/fffr6VLl+rhhx+WyWSy+XsPAHBfnKoKAHArLVu2VFBQkCQpJibG+vysWbPUunVrvfnmm/LwKP29aa9evTR8+HC9/vrruvXWW61j9+/fr/nz56t3797W57KysjRgwAA9//zzMhgMkqSQkBDdeeed+uabbxQVFXXBfZ9v7ty5qlevnj744AMFBARIknr06KGTJ09q4cKFeuSRR9SwYUMZDAZlZWXp8ccf1z333CNJio2N1XfffacNGzbIYrFYazlf2fPt2rXThAkTJEmdO3fWxo0b9dlnn+n48eNq3Lix/vOf/+jIkSNatGiROnfuLEmKi4uTr6+v/vGPf2jNmjVc2AcAQMcRAOD+Dh8+rD179qhPnz7W0ChJHh4e6tevnw4ePKiMjIwK7+nWrVuFx6NHj9bcuXMrBLXmzZtbt2+r4uJibdmyRV27drWGxjJ9+vRRcXGxtm7dWuH5m266qcLjpk2bqrCwUAUFBRfdX1XvlUo7jZL0yy+/KCgoyBoay9ciSZs3b774QQEA3B4dRwCA2zty5Igk6Z133tE777xT5Zhjx44pPDxckuTv71/pgjiZmZmaPXu21q9fr+PHj6ukpMT6Wvl1iRdz8uRJFRcXKywsrNJroaGhkqTjx49XeD4kJKTCY6Ox9Me32Wy+6P4aNWpU7XuPHj1qVy0AgLqJ4AgAcHtlXcIHHnhAd955Z5VjyrqH0rlwVcZiseixxx7Ttm3b9Nhjj+n6669X/fr1VVBQoJEjR15SLcXFxXa/51Jc7L0Gg6HaWi5n3wAA90FwBAC4vbLTM81ms9q1a2f3+w8dOqT//e9/evDBBzVmzBjr8wcPHrR7Ww0bNpSPj0+VV0Ut64xW1QF0lCZNmigpKUlms7nCabzOqAUA4LpY4wgAcDtlXbKyK4KGhYXpmmuu0apVq1RYWFhh7IcffqgFCxZUu72cnBxJsl74pszChQsr7KeqfZ/PaDSqS5cu2rBhg3WdYZkffvhB9erV03XXXVdtPTWpe/fuysnJ0bp16yrVUvY6AAAERwCA22ncuLEkaf78+fr+++8lld6WIisrS//v//0/ffvtt9q4caNmzZqlmTNnVgpw52vZsqVCQkK0ePFirV69WomJiZo2bZoKCwsVGhqq3377TZs2bZLZbK5y3+d7/PHHZTKZ9NBDD+mbb77R2rVrNXXqVP3www8aM2aM/P39a/C7Ub27775bERERmjx5sj755BP98ssvevvtt/Xqq6+qR48eFS4S1L59ez355JNXrDYAgOsgOAIA3M6IESPUtm1bvfPOO3rvvfcklV4l9N1335XRaNTTTz+tMWPGKDExUc8++6z1dhUX4uvrqzlz5ig4OFhPPvmkpkyZokaNGulvf/ubxowZo5MnT2rq1KkqKSmpct/nu/baa6234pgyZYoeffRRbd++Xc8//7zGjRtX49+P6gQEBOg///mPevXqpYSEBD388MP6+OOPNWrUKL355psV1jiaTCabLsgDAHA/Bos9l4IDAAAAANQ5dBwBAAAAANUiOAIAAAAAqkVwBAAAAABUi+AIAAAAAKgWwREAAAAAUC2CIwAAAACgWgRHAAAAAEC1CI4AAAAAgGoRHAEAAAAA1SI4AgAAAACqRXAEAAAAAFSL4AgAAAAAqNb/B3H/MlXGNXsuAAAAAElFTkSuQmCC", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "def read_npv_history(folder):\n", + " \"\"\"Collect the NPV, in million $, at each iteration from the saved result files.\"\"\"\n", + " values = []\n", + " it = 0\n", + " while True:\n", + " file = f'{folder}/optimize_result_{it}.npz'\n", + " if not os.path.exists(file):\n", + " break\n", + " info = np.load(file)\n", + " # 'fun' is the objective value at that iteration, in billion $ with a flipped sign\n", + " # (obj_scaling = -1e9). Undo both to get NPV in million $.\n", + " values.append(-1000.0 * float(np.mean(info['fun'])))\n", + " it += 1\n", + " return values\n", + "\n", + "\n", + "npv_bfgs = read_npv_history(ko.get('savefolder', 'Results'))\n", + "\n", + "plt.style.use('seaborn-v0_8-whitegrid')\n", + "fig, ax = plt.subplots(figsize=(9.2, 5.2), facecolor='white')\n", + "ax.plot(npv_bfgs, 's-', color='#4C78A8', linewidth=2, markersize=7, label='BFGS')\n", + "ax.set_xlabel('Iteration no.', size=13)\n", + "ax.set_ylabel('NPV [million $]', size=13)\n", + "ax.set_title('Objective function', size=14)\n", + "ax.set_xticks(range(len(npv_bfgs)))\n", + "ax.legend(fontsize=12)\n", + "fig.tight_layout()\n", + "plt.show()\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The same problem with a different search direction. method='GD' takes a plain steepest-descent step instead of the BFGS quasi-Newton direction — simpler, but it does not accumulate curvature information across iterations, so it typically needs more of them to reach the same NPV. Everything else — the ensemble, the objective, the bounds — is reused unchanged, which is the point of keeping the optimizer separate from the ensemble.\n", + "\n", + "Both runs start from the same x0 captured above, so the comparison is fair. Note that ensemble.get_state() would not do here: it returns the ensemble's current controls, which the first optimization has already moved.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2026-08-20│09:12:08 : ========== Starting Line Search Minimization (GD) ==========\n", + "2026-08-20│09:12:08 : \n", + " \n", + "USER-SPECIFIED OPTIONS:\n", + " transform: True\n", + " maxiter: 10\n", + " step_size_adapt: 2\n", + " savefolder: Results_gd\n", + " saveit: True\n", + " datatype: ['FOPT', 'FGPT', 'FWPT', 'FWIT']\n", + "\n", + "2026-08-20│09:12:08 : Computing initial function value...\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "51b3a365cd4f45c8a875dfaf4442245b", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + " 0%| | 0/1 [00:00 2.813e+01\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "806081630b57447483643f3212ec0ccf", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + " 0%| | 0/1 [00:00 2.185e+01\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "86bca56bdea64772afee573ff6c43a04", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + " 0%| | 0/1 [00:00 9.880e+00\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "5d7a20e08b2c42fe934917df76c1d0e4", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + " 0%| | 0/1 [00:00 1.321e+01\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "a23f0098ec2f48619d19f46fd139b14e", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + " 0%| | 0/1 [00:00Compare the two:\n" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "npv_gd = read_npv_history(ko_gd['savefolder'])\n", + "\n", + "fig, ax = plt.subplots(figsize=(9.2, 5.2), facecolor='white')\n", + "ax.plot(npv_bfgs, 's-', color='#4C78A8', linewidth=2, markersize=7, label='BFGS')\n", + "ax.plot(npv_gd, 'o--', color='#E45756', linewidth=2, markersize=7, label='GD')\n", + "ax.set_xlabel('Iteration no.', size=13)\n", + "ax.set_ylabel('NPV [million $]', size=13)\n", + "ax.set_title('BFGS vs. GD', size=14)\n", + "ax.legend(fontsize=12)\n", + "fig.tight_layout()\n", + "plt.show()\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Setting up the .mako file\n", + "The optimization relies on a .mako file for writing the current control variables to the flow simulator input. In this case, the flow simulator is opm-flow [opm-projects.org](opm-projects.org), and the input file is provided as a text file (.DATA file). Once a year, the .mako file writes a WCONINJE block that sets that year's rate for each injector:\n", + "\n", + " WCONINJE\n", + " INJ1 WATER OPEN RATE ${rate_inj1[index]} 1* 500.0 /\n", + " INJ2 WATER OPEN RATE ${rate_inj2[index]} 1* 500.0 /\n", + " INJ3 WATER OPEN RATE ${rate_inj3[index]} 1* 500.0 /\n", + " INJ4 WATER OPEN RATE ${rate_inj4[index]} 1* 500.0 /\n", + " /\n", + "\n", + "The names rate_inj1–rate_inj4 are the keys of the ensemble.controls table in the input file, so the .mako placeholders and the config have to agree. The producer's bottom-hole pressure is fixed for the whole run and is not a control.\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Running locally\n", + "\n", + "It is recommended to run the notebook from a virtual environment. Follow these steps to run this notebook on your own computer:\n", + "\n", + "*Step 1: Create virtual environment as normal*\n", + "\n", + " python3 -m venv pet_venv\n", + "\n", + "Then activate the environment using:\n", + "\n", + " source pet_venv/bin/activate\n", + "\n", + "*Step 2: Install Jupyter Notebook into virtual environment*\n", + "\n", + " python3 -m pip install ipykernel\n", + "\n", + "*Step 3: Install PET in the virtual environment, see [PET installation](https://github.com/Python-Ensemble-Toolbox/PET)*\n", + "\n", + "*Step 4: Allow Jupyter access to the kernel within the virtual environment*\n", + "\n", + " python3 -m ipykernel install --user --name=pet_venv\n", + "\n", + "Start jupyter notebook, and load tutorial_popt.ipynb (this file). On the jupyter notebook toolbar, select 'Kernel' and 'Change Kernel'.\n" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "venv-PET (3.12.3.final.0)", + "language": "python", + "name": "python3" + }, + "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.12.3" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/docs/tutorials/popt/TRUEPERMX.INC b/docs/tutorials/popt/TRUEPERMX.INC deleted file mode 100644 index cd9f4236..00000000 --- a/docs/tutorials/popt/TRUEPERMX.INC +++ /dev/null @@ -1,10002 +0,0 @@ -PERMX -1.2125322688166615 -1.4804586292831 -1.2900273928077464 -1.3080326276886987 -0.9010201034671027 -0.3391250401022951 -0.06567433422955772 -0.06354385316487116 -0.03940458934890809 -0.032323623959903416 -0.05640692034891659 -0.08765401301117075 -0.11926666171573598 -0.24369538039382882 -0.4116173104000202 -0.8777823213237925 -1.9567714055939114 -0.492381119770178 -0.6994481587460912 -1.130121492845984 -2.9515731747566845 -3.790374838956305 -3.326437141450565 -0.7913480251200226 -0.43196724653234764 -0.3533662219994789 -0.22809373547540918 -0.2774827250179592 -0.424056609314691 -0.6973011791285172 -0.8375718302649562 -0.7005929070882069 -1.7147199389951449 -2.977031980873864 -4.05245189040416 -3.629392958984608 -2.6543454845269143 -0.8797436411269038 -1.703990529465131 -1.1528948839880586 -1.6989934181578406 -1.2222853627713657 -2.0551003853536076 -2.2956115001171185 -4.030249805921163 -3.170949262251285 -3.508114400332186 -6.923847500310728 -6.235563811854872 -11.360024946098978 -12.3859862472974 -8.90614905921594 -8.40980259498171 -4.755144335265007 -9.531612686043303 -9.678313483330065 -5.243684524288248 -2.028258479251364 -2.3135812198759593 -4.080819348942676 -3.6137554416469735 -2.5013941048941275 -1.1753478976195024 -0.9420958435909906 -1.1507097606709262 -2.1752390512760917 -0.8463162335672384 -1.8921722755190742 -2.662042152924102 -1.6254009524659196 -0.6917612341619975 -0.4101908593525552 -0.5355115478981787 -0.2665758516256408 -0.4377670410505516 -0.46829599500426977 -1.1090638095750716 -1.8533551280324871 -1.3380473840404588 -0.6010544233927353 -0.8599777688568763 -0.755020000199926 -0.4488916810644499 -0.12208776399915873 -0.12367800038259572 -0.13176309673293568 -0.3047656034275932 -0.262303557460595 -0.2523106660809352 -0.14921302645307236 -0.19335829930026907 -0.14140877907400262 -0.07430335376315973 -0.11420397202787833 -0.1498040348377993 -0.31081438115941834 -0.32324652519021035 -0.21679942695747986 -0.2288786610175765 -0.49619176131652853 -2.4018918571401033 -1.8671680032099662 -1.0169833662649013 -1.0038799695545888 -0.40023510658919026 -0.2091377691885897 -0.03943293276886986 -0.04860679439790934 -0.07898707011182818 -0.07469188450415173 -0.12667975510168822 -0.14307468732590373 -0.2117280666854895 -0.3837366462332798 -0.8763544126422008 -1.270901134936579 -0.4381178775005482 -0.6410225108423376 -1.517438320621433 -2.049141166918937 -7.7375420778253945 -4.014781591429012 -1.0360687740994596 -0.4572513398700553 -0.3238768673459398 -0.2336375744890227 -0.39599920906978914 -0.5890527863993439 -0.6587113819203178 -0.9823096964849783 -0.7685275507628313 -1.13342998476044 -3.5978434376468686 -2.2419877474955414 -4.024449173091083 -2.6415354035329557 -1.4063725959710205 -2.2800629574957845 -1.5457811504269583 -1.432573851728561 -0.8916982739442154 -1.1086764116176986 -2.254696032198072 -3.368240969952938 -2.9025135125419337 -4.614569383648235 -6.529256907431407 -6.222308558136882 -11.476511118474113 -13.356289467458973 -10.104601072160552 -8.183596829673174 -7.256666244736915 -6.854259048663036 -7.728436661511358 -6.287889615298376 -3.6658285985851013 -3.0523704288535605 -3.9660146941185106 -2.175062320124374 -2.4428274393569773 -1.406524336912903 -1.1064996241365175 -0.9716718557167725 -1.7608241667501707 -1.8553156308982335 -2.0176473797768324 -1.343044907370552 -2.0756700251937574 -1.160061932745492 -0.9422358241042452 -0.7242814446953812 -0.3780426419448275 -0.41581836213051293 -0.412034818242143 -0.7504677171812075 -2.3063882027244715 -1.9206676679481778 -0.556220126032826 -0.5559010232302728 -0.8420930154260731 -0.43504803595429814 -0.2213249701340905 -0.21136159086498935 -0.2534325885449603 -0.606290064766037 -0.32391908428000005 -0.20602158487331523 -0.21978573094784967 -0.10152864252990129 -0.0814987019355344 -0.047962871930502894 -0.11230345493058891 -0.15572225907270204 -0.2587134364957289 -0.28663854925961896 -0.280168981468264 -0.22038441037998402 -0.47879658218011123 -1.3722798298439178 -1.3355104606517239 -0.5301705257137086 -0.644045266947678 -0.41583323036699693 -0.28348711052523257 -0.08159967189568999 -0.07659954247150642 -0.06639116007367553 -0.10079066191158582 -0.15597698311758698 -0.19707098702535877 -0.3310375397120963 -0.3825390910622527 -1.5355814562385282 -1.5794934861894003 -0.4960062442978919 -1.2824627395081611 -1.113368430547358 -3.6145821542065764 -4.77102496286739 -4.974261790294575 -1.7728289080562225 -0.630660913481441 -0.32276952946169224 -0.3292436361152782 -0.412976840490177 -0.7355427467216517 -0.6170017931072164 -1.3234441438146929 -0.7164124112103116 -1.0915920560987626 -3.3639010517230203 -3.0368212933849668 -2.3412986982588455 -2.475207464307871 -2.136517350470544 -2.7140830261195403 -1.6585409780682852 -1.5072263881361814 -1.001760745793743 -0.7892766331727672 -1.1671805014626593 -2.5984025567843303 -2.652197374720823 -8.59448964537681 -9.091990736006842 -6.705007465450535 -11.50024869168686 -13.001586677858983 -17.515633744010934 -10.620701202620026 -8.40046321721369 -7.555918832099491 -8.095736323633393 -5.138762318784004 -3.4681040757313126 -3.144375823190744 -3.404611570539297 -2.6231747763244457 -1.859448082186475 -1.6458547222757614 -1.3931307846145902 -1.8986043124568925 -2.868951983689119 -2.0187544911436306 -1.3031953349604402 -1.2439332988494072 -2.597124630950966 -1.4595885407438802 -1.076221305303012 -1.3940972134101628 -0.911644157372349 -0.4675427959861825 -0.9005081669714884 -0.7418002668438646 -1.1268242900421557 -2.004686053984666 -0.6596177084123971 -0.7961699945418612 -1.4629475999700041 -1.1020378876405406 -0.336487500969898 -0.3679268212564894 -0.278611881910311 -0.6889025276535712 -0.3413850559357766 -0.3064636620770901 -0.17645881171960676 -0.05007593613420975 -0.06811332847729189 -0.050046192206586716 -0.06724749346888619 -0.08736896091365383 -0.19492636372949407 -0.2402153421076342 -0.14276083394557887 -0.1755362239601581 -0.5255176359525043 -1.3598715881739731 -0.8450072836198772 -0.4873021159566793 -0.5000743739101948 -0.48850920165523515 -0.360379607595271 -0.13203833823491493 -0.06762641708055342 -0.06116032499667604 -0.0837123698818413 -0.16684509386189134 -0.32915733609494513 -0.2197789011303936 -0.3174597844473018 -1.414209064116958 -1.9338750198197454 -0.6073843066953787 -0.6258280334627025 -1.419001748037505 -1.9234985777647609 -4.837859644607967 -2.2040689476121065 -1.3205746291538716 -0.6765499844068573 -0.314926888744154 -0.2767262316657347 -0.5209454490681636 -0.7305886319725089 -0.6309570125319863 -0.6956098259832042 -0.8447373136607846 -1.2408143313628344 -2.7473672041063937 -3.7892176794568946 -3.8594698778606698 -2.438233757264346 -2.829369935297147 -2.6711867515823804 -1.6443912979747606 -1.6772008170353037 -1.1047288905212578 -0.8436568459202355 -1.065212788828607 -2.3792058012639288 -3.7850923558628033 -4.031695151499898 -9.762490267326838 -6.90573918008613 -9.476702810967465 -9.57199709482207 -16.788459691797275 -11.526204621299987 -7.896040989167524 -5.0485130180910955 -6.864748521508647 -3.4451031705294595 -2.578750093843302 -2.365853415699326 -1.92107861671546 -2.4087015074747016 -1.923805069076906 -1.5506540391711046 -1.9903465870522559 -1.6394033137974593 -3.42589460162905 -2.88421028943536 -2.06286598181171 -2.836800869163618 -3.61078994497241 -1.7082052335970235 -1.5184620349765883 -1.8857506106519912 -1.1680107528583912 -1.1236237778588785 -1.115286971716121 -1.6254909849537238 -1.744833137989038 -1.7829956517811334 -1.1367071443655838 -0.7270336681530619 -0.9707651777102733 -1.2744723604329378 -0.8967848972759841 -0.4622460512036558 -0.452913943315553 -0.8191007573051922 -0.3189777275316271 -0.22509013741720998 -0.11793017113264806 -0.0404160312517718 -0.04619924723278723 -0.06340960576769741 -0.1008039367579722 -0.08448441121883687 -0.21880336339789802 -0.18618367495221919 -0.11060199514887457 -0.1685583325322691 -0.3908884955073753 -0.953810272318493 -0.7349991527580741 -1.2154463060464265 -0.6759426792662018 -0.5799503103662317 -0.5354816906350288 -0.26632841452937184 -0.1156245981836628 -0.052136226583020286 -0.09248235472251784 -0.20688097013093715 -0.24679451186831225 -0.20636670072501384 -0.41777836998563433 -1.2619481914572748 -1.4360355922662877 -1.4891819808562436 -1.1407392941591081 -1.9793937921549738 -1.8039344830816626 -2.956094504323999 -2.7659518881814456 -1.0075801712037085 -0.806964589393533 -0.5505833457669806 -0.3492249034339575 -0.4432680652132572 -0.6581646112882353 -0.6133860639439674 -0.7270539169373166 -0.4367615727753751 -0.7385510656473189 -2.7095653787969165 -3.717997150213712 -2.3900856128951924 -2.317028534616145 -4.190946133933185 -2.12360623973929 -2.57303184731828 -2.2510234704593017 -0.8132065040323636 -0.6343589648336682 -0.9779640195917108 -1.652203467754637 -3.6331108464426904 -4.574054317967956 -11.331718518618725 -7.399171592496612 -7.148324399577648 -8.080009440978051 -14.603830498623612 -13.551351415032467 -11.643287331630953 -6.252497286120459 -7.057229043040761 -4.2981778749826445 -1.2405440676612827 -2.1180871221671524 -2.3848879846258666 -2.129293178524424 -3.5398210779195205 -1.4490237157223418 -1.853441306032745 -1.3824549574017855 -2.280565858661106 -3.405041238912149 -3.287618108403765 -1.903705101376098 -6.612727493826659 -4.047568037822436 -1.7846753685455994 -1.8404231587485032 -1.7645672422359509 -0.866776533208562 -0.5792622774755373 -2.1403538320858426 -1.8490396730470855 -1.79828037679407 -1.16914779608729 -1.0014575019557301 -1.362593629526772 -2.889384956601598 -1.0048630548519797 -0.5666388442347636 -0.5524975090736806 -0.6552653712990425 -0.5104250328581175 -0.19813453814525317 -0.09916228981681025 -0.07921505190867904 -0.10022595973149888 -0.10646496435616754 -0.11017397254400471 -0.2646055970014457 -0.24801390257384978 -0.1657990541975228 -0.27645548106197587 -0.2831218033259363 -0.3357497619636243 -0.6295881896520418 -0.6270761737229505 -0.9773918249042375 -2.009309412803469 -0.6890342471049724 -0.5677823258910606 -0.3702612352091075 -0.08935629346177565 -0.09951381636757649 -0.11113655103317559 -0.24748306688687852 -0.30390999530454316 -0.3337662589317241 -0.6485698676165954 -1.2661765716885618 -1.5593855142547204 -2.006817678265277 -2.463431915078809 -1.2147219791568429 -1.1678417888418118 -1.8057723010078726 -1.6456626148312858 -1.2068878944366186 -0.5607725512568706 -0.5150312429266884 -0.5020327885169276 -0.6076115878929335 -0.4032159727018396 -0.8641301251777078 -0.5705613654385204 -0.3339092789546469 -0.5495902276643773 -1.2405878353363253 -1.89088393022417 -1.5167769871157124 -2.252785157795304 -4.4574881443623955 -2.764721479721476 -1.8237889751088199 -2.0639468125836418 -0.6741888968201353 -0.975369643455119 -1.015238016617267 -2.3218705661830423 -5.403267712487912 -3.329197139806631 -8.712023367600132 -8.305796409863998 -8.508323397920313 -6.945968634123698 -13.534648278367994 -15.094930365881714 -17.968797597783432 -6.151702318574053 -5.516894518358137 -2.854968224708378 -0.8988459278615178 -1.461758822606118 -1.6327228301391459 -1.2517884704406992 -2.272706802742752 -0.9196445580589782 -2.5333407279832083 -1.612617959458094 -2.514833839558775 -4.11723634646475 -4.076670069868371 -2.6907346612075167 -6.010063094707296 -7.002139173619689 -2.512279181007287 -1.7257969073849186 -1.6511890765902684 -0.8465259086507101 -0.736952397324336 -1.230629237028286 -1.8588850314345233 -1.752996473884358 -1.2480425874462573 -1.8924725059112448 -2.0724899961364103 -2.72647186675392 -1.5415425577987576 -0.587336216712722 -0.5675879320465639 -0.7294790878755127 -0.7526790597419568 -0.40614768100010207 -0.09381071967556842 -0.10705800393016045 -0.06846008839001942 -0.10159093994499353 -0.07330661657007048 -0.1727608046993729 -0.24898595522960787 -0.1933200097489323 -0.39301275980549727 -0.614748663321671 -0.25107470111530716 -0.35246000353344104 -0.6217057903961278 -0.9060961069035675 -1.2292891094971432 -1.9025007363157573 -0.6742840665748534 -0.5348592779018411 -0.19359542208562658 -0.19243605237055617 -0.10875449341232137 -0.21830455417302386 -0.19416109282457913 -0.32280735826290236 -0.5324679630141663 -0.8510350349543981 -1.7605271499917992 -2.2719320661586293 -2.8936309461371983 -1.4294898160607956 -0.9204726740058853 -1.3966903022057569 -1.3787952149950213 -1.8102337642869581 -0.7654318387172464 -0.5997717952976697 -0.3934731263522612 -0.3753153820470707 -0.4893245698515353 -0.8551325643397981 -0.59823880789068 -0.38320392551044385 -0.3768124512314911 -0.9785198460651731 -1.9180725679218975 -2.335686114339949 -2.645290823320606 -4.425493491632758 -2.332157817231847 -1.5515707980610478 -1.4673982546059579 -0.6688307285244928 -0.8644137370940368 -0.8383954127134358 -1.654100836934561 -3.1833824310172716 -3.107987649111362 -8.262453196762747 -7.197134077223696 -6.364237892866922 -5.972961727353014 -17.04291695881444 -9.600529590739233 -13.216066981460052 -6.294574586447089 -2.1875176887049457 -2.8759214722715387 -1.2308426003508581 -0.9199306619102284 -1.6884106620810213 -1.6244828478304385 -1.3891911014701035 -1.6671780157770404 -1.7865946291273882 -2.036990095323861 -2.9840656441387705 -2.6977140138490503 -4.000924121155857 -2.1307816126505776 -3.431987291505304 -6.99343563402641 -2.392255424243771 -1.094467188305712 -2.20615327166393 -1.1884761744952426 -0.6644451421619743 -1.2499848780649812 -2.054524171586822 -2.009225321805618 -1.1892925619948174 -1.7566241308224742 -2.7183701936070936 -3.3986272186965096 -2.2002114263467973 -0.9347078747273837 -0.7246404270396924 -0.978042907632364 -1.1462412597001161 -0.3735311228942744 -0.14853439444621694 -0.13161808836679692 -0.036621975464235096 -0.08262746990416618 -0.08319743798876808 -0.1725018948040006 -0.19734233064960047 -0.4129952029572883 -0.2700888574538891 -0.45043977746253266 -0.333273268490536 -0.32134569317875844 -1.5205546818426245 -1.21002057959257 -1.616730979629924 -2.5151826528985413 -2.5907862863212663 -0.854579358594881 -0.27040811274593834 -0.30636821544557935 -0.15640391417221589 -0.35939194758619786 -0.322574816704496 -0.4016190131704785 -0.8029242147737621 -0.9328172123057249 -1.759296713068324 -2.758016291902624 -3.044089760767295 -1.5585260633711246 -1.9132867018535384 -1.6734167749380733 -1.0697048007808088 -1.6746130275557298 -0.7069597403121033 -0.6613579925898375 -0.45757386107579034 -0.5278205197379553 -0.5623946514034474 -0.46925325204580903 -0.6696333382905569 -0.2686724839141598 -0.4552227184289927 -1.243361961345643 -3.5277863340713065 -1.8877333675438213 -1.9424141037086415 -4.220386395010252 -3.021242641681074 -2.4005329305025054 -2.201501962747816 -1.0347562526592025 -0.7594105478185512 -0.6606274364250763 -1.6004318409257472 -1.867900696984884 -2.5009505061633046 -5.21089239391635 -6.89623227393693 -7.120616226895258 -9.400639998908934 -22.535190747492674 -13.877571153390525 -8.741167747719262 -7.386872073587702 -3.8996101475571243 -2.829683002975269 -1.320980468555244 -0.8573531209908036 -1.8706272857217443 -1.8385494379712606 -1.5329260039106063 -1.8552077604256219 -2.313431319944848 -1.7944349837961124 -1.461361144898593 -2.9979517924610466 -3.338875443460325 -4.08529453270212 -2.928544322738501 -7.605416506474529 -1.8909438292545326 -2.8159316762845874 -2.488616300498283 -1.2718729129778752 -1.0861580520692744 -1.5670224860965962 -1.7005331233407572 -1.9428934219719758 -2.2959057275619332 -3.289422684202737 -4.297922753727922 -2.7163006466746418 -2.359888216158232 -1.0384003769084824 -0.8778093721142338 -0.7143203454244922 -2.582795141251466 -0.435449185055045 -0.15899554380220254 -0.13531415480355619 -0.09257491494034759 -0.08515897575261343 -0.10066757857262675 -0.16522403921279827 -0.30310309036862154 -0.45393919878659134 -0.4728617469563949 -0.616483432148848 -0.2991833492106204 -0.4141499236640521 -1.5899178454185325 -1.015684403090913 -1.4871691722021256 -1.6715939984434371 -2.5527113967611674 -2.1004366955597185 -0.36625633694452964 -0.2850845507123412 -0.2678241985915992 -0.2260599478648697 -0.7489644367993941 -0.43427871311767063 -0.8309760967061419 -0.8432131191866992 -2.07618441129493 -2.7698806520446264 -3.231535004458054 -3.2797222633098215 -2.9348751688479173 -1.8261693148881863 -1.2049644364994323 -1.6167645739124168 -0.8363007055024586 -0.5540258251624542 -0.3795112047712654 -0.5321131439901924 -0.5741926880469401 -0.5717806852870029 -0.8643843858505891 -0.20008370049294427 -0.451769401775082 -1.0541545489558426 -1.3268174576298135 -1.22559730890792 -2.3415734400789536 -5.655129571994112 -2.4305925579117615 -3.839613027158175 -2.1098808066568964 -1.074836136847823 -1.0392825158216452 -0.7128908510613645 -1.4217080406507916 -1.6925876329228846 -2.791640161078685 -6.7442482956813405 -9.350394280517087 -11.821626607318606 -11.178120088541018 -16.573358689225838 -19.063816102342628 -10.483401723794552 -8.735229615122273 -4.282809139526844 -2.194078719603304 -0.8044357898990716 -0.7754970902243946 -1.1245357139308219 -1.2355570631380148 -1.5736162299721368 -1.9180975239187816 -2.522179502975168 -1.1518459266231935 -1.387081998409466 -2.561102304919811 -2.539391390222784 -3.0117545913601322 -2.828217472429387 -3.7920658547016086 -2.4257817118385736 -4.392967982446662 -3.436923730740381 -2.0123016962161553 -1.341142741851449 -1.9348035341559473 -2.7032434301145325 -2.974516368870554 -2.088528437412702 -4.125109161037656 -4.109300059945181 -4.323201551749808 -3.0643038625942385 -1.687587157823629 -0.8015016685392754 -0.9506815439025258 -1.924390139774795 -0.793566117754582 -0.2548179286356915 -0.1917147075593359 -0.09928772114714952 -0.09077840895222071 -0.12127927891887266 -0.1864985102765644 -0.23413457396602746 -0.5305523063819693 -0.8161061044989009 -0.7025772283625702 -0.42276494482741944 -0.38172657403743576 -0.9091619463719905 -0.8147090697316451 -1.105069353133739 -1.9446248132637491 -1.8796668681904198 -1.2356870854810866 -2.1537133626915033 -0.284140188318345 -0.25007506984146816 -0.4865003934173872 -0.992215603945211 -0.9560776531537367 -1.1222224537998935 -0.5885904251882919 -2.8247413464537705 -2.920652666810462 -8.07066998512349 -5.246376679603365 -3.145366935699436 -1.7400420757597668 -1.6545936321281134 -1.423254907667995 -1.2937528640009053 -0.6849439304222011 -0.4458164432493552 -0.5113400749113659 -0.3567402860597747 -0.702319035716219 -0.44403104517646763 -0.23261202816997129 -0.3679134865811022 -0.573075037058734 -0.9536206143541416 -1.1675986393882711 -1.946759686630442 -8.712599501531816 -5.854617217415572 -3.8652306058412735 -2.036147287232846 -1.2503380178188404 -1.1077537456365638 -0.7425524603968814 -1.9699824952137104 -1.556955413238379 -4.789740779189489 -4.022520036178864 -6.615360187160878 -17.104942937568907 -17.228898154850842 -19.349588419896072 -11.568748949388938 -8.308843796572033 -6.2103470789646895 -4.486919575871393 -4.270965421680071 -0.9401900695968124 -0.6112828517277465 -0.8918665649004438 -0.9639138299091411 -2.7336838223553057 -1.9139568974131933 -3.22927703482176 -2.133144445077974 -1.2991492097829274 -2.153973764055829 -2.408518188202364 -2.8640305862567654 -4.320019187209692 -3.6129587883375702 -2.3923169808107327 -5.749898944198151 -3.728575922904064 -3.2811310960160043 -1.421624646019525 -3.142815425019731 -3.555625252865416 -2.5858304550704347 -4.291285697672176 -4.229124440071734 -7.446908265145206 -3.9408073216846367 -2.687032043719747 -1.711667770765186 -1.7570268463399852 -1.0485277364682002 -1.2879913620147994 -0.833983474903379 -0.45588362981947944 -0.2169408628323393 -0.12238677630023978 -0.12108660236960848 -0.17863148326025688 -0.25340726203698494 -0.30036995590331134 -0.545947940934065 -1.3085283255129765 -0.6370855095744706 -0.47375088905141366 -0.5261984458585908 -1.261671792879952 -0.9301215731410226 -0.6500441354643886 -1.5324029739986647 -1.7042123072533957 -1.6028192159574706 -1.675856169393293 -0.7180724269216021 -0.34046847355597093 -0.6510969957851049 -1.218439036374001 -0.8095945738966157 -1.1222150679441212 -1.3145152254325487 -2.8377392589260957 -4.428896945582106 -7.016120191279347 -9.10226513317867 -4.049693965384548 -2.5101956141083535 -2.926772834942522 -1.7860786647692413 -0.7641668699169798 -0.9385359237309928 -0.4094950842327964 -0.41187517441626964 -0.4004827863006394 -0.6206692052157449 -0.49231390639978756 -0.2008177308575181 -0.36233711490405474 -0.7528997239722705 -0.9262405598983402 -0.6567816590792409 -1.9091289836083238 -8.896054982706124 -5.192209842369905 -3.5535842621112645 -3.3288815718775 -1.2200097089810245 -1.4141010587507763 -0.7942778167190911 -2.4353551624533463 -1.4589161422006824 -3.4165290303848153 -3.6417023596111147 -7.880730941823473 -20.845822044125395 -18.75155495844634 -24.948897789078732 -6.373628515386903 -6.977485293614836 -8.45131295846353 -4.566172253749739 -3.217063963172469 -0.6193401548875621 -1.1682701374631157 -1.049499327163328 -1.4955975956448433 -2.799006473447229 -3.4404057822225136 -2.302679772192567 -2.3540624190066093 -1.810854281153776 -1.8185113150747436 -2.917935129154271 -5.192449650230835 -3.505037275143055 -2.968883743716009 -3.850444835779146 -5.154933626708668 -2.6345891032302466 -2.6821963740147106 -1.82849991679632 -1.9897622536910828 -6.685731630221358 -3.8410714693579053 -3.646405982217459 -4.43550877770907 -6.173467355680075 -5.906555071471137 -4.744015326203163 -3.0732007159555894 -1.6137498665003933 -1.3691986108676917 -1.3458312101363545 -0.5967650867537893 -0.567652643022337 -0.17916492410531734 -0.15146032700005918 -0.10581359457271958 -0.24570327368823083 -0.32915255851203856 -0.2466771470225501 -0.6464500301882942 -1.2207379631847954 -0.6913449421717585 -0.8765546884284063 -0.5119672339211205 -2.06635463216159 -1.4636053217598155 -0.9373262299435255 -1.7489128117877344 -1.923964860736541 -2.0985265029642006 -1.315172226739579 -0.7460980700173663 -0.7601638988726497 -0.9999192246172233 -2.148854688801063 -1.2145802774853973 -2.1211809582412955 -2.242714272533742 -3.2179067110897743 -5.94791232745854 -9.507129202246956 -14.954817388383518 -6.083136790254848 -2.1743359543074687 -3.886248269811056 -1.3824913477425542 -1.1068760204037027 -0.991823031336013 -0.6699155620901018 -0.30068407671381453 -0.4911274955795443 -0.6549233742025634 -0.6235719013834894 -0.2635132370747299 -0.3626310932852573 -0.35065260091753914 -0.6529563946564099 -1.1437889604575193 -2.0473103227994316 -9.017205262915379 -4.428626626252696 -4.049509803888581 -2.73111196130647 -1.103790617056485 -1.975119595381997 -1.1195439703280867 -2.5300173428952264 -1.0330283977798067 -3.621036738235864 -2.974049999172918 -6.718015129086754 -22.147226151929754 -19.498815027351483 -16.64549448384015 -10.59066573086206 -4.11740557089337 -4.891094469562561 -3.4806733928249773 -2.1176214455722877 -0.7183857494762139 -1.3975755165684538 -1.1449797742180363 -1.882375115475783 -1.4214497721615322 -2.4112659091425708 -1.8461269990810985 -2.329791465757807 -1.570057697105812 -1.6263431044169698 -3.6735203929834754 -5.000824197931061 -5.116957958722307 -4.710325911570023 -3.909909987700557 -6.203765691263734 -5.4310868568453925 -1.6667368168028835 -1.5603058977523576 -1.8061470887071198 -7.309036362386895 -6.023729306718464 -6.10514057153283 -6.210646878373021 -4.663658353085684 -6.3343760677003065 -3.315227796228318 -2.612310727311468 -2.400221065570011 -1.6520839715186866 -1.2273716934840542 -0.5887502173202552 -0.6571300819127147 -0.2500522360458084 -0.22298700829677262 -0.0872266240478719 -0.19544827603190898 -0.6039738461106757 -0.5563036730707321 -0.5496651260071901 -1.0331345301804538 -1.0728709968991814 -0.9343805763949066 -0.7506639458764784 -2.1562775035091297 -1.3119070792438086 -0.8981057239240674 -1.4203624864913 -1.7653157712216234 -1.2653507862795819 -0.9393752155668132 -1.670700733599923 -1.219133070099974 -0.888363582847684 -2.2830179866898113 -3.18067784087384 -1.9525848528099121 -2.2102653577095652 -3.4616375946939693 -6.856788153141722 -11.506690151432208 -11.618856238767457 -5.695289042519083 -4.395262745471972 -4.588114975015994 -0.8323288233766578 -0.7239799771884202 -0.9101076916700122 -0.5117314336937289 -0.26928392882747476 -0.44266741759458483 -0.4955159856606914 -1.0873077765611983 -0.4264193256775005 -0.14921910984473516 -0.3612133564398514 -0.6537582022478147 -1.0915584351875733 -1.1135055484633531 -3.9514867368792026 -3.5391162788686317 -2.780075601237899 -1.8499169666599737 -1.108872703046638 -1.004139288357045 -2.727535336227641 -3.417343791169896 -2.3820845965449506 -2.7613634641328506 -3.4711447119596865 -6.146170440038144 -17.241201957154114 -17.094165590733166 -10.94261502218292 -15.441616969661313 -4.024420235735273 -4.131844496770326 -4.551933801736108 -1.7866820846364828 -1.0492274187875466 -1.0659488151523657 -1.5234003121606885 -1.5553927043160338 -1.1850317877930323 -2.0218840509470306 -1.412789759494723 -1.4828256990986362 -1.3114913349014528 -1.4860057537651121 -2.055739459546351 -5.258635176666437 -7.927835157075187 -6.387825653111029 -4.101259822884014 -4.030808808396502 -6.011508882235964 -1.7939861325841493 -1.1769133018003652 -2.0086779848905305 -3.1104302683510645 -7.8393300856831845 -13.67406472581473 -12.44306961193613 -8.803128205062484 -4.828653921365888 -2.5390233551545105 -1.9205829233680793 -2.707036447676976 -1.6833597237658993 -1.0907639152090516 -1.0081366737770034 -0.7451222640637825 -0.3648693691190972 -0.4293430481560379 -0.1467485165605538 -0.19633795787443079 -0.3598280695973436 -0.6340992581351729 -0.34412671088179425 -1.0889877525425746 -1.6632233969564874 -1.4741037017304173 -0.4627830753916743 -2.074342042637431 -2.2705616409302185 -1.7194842305246822 -1.7344569178742804 -2.2590262490200055 -1.7975658672310524 -1.3943099483731196 -0.8963438271513443 -0.8758381918085766 -0.9547324767378005 -2.0774685846746372 -2.104295411204303 -2.3855055135273187 -3.1267076089591974 -4.103397048844764 -11.914034115554218 -13.17817992918677 -14.912404649560779 -8.405229908979395 -5.7918962908581015 -4.063933305638903 -1.7539765403473977 -0.46131557936329765 -0.6907166948809251 -0.756297752661413 -0.3759751950149172 -0.4895846430936229 -0.5556329440318241 -0.7180444340230767 -0.47274307690372114 -0.32289508843763426 -0.32114465183272195 -0.4283784351510105 -0.5673637403291929 -1.0983571436004942 -1.648038065206065 -3.076160809672779 -4.948228133582063 -2.037505828021697 -1.593340505608113 -1.7207484949862397 -3.7259321636220024 -5.048804806548078 -2.612318909881062 -2.114015300592771 -4.677585607313748 -6.239214799914245 -14.656912020035792 -20.203123971965304 -9.436266409278637 -11.406484375643503 -7.1084428391590135 -3.4974879670911583 -2.7495636486692603 -1.8968871609707525 -1.1814372893220526 -1.1203741120931467 -1.2050914328944744 -0.997834664356933 -0.9738075350764726 -1.078445107679749 -1.6814722903788852 -0.7333288614719657 -0.9279088740762447 -1.2219508725007067 -1.516423541589168 -3.5594688754146198 -6.664094129464004 -7.560157051214169 -3.9698355702850066 -4.427866064976359 -14.137702677760831 -2.8462417247835337 -2.0432899438461587 -1.9230440337480996 -1.707525045296624 -6.785934912484038 -16.29772861525193 -12.966924044419663 -13.50092193207029 -4.835053805173967 -3.4196712625257915 -3.4757906699801198 -2.9736380976362953 -2.850070756674395 -1.8473454191814345 -1.1229917503220708 -0.8038125686235128 -0.6530391209321397 -0.720599775705255 -0.3331881975048396 -0.3921655111272996 -0.31574954462693644 -0.4363441077116981 -0.7872522615819448 -1.5648315816455458 -1.9837228188378482 -2.1931183257943525 -0.9679700762652715 -1.7188727918630324 -2.0721769083138963 -2.0623962769198187 -2.7829389824122925 -2.214643595694913 -1.898962809914727 -0.9976985260452045 -0.5872378047977684 -0.6174513544532413 -0.8390318060965607 -1.2911435411777328 -1.7308979859093698 -1.5555930110053189 -4.6646425727017204 -5.216569287810087 -7.939328296474538 -14.376987336993963 -23.862247938195306 -12.098551027235798 -4.8982545128754005 -4.715450984326936 -2.5005269690432566 -0.932433395257351 -0.7846161002216125 -0.646059837594246 -0.43044082006598317 -0.8421551409175083 -0.9360641676930741 -0.9222048083065497 -0.7217924498268542 -0.7333282049093267 -0.6051153777974825 -0.320833304167971 -0.6209893227742552 -0.5899781460686184 -0.8329523042850034 -2.7345275054770584 -3.6120902500315473 -3.247845443541052 -2.3860230571040786 -2.476093449211509 -5.939644079039937 -8.896903981369604 -4.57521284646741 -3.724616647727415 -6.273678649745647 -6.742832695131067 -13.569715464839433 -18.42326283470694 -15.640550320242625 -14.384489625880285 -5.881186298331453 -3.7277689520676356 -2.0633018385836714 -2.1108308256335424 -1.084076966717804 -1.375456653482792 -1.2034657619753635 -0.7466492051666526 -0.8083608629022416 -0.961352136894034 -1.7841591012424396 -0.6668770252292204 -0.987316399441231 -1.5390039789259247 -1.7652693761904386 -4.644011101833992 -5.663255605297397 -7.9702012109622435 -4.453079979264868 -7.1595849433192855 -12.571411633857714 -2.9166271656154823 -1.5023396420079393 -1.6241724333743774 -2.845529079529943 -4.626294352955287 -19.73223070521613 -27.786417279654923 -14.945396369723811 -6.283245349718126 -5.483214468542526 -6.421320689653553 -9.280348107550923 -2.3349149816865653 -2.9711416406978923 -0.9951746666845851 -1.2307355227272838 -1.0845245690808312 -1.2962802515677403 -0.7877210603957367 -0.5143605361815566 -0.3191108463435736 -0.6907114895800651 -1.2135330967775755 -1.0463525787778893 -1.0629555667233404 -2.0798734363110727 -1.1708231349902656 -3.163823977342322 -3.071631874772906 -2.245155197998893 -2.19632795796012 -2.654619326360131 -2.2339499445412137 -1.2114395845172181 -0.6807719232524719 -0.7538124495214228 -0.8895347733172155 -0.6174623543034695 -1.4167077046414576 -2.624574423215054 -4.847318906141652 -4.912722367980508 -8.016365182809862 -9.487012005404752 -18.60342992986171 -13.82438057683819 -8.531435666592657 -7.413037977266312 -2.357570677364754 -1.8484812956419077 -0.6874801119475008 -0.48816464912698443 -0.6746906640045687 -1.0459003601717618 -0.9519963574570454 -0.520509101646676 -0.49864979293243733 -0.7308142951086607 -0.849256396413588 -0.3085774003710268 -0.7449992175749314 -0.37438047211992326 -0.6528779518060098 -1.4800078637528882 -4.422736799256389 -2.5797411425880794 -4.083190805713065 -2.5565647827524702 -9.615383829014345 -11.019922886371768 -5.294399112938728 -3.977047798724604 -4.144424862888322 -5.264438996757692 -4.6828068569982895 -9.655982279993301 -28.390547950706676 -10.093699436987299 -5.145933311933867 -2.507005521955877 -2.4675989794093636 -3.324942093730002 -1.1349001448022134 -0.8974777440301066 -1.326737989024977 -0.8898079245768249 -0.7540625764183834 -0.8483954915819498 -2.1715796374857086 -0.7842773052468274 -0.796884056658238 -1.1105451384023033 -3.1511873814690596 -4.822935326457035 -2.986695333787986 -12.99704898848402 -5.795197734707725 -7.721125450138755 -10.194115072009444 -2.680764686747856 -1.6002059958480348 -1.0618077273362365 -1.9607091403176042 -5.037619347787524 -10.997252417740828 -25.971980517944935 -30.134762874545455 -14.211345104679959 -9.723846794238321 -5.973507584930467 -4.581771328379959 -2.8011490782351967 -3.1569162350349718 -2.6612883235380793 -0.8342085213215151 -2.3423735164661355 -1.6617545370541436 -1.1362823183382125 -0.8851709997331649 -0.6157269421082908 -1.1212603739413862 -0.9252696589574615 -1.0219300849791582 -0.978711027235377 -1.3718509937990262 -1.2176305850772031 -2.5810232932401576 -4.833173963260952 -2.2617799797407305 -2.615606513578971 -2.868409250385821 -2.4281492040891828 -1.6705389143026645 -1.1692372069212669 -0.7157395074800232 -0.651678098153309 -1.371570205435169 -1.2198945557991765 -2.7039426664712547 -4.188429516701842 -6.463976316048922 -9.71210013045981 -19.578301128224126 -18.855943876260792 -16.94007202139202 -6.684696661789033 -5.94492303124545 -2.980300638374068 -1.6340766969339544 -0.8326977153413754 -0.36618360788475746 -0.5519154606558833 -1.005554620964622 -1.3398478493202646 -0.6634402965163031 -0.3198186406298885 -0.7075390092608288 -0.5784846989765976 -0.507531564468789 -0.8784778305465775 -0.541647177177239 -0.4429976155574044 -1.6801071108229642 -2.770286635165348 -2.27538464961481 -4.1679434841648595 -6.532590257704249 -11.60575759845179 -11.764943438080344 -4.338671004077047 -2.7719754952165028 -4.04138333728295 -5.760483683695572 -4.55322162865495 -10.002563680779835 -14.157382484490736 -9.889752844780219 -3.561480010078316 -2.5345427836987984 -2.3218226514783944 -1.750950843894024 -1.53134119689779 -0.786475854019824 -0.7432117396952558 -0.7449122398878054 -0.8774826235172668 -0.6472165865972017 -1.0951960610419886 -0.5549262719519306 -0.7172328635640599 -1.087423256637555 -1.1532238882170782 -3.3114094827480463 -2.0815462450029174 -8.007381389424054 -3.0859030140972683 -7.496884088697572 -11.86516631378068 -4.790791852694939 -1.306801162069305 -1.1536613199025518 -2.298664846237041 -4.129423056183623 -8.968611839722621 -32.63509279086292 -28.335174239442505 -17.77683817566819 -11.617629450414578 -9.246821122510179 -5.034542381842421 -4.649208257648332 -4.301870141130366 -2.2504538939911476 -1.4171967463727517 -2.0370853103225204 -1.5146902442959815 -1.1030231541691755 -1.255925615983544 -1.2041591198722612 -0.9306700218988792 -1.1574728914089487 -1.0340506896613773 -1.0342112470325655 -0.6553866335372573 -0.9140713897900249 -2.929495114348135 -3.9680577246236575 -1.8861648097122365 -2.47060847095099 -2.8637247532867005 -4.032801862956171 -1.4264412230928387 -1.1478315611236953 -0.7965556669381517 -0.7427501308248299 -0.5846151719513137 -1.7380045561720352 -3.481782974660443 -3.099162450585002 -7.341703129991905 -9.972159268713606 -15.971763169903324 -21.510791088957628 -18.408703725166426 -7.8688459213242865 -7.640383712727395 -2.511189357508516 -2.7029395374759146 -0.8696584325806931 -0.4570038642438071 -0.8460791524556053 -1.6276008520520082 -2.396622059854173 -0.6849938441610568 -0.37742172217684666 -0.531480181580709 -0.4951633082819391 -0.44570593065596015 -0.6905340955831475 -0.37017895624072317 -0.554986588763785 -1.2946148263089547 -1.8522571343562326 -2.401927216582757 -4.4901400271463965 -7.6444936310760605 -11.053251883919145 -8.738143552088989 -6.032965335739228 -2.5014706624223355 -3.132600193917248 -4.16081934488889 -4.560150440535009 -10.855703953107403 -6.305048068983698 -9.844492046786865 -6.156594121191223 -1.5893314136380725 -1.5962387279083725 -2.4336466206029352 -0.9535282875176551 -0.4513422456691734 -0.7813502634230584 -0.6573344832235141 -1.464211611166208 -0.9938471301480153 -0.6062081732322792 -0.558433995410648 -0.6403563506735495 -0.6460303681879395 -0.6516792957992729 -1.6804920518862196 -2.0948108849772478 -5.784930135628369 -3.186420429780307 -5.718974243578719 -5.990751953342318 -3.5028289035560496 -2.0353725862799315 -2.0111525682567604 -2.58566611544586 -3.828807319403507 -13.981380873254498 -45.50862026474393 -20.799824906027393 -15.374468479227371 -16.33983774559593 -8.550597672798586 -4.575920238589359 -4.641740478656849 -3.4362617562522035 -3.2895008767598757 -2.0814795959824335 -3.0027664160735394 -1.4917042793627493 -1.769846440474213 -1.908439434240635 -1.4811576928965118 -1.0972614347548901 -1.1239313454842186 -1.2050111242388208 -1.0195200387811199 -0.6755392998798208 -1.0752717605135238 -2.3387376994359443 -3.2988947057887965 -1.5226703665132288 -1.9085680956863216 -4.279409572294474 -6.722874999483636 -1.834234183936644 -0.7486465637294805 -0.7298686384981179 -0.6250598930460217 -0.7547527408608433 -1.4783223035894024 -4.153293985196603 -4.234422814320242 -4.16537492250912 -12.529218735666857 -27.954963975016625 -18.97573669655778 -10.94964315140702 -12.444766346188182 -5.823556651315275 -2.5628143848410088 -3.506296674478478 -1.0199001401705394 -0.5367465095556937 -1.010680205087541 -1.1260127753890328 -1.196187891676761 -0.820862085124733 -0.5841723421141911 -0.6671119358565191 -0.5877797931789194 -0.35575749857510336 -0.6430699591059656 -0.4327992858512798 -0.5302887905269594 -0.946252899972045 -0.906025509636594 -2.1882258802299774 -4.245417865293341 -7.424479184338899 -9.63274035956309 -5.997183345514955 -5.79642775364636 -2.1352335542724603 -2.8979212987945524 -2.4379899662104947 -4.866365409258836 -8.83956699807937 -6.022327785848122 -6.580308711136553 -5.3291724976760975 -2.581011923198323 -2.1328072137960197 -2.8638018076211096 -1.4814895914878787 -0.8666192667519046 -1.1823517263443895 -0.7691148394991054 -0.8261831223758034 -0.4625671749163746 -0.547778234541268 -0.33980008904866155 -0.6236276632682529 -0.7354342935758577 -0.712444479404614 -1.2960974740109366 -1.3457461145032357 -4.301570134392949 -4.870226389258316 -4.721738989185069 -4.488064087079133 -3.5722514848481337 -2.348209053230039 -2.4290954784964374 -4.547510010327526 -4.480900814241144 -18.749290145902368 -55.03950232538579 -14.347423148901099 -22.546491396407358 -19.021326078959184 -10.684744261661816 -6.914025649497886 -4.410709448665953 -2.879415765166599 -1.9565103082650432 -3.188790455950387 -2.065734151936489 -1.2805338529985164 -1.6661967562579232 -0.9235270649654561 -1.4883305375976177 -1.7086799184279515 -2.046278111696572 -1.3095160372381445 -1.562313512149125 -0.7067778830839662 -0.8744221553790001 -2.2739536086365786 -3.092110421914706 -0.8774315199802284 -2.8885722735263872 -3.0013883793465608 -5.98719367063786 -1.550211709303653 -1.1511629712139837 -0.9241450235678991 -1.0039202202484914 -1.0610373558524655 -1.7749035710773866 -6.377036095414528 -5.057243037899967 -5.6837828025156405 -15.702276766438759 -9.680201373003555 -33.314405798890014 -6.976622001539495 -5.629252371864726 -4.5848006923124665 -2.9346261129346902 -1.6720954911031038 -1.5350376519109983 -0.7864176514262512 -1.1442197499917868 -1.7853351662207104 -1.683520907745862 -0.8529780344321584 -0.8873426723423586 -0.43323784981350366 -0.4282611624551822 -0.2374015542391457 -0.5386119775358678 -0.65346728989561 -0.3306748850697556 -0.5693519813264849 -0.6486792900728096 -1.6106156162290481 -2.838451283476919 -3.528594327451623 -11.83214029042304 -5.699765365359468 -3.012522356388639 -1.9614849818757314 -1.917966507861555 -1.483334658048975 -3.2101796824916664 -3.7969956681158963 -4.4904996634342424 -3.2878552307622027 -6.413034415217703 -2.8121771362589354 -2.5171145123140506 -4.647662379570287 -1.6607390151108066 -1.4572696851135696 -0.8518369657753504 -0.8399470462505384 -0.6694179812659684 -0.39666855292223413 -0.4710072042163386 -0.42961253315383663 -0.42566729324251157 -0.6544417104101489 -0.7510259631052304 -0.9457202876843727 -1.6213037178405487 -3.252123904866043 -4.29486048458252 -3.3752575385427215 -4.682687353402216 -2.8460119703485383 -3.4854601311402527 -4.1152425292561805 -5.845189645581429 -10.144163562895342 -15.593884681647836 -49.35462708921623 -29.34960782606807 -26.52055174695184 -12.038166604921628 -9.906548928399099 -10.092279142646548 -4.734390428335348 -2.9978325120331486 -1.4892725421134876 -2.237199924251329 -3.063203722980553 -1.586469880122748 -1.1593759161287644 -0.8572035319176088 -2.4054311806422892 -2.139921250068007 -1.7028669003195187 -1.4859298868026554 -1.555002600427126 -0.6127769447742732 -0.6037214961315871 -1.8874175827172286 -2.9455597710692794 -1.3916647488277205 -1.5179733135235782 -2.9479279446011173 -5.236263312842299 -2.8661154598380447 -1.7423726550036391 -0.8384868872848056 -0.5687945216745415 -1.1719517304567255 -3.1204536369460847 -6.691294408521953 -16.07347656855973 -8.471047619159798 -20.727524185476227 -7.173074946035136 -11.084531988604322 -6.104950154733516 -4.555951347419347 -2.584031441026115 -2.3659076422579113 -0.8667290310660363 -1.6541345259571907 -0.6930053753245221 -1.4382789130831701 -2.5256753169578294 -1.3327689447169973 -0.8578967612338512 -0.8616676285746603 -0.24129465617828644 -0.3680297193381047 -0.525742869891341 -0.656620241600755 -0.4983213858176106 -0.16650882551460644 -0.4262588792847623 -0.5146376165816242 -0.8868176340747602 -1.3513203289023354 -3.845415401661707 -6.322208306748565 -3.768991142971333 -4.089214531691538 -1.9845799562405821 -2.81256039585761 -2.0362779033600744 -3.201673571102559 -2.932781740277727 -6.968584481706092 -4.361862827941264 -3.554719605509154 -4.19875713918476 -3.150083540816109 -3.9298134885492004 -1.581417378001684 -1.2339162450226893 -1.1754447055060575 -0.4978786045077192 -0.3660042827276919 -0.592611239159465 -0.46336724662376305 -0.5445263367174598 -0.2954965695235467 -0.7476591806676193 -0.7881827848535263 -0.74480866241736 -1.5620513170350934 -4.990439737240222 -3.458176195641201 -4.613115640157599 -3.483374586195383 -4.673260287996063 -5.859231766990166 -4.332823994983247 -5.1844666577158405 -10.837898341532949 -23.50033774290637 -42.533322138809986 -24.660022225488245 -22.042524130946624 -31.62789977548367 -14.946856349745188 -14.957955660394443 -5.829431300902391 -2.114019367981569 -1.692087465311779 -2.176510296855868 -2.836903646993923 -2.6185560747974073 -1.7111613652326365 -0.721409655955685 -1.2808289522056844 -2.710502501848847 -2.2256167205955824 -1.685044548507337 -1.5591975295974376 -0.6524559838356582 -0.6491510635761712 -1.5319714746170972 -2.5662371800410804 -0.8804099068400665 -3.3098243809180605 -3.314226646841216 -6.621011902271599 -1.9728736619729499 -1.9586336538319689 -1.3779314063876267 -0.7726798814808743 -3.9282536235075303 -3.158825247663976 -5.393169668052686 -19.1740539908438 -12.45102155560392 -14.792231719591417 -7.602380165473457 -12.290113117983278 -18.966809765472394 -4.757118286834036 -2.5092003709115156 -1.3622961968071434 -0.9859785006647399 -1.0979868676519533 -1.4321461514350686 -1.502783694307969 -2.3977920423633576 -0.8424419837349607 -1.0667278099101336 -1.2933454022568383 -0.3777748483508135 -0.5063189819206164 -0.4517000318001387 -0.8531045054708485 -0.2641039650883729 -0.17387275248987197 -0.3970884625577797 -0.2643930316718527 -0.6857694161867439 -0.48148309564321184 -3.150317386457125 -4.743792532210715 -5.599985862259476 -5.1079376133129015 -4.49917051557045 -3.2599577001151583 -2.604823090025764 -3.1570767477094477 -4.1654570244584415 -3.888958306601764 -5.536144333833185 -5.050244007520068 -4.136778846075198 -3.4163425400284813 -2.572920467279726 -1.2784382123403186 -1.3848027810845915 -0.7215288578055463 -0.6321267063600624 -0.5504209260209512 -0.6267265226725552 -0.6482074532171621 -0.4041486595637397 -0.2038378760722912 -0.45720081050792577 -0.4484446336596816 -0.7507498409211782 -1.4433177052992803 -2.184016115406889 -3.594813846552806 -3.7065274244555235 -2.201668074978797 -6.655739975432827 -5.814881236905196 -5.7255604125983055 -4.9590124668114335 -18.78806170749831 -19.24373068081895 -34.72028528253655 -22.46033103271953 -49.815188512784324 -23.104721478535467 -26.621203473344732 -13.609878339596296 -6.784424752453826 -3.452361755178453 -1.6951569430698272 -2.5761065872984945 -3.0984306542046527 -2.3140632906355045 -1.4970915491144143 -0.7798785226514292 -0.7378587829669805 -2.6653799785629277 -3.342946305843361 -1.723443353729643 -1.4457503139327008 -0.6808911628321567 -0.8347489472749482 -1.8969851127028874 -2.4110644022563474 -1.1944627431620711 -1.555152133825833 -1.8384573215116178 -4.069746385709473 -3.9444190957397676 -1.4912173225953742 -1.6049787143425338 -0.8137326016348795 -3.5977800621894183 -4.744444749318395 -9.61935333394743 -18.662437932175887 -7.818149708140013 -9.960946574773097 -9.779883693753899 -13.967538845609399 -13.929308055252234 -11.073855025871737 -4.06034644315488 -1.023221956196373 -1.8757006010790784 -0.8485319960387279 -0.706549040102928 -1.5891892143608517 -1.4154632479466873 -0.8270806796727597 -0.8268609290015737 -0.8592670826289613 -0.7643182453761613 -0.5698206959409475 -0.44131382706227335 -0.6386006101241912 -0.38370158487125006 -0.25154252139913297 -0.32976740052553133 -0.20034863132351555 -0.4551317514705018 -0.5992995662819705 -2.625494548713772 -3.3418302412894154 -6.747375572347159 -3.103558779245747 -3.4689139243831075 -3.201042089943804 -4.399526091275934 -2.5637709539936355 -2.478651432510174 -3.8770663816230337 -6.769294536485818 -5.719878337846701 -4.343388320353491 -4.244937935957679 -2.5424491913556944 -2.3682398442763044 -1.0491419867519838 -0.8529244532082255 -0.7063804215463748 -0.3899773269631602 -0.3881538385344931 -0.5716662581246046 -0.5549377684700957 -0.2436704453710888 -0.559981656778532 -0.4837784349531748 -0.9147988741734027 -0.6872353679248394 -1.9740731356840986 -4.768687378274499 -2.591277784248891 -2.1806135037835728 -7.604060872189068 -7.230845503536622 -7.677364834085856 -3.4533880295074804 -12.411681153346107 -13.3238985729062 -22.759131236512435 -27.954076784201213 -22.3992329419535 -32.52791063274514 -35.26607314225948 -15.933856088731366 -6.689253185274172 -5.075974053728372 -3.2080516903571024 -2.027102601747287 -6.017430717538663 -3.592035418620092 -1.704692678367279 -0.30993031959819417 -0.9794494768477722 -1.9453602261213532 -4.424473524962809 -1.922111798379368 -1.3481951739684745 -1.1755002840018953 -0.9355294252183795 -2.8396044391074056 -1.6277930964212486 -0.8539664223091402 -0.8211451841460949 -1.3925162528058397 -3.511117509215117 -3.027755503479498 -1.4391680214254159 -1.5921547510292593 -0.7360404070302636 -3.0883433360224903 -7.3628141883384135 -9.430604462184935 -15.221957514182916 -16.861775341601675 -16.88618622028553 -16.82554995831412 -8.975674902671418 -10.59744439530256 -10.200050547767628 -3.9384276349020353 -0.7840942419367192 -1.1419126629232554 -0.7396768790773323 -0.5504848757049257 -1.6949907887664044 -1.287195576883965 -1.216144165057931 -0.880349723689589 -1.0350518124018409 -1.4293817251762135 -1.2013441929654385 -0.4425934126149794 -0.6661879102527177 -0.41992124781814233 -0.2428061826691043 -0.24553874914555057 -0.2626999375369166 -0.4234006096685562 -0.6588925369104193 -1.815487052203524 -2.9900754954514115 -4.197895209086225 -5.283096238156725 -4.363595345102217 -4.746665106996539 -3.6221451399182163 -3.0489546747314784 -1.9183471716566793 -3.926725318181627 -4.521772215343707 -5.777334925038007 -7.291721308292044 -6.283293428885399 -2.24817162013527 -1.3100749120849189 -0.6517720223131952 -0.7135572680125519 -0.41468205823237997 -0.49435908797638606 -0.49356982331756893 -0.3361262599610412 -0.39683878885746887 -0.38450165965747607 -0.5781475996456322 -0.571842750238986 -0.9703909046188668 -0.5786850965076746 -1.8470784552139599 -5.236173104134221 -3.0698597280195905 -5.026341757054277 -7.303332054345604 -6.5319692785008225 -6.93989374676365 -2.5886906495290862 -12.371731430293483 -18.16241591220041 -15.419275884797448 -25.608361256314552 -13.420321067228931 -46.22599387471268 -39.25356027329692 -13.98626447636662 -5.729343781703229 -4.660667491082877 -3.511164381221964 -2.153952442778999 -5.002096812297251 -7.018772694858025 -1.2977232145052464 -0.42906840395508916 -1.5064261189658796 -2.07481106040365 -3.3289359364890445 -1.279400282284153 -0.8730890884688219 -1.4064041849024727 -0.98243078815925 -2.2666763691011154 -1.6681521847130445 -1.019409633993508 -1.2651028859628302 -1.6324207490327372 -4.090554656236547 -3.2649062087532723 -1.291971851017716 -1.0281375321047843 -0.8005481565802005 -2.231989731860473 -5.17008241463484 -8.200735649535407 -8.38078532270614 -16.02468410480443 -20.781367632664022 -13.191834800315263 -5.470803019987036 -12.56423313570124 -13.314904384016286 -3.690313203118158 -2.4310275961757566 -1.5756212311795117 -0.55592111652392 -0.9158367137048632 -1.080701826845856 -1.3341324991307038 -1.4058781830987759 -1.1172998437990291 -0.9360394698784043 -1.414176977657608 -1.181585344386437 -0.6946711492136005 -0.24235093089193366 -0.37860538875489713 -0.3068233776434135 -0.2188675676079294 -0.29975225185850196 -0.8608823929841041 -1.0730612515394466 -1.3960803657602638 -1.6361439006951082 -4.000571835000382 -7.349499891567108 -4.32812411607522 -7.183749493814274 -4.96570648538549 -5.363226969152197 -3.4241614461956784 -5.832702949982341 -8.105336640358066 -8.653953497554888 -7.239017758537655 -7.049570309195914 -2.18646761292454 -1.282862144792788 -0.49858697872873137 -0.8200477192509421 -0.36779386150127824 -0.6466628803754447 -0.4077415701552731 -0.44543745258900136 -0.5156336048202488 -0.3904767494290089 -0.4162897181718268 -0.427567645598615 -0.8830840308707332 -0.5379970988984766 -1.7513271406965738 -8.348731938172708 -4.987370013719527 -11.166014677877659 -6.465112394329062 -5.660485943068403 -3.8565956038873592 -3.1328284325736684 -15.31644363166501 -13.968653580428374 -14.285495749482942 -30.842659450405613 -24.5608618532572 -24.02691856094014 -25.937149366439993 -9.447511084444493 -10.167168629357029 -4.649908295376863 -5.192938787555502 -2.1966846221763947 -3.16713944221358 -5.426411736345393 -2.113194242707448 -0.5769266351424724 -0.8360656078742451 -1.415323114481196 -1.0817729089836616 -0.906060224397856 -0.978285805657886 -0.9823602624809971 -1.1556063649407233 -2.7826410131034733 -1.6184078984689867 -0.9387059881647416 -1.2334850467868543 -1.1761183570917835 -2.5748887601253547 -1.6754196100657874 -1.7142140379620292 -1.1853977843974082 -1.3056926814757923 -1.4955394064152119 -3.72907946977874 -4.935391662453915 -9.287184941746267 -20.526022724997585 -18.380278326661305 -22.395543841023724 -8.605420748702677 -9.16246397466646 -9.804320926316558 -4.716195765325258 -2.2116777433452453 -5.638203220023937 -0.8710712204238135 -1.1609770331415445 -1.7969900907068477 -1.4576004113922154 -1.1973149599597148 -1.5890457511710787 -1.7585906379905816 -2.0928517041077783 -1.0658065218800379 -0.6672204279364443 -0.49299907019768824 -0.471552560175959 -0.38607173329071054 -0.19648397906330606 -0.2516177189802475 -0.4586706301667566 -1.0854980883208494 -1.0795591756056826 -1.7286962109887754 -4.983967170642392 -4.410518305168042 -7.438408613007211 -9.821947222255208 -5.681166811974992 -5.621008291654681 -5.411833301624767 -8.062132838059197 -6.848253220365387 -3.316551124310266 -6.521040776895672 -7.397316587742194 -1.8350644523993376 -1.3918319181234697 -0.583930891156843 -0.44759492633041664 -0.28652201761674817 -0.9991835751129642 -0.48476575197254684 -0.33682066205519745 -0.378292967577778 -0.23665903753966439 -0.5405717546253496 -0.4858781278154594 -0.5804464085302339 -0.5274573403562866 -1.3043556139175567 -6.39332111794454 -12.338685152429594 -9.23490638543137 -6.964015452642436 -8.301448335777502 -6.994014262869113 -6.701598968600936 -13.936333760829394 -12.15904078774156 -9.799776630590724 -38.938575432777746 -24.0443265418834 -36.1432486449896 -22.515979542316767 -8.008523527150098 -11.902588341079003 -4.646253384935767 -7.587638393726512 -3.821598899636904 -3.6378074898525816 -3.576456161475909 -2.0140065178615036 -1.0870016865563825 -0.7146008362696734 -1.0082444063797937 -1.2049456988186902 -1.0741928714815436 -0.6400438931204182 -0.7356711711455854 -2.045667015679746 -3.700667470122083 -1.5363042591104714 -0.9330710056437432 -1.0195038879265554 -1.4197577450076144 -1.1141402101116749 -0.9562524028094512 -1.542510462510808 -1.215784031509518 -1.4285695865562518 -1.137553282134217 -5.220481006100623 -6.654922239859483 -5.427540921980713 -14.791930965258626 -23.409478199787063 -20.214444125768942 -10.657672828270782 -5.283905235319694 -6.84334276370673 -4.881081137151564 -2.5923427320668924 -3.2111361449144473 -6.689216171782462 -0.7331478143260455 -1.8641835109611478 -0.9156319312843946 -1.0885161852647802 -2.5436888262624726 -1.874931769252001 -1.4058898811421887 -1.3366620198910477 -0.7371191410432826 -0.8913183530346481 -0.6837891440238202 -0.941058564340939 -0.17315798021271808 -0.20104220365955225 -0.3988902752658921 -0.7972922099913563 -1.7454377320454135 -1.7115519584315173 -3.2641097662314924 -5.287475949954443 -8.806674176198712 -15.738896761329531 -4.14650803897402 -3.8090129235432477 -4.369175577808154 -5.562207599080213 -4.170501617775263 -3.668538364896713 -5.061654943893187 -3.576205808178772 -2.7705766833732706 -1.1386655029828687 -0.37590052481428254 -0.43909444116911467 -0.25006857696222806 -0.7042295108763125 -0.36264422313611416 -0.25940721796820493 -0.30825730836094944 -0.16721772552245281 -0.5150533502738018 -0.3816280227794871 -0.39902162970858285 -0.5284347368960172 -0.8159551925968592 -3.3433443243833048 -8.804142062952504 -8.193989666691525 -12.152409338917277 -9.481912599839228 -11.423928290533002 -9.162254939736153 -18.91599227943393 -17.929150542228818 -9.799862370915067 -20.349874183337146 -16.054857099306453 -27.935400384994644 -11.345107632340815 -9.844397890028153 -11.065267832948088 -11.509660588119436 -4.716528233052912 -3.8438544483677473 -2.3709135819135176 -2.306800859147566 -1.8410280619488044 -2.03063697726517 -0.8061841805785995 -1.201528718764145 -1.0027131668647813 -1.0812273251160391 -1.4408501544157069 -0.7305554263606474 -1.9266511124124408 -1.9876960677627502 -1.6528464833798384 -0.7433401565956804 -1.0025617218741805 -1.4132331845510289 -1.2175176642912997 -0.7330018344236261 -1.1456929113076364 -1.306417743909993 -1.6075104179306272 -1.7592941448450532 -2.9861049980430616 -4.947434713065857 -10.521046195000658 -24.501944032781008 -54.16547218224167 -31.79563123008617 -10.287437604944243 -7.311728084923151 -8.870848797285868 -5.661981621103542 -3.466614952219414 -3.2317551346024116 -4.74157880856905 -3.199546378089749 -1.5983361111286252 -0.6251238620551648 -1.4891235514692083 -2.194516128206781 -2.2389547730911756 -1.9699224859280886 -1.996688291193274 -0.7322534554850951 -1.3869055949669624 -1.1048401191565294 -0.8855171940194261 -0.18686448629676988 -0.19423290987036343 -0.3150341416727274 -0.9194964735928001 -1.3710984264441868 -1.4837121617851747 -1.9263923971585781 -2.9322956715383395 -6.790590445953472 -9.097752985397197 -4.063088424333066 -2.686239620037281 -3.252351889517665 -4.489330800555934 -3.688746720407967 -6.1421521098724305 -4.779193251224833 -4.133051733707877 -2.399305095918959 -0.6437644501644412 -0.49109051964817585 -0.2768721684918618 -0.23178489294342003 -0.2904159646007641 -0.36109326067814734 -0.3663340736342621 -0.3487549471102929 -0.16415977806291351 -0.32102375776330033 -0.5833925682806009 -0.33985886685964617 -0.38472957936984853 -0.9282765403640894 -2.0658408783982405 -4.879264416360337 -5.21985546012169 -14.562233899603093 -13.85327444465346 -14.89607564613884 -16.510445457108315 -18.102107173256734 -18.191756138223706 -18.340308974936725 -15.675389080094028 -11.534502037637804 -14.141056792620626 -15.72607873594158 -12.486061381187294 -13.554491515595569 -16.104127961620836 -5.994045921722618 -4.3351902120258625 -2.555252133468969 -3.0931749055888007 -2.18181007237485 -2.1043360513475733 -1.0866895636633795 -1.9391051154798886 -1.1219819784772382 -0.9519134030966999 -1.2844047138944887 -0.554092592842177 -1.4923841859027136 -2.182490389797187 -1.2681004175591373 -0.7961063115886947 -1.0454608649658523 -1.063931106733445 -1.4572106338092117 -1.2420950546875809 -1.4130324173271478 -1.4006386610252632 -1.3523642484411849 -1.6454434397036444 -2.7287153261116974 -6.175703653341769 -10.623690164867206 -18.325568362049964 -51.93839743079589 -21.65723602717956 -12.281275109057605 -8.905393324261698 -6.899051076402698 -3.812411025737921 -3.7764989349201565 -4.034779830814938 -4.667295541604537 -3.599773954021873 -1.3161035796698168 -0.6464250333709102 -1.3431317876716369 -3.4111223666682067 -1.4864874941781694 -2.2069856419859017 -1.5355983301945206 -0.9906979483605304 -1.6896893813347873 -0.8780157970816255 -0.7905001321112717 -0.5394707624882068 -0.2770943876056335 -0.36263275595920497 -0.599485002771053 -1.1348101543847926 -1.228663687194862 -2.116524912279163 -2.5770030111681836 -5.492212481122036 -5.445629685919587 -1.5563034772337387 -2.5352554818630204 -4.913842947432448 -5.368155231297466 -6.8957958706232345 -10.086969579582417 -4.110569722998347 -3.480737511842567 -2.0343543901943786 -0.6360979846109902 -0.400323419131075 -0.34753199609205937 -0.18703645747209757 -0.4673125132534198 -0.49959288882601116 -0.3320751097151966 -0.3206251723359706 -0.22062585144462915 -0.3648116281396986 -0.4974234916605018 -0.29167687370665146 -0.3582256137026016 -0.862715360380737 -1.2323116206874232 -5.666076694669841 -5.462662673734787 -9.04618888420048 -12.713926457374733 -17.224285322950205 -15.12575424998415 -15.970464657888478 -15.688898905340999 -22.51702345459374 -25.346246689859203 -9.084926833141857 -8.438625000588564 -11.91599204370983 -19.160967057716704 -25.429177985986314 -26.47518614051586 -5.193951417238256 -4.131325890315302 -2.5177939798735998 -3.1512693233180027 -2.6944391491747854 -3.6259940996448936 -1.7779312621586842 -2.979715629786172 -1.157496943128339 -1.333811747531966 -1.039699173146467 -0.5389089390997897 -1.9139247312281853 -1.6872142230842795 -1.5969947022185889 -1.2007636993322859 -1.48253398760769 -1.0035750933039034 -1.4296146425283576 -0.8924248443991873 -1.0093577539363583 -1.4467918281641066 -1.429303326442508 -1.7415234448481425 -3.9092723027545064 -5.355413855192747 -7.40289393761831 -12.440732088268158 -52.009515701243934 -9.5593189534966 -13.274794695904909 -9.048875310866398 -7.805066144036763 -4.709397537087202 -4.041899807092552 -4.83493247369726 -7.053489748196413 -8.194199863001785 -2.370893929503605 -1.2669415915140818 -1.4484596416085729 -2.5125866674432764 -2.2834208288598097 -1.9606602342138417 -2.0972671570822277 -1.2719186170124135 -1.7724277475358008 -1.7740709225715585 -0.7187656663524895 -0.6804617378276551 -0.35889364602597446 -0.5323538679219665 -0.7515179140600504 -0.7343283104080476 -1.0441441651085577 -1.6114824407859114 -2.6363353143853216 -3.254910441484372 -4.946670441874659 -1.4021858529615177 -2.580030760709154 -2.7238118467522217 -7.26665266877858 -8.30541309950645 -9.465027647001499 -3.2070039602722002 -2.7032672468883914 -2.255349735948565 -0.7019625607936888 -0.46506081644749747 -0.46924837223117744 -0.19241763140524842 -0.2624982180657737 -0.5972197351451966 -0.62589500364314 -0.43343930395118513 -0.2574803134837495 -0.2657004282503108 -0.25830737020727207 -0.2802590845262913 -0.6074988547809307 -1.2996000194260382 -1.4688327613675864 -6.686239720304154 -7.501445267854894 -5.528529989052053 -8.53029599832932 -16.479781028990473 -12.671815153222934 -9.561407792294085 -20.51943127318346 -23.929205696891394 -14.018414394138304 -9.506639078929872 -6.450354719374261 -9.154835947937261 -18.209973899964382 -20.407131774243897 -31.647227401613552 -8.042940047491376 -6.215957406754055 -2.1037430934147063 -2.939833372368852 -2.185357771655561 -3.322591508800573 -2.2510237593408053 -2.7216986155357223 -1.6025207623801414 -1.941436986210519 -0.8910691928735033 -0.9234772485587771 -1.5660189032339933 -2.1575860881267643 -1.0499219762175342 -1.5231227379650512 -1.8591831984430083 -1.0044390015923816 -2.307611633686027 -0.903667418762552 -1.0190908769864613 -1.1550215304353344 -0.9679214820817208 -1.8535679005682888 -3.6319352152794195 -5.160783807068009 -4.771103308973606 -9.369837676974518 -21.44608749324892 -12.933763548017536 -22.66160569985725 -12.378550356740549 -6.460315339296645 -5.41652152478113 -6.767741817864213 -8.315752587027795 -10.656212283361581 -6.360840664085033 -1.857736769763082 -1.4826907307878738 -0.44229249856680064 -3.0782399526065616 -2.596803120885009 -1.4606941088250172 -1.8161579318225949 -2.9216147968107786 -1.650504016147071 -1.7209023203965705 -1.2062578922488592 -1.2349069245221032 -0.6474081679014846 -0.8233979755255859 -1.0680739051828196 -0.7725845264783134 -1.140136380881425 -0.9001561815261022 -1.507617207074634 -3.3276433475152754 -4.54328824552827 -1.0853567170662861 -3.48996909669352 -3.53345289425155 -3.5241209884773883 -5.20910055151212 -9.73086226519076 -3.179350512305362 -4.7983564279734 -2.4064426255641287 -0.6511260500011462 -0.5238146766027824 -0.4153214275270176 -0.2828007101624139 -0.27794020114221074 -0.8550394896292416 -0.7253319320298787 -0.5397598987060288 -0.3137276128144222 -0.19637747304845188 -0.1535255130814358 -0.2554617901328375 -0.5486197714969299 -1.3642954258463615 -2.5795168122172707 -3.7438294602853475 -7.539207767345601 -4.850923307274329 -4.91800845863684 -8.347947841575975 -7.894499265590312 -11.88021036779996 -17.225984901812435 -17.145977994521452 -6.790121695242653 -8.295087998486219 -5.764955302334907 -4.865235982438659 -15.360910085011659 -21.32750621582484 -27.962787116634082 -7.424230937351939 -6.551268560941856 -3.883290959773632 -3.2789874193886868 -4.281260390300161 -3.3550736011316054 -3.4345855095624933 -2.419960076484918 -2.7180092330641497 -1.0937281755473443 -1.115429975367865 -0.6402205512557663 -1.4003505484200478 -1.645956665766187 -0.916979765089737 -1.2265449612143617 -1.6495132648079789 -1.441910159829518 -1.7210617835667794 -0.717891191394206 -0.6906883884797738 -1.0330389427070634 -2.1678131526664055 -2.851931601712513 -3.642074736056022 -3.7727137178666985 -6.138473011394107 -8.441843336965778 -10.63114816820454 -7.377386278658926 -13.617723625716227 -10.103801668410082 -6.544279842536024 -7.739919968360115 -4.903694808047201 -11.48681099776025 -10.712788549200807 -10.864132987641602 -2.817367002418937 -1.7530682840067064 -0.7348099064637896 -0.5504521502851376 -1.6416336967393674 -1.7014569195008757 -1.4147425255395334 -3.042968317709324 -2.306125832027019 -1.4951718530210047 -1.409708993360558 -1.545520080653836 -0.8369524220747728 -1.2982481776794461 -0.7724735615305393 -1.2941707879092141 -1.791176771093077 -1.042028555335623 -1.2142098388195066 -2.1755756612426023 -4.04176139622065 -2.148027366492962 -2.956878025265914 -3.685998762431407 -3.4034832498661074 -5.136092079407512 -7.196576129909837 -3.6365278059626074 -6.519092743265236 -2.3260003618256553 -0.7090851741026074 -0.4928808416900558 -0.5835635626514115 -0.261569057915187 -0.39913244817744414 -1.1887299561037177 -2.0146784394846744 -0.6039069082908359 -0.29151809276855717 -0.2532791473620788 -0.13706713835742704 -0.21464575255801535 -0.6501169258081161 -1.8946932347458973 -2.1265949733581477 -5.107379143592223 -9.520430549681906 -5.620627956120275 -5.967495898586707 -7.015470052242095 -6.250088726393989 -22.516260592280776 -20.986885265404002 -9.764365358407947 -5.2574791395857154 -4.5207080739289935 -5.120985876827616 -6.613328395541728 -17.07323992117589 -23.100561104141658 -36.73212778014345 -14.478168272270285 -5.403164859820738 -4.9168233167953455 -3.72700733082962 -2.8696250702192243 -3.9114786330135067 -8.935693346454137 -3.3767681487991643 -3.7722168841456023 -1.7099966934286206 -1.0893974598060638 -0.8620004406740859 -1.8961779173667466 -1.321903564538192 -0.9369827372387661 -1.218509242746721 -2.1765935450653964 -1.6309916885611215 -1.948287247063227 -0.7496873826360264 -0.7737471214645221 -1.187612987195436 -2.080004410318371 -2.3406141148428414 -2.4390816077666706 -2.9159795461811187 -3.484210208651492 -6.909061271165538 -11.935001425557147 -16.557530873393013 -12.165086051356141 -6.7490757891873345 -5.881030884069908 -4.844152077385771 -5.422518753235108 -7.968868415756088 -11.24168051563912 -4.475789013068734 -3.2772165919124014 -1.1336154737431139 -0.6759565757266173 -0.575778446730067 -1.276775401608629 -2.2874972570881105 -1.293146906340129 -2.6501287873636827 -2.0052167253992312 -1.4950504502259638 -1.173895195198146 -2.697286365244749 -1.0823307297115308 -0.9625798550548198 -0.7267211894032921 -1.188228394457505 -1.4645089613817193 -1.763582857330596 -1.1791804311393796 -2.187579836384808 -5.6149362032850405 -1.592112366756098 -1.6308408010098392 -2.1412332536663223 -2.03304587941774 -3.2984123356490094 -2.5961459550570942 -3.6382869588326296 -5.361862377296728 -3.5672577977463633 -1.6835309563667058 -0.49187545359124824 -0.6497850872703763 -0.32875795075313863 -0.3831414623529678 -0.9603625552873768 -1.6847959260462468 -0.46791316924202087 -0.2625918450515715 -0.19804924914599056 -0.16897772341163086 -0.19172030648590113 -0.8662314040864126 -2.0545834419601623 -2.3497988971614445 -2.5270093833038656 -5.872854128366278 -5.3521573971029 -6.943142504226976 -7.216858671145422 -7.07796178598663 -29.779321915056272 -20.62632119093386 -5.1495083807976005 -3.8867911967244386 -5.433750594328683 -4.275985969707677 -6.498873890990982 -21.313159682299137 -19.316366775203733 -24.609216043096442 -11.671405548549004 -8.312199644850276 -6.530198414406152 -4.566420939805765 -2.111280051743381 -2.838488308351419 -6.759083353995495 -3.103243257423091 -3.0294377396622356 -1.579052658777271 -0.9130295990214847 -0.8674411020145385 -2.329144313127486 -2.3599898988031276 -1.8622040543293539 -0.8984190719096276 -1.73717158531889 -1.0020908426405313 -2.379108123144116 -0.9428620439700213 -0.7905113968289638 -0.9914821734114323 -4.52596210008513 -2.586078246317355 -2.366551458944084 -3.556139022156111 -4.857585798802114 -7.009689779716246 -11.362472129485788 -14.019849175059557 -5.25044255297351 -5.503899923161123 -5.33140648818061 -6.4611515125810595 -5.624426828724347 -5.946064852492202 -12.634428356184124 -4.451555375907635 -1.0795274434182784 -1.1463621375135886 -0.6326666603100154 -0.7032694802078123 -0.9208969240512137 -1.0732467654386524 -0.7158326705288827 -1.674639121578664 -1.5488429438936513 -0.8662823119817045 -1.2356810955461264 -2.324619429862314 -1.9885834738797674 -0.894240315114667 -0.5138844221031047 -1.1360741603780384 -1.2020674035501795 -1.535250711685671 -1.2744359588425789 -1.5645748231912189 -4.681713267627877 -0.9415666927821469 -1.169782335748807 -1.4964836488782816 -1.5097281540104999 -3.653737910379951 -2.1851969162226155 -1.8793560724075347 -3.054901654854783 -3.6012527030293744 -1.2309914375686482 -0.9504161951868496 -0.49649441024815627 -0.3989368305235675 -0.6893260241095815 -0.8066755565609262 -1.398886573573742 -0.6008112375858317 -0.14682091240125153 -0.14340023946259917 -0.1739772621776082 -0.22350834827040375 -1.269535356063277 -2.1823998230821955 -3.038249178505868 -2.9578329613145726 -5.301362808498153 -3.753626346633016 -6.399291823830765 -9.788804746067328 -8.362449855193194 -11.955899340347122 -19.540691952616722 -4.821212767804263 -3.715564565114008 -4.042747379772246 -3.1546577500424737 -6.5801208235081665 -10.871301281583502 -15.783673494390062 -29.83969257323056 -13.112928693863063 -10.513388551485427 -10.731931132720966 -3.976132587056691 -1.7605870611821728 -3.9807740949046835 -6.825326093321704 -2.833953072059005 -4.187972119524895 -1.1275832553368996 -1.7678509927940906 -1.5261634278917242 -2.7943678331721973 -3.336272175415271 -2.0986328199631985 -0.8755092629805353 -1.478500584439258 -1.1649856118688096 -2.104354164786486 -1.0032033695483904 -0.9593257785843505 -1.0221874683927248 -3.006523900602561 -3.5540276628704977 -3.0894173230991937 -3.6242455525144526 -3.8953505123069148 -6.394066900508976 -8.605587035514928 -12.87086159126527 -13.838975822251566 -5.507376033877197 -3.5697230345471906 -5.127243192092138 -3.198411297069431 -4.308131225763425 -5.89866931173215 -3.285622109503302 -1.4537320195151782 -1.1175931124607645 -0.9333069545904679 -1.3937515392659776 -1.8119298273907738 -1.151626503389245 -1.1427970879597131 -1.120063216089273 -1.2777439011930427 -0.7655184962280427 -1.265052870146301 -1.9321761350526896 -1.773513467434915 -2.2511463817121804 -0.7382728999882446 -1.102159132412065 -0.9492274827644863 -1.2546026964475288 -2.446382455830425 -1.2855092422201213 -2.196096021973548 -1.5912252114302 -1.0216169766603482 -1.5962432353199603 -1.0004691666102676 -3.561747736375862 -3.243856716504319 -1.2974615048186415 -1.6923423885416462 -3.1145729183458535 -0.8120962196299597 -1.4324279822698809 -0.789933995618191 -0.39953338759188817 -1.0564317588378007 -1.083468399947775 -1.609213591127005 -0.5495144176341692 -0.16474579933254788 -0.16590098651422014 -0.20323204568429878 -0.2725141760422447 -1.047933301684948 -2.519796783436346 -2.144158958439166 -4.466884421766398 -3.083886604690757 -3.7796638008598764 -8.75879262104227 -9.90976543056792 -7.143506943514674 -7.686859412015405 -10.464194825884634 -4.9561453587061965 -4.274683174024345 -4.887652427196144 -2.9064313237277735 -4.335130754341598 -8.572460107865101 -27.50263458677062 -31.431662049926707 -16.358102101920533 -8.254031320829117 -12.33142220964664 -6.9817828931391395 -3.35640311786277 -4.185276904148529 -6.416002763976964 -3.266935530200821 -2.967233892392837 -1.9472449267667407 -1.319154098240527 -2.0051941491335317 -6.06903586039414 -2.7544785255215793 -3.3810263674130656 -0.8507281699450163 -1.2195118019586455 -1.116914197914427 -1.545694649869652 -0.7057431235100254 -1.1309865174987743 -0.9365998662862961 -2.6778160441363683 -2.409671440744892 -1.8386191630403919 -4.7650985747607875 -5.012942739204123 -3.9810940164259927 -5.050147783434897 -9.56940509023682 -14.853680770846609 -3.37310194288171 -3.5979633771203705 -6.174603394798967 -3.31729761057341 -2.810968806705053 -4.7714228253737145 -2.071194991345644 -1.4161847313527263 -1.276188491627613 -1.3347187865247823 -1.3652050340998325 -1.994817600237699 -1.30000679229374 -2.264188317637993 -2.40433461009781 -1.035284008370431 -0.8264263545614177 -1.4916867847693964 -3.5392469265669 -2.7257846185813293 -2.207642454595965 -1.4163443387414414 -1.0481869182542742 -0.9744397128216846 -0.9042497566698496 -2.772069463772739 -2.1870961460212093 -1.7648084018496546 -2.0883345605550403 -1.0932918818235997 -1.431877227704371 -0.7579718381597679 -1.7917865822490417 -3.6121897256533346 -1.1542007484927443 -1.441401046263788 -2.75527687527543 -1.0868775969823476 -0.8182043614793453 -0.6554682764910293 -0.6099318611995518 -1.2449475543060067 -0.9886156869760039 -2.0012605770636283 -0.6526579370486262 -0.16388571413903383 -0.20180682305693046 -0.2730735716811726 -0.4129374823134053 -0.8790126483023712 -2.2501207952652296 -1.7713336847766092 -3.8548296294581346 -5.280516385640577 -5.843748658176567 -10.509121499867984 -9.64553264057671 -9.1372707494441 -8.700240729653672 -16.84289773513349 -4.420209288693808 -2.929686422634876 -2.792121171783599 -2.9925333649835437 -4.873484682424452 -7.402926515822579 -18.196049806817207 -10.966309987174878 -19.57437328711188 -9.882746296337965 -13.552941197378034 -6.883506863239946 -7.154709358880149 -10.167667887403084 -4.409679562309447 -2.3873204622510844 -3.8101409054084723 -2.7987250406952637 -0.9839413431108981 -1.7606366742508084 -3.3848105639301886 -2.25531626054878 -2.4348608467377786 -1.3411182204918877 -1.6421444832458199 -1.645398661330765 -1.7694837648742174 -1.1246542299142113 -0.8119021688907728 -0.6520333889504119 -2.0536157390569754 -1.9644314311792062 -4.683080306981708 -4.201702334911948 -3.8965576545247274 -3.1451870129245325 -5.450176115814187 -4.962398963254012 -21.880648856117485 -3.749351041470661 -6.115140243337277 -4.392461244541332 -2.9679347021332885 -5.775170024842123 -2.034703502713266 -1.4194684554208143 -1.5878941249968073 -1.799212517259287 -1.5601460970653194 -1.7253769630356266 -3.7943423166829406 -2.683491396445872 -0.9603990895776505 -1.696233795343886 -3.2001431058423053 -1.267051589078773 -1.291805190532862 -4.801442807201173 -3.1123472245446187 -3.570184224597172 -1.824323986670206 -1.0058845780947112 -1.7415407978233084 -0.8083272575033548 -3.3038796743539742 -3.332760692549459 -1.5478469398594477 -1.9776100940900845 -1.1372572882320415 -1.2318361425475066 -0.5833002314567169 -0.9173657354992113 -3.2412011729203614 -1.3651932521449692 -1.5801443819394378 -2.2199252830162366 -1.6180727576829737 -1.8760915289461122 -0.7333456825711552 -0.6919167744937167 -0.8476415583147918 -0.8635825280548258 -1.8456144378826245 -0.7859344551478585 -0.24981882449830034 -0.3493449509068533 -0.38012772876224227 -0.3281711611138732 -0.814705955858051 -1.925001477986507 -3.2804678370691915 -2.7334429273763585 -4.433011394369328 -4.832485787599025 -5.779400189651446 -11.266772840990848 -6.894423742304543 -6.916063139197839 -8.64860576054406 -3.711261047810593 -2.324000732359487 -2.824248412540527 -3.905500213308678 -2.0489362326521787 -5.3715148386985065 -14.428559678940447 -17.492668387728266 -17.23328032967347 -21.993546707614364 -17.729226925764294 -8.992719063095443 -7.634114871495332 -10.691039488749952 -8.318755573049122 -2.1996569554444134 -2.736705972451869 -2.6183568995775786 -1.5457079519913999 -1.500941780203075 -3.324640490641099 -1.2050901894339234 -2.437089586124191 -1.4130498995630734 -1.7605816624309854 -1.3361686141722555 -1.2092332854568122 -1.7304742338394945 -2.135219789739921 -0.6702870670868053 -1.2030042680596003 -2.2039306506991165 -4.641829456577945 -4.183983962248329 -3.9872125713329685 -2.3145191067698594 -3.865885265697742 -4.22298578311131 -7.570834591670387 -2.7969972557466756 -5.294354403036359 -3.7932662862183055 -2.6644582362864253 -3.3350299120194737 -1.7112779426116436 -1.2306862734070154 -1.2479392997925756 -2.8786284294433244 -1.9548767415444885 -1.7459355255359694 -4.36084384986062 -3.5319056838439207 -1.3629338820480383 -2.1422581643945584 -2.9018459023138927 -3.985217189570986 -1.0439600957629471 -3.008571333143857 -1.7696173467206793 -2.4257100110400094 -3.3531349888762065 -1.6119733892505257 -1.717053133238092 -1.4300337374717387 -1.563946062167917 -2.0271639158727544 -1.5354331691232395 -2.260910723350392 -1.9999067386164506 -1.8340044414166927 -0.9749356455275576 -0.4392779636195976 -1.909351959254941 -1.9466791670197068 -1.3228921900957964 -1.5901339550050315 -1.8522519243013789 -2.1327030859019884 -1.4015282341340325 -0.6418698667540608 -1.1510354850868862 -1.6940579302678818 -1.441430096456315 -0.7469671346787083 -0.3027180594469527 -0.43743596587483824 -0.4455240916281086 -0.5223897564653435 -0.8417209541555083 -2.4598155272510036 -2.801268136865988 -2.7174959302323147 -3.334698810068602 -3.7757505291512152 -4.378243182585553 -7.325205427876212 -7.149611573893954 -6.3556814327698845 -9.139443290406561 -4.774294035371296 -3.0996678964144433 -3.9121338350835564 -2.5470639120539174 -1.4645008491813778 -5.332515669716228 -15.914688147303726 -11.627718225890485 -9.816681444551238 -10.286567241859567 -16.689769020040092 -7.590161786368694 -6.477500997894149 -10.722893991789029 -9.319565232716661 -2.748218646806359 -2.6293747845894435 -1.7471682849393173 -1.970549587815764 -1.1830594731524393 -2.703113900309647 -1.3657207360269397 -0.9543618485940659 -2.0591692307728016 -1.3551743433007026 -1.5816150701468803 -1.0772205118091784 -2.0084133588668127 -2.4420338431350053 -0.8167835383099734 -1.412355646894764 -1.9063121637348288 -3.9881126749421205 -5.469037817413178 -3.9952799562351915 -2.3299745741201083 -3.1439469989560602 -3.1062935332979382 -5.880344159756379 -3.8812225262668067 -3.538283065486641 -3.346495485180905 -2.1366120285629764 -1.9520017744328366 -1.425486648637604 -1.3507040080710353 -1.2429500601437524 -1.4706951764453127 -1.4838203755347068 -1.4764849302934786 -2.03804382683135 -2.7085551628254403 -3.8755780117846577 -4.024282990373001 -3.472247861930649 -4.087125283245642 -4.641135186112224 -4.119352847850037 -2.566589877186566 -3.8630935601087755 -4.380704438014715 -1.9578957360785516 -3.041233804995822 -1.5996542466201702 -1.1536899506456368 -1.1840905381303102 -1.5243234954011058 -3.10225404134237 -1.389136288472292 -1.947624803408232 -1.043029000045949 -0.4434198388099706 -1.2471538483982767 -1.5912627290383676 -1.343232828146118 -1.5502557281808658 -2.9121549272480887 -2.9602438563022475 -1.2877992765266815 -0.8430361463045101 -1.1640181984471534 -1.4287349232436757 -1.6801356480245326 -1.1287182433576037 -0.4552646234527535 -0.9482065604062504 -0.4385830824178046 -0.5259292747296872 -0.8795699729013391 -1.7602941449144176 -2.1978404731701797 -2.96259306730403 -2.3303550614375657 -2.1796193750830595 -3.4287320235051633 -5.359826334230363 -6.507647322792162 -7.637720397682128 -13.91493234351428 -5.84177025961698 -3.1070519688397154 -7.278595806233753 -3.9594148973866905 -1.390219224504334 -3.52888556883402 -11.74995025872599 -15.908995722993085 -10.319849187865758 -5.6534690384897015 -7.345871326253464 -8.12523119716045 -5.863536625099568 -6.242986440192965 -8.641646715258489 -3.2607406580648446 -2.1889300633268958 -2.1379872046363713 -1.6882870972421427 -1.08218715493958 -2.0965747164745716 -1.5303469873003885 -0.9775267310365762 -1.3557012058117712 -1.9266318138546201 -1.9737311026645952 -1.770563783925488 -1.6358755639895222 -2.690603861503994 -1.94728235835875 -2.838141098609387 -1.8246204381473534 -3.9620635053879645 -4.272561283155242 -2.2228639374366943 -1.590928160541482 -1.3898742963066424 -4.290150578227471 -3.0944954973437153 -3.0360934662681642 -3.73481924008967 -4.514344428187172 -3.487958883863884 -2.268636015677052 -1.6093947037727054 -1.3818388567607227 -1.2751491269789577 -1.3491352272892676 -1.3362670417170277 -1.829937781861335 -1.5627814035188334 -2.728776748628326 -3.503474120932625 -3.523153923495027 -2.1734226858868166 -2.019195619992682 -3.6859695982471616 -4.22087746103213 -3.8810915512481383 -3.091890201184814 -4.431346811563142 -2.127942325871402 -2.121412378297635 -1.0211953704627463 -1.136227713709855 -0.8617346075075938 -1.418482699623646 -2.790534106229679 -1.7424064060590019 -1.0386155798892787 -1.0132993742205374 -0.7953048065193901 -0.6265371566671326 -0.789911028345582 -1.1761534407480476 -1.172880473592403 -3.0070503556420483 -2.748512862026582 -2.017780193213067 -1.3979169654733474 -1.8068793667631469 -2.5307408151794037 -1.1803967281563996 -0.8864247023419463 -0.8449836800411793 -1.1228519754105626 -0.3628966156325152 -0.5589918003542247 -1.0026423489307272 -1.863749628728893 -1.6106495235628429 -2.904738898223536 -2.7024256371151965 -2.651758926792188 -3.2662336422612164 -4.393490492856703 -3.7282144112224906 -6.746233233919289 -14.423945967561313 -4.902665643037363 -3.8984402661451036 -5.7060089468430375 -4.5260085227986915 -1.4058304785532045 -2.03867449801246 -7.177847312772452 -5.678688769602045 -5.156333882097475 -3.7743021320760155 -5.792561761075708 -11.415615079331975 -5.449330511820507 -7.228127480499177 -6.586301331634405 -2.8826317894719584 -2.8788801425191606 -2.470607781406827 -2.4415516247512947 -1.2213397285055922 -1.5920913605807177 -2.008902908017603 -1.0427262104793171 -1.8310164051133728 -1.5841409868561356 -3.0437481623510396 -1.6808500884504196 -2.0090062510580178 -2.2460642248235816 -2.757787041898073 -2.5968482931218015 -2.507793779869221 -3.0301224321188434 -3.9669188216020954 -1.7255839542063953 -1.7485048790887503 -1.5128206789708725 -3.87188459102163 -2.4650943939869316 -2.975519876337028 -3.6171856426983986 -4.535943792370364 -3.3059034003686936 -3.421884193729642 -2.24558330540949 -2.347627685317123 -1.7099394988934702 -2.226554674023891 -3.0816759583013873 -2.780813142903295 -1.3063280155826882 -1.8825534884197461 -3.8388014721354775 -2.0589762964486718 -3.510668501164923 -2.842569648999987 -4.6133406030151 -2.4075214322509733 -3.8593591969683887 -3.3125169415426616 -5.895612331424823 -3.7294736727009794 -2.1003617328200326 -0.9769017151156343 -1.8991120480832244 -0.753617107101251 -1.6154823895783446 -2.22614981274716 -1.3031245792372639 -0.8255080842999071 -0.8051412161957874 -0.606455534078109 -0.6763927804802982 -0.5551055611724267 -0.7872242800034799 -2.32440057589847 -3.5270244915207623 -2.305911288314621 -3.188599554638841 -2.1849607174155086 -2.38348213840877 -2.2481654909818034 -0.8749317265368938 -1.271661755555433 -0.9793201965341245 -1.0569017258207298 -0.7152158332151605 -0.6582384951727746 -0.6035194715569973 -1.6252850607115292 -1.4744980243873624 -2.6232820679779834 -2.444327494048403 -2.2286214545085654 -2.6515828669791413 -3.4117150288923135 -3.8737311751781776 -5.044025993687462 -6.187100224087788 -3.709730572865474 -4.3189391023668176 -7.504702126089687 -2.6093177264140968 -0.7829079692709331 -2.1327632203837683 -5.3565801209899675 -5.46408949813206 -5.747833672647635 -4.743898746725504 -5.108309616514623 -4.550785798761785 -6.5198729662686015 -6.898554916648426 -4.728651840114831 -2.9313478343039954 -1.8975549110655383 -4.049408126996285 -2.4663278976138283 -1.5432745395087701 -0.9724810002197933 -1.883534833730123 -1.9136889660344574 -2.0259540141399786 -2.510280628080927 -3.062194356314423 -1.7300401591668388 -2.1648022083182767 -2.4058549484531975 -2.5425216101176193 -4.015508833876343 -2.6945562517282267 -1.5811640084279028 -2.1247773252897475 -0.6044555055243025 -1.5083619721348476 -1.2837732022465047 -2.814219445331052 -3.144245934418462 -3.0476736474422093 -3.284994321653071 -5.491469382899524 -2.7388908363498725 -2.460416028159715 -2.3446118367565645 -2.5440667486245614 -2.4130481384752027 -4.795926613874112 -5.610989550378109 -2.935939379398618 -1.9564544980929488 -2.6831211448826076 -3.4638611606505294 -3.7377025946863975 -3.339705841120371 -3.8278201924992863 -3.76485734299047 -3.397434871368859 -3.077747448652519 -5.575171588363606 -3.876269437694012 -2.8614291561047476 -2.9190366757871202 -0.8547125851382467 -1.9461269364362481 -1.8940127480576612 -1.4077792255637323 -1.3052646483966945 -0.9569287961590686 -1.0566613553956865 -1.633497935873826 -0.7849683962115308 -0.47615668783332393 -0.6273354281785939 -0.7176258753036326 -2.5557217045963556 -2.61866123479219 -2.219833115319287 -2.7691794210392136 -3.0311561001419443 -1.8105196820264793 -2.4254080225010943 -1.541096542045103 -1.0158691975388663 -0.9024324542323355 -0.6429541859554644 -0.6731772830954386 -0.5571809652783478 -0.48530924703996636 -0.8118176636870817 -1.889551753110049 -2.2629698675487164 -2.7332097812668263 -2.5656008971319126 -3.287765423884296 -5.141144382292081 -2.3023681383502153 -5.193989567539604 -4.824798429641828 -4.755078789066073 -3.1817424211324132 -6.856025086660281 -1.9674463270354903 -0.7028116217323707 -1.5398719779580654 -5.673122471897622 -5.311633076956483 -4.922098543174002 -8.025782873046436 -9.429373349398206 -4.641606875463034 -7.00467517394367 -6.082327821925443 -5.424887817492637 -2.8869071134276325 -1.7345781856170144 -1.966319929573835 -2.060949073301614 -1.391336702963143 -1.0244910513987575 -1.2030434803008216 -1.6355676735937328 -2.158069313773331 -2.6620183139014153 -2.1700330692783565 -0.9915037940094831 -1.9915139884000352 -2.407950521957144 -2.58716260203016 -3.646457201046748 -4.282687395170116 -1.8073558342085143 -1.7220481620187813 -0.6911697886963237 -1.618618884499895 -1.1397299874958207 -2.2942327362620683 -3.317904666301108 -2.580661963008855 -4.476892548711874 -8.382181169439322 -2.9401940365473562 -1.8305902861740302 -2.0378369378368966 -3.475775485731754 -3.4226096116222253 -7.780495066251723 -7.206156305756006 -4.598784761556934 -1.9719279695410281 -1.5273892734675822 -2.8191487310184784 -3.72846195359168 -3.3618517682764972 -3.136815797543157 -2.463898364827506 -3.2860913874984807 -2.5587066774861826 -4.931178196573177 -6.901992289214891 -2.077255607696074 -2.2485893372257424 -0.8868372025202506 -0.969035639503475 -1.984056527247741 -1.6346114161821972 -0.9024470333822 -1.1597262140873839 -1.9244525499353096 -1.0746534352666877 -0.7226150460990707 -0.4408371009400586 -0.3953298639219817 -0.5863509264023247 -1.9794348580226602 -3.0316751457764877 -1.189259812782167 -1.7180979369086027 -2.711468699489911 -1.6671566084901224 -2.1756179581124133 -1.57276961530576 -1.7127826203654937 -1.5124792674603331 -0.5957386169756878 -0.8132128547114976 -0.793655057743109 -0.7107255434396951 -0.9714837614525805 -1.5960548334208364 -4.393884186253196 -6.288613589621108 -2.420512056536489 -2.3829544327276335 -3.142291396683076 -2.9113005668662324 -7.269641095382834 -8.634217181393113 -4.604047353298433 -5.898686043824728 -4.105404929724192 -1.5216079337524622 -1.185276714804926 -1.6216157164024336 -4.907306734854733 -4.222625096073001 -4.64476957821903 -7.718826424308783 -8.3044711721888 -3.2103614288024866 -6.887104608548804 -5.531137938227039 -6.300936239108606 -2.0279279928184657 -1.359327238010011 -3.6690913770977938 -2.665519274924283 -0.9471905523420788 -1.0217041608434214 -1.4219343747108206 -2.909561013795676 -2.8316005007626517 -2.360402383896469 -1.3522650329136874 -1.2024890119918035 -1.2605951401785016 -1.400377187068203 -2.105211157993899 -4.038289004325674 -3.533863468705675 -1.162262902624298 -1.4195584990135266 -0.6152246031785655 -1.4512118100175253 -1.2388650888731856 -1.481673160682153 -2.0141706964359063 -3.482314593722155 -5.507290002631111 -6.930997501481372 -3.6400544411982447 -1.5713852986744732 -3.0755534692341477 -4.838473441333061 -5.217239686158998 -7.455773225602312 -6.0470913419926084 -3.284981912700043 -3.7569091354556705 -2.0142651666501816 -2.2972074483716853 -7.725398960870648 -6.763857980375727 -3.4522334896879774 -4.297745892430388 -2.7991447499887676 -2.5296417959730007 -6.371415301610358 -7.899826927228899 -7.758114781613032 -2.256633501076134 -0.7052507679015211 -0.7479011589842309 -1.262582257382351 -2.064796634769709 -1.2512274262697873 -2.0471875213160007 -2.2450310665797515 -1.5175378345578923 -0.48280707246380367 -0.44493764410122427 -0.526369883966328 -0.7040208716926535 -2.239656306387228 -2.053832431682352 -2.6353694023469174 -1.1136829618830575 -1.7576283058624642 -2.3336044882508413 -3.683919078905514 -3.0264968035485618 -2.0075199998680766 -1.1224834978888067 -0.6676780198343926 -0.7746151298804429 -0.9488604705554468 -0.8064661355524416 -1.2491183574475966 -3.0719920032772725 -2.4231779749654248 -5.949713086085061 -2.0511688549272122 -2.7714314372421684 -3.2900348965535375 -3.2114980801308497 -8.171100731406801 -6.0811965786658195 -4.540510393314057 -5.396403683526004 -3.589450757975333 -1.594504328226346 -1.1678197426250498 -1.4551354117315938 -4.009677597320854 -3.182641731995499 -4.8755912770274 -8.090648079016873 -11.142577885893685 -4.3478178650242585 -7.8613191892493015 -3.913697013778208 -3.9432494188327443 -3.2807149284945822 -1.844048842113351 -5.324623945755538 -1.9601512365442018 -1.431540764846666 -2.016495201962504 -1.6144356338093975 -3.6584793360940915 -3.5130332195085576 -3.5383798322703046 -1.5230963860826128 -1.3633214298988316 -2.27740945721014 -1.8518623324016081 -2.592041736508499 -5.6782733005879935 -2.3874557909748946 -1.357552426632854 -0.7541309267212213 -0.5807762085993738 -0.6832675020359877 -0.857858443948575 -2.487709793382276 -1.924746339113535 -3.31114838257873 -6.493901677518508 -5.510710254195789 -1.7033151482830768 -2.2333153366575464 -2.79612271884098 -6.236146226568033 -6.596082312698583 -6.156593592685824 -5.832350505277733 -4.899250103437023 -5.625793639246961 -1.5434608813419028 -1.9928488586470403 -7.553949938344149 -7.782345257550658 -3.8056494021206726 -3.3633369155162947 -4.264747202710666 -3.510809945256562 -4.549841539153158 -8.863269278276295 -7.241290550509491 -3.457055698460699 -0.7379230806517835 -0.7370029675479208 -1.5722618822923191 -1.7320279740304954 -1.6768213700397914 -2.0349658799617356 -2.839764847043687 -2.434906056696674 -0.5219683704276228 -0.4611389302007694 -0.3618651534067393 -1.2710100704664569 -1.0643382028417683 -1.2152622314915713 -3.515646300989658 -1.120844941506295 -2.3143095349689906 -2.8163757799311333 -4.612179029598811 -3.2699035496248596 -1.6970856787443758 -1.4508913696375436 -1.1451438000788585 -0.8546485233389808 -1.938648870767065 -2.1531495389845277 -0.967409617357612 -3.4874329687405066 -2.4202853271971034 -4.709354782746454 -1.9049539085603757 -2.16945678415431 -1.2410993551849139 -3.2360024226126995 -6.62107358969622 -11.936424009477959 -8.168714218724478 -4.282344515776364 -3.451685194483821 -1.5037936439836674 -1.0200694787328692 -1.3108509688833836 -4.6235320230083525 -2.2953190652746214 -4.471464005080597 -8.483594612303001 -6.779367073296267 -3.6019427988690023 -10.83695380072779 -6.6703657137284615 -4.580530734660112 -4.5587808133588075 -2.7938083563593388 -5.010301026100086 -2.236116165416519 -1.6534387391474155 -2.9965159943850432 -2.0230660484055667 -4.335540519559516 -2.4782026849932812 -1.9513074516504503 -1.326625065222754 -0.8773863148626945 -1.8621994143875473 -2.2578023037580803 -4.700888429876425 -6.999736357872487 -2.492147105555022 -1.6601268653636447 -0.9345019389655886 -0.5678410349046126 -0.7128042048225574 -0.49966899808032983 -2.078018712457827 -2.5280458628614824 -3.694806384959175 -6.042233284566847 -3.4979311105367863 -1.773091121245753 -1.816253171669304 -3.056409753340723 -7.02135767338315 -5.268655254581645 -5.998324836313361 -11.22749894207509 -6.1655213978203705 -4.985343568271573 -2.7848301844388725 -3.6707694545754244 -5.679826224163122 -10.086405956971596 -6.373499293828793 -4.766864780220388 -3.0827478630227736 -2.3724019870824353 -2.8623889791620583 -3.9522772539719244 -11.721450632651257 -3.418860652290323 -4.839490048921353 -0.7127226979549643 -1.4561950291329597 -2.5590595656769484 -2.198160680948482 -1.151446231255119 -3.018215996381313 -1.4144077302841311 -0.6261435544353361 -0.6165709055217248 -0.3412810362256753 -0.7111930779281855 -0.7575245165495961 -1.300943237220703 -1.9647035462926175 -1.360880135530333 -1.8443416737119476 -3.1323088617546158 -4.1820102479375265 -3.0615647721554398 -2.154375912614175 -1.5916074931349262 -2.0502053220800995 -1.1146755284023908 -1.8261942867856393 -2.085318475770565 -1.4640414832251856 -2.793734120128064 -3.0763280708794234 -5.474604199256736 -2.340404527339076 -2.1178708810513887 -1.5048498727300823 -2.5064528927620287 -9.05969620289082 -9.745058270539774 -7.642034199849282 -7.059015553098782 -3.3657412972556293 -2.238878248073363 -1.5753451586908853 -1.250050529201689 -2.8830081313379727 -2.4059841930955415 -3.068939553558449 -5.674524917656028 -6.612260176760428 -7.183427835514221 -10.973911922507682 -8.9958577931225 -8.530029277306161 -7.400480766883002 -4.9785897337433 -8.908278258920065 -2.385926876898398 -2.2404176914551193 -1.599030473039643 -1.8510059002021064 -4.37774041351153 -2.3635396830659867 -2.0463567228360433 -1.591512178456062 -1.0535874091898179 -2.9619364897480596 -2.8807583783659805 -7.712195345675105 -5.032383998539439 -3.828535773888443 -1.942213135192152 -0.8177578827512452 -0.723644481023816 -0.5642714728135996 -0.5548693464288647 -1.3081553226262506 -1.9405126196260065 -3.082360925527913 -3.7167608830918457 -2.7984586120354593 -1.5761351610923355 -2.2347170971143027 -3.9722444459266977 -9.476922319586361 -6.301093498817773 -6.067656298618779 -9.29101501869595 -4.405966062586523 -3.7079928342078787 -4.049039659439556 -4.53447962135387 -9.256249961951816 -6.654617860074968 -8.035784073336838 -6.187776454112512 -3.0347882499346865 -2.6463700186467296 -3.3858120498227295 -3.273370486629555 -8.493294940591072 -2.6590844037361934 -2.5361321867419013 -3.4082778920243695 -0.8562436338516051 -2.323390751422297 -2.1401867597910402 -0.8363102776098452 -2.2314824603837247 -1.5875232562544908 -0.6506281939728367 -0.6126594779804639 -0.5715837690046907 -0.48181760851736655 -0.6595282663086879 -1.8254716895935243 -1.7465660748032434 -2.043950333869519 -1.5383133042228514 -3.123839678160781 -4.150027042496471 -2.973799643371457 -3.8381778449789543 -3.7981074686539134 -3.752266319263797 -2.5416452768710256 -3.140909127999996 -1.9498608194584317 -2.306797094985878 -4.241305808657814 -5.06763811794678 -4.137240594890599 -3.109153263932746 -2.6434175563102884 -2.2284427758900804 -2.1778297863908747 -7.634121411239339 -6.225292059217574 -7.293080225513859 -7.996949726691301 -3.807815198544074 -2.516495766907835 -2.3027478960391883 -0.8667079165167619 -2.407632761706193 -2.2470207011433434 -1.5409651757349876 -4.382741374952101 -9.883139999697246 -9.41067060589949 -15.026593088522267 -9.174958440539244 -9.888911636588997 -9.896357706830788 -7.3912482257592735 -10.6178275477949 -4.994778881369133 -3.111341738259873 -1.8125309344918248 -3.8733258038019165 -4.158237951516942 -2.900729274070517 -1.827603566801046 -2.3266019693107407 -2.209024520755388 -3.9823766301090058 -4.091942469667431 -3.9503017319390104 -3.820097974648527 -3.6141975103672204 -2.619090391309167 -1.667185057974512 -0.6847129970329926 -0.5430417535497516 -1.2554016296861386 -1.0093845879320507 -1.3061848962077727 -2.6192343975820247 -2.2854241122023833 -1.824385109516383 -1.6004993367018163 -2.4955998289956325 -3.066064005630135 -11.37405904652963 -12.657512219623651 -6.2796553243993225 -5.667929403219697 -6.716411908300483 -3.053627033518126 -6.191084515603276 -5.820225058264674 -8.50215884735713 -6.21937869335715 -6.393735170805755 -4.027329514386111 -2.984573208082841 -3.1447661933070292 -3.8607882480749467 -6.301549324711725 -9.17949490349131 -3.220203842525909 -2.841555552405083 -2.121058057760739 -4.139024080772804 -1.656721968651425 -1.8707714882477053 -0.9201447761050312 -2.5150314747398217 -1.9407718050342198 -1.2342828478746437 -0.8492905158894339 -0.679547562603474 -0.8157962215571097 -0.5772282014220215 -1.5619353446528106 -2.2031495842029614 -2.268837767602695 -1.446597184718736 -3.6841001243505294 -4.774780631172373 -3.713626735153211 -5.275256390483019 -2.459423991321088 -4.791100182565822 -3.6956390728652004 -3.6673156645841445 -1.8523402172010108 -2.5923098444480708 -3.1560321256894106 -6.781295855061861 -4.059203285583241 -5.445413891141595 -2.266585524872968 -1.7919208459660618 -2.728565669586737 -6.689623768595608 -4.210487622436832 -4.81389977270274 -6.881225537704669 -2.53356587329974 -1.8407612574814873 -2.2792092606159375 -0.884767854831388 -1.3881926591418574 -2.030011673771438 -1.5106963267777815 -3.9910136215550294 -15.746593467605143 -8.129388124437666 -20.762459071478595 -13.352154204604407 -13.006064865634835 -12.023258426565263 -10.740082446843743 -15.036552227518946 -6.6420706276422905 -2.9822072449967316 -2.600670950590335 -3.142592522417464 -5.639118460298913 -4.039336173168149 -2.4293276401814268 -3.394186771361296 -3.9061497914974304 -3.516354413936442 -2.9414178485207017 -4.023214245524386 -3.3746145719144787 -5.9413261936187 -2.304334937133592 -2.2880408575348916 -1.272496880105707 -0.7120143329701325 -1.249173773574368 -1.230545049173571 -1.219836011118693 -2.005486242456361 -2.047765888906083 -1.5789889274180258 -1.8004305220221055 -3.1394090837791806 -4.676407460700444 -10.564006632085263 -12.864822319173433 -5.923502565122615 -3.990306675430906 -9.939516125805469 -3.5726622575562437 -8.450454917384052 -8.822417502894828 -4.785502090521399 -7.0368076658254175 -3.0298847103153967 -3.2566367528816236 -3.9637059802611896 -4.320892187996689 -5.362922899867475 -5.673927521564166 -10.730337121924023 -3.258104924274056 -2.1584515115771574 -1.8398501432392909 -4.515689946748048 -2.658137567198069 -1.2304385450716564 -0.7951452675238654 -1.7790453275845952 -3.013621656240973 -1.08427794495013 -1.0620673955304045 -1.2942175149201025 -1.1945225456895885 -1.1151688321110491 -1.5912440106110843 -1.4404117803003749 -2.660463182809227 -2.6061485875307273 -2.1285474803781907 -4.723661145466475 -3.662277286336025 -6.7568822725282605 -5.860882493241101 -5.081099458616486 -3.952725457295228 -3.382270662121827 -2.4256982606552904 -1.9611114574302686 -2.7547819067230983 -6.388546222444892 -5.08602303355227 -3.981234022037844 -3.918521902794497 -2.3193877260484226 -1.787988439399069 -3.188777561329036 -4.485449984065722 -3.0767060033593525 -3.647142880155348 -3.5946518702069836 -1.809037143469174 -1.3731259006831498 -0.5623253094834832 -0.8089188031990531 -1.373280986524882 -1.491727361926496 -2.974178231070698 -8.228318537411543 -7.865412993180208 -25.01407078988928 -22.03497300814717 -16.350555214675868 -15.534799478029868 -10.931701426681885 -21.013538744962183 -7.920791380573641 -6.016966312750562 -3.027332218978927 -4.535329711991752 -6.254317397932627 -4.676646243459245 -3.141149401572349 -2.925136226305535 -6.272865260562193 -3.240457308232737 -5.481348355481766 -3.8211705364657993 -3.585184747765493 -5.425521663700405 -2.85790620503347 -1.6093142150801039 -2.113909783855567 -0.9353728146507808 -1.3301313064090787 -1.5248827110804741 -1.6480863619696466 -1.1285552709363458 -1.213400676657023 -1.332015975086068 -2.1269437593144156 -3.7146697091814125 -2.760324647533014 -8.005300657515622 -7.4550487636209475 -3.0695291514908676 -2.6801873418653153 -6.611683603061789 -7.1711811926488 -6.5990358600571 -6.742568734004828 -6.866256548474698 -8.710342601702033 -2.5267757394434813 -2.144417298317013 -3.7486904319451466 -3.2821515775304486 -5.417092605259094 -5.5028990101241035 -8.638260575129673 -3.618530440608847 -2.338448472980318 -1.7348006205416238 -1.872814908380665 -1.9996287101264145 -2.7487463241099195 -1.5701473191810886 -1.9598932289167952 -3.234543475466631 -1.2477862536879787 -1.1349038460348144 -1.0825289043179651 -1.2584962940372766 -1.1259779473394116 -1.357942835889225 -1.3997287486539507 -2.1359453317830117 -3.665779776607481 -3.6575972806580865 -4.073465766627077 -8.302115214276725 -9.122007286984516 -7.6938615734860285 -8.5357708352383 -6.185425778953031 -2.2086005083391376 -1.978670366626951 -2.0704473452331618 -4.385707735005806 -5.608151612264925 -3.801670045172847 -7.102762837819584 -4.560250148669702 -4.415993039725568 -1.7907233550758037 -2.7456565429490634 -3.1849630689449575 -2.2164468064101546 -3.315935214188391 -3.0627488613647986 -1.0799105544280694 -0.4721425129536854 -0.6410550979014055 -0.8568877084899817 -1.068800099966478 -2.2555366647895427 -1.9451408907656624 -3.456929584387572 -7.100785900064998 -19.95095463300262 -25.406007184514447 -22.890357507305076 -20.82729902827842 -21.732405750219765 -22.619570303052296 -7.878171981690324 -6.584610412722578 -3.6342574634148703 -3.9185560195446194 -6.133222591411113 -5.0628042813132215 -2.9965356895737063 -3.43704811061481 -6.064102237608432 -3.4741316677896283 -4.045509798383365 -2.6189838988806837 -3.8293171976304423 -4.0952032398536895 -2.9843286517267913 -1.5883921083810568 -1.7238552447563569 -1.1925348211615499 -0.8246161295248036 -1.3402927088404255 -1.5571427261403297 -1.239023561407608 -0.611879110967445 -0.964743319621745 -2.286759901135513 -2.685258623600458 -3.7173934067946557 -3.265001074598153 -5.438710961517032 -5.102801703163054 -4.435917397968346 -6.323732853469602 -10.05791283832094 -6.251566709382691 -6.741381470448226 -6.69679984687551 -5.2045228865284265 -2.772590317485756 -2.148132934401742 -3.0111558812618333 -3.9837898331859516 -3.2025005290515436 -4.470450912823724 -13.277476029283614 -3.475605995202575 -2.6049568591203407 -1.4709298163547284 -1.2631664409802206 -1.4222202977912786 -2.094006799808542 -5.228791356341216 -1.8758047912808156 -3.1745835252550947 -2.3722620753985737 -1.1960324192548948 -1.7845414348181254 -2.813172982193982 -1.3263605982196944 -1.311814045113515 -1.1479056463867459 -1.5238489781562798 -4.633937820158498 -5.269787356030972 -3.443244674096775 -7.916204304221458 -5.669338846384263 -9.300816630721316 -9.711294953408109 -7.4809400244391595 -2.9025475962671736 -1.6661377740954477 -1.8386863243934688 -5.824070561544881 -5.759626505907345 -4.0691753474483665 -4.0217262252082095 -6.834069950184906 -5.0731346569426865 -2.294281869937102 -1.53167754160756 -3.585513444754727 -2.377699409917504 -2.3231604393040066 -2.4823003096352365 -0.9362893801499036 -0.8606402342798769 -0.7417468178823574 -0.7412688523336406 -1.193695706217972 -1.056256114463237 -2.653699952408096 -2.3104799971178975 -4.519176442413337 -14.215410464262622 -22.092525036540234 -30.092106981336837 -23.496446686135954 -36.68335511140618 -26.31444868076842 -9.703968954851659 -8.021234868236643 -4.381278589813171 -3.3742760591982064 -3.3782210299310935 -3.9509778899789887 -3.5221111455422247 -4.979364703528726 -12.48379174213477 -3.8619607758589893 -6.285930176509103 -5.022821668983524 -2.9050157835858887 -2.6185242804879914 -2.860053378191965 -1.9613035249722268 -1.9005579649888231 -1.332881393978224 -0.8677408213856833 -0.9874200052585076 -1.7405541355595124 -1.3981146285912704 -1.266492503839965 -1.6669677395283393 -1.654297771332877 -2.2054118565513057 -1.4352617327035977 -2.9848406384084645 -5.284104179401419 -4.327514671799728 -4.618086207521797 -6.972896560340819 -11.738561700347415 -9.903554859488718 -10.024344703773586 -11.022275115907362 -5.586572352116214 -1.7402032870246726 -2.608874478448191 -2.8619821648340187 -3.15094433207549 -3.60096950816418 -5.169977747582646 -8.640195581694543 -3.7493654585780356 -3.1658675504364084 -2.6371241158491188 -1.3501351633133893 -1.4845354206447867 -2.74068700436761 -4.091447380441558 -8.034463716974217 -2.372161246975853 -2.746399074694769 -1.0228685301588254 -2.446932588819705 -4.122027405447531 -1.1356113115442033 -1.1697311469379132 -1.676490164347403 -1.4679308895243686 -6.273126159413823 -6.342338603112701 -3.7721060244045406 -5.6535662651625636 -6.291996800439352 -14.611124344981686 -8.593667797969356 -10.222507729913682 -5.227706217582437 -3.60436357974746 -3.4422374577264776 -5.38119800794584 -6.110961028978092 -5.919137891821016 -6.730875485146238 -7.09248028020957 -8.295003447155437 -4.599691396808711 -3.4103207339419255 -5.140211526171218 -2.521696896016808 -2.5855555183854997 -2.422271007325331 -0.8430023335587519 -1.178983190123338 -0.7409085301460949 -0.809430185546688 -1.421921148663434 -1.56367614110757 -2.512701726995209 -3.172757141860857 -9.382871820719203 -17.897707259517194 -20.626150153630835 -28.859340666419744 -19.825913971815137 -25.481823967522615 -28.1810143674817 -9.344461331178751 -5.450047373597956 -4.052539002500715 -4.606579634924123 -2.866337490537791 -4.536726391830339 -3.4930204246734196 -3.3017563920493913 -7.9858735992999055 -7.471187339497024 -5.758014849915399 -4.315488945946666 -3.2651534009664513 -2.845617851122983 -3.163820266639586 -1.4269849542838438 -1.5567749544115517 -1.420119485208963 -0.6105268501970477 -0.6435110431829236 -1.6167471555578228 -1.83405083878511 -0.769395379212353 -1.136841260046634 -1.3328198866778627 -1.6442865141068617 -2.481958356422896 -2.3771474338606344 -2.97997897921915 -2.6739159725905126 -5.730681887207765 -6.125892519612462 -9.40900502217891 -11.59165306881821 -8.999280684624173 -7.192749630077806 -4.608119976282317 -1.8942665907666942 -3.332045626613911 -2.491686455434055 -5.125293567953708 -3.497217984982202 -4.830053839526861 -6.612154352198308 -4.2854611835239576 -4.30403520574294 -2.402674665829152 -1.4305197829334297 -1.3960034507152332 -2.182430622839534 -2.714981033239464 -8.719222160881657 -3.748608345834354 -3.3161451744233688 -2.95280909020469 -3.261692999909507 -4.023800221351019 -0.6066478040850465 -1.3728484100027842 -0.9863045670391185 -1.123720294468661 -5.7766805169166195 -6.776550952251349 -4.731587705358074 -6.771278275515114 -8.431664172796951 -22.491693657644777 -12.395368208852464 -11.893475993517248 -7.079989802245876 -4.847881258974193 -2.9787043932663866 -3.801216165557222 -11.510798756997998 -9.285044786077785 -4.706053482948178 -8.412072228974214 -14.265405329975708 -4.905265609337385 -2.615878673508001 -4.34201976305263 -3.590573556498323 -2.4401432937924805 -2.499218513735247 -1.059298118295881 -1.0517431483885589 -0.593801530279973 -0.5929556206391982 -2.213441839250006 -2.419571244036549 -2.259631291755751 -3.1690741431289777 -8.26423735537299 -20.38813499019595 -19.404871670920652 -17.05692650674395 -13.461244260818484 -32.757479473324416 -22.341340745986596 -13.379054533553486 -7.723534696573481 -9.473105862205044 -6.9109068899651 -4.325334392230605 -3.381856974415952 -2.3051846424506275 -4.090604324085265 -7.3515591151947515 -7.710076843674528 -6.211249781747854 -4.670328249000173 -3.911939380871808 -3.1821473445511193 -1.9718258334084517 -1.070107769778456 -1.346986065535797 -1.1968566462359507 -0.5628145366871166 -1.0551298242801308 -1.017907026738066 -1.3038057397658398 -0.9537145866565966 -1.1945324905597408 -1.3139504255224745 -1.5321876273578974 -2.1272269497064116 -1.6879677562358386 -2.3837394358748374 -3.124518165027934 -5.034246328274515 -3.6145764716144644 -9.109873245094416 -12.214572282798205 -8.666151616285651 -6.890313424169528 -3.60914426785955 -3.206914956763538 -3.962731546555559 -3.5036723261811975 -9.042741421703994 -5.596755701065551 -3.1750761879689375 -6.2859579461414485 -4.183131973064248 -2.912599115365938 -2.2429409522603034 -1.753263352280367 -1.0901609978408777 -1.269789391791925 -5.1365690334620595 -4.585564138454346 -3.199959163490274 -6.627466579819749 -3.6652112775748966 -1.810984888909853 -2.248502784234478 -1.7458686012201496 -0.9455941320497365 -1.1264213423061356 -2.2601349901258083 -4.084656241954934 -3.9568719669958385 -4.166112302622815 -3.6614545118236768 -6.532175410253021 -24.621928545633654 -21.751182580033912 -11.054497592025424 -14.946463634094679 -5.7364658416255505 -3.680702514556351 -5.366179604381143 -12.354012884217516 -11.182690505375934 -5.732504719634853 -8.496207528979642 -10.513629168108627 -3.9745266107794466 -3.891749658154821 -4.488851861851063 -3.0696618339945543 -1.9679745191176727 -2.819736597817898 -1.1675878767507528 -0.5395382519210886 -0.4964209858586847 -0.6629748219856089 -1.6974670519422408 -1.9872615806935023 -3.3941968925425328 -3.265374665204864 -9.008869952019557 -15.542949547323811 -16.003730815511133 -18.210479503693776 -23.822523899022425 -28.01991884613539 -17.11408020086844 -14.20530865327132 -10.8934669094591 -17.46789793956717 -7.046596419462988 -5.881160831589838 -3.1787370452985866 -2.1250767351277684 -2.6042659917134743 -6.4527874909332725 -13.126223420126632 -5.986161850636754 -5.70255694750192 -4.358340886203452 -4.443807344602408 -2.359307783719256 -0.9468609095150416 -1.699663632560937 -1.1743541935457127 -0.6242671312880412 -0.8288116849703928 -1.6291608983226051 -1.4324471806944292 -1.0145187420922006 -0.8259389791626613 -1.2013863946933137 -0.753675993911406 -2.0511572530526845 -1.1718097051157192 -1.5348701223205838 -2.626272626050159 -3.5221242916925055 -2.607096460899245 -7.28428644208867 -5.789159690965877 -7.619688252638728 -4.769742587994534 -4.2977549403518385 -1.850955801342229 -8.188535476038973 -5.475434149183342 -8.539784550201015 -9.43271080794028 -2.932499080519721 -6.346049430672101 -3.658478879059889 -2.26146706984849 -1.5618407203924303 -1.9388324982845366 -0.9104180353452789 -1.4967052367160194 -3.319037644172026 -5.339886552249775 -3.804358133311591 -3.0420097709040723 -2.976206533407785 -2.4162956233871746 -1.8770691007798685 -2.9016189309525195 -1.6764604709834765 -1.7415019499167095 -3.0262998892208715 -2.195665019919263 -4.392827469975716 -3.7640946122615535 -3.665677993541464 -8.951429214109577 -19.39819208675478 -14.362288744842166 -12.795061307940209 -16.065092618672775 -12.051772427606432 -3.8628767821004284 -6.210110984275387 -7.815305642507784 -14.922603456145453 -7.9500593440999765 -11.212780132316633 -13.096838319868855 -4.0190877643329745 -6.611103074802309 -4.758947972195548 -4.11192800325264 -3.309656998086914 -1.2888496652776846 -1.0130320847502927 -0.7770215700031498 -0.6438820400532235 -0.9203024670927467 -1.6757510497002561 -2.4640258984889294 -3.0799251863389396 -4.205664915876774 -8.534075666232257 -19.56624519906558 -24.13600188954152 -20.16002626610933 -24.688470566648327 -22.865625006474502 -14.17225998708206 -13.928380950608796 -8.430538160119237 -9.97015022097154 -5.6109460463457825 -4.1498288931868 -3.6609917070850506 -2.9892394281648618 -2.552700403137022 -8.079640983389694 -14.467266032287311 -13.206563185815005 -6.48379368569375 -7.509462468946979 -6.863755215660352 -2.2012245951516234 -1.1749127829318595 -1.369638463157791 -1.1754147423270793 -0.952555711423391 -0.5557698055243172 -1.2314047976678932 -1.3968975294577008 -0.5803867730823618 -0.377087642664269 -0.7295727796211968 -0.6116815328653761 -2.0330378216380733 -1.084396433921494 -1.1205050134131158 -2.241837043629634 -4.332912972101142 -3.209205774379972 -6.737244508328489 -4.317616221403201 -7.710589021452096 -4.096861540981875 -6.2968118637434145 -4.023427361653206 -5.512758281716835 -6.582195659590338 -9.264822945669541 -7.45375511875299 -3.687963473325079 -6.111567490204038 -3.612666943380969 -4.187809200216392 -2.266130145333083 -0.7723901692258919 -0.88057016011628 -0.939922689565802 -1.2708476051662978 -3.8785333111198654 -5.932286738230052 -2.4079273275356297 -3.709302448994065 -2.297941941147988 -2.5559226508261994 -2.291353207508717 -1.7687962990408277 -1.4124443499706578 -2.240145395790897 -3.8501890905471527 -4.422798161191501 -3.8292889015825353 -6.259491816333808 -6.533873360920743 -30.444929226036685 -21.451214472367138 -14.692953699893545 -9.40622646508739 -6.688131788550943 -3.781333862047518 -5.728127413060173 -7.625816540965673 -6.550444475626558 -6.556804325863093 -12.952279828166079 -14.830470695018652 -6.327685707119558 -8.474181352795911 -6.672945419251216 -5.6083404171500115 -3.3829239398648805 -2.1083197803050875 -1.4651111645742332 -1.240218806216434 -0.6159518130140802 -1.365723111079857 -1.95538285164987 -4.630278712917188 -3.38610879215804 -6.7572803617813895 -10.43232563383647 -22.964400461821928 -18.504303789219453 -21.11385451551827 -23.399495761355027 -30.79883914474469 -15.60431616523695 -21.71561143221624 -5.9486772049724586 -11.735859336597889 -9.834235114900439 -5.1816900259311085 -3.1699880055678658 -1.550052666814486 -2.1834048427343262 -6.216166286483548 -15.843230534149157 -16.344299507519757 -11.315616821380438 -5.116969760672525 -5.7106081952564365 -3.590589856112305 -1.0065157353722676 -1.6569613244854553 -0.9795764785403933 -1.0174711351720023 -0.6313498696528372 -0.8735907199218923 -1.3834057734607719 -0.5882432003632534 -0.37900187034771404 -0.657957717794863 -0.7070465891020179 -1.4890883649398403 -1.0837768962914818 -1.2370269652721264 -1.6728759854422732 -2.8943079874644586 -3.1427342097289435 -7.356874395108093 -3.7539895312695024 -5.644274995771138 -3.169197300623563 -2.8759350766315794 -2.774507351386433 -4.606281653386577 -5.902747399936278 -9.180873068107449 -5.803507836210803 -4.932103295086769 -4.238633479146083 -3.5620567776630714 -3.899206152764494 -1.8039528791413533 -0.65964958626593 -0.91806375686546 -0.5416588786391914 -0.8571422143315146 -2.8758246462179704 -4.865642146821039 -3.6382943866705366 -2.710188126350627 -2.9883777399618863 -3.659887606763722 -1.7842037335327474 -2.6988770998171767 -2.017646676827047 -2.5979073239478043 -4.831989775871161 -9.180963209562291 -8.471153982237935 -5.177390594762643 -8.237942017257549 -25.910379596400535 -25.781043281224385 -10.042392950524196 -11.536160618222853 -8.9098929379249 -4.284741099331122 -5.038516757424998 -4.6387004063803925 -6.08753797733333 -6.124253359618934 -9.598818205065305 -18.920798393968656 -8.205001976183977 -10.837433971279362 -5.822325446277085 -10.09833646514427 -5.416007687515583 -2.8447444073321178 -2.480078222209696 -1.5052291485141605 -0.9179490564666151 -1.1897236672803242 -2.0012634686236983 -9.061390747559148 -5.756152110333792 -6.825979192462114 -8.757431781942538 -33.065494685133636 -22.301367496073077 -23.463543963183813 -34.09408068024452 -27.888641587438887 -35.9383761545858 -13.164445805966366 -10.431659680973684 -19.894998502960373 -10.496158523810113 -4.857911584015281 -4.157933024735631 -2.2220237313074436 -2.6097342928224796 -4.14778230350936 -14.354342586184611 -10.306749772858781 -11.128343653692186 -8.912054897259695 -6.761358823576327 -3.921749173149307 -0.8388574100646047 -0.9443149993982094 -1.2186879325958246 -1.1776342853308268 -0.7912147771070441 -1.4053486626110079 -0.743854302183979 -0.9139231776551028 -0.45580998343137324 -0.762325477085296 -1.3167863475467856 -2.2830963892511735 -1.4791049970059398 -0.7673935557233584 -3.129182279763882 -2.834978790753222 -2.662356890244539 -4.782759164971398 -6.117921345490848 -6.995550240320661 -4.841827712635299 -5.301812535116276 -2.5574629914556724 -3.263900143545237 -5.363766351403308 -8.549207317845324 -6.609552632009063 -6.166179064582208 -6.887082321711944 -2.4704742322467657 -3.9369520015594794 -1.5449426631808572 -0.5600402344966273 -0.4671545194703644 -0.3766698598873748 -0.6109938708041444 -1.4182685546727671 -1.5441326669611186 -2.629825598346821 -3.255929978644248 -3.4982557928237923 -3.3059007435479852 -3.124112196086307 -1.4408051310099885 -1.8161388675762296 -3.747466594782341 -5.259242923752485 -8.872144149776238 -6.006439072154971 -6.708110863808561 -8.98723163908879 -22.83810393757579 -23.092201260871164 -7.331676463598235 -14.800924662509733 -6.9741842506301435 -3.1119419747058945 -4.778061861225704 -5.446442938552482 -6.071387084378958 -10.271102925721245 -18.727075006896477 -27.44036104895108 -13.208032809518498 -14.157015666574983 -7.628381064536459 -7.30707790900949 -6.473386924984858 -8.61000872748829 -2.7265575406234075 -1.8365990227193092 -0.7887985029757675 -2.7041071619129453 -3.013638883766832 -6.8819444087904165 -8.270466295183489 -8.414096685596753 -6.135715496742833 -34.029535482427 -16.999600316450373 -35.81676724915226 -45.288741205495405 -23.564944904774034 -54.86289320110347 -20.968751232740495 -18.159763365847457 -16.360811292767636 -11.174084089918269 -9.680144753882777 -5.180628444634995 -2.8623832669784943 -3.4198595920687187 -4.989580674354801 -10.624376989758042 -6.727456707353469 -8.430578810301744 -8.38795894904232 -3.0958787595107538 -3.468717688659653 -0.8126697026299122 -0.5656296500576349 -1.0894835939095917 -1.3195947665213608 -0.6815860889861808 -1.3301683362118553 -0.5832978353756516 -0.5551016283037958 -0.6075972877203825 -0.48080609882284264 -0.9385754535784157 -1.6268085342909662 -1.2768712932317337 -1.1931374469928415 -2.217654602464727 -2.270395411570607 -4.917834629409787 -2.316750387882159 -3.418860423569011 -4.198211215366001 -4.194117883823511 -5.013673024731322 -2.444305845214599 -4.859707075177644 -3.5614518055798827 -11.117257586841758 -11.944781427851149 -10.431105772113078 -8.390306970974276 -3.589999682962367 -5.028789931881665 -2.724538274836611 -0.5292168237053132 -0.40029910464911544 -0.368633947719559 -0.6467385436023015 -1.4317750111253407 -2.1675621019572846 -2.680617937886297 -2.613399687056482 -2.5806517672800076 -2.371013706058698 -1.9616255005064018 -2.862633578235515 -1.795957889793808 -5.850823017326045 -4.3541664630087125 -10.679017590789334 -8.40988251072671 -7.0069610188316505 -11.179316557281457 -27.456122678935177 -14.69907901549649 -16.341005237165767 -11.185613355545504 -12.270230367645084 -3.518679122649178 -3.6561408443609835 -4.613760103628435 -8.779727668918968 -9.400519716319083 -25.29982068687687 -26.734195739228948 -16.88581336379047 -8.483795475200614 -13.35335918558437 -6.2933457073082755 -7.042610543660851 -10.371330449856108 -5.758299822872706 -1.899925641536186 -1.1397830588749585 -4.206305043400167 -3.324305387604376 -5.3342825354238945 -10.10601217092928 -10.311107685915452 -13.28424567396261 -22.983545562185995 -25.703496837389796 -29.925149513730307 -27.37428490428545 -29.815126369352488 -33.00728007933278 -28.02024520387224 -9.615033602638619 -17.655007564204695 -14.98579668574587 -7.083214698333175 -4.810162949099412 -1.60988791186751 -2.9505315130142757 -4.14782638370465 -5.375087014886489 -10.02549081696088 -6.922873974827121 -6.772212589227845 -3.647606919569439 -2.147175436789162 -1.1924041463392994 -0.7753401871338718 -0.8270088609693023 -1.5808029864105708 -1.817330860318409 -1.3419451406578848 -0.6321526254067146 -0.6226072834635521 -0.820084839342555 -0.6105715129272119 -0.8215050896598767 -0.7585392150536446 -1.03036890816257 -1.6205257319027877 -1.9994280417339274 -1.763757607002275 -5.2901207109370345 -2.4021486302994592 -4.95962031219956 -5.477898463897569 -4.702288406376224 -3.7087810963533605 -4.376294425524951 -7.880407158773078 -7.466647957290121 -9.942946730428032 -13.314710754967226 -18.459701309222766 -11.237989398115504 -4.205588051527728 -4.263417176722605 -2.6438372585262098 -0.6373623707956927 -0.42576100037237824 -0.5232395936126065 -0.4745127147332751 -0.8117883883886987 -1.8077431005381064 -2.0110629611331032 -3.3708139782387367 -1.5084870486054707 -1.5346401094813527 -1.2553660902856594 -2.35404650644247 -2.968256123958012 -7.677297487574293 -3.9849622572568664 -12.716294137932806 -12.487052649341049 -10.257297856294981 -23.756745055285265 -26.00317249256816 -16.041150957545067 -28.85608328690181 -15.844662694412284 -11.017135313043848 -4.687573504657866 -2.6915065316632725 -3.9153485584149443 -9.791093139252952 -14.791573255040886 -44.604856676403216 -37.169314063812116 -10.872717890892613 -12.290374381327888 -10.624219601368699 -10.835813763723563 -8.314661439831783 -12.055019710071644 -4.544244347794859 -2.252927321734231 -0.6403945487790861 -2.049295536429084 -6.429162501794088 -5.36483765350758 -8.810283421189254 -19.922715537328347 -12.952508116225522 -12.72740055670594 -18.04991587251513 -43.05222727453594 -34.89891575535455 -29.6607427745377 -23.89558930216003 -23.91496537007897 -11.107757009239517 -11.945301774793673 -12.373648524266615 -10.491042385630317 -9.674592276214522 -2.410246946095467 -2.005402767882636 -3.6417816332888373 -5.594304592079883 -5.699727020374433 -6.624053216569046 -4.28134910325415 -3.356952877473935 -2.242478650982966 -1.6781688261917589 -1.4127305545577775 -0.7664190133290133 -1.3824100049810555 -2.8171295082375525 -2.0223283416677296 -1.233541047404699 -0.9256825053733044 -0.821579154072614 -0.6206830452487708 -0.647687405690901 -0.8085943354737853 -1.1878328189825067 -3.1993765039806727 -1.9061047774708648 -3.9920645979404004 -5.286359188105332 -2.2242453673114477 -2.644985640039868 -6.091627930238062 -6.7312336117151395 -3.106556254827349 -8.414860415569908 -5.291590815194033 -9.005947709297532 -10.074736612920187 -15.51218424181497 -35.17581362405119 -17.65746611001853 -5.661700418335048 -3.6278728385123067 -3.3666578534347233 -0.8166870838640454 -0.4012504547814017 -0.43920734497489944 -0.6156843036704256 -1.093782565812351 -1.5516392753483035 -2.33577797260578 -3.9105973985705855 -2.0301754580604334 -0.9523187172320674 -1.7143686778600113 -2.948049491741665 -2.0456571704726296 -1.9141337830166565 -6.474381994527278 -5.526466765220094 -9.588495179546445 -11.990493663331256 -20.906944349953598 -20.32393308736341 -18.728671711698116 -41.239891868649394 -26.91230048791629 -12.15117897725743 -8.557486807721233 -5.1074039093921835 -5.536645553819214 -9.95242431886587 -16.480025777095893 -48.06166599744176 -38.5725956810579 -6.2064944433803255 -7.624607845494272 -12.892838424967785 -8.810347070023886 -5.717838833188287 -7.349559887026169 -5.295774109092667 -1.7188915887346852 -0.6802085934046468 -1.856479479890047 -3.8596693116645353 -5.204508387162981 -5.7360673040588805 -13.5412620388132 -13.086512287078628 -8.658051128145846 -30.77258433528254 -60.08432581264801 -30.1701235386056 -28.678536440946253 -23.10852324999488 -27.47365242640078 -7.822605807041477 -16.885591846385843 -9.369978071971357 -8.810696108951904 -5.477223355854842 -2.6363448835716543 -1.8443426554659095 -2.05521025698957 -6.196443298631871 -5.827988232372615 -7.208774406710071 -4.745017995222199 -5.918389613463134 -2.1394930937096515 -1.4392211126435908 -0.8447632624354612 -1.1211185980966523 -1.6516641488165527 -2.3382690845256806 -2.7272497404256977 -1.393003871943397 -0.575872849094401 -1.002981648659106 -1.2541906939350946 -0.9250942414459632 -0.7383727996318292 -1.4273035551558673 -3.6817645953812557 -3.3806118685813717 -5.87858945297632 -4.952284612440967 -3.5729055576622493 -1.6364504733720147 -3.10224091910995 -4.234348410981822 -3.7056844442040537 -5.8541225062890225 -7.653297989300566 -8.506281319915773 -7.795212429104562 -21.841376318471454 -42.695116872904464 -24.293254821431642 -5.520273020930129 -6.940149841774324 -4.606439831750202 -1.0937047386701215 -0.47699465345305403 -0.3156118046170381 -0.5464818171398454 -0.900251719296854 -1.7747223526931863 -3.49799675334289 -3.5899266362747024 -2.225555470914207 -0.7981366237732346 -1.8142922045420735 -3.104261620943718 -1.2210518827791694 -1.1822432248180847 -2.237196444047888 -4.778383692039958 -7.561697204497558 -15.31260775789977 -18.891323849409403 -16.49008386074416 -17.162481392715456 -24.40376178745066 -23.086878159212233 -10.110139945545296 -10.010120453644621 -7.810990054283977 -5.856898735991005 -10.70008200968201 -17.66544257405857 -45.21281254462525 -23.177474932557846 -8.62217922471953 -5.911819607725914 -9.82534588523815 -9.351245301201246 -7.657180039313587 -7.628245209681632 -4.353237131820852 -1.7596706294436495 -0.9370188428377338 -1.257290649820244 -3.8950962768100377 -6.779502551857292 -6.730224292939077 -11.261349364259189 -11.378848896428938 -14.40993941247735 -28.57779275637766 -35.37690388478909 -18.984460337961266 -18.296827659158822 -18.299414965120196 -32.585250846125966 -11.290049315911606 -10.002858001867207 -10.165399059918853 -7.28649525205255 -5.719081139037942 -2.5459870359719123 -1.847757084984893 -3.00174247433859 -6.800627537738381 -4.107699227589178 -4.463942248651087 -5.704815359556867 -4.186782449909396 -3.6178781029763676 -3.185384986296028 -1.5148209242138286 -1.0658196465243182 -2.0274063325589617 -3.875023354122228 -3.4621534894455728 -2.6789155063036123 -0.8865028274441535 -0.7855654095647421 -1.1445345631860877 -0.8234239712229852 -0.700084786408666 -1.7725527265026342 -3.4513430712225737 -2.9537012994081198 -3.52077739867411 -3.8667886975627184 -3.0433264542578495 -1.0831424911479701 -2.0302548176362367 -5.367524103760581 -4.935022187059414 -8.780342336091968 -10.855614432674125 -4.977944351988381 -5.157221381414596 -14.030051480738667 -44.98548331774177 -43.97738377962675 -6.529958872922327 -8.179207801517896 -4.210332285133593 -1.4763195908600042 -0.5971127362654394 -0.30501405059247316 -0.3979477255480439 -0.6411638702392741 -1.571527033819276 -2.9218439061969335 -2.6791021862772366 -1.5867858924063116 -0.7331074959448448 -3.1491644495287803 -2.5414501538905236 -1.2567851161037402 -0.8194427020404043 -2.448326953097453 -1.523009622055718 -11.188816131858264 -14.553124701470473 -19.11944671024915 -27.648088883375134 -16.63097985879277 -26.211167762863955 -21.807574643531495 -9.145442431676653 -14.472476798766653 -14.140098485355544 -6.500129879282984 -10.446311499726319 -20.10175650032518 -34.19437466867353 -22.930650520311 -13.24128941814076 -7.142245598613847 -13.131103987778781 -10.674705528989804 -7.15685044201053 -5.019479068215283 -4.8775306893134 -2.01564548811771 -0.7229520868832213 -1.4402488349293168 -4.840525827791772 -4.86316034322885 -4.7609959908963555 -4.419915693555298 -10.510900789108266 -10.545618562456236 -25.80402670061988 -31.76816267554417 -14.412219274282162 -13.608784308821106 -13.608717489849724 -19.049160230451534 -14.040236656113466 -11.597962563818609 -7.0472223830676555 -8.162884995614467 -3.50263691261679 -2.1297410260592904 -2.6956913934611464 -3.717810128551158 -6.276083269025947 -5.03740887963705 -2.20191406238849 -5.15576957734044 -4.486024190554441 -4.955263728388073 -3.7121086756172588 -1.9732941610078765 -1.871950893264976 -1.2100104726867544 -7.325982739107198 -4.041554692997248 -2.4542569430803827 -1.8781308612962953 -1.086493892658091 -0.9868529573084458 -0.5920514207232299 -0.5277855787976262 -1.568037283609668 -1.539386269288319 -1.8709123478053258 -3.572207659117171 -3.4912381148511575 -2.325664720457687 -1.2272257784794531 -2.5620248054206924 -6.682080491388243 -6.763237200302776 -11.723326492721291 -16.620492860953334 -5.087508178893294 -6.220603436193985 -11.60170443440655 -27.862511660841136 -28.565229519511917 -9.989263199027453 -9.517572941326575 -2.59667038740851 -1.7069855251006245 -0.6311971265684476 -0.4251130014812795 -0.6933060322963884 -0.8710916856004546 -1.5065794452805836 -2.0013129105800904 -1.537698233221872 -2.2945543893864575 -1.2932341459631436 -3.3492701775829747 -4.705503190226337 -1.8193757552355012 -1.0880078748132762 -1.7874278065708427 -2.286710295451183 -1.266430377554843 -26.77188075570736 -23.594954678245156 -17.095716775098357 -11.85373038830989 -20.636371034890622 -20.32443168646501 -9.366385180092898 -16.001118655064964 -19.643261809376156 -6.167864796262217 -12.471165505946962 -20.40773672720327 -25.475149312184154 -21.218610434026964 -19.101940952756703 -22.608635713283743 -14.070874820180293 -6.088231559939713 -11.546383090490632 -7.325975429100271 -6.944252797515586 -2.2065375014101845 -1.1990132254484756 -1.5375401178076322 -5.633071399233157 -5.299150347984032 -4.464917079641844 -6.9584642433392 -6.998656310846807 -7.557778333132602 -21.827275898006135 -25.994558945518733 -11.498526682006986 -6.67234063150607 -13.728032054379725 -17.54200939414141 -30.215148377437004 -12.626359960203485 -8.391419818687895 -7.907457308017105 -4.341307304581376 -2.425017564406401 -4.29023583519125 -5.390070260188467 -4.864484744296875 -6.570970941781802 -4.092934032663939 -3.494364374257895 -4.546034115406343 -7.46594587009476 -6.936601152616636 -2.0795228952508276 -1.4444895477858135 -0.9780289192982724 -6.725806479586362 -3.6451968476909262 -3.1260356064282027 -1.5178203931561502 -1.4275773877368525 -1.65218822139416 -0.8139210783053432 -0.5738869340589032 -0.933256942995294 -1.4266760630791255 -1.4931818719854495 -2.41526541063097 -1.632162640559399 -1.633547938787106 -1.4724196064987667 -1.7574913853755456 -7.7437290865299255 -9.230268330616237 -12.114909741437106 -11.052429958243351 -4.885748783871075 -12.360011410385871 -6.305289728681961 -25.48123993675318 -27.171118997831204 -10.22672230752212 -9.545466975088566 -1.821715077246404 -1.142833154864616 -0.3630702385927968 -0.37666639463007107 -0.5493625090191688 -1.1505118250821942 -1.1131909424423445 -1.5852892537317829 -1.7813078523142225 -2.202011633561647 -1.2336807832744148 -2.7553402284254345 -4.860851434253184 -3.215563922072788 -1.808508642246686 -1.3703900138315692 -3.0961150573062013 -2.018339166980829 -0.8520662525151047 -15.067740506620455 -25.07677245261689 -15.224310720381869 -17.295286468698368 -20.045710365602353 -8.035566240407984 -17.090960484761126 -12.925709979171687 -10.396038280396642 -9.407996119796072 -20.552811915131475 -44.28074756633765 -25.15300152002213 -18.84932618176307 -20.483223348778893 -13.47884822665103 -4.1201824664475915 -8.751044204036802 -4.634590914281866 -3.432424244152381 -1.853252148915111 -1.4075230409554256 -1.4571990933208947 -3.6559426580500367 -6.114926762460299 -6.513798088996188 -7.100969533885832 -8.00911703475499 -9.603367879648557 -16.967822612719274 -19.026582389511017 -10.895504263980587 -3.2613482230376887 -6.126609118104357 -8.35435377244004 -21.022216400357756 -14.439169512437754 -10.746386419766516 -4.815655528118492 -9.54136406155746 -4.924451916339653 -7.77800581989891 -8.21855676311457 -11.787057540060813 -8.286672869294257 -4.5775620981943534 -3.4959911042886613 -7.051942309445319 -8.585312592058733 -8.951108748172777 -2.9103672373151594 -1.722082680309166 -1.8311561699624268 -6.49784168415495 -2.866821783672678 -4.706082314869262 -2.43790655687696 -1.2550447830135967 -1.7262271276441088 -1.666325689461742 -0.7461222794348756 -1.0078081674283668 -0.8719574847962627 -0.7116117914242128 -1.7877935043003081 -0.9809243335958735 -1.6943844809623703 -0.5895088204617251 -1.8665903735185312 -4.667198335140072 -7.502562040461832 -11.165986730434291 -8.891125780694319 -4.075857541778748 -6.7313486912061 -5.347133625983075 -8.632080092494096 -12.008284413013588 -13.947545864266944 -6.1492532510365 -2.130767738784508 -0.9861782479478498 -0.4113467407213736 -0.33589865348103926 -0.32701870174247566 -1.4883070721644263 -0.7285625730830217 -2.2855574312402185 -1.6162267640809145 -1.6706300785086414 -2.1955855473201438 -1.8745726763973118 -5.3160490353668965 -6.29613283082963 -2.3496746230201526 -2.3295444795967692 -2.172597180952188 -2.094451219781283 -0.6341838091920995 -1.6033273801571337 -16.006937428967422 -15.520523111459328 -14.528876230592955 -22.692788151313525 -15.789511232261631 -13.257133057901912 -11.425322554972295 -6.818403071701421 -10.9752541987974 -31.494335287729584 -49.51691648378206 -29.854490965007873 -15.936669850554685 -13.880856055242539 -10.011627739972056 -4.037880303651943 -5.266990305047543 -6.6736833663858794 -4.842037243036488 -1.7735853258206673 -1.119825585555362 -1.05721712814681 -5.118569377175481 -4.284502043097462 -4.7632611675029315 -4.674450550478328 -13.816530404706274 -11.569836729822201 -11.852418663699058 -20.459489025359105 -11.108174618647126 -3.3588196986483143 -9.543612979932188 -10.130123359232872 -15.59243323915386 -10.129224904278313 -11.726776593666541 -4.129481611032808 -5.134306860398171 -5.146256420394975 -6.872954562534942 -9.177519717744492 -10.628480053069774 -5.347335329528709 -5.220568204499457 -3.1854342819571144 -5.320695715580923 -7.31855286962681 -4.878841098341398 -3.009048332636122 -2.0728906418731037 -3.241764532007845 -7.523309939168039 -6.126621428303566 -5.288675321884089 -3.170235423087436 -2.080692388251583 -1.5439518820484153 -1.3606698322950812 -1.1596893196666145 -1.2084071319919651 -1.4330507862039317 -0.711401392962869 -1.4805338435554343 -1.5690085144894113 -1.86526733103794 -0.6123793848726424 -1.3101933266998125 -3.647556323022644 -4.61164599578287 -8.88521983527123 -6.9988291118592665 -5.301936632863269 -6.50949148761894 -5.558883628047029 -7.856187842487909 -7.96710848953968 -11.097416348156539 -8.548294438610453 -1.8694785538357646 -1.1208353475069068 -0.847047073689708 -0.25691809734002125 -0.7100863784926371 -0.7817064774433671 -1.2751162455963279 -1.4126693030818402 -1.079261790273577 -1.3669121178907833 -2.9865691724486103 -1.7398842288518288 -4.6099864192409425 -6.643230353935129 -1.9009642753219416 -2.123213541986067 -2.2674588697252815 -1.841540748308192 -0.6875184171180665 -0.8993911690609979 -1.6609500566674087 -11.494217777610409 -8.577633206981393 -14.766684742059098 -19.179844104577167 -10.560988787174551 -16.999309965310626 -5.529655270063051 -7.960387272534331 -30.121434247929564 -50.327537359117585 -47.26678490016585 -23.200266148562623 -10.930195891764873 -9.718002430528344 -6.411690855167213 -3.2773749949502586 -6.301332025987662 -3.474967324375312 -2.972015052385381 -2.0706561962747565 -1.2313472936496908 -2.2742668071380403 -5.645608453203754 -3.235636647539793 -3.7442926826020755 -10.373050053898059 -14.983623070338792 -4.432377651724088 -16.010185144083977 -6.5338437030154255 -4.82951913113374 -7.845751383420541 -5.31966969615029 -15.801182805386633 -15.23204488856229 -11.056395266685985 -3.5041747623869415 -4.067801671559309 -4.222042784859117 -6.204831218686806 -5.60388961350616 -11.23890992051567 -5.915088875339315 -2.716698456347181 -3.767243123152438 -5.662489663628484 -5.81395042632537 -4.899979052901826 -2.9405066360602623 -2.8893057941614835 -3.4137579340659654 -7.263703471362972 -6.815698817301175 -6.3692264033290655 -4.856137353410928 -1.1814026582889026 -1.7165233895167589 -1.248766413963207 -1.0809503873801178 -1.1780316416195378 -1.820898840626287 -0.6187062160186055 -0.5209357703737306 -0.7224928019292473 -1.6754276020781227 -0.9745878208942049 -0.6682129505203825 -3.089138153226146 -3.435732457513157 -7.746010499761588 -6.16259654463281 -10.031580889849929 -4.225436941522925 -9.028461200620166 -7.64180994544155 -5.768564903795221 -15.574182828994505 -11.455404124774924 -2.6054947774222175 -1.586116336808978 -1.0848504473291087 -0.4953225452099303 -0.9591242973096192 -1.3275496152739643 -1.2190185811416683 -2.225804692543911 -1.3239817089666082 -0.9648201180527753 -3.027088973480887 -3.022253088422811 -3.3929929931064353 -6.972126786346908 -2.1762960687011934 -2.2654526284675716 -2.0497034911867265 -2.3498385229579744 -1.31352700058909 -0.8481979426930758 -2.1619762688895214 -3.6451077818472553 -5.995233796618177 -12.521420840778738 -13.913100348963146 -9.480132037890614 -10.394764518981352 -5.935979678246076 -7.000341648455697 -21.65255442191488 -44.720787756969685 -60.78340285129296 -23.263105610354163 -11.304353852517469 -6.2766827855485925 -12.31660473913042 -6.8003474247934 -5.249730276445756 -2.2940066512299024 -2.2395987276789175 -1.6227678919352517 -1.4309513374017264 -1.5467694506246437 -4.69692408290568 -2.8768417104086508 -3.2385358675587703 -8.237003678176876 -6.209734159974467 -2.539950470270962 -6.543234079842045 -5.434048911401054 -3.6318713642014466 -7.5741521876199345 -5.25745826491548 -9.434935286525343 -17.917679165190396 -7.316121114972785 -4.808396279694214 -3.7492004844885467 -1.7183929713825379 -3.248872914699998 -5.723670640510797 -19.099486936932504 -6.0245757228995425 -4.592694585879401 -6.080250416621856 -3.7300602173052466 -7.046739049185358 -4.327427096345198 -3.1035962275879543 -3.8521753721039076 -3.805236042652991 -8.706189539259551 -12.218734663449183 -9.07786711727762 -2.7786440390806693 -1.7594819219830373 -2.6299482004702903 -1.3688232766895834 -1.440021288355456 -1.8364068214785931 -1.477993225655722 -0.4427199569717308 -0.6538481211919436 -0.7573900579917978 -1.463112496990291 -1.158969481927797 -0.9454370748487946 -1.5692677831281692 -2.267853028085025 -5.280217500266081 -4.714050270498076 -15.445676802176534 -4.191848931521386 -6.875416335609423 -6.6736528105473205 -5.437455385764607 -19.495088172739177 -11.902931386847843 -4.088043985053814 -1.4350048058918843 -0.9059240927791954 -0.5926706979236227 -1.8110024523548358 -1.873120576408873 -1.4836189588638897 -1.1294228315559784 -1.2627437555337608 -0.7626116710448487 -2.0778658263121375 -2.355666361501661 -2.0078023965892293 -4.616171786790823 -2.496593416553124 -2.836478032276851 -2.3750811044148126 -1.907599945300184 -1.6473716151586182 -0.6925554203845642 -2.12406540015024 -2.555680793664109 -4.9868779056926025 -7.445548315670756 -15.318152891444859 -20.118653105299042 -13.541895338879506 -8.417716435037612 -7.68410588363368 -28.46126167788257 -46.298363142555964 -23.549602035416978 -21.87672896856564 -13.860187801738634 -7.052551947760101 -8.57656475694522 -5.605348396936596 -4.185468092611 -2.5655904514750767 -1.2821649934890584 -1.8324293727157677 -1.3549225943379515 -0.8980570648997077 -2.969446967274987 -1.4706629410360355 -2.4667134828189465 -2.3251734925093284 -8.119020384073915 -3.092636903472302 -6.898796741118388 -3.4977409167578406 -2.594162082643435 -6.164406025211842 -6.642412028413759 -5.539938193629602 -10.277703331223622 -6.272150038238303 -4.10874909024064 -2.4318233754514043 -2.149567075782918 -5.184103564876007 -4.534397876096346 -7.066035076035086 -8.391410409472178 -6.929325051787578 -7.173469005862621 -5.086588055280538 -1.7087377654946272 -4.748150053981177 -6.47478506678123 -5.853012332422341 -5.110343038505469 -10.979897604606236 -8.456701335934861 -4.4393518105249425 -2.061411564897376 -1.331371138246805 -2.408009093072858 -2.020322409059846 -1.6923239378012915 -2.62938831046777 -1.0652993045388144 -0.7267403900171505 -0.6264094307822096 -0.9545614160715562 -1.7509209851052399 -0.8760476828952937 -0.8962218438598716 -1.4977465754232977 -3.0125488059296273 -2.340154994158965 -4.0224404011716315 -11.318585249565908 -4.061198845600106 -4.847263513877748 -5.619194152100662 -5.035627885717852 -13.991647867037116 -13.130430888177665 -8.204230048083163 -2.383108469886166 -0.8780037182707771 -1.664747236690213 -1.962961977624227 -2.632800017980663 -2.1509343172486877 -2.417589631859022 -0.94203795590844 -0.8796649841262354 -2.2786257032750457 -2.5500440371151387 -2.209382057425648 -6.0314959872852185 -4.087694997814009 -2.2279340449946505 -2.80325206356038 -1.751988214088953 -1.9638376603480738 -0.7753297671574803 -2.839449991669988 -2.6550783336954566 -2.665611528531831 -6.6299150514906495 -10.896675318005409 -13.758719956795566 -11.336868293705832 -4.139617309437986 -10.56851004036826 -32.934995820739765 -42.221806134029855 -26.879489072168454 -16.107669639432068 -15.320546417478417 -7.777521178593557 -4.297081600161922 -4.133009885234381 -2.6913376212274884 -1.9855688284483322 -1.166253417959835 -0.9150503327312564 -1.5246252944208158 -0.5128778102616111 -1.3747833038952513 -1.347755470649691 -2.148017555700353 -1.9174011442792427 -3.9335010527475696 -6.415197584830888 -4.503298449845299 -5.3901141381890945 -3.6539243397055876 -6.951467199622029 -7.479023445575305 -5.621565600770321 -5.3211464938938455 -8.300098409596488 -2.1052451183846284 -3.772063115448691 -3.504147019959176 -5.610114149035049 -2.3813553974125177 -3.5096891956480993 -7.884433478698454 -8.88321298647082 -5.73009139889674 -5.2514877396041895 -2.073831769946163 -4.4203795227063285 -10.013398251872617 -11.315602155351193 -6.446617811165719 -7.280959396367214 -11.273932413256047 -2.7579388178408166 -2.0577020888551067 -1.1016501652993205 -2.5098704747798175 -1.745169552608199 -1.5952369935827604 -3.1149986149983593 -1.5545891188903815 -0.7545845388208047 -0.48677634563457955 -0.8023295436641461 -1.1769539937321147 -0.8775008622899412 -0.8197737516265032 -1.7437707260368203 -1.6940776377176696 -1.7814096622891409 -3.559593271249946 -14.886890699613815 -3.9502249350118492 -4.4630660628759244 -7.644203863556885 -6.29199500964328 -5.506750073221271 -6.308113584516359 -5.474074082642922 -2.013131883005882 -1.2693261286257222 -2.6627000263458145 -2.7601870481879973 -2.1306492109749273 -1.0784782836492774 -2.6041722668871676 -1.7112649741890436 -0.747820547770256 -1.3798118735915064 -5.0194068305214765 -2.7594556217252526 -6.563342772169608 -5.429361979187498 -3.7141403934244313 -4.314488800398448 -3.075779716982894 -1.9005441582846034 -1.4480149972817151 -1.9545102980892475 -2.7867861137970897 -3.276844682799529 -5.467596176547405 -6.018303902310177 -10.487686061509455 -8.562950128003544 -8.085543677916407 -22.811183107426768 -35.21232159664646 -36.352294838251034 -36.50608432467747 -15.64475600554919 -14.064114025026072 -9.186731556904615 -4.161151097757572 -3.7400671808258172 -2.9096331273342306 -2.2231213394061333 -1.8313982139518343 -0.914674255040051 -0.8446241352076935 -0.8952861878425321 -1.1660600979580036 -1.8173728141702574 -1.9374088433590266 -1.9780846558854168 -3.3836060478125027 -5.25908054731195 -3.178336181227931 -4.584091012374966 -3.332384905650644 -8.460727255343032 -5.201886585250439 -5.516172152405152 -4.9700113201457325 -6.0905198582878715 -3.3745035763975135 -3.0599252373629056 -3.361632375874685 -4.725641606840997 -3.0820608790764137 -1.9356400265389635 -4.715986243798138 -8.611675283274415 -4.630573391304935 -4.96162038404114 -2.4672576903306225 -6.455842449686332 -11.066110917811514 -11.329383206274484 -7.438932890973327 -4.714777511734987 -6.107624567245355 -2.598534712834443 -3.2071446044288883 -1.0562667707616578 -2.4900564512798873 -1.8990466040454714 -1.8502753220043242 -2.2459622533159966 -1.0122124127519236 -0.8489884600665524 -0.4889069913763012 -1.1588343831574137 -0.842813831792139 -0.7943766335621455 -0.7684567454209706 -1.2841240200466666 -1.3179488974687283 -1.313780981542461 -4.298339662002397 -8.027611408536377 -7.169630516572664 -3.948418649288266 -6.983089418510464 -5.711999481518694 -7.465740978713153 -13.893641130833489 -8.12638585726508 -2.1758738680679635 -1.8646937018667837 -2.2475313158147707 -3.7338871062679835 -3.214140128154337 -0.8774011349935324 -0.9834969929849579 -1.796842332657384 -1.3185458756745791 -2.238829143875983 -5.365973174305055 -6.432553087399631 -5.789565748096593 -4.637940248651088 -2.9426726486913113 -3.091352708882026 -3.3554400861842977 -2.1750582488353283 -1.9310191610683518 -1.910200134162538 -2.781603750069045 -2.3525819037123843 -7.141551095221279 -11.611912459618704 -17.736344582836377 -7.048959359694891 -12.47374881062699 -40.346664766481545 -35.860629980076645 -50.509026297493676 -31.705625623319424 -18.049700057840475 -14.411148808100132 -11.063556349188874 -5.618188590198426 -3.4941803554526283 -3.8676491556373462 -3.3837850764797714 -2.289749698994437 -1.05482373191686 -0.8182692895126934 -1.3371407710546968 -0.8853126247618167 -1.4803536847876158 -1.4281898400841988 -2.3560934672349623 -3.677779725543758 -4.2710567494926694 -5.27861799540125 -2.9101815846467236 -4.053775492050182 -4.206618317578775 -4.528346165987142 -3.763937861775621 -4.393694872556117 -4.069473869259255 -3.0160639996359366 -2.9459674941688787 -2.8572148604152927 -3.6470242827006536 -1.8276309566511302 -2.4702864702546456 -2.8695903645066902 -7.092551608624402 -6.0134133542793045 -6.1527992978919475 -7.1667561728347575 -8.408022435565822 -13.879782062812184 -22.581668908178088 -5.646990090503281 -4.169406567544975 -4.239829299675148 -3.4964301750094804 -2.7684208921742988 -1.3416151551461106 -2.1410895268538797 -2.9383484084558016 -3.6404275425419423 -2.854370263401406 -1.4773899379319557 -1.2305714546918605 -1.0472566636380194 -0.6357529535962038 -0.989056727719442 -0.7578316352024128 -0.9843884047330805 -2.2301361147478387 -0.9392693938333748 -0.8565002506574794 -5.447005431487151 -3.341851557587928 -7.180218842625533 -2.895009644767412 -5.467767255529253 -6.384104487497386 -9.284505320692345 -9.037640042772622 -13.43053688989533 -3.9786674944586324 -4.168609340956171 -2.1645276983794686 -2.7935827751885043 -2.0990304298079496 -0.9030906421829699 -0.7911758899733099 -1.4921958183424584 -1.7563003813735787 -1.9149127597009123 -3.928962562903891 -9.297572734581605 -5.889557447582295 -5.8276901317235845 -5.688807282435275 -3.2396937404019686 -2.2142091040966787 -1.5670624613485145 -1.7421456028034907 -1.2417646883992275 -2.191926563516237 -2.317843613474458 -4.882271412493153 -8.175428156611677 -14.015794843621443 -7.518250620746434 -9.644197219515123 -33.38998937981583 -28.835706509038324 -72.66560016135425 -30.38584306945295 -20.600418102554222 -12.841975668801174 -17.729934685208857 -7.022996187458117 -2.746728436940565 -3.9093369318603415 -4.702580005420482 -3.739245402306997 -1.5900232253377415 -1.12082955917663 -1.6629037383498848 -1.4199313983624633 -1.2970392835725344 -2.7544115962040285 -2.152414405886868 -2.808934309137617 -4.300752539973365 -6.372614746322472 -3.4047068621275973 -4.954398317715172 -3.176010839042536 -3.2479774534920396 -4.702185990357408 -2.9380558703657274 -3.356434468272392 -1.9133747269727135 -2.3904037282324393 -2.706142284661406 -2.6931246286479005 -0.9536564676091911 -1.3956365603084913 -5.646841671411327 -8.435450080672164 -9.068380471611187 -15.63444621330015 -10.125506106053422 -12.194776854531137 -12.386331701288357 -33.56408573191821 -7.016714048198707 -2.307468283899219 -3.75534348185952 -3.833477693252622 -3.685894253187519 -1.1786876265504078 -2.2414597321094885 -3.524603777047375 -3.8290248070690662 -3.205916897618336 -1.9105755626808578 -2.124964697274691 -1.6066772011548747 -0.6961091224356851 -0.9270685856478255 -1.1828176677033677 -1.559855993468461 -1.823976542522906 -0.7033316276695035 -1.3303522974799844 -1.8994742917739271 -2.8217123861418414 -4.32056542480721 -2.8432306639598677 -4.479170150088704 -8.261596224037477 -6.579130987247407 -9.790705008722304 -16.83801523731276 -7.721808903180257 -5.040191017319034 -3.393287481991764 -3.053468087329794 -5.124621013437493 -0.9675104122545266 -0.8652023211835203 -0.9771178206523256 -2.2167336794503014 -3.089914012561675 -4.604637025932026 -4.494173241445221 -8.099995534471967 -7.129862883514828 -4.803818280636543 -5.289757927387148 -4.428166075805311 -1.482319535309513 -2.1403279848625245 -0.908913667002507 -2.9693059570999476 -4.632534390324334 -7.342741083734194 -10.916985248872948 -13.447886790286331 -8.111114884163268 -6.252773278153554 -35.08962120497424 -30.735481119137358 -52.27800257658024 -27.985566284104898 -32.69629490480388 -16.27221174647249 -15.82259369547569 -7.016430250882316 -3.634632410150914 -5.0695199855491575 -4.179713633997333 -5.318054743795255 -2.285535847976693 -1.661114621970177 -2.054812931284627 -2.1406067742990222 -2.4088706359866956 -3.4977606003184207 -2.128306522140797 -5.728928957230386 -2.7401699096182637 -4.076321085531525 -4.424416809309224 -5.659776135831936 -1.4664561122256847 -3.820076708829411 -3.2067533655161173 -2.1510250444178762 -1.4586294812082934 -1.6588919768287187 -2.2248203108518503 -2.4867041561031202 -2.0499495595294746 -0.5766545980480023 -1.484255473319203 -4.136525048539033 -6.406104772804356 -12.447072788388425 -12.515423756569994 -10.882990241490537 -13.420532793844636 -16.58738036677092 -27.362596206420935 -8.127808827542625 -2.4566218096910335 -2.410343174205703 -2.0483963907533482 -1.567525924138943 -0.7770957894817743 -1.5874989133621242 -3.5526838324262995 -3.141173243359578 -1.9147916712479336 -2.282851038885885 -1.3698165000351565 -1.2133379603870953 -0.7819685711595444 -0.6709924856824725 -1.0986495708992376 -1.3504365054053378 -1.8589897381422384 -0.9965454574150743 -0.7835008497734376 -1.6589303918688771 -1.771849917941708 -3.3862896191401797 -3.4531522492344777 -3.8735051296864436 -11.384438470561578 -6.5338879403091354 -12.115619546131214 -12.289011413747073 -8.09554226856608 -2.737961142003275 -4.609236332371995 -3.8253123844227654 -6.6789444960144175 -1.276218656053717 -0.9546463796305006 -0.8307189784506765 -1.8043800316011378 -2.919221099305845 -4.5954421370209895 -4.465529064987855 -9.077859696317477 -4.356453043404306 -10.714707987626369 -11.212234940782826 -4.345268047402667 -1.491318633120407 -1.4055380649504179 -1.5368484619016984 -2.8938360890392447 -5.42485324156869 -5.617878234975838 -16.030358897000564 -10.05393955898073 -10.271241201261436 -6.786759875976954 -3.405649609097566 -29.046848419902833 -37.46611247471894 -40.191147767008644 -25.3595217220135 -13.367755020630094 -12.849080124879338 -8.59279125232018 -8.136797541835973 -5.424023411837761 -4.775558965820931 -5.150067776450165 -2.06236176142904 -1.3171351709379422 -2.4586452688446214 -2.0077166609100274 -3.5873737459144377 -2.32084713912415 -2.917860679897144 -5.181090126418597 -5.305777762886266 -4.991009288973957 -4.251948782297433 -6.807046151365507 -1.4172842356556392 -3.581242044695756 -4.287359119947881 -1.6614456642156703 -1.1435676847445022 -1.227263250634701 -1.2103110795536847 -2.439470504331026 -1.4141490201517497 -0.6158909646800881 -1.7775266965952208 -5.5280231235094615 -6.96383759458768 -10.587126645115928 -10.663579212041471 -13.31036924495416 -11.774974383633603 -21.796165483419426 -30.078917978124284 -8.679490013599777 -2.076288311253103 -2.788885896259975 -1.988136077779286 -1.3820502573457298 -1.094614663412079 -1.4559996033484 -2.079178739330679 -1.998878232396425 -1.5868385510895286 -3.0570131954826 -1.2151894862759343 -2.049881476216056 -1.3470384709426746 -1.2330443401650708 -0.8499743376397104 -1.293981793685745 -1.1009847376940192 -0.5186182547215882 -0.5951279172282623 -1.1258421640390597 -1.0459957601509273 -2.340025188706009 -2.89862821414264 -4.19444927775052 -7.626629541954278 -8.134302148720819 -9.739296735905175 -15.369602929972581 -6.681210908452139 -3.9071207818837563 -5.762634950764634 -3.9882710354416253 -4.189926792930089 -1.8688110399972009 -0.8266853988958327 -1.369801058478298 -1.8653108338111182 -2.3155949793026105 -3.430651668659249 -3.4130034100871867 -6.352072322052492 -5.329563432919802 -9.262106021569954 -10.405101471828324 -7.12673113800511 -3.177162927562916 -1.7293443704711295 -2.0830339356790764 -2.9448769906765078 -6.497419339014062 -9.863014365961616 -20.225511061708715 -14.186114267952055 -8.248081944534066 -7.940469495613434 -5.623357887352631 -3.201126048958331 -23.651717153390628 -31.539512460875795 -14.216038980134899 -10.517349360733027 -13.972168956980987 -10.459694391744707 -8.267677738650752 -8.963448399000436 -6.744879817182731 -4.761175094249656 -3.6882676827951544 -1.49241833090441 -2.9180793647556746 -2.9808744081340186 -2.7431837715289182 -2.570193153358767 -2.870239128169845 -5.464026512682719 -3.830653568562402 -4.7073502124855695 -4.901128817417724 -10.20594442061612 -3.6542918330143297 -5.239930777477665 -2.2512546384449594 -0.9588744544689375 -0.5793107791959307 -1.20468157639985 -0.9466518591748647 -0.9063588876593877 -0.6199210089175717 -0.5024517783061182 -1.6428168865434123 -5.09727372158788 -6.8836397354106715 -11.3939098499146 -14.225788043508414 -19.847800823448605 -13.193957508745587 -24.39988976096209 -20.615322909519808 -10.489988500855747 -2.195627363738863 -2.82006371209899 -1.401400382832928 -0.569658266518711 -0.9513293424451285 -1.4172312564723486 -2.0603260099415803 -1.4508140539292242 -1.1203553964864021 -2.3597592464141695 -1.6084231335555117 -1.0289109662003206 -1.8720201986232854 -1.3685456610709281 -1.4699368518327667 -1.3098731652589544 -0.7377711881276529 -0.4726575031036338 -0.3550202790502771 -0.891849366613886 -1.2639211773482188 -1.3398619814118955 -3.286832033191292 -5.5014570501814 -9.538296912546196 -10.482579592090186 -10.501212360859359 -9.090750281770138 -4.0510648465265096 -6.108988395871641 -6.119162817256925 -5.120432423275691 -3.893856020908312 -2.9655603653284595 -0.8538868775463625 -0.8818549248311265 -1.8529760047904698 -1.6350882687355164 -2.989889713858706 -4.604329097955426 -5.552394234891681 -7.28538600507303 -10.801050364101714 -5.450994016598301 -6.038891408277962 -4.213697445450901 -1.9078091980942227 -3.222374825787433 -5.640933232968271 -6.798123662750519 -9.226296499004786 -12.253484801381447 -13.377220106717685 -10.230618459228658 -6.071411974735125 -12.54049679775689 -5.496549864815288 -3.8698383647479644 -17.798291578613497 -9.869858251329326 -20.706675381321556 -9.40052035693272 -11.083195251043355 -4.358012135223985 -13.32592785404993 -11.85484103372486 -4.653910773680777 -5.108022316903936 -2.0819505260937192 -3.652015242146827 -3.030002877689455 -3.249691406270896 -3.3228731977604427 -3.139475496475884 -5.878082723027809 -6.7158939575681 -5.156350929689759 -3.2560941638824037 -5.968522599157024 -2.3016708710115927 -6.120919429249354 -2.2491447666492217 -0.9506112658875085 -0.536081457896106 -0.7561681798390638 -1.1397238161537915 -1.0657273132539358 -0.8948219801356794 -0.5523865237806842 -1.3127217756452894 -4.397392884161557 -10.091745497273653 -7.565868980926743 -14.774873658017903 -19.355040986235423 -18.282225888531666 -33.47753026050567 -18.473316354548622 -11.771658175367671 -4.38915594845575 -1.5186676739992373 -1.1188531238391812 -0.8039162128003331 -1.17941829953185 -0.8888213659270939 -2.6753021801789085 -1.555856459074433 -1.0181950252462586 -1.983961481049774 -0.8679624153961985 -1.4499604600688003 -2.5194385863305135 -1.2232292081229061 -1.2145536366030971 -1.3470878103085722 -0.6660671231416431 -0.6531617130503076 -0.4634041698667528 -0.5965177852469443 -1.1376446379449732 -1.964565354413291 -3.8316753674467203 -5.871358031237712 -10.371686400903842 -6.398387129477868 -11.200778355747861 -9.385904505973981 -4.858021844202924 -4.416958440904579 -7.264211239034685 -6.526553419121169 -2.7367488901987 -2.1781196588862395 -1.2026818611220684 -0.9107780660733502 -1.132794756787489 -1.5048427934135165 -2.745453345010958 -3.7844127104380174 -4.086872096057043 -8.64507560468908 -9.021959804769523 -5.121103103973541 -2.4072136419960546 -3.589168127929037 -2.173419449865108 -3.9672018506099676 -3.746042447943929 -6.4055586527051265 -9.171310244604397 -13.7702240529568 -16.978556787641445 -12.87199265883171 -9.941653341849745 -9.618808907489798 -9.309464358832486 -4.760882821856833 -1.3653978988467068 -19.536192966659492 -24.747278623531592 -8.372406019761753 -9.31542968255029 -8.032238287605082 -9.872438562527988 -8.107904675062324 -5.137640435987338 -7.182721643505818 -2.8065804300039088 -1.6769336849432426 -2.570374536513651 -3.547551333047214 -2.259021549851288 -3.489624899969934 -5.577838558979591 -4.9829134922689855 -2.9668680771116347 -4.172643646259249 -3.123022981426789 -2.7956074434719222 -4.738557900073309 -1.9138376940275275 -1.1758700943757927 -0.6690189639503985 -0.4175542903464565 -0.46604023014348994 -1.0547302761566884 -0.6857076065421416 -0.455812785399985 -0.7639461048758305 -2.6786961329345145 -5.932926455443066 -3.8609219905716 -12.10324991663943 -18.76979281478518 -17.848529342423106 -34.683384129932065 -31.1160237885668 -16.68377061769366 -2.8558920919376476 -2.922467249205484 -1.5477208343513962 -0.6768695096116766 -1.1313916257661731 -1.561053814049392 -1.1641903858961975 -1.2738905225787718 -1.2226143887543486 -2.1369683918449205 -0.8513582771522249 -1.9209956286269276 -2.700385213013331 -2.039063314640123 -1.3785623313722462 -1.1132484897346717 -1.7388652054006002 -0.5503331225915239 -0.4585201284593478 -0.6422140580351964 -1.5383033981955336 -1.5126605667635633 -2.8360750130501176 -6.5285693598723125 -14.025304733746408 -9.383176931359658 -14.114036581884164 -9.097642199813158 -5.295627119729442 -9.982119966013036 -6.694755679300275 -9.000834481461721 -2.649950915136919 -1.5837769346596744 -1.8624016556840783 -0.8938755406934771 -1.6728734986336116 -2.320494534847566 -3.4623631771907766 -1.8288976688360867 -2.8808945399127577 -7.434038293429511 -11.28700320351233 -4.50776639611913 -3.8025668743509646 -4.147224779751028 -4.4090207175901845 -2.594709550190372 -3.7726811241935607 -7.709688636642758 -6.315374154726421 -10.848341764110703 -11.710193614763357 -9.572000097238462 -10.761914252847156 -9.65007827344596 -9.192857578485864 -3.674792111787333 -0.7753550769009547 -0.616264959772185 -22.699878995928078 -6.7507642654535855 -6.906767578044319 -10.33591184926217 -12.908374118316207 -11.500320488906036 -6.646561201384747 -11.132951337859794 -8.043687503243465 -1.7009593791606117 -1.7415168631316893 -2.672375471727577 -2.4429548212564063 -3.436392609628384 -5.977353040153537 -3.3546119585521557 -5.323042329454658 -4.783084244676749 -2.4250432086365477 -3.6767754099532226 -3.5267836784925604 -2.913767161707078 -2.612451825496309 -0.6324948834740656 -0.2522144470087458 -0.15206572174886673 -0.5379228587920806 -0.4965246794298857 -0.4857420886076647 -0.948875494073785 -3.023226187758867 -7.2522171867988545 -2.977620553893797 -12.417859692016199 -15.975014657819624 -18.788323912760504 -23.86209585749794 -41.47632150637763 -13.983703095439097 -4.392079721835773 -3.813649435198758 -1.4332359936879282 -1.0634743051289113 -0.7758965362949624 -1.5165547190889084 -1.4391373529499631 -0.9925937777876553 -0.9435603645749718 -1.4147194987919922 -1.0005780428698525 -1.9053954018766952 -4.073576549694378 -2.4514934397188486 -1.8516221182763333 -1.0676117249403891 -2.6426843119127814 -0.5662245796765429 -0.3410544800161887 -0.7075335869008262 -1.8443478919243024 -1.4403774911821012 -5.636578562647438 -6.428067124813747 -13.006064338910221 -8.322502401620396 -9.274311554552842 -10.06336296607246 -6.200222282483937 -7.646483631900833 -11.498303385172136 -11.501429578563133 -4.426991219019167 -1.7068859473042357 -3.5274601039884996 -1.2295778478597492 -2.4019896470209052 -1.4224107519125921 -3.0915039243441087 -1.9652590560400371 -5.8113517492831726 -10.29726998437123 -9.455571373077015 -4.113002825761522 -3.9773132593371687 -5.268083259963183 -4.845354402376265 -4.162073086331623 -5.913269625783353 -9.323312818262108 -6.635130216564031 -7.320010706770608 -12.775791832055393 -7.4928912719834 -14.33271721006136 -12.16217534202157 -6.259258479099643 -3.5067555605335774 -0.7492063851273335 -0.7492072008766012 -1.4388604612233016 -9.60873479849502 -7.216790025806269 -10.351650216532239 -17.554677347258387 -4.779977024469189 -5.673183036714254 -7.001405720259277 -9.874119404839792 -2.204001947032378 -3.41200708618656 -2.276055332610092 -2.167680318319031 -3.1771041538296054 -4.8923394600000645 -4.373756105002493 -9.058724874560399 -6.019832046403512 -3.5009100535882998 -2.88778761640154 -3.325475449448605 -2.530027817227464 -1.9587593410671196 -0.6219860285173135 -0.18810059785278618 -0.20985899628019533 -0.30137791148019194 -0.5761695563034737 -0.39041021862819403 -1.015815389892229 -4.484399941853507 -4.598032529479299 -2.229401845563392 -8.075365082852757 -9.750917524196522 -13.497336337380261 -38.519488932497175 -44.25716274112207 -17.07938435944443 -7.342721763624953 -4.435370649587247 -3.0080724430753745 -1.7211375275612646 -1.4528443887112679 -1.5263083181109676 -0.9791197492108367 -0.4275708727044015 -0.7985215165349147 -1.2418607999154898 -0.829901821414821 -2.2087523324998375 -5.793041792151893 -4.653512125078054 -2.5094969266356535 -1.4112999663785033 -0.8864426275803352 -0.8832890033227212 -0.6283339242361855 -0.7391815801431333 -1.360146761584321 -1.3960905194533941 -2.83478923661946 -5.8810315764536965 -11.993341261254875 -4.604925636261993 -8.655846483486833 -7.750023562035743 -7.517628844800029 -4.981529076075303 -6.850393423705629 -18.82352942404981 -4.995313045266127 -1.6104754449162355 -2.104833142567022 -1.9858646243671958 -1.6621750990991333 -1.3325877385016074 -2.78182647975852 -2.347309877800565 -4.2247945367180755 -6.528253099029225 -7.840718851754317 -3.90722238478917 -3.632338319026414 -5.562411451302389 -6.007779713746997 -5.018632586898061 -9.486677813431424 -8.181287543868569 -5.785804473998766 -7.111226020973042 -13.15645664093733 -12.868788671901738 -8.827144846736887 -7.844192061767 -7.625984008893592 -3.3335181170292647 -1.1797693535136844 -0.8725480358228963 -1.0060543661756327 -2.6151429417640824 -15.847748473663707 -7.1620554068624545 -12.595362534669551 -3.4590701353986013 -6.862016502805414 -4.846471714915483 -4.695122681748182 -3.456066457441526 -4.052818424177087 -2.4679899910493015 -1.2174019112357328 -3.371210186403288 -5.7083672917376616 -4.313278286660079 -12.386313770216589 -9.854753898400581 -3.8028495809339344 -2.436583749136557 -1.9911871147974045 -1.8573593985599957 -1.856360429205526 -0.8646885852009603 -0.18170662413187716 -0.351388820012014 -0.33269458024272025 -0.8914155590468433 -0.4951344276830878 -0.6428733558445211 -4.358180247229769 -7.998358395943295 -2.6369413489356117 -5.3001042579234365 -8.572622823301089 -6.1861634607790785 -35.770648449511405 -46.682881998072304 -17.787565406243303 -5.503329306304992 -3.9035070511675602 -4.577700187508653 -4.596967738296056 -3.5830815568218717 -1.3210505786292444 -0.5464575890318376 -0.35115149330743683 -0.6399318710986758 -1.368565412890804 -1.0996641457143108 -1.7947810025180382 -4.4502859931766885 -4.199343207005445 -2.336106011299321 -1.0647294601882922 -1.037963213412581 -0.9281665533413667 -1.5808405213060974 -1.3064616757075123 -1.4537994762778605 -1.6549768261793363 -2.4880962291196993 -7.15437421675182 -5.144604022260929 -4.2052116864772096 -4.771181140311283 -4.832607138913772 -9.540209830102704 -4.355813653216182 -4.98014372013949 -14.633436370902173 -6.926531027866121 -2.963118604994217 -2.738534821153121 -2.2132301470778253 -1.615554552294164 -2.2471191478768073 -2.732871577961649 -2.6777310562953294 -9.051401141020797 -9.27119129136883 -14.586522569090913 -3.0279869147314287 -4.964769710568744 -8.25809422056032 -9.212133057589455 -6.293513808145438 -12.398654574931594 -7.3994740501429055 -4.383211042098909 -11.84655987041208 -17.75337235846234 -10.304614313278256 -11.385228096578018 -8.94327916179105 -5.5655035793885395 -6.175390938644912 -2.9260106779156185 -1.3708147391061214 -1.7246265354122683 -1.6884007680608362 -1.9920616835645166 -11.412503502139193 -7.814818963282524 -4.020708979504001 -6.204887578708615 -3.7821693969994414 -5.348307875532426 -4.531556938493045 -3.7582113181950088 -2.97665618978538 -2.0266842539536434 -1.7764003842267884 -3.4533675802472388 -5.649087674183697 -20.479125248995835 -10.099814837486392 -3.8607762401226506 -3.5030363027230336 -1.6160454810103486 -2.783449903419987 -1.31181877196563 -0.9325876350492199 -0.26417144049085517 -0.2483927325857365 -0.48056622857163234 -0.8824283088536412 -1.0080000336474195 -1.0234846233279735 -5.128388490756673 -7.414363352147754 -3.0145225561536324 -5.561616484630805 -10.157000093871206 -10.050196373476375 -29.845206191023763 -56.11357088300625 -15.179879099803147 -4.401879164928695 -6.848717838557555 -10.608848032392123 -6.279530117687375 -7.757090933155712 -1.5421602559520016 -0.4415736405274406 -0.3969924554385027 -0.7352916534698853 -0.9116741850484699 -1.702515878081198 -1.8115404947868594 -5.974514722891021 -8.528477268538449 -2.462369352313839 -0.9853924946537843 -1.4203144491197799 -1.1799104651396048 -2.103357291744 -2.7340807948687775 -1.0257230656309535 -1.5342365620127925 -3.1041360313344044 -4.925872921005434 -14.243511377029225 -6.687601542116242 -3.857575593601091 -4.571908727790771 -6.577150393836525 -8.374893489773264 -4.08319875945269 -6.581223241970836 -6.510486608146789 -4.709814296227621 -2.8883599960303825 -2.354078098472987 -1.3938368685856104 -3.366543988141481 -2.248203164447044 -2.917163318467652 -6.835125151409866 -11.422800708211703 -10.391578812305813 -2.2175604684955696 -8.503701495342805 -6.878241228463511 -10.345163270161235 -6.99181094345512 -12.666748837921661 -9.416234176005918 -5.933993909629964 -11.005386762000063 -16.771391789160667 -16.632304877216377 -13.742221190428817 -18.5143437503384 -5.906378647069008 -5.649771681303708 -3.524150470520071 -1.6116130545956264 -2.2538833306761155 -2.027217725119192 -3.496848543506662 -2.0772767828848644 -4.560890269084701 -3.8455557258851663 -3.0789831084600996 -4.248579277474056 -6.167761391160954 -3.962375367814137 -2.3858067148158497 -3.056529445039104 -2.7275475047852527 -2.209052481549088 -4.293960087274239 -5.173395855110631 -8.956586184744339 -8.98641730364564 -4.502100119097544 -2.8006720782404653 -1.6118186928862015 -1.527539430344498 -1.7172706805000053 -0.7986334309494769 -0.33734213224267723 -0.22956100910421542 -0.6858161016558671 -0.6099677972353157 -1.1002758548556348 -1.3598862650927768 -3.7072473628429137 -4.349613648914493 -2.6279002740361825 -4.9923569678674165 -8.855372308170839 -8.759022346482698 -17.068417324976412 -44.80140222134935 -9.732091339349898 -7.175837001885704 -8.121188101777047 -10.809478119713066 -9.750108152238266 -7.879147372198753 -3.072929765356834 -0.5397390832318069 -0.290738044050135 -0.6267271982812574 -0.8088071923266974 -1.6774223347726416 -1.6728209208350329 -4.795207472890958 -4.0707099722050195 -1.6148806908231264 -1.5517514547719724 -0.6016371543588679 -1.214039640256809 -1.6957749319232975 -2.5037623185054474 -1.7780060863183225 -1.4807855126185405 -1.6894590358823949 -4.49885010541671 -8.638688925359407 -5.685396719490651 -3.641571257254481 -4.479848051370908 -4.9059264945676215 -4.864192189955074 -5.181291833181958 -5.236954061398205 -7.278733369221725 -4.33485477015644 -3.6170920994509093 -2.131674630214294 -1.813205139891258 -2.154578315442218 -2.245190593544555 -3.00532432307991 -6.704881349544161 -22.55006124216905 -10.844770655564831 -2.6729461773904535 -12.019644734137536 -9.813166216595473 -12.242676735839279 -10.94940099061345 -13.40962381808883 -8.483162773818119 -7.72230875107265 -9.744807755692904 -21.1607617736203 -15.399832143127549 -20.065583257491685 -17.336879948300584 -7.0158968450772194 -5.678944785505138 -6.186106806379143 -3.13850738237754 -2.1882693268794373 -2.2480636480973524 -3.499877146245024 -2.72558670377522 -2.8354238824390907 -3.033776208040222 -2.58920975671827 -5.050208128361683 -9.197670349194052 -5.952382529702321 -1.6753252757565404 -3.053683905116764 -4.164074518359373 -3.497202326769795 -2.5653786479003906 -7.149480248476319 -10.529520954104209 -7.2588049604362 -2.912310658451827 -2.780600466126398 -1.6727725978739376 -1.5170882940181123 -1.215724062766072 -0.8373588957734928 -0.3105858114549728 -0.20164347456092097 -0.6668261180973308 -0.5434499414526504 -1.1809442598367097 -2.386110840689926 -2.8126461561861555 -4.434534596527628 -3.560161803626534 -5.367429471051615 -9.56140556895546 -9.718972651399833 -15.546730888300477 -21.063206660880724 -7.792721745029398 -8.361341017855132 -6.37913581065322 -15.16731892462348 -8.637675245498752 -8.262770870895787 -2.2804128614302583 -0.6640183103220719 -0.5185321811133756 -0.6686339637540878 -1.1447721537211188 -1.6401234372771738 -2.207379471031516 -3.9537812511843105 -3.083241968731378 -1.2057196231786158 -1.342856168919014 -1.1264089987187142 -1.264079220690999 -1.274138083959344 -1.8209944337907473 -1.769596114438857 -1.699616481510935 -1.767867452438454 -3.319592808235763 -5.358732164840356 -3.1862214708213177 -4.2746884017696924 -4.5240040455610275 -2.4788627052207812 -5.247592927455279 -6.482258104060724 -3.1155259669017745 -4.534272560667072 -3.599359633977448 -3.064509064182539 -1.6591717961858212 -2.606146184824341 -2.106128819524509 -2.101751528652914 -2.1595102473821233 -7.043214288982378 -15.98637988927534 -12.220412349931097 -3.1318074598947145 -11.374726496058061 -8.086114561915071 -11.45564821921057 -16.684878517499772 -16.563301748451792 -7.630703604875916 -7.000649852987695 -4.592084611940334 -14.855038893130024 -25.044369023480336 -19.90477254906671 -18.762124322491076 -12.359578076211873 -7.576494946877029 -12.50283804429088 -5.7786037277680595 -3.7395738828505554 -2.7896866335479293 -3.324034298169899 -2.5881556098574556 -2.274484394097746 -3.7411277572849433 -2.1024288692227504 -4.978034708900601 -6.559713157810803 -3.2515463760239625 -1.9591692536194312 -2.7621944707495714 -3.399017344209273 -3.71442600544201 -3.937905761179877 -3.320798282633125 -7.040511225172921 -6.616837941925883 -3.6529825425863867 -3.2295077012133326 -1.7913735524549002 -0.797678849392948 -1.5501117536401896 -1.0837934277963253 -0.20493960930365174 -0.15061271179426758 -0.49325918205215535 -0.6562940143844908 -0.9951002937196533 -0.8624973123005952 -2.424144096760667 -4.059075507721132 -3.753249750151812 -4.281622793807894 -8.950434904589118 -14.521438500773215 -6.3116395645502 -12.777123045562222 -10.283047151146096 -4.472653857580527 -6.588826917718494 -14.044755127032401 -9.7646551982324 -5.284518805997275 -2.8681776807772783 -0.7177937792678126 -0.7544796622298258 -0.7680692974872737 -1.4702726574785736 -1.7854135766181776 -2.3646667031164026 -3.152605310977375 -5.108646192305241 -1.4121252708473457 -1.3330074709115332 -1.8667642869673788 -1.5841223506345803 -0.7015903903408529 -1.0970284839411721 -1.4994250728020233 -0.8957633522083028 -1.3634204306638884 -2.3106645360382334 -6.8056925252583 -4.714956519073275 -6.333863184362366 -6.296661443660446 -3.056634984241136 -5.355946873948274 -5.250569220353482 -5.592625774585318 -4.5824893336744745 -3.8619875916659145 -2.551959600570251 -2.137545359135938 -2.7384892053378374 -1.3800074220443201 -1.236639557779594 -2.4755858779009237 -4.550756546718834 -6.479758837279433 -7.7696889181939275 -4.9572179864754835 -6.581779283815366 -10.87109705836254 -28.101587314869374 -18.381242252326416 -18.91337361765561 -7.731342476672087 -5.288564727564963 -6.327198312481467 -17.346284044383314 -26.839855726070336 -14.114465811289369 -30.538632382995786 -14.281725105327222 -16.27229737801885 -13.06566270285563 -3.9414449091748307 -2.981619281541357 -4.96158438354736 -6.096045567503887 -2.817991060648095 -4.236421420982443 -2.6666623218227685 -2.3333552546994523 -4.867419993434468 -2.7357106732497942 -3.064584735225381 -1.5274835998707905 -2.8781438532946657 -3.65615395051236 -5.090611608032792 -3.100722499363253 -2.483164707307761 -4.468452681777301 -5.4264247295072705 -4.496605564172022 -3.2427848187721233 -1.9453372785039011 -1.3842740557374842 -2.1555549683315807 -1.4000861587722924 -0.2229203960555363 -0.16836173484612962 -0.5098563012833307 -0.9232299076565135 -1.3572607706898872 -0.8421726340124155 -1.5538662166314636 -3.878124431726792 -3.5589396664103012 -2.846922218612157 -10.749561340679588 -8.444186659433761 -3.271658596006987 -9.117930220608558 -9.717618291157075 -5.231359223089943 -4.142078674043619 -12.287212690705555 -8.335398464928149 -6.097623264814929 -2.2725011519118574 -0.6428916944720545 -0.5774286918457187 -1.0977781313320816 -1.2987690506850857 -3.358544614857401 -2.8526923801510633 -6.27051102032901 -5.5305194851247235 -1.397463709208377 -0.9218439525434017 -1.324434768098566 -1.3400327542996355 -0.7423237656797576 -0.9553506761745748 -1.1809317196615923 -0.7652267867982337 -0.9225264975719816 -3.0230487650570765 -6.526092899574134 -4.069210687081431 -8.701960721003093 -4.916401683988562 -2.793281863333736 -3.350303621490689 -4.607699472334403 -4.3833302101099 -4.160706778211352 -5.817968629413193 -2.1882309963371442 -2.6842548786887304 -2.6307350925979125 -2.4670672160924 -1.450859541191758 -2.894451149774139 -4.304872388863932 -6.385145488700247 -10.015529306704353 -8.680501721189035 -7.531827333531395 -15.561170829534435 -20.02035794618475 -17.005667981687047 -15.339974650787394 -7.73068832212426 -3.6388294480471335 -4.938596663523687 -13.538327416971045 -20.521190686883276 -23.939904462394605 -23.017486818623386 -16.558476303739823 -26.80287719898104 -21.908245537221223 -6.225379117334404 -3.952224420142079 -6.901157065022589 -5.538470408717767 -2.95376916037641 -2.887015396527841 -2.4463868552144756 -1.5207911035787158 -3.2082803643145468 -2.658426051283094 -1.6585647856410946 -1.7152851467997083 -1.6311080763962038 -1.6998595323299313 -4.816755985912531 -1.671944910251757 -4.064845616919355 -3.4070133987203635 -4.275999394605833 -4.483878736387826 -3.885145991444064 -2.7265997102866595 -1.5628612005901241 -1.780092835159287 -1.6574098193742104 -0.474023314787805 -0.21402022077072366 -0.39872507098796356 -0.8796915658235982 -1.7731340793793218 -0.7641901733755625 -2.1541875459103257 -3.873314789627367 -2.4243756606225175 -5.449488397969656 -13.466126199122025 -11.160657847024137 -4.073203737031131 -5.582952475603653 -6.486400616739037 -4.4943288303636635 -5.74464451425113 -18.381711959656883 -8.07273581862023 -5.206195803313955 -2.230659902961315 -1.3196535992923233 -0.6562475608765671 -1.0193915670739802 -1.7002755726503829 -2.127982951843606 -4.368717036534564 -5.547234256634168 -5.542559724691847 -1.3896468677561202 -0.7564704684302762 -2.6391968212904318 -2.4295608860287365 -1.9591785176868561 -1.1539386236808435 -1.5308970350369484 -1.3170375836054682 -0.9846719983749976 -4.739689358537602 -5.031721834206219 -4.614731498443337 -15.216986439101635 -6.654378465269146 -4.961857666394442 -5.121616834360443 -6.590311293300129 -4.934450531802364 -3.4465702086226417 -3.8188046091057006 -2.8232146827412308 -3.7151968215665034 -3.9196906009176757 -1.3825033705375387 -1.6384350246751895 -3.7550617272725755 -5.615881966564797 -10.542215163569244 -10.444405085006759 -8.722190021145744 -8.748581568775213 -14.954988684085532 -15.370435260885422 -14.604049500929731 -16.059473827311344 -7.95791295426308 -3.3096247864353736 -4.616535363162996 -17.544542945336598 -17.08419788525818 -27.367695868303414 -24.49868153737069 -17.993715519281345 -23.783932067654643 -35.13222444745253 -6.117392563491001 -5.402715376869867 -6.3638210313795085 -7.228198531154923 -3.3997075004697703 -2.65730358358272 -1.6030723934886442 -2.041668122107081 -2.481666142632028 -4.521086069351806 -1.2811512720903178 -1.1955860735467363 -1.1909430347227568 -1.2983050627076 -2.7129214121193885 -2.59817316640215 -1.7575174796588617 -2.5011019203688987 -5.087101863577881 -3.2134016537964616 -2.346411815780354 -1.7693715591178611 -1.9396412243105583 -1.8396877506770513 -1.2083571234446475 -0.8868530583692987 -0.3165878640187503 -0.31271401729833237 -0.4778521806278535 -0.9522932707424924 -1.1946007829287446 -2.053096295152347 -4.553891923024225 -4.042397621103828 -7.03355321261462 -12.954787199227688 -6.379648148543021 -6.852354580348446 -5.127102864247849 -8.574569387002919 -4.7423656188596475 -8.983612213872053 -9.969385941051032 -10.208606880540703 -7.15925266083044 -2.6932948084413426 -1.5159343372771232 -0.9372661271991645 -1.2914226509467335 -2.02256859515299 -3.0242417860390964 -2.962186088621354 -5.089207359481341 -4.505518876784706 -1.8026044267697592 -2.0257277776057294 -2.4475924844892054 -3.5572814398106964 -2.7181142503798714 -1.404532012258789 -1.320043301799241 -1.1417936587800817 -0.8921954409010688 -4.778442071129526 -4.83623356504171 -3.7128358764446046 -6.834035580648199 -8.944252249271816 -12.43795575569742 -6.76116956568309 -9.182815725313095 -6.939890261972542 -4.788451341869605 -3.5564142898621207 -6.981046710821102 -5.738209656311345 -3.6851210884207233 -3.0361404864146535 -3.3713664685282674 -4.1174288861416795 -7.179135174150869 -9.287686670792576 -6.119412989522455 -5.9819817634166625 -6.5783402017028205 -9.001539151917145 -10.729139801056645 -10.254078671675062 -14.302360999747787 -5.992997648420157 -4.5119109946210365 -6.688698631000589 -17.442350363696985 -14.180700133794156 -40.47194645574278 -31.605537336386412 -22.675101407819824 -23.308731018989754 -33.9338316983135 -10.286353633794716 -7.463926872727747 -4.802589947149042 -9.089214496425987 -3.716530376145603 -2.0058124632656193 -2.490869357838865 -1.5843801272864344 -1.236634246716228 -2.233597399790206 -3.3621659694098978 -0.7102926073573538 -0.8512588522973918 -1.1418770218559726 -1.0557708206157594 -1.782246232232713 -3.6002426708306325 -2.5595908582009 -2.280274758715263 -3.7744590166324277 -2.3509179636106117 -1.6953744912607212 -2.095301876221702 -1.5220863171938332 -1.398106584456151 -0.9811971584055594 -0.4539997277993294 -0.5078095076553363 -0.7518658371200752 -1.0126390602400086 -0.7031919265856728 -1.9003004175558489 -3.108926240696603 -3.3021596719697093 -4.741287069822195 -11.914646203509207 -8.538147258020688 -7.7026529929524505 -4.3879072921771005 -5.337334539117794 -5.296290064046625 -8.06518711288554 -10.40343112862573 -12.302402530228843 -4.716557195070585 -1.6634150612864047 -1.5723009305073838 -1.3516303436566686 -0.7353198997488725 -1.7666083278739755 -2.331921854440142 -2.7240861218086065 -5.390978758646863 -3.884635719015386 -2.078017074779489 -2.688351962552023 -1.8428995496278395 -2.280453964884591 -4.141076549656688 -2.4388031926224163 -1.5609794259010956 -0.9989211752435894 -1.6543182664870313 -4.0316300960406615 -5.707302307318643 -3.9131890685586046 -5.6990228520429085 -8.091676556557564 -16.754814072265912 -13.743707880421617 -11.424513773617985 -6.770719879827992 -7.032575160437059 -3.7698266663076505 -4.693368256516056 -5.349834488857111 -2.421643295500949 -6.452660454496782 -9.346595507656344 -6.7923622557714305 -10.76709311681217 -8.326099197607563 -5.24639650428405 -7.139554259007032 -7.073158792210538 -6.202661009523978 -10.410328684906418 -12.604206784162912 -18.931168425706833 -5.93846937838502 -8.532394772940007 -6.535709600789002 -9.544951196014557 -11.226081680986281 -29.111815384731788 -26.399895566756214 -16.657333841064712 -33.59950376944874 -33.835995712008824 -23.505341338442534 -14.933332212556019 -6.895749726217873 -4.782188563245183 -6.437109421312205 -2.754103600456444 -2.5706518375921923 -1.8687148783473424 -1.309604245379025 -1.8215990742378285 -2.404646868646601 -4.6741697250039795 -0.6219827881938027 -0.9014050590461694 -0.7294955337352202 -1.0135731357421995 -2.6884232367869987 -2.2120702810187516 -3.7904449261839197 -3.991053040517894 -2.5670241835889227 -1.1425651075234442 -3.5811121387323954 -2.8698735081284927 -2.1024869002911584 -1.0357314139043325 -0.5867168737472698 -0.6969815643429177 -0.40811473501263795 -1.2224237937434614 -0.7735412410498442 -1.2118620117542014 -2.0687276316818046 -2.9270493945544795 -4.120783270471888 -6.33980692354015 -5.454359110591841 -3.331923962920632 -5.991278255027627 -5.145393868813083 -5.2588865146996016 -10.471773025717335 -21.376282135073414 -10.61876913328344 -8.53776397864632 -2.2448529992392268 -1.696688667511003 -1.4304328942202358 -1.0994212388564566 -1.4632060980668808 -1.807579379400426 -2.6621524298458823 -2.84001095350049 -4.187877404684664 -2.389295628557929 -4.370591780530231 -2.8460690749790416 -1.8179112550544672 -3.8282375684454486 -1.9802181821965135 -2.5983679202940926 -1.6802333128066151 -3.297189330395181 -3.709048696215213 -5.815879967597031 -4.2304346156749215 -7.6094862975498305 -5.311529899584493 -16.947652350172525 -15.400656583126722 -11.926517862974997 -10.14962021790455 -9.787180748220955 -3.789336413357797 -7.311571043228991 -8.426816073144327 -4.583883111160256 -7.0445329946875646 -8.77117759178083 -11.07871036085157 -10.339603145615012 -13.05079604958329 -7.9280117410513204 -5.278600810821456 -7.865151479695953 -5.371038325050195 -12.661610633168404 -14.325840118624411 -14.196236431276768 -7.1092968858640075 -5.1073229328680885 -5.487188402300247 -11.518339938689264 -13.133455423189677 -27.199948129835747 -21.10290844214823 -20.5183439025721 -39.92810894709216 -51.19557121563585 -43.56135990131098 -10.30119584981682 -4.16022667641087 -3.734245057161287 -4.939844911690361 -2.739426887461685 -3.0700094369446553 -2.0507291321027887 -1.3101698030469862 -2.6190582380794867 -2.614716234194876 -5.31468181335598 -6.0348194225502905 -1.0904543180012367 -0.6249097409860374 -1.1281225249178408 -2.4619905021139123 -2.4767648554732893 -3.3503615193666 -2.5697298695007156 -2.1452797742762253 -1.3847051647962547 -2.4780085331810877 -2.43170743436707 -3.056257194214897 -1.4875692754881018 -0.7851215575440524 -1.2934097172446921 -0.6504940806534646 -1.1678367527776297 -0.7293268357642468 -0.7147922342608478 -1.7341296651957048 -1.8132347962099153 -2.4914686387667127 -3.0816583587626436 -3.545668976050864 -1.8334504530058486 -4.543269429506922 -7.095035646244819 -4.745873492183247 -7.824417247357627 -15.348738346882854 -13.607904823410175 -7.544619348461914 -1.4977276671234176 -1.6290645021802086 -1.7099664802692687 -0.9145464822554831 -0.8896600675195524 -1.227166408814828 -1.8978395332054676 -3.9791173914900098 -2.948747310199992 -3.2322420468454127 -3.8190265956820233 -2.4113767577007335 -2.2391019491644806 -2.457829805893191 -5.33765341420369 -3.533581970482355 -1.752869631158428 -2.4591989312115006 -3.6147150141731372 -4.4605228198025575 -3.539584242247042 -4.5731961317908905 -4.838824169618622 -11.681503782728019 -13.35261522504778 -15.835895847805704 -8.993714759099133 -4.787751289533857 -6.899261258354589 -9.221199452649492 -7.0841236033547785 -4.1236270544418145 -6.174199188800572 -13.66950344572591 -23.883393305102178 -14.751058226151054 -9.502927582640812 -7.20863781199632 -6.2594806519226065 -12.115459682804232 -13.219155881684339 -9.080928390024777 -13.093925539731682 -13.612092177544595 -7.33194260418941 -7.341303562123159 -4.45788306125662 -10.937960495802512 -8.15369220070784 -14.490743307004628 -21.573358404980794 -20.706368235014182 -70.54927762353218 -42.507818672025074 -38.911944710091575 -19.783256563960446 -5.710944391903202 -5.5283892319217784 -7.876411032680509 -3.5549051264345577 -4.5974619517895405 -1.9624331793987884 -1.9137489433685804 -1.2691927591744077 -1.874294034801924 -4.05037027795976 -9.037238789699874 -4.1747331414063416 -1.0350714935071976 -1.8370549726949663 -2.4047310810595053 -2.2039859401345487 -4.934933711269194 -3.28674097115547 -2.380937177377175 -0.9296614888563762 -1.5680865459878064 -2.4988620068011462 -2.2170604239898593 -1.8053794060714914 -0.9858202820538511 -1.136148500344313 -0.6710294906538463 -0.8444881003566553 -0.7306438804930716 -0.49085455099732944 -1.306792527393112 -0.7814568580941916 -1.7097730805300213 -2.7868737049571686 -2.2448907701826237 -2.5885217524586293 -3.09108919975008 -7.642223986718591 -7.625786990464786 -6.963060270007398 -17.63523849356425 -12.92023847941935 -6.6807342481388305 -1.7907568207023103 -2.1811300434636913 -1.4042371817085157 -1.1806220866717136 -0.7924491525536802 -1.0488832365534295 -2.4252658311612842 -1.931236781706743 -2.3162923281187604 -4.069553289653974 -4.198369997688999 -2.4475777786234434 -1.6128109631786889 -2.4678705218840307 -8.72988226381806 -3.290512998832535 -2.6115099018776746 -1.6282794169138703 -2.319297563363642 -4.26223229687816 -5.018198349880694 -2.5876963956039636 -4.421029078067148 -6.103483103152593 -15.900910301329189 -10.846722537045949 -9.442733818093053 -8.16043159993187 -7.997432121018875 -16.868653738570806 -7.160582499609388 -5.010323676895024 -14.150566267092083 -17.42971465382775 -14.960688081337167 -15.1364328707269 -9.989440476851494 -7.441442138473628 -5.901042164999167 -12.192761563022277 -5.952657035083436 -7.44094634780741 -14.996302586120118 -8.718513776870212 -6.501402993367734 -4.519396988412459 -5.518692841200555 -8.443294046912161 -7.623947576747166 -23.664908066612995 -28.449034731715315 -18.947907469446125 -40.07631973022911 -33.34203653077521 -28.151687334752697 -13.600071516625642 -10.828246133836004 -10.1214818908791 -7.6430504443062635 -3.3347632041280204 -4.281705607985773 -2.8173529107666258 -1.7068449566401511 -2.3591271398165166 -1.6934110390694275 -5.281119280787857 -6.595649100882033 -5.645067336890217 -4.5838173779212665 -2.4617143779600688 -3.791229984795796 -4.456035088210715 -3.3700061763403713 -2.26296794634709 -1.915908926074878 -1.4879783550569512 -1.974851506908468 -1.9668759762598251 -1.6890480659115346 -2.0467623079045634 -1.4772817800404439 -1.2040806157294428 -0.7067509161363 -1.083091600257264 -0.5981272348981999 -0.6443789338383507 -1.4016583788268393 -0.7891231429282182 -1.2483059085403998 -0.9663366103175028 -2.2334178199770576 -3.5011067166185117 -4.777654417282259 -10.078978348829066 -8.713347203073955 -6.359911854841905 -13.12885270820793 -13.379889913460849 -6.039461110952688 -2.104183141621837 -1.905198800585054 -1.2078796678762838 -0.6489044384638322 -0.8385096879580674 -1.5309154787997785 -1.760198065513726 -2.2018098945676527 -2.6822723907450037 -4.284891256808187 -7.836887820020142 -2.4788509501260365 -3.093698424611037 -3.5613992602506883 -9.844538262478734 -5.777950762351308 -2.78327802242011 -1.639026921901051 -2.3047801406549064 -4.854387480127662 -5.877673682337021 -2.4503011223149165 -4.52021929894793 -6.515275570023629 -12.007677526018341 -15.265565521457276 -9.267545572025169 -7.7085379665747045 -7.341295341492283 -8.699542542174116 -6.543022614124346 -8.602591501146343 -15.904598359928267 -19.53311733252933 -12.529910644660811 -20.417878029285937 -16.784857906748766 -14.541531567817335 -7.933733571549418 -7.096812438013753 -5.530027869164673 -8.514108729411713 -7.387463474823583 -7.11340365320178 -6.145228724500011 -4.996881429351312 -4.711287820245637 -5.970366367583246 -9.187206973909895 -19.497770158900778 -30.325819789217174 -25.769881394208745 -35.329145682375696 -33.67272354418533 -29.519514438141243 -23.747255214784033 -22.285382901102963 -15.051647626182532 -9.13632247761697 -5.300961536441655 -4.125043057240204 -3.125436406839314 -2.5958264465081515 -2.668020243517074 -1.373792979378285 -3.0770196200004807 -5.535579302578295 -5.56535692990225 -6.471446311614424 -1.9465395385753808 -2.275366565467261 -3.2280475601875773 -2.5518020025383468 -3.087321487330004 -2.9607598331767098 -1.7104028740657433 -1.4919906024724532 -1.7500260514639467 -1.9020669376304205 -3.42940102627685 -2.456056519141069 -2.3714317142997023 -1.147521156186482 -0.9519304699348948 -0.44348294044574654 -0.822666259782227 -1.3155095519955422 -1.0245058754816063 -1.9837764500981954 -1.603137809521118 -2.0336562846186523 -2.1562501480106606 -3.4837549722574286 -9.669039614963918 -9.031079464055452 -5.486356445146473 -8.982334254765393 -9.049751697040533 -6.813812096891772 -3.821125557693898 -2.157535232413434 -1.2652200424036277 -0.5835527943185441 -1.061134072492371 -2.323513625346806 -4.089251489291498 -1.5936468171225457 -2.9013912550476504 -4.812660968628757 -4.565560361609655 -2.513294685174719 -2.9894050884520413 -3.8324199525152682 -9.508657060271457 -5.513157030368454 -3.1910137259984586 -1.824334714438756 -2.3999249543118424 -2.029823336546366 -2.0374554790927237 -2.438783747126405 -2.1830506781435575 -4.338612411792259 -7.879703876359504 -15.97694900264528 -10.14257043345347 -6.263465156108226 -9.9275555038449 -8.468055319111174 -5.831927457472919 -9.65865145957608 -9.535768918575904 -10.314171671671268 -24.983385635436196 -13.414627251141427 -16.344713494704475 -9.583257515970438 -7.086642140746164 -9.246624510607047 -3.8369389934481335 -6.519905025481576 -9.13152668433322 -9.59288141866958 -6.686337310607078 -4.296752392685147 -5.111988768206847 -6.864369344805863 -14.474848029613877 -15.800293164067792 -29.91248309292137 -40.74705891382117 -23.58776979165525 -41.091279425508546 -15.783098447489811 -13.21606526794959 -10.707060351851933 -13.48836906637521 -25.207516769480886 -4.956151826638302 -3.7686601971512785 -1.6500647856957253 -4.299675687320204 -2.5223392536925466 -1.5092404730866658 -2.470723246562209 -5.182567583301662 -4.398918125930424 -3.3506007303856236 -2.5909678631882858 -2.814434379271632 -4.602176798502565 -3.7448660906217417 -5.913710606458845 -2.849125822208597 -1.59988755855561 -1.1848076018762463 -3.398314666319618 -2.12844929274 -3.2979558409760994 -2.2918788863688304 -1.9836139417123608 -1.6211495967376743 -0.8840753918338999 -0.762114454209383 -0.6376690633057883 -1.351151839780062 -0.6803173868003183 -1.7444061669302124 -2.1017234861646985 -2.6627478828067783 -1.602249698528438 -3.5291183217634545 -9.758441998959643 -9.367273532931456 -5.517614897832826 -5.6517453490192615 -9.92018116719123 -7.2805563278718415 -2.7537530171057147 -2.7677380373648073 -1.2178265681799447 -0.5109692082908512 -1.2275985207526976 -2.591528175691429 -4.457645749878638 -2.2470764760555864 -2.6921805802164855 -3.384220319509104 -3.4535571517099957 -3.0906244809756656 -4.441290309748919 -6.896287455110711 -9.481181411827075 -11.3519451523099 -8.909028286063824 -3.3599907027076457 -1.8253590134621518 -2.3334828292828376 -2.358237027173766 -2.8506935800151054 -2.019388131129544 -3.8502732769250483 -7.218929512646857 -11.830850248662717 -5.6294824128735845 -3.078556983721697 -5.98139137802402 -15.651153221654118 -9.308771350734572 -5.17519867116644 -12.288087480597255 -14.555113640323164 -13.84793143867849 -14.426474589525887 -17.983499786958614 -8.563000276903274 -5.641982620467932 -6.74042083199556 -6.373281297743616 -5.178169415551256 -4.768194898354185 -9.746088714417064 -5.925797475114078 -5.292587313060835 -5.79718119334156 -7.777104970797945 -8.438515239347842 -15.19753224448654 -11.915497040168798 -55.06510591860652 -43.88319433266842 -24.972467232124547 -19.04989367099535 -17.311988813670087 -24.94250505048817 -20.534386315544417 -15.635642052064638 -5.973772993928634 -5.471908443621445 -3.0392293521405174 -4.087203400022338 -2.448163788515626 -1.411819046307079 -1.6958652778799752 -7.159417299782093 -5.784729567903362 -2.1478482805443084 -2.221226236054025 -2.401690758572732 -7.602185715256247 -4.934086887819413 -7.685848744705554 -3.9348145237958234 -2.151824628115058 -1.8338227744340252 -2.4828009164222475 -2.362598578280216 -3.042043674359703 -2.7729764927806824 -1.780262479514815 -1.6588569362637668 -1.2180329289151848 -0.6028164774628592 -0.5536681983477771 -1.3967545621969892 -0.8665681648675267 -2.4233311573291663 -1.7146416399498905 -2.969438232005024 -1.7485063578821471 -6.105050715700071 -7.7704894570403065 -11.623112483770893 -7.999760646753709 -4.8560948502147605 -5.67849103812258 -5.090666104276022 -2.833199762231458 -2.7808163343202543 -0.9052002831732996 -0.7252302035943282 -1.8177393772888595 -1.694272177947491 -5.379008770447911 -4.260601715978404 -3.1436992903992973 -2.785635654305825 -4.312426939920621 -2.7212727025632137 -3.791950709940834 -4.142474906793515 -9.71019059910968 -13.090485414923265 -10.562794148751703 -5.460479742978791 -2.5972834110932435 -2.2084096151089745 -2.532991727167388 -2.8836862857685817 -2.0236893541125314 -4.948394025694686 -6.45446470760352 -8.50912105826304 -3.740314320086127 -3.8555607799278917 -5.7516039890102935 -15.76741265991235 -6.147004226722521 -5.822826439690555 -9.936807482065351 -12.23895780748156 -14.4323422220459 -13.964891044784496 -17.851968287194058 -4.991198955242227 -6.704113021616839 -6.913075475800661 -7.060747286141928 -4.677575016006282 -6.958503202830836 -9.882501032595005 -3.979010613277226 -4.684849837452897 -5.864292928391411 -8.765453594115735 -6.269169741947405 -12.875919326961915 -17.856476955124435 -48.343056347778145 -33.67720443288759 -21.497738948047257 -21.482575876712787 -25.021373100427684 -28.03168425528377 -18.725400996213303 -21.435628745004617 -5.846255510610365 -4.539404894866771 -3.598408194900337 -2.2242737782383455 -1.1885021246287228 -1.0644513635570327 -1.0011501707244836 -5.233392225374001 -2.9329442615379566 -1.807550289281059 -2.363034541007498 -2.217426479897526 -8.759198837708956 -4.469657584368577 -9.044390607517492 -4.395825561376989 -2.6279879707506244 -1.547346103828607 -2.757383055333229 -3.520109959183008 -2.5780840305382497 -3.063826791303298 -2.692204485364638 -1.529565350342509 -1.485933690711763 -0.8357022244035445 -1.1101064609115128 -1.7165735743907111 -0.6288919403618966 -1.4779527305615494 -1.443267495562091 -2.455574888135393 -3.059019805370411 -8.279374102512046 -9.459354015708275 -7.8219350122808065 -4.125440236132335 -6.613145895684361 -5.9981409061429405 -3.2811584425279965 -2.0757703455838508 -1.6096029423745486 -1.4842408944794743 -1.0501429396592035 -0.8264701725986906 -2.4848603148105415 -4.913969083412715 -5.034200454744249 -5.724115588057498 -2.6212015628225704 -3.6212420142010973 -3.7295285570934187 -3.723599780318981 -3.1024667599305498 -10.122395636320801 -7.194822845853054 -8.269629809035893 -6.384530635852409 -2.342286905661905 -1.5146217485148947 -1.6350554157582582 -3.6499815669260904 -2.704407211121685 -3.956889921433472 -5.960163349428994 -6.807959930929372 -2.6985387694516314 -4.573637095839627 -3.579673825805236 -10.280215088966651 -5.329615309038697 -5.153626859702108 -6.048949666081696 -9.198991968113166 -15.290924016524418 -22.845490858483032 -14.869108451985412 -6.847305789748773 -4.750476899860299 -7.937686473405908 -8.4556435988344 -12.521330037214433 -4.272776913634509 -9.323987553907761 -4.992741277177291 -6.0544426520529715 -7.789445592793213 -10.096337304247394 -11.920791333018338 -12.216684759083613 -15.644736792225725 -24.746318449505463 -19.22277455810084 -22.152731357660272 -26.68969422908449 -23.238989585472137 -27.561681179980987 -37.32314511564487 -9.222813877262029 -7.162083042052853 -3.8944797409615077 -4.766336524603931 -2.313995119122023 -1.4133676946171192 -0.7242948550924906 -1.3730232391886148 -3.4519059073433622 -2.8558465929474064 -2.124635010012687 -1.7332018253923112 -2.2027389007989555 -4.8076489829524744 -2.6341872425915605 -0.8026090667781511 -3.6193192241686094 -2.7370030659824214 -2.0570510642234456 -2.4137908631813207 -5.241393722258516 -4.603290787433558 -1.999999959919284 -4.105795836082196 -1.7705949764405837 -2.038822657995933 -1.1599629575944572 -0.9781468721780081 -0.9928516963253735 -0.5661781075650629 -1.168372506130507 -0.9185711374793907 -2.9224389618753843 -3.6377864746879607 -7.734474281832131 -10.462724521302286 -7.7221383015068685 -6.1253015310225765 -7.446717029028062 -8.232522630915938 -3.8850065388367674 -3.5382572095012867 -1.8964768689371987 -1.7199935554886125 -0.7037517865331814 -0.9907288536303577 -2.047349332001362 -4.533580296623485 -6.661160031507808 -5.7580826594083305 -3.861396785800465 -3.2801701593800687 -2.7117978826887996 -3.018167910037387 -3.2570234968011147 -6.0274442772839585 -5.961649550673999 -7.223221215388404 -5.948714443418765 -3.0023191854905544 -1.847977275943433 -1.940048836380205 -3.2928917824346264 -3.0049867218075583 -3.9051608059253335 -6.6027370910024565 -7.654718778099078 -4.2823934180363885 -6.523193847513529 -4.6037853506783915 -5.064813781196005 -2.2329835991581515 -4.919502473119279 -6.377758487409665 -6.854969629387566 -10.703797985195738 -17.917799366373607 -14.874256219248116 -13.701787589933554 -7.557209037485704 -13.132541475057558 -4.000625030033352 -13.898817783436927 -3.1892823151413676 -8.248998638042135 -6.666156917771516 -6.717000953696016 -5.748410465227025 -9.688422129420434 -7.276547315596028 -8.465332479280024 -14.124902331312644 -24.153142437137745 -13.505238616969027 -15.610379188462817 -30.03789338874134 -47.20055830335209 -37.338350004825784 -31.281399133095256 -12.69214800386331 -13.814708168852892 -5.246137439190499 -1.494370167556941 -0.861471121858202 -0.548737724003759 -0.7273357029709739 -1.045127893810411 -3.971835110925667 -2.2093180190504667 -1.5573750802009265 -2.3424327036876544 -2.2232035248173267 -3.6066494146630745 -2.7392697720009016 -0.6066403988026389 -1.4280387715154785 -2.2553608390684303 -3.151483015683289 -3.979868292359376 -3.5475358079269927 -4.111208693416245 -3.1749155142669236 -2.9532635458525167 -2.0288315284681113 -2.0304700933278266 -1.0095387101349091 -1.3496996429464543 -1.0745759733407916 -1.155341594213904 -1.2511207997870164 -2.532300137362984 -3.1518642093504416 -3.5896436754123977 -8.745208535248702 -5.431310415719552 -4.195309041060013 -4.1206549007356905 -5.057209684995682 -5.3257870436536345 -2.7778586671172043 -3.3606384135035943 -2.5074063132087328 -1.3536141224694407 -0.8680849103779248 -0.6224441181935575 -1.2801124876588548 -5.525059779583743 -7.307332049802208 -4.215234840701521 -3.6939247462188285 -2.565958594787039 -2.4904399000896364 -2.1214429396232375 -1.9841661841106715 -4.788830295927399 -5.339359082626015 -4.31322871412363 -5.728454150434614 -2.6632836896620176 -1.5347641355721977 -1.514219086946011 -2.05022071948529 -2.0663560542793014 -5.199140422593936 -4.923083427453467 -5.6366405029239335 -3.95454163366789 -5.482183044631095 -4.329783801940156 -7.243508226470339 -1.9992807764950769 -4.417218782757773 -8.609002881161839 -8.461020825159375 -7.116310997699587 -15.061002656544701 -11.184904287242373 -9.600932852258143 -9.457199201192294 -7.1054910475132855 -5.922697526965069 -11.55895504425068 -6.6005833469723765 -8.518076921795961 -6.180690263248647 -9.721281287280295 -4.860731132659655 -12.817613185606863 -9.165163582366393 -7.777796370309789 -15.562756496166605 -28.293035074258206 -8.923865633701384 -9.58490696573365 -25.345299003983204 -33.47393063241578 -30.32904259238474 -46.196497575011776 -11.883129297453927 -16.920202606716373 -7.613713984272723 -2.0834503094798156 -1.3215985001097599 -0.6724613201670071 -0.5537136125735184 -0.831533328700294 -3.925872739201006 -1.72967533842497 -1.1975752136266853 -1.9399789482924266 -1.6836313227080164 -2.3652085610964377 -2.4915143642397215 -0.9623612408174895 -1.0750810052279796 -0.8971404903941946 -4.22995615809571 -5.395231025264306 -5.895196319997023 -2.9710809836885814 -2.998992902603046 -2.4232336247633173 -2.647947870333097 -1.1779021732992285 -1.434200985023836 -1.6354775530466548 -1.8688413040323102 -1.2117421299143571 -1.203694302306045 -1.61342033131215 -3.737000989007959 -4.760662695160779 -7.493583943990795 -6.208538293406064 -3.2784403102019204 -3.641300169609664 -2.3887790057408482 -3.4340264773888536 -4.576250619411376 -6.823592388362517 -3.915677715877313 -1.9419743274901289 -1.3275562876689566 -0.818878854430832 -1.338376696393951 -3.002257528102959 -7.396736921233169 -7.832386789966289 -3.335952838364934 -3.4133813184388284 -1.6448473106652546 -1.3614491203637664 -1.7136118575404933 -4.6940619921865085 -2.0068724940983 -3.4238114274983227 -2.0576580996441307 -2.868295424029003 -2.251759572082732 -1.3227697808557182 -2.5692087741906855 -1.8517621368607455 -4.957549120788177 -5.66468414731108 -4.3559225873043514 -4.9171444994417 -5.152780827204971 -2.860274444900437 -4.266222529539659 -1.333990400511452 -3.1460178744136256 -5.996276439636522 -7.365339226726611 -8.407666656464482 -9.203000117460558 -7.738494482786561 -11.286094658918143 -6.2242567147246515 -6.347242271478763 -9.212132764780058 -11.02113972231863 -6.562440869364663 -9.049869230236421 -6.096032061643119 -8.991951864478883 -6.922997811214958 -8.184504859235126 -11.2191972537273 -12.08467348046197 -17.88043399610594 -24.990714358991173 -8.87538875896697 -7.822268344779825 -13.52111210971788 -22.939383915279457 -27.97752166758854 -46.177712746258464 -5.360133519854131 -15.107436540498682 -7.942823353166826 -2.0492712902601813 -1.1987557963392972 -0.9554425985973267 -0.7538221606414302 -0.7311875595876645 -1.4157785641290512 -1.9752996208379867 -1.9491619680217929 -1.5871874184611634 -1.5582253389406768 -1.30481884746865 -2.775680690747148 -1.19054764922581 -1.3540707520968887 -1.058771537077564 -0.6618966071045834 -/ \ No newline at end of file diff --git a/docs/tutorials/popt/init_optim.toml b/docs/tutorials/popt/init_optim.toml deleted file mode 100644 index 57f59995..00000000 --- a/docs/tutorials/popt/init_optim.toml +++ /dev/null @@ -1,59 +0,0 @@ -[ensemble] -disable_tqdm = true -ne = 10 -state = ["injbhp","prodbhp"] -prior_injbhp = [ - ["mean","init_injbhp.npz"], - ["var",6250.0], - ["limits",100.0,500.0] -] -prior_prodbhp = [ - ["mean","init_prodbhp.npz"], - ["var",6250.0,], - ["limits",20.0,300.0] -] -num_models = 1 -transform = true - -[optim] -maxiter = 5 -tol = 1e-06 -alpha = 0.2 -beta = 0.1 -alpha_maxiter = 3 -resample = 0 -optimizer = 'GA' -nesterov = true -restartsave = true -restart = false -hessian = false -inflation_factor = 10 -savedata = ["alpha","obj_func_values"] - -[fwdsim] -npv_const = [ - ["wop",283.05], - ["wgp",0.0], - ["wwp",37.74], - ["wwi",12.58], - ["disc",0.08], - ["obj_scaling",-1.0e6] -] -parallel = 2 -simoptions = [ - ['mpi', 'mpirun -np 3'], - ['sim_path', '/usr/bin/'], - ['sim_flag', '--tolerance-mb=1e-5 --parsing-strictness=low'] -] -sim_limit = 5.0 -runfile = "3well" -reportpoint = [ - 1994-02-09 00:00:00, - 1995-01-01 00:00:00, - 1996-01-01 00:00:00, - 1997-01-01 00:00:00, - 1998-01-01 00:00:00, - 1999-01-01 00:00:00, -] -reporttype = "dates" -datatype = ["fopt","fgpt","fwpt","fwit"] diff --git a/docs/tutorials/popt/jupyter_kernel.png b/docs/tutorials/popt/jupyter_kernel.png deleted file mode 100644 index 90975fab..00000000 Binary files a/docs/tutorials/popt/jupyter_kernel.png and /dev/null differ diff --git a/docs/tutorials/popt/permx.png b/docs/tutorials/popt/permx.png deleted file mode 100644 index 4977cc7b..00000000 Binary files a/docs/tutorials/popt/permx.png and /dev/null differ diff --git a/docs/tutorials/popt/tutorial_popt.ipynb b/docs/tutorials/popt/tutorial_popt.ipynb deleted file mode 100644 index 1b110ed6..00000000 --- a/docs/tutorials/popt/tutorial_popt.ipynb +++ /dev/null @@ -1,849 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Tutorial for running the Python Optimization Toolbox (POPT)\n", - "\n", - "As an illustrative example we choose a 2D-field with one producer and two (water) injectors. The figure below shows the permeability field and the well positions. The grid is 100x100, and the porosity is 0.18. The optimization problem is to find the pressure control for the wells in order to maximize net present value. \n", - "\n", - "\"drawing\"\n", - " \n", - "
\n", - "The first step is to load neccessary external and local modules. " - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "metadata": { - "scrolled": true - }, - "outputs": [ - { - "data": { - "text/html": [ - "" - ], - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "# Set width\n", - "from IPython.display import display, HTML\n", - "display(HTML(\"\"))\n", - "\n", - "# Import global modules\n", - "import os\n", - "import glob\n", - "import shutil\n", - "import logging\n", - "from glob import glob\n", - "from copy import deepcopy\n", - "import numpy as np\n", - "from scipy.optimize import minimize\n", - "import matplotlib.pyplot as plt \n", - "from scipy.stats import expon\n", - "\n", - "# Import local modules\n", - "from input_output import read_config # functions for reading input\n", - "from popt.misc_tools import optim_tools as ot # help functions for optimization\n", - "from popt.loop.optimize import Optimize # this class contains the iterative loop\n", - "from popt.loop.ensemble import Ensemble # this class contains the control pertrubations and gradient calculations\n", - "from simulator.opm import flow # the simulator we want to use\n", - "from popt.update_schemes.enopt import EnOpt # the standard EnOpt method\n", - "from popt.update_schemes.smcopt import SmcOpt # the sequential Monte Carlo method\n", - "from popt.cost_functions.npv import npv # the cost function" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Set the random seed:" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "metadata": { - "scrolled": true - }, - "outputs": [], - "source": [ - "np.random.seed(101122) " - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "The plottting function is used to display the objective function vs. iterations for different methods:" - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "metadata": { - "scrolled": true - }, - "outputs": [], - "source": [ - "def plot_obj_func():\n", - " \n", - " # Collect all results\n", - " path_to_files = './'\n", - " path_to_figures = './' # Save here\n", - " if not os.path.exists(path_to_figures):\n", - " os.mkdir(path_to_figures)\n", - " files = os.listdir(path_to_files)\n", - " results = [name for name in files if \"optimize_result\" in name]\n", - " num_iter = len(results)\n", - "\n", - " mm = []\n", - " for iter in range(num_iter):\n", - " info = np.load(str(path_to_files) + 'optimize_result_{}.npz'.format(iter))\n", - " if 'best_func' in info:\n", - " mm.append(-info['best_func'])\n", - " else:\n", - " mm.append(-info['obj_func_values'])\n", - "\n", - " f = plt.figure()\n", - " plt.plot(mm, 'bs-')\n", - " plt.xticks(range(num_iter))\n", - " plt.xticks(fontsize = 14)\n", - " plt.yticks(fontsize = 14)\n", - " plt.xlabel('Iteration no.', size=14)\n", - " plt.ylabel('NPV', size=14)\n", - " plt.title('Objective function', size=14)\n", - " f.tight_layout(pad=2.0)\n", - " plt.show()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Remove old results and folders, if present:" - ] - }, - { - "cell_type": "code", - "execution_count": 13, - "metadata": { - "scrolled": true - }, - "outputs": [], - "source": [ - "for folder in glob('En_*'):\n", - " shutil.rmtree(folder)\n", - "for file in glob('optimize_result_*'):\n", - " os.remove(file)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Read inputfile. In this tutorial the input file is written as a .toml file, and consists of three main keys: ensemble, optim and fwdsim. The first part contains keys related to the ensemble, the second part contains the options for the optimization algorithm and the third part are options related to the forward simulation model and objective function. The description of all keys are provided in the printouts of method docstrings below." - ] - }, - { - "cell_type": "code", - "execution_count": 14, - "metadata": { - "scrolled": false - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[ensemble]\r\n", - "disable_tqdm = true\r\n", - "ne = 10\r\n", - "state = [\"injbhp\",\"prodbhp\"]\r\n", - "prior_injbhp = [\r\n", - " [\"mean\",\"init_injbhp.npz\"],\r\n", - " [\"var\",6250.0],\r\n", - " [\"limits\",100.0,500.0]\r\n", - "]\r\n", - "prior_prodbhp = [\r\n", - " [\"mean\",\"init_prodbhp.npz\"],\r\n", - " [\"var\",6250.0,],\r\n", - " [\"limits\",20.0,300.0]\r\n", - "]\r\n", - "num_models = 1\r\n", - "transform = true\r\n", - "\r\n", - "[optim]\r\n", - "maxiter = 5\r\n", - "tol = 1e-06\r\n", - "alpha = 0.2\r\n", - "beta = 0.1\r\n", - "alpha_maxiter = 3\r\n", - "resample = 0\r\n", - "optimizer = 'GA'\r\n", - "nesterov = true\r\n", - "restartsave = true\r\n", - "restart = false\r\n", - "hessian = false\r\n", - "inflation_factor = 10\r\n", - "savedata = [\"alpha\",\"obj_func_values\"]\r\n", - "\r\n", - "[fwdsim]\r\n", - "npv_const = [\r\n", - " [\"wop\",283.05],\r\n", - " [\"wgp\",0.0],\r\n", - " [\"wwp\",37.74],\r\n", - " [\"wwi\",12.58],\r\n", - " [\"disc\",0.08],\r\n", - " [\"obj_scaling\",-1.0e6]\r\n", - "]\r\n", - "parallel = 2\r\n", - "simoptions = [\r\n", - " ['mpi', 'mpirun -np 3'],\r\n", - " ['sim_path', '/usr/bin/'],\r\n", - " ['sim_flag', '--tolerance-mb=1e-5 --parsing-strictness=low']\r\n", - "]\r\n", - "sim_limit = 5.0\r\n", - "runfile = \"3well\"\r\n", - "reportpoint = [\r\n", - " 1994-02-09 00:00:00,\r\n", - " 1995-01-01 00:00:00,\r\n", - " 1996-01-01 00:00:00,\r\n", - " 1997-01-01 00:00:00,\r\n", - " 1998-01-01 00:00:00,\r\n", - " 1999-01-01 00:00:00,\r\n", - "]\r\n", - "reporttype = \"dates\"\r\n", - "datatype = [\"fopt\",\"fgpt\",\"fwpt\",\"fwit\"]\r\n" - ] - } - ], - "source": [ - "!cat init_optim.toml\n", - "ko, kf, ke = read_config.read_toml('init_optim.toml')" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Set initial pressure (note that the filenames correspond to the names given in the input file above):" - ] - }, - { - "cell_type": "code", - "execution_count": 15, - "metadata": { - "scrolled": true - }, - "outputs": [], - "source": [ - "init_injbhp = np.array([300.0,250.0])\n", - "init_prodbhp = np.array([100.0])\n", - "np.savez('init_injbhp.npz', init_injbhp)\n", - "np.savez('init_prodbhp.npz', init_prodbhp)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Initialize the simulator with simulator keys." - ] - }, - { - "cell_type": "code", - "execution_count": 16, - "metadata": { - "scrolled": false - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - " The inputs are all optional, but in the same fashion as the other simulators a system must be followed.\n", - " The input_dict can be utilized as a single input. Here all nescessary info is stored. Alternatively,\n", - " if input_dict is not defined, all the other input variables must be defined.\n", - "\n", - " Parameters\n", - " ----------\n", - " input_dict : dict, optional\n", - " Dictionary containing all information required to run the simulator.\n", - "\n", - " - parallel: number of forward simulations run in parallel\n", - " - simoptions: options for the simulations\n", - " - mpi: option to use mpi (always use > 2 cores)\n", - " - sim_path: Path to the simulator\n", - " - sim_flag: Flags sent to the simulator (see simulator documentation for all possibilities)\n", - " - sim_limit: maximum number of seconds a simulation can run before being killed\n", - " - runfile: name of the simulation input file\n", - " - reportpoint: these are the dates the simulator reports results\n", - " - reporttype: this key states that the report poins are given as dates\n", - " - datatype: the data types the simulator reports\n", - "\n", - " filename : str, optional\n", - " Name of the .mako file utilized to generate the ECL input .DATA file. Must be in uppercase for the\n", - " ECL simulator.\n", - "\n", - " options : dict, optional\n", - " Dictionary with options for the simulator.\n", - "\n", - " Returns\n", - " -------\n", - " initial_object : object\n", - " Initial object from the class ecl_100.\n", - " \n" - ] - } - ], - "source": [ - "sim = flow(kf)\n", - "print(flow.__init__.__doc__)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Initialize the ensemble with ensemble keys, the simulator, and the chosen objective function. Here we also extract the initial state (x0), the covariance (cov), and the bounds. " - ] - }, - { - "cell_type": "code", - "execution_count": 17, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - " Parameters\n", - " ----------\n", - " keys_en : dict\n", - " Options for the ensemble class\n", - "\n", - " - disable_tqdm: supress tqdm progress bar for clean output in the notebook\n", - " - ne: number of perturbations used to compute the gradient\n", - " - state: name of state variables passed to the .mako file\n", - " - prior_: the prior information the state variables, including mean, variance and variable limits\n", - " - num_models: number of models (if robust optimization) (default 1)\n", - " - transform: transform variables to [0,1] if true (default true)\n", - "\n", - " sim : callable\n", - " The forward simulator (e.g. flow)\n", - "\n", - " obj_func : callable\n", - " The objective function (e.g. npv)\n", - " \n" - ] - } - ], - "source": [ - "ensemble = Ensemble(ke, sim, npv)\n", - "print(Ensemble.__init__.__doc__)\n", - "x0 = ensemble.get_state()\n", - "cov = ensemble.get_cov()\n", - "bounds = ensemble.get_bounds()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Example using EnOpt. The input and available options are given below. During optimization, useful information is written to the screen. The same information is also written to a log-file named popt.log. " - ] - }, - { - "cell_type": "code", - "execution_count": 18, - "metadata": { - "scrolled": false - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - " Parameters\n", - " ----------\n", - " fun: callable\n", - " objective function\n", - "\n", - " x: ndarray\n", - " Initial state\n", - "\n", - " args: tuple\n", - " Initial covariance\n", - "\n", - " jac: callable\n", - " Gradient function\n", - "\n", - " hess: callable\n", - " Hessian function\n", - "\n", - " bounds: list, optional\n", - " (min, max) pairs for each element in x. None is used to specify no bound.\n", - "\n", - " options: dict\n", - " Optimization options\n", - "\n", - " - maxiter: maximum number of iterations (default 10)\n", - " - restart: restart optimization from a restart file (default false)\n", - " - restartsave: save a restart file after each successful iteration (defalut false)\n", - " - tol: convergence tolerance for the objective function (default 1e-6)\n", - " - alpha: step size for the steepest descent method (default 0.1)\n", - " - beta: momentum coefficient for running accelerated optimization (default 0.0)\n", - " - alpha_maxiter: maximum number of backtracing trials (default 5)\n", - " - resample: number indicating how many times resampling is tried if no improvement is found\n", - " - optimizer: 'GA' (gradient accent) or Adam (default 'GA')\n", - " - nesterov: use Nesterov acceleration if true (default false)\n", - " - hessian: use Hessian approximation (if the algorithm permits use of Hessian) (default false)\n", - " - normalize: normalize the gradient if true (default true)\n", - " - cov_factor: factor used to shrink the covariance for each resampling trial (defalut 0.5)\n", - " - savedata: specify which class variables to save to the result files (state, objective\n", - " function value, iteration number, number of function evaluations, and number\n", - " of gradient evaluations, are always saved)\n", - " \n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2023-12-14 10:16:03,832 : INFO : popt.loop.optimize : ====== Running optimization - EnOpt ======\n", - "2023-12-14 10:16:03,833 : INFO : popt.loop.optimize : \n", - "{'alpha': 0.2,\n", - " 'alpha_maxiter': 3,\n", - " 'beta': 0.1,\n", - " 'datatype': ['fopt', 'fgpt', 'fwpt', 'fwit'],\n", - " 'hessian': False,\n", - " 'inflation_factor': 10,\n", - " 'maxiter': 5,\n", - " 'nesterov': True,\n", - " 'optimizer': 'GA',\n", - " 'resample': 0,\n", - " 'restart': False,\n", - " 'restartsave': True,\n", - " 'savedata': ['alpha', 'obj_func_values'],\n", - " 'tol': 1e-06}\n", - "2023-12-14 10:16:03,833 : INFO : popt.loop.optimize : iter alpha_iter obj_func step-size cov[0,0] \n", - "2023-12-14 10:16:03,834 : INFO : popt.loop.optimize : 0 -1.9083e-01 \n", - "2023-12-14 10:16:13,088 : INFO : popt.loop.optimize : 1 0 -3.1499e-01 2.00e-01 3.97e-02 \n", - "2023-12-14 10:16:21,543 : INFO : popt.loop.optimize : 2 0 -3.7002e-01 2.00e-01 3.97e-02 \n", - "2023-12-14 10:16:33,583 : INFO : popt.loop.optimize : 3 0 -3.7252e-01 2.00e-01 3.95e-02 \n", - "2023-12-14 10:16:43,758 : INFO : popt.loop.optimize : 4 0 -3.7253e-01 2.00e-01 3.93e-02 \n", - "2023-12-14 10:16:53,204 : INFO : popt.loop.optimize : 5 0 -3.7260e-01 2.00e-01 3.97e-02 \n", - "2023-12-14 10:16:53,211 : INFO : popt.loop.optimize : Optimization converged in 5 iterations \n", - "2023-12-14 10:16:53,213 : INFO : popt.loop.optimize : Optimization converged with final obj_func = -0.3726\n", - "2023-12-14 10:16:53,216 : INFO : popt.loop.optimize : Total number of function evaluations = 6\n", - "2023-12-14 10:16:53,218 : INFO : popt.loop.optimize : Total number of jacobi evaluations = 5\n", - "2023-12-14 10:16:53,221 : INFO : popt.loop.optimize : Total elapsed time = 0.84 minutes\n", - "2023-12-14 10:16:53,227 : INFO : popt.loop.optimize : ============================================\n" - ] - }, - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 18, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "print(EnOpt.__init__.__doc__)\n", - "EnOpt(ensemble.function, x0, args=(cov,), jac=ensemble.gradient, hess=ensemble.hessian, bounds=bounds, **ko)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Finally, plot the objective function using the function defined above:" - ] - }, - { - "cell_type": "code", - "execution_count": 19, - "metadata": { - "scrolled": false - }, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "plot_obj_func()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Example using the sequential Monte Carlo method. Here we also save the best state (which is not the mean of the ensemble simulations) and the corresponding best objective function value: " - ] - }, - { - "cell_type": "code", - "execution_count": 20, - "metadata": { - "scrolled": false - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - " Parameters\n", - " ----------\n", - " fun: callable\n", - " objective function\n", - "\n", - " x: ndarray\n", - " Initial state\n", - "\n", - " sens: callable\n", - " Ensemble sensitivity\n", - "\n", - " bounds: list, optional\n", - " (min, max) pairs for each element in x. None is used to specify no bound.\n", - "\n", - " options: dict\n", - " Optimization options\n", - "\n", - " - maxiter: maximum number of iterations (default 10)\n", - " - restart: restart optimization from a restart file (default false)\n", - " - restartsave: save a restart file after each successful iteration (defalut false)\n", - " - tol: convergence tolerance for the objective function (default 1e-6)\n", - " - alpha: weight between previous and new step (default 0.1)\n", - " - alpha_maxiter: maximum number of backtracing trials (default 5)\n", - " - resample: number indicating how many times resampling is tried if no improvement is found\n", - " - cov_factor: factor used to shrink the covariance for each resampling trial (defalut 0.5)\n", - " - inflation_factor: term used to weight down prior influence (defalult 1)\n", - " - savedata: specify which class variables to save to the result files (state, objective function\n", - " value, iteration number, number of function evaluations, and number of gradient\n", - " evaluations, are always saved)\n", - " \n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2023-12-14 10:17:21,181 : INFO : popt.loop.optimize : ====== Running optimization - SmcOpt ======\n", - "2023-12-14 10:17:21,182 : INFO : popt.loop.optimize : \n", - "{'alpha': 0.2,\n", - " 'alpha_maxiter': 3,\n", - " 'beta': 0.1,\n", - " 'datatype': ['fopt', 'fgpt', 'fwpt', 'fwit'],\n", - " 'hessian': False,\n", - " 'inflation_factor': 10,\n", - " 'maxiter': 5,\n", - " 'nesterov': True,\n", - " 'optimizer': 'GA',\n", - " 'resample': 0,\n", - " 'restart': False,\n", - " 'restartsave': True,\n", - " 'savedata': ['alpha', 'obj_func_values', 'best_state', 'best_func'],\n", - " 'tol': 1e-06}\n", - "2023-12-14 10:17:21,182 : INFO : popt.loop.optimize : iter alpha_iter obj_func step-size \n", - "2023-12-14 10:17:21,183 : INFO : popt.loop.optimize : 0 -1.9083e-01 \n", - "2023-12-14 10:17:30,338 : INFO : popt.loop.optimize : 1 0 -3.6047e-01 2.00e-01 \n", - "2023-12-14 10:17:39,446 : INFO : popt.loop.optimize : 2 0 -3.7190e-01 2.00e-01 \n", - "2023-12-14 10:17:49,220 : INFO : popt.loop.optimize : 3 0 -3.7443e-01 2.00e-01 \n", - "2023-12-14 10:17:58,141 : INFO : popt.loop.optimize : 4 0 -3.7443e-01 2.00e-01 \n", - "2023-12-14 10:18:10,110 : INFO : popt.loop.optimize : 5 0 -3.7443e-01 2.00e-01 \n", - "2023-12-14 10:18:10,112 : INFO : popt.loop.optimize : Optimization converged in 5 iterations \n", - "2023-12-14 10:18:10,113 : INFO : popt.loop.optimize : Optimization converged with final obj_func = -0.3672\n", - "2023-12-14 10:18:10,113 : INFO : popt.loop.optimize : Total number of function evaluations = 6\n", - "2023-12-14 10:18:10,114 : INFO : popt.loop.optimize : Total number of jacobi evaluations = 5\n", - "2023-12-14 10:18:10,114 : INFO : popt.loop.optimize : Total elapsed time = 0.83 minutes\n", - "2023-12-14 10:18:10,114 : INFO : popt.loop.optimize : ============================================\n" - ] - }, - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 20, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "ko_smc = deepcopy(ko)\n", - "ko_smc['savedata'] += [\"best_state\", \"best_func\"]\n", - "print(SmcOpt.__init__.__doc__)\n", - "SmcOpt(ensemble.function, x0, args=(cov,), sens=ensemble.calc_ensemble_weights, bounds=bounds, **ko_smc)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Plot the objective function using the function defined above:" - ] - }, - { - "cell_type": "code", - "execution_count": 21, - "metadata": { - "scrolled": false - }, - "outputs": [ - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAlwAAAG8CAYAAAALsHuvAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/OQEPoAAAACXBIWXMAAA9hAAAPYQGoP6dpAABevklEQVR4nO3de1yUZf4//tdwGpSzooGBoIiHPFaCeIiDJKDlaSshvquQmNVurf60wwdb81QYrtmn3dq2NJFKVyk3ywOnElARDPJQqQi6gijiJw8Mh+R8/f6YZmKcAWaAYYbh9Xw85iFc93Xf93tu3Z1313XN9ZYIIQSIiIiISG/MDB0AERERkaljwkVERESkZ0y4iIiIiPSMCRcRERGRnjHhIiIiItIzJlxEREREesaEi4iIiEjPmHARERER6RkTLiIiIiI9Y8JFRF3C09MTnp6eWvffsWMHJBIJduzYobeYdLF27VpIJBJkZmYaOhQAQGVlJZYtW4YhQ4bA0tISEokEp0+fNnRYOjG2v2MiQ2LCRURqMjIyEB4eDnd3d0ilUvTr1w/Tpk3Du+++i9raWkOH1yGZmZmQSCRYu3atoUPRyquvvoq///3vGDNmDP7nf/4Ha9asgYuLi6HDUlFcXAyJRILo6GhDh0Jk9CwMHQARGY/Gxkb8+c9/xscffwwbGxvMnDkTw4YNg0wmQ1paGlasWIF//etfOHjwIIYNG9ape82fPx9+fn5wdXXtoug758UXX0RERAQGDx5s6FAAAAcOHMDw4cOxf/9+Q4fSYcb2d0xkSEy4iEgpNjYWH3/8MXx8fPDVV1/h/vvvVx5ramrC+vXrsX79eoSFheHkyZOwt7fv8L0cHBzg4ODQFWF3CWdnZzg7Oxs6DKWysjL4+/sbOoxOMba/YyKDEkREQogLFy4IMzMz0a9fP1FeXt5qv8jISAFArF69WqXdw8NDeHh4iDt37oilS5eK++67T0ilUjFhwgSxa9cuteskJCQIACIhIUHt2H//+18RExMj3N3dhZWVlXBxcRFRUVGiuLhYY0yXLl0Szz77rPD09BRWVlZiwIABIiAgQHntNWvWCAAaX5cvX1bpk5GRIYQQori4WEgkEhEUFKTxnvX19aJ///7Czc1NNDU1Kdvr6urEO++8Ix588EHRt29fYWtrK6ZNmya+/vrrVp9pS1FRURrjDAgI0Bhne8/08uXLAoCIiooSRUVFYt68ecLR0VH07dtXBAcHi9OnT2uM48aNG2LFihVi+PDhwtraWjg5OQlfX1/xt7/9TeVeml6K2Nr6Oz527JiYNWuWcHJyElKpVIwYMUK88cYboqamRq2v4v2Xl5eLRYsWif79+wtra2sxadIkjc+ByBhxhIuIAACJiYlobm7G0qVLcd9997Xab/Xq1di1axe2b9+O9evXqxyrr6/Ho48+iurqaixcuBA1NTVISkpCZGQkbt68iZdeeqndOE6cOIHQ0FDU1NTg8ccfh7e3N4qLi7Fz504kJycjJycHQ4cOVfY/duwYHnvsMVRVVSE0NBQRERG4c+cOTp06hffeew/R0dEIDAxEcXExEhMTERAQgMDAQOX5jo6OGuPw8PCAv78/srKycPXqVbi5uakcP3ToEG7duoXXXnsNZmby5bB1dXUICwtDZmYmJkyYgJiYGDQ0NODgwYOYO3cu/vGPf+DFF19s8/3PmzcPnp6eWLduHTw8PJTro3T5QoImxcXF8PPzw+jRo7F48WJcunQJX3/9NYKCgnD+/HmVv/MLFy4gKCgI169fx7Rp0zBv3jzU1NTg7NmziIuLw8svv4wJEyZg2bJleO+99zB+/HjMmzdPeX57sX7xxRd4+umnIZVKER4ejoEDByItLQ3r169HamoqMjMzYW1trXJORUUFpk2bBgcHByxcuBD/93//hz179iA0NBQ//PADxowZ06nnQ6R3hs74iMg4BAYGCgAiPT293b6DBg0SAMSVK1eUbR4eHgKA8Pf3F3V1dcr20tJS4ezsLKRSqbh69aqyXdPoR319vfD09BR2dnbi5MmTKvc8evSoMDc3F48//riyrba2Vtx///3CzMxMJCcnq8VZWlqq/DkjI0MAEGvWrNH4njSNHG3btk0AEPHx8Wr9n3jiCQFA/Pzzz8q2VatWKUf/mpuble2VlZVi4sSJwsrKSly7dk3j/e+FFqNa7cWp0NYIFwDx9ttvq/T/61//KgCIjRs3qrRPnDhRABAff/yx2j1aPtOWo2eaaIpHJpMJBwcHIZVKxZkzZ5TtTU1NIjw8XAAQ69evV7mOIv4//elPKqOJir+f5557TuP9iYwJv6VIRACA8vJyAIC7u3u7fRV9rl+/rnYsLi4OVlZWyt/d3NywbNky1NXVYffu3W1e98CBAyguLsYrr7yCBx98UOXYtGnTMHfuXBw6dAiVlZUAgK+//hrXrl3DH//4R4SFhald795RKV09+eSTsLa2xueff67SXlFRgQMHDmDChAkYPXo0AKC5uRkffvghvLy8sG7dOkgkEmV/Ozs7vPHGG6ivr8d//vOfTsXUUUOGDMErr7yi0hYTEwMAyMvLU7Z9//33yM/Ph7+/P5599lm163T2mX799deQyWRYvHgxxo0bp2w3MzPDpk2bYGFhoXEbCRsbG8THxytHEwEgKioKFhYWKvETGStOKRJRl7GwsMDkyZPV2h955BEAwKlTp9o8Pzc3F4B8SkvT9g3l5eVobm5GYWEhJk6ciO+//x4AEBIS0snINXNwcMCcOXOQlJSEM2fOYPz48QDkU2J1dXVYuHChsu+FCxdw584dDBo0COvWrVO71i+//AIAKCgo0Eus7ZkwYYJKsgL8njxVVFQo2/T9TBX/BlpO6yoMHjwYQ4cORWFhIaqqqmBnZ6c8Nnz4cNja2qr0t7CwwH333acSP5GxYsJFRAAAFxcXFBQUoLS0FCNGjGizb2lpKQCofd3f2dlZ7UMdgHJ9kEwma/O6t2/fBgDs3LmzzX41NTUq12v5bcqutnDhQiQlJeHzzz9XJlyfffYZzM3NERkZqeyniP3s2bM4e/Zsq9dTxN7dNH2j1MJC/hHQ1NSkbNP3M1WMTra2TtDV1RWFhYWorKxUSbha+0ashYWFSvxExopTikQEAJgyZQoA4LvvvmuzX0FBAcrKynD//ferTT/evHkTzc3NaufcuHEDANrdIkDxobp//34IIVp9BQQEAPh9wfu1a9faf4MdFBYWhgEDBuDf//43mpubUVxcjGPHjuHRRx9V2YhUEfsTTzzRZuwJCQmdikeR0DY2Nqoday+h1Ya+n6niOSn+TdxLMbXdmS1HiIwREy4iAgAsWrQIZmZm2Lp1q3L6S5O33noLALB48WK1Y42NjcjJyVFrP3r0KACorcu616RJkwBA4zU08fX1BQCkpaW129fc3BwAdB4NsbCwQEREBK5du4aMjAzs3LkTQgj88Y9/VOk3atQo2NvbIz8/Hw0NDTrdQxdOTk4ANCdE7U3ZakPfz1Txb0BTCaXS0lJcunQJQ4cOVRndIjIFTLiICAAwYsQILFu2DLdu3cLs2bPVFsQ3Nzdjw4YN+Pzzz+Hl5YWXX35Z43VWrVqF+vp65e9Xr17Fe++9B6lUioiIiDZjmDt3LgYPHowtW7bgyJEjascbGhpw7Ngx5e9z5syBm5sbPv/8c6Smpqr1b5mU9OvXD8Dv06G6UKzV+uyzz/DZZ5/BxsYG8+fPV+ljYWGBF154ASUlJXj55Zc1Jl0///wz/u///k/n+7fk4+MDAPj0009VRhNzcnLanYrV9vo+Pj44cuQItm7dqna85TN1cnKCRCLR6ZnOnTsXDg4OSEhIUJl6FULgtddeQ2NjI0sFkUniGi4iUtq0aRNkMhm2b98Ob29vPPbYY/Dy8kJlZSXS0tJQVFQEb29vHDp0SOOUj6urK2pqajBu3DjMnj1buQ/XrVu38Pe//73ddUFSqRRffvklZs6ciYCAAEyfPh1jx46FRCJBSUkJjh49iv79+ysXnkulUiQlJSEsLAwzZ85EWFgYxo8fj8rKSpw+fRq//vqrctRn5MiRGDRoEHbv3g2pVAo3NzdIJBK89NJL7U51+vj4YMSIEdi1axcaGhqwcOFC2NjYqPVbt24dTp48ib///e84ePAg/P39MXDgQFy7dg0//fQTzpw5g5ycHAwcOFDbvxI1fn5+mDp1Kg4fPozJkyfD398fJSUl+PrrrzF79mx89dVXHb62ws6dOxEYGIilS5fis88+w+TJk1FbW4uzZ8/i1KlTuHXrFgDA1tZWmZwtXLgQ3t7eMDMzw8KFC+Hh4aHx2vb29ti6dSuefvppTJo0CeHh4RgwYAC+/fZb/PDDD/D19VX7NiWRSej+nSiIyNilp6eLp556SgwaNEhYWloKR0dHMXnyZPHOO++IX3/9VeM5ip3mb9++rbLT/Pjx43Xeaf7q1ati2bJlwtvbW0ilUmFvby9GjRollixZIr777ju1/hcvXhQxMTHCzc1NWFpaioEDB4rAwEDx6aefqvTLzc0VAQEBws7Ort2d5u/15ptvKs9JTU1t9dk1NjaKjz76SEydOlXY29sLqVQqBg8eLMLCwsSHH34oqqurWz23JbSyD5cQQty8eVMsWrRI9OvXT/Tp00f4+fmJ1NTUdnea1+U+5eXlYtmyZWLo0KHCyspK9OvXT0yaNEls2bJFpd+FCxfErFmzhKOjo5BIJFrvNH/kyBExc+ZM4ejoKKysrMTw4cPF6tWrNT6ftp6F4t8dkbGTCCGEQTI9IurV/vWvf+GFF17Arl278PTTTxs6HCIiveIaLiIyiIsXLwLo/EaaREQ9AUe4iKhbpaenY9++fUhISICTkxOKi4thaWlp6LCIiPSKI1xE1K0OHjyInTt3YvLkyUhLS2OyRUS9Ake4iIiIiPSMI1xEREREesaEi4iIiEjPuPGpEWlubkZZWRns7OwgkUgMHQ4RERG1QQiBqqoqDBo0SFnntDVMuIxIWVmZWjFgIiIiMm6lpaXtbnHDhMuIKIq1lpaWaiybQkRERMajsrIS7u7uWhVbZ8JlRBTTiPb29ky4iIiIeghtlgFx0TwRERGRnjHhIiIiItIzJlxEREREesaEi4iIiEjPmHARERER6RkTLiIiIiI9M9qEKy8vD7NmzYKjoyNsbGzg5+eHpKQkrc9PTk5GREQERo4cCUdHR/Tt2xcjR45ETEwMCgsL1fqvXbsWEomkzVdMTIzKOdHR0W32JyIiIgKMdB+ujIwMhIaGwtraGhEREbCzs8PevXsRHh6O0tJSrFy5st1rHDp0CLm5uZg0aRJmzpwJS0tLnD9/HomJidi5cycOHTqE6dOnK/sHBga2eq1t27bh2rVrCA0N1Xh82bJlcHR01PVtEhERUS8hEUIIQwfRUmNjI0aOHImrV68iNzcXEyZMAADIZDL4+vqiuLgYhYWF8PDwaPM6tbW1sLa2Vmv/7rvv8Oijj2LixInIy8trN54bN27Azc0NDg4OKCsrg5WVlfJYdHQ0EhMTcfnyZXh6eur0PjWprKyEg4MDZDIZNz4lom535Qpw82brx52dgcGDuy8eU8Xn3D264znr8rltdCNchw8fxqVLl/DMM88oky0AcHBwwKpVq5RJzhtvvNHmdTQlWwAQHBwMJycnXLx4Uat4EhMT0djYiIULF6okW0REpuTKFWDECKC2tvU+1tbAhQtMBjqDz7l7GONzNrqEKzMzEwAQEhKidkwxpZeVldXh6+fk5ODOnTuYNm2aVv0/+eQTAMCSJUta7XPgwAFUVVVBKpVi1KhRCA4OZnJGRD3KzZttfzgB8uM3bzIR6Aw+5+5hjM/Z6BKuoqIiAIC3t7faMRcXF9ja2ir7aCMtLQ3Hjx9HXV0dioqKcODAATg7O+Pdd99t99yjR4+isLAQfn5+GD16dKv9XnrpJZXfXV1dkZCQ0OqaL4W6ujrU1dUpf6+srGw3JiKirlRfD1RVAdeva9c/NRXQ8L0j0tLly9r143PuHG2fc3cyuoRLJpMBkE8hamJvb6/so420tDS88847yt+HDRuG3bt34+GHH2733PZGt/z9/fHYY4/Bz88PAwYMwNWrV/Hvf/8bGzduxJw5c5CdnY2JEye2ev2NGzdi3bp1Wr8Xot6Ka17kmpqAmhp5glRd/fufLX/Wtk3xc0ODbjGsWqWf90aq+JxNj9Etmg8JCUF6ejqKioowbNgwteP3338/qqurdUq6AKC6uhrnzp3D+vXr8e2332L79u2IjIxstX9lZSVcXV1hZmaG69evw9bWVut7bd++HTExMZg9eza++eabVvtpGuFyd3fnonmiFoxxLYY2hADu3u1cUnRv2927+ovX0lK75GviRMDOTn9xmLqqKiA/v/1+fM6do+1z/uEH4KGHOn6fHr1oXjGy1VpCVVlZCScnJ52va2trC19fX+zbtw8TJ07E0qVLMWPGDAwYMEBj/927d+PXX39FTEyMTskWAERFReHPf/4zsrOz2+wnlUohlUp1ujZRb9NdazEUU2utjQR1pE1f/zlrZib/MLazA2xt5S/Fzx1ps7UFfvoJ0GLgHx991LkPqN7u5Ek+5+6g7XPuTkaXcCnWbhUVFalN+5WXl6O6uhq+vr4dvr6FhQWCgoJw5swZ5OfnY+bMmRr7bdu2DUDbi+VbY25uDkdHR9y5c6fDcRKRbvLzgbKyjidKuk6t6cLGRvtESJtESSoFuLcyUc9idAlXQEAANm7ciLS0NERERKgcS01NVfbpjLKyMgCApaWlxuM//fQT8vLyMHr0aPj5+el8/StXrqC8vBwjRozoVJxEBDQ2atfvuee65n5SaedHjFr+bGMjH5Eiot7N6BKu4OBgDB06FLt27cJf/vIXlY1P4+LiYGVlhUWLFin7X79+HTKZDK6urioL7fPz8zUuWE9NTcVXX30FR0dHTJ48WWMMisXy95byaam8vBxNTU24//77VdorKioQHR0NAG2uESMiza5fB06cAHJygNxc4PvvtTvP0xMYMKBjI0Ytp9Za+e8wk+fsLF8L195aOWfn7ovJFPE5dw9jfM5Gt2geaL20T0lJCTZv3qxS2kexEWpCQoIy0QEAiUSCMWPGYNy4cXBzc0NNTQ1+/PFHHD16FJaWltizZw/mz5+vdu/6+noMGjQIVVVVKCsrQ//+/TXGmJmZiRkzZmDKlCnw9vbGgAEDUFpaipSUFNy6dQvTp0/HwYMHW92AVRPuNE+9TV0dcOqUPLFSvEpKOnatzi5+JX4btLvwOXcP7jSvhaCgIBw7dgxr1qzBnj170NDQgLFjxyI+Ph7h4eFaXSMuLg4ZGRnIysrCL7/8AjMzMwwePBhLly7F8uXLMWrUKI3n7du3D7du3cKCBQtaTbYAwMvLC9HR0cjLy8O+ffsgk8lga2uLcePGITIyEkuWLIG5uXmH3j+RKRJCnky1TK5OnZIvVm9JIgHGjAH8/OQve3vgqacME3NvM3gwP+i7A59z9zC252yUI1y9FUe4yJRUV8sXsrdMsG7cUO83YMDvyZWfH+Djo/p1eG2/bcQRLiLqbj1+hIuIepbmZqCoSDW5+vFHeXtLFhbAgw+qJlhDhrT9jTtjXItBRKQrJlxEpLM7d+SL2RXJ1YkT8rZ7ubmpJlcPPQT06aPbvQYPlm9qyjUvRNSTMeEiojY1NQE//6w6elVQoN7P2lq+O7YiuZo0SZ5wdQVjW4tBRKQrJlxEpOLGDfmIlSK5+v57ef2+ew0bpjp6NW5c791SgYioPUy4iHqx+nrg9GnV0avLl9X72dkBvr6qo1etVMUiIiINmHAR9RJCAKWlqsnVyZPyvbBakkiABx5QHb0aNQrgLidERB3HhIvIRP36q3yrhNzc33dtv35dvV///urbMrQo2kBERF2ACReRCRACuHhRdfTqzBn5gveWzM2B8eOByZN/T7C8vFgImYhI35hwEfVAMpnqtgy5ucDt2+r9XF1Vk6uHHwb69u3+eImIejsmXERGrqkJOHdONbk6f14+qtWSVCpPqFpOD7q5cfSKiMgYMOEiMjK//KK+LUNVlXq/IUNUR6/GjwesrLo/XiIiah8TLqJO6Gw1+vp6eQmclqNXly6p97OxUd+W4b77Oh8/ERF1DyZcRB105QowYkT7Nf4uXPg96bp6VTW5+uEHzeePGqU6NTh6NLdlICLqyZhwEXXQzZttJ1uA/Pi77/6eaF29qt7HyUk1ufL1BRwd9RIyEREZCBMuIj373//9/WczM3kJnJYJ1vDhXNhORGTqmHAR6VlgIBAW9vu2DLa2ho6IiIi6GxMuIj175x3goYcMHQURERmSmaEDICIiIjJ1TLiIiIiI9IwJFxEREZGeMeEi6iBnZ/k+W22xtpb3IyKi3o0JF1EHDR4s39T0z3+W/z5linwj05avlpueEhFR78VvKRJ1wuDBQH6+/OdFi/htRCIi0owjXESdcP26vNA0AMyebdhYiIjIeDHhIuqEAwfkf/r4AIMGGTYWIiIyXky4iDrh66/lf86da9g4iIjIuDHhIuqg6mrg22/lPzPhIiKitjDhIuqgtDSgrg4YOhQYPdrQ0RARkTEz2oQrLy8Ps2bNgqOjI2xsbODn54ekpCStz09OTkZERARGjhwJR0dH9O3bFyNHjkRMTAwKCws1niORSFp9RUdHazynsrISK1asgIeHB6RSKTw9PfHKK6+gurq6I2+bepBvvpH/OWcOIJEYNhYiIjJuRrktREZGBkJDQ2FtbY2IiAjY2dlh7969CA8PR2lpKVauXNnuNQ4dOoTc3FxMmjQJM2fOhKWlJc6fP4/ExETs3LkThw4dwvTp09XO8/Dw0JhcTZgwQa2tpqYGAQEBOH36NEJCQvD000/j1KlT2Lx5M7KysnDkyBFYt7czJvVIjY2/L5jndCIREbVLGJmGhgbh5eUlpFKpOHXqlLK9oqJCDB8+XFhZWYni4uJ2r3P37l2N7d9++60AICZOnKh2DIAICAjQOtY33nhDABCvvfaaSvtrr70mAIi4uDitryWEEDKZTAAQMplMp/Oo+2VlCQEI0a+fEA0Nho6GiIgMQZfPbaObUjx8+DAuXbqEyMhIlVElBwcHrFq1CvX19UhMTGz3Oq2NLAUHB8PJyQkXL17sVJxCCGzbtg22trZYvXq1yrHVq1fD1tYW27Zt69Q9yHgpvp342GOAhVGOExMRkTExuo+KzMxMAEBISIjasdDQUABAVlZWh6+fk5ODO3fuYNq0aRqPV1RU4OOPP8bNmzfRr18/TJ06FWPHjlXrV1RUhLKyMoSGhsLGxkblmI2NDaZOnYrU1FSUlpbC3d29w/GS8RHi94RrzhzDxkJERD2D0SVcRUVFAABvb2+1Yy4uLrC1tVX20UZaWhqOHz+Ouro6FBUV4cCBA3B2dsa7776rsf+ZM2fw3HPPqbSFhYUhMTERAwcO1CpORXtqaiqKiopaTbjq6upQV1en/L2yslLr90WGc/48cOkSYGUF/PbfAERERG0yuoRLJpMBkE8hamJvb6/so420tDS88847yt+HDRuG3bt34+GHH1bru3LlSjzxxBMYPnw4rKys8PPPP2PDhg1ITk7G448/jpycHJibm2sdZ8t+mmzcuBHr1q3T+r2QcVCMbgUHA3Z2ho2FiIh6BqNbw9XVNm/eDCEEqqqqcOLECYwYMQJTp07Frl27NPadPHky+vfvDzs7O0yePBkHDhxAQEAA8vLy8LXik7aLxMbGQiaTKV+lpaVden3SD+4uT0REujK6hEsxYtTayFBlZWWro0ptsbW1ha+vL/bt24eRI0di6dKl+OWXX9o9z8zMDM8++ywAIDs7W6c4W/bTRCqVwt7eXuVFxq28nMWqiYhId0aXcCnWRGlap1VeXo7q6upW101pw8LCAkFBQaipqUF+fr5W5zg7OwOQ77ulTZwt2zsTKxmf/fvlf7JYNRER6cLoEq6AgAAA8rVX90pNTVXp01FlZWUAAEtLS636n/htSMPT01PZ5u3tjUGDBiE7O1slEQPkiVl2djaGDBnCbyiaGE4nEhFRRxhdwhUcHIyhQ4di165dOH36tLJdJpMhLi4OVlZWWLRokbL9+vXrKCgoUJvaa230KjU1FV999RUcHR0xefJkZftPP/2EhoYGtf7Hjx9HfHw8LC0t8dRTTynbJRIJlixZgurqamzYsEHlnA0bNqC6ulo5FUmmgcWqiYiooyRCCGHoIO7VWmmfkpISbN68WaW0T3R0NBITE5GQkKBSkkcikWDMmDEYN24c3NzcUFNTgx9//BFHjx6FpaUl9uzZg/nz56tc5+DBg5g2bRrc3d1haWmJs2fPIi0tDRKJBB988AGef/55lThramowdepUnDlzBiEhIXjooYdw8uRJpKWlwcfHB1lZWejTp4/W71uxPk0mk3E9lxH66ivgD3+QF6u+eJH1E4mIejtdPreNblsIAAgKCsKxY8ewZs0a7NmzBw0NDRg7dizi4+MRHh6u1TXi4uKQkZGBrKws/PLLLzAzM8PgwYOxdOlSLF++HKNGjVLpP3fuXFRUVODMmTNIT09HfX09XFxcEBERgeXLl8PX11ftHjY2NsjKysLatWuxd+9eZGRkwNXVFStXrsSaNWt0SrbI+LXc7JTJFhER6cIoR7h6K45wGa/GRsDFBbh1C8jIAAIDDR0REREZmi6f20a3hovIGB0/Lk+2+vUDWqkKRURE1ComXERaYLFqIiLqDCZcRO1gsWoiIuosJlxE7WCxaiIi6iwmXETtYLFqIiLqLCZcRO3g7vJERNRZTLiI2sBi1URE1BWYcBG1gcWqiYioKzDhImoDpxOJiKgrMOEiagWLVRMRUVdhwkXUivR0oK4OGDIEGD3a0NEQEVFPxoSLqBUtpxNZrJqIiDqDCReRBo2NwIED8p85nUhERJ3FhItIAxarJiKirsSEi0iDb76R/8li1URE1BWYcBHdg8WqiYioqzHhIrrH+fPAxYssVk1ERF2HCRfRPVismoiIuhoTLqJ7cHd5IiLqaky4iFpgsWoiItIHJlxELbBYNRER6QMTLqIWOJ1IRET6wISL6DcsVk1ERPrChIvoNyxWTURE+sKEi+g3LFZNRET6woSLCCxWTURE+sWEiwi/F6t2cmKxaiIi6npMuIjAYtVERKRfRptw5eXlYdasWXB0dISNjQ38/PyQlJSk9fnJycmIiIjAyJEj4ejoiL59+2LkyJGIiYlBYWGhWv+ioiLExcXB398fgwYNgpWVFdzd3bFo0SIUFBRovEd0dDQkEkmrL+oZWhar5nQiERHpg1H+t3xGRgZCQ0NhbW2NiIgI2NnZYe/evQgPD0dpaSlWrlzZ7jUOHTqE3NxcTJo0CTNnzoSlpSXOnz+PxMRE7Ny5E4cOHcL06dOV/VevXo09e/ZgzJgxmDt3Luzt7fHTTz/hs88+w5dffomUlBT4+/trvNeyZcvg6OjYVW+fuhmLVRMRkb5JhBDC0EG01NjYiJEjR+Lq1avIzc3FhAkTAAAymQy+vr4oLi5GYWEhPDw82rxObW0trK2t1dq/++47PProo5g4cSLy8vKU7Tt27MD48ePx4IMPqvTfvXs3nn76aTzwwAM4e/asyrHo6GgkJibi8uXL8PT07NgbbqGyshIODg6QyWSwt7fv9PVIOxs3AqtWATNnAocOGToaIiLqKXT53Da6KcXDhw/j0qVLiIyMVCZbAODg4IBVq1ahvr4eiYmJ7V5HU7IFAMHBwXBycsLFixdV2qOjo9WSLQCIiIjA8OHDce7cOdy8eVO3N0M9gmL91pw5ho2DiIhMl9FNKWZmZgIAQkJC1I6F/jbfk5WV1eHr5+Tk4M6dO5imw1fRLC0tAQAWraymPnDgAKqqqiCVSjFq1CgEBwfDysqqwzFS92lZrJoJFxER6YvRJVxFRUUAAG9vb7VjLi4usLW1VfbRRlpaGo4fP466ujoUFRXhwIEDcHZ2xrvvvqvV+d9//z3Onj0LHx+fVtdpvfTSSyq/u7q6IiEhQZkgtqaurg51dXXK3ysrK7WKibrO/v3yRfMsVk1ERPpkdFOKMpkMgHwKURN7e3tlH22kpaVh3bp1ePvtt7F37164u7sjJSUFEydO1CqWqKgomJmZYdOmTWrH/f39kZSUhCtXruDu3bsoKirC+vXrUVFRgTlz5iA/P7/N62/cuBEODg7Kl7u7u9bvi7oGv51IRETdwegSrq62efNmCCFQVVWFEydOYMSIEZg6dSp27drV5nl3797F/PnzUVBQgA0bNiAwMFCtz+LFi/HUU0/B3d0d1tbWGDZsGFavXo33338f9fX1WL9+fZv3iI2NhUwmU75KS0s781ZJRzU1LFZNRETdw+gSLsXIVmujWIpvBOjK1tYWvr6+2LdvH0aOHImlS5fil19+0di3trYWc+fORUZGBmJjY7Fq1Sqd7hUVFQVra2tkZ2e32U8qlcLe3l7lRd0nLY3FqomIqHsYXcKlWLulaZ1WeXk5qqurNa7v0paFhQWCgoJQU1Ojccrv7t27mDNnDtLT0/Hqq68iLi5O53uYm5vD0dERNTU1HY6T9I/FqomIqLsYXcIVEBAAQL726l6pqakqfTqqrKwMwO/fPlS4e/cu5s6di/T0dLz88suIj4/v0PWvXLmC8vLyLtmbi/SDxaqJiKg7GV3CFRwcjKFDh2LXrl04ffq0sl0mkyEuLg5WVlZYtGiRsv369esoKChQm4JsbcF6amoqvvrqKzg6OmLy5MnKdsU0Ynp6OlasWIG//e1vbcZZXl6Oa9euqbVXVFQgOjoaABAZGdne2yUDYbFqIiLqTka3LYSFhQW2bduG0NBQ+Pv7q5T2KSkpwebNm1VGjmJjY5GYmIiEhARlogMAPj4+GDNmDMaNGwc3NzfU1NTgxx9/xNGjR2FpaYnt27fDxsZG2f/5559Heno6XFxcYGdnh7Vr16rFFh0drbx3QUEBZsyYgSlTpsDb2xsDBgxAaWkpUlJScOvWLUyfPh2vvvqqnp4SdRaLVRMRUXcyyo+aoKAgHDt2DGvWrMGePXvQ0NCAsWPHIj4+HuHh4VpdIy4uDhkZGcjKysIvv/wCMzMzDB48GEuXLsXy5csxatQolf7FxcUA5CNX69at03jNwMBAZcLl5eWF6Oho5OXlYd++fZDJZLC1tcW4ceMQGRmJJUuWwNzcvMPPgPSHxaqJiKi7GV0txd6MtRS7x7lz8m8lWlkBN28CdnaGjoiIiHqiHl1LkUjfFKNbwcFMtoiIqHsw4aJeh8WqiYiouzHhol6FxaqJiMgQmHBRr8Ji1UREZAhMuKhX4bcTiYjIEJhwUa/Rslg1pxOJiKg7MeGiXqNlseoxYwwdDRER9SZMuKjXYLFqIiIyFCZc1CuwWDURERkSEy7qFXJyWKyaiIgMhwkX9QqK6UQWqyYiIkNgwkUmj8WqiYjI0Jhwkck7fx64eFFerDo01NDREBFRb8SEi0yeonYii1UTEZGhMOEik6eYTuRmp0REZChMuMiksVg1EREZAyZcZNJYrJqIiIwBEy4yafx2IhERGQMmXGSyWKyaiIiMBRMuMlksVk1ERMaCCReZLBarJiIiY8GEi0wSi1UTEZExYcJFJonFqomIyJgw4SKTxGLVRERkTJhwkclhsWoiIjI2TLjI5LBYNRERGRsmXGRyFMWqp09nsWoiIjIOTLjI5HA6kYiIjI3RJlx5eXmYNWsWHB0dYWNjAz8/PyQlJWl9fnJyMiIiIjBy5Eg4Ojqib9++GDlyJGJiYlBYWNjqeampqQgICICdnR3s7e0RFBSE7777rtX+hYWFWLBgAZydndGnTx+MHz8eH374IYQQOr1f6hosVk1ERMbIKL+/lZGRgdDQUFhbWyMiIgJ2dnbYu3cvwsPDUVpaipUrV7Z7jUOHDiE3NxeTJk3CzJkzYWlpifPnzyMxMRE7d+7EoUOHMH36dJVzPv/8cyxcuBADBgxAdHQ0AGDPnj2YMWMGkpKS8OSTT6r0P3fuHKZMmYK7d+9iwYIFGDRoEA4ePIg//elPOHfuHP7xj3902TMh7bBYNRERGSVhZBoaGoSXl5eQSqXi1KlTyvaKigoxfPhwYWVlJYqLi9u9zt27dzW2f/vttwKAmDhxokr77du3haOjo3B2dhalpaXK9tLSUuHs7CycnZ1FZWWlyjn+/v4CgDh06JCyra6uTjzyyCMCgDh+/Lg2b1lJJpMJAEImk+l0Hv3u8ceFAITYsMHQkRARkanT5XPb6KYUDx8+jEuXLiEyMhITJkxQtjs4OGDVqlWor69HYmJiu9extrbW2B4cHAwnJydcvHhRpf2LL75ARUUFXnrpJbi5uSnb3dzc8OKLL+LmzZv46quvlO2FhYU4cuQIgoKCMHPmTGW7lZUVNmzYAADYunWrVu+ZukbLYtVcv0VERMbE6BKuzMxMAEBISIjasdDfvuOflZXV4evn5OTgzp07GHNPNWNd79tW/2nTpsHGxqZTcZLu0tKA2loWqyYiIuNjdGu4ioqKAADe3t5qx1xcXGBra6vso420tDQcP34cdXV1KCoqwoEDB+Ds7Ix3331X6/sq2lret63+5ubmGDJkCM6dO4fGxkZYtLLVeV1dHerq6pS/V1ZWav2+SB2LVRMRkbEyuoRLJpMBkE8hamJvb6/so420tDS88847yt+HDRuG3bt34+GHH9b6vvb29ip9tI2zubkZVVVVcHJy0thn48aNWLdundbvhVrX1MRi1UREZLyMbkqxq23evBlCCFRVVeHEiRMYMWIEpk6dil27dhk6NMTGxkImkylfpaWlhg6pxzp+nMWqiYjIeBldwqUYMWptFKuysrLVUaW22NrawtfXF/v27cPIkSOxdOlS/PLLL1rdVzHV1/K+2sQpkUhg18ZW51KpFPb29iov6hgWqyYiImNmdAmXpvVSCuXl5aiurta4bkpbFhYWCAoKQk1NDfLz87W6r6b1Wm31b2pqwuXLlzFkyJBW129R12GxaiIiMnZGl3AFBAQAkK+9uldqaqpKn44qKysDAFhaWnb4vm31P3bsGGpqajodJ2mHxaqJiMjo6X9bMN00NDSIoUOHtrnx6eXLl5XtZWVl4vz586KiokLlOnl5eRqvn5KSIiwtLYWjo6Oorq5Wtt++fVs4ODh06can2dnZOr13bnzaMRs3yjc7DQszdCRERNSb6PK5bXTzXRYWFti2bRtCQ0Ph7++vUtqnpKQEmzdvhqenp7J/bGwsEhMTkZCQoCzHAwA+Pj4YM2YMxo0bBzc3N9TU1ODHH3/E0aNHYWlpie3bt8PGxkbZ38nJCe+//z4WLlyIhx56COHh4QDkpX1u3bqFPXv2qK3H+uc//4mpU6di3rx5CA8Ph6urKw4ePIizZ8/ixRdfxJQpU/T6rEiO04lERGT0uiEB7JATJ06IsLAwYW9vL/r06SN8fX3F7t271fpFRUUJACIhIUGlPS4uTsyYMUPcf//9wsrKSlhbW4vhw4eLpUuXinPnzrV63+TkZPHII48IGxsbYWtrKwICAkR6enqr/QsKCsSTTz4p+vXrJ6RSqRg7dqz44IMPRHNzs87vmSNcurt+XQiJRD7Cde2aoaMhIqLeRJfPbYkQQhg456PfKL6BKZPJ+I1FLW3dCixdKi9W/f33ho6GiIh6E10+t41u0TyRLr75Rv7nnDmGjYOIiKgtTLiox2KxaiIi6imYcFGPxWLVRETUUzDhoh6LxaqJiKin0Dnhunbtmj7iINJJy2LVXL9FRETGTueEy9PTE48//ji++uorNDY26iMmona1LFb9yCOGjoaIiKhtOidcrq6uOHToEJ588kncf//9eOWVV3D+/Hl9xEbUKharJiKinkTnhKukpATJycl48sknUVlZiXfeeQdjxozBlClT8Mknn6C6ulofcRIpsVg1ERH1NJ3a+PTOnTvYuXMntm/fjtOnT0MikaBv375YsGABFi9ejKlTp3ZlrCaPG59q5/x54IEH5MWqb94E7qm4RERE1C26beNTJycnvPjiizh58iROnz6NP//5z7C2tkZCQgL8/f0xatQobN68GTdu3OjMbYhUKEa3pk9nskVERD1Dl5f2aWhowL59+7B9+3akp6dDCAELCwvU1dV15W1MEke4tDN5MpCbC3z4IfD884aOhoiIeitdPre7fLmxpaUlnnjiCVhbW0MmkyE3N5ffZqQuU14OnDgh/5nbQRARUU/RpQlXUVERtm/fjk8//RTl5eUQQsDT0xPPPPNMV96GerH9++WL5n18gEGDDB0NERGRdjqdcP3666/Ys2cPtm/fjuPHj0MIAalUivDwcMTExCA4OLgr4iQCwGLVRETUM3U44crOzsb27dvxxRdfoKamBkIIjB8/HjExMfh//+//wcnJqSvjJGKxaiIi6rF0Trji4+ORkJCAoqIiCCHg4OCA5557DjExMXj44Yf1ESMRABarJiKinkvnhCs2NhYAEBAQgJiYGDz55JOwtrbu8sCI7sVi1URE1FN1KOFavHgxvLy89BEPkUYsVk1ERD2ZzgnXW2+9BQA4cuQI8vLyIJFI4Ovri2nTpnV5cEQKLFZNREQ9mc4JV2NjI5544gkcUAw3/GbevHn44osvYGbWqc3riTRisWoiIurJdM6O3n//fezfvx8DBgzAc889h+eeew4DBw7Evn378M9//lMfMVIvx2LVRETU0+lc2sfX1xcXL17EuXPn4OLiAgAoLy/HAw88gOHDhyM3N1cvgfYGLO2jGYtVExGRMdJr8eoLFy7gD3/4gzLZAgAXFxfMnz8f58+f1z1aonawWDUREfV0OidcVVVVcHd3V2t3d3dHdXV1lwRF1BKnE4mIqKfr0Ap3iYZNkDS1EXVWy2LVs2cbNhYiIqKO6tD3va5evYrvv/9erQ0A8vLyoGlZmK+vb0duRb3cgQPyRfMTJwL332/oaIiIiDqmQwnXJ598gk8++UStXQgBPz8/jec0NTV15FbUy3E6kYiITIHOCVdUVJQ+4iBSw2LVRERkKnROuBISEvQRh5q8vDysWbMGx48fR0NDA8aOHYsVK1ZgwYIF7Z4rhEBKSgq++eYbZGdno6SkBA0NDfD29kZ4eDhWrFihVv9x7dq1WLduXZvXXbx4scrIXnR0NBITE9uMgzqOxaqJiMhUGOWe3RkZGQgNDYW1tTUiIiJgZ2eHvXv3Ijw8HKWlpVi5cmWb59fV1WHWrFmQSqUIDAxEaGgoamtrkZqaitdffx379u1DZmYm+vbtqzwnMDCw1ett27YN165dQ2hoqMbjy5Ytg6OjY0feKrXhm2/kf86Zw2LVRETUs+m88enixYt1v4lEonHNlyaNjY0YOXIkrl69itzcXEyYMAEAIJPJ4Ovri+LiYhQWFsLDw6PVazQ0NGDTpk3405/+BCcnJ5X2J554Avv378emTZvwyiuvtBvPjRs34ObmBgcHB5SVlcHKykp5TDHCdfnyZXh6emr1/trCjU9/19QEuLjINzo9fBgICjJ0RERERKp0+dzWeYRrx44dWveVSCQQQuiUcB0+fBiXLl3CM888o0y2AMDBwQGrVq1SJjlvvPFGq9ewtLTE66+/rrE9NjYW+/fvR1ZWllYJV2JiIhobG7Fw4UKVZIv06/hxebLFYtVERGQKdE64cnJytOp38eJFrF27FpcuXdLp+pmZmQCAkJAQtWOKKb2srCydrtmSpaUlAMBCywrIikRxyZIlrfY5cOAAqqqqIJVKMWrUKAQHBzM56yQWqyYiIlOi80fZpEmT2jx+8+ZNrFu3Dlu3bkV9fT2mTZuG+Ph4ra9fVFQEAPD29lY75uLiAltbW2Wfjti+fTsAzQndvY4ePYrCwkL4+flh9OjRrfZ76aWXVH53dXVFQkJCq2u+FOrq6lBXV6f8vbKyst2YegMWqyYiIlPToZ3mNfn111+xfv16eHl54YMPPoC3tze+/vprHDlyBJMnT9b6OjKZDIB8ClETe3t7ZR9dJScn46OPPsKoUaMQExPTbv/2Rrf8/f2RlJSEK1eu4O7duygqKsL69etRUVGBOXPmID8/v83rb9y4EQ4ODsqXppJJvVFBAXDxorxYdTs5KxERUc8gOqmxsVF88MEHwsXFRUgkEuHu7i62b98umpqaOnS9GTNmCACiqKhI4/FBgwYJe3t7na/7/fffCzs7O+Hk5CR+/vnndvvLZDLRt29fYWtrK6qqqnS61yeffCIAiNmzZ7fZr7a2VshkMuWrtLRUABAymUyn+5majRuFAIQICzN0JERERK2TyWRaf253aoTriy++wAMPPICXXnoJdXV1ePvtt1FYWIhnnnkGZmYdu7RiZKu1USzFNwJ0kZ+fj5CQEJiZmSE1NbXN6UGF3bt349dff0V4eDhsbW11ul9UVBSsra2RnZ3dZj+pVAp7e3uVF3E6kYiITE+HsqLMzExMmjQJERERuHLlClauXIn//ve/ePXVV9U2FNWVYu2WpnVa5eXlqK6u1ri+qzX5+fmYMWMGmpubkZqaCh8fH63O27ZtG4C2F8u3xtzcHI6OjqipqdH53N6OxaqJiMgU6ZxwzZw5E8HBwTh58iSioqJQVFSETZs2ddnGnwEBAQCAtLQ0tWOpqakqfdqjSLaampqQkpLS7oJ/hZ9++gl5eXkYPXp0q7Uh23LlyhWUl5d3yd5cvQ2LVRMRkSnS+VuKqampkEgkGDx4MMrLy7F06dJ2z5FIJDh48KBW1w8ODsbQoUOxa9cu/OUvf1HZ+DQuLg5WVlZYtGiRsv/169chk8ng6uqqMtX4ww8/YMaMGWhsbERKSopOC/cVi+XbWlhfXl6OpqYm3H9PVlBRUYHo6GgAQGRkpNb3JDlOJxIRkSnSeaf5jqzNkkgkaGpq0rp/a6V9SkpKsHnzZpXSPoqNUBMSEpSJzu3btzFs2DDcuXMHYWFhGke2HB0dsXz5crX2+vp6DBo0CFVVVSgrK0P//v01xpiZmYkZM2ZgypQp8Pb2xoABA1BaWoqUlBTcunUL06dPx8GDB3WaYu3tO83X1ADOzvL6iT/+CIwda+iIiIiIWqfXneYvX77c4cC0FRQUhGPHjmHNmjXYs2ePsnh1fHw8wsPD2z2/srISd+7cAQCkpKQgJSVFrY+Hh4fGhGvfvn24desWFixY0GqyBQBeXl6Ijo5GXl4e9u3bB5lMBltbW4wbNw6RkZFYsmQJzM3NtX/TxGLVRERksnQe4SL96e0jXM88A+zYASxbBvzv/xo6GiIiorbp8rndZRufEnVGU5N8wTzA9VtERGR6mHCRUWCxaiIiMmVMuMgosFg1ERGZMiZcZHAti1XPmWPYWIiIiPSBCRcZXMti1WFhho6GiIio6zHhIoNTjG5Nnw7Y2Rk2FiIiIn1gwkUGx93liYjI1DHhIoNisWoiIuoNmHCRQbFYNRER9QZMuMigOJ1IRES9ARMuMpiaGuDbb+U/M+EiIiJTxoSLDIbFqomIqLdgwkUG88038j/nzAEkEsPGQkREpE9MuMggWKyaiIh6EyZcZBAsVk1ERL0JEy4yCBarJiKi3oQJF3U7FqsmIqLehgkXdTsWqyYiot6GCRd1OxarJiKi3oYJF3U77i5PRES9DRMu6lYsVk1ERL0REy7qVixWTUREvRETLupWnE4kIqLeiAkXdRsWqyYiot6KCRd1m/R0ebFqT08WqyYiot6FCRd1m5bTiSxWTUREvQkTLuoWLFZNRES9GRMu6hYsVk1ERL2Z0SZceXl5mDVrFhwdHWFjYwM/Pz8kJSVpda4QAsnJyXjhhRcwbtw4ODg4oG/fvhg/fjzi4uJQW1ur8TyJRNLqKzo6WuM5lZWVWLFiBTw8PCCVSuHp6YlXXnkF1dXVHX3rJonFqomIqDeTCCGEoYO4V0ZGBkJDQ2FtbY2IiAjY2dlh7969KCkpwebNm7Fy5co2z6+trUWfPn0glUoRGBiIsWPHora2FqmpqSgqKoKPjw8yMzPRt29flfMkEgk8PDw0JlcTJkzAvHnzVNpqamowbdo0nD59GiEhIXjwwQdx6tQppKWlwcfHB0eOHIG1tbXW77uyshIODg6QyWSwt7fX+jxjJwQwfLi8fmJSEvDUU4aOiIiIqPN0+twWRqahoUF4eXkJqVQqTp06pWyvqKgQw4cPF1ZWVqK4uLjNa9TX14s333xT3L59W6199uzZAoDYtGmT2nkAREBAgNaxvvHGGwKAeO2111TaX3vtNQFAxMXFaX0tIYSQyWQCgJDJZDqdZ+zOnRMCEMLKSojKSkNHQ0RE1DV0+dw2uinFw4cP49KlS4iMjMSECROU7Q4ODli1ahXq6+uRmJjY5jUsLS3x+uuvw8nJSa09NjYWAJCVldWpOIUQ2LZtG2xtbbF69WqVY6tXr4atrS22bdvWqXuYCharJiKi3s7oVtNkZmYCAEJCQtSOhYaGAuhcsmRpaQkAsGhlIVFFRQU+/vhj3Lx5E/369cPUqVMxduxYtX5FRUUoKytDaGgobGxsVI7Z2Nhg6tSpSE1NRWlpKdzd3Tscryng7vJERNTbGV3CVVRUBADw9vZWO+bi4gJbW1tln47Yvn07AM0JHQCcOXMGzz33nEpbWFgYEhMTMXDgQK3iVLQr1oy1lnDV1dWhrq5O+XtlZaX2b6SHYLFqIiIiI/yWokwmAyCfQtTE3t5e2UdXycnJ+OijjzBq1CjExMSoHV+5ciWOHz+OmzdvorKyEsePH8fMmTORkpKCxx9/HE1NTTrF2bKfJhs3boSDg4PyZYojYSxWTUREZIQJl77k5eUhPDwcDg4O+OKLLyCVStX6bN68GZMnT0b//v1hZ2eHyZMn48CBAwgICEBeXh6+VsyNdZHY2FjIZDLlq7S0tEuvbww4nUhERGSECZdixKi1kSHFVzB1kZ+fj5CQEJiZmSE1NRWjR4/W+lwzMzM8++yzAIDs7Gyd4mzZTxOpVAp7e3uVlylhsWoiIiI5o0u4FGuiNK3TKi8vR3V1davrpjTJz8/HjBkz0NzcjNTUVPj4+Ogck7OzMwD5vlvaxNmyXZdYTQ2LVRMREckZXcIVEBAAAEhLS1M7lpqaqtKnPYpkq6mpCSkpKZg0aVKHYjrx26pvT09PZZu3tzcGDRqE7OxslUQMkCdm2dnZGDJkiEmuy9IWi1UTERHJGV3CFRwcjKFDh2LXrl04ffq0sl0mkyEuLg5WVlZYtGiRsv369esoKChQm9r74YcfMGPGDDQ2NiI5ORmTJ09u874//fQTGhoa1NqPHz+O+Ph4WFpa4qkWW6RLJBIsWbIE1dXV2LBhg8o5GzZsQHV1tXIqsjdisWoiIqLf9fjSPtHR0UhMTERCQoKyJM/t27cxbNgw3LlzB2FhYRpHthwdHbF8+XKV6xw8eBDTpk2Du7s7LC0tcfbsWaSlpUEikeCDDz7A888/r3KNmpoaTJ06FWfOnEFISAgeeughnDx5UlnaJysrC3369NH6fZtSaZ+jRwF/f3mx6hs3gN+2PyMiIjIZunxuG90+XAAQFBSEY8eOYc2aNdizZw8aGhowduxYxMfHIzw8vN3zKysrcefOHQBASkoKUlJS1Pp4eHioJFxz585FRUUFzpw5g/T0dNTX18PFxQURERFYvnw5fH191a5hY2ODrKwsrF27Fnv37kVGRgZcXV2xcuVKrFmzRqdky9R88438z1mzmGwREREZ5QhXb2UqI1xCACNGAEVFLFZNRESmS5fPbaNbw0U9X0GBPNmysgLCwgwdDRERkeEx4aIux2LVREREqphwUZdTrN+aM8ewcRARERkLJlzUpW7cAHJz5T8z4SIiIpJjwkVdav9+FqsmIiK6FxMu6lIsVk1ERKSOCRd1GRarJiIi0owJF3UZFqsmIiLSjAkXdRkWqyYiItKMCRd1CRarJiIiah0TLuoSx48DN2/Ki1VPm2boaIiIiIwLEy7qEixWTURE1DomXNRpQnA7CCIiorYw4aJOY7FqIiKitjHhok5jsWoiIqK2MeGiTmOxaiIiorYx4aJOYbFqIiKi9jHhok5hsWoiIqL2MeGiTuG3E4mIiNrHhIs6rGWxak4nEhERtY4JF3VYy2LVY8caOhoiIiLjxYSLOozFqomIiLTDhIs6hMWqiYiItMeEizokJ0derNrRkcWqiYiI2sOEizpEMZ342GMsVk1ERNQeJlykMxarJiIi0g0TLtIZi1UTERHphgkX6YzFqomIiHRjtAlXXl4eZs2aBUdHR9jY2MDPzw9JSUlanSuEQHJyMl544QWMGzcODg4O6Nu3L8aPH4+4uDjU1taqnVNUVIS4uDj4+/tj0KBBsLKygru7OxYtWoSCggKN94mOjoZEImn1ZapYrJqIiEg3FoYOQJOMjAyEhobC2toaERERsLOzw969exEeHo7S0lKsXLmyzfPr6uowa9YsSKVSBAYGIjQ0FLW1tUhNTcXrr7+Offv2ITMzE3379lWes3r1auzZswdjxozB3LlzYW9vj59++gmfffYZvvzyS6SkpMDf31/j/ZYtWwZHR8eufARGi8WqiYiIOkAYmYaGBuHl5SWkUqk4deqUsr2iokIMHz5cWFlZieLi4javUV9fL958801x+/ZttfbZs2cLAGLTpk0qxxISEsTJkyfVrvXvf/9bABAPPPCA2rGoqCgBQFy+fFn7N9gGmUwmAAiZTNYl19OHrVuFAISYONHQkRARERmWLp/bRjelePjwYVy6dAmRkZGYMGGCst3BwQGrVq1CfX09EhMT27yGpaUlXn/9dTg5Oam1x8bGAgCysrJUjkVHR+PBBx9Uu1ZERASGDx+Oc+fO4ebNmx18V6aD304kIiLSndFNKWZmZgIAQkJC1I6FhoYCUE+WdGH526ZRFhbav/X2zjlw4ACqqqoglUoxatQoBAcHw8rKqsMxGisWqyYiIuoYo0u4ioqKAADe3t5qx1xcXGBra6vs0xHbt28HoDmh0+T777/H2bNn4ePj0+o6rZdeeknld1dXVyQkJCgTxNbU1dWhrq5O+XtlZaVWMRkKi1UTERF1jNFNKcpkMgDyKURN7O3tlX10lZycjI8++gijRo1CTEyMVrFERUXBzMwMmzZtUjvu7++PpKQkXLlyBXfv3kVRURHWr1+PiooKzJkzB/n5+W1ef+PGjXBwcFC+3N3dO/S+uguLVRMREXWM0SVc+pKXl4fw8HA4ODjgiy++gFQqbbP/3bt3MX/+fBQUFGDDhg0IDAxU67N48WI89dRTcHd3h7W1NYYNG4bVq1fj/fffR319PdavX9/mPWJjYyGTyZSv0tLSzrxFvWKxaiIioo4zuoRLMbLV2ihWZWVlq6NfrcnPz0dISAjMzMyQmpqK0aNHt9m/trYWc+fORUZGBmJjY7Fq1Sqd7hcVFQVra2tkZ2e32U8qlcLe3l7lZaxYrJqIiKjjjC7hUqzd0rROq7y8HNXV1RrXd7UmPz8fM2bMQHNzM1JTU+Hj49Nm/7t372LOnDlIT0/Hq6++iri4ON3eAABzc3M4OjqipqZG53ONFYtVExERdZzRJVwBAQEAgLS0NLVjqampKn3ao0i2mpqakJKSgkmTJrXZ/+7du5g7dy7S09Px8ssvIz4+Xsfo5a5cuYLy8nJ4enp26Hxjw2LVREREnWN0CVdwcDCGDh2KXbt24fTp08p2mUyGuLg4WFlZYdGiRcr269evo6CgQG0K8ocffsCMGTPQ2NiI5ORkTJ48uc37KqYR09PTsWLFCvztb39rs395eTmuXbum1l5RUYHo6GgAQGRkZDvvtmdgsWoiIqLOMbptISwsLLBt2zaEhobC399fpbRPSUkJNm/erDJyFBsbi8TERCQkJCgTndu3b2PGjBmoqKhAWFgY0tPTkZ6ernIfR0dHLF++XPn7888/j/T0dLi4uMDOzg5r165Viy06Olp574KCAsyYMQNTpkyBt7c3BgwYgNLSUqSkpODWrVuYPn06Xn311S5+OoahqJ0YFMRi1URERB1hdAkXAAQFBeHYsWNYs2YN9uzZg4aGBowdOxbx8fEIDw9v9/zKykrcuXMHAJCSkoKUlBS1Ph4eHioJV3FxMQD5yNW6des0XjcwMFCZcHl5eSE6Ohp5eXnYt28fZDIZbG1tMW7cOERGRmLJkiUwNzfX7Y0bKU4nEhERdY5ECCEMHQTJKb6BKZPJjOYbizduAK6u8nVcV68C999v6IiIiIiMgy6f20a3houMy/798mRr4kQmW0RERB3FhIvapJhOZO1EIiKijmPCRa1qWaya67eIiIg6jgkXtYrFqomIiLoGEy5qFYtVExERdQ0mXKQRi1UTERF1HSZcpBGLVRMREXUdJlykEYtVExERdR0mXKSGxaqJiIi6FhMuUsNi1URERF2LCRepYbFqIiKirsWEi9RwOpGIiKhrMeEiFTduALm58p9ZzoeIiKhrMOEiFSxWTURE1PWYcJEKxfotjm4RERF1HSZcpFRTI6+fCHD9FhERUVdiwkVKLFZNRESkH0y4SInFqomIiPSDCRcBUC1WzfVbREREXYsJFwFQLVb9yCOGjoaIiMi0MOEiACxWTUREpE9MuIjFqomIiPSMCRcpi1VbWgKhoYaOhoiIyPQw4SLlZqfTpwP29oaNhYiIyBQx4SJOJxIREekZE65ejsWqiYiI9I8JVy/HYtVERET6x4Srl2OxaiIiIv0z2oQrLy8Ps2bNgqOjI2xsbODn54ekpCStzhVCIDk5GS+88ALGjRsHBwcH9O3bF+PHj0dcXBxqa2tbPTc1NRUBAQGws7ODvb09goKC8N1337Xav7CwEAsWLICzszP69OmD8ePH48MPP4QQQuf33N1YrJqIiKh7SIQRZgYZGRkIDQ2FtbU1IiIiYGdnh71796KkpASbN2/GypUr2zy/trYWffr0gVQqRWBgIMaOHYva2lqkpqaiqKgIPj4+yMzMRN++fVXO+/zzz7Fw4UIMGDAA4eHhAIA9e/bg5s2bSEpKwpNPPqnS/9y5c5gyZQru3r2LBQsWYNCgQTh48CDOnj2LF198Ef/4xz90et+VlZVwcHCATCaDfTd8XXDfPmD+fHmx6v/+l/UTiYiIdKHT57YwMg0NDcLLy0tIpVJx6tQpZXtFRYUYPny4sLKyEsXFxW1eo76+Xrz55pvi9u3bau2zZ88WAMSmTZtUjt2+fVs4OjoKZ2dnUVpaqmwvLS0Vzs7OwtnZWVRWVqqc4+/vLwCIQ4cOKdvq6urEI488IgCI48eP6/TeZTKZACBkMplO53VUdLQQgBDLlnXL7YiIiEyKLp/bRjelePjwYVy6dAmRkZGYMGGCst3BwQGrVq1CfX09EhMT27yGpaUlXn/9dTg5Oam1x8bGAgCysrJUjn3xxReoqKjASy+9BDc3N2W7m5sbXnzxRdy8eRNfffWVsr2wsBBHjhxBUFAQZs6cqWy3srLChg0bAABbt27V7c13IxarJiIi6j5Gl3BlZmYCAEJCQtSOhf62Dfq9yZIuLH8rFGhhYdGp+7bVf9q0abCxselUnPrGYtVERETdx6L9Lt2rqKgIAODt7a12zMXFBba2tso+HbF9+3YA6olSW/dVtLW8b1v9zc3NMWTIEJw7dw6NjY1qyZ1CXV0d6urqlL9XVlbq8lY6hcWqiYiIuo/RjXDJZDIA8ilETezt7ZV9dJWcnIyPPvoIo0aNQkxMjNb3VSyEa3lfbeJsbm5GVVVVq/Fs3LgRDg4Oype7u7tub6iDWKyaiIioexldwqUveXl5CA8Ph4ODA7744gtIpVJDh4TY2FjIZDLlq7S0tFvue+ECi1UTERF1J6ObUlSMGLU2ilVZWam2GL49+fn5CAkJgZmZGVJTUzF69Og279u/f3+1e7bso22cEokEdnZ2rcYllUoNkvgpRrdYrJqIiKh7GN0Il6b1Ugrl5eWorq7WuG6qNfn5+ZgxYwaam5uRmpoKHx8fne+rab1WW/2bmppw+fJlDBkypNX1W4bE6UQiIqLuZXQJV0BAAAAgLS1N7VhqaqpKn/Yokq2mpiakpKRg0qRJXXbftvofO3YMNTU1WsfZnVoWq54927CxEBER9RrdsC+YThoaGsTQoUPb3Pj08uXLyvaysjJx/vx5UVFRoXKd/Px84ejoKGxtbcWxY8fave/t27eFg4NDl258mp2drdN7746NT7dtk292+vDDersFERFRr6DL57bRzXdZWFhg27ZtCA0Nhb+/v8bSPp6ensr+sbGxSExMREJCAqKjowEAt2/fxowZM1BRUYGwsDCkp6cjXVE08DeOjo5Yvny58ncnJye8//77WLhwIR566CGV0j63bt3Cnj171NZj/fOf/8TUqVMxb948hIeHw9XVVaW0z5QpU/TyjDqD04lEREQG0A0JYIecOHFChIWFCXt7e9GnTx/h6+srdu/erdYvKipKABAJCQnKtsuXLwsAbb48PDw03jc5OVk88sgjwsbGRtja2oqAgACRnp7eapwFBQXiySefFP369RNSqVSMHTtWfPDBB6K5uVnn96zvEa7qaiGsreUjXGfO6OUWREREvYYun9tGWby6t9J38WoWqyYiIuo6unxuG92iedIfxXTinDlMtoiIiLoTE65eomWxaq7fIiIi6l5Gt2ieus6VK/IC1QBw6pT8Z1tb+evkScDZGRg82LAxEhER9QZMuEzUlSvAiBFAba1qe3U1oNiOzNpaXuaHSRcREZF+cUrRRN28qZ5s3au29vcRMCIiItIfJlxEREREesaEi4iIiEjPmHARERER6RkTLiIiIiI9Y8JFREREpGdMuIiIiIj0jAmXiXJ2lu+z1RZra3k/IiIi0i9ufGqiBg+Wb2ra1j5b3GmeiIioezDhMmGDBzOhIiIiMgacUiQiIiLSMyZcRERERHrGhIuIiIhIz5hwEREREekZEy4iIiIiPWPCRURERKRnTLiIiIiI9IwJFxEREZGeceNTIyKEAABUVlYaOBIiIiJqj+LzWvH53RYmXEakqqoKAODu7m7gSIiIiEhbVVVVcHBwaLOPRGiTllG3aG5uRllZGezs7CCRSLr02pWVlXB3d0dpaSns7e279Nokx2fcPficuwefc/fgc+4e+nrOQghUVVVh0KBBMDNre5UWR7iMiJmZGdzc3PR6D3t7e/6PWs/4jLsHn3P34HPuHnzO3UMfz7m9kS0FLponIiIi0jMmXERERER6xoSrl5BKpVizZg2kUqmhQzFZfMbdg8+5e/A5dw8+5+5hDM+Zi+aJiIiI9IwjXERERER6xoSLiIiISM+YcBERERHpGRMuIiIiIj1jwmXi8vLyMGvWLDg6OsLGxgZ+fn5ISkoydFgm4/PPP8dzzz2HiRMnQiqVQiKRYMeOHYYOy6Rcu3YN//u//4uQkBAMHjwYVlZWcHFxwRNPPIETJ04YOjyTUVtbixUrVsDf3x+DBg2CtbU1XFxcMHXqVCQkJKChocHQIZq0+Ph4SCQSSCQS5ObmGjock+Dp6al8pve+AgMDuz0e7jRvwjIyMhAaGgpra2tERETAzs4Oe/fuRXh4OEpLS7Fy5UpDh9jj/fWvf0VJSQmcnZ3h6uqKkpISQ4dkcv7xj38gPj4eXl5eCAkJwYABA1BUVIR9+/Zh37592LVrF8LDww0dZo9XXV2NDz/8EL6+vnjssccwYMAA3LlzB8nJyVi8eDF2796N5OTkdsuXkO5+/vlnrFmzBjY2NqipqTF0OCbFwcEBy5cvV2v39PTs9li4LYSJamxsxMiRI3H16lXk5uZiwoQJAACZTAZfX18UFxejsLAQHh4ehg20h/v222/h7e0NDw8PvP3224iNjUVCQgKio6MNHZrJ+M9//oP+/fsjICBApf3o0aMIDg6Gra0trl+/zn2MOqm5uRmNjY2wsrJSaW9sbMSMGTOQmZmJAwcO4LHHHjNQhKapoaEBfn5+sLS0hLe3Nz7//HPk5OTAz8/P0KH1eIqkqri42KBxKPA/VUzU4cOHcenSJURGRiqTLUCe7a9atQr19fVITEw0XIAm4tFHH2XSqmd/+MMf1JItAHjkkUcQFBSEO3fu4KeffjJAZKbFzMxMLdkCAAsLC8yfPx8AcPHixe4Oy+S99dZbOHv2LLZv3w5zc3NDh0N6xClFE5WZmQkACAkJUTsWGhoKAMjKyurOkIi6nKWlJQB5UkD60dzcjJSUFADAmDFjDByNaTl58iTeeustrF+/Hg888IChwzFJdXV12LFjB8rKymBvbw8fHx9MmjTJILHw/6VMVFFREQDA29tb7ZiLiwtsbW2VfYh6oitXruDbb7+Fq6srxo4da+hwTEZ9fT3i4uIghMCtW7fw3XffoaCgAM888wyCg4MNHZ7JqKurw6JFizBhwgS8+uqrhg7HZJWXl+OZZ55RafPx8cG///1veHl5dWssTLhMlEwmAyCfQtTE3t5e2Yeop2loaMDChQtRV1eH+Ph4TsV0ofr6eqxbt075u0Qiwcsvv4yNGzcaMCrT88Ybb6CoqAg//PAD//3qyTPPPINHHnkEY8aMga2tLQoLC7FlyxZ89tlnCA4Oxk8//QQ7O7tui4druIioR2lubkZ0dDSOHDmCZ599FgsXLjR0SCbF1tYWQgg0NTWhtLQUH3zwAbZt24bAwEBUVlYaOjyTkJOTg82bN+Ovf/0rp2n1aM2aNZg+fToGDhyIvn37YsKECfj000+xcOFClJSUYOvWrd0aDxMuE6UY2WptFKuysrLV0S8iY9Xc3IzFixdj165d+OMf/4h//etfhg7JZJmZmcHNzQ0vvPACPv74Y2RnZ+Ott94ydFg9XmNjI6KiojBu3Dj8z//8j6HD6ZWee+45AEB2dna33pcJl4lSrN3StE6rvLwc1dXVGtd3ERmr5uZmPPPMM0hMTMTTTz+NHTt2cE+obqL48o3iyzjUcdXV1SgqKsLp06dhZWWlshmn4pvjkydPhkQiwb59+wwbrIlydnYGgG7f84xruExUQEAANm7ciLS0NERERKgcS01NVfYh6gkUydann36K8PBwfPbZZ1z30o3KysoA/P6tUOo4qVSKmJgYjceOHDmCoqIizJkzBwMGDDDI5py9gaJCRbc/X0EmqaGhQQwdOlRIpVJx6tQpZXtFRYUYPny4sLKyEpcvXzZYfKZo48aNAoBISEgwdCgmpampSURFRQkA4qmnnhINDQ2GDskknT17VtTU1Ki119TUiLCwMAFAvPXWWwaIrPdQ/DvPyckxdCg93vnz5zX+ez5//rxwcXERAERWVla3xsQRLhNlYWGBbdu2ITQ0FP7+/iqlfUpKSrB582b+11MX2LZtG44dOwYAys03t23bppx6mTZtGpYsWWKo8EzC+vXrkZiYCFtbWwwfPhxvvvmmWp958+apbPBLuktKSsKWLVswbdo0eHp6wt7eHteuXUNycjJu3bqFRx55BP/f//f/GTpMIq3s3r0bW7Zsgb+/Pzw8PGBjY4PCwkIcOnQIDQ0NiI2Nhb+/f7fGxITLhAUFBeHYsWNYs2YN9uzZg4aGBowdOxbx8fGsPddFjh07prZjf3Z2tspiTCZcnaMoy1FdXd3qom1PT08mXJ30+OOPo6ysDMePH0dOTg6qq6vh4OCAcePGISIiAosXL+YGs9RjBAUF4fz58zh16hSOHj2KX3/9Fc7Ozpg1axb+9Kc/adwUXN9YS5GIiIhIz/gVHyIiIiI9Y8JFREREpGdMuIiIiIj0jAkXERERkZ4x4SIiIiLSMyZcRERERHrGhIuIiIhIz5hwEREREekZEy4ioi6WmZkJiUSCtWvXGjoUIjISTLiIyKCKi4shkUgQFham0h4dHQ2JRKIs7WNsJBIJAgMDDR0GEfUQLIxFRNTFfH19cf78eTg7Oxs6FCIyEky4iIi6WN++fTFy5EhDh0FERoRTikRkdDw9PZGYmAgAGDJkCCQSicYpvMuXL2PJkiUYPHgwpFIpXF1dER0djZKSErVrKs6/du0aFi1aBBcXF5iZmSEzMxMAkJGRgcWLF2PEiBGwtbWFra0tJk6ciI8//ljlOor1WQCQlZWljE0ikWDHjh0qfTSt4fr555+xYMECDBw4EFKpFEOGDMHy5ctx69Ytjc/B09MT1dXVWLZsGQYNGgSpVIpx48bhyy+/1Pp57tixQxlfWloapkyZgr59+6J///6IiorSeG8A2L9/P4KCguDg4IA+ffpg/Pjx2LJlCxobG7W+NxHJcYSLiIzO8uXLsWPHDpw5cwbLli2Do6MjAHkConDixAmEhoaipqYGjz/+OLy9vVFcXIydO3ciOTkZOTk5GDp0qMp1b926hcmTJ6Nfv36IiIhAbW0t7O3tAQDx8fG4ePEi/Pz8MH/+fFRUVCAlJQXPPfccLly4gHfeeUcZw5o1a7Bu3Tp4eHggOjpaef0JEya0+b6OHTuG0NBQ1NfX48knn4SnpydycnLw3nvv4cCBA8jNzVWbhmxoaEBISAju3LmDJ554Ar/++it2796NBQsWICUlBSEhIVo/12+++QYHDx7E7NmzMWXKFBw5cgSffvopLl26hGPHjqn03bJlC1auXIl+/fohMjISNjY2+Oabb7By5UocPXoU//nPf5SJJxFpQRARGdDly5cFABEaGqrSHhUVJQCIy5cvq51TX18vPD09hZ2dnTh58qTKsaNHjwpzc3Px+OOPq7QDEADEM888IxobG9Wu+d///letraGhQcyYMUOYm5uLkpIStesFBARofE8ZGRkCgFizZo2yrampSXh5eQkAIiUlRaX/K6+8IgCIxYsXq7R7eHgIAGLu3Lmirq5O2f7tt99qfGatSUhIEACEhYWFOHbsmLK9sbFRBAYGCgAiJydH2X7x4kVhYWEhBg4cKK5cuaJsr62tFdOmTRMAxKeffqrVvYlIjlOKRNTjHDhwAMXFxXjllVfw4IMPqhybNm0a5s6di0OHDqGyslLlmJWVFTZt2gRzc3O1aw4ZMkStzcLCAs8//zyampqQkZHRqZizs7Nx6dIlzJw5E6GhoSrH3njjDfTr1w+7du1CfX292rnvvvsurKyslL8HBwfDw8MDeXl5OsUQGRmJqVOnKn83NzdHVFQUAKhca9euXWhsbMTKlSvh7u6ubJdKpYiPjwcA5fQpEWmHU4pE1OPk5uYCAC5cuKBxnVR5eTmam5tRWFiIiRMnKtuHDBnS6jcHq6qqsHnzZuzbtw+XLl1CTU2NyvGysrJOxXzq1CkA0LiVhGK9WFpaGi5cuICxY8cqjzk6OmpMBt3c3JCTk6NTDA8//LDG6wBARUWFVrFOnjwZ1tbWOH36tE73JurtmHARUY9z+/ZtAMDOnTvb7Hdv0nTfffdp7FdfX4/AwECcPHkSDz74IBYuXIj+/fvDwsICxcXFSExMRF1dXadiVoy2tRaDq6urSj8FBwcHjf0tLCzQ3NysUwyK9Wr3XgcAmpqatIpVIpHgvvvuw7Vr13S6N1Fvx4SLiHocReKwf/9+PP7441qf19oi76+//honT55ETEwMtm3bpnJs9+7dym9MdoYi5hs3bmg8Xl5ertLPkFrG6uHhoXJMCIEbN24YRZxEPQnXcBGRUVKss2o58qIwadIkANB5Sq01ly5dAgDMnTtX7djRo0c1nmNmZqYxttYo1poptqFoqaamBvn5+ejTpw9GjBih9TX1pa1YT5w4gdra2na/kUlEqphwEZFR6tevHwCgtLRU7djcuXMxePBgbNmyBUeOHFE73tDQoLbNQVsUozj3npOVlYWtW7e2Gt/Vq1e1vsfUqVPh5eWF5ORkfPvttyrH3nzzTdy6dQtPP/20yuJ4Q4mMjISFhQW2bNmisnatvr4er732GgCobIfR0NCAgoICZeJKROo4pUhERmn69OnYvHkzli5diieeeAI2Njbw8PDAwoULIZVK8eWXX2LmzJkICAjA9OnTMXbsWEgkEpSUlODo0aPo378/CgoKtLrX7Nmz4enpiU2bNuHnn3/GmDFjcOHCBRw4cADz58/XuMno9OnTkZSUhHnz5uHBBx+Eubk55syZg3Hjxmm8h5mZGXbs2IHQ0FDMmjULTz31FDw8PJCTk4PMzEx4eXnh7bff7tQz6ypeXl6Ij4/HypUrMW7cOCxYsAA2NjbYv38/Lly4gLlz5+KPf/yjsv+1a9cwatQoeHh4GG3tSyJDY8JFREZp5syZ2LRpE7Zu3Yp33nkHDQ0NCAgIwMKFCwEAPj4+OHPmDP72t7/h0KFDyM7OhlQqxf3334958+bh6aef1vpetra2OHz4MF555RUcOXIEmZmZGD16NHbu3In77rtPY8L13nvvAQAOHz6M/fv3o7m5GW5ubq0mXIB8y4rc3FysX78eaWlpkMlkGDRoEJYtW4a//vWvRlV7ccWKFRg2bBi2bNmCzz//HPX19Rg+fDjeeecd/OUvf+Gmp0Q6kgghhKGDICIiIjJlXMNFREREpGdMuIiIiIj0jAkXERERkZ4x4SIiIiLSMyZcRERERHrGhIuIiIhIz5hwEREREekZEy4iIiIiPWPCRURERKRnTLiIiIiI9IwJFxEREZGeMeEiIiIi0jMmXERERER69v8DCoCh705GOhkAAAAASUVORK5CYII=", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "plot_obj_func()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Example using ensemble gradient approximation with the conjugate gradient (CG) method from scipy.minimize: " - ] - }, - { - "cell_type": "code", - "execution_count": 22, - "metadata": { - "scrolled": true - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - " message: Maximum number of iterations has been exceeded.\n", - " success: False\n", - " status: 1\n", - " fun: -0.37443170946723164\n", - " x: [-1.023e-01 -1.007e-01 -2.088e-01]\n", - " nit: 5\n", - " jac: [ 0.000e+00 2.207e-06 0.000e+00]\n", - " nfev: 21\n", - " njev: 21\n" - ] - } - ], - "source": [ - "res = minimize(ensemble.function, x0, args=(cov,), method='CG', jac=ensemble.gradient, tol=ko['tol'],\n", - " callback=ot.save_optimize_results, bounds=bounds, options=ko)\n", - "print(res)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Example calling EnOpt through scipy.minimize (this does exactly the same as running EnOpt, but with a different random seed since we do not reset the seed):" - ] - }, - { - "cell_type": "code", - "execution_count": 23, - "metadata": { - "scrolled": false - }, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2023-12-14 10:22:29,796 : INFO : popt.loop.optimize : ====== Running optimization - EnOpt ======\n", - "2023-12-14 10:22:29,797 : INFO : popt.loop.optimize : \n", - "{'alpha': 0.2,\n", - " 'alpha_maxiter': 3,\n", - " 'beta': 0.1,\n", - " 'callback': None,\n", - " 'constraints': (),\n", - " 'datatype': ['fopt', 'fgpt', 'fwpt', 'fwit'],\n", - " 'hessian': False,\n", - " 'hessp': None,\n", - " 'inflation_factor': 10,\n", - " 'maxiter': 5,\n", - " 'nesterov': True,\n", - " 'optimizer': 'GA',\n", - " 'resample': 0,\n", - " 'restart': False,\n", - " 'restartsave': True,\n", - " 'savedata': ['alpha', 'obj_func_values'],\n", - " 'tol': 1e-06}\n", - "2023-12-14 10:22:29,797 : INFO : popt.loop.optimize : iter alpha_iter obj_func step-size cov[0,0] \n", - "2023-12-14 10:22:29,798 : INFO : popt.loop.optimize : 0 -1.9083e-01 \n", - "2023-12-14 10:22:38,680 : INFO : popt.loop.optimize : 1 0 -3.0921e-01 2.00e-01 3.90e-02 \n", - "2023-12-14 10:22:47,943 : INFO : popt.loop.optimize : 2 0 -3.6664e-01 2.00e-01 3.90e-02 \n", - "2023-12-14 10:23:00,146 : INFO : popt.loop.optimize : Optimization converged in 2 iterations \n", - "2023-12-14 10:23:00,147 : INFO : popt.loop.optimize : Optimization converged with final obj_func = -0.3666\n", - "2023-12-14 10:23:00,147 : INFO : popt.loop.optimize : Total number of function evaluations = 3\n", - "2023-12-14 10:23:00,147 : INFO : popt.loop.optimize : Total number of jacobi evaluations = 2\n", - "2023-12-14 10:23:00,148 : INFO : popt.loop.optimize : Total elapsed time = 0.52 minutes\n", - "2023-12-14 10:23:00,148 : INFO : popt.loop.optimize : ============================================\n" - ] - }, - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 23, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "for file in glob('optimize_result_*'):\n", - " os.remove(file)\n", - "minimize(ensemble.function, x0, args=(cov,), method=EnOpt, jac=ensemble.gradient, hess=ensemble.hessian,\n", - " bounds=bounds, options=ko)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Plot the objective function using the function defined above:" - ] - }, - { - "cell_type": "code", - "execution_count": 24, - "metadata": { - "scrolled": false - }, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "plot_obj_func()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Setting up the .mako file\n", - "The optimization relies on a .mako file for writing the current control variables to the flow simulator input. In this case, the flow simulator is opm-flow [opm-projects.org](opm-projects.org), and the input file is provided as a text file (.DATA file). The .mako file is created by replacing the keywords WCONINJE and WCONPROD in the .DATA file with: \n", - " \n", - " WCONINJE\n", - " 'INJ-1' WATER 'OPEN' BHP 2* ${injbhp[0]} /\n", - " 'INJ-2' WATER 'OPEN' BHP 2* ${injbhp[1]} /\n", - " /\n", - "\n", - " WCONPROD\n", - " 'PRO-1' 'OPEN' BHP 5* ${prodbhp[0]} /\n", - " /\n" - ] - }, - { - "attachments": { - "jupyter_kernel.png": { - "image/png": "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" - } - }, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Running locally\n", - "\n", - "It is recommended to run the notebook from a virtual environment. Follow these steps to run this notebook on your own computer: \n", - " \n", - "*Step 1: Create virtual environment as normal*\n", - "\n", - " python3 -m venv pet_venv\n", - "\n", - "Then activate the environment using:\n", - "\n", - " source pet_venv/bin/activate\n", - "\n", - "*Step 2: Install Jupyter Notebook into virtual environment*\n", - "\n", - " python3 -m pip install ipykernel\n", - "\n", - "*Step 3: Install PET in the virtual environment, see [PET installation](https://github.com/Python-Ensemble-Toolbox/PET)*\n", - "\n", - "*Step 4: Allow Jupyter access to the kernel within the virtual environment*\n", - "\n", - " python3 -m ipykernel install --user --name=pet_venv\n", - "\n", - "Start jupyter notebook, and load tutorial_popt.ipynb (this file). On the jupyter notebook toolbar, select ‘Kernel’ and ‘Change Kernel’. The new kernel is now be available in the list for selection:\n", - " \n", - "![jupyter_kernel.png](attachment:jupyter_kernel.png)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "pet_ecalc_venv", - "language": "python", - "name": "pet_ecalc_venv" - }, - "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.8.10" - } - }, - "nbformat": 4, - "nbformat_minor": 4 -} diff --git a/docs/tutorials/usefull/tutorial_petdataframe.ipynb b/docs/tutorials/usefull/tutorial_petdataframe.ipynb new file mode 100644 index 00000000..ee3df54c --- /dev/null +++ b/docs/tutorials/usefull/tutorial_petdataframe.ipynb @@ -0,0 +1,1342 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "1a0de4c2", + "metadata": {}, + "source": [ + "# The PETDataFrame\n", + "\n", + "A PET run keeps its data in three tables -- the observed data, its variance,\n", + "and the ensemble prediction -- plus the adjoints, when the simulator produces\n", + "them. All four are\n", + "`PETDataFrame` (`misc/structures/structures.py`), a `pandas.DataFrame` subclass\n", + "that adds the handful of operations PET needs and keeps everything pandas\n", + "already gives you.\n", + "\n", + "The reason it exists is that these tables are *ragged*. A cell is not a number:\n", + "it holds whatever one data type produced at one report point -- a well rate (a\n", + "scalar), a seismic vintage (an array of thousands of values), or nothing at all.\n", + "An analysis, meanwhile, wants a plain `(nd, ne)` matrix with the rows in a fixed\n", + "order, and wants to be sure the observation vector, the variance vector and the\n", + "prediction matrix are indexed the same way.\n", + "\n", + "`PETDataFrame` is what sits between those two views. This tutorial goes through\n", + "what it can do." + ] + }, + { + "cell_type": "markdown", + "id": "50251d51", + "metadata": {}, + "source": [ + "## The table\n", + "\n", + "Four report dates, two well rates and a seismic response that only exists at two\n", + "of them." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "398ea872", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-26T08:35:22.782435Z", + "iopub.status.busy": "2026-08-26T08:35:22.781953Z", + "iopub.status.idle": "2026-08-26T08:35:23.119293Z", + "shell.execute_reply": "2026-08-26T08:35:23.118885Z" + } + }, + "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", + "
WOPR:PRO1WWPR:PRO1SEISMIC
dates
2023-02-052578.20.002None
2024-03-113253.90.037[0.11, 0.07, 0.15, 0.09]
2025-04-152454.20.481None
2026-05-202794.82.941[0.19, 0.12, 0.23, 0.14]
\n", + "
" + ], + "text/plain": [ + " WOPR:PRO1 WWPR:PRO1 SEISMIC\n", + "dates \n", + "2023-02-05 2578.2 0.002 None\n", + "2024-03-11 3253.9 0.037 [0.11, 0.07, 0.15, 0.09]\n", + "2025-04-15 2454.2 0.481 None\n", + "2026-05-20 2794.8 2.941 [0.19, 0.12, 0.23, 0.14]" + ] + }, + "execution_count": 1, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "import datetime as dt\n", + "\n", + "import numpy as np\n", + "import pandas as pd\n", + "\n", + "from misc.structures import PETDataFrame\n", + "\n", + "dates = pd.to_datetime([\"2023-02-05\", \"2024-03-11\", \"2025-04-15\", \"2026-05-20\"])\n", + "\n", + "obs = PETDataFrame(\n", + " {\n", + " \"WOPR:PRO1\": [2578.2, 3253.9, 2454.2, 2794.8],\n", + " \"WWPR:PRO1\": [0.002, 0.037, 0.481, 2.941],\n", + " \"SEISMIC\": [\n", + " None,\n", + " np.array([0.11, 0.07, 0.15, 0.09]),\n", + " None,\n", + " np.array([0.19, 0.12, 0.23, 0.14]),\n", + " ],\n", + " },\n", + " index=dates,\n", + " name=\"observed\",\n", + ")\n", + "obs.index.name = \"dates\"\n", + "obs" + ] + }, + { + "cell_type": "markdown", + "id": "54b8e4b3", + "metadata": {}, + "source": [ + "`name`, `is_ensemble` and the scaling parameters are declared in `_metadata`, so\n", + "they survive slicing, copying and arithmetic -- more on that at the end." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "7097900d", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-26T08:35:23.124288Z", + "iopub.status.busy": "2026-08-26T08:35:23.123902Z", + "iopub.status.idle": "2026-08-26T08:35:23.127348Z", + "shell.execute_reply": "2026-08-26T08:35:23.126974Z" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "('observed', False, False)" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "obs.name, obs.is_ensemble, obs.is_scaled" + ] + }, + { + "cell_type": "markdown", + "id": "989f6fd7", + "metadata": {}, + "source": [ + "## `to_matrix()`: one table, one vector\n", + "\n", + "This is the method the whole class is built around. It walks the table and\n", + "returns the numbers as an array, flattening any cell that holds one." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "9319e33f", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-26T08:35:23.140290Z", + "iopub.status.busy": "2026-08-26T08:35:23.140133Z", + "iopub.status.idle": "2026-08-26T08:35:23.146601Z", + "shell.execute_reply": "2026-08-26T08:35:23.146020Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(16,) float64\n" + ] + }, + { + "data": { + "text/plain": [ + "array([2.5782e+03, 2.0000e-03, 3.2539e+03, 3.7000e-02, 1.1000e-01,\n", + " 7.0000e-02, 1.5000e-01, 9.0000e-02, 2.4542e+03, 4.8100e-01,\n", + " 2.7948e+03, 2.9410e+00, 1.9000e-01, 1.2000e-01, 2.3000e-01,\n", + " 1.4000e-01])" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "d = obs.to_matrix()\n", + "print(d.shape, d.dtype)\n", + "d" + ] + }, + { + "cell_type": "markdown", + "id": "2f516eec", + "metadata": {}, + "source": [ + "Sixteen numbers out of a 4x3 table: two scalars at every date, plus four seismic\n", + "values at each of the two dates that have them, and nothing for the two empty\n", + "cells.\n", + "\n", + "Two flags control the edges:\n", + "\n", + "| flag | default | effect |\n", + "| --- | --- | --- |\n", + "| `filter` | `True` | skip cells that are entirely missing (`None`/`NaN`) |\n", + "| `squeeze` | `True` | return `(nd,)` rather than `(nd, 1)` |" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "6b040526", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-26T08:35:23.150240Z", + "iopub.status.busy": "2026-08-26T08:35:23.150100Z", + "iopub.status.idle": "2026-08-26T08:35:23.161066Z", + "shell.execute_reply": "2026-08-26T08:35:23.160184Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "filter=True (16,) float64\n", + "filter=False (18,) object\n", + "squeeze=False (16, 1)\n" + ] + } + ], + "source": [ + "print(\"filter=True \", obs.to_matrix().shape, obs.to_matrix().dtype)\n", + "print(\"filter=False \", obs.to_matrix(filter=False).shape, obs.to_matrix(filter=False).dtype)\n", + "print(\"squeeze=False\", obs.to_matrix(squeeze=False).shape)" + ] + }, + { + "cell_type": "markdown", + "id": "99a8d725", + "metadata": {}, + "source": [ + "Keeping the empty cells forces an object array, which is why `filter=True` is\n", + "the default: the analysis wants floats.\n", + "\n", + "The row order is worth knowing before you write anything that reasons about\n", + "individual rows. It is **time-major** -- the table is walked row by row, so the\n", + "data types interleave within each report point rather than being blocked\n", + "together. `to_series()` shows the same ordering with its labels attached:" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "f507fe28", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-26T08:35:23.162648Z", + "iopub.status.busy": "2026-08-26T08:35:23.162517Z", + "iopub.status.idle": "2026-08-26T08:35:23.172673Z", + "shell.execute_reply": "2026-08-26T08:35:23.171298Z" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "dates datatype \n", + "2023-02-05 WOPR:PRO1 2578.2\n", + " WWPR:PRO1 0.002\n", + " SEISMIC None\n", + "2024-03-11 WOPR:PRO1 3253.9\n", + " WWPR:PRO1 0.037\n", + " SEISMIC [0.11, 0.07, 0.15, 0.09]\n", + "2025-04-15 WOPR:PRO1 2454.2\n", + " WWPR:PRO1 0.481\n", + " SEISMIC None\n", + "2026-05-20 WOPR:PRO1 2794.8\n", + " WWPR:PRO1 2.941\n", + " SEISMIC [0.19, 0.12, 0.23, 0.14]\n", + "dtype: object" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "obs.to_series()" + ] + }, + { + "cell_type": "markdown", + "id": "63e08a0d", + "metadata": {}, + "source": [ + "## Reading data in\n", + "\n", + "The observed data of a real case is a CSV, and `from_csv` is a thin wrapper over\n", + "`pd.read_csv` that hands back a `PETDataFrame`. This is the file the\n", + "[TinyBox PIPT tutorial](https://python-ensemble-toolbox.github.io/PET/tutorials/pipt/TinyBox/tutorial_pipt)\n", + "assimilates:" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "90915f70", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-26T08:35:23.174360Z", + "iopub.status.busy": "2026-08-26T08:35:23.174178Z", + "iopub.status.idle": "2026-08-26T08:35:23.198651Z", + "shell.execute_reply": "2026-08-26T08:35:23.197703Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "PETDataFrame (10, 7) -> (70,)\n" + ] + }, + { + "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", + " \n", + "
WOPR:PRO1WWPR:PRO1WOPR:PRO2WWPR:PRO2
dates
2023-02-052578.204232-0.0020492074.9396450.002560
2024-03-113253.9021900.0371532180.3340860.000093
2025-04-152454.2492830.4807022472.0841270.044738
2026-05-202794.8078682.9407812663.8940660.296100
\n", + "
" + ], + "text/plain": [ + " WOPR:PRO1 WWPR:PRO1 WOPR:PRO2 WWPR:PRO2\n", + "dates \n", + "2023-02-05 2578.204232 -0.002049 2074.939645 0.002560\n", + "2024-03-11 3253.902190 0.037153 2180.334086 0.000093\n", + "2025-04-15 2454.249283 0.480702 2472.084127 0.044738\n", + "2026-05-20 2794.807868 2.940781 2663.894066 0.296100" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "tinybox = PETDataFrame.from_csv(\n", + " \"../pipt/TinyBox/data.csv\", index_col=0, parse_dates=True\n", + ")\n", + "\n", + "print(type(tinybox).__name__, tinybox.shape, \"->\", tinybox.to_matrix().shape)\n", + "tinybox.iloc[:4, :4]" + ] + }, + { + "cell_type": "markdown", + "id": "a438c378", + "metadata": {}, + "source": [ + "`from_pickle` does the same for a pickled frame, and `from_pandas` adopts a\n", + "frame you already have, carrying over its `attrs` -- any units or provenance you\n", + "hung on it -- which plain construction drops." + ] + }, + { + "cell_type": "markdown", + "id": "3ae99a5e", + "metadata": {}, + "source": [ + "## `merge_dataframes()`: one table per member, one table for the ensemble\n", + "\n", + "The simulator returns one table per ensemble member. `merge_dataframes` stacks\n", + "them into a single table whose cells hold the ensemble: a scalar becomes a\n", + "`(ne,)` array, a field becomes `(nx, ne)`.\n", + "\n", + "This is exactly what `ensemble.calc_prediction` does with the raw simulator\n", + "output, and with the adjoints beside it." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "c89384c2", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-26T08:35:23.200308Z", + "iopub.status.busy": "2026-08-26T08:35:23.200167Z", + "iopub.status.idle": "2026-08-26T08:35:23.236100Z", + "shell.execute_reply": "2026-08-26T08:35:23.235169Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "is_ensemble : True\n", + "scalar cell : (20,)\n", + "field cell : (4, 20)\n" + ] + } + ], + "source": [ + "rng = np.random.default_rng(4)\n", + "ne = 20\n", + "\n", + "\n", + "def one_member():\n", + " \"\"\"A single member's forecast, in the shape a simulator returns it.\"\"\"\n", + " df = pd.DataFrame(\n", + " {\n", + " \"WOPR:PRO1\": obs[\"WOPR:PRO1\"].to_numpy() * rng.normal(1, 0.05, 4),\n", + " \"WWPR:PRO1\": obs[\"WWPR:PRO1\"].to_numpy() * rng.normal(1, 0.30, 4),\n", + " \"SEISMIC\": [\n", + " None,\n", + " obs.at[dates[1], \"SEISMIC\"] + rng.normal(0, 0.02, 4),\n", + " None,\n", + " obs.at[dates[3], \"SEISMIC\"] + rng.normal(0, 0.02, 4),\n", + " ],\n", + " },\n", + " index=dates,\n", + " )\n", + " df.index.name = \"dates\"\n", + " return df\n", + "\n", + "\n", + "pred = PETDataFrame.merge_dataframes([one_member() for _ in range(ne)])\n", + "\n", + "print(\"is_ensemble :\", pred.is_ensemble)\n", + "print(\"scalar cell :\", pred.at[dates[0], \"WOPR:PRO1\"].shape)\n", + "print(\"field cell :\", pred.at[dates[1], \"SEISMIC\"].shape)" + ] + }, + { + "cell_type": "markdown", + "id": "cf37c919", + "metadata": {}, + "source": [ + "The merge is strict about geometry: every member must carry the same index and\n", + "the same columns, or it raises rather than quietly aligning. And because\n", + "`is_ensemble` is now set, `to_matrix()` knows the last axis of each cell is the\n", + "ensemble and gives back a matrix instead of a longer vector:" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "9818a29f", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-26T08:35:23.238138Z", + "iopub.status.busy": "2026-08-26T08:35:23.238020Z", + "iopub.status.idle": "2026-08-26T08:35:23.241941Z", + "shell.execute_reply": "2026-08-26T08:35:23.241290Z" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "(16, 20)" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "Y = pred.to_matrix()\n", + "Y.shape" + ] + }, + { + "cell_type": "markdown", + "id": "1d756f4d", + "metadata": {}, + "source": [ + "Sixteen rows again -- the same sixteen, in the same order, as the observation\n", + "vector. That correspondence is the point of the class.\n", + "\n", + "## Three frames, one geometry\n", + "\n", + "All three tables are built on the same index and columns -- the variance\n", + "cell-for-cell on the data, the prediction put there by `filter_dataframe` -- so\n", + "`to_matrix()` walks them in the same order and the data misfit is a one-liner\n", + "with no bookkeeping:" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "a86b4247", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-26T08:35:23.243686Z", + "iopub.status.busy": "2026-08-26T08:35:23.243546Z", + "iopub.status.idle": "2026-08-26T08:35:23.251203Z", + "shell.execute_reply": "2026-08-26T08:35:23.250813Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "d (16, 1) v (16, 1) Y (16, 20)\n", + "mean data misfit: 62.3\n" + ] + } + ], + "source": [ + "# Variance table: same geometry as the data, None wherever the data is None.\n", + "var = PETDataFrame(\n", + " {\n", + " col: [\n", + " None\n", + " if obs.at[idx, col] is None\n", + " else 0.01 * np.atleast_1d(np.asarray(obs.at[idx, col], float)) ** 2 + 1e-8\n", + " for idx in obs.index\n", + " ]\n", + " for col in obs.columns\n", + " },\n", + " index=obs.index,\n", + ")\n", + "\n", + "d = obs.to_matrix(squeeze=False) # (nd, 1)\n", + "v = var.to_matrix(squeeze=False) # (nd, 1)\n", + "Y = pred.to_matrix() # (nd, ne)\n", + "\n", + "misfit = np.sum((Y - d) ** 2 / v, axis=0)\n", + "\n", + "print(f\"d {d.shape} v {v.shape} Y {Y.shape}\")\n", + "print(f\"mean data misfit: {misfit.mean():.1f}\")" + ] + }, + { + "cell_type": "markdown", + "id": "935a5328", + "metadata": {}, + "source": [ + "PET's own diagnostics are written the same way -- see `get_outlier_index` in\n", + "`pipt.misc_tools.analysis_tools`, which is this calculation plus a threshold.\n", + "\n", + "The one thing to keep straight is the gaps. `filter=True` drops a row where\n", + "*that* frame is empty, so the three have to agree on where the empty cells are.\n", + "`DataReader.get_variance` guarantees it for the variance by building on\n", + "`data_df` cell for cell; a simulator reporting a vintage the data does not have\n", + "would not, and the vectors would come out different lengths.\n", + "\n", + "## `filter_dataframe()`: putting the simulator on the observation grid\n", + "\n", + "A simulator reports more than you assimilate: extra time steps, extra data\n", + "types. `filter_dataframe` cuts its output down to the observation table's\n", + "geometry, and it is the one line behind `sim_to_pred_data` in\n", + "`pipt.ensembles.forecast`:\n", + "\n", + "```python\n", + "pred.filter_dataframe(index=self.data_df.index, columns=self.data_df.columns)\n", + "```" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "6fc3155f", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-26T08:35:23.252563Z", + "iopub.status.busy": "2026-08-26T08:35:23.252245Z", + "iopub.status.idle": "2026-08-26T08:35:23.262870Z", + "shell.execute_reply": "2026-08-26T08:35:23.262196Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "simulator output (6, 5)\n" + ] + }, + { + "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", + "
WOPR:PRO1WWPR:PRO1SEISMIC
dates
2023-02-050.00.00.0
2024-03-112.02.02.0
2025-04-153.03.03.0
2026-05-205.05.05.0
\n", + "
" + ], + "text/plain": [ + " WOPR:PRO1 WWPR:PRO1 SEISMIC\n", + "dates \n", + "2023-02-05 0.0 0.0 0.0\n", + "2024-03-11 2.0 2.0 2.0\n", + "2025-04-15 3.0 3.0 3.0\n", + "2026-05-20 5.0 5.0 5.0" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "sim_dates = pd.to_datetime(\n", + " [\"2023-02-05\", \"2023-08-01\", \"2024-03-11\", \"2025-04-15\", \"2025-11-02\", \"2026-05-20\"]\n", + ")\n", + "raw = PETDataFrame(\n", + " {c: np.arange(6, dtype=float) for c in\n", + " [\"WOPR:PRO1\", \"WWPR:PRO1\", \"SEISMIC\", \"WBHP:PRO1\", \"WGOR:PRO1\"]},\n", + " index=sim_dates,\n", + ")\n", + "raw.index.name = \"dates\"\n", + "\n", + "print(f\"simulator output {raw.shape}\")\n", + "raw.filter_dataframe(index=obs.index, columns=obs.columns)" + ] + }, + { + "cell_type": "markdown", + "id": "ad154440", + "metadata": {}, + "source": [ + "Selection is by *label*, and it is deliberately tolerant about how the label is\n", + "spelled. Report points arriving from a TOML config are `datetime.date` objects\n", + "while the data CSV parses to a `DatetimeIndex`; those dtypes differ, but they\n", + "select each other perfectly well:" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "b629747f", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-26T08:35:23.264051Z", + "iopub.status.busy": "2026-08-26T08:35:23.263948Z", + "iopub.status.idle": "2026-08-26T08:35:23.269870Z", + "shell.execute_reply": "2026-08-26T08:35:23.269434Z" + } + }, + "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", + "
WOPR:PRO1WWPR:PRO1SEISMIC
dates
2023-02-050.00.00.0
2025-04-153.03.03.0
\n", + "
" + ], + "text/plain": [ + " WOPR:PRO1 WWPR:PRO1 SEISMIC\n", + "dates \n", + "2023-02-05 0.0 0.0 0.0\n", + "2025-04-15 3.0 3.0 3.0" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "report_points = pd.Index(\n", + " [dt.date(2023, 2, 5), dt.date(2025, 4, 15)], name=\"dates\"\n", + ")\n", + "\n", + "raw.filter_dataframe(index=report_points, columns=obs.columns)" + ] + }, + { + "cell_type": "markdown", + "id": "180977db", + "metadata": {}, + "source": [ + "A label that genuinely is not there is an error, not a silent gap:" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "5cc4031a", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-26T08:35:23.271359Z", + "iopub.status.busy": "2026-08-26T08:35:23.271173Z", + "iopub.status.idle": "2026-08-26T08:35:23.274250Z", + "shell.execute_reply": "2026-08-26T08:35:23.273788Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "ValueError: Provided index does not match DataFrame index: \"None of [DatetimeIndex(['2030-01-01'], dtype='datetime64[ns]', freq=None)] are in the [index]\"\n" + ] + } + ], + "source": [ + "try:\n", + " raw.filter_dataframe(index=pd.to_datetime([\"2030-01-01\"]))\n", + "except ValueError as exc:\n", + " print(\"ValueError:\", exc)" + ] + }, + { + "cell_type": "markdown", + "id": "bc9aafe9", + "metadata": {}, + "source": [ + "## Scaling, and keeping the derived quantities consistent\n", + "\n", + "Data types in a reservoir case differ by orders of magnitude -- oil rate in the\n", + "thousands, water cut around one. `scale()` normalises each column, records what\n", + "it used, and `invert_scale()` puts it back." + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "26c03202", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-26T08:35:23.275659Z", + "iopub.status.busy": "2026-08-26T08:35:23.275489Z", + "iopub.status.idle": "2026-08-26T08:35:23.282350Z", + "shell.execute_reply": "2026-08-26T08:35:23.281636Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "is_scaled : True\n", + "in [0, 1] : True\n", + "round trip: True\n" + ] + } + ], + "source": [ + "np.random.seed(404)\n", + "rates = PETDataFrame({k: 10 * np.random.rand(5) for k in (\"WOPR\", \"WWPR\", \"WBHP\")})\n", + "\n", + "scaled = rates.copy()\n", + "scaled.scale(type=\"max-min\") # or type=\"z-score\"\n", + "\n", + "print(\"is_scaled :\", scaled.is_scaled)\n", + "print(\"in [0, 1] :\", bool(((scaled >= 0) & (scaled <= 1)).all().all()))\n", + "\n", + "restored = scaled.copy()\n", + "restored.invert_scale(type=\"max-min\")\n", + "print(\"round trip:\", np.allclose(restored.to_numpy(), rates.to_numpy()))" + ] + }, + { + "cell_type": "markdown", + "id": "dd1c61f7", + "metadata": {}, + "source": [ + "The useful part is that the parameters are kept on the frame, so anything\n", + "*derived* from the data can be scaled to match. A variance is a squared\n", + "quantity, so it takes the squared range; a sensitivity is a derivative, so it\n", + "takes the range itself:\n", + "\n", + "$$\\tilde{d} = \\frac{d - d_{\\min}}{r}, \\qquad\n", + " \\tilde{\\sigma}^2 = \\frac{\\sigma^2}{r^2}, \\qquad\n", + " \\tilde{J} = \\frac{J}{r}, \\qquad r = d_{\\max} - d_{\\min}$$\n", + "\n", + "Passing `minimum`/`maximum` explicitly is how you apply those:" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "a2e26af6", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-26T08:35:23.283666Z", + "iopub.status.busy": "2026-08-26T08:35:23.283529Z", + "iopub.status.idle": "2026-08-26T08:35:23.288085Z", + "shell.execute_reply": "2026-08-26T08:35:23.287613Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "variance scaled by 1/r^2: True\n" + ] + } + ], + "source": [ + "r = scaled.scale_max - scaled.scale_min # kept from the scale() call\n", + "\n", + "variance = PETDataFrame({k: 0.1 * np.random.rand(5) for k in (\"WOPR\", \"WWPR\", \"WBHP\")})\n", + "\n", + "var_scaled = variance.copy()\n", + "var_scaled.scale(type=\"max-min\", minimum=0, maximum=r ** 2)\n", + "\n", + "print(\"variance scaled by 1/r^2:\", np.allclose(var_scaled.to_numpy(),\n", + " (variance / r ** 2).to_numpy()))" + ] + }, + { + "cell_type": "markdown", + "id": "27ad9244", + "metadata": {}, + "source": [ + "This is how a run keeps its pieces consistent when `scale_data` is on: the\n", + "ensemble scales the adjoints with `minimum=0, maximum=scale_max - scale_min`\n", + "taken straight off the data frame. Scaling twice is refused rather than silently\n", + "compounded:" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "3a76ba9a", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-26T08:35:23.289185Z", + "iopub.status.busy": "2026-08-26T08:35:23.289091Z", + "iopub.status.idle": "2026-08-26T08:35:23.291237Z", + "shell.execute_reply": "2026-08-26T08:35:23.290761Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "ValueError: DataFrame is already scaled, cannot apply max-min scaling again without inverting first.\n" + ] + } + ], + "source": [ + "try:\n", + " scaled.scale(type=\"max-min\")\n", + "except ValueError as exc:\n", + " print(\"ValueError:\", exc)" + ] + }, + { + "cell_type": "markdown", + "id": "b0c0b4dd", + "metadata": {}, + "source": [ + "## Jacobians and adjoints\n", + "\n", + "When a simulator computes adjoints, a cell no longer holds a value per member --\n", + "it holds a *gradient* per member, $\\partial d_i / \\partial x$, of length `nx`.\n", + "The table looks the same; only the cell contents grew an axis. `is_jacobian=True`\n", + "stacks those cells instead of flattening them:" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "036d60e4", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-26T08:35:23.292477Z", + "iopub.status.busy": "2026-08-26T08:35:23.292345Z", + "iopub.status.idle": "2026-08-26T08:35:23.304222Z", + "shell.execute_reply": "2026-08-26T08:35:23.303699Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "cell : (4, 20) (nx, ne)\n", + "to_matrix(is_jacobian=True): (6, 4, 20) (nd, nx, ne)\n", + "to_matrix() : (24, 20) -- flattened, not what you want\n" + ] + } + ], + "source": [ + "nx = 4\n", + "adj_dates = pd.to_datetime([\"2023-02-05\", \"2024-03-11\", \"2025-04-15\"])\n", + "adj_cols = [\"WOPR:PRO1\", \"WWPR:PRO1\"]\n", + "\n", + "\n", + "def one_member_adjoint():\n", + " df = pd.DataFrame(\n", + " {c: [rng.normal(size=nx) for _ in adj_dates] for c in adj_cols},\n", + " index=adj_dates,\n", + " )\n", + " df.index.name = \"dates\"\n", + " return df\n", + "\n", + "\n", + "adjoints = PETDataFrame.merge_dataframes([one_member_adjoint() for _ in range(ne)])\n", + "\n", + "print(\"cell :\", adjoints.at[adj_dates[0], \"WOPR:PRO1\"].shape, \"(nx, ne)\")\n", + "print(\"to_matrix(is_jacobian=True):\", adjoints.to_matrix(is_jacobian=True).shape, \"(nd, nx, ne)\")\n", + "print(\"to_matrix() :\", adjoints.to_matrix().shape, \"-- flattened, not what you want\")" + ] + }, + { + "cell_type": "markdown", + "id": "e3ff2ea8", + "metadata": {}, + "source": [ + "That first shape, `(nd, nx, ne)`, is what the schemes read when a simulator sets\n", + "`compute_adjoints`; `savedata = [\"adjoints\"]` in the `[dataassim]` block writes\n", + "the table itself to each iteration's `assimilation_result_{i}.npz`, as records.\n", + "\n", + "State variables can also be split across a `MultiIndex` column level, `(datatype,\n", + "parameter)`. `to_matrix` concatenates the parameter blocks per data type, so the\n", + "result is identical to having built one wide column in the first place:" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "c78d0256", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-26T08:35:23.305486Z", + "iopub.status.busy": "2026-08-26T08:35:23.305365Z", + "iopub.status.idle": "2026-08-26T08:35:23.317259Z", + "shell.execute_reply": "2026-08-26T08:35:23.316787Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "columns : [('WOPR:PRO1', 'permx'), ('WOPR:PRO1', 'poro'), ('WWPR:PRO1', 'permx'), ('WWPR:PRO1', 'poro')]\n", + "as a Jacobian : (6, 8) -- nx doubled to 8\n", + "same as flattened: True\n" + ] + } + ], + "source": [ + "wide = {}\n", + "for key in adj_cols:\n", + " for param in (\"permx\", \"poro\"):\n", + " wide[(key, param)] = [rng.normal(size=nx) for _ in adj_dates]\n", + "\n", + "multi = pd.DataFrame(wide, index=adj_dates)\n", + "multi.columns = pd.MultiIndex.from_tuples(wide.keys())\n", + "multi.index.name = \"dates\"\n", + "multi = PETDataFrame.from_pandas(multi)\n", + "\n", + "print(\"columns :\", list(multi.columns))\n", + "print(\"as a Jacobian :\", multi.to_matrix(is_jacobian=True).shape, \"-- nx doubled to 8\")\n", + "print(\"same as flattened:\", np.array_equal(\n", + " multi.to_matrix(is_jacobian=True),\n", + " multi._to_singlelevel_columns().to_matrix(is_jacobian=True),\n", + "))" + ] + }, + { + "cell_type": "markdown", + "id": "a8233cb2", + "metadata": {}, + "source": [ + "## It is still a DataFrame\n", + "\n", + "Nothing above costs you pandas. `_constructor` and `_metadata` are set so that\n", + "operations return a `PETDataFrame` with its flags intact rather than degrading\n", + "to a plain frame:" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "9acfdccc", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-26T08:35:23.318530Z", + "iopub.status.busy": "2026-08-26T08:35:23.318434Z", + "iopub.status.idle": "2026-08-26T08:35:23.322911Z", + "shell.execute_reply": "2026-08-26T08:35:23.322519Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " copy(): PETDataFrame is_ensemble=True\n", + " .loc[]: PETDataFrame is_ensemble=True\n", + " filter_dataframe(): PETDataFrame is_ensemble=True\n", + " map(): PETDataFrame is_ensemble=True\n" + ] + } + ], + "source": [ + "for label, out in [\n", + " (\"copy()\", pred.copy()),\n", + " (\".loc[]\", pred.loc[dates[:2]]),\n", + " (\"filter_dataframe()\", pred.filter_dataframe(columns=[\"WOPR:PRO1\"])),\n", + " (\"map()\", pred.map(lambda cell: cell)),\n", + "]:\n", + " print(f\"{label:>20}: {type(out).__name__:<13} is_ensemble={out.is_ensemble}\")" + ] + }, + { + "cell_type": "markdown", + "id": "0f74a763", + "metadata": {}, + "source": [ + "Which means the labels are there when you want to look at the ensemble, without\n", + "unpacking anything into arrays first:" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "id": "8dc60e77", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-26T08:35:23.324139Z", + "iopub.status.busy": "2026-08-26T08:35:23.324047Z", + "iopub.status.idle": "2026-08-26T08:35:23.895295Z", + "shell.execute_reply": "2026-08-26T08:35:23.894722Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "\n", + "fig, axes = plt.subplots(1, 2, figsize=(10, 3.5))\n", + "\n", + "for ax, col in zip(axes, [\"WOPR:PRO1\", \"WWPR:PRO1\"]):\n", + " members = np.vstack(pred[col].to_numpy()) # (ndates, ne)\n", + " ax.plot(pred.index, members, c=\"tab:blue\", lw=0.6, alpha=0.35)\n", + " ax.plot(obs.index, obs[col], \"o-\", c=\"crimson\", lw=1.6, label=\"observed\")\n", + " ax.set_title(col)\n", + " ax.tick_params(axis=\"x\", rotation=30)\n", + "\n", + "axes[0].set_ylabel(\"rate\")\n", + "axes[0].legend(fontsize=8)\n", + "fig.suptitle(\"Prior ensemble against the observations\", y=1.02)\n", + "plt.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "c098ad39", + "metadata": {}, + "source": [ + "## Where they come from in a real run\n", + "\n", + "| frame | built by | cells hold |\n", + "| --- | --- | --- |\n", + "| `data_df` | `DataReader.get_data()`, from `data = \"data.csv\"` | the observation |\n", + "| `data_var_df` | `DataReader.get_variance()`, on `data_df`'s geometry | its variance |\n", + "| `sim_data` | `merge_dataframes()` over the simulator's per-member output, on demand | `(ne,)` or `(nx, ne)` |\n", + "\n", + "On the analysis path the data are matrices, not frames. `DataLayout.from_frame(data_df)`\n", + "fixes the row order once -- label-major, then data type, empty cells skipped -- and\n", + "everything is built in that order: the ensemble's `obs_vector` and `obs_variance`\n", + "from the two frames, and `pred_data`, a `PredictedData` whose `(nd, ne)` `.matrix` is\n", + "filled straight from each member's simulator output. Adjoints are an `(nd, nx, ne)`\n", + "array with the same rows. `pred_data.to_frame()` gives the frame view back for\n", + "inspection, and `sim_data` is the full forecast as a frame, built when something asks\n", + "for it. That is why an analysis never has to think about ragged cells, missing\n", + "vintages, or what order the data types came in.\n", + "\n", + "---\n", + "\n", + "The state side of a run is a plain `(nx, ne)` array. Its `{name: (start, stop)}`\n", + "row map is a `StateLayout` (the ensemble's `state_layout`), which slices the matrix\n", + "back into the per-variable dictionaries a simulator expects." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "ed81d707", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-26T08:35:23.896649Z", + "iopub.status.busy": "2026-08-26T08:35:23.896463Z", + "iopub.status.idle": "2026-08-26T08:35:23.899864Z", + "shell.execute_reply": "2026-08-26T08:35:23.899444Z" + } + }, + "outputs": [], + "source": [ + "from misc.structures import StateLayout\n", + "\n", + "state, layout = StateLayout.from_dict(\n", + " {\"permx\": rng.normal(size=(10, ne)), \"poro\": rng.normal(size=(6, ne))}\n", + ")\n", + "\n", + "print(state.shape, layout.indices)\n", + "print({k: v.shape for k, v in layout.to_dict(state).items()})\n", + "print(\"one member ->\", {k: v.shape for k, v in layout.member_dicts(state)[0].items()})" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "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.12.3" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/mkdocs.yml b/mkdocs.yml index 3282a420..be67f434 100644 --- a/mkdocs.yml +++ b/mkdocs.yml @@ -11,6 +11,8 @@ nav: - Home: index.md - Reference: reference/ - Tutorials: tutorials/ + - Configuration: configuration.md + - Architecture: architecture.md - Bibliography: references.md - dev_guide.md @@ -89,7 +91,7 @@ plugins: handlers: python: # load_external_modules: true - paths: [.] + paths: [src] # NB: The following does not work coz pipt and popt contain submodules with the same name. # paths: [pipt, popt, simulator, ensemble, misc, input_output, tests] import: diff --git a/pyproject.toml b/pyproject.toml index 0dff01f7..0c70892d 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -13,33 +13,44 @@ maintainers = [ { name = "Kristian Fossum", email = "krfo@norceresearch.no" }, { name = "Rolf J. Lorentzen", email = "rolo@norceresearch.no" } ] -license = { file = "LICENSE.txt" } +license = { file = "LICENSE" } readme = "README.md" -requires-python = ">=3.8" +requires-python = ">=3.10" +classifiers = [ + "Development Status :: 4 - Beta", + "Intended Audience :: Science/Research", + "License :: OSI Approved :: GNU General Public License v3 (GPLv3)", + "Programming Language :: Python :: 3", + "Programming Language :: Python :: 3.10", + "Programming Language :: Python :: 3.11", + "Programming Language :: Python :: 3.12", + "Topic :: Scientific/Engineering", +] dependencies = [ "numpy", "scipy", "matplotlib", "h5py", - "mako", "tqdm", "PyWavelets", - "psutil", - "geostat @ git+https://github.com/Python-Ensemble-Toolbox/Geostatistics@main", - "pytest", + "geostat @ git+https://github.com/Python-Ensemble-Toolbox/Geostatistics@3f9f0c876815db140fae3404d322892190cb6728", "pandas", "p_tqdm", - #"mat73", - "opencv-python", - #"rips", "tomli", "tomli-w", "pyyaml", - #"scikit-learn", - #"pylops" + "sympy", ] +[project.scripts] +pet = "pet_cli.__main__:main" + [project.optional-dependencies] +dev = [ + "pytest", + "pytest-cov", + "ruff", +] doc = [ "mkdocs-material", "mkdocstrings", @@ -59,4 +70,30 @@ Homepage = "https://github.com/Python-Ensemble-Toolbox/PET" package-dir = {"" = "src"} [tool.setuptools.packages.find] -where = ["src"] \ No newline at end of file +where = ["src"] + +[tool.pytest.ini_options] +testpaths = ["tests"] +markers = [ + "slow: end-to-end assimilation with a parallel forecast; deselect with -m 'not slow'", +] + +[tool.ruff] +line-length = 120 +target-version = "py310" + +[tool.ruff.lint] +select = ["E", "F", "W"] +ignore = [ + "E501", # line length is handled by formatting, not a hard error + "F403", # star imports are used intentionally to flatten package namespaces + "F405", + "E741", # single-letter names (l, I, ...) are idiomatic in this numerical/linear-algebra codebase +] + +[tool.ruff.lint.per-file-ignores] +"__init__.py" = ["F401"] # intentional namespace re-exports +"src/misc/grdecl.py" = ["E722", "E741", "F821"] # vendored parser; F821 is dead Python-2-only code +"src/misc/ecl.py" = ["E722", "E741"] +"src/misc/grid/sector.py" = ["E722", "E741"] +"src/misc/grid/unstruct.py" = ["F841"] # untested legacy grid parser; allocations look WIP, not dead code diff --git a/src/ensemble/__init__.py b/src/ensemble/__init__.py index c8b7821d..68fc4db4 100644 --- a/src/ensemble/__init__.py +++ b/src/ensemble/__init__.py @@ -1 +1,4 @@ -"""Multiple realisations management.""" \ No newline at end of file +"""Foundation shared by ``pipt`` and ``popt``: the base ensemble, checkpoint/restart and logging.""" +from .ensemble import * +from .logger import * +from .protocols import * diff --git a/src/ensemble/checkpoint.py b/src/ensemble/checkpoint.py new file mode 100644 index 00000000..094a77c8 --- /dev/null +++ b/src/ensemble/checkpoint.py @@ -0,0 +1,153 @@ +"""Checkpoint/restart machinery shared by PIPT and POPT. + +Both the optimization schemes in :mod:`popt.optimization_methods` and the +assimilation schemes in :mod:`pipt.update_schemes` are long-running iterative +algorithms that need to survive interruption. The persistence logic is +identical for both, so it lives here rather than being duplicated per package. + +A host class must provide: + +- ``restart`` (bool): whether a checkpoint should be restored on startup. +- ``restart_file`` (str): path to the checkpoint file. +- ``logger``: a :class:`ensemble.logger.PetLogger` or ``None``. +- ``_get_base_restart_state()`` / ``_set_base_restart_state(state)``: serialize + and restore the state owned by the algorithm base class. +- ``_get_restart_state()`` / ``_set_restart_state(state)``: the same, for state + owned by the concrete subclass. Both default to storing nothing, so only a + host that carries its own iteration state needs to implement them. + +Checkpoints record the writing class, so a file written by one algorithm cannot +silently be loaded into another. +""" + +import os +import pickle + +import numpy as np + +__all__ = ["RestartMixin"] + + +class RestartMixin: + """Reusable checkpoint and restart functionality for iterative algorithms.""" + + RESTART_VERSION = 1 + + def _get_restart_state(self) -> dict: + """Serialize state owned by the concrete algorithm. Override as needed. + + Defaulted here so a host with nothing of its own to checkpoint -- every + PIPT scheme, as it happens -- inherits the pair rather than declaring + two empty methods to satisfy the protocol. + """ + return {} + + def _set_restart_state(self, state: dict) -> None: + """Restore state owned by the concrete algorithm. Override as needed.""" + + def save_restart(self): + """Save the current optimizer state to a restart file.""" + payload = self._build_restart_payload() + self._write_restart_payload(payload) + + def load_restart(self): + """Restore optimizer state from a restart file.""" + payload = self._read_restart_payload() + self._restore_from_restart_payload(payload) + self._restart_loaded = True + if self.logger: + self.logger( + f"Loaded restart checkpoint from " + f"'{self.restart_file}'" + ) + + def clear_restart(self): + """Delete the restart file if it exists.""" + if self._restart_exists(): + os.remove(self.restart_file) + + # ------------------------------------------------------------------ + # Restart lifecycle + # ------------------------------------------------------------------ + def _maybe_restore_restart(self) -> bool: + """Restore a checkpoint if restart is enabled.""" + if not self.restart or not self._restart_exists(): + return False + self.load_restart() + return True + + def _restart_exists(self) -> bool: + """Return True if a restart file exists.""" + return os.path.exists(self.restart_file) + + # ------------------------------------------------------------------ + # File I/O + # ------------------------------------------------------------------ + def _write_restart_payload(self, payload) -> None: + """Atomically write a restart payload to disk.""" + restart_dir = os.path.dirname(self.restart_file) + if restart_dir: + os.makedirs(restart_dir, exist_ok=True) + + tmp_path = f"{self.restart_file}.tmp" + with open(tmp_path, "wb") as handle: + pickle.dump( + payload, + handle, + protocol=pickle.HIGHEST_PROTOCOL, + ) + os.replace(tmp_path, self.restart_file) + + def _read_restart_payload(self) -> dict: + """Read a restart payload from disk.""" + with open(self.restart_file, "rb") as handle: + return pickle.load(handle) + + # ------------------------------------------------------------------ + # Payload construction and restoration + # ------------------------------------------------------------------ + def _build_restart_payload(self) -> dict: + """Create a serializable restart payload.""" + return { + "version": self.RESTART_VERSION, + "module": type(self).__module__, + "class_name": type(self).__name__, + "random_state": np.random.get_state(), + "base_state": self._get_base_restart_state(), + "subclass_state": self._get_restart_state(), + } + + def _restore_from_restart_payload(self, payload) -> None: + """Restore optimizer state from a payload.""" + self._validate_restart_payload(payload) + self._set_base_restart_state( + payload["base_state"] + ) + self._set_restart_state( + payload.get("subclass_state", {}) + ) + rng_state = payload.get("random_state") + if rng_state is not None: + np.random.set_state(rng_state) + + def _validate_restart_payload(self, payload) -> None: + """Validate restart payload compatibility.""" + + version = payload.get("version") + module = payload.get("module") + class_name = payload.get("class_name") + + if version != self.RESTART_VERSION: + raise RuntimeError( + f"Restart file '{self.restart_file}' " + f"has unsupported version {version}." + ) + + if ( + module != type(self).__module__ + or class_name != type(self).__name__ + ): + raise RuntimeError( + f"Restart file '{self.restart_file}' " + f"does not match {type(self).__name__}." + ) diff --git a/src/ensemble/ensemble.py b/src/ensemble/ensemble.py index 4c07f567..2ec9c6d9 100644 --- a/src/ensemble/ensemble.py +++ b/src/ensemble/ensemble.py @@ -3,25 +3,34 @@ """ # External imports -import csv # For reading Comma Separated Values files import os # OS level tools import sys # System-specific parameters and functions -from copy import deepcopy, copy # Copy functions. (deepcopy let us copy mutable items) +from copy import deepcopy # Copy functions. (deepcopy let us copy mutable items) from shutil import rmtree # rmtree for removing folders import numpy as np # Misc. numerical tools +import pandas as pd import pickle # To save and load information from glob import glob -import datetime as dt from tqdm.auto import tqdm from p_tqdm import p_map import logging # Internal imports -import pipt.misc_tools.analysis_tools as at -import pipt.misc_tools.extract_tools as extract -import pipt.misc_tools.ensemble_tools as entools -import pipt.misc_tools.data_tools as dtools -from misc.system_tools.environ_var import OpenBlasSingleThread # Single threaded OpenBLAS runs +from misc.structures.structures import PETDataFrame +from misc.structures.layout import StateLayout +from misc.sampling import random_stream +from input_output.config import normalize_ensemble + +# NOTE: pipt.misc_tools is imported lazily inside the methods that need it. +# `ensemble` is the foundation package that both pipt and popt build on, so a +# module-level `import pipt...` here inverts the layering and creates a cycle: +# ensemble/__init__ -> ensemble.ensemble -> pipt.misc_tools +# -> pipt.ensembles -> `from ensemble import BaseEnsemble` (partial!) +# That made `import ensemble` fail as a first import, and made single-file test +# runs such as `pytest tests/optimization/test_ensembles.py` fail on collection +# while the full suite passed by accident of import order. + +__all__ = ["BaseEnsemble"] # Settings ####################################################################################################### @@ -34,7 +43,7 @@ } ####################################################################################################### -class Ensemble: +class BaseEnsemble: """ Class for organizing misc. variables and simulator for an ensemble-based inversion run. Here, the forecast step and prediction runs are performed. General methods that are useful in various ensemble loops have also been @@ -54,13 +63,23 @@ def __init__(self, keys_en: dict, sim, redund_sim=None): init_file : str path to input file containing initiallization values """ - # Internalize PET dictionary + import pipt.misc_tools.extract_tools as extract + + # Internalize PET dictionary -- in canonical form, as a copy, so the + # caller's dictionary is neither read with fallbacks nor written to. + keys_en = normalize_ensemble(keys_en) self.keys_en = keys_en self.sim = sim + # Every draw this run makes comes from here: a private stream when the + # config gives a `seed`, else NumPy's global one, as before. + self.rng = random_stream(keys_en.get('seed')) self.sim.redund_sim = redund_sim # Initialize some attributes self.pred_data = None + self.member_outputs = None # per level, what each member's simulation returned + self.member_adjoints = None # one adjoint frame per member, when the simulator computes them + self._sim_data = None # the frame view of member_outputs, built on first use self.enX_temp = None self.enX = None self.idX = {} @@ -70,300 +89,283 @@ def __init__(self, keys_en: dict, sim, redund_sim=None): self.aux_input = None # Check if folder contains any En_ files, and remove them! - for folder in glob('En_*'): - try: - if len(folder.split('_')) == 2: - int(folder.split('_')[1]) - rmtree(folder) - except: - pass + self._clear_member_run_folders() - # Save name for (potential) pickle dump/load - self.pickle_restart_file = 'emergency_dump' + # Written when every realisation of a forecast fails, so the run can + # be inspected. Resuming a run is the scheme's checkpoint's job + # (`AssimilationScheme` on RestartMixin), not this file's. + self.emergency_dump_file = 'emergency_dump' - # Initiallize the restart. Standard is no restart + # Set by the scheme when it resumes from a checkpoint. A forecast then + # honours a hand-placed `restart_sim_results.pkl`. self.restart = False # Get the active logger self.logger = logging.getLogger(__name__) - # If it is a restart run, we do not need to initialize anything, only load the self info. that exists in the - # pickle save file. If it is not a restart run, we initialize everything below. - if ('restart' in self.keys_en) and (self.keys_en['restart'] == 'yes'): - # Initiate a restart run - self.logger.info('\033[92m--- Restart run initiated! ---\033[92m') - # Check if the pickle save file exists in folder - try: - assert (self.pickle_restart_file in [ - f for f in os.listdir('.') if os.path.isfile(f)]) - except AssertionError as err: - self.logger.info('The restart file "{0}" does not exist in folder. Cannot restart!'.format( - self.pickle_restart_file)) - raise err - - # Load restart file - self.load() - - # Ensure that restart switch is ON since the error may not have happened during a restart run - self.restart = True + # initialize sim limit + if 'sim_limit' in self.keys_en: + self.sim_limit = self.keys_en['sim_limit'] + else: + self.sim_limit = float('inf') - # Init. various variables/lists/dicts. needed in ensemble run + # bool that can be used to supress tqdm output (useful when testing code) + if 'disable_tqdm' in self.keys_en: + self.disable_tqdm = self.keys_en['disable_tqdm'] else: - # delete potential restart files to avoid any problems - if self.pickle_restart_file in [f for f in os.listdir('.') if os.path.isfile(f)]: - os.remove(self.pickle_restart_file) + self.disable_tqdm = False - # initialize sim limit - if 'sim_limit' in self.keys_en: - self.sim_limit = self.keys_en['sim_limit'] - else: - self.sim_limit = float('inf') + # extract information that is given for the prior model + if 'state' in self.keys_en: + self.prior_info = extract.extract_prior_info(self.keys_en) + elif 'controls' in self.keys_en: + self.prior_info = extract.extract_initial_controls(self.keys_en) - # bool that can be used to supress tqdm output (useful when testing code) - if 'disable_tqdm' in self.keys_en: - self.disable_tqdm = self.keys_en['disable_tqdm'] - else: - self.disable_tqdm = False - - # extract information that is given for the prior model - if 'state' in self.keys_en: - self.prior_info = extract.extract_prior_info(self.keys_en) - elif 'controls' in self.keys_en: - self.prior_info = extract.extract_initial_controls(self.keys_en) - - - # Ensemble size - self.ne = self.keys_en.get('ne', None) - - # Calculate initial ensemble if IMPORTSTATICVAR has not been given in init. file. - # Prior info. on state variables must be given by PRIOR_ keyword. - if 'importstaticvar' not in self.keys_en: - if self.ne is None: - self.ne = 100 - else: - self.ne = int(self.ne) - # Generate prior ensemble - self.enX, self.idX, self.cov_prior = entools.generate_prior_ensemble( - prior_info = self.prior_info, - size = self.ne, - save = self.keys_en.get('save_prior', True) - ) + # Ensemble size + self.ne = self.keys_en.get('ne', None) + # Calculate initial ensemble if `importstate` has not been given. + # Prior info. on state variables must be given by PRIOR_ keyword. + if 'importstate' not in self.keys_en: + if self.ne is None: + self.ne = 100 else: - # State variable imported as a Numpy save file - tmp_load = np.load(self.keys_en['importstaticvar'], allow_pickle=True) - - if self.ne is None: - self.ne = tmp_load[key].shape[1] - else: - self.ne = int(self.ne) - - # We assume that the user has saved the state dict. as **state (effectively saved all keys in state - # individually). - for key in self.keys_en['staticvar']: - if self.enX is None: - self.enX = tmp_load[key][:,:self.ne] - else: - self.enX = np.vstack((self.enX, tmp_load[key][:,:self.ne])) - - # fill in indices - self.idX[key] = (self.enX.shape[0] - tmp_load[key].shape[0], self.enX.shape[0]) - - self.list_states = list(self.keys_en['staticvar']) + self.ne = int(self.ne) + + # Generate prior ensemble + self.enX, layout = StateLayout.from_prior_info( + self.prior_info, + self.ne, + rng=self.rng, + save=self.keys_en.get('save_prior', True), + ) + else: + # State variable imported as a Numpy save file + file = np.load(self.keys_en['importstate'], allow_pickle=True) + self.enX, layout = StateLayout.from_dict({key: file[key] for key in file.files}, ne=int(self.ne)) + self.idX = layout.indices + self.list_states = list(layout.variables) if 'multilevel' in self.keys_en: self.multilevel = extract.extract_multilevel_info(self.keys_en['multilevel']) self.ml_ne = self.multilevel['ml_ne'] self.tot_level = len(self.multilevel['levels']) - self.ml_corr_done = False - - - def get_list_assim_steps(self): - """ - Returns list of assimilation steps. Useful in a 'loop'-script. - Returns - ------- - list_assim : list - List of total assimilation steps. - """ - # Get list of assim. steps. from ASSIMINDEX - list_assim = list(range(len(self.keys_da['assimindex']))) - - # If it is a restart run, we only list the assimilation steps we have not done - if self.restart is True: - # List simulations we already have done. Do this by checking pred_data. - # OBS: Minus 1 here do to the aborted simulation is also not None. - sim_done = list( - range(len([ind for ind, p in enumerate(self.pred_data) if p is not None]) - 1)) - # Update list of assim. steps by removing simulations we have done - list_assim = [ind for ind in list_assim if ind not in sim_done] + @staticmethod + def _clear_member_run_folders(): + """Remove the per-realisation `En_` simulator scratch folders. - # Return tot. assim. steps - return list_assim + Only folders named exactly `En_` are touched, so a user's + `En_something` directory in the run folder is left alone. + """ + for folder in glob('En_*'): + try: + if len(folder.split('_')) == 2: + int(folder.split('_')[1]) + rmtree(folder) + except Exception: + pass - def calc_prediction(self, enX=None, save_prediction=None): + def calc_prediction(self, enX, save_prediction=None): """ - Method for making predictions using the state variable. Will output the simulator response for all report steps - and all data values provided to the simulator. + Function for running the simulator over several levels. We assume that it is sufficient to provide the level + integer to the setup of the forward run. This will initiate the correct simulator fidelity. + The function then runs the set of state through the different simulator fidelities. + + Per level: the state becomes one input dict per member + (:meth:`_simulator_input`), the members run on one of three backends + (:meth:`_run_members`), crashed members are replaced, adjoints are + split off, and the outputs are kept as returned (``member_outputs``); + the frame view (``sim_data``) is built from them on demand. Parameters ---------- - input_state : - Use an input state instead of internal state (stored in self) to run predictions - save_prediction : - Save the predictions as a .npz file (numpy compressed file) - - Returns - ------- - prediction : - List of dictionaries with keys equal to data types (in DATATYPE), - containing the responses at each time step given in PREDICTION. - + enX: + If simulation is run stand-alone one can input any state. """ - one_state = False - # Use input state if given - if enX is None: - use_input_ensemble = False - enX = self.enX - self.enX = None # free memory + nparallel = int(self.sim.input_dict.get('parallel', 1)) + self.member_outputs = [] + self.member_adjoints = None + self._sim_data = None + + # Simulators run each realisation in its own `En_` folder and + # create it with `os.mkdir`, which fails rather than reuses if the + # folder is already there. Nothing else removes them between calls, so + # a second prediction collides with the first: an optimizer evaluating + # the mean control (member 0 alone) and then the perturbation ensemble + # (members 0..ne-1) hit `FileExistsError: 'En_0'` on its very first + # iteration. Clearing here rather than only in `__init__` makes each + # prediction independent of what the previous one left behind. + self._clear_member_run_folders() + + if hasattr(self, 'multilevel') and (self.multilevel is not None): + is_multilevel = True + # Iterate over level *indices*: `level` is used below to index both + # `ne` and `enX`. Iterating the ml_ne values instead made `level` + # an ensemble size, so `ne[level]` raised IndexError and multilevel + # forward simulation could never run. + ne = self.multilevel['ml_ne'] + levels = tqdm(range(len(ne)), desc='Fidelity level', position=1, **progbar_settings) + assert isinstance(enX, list) + enX = [np.asarray(x) for x in enX] else: - use_input_ensemble = True + levels = range(1) + ne = [self.ne] + is_multilevel = False + enX = np.asarray(enX) - if isinstance(enX,list) and hasattr(self, 'multilevel'): # assume multilevel is used if state is a list - success = self.calc_ml_prediction(enX) - else: + # Loop over levels, if not multilevel, this loop will only run once. + for level in levels: - # Number of parallel runs - nparallel = int(self.sim.input_dict.get('parallel', 1)) - self.pred_data = [] - - # Run setup function for redund simulator + # Setup forward simulator and redundant simulator at the correct fidelity if self.sim.redund_sim is not None: if hasattr(self.sim.redund_sim, 'setup_fwd_run'): - self.sim.redund_sim.setup_fwd_run() - + self.sim.redund_sim.setup_fwd_run(level=level) + # Run setup function for simulator if hasattr(self.sim, 'setup_fwd_run'): - self.sim.setup_fwd_run(redund_sim=self.sim.redund_sim) - - if enX.ndim == 1: - one_state = True - enX = enX[:, np.newaxis] - elif enX.shape[1] == 1: - one_state = True - - # If we have several models (num_models) but only one state input - if one_state and self.ne > 1: - enX = np.tile(enX, (1, self.ne)) - - # Convert ensemble matrix to list of dictionaries - enX = entools.matrix_to_list(enX, self.idX) - - if not (self.aux_input is None): - for n in range(self.ne): - enX[n]['aux_input'] = self.aux_input[n] - - ###################################################################################################################### - # No parralelization - if nparallel==1: - en_pred = [] - pbar = tqdm(enumerate(enX), total=self.ne, **progbar_settings) - for member_index, state in pbar: - en_pred.append(self.sim.run_fwd_sim(state, member_index)) - - # Parallelization on HPC using SLURM - elif self.sim.input_dict.get('hpc', False): # Run prediction in parallel on hpc - en_pred = self.run_on_HPC(enX, batch_size=nparallel, save_prediction=save_prediction) - - # Parallelization on local machine using p_map - else: - en_pred = p_map( - self.sim.run_fwd_sim, - enX, - list(range(self.ne)), - num_cpus=nparallel, - disable=self.disable_tqdm, - **progbar_settings - ) - ###################################################################################################################### - - # Convert state enemble back to matrix form - enX = entools.list_to_matrix(enX, self.idX) - - # If only one state was inputted, keep only that state - if one_state and self.ne > 1: - enX = enX[:,0][:,np.newaxis] - - # restore state ensemble if it was not inputted - if not use_input_ensemble: - self.enX = enX - enX = None # free memory - - # List successful runs and crashes - success = True - list_success = [indx for indx, el in enumerate(en_pred) if el is not False] - list_crash = [indx for indx, el in enumerate(en_pred) if el is False] - - # Dump all information and print error if all runs have crashed - if not list_success: - self.save() - success = False - if len(list_crash) > 1: - print( - '\n\033[1;31mERROR: All started simulations has failed! We dump all information and exit!\033[1;m') - self.logger.info( - '\n\033[1;31mERROR: All started simulations has failed! We dump all information and exit!\033[1;m') - sys.exit(1) - return success - - # Check crashed runs - if list_crash: - # Replace crashed runs with (random) successful runs. If there are more crashed runs than successful once, - # we draw with replacement. - if len(list_crash) < len(list_success): - copy_member = np.random.choice(list_success, size=len(list_crash), replace=False) - else: - copy_member = np.random.choice(list_success, size=len(list_crash), replace=True) - - # Insert the replaced runs in prediction list - for index, element in enumerate(copy_member): - msg = ( - f"\033[92m--- Ensemble member {list_crash[index]} failed, " - f"has been replaced by ensemble member {element}! ---\033[92m" - ) - print(msg) - self.logger.info(msg) - if enX.shape[1] > 1: - enX[:, list_crash[index]] = deepcopy(enX[:, element]) - en_pred[list_crash[index]] = deepcopy(en_pred[element]) - - if getattr(self.sim, 'compute_adjoints', False): - en_pred, en_adj = zip(*en_pred) - - # Each adjoint in en_adj is a DataFram with mulit-index columns (data type, param) - self.adjoints = [dtools.multilevel_to_singlelevel_columns(a) for a in en_adj] - - # Combine ensemble predictions into pred_data structure - # TODO: In the long run, pred_data should also be made into a DataFrame! - self.pred_data = dtools.en_pred_to_pred_data(en_pred) - - # some predicted data might need to be adjusted (e.g. scaled or compressed if it is 4D seis data). Do not - # include this here. - if enX is not None: - self.enX = enX - enX = None # free memory - - # Store results if needed + self.sim.setup_fwd_run(level=level) + + if ne[level] > 0: + sim_input = self._simulator_input(enX[level] if is_multilevel else enX, ne[level]) + sim_output = self._run_members(sim_input, ne[level], nparallel) + + # Replace crashed sims with successful ones, and give the + # crashed members the state of the member that replaced them, + # so state and prediction stay a matched pair. This mutates + # the state passed in, which is the trial state the caller is + # forecasting and will commit. + sim_output, enX, success = self._replace_failed_simulations(sim_output, enX, level, is_multilevel) + + if (not is_multilevel) and getattr(self.sim, 'compute_adjoints', False): + sim_output, adjoints = zip(*sim_output) + self.member_adjoints = list(adjoints) + + self.member_outputs.append(list(sim_output)) + + # `treat_modeling_error` corrects `pred_data`, which does not exist + # until the caller has filtered `sim_data`. It is invoked from + # `ForecastMixin.forecast` once that is done; calling it here raised + # TypeError on `self.pred_data[-1]` being None. + if save_prediction is not None: - np.savez(f'{save_prediction}.npz', **{'pred_data': self.pred_data}) + # The ensemble's own options name the folder (popt passes `save_prediction`; its + # options are `keys_en`). This read `self.ensemble.keys_da`, an attribute the base + # ensemble never had, so the feature raised AttributeError whenever it was used. + folder = self.keys_en.get('savefolder', 'Predictions') + os.makedirs(folder, exist_ok=True) + if is_multilevel: + for l in range(self.tot_level): + self.sim_data[l].to_pickle(f'{folder}/{save_prediction}_level{l}.pkl') + else: + self.sim_data.to_pickle(f'{folder}/{save_prediction}.pkl') return success - + + # ------------------------------------------------------------------ + # The steps of one level's forecast + # ------------------------------------------------------------------ + def _simulator_input(self, enX, ne): + """One dict per member, as ``run_fwd_sim`` takes it, with any auxiliary input attached.""" + sim_input = self.state_layout.member_dicts(enX) + if self.aux_input is not None: + for n in range(ne): + sim_input[n]['aux_input'] = self.aux_input[n] + return sim_input + + def _run_members(self, sim_input, ne, nparallel): + """Run every member through the simulator: serially, on the HPC queue, or in a local process pool.""" + if nparallel == 1: + sim_output = [] + pbar = tqdm(enumerate(sim_input), total=ne, **progbar_settings) + for member_index, state in pbar: + sim_output.append(self.sim.run_fwd_sim(state, member_index)) + return sim_output + + if self.sim.input_dict.get('hpc', False): # Run prediction in parallel on hpc + return self.run_on_HPC(sim_input, batch_size=nparallel) + + # Parallelization on local machine using p_map + return p_map( + self.sim.run_fwd_sim, + sim_input, + list(range(ne)), + num_cpus=nparallel, + disable=self.disable_tqdm, + **progbar_settings, + ) + + @property + def state_layout(self) -> StateLayout: + """The state's variable layout, read off ``idX`` -- the one place the row ranges live.""" + return StateLayout(self.idX) + + @property + def sim_data(self): + """The full forecast as a frame (one per level), built from the member outputs on first use. + + Nothing on the analysis path reads it; saving, inspection and popt's + objective functions do, so it is built when one of them asks and + cached until the next forecast. + """ + if self._sim_data is None and self.member_outputs: + frames = [self._collect_sim_data(outputs) for outputs in self.member_outputs] + self._sim_data = frames[0] if len(frames) == 1 else frames + return self._sim_data + + @sim_data.setter + def sim_data(self, value): + """Set the frame view directly, as a forecast loaded from a file is.""" + self._sim_data = value + + def _collect_sim_data(self, sim_output): + """One ensemble frame from the members' outputs, each a list of dicts or a DataFrame, scaled like the data.""" + # Check if all predictions are lists of dictionaries + if all(isinstance(el, (list, tuple, np.ndarray)) and + all(isinstance(sub_el, dict) for sub_el in el) + for el in sim_output): + + if hasattr(self.sim, 'true_order'): + dfs = [] + for pred in sim_output: + df = pd.DataFrame.from_records(pred, index=self.sim.true_order[1]) + df.index.name = self.sim.true_order[0] + dfs.append(df) + + else: + dfs = [pd.DataFrame.from_records(pred) for pred in sim_output] + + # Combine dataframes into PETDataFrame + sim_data = PETDataFrame.merge_dataframes(dfs) + + elif all(isinstance(el, pd.DataFrame) for el in sim_output): + # List of dataframes + sim_data = PETDataFrame.merge_dataframes(list(sim_output)) + try: + sim_data = sim_data[self.data_df.columns] + except Exception: + sim_data = sim_data[self.sim.datatype] + + else: + msg = 'Simulator output should be either a dataframe or a list of dictionaries.' + self.logger.error(msg) + raise ValueError(msg) + + if self.keys_en.get('scale_data', False) and hasattr(self, 'data_df'): + sim_data.scale( + type='max-min', + minimum=self.data_df.scale_min, + maximum=self.data_df.scale_max + ) + return sim_data + def run_on_HPC(self, enX, batch_size=None, **kwargs): + """Run the members through the simulator's HPC queue, ``batch_size`` at a time; needs the queue hooks on the wrapper.""" + import pipt.misc_tools.analysis_tools as at + list_member_index = list(range(self.ne)) # Split the ensemble into batches of 500 @@ -390,201 +392,90 @@ def run_on_HPC(self, enX, batch_size=None, **kwargs): ) else: job_id=self.sim.SLURM_HPC_run( - n_e, + n_e, venv=os.path.join(os.path.dirname(sys.executable),'activate'), filename=self.sim.file, **self.sim.options ) - + # Wait for the simulations to finish if job_id: sim_status = self.sim.wait_for_jobs(job_id) else: - print("Job submission failed. Exiting.") + self.logger.info("Job submission failed.") sim_status = [False]*len(n_e) # Extract the results. Need a local counter to check the results in the correct order for c_member, member_i in enumerate([list_member_index[curr_n] for curr_n in n_e]): if sim_status[c_member]: + # One append per member, whatever happens: en_pred is positional, so + # appending twice for one member shifts every member after it. try: self.sim.extract_data(member_i) - en_pred.append(deepcopy(self.sim.pred_data)) - if self.sim.saveinfo is not None: # Try to save information + pred = deepcopy(self.sim.pred_data) + except Exception as exc: + self.logger.error(f"Could not extract data for ensemble member {member_i}: {exc}") + pred = False + en_pred.append(pred) + if pred is not False and self.sim.saveinfo is not None: # Try to save information + try: at.store_ensemble_sim_information(self.sim.saveinfo, member_i) - except Exception as e: - print(f"Error extracting data for ensemble member {member_i}: {e}") - self.logger.error(f"Error extracting data for ensemble member {member_i}: {e}") - en_pred.append(False) + except Exception as exc: + self.logger.error(f"Could not store sim information for member {member_i}: {exc}") else: en_pred.append(False) self.sim.remove_folder(member_i) - + return en_pred def save(self): - """ - We use pickle to dump all the information we have in 'self'. Can be used, e.g., if some error has occurred. - - Changelog - --------- - - ST 28/2-17 - """ - # Open save file and dump all info. in self - with open(self.pickle_restart_file, 'wb') as f: + """Dump everything in ``self`` to ``emergency_dump_file`` for inspection after a failed forecast.""" + with open(self.emergency_dump_file, 'wb') as f: pickle.dump(self.__dict__, f, protocol=4) - def load(self): - """ - Load a pickled file and save all info. in self. - - Changelog - --------- - - ST 28/2-17 - """ - # Open file and read with pickle - with open(self.pickle_restart_file, 'rb') as f: - tmp_load = pickle.load(f) - - # Save in 'self' - self.__dict__.update(tmp_load) - - def calc_ml_prediction(self, enX=None): - """ - Function for running the simulator over several levels. We assume that it is sufficient to provide the level - integer to the setup of the forward run. This will initiate the correct simulator fidelity. - The function then runs the set of state through the different simulator fidelities. - Parameters - ---------- - enX: - If simulation is run stand-alone one can input any state. - """ - - no_tot_run = int(self.sim.input_dict['parallel']) - ml_pred_data = [] - - for level in tqdm(self.multilevel['levels'], desc='Fidelity level', position=1, **progbar_settings): - - # Setup forward simulator and redundant simulator at the correct fidelity - if self.sim.redund_sim is not None: - if hasattr(self.sim.redund_sim, 'setup_fwd_run'): - self.sim.redund_sim.setup_fwd_run(level=level) - - # Run setup function for simulator - if hasattr(self.sim, 'setup_fwd_run'): - self.sim.setup_fwd_run(level=level) - - ml_ne = self.multilevel['ne'][level] - if ml_ne: - - level_enX = entools.matrix_to_list(enX[level], self.idX) - for n in ml_ne: - if self.aux_input is not None: - level_enX[n]['aux_input'] = self.aux_input[n] - - # Index list of ensemble members - list_member_index = list(ml_ne) - - ######################################################################################################## - - # Number of parallel runs - if self.sim.input_dict.get('hpc', False): # Run prediction in parallel on hpc - en_pred = self.run_on_HPC(level_enX, batch_size=nparallel) + def _replace_failed_simulations(self, sim_output, enX, level=None, is_multilevel=False): + + # List successful runs and crashes + list_crash = [indx for indx, el in enumerate(sim_output) if el is False] + list_success = [indx for indx, el in enumerate(sim_output) if el is not False] + success = True + + # Dump all information and print error if all runs have crashed + if not list_success: + self.save() + success = False + if len(list_crash) > 1: + msg = 'All started simulations failed; the ensemble has been dumped for inspection.' + self.logger.info(msg) + raise RuntimeError(msg) + return sim_output, enX, success + + # Check crashed runs + if list_crash: + # Replace crashed runs with (random) successful runs. If there are more crashed runs than successful once, + # we draw with replacement. + if len(list_crash) < len(list_success): + copy_member = self.rng.choice( + list_success, size=len(list_crash), replace=False) + else: + copy_member = self.rng.choice( + list_success, size=len(list_crash), replace=True) + + # Insert the replaced runs in prediction list + for index, element in enumerate(copy_member): + msg = ( + f"\033[92m--- Ensemble member {list_crash[index]} failed, " + f"has been replaced by ensemble member {element}! ---\033[92m" + ) + self.logger.info(msg) - # Parallelization on local machine using p_map + if is_multilevel and level is not None and enX[level].shape[1] > 1: + enX[level][:, list_crash[index]] = deepcopy(enX[level][:, element]) else: - en_pred = p_map( - self.sim.run_fwd_sim, - level_enX, - list_member_index, - num_cpus=no_tot_run, - disable=self.disable_tqdm, - **progbar_settings, - ) - ######################################################################################################## - - # List successful runs and crashes - list_crash = [indx for indx, el in enumerate(en_pred) if el is False] - list_success = [indx for indx, el in enumerate(en_pred) if el is not False] - success = True - - # Dump all information and print error if all runs have crashed - if not list_success: - self.save() - success = False - if len(list_crash) > 1: - print( - '\n\033[1;31mERROR: All started simulations has failed! We dump all information and exit!\033[1;m') - self.logger.info( - '\n\033[1;31mERROR: All started simulations has failed! We dump all information and exit!\033[1;m') - sys.exit(1) - return success - - # Check crashed runs - if list_crash: - # Replace crashed runs with (random) successful runs. If there are more crashed runs than successful once, - # we draw with replacement. - if len(list_crash) < len(list_success): - copy_member = np.random.choice( - list_success, size=len(list_crash), replace=False) - else: - copy_member = np.random.choice( - list_success, size=len(list_crash), replace=True) - - # Insert the replaced runs in prediction list - for index, element in enumerate(copy_member): - msg = ( - f"\033[92m--- Ensemble member {list_crash[index]} failed, " - f"has been replaced by ensemble member {element}! ---\033[92m" - ) - print(msg) - self.logger.info(msg) - if enX[level].shape[1] > 1: - enX[level][:, list_crash[index]] = deepcopy(enX[level][:, element]) - - en_pred[list_crash[index]] = deepcopy(en_pred[element]) - - #Convert ensemble specific result into pred_data, and filter for NONE data - ml_pred_data.append(dtools.en_pred_to_pred_data(en_pred)) - - # loop over time instance first, and the level instance. - self.pred_data = np.array(ml_pred_data).T.tolist() - - if hasattr(self,'treat_modeling_error'): - self.treat_modeling_error() + if enX.shape[1] > 1: + enX[:, list_crash[index]] = deepcopy(enX[:, element]) - return success + sim_output[list_crash[index]] = deepcopy(sim_output[element]) + + return sim_output, enX, success - def treat_modeling_error(self): - if self.multilevel['ml_error_corr']: - scheme = self.multilevel['ml_error_corr'][1] - - if scheme =='sep': - self.calc_modeling_error_sep() - self.address_ML_error() - elif scheme =='once': - if not self.ml_corr_done: - self.calc_modeling_error_ens() - self.ml_corr_done = True - self.address_ML_error() - elif scheme =='ens': - self.calc_modeling_error_ens() - - def calc_modeling_error_sep(self): - print('calc_modeling_error_sep -- Not yet implemented') - - def calc_modeling_error_ens(self): - - if self.multilevel['ml_error_corr'][0] =='bias_corr': - # modify self.pred_data without changing its structure. Hence, for each level (except the finest one) - # we correct each data at each point in time. - for assim_index in range(len(self.pred_data)): - for dat in self.pred_data[assim_index][-1].keys(): - # extract the HF model mean - ref_mean = self.pred_data[assim_index][-1][dat].mean(axis=1) - # modify each level - for level in range(self.tot_level - 1): - self.pred_data[assim_index][level][dat] += (ref_mean - self.pred_data[assim_index][level][dat].mean(axis=1)) - - - def address_ML_error(self): - print('address_ML_error -- Not yet implemented') diff --git a/src/ensemble/logger.py b/src/ensemble/logger.py index 788f255d..dd936156 100644 --- a/src/ensemble/logger.py +++ b/src/ensemble/logger.py @@ -1,5 +1,22 @@ +"""Run logging: a table-formatting file logger and a no-op stand-in for when logging is off.""" import logging +__all__ = ["PetLogger", "NullLogger"] + + +class NullLogger: + """Callable no-op standing in for a :class:`PetLogger` when logging is + disabled -- so callers can invoke ``self.logger(...)`` unconditionally + without checking whether logging is on, and no log file is created. + """ + + def __call__(self, *args, **kwargs): + pass + + def info(self, *args, **kwargs): + """No-op.""" + pass + class PetLogger: ''' A custom logger that logs messages and key-value pairs in a formatted table. @@ -12,17 +29,23 @@ def __init__(self, filename=None): self.filename = filename if filename else 'PET.log' self.ns = 12 # Number of spaces for table formatting - # Configurate logging - logging.basicConfig( - level=logging.INFO, - format='%(asctime)s : %(message)s', - datefmt='%Y-%m-%d│%H:%M:%S', - handlers=[ - logging.FileHandler(self.filename, mode='w', encoding='utf-8'), - logging.StreamHandler() - ] - ) - self._logger = logging.getLogger(__name__) + # One named logger per log file, carrying its own file and console + # handlers. This used to call logging.basicConfig, which configures + # the *root* logger once per process and silently does nothing the + # second time -- so a second PetLogger (popt beside pipt, or a re-run + # in a notebook) kept writing into the first file, and any test or + # application that had touched the root logger got no file at all. + # Records still propagate upward, so a root handler (pytest's capture, + # an application's own configuration) sees them too. + self._logger = logging.getLogger(f"pet.{self.filename}") + self._logger.setLevel(logging.INFO) + for handler in list(self._logger.handlers): + self._logger.removeHandler(handler) + handler.close() + formatter = logging.Formatter('%(asctime)s : %(message)s', datefmt='%Y-%m-%d│%H:%M:%S') + for handler in (logging.FileHandler(self.filename, mode='w', encoding='utf-8'), logging.StreamHandler()): + handler.setFormatter(formatter) + self._logger.addHandler(handler) def __call__(self, *args, **kwargs): @@ -37,7 +60,7 @@ def __call__(self, *args, **kwargs): >>> logger = PetLogger() >>> logger('This is a log message.') 2024-06-01│12:00:00 : This is a log message. - >>> + >>> >>> logger(iteration=1, fun=0.5, step_size=0.1) 2024-06-01│12:00:00 : 2024-06-01│12:00:00 : ┌────────────┬────────────┬────────────┐ @@ -53,7 +76,7 @@ def __call__(self, *args, **kwargs): msg = ' ' + ' '.join(str(arg) for arg in args) self._logger.info(msg) - if kwargs: + if kwargs: # Make strings for table logging self._set_ns(**kwargs) header = [] @@ -64,12 +87,12 @@ def __call__(self, *args, **kwargs): if isinstance(value, int) or isinstance(value, str): values.append(f'{value:^{self.ns}}') elif '%' in key: - values.append(f'{value:^{self.ns}.1f}') + values.append(f'{value:^{self.ns}.2f}') else: values.append(f'{value:^{self.ns}.3e}') - except: + except Exception: values.append(f'{"":^{self.ns}}') - + # Log table seperator = ['─' * self.ns for _ in kwargs.keys()] self._logger.info('') @@ -81,6 +104,7 @@ def __call__(self, *args, **kwargs): self._logger.info('') def info(self, *args, **kwargs): + """Log as given; ``__call__`` is the table-aware form.""" self._logger.info(*args, **kwargs) def _set_ns(self, **kwargs): @@ -90,10 +114,17 @@ def _set_ns(self, **kwargs): Parameters: **kwargs: Keyword arguments to consider for adjusting the space width. ''' + self.ns = 12 for key, value in kwargs.items(): + value_len = 0 try: - if (len(key) > self.ns) or (len(f'{value:.3e}') > self.ns): - self.ns = max(len(key), len(f'{value:.3e}')) + 2 - except: - if len(key) > self.ns: - self.ns = len(key) + 2 \ No newline at end of file + if isinstance(value, int) or isinstance(value, str): + value_len = len(str(value)) + elif '%' in key: + value_len = len(f'{value:.2f}') + else: + value_len = len(f'{value:.3e}') + except Exception: + value_len = 0 + + self.ns = max(self.ns, len(key) + 2, value_len + 2) diff --git a/src/ensemble/protocols.py b/src/ensemble/protocols.py new file mode 100644 index 00000000..2ced3778 --- /dev/null +++ b/src/ensemble/protocols.py @@ -0,0 +1,49 @@ +"""The contract a forward simulator must satisfy to be driven by the base ensemble.""" + +from typing import Protocol, runtime_checkable + +__all__ = ["ForwardSimulator"] + + +@runtime_checkable +class ForwardSimulator(Protocol): + """What :meth:`ensemble.ensemble.BaseEnsemble.calc_prediction` requires of a simulator. + + Two members are required, and they are all that ``isinstance(sim, + ForwardSimulator)`` checks: + + ``input_dict`` + The parsed simulator section of the config. The ensemble reads + ``parallel`` (local workers, default 1) and ``hpc`` from it. + ``run_fwd_sim(state, member_index)`` + Run one realisation. ``state`` maps each state variable to that + member's values; ``member_index`` is the member's position in the + ensemble. Return one of + + - a list with one dict per report point, keyed by data type, + - a ``pandas.DataFrame`` with report points as index and data types + as columns, + - ``False`` when the run failed, so the member can be replaced, or + - ``(output, adjoint)`` when ``compute_adjoints`` is true. + + Members the ensemble looks for with ``hasattr``/``getattr`` and uses only + when present: + + ``setup_fwd_run(level=...)`` + Called once before each prediction, with the fidelity level. + ``true_order`` + ``[index_name, index_values]`` used to index the returned records. + ``datatype`` + Fallback column filter when the observed data has no columns yet. + ``compute_adjoints`` + Whether ``run_fwd_sim`` returns ``(output, adjoint)``. Default False. + + The ensemble also *assigns* ``redund_sim`` (a backup simulator, or + ``None``) onto the simulator when it is constructed. The analytical models + in :mod:`simulator` are the smallest complete examples. + """ + + input_dict: dict + + def run_fwd_sim(self, state, member_index, *args, **kwargs): + """Run one member; the class docstring lists the accepted return values.""" diff --git a/src/input_output/config.py b/src/input_output/config.py new file mode 100644 index 00000000..c09f9b92 --- /dev/null +++ b/src/input_output/config.py @@ -0,0 +1,220 @@ +"""The configuration boundary: one normalisation and one validation, however a config arrives. + +A run is described by three sections -- the problem (``dataassim`` for pipt, +``optim`` for popt), the ``ensemble`` and the ``simulator`` (``fwdsim``) -- +read from TOML, YAML or the legacy ``.pipt``/``.popt`` text format, or built +as dictionaries in a script. Whichever way they arrive, :func:`normalize` +turns them into the one form the rest of PET reads: the canonical name where +a key has had several spellings, a boolean where a flag could be ``yes``/``no``, +a dictionary where a sub-block could be a list of pairs, and the field +conversions (``datatype``, ``reportpoint``, ``assimindex``) done once. The +result is a copy; nothing downstream sees, or changes, the caller's +dictionaries. :func:`validate` says what a run would fail on, by section and +key, instead of an assertion or a ``KeyError`` somewhere inside a scheme. +""" + +from copy import deepcopy +from dataclasses import dataclass + +from input_output.organize import ConfigNormalizer + +__all__ = ["ConfigError", "Problem", "as_flag", "pairs_to_dict", "normalize", "normalize_dataassim", + "normalize_ensemble", "normalize_simulator", "normalize_optim", "validate", "fatal_problems", + "KNOWN_DATAASSIM", "KNOWN_ENSEMBLE"] + + +class ConfigError(ValueError): + """A config that cannot run, with every problem listed.""" + + +# --------------------------------------------------------------------------- +# Value helpers (the legacy text format wrote flags as yes/no and blocks as rows) +# --------------------------------------------------------------------------- +def as_flag(value, default=False) -> bool: + """A boolean from a flag value: booleans as they are, ``yes``/``no``/``true``/``false`` strings, else truthiness.""" + if value is None: + return default + if isinstance(value, bool): + return value + if isinstance(value, str): + lowered = value.strip().lower() + if lowered in ("yes", "true"): + return True + if lowered in ("no", "false"): + return False + return bool(value) + + +def pairs_to_dict(entries) -> dict: + """``[[key, value], [key], [key, v1, v2]]`` -> ``{key: value, key: None, key: [v1, v2]}``.""" + assert isinstance(entries, list) + result = {} + for entry in entries: + if not isinstance(entry, list): + entry = [entry] + if len(entry) == 1: + result[str(entry[0])] = None + elif len(entry) == 2: + result[str(entry[0])] = entry[1] + else: + result[str(entry[0])] = entry[1:] + return result + + +# --------------------------------------------------------------------------- +# What each section canonicalises +# --------------------------------------------------------------------------- +ALIASES_DATAASSIM = {"truedata": "data", "var": "datavar", "save_folder": "savefolder", "restartfile": "restart_file"} +FLAGS_DATAASSIM = ("emp_cov", "restart", "restartsave", "obsvarsave", "screendata", "post_process_forecast", + "scale_data", "logit") +BLOCKS_DATAASSIM = ("iteration", "mda", "compress", "localization", "localanalysis") + +ALIASES_ENSEMBLE = {"importstaticvar": "importstate", "save_folder": "savefolder"} +FLAGS_ENSEMBLE = ("save_prior", "disable_tqdm", "natural_gradient") +BLOCKS_ENSEMBLE = ("multilevel",) + +ALIASES_SIMULATOR: dict = {} +FLAGS_SIMULATOR = ("compute_adjoints", "replace", "hpc") +BLOCKS_SIMULATOR: tuple = () + +ALIASES_OPTIM = {"save_folder": "savefolder", "restartfile": "restart_file"} +FLAGS_OPTIM = ("restart", "restartsave", "saveit", "logit", "transform") +BLOCKS_OPTIM: tuple = () + +#: Keys the code reads from the two sections PET owns. `pet validate` points out anything else, +#: since a misspelt key is silently ignored otherwise. Simulator keys are the wrapper's business. +KNOWN_DATAASSIM = frozenset({ + "scheme", "analysis", "data", "datavar", "obsname", "datatype", "truedataindex", "assimindex", "energy", + "emp_cov", "iteration", "mda", "compress", "localization", "localanalysis", "actnum", "scale_data", "scale", + "screendata", "post_process_forecast", "remove_outliers", + "savefolder", "nosave", "savedata", "analysisdebug", "iterinfo", "obsvarsave", "qa", "qc", + "restart", "restartsave", "restart_file", "logit", "logger_name", + # legacy text files keep the ensemble's keys in DATAASSIM + "ne", "state", "staticvar", "importstate", "seed", "save_prior", "sim_limit", "disable_tqdm", +}) +KNOWN_ENSEMBLE = frozenset({ + "ne", "state", "controls", "importstate", "seed", "save_prior", "sim_limit", "disable_tqdm", "multilevel", + "savefolder", "natural_gradient", "num_models", "save_prediction", +}) + + +def _canonical(keys, aliases, flags, blocks, block_prefixes=()): + keys = deepcopy(keys) if keys else {} + for old, new in aliases.items(): + if old in keys: + keys.setdefault(new, keys[old]) # the canonical spelling wins when both are given + del keys[old] + for key in flags: + if key in keys: + keys[key] = as_flag(keys[key]) + for key in list(keys): + if (key in blocks or key.startswith(block_prefixes)) and isinstance(keys[key], list): + keys[key] = pairs_to_dict(keys[key]) + return keys + + +def normalize_dataassim(keys) -> dict: + """The ``dataassim`` section in canonical form, as a copy.""" + return _canonical(keys, ALIASES_DATAASSIM, FLAGS_DATAASSIM, BLOCKS_DATAASSIM, block_prefixes=("prior_",)) + + +def normalize_ensemble(keys) -> dict: + """The ``ensemble`` section in canonical form, as a copy.""" + return _canonical(keys, ALIASES_ENSEMBLE, FLAGS_ENSEMBLE, BLOCKS_ENSEMBLE, block_prefixes=("prior_",)) + + +def normalize_simulator(keys) -> dict: + """The ``simulator`` section in canonical form, as a copy.""" + return _canonical(keys, ALIASES_SIMULATOR, FLAGS_SIMULATOR, BLOCKS_SIMULATOR) + + +def normalize_optim(keys) -> dict: + """The ``optim`` section in canonical form, as a copy.""" + return _canonical(keys, ALIASES_OPTIM, FLAGS_OPTIM, BLOCKS_OPTIM) + + +def is_dataassim(problem_section) -> bool: + """Whether the problem section describes a data-assimilation run (else an optimisation).""" + return bool(problem_section) and ("scheme" in problem_section or "daalg" in problem_section) + + +def normalize(cfg_prb, cfg_sim, cfg_ens=None): + """All three sections as the rest of PET reads them: field conversions, canonical names, flags, blocks. + + Returns ``(problem, simulator, ensemble)``; the ensemble is ``{}`` when the + config has none (the legacy text format keeps those keys in DATAASSIM). + """ + cfg_prb, cfg_sim, cfg_ens = ConfigNormalizer.normalize_config(cfg_prb, cfg_sim, cfg_ens) + problem = normalize_dataassim(cfg_prb) if is_dataassim(cfg_prb) else normalize_optim(cfg_prb) + return problem, normalize_simulator(cfg_sim), normalize_ensemble(cfg_ens or {}) + + +# --------------------------------------------------------------------------- +# Validation +# --------------------------------------------------------------------------- +@dataclass(frozen=True) +class Problem: + """One thing wrong with a config. ``fatal`` problems stop a run at construction.""" + + section: str + key: str + message: str + fatal: bool = True + + def __str__(self) -> str: + return f"[{self.section}] {self.key}: {self.message}" + + +def _as_list(value): + return value if isinstance(value, (list, tuple)) else [value] + + +def validate(cfg_prb, cfg_sim=None, cfg_ens=None) -> list: + """Everything a run would fail on, by section and key; empty when the config is fine. + + Expects normalised sections (see :func:`normalize`). The ensemble's + requirements are checked when an ensemble section is given or the problem + section carries its keys, as legacy text files do. + """ + prb, sim, ens = (cfg_prb or {}), (cfg_sim or {}), (cfg_ens or {}) + problems = [] + if "daalg" in prb: + problems.append(Problem("dataassim", "daalg", "replaced by `scheme`; run `pet migrate` on the file")) + if is_dataassim(prb): + for key, what in (("data", "the observed data"), ("datavar", "the observation variance")): + if key not in prb: + problems.append(Problem("dataassim", key, f"required: {what}")) + data = prb.get("data") + if "obsname" not in prb and not (isinstance(data, dict) and "index_name" in data): + problems.append(Problem("dataassim", "obsname", "required: the name of the observation index (times, dates)")) + if sim and "datatype" not in sim and "datatype" not in prb: + problems.append(Problem("simulator", "datatype", "required: the data types the simulator reports", fatal=False)) + + merged = {**prb, **ens} + if ens or any(key in prb for key in ("ne", "state", "staticvar")): + if "ne" not in merged: + problems.append(Problem("ensemble", "ne", "required: the ensemble size", fatal=False)) + state = merged.get("state", merged.get("staticvar")) + if state is None and "controls" not in merged: + problems.append(Problem("ensemble", "state", "required: the state variables (or `controls` for optimisation)")) + elif state is not None and "importstate" not in merged: + for name in _as_list(state): + if f"prior_{name}" not in merged: + problems.append(Problem("ensemble", f"prior_{name}", + f"required: the prior description of `{name}` (or `importstate` to load one)")) + return problems + + +def fatal_problems(cfg_prb, cfg_sim=None, cfg_ens=None) -> list: + """The problems that stop a run at construction.""" + return [problem for problem in validate(cfg_prb, cfg_sim, cfg_ens) if problem.fatal] + + +def unknown_keys(cfg_prb, cfg_ens=None) -> list: + """Keys in the two sections PET owns that nothing reads -- usually a misspelling.""" + prb, ens = (cfg_prb or {}), (cfg_ens or {}) + found = [] + if is_dataassim(prb): + found += [f"[dataassim] {key}" for key in prb if key not in KNOWN_DATAASSIM and not key.startswith("prior_")] + found += [f"[ensemble] {key}" for key in ens if key not in KNOWN_ENSEMBLE and not key.startswith("prior_")] + return found diff --git a/src/input_output/get_ecl_key_val.py b/src/input_output/get_ecl_key_val.py index ad3727bd..6ccf518c 100644 --- a/src/input_output/get_ecl_key_val.py +++ b/src/input_output/get_ecl_key_val.py @@ -5,6 +5,7 @@ def read_file(val_type, filename): + """Values of keyword ``val_type`` in an Eclipse-style include file, read until the terminating ``/``.""" file = open(filename, 'r') lines = file.readlines() @@ -48,6 +49,7 @@ def read_file(val_type, filename): return values def write_file(filename, val_type, data): + """Write ``data`` as keyword ``val_type`` in an Eclipse-style include file.""" file = open(filename, 'w') file.writelines(val_type + '\n') diff --git a/src/input_output/organize.py b/src/input_output/organize.py index 8e500e38..663f1d69 100644 --- a/src/input_output/organize.py +++ b/src/input_output/organize.py @@ -1,139 +1,181 @@ """Descriptive description.""" from copy import deepcopy +from pathlib import Path import csv -import datetime as dt +import os import pandas as pd +import yaml -class Organize_input(): - def __init__(self, keys_pr, keys_fwd, keys_en=None): - self.keys_pr = keys_pr - self.keys_fwd = keys_fwd - self.keys_en = keys_en - - def organize(self): - # Organize the data types given by DATATYPE keyword - self._org_datatype() - # Organize the observed data given by TRUEDATA keyword and initialize predicted data variable - self._org_report() - - def get_keys_pr(self): - return deepcopy(self.keys_pr) - - def get_keys_fwd(self): - return deepcopy(self.keys_fwd) - - def get_keys_en(self): - return deepcopy(self.keys_en) - - def _org_datatype(self): - """ Check if datatype is given as a csv file. If so, we read and make a list.""" - if isinstance(self.keys_fwd['datatype'], str) and self.keys_fwd['datatype'].endswith('.csv'): - with open(self.keys_fwd['datatype']) as csvfile: - reader = csv.reader(csvfile) # get a reader object - datatype = [] # Initialize the list of csv data - for rows in reader: # Rows is a list of values in the csv file - csv_data = [None] * len(rows) - for col in range(len(rows)): - csv_data[col] = str(rows[col]) - datatype.extend(csv_data) - self.keys_fwd['datatype'] = datatype - - if not isinstance(self.keys_fwd['datatype'], list): - self.keys_fwd['datatype'] = [self.keys_fwd['datatype']] - # make copy for problem keywords - self.keys_pr['datatype'] = self.keys_fwd['datatype'] - - def _org_report(self): + +class ConfigNormalizer: + """ + Utility class for normalizing and type-converting configuration dictionaries for PIPT/POPT workflows. + + This class provides static methods to process and normalize configuration sections such as 'datatype', + 'truedataindex', 'reportpoint', and 'assimindex'. + """ + + @staticmethod + def normalize_datatype(datatype): """ - Organize the input true observed data. The obs_data will be a list of length equal length of "TRUEDATAINDEX", - and each entery in the list will be a dictionary with keys equal to the "DATATYPE". - Also, the pred_data variable (predicted data or forward simulation) will be initialized here with the same - structure as the obs_data variable. - - !!! warning - An "N/A" entry in "TRUEDATA" is treated as a None-entry; that is, there is NOT an observed data at this - assimilation step.' - - !!! warning - The array associated with the first string inputted in "TRUEDATAINDEX" is assumed to be the "main" - index, that is, the length of this array will determine the length of the obs_data list! There arrays - associated with the subsequent strings in "TRUEDATAINDEX" are then assumed to be a subset of the first - string. - An example: the first string is SOURCE (e.g., sources in CSEM), where the array will be a list of numbering - for the sources; and the second string is FREQ, where the array associated will be a list of frequencies. - - !!! info - It is assumed that the number of data associated with a subset is the same for each index in the subset. - For example: If two frequencies are inputted in FREQ, then the number of data for one SOURCE index and one - frequency is 1/2 of the total no. of data for that SOURCE index. If three frequencies are inputted, the number - of data for one SOURCE index and one frequencies is 1/3 of the total no of data for that SOURCE index, - and so on. + Normalize the 'datatype' field: read from CSV if needed, ensure list of strings. """ - - # Extract primary indices from "TRUEDATAINDEX" - if 'truedataindex' in self.keys_pr: - - if isinstance(self.keys_pr['truedataindex'], list): # List of prim. ind - true_prim = self.keys_pr['truedataindex'] - else: # Float - true_prim = [self.keys_pr['truedataindex']] - - # Check if a csv file has been included as "TRUEDATAINDEX". If so, we read it and make a list, - if isinstance(self.keys_pr['truedataindex'], str) and self.keys_pr['truedataindex'].endswith('.csv'): - with open(self.keys_pr['truedataindex']) as csvfile: - reader = csv.reader(csvfile) # get a reader object - true_prim = [] # Initialize the list of csv data - for rows in reader: # Rows is a list of values in the csv file - csv_data = [None] * len(rows) - for ind, col in enumerate(rows): - csv_data[ind] = int(col) - true_prim.extend(csv_data) - self.keys_pr['truedataindex'] = true_prim - - # Check if a csv file has been included as "REPORTPOINT". If so, we read it and make a list, - if 'reportpoint' in self.keys_fwd: - if isinstance(self.keys_fwd['reportpoint'], str) and self.keys_fwd['reportpoint'].endswith('.csv'): - with open(self.keys_fwd['reportpoint']) as csvfile: - reader = csv.reader(csvfile) # get a reader object - pred_prim = [] # Initialize the list of csv data - for rows in reader: # Rows is a list of values in the csv file - csv_data = [None] * len(rows) - for ind, col in enumerate(rows): - try: - csv_data[ind] = int(col) - except ValueError: - csv_data[ind] = dt.datetime.strptime( - col, '%Y-%m-%d %H:%M:%S') - - pred_prim.extend(csv_data) - self.keys_fwd['reportpoint'] = pred_prim - - elif isinstance(self.keys_fwd['reportpoint'], dict): - self.keys_fwd['reportpoint'] = pd.date_range(**self.keys_fwd['reportpoint']).to_pydatetime().tolist() - - else: - pass - - - # Check if assimindex is given as a csv file. If so, we read and make a potential 2D list (if sequential). - if 'assimindex' in self.keys_pr: - if isinstance(self.keys_pr['assimindex'], str) and self.keys_pr['assimindex'].endswith('.csv'): - with open(self.keys_pr['assimindex']) as csvfile: - reader = csv.reader(csvfile) # get a reader object - assimindx = [] # Initialize the 2D list of csv data - for rows in reader: # Rows is a list of values in the csv file - csv_data = [None] * len(rows) - for col in range(len(rows)): - csv_data[col] = int(rows[col]) - assimindx.append(csv_data) - self.keys_pr['assimindex'] = assimindx - - # check that they are lists - if not isinstance(self.keys_pr['truedataindex'], list): - self.keys_pr['truedataindex'] = [self.keys_pr['truedataindex']] - if not isinstance(self.keys_fwd['reportpoint'], list): - self.keys_fwd['reportpoint'] = [self.keys_fwd['reportpoint']] - if not isinstance(self.keys_pr['assimindex'], list): - self.keys_pr['assimindex'] = [self.keys_pr['assimindex']] + if isinstance(datatype, str) and datatype.endswith('.csv'): + with open(datatype) as csvfile: + reader = csv.reader(csvfile) + return [str(col) for row in reader for col in row] + if not isinstance(datatype, list): + return [datatype] + return [str(x) for x in datatype] + + @staticmethod + def normalize_truedataindex(truedataindex): + """ + Normalize the 'truedataindex' field: read from CSV if needed, ensure list of ints. + """ + if isinstance(truedataindex, str) and truedataindex.endswith('.csv'): + with open(truedataindex) as csvfile: + reader = csv.reader(csvfile) + return [int(col) for row in reader for col in row] + if not isinstance(truedataindex, list): + return [truedataindex] + return [int(x) for x in truedataindex] + + @staticmethod + def normalize_reportpoint(reportpoint): + """ + Normalize the 'reportpoint' field: handle CSV, dict (date_range), or pass through. + """ + if isinstance(reportpoint, str): + return report_point_file_reader(reportpoint) + elif isinstance(reportpoint, dict): + return pd.date_range(**reportpoint).to_pydatetime().tolist() + elif not isinstance(reportpoint, list): + return [reportpoint] + return reportpoint + + @staticmethod + def normalize_assimindex(assimindex): + """ + Normalize the 'assimindex' field: read from CSV if needed, ensure list of lists of ints. + """ + if isinstance(assimindex, str) and assimindex.endswith('.csv'): + with open(assimindex) as csvfile: + reader = csv.reader(csvfile) + return [[int(col) for col in row] for row in reader] + if not isinstance(assimindex, list): + return [assimindex] + # If it's a flat list, wrap in another list + if assimindex and not isinstance(assimindex[0], list): + return [assimindex] + return assimindex + + @staticmethod + def normalize_config(keys_pr, keys_fwd, keys_en=None): + """ + Normalize all relevant fields in the config dictionaries and return new dicts. + """ + keys_pr = deepcopy(keys_pr) if keys_pr else {} + keys_fwd = deepcopy(keys_fwd) if keys_fwd else {} + keys_en = deepcopy(keys_en) if keys_en else {} if keys_en is not None else None + + # Normalize datatype + if 'datatype' in keys_fwd: + keys_fwd['datatype'] = ConfigNormalizer.normalize_datatype(keys_fwd['datatype']) + keys_pr['datatype'] = keys_fwd['datatype'] + + # Normalize truedataindex + if 'truedataindex' in keys_pr: + keys_pr['truedataindex'] = ConfigNormalizer.normalize_truedataindex(keys_pr['truedataindex']) + + # Normalize reportpoint + if 'reportpoint' in keys_fwd: + keys_fwd['reportpoint'] = ConfigNormalizer.normalize_reportpoint(keys_fwd['reportpoint']) + + # Normalize assimindex + if 'assimindex' in keys_pr: + keys_pr['assimindex'] = ConfigNormalizer.normalize_assimindex(keys_pr['assimindex']) + + return keys_pr, keys_fwd, keys_en + + +def report_point_file_reader(filepath): + """ + Read a file containing report points and return parsed values. + + Supported file types: + - .csv : Each cell is parsed as int or datetime + - .txt : Each line is parsed as int or datetime + - .yaml: Each entry is parsed as int or datetime + + Parameters + ---------- + filepath : str + Path to the input file. + + Returns + ------- + list + List of parsed values (int or datetime-like objects). + + Raises + ------ + FileNotFoundError + If the file does not exist. + ValueError + If the file type is unsupported or parsing fails. + """ + + def _parse_value(value, source): + """Parse a single value into int or datetime.""" + if pd.isna(value) or (isinstance(value, str) and not value.strip()): + return None + + try: + return int(value) + except (ValueError, TypeError): + try: + return pd.to_datetime(value) + except Exception: + raise ValueError( + f"Unable to parse '{value}' in file '{source}' " + "as integer or datetime." + ) + + if not os.path.isfile(filepath): + raise FileNotFoundError(f"File '{filepath}' does not exist.") + + extension = Path(filepath).suffix.lower() + report_points = [] + + if extension == ".csv": + df = pd.read_csv(filepath, header=None) + values = df.values.ravel() + + for value in values: + parsed = _parse_value(value, filepath) + if parsed is not None: + report_points.append(parsed) + + elif extension == ".txt": + with open(filepath, encoding="utf-8") as file: + for line in file: + parsed = _parse_value(line.strip(), filepath) + if parsed is not None: + report_points.append(parsed) + + elif extension == ".yaml": + with open(filepath, encoding="utf-8") as file: + data = yaml.safe_load(file) or [] + + for value in data: + parsed = _parse_value(value, filepath) + if parsed is not None: + report_points.append(parsed) + + else: + raise ValueError(f"Unsupported file type: '{extension}'") + + return report_points diff --git a/src/input_output/read_config.py b/src/input_output/read_config.py index f39ffa57..5b616ff5 100644 --- a/src/input_output/read_config.py +++ b/src/input_output/read_config.py @@ -1,147 +1,151 @@ """Parse config files.""" -from misc import read_input_csv as ricsv -from copy import deepcopy -from input_output.organize import Organize_input +from input_output.config import is_dataassim, normalize as normalize_config +from pathlib import Path import tomli import tomli_w import yaml from yaml.loader import FullLoader import numpy as np +import os def read(filename: str): ''' Read configuration file. Supported formats are toml, .yaml, .pipt and .popt.''' - if filename.endswith('.pipt') or filename.endswith('.popt'): - return read_txt(filename) - elif filename.endswith('.yaml'): - return read_yaml(filename) - elif filename.endswith('.toml'): + if Path(filename).suffix.lower() == ".toml": return read_toml(filename) + elif Path(filename).suffix.lower() in [".yaml", ".yml"]: + return read_yaml(filename) + elif Path(filename).suffix.lower() in [".pipt", ".popt"]: + return read_txt(filename) else: raise ValueError('File format not supported. Supported formats are toml, .yaml, .pipt, .popt') -def convert_txt_to_yaml(init_file): - # Read .pipt or .popt file - pr, fwd = read_txt(init_file) - - # Write dictionaries to yaml file with same base file name - new_file = change_file_extension(init_file, 'yaml') - with open(new_file, 'wb') as f: - if 'daalg' in pr: - yaml.dump({'dataassim': pr, 'fwdsim': fwd}, f) - else: - yaml.dump({'optim': pr, 'fwdsim': fwd}, f) - - -def read_yaml(init_file): +def read_yaml(filepath: str): """ - Read .yaml input file, parse and return dictionaries for PIPT/POPT. + Read and parse a .yaml configuration file for PIPT/POPT. - Parameters - ---------- - init_file : str - .yaml file + The YAML file should contain one or more of the following top-level keys: + - 'dataassim' (dict): Data assimilation configuration + - 'optim' (dict): Optimization configuration + - 'fwdsim' (dict): Forward simulation configuration + - 'ensemble' (dict, optional): Ensemble configuration Returns ------- - keys_da : dict - Parsed keywords from dataassim - keys_fwd : dict - Parsed keywords from fwdsim + tuple + (keys_pr, keys_fwd, keys_en) + - keys_pr: dict, parsed 'dataassim' or 'optim' section (empty if not present) + - keys_fwd: dict, parsed 'fwdsim' section (empty if not present) + - keys_en: dict, parsed 'ensemble' section (empty if not present) + + Raises + ------ + FileNotFoundError + If the file does not exist. + ValueError + If the YAML file is missing required sections. + yaml.YAMLError + If the YAML file is invalid. """ - # Make a !ndarray tag to convert a sequence to np.array + if not os.path.isfile(filepath): + raise FileNotFoundError(f"YAML file '{filepath}' does not exist.") + + # Register a custom constructor for !ndarray if needed def ndarray_constructor(loader, node): array = loader.construct_sequence(node) return np.array(array) - - # Add constructor to yaml with tag !ndarray yaml.add_constructor('!ndarray', ndarray_constructor) - # Read yaml file - with open(init_file, 'rb') as fid: - y = yaml.load(fid, Loader=FullLoader) + with open(filepath, "rb") as f: + try: + config = yaml.load(f, Loader=FullLoader) + except yaml.YAMLError as e: + raise yaml.YAMLError(f"Error parsing YAML file '{filepath}': {e}") - # Check for ensemble - if 'ensemble' in y.keys(): - keys_en = y['ensemble'] - check_mand_keywords_en(keys_en) - else: - keys_en = {} - - # Check for dataassim - if 'dataassim' in y.keys(): - keys_pr = y['dataassim'] - check_mand_keywords_da(keys_pr) - elif 'optim' in y.keys(): - keys_pr = y['optim'] - check_mand_keywords_opt(keys_pr) - else: - keys_pr = {} - - if 'fwdsim' in y.keys(): - keys_fwd = y['fwdsim'] - else: - keys_fwd = {} + if not isinstance(config, dict): + raise ValueError(f"YAML file '{filepath}' does not contain a valid dictionary at the top level.") - # Organize keywords - org = Organize_input(keys_pr, keys_fwd, keys_en) - org.organize() + # Extract sections + cfg_ens = config.get("ensemble", {}) + cfg_sim = config.get("fwdsim") or config.get("simulator") or {} + cfg_prb = config.get("dataassim") or config.get("optim") or {} - return org.get_keys_pr(), org.get_keys_fwd(), org.get_keys_en() + return normalize_config(cfg_prb, cfg_sim, cfg_ens) + + +def read_toml(filepath: str): + """ + Read and parse a .toml configuration file for PIPT/POPT. + + The TOML file should contain one or more of the following top-level keys: + - 'dataassim' (dict): Data assimilation configuration + - 'optim' (dict): Optimization configuration + - 'fwdsim' (dict): Forward simulation configuration + - 'ensemble' (dict, optional): Ensemble configuration + + Returns + ------- + tuple + (keys_pr, keys_fwd, keys_en) + - keys_pr: dict, parsed 'dataassim' or 'optim' section (empty if not present) + - keys_fwd: dict, parsed 'fwdsim' section (empty if not present) + - keys_en: dict, parsed 'ensemble' section (empty if not present) + + Raises + ------ + FileNotFoundError + If the file does not exist. + ValueError + If the TOML file is missing required sections. + tomli.TOMLDecodeError + If the TOML file is invalid. + """ + if not os.path.isfile(filepath): + raise FileNotFoundError(f"TOML file '{filepath}' does not exist.") + + with open(filepath, 'rb') as f: + try: + config = tomli.load(f) + except tomli.TOMLDecodeError as e: + raise tomli.TOMLDecodeError(f"Error parsing TOML file '{filepath}': {e}") + + if not isinstance(config, dict): + raise ValueError(f"TOML file '{filepath}' does not contain a valid dictionary at the top level.") + + # Extract sections + cfg_ens = config.get("ensemble", {}) + cfg_sim = config.get("fwdsim") or config.get("simulator") or {} + cfg_prb = config.get("dataassim") or config.get("optim") or {} + + return normalize_config(cfg_prb, cfg_sim, cfg_ens) def convert_txt_to_toml(init_file): + """Write a legacy ``.pipt``/``.popt`` file as ``.toml`` next to it.""" # Read .pipt or .popt file - pr, fwd = read_txt(init_file) + pr, fwd, _ = read_txt(init_file) # Write dictionaries to toml file with same base file name new_file = change_file_extension(init_file, 'toml') with open(new_file, 'wb') as f: - if 'daalg' in pr: + if is_dataassim(pr): tomli_w.dump({'dataassim': pr, 'fwdsim': fwd}, f) else: tomli_w.dump({'optim': pr, 'fwdsim': fwd}, f) +def convert_txt_to_yaml(init_file): + """Write a legacy ``.pipt``/``.popt`` file as ``.yaml`` next to it.""" + # Read .pipt or .popt file + pr, fwd, _ = read_txt(init_file) -def read_toml(init_file): - """ - Read .toml configuration file, parse and output dictionaries for PIPT/POPT - - Parameters - ---------- - init_file : str - toml configuration file - """ - # Read - with open(init_file, 'rb') as fid: - t = tomli.load(fid) - - # Check for dataassim and fwdsim - if 'ensemble' in t.keys(): - keys_en = t['ensemble'] - check_mand_keywords_en(keys_en) - else: - keys_en = {} - if 'optim' in t.keys(): - keys_pr = t['optim'] - check_mand_keywords_opt(keys_pr) - elif 'dataassim' in t.keys(): - keys_pr = t['dataassim'] - check_mand_keywords_da(keys_pr) - else: - keys_pr = {} - if 'fwdsim' in t.keys(): - keys_fwd = t['fwdsim'] - else: - raise KeyError - - # Organize keywords - org = Organize_input(keys_pr, keys_fwd, keys_en) - org.organize() - - return org.get_keys_pr(), org.get_keys_fwd(), org.get_keys_en() - + # Write dictionaries to yaml file with same base file name + new_file = change_file_extension(init_file, 'yaml') + with open(new_file, 'w') as f: + if is_dataassim(pr): + yaml.dump({'dataassim': pr, 'fwdsim': fwd}, f) + else: + yaml.dump({'optim': pr, 'fwdsim': fwd}, f) def read_txt(init_file): """ @@ -195,20 +199,12 @@ def read_txt(init_file): # Assign the keys and values to different dictionaries depending on whether we have data assimilation (DATAASSIM) # or optimization (OPTIM). FWDSIM info is always assigned to keys_fwd - keys_pr = None - if pr_part == 'dataassim': - keys_pr = parse_keywords(clean_lines_pr) - check_mand_keywords_da(keys_pr) - elif pr_part == 'optim': - keys_pr = parse_keywords(clean_lines_pr) - check_mand_keywords_opt(keys_pr) + keys_pr = parse_keywords(clean_lines_pr) if pr_part in ('dataassim', 'optim') else None keys_fwd = parse_keywords(clean_lines_fwd) - check_mand_keywords_fwd(keys_fwd) - - org = Organize_input(keys_pr, keys_fwd) - org.organize() - - return org.get_keys_pr(), org.get_keys_fwd() + # Three sections, like the other readers; the text format keeps the + # ensemble's keys in DATAASSIM, so the third is empty. What is missing is + # reported by `pet validate` and when the run is built, not asserted here. + return normalize_config(keys_pr, keys_fwd, None) def read_clean_file(init_file): @@ -265,6 +261,86 @@ def remove_empty_lines(lines): return lines_clean +def _coerce_keyword_rows(rows): + """ + Convert the raw text rows following a keyword into a typed value. + + ``rows`` is a list of the raw (whitespace/tab-separated) strings that + followed a keyword in the init. file. Depending on how many rows there + are, and whether their tokens parse as numbers, the result is a float or + string scalar, a 1D list, or a 2D list. Numeric parsing is attempted + first (scalar, then 1D, then 2D); if that fails at every level the value + is treated as string data instead. + """ + if len(rows) == 1: + row = rows[0] + if len(row.split()) == 1: + try: + return float(row) + except Exception: + pass + try: + return [float(x) for x in row.split()] + except Exception: + pass + tokens = row.split('\t') + if len(tokens) == 1: + return row.strip().lower() + return [x.rstrip('\n').lower() for x in tokens if x != ''] + + # Multiple rows: try a flat 1D float list (one float per row) first... + try: + return [float(x) for x in rows] + except Exception: + pass + + # ...then a 2D float list (each row is one or more whitespace-separated floats)... + try: + return [[float(x) for x in col.split()] for col in rows] + except Exception: + pass + + # ...and finally fall back to string data: one column per row becomes a 1D + # list of strings, multiple (tab-separated) columns become a 2D list. + one_col = all(len(row.split('\t')) == 1 for row in rows) + if one_col: + return [x.rstrip('\n').lower() for x in rows] + return [[x.rstrip('\n').lower() for x in col.split('\t') if x != ''] for col in rows] + + +def _promote_token(token): + """Convert a string token to a float or list of floats where possible, else leave it unchanged.""" + try: + return float(token) + except Exception: + pass + try: + return [float(x) for x in token.split()] + except Exception: + return token + + +def _promote_numeric_strings(keys): + """ + Retroactively convert list values that were parsed as pure strings back to + numbers, where every entry (or sub-entry) actually parses as a float. + + ``_coerce_keyword_rows`` only recognizes a row block as numeric if *all* + of its rows parse as floats, so a keyword with a mix of numeric and + string rows ends up stored as strings. This fixes up such keywords + entry-by-entry after the fact. + """ + for value in keys.values(): + if not isinstance(value, list): + continue + if isinstance(value[0], list): + for row in value: + if all(isinstance(x, str) for x in row): + row[:] = [_promote_token(x) for x in row] + elif all(isinstance(x, str) for x in value): + value[:] = [_promote_token(x) for x in value] + + def parse_keywords(lines): """ Here we parse the lines in the init. file to a Python dictionary. The keys of the dictionary is the keywords @@ -282,122 +358,19 @@ def parse_keywords(lines): keys : dict Dictionary with all info. from the init. file. """ - # Init. the dictionary keys = {} + for line in lines: + if not line: # Empty list corresponds to an empty line in the file + continue + keyword = line[0].strip().lower() + keys[keyword] = _coerce_keyword_rows(line[1:]) - # Loop over all input keywords and store in the dictionary. - for i in range(len(lines)): - if lines[i] != []: # Check for empty list (corresponds to empty line in file) - try: # Try first to store the info. in keyword as float in a 1D list - # A scalar, which we store as scalar... - if len(lines[i][1:]) == 1 and len(lines[i][1:][0].split()) == 1: - keys[lines[i][0].strip().lower()] = float(lines[i][1:][0]) - else: - keys[lines[i][0].strip().lower()] = [float(x) for x in lines[i][1:]] - except: - try: # Store as float in 2D list - if len(lines[i][1:]) == 1: # Check if it is actually a 1D array disguised as 2D - keys[lines[i][0].strip().lower()] = \ - [float(x) for x in lines[i][1:][0].split()] - else: # if not store as 2D list - keys[lines[i][0].strip().lower()] = \ - [[float(x) for x in col.split()] for col in lines[i][1:]] - except: # Keyword contains string(s), not floats - if len(lines[i][1:]) == 1: # If 1D list - # If it is a scalar store as single input - if len(lines[i][1:][0].split('\t')) == 1: - keys[lines[i][0].strip().lower()] = lines[i][1:][0].strip().lower() - else: # Store as 1D list - keys[lines[i][0].strip().lower()] = \ - [x.rstrip('\n').lower() - for x in lines[i][1:][0].split('\t') if x != ''] - else: # It is a 2D list - # Check each row in 2D list. If it is single column (i.e., one string per row), - # we make it a 1D list of strings; if not, we make it a 2D list of strings. - one_col = True - for j in range(len(lines[i][1:])): - if len(lines[i][1:][j].split('\t')) > 1: - one_col = False - break - if one_col is True: # Only one column - keys[lines[i][0].strip().lower()] = \ - [x.rstrip('\n').lower() for x in lines[i][1:]] - else: # Store as 2D list - keys[lines[i][0].strip().lower()] = \ - [[x.rstrip('\n').lower() for x in col.split('\t') if x != ''] - for col in lines[i][1:]] - - # Need to check if there are any only-string-keywords that actually contains floats, and convert those to - # floats (the above loop only handles pure float or pure string input, hence we do a quick fix for mixed - # lists here) - # Loop over all keys in dict. and check every "pure" string keys for floats - for i in keys: - if isinstance(keys[i], list): # Check if key is a list - if isinstance(keys[i][0], list): # Check if it is a 2D list - for j in range(len(keys[i])): # Loop over all sublists - # Check sublist for strings - if all(isinstance(x, str) for x in keys[i][j]): - for k in range(len(keys[i][j])): # Loop over enteries in sublist - try: # Try to make float - keys[i][j][k] = float(keys[i][j][k]) # Scalar - except: - try: # 1D array - keys[i][j][k] = [float(x) - for x in keys[i][j][k].split()] - except: # If it is actually a string, pass over - pass - else: # It is a 1D list - # Check if list only contains strings - if all(isinstance(x, str) for x in keys[i]): - for j in range(len(keys[i])): # Loop over all entries in list - try: # Try to make float - keys[i][j] = float(keys[i][j]) - except: - try: - keys[i][j] = [float(x) for x in keys[i][j].split()] - except: # If it is actually a string, pass over - pass - - # Return dict. + _promote_numeric_strings(keys) return keys -def check_mand_keywords_fwd(keys_fwd): - """Check for mandatory keywords in `FWDSIM` part, and output error if they are not present""" - - # Mandatory keywords in FWDSIM - assert 'parallel' in keys_fwd, 'PARALLEL not in FWDSIM!' - assert 'datatype' in keys_fwd, 'DATATYPE not in FWDSIM!' - - -def check_mand_keywords_da(keys_da): - """Check for mandatory keywords in `DATAASSIM` part, and output error if they are not present""" - - # Mandatory keywords in DATAASSIM - assert 'truedataindex' in keys_da, 'TRUEDATAINDEX not in DATAASSIM!' - assert 'assimindex' in keys_da, 'ASSIMINDEX not in DATAASSIM!' - assert 'truedata' in keys_da, 'TRUEDATA not in DATAASSIM!' - assert 'datavar' in keys_da, 'DATAVAR not in DATAASSIM!' - assert 'obsname' in keys_da, 'OBSNAME not in DATAASSIM!' - assert 'energy' in keys_da, 'ENERGY not in DATAASSIM!' - - -def check_mand_keywords_opt(keys_opt): - """Check for mandatory keywords in `OPTIM` part, and output error if they are not present""" -pass - - -def check_mand_keywords_en(keys_en): - """Check for mandatory keywords in `ENSEMBLE` part, and output error if they are not present""" - - # Mandatory keywords in ENSEMBLE - assert 'ne' in keys_en, 'NE not in ENSEMBLE!' - assert ('state' in keys_en) or ('controls' in keys_en), 'STATE or CONTROLS not in ENSEMBLE!' - if 'importstaticvar' not in keys_en: - assert filter(list(keys_en.keys()), - 'prior_*') != [], 'No PRIOR_ in DATAASSIM' - def change_file_extension(filename, new_extension): + """``filename`` with its extension replaced by ``new_extension``.""" if '.' in filename: name, old_extension = filename.rsplit('.', 1) new_filename = name + '.' + new_extension diff --git a/src/misc/ecl.py b/src/misc/ecl.py index 2051bdf7..4341bfc4 100644 --- a/src/misc/ecl.py +++ b/src/misc/ecl.py @@ -600,7 +600,7 @@ def _get_prop_name(self, selector): # pylint: disable=no-self-use selector : tuple Selector tuple, e.g., (Prop.mole, 'CO2', Phase.gas). names : dict - Dictionary of defined names in the case. There must be an entry "components" + Dictionary of defined names in the case. There must be an entry "components" containing the names of the components in the case files. Returns @@ -645,7 +645,7 @@ def cell_data(self, selector): Parameters ---------- selector : tuple - Specification of the property to be loaded. This is a tuple starting with a Prop, + Specification of the property to be loaded. This is a tuple starting with a Prop, and then some context-dependent items. Returns @@ -711,9 +711,9 @@ def summary_data(self, propname): Parameters ---------- propname : str - Name of the property to be loaded. This is in the form 'mnemonic well', - e.g., 'WWIR I05'. Alternatively, propname can be either only well or - only mnemonic. Then the value for all mnemonics or all wells are given, + Name of the property to be loaded. This is in the form 'mnemonic well', + e.g., 'WWIR I05'. Alternatively, propname can be either only well or + only mnemonic. Then the value for all mnemonics or all wells are given, e.g., propname='WWIR' returns WWIR for all wells. Returns @@ -853,8 +853,9 @@ def date(self): # convert Eclipse date field to a Python date object return _intehead_date(intehead) - + def arrays(self): + """Names of the arrays in the file.""" ecl_file = EclipseFile(self.root, self.ext) return [list(ecl_file.cat.keys())[i][0] for i, _ in enumerate(ecl_file.cat)] @@ -1246,6 +1247,7 @@ def grid(self): return self._grid.grid() def arrays(self, when): + """Names of the arrays in the restart step at ``when``.""" return self.at(when).arrays() diff --git a/src/misc/grdecl.py b/src/misc/grdecl.py index 60c4ace5..2181d9de 100644 --- a/src/misc/grdecl.py +++ b/src/misc/grdecl.py @@ -19,8 +19,7 @@ import os import os.path import re -from six.moves import range # pylint: disable=redefined-builtin, import-error -import six +import io import sys @@ -1113,7 +1112,7 @@ def _fast_index_mem(base_dir, fname, mem, skip, index): # definition of special characters that can be compared directly to the # contents of the memory-map. notice that this is the inverse of the -# six.byte2int function that is used further below when manipulating a +# byte indexing (``b' '[0]``) that is used further below when manipulating a # bytearray copy. if sys.version_info[0] < 3: _SP = b' ' @@ -1339,7 +1338,7 @@ def _sec_mat_mem(mem, bgn, end, dtype, usecols): # let the library do the heavy lifting of this section; it is just an # array without any special formatting (anymore) - with ctx.closing(six.BytesIO(buf)) as src: + with ctx.closing(io.BytesIO(buf)) as src: data = numpy.loadtxt(src, dtype=dtype, usecols=usecols) return data @@ -1370,9 +1369,9 @@ def _read_specgrid(mem, sec_tbl): return spec[::-1] -_CR = six.byte2int(b'\r') -_LF = six.byte2int(b'\n') -_WS = six.byte2int(b' ') +_CR = b'\r'[0] +_LF = b'\n'[0] +_WS = b' '[0] def _strip_newline(data): @@ -1536,7 +1535,7 @@ def _read_multi(wrapper_name, mem): Parameters ---------- wrapper_name : str - Name of the file containing the inclusion wrapper. This file is only + Name of the file containing the inclusion wrapper. This file is only interesting because the name of the dimensions file is constructed based on it. mem : mmap.mmap Handle to memory-mapping of the wrapper file. diff --git a/src/misc/grid/cornerpoint.py b/src/misc/grid/cornerpoint.py index 28c86530..6940bf2f 100644 --- a/src/misc/grid/cornerpoint.py +++ b/src/misc/grid/cornerpoint.py @@ -156,7 +156,7 @@ def elem_vtcs_ndcs(nk, nj, ni): # pylint: disable=invalid-name Returns ------- ndarray - Zero-based indices for the hexahedral element corners, + Zero-based indices for the hexahedral element corners, with shape (nk*nj*ni, 8) and dtype int. """ # hex_perm is the order a hexahedron should be specified to the @@ -299,7 +299,7 @@ def cp_cells(grid, face): dict Set of geometrical objects that can be sent to rendering. Contains: - 'points': ndarray, shape (nverts, 3) - - 'cells': ndarray, shape (nelems, ncorns), where ncorns is either 8 + - 'cells': ndarray, shape (nelems, ncorns), where ncorns is either 8 (hexahedron volume) or 4 (quadrilateral face), depending on the face parameter. """ src = {} @@ -355,7 +355,7 @@ def cell_filter(grid, func): # call the filter function on all these addresses, and simply # return the boolean array of those filter_flags = func(kji[2], kji[1], kji[0]) - masked = filter_flags.astype(np.bool) + masked = filter_flags.astype(bool) # get the mask of active cells, and combine this with the masked # cells from the filter, giving us a flag for all visible nodes @@ -645,10 +645,10 @@ def mass_center(corn, filtr): Parameters ---------- corn : numpy.ndarray - Coordinate values for each corner. This matrix can be constructed with the + Coordinate values for each corner. This matrix can be constructed with the `corner_coordinates` function. Shape = (3, nk*2*nj*2*ni*2). filtr : numpy.ndarray - Active corners; use scatter of ACTNUM if no filtering. Shape = (nk, 2, nj, 2, ni, 2), + Active corners; use scatter of ACTNUM if no filtering. Shape = (nk, 2, nj, 2, ni, 2), dtype = numpy.bool. Returns diff --git a/src/misc/grid/unstruct.py b/src/misc/grid/unstruct.py index 12b8645c..59c59cf4 100644 --- a/src/misc/grid/unstruct.py +++ b/src/misc/grid/unstruct.py @@ -118,7 +118,7 @@ def conv(grid): corn_z = np.empty((2, 2, 2, nk), dtype=np.float32) corn_i = np.empty((2, 2, 2, nk), dtype=np.int32) corn_j = np.empty((2, 2, 2, nk), dtype=np.int32) - corn_a = np.empty((2, 2, 2, nk), dtype=np.bool) + corn_a = np.empty((2, 2, 2, nk), dtype=bool) # get all unique points that are hinged to a certain pillar (p, q) for q, p in np.ndindex((nj + 1, ni + 1)): diff --git a/src/misc/read_input_csv.py b/src/misc/read_input_csv.py index 0b031d1a..61ea4cfa 100644 --- a/src/misc/read_input_csv.py +++ b/src/misc/read_input_csv.py @@ -1,498 +1,222 @@ -""" -CSV and Pickle Data Reader Utilities - -This module provides utility functions for reading and processing data from CSV and pickle files. -It supports various data formats including NumPy arrays, pandas DataFrames, and handles data -type conversions for ensemble modeling and data assimilation workflows. - -Main Functions: - - read_data_df: Reads data from CSV/pickle files, returns as NumPy arrays or dictionaries - - read_var_df: Reads variance data from CSV/pickle files - - read_data_csv: Legacy CSV reading function with data flattening - - read_var_csv: Legacy variance CSV reading function - - convert_to_array: Converts string representations to NumPy arrays - - to_array_if_sequence: Converts various data types to NumPy array format - -Typical use cases: - - Loading observational data for data assimilation - - Reading ensemble data with various data types - - Processing CSV files with mixed data types and array-like strings - - Handling variance/uncertainty data alongside measurements - -Last Modified: February 2026 +"""Observed data and its variance, read from the files a config names. + +:class:`DataReader` turns the ``truedata``/``datavar`` entries of the +``[dataassim]`` block -- CSV, pickle or ``.npz`` files, with cells that may +themselves point at ``.npz`` arrays -- into the frames the ensemble holds, +applying wavelet compression to seismic vintages when configured. """ import ast -import pandas as pd +import os +from copy import deepcopy + import numpy as np -import pickle - -def convert_to_array(array_str): - """ - Convert space-separated string representations of numbers to NumPy arrays. - - This function handles strings with space-separated numeric values and converts - them back to NumPy arrays. It removes brackets and whitespace before parsing. - - Parameters - ---------- - array_str : str - String containing space-separated numbers, optionally with brackets. - Example: "[1.0 2.0 3.0]" or "1.0 2.0 3.0" - - Returns - ------- - np.ndarray or str - NumPy array of floats if conversion is successful, otherwise returns - the original string unchanged. - - Examples - -------- - >>> convert_to_array("1.0 2.0 3.0") - array([1., 2., 3.]) - >>> convert_to_array("[1.0 2.0 3.0]") - array([1., 2., 3.]) - """ - try: - # Remove any unwanted characters like square brackets and split by space - cleaned_str = array_str.replace('[', '').replace(']', '').strip() - # Split the string by spaces and convert the result to a NumPy array of floats - return np.array([float(x) for x in cleaned_str.split()]) - except (ValueError, AttributeError): - # If the string cannot be converted, return it as is (error handling) - return array_str - -def to_array_if_sequence(val): - """ - Convert various data types to NumPy array or sequence format. - - Handles conversion of different input types (scalars, lists, strings, arrays) - into a consistent array-like format for data processing. - - Parameters - ---------- - val : various - Input value to convert. Can be np.ndarray, int, float, list, str, or other. - - Returns - ------- - np.ndarray or list - - NumPy array if input is ndarray, numeric scalar, list, or parseable string - - List containing the value if input is of another type - - Notes - ----- - String inputs are only parsed if they are enclosed in brackets (e.g., "[1 2 3]"). - All numeric scalars are wrapped into 1D arrays. - """ - if isinstance(val, np.ndarray): - return val - elif isinstance(val, (int, float)): - return np.array([val]) - elif isinstance(val, list): - return np.array(val) - elif isinstance(val, str) and val.strip().startswith('[') and val.strip().endswith(']'): - try: - return np.fromstring(val.strip('[]'), sep=' ') - except: - return val # fallback in case parsing fails - else: - return [val] # wrap scalars - - -def read_data_df(filename, datatype=None, truedataindex=None, outtype='np.array',return_data_info=True): - """ - Read observational data from CSV or pickle files with flexible output formats. - - This function reads data files (CSV or pickle) containing observational data, - processes array-like string representations, and returns the data in the - requested format. Supports filtering by data types and row indices. - - Parameters - ---------- - filename : str - Path to the data file. Must end with '.csv' or '.pkl'. - datatype : list of str, optional - Column names to extract. If None, all columns are used. Default is None. - truedataindex : list of int, optional - Row indices to extract (0-based). If None, all rows are used. Default is None. - outtype : {'np.array', 'list'}, optional - Output format: - - 'np.array': Returns flattened NumPy array - - 'list': Returns list of dictionaries - Default is 'np.array'. - return_data_info : bool, optional - If True, also returns metadata (column names and row indices). Default is True. - - Returns - ------- - flat_array : np.ndarray - Flattened 1D array of all data (if outtype='np.array'). - data : list of dict - List where each element is a dictionary with column names as keys (if outtype='list'). - datatype : list of str - Column names used (only if return_data_info=True). - indices : list - Row indices/labels used (only if return_data_info=True). - - Notes - ----- - - String representations of arrays (e.g., "[1.0 2.0 3.0]") are automatically - converted to NumPy arrays. - - When outtype='np.array', arrays from multiple columns and rows are concatenated - into a single flat array. - - The first column in CSV files is used as the index. - """ - - # read the file - if filename.endswith('.csv'): - df = pd.read_csv(filename, index_col=0) - elif filename.endswith('.pkl'): - df = pd.read_pickle(filename) - # convert the string representation of arrays back to NumPy arrays - for col in df.columns: - df[col] = df[col].apply(convert_to_array) - - df = df.where(pd.notnull(df), None) - - if outtype == 'np.array': # vectorize data - if datatype is not None: - if truedataindex is not None: - flat_array = np.concatenate([np.concatenate([df.iloc[ti][col] if isinstance(df.iloc[ti][col], np.ndarray) else - np.array([df.iloc[ti][col]]) - for col in datatype]) for ti in truedataindex]) - if return_data_info: - return flat_array, list(datatype), [df.index[el] for el in truedataindex] - else: - flat_array = np.concatenate([np.concatenate([row[col] if isinstance(row[col], np.ndarray) else - np.array([row[col]]) - for col in datatype]) for _, row in df.iterrows()]) - if return_data_info: - return flat_array, list(datatype), list(df.index) + +from misc.structures import PETDataFrame + +class DataReader: + """Reads the observed data and its variance, as frames, from the files a config names.""" + + def __init__(self, info: dict, **kwargs): + self.info = info + self.data = info.get('data', None) + self.var = info.get('datavar', None) + + # NB: Not sure if this will be used or needed! + self.assimindex = info.get('assimindex', None) + self.truedataindex = info.get('truedataindex', None) + self.datatype = info.get('datatype', None) + + # Sparse infor for data compression (for seismic data) + self.sparse = kwargs.get('sparse_info', None) + self.sparse_data = [] + + # Error handling for missing data or variance + if self.data is None: + msg = "Data missing: the 'data' key is missing in info dictionary." + raise ValueError(msg) + if self.var is None: + msg = "Variance missing: the 'datavar' key is missing in info dictionary." + raise ValueError(msg) + + + def get_data(self) -> PETDataFrame: + """The observations as a frame: report labels as index, data types as columns; ``.npz`` cells are loaded and compressed vintages reduced to their leading wavelet coefficients.""" + if isinstance(self.data, str): + df = self._read_from_file(self.data) + elif isinstance(self.data, dict): + df = self._read_from_dict(self.data) else: - if truedataindex is not None: - flat_array = np.concatenate([np.concatenate([df.iloc[ti][col] if isinstance(df.iloc[ti][col], np.ndarray) else - np.array([df.iloc[ti][col]]) - for col in df.columns]) for ti in truedataindex]) - if return_data_info: - return flat_array, list(df.columns), [df.index[el] for el in truedataindex] - else: - flat_array = np.concatenate([np.concatenate([row[col] if isinstance(row[col], np.ndarray) else np.array([row[col]]) - for col in df.columns]) for _, row in df.iterrows()]) - if return_data_info: - return flat_array, list(df.columns), list(df.index) - - return flat_array - - elif outtype == 'list': # return data as a list over row indices. Where each list element is a dictionary with keys equal to column names - if datatype is not None: - if truedataindex is not None: - data = [ - { - col: to_array_if_sequence(df.iloc[ti][col]) - for col in datatype - } - for ti in truedataindex - ] - - if return_data_info: - data, list(datatype), [df.index[el] for el in truedataindex] - else: - data = [ - { - col: to_array_if_sequence(row[col]) - for col in datatype - } - for _, row in df.iterrows() - ] - if return_data_info: - data, list(datatype), list(df.index) + msg = f"Unsupported data type: {type(self.data)}. Expected str or dict." + raise TypeError(msg) + + # Process each cell for potential npz files and apply wavelet compression if specified + vintage = 0 + for i, idx in enumerate(df.index): + for col in df.columns: + cell = df.loc[idx, col] + + if isinstance(cell, str) and cell.endswith('.npz'): + npzfile = np.load(cell, allow_pickle=True) + cell = np.squeeze(npzfile[npzfile.files[0]]) + assert cell.ndim < 2, f"Expected 1D array in npz file {cell}, but got {cell.ndim}D." + + if (self.sparse is not None) and (col in self.sparse['compress_data']) and (not np.isnan(cell).any()): + if vintage < len(self.sparse['mask']): + cell = self._wavelet_compression(cell, vintage=vintage) + vintage += 1 + + # Store new value + df.at[idx, col] = cell + + # NB: Not sure if this will be used or needed! + self.datatype = df.columns.tolist() + self.assimindex = np.arange(len(df.index)).tolist() + self.truedataindex = df.index.tolist() + return df + + + def get_variance(self, data_df: PETDataFrame, sparse_data: list=None) -> PETDataFrame: + """The variance frame on ``data_df``'s geometry, from ``['abs', v]``, ``['rel', percent]``, ``['emp', ensemble]`` or ``['cd', file]`` cells; a compressed vintage gets its estimated noise squared.""" + if isinstance(self.var, str): + _df = self._read_from_file(self.var) + else: + msg = f"Unsupported variance type: {type(self.var)}. Expected str (file path)." + raise TypeError(msg) + + # Fill in dataframe + vintage = 0 + df = PETDataFrame(columns=data_df.columns, index=data_df.index) + for i, idx in enumerate(data_df.index): + for c, col in enumerate(data_df.columns): + + if (data_df.loc[idx, col] is not None) and (not np.isnan(data_df.loc[idx, col]).any()): + # Sparse stuff (for seismic data) + if ( + self.sparse is not None + and sparse_data is not None + and col in self.sparse.get('compress_data', []) + and vintage < len(sparse_data) + ): + var = np.power(sparse_data[vintage].est_noise, 2) + vintage += 1 + + + else: + var = self._extract_cell_variance( + _df.loc[idx, col], + data_df.loc[idx, col], + i, + c, + ) + + df.at[idx, col] = var + else: + df.at[idx, col] = None + + # Mark as ensemble if specified in info + if 'emp_cov' in self.info: + if (self.info['emp_cov'] == 'yes') or (self.info['emp_cov'] is True): + df.is_ensemble = True + + return df.astype(float, errors='ignore') + + + def _read_from_file(self, filepath: str) -> PETDataFrame: + ext = os.path.splitext(filepath)[1].lower() + if ext == '.pkl': + df = PETDataFrame.from_pickle(filepath) + elif ext == '.csv': + df = PETDataFrame.from_csv(filepath, index_col=0, parse_dates=True) + #df = df.astype(float, errors='ignore') + elif ext == '.npz': + data = dict(np.load(filepath, allow_pickle=True)) + df = self._read_from_dict(data) else: - if truedataindex is not None: - data = [ - { - col: to_array_if_sequence(df.iloc[ti][col]) - for col in df.columns - } - for ti in truedataindex - ] - if return_data_info: - data, list(datatype), list(df.index) + msg = f"Unsupported file type: {filepath}. Expected .csv, .pkl, or .npz." + raise ValueError(msg) + return df + + + def _read_from_dict(self, data_dict: dict) -> PETDataFrame: + index = data_dict.pop('index', None) + index_name = data_dict.pop('index_name', self.info.get('obsname', None)) + df = PETDataFrame(data=data_dict, index=index) + df.index.name = index_name + return df + + + def _extract_cell_variance(self, var_cell, data_cell, i, c): + + if isinstance(var_cell, str) and var_cell.strip().startswith('['): + # Example: "['abs', 0.5]" --> ['abs', 0.5] + var_cell = ast.literal_eval(var_cell) + + # Variance given as relative percentage (e.g., ['rel', 5] means 5% of the data value) + if var_cell[0].lower() == 'rel': + if var_cell[1] is None: + return None + return (0.01*var_cell[1] * data_cell)**2 + + # Variance given as absolute value (e.g., ['abs', 0.5] means a variance of 0.5). + # If the value is iterable, it is indexed by column. + elif var_cell[0].lower() == 'abs': + if hasattr(data_cell, 'ndim') and data_cell.ndim > 0: + val = var_cell[1]*np.ones_like(data_cell) + return val else: - data = [ - { - col: to_array_if_sequence(row[col]) - for col in df.columns - } - for _, row in df.iterrows() - ] - if return_data_info: - return data, list(df.columns), list(df.index) - return data - -def read_var_df(filename, datatype=None, truedataindex=None, outtype='list'): - """ - Read variance/uncertainty data from CSV or pickle files. - - This function is designed to read variance or standard deviation data that - corresponds to observational data. It returns the data as a list of dictionaries, - with special handling for datatype columns that may contain tuple representations. - - Parameters - ---------- - filename : str - Path to the variance file. Must end with '.csv' or '.pkl'. - datatype : list of str, optional - Column names to extract. Supports tuple-like string representations - (e.g., "('OPR', 'WWCT')") which are parsed using ast.literal_eval. - If None, all columns are used. Default is None. - truedataindex : list of str or int, optional - Row indices/labels to extract. If None, all rows are used. Default is None. - outtype : {'list'}, optional - Output format. Currently only 'list' is supported. Default is 'list'. - - Returns - ------- - var : list of dict - List where each element is a dictionary with column names as keys and - variance/uncertainty values as values. Each dictionary corresponds to one row. - - Notes - ----- - - CSV file indices are converted to strings for consistent lookup. - - The datatype parameter attempts to evaluate string representations of tuples, - which is useful when column names are composite keys. - - This function is typically used alongside read_data_df to load both - observations and their uncertainties. - """ - - # read the file - if filename.endswith('.csv'): - df = pd.read_csv(filename, index_col=0) - df.index = df.index.astype(str) # Convert index to string - elif filename.endswith('.pkl'): - df = pd.read_pickle(filename) - - # Perform a one-time conversion of datatype if needed - if datatype is not None: - try: - datatype = [ast.literal_eval(col) for col in datatype] - except (ValueError, SyntaxError): - pass # Keep datatype as is if conversion fails - - - if outtype == 'list': - if datatype is not None: - if truedataindex is not None: - var = [{col: df.loc[ti][col] for col in datatype} for ti in truedataindex] + val = var_cell[1] + if hasattr(val, '__iter__') and not isinstance(val, str): + return val[c] else: - var = [{col: row[col] for col in datatype} for _, row in df.iterrows()] + return val + + # Variance given as empirical ensemble (e.g., ['emp', [300, 350, 244, ...]]). + elif (var_cell[0].lower() == 'emp'): + return var_cell[1] + + # Variance given as full covariance matrix (e.g., ['cd', 'covfile.npz']). + elif (var_cell[0].lower() == 'cd') and (var_cell[1].endswith('.npz')): + # Populate once + if not hasattr(self, 'cov'): + covfile = np.load(var_cell[1], allow_pickle=True)['cov'] + self.cov = covfile[covfile.files[0]] + return self.cov[i*c, i*c] + + # Return None if no data for this cell + elif data_cell is None: + return None + else: - if truedataindex is not None: - var = [{col: df.loc[ti][col] for col in df.columns} for ti in truedataindex] + msg = f"Unsupported variance type in cell: {var_cell}. Expected format like ['rel', value], ['abs', values], or ['emp', value]." + raise ValueError(msg) + + + def _wavelet_compression(self, arr, vintage): + + options = deepcopy(self.sparse) + options['mask'] = options['mask'][vintage] + min_noise = options['min_noise'] + + if isinstance(min_noise, list): + if 0 <= vintage < len(min_noise): + options['min_noise'] = min_noise[vintage] else: - var = [{col: row[col] for col in df.columns} for _, row in df.iterrows()] - - return var - -def read_data_csv(filename, datatype, truedataindex): - """ - Read observational data from CSV files (legacy function). - - This is a legacy function for reading CSV files with flexible header configurations. - Supports files with column headers, row headers, both, or neither. Handles missing - values by replacing them with 'n/a'. - - Parameters - ---------- - filename : str - Path to the CSV file. - datatype : list of str - Column names (or positional column identifiers) for data types to extract. - truedataindex : list - Row identifiers where observational data was recorded (e.g., time stamps, - observation indices). Used to select specific rows from the CSV. - - Returns - ------- - imported_data : list of list - 2D list where each sublist represents a row of extracted data. - Each element is either a float (numeric data) or string (text/missing data). - Missing numeric values are replaced with 'n/a'. - - Notes - ----- - - If the first column is 'header_both', the CSV is assumed to have both - row and column headers. - - If row count matches len(truedataindex), assumes column headers exist. - - If row count is len(truedataindex)+1, assumes first row was misinterpreted - as header and re-reads it as data. - - NaN values in numeric columns are replaced with 'n/a' strings. - - See Also - -------- - read_data_df : Modern version using pandas DataFrames with more flexible output. - """ - - df = pd.read_csv(filename) # Read the file - - imported_data = [] # Initialize the 2D list of csv data - tlength = len(truedataindex) - dnumber = len(datatype) - - if df.columns[0] == 'header_both': # csv file has column and row headers - pos = [None] * dnumber - for col in range(dnumber): - # find index of data type in csv file header - pos[col] = df.columns.get_loc(datatype[col]) - for t in truedataindex: - row = df[df['header_both'] == t] # pick row corresponding to truedataindex - row = row.values[0] # select the values of the dataframe row - csv_data = [None] * dnumber - for col in range(dnumber): - if (not type(row[pos[col]]) == str) and (np.isnan(row[pos[col]])): # do not check strings - csv_data[col] = 'n/a' - else: - try: # Making a float - csv_data[col] = float(row[pos[col]]) - except: # It is a string - csv_data[col] = row[pos[col]] - imported_data.append(csv_data) - else: # No row headers (the rows in the csv file must correspond to the order in truedataindex) - if tlength == df.shape[0]: # File has column headers - pos = [None] * dnumber - for col in range(dnumber): - # Find index of the header in datatype - pos[col] = df.columns.get_loc(datatype[col]) - # File has no column headers (columns must correspond to the order in datatype) - elif tlength == df.shape[0]+1: - # First row has been misinterpreted as header, so we read first row again: - temp = pd.read_csv(filename, header=None, nrows=1).values[0] - pos = list(range(df.shape[1])) # Assume the data is in the correct order - csv_data = [None] * len(temp) - for col in range(len(temp)): - if (not type(temp[col]) == str) and (np.isnan(temp[col])): # do not check strings - csv_data[col] = 'n/a' - else: - try: # Making a float - csv_data[col] = float(temp[col]) - except: # It is a string - csv_data[col] = temp[col] - imported_data.append(csv_data) - - for rows in df.values: - csv_data = [None] * dnumber - for col in range(dnumber): - if (not type(rows[pos[col]]) == str) and (np.isnan(rows[pos[col]])): # do not check strings - csv_data[col] = 'n/a' - else: - try: # Making a float - csv_data[col] = float(rows[pos[col]]) - except: # It is a string - csv_data[col] = rows[pos[col]] - imported_data.append(csv_data) - - return imported_data - - -def read_var_csv(filename, datatype, truedataindex): - """ - Read variance/uncertainty data from CSV files (legacy function). - - This is a legacy function for reading CSV files containing variance or - standard deviation data. Assumes that variance data is stored in alternating - columns: data type identifier (string) followed by variance value (numeric). - - Parameters - ---------- - filename : str - Path to the CSV file containing variance data. - datatype : list of str - Column names (or positional identifiers) for data types. The function - expects variance values in adjacent columns (datatype_col + 1). - truedataindex : list - Row identifiers where variance data was recorded. Used to select - specific rows from the CSV. - - Returns - ------- - imported_var : list of list - 2D list where each sublist contains alternating data type identifiers - (strings, converted to lowercase) and variance values (floats). - Format: [type1, var1, type2, var2, ...] for each row. - - Notes - ----- - - The function expects variance data in alternating columns with the structure: - [type_name, variance_value, type_name, variance_value, ...] - - Data type names are automatically converted to lowercase. - - Supports the same header configurations as read_data_csv: - both headers, column headers only, row headers only, or no headers. - - If first column is 'header_both', assumes both row and column headers exist. - - See Also - -------- - read_var_df : Modern version using pandas DataFrames. - read_data_csv : Companion function for reading observational data. - """ - - df = pd.read_csv(filename) # Read the file - - imported_var = [] # Initialize the 2D list of csv data - tlength = len(truedataindex) - dnumber = len(datatype) - - if df.columns[0] == 'header_both': # csv file has column and row headers - pos = [None] * dnumber - for col in range(dnumber): - # find index of data type in csv file header - pos[col] = df.columns.get_loc(datatype[col]) - for t in truedataindex: - row = df[df['header_both'] == t] # pick row - row = row.values[0] # select the values of the dataframe - csv_data = [None] * 2 * dnumber - for col in range(dnumber): - csv_data[2*col] = row[pos[col]] - try: # Making a float - csv_data[2*col+1] = float(row[pos[col]]+1) - except: # It is a string - csv_data[2*col+1] = row[pos[col]+1] - # Make sure the string input is lowercase - csv_data[0::2] = [x.lower() for x in csv_data[0::2]] - imported_var.append(csv_data) - else: # No row headers (the rows in the csv file must correspond to the order in truedataindex) - if tlength == df.shape[0]: # File has column headers - pos = [None] * dnumber - for col in range(dnumber): - # Find index of datatype in csv file header - pos[col] = df.columns.get_loc(datatype[col]) - # File has no column headers (columns must correspond to the order in datatype) - elif tlength == df.shape[0]+1: - # First row has been misinterpreted as header, so we read first row again: - temp = pd.read_csv(filename, header=None, nrows=1).values[0] - # Make sure the string input is lowercase - temp[0::2] = [x.lower() for x in temp[0::2]] - # Assume the data is in the correct order - pos = list(range(0, df.shape[1], 2)) - csv_data = [None] * len(temp) - for col in range(dnumber): - csv_data[2 * col] = temp[2 * col] - try: # Making a float - csv_data[2*col+1] = float(temp[2*col+1]) - except: # It is a string - csv_data[2*col+1] = temp[2*col+1] - imported_var.append(csv_data) - - for rows in df.values: - csv_data = [None] * 2 * dnumber - for col in range(dnumber): - csv_data[2*col] = rows[2*col] - try: # Making a float - csv_data[2*col+1] = float(rows[pos[col]+1]) - except: # It is a string - csv_data[2*col+1] = rows[pos[col]+1] - # Make sure the string input is lowercase - csv_data[0::2] = [x.lower() for x in csv_data[0::2]] - imported_var.append(csv_data) - - return imported_var + msg = 'min_noise must either be scalar or list with one number for each vintage' + raise ValueError(msg) + + # Apply wavelet compression. Imported here: PyWavelets is needed only + # for sparse compression, and keeping the import out of module scope + # means importing misc does not import pipt. + from pipt.misc_tools.wavelet_tools import SparseRepresentation + + sparsrep = SparseRepresentation(options) + arr_compressed, wdec_rec = sparsrep.compress(arr, th_mult=options['th_mult']) + self.sparse_data.append(sparsrep) # Store the information + + # Save reconstructed data + arr_reconstructed = sparsrep.reconstruct(wdec_rec) # reconstruct the data + np.savez('truedata_rec_' + str(vintage) + '.npz', arr_reconstructed) + + return arr_compressed + diff --git a/src/misc/sampling.py b/src/misc/sampling.py new file mode 100644 index 00000000..987c1713 --- /dev/null +++ b/src/misc/sampling.py @@ -0,0 +1,127 @@ +"""Random draws for PET: which stream they come from, and the sampler that makes them. + +Every draw PET makes -- prior realisations, perturbed observations, outlier +and crash replacement, the auto-adaptive localization's shuffle, popt's +control perturbations -- goes through the ensemble's ``rng``. That is a +``numpy.random.RandomState`` seeded from the ensemble config's ``seed`` when +one is given, so a run is reproducible on its own and leaves NumPy's global +state untouched; without a seed it is :class:`GlobalRandomStream`, which +draws from the global functions exactly as PET always did, so +``np.random.seed(...)`` keeps controlling a run. +""" + +import numpy as np +from scipy import linalg + +__all__ = ["GlobalRandomStream", "random_stream", "gen_real"] + + +class GlobalRandomStream: + """NumPy's global random functions behind a ``RandomState``-shaped object. + + Exists for two reasons: the ``numpy.random`` module itself cannot be + pickled, and the ensemble is pickled by its emergency dump; and a named + object makes it visible in code that a draw comes from the global stream. + """ + + def randn(self, *shape): + """As ``numpy.random.randn``, on the global stream.""" + return np.random.randn(*shape) + + def standard_normal(self, size=None): + """As ``numpy.random.standard_normal``, on the global stream.""" + return np.random.standard_normal(size) + + def normal(self, loc=0.0, scale=1.0, size=None): + """As ``numpy.random.normal``, on the global stream.""" + return np.random.normal(loc, scale, size) + + def rand(self, *shape): + """As ``numpy.random.rand``, on the global stream.""" + return np.random.rand(*shape) + + def uniform(self, low=0.0, high=1.0, size=None): + """As ``numpy.random.uniform``, on the global stream.""" + return np.random.uniform(low, high, size) + + def choice(self, a, size=None, replace=True, p=None): + """As ``numpy.random.choice``, on the global stream.""" + return np.random.choice(a, size=size, replace=replace, p=p) + + def permutation(self, x): + """As ``numpy.random.permutation``, on the global stream.""" + return np.random.permutation(x) + + def multivariate_normal(self, mean, cov, size=None): + """As ``numpy.random.multivariate_normal``, on the global stream.""" + return np.random.multivariate_normal(mean, cov, size) + + def get_state(self): + """As ``numpy.random.get_state``, on the global stream.""" + return np.random.get_state() + + def set_state(self, state): + """As ``numpy.random.set_state``, on the global stream.""" + np.random.set_state(state) + + def __reduce__(self): + return (GlobalRandomStream, ()) + + +def random_stream(seed=None): + """The stream a run draws from: a private ``RandomState`` if ``seed`` is given, else the global one.""" + if seed is None: + return GlobalRandomStream() + return np.random.RandomState(int(seed)) + + +def gen_real(mean, var, number, rng=None, limits=None, return_chol=False): + """Realisations of a Gaussian with the given mean and (co)variance. + + Draw for draw the same as ``geostat.decomp.Cholesky.gen_real`` -- the + same shapes drawn in the same order with the same arithmetic -- so runs + are bit-identical to what geostat produced; only the stream is a + parameter now. + + Parameters + ---------- + mean : array-like, shape (n,) + Mean vector. + var : array-like + Variance vector ``(n,)``, covariance matrix ``(n, n)``, or a scalar + when ``mean`` has one element. + number : int + Number of realisations. + rng : RandomState-like, optional + The stream to draw from; the global one by default. + limits : dict, optional + ``{'lower': ..., 'upper': ...}`` to clip the realisations to. + return_chol : bool, optional + Also return the factor used: ``sqrt(var)`` for a diagonal, the upper + Cholesky factor otherwise. + + Returns + ------- + ndarray, shape (n, number), and the factor when ``return_chol``. + """ + rng = random_stream() if rng is None else rng + var = np.asarray(var) + if len(mean) == 1 or var.ndim == 1: + factor = np.sqrt(var) + elif np.count_nonzero(var - np.diagonal(var)) == 0: + factor = np.sqrt(var) # diagonal: no factorisation needed + else: + factor = linalg.cholesky(var) # upper triangular, var = factor.T @ factor + + if var.ndim == 1: + real = (np.dot(np.expand_dims(mean, axis=1), np.ones((1, number))) + + np.expand_dims(factor, axis=1) * rng.randn(np.size(mean), number)) + else: + real = (np.tile(np.reshape(mean, (len(mean), 1)), (1, number)) + + np.dot(factor.T, rng.randn(np.size(mean), number))) + + if limits is not None: + real[real > limits['upper']] = limits['upper'] + real[real < limits['lower']] = limits['lower'] + + return (real, factor) if return_chol else real diff --git a/src/misc/structures/__init__.py b/src/misc/structures/__init__.py new file mode 100644 index 00000000..5e1a4f85 --- /dev/null +++ b/src/misc/structures/__init__.py @@ -0,0 +1,12 @@ +"""PET's data containers. + +``PETDataFrame`` is the ragged table observed and predicted data arrive in +and are saved as; on the analysis path the data live in matrices ordered by +a ``DataLayout`` (``PredictedData`` for the forecast). The state is a plain +``(nx, ne)`` array whose variable layout is a ``StateLayout``. +""" +from .structures import PETDataFrame +from misc.structures.layout import DataLayout, LayoutRow, StateLayout +from misc.structures.predicted import PredictedData + +__all__ = ["PETDataFrame", "DataLayout", "LayoutRow", "PredictedData", "StateLayout"] diff --git a/src/misc/structures/layout.py b/src/misc/structures/layout.py new file mode 100644 index 00000000..12b43743 --- /dev/null +++ b/src/misc/structures/layout.py @@ -0,0 +1,297 @@ +"""The two layouts every PET array follows: rows of the data vector, rows of the state. + +Observed data arrive as a frame with one row per report label (a time, a +date, an index) and one column per data type; a cell holds a scalar or a +vector, or nothing when that type was not observed at that label. Every +matrix the analyses work on -- the observation vector, its variance, the +predicted-data ensemble, the adjoints -- lists those cells in one fixed +order, label-major then type, skipping the empty ones. :class:`DataLayout` +is that order, computed once from the observed frame. Anything built from it +is aligned with anything else built from it by construction, which is what +the frame filters used to promise and could not keep once a cell was empty. + +The state is a plain ``(nx, ne)`` array. Its ``{variable: (start, stop)}`` +row map used to ride on an ``ndarray`` subclass, copied onto every slice and +view (wrongly) and lost on unpickling. It now lives once, as the ensemble's +``idX`` dictionary, and :class:`StateLayout` gives it the conversions the +boundary needs: one dictionary per variable for saving and QA/QC, one +dictionary per member for the simulator, clipping to the prior's limits, and +the two constructors that build a state, from a dictionary of arrays or from +the prior description. +""" + +from dataclasses import dataclass + +import numpy as np +import pandas as pd + +from misc.sampling import gen_real +from misc.structures.structures import PETDataFrame + +__all__ = ["DataLayout", "LayoutRow", "StateLayout"] + + +def is_missing(cell) -> bool: + """Whether a frame cell holds no observation: ``None`` or nothing but NaN.""" + if cell is None: + return True + return not np.any(pd.notna(np.atleast_1d(cell))) + + +@dataclass(frozen=True) +class LayoutRow: + """One observed cell and the rows it owns: ``[start, stop)``.""" + + label: object + datatype: str + start: int + stop: int + + @property + def size(self) -> int: + """Number of rows this cell owns.""" + return self.stop - self.start + + @property + def rows(self) -> slice: + """The slice of the data vector this cell owns.""" + return slice(self.start, self.stop) + + +@dataclass(frozen=True) +class DataLayout: + """The order of the data vector, derived once from the observed frame.""" + + rows: tuple + labels: tuple + datatypes: tuple + label_name: object = None + + @classmethod + def from_frame(cls, frame) -> "DataLayout": + """Walk ``frame`` label-major then type, as the frame flatten did, skipping empty cells.""" + rows, start = [], 0 + for label in frame.index: + for datatype in frame.columns: + cell = frame.loc[label, datatype] + if is_missing(cell): + continue + size = int(np.size(cell)) + rows.append(LayoutRow(label, datatype, start, start + size)) + start += size + return cls(tuple(rows), tuple(frame.index), tuple(frame.columns), frame.index.name) + + @property + def nd(self) -> int: + """Length of the data vector.""" + return self.rows[-1].stop if self.rows else 0 + + def row(self, label, datatype) -> LayoutRow: + """The row of ``(label, datatype)``; ``KeyError`` when that cell was not observed.""" + for row in self.rows: + if row.label == label and row.datatype == datatype: + return row + raise KeyError(f"no observed cell at ({label!r}, {datatype!r})") + + def row_datatypes(self) -> np.ndarray: + """The data type of every row of the vector, ``(nd,)``.""" + return np.array([row.datatype for row in self.rows for _ in range(row.size)], dtype=object) + + # ------------------------------------------------------------------ + # Frame -> array + # ------------------------------------------------------------------ + def vector(self, frame) -> np.ndarray: + """The observed cells of ``frame`` as an ``(nd,)`` vector, in layout order.""" + out = np.empty(self.nd) + for row in self.rows: + out[row.rows] = np.ravel(np.asarray(frame.loc[row.label, row.datatype], dtype=float)) + return out + + def matrix(self, frame, ne) -> np.ndarray: + """The cells of an ensemble ``frame`` -- ``(ne,)`` or ``(size, ne)`` each -- as ``(nd, ne)``.""" + out = np.empty((self.nd, ne)) + for row in self.rows: + out[row.rows, :] = np.asarray(frame.loc[row.label, row.datatype], dtype=float).reshape(row.size, ne) + return out + + # ------------------------------------------------------------------ + # Array -> frame (the view) + # ------------------------------------------------------------------ + def to_frame(self, values, name=None) -> PETDataFrame: + """A frame view of ``values`` -- ``(nd,)`` or ``(nd, ne)`` -- with empty cells ``None``. + + Cells come out as the flatten expects them back: a scalar for a + one-row observation, a vector or an ``(size, ne)`` block otherwise. + """ + values = np.asarray(values) + frame = pd.DataFrame({datatype: [None] * len(self.labels) for datatype in self.datatypes}, + index=pd.Index(self.labels, name=self.label_name), dtype=object) + for row in self.rows: + block = values[row.rows] + if row.size == 1: + block = float(block[0]) if values.ndim == 1 else block[0] # a scalar, or its (ne,) ensemble + frame.at[row.label, row.datatype] = block + return PETDataFrame.from_pandas(frame, name=name, is_ensemble=values.ndim == 2) + + +def _gen_real_limits(limits, layer): + """Translate a prior's ``limits`` entry into what ``gen_real`` expects. + + Configs give ``limits`` as a single ``[lower, upper]`` pair -- the form + the update-step clipping and :func:`limit_state` also read -- while + ``gen_real`` wants a ``{'lower': ..., 'upper': ...}`` mapping. A per-layer + list of either form is accepted too, for a prior that bounds its layers + differently. + """ + if isinstance(limits, dict): + entry = limits + elif isinstance(limits[0], (list, tuple, dict)): + entry = limits[layer] + else: + entry = limits + if isinstance(entry, dict): + return entry + lower, upper = entry + return {'lower': lower, 'upper': upper} + + +@dataclass(frozen=True) +class StateLayout: + """Row ranges of the state variables in an ``(nx, ne)`` state matrix, in stacking order.""" + + indices: dict + + @property + def nx(self) -> int: + """Number of state rows.""" + return max((stop for _, stop in self.indices.values()), default=0) + + @property + def variables(self) -> tuple: + """Variable names in stacking order.""" + return tuple(self.indices) + + def rows(self, name) -> slice: + """The row slice of variable ``name``.""" + start, stop = self.indices[name] + return slice(start, stop) + + # ------------------------------------------------------------------ + # Constructors: a state matrix and its layout + # ------------------------------------------------------------------ + @classmethod + def from_dict(cls, member, ne=None): + """Stack ``{variable: (n, ne) array}`` into a state matrix; returns ``(matrix, layout)``. + + With ``ne`` given, only the first ``ne`` columns of each array are used. + """ + if len(member) == 0: + raise ValueError('member must not be empty') + running, indices, parts = 0, {}, [] + for key, values in member.items(): + values = np.asarray(values) if ne is None else np.asarray(values)[:, :int(ne)] + indices[key] = (running, running + values.shape[0]) + running += values.shape[0] + parts.append(values) + return np.concatenate(parts), cls(indices) + + @classmethod + def from_prior_info(cls, prior_info, ne, rng=None, save=True): + """Draw a prior ensemble from the prior description; returns ``(matrix, layout)``. + + Parameters + ---------- + prior_info : dict + Per variable: ``mean``, ``variance`` (per layer), the grid size + ``nx``/``ny``/``nz`` and, for fields, the covariance description. + ne : int + Number of members. + rng : RandomState-like, optional + The stream to draw from; the global one by default. + save : bool, optional + Write the prior to ``prior_ensemble.npz`` (default True). + """ + from geostat.decomp import Cholesky + + enX, idX = None, {} + for name, info in prior_info.items(): + mean = info['mean'] + var = info['variance'] + nx, ny, nz = info.get('nx', 0), info.get('ny', 0), info.get('nz', 0) + if nx == ny == 0: + break + + j = 0 + field = None + for z in range(nz): + if isinstance(mean, (list, np.ndarray)) and len(mean) > 1: + cov = Cholesky().gen_cov2d( + x_size=nx, y_size=ny, variance=var[z], var_range=info['corr_length'][z], + aspect=info['aniso'][z], angle=info['angle'][z], var_type=info['vario'][z], + ) + else: + cov = np.array(var[z]) + + i = j + j = int((z + 1) * (len(mean) / nz)) + meanz = mean[i:j] + + if info.get('limits', None) is None: + fieldz = gen_real(meanz, cov, ne, rng=rng) + else: + fieldz = gen_real(meanz, cov, ne, rng=rng, limits=_gen_real_limits(info['limits'], z)) + field = fieldz if field is None else np.vstack((field, fieldz)) + + if enX is None: + enX = field + idX[name] = (0, field.shape[0]) + else: + start = enX.shape[0] + enX = np.vstack((enX, field)) + idX[name] = (start, start + field.shape[0]) + + layout = cls(idX) + if save: + np.savez('prior_ensemble.npz', **layout.to_dict(enX)) + return enX, layout + + # ------------------------------------------------------------------ + # Conversions at the boundary + # ------------------------------------------------------------------ + def to_dict(self, matrix) -> dict: + """``{variable: rows}`` views of ``matrix``.""" + array = np.asarray(matrix) + return {key: array[start:stop] for key, (start, stop) in self.indices.items()} + + def member_dicts(self, matrix) -> list: + """One ``{variable: values}`` per member -- what a simulator takes.""" + array = np.asarray(matrix) + if array.ndim == 1: + array = array[:, np.newaxis] + slices = {key: array[start:stop] for key, (start, stop) in self.indices.items()} + return [{key: slices[key][:, n] for key in slices} for n in range(array.shape[1])] + + def clip(self, matrix, limits) -> None: + """Clip ``matrix`` in place to ``limits``. + + ``limits`` is a ``(lower, upper)`` pair for every variable, a + ``{variable: (lower, upper)}`` dict, or a list of pairs in stacking + order; ``None`` bounds are left open. + """ + array = np.asarray(matrix) + if isinstance(limits, tuple): + lb, ub = limits + if not (lb is None and ub is None): + np.clip(array, lb, ub, out=array) + elif isinstance(limits, dict): + for key, (i, j) in self.indices.items(): + if key in limits: + lb, ub = limits[key] + if not (lb is None and ub is None): + np.clip(array[i:j], lb, ub, out=array[i:j]) + elif isinstance(limits, list): + for (key, (i, j)), (lb, ub) in zip(self.indices.items(), limits): + if not (lb is None and ub is None): + np.clip(array[i:j], lb, ub, out=array[i:j]) + else: + raise ValueError("limits must be a tuple, dict, or list") diff --git a/src/misc/structures/predicted.py b/src/misc/structures/predicted.py new file mode 100644 index 00000000..5396df1e --- /dev/null +++ b/src/misc/structures/predicted.py @@ -0,0 +1,109 @@ +"""The predicted-data ensemble as the analyses use it: an ``(nd, ne)`` matrix in a layout's row order.""" + +from dataclasses import dataclass + +import numpy as np +import pandas as pd + +from misc.structures.layout import DataLayout + +__all__ = ["PredictedData", "member_cell"] + + +def member_cell(member, row, position): + """One member's value for one observed cell, from its records or its frame.""" + if isinstance(member, pd.DataFrame): + return member.loc[row.label, row.datatype] + where = row.label if position is None else position[row.label] + try: + record = member[where] + except (IndexError, TypeError) as exc: + raise ValueError( + f"no record at position {where!r} for label {row.label!r}: the simulator must report every " + f"observed label, and name the labels in `true_order` when they are not positions." + ) from exc + try: + return record[row.datatype] + except KeyError as exc: + raise KeyError(f"member output has no {row.datatype!r} at {row.label!r}") from exc + + +@dataclass +class PredictedData: + """Predictions for every observed cell, one column per member. + + Built straight from what each member's simulation returned, so its rows + are the layout's rows: the same rows the observation vector and its + variance have. The frame the older code passed around is available as a + view (:meth:`to_frame`) for saving and inspection. + """ + + matrix: np.ndarray + layout: DataLayout + + @property + def nd(self) -> int: + """Number of data rows.""" + return self.matrix.shape[0] + + @property + def ne(self) -> int: + """Number of members.""" + return self.matrix.shape[1] + + @classmethod + def from_members(cls, layout, members, position=None, scale=None, transform=None) -> "PredictedData": + """Fill the matrix from one output per member. + + Parameters + ---------- + members : sequence + One output per member: a list of records (one dict per report + point, keyed by data type) or a DataFrame indexed by label. + position : dict, optional + Where each observed label sits in a member's records. Omit when + the labels are the positions. + scale : (minimum, maximum), optional + Per-data-type max-min scaling to apply, as the observations were + scaled: ``(value - minimum) / (maximum - minimum)``. + transform : callable, optional + ``transform(row, values) -> values``, applied to a member's + (scaled) raw values before they enter the matrix -- how a + simulated seismic vintage becomes the wavelet coefficients the + observed one was reduced to. Its output must have ``row.size`` + values; the raw values need not. + """ + matrix = np.empty((layout.nd, len(members))) + minimum, maximum = scale if scale is not None else (None, None) + for j, member in enumerate(members): + for row in layout.rows: + values = np.ravel(np.asarray(member_cell(member, row, position), dtype=float)) + if scale is not None: + low = minimum[row.datatype] + values = (values - low) / (maximum[row.datatype] - low) + if transform is not None: + values = np.ravel(np.asarray(transform(row, values), dtype=float)) + if values.size != row.size: + raise ValueError( + f"member {j}: {row.datatype!r} at {row.label!r} has {values.size} values; " + f"the observation has {row.size}" + ) + matrix[row.rows, j] = values + return cls(matrix, layout) + + @classmethod + def from_frame(cls, layout, frame, ne) -> "PredictedData": + """From a prediction frame whose cells are ``(ne,)`` or ``(size, ne)`` arrays.""" + return cls(layout.matrix(frame, ne), layout) + + def to_frame(self, name=None): + """The frame view: one cell per observed label and data type.""" + return self.layout.to_frame(self.matrix, name=name) + + def take_members(self, index) -> "PredictedData": + """The predictions of the members ``index`` names, in that order.""" + return PredictedData(self.matrix[:, index], self.layout) + + def rows_of(self, datatype): + """The row slices holding ``datatype``, in layout order.""" + return [row.rows for row in self.layout.rows if row.datatype == datatype] diff --git a/src/misc/structures/structures.py b/src/misc/structures/structures.py new file mode 100644 index 00000000..5bcc9914 --- /dev/null +++ b/src/misc/structures/structures.py @@ -0,0 +1,248 @@ +""" +Core PET data structures. + +This module defines `PETDataFrame`, a pandas `DataFrame` subclass for +ensemble-style tabular data, and `PETStateArray`, a NumPy `ndarray` +subclass for state vectors with PET-specific indexing metadata. +""" + +import pandas as pd +import numpy as np + +from pandas._typing import Axes, Dtype + +__author__ = 'Mathias Methlie Nilsen' + +__all__ = ['PETDataFrame'] + + +class PETDataFrame(pd.DataFrame): + """ + Pandas DataFrame subclass that preserves all pandas behavior + while allowing project-specific custom methods. + """ + + # Custom attributes to preserve across pandas operations + _metadata = [ + 'name', 'is_ensemble', 'is_scaled', + 'scale_min', 'scale_max', 'scale_mean', 'scale_std' + ] + + @property + def _constructor(self): + # Ensures pandas ops (copy, loc filtering, arithmetic, etc.) + # return this subclass when possible. + return PETDataFrame + + def __init__( + self, + data=None, + index: Axes | None = None, + columns: Axes | None = None, + dtype: Dtype | None = None, + copy: bool | None = None, + name: str | None = None, + is_ensemble: bool = False, # Optional flag to indicate if this DataFrame is an ensemble + ) -> None: + + super().__init__(data=data, index=index, columns=columns, dtype=dtype, copy=copy) + self.name = name + self.is_ensemble = is_ensemble + self.is_scaled = False # Flag to track if the DataFrame has been scaled + + @classmethod + def from_pandas(cls, df: pd.DataFrame, name: str | None = None, is_ensemble: bool = False) -> "PETDataFrame": + """Create a PETDataFrame from an existing pd.DataFrame.""" + out = cls(data=df, name=name, is_ensemble=is_ensemble) + out.index.name = df.index.name + out.attrs = df.attrs.copy() + return out + + @classmethod + def from_pickle(cls, filepath: str) -> "PETDataFrame": + """Load a PETDataFrame from a pickle file.""" + df = pd.read_pickle(filepath) + df.where(pd.notnull(df), None) + if not isinstance(df, pd.DataFrame): + raise ValueError(f"Pickle file {filepath} does not contain a DataFrame.") + return cls.from_pandas(df) + + @classmethod + def from_csv(cls, filepath: str, **kwargs) -> "PETDataFrame": + """Load a PETDataFrame from a CSV file.""" + df = pd.read_csv(filepath, **kwargs) + df.where(pd.notnull(df), None) + return cls.from_pandas(df) + + @classmethod + def merge_dataframes(cls, dfs: list[pd.DataFrame]) -> "PETDataFrame": + ''' + Combine a list of DataFrames (one per ensemble member) into a single + PETDataFrame where each cell contains an array of ensemble values. + ''' + if len(dfs) == 0: + raise ValueError('dfs must contain at least one DataFrame.') + if not all(isinstance(df, pd.DataFrame) for df in dfs): + raise ValueError('All elements in dfs must be pandas DataFrames.') + + first = dfs[0] + for i, dfn in enumerate(dfs[1:], start=1): + if not dfn.index.equals(first.index): + raise ValueError(f'DataFrame at position {i} has a different index.') + if not dfn.columns.equals(first.columns): + raise ValueError(f'DataFrame at position {i} has different columns.') + + merged = pd.DataFrame(index=first.index, columns=first.columns, dtype=object) + merged.index.name = first.index.name + + for idx in merged.index: + for col in merged.columns: + values = [dfn.at[idx, col] for dfn in dfs] + merged.at[idx, col] = np.asarray(values).squeeze().T + + out = cls.from_pandas(merged, name=getattr(first, 'name', None), is_ensemble=True) + out.attrs = first.attrs.copy() + return out + + def filter_dataframe(self, index=None, columns=None) -> "PETDataFrame": + """Return a new PETDataFrame filtered to the specified columns and index.""" + filtered = self.copy() + if index is not None: + # Let .loc decide whether the labels are present: comparing dtypes + # rejects indices that select perfectly well (datetime.date labels + # against a DatetimeIndex, for instance). + try: + filtered = filtered.loc[index] + except KeyError as exc: + raise ValueError( + f"Provided index does not match DataFrame index: {exc}" + ) from exc + if columns is not None: + filtered = filtered.filter(items=columns) + + return filtered + + + def scale(self, type='max-min', **kwargs) -> None: + ''' + Scale each column of DataFrame using the specified method. + ''' + if type == 'max-min': + if self.is_scaled: + raise ValueError("DataFrame is already scaled, cannot apply max-min scaling again without inverting first.") + + self.is_scaled = True + self.scale_min = self.min() if kwargs.get('minimum', None) is None else kwargs.get('minimum') + self.scale_max = self.max() if kwargs.get('maximum', None) is None else kwargs.get('maximum') + scale_range = self.scale_max - self.scale_min + + if isinstance(self.columns, pd.MultiIndex) and (isinstance(self.scale_min, pd.Series) or isinstance(self.scale_max, pd.Series)): + self.loc[:, :] = self.sub(self.scale_min, axis='columns', level=0).div(scale_range, axis='columns', level=0) + else: + self.loc[:, :] = (self - self.scale_min) / scale_range + + elif type == 'z-score': + if self.is_scaled: + raise ValueError("DataFrame is already scaled, cannot apply z-score scaling again without inverting first.") + self.is_scaled = True + self.scale_mean = self.mean() if kwargs.get('mean', None) is None else kwargs.get('mean') + self.scale_std = self.std() if kwargs.get('std', None) is None else kwargs.get('std') + self.loc[:, :] = (self - self.scale_mean) / self.scale_std + + else: + raise ValueError(f"Unsupported scaling type: {type}") + + def invert_scale(self, type='max-min', **kwargs) -> None: + ''' + Invert the scaling transformation applied to the DataFrame. + ''' + if not self.is_scaled: + raise ValueError("DataFrame is not scaled, cannot invert scale.") + if type == 'max-min': + if not self.is_scaled: + raise ValueError("DataFrame is not scaled, cannot invert max-min scaling.") + scale_max = self.scale_max if kwargs.get('maximum', None) is None else kwargs.get('maximum') + scale_min = self.scale_min if kwargs.get('minimum', None) is None else kwargs.get('minimum') + scale_range = scale_max - scale_min + + if isinstance(self.columns, pd.MultiIndex) and (isinstance(scale_min, pd.Series) or isinstance(scale_max, pd.Series)): + self.loc[:, :] = self.mul(scale_range, axis='columns', level=0).add(scale_min, axis='columns', level=0) + else: + self.loc[:, :] = self * scale_range + scale_min + + self.is_scaled = False + + elif type == 'z-score': + if not self.is_scaled: + raise ValueError("DataFrame is not scaled, cannot invert z-score scaling.") + scale_mean = self.scale_mean if kwargs.get('mean', None) is None else kwargs.get('mean') + scale_std = self.scale_std if kwargs.get('std', None) is None else kwargs.get('std') + self.loc[:, :] = self * scale_std + scale_mean + self.is_scaled = False + else: + raise ValueError(f"Unsupported scaling type: {type}") + + + def to_series(self) -> pd.Series: + """Cells as a Series indexed by ``(label, datatype)``, label-major: the legacy flatten order.""" + mult_index = [] + for idx in self.index: + for col in self.columns: + mult_index.append((idx, col)) + mult_index = pd.MultiIndex.from_tuples(mult_index, names=[self.index.name, 'datatype']) + + values = [] + for idx in self.index: + for col in self.columns: + values.append(self.loc[idx, col]) + + return pd.Series(values, index=mult_index) + + + def to_matrix(self, filter=True, is_jacobian=False, squeeze=True) -> np.ndarray: + """Legacy flatten of the observed cells, label-major then type; ``misc.structures.DataLayout`` is the analysis path's equivalent.""" + + # If multi-index columns, convert to single-level first + if isinstance(self.columns, pd.MultiIndex): + df = self._to_singlelevel_columns() + else: + df = self + + arr = [] + for val in df.to_series().values: + if filter and not np.any(pd.notna(np.atleast_1d(val))): + continue + + if (not self.is_ensemble) and isinstance(val, np.ndarray) and (not is_jacobian): + arr.extend(val) + else: + arr.append(val) + + if is_jacobian: + arr = np.stack(arr, axis=0) + else: + arr = np.vstack(arr) + + return np.squeeze(arr) if squeeze else arr + + + def _to_singlelevel_columns(self) -> "PETDataFrame": + """ + Convert a MultiIndex-column DataFrame with structure (key, param) + into a DataFrame with one column per key, where the value is + the concatenation of all param-arrays for that key. + """ + result = {} + keys = pd.Index(self.columns.get_level_values(0)).unique() + + for key in keys: + param_arrays = self[key] + concatenated = [ + np.concatenate(param_arrays.iloc[i].values) + for i in range(len(self)) + ] + result[key] = concatenated + + df_new = PETDataFrame(result, index=self.index) + df_new.index.name = self.index.name + return df_new diff --git a/src/misc/system_tools/environ_var.py b/src/misc/system_tools/environ_var.py index bc2f0419..1b93fc33 100644 --- a/src/misc/system_tools/environ_var.py +++ b/src/misc/system_tools/environ_var.py @@ -104,7 +104,7 @@ def __exit__(self, exc_typ, exc_val, exc_trb): if len(self.num_threads): os.environ['OMP_NUM_THREADS'] = self.num_threads else: - os.environ.unsetenv('OMP_NUM_THREADS') + os.environ.pop('OMP_NUM_THREADS', None) # Reset Process context ctx._default_context = self.ctx @@ -230,15 +230,15 @@ def __exit__(self, exc_typ, exc_val, exc_trb): if len(self.path): os.environ['PATH'] = self.path else: - os.environ.unsetenv('PATH') + os.environ.pop('PATH', None) if len(self.ld_path): os.environ['LD_LIBRARY_PATH'] = self.ld_path else: - os.environ.unsetenv('LD_LIBRARY_PATH') + os.environ.pop('LD_LIBRARY_PATH', None) # We unset the CMG license server path - os.environ.unsetenv('CMG_LIC_HOST') + os.environ.pop('CMG_LIC_HOST', None) # Reset Process context ctx._default_context = self.ctx @@ -265,7 +265,7 @@ def __init__(self, filename, suffix, matchstring): """ self.filename = filename self.suffix = suffix - if type(matchstring) != list: + if not isinstance(matchstring, list): self.mstring = list(matchstring) else: self.mstring = matchstring @@ -318,7 +318,7 @@ def __exit__(self, exc_typ, exc_val, exc_trb): # TODO: not do time.sleep() # time.sleep(0.1) member = True - if member == False: + if not member: return False return True @@ -388,7 +388,7 @@ def __exit__(self, exc_typ, exc_val, exc_trb): if self.filename.split(os.sep)[1] in os.listdir(self.filename.split(os.sep)[0]): member = True - if member == False: + if not member: sys.exit(1) return False @@ -471,4 +471,4 @@ def __exit__(self, exc_typ, exc_val, exc_trb): sys.exit(1) # Return False (exit 0?) - return False \ No newline at end of file + return False diff --git a/src/pet_cli/__init__.py b/src/pet_cli/__init__.py new file mode 100644 index 00000000..208caeec --- /dev/null +++ b/src/pet_cli/__init__.py @@ -0,0 +1 @@ +"""Command-line entry point for the Python Ensemble Toolbox (PET).""" diff --git a/src/pet_cli/__main__.py b/src/pet_cli/__main__.py new file mode 100644 index 00000000..1cf16fed --- /dev/null +++ b/src/pet_cli/__main__.py @@ -0,0 +1,149 @@ +""" +Command-line interface for PET (Python Ensemble Toolbox). + +This CLI does not run simulations itself -- forward simulators and cost +functions are user-supplied Python code and must be wired up in a driver +script (see the PIPT/POPT tutorials). Instead, it covers the parts of a +PET workflow that are purely about configuration files: + + pet validate CONFIG check a config file for missing/invalid keys + pet convert CONFIG --to FMT convert a legacy .pipt/.popt file to toml/yaml + pet migrate CONFIG update a config file to the current schema + pet version print the installed PET version +""" +from __future__ import annotations + +import argparse +import sys +from importlib.metadata import PackageNotFoundError, version as pkg_version +from pathlib import Path + +from input_output import config, read_config +from pet_cli.migrate import migrate_config + + +def _cmd_version(_args: argparse.Namespace) -> int: + try: + print(pkg_version("PET")) + except PackageNotFoundError: + print("PET (version unknown - not installed as a package)") + return 0 + + +def _cmd_validate(args: argparse.Namespace) -> int: + config_file = args.config_file + if not Path(config_file).is_file(): + print(f"error: no such file: {config_file}", file=sys.stderr) + return 1 + + try: + sections = read_config.read(config_file) + except Exception as err: # noqa: BLE001 - report any parse failure to the user + print(f"error: failed to parse '{config_file}': {err}", file=sys.stderr) + return 1 + + names = ["dataassim/optim", "fwdsim", "ensemble"] + print(f"Parsed '{config_file}' successfully:") + for name, section in zip(names, sections): + count = len(section) if section else 0 + print(f" [{name}] {count} keyword(s)") + + cfg_prb, cfg_sim, cfg_ens = sections + problems = config.validate(cfg_prb, cfg_sim, cfg_ens) + unknown = config.unknown_keys(cfg_prb, cfg_ens) + if unknown: + print("\nKeys nothing in PET reads (check the spelling):") + for key in unknown: + print(f" - {key}") + if problems: + print("\nProblems found:") + for problem in problems: + print(f" - {problem}") + return 1 + print("\nNo problems found.") + return 0 + + +def _cmd_convert(args: argparse.Namespace) -> int: + config_file = args.config_file + if not Path(config_file).is_file(): + print(f"error: no such file: {config_file}", file=sys.stderr) + return 1 + + try: + if args.to == "toml": + read_config.convert_txt_to_toml(config_file) + else: + read_config.convert_txt_to_yaml(config_file) + except Exception as err: # noqa: BLE001 - report any conversion failure to the user + print(f"error: failed to convert '{config_file}': {err}", file=sys.stderr) + return 1 + + new_file = read_config.change_file_extension(config_file, args.to) + print(f"Wrote '{new_file}'") + return 0 + + +def _cmd_migrate(args: argparse.Namespace) -> int: + config_file = args.config_file + if not Path(config_file).is_file(): + print(f"error: no such file: {config_file}", file=sys.stderr) + return 1 + + try: + report = migrate_config( + config_file, dry_run=args.dry_run, backup=not args.no_backup + ) + except Exception as err: # noqa: BLE001 - report any migration failure to the user + print(f"error: failed to migrate '{config_file}': {err}", file=sys.stderr) + return 1 + + if not report.changed: + print(f"'{config_file}' is already on the current schema; nothing to do.") + if report.warnings: + print(report) + return 0 + + verb = "Would apply" if args.dry_run else "Applied" + print(f"{verb} the following changes to '{config_file}':") + print(report) + if not args.dry_run and not args.no_backup: + print(f"Original kept as '{config_file}.bak'") + return 0 + + +def build_parser() -> argparse.ArgumentParser: + """The ``pet`` argument parser: ``validate``, ``convert``, ``migrate``, ``version``.""" + parser = argparse.ArgumentParser(prog="pet", description=__doc__.strip().splitlines()[0]) + subparsers = parser.add_subparsers(dest="command", required=True) + + validate = subparsers.add_parser("validate", help="check a config file for missing/invalid keys") + validate.add_argument("config_file", help="path to a .toml, .yaml, .pipt, or .popt config file") + validate.set_defaults(func=_cmd_validate) + + convert = subparsers.add_parser("convert", help="convert a legacy .pipt/.popt config file") + convert.add_argument("config_file", help="path to a .pipt or .popt config file") + convert.add_argument("--to", choices=["toml", "yaml"], default="toml", help="output format (default: toml)") + convert.set_defaults(func=_cmd_convert) + + migrate = subparsers.add_parser("migrate", help="update a config file to the current schema") + migrate.add_argument("config_file", help="path to a .toml or .yaml config file") + migrate.add_argument("--dry-run", action="store_true", help="report changes without writing") + migrate.add_argument("--no-backup", action="store_true", help="do not keep a .bak copy") + migrate.set_defaults(func=_cmd_migrate) + + version = subparsers.add_parser("version", help="print the installed PET version") + version.set_defaults(func=_cmd_version) + + return parser + + +def main(argv: list[str] | None = None) -> int: + """Entry point of the ``pet`` command; returns the exit code.""" + parser = build_parser() + args = parser.parse_args(argv) + return args.func(args) + + +if __name__ == "__main__": + raise SystemExit(main()) diff --git a/src/pet_cli/migrate.py b/src/pet_cli/migrate.py new file mode 100644 index 00000000..6bc33e16 --- /dev/null +++ b/src/pet_cli/migrate.py @@ -0,0 +1,301 @@ +"""Migrate legacy PET config files to the current schema. + +Two changes are handled. + +The two-element ``daalg`` key, which packed an assimilation family and an +update method into a list, is replaced by a single ``scheme`` key naming the +algorithm:: + + daalg = ["esmda", "esmda"] -> scheme = "esmda" + +The second element was the one that actually selected the class, so that is +what carries over. Where the two elements disagree the second still wins, and +the migration reports it so the change is visible rather than silent. + +``analysisdebug`` is renamed to ``savedata``, matching popt and describing +what the key does -- it names the variables recorded each iteration, which is +a record of the run rather than a debugging aid:: + + analysisdebug = [...] -> savedata = [...] + +The old spelling still works at runtime, with a deprecation warning, so this +one is a tidy-up rather than a required migration. The *output files* did +change name, from ``debug_analysis_step_{i}.npz`` to +``assimilation_result_{i}.npz``, which no config rewrite can paper over: any +post-processing that globs the old pattern needs updating by hand. + +Formatting is preserved. The rewrite is a surgical edit of the ``daalg`` +assignment itself, not a parse-and-redump of the file, because a round trip +through a TOML/YAML writer discards everything that is not data: comments, +commented-out alternative blocks, indentation, inline tables, quote style and +list layout. Real PET configs carry all of those -- a commented-out +localization block that gets toggled against the active one is a common +pattern, and silently deleting it would be unacceptable. + +If the surgical edit cannot find the assignment (an unusual layout), the +migration falls back to the round trip and warns that formatting will be lost, +rather than failing or destroying the file silently. +""" + +from __future__ import annotations + +import re + +import shutil +from pathlib import Path + +import tomli +import tomli_w +import yaml + +__all__ = ["migrate_config", "migrate_section", "MigrationReport"] + +_DA_SECTIONS = ("dataassim", "optim") + +#: Keys renamed with their value untouched, ``old -> new``. +_RENAMED_KEYS = {"analysisdebug": "savedata"} + + +class MigrationReport: + """What a migration changed, or would change.""" + + def __init__(self) -> None: + self.changes: list[str] = [] + self.warnings: list[str] = [] + + @property + def changed(self) -> bool: + """Whether the migration changed anything.""" + return bool(self.changes) + + def __str__(self) -> str: + lines = [f" - {c}" for c in self.changes] + lines += [f" ! {w}" for w in self.warnings] + return "\n".join(lines) + + +def migrate_section(section: dict, report: MigrationReport) -> dict: + """Migrate one config section in place, recording what changed.""" + for old, new in _RENAMED_KEYS.items(): + if old not in section: + continue + if new in section: + report.warnings.append( + f"Section already has '{new}'; left the deprecated '{old}' in " + f"place rather than guessing which one you meant." + ) + continue + section[new] = section.pop(old) + report.changes.append(f"{old} -> {new}") + + if "daalg" not in section: + return section + + daalg = section.pop("daalg") + + if isinstance(daalg, str): + scheme = daalg + elif isinstance(daalg, (list, tuple)) and daalg: + scheme = daalg[-1] + if len(daalg) == 2 and daalg[0] != daalg[1]: + report.warnings.append( + f"daalg was {list(daalg)!r} with differing entries; " + f"kept {scheme!r}, which is the one that selected the class." + ) + elif len(daalg) > 2: + report.warnings.append( + f"daalg had {len(daalg)} entries {list(daalg)!r}; kept {scheme!r}." + ) + else: + report.warnings.append( + f"daalg had unexpected value {daalg!r}; left the file unchanged." + ) + section["daalg"] = daalg + return section + + section["scheme"] = scheme + report.changes.append(f"daalg = {daalg!r} -> scheme = {scheme!r}") + + if "analysis" not in section: + report.warnings.append( + "No 'analysis' key found; add one to select the analysis flavour " + "(e.g. analysis = 'approx')." + ) + + return section + + +#: ``daalg`` assignment in TOML: `daalg = [...]`, `daalg = "x"`, `daalg = 'x'`. +#: The list alternative is non-greedy so it also matches a multi-line list. +_TOML_DAALG = re.compile( + r"^(?P[^\S\n]*)daalg(?P
[^\S\n]*)=(?P[^\S\n]*)"
+    r"(?P\[[\s\S]*?\]|\"[^\"\n]*\"|'[^'\n]*')"
+    r"(?P[^\n]*)$",
+    re.MULTILINE,
+)
+
+#: Same for YAML inline form: `daalg: [a, b]` or `daalg: x`.
+_YAML_DAALG = re.compile(
+    r"^(?P[^\S\n]*)daalg(?P
[^\S\n]*):(?P[^\S\n]*)"
+    r"(?P\[[^\]\n]*\]|[^\n#]+?)"
+    r"(?P[^\n]*)$",
+    re.MULTILINE,
+)
+
+
+def _replace_daalg_in_text(text: str, fmt: str, scheme: str):
+    """Replace the ``daalg`` assignment in place, leaving the rest untouched.
+
+    Returns ``(new_text, count)``. A count of 0 means the assignment could not
+    be located and the caller should fall back to a full rewrite.
+    """
+    pattern = _TOML_DAALG if fmt == "toml" else _YAML_DAALG
+    separator = "=" if fmt == "toml" else ":"
+
+    def substitute(match):
+        # "scheme" is one character longer than "daalg", so drop one space of
+        # padding to keep a hand-aligned "=" column lined up. A single space
+        # is left alone -- that is normal spacing, not alignment.
+        pre = match.group("pre")
+        if len(pre) > 1:
+            pre = pre[:-1]
+        return (
+            f"{match.group('indent')}scheme{pre}{separator}"
+            f"{match.group('post')}\"{scheme}\"{match.group('trail')}"
+        )
+
+    new_text, count = pattern.subn(substitute, text)
+    return new_text, count
+
+
+def _rename_key_in_text(text: str, fmt: str, old: str, new: str):
+    """Rewrite an assignment's *key*, leaving its value and layout alone.
+
+    Simpler than :func:`_replace_daalg_in_text` because only the name on the
+    left of the separator moves; the value can be a multi-line list, an inline
+    table or anything else and never has to be understood.
+
+    Returns ``(new_text, count)``.
+    """
+    separator = "=" if fmt == "toml" else ":"
+    pattern = re.compile(
+        rf"^(?P[^\S\n]*){re.escape(old)}(?P
[^\S\n]*){re.escape(separator)}",
+        re.MULTILINE,
+    )
+
+    def substitute(match):
+        # Keep a hand-aligned separator column: absorb the length difference
+        # into the padding when there is padding to absorb.
+        pre = match.group("pre")
+        if len(pre) > 1:
+            pre = pre[: max(1, len(pre) - (len(new) - len(old)))]
+        return f"{match.group('indent')}{new}{pre}{separator}"
+
+    return pattern.subn(substitute, text)
+
+
+def _load(path: Path):
+    suffix = path.suffix.lower()
+    if suffix == ".toml":
+        with open(path, "rb") as handle:
+            return tomli.load(handle), "toml"
+    if suffix in (".yaml", ".yml"):
+        with open(path) as handle:
+            return yaml.safe_load(handle), "yaml"
+    raise ValueError(
+        f"Cannot migrate '{path}': only .toml and .yaml/.yml are supported. "
+        f"Convert legacy .pipt/.popt files first with `pet convert`."
+    )
+
+
+def _dump(config: dict, path: Path, fmt: str) -> None:
+    if fmt == "toml":
+        with open(path, "wb") as handle:
+            tomli_w.dump(config, handle)
+    else:
+        with open(path, "w") as handle:
+            yaml.safe_dump(config, handle, sort_keys=False)
+
+
+def migrate_config(path, *, dry_run: bool = False, backup: bool = True) -> MigrationReport:
+    """Migrate a config file to the current schema.
+
+    Parameters
+    ----------
+    path : str or Path
+        Path to a ``.toml`` or ``.yaml`` config file.
+    dry_run : bool, optional
+        Report what would change without writing anything.
+    backup : bool, optional
+        Keep the original alongside the migrated file as ``.bak``.
+
+    Returns
+    -------
+    MigrationReport
+    """
+    path = Path(path)
+    config, fmt = _load(path)
+    report = MigrationReport()
+
+    if not isinstance(config, dict):
+        raise ValueError(f"'{path}' does not contain a mapping at the top level.")
+
+    # Parse first: the parsed value is the reliable source for *what* the new
+    # scheme should be, and for the ambiguity warnings.
+    schemes = []
+    renames = []
+    for name in _DA_SECTIONS:
+        section = config.get(name)
+        if not isinstance(section, dict):
+            continue
+        had_daalg = "daalg" in section
+        present = [old for old in _RENAMED_KEYS if old in section]
+        if not had_daalg and not present:
+            continue
+
+        before = len(report.changes)
+        migrate_section(section, report)
+        if len(report.changes) == before:
+            continue
+        if had_daalg and "scheme" in section:
+            schemes.append(section["scheme"])
+        renames += [(old, _RENAMED_KEYS[old]) for old in present if _RENAMED_KEYS[old] in section]
+
+    if not report.changed or dry_run:
+        return report
+
+    # Write via a surgical text edit so comments, commented-out blocks,
+    # indentation, inline tables and quote style all survive.
+    original = path.read_text()
+    new_text = original
+    surgical = True
+
+    if schemes:
+        if len(schemes) == 1:
+            new_text, count = _replace_daalg_in_text(new_text, fmt, schemes[0])
+            surgical = surgical and count == 1
+        else:
+            # Several sections carry a daalg; one substitution cannot serve both.
+            surgical = False
+
+    for old, new in renames:
+        new_text, count = _rename_key_in_text(new_text, fmt, old, new)
+        surgical = surgical and count > 0
+
+    if backup:
+        shutil.copy2(path, path.with_suffix(path.suffix + ".bak"))
+
+    if surgical:
+        path.write_text(new_text)
+    else:
+        # Unusual layout (or several sections): fall back to a full rewrite,
+        # but say so -- this is the path that loses comments.
+        report.warnings.append(
+            "Could not edit every changed line in place, so the file was "
+            "rewritten from its parsed contents. Comments, commented-out "
+            "blocks and original formatting have been lost; the previous "
+            "version is in the .bak file."
+        )
+        _dump(config, path, fmt)
+
+    return report
diff --git a/src/pipt/__init__.py b/src/pipt/__init__.py
index 48cb2ed7..9362354a 100644
--- a/src/pipt/__init__.py
+++ b/src/pipt/__init__.py
@@ -9,3 +9,26 @@
 # import sys
 # from #replacement_package import #replacement_submodule
 # sys.modules["pipt.#module.#submodule"] = #replacement_submodule
+
+from pipt.update_schemes.factory import build_scheme  # noqa: E402
+from pipt.update_schemes.enkf import EnKF  # noqa: E402
+from pipt.update_schemes.enrml import GNEnRML, LMEnRML  # noqa: E402
+from pipt.update_schemes.es import ES  # noqa: E402
+from pipt.update_schemes.esmda import ESMDA  # noqa: E402
+from pipt.update_schemes.registry import (  # noqa: E402
+    available_schemes,
+    get_scheme,
+    register_scheme,
+)
+
+__all__ = [
+    "EnKF",
+    "ES",
+    "ESMDA",
+    "LMEnRML",
+    "GNEnRML",
+    "build_scheme",
+    "available_schemes",
+    "get_scheme",
+    "register_scheme",
+]
diff --git a/src/pipt/ensembles/__init__.py b/src/pipt/ensembles/__init__.py
new file mode 100644
index 00000000..421dc679
--- /dev/null
+++ b/src/pipt/ensembles/__init__.py
@@ -0,0 +1,19 @@
+"""Ensemble containers for data assimilation.
+
+Mirrors the layout of :mod:`popt.ensembles`.
+"""
+
+from .ensemble_base import AssimilationEnsemble
+from .forecast import ForecastMixin, OutlierMixin
+from .local_analysis import LocalAnalysisMixin
+
+#: Historical name, kept so existing code and subclasses keep working.
+Ensemble = AssimilationEnsemble
+
+__all__ = [
+    "AssimilationEnsemble",
+    "Ensemble",
+    "ForecastMixin",
+    "OutlierMixin",
+    "LocalAnalysisMixin",
+]
diff --git a/src/pipt/ensembles/ensemble_base.py b/src/pipt/ensembles/ensemble_base.py
new file mode 100644
index 00000000..199a6535
--- /dev/null
+++ b/src/pipt/ensembles/ensemble_base.py
@@ -0,0 +1,331 @@
+"""Ensemble container for ensemble-based data assimilation.
+
+The PIPT counterpart to :mod:`popt.ensembles.ensemble_base`: holds the state
+realisations, observed data, localization and forward simulator for an
+assimilation run.
+
+Previously ``pipt.loop.ensemble.Ensemble``; that module has been removed.
+"""
+
+import os.path
+
+import numpy as np
+from scipy.linalg import cholesky
+from misc.sampling import gen_real
+from misc.structures import DataLayout
+from input_output.config import ConfigError, fatal_problems, normalize_dataassim, normalize_ensemble
+
+from ensemble import BaseEnsemble, NullLogger, PetLogger
+import misc.read_input_csv as rcsv
+from pipt.localization import build_localization_instance
+import pipt.misc_tools.analysis_tools as at
+import pipt.misc_tools.extract_tools as extract
+
+from pipt.ensembles.forecast import ForecastMixin, OutlierMixin
+from pipt.ensembles.local_analysis import LocalAnalysisMixin
+
+__all__ = ["AssimilationEnsemble"]
+
+
+class NoLocalization:
+    """Stands in for a localization when the config asks for none.
+
+    Analyses branch on ``localization.name``; ``None`` means no localization.
+    A module-level class rather than an anonymous one so the ensemble that
+    holds it can be pickled -- ``emergency_dump`` and the restart file both
+    pickle the ensemble, and an anonymous class made that fail exactly when
+    a run had crashed.
+    """
+
+    name = None
+
+
+class AssimilationEnsemble(ForecastMixin, OutlierMixin, LocalAnalysisMixin, BaseEnsemble):
+    """
+    Class for organizing/initializing misc. variables and simulator for an
+    ensemble-based inversion run. Inherits the PET ensemble structure
+    """
+
+    def __init__(self, keys_da, keys_en, sim):
+        """
+        Parameters
+        ----------
+        keys_da : dict
+            Options for the data assimilation class
+
+            - scheme: name of the assimilation algorithm (e.g., "esmda", "lmenrml", "gnenrml")
+            - analysis: update flavour ("approx", "full" or "subspace")
+            - energy: percent of singular values kept after SVD
+            - obsvarsave: save the observations as a file (default false)
+            - restart, restartsave, restart_file: checkpointing, read by the scheme (see
+              ``pipt.update_schemes.core.restart_options``); the ensemble contributes
+              ``restart_state()`` to the checkpoint.
+            - savedata: names of scheme attributes to write to one file per
+              iteration, ``assimilation_result_{i}.npz``. Iteration 0 is the
+              prior. ``"state"`` expands to one array per state variable;
+              anything else is looked up on the scheme and then on the
+              ensemble, so e.g. ``"ensemble_misfit"``, ``"pred_data"``,
+              ``"data_misfit"`` and ``"lam"`` all resolve. A name that resolves
+              nowhere is reported and skipped. Omitting the key disables the
+              saving, so there is no separate on/off switch.
+              (Was ``analysisdebug``, still honoured with a warning.)
+            - savefolder (or save_folder): where run artifacts go
+              (default ``Results``)
+            - logit: enable run logging (default true). When false, no log
+              file is created and self.logger(...) calls become no-ops.
+            - logger_name: log file name (default ``ASSIM.log``)
+            - nosave: present in the config disables artifact saving entirely
+            - truedataindex: order of the simulated data (for timeseries this is points in time)
+            - obsname: unit for truedataindex (for timeseries this is days or hours or seconds, etc.)
+            - truedata: the data, e.g., provided as a .csv file
+            - assimindex: index for the data that will be used for assimilation
+            - datatype: list with the name of the datatypes
+            - staticvar: name of the static variables
+            - dynamicvar: name of the dynamic variables
+            - datavar: data variance, e.g., provided as a .csv file
+
+        keys_en : dict
+            Options for the ensemble class
+
+            - ne: number of perturbations used to compute the gradient
+            - state: name of state variables passed to the .mako file
+            - prior_: the prior information the state variables, including mean, variance and variable limits
+
+            NB: If keys_en is empty dict, it is assumed that the prior info is contained in keys_da.
+            The merged dict keys_da|keys_en is what is sent to the parent class.
+
+        sim : callable
+            The forward simulator (e.g. flow)
+        """
+
+
+        # Canonical copies of both sections; what is missing is reported here,
+        # by key, rather than as a KeyError somewhere inside the run.
+        keys_da = normalize_dataassim(keys_da)
+        keys_en = normalize_ensemble(keys_en)
+        problems = fatal_problems(keys_da, None, keys_en)
+        if problems:
+            raise ConfigError("the config cannot run:\n  " + "\n  ".join(str(p) for p in problems))
+
+        # do the initiallization of the PETensemble
+        super().__init__(keys_da | keys_en, sim)
+
+        # Setup logger. logit=False replaces it with a no-op so every scheme's
+        # unconditional self.logger(...) calls stay valid without a file being
+        # created.
+        if keys_da.get('logit', True):
+            self.logger = PetLogger(filename=keys_da.get('logger_name', 'ASSIM.log'))
+        else:
+            self.logger = NullLogger()
+        self.logger(f'=========== Running Data Assimilation - {keys_da["scheme"].upper()} ===========')
+
+        # Internalize PIPT dictionary
+        if not hasattr(self, 'keys_da'):
+            self.keys_da = keys_da
+        if not hasattr(self, 'keys_en'):
+            self.keys_en = keys_en
+
+        # Init in _init_prediction_output (used in run_prediction)
+        self.prediction = None
+        self.temp_state = None  # temporary state saving
+        self.cov_prior = None  # Prior cov. matrix
+        self.sparse_info = None  # Init in _org_sparse_representation
+        self.sparse_data = []  # List of the compression info
+        self.data_rec = []  # List of reconstructed data
+        self.scale_val = None  # Use to scale data
+
+        # Prepare sparse representation
+        if 'compress' in self.keys_da:
+            self.sparse_info = extract.organize_sparse_representation(self.keys_da['compress'])
+            if self.sparse_info.get('use_ensemble'):
+                # The option meant: widen the leading wavelet indices with the first
+                # forecast, then compress the observations with them. Observations are
+                # perturbed when the scheme is built, before any forecast exists, so the
+                # raw observation vector and the compressed-length variance the reader
+                # produced for this option could never be used together.
+                raise ValueError(
+                    "'use_ensemble' in the compress section is not supported: observations are "
+                    "perturbed when the scheme is built, before a forecast exists to widen the "
+                    "leading indices with. Set use_ensemble to no."
+                )
+        else:
+            self.sparse_info = None
+
+        # Load the data
+        reader = rcsv.DataReader(self.keys_da, sparse_info=self.sparse_info)
+        self.data_df = reader.get_data()
+        self.sparse_data = reader.sparse_data
+        self.data_var_df = reader.get_variance(self.data_df, reader.sparse_data)
+
+        if self.keys_da.get('scale_data', False):
+            self.data_df.scale('max-min')
+
+            if self.keys_da.get('emp_cov', False):
+                self.data_var_df.scale('max-min',
+                        minimum=self.data_df.scale_min,
+                        maximum=self.data_df.scale_max,
+                )
+            else:
+                self.data_var_df.scale('max-min',
+                        minimum=0,
+                        maximum=(self.data_df.scale_max - self.data_df.scale_min)**2
+                )
+
+        # The order every data matrix uses, and the observations in it. Built
+        # after scaling, so the vector holds what the analyses compare against.
+        self.data_layout = DataLayout.from_frame(self.data_df)
+        self.obs_vector = self.data_layout.vector(self.data_df)
+        self.obs_variance = self._observation_variance()
+
+        self.keys_da['datatype'] = reader.datatype
+        self.keys_da['truedataindex'] = reader.truedataindex
+        self.keys_da['assimindex'] = reader.assimindex
+
+        #self._org_obs_data() # Depricated!!
+        #self._org_data_var() # Depricated!!
+
+        # Define projection operator for centring and scaling ensemble matrix
+        self.proj = (np.eye(self.ne) - np.ones((self.ne, self.ne))/self.ne) / np.sqrt(self.ne - 1)
+
+        # Option to store the dictionaries containing observed data and data variance
+        if extract.is_enabled(self.keys_da.get('obsvarsave', False)):
+            # Save data_df and data_var_df as pickle files
+            folder = self.keys_da.get('savefolder', './')
+            # Check if folder exists, if not create it
+            if not os.path.exists(folder):
+                os.makedirs(folder)
+            self.data_df.to_pickle(f'{folder}/obs_data.pkl')
+            self.data_var_df.to_pickle(f'{folder}/obs_var.pkl')
+
+        # Initialize localization
+        if 'localization' in self.keys_da:
+            self.localization = build_localization_instance(
+                self.keys_da['localization'],
+                self.keys_da['truedataindex'],
+                self.keys_da['datatype'],
+                self.keys_en['state'],
+                self.ne,
+                data=self.data_df,
+                prior_info=self.prior_info,
+                rng=self.rng,
+            )
+        else:
+            self.localization = NoLocalization()
+
+        # Initialize local analysis
+        if 'localanalysis' in self.keys_da:
+            self.local_analysis = extract.extract_local_analysis_info(self.keys_da['localanalysis'], self.idX.keys())
+
+        self.pred_data  = None  # predicted data or forward simulation
+        self.cell_index = None  # default value for extracting states
+
+    def check_assimindex_simultaneous(self):
+        """
+        Check if assim. indices is given as a 1D list as is needed in simultaneous updating. If not, make it a 2D list
+        with one row.
+        """
+        # Check if ASSIMINDEX is a list. If not, make it a 2D list with one row
+        if not isinstance(self.keys_da['assimindex'], list):
+            self.keys_da['assimindex'] = [[self.keys_da['assimindex']]]
+
+        # Check if ASSIMINDEX is a 1D list. If true, make it a 2D list with one row
+        elif not isinstance(self.keys_da['assimindex'][0], list):
+            self.keys_da['assimindex'] = [self.keys_da['assimindex']]
+
+        # If ASSIMINDEX is a 2D list, we reshape it to a 2D list with one row
+        elif isinstance(self.keys_da['assimindex'][0], list):
+            self.keys_da['assimindex'] = [
+                [item for sublist in self.keys_da['assimindex'] for item in sublist]]
+
+    # ------------------------------------------------------------------
+    # Checkpointing (the scheme's RestartMixin calls these)
+    # ------------------------------------------------------------------
+    RESTART_ATTRIBUTES = ('enX', 'prior_enX', 'pred_data', 'member_outputs', 'member_adjoints', 'adjoints',
+                          'scale_data', 'Am', 'proj', 'iteration',
+                          'sparse_data', 'scale_val')
+    """What a resume must restore on the ensemble: what iterations change (the
+    state, its forecast), and what construction drew or derived from a draw
+    (the prior, the observation scaling, the scaled prior's SVD), so a resumed
+    run continues the interrupted one whatever the random state was when the
+    resuming process built its ensemble."""
+
+    def restart_state(self) -> dict:
+        """What a checkpoint carries for this ensemble: ``RESTART_ATTRIBUTES`` plus the random stream's state."""
+        state = {name: getattr(self, name) for name in self.RESTART_ATTRIBUTES if hasattr(self, name)}
+        state['rng_state'] = self.rng.get_state()
+        return state
+
+    def restore_restart_state(self, state: dict) -> None:
+        """Overlay a checkpoint's ensemble state and mark the ensemble as resumed."""
+        state = dict(state)
+        self.rng.set_state(state.pop('rng_state'))
+        for name, value in state.items():
+            setattr(self, name, value)
+        self.restart = True
+
+    def _observation_variance(self):
+        """The observation variances in layout order: ``(nd,)``, or ``(nd, ne)`` for an empirical error ensemble.
+
+        A variance that is NaN for an observed cell is an error here. It used
+        to be dropped when the covariance was assembled, which left the
+        covariance one entry shorter than the observation vector.
+        """
+        if self.data_var_df.is_ensemble:
+            variance = self.data_layout.matrix(self.data_var_df, self.ne)
+        else:
+            variance = self.data_layout.vector(self.data_var_df)
+        if np.isnan(variance).any():
+            bad = [(row.label, row.datatype) for row in self.data_layout.rows
+                   if np.isnan(np.atleast_1d(variance[row.rows])).any()]
+            raise ValueError(f"the data variance is NaN for observed cells {bad!r}")
+        return variance
+
+    def perturb_observations(self, vecObs):
+        '''
+        Generate the perturbed observed data ensemble
+        '''
+        if extract.is_enabled(self.keys_da.get('screendata', False)):
+            # Screening inflates the variance of data the ensemble cannot reach,
+            # which needs predictions -- and observations are perturbed when the
+            # scheme is built, before any forecast has run. The old calls below
+            # this point could never work (wrong arity, an `enPred` the ensemble
+            # never had), so say so instead of failing on an attribute.
+            raise ValueError(
+                "'screendata' is not supported: observations are perturbed when the "
+                "scheme is built, before any prediction exists to screen them against. "
+                "Remove the option from the dataassim section."
+            )
+
+        # Generate ensemble of perturbed observed data
+        if extract.is_enabled(self.keys_da.get('emp_cov', False)):
+            if hasattr(self, 'cov_data'):  # cd matrix has been imported
+                # enObs: samples from N(0,Cd)
+                enObs = cholesky(self.cov_data).T @ self.rng.randn(self.cov_data.shape[0], self.ne)
+            else:
+                enObs = self.obs_variance   # (nd, ne): the empirical error ensemble
+
+            # Center the ensemble of perturbed observed data
+            # enObs = vecObs[:, np.newaxis] - enObs
+            self.cov_data = np.var(enObs, ddof=1, axis=1)
+            self.scale_data = np.sqrt(self.cov_data)
+
+        else:
+            if not hasattr(self, 'cov_data'):  # if cd is not loaded
+                self.cov_data = self.obs_variance
+
+            enObs, self.scale_data = gen_real(
+                mean = vecObs,
+                var = self.cov_data,
+                number = self.ne,
+                rng = self.rng,
+                return_chol = True
+            )
+
+        return enObs
+
+    def _ext_scaling(self):
+        # get vector of scaling
+        self.state_scaling = at.calc_scaling(
+            self.prior_enX, self.idX, self.prior_info)
+
+        self.Am = None
diff --git a/src/pipt/ensembles/forecast.py b/src/pipt/ensembles/forecast.py
new file mode 100644
index 00000000..6a3dbde6
--- /dev/null
+++ b/src/pipt/ensembles/forecast.py
@@ -0,0 +1,330 @@
+"""Forecast support for assimilation ensembles.
+
+Running the forward simulator and turning its raw output into ``pred_data`` is
+ensemble work, not loop work: it reads ``sim``, ``enX``, ``data_df`` and the
+compression machinery, and it writes ``pred_data``. It lived on
+``pipt.loop.assimilation.Assimilate`` only because that class historically drove
+every iteration.
+
+:class:`AssimilationScheme` expects its ensemble collaborator to expose a
+public :meth:`ForecastMixin.forecast`, so the forecast lives here and the loop
+delegates to it. Mixed into :class:`pipt.ensembles.AssimilationEnsemble`.
+"""
+
+import os
+import pickle
+from typing import Any
+
+import numpy as np
+import pandas as pd
+from misc.structures import PredictedData
+
+import pipt.misc_tools.analysis_tools as at
+import pipt.misc_tools.extract_tools as extract
+
+__all__ = ["ForecastMixin", "OutlierMixin"]
+
+
+class ForecastMixin:
+    """Forward simulation and predicted-data preparation."""
+
+    RESTART_RESULTS_FILE = "restart_sim_results.pkl"
+    SIM_RESULTS_FILE = "sim_results.pkl"
+
+    def forecast(self, enX) -> None:
+        """Run forecast simulations and prepare predicted data for analysis.
+
+        Parameters
+        ----------
+        enX
+            The state to predict on. Passed in rather than read off the
+            ensemble, so a scheme can forecast a *trial* state without first
+            parking it somewhere for this method to find.
+        """
+        if self._load_restart_prediction_if_available():
+            return
+
+        self.calc_prediction(enX)
+        self.pred_data = self._predicted_data()
+        self.adjoints = self._adjoint_array()
+
+        # Multilevel runs correct each level towards the reference level's mean.
+        if getattr(self, "multilevel", None) is not None:
+            self.treat_modeling_error()
+
+        self._apply_prediction_scaling()
+        self._save_reconstructed_forecast_if_requested()
+        self._save_forecast_debug()
+
+    def _predicted_data(self):
+        """The forecast as the analyses see it: the layout's rows, filled from each member's output.
+
+        One container per level for a multilevel ensemble. Scaling follows the
+        observations: when ``data_df`` was max-min scaled, so are these, with
+        the same minimum and maximum per data type. Compressed data types are
+        reduced to the observed vintage's wavelet coefficients on the way in.
+        """
+        scale = (self.data_df.scale_min, self.data_df.scale_max) if self.data_df.is_scaled else None
+        position = self._record_positions()
+        transform = self._row_transform()
+        levels = [PredictedData.from_members(self.data_layout, members, position=position, scale=scale, transform=transform)
+                  for members in self.member_outputs]
+        return levels if getattr(self, "multilevel", None) is not None else levels[0]
+
+    # ------------------------------------------------------------------
+    # Wavelet compression of seismic data types (the `compress` option)
+    # ------------------------------------------------------------------
+    def _compressed_rows(self) -> dict:
+        """``{(label, datatype): vintage}`` for the observed cells the reader compressed, in its order.
+
+        The reader walks the observed frame label-major then type and numbers
+        the compressed cells it meets; the layout walks the same way, so the
+        n-th compressed row is vintage n. Cells beyond the masks given stay
+        uncompressed on both sides.
+        """
+        if not self.sparse_info or not self.sparse_data:
+            return {}
+        types = self.sparse_info["compress_data"]
+        types = [types] if isinstance(types, str) else list(types)
+        rows = [row for row in self.data_layout.rows if row.datatype in types]
+        return {(row.label, row.datatype): vintage for vintage, row in enumerate(rows[:len(self.sparse_data)])}
+
+    def _sim2seis_scale(self):
+        """The `sim2seis` scaling factor from ``scale_results.pkl``, read once; ``None`` when not in use."""
+        if not extract.is_enabled(self.keys_da.get("post_process_forecast", False)):
+            return None
+        if self.scale_val is None and os.path.exists("scale_results.pkl"):
+            with open("scale_results.pkl", "rb") as file:
+                scale = pickle.load(file)
+            self.scale_val = np.sum(scale[0]) / len(scale[0])
+        return self.scale_val
+
+    def _row_transform(self):
+        """What a member's raw values go through before entering the matrix; ``None`` when nothing does.
+
+        Data types containing ``sim2seis`` are divided by the sim2seis scale
+        when one is configured; compressed vintages become their leading
+        wavelet coefficients, through the same :class:`SparseRepresentation`
+        that reduced the observed vintage, so the leading indices match. The
+        reconstruction of each compressed member is kept only when
+        ``saveforecast`` will write it.
+        """
+        compressed = self._compressed_rows()
+        scale_val = self._sim2seis_scale()
+        if not compressed and scale_val is None:
+            return None
+        keep_reconstruction = compressed and "saveforecast" in self.sim.input_dict
+        self.data_rec = [[] for _ in range(len(self.sparse_data))] if compressed else []
+
+        def transform(row, values):
+            if scale_val is not None and "sim2seis" in row.datatype:
+                values = values / scale_val
+            vintage = compressed.get((row.label, row.datatype))
+            if vintage is not None:
+                values, wdec_rec = self.sparse_data[vintage].compress(values)
+                if keep_reconstruction:
+                    self.data_rec[vintage].append(self.sparse_data[vintage].reconstruct(wdec_rec))
+            return values
+
+        return transform
+
+    def _adjoint_array(self):
+        """The members' adjoints as ``(nd, nx, ne)`` in layout order, scaled with the data; ``None`` without adjoints.
+
+        Each member's adjoint is a frame whose cells hold the sensitivity of
+        that cell's values to the ``nx`` state variables. Only observed cells
+        are taken, so the array lines up with ``pred_data`` row for row.
+        """
+        members = self.member_adjoints
+        if not members:
+            return None
+        cells = {row: [np.asarray(member.loc[row.label, row.datatype], dtype=float).reshape(row.size, -1)
+                       for member in members] for row in self.data_layout.rows}
+        nx = next(iter(cells.values()))[0].shape[1]
+        out = np.empty((self.data_layout.nd, nx, len(members)))
+        for row, blocks in cells.items():
+            for j, block in enumerate(blocks):
+                out[row.rows, :, j] = block
+        if self.data_df.is_scaled:
+            span = self.data_df.scale_max - self.data_df.scale_min
+            for row in self.data_layout.rows:
+                out[row.rows] = (out[row.rows] - 0) / span[row.datatype]
+        return out
+
+    def _record_positions(self):
+        """Where each observed label sits in a member's records: the simulator's ``true_order``, else the label itself."""
+        order = getattr(self.sim, "true_order", None)
+        if order is None:
+            return None
+        positions = pd.Index(order[1]).get_indexer(list(self.data_layout.labels))
+        missing = [label for label, pos in zip(self.data_layout.labels, positions) if pos < 0]
+        if missing:
+            raise ValueError(f"the simulator reports no values at observed labels {missing!r}")
+        return dict(zip(self.data_layout.labels, positions))
+
+    def treat_modeling_error(self) -> None:
+        """Shift every coarser level so each row's ensemble mean matches the finest level's."""
+        reference = self.pred_data[-1].matrix.mean(axis=1)
+        for level in self.pred_data[:-1]:
+            level.matrix += (reference - level.matrix.mean(axis=1))[:, None]
+
+    # ------------------------------------------------------------------
+    # Saving helpers
+    # ------------------------------------------------------------------
+    @property
+    def _saving_enabled(self) -> bool:
+        return "nosave" not in self.keys_da
+
+    @property
+    def save_folder(self) -> str | None:
+        """Folder for run artifacts, or ``None`` when saving is disabled.
+
+        ``save_folder`` is accepted too; the config boundary maps it to
+        ``savefolder``. Reading this creates nothing; :meth:`_save_path` makes
+        the folder when something is about to be written into it.
+        """
+        if not self._saving_enabled:
+            return None
+        return self.keys_da.get("savefolder", "Results")
+
+    def _save_path(self, filename: str) -> str:
+        """Path of ``filename`` inside the save folder, which is created here."""
+        if self.save_folder is None:
+            raise RuntimeError("Cannot save results because saving is disabled.")
+        os.makedirs(self.save_folder, exist_ok=True)
+        return os.path.join(self.save_folder, filename)
+
+    # ------------------------------------------------------------------
+    # Forecast steps
+    # ------------------------------------------------------------------
+    def _load_restart_prediction_if_available(self) -> bool:
+        # A hand-placed file: a saved forecast copied to this name in the
+        # working directory supplies the forecast a crashed run had already
+        # finished. It is honoured only on a restart, so a file left behind
+        # cannot silently stand in for a fresh forecast on an ordinary run.
+        if not self.restart or not os.path.exists(self.RESTART_RESULTS_FILE):
+            return False
+
+        with open(self.RESTART_RESULTS_FILE, "rb") as file:
+            self.sim_data = pickle.load(file)
+
+        self.pred_data = self._container_from_frame(self.sim_to_pred_data(self.sim_data))
+
+        # Consumed once; it then lives with the other results under the name a
+        # saved forecast gets (in the working directory when saving is off).
+        used = self.SIM_RESULTS_FILE if self.save_folder is None else self._save_path(self.SIM_RESULTS_FILE)
+        os.replace(self.RESTART_RESULTS_FILE, used)
+        self.logger("--- Restart sim results used ---")
+        return True
+
+    def _apply_prediction_scaling(self) -> None:
+        """Multiply the predictions of the data types named by ``scale`` by its factor."""
+        if "scale" not in self.keys_da:
+            return
+
+        scale_keys, scale_factor = self.keys_da["scale"]
+        if isinstance(scale_keys, str):
+            scale_keys = [scale_keys]
+        levels = self.pred_data if isinstance(self.pred_data, list) else [self.pred_data]
+        for level in levels:
+            for datatype in scale_keys:
+                for rows in level.rows_of(datatype):
+                    level.matrix[rows] *= scale_factor
+
+    def _save_forecast_debug(self) -> None:
+        if "saveforecast" not in self.sim.input_dict:
+            return
+        if not self._saving_enabled:
+            return
+
+        forecast = self.sim_data
+        if self.data_df.is_scaled:
+            forecast = forecast.copy().invert_scale()
+
+        with open(self._save_path(self.SIM_RESULTS_FILE), "wb") as file:
+            pickle.dump(forecast, file)
+
+    def _container_from_frame(self, frame):
+        """A ``PredictedData`` (one per level) from a prediction frame, for paths that still produce frames."""
+        if isinstance(frame, list):
+            return [PredictedData.from_frame(self.data_layout, level, self.ne) for level in frame]
+        return PredictedData.from_frame(self.data_layout, frame, self.ne)
+
+    def sim_to_pred_data(self, pred: Any) -> Any:
+        '''
+        Filter the simulator output to match the structure of the predicted data expected.
+
+        Parameters
+        ----------
+        pred : Any
+            The raw output from the simulator, which may be a list of DataFrames or a single DataFrame.
+
+        Returns
+        -------
+        Any
+            The processed predicted data, structured to match the ensemble's expected format for analysis.
+        '''
+        if isinstance(pred, list):
+            return [self.sim_to_pred_data(frame) for frame in pred]
+        index = self.data_df.index
+        columns = self.data_df.columns
+        return pred.filter_dataframe(index=index, columns=columns)
+
+    def _save_reconstructed_forecast_if_requested(self) -> None:
+        """Write the reconstructed compressed vintages, ``(n_raw, ne)`` per vintage, when ``saveforecast`` asks."""
+        if "saveforecast" not in self.sim.input_dict or not self.data_rec:
+            return
+        self.data_rec = [np.asarray(members).T for members in self.data_rec]
+        with open("rec_results.pkl", "wb") as file:
+            pickle.dump(self.data_rec, file)
+
+
+class OutlierMixin:
+    """Replacement of outlier ensemble members.
+
+    Ensemble work, like the forecast: it rewrites ``pred_data``, ``sim_data``
+    and the state matrix in place. Called between forecast and scoring, so the
+    replacement feeds into the misfit the scheme sees.
+    """
+
+    def remove_outliers(self, enX):
+        """Replace outlier ensemble members with resampled non-outliers.
+
+        Returns the state with outliers resampled -- the same object when
+        there is nothing to replace. Returned rather than written back,
+        because the caller owns the state being forecast.
+        """
+        outlier_idx, non_outlier_idx = at.get_outlier_index(
+            self.pred_data.matrix, self.obs_vector, self.obs_variance,
+        )
+        if len(outlier_idx) == 0:
+            return enX
+        idx = np.arange(self.ne)
+        for outlier in outlier_idx:
+            new_idx = self.rng.choice(non_outlier_idx)
+            idx[outlier] = new_idx
+            self.logger(f"Replaced outlier {outlier} with member {new_idx}")
+
+        self.pred_data = self.pred_data.take_members(idx)
+
+        # The full forecast follows the members: reorder the raw outputs and
+        # let the frame view be rebuilt when next asked for. A forecast loaded
+        # from a file exists only as a frame; its cells with no data are None
+        # and are left alone (na_action), instead of failing on `.ndim`.
+        if getattr(self, "member_outputs", None):
+            self.member_outputs = [[members[i] for i in idx] for members in self.member_outputs]
+            self._sim_data = None
+        elif getattr(self, "sim_data", None) is not None:
+            def filter_outliers(cell):
+                return cell[..., idx] if cell.ndim > 1 else cell[idx]
+            self.sim_data = self.sim_data.map(filter_outliers, na_action='ignore')
+
+        # The adjoint belongs to the member it was evaluated at, so it moves
+        # with the state and the predictions -- a member whose gradient came
+        # from a different member is not a member of anything.
+        if getattr(self, "adjoints", None) is not None:
+            self.adjoints = self.adjoints[..., idx]
+            if getattr(self, "member_adjoints", None):
+                self.member_adjoints = [self.member_adjoints[i] for i in idx]
+
+        return enX[:, idx]
diff --git a/src/pipt/ensembles/local_analysis.py b/src/pipt/ensembles/local_analysis.py
new file mode 100644
index 00000000..26b07725
--- /dev/null
+++ b/src/pipt/ensembles/local_analysis.py
@@ -0,0 +1,198 @@
+"""Local-analysis update for assimilation ensembles.
+
+This is analysis mathematics rather than ensemble state, and sits here only
+because it needs the ensemble's data and localization objects. It is mixed into
+:class:`pipt.ensembles.AssimilationEnsemble` so the schemes can keep calling
+``self.local_analysis_update()``.
+
+Longer term this belongs with the analysis strategies in
+:mod:`pipt.update_schemes.analysis`; keeping it as its own mixin is the first
+step of that separation.
+"""
+
+import numpy as np
+from copy import deepcopy
+from scipy.linalg import solve
+
+import pipt.misc_tools.analysis_tools as at
+from pipt.localization import _calc_distance
+
+__all__ = ["LocalAnalysisMixin"]
+
+
+class LocalAnalysisMixin:
+    """Localized (per-parameter-neighbourhood) analysis update."""
+
+    def local_analysis_update(self):
+        '''
+        Function for updates that can be used by all algorithms. Do this once to avoid duplicate code for local
+        analysis.
+        '''
+        # Copy original info to restore after local updates
+        orig_list_data = deepcopy(self.list_datatypes)
+        orig_list_state = deepcopy(self.list_states)
+        orig_cd = deepcopy(self.cov_data)
+        orig_real_obs_data = deepcopy(self.real_obs_data)
+        orig_data_vector = deepcopy(self.obs_data_vector)
+
+        # loop over the states that we want to update. Assume that the state and data combinations have been
+        # determined by the initialization.
+        # TODO: augment parameters with identical mask.
+
+        # REGION PARAMETERS
+        ############################################################################################################
+        for state in self.local_analysis['region_parameter']:
+            self.list_datatypes = [
+                elem for elem in self.list_datatypes if
+                elem in self.local_analysis['update_mask'][state]
+            ]
+            self.list_states = [deepcopy(state)]
+
+            self._ext_scaling()  # scaling for this state
+            if 'localization' in self.keys_da:
+                self.localization.loc_info['field'] = self.state_scaling.shape
+            del self.cov_data
+
+            # reset the random state for consistency
+            np.random.set_state(self.data_random_state)
+            self.vecObs, self.enObs = self.set_observations()
+            _, self.enPred = at.aug_obs_pred_data(
+                self.obs_data,
+                self.pred_data,
+                self.assim_index,
+                self.list_datatypes
+            )
+
+            # Get state ensemble for list_states
+            enX = []
+            idX = {}
+            for idx in self.list_states:
+                start, end = self.idX[idx]
+                tempX = self.enX[start:end, :]
+                enX.append(tempX)
+                idX[idx] = (enX.shape[0] - tempX.shape[0], enX.shape[0])
+
+            # Compute the analysis update
+            self.update(
+                enX = np.vstack(enX),
+                enY = self.enPred,
+                enE = self.enObs,
+            )
+
+            # Update the state
+            if hasattr(self, 'step'):
+                self.enX_temp = self.enX + self.step
+        ############################################################################################################
+
+        # VECTOR REGION PARAMETERS
+        ############################################################################################################
+        for state in self.local_analysis['vector_region_parameter']:
+            current_list_datatypes = deepcopy(self.list_datatypes)
+            for state_indx in range(self.state[state].shape[0]): # loop over the elements in the region
+                self.list_datatypes = [elem for elem in self.list_datatypes if
+                                       elem in self.local_analysis['update_mask'][state][state_indx]]
+                if len(self.list_datatypes):
+                    self.list_states = [deepcopy(state)]
+                    self._ext_scaling()  # scaling for this state
+                    if 'localization' in self.keys_da:
+                        self.localization.loc_info['field'] = self.state_scaling.shape
+                    del self.cov_data
+                    # reset the random state for consistency
+                    np.random.set_state(self.data_random_state)
+                    self._ext_obs()  # get the data that's in the list of data.
+                    _, self.aug_pred_data = at.aug_obs_pred_data(self.obs_data, self.pred_data, self.assim_index,
+                                                                 self.list_datatypes)
+                    # Mean pred_data and perturbation matrix with scaling
+                    if len(self.scale_data.shape) == 1:
+                        self.pert_preddata = np.dot(np.expand_dims(self.scale_data ** (-1), axis=1),
+                                                    np.ones((1, self.ne))) * np.dot(self.aug_pred_data, self.proj)
+                    else:
+                        self.pert_preddata = solve(
+                            self.scale_data, np.dot(self.aug_pred_data, self.proj))
+
+                    aug_state = at.aug_state(self.current_state, self.list_states)[state_indx,:]
+                    self.update()
+                    if hasattr(self, 'step'):
+                        aug_state_upd = aug_state + self.step[state_indx,:]
+                    self.state[state][state_indx,:] = aug_state_upd
+
+                self.list_datatypes = deepcopy(current_list_datatypes)
+        ############################################################################################################
+
+
+        for state in self.local_analysis['cell_parameter']:
+            self.list_states = [deepcopy(state)]
+            self._ext_scaling()  # scaling for this state
+            orig_state_scaling = deepcopy(self.state_scaling)
+            param_position = self.local_analysis['parameter_position'][state]
+            field_size = param_position.shape
+            for k in range(field_size[0]):
+                for j in range(field_size[1]):
+                    for i in range(field_size[2]):
+                        current_data_list = list(
+                            self.local_analysis['update_mask'][state][k][j][i])
+                        current_data_list.sort()  # ensure consistent ordering of data
+                        if len(current_data_list):
+                            # if non-unique data for assimilation index, get the relevant data.
+                            if self.local_analysis['unique'] is False:
+                                orig_assim_index = deepcopy(self.assim_index)
+                                assim_index_data_list = set(
+                                    [el.split('_')[0] for el in current_data_list])
+                                current_assim_index = [
+                                    int(el.split('_')[1]) for el in current_data_list]
+                                current_data_list = list(assim_index_data_list)
+                                self.assim_index[1] = current_assim_index
+                            self.list_datatypes = deepcopy(current_data_list)
+                            del self.cov_data
+                            # reset the random state for consistency
+                            np.random.set_state(self.data_random_state)
+                            self._ext_obs()
+                            _, self.aug_pred_data = at.aug_obs_pred_data(self.obs_data, self.pred_data,
+                                                                         self.assim_index,
+                                                                         self.list_datatypes)
+                            # get parameter indexes
+                            full_cell_index = np.ravel_multi_index(
+                                np.array([[k], [j], [i]]), tuple(field_size))
+                            # count active values
+                            self.cell_index = [sum(param_position.flatten()[:el])
+                                               for el in full_cell_index]
+                            if 'localization' in self.keys_da:
+                                self.localization.loc_info['field'] = (
+                                    len(self.cell_index),)
+                                self.localization.loc_info['distance'] = _calc_distance(
+                                    self.local_analysis['data_position'],
+                                    self.local_analysis['unique'],
+                                    current_data_list, self.assim_index,
+                                    self.obs_data, self.pred_data, [(k, j, i)])
+                            # Set relevant state scaling
+                            self.state_scaling = orig_state_scaling[self.cell_index]
+
+                            # Mean pred_data and perturbation matrix with scaling
+                            if len(self.scale_data.shape) == 1:
+                                self.pert_preddata = np.dot(np.expand_dims(self.scale_data ** (-1), axis=1),
+                                                            np.ones((1, self.ne))) * np.dot(self.aug_pred_data,
+                                                                                            self.proj)
+                            else:
+                                self.pert_preddata = solve(
+                                    self.scale_data, np.dot(self.aug_pred_data, self.proj))
+
+                            aug_state = at.aug_state(
+                                self.current_state, self.list_states, self.cell_index)
+                            self.update()
+                            if hasattr(self, 'step'):
+                                aug_state_upd = aug_state + self.step
+                            self.state = at.update_state(
+                                aug_state_upd, self.state, self.list_states, self.cell_index)
+
+                            if self.local_analysis['unique'] is False:
+                                # reset assim index
+                                self.assim_index = deepcopy(orig_assim_index)
+                            if hasattr(self, 'localization') and 'distance' in self.localization.loc_info:  # reset
+                                del self.localization.loc_info['distance']
+
+        self.list_datatypes = deepcopy(orig_list_data)  # reset to original list
+        self.list_states = deepcopy(orig_list_state)
+        self.cov_data = deepcopy(orig_cd)
+        self.real_obs_data = deepcopy(orig_real_obs_data)
+        self.obs_data_vector = deepcopy(orig_data_vector)
+        self.cell_index = None
diff --git a/src/pipt/localization/__init__.py b/src/pipt/localization/__init__.py
new file mode 100644
index 00000000..ba8e1997
--- /dev/null
+++ b/src/pipt/localization/__init__.py
@@ -0,0 +1,31 @@
+"""Localization package for PIPT."""
+from .auto_ada_loc import AutoAdaptiveLocalization
+from .common import LocalizationBase, LocalizationConfigBuilder, normalize_parsed_info, parse_init_args
+from .distance_localization import (
+    DistanceLocalization,
+    FurrerBengtssonKernel,
+    GaspariCohnKernel,
+    RegionKernel,
+)
+from .factory import LOCALIZATIONS, available_localizations, build_localization_instance, register_localization
+from .local_analysis import LocalAnalysisLocalization, _calc_distance, _calc_loc
+
+__all__ = [
+    "LocalizationBase",
+    "LocalizationConfigBuilder",
+    "normalize_parsed_info",
+    "parse_init_args",
+    "build_localization_instance",
+    "register_localization",
+    "available_localizations",
+    "LOCALIZATIONS",
+    "AutoAdaptiveLocalization",
+    "DistanceLocalization",
+    "LocalAnalysisLocalization",
+    "GaspariCohnKernel",
+    "FurrerBengtssonKernel",
+    "RegionKernel",
+    "_calc_loc",
+    "_calc_distance",
+]
+
diff --git a/src/pipt/localization/auto_ada_loc.py b/src/pipt/localization/auto_ada_loc.py
new file mode 100644
index 00000000..e0afe439
--- /dev/null
+++ b/src/pipt/localization/auto_ada_loc.py
@@ -0,0 +1,367 @@
+"""Adaptive localization implementation."""
+import numpy as np
+from misc.sampling import random_stream
+from typing import Union
+from scipy.special import expit
+from pipt.localization.common import (
+    LocalizationBase,
+)
+
+__all__ = ["AutoAdaptiveLocalization"]
+
+class AutoAdaptiveLocalization(LocalizationBase):
+    """Adaptive localization strategy and engine implementation."""
+
+    name = "autoadaloc"
+
+    def __init__(self, info: Union[dict, list], rng=None):
+        """
+        Initialize the AutoAdaptiveLocalization instance.
+
+        All configuration is supplied through the ``info`` dictionary, which maps
+        directly to a ``[dataassim.localization]`` table in a TOML config file.
+
+        Parameters
+        ----------
+        info : dict or list
+            Localization configuration. Recognised keys:
+
+            **field** : list of int, *required*
+                Grid dimensions. For a 3-D reservoir use ``[nz, nx, ny]``;
+                for a 2-D field ``[nx, ny]`` is sufficient. Only the product
+                (total cell count) is used by this class.
+
+            **actnum** : str, *optional*
+                Path to a ``.npz`` file whose first array is a boolean mask
+                of active cells. When supplied, only active cells are counted
+                toward ``default_num_active``. Default: ``None`` (all cells
+                are considered active).
+
+            **threshold** : {``"adaptive"``, ``"fixed"``, ``"universal"``}, *optional*
+                Method used to compute the correlation threshold below which
+                a correlation is deemed indistinguishable from sampling noise:
+
+                - ``"adaptive"`` — threshold = ``cutoff * sigma``, where *sigma*
+                  is estimated column-wise from shuffled correlations via the
+                  MAD estimator. The ``cutoff`` parameter controls how many noise
+                  standard deviations to use as the cut-off.
+                - ``"fixed"`` — threshold equals ``cutoff`` directly; no noise
+                  estimation is performed. Use when you want a deterministic,
+                  reproducible cut-off independent of the ensemble.
+                - ``"universal"`` — threshold = ``sqrt(2 * log(N)) * sigma``;
+                  adapts automatically to ensemble size without requiring
+                  ``cutoff`` to be tuned.
+
+                Default: ``"adaptive"``.
+
+            **cutoff** : float, *optional*
+                Threshold value or noise multiplier (interpretation depends on
+                ``threshold``). Larger values suppress more correlations.
+                Default: ``0.3``.
+
+            **type** : {``"hard"``, ``"soft"``, ``"sigm"``}, *optional*
+                Tapering strategy applied once the threshold is known:
+
+                - ``"hard"`` — binary mask: 1 where |r| ≥ threshold, 0
+                  elsewhere. Sharp cut-off, computationally efficient.
+                - ``"soft"`` — smooth rational-function taper that transitions
+                  gradually around the threshold. Avoids discontinuities in
+                  the localization operator.
+                - ``"sigm"`` — sigmoid-based taper; similar smoothness to
+                  ``"soft"`` but with a different shape near the transition.
+
+                Default: ``"hard"``.
+
+        Examples
+        --------
+        Minimal TOML block inside ``[dataassim]`` using fixed thresholding:
+
+        ```toml
+        [dataassim.localization]
+        name       = "autoadaloc"
+        field      = [1, 20, 20]   # [nz, nx, ny]
+        threshold  = "fixed"
+        cutoff     = 0.4
+        type       = "hard"
+        ```
+
+        Noise-adaptive thresholding with a smooth taper:
+
+        ```toml
+        [dataassim.localization]
+        name       = "autoadaloc"
+        field      = [2, 30, 40]   # two-layer, 30×40 lateral grid
+        actnum     = "active_cells.npz"
+        threshold  = "universal"   # adapts to ensemble size automatically
+        type       = "soft"
+        ```
+
+        Large state vector — skip forming the full cross-covariance:
+
+        ```toml
+        [dataassim.localization]
+        name       = "autoadaloc"
+        field      = [5, 100, 100]
+        threshold  = "fixed"
+        cutoff     = 0.3
+        type       = "hard"
+        ```
+        """
+        # The stream the shuffle below draws from; the global one unless the run is seeded.
+        self.rng = rng if rng is not None else random_stream()
+        self.field, self.actnum = self.config_common(info)
+        self.cutoff = self._cutoff_from(info)
+        self.threshold  = info.get("threshold", "adaptive")
+        self.tapertype  = info.get("type", "hard")
+        self.parameters = info.get("parameters", ['NA'])
+        self.projection = info.get("projection", "rank-r")
+
+        # Ensure that the tapering type is valid
+        if self.tapertype not in ["hard", "soft", "sigm"]:
+            raise ValueError(
+                f"Invalid tapering type '{self.tapertype}'. "
+                "Supported types are 'hard', 'soft', and 'sigm'."
+            )
+
+        # Ensure that the threshold method is valid
+        if self.threshold not in ["adaptive", "fixed", "universal"]:
+            raise ValueError(
+                f"Invalid threshold method '{self.threshold}'. "
+                "Supported methods are 'adaptive', 'fixed', and 'universal'."
+            )
+
+    def __call__(
+            self,
+            X: np.ndarray,
+            Y: np.ndarray,
+            parameters: list[str]=None,
+            prior_info: dict=None
+        ) -> np.ndarray:
+        """
+        Calculate truncated cross-covariance matrix.
+
+        Parameters
+        ----------
+        X : ndarray, shape (nx, ne)
+            State perturbation ensemble.
+
+        Y : ndarray, shape (ny, ne)
+            Projected predicted data ensemble.
+
+        parameters : list[str]
+            Ordered list of parameters corresponding to blocks in X.
+
+        prior_info : dict, optional
+            Prior information for each parameter. If provided,
+            ``prior_info[param]["active"]`` specifies the number of
+            active variables associated with the parameter.
+
+        Returns
+        -------
+        ndarray, shape (nx, ny)
+            Tapered matrix containing the tapering coefficients for the cross-covariance between X and Y.
+        """
+        parameters = self.parameters if parameters is None else parameters
+        prior_info = {} if prior_info is None else prior_info
+
+        corr = self.corr_matrix(X, Y) # Shape: (nx, ny)
+        corr_shuffled = self.corr_matrix(
+            X[:, self.rng.permutation(X.shape[1])],
+            Y,
+        )
+
+        default_num_active = (
+            np.sum(self.actnum) if (self.actnum is not None) else np.prod(self.field)
+        )
+
+        taper = np.ones_like(corr)
+        row_start = 0
+        for param in parameters:
+
+            if param == "NA":
+                num_active = taper.shape[0] - row_start
+            else:
+                param_info = prior_info.get(param, {})
+                num_active = int(param_info.get("active", default_num_active))
+
+            rows = slice(row_start, row_start + num_active)
+            taper[rows] = self.tapering_function(
+                corr[rows],
+                corr_shuffled[rows],
+            )
+            row_start += num_active
+
+        return taper
+
+
+    @staticmethod
+    def _cutoff_from(info: dict) -> float:
+        """How many noise standard deviations a correlation must clear to survive.
+
+        This is what used to be called ``nstd``, and it was carried as the value of the
+        ``autoadaloc`` key itself -- ``AUTOADALOC 2`` meant two. Reading only ``cutoff``
+        left such a config running at the default while the number the user wrote was
+        ignored, which changes the taper and so the posterior without any error. All
+        three spellings are accepted; ``autoadaloc`` is also set to ``True`` as a plain
+        mode flag, which is not a value and is skipped.
+        """
+        for key in ("cutoff", "nstd", "autoadaloc"):
+            value = info.get(key)
+            if value is None or isinstance(value, bool):
+                continue
+            try:
+                return float(value)
+            except (TypeError, ValueError):
+                continue
+        return 0.3
+
+    def tapering_function(self, corr_values: np.ndarray, corr_values_shuffled: np.ndarray) -> np.ndarray:
+
+        """
+        Compute tapering coefficients from sample correlations.
+
+        The tapering coefficients are used to suppress correlations that are
+        indistinguishable from noise. A noise level is estimated for each
+        observation variable from the corresponding shuffled correlations using
+        the median absolute deviation (MAD),
+
+            sigma = median(|r_shuffled|) / 0.6745
+
+        which provides a robust estimate of the standard deviation under the
+        assumption of Gaussian noise.
+
+        Depending on the localization settings, the correlation threshold is
+        computed using one of the following methods:
+
+        - ``"adaptive"`` (default):
+            threshold = cutoff * sigma
+        - ``"fixed"``:
+            threshold = cutoff
+        - ``"universal"``:
+            threshold = sqrt(2 log(N)) * sigma
+
+        Tapering can then be applied using one of three strategies:
+
+        - ``"hard"`` (default):
+            correlations above the threshold are assigned a taper value of 1,
+            otherwise 0.
+        - ``"soft"``:
+            smooth tapering based on ``rational_function``.
+        - ``"sigm"``:
+            sigmoid-based tapering using ``rational_function_sigmoid``.
+
+        Parameters
+        ----------
+        corr_values : ndarray of shape (nx, ny)
+            Sample correlation matrix.
+
+        corr_values_shuffled : ndarray of shape (nx, ny)
+            Correlation matrix computed from shuffled or randomized ensembles.
+            Used to estimate the noise level of the correlations.
+
+        Returns
+        -------
+        ndarray of shape (nx, ny)
+            Tapering coefficients in the interval [0, 1]. These coefficients
+            can be applied element-wise to the correlation matrix to reduce
+            the influence of correlations attributed to sampling noise.
+        """
+        taper_coeff = np.zeros_like(corr_values)
+        for i in range(corr_values.shape[1]):
+            corr = corr_values[:, i]
+
+            # Estimate noise level from shuffled correlations:
+            mad_to_std = 1 / 0.6745
+            noise_std  = np.median(np.abs(corr_values_shuffled[:, i])) * mad_to_std
+
+            # Compute threshold
+            if self.threshold == "fixed":
+                threshold = self.cutoff
+            elif self.threshold == "universal":
+                threshold = np.sqrt(2 * np.log(corr.size)) * noise_std
+            else:  # "adaptive"
+                threshold = self.cutoff * noise_std
+
+            # Compute taper coefficients
+            if self.tapertype == "soft":
+                taper = self.rational_function(
+                    1 - np.abs(corr),
+                    1 - threshold,
+                )
+            elif self.tapertype == "sigm":
+                taper = self.rational_function_sigmoid(
+                    np.abs(corr),
+                    threshold,
+                )
+            else:
+                taper = np.zeros_like(corr)
+                taper[np.abs(corr) > threshold] = 1.0
+
+            taper_coeff[:, i] = taper
+
+        return taper_coeff
+
+
+    def rational_function(self, distance, length_scale):
+        """Piecewise rational taper of ``distance`` at ``length_scale``: 1 inside the scale, decaying to 0 at twice the scale."""
+        z_ratio = np.absolute(distance) / length_scale
+        idx_inner = np.where(z_ratio <= 1)
+        idx_outer = np.where(z_ratio <= 2)
+        idx_transition = np.setdiff1d(idx_outer, idx_inner)
+
+        taper = np.zeros(len(z_ratio))
+
+        taper[idx_inner] = (
+            1
+            - (np.power(z_ratio[idx_inner], 5) / 4)
+            + (np.power(z_ratio[idx_inner], 4) / 2)
+            + (5 * np.power(z_ratio[idx_inner], 3) / 8)
+            - (5 * np.power(z_ratio[idx_inner], 2) / 3)
+        )
+
+        taper[idx_transition] = (
+            (np.power(z_ratio[idx_transition], 5) / 12)
+            - (np.power(z_ratio[idx_transition], 4) / 2)
+            + (5 * np.power(z_ratio[idx_transition], 3) / 8)
+            + (5 * np.power(z_ratio[idx_transition], 2) / 3)
+            - 5 * z_ratio[idx_transition]
+            - np.divide(2, 3 * z_ratio[idx_transition])
+            + 4
+        )
+
+        return taper
+
+    @staticmethod
+    def rational_function_sigmoid(distance, length_scale):
+        """A steep sigmoid taper switching at ``length_scale``."""
+        steepness = 50
+        return expit((distance - length_scale) * steepness)
+
+    @staticmethod
+    def corr_matrix(X, Y, eps=1e-6):
+        """
+        Compute the correlation matrix between two ensemble matrices X and Y.
+
+        Parameters
+        ----------
+        X : np.ndarray, shape (nx, ne)
+        Y : np.ndarray, shape (ny, ne)
+        eps : float, optional, default=1e-6
+            Small value to avoid division by zero when computing standard deviations.
+
+        Returns
+        -------
+        corr : np.ndarray, shape (nx, ny)
+            The correlation matrix between X and Y.
+        """
+        stdX = np.std(X, axis=1)
+        stdY = np.std(Y, axis=1)
+
+        nx = X.shape[0]
+        corr = np.corrcoef(X, Y)[:nx, nx:]
+        corr[stdX < eps, :] = 0
+        corr[:, stdY < eps] = 0
+
+        return np.nan_to_num(corr)
+
+
diff --git a/src/pipt/localization/common.py b/src/pipt/localization/common.py
new file mode 100644
index 00000000..36e860ad
--- /dev/null
+++ b/src/pipt/localization/common.py
@@ -0,0 +1,326 @@
+"""Localization strategies and shared primitives for PIPT.
+
+Design principles:
+- Keep parsing, geometry, and adaptive math in separate classes.
+- Expose small, explicit workflow strategies with a stable API.
+"""
+import csv
+import pickle
+import numpy as np
+from abc import ABC
+from typing import Any, Dict, List, Tuple, Union
+from pipt.misc_tools.extract_tools import list_to_dict
+
+__all__ = [
+    "LocalizationBase",
+    "LocalizationConfigBuilder",
+    "parse_init_args",
+    "normalize_parsed_info",
+    "infer_name",
+]
+
+class LocalizationBase(ABC):
+    """Shared base for localization engines and workflow strategies."""
+
+    def config_common(self, info: Union[dict, list]) -> dict:
+        """
+        Configure the common localization parameters for all strategies.
+
+        Parameters
+        ----------
+        info : dict or list
+            Localization configuration information.
+            - `field`: list of integers specifying the localization field dimensions.
+            - `actnum`: optional path to a .npz file containing the actnum array
+
+        """
+        if 'field' not in info:
+            raise KeyError("'field' must be defined in localization input")
+        else:
+            assert isinstance(info['field'], list), "'field' must be a list of integers"
+
+        self.info = info
+
+        # Extract and validate the field dimensions
+        field = [int(elem) for elem in info['field']]
+
+        # Handle optional actnum file
+        actnum = info.get('actnum', None)
+        if actnum is not None:
+            if not str(actnum).endswith(".npz"):
+                raise ValueError("actnum must point to a .npz file")
+            actnum_npz = np.load(actnum)
+            if hasattr(actnum_npz, "files") and len(actnum_npz.files) > 0:
+                key = "actnum" if "actnum" in actnum_npz.files else actnum_npz.files[0]
+                actnum = actnum_npz[key]
+            else:
+                actnum = actnum_npz
+
+        return field, actnum
+
+
+
+class LocalizationConfigBuilder:
+    """Build normalized localization configuration and precomputed masks."""
+
+    def __init__(self, parsed_info: Union[dict, list]):
+        self.parsed_dict = normalize_parsed_info(parsed_info)
+
+    def build(self, data_index: list, data_types: list, parameters: list, ne: int) -> dict:
+        """Build the localization info dictionary used by strategies."""
+        if "field" not in self.parsed_dict:
+            raise KeyError("'field' must be defined in localization input")
+
+        loc_info: Dict[Any, Any] = {
+            "field": [int(elem) for elem in self.parsed_dict["field"]],
+            "actnum": None,
+        }
+
+        if "actnum" in self.parsed_dict and self.parsed_dict["actnum"] is not None:
+            file_path = self.parsed_dict["actnum"]
+            if not str(file_path).endswith(".npz"):
+                raise ValueError("actnum must point to a .npz file")
+            actnum_npz = np.load(file_path)
+            if hasattr(actnum_npz, "files") and len(actnum_npz.files) > 0:
+                key = "actnum" if "actnum" in actnum_npz.files else actnum_npz.files[0]
+                loc_info["actnum"] = actnum_npz[key]
+            else:
+                loc_info["actnum"] = actnum_npz
+
+        if "threshold" in self.parsed_dict:
+            loc_info["threshold"] = self.parsed_dict["threshold"]
+
+        mode_info = self._parse_special_modes(self.parsed_dict)
+        if mode_info is not None:
+            loc_info.update(mode_info)
+            loc_info["mask"] = {}
+            return loc_info
+        else:
+            pickle_data = self._load_pickle_localization(self.parsed_dict)
+            if pickle_data is not None:
+                loc_info = pickle_data
+                if "field" not in loc_info:
+                    loc_info["field"] = [int(elem) for elem in self.parsed_dict["field"]]
+                if "actnum" not in loc_info:
+                    loc_info["actnum"] = None
+                if "threshold" in self.parsed_dict and "threshold" not in loc_info:
+                    loc_info["threshold"] = self.parsed_dict["threshold"]
+            else:
+                loc_info = self._build_explicit_localization_entries(
+                    parsed_dict=self.parsed_dict,
+                    data_index=data_index,
+                    data_types=data_types,
+                    parameters=parameters,
+                    init_local=loc_info,
+                )
+
+        # NOTE: SpatialLocalization (from distance_loc) removed — LocalAnalysisLocalization
+        # will be reimplemented without LocalizationConfigBuilder.
+        loc_info["mask"] = {}
+        return loc_info
+
+    @staticmethod
+    def _parse_special_modes(parsed_dict: dict) -> Union[dict, None]:
+        if "autoadaloc" in parsed_dict:
+            mode = {
+                "autoadaloc": True,
+                "nstd": parsed_dict["autoadaloc"],
+            }
+            if "type" in parsed_dict:
+                mode["type"] = parsed_dict["type"]
+            return mode
+
+        if "localanalysis" in parsed_dict:
+            mode = {"localanalysis": True}
+            if "type" in parsed_dict:
+                mode["type"] = parsed_dict["type"]
+            if "range" in parsed_dict:
+                mode["range"] = float(parsed_dict["range"])
+            return mode
+
+        return None
+
+    @staticmethod
+    def _load_pickle_localization(parsed_dict: dict) -> Union[dict, None]:
+        pickle_file = None
+        for _, value in parsed_dict.items():
+            if str(value).endswith(".p") or str(value).endswith(".pkl"):
+                pickle_file = value
+                break
+        if pickle_file is None:
+            return None
+        with open(pickle_file, "rb") as stream:
+            return pickle.load(stream)
+
+    def _build_explicit_localization_entries(
+        self,
+        parsed_dict: dict,
+        data_index: list,
+        data_types: list,
+        parameters: list,
+        init_local: dict,
+    ) -> dict:
+        for time in data_index:
+            for datum in data_types:
+                for parameter in parameters:
+                    init_local[(datum, time, parameter)] = {
+                        "taper_func": None,
+                        "position": None,
+                        "anisotropi": None,
+                        "range": None,
+                    }
+
+        info_rows = self._read_localization_rows(parsed_dict)
+        for row in info_rows:
+            self._apply_localization_row(row, init_local)
+
+        return init_local
+
+    @staticmethod
+    def _read_localization_rows(parsed_dict: dict) -> List[str]:
+        csv_key = next((k for k in parsed_dict if str(k).endswith(".csv")), None)
+        if csv_key:
+            with open(csv_key) as csv_file:
+                reader = csv.reader(csv_file)
+                return [item for sublist in reader for item in sublist]
+
+        for key in parsed_dict:
+            if len(str(key).split(",")) > 1:
+                return str(key).split(",")
+
+        return []
+
+    @staticmethod
+    def _apply_localization_row(row: str, init_local: dict) -> None:
+        tmp_info = row.split()
+        if not tmp_info:
+            return
+
+        if len(tmp_info) == 11:
+            name = (tmp_info[8].lower(), float(tmp_info[9]), tmp_info[10].lower())
+        else:
+            name = (
+                tmp_info[8].lower() + " " + tmp_info[9].lower(),
+                float(tmp_info[10]),
+                tmp_info[11].lower(),
+            )
+
+        if name not in init_local:
+            return
+
+        entry = init_local[name]
+        entry["taper_func"] = tmp_info[0]
+
+        if tmp_info[0] == "import":
+            entry["file"] = tmp_info[1]
+            return
+
+        entry["position"] = [[int(float(tmp_info[1])), int(float(tmp_info[2])), int(float(tmp_info[3]))]]
+        entry["range"] = [int(tmp_info[4]), int(tmp_info[5])]
+        entry["anisotropi"] = [float(tmp_info[6]), float(tmp_info[7])]
+
+    def _build_unique_masks(self, init_local: dict, ne: int, spatial_engine) -> dict:
+        masks: Dict[Any, np.ndarray] = {}
+
+        loc_mask_info = [
+            (
+                init_local[element]["taper_func"],
+                init_local[element]["anisotropi"][0],
+                init_local[element]["anisotropi"][1],
+                init_local[element]["range"],
+            )
+            for element in init_local.keys()
+            if isinstance(element, tuple) and len(element) == 3 and init_local[element]["taper_func"] is not None
+        ]
+
+        for info in loc_mask_info:
+            key, loc_range = self._mask_key_from_info(info)
+            if key in masks:
+                continue
+
+            masks[key] = spatial_engine.gen_loc_mask(
+                taper_function=info[0],
+                anisotropi=[info[1], info[2]],
+                loc_range=loc_range,
+                field_size=init_local["field"],
+                ne=ne,
+            )
+
+        return masks
+
+    @staticmethod
+    def _mask_key_from_info(info: tuple) -> Tuple[tuple, Any]:
+        taper_func, aniso_1, aniso_2, loc_range = info
+
+        if taper_func == "region":
+            if isinstance(loc_range, list):
+                return ("region", loc_range[0], loc_range[1], loc_range[2]), loc_range
+            return ("region", loc_range), loc_range
+
+        if isinstance(loc_range, list):
+            return (taper_func, aniso_1, aniso_2, loc_range[0], loc_range[1]), loc_range[0]
+
+        return (taper_func, aniso_1, aniso_2, loc_range), loc_range
+
+
+#: The keyword whose *presence* selected each mode before the strategies were named.
+#: Order matters: it is the order the original chain tested them in.
+_MODE_KEYWORDS = (
+    ("autoadaloc", "autoadaloc"),
+    ("localanalysis", "localanalysis"),
+    ("dist_loc", "distance_loc"),
+)
+
+
+def infer_name(info: dict) -> str:
+    """Name the localization mode a config selects by keyword rather than by name.
+
+    Localization used to be chosen by which keyword appeared in the block --
+    ``autoadaloc``, ``localanalysis``, ``dist_loc``, a pickled mask file, or none of
+    them for the parallel update. Those configs carry no ``name``, so it is worked out
+    here and they keep running unchanged.
+    """
+    for keyword, name in _MODE_KEYWORDS:
+        if keyword in info:
+            return name
+
+    # ``dist_loc`` was also accepted as a bare value rather than a key.
+    values = [str(value) for value in info.values()]
+    if "dist_loc" in values:
+        return "distance_loc"
+
+    # A pickled mask file, under any key, means distance localization.
+    if any(value.endswith((".p", ".pkl")) for value in values):
+        return "distance_loc"
+
+    return "parallel_update"
+
+
+def normalize_parsed_info(parsed_info: Union[dict, list]) -> dict:
+    """Normalize localization input to dictionary form, naming the mode if it does not."""
+    if isinstance(parsed_info, list):
+        parsed_info = list_to_dict(parsed_info)
+    if not isinstance(parsed_info, dict):
+        raise TypeError("parsed_info must be dict or list")
+    if "name" not in parsed_info:
+        parsed_info = {**parsed_info, "name": infer_name(parsed_info)}
+    return parsed_info
+
+
+def parse_init_args(
+    data_indices: Union[list, None] = None,
+    data_types: Union[list, None] = None,
+    parameters: Union[list, None] = None,
+    ensemble_size: Union[int, None] = None,
+):
+    """Parse constructor arguments using canonical keyword names."""
+
+    if data_indices is None or data_types is None or parameters is None or ensemble_size is None:
+        raise TypeError(
+            "Localization requires data_indices, data_types, parameters, and ensemble_size."
+        )
+
+    return data_indices, data_types, parameters, ensemble_size
+
+
+
diff --git a/src/pipt/localization/distance_localization.py b/src/pipt/localization/distance_localization.py
new file mode 100644
index 00000000..04c1f433
--- /dev/null
+++ b/src/pipt/localization/distance_localization.py
@@ -0,0 +1,855 @@
+"""Distance-based localization implementation."""
+
+from __future__ import annotations
+
+import csv
+import pickle
+from dataclasses import dataclass
+from typing import Dict, List, Optional, Tuple, Union
+
+import numpy as np
+import pandas as pd
+from scipy import sparse
+
+from pipt.localization.common import LocalizationBase
+from pipt.misc_tools.extract_tools import list_to_dict
+
+__all__ = [
+    "DistanceLocalization",
+    "GaspariCohnKernel",
+    "FurrerBengtssonKernel",
+    "RegionKernel",
+]
+
+
+def _parse_time(s: str):
+    """Parse a time token as float or, if that fails, as a pd.Timestamp."""
+    try:
+        return float(s)
+    except ValueError:
+        return pd.Timestamp(s)
+
+
+# ===========================================================
+# Localization entry container
+# ===========================================================
+
+@dataclass(slots=True)
+class LocalizationEntry:
+    """Configuration for a single (data_type, time, parameter) localization entry."""
+
+    taper:            str
+    positions:        List[List[int]]
+    radius:           int
+    z_range:          object
+    anisotropy_ratio: float = 1.0
+    rotation_deg:     float = 0.0
+    filepath:         Optional[str] = None   # used when taper == 'import'
+
+
+# ===========================================================
+# Geometry helpers
+# ===========================================================
+
+def _build_transform(anisotropy_ratio: float, rotation_deg: float) -> np.ndarray:
+    """Return the 2x2 anisotropy + rotation transform matrix."""
+    angle    = np.deg2rad(rotation_deg)
+    rotation = np.array([[ np.cos(angle), np.sin(angle)],
+                         [-np.sin(angle), np.cos(angle)]])
+    scaling  = np.array([[1.0 / anisotropy_ratio, 0.0],
+                         [0.0,                    1.0]])
+    return scaling @ rotation
+
+
+def _kernel_coordinates(nx: int, ny: int) -> Tuple[np.ndarray, np.ndarray]:
+    """Return (X, Y) coordinate grids centered at the origin."""
+    x = np.arange(nx) - nx // 2
+    y = np.arange(ny) - ny // 2
+    return np.meshgrid(x, y, indexing="ij")
+
+
+def _crop_kernel(kernel: np.ndarray) -> np.ndarray:
+    """Trim zero-only border rows and columns from a kernel array."""
+    rows = np.any(kernel > 0, axis=1)
+    cols = np.any(kernel > 0, axis=0)
+    r0 = rows.argmax()
+    r1 = len(rows) - rows[::-1].argmax()
+    c0 = cols.argmax()
+    c1 = len(cols) - cols[::-1].argmax()
+    return kernel[r0:r1, c0:c1]
+
+
+# ===========================================================
+# Kernel classes
+# ===========================================================
+
+class GaspariCohnKernel:
+    """Gaspari-Cohn compactly supported smooth taper kernel."""
+
+    def build(
+        self,
+        radius:           int,
+        anisotropy_ratio: float,
+        rotation_deg:     float,
+        field_shape:      tuple,
+        ensemble_size:    Optional[int] = None,
+    ) -> np.ndarray:
+        """Taper weights around a datum: smooth Gaspari-Cohn decay over ``radius`` cells, stretched by ``anisotropy_ratio``."""
+        nx, ny = 2 * field_shape[1], 2 * field_shape[2]
+        X, Y   = _kernel_coordinates(nx, ny)
+        coords = np.vstack((X.ravel(), Y.ravel()))
+
+        T           = _build_transform(anisotropy_ratio, rotation_deg)
+        transformed = T @ coords
+        ratio       = np.sqrt((transformed[0] / radius) ** 2 +
+                              (transformed[1] / radius) ** 2)
+
+        values = np.zeros_like(ratio)
+        inner  = ratio <= 1
+        outer  = (ratio > 1) & (ratio <= 2)
+
+        values[inner] = (
+            -0.25 * ratio[inner] ** 5
+            + 0.5  * ratio[inner] ** 4
+            + 0.625 * ratio[inner] ** 3
+            - (5.0 / 3.0) * ratio[inner] ** 2
+            + 1.0
+        )
+        values[outer] = (
+            (1.0 / 12.0) * ratio[outer] ** 5
+            - 0.5  * ratio[outer] ** 4
+            + 0.625 * ratio[outer] ** 3
+            + (5.0 / 3.0) * ratio[outer] ** 2
+            - 5.0  * ratio[outer]
+            + 4.0
+            - (2.0 / 3.0) / ratio[outer]
+        )
+
+        return _crop_kernel(values.reshape(nx, ny))
+
+
+class FurrerBengtssonKernel:
+    """Furrer-Bengtsson ensemble-size-aware taper kernel."""
+
+    def build(
+        self,
+        radius:           int,
+        anisotropy_ratio: float,
+        rotation_deg:     float,
+        field_shape:      tuple,
+        ensemble_size:    Optional[int] = None,
+    ) -> np.ndarray:
+        """Taper weights around a datum: Furrer-Bengtsson decay over ``radius`` cells, adjusted for the ensemble size."""
+        nx, ny = 2 * field_shape[1], 2 * field_shape[2]
+        X, Y   = _kernel_coordinates(nx, ny)
+        coords = np.vstack((X.ravel(), Y.ravel()))
+
+        T           = _build_transform(anisotropy_ratio, rotation_deg)
+        transformed = T @ coords
+        distance    = np.sqrt(transformed[0] ** 2 + transformed[1] ** 2)
+
+        weight         = np.zeros_like(distance)
+        inside         = distance < radius
+        d              = distance[inside] / radius
+        weight[inside] = 1.0 - (1.5 * d - 0.5 * d ** 3)
+
+        ne = ensemble_size if ensemble_size is not None else 50
+        fb = (ne * weight ** 2) / (weight ** 2 * (ne + 1) + 1)
+
+        return _crop_kernel(fb.reshape(nx, ny))
+
+
+class RegionKernel:
+    """Binary region kernel - full weight (1) everywhere within range."""
+
+    def build(
+        self,
+        radius:           int           = None,
+        anisotropy_ratio: float         = 1.0,
+        rotation_deg:     float         = 0.0,
+        field_shape:      tuple         = None,
+        ensemble_size:    Optional[int] = None,
+    ) -> np.ndarray:
+        """Weight 1 everywhere within ``radius`` (stretched by ``anisotropy_ratio``), 0 outside."""
+        return np.ones((1, 1))
+
+
+# ===========================================================
+# DistanceLocalization - mirrors AutoAdaptiveLocalization API
+# ===========================================================
+
+class DistanceLocalization(LocalizationBase):
+    """
+    Distance-based localization strategy for sparse mask projection.
+
+    Follows the same init/call pattern as AutoAdaptiveLocalization:
+    - All configuration is parsed and stored at ``__init__`` time.
+    - ``__call__`` assembles and returns the sparse localization operator.
+
+    Parameters
+    ----------
+    info : dict or list
+        Localization configuration. Must contain:
+
+        - ``field``: ``[nz, nx, ny]`` grid dimensions.
+        - ``actnum``: path to ``.npz`` file with active-cell mask (optional).
+        - ``taper_func``: kernel type -- ``"gc"``, ``"fb"``, or ``"region"``
+          (default: ``"region"``).
+
+        Plus one of:
+        - a ``.csv`` key or comma-separated inline rows specifying entries, or
+        - a ``.pkl`` / ``.p`` key pointing to a pre-built entries dict.
+
+    data : pd.DataFrame, optional
+        Observed data with time indices as rows and data types as columns.
+
+    parameters : list of str, optional
+        State parameter names used as defaults in ``__call__``.
+
+    ensemble_size : int, optional
+        Ensemble size; used by the Furrer-Bengtsson kernel.
+
+    prior_info : dict, optional
+        Per-parameter prior information (``nx``, ``ny``, ``nz``).
+        Used to build zero masks for unconfigured parameters.
+    """
+
+    name = "distance_loc"
+
+    _kernel_map = {
+        "gc":     GaspariCohnKernel,
+        "fb":     FurrerBengtssonKernel,
+        "region": RegionKernel,
+    }
+
+    def __init__(
+        self,
+        info:          Union[dict, list],
+        data:          Union[pd.DataFrame, None] = None,
+        parameters:    Union[list, None]         = None,
+        ensemble_size: Union[int, None]          = None,
+        prior_info:    Union[dict, None]         = None,
+    ):
+        """
+        Initialize the DistanceLocalization instance.
+
+        Spatial localization entries — one per (data_type, time, parameter)
+        combination — are supplied either via an external CSV file or as
+        comma-separated inline rows embedded in the ``info`` dict key.
+        All ``info`` keys map directly to the ``[dataassim.localization]``
+        table in a TOML config file.
+
+        Parameters
+        ----------
+        info : dict or list
+            Localization configuration. Recognised keys:
+
+            **field** : list of int, *required*
+                Grid dimensions ``[nz, nx, ny]``. Used to size the spatial
+                kernel arrays and to lay out the flattened cell vectors.
+
+            **actnum** : str, *optional*
+                Path to a ``.npz`` file whose first array is a boolean mask
+                of active cells. When supplied, only active cells appear in
+                the output localization operator. Default: ``None``.
+
+            **taper_func** : {``"gc"``, ``"fb"``, ``"region"``}, *optional*
+                Spatial kernel applied at each observation location:
+
+                - ``"gc"`` — **Gaspari-Cohn** fifth-order piecewise
+                  polynomial. Compact support extends to ``2 × radius``
+                  grid cells. Values lie in [0, 1] with a smooth,
+                  differentiable profile. The standard choice for
+                  distance-based localization in geoscience DA.
+                - ``"fb"`` — **Furrer-Bengtsson** ensemble-size-aware
+                  taper. Weights are scaled by ensemble size *Ne* so
+                  that larger ensembles produce sharper localization.
+                  Values lie in [0, Ne/(Ne+2)]. Pass ``ensemble_size``
+                  to control *Ne* (default 50).
+                - ``"region"`` — Binary point kernel: weight 1 at the
+                  single nearest cell, 0 everywhere else. Equivalent to
+                  assigning one observation to exactly one grid cell.
+
+                Default: ``"region"``.
+
+            **entries** : str, list, or dict, *optional*
+                Localization entries configuration. Three formats are supported:
+
+                - **str**: Path to a CSV file containing one entry per line
+                  (see *CSV row format* in Notes).
+                - **list**: List of entry dicts or CSV row strings. Dicts must
+                  contain ``"taper"``, ``"x"``, ``"y"``, ``"radius"``,
+                  ``"data_type"``, ``"time"``, ``"param"`` (plus optional
+                  ``"z"``, ``"z_range"``, ``"aniso"``, ``"rotation"``).
+                  Wildcard ``"*"`` can be used to expand entries across all
+                  known values for that field.
+                - **dict**: Pre-built ``{(data_type, time, param): LocalizationEntry}``
+                  dict (rarely used; prefer the other formats).
+
+
+        data : pd.DataFrame, optional
+            Observed data whose **index** contains the assimilation time
+            steps (must match the ``time`` field in each CSV row) and
+            whose **columns** are the data-type names (e.g.
+            ``"WOPR PRO1"``). Required for ``__call__`` to produce output.
+
+        parameters : list of str, optional
+            Ordered list of state parameter names (e.g.
+            ``["permx", "poro"]``). Determines which parameters receive
+            a localization mask and the stacking order in the output.
+
+        ensemble_size : int, optional
+            Ensemble size *Ne*. Only affects the Furrer-Bengtsson kernel
+            (``taper_func = "fb"``). Default: ``None`` (``"fb"`` falls
+            back to *Ne* = 50).
+
+        prior_info : dict, optional
+            Per-parameter grid sizes. Required only when a parameter
+            appears in ``parameters`` but has **no** localization entry
+            in the CSV; such parameters receive an all-zero weight column
+            whose length is taken from this dict::
+
+                {"poro": {"nx": 20, "ny": 20, "nz": 1}}
+
+        Notes
+        -----
+        **CSV row format**
+
+        Each entry is a single space-separated line with 11 fields
+        (or 12 if the data-type name contains a space)::
+
+            taper  x_pos  y_pos  z_pos  radius  z_range  aniso  rotation  data_type  time  param
+
+        For two-word data types (e.g. ``WOPR PRO1``) use 12 fields::
+
+            taper  x_pos  y_pos  z_pos  radius  z_range  aniso  rotation  word1  word2  time  param
+
+        Field descriptions:
+
+        - **taper** — kernel tag: ``gc``, ``fb``, or ``region``.
+        - **x_pos** — observation x-cell index on the grid (0-based), along the ``nx`` axis.
+        - **y_pos** — observation y-cell index on the grid (0-based), along the ``ny`` axis.
+        - **z_pos** — observation layer index on the grid (0-based).
+        - **radius** — kernel half-radius in grid cells. For ``gc`` the
+          full support spans ``2 × radius`` cells from the center.
+        - **z_range** — ``":"`` to spread the kernel across all *nz*
+          layers, or an integer to restrict it to that single layer.
+        - **aniso** — anisotropy ratio (x-axis scaling factor). Use
+          ``1.0`` for isotropic kernels; ``2.0`` compresses the kernel
+          to half-width in the x-direction.
+        - **rotation** — clockwise rotation of the kernel in degrees.
+          Use ``0.0`` for axis-aligned kernels.
+        - **data_type** — observation type name, case-insensitive. Must
+          match a column in the ``data`` DataFrame.
+        - **time** — assimilation time step; must match an index value
+          of the ``data`` DataFrame.
+        - **param** — state parameter name, case-insensitive. Must appear
+          in the ``parameters`` list.
+
+        Examples
+        --------
+        TOML config using an external CSV file (recommended for many
+        observation types or time steps):
+
+        ```toml
+        [dataassim.localization]
+        name       = "distance_loc"
+        field      = [1, 20, 20]    # [nz, nx, ny]
+        taper_func = "gc"
+        "loc_entries.csv" = true    # key = filename; value is ignored
+        ```
+
+        Example ``loc_entries.csv`` (Gaspari-Cohn, isotropic, all layers):
+
+        ```
+        gc 10 10 0  6 : 1.0  0.0  pressure    400.0 permx
+        gc 10 10 0  6 : 1.0  0.0  pressure    800.0 permx
+        gc  5 15 0  4 : 1.0  0.0  wopr pro1   400.0 permx
+        gc  5 15 0  4 : 2.0 30.0  wopr pro1   800.0 permx
+        ```
+
+        TOML config using the Furrer-Bengtsson kernel with active-cell
+        mask and anisotropic entries in the CSV:
+
+        ```toml
+        [dataassim.localization]
+        name       = "distance_loc"
+        field      = [2, 30, 40]    # two-layer, 30×40 lateral grid
+        taper_func = "fb"
+        actnum     = "active.npz"
+        "loc_entries.csv" = true
+        ```
+
+        ``loc_entries.csv`` restricting each observation to layer 0 only
+        (``z_range = 0``) with anisotropic, rotated kernel:
+
+        ```
+        fb  8 12 0 6 0 2.0 45.0 wopr pro1 400.0 permx
+        fb 15  5 0 8 0 1.0  0.0 wwct pro2 400.0 permx
+        ```
+
+        Python config using the ``entries`` key with a list of dicts
+        (modern preferred approach):
+
+        ```python
+        info = {
+            "field": [1, 20, 20],
+            "taper_func": "gc",
+            "entries": [
+                {
+                    "taper": "gc",
+                    "x": 10, "y": 10, "z": 0,
+                    "radius": 6,
+                    "z_range": ":",
+                    "aniso": 1.0, "rotation": 0.0,
+                    "data_type": "pressure",
+                    "time": 400.0,
+                    "param": "permx",
+                },
+                {
+                    "taper": "gc",
+                    "x": 5, "y": 15, "z": 0,
+                    "radius": 4,
+                    "z_range": ":",
+                    "aniso": 1.0, "rotation": 0.0,
+                    "data_type": "wopr pro1",
+                    "time": 400.0,
+                    "param": "permx",
+                },
+            ]
+        }
+        ```
+
+        Wildcard expansion in ``entries`` (apply one config to all data types):
+
+        ```python
+        info = {
+            "field": [1, 20, 20],
+            "taper_func": "gc",
+            "entries": [
+                {
+                    "taper": "gc",
+                    "x": 10, "y": 10, "z": 0,
+                    "radius": 6,
+                    "z_range": ":",
+                    "aniso": 1.0, "rotation": 0.0,
+                    "data_type": "*",      # expands to all data types
+                    "time": "*",           # expands to all times
+                    "param": "permx",
+                },
+            ]
+        }
+        ```
+        """
+        if isinstance(info, list):
+            info = list_to_dict(info)
+
+        # -- shared config (field shape + actnum) from base class
+        self.field, self.actnum = self.config_common(info)
+
+        # -- store all call-time defaults as instance attributes
+        self.parameters    = [parameters] if isinstance(parameters, str) else parameters
+        self.prior_info    = prior_info if prior_info is not None else {}
+        self.ensemble_size = ensemble_size
+
+        # -- select and instantiate the kernel (optional; entry rows may supply it instead)
+        taperfunc = info.get("taper_func")
+        if taperfunc is not None and taperfunc not in self._kernel_map:
+            raise ValueError(
+                f"Unknown taper_func '{taperfunc}'. "
+                f"Supported: {list(self._kernel_map)}"
+            )
+
+        # -- data and derived index/type lists
+        self.data = data
+        if self.data is not None:
+            self.data_indices = list(self.data.index)
+            self.data_types   = list(self.data.columns)
+        else:
+            self.data_indices = None
+            self.data_types   = None
+
+        # -- parse config entries and precompute kernel masks
+        self._entries: Dict[Tuple, LocalizationEntry] = (
+            self._parse_config(info) if self.data_indices is not None else {}
+        )
+        self._mask_cache: Dict[tuple, np.ndarray] = self._build_mask_cache()
+
+    # ------------------------------------------------------------------
+    # Public interface
+    # ------------------------------------------------------------------
+
+    def __call__(
+        self,
+        curr_data:  Union[list, None] = None,
+        curr_time:  Union[list, None] = None,
+        curr_param: Union[list, None] = None,
+    ) -> sparse.spmatrix:
+        """
+        Build the sparse localization operator for the current assimilation step.
+
+        Parameters
+        ----------
+        curr_data : list of str, optional
+            Data types to include. Defaults to ``self.data_types``.
+        curr_time : list, optional
+            Time indices to include. Defaults to ``self.data_indices``.
+        curr_param : list of str, optional
+            State parameters to update. Defaults to ``self.parameters``.
+
+        Returns
+        -------
+        scipy.sparse matrix, shape (n_active_cells, n_obs)
+            Sparse localization operator.
+        """
+        curr_data  = self.data_types   if curr_data  is None else curr_data
+        curr_time  = self.data_indices if curr_time  is None else curr_time
+        curr_param = self.parameters   if curr_param is None else curr_param
+
+        loc_blocks = []
+
+        for time in curr_time:
+            for data_name in curr_data:
+
+                cell  = self.data.loc[time, data_name]
+                n_obs = len(cell) if hasattr(cell, "__len__") else 1
+                if n_obs <= 0:
+                    continue
+
+                obs_blocks = [[] for _ in range(n_obs)]
+
+                for param in curr_param:
+                    key = (data_name.lower(), time, param.lower())
+                    if key in self._entries and self._entries[key].taper is not None:
+                        mask = self._resolve_mask(key)
+                        for i in range(n_obs):
+                            obs_blocks[i].append(mask)
+                    else:
+                        zero_masks = self._zero_mask(param, n_obs)
+                        for i in range(n_obs):
+                            obs_blocks[i].append(zero_masks[i])
+
+                for blocks in obs_blocks:
+                    sparse_blocks = [sparse.csc_matrix(b.reshape(1, -1)) for b in blocks]
+                    loc_blocks.append(
+                        sparse.hstack(sparse_blocks) if len(sparse_blocks) > 1
+                        else sparse_blocks[0]
+                    )
+
+        return sparse.vstack(loc_blocks).transpose()
+
+    # ------------------------------------------------------------------
+    # Config parsing
+    # ------------------------------------------------------------------
+
+    @staticmethod
+    def _entry_from_legacy(raw) -> LocalizationEntry:
+        """Convert one entry of a pickled localization file to a :class:`LocalizationEntry`.
+
+        Those files hold plain dicts -- ``taper_func``, ``position``, ``range`` as
+        ``[radius, z_range]``, ``anisotropi`` as ``[ratio, rotation]``, and ``file`` for
+        the ``import`` taper. They used to be returned as-is, so the first thing that
+        asked for ``.taper`` raised ``AttributeError: 'dict' object has no attribute
+        'taper'`` and no pickled mask file could be used at all.
+        """
+        if isinstance(raw, LocalizationEntry):
+            return raw
+        if not isinstance(raw, dict):
+            raise TypeError(f"Localization pickle holds {type(raw).__name__}, expected a dict per entry.")
+
+        taper = raw.get("taper_func")
+        if taper is None:                       # a skeleton entry: no localization here
+            return LocalizationEntry(taper=None, positions=None, radius=None, z_range=None)
+
+        if taper == "import":
+            return LocalizationEntry(
+                taper="import", positions=None, radius=None,
+                z_range=raw.get("range"), filepath=raw.get("file"),
+            )
+
+        # ``range`` is [radius, z_range]; older files sometimes wrote the radius alone.
+        loc_range = raw.get("range")
+        if isinstance(loc_range, (list, tuple)):
+            radius, z_range = loc_range[0], (loc_range[1] if len(loc_range) > 1 else ":")
+        else:
+            radius, z_range = loc_range, ":"
+
+        aniso = raw.get("anisotropi") or [1.0, 0.0]
+
+        return LocalizationEntry(
+            taper            = taper,
+            positions        = raw.get("position"),
+            radius           = int(radius) if radius is not None else None,
+            z_range          = str(z_range),
+            anisotropy_ratio = float(aniso[0]),
+            rotation_deg     = float(aniso[1]),
+        )
+
+    def _parse_config(self, info: dict) -> Dict[Tuple, LocalizationEntry]:
+        """Parse localization config into a ``(data_type, time, param)`` entry dict."""
+
+        # -- pickle shortcut
+        for v in info.values():
+            if str(v).endswith((".p", ".pkl")):
+                with open(v, "rb") as f:
+                    raw = pickle.load(f)
+                return {
+                    k: self._entry_from_legacy(v)
+                    for k, v in raw.items()
+                    if isinstance(k, tuple) and len(k) == 3
+                }
+
+        # -- skeleton: one empty entry per (data_type, time, param) combo
+        entries: Dict[Tuple, LocalizationEntry] = {
+            (datum.lower(), time, param.lower()): LocalizationEntry(
+                taper=None, positions=None, radius=None, z_range=None
+            )
+            for time  in self.data_indices
+            for datum in self.data_types
+            for param in self.parameters
+        }
+
+        # -- read rows: CSV file, inline entries list, or legacy comma-separated key
+        entries_val = info.get("entries")
+        csv_key = next((k for k in info if str(k).endswith(".csv")), None)
+        if isinstance(entries_val, str):
+            with open(entries_val) as f:
+                rows = [item for sublist in csv.reader(f) for item in sublist]
+            self._parse_rows(rows, entries)
+        elif entries_val is not None:
+            self._parse_entries(entries_val, entries)
+        elif csv_key:
+            with open(csv_key) as f:
+                rows = [item for sublist in csv.reader(f) for item in sublist]
+            self._parse_rows(rows, entries)
+        else:
+            # legacy: single comma-separated dict key
+            rows = next(
+                (str(k).split(",") for k in info if len(str(k).split(",")) > 1),
+                [],
+            )
+            self._parse_rows(rows, entries)
+
+    # ------------------------------------------------------------------
+    # Mask caching
+    # ------------------------------------------------------------------
+
+        return entries
+
+    @staticmethod
+    def _parse_entries(
+        entry_list: list,
+        entries: Dict[Tuple, "LocalizationEntry"],
+    ) -> None:
+        """Fill *entries* from a list of dicts (preferred API) or row strings."""
+        all_data   = {k[0] for k in entries}
+        all_times  = {k[1] for k in entries}
+        all_params = {k[2] for k in entries}
+
+        for item in entry_list:
+            if isinstance(item, str):
+                # accept plain row strings inside the list too
+                DistanceLocalization._parse_rows([item], entries)
+                continue
+
+            dt  = item.get("data_type", "*")
+            t   = item.get("time", "*")
+            par = item.get("param", "*")
+
+            # "*" expands to every known value for that field
+            data_types = all_data   if dt  == "*" else {dt.lower()}
+            times      = all_times  if t   == "*" else {_parse_time(str(t))}
+            params     = all_params if par == "*" else {par.lower()}
+
+            loc_entry = LocalizationEntry(
+                taper            = item["taper"],
+                positions        = [[int(item["x"]), int(item["y"]), int(item.get("z", 0))]],
+                radius           = int(item["radius"]),
+                z_range          = item.get("z_range", ":"),
+                anisotropy_ratio = float(item.get("aniso", 1.0)),
+                rotation_deg     = float(item.get("rotation", 0.0)),
+            )
+            for key in [(d, ti, p) for d in data_types for ti in times for p in params]:
+                if key in entries:
+                    entries[key] = loc_entry
+
+    @staticmethod
+    def _parse_rows(
+        rows: list,
+        entries: Dict[Tuple, "LocalizationEntry"],
+    ) -> None:
+        """Fill *entries* from a list of space-separated row strings."""
+        all_data   = {k[0] for k in entries}
+        all_times  = {k[1] for k in entries}
+        all_params = {k[2] for k in entries}
+
+        for row in rows:
+            parts = row.split()
+            if not parts:
+                continue
+
+            if parts[0] == 'import':
+                if len(parts) == 6:
+                    key = (parts[3].lower(), _parse_time(parts[4]), parts[5].lower())
+                else:
+                    key = (f"{parts[3].lower()} {parts[4].lower()}",
+                           _parse_time(parts[5]), parts[6].lower())
+                if key not in entries:
+                    continue
+                entries[key] = LocalizationEntry(
+                    taper     = 'import',
+                    positions = None,
+                    radius    = None,
+                    z_range   = parts[2],
+                    filepath  = parts[1],
+                )
+                continue
+
+            if len(parts) == 11:
+                dt, t, par = parts[8].lower(), parts[9], parts[10].lower()
+            else:
+                dt  = f"{parts[8].lower()} {parts[9].lower()}"
+                t   = parts[10]
+                par = parts[11].lower()
+
+            data_types = all_data   if dt  == "*" else {dt}
+            times      = all_times  if t   == "*" else {_parse_time(t)}
+            params     = all_params if par == "*" else {par}
+
+            loc_entry = LocalizationEntry(
+                taper            = parts[0],
+                positions        = [[int(float(parts[1])),
+                                     int(float(parts[2])),
+                                     int(float(parts[3]))]],
+                radius           = int(parts[4]),
+                z_range          = parts[5],
+                anisotropy_ratio = float(parts[6]),
+                rotation_deg     = float(parts[7]),
+            )
+            for key in [(d, ti, p) for d in data_types for ti in times for p in params]:
+                if key in entries:
+                    entries[key] = loc_entry
+
+    # ------------------------------------------------------------------
+    # Mask caching
+    # ------------------------------------------------------------------
+
+    def _build_mask_cache(self) -> Dict[tuple, np.ndarray]:
+        """Precompute unique spatial kernel arrays for all active entries."""
+        cache: Dict[tuple, np.ndarray] = {}
+        for entry in self._entries.values():
+            if entry.taper is None:
+                continue
+            key = self._cache_key(entry)
+            if key not in cache:
+                if entry.taper == 'import':
+                    data = np.load(entry.filepath)
+                    arr  = data[data.files[0]] if hasattr(data, 'files') and data.files else data
+                    cache[key] = arr.reshape(self.field)   # ensure (nz, nx, ny)
+                else:
+                    kernel = self._kernel_map[entry.taper]()
+                    cache[key] = kernel.build(
+                        radius           = entry.radius,
+                        anisotropy_ratio = entry.anisotropy_ratio,
+                        rotation_deg     = entry.rotation_deg,
+                        field_shape      = self.field,
+                        ensemble_size    = self.ensemble_size,
+                    )
+        return cache
+
+    @staticmethod
+    def _cache_key(entry: LocalizationEntry) -> tuple:
+        if entry.taper == 'import':
+            return ('import', entry.filepath)
+        return (entry.taper, entry.radius, entry.anisotropy_ratio, entry.rotation_deg)
+
+    # ------------------------------------------------------------------
+    # Call-time helpers
+    # ------------------------------------------------------------------
+
+    def _resolve_mask(self, key: Tuple[str, float, str]) -> np.ndarray:
+        """Return the repositioned spatial mask for an entry key, over the active cells.
+
+        The kernel is placed on the full grid, but the state holds only the active
+        cells, and :meth:`_zero_mask` already reduces to them. Returning the full grid
+        here made the two disagree: a localized parameter contributed one row per grid
+        cell and an unlocalized one a row per active cell, so the operator came out
+        with the wrong number of rows altogether.
+        """
+        entry = self._entries[key]
+        kernel = self._mask_cache[self._cache_key(entry)]
+        if entry.z_range == ":":
+            masks = [
+                self._place_kernel(kernel, [pos[0], pos[1], z])
+                for pos in entry.positions
+                for z in range(self.field[0])
+            ]
+        else:
+            masks = []
+
+            for pos in entry.positions:
+                z_center = pos[2]
+                z_range = int(entry.z_range)
+
+                z_min = max(0, z_center - z_range)
+                z_max = min(self.field[0] - 1, z_center + z_range)
+
+                for z in range(z_min, z_max + 1):
+                    masks.append(
+                        self._place_kernel(kernel, [pos[0], pos[1], z])
+                    )
+
+        mask = np.maximum.reduce(masks)
+        if self.actnum is None:
+            return mask
+        # The caller flattens with reshape(1, -1), so select on the same C-order
+        # flattening rather than on the grid axes.
+        return mask.ravel()[self.actnum]
+
+    def _place_kernel(self, kernel: np.ndarray, position: List[int]) -> np.ndarray:
+        """
+        Place a compact 2-D kernel patch at ``position`` on the 3-D grid.
+
+        Uses clip arithmetic to handle all grid edges uniformly.
+
+        Parameters
+        ----------
+        kernel : np.ndarray, shape (kx, ky)
+            Built ``(nx, ny)``-major like the field, so its first axis is x.
+        position : [x_pos, y_pos, z_pos]
+        """
+        result             = np.zeros(self.field)
+        nz, nx, ny         = self.field
+        kx, ky             = kernel.shape
+        x_pos, y_pos, z_pos = position
+
+        x_min = x_pos - kx // 2
+        x_max = x_min + kx
+        y_min = y_pos - ky // 2
+        y_max = y_min + ky
+
+        gx0 = max(0, x_min)
+        gx1 = min(nx, x_max)
+        gy0 = max(0, y_min)
+        gy1 = min(ny, y_max)
+
+        kx0 = gx0 - x_min
+        kx1 = kx0 + (gx1 - gx0)
+        ky0 = gy0 - y_min
+        ky1 = ky0 + (gy1 - gy0)
+
+        result[z_pos, gx0:gx1, gy0:gy1] = kernel[kx0:kx1, ky0:ky1]
+        return result
+
+    def _zero_mask(self, param: str, n_obs: int) -> List[np.ndarray]:
+        """Return zero-valued masks for a parameter with no localization entry."""
+        p       = self.prior_info[param]
+        n_cells = p["nx"] * p["ny"] * p["nz"]
+
+        if n_obs > 1:
+            mat = np.zeros((n_obs, n_cells))
+            return [mat[i, self.actnum] if self.actnum is not None else mat[i]
+                    for i in range(n_obs)]
+
+        vec = np.zeros(n_cells)
+        return [vec[self.actnum] if self.actnum is not None else vec]
diff --git a/src/pipt/localization/factory.py b/src/pipt/localization/factory.py
new file mode 100644
index 00000000..50975042
--- /dev/null
+++ b/src/pipt/localization/factory.py
@@ -0,0 +1,133 @@
+"""Build a localization strategy from its config, by name.
+
+The strategies are looked up in :data:`LOCALIZATIONS`, a table from the
+config's ``name`` to a builder. Adding a strategy is one call to
+:func:`register_localization`; nothing here needs editing.
+"""
+
+from typing import Callable, Union
+
+import pandas as pd
+
+from input_output.config import ConfigError
+from pipt.localization.common import normalize_parsed_info
+
+__all__ = [
+    "LOCALIZATIONS",
+    "UNSUPPORTED_LOCALIZATIONS",
+    "available_localizations",
+    "build_localization_instance",
+    "register_localization",
+]
+
+#: Modes a config may still select that this line cannot run, and why. Both worked
+#: before the update schemes were restructured; each needs machinery that was rewritten
+#: around it and neither was carried across. Refusing here, while the config is being
+#: read, beats failing part way through the first update or -- as local analysis used
+#: to -- reporting a misfit for a posterior that is still the prior.
+UNSUPPORTED_LOCALIZATIONS: dict[str, str] = {
+    "localanalysis": (
+        "Local analysis is not supported. It updates each parameter against its own "
+        "subset of the data, which needs the per-subset observation machinery "
+        "(`_ext_obs`, `current_state`, `pert_preddata`) that the scheme rewrite "
+        "replaced with a single DataLayout built once at setup. Use distance "
+        "localization (`name = \"distance_loc\"`) or the auto-adaptive taper "
+        "(`name = \"autoadaloc\"`) instead."
+    ),
+    "parallel_update": (
+        "The parallel update is not supported. It was the fallback when a "
+        "LOCALIZATION block named no other mode, and it needs the same per-subset "
+        "observation machinery as local analysis. Name the mode you want: "
+        "`autoadaloc`, `distance_loc`, or remove the LOCALIZATION block to assimilate "
+        "without localization."
+    ),
+}
+
+
+def _build_autoadaloc(*, info, rng=None, **_):
+    from pipt.localization.auto_ada_loc import AutoAdaptiveLocalization
+    return AutoAdaptiveLocalization(info, rng=rng)
+
+
+def _build_distance(*, info, data, parameters, ensemble_size, prior_info, **_):
+    from pipt.localization.distance_localization import DistanceLocalization
+    return DistanceLocalization(
+        info=info,
+        data=data,
+        parameters=parameters,
+        ensemble_size=ensemble_size,
+        prior_info=prior_info,
+    )
+
+
+#: Config ``name`` -> builder. Every builder is called with the same keyword
+#: arguments (``info`` plus everything :func:`build_localization_instance`
+#: receives) and takes what it needs.
+LOCALIZATIONS: dict[str, Callable[..., object]] = {
+    "autoadaloc": _build_autoadaloc,
+    "distance_loc": _build_distance,
+}
+
+
+def register_localization(name: str, builder: Callable[..., object], *, overwrite: bool = False) -> None:
+    """Make a localization strategy selectable as ``localization = {name = ...}``.
+
+    Parameters
+    ----------
+    name : str
+        The value of the config's ``name`` key.
+    builder : callable
+        Called as ``builder(info=..., data_indices=..., data_types=...,
+        parameters=..., ensemble_size=..., data=..., prior_info=..., rng=...)``; it may
+        ignore what it does not need. Returns the strategy object, which the
+        analyses use through its ``name`` attribute and by calling it.
+    overwrite : bool, optional
+        Allow replacing an existing entry. Off by default, so two packages
+        claiming the same name is an error rather than a load-order lottery.
+    """
+    key = str(name).lower()
+    if key in LOCALIZATIONS and not overwrite:
+        raise ValueError(f"Localization {key!r} is already registered; pass overwrite=True to replace it.")
+    LOCALIZATIONS[key] = builder
+
+
+def available_localizations() -> list[str]:
+    """The registered localization names, sorted."""
+    return sorted(LOCALIZATIONS)
+
+
+def build_localization_instance(
+    parsed_info: Union[dict, list],
+    data_indices: Union[list, None] = None,
+    data_types: Union[list, None] = None,
+    parameters: Union[list, None] = None,
+    ensemble_size: Union[int, None] = None,
+    data: Union[pd.DataFrame, None] = None,
+    prior_info: Union[dict, None] = None,
+    rng=None,
+) -> object:
+    """Create the localization strategy the config names.
+
+    ``rng`` is the run's random stream, for strategies that draw (the
+    auto-adaptive one shuffles the ensemble to estimate a noise level).
+    """
+    info = normalize_parsed_info(parsed_info)
+    name = info.pop("name", None)
+    if name is None:
+        raise ConfigError(f"Localization config has no 'name'; expected one of {available_localizations()}.")
+    key = str(name).lower()
+    if key in UNSUPPORTED_LOCALIZATIONS:
+        raise ConfigError(UNSUPPORTED_LOCALIZATIONS[key])
+    builder = LOCALIZATIONS.get(key)
+    if builder is None:
+        raise ConfigError(f"Unknown localization type {name!r}; expected one of {available_localizations()}.")
+    return builder(
+        info=info,
+        data_indices=data_indices,
+        data_types=data_types,
+        parameters=parameters,
+        ensemble_size=ensemble_size,
+        data=data,
+        prior_info=prior_info,
+        rng=rng,
+    )
diff --git a/src/pipt/localization/local_analysis.py b/src/pipt/localization/local_analysis.py
new file mode 100644
index 00000000..16b64735
--- /dev/null
+++ b/src/pipt/localization/local_analysis.py
@@ -0,0 +1,142 @@
+"""Local-analysis localization strategy. Not functional at present; see the CHANGELOG's Known issues."""
+import pipt.misc_tools.analysis_tools as at
+import numpy as np
+from typing import Union
+from scipy.spatial import distance
+from pipt.localization.common import (
+    LocalizationBase,
+    LocalizationConfigBuilder,
+)
+
+__all__ = ["LocalAnalysisLocalization", "_calc_loc", "_calc_distance"]
+
+
+class LocalAnalysisLocalization(LocalizationBase):
+    """Local-analysis strategy carrying mode-specific localization metadata."""
+
+    name = "localanalysis"
+
+    def __init__(
+            self,
+            info: Union[dict, list],
+            data_indices: Union[list, None] = None,
+            data_types: Union[list, None] = None,
+            parameters: Union[list, None] = None,
+            ensemble_size: Union[int, None] = None,
+        ):
+        """
+        Initialize the LocalAnalysisLocalization instance.
+
+        Parameters
+        ----------
+        info : dict or list
+            Localization configuration information.
+        data_indices : list
+            Indices of the data to be assimilated.
+        data_types : list
+            Types of the data to be assimilated.
+        parameters : list
+            List of free parameters for the assimilation.
+        ensemble_size : int
+            Size of the ensemble used in the assimilation.
+        """
+        config = LocalizationConfigBuilder(info)
+        loc_info = config.build(
+            data_index=data_indices,
+            data_types=data_types,
+            parameters=parameters,
+            ne=ensemble_size,
+        )
+        super().__init__(loc_info)
+
+
+def _calc_loc(max_dist, distance, prior_info, loc_type, ne):
+    """Compute local-analysis weights for distance-based localization."""
+    variance = prior_info["variance"][0]
+    mask = np.zeros(len(distance))
+
+    if loc_type == "fb":
+        for i in range(len(distance)):
+            if distance[i] < max_dist:
+                tmp = variance - variance * (
+                    1.5 * np.abs(distance[i]) / max_dist - 0.5 * (distance[i] / max_dist) ** 3
+                )
+            else:
+                tmp = 0
+            mask[i] = (ne * tmp ** 2) / ((tmp ** 2) * (ne + 1) + variance ** 2)
+
+    elif loc_type == "gc":
+        for count, dist_value in enumerate(np.abs(distance)):
+            if dist_value <= max_dist:
+                tmp = (
+                    -(1.0 / 4.0) * (dist_value / max_dist) ** 5
+                    + (1.0 / 2.0) * (dist_value / max_dist) ** 4
+                    + (5.0 / 8.0) * (dist_value / max_dist) ** 3
+                    - (5.0 / 3.0) * (dist_value / max_dist) ** 2
+                    + 1
+                )
+            elif dist_value <= 2 * max_dist:
+                tmp = (
+                    (1.0 / 12.0) * (dist_value / max_dist) ** 5
+                    - (1.0 / 2.0) * (dist_value / max_dist) ** 4
+                    + (5.0 / 8.0) * (dist_value / max_dist) ** 3
+                    + (5.0 / 3.0) * (dist_value / max_dist) ** 2
+                    - 5.0 * (dist_value / max_dist)
+                    + 4.0
+                    - (2.0 / 3.0) * (max_dist / dist_value)
+                )
+            else:
+                tmp = 0.0
+            mask[count] = tmp
+
+    return mask[np.newaxis, :]
+
+def _calc_distance(data_pos, index_unique, current_data_list, assim_index, obs_data, pred_data, param_pos):
+    """
+    Calculate the distance between data and parameters.
+
+    Parameters
+    ----------
+    data_pos : dict
+        Dictionary containing the position of the data.
+
+    index_unique : bool
+        Boolean that determines if the position is unique.
+
+    current_data_list : list
+        List containing the names of the data that should be evaluated.
+
+    assim_index : int
+        The index of the data to be evaluated.
+
+    obs_data : list of dict
+        List of dictionaries containing the data.
+
+    pred_data : list of dict
+        List of dictionaries containing the predictions.
+
+    param_pos : list of tuple
+        List of tuples representing the position of the parameters.
+
+    Returns
+    -------
+        - dist: list of euclidean distance between the data/parameter pair.
+    """
+    # distance to data if distance based localization
+    if index_unique is False:
+        dist = []
+        for dat in current_data_list:
+            for indx in assim_index[1]:
+                indx_data_pos = data_pos[dat][indx]
+                if obs_data[indx] is not None and obs_data[indx][dat] is not None:
+                    # add shortest distance
+                    dist.append(min(distance.cdist(indx_data_pos, param_pos).flatten()))
+    else:
+        dist = []
+        for data in current_data_list:
+            elem_data_pos = data_pos[data]
+            obs, _ = at.aug_obs_pred_data(obs_data, pred_data, assim_index, [data])
+            dist.extend(
+                len(obs)*[min(distance.cdist(elem_data_pos, param_pos).flatten())])
+
+    return dist
diff --git a/src/pipt/loop/__init__.py b/src/pipt/loop/__init__.py
deleted file mode 100644
index 5ef61a98..00000000
--- a/src/pipt/loop/__init__.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Main loop for running data assimilation."""
diff --git a/src/pipt/loop/assimilation.py b/src/pipt/loop/assimilation.py
deleted file mode 100644
index d280547b..00000000
--- a/src/pipt/loop/assimilation.py
+++ /dev/null
@@ -1,541 +0,0 @@
-"""Descriptive description."""
-
-# External imports
-import numpy as np
-from tqdm import tqdm
-from p_tqdm import p_map
-import pickle
-from copy import deepcopy
-import sys
-import os
-from shutil import rmtree
-import datetime as dt
-import random
-import psutil
-from copy import copy
-from importlib import import_module
-
-# Internal imports
-from pipt.misc_tools.qaqc_tools import QAQC
-from pipt.loop.ensemble import Ensemble
-from misc.system_tools.environ_var import OpenBlasSingleThread
-from pipt.misc_tools import analysis_tools as at
-
-import pipt.misc_tools.extract_tools as extract
-import pipt.misc_tools.ensemble_tools as entools
-
-
-class Assimilate:
-    """
-    Class for iterative ensemble-based methods. This loop is similar/equal to a deterministic/optimization loop, but
-    since we use ensemble-based method, we need to invoke `pipt.fwd_sim.ensemble.Ensemble` to get correct hierarchy of
-    classes. The iterative loop will go until the max. iterations OR convergence has been met. Parameters for both these
-    stopping criteria have to be given by the user through methods in their `pipt.update_schemes` class. Note that only
-    iterative ensemble smoothers can be implemented with this loop (at the moment). Methods needed to be provided by
-    user in their update_schemes class:  
-
-    `calc_analysis`  
-    `check_convergence`  
-
-    % Copyright (c) 2019-2022 NORCE, All Rights Reserved. 4DSEIS
-    """
-    # TODO: Sequential iterative loop
-
-    def __init__(self, ensemble: Ensemble):
-        """
-        Initialize by passing the PIPT init. file up the hierarchy.
-        """
-        # Internalize ensemble and simulator class instances
-        self.ensemble = ensemble
-
-        # Save folder
-        if 'nosave' not in self.ensemble.keys_da:
-            self.save_folder = self.ensemble.keys_da.get('savefolder', 'SaveOutputs')
-            if not os.path.exists(self.save_folder):
-                os.makedirs(self.save_folder)
-
-        if self.ensemble.restart is False:
-            # Default max. iter if not defined in the ensemble
-            if hasattr(ensemble, 'max_iter'):
-                self.max_iter = self.ensemble.max_iter
-            else:
-                self.max_iter = extract.extract_maxiter(self.ensemble.keys_da)
-
-            # Within variables
-            self.why_stop = None    # Output of why iter. loop stopped
-
-            self.scale_val = []  # Used to scale seismic data
-
-            # This feature is removed
-            # Initialize temporary storage of state variable during the assimilation (if option is supplied in DATAASSIM
-            # part). Save initially regardless of which option you have chosen as long as it is not 'no'
-            # if 'tempsave' in self.ensemble.keys_da and self.ensemble.keys_da['tempsave'] != 'no':
-            #     self.ensemble.save_temp_state_iter(0, self.max_iter)  # save init. ensemble
-
-    def run(self):
-        """
-        The general loop implemented here is:
-
-        
    
-            
  1. Forecast/forward simulation
    2. 
-            
  2. Check for convergence
    3. 
-            
  3. If convergence have not been achieved, do analysis/update
    4. 
-        

-
-        % Copyright (c) 2019-2022 NORCE, All Rights Reserved. 4DSEIS
-        """
-        # TODO: Implement a 'calc_sensitivity' method in the loop. For now it is assumed that the sensitivity is
-        # calculated in 'calc_analysis' using some kind of ensemble approximation.
-
-        # Init. while loop condition variable
-        conv = False
-        success_iter = True
-
-        # Initiallize progressbar
-        #pbar_out = tqdm(total=self.max_iter, desc='Iterations (Obj. func. val: )', position=0)
-
-        # Check if we want to perform a Quality Assurance of the forecast
-        qaqc = None
-        if ('qa' in self.ensemble.sim.input_dict) or ('qc' in self.ensemble.keys_da):
-            qaqc = QAQC(
-                self.ensemble.keys_da|self.ensemble.sim.input_dict,
-                self.ensemble.obs_data, 
-                self.ensemble.datavar, 
-                self.ensemble.logger,
-                self.ensemble.prior_info, 
-                self.ensemble.sim, 
-                entools.matrix_to_dict(self.ensemble.prior_enX, self.ensemble.idX)
-            )
-
-        # Run a while loop until max. iterations or convergence is reached
-        while (self.ensemble.iteration < self.max_iter) and (conv is False):
-            # Add a check to see if this is the prior model
-            
-            if self.ensemble.iteration == 0:
-                # Calc forecast for prior model
-                # Inset 0 as input to forecast all data
-                self.calc_forecast()
-
-                # remove outliers
-                if 'remove_outliers' in self.ensemble.sim.input_dict:
-                    self.remove_outliers()
-
-                if 'qa' in self.ensemble.keys_da:  # Check if we want to perform a Quality Assurance of the forecast
-                    # set updated prediction, state and lam
-                    qaqc.set(
-                        self.ensemble.pred_data, 
-                        entools.matrix_to_dict(self.ensemble.enX, self.ensemble.idX), 
-                        self.ensemble.lam
-                    )
-
-                    # Level 1,2 all data, and subspace
-                    qaqc.calc_mahalanobis((1, 'time', 2, 'time', 1, None, 2, None))
-                    qaqc.calc_coverage()  # Compute data coverage
-                    qaqc.calc_kg({'plot_all_kg': True, 'only_log': False, 'num_store': 5})  # Compute kalman gain
-
-                success_iter = True
-
-                # always store prior forcast, unless specifically told not to
-                if 'nosave' not in self.ensemble.keys_da:
-                    np.savez(f'{self.save_folder}/prior_forecast.npz', pred_data=self.ensemble.pred_data)
-
-            # For the remaining iterations we start by applying the analysis and finish by running the forecast
-            else:
-                # Analysis (in the update_scheme class)
-                self.ensemble.calc_analysis()
-
-                if 'qa' in self.ensemble.keys_da and 'screendata' in self.ensemble.keys_da and \
-                        self.ensemble.keys_da['screendata'] == 'yes' and self.ensemble.iteration == 1:
-                    #  need to update datavar, and recompute mahalanobis measures
-                    self.logger.info(
-                        'Recomputing Mahalanobis distance with updated datavar')
-                    qaqc.datavar = self.datavar  # this is updated from calc_analysis
-                    # Level 1,2 all data, and subspace
-                    qaqc.calc_mahalanobis((1, 'time', 2, 'time', 1, None, 2, None))
-
-                # Forecast with the updated state
-                self.calc_forecast()
-
-                if 'remove_outliers' in self.ensemble.keys_da:
-                    self.remove_outliers()
-
-                # Check convergence (in the update_scheme class). Outputs logical variable to tell the while loop to
-                # stop, and a variable telling what criteria for convergence was reached.
-                # Also check if the objective function has been reduced, and use this function to accept the state and
-                # update the lambda values.
-                #
-                conv, success_iter, self.why_stop = self.ensemble.check_convergence()
-
-            # if reduction of objective function -> save the state
-            if success_iter:
-                # More general method to save all relevant information from an iteration analysis/forecast step
-                if 'iterinfo' in self.ensemble.keys_da:
-                    #
-                    self._save_iteration_information()
-                if self.ensemble.iteration > 0:
-                    if 'analysisdebug' in self.ensemble.keys_da:
-                        self._save_analysis_debug()
-                    if 'qc' in self.ensemble.keys_da:  # Check if we want to perform a Quality Control of the updated state
-                        # set updated prediction, state and lam
-                        qaqc.set(
-                            self.ensemble.pred_data,
-                            entools.matrix_to_dict(self.ensemble.enX, self.ensemble.idX), 
-                            self.ensemble.lam
-                        )
-                        qaqc.calc_da_stat()  # Compute statistics for updated parameters
-                    if 'qa' in self.ensemble.keys_da:  # Check if we want to perform a Quality Assurance of the forecast
-                        # set updated prediction, state and lam
-                        qaqc.set(
-                            self.ensemble.pred_data,
-                            entools.matrix_to_dict(self.ensemble.enX, self.ensemble.idX), 
-                            self.ensemble.lam
-                        )
-                        qaqc.calc_mahalanobis(
-                            (1, 'time', 2, 'time', 1, None, 2, None))  # Level 1,2 all data, and subspace
-                        #  qaqc.calc_coverage()  # Compute data coverage
-                        qaqc.calc_kg()  # Compute kalman gain
-
-            # Update iteration counter if iteration was successful
-            if self.ensemble.iteration >= 0 and success_iter is True:
-                if self.ensemble.iteration == 0:
-                    self.ensemble.iteration += 1
-                    #pbar_out.update(1)
-                    # pbar_out.set_description(f'Iterations (Obj. func. val:{self.data_misfit:.1f})')
-                    # self.prior_data_misfit = self.data_misfit
-                    # self.pbar_out.refresh()
-                else:
-                    self.ensemble.iteration += 1
-                    #pbar_out.update(1)
-                    #pbar_out.set_description(
-                    #    f'Iterations (Obj. func. val:{self.ensemble.data_misfit:.1f}'
-                    #    f' Reduced: {100 * (1 - (self.ensemble.data_misfit / self.ensemble.prev_data_misfit)):.0f} %)')
-                    # self.pbar_out.refresh()
-
-            if 'restartsave' in self.ensemble.keys_da and self.ensemble.keys_da['restartsave'] == 'yes':
-                self.ensemble.save()
-
-        # always store posterior forcast and state, unless specifically told not to
-        if 'nosave' not in self.ensemble.keys_da:
-            try: # first try to save as npz file
-                np.savez(f'{self.save_folder}/posterior_state_estimate.npz', **entools.matrix_to_dict(self.ensemble.enX, self.ensemble.idX))
-                np.savez(f'{self.save_folder}/posterior_forecast.npz', **{'pred_data': self.ensemble.pred_data})
-            except: # If this fails, store as pickle
-                with open(f'{self.save_folder}/posterior_state_estimate.p', 'wb') as file:
-                    pickle.dump(entools.matrix_to_dict(self.ensemble.enX, self.ensemble.idX), file)
-                with open(f'{self.save_folder}/posterior_forecast.p', 'wb') as file:
-                    pickle.dump(self.ensemble.pred_data, file)
-
-        # If none of the convergence criteria were met, max. iteration was the reason iterations stopped.
-        if conv is False:
-            reason = 'Iterations stopped due to max iterations reached!'
-        else:
-            reason = 'Convergence was met :)'
-
-        # Save why_stop in Numpy save file
-        # savez('why_iter_loop_stopped', why=self.why_stop, conv_string=reason)
-
-        # Save why_stop in pickle save file
-        why = self.why_stop
-        if why is not None:
-            why['conv_string'] = reason
-        with open(f'{self.save_folder}/why_iter_loop_stopped.p', 'wb') as f:
-            pickle.dump(why, f, protocol=4)
-        # pbar.close()
-        #pbar_out.close()
-        if self.ensemble.prev_data_misfit is not None:
-            out_str = 'Convergence was met.'
-            if self.ensemble.prior_data_misfit > self.ensemble.data_misfit:
-                out_str += f' Obj. function reduced from {self.ensemble.prior_data_misfit:0.1f} ' \
-                           f'to {self.ensemble.data_misfit:0.1f}'
-            #tqdm.write(out_str)
-            self.ensemble.logger(out_str)
-
-    def remove_outliers(self):
-
-        # function to remove ouliers
-
-        # get the cov data
-        prod_obs = np.array([])
-
-        prod_cov = np.array([])
-        prod_pred = np.empty([0, self.ensemble.ne])
-        for i in range(len(self.ensemble.obs_data)):
-            for key in self.ensemble.obs_data[i].keys():
-                if self.ensemble.obs_data[i][key] is not None and self.ensemble.obs_data[i][key].shape == (1,):
-                    prod_obs = np.concatenate((prod_obs, self.ensemble.obs_data[i][key]))
-                    prod_cov = np.concatenate((prod_cov, self.ensemble.datavar[i][key]))
-                    prod_pred = np.concatenate(
-                        (prod_pred, self.ensemble.pred_data[i][key]))
-
-        mat_prod_obs = np.dot(prod_obs.reshape((len(prod_obs), 1)),
-                              np.ones((1, self.ensemble.ne)))
-
-        hm = np.diag(np.dot((prod_pred - mat_prod_obs).T, np.dot(np.expand_dims(prod_cov ** (-1), axis=1),
-                                                                 np.ones((1, self.ensemble.ne))) * (prod_pred - mat_prod_obs)))
-        hm_std = np.std(hm)
-        hm_mean = np.mean(hm)
-        outliers = np.argwhere(np.abs(hm - hm_mean) > 4 * hm_std)
-        print('Outliers: ' + str(np.squeeze(outliers)))
-        members = np.arange(self.ensemble.ne)
-        members = np.delete(members, outliers)
-        for index in outliers.flatten():
-
-            new_index = np.random.choice(members)
-
-            # replace state
-            if self.ensemble.enX_temp is not None:
-                self.ensemble.enX[:, index] = deepcopy(self.ensemble.enX[:, new_index])
-            else:
-                self.ensemble.enX_temp[:, index] = deepcopy(self.ensemble.enX_temp[:, new_index])
-                
-
-            # replace the failed forecast
-            for i, data_ind in enumerate(self.ensemble.pred_data):
-                if self.ensemble.pred_data[i] is not None:
-                    for el in data_ind.keys():
-                        if self.ensemble.pred_data[i][el] is not None:
-                            if type(self.ensemble.pred_data[i][el]) is list:
-                                self.ensemble.pred_data[i][el][index] = deepcopy(
-                                    self.ensemble.pred_data[i][el][new_index])
-                            else:
-                                self.ensemble.pred_data[i][el][:, index] = deepcopy(
-                                    self.ensemble.pred_data[i][el][:, new_index])
-
-    def _save_iteration_information(self):
-        """
-        More general method for saving all relevant information from a analysis/forecast step. Note that this is
-        only performed when there is a reduction in objective function.
-
-        Parameters
-        ----------
-        values : list
-            List of values to be saved. It can also contain a separate Python file.
-
-        If one reads a python file, it is
-        """
-        # Make sure "ANALYSISDEBUG" gives a list
-        if isinstance(self.ensemble.keys_da['iterinfo'], list):
-            saveinfo = self.ensemble.keys_da['iterinfo']
-        else:
-            saveinfo = [self.ensemble.keys_da['iterinfo']]
-
-        for el in saveinfo:
-            if '.py' in el:  # This is a unique python file
-                iter_info_func = import_module(el.strip('.py'))
-                # Note: the function must be named main, and we pass the full current instance of the object.
-                iter_info_func.main(self)
-
-    def _save_analysis_debug(self):
-        """
-        Moved Old analysis debug here to retain consistency.
-
-        !!! danger
-            only class variables can be stored now.
-        """
-        # Init dict. of variables to save
-        save_dict = {}
-
-        # Make sure "ANALYSISDEBUG" gives a list
-        if isinstance(self.ensemble.keys_da['analysisdebug'], list):
-            analysisdebug = self.ensemble.keys_da['analysisdebug']
-        else:
-            analysisdebug = [self.ensemble.keys_da['analysisdebug']]
-
-        # Loop over variables to store in save list
-        for save_typ in analysisdebug:
-            if hasattr(self, save_typ):
-                save_dict[save_typ] = eval('self.{}'.format(save_typ))
-            elif hasattr(self.ensemble, save_typ):
-                save_dict[save_typ] = eval('self.ensemble.{}'.format(save_typ))
-            # Save with key equal variable name and the actual variable
-            elif save_typ == 'state':
-                save_dict['state'] = entools.matrix_to_dict(self.ensemble.enX, self.ensemble.idX)
-            else:
-                print(f'Cannot save {save_typ}, because it is a local variable!\n\n')
-
-        save_dict['savefolder'] = self.save_folder
-
-        # Save the variables
-        at.save_analysisdebug(self.ensemble.iteration, **save_dict)
-
-    def calc_forecast(self):
-        """
-        Calculate the forecast step.
-
-        Run the forward simulator, generating predicted data for the analysis step. First input to the simulator
-        instances is the ensemble of (joint) state to be run and how many to run in parallel. The forward runs are done
-        in a while-loop consisting of the following steps:
-
-                1. Run the simulator for each ensemble member in the background.
-                2. Check for errors during run (if error, correct and run again or abort).
-                3. Check if simulation has ended; if yes, run simulation for the next ensemble members.
-                4. Get results from successfully ended simulations.
-
-        The procedure here is general, hence a simulator used here must contain the initial step of setting up the
-        parameters and steps i-iv, if not an error will be outputted. Initialization of the simulator is done when
-        initializing the Ensemble class (see __init__). The names of the mandatory methods in a simulator are:
-
-                > setup_fwd_sim
-                > run_fwd_sim
-                > check_sim_end
-                > get_sim_results
-
-        Notes
-        -----
-        Parallel run in "ampersand" mode means that it will be started in the background and run independently of the
-        Python script. Hence, check for simulation finished or error must be conducted!
-
-        !!! info
-            It is only necessary to get the results from the forward simulations that corresponds to the observed
-            data at the particular assimilation step. That is, results from all data types are not necessary to
-            extract at step iv; if they are not present in the obs_data (indicated by a None type) then this result does
-            not need to be extracted.
-
-        !!! info
-            It is assumed that no underscore is inputted in DATATYPE. If there are underscores in DATATYPE
-            entries, well, then we may have a problem when finding out which response to extract in get_sim_results below.
-            """
-        # Add an option to load existing sim results. The user must actively create the restart file by renaming an
-        # existing sim_results.p file to restart_sim_results.p.
-        if os.path.exists('restart_sim_results.p'):
-            with open('restart_sim_results.p', 'rb') as f:
-                self.ensemble.pred_data = pickle.load(f)
-            os.rename('restart_sim_results.p', 'sim_results.p')
-            print('--- Restart sim results used ---')
-            return
-
-        # If we are doing an sequential assimilation, such as enkf, we loop over assimilation steps
-        if len(self.ensemble.keys_da['assimindex']) > 1:
-            assim_step = self.ensemble.iteration
-        else:
-            assim_step = 0
-
-        # Get assimilation order as a list where first entry are the string(s) in OBSNAME and second entry are
-        # the associated array(s)
-        if assim_step == 0 or assim_step == len(self.ensemble.keys_da['assimindex']):
-            assim_ind = [self.ensemble.keys_da['obsname'], list(
-                np.concatenate(self.ensemble.keys_da['assimindex']))]
-        else:
-            assim_ind = [self.ensemble.keys_da['obsname'],
-                         self.ensemble.keys_da['assimindex'][assim_step]]
-
-        # Get TRUEDATAINDEX
-        true_order = [self.ensemble.keys_da['obsname'],
-                      self.ensemble.keys_da['truedataindex']]
-
-        # List assim. index
-        if isinstance(true_order[1], list):  # Check if true data prim. ind. is a list
-            true_prim = [true_order[0], [x for x in true_order[1]]]
-        else:  # Float
-            true_prim = [true_order[0], [true_order[1]]]
-        if isinstance(assim_ind[1], list):  # Check if prim. ind. is a list
-            l_prim = [int(x) for x in assim_ind[1]]
-        else:  # Float
-            l_prim = [int(assim_ind[1])]
-
-        # Run forecast. Predicted data solved in self.ensemble.pred_data
-        if self.ensemble.enX_temp is None:
-            self.ensemble.calc_prediction()
-        else:
-            self.ensemble.calc_prediction(enX=self.ensemble.enX_temp)
-
-        # Filter pred. data needed at current assimilation step. This essentially means deleting pred. data not
-        # contained in the assim. indices for current assim. step or does not have obs. data at this index
-        self.ensemble.pred_data = [elem for i, elem in enumerate(self.ensemble.pred_data) if i in l_prim or
-                                   true_prim[1][i] is not None]
-
-        # Scale data if required (currently only one group of data can be scaled)
-        if 'scale' in self.ensemble.keys_da:
-            for pred_data in self.ensemble.pred_data:
-                for key in pred_data:
-                    if key in self.ensemble.keys_da['scale'][0]:
-                        pred_data[key] *= self.ensemble.keys_da['scale'][1]
-
-        # Post process predicted data if wanted
-        if 'post_process_forecast' in self.ensemble.keys_da and self.ensemble.keys_da['post_process_forecast'] == 'yes':
-            self.post_process_forecast()
-
-        # Extra option debug
-        if 'saveforecast' in self.ensemble.sim.input_dict:
-            with open(f'{self.save_folder}/sim_results.p', 'wb') as f:
-                pickle.dump(self.ensemble.pred_data, f)
-
-    def post_process_forecast(self):
-        """
-        Post processing of predicted data after a forecast run
-        """
-        # Temporary storage of seismic data that need to be scaled
-        pred_data_tmp = [None for _ in self.ensemble.pred_data]
-
-        # Loop over pred data and store temporary
-        if self.ensemble.sparse_info is not None:
-            for i, pred_data in enumerate(self.ensemble.pred_data):
-                for key in pred_data:
-                    # Reset vintage
-                    vintage = 0
-
-                    # Store according to sparse_info
-                    if key == self.ensemble.sparse_info['compress_data'] and pred_data[key] is not None:
-                        # If first entry in pred_data_tmp
-                        if pred_data_tmp[i] is None:
-                            pred_data_tmp[i] = {key: pred_data[key]}
-                        else:
-                            pred_data_tmp[i][key] = pred_data[key]
-
-                        # Update vintage
-                        vintage += 1
-
-        # Scaling used in sim2seis
-        if os.path.exists('scale_results.p'):
-            if not self.scale_val:
-                with open('scale_results.p', 'rb') as f:
-                    scale = pickle.load(f)
-                # base the scaling on the first dataset and the first iteration
-                self.scale_val = np.sum(scale[0]) / len(scale[0])
-
-            if self.ensemble.sparse_info is not None:
-                for i in range(len(pred_data_tmp)):  # INDEX
-                    if pred_data_tmp[i] is not None:
-                        for k in pred_data_tmp[i]:  # DATATYPE
-                            if 'sim2seis' in k and pred_data_tmp[i][k] is not None:
-                                pred_data_tmp[i][k] = pred_data_tmp[i][k] / self.scale_val
-
-            else:
-                for i in range(len(self.ensemble.pred_data)):  # TRUEDATAINDEX
-                    for k in self.ensemble.pred_data[i]:  # DATATYPE
-                        if 'sim2seis' in k and self.ensemble.pred_data[i][k] is not None:
-                            self.ensemble.pred_data[i][k] = self.ensemble.pred_data[i][k] / \
-                                self.scale_val
-
-        # If wavelet compression is based on the simulated data, we need to recompute obs_data, datavar and pred_data.
-        if self.ensemble.sparse_info:
-            vintage = 0
-            self.ensemble.data_rec = []
-            for i in range(len(pred_data_tmp)):  # INDEX
-                if pred_data_tmp[i] is not None:
-                    for key in pred_data_tmp[i]:  # DATATYPE
-                        if key == self.ensemble.sparse_info['compress_data']:
-                            if self.ensemble.keys_da['daalg'][1] == 'gies':
-                                self.ensemble.pred_data[i][key] = np.zeros(
-                                    (len(self.ensemble.obs_data[i][key]), self.ensemble.ne+1))
-                            else:
-                                self.ensemble.pred_data[i][key] = np.zeros(
-                                    (len(self.ensemble.obs_data[i][key]), self.ensemble.ne))
-                            for m in range(pred_data_tmp[i][key].shape[1]):
-                                data_array = self.ensemble.compress_manager(pred_data_tmp[i][key][:, m], vintage,
-                                                                    self.ensemble.sparse_info['use_ensemble'])
-                                self.ensemble.pred_data[i][key][:, m] = data_array
-                            vintage = vintage + 1
-            if self.ensemble.sparse_info['use_ensemble']:
-                self.ensemble.compress_manager()
-                self.ensemble.sparse_info['use_ensemble'] = None
-
-        # Extra option debug
-        if 'saveforecast' in self.ensemble.sim.input_dict:
-            # Save the reconstructed signal for later analysis
-            if self.ensemble.sparse_data:
-                for vint in np.arange(len(self.ensemble.data_rec)):
-                    self.ensemble.data_rec[vint] = np.asarray(
-                        self.ensemble.data_rec[vint]).T
-                with open('rec_results.p', 'wb') as f:
-                    pickle.dump(self.ensemble.data_rec, f)
diff --git a/src/pipt/loop/ensemble.py b/src/pipt/loop/ensemble.py
deleted file mode 100644
index 16775681..00000000
--- a/src/pipt/loop/ensemble.py
+++ /dev/null
@@ -1,881 +0,0 @@
-"""Descriptive description."""
-
-# External import
-import os.path
-
-import numpy
-import numpy as np
-import sys
-from copy import deepcopy, copy
-from scipy.linalg import solve, cholesky
-from scipy.spatial import distance
-import itertools
-from geostat.decomp import Cholesky
-
-# Internal import
-from ensemble.ensemble import Ensemble as PETEnsemble
-from ensemble.logger import PetLogger
-import misc.read_input_csv as rcsv
-from pipt.misc_tools import wavelet_tools as wt
-from pipt.misc_tools.cov_regularization import localization, _calc_distance
-
-# Import internal tools
-import pipt.misc_tools.analysis_tools as at
-import pipt.misc_tools.extract_tools as extract
-import pipt.misc_tools.ensemble_tools as entools
-
-
-class Ensemble(PETEnsemble):
-    """
-    Class for organizing/initializing misc. variables and simulator for an
-    ensemble-based inversion run. Inherits the PET ensemble structure
-    """
-
-    def __init__(self, keys_da, keys_en, sim):
-        """
-        Parameters
-        ----------
-        keys_da : dict
-            Options for the data assimilation class
-
-            - daalg: spesification of the method, first the main type (e.g., "enrml"), then the solver (e.g., "gnenrml")
-            - analysis: update flavour ("approx", "full" or "subspace")
-            - energy: percent of singular values kept after SVD
-            - obsvarsave: save the observations as a file (default false)
-            - restart: restart optimization from a restart file (default false)
-            - restartsave: save a restart file after each successful iteration (defalut false)
-            - analysisdebug: specify which class variables to save to the result files
-            - truedataindex: order of the simulated data (for timeseries this is points in time)
-            - obsname: unit for truedataindex (for timeseries this is days or hours or seconds, etc.)
-            - truedata: the data, e.g., provided as a .csv file
-            - assimindex: index for the data that will be used for assimilation
-            - datatype: list with the name of the datatypes
-            - staticvar: name of the static variables
-            - dynamicvar: name of the dynamic variables
-            - datavar: data variance, e.g., provided as a .csv file
-
-        keys_en : dict
-            Options for the ensemble class
-
-            - ne: number of perturbations used to compute the gradient
-            - state: name of state variables passed to the .mako file
-            - prior_: the prior information the state variables, including mean, variance and variable limits
-
-            NB: If keys_en is empty dict, it is assumed that the prior info is contained in keys_da.
-            The merged dict keys_da|keys_en is what is sent to the parent class. 
-
-        sim : callable
-            The forward simulator (e.g. flow)
-        """
-
-
-        # do the initiallization of the PETensemble
-        super(Ensemble, self).__init__(keys_da|keys_en, sim)
-
-        # Setup logger
-        self.logger = PetLogger(filename='assim.log')
-        self.logger(f'=========== Running Data Assimilation - {keys_da["daalg"][0].upper()} ===========')
-
-        # Internalize PIPT dictionary
-        if not hasattr(self, 'keys_da'):
-            self.keys_da = keys_da
-        if not hasattr(self, 'keys_en'):
-            self.keys_en = keys_en
-
-        if self.restart is False:
-            # Init in _init_prediction_output (used in run_prediction)
-            self.prediction = None
-            self.temp_state = None  # temporary state saving
-            self.cov_prior = None  # Prior cov. matrix
-            self.sparse_info = None  # Init in _org_sparse_representation
-            self.sparse_data = []  # List of the compression info
-            self.data_rec = []  # List of reconstructed data
-            self.scale_val = None  # Use to scale data
-
-            # Prepare sparse representation
-            if 'compress' in self.keys_da:
-                self.sparse_info = extract.organize_sparse_representation(self.keys_da['compress'])
-
-            self._org_obs_data()
-            self._org_data_var()
-
-            # Define projection operator for centring and scaling ensemble matrix
-            self.proj = (np.eye(self.ne) - np.ones((self.ne, self.ne))/self.ne) / np.sqrt(self.ne - 1)
-
-            # Option to store the dictionaries containing observed data and data variance
-            if 'obsvarsave' in self.keys_da and self.keys_da['obsvarsave'] == 'yes':
-                np.savez('obs_var', obs=self.obs_data, var=self.datavar)
-
-            # Initialize localization
-            if 'localization' in self.keys_da:
-                self.localization = localization(
-                    self.keys_da['localization'],
-                    self.keys_da['truedataindex'],
-                    self.keys_da['datatype'],
-                    self.keys_da['staticvar'],
-                    self.ne
-                )
-
-            # Initialize local analysis
-            if 'localanalysis' in self.keys_da:
-                self.local_analysis = extract.extract_local_analysis_info(self.keys_da['localanalysis'], self.idX.keys())
-
-            self.pred_data = [{k: np.zeros((1, self.ne), dtype='float32') for k in self.keys_da['datatype']}
-                              for _ in self.obs_data]
-
-            self.cell_index = None  # default value for extracting states
-
-    def check_assimindex_sequential(self):
-        """
-        Check if assim. indices is given as a 2D list as is needed in sequential updating. If not, make it a 2D list
-        """
-        # Check if ASSIMINDEX is a list. If not, make it a 2D list
-        if not isinstance(self.keys_da['assimindex'], list):
-            self.keys_da['assimindex'] = [[self.keys_da['assimindex']]]
-
-        # If ASSIMINDEX is a 1D list (either given in as a single row or single column), we reshape to a 2D list
-        elif not isinstance(self.keys_da['assimindex'][0], list):
-            assimindex_temp = [None] * len(self.keys_da['assimindex'])
-
-            for i in range(len(self.keys_da['assimindex'])):
-                assimindex_temp[i] = [self.keys_da['assimindex'][i]]
-
-            self.keys_da['assimindex'] = assimindex_temp
-
-    def check_assimindex_simultaneous(self):
-        """
-        Check if assim. indices is given as a 1D list as is needed in simultaneous updating. If not, make it a 2D list
-        with one row.
-        """
-        # Check if ASSIMINDEX is a list. If not, make it a 2D list with one row
-        if not isinstance(self.keys_da['assimindex'], list):
-            self.keys_da['assimindex'] = [[self.keys_da['assimindex']]]
-
-        # Check if ASSIMINDEX is a 1D list. If true, make it a 2D list with one row
-        elif not isinstance(self.keys_da['assimindex'][0], list):
-            self.keys_da['assimindex'] = [self.keys_da['assimindex']]
-
-        # If ASSIMINDEX is a 2D list, we reshape it to a 2D list with one row
-        elif isinstance(self.keys_da['assimindex'][0], list):
-            self.keys_da['assimindex'] = [
-                [item for sublist in self.keys_da['assimindex'] for item in sublist]]
-
-    def _org_obs_data(self):
-        """
-        Organize the input true observed data. The obs_data will be a list of length equal length of "TRUEDATAINDEX",
-        and each entry in the list will be a dictionary with keys equal to the "DATATYPE".
-        Also, the pred_data variable (predicted data or forward simulation) will be initialized here with the same
-        structure as the obs_data variable.
-
-        !!! warning
-            An "N/A" entry in "TRUEDATA" is treated as a None-entry; that is, there is NOT an observed data at this
-            assimilation step.
-
-        !!! warning
-            The array associated with the first string inputted in "TRUEDATAINDEX" is assumed to be the "main"
-            index, that is, the length of this array will determine the length of the obs_data list! There arrays
-            associated with the subsequent strings in "TRUEDATAINDEX" are then assumed to be a subset of the first
-            string.  An example: the first string is SOURCE (e.g., sources in CSEM), where the array will be a list of numbering
-            for the sources; and the second string is FREQ, where the array associated will be a list of frequencies.
-
-        !!! note
-            It is assumed that the number of data associated with a subset is the same for each index in the subset.
-            For example: If two frequencies are inputted in FREQ, then the number of data for one SOURCE index and one
-            frequency is 1/2 of the total no. of data for that SOURCE index. If three frequencies are inputted, the number
-            of data for one SOURCE index and one frequencies is 1/3 of the total no of data for that SOURCE index,
-            and so on.
-        """
-
-        # # Check if keys_da['datatype'] is a string or list, and make it a list if single string is given
-        # if isinstance(self.keys_da['datatype'], str):
-        #     datatype = [self.keys_da['datatype']]
-        # else:
-        #     datatype = self.keys_da['datatype']
-        #
-        # # Extract primary indices from "TRUEDATAINDEX"
-        # if isinstance(self.keys_da['truedataindex'], list):  # List of prim. ind
-        #     true_prim = self.keys_da['truedataindex']
-        # else:  # Float
-        #     true_prim = [self.keys_da['truedataindex']]
-        #
-        # # Check if a csv file has been included as "TRUEDATAINDEX". If so, we read it and make a list,
-        # if isinstance(self.keys_da['truedataindex'], str) and self.keys_da['truedataindex'].endswith('.csv'):
-        #     with open(self.keys_da['truedataindex']) as csvfile:
-        #         reader = csv.reader(csvfile)  # get a reader object
-        #         true_prim = []  # Initialize the list of csv data
-        #         for rows in reader:  # Rows is a list of values in the csv file
-        #             csv_data = [None] * len(rows)
-        #             for ind, col in enumerate(rows):
-        #                 csv_data[ind] = int(col)
-        #             true_prim.extend(csv_data)
-        #     self.keys_da['truedataindex'] = true_prim
-        #
-        # # Check if a csv file has been included as "PREDICTION". If so, we read it and make a list,
-        # if 'prediction' in self.keys_da:
-        #     if isinstance(self.keys_da['prediction'], str) and self.keys_da['prediction'].endswith('.csv'):
-        #         with open(self.keys_da['prediction']) as csvfile:
-        #             reader = csv.reader(csvfile)  # get a reader object
-        #             pred_prim = []  # Initialize the list of csv data
-        #             for rows in reader:  # Rows is a list of values in the csv file
-        #                 csv_data = [None] * len(rows)
-        #                 for ind, col in enumerate(rows):
-        #                     csv_data[ind] = int(col)
-        #                 pred_prim.extend(csv_data)
-        #         self.keys_da['prediction'] = pred_prim
-
-        # Extract the observed data from "TRUEDATA"
-        if len(self.keys_da['truedataindex']) == 1:  # Only one assimilation step
-            if isinstance(self.keys_da['truedata'], list):
-                truedata = [self.keys_da['truedata']]
-            else:
-                truedata = [[self.keys_da['truedata']]]
-        else:  # More than one assim. step
-            if isinstance(self.keys_da['truedata'][0], list):  # 2D list
-                truedata = self.keys_da['truedata']
-            else:
-                truedata = [[x] for x in self.keys_da['truedata']]  # Make it a 2D list
-
-        # Initialize obs_data list. List length = len("TRUEDATAINDEX"); dictionary in each list entry = d
-        self.obs_data = [None] * len(self.keys_da['truedataindex'])
-
-        # Check if a csv file has been included in TRUEDATA. If so, we read it and make a 2D list, which we can use
-        # in the below when assigning data to obs_data dictionary
-        if isinstance(self.keys_da['truedata'], str) and self.keys_da['truedata'].endswith('.pkl'):
-            self.obs_data, self.keys_da['datatype'], self.truedataindex = rcsv.read_data_df(self.keys_da['truedata'],outtype='list')
-            self.keys_da['truedataindex'] = self.truedataindex
-
-            # This does not need any more adjustment
-            return
-        if isinstance(self.keys_da['truedata'], str) and self.keys_da['truedata'].endswith('.csv'):
-            truedata = rcsv.read_data_csv(
-                self.keys_da['truedata'], self.keys_da['datatype'], self.keys_da['truedataindex'])
-
-        # # Check if assimindex is given as a csv file. If so, we read and make a potential 2D list (if sequential).
-        # if isinstance(self.keys_da['assimindex'], str) and self.keys_da['assimindex'].endswith('.csv'):
-        #     with open(self.keys_da['assimindex']) as csvfile:
-        #         reader = csv.reader(csvfile)  # get a reader object
-        #         assimindx = []  # Initialize the 2D list of csv data
-        #         for rows in reader:  # Rows is a list of values in the csv file
-        #             csv_data = [None] * len(rows)
-        #             for col in range(len(rows)):
-        #                 csv_data[col] = int(rows[col])
-        #             assimindx.append(csv_data)
-        #     self.keys_da['assimindex'] = assimindx
-
-        # Now we loop over all list entries in obs_data and fill in the observed data from "TRUEDATA".
-        # NOTE: Not all data types may have observed data at each "TRUEDATAINDEX"; in this case it will have a None
-        # entry.
-        # NOTE2: If "TRUEDATA" contains a .npz file, this will be loaded. BUT the array loaded MUST be a 1D numpy
-        # array! So resize BEFORE saving the .npz file!
-        # NOTE3: If CSV file has been included in TRUEDATA, we read the data from this file
-        vintage = 0
-        for i in range(len(self.obs_data)):  # TRUEDATAINDEX
-            # Init. dict. with datatypes (do inside loop to avoid copy of same entry)
-            self.obs_data[i] = {}
-            # Make unified inputs
-            if 'unif_in' in self.keys_da and self.keys_da['unif_in'] == 'yes':
-                if isinstance(truedata[i][0], str) and truedata[i][0].endswith('.npz'):
-                    load_data = np.load(truedata[i][0])  # Load the .npz file
-                    data_array = load_data[load_data.files[0]]
-
-                    # Perform compression for the data type specified in self.sparse_info['compress_data'] if required
-                    if self.sparse_info is not None and self.keys_da['datatype'][0] == self.sparse_info['compress_data']:
-                        data_array = self.compress_manager(data_array, vintage, False)
-                        vintage = vintage + 1
-
-                    # Save array in obs_data. If it is an array with single value (not list), then we convert it to a
-                    # list with one entry.
-                    self.obs_data[i][self.keys_da['datatype'][0]] = np.array(
-                        [data_array[()]]) if data_array.shape == () else data_array
-
-                    # Entry is N/A, i.e., no data given
-                elif isinstance(truedata[i][0], str) and not truedata[i][0].endswith('.npz') \
-                        and truedata[i][0].lower() == 'n/a':
-                    self.obs_data[i][self.keys_da['datatype'][0]] = None
-
-                # Unknown string entry
-                elif isinstance(truedata[i][0], str) and not truedata[i][0].endswith('.npz') \
-                        and not truedata[i][0].lower() == 'n/a':
-                    print(
-                        '\n\033[1;31mERROR: Cannot load observed data file! Maybe it is not a .npz file?\033[1;m')
-                    sys.exit(1)
-                # Entry is a numerical value
-                elif not isinstance(truedata[i][0], str):  # Some numerical value or None
-                    self.obs_data[i][self.keys_da['datatype'][0]] = np.array(
-                        truedata[i][:])  # no need to make this into a list
-            else:
-                for j, datatype in enumerate(self.keys_da['datatype']):
-                    # Load a Numpy npz file
-                    if isinstance(truedata[i][j], str) and truedata[i][j].endswith('.npz'):
-                        load_data = np.load(truedata[i][j])  # Load the .npz file
-                        data_array = load_data[load_data.files[0]]
-
-                        # Perform compression for the data type specified in self.sparse_info['compress_data'] if required
-                        if self.sparse_info is not None and datatype == self.sparse_info['compress_data']:
-                            data_array = self.compress_manager(data_array, vintage, False)
-                            vintage = vintage + 1
-
-                        # Save array in obs_data. If it is an array with single value (not list), then we convert it to a
-                        # list with one entry
-                        self.obs_data[i][self.keys_da['datatype'][j]] = np.array(
-                            [data_array[()]]) if data_array.shape == () else data_array
-
-                    # Entry is N/A, i.e., no data given
-                    elif isinstance(truedata[i][j], str) and not truedata[i][j].endswith('.npz') \
-                            and truedata[i][j].lower() == 'n/a':
-                        self.obs_data[i][self.keys_da['datatype'][j]] = None
-
-                    # Unknown string entry
-                    elif isinstance(truedata[i][j], str) and not truedata[i][j].endswith('.npz') \
-                            and not truedata[i][j].lower() == 'n/a':
-                        print(
-                            '\n\033[1;31mERROR: Cannot load observed data file! Maybe it is not a .npz file?\033[1;m')
-                        sys.exit(1)
-
-                    # Entry is a numerical value
-                    # Some numerical value or None
-                    elif not isinstance(truedata[i][j], str):
-                        if type(truedata[i][j]) is numpy.ndarray:
-                            self.obs_data[i][self.keys_da['datatype'][j]] = truedata[i][j]
-                        else:
-                            self.obs_data[i][self.keys_da['datatype'][j]] = np.array([truedata[i][j]])
-
-                    # Scale data if required (currently only one group of data can be scaled)
-                    if 'scale' in self.keys_da and self.keys_da['scale'][0] in self.keys_da['datatype'][j] and \
-                            self.obs_data[i][self.keys_da['datatype'][j]] is not None:
-                        self.obs_data[i][self.keys_da['datatype']
-                                         [j]] *= self.keys_da['scale'][1]
-
-    def _org_data_var(self):
-        """
-        Organize the input data variance given by the keyword "DATAVAR" in the "DATAASSIM" part the init_file.
-
-        If a diagonal auto-covariance is to be used to generate data, there are two options for data variance: absolute
-        and relative variance. Absolute is a fixed value for the variance, and relative is a percentage of
-        the observed data as standard deviation which in turn is set as variance. If we want to use an empirical data
-        covariance matrix to generate data, the user must supply a Numpy save file with samples, which is loaded here.
-        If we want to specify the whole covariance matrix, this can also be done. The user must supply a Numpy save file
-        which is loaded here.
-
-        !!! warning
-            When relative variance is given as input, we set the variance as (true_obs_data*rel_perc*0.01)**2
-            BECAUSE we often want this alternative in cases where we "add some percentage of Gaussian noise to the
-            observed data". Hence, we actually want some percentage of the true observed data as STANDARD DEVIATION since
-            it ultimately is the standard deviation (through square-root decompostion of Cd) that is used when adding
-            noise to observed data.Note that this is ONLY a matter of definition, but we feel that this way of defining
-            relative variance is most common.
-        """
-            # TODO: Change when sub-assim. indices have been re-implemented.
-
-        # Check if keys_da['datatype'] is a string or list, and make it a list if single string is given
-        if isinstance(self.keys_da['datatype'], str):
-            datatype = [self.keys_da['datatype']]
-        else:
-            datatype = self.keys_da['datatype']
-
-        # Extract primary indices from "TRUEDATAINDEX"
-        if isinstance(self.keys_da['truedataindex'], list):  # List of prim. ind
-            true_prim = self.keys_da['truedataindex']
-        else:  # Float
-            true_prim = [self.keys_da['truedataindex']]
-
-        #
-        # Extract the data variance from "DATAVAR"
-        #
-        # Only one assimilation step
-        if len(true_prim) == 1:
-            # More than one DATATYPE, but only one entry in DATAVAR
-            if len(self.keys_da['datavar']) == 2 and len(datatype) > 1:
-                # Copy list entry no. data type times
-                datavar = [self.keys_da['datavar'] * len(datatype)]
-
-            # One DATATYPE
-            else:
-                datavar = [self.keys_da['datavar']]
-
-        # More than one assim. step
-        else:
-            # More than one DATATYPE, but only one entry in DATAVAR
-            if not isinstance(self.keys_da['datavar'][0], list) and len(self.keys_da['datavar']) == 2 and \
-                    len(datatype) > 1:
-                # Need to make a list with entries equal to 2*no. data types (since there are 2 entries in DATAVAR
-                # for one data type). Then we copy this list as many times as we have TRUEDATAINDEX (i.e.,
-                # we get a 2D list)
-                # Copy list entry no. data types times
-                datavar_temp = self.keys_da['datavar'] * len(datatype)
-                datavar = [None] * len(true_prim)  # Init.
-                for i in range(len(true_prim)):
-                    datavar[i] = deepcopy(datavar_temp)
-
-            # Entry for each DATATYPE, but not for each TRUEDATAINDEX
-            elif (len(self.keys_da['datavar'])) / 2 == len(datatype) and \
-                    not isinstance(self.keys_da['datavar'][0], list):
-                # If we have entry for each DATATYPE but NOT for each TRUEDATAINDEX, then we just copy the list of
-                # entries to each TRUEDATAINDEX
-                datavar = [None] * len(true_prim)  # Init.
-                for i in range(len(true_prim)):
-                    datavar[i] = deepcopy(self.keys_da['datavar'])
-
-            else:
-                datavar = self.keys_da['datavar']
-
-        # Check if a csv file has been included in DATAVAR. If so datavar will be redefined and variance info will be
-        #  extracted from the csv file
-        if isinstance(self.keys_da['datavar'], str) and self.keys_da['datavar'].endswith('.csv'):
-            datavar = rcsv.read_var_csv(self.keys_da['datavar'], datatype, true_prim)
-        
-        if isinstance(self.keys_da['datavar'], str) and self.keys_da['datavar'].endswith('.pkl'):
-            datavar = rcsv.read_var_df(self.keys_da['datavar'], datatype=self.keys_da['datatype'],
-                                       truedataindex=self.keys_da['truedataindex'])
-
-
-            # Initialize datavar output
-            self.datavar = [None] * len(true_prim)
-            for i in range(len(self.obs_data)):  # TRUEDATAINDEX
-            # Init. dict. with datatypes (do inside loop to avoid copy of same entry)
-                self.datavar[i] = {}
-                for j in range(len(datatype)):  # DATATYPE
-                    if self.obs_data[i][datatype[j]] is not None:
-                        self.datavar[i][datatype[j]] = []
-                        for c,el in enumerate(self.obs_data[i][datatype[j]]):
-                            if datavar[i][datatype[j]][0].lower() == 'rel':
-                                self.datavar[i][datatype[j]].append((datavar[i][datatype[j]][1]*(el*0.01))**2)
-                            elif datavar[i][datatype[j]][0].lower() == 'abs':
-                                # Check if datavar[i][datatype[j]][1] is iterable
-                                var_value = datavar[i][datatype[j]][1]
-                                if hasattr(var_value, '__iter__') and not isinstance(var_value, str):
-                                    self.datavar[i][datatype[j]].append(var_value[c])
-                                else:
-                                    self.datavar[i][datatype[j]].append(var_value)
-                            elif datavar[i][datatype[j]][0].lower() == 'emp':
-                                self.datavar[i][datatype[j]].append(datavar[i][datatype[j]][1])
-                            else:
-                                print('\n\033[1;31mERROR: Cannot read data variance from pkl file! The first entry in the pkl file must be either "rel" or "abs"!\033[1;m')
-                                sys.exit()
-                        self.datavar[i][datatype[j]] = np.array(self.datavar[i][datatype[j]])
-                    else:
-                        self.datavar[i][datatype[j]] = None
-
-            return
-
-        # Loop over all entries in datavar and fill in values from "DATAVAR" (use obs_data values in the REL variance
-        #  cases)
-        # Initialize datavar output
-        self.datavar = [None] * len(true_prim)
-        # TODO: Implement loading of data variance from .npz file
-        vintage = 0
-        for i in range(len(self.obs_data)):  # TRUEDATAINDEX
-            # Init. dict. with datatypes (do inside loop to avoid copy of same entry)
-            self.datavar[i] = {}
-            for j in range(len(datatype)):  # DATATYPE
-                # ABS
-                # Absolute var.
-                if datavar[i][2*j] == 'abs' and self.obs_data[i][datatype[j]] is not None:
-                    self.datavar[i][datatype[j]] = datavar[i][2*j+1] * \
-                        np.ones(len(self.obs_data[i][datatype[j]]))
-
-                # REL
-                # Rel. var.
-                elif datavar[i][2*j] == 'rel' and self.obs_data[i][datatype[j]] is not None:
-                    # Rel. var WITH a min. variance tolerance
-                    if isinstance(datavar[i][2*j+1], list):
-                        self.datavar[i][datatype[j]] = (datavar[i][2*j+1][0] * 0.01 *
-                                                        self.obs_data[i][datatype[j]]) ** 2
-                        ind_tol = self.datavar[i][datatype[j]] < datavar[i][2*j+1][1] ** 2
-                        self.datavar[i][datatype[j]][ind_tol] = datavar[i][2*j+1][1] ** 2
-
-                    else:  # Single. rel. var input
-                        var = (datavar[i][2*j+1] * 0.01 * self.obs_data[i][datatype[j]]) ** 2
-                        var = np.clip(var, 1.0e-9, None)  # avoid zero variance
-                        self.datavar[i][datatype[j]] = var
-                # EMP
-                elif datavar[i][2*j] == 'emp' and datavar[i][2*j+1].endswith('.npz') and \
-                        self.obs_data[i][datatype[j]] is not None:  # Empirical var.
-                    load_data = np.load(datavar[i][2*j+1])  # load the numpy savez file
-                    # store in datavar
-                    self.datavar[i][datatype[j]] = load_data[load_data.files[0]]
-
-                # LOAD
-                elif datavar[i][2*j] == 'load' and datavar[i][2*j+1].endswith('.npz') and \
-                        self.obs_data[i][datatype[j]] is not None:  # Load variance. (1d array)
-                    load_data = np.load(datavar[i][2*j+1])  # load the numpy savez file
-                    load_data = load_data[load_data.files[0]]
-                    self.datavar[i][datatype[j]] = load_data  # store in datavar
-
-                # CD the full covariance matrix is given in its correct format. Hence, load once and set as CD
-                elif datavar[i][2 * j] == 'cd' and datavar[i][2 * j + 1].endswith('.npz') and \
-                        self.obs_data[i][datatype[j]] is not None:
-                    if not hasattr(self, 'cov_data'):  # check to populate once
-                        # load the numpy savez file
-                        load_data = np.load(datavar[i][2 * j + 1])
-                        self.cov_data = load_data[load_data.files[0]]
-                    # store the variance
-                    self.datavar[i][datatype[j]] = self.cov_data[i*j, i*j]
-
-                elif self.obs_data[i][datatype[j]] is None:  # No observed data
-                    self.datavar[i][datatype[j]] = None  # Set None type here also
-
-                # Handle case when noise is estimated using wavelets
-                if self.sparse_info is not None and self.datavar[i][datatype[j]] is not None and \
-                            datatype[j]==self.sparse_info['compress_data']:
-                    # compute var from sparse_data
-                    est_noise = np.power(self.sparse_data[vintage].est_noise, 2)
-                    self.datavar[i][datatype[j]] = est_noise  # override the given value
-                    vintage = vintage + 1
-
-
-    def set_observations(self):
-        '''
-        Generate the perturbed observed data ensemble
-        '''
-        # Make observed data vector
-        vecObs, _ = at.aug_obs_pred_data(
-            self.obs_data, 
-            self.pred_data, 
-            self.assim_index,
-            self.list_datatypes
-        )
-        
-        # Generate ensemble of perturbed observed data
-        if ('emp_cov' in self.keys_da) and (self.keys_da['emp_cov'] == 'yes'):
-
-            if hasattr(self, 'cov_data'):  # cd matrix has been imported
-                # enObs: samples from N(0,Cd)
-                enObs = cholesky(self.cov_data).T @ np.random.randn(self.cov_data.shape[0], self.ne)
-            else:
-                # Extract assim indices
-                if isinstance(self.assim_index[1], list):
-                    l_prim = [int(x) for x in self.assim_index[1]]
-                else:
-                    l_prim = [int(self.assim_index[1])]
-                
-                # Concatenate datavar in the same manner as aug_obs_pred_data
-                enObs = np.concatenate(tuple(
-                    self.datavar[el][dat] for el in l_prim for dat in self.list_datatypes 
-                    if self.datavar[el][dat] is not None
-                ))
-
-            # Screen data if required
-            if ('screendata' in self.keys_da) and (self.keys_da['screendata'] == 'yes'):
-                enObs = at.screen_data(
-                    enObs, 
-                    self.enPred, 
-                    vecObs, 
-                    self.iteration
-                )
-            
-            # Center the ensemble of perturbed observed data
-            # enObs = vecObs[:, np.newaxis] - enObs
-            self.cov_data = np.var(enObs, ddof=1, axis=1)
-            self.scale_data = np.sqrt(self.cov_data)
-        
-        else:
-            if not hasattr(self, 'cov_data'):  # if cd is not loaded
-                self.cov_data = at.gen_covdata(
-                    datavar = self.datavar,
-                    assim_index = self.assim_index,
-                    list_data = self.list_datatypes,
-                )
-            # data screening
-            if ('screendata' in self.keys_da) and (self.keys_da['screendata'] == 'yes'):
-                self.cov_data = at.screen_data(
-                    data = self.cov_data, 
-                    aug_pred_data = self.enPred, 
-                    obs_data_vector = vecObs, 
-                    iteration = self.iteration
-                )
-            
-            generator = Cholesky()  # Initialize GeoStat class for generating realizations
-            enObs, self.scale_data = generator.gen_real(
-                mean = vecObs, 
-                var = self.cov_data, 
-                number = self.ne,
-                return_chol = True
-            )
-        
-        return vecObs, enObs
-
-    def _ext_scaling(self):
-        # get vector of scaling
-        self.state_scaling = at.calc_scaling(
-            self.prior_enX, self.idX, self.prior_info)
-        
-        self.Am = None
-
-
-    def compress_manager(self, data=None, vintage=0, aug_coeff=None):
-        """
-        Compress the input data using wavelets.
-
-        Parameters
-        ----------
-        data : 
-            data to be compressed
-            If data is `None`, all data (true and simulated) is re-compressed (used if leading indices are updated)
-        vintage : int
-            the time index for the data
-        aug_coeff : bool
-            - False: in this case the leading indices for wavelet coefficients are computed
-            - True: in this case the leading indices are augmented using information from the ensemble
-            - None: in this case simulated data is compressed
-        """
-
-        # If input data is None, we re-compress all data
-        data_array = None
-        if data is None:
-            vintage = 0
-            for i in range(len(self.obs_data)):  # TRUEDATAINDEX
-                for j in self.obs_data[i].keys():  # DATATYPE
-
-                    data_array = self.obs_data[i][j]
-
-                    # Perform compression if required
-                    if data_array is not None and \
-                            vintage < len(self.sparse_info['mask']) and \
-                            len(data_array) == int(np.sum(self.sparse_info['mask'][vintage])):
-                        data_array, wdec_rec = self.sparse_data[vintage].compress(
-                            data_array)  # compress
-                        self.obs_data[i][j] = data_array  # save array in obs_data
-                        rec = self.sparse_data[vintage].reconstruct(
-                            wdec_rec)  # reconstruct the data
-                        s = 'truedata_rec_' + str(vintage) + '.npz'
-                        np.savez(s, rec)  # save reconstructed data
-                        est_noise = np.power(self.sparse_data[vintage].est_noise, 2)
-                        self.datavar[i][j] = est_noise
-
-                        # Update the ensemble
-                        data_sim = self.pred_data[i][j]
-                        self.pred_data[i][j] = np.zeros((len(data_array), self.ne))
-                        self.data_rec.append([])
-                        for m in range(self.pred_data[i][j].shape[1]):
-                            data_array = data_sim[:, m]
-                            data_array, wdec_rec = self.sparse_data[vintage].compress(
-                                data_array)  # compress
-                            self.pred_data[i][j][:, m] = data_array
-                            rec = self.sparse_data[vintage].reconstruct(
-                                wdec_rec)  # reconstruct the data
-                            self.data_rec[vintage].append(rec)
-
-                        # Go to next vintage
-                        vintage = vintage + 1
-
-            # Option to store the dictionaries containing observed data and data variance
-            if 'obsvarsave' in self.keys_da and self.keys_da['obsvarsave'] == 'yes':
-                np.savez('obs_var', obs=self.obs_data, var=self.datavar)
-
-            if 'saveforecast' in self.keys_en:
-                s = 'prior_forecast_rec.npz'
-                np.savez(s, self.data_rec)
-
-            data_array = None
-
-        elif aug_coeff is None: # compress predicted data
-
-            data_array, wdec_rec = self.sparse_data[vintage].compress(data)
-            rec = self.sparse_data[vintage].reconstruct(
-                wdec_rec)  # reconstruct the simulated data
-            if len(self.data_rec) == vintage:
-                self.data_rec.append([])
-            self.data_rec[vintage].append(rec)
-
-        elif not aug_coeff: # compress true data, aug_coeff = false
-
-            options = copy(self.sparse_info)
-            # find the correct mask for the vintage
-            options['mask'] = options['mask'][vintage]
-            if type(options['min_noise']) == list:
-                if 0 <= vintage < len(options['min_noise']):
-                    options['min_noise'] = options['min_noise'][vintage]
-                else:
-                    print(
-                        'Error: min_noise must either be scalar or list with one number for each vintage')
-                    sys.exit(1)
-            x = wt.SparseRepresentation(options)
-            data_array, wdec_rec = x.compress(data, self.sparse_info['th_mult'])
-            self.sparse_data.append(x)  # store the information
-            data_rec = x.reconstruct(wdec_rec)  # reconstruct the data
-            s = 'truedata_rec_' + str(vintage) + '.npz'
-            np.savez(s, data_rec)  # save reconstructed data
-            if self.sparse_info['use_ensemble']:
-                data_array = data  # just return the same as input
-
-        elif aug_coeff:
-
-            _, _ = self.sparse_data[vintage].compress(data, self.sparse_info['th_mult'])
-            data_array = data  # just return the same as input
-
-        return data_array
-
-    def local_analysis_update(self):
-        '''
-        Function for updates that can be used by all algorithms. Do this once to avoid duplicate code for local
-        analysis.
-        '''
-        # Copy original info to restore after local updates
-        orig_list_data = deepcopy(self.list_datatypes)
-        orig_list_state = deepcopy(self.list_states)
-        orig_cd = deepcopy(self.cov_data)
-        orig_real_obs_data = deepcopy(self.real_obs_data)
-        orig_data_vector = deepcopy(self.obs_data_vector)
-
-        # loop over the states that we want to update. Assume that the state and data combinations have been
-        # determined by the initialization.
-        # TODO: augment parameters with identical mask.
-
-        # REGION PARAMETERS
-        ############################################################################################################
-        for state in self.local_analysis['region_parameter']:
-            self.list_datatypes = [
-                elem for elem in self.list_datatypes if
-                elem in self.local_analysis['update_mask'][state]
-            ]
-            self.list_states = [deepcopy(state)]
-
-            self._ext_scaling()  # scaling for this state
-            if 'localization' in self.keys_da:
-                self.localization.loc_info['field'] = self.state_scaling.shape
-            del self.cov_data
-
-            # reset the random state for consistency
-            np.random.set_state(self.data_random_state)
-            self.vecObs, self.enObs = self.set_observations()
-            _, self.enPred = at.aug_obs_pred_data(
-                self.obs_data, 
-                self.pred_data, 
-                self.assim_index,
-                self.list_datatypes
-            )
-
-            # Get state ensemble for list_states
-            enX = []
-            idX = {}
-            for idx in self.list_states:
-                start, end = self.idX[idx]
-                tempX = self.enX[start:end, :]
-                enX.append(tempX)
-                idX[idx] = (enX.shape[0] - tempX.shape[0], enX.shape[0])
-
-            # Compute the analysis update
-            self.update(
-                enX = np.vstack(enX),
-                enY = self.enPred,
-                enE = self.enObs,
-            )
-
-            # Update the state
-            if hasattr(self, 'step'):
-                self.enX_temp = self.enX + self.step
-        ############################################################################################################
-
-        # VECTOR REGION PARAMETERS
-        ############################################################################################################
-        for state in self.local_analysis['vector_region_parameter']:
-            current_list_datatypes = deepcopy(self.list_datatypes)
-            for state_indx in range(self.state[state].shape[0]): # loop over the elements in the region
-                self.list_datatypes = [elem for elem in self.list_datatypes if
-                                       elem in self.local_analysis['update_mask'][state][state_indx]]
-                if len(self.list_datatypes):
-                    self.list_states = [deepcopy(state)]
-                    self._ext_scaling()  # scaling for this state
-                    if 'localization' in self.keys_da:
-                        self.localization.loc_info['field'] = self.state_scaling.shape
-                    del self.cov_data
-                    # reset the random state for consistency
-                    np.random.set_state(self.data_random_state)
-                    self._ext_obs()  # get the data that's in the list of data.
-                    _, self.aug_pred_data = at.aug_obs_pred_data(self.obs_data, self.pred_data, self.assim_index,
-                                                                 self.list_datatypes)
-                    # Mean pred_data and perturbation matrix with scaling
-                    if len(self.scale_data.shape) == 1:
-                        self.pert_preddata = np.dot(np.expand_dims(self.scale_data ** (-1), axis=1),
-                                                    np.ones((1, self.ne))) * np.dot(self.aug_pred_data, self.proj)
-                    else:
-                        self.pert_preddata = solve(
-                            self.scale_data, np.dot(self.aug_pred_data, self.proj))
-
-                    aug_state = at.aug_state(self.current_state, self.list_states)[state_indx,:]
-                    self.update()
-                    if hasattr(self, 'step'):
-                        aug_state_upd = aug_state + self.step[state_indx,:]
-                    self.state[state][state_indx,:] = aug_state_upd
-
-                self.list_datatypes = deepcopy(current_list_datatypes)
-        ############################################################################################################
-
-
-        for state in self.local_analysis['cell_parameter']:
-            self.list_states = [deepcopy(state)]
-            self._ext_scaling()  # scaling for this state
-            orig_state_scaling = deepcopy(self.state_scaling)
-            param_position = self.local_analysis['parameter_position'][state]
-            field_size = param_position.shape
-            for k in range(field_size[0]):
-                for j in range(field_size[1]):
-                    for i in range(field_size[2]):
-                        current_data_list = list(
-                            self.local_analysis['update_mask'][state][k][j][i])
-                        current_data_list.sort()  # ensure consistent ordering of data
-                        if len(current_data_list):
-                            # if non-unique data for assimilation index, get the relevant data.
-                            if self.local_analysis['unique'] == False:
-                                orig_assim_index = deepcopy(self.assim_index)
-                                assim_index_data_list = set(
-                                    [el.split('_')[0] for el in current_data_list])
-                                current_assim_index = [
-                                    int(el.split('_')[1]) for el in current_data_list]
-                                current_data_list = list(assim_index_data_list)
-                                self.assim_index[1] = current_assim_index
-                            self.list_datatypes = deepcopy(current_data_list)
-                            del self.cov_data
-                            # reset the random state for consistency
-                            np.random.set_state(self.data_random_state)
-                            self._ext_obs()
-                            _, self.aug_pred_data = at.aug_obs_pred_data(self.obs_data, self.pred_data,
-                                                                         self.assim_index,
-                                                                         self.list_datatypes)
-                            # get parameter indexes
-                            full_cell_index = np.ravel_multi_index(
-                                np.array([[k], [j], [i]]), tuple(field_size))
-                            # count active values
-                            self.cell_index = [sum(param_position.flatten()[:el])
-                                               for el in full_cell_index]
-                            if 'localization' in self.keys_da:
-                                self.localization.loc_info['field'] = (
-                                    len(self.cell_index),)
-                                self.localization.loc_info['distance'] = _calc_distance(
-                                    self.local_analysis['data_position'],
-                                    self.local_analysis['unique'],
-                                    current_data_list, self.assim_index,
-                                    self.obs_data, self.pred_data, [(k, j, i)])
-                            # Set relevant state scaling
-                            self.state_scaling = orig_state_scaling[self.cell_index]
-
-                            # Mean pred_data and perturbation matrix with scaling
-                            if len(self.scale_data.shape) == 1:
-                                self.pert_preddata = np.dot(np.expand_dims(self.scale_data ** (-1), axis=1),
-                                                            np.ones((1, self.ne))) * np.dot(self.aug_pred_data,
-                                                                                            self.proj)
-                            else:
-                                self.pert_preddata = solve(
-                                    self.scale_data, np.dot(self.aug_pred_data, self.proj))
-
-                            aug_state = at.aug_state(
-                                self.current_state, self.list_states, self.cell_index)
-                            self.update()
-                            if hasattr(self, 'step'):
-                                aug_state_upd = aug_state + self.step
-                            self.state = at.update_state(
-                                aug_state_upd, self.state, self.list_states, self.cell_index)
-
-                            if self.local_analysis['unique'] == False:
-                                # reset assim index
-                                self.assim_index = deepcopy(orig_assim_index)
-                            if hasattr(self, 'localization') and 'distance' in self.localization.loc_info:  # reset
-                                del self.localization.loc_info['distance']
-
-        self.list_datatypes = deepcopy(orig_list_data)  # reset to original list
-        self.list_states = deepcopy(orig_list_state)
-        self.cov_data = deepcopy(orig_cd)
-        self.real_obs_data = deepcopy(orig_real_obs_data)
-        self.obs_data_vector = deepcopy(orig_data_vector)
-        self.cell_index = None
diff --git a/src/pipt/misc_tools/analysis_tools.py b/src/pipt/misc_tools/analysis_tools.py
index a1afc0a9..e0a420ab 100644
--- a/src/pipt/misc_tools/analysis_tools.py
+++ b/src/pipt/misc_tools/analysis_tools.py
@@ -9,17 +9,18 @@
 __all__ = [
     'parallel_upd',
     'calc_autocov',
-    'calc_crosscov',
     'calc_objectivefun'
 ]
 
 # External imports
+import os
 import numpy as np          # Numerical tools
 from scipy import linalg    # Linear algebra tools
 from misc.system_tools.environ_var import OpenBlasSingleThread  # only single thread
 import multiprocessing as mp  # parallel updates
-import time
 import pickle
+import logging
+import warnings
 from importlib import import_module  # To import packages
 
 from scipy.spatial import cKDTree
@@ -80,11 +81,11 @@ def parallel_upd(list_state, prior_info, states_dict, X, local_mask_info, obs_da
 
     dat = [el for el in local_mask_info.keys()]
     # data coordinates to initialize search
-    tot_completions = [tuple(el) for dat_mask in dat if type(
-        dat_mask) == tuple for el in local_mask_info[dat_mask]['position']]
+    tot_completions = [tuple(el) for dat_mask in dat if isinstance(
+        dat_mask, tuple) for el in local_mask_info[dat_mask]['position']]
     uniq_completions = [el for el in set(tot_completions)]
-    tot_w_name = [dat_mask for dat_mask in dat if type(
-        dat_mask) == tuple for _ in local_mask_info[dat_mask]['position']]
+    tot_w_name = [dat_mask for dat_mask in dat if isinstance(
+        dat_mask, tuple) for _ in local_mask_info[dat_mask]['position']]
     uniq_w_name = [tot_w_name[tot_completions.index(el)] for el in uniq_completions]
     # todo: limit to active datanan
     coord_search = cKDTree(data=uniq_completions)
@@ -94,9 +95,9 @@ def parallel_upd(list_state, prior_info, states_dict, X, local_mask_info, obs_da
 
         tot_well_dict = {}
         for well in set(act_w_name):
-            tot_well_dict[well] = [el for el in local_mask_info.keys() if type(el) == tuple and
+            tot_well_dict[well] = [el for el in local_mask_info.keys() if isinstance(el, tuple) and
                                    el[0].split()[1] == well]
-    except:
+    except Exception:
         tot_well_dict = local_mask_info
 
     if len(scale_data.shape) == 1:
@@ -240,7 +241,7 @@ def _calc_row_upd(inp):
 
     Parameters
     ----------
-    inp : list    
+    inp : list
         List of [state, param_coordinates, metadata file name]
     """
 
@@ -258,7 +259,8 @@ def _calc_row_upd(inp):
     max_r = {}
     for state in states:
         tmp_r = [meta_data['local_mask_info'][el]['range'][0] for el in meta_data['local_mask_info'].keys() if
-                 type(el) == tuple and state in el and type(meta_data['local_mask_info'][el]['range'][0]) == int]
+                 isinstance(el, tuple) and state in el and
+                 isinstance(meta_data['local_mask_info'][el]['range'][0], int)]
         if len(tmp_r):
             max_r[state] = max(tmp_r)
         else:
@@ -291,7 +293,7 @@ def _calc_row_upd(inp):
                 try:
                     tot_act_well = [elem for elem in meta_data['tot_well_dict']
                                     [well[0].split()[1]] if elem[2] == el]
-                except:
+                except Exception:
                     tot_act_well = [elem for elem in meta_data['tot_well_dict'][well]]
                 # curr_completions = frozenset((inp[1][tot_act_well[0]]['position']))
                 tot_act_data_types = set([el[0].split()[0] for el in tot_act_well])
@@ -335,7 +337,7 @@ def _calc_region(loc_info, states, field_dim, actnum):
     ----------
     loc_info : dict
         Information for localization
-    states : dict 
+    states : dict
         State variables
     field_dim : list
         Dimension of grid
@@ -349,7 +351,7 @@ def _calc_region(loc_info, states, field_dim, actnum):
     """
     regions = {}
     for state in states:
-        tmp_reg = [loc_info[el]['range'] for el in loc_info.keys() if type(el) == tuple and 'region' in loc_info[el]['taper_func']
+        tmp_reg = [loc_info[el]['range'] for el in loc_info.keys() if isinstance(el, tuple) and 'region' in loc_info[el]['taper_func']
                    and state in el]
         unique_reg = [el for el in set(map(tuple, tmp_reg))]
         regions[state] = []
@@ -376,7 +378,7 @@ def _get_region(reg, field_dim=None, actnum=None):
 
     Parameters
     ----------
-    reg : 
+    reg :
     field_dim : list
         Dimension of grid
     actnum : ndarray
@@ -388,7 +390,7 @@ def _get_region(reg, field_dim=None, actnum=None):
     """
 
     # Get the files
-    if type(reg[0]) == str:
+    if isinstance(reg[0], str):
         flag_region = [int(el) for el in reg[1:]]
         with open(reg[0], 'r') as file:
             lines = file.readlines()
@@ -528,7 +530,6 @@ def calc_autocov(pert):
     # Return the auto-covariance matrix
     return cov_auto
 
-
 def calc_objectivefun(pert_obs, pred_data, Cd):
     """
     Calculate the objective function.
@@ -552,107 +553,28 @@ def calc_objectivefun(pert_obs, pred_data, Cd):
     #ne = pred_data.shape[1]
     ne = pert_obs.shape[1]
     r = (pred_data[:, :ne] - pert_obs)  # Only use ne members (gies code has ne+1 predicted data)
+    # The per-member misfit is the diagonal of r.T @ (Cd^-1 r). Summing the
+    # columns gives the same numbers without forming the (ne, ne) product.
     if len(Cd.shape) == 1:
-        precission = Cd**(-1)
-        data_misfit = np.diag(r.T.dot(r*precission[:, None]))
+        precision = Cd**(-1)
+        data_misfit = np.sum(r * (r*precision[:, None]), axis=0)
     else:
-        data_misfit = np.diag(r.T.dot(linalg.solve(Cd, r)))
+        data_misfit = np.sum(r * linalg.solve(Cd, r), axis=0)
 
     return data_misfit
 
 
-def calc_crosscov(pert1, pert2):
-    """
-    Calculate sample cross-covariance matrix.
-
-    Parameters
-    ----------
-    pert1, pert2: ndarray
-        Perturbation matrices (matrix of variables perturbed with their mean).
-
-    Returns
-    -------
-    cov_cross : ndarray
-        Sample cross-covariance matrix
-    """
-    # TODO: Implement sqrt-covariance matrices
-
-    # No of samples
-    ne = pert1.shape[1]
-
-    # Standard calc. of sample cross-covariance
-    cov_cross = (1 / (ne - 1)) * np.dot(pert1, pert2.T)
-
-    # Return the cross-covariance matrix
-    return cov_cross
-
-
-def update_datavar(cov_data, datavar, assim_index, list_data):
+def save_assimilation_result(ind_save, **kwargs):
     """
-    Extract the separate variance from an augmented vector. It is assumed that the augmented variance
-    is made gen_covdata, hence this is the reverse method of gen_covdata.
-
-    Parameters
-    ----------
-    cov_data : array-like
-        Augmented vector of variance.
-
-    datavar : dict
-        Dictionary of separate variances.
-
-    assim_index : list
-        Assimilation order as a list.
-
-    list_data : list
-        List of data keys.
-
-    Returns
-    -------
-    datavar : dict
-        Updated dictionary of separate variances."""
-
-    # Loop over all entries in list_state and extract a vector with same number of elements as the key in datavar
-    # determines from aug and replace the values in datavar[key].
-
-    # Make sure assim_index is list
-    if isinstance(assim_index[1], list):  # Check if prim. ind. is a list
-        l_prim = [int(x) for x in assim_index[1]]
-    else:
-        l_prim = [int(assim_index[1])]
-
-    # Extract the diagonal if cov_data is a matrix
-    if len(cov_data.shape) == 2:
-        cov_data = np.diag(cov_data)
-
-    # Initialize a variable to keep track of which row in 'cov_data' we start from in each loop
-    aug_row = 0
-    # Loop over all primary indices
-    for ix in range(len(l_prim)):
-        # Loop over data types and augment the data variance
-        for i in range(len(list_data)):
-            if datavar[l_prim[ix]][list_data[i]] is not None:
-
-                # If there is an observed data here, update it
-                no_rows = datavar[l_prim[ix]][list_data[i]].shape[0]
-
-                # Extract the rows from aug and update 'state[key]'
-                datavar[l_prim[ix]][list_data[i]] = cov_data[aug_row:aug_row + no_rows]
-
-                # Update tracking variable for row in 'aug'
-                aug_row += no_rows
+    Save the requested variables for one assimilation iteration.
 
-    # Return
-    return datavar
-
-
-def save_analysisdebug(ind_save, **kwargs):
-    """
-    Save variables in analysis step for debugging purpose
+    The PIPT counterpart to ``popt.misc_tools.optim_tools.save_optimize_results``,
+    which writes ``optimize_result_{i}.npz``.
 
     Parameters
     ----------
     ind_save : int
-        Index of analysis step
+        Iteration index. ``0`` is the prior.
     **kwargs : dict
         Variables that will be saved to npz file
 
@@ -663,16 +585,33 @@ def save_analysisdebug(ind_save, **kwargs):
     """
     # Save input variables
     folder = kwargs.pop('savefolder')
+    os.makedirs(folder, exist_ok=True)
     try:
-        np.savez(f'{folder}/debug_analysis_step_{ind_save}', **kwargs)
-    except: # if npz save fails dump to a pickle file
-        with open(f'{folder}/debug_analysis_step_{ind_save}.p', 'wb') as file:
+        np.savez(f'{folder}/assimilation_result_{ind_save}', **kwargs)
+    except Exception: # if npz save fails dump to a pickle file
+        with open(f'{folder}/assimilation_result_{ind_save}.p', 'wb') as file:
             pickle.dump(kwargs, file)
 
 
+def save_analysisdebug(ind_save, **kwargs):
+    """Deprecated alias for :func:`save_assimilation_result`.
+
+    The files are not a debugging aid -- they are the per-iteration record of
+    a run -- so both the function and what it writes were renamed.
+    """
+    warnings.warn(
+        "save_analysisdebug is deprecated; use save_assimilation_result. "
+        "Note that it now writes 'assimilation_result_{i}.npz' rather than "
+        "'debug_analysis_step_{i}.npz'.",
+        DeprecationWarning,
+        stacklevel=2,
+    )
+    return save_assimilation_result(ind_save, **kwargs)
+
+
 def get_list_data_types(obs_data, assim_index):
     """
-    Extract the list of all and active data types 
+    Extract the list of all and active data types
 
     Parameters
     ----------
@@ -802,56 +741,6 @@ def gen_covdata(datavar, assim_index, list_data):
     return cd
 
 
-def screen_data(cov_data, pred_data, obs_data_vector, keys_da, iteration):
-    """
-    INSERT DESCRIPTION
-
-    Parameters
-    ----------
-    cov_data : ndarray
-        Data covariance matrix
-    pred_data : ndarray
-        Predicted data
-    obs_data_vector : 
-        Observed data (1D array)
-    keys_da : dict
-        Dictionary with every input in `DATAASSIM`
-    iteration : int
-        Current iteration
-
-    Returns
-    -------
-    cov_data : ndarray
-        Updated data covariance matrix
-    """
-
-    if ('restart' in keys_da and keys_da['restart'] == 'yes') or (iteration != 0):
-        with open('cov_data.p', 'rb') as f:
-            cov_data = pickle.load(f)
-    else:
-        emp_cov = False
-        if cov_data.ndim == 2:  # assume emp_cov
-            emp_cov = True
-            var = np.var(cov_data, ddof=1, axis=1)
-            cov_data = cov_data - cov_data.mean(1)[:, np.newaxis]
-        num_data = pred_data.shape[0]
-        for i in range(num_data):
-            v = 0
-            if obs_data_vector[i] < np.min(pred_data[i, :]):
-                v = np.abs(obs_data_vector[i] - np.min(pred_data[i, :]))
-            elif obs_data_vector[i] > np.max(pred_data[i, :]):
-                v = np.abs(obs_data_vector[i] - np.max(pred_data[i, :]))
-            if not emp_cov:
-                cov_data[i] = np.max((cov_data[i], v ** 2))
-            else:
-                v = np.max((v**2 / var[i], 1))
-                cov_data[i, :] *= np.sqrt(v)
-        with open('cov_data.p', 'wb') as f:
-            pickle.dump(cov_data, f)
-
-    return cov_data
-
-
 def store_ensemble_sim_information(saveinfo, member):
     """
     Here, we can either run a unique python script or do some other post-processing routines. The function should
@@ -867,54 +756,6 @@ def store_ensemble_sim_information(saveinfo, member):
             sim_info_func.main(member)
 
 
-def extract_tot_empirical_cov(data_var, assim_index, list_data, ne):
-    """
-    Extract realizations of noise from data_var (if imported), or generate realizations if only variance is specified
-    (assume uncorrelated)
-
-    Parameters
-    ----------
-    data_var : list
-        List of dictionaries containing the varianse as read from the input
-    assim_index : int
-        Index of the assimilation
-    list_data : list
-        List of data types
-    ne : int
-        Ensemble size
-
-    Returns
-    -------
-    E : ndarray
-        Sorted (according to assim_index and list_data) matrix of data realization noise.
-    """
-
-    if isinstance(assim_index[1], list):  # Check if prim. ind. is a list
-        l_prim = [int(x) for x in assim_index[1]]
-    else:
-        l_prim = [int(assim_index[1])]
-
-    tmp_E = []
-    for el in l_prim:
-        tmp_tmp_E = {}
-        for dat in list_data:
-            if data_var[el][dat] is not None:
-                if len(data_var[el][dat].shape) == 1:
-                    tmp_tmp_E[dat] = np.sqrt(
-                        data_var[el][dat][:, np.newaxis])*np.random.randn(data_var[el][dat].shape[0], ne)
-                else:
-                    if data_var[el][dat].shape[0] == data_var[el][dat].shape[1]:
-                        tmp_tmp_E[dat] = np.dot(linalg.cholesky(
-                            data_var[el][dat]), np.random.randn(data_var[el][dat].shape[1], ne))
-                    else:
-                        tmp_tmp_E[dat] = data_var[el][dat]
-        tmp_E.append(tmp_tmp_E)
-    E = np.concatenate(tuple(tmp_E[i][dat] for i, el in enumerate(
-        l_prim) for dat in list_data if data_var[el][dat] is not None))
-
-    return E
-
-
 def aug_obs_pred_data(obs_data, pred_data, assim_index, list_data):
     """
     Augment the observed and predicted data to an array at an assimilation step. The observed data will be an augemented
@@ -930,7 +771,7 @@ def aug_obs_pred_data(obs_data, pred_data, assim_index, list_data):
 
     Returns
     -------
-    obs : ndarray 
+    obs : ndarray
         Augmented vector of observed data
     pred : ndarray
         Ensemble matrix of predicted data
@@ -948,7 +789,7 @@ def aug_obs_pred_data(obs_data, pred_data, assim_index, list_data):
 
     tot_pred = tuple(pred_data[el][dat] for el in l_prim if pred_data[el]
                      is not None for dat in list_data if obs_data[el][dat] is not None)
-    
+
     if len(tot_pred):  # if this is done during the initiallization tot_pred contains nothing
         pred = np.concatenate(tot_pred)
     else:
@@ -995,202 +836,6 @@ def aug_obs_pred_data(obs_data, pred_data, assim_index, list_data):
     return obs, pred
 
 
-def calc_kalmangain(cov_cross, cov_auto, cov_data, opt=None):
-    r"""
-    Calculate the Kalman gain
-
-    Parameters
-    ----------
-    cov_cross : ndarray
-        Cross-covariance matrix between state and predicted data
-    cov_auto : ndarray
-        Auto-covariance matrix of predicted data
-    cov_data : ndarray
-        Variance on observed data (diagonal matrix)
-    opt : str
-        Which method should we use to calculate Kalman gain
-        
    
-            
  • 'lu': LU decomposition (default)
    • 
-            
  • 'chol': Cholesky decomposition
    • 
-        

-
-    Returns
-    -------
-    kalman_gain : ndarray
-        Kalman gain
-
-    Notes
-    -----
-    In the following Kalman gain is $K$, cross-covariance is $C_{mg}$, predicted data auto-covariance is $C_{g}$,
-    and data covariance is $C_{d}$.
-
-    With `'lu'` option, we solve the transposed linear system:
-    $$
-        K^T = (C_{g} + C_{d})^{-T}C_{mg}^T
-    $$
-
-    With `'chol'` option we use Cholesky on auto-covariance matrix,
-    $$
-       L L^T = (C_{g} + C_{d})^T
-    $$
-    and solve linear system with the square-root matrix from Cholesky:
-    $$
-        L^T Y = C_{mg}^T\\
-        LK = Y
-    $$
-    """
-    if opt is None:
-        calc_opt = 'lu'
-
-    # Add data and predicted data auto-covariance matrices
-    if len(cov_data.shape) == 1:
-        cov_data = np.diag(cov_data)
-    c_auto = cov_auto + cov_data
-
-    if calc_opt == 'lu':
-        kg = linalg.solve(c_auto.T, cov_cross.T)
-        kalman_gain = kg.T
-
-    elif calc_opt == 'chol':
-        # Cholesky decomp (upper triangular matrix)
-        u = linalg.cho_factor(c_auto.T, check_finite=False)
-
-        # Solve linear system with cholesky square-root
-        kalman_gain = linalg.cho_solve(u, cov_cross.T, check_finite=False)
-
-    # Return Kalman gain
-    return kalman_gain
-
-
-def calc_subspace_kalmangain(cov_cross, data_pert, cov_data, energy):
-    """
-    Compute the Kalman gain in a efficient subspace determined by how much energy (i.e. percentage of singluar values)
-    to retain. For more info regarding the implementation, see Chapter 14 in [`evensen2009a`][].
-
-    Parameters
-    cov_cross : ndarray
-        Cross-covariance matrix between state and predicted data
-    data_pert : ndarray
-            Predicted data - mean of predicted data
-    cov_data : ndarray
-        Variance on observed data (diagonal matrix)
-
-    Returns
-    -------
-    k_g : ndarray
-        Subspace Kalman gain
-    """
-    # No. ensemble members
-    ne = data_pert.shape[1]
-
-    # Perform SVD on pred. data perturbations
-    u_d, s_d, v_d = np.linalg.svd(np.sqrt(1 / (ne - 1)) * data_pert, full_matrices=False)
-
-    # If no. measurements is more than ne - 1, we only keep ne - 1 sing. val.
-    if data_pert.shape[0] >= ne:
-        u_d, s_d, v_d = u_d[:, :-1].copy(), s_d[:-1].copy(), v_d[:-1, :].copy()
-
-    # If energy is less than 100 we truncate the SVD matrices
-    if energy < 100:
-        ti = (np.cumsum(s_d) / sum(s_d)) * 100 <= energy
-        u_d, s_d, v_d = u_d[:, ti].copy(), s_d[ti].copy(), v_d[ti, :].copy()
-
-    # Calculate x_0 and its eigenvalue decomp.
-    if len(cov_data.shape) == 1:
-        x_0 = np.dot(np.diag(s_d[:]**(-1)), np.dot(u_d[:, :].T, np.expand_dims(cov_data, axis=1)*np.dot(u_d[:, :],
-                                                                                                        np.diag(s_d[:]**(-1)).T)))
-    else:
-        x_0 = np.dot(np.diag(s_d[:] ** (-1)), np.dot(u_d[:, :].T, np.dot(cov_data, np.dot(u_d[:, :],
-                                                                                          np.diag(s_d[:] ** (-1)).T))))
-    s, u = np.linalg.eig(x_0)
-
-    # Calculate x_1
-    x_1 = np.dot(u_d[:, :], np.dot(np.diag(s_d[:]**(-1)).T, u))
-
-    # Calculate Kalman gain based on the subspace matrices we made above
-    k_g = np.dot(cov_cross, np.dot(x_1, linalg.solve(
-        (np.eye(s.shape[0]) + np.diag(s)), x_1.T)))
-
-    # Return subspace Kalman gain
-    return k_g
-
-
-def compute_x(pert_preddata, cov_data, keys_da, alfa=None):
-    """
-    INSERT DESCRIPTION
-
-    Parameters
-    ----------
-    pert_preddata : ndarray
-        Perturbed predicted data
-    cov_data : ndarray
-        Data covariance matrix
-    keys_da : dict
-        Dictionary with every input in `DATAASSIM`
-    alfa : None, optional
-        INSERT DESCRIPTION
-
-    Returns
-    -------
-    X : ndarray
-        INSERT DESCRIPTION
-    """
-    X = []
-    if 'kalmangain' in keys_da and keys_da['kalmangain'][0] == 'subspace':
-
-        # TSVD energy
-        energy = keys_da['kalmangain'][1]
-
-        # No. ensemble members
-        ne = pert_preddata.shape[1]
-
-        # Calculate x_0 and its eigenvalue decomp.
-        if len(cov_data.shape) == 1:
-            scale = np.expand_dims(np.sqrt(cov_data), axis=1)
-        else:
-            scale = np.expand_dims(np.sqrt(np.diag(cov_data)), axis=1)
-
-        # Perform SVD on pred. data perturbations
-        u_d, s_d, v_d = np.linalg.svd(pert_preddata/scale, full_matrices=False)
-
-        # If no. measurements is more than ne - 1, we only keep ne - 1 sing. val.
-        if pert_preddata.shape[0] >= ne:
-            u_d, s_d, v_d = u_d[:, :-1].copy(), s_d[:-1].copy(), v_d[:-1, :].copy()
-
-        # If energy is less than 100 we truncate the SVD matrices
-        if energy < 100:
-            ti = (np.cumsum(s_d) / sum(s_d)) * 100 <= energy
-            u_d, s_d, v_d = u_d[:, ti].copy(), s_d[ti].copy(), v_d[ti, :].copy()
-
-        # Calculate x_0 and its eigenvalue decomp.
-        if len(cov_data.shape) == 1:
-            x_0 = np.dot(np.diag(s_d[:] ** (-1)),
-                         np.dot(u_d[:, :].T, np.expand_dims(cov_data, axis=1) * np.dot(u_d[:, :],
-                                                                                       np.diag(s_d[:] ** (-1)).T)))
-        else:
-            x_0 = np.dot(np.diag(s_d[:] ** (-1)), np.dot(u_d[:, :].T, np.dot(cov_data, np.dot(u_d[:, :],
-                                                                                              np.diag(s_d[:] ** (-1)).T))))
-        s, u = np.linalg.eig(x_0)
-
-        # Calculate x_1
-        x_1 = np.dot(u_d[:, :], np.dot(np.diag(s_d[:] ** (-1)).T, u))/scale
-
-        # Calculate X based on the subspace matrices we made above
-        X = np.dot(np.dot(pert_preddata.T, x_1), linalg.solve(
-            (np.eye(s.shape[0]) + np.diag(s)), x_1.T))
-
-    else:
-        if len(cov_data.shape) == 1:
-            X = linalg.solve(np.dot(pert_preddata, pert_preddata.T) +
-                             np.diag(cov_data), pert_preddata)
-        else:
-            X = linalg.solve(np.dot(pert_preddata, pert_preddata.T) +
-                             cov_data, pert_preddata)
-        X = X.T
-
-    return X
-
-
 def aug_state(state, list_state, cell_index=None):
     """
     Augment the state variables to an array.
@@ -1243,10 +888,12 @@ def calc_scaling(enX, idX, prior_info):
 
     Parameters
     ----------
-    state : dict
-        Dictionary containing the state
-    list_state : list
-        List of states for augmenting
+    enX : np.ndarray
+        State ensemble matrix, shape ``(nx, ne)``; only its row count per
+        variable is used.
+    idX : dict
+        Row range ``(start, stop)`` of each state variable in ``enX``, in the
+        order the state was stacked.
     prior_info : dict
         Nested dictionary containing prior information
 
@@ -1260,13 +907,14 @@ def calc_scaling(enX, idX, prior_info):
     for elem in idX.keys():
         # more than single value. This is for multiple layers. Assume all values are active
         if len(prior_info[elem]['variance']) > 1:
-            scaling.append(np.concatenate(tuple(np.sqrt(prior_info[elem]['variance'][z]) *
-                                                np.ones(
-                                                    prior_info[elem]['ny']*prior_info[elem]['nx'])
-                                                for z in range(prior_info[elem]['nz']))))
+            ny = prior_info[elem]['ny']
+            nx = prior_info[elem]['nx']
+            scaling.append(np.tile(np.sqrt(prior_info[elem]['variance']), ny*nx))
         else:
-            scaling.append(tuple(np.sqrt(prior_info[elem]['variance']) *
-                                 np.ones(enX[idX[elem][0]:idX[elem][1]].shape[0])))
+            i = idX[elem][0]
+            j = idX[elem][1]
+            ones = np.ones(enX[i:j].shape[0])
+            scaling.append(np.sqrt(prior_info[elem]['variance']) * ones)
 
     return np.concatenate(scaling)
 
@@ -1321,117 +969,6 @@ def update_state(aug_state, state, list_state, cell_index=None):
     return state
 
 
-def resample_state(aug_state, state, list_state, new_en_size):
-    """
-    Extract the seperate state variables from an augmented state matrix. Calculate the mean and covariance, and resample
-    this.
-
-    Parameters
-    ----------
-    aug_state : ndarray
-        Augmented matrix of state variables
-    state : dict
-        Dict. af state variables
-    list_state : list
-        List of state variable
-    new_en_size : int
-        Size of the new ensemble
-
-    Returns
-    -------
-    state : dict
-        Dict. of resampled members
-    """
-
-    aug_row = 0
-    curr_ne = state[list_state[0]].shape[1]
-    new_state = {}
-    for elem in list_state:
-        # determine how many rows to extract
-        no_rows = state[elem].shape[0]
-        new_state[elem] = np.empty((no_rows, new_en_size))
-
-        mean_state = np.mean(aug_state[aug_row:aug_row + no_rows, :], 1)
-        pert_state = np.sqrt(1/(curr_ne - 1)) * (aug_state[aug_row:aug_row + no_rows, :] - np.dot(np.resize(mean_state,
-                                                                                                            (len(mean_state), 1)), np.ones((1, curr_ne))))
-        for i in range(new_en_size):
-            new_state[elem][:, i] = mean_state + \
-                np.dot(pert_state, np.random.normal(0, 1, pert_state.shape[1]))
-
-        aug_row += no_rows
-
-    return new_state
-
-
-def block_diag_cov(cov, list_state):
-    """
-    Block diagonalize a covariance matrix dictionary.
-
-    Parameters
-    ----------
-    cov : dict
-        Dict. with cov. matrices
-    list_state : list
-        Fixed list of keys in state dict.
-
-    Returns
-    -------
-    cov_out : ndarray
-        Block diag. matrix with prior covariance matrices for each state.
-    """
-    # TODO: Change if there are cross-correlation between different states
-
-    # Init. block in matrix
-    cov_out = cov[list_state[0]]
-
-    # Test if scalar has been given in init. block
-    if not hasattr(cov_out, '__len__'):
-        cov_out = np.array([[cov_out]])
-
-    # Loop of rest of the state-names and add in block diag. matrix
-    for i in range(1, len(list_state)):
-        cov_out = linalg.block_diag(cov_out, cov[list_state[i]])
-
-    # Return
-    return cov_out
-
-
-def calc_kalman_filter_eq(aug_state, kalman_gain, obs_data, pred_data):
-    """
-    Calculate the updated augment state using the Kalman filter equations
-
-    Parameters
-    ----------
-    aug_state : ndarray
-        Augmented state variable (all the parameters defined in `STATICVAR` augmented in one array)
-    kalman_gain : ndarray
-        Kalman gain
-    obs_data : ndarray
-        Augmented observed data vector (all `OBSNAME` augmented in one array)
-    pred_data : ndarray
-        Augmented predicted data vector (all `OBSNAME` augmented in one array)
-
-    Returns
-    -------
-    aug_state_upd : ndarray
-        Updated augmented state variable using the Kalman filter equations
-    """
-    # TODO: Implement svd updating algorithm
-
-    # Matrix version
-    # aug_state_upd = aug_state + np.dot(kalman_gain, (obs_data - pred_data))
-
-    # For-loop version
-    aug_state_upd = np.zeros(aug_state.shape)  # Init. updated state
-
-    for i in range(aug_state.shape[1]):  # Loop over ensemble members
-        aug_state_upd[:, i] = aug_state[:, i] + \
-            np.dot(kalman_gain, (obs_data[:, i] - pred_data[:, i]))
-
-    # Return the updated state
-    return aug_state_upd
-
-
 def limits(state, prior_info):
     """
     Check if any state variables overshoots the limits given by the prior info. If so, modify these values
@@ -1455,44 +992,6 @@ def limits(state, prior_info):
     return state
 
 
-def subsample_state(index, aug_state, pert_state):
-    """
-    Draw a subsample from the original state, given by the index
-
-    Parameters
-    ----------
-    index : ndarray
-        Index of parameters to draw.
-    aug_state : ndarray
-        Original augmented state.
-    pert_state : ndarray
-        Perturbed augmented state, for error covariance.
-
-    Returns
-    -------
-    new_state : dict
-        Subsample of state.
-    """
-
-    new_state = np.empty((aug_state.shape[0], len(index)))
-    for i in range(len(index)):
-        new_state[:, i] = aug_state[:, index[i]] + \
-            np.dot(pert_state, np.random.normal(0, 1, pert_state.shape[1]))
-        # select some elements
-
-    return new_state
-
-
-def get_obs_size(obs_data, time_index, datatypes):
-    """Return a 2D list of sizes for each observation array."""
-    return [
-        [
-            obs_data[int(time)][data].size if obs_data[int(time)][data] is not None else 0
-            for data in datatypes
-        ]
-        for time in time_index
-    ]
-
 def truncSVD(matrix, r=None, energy=None, full_matrices=False):
     '''
     Perform truncated SVD on input matrix.
@@ -1506,19 +1005,24 @@ def truncSVD(matrix, r=None, energy=None, full_matrices=False):
         Rank to truncate the SVD to. If None, energy must be specified.
 
     energy : float, optional
-        Percentage of energy to retain in the truncated SVD. If None, r must be specified.
+        Fraction of the singular-value sum to retain, given either as a fraction
+        in (0, 1] or as a percentage in (1, 100]. The smallest rank whose
+        retained fraction reaches this value is used, so the requested amount is
+        met rather than approached from below. Note this accumulates the
+        singular values themselves, not their squares -- it is a fraction of the
+        nuclear norm, not of the Frobenius energy. If None, r must be specified.
 
     full_matrices : bool, optional
         Whether to compute full or reduced SVD. Default is False.
-    
+
     Returns
     -------
     U : ndarray, shape (m, r)
         Left singular vectors.
-    
+
     S : ndarray, shape (r,)
         Singular values.
-    
+
     VT : ndarray, shape (r, n)
         Right singular vectors transposed.
     '''
@@ -1527,20 +1031,90 @@ def truncSVD(matrix, r=None, energy=None, full_matrices=False):
 
     # If not specified rank, energy must be given
     if r is None:
-        if energy is not None:
-            # Energy is given as fraction
-            if energy < 1:
-                r = np.searchsorted(np.cumsum(S)/np.sum(S), energy)
-            # Energy is given as a percentage
-            else:
-                r = np.searchsorted(np.cumsum(S)/np.sum(S), energy/100)
-        else:
+        if energy is None:
             raise ValueError("Either rank 'r' or 'energy' must be specified for truncSVD.")
-    
+
+        # Accept a percentage (1, 100] as well as a fraction (0, 1]. The bound is
+        # exclusive so that energy=1 keeps everything rather than meaning 1%.
+        fraction = energy/100 if energy > 1 else energy
+
+        total = np.sum(S)
+        if total == 0:
+            # No spectrum to apportion; nothing is more representative than
+            # anything else, so keep it all rather than dividing by zero.
+            r = len(S)
+        else:
+            # searchsorted gives the first index at which the cumulative
+            # fraction REACHES `fraction`; that index must be kept, hence +1.
+            # Clamped here rather than below so that energy=1 does not trip the
+            # "specified rank" warning on a rounding error in the last entry.
+            r = min(int(np.searchsorted(np.cumsum(S)/total, fraction)) + 1, len(S))
+
     if r == 0:
         r = 1  # Ensure at least one singular value is retained
     if r > len(S):
-        print("Warning: Specified rank exceeds number of singular values. Using maximum available rank.")
+        warnings.warn("Specified rank exceeds the number of singular values; using all of them.", stacklevel=2)
         r = len(S)
 
-    return U[:,:r], S[:r], VT[:r,:]
\ No newline at end of file
+    return U[:,:r], S[:r], VT[:r,:]
+
+def get_outlier_index(
+    pred,
+    data,
+    data_var=None,
+    tresh=4.0
+):
+    """
+    Identify outlier ensemble members based on a normalized data-mismatch score.
+
+    For each ensemble member j, the mismatch is:
+
+        h_j = sum_i ((Y_ij - d_i) / sigma_i)^2
+
+    where sigma_i is the ensemble standard deviation (or provided variance) for observable i.
+    Members whose score deviates more than `tresh` standard deviations from the mean are flagged as outliers.
+
+    Parameters
+    ----------
+    pred : array_like, shape (nd, ne)
+        Predicted data ensemble, one column per member.
+    data : array_like, shape (nd,)
+        Observed data, in the same row order.
+    data_var : array_like or None, optional
+        Data variance, ``(nd,)`` or ``(nd, ne)`` for an empirical ensemble. If not provided, the ensemble
+        variance of the predicted data is used.
+    tresh : float, optional
+        Outlier threshold in numbers of standard deviations. Default is 4.
+
+    Returns
+    -------
+    outlier_indices : np.ndarray
+        Indices of outlier ensemble members.
+    members : np.ndarray
+        Array of ensemble member indices, with outliers replaced by randomly selected non-outlier members.
+    """
+    Y = np.asarray(pred, dtype=float)  # (nd, ne)
+    d = np.asarray(data, dtype=float).reshape(-1, 1)  # (nd, 1)
+
+    # Determine variance for normalization
+    if data_var is not None:
+        var = np.asarray(data_var, dtype=float)
+        if var.ndim == 1:
+            var = var[:, np.newaxis]
+    else:
+        var = np.var(Y, axis=1, ddof=1)[:, np.newaxis]
+
+    # Compute normalized data-mismatch score for each ensemble member
+    mismatch = np.sum(((Y - d) / np.sqrt(var)) ** 2, axis=0)  # (ne,)
+
+    # Identify outliers using the sigma rule
+    mean_mismatch = np.mean(mismatch)
+    std_mismatch = np.std(mismatch)
+    outlier_mask = np.abs(mismatch - mean_mismatch) > tresh * std_mismatch
+    outlier_indices = np.where(outlier_mask)[0]
+    non_outlier_members = np.where(~outlier_mask)[0]
+
+    if len(outlier_indices) > 0:
+        logging.getLogger(__name__).info(f" Identified outliers: {outlier_indices}")
+
+    return outlier_indices, non_outlier_members
diff --git a/src/pipt/misc_tools/cov_regularization.py b/src/pipt/misc_tools/cov_regularization.py
deleted file mode 100644
index 761cd0b0..00000000
--- a/src/pipt/misc_tools/cov_regularization.py
+++ /dev/null
@@ -1,888 +0,0 @@
-"""
-Scripts used for localization in the fwd_sim step of Bayes.
-
-Changelog
----------
-- 28/6-16: Initialise major reconstruction of the covariance regularization script.
-
-Main outline is:
-
-- make this a collection of support functions, not a class
-- initialization will be performed at the initialization of the ensemble class, not at the analysis step. This will
-  return a dictionary of dictionaries, with a triple as key (data_type, assim_time, parameter). From this key the info
-  for a unique localization function can be found as a new dictionary with keys:
-  `taper_func`, `position`, `anisotropi`, `range`.
-  This is, potentially, a substantial amount of data which should be imported
-  as a npz file. For small cases, it can be defined in the init file in csv
-  form:
-
-      LOCALIZATION
-      FIELD    10 10
-      fb 2 2 1 5 1 0 WBHP PRO-1 10 PERMX,fb 7 7 1 5 1 0 WBHP PRO-2 10 PERMX,fb 5 5 1 5 1 0 WBHP INJ-1 10 PERMX
-      (taper_func pos(x) pos(y) pos(z) range range(z) anisotropi(ratio) anisotropi(angel) data well assim_time parameter)
-
-- Generate functions that return the correct localization function.
-"""
-
-__author__ = 'kfo005'
-
-
-import numpy as np
-import scipy.linalg as linalg
-from scipy.special import expit
-import os
-import pickle
-import csv
-import datetime as dt
-from shutil import rmtree
-from scipy import sparse
-from scipy.spatial import distance
-from typing import Union
-
-# internal import
-import pipt.misc_tools.analysis_tools as at
-from pipt.misc_tools.extract_tools import list_to_dict
-
-
-class localization():
-    #####
-    # TODO: Check field dimensions, should always ensure that we can provide i ,j ,k (x, y, z)
-    ###
-
-    def __init__(self, parsed_info: Union[dict,list], assimIndex: list, data_typ: list, free_parameter: list, ne: int):
-        """
-        Format the parsed info from the input file, and generate the unique localization masks
-        """
-        # Make parsed_info to a dict
-        if isinstance(parsed_info, list):
-            parsed_info = list_to_dict(parsed_info)
-        assert isinstance(parsed_info, dict)
-
-        # Initialize
-        init_local = {}
-
-        # Assert field keyword in parsed_info
-        assert 'field' in parsed_info
-        init_local['field'] = [int(elem) for elem in parsed_info['field']]
-
-        # Check for ACTNUM
-        init_local['actnum'] = None
-        if 'actnum' in parsed_info:
-            file = parsed_info['actnum']
-            assert file.endswith('.npz') # this must be a .npz file!!
-            init_local['actnum'] = np.load(file)
-
-        # Check for threshold
-        if 'threshold' in parsed_info:
-            init_local['threshold'] = parsed_info['threshold']
-   
-        # Check localization method/type
-        try:
-            if 'autoadaloc' in parsed_info:
-                init_local['autoadaloc'] = True
-                init_local['nstd'] = parsed_info['autoadaloc']
-                if 'type' in parsed_info:
-                    init_local['type'] = parsed_info['type']
-            elif 'localanalysis' in parsed_info:
-                init_local = {'localanalysis': True}
-                if 'type' in parsed_info:
-                    init_local['type'] = parsed_info['type']
-                if 'range' in parsed_info:
-                    init_local['range'] = float(parsed_info['range'])
-            else:
-                # Load from pickle file
-                picklefile = None
-                for key, val in parsed_info.items():
-                    if (str(val).endswith('.p')) or (str(val).endswith('.pkl')):
-                        picklefile = key
-                        break
-                init_local = pickle.load(open(parsed_info[picklefile], 'rb'))
-
-        except:
-            # no file could be loaded, initiallize the outer dictionary
-            init_local = {}
-            for time in assimIndex:
-                for datum in data_typ:
-                    for parameter in free_parameter:
-                        init_local[(datum, time, parameter)] = {
-                            'taper_func': None,
-                            'position': None,
-                            'anisotropi': None,
-                            'range': None
-                        }
-            # If you expect a key with a CSV filename, find it:
-            csv_key = next((k for k in parsed_info if str(k).endswith('.csv')), None)
-            if csv_key:
-                with open(csv_key) as csv_file:
-                    reader = csv.reader(csv_file)
-                    info = [elem for elem in reader]
-                info = [item for sublist in info for item in sublist]
-            # Else find the key-string that contains the info
-            else:
-                for key, val in parsed_info.items():
-                    if len(key.split(',')) > 1:
-                        info = key.split(',')
-                        break
-                    else:
-                        info = []
-
-            for elem in info:
-                # If a predefined mask is to be imported the localization keyword must be
-                # [import filename.npz]
-                # where filename is the name of the .npz file to be uploaded.
-                tmp_info = elem.split()
-
-                # format the data and time elements
-                if len(tmp_info) == 11:  # data has only one name
-                    name = (tmp_info[8].lower(), float(tmp_info[9]), tmp_info[10].lower())
-                else:
-                    name = (tmp_info[8].lower() + ' ' + tmp_info[9].lower(),
-                            float(tmp_info[10]), tmp_info[11].lower())
-
-                # assert if the data to be localized actually exists
-                if name in init_local.keys():
-
-                    # input the correct info into the localization dictionary
-                    init_local[name]['taper_func'] = tmp_info[0]
-                    if tmp_info[0] == 'import':
-                        # if a predefined mask is to be imported, the name is the following element.
-                        init_local[name]['file'] = tmp_info[1]
-                    else:
-                        # the position can span over multiple cells, e.g., 55:100. Hence keep this input as a string
-                        init_local[name]['position'] = [
-                            [int(float(tmp_info[1])), int(float(tmp_info[2])), int(float(tmp_info[3]))]]
-                        init_local[name]['range'] = [int(tmp_info[4]), int(
-                            tmp_info[5])]  # the range is always an integer
-                        init_local[name]['anisotropi'] = [
-                            float(tmp_info[6]), float(tmp_info[7])]
-
-
-        '''
-        # if the next element is a .p file (pickle), assume that this has been correctly formated and can be automatically
-        # imported. NB: it is important that we use the pickle format since we have a dictionary containing dictionaries
-        # to make this as robust as possible, we always try to load the file
-        try:
-            if parsed_info[1][0].upper() == 'AUTOADALOC':
-                init_local = {}
-                init_local['autoadaloc'] = True
-                init_local['nstd'] = parsed_info[1][1]
-                if len(parsed_info) > 2 and parsed_info[2][0] == 'type':
-                    init_local['type'] = parsed_info[2][1]
-            elif parsed_info[1][0].upper() == 'LOCALANALYSIS':
-                init_local = {}
-                init_local['localanalysis'] = True
-                for i, opt in enumerate(list(zip(*parsed_info))[0]):
-                    if opt.lower() == 'type':
-                        init_local['type'] = parsed_info[i][1]
-                    if opt.lower() == 'range':
-                        init_local['range'] = float(parsed_info[i][1])
-            else:
-                init_local = pickle.load(open(parsed_info[1][0], 'rb'))
-        except:
-            # no file could be loaded
-            # initiallize the outer dictionary
-            init_local = {}
-            for time in assimIndex:
-                for datum in data_typ:
-                    for parameter in free_parameter:
-                        init_local[(datum, time, parameter)] = {
-                            'taper_func': None,
-                            'position': None,
-                            'anisotropi': None,
-                            'range': None
-                        }
-            # insert the values that are defined
-            # check if data are provided through a .csv file
-            if parsed_info[1][0].endswith('.csv'):
-                with open(parsed_info[1][0]) as csv_file:
-                    # get all lines
-                    reader = csv.reader(csv_file)
-                    info = [elem for elem in reader]
-                # collapse
-                info = [item for sublist in info for item in sublist]
-            else:
-                info = parsed_info[1][0].split(',')
-            for elem in info:
-                #
-                # If a predefined mask is to be imported the localization keyword must be
-                # [import filename.npz]
-                # where filename is the name of the .npz file to be uploaded.
-                tmp_info = elem.split()
-
-                # format the data and time elements
-                if len(tmp_info) == 11:  # data has only one name
-                    name = (tmp_info[8].lower(), float(tmp_info[9]), tmp_info[10].lower())
-                else:
-                    name = (tmp_info[8].lower() + ' ' + tmp_info[9].lower(),
-                            float(tmp_info[10]), tmp_info[11].lower())
-
-                # assert if the data to be localized actually exists
-                if name in init_local.keys():
-
-                    # input the correct info into the localization dictionary
-                    init_local[name]['taper_func'] = tmp_info[0]
-                    if tmp_info[0] == 'import':
-                        # if a predefined mask is to be imported, the name is the following element.
-                        init_local[name]['file'] = tmp_info[1]
-                    else:
-                        # the position can span over multiple cells, e.g., 55:100. Hence keep this input as a string
-                        init_local[name]['position'] = [
-                            [int(float(tmp_info[1])), int(float(tmp_info[2])), int(float(tmp_info[3]))]]
-                        init_local[name]['range'] = [int(tmp_info[4]), int(
-                            tmp_info[5])]  # the range is always an integer
-                        init_local[name]['anisotropi'] = [
-                            float(tmp_info[6]), float(tmp_info[7])]
-        '''
-
-        # generate the unique localization masks. Recall that the parameters: "taper_type", "anisotropi", and "range"
-        # gives a unique mask.
-
-        # Check for 'threshold' key in parsed_info and copy it to init_local if found
-        for elem in parsed_info:
-            if 'threshold' in elem[0].lower():
-                init_local['threshold'] = elem[1]
-
-        init_local['mask'] = {}
-        # loop over all localization info to ensure that all the masks have been generated
-        # Store masks with the key ('taper_function', 'anisotropi', 'range')
-        loc_mask_info = [(init_local[el]['taper_func'], init_local[el]['anisotropi'][0], init_local[el]
-                          ['anisotropi'][1], init_local[el]['range']) for el in init_local.keys() if len(el) == 3]
-        for test_key in loc_mask_info:
-            if not len(init_local['mask']):
-                if test_key[0] == 'region':
-                    if isinstance(test_key[3], list):
-                        new_key = ('region', test_key[3][0],
-                                   test_key[3][1], test_key[3][2])
-                    else:
-                        new_key = ('region', test_key[3])
-                    init_local['mask'][new_key] = self._gen_loc_mask(taper_function=test_key[0],
-                                                                     anisotropi=[
-                                                                         test_key[1], test_key[2]],
-                                                                     loc_range=test_key[3],
-                                                                     field_size=init_local['field'],
-                                                                     ne=ne
-                                                                     )
-                else:
-                    if isinstance(test_key[3], list):
-                        new_key = (test_key[0], test_key[1],
-                                   test_key[2], test_key[3][0], test_key[3][1])
-                    else:
-                        new_key = test_key
-                    init_local['mask'][new_key] = self._gen_loc_mask(taper_function=test_key[0],
-                                                                     anisotropi=[
-                                                                         test_key[1], test_key[2]],
-                                                                     loc_range=test_key[3][0],
-                                                                     field_size=init_local['field'],
-                                                                     ne=ne
-                                                                     )
-            else:
-                # if loc = region, anisotropi has no meaning.
-                if test_key[0] == 'region':
-                    # If region there are two options:
-                    # 1: file. Unique parameters ('region', filename)
-                    # 2: area. Unique parameters ('region', 'x', 'y','z')
-                    if isinstance(test_key[3], list):
-                        new_key = ('region', test_key[3][0],
-                                   test_key[3][1], test_key[3][2])
-                    else:
-                        new_key = ('region', test_key[3])
-
-                    if new_key not in init_local['mask']:
-                        # generate this mask
-                        init_local['mask'][new_key] = self._gen_loc_mask(taper_function=test_key[0],
-                                                                         anisotropi=[
-                                                                             test_key[1], test_key[2]],
-                                                                         loc_range=test_key[3],
-                                                                         field_size=init_local['field'],
-                                                                         ne=ne
-                                                                         )
-
-                else:
-                    if isinstance(test_key[3], list):
-                        new_key = (test_key[0], test_key[1],
-                                   test_key[2], test_key[3][0], test_key[3][1])
-                    else:
-                        new_key = test_key
-
-                    if new_key not in init_local['mask']:
-                        # generate this mask
-                        init_local['mask'][new_key] = self._gen_loc_mask(taper_function=test_key[0],
-                                                                         anisotropi=[
-                                                                             test_key[1], test_key[2]],
-                                                                         loc_range=test_key[3][0],
-                                                                         field_size=init_local['field'],
-                                                                         ne=ne
-                                                                         )
-        self.loc_info = init_local
-
-    def localize(self, curr_data, curr_time, curr_param, ne, prior_info, data_size):
-        # generate the full localization mask
-        # potentially: current_time, curr_param, and curr_data are lists. Must loop over:
-        # curr_time, curr_data and curr param to generate localization mask
-        # rho = n_m (size of total parameters) x n_d (size of all data)
-
-        loc = []
-        for time_count, time in enumerate(curr_time):
-            for count, data in enumerate(curr_data):
-                if data_size[time_count][count] > 0:
-                    tmp_loc = [[] for _ in range(data_size[time_count][count])]
-                    for param in curr_param:
-                        # Check if this parameter should be localized
-                        if (data, time, param) in self.loc_info:
-                            if not self.loc_info[(data, time, param)]['taper_func'] == 'region':
-                                if isinstance(self.loc_info[(data, time, param)]['range'], list):
-                                    key = (self.loc_info[(data, time, param)]['taper_func'],
-                                           self.loc_info[(data, time, param)
-                                                         ]['anisotropi'][0],
-                                           self.loc_info[(data, time, param)
-                                                         ]['anisotropi'][1],
-                                           self.loc_info[(data, time, param)]['range'][0],
-                                           self.loc_info[(data, time, param)]['range'][1])
-                                    mask = self._repos_locmask(self.loc_info['mask'][key],
-                                                               [[el[0], el[1], el[2]] for el in
-                                                                self.loc_info[(data, time, param)]['position']],
-                                                               z_range=self.loc_info[(data, time, param)]['range'][1])
-                                else:
-                                    key = (self.loc_info[(data, time, param)]['taper_func'],
-                                           self.loc_info[(data, time, param)
-                                                         ]['anisotropi'][0],
-                                           self.loc_info[(data, time, param)
-                                                         ]['anisotropi'][1],
-                                           self.loc_info[(data, time, param)]['range'])
-                                    mask = self._repos_locmask(self.loc_info['mask'][key],
-                                                               [[el[0], el[1]] for el in
-                                                                self.loc_info[(data, time, param)]['position']])
-                                # if len(mask.shape) == 2: # this is field data
-                                #     # check that first axis is data, i.e., n_d X n_m
-                                #     if mask.shape[0] == data_size[time_count][count]:
-                                #         for i in range(data_size[time_count][count]):
-                                #             tmp_loc[i].append(mask[i, :])
-                                #         # tmp_loc = np.hstack((tmp_loc, mask)) if tmp_loc.size else mask # trick
-                                #     else:
-                                for i in range(data_size[time_count][count]):
-                                    tmp_loc[i].append(mask)
-                                    # tmp_loc = np.hstack((tmp_loc, mask.T)) if tmp_loc.size else mask.T
-                                # else:
-                                #     tmp_loc[0].append(mask)
-                                # tmp_loc = np.append(tmp_loc, mask)
-                                # np.savez('local_mask_upd/' + str(param) + ':' + str(time) + ':' + str(data).replace(' ', ':')
-                                #          + '.npz', loc=mask)
-                            elif self.loc_info[(data, time, param)]['taper_func'] == 'region':
-                                if isinstance(self.loc_info[(data, time, param)]['range'], list):
-                                    key = (self.loc_info[(data, time, param)]['taper_func'],
-                                           self.loc_info[(data, time, param)]['range'][0],
-                                           self.loc_info[(data, time, param)]['range'][1],
-                                           self.loc_info[(data, time, param)]['range'][2])
-                                else:
-                                    key = (self.loc_info[(data, time, param)]['taper_func'],
-                                           self.loc_info[(data, time, param)]['range'])
-
-                                mask = self.loc_info['mask'][key]
-                                for i in range(data_size[time_count][count]):
-                                    tmp_loc[i].append(mask)
-                        else:
-                            # if no localization has been defined, assume that we do not update
-                            if data_size[time_count][count] > 1:
-                                # must make a field mask of zeros
-                                mask = np.zeros((data_size[time_count][count], prior_info[param]['nx'] *
-                                                 prior_info[param]['ny'] *
-                                                 prior_info[param]['nz']))
-                                # set the localization mask to zeros for this parameter
-                                for i in range(data_size[time_count][count]):
-                                    if self.loc_info['actnum'] is not None:
-                                        tmp_loc[i].append(
-                                            mask[i, self.loc_info['actnum']])
-                                    else:
-                                        tmp_loc[i].append(mask[i, :])
-                                # tmp_loc = np.hstack((tmp_loc, mask)) if tmp_loc.size else mask
-                            else:
-                                mask = np.zeros(prior_info[param]['nx'] *
-                                                prior_info[param]['ny'] *
-                                                prior_info[param]['nz'])
-                                if self.loc_info['actnum'] is not None:
-                                    tmp_loc[0].append(mask[self.loc_info['actnum']])
-                                else:
-                                    tmp_loc[0].append(mask)
-                    # if data_size[count] == 1:
-                    #     loc = np.append(loc, np.array([tmp_loc, ]).T, axis=1) if loc.size else np.array([tmp_loc, ]).T
-                    # elif data_size[count] > 1:
-                    #     loc = np.concatenate((loc, tmp_loc.T), axis=1) if loc.size else tmp_loc.T
-                    for el in tmp_loc:
-                        if len(el) > 1:
-                            loc.append(sparse.hstack(el))
-                        else:
-                            loc.append(sparse.csc_matrix(el))
-        return sparse.vstack(loc).transpose()
-        # return np.array(loc).T
-
-    def auto_ada_loc(self, pert_state, proj_pred_data, curr_param, **kwargs):
-        if 'prior_info' in kwargs:
-            prior_info = kwargs['prior_info']
-        else:
-            prior_info = {key: None for key in curr_param}
-
-        step = []
-
-        ne = pert_state.shape[1]
-        rp_index = np.random.permutation(ne)
-        shuffled_ensemble = pert_state[:, rp_index]
-        corr_mtx = self.get_corr_mtx(pert_state, proj_pred_data)
-        corr_mtx_shuffled = self.get_corr_mtx(shuffled_ensemble, proj_pred_data)
-
-        tapering_matrix = np.ones(corr_mtx.shape)
-
-        if self.loc_info['actnum'] is not None:
-            num_active = np.sum(self.loc_info['actnum'])
-        else:
-            num_active = np.prod(self.loc_info['field'])
-        count = 0
-        for param in curr_param:
-            if param == 'NA':
-                num_active = tapering_matrix.shape[0]
-            else:
-                if 'active' in prior_info[param]:  # if this is defined
-                    num_active = int(prior_info[param]['active'])
-            prop_index = np.arange(num_active) + count
-            current_tapering = self.tapering_function(
-                corr_mtx[prop_index, :], corr_mtx_shuffled[prop_index, :])
-            tapering_matrix[prop_index, :] = current_tapering
-            count += num_active
-        step = np.dot(np.multiply(tapering_matrix, pert_state), proj_pred_data)
-
-        return step
-
-    def tapering_function(self, cf, cf_s):
-
-        nstd = 1
-        if self.loc_info['nstd'] is not None:
-            nstd = self.loc_info['nstd']
-
-        tc = np.zeros(cf.shape)
-
-        for i in range(cf.shape[1]):
-            current_cf = cf[:, i]
-            est_noise_std = np.median(np.absolute(cf_s[:, i]), axis=0) / 0.6745
-            if 'threshold' in self.loc_info and self.loc_info['threshold'] == 'universal':
-                cutoff_point = np.sqrt(2*np.log(np.prod(current_cf.shape))) * est_noise_std
-            elif 'threshold' in self.loc_info and self.loc_info['threshold'] == 'fixed':
-                cutoff_point = nstd
-            else:
-                cutoff_point = nstd * est_noise_std
-            if 'type' in self.loc_info and self.loc_info['type'] == 'soft':
-                current_tc = self.rational_function(1-np.absolute(current_cf),
-                                                    1 - cutoff_point)
-            elif 'type' in self.loc_info and self.loc_info['type'] == 'sigm':
-                current_tc = self.rational_function_sigmoid(np.absolute(current_cf),
-                                                            nstd)
-            else:  # default to hard thresholding
-                set_upper = np.where(np.absolute(current_cf) > cutoff_point)
-                current_tc = np.zeros(current_cf.shape)
-                current_tc[set_upper] = 1  # this is hard thresholding
-            tc[:, i] = current_tc.flatten()
-
-        return tc
-
-    def rational_function(self, dist, lc):
-
-        z = np.absolute(dist) / lc
-        index_1 = np.where(z <= 1)
-        index_2 = np.where(z <= 2)
-        index_12 = np.setdiff1d(index_2, index_1)
-
-        y = np.zeros(len(z))
-
-        y[index_1] = 1 - (np.power(z[index_1], 5) / 4) \
-            + (np.power(z[index_1], 4) / 2) \
-            + (5*np.power(z[index_1], 3) / 8) \
-            - (5*np.power(z[index_1], 2) / 3)
-
-        y[index_12] = (np.power(z[index_12], 5) / 12) \
-            - (np.power(z[index_12], 4) / 2) \
-            + (5 * np.power(z[index_12], 3) / 8) \
-            + (5 * np.power(z[index_12], 2) / 3) \
-            - 5*z[index_12] \
-            - np.divide(2, 3*z[index_12]) + 4
-
-        return y
-
-    def rational_function_sigmoid(self, dist, lc):
-        steepness = 50  # define how steep the transition is
-        y = expit((dist-(1-lc))*steepness)
-
-        return y
-
-    def get_corr_mtx(self, pert_state, proj_pred_data):
-
-        # compute correlation matrix
-
-        ne = pert_state.shape[1]
-
-        std_model = np.std(pert_state, axis=1)
-        std_model[std_model < 10 ** -6] = 10 ** -6
-        std_data = np.std(proj_pred_data, axis=1)
-        std_data[std_data < 10 ** -6] = 10 ** -6
-        # model_zero_spread_index = np.find(std_model<10**-6)
-        # data_zero_spread_index = np.find(std_data<10**-6)
-
-        C1 = np.mean(pert_state, axis=1)
-        A1 = np.outer(C1, np.ones(ne))
-        B1 = np.outer(std_model, np.ones(ne))
-        normalized_ensemble = np.divide((pert_state - A1), B1)
-
-        C2 = np.mean(proj_pred_data, axis=1)
-        A2 = np.outer(C2, np.ones(ne))
-        B2 = np.outer(std_data, np.ones(ne))
-        normalized_simData = np.divide((proj_pred_data - A2), B2)
-
-        corr_mtx = np.divide(
-            np.dot(normalized_ensemble, np.transpose(normalized_simData)), ne)
-
-        corr_mtx[std_model < 10 ** -6, :] = 0
-        corr_mtx[:, std_data < 10 ** -6] = 0
-
-        return corr_mtx
-
-    def _gen_loc_mask(self, taper_function=None, anisotropi=None, loc_range=None, field_size=None, ne=None):
-
-        # redesign the old _gen_loc_mask
-
-        if taper_function == 'gc':  # if the taper function is Gaspari-Kohn.
-
-            # rotation matrix
-            rotate = np.array([[np.cos((anisotropi[1] / 180) * np.pi), np.sin((anisotropi[1] / 180) * np.pi)],
-                               [-np.sin((anisotropi[1] / 180) * np.pi), np.cos((anisotropi[1] / 180) * np.pi)]])
-            # Scale matrix
-            scale = np.array([[1 / anisotropi[0], 0], [0, 1]])
-
-            # tot_range = [int(el) for el in np.dot(np.dot(scale, rotate), np.array([loc_range, loc_range]))]
-            tot_range = [int(el) for el in np.array([loc_range, loc_range])]
-
-            # preallocate a mask sufficiantly large
-            mask = np.zeros((2 * field_size[1], 2 * field_size[2]))  # 2D
-
-            center = [int(mask.shape[0] / 2), int(mask.shape[1] / 2)]
-            length = np.empty(2)
-            for i in range(mask.shape[0]):
-                for j in range(mask.shape[1]):
-                    # subtract 1 and switch element to make python and ecl equivalent
-                    length[0] = (center[0]) - i
-                    length[1] = (center[1]) - j
-                    lt = np.dot(np.dot(scale, rotate), length)
-                    # d = np.sqrt(np.sum(lt**2))
-
-                    # Gaspari-Chon
-                    ratio = np.sqrt((lt[0] / tot_range[0]) ** 2 +
-                                    (lt[1] / tot_range[1]) ** 2)
-                    h1 = ratio
-                    h2 = np.sqrt((lt[0] / (2 * tot_range[0])) ** 2 +
-                                 (lt[1] / (2 * tot_range[1])) ** 2)
-
-                    if ((h1 <= 1) & (h2 <= 1)):  # check that this layer should be localized
-                        mask[i, j] = (-1 / 4) * ratio ** 5 + (1 / 2) * ratio ** 4 + (5 / 8) * ratio ** 3 - \
-                                     (5 / 3) * ratio ** 2 + 1
-                    elif ((h1 > 1) & (h2 <= 1)):  # check that this layer should be localized
-                        mask[i, j] = (1 / 12) * ratio ** 5 - (1 / 2) * ratio ** 4 + (5 / 8) * ratio ** 3 + \
-                                     (5 / 3) * ratio ** 2 - 5 * \
-                            ratio + 4 - (2 / 3) * ratio ** (-1)
-                    elif (h1 > 1) & (h2 > 1):
-                        mask[i, j] = 0
-            # only return non-zero part
-            return mask[mask.nonzero()[0].min():mask.nonzero()[0].max() + 1,
-                        mask.nonzero()[1].min():mask.nonzero()[1].max() + 1]
-
-        # Taper function based on a covariance structure, as defined by eq (23) in "R.Furrer and
-        if taper_function == 'fb':
-            # T.Bengtsson, Estimation of high-dimensional prior and posterior covariance matrices
-            # in Kalman filter variants, Journal of Multivariate Analysis, 2007."
-
-            # rotation matrix
-            rotate = np.array([[np.cos((anisotropi[1] / 180) * np.pi), np.sin((anisotropi[1] / 180) * np.pi)],
-                               [-np.sin((anisotropi[1] / 180) * np.pi), np.cos((anisotropi[1] / 180) * np.pi)]])
-            # Scale matrix
-            scale = np.array([[1 / anisotropi[0], 0], [0, 1]])
-
-            # preallocate a mask sufficiantly large
-            mask = np.zeros((2 * field_size[1], 2 * field_size[2]))  # 2D
-
-            center = [int(mask.shape[0] / 2), int(mask.shape[1] / 2)]
-            length = np.empty(2)
-
-            # transform the position into values
-            for i in range(mask.shape[0]):
-                for j in range(mask.shape[1]):
-                    #
-                    length[0] = (center[0]) - i
-                    length[1] = (center[1]) - j
-                    lt = np.dot(np.dot(scale, rotate), length)
-                    # Calc the distance
-                    d = np.sqrt(np.sum(lt ** 2))
-                    # The fb function is now dependent on finding the covariance function. We use the same variogram
-                    # function as the prior, that is, a spherical model.
-                    # Todo: Include different variogram models
-                    tmp = 0
-                    if (d < loc_range):
-                        tmp = 1 - 1 * (1.5 * np.abs(d) / loc_range - .5 *
-                                       (d / loc_range) ** 3)
-                    # eq (23) of Furrer and Bengtsson
-                    tmp_mask = (ne * tmp ** 2) / ((tmp ** 2) * (ne + 1) + 1 ** 2)
-                    if mask[i, j] < tmp_mask:
-                        mask[i, j] = tmp_mask
-
-            return mask[mask.nonzero()[0].min():mask.nonzero()[0].max() + 1,
-                        mask.nonzero()[1].min():mask.nonzero()[1].max() + 1]
-
-        if taper_function == 'region':
-            # since this matrix always is field size, store as sparse
-            return np.ones(1)
-
-    def _repos_locmask(self, mask, data_pos, z_range=None):
-        # input:
-        # mask: The default localization mask. This has dimensions equal to its range. Note that all anisotropi is already
-        #       taken care of during the creation of the mask.
-        # grid_dim: tuple providing the dimensions of the grid.
-        # data_pos: List of tuple values (X,Y,Z) giving positioning of the data
-
-        grid_dim = self.loc_info['field']
-        if len(data_pos) > 1:  # if more than one position is defined for this data
-            loc_mask = np.zeros(grid_dim)
-
-            for data in data_pos:
-                loc_mask = np.maximum(loc_mask, self._repos_mask(mask, data))
-        elif len(data_pos) == 1:  # single position
-            loc_mask = self._repos_mask(mask, data_pos[0])
-        else:  # no data pos, i.e. this data should not update this parameter
-            loc_mask = np.zeros(grid_dim)
-
-        if self.loc_info['actnum'] is not None:
-            if z_range == ':':
-                return loc_mask.flatten()[self.loc_info['actnum']]
-            else:
-                new_loc_mask = loc_mask[z_range, :, :]
-                new_actnum = self.loc_info['actnum'].reshape(grid_dim)[z_range, :, :]
-                return new_loc_mask.flatten()[new_actnum.flatten()]
-        else:
-            if z_range == ':':
-                return loc_mask.flatten()
-            else:
-                return loc_mask[z_range, :, :].flatten()
-
-    def _repos_mask(self, mask, data_pos):
-        grid_dim = self.loc_info['field'][1:]
-        mask_dimX = mask.shape[0]
-        mask_dimY = mask.shape[1]
-
-        # If the mask is placed sufficiently inside the grid, it only requires padding
-
-        if ((grid_dim[0] - (data_pos[1] + mask_dimX / 2) > 0) and data_pos[1] - mask_dimX / 2 > 0) \
-                and (((grid_dim[1] - (data_pos[0] + mask_dimY / 2) > 0)) and (data_pos[0] - mask_dimY / 2 > 0)):
-            # x padding
-            pad_x_l = data_pos[1] - int(mask_dimX / 2)
-            pad_x_r = grid_dim[0] - (data_pos[1] + int(np.ceil(mask_dimX / 2)))
-            # y padding
-            pad_y_d = data_pos[0] - int(mask_dimY / 2)
-            pad_y_u = grid_dim[1] - (data_pos[0] + int(np.ceil(mask_dimY / 2)))
-
-            loc_2d_mask = np.pad(
-                mask, ((pad_x_l, pad_x_r), (pad_y_d, pad_y_u)), 'constant')
-
-        elif ((grid_dim[0] - (data_pos[1] + mask_dimX / 2) > 0) and data_pos[1] - mask_dimX / 2 > 0) \
-                and not (((grid_dim[1] - (data_pos[0] + mask_dimY / 2) > 0)) and (data_pos[0] - mask_dimY / 2 > 0)):
-            # x padding
-            pad_x_l = data_pos[1] - int(mask_dimX / 2)
-            pad_x_r = grid_dim[0] - (data_pos[1] + int(np.ceil(mask_dimX / 2)))
-
-            pad_y_u = 0
-            # y padding
-            if data_pos[0] - int(mask_dimY / 2) <= 0:
-                pad_y_d = 0
-                pad_y_u = abs(data_pos[0] - int(mask_dimY / 2))
-                pos_y1 = abs(data_pos[0] - int(mask_dimY / 2))
-            else:
-                pad_y_d = grid_dim[1] - int(np.ceil(mask_dimY / 2))
-                pos_y1 = 0
-            if grid_dim[1] - (data_pos[0] + int(np.ceil(mask_dimY / 2))) <= 0:
-                pad_y_u = 0
-                pad_y_d += (data_pos[0] - grid_dim[1]) + 1
-                pos_y2 = grid_dim[1]
-            else:
-                pad_y_u += grid_dim[1] - (int(np.ceil(mask_dimY / 2)))
-                pos_y2 = grid_dim[1] + abs(data_pos[0] - int(mask_dimY / 2))
-
-            # check if negative padding, if true the mask is larger than the field. Need to update the coordinates,
-            # and remove negative padding.
-            if pad_y_d < 0:
-                pad_y_d = 0
-                pos_y2 += pos_y1
-            if pos_y1 == pos_y2:
-                pos_y2 += 1
-
-            loc_2d_mask = np.pad(mask, ((pad_x_l, pad_x_r), (pad_y_d, pad_y_u)), 'constant')[
-                :, pos_y1:pos_y2]
-
-        elif not ((grid_dim[0] - (data_pos[1] + mask_dimX / 2) > 0) and data_pos[1] - mask_dimX / 2 > 0) \
-                and (((grid_dim[1] - (data_pos[0] + mask_dimY / 2) > 0)) and (data_pos[0] - mask_dimY / 2 > 0)):
-            # x padding
-            pad_x_r = 0
-            if data_pos[1] - int(mask_dimX / 2) <= 0:
-                pad_x_l = 0
-                pad_x_r = abs(data_pos[1] - int(mask_dimX / 2))
-                pos_x1 = abs(data_pos[1] - int(mask_dimX / 2))
-            else:
-                pad_x_l = grid_dim[0] - int(np.ceil(mask_dimX / 2))
-                pos_x1 = 0
-            if grid_dim[0] - (data_pos[1] + int(np.ceil(mask_dimX / 2))) <= 0:
-                pad_x_r = 0
-                pad_x_l += (data_pos[1] - grid_dim[0]) + 1
-                pos_x2 = grid_dim[0]
-            else:
-                pad_x_r += grid_dim[0] - (int(np.ceil(mask_dimX / 2)))
-                pos_x2 = grid_dim[0] + abs(data_pos[1] - int(mask_dimX / 2))
-            # y padding
-            pad_y_d = data_pos[0] - int(mask_dimY / 2)
-            pad_y_u = grid_dim[1] - (data_pos[0] + int(np.ceil(mask_dimY / 2)))
-
-            # check if negative padding, if true the mask is larger than the field. Need to update the coordinates,
-            # and remove negative padding.
-            if pad_x_l < 0:
-                pad_x_l = 0
-                pos_x2 += pos_x1
-            if pos_x1 == pos_x2:
-                pos_x2 += 1
-
-            loc_2d_mask = np.pad(mask, ((pad_x_l, pad_x_r), (pad_y_d, pad_y_u)), 'constant')[
-                pos_x1:pos_x2, :]
-        else:
-            pad_x_r = 0
-            pad_y_u = 0
-
-            if data_pos[1] - int(mask_dimX / 2) <= 0:
-                pad_x_l = 0
-                pad_x_r = abs(data_pos[1] - int(mask_dimX / 2))
-                pos_x1 = abs(data_pos[1] - int(mask_dimX / 2))
-            else:
-                pad_x_l = grid_dim[0] - int(np.ceil(mask_dimX / 2))
-                pos_x1 = 0
-            if grid_dim[0] - (data_pos[1] + int(np.ceil(mask_dimX / 2))) <= 0:
-                pad_x_r = 0
-                pad_x_l += (data_pos[1] - grid_dim[0]) + 1
-                pos_x2 = grid_dim[0]
-            else:
-                pad_x_r += grid_dim[0] - (int(np.ceil(mask_dimX / 2)))
-                pos_x2 = grid_dim[0] + abs(data_pos[1] - int(mask_dimX / 2))
-
-            # y padding
-            if data_pos[0] - int(mask_dimY / 2) <= 0:
-                pad_y_d = 0
-                pad_y_u = abs(data_pos[0] - int(mask_dimY / 2))
-                pos_y1 = abs(data_pos[0] - int(mask_dimY / 2))
-            else:
-                pad_y_d = grid_dim[1] - int(np.ceil(mask_dimY / 2))
-                pos_y1 = 0
-            if grid_dim[1] - (data_pos[0] + int(np.ceil(mask_dimY / 2))) <= 0:
-                pad_y_u = 0
-                pad_y_d += (data_pos[0] - grid_dim[1]) + 1
-                pos_y2 = grid_dim[1]
-            else:
-                pad_y_u += grid_dim[1] - (int(np.ceil(mask_dimY / 2)))
-                pos_y2 = grid_dim[1] + abs(data_pos[0] - int(mask_dimY / 2))
-
-            # check if negative padding, if true the mask is larger than the field. Need to update the coordinates,
-            # and remove negative padding.
-            if pad_y_d < 0:
-                pad_y_d = 0
-                pos_y2 += pos_y1
-            if pad_x_l < 0:
-                pad_x_l = 0
-                pos_x2 += pos_x1
-            if pos_x1 == pos_x2:
-                pos_x2 += 1
-            if pos_y1 == pos_y2:
-                pos_y2 += 1
-            loc_2d_mask = np.pad(mask, ((pad_x_l, pad_x_r), (pad_y_d, pad_y_u)), 'constant')[
-                pos_x1:pos_x2, pos_y1:pos_y2]
-
-        loc_mask = np.zeros(self.loc_info['field'])
-        loc_mask[data_pos[2], :, :] = loc_2d_mask
-        return loc_mask
-
-
-def _calc_distance(data_pos, index_unique, current_data_list, assim_index, obs_data, pred_data, param_pos):
-    """
-    Calculate the distance between data and parameters.
-
-    Parameters
-    ----------
-    data_pos : dict
-        Dictionary containing the position of the data.
-
-    index_unique : bool
-        Boolean that determines if the position is unique.
-
-    current_data_list : list
-        List containing the names of the data that should be evaluated.
-
-    assim_index : int
-        The index of the data to be evaluated.
-
-    obs_data : list of dict
-        List of dictionaries containing the data.
-
-    pred_data : list of dict
-        List of dictionaries containing the predictions.
-
-    param_pos : list of tuple
-        List of tuples representing the position of the parameters.
-
-    Returns
-    -------
-        - dist: list of euclidean distance between the data/parameter pair.
-    """
-    # distance to data if distance based localization
-    if index_unique == False:
-        dist = []
-        for dat in current_data_list:
-            for indx in assim_index[1]:
-                indx_data_pos = data_pos[dat][indx]
-                if obs_data[indx] is not None and obs_data[indx][dat] is not None:
-                    # add shortest distance
-                    dist.append(min(distance.cdist(indx_data_pos, param_pos).flatten()))
-    else:
-        dist = []
-        for data in current_data_list:
-            elem_data_pos = data_pos[data]
-            obs, _ = at.aug_obs_pred_data(obs_data, pred_data, assim_index, [data])
-            dist.extend(
-                len(obs)*[min(distance.cdist(elem_data_pos, param_pos).flatten())])
-
-    return dist
-
-
-def _calc_loc(max_dist, distance, prior_info, loc_type, ne):
-    # given the parameter type (to get the prior info) and the range to the data points we can calculate the
-    # localization mask
-    variance = prior_info['variance'][0]
-    mask = np.zeros(len(distance))
-    if loc_type == 'fb':
-        # assume that FB localization is utilized. Here vi can add all different localization functions
-        for i in range(len(distance)):
-            if distance[i] < max_dist:
-                tmp = variance - variance * (
-                    1.5 * np.abs(distance[i]) / max_dist - .5 * (distance[i] / max_dist) ** 3)
-            else:
-                tmp = 0
-
-            mask[i] = (ne * tmp ** 2) / ((tmp ** 2) * (ne + 1) + variance ** 2)
-    elif loc_type == 'gc':
-        for count, i in enumerate(np.abs(distance)):
-            if (i <= max_dist):
-                tmp = -(1. / 4.) * (i / max_dist) ** 5 + (1. / 2.) * (i / max_dist) ** 4 + (5. / 8.) * (
-                    i / max_dist) ** 3 - (5. / 3.) * (i / max_dist) ** 2 + 1
-            elif (i <= 2 * max_dist):
-                tmp = (1. / 12.) * (i / max_dist) ** 5 - (1. / 2.) * (i / max_dist) ** 4 + (5. / 8.) * (
-                    i / max_dist) ** 3 + (5. / 3.) * (i / max_dist) ** 2 - 5. * (i / max_dist) + 4. - (
-                    2. / 3.) * (max_dist / i)
-            else:
-                tmp = 0.
-            mask[count] = tmp
-
-    return mask[np.newaxis, :]
diff --git a/src/pipt/misc_tools/data_tools.py b/src/pipt/misc_tools/data_tools.py
deleted file mode 100644
index 5d08a49e..00000000
--- a/src/pipt/misc_tools/data_tools.py
+++ /dev/null
@@ -1,233 +0,0 @@
-__author__ = 'Mathias Methlie Nilsen'
-
-import numpy as np
-import pandas as pd
-
-__all__ = [
-    'combine_ensemble_predictions', 
-    'en_pred_to_pred_data', 
-    'merge_dataframes',
-    'multilevel_to_singlelevel_columns',
-    'dataframe_to_series', 
-    'series_to_dataframe', 
-    'series_to_matrix', 
-    'dataframe_to_matrix'
-]
-
-
-def combine_ensemble_predictions(en_pred, dataypes, true_order) -> pd.DataFrame:
-    index_name, index = true_order
-    
-    # Initialize empty DataFrame
-    df = pd.DataFrame(columns=dataypes, index=index)
-    df.index.name = index_name
-
-    # Check en_pred is iterable
-    if not isinstance(en_pred, (list, tuple, np.ndarray)):
-        raise ValueError('en_pred must be a list, tuple, or ndarray of ensemble predictions.')
-    
-    #----------------------------------------------------------------------------------------------
-    if all(isinstance(el, (list, tuple, np.ndarray)) for el in en_pred): 
-        if all(isinstance(el, dict) for el in en_pred[0]):
-            pred_data = en_pred_to_pred_data(en_pred)
-
-            #pred_data = [
-            #    {typ: np.concatenate(tuple((el[ind][typ][:, np.newaxis]) for el in en_pred), axis=1)
-            #    if any(elem is not None for elem in tuple((el[ind][typ]) for el in en_pred))
-            #    else None for typ in en_pred[0][0].keys()} for ind in range(len(en_pred[0]))
-            #]
-
-            # Fill in DataFrame
-            for i, ind in enumerate(index):
-                for key in dataypes:
-                    if not key in pred_data[i]:
-                        raise ValueError(f'Key {key} not found in pred_data at index {i}.')
-                    
-                    if pred_data[i][key] is not None:
-                        df.at[ind, key] = np.squeeze(pred_data[i][key])
-                    else:
-                        df.at[ind, key] = np.nan
-
-        else:
-            raise ValueError('Unsupported nested structure in en_pred.')
-    #----------------------------------------------------------------------------------------------
-        
-
-    #----------------------------------------------------------------------------------------------
-    elif all(isinstance(el, dict) for el in en_pred):
-        # Combine dicts to one dict with concatenated arrays
-        pred_data_dict = {}
-        for key in en_pred[0].keys():
-            member_list = []
-            for el in en_pred:
-                member_data = el[key][:, np.newaxis]
-                member_list.append(member_data)
-            pred_data_dict[key] = np.concatenate(tuple(member_list), axis=1)
-        
-        # Fill in DataFrame
-        for i, ind in enumerate(index):
-            for key in dataypes:
-                if not key in pred_data_dict:
-                    raise ValueError(f'Key {key} not found in pred_data_dict.')
-
-                if pred_data_dict[key] is not None:
-                    df.at[ind, key] = np.squeeze(pred_data_dict[key][i, :])
-                else:
-                    df.at[ind, key] = np.nan
-    #----------------------------------------------------------------------------------------------
-        
-
-    #----------------------------------------------------------------------------------------------
-    elif all(isinstance(el, pd.DataFrame) for el in en_pred):
-
-        # Fill in DataFrame
-        for i, ind in enumerate(index):
-            for key in dataypes:
-                if not key in en_pred[0].columns:
-                    raise ValueError(f'Key {key} not found in DataFrame columns.')
-                
-                member_data = []
-                for el in en_pred:
-                    member_data.append(el.at[ind, key])
-
-                df.at[ind, key] = np.squeeze(np.array(member_data))  
-    #----------------------------------------------------------------------------------------------
-
-    return df
-
-
-
-def en_pred_to_pred_data(en_pred):
-    '''
-    This is equvalent to the famouse one-liner from the wizard known as Kristian Fossum!
-    A big thanks to copilot for helpeing me decode the wizards spell to make this function.
-    '''
-    pred_data = []
-
-    # Loop over each time step
-    for ind in range(len(en_pred[0])):
-        data_type_dict = {}
-        
-        # Loop over each data type
-        for typ in en_pred[0][0].keys():
-            
-            # Check if any ensemble member has non-None data for this type and time step
-            has_data = False
-            for el in en_pred:
-                if el[ind][typ] is not None:
-                    has_data = True
-                    break
-            
-            # If at least one member has data, concatenate all members
-            if has_data:
-                member_list = []
-                for el in en_pred:
-                    if not isinstance(el[ind][typ],np.ndarray):
-                        member_data = np.array([el[ind][typ]])[:, np.newaxis]
-                    else:
-                        member_data = el[ind][typ][:, np.newaxis]
-                    member_list.append(member_data)
-                
-                data_type_dict[typ] = np.concatenate(tuple(member_list), axis=1)
-            else:
-                # Otherwise, store None
-                data_type_dict[typ] = None
-        
-        pred_data.append(data_type_dict)
-    
-    return pred_data
-
-
-def merge_dataframes(en_dfs: list[pd.DataFrame]) -> pd.DataFrame:
-    '''
-    Combine a list of DataFrames (one per ensemble member) into a single DataFrame
-    where each cell contains an array of ensemble values.
-    '''
-    if not all(isinstance(df, pd.DataFrame) for df in en_dfs):
-        raise ValueError('All elements in en_dfs must be pandas DataFrames.')
-
-    # Initialize empty DataFrame with same index and columns as the first DataFrame
-    df = pd.DataFrame(index=en_dfs[0].index, columns=en_dfs[0].columns)
-    df.index.name = en_dfs[0].index.name
-
-    # Loop over each cell and combine ensemble values into arrays
-    for idx in df.index:
-        for col in df.columns:
-            values = []
-            for dfn in en_dfs:
-                values.append(dfn.at[idx, col])
-            df.at[idx, col] = np.array(values).squeeze().T
-    return df
-
-def multilevel_to_singlelevel_columns(df: pd.DataFrame) -> pd.DataFrame:
-    """
-    Convert a MultiIndex-column DataFrame with structure (key, param)
-    into a DataFrame with one column per key, where the value is
-    the concatenation of all param-arrays for that key.
-    """
-    result = {}
-
-    # Top-level keys (level 0 of MultiIndex), preserving first appearance order
-    keys = pd.Index(df.columns.get_level_values(0)).unique()
-
-    for key in keys:
-        # Extract all columns for this key → list of arrays per row
-        param_arrays = df[key]  # this is a sub-dataframe for this key
-
-        # For each row, concatenate arrays from all params
-        concatenated = [
-            np.concatenate(param_arrays.iloc[i].values)
-            for i in range(len(df))
-        ]
-
-        result[key] = concatenated
-    
-    df_new = pd.DataFrame(result, index=df.index)
-    df_new.index.name = df.index.name
-    return df_new    
-  
-
-def dataframe_to_series(df):
-    mult_index = []
-    for idx in df.index:
-        for col in df.columns:
-            mult_index.append((idx, col))
-    mult_index = pd.MultiIndex.from_tuples(mult_index, names=[df.index.name, 'datatype'])
-    
-    values = []
-    for idx in df.index:
-        for col in df.columns:
-            values.append(df.loc[idx, col])
-    
-    return pd.Series(values, index=mult_index)
-
-def series_to_dataframe(series):
-    col = series.index.get_level_values('datatype').unique()
-    idx = series.index.get_level_values(series.index.names[0]).unique()
-    df = pd.DataFrame(index=idx, columns=col.values)
-    for (date, datatype), value in series.items():
-        df.at[date, datatype] = value
-    return df
-
-def series_to_matrix(series):
-    val = np.array([v for v in series.values])
-    return val
-
-def dataframe_to_matrix(df):
-    series = dataframe_to_series(df)
-    return series_to_matrix(series)
-
-
-
-
-    
-            
-
-
-
-
-            
-        
-            
-        
-        
\ No newline at end of file
diff --git a/src/pipt/misc_tools/ensemble_tools.py b/src/pipt/misc_tools/ensemble_tools.py
index 25e409ce..6fd7e975 100644
--- a/src/pipt/misc_tools/ensemble_tools.py
+++ b/src/pipt/misc_tools/ensemble_tools.py
@@ -1,19 +1,12 @@
-# This module contains functions and tools for ensembles
+"""Conversion of the stacked state matrix into a per-variable dictionary of arrays."""
 
 __all__ = [
     'matrix_to_dict',
-    'matrix_to_list',
-    'list_to_matrix',
-    'generate_prior_ensemble',
-    'clip_matrix'
 ]
 
 # Imports
 import numpy as np
 
-# Internal imports
-from geostat.decomp import Cholesky
-
 
 def matrix_to_dict(matrix: np.ndarray, indecies: dict[tuple]) -> dict:
     '''
@@ -26,7 +19,7 @@ def matrix_to_dict(matrix: np.ndarray, indecies: dict[tuple]) -> dict:
     indecies : dict
         Dictionary with keys as variable names and values as tuples indicating the start and end row indices
         for each variable in the ensemble matrix.
-    
+
     Returns
     -------
     ensemble_dict : dict
@@ -35,227 +28,5 @@ def matrix_to_dict(matrix: np.ndarray, indecies: dict[tuple]) -> dict:
     ensemble_dict = {}
     for key, (start, end) in indecies.items():
         ensemble_dict[key] = matrix[start:end]
-    
-    return ensemble_dict
-
-
-def matrix_to_list(matrix: np.ndarray, indecies: dict[tuple]) -> list[dict]:
-    '''
-    Convert an ensemble matrix to a list of dictionaries.
-
-    Parameters
-    ----------
-    matrix : np.ndarray
-        Ensemble matrix where each column represents an ensemble member.
-    indecies : dict
-        Dictionary with keys as variable names and values as tuples indicating the start and end row indices
-        for each variable in the ensemble matrix.
-    
-    Returns
-    -------
-    ensemble_list : list of dict
-    '''
-    ne = matrix.shape[1]
-    ensemble_list = []
-
-    for n in range(ne):
-        member = matrix_to_dict(matrix[:,n], indecies)
-        ensemble_list.append(member)
-    
-    return ensemble_list
-
-
-def list_to_matrix(ensemble_list: list[dict], indecies: dict[tuple]) -> np.ndarray:
-    '''
-    Convert a list of dictionaries to an ensemble matrix.
-
-    Parameters
-    ----------
-    ensemble_list : list of dict
-        List where each dictionary represents an ensemble member with variable names as keys.
-    indecies : dict
-        Dictionary with keys as variable names and values as tuples indicating the start and end row indices
-        for each variable in the ensemble matrix.
-    
-    Returns
-    -------
-    matrix : np.ndarray
-        Ensemble matrix where each column represents an ensemble member.
-    '''
-    ne = len(ensemble_list)
-    nx = sum(end - start for start, end in indecies.values())
-    matrix = np.zeros((nx, ne))
-
-    for n, member in enumerate(ensemble_list):
-        for key, (start, end) in indecies.items():
-            if member[key].ndim == 2:
-                matrix[start:end, n] = member[key][:,n]
-            else:
-                matrix[start:end, n] = member[key]
-    
-    return matrix
-
-
-def generate_prior_ensemble(prior_info: dict, size: int, save: bool = True) -> tuple[np.ndarray, dict, dict]: 
-    '''
-    Generate a prior ensemble based on provided prior information.
-
-    Parameters
-    ----------
-    prior_info : dict
-        Dictionary containing prior information for each state variable.
-
-    size : int
-        Size of ensemble.
-
-    save : bool, optional
-        Whether to save the generated ensemble to a file. Default is True.  
-    
-    Returns
-    -------
-    enX : np.ndarray
-        The generated ensemble matrix, shape: (nx, ne).
-
-    idX : dict
-        Dictionary with keys as variable names and values as tuples indicating the start and end row indices
-        for each variable in the ensemble matrix.
-
-    cov_prior : dict
-        Dictionary containing the covariance matrices for each state variable.
-    '''
-    
-    # Initialize sampler
-    generator = Cholesky()
-
-    # Initialize variables
-    enX = None
-    idX = {}
-    cov_prior = {}
-
-    # Loop over all state variables
-    for name, info in prior_info.items():
-
-        # Extract info
-        nx = info.get('nx', 0)
-        ny = info.get('ny', 0)
-        nz = info.get('nz', 0)
-        mean = info.get('mean', None)
-
-        # if no dimensions are given, nothing is generated for this variable
-        if nx == ny == 0: 
-                break
-        
-        # Extract more options
-        variance = info.get('variance', None)
-        corr_length = info.get('corr_length', None)
-        aniso = info.get('aniso', None)
-        vario = info.get('vario', None)
-        angle = info.get('angle', None)
-        limits= info.get('limits',None)
-
-        # Loop over nz to make layers of 2D priors
-        index_stop = 0
-        for idz in range(nz):
-            # If mean is scalar, no covariance matrix is needed
-            if isinstance(mean, (list, np.ndarray)) and len(mean) > 1:
-                # Generate covariance matrix
-                cov = generator.gen_cov2d(
-                    x_size = nx, 
-                    y_size = ny, 
-                    variance = variance[idz], 
-                    var_range = corr_length[idz], 
-                    aspect = aniso[idz], 
-                    angle = angle[idz], 
-                    var_type = vario[idz]
-                )
-            else:
-                cov = np.array(variance[idz])
-
-            # Pick out the mean vector for the current layer
-            index_start = index_stop
-            index_stop  = int((idz + 1) * (len(mean)/nz))
-            mean_layer  = mean[index_start:index_stop]
-
-            # Generate realizations. If LIMITS have been entered, they must be taken account for here
-            if limits is None:
-                real = generator.gen_real(mean_layer, cov, size)
-            else:
-                real = generator.gen_real(mean_layer, cov, size, limits[idz])
-
-            # Stack realizations for each layer
-            if idz == 0:
-                real_out = real
-            else:
-                real_out = np.vstack((real_out, real))
-        
-        # Fill in the ensemble matrix and indecies
-        if enX is None:
-            idX[name] = (0, real_out.shape[0])
-            enX = real_out
-        else:
-            idX[name] = (enX.shape[0], enX.shape[0] + real_out.shape[0])
-            enX = np.vstack((enX, real_out))
-        
-        # Store the covariance matrix
-        cov_prior[name] = cov
-
-    # Save prior ensemble
-    if save:
-        np.savez(
-            'prior_ensemble.npz', 
-            **{name: enX[idX[name][0]:idX[name][1]] for name in idX.keys()}
-        )
-
-    return enX, idX, cov_prior
-
-
-def clip_matrix(matrix: np.ndarray, limits: dict|tuple|list, indecies: dict|None = None) -> np.ndarray:
-    '''
-    Clip the values in an ensemble matrix based on provided limits.
-
-    Parameters
-    ----------
-    matrix : np.ndarray
-        Ensemble matrix where each column represents an ensemble member.
-    
-    limits : dict, tuple, or list
-        If tuple, it should be (lower_bound, upper_bound) applied to all variables.
-        If dict, it should have variable names as keys and (lower_bound, upper_bound) as values.
-        If list, it should contain (lower_bound, upper_bound) tuples for each variable in the order of indecies.
-    
-    indecies : dict, optional
-        Dictionary with keys as variable names and values as tuples indicating the start and end row indices
-        for each variable in the ensemble matrix. Required if limits is a dict or list. Default is None.
-    
-    Returns
-    -------
-    matrix : np.ndarray
-    '''
-    if isinstance(limits, tuple):
-        lb, ub = limits
-        if not (lb is None and ub is None):
-            matrix = np.clip(matrix, lb, ub)
-
-    elif isinstance(limits, dict) and isinstance(indecies, dict):
-        if indecies is None:
-            raise ValueError("When limits is a dictionary, indecies must also be provided.")
-        
-        for key, (start, end) in indecies.items():
-            if key in limits:
-                lb, ub = limits[key]
-                if not (lb is None and ub is None):
-                    matrix[start:end] = np.clip(matrix[start:end], lb, ub)
-    
-    elif isinstance(limits, list):
-        if indecies is None:
-            raise ValueError("When limits is a list, indecies must also be provided.")
-        
-        if len(limits) != len(indecies):
-            raise ValueError("Length of limits list must match number of variables in indecies.")
-        
-        for (key, (start, end)), (lb, ub) in zip(indecies.items(), limits):
-            if not (lb is None and ub is None):
-                matrix[start:end] = np.clip(matrix[start:end], lb, ub)
-
-    return matrix
 
+    return ensemble_dict
diff --git a/src/pipt/misc_tools/extract_tools.py b/src/pipt/misc_tools/extract_tools.py
index 6dd0fd54..a37fdaf8 100644
--- a/src/pipt/misc_tools/extract_tools.py
+++ b/src/pipt/misc_tools/extract_tools.py
@@ -1,4 +1,4 @@
-# This module includes functions for extracting information from input dicts
+"""Extraction and normalisation of options from the parsed configuration dictionaries."""
 
 __all__ = [
     'extract_prior_info',
@@ -7,10 +7,11 @@
     'extract_local_analysis_info',
     'extract_maxiter',
     'organize_sparse_representation',
+    'is_enabled',
     'list_to_dict'
 ]
 
-# Imports 
+# Imports
 import numpy  as np
 import pandas as pd
 import pickle
@@ -20,29 +21,32 @@
 from typing import Union
 
 # Internal imports
-import pipt.misc_tools.analysis_tools as at
+from input_output.config import as_flag, pairs_to_dict
 
 
+# The flag and list-of-pairs helpers live at the config boundary; the names stay for the callers.
+is_enabled = as_flag
 def extract_prior_info(keys: dict) -> dict:
     '''
     Extract prior information on STATE from keyword(s).
     '''
     # Get state names as list
     state_names = keys['state']
-    if not isinstance(state_names, list): state_names = [state_names]
+    if not isinstance(state_names, list):
+        state_names = [state_names]
 
     # Check if PRIOR_ exists for each entry in state
     for name in state_names:
-        assert_msg = f'PRIOR_{name.upper()} is missing! This keyword is needed to make initial ensemble for {name.upper()} entered in STATE' 
+        assert_msg = f'PRIOR_{name.upper()} is missing! This keyword is needed to make initial ensemble for {name.upper()} entered in STATE'
         assert f'prior_{name}' in keys, assert_msg
-    
-    # Sefine dict to store prior information in 
+
+    # Sefine dict to store prior information in
     prior_info = {name: None for name in state_names}
 
     # loop over state priors
     for name in state_names:
         prior = keys[f'prior_{name}']
-        
+
         # Check if is a list (old way)
         if isinstance(prior, list):
             prior = list_to_dict(prior)
@@ -55,14 +59,14 @@ def extract_prior_info(keys: dict) -> dict:
                 assert prior['mean'].endswith('.npz'), 'File name does not end with \'.npz\'!'
                 mean_file = np.load(prior['mean'])
                 assert len(mean_file.files) == 1, \
-                    f"More than one variable located in {prior['mean']}. Only the mean vector can be stored in the .npz file!" 
+                    f"More than one variable located in {prior['mean']}. Only the mean vector can be stored in the .npz file!"
                 prior['mean'] = mean_file[mean_file.files[0]]
             else:  # Single number inputted, make it a list if not already
                 if not isinstance(prior['mean'], list):
                     prior['mean'] = [prior['mean']]
         else:
             prior['mean'] = [None]
-       
+
         # loop over keys in prior
         for key in prior.keys():
             # ensure that entry is a list
@@ -85,7 +89,7 @@ def extract_prior_info(keys: dict) -> dict:
                 prior['nz'] = nz
                 prior['nx'] = int(grid_dim[0])
                 prior['ny'] = int(grid_dim[1])
-                
+
 
                 # Check mean when values have been inputted directly (not when mean has been loaded)
                 mean = prior['mean']
@@ -124,7 +128,7 @@ def extract_prior_info(keys: dict) -> dict:
 
         # add prior to prior_info
         prior_info[name] = prior
-        
+
     return prior_info
 
 
@@ -142,7 +146,7 @@ def extract_initial_controls(keys: dict) -> dict:
         Configuration dictionary containing a 'controls' key. Each control variable
         should be a nested dictionary with the name of the control variable as the key.
         The dictionary for each control variable should contain the following possible keys:
-        
+
         - 'initial' or 'mean' : Initial value or mean of control variable
             Can be scalar, list, numpy array, or filename (.npy, .npz, .csv).
             If .npz or .csv, the variable name should match the control variable name.
@@ -153,7 +157,7 @@ def extract_initial_controls(keys: dict) -> dict:
 
         - 'var' or 'variance' : float, list, or array, optional
             Variance of the control variable
-            
+
         - 'std' : float, list, array, or str, optional
             Standard deviation. If string ending with '%', interpreted as percentage
             of the bound range (requires 'limits' to be specified). Only if 'var'/'variance'
@@ -163,7 +167,7 @@ def extract_initial_controls(keys: dict) -> dict:
     -------
     control_info : dict
         Dictionary with control variable names as keys. Each value is a dict containing:
-        
+
         - 'mean' : numpy.ndarray
             Initial/mean values for the control variable
         - 'limits' : list
@@ -209,7 +213,7 @@ def extract_initial_controls(keys: dict) -> dict:
         assert ('initial' in info) or ('mean' in info), f'INITIAL or MEAN missing in CONTROLS for {name}!'
 
         # Rename to mean if initial is there
-        if 'initial' in info: 
+        if 'initial' in info:
             info['mean'] = info.pop('initial', None)
 
         # Mean
@@ -218,7 +222,7 @@ def extract_initial_controls(keys: dict) -> dict:
             # Check if NPZ file
             if info['mean'].endswith('.npz'):
                 file = np.load(info['mean'], allow_pickle=True)
-                if not (name in file.files):
+                if name not in file.files:
                     # Assume only one variable in file
                     msg = f'Variable {name} not in {info["mean"]} and more than one variable located in the file!'
                     assert len(file.files) == 1, msg
@@ -234,7 +238,7 @@ def extract_initial_controls(keys: dict) -> dict:
             elif info['mean'].endswith('.csv'):
                 df = pd.read_csv(info['mean'])
                 assert name in df.columns, f'Column {name} not in {info["mean"]}!'
-                info['mean'] = df[name].to_numpy() 
+                info['mean'] = df[name].to_numpy()
 
         elif isinstance(info['mean'], (int, float)):
             info['mean'] = np.array([info['mean']])
@@ -250,7 +254,7 @@ def extract_initial_controls(keys: dict) -> dict:
             info['mean'] = np.maximum(info['mean'], info['limits'][0])
         if info['limits'][1] is not None:
             info['mean'] = np.minimum(info['mean'], info['limits'][1])
-        
+
 
         # Check for var VAR or STD
         ############################################################################################################
@@ -260,7 +264,7 @@ def extract_initial_controls(keys: dict) -> dict:
 
         elif 'std' in info:
             std = info.pop('std', None)
-            
+
             # Standard deviation can be given as percentage of bound range
             if isinstance(std, str) and (info['limits'][0] is not None) and (info['limits'][1] is not None):
                 if std.endswith('%'):
@@ -276,12 +280,12 @@ def extract_initial_controls(keys: dict) -> dict:
         control_info[name] = info
 
     return control_info
-            
-        
 
 
 
-    
+
+
+
 
 def extract_multilevel_info(keys: Union[dict, list]) -> dict:
     '''
@@ -292,7 +296,7 @@ def extract_multilevel_info(keys: Union[dict, list]) -> dict:
     if isinstance(keys, list):
         keys_ml = list_to_dict(keys)
     assert isinstance(keys_ml, dict)
-    
+
     # Set levels
     assert 'levels' in keys_ml, 'LEVELS keyword missing in MULTILEVEL!'
     levels = int(keys_ml['levels'])
@@ -312,13 +316,11 @@ def extract_multilevel_info(keys: Union[dict, list]) -> dict:
     if not np.sum(keys_ml['ml_weights']) == 1.0:
         keys_ml['ml_weights'] = keys_ml['ml_weights']/np.sum(keys_ml['ml_weights'])
 
-    # Set multi-level error
-    keys_ml['ml_error_corr'] = keys_ml.get('ml_error_corr', None)
-    
     return keys_ml
 
 
 def extract_local_analysis_info(keys: Union[dict, list], state: list) -> dict:
+    """Local-analysis settings from the ``localanalysis`` block: parameter and region lists restricted to ``state``, ``search_range``, ``column_update``, and the pickled position and mask files."""
     # Check if keys are list, and make it a dict if not
     if isinstance(keys, list):
         keys = list_to_dict(keys)
@@ -337,7 +339,7 @@ def extract_local_analysis_info(keys: Union[dict, list], state: list) -> dict:
         if key.lower() in ['region_parameter', 'vector_region_parameter', 'cell_parameter']:
             local[key] = [elem for elem in key_item.split(' ') if elem in state]
         elif key.lower() == 'search_range':
-            local[key] = int(key_item) 
+            local[key] = int(key_item)
         elif key.lower() == 'column_update':
             local[key] = [elem for elem in key_item.split(',')]
         elif key.lower().endswith('_file'): # 'parameter_position_file', 'data_position_file' or 'update_mask_file'
@@ -352,7 +354,7 @@ def extract_local_analysis_info(keys: Union[dict, list], state: list) -> dict:
         assert 'data_position' in local, 'A pickle file containing the position of the data is MANDATORY'
 
         data_name = [elem for elem in local['data_position'].keys()]
-        if type(local['data_position'][data_name[0]][0]) == list:  # assim index has spesific position
+        if isinstance(local['data_position'][data_name[0]][0], list):  # assim index has spesific position
             local['unique'] = False
             data_pos = [elem for data in data_name for assim_elem in local['data_position'][data]
                         for elem in assim_elem]
@@ -386,7 +388,7 @@ def extract_local_analysis_info(keys: Union[dict, list], state: list) -> dict:
                 [data_ind[count] for count, val in enumerate(in_region) if val])
 
         return local
-    
+
 
 def organize_sparse_representation(info: Union[dict,list]) -> dict:
     """
@@ -414,15 +416,16 @@ def organize_sparse_representation(info: Union[dict,list]) -> dict:
         with masks loaded or created, dimensions flipped for compatibility, and
         all options standardized.
     """
-    # Ensure a dict
-    if isinstance(info, list):
-        info = list_to_dict(info)
+    # Ensure a dict, and work on a copy: the flags below are rewritten in place.
+    info = list_to_dict(info) if isinstance(info, list) else dict(info)
     assert isinstance(info, dict)
 
     # Redefine all 'yes' and 'no' values to bool
     for key, val in info.items():
-        if val == 'yes': info[key] = True
-        if val == 'no':  info[key] = False
+        if val == 'yes':
+            info[key] = True
+        if val == 'no':
+            info[key] = False
 
     # Intial dict
     sparse = {}
@@ -459,48 +462,32 @@ def organize_sparse_representation(info: Union[dict,list]) -> dict:
     sparse['keep_ca'] = info.get('keep_ca', False)
     sparse['inactive_value'] = info['inactive_value']
     sparse['use_ensemble'] = info.get('use_ensemble', None)
-    if sparse['use_ensemble'] == False: sparse['use_ensemble'] = None
+    if sparse['use_ensemble'] is False:
+        sparse['use_ensemble'] = None
 
     return sparse
 
 
 def extract_maxiter(keys: dict) -> dict:
-
+    """``max_iter`` from the ``iteration`` or ``mda`` block; 1 without either. Reads without rewriting the block."""
     if 'iteration' in keys:
-        if isinstance(keys['iteration'], list): 
-            keys['iteration'] = list_to_dict(keys['iteration'])
+        block = keys['iteration']
+        block = list_to_dict(block) if isinstance(block, list) else block
         try:
-            max_iter = keys['iteration']['max_iter']
+            max_iter = block['max_iter']
         except KeyError:
                 raise AssertionError('MAX_ITER has not been given in ITERATION')
-        
     elif 'mda' in keys:
-        if isinstance(keys['mda'], list): 
-            keys['mda'] = list_to_dict(keys['mda'])
+        block = keys['mda']
+        block = list_to_dict(block) if isinstance(block, list) else block
         try:
-            max_iter = keys['mda']['max_iter']
+            max_iter = block['max_iter']
         except KeyError:
                 raise AssertionError('MAX_ITER has not been given in MDA')
-
     else:
         max_iter = 1
 
     return max_iter
-    
-   
-def list_to_dict(info_list: list) -> dict:
-    assert isinstance(info_list, list)
-    # Initialize and loop over entries
-    info_dict = {}
-    for entry in info_list:
-        if not isinstance(entry, list):
-            entry = [entry]
-        # Fill in values
-        if len(entry) == 1:
-            info_dict[str(entry[0])] = None
-        elif len(entry) == 2:
-            info_dict[str(entry[0])] = entry[1]
-        else:
-            info_dict[str(entry[0])] = entry[1:]
 
-    return info_dict
+
+list_to_dict = pairs_to_dict
diff --git a/src/pipt/misc_tools/qaqc_tools.py b/src/pipt/misc_tools/qaqc_tools.py
index 85e20019..a560537b 100644
--- a/src/pipt/misc_tools/qaqc_tools.py
+++ b/src/pipt/misc_tools/qaqc_tools.py
@@ -1,1052 +1,703 @@
-"""Quality Assurance of the forecast (QA) and analysis (QC) step."""
-import copy
-import numpy as np
-import os
-# import matplotlib as mpl
-# mpl.use('Qt5Agg')
-import matplotlib.pyplot as plt
-import matplotlib.patches as pat
+"""Quality assurance of the forecast (QA) and of the analysis (QC).
+
+Four diagnostics, driven by the scheme through its hooks: after the prior
+forecast and after every accepted iteration.
+
+``calc_coverage``
+    Is every observation inside the range the ensemble forecasts? Plots the
+    forecast spread with the observations, marking those outside it, and logs
+    how many fall outside per data type. Seismic (vector) data get the
+    importance-scaled 2-D coverage maps of E. O. Lie (GeoCore).
+``calc_mahalanobis``
+    The model-deficiency diagnostic of Oliver (2020), *Diagnosing reservoir
+    model deficiency for model improvement*: Mahalanobis distances between the
+    observations and the perturbed forecast, singly (level 1) or in pairs and
+    triples, logged as a ranked list with cross-plots of the worst.
+``calc_kg``
+    The ES-style Kalman gain each data type would apply to each parameter,
+    ranked by size, so conflicting or dominant data can be spotted; field
+    parameters can be written to the grid through the simulator.
+``calc_da_stat``
+    How far the parameters moved from the prior, in units of the prior
+    standard deviation, per parameter group.
+
+Data enters as the ensemble's frames -- observations, variances and
+predictions indexed by report point with one column per data type, each cell
+an array (``(1,)`` for point data, ``(n,)`` for vector data such as seismic)
+or ``None`` -- and is adapted once, per data type, into the arrays the
+diagnostics consume. Outputs go to a ``QAQC`` folder under the run's save
+folder. Multilevel ensembles are not supported.
+
+Copyright (c) 2019-2022 NORCE, All Rights Reserved. 4DSEIS
+"""
+
+import logging
+from pathlib import Path
+
 import matplotlib.collections as mcoll
+import matplotlib.patches as pat
+import matplotlib.pyplot as plt
+import numpy as np
 from matplotlib.colors import ListedColormap
-import itertools
-import logging
-from pipt.misc_tools import cov_regularization
 from scipy.interpolate import interp1d
 from scipy.io import loadmat
-import cv2
+
+import pipt.misc_tools.analysis_tools as at
+
+__all__ = ["QAQC"]
+
+#: Data types treated as seismic (vector) data by the coverage maps.
+SEISMIC_TYPES = ("bulkimp", "sim2seis", "avo", "grav")
+
+
+def _finite_array(cell):
+    """The cell as a flat float array, or ``None`` if it holds no usable value."""
+    if cell is None:
+        return None
+    try:
+        values = np.asarray(cell, dtype=float).ravel()
+    except (TypeError, ValueError):
+        return None
+    if values.size == 0 or not np.isfinite(values).all():
+        return None
+    return values
+
+
+def _rgb_to_hls(rgb):
+    """Vectorised colorsys.rgb_to_hls on an (..., 3) array in [0, 1]."""
+    r, g, b = rgb[..., 0], rgb[..., 1], rgb[..., 2]
+    maxc, minc = rgb.max(axis=-1), rgb.min(axis=-1)
+    lum = (maxc + minc) / 2
+    delta = maxc - minc
+    with np.errstate(divide="ignore", invalid="ignore"):
+        sat = np.where(delta == 0, 0.0,
+                       np.where(lum <= 0.5, delta / (maxc + minc), delta / (2 - maxc - minc)))
+        rc, gc, bc = (maxc - r) / delta, (maxc - g) / delta, (maxc - b) / delta
+    hue = np.where(r == maxc, bc - gc, np.where(g == maxc, 2 + rc - bc, 4 + gc - rc))
+    hue = np.where(delta == 0, 0.0, (hue / 6) % 1)
+    return np.stack((hue, lum, sat), axis=-1)
+
+
+def _hls_to_rgb(hls):
+    """Vectorised colorsys.hls_to_rgb on an (..., 3) array in [0, 1]."""
+    h, lum, s = hls[..., 0], hls[..., 1], hls[..., 2]
+    m2 = np.where(lum <= 0.5, lum * (1 + s), lum + s - lum * s)
+    m1 = 2 * lum - m2
+
+    def channel(hue):
+        hue = hue % 1
+        return np.where(hue < 1 / 6, m1 + (m2 - m1) * hue * 6,
+               np.where(hue < 0.5, m2,
+               np.where(hue < 2 / 3, m1 + (m2 - m1) * (2 / 3 - hue) * 6, m1)))
+
+    rgb = np.stack((channel(h + 1 / 3), channel(h), channel(h - 1 / 3)), axis=-1)
+    return np.where(s[..., None] == 0, lum[..., None], rgb)
 
 
-# Define the class for qa/qc tools.
 class QAQC:
+    """Quality assurance of the forecast (QA) and the analysis (QC); see the module docstring.
+
+    Parameters
+    ----------
+    keys : dict
+        The ``dataassim`` config merged with the simulator's ``input_dict``.
+        Read: ``assimindex`` (which report points are assimilated), and
+        optionally ``actnum`` (path to an ``.npz`` with an ``actnum`` mask)
+        and ``scale`` (a divisor applied to seismic data before plotting).
+    data_df, data_var_df : PETDataFrame
+        Observations and their variances, indexed by report point, one column
+        per data type.
+    logger : object, optional
+        Anything with an ``info`` method. Defaults to ``logging.getLogger``.
+    prior_info : dict, optional
+        Per-parameter prior description (``nx``, ``ny``, ``nz``); needed by
+        ``calc_kg`` and by grid output.
+    sim : object, optional
+        Simulator; used only for an optional ``write_to_grid`` method.
+    ini_state : dict, optional
+        The prior state, ``{parameter: (n, ne) array}``, as ``state_layout.to_dict(enX)``
+        returns it; defines the parameter groups and the ensemble size.
+    localization : object, optional
+        The scheme's localization. Only the auto-adaptive kind is used, by
+        ``calc_kg``; anything else is ignored.
+    folder : str or Path, optional
+        Where plots and grid files go. Default ``QAQC`` in the working directory.
     """
-     Perform Quality Assurance of the forecast (QA) and analysis (QC) step.
-     Available functions:
-        1) calc_coverage: check forecast data coverage
-        2) calc_mahalanobis: evaluate "higher-order" data coverage
-        3) calc_kg: check/write individual gain for parameters;
-                    flag data which have conflicting updates
-        4) calc_da_stat: compute statistics for updated parameters
-
-     Copyright (c) 2019-2022 NORCE, All Rights Reserved. 4DSEIS
-     """
-
-    # Initialize
-    def __init__(self, keys, obs_data, datavar, logger=None, prior_info=None, sim=None, ini_state=None):
-        self.keys = keys  # input info for the case
-        self.obs_data = obs_data  # observed (real) data
-        self.datavar = datavar  # data variance
-        if logger is None:  # define a logger to print ouput
-            logging.basicConfig(level=logging.INFO,
-                                filename='qaqc_logger.log',
-                                filemode='a',
-                                format='%(asctime)s : %(levelname)s : %(name)s : %(message)s')
-            self.logger = logging.getLogger('QAQC')
-        else:
-            self.logger = logger
-        self.prior_info = prior_info  # prior info for the different parameter types
-        self.sim = sim  # this class contains potential writing functions (this class can be saved to debug_analysis)
-        self.ini_state = ini_state  # the first state; used to compute statistics
-        self.ne = 0
-        if 'multilevel' in keys:
-            self.multilevel = keys['multilevel']
-            for i, opt in enumerate(list(zip(*self.multilevel))[0]):
-                if opt == 'levels':
-                    self.tot_level = int(self.multilevel[i][1])
-                if opt == 'en_size':
-                    self.ml_ne = [int(el) for el in self.multilevel[i][1]]
-                if opt == 'cov_wgt':
-                    try:
-                        cov_mat_wgt = [float(elem) for elem in [item for item in self.multilevel[i][1]]]
-                    except:
-                        cov_mat_wgt = [float(item) for item in self.multilevel[i][1]]
-                    Sum = 0
-                    for i in range(len(cov_mat_wgt)):
-                        Sum += cov_mat_wgt[i]
-                    for i in range(len(cov_mat_wgt)):
-                        cov_mat_wgt[i] /= Sum
-                    self.cov_wgt = cov_mat_wgt
-            self.list_state = list(self.ini_state[0].keys())
-        else:
-            if self.ini_state is not None:
-                self.ne = self.ini_state[list(self.ini_state.keys())[0]].shape[1]  # get the ensemble size from here
-            self.list_state = list(self.ini_state.keys())
-
-        assim_step = 0  # Assume simultaneous assimiation
-        assim_ind = [keys['obsname'], keys['assimindex'][assim_step]]
-        #assim_ind = [keys['obsname'], keys['assimindex']]
-        if isinstance(assim_ind[1], list):  # Check if prim. ind. is a list
-            self.l_prim = [int(x) for x in assim_ind[1]]
-            #self.l_prim = [int(x[0]) for x in assim_ind[1]]
-        else:  # Float
-            self.l_prim = [int(assim_ind[1])]
-
-        self.data_types = list(obs_data[0].keys())  # All data types
-        self.en_obs = {}
-        self.en_obs_vec = {}
-        self.en_time = {}
-        self.en_time_vec = {}
+
+    def __init__(self, keys, data_df, data_var_df, logger=None, prior_info=None, sim=None,
+                 ini_state=None, localization=None, folder="QAQC"):
+        if "multilevel" in keys:
+            raise NotImplementedError(
+                "QA/QC is not available for multilevel ensembles: the diagnostics "
+                "assume one prediction ensemble per report point."
+            )
+        self.keys = keys
+        self.logger = logger if logger is not None else logging.getLogger("QAQC")
+        self.prior_info = prior_info
+        self.sim = sim
+        self.ini_state = ini_state
+        self.localization = localization if getattr(localization, "name", None) == "autoadaloc" else None
+        self.list_state = list(ini_state.keys()) if ini_state else []
+        self.ne = next(iter(ini_state.values())).shape[1] if ini_state else None
+        self.folder = Path(folder)
+        self.folder.mkdir(parents=True, exist_ok=True)
+        self.actnum = self._load_actnum(keys)
+
+        self.data_types = list(data_df.columns)
+        self._labels = list(data_df.index)
+        self.l_prim = self._assimilated_positions(keys, len(self._labels))
+
+        # Point data (one value per report point): (n_t, 1) arrays and the
+        # positions they came from. Vector data (n values per report point,
+        # e.g. seismic): concatenated over report points, plus the raw cells
+        # for the per-vintage coverage maps.
+        self.en_obs, self.en_var, self.en_time = {}, {}, {}
+        self.en_obs_vec, self.en_var_vec, self.en_time_vec = {}, {}, {}
+        self._obs_vector_cells = {}
         for typ in self.data_types:
-            self.en_obs[typ] = np.array(
-                [self.obs_data[ind][typ].flatten() for ind in self.l_prim if self.obs_data[ind][typ]
-                 is not None and sum(np.isnan(self.obs_data[ind][typ])) == 0 and self.obs_data[ind][typ].shape == (1,)])
-            l = [self.obs_data[ind][typ].flatten() for ind in self.l_prim if self.obs_data[ind][typ] is not None
-                 and sum(np.isnan(self.obs_data[ind][typ])) == 0
-                 and self.obs_data[ind][typ].shape[0] > 1]
-            if l:
-                self.en_obs_vec[typ] = np.expand_dims(np.concatenate(l), 1)
-            self.en_time[typ] = [ind for ind in self.l_prim if self.obs_data[ind][typ]
-                                 is not None and self.obs_data[ind][typ].shape == (1,)]
-            l = [ind for ind in self.l_prim if self.obs_data[ind][typ]
-                 is not None and self.obs_data[ind][typ].shape[0] > 1]
-            if l:
-                self.en_time_vec[typ] = l
-
-        # Check if the QA folder is generated
-        self.folder = 'QAQC' + os.sep
-        if not os.path.exists(self.folder):
-            os.mkdir(self.folder)  # if not generate
-
-        if 'localization' in self.keys:
-            self.localization = cov_regularization.localization(self.keys['localization'],
-                                                                self.keys['truedataindex'],
-                                                                self.keys['datatype'],
-                                                                self.keys['staticvar'],
-                                                                self.ne)
+            self._collect_observations(typ, data_df, data_var_df)
+
+        # Filled by set().
         self.pred_data = None
         self.state = None
-        self.en_fcst = {}
-        self.en_ml_fcst = {}
-        self.en_ml_fcst_vec = {}
-        self.en_fcst_vec = {}
         self.lam = None
+        self.en_fcst, self.en_fcst_vec, self._fcst_vector_cells = {}, {}, {}
+
+    # ------------------------------------------------------------------
+    # Adapting the frames
+    # ------------------------------------------------------------------
+    @staticmethod
+    def _assimilated_positions(keys, n_points):
+        """Positions (into the report-point index) of the assimilated data.
+
+        ``assimindex`` is a list, or a list of lists for schemes that
+        assimilate in several steps; every listed position counts here.
+        """
+        assim = keys.get("assimindex")
+        if assim is None:
+            return list(range(n_points))
+        if not isinstance(assim, (list, tuple)):
+            return [int(assim)]
+        flat = []
+        for item in assim:
+            flat.extend(item if isinstance(item, (list, tuple)) else [item])
+        return [int(x) for x in flat]
+
+    @staticmethod
+    def _load_actnum(keys):
+        path = keys.get("actnum")
+        if not path:
+            return None
+        try:
+            return np.load(path)["actnum"].astype(bool)
+        except Exception:
+            return None
+
+    def _collect_observations(self, typ, data_df, data_var_df):
+        point, vector = [], []
+        for pos in self.l_prim:
+            label = self._labels[pos]
+            obs = _finite_array(data_df.loc[label, typ])
+            if obs is None:
+                continue
+            var = _finite_array(data_var_df.loc[label, typ]) if typ in data_var_df.columns else None
+            if var is None or var.size not in (1, obs.size):
+                self.logger.info(f"QAQC: no variance for {typ} at report point {label}; skipping it")
+                continue
+            var = np.broadcast_to(var, obs.shape)
+            (point if obs.size == 1 else vector).append((pos, obs, var))
+
+        self.en_obs[typ] = np.array([o for _, o, _ in point], dtype=float).reshape(-1, 1)
+        self.en_var[typ] = np.array([v for _, _, v in point], dtype=float).reshape(-1, 1)
+        self.en_time[typ] = [pos for pos, _, _ in point]
+        if vector:
+            self.en_obs_vec[typ] = np.concatenate([o for _, o, _ in vector])[:, None]
+            self.en_var_vec[typ] = np.concatenate([v for _, _, v in vector])[:, None]
+            self.en_time_vec[typ] = [pos for pos, _, _ in vector]
+            self._obs_vector_cells[typ] = vector
 
-    # Set the predicted data and current state
     def set(self, pred_data, state=None, lam=None):
+        """Hand over the current predictions, state and damping parameter.
+
+        Parameters
+        ----------
+        pred_data : PETDataFrame
+            Predictions aligned with the observation frame; each cell an array
+            whose last axis is the ensemble.
+        state : dict, optional
+            Current state, ``{parameter: (n, ne) array}``.
+        lam : float, optional
+            The scheme's damping parameter (0 for schemes without one).
+        """
         self.pred_data = pred_data
-        for typ in self.data_types:
-            if hasattr(self, 'multilevel'):
-                self.en_ml_fcst[typ] = [np.array([self.pred_data[ind][l][typ].flatten()
-                                                  for ind in self.l_prim if sum(np.isnan(self.obs_data[ind][typ])) == 0
-                                                  and self.obs_data[ind][typ].shape == (1,)]) for l in
-                                        range(self.tot_level)]
-                # todo: for vector data
-
-                self.en_fcst[typ] = np.concatenate(self.en_ml_fcst[typ], axis=1)  # merge all levels
-            else:
-                self.en_fcst[typ] = np.array(
-                    [self.pred_data[ind][typ].flatten() for ind in self.l_prim if
-                     self.obs_data[ind][typ] is not None and
-                     sum(np.isnan(self.obs_data[ind][typ])) == 0
-                     and self.obs_data[ind][typ].shape == (1,)])
-                l = [self.pred_data[ind][typ] for ind in self.l_prim if
-                     self.obs_data[ind][typ] is not None
-                     and sum(np.isnan(self.obs_data[ind][typ])) == 0
-                     and self.obs_data[ind][typ].shape[0] > 1]
-                if l:
-                    self.en_fcst_vec[typ] = np.concatenate(l)
         self.state = state
         self.lam = lam
-
-    def calc_coverage(self, line=None, field_dim=None, uxl = None, uil = None, contours = None, uxl_c = None, uil_c = None):
-        """
-        Calculate the Data coverage for production and seismic data. For seismic data the plotting is based on the
-        importance-scaled coverage developed by Espen O. Lie from GeoCore.
-
-        Input:
-            line: if not None, plot 1d coverage
-            field_dim: if None, must import utm coordinates. Else give the grid
-
-        Copyright (c) 2019-2022 NORCE, All Rights Reserved. 4DSEIS
+        for typ in self.data_types:
+            rows = [np.asarray(pred_data.loc[self._labels[pos], typ], dtype=float).ravel()
+                    for pos in self.en_time[typ]]
+            self.en_fcst[typ] = (np.array(rows, dtype=float) if rows
+                                 else np.empty((0, self.ne or 0)))
+            cells = [np.asarray(pred_data.loc[self._labels[pos], typ], dtype=float)
+                     for pos in self.en_time_vec.get(typ, [])]
+            if cells:
+                self._fcst_vector_cells[typ] = cells
+                self.en_fcst_vec[typ] = np.concatenate(cells, axis=0)
+
+    def _lumped(self, typ):
+        """Point and vector data of one type stacked: forecast (nd, ne), observations and variances (nd, 1)."""
+        parts = [(self.en_fcst.get(typ), self.en_obs.get(typ), self.en_var.get(typ)),
+                 (self.en_fcst_vec.get(typ), self.en_obs_vec.get(typ), self.en_var_vec.get(typ))]
+        parts = [(f, o, v) for f, o, v in parts if f is not None and f.size]
+        if not parts:
+            return None, None, None
+        return tuple(np.concatenate(block, axis=0) for block in zip(*parts))
+
+    def _save_figure(self, name):
+        plt.savefig(self.folder / f"{name}.png", bbox_inches="tight")
+        plt.close()
+
+    # ------------------------------------------------------------------
+    # Coverage
+    # ------------------------------------------------------------------
+    def calc_coverage(self, line=None, field_dim=None, uxl=None, uil=None, contours=None,
+                      uxl_c=None, uil_c=None):
+        """Check whether the observations lie inside the ensemble's forecast range.
+
+        For each point data type: a plot of the forecast ensemble over the
+        report points with the observations, red where an observation lies
+        above or below every member, and a log line with the count. For the
+        first seismic data type present: the importance-scaled 2-D coverage
+        maps, per vintage.
+
+        Parameters
+        ----------
+        line : int, optional
+            Also plot the 1-D coverage along this line of the seismic maps.
+        field_dim : tuple, optional
+            Grid dimensions of the seismic maps when no mask file is present.
+        uxl, uil : array-like, optional
+            Easting and northing coordinates of the map edges; default from a
+            ``seglines.mat`` in the working directory, else grid indices.
+        contours, uxl_c, uil_c : array-like, optional
+            A contour field and its coordinates to draw over the maps.
         """
+        self._require("pred_data")
+        for typ in self.data_types:
+            if typ in SEISMIC_TYPES or not self.en_obs[typ].size:
+                continue
+            fcst, obs = self.en_fcst[typ], self.en_obs[typ]
+            below = (obs < fcst).all(axis=1)          # observation under every member
+            above = (obs > fcst).all(axis=1)          # observation over every member
+            times = np.asarray(self.en_time[typ])
+            outside = int(below.sum() + above.sum())
+            self.logger.info(f"QAQC coverage {typ}: {outside} of {obs.size} observations outside the ensemble range")
 
-        def _colorline(x, y, z=None, cmap='copper', norm=plt.Normalize(0.0, 1.0),
-                       linewidth=3, alpha=1.0):
-            """
-            http://nbviewer.ipython.org/github/dpsanders/matplotlib-examples/blob/master/colorline.ipynb
-            http://matplotlib.org/examples/pylab_examples/multicolored_line.html
-            Plot a colored line with coordinates x and y
-            Optionally specify colors in the array z
-            Optionally specify a colormap, a norm function and a line width
-            """
-
-            # Default colors equally spaced on [0,1]:
-            if z is None:
-                z = np.linspace(0.0, 1.0, len(x))
-
-            # Special case if a single number:
-            # to check for numerical input -- this is a hack
-            if not hasattr(z, "__iter__"):
-                z = np.array([z])
-
-            z = np.asarray(z)
-
-            segments = _make_segments(x, y)
-            lc = mcoll.LineCollection(segments, array=z, cmap=cmap, norm=norm,
-                                      linewidth=linewidth, alpha=alpha)
-
-            ax = plt.gca()
-            ax.add_collection(lc)
-
-            return lc
-
-        def _make_segments(x, y):
-            """
-            Create list of line segments from x and y coordinates, in the correct format
-            for LineCollection: an array of the form numlines x (points per line) x 2 (x
-            and y) array
-            """
-
-            points = np.array([x, y]).T.reshape(-1, 1, 2)
-            segments = np.concatenate([points[:-1], points[1:]], axis=1)
-            return segments
-
-        def _plot_coverage_1D(line, field_dim):
-            x = np.array([-1, -np.finfo(float).eps, 0, .5, 1, 1 + np.finfo(float).eps, 2])
-            d_ens = np.squeeze(data_reg[:, int(line), :])
-            d_real = np.squeeze(data_real_reg[:, int(line)])
-            scale = max(d_real)  # 2.5
-
-            r = np.array([0.1, 0.3, 0.8, 1.0, 0.8, 0.7, 0.5])
-            f = interp1d(x, r)
-            ri = f(3 * np.arange(256) / 255 - 1)
-            g = np.array([0.1, 0.3, 0.9, 1.0, 0.9, 0.4, 0.2])
-            f = interp1d(x, g)
-            gi = f(3 * np.arange(256) / 255 - 1)
-            b = np.array([0.4, 0.6, 0.8, 1.0, 0.8, 0.4, 0.2])
-            f = interp1d(x, b)
-            bi = f(3 * np.arange(256) / 255 - 1)
-
-            d_min = np.min(d_ens, axis=1)
-            d_max = np.max(d_ens, axis=1) + nl
-            sat = 2 * np.minimum((d_max + d_real) / scale, 0.5)
-            sat = (sat - nl) / (1 - nl)
-            sc = d_max - d_min
-
-            attr = (d_real - d_min) / sc
-            attr = np.minimum(np.maximum(attr, -1), 2)
+            plt.figure()
+            plt.plot(times, fcst, c="0.35")
+            plt.plot(times, obs, "g*")
+            plt.plot(times[above], obs[above], "r*")
+            plt.plot(times[below], obs[below], "r*")
+            plt.title(f"{typ}: forecast range and observations")
+            self._save_figure(typ.replace(" ", "_"))
+
+        seismic = [typ for typ in SEISMIC_TYPES if typ in self._obs_vector_cells]
+        if seismic:
+            self._seismic_coverage(seismic[0], line, field_dim, uxl, uil, contours, uxl_c, uil_c)
+
+    def _seismic_scaling(self):
+        scale = self.keys.get("scale")
+        if isinstance(scale, (list, tuple)) and len(scale) > 1:
+            return float(scale[1])
+        if isinstance(scale, (int, float)):
+            return float(scale)
+        return 1.0
+
+    def _seismic_coverage(self, typ, line, field_dim, uxl, uil, contours, uxl_c, uil_c):
+        scaling = self._seismic_scaling()
+        observed = [obs / scaling for _, obs, _ in self._obs_vector_cells[typ]]
+        predicted = [cell / scaling for cell in self._fcst_vector_cells.get(typ, [])]
+        if len(predicted) != len(observed):
+            self.logger.info(f"QAQC coverage {typ}: predictions missing, skipping the seismic maps")
+            return
 
+        if uxl is None and uil is None:
             try:
-                uxl = loadmat('seglines.mat')['uxl'].flatten()
-            except:
-                uxl = [0, field_dim[0]]
-
-            uxl = np.arange(uxl[0], uxl[-1], (uxl[-1] - uxl[0]) / data_real_reg.shape[0])
-            x = np.concatenate((uxl, np.flip(uxl)))
-            y = np.concatenate((d_min, np.flip(d_max)))
-
-            # plot not scaled by importance
-            fig = plt.figure()
-            ax = fig.add_subplot()
-            right_side = ax.spines["right"]
-            right_side.set_visible(False)
-            top_side = ax.spines["top"]
-            top_side.set_visible(False)
-            poly = pat.Polygon(np.column_stack((x, y)), closed=False, edgecolor='k', facecolor=np.array([.7, .7, .7]))
-            ax.add_patch(poly)
-            ln = _colorline(uxl, d_real, attr, None, plt.Normalize(-1, 2))
-            c = np.column_stack((ri, gi, bi))
-            cm = ListedColormap(c)
-            ln.set_cmap(cm)
-            plt.colorbar(ln)
-            plt.xlim(uxl[0] - np.finfo(float).eps, uxl[-1] + np.finfo(float).eps)
-            plt.ylim(0, scale)
-            plt.title('1D coverage plot not scaled by Importance')
-            filename = self.folder + 'coverage_1d_vint_' + str(vint)
-            plt.savefig(filename)
-            os.system('convert ' + filename + '.png' + ' -trim ' + filename + '.png')
-
-            # plot scaled by importance
+                seglines = loadmat("seglines.mat")
+                uxl, uil = seglines["uxl"].flatten(), seglines["uil"].flatten()
+            except Exception:
+                uxl = uil = None
+
+        nl = 0.25
+        knots = np.array([-1, -np.finfo(float).eps, 0, .5, 1, 1 + np.finfo(float).eps, 2])
+        channels = [interp1d(knots, np.array(c)) for c in (
+            [0.1, 0.3, 0.8, 1.0, 0.8, 0.7, 0.5],
+            [0.1, 0.3, 0.9, 1.0, 0.9, 0.4, 0.2],
+            [0.4, 0.6, 0.8, 1.0, 0.8, 0.4, 0.2],
+        )]
+
+        for vint, (d_obs, d_pred) in enumerate(zip(observed, predicted)):
+            try:
+                mask = loadmat("mask_20.mat")[f"mask_{vint + 1}"].astype(bool).transpose()
+            except Exception:
+                if field_dim is None:
+                    self.logger.info("QAQC coverage: no mask_20.mat and no field_dim given; skipping the seismic maps")
+                    return
+                mask = np.ones(field_dim, dtype=bool)
+            data_real_reg = np.zeros(mask.shape)
+            data_real_reg[mask] = d_obs
+            data_reg = np.zeros(mask.shape + (d_pred.shape[1],))
+            data_reg[mask] = d_pred
+
+            d_min = data_reg.min(axis=2)
+            d_max = data_reg.max(axis=2) + nl
+            sat = 2 * np.minimum((d_max + data_real_reg) / np.max(d_max + data_real_reg), 0.5)
+            attr = np.clip((data_real_reg - d_min) / (d_max - d_min), -1, 2)
+            rgb = np.dstack([f(attr) for f in channels])
+
+            x_edges = uxl if uxl is not None else [0, mask.shape[0]]
+            y_edges = uil if uil is not None else [0, mask.shape[1]]
+            extent = (x_edges[0], x_edges[-1], y_edges[-1], y_edges[0])
+
+            def draw(image, title, name):
+                plt.figure()
+                plt.imshow(image, extent=extent)
+                if contours is not None and uil_c is not None and uxl_c is not None:
+                    plt.contour(uxl_c, uil_c, contours[::-1, :], levels=1, colors="black")
+                    plt.xlim(extent[0], extent[1])
+                    plt.ylim(extent[2], extent[3])
+                    plt.xlabel("Easting (km)")
+                    plt.ylabel("Northing (km)")
+                plt.title(f"{title} - epsilon={nl}")
+                self._save_figure(f"{name}_vint_{vint}")
+
+            draw(rgb, "Coverage - not scaled by Importance", "coverage")
+            # Importance scaling: darken the lightness channel where the
+            # ensemble spread is small relative to the signal.
+            hls = _rgb_to_hls(np.clip(rgb, 0, 1))
+            hls[..., 1] = np.minimum(hls[..., 1] / (np.abs(sat - nl) / (1 - nl) * 1.5), 1.0)
+            draw(np.clip(_hls_to_rgb(hls), 0, 1), "Coverage - scaled by Importance", "coverage_importance")
+            draw(sat[::-1, :], "Importance", "importance")
+
+            if line is not None:
+                self._coverage_line(int(line), vint, data_reg, data_real_reg, nl, channels, x_edges)
+
+    def _coverage_line(self, line, vint, data_reg, data_real_reg, nl, channels, x_edges):
+        d_ens = np.squeeze(data_reg[:, line, :])
+        d_real = np.squeeze(data_real_reg[:, line])
+        scale = max(d_real)
+        d_min = d_ens.min(axis=1)
+        d_max = d_ens.max(axis=1) + nl
+        sat = (2 * np.minimum((d_max + d_real) / scale, 0.5) - nl) / (1 - nl)
+        attr = np.clip((d_real - d_min) / (d_max - d_min), -1, 2)
+        colours = ListedColormap(np.column_stack([f(3 * np.arange(256) / 255 - 1) for f in channels]))
+        x = np.arange(x_edges[0], x_edges[-1], (x_edges[-1] - x_edges[0]) / data_real_reg.shape[0])
+        outline = np.column_stack((np.concatenate((x, x[::-1])), np.concatenate((d_min, d_max[::-1]))))
+
+        for scaled, name in ((False, "coverage_1d"), (True, "coverage_1d_importance")):
             fig = plt.figure()
             ax = fig.add_subplot()
-            right_side = ax.spines["right"]
-            right_side.set_visible(False)
-            top_side = ax.spines["top"]
-            top_side.set_visible(False)
-            poly = pat.Polygon(np.column_stack((x, y)), closed=False, edgecolor='k', facecolor=np.array([.7, .7, .7]))
-            ax.add_patch(poly)
-            ln = _colorline(uxl, d_real, attr, None, plt.Normalize(-1, 2))
-            # y0 = np.column_stack((np.zeros(uxl.shape)+np.minimum(np.min(d_min), np.min(d_real)),
-            #                     np.zeros(uxl.shape)+np.maximum(np.max(d_max), np.max(d_real))))
-            alpha = 1 - sat
-            alpha = np.minimum(alpha, 1.0)
-            alpha = np.maximum(alpha, 0.0)
-            cw = ListedColormap(['White'])
-            for l in range(len(uxl)):
-                ln_imp = _colorline(uxl[l] * np.ones(2), np.array([d_min[l], d_max[l]]), alpha=alpha[l])
-                ln_imp.set_cmap(cw)
-            c = np.column_stack((ri, gi, bi))
-            cm = ListedColormap(c)
-            ln.set_cmap(cm)
-            plt.colorbar(ln)
-            plt.xlim(uxl[0] - np.finfo(float).eps, uxl[-1] + np.finfo(float).eps)
+            ax.spines["right"].set_visible(False)
+            ax.spines["top"].set_visible(False)
+            ax.add_patch(pat.Polygon(outline, closed=False, edgecolor="k", facecolor=np.array([.7, .7, .7])))
+            segments = np.concatenate([np.array([x, d_real]).T.reshape(-1, 1, 2)[:-1],
+                                       np.array([x, d_real]).T.reshape(-1, 1, 2)[1:]], axis=1)
+            coloured = mcoll.LineCollection(segments, array=attr, cmap=colours, norm=plt.Normalize(-1, 2), linewidth=3)
+            ax.add_collection(coloured)
+            if scaled:
+                alpha = np.clip(1 - sat, 0.0, 1.0)
+                for i in range(len(x)):
+                    seg = mcoll.LineCollection([[(x[i], d_min[i]), (x[i], d_max[i])]], colors="white",
+                                               alpha=float(alpha[i]), linewidth=3)
+                    ax.add_collection(seg)
+            plt.colorbar(coloured)
+            plt.xlim(x[0], x[-1])
             plt.ylim(0, scale)
-            plt.title('1D coverage plot scaled by Importance')
-            filename = self.folder + 'coverage_1d_importance_vint_' + str(vint)
-            plt.savefig(filename)
-            os.system('convert ' + filename + '.png' + ' -trim ' + filename + '.png')
-
-        for typ in [dat for dat in self.data_types if not dat in ['bulkimp', 'sim2seis', 'avo', 'grav']]:  # Only well data
-            if hasattr(self, 'multilevel'):  # calc for each level
-                plt.figure()
-                cover_low = [True for _ in self.en_obs[typ]]
-                cover_high = [True for _ in self.en_obs[typ]]
-                for l in range(self.tot_level):
-                    # Check coverage
-                    level_cover_low = [(el < self.en_ml_fcst[typ][l][ind]).all() for ind, el in
-                                       enumerate(self.en_obs[typ])]
-                    level_cover_high = [(el > self.en_ml_fcst[typ][l][ind]).all() for ind, el in
-                                        enumerate(self.en_obs[typ])]
-                    for ind, el in enumerate(level_cover_low):
-                        if not el:
-                            cover_low[ind] = False
-                        if not level_cover_high[ind]:
-                            cover_high[ind] = False
-                    plt.plot(self.en_time[typ], self.en_ml_fcst[typ][l], c=f'{l / self.tot_level}', label=f'Level {l}')
-                plt.plot(self.en_time[typ], self.en_obs[typ], 'g*')
-                plt.plot([self.en_time[typ][ind] for ind, el in enumerate(cover_high) if el],
-                         self.en_obs[typ][cover_high], 'r*')
-                plt.plot([self.en_time[typ][ind] for ind, el in enumerate(cover_low) if el],
-                         self.en_obs[typ][cover_low], 'r*')
-                # remove duplicate labels
-                handles, labels = plt.gca().get_legend_handles_labels()
-                labels, ids = np.unique(labels, return_index=True)
-                handles = [handles[i] for i in ids]
-                plt.legend(handles, labels, loc='best')
-                ######
-                plt.savefig(self.folder + typ.replace(' ', '_'))
-                plt.close()
-            else:
-                # Check coverage
-                cover_low = [(el < self.en_fcst[typ][ind]).all() for ind, el in enumerate(self.en_obs[typ])]
-                cover_high = [(el > self.en_fcst[typ][ind]).all() for ind, el in enumerate(self.en_obs[typ])]
-                # if sum(cover_low) > 1 or sum(cover_high) > 1:  # not covered
-                # TODO: log this with some text
-                # plot the missing coverage
-                plt.figure()
-                plt.plot(self.en_time[typ], self.en_fcst[typ], c='0.35')
-                plt.plot(self.en_time[typ], self.en_obs[typ], 'g*')
-                plt.plot([self.en_time[typ][ind] for ind, el in enumerate(cover_high) if el],
-                         self.en_obs[typ][cover_high], 'r*')
-                plt.plot([self.en_time[typ][ind] for ind, el in enumerate(cover_low) if el],
-                         self.en_obs[typ][cover_low], 'r*')
-                plt.savefig(self.folder + typ.replace(' ', '_'))
-                plt.close()
-
-        #  Plot the seismic data
-        data_sim = []
-        data = []
-        supported_data = ['sim2seis', 'bulkimp', 'avo', 'grav']
-        my_data = [dat for dat in supported_data if dat in self.data_types]
-        if len(my_data) == 0:
-            return
-        else:
-            my_data = my_data[0]
-	    #my_data = my_data[1]
-
-        # get the data
-        seis_scaling = 1.0
-        if 'scale' in self.keys:
-            seis_scaling = self.keys['scale'][1]
-        for ind, t in enumerate(self.l_prim):
-            if self.obs_data[t][my_data] is not None and sum(np.isnan(self.obs_data[t][my_data])) == 0:
-                data_sim.append(self.obs_data[t][my_data] / seis_scaling)
-                data.append(self.pred_data[t][my_data] / seis_scaling)
-
-        # loop through all vintages
-        for vint in range(len(data_sim)):
-
-            # map to 2D
-            if not len(data_sim):
-                return
-            try:
-                mask = loadmat('mask_20.mat')[f'mask_{vint + 1}']
-                mask = mask.astype(bool).transpose()
-                data_real_reg = np.zeros(mask.shape)
-            except:
-                mask = np.ones(field_dim, dtype=bool)
-                data_real_reg = np.zeros(mask.shape)
-            data_real_reg[mask] = data_sim[vint]
-            ne = data[vint].shape[1]
-            data_reg = np.zeros(mask.shape + (ne,))
-            for member in range(ne):
-                data_reg[mask, member] = data[vint][:, member]
-
-            # generate coverage and plot
-            nl = 0.25
-            x = np.array([-1, -np.finfo(float).eps, 0, .5, 1, 1 + np.finfo(float).eps, 2])
-
-            r = np.array([0.1, 0.3, 0.8, 1.0, 0.8, 0.7, 0.5])
-            g = np.array([0.1, 0.3, 0.9, 1.0, 0.9, 0.4, 0.2])
-            b = np.array([0.4, 0.6, 0.8, 1.0, 0.8, 0.4, 0.2])
-
-            d_min = np.min(data_reg, axis=2)
-            d_max = np.max(data_reg, axis=2) + nl
-            sat = 2 * np.minimum((d_max + data_real_reg) / np.max(d_max.flatten() + data_real_reg.flatten()),
-                                 0.5)
-            sc = d_max - d_min
-
-            attr = (data_real_reg - d_min) / sc
-            attr = np.minimum(np.maximum(attr, -1), 2)
-
-            rgb = []
-            f = interp1d(x, r)
-            rgb.append(f(attr))
-            f = interp1d(x, g)
-            rgb.append(f(attr))
-            f = interp1d(x, b)
-            rgb.append(f(attr))
-            rgb = np.dstack(rgb)
-
-            if uxl is None and uil is None:
-                try:
-                    uxl = loadmat('seglines.mat')['uxl'].flatten()
-                    uil = loadmat('seglines.mat')['uil'].flatten()
-                except:
-                    uxl = [0, field_dim[0]]
-                    uil = [0, field_dim[1]]
-
-            extent = (uxl[0], uxl[-1], uil[-1], uil[0])
-            plt.figure()
-            plt.imshow(rgb, extent=extent)
-            if contours is not None and uil_c is not None and uxl_c is not None:
-                plt.contour(uxl_c, uil_c, contours[::-1, :], levels=1, colors='black')
-                plt.xlim(uxl[0], uxl[-1])
-                plt.ylim(uil[-1], uil[0])
-                plt.xlabel('Easting (km)')
-                plt.ylabel('Northing (km)')
-            plt.title('Coverage - not scaled by Importance - epsilon=' + str(nl))
-            filename = self.folder + 'coverage_vint_' + str(vint)
-            plt.savefig(filename)
-            os.system('convert ' + filename + '.png' + ' -trim ' + filename + '.png')
-
-            plt.figure()
-            rgb_scaled = np.uint8(rgb * 255)
-            hls = cv2.cvtColor(rgb_scaled, cv2.COLOR_RGB2HLS)
-            hls = hls / np.array([180, 255, 255])
-            hls[:, :, 1] = hls[:, :, 1] / (np.abs(sat - nl) / (1 - nl) * 1.5)
-            hls[:, :, 1] = np.minimum(hls[:, :, 1], 1.0)
-            hls = np.uint8(hls * np.array([180, 255, 255]))
-            rgb_scaled = cv2.cvtColor(hls, cv2.COLOR_HLS2RGB)
-            rgb = rgb_scaled / 255
-            plt.imshow(rgb, extent=extent)
-            if contours is not None and uil_c is not None and uxl_c is not None:
-                plt.contour(uxl_c, uil_c, contours[::-1, :], levels=1, colors='black',  extent=extent)
-                plt.xlim(uxl[0], uxl[-1])
-                plt.ylim(uil[-1], uil[0])
-                plt.xlabel('Easting (km)')
-                plt.ylabel('Northing (km)')
-            plt.title('Coverage - scaled by Importance - epsilon=' + str(nl))
-            filename = self.folder + 'coverage_importance_vint_' + str(vint)
-            plt.savefig(filename)
-            os.system('convert ' + filename + '.png' + ' -trim ' + filename + '.png')
-            plt.close()
-
-            plt.figure()
-            plt.imshow(sat[::-1,:], extent=extent)
-            if contours is not None and uil_c is not None and uxl_c is not None:
-                plt.contour(uxl_c, uil_c, contours[::-1, :], levels=1, colors='black', extent=extent)
-                plt.xlim(uxl[0], uxl[-1])
-                plt.ylim(uil[-1], uil[0])
-                plt.xlabel('Easting (km)')
-                plt.ylabel('Northing (km)')
-            plt.title('Importance - epsilon=' + str(nl))
-            filename = self.folder + 'importance_vint_' + str(vint)
-            plt.savefig(filename)
-            os.system('convert ' + filename + '.png' + ' -trim ' + filename + '.png')
-
-            if line:
-                _plot_coverage_1D(line, field_dim)
+            plt.title(f"1D coverage plot {'' if scaled else 'not '}scaled by Importance")
+            self._save_figure(f"{name}_vint_{vint}")
 
+    # ------------------------------------------------------------------
+    # Kalman gain
+    # ------------------------------------------------------------------
     def calc_kg(self, options=None):
+        """Rank the ES-style Kalman gain each data type would apply to each parameter.
+
+        For every data type, the gain of the ensemble mean is computed in the
+        subspace of the forecast anomalies with the scheme's damping
+        parameter (the ES/LM-EnRML form), per parameter. The largest gains by
+        maximum and by mean are logged, and optionally plotted or written to
+        the grid through the simulator.
+
+        Parameters
+        ----------
+        options : dict, optional
+            ``num_store`` (10): how many gains to keep in the ranked lists.
+            ``unique_time`` (False): one gain per report point instead of one
+            per data type over all its report points.
+            ``plot_all_kg`` (False): plot or write every field gain, not just
+            the ranked ones.
+            ``only_log`` (True): log only; no plots or grid files.
+            ``auto_ada_loc`` (True): apply the scheme's auto-adaptive
+            localization, when it has one, to field parameters.
+            ``write_to_resinsight`` (False): pass a time index to the grid writer.
         """
-        Check/write individual gain for parameters.
-        Note form ES gain with an identity Cd... This can be improved
-
-        Visualization of the many of these parameters is problem-specific. In reservoir simulation cases, it is necessary
-        to write this to the simulation grid. While for other applications, one might want other visualization. Hence,
-        the method also depends on a simulator specific writer.
-
-        Input:
-        options: Settings for the kalman gain computations
-            - num_store: number of elements to store (default 10)
-            - unique_time: calculate for each time instance (default False)
-            - plot_all_kg: plot all the kalman gains for the field parameters, if not plot the num_store (default False)
-            - only_log: only write to logger; no plotting (default True)
-            - auto_ada_loc: use localization in computations (default True)
-            - write_to_resinsight: pipe results to ResInsight (default False)
-              (Note: this requires that ResInsight is open on the computer)
-
-        Copyright (c) 2019-2022 NORCE, All Rights Reserved. 4DSEIS
-        """
+        opts = {"num_store": 10, "unique_time": False, "plot_all_kg": False, "only_log": True,
+                "auto_ada_loc": True, "write_to_resinsight": False, **(options or {})}
+        self._require("prior_info", "lam", "state")
+        localize = opts["auto_ada_loc"] and self.localization is not None
+        ranked = {"mean": [], "max": []}
 
-        # Stuff which needs to be defined in the initialization
-        # number of elements to store
-        if options is not None and 'num_store' in options:
-            num_store = options['num_store']
-        else:
-            num_store = 10
-        # calculate for each time instance
-        if options is not None and 'unique_time' in options:
-            unique_time = options['unique_time']
-        else:
-            unique_time = False
-        # plot all the kalman gains for the field parameters, if not plot the num_store
-        if options is not None and 'plot_all_kg' in options:
-            plot_all_kg = options['plot_all_kg']
-        else:
-            plot_all_kg = False
-        # only write to logger; no plotting
-        if options is not None and 'only_log' in options:
-            only_log = options['only_log']
-        else:
-            only_log = True
-        # use localization in computations
-        if 'localization' not in self.keys:
-            auto_ada_loc = False
-        elif options is not None and 'auto_ada_loc' in options:
-            auto_ada_loc = options['auto_ada_loc']
-        else:
-            auto_ada_loc = True
-        # write to resinsight
-        if options is not None and 'write_to_resinsight' in options:
-            write_to_resinsight = options['write_to_resinsight']
-        else:
-            write_to_resinsight = False
-
-        # check that we have prior info and sim class
-        if self.prior_info is None:
-            raise NameError('prior_info must be defined')
-        if self.lam is None:
-            raise NameError('lam must be defined')
-        if self.state is None:
-            raise NameError('state must be defined')
-
-        # initialize
-        max_kg_update = [0 for _ in range(num_store)]
-        max_mean_kg_update = [0 for _ in range(num_store)]
-        kg_max_max = [tuple() for _ in range(num_store)]
-        kg_max_mean = [tuple() for _ in range(num_store)]
-
-        # function to compute projection
-        def _calc_proj():
-            # do subspace inversion
-            u, s, v = np.linalg.svd(pert_pred, full_matrices=False)
-            # store 99 % of energy
-            ti = (np.cumsum(s) / sum(s)) <= 0.99
-            if sum(ti) == 0:
-                ti[0] = True
-            u, s, v = u[:, ti].copy(), s[ti].copy(), v[ti, :].copy()
-            _X2 = None
-            if sum(s):
-                ps_inv = np.diag([el_s ** (-1) for el_s in s])
-                X0 = (self.ne - 1) * np.dot(ps_inv, np.dot(u.T, (np.concatenate(t_var) *
-                                                                 np.dot(u, ps_inv).T).T))
-                Lamb, Z = np.linalg.eig(X0)
-                _X1 = np.dot(u, np.dot(ps_inv, Z))
-                _X2 = np.dot(np.dot(pert_pred.T, _X1), np.dot(np.linalg.inv((self.lam + 1) *
-                                                                            np.eye(Lamb.shape[0]) + Lamb), _X1.T))
-            return _X2
-
-        # function to compute kalman gain
-        def _calc_kalman_gain():
-            if num_cell > 1:
-                if actnum is None:
-                    idx = np.ones(self.state[param].shape[0], dtype=bool)
-                else:
-                    if num_cell == np.sum(actnum):
-                        idx = actnum  # 3d-parameter fields
-                    else:
-                        if self.prior_info:
-                            num_act_layer = int(self.prior_info[param]['nx'] * self.prior_info[param]['ny'])
-                            idx = actnum[:num_act_layer]  # this occurs for 2d-parameter fields
-                        else:
-                            raise NameError('prior_info must be defined')
-                _kg = np.zeros(idx.shape)
-                if auto_ada_loc and num_cell == np.sum(idx):
-                    proj_pred_data = np.dot(X2, delta_d)
-                    step = self.localization.auto_ada_loc(self.state[param], proj_pred_data,
-                                                          [param], **{'prior_info': self.prior_info})
-                    _kg[idx] = np.mean(step, axis=1)
-                else:
-                    _kg[idx] = np.dot(self.state[param], np.dot(X2, mean_residual)).flatten()
-            else:  # scalar
-                _kg = np.dot(np.dot(self.state[param], X2), mean_residual).flatten()
-
-            return _kg
-
-        # function to compute max values
-        def _populate_kg():
-            if actnum is None:
-                idx = np.ones(self.state[param].shape[0], dtype=bool)
-            else:
-                if num_cell == np.sum(actnum):
-                    idx = actnum  # 3d-parameter fields
-                else:
-                    if self.prior_info:
-                        num_act_layer = int(self.prior_info[param]['nx'] * self.prior_info[param]['ny'])
-                        idx = actnum[:num_act_layer]  # this occurs for 2d-parameter fields
-                    else:
-                        raise NameError('prior_info must be defined')
-            if len(np.where(abs(tmp[idx]).max() > np.array(max_kg_update))[0]):
-                indx = np.where(abs(tmp[idx]).max() > np.array(max_kg_update))[0][0]
-                max_kg_update.insert(indx, abs(tmp[idx]).max())
-                max_kg_update.pop()
-                kg_max_max.insert(indx, (typ, param, time))
-                kg_max_max.pop()
-            if len(np.where(abs(tmp[idx].mean()) > np.array(max_mean_kg_update))[0]):
-                indx = np.where(abs(tmp[idx].mean()) > np.array(max_mean_kg_update))[0][0]
-                max_mean_kg_update.insert(indx, abs(tmp[idx].mean()))
-                max_mean_kg_update.pop()
-                kg_max_mean.insert(indx, (typ, param, time))
-                kg_max_mean.pop()
-
-        # function to write to grid
-        def _plot_kg(_field=None):
-            if _field is None:  # assume scalar plot
-                plt.figure()
-                plt.plot(self.en_time[typ], kg_single)
-                plt.savefig(self.folder + f'Kg_{param}_{typ}')
-                plt.close()
-            else:
-                if self.sim is None:
-                    raise NameError('sim must be defined')
-                if actnum is None:
-                    idx = np.ones(self.state[param].shape[0], dtype=bool)
-                else:
-                    if num_cell != np.sum(actnum):
-                        return  # TODO: implement plotting of surfaces
-                    if os.path.exists('actnum_ref.npz'):
-                        idx = np.load('actnum_ref.npz')['actnum']
-                    else:
-                        idx = actnum
-                kg = np.ma.array(data=tmp, mask=~idx)
-                #dim = (self.prior_info[param]['nx'], self.prior_info[param]['ny'], self.prior_info[param]['nz'])
-                dim = next((item[1] for item in self.prior_info[param] if item[0] == 'grid'), None)
-                input_time = None
-                if write_to_resinsight:
-                    if time is None:
-                        input_time = len(self.l_prim)
-                    else:
-                        input_time = time
-                deblank_typ = typ.replace(' ', '_')
-                if hasattr(self.sim, 'write_to_grid'):
-                    self.sim.write_to_grid(kg, f'{_field}_{param}_{deblank_typ}_{time}', self.folder, dim, input_time)
-                elif hasattr(self.sim.flow, 'write_to_grid'):
-                    self.sim.flow.write_to_grid(kg, f'{_field}_{param}_{deblank_typ}_{time}', self.folder, dim,
-                                                input_time)
-                else:
-                    print('You need to implement a writer in you simulator class!! \n')
-
-        # -- Main function --
-        # need actnum
-        actnum = None
-        if os.path.exists('actnum.npz'):
-            actnum = np.load('actnum.npz')['actnum']
-        if unique_time:
-            en_fcst = self.en_fcst
-            en_ml_fcst = self.en_ml_fcst
-            en_obs = self.en_obs
-            en_time = self.en_time
-        else:  # second dict overwrites the first if the same key is present
-            en_fcst = {**self.en_fcst, **self.en_fcst_vec}
-            en_ml_fcst = {**self.en_ml_fcst, **self.en_ml_fcst_vec}
-            en_obs = {**self.en_obs, **self.en_obs_vec}
-            en_time = {**self.en_time, **self.en_time_vec}
-        for typ in self.data_types:  # ['sim2seis', 'WOPR A-11']:
-            if unique_time:
+        for typ in self.data_types:
+            if opts["unique_time"]:
                 for param in self.list_state:
-                    kg_single = []
-                    for ind, time in enumerate(en_time[typ]):
-                        t_var = np.array(max([el[typ] for el in self.datavar if el[typ] is not None]))[
-                            np.newaxis]  # to be able to concantenate
-                        if not len(t_var):  # [self.datavar[ind][typ]]
-                            t_var = [1]
-                        if hasattr(self, 'multilevel'):
-                            self.ML_state = copy.deepcopy(self.state)
-                            delattr(self, 'state')
-                            tmp_kg = []
-                            for l in range(self.tot_level):
-                                pert_pred = (en_ml_fcst[typ][l][ind, :] - en_ml_fcst[typ][l][ind, :].mean())[np.newaxis,
-                                            :]
-                                mean_residual = (en_obs[typ][ind] - en_ml_fcst[typ][l][ind, :]).mean()
-                                mean_residual = mean_residual[np.newaxis, np.newaxis].flatten()
-                                delta_d = (en_obs[typ][ind] - en_ml_fcst[typ][l][ind, :self.ne])[np.newaxis, :]
-                                X2 = _calc_proj()
-                                self.state = self.ML_state[l]
-                                num_cell = self.state[param].shape[0]
-                                if X2 is None:  # cases with full collapse in one level
-                                    tmp_kg.append(np.zeros(num_cell))
-                                else:
-                                    tmp_kg.append(_calc_kalman_gain())
-                            tmp = sum([self.cov_wgt[i] * el for i, el in enumerate(tmp_kg)]) / sum(self.cov_wgt)
-                            num_cell = self.state[param].shape[0]
-                            self.state = copy.deepcopy(self.ML_state)
-                            delattr(self, 'ML_state')
+                    scalar_gains = []
+                    for ind, time in enumerate(self.en_time[typ]):
+                        fcst = self.en_fcst[typ][ind][None, :]
+                        obs, var = self.en_obs[typ][ind], self.en_var[typ][ind]
+                        gain = self._gain(param, fcst, obs[:, None], var, localize)
+                        if gain is None:
+                            continue
+                        if gain.size == 1:
+                            scalar_gains.append(gain.item())
                         else:
-                            pert_pred = (en_fcst[typ][ind, :self.ne] - en_fcst[typ][ind, :self.ne].mean())[np.newaxis, :]
-                            mean_residual = (en_obs[typ][ind] - en_fcst[typ][ind, :self.ne]).mean()
-                            mean_residual = mean_residual[np.newaxis, np.newaxis].flatten()
-                            delta_d = (en_obs[typ][ind] - en_fcst[typ][ind, :self.ne])[np.newaxis, :]
-                            X2 = _calc_proj()
-                            num_cell = self.state[param].shape[0]
-                            tmp = _calc_kalman_gain()
-                            num_cell = self.state[param].shape[0]
-
-                        if num_cell == 1:
-                            kg_single.append(tmp)
-                        else:
-                            _populate_kg()
-                            if not only_log and plot_all_kg:
-                                _plot_kg('Kg')
-
-                    if len(kg_single):
-                        _plot_kg()
-
+                            self._rank(ranked, gain, (typ, param, time), opts["num_store"])
+                            if not opts["only_log"] and opts["plot_all_kg"]:
+                                self._write_field(gain, param, f"Kg_{param}_{typ}_{time}", time, opts)
+                    if scalar_gains:
+                        plt.figure()
+                        plt.plot(self.en_time[typ], scalar_gains)
+                        plt.title(f"Kalman gain of {param} from {typ}")
+                        self._save_figure(f"Kg_{param}_{typ.replace(' ', '_')}")
             else:
-                t_var = [self.datavar[ind][typ] for ind in en_time[typ] if self.datavar[ind][typ] is not None]
-                if len(t_var) == 0:
+                fcst, obs, var = self._lumped(typ)
+                if fcst is None:
                     continue
-                if hasattr(self, 'multilevel'):
-                    self.ML_state = copy.deepcopy(self.state)
-                    delattr(self, 'state')
-                    for param in self.list_state:
-                        tmp_kg = []
-                        for l in range(self.tot_level):
-                            if len(en_ml_fcst[typ][l].shape) == 2:
-                                pert_pred = en_ml_fcst[typ][l] - np.dot(en_ml_fcst[typ][l].mean(axis=1)[:, np.newaxis],
-                                                                        np.ones((1, self.ml_ne[l])))
-                            delta_d = en_obs[typ] - en_ml_fcst[typ][l][:,:self.ne]
-                            mean_residual = (en_obs[typ] - en_ml_fcst[typ][l]).mean(axis=1)
-                            X2 = _calc_proj()
-                            self.state = self.ML_state[l]
-                            num_cell = self.state[param].shape[0]
-                            if num_cell > 1:
-                                time = None
-                                if X2 is None:  # cases with full collapse in one level
-                                    tmp_kg.append(np.zeros(num_cell))
-                                else:
-                                    tmp_kg.append(_calc_kalman_gain())
-
-                        tmp = sum([self.cov_wgt[i] * el for i, el in enumerate(tmp_kg)]) / sum(self.cov_wgt)
-                        _populate_kg()
-                        if not only_log and plot_all_kg:
-                            _plot_kg('Kg-lump_vector')
-                    self.state = copy.deepcopy(self.ML_state)
-                    delattr(self, 'ML_state')
-                else:
-                    # combine time instances
-                    if len(en_fcst[typ].shape) == 2:
-                        pert_pred = en_fcst[typ][:, :self.ne] - np.dot(en_fcst[typ][:, :self.ne].mean(axis=1)[:, np.newaxis],
-                                                          np.ones((1, self.ne)))
-                    delta_d = en_obs[typ] - en_fcst[typ][:, :self.ne]
-                    mean_residual = (en_obs[typ] - en_fcst[typ][:, :self.ne]).mean(axis=1)
-                    X2 = _calc_proj()
-                    for param in self.list_state:
-                        num_cell = self.state[param].shape[0]
-                        if num_cell > 1:
-                            time = None
-                            tmp = _calc_kalman_gain()
-                            _populate_kg()
-                            if not only_log and plot_all_kg:
-                                _plot_kg('Kg-lump_vector')
-
-        # write top 10 values to the log
+                for param in self.list_state:
+                    if self.state[param].shape[0] == 1:
+                        continue
+                    gain = self._gain(param, fcst, obs, var, localize)
+                    if gain is None:
+                        continue
+                    self._rank(ranked, gain, (typ, param, None), opts["num_store"])
+                    if not opts["only_log"] and opts["plot_all_kg"]:
+                        self._write_field(gain, param, f"Kg-lump_{param}_{typ}", None, opts)
+
         newline = "\n"
-        self.logger.info('Calculations complete. 10 largest Kg mean values are:' + newline
-                         + f'{newline.join(f"{el}" for el in kg_max_mean if el)}')
-        self.logger.info('Calculations complete. 10 largest Kg max values are:' + newline
-                         + f'{newline.join(f"{el}" for el in kg_max_max if el)}')
-        if not only_log and not plot_all_kg:
-            # need to form and plot/write the gains from kg_max_mean and kg_max_max
-            # start with kg_max_mean
-            for el_ind, el in enumerate(itertools.chain(kg_max_mean, kg_max_max)):
-                # add filter if there are not 10 values
-                if len(el):
-                    # test if we have some time-dependece
-                    if el[2] is not None:
-                        typ = el[0]
-                        param = el[1]
-                        time = el[2]
-                        time_str = '-' + str(time)
-                        ind = en_time[typ].index(time)
-                        pert_pred = (en_fcst[typ][ind, :] - en_fcst[typ][ind, :].mean())[np.newaxis, :]
-                        mean_residual = (en_obs[typ][ind] - en_fcst[typ][ind, :]).mean()[np.newaxis, np.newaxis]
-                        t_var = [self.datavar[ind][typ]]
-                    else:
-                        typ = el[0]
-                        param = el[1]
-                        time = len(self.l_prim)
-                        time_str = '-'
-                        pert_pred = en_fcst[typ][:, :self.ne] - np.dot(en_fcst[typ][:, :self.ne].mean(axis=1)[:, np.newaxis],
-                                                          np.ones((1, self.ne)))
-                        mean_residual = (en_obs[typ] - en_fcst[typ]).mean(axis=1)
-                        t_var = [self.datavar[ind][typ] for ind in en_time[typ] if self.datavar[ind][typ] is not None]
-                    X2 = _calc_proj()
-                    delta_d = en_obs[typ] - en_fcst[typ][:, :self.ne]
-                    num_cell = self.state[param].shape[0]
-                    tmp = _calc_kalman_gain()
-                    if el_ind < len(kg_max_mean):
-                        _plot_kg('Kg-mean' + time_str)
-                    else:
-                        _plot_kg('Kg-max' + time_str)
+        for kind in ("mean", "max"):
+            entries = newline.join(f"{key}: {value:.4g}" for value, key in ranked[kind])
+            self.logger.info(f"Calculations complete. {len(ranked[kind])} largest Kg {kind} values are:{newline}{entries}")
 
-    def calc_mahalanobis(self, combi_list=(1, None)):
+        if not opts["only_log"] and not opts["plot_all_kg"]:
+            for kind in ("mean", "max"):
+                for _, (typ, param, time) in ranked[kind]:
+                    if time is None:
+                        fcst, obs, var = self._lumped(typ)
+                    else:
+                        ind = self.en_time[typ].index(time)
+                        fcst = self.en_fcst[typ][ind][None, :]
+                        obs, var = self.en_obs[typ][ind][:, None], self.en_var[typ][ind]
+                    gain = self._gain(param, fcst, obs, var, localize)
+                    if gain is not None:
+                        suffix = "" if time is None else f"-{time}"
+                        self._write_field(gain, param, f"Kg-{kind}{suffix}_{param}_{typ}", time, opts)
+
+    def _projection(self, pert, var):
+        """The (ne, nd) operator taking a data residual to ensemble weights.
+
+        Subspace form of ``C_md (C_dd + (1 + lam) C_d)^-1``: a truncated SVD
+        of the forecast anomalies, then an eigendecomposition of the data
+        covariance projected onto it. ``None`` if the ensemble has collapsed.
         """
-        Calculate the mahalanobis distance as described in "Oliver, D. S. (2020). Diagnosing reservoir model deficiency
-        for model improvement. Journal of Petroleum Science and Engineering, 193(February).
-        https://doi.org/10.1016/j.petrol.2020.107367"
-
-        Input:
-        combi_list: list of levels and possible combination of datatypes. The list must be given as a tuple with pairs:
-            level int: defines which level. default = 1
-            combi_typ: defines how data are combined: Default is no combine.
+        U, S, _ = at.truncSVD(pert, energy=0.99)
+        if S.size == 0 or not np.any(S):
+            return None
+        Sinv = 1.0 / S
+        X0 = (self.ne - 1) * ((Sinv[:, None] * U.T) @ (var[:, None] * U)) * Sinv[None, :]
+        Lamb, Z = np.linalg.eigh(X0)
+        X1 = (U * Sinv[None, :]) @ Z                                   # (nd, nr)
+        return (pert.T @ X1) / ((self.lam + 1) + Lamb)[None, :] @ X1.T  # (ne, nd)
+
+    def _gain(self, param, fcst, obs, var, localize):
+        """Gain of the ensemble mean of ``param`` from data with forecast ``fcst`` (nd, ne)."""
+        ne = min(self.ne, fcst.shape[1])
+        fcst = fcst[:, :ne]
+        pert = fcst - fcst.mean(axis=1, keepdims=True)
+        X2 = self._projection(pert, np.asarray(var, dtype=float).ravel())
+        if X2 is None:
+            return None
+        residual = obs - fcst                                          # (nd, ne)
+        state = self.state[param][:, :ne]
+        if localize and state.shape[0] > 1:
+            anomalies = state - state.mean(axis=1, keepdims=True)
+            projected = X2 @ residual                                  # (ne, ne)
+            taper = self.localization(X=anomalies, Y=projected, parameters=[param],
+                                      prior_info=self.prior_info)
+            return ((taper * anomalies) @ projected).mean(axis=1)
+        return state @ (X2 @ residual.mean(axis=1))
+
+    @staticmethod
+    def _rank(ranked, gain, key, keep):
+        for kind, value in (("max", float(np.abs(gain).max())), ("mean", float(abs(gain.mean())))):
+            ranked[kind].append((value, key))
+            ranked[kind].sort(key=lambda item: item[0], reverse=True)
+            del ranked[kind][keep:]
+
+    def _write_field(self, values, param, name, time, opts):
+        """Write a per-cell field to the grid through the simulator, if it can."""
+        writer = getattr(self.sim, "write_to_grid", None) or getattr(getattr(self.sim, "flow", None), "write_to_grid", None)
+        if writer is None:
+            self.logger.info(f"QAQC: no grid writer on the simulator; {name} not written")
+            return
+        info = self.prior_info[param]
+        dim = (info["nx"], info["ny"], info["nz"])
+        if self.actnum is not None and self.actnum.sum() == values.size:
+            data = np.zeros(self.actnum.shape)
+            data[self.actnum] = values
+            field = np.ma.array(data=data, mask=~self.actnum)
+        elif self.actnum is None:
+            field = np.ma.array(data=values, mask=np.zeros(values.shape, dtype=bool))
+        else:
+            return  # a surface parameter on a 3-D grid; no writer for that yet
+        input_time = (len(self.l_prim) if time is None else time) if opts.get("write_to_resinsight") else None
+        writer(field, name.replace(" ", "_"), str(self.folder), dim, input_time)
 
-        Copyright (c) 2019-2022 NORCE, All Rights Reserved. 4DSEIS
+    # ------------------------------------------------------------------
+    # Mahalanobis distance
+    # ------------------------------------------------------------------
+    def calc_mahalanobis(self, combi_list=(1, None)):
+        """Rank the Mahalanobis distance between observations and the perturbed forecast.
+
+        After Oliver (2020). The forecast is perturbed with the observation
+        error (a fixed seed, so repeated calls agree), then each observation
+        is scored against it alone (level 1), in pairs (2) or triples (3).
+        The largest scores are logged; level 1 also draws cross-plots of the
+        worst pairs.
+
+        Parameters
+        ----------
+        combi_list : tuple
+            Pairs ``(level, combine)``. ``combine`` is ``None`` to score each
+            observation, or a string containing ``'time'`` or ``'vector'`` to
+            first project each data type's series onto its leading principal
+            component and score the data types.
         """
-
+        self._require("pred_data")
+        rng = np.random.default_rng(50)
         for combo in range(0, len(combi_list), 2):
             level = combi_list[combo]
-            if len(combi_list) > combo:
-                combi_type = combi_list[combo + 1]
+            combine = combi_list[combo + 1] if combo + 1 < len(combi_list) else None
+            self.logger.info(f"Starting level {level} calculations of Mahalanobis distance")
+
+            if combine is None:
+                types = [typ for typ in self.data_types if self.en_fcst.get(typ) is not None and self.en_fcst[typ].size]
+                if not types:
+                    return
+                fcst = np.concatenate([self.en_fcst[typ] for typ in types], axis=0)
+                obs = np.concatenate([self.en_obs[typ] for typ in types], axis=0)
+                var = np.concatenate([self.en_var[typ] for typ in types], axis=0)
+                labels = [(typ, pos) for typ in types for pos in self.en_time[typ]]
+                fcst_pert = fcst + np.sqrt(var) * rng.standard_normal(fcst.shape)
+            elif "time" in combine or "vector" in combine:
+                labels, rows, obs_rows = [], [], []
+                for typ in self.data_types:
+                    series = self.en_fcst.get(typ)
+                    if series is None or not series.size:
+                        continue
+                    pert = series + np.sqrt(self.en_var[typ]) * rng.standard_normal(series.shape)
+                    _, _, vt = np.linalg.svd((pert - pert.mean(axis=1, keepdims=True)).T, full_matrices=False)
+                    leading = vt[:1, :]                                  # (1, n_t)
+                    rows.append((leading @ pert).ravel())
+                    obs_rows.append((leading @ self.en_obs[typ]).ravel())
+                    labels.append(typ)
+                if not rows:
+                    return
+                fcst_pert, obs = np.array(rows), np.array(obs_rows)
             else:
-                combi_type = None
-
-            self.logger.info(f'Starting level {level} calculations of Mahalanobis distance')
-
-            # start by generating correct vectors and fixind the seed
-            np.random.seed(50)
-            en_fcst_pert = []
-            filt_data = []
-            if combi_type is None:  # look at all data individually
-                en_fcst = np.concatenate([self.en_fcst[typ] for typ in self.data_types if self.en_fcst[typ].size],
-                                         axis=0)
-                filt_data = [(typ, ind) for typ in self.data_types for ind in self.l_prim
-                             if self.obs_data[ind][typ] is not None and sum(np.isnan(self.obs_data[ind][typ])) == 0
-                             and self.obs_data[ind][typ].shape == (1,)]
-                en_obs = np.concatenate([self.en_obs[typ] for typ in self.data_types if self.en_obs[typ].size], axis=0)
-                en_var = np.array([self.datavar[ind][typ].flatten() for typ in self.data_types for ind in self.l_prim
-                                   if
-                                   self.obs_data[ind][typ] is not None and sum(np.isnan(self.obs_data[ind][typ])) == 0
-                                   and self.obs_data[ind][typ].shape == (1,)])
-
-                en_fcst_pert = en_fcst + np.sqrt(en_var[:, 0])[:, np.newaxis] * \
-                               np.random.randn(en_fcst.shape[0], en_fcst.shape[1])
-
-            else:  # some data should be defined as blocks. To get the correct measure we project the data onto the subspace
-                # spanned by the first principal component. The level 1, 2 and 3. Difference is then calculated in
-                # similar fashion as for the full data-space. have simple rules for generating combinations. All data are
-                # aquired at some time, at some position, and there might be multiple data types at the same time and
-                # position.
-                en_obs = []
-                if 'time' in combi_type or 'vector' in combi_type:
-                    tmp_fcst = []
-                    for typ in self.data_types:
-                        tmp_fcst.append([self.en_fcst[typ][ind, :self.ne][np.newaxis, :self.ne] for ind in self.l_prim
-                                         if self.obs_data[ind][typ] is not None and sum(
-                                np.isnan(self.obs_data[ind][typ])) == 0])
-                    filt_fcst = [x for x in tmp_fcst if len(x)]  # remove all empty lists
-                    filt_data = [list(self.data_types)[i] for i, x in enumerate(tmp_fcst) if len(x)]
-                    en_fcst_pert = []
-                    for i, dat in enumerate(filt_data):
-                        tmp_enfcst = np.concatenate(filt_fcst[i], axis=0)
-                        tmp_var = np.concatenate([self.datavar[ind][dat].flatten() for ind in self.l_prim
-                                                  if self.obs_data[ind][dat] is not None and sum(
-                                np.isnan(self.obs_data[ind][dat])) == 0])
-                        tmp_var = np.expand_dims(tmp_var, 1)
-                        tmp_fcst_pert = tmp_enfcst + np.sqrt(tmp_var[:, 0])[:, np.newaxis] * \
-                                        np.random.randn(tmp_enfcst.shape[0], tmp_enfcst.shape[1])
-                        X = tmp_fcst_pert - tmp_fcst_pert.mean(axis=1)[:, np.newaxis]
-                        u, s, v = np.linalg.svd(X.T, full_matrices=False)
-                        v_sing = v[:1, :]
-                        en_fcst_pert.append(np.dot(v_sing, tmp_fcst_pert).flatten())
-                        tmp_obs = np.concatenate([self.obs_data[ind][dat] for ind in self.l_prim if
-                                                  self.obs_data[ind][dat] is not None and
-                                                  sum(np.isnan(self.obs_data[ind][dat])) == 0])
-                        tmp_obs = np.expand_dims(tmp_obs, 1)
-                        en_obs.append(np.dot(v_sing, tmp_obs).flatten())
-
-                    en_fcst_pert = np.array(en_fcst_pert)
-                    en_obs = np.array(en_obs)
+                self.logger.info(f"Unknown combination {combine!r}; skipping")
+                continue
 
             if level == 1:
-                nD = len(en_fcst_pert)
-                scores = np.zeros(nD)
-                for i in range(nD):
-                    mean_fcst = np.mean(en_fcst_pert[i, :])
-                    ivar = 1. / np.var(en_fcst_pert[i, :])
-                    scores[i] = ivar * (en_obs[i, :] - mean_fcst) ** 2
-
-                num_scores = min(10, len(scores.flatten()))  # if there is less than 10 data
-                unsort_top10 = np.argpartition(scores.flatten(), -num_scores)[
-                               -num_scores:]  # this is fast but not sorted. Get 10 highest values
-                top10 = unsort_top10[np.argsort(scores[unsort_top10])[::-1]]  # sort in descending order
-                newline = "\n"
-                if combi_type is None:
-                    self.logger.info(f'Calculations complete. {num_scores} largest values are:' + newline
-                                     + f'{newline.join(f" data type: {filt_data[ind][0]}    time: {filt_data[ind][1]}    Score: {scores[ind]}" for ind in top10)}')
-
-                    # make cross-plot
-                    i1 = [top10[3], top10[3]]
-                    i2 = [top10[2], top10[0]]
-                    for ind in range(len(i1)):
-                        plt.figure()
-                        plt.plot(en_fcst_pert[i1[ind], :], en_fcst_pert[i2[ind], :], '.b')
-                        plt.plot(en_obs[i1[ind], :], en_obs[i2[ind], :], '.r')
-                        plt.xlabel(str(filt_data[i1[ind]][0]) + ', time ' + str(filt_data[i1[ind]][1]))
-                        plt.ylabel(str(filt_data[i2[ind]][0]) + ', time ' + str(filt_data[i2[ind]][1]))
-                        plt.savefig(
-                            self.folder + 'crossplot_' + filt_data[i1[ind]][0].replace(' ', '_') + '_t' +
-                            str(filt_data[i1[ind]][1]) + '-' + filt_data[i2[ind]][0].replace(
-                                ' ', '_') + '_t' + str(filt_data[i2[ind]][1]))
-                        plt.close()
-                else:
-                    self.logger.info(f'Calculations complete. {num_scores} largest values are:' + newline
-                                     + f'{newline.join(f" data type: {filt_data[ind]}    Score: {scores[ind]}" for ind in top10)}')
-
-                    # make cross-plot
-                    i1 = [top10[0], top10[1]]
-                    i2 = [top10[1], top10[3]]
-                    for ind in range(len(i1)):
-                        plt.figure()
-                        plt.plot(en_fcst_pert[i1[ind], :], en_fcst_pert[i2[ind], :], '.b')
-                        plt.plot(en_obs[i1[ind], :], en_obs[i2[ind], :], '.r')
-                        plt.xlabel(str(filt_data[i1[ind]]) + ' (proj)')
-                        plt.ylabel(str(filt_data[i2[ind]]) + ' (proj)')
-                        plt.savefig(
-                            self.folder + 'crossplot_' + str(filt_data[i1[ind]]).replace(' ', '_') + '-' +
-                            str(filt_data[i2[ind]]).replace(' ', '_'))
-                        plt.close()
-
-            elif level == 2:
-                nD = len(en_fcst_pert)
-                scores = np.zeros((nD, nD))
-                for i in range(nD):
-                    for j in range(nD):
-                        if i != j:
-                            ne = en_fcst_pert.shape[1]
-                            z = np.concatenate((en_obs[i, :], en_obs[j, :]), axis=0)
-                            X = np.vstack((en_fcst_pert[i, :], en_fcst_pert[j, :]))
-                            mean_fcst = np.mean(X, axis=1)
-                            diff_fcst = X - mean_fcst[:, np.newaxis]
-                            C_fcst = np.dot(diff_fcst, diff_fcst.T) / (ne - 1)
-                            inv_C = np.linalg.inv(C_fcst)
-                            res = z - mean_fcst
-                            term1 = np.dot(res, inv_C)
-                            scores[i, j] = np.dot(term1, res) / 2
-                        else:
-                            mean_fcst = np.mean(en_fcst_pert[i, :])
-                            ivar = 1. / np.var(en_fcst_pert[i, :])
-                            scores[i, j] = ivar * (en_obs[i, :] - mean_fcst) ** 2
-
-                num_scores = min(20, len(scores.flatten()))
-                unsort_top10 = np.argpartition(scores.flatten(), -num_scores)[
-                               -num_scores:]  # this is fast but not sorted. Get 20 highest values, select every other.
-                top10 = unsort_top10[np.argsort(scores.flatten()[unsort_top10])[
-                                     ::-2]]  # sort in descending order. Will be duplicates select every other.
-                newline = "\n"
-                if combi_type is None:
-                    self.logger.info(f'Calculations complete. {int(num_scores / 2)} largest values are:' + newline
-                                     + f'{newline.join(f" data type 1: {filt_data[np.where(scores == scores.flatten()[ind])[0][0]][0]}    time 1: {filt_data[np.where(scores == scores.flatten()[ind])[0][0]][1]} data type 2: {filt_data[np.where(scores == scores.flatten()[ind])[1][0]][0]}    time 2: {filt_data[np.where(scores == scores.flatten()[ind])[1][0]][1]}    Score: {scores.flatten()[ind]}" for ind in top10)}')
-
-                else:
-                    self.logger.info(f'Calculations complete. {int(num_scores / 2)} largest values are:' + newline
-                                     + f'{newline.join(f" data type 1: {filt_data[np.where(scores == scores.flatten()[ind])[0][0]]}    data type 2: {filt_data[np.where(scores == scores.flatten()[ind])[1][0]]}   Score: {scores.flatten()[ind]}" for ind in top10)}')
-
-            elif level == 3:
-                nD = len(en_fcst_pert)
-                scores = np.zeros((nD, nD, nD))
-                for i in range(nD):
-                    for j in range(nD):
-                        for k in range(nD):
-                            if i != j != k:
-                                ne = en_fcst_pert.shape[1]
-                                z = np.concatenate((self.en_obs[i, :], self.en_obs[j, :], self.en_obs[k, :]), axis=0)
-                                X = np.vstack((en_fcst_pert[i, :], en_fcst_pert[j, :], en_fcst_pert[k, :]))
-                                mean_fcst = np.mean(X, axis=1)
-                                diff_fcst = X - mean_fcst[:, np.newaxis]
-                                C_fcst = np.dot(diff_fcst, diff_fcst.T) / (ne - 1)
-                                inv_C = np.linalg.inv(C_fcst)
-                                res = z - mean_fcst
-                                term1 = np.dot(res, inv_C)
-                                scores[i, j] = np.dot(term1, res) / 2
-                            else:
-                                mean_fcst = np.mean(en_fcst_pert[i, :])
-                                ivar = 1. / np.var(en_fcst_pert[i, :])
-                                scores[i, j] = ivar * (self.en_obs[i, :] - mean_fcst) ** 2
+                scores = (obs[:, 0] - fcst_pert.mean(axis=1)) ** 2 / fcst_pert.var(axis=1)
+                top = np.argsort(scores)[::-1][:10]
+                self.logger.info("Calculations complete. Largest values are:\n" + "\n".join(
+                    f" data: {labels[i]}    Score: {scores[i]:.4g}" for i in top))
+                self._crossplots(top, fcst_pert, obs, labels, combine)
+            elif level in (2, 3):
+                self._joint_scores(level, fcst_pert, obs, labels)
             else:
-                print('Current level is not implemented')
-
+                self.logger.info(f"Mahalanobis level {level} is not implemented")
+
+    def _joint_scores(self, level, fcst_pert, obs, labels):
+        """Mahalanobis distance of every pair (level 2) or triple (3) of data."""
+        n = len(fcst_pert)
+        ne = fcst_pert.shape[1]
+        scores = {}
+        combos = ([(i, j) for i in range(n) for j in range(i + 1, n)] if level == 2
+                  else [(i, j, k) for i in range(n) for j in range(i + 1, n) for k in range(j + 1, n)])
+        for idx in combos:
+            X = fcst_pert[list(idx)]
+            mean = X.mean(axis=1)
+            diff = X - mean[:, None]
+            cov = diff @ diff.T / (ne - 1)
+            res = obs[list(idx), 0] - mean
+            try:
+                scores[idx] = float(res @ np.linalg.solve(cov, res)) / 2
+            except np.linalg.LinAlgError:
+                continue
+        top = sorted(scores.items(), key=lambda item: item[1], reverse=True)[:10]
+        self.logger.info(f"Calculations complete. Largest level-{level} values are:\n" + "\n".join(
+            f" data: {tuple(labels[i] for i in idx)}    Score: {score:.4g}" for idx, score in top))
+
+    def _crossplots(self, top, fcst_pert, obs, labels, combine):
+        if len(top) < 2:
+            return
+        pairs = [(top[0], top[1])] if len(top) < 4 else [(top[3], top[2]), (top[3], top[0])]
+        for a, b in pairs:
+            plt.figure()
+            plt.plot(fcst_pert[a], fcst_pert[b], ".b")
+            plt.plot(obs[a], obs[b], ".r")
+            plt.xlabel(str(labels[a]) + (" (proj)" if combine else ""))
+            plt.ylabel(str(labels[b]) + (" (proj)" if combine else ""))
+            self._save_figure("crossplot_" + f"{labels[a]}-{labels[b]}".replace(" ", "_").replace("'", "")
+                              .replace("(", "").replace(")", "").replace(",", "_t"))
+
+    # ------------------------------------------------------------------
+    # Update statistics
+    # ------------------------------------------------------------------
     def calc_da_stat(self, options=None):
-        """
-        Calculate statistics for the updated parameters. The persentage of parameters that have updates larger than one,
-        two and three standard deviations (calculated from the initial ensemble) are flagged.
+        """Log how far each parameter group moved from the prior.
 
-        Input:
-        options: Settings for statistics
-            - write_to_file: write results to .grdecl file (default False)
+        Per group: the mean prior and current standard deviation, and the
+        percentage of parameters whose mean moved by more than one, two and
+        three prior standard deviations.
 
-        Copyright (c) 2019-2022 NORCE, All Rights Reserved. 4DSEIS
+        Parameters
+        ----------
+        options : dict, optional
+            ``write_to_file`` (False): also write a field of these flags
+            (-3..3) to the grid through the simulator.
         """
-
-        if options is not None and 'write_to_file' in options:
-            write_to_file = options['write_to_file']
-        else:
-            write_to_file = False
-
-        actnum = None
-        if os.path.exists('actnum.npz'):
-            actnum = np.load('actnum.npz')['actnum']
-
-        newline = '\n'
-        log_str = 'Statistics for updated parameters. Initial and final std, and percent larger than 1,2,3 initial std:'
+        self._require("state")
+        write = bool(options and options.get("write_to_file"))
+        lines = ["Statistics for updated parameters. Initial and final std, and percent larger than 1,2,3 initial std:"]
         for key in self.list_state:
-            if hasattr(self, 'multilevel'):
-                tot_init_state = np.concatenate([el[key] for el in self.ini_state], axis=1)
-                tot_state = np.concatenate([el[key] for el in self.state], axis=1)
-                initial_mean = np.mean(tot_init_state, axis=1)
-                final_mean = np.mean(tot_state, axis=1)
-                S = np.std(tot_init_state, axis=1)
-                ES = np.append(np.mean(S), np.mean(np.std(tot_state, axis=1)))
-            else:
-                initial_mean = np.mean(self.ini_state[key], axis=1)
-                final_mean = np.mean(self.state[key], axis=1)
-                S = np.std(self.ini_state[key], axis=1)
-                ES = np.append(np.mean(S), np.mean(np.std(self.state[key], axis=1)))
-            M = final_mean - initial_mean
-            N = np.zeros(3)
-            N[0] = np.sum(np.abs(M) > S)
-            N[1] = np.sum(np.abs(M) > 2 * S)
-            N[2] = np.sum(np.abs(M) > 3 * S)
-            P = N * 100 / len(M)
-            log_str += newline + 'Group ' + key + ' ' + str(ES) + ', ' + str(P)
-
-            if write_to_file:
-                if actnum is None:
-                    if hasattr(self, 'multilevel'):
-                        idx = np.ones(self.state[0][key].shape[0], dtype=bool)
-                    else:
-                        idx = np.ones(self.state[key].shape[0], dtype=bool)
-                else:
-                    idx = actnum
-                if M.size == np.sum(idx) and M.size > 1:  # we have a grid parameter
-                    tmp = np.zeros(M.shape)
-                    tmp[M > S] = 1
-                    tmp[M > 2 * S] = 2
-                    tmp[M > 3 * S] = 3
-                    tmp[M < -S] = -1
-                    tmp[M < -2 * S] = -2
-                    tmp[M < -3 * S] = -3
-                    data = np.zeros(idx.shape)
-                    data[idx] = tmp
-                    field = np.ma.array(data=data, mask=~idx)
-                    dim = (self.prior_info[key]['nx'], self.prior_info[key]['ny'], self.prior_info[key]['nz'])
-                    #dim = next((item[1] for item in self.prior_info[key] if item[0] == 'grid'), None)
-                    input_time = None
-                    if hasattr(self.sim, 'write_to_grid'):
-                        self.sim.write_to_grid(field, f'da_stat_{key}', self.folder, dim, input_time)
-                    elif hasattr(self.sim.flow, 'write_to_grid'):
-                        self.sim.flow.write_to_grid(field, f'da_stat_{key}', self.folder, dim, input_time)
-                    else:
-                        print('You need to implement a writer in you simulator class!! \n')
-
-        self.logger.info(log_str)
+            initial, current = self.ini_state[key], self.state[key]
+            std0 = initial.std(axis=1)
+            moved = current.mean(axis=1) - initial.mean(axis=1)
+            stds = (float(std0.mean()), float(current.std(axis=1).mean()))
+            pct = tuple(float(100 * np.mean(np.abs(moved) > k * std0)) for k in (1, 2, 3))
+            lines.append(f"Group {key}: std {stds[0]:.4g} -> {stds[1]:.4g}; "
+                         f"{pct[0]:.1f}% / {pct[1]:.1f}% / {pct[2]:.1f}% beyond 1 / 2 / 3 std")
+            if write and moved.size > 1:
+                flags = np.zeros(moved.shape)
+                for k in (1, 2, 3):
+                    flags[moved > k * std0] = k
+                    flags[moved < -k * std0] = -k
+                self._write_field(flags, key, f"da_stat_{key}", None, {})
+        self.logger.info("\n".join(lines))
+
+    def _require(self, *names):
+        """Raise if any of the named inputs is still unset (``set()`` provides all but ``prior_info``)."""
+        missing = [name for name in names if getattr(self, name) is None]
+        if missing:
+            hint = "" if missing == ["prior_info"] else "; call set() first"
+            raise ValueError(f"QAQC needs {', '.join(missing)}{hint}")
diff --git a/src/pipt/misc_tools/wavelet_tools.py b/src/pipt/misc_tools/wavelet_tools.py
index ac206de8..318d25c3 100644
--- a/src/pipt/misc_tools/wavelet_tools.py
+++ b/src/pipt/misc_tools/wavelet_tools.py
@@ -5,12 +5,11 @@
 """
 import pywt
 import numpy as np
-import sys
 from copy import deepcopy
-import warnings
 
 
 class SparseRepresentation:
+    """Wavelet compression of one seismic vintage. Thresholding the observed vintage fixes the leading coefficients; later calls reduce any vintage to those."""
 
     # Initialize
     def __init__(self, options):
@@ -32,6 +31,7 @@ def __init__(self, options):
     # Function for image compression. If the function is called without threshold, then the leading indices must
     # be defined in the class. Typically, this is done by running the compression on true data with a given threshold.
     def compress(self, data, th_mult=None):
+        """Compress ``data`` (the masked grid, flattened). With ``th_mult`` the coefficients are thresholded and the leading indices (re)defined; without it the stored indices select them. Returns ``(compressed, wdec_rec)``."""
         if ('inactive_value' not in self.options) or (self.options['inactive_value'] is None):
             self.options['inactive_value'] = np.mean(data)
         signal = np.zeros(self.num_grid)
@@ -120,8 +120,7 @@ def compress(self, data, th_mult=None):
                         current_threshold = est_noise_level**2 / \
                             np.sqrt(np.abs(std_data**2 - est_noise_level**2))
                     else:
-                        print('Thresholding rule not implemented')
-                        sys.exit(1)
+                        raise ValueError(f"Thresholding rule {self.options['threshold_rule']!r} is not implemented")
                     current_threshold = th_mult * current_threshold
                     if level == 0:
                         self.threshold[level] = current_threshold
@@ -196,8 +195,7 @@ def compress(self, data, th_mult=None):
             compressed_data = np.append(self.ca_leading_coeff, self.cd_leading_coeff)
         else:
             if self.ca_leading_index is None or self.cd_leading_index is None:
-                print('Leading indices not defined')
-                sys.exit(1)
+                raise RuntimeError('Leading indices not defined: compress() must run before reconstruct()')
             compressed_data = np.append(
                 ca_in_vec[self.ca_leading_index], cd_in_vec[self.cd_leading_index])
 
@@ -220,14 +218,14 @@ def compress(self, data, th_mult=None):
 
     # Reconstruct the current compressed dataset.
     def reconstruct(self, wdec_rec):
+        """The masked, flattened vintage rebuilt from the retained wavelet coefficients."""
 
         if wdec_rec is None:
-            print('No signal to reconstruct')
-            sys.exit(1)
+            raise ValueError('No signal to reconstruct')
 
         # reconstruct from wavelet coefficients
         data_rec = pywt.waverecn(wdec_rec, self.options['wname'], 'symmetric')
-        data_rec = data_rec[tuple(slice(0, s) for s in self.options['dim'])] 
+        data_rec = data_rec[tuple(slice(0, s) for s in self.options['dim'])]
 
         data_rec = data_rec.flatten(order=self.options['order'])
         data_rec = data_rec[self.options['mask']]
diff --git a/src/pipt/pipt_init.py b/src/pipt/pipt_init.py
index da4ff3dc..ad5dddff 100644
--- a/src/pipt/pipt_init.py
+++ b/src/pipt/pipt_init.py
@@ -1,18 +1,64 @@
-"""Descriptive description."""
+"""Entry point for constructing an assimilation scheme from parsed config."""
 
-# External imports
-from fnmatch import filter  # to check if wildcard name is in list
-from importlib import import_module
+from pipt.update_schemes.registry import get_scheme
+
+__all__ = ["init_da"]
 
 
 def init_da(da_input, en_input, sim):
-    "initialize the ensemble object based on the DA inputs"
+    """Build the assimilation scheme object described by the config.
+
+    Parameters
+    ----------
+    da_input : dict
+        Parsed ``dataassim`` section. Must contain ``scheme`` (the algorithm
+        name) and ``analysis`` (the flavour).
+    en_input : dict
+        Parsed ``ensemble`` section.
+    sim : object
+        Forward simulator instance.
+
+    Returns
+    -------
+    object
+        Instantiated scheme.
+
+    Raises
+    ------
+    ValueError
+        If ``daalg`` is missing or malformed.
+    KeyError
+        If the requested scheme/analysis combination is not registered. The
+        message lists the valid options.
+    """
+    scheme = da_input.get("scheme")
+
+    if scheme is None:
+        if "daalg" in da_input:
+            raise ValueError(
+                "This config uses the legacy 'daalg' key. It has been replaced "
+                "by a single 'scheme' key naming the algorithm:\n\n"
+                "    daalg = ['esmda', 'esmda']   ->   scheme = 'esmda'\n\n"
+                "Run `pet migrate ` to convert the file in place "
+                "(the original is kept as .bak)."
+            )
+        raise ValueError(
+            "SCHEME is missing from the data-assimilation config. "
+            "It names the assimilation algorithm, e.g. scheme = 'esmda'."
+        )
 
-    assert len(
-        da_input['daalg']) == 2, f"Need to input assimilation type and update method, got {da_input['daalg']}"
+    if not isinstance(scheme, str):
+        raise ValueError(
+            f"SCHEME must be the algorithm name as a string, e.g. 'esmda'; "
+            f"got {scheme!r}."
+        )
 
-    da_import = getattr(import_module('pipt.update_schemes.' +
-                        da_input['daalg'][0]), f'{da_input["daalg"][1]}_{da_input["analysis"]}')
+    analysis = da_input.get("analysis")
+    if analysis is None:
+        raise ValueError(
+            f"ANALYSIS is missing from the data-assimilation config. "
+            f"It selects the analysis flavour for scheme '{scheme}'."
+        )
 
-    # Init. update scheme class, and get an object of that class
-    return da_import(da_input, en_input, sim)
+    scheme_cls = get_scheme(scheme, analysis)
+    return scheme_cls(da_input, en_input, sim)
diff --git a/src/pipt/update_schemes/__init__.py b/src/pipt/update_schemes/__init__.py
index a455772e..bb7e9beb 100644
--- a/src/pipt/update_schemes/__init__.py
+++ b/src/pipt/update_schemes/__init__.py
@@ -3,3 +3,10 @@
 # import os
 # home = os.path.expanduser("~") # os independent home
 # __path__.append(os.path.join(home,'4DSEIS_private/4DSEIS-packages/update_schemes'))
+from .core import *
+from .enkf import *
+from .enrml import *
+from .es import *
+from .esmda import *
+from .multilevel import *
+from . import analysis
diff --git a/src/pipt/update_schemes/analysis/__init__.py b/src/pipt/update_schemes/analysis/__init__.py
new file mode 100644
index 00000000..93f87a6d
--- /dev/null
+++ b/src/pipt/update_schemes/analysis/__init__.py
@@ -0,0 +1,57 @@
+"""Analysis-step analyses.
+
+An *analysis* computes the state update for one assimilation
+iteration. The flavours differ only in how the ensemble-approximated
+sensitivity is inverted; they share a calling convention and their
+linear-algebra helpers.
+
+The analysis is a *parameter* of a scheme, not part of its identity::
+
+    ESMDA(keys_da, keys_en, sim, analysis="subspace")
+
+Layout
+------
+``base``
+    :class:`AnalysisBase` -- the shared contract and helpers.
+``approx``, ``full``, ``subspace``, ``subspace2``
+    The four registered flavours.
+``hybrid``, ``margis``
+    Flavours consumed as mixins rather than through the registry: ``hybrid``
+    belongs to the multilevel scheme and ``margis`` is backed by a private
+    package when installed.
+``registry``
+    Name-to-class lookup, plus :func:`register_analysis` for out-of-tree
+    flavours.
+
+These previously lived in ``update_schemes.update_methods_ns`` while this
+package held only the base class, because the flavours were consumed as mixins
+and re-exporting them here would have formed an import cycle. Now that schemes
+hold an analysis rather than inheriting one, they live together.
+"""
+
+from .base import AnalysisBase, AnalysisResult
+from .approx import approx_update
+from .full import full_update
+from .hybrid import hybrid_update
+from .subspace import subspace_update
+from .subspace2 import subspace2_update
+from .registry import (
+    ANALYSES,
+    available_analyses,
+    get_analysis,
+    register_analysis,
+)
+
+__all__ = [
+    "AnalysisBase",
+    "AnalysisResult",
+    "approx_update",
+    "full_update",
+    "subspace_update",
+    "subspace2_update",
+    "hybrid_update",
+    "ANALYSES",
+    "available_analyses",
+    "get_analysis",
+    "register_analysis",
+]
diff --git a/src/pipt/update_schemes/analysis/approx.py b/src/pipt/update_schemes/analysis/approx.py
new file mode 100644
index 00000000..de5f1324
--- /dev/null
+++ b/src/pipt/update_schemes/analysis/approx.py
@@ -0,0 +1,139 @@
+"""EnRML (IES) without the prior increment term."""
+
+import numpy as np
+
+from pipt.update_schemes.analysis.base import AnalysisBase, AnalysisResult
+import pipt.misc_tools.analysis_tools as at
+
+
+class approx_update(AnalysisBase):
+    """
+    Approximate LM Update scheme as defined in "Chen, Y., & Oliver, D. S. (2013). Levenberg–Marquardt forms of the iterative ensemble
+    smoother for efficient history matching and uncertainty quantification. Computational Geosciences, 17(4), 689–703.
+    https://doi.org/10.1007/s10596-013-9351-5". Note that for a EnKF or ES update, or for update within GN scheme, lambda = 0.
+    """
+
+    def update(self, enX, enY, enE, **kwargs):
+        '''
+        Perform the approximate LM update.
+
+        Parameters:
+        ----------
+            enX : np.ndarray
+                State ensemble matrix (nx, ne)
+
+            enY : np.ndarray
+                Predicted data ensemble matrix (nd, ne)
+
+            enE : np.ndarray
+                Ensemble of perturbed observations (nd, ne)
+        '''
+        scheme = self.scheme
+        # The scheme protocol allows ``logger`` to be None (or absent on a
+        # test double), so only log when there is something to log to.
+        log = getattr(scheme, 'logger', None)
+        if log is not None:
+            log("[approx_update] Performing update....")
+
+        # Shapes
+        nx, ne = enX.shape
+        ny, _  = enY.shape
+
+        # Scaling factors and other attributes needed for the update. The
+        # fallbacks are built only when the scheme lacks the attribute:
+        # ``getattr(obj, name, default)`` evaluates ``default`` eagerly, which
+        # here would allocate an (ny, ny) identity and factorise it on every
+        # call, even though a real scheme always provides these.
+        cov = scheme.cov_data if hasattr(scheme, 'cov_data') else np.eye(ny)  # (ny, ny) or (ny,)
+        # State scaling: the prior standard deviation per state row. Anomalies
+        # are divided by it and the step multiplied back, so the update works
+        # in a scaled space whatever units the variables have.
+        scx = scheme.state_scaling if hasattr(scheme, 'state_scaling') else np.ones(nx)
+        scy = scheme.scale_data if hasattr(scheme, 'scale_data') else self.sqrtm(cov)
+        PI  = (scheme.proj if hasattr(scheme, 'proj')
+               else (np.eye(ne) - np.ones((ne, ne)) / ne) / np.sqrt(ne-1))
+        # PI shape: (ne, ne) such that A@PI = A - mean(A)/sqrt(ne-1) for any ensemble matrix A of shape (na, ne)
+
+        # Check for adjoint-based update
+        if kwargs.get('enAdj', None) is not None:
+            if log is not None:
+                log("[approx_update] Using adjoint-based update.")
+            Y = kwargs['enAdj'].mean(axis=-1) @ enX @ PI    # shape: (nd, ne)
+        else:
+            Y = enY @ PI                                    # shape: (nd, ne) --> Such that Cyy ≈ Y @ Y.T
+
+        # Anomaly matrices
+        X_anom = self.solve(scx, enX @ PI)                  # shape: (nx, ne) --> State anomalies: (X-mean(X))/sqrt(ne-1)
+        Y_anom = self.solve(scy, Y)                         # shape: (nd, ne) --> Predicted data anomalies: (Y-mean(Y))/sqrt(ne-1)
+        D_anom = self.solve(scy, enE - enY)                 # shape: (nd, ne) --> Innovation ensemble: data - predictions
+
+        # Truncated SVD on predicted data anomalies
+        Ur, Sr, VrT = at.truncSVD(Y_anom, energy=scheme.trunc_energy) # shape: (nd, nr), (nr,), (nr, ne)
+
+        # ===============================================
+        # Compute step
+        # ===============================================
+        X1 = Ur.T @ D_anom                                  # shape: (nr, ne) --> Projected innovation ensemble
+
+        if scheme.keys_da.get('emp_cov', False):
+            E_anom = self.solve(scy, enE @ PI)              # shape: (nd, ne)
+            invSr = (1/Sr)[:, None]                         # shape: (nr, 1)
+            X0 = invSr * (Ur.T @ E_anom)                    # shape: (nr, ne)
+            eigval, eigvec = np.linalg.eigh(X0 @ X0.T)      # shape: (nr,), (nr, nr); symmetric, so eigh
+            d = (scheme.lam + 1) * eigval + 1                 # shape: (nr, )
+            rhs = eigvec.T @ (invSr * X1)                   # shape: (nr, ne)
+            X2 = invSr * (eigvec @ self.solve(d, rhs))      # shape: (nr, ne)
+        else:
+            X2 = self.solve(1 + scheme.lam + Sr**2, X1)       # shape: (nr, ne)
+
+        # AUTO-ADAPTIVE LOCALIZATION
+        localization = scheme.localization
+        if localization.name == 'autoadaloc':
+            y_proj = localization.info.get('projection', 'rank-r')
+            assert y_proj in ['rank-r', 'ensemble'], "Projection method must be either 'rank-r' or 'ensemble'."
+
+            if y_proj == 'rank-r':
+                Y_anom_proj = Sr[:, None] * VrT             # shape: (nr, ne) --> Y_proj = U.T @ Y_anom
+                T_loc = localization(                       # shape: (nx, nr) --> nr < ne << ny (typically)
+                    X = scx[:, None]*X_anom,                # shape: (nx, ne)
+                    Y = Y_anom_proj
+                )
+                Cxy_loc = T_loc * (scx[:, None]*X_anom @ Y_anom_proj.T)
+                return AnalysisResult(step=Cxy_loc @ X2)    # shape: (nx, ne)
+
+            elif y_proj == 'ensemble':
+                Y_anom_proj = X2 @ D_anom                   # shape: (ne, ne)
+                T_loc = localization(                       # shape: (nx, ne)
+                    X = scx[:, None]*X_anom,                # shape: (nx, ne)
+                    Y = Y_anom_proj
+                )
+                step = (T_loc * scx[:, None]*X_anom) @ Y_anom_proj
+                return AnalysisResult(step=step)            # shape: (nx, ne)
+
+        # DISTANCE-BASED LOCALIZATION
+        elif localization.name == 'distance_loc':
+
+            # Gain-factor matrix X shape: (nr, nd)
+            if scheme.keys_da.get('emp_cov', False):
+                A = scx[:, None] * X_anom * np.sqrt(ne - 1)  # Back to physical units, undo 1/sqrt(ne-1); shape: (nx, ne)
+                X = (VrT.T @ eigvec) @ self.solve(d, eigvec.T @ (invSr * Ur.T))
+            else:
+                A = scx[:, None] * X_anom                   # shape: (nx, ne)
+                X = VrT.T @ (Sr[:, None] * self.solve(1 + scheme.lam + Sr**2, Ur.T))
+
+            T_loc = localization()                          # shape: (nx, nd) -- sparse localisation mask
+            K_loc = T_loc.multiply(A @ X)                   # shape: (nx, nd) -- elementwise sparse × dense
+            return AnalysisResult(step=K_loc @ D_anom)      # shape: (nx, ne)
+
+        # LOCAL ANALYSIS / PARALLEL UPDATE: not implemented after the
+        # refactoring. Used to warn and return None, which left the scheme
+        # with no step and the posterior equal to the prior.
+        elif localization.name in ('localanalysis', 'parallel_update'):
+            raise NotImplementedError(
+                f"approx_update: localization {localization.name!r} is not implemented."
+            )
+
+        # NO LOCALIZATION
+        else:
+            X3 = (VrT.T * Sr[None, :]) @ X2                 # shape: (ne, ne); column-scale instead of a dense diag
+            return AnalysisResult(step=scx[:, None] * X_anom @ X3)   # shape: (nx, ne)
diff --git a/src/pipt/update_schemes/analysis/base.py b/src/pipt/update_schemes/analysis/base.py
new file mode 100644
index 00000000..12f181e3
--- /dev/null
+++ b/src/pipt/update_schemes/analysis/base.py
@@ -0,0 +1,213 @@
+"""Shared base for the analysis-step analyses.
+
+An *analysis* computes the state update for one assimilation
+iteration. The three shipped flavours -- ``approx``, ``full`` and ``subspace``
+-- differ only in how the ensemble-approximated sensitivity is inverted; they
+share their calling convention and their linear-algebra helpers.
+
+This is the PIPT counterpart to ``popt.optimization_methods.subroutines``:
+small, focused numerical pieces the top-level scheme composes with, rather than
+behaviour baked into the scheme's class name.
+
+Historically these flavours were mixins combined into the scheme at class
+definition time, producing a combinatorial explosion of names
+(``esmda_approx``, ``esmda_full``, ``esmda_subspace``, ``lmenrml_approx``, ...).
+Every algorithm class now takes ``analysis`` as a constructor argument and
+binds the matching analysis instead (see ``AnalysisBindingMixin``). Mixing in still
+works, for an analysis that genuinely cannot take this shape -- nothing shipped
+here needs it any more, now that ``margis`` binds like the rest -- but doing
+so is riskier than it looks: see ``AnalysisBindingMixin``'s module docstring for why
+the scheme base usually has to be listed first, and what that can do to
+method resolution.
+
+Analysis contract
+-----------------
+``update(enX, enY, enE, **kwargs) -> AnalysisResult``
+    Return the update as an :class:`AnalysisResult`: a state-space ``step``
+    of shape ``(nx, ne)`` (a plain array is accepted and means the same), or
+    a step in ensemble-weight space, ``w_step`` or ``W_step`` (two
+    conventions, see the class). The scheme turns whichever it gets into a
+    trial state with ``propose_state``; an analysis never writes its result
+    onto the scheme.
+
+Analyses reach everything they need through ``self.scheme``: the damping
+parameter ``self.scheme.lam``, ``self.scheme.trunc_energy``,
+``self.scheme.localization``, ``self.scheme.prior_enX``,
+``self.scheme.cov_data``, and so on. Some of those are the scheme's own
+attributes and some belong to its ensemble, but the scheme exposes both as
+properties (see :class:`~pipt.update_schemes.core.AssimilationScheme`),
+so an analysis never has to know which -- and there is no forwarding
+machinery on this side at all. A new flavour that needs a value no existing
+one uses just reads ``self.scheme.``; if the scheme does not already
+expose it, adding one property there is the whole change.
+
+``self.scheme`` resolves for both ways an analysis can be used:
+
+- **Bound** -- ``self.scheme`` is the scheme it was constructed against.
+- **Mixed in** -- ``self`` *is* the scheme, so ``self.scheme`` is ``self``
+  (see :attr:`scheme` below). Nothing shipped here still needs this
+  (``margis`` binds like the rest now); it remains supported for an analysis
+  whose calling convention genuinely does not fit the bound shape.
+
+State an analysis keeps between iterations -- ``full_update`` caches ``Am``,
+the weight-space flavours start ``current_W`` and keep their scaled
+perturbations -- lives on ``self.scheme`` explicitly, the same way it is
+read, not on ``self``: nothing forwards a plain ``self.Am = ...`` to the
+scheme.
+"""
+
+from abc import ABC, abstractmethod
+
+import numpy as np
+from dataclasses import dataclass
+from scipy.linalg import solve as _dense_solve
+from scipy.linalg import sqrtm as _dense_sqrtm
+
+__all__ = ["AnalysisBase"]
+
+
+@dataclass(slots=True)
+class AnalysisResult:
+    """What an analysis hands back to the scheme. Exactly one field is set.
+
+    ``step``
+        Additive step in state space, ``(nx, ne)``; the trial state is
+        ``enX + scale * step``. The multilevel analysis returns one array per
+        fidelity level.
+    ``w_step``
+        Additive step to the weight matrix ``W`` of the ensemble subspace
+        formulation (Evensen et al. 2019), starting from ``W = 0``; the trial
+        state is ``prior_enX @ (I + W / sqrt(ne - 1))``.
+    ``W_step``
+        Additive step to the ensemble transform ``W`` of the matrix
+        formulation (Raanes et al. 2019), starting from ``W = I``; the trial
+        state is ``mean(prior_enX) + prior_anomalies * sqrt(ne - 1) @ W``.
+
+    ``scale`` is the scheme's step length (GN-EnRML's ``gamma``; 1 elsewhere)
+    and belongs to the scheme, which is why the analysis returns a step and
+    not a state.
+    """
+
+    step: object = None
+    w_step: object = None
+    W_step: object = None
+
+    def __post_init__(self):
+        given = [name for name in ("step", "w_step", "W_step") if getattr(self, name) is not None]
+        if len(given) != 1:
+            raise ValueError(f"AnalysisResult needs exactly one of step, w_step, W_step; got {given or 'none'}")
+
+    @classmethod
+    def coerce(cls, value):
+        """An ``AnalysisResult`` as given; a plain array or list as a state-space step."""
+        if isinstance(value, cls):
+            return value
+        if value is None:
+            raise ValueError("the analysis returned None; return an AnalysisResult (or a step array)")
+        return cls(step=value)
+
+
+class AnalysisBase(ABC):
+    """Base class for analysis-step analyses.
+
+    Provides the linear-algebra helpers every flavour needs. Both accept either
+    a full 2-D matrix or a 1-D array holding just the diagonal, which is how
+    PIPT represents a diagonal data covariance without materialising ``nd x nd``
+    zeros.
+
+    Two usages
+    ----------
+    **Bound** (what every algorithm class does, for every flavour in its
+    ``COMPATIBLE_ANALYSES``) -- constructed against a scheme it holds a
+    reference to::
+
+        strategy = approx_update(scheme)
+        step = strategy.update(enX, enY, enE)
+
+    which is what lets ``analysis`` be a constructor argument of one scheme
+    class rather than picking which of several classes you get. Inside
+    ``update()``, context is read explicitly off ``self.scheme`` -- there is
+    no delegation step to run first; ``self.scheme`` is just the object
+    passed to the constructor, and it exposes ensemble state as properties
+    of its own.
+
+    **Mixed in** -- nothing shipped here still needs this (``margis`` binds
+    like the rest now); it remains supported for an analysis whose calling
+    convention genuinely does not fit the bound shape above::
+
+        class some_scheme(SomeAlgorithm, some_analysis): ...
+
+    ``self`` *is* the scheme here, so ``self.scheme`` (the :attr:`scheme`
+    property below) simply returns ``self`` -- ``self.scheme.lam`` and
+    ``self.lam`` are then the same read, resolved by ordinary inheritance.
+
+    An unbound, un-mixed-in analysis has ``self.scheme`` fall back to
+    ``self`` too, so a context read raises a plain ``AttributeError`` rather
+    than finding a half-initialised scheme.
+    """
+
+    def __init__(self, scheme=None):
+        """
+        Parameters
+        ----------
+        scheme : object, optional
+            Scheme this analysis computes updates for. ``None`` leaves the
+            analysis unbound. Never invoked in the mixin case: no
+            ``__init__`` in that MRO chains to ``super()``.
+        """
+        self._scheme = scheme
+
+    @property
+    def scheme(self):
+        """The scheme to read context from and write results onto.
+
+        The bound value if there is one; otherwise ``self`` -- which is
+        exactly right when *mixed in* (``self`` already is the scheme, so
+        ``self.scheme.x`` and ``self.x`` are the same read) and merely
+        produces a plain ``AttributeError`` from an unbound, un-mixed-in
+        analysis rather than a special-cased error path.
+        """
+        bound = getattr(self, "_scheme", None)
+        return bound if bound is not None else self
+
+    @abstractmethod
+    def update(self, enX, enY, enE, **kwargs):
+        """Compute the analysis update step.
+
+        Parameters
+        ----------
+        enX : np.ndarray
+            State ensemble matrix, shape ``(nx, ne)``.
+        enY : np.ndarray
+            Predicted data ensemble matrix, shape ``(nd, ne)``.
+        enE : np.ndarray
+            Perturbed observation ensemble, shape ``(nd, ne)``.
+        **kwargs
+            Analysis-specific extras, e.g. ``prior`` or ``enAdj``.
+
+        Returns
+        -------
+        AnalysisResult
+            The update: a state-space ``step`` of shape ``(nx, ne)``, or a
+            weight-space ``w_step``/``W_step``. Returning a plain array is
+            taken as a state-space step.
+        """
+
+    @staticmethod
+    def solve(A, B):
+        """Apply ``A⁻¹ B``, supporting both matrix (2-D) and diagonal (1-D) ``A``.
+
+        ``np.ndim`` is used rather than ``A.ndim`` so that plain lists and
+        scalars -- which a covariance can still be when it comes straight from a
+        config file -- are handled instead of raising ``AttributeError``.
+        """
+        if np.ndim(A) == 2:
+            return _dense_solve(A, B)
+        return (np.asarray(A) ** (-1))[:, None] * B
+
+    @staticmethod
+    def sqrtm(A):
+        """Matrix square root, supporting both matrix and diagonal inputs."""
+        if np.ndim(A) == 2:
+            return _dense_sqrtm(A)
+        return np.sqrt(A)
diff --git a/src/pipt/update_schemes/analysis/full.py b/src/pipt/update_schemes/analysis/full.py
new file mode 100644
index 00000000..405e37a3
--- /dev/null
+++ b/src/pipt/update_schemes/analysis/full.py
@@ -0,0 +1,114 @@
+"""Full (model-space) LM ensemble update."""
+
+import numpy as np
+
+from pipt.update_schemes.analysis.base import AnalysisBase, AnalysisResult
+import pipt.misc_tools.analysis_tools as at
+
+
+class full_update(AnalysisBase):
+    """
+    Full LM update as in Chen & Oliver (2013).
+
+    Unlike the approximate update, the state-error covariance is represented
+    in model space via the ``Am`` matrix, which adds an explicit regularisation
+    term pulling the ensemble toward the prior.
+
+    Reference
+    ---------
+    Chen, Y., & Oliver, D. S. (2013). Levenberg-Marquardt forms of the iterative
+    ensemble smoother for efficient history matching and uncertainty quantification.
+    Computational Geosciences, 17(4), 689-703.
+    https://doi.org/10.1007/s10596-013-9351-5
+
+    Note
+    ----
+    No localization is implemented for this update scheme.
+    """
+
+    def update(self, enX, enY, enE, **kwargs):
+        """
+        Perform the full LM update.
+
+        Parameters
+        ----------
+        enX : np.ndarray, shape (nx, ne)
+            State ensemble matrix.
+        enY : np.ndarray, shape (nd, ne)
+            Predicted data ensemble matrix.
+        enE : np.ndarray, shape (nd, ne)
+            Perturbed observations ensemble.
+
+        Returns
+        -------
+        np.ndarray, shape (nx, ne)
+            Update step to be added to the state ensemble.
+        """
+        scheme = self.scheme
+
+        nx, ne = enX.shape
+        ny, _  = enY.shape
+
+        # Scaling factors and projection matrix. Fallbacks are built only when
+        # the scheme lacks the attribute; see approx_update for why.
+        cov    = scheme.cov_data if hasattr(scheme, 'cov_data') else np.eye(ny)
+        # State scaling (prior standard deviation per row): anomalies and the
+        # prior misfit are divided by it, Am is built in the same scaled space,
+        # and the step is multiplied back.
+        scx    = scheme.state_scaling if hasattr(scheme, 'state_scaling') else np.ones(nx)
+        scy    = scheme.scale_data if hasattr(scheme, 'scale_data') else self.sqrtm(cov)
+        PI     = (scheme.proj if hasattr(scheme, 'proj')
+                  else (np.eye(ne) - np.ones((ne, ne)) / ne) / np.sqrt(ne - 1))
+
+        priorX = kwargs.get('prior', scheme.prior_enX)
+
+        # Build Am matrix once per outer iteration
+        if scheme.Am is None:
+            self.ext_Am()
+
+        # Anomaly matrices
+        Y_anom = self.solve(scy, enY @ PI)              # shape: (nd, ne)
+        X_anom = self.solve(scx, enX @ PI)              # shape: (nx, ne)
+        D_anom = self.solve(scy, enE - enY)             # shape: (nd, ne)
+
+        # Truncated SVD of predicted-data anomalies
+        Ur, Sr, VrT = at.truncSVD(Y_anom, energy=scheme.trunc_energy)  # (nd,nr), (nr,), (nr,ne)
+
+        # ── Data-misfit term (δm₁) ──────────────────────────────────────────
+        X1 = Ur.T @ D_anom                              # shape: (nr, ne)
+        X2 = self.solve(1 + scheme.lam + Sr ** 2, X1)   # shape: (nr, ne)
+        X3 = (VrT.T * Sr[None, :]) @ X2                 # shape: (ne, ne); column-scale instead of a dense diag
+        delta_m1 = (scx[:, None] * X_anom) @ X3         # shape: (nx, ne)
+
+        # ── Regularisation term (δm₂) -- model-space prior pull ─────────────
+        Am = scheme.Am
+        X4 = Am.T @ self.solve(scx, enX - priorX)       # shape: (nr', ne)
+        X5 = Am @ X4                                    # shape: (nx,  ne)
+        X6 = X_anom.T @ X5                              # shape: (ne,  ne)
+        X7 = VrT.T @ self.solve(1 + scheme.lam + Sr ** 2,
+                                VrT @ X6)               # shape: (ne, ne)
+        delta_m2 = -(scx[:, None] * X_anom) @ X7        # shape: (nx, ne)
+
+        return AnalysisResult(step=delta_m1 + delta_m2)
+
+    # ------------------------------------------------------------------
+    # Helpers
+    # ------------------------------------------------------------------
+
+    def ext_Am(self):
+        """Compute and cache the Am matrix from the scaled prior anomalies.
+
+        The anomalies are divided by ``state_scaling``, the same scaled space
+        ``update`` puts ``X_anom`` and the prior misfit in, so that
+        ``Am @ Am.T`` approximates the inverse of the *scaled* prior
+        covariance. Multiplying by the scaling instead, as this once did,
+        made the regularisation term off by the squared standard deviation
+        for any variable whose prior standard deviation was not 1.
+        """
+        scheme = self.scheme
+        delta = self.solve(scheme.state_scaling, scheme.prior_enX @ scheme.proj)
+        U, S, _ = np.linalg.svd(delta, full_matrices=False)
+
+        # Truncate to the energy threshold
+        r = int(np.searchsorted(np.cumsum(S) / S.sum(), self.scheme.trunc_energy)) + 1
+        scheme.Am = U[:, :r] * (S[:r] ** (-1))[None, :]   # shape: (nx, r), notation from paper
diff --git a/src/pipt/update_schemes/analysis/hybrid.py b/src/pipt/update_schemes/analysis/hybrid.py
new file mode 100644
index 00000000..9a07659d
--- /dev/null
+++ b/src/pipt/update_schemes/analysis/hybrid.py
@@ -0,0 +1,82 @@
+"""
+ES, and Iterative ES updates with hybrid update matrix calculated from multi-fidelity runs.
+"""
+
+import numpy as np
+from scipy.linalg import solve
+from pipt.misc_tools import analysis_tools as at
+import pipt.misc_tools.extract_tools as extract
+from pipt.update_schemes.analysis.base import AnalysisBase, AnalysisResult
+
+class hybrid_update(AnalysisBase):
+    '''
+    Class for hybrid update schemes as described in: Fossum, K., Mannseth, T., & Stordal, A. S. (2020). Assessment of
+    multilevel ensemble-based data assimilation for reservoir history matching. Computational Geosciences, 24(1),
+    217–239. https://doi.org/10.1007/s10596-019-09911-x
+
+    Note that the scheme is slightly modified to be inline with the standard (I)ES approximate update scheme. This
+    is what lets it be bound as an analysis like ``approx_update`` and friends, despite working on *lists* of
+    per-level matrices rather than single ones -- see ``esmda_hybrid.COMPATIBLE_ANALYSES``.
+    '''
+
+    def update(self, enX, enY, enE, **kwargs):
+        '''
+        Perform the hybrid update.
+
+        Parameters:
+        ----------
+            enX : list of np.ndarray
+                List of state ensemble matrices for each level (nx, ne)
+
+            enY : list of np.ndarray
+                List of predicted data ensemble matrices for each level (nd, ne)
+
+            enE : list of np.ndarray
+                List of ensemble of perturbed observations for each level (nd, ne)
+        '''
+        # esmda_hybrid computes its own proj/scale_data (one entry per
+        # fidelity level, where other flavours have a single matrix). Reading
+        # them off the scheme picks those up automatically -- that is what
+        # the scheme's own_or_ensemble properties are for.
+        scheme = self.scheme
+        proj = scheme.proj
+        scale_data = scheme.scale_data
+        state_scaling = scheme.state_scaling
+
+        # Loop over levels to calculate the update step
+        X3 = []
+        enXcentered = []
+        for l in range(scheme.tot_level):
+
+            # Get Perturbed state ensemble at level l
+            if extract.is_enabled(scheme.keys_da.get('emp_cov', False)):
+                enXcentered.append(self.solve(state_scaling, enX[l] - np.mean(enX[l], 1)[:,None]))
+            else:
+                enXcentered.append(self.solve(state_scaling, np.dot(enX[l], proj[l])))
+
+            # Calculate truncated SVD of predicted data ensemble at level l
+            enYcentered = self.solve(scale_data[l], np.dot(enY[l], proj[l]))
+            Ud, Sd, VTd = at.truncSVD(enYcentered, energy=scheme.trunc_energy)
+
+            X2 = solve(((scheme.lam + 1)*np.eye(len(Sd)) + np.diag(Sd**2)), Ud.T)
+            X3.append(np.dot(np.dot(VTd.T, np.diag(Sd)), X2))
+
+        # Calculate each row of step individually to avoid memory issues.
+        step = [np.empty(enXcentered[l].shape) for l in range(scheme.tot_level)]
+        # Generate row batches: at most 1000 rows at a time, and at least one,
+        # so a single-row state does not produce an empty range.
+        nrows = state_scaling.shape[0]
+        step_size = max(1, min(1000, nrows // 2))
+        row_step = [np.arange(s, min(s + step_size, nrows)) for s in range(0, nrows, step_size)]
+
+        # Loop over rows
+        for row in row_step:
+            ml_weights = scheme.multilevel['ml_weights']
+            kg = sum([ml_weights[l]*np.dot(enXcentered[l][row, :], X3[l]) for l in range(scheme.tot_level)])
+
+            # Loop over levels
+            for l in range(scheme.tot_level):
+                enRes = self.solve(scale_data[l], enE[l] - enY[l])
+                step[l][row, :] = np.dot(state_scaling[row, None] * kg, enRes)
+
+        return AnalysisResult(step=step)
diff --git a/src/pipt/update_schemes/analysis/margis.py b/src/pipt/update_schemes/analysis/margis.py
new file mode 100644
index 00000000..79c78e52
--- /dev/null
+++ b/src/pipt/update_schemes/analysis/margis.py
@@ -0,0 +1,157 @@
+"""Stochastic iterative ensemble smoother (IES, i.e. EnRML) with *subspace* implementation.
+
+Ported from ``update_methods_ns/margIS_update.py`` on the project's ``main``
+branch (an older, pre-refactor layout), replacing the inert placeholder that
+used to live here. This is closer to real than that placeholder -- it reads
+the same context (``ne``, ``proj``, ``lam``, ``scale_data``) other analyses
+in this package need, via ``self.scheme`` rather than the ported code's
+original bare ``self.X`` (see ``AnalysisBase`` for why), and its
+``update(self, enX, enY, enE, **kwargs)`` signature matches
+what ``GNEnRML.calc_analysis`` already calls it with -- unlike on ``main``,
+where the equivalent caller passes no arguments at all.
+
+Several problems in the ported code have been fixed here, against
+Stordal, Lorentzen & Fossum, *Marginalized iterative ensemble smoothers for
+data assimilation*, Computational Geosciences 27:975-986 (2023). One of
+these was diagnosed wrong on the first pass and is recorded here so the
+mistake is not repeated:
+
+- It delivers its result via ``self.W_step`` (capital W), the ensemble
+  *matrix* update ("following e.g. Raanes et al. 2019", per the code this
+  was ported from), whose reconstruction is
+  ``enX = mean(prior_enX) + prior_enX @ proj * sqrt(ne-1) @ W``. That branch
+  had been dropped from this codebase's ``GNEnRML.calc_analysis`` -- only
+  the lowercase ``w_step`` *vector* update ("following e.g. Evensen et al.
+  2019", reconstruction ``enX = prior_enX @ (I + W/sqrt(ne-1))``) remained.
+  The first fix here renamed ``self.W_step`` to ``self.w_step`` to match the
+  branch that still existed -- which was wrong: it is a different formula
+  for a differently-defined ``W`` (this method's ``W`` starts at the identity
+  per the paper, Section 2.4; the vector update's starts at zero), not an
+  alternative name for the same one. Confirmed by running it: routed through
+  the vector-update branch, the assimilation made the misfit *worse* by five
+  orders of magnitude, and stayed exactly as bad regardless of how small the
+  step length ``gamma`` shrank -- the signature of applying the wrong
+  reconstruction formula entirely, not a scale problem. The real fix restores
+  the missing ``hasattr(self, 'W_step')`` branch to ``GNEnRML.calc_analysis``
+  (see there) and leaves this file delivering ``self.W_step`` as it always
+  did. Confirmed against real data (PIPT's own ``TinyBox`` tutorial case):
+  misfit prior 1.96e10, after one iteration 1.18e8, a 99.4% reduction.
+- The update loop was hardcoded to 70 individual data points, each its own
+  "type" of one (``M = 1``), matching neither the data actually being
+  assimilated nor the method's own general form. Equations 8-9 of the paper
+  give the multi-type log-likelihood as a *sum over data types*, each with
+  its own count ``M_k`` -- Eq. 37's ``(M + nu)/(S + nu*s**2)`` factor (what
+  ``Ratio`` computes below) is exactly one term of that sum. The loop now
+  groups rows by data type (``scheme.data_df``'s columns) instead of walking
+  points one at a time; ``M`` is each type's actual row count rather than a
+  fixed ``1``.
+- It checked ``if self.iteration == 1`` to detect the first call and
+  initialise ``current_W``/``current_w``/``D``. This codebase's schemes count
+  from ``self.iteration = 0`` (the log even prints ``self.iteration + 1`` to
+  display 1-based numbers), so the first real analysis call happens at
+  ``iteration == 0`` -- confirmed against ``GNEnRML.__init__`` and
+  ``subspace_update``, which does the same ``if self.iteration == 0`` check
+  for the same reason. Left at ``== 1`` (the ported code's convention, from a
+  layout that apparently counted from 1), initialisation never ran and the
+  first real call failed outright with ``AttributeError: 'AssimilationEnsemble'
+  object has no attribute 'current_W'``.
+- It carried its own ``scale()`` (elementwise for a diagonal covariance,
+  else a dense solve), duplicating :meth:`AnalysisBase.solve` -- the same
+  duplication ``approx``/``full``/``subspace`` used to have before they were
+  consolidated onto the shared base (see that base's module docstring). Now
+  ``margIS_update`` inherits :class:`AnalysisBase` and calls ``self.solve``
+  directly, picking up the same fix that consolidation made: ``np.ndim``
+  rather than ``scaling.shape``, so a covariance passed as a plain list or
+  scalar works rather than raising ``AttributeError``.
+
+The upstream original also carries a square-root (deterministic) variant,
+delivering ``sqrt_w_step``. Nothing in this codebase consumes it --
+``GNEnRML.calc_analysis`` reconstructs from ``step``, ``w_step`` or
+``W_step`` only -- so the partial ``*_sqrt`` chain that fed it (and the
+commented-out assignment at the end) is dropped here rather than kept as
+dead code that cannot run. Recoverable from the upstream file if the variant
+is ever wired up.
+
+``nu``/``s`` remain a single shared value across all types rather than
+per-type ``nu_k``/``s_k`` -- the paper's own worked example (Section 3) does
+the same, setting one shared ``nu`` (there, the total measurement count) for
+every type, so this is not a shortcut introduced here.
+
+Inheriting ``AnalysisBase`` also let ``"margis": margIS_update`` join
+``GNEnRML.COMPATIBLE_ANALYSES`` directly, the same way ``"approx"`` and
+friends are listed there -- ``GNEnRML(..., analysis="margis")`` builds
+``margIS_update(self)`` by ordinary composition, no mixin involved. The
+former ``gnenrml_margis`` class -- which mixed ``margIS_update`` into its
+bases instead -- is gone; while it existed, that mixing turned out to be
+broken in its own right (before this class-level entry existed): with
+``GNEnRML`` listed first, plain attribute lookup found ``AnalysisBindingMixin.update``
+before ``margIS_update.update``, so the scheme could not run regardless of
+this file's own math. See :class:`pipt.update_schemes.core.analysis_binding.AnalysisBindingMixin`
+for why that shadowing happens and why binding avoids it entirely.
+
+This has now been run against real data (see above) and produces a large,
+sensible misfit reduction on one case -- worth far more confidence than "it
+runs without erroring," but still not a golden reference: it is one run, on
+one case, with no committed values pinning today's numbers against a future
+change the way :mod:`test_numerical_characterisation` does for the other
+flavours. Treat it as plausible, not verified.
+"""
+
+import numpy as np
+import pandas as pd
+
+from pipt.update_schemes.analysis.base import AnalysisBase, AnalysisResult
+
+
+class margIS_update(AnalysisBase):
+    """
+    MargIES update from Stordal et.al.
+    This is now implemented with perturbed observations, which means that we set a prior belief on the data uncertainty.
+    Thus, the prior is an invers chi2 distriubtuinm and after scaling the mean varians is 1.
+    """
+
+    def update(self, enX, enY, enE, **kwargs):
+        """The margIES weight-space update (Stordal et al.), one regularisation term per data type; returns the analysis result the scheme applies."""
+
+        scheme = self.scheme
+        ne = scheme.ne
+
+        if scheme.iteration == 0:  # method requires some initiallization
+            scheme.current_W = np.eye(ne)
+            scheme.D = self.solve(scheme.scale_data, enE)
+            # Scale everything so that data uncertainty is I
+
+        sY = self.solve(scheme.scale_data, enY) #Scaling is same as with 'known' uncertainty, hence makes sense to set s = 1
+        S = 0
+
+        deltaD = 0
+
+        Y = np.linalg.solve(scheme.current_W.T, sY.T).T
+        Y = Y @ scheme.proj * np.sqrt(ne - 1)
+
+        # One term of Eq. 8/9 per data type, not per individual point.
+        # The layout knows the data type of every row of the data vector.
+        row_labels = scheme.data_layout.row_datatypes()
+        data_types = pd.unique(row_labels)
+        s = 1 #should be default option with possibility to change in setup
+        nu = ne-1 #should be default option with possibility to change in setup
+        for dtype in data_types:
+            index = np.flatnonzero(row_labels == dtype)
+            M = len(index)  # Numbers of data of this type.
+
+            delta = scheme.D[index,:]-sY[index,:]
+            Chi = np.sum(delta * delta, axis = 0)
+            Chi = np.mean(Chi)
+            Ratio = (M + nu) / (Chi + nu*s*s)
+            #Ratio = 1
+            #Gradient
+            deltaD = deltaD + (Y[index,:] * Ratio).T @ delta
+            # Hessian
+            S = S + (Y[index,:] * Ratio).T @ Y[index,:]
+
+        deltaM = (ne-1)*(np.eye(ne)-scheme.current_W)
+        S = S + np.eye(ne) * (ne - 1)
+        Delta = deltaM + deltaD
+
+
+        return AnalysisResult(W_step=np.linalg.solve(S, Delta) / (1 + scheme.lam))
diff --git a/src/pipt/update_schemes/analysis/registry.py b/src/pipt/update_schemes/analysis/registry.py
new file mode 100644
index 00000000..25cd2b2e
--- /dev/null
+++ b/src/pipt/update_schemes/analysis/registry.py
@@ -0,0 +1,84 @@
+"""Canonical name-to-class lookup for the shipped analysis flavours.
+
+A convenience for introspection (``available_analyses()``) and for anyone
+building a scheme's own ``COMPATIBLE_ANALYSES`` dict (see
+:class:`~pipt.update_schemes.core.analysis_binding.AnalysisBindingMixin`) without importing
+``approx_update``/``full_update``/``subspace_update`` individually.
+
+Registering a flavour here (:func:`register_analysis`) does **not** by itself
+make it selectable on any existing scheme: each algorithm class (``ESMDA``,
+``EnKF``, ...) declares its own ``COMPATIBLE_ANALYSES``, read directly off the
+class rather than computed from this registry, so that reading one scheme's
+source tells you everything it supports. Wiring a newly registered flavour
+into a scheme means adding it to that scheme's ``COMPATIBLE_ANALYSES`` --
+or, for a wholly out-of-tree scheme, registering the combination directly via
+:func:`pipt.update_schemes.registry.register_scheme`.
+
+Kept in its own module rather than in :mod:`pipt.update_schemes.analysis.base`:
+the concrete flavours import the base, so a registry living there would import
+its own importers. ``tests/test_import_hygiene.py`` guards the layering.
+"""
+
+from pipt.update_schemes.analysis.approx import approx_update
+from pipt.update_schemes.analysis.full import full_update
+from pipt.update_schemes.analysis.subspace import subspace_update
+from pipt.update_schemes.analysis.subspace2 import subspace2_update
+
+__all__ = ["ANALYSES", "available_analyses", "get_analysis", "register_analysis"]
+
+
+#: Maps an ``analysis`` flavour to the analysis class implementing it.
+ANALYSES: dict[str, type] = {
+    "approx": approx_update,
+    "full": full_update,
+    "subspace": subspace_update,
+    "subspace2": subspace2_update,
+}
+
+
+def register_analysis(analysis: str, cls: type, *, overwrite: bool = False) -> None:
+    """Add an analysis under a flavour name, for later lookup by that name.
+
+    This alone does not make ``cls`` selectable on any existing scheme -- see
+    the module docstring for how to actually wire a new flavour in.
+
+    Parameters
+    ----------
+    analysis : str
+        Flavour name to register it under.
+    cls : type
+        Analysis class implementing it.
+    overwrite : bool, optional
+        Allow replacing an existing entry. Defaults to ``False``, so two
+        packages claiming one name is an error rather than a load-order
+        lottery -- matching ``registry.register_scheme``.
+    """
+    key = str(analysis).lower()
+    if key in ANALYSES and not overwrite:
+        raise ValueError(
+            f"Analysis flavour '{key}' is already registered to "
+            f"{ANALYSES[key].__name__}; pass overwrite=True to replace it."
+        )
+    ANALYSES[key] = cls
+
+
+def available_analyses() -> list[str]:
+    """Return the registered flavour names, sorted."""
+    return sorted(ANALYSES)
+
+
+def get_analysis(analysis: str) -> type:
+    """Look up the analysis class for a flavour.
+
+    Raises
+    ------
+    KeyError
+        If the flavour is not registered. The message lists the valid ones.
+    """
+    key = str(analysis).lower()
+    if key in ANALYSES:
+        return ANALYSES[key]
+    raise KeyError(
+        f"Unknown analysis flavour '{analysis}'. "
+        f"Available flavours: {', '.join(available_analyses())}."
+    )
diff --git a/src/pipt/update_schemes/analysis/subspace.py b/src/pipt/update_schemes/analysis/subspace.py
new file mode 100644
index 00000000..75419409
--- /dev/null
+++ b/src/pipt/update_schemes/analysis/subspace.py
@@ -0,0 +1,96 @@
+"""Stochastic iterative ensemble smoother (IES) with subspace implementation."""
+
+import numpy as np
+
+from pipt.update_schemes.analysis.base import AnalysisBase, AnalysisResult
+import pipt.misc_tools.analysis_tools as at
+
+
+class subspace_update(AnalysisBase):
+    """
+    Ensemble subspace update (weight-space IES).
+
+    The update is formulated in the ensemble weight space W (shape ne × ne)
+    rather than model space, making it efficient when ne ≪ nx. The caller
+    checks ``self.w_step`` (not ``self.step``) to apply the update.
+
+    References
+    ----------
+    Raanes, P. N., Stordal, A. S., & Evensen, G. (2019).
+    Revising the stochastic iterative ensemble smoother.
+    Nonlinear Processes in Geophysics, 26(3), 325-338.
+    https://doi.org/10.5194/npg-26-325-2019
+
+    Evensen, G., Raanes, P. N., Stordal, A. S., & Hove, J. (2019).
+    Efficient implementation of an iterative ensemble smoother for data
+    assimilation and reservoir history matching.
+    Frontiers in Applied Mathematics and Statistics, 5, 47.
+    https://doi.org/10.3389/fams.2019.00047
+    """
+
+    def update(self, enX, enY, enE, **kwargs):
+        """
+        Perform the subspace (weight-space) LM update.
+
+        Sets ``self.scheme.w_step`` (shape ne × ne) and returns ``None`` --
+        the caller applies the weight update, not a state-space step.
+
+        Parameters
+        ----------
+        enX : np.ndarray, shape (nx, ne)
+            State ensemble matrix (unused directly; included for interface parity).
+        enY : np.ndarray, shape (nd, ne)
+            Predicted data ensemble matrix.
+        enE : np.ndarray, shape (nd, ne)
+            Perturbed observations ensemble.
+
+        Returns
+        -------
+        AnalysisResult
+            The weight-space step ``w_step`` (ne, ne).
+        """
+        scheme = self.scheme
+        ny, ne = enY.shape
+
+        # Fallbacks are built only when the scheme lacks the attribute; see
+        # approx_update for why.
+        scy = scheme.scale_data if hasattr(scheme, 'scale_data') else np.ones(ny)
+        PI  = (scheme.proj if hasattr(scheme, 'proj')
+               else (np.eye(ne) - np.ones((ne, ne)) / ne) / np.sqrt(ne - 1))
+
+        # Initialise weight matrix and projected observation perturbations once
+        if scheme.iteration == 0:
+            scheme.current_W = np.zeros((ne, ne))
+            scheme.E = enE @ PI                              # shape: (nd, ne)
+
+        # Whitened predicted-data anomalies. The SVD below, the residual and
+        # the observation perturbations must all live in the same (data-scaled)
+        # space, otherwise the weights depend on the units of the data.
+        Y = self.solve(scy, enY @ PI)                        # shape: (nd, ne)
+
+        # S = Y @ Omega^{-1},  Omega = I + W @ PI
+        Omega = np.eye(ne) + scheme.current_W @ PI           # shape: (ne, ne)
+        S = np.linalg.solve(Omega.T, Y.T).T                  # shape: (nd, ne)
+
+        # Scaled observation residuals
+        enRes = self.solve(scy, enY - enE)                   # shape: (nd, ne)
+
+        # Truncated SVD of S
+        Us, Ss, VsT = at.truncSVD(S, energy=scheme.trunc_energy)  # (nd,nr), (nr,), (nr,ne)
+        Sinv = (1 / Ss)[:, None]                             # shape: (nr, 1)
+
+        # Projected observation perturbations in reduced space
+        X  = Sinv * (Us.T @ self.solve(scy, scheme.E))       # shape: (nr, ne)
+        eigval, eigvec = np.linalg.eigh(X @ X.T)            # shape: (nr,), (nr, nr); symmetric, so eigh
+        X2 = (Us * Sinv.T) @ eigvec                          # shape: (nd, nr)
+        X3 = S.T @ X2                                        # shape: (ne, nr)
+
+        lam_term = np.eye(len(eigval)) + (1 + scheme.lam) * np.diag(eigval)  # shape: (nr, nr)
+        deltaM = X3 @ self.solve(lam_term, X3.T @ scheme.current_W)  # shape: (ne, ne)
+        deltaD = X3 @ self.solve(lam_term, X2.T @ enRes)           # shape: (ne, ne)
+
+        w_step = (
+            -scheme.current_W / (1 + scheme.lam)
+            - (deltaD - deltaM) / (1 + scheme.lam)
+        )
+        return AnalysisResult(w_step=w_step)
diff --git a/src/pipt/update_schemes/analysis/subspace2.py b/src/pipt/update_schemes/analysis/subspace2.py
new file mode 100644
index 00000000..b12d81e8
--- /dev/null
+++ b/src/pipt/update_schemes/analysis/subspace2.py
@@ -0,0 +1,82 @@
+"""Ensemble-transform IES: Gauss-Newton on the ne x ne transform matrix."""
+
+import numpy as np
+
+from pipt.update_schemes.analysis.base import AnalysisBase, AnalysisResult
+
+
+class subspace2_update(AnalysisBase):
+    """
+    Ensemble-transform subspace update (matrix-formulation IES).
+
+    Solves directly for the ensemble transform ``W`` (shape ne x ne), starting from
+    ``W = I``, minimising
+
+        J(W) = 0.5 (ne-1) ||W - I||_F^2 + 0.5 ||D - g(xbar + Xp W)||^2_{Cd^-1}
+
+    by Gauss-Newton. Unlike :class:`subspace_update` it uses the analytic data
+    covariance throughout -- via ``scale_data`` -- rather than the ensemble
+    representation ``E E.T``, so there is no SVD and ``energy``/``trunc_energy`` is
+    not consulted. The trial state is reconstructed by ``propose_state`` as
+    ``mean(prior_enX) + prior_anomalies * sqrt(ne - 1) @ W``.
+
+    This is exactly :class:`margIS_update` with ``Ratio`` fixed at 1: the data error
+    scale is taken as known instead of being marginalised over an inverse-chi2 prior.
+    ``tests/assimilation/test_subspace2.py`` pins that identity.
+
+    References
+    ----------
+    Raanes, P. N., Stordal, A. S., & Evensen, G. (2019).
+    Revising the stochastic iterative ensemble smoother.
+    Nonlinear Processes in Geophysics, 26(3), 325-338.
+    https://doi.org/10.5194/npg-26-325-2019
+    """
+
+    def update(self, enX, enY, enE, **kwargs):
+        """
+        Perform one Gauss-Newton step on the ensemble transform.
+
+        Parameters
+        ----------
+        enX : np.ndarray, shape (nx, ne)
+            State ensemble matrix (unused; the reconstruction works from the prior).
+        enY : np.ndarray, shape (nd, ne)
+            Predicted data ensemble matrix.
+        enE : np.ndarray, shape (nd, ne)
+            Perturbed observations.
+
+        Returns
+        -------
+        AnalysisResult
+            The transform step ``W_step`` of shape (ne, ne).
+        """
+        scheme = self.scheme
+        ne = enY.shape[1]
+
+        if scheme.iteration == 0:
+            scheme.current_W = np.eye(ne)
+
+        # Whiten both the observations and the predictions with the *current*
+        # scale. ES-MDA redraws enE and scale_data at every assimilation step
+        # (with alpha[iteration] * cov_data), so caching D on the first call --
+        # as the reference implementation does -- would drive later steps with
+        # the first step's observations whitened by the first step's factor,
+        # while sY used the current one. The two would be in different units and
+        # nothing would report it: the run still completes and the misfit still
+        # falls. It is one solve, so there is nothing to gain by keeping it.
+        D  = self.solve(scheme.scale_data, enE)              # shape: (nd, ne)
+        sY = self.solve(scheme.scale_data, enY)              # shape: (nd, ne)
+
+        # Predicted anomalies seen through the current transform.
+        Y = np.linalg.solve(scheme.current_W.T, sY.T).T      # shape: (nd, ne)
+        Y = Y @ scheme.proj * np.sqrt(ne - 1)                # shape: (nd, ne)
+
+        # Gradients: data misfit and the prior pull back towards W = I.
+        deltaD = Y.T @ (D - sY)                              # shape: (ne, ne)
+        deltaM = (ne - 1) * (np.eye(ne) - scheme.current_W)  # shape: (ne, ne)
+
+        # Gauss-Newton Hessian.
+        S = Y.T @ Y + np.eye(ne) * (ne - 1)                  # shape: (ne, ne)
+
+        W_step = np.linalg.solve(S, deltaM + deltaD) / (1 + scheme.lam)
+        return AnalysisResult(W_step=W_step)
diff --git a/src/pipt/update_schemes/core/__init__.py b/src/pipt/update_schemes/core/__init__.py
new file mode 100644
index 00000000..eebf0c54
--- /dev/null
+++ b/src/pipt/update_schemes/core/__init__.py
@@ -0,0 +1,28 @@
+"""Machinery every assimilation scheme is built from.
+
+Separated from the algorithms themselves so that ``pipt.update_schemes`` reads
+as a list of schemes rather than a mixture of schemes and the scaffolding they
+stand on. Two pieces::
+
+    class ESMDA(AssimilationScheme)
+
+:class:`AssimilationScheme`
+    The iteration loop, convergence bookkeeping, restart handling, the run
+    table, the result object, and the diagnostics and artifact saving that
+    surround a run. Subclasses supply :meth:`~AssimilationScheme.update_step`.
+:class:`AnalysisBindingMixin`
+    Resolves the ``analysis`` flavour to an analysis object and delegates
+    ``update()`` to it, so the flavour is a parameter rather than part of the
+    class name.
+"""
+
+from .scheme_base import AssimilationResult, AssimilationScheme, StepReport, restart_options
+from .analysis_binding import AnalysisBindingMixin
+
+__all__ = [
+    "AssimilationScheme",
+    "AssimilationResult",
+    "StepReport",
+    "restart_options",
+    "AnalysisBindingMixin",
+]
diff --git a/src/pipt/update_schemes/core/analysis_binding.py b/src/pipt/update_schemes/core/analysis_binding.py
new file mode 100644
index 00000000..a02f8af8
--- /dev/null
+++ b/src/pipt/update_schemes/core/analysis_binding.py
@@ -0,0 +1,152 @@
+"""Binding an analysis to a scheme rather than inheriting one.
+
+Lets a scheme take its analysis flavour as an argument, so one class covers
+``approx``/``full``/``subspace`` instead of one class per combination.
+
+How a scheme ends up paired with an analysis
+--------------------------------------------
+Every scheme declares, right on the class,
+which flavours it supports and which class handles each -- e.g.
+``esmda.py``::
+
+    class ESMDA(AnalysisBindingMixin, ...):
+        COMPATIBLE_ANALYSES = {
+            "approx": approx_update,
+            "full": full_update,
+            "subspace": subspace_update,
+        }
+
+Walked through for ``ESMDA(da, en, sim, analysis="approx")``, at construction
+time::
+
+    1. ESMDA.__init__(...)            [pipt/update_schemes/esmda.py]
+           |
+           |  self.bind_analysis(self.resolve_analysis(analysis, keys_da))
+           v
+    2. resolve_analysis("approx", keys_da) -> "approx"     [this module]
+           picks the flavour: explicit argument, else keys_da["analysis"],
+           else "approx".
+           |
+           v
+    3. bind_analysis("approx")                              [this module]
+           looks "approx" up in `self.COMPATIBLE_ANALYSES`, giving
+           approx_update. self.analysis = approx_update(self) -- an
+           *instance*, holding a reference back to the scheme (`self`) it
+           was built from.
+
+    Later, once per iteration:
+
+    4. ESMDA.calc_analysis() calls self.update(enX=..., enY=..., ...)
+           |
+           |  AnalysisBindingMixin.update() just forwards:
+           v
+       self.analysis.update(enX=..., enY=..., ...)           [analysis/approx.py]
+           does the linear algebra, reading whatever context it needs off
+           `self.scheme` -- the esmda_instance from step 3. `scheme.lam` is
+           the scheme's own attribute; `scheme.keys_da` is its ensemble's,
+           exposed as a property on the scheme (see AssimilationScheme).
+           The analysis does not need to know which is which.
+
+``EnKF``/``ES`` never revisit a data group, so the prior-increment term
+``full`` adds over ``approx`` never applies -- the two produce identical
+output (pinned by the characterisation suite). Rather than special-casing
+that in code, ``EnKF.COMPATIBLE_ANALYSES`` just points ``"full"`` at the same
+class as ``"approx"``:
+
+    COMPATIBLE_ANALYSES = {"approx": approx_update, "full": approx_update, "subspace": subspace_update}
+
+``ES`` inherits this dict unchanged, so the fact lives in exactly one place
+and applies regardless of how the scheme was constructed.
+
+Mixing in is still supported, but nothing live uses it
+--------------------------------------------------------------------------
+``bind_analysis`` still checks whether an analysis was mixed directly into
+the scheme's bases (``_flavour_is_mixed_in``) and, if so, leaves
+``self.analysis`` unset and lets that inherited ``update()`` take over
+instead of building one. Both flavours that used to need this --
+``hybrid_update`` (multilevel ES-MDA) and ``margIS_update`` (marg-IS) -- now
+bind normally instead: both take the same ``(enX, enY, enE, **kwargs)``
+shape as ``approx_update`` and friends, so ``esmda_hybrid.COMPATIBLE_ANALYSES
+= {"hybrid": hybrid_update}`` and ``GNEnRML.COMPATIBLE_ANALYSES["margis"] =
+margIS_update`` bind them the normal way.
+
+Mixing an analysis directly into a scheme's bases is riskier than it looks
+when the scheme base is listed first, which it usually must be: whichever
+class the scheme's own ``__init__`` needs to resolve to has to come first,
+but that can leave the *analysis's* ``update()`` shadowed by
+``AnalysisBindingMixin.update()`` -- found first via the scheme's own MRO chain --
+regardless of what ``bind_analysis`` decides. That bit both ``esmda_hybrid``
+and ``gnenrml_margis`` (the latter fixed with an explicit ``update``
+override before margis was converted to bind normally; see the CHANGELOG).
+No class in this repository mixes an analysis in any more; ``co_lm_enrml``,
+the last one, is a thin ``LMEnRML`` subclass that binds normally.
+Prefer binding (a ``COMPATIBLE_ANALYSES`` entry) over mixing in for any new
+flavour that fits the ``(enX, enY, enE, **kwargs)`` shape; mixing in is only
+for an analysis that genuinely cannot, the way ``margIS_update`` used to.
+"""
+
+__all__ = ["AnalysisBindingMixin"]
+
+
+class AnalysisBindingMixin:
+    """Resolve an analysis flavour to an analysis object and delegate to it."""
+
+    #: Flavour name -> analysis class to build with ``self`` as its scheme.
+    #: Every scheme mixing this in sets its own (see module docstring). A
+    #: scheme that instead gets a flavour by mixing the analysis directly
+    #: into its bases needs no entry for it here, since ``bind_analysis``
+    #: never consults this dict in that case.
+    COMPATIBLE_ANALYSES: dict[str, type] = {}
+
+    #: The bound analysis object, or ``None`` when a mixin supplies the
+#: flavour instead. ``analysis_name`` holds the flavour's name.
+    analysis = None
+
+    def resolve_analysis(self, analysis=None, keys_da=None) -> str:
+        """Decide the flavour: explicit argument, else the config, else "approx"."""
+        if analysis is not None:
+            return str(analysis).lower()
+        if keys_da is not None:
+            return str(keys_da.get("analysis", "approx")).lower()
+        return "approx"
+
+    def bind_analysis(self, analysis) -> None:
+        """Bind the analysis for ``analysis``, unless a mixin already supplies one.
+
+        Nothing shipped in this repository takes that path today (see the
+        module docstring); it remains for a scheme that mixes an analysis
+        directly into its bases instead of listing it in
+        ``COMPATIBLE_ANALYSES``, in which case it keeps the inherited
+        implementation and binds nothing.
+        """
+        self.analysis_name = analysis
+        if self._flavour_is_mixed_in():
+            self.analysis = None
+            return
+        if analysis not in self.COMPATIBLE_ANALYSES:
+            raise KeyError(
+                f"{type(self).__name__} has no {analysis!r} analysis flavour. "
+                f"Available: {', '.join(sorted(self.COMPATIBLE_ANALYSES))}."
+            )
+        self.analysis = self.COMPATIBLE_ANALYSES[analysis](self)
+
+    def _flavour_is_mixed_in(self) -> bool:
+        """True if some other class in the MRO already defines ``update``."""
+        return any(
+            "update" in klass.__dict__
+            for klass in type(self).__mro__
+            if klass is not AnalysisBindingMixin
+        )
+
+    def update(self, *args, **kwargs):
+        """Delegate the analysis step to the bound analysis.
+
+        Only reached when nothing else in the MRO defines ``update``; a
+        mixed-in flavour takes precedence and never gets here.
+        """
+        if self.analysis is None:
+            raise AttributeError(
+                f"{type(self).__name__} has no analysis bound and no "
+                f"mixed-in update(); bind_analysis() was not called."
+            )
+        return self.analysis.update(*args, **kwargs)
diff --git a/src/pipt/update_schemes/core/scheme_base.py b/src/pipt/update_schemes/core/scheme_base.py
new file mode 100644
index 00000000..793a46aa
--- /dev/null
+++ b/src/pipt/update_schemes/core/scheme_base.py
@@ -0,0 +1,1090 @@
+"""The class every iterative ensemble data-assimilation scheme inherits.
+
+This is the PIPT counterpart to
+:mod:`popt.optimization_methods.optimizer_base`, and deliberately mirrors its
+shape: the scheme object owns its own iteration loop, its convergence checks,
+and its checkpoint/restart handling, while subclasses supply only the
+algorithm-specific analysis step.
+
+The two packages differ in what the iteration acts on. An optimizer is handed
+callables (``fun``, ``jac``, ``hess``) and drives a control vector. An
+assimilation scheme is handed an *ensemble* collaborator, which owns the state
+realisations, the observed data, and the forward simulator.
+
+Ensemble collaborator protocol
+------------------------------
+The scheme only relies on the following members, so anything satisfying them
+can be substituted (a lightweight fake is used in the unit tests):
+
+``ensemble.forecast()``
+    Run the forward simulator on the current state and refresh ``pred_data``.
+``ensemble.enX``
+    State ensemble matrix, shape ``(nx, ne)``.
+``ensemble.pred_data``
+    Predicted data for the current state.
+``ensemble.logger``
+    A :class:`ensemble.logger.PetLogger`, a no-op :class:`ensemble.logger.NullLogger`
+    (set when the ensemble's ``logit`` option is false), or ``None`` (e.g. a test
+    double with no logger at all).
+``ensemble.keys_da``
+    The parsed ``dataassim`` config. Read at every hook, since which
+    diagnostics and artifacts a run produces is a matter of configuration.
+``ensemble.sim``
+    The forward simulator. Only ``input_dict`` is read here, to decide whether
+    QA/QC was asked for.
+``ensemble._saving_enabled``
+    Whether the run writes artifacts at all.
+
+Reaching the ensemble's state
+-----------------------------
+A scheme reads plenty of ensemble state -- ``enX``, ``pred_data``,
+``keys_da``, ``localization`` and friends -- and so do the analyses,
+through the scheme. Rather than forwarding unknown attributes
+at lookup time, each of those names is declared as an explicit
+:class:`property` on :class:`AssimilationScheme` (see the block of
+``_ensemble_attr`` / ``_own_or_ensemble_attr`` declarations below). The
+scheme is therefore a *façade*: everything an analysis needs is
+reachable as ``scheme.``, whether the value lives on the scheme or on
+its ensemble, and an analysis never has to know which.
+
+Reads delegate; writes do not. Assigning ensemble state goes through
+``self.ensemble. = ...`` explicitly, because that is the object the
+forecast reads back. The four names a scheme *may* legitimately compute for
+itself (``cov_data``, ``scale_data``, ``proj``, ``Am``) are the exception
+and have setters.
+
+Relationship to the legacy design
+---------------------------------
+Historically a PIPT scheme *inherited* from ``pipt.loop.ensemble.Ensemble`` and
+an external ``pipt.loop.assimilation.Assimilate`` object drove the loop. That
+made every scheme simultaneously an algorithm and a data container, and made
+the analysis flavour (``approx``/``full``/``subspace``) part of the class name.
+Here the ensemble is a *collaborator* rather than a superclass, matching how
+``OptimizerBase`` composes with its callables.
+"""
+
+import os
+import pickle
+import warnings
+from abc import ABC, abstractmethod
+from copy import deepcopy
+from pathlib import Path
+from dataclasses import dataclass
+from importlib import import_module
+from typing import Any
+
+import numpy as np
+import pandas as pd
+from scipy.optimize import OptimizeResult
+
+from misc.structures import PETDataFrame
+from pipt.ensembles import AssimilationEnsemble
+from ensemble.checkpoint import RestartMixin
+from pipt.update_schemes.core.analysis_binding import AnalysisBindingMixin
+from pipt.update_schemes.analysis.base import AnalysisResult
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    # QAQC pulls in matplotlib; it is imported at runtime only inside
+    # _build_qaqc, when the configuration actually asks for QA/QC.
+    from pipt.misc_tools.qaqc_tools import QAQC
+import pipt.misc_tools.analysis_tools as at
+import pipt.misc_tools.extract_tools as extract
+
+__all__ = ["AssimilationScheme", "AssimilationResult", "StepReport"]
+
+
+def _ensemble_attr(name):
+    """Read-only view of an ensemble attribute, as a real property.
+
+    Used for the state a scheme reads but never owns. No setter: assigning
+    raises ``AttributeError`` rather than quietly creating a scheme-local
+    shadow that the ensemble -- and therefore the forecast -- would never
+    see.
+    """
+    def getter(self):
+        return getattr(self.ensemble, name)
+
+    return property(getter, doc=f"``ensemble.{name}`` (owned by the ensemble).")
+
+
+def _own_or_ensemble_attr(name):
+    """The scheme's own value if it has set one, else the ensemble's.
+
+    For the handful of names a scheme may legitimately recompute for itself
+    (see the block where these are declared). Assigning stores on the
+    scheme; reads fall through to the ensemble until it does.
+    """
+    slot = f"_own_{name}"
+
+    def getter(self):
+        try:
+            return self.__dict__[slot]
+        except KeyError:
+            return getattr(self.ensemble, name)
+
+    def setter(self, value):
+        self.__dict__[slot] = value
+
+    return property(
+        getter,
+        setter,
+        doc=f"``{name}``: the scheme's own if it computed one, else the ensemble's.",
+    )
+
+
+@dataclass(slots=True)
+class StepReport:
+    """What one attempt produced. Returned by :meth:`update_step`.
+
+    The base does not dictate how a scheme takes its step; this is what it
+    needs back afterwards, to score convergence, log, and build the result.
+    Required fields are positional, so forgetting one is a ``TypeError`` at
+    construction rather than a ``None`` surfacing several iterations later.
+    """
+
+    accepted: bool
+    """Keep this step? ``False`` says the scheme found no improving step and
+    has exhausted the attempts it makes inside :meth:`update_step`, so the
+    loop stops rather than asking for the same step again."""
+
+    state: "Any"
+    """The state this attempt produced, committed by the loop when
+    ``accepted``. A scheme still writes it to ``ensemble.enX_temp`` first,
+    because that is what the forecast predicts on -- but handing it back here
+    is what lets the loop own the commit, rather than every scheme
+    remembering the same two lines. Forgetting them used to give a run that
+    iterated and logged normally while returning the prior untouched."""
+
+    misfit: "np.ndarray"
+    """Per-realisation data misfit **as of now**. The loop derives
+    ``data_misfit`` and ``data_misfit_std`` from it, so the three can no
+    longer drift apart the way separately-assigned attributes could.
+
+    "As of now" matters for a scheme that gives up: LM-EnRML restores the last
+    accepted misfit when it backs off, and returns *that*, so the value the
+    loop records and logs is the one the run actually reached."""
+
+    why_stop: dict | None = None
+    """Criterion record, merged into ``result.why_stop``."""
+
+
+class AssimilationResult(OptimizeResult):
+    """Result of an assimilation run.
+
+    A ``dict`` subclass with attribute access, mirroring
+    :class:`scipy.optimize.OptimizeResult` so that PIPT and POPT results can be
+    handled the same way. Typical fields:
+
+    ``nit``
+        Number of accepted iterations.
+    ``success``
+        Whether the run stopped on a convergence criterion rather than by
+        exhausting ``maxiter``.
+    ``message``
+        Human-readable reason the run stopped.
+    ``why_stop``
+        Mapping of criterion name to whether it fired.
+    ``data_misfit`` / ``prior_data_misfit``
+        Final and initial mean data misfit.
+    """
+
+
+def restart_options(keys_da) -> dict:
+    """The checkpoint settings of a config's ``[dataassim]`` block, as scheme options.
+
+    ``restart`` (resume from the checkpoint), ``restartsave`` (write one after
+    the prior forecast and every accepted iteration) and ``restart_file``
+    (default ``_restart.pkl``). Legacy ``yes``/``no`` strings are
+    accepted. Schemes pass ``**restart_options(keys_da)`` to the base so the
+    keys reach :class:`~ensemble.checkpoint.RestartMixin`; they used to stop
+    at the ensemble, which loaded a pickle of itself and left the scheme's own
+    state -- iteration, damping, misfit history -- at its initial values.
+    """
+    options = {
+        "restart": extract.is_enabled(keys_da.get("restart", False)),
+        "restartsave": extract.is_enabled(keys_da.get("restartsave", False)),
+    }
+    if "restart_file" in keys_da:
+        options["restart_file"] = keys_da["restart_file"]
+    elif "restartfile" in keys_da:   # a section that did not pass the config boundary
+        options["restart_file"] = keys_da["restartfile"]
+    return options
+
+
+class AssimilationScheme(AnalysisBindingMixin, RestartMixin, ABC):
+    """What every iterative ensemble data-assimilation scheme inherits.
+
+    Subclasses implement :meth:`update_step`, which performs one iteration and
+    reports what it produced. Everything else is here: the loop, convergence
+    bookkeeping, restart files, the run table, the result object, and the
+    diagnostics and artifact saving that surround a run.
+
+    Those last two used to be a separate ``AssimilationWorkflowMixin`` that a
+    combined class mixed in ahead of the loop. The split bought nothing --
+    every shipped scheme wanted both halves -- and cost the reader two classes
+    and one load-bearing MRO order, in which listing the mixin second silently
+    stopped a run from saving anything.
+    """
+
+    PRIOR_FORECAST_FILE = "prior_forecast.pkl"
+    POSTERIOR_STATE_FILE = "posterior_state_estimate.npz"
+    POSTERIOR_FORECAST_FILE = "posterior_forecast.pkl"
+    STOP_REASON_FILE = "why_iter_loop_stopped.pkl"
+
+    qaqc: "QAQC | None" = None
+
+    #: The ensemble a scheme builds when none is handed in. Multilevel ES-MDA
+    #: overrides it with its per-level ensemble.
+    ENSEMBLE_CLASS = AssimilationEnsemble
+
+    @classmethod
+    def build_ensemble(cls, keys_da, keys_en, sim, ensemble=None):
+        """The collaborator to run on: ``ensemble`` if given, else a fresh ``ENSEMBLE_CLASS``.
+
+        Handing one in lets two schemes share a prior and its forecasts, and
+        lets a test substitute a stand-in without the config, data files and
+        simulator a real ensemble needs.
+        """
+        return ensemble if ensemble is not None else cls.ENSEMBLE_CLASS(keys_da, keys_en, sim)
+
+    def __init__(self, ensemble: AssimilationEnsemble, **options):
+        """
+        Parameters
+        ----------
+        ensemble : object
+            Collaborator satisfying the ensemble protocol described in the
+            module docstring. Owns the state, the observed data and the
+            forward simulator.
+        **options
+            Scheme configuration.
+
+            - maxiter: Maximum number of accepted iterations (default: 100).
+            - misfit_tol: Relative data-misfit tolerance for convergence
+              (default: 0.01). The assimilation counterpart of an optimizer's
+              ``ftol``.
+            - step_tol: Absolute tolerance on the norm of the state update
+              (default: 1e-8). Counterpart of an optimizer's ``xtol``.
+            - restart: Restore from a restart file on startup (default: False).
+            - restartsave: Write a restart file after the prior forecast and
+              each accepted iteration (default: False).
+            - restart_file: Path for the restart file
+              (default: '{scheme_name}_restart.pkl').
+              Config-driven schemes take these three from the ``[dataassim]``
+              block via :func:`restart_options`.
+        """
+        self.ensemble = ensemble
+        self.options = options
+
+        # Core iteration controls.
+        self.iteration = 0
+        self.maxiter = options.get("maxiter", 100)
+
+        # Convergence tolerances.
+        self.misfit_tol = options.get("misfit_tol", 0.01)
+        self.step_tol = options.get("step_tol", 1e-8)
+
+        # Restart/checkpoint controls.
+        self.restart = options.get("restart", False)
+        self.restartsave = options.get("restartsave", False)
+        self.restart_file = options.get(
+            "restart_file",
+            options.get("restartfile", f"{type(self).__name__.lower()}_restart.pkl"),
+        )
+        self._restart_loaded = False
+
+        # Iteration state. `data_misfit` is the assimilation analogue of an
+        # optimizer's objective value; `enX` of its control vector.
+        self.data_misfit_mean = None
+        self.prior_data_misfit_mean = None
+        self.data_misfit_std = None
+        self.prev_data_misfit_mean = None
+        self.enX_old = None
+
+        # Logging. Owned by the ensemble (its logit/logger_name config
+        # decides whether this is a real PetLogger or a no-op) -- adopt
+        # whatever it has rather than building a separate one.
+        self.logger = getattr(ensemble, "logger", None)
+
+        # Result container and stop bookkeeping.
+        self.conv_msg = ""
+        self.why_stop = {}
+        self.results = AssimilationResult()
+
+        #: Whether the most recent step was accepted. Assigned by
+        #: :meth:`run_assimilation` from what :meth:`update_step` returns, so
+        #: it is always in step with the loop's own view. The
+        #: Levenberg-Marquardt family also sets it in its scoring pass, and
+        #: returns the same value.
+        self.step_accepted = True
+
+    # ------------------------------------------------------------------
+    # Ensemble delegation
+    # ------------------------------------------------------------------
+    # Owned by the ensemble outright. No setter is deliberate: a stray
+    # `self.enX = ...` raises instead of creating a shadow the forecast never
+    # sees. Write ensemble state as `self.ensemble.enX = ...`.
+    adjoints = _ensemble_attr("adjoints")
+    data_df = _ensemble_attr("data_df")
+    data_var_df = _ensemble_attr("data_var_df")
+    enX = _ensemble_attr("enX")
+    idX = _ensemble_attr("idX")
+    keys_da = _ensemble_attr("keys_da")
+    localization = _ensemble_attr("localization")
+    ml_ne = _ensemble_attr("ml_ne")
+    multilevel = _ensemble_attr("multilevel")
+    ne = _ensemble_attr("ne")
+    pred_data = _ensemble_attr("pred_data")
+    data_layout = _ensemble_attr("data_layout")
+    obs_vector = _ensemble_attr("obs_vector")
+    obs_variance = _ensemble_attr("obs_variance")
+    state_layout = _ensemble_attr("state_layout")
+    prior_enX = _ensemble_attr("prior_enX")
+    prior_info = _ensemble_attr("prior_info")
+    save_folder = _ensemble_attr("save_folder")
+    sim = _ensemble_attr("sim")
+    sim_data = _ensemble_attr("sim_data")
+    state = _ensemble_attr("state")
+    state_scaling = _ensemble_attr("state_scaling")
+    tot_level = _ensemble_attr("tot_level")
+    _saving_enabled = _ensemble_attr("_saving_enabled")
+
+    # The ensemble holds a default, but these four a scheme may compute for
+    # itself, so they need setters:
+    #   cov_data    EnKF rebuilds it each calc_analysis.
+    #   scale_data  EnKF/ESMDA/esmda_hybrid redraw it each iteration.
+    #   proj        esmda_hybrid holds one matrix *per level*, not one.
+    #   Am          full_update caches it after computing it once.
+    # Assigning shadows the ensemble from then on; until then reads fall
+    # through.
+    #
+    # Do NOT make these write through. For three of them the scheme's value is
+    # a different quantity that merely shares a name -- hybrid's per-level
+    # `proj` list, ESMDA's alpha-inflated `scale_data` -- and `local_analysis`
+    # and `perturb_observations` still read the ensemble's own version.
+    Am = _own_or_ensemble_attr("Am")
+    cov_data = _own_or_ensemble_attr("cov_data")
+    proj = _own_or_ensemble_attr("proj")
+    scale_data = _own_or_ensemble_attr("scale_data")
+
+    # ------------------------------------------------------------------
+    # Subclass contract
+    # ------------------------------------------------------------------
+    @abstractmethod
+    def update_step(self) -> "StepReport":
+        """Perform one scheme-specific analysis step.
+
+        Implementations compute the analysis update, apply it to the ensemble
+        state, run the resulting forecast, and score the result. How they do
+        that is entirely theirs -- the base calls this and nothing inside it.
+
+        Returns
+        -------
+        StepReport
+            ``accepted`` decides whether the loop advances or gives the scheme
+            another attempt at the same iteration number, which is how the
+            Levenberg-Marquardt schemes back off by increasing their damping
+            parameter. ``misfit`` is the per-realisation data misfit as of now;
+            the loop derives ``data_misfit`` and ``data_misfit_std`` from it.
+        """
+
+    def check_convergence(self) -> bool:
+        """Check scheme-specific convergence criteria.
+
+        Returns
+        -------
+        bool
+            ``True`` if a subclass-specific stopping criterion is satisfied.
+            The default implementation never stops the loop.
+        """
+        return False
+
+    # ------------------------------------------------------------------
+    # Main loop
+    # ------------------------------------------------------------------
+    def run_assimilation(self) -> AssimilationResult:
+        """Run this scheme's assimilation to completion.
+
+        Named for the job rather than the mechanism, and matching the
+        ``run_forecast`` already on this class. The counterpart in popt is
+        ``OptimizerBase.run_optimization``.
+
+        Restores a checkpoint if configured, forecasts and scores the prior,
+        then calls :meth:`update_step` until a convergence criterion fires or
+        ``maxiter`` iterations have been taken. One call is one iteration: a
+        scheme that retries -- re-damping, backtracking a step length -- does
+        so inside :meth:`update_step`, so a report coming back rejected means
+        it has run out of attempts, and the run stops rather than asking again
+        for a step it just said it could not find.
+
+        Convergence is checked on rejected reports too, before that stop takes
+        effect: a scheme's :meth:`check_convergence` can legitimately fire on
+        a step it is about to reject (a stalled misfit that did not actually
+        improve), and that verdict decides how the run is reported.
+
+        Returns
+        -------
+        AssimilationResult
+            Populated result object, also stored on ``self.results``.
+        """
+        if self.restart and not self._restart_loaded:
+            self.load_restart()
+            # Built by the prior-forecast hook on an ordinary run, which a resume skips.
+            self.qaqc = self._build_qaqc()
+        elif not self.restart:
+            self.clear_restart()
+            # The prior goes through the same post-forecast hook as every
+            # later forecast, so outlier replacement applies to it too; that
+            # hook can resample members, so its result is what gets committed.
+            self.ensemble.enX = self.run_forecast(self.enX)
+            self.record_prior_score()  # Scores through score(), below.
+            self.after_prior_forecast()
+            if self.restartsave:
+                self.save_restart()  # the prior forecast is the expensive part of a short run
+
+        converged = False
+
+        while self.iteration < self.maxiter:
+            # Guarded: enX is (nx, ne), so schemes that never opt in pay nothing.
+            if self.step_tol > 0:
+                self.enX_old = deepcopy(self.ensemble.enX)
+
+            # Perform the scheme-specific update (in subclasses)
+            step = self.update_step()
+            assert isinstance(step, StepReport), (
+                f"{type(self).__name__}.update_step() must return a StepReport, "
+                f"not {type(step).__name__}"
+            )
+            self.step_accepted = step.accepted
+
+            # Update the state ensemble. No copy: the report's state is the
+            # array the scheme built and forecast on this iteration (enX + step,
+            # or its outlier-resampled successor), and nothing mutates a state
+            # matrix in place afterwards, so a copy would only double the
+            # peak memory at commit for an (nx, ne) array nobody else changes.
+            if self.step_accepted:
+                self.ensemble.enX = step.state
+
+            # Update the misfit and convergence bookkeeping
+            misfit = np.asarray(step.misfit, dtype=float)
+            self.ensemble_misfit  = misfit
+            self.data_misfit_mean = float(misfit.mean())
+            self.data_misfit_std  = float(misfit.std())
+
+            if step.why_stop:
+                self.why_stop.update(step.why_stop)
+
+            if self.step_accepted:
+                # Logged before the counter advances: the row is numbered
+                # `iteration + 1`, so this is the iteration just finished.
+                self.log_update(success=True)
+                self.iteration += 1
+                self.after_accepted_iteration()
+
+            # After every attempt, not only accepted ones: a scheme can
+            # converge on a step it is about to reject.
+            if self.check_misfit_convergence():
+                converged = True
+            elif self.check_state_convergence():
+                converged = True
+            elif self.check_convergence(): # Subclass-specific convergence criteria.
+                converged = True
+
+            if self.step_accepted and self.restartsave:
+                self.save_restart()
+
+            if converged:
+                break
+
+            if not self.step_accepted:
+                # The scheme has already retried as much as it intends to,
+                # inside update_step(). Asking again would repeat the step it
+                # just reported it could not improve on.
+                self.conv_msg = self.conv_msg or "No improving step found"
+                break
+
+        if self.iteration >= self.maxiter and not converged:
+            self.conv_msg = "Maximum number of iterations reached"
+
+        self.after_loop(converged)
+        return self._finalize(converged)
+
+    # ------------------------------------------------------------------
+    # The run table
+    # ------------------------------------------------------------------
+
+    def log_update(self, success=None, prior_run=False) -> None:
+        """Log one row of the run table.
+
+        Called by :meth:`run_assimilation` -- once for the prior and once per
+        accepted iteration -- so a scheme gets its rows without asking, and
+        the attempts it makes inside :meth:`update_step` stay its own
+        business. The row is the same for every scheme apart from its control
+        parameter, which :meth:`log_columns` supplies.
+        """
+        if self.logger is None:
+            return
+        info = {
+            "Iteration"   : f"{0 if prior_run else self.iteration + 1}",
+            "Status"      : "Success" if (prior_run or success) else "Failed",
+            "Data Misfit" : self.data_misfit_mean,
+            "Change (%)"  : "" if prior_run else
+                            100 * (self.data_misfit_mean / self.prev_data_misfit_mean - 1),
+        }
+        info.update(self.log_columns(prior_run=prior_run))
+        self.logger(**info)
+
+    def log_columns(self, prior_run: bool = False) -> dict:
+        """Trailing columns for the run table -- typically the scheme's
+        control parameter, e.g. ``{"λ": self.lam}``. Empty by default."""
+        return {}
+
+    def score(self, pred_data=None) -> "np.ndarray | None":
+        r"""Per-realisation data misfit of a forecast.
+
+        Called every time a new state has been forecast and needs a number:
+        once for the prior, by :meth:`record_prior_score`, and then by each
+        scheme for every attempt it takes inside :meth:`update_step`. One
+        definition per scheme, rather than the same expression repeated in a
+        prior-scoring hook and again in the step.
+
+        Parameters
+        ----------
+        pred_data : optional
+            The forecast to score -- a ``PETDataFrame`` or an ``(nd, ne)``
+            matrix. Defaults to ``self.pred_data``, which is what the
+            ensemble's most recent forecast produced, so the usual call is
+            ``self.score()`` straight after ``run_forecast``. Pass one
+            explicitly to score a forecast the ensemble no longer holds.
+
+        Returns
+        -------
+        np.ndarray or None
+            ``(ne,)`` misfit per realisation, or ``None`` when the scheme has
+            no observation ensemble bound -- a scheme that scores some other
+            way overrides this, and one that reports no misfit at all (the
+            base's own tests) leaves the loop's misfit bookkeeping alone.
+
+        Notes
+        -----
+        The default is the objective function every shipped scheme uses,
+
+        .. math::
+
+            \Phi_j = (g(m_j) - d_j)^{\mathsf T} C_d^{-1} (g(m_j) - d_j),
+
+        against the *perturbed* observations ``enObs`` and the data covariance
+        ``cov_data``. ES-MDA overrides it to score against an un-inflated copy
+        of the perturbations (``enObs_conv``); the multilevel scheme to score
+        all fidelity levels at once.
+        """
+        pred = self.pred_data if pred_data is None else pred_data
+        enObs = getattr(self, "enObs", None)
+        if enObs is None or pred is None:
+            return None
+        return at.calc_objectivefun(enObs, self._as_matrix(pred), self.cov_data)
+
+    @staticmethod
+    def _as_matrix(pred) -> "np.ndarray":
+        """A forecast as an ``(nd, ne)`` matrix: a ``PredictedData``, a legacy frame, or an array."""
+        if hasattr(pred, "matrix"):
+            return pred.matrix
+        return pred.to_matrix() if hasattr(pred, "to_matrix") else np.asarray(pred)
+
+    def record_prior_score(self) -> None:
+        """Score the prior forecast and record it, before any iteration.
+
+        Sets ``prior_data_misfit_mean``, ``data_misfit_mean`` and the
+        per-realisation ``ensemble_misfit``, so the prior is described by the
+        same attributes as every later iteration -- and early enough that the
+        iteration-0 artifacts written by :meth:`after_prior_forecast` can
+        capture them.
+
+        This used to be a ``score_prior()`` hook that each scheme implemented,
+        which meant every scheme spelled out both the misfit expression and
+        the five assignments around it. The expression is now :meth:`score`
+        and the bookkeeping is here; a scheme customises the former.
+
+        Does nothing when :meth:`score` reports no misfit, which is how a
+        scheme with nothing to score opts out.
+        """
+        misfit = self.score()
+        if misfit is None:
+            return
+
+        misfit = np.asarray(misfit, dtype=float)
+        self.ensemble_misfit = misfit
+        self.data_misfit_mean = float(misfit.mean())
+        self.data_misfit_std = float(misfit.std())
+        self.prior_data_misfit_mean = self.data_misfit_mean
+        self.prior_data_misfit_std = self.data_misfit_std
+
+        self.log_update(success=True, prior_run=True)
+
+    # ------------------------------------------------------------------
+    # Points in a run
+    # ------------------------------------------------------------------
+    def run_forecast(self, state):
+        """Forecast ``state``, then run the post-forecast step.
+
+        Returns the state to carry forward -- the same one unless
+        :meth:`after_forecast` replaced members in it.
+        """
+        self.ensemble.forecast(state)
+        return self.after_forecast(state)
+
+    def after_prior_forecast(self) -> None:
+        """Handle the prior forecast: prior QA, saved artifacts.
+
+        Outlier replacement is not done here. The prior goes through
+        :meth:`after_forecast` like every other forecast, so it has already
+        happened by the time this runs -- and before :meth:`record_prior_score`
+        computes the misfit, which is the order that matters.
+        """
+        self.qaqc = self._build_qaqc()
+
+        self._run_prior_quality_assurance()
+        self._save_prior_forecast()
+        if self._savedata_keys:
+            self._save_iteration_data()
+        if "iterinfo" in self.keys_da:
+            self._save_iteration_information()
+
+    def after_analysis(self) -> None:
+        """Between analysis and forecast.
+
+        The odd one out: it marks a point *inside* :meth:`update_step`, and
+        this class does not dictate the shape of a step, so a scheme calls it
+        itself. The rest of the hooks here are called by
+        :meth:`run_assimilation`. Nothing runs here at present; it used to
+        refresh QA/QC's variance after data screening, which is no longer
+        supported.
+        """
+
+    def after_forecast(self, state):
+        """Between forecast and scoring: replace outlier members.
+
+        Ordering matters -- outliers are replaced before the misfit is scored,
+        so the replacement feeds into the number the scheme sees. The
+        resampled state is returned rather than written back, so the caller
+        keeps ownership of what it is forecasting.
+        """
+        if "remove_outliers" in self.keys_da:
+            return self.ensemble.remove_outliers(state)
+        return state
+
+    def after_accepted_iteration(self) -> None:
+        """Persist iteration artifacts and run QA/QC after an accepted update."""
+        if "iterinfo" in self.keys_da:
+            self._save_iteration_information()
+        if self._savedata_keys:
+            self._save_iteration_data()
+
+        if self.qaqc is not None:
+            if "qc" in self.keys_da:
+                self._set_qaqc()
+                self.qaqc.calc_da_stat()
+            if "qa" in self.keys_da:
+                self._set_qaqc()
+                self.qaqc.calc_mahalanobis((1, "time", 2, "time", 1, None, 2, None))
+                self.qaqc.calc_kg()
+
+
+    def after_loop(self, converged: bool) -> None:
+        """Save the posterior and the reason the run stopped."""
+        if self._saving_enabled:
+            self._save_posterior_results()
+            self._save_stop_reason(converged)
+        self._log_convergence_summary(converged)
+
+    # ------------------------------------------------------------------
+    # Shared convergence criteria
+    # ------------------------------------------------------------------
+    def check_misfit_convergence(self) -> bool:
+        """Check convergence on the relative change in mean data misfit."""
+        if self.prev_data_misfit_mean is None or self.data_misfit_mean is None:
+            return False
+        prev = np.mean(self.prev_data_misfit_mean)
+        if prev == 0:
+            return False
+        change = abs(np.mean(self.data_misfit_mean) - prev)
+        if change < self.misfit_tol * abs(prev):
+            self.conv_msg = (
+                f"Data misfit change satisfies |Δd| < {self.misfit_tol}·|d_prev|"
+            )
+            self.why_stop["misfit_tol"] = True
+            return True
+        return False
+
+    def check_state_convergence(self) -> bool:
+        """Check convergence on the norm of the state update.
+
+        The counterpart of :meth:`popt.optimization_methods.optimizer_base.
+        OptimizerBase.check_state_convergence`, which compares ``xk`` against
+        ``xk_old``. ``enX_old`` is snapshotted by :meth:`run_assimilation`
+        before each attempt, but only when ``step_tol > 0`` -- see there for
+        why.
+
+        Opt-in in practice: every shipped scheme passes ``step_tol=0.0``,
+        because ``‖Δx‖₂`` over a state that mixes variables on different
+        scales (log-permeability alongside saturations, say) has no tolerance
+        that is meaningful across cases. The base default of ``1e-8`` is small
+        enough to mean "the state did not move at all" rather than being a
+        guess at a scale.
+        """
+        if self.enX_old is None:
+            return False
+        # A rejected step leaves enX untouched, so the norm would be exactly
+        # zero -- convergence on every rejection, when the scheme in fact
+        # failed to improve.
+        if not self.step_accepted:
+            return False
+        step_norm = np.linalg.norm(np.asarray(self.ensemble.enX) - np.asarray(self.enX_old))
+        if step_norm < self.step_tol:
+            self.conv_msg = f"State change satisfies ‖Δx‖ < {self.step_tol}"
+            self.why_stop["step_tol"] = True
+            return True
+        return False
+
+    # ------------------------------------------------------------------
+    # Result handling
+    # ------------------------------------------------------------------
+    def _finalize(self, converged: bool) -> AssimilationResult:
+        """Populate the result object and log the stopping reason."""
+        self.results["nit"] = self.iteration
+        self.results["success"] = bool(converged)
+        self.results["message"] = self.conv_msg
+        self.results["why_stop"] = dict(self.why_stop)
+        self.results["data_misfit"] = self.data_misfit_mean
+        self.results["prior_data_misfit"] = self.prior_data_misfit_mean
+        self.results["x"] = getattr(self.ensemble, "enX", None)
+
+        if self.logger:
+            self.logger(f"Assimilation finished after {self.iteration} iteration(s): "
+                        f"{self.conv_msg or 'no stopping reason recorded'}")
+        return self.results
+
+    # ------------------------------------------------------------------
+    # QA/QC
+    # ------------------------------------------------------------------
+    def _build_qaqc(self) -> "QAQC | None":
+        """Create QA/QC helper only when requested by the configuration."""
+        qaqc_requested = (
+            "qa" in self.keys_da
+            or "qa" in self.sim.input_dict
+            or "qc" in self.keys_da
+        )
+        if not qaqc_requested:
+            return None
+
+        from pipt.misc_tools.qaqc_tools import QAQC  # heavy: matplotlib
+
+        return QAQC(
+            self.keys_da | self.sim.input_dict,
+            self.data_df,
+            self.data_var_df,
+            logger=self.logger,
+            prior_info=self.prior_info,
+            sim=self.sim,
+            ini_state=self.state_layout.to_dict(self.prior_enX),
+            localization=self.localization,
+            folder=Path(self.save_folder or ".") / "QAQC",
+        )
+
+    def _set_qaqc(self) -> None:
+        # QA/QC reads predictions cell by cell; hand it the frame view.
+        self.qaqc.set(self.pred_data.to_frame(), self.state_layout.to_dict(self.enX), self.lam)
+
+    def _run_prior_quality_assurance(self) -> None:
+        if self.qaqc is None or "qa" not in self.keys_da:
+            return
+
+        self._set_qaqc()
+        self.qaqc.calc_mahalanobis((1, "time", 2, "time", 1, None, 2, None))
+        self.qaqc.calc_coverage()
+        self.qaqc.calc_kg({"plot_all_kg": True, "only_log": False, "num_store": 5})
+
+    # ------------------------------------------------------------------
+    # From an analysis result to a trial state
+    # ------------------------------------------------------------------
+    def propose_state(self, result, step_scale=1.0):
+        """The trial state an analysis result implies.
+
+        Parameters
+        ----------
+        result : AnalysisResult or array-like
+            What ``self.update(...)`` returned. A plain array is a
+            state-space step.
+        step_scale : float, optional
+            Step length applied to the step (GN-EnRML's ``gamma``); 1 for
+            schemes without one.
+
+        Returns
+        -------
+        np.ndarray
+            The state to forecast. Weight-space results also advance
+            ``self.W`` from ``self.current_W``; the scheme commits ``W`` to
+            ``current_W`` when it accepts the step.
+        """
+        result = AnalysisResult.coerce(result)
+        self.step = result.step   # kept for ``savedata``; None for weight-space results
+        if result.step is not None:
+            return self.enX + step_scale * result.step
+        if result.w_step is not None:
+            # Ensemble subspace formulation (Evensen et al. 2019), W_0 = 0.
+            self.W = self.current_W + step_scale * result.w_step
+            return np.dot(self.prior_enX, (np.eye(self.ne) + self.W / np.sqrt(self.ne - 1)))
+        # Matrix formulation (Raanes et al. 2019), W_0 = I.
+        self.W = self.current_W + step_scale * result.W_step
+        X_p = self.prior_enX @ self.proj * np.sqrt(self.ne - 1)
+        return np.mean(self.prior_enX, axis=1, keepdims=True) + np.dot(X_p, self.W)
+
+    # ------------------------------------------------------------------
+    # Saving
+    # ------------------------------------------------------------------
+    def _save_prior_forecast(self) -> None:
+        if not self._saving_enabled:
+            return
+        try:
+            self.sim_data.to_pickle(self._save_path(self.PRIOR_FORECAST_FILE))
+        except Exception:
+            np.savez(self._save_path(self.PRIOR_FORECAST_FILE), sim_data=self.sim_data)
+
+    def _save_posterior_results(self) -> None:
+        """Save posterior state and forecast, falling back to pickle if needed."""
+        try:
+            np.savez(self._save_path(self.POSTERIOR_STATE_FILE), **self.state_layout.to_dict(self.enX))
+            self.sim_data.to_pickle(self._save_path(self.POSTERIOR_FORECAST_FILE))
+        except Exception:
+            with open(self._save_path(self.POSTERIOR_STATE_FILE), "wb") as file:
+                pickle.dump(self.state_layout.to_dict(self.enX), file)
+            with open(self._save_path(self.POSTERIOR_FORECAST_FILE), "wb") as file:
+                pickle.dump(self.sim_data, file)
+
+    def _save_stop_reason(self, converged: bool) -> None:
+        if converged:
+            reason = "Convergence criteria met. Stopping assimilation loop."
+        else:
+            reason = "Maximum iterations reached without convergence."
+        self.logger.info(reason)
+
+        why = self.why_stop.copy() if isinstance(self.why_stop, dict) else self.why_stop
+        if why is not None:
+            why["conv_string"] = reason
+
+        with open(self._save_path(self.STOP_REASON_FILE), "wb") as file:
+            pickle.dump(why, file, protocol=4)
+
+    def _log_convergence_summary(self, converged: bool) -> None:
+        # `logger` is None for a collaborator that has none at all, which the
+        # ensemble protocol allows; `log_update` guards the same way.
+        if self.logger is None or self.prev_data_misfit_mean is None:
+            return
+
+        # Said "Convergence was met." whatever had happened, including a run
+        # that stopped on the iteration limit.
+        out_str = "\n Convergence was met." if converged else "\n Stopped without convergence."
+        if self.prior_data_misfit_mean > self.data_misfit_mean:
+            out_str += (
+                f" Obj. function reduced from {self.prior_data_misfit_mean:0.1f} "
+                f"to {self.data_misfit_mean:0.1f}"
+            )
+        self.logger(out_str)
+
+    def _save_iteration_information(self) -> None:
+        """Run configured iteration-info hooks."""
+        for element in self._as_list(self.keys_da["iterinfo"]):
+            if ".py" not in element:
+                continue
+
+            module_name = element.removesuffix(".py")
+            iter_info_func = import_module(module_name)
+            iter_info_func.main(self)
+
+    @property
+    def _savedata_keys(self) -> list[str]:
+        """Variable names to record each iteration, from ``savedata``.
+
+        ``analysisdebug`` is the old spelling and is still honoured, with a
+        deprecation warning. The two are not merged: a config carrying both is
+        almost certainly mid-migration, and silently unioning them would hide
+        whichever one the user forgot to delete.
+        """
+        if "savedata" in self.keys_da:
+            return self._as_list(self.keys_da["savedata"])
+        if "analysisdebug" in self.keys_da:
+            warnings.warn(
+                "The 'analysisdebug' config key is deprecated; rename it to "
+                "'savedata'. Output files are now 'assimilation_result_{i}.npz' "
+                "rather than 'debug_analysis_step_{i}.npz'.",
+                DeprecationWarning,
+                stacklevel=2,
+            )
+            return self._as_list(self.keys_da["analysisdebug"])
+        return []
+
+    def _save_iteration_data(self) -> None:
+        """Save the scheme attributes named by ``savedata``.
+
+        One file per iteration, ``assimilation_result_{iteration}.npz``, with
+        iteration 0 describing the prior -- the assimilation counterpart of
+        popt's ``optimize_result_{i}.npz``. ``state`` is special-cased: it
+        expands to one array per state variable rather than a single entry.
+
+        A name the scheme does not carry is reported and skipped rather than
+        failing the run, since a variable can legitimately be absent for a
+        given scheme -- ``lam`` exists for the Levenberg-Marquardt family and
+        not for ES-MDA.
+        """
+        save_dict: dict[str, Any] = {}
+
+        for save_type in self._savedata_keys:
+            if hasattr(self, save_type):
+                save_attr = getattr(self, save_type)
+                if isinstance(save_attr, (pd.DataFrame, PETDataFrame)):
+                    save_dict[save_type] = save_attr.to_dict(orient="records")
+                elif hasattr(save_attr, "matrix"):
+                    save_dict[save_type] = save_attr.matrix   # PredictedData: the (nd, ne) matrix
+                else:
+                    save_dict[save_type] = save_attr
+            elif save_type == "state":
+                save_dict.update(self._state_debug_dict())
+            else:
+                warnings.warn(
+                    f"Cannot save '{save_type}' at iteration {self.iteration}: "
+                    f"neither {type(self).__name__} nor its ensemble has an "
+                    f"attribute by that name.",
+                    stacklevel=2,
+                )
+
+        save_dict["savefolder"] = self.save_folder
+        at.save_assimilation_result(self.iteration, **save_dict)
+
+    def _state_debug_dict(self) -> dict[str, Any]:
+        if getattr(self.ensemble, "multilevel", None) is not None:
+            return {
+                f"state_level{level}": self.state_layout.to_dict(self.enX[level])
+                for level in range(self.ensemble.tot_level)
+            }
+        return self.state_layout.to_dict(self.enX)
+
+    @staticmethod
+    def _as_list(value: Any) -> list[Any]:
+        return value if isinstance(value, list) else [value]
+
+    # ------------------------------------------------------------------
+    # Paths
+    # ------------------------------------------------------------------
+    def _save_path(self, filename: str) -> str:
+        if self.save_folder is None:
+            raise RuntimeError("Cannot save results because saving is disabled.")
+        os.makedirs(self.save_folder, exist_ok=True)
+        return os.path.join(self.save_folder, filename)
+    # ------------------------------------------------------------------
+    # Restart hooks required by RestartMixin
+    # ------------------------------------------------------------------
+    RESTART_ATTRIBUTES: tuple = ()
+    """Attributes a scheme needs restored to resume mid-run: what its
+    iterations change and what it drew at construction (perturbed
+    observations, a damping parameter). The loop's own bookkeeping and the
+    ensemble's state are covered by the base state; a subclass only names what
+    it adds. Missing names are skipped, so a scheme that has not yet set one
+    of them checkpoints fine."""
+
+    def _get_restart_state(self) -> dict:
+        return {name: getattr(self, name) for name in self.RESTART_ATTRIBUTES if hasattr(self, name)}
+
+    def _set_restart_state(self, state: dict) -> None:
+        for name, value in state.items():
+            setattr(self, name, value)
+
+    def _get_base_restart_state(self) -> dict:
+        """Serialize the loop's bookkeeping and the ensemble's state."""
+        return {
+            "iteration": self.iteration,
+            "data_misfit": self.data_misfit_mean,
+            "prior_data_misfit": self.prior_data_misfit_mean,
+            "data_misfit_std": self.data_misfit_std,
+            "prior_data_misfit_std": getattr(self, "prior_data_misfit_std", None),
+            "prev_data_misfit": self.prev_data_misfit_mean,
+            "prev_data_misfit_std": getattr(self, "prev_data_misfit_std", None),
+            "ensemble_misfit": getattr(self, "ensemble_misfit", None),
+            "conv_msg": self.conv_msg,
+            "why_stop": dict(self.why_stop),
+            "ensemble": self.ensemble.restart_state(),
+        }
+
+    def _set_base_restart_state(self, state: dict) -> None:
+        """Restore the loop's bookkeeping and the ensemble's state."""
+        self.iteration = state["iteration"]
+        self.data_misfit_mean = state["data_misfit"]
+        self.prior_data_misfit_mean = state["prior_data_misfit"]
+        self.data_misfit_std = state["data_misfit_std"]
+        self.prior_data_misfit_std = state.get("prior_data_misfit_std")
+        self.prev_data_misfit_mean = state["prev_data_misfit"]
+        self.prev_data_misfit_std = state.get("prev_data_misfit_std")
+        if state.get("ensemble_misfit") is not None:
+            self.ensemble_misfit = state["ensemble_misfit"]
+        self.conv_msg = state.get("conv_msg", "")
+        self.why_stop = dict(state.get("why_stop", {}))
+        self.ensemble.restore_restart_state(state["ensemble"])
+
+    # ------------------------------------------------------------------
+    # Convenience entry point
+    # ------------------------------------------------------------------
+    @classmethod
+    def assimilate(cls, *args, **options) -> "AssimilationResult":
+        """Construct the scheme and run it to completion.
+
+        The assimilation counterpart of ``scipy.optimize.minimize``: one call
+        that builds the scheme, runs every iteration, and returns the outcome.
+        Use it when the scheme object itself is not needed afterwards; when it
+        is, construct the class and call :meth:`run_assimilation` instead.
+
+        Every argument is forwarded verbatim to the constructor, so this accepts
+        whatever the scheme accepts rather than imposing a second signature.
+
+        Parameters
+        ----------
+        *args
+            Positional arguments for the constructor. For the shipped PIPT
+            schemes that is ``(keys_da, keys_en, sim)`` -- the parsed
+            data-assimilation config, the parsed ensemble config, and the
+            forward simulator -- from which the scheme builds its own ensemble.
+            A scheme written directly against the collaborator protocol is
+            handed its ensemble here instead.
+        **options
+            Keyword arguments for the constructor, such as ``analysis`` to
+            override the flavour named in the config.
+
+        Returns
+        -------
+        AssimilationResult
+            Outcome of the run. ``x`` is the posterior state ensemble, ``nit``
+            the number of accepted iterations, ``data_misfit`` and
+            ``prior_data_misfit`` the final and initial mean misfits, and
+            ``message`` the reason the run stopped.
+
+        Examples
+        --------
+        >>> keys_da, keys_sim, keys_en = read_config.read("case.toml")
+        >>> result = ESMDA.assimilate(keys_da, keys_en, flow(keys_sim))
+        >>> result.prior_data_misfit, result.data_misfit
+        (539.2, 70.1)
+
+        Overriding the flavour named in the config:
+
+        >>> result = ESMDA.assimilate(keys_da, keys_en, sim, analysis="subspace")
+
+        Notes
+        -----
+        ``success`` reports whether the run stopped on a convergence criterion
+        rather than by exhausting ``maxiter``. Schemes with a fixed iteration
+        schedule -- ES-MDA in particular -- therefore finish normally with
+        ``success=False``, which is expected rather than a failure.
+
+        See Also
+        --------
+        run_assimilation : Run an already-constructed scheme.
+        """
+        return cls(*args, **options).run_assimilation()
diff --git a/src/pipt/update_schemes/enkf.py b/src/pipt/update_schemes/enkf.py
index 11c4a399..782347cc 100644
--- a/src/pipt/update_schemes/enkf.py
+++ b/src/pipt/update_schemes/enkf.py
@@ -3,244 +3,264 @@
 """
 # External imports
 import numpy as np
-from scipy.linalg import solve
 from copy import deepcopy
-from geostat.decomp import Cholesky                     # Making realizations
+from misc.sampling import gen_real
 
 # Internal imports
-from pipt.loop.ensemble import Ensemble
+from pipt.update_schemes.core import AssimilationScheme, StepReport, restart_options
+from pipt.update_schemes.analysis.approx import approx_update
+from pipt.update_schemes.analysis.subspace import subspace_update
 # Misc. tools used in analysis schemes
-from pipt.misc_tools import analysis_tools as at
-import pipt.misc_tools.ensemble_tools as entools
-
-from pipt.update_schemes.update_methods_ns.approx_update import approx_update
-from pipt.update_schemes.update_methods_ns.full_update import full_update
-from pipt.update_schemes.update_methods_ns.subspace_update import subspace_update
-
-
-class enkfMixIn(Ensemble):
+import pipt.misc_tools.extract_tools as extract
+
+
+
+class EnKF(AssimilationScheme):
+    """Ensemble Kalman Filter (EnKF).
+
+    Assimilates data sequentially, updating the state once per group of
+    observations in the order given by ``assimindex``. Each update applies the
+    Kalman equations with the covariances approximated from the ensemble:
+
+    .. math::
+
+        m \\leftarrow m + C_{md} (C_{dd} + C_d)^{-1} (d_{obs} - g(m))
+
+    There is no damping and no rejection: every step is accepted, and the run
+    ends once the data groups are exhausted.
+
+    Parameters
+    ----------
+    keys_da : dict
+        Parsed ``dataassim`` configuration. Besides the keys every scheme
+        reads -- ``data``, ``datavar``, ``obsname``, ``truedataindex`` -- the
+        ones this scheme acts on are listed under Notes.
+    keys_en : dict
+        Parsed ``ensemble`` configuration: ensemble size ``ne``, the ``state``
+        variable names, and the ``prior_`` blocks describing each.
+    sim : object
+        Forward simulator instance, e.g. ``simulator.opm.flow``.
+    analysis : {'approx', 'full', 'subspace'}, optional
+        Analysis flavour, i.e. how the ensemble-approximated sensitivity is
+        inverted. Defaults to the ``analysis`` key in ``keys_da``, falling back
+        to ``'approx'``. The flavours differ in cost and in how they handle a
+        rank-deficient ensemble; they solve the same update equation.
+
+    Attributes
+    ----------
+    ensemble : pipt.ensembles.AssimilationEnsemble
+        Collaborator holding the state realisations, observed data and
+        simulator. Its state is exposed as properties on the scheme, so
+        ``scheme.enX`` and ``scheme.keys_da`` read straight through.
+    analysis : pipt.update_schemes.analysis.AnalysisBase
+        The bound analysis object. Note the constructor takes ``analysis`` as
+        a *name* and this attribute holds the resulting object, the way
+        ``Model(optimizer="adam").optimizer`` is an optimizer instance.
+    analysis_name : str
+        The flavour name that was resolved, e.g. ``'approx'``.
+    iteration : int
+        Accepted iterations completed so far.
+    data_misfit, prior_data_misfit : float
+        Current and initial mean data misfit.
+
+    Notes
+    -----
+    ``assimindex`` determines the grouping and ordering of the sequential
+    updates. If all data are to be assimilated in a single step, use :class:`ES`,
+    which is this scheme specialised to one group.
+
+    ``energy`` sets the fraction of singular values retained in the truncated
+    SVD (default 0.98); values above 1 are read as percentages.
+
+    Every data group is assimilated exactly once, so the prior-increment term
+    that distinguishes ``full`` from ``approx`` is never reached: ``"full"``
+    is pointed at the same class as ``"approx"`` in
+    :attr:`COMPATIBLE_ANALYSES`. :class:`ES` inherits this.
+
+    Examples
+    --------
+    >>> result = EnKF.assimilate(keys_da, keys_en, flow(keys_sim))
+
+    References
+    ----------
+    Evensen, *Data Assimilation: The Ensemble Kalman Filter* [`evensen2009a`][].
+
+    See Also
+    --------
+    ES : All-data-at-once form of the same update.
     """
-    Straightforward EnKF analysis scheme implementation. The sequential updating can be done with general grouping and
-    ordering of data. If only one-step EnKF is to be done, use `es` instead.
-    """
-
-    def __init__(self, keys_da, keys_en, sim):
-        """
-        The class is initialized by passing the PIPT init. file upwards in the hierarchy to be read and parsed in
-        `pipt.input_output.pipt_init.ReadInitFile`.
-        """
-        # Pass the init_file upwards in the hierarchy
-        super().__init__(keys_da, keys_en, sim)
-
-        self.prev_data_misfit = None
-
-        if self.restart is False:
-            self.prior_enX = deepcopy(self.enX)
-            self.list_states = list(self.idX.keys())
 
-            # At the moment, the iterative loop is threated as an iterative smoother an thus we check if assim. indices
-            # are given as in the Simultaneous loop.
-            self.check_assimindex_simultaneous()
+    # Neither this class nor ES revisit a data group, so the prior-increment
+    # term "full" adds over "approx" never applies -- the two produce
+    # identical output (pinned by the characterisation suite), just through
+    # more expensive machinery for "full". Rather than special-case that in
+    # code, "full" is simply pointed at the same class as "approx" here.
+    COMPATIBLE_ANALYSES = {
+        "approx": approx_update,
+        "full": approx_update,
+        "subspace": subspace_update,
+    }
 
-            self.assim_index = [self.keys_da['obsname'], self.keys_da['assimindex'][0]]
-            self.list_datatypes, self.list_act_datatypes = at.get_list_data_types(self.obs_data, self.assim_index)
+    RESTART_ATTRIBUTES = ("enObs", "enObs_conv", "scale_data")
 
+    def __init__(self, keys_da, keys_en, sim, analysis=None, ensemble=None):
+        """Build the ensemble from the config and bind the analysis.
 
-            # Extract no. assimilation steps from MDA keyword in DATAASSIM part of init. file and set this equal to
-            # the number of iterations pluss one. Need one additional because the iter=0 is the prior run.
-            self.max_iter = len(self.keys_da['assimindex'])+1
-            self.iteration = 0
-            self.lam = 0  # set LM lamda to zero as we are doing one full update.
-
-            if 'energy' in self.keys_da:
-                # initial energy (Remember to extract this)
-                self.trunc_energy = self.keys_da['energy']
-                if self.trunc_energy > 1:  # ensure that it is given as percentage
-                    self.trunc_energy /= 100.
-            else:
-                self.trunc_energy = 0.98
-
-            # Get the perturbed observations and observation scaling
-            self.vecObs, self.enObs = self.set_observations()
-            self.enObs_conv = deepcopy(self.enObs)
+        See the class docstring for the parameters.
+        """
+        # Build the collaborator, then hand it to the scheme base -- which
+        # adopts the ensemble's own logger, so log output is unchanged.
+        ensemble = self.build_ensemble(keys_da, keys_en, sim, ensemble)
+        # Zero tolerances switch off the base class's generic convergence
+        # criteria; this scheme decides in check_convergence(). See
+        # AssimilationScheme's `misfit_tol`/`step_tol` docs for why.
+        super().__init__(ensemble, misfit_tol=0.0, step_tol=0.0, **restart_options(ensemble.keys_da))
+
+        # Flavour is a parameter, so it selects an analysis object not a class.
+        self.bind_analysis(self.resolve_analysis(analysis, ensemble.keys_da))
+
+        self.prev_data_misfit_mean = None
+
+        self.ensemble.prior_enX = deepcopy(self.enX)
+        self.ensemble.list_states = list(self.idX.keys())
+
+        # At the moment, the iterative loop is threated as an iterative smoother an thus we check if assim. indices
+        # are given as in the Simultaneous loop.
+        self.ensemble.check_assimindex_simultaneous()
+
+        self.ensemble.assim_index = [self.keys_da['obsname'], self.keys_da['assimindex'][0]]
+        self.ensemble.list_datatypes = self.keys_da['datatype']
+
+
+        # One update per assimilation index.
+        self.maxiter = len(self.keys_da['assimindex'])
+        self.iteration = 0
+        # Mirrored for ensemble-side helpers that consult it.
+        self.ensemble.iteration = 0
+        self.lam = 0  # set LM lamda to zero as we are doing one full update.
+
+        if 'energy' in self.keys_da:
+            # initial energy (Remember to extract this)
+            self.trunc_energy = self.keys_da['energy']
+            if self.trunc_energy > 1:  # ensure that it is given as percentage
+                self.trunc_energy /= 100.
+        else:
+            self.trunc_energy = 0.98
 
-            self._ext_scaling()
+        # Get the perturbed observations and observation scaling
+        self.vecObs = self.ensemble.obs_vector
+        self.enObs = self.ensemble.perturb_observations(self.vecObs)
+        self.ensemble._ext_scaling()
 
     def calc_analysis(self):
         """
         Calculate the analysis step of the EnKF procedure. The updating is done using the Kalman filter equations, using
         svd for numerical stability. Localization is available.
         """
-        # If this is initial analysis we calculate the objective function for all data. In the final convergence check
-        # we calculate the posterior objective function for all data
-        if not hasattr(self, 'prior_data_misfit'):
-            assim_index = [self.keys_da['obsname'], list(
-                np.concatenate(self.keys_da['assimindex']))]
-            list_datatypes, list_active_dataypes = at.get_list_data_types(
-                self.obs_data, assim_index)
-            # if not hasattr(self, 'cov_data'):
-            #     self.full_cov_data = at.gen_covdata(
-            #         self.datavar, assim_index, list_datatypes)
-            # else:
-            #     self.full_cov_data = self.cov_data
-
-            # #obs_data_vector, pred_data = at.aug_obs_pred_data(
-            # #    self.obs_data, self.pred_data, assim_index, list_datatypes)
-            
-            _, enPred = at.aug_obs_pred_data(
-                self.obs_data, 
-                self.pred_data, 
-                assim_index, 
-                list_datatypes
-            )
-
-            # # Generate realizations of the observed data
-            # generator = Cholesky()  # Initialize GeoStat class for generating realizations
-            # self.enObs = generator.gen_real(
-            #     vecObs, 
-            #     self.full_cov_data, 
-            #     self.ne
-            # )
-
-            # Calc. misfit for the initial iteration
-            data_misfit = at.calc_objectivefun(self.enObs, enPred, self.scale_data)
-
-            # Store the (mean) data misfit (also for conv. check)
-            self.data_misfit = np.mean(data_misfit)
-            self.prior_data_misfit = np.mean(data_misfit)
-            self.data_misfit_std = np.std(data_misfit)
-
-            self.logger.info(
-                f'Prior run complete with data misfit: {self.prior_data_misfit:0.1f}.')
-
-        # Get assimilation order as a list
-        # must subtract one to be inline
-        self.assim_index = [self.keys_da['obsname'], self.keys_da['assimindex'][self.iteration-1]]
-
-        # Get list of data types to be assimilated and of the free states. Do this once, because listing keys from a
-        # Python dictionary just when needed (in different places) may not yield the same list!
-        self.list_datatypes, list_active_dataypes = at.get_list_data_types(
-            self.obs_data, self.assim_index)
-
         # Augment observed and predicted data
-        if ('emp_cov' in self.keys_da) and (self.keys_da['emp_cov'] == 'yes'):
-            _, self.enPred = at.aug_obs_pred_data(
-                self.obs_data, 
-                self.pred_data, 
-                self.assim_index,
-                self.list_datatypes
-            )
+        if extract.is_enabled(self.keys_da.get('emp_cov', False)):
+            self.enPred = self.pred_data.matrix
         else:
-            self.vecObs, self.enPred = at.aug_obs_pred_data(
-                self.obs_data, 
-                self.pred_data, 
-                self.assim_index,
-                self.list_datatypes
-            )
-            
-            self.cov_data = at.gen_covdata(
-                self.datavar, 
-                self.assim_index, 
-                self.list_datatypes
-            )
+            self.enPred = self.pred_data.matrix
+
+            #self.cov_data = at.gen_covdata(
+            #    self.datavar,
+            #    self.assim_index,
+            #    self.list_datatypes
+           # )
+            self.cov_data = self.ensemble.obs_variance
 
-            generator = Cholesky()  # Initialize GeoStat class for generating realizations
             self.data_random_state = deepcopy(np.random.get_state())
-            self.enObs, self.scale_data = generator.gen_real(
-                self.vecObs, 
-                self.cov_data, 
+            self.enObs, self.scale_data = gen_real(
+                self.vecObs,
+                self.cov_data,
                 self.ne,
+                rng=self.ensemble.rng,
                 return_chol=True
             )
 
         self.E = np.dot(self.enObs, self.proj)
 
         if 'localanalysis' in self.keys_da:
-            self.local_analysis_update()
+            self.ensemble.local_analysis_update()
+            # The one path that still writes ensemble.enX_temp, which nothing
+            # reads now -- so take its result explicitly.
+            proposed = getattr(self.ensemble, "enX_temp", None)
+            self.enX_proposal = self.enX if proposed is None else proposed
         else:
-            self.update(
-                enX = self.enX, 
-                enY = self.enPred, 
-                enE = self.enObs, 
-                prior = self.prior_enX
-            )
-            # Update the state ensemble and weights
-            if hasattr(self, 'step'):
-                self.enX_temp = self.enX + self.step
-            if hasattr(self, 'w_step'):
-                self.W = self.current_W + self.w_step
-                self.enX_temp = np.dot(self.prior_enX, (np.eye(self.ne) + self.W/np.sqrt(self.ne - 1)))
+            # Check for adjoint
+            if hasattr(self, 'adjoints'):
+                enAdj = self.adjoints   # (nd, nx, ne), None without adjoints
+            else:
+                enAdj = None
+
+            self.enX_proposal = self.propose_state(self.update(
+                enX = self.enX,
+                enY = self.enPred,
+                enE = self.enObs,
+                prior = self.prior_enX,
+                enAdj = enAdj
+            ))
 
             # Ensure limits are respected
             limits = {key: self.prior_info[key].get('limits', (None, None)) for key in self.idX.keys()}
-            self.enX_temp = entools.clip_matrix(self.enX_temp, limits, self.idX)
-
-    def check_convergence(self):
+            self.state_layout.clip(self.enX_proposal, limits)
+
+    # ------------------------------------------------------------------
+    # AssimilationScheme contract
+    # ------------------------------------------------------------------
+    def update_step(self) -> StepReport:
+        """Run one EnKF step: analysis, forecast, then score and commit.
+
+        Returns
+        -------
+        bool
+            Always ``True``. The EnKF applies one update per data group and
+            has no rejection path.
+        """
+        self.calc_analysis()
+        self.after_analysis()
+        state = self.run_forecast(self.enX_proposal)
+        self.score_and_commit()
+        return StepReport(accepted=True, misfit=self.ensemble_misfit,
+                          state=state)
+
+    def check_convergence(self) -> bool:
+        """The EnKF runs its full sweep of data groups; nothing stops early."""
+        return False
+
+    def score_and_commit(self):
         """
         Calculate the "convergence" of the method. Important to
         """
-        self.prev_data_misfit = self.prior_data_misfit
-        
-        # only calulate for the final (posterior) estimate
-        if self.iteration == len(self.keys_da['assimindex']):
-            assim_index = [self.keys_da['obsname'], list(
-                np.concatenate(self.keys_da['assimindex']))]
-            list_datatypes = self.list_datatypes
-
-            _, enPred = at.aug_obs_pred_data(
-                self.obs_data,
-                self.pred_data,
-                assim_index,
-                list_datatypes
-            )
+        self.prev_data_misfit_mean = self.prior_data_misfit_mean
 
-            data_misfit = at.calc_objectivefun(self.enObs, enPred, self.full_cov_data)
-            self.data_misfit = np.mean(data_misfit)
+        # only calulate for the final (posterior) estimate
+        if self.iteration + 1 == len(self.keys_da['assimindex']):
+            data_misfit = self.score()
+            self.ensemble_misfit = data_misfit
+            self.data_misfit_mean = np.mean(data_misfit)
             self.data_misfit_std = np.std(data_misfit)
 
         else:  # sequential updates not finished. Misfit is not relevant
-            self.data_misfit = self.prior_data_misfit
+            self.data_misfit_mean = self.prior_data_misfit_mean
 
         # Logical variables for conv. criteria
-        why_stop = {'rel_data_misfit': 1 - (self.data_misfit / self.prev_data_misfit),
-                    'data_misfit': self.data_misfit,
-                    'prev_data_misfit': self.prev_data_misfit}
+        why_stop = {'rel_data_misfit': 1 - (self.data_misfit_mean / self.prev_data_misfit_mean),
+                    'data_misfit': self.data_misfit_mean,
+                    'prev_data_misfit': self.prev_data_misfit_mean}
 
         # Update state ensemble
-        self.enX = deepcopy(self.enX_temp)
-        self.enX_temp = None
 
-        if self.data_misfit == self.prev_data_misfit:
+        if self.data_misfit_mean == self.prev_data_misfit_mean:
             self.logger.info(
                 f'EnKF update {self.iteration} complete!')
         else:
-            if self.data_misfit < self.prior_data_misfit:
+            if self.data_misfit_mean < self.prior_data_misfit_mean:
                 self.logger.info(
-                    f'EnKF update complete! Objective function decreased from {self.prior_data_misfit:0.1f} to {self.data_misfit:0.1f}.')
+                    f'EnKF update complete! Objective function decreased from {self.prior_data_misfit_mean:0.1f} to {self.data_misfit_mean:0.1f}.')
             else:
                 self.logger.info(
-                    f'EnKF update complete! Objective function increased from {self.prior_data_misfit:0.1f} to {self.data_misfit:0.1f}.')
-        # Return conv = False, why_stop var.
-        return False, True, why_stop
-
-
-class enkf_approx(enkfMixIn, approx_update):
-    """
-    MixIn the main EnKF update class with the standard analysis scheme.
-    """
-    pass
-
-
-class enkf_full(enkfMixIn, approx_update):
-    """
-    MixIn the main EnKF update class with the standard analysis scheme. Note that this class is only included for
-    completness. The EnKF does not iterate, and the standard scheme is therefor always applied.
-    """
-    pass
-
-
-class enkf_subspace(enkfMixIn, subspace_update):
-    """
-    MixIn the main EnKF update class with the subspace analysis scheme.
-    """
-    pass
+                    f'EnKF update complete! Objective function increased from {self.prior_data_misfit_mean:0.1f} to {self.data_misfit_mean:0.1f}.')
+        self.why_stop = why_stop
+        return why_stop
diff --git a/src/pipt/update_schemes/enrml.py b/src/pipt/update_schemes/enrml.py
index 7b0c5450..abc97310 100644
--- a/src/pipt/update_schemes/enrml.py
+++ b/src/pipt/update_schemes/enrml.py
@@ -2,1168 +2,675 @@
 EnRML type schemes
 """
 # External imports
-import pipt.misc_tools.analysis_tools as at
 import pipt.misc_tools.extract_tools as extract
-import pipt.misc_tools.ensemble_tools as entools
-import pipt.misc_tools.data_tools as dtools
 
-
-from geostat.decomp import Cholesky
-from pipt.loop.ensemble import Ensemble
-from pipt.update_schemes.update_methods_ns.subspace_update import subspace_update
-from pipt.update_schemes.update_methods_ns.subspace2_update import subspace2_update
-from pipt.update_schemes.update_methods_ns.full_update import full_update
-from pipt.update_schemes.update_methods_ns.approx_update import approx_update
-from pipt.update_schemes.update_methods_ns.margIS_update import margIS_update
-
-import sys
-import pkgutil
-import inspect
+from pipt.update_schemes.core import AssimilationScheme, StepReport, restart_options
+from pipt.update_schemes.analysis.approx import approx_update
+from pipt.update_schemes.analysis.full import full_update
+from pipt.update_schemes.analysis.subspace import subspace_update
+from pipt.update_schemes.analysis.subspace2 import subspace2_update
 import numpy as np
 import copy as cp
-from scipy.linalg import cholesky, solve, inv, lu_solve, lu_factor
-
-import importlib.util
-
-# List all available packages in the namespace package
-# Import those that are present
-import pipt.update_schemes.update_methods_ns as ns_pkg
-tot_ns_pkg = []
-# extract all class methods from namespace
-for finder, name, ispkg in pkgutil.walk_packages(ns_pkg.__path__):
-    spec = finder.find_spec(name)
-    _module = importlib.util.module_from_spec(spec)
-    spec.loader.exec_module(_module)
-    tot_ns_pkg.extend(inspect.getmembers(_module, inspect.isclass))
-
-# import standard libraries
 
-# Check and import (if present) from other namespace packages
-#if 'margIS_update' in [el[0] for el in tot_ns_pkg]:  # only compare package name
-#    from pipt.update_schemes.update_methods_ns.margIS_update import margIS_update
-#else:
-#    class margIS_update:
-#        pass
-
-# Internal imports
-from pipt.misc_tools.analysis_tools import aug_state
-
-
-class lmenrmlMixIn(Ensemble):
-    """
-    This is an implementation of EnRML using Levenberg-Marquardt. The update scheme is selected by a MixIn with multiple
-    update_methods_ns. This class must therefore facititate many different update schemes.
+# `analysis/margis.py` ships a real (if unfinished -- see its module
+# docstring) port of the margIS math, not an inert placeholder. The import is
+# still guarded in case a private overlay replaces the module with a complete
+# implementation.
+#
+# NOTE: this used to walk `update_methods_ns` with pkgutil so a private
+# namespace package could drop a module in alongside it. That package is now
+# `pipt.update_schemes.analysis`, so a private overlay must target the new
+# name; the walk itself is gone, since executing every module in the package to
+# discover one class is a costly way to express an optional import.
+try:
+    from pipt.update_schemes.analysis.margis import margIS_update
+except ImportError:  # pragma: no cover - depends on a package outside this repo
+    class margIS_update:
+        pass
+
+
+__all__ = [
+    'IterativeEnRML',
+    'LMEnRML',
+    'GNEnRML',
+]
+
+
+class IterativeEnRML(AssimilationScheme):
+    """What LM-EnRML and GN-EnRML share: everything but the control parameter.
+
+    Both solve the randomized maximum likelihood problem by repeated
+    linearisation, accept or reject each step on the mean data misfit, retry
+    a rejected step from the same state inside :meth:`update_step`, and stop
+    on the relative misfit change, on ``max_inner_iter`` failed attempts in
+    one iteration, or on ``max_iter``. They differ only in the *control
+    parameter* that reacts to an attempt: LM-EnRML's damping :math:`\\lambda`
+    inflates the Hessian and grows on rejection; GN-EnRML's step length
+    :math:`\\gamma` scales the step and shrinks on rejection. A subclass
+    supplies that behaviour through the hooks below and nothing else.
+
+    Hooks
+    -----
+    ``_read_damping_options(options)``
+        Read the control parameter(s) from the ``iteration`` block.
+    ``_step_scale()``
+        Factor applied to the analysis step: 1 for LM-EnRML, :math:`\\gamma`
+        for GN-EnRML.
+    ``_record_control()``
+        Remember the control the attempt ran with, for the run table.
+    ``_control_exhausted()`` and ``_exhausted_message()``
+        Whether the control itself says stop (LM-EnRML: :math:`\\lambda \\ge`
+        ``lambda_max``), and the stop reason to report then.
+    ``_why_stop_control()``
+        The control's entries in ``why_stop``.
+    ``_on_improved()``
+        Accepted with a smaller misfit spread: relax the control.
+    ``_on_rejected()``
+        Rejected: tighten the control.
+    ``_give_up_message(attempt)``
+        Stop reason when ``max_inner_iter`` attempts all failed.
+    ``log_columns()``
+        The control's column in the run table.
     """
 
-    def __init__(self, keys_da, keys_en, sim):
-        """
-        The class is initialized by passing the PIPT init. file upwards in the hierarchy to be read and parsed in
-        `pipt.input_output.pipt_init.ReadInitFile`.
-        """
-        # Pass the init_file upwards in the hierarchy
-        super().__init__(keys_da, keys_en, sim)
-
-        if self.restart is False:
-            # Save prior state in separate variable
-            self.prior_enX = cp.deepcopy(self.enX) # not sure if this is wise!
-
-            # Set parameters needed for LM-EnRML
-            options = self.keys_da['iteration']
-            if isinstance(options, list):
-                options = extract.list_to_dict(options)
-
-            self.data_misfit_tol = options.get('data_misfit_tol', 0.01)
-            self.trunc_energy = options.get('energy', 0.95)
-            self.step_tol  = options.get('step_tol', 0.01)
-            self.lam       = options.get('lambda', 100)
-            self.lam_max   = options.get('lambda_max', 1e10)
-            self.lam_min   = options.get('lambda_min', 0.01)
-            self.gamma     = options.get('lambda_factor', 5)
-            self.iteration = 0
-
-            # Ensure that it is given as percentage
-            if self.trunc_energy > 1:
-                    self.trunc_energy /= 100.
-
-            # Initalize some variables
-            self.prev_data_misfit = None  # Data misfit at previous iteration
-
-            # Load ACTNUM if given
-            if 'actnum' in self.keys_da.keys():
-                try:
-                    self.actnum = np.load(self.keys_da['actnum'])['actnum']
-                except:
-                    print('ACTNUM file cannot be loaded!')
-            else:
-                self.actnum = None
+    # Drawn once at construction (the perturbed observations), derived from
+    # that draw on the first iteration (the subspace analysis's E), or carried
+    # from one iteration to the next: the misfit the acceptance test compares
+    # against, the committed W, and whether the last attempt declared
+    # convergence. Subclasses add their damping control.
+    RESTART_ATTRIBUTES = ("enObs", "scale_data", "E", "prev_ensemble_misfit", "W", "current_W", "_converged")
 
-            # At the moment, the iterative loop is threated as an iterative smoother and thus we check if assim. indices
-            # are given as in the Simultaneous loop.
-            self.check_assimindex_simultaneous()
-            self.assim_index = [self.keys_da['obsname'], self.keys_da['assimindex'][0]]
+    def __init__(self, keys_da, keys_en, sim, analysis=None, ensemble=None):
+        """Build the ensemble from the config (or take the one given) and bind the analysis.
 
-            # define the list of datatypes
-            self.list_datatypes, self.list_act_datatypes = at.get_list_data_types(self.obs_data, self.assim_index)
+        See the subclass docstrings for the parameters; ``ensemble`` is a
+        ready-made collaborator to run on instead of building one.
+        """
+        # The collaborator is handed to the scheme base, which adopts the
+        # ensemble's own logger, so log output is unchanged.
+        ensemble = self.build_ensemble(keys_da, keys_en, sim, ensemble)
+        # Zero tolerances switch off the base class's generic convergence
+        # criteria; this scheme decides in check_convergence(). See
+        # AssimilationScheme's `misfit_tol`/`step_tol` docs for why.
+        super().__init__(ensemble, misfit_tol=0.0, step_tol=0.0, **restart_options(ensemble.keys_da))
 
-            # Get the perturbed observations and observation scaling
-            self.data_random_state = cp.deepcopy(np.random.get_state())
-            self.vecObs, self.enObs = self.set_observations()
-            
-            # Get state scaling and svd of scaled prior
-            self._ext_scaling()
+        # Flavour is a parameter, so it selects an analysis object not a class.
+        self.bind_analysis(self.resolve_analysis(analysis, ensemble.keys_da))
 
-    
+        options = self.keys_da['iteration']
 
+        self.data_misfit_tol = options.get('data_misfit_tol', 0.01)
+        self.trunc_energy = options.get('energy', 0.95)
+        # How many times one iteration may retry before giving up. The
+        # retry loop lives inside update_step(), so this bounds it there.
+        self.max_inner_iter = options.get('max_inner_iter', 10)
+        self._read_damping_options(options)
+
+        # Ensure that it is given as percentage
+        if self.trunc_energy > 1:
+            self.trunc_energy /= 100.
+
+        # Initalize some variables
+        self.iteration = 0
+        # Mirrored for ensemble-side helpers that consult it.
+        self.ensemble.iteration = 0
+        # `max_iter` is the number of update iterations; the prior forecast is not one of them.
+        self.maxiter = extract.extract_maxiter(self.keys_da)
+        self._converged = False
+        self.ensemble.prior_enX = cp.deepcopy(self.enX)
+        self.prev_data_misfit_mean = None  # Data misfit at previous iteration
+        self.ensemble.list_datatypes = list(self.data_df.columns)
+
+        # Load ACTNUM if given
+        self.actnum = None
+        if 'actnum' in self.keys_da.keys():
+            try:
+                self.actnum = np.load(self.keys_da['actnum'])['actnum']
+            except Exception:
+                self.logger.info('ACTNUM file cannot be loaded!')
+
+        # At the moment, the iterative loop is threated as an iterative smoother and thus we check if assim. indices
+        # are given as in the Simultaneous loop.
+        self.ensemble.check_assimindex_simultaneous()
+        self.ensemble.assim_index = [self.keys_da['obsname'], self.keys_da['assimindex'][0]]
+
+        # Get the perturbed observations and scaling
+        self.data_random_state = cp.deepcopy(np.random.get_state())
+        self.vecObs = self.ensemble.obs_vector
+        self.enObs = self.ensemble.perturb_observations(self.vecObs)
+        self.ensemble._ext_scaling()
+
+    # ------------------------------------------------------------------
+    # Hooks a subclass supplies
+    # ------------------------------------------------------------------
+    def _read_damping_options(self, options):
+        raise NotImplementedError
+
+    def _step_scale(self):
+        return 1.0
+
+    def _record_control(self):
+        raise NotImplementedError
+
+    def _control_exhausted(self):
+        return False
+
+    def _exhausted_message(self):
+        raise NotImplementedError
+
+    def _why_stop_control(self):
+        raise NotImplementedError
+
+    def _on_improved(self):
+        raise NotImplementedError
+
+    def _on_rejected(self):
+        raise NotImplementedError
+
+    def _give_up_message(self, attempt):
+        raise NotImplementedError
+
+    # ------------------------------------------------------------------
+    # Shared machinery
+    # ------------------------------------------------------------------
     def calc_analysis(self):
-        """
-        Calculate the update step in LM-EnRML, which is just the Levenberg-Marquardt update algorithm with
-        the sensitivity matrix approximated by the ensemble.
-        """
+        """Compute the trial state: the analysis step, scaled and clipped."""
         # Get Ensemble of predicted data
-        _, self.enPred = at.aug_obs_pred_data(
-            self.obs_data,
-            self.pred_data,
-            self.assim_index,
-            self.list_datatypes
-        )
-
-        if self.iteration == 1:  # first iteration
-            
-            # Calculate the prior data misfit
-            data_misfit = at.calc_objectivefun(
-                pert_obs=self.enObs,
-                pred_data=self.enPred,
-                Cd=self.cov_data
-            )
-
-            # Store the (mean) data misfit (also for conv. check)
-            self.ensemble_misfit = data_misfit
-            self.data_misfit = np.mean(data_misfit)
-            self.prior_data_misfit = np.mean(data_misfit)
-            self.data_misfit_std = np.std(data_misfit)
-
-            if self.lam == 'auto':
-                self.lam = (0.5 * self.prior_data_misfit)/self.enPred.shape[0]
-
-            # Log initial data misfit
-            self.log_update(success=True, prior_run=True)
+        self.enPred = self.pred_data.matrix
 
         if 'localanalysis' in self.keys_da:
-            self.local_analysis_update()
+            self.ensemble.local_analysis_update()
+            # The one path that still writes ensemble.enX_temp, which nothing
+            # reads now -- so take its result explicitly.
+            proposed = getattr(self.ensemble, "enX_temp", None)
+            self.enX_proposal = self.enX if proposed is None else proposed
         else:
-
             # Check for adjoint
             if hasattr(self, 'adjoints'):
-                enAdj = dtools.merge_dataframes(self.adjoints)
-                enAdj = dtools.dataframe_to_matrix(enAdj) # Shape (nd, nx, ne)
+                enAdj = self.adjoints   # (nd, nx, ne), None without adjoints
             else:
                 enAdj = None
 
-            # Perform the update
-            self.update(
-                enX = self.enX, 
-                enY = self.enPred, 
-                enE = self.enObs, 
+            # Perform the update and turn its result into the trial state
+            self.enX_proposal = self.propose_state(self.update(
+                enX = self.enX,
+                enY = self.enPred,
+                enE = self.enObs,
                 # kwargs
                 prior = self.prior_enX,
                 enAdj = enAdj
-            )
+            ), step_scale=self._step_scale())
 
-            # Update the state ensemble and weights
-            if hasattr(self, 'step'):
-                self.enX_temp = self.enX + self.step
-            # This is the vector update following e.g. Evensen et al 2019 update for subspace
-            if hasattr(self, 'w_step'):
-                self.W = self.current_W + self.w_step
-                self.enX_temp = np.dot(self.prior_enX, (np.eye(self.ne) + self.W / np.sqrt(self.ne - 1)))
-            #This is the matrix update following e.g. Raanes et al 2019 update for subspace
-            if hasattr(self, 'W_step'):
-                self.W = self.current_W + self.W_step
-                X_p = self.prior_enX @ self.proj * np.sqrt(self.ne - 1)
-                self.enX_temp = np.mean(self.prior_enX, axis=1, keepdims=True) + np.dot(X_p, self.W)
-
-            if hasattr(self, 'sqrt_w_step'):
-                self.w = self.current_w + self.sqrt_w_step
-                Us, Ss, VsT = np.linalg.svd(self.S, full_matrices=False)
-                eps = 1e-8 * Ss[0]  # e.g., 1e-8 * largest
-                s_inv = 1.0 / np.sqrt(np.maximum(Ss, eps))
-                S_inv = np.diag(s_inv)
-                self.W = Us @ S_inv @ Us.T
-                X_p = self.prior_enX @ self.proj * np.sqrt(self.ne - 1)
-                x = np.mean(self.prior_enX, axis=1) + X_p @ self.w
-                self.enX_temp = np.repeat(x[:, None], self.ne, axis=1) + np.dot(X_p, self.W)
+            # Ensure limits are respected
+            limits = {key: self.prior_info[key].get('limits', (None, None)) for key in self.idX}
+            self.state_layout.clip(self.enX_proposal, limits)
 
+    def update_step(self) -> StepReport:
+        """Run one iteration, retrying until an attempt improves the misfit.
 
-            # Ensure limits are respected
-            limits = {key: self.prior_info[key].get('limits', (None, None)) for key in self.idX.keys()}
-            self.enX_temp = entools.clip_matrix(self.enX_temp, limits, self.idX)
+        The retry loop is here rather than in the base loop: one call is one
+        iteration, and the attempts it took to get there are this scheme's
+        business. That mirrors popt, where ``EnOpt.update_step`` backtracks
+        over its own step length and returns only once it has an improving
+        step or has run out of attempts.
 
-    def check_convergence(self):
-        """
-        Check if LM-EnRML have converged based on evaluation of change sizes of objective function, state and damping
-        parameter. 
+        Each attempt re-solves the analysis with the current control
+        parameter, forecasts the proposal and scores it. A worse misfit
+        tightens the control (:meth:`_on_rejected`) and tries again from the
+        *same* state -- nothing was committed -- so the retries cost
+        forecasts, not correctness.
 
         Returns
         -------
-        conv: bool
-            Logic variable telling if algorithm has converged
-        why_stop: dict
-            Dict. with keys corresponding to conv. criteria, with logical variable telling which of them that has been
-            met
-        """
-        # Get Ensemble of predicted data
-        _, enPred = at.aug_obs_pred_data(
-            self.obs_data,
-            self.pred_data,
-            self.assim_index,
-            self.list_datatypes
-        )
-
-        # Initialize the initial success value
-        success = False
-
-        # if inital conv. check, there are no prev_data_misfit
-        self.prev_data_misfit = self.data_misfit
-        self.prev_data_misfit_std = self.data_misfit_std
-
-        # Calc. std dev of data misfit (used to update lamda)
-        # mat_obs = np.dot(obs_data_vector.reshape((len(obs_data_vector),1)), np.ones((1, self.ne))) # use the perturbed
-        # data instead.
-
-        data_misfit = at.calc_objectivefun(self.enObs, enPred, self.cov_data)
-        self.ensemble_misfit = data_misfit
-        self.data_misfit = np.mean(data_misfit)
-        self.data_misfit_std = np.std(data_misfit)
-
-        # # Calc. mean data misfit for convergence check, using the updated state variable
-        # self.data_misfit = np.dot((mean_preddata - obs_data_vector).T,
-        #                      solve(cov_data, (mean_preddata - obs_data_vector)))
-
-        # Convergence check: Relative step size of data misfit or state change less than tolerance
-        if abs(1 - (self.data_misfit / self.prev_data_misfit)) < self.data_misfit_tol \
-                or self.lam >= self.lam_max:
-            # Logical variables for conv. criteria
-            why_stop = {'data_misfit_stop': 1 - (self.data_misfit / self.prev_data_misfit) < self.data_misfit_tol,
-                        'data_misfit': self.data_misfit,
-                        'prev_data_misfit': self.prev_data_misfit,
-                        'lambda': self.lam,
-                        'lambda_stop': self.lam >= self.lam_max}
-
-            if self.data_misfit >= self.prev_data_misfit:
-                success = False
-                self.log_update(success=success)
-                self.logger(
-                    f'Iterations have converged after {self.iteration} iterations. Objective function reduced '
-                    f'from {self.prior_data_misfit:0.1f} to {self.prev_data_misfit:0.1f}'
-            )
-            else:
-                self.log_update(success=True)
-                self.logger.info(
-                    f'Iterations have converged after {self.iteration} iterations. Objective function reduced '
-                    f'from {self.prior_data_misfit:0.1f} to {self.data_misfit:0.1f}'
-                )
-                
-            # Return conv = True, why_stop var.
-            return True, success, why_stop
-
-        else:  # conv. not met
-            # Logical variables for conv. criteria
-            why_stop = {'data_misfit_stop': 1 - (self.data_misfit / self.prev_data_misfit) < self.data_misfit_tol,
-                        'data_misfit': self.data_misfit,
-                        'prev_data_misfit': self.prev_data_misfit,
-                        'lambda': self.lam,
-                        'lambda_stop': self.lam >= self.lam_max}
-            
-
-            ###############################################
-            ##### update Lambda step-size values ##########
-            ###############################################
-            # If reduction in mean data misfit, reduce damping param
-            if self.data_misfit < self.prev_data_misfit and self.data_misfit_std < self.prev_data_misfit_std:
-
-                success = True
-                self.log_update(success=success)
-
-                # Reduce damping parameter
-                if self.lam > self.lam_min:
-                    self.lam = self.lam / self.gamma
-                    self.logger(f'λ reduced: {self.lam * self.gamma} ──> {self.lam}')
-
-                # Update state ensemble
-                self.enX = cp.deepcopy(self.enX_temp)
-                self.enX_temp = None
-
-                # Update ensemble weights
-                if hasattr(self, 'W'):
-                    self.current_W = cp.deepcopy(self.W)
-                if hasattr(self, 'w'):
-                    self.current_w = cp.deepcopy(self.w)
-
-
-            elif self.data_misfit < self.prev_data_misfit and self.data_misfit_std >= self.prev_data_misfit_std:
-
-                # accept itaration, but keep lam the same
-                success = True
-                self.log_update(success=success)
-                
-                # Update state ensemble
-                self.enX = cp.deepcopy(self.enX_temp)
-                self.enX_temp = None
-
-                # Update ensemble weights
-                if hasattr(self, 'W'):
-                    self.current_W = cp.deepcopy(self.W)
-                if hasattr(self, 'w'):
-                    self.current_w = cp.deepcopy(self.w)
-
-            else:  # Reject iteration, and increase lam
-                success = False
-                self.log_update(success=success)
-                self.lam = self.lam * self.gamma
-                # Increase damping parameter (divide calculations for ANALYSISDEBUG purpose)
-                self.logger(f'Data misfit increased! λ increased: {self.lam / self.gamma} ──> {self.lam}')
-
-            if not success:
-                # Reset the objective function after report
-                self.data_misfit = self.prev_data_misfit
-                self.data_misfit_std = self.prev_data_misfit_std
-
-            # Return conv = False, why_stop var.
-            return False, success, why_stop
-
-    def log_update(self, success, prior_run=False):
-        '''
-        Log the update results in a formatted table.
-        '''
-        info = {
-            "Iteration"     : f'{0 if prior_run else self.iteration}',
-            "Status"        : "Success" if (prior_run or success) else "Failed",
-            "Data Misfit"   : self.data_misfit,
-            "Change (%)"    : '',
-            "λ"             : self.lam
-        }
-        if not prior_run:
-            delta = 100*(self.data_misfit / self.prev_data_misfit - 1)
-            info["Change (%)"] = delta
-        
-        self.logger(**info)
-        
-
-
-
-class lmenrml_approx(lmenrmlMixIn, approx_update):
-    pass
-
-
-class lmenrml_full(lmenrmlMixIn, full_update):
-    pass
-
-
-class lmenrml_subspace(lmenrmlMixIn, subspace_update):
-    pass
-
-class lmenrml_subspace2(lmenrmlMixIn, subspace2_update):
-    pass
-
-class lmenrml_margIS(lmenrmlMixIn, margIS_update):
-    pass
-
-
-class gnenrmlMixIn(Ensemble):
-    """
-    This is an implementation of EnRML using the Gauss-Newton approach. The update scheme is selected by a MixIn with multiple
-    update_methods_ns. This class must therefore facititate many different update schemes.
-    """
-
-    def __init__(self, keys_da, keys_en, sim):
+        StepReport
+            ``accepted`` is whether an attempt improved the misfit. It is
+            ``False`` only when the scheme has also decided to stop, which
+            :meth:`check_convergence` then reports to the loop.
         """
-        The class is initialized by passing the PIPT init. file upwards in the hierarchy to be read and parsed in
-        `pipt.input_output.pipt_init.ReadInitFile`.
-        """
-        # Pass the init_file upwards in the hierarchy
-        super().__init__(keys_da, keys_en, sim)
-
-        if self.restart is False:
-            # Save prior state in separate variable
-            #self.prior_state = cp.deepcopy(self.state)
-            self.prior_enX = cp.deepcopy(self.enX) # not sure if this is wise!
-
-            # extract and save state scaling
-
-            # Extract parameters like conv. tol. and damping param. from ITERATION keyword in DATAASSIM
-            self._ext_iter_param()
-
-            # Within variables
-            self.prev_data_misfit = None  # Data misfit at previous iteration
-            if 'actnum' in self.keys_da.keys():
-                try:
-                    self.actnum = np.load(self.keys_da['actnum'])['actnum']
-                except:
-                    print('ACTNUM file cannot be loaded!')
-            else:
-                self.actnum = None
-            # At the moment, the iterative loop is threated as an iterative smoother and thus we check if assim. indices
-            # are given as in the Simultaneous loop.
-            self.check_assimindex_simultaneous()
-            # define the assimilation index
-            self.assim_index = [self.keys_da['obsname'], self.keys_da['assimindex'][0]]
-            
-            # define the list of datatypes
-            self.list_datatypes, self.list_act_datatypes = at.get_list_data_types(
-                self.obs_data, self.assim_index)
-            # Get the perturbed observations and observation scaling
-            self._ext_obs()
-            # Get state scaling and svd of scaled prior
-            self._ext_scaling()
-           
-            # ensure that the updates does not invoke the LM inflation of the Hessian.
-            self.lam = 0
-
-    def _ext_obs(self):
-
-        self.obs_data_vector, _ = at.aug_obs_pred_data(self.obs_data, self.pred_data, self.assim_index,
-                                                       self.list_datatypes)
-
-        # Generate the data auto-covariance matrix
-        if 'emp_cov' in self.keys_da and self.keys_da['emp_cov'] == 'yes':
-            if hasattr(self, 'cov_data'):  # cd matrix has been imported
-                tmp_E = np.dot(cholesky(self.cov_data).T,
-                               np.random.randn(self.cov_data.shape[0], self.ne))
-            else:
-                tmp_E = at.extract_tot_empirical_cov(
-                    self.datavar, self.assim_index, self.list_datatypes, self.ne)
-            # self.E = (tmp_E - tmp_E.mean(1)[:,np.newaxis])/np.sqrt(self.ne - 1)/
-            if 'screendata' in self.keys_da and self.keys_da['screendata'] == 'yes':
-                tmp_E = at.screen_data(tmp_E, self.aug_pred_data,
-                                       self.obs_data_vector, self.iteration)
-            self.E = tmp_E
-            self.real_obs_data = self.obs_data_vector[:, np.newaxis] - tmp_E
-
-            self.cov_data = np.var(self.E, ddof=1,
-                                   axis=1)  # calculate the variance, to be used for e.g. data misfit calc
-            # self.cov_data = ((self.E * self.E)/(self.ne-1)).sum(axis=1) # calculate the variance, to be used for e.g. data misfit calc
-            self.scale_data = np.sqrt(self.cov_data)
-        else:
-            if not hasattr(self, 'cov_data'):  # if cd is not loaded
-                self.cov_data = at.gen_covdata(
-                    self.datavar, self.assim_index, self.list_datatypes)
-            # data screening
-            if 'screendata' in self.keys_da and self.keys_da['screendata'] == 'yes':
-                self.cov_data = at.screen_data(
-                    self.cov_data, self.aug_pred_data, self.obs_data_vector, self.iteration)
-
-            init_en = Cholesky()  # Initialize GeoStat class for generating realizations
-            self.real_obs_data, self.scale_data = init_en.gen_real(self.obs_data_vector, self.cov_data, self.ne,
-                                                                   return_chol=True)
-
-    def _ext_state(self):
-        # get vector of scaling
-        self.state_scaling = at.calc_scaling(
-            self.prior_state, self.list_states, self.prior_info)
-
-        delta_scaled_prior = self.state_scaling[:, None] * \
-            np.dot(at.aug_state(self.prior_state, self.list_states), self.proj)
-
-        u_d, s_d, v_d = np.linalg.svd(delta_scaled_prior, full_matrices=False)
-
-        # remove the last singular value/vector. This is because numpy returns all ne values, while the last is actually
-        # zero. This part is a good place to include eventual additional truncation.
-        energy = 0
-        trunc_index = len(s_d) - 1  # inititallize
-        for c, elem in enumerate(s_d):
-            energy += elem
-            if energy / sum(s_d) >= self.trunc_energy:
-                trunc_index = c  # take the index where all energy is preserved
+        attempt = 0
+        while True:
+            self.calc_analysis()
+            self.after_analysis()
+            state = self.run_forecast(self.enX_proposal)
+            self.score_and_commit()
+
+            if self.step_accepted or self._converged:
                 break
-        u_d, s_d, v_d = u_d[:, :trunc_index +
-                            1], s_d[:trunc_index + 1], v_d[:trunc_index + 1, :]
-        self.Am = np.dot(u_d, np.eye(trunc_index+1) *
-                         ((s_d**(-1))[:, None]))  # notation from paper
-
-    def calc_analysis(self):
-        """
-        Calculate the update step in LM-EnRML, which is just the Levenberg-Marquardt update algorithm with
-        the sensitivity matrix approximated by the ensemble.
-
-        """
-
-        # reformat predicted data
-        _, self.aug_pred_data = at.aug_obs_pred_data(self.obs_data, self.pred_data, self.assim_index,
-                                                     self.list_datatypes)
 
-        if self.iteration == 1:  # first iteration
-            data_misfit = at.calc_objectivefun(
-                self.real_obs_data, self.aug_pred_data, self.cov_data)
+            attempt += 1
+            if attempt >= self.max_inner_iter:
+                # Reported as a stopping criterion, with its reason in
+                # `why_stop`: there is no smaller step left to try.
+                self._converged = True
+                self.conv_msg = self._give_up_message(attempt)
+                self.why_stop['inner_stop'] = True
+                self.logger.info(self.conv_msg)
+                break
 
-            # Store the (mean) data misfit (also for conv. check)
-            self.data_misfit = np.mean(data_misfit)
-            self.prior_data_misfit = np.mean(data_misfit)
-            self.data_misfit_std = np.std(data_misfit)
+        return StepReport(accepted=self.step_accepted, misfit=self.ensemble_misfit,
+                          state=state)
 
-            if self.gamma == 'auto':
-                self.gamma = 0.1
+    def check_convergence(self) -> bool:
+        """Report the verdict reached by the preceding :meth:`score_and_commit`."""
+        return self._converged
 
-        # Mean pred_data and perturbation matrix with scaling
-        if len(self.scale_data.shape) == 1:
-            self.pert_preddata = np.dot(np.expand_dims(self.scale_data ** (-1), axis=1),
-                                        np.ones((1, self.ne))) * np.dot(self.aug_pred_data, self.proj)
-        else:
-            self.pert_preddata = solve(
-                self.scale_data, np.dot(self.aug_pred_data, self.proj))
-
-        aug_state = at.aug_state(self.current_state, self.list_states)
-
-        self.update()  # run analysis
-        if hasattr(self, 'step'):
-            aug_state_upd = aug_state + self.gamma*self.step
-        if hasattr(self, 'w_step'):
-            self.W = self.current_W + self.gamma*self.w_step
-            aug_prior_state = at.aug_state(self.prior_state, self.list_states)
-            aug_state_upd = np.dot(aug_prior_state, (np.eye(
-                self.ne) + self.W / np.sqrt(self.ne - 1)))
-        if hasattr(self, 'sqrt_w_step'):  # if we do a sqrt update
-            self.w = self.current_w + self.gamma*self.sqrt_w_step
-            new_mean_state = self.mean_prior + np.dot(self.X, self.w)
-            u, sigma, v = np.linalg.svd(self.C_w, full_matrices=True)
-            sigma_inv_sqrt = np.diag([el_s ** (-1 / 2) for el_s in sigma])
-            C_w_inv_sqrt = np.dot(np.dot(u, sigma_inv_sqrt), v.T)
-            self.W = C_w_inv_sqrt * np.sqrt(self.ne - 1)
-            aug_state_upd = np.tile(new_mean_state, (self.ne, 1)
-                                    ).T + np.dot(self.X, self.W)
-
-        # Extract updated state variables from aug_update
-        self.state = at.update_state(aug_state_upd, self.state, self.list_states)
-        self.state = at.limits(self.state, self.prior_info)
-
-    def check_convergence(self):
-        """
-        Check if LM-EnRML have converged based on evaluation of change sizes of objective function, state and damping
-        parameter.
+    def score_and_commit(self):
+        """Score the forecast, decide on the attempt, and adjust the control.
 
         Returns
         -------
-        conv: bool
-            Logic variable telling if algorithm has converged
-        why_stop: dict
-            Dict. with keys corresponding to conv. criteria, with logical variable telling which of them that has been
-            met
+        why_stop : dict
+            The convergence criteria with their values, including the
+            control's own entries.
         """
-        # Prelude to calc. conv. check (everything done below is from calc_analysis)
-        if hasattr(self, 'list_datatypes'):
-            assim_index = [self.keys_da['obsname'], self.keys_da['assimindex'][0]]
-            list_datatypes = self.list_datatypes
-            cov_data = self.cov_data
-            obs_data_vector, pred_data = at.aug_obs_pred_data(self.obs_data, self.pred_data, assim_index,
-                                                              list_datatypes)
-            mean_preddata = np.mean(pred_data, 1)
-        else:
-            assim_index = [self.keys_da['obsname'], self.keys_da['assimindex'][0]]
-            list_datatypes, _ = at.get_list_data_types(self.obs_data, assim_index)
-            # cov_data = at.gen_covdata(self.datavar, assim_index, list_datatypes)
-            obs_data_vector, pred_data = at.aug_obs_pred_data(self.obs_data, self.pred_data, assim_index,
-                                                              list_datatypes)
-            # mean_preddata = np.mean(pred_data, 1)
-
-        # Initialize the initial success value
-        success = False
-
-        # if inital conv. check, there are no prev_data_misfit
-        if self.prev_data_misfit is None:
-            self.data_misfit = np.mean(self.data_misfit)
-            self.prev_data_misfit = self.data_misfit
-            self.prev_data_misfit_std = self.data_misfit_std
-            success = True
-
-        # update the last mismatch, only if this was a reduction of the misfit
-        if self.data_misfit < self.prev_data_misfit:
-            self.prev_data_misfit = self.data_misfit
-            self.prev_data_misfit_std = self.data_misfit_std
-            success = True
-        # if there was no reduction of the misfit, retain the old "valid" data misfit.
+        # The control this attempt ran with, captured before the branches
+        # below adjust it: that is what the row for this iteration reports,
+        # since the loop logs after the adjustment has happened.
+        self._record_control()
 
-        # Calc. std dev of data misfit (used to update lamda)
-        # mat_obs = np.dot(obs_data_vector.reshape((len(obs_data_vector),1)), np.ones((1, self.ne))) # use the perturbed
-        # data instead.
-        mat_obs = self.real_obs_data
-        data_misfit = at.calc_objectivefun(mat_obs, pred_data, self.cov_data)
+        self.prev_data_misfit_mean = self.data_misfit_mean
+        self.prev_data_misfit_std = self.data_misfit_std
+        self.prev_ensemble_misfit = getattr(self, "ensemble_misfit", None)
 
-        self.data_misfit = np.mean(data_misfit)
+        data_misfit = self.score()
+        self.ensemble_misfit = data_misfit
+        self.data_misfit_mean = np.mean(data_misfit)
         self.data_misfit_std = np.std(data_misfit)
 
-        # # Calc. mean data misfit for convergence check, using the updated state variable
-        # self.data_misfit = np.dot((mean_preddata - obs_data_vector).T,
-        #                      solve(cov_data, (mean_preddata - obs_data_vector)))
-
-        # Convergence check: Relative step size of data misfit or state change less than tolerance
-        if abs(1 - (self.data_misfit / self.prev_data_misfit)) < self.data_misfit_tol:
-            # Logical variables for conv. criteria
-            why_stop = {'data_misfit_stop': 1 - (self.data_misfit / self.prev_data_misfit) < self.data_misfit_tol,
-                        'data_misfit': self.data_misfit,
-                        'prev_data_misfit': self.prev_data_misfit,
-                        'gamma': self.gamma,
-                        }
-
-            if self.data_misfit >= self.prev_data_misfit:
-                success = False
-                self.logger.info(
-                    f'Iterations have converged after {self.iteration} iterations. Objective function reduced '
-                    f'from {self.prior_data_misfit:0.1f} to {self.prev_data_misfit:0.1f}')
-            else:
-                self.logger.info(
-                    f'Iterations have converged after {self.iteration} iterations. Objective function reduced '
-                    f'from {self.prior_data_misfit:0.1f} to {self.data_misfit:0.1f}')
-            # Return conv = True, why_stop var.
-            return True, success, why_stop
-
-        else:  # conv. not met
-            # Logical variables for conv. criteria
-            why_stop = {'data_misfit_stop': 1 - (self.data_misfit / self.prev_data_misfit) < self.data_misfit_tol,
-                        'data_misfit': self.data_misfit,
-                        'prev_data_misfit': self.prev_data_misfit,
-                        'gamma': self.gamma}
-
-            ###############################################
-            ##### update Lambda step-size values ##########
-            ###############################################
-            # If reduction in mean data misfit, reduce damping param
-            if self.data_misfit < self.prev_data_misfit and self.data_misfit_std < self.prev_data_misfit_std:
-                # Reduce damping parameter (divide calculations for ANALYSISDEBUG purpose)
-                self.gamma = self.gamma + (self.gamma_max - self.gamma) * 2 ** (
-                    -(self.iteration) / (self.gamma_factor - 1))
-                success = True
-                self.current_state = cp.deepcopy(self.state)
-                if hasattr(self, 'W'):
-                    self.current_W = cp.deepcopy(self.W)
-
-            elif self.data_misfit < self.prev_data_misfit and self.data_misfit_std >= self.prev_data_misfit_std:
-                # accept itaration, but keep lam the same
-                success = True
-                self.current_state = cp.deepcopy(self.state)
-                if hasattr(self, 'W'):
-                    self.current_W = cp.deepcopy(self.W)
-
-            else:  # Reject iteration, and increase lam
-                # Increase damping parameter (divide calculations for ANALYSISDEBUG purpose)
-                err_str = f"Misfit increased. Set new start step length and try again. Final ojective function value is {self.data_misfit:0.1f}"
-                self.logger.info(err_str)
-                sys.exit(err_str)
-                success = False
-
-            if success:
-                self.logger.info(f'Successfull iteration number {self.iteration}! Objective function reduced from '
-                                 f'{self.prev_data_misfit:0.1f} to {self.data_misfit:0.1f}. New Gamma for next analysis: '
-                                 f'{self.gamma}')
-            else:
-                self.logger.info(f'Failed iteration number {self.iteration}! Objective function increased from '
-                                 f'{self.prev_data_misfit:0.1f} to {self.data_misfit:0.1f}. New Gamma for repeated analysis: '
-                                 f'{self.gamma}')
+        relative_change = 1 - (self.data_misfit_mean / self.prev_data_misfit_mean)
+        tolerance_met = abs(relative_change) < self.data_misfit_tol
+        why_stop = {'data_misfit_stop': relative_change < self.data_misfit_tol,
+                    'data_misfit': self.data_misfit_mean,
+                    'prev_data_misfit': self.prev_data_misfit_mean,
+                    **self._why_stop_control()}
+
+        if tolerance_met or self._control_exhausted():
+            # Converged. A step that increased the misfit is not taken, and
+            # the reduction reported is to the last accepted misfit.
+            success = bool(self.data_misfit_mean < self.prev_data_misfit_mean)   # a Python bool, as StepReport expects
+            reported = self.data_misfit_mean if success else self.prev_data_misfit_mean
+            self.logger.info(
+                f'Iterations have converged after {self.iteration + 1} iterations. Objective function reduced '
+                f'from {self.prior_data_misfit_mean:0.1f} to {reported:0.1f}'
+            )
+            self._converged = True
+            # Without this the run reports "no stopping reason recorded" on a
+            # perfectly ordinary convergence: only the base class's generic
+            # criteria set conv_msg, and these schemes disable those.
+            self.conv_msg = (
+                f"Data misfit change satisfies |1 - d/d_prev| < {self.data_misfit_tol}"
+                if tolerance_met else self._exhausted_message()
+            )
+            self.step_accepted = success
+            self.why_stop = why_stop
+            return why_stop
 
-            # Return conv = False, why_stop var.
-            return False, success, why_stop
+        if self.data_misfit_mean < self.prev_data_misfit_mean:
+            success = True
+            # A smaller spread as well: relax the control. Otherwise accept
+            # the step but leave the control alone.
+            if self.data_misfit_std < self.prev_data_misfit_std:
+                self._on_improved()
+            # Commit the ensemble weights of a weight-space analysis.
+            if hasattr(self, 'W'):
+                self.current_W = cp.deepcopy(self.W)
+        else:
+            success = False
+            self._on_rejected()
+            # Back to the last accepted misfit, array included -- that is
+            # what update_step reports and the next comparison uses.
+            self.data_misfit_mean = self.prev_data_misfit_mean
+            self.data_misfit_std = self.prev_data_misfit_std
+            if self.prev_ensemble_misfit is not None:
+                self.ensemble_misfit = self.prev_ensemble_misfit
+
+        self._converged = False
+        self.step_accepted = success
+        self.why_stop = why_stop
+        return why_stop
+
+
+class LMEnRML(IterativeEnRML):
+    """Levenberg-Marquardt Ensemble Randomized Maximum Likelihood (LM-EnRML).
+
+    An iterative ensemble smoother that solves the randomized maximum
+    likelihood problem by repeated linearisation, with a Levenberg-Marquardt
+    damping parameter :math:`\\lambda` controlling the step size. The damped
+    update inflates the Hessian approximation:
+
+    .. math::
+
+        m \\leftarrow m + C_{md} \\big((1 + \\lambda) C_d + C_{dd}\\big)^{-1}
+        (d_{obs} - g(m))
+
+    Unlike ES-MDA, steps are accepted or rejected. A step that increases the
+    mean data misfit is discarded, :math:`\\lambda` is multiplied by
+    ``lambda_factor`` and the step re-solved from the same state; one that
+    decreases it is kept and :math:`\\lambda` reduced. That retry loop lives
+    inside :meth:`update_step`, so one iteration is one call however many
+    attempts it takes -- the shape popt's optimizers have. The run stops when
+    the relative misfit change falls below ``data_misfit_tol``, when
+    :math:`\\lambda` reaches ``lambda_max``, when a single iteration exhausts
+    ``max_inner_iter`` attempts, or on ``max_iter``.
+
+    Parameters
+    ----------
+    keys_da : dict
+        Parsed ``dataassim`` configuration. Besides the keys every scheme
+        reads -- ``data``, ``datavar``, ``obsname``, ``truedataindex`` -- the
+        ones this scheme acts on are listed under Notes.
+    keys_en : dict
+        Parsed ``ensemble`` configuration: ensemble size ``ne``, the ``state``
+        variable names, and the ``prior_`` blocks describing each.
+    sim : object
+        Forward simulator instance, e.g. ``simulator.opm.flow``.
+    analysis : {'approx', 'full', 'subspace'}, optional
+        Analysis flavour, i.e. how the ensemble-approximated sensitivity is
+        inverted. Defaults to the ``analysis`` key in ``keys_da``, falling back
+        to ``'approx'``. The flavours differ in cost and in how they handle a
+        rank-deficient ensemble; they solve the same update equation.
+
+    Attributes
+    ----------
+    ensemble : pipt.ensembles.AssimilationEnsemble
+        Collaborator holding the state realisations, observed data and
+        simulator. Its state is exposed as properties on the scheme, so
+        ``scheme.enX`` and ``scheme.keys_da`` read straight through.
+    analysis : pipt.update_schemes.analysis.AnalysisBase
+        The bound analysis object. Note the constructor takes ``analysis`` as
+        a *name* and this attribute holds the resulting object, the way
+        ``Model(optimizer="adam").optimizer`` is an optimizer instance.
+    analysis_name : str
+        The flavour name that was resolved, e.g. ``'approx'``.
+    iteration : int
+        Accepted iterations completed so far.
+    data_misfit, prior_data_misfit : float
+        Current and initial mean data misfit.
+
+    Notes
+    -----
+    Configured through the ``iteration`` block of ``keys_da``:
+
+    ``max_iter``
+        Maximum accepted iterations.
+    ``lambda``
+        Initial damping parameter (default 100). ``'auto'`` derives it from the
+        prior data misfit.
+    ``lambda_factor``
+        Factor by which damping grows on rejection and shrinks on acceptance
+        (default 5). Held as ``lam_factor`` -- not ``gamma``, which is
+        GN-EnRML's step length, a different quantity entirely.
+    ``lambda_max``, ``lambda_min``
+        Bounds on the damping parameter.
+    ``max_inner_iter``
+        Damping attempts one iteration may make before the run gives up
+        (default 10). ``lambda_max`` normally stops it first.
+    ``data_misfit_tol``
+        Relative misfit change treated as converged (default 0.01).
+
+    Examples
+    --------
+    >>> result = LMEnRML.assimilate(keys_da, keys_en, flow(keys_sim))
+    >>> result.message
+    'Maximum number of iterations reached'
+
+    ``success`` distinguishes the two ways a run can end: ``True`` when a
+    convergence criterion fired, ``False`` when ``max_iter`` was reached first.
+    Both are ordinary outcomes -- check ``prior_data_misfit`` against
+    ``data_misfit`` to judge whether the run achieved anything.
+
+    References
+    ----------
+    Chen and Oliver, *Levenberg-Marquardt forms of the iterative ensemble
+    smoother for efficient history matching and uncertainty quantification*
+    [`chen2013`][].
+
+    See Also
+    --------
+    IterativeEnRML : The loop, scoring and bookkeeping both schemes share.
+    GNEnRML : Gauss-Newton form, damped by a step length instead.
+    ESMDA : Fixed schedule rather than convergence-driven iteration.
+    """
 
-    def _ext_iter_param(self):
-        """
-        Extract parameters needed in LM-EnRML from the ITERATION keyword given in the DATAASSIM part of PIPT init.
-        file. These parameters include convergence tolerances and parameters for the damping parameter. Default
-        values for these parameters have been given here, if they are not provided in ITERATION.
+    RESTART_ATTRIBUTES = IterativeEnRML.RESTART_ATTRIBUTES + ("lam",)
+
+    COMPATIBLE_ANALYSES = {
+        "approx": approx_update,
+        "full": full_update,
+        "subspace": subspace_update,
+        "subspace2": subspace2_update,
+    }
+
+    def _read_damping_options(self, options):
+        self.lam       = options.get('lambda', 100)
+        self.lam_max   = options.get('lambda_max', 1e10)
+        self.lam_min   = options.get('lambda_min', 0.01)
+        self.lam_factor = options.get('lambda_factor', 5)
+
+    def score(self, pred_data=None):
+        r"""Data misfit, sizing ``lambda='auto'`` the first time there is one.
+
+        :math:`\lambda_0 = \Phi_{prior} / 2 N_d` is defined against the prior
+        misfit, so it cannot be settled in ``__init__``. The first score of a
+        run is the prior's, which makes this the earliest point it can be
+        resolved -- and everything downstream needs a number: the prior row
+        reports λ, and the prior QA/QC pass computes with it.
         """
-        options = self.keys_da['iteration']
-        if isinstance(options, list):
-            options = extract.list_to_dict(options)
-        
-        self.data_misfit_tol = options.get('data_misfit_tol', 0.01)
-        self.trunc_energy = options.get('energy', 0.95)
-        self.step_tol     = options.get('step_tol', 0.01)
-        self.gamma        = options.get('gamma', 0.2)
-        self.gamma_max    = options.get('gamma_max', 0.5)
-        self.gamma_factor = options.get('gamma_factor', 2.5)
+        misfit = super().score(pred_data)
+        if self.lam == 'auto' and misfit is not None:
+            self.lam = 0.5 * float(np.mean(misfit)) / self.enObs.shape[0]
+        return misfit
+
+    def _record_control(self):
+        self.lam_used = self.lam
+
+    def _control_exhausted(self):
+        return self.lam >= self.lam_max
+
+    def _exhausted_message(self):
+        return f"Damping parameter reached lambda_max ({self.lam_max})"
+
+    def _why_stop_control(self):
+        return {'lambda': self.lam, 'lambda_stop': self.lam >= self.lam_max}
+
+    def _on_improved(self):
+        # Reduce damping parameter
+        if self.lam > self.lam_min:
+            self.lam = self.lam / self.lam_factor
+            self.logger(f'λ reduced: {self.lam * self.lam_factor} ──> {self.lam}')
+
+    def _on_rejected(self):
+        self.lam = self.lam * self.lam_factor
+        self.logger(f'Data misfit increased! λ increased: {self.lam / self.lam_factor} ──> {self.lam}')
+
+    def _give_up_message(self, attempt):
+        return f"No improving step after {attempt} damping attempts (λ = {self.lam:.3g})"
+
+    def log_columns(self, prior_run: bool = False) -> dict:
+        """LM-EnRML reports the damping the logged iteration ran with."""
+        return {"λ": getattr(self, "lam_used", self.lam)}
+
+
+class GNEnRML(IterativeEnRML):
+    """Gauss-Newton Ensemble Randomized Maximum Likelihood (GN-EnRML).
+
+    Solves the same randomized maximum likelihood problem as :class:`LMEnRML`,
+    but takes undamped Gauss-Newton steps scaled by a step length
+    :math:`\\gamma \\in (0, 1]` rather than inflating the Hessian:
+
+    .. math::
+
+        m \\leftarrow m + \\gamma \\, C_{md} (C_d + C_{dd})^{-1}
+        (d_{obs} - g(m))
+
+    Steps are accepted or rejected on the mean data misfit as in LM-EnRML. On
+    acceptance :math:`\\gamma` is relaxed towards ``gamma_max``; on rejection it
+    is divided by ``gamma_factor`` and the step re-solved, in the same
+    within-:meth:`update_step` loop LM-EnRML uses for :math:`\\lambda`.
+
+    Parameters
+    ----------
+    keys_da : dict
+        Parsed ``dataassim`` configuration. Besides the keys every scheme
+        reads -- ``data``, ``datavar``, ``obsname``, ``truedataindex`` -- the
+        ones this scheme acts on are listed under Notes.
+    keys_en : dict
+        Parsed ``ensemble`` configuration: ensemble size ``ne``, the ``state``
+        variable names, and the ``prior_`` blocks describing each.
+    sim : object
+        Forward simulator instance, e.g. ``simulator.opm.flow``.
+    analysis : {'approx', 'full', 'subspace'}, optional
+        Analysis flavour, i.e. how the ensemble-approximated sensitivity is
+        inverted. Defaults to the ``analysis`` key in ``keys_da``, falling back
+        to ``'approx'``. The flavours differ in cost and in how they handle a
+        rank-deficient ensemble; they solve the same update equation.
+
+    Attributes
+    ----------
+    ensemble : pipt.ensembles.AssimilationEnsemble
+        Collaborator holding the state realisations, observed data and
+        simulator. Its state is exposed as properties on the scheme, so
+        ``scheme.enX`` and ``scheme.keys_da`` read straight through.
+    analysis : pipt.update_schemes.analysis.AnalysisBase
+        The bound analysis object. Note the constructor takes ``analysis`` as
+        a *name* and this attribute holds the resulting object, the way
+        ``Model(optimizer="adam").optimizer`` is an optimizer instance.
+    analysis_name : str
+        The flavour name that was resolved, e.g. ``'approx'``.
+    iteration : int
+        Accepted iterations completed so far.
+    data_misfit, prior_data_misfit : float
+        Current and initial mean data misfit.
+
+    Notes
+    -----
+    Configured through the ``iteration`` block of ``keys_da``:
+
+    ``max_iter``
+        Maximum accepted iterations.
+    ``gamma``
+        Initial step length (default 0.2).
+    ``gamma_max``
+        Value the step length relaxes towards on success (default 0.5).
+    ``gamma_factor``
+        Divisor applied to the step length on rejection (default 2.5).
+    ``max_inner_iter``
+        Step-length attempts one iteration may make before the run gives up
+        (default 10). There is no ``gamma_min``, so this is what bounds it.
+    ``data_misfit_tol``
+        Relative misfit change treated as converged (default 0.01).
+
+    The ``margis`` flavour is backed by ``margIS_update``, ported from an
+    older layout. It returns a matrix-form ensemble transform step
+    (``AnalysisResult(W_step=...)``, starting from ``W = I``) rather than the
+    weight step most other flavours use; ``propose_state`` reconstructs the
+    state for either. Run against real data it produces a
+    large, sensible misfit reduction, but is still one run on one case with
+    no committed reference pinning it -- see its module docstring
+    (:mod:`pipt.update_schemes.analysis.margis`) for what was fixed in the
+    port and what remains a modelling choice rather than a bug.
+
+    Examples
+    --------
+    >>> result = GNEnRML.assimilate(keys_da, keys_en, flow(keys_sim))
+
+    References
+    ----------
+    Chen and Oliver [`chen2013`][]; see also Raanes, Stordal and Evensen,
+    *Revising the stochastic iterative ensemble smoother* [`raanes2019`][], and
+    Evensen et al. [`evensen2019`][].
+
+    See Also
+    --------
+    IterativeEnRML : The loop, scoring and bookkeeping both schemes share.
+    LMEnRML : Levenberg-Marquardt form, damped via the Hessian.
+    """
 
-        if self.trunc_energy > 1:  # ensure that it is given as percentage
-                self.trunc_energy /= 100.
+    RESTART_ATTRIBUTES = IterativeEnRML.RESTART_ATTRIBUTES + ("gamma",)
 
+    COMPATIBLE_ANALYSES = {
+        "approx": approx_update,
+        "full": full_update,
+        "subspace": subspace_update,
+        "subspace2": subspace2_update,
+        "margis": margIS_update,
+    }
 
-class gnenrml_approx(gnenrmlMixIn, approx_update):
-    pass
+    def _read_damping_options(self, options):
+        self.gamma = options.get('gamma', 0.2)
+        self.gamma_max = options.get('gamma_max', 0.5)
+        self.gamma_factor = options.get('gamma_factor', 2.5)
+        # 'auto' means "pick a sensible default", which for the step length
+        # is a constant -- it needs nothing from the prior.
+        if self.gamma == 'auto':
+            self.gamma = 0.1
+        # Analyses read `lam`; Gauss-Newton takes undamped steps.
+        self.lam = 0
 
+    def _step_scale(self):
+        return self.gamma
 
-class gnenrml_full(gnenrmlMixIn, full_update):
-    pass
+    def _record_control(self):
+        self.gamma_used = self.gamma
 
+    def _exhausted_message(self):
+        raise AssertionError("GN-EnRML has no bound on gamma that stops it")
 
-class gnenrml_subspace(gnenrmlMixIn, subspace_update):
-    pass
+    def _why_stop_control(self):
+        return {'gamma': self.gamma}
 
-class gnenrml_subspace2(gnenrmlMixIn, subspace2_update):
-    pass
+    def _on_improved(self):
+        if self.gamma_factor > 1:
+            self.gamma = self.gamma + (self.gamma_max - self.gamma) * 2 ** (
+                -(self.iteration + 1) / (self.gamma_factor - 1)
+            )
 
+    def _on_rejected(self):
+        if self.gamma_factor > 1:
+            self.gamma = self.gamma / self.gamma_factor
+        self.logger(f'Data misfit increased! New Gamma for repeated analysis: {self.gamma}')
 
-class gnenrml_margis(gnenrmlMixIn, margIS_update):
-    '''
-    The marg-IS scheme is currently not available in this version of PIPT. To utilize the scheme you have to import the
-    *margIS_update* class from a standalone repository.
-    '''
-    pass
+    def _give_up_message(self, attempt):
+        return f"No improving step after {attempt} step-length attempts (γ = {self.gamma:.3g})"
 
+    def log_columns(self, prior_run: bool = False) -> dict:
+        """GN-EnRML reports the step length the logged iteration took."""
+        return {"γ": getattr(self, "gamma_used", self.gamma)}
 
-class co_lm_enrml(lmenrmlMixIn, approx_update):
-    """
-    This is the implementation of the approximative LM-EnRML algorithm as described in [`chen2013`][].
 
-    This algorithm is quite similar to the lm_enrml as provided above, and will therefore inherit most of its methods.
-    We only change the calc_analysis part...
+class co_lm_enrml(LMEnRML):
+    """Approximate LM-EnRML of Chen and Oliver (2013), under its historical name.
 
-    % Copyright (c) 2019-2022 NORCE, All Rights Reserved. 4DSEIS
+    This is ``LMEnRML(..., analysis="approx")`` and nothing more: the class
+    only ever differed from LM-EnRML by mixing in the approximate analysis,
+    which is a constructor argument now. It stays so that configs written as
+    ``scheme = "co_lm_enrml"`` and code importing the name keep working.
+    New code should say ``LMEnRML`` with ``analysis="approx"``.
     """
 
-    def __init__(self, keys_da):
-        """
-        The class is initialized by passing the PIPT init. file upwards in the hierarchy to be read and parsed in
-        `pipt.input_output.pipt_init.ReadInitFile`.
-        """
-        # Call __init__ in parent class
-        super().__init__(keys_da)
+    COMPATIBLE_ANALYSES = {"approx": approx_update}
 
-    def calc_analysis(self):
-        """
-        Calculate the update step in approximate LM-EnRML code.
+    def __init__(self, keys_da, keys_en, sim, analysis=None, ensemble=None):
+        # The name pins the flavour, so a config that does not say gets it.
+        if analysis is None and "analysis" not in keys_da:
+            analysis = "approx"
+        super().__init__(keys_da, keys_en, sim, analysis=analysis, ensemble=ensemble)
 
-        Attributes
-        ----------
-        iteration : int
-            Iteration number
 
-        Returns
-        -------
-        success : bool
-            True if data mismatch is decreasing, False if increasing
-        """
-        # Get assimilation order as a list
-        self.assim_index = [self.keys_da['obsname'], self.keys_da['assimindex'][0]]
-
-        # When handling large cases, it may be very costly to assemble the data covariance and localizaton matrix.
-        # To alleviate this in the simultuaneus-iterative scheme we store these matrices, the list of states and
-        # the list of data types after the first iteration.
-
-        if not hasattr(self, 'list_datatypes'):
-            # Get list of data types to be assimilated and of the free states. Do this once, because listing keys from a
-            # Python dictionary just when needed (in different places) may not yield the same list!
-            self.list_datatypes, self.list_act_datatypes = at.get_list_data_types(
-                self.obs_data, self.assim_index)
-            list_datatypes = self.list_datatypes
-            self.list_states = list(self.state.keys())
-            list_states = self.list_states
-            list_act_datatypes = self.list_act_datatypes
-
-            # self.cov_data = np.load('CD.npz')['arr_0']
-            # Generate the realizations of the observed data once
-            # Augment observed and predicted data
-            self.obs_data_vector, self.aug_pred_data = at.aug_obs_pred_data(self.obs_data, self.pred_data, self.assim_index,
-                                                                            self.list_datatypes)
-            obs_data_vector = self.obs_data_vector
-
-            # Generate the data auto-covariance matrix
-            if 'emp_cov' in self.keys_da and self.keys_da['emp_cov'] == 'yes':
-                if hasattr(self, 'cov_data'):  # cd matrix has been imported
-                    tmp_E = np.dot(cholesky(self.cov_data).T,
-                                   np.random.randn(self.cov_data.shape[0], self.ne))
-                else:
-                    tmp_E = at.extract_tot_empirical_cov(
-                        self.datavar, self.assim_index, self.list_datatypes, self.ne)
-                # self.E = (tmp_E - tmp_E.mean(1)[:,np.newaxis])/np.sqrt(self.ne - 1)/
-                if 'screendata' in self.keys_da and self.keys_da['screendata'] == 'yes':
-                    tmp_E = at.screen_data(tmp_E, self.aug_pred_data,
-                                           obs_data_vector, self.iteration)
-                self.E = tmp_E
-                self.real_obs_data = obs_data_vector[:, np.newaxis] - tmp_E
-
-                self.cov_data = np.var(self.E, ddof=1,
-                                       axis=1)  # calculate the variance, to be used for e.g. data misfit calc
-                # self.cov_data = ((self.E * self.E)/(self.ne-1)).sum(axis=1) # calculate the variance, to be used for e.g. data misfit calc
-                self.scale_data = np.sqrt(self.cov_data)
-            else:
-                if not hasattr(self, 'cov_data'):  # if cd is not loaded
-                    self.cov_data = at.gen_covdata(
-                        self.datavar, self.assim_index, self.list_datatypes)
-                # data screening
-                if 'screendata' in self.keys_da and self.keys_da['screendata'] == 'yes':
-                    self.cov_data = at.screen_data(
-                        self.cov_data, self.aug_pred_data, obs_data_vector, self.iteration)
-
-                init_en = Cholesky()  # Initialize GeoStat class for generating realizations
-                self.real_obs_data, self.scale_data = init_en.gen_real(self.obs_data_vector, self.cov_data, self.ne,
-                                                                       return_chol=True)
-
-            self.datavar = at.update_datavar(
-                self.cov_data, self.datavar, self.assim_index, self.list_datatypes)
-            self.current_state = cp.deepcopy(self.state)
-
-            # Calc. misfit for the initial iteration
-            data_misfit = at.calc_objectivefun(
-                self.real_obs_data, self.aug_pred_data, self.cov_data)
-            # Store the (mean) data misfit (also for conv. check)
-            self.data_misfit = np.mean(data_misfit)
-            self.prior_data_misfit = np.mean(data_misfit)
-            self.data_misfit_std = np.std(data_misfit)
-
-            if self.lam == 'auto':
-                self.lam = 0.5 * self.prior_data_misfit
-
-        else:
-            _, self.aug_pred_data = at.aug_obs_pred_data(
-                self.obs_data, self.pred_data, self.assim_index, self.list_datatypes)
-
-        # Mean pred_data and perturbation matrix with scaling
-        mean_preddata = np.mean(self.aug_pred_data, 1)
-        if len(self.scale_data.shape) == 1:
-            if 'emp_cov' in self.keys_da and self.keys_da['emp_cov'] == 'yes':
-                pert_preddata = np.dot(np.expand_dims(self.scale_data ** (-1), axis=1), np.ones((1, self.ne))) * (
-                    self.aug_pred_data - np.dot(mean_preddata[:, None], np.ones((1, self.ne))))
-            else:
-                pert_preddata = np.dot(np.expand_dims(self.scale_data ** (-1), axis=1), np.ones((1, self.ne))) * (
-                    self.aug_pred_data - np.dot(mean_preddata[:, None], np.ones((1, self.ne)))) / \
-                    (np.sqrt(self.ne - 1))
-        else:
-            if 'emp_cov' in self.keys_da and self.keys_da['emp_cov'] == 'yes':
-                pert_preddata = solve(self.scale_data, self.aug_pred_data -
-                                      np.dot(mean_preddata[:, None], np.ones((1, self.ne))))
-            else:
-                pert_preddata = solve(self.scale_data, self.aug_pred_data - np.dot(mean_preddata[:, None], np.ones((1, self.ne)))) / \
-                    (np.sqrt(self.ne - 1))
-        self.pert_preddata = pert_preddata
-
-        self.update()
-        if hasattr(self, 'step'):
-            aug_state_upd = aug_state + self.step
-        if hasattr(self, 'w_step'):
-            self.W = self.current_W - self.w_step
-            aug_prior_state = at.aug_state(self.prior_state, self.list_states)
-            aug_state_upd = np.dot(aug_prior_state, (np.eye(
-                self.ne) + self.W / np.sqrt(self.ne - 1)))
-
-        # Extract updated state variables from aug_update
-        self.state = at.update_state(aug_state_upd, self.state, self.list_states)
-        self.state = at.limits(self.state, self.prior_info)
+class gn_enrml(GNEnRML):
+    """Gauss-Newton stochastic IES of Raanes et al. (2019), under its historical name.
 
-
-class gn_enrml(lmenrmlMixIn):
-    """
-    This is the implementation of the stochastig IES as  described in [`raanes2019`][].
-
-    More information about the method is found in [`evensen2019`][].
-    This implementation is the Gauss-Newton version.
-
-    This algorithm is quite similar to the `lm_enrml` as provided above, and will therefore inherit most of its methods.
-    We only change the calc_analysis part...
+    This is ``GNEnRML(..., analysis="subspace")``: the weight-space update this
+    class used to carry inline is the ``subspace`` analysis, and the
+    step-length schedule it called ``lambda`` is GN-EnRML's ``gamma``
+    schedule. It stays so that configs written as ``scheme = "gn_enrml"`` and
+    code importing the name keep working. New code should say ``GNEnRML``
+    with ``analysis="subspace"``.
     """
 
-    def __init__(self, keys_da):
-        """
-        The class is initialized by passing the PIPT init. file upwards in the hierarchy to be read and parsed in
-        `pipt.input_output.pipt_init.ReadInitFile`.
-        """
-        # Call __init__ in parent class
-        super().__init__(keys_da)
-
-    def calc_analysis(self):
-        """
-        Changelog
-        ---------
-        - KF 25/2-20
-        """
-        # Get assimilation order as a list
-        assim_index = [self.keys_da['obsname'], self.keys_da['assimindex'][0]]
-
-        # When handling large cases, it may be very costly to assemble the data covariance and localizaton matrix.
-        # To alleviate this in the simultuaneus-iterative scheme we store these matrices, the list of states and
-        # the list of data types after the first iteration.
-
-        if not hasattr(self, 'list_datatypes'):
-            # Get list of data types to be assimilated and of the free states. Do this once, because listing keys from a
-            # Python dictionary just when needed (in different places) may not yield the same list!
-            self.list_datatypes, self.list_act_datatypes = at.get_list_data_types(
-                self.obs_data, assim_index)
-            list_datatypes = self.list_datatypes
-            self.list_states = list(self.state.keys())
-            list_states = self.list_states
-            list_act_datatypes = self.list_act_datatypes
-
-            # Generate the realizations of the observed data once
-            # Augment observed and predicted data
-            self.obs_data_vector, pred_data = at.aug_obs_pred_data(self.obs_data, self.pred_data, assim_index,
-                                                                   self.list_datatypes)
-            obs_data_vector = self.obs_data_vector
-
-            if 'emp_cov' in self.keys_da and self.keys_da['emp_cov'] == 'yes':
-                if hasattr(self, 'cov_data'):  # cd matrix has been imported
-                    tmp_E = np.dot(cholesky(self.cov_data).T, np.random.randn(
-                        self.cov_data.shape[0], self.ne))
-                else:
-                    tmp_E = at.extract_tot_empirical_cov(
-                        self.datavar, assim_index, self.list_datatypes, self.ne)
-                # self.E = (tmp_E - tmp_E.mean(1)[:,np.newaxis])/np.sqrt(self.ne - 1)/
-                self.real_obs_data = obs_data_vector[:, np.newaxis] - tmp_E
-
-                self.cov_data = np.var(tmp_E, ddof=1,
-                                       axis=1)  # calculate the variance, to be used for e.g. data misfit calc
-                # self.cov_data = ((self.E * self.E)/(self.ne-1)).sum(axis=1) # calculate the variance, to be used for e.g. data misfit calc
-                self.scale_data = np.sqrt(self.cov_data)
-            else:
-                if not hasattr(self, 'cov_data'):  # if cd is not loaded
-                    self.cov_data = at.gen_covdata(
-                        self.datavar, assim_index, self.list_datatypes)
-                # data screening
-                if 'screendata' in self.keys_da and self.keys_da['screendata'] == 'yes':
-                    self.cov_data = at.screen_data(
-                        self.cov_data, pred_data, obs_data_vector, self.iteration)
-
-                init_en = Cholesky()  # Initialize GeoStat class for generating realizations
-                self.real_obs_data, self.scale_data = init_en.gen_real(self.obs_data_vector, self.cov_data, self.ne,
-                                                                       return_chol=True)
-
-            self.datavar = at.update_datavar(
-                self.cov_data, self.datavar, assim_index, self.list_datatypes)
-            cov_data = self.cov_data
-            obs_data = self.real_obs_data
-            #
-            self.current_state = cp.deepcopy(self.state)
-            #
-            self.aug_prior = cp.deepcopy(at.aug_state(
-                self.current_state, self.list_states))
-            # self.mean_prior = aug_prior.mean(axis=1)
-            # self.X = (aug_prior - np.dot(np.resize(self.mean_prior, (len(self.mean_prior), 1)),
-            #                                                  np.ones((1, self.ne))))
-            self.W = np.zeros((self.ne, self.ne))
-
-            self.proj = (np.eye(self.ne) - (1 / self.ne) *
-                         np.ones((self.ne, self.ne))) / np.sqrt(self.ne - 1)
-            self.E = np.dot(obs_data, self.proj)
-
-            # Calc. misfit for the initial iteration
-            if len(cov_data.shape) == 1:
-                tmp_data_misfit = np.diag(np.dot((pred_data - obs_data).T,
-                                                 np.dot(np.expand_dims(self.cov_data ** (-1), axis=1),
-                                                        np.ones((1, self.ne))) * (pred_data - obs_data)))
-            else:
-                tmp_data_misfit = np.diag(
-                    np.dot((pred_data - obs_data).T, solve(self.cov_data, (pred_data - obs_data))))
-            mean_data_misfit = np.mean(tmp_data_misfit)
-            # mean_data_misfit = np.median(tmp_data_misfit)
-            std_data_misfit = np.std(tmp_data_misfit)
-
-            # Store the (mean) data misfit (also for conv. check)
-            self.data_misfit = mean_data_misfit
-            self.prior_data_misfit = mean_data_misfit
-            self.data_misfit_std = std_data_misfit
-
-        else:
-            # for analysis debug...
-            list_datatypes = self.list_datatypes
-            list_act_datatypes = self.list_act_datatypes
-            list_states = self.list_states
-            cov_data = self.cov_data
-            obs_data_vector = self.obs_data_vector
-            _, pred_data = at.aug_obs_pred_data(
-                self.obs_data, self.pred_data, assim_index, self.list_datatypes)
-            obs_data = self.real_obs_data
-
-        if len(self.scale_data.shape) == 1:
-            Y = np.dot(np.expand_dims(self.scale_data ** (-1), axis=1), np.ones((1, self.ne))) * \
-                np.dot(pred_data, self.proj)
-        else:
-            Y = solve(self.scale_data, np.dot(pred_data, self.proj))
-        omega = np.eye(self.ne) + np.dot(self.W, self.proj)
-        LU = lu_factor(omega.T)
-        S = lu_solve(LU, Y.T).T
-        if len(self.scale_data.shape) == 1:
-            scaled_misfit = np.dot(np.expand_dims(self.scale_data ** (-1), axis=1),
-                                   np.ones((1, self.ne))) * (obs_data - pred_data)
-        else:
-            scaled_misfit = solve(self.scale_data, (obs_data - pred_data))
-
-        u, s, v = np.linalg.svd(S, full_matrices=False)
-        if self.trunc_energy < 1:
-            ti = (np.cumsum(s) / sum(s)) <= self.trunc_energy
-            u, s, v = u[:, ti].copy(), s[ti].copy(), v[ti, :].copy()
-
-        ps_inv = np.diag([el_s ** (-1) for el_s in s])
-        if len(self.scale_data.shape) == 1:
-            X = np.dot(ps_inv, np.dot(u.T, np.dot(np.expand_dims(self.scale_data ** (-1), axis=1),
-                                                  np.ones((1, self.ne))) * self.E))
-        else:
-            X = np.dot(ps_inv, np.dot(u.T, solve(self.scale_data, self.E)))
-        Lam, z = np.linalg.eig(np.dot(X, X.T))
-
-        X2 = np.dot(u, np.dot(ps_inv.T, z))
-
-        X3_m = np.dot(S.T, X2)
-        # X3_old = np.dot(X2, np.linalg.solve(np.eye(len(Lam)) + np.diag(Lam), X2.T))
-        step_m = np.dot(np.dot(X3_m, inv(np.eye(len(Lam)) + np.diag(Lam))),
-                        np.dot(X3_m.T, self.W))
-
-        if 'localization' in self.keys_da:
-            if self.keys_da['localization'][1][0] == 'autoadaloc':
-                loc_step_d = np.dot(np.linalg.pinv(self.aug_prior), self.localization.auto_ada_loc(self.aug_prior,
-                                                                                                   np.dot(np.dot(S.T, X2),
-                                                                                                          np.dot(inv(
-                                                                                                              np.eye(len(Lam)) + np.diag(Lam)),
-                                                                                                       np.dot(X2.T, scaled_misfit))),
-                                                                                                   self.list_states,
-                                                                                                   **{'prior_info': self.prior_info}))
-                self.step = self.lam * (self.W - (step_m + loc_step_d))
-        else:
-            step_d = np.dot(np.linalg.inv(omega).T,  np.dot(np.dot(Y.T, X2),
-                                                            np.dot(inv(np.eye(len(Lam)) + np.diag(Lam)),
-                                                                   np.dot(X2.T, scaled_misfit))))
-            self.step = self.lam * (self.W - (step_m + step_d))
-
-        self.W -= self.step
-
-        aug_state_upd = np.dot(self.aug_prior, (np.eye(
-            self.ne) + self.W / np.sqrt(self.ne - 1)))
-
-        # Extract updated state variables from aug_update
-        self.state = at.update_state(aug_state_upd, self.state, self.list_states)
-
-        self.state = at.limits(self.state, self.prior_info)
+    COMPATIBLE_ANALYSES = {"subspace": subspace_update}
 
-    def check_convergence(self):
-        """
-        Check if GN-EnRML have converged based on evaluation of change sizes of objective function, state and damping
-        parameter. Very similar to original function, but exit if there is no reduction in obj. function.
-
-        Returns
-        -------
-        conv : bool
-            Logic variable indicating if the algorithm has converged.
-
-        status : bool
-            Indicates whether the objective function has reduced.
-
-        why_stop : dict
-            Dictionary with keys corresponding to convergence criteria, with logical variables indicating
-            which of them has been met.
-
-        Changelog
-        ---------
-        - ST 3/6-16
-        - ST 6/6-16: Added LM damping param. check
-        - KF 16/11-20: Modified for GN-EnRML
-        - KF 10/3-21: Output whether the method reduced the objective function
-        """
-        # Prelude to calc. conv. check (everything done below is from calc_analysis)
-        if hasattr(self, 'list_datatypes'):
-            assim_index = [self.keys_da['obsname'], self.keys_da['assimindex'][0]]
-            list_datatypes = self.list_datatypes
-            cov_data = self.cov_data
-            obs_data_vector, pred_data = at.aug_obs_pred_data(self.obs_data, self.pred_data, assim_index,
-                                                              list_datatypes)
-            mean_preddata = np.mean(pred_data, 1)
-        else:
-            assim_index = [self.keys_da['obsname'], self.keys_da['assimindex'][0]]
-            list_datatypes, _ = at.get_list_data_types(self.obs_data, assim_index)
-            # cov_data = at.gen_covdata(self.datavar, assim_index, list_datatypes)
-            obs_data_vector, pred_data = at.aug_obs_pred_data(self.obs_data, self.pred_data, assim_index,
-                                                              list_datatypes)
-            # mean_preddata = np.mean(pred_data, 1)
-
-        success = False
-
-        # if inital conv. check, there are no prev_data_misfit
-        if self.prev_data_misfit is None:
-            self.data_misfit = np.mean(self.data_misfit)
-            self.prev_data_misfit = self.data_misfit
-            self.prev_data_misfit_std = self.data_misfit_std
-            success = True
-        # update the last mismatch, only if this was a reduction of the misfit
-        if self.data_misfit < self.prev_data_misfit:
-            self.prev_data_misfit = self.data_misfit
-            self.prev_data_misfit_std = self.data_misfit_std
-            success = True
-        # if there was no reduction of the misfit, retain the old "valid" data misfit.
-
-        # Calc. std dev of data misfit (used to update lamda)
-        # mat_obs = np.dot(obs_data_vector.reshape((len(obs_data_vector), 1)), np.ones((1, self.ne)))  # use the perturbed
-        # data instead.
-        mat_obs = self.real_obs_data
-        if len(cov_data.shape) == 1:
-            data_misfit = np.diag(np.dot((pred_data - mat_obs).T,
-                                         np.dot(np.expand_dims(self.cov_data ** (-1), axis=1),
-                                                np.ones((1, self.ne))) * (pred_data - mat_obs)))
-        else:
-            data_misfit = np.diag(np.dot((pred_data - mat_obs).T,
-                                  solve(self.cov_data, (pred_data - mat_obs))))
-        self.data_misfit = np.mean(data_misfit)
-        self.data_misfit_std = np.std(data_misfit)
-
-        # # Calc. mean data misfit for convergence check, using the updated state variable
-        # self.data_misfit = np.dot((mean_preddata - obs_data_vector).T,
-        #                      solve(cov_data, (mean_preddata - obs_data_vector)))
-        # if self.data_misfit > self.prev_data_misfit:
-        #    print(f'\n\nMisfit increased from {self.prev_data_misfit:.1f} to {self.data_misfit:.1f}. Exiting')
-        #    self.logger.info(f'\n\nMisfit increased from {self.prev_data_misfit:.1f} to {self.data_misfit:.1f}. Exiting')
-
-        # Convergence check: Relative step size of data misfit or state change less than tolerance
-        if abs(1 - (self.data_misfit / self.prev_data_misfit)) < self.data_misfit_tol \
-                or np.any(abs(np.mean(self.step, 1)) < self.step_tol) \
-                or self.lam >= self.lam_max:
-            # or self.data_misfit > self.prev_data_misfit:
-            # Logical variables for conv. criteria
-            why_stop = {'data_misfit_stop': 1 - (self.data_misfit / self.prev_data_misfit) < self.data_misfit_tol,
-                        'data_misfit': self.data_misfit,
-                        'prev_data_misfit': self.prev_data_misfit,
-                        'step_size_stop': np.any(abs(np.mean(self.step, 1)) < self.step_tol),
-                        'step_size': self.step,
-                        'lambda': self.lam,
-                        'lambda_stop': self.lam >= self.lam_max}
-
-            if self.data_misfit >= self.prev_data_misfit:
-                success = False
-                self.logger.info(f'Iterations have converged after {self.iteration} iterations. Objective function reduced '
-                                 f'from {self.prior_data_misfit:0.1f} to {self.prev_data_misfit:0.1f}')
-            else:
-                self.logger.info(f'Iterations have converged after {self.iteration} iterations. Objective function reduced '
-                                 f'from {self.prior_data_misfit:0.1f} to {self.data_misfit:0.1f}')
-
-            # Return conv = True, why_stop var.
-            return True, success, why_stop
-
-        else:  # conv. not met
-            # Logical variables for conv. criteria
-            why_stop = {'data_misfit_stop': 1 - (self.data_misfit / self.prev_data_misfit) < self.data_misfit_tol,
-                        'data_misfit': self.data_misfit,
-                        'prev_data_misfit': self.prev_data_misfit,
-                        'step_size': self.step,
-                        'step_size_stop': np.any(abs(np.mean(self.step, 1)) < self.step_tol),
-                        'lambda': self.lam,
-                        'lambda_stop': self.lam >= self.lam_max}
-
-            ###############################################
-            ##### update Lambda step-size values ##########
-            ###############################################
-            if self.data_misfit < self.prev_data_misfit and self.data_misfit_std < self.prev_data_misfit_std:
-                # If reduction in mean data misfit, increase step length
-                self.lam = self.lam + (self.lam_max - self.lam) * \
-                    2 ** (-(self.iteration) / (self.gamma - 1))
-                success = True
-                self.current_state = cp.deepcopy(self.state)
-            elif self.data_misfit < self.prev_data_misfit and self.data_misfit_std >= self.prev_data_misfit_std:
-                # Accept itaration, but keep lam the same
-                success = True
-                self.current_state = cp.deepcopy(self.state)
-            else:  # Reject iteration, and decrease step length
-                self.lam = self.lam / self.gamma
-                success = False
-
-            if success:
-                self.logger.info(f'Successfull iteration number {self.iteration}! Objective function reduced from '
-                                 f'{self.prev_data_misfit:0.1f} to {self.data_misfit:0.1f}. New Lamba for next analysis: '
-                                 f'{self.lam}')
-            else:
-                self.logger.info(f'Failed iteration number {self.iteration}! Objective function increased from '
-                                 f'{self.prev_data_misfit:0.1f} to {self.data_misfit:0.1f}. New Lamba for repeated analysis: '
-                                 f'{self.lam}')
-                # Reset data misfit to prev_data_misfit (because the current state is neglected)
-                self.data_misfit = self.prev_data_misfit
-                self.data_misfit_std = self.prev_data_misfit_std
-
-            return False, success, why_stop
+    def __init__(self, keys_da, keys_en, sim, analysis=None, ensemble=None):
+        if analysis is None and "analysis" not in keys_da:
+            analysis = "subspace"
+        super().__init__(keys_da, keys_en, sim, analysis=analysis, ensemble=ensemble)
diff --git a/src/pipt/update_schemes/es.py b/src/pipt/update_schemes/es.py
index b8bb7cfd..850cefe3 100644
--- a/src/pipt/update_schemes/es.py
+++ b/src/pipt/update_schemes/es.py
@@ -1,102 +1,144 @@
 """
 ES type schemes
 """
-from pipt.update_schemes.enkf import enkf_approx
-from pipt.update_schemes.enkf import enkf_full
-from pipt.update_schemes.enkf import enkf_subspace
+from pipt.update_schemes.enkf import EnKF
 
 import numpy as np
-from copy import deepcopy
-from pipt.misc_tools import analysis_tools as at
 
 
-class esMixIn():
-    """
-    This is the straightforward ES analysis scheme. We treat this as a all-data-at-once EnKF step, hence the
-    calc_analysis method here is identical to that in the `enkf` class. Since, for the moment, ASSIMINDEX is parsed in a
-    specific manner (or more precise, single rows and columns in the PIPT init. file is parsed to a 1D list), a
-    `Simultaneous` 'loop' had to be implemented, and `es` will use this to do the inversion. Maybe in the future, we can
-    make the `enkf` class do simultaneous updating also. The consequence of all this is that we inherit BOTH `enkf` and
-    `Simultaneous` classes, which is convenient. The `Simultaneous` class is inherited to set up the correct inversion
-    structure and `enkf` is inherited to get `calc_analysis`, so we do not have to implement it again.
+class ES(EnKF):
+    """Ensemble Smoother (ES).
+
+    Assimilates all observations simultaneously in a single update, rather than
+    sequentially in time as the filter does. It is :class:`EnKF` specialised to
+    one data group, and shares its analysis step; only the iteration budget and
+    the misfit bookkeeping differ.
+
+    A single conditioning step is cheap but can over-correct when the model is
+    strongly non-linear. :class:`ESMDA` addresses this by spreading the same
+    update over several inflated steps.
+
+    Parameters
+    ----------
+    keys_da : dict
+        Parsed ``dataassim`` configuration. Besides the keys every scheme
+        reads -- ``data``, ``datavar``, ``obsname``, ``truedataindex`` -- the
+        ones this scheme acts on are listed under Notes.
+    keys_en : dict
+        Parsed ``ensemble`` configuration: ensemble size ``ne``, the ``state``
+        variable names, and the ``prior_`` blocks describing each.
+    sim : object
+        Forward simulator instance, e.g. ``simulator.opm.flow``.
+    analysis : {'approx', 'full', 'subspace'}, optional
+        Analysis flavour, i.e. how the ensemble-approximated sensitivity is
+        inverted. Defaults to the ``analysis`` key in ``keys_da``, falling back
+        to ``'approx'``. The flavours differ in cost and in how they handle a
+        rank-deficient ensemble; they solve the same update equation.
+
+    Attributes
+    ----------
+    ensemble : pipt.ensembles.AssimilationEnsemble
+        Collaborator holding the state realisations, observed data and
+        simulator. Its state is exposed as properties on the scheme, so
+        ``scheme.enX`` and ``scheme.keys_da`` read straight through.
+    analysis : pipt.update_schemes.analysis.AnalysisBase
+        The bound analysis object. Note the constructor takes ``analysis`` as
+        a *name* and this attribute holds the resulting object, the way
+        ``Model(optimizer="adam").optimizer`` is an optimizer instance.
+    analysis_name : str
+        The flavour name that was resolved, e.g. ``'approx'``.
+    iteration : int
+        Accepted iterations completed so far.
+    data_misfit, prior_data_misfit : float
+        Current and initial mean data misfit.
+
+    Notes
+    -----
+    ``assimindex`` is flattened to a single group at construction, so the
+    ordering that matters for :class:`EnKF` has no effect here.
+
+    Because there is only one step, the ``full`` flavour coincides with
+    ``approx`` -- the prior-increment term they differ over is only reached
+    when iterating -- so :attr:`EnKF.COMPATIBLE_ANALYSES`, inherited
+    unchanged here, points ``"full"`` at the cheaper ``approx`` analysis.
+
+    Examples
+    --------
+    >>> result = ES.assimilate(keys_da, keys_en, flow(keys_sim))
+    >>> result.nit
+    1
+
+    References
+    ----------
+    Evensen, *Data Assimilation: The Ensemble Kalman Filter* [`evensen2009a`][].
+
+    See Also
+    --------
+    EnKF : Sequential form of the same update.
+    ESMDA : Spreads the conditioning over several inflated steps.
     """
 
-    def __init__(self, keys_da, keys_en, sim):
-        """
-        The class is initialized by passing the PIPT init. file upwards in the hierarchy to be read and parsed in
-        `pipt.input_output.pipt_init.ReadInitFile`.
+    def __init__(self, keys_da, keys_en, sim, analysis=None, ensemble=None):
+        """Build the ensemble from the config (or take the one given) and bind the analysis.
+
+        See the class docstring for the parameters.
         """
-        # Pass init. file to Simultaneous parent class (Python searches parent classes from left to right).
-        super().__init__(keys_da, keys_en, sim)
+        super().__init__(keys_da, keys_en, sim, analysis=analysis, ensemble=ensemble)
 
-        if self.restart is False:
-            # At the moment, the iterative loop is threated as an iterative smoother an thus we check if assim. indices
-            # are given as in the Simultaneous loop.
-            self.check_assimindex_simultaneous()
+        # At the moment, the iterative loop is threated as an iterative smoother an thus we check if assim. indices
+        # are given as in the Simultaneous loop.
+        self.ensemble.check_assimindex_simultaneous()
 
-            # Extract no. assimilation steps from MDA keyword in DATAASSIM part of init. file and set this equal to
-            # the number of iterations pluss one. Need one additional because the iter=0 is the prior run.
-            self.max_iter = 2
+        # A single all-data-at-once update.
+        self.maxiter = 1
 
-    def check_convergence(self):
+    def check_convergence(self) -> bool:
+        """ES takes a single all-data-at-once step; nothing stops early."""
+        return False
+
+    def score_and_commit(self):
         """
         Calculate the "convergence" of the method. Important to
         """
-        self.prev_data_misfit = self.prior_data_misfit
+        self.prev_data_misfit_mean = self.prior_data_misfit_mean
         # only calulate for the final (posterior) estimate
-        if self.iteration == len(self.keys_da['assimindex']):
-            assim_index = [self.keys_da['obsname'], list(
-                np.concatenate(self.keys_da['assimindex']))]
-            list_datatypes = self.list_datatypes
-            obs_data_vector, pred_data = at.aug_obs_pred_data(self.obs_data, self.pred_data, assim_index,
-                                                              list_datatypes)
-
-            data_misfit = at.calc_objectivefun(
-                self.enObs, pred_data, self.scale_data)
-            self.data_misfit = np.mean(data_misfit)
+        if self.iteration + 1 == len(self.keys_da['assimindex']):
+            data_misfit = self.score()
+            self.ensemble_misfit = data_misfit
+            self.data_misfit_mean = np.mean(data_misfit)
             self.data_misfit_std = np.std(data_misfit)
 
         else:  # sequential updates not finished. Misfit is not relevant
-            self.data_misfit = self.prior_data_misfit
+            self.data_misfit_mean = self.prior_data_misfit_mean
 
         # Logical variables for conv. criteria
-        why_stop = {'rel_data_misfit': 1 - (self.data_misfit / self.prev_data_misfit),
-                    'data_misfit': self.data_misfit,
-                    'prev_data_misfit': self.prev_data_misfit}
-
-        if self.data_misfit == self.prev_data_misfit:
+        why_stop = {'rel_data_misfit': 1 - (self.data_misfit_mean / self.prev_data_misfit_mean),
+                    'data_misfit': self.data_misfit_mean,
+                    'prev_data_misfit': self.prev_data_misfit_mean}
+
+        # Update state ensemble. This is unconditional, as it is in every other
+        # scheme: the analysis result lives in enX_temp and is worthless until
+        # promoted. It used to sit inside the equal-misfit branch below, which
+        # is essentially never taken -- prev_data_misfit is the prior misfit and
+        # data_misfit is the posterior one -- so ES returned its prior ensemble
+        # unchanged while logging a reduced misfit.
+
+        if self.data_misfit_mean == self.prev_data_misfit_mean:
             self.logger.info(
                 f'ES update {self.iteration} complete!')
-            self.enX = deepcopy(self.enX_temp)
-            self.enX_temp = None
         else:
-            if self.data_misfit < self.prior_data_misfit:
-                self.logger.info(
-                    f'ES update complete! Objective function decreased from {self.prior_data_misfit:0.1f} to {self.data_misfit:0.1f}.')
-            else:
-                self.logger.info(
-                    f'ES update complete! Objective function increased from {self.prior_data_misfit:0.1f} to {self.data_misfit:0.1f}.')
-        # Return conv = False, why_stop var.
-        return False, True, why_stop
 
+            # Reduction
+            if self.data_misfit_mean < self.prior_data_misfit_mean:
+                dF = (self.prev_data_misfit_mean - self.data_misfit_mean)/self.prev_data_misfit_mean * 100
+                self.logger('ES update complete!')
+                msg = f'Data Misfit reduced by {dF:.1f} %: {self.prev_data_misfit_mean:0.1f} --> {self.data_misfit_mean:0.1f}.'
+                self.logger(msg)
 
-class es_approx(esMixIn, enkf_approx):
-    """
-    Mixin of ES class and approximate update
-    """
-    pass
-
-
-class es_full(esMixIn, enkf_full):
-    """
-    mixin of ES class and full update.
-    Note that since we do not iterate there is no difference between is full and approx.
-    """
-    pass
-
+            # Increase
+            else:
+                self.logger.info(
+                    f'ES update complete! Objective function increased from {self.prior_data_misfit_mean:0.1f} to {self.data_misfit_mean:0.1f}.')
 
-class es_subspace(esMixIn, enkf_subspace):
-    """
-    mixin of ES class and subspace update.
-    """
-    pass
+        self.why_stop = why_stop
+        return why_stop
diff --git a/src/pipt/update_schemes/esmda.py b/src/pipt/update_schemes/esmda.py
index 609d5930..10daf2c5 100644
--- a/src/pipt/update_schemes/esmda.py
+++ b/src/pipt/update_schemes/esmda.py
@@ -3,84 +3,226 @@
 """
 
 # External imports
-import scipy.linalg as scilinalg
 from copy import deepcopy
 import numpy as np
-from geostat.decomp import Cholesky
+from misc.sampling import gen_real
 
 # Internal imports
-from pipt.loop.ensemble import Ensemble
+from pipt.update_schemes.core import AssimilationScheme, StepReport, restart_options
+from pipt.update_schemes.analysis.approx import approx_update
+from pipt.update_schemes.analysis.full import full_update
+from pipt.update_schemes.analysis.subspace import subspace_update
+from pipt.update_schemes.analysis.subspace2 import subspace2_update
 import pipt.misc_tools.analysis_tools as at
-import pipt.misc_tools.ensemble_tools as entools
-import pipt.misc_tools.data_tools as dtools
 
-# import update schemes
-from pipt.update_schemes.update_methods_ns.approx_update import approx_update
-from pipt.update_schemes.update_methods_ns.full_update import full_update
-from pipt.update_schemes.update_methods_ns.subspace_update import subspace_update
-from pipt.update_schemes.update_methods_ns.subspace2_update import subspace2_update
-
-class esmdaMixIn(Ensemble):
-    """
-    This is the implementation of the ES-MDA algorithm given in [`emerick2013a`][].
-    This algorithm have been implemented mostly to
-    illustrate how a algorithm using the Mda loop can be implemented.
+__all__ = ['ESMDA']
+
+class ESMDA(AssimilationScheme):
+    """Ensemble Smoother with Multiple Data Assimilation (ES-MDA).
+
+    An iterative ensemble smoother that assimilates all data repeatedly over a
+    fixed number of steps, inflating the data-error covariance at each one so
+    that the repeated conditioning does not over-fit. With inflation factors
+    :math:`\\alpha_i` satisfying :math:`\\sum_i 1/\\alpha_i = 1`, each step applies
+
+    .. math::
+
+        m \\leftarrow m + C_{md} (C_{dd} + \\alpha_i C_d)^{-1} (d_{obs} - g(m))
+
+    with the observations re-perturbed as
+    :math:`d_{obs} = d_{true} + \\sqrt{\\alpha_i} C_d^{1/2} Z`.
+
+    The schedule is fixed rather than convergence-driven, so a run normally
+    ends by exhausting its steps and reports ``success=False``. That is the
+    expected outcome, not a failure.
+
+    Parameters
+    ----------
+    keys_da : dict
+        Parsed ``dataassim`` configuration. Besides the keys every scheme
+        reads -- ``data``, ``datavar``, ``obsname``, ``truedataindex`` -- the
+        ones this scheme acts on are listed under Notes.
+    keys_en : dict
+        Parsed ``ensemble`` configuration: ensemble size ``ne``, the ``state``
+        variable names, and the ``prior_`` blocks describing each.
+    sim : object
+        Forward simulator instance, e.g. ``simulator.opm.flow``.
+    analysis : {'approx', 'full', 'subspace'}, optional
+        Analysis flavour, i.e. how the ensemble-approximated sensitivity is
+        inverted. Defaults to the ``analysis`` key in ``keys_da``, falling back
+        to ``'approx'``. The flavours differ in cost and in how they handle a
+        rank-deficient ensemble; they solve the same update equation.
+
+    Attributes
+    ----------
+    ensemble : pipt.ensembles.AssimilationEnsemble
+        Collaborator holding the state realisations, observed data and
+        simulator. Its state is exposed as properties on the scheme, so
+        ``scheme.enX`` and ``scheme.keys_da`` read straight through.
+    analysis : pipt.update_schemes.analysis.AnalysisBase
+        The bound analysis object. Note the constructor takes ``analysis`` as
+        a *name* and this attribute holds the resulting object, the way
+        ``Model(optimizer="adam").optimizer`` is an optimizer instance.
+    analysis_name : str
+        The flavour name that was resolved, e.g. ``'approx'``.
+    iteration : int
+        Accepted iterations completed so far.
+    data_misfit, prior_data_misfit : float
+        Current and initial mean data misfit.
+
+    Notes
+    -----
+    Configured through the ``mda`` block of ``keys_da``:
+
+    ``tot_assim_steps``
+        Number of assimilation steps, e.g. ``3``.
+    ``inflation_param``
+        Inflation factors, one per step, e.g. ``[3, 3, 3]``. Their reciprocals
+        must sum to 1, which is asserted at construction. Defaults to
+        ``tot_assim_steps`` repeated, which satisfies the constraint.
+
+    Examples
+    --------
+    >>> result = ESMDA.assimilate(keys_da, keys_en, flow(keys_sim))
+    >>> result.nit
+    3
+
+    References
+    ----------
+    Emerick and Reynolds, *Ensemble smoother with multiple data assimilation*
+    [`emerick2013a`][].
+
+    See Also
+    --------
+    ES : Single-step smoother; ES-MDA with one assimilation step.
+    LMEnRML : Iterates to convergence instead of on a fixed schedule.
     """
 
-    def __init__(self, keys_da, keys_en, sim):
-        """
-        The class is initialized by passing the keywords and simulator object upwards in the hierarchy.
+    #: Ensemble class this scheme composes. Subclasses needing a specialised
+    #: collaborator -- the multilevel variant, for instance -- override it
+    #: rather than duplicating the constructor.
 
-        Parameters
-        ----------
-        keys_da['mda'] : dict
-            - tot_assim_steps: total number of iterations in MDA, e.g., 3
-            - inflation_param: covariance inflation factors, e.g., [2, 4, 4]
+    COMPATIBLE_ANALYSES = {
+        "approx": approx_update,
+        "full": full_update,
+        "subspace": subspace_update,
+        "subspace2": subspace2_update,
+    }
+
+    # The perturbed observations are redrawn every step (from the ensemble's
+    # stream, whose state travels with the ensemble); the misfit is scored
+    # against the un-inflated draw taken at construction (`enObs_conv`).
+    RESTART_ATTRIBUTES = ("enObs", "enObs_conv", "scale_data")
 
-        keys_en : dict
+    def __init__(self, keys_da, keys_en, sim, analysis=None, ensemble=None):
+        """Build the ensemble from the config (or take the one given) and bind the analysis.
 
-        sim : callable
+        See the class docstring for the parameters; ``ensemble`` is a
+        ready-made collaborator to run on instead of building one.
         """
-        # Pass the init_file upwards in the hierarchy
-        super().__init__(keys_da, keys_en, sim)
-
-        self.prev_data_misfit = None
-
-        if self.restart is False:
-            self.prior_enX = deepcopy(self.enX)
-            self.list_states = list(self.idX.keys())
-
-            # At the moment, the iterative loop is threated as an iterative smoother an thus we check if assim. indices
-            # are given as in the Simultaneous loop.
-            self.check_assimindex_simultaneous()
-            self.assim_index = [self.keys_da['obsname'], self.keys_da['assimindex'][0]]
-            self.list_datatypes, self.list_act_datatypes = at.get_list_data_types(self.obs_data, self.assim_index)
-
-            # Extract no. assimilation steps from MDA keyword in DATAASSIM part of init. file and set this equal to
-            # the number of iterations pluss one. Need one additional because the iter=0 is the prior run.
-            self.max_iter = len(self._ext_assim_steps())+1
-            self.iteration = 0
-
-            self.lam = 0  # set LM lamda to zero as we are doing one full update.
-            if 'energy' in self.keys_da:
-                # initial energy (Remember to extract this)
-                self.trunc_energy = self.keys_da['energy']
-                if self.trunc_energy > 1:  # ensure that it is given as percentage
-                    self.trunc_energy /= 100.
-            else:
-                self.trunc_energy = 0.98
+        # The collaborator is handed to the scheme base, which adopts the
+        # ensemble's own logger, so the log output is unchanged.
+        ensemble = self.build_ensemble(keys_da, keys_en, sim, ensemble)
+        # Zero tolerances switch off the base class's generic convergence
+        # criteria; this scheme decides in check_convergence(). See
+        # AssimilationScheme's `misfit_tol`/`step_tol` docs for why.
+        super().__init__(ensemble, misfit_tol=0.0, step_tol=0.0, **restart_options(ensemble.keys_da))
+
+        # The analysis flavour is a parameter of the algorithm, not a different
+        # algorithm, so it selects an analysis object rather than a class.
+        self.bind_analysis(self.resolve_analysis(analysis, ensemble.keys_da))
+
+        self.prev_data_misfit_mean = None
+
+        # A specialised ensemble may already have established these -- the
+        # multilevel one partitions enX into per-level blocks and sets both
+        # itself. Only fill
+        # them in when the collaborator has not.
+        if getattr(self.ensemble, 'prior_enX', None) is None:
+            self.ensemble.prior_enX = deepcopy(self.enX)
+        if getattr(self.ensemble, 'list_states', None) is None:
+            self.ensemble.list_states = list(self.idX)
+        self.ensemble.list_datatypes = self.keys_da['datatype']
+
+        # At the moment, the iterative loop is threated as an iterative smoother an thus we check if assim. indices
+        # are given as in the Simultaneous loop.
+        #self.check_assimindex_simultaneous()
+        #self.assim_index = [self.keys_da['obsname'], self.keys_da['assimindex'][0]]
+        #self.list_datatypes, self.list_act_datatypes = at.get_list_data_types(self.obs_data, self.assim_index)
+
+        # One update per assimilation step of the MDA schedule.
+        self.maxiter = len(self._ext_assim_steps())
+        self.iteration = 0
+        # Mirrored so ensemble-side helpers that consult the iteration
+        # counter (e.g. data screening in perturb_observations) agree with
+        # the scheme's, which is the one the loop advances.
+        self.ensemble.iteration = 0
+
+        self.lam = 0  # set LM lamda to zero as we are doing one full update.
+        if 'energy' in self.keys_da:
+            # initial energy (Remember to extract this)
+            self.trunc_energy = self.keys_da['energy']
+            if self.trunc_energy > 1:  # ensure that it is given as percentage
+                self.trunc_energy /= 100.
+        else:
+            self.trunc_energy = 0.98
 
-            # Get the perturbed observations and observation scaling
-            self.vecObs, self.enObs = self.set_observations()
-            self.enObs_conv = deepcopy(self.enObs)
+        # Get the perturbed observations and observation scaling
+        self.vecObs = self.ensemble.obs_vector
+        self.enObs = self.ensemble.perturb_observations(self.vecObs)
+        self.enObs_conv = deepcopy(self.enObs)
 
-            # Get state scaling and svd of scaled prior
-            self._ext_scaling()
+        # Get state scaling and svd of scaled prior
+        self.ensemble._ext_scaling()
 
         # Extract the inflation parameter from MDA keyword
         self.alpha = self._ext_inflation_param()
 
-        self.prev_data_misfit = None
+        self.prev_data_misfit_mean = None
+
+    # ------------------------------------------------------------------
+    # AssimilationScheme contract
+    # ------------------------------------------------------------------
+    def update_step(self) -> StepReport:
+        """Run one ES-MDA assimilation step.
+
+        Computes the inflated analysis, forecasts the trial state, then scores
+        the resulting misfit and promotes the state. Scoring after the forecast
+        is what lets outlier replacement, which runs in between, feed into the
+        number the scheme sees.
+
+        Returns
+        -------
+        bool
+            Always ``True``. ES-MDA takes a fixed number of inflated steps and
+            never rejects one. The ``success`` flag it logs compares the misfit
+            against the previous iteration and is a *reporting* signal only --
+            returning it here would make the base class discard accepted steps.
+        """
+        self.calc_analysis()
+        self.after_analysis()
+        state = self.run_forecast(self.enX_proposal)
+        self.score_and_commit()
+        return StepReport(accepted=True, misfit=self.ensemble_misfit,
+                          state=state)
+
+    def check_convergence(self) -> bool:
+        """ES-MDA runs its full schedule of inflated steps; nothing stops early."""
+        return False
+
+    def score(self, pred_data=None):
+        """Data misfit against the *un-inflated* perturbed observations.
+
+        ``enObs`` is redrawn each step with the covariance inflated by
+        ``alpha[iteration]``, so scoring against it would compare every
+        iteration to a different yardstick. ``enObs_conv`` is the copy taken
+        before any inflation, which is what makes the misfit trajectory
+        comparable across the schedule.
+        """
+        pred = self.pred_data if pred_data is None else pred_data
+        return at.calc_objectivefun(
+            self.enObs_conv, self._as_matrix(pred), self.cov_data
+        )
 
     def calc_analysis(self):
         r"""
@@ -107,174 +249,93 @@ def calc_analysis(self):
 
         where $N_a$ being the total number of assimilation steps.
         """
-        # Get Ensemble of predicted data
-        _, self.enPred = at.aug_obs_pred_data(
-            self.obs_data,
-            self.pred_data,
-            self.assim_index,
-            self.list_datatypes
+        # Get Ensemble matrix of predicted data
+        self.enPred = self.pred_data.matrix
+
+        # The prior misfit used to be computed here, behind an `iteration == 0`
+        # branch. The base scores it through `score()` before the loop now,
+        # early enough for the iteration-0 artifacts to record it.
+        self.data_random_state = deepcopy(np.random.get_state())
+        self.enObs, self.scale_data = gen_real(
+            self.vecObs,
+            self.alpha[self.iteration] * self.cov_data,
+            self.ne,
+            rng=self.ensemble.rng,
+            return_chol=True
         )
-
-        # Initialize GeoStat class for generating realizations
-        generator = Cholesky() 
-
-        if self.iteration == 1:  # first iteration
-
-            # Calculate the prior data misfit
-            data_misfit = at.calc_objectivefun(
-                pert_obs=self.enObs,
-                pred_data=self.enPred,
-                Cd=self.cov_data
-            )
-
-            # Store the (mean) data misfit (also for conv. check)
-            self.prior_data_misfit = np.mean(data_misfit)
-            self.prior_data_misfit_std = np.std(data_misfit)
-            self.data_misfit = np.mean(data_misfit)
-            self.data_misfit_std = np.std(data_misfit)
-            self.ensemble_misfit = data_misfit
-
-            # Log initial data misfit
-            self.log_update(prior_run=True)
-            self.data_random_state = deepcopy(np.random.get_state())
-            
-            self.enObs, self.scale_data = generator.gen_real(
-                self.vecObs,
-                self.alpha[self.iteration - 1] * self.cov_data,
-                self.ne,
-                return_chol=True
-            )
-            self.E = np.dot(self.enObs, self.proj)
-
-        else:
-            self.data_random_state = deepcopy(np.random.get_state())
-            self.enObs, self.scale_data = generator.gen_real(
-                self.vecObs,
-                self.alpha[self.iteration - 1] * self.cov_data,
-                self.ne,
-                return_chol=True
-            )
-            self.E = np.dot(self.enObs, self.proj)
+        self.E = np.dot(self.enObs, self.proj)
 
         if 'localanalysis' in self.keys_da:
-            self.local_analysis_update()
+            self.ensemble.local_analysis_update()
+            # The one path that still writes ensemble.enX_temp, which nothing
+            # reads now -- so take its result explicitly.
+            proposed = getattr(self.ensemble, "enX_temp", None)
+            self.enX_proposal = self.enX if proposed is None else proposed
         else:
 
             # Check for adjoint
             if hasattr(self, 'adjoints'):
-                enAdj = dtools.merge_dataframes(self.adjoints)
-                enAdj = dtools.dataframe_to_matrix(enAdj) # Shape (nd, nx, ne)
+                enAdj = self.adjoints   # (nd, nx, ne), None without adjoints
             else:
                 enAdj = None
 
-            # Perform the update
-            self.update(
-                enX = self.enX, 
-                enY = self.enPred, 
-                enE = self.enObs, 
+            # Perform the update. The proposal is scheme-local, handed to
+            # run_forecast and then reported back; the ensemble is only
+            # written when the loop commits it.
+            self.enX_proposal = self.propose_state(self.update(
+                enX = self.enX,
+                enY = self.enPred,
+                enE = self.enObs,
                 # kwargs
                 prior = self.prior_enX,
                 enAdj = enAdj
-            )
-
-            # Update the state ensemble and weights
-            if hasattr(self, 'step'):
-                self.enX_temp = self.enX + self.step
-                # This is the vector update following e.g. Evensen et al 2019 update for subspace
-            if hasattr(self, 'w_step'):
-                self.W = self.current_W + self.w_step
-                self.enX_temp = np.dot(self.prior_enX, (np.eye(self.ne) + self.W / np.sqrt(self.ne - 1)))
-                # This is the matrix update following e.g. Raanes et al 2019 update for subspace
-            if hasattr(self, 'W_step'):
-                self.W = self.current_W + self.W_step
-                X_p = self.prior_enX @ self.proj * np.sqrt(self.ne - 1)
-                self.enX_temp = np.mean(self.prior_enX, axis=1, keepdims=True) + np.dot(X_p, self.W)
-
-            if hasattr(self, 'sqrt_w_step'):
-                self.w = self.current_w + self.sqrt_w_step
-                Us, Ss, VsT = np.linalg.svd(self.S, full_matrices=False)
-                eps = 1e-8 * Ss[0]  # e.g., 1e-8 * largest
-                s_inv = 1.0 / np.sqrt(np.maximum(Ss, eps))
-                S_inv = np.diag(s_inv)
-                self.W = Us @ S_inv @ Us.T
-                X_p = self.prior_enX @ self.proj * np.sqrt(self.ne - 1)
-                x = np.mean(self.prior_enX, axis=1) + X_p @ self.w
-                self.enX_temp = np.repeat(x[:, None], self.ne, axis=1) + np.dot(X_p, self.W)
+            ))
 
 
             # Ensure limits are respected
-            limits = {key: self.prior_info[key].get('limits', (None, None)) for key in self.idX.keys()}
-            self.enX_temp = entools.clip_matrix(self.enX_temp, limits, self.idX)
+            limits = {key: self.prior_info[key].get('limits', (None, None)) for key in self.idX}
+            self.state_layout.clip(self.enX_proposal, limits)
 
-    def check_convergence(self):
-        """
-        Check if LM-EnRML have converged based on evaluation of change sizes of objective function, state and damping
-        parameter.
+    def score_and_commit(self):
+        """Score the forecast that followed the analysis, then commit the step.
+
+        Was the second half of ``check_convergence``: ES-MDA never actually
+        tested for convergence there, it recomputed the misfit, logged the
+        iteration and promoted ``enX_temp``. Under the new contract the
+        convergence question lives in :meth:`check_convergence` and this keeps
+        the bookkeeping.
 
         Returns
         -------
-        bool
-            Logic variable telling if algorithm has converged
         dict
-            Dict. with keys corresponding to conv. criteria, with logical variable telling which of them that has been
-            met
+            The ``why_stop`` record, also stored on ``self.why_stop``.
         """
 
-        self.prev_data_misfit = self.data_misfit
+        self.prev_data_misfit_mean = self.data_misfit_mean
         self.prev_data_misfit_std = self.data_misfit_std
 
-        # Get Ensemble of predicted data
-        _, enPred = at.aug_obs_pred_data(
-            self.obs_data,
-            self.pred_data,
-            self.assim_index,
-            self.list_datatypes
-        )
-
-        data_misfit = at.calc_objectivefun(self.enObs_conv, enPred, self.cov_data)
-        self.data_misfit = np.mean(data_misfit)
+        data_misfit = self.score()
+        self.data_misfit_mean     = np.mean(data_misfit)
         self.data_misfit_std = np.std(data_misfit)
+        self.ensemble_misfit = data_misfit
 
         # Logical variables for conv. criteria
-        why_stop = {'rel_data_misfit': 1 - (self.data_misfit / self.prev_data_misfit),
-                    'data_misfit': self.data_misfit,
-                    'prev_data_misfit': self.prev_data_misfit}
-
-        # Log update results
-        success = self.data_misfit < self.prev_data_misfit
-        self.log_update(success=success)
-        
-        # Return conv = False, why_stop var.
-        # Update state ensemble
-        self.enX = deepcopy(self.enX_temp)
-        self.enX_temp = None
+        why_stop = {'rel_data_misfit': 1 - (self.data_misfit_mean / self.prev_data_misfit_mean),
+                    'data_misfit': self.data_misfit_mean,
+                    'prev_data_misfit': self.prev_data_misfit_mean}
+
+        # Promote the trial state. Written through the ensemble so the next
+        # forecast and any external reader see it.
         if hasattr(self, 'W'):
             self.current_W = deepcopy(self.W)
 
-        return False, True, why_stop
-
-    def log_update(self, success=None, prior_run=False):
-        '''
-        Log the update results in a formatted table.
-        '''
-        iteration_str = f'{0 if prior_run else self.iteration}/{self.max_iter}'
-        
-        log_data = {
-            "Iteration": iteration_str,
-            "Status": "Success" if (prior_run or success) else "Failed",
-            "Data Misfit": self.data_misfit
-        }
-        
-        if not prior_run:
-            if success:
-                log_data["Reduction (%)"] = 100 * (1 - self.data_misfit / self.prev_data_misfit)
-            else:
-                log_data["Increase (%)"] = 100 * (self.data_misfit / self.prev_data_misfit - 1)
-        else:
-            log_data["Reduction (%)"] = 'N/A'
-        
-        self.logger(**log_data)
-            
+        self.why_stop = why_stop
+        return why_stop
+
+    def log_columns(self, prior_run: bool = False) -> dict:
+        """ES-MDA reports the inflation factor for the step just taken."""
+        return {"α": "" if prior_run else self.alpha[self.iteration]}
+
     def _ext_inflation_param(self):
         r"""
         Extract the data covariance inflation parameter from the MDA keyword in DATAASSIM part. Also, we check that
@@ -293,36 +354,25 @@ def _ext_inflation_param(self):
         """
         try:
             mda_opts = dict(self.keys_da['mda'])
-        except:
+        except Exception:
             mda_opts = dict([self.keys_da['mda']])
 
         # Check if INFLATION_PARAM has been provided, and if so, extract the value(s). If not, we set alpha to the
         # default value equal to the tot. no. assim. steps
         if 'inflation_param' in mda_opts:
-            # Extract value
             alpha_tmp = mda_opts['inflation_param']
+            alpha = alpha_tmp if isinstance(alpha_tmp, list) else [alpha_tmp] * len(self._ext_assim_steps())
 
-            # If one value is given, we copy it to all assim. steps. If multiple values are given, we check the
-            # number of parameters corresponds to tot. no. assim. steps
-            if not isinstance(alpha_tmp, list):  # Single input
-                alpha = [alpha_tmp] * len(self._ext_assim_steps())  # Copy value
-
-            else:
-                assert len(alpha_tmp) == len(self._ext_assim_steps()), 'Number of parameters given in INFLATION_PARAM in MDA does ' \
-                    'not match the total number of assimilation steps given by ' \
-                    'TOT_ASSIM_STEPS in same keyword!'
-
-                # Inflation parameters for each assimilation step given directly
-                alpha = alpha_tmp
-
-        else:  # Give alpha by default value
-            alpha = [len(self._ext_assim_steps())] * len(self._ext_assim_steps())
+            assert len(alpha) == len(self._ext_assim_steps()), \
+            'Number of INFLATION_PARAM values does not match TOT_ASSIM_STEPS!'
+        else:
+            n_steps = len(self._ext_assim_steps())
+            alpha = [n_steps] * n_steps
 
         # Check if alpha fulfills the criterion to machine precision
-        assert 1 - np.finfo(float).eps <= sum([(1 / x) for x in alpha]) <= 1 + np.finfo(float).eps, \
-            'The sum of the inverse of the inflation parameters given in INFLATION_PARAM does not add up to 1!'
+        assert 1 - np.finfo(float).eps <= sum(1/x for x in alpha) <= 1 + np.finfo(float).eps, \
+            'Sum of inverse inflation parameters does not add up to 1!'
 
-        # Return inflation parameter
         return alpha
 
     def _ext_assim_steps(self):
@@ -349,129 +399,15 @@ def _ext_assim_steps(self):
         """
         try:
             mda_opts = dict(self.keys_da['mda'])
-        except:
+        except Exception:
             mda_opts = dict([self.keys_da['mda']])
 
-    
+
         # Check if 'max_iter' has been given; if not, give error (mandatory in ITERATION)
         try:
             assim_steps = list(range(int(mda_opts['tot_assim_steps'])))
         except KeyError:
             raise AssertionError('TOT_ASSIM_STEPS has not been given in MDA!')
 
-        # If it is a restart run, we remove simulations already done
-        if self.restart is True:
-            # List simulations we already have done. Do this by checking pred_data.
-            # OBS: Minus 1 here do to the aborted simulation is also not None.
-            # TODO: Relying on loop_ind may not be the best strategy (?)
-            sim_done = list(range(self.loop_ind))
-
-            # Update list of assim. steps by removing simulations we have done
-            assim_steps = [ind for ind in assim_steps if ind not in sim_done]
-
         # Return list assim. steps
         return assim_steps
-
-
-class esmda_approx(esmdaMixIn, approx_update):
-    pass
-
-
-class esmda_full(esmdaMixIn, full_update):
-    pass
-
-
-class esmda_subspace(esmdaMixIn, subspace_update):
-    pass
-
-class esmda_subspace2(esmdaMixIn, subspace2_update):
-    pass
-
-
-class esmda_geo(esmda_approx):
-    """
-    This is the implementation of the ES-MDA-GEO algorithm from [1]. The main analysis step in this algorithm is the
-    same as the standard ES-MDA algorithm (implemented in the `es_mda` class). The difference between this and the
-    standard algorithm is the calculation of the inflation factor. Also see [`rafiee2017`][].
-    """
-
-    def __init__(self, keys_da):
-        """
-        The class is initialized by passing the PIPT init. file upwards in the hierarchy to be read and parsed in
-        `pipt.input_output.pipt_init.ReadInitFile`.
-        """
-        # Pass the init_file upwards in the hierarchy
-        super().__init__(keys_da)
-
-        # Within
-        self.alpha = [None] * self.tot_assim
-
-    def _calc_inflation_factor(self, pert_preddata, cov_data, energy=99):
-        """
-        We calculate the inflation factor, follow the procedure laid out in Algorithm 1 in [1].
-
-        Parameters
-        ----------
-        pert_preddata : ndarray
-            Predicted data (fwd. run) ensemble matrix perturbed with its mean
-        cov_data : ndarray
-            Data covariance matrix
-        energy : float, optional
-            Percentage of energy kept in (T)SVD decompostion of 'sensitivity' matrix (default is 99%)
-
-        Returns
-        -------
-        alpha : float
-            Inflation factor
-        beta : float
-            Geometric factor
-        """
-        # Need the square-root of the data covariance matrix
-        if np.count_nonzero(cov_data - np.diagonal(cov_data)) == 0:
-            l = np.sqrt(cov_data)  # only variance (diagonal) term
-        else:
-            # Cholesky decomposition
-            l = scilinalg.cholesky(cov_data)  # cov. matrix has off-diag. terms
-
-        # Calculate the 'sensitivity' matrix:
-        sens = (1 / np.sqrt(self.ne - 1)) * np.dot(l, pert_preddata)
-
-        # Perform SVD on sensitivtiy matrix
-        _, s_d, _ = np.linalg.svd(sens, full_matrices=False)
-
-        # If no. measurements is more than ne - 1, we only keep ne - 1 sing. val.
-        if sens.shape[0] >= self.ne:
-            s_d = s_d[:-1].copy()
-
-        # If energy is less than 100 we truncate the SVD matrices
-        if energy < 100:
-            ti = (np.cumsum(s_d) / sum(s_d)) * 100 <= energy
-            s_d = s_d[ti].copy()
-
-        # Calc average singular value
-        avg_s_d = s_d.mean()
-
-        # The inflation factor is chosen as the maximum of the average singular value (squared) and max. no. of
-        # iterations
-        alpha = np.max((avg_s_d ** 2, self.tot_assim))
-
-        # We calculate the geometric (reduction) factor (called 'common ratio' in the article). The formula is given
-        # as (1 - beta**-n) / (1 - beta**-1) = alpha (it is actually incorrect in the article, and should be as
-        # written here), with n=tot. assim. steps. Rewritten:
-        #
-        # (1-alpha)*beta**n + alpha*beta**(n-1) - 1 = 0
-        #
-        # This is of course a nasty polynomial root problem, but we use Numpy.roots, extract the real
-        # root less than 1, and hope for the best :p
-        root_coeff = np.zeros(self.tot_assim + 1)
-        root_coeff[0] = 1 - alpha  # first coeff. in polynomial
-        root_coeff[1] = alpha  # sec. coeff in polynomial
-        root_coeff[-1] = -1
-        roots = np.roots(root_coeff)
-
-        # Most likely the first root will be 1, and the second one will be the one we want. Due to numerical
-        # imprecision, the first root will not be exactly one, so we us Numpy.min to get the second root.
-        beta = np.min([x.real for x in roots if x.imag == 0 and x.real < 1])
-
-        # Return inflation and geometric factor
-        return alpha, beta
diff --git a/src/pipt/update_schemes/factory.py b/src/pipt/update_schemes/factory.py
new file mode 100644
index 00000000..f1e9e0f4
--- /dev/null
+++ b/src/pipt/update_schemes/factory.py
@@ -0,0 +1,59 @@
+"""Friendly constructors for the assimilation schemes.
+
+The analysis flavour is a *parameter* of the algorithm, not a different
+algorithm, so this module exposes one constructor per algorithm and takes the
+flavour as an argument::
+
+    from pipt import ESMDA
+    scheme = ESMDA(cfg_da, cfg_en, sim, analysis="approx")
+
+This mirrors how ``popt`` exposes ``EnOpt``/``LineSearch``/``TrustRegion`` as
+one name per algorithm. The underlying concrete classes are unchanged and stay
+importable, so ``isinstance`` checks and subclassing still work; these
+constructors resolve through :mod:`pipt.update_schemes.registry` and return an
+instance of exactly the same class as before.
+"""
+
+from pipt.update_schemes.registry import get_scheme
+
+__all__ = ["EnKF", "ES", "ESMDA", "LMEnRML", "GNEnRML", "build_scheme"]
+
+
+def build_scheme(scheme, da_input, en_input, sim, analysis=None):
+    """Construct any registered scheme by name.
+
+    Parameters
+    ----------
+    scheme : str
+        Algorithm name, e.g. ``"esmda"``.
+    da_input : dict
+        Parsed data-assimilation config.
+    en_input : dict
+        Parsed ensemble config.
+    sim : object
+        Forward simulator instance.
+    analysis : str, optional
+        Analysis flavour. Defaults to the config's ``analysis`` key, so that
+        this agrees with :func:`pipt.pipt_init.init_da`, falling back to
+        ``"approx"`` if the config does not say. Pass it to override the config.
+
+    Returns
+    -------
+    object
+        The instantiated scheme.
+    """
+    if analysis is None:
+        # The config is the source of truth, so that this agrees with
+        # `init_da`. "approx" remains the fallback for a config that does not
+        # say -- but a config that *does* say must never be overridden by a
+        # default, which is what silently built the wrong scheme before.
+        analysis = da_input.get("analysis", "approx")
+    return get_scheme(scheme, analysis)(da_input, en_input, sim)
+
+
+# The algorithm classes themselves. The flavour is a parameter of each, so
+# these are plain classes now rather than functions that pick one of eighteen.
+from pipt.update_schemes.enkf import EnKF  # noqa: E402
+from pipt.update_schemes.enrml import GNEnRML, LMEnRML  # noqa: E402
+from pipt.update_schemes.es import ES  # noqa: E402
+from pipt.update_schemes.esmda import ESMDA  # noqa: E402
diff --git a/src/pipt/update_schemes/gies/gies_base.py b/src/pipt/update_schemes/gies/gies_base.py
index fc96ee58..f7f7c3be 100644
--- a/src/pipt/update_schemes/gies/gies_base.py
+++ b/src/pipt/update_schemes/gies/gies_base.py
@@ -3,17 +3,10 @@
 """
 # External imports
 import pipt.misc_tools.analysis_tools as at
-from geostat.decomp import Cholesky
-from pipt.loop.ensemble import Ensemble
-from pipt.update_schemes.update_methods_ns.subspace_update import subspace_update
-from pipt.update_schemes.update_methods_ns.full_update import full_update
-from pipt.update_schemes.update_methods_ns.approx_update import approx_update
-import sys
-import pkgutil
-import inspect
+from pipt.ensembles import AssimilationEnsemble as Ensemble
 import numpy as np
 import copy as cp
-from scipy.linalg import cholesky, solve
+from scipy.linalg import solve
 
 # Internal imports
 
@@ -27,7 +20,7 @@ class GIESMixIn(Ensemble):
                     ensemble smoother." Computational Geosciences 26.3 (2022): 571-594.
     """
 
-    def __init__(self, keys_da, keys_fwd, sim):
+    def __init__(self, keys_da, keys_en, sim):
         """
         The class is initialized by passing the PIPT init. file upwards in the hierarchy to be read and parsed in
         `pipt.input_output.pipt_init.ReadInitFile`.
@@ -38,7 +31,7 @@ def __init__(self, keys_da, keys_fwd, sim):
             PIPT init. file containing info. to run the inversion algorithm
         """
         # Pass the init_file upwards in the hierarchy
-        super().__init__(keys_da, keys_fwd, sim)
+        super().__init__(keys_da, keys_en, sim)
 
         if self.restart is False:
             # Save prior state in separate variable
@@ -52,7 +45,7 @@ def __init__(self, keys_da, keys_fwd, sim):
             if 'actnum' in self.keys_da.keys():
                 try:
                     self.actnum = np.load(self.keys_da['actnum'])['actnum']
-                except:
+                except Exception:
                     print('ACTNUM file cannot be loaded!')
             else:
                 self.actnum = None
@@ -111,8 +104,8 @@ def calc_analysis(self):
                     self.scale_data, self.aug_pred_data[:, 0:self.ne] - self.aug_pred_data[:, self.ne, None])
 
             aug_state = at.aug_state(self.current_state, self.list_states)
-            self.update()  # run ordinary analysis
-            if hasattr(self, 'step'):
+            self.step = self.update()  # run ordinary analysis
+            if self.step is not None:
                 aug_state_upd = aug_state + self.step
             if hasattr(self, 'w_step'):
                 self.W = self.current_W + self.w_step
@@ -127,7 +120,7 @@ def calc_analysis(self):
     def check_convergence(self):
         """
         Check if LM-EnRML have converged based on evaluation of change sizes of objective function, state and damping
-        parameter. 
+        parameter.
 
         Returns
         -------
diff --git a/src/pipt/update_schemes/gies/gies_rlmmac.py b/src/pipt/update_schemes/gies/gies_rlmmac.py
index 80d03fa3..221b0ccf 100644
--- a/src/pipt/update_schemes/gies/gies_rlmmac.py
+++ b/src/pipt/update_schemes/gies/gies_rlmmac.py
@@ -4,4 +4,4 @@
 
 
 class gies_rlmmac(GIESMixIn, rlmmac_update):
-    pass
\ No newline at end of file
+    pass
diff --git a/src/pipt/update_schemes/gies/rlmmac_update.py b/src/pipt/update_schemes/gies/rlmmac_update.py
index ba70301b..6ece2d47 100644
--- a/src/pipt/update_schemes/gies/rlmmac_update.py
+++ b/src/pipt/update_schemes/gies/rlmmac_update.py
@@ -1,12 +1,10 @@
 """EnRML (IES) without the prior increment term."""
 
 import numpy as np
-from copy import deepcopy
-import copy as cp
-from scipy.linalg import solve, solve_banded, cholesky, lu_solve, lu_factor, inv
-import pickle
+from scipy.linalg import solve
 import pipt.misc_tools.analysis_tools as at
-from pipt.misc_tools.cov_regularization import _calc_loc
+import pipt.misc_tools.extract_tools as extract
+from pipt.localization.local_analysis import _calc_loc
 
 class rlmmac_update():
     """
@@ -26,7 +24,7 @@ def update(self):
             ti = (np.cumsum(s_d) / sum(s_d)) <= self.trunc_energy
             u_d, s_d, v_d = u_d[:, ti].copy(), s_d[ti].copy(), v_d[ti, :].copy()
         if 'localization' in self.keys_da:
-            if 'emp_cov' in self.keys_da and self.keys_da['emp_cov'] == 'yes':
+            if extract.is_enabled(self.keys_da.get('emp_cov', False)):
                 if len(self.scale_data.shape) == 1:
                     E_hat = np.dot(np.expand_dims(self.scale_data ** (-1),
                                    axis=1), np.ones((1, self.ne))) * self.E
@@ -66,7 +64,7 @@ def update(self):
 
                 # Mean state and perturbation matrix
                 mean_state = np.mean(aug_state, 1)
-                if 'emp_cov' in self.keys_da and self.keys_da['emp_cov'] == 'yes':
+                if extract.is_enabled(self.keys_da.get('emp_cov', False)):
                     pert_state = (self.state_scaling**(-1))[:, None] * (aug_state - np.dot(np.resize(mean_state, (len(mean_state), 1)),
                                                                                            np.ones((1, self.ne))))
                 else:
@@ -91,7 +89,7 @@ def update(self):
                     # if no distance, do full update
                     weight = np.ones((aug_state.shape[0], X.shape[1]))
                 mean_state = np.mean(aug_state, 1)
-                if 'emp_cov' in self.keys_da and self.keys_da['emp_cov'] == 'yes':
+                if extract.is_enabled(self.keys_da.get('emp_cov', False)):
                     pert_state = (aug_state - np.dot(np.resize(mean_state, (len(mean_state), 1)),
                                                      np.ones((1, self.ne))))
                 else:
@@ -108,7 +106,7 @@ def update(self):
                 try:
                     self.step = weight.multiply(
                         np.dot(pert_state, X)).dot(scaled_delta_data)
-                except:
+                except Exception:
                     self.step = (weight*(np.dot(pert_state, X))).dot(scaled_delta_data)
 
             elif sum(['dist_loc' in el for el in f]) >= 1:
@@ -116,7 +114,7 @@ def update(self):
                                                                               for elem in self.assim_index[1]],
                                                         self.list_states, self.ne, self.prior_info, data_size)
                 mean_state = np.mean(aug_state, 1)
-                if 'emp_cov' in self.keys_da and self.keys_da['emp_cov'] == 'yes':
+                if extract.is_enabled(self.keys_da.get('emp_cov', False)):
                     pert_state = (aug_state - np.dot(np.resize(mean_state, (len(mean_state), 1)),
                                                      np.ones((1, self.ne))))
                 else:
@@ -145,9 +143,9 @@ def update(self):
                             count += 1
 
                 well = [w for w in
-                        set([el[0] for el in self.localization.loc_info.keys() if type(el) == tuple])]
+                        set([el[0] for el in self.localization.loc_info.keys() if isinstance(el, tuple)])]
                 times = [t for t in set(
-                    [el[1] for el in self.localization.loc_info.keys() if type(el) == tuple])]
+                    [el[1] for el in self.localization.loc_info.keys() if isinstance(el, tuple)])]
                 tot_dat_index = {}
                 for uniq_well in well:
                     tmp_index = []
@@ -155,7 +153,7 @@ def update(self):
                         if (uniq_well, t) in act_data_list:
                             tmp_index.append(act_data_list[(uniq_well, t)])
                     tot_dat_index[uniq_well] = tmp_index
-                if 'emp_cov' in self.keys_da and self.keys_da['emp_cov'] == 'yes':
+                if extract.is_enabled(self.keys_da.get('emp_cov', False)):
                     emp_cov = True
                 else:
                     emp_cov = False
@@ -175,13 +173,13 @@ def update(self):
         else:
             # Mean state and perturbation matrix
             mean_state = np.mean(aug_state, 1)
-            if 'emp_cov' in self.keys_da and self.keys_da['emp_cov'] == 'yes':
+            if extract.is_enabled(self.keys_da.get('emp_cov', False)):
                 pert_state = (self.state_scaling**(-1))[:, None] * (aug_state - np.dot(np.resize(mean_state, (len(mean_state), 1)),
                                                                                        np.ones((1, self.ne))))
             else:
                 pert_state = (self.state_scaling**(-1)
                               )[:, None] * np.dot(aug_state, self.proj)
-            if 'emp_cov' in self.keys_da and self.keys_da['emp_cov'] == 'yes':
+            if extract.is_enabled(self.keys_da.get('emp_cov', False)):
                 if len(self.scale_data.shape) == 1:
                     E_hat = np.dot(np.expand_dims(self.scale_data ** (-1),
                                    axis=1), np.ones((1, self.ne))) * self.E
diff --git a/src/pipt/update_schemes/multilevel.py b/src/pipt/update_schemes/multilevel.py
index cb8a493b..59af02ca 100644
--- a/src/pipt/update_schemes/multilevel.py
+++ b/src/pipt/update_schemes/multilevel.py
@@ -1,58 +1,87 @@
 '''
-Here we place the classes that are required to run the multilevel schemes developed in the 4DSeis project. All methods
-inherit the ensemble class, hence the main loop is inherited. These classes will consider the analysis step.
+Multilevel schemes developed in the 4DSeis project.
+
+The multilevel machinery is *ensemble* work: it reorganises the state into one
+block per fidelity level and configures the simulator to run them. It therefore
+lives on :class:`MultilevelEnsemble`, which the scheme composes, rather than
+being inherited by the scheme itself.
+
+That split matters. ``multilevel`` previously subclassed the ensemble and
+``esmda_hybrid`` inherited from both it and the ES-MDA scheme, relying on C3
+linearisation to route ``super().__init__()`` into the scheme's constructor.
+Once the schemes stopped inheriting the ensemble, the ensemble intercepted that
+chain and the scheme's ``__init__`` silently stopped running -- leaving
+``alpha`` unset and the analysis step broken. Composition removes the ordering
+dependence entirely.
 '''
 
 #──────────────────────────────────────────────────────────────────────────────────────
-from pipt.loop.ensemble import Ensemble
-from pipt.update_schemes.esmda import esmdaMixIn
+from pipt.ensembles import AssimilationEnsemble as Ensemble
+from pipt.update_schemes.esmda import ESMDA
+from pipt.update_schemes.analysis.base import AnalysisResult
 from pipt.misc_tools import analysis_tools as at
-import pipt.misc_tools.ensemble_tools as entools
-from geostat.decomp import Cholesky
-from pipt.update_schemes.update_methods_ns.hybrid_update import hybrid_update
+from misc.sampling import gen_real
+from pipt.update_schemes.analysis.hybrid import hybrid_update
 
 import numpy as np
 from copy import deepcopy
 #──────────────────────────────────────────────────────────────────────────────────────
 
 
-__all__ = ['multilevel', 'esmda_hybrid']
+__all__ = ['MultilevelEnsemble', 'multilevel', 'esmda_hybrid']
 
-class multilevel(Ensemble):
-    """
-    Inititallize the multilevel class. Similar for all ML schemes, hence make one class for all.
+
+class MultilevelEnsemble(Ensemble):
+    """Ensemble whose state is partitioned into fidelity levels.
+
+    ``enX`` is a *list* of matrices, one per level, rather than a single
+    ``(nx, ne)`` matrix, and the simulator is configured to run each level.
+    Everything else is the ordinary assimilation ensemble.
+
+    Attributes
+    ----------
+    enX : list of ndarray
+        State ensemble per level; ``enX[l]`` has shape ``(nx, ml_ne[l])``.
+    tot_level : int
+        Number of fidelity levels.
+    ml_ne : list of int
+        Ensemble size at each level.
     """
-    def __init__(self, keys_da,keys_fwd,sim):
-        super().__init__(keys_da, keys_fwd, sim)
-        
+
+    def __init__(self, keys_da, keys_en, sim):
+        super().__init__(keys_da, keys_en, sim)
+
         self.list_states = list(self.idX.keys())
 
+        # Keep the unpartitioned prior: state scaling is defined over the whole
+        # state, not per level. Under the previous class layout the scheme's
+        # __init__ ran before the split and so saw the matrix; holding it here
+        # reproduces that without depending on constructor ordering.
+        self._flat_prior_enX = deepcopy(self.enX)
+
         # Reorganize prior ensemble to multilevel structure if nested is true
         self.enX = self.reorganize_ml_prior(self.enX)
         self.prior_enX = deepcopy(self.enX)
 
-        # Set ML specific options for simulator 
+        # Set ML specific options for simulator
         self._init_sim()
 
-        self.iteration = 0
-        self.lam = 0  # set LM lamda to zero as we are doing one full update.
-        if 'energy' in self.keys_da:
-            self.trunc_energy = self.keys_da['energy']  # initial energy (Remember to extract this)
-            if self.trunc_energy > 1:  # ensure that it is given as percentage
-                self.trunc_energy /= 100.
-        else:
-            self.trunc_energy = 0.98
-
         self.assim_index = [self.keys_da['obsname'], self.keys_da['assimindex'][0]]
-        self.list_datatypes, self.list_act_datatypes = at.get_list_data_types(self.obs_data, self.assim_index)
-
-        self.cov_data  = at.gen_covdata(self.datavar, self.assim_index, self.list_datatypes)
-        self.vecObs, _ = at.aug_obs_pred_data(
-            self.obs_data, 
-            self.pred_data, 
-            self.assim_index,
-            self.list_datatypes
+        self.list_datatypes = self.keys_da['datatype']
+
+        self.cov_data = self.obs_variance
+        self.vecObs = self.obs_vector
+
+    def _ext_scaling(self):
+        """Compute state scaling from the unpartitioned prior.
+
+        Once the prior is a list of per-level blocks, the scaling is still
+        defined over the whole state matrix.
+        """
+        self.state_scaling = at.calc_scaling(
+            self._flat_prior_enX, self.idX, self.prior_info
         )
+        self.Am = None
 
     def _init_sim(self):
         """
@@ -76,13 +105,35 @@ def reorganize_ml_prior(self, enX: np.ndarray) -> list:
         return ml_enX
 
 
+#: Historical name for the multilevel container, which used to be what schemes
+#: inherited. It is the ensemble now, so this is an alias rather than a base.
+multilevel = MultilevelEnsemble
+
 
-class esmda_hybrid(multilevel,hybrid_update,esmdaMixIn):
+class esmda_hybrid(ESMDA):
     '''
-     A multilevel implementation of the ES-MDA algorithm with the hybrid gain
+    A multilevel implementation of the ES-MDA algorithm with the hybrid gain.
+
+    Composes a :class:`MultilevelEnsemble` and binds ``hybrid_update`` for the
+    per-level gain, the same way :class:`~pipt.update_schemes.esmda.ESMDA`
+    binds ``approx_update`` and friends. It is not just ``ESMDA`` with an
+    extra flavour, though: its own ``COMPATIBLE_ANALYSES`` offers only
+    ``"hybrid"``, deliberately narrower than ``ESMDA``'s -- ``approx_update``
+    et al. expect a single ``enX``/``proj`` matrix, and this scheme's state is
+    partitioned into one such matrix *per level*, which those analyses were
+    never written to handle.
+
+    Notes
+    -----
+    Requires a ``multilevel`` block in ``keys_en`` giving ``levels``,
+    ``en_size`` per level and ``ml_weights``.
     '''
-    def __init__(self,keys_da, keys_fwd, sim):
-        super().__init__(keys_da, keys_fwd, sim)
+
+    ENSEMBLE_CLASS = MultilevelEnsemble
+    COMPATIBLE_ANALYSES = {"hybrid": hybrid_update}
+
+    def __init__(self, keys_da, keys_en, sim, analysis=None, ensemble=None):
+        super().__init__(keys_da, keys_en, sim, analysis=analysis, ensemble=ensemble)
 
         self.proj = []
         for l in range(self.tot_level):
@@ -90,43 +141,38 @@ def __init__(self,keys_da, keys_fwd, sim):
             proj_l = (np.eye(nl) - np.ones((nl, nl))/nl) / np.sqrt(nl - 1)
             self.proj.append(proj_l)
 
+    # update_step() and check_convergence() are inherited from ESMDA unchanged:
+    # the multilevel variant differs in the analysis and the scoring, not in
+    # the step choreography or the fixed schedule.
+
+    def score(self, pred_data=None):
+        """Data misfit over every fidelity level at once.
+
+        ``pred_data`` is one frame per level here, so the levels are
+        concatenated along the ensemble axis and scored as a single ensemble
+        against the un-inflated perturbations, as
+        :meth:`pipt.update_schemes.esmda.ESMDA.score` does for one level.
+        """
+        pred = self.pred_data if pred_data is None else pred_data
+        levels = [self._as_matrix(frame) for frame in pred]
+        return at.calc_objectivefun(
+            self.enObs_conv, np.concatenate(levels, axis=1), self.cov_data
+        )
 
     def calc_analysis(self):
-        
+        """The ES-MDA analysis over every fidelity level: per-level predictions, redrawn observations, the hybrid update, clipped proposals."""
+
         # Get ensemble predictions at all levels
         self.enPred = []
         for l in range(self.tot_level):
-            _, enPred_level = at.aug_obs_pred_data(
-                self.obs_data, 
-                [el[l] for el in self.pred_data], 
-                self.assim_index,
-                self.list_datatypes
-            )
-            self.enPred.append(enPred_level) 
+            enPred_level = self.pred_data[l].matrix
+            self.enPred.append(enPred_level)
 
         # Initialize GeoStat class for generating realizations
-        cholesky = Cholesky()
-
-        if self.iteration == 1:  # first iteration
-
-            # Note, evaluate for high fidelity model
-            data_misfit = at.calc_objectivefun(
-                self.enObs_conv, 
-                np.concatenate(self.enPred,axis=1), # Is this correct, given the comment above??????
-                self.cov_data
-            )
-
-            # Store the (mean) data misfit (also for conv. check)
-            self.data_misfit = np.mean(data_misfit)
-            self.prior_data_misfit = np.mean(data_misfit)
-            self.prior_data_misfit_std = np.std(data_misfit)
-            self.data_misfit = np.mean(data_misfit)
-            self.data_misfit_std = np.std(data_misfit)
-
-            # Log initial data misfit
-            self.log_update(prior_run=True)
-            self.data_random_state = deepcopy(np.random.get_state())
 
+        if self.iteration == 0:  # first iteration
+
+            self.data_random_state = deepcopy(np.random.get_state())
 
             self.ml_enObs = []
             self.scale_data = []
@@ -134,10 +180,11 @@ def calc_analysis(self):
             for l in range(self.tot_level):
 
                 # Generate real data and scale data
-                enObs_level, scale_data_level = cholesky.gen_real(
+                enObs_level, scale_data_level = gen_real(
                     self.vecObs,
-                    self.alpha[self.iteration - 1] * self.cov_data, 
+                    self.alpha[self.iteration] * self.cov_data,
                     self.ml_ne[l],
+                    rng=self.ensemble.rng,
                     return_chol=True
                 )
                 self.ml_enObs.append(enObs_level)
@@ -148,67 +195,59 @@ def calc_analysis(self):
             self.data_random_state = deepcopy(np.random.get_state())
 
             for l in range(self.tot_level):
-                self.ml_enObs[l], self.scale_data[l] = cholesky.gen_real(
+                self.ml_enObs[l], self.scale_data[l] = gen_real(
                     self.vecObs,
-                    self.alpha[self.iteration - 1] * self.cov_data,
+                    self.alpha[self.iteration] * self.cov_data,
                     self.ml_ne[l],
+                    rng=self.ensemble.rng,
                     return_chol=True
                 )
                 self.E[l] = np.dot(self.ml_enObs[l], self.proj[l])
 
-        # Calculate update step
-        self.update(
+        # Calculate the update step: one state-space step per fidelity level.
+        result = AnalysisResult.coerce(self.update(
             enX = self.enX,
             enY = self.enPred,
             enE = self.ml_enObs
-        )
-        if hasattr(self, 'step'):
-            self.enX_temp = [self.enX[l] + self.step[l] for l in range(self.tot_level)]
-            # Enforce limits
-            limits = {key: self.prior_info[key].get('limits', (None, None)) for key in self.idX.keys()}
-            self.enX_temp = [entools.clip_matrix(self.enX_temp[l], limits, self.idX) for l in range(self.tot_level)]
-
-    def check_convergence(self):
-        """
-        Check ESMDA objective function for logging purposes.
+        ))
+        self.step = result.step
+        limits = {key: self.prior_info[key].get('limits', (None, None)) for key in self.idX}
+        # A scheme-local proposal, one entry per fidelity level.
+        enX_proposal = []
+        for l in range(self.tot_level):
+            level = self.enX[l] + self.step[l]
+            self.state_layout.clip(level, limits)
+            enX_proposal.append(level)
+        self.enX_proposal = enX_proposal
+
+    def score_and_commit(self):
+        """Score the forecast that followed the analysis, then commit the step.
+
+        Was the second half of ``check_convergence``. ES-MDA never tested for
+        convergence there; it recomputed the misfit, logged the iteration and
+        promoted ``enX_temp``.
+
+        Returns
+        -------
+        dict
+            The ``why_stop`` record, also stored on ``self.why_stop``.
         """
 
-        self.prev_data_misfit = self.data_misfit
+        self.prev_data_misfit_mean = self.data_misfit_mean
         self.prev_data_misfit_std = self.data_misfit_std
 
-        # Prelude to calc. conv. check (everything done below is from calc_analysis)
-        enPred = []
-        for l in range(self.tot_level):
-            _, enPred_level = at.aug_obs_pred_data(
-                self.obs_data, 
-                [el[l] for el in self.pred_data], 
-                self.assim_index,
-                self.list_datatypes
-            )
-            enPred.append(enPred_level)
-
-        data_misfit = at.calc_objectivefun(
-            self.enObs_conv, 
-            np.concatenate(enPred,axis=1), 
-            self.cov_data
-        )
-        self.data_misfit = np.mean(data_misfit)
+        data_misfit = self.score()
+        self.ensemble_misfit = data_misfit
+        self.data_misfit_mean = np.mean(data_misfit)
         self.data_misfit_std = np.std(data_misfit)
 
         # Logical variables for conv. criteria
-        why_stop = {'rel_data_misfit': 1 - (self.data_misfit / self.prev_data_misfit),
-                    'data_misfit': self.data_misfit,
-                    'prev_data_misfit': self.prev_data_misfit}
-
-        # Log update results
-        success = self.data_misfit < self.prev_data_misfit
-        self.log_update(success=success)
-
-        # Return conv = False, why_stop var.
-        self.enX = deepcopy(self.enX_temp)
-        self.enX_temp = None
+        why_stop = {'rel_data_misfit': 1 - (self.data_misfit_mean / self.prev_data_misfit_mean),
+                    'data_misfit': self.data_misfit_mean,
+                    'prev_data_misfit': self.prev_data_misfit_mean}
 
         if hasattr(self, 'W'):
             self.current_W = deepcopy(self.W)
 
-        return False, True, why_stop
+        self.why_stop = why_stop
+        return why_stop
diff --git a/src/pipt/update_schemes/registry.py b/src/pipt/update_schemes/registry.py
new file mode 100644
index 00000000..0df3a38f
--- /dev/null
+++ b/src/pipt/update_schemes/registry.py
@@ -0,0 +1,171 @@
+"""Explicit registry of selectable assimilation schemes.
+
+PIPT historically resolved a scheme by string surgery on the config::
+
+    getattr(import_module('pipt.update_schemes.' + daalg[0]),
+            f'{daalg[1]}_{analysis}')
+
+That failed badly: a typo in ``daalg`` surfaced as a bare
+``ModuleNotFoundError`` or ``AttributeError`` naming a symbol the user never
+wrote, there was no way to ask what the valid combinations are, and any tool
+wanting to list the available schemes had to guess at module contents.
+
+A later refactor replaced the string surgery with an explicit table, but built
+it from eighteen hand-written classes -- one per ``(scheme, analysis)``
+combination -- because the analysis flavour used to be baked into the class
+through mixin composition. It no longer is: every algorithm class declares its
+own ``COMPATIBLE_ANALYSES`` (flavour name -> analysis class) and takes
+``analysis`` as a constructor argument that picks from it (see
+``AnalysisBindingMixin`` for how). The per-combination classes had become pure
+duplication -- ``esmda_approx`` was nothing but ``class esmda_approx(ESMDA):
+FLAVOUR = "approx"`` -- so this module now derives the regular combinations
+from two small tables instead of storing eighteen classes:
+
+``ALGORITHMS``
+    One entry per algorithm, e.g. ``"esmda" -> ESMDA``.
+``SPECIAL_SCHEMES``
+    Combinations backed by a real, distinct implementation rather than a
+    registered analysis flavour -- ``esmda_hybrid`` (multilevel ES-MDA) is
+    an algorithm in its own right that happens to share the ``esmda`` name,
+    not an alias.
+
+Extending the registry
+----------------------
+Schemes living outside this repository can register themselves without
+editing this file::
+
+    from pipt.update_schemes.registry import register_scheme
+    register_scheme("myscheme", "approx", MyScheme)
+"""
+
+from functools import partial
+
+from pipt.update_schemes.enkf import EnKF
+from pipt.update_schemes.enrml import GNEnRML, LMEnRML, co_lm_enrml, gn_enrml
+from pipt.update_schemes.es import ES
+from pipt.update_schemes.esmda import ESMDA
+# esmda_hybrid is a multilevel variant and lives with the multilevel machinery.
+from pipt.update_schemes.multilevel import esmda_hybrid
+
+__all__ = [
+    "ALGORITHMS",
+    "SPECIAL_SCHEMES",
+    "available_schemes",
+    "get_scheme",
+    "register_scheme",
+]
+
+
+#: One class per algorithm. The analysis flavour is a constructor argument,
+#: not part of this mapping.
+ALGORITHMS: dict[str, type] = {
+    "enkf": EnKF,
+    "es": ES,
+    "esmda": ESMDA,
+    "lmenrml": LMEnRML,
+    "gnenrml": GNEnRML,
+    # Historical names still found in configs. Each is a thin subclass whose
+    # COMPATIBLE_ANALYSES holds the one flavour the name always meant, so
+    # asking it for another flavour fails the same way as any other scheme.
+    "co_lm_enrml": co_lm_enrml,
+    "gn_enrml": gn_enrml,
+}
+
+#: Combinations backed by a distinct implementation rather than a registered
+#: analysis flavour. Checked before the generic algorithm+flavour resolution,
+#: so also the way to override or add a genuinely different scheme.
+SPECIAL_SCHEMES: dict[tuple[str, str], type] = {
+    ("esmda", "hybrid"): esmda_hybrid,
+}
+
+
+def register_scheme(scheme: str, analysis: str, cls: type, *, overwrite: bool = False) -> None:
+    """Add a scheme to the registry.
+
+    Parameters
+    ----------
+    scheme : str
+        Scheme name, as it appears in the config's ``scheme`` key.
+    analysis : str
+        Analysis flavour, as it appears in the config's ``analysis`` key.
+    cls : type
+        Class implementing the combination.
+    overwrite : bool, optional
+        Allow replacing an existing entry. Defaults to ``False`` so that two
+        packages silently claiming the same key is an error rather than a
+        load-order lottery.
+    """
+    key = (str(scheme).lower(), str(analysis).lower())
+    if not overwrite:
+        existing = _resolve(key)
+        if existing is not None:
+            name = getattr(existing, "func", existing).__name__
+            raise ValueError(
+                f"Scheme {key} is already registered to {name}; "
+                f"pass overwrite=True to replace it."
+            )
+    SPECIAL_SCHEMES[key] = cls
+
+
+def available_schemes() -> list[tuple[str, str]]:
+    """Return the registered ``(scheme, analysis)`` combinations, sorted."""
+    combos = {
+        (name, flavour)
+        for name, cls in ALGORITHMS.items()
+        for flavour in cls.COMPATIBLE_ANALYSES
+    }
+    combos |= set(SPECIAL_SCHEMES)
+    return sorted(combos)
+
+
+#: Generic algorithm+flavour combinations, built lazily and cached so that
+#: repeated lookups of the same combination return the same object -- as they
+#: did when this was a flat dict of classes.
+_generic_cache: dict[tuple[str, str], partial] = {}
+
+
+def _resolve(key: tuple[str, str]):
+    """Look up ``key`` without raising. ``None`` if it is not registered."""
+    if key in SPECIAL_SCHEMES:
+        return SPECIAL_SCHEMES[key]
+    algo, flavour = key
+    if algo in ALGORITHMS and flavour in ALGORITHMS[algo].COMPATIBLE_ANALYSES:
+        if key not in _generic_cache:
+            _generic_cache[key] = partial(ALGORITHMS[algo], analysis=flavour)
+        return _generic_cache[key]
+    return None
+
+
+def get_scheme(scheme: str, analysis: str):
+    """Look up the constructor for a ``(scheme, analysis)`` combination.
+
+    Returns
+    -------
+    callable
+        Either the class directly (for a :data:`SPECIAL_SCHEMES` entry) or the
+        algorithm class with ``analysis`` pre-bound via :func:`functools.partial`.
+        Either way, call it as ``result(da_input, en_input, sim)``.
+
+    Raises
+    ------
+    KeyError
+        If the combination is not registered. The message distinguishes an
+        unknown scheme from a known scheme with an unsupported analysis
+        flavour, and lists the valid options in both cases.
+    """
+    key = (str(scheme).lower(), str(analysis).lower())
+    resolved = _resolve(key)
+    if resolved is not None:
+        return resolved
+
+    if key[0] not in ALGORITHMS:
+        raise KeyError(
+            f"Unknown assimilation scheme '{scheme}'. "
+            f"Available schemes: {', '.join(sorted(ALGORITHMS))}."
+        )
+
+    flavours = sorted(flavour for name, flavour in available_schemes() if name == key[0])
+    raise KeyError(
+        f"Scheme '{scheme}' has no '{analysis}' analysis flavour. "
+        f"Available flavours for '{scheme}': {', '.join(flavours)}."
+    )
diff --git a/src/pipt/update_schemes/update_methods_ns/__init__.py b/src/pipt/update_schemes/update_methods_ns/__init__.py
deleted file mode 100644
index 64972607..00000000
--- a/src/pipt/update_schemes/update_methods_ns/__init__.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Descriptive description."""
diff --git a/src/pipt/update_schemes/update_methods_ns/approx_update.py b/src/pipt/update_schemes/update_methods_ns/approx_update.py
deleted file mode 100644
index d44f7f58..00000000
--- a/src/pipt/update_schemes/update_methods_ns/approx_update.py
+++ /dev/null
@@ -1,237 +0,0 @@
-"""EnRML (IES) without the prior increment term."""
-
-import numpy as np
-from copy import deepcopy
-import copy as cp
-from scipy.linalg import solve, solve_banded, cholesky, lu_solve, lu_factor, inv
-import pickle
-
-import pipt.misc_tools.ensemble_tools as entools
-import pipt.misc_tools.analysis_tools as at
-
-from pipt.misc_tools.cov_regularization import _calc_loc
-
-
-class approx_update():
-    """
-    Approximate LM Update scheme as defined in "Chen, Y., & Oliver, D. S. (2013). Levenberg–Marquardt forms of the iterative ensemble
-    smoother for efficient history matching and uncertainty quantification. Computational Geosciences, 17(4), 689–703.
-    https://doi.org/10.1007/s10596-013-9351-5". Note that for a EnKF or ES update, or for update within GN scheme, lambda = 0.
-    """
-
-    def update(self, enX, enY, enE, **kwargs):
-        ''' 
-        Perform the approximate LM update.
-
-        Parameters:
-        ----------
-            enX : np.ndarray 
-                State ensemble matrix (nx, ne)
-            
-            enY : np.ndarray
-                Predicted data ensemble matrix (nd, ne)
-            
-            enE : np.ndarray
-                Ensemble of perturbed observations (nd, ne)
-        '''
-
-        # Scale and center the ensemble matrecies
-        enYcentered = self.scale(np.dot(enY, self.proj), self.scale_data)
-
-        # Perform truncated SVD
-        Ud, Sd, VTd = at.truncSVD(enYcentered, energy=self.trunc_energy)
-
-        # Check for localization methods
-        if 'localization' in self.keys_da:
-            loc_info = self.localization.loc_info
-
-            # Calculate the localization projection matrix
-            if 'emp_cov' in self.keys_da and self.keys_da['emp_cov'] == 'yes':
-                # Scale and center the data ensemble matrix
-                enEcentered = self.scale(np.dot(enE, self.proj), self.scale_data)
-
-                # Calculate intermediate matrix
-                Sinv = np.diag(1/Sd)
-                X0 = Sinv @ Ud.T @ enEcentered
-
-                # Eigen decomposition of X0 X0^T
-                eigval, eigvec = np.linalg.eig(X0 @ X0.T)
-                reg_term = (self.lam + 1) * np.diag(eigval) + np.eye(len(eigval))
-                X = (VTd.T @ eigvec) @ solve(reg_term, (Ud.T @ (Sinv @ eigvec)).T)
-                
-            else:
-                reg_term = (self.lam + 1)*np.eye(Sd.size) + np.diag(Sd**2)
-                X = VTd.T @ np.diag(Sd) @ solve(reg_term, Ud.T)
-
-            
-            # Check for adaptive localization
-            if 'autoadaloc' in loc_info:
-
-                # Scale and center the state ensemble matrix, enX
-                if ('emp_cov' in self.keys_da) and (self.keys_da['emp_cov'] == 'yes'):
-                    enXcentered = self.scale(enX - np.mean(enX, 1)[:,None], self.state_scaling)
-                else:
-                    enXcentered = self.scale(np.dot(enX, self.proj), self.state_scaling)
-
-                # Calculate and scale difference between observations and predictions (residuals)
-                enRes = self.scale(enE - enY, self.scale_data)
-
-                # Compute the update step with auto-adaptive localization
-                self.step = self.localization.auto_ada_loc(
-                    pert_state     = self.state_scaling[:, None]*enXcentered, 
-                    proj_pred_data = np.dot(X, enRes),
-                    curr_param     = self.list_states,
-                    prior_info     = self.prior_info
-                )
-
-
-            # Check for local analysis 
-            elif ('localanalysis' in loc_info) and (loc_info['localanalysis']):
-                
-                # Calculate weights
-                if 'distance' in loc_info:
-                    weight = _calc_loc(
-                        max_dist   = loc_info['range'], 
-                        distance   = loc_info['distance'],
-                        prior_info = self.prior_info[self.list_states[0]], 
-                        loc_type   = loc_info['type'], 
-                        ne = self.ne
-                    )
-                else: # if no distance, do full update
-                    weight = np.ones((enX.shape[0], X.shape[1]))
-
-                # Center ensemble matrix
-                enXcentered = enX - np.mean(enX, axis=1, keepdims=True)
-
-                if (not ('emp_cov' in self.keys_da) and (self.keys_da['emp_cov'] == 'yes')):
-                    enXcentered /= np.sqrt(self.ne - 1)
-
-                # Calculate and scale difference between observations and predictions (residuals)
-                enRes = self.scale(enE - enY, self.scale_data)
-
-                # Compute the update step with local analysis
-                try:
-                    self.step = weight.multiply(np.dot(enXcentered, X)).dot(enRes)
-                except:
-                    self.step = (weight*(np.dot(enXcentered, X))).dot(enRes)
-
-
-            # Check for distance based localization
-            elif ('dist_loc' in self.keys_da['localization'].keys()) or ('dist_loc' in self.keys_da['localization'].values()):
-
-                # Setup localization mask
-                mask = self.localization.localize(
-                    self.list_datatypes, 
-                    [self.keys_da['truedataindex'][int(elem)] for elem in self.assim_index[1]],
-                    self.list_states, 
-                    self.ne, 
-                    self.prior_info, 
-                    at.get_obs_size(self.obs_data, self.assim_index[1], self.list_datatypes)
-                )
-
-                # Center ensemble matrix
-                enXcentered = enX - np.mean(enX, axis=1, keepdims=True)
-
-                if not ('emp_cov' in self.keys_da and self.keys_da['emp_cov'] == 'yes'):
-                    enXcentered /= np.sqrt(self.ne - 1)
-
-                # Calculate and scale difference between observations and predictions (residuals)
-                enRes = self.scale(enE - enY, self.scale_data)
-
-                # Compute the update step with distance-based localization
-                self.step = mask.multiply(np.dot(enXcentered, X)).dot(enRes)
-
-
-
-            # Else do parallel update (NOT TESTED AFTER UPDATES)
-            else:
-                act_data_list = {}
-                count = 0
-                for i in self.assim_index[1]:
-                    for el in list(self.idX.keys()):
-                        if self.real_obs_data[int(i)][el] is not None:
-                            act_data_list[(el, float(self.keys_da['truedataindex'][int(i)]))] = count
-                            count += 1
-
-                well  = [w for w in set([el[0] for el in loc_info.keys() if type(el) == tuple])]
-                times = [t for t in set([el[1] for el in loc_info.keys() if type(el) == tuple])]
-
-                tot_dat_index = {}
-                for uniq_well in well:
-                    tmp_index = []
-                    for t in times:
-                        if (uniq_well, t) in act_data_list:
-                            tmp_index.append(act_data_list[(uniq_well, t)])
-                    tot_dat_index[uniq_well] = tmp_index
-
-                if ('emp_cov' in self.keys_da) and (self.keys_da['emp_cov'] == 'yes'):
-                    emp_cov = True
-                else:
-                    emp_cov = False
-
-                self.step = at.parallel_upd(
-                    list(self.idX.keys()), 
-                    self.prior_info, 
-                    entools.matrix_to_dict(enX, self.idX),
-                    X,
-                    loc_info, 
-                    enE, 
-                    enY,
-                    int(self.keys_fwd['parallel']),
-                    actnum=loc_info['actnum'],
-                    field_dim=loc_info['field'],
-                    act_data_list=tot_dat_index,
-                    scale_data=self.scale_data,
-                    num_states=len([el for el in list(self.idX.keys())]),
-                    emp_d_cov=emp_cov
-                )
-                self.step = at.aug_state(self.step, list(self.idX.keys()))
-
-        else:
-
-            # if ('emp_cov' in self.keys_da) and (self.keys_da['emp_cov'] == 'yes'):
-                
-            #     # Scale and center the ensemble matrecies: enX and enE
-            #     enXcentered = self.scale(enX - np.mean(enX, 1)[:,None], self.state_scaling)
-            #     enEcentered = self.scale(enE - np.mean(enE, 1)[:,None], self.scale_data)
-
-            #     Sinv = np.diag(1/Sd)
-            #     X0 = Sinv @ Ud.T @ enEcentered
-            #     eigval, eigvec = np.linalg.eig(X0 @ X0.T)
-
-            #     # Calculate and scale difference between observations and predictions (residuals)
-            #     enRes = self.scale(enE - enY, self.scale_data)
-
-            #     # Compute the update step
-            #     X1 = (Ud @ Sinv @ eigvec).T @ enRes
-            #     X2 = solve((self.lam + 1) * np.diag(eigval) + np.eye(len(eigval)), X1)
-            #     X3 = np.dot(VTd.T, eigvec) @ X2
-            #     self.step = np.dot(self.state_scaling[:, None]*enXcentered, X3)
- 
-            # else:
-            enXcentered = self.scale(np.dot(enX, self.proj), self.state_scaling)
-            enRes = self.scale(enE - enY, self.scale_data)
-            
-            # Compute the update step
-            X1 = Ud.T @ enRes
-            X2 = solve((self.lam + 1)*np.eye(Sd.size) + np.diag(Sd**2), X1)
-            X3 = VTd.T @ np.diag(Sd) @ X2
-            self.step = np.dot(self.state_scaling[:, None] * enXcentered, X3)
-
-
-    def scale(self, data, scaling):
-        """
-        Scale the data perturbations by the data error standard deviation.
-
-        Args:
-            data (np.ndarray): data perturbations
-            scaling (np.ndarray): data error standard deviation
-
-        Returns:
-            np.ndarray: scaled data perturbations
-        """
-
-        if len(scaling.shape) == 1:
-            return (scaling ** (-1))[:, None] * data
-        else:
-            return solve(scaling, data)
diff --git a/src/pipt/update_schemes/update_methods_ns/full_update.py b/src/pipt/update_schemes/update_methods_ns/full_update.py
deleted file mode 100644
index 406081ce..00000000
--- a/src/pipt/update_schemes/update_methods_ns/full_update.py
+++ /dev/null
@@ -1,88 +0,0 @@
-"""EnRML (IES) as in 2013."""
-
-import numpy as np
-from copy import deepcopy
-import copy as cp
-from scipy.linalg import solve, solve_banded, cholesky, lu_solve, lu_factor, inv
-import pickle
-import pipt.misc_tools.analysis_tools as at
-
-
-class full_update():
-    """
-    Full LM Update scheme as defined in "Chen, Y., & Oliver, D. S. (2013). Levenberg–Marquardt forms of the iterative ensemble
-    smoother for efficient history matching and uncertainty quantification. Computational Geosciences, 17(4), 689–703.
-    https://doi.org/10.1007/s10596-013-9351-5". Note that for a EnKF or ES update, or for update within GN scheme, lambda = 0.
-
-    !!! note
-        no localization is implemented for this method yet.
-    """
-
-    def update(self, enX, enY, enE, **kwargs):
-
-        # Get prior ensemble if provided
-        priorX = kwargs.get('prior', self.prior_enX)
-
-        if self.Am is None:
-            self.ext_Am() # do this only once 
-
-        # Scale and center the ensemble matrecies
-        enYcentered = self.scale(np.dot(enY, self.proj), self.scale_data) 
-        enXcentered = self.scale(np.dot(enX, self.proj), self.state_scaling)
-
-        # Perform tuncated SVD
-        u_d, s_d, v_d = at.truncSVD(enYcentered, energy=self.trunc_energy)
-
-        # Compute the update step
-        x_1 = np.dot(u_d.T, self.scale(enE - enY, self.scale_data))
-        x_2 = solve(((self.lam + 1) * np.eye(len(s_d)) + np.diag(s_d ** 2)), x_1)
-        x_3 = np.dot(np.dot(v_d.T, np.diag(s_d)), x_2)
-        delta_m1 = np.dot((self.state_scaling[:, None]*enXcentered), x_3)
-
-        x_4 = np.dot(self.Am.T, (self.state_scaling**(-1))[:, None]*(enX - priorX))
-        x_5 = np.dot(self.Am, x_4)
-        x_6 = np.dot(enXcentered.T, x_5)
-        x_7 = np.dot(v_d.T, solve(((self.lam + 1) * np.eye(len(s_d)) + np.diag(s_d ** 2)), np.dot(v_d, x_6)))
-        delta_m2 = -np.dot((self.state_scaling[:, None]*enXcentered), x_7)
-
-        self.step = delta_m1 + delta_m2
-    
-
-    def scale(self, data, scaling):
-        """
-        Scale the data perturbations by the data error standard deviation.
-
-        Args:
-            data (np.ndarray): data perturbations
-            scaling (np.ndarray): data error standard deviation
-
-        Returns:
-            np.ndarray: scaled data perturbations
-        """
-
-        if len(scaling.shape) == 1:
-            return (scaling ** (-1))[:, None] * data
-        else:
-            return solve(scaling, data)
-    
-    def ext_Am(self, *args, **kwargs):
-        """
-        The class is initialized by calculating the required Am matrix.
-        """
-
-        delta_scaled_prior = self.state_scaling[:, None] * np.dot(self.prior_enX, self.proj)
-        u_d, s_d, v_d = np.linalg.svd(delta_scaled_prior, full_matrices=False)
-
-        # remove the last singular value/vector. This is because numpy returns all ne values, while the last is actually
-        # zero. This part is a good place to include eventual additional truncation.
-        energy = 0
-        trunc_index = len(s_d) - 1  # inititallize
-        for c, elem in enumerate(s_d):
-            energy += elem
-            if energy / sum(s_d) >= self.trunc_energy:
-                trunc_index = c  # take the index where all energy is preserved
-                break
-        u_d, s_d, v_d = u_d[:, :trunc_index +
-                                1], s_d[:trunc_index + 1], v_d[:trunc_index + 1, :]
-        self.Am = np.dot(u_d, np.eye(trunc_index + 1) *
-                         ((s_d ** (-1))[:, None]))  # notation from paper
diff --git a/src/pipt/update_schemes/update_methods_ns/hybrid_update.py b/src/pipt/update_schemes/update_methods_ns/hybrid_update.py
deleted file mode 100644
index e7d5bc5e..00000000
--- a/src/pipt/update_schemes/update_methods_ns/hybrid_update.py
+++ /dev/null
@@ -1,87 +0,0 @@
-"""
-ES, and Iterative ES updates with hybrid update matrix calculated from multi-fidelity runs.
-"""
-
-import numpy as np
-from scipy.linalg import solve
-from pipt.misc_tools import analysis_tools as at
-
-class hybrid_update:
-    '''
-    Class for hybrid update schemes as described in: Fossum, K., Mannseth, T., & Stordal, A. S. (2020). Assessment of
-    multilevel ensemble-based data assimilation for reservoir history matching. Computational Geosciences, 24(1),
-    217–239. https://doi.org/10.1007/s10596-019-09911-x
-
-    Note that the scheme is slightly modified to be inline with the standard (I)ES approximate update scheme. This
-    enables the scheme to efficiently be coupled with multiple updating strategies via class MixIn
-    '''
-
-    def scale(self, data, scaling):
-        """
-        Scale the data perturbations by the data error standard deviation.
-
-        Args:
-            data (np.ndarray): data perturbations
-            scaling (np.ndarray): data error standard deviation
-
-        Returns:
-            np.ndarray: scaled data perturbations
-        """
-
-        if len(scaling.shape) == 1:
-            return (scaling ** (-1))[:, None] * data
-        else:
-            return solve(scaling, data)
-        
-    def update(self, enX, enY, enE, **kwargs):
-        '''
-        Perform the hybrid update.
-
-        Parameters:
-        ----------
-            enX : list of np.ndarray 
-                List of state ensemble matrices for each level (nx, ne)
-            
-            enY : list of np.ndarray
-                List of predicted data ensemble matrices for each level (nd, ne)
-            
-            enE : list of np.ndarray
-                List of ensemble of perturbed observations for each level (nd, ne)
-        '''
-        # Loop over levels to calculate the update step
-        X3 = []
-        enXcentered = []
-        for l in range(self.tot_level):
-            
-            # Get Perturbed state ensemble at level l
-            if ('emp_cov' in self.keys_da) and (self.keys_da['emp_cov'] == 'yes'):
-                enXcentered.append(self.scale(enX[l] - np.mean(enX[l], 1)[:,None], self.state_scaling))
-            else:
-                enXcentered.append(self.scale(np.dot(enX[l], self.proj[l]), self.state_scaling))
-
-            # Calculate truncated SVD of predicted data ensemble at level l 
-            enYcentered = self.scale(np.dot(enY[l], self.proj[l]), self.scale_data[l])
-            Ud, Sd, VTd = at.truncSVD(enYcentered, energy=self.trunc_energy)
-
-            X2 = solve(((self.lam + 1)*np.eye(len(Sd)) + np.diag(Sd**2)), Ud.T)
-            X3.append(np.dot(np.dot(VTd.T, np.diag(Sd)), X2))
-                
-        # Calculate each row of self.step individually to avoid memory issues.
-        self.step = [np.empty(enXcentered[l].shape) for l in range(self.tot_level)]
-        step_size = min(1000, int(self.state_scaling.shape[0]/2)) # do maximum 1000 rows at a time.
-
-        # Generate row batches
-        nrows = self.state_scaling.shape[0]
-        row_step = [np.arange(s, min(s + step_size, nrows)) for s in range(0, nrows, step_size)]
-
-        # Loop over rows
-        for row in row_step:
-            ml_weights = self.multilevel['ml_weights']
-            kg = sum([ml_weights[l]*np.dot(enXcentered[l][row, :], X3[l]) for l in range(self.tot_level)])
-
-            # Loop over levels
-            for l in range(self.tot_level):
-                enRes = self.scale(enE[l] - enY[l], self.scale_data[l])
-                self.step[l][row, :] = np.dot(self.state_scaling[row, None] * kg, enRes)
-
-
diff --git a/src/pipt/update_schemes/update_methods_ns/margIS_update.py b/src/pipt/update_schemes/update_methods_ns/margIS_update.py
deleted file mode 100644
index f7aa1eb8..00000000
--- a/src/pipt/update_schemes/update_methods_ns/margIS_update.py
+++ /dev/null
@@ -1,101 +0,0 @@
-"""Stochastic iterative ensemble smoother (IES, i.e. EnRML) with *subspace* implementation."""
-
-import numpy as np
-from scipy.linalg import solve, lu_solve, lu_factor, cho_solve
-
-import pipt.misc_tools.analysis_tools as at
-
-
-class margIS_update():
-    """
-    MargIES update from Stordal et.al.
-    This is now implemented with perturbed observations, which means that we set a prior belief on the data uncertainty.
-    Thus, the prior is an invers chi2 distriubtuinm and after scaling the mean varians is 1.
-    """
-
-    def update(self, enX, enY, enE, **kwargs):
-
-        if self.iteration == 1:  # method requires some initiallization
-            self.current_W = np.eye(self.ne)
-            self.current_w = np.zeros(self.ne)
-            self.D = self.scale(enE, self.scale_data)
-            # Scale everything so that data uncertainty is I
-
-        sY = self.scale(enY, self.scale_data) #Scaling is same as with 'known' uncertainty, hence makes sense to set s = 1
-        self.S = 0
-
-        deltaD = 0
-        deltaD_sqrt = 0
-
-        Y = np.linalg.solve(self.current_W.T, sY.T).T
-        Y = Y @ self.proj * np.sqrt(self.ne - 1)
-        index = np.arange(0, 70, 70)  # Has to be specified via data types (or select each data)...
-        M = 1 #Numbers of data per type. Computed from index
-        s = 1 #should be default option with possibility to change in setup
-        nu = self.ne-1 #should be default option with possibility to change in setup
-        for j in range(70):
-
-            delta = self.D[index,:]-sY[index,:]
-            Chi = np.sum(delta * delta, axis = 0)
-            Chi = np.mean(Chi)
-            Ratio = (M + nu) / (Chi + nu*s*s)
-            #Ratio = 1
-            #Gradient
-            deltaD = deltaD + (Y[index,:] * Ratio).T @ delta
-            deltaD_sqrt = deltaD_sqrt + np.mean((Y[index, :] * Ratio).T @ delta ,axis=1)
-            # Hessian
-            self.S = self.S + (Y[index,:] * Ratio).T @ Y[index,:]
-            index += 1
-
-        deltaM = (self.ne-1)*(np.eye(self.ne)-self.current_W)
-        deltaM_sqrt = (self.ne-1)*self.current_w
-        self.S = self.S + np.eye(self.ne) * (self.ne - 1)
-        Delta = deltaM + deltaD
-        Delta_sqrt = deltaM_sqrt + deltaD_sqrt
-
-
-        self.W_step =   np.linalg.solve(self.S, Delta) / (1 + self.lam)
-       # self.sqrt_w_step = np.linalg.solve(self.S, Delta_sqrt) / (1 + self.lam)
-
-    def scale(self, data, scaling):
-        """
-        Scale the data perturbations by the data error standard deviation.
-
-        Args:
-            data (np.ndarray): data perturbations
-            scaling (np.ndarray): data error standard deviation
-
-        Returns:
-            np.ndarray: scaled data perturbations
-        """
-
-        if len(scaling.shape) == 1:
-            return (scaling ** (-1))[:, None] * data
-        else:
-            return solve(scaling, data)
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
diff --git a/src/pipt/update_schemes/update_methods_ns/subspace2_update.py b/src/pipt/update_schemes/update_methods_ns/subspace2_update.py
deleted file mode 100644
index 52d54f34..00000000
--- a/src/pipt/update_schemes/update_methods_ns/subspace2_update.py
+++ /dev/null
@@ -1,56 +0,0 @@
-"""Stochastic iterative ensemble smoother (IES, i.e. EnRML) with *subspace* implementation."""
-
-import numpy as np
-from scipy.linalg import solve, lu_solve, lu_factor
-import pipt.misc_tools.analysis_tools as at
-
-
-
-
-
-class subspace2_update():
-    """
-    Ensemble subspace update, as described in  Raanes, P. N., Stordal, A. S., &
-    Evensen, G. (2019). Revising the stochastic iterative ensemble smoother.
-    Nonlinear Processes in Geophysics, 26(3), 325–338. https://doi.org/10.5194/npg-26-325-2019
-
-    """
-
-    def update(self, enX, enY, enE, **kwargs):
-
-        if self.iteration == 1:  # method requires some initiallization
-            self.current_W = np.eye(self.ne)
-            self.D = self.scale(enE, self.scale_data)
-        # Scale everything so that data uncertainty is I
-        sY = self.scale(enY, self.scale_data)
-        Y = np.linalg.solve(self.current_W.T,sY.T).T #Raanes
-        Y = np.dot(Y, self.proj) * np.sqrt(self.ne - 1) #Raanes
-
-
-        #Gradients
-
-        deltaD = Y.T @ (self.D - sY)
-        deltaM = (self.ne-1)*(np.eye(self.ne)-self.current_W)
-
-        #Hessian
-        S = Y.T @ Y + np.eye(self.ne)*(self.ne-1)
-
-        self.W_step =   np.linalg.solve(S , (deltaM + deltaD))/(1 + self.lam)
-
-
-    def scale(self, data, scaling):
-        """
-        Scale the data perturbations by the data error standard deviation.
-
-        Args:
-            data (np.ndarray): data perturbations
-            scaling (np.ndarray): data error standard deviation
-
-        Returns:
-            np.ndarray: scaled data perturbations
-        """
-
-        if len(scaling.shape) == 1:
-            return (scaling ** (-1))[:, None] * data
-        else:
-            return solve(scaling, data)
\ No newline at end of file
diff --git a/src/pipt/update_schemes/update_methods_ns/subspace_update.py b/src/pipt/update_schemes/update_methods_ns/subspace_update.py
deleted file mode 100644
index 987505a7..00000000
--- a/src/pipt/update_schemes/update_methods_ns/subspace_update.py
+++ /dev/null
@@ -1,71 +0,0 @@
-"""Stochastic iterative ensemble smoother (IES, i.e. EnRML) with *subspace* implementation."""
-
-import numpy as np
-from scipy.linalg import solve, lu_solve, lu_factor
-import pipt.misc_tools.analysis_tools as at
-#from sklearn.linear_model import Lasso
-
-class subspace_update():
-    """
-
-    More information about the method is found in Evensen, G., Raanes, P. N., Stordal, A. S., & Hove, J. (2019).
-    Efficient Implementation of an Iterative Ensemble Smoother for Data Assimilation and Reservoir History Matching.
-    Frontiers in Applied Mathematics and Statistics, 5(October), 114. https://doi.org/10.3389/fams.2019.00047
-    """
-
-    def update(self, enX, enY, enE, **kwargs):
-
-        if self.iteration == 1:  # method requires some initiallization
-            self.current_W = np.zeros((self.ne, self.ne))
-            self.E = np.dot(enE, self.proj) #original
-        
-        # Center ensemble matrices
-
-        Y = np.dot(enY, self.proj)
-
-
-        omega = np.eye(self.ne) + np.dot(self.current_W, self.proj) #original
-        S = lu_solve(lu_factor(omega.T), Y.T).T #original
-
-        # Compute scaled misfit (residual between predicted and observed data)
-        enRes = self.scale(enY - enE, self.scale_data) #orginal
-       # enRes = self.scale(S @ self.current_W + enE - enY, self.scale_data)
-        #enRes = self.scale(np.dot(S,self.current_W)+enE-enY,self.scale_data)
-        # Truncate SVD of S
-        #Us, Ss, VsT = at.truncSVD(S, energy=self.trunc_energy)
-        Us, Ss, VsT = np.linalg.svd(S, full_matrices = False)
-        eps = 1e-8 * Ss[0]  # e.g., 1e-8 * largest
-        s_inv = 1.0 / np.maximum(Ss, eps)
-        Sinv = np.diag(s_inv)
-
-        #Sinv = np.diag(1/Ss)
-
-        # Compute update step
-        X = Sinv @ Us.T @ self.scale(self.E, self.scale_data)
-        #X = Sinv @ Us.T @ enRes
-        eigval, eigvec = np.linalg.eig(X @ X.T)
-        X2 = Us @ Sinv.T @ eigvec
-        X3 = S.T @ X2
-
-        lam_term = np.eye(len(eigval)) + (1+self.lam) * np.diag(eigval)
-        deltaM = X3 @ solve(lam_term, X3.T @ self.current_W)
-        deltaD = X3 @ solve(lam_term, X2.T @ enRes)
-        self.w_step = -self.current_W/(1 + self.lam) - (deltaD - deltaM)/(1 + self.lam)
-        
-
-    def scale(self, data, scaling):
-        """
-        Scale the data perturbations by the data error standard deviation.
-
-        Args:
-            data (np.ndarray): data perturbations
-            scaling (np.ndarray): data error standard deviation
-
-        Returns:
-            np.ndarray: scaled data perturbations
-        """
-
-        if len(scaling.shape) == 1:
-            return (scaling ** (-1))[:, None] * data
-        else:
-            return solve(scaling, data)
diff --git a/src/popt/README.md b/src/popt/README.md
index 0c22dae1..20d694d0 100644
--- a/src/popt/README.md
+++ b/src/popt/README.md
@@ -6,7 +6,8 @@ Currently, the following methods are implemented:
 - EnOpt: The standard ensemble optimization method
 - GenOpt: Generalized ensemble optimization (using non-Gaussian distributions)
 - SmcOpt: Gradient-free optimization based on sequential Monte Carlo
-- LineSearch: Gradient based method satisfying the strong Wolfie conditions
+- LineSearch: Gradient based method satisfying the strong Wolfe conditions
+- TrustRegion: Trust-region method with an ensemble-built model
 
 The gradient and Hessian methods are compatible with SciPy, and can be used as input to scipy.optimize.minimize. 
-A POPT tutorial is found [here](https://python-ensemble-toolbox.github.io/PET/tutorials/popt/tutorial_popt).
+A POPT tutorial is found [here](https://python-ensemble-toolbox.github.io/PET/tutorials/popt/5Spot/tutorial_popt).
diff --git a/src/popt/__init__.py b/src/popt/__init__.py
index e6817f34..9497e320 100644
--- a/src/popt/__init__.py
+++ b/src/popt/__init__.py
@@ -2,3 +2,25 @@
 
 --8<-- "popt/README.md"
 """
+from popt.optimization_methods.optimizer_base import OptimizerBase, StepReport
+from popt.optimization_methods.enopt import EnOpt
+from popt.optimization_methods.genopt import GenOpt
+from popt.optimization_methods.linesearch import LineSearch
+from popt.optimization_methods.trust_region import TrustRegion
+from popt.optimization_methods.smcopt import SmcOpt
+from popt.ensembles.ensemble_gaussian import GaussianEnsemble
+from popt.ensembles.ensemble_generalized import GeneralizedEnsemble
+from popt.optimization_methods.subroutines.cma import CMA
+
+__all__ = [
+    "OptimizerBase",
+    "StepReport",
+    "EnOpt",
+    "GenOpt",
+    "LineSearch",
+    "TrustRegion",
+    "SmcOpt",
+    "GaussianEnsemble",
+    "GeneralizedEnsemble",
+    "CMA",
+]
diff --git a/src/popt/cost_functions/__init__.py b/src/popt/cost_functions/__init__.py
index e69de29b..8b137891 100644
--- a/src/popt/cost_functions/__init__.py
+++ b/src/popt/cost_functions/__init__.py
@@ -0,0 +1 @@
+
diff --git a/src/popt/cost_functions/epf.py b/src/popt/cost_functions/epf.py
index 380e1c03..6768578b 100644
--- a/src/popt/cost_functions/epf.py
+++ b/src/popt/cost_functions/epf.py
@@ -1,3 +1,4 @@
+"""External penalty function for constrained optimisation."""
 import numpy as np
 
 def epf(r, c_eq=0, c_iq=0):
@@ -8,5 +9,5 @@ def epf(r, c_eq=0, c_iq=0):
 
     We assume that the ensemble members are stacked as columns.
     """
-    
+
     return r*0.5*( np.sum(c_eq**2, axis=0) + np.sum(np.maximum(-c_iq,0)**2, axis=0) )
diff --git a/src/popt/cost_functions/quadratic.py b/src/popt/cost_functions/quadratic.py
index ee2f0a6c..a2b7ec4d 100644
--- a/src/popt/cost_functions/quadratic.py
+++ b/src/popt/cost_functions/quadratic.py
@@ -5,35 +5,34 @@
 
 
 def quadratic(x, *args, **kwargs):
-	r"""Quadratic objective function
+    r"""Quadratic objective function
 
-	$$ f(x) = ||x - b||^2_A $$
-	"""
+    $$ f(x) = ||x - b||^2_A $$
+    """
 
-	r = kwargs.get('r', -1)
+    r = kwargs.get('r', -1)
+    dim, ne = x.shape
+    A = 0.5*np.diag(np.ones(dim))
+    b = 1.0*np.ones(dim)
+    f = np.zeros(ne)
+    for i in range(ne):
+        u = x[:, i] - b
+        f[i] = u.T@A@u
 
-	x = x[0]['vector']
-	dim, ne = x.shape
-	A = 0.5*np.diag(np.ones(dim))
-	b = 1.0*np.ones(dim)
-	f = np.zeros(ne)
-	for i in range(ne):
-		u = x[:, i] - b
-		f[i] = u.T@A@u
+        # check for contraints
+        if r >= 0:
+            c_eq = g(x[:, i])
+            c_iq = h(x[:, i])
+            f[i] += epf(r, c_eq=c_eq, c_iq=c_iq)
 
-		# check for contraints
-		if r >= 0:
-			c_eq = g(x[:, i])
-			c_iq = h(x[:, i])
-			f[i] += epf(r, c_eq=c_eq, c_iq=c_iq) 
-
-	return f
+    return f
 
 # Equality constraint saying that sum of x should be equal to dimention + 1
 def g(x):
-	return sum(x) - (x.size + 1)
+    """Equality constraint ``sum(x) - (n + 1) = 0``."""
+    return sum(x) - (x.size + 1)
 
 # Inequality constrint saying that x_1 should be equal or less than 0
 def h(x):
-	return -x[0]
-
+    """Inequality constraint ``-x[0] <= 0``."""
+    return -x[0]
diff --git a/src/popt/cost_functions/rosenbrock.py b/src/popt/cost_functions/rosenbrock.py
index fef3e244..9096282a 100644
--- a/src/popt/cost_functions/rosenbrock.py
+++ b/src/popt/cost_functions/rosenbrock.py
@@ -1,7 +1,7 @@
 """Rosenbrock objective function."""
+from scipy.optimize import rosen
 
-
-def rosenbrock(state, *args, **kwargs):
+def _rosenbrock(state, *args, **kwargs):
     """
     Rosenbrock: http://en.wikipedia.org/wiki/Rosenbrock_function
     """
@@ -10,3 +10,7 @@ def rosenbrock(state, *args, **kwargs):
     x1 = x[1:]
     f = sum((1 - x0) ** 2) + 100 * sum((x1 - x0 ** 2) ** 2)
     return f
+
+def rosenbrock(x, *args, **kwargs):
+    """SciPy's Rosenbrock function of ``x``; extra arguments are ignored."""
+    return rosen(x)
diff --git a/src/popt/ensembles/__init__.py b/src/popt/ensembles/__init__.py
new file mode 100644
index 00000000..6a1d20a4
--- /dev/null
+++ b/src/popt/ensembles/__init__.py
@@ -0,0 +1,3 @@
+"""Ensembles that estimate objective gradients and Hessians for popt's optimizers."""
+from .ensemble_gaussian import *
+from .ensemble_generalized import *
diff --git a/src/popt/ensembles/ensemble_base.py b/src/popt/ensembles/ensemble_base.py
new file mode 100644
index 00000000..6ef3b935
--- /dev/null
+++ b/src/popt/ensembles/ensemble_base.py
@@ -0,0 +1,226 @@
+"""Base ensemble for optimisation: the control vector as state, objective evaluation over the members, and multilevel bookkeeping."""
+# External imports
+import numpy as np
+import pandas as pd
+
+
+# Internal imports
+from popt.misc_tools import optim_tools as ot
+from ensemble import BaseEnsemble
+from simulator.simple_models import noSimulation
+from pipt.misc_tools.ensemble_tools import matrix_to_dict
+
+__all__ = ['EnsembleOptimizationBase']
+
+class EnsembleOptimizationBase(BaseEnsemble):
+    '''
+    Base class for the popt ensemble
+    '''
+    def __init__(self, options, simulator, objective):
+        '''
+        Parameters
+        ----------
+        options : dict
+            Options for the ensemble class
+
+        simulator : callable
+            The forward simulator (e.g. flow). If None, no simulation is performed.
+
+        objective : callable
+            The objective function (e.g. npv)
+        '''
+        if simulator is None:
+            sim = noSimulation({})
+        else:
+            sim = simulator
+
+        # Initialize the PET Ensemble
+        super().__init__(options, sim)
+
+        # Unpack some options
+        self.save_prediction = options.get('save_prediction', None)
+        self.num_models      = options.get('num_models', 1) # Number of realizations for robust optimization
+        self.num_samples     = self.ne # Number of perturbations for the ensemble
+
+        # Set objective function (callable)
+        if callable(objective):
+            self.obj_func = objective
+        else:
+            raise ValueError("Objective function must be callable.")
+
+        # Initialize state-related attributes
+        self.stateX = np.array([]) # Current state vector, (nx,)
+        self.stateF = None         # Function value(s) of current state
+        self.bounds = []           # Bounds (untransformed) for each variable in stateX
+        self.varX   = np.array([]) # Variance for state vector, (nx,)
+        self.covX   = None         # Covariance matrix for state vector, (nx, nx)
+        self.enX    = None         # Ensemble of state vectors ,(nx, ne)
+        self.enF    = None         # Ensemble of function values, (ne,)
+        self.lb     = np.array([]) # Lower bounds (transformed) for state vector, (nx,)
+        self.ub     = np.array([]) # Upper bounds (transformed) for state vector, (nx,)
+
+        # Process state information
+        for name, info in self.prior_info.items():
+            mean = np.asarray(info['mean'])
+            var  = info['variance'] * np.ones(mean.size)
+            lb, ub = info.get('limits', (-np.inf, np.inf))
+
+            # Append to state vector and bounds
+            self.stateX = np.append(self.stateX, mean)
+            self.varX = np.append(self.varX, var)
+            self.lb = np.append(self.lb, lb * np.ones(mean.size))
+            self.ub = np.append(self.ub, ub * np.ones(mean.size))
+            self.bounds += mean.size * [(lb, ub)]
+            self.idX[name] = (self.stateX.size - mean.size, self.stateX.size)
+
+        self.covX = np.diag(self.varX)  # Covariance matrix, (nx, nx)
+        self.dimX = self.stateX.size    # Dimension of state vector
+
+    def function(self, x, *args, **kwargs):
+        """
+        Evaluate objective values for a single state vector or an ensemble.
+
+        Parameters
+        ----------
+        x : ndarray
+            Control vector with shape ``(n_controls,)`` or ensemble matrix with
+            shape ``(n_controls, n_perturbations)``.
+
+        Returns
+        -------
+        numpy.ndarray
+            Objective function values, or ``inf`` when the simulation crashed, so the
+            optimizer rejects the point instead of the run ending. A crashed
+            single-point evaluation leaves ``stateF`` at its last good value.
+
+        Raises
+        ------
+        ValueError
+            If ``x`` is not one- or two-dimensional.
+        """
+        self._aux_input()
+        x = np.asarray(x)
+
+        # Check for ensemble input (nx, ne) vs. single state vector (nx,)
+        ensemble_input = (x.ndim != 1)
+        if ensemble_input:
+            self.ne = x.shape[1]
+        else:
+            x = x[:, np.newaxis]
+            self.ne = self.num_models # In case of robust optimization
+
+        if isinstance(self.sim, noSimulation):
+            func_values = self.obj_func(x, **kwargs)
+        else:
+            x = self._reorganize_multilevel_ensemble(x)
+            sim_success = self.calc_prediction(x, save_prediction=self.save_prediction)
+            x = self._reorganize_multilevel_ensemble(x)
+
+            if sim_success:
+                func_values = self.obj_func(
+                    self.sim_data,
+                    input_dict=self.sim.input_dict,
+                    true_order=self.sim.true_order,
+                    state=matrix_to_dict(x, self.idX),
+                    **kwargs
+                )
+            else:
+                # A crashed evaluation costs the point, not the run: the optimizer
+                # sees an objective it can never improve on, so backtracking rejects
+                # the trial point and carries on from the last good one. Raising here
+                # ended the whole optimization because one trial control vector
+                # happened to be one the simulator could not run.
+                self.logger.error(
+                    "Simulation failed while evaluating the objective; the point is "
+                    "reported as inf so the optimizer can reject it."
+                )
+                func_values = np.full(self.ne, np.inf)
+
+        if ensemble_input:
+            self.enF = func_values
+        elif np.all(np.isfinite(func_values)):
+            self.stateF = func_values
+        # A crashed single-point evaluation leaves `stateF` alone. The gradient is
+        # `enF - repeat(stateF, nr)`, so writing inf here would poison every later
+        # gradient with inf/NaN rather than just rejecting this one point.
+
+        return func_values
+
+
+    def get_state(self):
+        """
+        Returns
+        -------
+        x : numpy.ndarray
+            Control vector as ndarray, shape (number of controls, number of perturbations)
+        """
+        return self.stateX
+
+    def get_cov(self):
+        """
+        Returns
+        -------
+        cov : numpy.ndarray
+            Covariance matrix, shape (number of controls, number of controls)
+        """
+        return self.covX
+
+    def get_bounds(self):
+        """
+        Returns
+        -------
+        bounds : list
+            (min, max) pairs for each element in x. None is used to specify no bound.
+        """
+        return self.bounds
+
+    def save_stateX(self, state=None, path='./', filetype='npz'):
+        '''
+        Save the state vector.
+
+        Parameters
+        ----------
+        path : str
+            Path to save the state vector. Default is current directory.
+
+        filetype : str
+            File type to save the state vector. Options are 'csv', 'npz' or 'npy'. Default is 'npz'.
+        '''
+        if state is None:
+            stateX = self.stateX
+        else:
+            stateX = state
+
+        if filetype == 'csv':
+            state_dict = matrix_to_dict(stateX, self.idX)
+            state_df = pd.DataFrame(data=state_dict)
+            state_df.to_csv(path + 'stateX.csv', index=False)
+        elif filetype == 'npz':
+            state_dict = matrix_to_dict(stateX, self.idX)
+            np.savez_compressed(path + 'stateX.npz', **state_dict)
+        elif filetype == 'npy':
+            np.save(path + 'stateX.npy', stateX)
+
+    def _reorganize_multilevel_ensemble(self, x):
+        # Only toggle multilevel state when x is truly an ensemble (2D with >1 columns).
+        # Treat shape (nx, 1) the same as a 1D vector.
+        if 'multilevel' in self.keys_en:
+            if isinstance(x,list) or ( x.ndim > 1 and (x.shape[1] > 1) ):
+                ml_ne = self.multilevel['ml_ne']
+                x = ot.toggle_ml_state(x, ml_ne)
+        return x
+
+    def _aux_input(self):
+        """
+        Set the auxiliary input used for multiple geological realizations
+        """
+
+        nr = 1  # nr is the ratio of samples over models
+        if self.num_models > 1:
+            if np.remainder(self.num_samples, self.num_models) == 0:
+                nr = int(self.num_samples / self.num_models)
+                self.aux_input = list(np.repeat(np.arange(self.num_models), nr))
+            else:
+                raise ValueError('num_samples must be a multiple of num_models')
+        return nr
+
diff --git a/src/popt/loop/ensemble_gaussian.py b/src/popt/ensembles/ensemble_gaussian.py
similarity index 50%
rename from src/popt/loop/ensemble_gaussian.py
rename to src/popt/ensembles/ensemble_gaussian.py
index 0a7e68ed..acf5404b 100644
--- a/src/popt/loop/ensemble_gaussian.py
+++ b/src/popt/ensembles/ensemble_gaussian.py
@@ -1,3 +1,4 @@
+"""Gaussian control perturbations: ensemble estimates of the gradient, the Hessian and the sensitivity used by SmcOpt."""
 # External imports
 import numpy as np
 import warnings
@@ -6,11 +7,11 @@
 
 # Internal imports
 from popt.misc_tools import optim_tools as ot
-from popt.loop.ensemble_base import EnsembleOptimizationBaseClass
+from popt.ensembles.ensemble_base import EnsembleOptimizationBase
 
 __all__ = ['GaussianEnsemble']
 
-class GaussianEnsemble(EnsembleOptimizationBaseClass):
+class GaussianEnsemble(EnsembleOptimizationBase):
     """
     Gaussian Ensemble class for ensemble-based optimization.
 
@@ -18,7 +19,7 @@ class GaussianEnsemble(EnsembleOptimizationBaseClass):
     -------
     gradient(x, *args, **kwargs)
         Ensemble gradient
- 
+
     hessian(x, *args, **kwargs)
         Ensemble hessian
 
@@ -57,89 +58,86 @@ def __init__(self, options, simulator, objective):
         self.particles = []  # list in case of multilevel
         self.particle_values = []  # list in case of multilevel
         self.resample_index = None
-    
+
     def gradient(self, x, *args, **kwargs):
-        '''
-        Ensemble-based Gradient (EnOpt).
+        """
+        Estimate the ensemble gradient (EnOpt) at a given state.
 
         Parameters
         ----------
         x : ndarray
-            Control vector, shape (number of controls, )
-        
+            Control vector, shape (number of controls, ).
         args : tuple
-            Covarice matrix, shape (number of controls, number of controls)
-        
+            First positional argument must be the covariance matrix with shape
+            (number of controls, number of controls).
+
         Returns
         -------
-        gradient : ndarray
-            Ensemble gradient, shape (number of controls, )
-        '''
-        # Update state vector
-        self.stateX = x
+        ndarray
+            Ensemble gradient, shape (number of controls, ).
 
-        # Set covariance equal to the input
-        self.covX = args[0]
+        Raises
+        ------
+        ValueError
+            If required inputs are missing or have invalid shapes.
+        """
+        if len(args) < 1:
+            raise ValueError("gradient requires covariance matrix as first positional argument.")
 
-        # Generate state ensemble
-        self.ne = self.num_samples
-        nr = self._aux_input()   
-        enX = np.random.multivariate_normal(self.stateX, self.covX, self.ne).T
+        x = np.asarray(x)
+        if x.ndim != 1:
+            raise ValueError(f"Expected x to be a 1D vector, got shape {x.shape}.")
 
-        # Shift ensemble to have correct mean
-        enX = enX - enX.mean(axis=1, keepdims=True) + self.stateX[:,None]
+        cov = np.asarray(args[0])
+        if cov.shape != (self.dimX, self.dimX):
+            raise ValueError(
+                f"Covariance shape mismatch: expected {(self.dimX, self.dimX)}, got {cov.shape}."
+            )
 
-        # Truncate to bounds
-        if (self.lb is not None) and (self.ub is not None):
-            if self.transform:
-                enX = np.clip(enX, 0.0, 1.0)
-            else:
-                enX = np.clip(enX, self.lb[:, None], self.ub[:, None])
+        nr = self._aux_input()
 
-        # Evaluate objective function for ensemble
-        enF = self.function(enX, *args, **kwargs)
+        # Update internal state and covariance used by downstream methods.
+        self.stateX = x
+        self.covX = cov
+        self.ne = self.num_samples
+
+        # Draw perturbations and recenter ensemble around current state.
+        enX = self.rng.multivariate_normal(self.stateX, self.covX, self.ne).T
+        enX = enX - enX.mean(axis=1, keepdims=True) + self.stateX[:, None]
+        enX = np.clip(enX, self.lb[:, None], self.ub[:, None])
 
-        # Store ensembles
+        enF = self.function(enX, **kwargs)
         self.enX = enX
-        self.enF = enF
-    
-        # Make function ensemble to a list (for Multilevel) 
-        if not isinstance(self.enF, list):
-            self.enF = [self.enF]
+        self.enF = enF if isinstance(enF, list) else [enF]
 
-        # Define some variables for gradient calculation
-        index = 0       
+        start_idx = 0
         nlevels = len(self.enF)
         grad_ml = np.zeros((nlevels, self.dimX))
 
-        # Loop over levels (only one level if not multilevel)
-        for id_level in range(nlevels):
-            dF = self.enF[id_level] - np.repeat(self.stateF, nr)
-            ne = self.enF[id_level].shape[0] 
+        # Loop over levels (single level when not multilevel).
+        for levelID in range(nlevels):
+            dF = self.enF[levelID] - np.repeat(self.stateF, nr)
+            ne = dF.shape[0]
 
-            # Calculate ensemble gradient for level
-            g = np.zeros(self.dimX)
-            for n in range(ne):
-                g = g + dF[n] * (self.enX[:, index+n] - self.stateX)
-
-            grad_ml[id_level] = g/ne
-            index += ne
+            dx = self.enX[:, start_idx:start_idx + ne] - self.stateX[:, None]
+            grad_ml[levelID] = np.squeeze(dx @ dF) / ne
+            start_idx += ne
 
         if 'multilevel' in self.keys_en:
-            weight = np.array(self.multilevel['ml_weights'])
-            if len(weight) > 1:
-                if not np.sum(weight) == 1.0:
-                    weight = weight / np.sum(weight)
-                grad = np.dot(grad_ml, weight)
+            weight = np.asarray(self.multilevel['ml_weights'], dtype=float)
+            if weight.size > 1:
+                weight_sum = np.sum(weight)
+                if weight_sum != 1.0:
+                    weight = weight / weight_sum
+                grad = np.dot(weight, grad_ml)
             else:
                 grad = grad_ml[0]
         else:
             grad = grad_ml[0]
 
-        # Check if natural or averaged gradient (default is natural)
+        # Check if natural or averaged gradient (default is natural).
         if not self.keys_en.get('natural_gradient', True):
-            cov_inv = np.linalg.inv(self.covX)
-            grad = np.matmul(cov_inv, grad)
+            grad = np.linalg.solve(self.covX, grad)
 
         return grad
 
@@ -155,12 +153,12 @@ def hessian(self, x=None, *args, **kwargs):
 
         args : tuple
             Additional arguments passed to function
-        
+
         Returns
         -------
         hessian : ndarray
             Ensemble hessian, shape (number of controls, number of controls)
-        
+
         References
         ----------
         Zhang, Y., Stordal, A.S. & Lorentzen, R.J. A natural Hessian approximation for ensemble based optimization.
@@ -172,43 +170,41 @@ def hessian(self, x=None, *args, **kwargs):
 
         nr = self._aux_input()
 
-        # Make function ensemble to a list (for Multilevel) 
+        # Make function ensemble to a list (for Multilevel)
         if not isinstance(self.enF, list):
             self.enF = [self.enF]
 
-        # Define some variables for gradient calculation
-        index = 0       
+        # Define some variables for Hessian calculation
+        index = 0
         nlevels = len(self.enF)
         hess_ml = np.zeros((nlevels, self.dimX, self.dimX))
 
         # Loop over levels (only one level if not multilevel)
-        for id_level in range(nlevels):
-            dF = self.enF[id_level] - np.repeat(self.stateF, nr)
-            ne = self.enF[id_level].shape[0] 
-
-            # Calculate ensemble Hessian for level
-            h = np.zeros((self.dimX, self.dimX))
-            for n in range(ne):
-                dx = (self.enX[:, index+n] - self.stateX)
-                h = h + dF[n] * (np.outer(dx, dx) - self.covX)
+        for levelID in range(nlevels):
+            dF = self.enF[levelID] - np.repeat(self.stateF, nr)
+            ne = self.enF[levelID].shape[0]
 
-            hess_ml[id_level] = h/ne
+            # Vectorized Hessian estimate for this level.
+            dx = self.enX[:, index:index + ne] - self.stateX[:, None]
+            hess_ml[levelID] = (dx * dF) @ dx.T / ne - self.covX * np.mean(dF)
             index += ne
 
         if 'multilevel' in self.keys_en:
             weight = ot.get_list_element(self.keys_en['multilevel'], 'cov_wgt')
             weight = np.array(weight)
             if not np.sum(weight) == 1.0:
-                weight = weight / np.sum(weight)  
+                weight = weight / np.sum(weight)
             hessian = np.sum([h*w for h, w in zip(hess_ml, weight)], axis=0)
         else:
             hessian = hess_ml[0]
-        
+
         # Check if natural or averaged Hessian (default is natural)
         if not self.keys_en.get('natural_gradient', True):
-            cov_inv = np.linalg.inv(self.covX)
-            hessian = cov_inv @ hessian @ cov_inv
-        
+            hessian = np.linalg.solve(
+                self.covX,
+                np.linalg.solve(self.covX, hessian).T
+            ).T
+
         return hessian
 
     def calc_ensemble_weights(self, x, *args, **kwargs):
@@ -242,12 +238,12 @@ def calc_ensemble_weights(self, x, *args, **kwargs):
             self.ne = self.num_samples
         else:
             self.ne = int(np.round(self.num_samples*self.survival_factor))
-        
-        nr = self._aux_input()
-        
+
+        self._aux_input()
+
         # Generate state ensemble
-        self.enX = np.random.multivariate_normal(self.stateX, self.covX, self.ne).T
-        
+        self.enX = self.rng.multivariate_normal(self.stateX, self.covX, self.ne).T
+
         # Truncate to bounds
         if (self.lb is not None) and (self.ub is not None):
             self.enX = np.clip(self.enX, self.lb[:, None], self.ub[:, None])
@@ -262,66 +258,67 @@ def calc_ensemble_weights(self, x, *args, **kwargs):
         if self.resample_index is None:
             self.resample_index = [None]*L
 
-        warnings.filterwarnings('ignore')  # suppress warnings
-        start_index = 0
-        level_sens = []
-        sens_matrix = np.zeros(self.enX.shape[0])
-        best_ens = 0
-        best_func = 0
-        ml_ne_new_total = 0
-        
-        if 'multilevel' in self.keys_en.keys():
-            en_size = ot.get_list_element(self.keys_en['multilevel'], 'en_size')
-        else:
-            en_size = [self.num_samples]
-            
-        for l in range(L):
-            ml_ne = en_size[l] 
-            if L > 1 and l == L-1:
-                ml_ne_new = int(np.round(self.num_samples*self.survival_factor)) - ml_ne_new_total
+        with warnings.catch_warnings():
+            warnings.simplefilter('ignore')  # suppress warnings from the weights' exponentials
+            start_index = 0
+            level_sens = []
+            sens_matrix = np.zeros(self.enX.shape[0])
+            best_ens = 0
+            best_func = 0
+            ml_ne_new_total = 0
+
+            if 'multilevel' in self.keys_en.keys():
+                en_size = ot.get_list_element(self.keys_en['multilevel'], 'en_size')
             else:
-                ml_ne_new = int(np.round(ml_ne*self.survival_factor))  # new samples
-                ml_ne_new_total += ml_ne_new
-            ml_ne_surv = ml_ne - ml_ne_new  # surviving samples
+                en_size = [self.num_samples]
 
-            if self.resample_index[l] is None:
-                self.particles.append(deepcopy(self.enX[:, start_index:start_index + ml_ne]))
-                self.particle_values.append(deepcopy(self.enF[l]))
-            else:
-                self.particles[l][:, :ml_ne_surv] = self.particles[l][:, self.resample_index[l]]
-                self.particles[l][:, ml_ne_surv:] = deepcopy(self.enX[:, start_index:start_index + ml_ne_new])
-                self.particle_values[l][:ml_ne_surv] = self.particle_values[l][self.resample_index[l]]
-                self.particle_values[l][ml_ne_surv:] = deepcopy(self.enF[l])
-
-            # Calculate the weights and ensemble sensitivity matrix
-            weights = np.zeros(ml_ne)
-            for i in range(ml_ne):
-                weights[i] = np.exp(np.clip(-(self.particle_values[l][i] - np.min(
-                    self.particle_values[l])) * self.inflation_factor, None, 10))
-
-            weights = weights + 1e-6  # Add small regularization
-            weights = weights/np.sum(weights)
-
-            level_sens.append(self.particles[l] @ weights)
-            if l == L-1:  # keep the best from the finest level
-                index = np.argmin(self.particle_values[l])
-                best_ens = self.particles[l][:, index]
-                best_func = self.particle_values[l][index]
-            self.resample_index[l] = np.random.choice(ml_ne, ml_ne_surv, replace=True, p=weights)
-
-            start_index += ml_ne_new
-
-        if 'multilevel' in self.keys_en.keys():
-            cov_wgt = ot.get_list_element(self.keys_en['multilevel'], 'cov_wgt')
             for l in range(L):
-                sens_matrix += level_sens[l]*cov_wgt[l]
-            sens_matrix /= self.num_samples
-        else:
-            sens_matrix = level_sens[0]
+                ml_ne = en_size[l]
+                if L > 1 and l == L-1:
+                    ml_ne_new = int(np.round(self.num_samples*self.survival_factor)) - ml_ne_new_total
+                else:
+                    ml_ne_new = int(np.round(ml_ne*self.survival_factor))  # new samples
+                    ml_ne_new_total += ml_ne_new
+                ml_ne_surv = ml_ne - ml_ne_new  # surviving samples
+
+                if self.resample_index[l] is None:
+                    self.particles.append(deepcopy(self.enX[:, start_index:start_index + ml_ne]))
+                    self.particle_values.append(deepcopy(self.enF[l]))
+                else:
+                    self.particles[l][:, :ml_ne_surv] = self.particles[l][:, self.resample_index[l]]
+                    self.particles[l][:, ml_ne_surv:] = deepcopy(self.enX[:, start_index:start_index + ml_ne_new])
+                    self.particle_values[l][:ml_ne_surv] = self.particle_values[l][self.resample_index[l]]
+                    self.particle_values[l][ml_ne_surv:] = deepcopy(self.enF[l])
+
+                # Calculate the weights and ensemble sensitivity matrix
+                weights = np.zeros(ml_ne)
+                for i in range(ml_ne):
+                    weights[i] = np.exp(np.clip(-(self.particle_values[l][i] - np.min(
+                        self.particle_values[l])) * self.inflation_factor, None, 10))
+
+                weights = weights + 1e-6  # Add small regularization
+                weights = weights/np.sum(weights)
+
+                level_sens.append(self.particles[l] @ weights)
+                if l == L-1:  # keep the best from the finest level
+                    index = np.argmin(self.particle_values[l])
+                    best_ens = self.particles[l][:, index]
+                    best_func = self.particle_values[l][index]
+                self.resample_index[l] = self.rng.choice(ml_ne, ml_ne_surv, replace=True, p=weights)
+
+                start_index += ml_ne_new
+
+            if 'multilevel' in self.keys_en.keys():
+                cov_wgt = ot.get_list_element(self.keys_en['multilevel'], 'cov_wgt')
+                for l in range(L):
+                    sens_matrix += level_sens[l]*cov_wgt[l]
+                sens_matrix /= self.num_samples
+            else:
+                sens_matrix = level_sens[0]
+
+            return sens_matrix, best_ens, best_func
 
-        return sens_matrix, best_ens, best_func
 
 
 
 
-        
diff --git a/src/popt/loop/ensemble_generalized.py b/src/popt/ensembles/ensemble_generalized.py
similarity index 59%
rename from src/popt/loop/ensemble_generalized.py
rename to src/popt/ensembles/ensemble_generalized.py
index 431a8b28..d7d9c772 100644
--- a/src/popt/loop/ensemble_generalized.py
+++ b/src/popt/ensembles/ensemble_generalized.py
@@ -1,20 +1,27 @@
+"""Non-Gaussian control perturbations (beta, logistic, truncated-Gaussian marginals) with mutation-based gradient estimates."""
 # External imports
 import numpy as np
 import scipy.stats as stats
-import sys
 import warnings
 
-from copy import deepcopy
 from scipy.special import polygamma
+from sympy import symbols, solve, im, re
 
 # Internal imports
 from popt.misc_tools import optim_tools as ot
-from pipt.misc_tools import analysis_tools as at
-from popt.loop.ensemble_base import EnsembleOptimizationBaseClass
+from popt.ensembles.ensemble_base import EnsembleOptimizationBase
 
 __all__ = ['GeneralizedEnsemble']
 
-class GeneralizedEnsemble(EnsembleOptimizationBaseClass):
+class GeneralizedEnsemble(EnsembleOptimizationBase):
+    """Control perturbations with a non-Gaussian marginal (beta, logistic, truncated Gaussian, or Gaussian)
+    coupled by a Gaussian copula, and the mutation-based gradient and Hessian estimates that go with them.
+
+    Perturbations are drawn as correlated standard normals ``enZ`` mapped through the marginal's quantile
+    function; the gradient of the expected objective follows from the score of the sampling density
+    (``gradient``/``hessian``), and its derivative with respect to the marginal's own parameter ``theta``
+    (``mutation_gradient``/``mutation_hessian``) lets the distribution itself be adapted.
+    """
 
     def __init__(self, options, simulator, objective):
         '''
@@ -22,10 +29,10 @@ def __init__(self, options, simulator, objective):
         ----------
         options : dict
             Options for the ensemble class
-        
+
         simulator : callable
             The forward simulator (e.g. flow). If None, no simulation is performed.
-        
+
         objective : callable
             The objective function (e.g. npv)
         '''
@@ -54,11 +61,11 @@ def __init__(self, options, simulator, objective):
             elif marginal == 'BetaMC':
                 lb, ub = np.array(self.bounds).T
                 state = self.get_state()
-                var = np.diag(self.cov)
+                var = np.diag(self.covX)
                 self.margs = BetaMC(lb, ub, 0.1*np.sqrt(var[0]))
                 default_theta = np.array([var_to_concentration(state[i], var[i], lb[i], ub[i]) for i in range(self.dim)])
                 self.theta = options.get('theta', default_theta)
-                
+
             elif marginal == 'Logistic':
                 self.margs = Logistic()
                 self.theta = options.get('theta', self.margs.var_to_scale(np.diag(self.covX)))
@@ -71,24 +78,28 @@ def __init__(self, options, simulator, objective):
             elif marginal == 'Gaussian':
                 self.margs = Gaussian()
                 self.theta = options.get('theta', np.sqrt(np.diag(self.covX)))
-    
+
     def get_theta(self):
+        """The marginal's parameters, one row per control."""
         return self.theta
-    
+
     def get_corr(self):
+        """The correlation matrix of the Gaussian copula."""
         return self.corr
-    
+
     def sample(self, size=None):
+        """Draw ``size`` perturbed controls: correlated normals ``enZ`` through the marginal's quantile function, clipped to the bounds. Returns ``(enX, enZ)``."""
 
         if size is None:
             size = self.num_samples
         #enZ = stats.qmc.MultivariateNormalQMC(np.zeros(self.dim), self.corr).random(n=size)
-        enZ = np.random.multivariate_normal(np.zeros(self.dim), self.corr, size=size)
+        enZ = self.rng.multivariate_normal(np.zeros(self.dim), self.corr, size=size)
         enX = self.margs.ppf(stats.norm.cdf(enZ), self.theta, mean=self.get_state())
         enX = ot.clip_state(enX, self.bounds)
         return enX, enZ
-    
+
     def gradient(self, x, *args, **kwargs):
+        """Estimate the gradient of the expected objective at ``x`` from the sampled members (``enX``, ``enZ``, ``enF`` may be passed in; else sampled and evaluated). Also sets ``avg_hess``."""
 
         # Update state vector
         self.stateX = x
@@ -107,7 +118,7 @@ def gradient(self, x, *args, **kwargs):
         # Sample
         if (self.enX is None) or (self.enZ is None):
             self.enX, self.enZ = self.sample(size=ne)
-        
+
         # Evaluate
         if self.enF is None:
             self.enF = self.function(self._trafo_ensemble(x).T)
@@ -117,29 +128,33 @@ def gradient(self, x, *args, **kwargs):
 
         H = np.linalg.inv(self.corr)-np.eye(dim)
         O = np.ones((dim,dim))-np.eye(dim)
-        enF = self.enF - np.repeat(self.stateF, nr)
-
-        for n in range(self.ne):
-
-            X = self.enX[n]
-            Z = self.enZ[n]
-            
-            # Marginal terms
-            G = self.margs.grad_log_pdf(X, self.theta, mean=x)              # ∇log(p)
-            K = self.margs.hess_log_pdf(X, self.theta, mean=x)              # ∇²log(p)
-
-            # Copula terms
-            rho  = self.margs.pdf(X, self.theta, mean=x)/stats.norm.pdf(Z)   # p(X)/φ(Z) 
-            D    = - rho*np.matmul(H,Z)                                      # ∇log(c)
-            M_ii = (G+rho*Z)*D - np.diag(H)*rho**2
-            M_ij = - np.outer(rho,rho)*H
-            M    = np.diag(M_ii) + M_ij*O                                    # ∇²log(c) 
-            
-            # calc grad and hess
-            grad_log_p = G + D
-            hess_log_p = np.diag(K)+M
-            self.avg_grad += enF[n]*grad_log_p
-            self.avg_hess += enF[n]*(np.outer(grad_log_p, grad_log_p) + hess_log_p)
+        enF = np.asarray(self.enF) - np.repeat(self.stateF, nr)
+
+        G = self.margs.grad_log_pdf(self.enX, self.theta, mean=x)
+        K = np.asarray(self.margs.hess_log_pdf(self.enX, self.theta, mean=x))
+
+        rho = self.margs.pdf(self.enX, self.theta, mean=x) / stats.norm.pdf(self.enZ)
+        DZ = self.enZ @ H.T
+        D = -rho * DZ
+        M_ii = (G + rho * self.enZ) * D - np.diag(H) * rho**2
+        M_ij = -(rho[:, :, None] * rho[:, None, :]) * H
+        M = np.eye(dim)[None, :, :] * M_ii[:, :, None] + M_ij * O
+
+        grad_log_p = G + D
+        if K.ndim == 1:
+            K = np.broadcast_to(np.diag(K), (self.enX.shape[0], dim, dim))
+        else:
+            K = np.eye(dim)[None, :, :] * K[:, :, None]
+        hess_log_p = K + M
+
+        weights = enF[:, None]
+        self.avg_grad = np.sum(weights * grad_log_p, axis=0)
+        self.avg_hess = np.sum(
+            weights[:, :, None] * (
+                np.einsum('ni,nj->nij', grad_log_p, grad_log_p) + hess_log_p
+            ),
+            axis=0,
+        )
 
         self.avg_grad = -self.avg_grad*self.grad_scale/ne
         self.avg_hess = self.avg_hess*self.hess_scale/ne
@@ -147,18 +162,27 @@ def gradient(self, x, *args, **kwargs):
         return self.avg_grad
 
     def hessian(self, x, *args, **kwargs):
+        """The Hessian estimate from the last ``gradient`` call (recomputed when ``sample=True``)."""
 
         # Update state vector
         self.stateX = x
 
-        if kwargs.get('sample', False): 
+        if kwargs.get('sample', False):
             self.gradient(x, *args, **kwargs)
-        
+
         return self.avg_hess
-    
+
     def mutation_gradient(self, x, *args, **kwargs):
-        # Set the ensemble state equal to the input control vector x
-        self.state = ot.update_optim_state(x, self.state, list(self.state.keys()))
+        """Gradient of the expected objective with respect to the marginal's parameter ``theta``, for adapting the distribution. Also sets ``nat_hess``.
+
+        With ``return_ensembles=True`` it returns ``(nat_grad, {'gaussian': enZ,
+        'objective': enF})`` instead, so a caller adapting the correlation matrix --
+        :class:`~popt.optimization_methods.subroutines.cma.CMA` -- can reuse the
+        ensemble this gradient came from rather than drawing and simulating another.
+        """
+
+       # Update state vector
+        self.stateX = x
 
         if args:
             self.theta, self.corr = args
@@ -169,53 +193,56 @@ def mutation_gradient(self, x, *args, **kwargs):
 
         ne  = self.num_samples
         nr  = self._aux_input()
-        dim = self.dim
 
         # Sample
         if (self.enX is None) or (self.enZ is None):
             self.enX, self.enZ = self.sample(size=ne)
-        
+
         # Evaluate
         if self.enF is None:
             self.enF = self.function(self._trafo_ensemble(x).T)
 
-        enF = self.enF - np.repeat(self.stateF, nr)
+        enF = np.asarray(self.enF) - np.repeat(self.stateF, nr)
 
-        self.nat_grad = np.zeros(dim)
-        self.nat_hess = np.zeros(dim)
-        for n in range(ne):
+        dm_log_p = self.margs.grad_theta_log_pdf(self.enX, self.theta, mean=x)
+        hm_log_p = self.margs.hess_theta_log_pdf(self.enX, self.theta, mean=x)
 
-            X = self.enX[n]
-            dm_log_p = self.margs.grad_theta_log_pdf(X, self.theta, mean=x)
-            hm_log_p = self.margs.hess_theta_log_pdf(X, self.theta, mean=x)
+        weights = enF[:, None]
+        self.nat_grad = np.sum(weights * dm_log_p, axis=0)
+        self.nat_hess = np.sum(weights * (hm_log_p + dm_log_p**2), axis=0)
 
-            self.nat_grad += enF[n]*dm_log_p
-            self.nat_hess += enF[n]*(hm_log_p + dm_log_p**2)
-        
         # Fisher
         self.nat_grad = self.nat_grad/ne
         self.nat_hess = np.diag(self.nat_hess/ne)
+
+        if kwargs.get('return_ensembles', False):
+            # CMA adapts the correlation from the Gaussian samples and their
+            # objective values, so `GenOpt` asks for the ensemble this gradient
+            # was built from rather than drawing -- and simulating -- a second one.
+            return self.nat_grad, {'gaussian': self.enZ, 'objective': np.asarray(self.enF)}
         return self.nat_grad
 
     def mutation_hessian(self, x, *args, **kwargs):
+        """The ``theta`` Hessian estimate from the last ``mutation_gradient`` call (recomputed when ``sample=True``)."""
 
         # Update state vector
         self.stateX = x
 
-        if kwargs.get('sample', False): 
+        if kwargs.get('sample', False):
             self.gradient(x, *args, **kwargs)
-        
+
         return self.nat_hess
-        
+
     def var2eps(self):
-        var = np.diag(self.cov)
+        """Half-width of the beta perturbation interval that reproduces the control variance."""
+        var = np.diag(self.covX)
         a = self.theta[:,0]
         b = self.theta[:,1]
 
         frac    = a*b / ( (a+b)**2 * (a+b+1) )
         epsilon = np.sqrt(0.25*var/frac)
         return epsilon
-    
+
     def _trafo_ensemble(self, x):
 
         if self.margs.name == 'Beta':
@@ -226,6 +253,7 @@ def _trafo_ensemble(self, x):
 
 
 class BetaMC:
+    """Beta marginal parametrised by mode and concentration, on ``[lb, ub]``; the mode is the current control."""
 
     def __init__(self, lb=0, ub=1, eps=0.01):
         self.name = 'BetaMC'
@@ -237,7 +265,7 @@ def _mc_to_ab(self, m, c):
         a = 1 + c*m
         b = 1 + c*(1-m)
         return a, b
-    
+
     def _get_mode(self, **kwargs):
         mode = kwargs.get('mean')
         mode = (mode-self.lb)/(self.ub-self.lb)
@@ -245,87 +273,106 @@ def _get_mode(self, **kwargs):
         return mode
 
     def pdf(self, x, theta, **kwargs):
+        """Density of the marginal at ``x``."""
         mode = self._get_mode(**kwargs)
         a, b = self._mc_to_ab(mode, theta)
         return stats.beta(a,b, loc=self.lb, scale=self.ub-self.lb).pdf(x)
 
     def ppf(self, u, theta, **kwargs):
+        """Quantile function of the marginal at ``u``."""
         mode = self._get_mode(**kwargs)
         a, b = self._mc_to_ab(mode, theta)
         return stats.beta(a,b, loc=self.lb, scale=self.ub-self.lb).ppf(u)
-    
+
     def grad_log_pdf(self, x, theta, **kwargs):
+        """Derivative of the log density with respect to ``x``."""
+        scale = self.ub - self.lb
         u = (x-self.lb)/(self.ub-self.lb)
         m = self._get_mode(**kwargs)
         c = theta
-        return c*m/u - c*(1-m)/(1-u)
+        return (c*m)/(scale*u) - (c*(1-m))/(scale*(1-u))
 
     def hess_log_pdf(self, x, theta, **kwargs):
+        """Second derivative of the log density with respect to ``x``."""
+        scale = self.ub - self.lb
         u = (x-self.lb)/(self.ub-self.lb)
         m = self._get_mode(**kwargs)
         c = theta
-        return -c*m/u**2 - c*(1-m)/(1-u)**2
-    
+        return -c*m/(scale**2 * u**2) - c*(1-m)/(scale**2 * (1-u)**2)
+
     def grad_theta_log_pdf(self, x, theta, **kwargs):
+        """Derivative of the log density with respect to ``theta``."""
+        a, b = self._mc_to_ab(self._get_mode(**kwargs), theta)
         u = (x-self.lb)/(self.ub-self.lb)
         m = self._get_mode(**kwargs)
-        c = theta
-        return c*np.log(u/(1-u)) - c*kappa(m,c)
-    
+        return m*np.log(u) + (1-m)*np.log(1-u) + polygamma(0, theta + 2) - m*polygamma(0, a) - (1-m)*polygamma(0, b)
+
     def hess_theta_log_pdf(self, x, theta, **kwargs):
+        """Second derivative of the log density with respect to ``theta``."""
         m = self._get_mode(**kwargs)
         c = theta
-        p1 = polygamma(1, 1+c*m)
-        p2 = polygamma(1, 1+c*(1-m))
-        return -c**2*(p1+p2)
-    
+        a, b = self._mc_to_ab(m, c)
+        return polygamma(1, c + 2) - m**2 * polygamma(1, a) - (1-m)**2 * polygamma(1, b)
+
 class Beta:
+    """Beta marginal on ``[0, 1]`` with parameters ``(a, b)`` per control."""
 
     name = 'Beta'
 
     def pdf(self, x, theta, **kwargs):
+        """Density of the marginal at ``x``."""
         a, b = theta.T
         return stats.beta(a,b).pdf(x)
-    
+
     def ppf(self, u, theta, **kwargs):
+        """Quantile function of the marginal at ``u``."""
         a, b = theta.T
         return stats.beta(a,b).ppf(u)
-    
+
     def grad_log_pdf(self, x, theta, **kwargs):
+        """Derivative of the log density with respect to ``x``."""
         a, b = theta.T
         return (a-1)/x - (b-1)/(1-x)
 
     def hess_log_pdf(self, x, theta, **kwargs):
+        """Second derivative of the log density with respect to ``x``."""
         a, b = theta.T
         return -(a-1)/x**2 - (b-1)/(1-x)**2
 
 
 class Logistic:
+    """Logistic marginal centred on the current control, with scale ``theta``."""
 
     name = 'Logistic'
 
     def pdf(self, x, theta, **kwargs):
+        """Density of the marginal at ``x``."""
         loc = kwargs.get('mean', 0)
         return stats.logistic(loc=loc, scale=theta).pdf(x)
-    
+
     def ppf(self, u, theta, **kwargs):
+        """Quantile function of the marginal at ``u``."""
         loc = kwargs.get('mean', 0)
         return stats.logistic(loc=loc, scale=theta).ppf(u)
 
     def grad_log_pdf(self, x, theta, **kwargs):
+        """Derivative of the log density with respect to ``x``."""
         loc = kwargs.get('mean', 0)
         u = (x - loc) / (2 * theta)
         return -np.tanh(u)/theta
-    
+
     def hess_log_pdf(self, x, theta, **kwargs):
+        """Second derivative of the log density with respect to ``x``."""
         loc = kwargs.get('mean', 0)
         u = (x - loc) / (2 * theta)
         return -1/(2*theta**2 * np.cosh(u)**2)
-    
+
     def var_to_scale(self, var):
+        """The logistic scale giving variance ``var``."""
         return np.sqrt(3*var)/np.pi
-    
+
 class TruncGaussian:
+    """Gaussian marginal truncated to ``[lb, ub]``, centred on the current control, with standard deviation ``theta``."""
 
     def __init__(self, lb=0, ub=1):
         self.name = 'TruncGaussian'
@@ -333,78 +380,92 @@ def __init__(self, lb=0, ub=1):
         self.ub = ub
 
     def pdf(self, x, theta, **kwargs):
+        """Density of the marginal at ``x``."""
         mu = kwargs.get('mean')
         a, b = (self.lb - mu)/theta, (self.ub - mu)/theta
         return stats.truncnorm(a, b, loc=mu, scale=theta).pdf(x)
 
     def ppf(self, u, theta, **kwargs):
+        """Quantile function of the marginal at ``u``."""
         mu = kwargs.get('mean')
         a, b = (self.lb - mu)/theta, (self.ub - mu)/theta
         return stats.truncnorm(a, b, loc=mu, scale=theta).ppf(u)
-    
+
     def grad_log_pdf(self, x, theta, **kwargs):
+        """Derivative of the log density with respect to ``x``."""
         mu = kwargs.get('mean')
         return -(x - mu)/theta**2
 
     def hess_log_pdf(self, x, theta, **kwargs):
+        """Second derivative of the log density with respect to ``x``."""
         return -1/theta**2
-    
+
     def grad_theta_log_pdf(self, x, theta, **kwargs):
+        """Derivative of the log density with respect to ``theta``."""
         mu  = kwargs.get('mean')
         sig = theta
-        phi = lambda z: stats.norm.pdf(z)
-        phi_d = phi((self.ub-mu)/sig) - phi((self.lb-mu)/sig) 
-        Phi_d = stats.norm.cdf((self.ub-mu)/sig) - stats.norm.cdf((self.lb-mu)/sig) 
+        def phi(z):
+            return stats.norm.pdf(z)
+        phi_d = phi((self.ub-mu)/sig) - phi((self.lb-mu)/sig)
+        Phi_d = stats.norm.cdf((self.ub-mu)/sig) - stats.norm.cdf((self.lb-mu)/sig)
         return (x-mu)/sig**2 + phi_d/(sig*Phi_d)
 
     def hess_theta_log_pdf(self, x, theta, **kwargs):
+        """Second derivative of the log density with respect to ``theta``."""
         mu  = kwargs.get('mean')
         sig = theta
-        phi = lambda z: stats.norm.pdf(z)
+        def phi(z):
+            return stats.norm.pdf(z)
 
         a = self.lb
         b = self.ub
 
-        phi_d = phi((b-mu)/sig) - phi((a-mu)/sig) 
+        phi_d = phi((b-mu)/sig) - phi((a-mu)/sig)
         Phi_d = stats.norm.cdf((b-mu)/sig) - stats.norm.cdf((a-mu)/sig)
         ratio = phi_d/Phi_d
 
         return -1/sig**2 - mu*ratio/sig**3 + (ratio/sig)**2 + (b*phi((b-mu)/sig) - a*phi((a-mu)/sig))/(sig**3 * Phi_d)
 
 class Gaussian:
+    """Gaussian marginal centred on the current control, with standard deviation ``theta``."""
 
     name = 'Gaussian'
 
     def pdf(self, x, theta, **kwargs):
+        """Density of the marginal at ``x``."""
         mu = kwargs.get('mean')
         return stats.norm(loc=mu, scale=theta).pdf(x)
 
     def ppf(self, u, theta, **kwargs):
+        """Quantile function of the marginal at ``u``."""
         mu = kwargs.get('mean')
         return stats.norm(loc=mu, scale=theta).ppf(u)
-    
+
     def grad_log_pdf(self, x, theta, **kwargs):
+        """Derivative of the log density with respect to ``x``."""
         mu = kwargs.get('mean')
         return -(x - mu)/theta**2
 
     def hess_log_pdf(self, x, theta, **kwargs):
+        """Second derivative of the log density with respect to ``x``."""
         return -1/theta**2
-        
-        
+
+
 
 def epsilon_trafo(x, enX, eps, lower=None, upper=None):
+    """Map unit-interval beta samples ``enX`` to an interval of half-width ``eps`` around ``x``, shifted to stay within the bounds."""
 
     if not (lower is None and upper is None):
         Psi = x + (enX-0.5)*np.minimum(2*eps, upper-lower)
         enY = Psi + np.maximum(0, lower-(x-eps)) - np.maximum(0, x+eps - upper)
     else:
         enY = x + 2*eps*(enX-0.5)
-    
+
     return enY
 
 
-from sympy import symbols, solve, im, re
 def var_to_concentration(mode, var, lb=0, ub=1):
+    """The beta concentration giving variance ``var`` at ``mode`` on ``[lb, ub]`` (variance capped below 1/12)."""
 
     mode = (mode-lb)/(ub-lb)
     var  = var/(ub-lb)**2
@@ -426,7 +487,7 @@ def var_to_concentration(mode, var, lb=0, ub=1):
 
     # solve for c
     solution = solve(equation, c)
-   
+
     # check if imaginary part is zero
     for i, sol in enumerate(solution):
         is_real = im(sol).evalf() < 1e-10
@@ -442,6 +503,7 @@ def var_to_concentration(mode, var, lb=0, ub=1):
     return np.max(solution)
 
 def kappa(m,c):
+    """Kappa(theta) of the beta marginal: the log-partition term of its natural-parameter form."""
     p1 = polygamma(0, 1+c*m)
     p2 = polygamma(0, 1+c*(1-m))
-    return p1-p2
\ No newline at end of file
+    return p1-p2
diff --git a/src/popt/loop/__init__.py b/src/popt/loop/__init__.py
deleted file mode 100644
index 5ded1783..00000000
--- a/src/popt/loop/__init__.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Main loop for running optimization."""
\ No newline at end of file
diff --git a/src/popt/loop/ensemble_base.py b/src/popt/loop/ensemble_base.py
deleted file mode 100644
index f2999e2c..00000000
--- a/src/popt/loop/ensemble_base.py
+++ /dev/null
@@ -1,301 +0,0 @@
-# External imports
-import numpy as np
-import pandas as pd
-import sys
-import warnings
-
-from copy import deepcopy
-
-# Internal imports
-from popt.misc_tools import optim_tools as ot
-from pipt.misc_tools import analysis_tools as at
-from ensemble.ensemble import Ensemble as SupEnsemble
-from simulator.simple_models import noSimulation
-from pipt.misc_tools.ensemble_tools import matrix_to_dict
-
-__all__ = ['EnsembleOptimizationBaseClass']
-
-class EnsembleOptimizationBaseClass(SupEnsemble):
-    '''
-    Base class for the popt ensemble
-    '''
-    def __init__(self, options, simulator, objective):
-        '''
-        Parameters
-        ----------
-        options : dict
-            Options for the ensemble class
-        
-        simulator : callable
-            The forward simulator (e.g. flow). If None, no simulation is performed.
-        
-        objective : callable
-            The objective function (e.g. npv)
-        '''
-        if simulator is None:
-            sim = noSimulation()
-        else:
-            sim = simulator
-
-        # Initialize the PET Ensemble
-        super().__init__(options, sim)
-
-        # Unpack some options
-        self.save_prediction = options.get('save_prediction', None)
-        self.num_models      = options.get('num_models', 1)
-        self.transform       = options.get('transform', False)
-        self.num_samples     = self.ne
-
-        # Set objective function (callable)
-        self.obj_func = objective
-        self.state_func_values = None
-        self.ens_func_values = None
-
-        # Initialize state-related attributes
-        self.stateX = np.array([]) # Current state vector, (nx,)
-        self.stateF = None         # Function value(s) of current state
-        self.bounds = []           # Bounds (untransformed) for each variable in stateX
-        self.varX   = np.array([]) # Variance for state vector
-        self.covX   = None         # Covariance matrix for state vector
-        self.enX    = None         # Ensemble of state vectors ,(nx, ne)
-        self.enF    = None         # Ensemble of function values, (ne, )
-        self.lb     = np.array([]) # Lower bounds (transformed) for state vector, (nx,)
-        self.ub     = np.array([]) # Upper bounds (transformed) for state vector, (nx,)
-
-        # Intialize state information
-        for key in self.prior_info.keys():
-
-            # Extract prior information for this variable
-            mean   = np.asarray(self.prior_info[key]['mean'])
-            var    = self.prior_info[key]['variance']*np.ones(mean.size)
-            lb, ub = self.prior_info[key].get('limits', (None, None))
-
-            # Fill in state vector and index information    
-            self.stateX = np.append(self.stateX, mean)
-            self.idX[key] = (self.stateX.size - mean.size, self.stateX.size)
-
-            # Set bounds and transform variance if applicable
-            if self.transform and (lb is not None) and (ub is not None):
-                var = var/(ub - lb)**2
-                var = np.clip(var, 0, 1, out=var)
-                self.bounds += mean.size*[(0, 1)]
-            else:
-                self.bounds += mean.size*[(lb, ub)]
-
-            # Fill in lb and ub vectors
-            self.lb = np.append(self.lb, lb*np.ones(mean.size))
-            self.ub = np.append(self.ub, ub*np.ones(mean.size))
-
-            # Fill in variance vector
-            self.varX = np.append(self.varX, var)
-            
-        self.covX = np.diag(self.varX)  # Covariance matrix
-        self.dimX = self.stateX.size    # Dimension of state vector
-        
-        # Scale state if applicable
-        self.stateX = self.scale_state(self.stateX)
-
-    def function(self, x, *args, **kwargs):
-        """
-        This is the main function called during optimization.
-
-        Parameters
-        ----------
-        x : ndarray
-            Control vector, shape (number of controls, number of perturbations)
-
-        Returns
-        -------
-        obj_func_values : numpy.ndarray
-            Objective function values, shape (number of perturbations, )
-        """
-        self._aux_input()
-
-        # check for ensmble
-        if len(x.shape) == 1:
-            x = x[:,np.newaxis]
-            self.ne = self.num_models
-        else: self.ne = x.shape[1]
-
-        # Run simulation
-        x = self.invert_scale_state(x)
-        x = self._reorganize_multilevel_ensemble(x)
-        run_success = self.calc_prediction(x, save_prediction=self.save_prediction)
-        x = self._reorganize_multilevel_ensemble(x)
-        x = self.scale_state(x).squeeze()
-
-        #if self.enX is not None:
-        #    self.enX = self.scale_state(self.enX)
-
-        # Evaluate the objective function
-        if run_success:
-            func_values = self.obj_func(
-                self.pred_data, 
-                input_dict=self.sim.input_dict,
-                true_order=self.sim.true_order, 
-                state=matrix_to_dict(self.invert_scale_state(x), self.idX),
-                **kwargs
-            )
-        else:
-            func_values = np.inf  # the simulations have crashed
-
-        if len(x.shape) == 1 and np.all(func_values != np.inf):
-            self.stateF = func_values
-        else:
-            self.enF = func_values 
-        
-        return func_values
-    
-    def get_state(self):
-        """
-        Returns
-        -------
-        x : numpy.ndarray
-            Control vector as ndarray, shape (number of controls, number of perturbations)
-        """
-        return self.stateX
-    
-    def get_cov(self):
-        """
-        Returns
-        -------
-        cov : numpy.ndarray
-            Covariance matrix, shape (number of controls, number of controls)
-        """
-        return self.covX
-
-    def get_bounds(self):
-        """
-        Returns
-        -------
-        bounds : list
-            (min, max) pairs for each element in x. None is used to specify no bound.
-        """
-
-        return self.bounds
-
-    def scale_state(self, x):
-        """
-        Transform the internal state from [lb, ub] to [0, 1]
-
-        Parameters
-        ----------
-        x : array_like
-            The input state
-
-        Returns
-        -------
-        x : array_like
-            The scaled state
-        """
-        x = np.asarray(x)
-        scaled_x = np.zeros_like(x)
-        
-        if self.transform is False:
-            return x
-        
-        for i in range(len(x)):
-            if (self.lb[i] is not None) and (self.ub[i] is not None):
-                scaled_x[i] = (x[i] - self.lb[i]) / (self.ub[i] - self.lb[i])
-            else:
-                scaled_x[i] = x[i]  # No scaling if bounds are None
-                
-        return scaled_x
-
-    def invert_scale_state(self, u):
-        """
-        Transform the internal state from [0, 1] to [lb, ub]
-
-        Parameters
-        ----------
-        u : array_like
-            The scaled state
-
-        Returns
-        -------
-        x : array_like
-            The unscaled state
-        """
-        u = np.asarray(u)
-        x = np.zeros_like(u)
-
-        if self.transform is False:
-            return u
-
-        for i in range(len(u)):
-            if (self.lb[i] is not None) and (self.ub[i] is not None):
-                x[i] = self.lb[i] + u[i] * (self.ub[i] - self.lb[i])
-            else:
-                x[i] = u[i]  # No scaling if bounds are None
-                
-        return x
-
-    def save_stateX(self, path='./', filetype='npz'):
-        '''
-        Save the state vector.
-
-        Parameters
-        ----------
-        path : str
-            Path to save the state vector. Default is current directory.
-        
-        filetype : str
-            File type to save the state vector. Options are 'csv', 'npz' or 'npy'. Default is 'npz'.
-        '''
-        if self.transform:
-            stateX = self.invert_scale_state(self.stateX)
-        else:
-            stateX = self.stateX
-
-        if filetype == 'csv':
-            state_dict = matrix_to_dict(stateX, self.idX)
-            state_df = pd.DataFrame(data=state_dict)
-            state_df.to_csv(path + 'stateX.csv', index=False)
-        elif filetype == 'npz':
-            state_dict = matrix_to_dict(stateX, self.idX)
-            np.savez_compressed(path + 'stateX.npz', **state_dict)
-        elif filetype == 'npy':
-            np.save(path + 'stateX.npy', stateX)
-    
-    def _reorganize_multilevel_ensemble(self, x):
-        # Only toggle multilevel state when x is truly an ensemble (2D with >1 columns).
-        # Treat shape (nx, 1) the same as a 1D vector.
-        if 'multilevel' in self.keys_en:
-            if isinstance(x,list) or ( x.ndim > 1 and (x.shape[1] > 1) ):
-                ml_ne = self.multilevel['ml_ne']
-                x = ot.toggle_ml_state(x, ml_ne)
-        return x
-
-    def _aux_input(self):
-        """
-        Set the auxiliary input used for multiple geological realizations
-        """
-
-        nr = 1  # nr is the ratio of samples over models
-        if self.num_models > 1:
-            if np.remainder(self.num_samples, self.num_models) == 0:
-                nr = int(self.num_samples / self.num_models)
-                self.aux_input = list(np.repeat(np.arange(self.num_models), nr))
-            else:
-                print('num_samples must be a multiplum of num_models!')
-                sys.exit(0)
-        return nr
-
-    def _scale_state(self):
-        """
-        Transform the internal state from [lb, ub] to [0, 1]
-        """
-        if self.transform and (self.lb and self.ub):
-            for i, key in enumerate(self.state):
-                self.state[key] = (self.state[key] - self.lb[i])/(self.ub[i] - self.lb[i])
-                np.clip(self.state[key], 0, 1, out=self.state[key])
-
-    def _invert_scale_state(self):
-        """
-        Transform the internal state from [0, 1] to [lb, ub]
-        """
-        if self.transform and (self.lb and self.ub):
-            for i, key in enumerate(self.state):
-                if self.transform:
-                    self.state[key] = self.lb[i] + self.state[key]*(self.ub[i] - self.lb[i])
-                np.clip(self.state[key], self.lb[i], self.ub[i], out=self.state[key])
diff --git a/src/popt/loop/extensions.py b/src/popt/loop/extensions.py
deleted file mode 100644
index 2dc7536e..00000000
--- a/src/popt/loop/extensions.py
+++ /dev/null
@@ -1,330 +0,0 @@
-# External imports 
-import numpy as np
-from scipy import stats
-from scipy.special import polygamma, digamma
-
-# Internal imports
-from popt.misc_tools import optim_tools as ot
-
-# NB! THIS FILE IS NOT USED ANYMORE
-
-__all__ = ['GenOptExtension']
-
-class GenOptExtension:
-    '''
-    Class that contains all the operations on the mutation distribution of GenOpt
-    '''
-    def __init__(self, x, cov, theta0=[20.0, 20.0], func=None, ne=None):
-        '''
-        Parameters
-        ----------
-        x : array_like, shape (d,)
-            Initial control vector. Used initally to get the dimensionality of the problem.
-        
-        cov : array_like, shape (d,d)
-            Initial covaraince matrix. Used to construct the correlation matrix and 
-            epsilon parameter of GenOpt
-        
-        theta0 : list, of length 2 ([alpha, beta])
-            Initial alpha and beta parameter of the marginal Beta distributions.
-        
-        func : callable (optional)
-            An objective function that can be used later for the gradeint.
-            Can also be passed directly to the gradeint fucntion.
-        
-        ne : int
-        '''
-        self.dim   = x.size                         # dimension of state                 
-        self.corr  = ot.cov2corr(cov)               # initial correlation
-        self.var   = np.diag(cov)                   # initial varaince
-        self.theta = np.tile(theta0, (self.dim,1))  # initial theta parameters, shape (dim, 2)
-        self.eps   = var2eps(self.var, self.theta)  # epsilon parameter(s). SET BY VARIANCE (NOT MANUALLY BU USER ANYMORE)!
-        self.func  = func                           # an objective function (optional)
-        self.size  = ne                             # ensemble size
-
-    def update_distribution(self, theta, corr):
-        '''
-        Updates the parameters (theta and corr) of the distirbution.
-
-        Parameters
-        ----------
-        theta : array_like, shape (d,2)
-            Contains the alpha (first column) and beta (second column) 
-            of the marginal distirbutions.
-
-        corr : array_like, shape (d,d)
-            Correlation matrix 
-        '''
-        self.theta = theta
-        self.corr  = corr
-        return 
-    
-    def get_theta(self):
-        return self.theta
-    
-    def get_corr(self):
-        return self.corr
-
-    def get_cov(self):
-
-        std = np.zeros(self.dim)
-        for d in range(self.dim):
-            std[d] = stats.beta(*self.theta[d]).std() * 2 * self.eps[d]
-        
-        return ot.corr2cov(self.corr, std=std)
-        
-    def sample(self, size):
-        '''
-        Samples the mutation distribution as described in the GenOpt paper (NOT PUBLISHED YET!)
-
-        Parameters
-        ----------
-        size : int
-            Ensemble size (ne). Size of the sample to be drawn.
-        
-        Returns
-        -------
-        out : tuple, (enZ, enX)
-
-            enZ : array_like, shape (ne,d)
-                Zero-mean Gaussain ensemble, drawn with the correlation matrix, corr
-            
-            enX : array_like, shape (ne,d)
-                The drawn ensemble matrix, X ~ p(x|θ,R) (GenOpt pdf)
-        '''
-        # Sample normal distribution with correlation
-        enZ = np.random.multivariate_normal(mean=np.zeros(self.dim),
-                                            cov=self.corr,
-                                            size=size)
-
-        # Transform Z to a uniform variable U
-        enU = stats.norm.cdf(enZ)
-
-        # Initialize enX
-        enX = np.zeros_like(enZ)
-
-        # Loop over dim
-        for d in range(self.dim):
-            marginal = stats.beta(*self.theta[d]) # Make marginal dist.
-            enX[:,d] = marginal.ppf(enU[:,d])     # Transform U to marginal variables X
-
-        return enZ, enX
-
-    def eps_trafo(self, x, enX):
-        '''
-        Performs the epsilon transformation, 
-            X ∈ [0, 1] ---> Y ∈ [x-ε, x+ε]
-        
-        Parameters
-        ----------
-        x : array_like, shape (d,)
-            Current state vector.
-        
-        enX : array_like, shape (ne,d)
-            Ensemble matrix X sampled from GenOpt distribution
-        
-        Returns
-        -------
-        out : array_like, shape (ne,d)
-            Epsilon transfromed ensemble matrix, Y
-        '''
-        enY = np.zeros_like(enX) # tranfomred ensemble 
-
-        # loop over dimenstion   
-        for d, xd in enumerate(x):
-            eps = self.eps[d]
-
-            a = (xd-eps) - ( (xd-eps)*(xd-eps < 0) ) \
-                         - ( (xd+eps-1)*(xd+eps > 1) ) \
-                         + (xd+eps-1)*(xd-eps < 0)*(xd+eps > 1) #Lower bound of ensemble
-            
-            b = (xd+eps) - ( (xd-eps)*(xd-eps < 0) ) \
-                         - ( (xd+eps-1)*(xd+eps > 1) ) \
-                         + (xd-eps)*(xd-eps < 0)*(xd+eps > 1)   #Upper bound of ensemble
-    
-            enY[:,d] =  a + enX[:, d]*(b-a)                 #Component-wise trafo.
-        
-        return enY
-
-    def gradient(self, x, *args, **kwargs):
-        '''
-        Calcualtes the average gradient of func using Stein's Lemma.
-        Described in GenOpt paper.
-
-        Parameters
-        ----------
-        x : array_like, shape (d,)
-            Current state vector.
-        
-        args : (theta, corr)
-            theta (parameters of distribution), shape (d,2)
-            corr (correlation matrix), shape (d,d)
-        
-        kwargs :
-            func : callable objectvie function
-            ne : ensemble size
-    
-        Returns
-        -------
-        out : array_like, shape (d,)
-            The average gradient.
-        '''
-        # check for objective fucntion 
-        func = kwargs.get('func')
-        if (func is None) and (self.func is not None):
-            func = self.func
-        else:
-            raise ValueError('No objectvie fucntion given. Please pass keyword argument: func=')
-        
-        # check for ensemble size
-        if 'ne' in kwargs:
-            ne = kwargs.get('ne')
-        elif self.size is None:
-            ne = max(int(0.25*self.dim), 5)
-        else:
-            ne = self.size
-
-        # update dist
-        if args:
-            self.update_distribution(*args)
-
-        # sample
-        self.enZ, self.enX = self.sample(size=ne)
-
-        # create ensembles
-        self.enY = self.eps_trafo(x, self.enX)
-        self.enJ = func(self.enY.T)
-        meanJ = self.enJ.mean()
-
-        # parameters
-        a = self.theta[:,0] # shape (d,)   
-        b = self.theta[:,1] # shape (d,)
-
-        # copula term
-        matH = np.linalg.inv(self.corr) - np.identity(self.dim)
-    
-        # empty gradients
-        gx = np.zeros(self.dim)
-        gt = np.zeros_like(self.theta)
-
-        for d in range(self.dim):
-            for n in range(ne):
-                
-                j = self.enJ[n]
-                x = self.enX[n]
-                z = self.enZ[n] 
-                
-                # gradient componets
-                g_marg = (a[d]-1)/x[d] - (b[d]-1)/(1-x[d])
-                g_dist = np.inner(matH[d], z)*stats.beta.pdf(x[d], a[d], b[d])/stats.norm.pdf(z[d])
-                gx[d] += (j-meanJ)*(g_marg - g_dist)
-
-                # mutation gradient
-                log_term = [np.log(x[d]), np.log(1-x[d])]
-                psi_term = [delA(a[d], b[d]), delA(b[d], a[d])]
-                gt[d] += (j-meanJ)*(np.array(log_term)-np.array(psi_term))
-            
-            # fisher matrix
-            f_inv = np.linalg.inv(self.fisher_matrix(a[d], b[d])) 
-            gt[d] = np.matmul(f_inv, gt[d])
-
-             
-        gx = -np.matmul(self.get_cov(), gx)/(2*self.eps*(ne-1))
-        self.grad_theta = gt/(ne-1)
-
-        return gx
-    
-    def mutation_gradient(self, x=None, *args, **kwargs):
-        '''
-        Returns the mutation gradient of theta. It is actually calulated in 
-        self.ensemble_gradient.
-
-        Parameters
-        ----------
-        kwargs:
-            return_ensemble : bool
-                If True, all the ensemble matrices are also returned in a dictionary.
-        
-        Returns
-        -------
-        out : array_like, shape (d,2)
-            Mutation gradeint of theta
-        
-        NB! If return_ensembles=True, the ensmebles are also returned!
-        '''
-        if 'return_ensembles' in kwargs:
-            ensembles = {'gaussian'   : self.enZ,
-                         'vanilla'    : self.enX,
-                         'transformed': self.enY,
-                         'objective'  : self.enJ}
-            return self.grad_theta, ensembles
-        else:
-            return self.grad_theta
-    
-    def corr_gradient(self):
-        '''
-        Returns the mutation gradeint of the correlation matrix
-        '''
-        enZ = self.enZ
-        enJ = self.enJ
-        ne  = np.squeeze(enJ).size 
-        grad_corr = np.zeros_like(self.corr)
-
-        for n in range(ne):
-            grad_corr += enJ[n]*(np.outer(enZ[:,n], enZ[:,n]) - self.corr)
-        
-        np.fill_diagonal(grad_corr, 0)
-        corr_gradient = grad_corr/(ne-1)
-
-        return corr_gradient
-    
-    def fisher_matrix(self, alpha, beta):
-        '''
-        Calculates the Fisher matrix of a Beta distribution.
-        
-        Parameters
-        ----------------------------------------------
-        alpha : float
-            alpha parameter in Beta distribution 
-
-        beta : float
-            beta parameter in Beta distribution
-
-        Returns
-        ----------------------------------------------
-        out : array_like, of shape (2, 2)
-            Fisher matrix 
-        '''
-        a = alpha
-        b = beta
-
-        upper_row = [polygamma(1, a) - polygamma(1, a+b), -polygamma(1, a + b)]
-        lower_row = [-polygamma(1, a + b), polygamma(1, b) - polygamma(1, a+b)]
-        fisher_matrix = np.array([upper_row, 
-                                  lower_row])
-        return fisher_matrix
-
-
-# Some helping functions
-def var2eps(var, theta):
-    alphas  = theta[:,0]
-    betas   = theta[:,1]
-    frac    = alphas*betas / ( (alphas+betas)**2 * (alphas+betas+1) )
-    epsilon = np.sqrt(0.25*var/frac)
-    return epsilon
-
-def delA(a, b):
-    '''
-    Calculates the expression psi(a) - psi(a+b),
-    where psi() is the digamma function.
-
-    Parameters
-    --------------------------------------------
-    a : float
-    b : float
-    
-    Returns
-    --------------------------------------------
-    out : float
-    '''
-    return digamma(a)-digamma(a+b)
diff --git a/src/popt/loop/optimize.py b/src/popt/loop/optimize.py
deleted file mode 100644
index f66eacf9..00000000
--- a/src/popt/loop/optimize.py
+++ /dev/null
@@ -1,239 +0,0 @@
-# External imports
-import os
-import numpy as np
-import time
-import pickle
-from abc import ABC, abstractmethod
-
-# Internal imports
-import popt.misc_tools.optim_tools as ot
-from ensemble.logger import PetLogger
-
-
-class Optimize(ABC):
-    """
-    Class for ensemble optimization algorithms. These are classified by calculating the sensitivity or gradient using
-    ensemble instead of classical derivatives. The loop is else as a classic optimization loop: a state (or control
-    variable) will be iterated upon using an algorithm defined in the update_scheme package.
-
-    Attributes
-    ----------
-    logger : Logger
-        Print output to screen and log-file
-
-    pickle_restart_file : str
-        Save name for pickle dump/load
-
-    optimize_result : OptimizeResult
-        Dictionary with results for the current iteration
-
-    iteration : int
-            Iteration index
-
-    max_iter : int
-        Max number of iterations
-
-    restart : bool
-        Restart flag
-
-    restartsave : bool
-        Save restart information flag
-
-    Methods
-    -------
-    run_loop()
-        The main optimization loop
-
-    save()
-        Save restart file
-
-    load()
-        Load restart file
-
-    calc_update()
-        Empty dummy function, actual functionality must be defined by the subclasses
-
-    """
-
-    def __init__(self, **options):
-        """
-        Parameters
-        ----------
-        options : dict
-            Optimization options
-        """
-        # Setup logger
-        self.logger = PetLogger('optim.log')
-
-        # Save name for (potential) pickle dump/load
-        self.pickle_restart_file = 'popt_restart_dump'
-
-        # Dictionary with results for the current iteration
-        self.optimize_result = None
-
-        # Initial iteration index
-        self.iteration = 0
-
-        # Time counter and random generator
-        self.start_time = None
-        self.rnd = None
-
-        # Max number of iterations
-        self.max_iter = options.get('maxiter', 20)
-
-        # Restart flag
-        self.restart = options.get('restart', False)
-
-        # Save restart information flag
-        self.restartsave = options.get('restartsave', False)
-
-        # Optimze with external penalty function for constraints, provide r_0 as input
-        self.epf = options.get('epf', {})
-        self.epf_iteration = 0
-
-        # Initialize variables (set in subclasses)
-        self.options = None
-        self.obj_func_values = None
-
-        # Initialize number of function and jacobi evaluations
-        self.nfev = 0
-        self.njev = 0
-
-        self.msg = 'Convergence was met :)'
-
-    # Abstract function that subclasses are forced to define
-    @abstractmethod
-    def fun(self, x, *args, **kwargs):  # objective function
-        pass
-
-    # Abstract properties that subclasses are forced to define
-    @property
-    @abstractmethod
-    def xk(self):  # current state
-        pass
-
-    @property
-    @abstractmethod
-    def ftol(self):  # function tolerance
-        pass
-
-    @ftol.setter
-    @abstractmethod
-    def ftol(self, value):  # setter for function tolerance
-        pass
-
-    def run_loop(self):
-        """
-        This is the main optimization loop.
-        """
-
-        # If it is a restart run, we load the self info that exists in the pickle save file.
-        if self.restart:
-            try:
-                self.load()
-            except (FileNotFoundError, pickle.UnpicklingError) as e:
-                raise RuntimeError(f"Failed to load restart file '{self.pickle_restart_file}': {e}")
-            # Set the random generator to be the saved value
-            np.random.set_state(self.rnd)
-        else:
-            # delete potential restart files to avoid any problems
-            if self.pickle_restart_file in [f for f in os.listdir('.') if os.path.isfile(f)]:
-                os.remove(self.pickle_restart_file)
-            self.iteration += 1
-
-        # Check if external penalty function (epf) for handling constraints should be used
-        epf_not_converged = True
-        previous_state = None
-        if self.epf:
-            previous_state = self.xk
-            self.logger(
-                f'─────> EPF-EnOpt: {self.epf_iteration}, {self.epf["r"]} (outer iteration, penalty factor)'
-            )  # print epf info
-
-        while epf_not_converged:  # outer loop using epf
-
-            # Run a while loop until max iterations or convergence is reached
-            is_successful = True
-            while self.iteration <= self.max_iter and is_successful:
-
-                # Update control variable
-                is_successful = self.calc_update()
-
-                # Save restart file (if requested)
-                if self.restartsave:
-                    self.rnd = np.random.get_state()  # get the current random state
-                    self.save()
-
-            # Check if max iterations was reached
-            if self.iteration >= self.max_iter:
-                self.msg = 'Optimization stopped due to maximum iterations reached!'
-                self.optimize_result['message'] = self.msg
-            else:
-                self.msg = 'No further improvement possible, optimization converged!'
-                self.optimize_result['message'] = self.msg
-
-            # Logging some info to screen
-            self.logger('')
-            self.logger('============================================')
-            self.logger(self.msg)
-            self.logger(f'Optimization converged in {self.iteration-1} iterations ')
-            self.logger(f'Optimization converged with final obj_func = {np.mean(self.optimize_result["fun"]):.4f}')
-            self.logger(f'Total number of function evaluations = {self.optimize_result["nfev"]}')
-            self.logger(f'Total number of jacobi evaluations = {self.optimize_result["njev"]}')
-            if self.start_time is not None:
-                self.logger(f'Total elapsed time = {(time.perf_counter()-self.start_time)/60:.2f} minutes')
-            self.logger('============================================')
-
-            # Test for convergence of outer epf loop
-            epf_not_converged = False
-            if self.epf:
-                if self.epf_iteration >= self.epf['max_epf_iter']-1:  # max epf_iterations
-                    self.logger(f'─────> EPF-EnOpt: maximum epf iterations reached')  # print epf info
-                    break
-                #p = np.abs(previous_state-self.xk) / (np.abs(previous_state) + 1.0e-9)
-                if self.epf['penalty'].size == 0:
-                    raise ValueError('EPF penalty is empty; cannot compute convergence criterion.')
-                p = np.mean(self.epf['penalty']) / self.epf['r']  # the penalty term (without r)
-                conv_crit = self.epf['conv_crit']
-                if p > conv_crit:
-                    epf_not_converged = True
-                    previous_state = self.xk
-                    self.epf['r'] *= self.epf['r_factor']  # increase penalty factor
-                    self.ftol *= self.epf['tol_factor']  # decrease tolerance
-                    self.obj_func_values = self.fun(self.xk, epf=self.epf)
-                    self.iteration = 0
-                    self.epf_iteration += 1
-                    optimize_result = ot.get_optimize_result(self)
-                    ot.save_optimize_results(optimize_result)
-                    self.nfev += 1
-                    self.iteration = +1
-                    r = self.epf['r']
-                    self.logger(f'─────> EPF-EnOpt: {self.epf_iteration}, {r} (outer iteration, penalty factor)')  # print epf info
-                else:
-                    self.logger(f'─────> EPF-EnOpt: converged, penalty term smaller than {conv_crit}')  # print epf info
-                    final_obj_no_penalty = str( round( float( np.mean(self.fun(self.xk)) ),4) )
-                    self.logger(f'─────> EPF-EnOpt: objective value without penalty = {final_obj_no_penalty}') # print epf info
-    def save(self):
-        """
-        We use pickle to dump all the information we have in 'self'. Can be used, e.g., if some error has occurred.
-        """
-        # Open save file and dump all info. in self
-        with open(self.pickle_restart_file, 'wb') as f:
-            pickle.dump(self.__dict__, f)
-
-    def load(self):
-        """
-        Load a pickled file and save all info. in self.
-        """
-        # Open file and read with pickle
-        with open(self.pickle_restart_file, 'rb') as f:
-            tmp_load = pickle.load(f)
-
-        # Save in 'self'
-        self.__dict__.update(tmp_load)
-
-    def calc_update(self):
-        """
-        This is an empty dummy function. Actual functionality must be defined by the subclasses.
-        """
-        pass
diff --git a/src/popt/misc_tools/basic_tools.py b/src/popt/misc_tools/basic_tools.py
deleted file mode 100644
index 0154a6d3..00000000
--- a/src/popt/misc_tools/basic_tools.py
+++ /dev/null
@@ -1,124 +0,0 @@
-"""
-Collection of simple, yet useful Python tools
-"""
-
-
-import numpy as np
-import sys
-
-def index2d(list2d, value):
-    """
-    Search in a 2D list for pattern or value and return is (i, j) index. If the
-    pattern/value is not found, (None, None) is returned
-
-    Examples
-    --------
-
-    >>> l = [['string1', 1], ['string2', 2]]
-    >>> print index2d(l, 'string1')
-    (0, 0)
-
-    Parameters
-    ----------
-    list2d : list of lists
-        2D list.
-
-    value : object
-        Pattern or value to search for.
-
-    Returns
-    -------
-    ind : tuple
-        Indices (i, j) of the value.
-    """
-    return next(((i, j) for i, lst in enumerate(list2d) for j, x in enumerate(lst) if x == value), None)
-
-
-def read_file(val_type, filename):
-    """
-    Read an eclipse file with specified keyword.
-
-    Examples
-    --------
-    >>> read_file('PERMX','filename.permx')
-
-    Parameters
-    ----------
-    val_type :
-        keyword or property
-    filename :
-        the file that is read
-
-    Returns
-    -------
-    values :
-        a vector with values for each cell
-    """
-
-    file = open(filename, 'r')
-    lines = file.readlines()
-    key = ''
-    line_idx = 0
-    while key != val_type:
-        line = lines[line_idx]
-        if not line:
-            print('Error: Keyword not found')
-            sys.exit(1)
-
-        line_idx += 1
-        if len(line):
-            key = line.split()
-            if key:
-                key = key[0]
-    data = []
-    finished = False
-    while line_idx < len(lines) and not finished:
-        line = lines[line_idx]
-        line_idx += 1
-        if line == '\n' or line[:2] == '--':
-            continue
-        if line == '':
-            break
-        if line.strip() == '/':
-            finished = True
-        sub_str = line.split()
-        for s in sub_str:
-            if '*' in s:
-                num_val = s.split('*')
-                v = float(num_val[1]) * np.ones(int(num_val[0]))
-                data.append(v)
-            elif '/' in s:
-                finished = True
-                break
-            else:
-                data.append(float(s))
-
-    values = np.hstack(data)
-    return values
-
-
-def write_file(filename, val_type, data):
-    """Write an eclipse file with specified keyword.
-
-    Examples
-    --------
-    >>> write_file('filename.permx','PERMX',data_vec)
-
-    Parameters
-    ----------
-    filename :
-        the file that is read
-    val_type:
-        keyword or property
-    data :
-        data written to file
-    """
-
-    file = open(filename, 'w')
-    file.writelines(val_type + '\n')
-    if data.dtype == 'int64':
-        np.savetxt(file, data, fmt='%i')
-    else:
-        np.savetxt(file, data)
-    file.writelines('/' + '\n')
-    file.close()
diff --git a/src/popt/misc_tools/optim_tools.py b/src/popt/misc_tools/optim_tools.py
index 558be1d5..b57b8690 100644
--- a/src/popt/misc_tools/optim_tools.py
+++ b/src/popt/misc_tools/optim_tools.py
@@ -4,79 +4,12 @@
 implementing, leave it in that class.
 """
 import numpy as np
-from scipy.linalg import block_diag
 import os
 from datetime import datetime
-from copy import deepcopy
 
 from scipy.optimize import OptimizeResult
 
 
-def aug_optim_state(state, list_state):
-    """
-    Augment the state variables to get one augmented array.
-
-    Parameters
-    ----------
-    state : dict
-        Dictionary of state variables for optimization. OBS: 1D arrays!
-    list_state : list
-        Fixed list of keys in the state dictionary.
-
-    Returns
-    -------
-    aug_state : numpy.ndarray
-        Augmented 1D array of state variables.
-    """
-    # Start with ensemble of first state variable
-    aug = state[list_state[0]]
-
-    # Loop over the next states (if exists)
-    for i in range(1, len(list_state)):
-        aug = np.hstack((aug, state[list_state[i]]))
-
-    # Return the augmented array
-    return aug
-
-
-def update_optim_state(aug_state, state, list_state):
-    """
-    Extract the separate state variables from an augmented state array.
-
-    It is assumed that the augmented state array is made in the aug_optim_state method, hence this is the reverse method.
-
-    Parameters
-    ----------
-    aug_state : numpy.ndarray
-        Augmented state array.
-    state : dict
-        Dictionary of state variables for optimization.
-    list_state : list
-        Fixed list of keys in the state dictionary.
-
-    Returns
-    -------
-    state : dict
-        State dictionary updated with aug_state.
-    """
-
-    # Loop over all entries in list_state and extract an array with same number of rows as the key in state
-    # determines from aug and replace the values in state[key].
-    # Init. a variable to keep track of which row in 'aug' we start from in each loop
-    aug_row = 0
-    for _, key in enumerate(list_state):
-        # Find no. rows in state[key] to determine how many rows from aug to extract
-        no_rows = state[key].shape[0]
-
-        # Extract the rows from aug and update 'state[key]'
-        state[key] = aug_state[aug_row:aug_row + no_rows]
-
-        # Update tracking variable for row in 'aug'
-        aug_row += no_rows
-
-    # Return
-    return state
-
 def get_list_element(list, element):
     """
     Retrieve the value associated with a given element in a list of tuples.
@@ -137,85 +70,6 @@ def toggle_ml_state(state, ml_ne):
 
     return new_state
 
-def corr2BlockDiagonal(state, corr):
-    """
-    Makes the correlation matrix block diagonal. The blocks are the state varible types.
-
-    Parameters
-    ----------
-    state: dict
-        Current control state, including state names
-
-    corr : array_like
-        Correlation matrix, of shape (d, d)
-
-    Returns
-    -------
-    corr_blocks : list
-        block matrices, one for each variable type
-
-    """
-
-    statenames = list(state.keys())
-    corr_blocks = []
-    for name in statenames:
-        dim = state[name].size
-        corr_blocks.append(corr[:dim, :dim])
-        corr = corr[dim:, dim:]
-    return corr_blocks
-
-
-def time_correlation(a, state, n_timesteps, dt=1.0):
-    """
-    Constructs correlation matrix with time correlation
-    using an autoregressive model.
-
-    $$ Corr(t_1, t_2) = a^{|t_1 - t_2|} $$
-
-    Assumes that each varaible in state is time-order such that
-    `x = [x1, x2,..., xi,..., xn]`, where `i` is the time index, 
-    and `xi` is d-dimensional.
-
-    Parameters
-    -------------------------------------------------------------
-    a : float
-        Correlation coef, in range (0, 1).
-
-    state : dict
-        Control state (represented in a dict).
-    
-    n_timesteps : int
-        Number of time-steps to correlate for each component.
-    
-    dt : float or int
-        Duration between each time-step. Default is 1.
-
-    Returns
-    -------------------------------------------------------------
-    out : numpy.ndarray
-        Correlation matrix with time correlation    
-    """
-    dim_states = [int(state[name].size/n_timesteps) for name in list(state.keys())]
-    blocks     = []
-
-    # Construct correlation matrix
-    # m: variable type index  
-    # i: first time index
-    # j: second time index
-    # k: first dim index
-    # l: second dim index
-    for m in dim_states:
-        corr_single_block = np.zeros((m*n_timesteps, m*n_timesteps))
-        for i in range(n_timesteps):
-            for j in range(n_timesteps):
-                for k in range(m):
-                    for l in range(m):
-                       corr_single_block[i*m + k, j*m + l] = (k==l)*a**abs(dt*(i-j))
-        blocks.append(corr_single_block)
-
-    return block_diag(*blocks)
-
-
 def cov2corr(cov):
     """
     Transfroms a covaraince matrix to a correlation matrix
@@ -235,27 +89,6 @@ def cov2corr(cov):
     return corr
 
 
-def corr2cov(corr, std):
-    """
-    Transfroms a correlation matrix to a covaraince matrix
-
-    Parameters
-    ----------
-    corr : array_like
-        The correlation matrix, of shape (d,d).
-
-    std : array_like
-        Array of the standard deviations, of shape (d, ).
-
-    Returns
-    -------
-    out : numpy.ndarray
-        The covaraince matrix, of shape (d,d)
-    """
-    cov = np.multiply(corr, np.outer(std, std))
-    return cov
-
-
 def get_sym_pos_semidef(a):
     """
     Force matrix to positive semidefinite
@@ -300,70 +133,17 @@ def clip_state(x, bounds):
         The state after truncation
     """
 
-    any_not_none = any(any(item) for item in bounds)
-    if any_not_none:
-        lb = np.array(bounds)[:, 0]
-        lb = np.where(lb is None, -np.inf, lb)
-        ub = np.array(bounds)[:, 1]
-        ub = np.where(ub is None, -np.inf, ub)
-        x = np.clip(x, lb, ub)
-    return x
-
-
-def get_optimize_result(obj):
-    """
-    Collect optimize results based on requested
-
-    Parameters
-    ----------
-    obj : popt.loop.optimize.Optimize
-        An instance of an optimization class
+    if bounds is None or len(bounds) == 0:
+        return x
+    # None means "no bound on this side". The previous version tested
+    # `lb is None` on a whole array (always False), defaulted the *upper*
+    # bound to -inf, and skipped clipping altogether when every bound was 0.
+    lb = np.array([-np.inf if lo is None else lo for lo, _ in bounds], dtype=float)
+    ub = np.array([np.inf if hi is None else hi for _, hi in bounds], dtype=float)
+    return np.clip(x, lb, ub)
 
-    Returns
-    -------
-    save_dict : scipy.optimize.OptimizeResult
-        The requested optimization results
-    """
 
-    # Initialize dictionary of variables to save
-    save_dict = OptimizeResult({'success': True, 'x': obj.xk, 'fun': np.mean(obj.fk),
-                                'nit':  obj.iteration, 'nfev': obj.nfev, 'njev': obj.njev})
-    if hasattr(obj, 'epf') and obj.epf:
-        save_dict['epf_iteration'] = obj.epf_iteration
-    if hasattr(obj, 'method') and obj.method:
-        save_dict['method'] = obj.method
-    elif 'method' in obj.options:
-        save_dict['method'] = obj.options['method']
-    if 'save_folder' in obj.options:
-        save_dict['save_folder'] = obj.options['save_folder']
-
-    if 'savedata' in obj.options:
-
-        # Make sure "SAVEDATA" gives a list
-        if isinstance( obj.options['savedata'], list):
-            savedata = obj.options['savedata']
-        else:
-            savedata = [ obj.options['savedata']]
-
-        if 'args' in savedata:
-            for a, arg in enumerate(obj.args):
-                save_dict[f'args[{a}]'] = arg
-      
-        # Loop over variables to store in save list
-        for save_typ in savedata:
-            if 'xk' in save_typ:
-                continue  # mean_state is alwaysed saved as 'x'
-            if save_typ in locals():
-                save_dict[save_typ] = eval('{}'.format(save_typ))
-            elif hasattr( obj, save_typ):
-                save_dict[save_typ] = eval(' obj.{}'.format(save_typ))
-            else:
-                print(f'Cannot save {save_typ}!\n\n')
-
-    return save_dict
-
-
-def save_optimize_results(intermediate_result):
+def save_optimize_results(intermediate_result, folder=None):
     """
     Save optimize results
 
@@ -377,7 +157,11 @@ def save_optimize_results(intermediate_result):
         intermediate_result = OptimizeResult({'x': intermediate_result})
 
     # Make folder (if it does not exist)
-    if 'save_folder' in intermediate_result:
+    if folder is not None:
+        save_folder = folder
+        if not os.path.exists(save_folder):
+            os.makedirs(save_folder)
+    elif 'save_folder' in intermediate_result:
         save_folder = intermediate_result['save_folder']
         if not os.path.exists(save_folder):
             os.makedirs(save_folder)
@@ -392,7 +176,7 @@ def save_optimize_results(intermediate_result):
 
     # Save the variables
     if 'epf_iteration' in intermediate_result:
-        np.savez(save_folder + '/optimize_result_{0}_{1}'.format(str(intermediate_result['epf_iteration']), suffix), 
+        np.savez(save_folder + '/optimize_result_{0}_{1}'.format(str(intermediate_result['epf_iteration']), suffix),
                  **intermediate_result)
     else:
         np.savez(save_folder + '/optimize_result_{0}'.format(suffix), **intermediate_result)
diff --git a/src/popt/optimization_methods/__init__.py b/src/popt/optimization_methods/__init__.py
new file mode 100644
index 00000000..1fa91585
--- /dev/null
+++ b/src/popt/optimization_methods/__init__.py
@@ -0,0 +1,7 @@
+"""Optimizers: EnOpt, GenOpt, LineSearch, TrustRegion and SmcOpt, all built on ``OptimizerBase``."""
+from .optimizer_base import *
+from .linesearch import *
+from .trust_region import *
+from .enopt import *
+from .genopt import *
+from .smcopt import *
diff --git a/src/popt/optimization_methods/enopt.py b/src/popt/optimization_methods/enopt.py
new file mode 100644
index 00000000..b36c73d9
--- /dev/null
+++ b/src/popt/optimization_methods/enopt.py
@@ -0,0 +1,226 @@
+"""Ensemble optimization methods compatible with OptimizerBase."""
+
+import numpy as np
+
+from popt.misc_tools import optim_tools as ot
+from popt.optimization_methods.optimizer_base import OptimizerBase, StepReport
+import popt.optimization_methods.subroutines.optimizers as opt
+
+__author__ = ""
+__all__ = ["EnOpt"]
+
+
+class EnOpt(OptimizerBase):
+    """Ensemble-based optimization (EnOpt)."""
+
+    NAME = "EnOpt"
+    VALID_OPTIMIZERS = ("GD", "Adam", "AdaMax", "Steihaug")
+
+    def __init__(self, x0, fun, jac=None, hess=None, args=(), bounds=None, callback=None, **options):
+        """Initialize an EnOpt optimizer instance.
+
+        Parameters
+        ----------
+        x0 : ndarray
+            Initial control/state vector.
+        fun : callable
+            Objective function.
+        jac : callable
+            Ensemble gradient function.
+        hess : callable, optional
+            Ensemble Hessian function.
+        args : tuple, optional
+            The first tuple element is interpreted as the initial covariance.
+        bounds : sequence, optional
+            Lower and upper bounds for each state variable.
+        callback : callable, optional
+            Callback invoked after successful updates.
+        **options
+            EnOpt configuration, plus everything :class:`OptimizerBase` takes.
+            - tol: Convergence tolerance for objective improvement (default: 1e-6). Also used as ``ftol`` when given.
+            - step_size: Initial optimizer step size. Overrides ``alpha`` when provided.
+            - alpha: Initial optimizer step size (default: 0.1).
+            - alpha_cov: Covariance update scaling factor (default: 0.001).
+            - beta: Momentum parameter used in the optimizer and optional Nesterov updates (default: 0.0).
+            - nesterov: Whether to evaluate search quantities with Nesterov momentum (default: False).
+            - alpha_maxiter: Maximum number of backtracking trials per iteration (default: 5).
+            - resample: Number of covariance resampling attempts if no improvement is found (default: 0).
+            - hessian: Whether to use the Hessian in the search direction computation (default: False).
+            - normalize: Whether to normalize the gradient or Hessian-derived search quantities (default: True).
+            - cov_factor: Covariance shrink factor applied during resampling (default: 0.5).
+            - optimizer: Update rule name. Supported values are ``GD``, ``Adam``, ``AdaMax``, and ``Steihaug`` (default: ``GD``).
+        """
+        if jac is None:
+            raise ValueError("EnOpt requires a Jacobian (ensemble gradient) callable.")
+
+        # Keep args empty for wrapped callables to avoid duplicating covariance
+        # (EnOpt passes covariance explicitly during each update).
+        super().__init__(x0, fun, jac=jac, hess=hess, args=(), bounds=bounds, callback=callback, **options)
+
+        # EnOpt controls
+        self.obj_func_tol = options.get("tol", 1e-6)
+        self.ftol = options.get("tol", options.get("ftol", self.ftol))
+        self.alpha = options.get("step_size", options.get("alpha", 0.1))
+        self.alpha_cov = options.get("alpha_cov", 0.001)
+        self.beta = options.get("beta", 0.0)
+        self.nesterov = options.get("nesterov", False)
+        self.alpha_iter_max = options.get("alpha_maxiter", 5)
+        self.max_resample = options.get("resample", 0)
+        self.use_hessian = options.get("hessian", False)
+        self.normalize = options.get("normalize", True)
+        self.cov_factor = options.get("cov_factor", 0.5)
+
+        # Dynamic EnOpt state
+        self.cov = np.asarray(args[0], dtype=float)
+        self.state_step = np.zeros_like(self.xk, dtype=float)
+        self.cov_step = np.zeros_like(self.cov, dtype=float)
+        self.alpha_iter = 0
+
+        self.optimizer_name = options.get("optimizer", "GD")
+        self.optimizer = self._build_optimizer(self.optimizer_name)
+
+    @property
+    def obj_func_values(self):
+        """Legacy alias for ``fk``."""
+        return self.fk
+
+    def update_step(self) -> StepReport:
+        """Perform one EnOpt step with backtracking and optional resampling."""
+        self.optimizer.restore_parameters()
+        resampling_iter = 0
+
+        while resampling_iter <= self.max_resample:
+            shrink = self.cov_factor ** resampling_iter
+            self._apply_optimizer_backtracking(np.sqrt(self.cov_factor) ** resampling_iter)
+            self.jk, self.hk = self._compute_search_quantities(shrink)
+
+            self.alpha_iter = 0
+            while self.alpha_iter <= self.alpha_iter_max:
+                new_state, new_step = self.optimizer.apply_update(
+                    self.xk,
+                    self.jk,
+                    hessian=self.hk,
+                    iter=self.iteration,
+                )
+                new_state = self.bound_handler.project_to_bounds(new_state)
+                new_func_values = self.fun(new_state)
+
+                if np.mean(self.fk) - np.mean(new_func_values) > self.obj_func_tol:
+                    self._accept_step(new_state, new_func_values, new_step, self.hk)
+                    return StepReport(True)
+
+                if self.alpha_iter < self.alpha_iter_max:
+                    self._apply_optimizer_backtracking()
+                    self.alpha_iter += 1
+                else:
+                    break
+
+            if (resampling_iter < self.max_resample) and (np.mean(new_func_values) > np.mean(self.fk)):
+                resampling_iter += 1
+                self.optimizer.restore_parameters()
+                continue
+
+            return StepReport(False, "EnOpt failed to find an improving step.")
+
+        return StepReport(False, "EnOpt exhausted all resampling attempts.")
+
+    def _evaluate_missing_derivatives(self):
+        # The ensemble gradient takes the covariance and is evaluated inside
+        # every step (`_compute_search_quantities`), never at the bare iterate.
+        pass
+
+    def _compute_search_quantities(self, shrink):
+        cov_step = self.beta * self.cov_step if self.nesterov else 0.0
+        state_step = self.beta * self.state_step if self.nesterov else 0.0
+
+        cov = shrink * (self.cov + cov_step)
+        x_for_grad = self.xk + state_step
+
+        gradient = self.jac(x_for_grad, cov, epf=self.epf)
+        hessian = self.hess(x_for_grad, cov) if self.hess is not None else None
+
+        if self.use_hessian:
+            gradient = np.linalg.inv(hessian) @ (self.cov @ self.cov) @ gradient
+        elif self.normalize:
+            gradient = gradient / np.maximum(np.linalg.norm(gradient, np.inf), 1e-12)
+
+        if self.normalize and hessian is not None:
+            hessian = hessian / np.maximum(np.linalg.norm(hessian, np.inf), 1e-12)
+
+        return gradient, hessian
+
+    def _accept_step(self, new_state, new_func_values, new_step, hessian):
+        self._commit_step(new_state, new_func_values)
+        self.state_step = new_step
+        if hasattr(self.optimizer, "get_step_size"):
+            self.alpha = self.optimizer.get_step_size()
+
+        if hessian is not None:
+            grad_cov = self.bound_handler.hess_from_unit_cube(hessian)
+            # Momentum on the covariance step, as for the state step (beta is
+            # documented as the momentum parameter). `beta * self.cov` here
+            # shrank the covariance by (1 - beta) every accepted step whatever
+            # the gradient said.
+            self.cov_step = self.alpha_cov * grad_cov + self.beta * self.cov_step
+            self.cov = ot.get_sym_pos_semidef(self.cov - self.cov_step)
+
+        if self.xk.size == 1 and hasattr(self.optimizer, "step_size"):
+            self.optimizer.step_size /= 2
+
+        self.optimizer.restore_parameters()
+
+    def _build_optimizer(self, optimizer_name):
+        if optimizer_name not in self.VALID_OPTIMIZERS:
+            raise ValueError(
+                f"Optimizer '{optimizer_name}' not recognized for EnOpt. "
+                f"Valid options are: {self.VALID_OPTIMIZERS}."
+            )
+
+        if optimizer_name == "GD":
+            return opt.GradientDescent(self.alpha, self.beta)
+        if optimizer_name == "Adam":
+            return opt.Adam(self.alpha, self.beta)
+        if optimizer_name == "AdaMax":
+            self.normalize = False
+            return opt.AdaMax(self.alpha, self.beta)
+        return opt.Steihaug(delta0=3.0)
+
+    def _apply_optimizer_backtracking(self, shrink=0.5):
+        # Every step rule takes the factor. The TypeError fallback that used
+        # to sit here halved Adam, AdaMax and Steihaug on the pre-trial call
+        # with shrink = 1.0, i.e. before the first attempt of every iteration.
+        self.optimizer.apply_backtracking(shrink)
+
+    def _get_restart_state(self) -> dict:
+        return {
+            "cov": self.cov,
+            "state_step": self.state_step,
+            "cov_step": self.cov_step,
+            "alpha": self.alpha,
+            "alpha_iter": self.alpha_iter,
+            "obj_func_tol": self.obj_func_tol,
+            "optimizer_name": self.optimizer_name,
+            "optimizer_state": dict(self.optimizer.__dict__),
+        }
+
+    def _set_restart_state(self, state: dict) -> None:
+        self.cov = state.get("cov", self.cov)
+        self.state_step = state.get("state_step", self.state_step)
+        self.cov_step = state.get("cov_step", self.cov_step)
+        self.alpha = state.get("alpha", self.alpha)
+        self.alpha_iter = state.get("alpha_iter", self.alpha_iter)
+        self.obj_func_tol = state.get("obj_func_tol", self.obj_func_tol)
+
+        self.optimizer_name = state.get("optimizer_name", self.optimizer_name)
+        self.optimizer = self._build_optimizer(self.optimizer_name)
+        self.optimizer.__dict__.update(state.get("optimizer_state", {}))
+
+    def log_columns(self) -> dict:
+        """The row of the iteration log: iteration, backtracking attempts, objective, step size, first covariance entry."""
+        return {
+            "iter.": self.iteration,
+            "alpha_iter": self.alpha_iter,
+            "obj_func": float(np.mean(self.fk)),
+            "step-size": self.alpha,
+            "cov[0,0]": float(self.cov[0, 0]),
+        }
diff --git a/src/popt/optimization_methods/genopt.py b/src/popt/optimization_methods/genopt.py
new file mode 100644
index 00000000..0b77cfaa
--- /dev/null
+++ b/src/popt/optimization_methods/genopt.py
@@ -0,0 +1,278 @@
+"""Non-Gaussian generalisation of EnOpt: the sampling distribution adapts as well."""
+
+import numpy as np
+
+from popt.optimization_methods.optimizer_base import OptimizerBase, StepReport
+from popt.optimization_methods.subroutines.cma import CMA
+import popt.optimization_methods.subroutines.optimizers as opt
+
+__all__ = ["GenOpt"]
+
+
+class GenOpt(OptimizerBase):
+    """Generalized ensemble optimization with an adapting mutation distribution.
+
+    EnOpt draws its ensemble from a Gaussian whose covariance is fixed apart from an
+    optional Hessian-driven update. GenOpt draws from the marginals of
+    :class:`~popt.ensembles.ensemble_generalized.GeneralizedEnsemble` -- Beta,
+    logistic, truncated Gaussian -- and moves the distribution itself along with the
+    controls: ``theta`` (the marginal's shape) follows its own gradient, and the
+    correlation matrix follows ``corr_adapt``.
+
+    So each accepted step updates three things rather than one: the controls from
+    ``jac``, ``theta`` from ``jac_mut``, and ``corr`` from ``corr_adapt`` -- which is
+    either a :class:`CMA` instance, called with the ensemble the mutation gradient
+    was built from, or any callable returning a matrix to descend along.
+
+    Examples
+    --------
+    ```python
+    ensemble = GeneralizedEnsemble(options, simulator, objective)
+    cma = CMA(ne=ensemble.num_samples, dim=x0.size, corr_update=True)
+    result = GenOpt.minimize(
+        x0, ensemble.function,
+        jac=ensemble.gradient, jac_mut=ensemble.mutation_gradient,
+        args=(ensemble.get_theta(), ensemble.get_corr()),
+        corr_adapt=cma, bounds=bounds,
+    )
+    ```
+    """
+
+    NAME = "GenOpt"
+    VALID_OPTIMIZERS = ("GD", "Adam")
+
+    def __init__(self, x0, fun, jac=None, jac_mut=None, corr_adapt=None,
+                 args=(), bounds=None, callback=None, **options):
+        """
+        Parameters
+        ----------
+        x0 : ndarray
+            Initial control vector.
+        fun : callable
+            Objective function.
+        jac : callable
+            Ensemble gradient, called as ``jac(x, theta, corr)``.
+        jac_mut : callable
+            Mutation gradient, called as ``jac_mut(x, theta, corr)``. For a
+            :class:`CMA` ``corr_adapt`` it is called with ``return_ensembles=True``
+            and must then also return ``{'gaussian': ..., 'objective': ...}``.
+        corr_adapt : CMA or callable, optional
+            Correlation-matrix adaptation. A :class:`CMA` instance is called with the
+            ensemble; any other callable is called with no arguments and its result
+            is descended along with step size ``alpha_corr``. ``None`` leaves the
+            correlation fixed.
+        args : tuple
+            ``(theta, corr)``: the initial marginal parameter and correlation matrix.
+        bounds : sequence, optional
+            (min, max) per control.
+        callback : callable, optional
+            Invoked after each accepted step.
+        **options
+            GenOpt configuration, plus everything :class:`OptimizerBase` takes.
+
+            - tol: objective improvement required to accept a step (default: 1e-6).
+            - alpha: initial step size for the controls (default: 0.1).
+            - alpha_theta: step size for the marginal parameter (default: 0.1).
+            - alpha_corr: step size for the correlation, for a non-CMA ``corr_adapt`` (default: 0.1).
+            - beta: momentum (default: 0.0).
+            - nesterov: evaluate the gradients at the momentum-extrapolated point (default: False).
+            - alpha_maxiter: backtracking trials per iteration (default: 5).
+            - resample: resampling attempts when backtracking fails (default: 0).
+            - normalize: scale both gradients by their inf-norm (default: True).
+            - cov_factor: shrink factor applied to theta when resampling (default: 0.5).
+            - optimizer: ``GD`` or ``Adam`` (default: ``GD``).
+        """
+        if jac is None:
+            raise ValueError("GenOpt requires a Jacobian (ensemble gradient) callable.")
+        if jac_mut is None:
+            raise ValueError("GenOpt requires a jac_mut (mutation gradient) callable; "
+                             "without it the distribution never adapts and this is EnOpt.")
+        if len(args) < 2:
+            raise ValueError("GenOpt needs args = (theta, corr): the initial marginal "
+                             "parameter and correlation matrix.")
+
+        super().__init__(x0, fun, jac=jac, args=(), bounds=bounds, callback=callback, **options)
+
+        self.jac_mut = jac_mut
+        self.corr_adapt = corr_adapt
+
+        self.obj_func_tol = options.get("tol", 1e-6)
+        self.ftol = options.get("tol", options.get("ftol", self.ftol))
+        self.alpha = options.get("step_size", options.get("alpha", 0.1))
+        self.alpha_theta = options.get("alpha_theta", 0.1)
+        # Upstream read 'alpha_theta' for this too, so `alpha_corr` silently did
+        # nothing and the correlation moved at the theta step size.
+        self.alpha_corr = options.get("alpha_corr", 0.1)
+        self.beta = options.get("beta", 0.0)
+        self.nesterov = options.get("nesterov", False)
+        self.alpha_iter_max = options.get("alpha_maxiter", 5)
+        self.max_resample = options.get("resample", 0)
+        self.normalize = options.get("normalize", True)
+        self.cov_factor = options.get("cov_factor", 0.5)
+
+        self.theta = np.asarray(args[0], dtype=float)
+        self.corr = np.asarray(args[1], dtype=float)
+        self.state_step = np.zeros_like(self.xk, dtype=float)
+        self.theta_step = np.zeros_like(self.theta, dtype=float)
+        self.alpha_iter = 0
+
+        self.optimizer_name = options.get("optimizer", "GD")
+        self.optimizer = self._build_optimizer(self.optimizer_name)
+
+    # ------------------------------------------------------------------
+    # The step
+    # ------------------------------------------------------------------
+
+    def update_step(self) -> StepReport:
+        """One GenOpt step: controls by backtracking, then theta and the correlation."""
+        self.optimizer.restore_parameters()
+        resampling_iter = 0
+        new_func_values = self.fk
+
+        while resampling_iter <= self.max_resample:
+            shrink = self.cov_factor ** resampling_iter
+            self.jk, theta_gradient, ensembles = self._compute_search_quantities(shrink)
+
+            self.alpha_iter = 0
+            while self.alpha_iter <= self.alpha_iter_max:
+                new_state, new_step = self.optimizer.apply_update(
+                    self.xk, self.jk, iter=self.iteration
+                )
+                new_state = self.bound_handler.project_to_bounds(new_state)
+                new_func_values = self.fun(new_state)
+
+                if np.mean(self.fk) - np.mean(new_func_values) > self.obj_func_tol:
+                    self._accept_step(new_state, new_func_values, new_step,
+                                      theta_gradient, ensembles)
+                    return StepReport(True)
+
+                if self.alpha_iter < self.alpha_iter_max:
+                    self.optimizer.apply_backtracking()
+                    self.alpha_iter += 1
+                else:
+                    break
+
+            if (resampling_iter < self.max_resample) and (np.mean(new_func_values) > np.mean(self.fk)):
+                resampling_iter += 1
+                self.optimizer.restore_parameters()
+                continue
+
+            return StepReport(False, "GenOpt failed to find an improving step.")
+
+        return StepReport(False, "GenOpt exhausted all resampling attempts.")
+
+    def _evaluate_missing_derivatives(self):
+        # Both gradients take theta and corr and are evaluated inside the step,
+        # never at the bare iterate. Same reason as EnOpt.
+        pass
+
+    def _compute_search_quantities(self, shrink):
+        theta_step = self.beta * self.theta_step if self.nesterov else 0.0
+        state_step = self.beta * self.state_step if self.nesterov else 0.0
+
+        theta = shrink * (self.theta + theta_step)
+        x_for_grad = self.xk + state_step
+
+        gradient = self.jac(x_for_grad, theta, self.corr, epf=self.epf)
+
+        # CMA needs the Gaussian samples and their objective values. Ask for them
+        # in the same call so the ensemble is drawn -- and simulated -- once.
+        if isinstance(self.corr_adapt, CMA):
+            theta_gradient, ensembles = self.jac_mut(
+                x_for_grad, theta, self.corr, return_ensembles=True
+            )
+        else:
+            theta_gradient, ensembles = self.jac_mut(x_for_grad, theta, self.corr), None
+
+        theta_gradient = np.asarray(theta_gradient, dtype=float)
+        if self.normalize:
+            gradient = gradient / np.maximum(np.linalg.norm(gradient, np.inf), 1e-12)
+            theta_gradient = theta_gradient / np.maximum(
+                np.linalg.norm(theta_gradient, np.inf), 1e-12
+            )
+
+        return gradient, theta_gradient, ensembles
+
+    def _accept_step(self, new_state, new_func_values, new_step, theta_gradient, ensembles):
+        self._commit_step(new_state, new_func_values)
+        self.state_step = new_step
+        if hasattr(self.optimizer, "get_step_size"):
+            self.alpha = self.optimizer.get_step_size()
+
+        # Theta is not backtracked; it follows its own gradient once the controls
+        # have found a step that improves the objective.
+        self.theta_step = self.beta * self.theta_step - self.alpha_theta * theta_gradient
+        self.theta = self.theta + self.theta_step
+
+        self._adapt_correlation(new_step, ensembles)
+
+        if self.xk.size == 1 and hasattr(self.optimizer, "step_size"):
+            self.optimizer.step_size /= 2
+
+        self.optimizer.restore_parameters()
+
+    def _adapt_correlation(self, new_step, ensembles):
+        if isinstance(self.corr_adapt, CMA):
+            # `step / alpha` is the unit-length direction the evolution path wants;
+            # alpha can be zero if the step rule collapsed, so guard the division.
+            alpha = self.alpha if self.alpha else 1.0
+            self.corr = self.corr_adapt(
+                cov=self.corr,
+                step=new_step / alpha,
+                X=ensembles["gaussian"],
+                J=ensembles["objective"],
+            )
+        elif callable(self.corr_adapt):
+            self.corr = self.corr - self.alpha_corr * self.corr_adapt()
+
+    # ------------------------------------------------------------------
+    # Base-class hooks
+    # ------------------------------------------------------------------
+
+    def _build_optimizer(self, optimizer_name):
+        if optimizer_name not in self.VALID_OPTIMIZERS:
+            raise ValueError(
+                f"Optimizer '{optimizer_name}' not recognized for GenOpt. "
+                f"Valid options are: {self.VALID_OPTIMIZERS}."
+            )
+        if optimizer_name == "GD":
+            return opt.GradientDescent(self.alpha, self.beta)
+        return opt.Adam(self.alpha, self.beta)
+
+    def _get_restart_state(self) -> dict:
+        return {
+            "theta": self.theta,
+            "corr": self.corr,
+            "state_step": self.state_step,
+            "theta_step": self.theta_step,
+            "alpha": self.alpha,
+            "alpha_iter": self.alpha_iter,
+            "obj_func_tol": self.obj_func_tol,
+            "optimizer_name": self.optimizer_name,
+            "optimizer_state": dict(self.optimizer.__dict__),
+        }
+
+    def _set_restart_state(self, state: dict) -> None:
+        self.theta = state.get("theta", self.theta)
+        self.corr = state.get("corr", self.corr)
+        self.state_step = state.get("state_step", self.state_step)
+        self.theta_step = state.get("theta_step", self.theta_step)
+        self.alpha = state.get("alpha", self.alpha)
+        self.alpha_iter = state.get("alpha_iter", self.alpha_iter)
+        self.obj_func_tol = state.get("obj_func_tol", self.obj_func_tol)
+
+        self.optimizer_name = state.get("optimizer_name", self.optimizer_name)
+        self.optimizer = self._build_optimizer(self.optimizer_name)
+        self.optimizer.__dict__.update(state.get("optimizer_state", {}))
+
+    def log_columns(self) -> dict:
+        """Iteration, backtracking attempts, objective, step size, and the correlation's spread."""
+        off_diagonal = self.corr - np.eye(self.corr.shape[0])
+        return {
+            "iter.": self.iteration,
+            "alpha_iter": self.alpha_iter,
+            "obj_func": float(np.mean(self.fk)),
+            "step-size": self.alpha,
+            "max corr": float(np.max(off_diagonal)),
+            "min corr": float(np.min(self.corr)),
+        }
diff --git a/src/popt/optimization_methods/linesearch.py b/src/popt/optimization_methods/linesearch.py
new file mode 100644
index 00000000..515de28d
--- /dev/null
+++ b/src/popt/optimization_methods/linesearch.py
@@ -0,0 +1,252 @@
+"""Line-search-based deterministic optimization methods.
+
+This module implements gradient-based algorithms that share a common line
+search interface, including gradient descent, BFGS, and Newton-CG.
+"""
+
+import numpy as np
+
+# Internal imports
+from popt.optimization_methods.subroutines import line_search, line_search_backtracking, bfgs_update, newton_cg
+from popt.optimization_methods.optimizer_base import OptimizerBase, StepReport
+
+__author__ = "Mathias Methlie Nilsen"
+__all__ = ["LineSearch"]
+
+# -----------------------------------------
+# Some symbols for logger
+# -----------------------------------------
+subk = 'ₖ'
+sup2 = '²'
+jac_inf_symbol = f'‖jac(x{subk})‖∞'
+fun_xk_symbol  = f'fun(x{subk})'
+nabla_symbol = "∇"
+
+
+class LineSearch(OptimizerBase):
+    """Line-search optimizer compatible with OptimizerBase.
+
+    The class supports gradient descent, BFGS, and Newton-CG search
+    directions, together with either Wolfe or backtracking line search.
+    It can operate with bounds, optional state transformations, logging,
+    result persistence, and restart checkpoints.
+    """
+
+    VALID_METHODS = ("GD", "BFGS", "Newton-CG")
+    LS_METHODS = {
+        0: line_search_backtracking, # Backtracking line search
+        1: line_search,              # Wolfe line search
+    }
+
+
+    def __init__(self, x0, fun, method='GD', jac=None, hess=None, args=(), bounds=None, callback=None, **options):
+        """Initialize a line-search optimizer instance.
+
+        Parameters
+        ----------
+        x0 : ndarray
+            Initial parameter vector.
+        fun : callable
+            Objective function.
+        method : {'GD', 'BFGS', 'Newton-CG'}, optional
+            Search-direction method.
+        jac : callable
+            Gradient function.
+        hess : callable, optional
+            Hessian function, required by ``Newton-CG``.
+        args : tuple, optional
+            Extra positional arguments passed to the wrapped callables.
+        bounds : sequence, optional
+            Lower and upper bounds for each state variable.
+        callback : callable, optional
+            Callback invoked after successful updates.
+        **options
+            Line-search configuration, plus everything :class:`OptimizerBase` takes.
+            - step_size: Initial step size (default: None, auto-scaled).
+            - step_size_max: Maximum step size (default: 1e5).
+            - step_size_adapt: Step size adaptation strategy (0: none, 1: function-based, 2: gradient-based). Default is 1 (function-based).
+            - c1: Armijo condition constant (default: 1e-4).
+            - c2: Curvature condition constant (default: 0.9).
+            - rho: Step size reduction factor for backtracking (default: 0.5).
+            - lsmaxiter: Maximum line search iterations (default: 10).
+            - lsmethod: Line search method (0: backtracking, 1: Wolfe, default: 1).
+            - normalize: Whether to normalize the search direction (default: False).
+            - recompute_jac: Number of gradient recomputation attempts on line search failure (default: 0).
+            - hess0_inv: Initial inverse-Hessian approximation for BFGS (default: identity).
+        """
+
+        if jac is None:
+            raise ValueError("LineSearch requires a Jacobian (gradient) function for the specified methods.")
+
+        # Initialize the base class
+        super().__init__(x0, fun, jac, hess, args, bounds, callback, **options)
+
+        # Validate method and required callables
+        if method not in self.VALID_METHODS:
+            raise ValueError(f"Invalid method '{method}'. Valid options are: {self.VALID_METHODS}")
+        if method == "Newton-CG" and hess is None:
+            raise ValueError(f"Method '{method}' requires a Hessian function.")
+
+        # Line search specific attributes
+        self.method = method
+        self.NAME = f"Line Search ({method})"  # the banner names the search direction
+
+        # Set options for step-size
+        self.step_size       = options.get('step_size', None)
+        self.step_size_max   = options.get('step_size_max', 1e5)
+        self.step_size_adapt = options.get('step_size_adapt', 1)
+        self.step_taken      = None  # the step length of the last accepted step
+
+        # Line search specific options
+        self.line_search_options = {
+            'c1': options.get('c1', 1e-4),              # Armijo condition constant
+            'c2': options.get('c2', 0.9),               # Curvature condition constant
+            'rho': options.get('rho', 0.5),             # Step size reduction factor for backtracking
+            'amax': self.step_size_max,                 # Max step size for line search
+            'maxiter': options.get('lsmaxiter', 10),    # Max line search iterations (the subroutines read 'maxiter')
+            'logger': self.logger,                      # Logger instance
+
+        }
+        try:
+            lsmethod = options.get('lsmethod', 1)
+            self.line_search_fn = self.LS_METHODS[lsmethod]
+        except KeyError:
+            raise ValueError(f"Invalid line search method: {lsmethod}")
+
+        # Other options
+        self.recompute_jac = options.get('recompute_jac', 0)
+        self.normalize = options.get('normalize', False)
+        self.jk_old = None
+        self.pk_old = None
+
+        if self.method == 'BFGS':
+            self.bk = options.get('hess0_inv', np.eye(self.xk.size))  # BFGS approximation of the inverse Hessian
+
+    def update_step(self) -> StepReport:
+        """
+        Perform one optimization step.
+
+        The method computes a search direction, performs a line search, and
+        commits the new iterate on success. When enabled, it can recompute the
+        gradient and retry if the line search fails.
+        """
+        iter_jac_recompute = 0  # Reset recompute counter for this step
+
+        # Perform line-search step (with optional recompute loop)
+        while iter_jac_recompute <= self.recompute_jac:
+            # Gradient and Hessian at the current iterate, if not already on hand
+            # (the Hessian is invalidated after every accepted step, the
+            # gradient when a retry asks for a fresh one).
+            self._evaluate_missing_derivatives()
+            pk = self._compute_search_direction()
+            step_size, fk_new, jk_new = self._run_line_search(pk)
+
+            # SUCCESS --> accept step and return
+            if step_size:
+                self._accept_step(pk, step_size, fk_new, jk_new)
+                return StepReport(True)
+
+            # FAILURE --> recompute or exit
+            if iter_jac_recompute < self.recompute_jac:
+                if self.logger:
+                    self.logger('Recomputing gradient and retrying line search...')
+                self.jk = None
+                iter_jac_recompute += 1
+            else:
+                return StepReport(False, 'Line search failed to find a suitable step size')
+
+    def _run_line_search(self, pk) -> tuple[float, float, np.ndarray]:
+        """Run the line search algorithm to find an acceptable step size."""
+        step_size = self._set_step_size(pk, self.step_size_max)
+        step_size, fk_new, jk_new, _, _ = self.line_search_fn(
+            step_size=step_size,
+            xk=self.xk,
+            pk=pk,
+            fun=lambda x, *a, **kw: np.mean(self.fun(x, *a, **kw)),
+            jac=self.jac,
+            fk=np.mean(self.fk),
+            jk=self.jk,
+            **self.line_search_options
+        )
+
+        return step_size, fk_new, jk_new
+
+    def _accept_step(self, pk, step_size, fk_new, jk_new) -> None:
+        """Make the line-search point current and update what the next direction needs."""
+        self.jk_old = self.jk
+        self.pk_old = pk
+        self.step_taken = step_size
+
+        self._commit_step(self.bound_handler.project_to_bounds(self.xk + step_size * pk), fk_new, jac=jk_new)
+
+        if self.method == 'BFGS':
+            sk = self.xk - self.xk_old
+            yk = self.jk - self.jk_old
+            if self.iteration == 1:
+                self.bk = np.dot(yk,sk)/np.dot(yk,yk) * np.eye(sk.size)
+            self.bk = bfgs_update(self.bk, sk, yk)
+
+        # The Hessian on hand belongs to the previous iterate; it is
+        # recomputed at the next step if the method needs one.
+        self.hk = None
+
+    def _get_restart_state(self) -> dict:
+        state = {
+            'step_size': self.step_size,
+            'jk_old': self.jk_old,
+            'pk_old': self.pk_old,
+        }
+        if self.method == 'BFGS':
+            state['bk'] = self.bk
+        return state
+
+    def _set_restart_state(self, state: dict) -> None:
+        self.step_size = state.get('step_size', self.step_size)
+        self.jk_old = state.get('jk_old', self.jk_old)
+        self.pk_old = state.get('pk_old', self.pk_old)
+        if self.method == 'BFGS' and 'bk' in state:
+            self.bk = state['bk']
+
+
+    def _compute_search_direction(self) -> np.ndarray:
+        if self.method == 'GD':
+            return -self.jk
+        elif self.method == 'BFGS':
+            return - np.matmul(self.bk, self.jk)
+        elif self.method == 'Newton-CG':
+            return newton_cg(self.jk, self.hk)
+        else:
+            raise ValueError(f"Unsupported method: {self.method}")
+
+
+    def _set_step_size(self, pk, amax) -> float:
+        if self.step_size is None:
+            self.step_size = 0.25 / np.linalg.norm(pk, np.inf)
+
+        alpha = float(np.asarray(self.step_size).reshape(-1)[0])
+
+        if self.iteration > 1:
+            slope = np.dot(pk, self.jk)
+            if self.step_size_adapt == 1 and slope != 0:
+                fk = float(np.asarray(np.mean(self.fk)).reshape(-1)[0])
+                fk_old = float(np.asarray(np.mean(self.fk_old)).reshape(-1)[0])
+                alpha = 2 * (fk - fk_old) / slope
+            elif self.step_size_adapt == 2 and slope != 0:
+                slope_old = np.dot(self.pk_old, self.jk_old)
+                alpha = self.step_size * slope_old / slope
+
+        alpha = float(abs(alpha))
+
+        if alpha >= amax:
+            alpha = 0.75 * amax
+
+        return alpha
+
+    def log_columns(self) -> dict:
+        """The row of the iteration log: iteration, objective, gradient infinity norm, step length taken."""
+        return {
+            'iter.': self.iteration,
+            fun_xk_symbol: self.fk,
+            jac_inf_symbol: np.linalg.norm(self.jk, np.inf),
+            'step-size': self.step_taken if self.step_taken is not None else self.step_size,
+        }
diff --git a/src/popt/optimization_methods/optimizer_base.py b/src/popt/optimization_methods/optimizer_base.py
new file mode 100644
index 00000000..3fff66b3
--- /dev/null
+++ b/src/popt/optimization_methods/optimizer_base.py
@@ -0,0 +1,769 @@
+'''Shared OptimizerBase for iterative optimization algorithms.'''
+import inspect
+import pprint
+from dataclasses import dataclass
+
+import numpy as np
+from scipy.optimize import OptimizeResult
+from abc import ABC, abstractmethod
+from functools import wraps
+
+# Internal imports
+import popt.misc_tools.optim_tools as ot
+from ensemble.checkpoint import RestartMixin
+from ensemble.logger import PetLogger
+
+__author__ = "Mathias Methlie Nilsen, Rolf J. Lorentzen"
+__all__ = [
+    'OptimizerBase',
+    'StepReport',
+    'BoundTransformHandler',
+    'OptimizerRestartMixin'
+]
+
+
+def _accepts_arguments(func, x, args, kwargs) -> bool:
+    """Whether ``func`` can be called as ``func(x, *args, **kwargs)``.
+
+    Answered from the signature, without calling. The optimizers support two
+    kinds of objective -- a rich one taking the covariance and extras, and a
+    plain one taking only the control vector -- and this is what tells them
+    apart.
+
+    Deciding it by calling and catching ``TypeError`` cannot: an objective that
+    runs an ensemble of simulations and then raises ``TypeError`` internally is
+    indistinguishable from one that rejected the arguments, so the error is
+    swallowed and the entire evaluation repeated. The repeat then trips over
+    the simulator scratch folders the first attempt created and reports
+    ``FileExistsError``, with the real error nowhere to be seen.
+
+    A callable whose signature cannot be inspected -- some builtins and C
+    extensions -- is assumed to accept them, so the full call is attempted and
+    any error propagates rather than being hidden.
+    """
+    try:
+        signature = inspect.signature(func)
+    except (TypeError, ValueError):
+        return True
+    try:
+        signature.bind(x, *args, **kwargs)
+    except TypeError:
+        return False
+    return True
+
+
+def _describe_signature(func) -> str:
+    """``func``'s signature for an error message, or '' if unavailable."""
+    try:
+        return str(inspect.signature(func))
+    except (TypeError, ValueError):
+        return ""
+
+
+@dataclass(frozen=True)
+class StepReport:
+    """What one call to :meth:`OptimizerBase.update_step` produced.
+
+    ``accepted`` says the optimizer committed a new iterate (through
+    :meth:`OptimizerBase._commit_step`); the loop then does the bookkeeping
+    every optimizer used to repeat. ``message`` is why it stopped when it did
+    not, and becomes the result's ``message``.
+    """
+
+    accepted: bool
+    message: str = ""
+
+
+class OptimizerRestartMixin(RestartMixin):
+    """Checkpoint/restart behaviour for optimizers.
+
+    The implementation is shared with PIPT via
+    :class:`ensemble.checkpoint.RestartMixin`; this subclass exists so the
+    optimizer-facing name stays stable.
+    """
+
+
+class BoundTransformHandler:
+    """
+    Transform states between the original parameter domain and the unit cube.
+
+    Notes
+    -----
+    All bounds must be finite whenever bounds are supplied.
+    """
+
+    def __init__(self, bounds=None, transform=False):
+        '''
+        Initialize the BoundTransformHandler.
+
+        Parameters
+        ----------
+        bounds : sequence of (lower, upper) pairs, optional
+            Lower and upper bounds for each state variable.
+        transform : bool, optional
+            If True, transform the optimization problem to the unit cube [0, 1]^n.
+        '''
+        self.transform = transform
+
+        # ------------------------------------------------------------------
+        # Bounds
+        # ------------------------------------------------------------------
+        if bounds is None:
+            self.bounds = None
+            self.lb = None
+            self.ub = None
+            return
+
+        self.bounds = bounds
+        self.lb, self.ub = np.asarray(bounds, dtype=float).T
+        self.db = self.ub - self.lb
+        self._validate_bounds()
+
+    # ----------------------------------------------------------------------
+    # Validation helpers
+    # ----------------------------------------------------------------------
+
+    def _validate_bounds(self):
+        """Validate lower and upper bounds."""
+        if not np.all(np.isfinite(self.lb)):
+            raise ValueError("All lower bounds must be finite.")
+        if not np.all(np.isfinite(self.ub)):
+            raise ValueError("All upper bounds must be finite.")
+        if np.any(self.ub <= self.lb):
+            raise ValueError(
+                "Every upper bound must be strictly greater "
+                "than its lower bound."
+            )
+
+    def _validate_state(self, x):
+        """Validate a state vector in the original parameter space."""
+        if x.shape != self.lb.shape:
+            raise ValueError(
+                f"Expected shape {self.lb.shape}, got {x.shape}."
+            )
+        if np.any(np.isnan(x)):
+            raise ValueError("State vector contains NaN values.")
+        if np.any(x < self.lb) or np.any(x > self.ub):
+            raise ValueError(
+                "State vector is outside the specified bounds."
+            )
+
+    def _validate_unit_cube(self, u):
+        """Validate a vector in unit-cube coordinates."""
+        if u.shape != self.lb.shape:
+            raise ValueError(
+                f"Expected shape {self.lb.shape}, got {u.shape}."
+            )
+        if np.any(np.isnan(u)):
+            raise ValueError(
+                "Unit-cube vector contains NaN values."
+            )
+        if np.any(u < 0.0) or np.any(u > 1.0):
+            raise ValueError(
+                "Unit-cube coordinates must lie in [0, 1]."
+            )
+
+    # ----------------------------------------------------------------------
+    # Coordinate transforms
+    # ----------------------------------------------------------------------
+
+    def state_to_unit_cube(self, x):
+        """Transform original coordinates to unit-cube coordinates."""
+        if (not self.transform) or (self.bounds is None):
+            return x
+        x = np.asarray(x, dtype=float)
+        self._validate_state(x)
+        return (x - self.lb) / self.db
+
+    def unit_cube_to_state(self, u):
+        """Transform unit-cube coordinates to original coordinates."""
+        if (not self.transform) or (self.bounds is None):
+            return u
+        u = np.asarray(u, dtype=float)
+        self._validate_unit_cube(u)
+        return self.lb + u * self.db
+
+    # ----------------------------------------------------------------------
+    # Feasibility operations
+    # ----------------------------------------------------------------------
+
+    def project_to_bounds(self, x):
+        """Project a vector onto the feasible domain."""
+        x = np.asarray(x, dtype=float)
+        if self.bounds is None:
+            return x
+        if self.transform:
+            return np.clip(x, 0.0, 1.0)
+        return np.clip(x, self.lb, self.ub)
+
+    def project_gradient(self, x, g, tol=1e-8):
+        """Project a gradient to respect active bound constraints."""
+        if self.bounds is None:
+            return g
+
+        g_proj = g.copy()
+
+        if self.transform:
+            lower_bound = tol
+            upper_bound = 1.0 - tol
+        else:
+            lower_bound = self.lb + tol
+            upper_bound = self.ub - tol
+
+        at_lower = x <= lower_bound
+        at_upper = x >= upper_bound
+
+        g_proj[at_lower] = np.minimum(g_proj[at_lower], 0.0)
+        g_proj[at_upper] = np.maximum(g_proj[at_upper], 0.0)
+
+        return g_proj
+
+    # ----------------------------------------------------------------------
+    # Derivative transforms
+    # ----------------------------------------------------------------------
+    def jac_to_unit_cube(self, jac):
+        """Transform a gradient to unit-cube coordinates."""
+        if (not self.transform) or (self.bounds is None):
+            return jac
+        return jac * self.db
+
+    def jac_from_unit_cube(self, jac):
+        """Transform a gradient from unit-cube coordinates."""
+        if (not self.transform) or (self.bounds is None):
+            return jac
+        if jac is None:
+            return None
+        return jac / self.db
+
+    def hess_to_unit_cube(self, hess):
+        """Transform a Hessian to unit-cube coordinates."""
+        if (not self.transform) or (self.bounds is None):
+            return hess
+        if hess is None:
+            return None
+        return hess * np.outer(self.db, self.db)
+
+    def hess_from_unit_cube(self, hess):
+        """Transform a Hessian from unit-cube coordinates."""
+        if (not self.transform) or (self.bounds is None):
+            return hess
+        if hess is None:
+            return None
+        return hess / np.outer(self.db, self.db)
+
+
+
+class OptimizerBase(OptimizerRestartMixin, ABC):
+    """The iteration every optimizer shares; a subclass supplies the step.
+
+    A subclass implements :meth:`update_step`, committing an improving point
+    with :meth:`_commit_step` and returning a :class:`StepReport`, and names
+    what its log row shows in :meth:`log_columns`. Everything else -- the
+    starting evaluation, the callback, recording and saving the result, the
+    log row, the function, state and projected-gradient convergence checks,
+    restart checkpoints and the EPF outer loop -- happens here.
+    """
+
+    NAME = "Optimizer"
+    """Shown in the start-of-run banner."""
+
+    def __init__(self, x0, fun, jac=None, hess=None, args=(), bounds=None, callback=None, **options):
+        """
+        Parameters
+        ----------
+        x0 : ndarray
+            Initial parameter vector.
+        fun : callable
+            Objective function.
+        jac : callable, optional
+            Gradient function.
+        hess : callable, optional
+            Hessian function.
+        args : tuple, optional
+            Extra positional arguments passed to callables: `fun`, `jac`, `hess`.
+        bounds : sequence, optional
+            Lower and upper bounds for each state variable.
+        callback : callable, optional
+            Called with the optimizer after every accepted step.
+        **options
+            Optimizer configuration such as tolerances, logging, restart, and
+            persistence options.
+            - maxiter: Maximum number of iterations (default: 100)
+            - ftol: Relative function tolerance for convergence (default: 1e-5)
+            - xtol: Relative change in state for convergence (default: 1e-8)
+            - gtol: Projected-gradient infinity-norm tolerance for convergence (default: 1e-5)
+            - fun0, jac0, hess0: Initial objective, gradient and Hessian values to reuse instead of evaluating them
+            - logit: Enable logging (default: True)
+            - logger_name: Log file name (default: 'OPTIM.log')
+            - restart: Enable restart from file (default: False)
+            - restartsave: Save restart file after each iteration (default: False)
+            - restart_file: Path for restart file (default: '{optimizer_name}_restart.pkl')
+            - epf: Dictionary of EPF options (default: None)
+                - r: Initial penalty factor
+                - r_factor: Penalty factor update multiplier (default: 2)
+                - tol_factor: Function tolerance update multiplier (default: 0.9)
+                - conv_crit: EPF convergence criterion, compared against the mean
+                  penalty with the penalty factor divided out (default: 1e-5). The
+                  objective must write `penalty` into the epf dict it is handed.
+            - transform: Enable [lb, ub] --> [0, 1] transformation for optimization (default: False)
+            - saveit: Save intermediate results after each iteration (default: False)
+            - savefolder (or save_folder): Folder for those results (default: 'Iteration_Results')
+        """
+        # Store user configuration first.
+        self.options = options
+        self.args = args
+        self.callback = callback if callable(callback) else None
+
+        # Bounds and optional unit-cube transform.
+        self.transform = options.get('transform', False)
+        self.bound_handler = BoundTransformHandler(bounds, transform=self.transform)
+        self.xk = self.bound_handler.state_to_unit_cube(x0) if self.transform else x0
+
+        # Wrapped objective-related callables with evaluation counters.
+        self.fun  = self._wrap_callable(fun, "fun")
+        self.jac  = self._wrap_callable(jac, "jac", self.bound_handler.jac_to_unit_cube)
+        self.hess = self._wrap_callable(hess, "hess", self.bound_handler.hess_to_unit_cube)
+
+        # Core iteration controls.
+        self.iteration = 0
+        self.maxiter = options.get('maxiter', 100)
+
+        # Restart/checkpoint controls.
+        self.restart = options.get('restart', False)
+        self.restartsave = options.get('restartsave', False)
+        self.restart_file = options.get(
+            'restart_file',
+            options.get('restartfile', f'{type(self).__name__.lower()}_restart.pkl')
+        )
+        self._restart_loaded = False
+
+        # EPF controls.
+        self.epf = options.get('epf', {})
+        self.epf_maxiter = self.epf.get('max_epf_iter', 10) if self.epf else 1
+        self.epf_iteration = 0
+
+        # Convergence tolerances.
+        self.ftol = options.get('ftol', 1e-5)  # Relative function tolerance
+        self.xtol = options.get('xtol', 1e-8)  # Relative state-change tolerance
+        self.gtol = options.get('gtol', 1e-5)  # Projected-gradient infinity norm
+
+        # Iteration state. Initial values may be handed in; whatever is
+        # missing is evaluated when the run starts (see `_start`).
+        self.fk = options.get('fun0', None)
+        self.jk = options.get('jac0', None)
+        self.hk = options.get('hess0', None)
+        self.fk_old = None
+        self.xk_old = None
+        self._started = False
+
+        # Logging.
+        self.logger = None
+        if options.get('logit', True):
+            self.logger = PetLogger(options.get('logger_name', 'OPTIM.log'))
+
+        # Result container and persistence.
+        self.conv_msg = ''
+        self.optimize_results = OptimizeResult()
+        self.saveit = options.get('saveit', False)
+        self.savefolder = options.get('savefolder', options.get('save_folder', 'Iteration_Results'))
+
+    @classmethod
+    def minimize(cls, x0, fun, *args, **kwargs) -> OptimizeResult:
+        """Construct the optimizer with these arguments, run it, and return its result.
+
+        The arguments are the constructor's, in the constructor's order; see
+        the class for what each optimizer takes.
+        """
+        optimizer = cls(x0, fun, *args, **kwargs)
+        optimizer.run_optimization()
+        return optimizer.optimize_results
+
+    @abstractmethod
+    def update_step(self) -> StepReport:
+        """Take one step from the current iterate.
+
+        Find a better point and make it current with :meth:`_commit_step`,
+        which also keeps the previous iterate for the convergence checks; then
+        return ``StepReport(True)``. The loop runs the callback, records and
+        saves the result, logs a row and checks convergence -- none of that
+        is the step's job. Return ``StepReport(False, why)`` when no
+        acceptable step exists: the run stops and ``why`` is its message.
+        """
+
+    def run_optimization(self):
+        """Run this optimizer to completion.
+
+        Named for the job rather than the mechanism; the counterpart in pipt is
+        ``AssimilationScheme.run_assimilation``.
+
+        The loop handles restart restoration, the starting evaluation, optional
+        EPF outer iterations, repeated calls to ``update_step()``, and the
+        shared convergence checks. When enabled, restart files are updated
+        after successful iterations and after EPF penalty updates.
+        """
+
+        if self.restart and not self._restart_loaded:
+            self.load_restart()
+        elif not self.restart:
+            self.clear_restart()
+
+        if not (self._restart_loaded or self._started):
+            self._start()
+
+        if self.epf_iteration == 0:
+            self.epf_iteration = 1
+
+        # EPF outer loop
+        while self.epf_iteration <= self.epf_maxiter:
+
+            self._refresh_epf_function_value()
+
+            # Main optimization loop
+            update_step_failed = False
+            optimization_converged = False
+            while self.iteration < self.maxiter:
+                self.iteration += 1
+
+                report = self.update_step()
+                if not report.accepted:
+                    self.conv_msg = report.message
+                    update_step_failed = True
+                    break
+
+                # The step is committed; this is the bookkeeping that follows every accepted step.
+                if self.callback is not None:
+                    self.callback(self)
+                self._record_results()
+                self._log_iteration()
+
+                # Check function tolerance convergence
+                if self.check_function_convergence():
+                    optimization_converged = True
+                # Check state tolerance convergence
+                elif self.check_state_convergence():
+                    optimization_converged = True
+                # Check subclass-specific convergence criteria (if any)
+                elif self.check_convergence():
+                    optimization_converged = True
+
+                # Save restart file if enabled
+                if self.restartsave:
+                    self.save_restart()
+
+                if optimization_converged:
+                    break
+
+            if (self.iteration == self.maxiter) and (not optimization_converged):
+                self.conv_msg = 'Maximum number of iterations reached'
+
+            if update_step_failed or (not self.epf):
+                # If the update step failed or EPF is not enabled, we exit the loop.
+                break
+
+            # Check if EPF convergence is met
+            if self.check_epf_convergence():
+                break
+
+            # Update iteration counters
+            self.iteration = 0
+            self.epf_iteration += 1
+
+            if self.restartsave:
+                self.save_restart()
+
+        # Set convergence message
+        self.optimize_results['message'] = self.conv_msg
+
+        # Log convergence message
+        self._log_convergence()
+
+    # ==========================================
+    # What the loop does around a step
+    # ==========================================
+    def _start(self):
+        """Evaluate what the first step needs and record the starting point."""
+        self._started = True
+        if self.logger:
+            self.logger(f'========== Starting {self.NAME} Minimization ==========')
+            if self.options:
+                self.logger(f'\n\nUSER-SPECIFIED OPTIONS:\n{pprint.pformat(OptimizeResult(self.options))}\n')
+
+        if self.fk is None:
+            if self.logger:
+                self.logger('Computing initial function value...')
+            self.fk = self._objective_value(self.xk)
+        self._evaluate_missing_derivatives()
+
+        self._log_iteration()
+        self._record_results()
+
+    def _objective_value(self, x):
+        """The objective at ``x`` as this optimizer keeps it (``fun``'s value as returned, by default)."""
+        return self.fun(x)
+
+    def _evaluate_missing_derivatives(self):
+        """Evaluate the gradient and Hessian at the current iterate when the optimizer has none.
+
+        Used at the start and by optimizers that invalidate them between
+        steps. One that computes its derivatives differently (EnOpt's
+        ensemble gradient needs the covariance) overrides this.
+        """
+        if self.jk is None and self.jac is not None:
+            self.jk = self.jac(self.xk)
+        if self.hk is None and self.hess is not None:
+            self.hk = self.hess(self.xk)
+
+    def _commit_step(self, x_new, f_new, jac=None, hess=None):
+        """Make ``x_new`` the current iterate; the one it replaces becomes ``xk_old``/``fk_old``.
+
+        The convergence checks compare the two, so a step that skipped either
+        assignment used to iterate and log normally while never converging.
+        Pass ``jac``/``hess`` when the step evaluated them at the new point.
+        """
+        self.xk_old = self.xk
+        self.fk_old = self.fk
+        self.xk = x_new
+        self.fk = f_new
+        if jac is not None:
+            self.jk = jac
+        if hess is not None:
+            self.hk = hess
+
+    def _record_results(self):
+        """Refresh the result object and, if asked, save it."""
+        self.optimize_results = self._update_optimize_result()
+        if self.saveit:
+            ot.save_optimize_results(self.optimize_results, folder=self.savefolder)
+
+    def log_columns(self) -> dict:
+        """One row of the iteration log. Optimizers override to show their own quantities."""
+        return {'iter.': self.iteration, 'fun': float(np.mean(self.fk))}
+
+    def _log_iteration(self):
+        if self.logger:
+            columns = self.log_columns()
+            if self.epf:
+                columns['EPF iter.'] = self.epf_iteration
+            self.logger(**columns)
+
+    # ==========================================
+    # Convergence
+    # ==========================================
+    def check_convergence(self) -> bool:
+        """Optimizer-specific criteria; by default the projected gradient against ``gtol``.
+
+        Runs after the function and state checks. An optimizer with more
+        criteria extends this; one without a gradient gets ``False``.
+        """
+        if self.jk is None:
+            return False
+        proj_jac = self.bound_handler.project_gradient(self.xk, self.jk)
+        if np.linalg.norm(proj_jac, np.inf) < self.gtol:
+            self.conv_msg = f'Projected gradient norm ‖g‖∞ < {self.gtol}.'
+            return True
+        return False
+
+    def check_function_convergence(self) -> bool:
+        """Check convergence based on relative change in objective value."""
+        if self.fk_old is not None:
+            df = np.mean(self.fk) - np.mean(self.fk_old)
+            if abs(df) < self.ftol*np.abs(np.mean(self.fk_old)):
+                self.conv_msg = f'Function change satisfies |Δf| < {self.ftol}·|f_prev|'
+                return True
+        return False
+
+    def check_state_convergence(self) -> bool:
+        """Check convergence based on the norm of the state update."""
+        if self.xk_old is not None:
+            dx = np.linalg.norm(self.xk - self.xk_old)
+            if dx < self.xtol:
+                self.conv_msg = f'State change norm ‖Δx‖₂ < {self.xtol}'
+                return True
+        return False
+
+    def check_epf_convergence(self):
+        """Evaluate convergence of the outer EPF iteration.
+
+        The loop stops once the constraints are satisfied, measured as the mean of
+        ``self.epf['penalty']`` with the penalty factor ``r`` divided back out. The
+        objective is responsible for writing ``penalty`` into the ``epf`` dict it is
+        handed; without it there is nothing to converge on and this raises.
+
+        Returns
+        -------
+        bool
+            ``True`` when the EPF loop should terminate, otherwise ``False``.
+        """
+        if self.epf_iteration == self.epf_maxiter:
+            if self.logger:
+                self.logger('─────> Maximum number of outer EPF iterations reached')
+            return True
+
+        # Mean penalty magnitude with the penalty factor divided back out, so the test
+        # asks whether the constraints are still violated rather than whether the
+        # controls happened to move. The objective writes `penalty` into the epf dict it
+        # is handed; `cost_functions.epf.epf` returns r * 0.5 * (...), so dividing by r
+        # leaves the violation itself.
+        if 'penalty' not in self.epf:
+            raise KeyError(
+                "EPF convergence needs self.epf['penalty']; the objective must write it "
+                "into the epf dict it is passed."
+            )
+        penalty = np.asarray(self.epf['penalty'])
+        if penalty.size == 0:
+            raise ValueError('EPF penalty is empty; cannot compute the convergence criterion.')
+        mean_penalty = np.mean(penalty) / self.epf['r']
+        conv_crit = self.epf.get('conv_crit', 1e-5)
+        if mean_penalty > conv_crit:
+
+            # Update penalty factor
+            rold = self.epf['r']
+            rnew = rold * self.epf.get('r_factor', 2)
+            self.epf['r'] = rnew
+            if self.logger:
+                self.logger(f'EPF penalty factor updated: {rold} ─────> {rnew}')
+
+            # Update function tolerance
+            ftol_old = self.ftol
+            ftol_new = ftol_old * self.epf.get('tol_factor', 0.9)
+            self.ftol = ftol_new
+            if self.logger:
+                self.logger(f'Function tolerance updated: {ftol_old} ─────> {ftol_new}')
+
+            return False
+        else:
+            if self.logger:
+                self.logger(f'Outer EPF loop converged ─────> penalty term smaller than {conv_crit}')
+            return True
+
+    # ==========================================
+    # Internal utility functions
+    # ==========================================
+    def _update_optimize_result(self):
+        xk = self.bound_handler.project_to_bounds(self.xk)
+        xk = self.bound_handler.unit_cube_to_state(xk)
+        result = OptimizeResult({
+            'x': xk,
+            'fun': self.fk,
+            'jac': self.bound_handler.jac_from_unit_cube(self.jk),
+            'hess': self.bound_handler.hess_from_unit_cube(self.hk),
+            'nit': self.iteration,
+            'nfev': self.fun.nfev,
+            'njev': self.jac.nfev if self.jac else 0,
+            'nhev': self.hess.nfev if self.hess else 0,
+        })
+        return result
+
+    def _refresh_epf_function_value(self):
+        if self.epf_iteration <= 1 or self.iteration != 0:
+            return
+
+        self.fk = self.fun(self.xk)
+        self._record_results()
+
+    def _wrap_callable(self, func, name, transform_result=None):
+        if func is None:
+            return None
+
+        if not callable(func):
+            raise ValueError(f"The {name} must be callable.")
+
+        @wraps(func)
+        def wrapper(x, *args, **kwargs):
+            wrapper.nfev += 1
+
+            x = self.bound_handler.project_to_bounds(x)
+            x = self.bound_handler.unit_cube_to_state(x)
+
+            # check if args empty, if so, don't pass them to func
+            if not args:
+                args = self.args
+            kwargs["epf"] = self.epf
+
+            # A plain objective may accept only `x`. Decide that from the
+            # signature rather than by calling and catching TypeError: the
+            # objective runs a full ensemble of simulations, and a TypeError
+            # raised *inside* it would otherwise be swallowed and the whole
+            # evaluation silently repeated. The repeat then failed on the
+            # scratch folders the first attempt had already created, reporting
+            # FileExistsError and hiding the real error completely.
+            if _accepts_arguments(func, x, args, kwargs):
+                result = func(x, *args, **kwargs)
+            elif _accepts_arguments(func, x, (), {}):
+                result = func(x)
+            else:
+                raise TypeError(
+                    f"The {name} {getattr(func, '__name__', func)!r} "
+                    f"{_describe_signature(func)} accepts neither "
+                    f"(x, *args, **kwargs) nor (x). It must take either the "
+                    f"control vector alone, or the control vector plus the "
+                    f"optimizer's args and keywords."
+                )
+
+            if (transform_result is not None) and self.transform:
+                result = transform_result(result)
+
+            return result
+
+        wrapper.nfev = 0
+        return wrapper
+
+    def _log_convergence(self):
+        if self.logger:
+            self.logger('==========================================================================')
+            self.logger(f'  Reason for convergence: {self.conv_msg}')
+            self.logger(f'  Final function value: {np.mean(self.fk):.4f}')
+            self.logger(f'  Total iterations: {self.iteration}')
+            self.logger(f'  Total function evaluations: {self.fun.nfev}')
+            if self.jac:
+                self.logger(f'  Total jacobian evaluations: {self.jac.nfev}')
+            if self.hess:
+                self.logger(f'  Total hessian evaluations: {self.hess.nfev}')
+            if self.epf:
+                self.logger(f'  Total EPF iterations: {self.epf_iteration}')
+            self.logger('==========================================================================')
+
+    # =============================================
+    # Restart state hooks consumed by RestartMixin
+    # =============================================
+
+    def _get_base_restart_state(self):
+        return {
+            'xk': self.xk,
+            'fk': self.fk,
+            'jk': self.jk,
+            'hk': self.hk,
+            'xk_old': self.xk_old,
+            'fk_old': self.fk_old,
+            'iteration': self.iteration,
+            'epf_iteration': self.epf_iteration,
+            'ftol': self.ftol,
+            'xtol': self.xtol,
+            'epf': self.epf,
+            'conv_msg': self.conv_msg,
+            'optimize_results': dict(self.optimize_results),
+            'nfev': getattr(self.fun, 'nfev', 0),
+            'njev': getattr(self.jac, 'nfev', 0) if self.jac else 0,
+            'nhev': getattr(self.hess, 'nfev', 0) if self.hess else 0,
+        }
+
+    def _set_base_restart_state(self, state):
+        self.xk = state['xk']
+        self.fk = state['fk']
+        self.jk = state['jk']
+        self.hk = state['hk']
+        self.xk_old = state['xk_old']
+        self.fk_old = state['fk_old']
+        self.iteration = state['iteration']
+        self.epf_iteration = state['epf_iteration']
+        self.ftol = state['ftol']
+        self.xtol = state['xtol']
+        self.epf = state['epf']
+        self.conv_msg = state.get('conv_msg', '')
+        self.optimize_results = OptimizeResult(state.get('optimize_results', {}))
+
+        self.fun.nfev = state.get('nfev', getattr(self.fun, 'nfev', 0))
+        if self.jac:
+            self.jac.nfev = state.get('njev', getattr(self.jac, 'nfev', 0))
+        if self.hess:
+            self.hess.nfev = state.get('nhev', getattr(self.hess, 'nfev', 0))
diff --git a/src/popt/optimization_methods/smcopt.py b/src/popt/optimization_methods/smcopt.py
new file mode 100644
index 00000000..1ab78438
--- /dev/null
+++ b/src/popt/optimization_methods/smcopt.py
@@ -0,0 +1,187 @@
+"""Stochastic Monte-Carlo optimization compatible with OptimizerBase."""
+
+import numpy as np
+
+from popt.optimization_methods.optimizer_base import OptimizerBase, StepReport
+import popt.optimization_methods.subroutines.optimizers as opt
+
+__author__ = ""
+__all__ = ["SmcOpt"]
+
+
+class SmcOpt(OptimizerBase):
+    """Sequential Monte-Carlo optimizer with resampling and backtracking."""
+
+    NAME = "SmcOpt"
+
+    def __init__(self, x0, fun, sens=None, args=(), bounds=None, callback=None, **options):
+        """
+        Parameters
+        ----------
+        x0 : ndarray
+            Initial state
+
+        fun : callable
+            objective function
+
+        sens : callable
+            Ensemble sensitivity function
+
+        args : tuple
+            Initial covariance tuple where ``args[0]`` is the covariance matrix used for sampling.
+
+        bounds : list, optional
+            (min, max) pairs for each element in x. None is used to specify no bound.
+
+        callback : callable, optional
+            Callback invoked after successful updates.
+
+        options : dict
+            SmcOpt configuration, plus everything :class:`OptimizerBase` takes
+            (``transform`` is forced off: SmcOpt works in physical coordinates).
+
+            - tol: convergence tolerance for the objective function (default 1e-6). Also used as ``ftol`` when given.
+            - alpha: weight between previous and new step (default 0.1)
+            - alpha_maxiter: maximum number of backtracking trials (default 5)
+            - resample: number indicating how many times resampling is tried if no improvement is found
+            - cov_factor: factor used to shrink the covariance for each resampling trial (default 0.5)
+            - inflation_factor: term used to weight down prior influence (default 1.0)
+            - survival_factor: fraction of surviving samples (clipped to [0.1, 1.0])
+            - best_func: best objective value seen before this run (default: the initial objective)
+            - savefolder/save_folder: folder used when saveit is true (default './')
+        """
+        if sens is None or not callable(sens):
+            raise ValueError("SmcOpt requires a callable sensitivity function 'sens'.")
+        if len(args) < 1:
+            raise ValueError("SmcOpt requires initial covariance as args[0].")
+
+        # SmcOpt historically operates in physical coordinates.
+        options = {**options, "transform": False}
+        super().__init__(x0, fun, jac=None, hess=None, args=(), bounds=bounds, callback=callback, **options)
+
+        self.sens = sens
+
+        # SmcOpt controls
+        self.obj_func_tol = options.get("tol", 1e-6)
+        self.ftol = options.get("tol", options.get("ftol", self.ftol))
+        self.alpha = options.get("alpha", 0.1)
+        self.alpha_iter_max = options.get("alpha_maxiter", 5)
+        self.max_resample = options.get("resample", 0)
+        self.cov_factor = options.get("cov_factor", 0.5)
+        self.inflation_factor = options.get("inflation_factor", 1.0)
+        self.survival_factor = float(np.clip(options.get("survival_factor", 1.0), 0.1, 1.0))
+        self.savefolder = options.get("savefolder", options.get("save_folder", "./"))
+        self.alpha_iter = 0
+
+        # Dynamic SMC state
+        self.cov = np.asarray(args[0], dtype=float)
+        self.best_state = None
+        self.best_func = None  # set when the run starts, from `best_func` or the initial objective
+        self.sens_njev = 0
+
+        self.optimizer = opt.GradientDescent(self.alpha, 0.0)
+
+    @property
+    def obj_func_values(self):
+        """Legacy alias for ``fk``."""
+        return self.fk
+
+    def _start(self):
+        # The best value seen so far starts at the initial objective, which
+        # the first log row and result already show.
+        if self.fk is None:
+            self.fk = self.fun(self.xk)
+        self.best_func = float(np.mean(self.options.get("best_func", self.fk)))
+        super()._start()
+
+    def update_step(self) -> StepReport:
+        """Perform one SMC update step with backtracking and optional resampling."""
+        self.optimizer.restore_parameters()
+        resampling_iter = 0
+        inflate = 2.0 * (self.inflation_factor + self.iteration)
+
+        while resampling_iter <= self.max_resample:
+            shrink = self.cov_factor ** resampling_iter
+            self.optimizer.apply_backtracking(np.sqrt(self.cov_factor) ** resampling_iter)
+
+            sens_matrix, self.best_state, best_func_tmp = self.sens(
+                self.xk,
+                inflate,
+                shrink * self.cov,
+                self.survival_factor,
+                epf=self.epf,
+            )
+            self.sens_njev += 1
+
+            self.alpha_iter = 0
+            while self.alpha_iter <= self.alpha_iter_max:
+                new_state = self.optimizer.apply_smc_update(self.xk, sens_matrix, iter=self.iteration)
+                new_state = self.bound_handler.project_to_bounds(new_state)
+
+                new_func_values = self.fun(new_state)
+
+                improved_objective = np.mean(self.fk) - np.mean(new_func_values) > self.obj_func_tol
+                improved_best = (self.best_func - best_func_tmp) > self.obj_func_tol
+                if improved_objective or improved_best:
+                    self._accept_step(new_state, new_func_values, best_func_tmp, improved_best)
+                    return StepReport(True)
+
+                if self.alpha_iter < self.alpha_iter_max:
+                    self.optimizer.apply_backtracking()
+                    self.alpha_iter += 1
+                else:
+                    break
+
+            if (resampling_iter < self.max_resample) and (np.mean(new_func_values) > np.mean(self.fk)):
+                resampling_iter += 1
+                self.optimizer.restore_parameters()
+                continue
+
+            return StepReport(False, "SmcOpt failed to find an improving step.")
+
+        return StepReport(False, "SmcOpt exhausted all resampling attempts.")
+
+    def _accept_step(self, new_state, new_func_values, best_func_tmp, improved_best):
+        self._commit_step(new_state, new_func_values)
+        if improved_best:
+            self.best_func = float(best_func_tmp)
+        self.optimizer.restore_parameters()
+
+    def _update_optimize_result(self):
+        result = super()._update_optimize_result()
+        result["fun"] = float(np.mean(self.fk))
+        result["njev"] = self.sens_njev
+        result["best_func"] = self.best_func
+        return result
+
+    def _get_restart_state(self) -> dict:
+        return {
+            "cov": self.cov,
+            "best_state": self.best_state,
+            "best_func": self.best_func,
+            "alpha": self.alpha,
+            "alpha_iter": self.alpha_iter,
+            "obj_func_tol": self.obj_func_tol,
+            "sens_njev": self.sens_njev,
+            "optimizer_state": dict(self.optimizer.__dict__),
+        }
+
+    def _set_restart_state(self, state: dict) -> None:
+        self.cov = state.get("cov", self.cov)
+        self.best_state = state.get("best_state", self.best_state)
+        self.best_func = state.get("best_func", self.best_func)
+        self.alpha = state.get("alpha", self.alpha)
+        self.alpha_iter = state.get("alpha_iter", self.alpha_iter)
+        self.obj_func_tol = state.get("obj_func_tol", self.obj_func_tol)
+        self.sens_njev = state.get("sens_njev", self.sens_njev)
+        self.optimizer.__dict__.update(state.get("optimizer_state", {}))
+
+    def log_columns(self) -> dict:
+        """The row of the iteration log: iteration, backtracking attempts, objective, best objective seen, step size."""
+        return {
+            "iter.": self.iteration,
+            "alpha_iter": self.alpha_iter,
+            "obj_func": float(np.mean(self.fk)),
+            "best_func": float(self.best_func),
+            "step-size": self.alpha,
+        }
diff --git a/src/popt/optimization_methods/subroutines/__init__.py b/src/popt/optimization_methods/subroutines/__init__.py
new file mode 100644
index 00000000..21d3a9d6
--- /dev/null
+++ b/src/popt/optimization_methods/subroutines/__init__.py
@@ -0,0 +1,4 @@
+"""Numerical subroutines shared by the optimizers: line searches, BFGS, Newton-CG, trust-region subproblems and step rules."""
+from .subroutines import *
+from .optimizers import *
+from .cma import *
diff --git a/src/popt/update_schemes/subroutines/cma.py b/src/popt/optimization_methods/subroutines/cma.py
similarity index 94%
rename from src/popt/update_schemes/subroutines/cma.py
rename to src/popt/optimization_methods/subroutines/cma.py
index bee93e5e..91f4100c 100644
--- a/src/popt/update_schemes/subroutines/cma.py
+++ b/src/popt/optimization_methods/subroutines/cma.py
@@ -14,27 +14,27 @@ def __init__(self, ne, dim, alpha_mu=None, n_mu=None, alpha_1=None, alpha_c=None
         ----------------------------------------------------------------------------------------------------------
         ne : int
             Ensemble size
-        
+
         dim : int
             Dimensions of control vector
-        
+
         alpha_mu : float
             Learning rate for rank-mu update. If None, value proposed in [1] is used.
-        
+
         n_mu : int, `n_mu < ne`
             Number of best samples of ne, to be used for rank-mu update.
             Default is int(ne/2).
-        
+
         alpha_1 : float
             Learning rate fro rank-one update. If None, value proposed in [1] is used.
-        
+
         alpha_c : float
-            Parameter (inverse if backwards time horizen)for evolution path update 
+            Parameter (inverse if backwards time horizen)for evolution path update
             in the rank-one update. See [1] for more info. If None, value proposed in [1] is used.
 
         corr_update : bool
             If True, CMA is used to update a correlation matrix. Default is False.
-        
+
         equal_weights : bool
             If True, all n_mu members are assign equal weighting, `w_i = 1/n_mu`.
             If False, the weighting scheme proposed in [1], where `w_i = log(n_mu + 1)-log(i)`,
@@ -52,7 +52,7 @@ def __init__(self, ne, dim, alpha_mu=None, n_mu=None, alpha_1=None, alpha_c=None
         #If None is given, default values are used
         if self.n_mu is None:
             self.n_mu = int(self.ne/2)
-        
+
         if equal_weights:
             self.weights = np.ones(self.n_mu)/self.n_mu
         else:
@@ -69,7 +69,7 @@ def __init__(self, ne, dim, alpha_mu=None, n_mu=None, alpha_1=None, alpha_c=None
             self.alpha_mu = self.c_cov*(1-1/self.mu_eff)
         if self.alpha_c is None:
             self.alpha_c  = 4/(dim+4)
-        
+
     def _rank_mu(self, X, J):
         '''
         Calculates the rank-mu matrix of CMA-ES.
@@ -79,9 +79,9 @@ def _rank_mu(self, X, J):
         weights = self.weights
         Cmu     = (Xsorted*weights)@Xsorted.T
 
-        if self.corr_update: 
+        if self.corr_update:
             Cmu = ot.cov2corr(Cmu)
-        
+
         return Cmu
 
     def _rank_one(self, step):
@@ -92,11 +92,11 @@ def _rank_one(self, step):
         self.evo_path = (1-s)*self.evo_path + np.sqrt(s*(2-s)*self.mu_eff)*step
         C1 = np.outer(self.evo_path, self.evo_path)
 
-        if self.corr_update: 
+        if self.corr_update:
             C1 = ot.cov2corr(C1)
 
         return C1
-    
+
     def __call__(self, cov, step, X, J):
         '''
         Performs the CMA update.
@@ -105,26 +105,26 @@ def __call__(self, cov, step, X, J):
         --------------------------------------------------
         cov : array_like, of shape (d, d)
             Current covariance or correlation matrix.
-        
+
         step : array_like, of shape (d,)
             New step of control vector.
             Used to update the evolution path.
 
         X : array_like, of shape (n, d)
             Control ensemble of size n.
-        
+
         J : array_like, of shape (n,)
             Objective ensemble of size n.
-        
+
         Returns
         --------------------------------------------------
         out : array_like, of shape (d, d)
             CMA updated covariance (correlation) matrix.
         '''
         a_mu  = self.alpha_mu
-        a_one = self.alpha_1 
+        a_one = self.alpha_1
         C_mu  = self._rank_mu(X, J)
         C_one = self._rank_one(step)
-        
-        cov   =  (1 - a_one - a_mu)*cov + a_one*C_one + a_mu*C_mu       
+
+        cov   =  (1 - a_one - a_mu)*cov + a_one*C_one + a_mu*C_mu
         return cov
diff --git a/src/popt/update_schemes/subroutines/optimizers.py b/src/popt/optimization_methods/subroutines/optimizers.py
similarity index 86%
rename from src/popt/update_schemes/subroutines/optimizers.py
rename to src/popt/optimization_methods/subroutines/optimizers.py
index a5bafe49..0b081f86 100644
--- a/src/popt/update_schemes/subroutines/optimizers.py
+++ b/src/popt/optimization_methods/subroutines/optimizers.py
@@ -1,9 +1,14 @@
 """Gradient acceleration."""
+import logging
+
 import numpy as np
 
 __all__ = ['GradientDescent', 'Adam', 'AdaMax', 'Steihaug', ]
 
 
+log = logging.getLogger(__name__)
+
+
 class GradientDescent:
     r"""
     A class for performing gradient descent optimization with momentum and backtracking.
@@ -65,7 +70,7 @@ def __init__(self, step_size, momentum):
         self.temp_velocity = 0
         self._step_size    = step_size
         self._momentum     = momentum
-    
+
 
     def apply_update(self, control, gradient, **kwargs):
         """
@@ -130,7 +135,7 @@ def apply_backtracking(self, shrink=0.5):
         """
         self._step_size = shrink*self._step_size
         self._momentum  = shrink*self._momentum
-    
+
     def restore_parameters(self):
         """
         Restore the original step size and momentum value.
@@ -138,11 +143,13 @@ def restore_parameters(self):
         self.velocity   = self.temp_velocity
         self._step_size = self.step_size
         self._momentum  = self.momentum
-    
+
     def get_momentum_for_nesterov(self):
+        """The momentum term, ``beta * velocity``, used for the Nesterov look-ahead."""
         return self.momentum * self.velocity
 
     def get_step_size(self):
+        """Current step size."""
         return self._step_size
 
 
@@ -203,7 +210,7 @@ class Adam:
     def __init__(self, step_size, beta1=0.9, beta2=0.999):
         """
         A class implementing the Adam optimizer for gradient-based optimization.
-        The Adam update equation for the control x using gradient g, 
+        The Adam update equation for the control x using gradient g,
         iteration t, and small constants ε is given by:
 
             m_t = β1 * m_{t-1} + (1 - β1) * g   \n
@@ -258,7 +265,7 @@ def apply_update(self, control, gradient, **kwargs):
         new_control, temp_velocity: tuple
             The new value of the control parameter after the update, and the current state step.
         """
-        iter  = kwargs['iter'] 
+        iter  = kwargs['iter']
         alpha = self._step_size
         beta1 = self.beta1
         beta2 = self.beta2
@@ -272,12 +279,12 @@ def apply_update(self, control, gradient, **kwargs):
         new_control = control - step  # steepest descent
         return new_control, step
 
-    def apply_backtracking(self):
+    def apply_backtracking(self, shrink=0.5):
         """
-        Apply backtracking by reducing step size temporarily.
+        Apply backtracking by scaling the step size temporarily.
         """
-        self._step_size = 0.5*self._step_size
-    
+        self._step_size = shrink*self._step_size
+
     def restore_parameters(self):
         """
         Restore the original step size.
@@ -287,6 +294,7 @@ def restore_parameters(self):
         self._step_size = self.step_size
 
     def get_step_size(self):
+        """Current step size."""
         return self._step_size
 
 
@@ -296,18 +304,19 @@ class AdaMax(Adam):
     '''
     def __init__(self, step_size, beta1=0.9, beta2=0.999):
         super().__init__(step_size, beta1, beta2)
-    
+
     def apply_update(self, control, gradient, **kwargs):
-        iter  = kwargs['iter'] 
+        """An AdaMax step (Adam with the infinity norm on the second moment); returns ``(new_control, step)``."""
+        iter  = kwargs['iter']
         alpha = self._step_size
         beta1 = self.beta1
         beta2 = self.beta2
 
         self.temp_vel1 = beta1*self.vel1 + (1-beta1)*gradient
         self.temp_vel2 = np.maximum(beta2*self.vel2, np.abs(gradient))
-        
+
         step = alpha/(1-beta1**iter) * self.temp_vel1/self.temp_vel2
-        new_control = control - step 
+        new_control = control - step
         return new_control, step
 
 
@@ -357,8 +366,6 @@ def __init__(self, maxiter=1e6, epsilon=1e-8, delta_max=1e5, delta0=1.0):
 
         # Function arguments.
         self.maxiter = maxiter
-        self.print_flag = 2
-        self.print_prefix = "Steihaug: "
         self.epsilon = epsilon
         self.delta_max = delta_max
         self.delta0 = delta0
@@ -395,14 +402,12 @@ def apply_update(self, xk, dfk, **kwargs):
         len_r0 = np.sqrt(np.dot(rj, rj))
         length_test = self.epsilon * len_r0
 
-        if self.print_flag >= 2:
-            print(self.print_prefix + "p0: " + repr(pj))
-            print(self.print_prefix + "r0: " + repr(rj))
-            print(self.print_prefix + "d0: " + repr(dj))
+        log.debug("p0: " + repr(pj))
+        log.debug("r0: " + repr(rj))
+        log.debug("d0: " + repr(dj))
 
         if len_r0 < self.epsilon:
-            if self.print_flag >= 2:
-                print(self.print_prefix + "len rj < epsilon.")
+            log.debug("len rj < epsilon.")
             return xk, pj
 
         # Iterate over j.
@@ -410,61 +415,53 @@ def apply_update(self, xk, dfk, **kwargs):
         while True:
             # The curvature.
             curv = np.dot(dj, np.dot(B, dj))
-            if self.print_flag >= 2:
-                print(self.print_prefix + "\nIteration j = " + repr(j))
-                print(self.print_prefix + "Curv: " + repr(curv))
+            log.debug("Iteration j = " + repr(j))
+            log.debug("Curv: " + repr(curv))
 
             # First test.
             if curv <= 0.0:
                 tau = self.get_tau(rj, dj)
-                if self.print_flag >= 2:
-                    print(self.print_prefix + "curv <= 0.0, therefore tau = " + repr(tau))
+                log.debug("curv <= 0.0, therefore tau = " + repr(tau))
                 pj_new = pj + tau * dj
                 xk_new = xk + pj_new
                 return xk_new, pj_new
 
             aj = np.dot(rj, rj) / curv
             pj_new = pj + aj * dj
-            if self.print_flag >= 2:
-                print(self.print_prefix + "aj: " + repr(aj))
-                print(self.print_prefix + "pj+1: " + repr(pj_new))
+            log.debug("aj: " + repr(aj))
+            log.debug("pj+1: " + repr(pj_new))
 
             # Second test.
             if np.sqrt(np.dot(pj_new, pj_new)) >= self.delta:
                 tau = self.get_tau(pj, dj)
-                if self.print_flag >= 2:
-                    print(self.print_prefix + "sqrt(dot(self.pj_new, self.pj_new)) >= self.delta, therefore tau = "
+                log.debug("sqrt(dot(self.pj_new, self.pj_new)) >= self.delta, therefore tau = "
                           + repr(tau))
                 pj_new = pj + tau * dj
                 xk_new = xk + pj_new
                 return xk_new, pj_new
 
             rj_new = rj + aj * np.dot(B, dj)
-            if self.print_flag >= 2:
-                print(self.print_prefix + "rj+1: " + repr(rj_new))
+            log.debug("rj+1: " + repr(rj_new))
 
             # Third test.
             if np.sqrt(np.dot(rj_new, rj_new)) < length_test:
-                if self.print_flag >= 2:
-                    print(self.print_prefix + "sqrt(dot(self.rj_new, self.rj_new)) < length_test")
+                log.debug("sqrt(dot(self.rj_new, self.rj_new)) < length_test")
                 xk_new = xk + pj_new
                 return xk_new, pj_new
 
             bj_new = np.dot(rj_new, rj_new) / np.dot(rj, rj)
             dj_new = -rj_new + bj_new * dj
-            if self.print_flag >= 2:
-                print(self.print_prefix + "len rj+1: " + repr(np.sqrt(np.dot(rj_new, rj_new))))
-                print(self.print_prefix + "epsilon.||r0||: " + repr(length_test))
-                print(self.print_prefix + "bj+1: " + repr(bj_new))
-                print(self.print_prefix + "dj+1: " + repr(dj_new))
+            log.debug("len rj+1: " + repr(np.sqrt(np.dot(rj_new, rj_new))))
+            log.debug("epsilon.||r0||: " + repr(length_test))
+            log.debug("bj+1: " + repr(bj_new))
+            log.debug("dj+1: " + repr(dj_new))
 
             # Update j+1 to j.
             pj = pj_new * 1.0
             rj = rj_new * 1.0
             dj = dj_new * 1.0
             if j > self.maxiter:
-                import sys
-                sys.exit()
+                raise RuntimeError(f"Steihaug CG did not converge within {self.maxiter} iterations")
             j = j + 1
 
     def get_tau(self, pj, dj):
@@ -473,15 +470,18 @@ def get_tau(self, pj, dj):
         dot_pj_dj = np.dot(pj, dj)
         len_dj_sqrd = np.dot(dj, dj)
 
-        tau = -dot_pj_dj + np.sqrt(
-            dot_pj_dj ** 2 - len_dj_sqrd * (np.dot(pj, pj) - self.delta ** 2)) / len_dj_sqrd
+        # Positive root of ||pj + tau dj||^2 = delta^2. The whole numerator is
+        # divided by ||dj||^2; dividing only the square root, as this once
+        # did, put every boundary-hitting step at the wrong length.
+        tau = (-dot_pj_dj + np.sqrt(
+            dot_pj_dj ** 2 - len_dj_sqrd * (np.dot(pj, pj) - self.delta ** 2))) / len_dj_sqrd
         return tau
 
-    def apply_backtracking(self):
+    def apply_backtracking(self, shrink=0.5):
         """
-        Apply backtracking by reducing step size temporarily.
+        Apply backtracking by scaling the trust radius temporarily.
         """
-        self.delta = 0.5 * self.delta
+        self.delta = shrink * self.delta
 
     def restore_parameters(self):
         """
@@ -490,4 +490,5 @@ def restore_parameters(self):
         self.delta = self.delta0
 
     def get_step_size(self):
-        return self.delta
\ No newline at end of file
+        """Current trust-region radius, which plays the role of the step size."""
+        return self.delta
diff --git a/src/popt/update_schemes/subroutines/subroutines.py b/src/popt/optimization_methods/subroutines/subroutines.py
similarity index 92%
rename from src/popt/update_schemes/subroutines/subroutines.py
rename to src/popt/optimization_methods/subroutines/subroutines.py
index bf14dd6f..1dc9f441 100644
--- a/src/popt/update_schemes/subroutines/subroutines.py
+++ b/src/popt/optimization_methods/subroutines/subroutines.py
@@ -1,3 +1,6 @@
+"""Line searches, the BFGS inverse-Hessian update, Newton-CG, and trust-region subproblem solvers."""
+import logging
+
 import numpy as np
 import numpy.linalg as la
 from functools import lru_cache
@@ -6,10 +9,10 @@
 from scipy.optimize._trustregion_exact import IterativeSubproblem
 
 __all__ = [
-    'line_search', 
-    'zoom', 
-    'line_search_backtracking', 
-    'bfgs_update', 
+    'line_search',
+    'zoom',
+    'line_search_backtracking',
+    'bfgs_update',
     'newton_cg',
     'solve_trust_region_subproblem'
 ]
@@ -33,40 +36,40 @@ def line_search(step_size, xk, pk, fun, jac, fk=None, jk=None, **kwargs):
 
     pk : ndarray
         Search direction.
-    
+
     fun : callable
         Objective function
 
     jac : callable
         Gradient of the objective function
-    
+
     fk : float, optional
         Function value at xk. If None, it will be computed.
-    
+
     jk : ndarray, optional
         Gradient at xk. If None, it will be computed.
-    
+
     **kwargs : dict
         Additional parameters for the line search, such as:
         - amax : float, maximum step size (default: 1000)
         - maxiter : int, maximum number of iterations (default: 10)
         - c1 : float, sufficient decrease condition (default: 1e-4)
         - c2 : float, curvature condition (default: 0.9)
-    
+
     Returns
     -------
     alpha : float
         Step size that satisfies the Wolfe conditions.
-    
+
     fval : float
         Function value at the new point xk + step_size*pk.
-    
+
     jval : ndarray
         Gradient at the new point xk + step_size*pk.
-    
+
     nfev : int
         Number of function evaluations.
-    
+
     njev : int
         Number of gradient evaluations.
     '''
@@ -109,7 +112,7 @@ def phi(alpha):
             phi.fun_val = fun(xk + alpha*pk)
             ls_nfev += 1
         return phi.fun_val
-    
+
     @lru_cache(maxsize=None)
     def dphi(alpha):
         global ls_njev
@@ -124,7 +127,7 @@ def dphi(alpha):
             dphi.jac_val = jac(xk + alpha*pk)
             ls_njev += 1
         return np.dot(dphi.jac_val, pk)
-    
+
     # Define initial values of phi and dphi
     phi_0  = phi(0)
     dphi_0 = dphi(0)
@@ -141,10 +144,10 @@ def dphi(alpha):
         if (phi_i > phi_0 + c1*a[i]*dphi_0) or (phi_i >= phi(a[i-1]) and i>0):
             logger(f'    Armijo condition: {cross}')
             # Call zoom function
-            step_size = zoom(a[i-1], a[i], phi, dphi, phi_0, dphi_0, maxiter+1-i, c1, c2, iter_id=i) 
+            step_size = zoom(a[i-1], a[i], phi, dphi, phi_0, dphi_0, maxiter+1-i, c1, c2, iter_id=i)
             logger('──────────────────────────────────────────────────')
             return step_size, phi.fun_val, dphi.jac_val, ls_nfev, ls_njev
-        
+
         logger(f'    Armijo condition: {check}')
 
         # Evaluate dphi(ai)
@@ -158,23 +161,23 @@ def dphi(alpha):
             return step_size, phi.fun_val, dphi.jac_val, ls_nfev, ls_njev
 
         logger(f'    Curvature condition: {cross}')
-        
+
         # Check for posetive derivative
         if dphi_i >= 0:
             # Call zoom function
             step_size = zoom(a[i], a[i-1], phi, dphi, phi_0, dphi_0, maxiter+1-i, c1, c2, iter_id=i)
             logger('──────────────────────────────────────────────────')
             return step_size, phi.fun_val, dphi.jac_val, ls_nfev, ls_njev
-        
+
         # Increase ai
         a.append(min(2*a[i], amax))
         logger(f'    Step-size: {a[i]:.3e} ──> {a[i+1]:.3e}')
-        
+
     # If we reached this point, the line search failed
     logger('Line search failed to find a suitable step size')
     logger('──────────────────────────────────────────────────')
     return None, None, None, ls_nfev, ls_njev
-            
+
 
 def zoom(alo, ahi, f, df, f0, df0, maxiter, c1, c2, iter_id=0):
     '''Zoom function for line search algorithm. (This is the same as for scipy)'''
@@ -182,6 +185,8 @@ def zoom(alo, ahi, f, df, f0, df0, maxiter, c1, c2, iter_id=0):
     phi_lo = f(alo)
     phi_hi = f(ahi)
     dphi_lo = df(alo)
+    aold = None
+    phi_old = None
 
     for j in range(maxiter):
         logger(f'iteration: {iter_id+j}')
@@ -200,7 +205,7 @@ def zoom(alo, ahi, f, df, f0, df0, maxiter, c1, c2, iter_id=0):
         if (aj is None) or (aj <  alo + tol_quad) or (aj > ahi - tol_quad):
                 aj = alo + 0.5*(ahi - alo)
 
-        
+
         logger(f'    New step-size ──> {aj:.3e}')
 
         # Evaluate phi(aj)
@@ -222,7 +227,7 @@ def zoom(alo, ahi, f, df, f0, df0, maxiter, c1, c2, iter_id=0):
             if abs(dphi_j) <= -c2*df0:
                 logger(f'    Curvature condition: {check}')
                 return aj
-            
+
             logger(f'    Curvature condition: {cross}')
             if dphi_j*(ahi-alo) >= 0:
                 # store old values
@@ -245,9 +250,6 @@ def zoom(alo, ahi, f, df, f0, df0, maxiter, c1, c2, iter_id=0):
     logger('──────────────────────────────────────────────────')
     return None
 
-
-
-
 def line_search_backtracking(step_size, xk, pk, fun, jac, fk=None, jk=None, **kwargs):
     '''
     Backtracking line search algorithm to find step size alpha that satisfies the Wolfe conditions.
@@ -262,40 +264,40 @@ def line_search_backtracking(step_size, xk, pk, fun, jac, fk=None, jk=None, **kw
 
     pk : ndarray
         Search direction.
-    
+
     fun : callable
         Objective function
 
     jac : callable
         Gradient of the objective function
-    
+
     fk : float, optional
         Function value at xk. If None, it will be computed.
-    
+
     jk : ndarray, optional
         Gradient at xk. If None, it will be computed.
-    
+
     **kwargs : dict
         Additional parameters for the line search, such as:
         - rho : float, backtracking factor (default: 0.5)
         - maxiter : int, maximum number of iterations (default: 10)
         - c1 : float, sufficient decrease condition (default: 1e-4)
         - c2 : float, curvature condition (default: 0.9)
-    
+
     Returns
     -------
     alpha : float
         Step size that satisfies the Wolfe conditions.
-    
+
     fval : float
         Function value at the new point xk + step_size*pk.
-    
+
     jval : ndarray
         Gradient at the new point xk + step_size*pk.
-    
+
     nfev : int
         Number of function evaluations.
-    
+
     njev : int
         Number of gradient evaluations.
     '''
@@ -333,7 +335,7 @@ def phi(alpha):
             fun_val = fun(xk + alpha*pk)
             ls_nfev += 1
         return fun_val
-    
+
 
     # run the backtracking line search loop
     for i in range(maxiter):
@@ -349,15 +351,15 @@ def phi(alpha):
                 logger('──────────────────────────────────────────────────')
 
                 return step_size, phi_i, jac_new, ls_nfev, ls_njev
-        
+
         logger(f'    Sufficient decrease: {cross}')
         # Reduce step size
-        step_size *= rho  
+        step_size *= rho
 
     # If we reached this point, the line search failed
     logger('Backtracking failed to find a suitable step size')
     logger('──────────────────────────────────────────────────')
-    return None, None, None, ls_nfev, ls_njev  
+    return None, None, None, ls_nfev, ls_njev
 
 
 def bfgs_update(Hk, sk, yk):
@@ -377,7 +379,7 @@ def bfgs_update(Hk, sk, yk):
     rho = 1.0 / (yk.T @ sk)
 
     if rho <= 0:
-        print('Non-positive curvature detected. BFGS update skipped....')
+        logging.getLogger(__name__).warning('Non-positive curvature detected. BFGS update skipped.')
         return Hk
 
     I = np.eye(Hk.shape[0])
@@ -387,12 +389,13 @@ def bfgs_update(Hk, sk, yk):
     return Hk_new
 
 def newton_cg(gk, Hk=None, maxiter=None, **kwargs):
+    """Newton-CG search direction for gradient ``gk`` and Hessian ``Hk`` (Hessian-vector products by finite differences of ``jac`` when ``Hk`` is None); ``-gk`` when no descent direction is found."""
 
     # Check for logger
     logger = kwargs.get('logger', None)
     if logger is None:
         logger = print
-    
+
     logger('')
     logger('Running Newton-CG subroutine..........')
 
@@ -409,7 +412,7 @@ def Hessd(d):
         maxiter = 20*gk.size # Same dfault as in scipy
 
     tol = min(0.5, np.sqrt(la.norm(gk)))*la.norm(gk)
-    z = 0
+    z = np.zeros_like(gk, dtype=float)
     r = gk
     d = -r
 
@@ -429,7 +432,7 @@ def Hessd(d):
                 return -gk
             else:
                 return z
-            
+
         rold = r
         a = np.dot(r,r)/dTHd
         z = z + a*d
@@ -443,6 +446,12 @@ def Hessd(d):
         b = np.dot(r, r)/np.dot(rold, rold)
         d = -r + b*d
 
+    # Out of iterations: return the best direction so far. Falling off the
+    # loop used to return None, which the caller then took the norm of.
+    logger('Maximum number of CG iterations reached, returning current direction')
+    logger('')
+    return z if maxiter > 0 else -gk
+
 
 def solve_trust_region_subproblem(xk, fk, gk, Hk, radius, method='iterative', **kwargs):
     '''
@@ -467,7 +476,7 @@ def solve_trust_region_subproblem(xk, fk, gk, Hk, radius, method='iterative', **
 
     **kwargs : dict
         Additional parameters for the solver.
-    
+
     Returns
     -------
     pk : ndarray
@@ -476,14 +485,15 @@ def solve_trust_region_subproblem(xk, fk, gk, Hk, radius, method='iterative', **
         Indicates whether the solution lies on the boundary of the trust region.
     '''
     # Make quadratic model
-    model = lambda p: fk + np.dot(gk, p) + 0.5*np.dot(p, np.matmul(Hk, p))
+    def model(p):
+        return fk + np.dot(gk, p) + 0.5*np.dot(p, np.matmul(Hk, p))
 
     # Solve the trust-region subproblem
     if method == 'iterative':
         subproblem = IterativeSubproblem(
                 xk,
-                model, 
-                lambda _: gk, 
+                model,
+                lambda _: gk,
                 lambda _: Hk,
             )
         pk, hits_boundary = subproblem.solve(radius)
@@ -491,13 +501,13 @@ def solve_trust_region_subproblem(xk, fk, gk, Hk, radius, method='iterative', **
     elif method == 'CG-Steihaug':
         subproblem = CGSteihaugSubproblem(
                 xk,
-                model, 
-                lambda _: gk, 
+                model,
+                lambda _: gk,
                 lambda _: Hk,
             )
         pk, hits_boundary = subproblem.solve(radius)
-    
+
     else:
         raise ValueError("Invalid method for solving trust-region subproblem. Choose 'iterative' or 'CG-Steihaug'.")
 
-    return pk, hits_boundary
\ No newline at end of file
+    return pk, hits_boundary
diff --git a/src/popt/optimization_methods/trust_region.py b/src/popt/optimization_methods/trust_region.py
new file mode 100644
index 00000000..e9f82c7b
--- /dev/null
+++ b/src/popt/optimization_methods/trust_region.py
@@ -0,0 +1,312 @@
+"""Trust-region deterministic optimization methods.
+
+This module implements a trust-region optimizer with optional
+BFGS Hessian approximation and restart support.
+"""
+
+import numpy as np
+
+# Internal imports
+from popt.optimization_methods.optimizer_base import OptimizerBase, StepReport
+from popt.optimization_methods.subroutines.subroutines import solve_trust_region_subproblem
+
+__author__ = "Mathias Methlie Nilsen"
+__all__ = ["TrustRegion"]
+
+# Symbols for logger output
+subk = "ₖ"
+fun_xk_symbol = f"fun(x{subk})"
+delta_k_symbol = f"Δ{subk}"
+rho_symbol = f"ρ{subk}"
+jac_inf_symbol = f"‖jac(x{subk})‖∞"
+
+
+class TrustRegion(OptimizerBase):
+    """Trust-region Optimizer.
+
+    The class supports exact Hessian trust-region subproblems (iterative or
+    CG-Steihaug) and optional BFGS Hessian approximation via ``hess='BFGS'``.
+    """
+
+    NAME = "Trust-Region"
+    VALID_METHODS = ("iterative", "CG-Steihaug")
+
+    def __init__(
+        self,
+        x0,
+        fun,
+        jac,
+        hess,
+        method="iterative",
+        args=(),
+        bounds=None,
+        callback=None,
+        **options,
+    ):
+        """Initialize a trust-region optimizer instance.
+
+        Parameters
+        ----------
+        x0 : ndarray
+            Initial parameter vector.
+        fun : callable
+            Objective function.
+        jac : callable
+            Gradient function.
+        hess : callable or {'BFGS'}
+            Hessian function, or ``'BFGS'`` to use a quasi-Newton Hessian approximation.
+        method : {'iterative', 'CG-Steihaug'} or callable, optional
+            Trust-region subproblem solver.
+        args : tuple, optional
+            Extra positional arguments passed to the wrapped callables.
+        bounds : sequence, optional
+            Lower and upper bounds for each state variable.
+        callback : callable, optional
+            Callback invoked after successful updates.
+        **options
+            Trust-region configuration, plus everything :class:`OptimizerBase` takes.
+            - trust_radius: Initial trust-region radius (default: 1.0).
+            - trust_radius_max: Maximum trust-region radius (default: ``100 * trust_radius``).
+            - trust_radius_min: Minimum trust-region radius before termination (default: ``trust_radius / 1000``).
+            - trust_radius_cuts: Maximum number of radius reductions before rejecting a step (default: 4).
+            - rho_tol: Minimum ratio between actual and predicted reduction for step acceptance (default: 1e-6).
+            - eta1: Threshold for rejecting a step (default: 0.05).
+            - eta2: Threshold for increasing the trust-region radius (default: 0.5).
+            - gam1: Factor used to decrease the trust-region radius (default: 0.5).
+            - gam2: Factor used to increase the trust-region radius when the boundary is hit (default: 1.5).
+            - resample: Whether to recompute gradient and Hessian after rejected steps (default: False).
+            - convergence_criteria: Optional callable for custom convergence checks.
+        """
+        if jac is None:
+            raise ValueError("TrustRegion requires a Jacobian (gradient) function.")
+
+        use_bfgs = isinstance(hess, str) and hess.upper() == "BFGS"
+        if (not use_bfgs) and (hess is None):
+            raise ValueError("TrustRegion requires a Hessian function or hess='BFGS'.")
+
+        super().__init__(x0, fun, jac, None if use_bfgs else hess, args, bounds, callback, **options)
+
+        self.method = self._validate_method(method)
+        self.quasi_newton = use_bfgs
+
+        convergence_criteria = options.get("convergence_criteria", None)
+        self.convergence_criteria = convergence_criteria if callable(convergence_criteria) else None
+
+        # Trust-region controls
+        self.trust_radius = options.get("trust_radius", 1.0)
+        self.trust_radius_max = options.get("trust_radius_max", 100 * self.trust_radius)
+        self.trust_radius_min = options.get("trust_radius_min", self.trust_radius / 1000)
+        self.trust_radius_cuts = options.get("trust_radius_cuts", 4)
+
+        # Acceptance and radius updates
+        self.rho_tol = options.get("rho_tol", 1e-6)
+        self.eta1 = options.get("eta1", 0.05) # Threshold for rejecting a step
+        self.eta2 = options.get("eta2", 0.5)  # Threshold for increasing the trust-region radius
+        self.gam1 = options.get("gam1", 0.5)  # Factor to decrease the trust-region radius when a step is rejected
+        self.gam2 = options.get("gam2", 1.5)  # Factor to increase the trust-region radius when a step is accepted and hits the boundary
+        self.rho = 0.0
+        self.hits_boundary = None  # whether the last accepted step reached the trust-region boundary
+
+        # Other options
+        self.resample = options.get("resample", False)
+        self.jk_old = None
+
+    def update_step(self) -> StepReport:
+        """Perform one trust-region step with optional radius reductions."""
+        self._evaluate_missing_derivatives()
+        return self._attempt_step(inner_iter=0)
+
+    def check_convergence(self) -> bool:
+        """The projected gradient, the trust-region radius, and any custom criterion."""
+        if super().check_convergence():
+            return True
+
+        if self.trust_radius <= self.trust_radius_min:
+            self.conv_msg = f"Trust-region radius {delta_k_symbol} <= {self.trust_radius_min}."
+            return True
+
+        if callable(self.convergence_criteria) and self.convergence_criteria(self):
+            self.conv_msg = "Custom convergence criteria met."
+            return True
+
+        return False
+
+    def _attempt_step(self, inner_iter: int) -> StepReport:
+        if inner_iter > self.trust_radius_cuts:
+            return StepReport(False, "Trust-region step rejected after radius cut attempts.")
+
+        jk_proj = self.bound_handler.project_gradient(self.xk, self.jk)
+
+        if self.quasi_newton and (self.hk is None) and (self.iteration == 1):
+            sk = -jk_proj
+            sk_norm = np.linalg.norm(sk, np.inf)
+            if sk_norm > 0:
+                sk = sk / sk_norm * self.trust_radius
+            hits_boundary = True
+        else:
+            hk_step = self.hk
+            if hk_step is None:
+                hk_step = self.hess(self.xk)
+                self.hk = hk_step
+
+            if callable(self.method):
+                sk, hits_boundary = self.method(
+                    self.xk,
+                    self.fk,
+                    jk_proj,
+                    hk_step,
+                    self.trust_radius,
+                    **self.options,
+                )
+            else:
+                sk, hits_boundary = solve_trust_region_subproblem(
+                    self.xk,
+                    self.fk,
+                    jk_proj,
+                    hk_step,
+                    self.trust_radius,
+                    method=self.method,
+                    **self.options,
+                )
+
+        xk_new = self.bound_handler.project_to_bounds(self.xk + sk)
+        fk_new = self._objective_value(xk_new)
+
+        df = self.fk - fk_new
+        if self.quasi_newton and (self.iteration == 1) and (self.hk is None):
+            dm = -np.dot(jk_proj, sk)
+        else:
+            hk_for_dm = self.hk
+            if hk_for_dm is None:
+                hk_for_dm = self.hess(self.xk)
+            dm = -np.dot(jk_proj, sk) - 0.5 * np.dot(sk, hk_for_dm @ sk)
+
+        self.rho = df / dm if dm != 0 else -np.inf
+
+        if (self.rho > self.rho_tol) and (fk_new < self.fk):
+            self._accept_step(xk_new, fk_new, sk, hits_boundary)
+            return StepReport(True)
+
+        if self.logger:
+            if not (fk_new < self.fk):
+                self.logger(
+                    f"Function value not reduced: {fun_xk_symbol} = {fk_new:<10.4e} >= {self.fk:<10.4e}"
+                )
+            else:
+                self.logger(
+                    f"Step not successful: {rho_symbol} = {self.rho:<10.4e} < {self.rho_tol:<10.4e}"
+                )
+
+        old_radius = self.trust_radius
+        self.trust_radius *= 0.25
+        if self.logger:
+            self.logger(
+                f"Reducing {delta_k_symbol}: {old_radius:<10.4e} -> {self.trust_radius:<10.4e}"
+            )
+
+        if self.trust_radius < self.trust_radius_min:
+            return StepReport(False, f"Trust-region radius {delta_k_symbol} below minimum.")
+
+        if self.resample:
+            self.jk = self.jac(self.xk)
+            if not self.quasi_newton:
+                self.hk = self.hess(self.xk)
+
+        return self._attempt_step(inner_iter=inner_iter + 1)
+
+    def _accept_step(self, xk_new, fk_new, sk, hits_boundary) -> None:
+        self.jk_old = self.jk
+        self._commit_step(xk_new, fk_new)
+        self.jk = self.jac(self.xk)
+
+        if self.quasi_newton:
+            yk = self.jk - self.jk_old
+            if self.hk is None:
+                denom = np.dot(yk, sk)
+                if denom > 0:
+                    self.hk = np.dot(yk, yk) / denom * np.eye(self.xk.size)
+                else:
+                    self.hk = np.eye(self.xk.size)
+            self.hk = self._bfgs_update(self.hk, sk, yk)
+        else:
+            self.hk = self.hess(self.xk)
+
+        self._update_trust_radius(hits_boundary)
+        self.hits_boundary = hits_boundary
+
+    def _update_trust_radius(self, hits_boundary: bool) -> None:
+        delta_old = self.trust_radius
+
+        if (self.rho >= self.eta2) and hits_boundary:
+            delta_new = min(self.gam2 * delta_old, self.trust_radius_max)
+        elif self.rho < self.eta1:
+            delta_new = self.gam1 * delta_old
+        else:
+            delta_new = delta_old
+
+        self.trust_radius = np.clip(delta_new, self.trust_radius_min, self.trust_radius_max)
+
+        if self.logger and (self.trust_radius != delta_old):
+            d_delta = (self.trust_radius - delta_old) / delta_old * 100
+            self.logger(
+                f"Tr-radius {delta_k_symbol} updated: {delta_old:<10.4e} -> {self.trust_radius:<10.4e} ({d_delta:<.2f}%)"
+            )
+
+    def _objective_value(self, x) -> float:
+        # The trust-region ratio needs a scalar; an ensemble objective returns one value per member.
+        return float(np.mean(self.fun(x)))
+
+    def _validate_method(self, method):
+        if callable(method):
+            if self.logger:
+                self.logger("Using custom trust-region subproblem solver callable.")
+            return method
+
+        if not isinstance(method, str):
+            raise ValueError("Method must be a string or a callable.")
+
+        if method not in self.VALID_METHODS:
+            raise ValueError(
+                f"Invalid trust-region method '{method}'. Valid options are: {self.VALID_METHODS}."
+            )
+
+        return method
+
+    def _bfgs_update(self, Bk, sk, yk):
+        sk = sk.reshape(-1, 1)
+        yk = yk.reshape(-1, 1)
+
+        ykTsk = (yk.T @ sk).item()
+        skTBksk = (sk.T @ Bk @ sk).item()
+        if ykTsk <= 0 or skTBksk <= 0:
+            return Bk
+
+        term1 = np.matmul(yk, yk.T) / ykTsk
+        term2 = np.matmul(np.matmul(Bk, sk), np.matmul(sk.T, Bk)) / skTBksk
+        return Bk + term1 - term2
+
+    def _get_restart_state(self) -> dict:
+        return {
+            "trust_radius": self.trust_radius,
+            "rho": self.rho,
+            "jk_old": self.jk_old,
+            "quasi_newton": self.quasi_newton,
+        }
+
+    def _set_restart_state(self, state: dict) -> None:
+        self.trust_radius = state.get("trust_radius", self.trust_radius)
+        self.rho = state.get("rho", self.rho)
+        self.jk_old = state.get("jk_old", self.jk_old)
+        self.quasi_newton = state.get("quasi_newton", self.quasi_newton)
+
+    def log_columns(self) -> dict:
+        """The row of the iteration log: iteration, objective, trust radius, reduction ratio, whether the step hit the boundary."""
+        columns = {
+            "iter.": self.iteration,
+            fun_xk_symbol: self.fk,
+            delta_k_symbol: self.trust_radius,
+            rho_symbol: self.rho,
+        }
+        if self.hits_boundary is not None:
+            columns[f"‖p{subk}‖ = {delta_k_symbol}"] = "yes" if self.hits_boundary else "no"
+        return columns
diff --git a/src/popt/update_schemes/__init__.py b/src/popt/update_schemes/__init__.py
deleted file mode 100644
index 2bf98afd..00000000
--- a/src/popt/update_schemes/__init__.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Iterative steppers."""
diff --git a/src/popt/update_schemes/enopt.py b/src/popt/update_schemes/enopt.py
deleted file mode 100644
index cae55043..00000000
--- a/src/popt/update_schemes/enopt.py
+++ /dev/null
@@ -1,274 +0,0 @@
-"""Ensemble optimisation algorithm."""
-# External imports
-import numpy as np
-from numpy import linalg as la
-import time
-import pprint
-
-# Internal imports
-from popt.misc_tools import optim_tools as ot
-from popt.loop.optimize import Optimize
-import popt.update_schemes.subroutines.optimizers as opt
-
-
-class EnOpt(Optimize):
-    r"""
-    This is an implementation of the ensemble steepest descent ensemble optimization algorithm - EnOpt.
-    The update of the control variable is done with the simple steepest (or gradient) descent algorithm:
-
-    $$ x_l = x_{l-1} - \alpha \times C \times G $$
-
-    where $x$ is the control variable, $l$ is the iteration index, $\alpha$ is the step size,
-    $C$ is a smoothing matrix (e.g., covariance matrix for $x$), and $G$ is the ensemble gradient.
-
-    Methods
-    -------
-    calc_update()
-        Update using steepest descent method with ensemble gradient
-
-    References
-    ----------
-    Chen et al., 2009, 'Efficient Ensemble-Based Closed-Loop Production Optimization', SPE Journal, 14 (4): 634-645.
-
-    TODO: Implement getter for optimize_result
-    """
-
-    def __init__(self, fun, x, args, jac, hess, bounds=None, **options):
-
-        """
-        Parameters
-        ----------
-        fun : callable
-            objective function
-
-        x : ndarray
-            Initial state
-
-        args : tuple
-            Initial covariance
-
-        jac : callable
-            Gradient function
-
-        hess : callable
-            Hessian function
-
-        bounds : list, optional
-            (min, max) pairs for each element in x. None is used to specify no bound.
-
-        options : dict
-            Optimization options
-
-            - maxiter: maximum number of iterations (default 10)
-            - restart: restart optimization from a restart file (default false)
-            - restartsave: save a restart file after each successful iteration (defalut false)
-            - tol: convergence tolerance for the objective function (default 1e-6)
-            - alpha: step size for the steepest descent method (default 0.1)
-            - beta: momentum coefficient for running accelerated optimization (default 0.0)
-            - alpha_maxiter: maximum number of backtracing trials (default 5)
-            - resample: number indicating how many times resampling is tried if no improvement is found
-            - optimizer: 'GD' (gradient descent) or Adam (default 'GD')
-            - nesterov: use Nesterov acceleration if true (default false)
-            - hessian: use Hessian approximation (if the algorithm permits use of Hessian) (default false)
-            - normalize: normalize the gradient if true (default true)
-            - cov_factor: factor used to shrink the covariance for each resampling trial (defalut 0.5)
-            - savedata: specify which class variables to save to the result files (state, objective
-                        function value, iteration number, number of function evaluations, and number
-                        of gradient evaluations, are always saved)
-        """
-
-        # init PETEnsemble
-        super(EnOpt, self).__init__(**options)
-
-        def __set__variable(var_name=None, defalut=None):
-            if var_name in options:
-                return options[var_name]
-            else:
-                return defalut
-
-        # Set input as class variables
-        self.options = options  # options
-        self._fun = fun  # objective function
-        self.cov = args[0]  # initial covariance
-        self.jac = jac  # gradient function
-        self.hess = hess  # hessian function
-        self.bounds = bounds  # parameter bounds
-        self.mean_state = x  # initial mean state
-
-        # Set other optimization parameters
-        self.obj_func_tol = __set__variable('tol', 1e-6)
-        self.alpha = __set__variable('step_size', 0.1)
-        self.alpha = __set__variable('alpha', 0.1) # accept either 'step_size' or 'alpha' for step size, 
-                                                                   # with 'alpha' as the default
-        self.alpha_cov = __set__variable('alpha_cov', 0.001)
-        self.beta = __set__variable('beta', 0.0)  # this is stored in the optimizer class
-        self.nesterov = __set__variable('nesterov', False)  # use Nesterov acceleration if value is true
-        self.alpha_iter_max = __set__variable('alpha_maxiter', 5)
-        self.max_resample = __set__variable('resample', 0)
-        self.use_hessian = __set__variable('hessian', False)
-        self.normalize = __set__variable('normalize', True)
-        self.cov_factor = __set__variable('cov_factor', 0.5)
-
-        # Initialize other variables
-        self.state_step = 0  # state step
-        self.cov_step = 0  # covariance step
-
-        # Calculate objective function of startpoint
-        if not self.restart:
-            self.start_time = time.perf_counter()
-            self.obj_func_values = self.fun(self.mean_state, epf=self.epf)
-            self.nfev += 1
-            self.optimize_result = ot.get_optimize_result(self)
-            ot.save_optimize_results(self.optimize_result)
-            if self.logger is not None:
-                self.logger.info('\n\n')
-                self.logger.info('       ====== Running optimization - EnOpt ======')
-                self.logger.info('\n'+pprint.pformat(self.options))
-                info_str = '       {:<10} {:<10} {:<15} {:<15} {:<15} '.format('iter', 'alpha_iter',
-                                                                        'obj_func', 'step-size', 'cov[0,0]')
-                self.logger.info(info_str)
-                self.logger.info('       {:<21} {:<15.4e}'.format(self.iteration, np.mean(self.obj_func_values)))
-
-        # Initialize optimizer
-        optimizer = __set__variable('optimizer', 'GD')
-        if optimizer == 'GD':
-            self.optimizer = opt.GradientDescent(self.alpha, self.beta)
-        elif optimizer == 'Adam':
-            self.optimizer = opt.Adam(self.alpha, self.beta)
-        elif optimizer == 'AdaMax':
-            self.normalize = False
-            self.optimizer = opt.AdaMax(self.alpha, self.beta)
-        elif optimizer == 'Steihaug':
-            self.optimizer = opt.Steihaug(delta0=3.0)
-        else:
-            raise ValueError(f'Optimizer {optimizer} not recognized for EnOpt!')
-
-        # The EnOpt class self-ignites, and it is possible to send the EnOpt class as a callale method to scipy.minimize
-        self.run_loop()  # run_loop resides in the Optimization class (super)
-
-    def fun(self, x, *args, **kwargs):
-        return self._fun(x, *args, **kwargs)
-
-    @property
-    def xk(self):
-        return self.mean_state
-
-    @property
-    def fk(self):
-        return self.obj_func_values
-
-    @property
-    def ftol(self):
-        return self.obj_func_tol
-
-    @ftol.setter
-    def ftol(self, value):
-        self.obj_func_tol = value
-        
-    def calc_update(self):
-        """
-        Update using steepest descent method with ensemble gradients
-        """
-
-        # Initialize variables for this step
-        improvement = False
-        success = False
-        resampling_iter = 0
-        self.optimizer.restore_parameters()
-
-        while not improvement:  # resampling loop
-
-            # Shrink covariance and step size each time we try resampling
-            shrink = self.cov_factor ** resampling_iter
-            self.optimizer.apply_backtracking(np.sqrt(self.cov_factor)** resampling_iter) 
-
-            # Calculate gradient
-            if self.nesterov:
-                gradient = self.jac(self.mean_state + self.beta*self.state_step,
-                                    shrink*(self.cov + self.beta*self.cov_step), epf=self.epf)
-            else:
-                gradient = self.jac(self.mean_state, shrink*self.cov, epf=self.epf)
-            self.njev += 1
-
-            # Compute the hessian
-            hessian = self.hess()
-            if self.use_hessian:
-                inv_hessian = np.linalg.inv(hessian)
-                gradient = inv_hessian @ (self.cov @ self.cov) @ gradient
-                if self.normalize:
-                    hessian /= np.maximum(la.norm(hessian, np.inf), 1e-12)  # scale the hessian with inf-norm
-            elif self.normalize:
-                gradient /= np.maximum(la.norm(gradient, np.inf), 1e-12)  # scale the gradient with inf-norm
-                hessian /= np.maximum(la.norm(hessian, np.inf), 1e-12)  # scale the hessian with inf-norm
-
-            # Initialize for this step
-            alpha_iter = 0
-
-            while not improvement:  # backtracking loop
-
-                new_state, new_step = self.optimizer.apply_update(self.mean_state, gradient,
-                                                                  hessian=hessian, iter=self.iteration)
-                new_state = ot.clip_state(new_state, self.bounds)
-
-                # Calculate new objective function
-                new_func_values = self.fun(new_state, epf=self.epf)
-                self.nfev += 1
-
-                if np.mean(self.obj_func_values) - np.mean(new_func_values) > self.obj_func_tol:
-
-                    # Update objective function values and state
-                    self.obj_func_values = new_func_values
-                    self.mean_state = new_state
-                    self.state_step = new_step
-                    self.alpha = self.optimizer.get_step_size()
-
-                    # Update covariance (currently we don't apply backtracking for alpha_cov)
-                    self.cov_step = self.alpha_cov * hessian + self.beta * self.cov_step
-                    self.cov = self.cov - self.cov_step
-                    self.cov = ot.get_sym_pos_semidef(self.cov)
-
-                    # Write logging info
-                    if self.logger is not None:
-                        info_str_iter = '       {:<10} {:<10} {:<15.4e} {:<15.2e} {:<15.2e}'.\
-                            format(self.iteration, alpha_iter, np.mean(self.obj_func_values),
-                                    self.alpha, self.cov[0, 0])
-                        self.logger.info(info_str_iter)
-
-                    # Update step size in the one-dimensional case
-                    if new_state.size == 1 and hasattr(self.optimizer, 'step_size'):
-                        self.optimizer.step_size /= 2
-
-                    # Iteration was a success
-                    improvement = True
-                    success = True
-                    self.optimizer.restore_parameters()
-
-                    # Save variables defined in savedata keyword.
-                    self.optimize_result = ot.get_optimize_result(self)
-                    ot.save_optimize_results(self.optimize_result)
-
-                    # Update iteration counter if iteration was successful and save current state
-                    self.iteration += 1
-
-                else:
-
-                    # If we do not have a reduction in the objective function, we reduce the step limiter
-                    if alpha_iter < self.alpha_iter_max:
-                        self.optimizer.apply_backtracking()  # decrease alpha
-                        alpha_iter += 1
-                    elif (resampling_iter < self.max_resample and
-                            np.mean(new_func_values) - np.mean(self.obj_func_values) > 0):  # update gradient
-                        resampling_iter += 1
-                        self.optimizer.restore_parameters()
-                        break
-                    else:
-                        success = False
-                        return success
-
-        return success
-
-
-
-
-    
-        
diff --git a/src/popt/update_schemes/genopt.py b/src/popt/update_schemes/genopt.py
deleted file mode 100644
index ef60691f..00000000
--- a/src/popt/update_schemes/genopt.py
+++ /dev/null
@@ -1,245 +0,0 @@
-"""Non-Gaussian generalisation of EnOpt."""
-# External imports
-import numpy as np
-from numpy import linalg as la
-import time
-
-# Internal imports
-from popt.misc_tools import optim_tools as ot
-from popt.loop.optimize import Optimize
-import popt.update_schemes.subroutines.optimizers as opt
-from popt.update_schemes.subroutines.cma import CMA
-
-
-class GenOpt(Optimize):
-    
-    def __init__(self, fun, x, args, jac, jac_mut, corr_adapt=None, bounds=None, **options):
-
-        """
-        Parameters
-        ----------
-        fun : callable
-            objective function
-
-        x : ndarray
-            Initial state
-
-        args : tuple
-            Initial covariance
-
-        jac : callable
-            Gradient function
-
-        jac_mut : callable
-            Mutation gradient function
-        
-        corr_adapt : callable
-            Function for correalation matrix adaption
-
-        bounds : list, optional
-            (min, max) pairs for each element in x. None is used to specify no bound.
-
-        options : dict
-            Optimization options
-        """
-
-        # init PETEnsemble
-        super(GenOpt, self).__init__(**options)
-        
-        def __set__variable(var_name=None, defalut=None):
-            if var_name in options:
-                return options[var_name]
-            else:
-                return defalut
-
-        # Set input as class variables
-        self.options    = options    # options
-        self.function   = fun        # objective function
-        self.jac        = jac        # gradient function
-        self.jac_mut    = jac_mut    # mutation function
-        self.corr_adapt = corr_adapt # correlation adaption function
-        self.bounds     = bounds     # parameter bounds
-        self.mean_state = x          # initial mean state
-        self.theta      = args[0]    # initial theta and correlation
-        self.corr       = args[1]    # inital correlation
-
-        # Set other optimization parameters
-        self.obj_func_tol   = __set__variable('obj_func_tol', 1e-6)
-        self.alpha          = __set__variable('alpha', 0.1)
-        self.alpha_theta    = __set__variable('alpha_theta', 0.1)
-        self.alpha_corr     = __set__variable('alpha_theta', 0.1)
-        self.beta           = __set__variable('beta', 0.0)        # this is stored in the optimizer class
-        self.nesterov       = __set__variable('nesterov', False)  # use Nesterov acceleration if value is true
-        self.alpha_iter_max = __set__variable('alpha_maxiter', 5)
-        self.max_resample   = __set__variable('resample', 0)
-        self.normalize      = __set__variable('normalize', True)
-        self.cov_factor     = __set__variable('cov_factor', 0.5)
-
-        # Initialize other variables
-        self.state_step = 0  # state step
-        self.theta_step = 0  # covariance step
-
-        # Calculate objective function of startpoint
-        if not self.restart:
-            self.start_time = time.perf_counter()
-            self.obj_func_values = self.function(self.mean_state)
-            self.nfev += 1
-            self.optimize_result = ot.get_optimize_result(self)
-            ot.save_optimize_results(self.optimize_result)
-            if self.logger is not None:
-                self.logger.info('       Running optimization...')
-                info_str = '       {:<10} {:<10} {:<15} {:<15} {:<10} {:<10} {:<10} {:<10} '.format('iter', 
-                                                                                                    'alpha_iter',
-                                                                                                    'obj_func', 
-                                                                                                    'step-size', 
-                                                                                                    'alpha0', 
-                                                                                                    'beta0',
-                                                                                                    'max corr',
-                                                                                                    'min_corr')
-                self.logger.info(info_str)
-                self.logger.info('       {:<21} {:<15.4e}'.format(self.iteration, 
-                                                                  round(np.mean(self.obj_func_values),4)))
-
-        # Initialize optimizer
-        optimizer = __set__variable('optimizer', 'GD')
-        if optimizer == 'GD':
-            self.optimizer = opt.GradientDescent(self.alpha, self.beta)
-        elif optimizer == 'Adam':
-            self.optimizer = opt.Adam(self.alpha, self.beta)
-
-        # The GenOpt class self-ignites, and it is possible to send the EnOpt class as a callale method to scipy.minimize
-        self.run_loop()  # run_loop resides in the Optimization class (super)
-
-    def fun(self, x, *args, **kwargs):
-        return self.function(x, *args, **kwargs)
-
-    @property
-    def xk(self):
-        return self.mean_state
-
-    @property
-    def fk(self):
-        return self.obj_func_values
-
-    @property
-    def ftol(self):
-        return self.obj_func_tol
-
-    @ftol.setter
-    def ftol(self, value):
-        self.obj_func_tol = value
-
-    def calc_update(self):
-        """
-        Update using steepest descent method with ensemble gradients
-        """
-
-        # Initialize variables for this step
-        improvement = False
-        success = False
-        resampling_iter = 0
-        self.optimizer.restore_parameters()
-
-        while improvement is False:  # resampling loop
-
-            # Shrink covariance each time we try resampling
-            shrink = self.cov_factor ** resampling_iter
-
-            # Calculate gradient
-            if self.nesterov:
-                gradient = self.jac(self.mean_state + self.beta*self.state_step,
-                                    self.theta + self.beta*self.theta_step, self.corr)
-            else:
-                gradient = self.jac(self.mean_state, self.theta, self.corr)
-            self.njev += 1
-
-            # Compute the mutation gradient
-            gradient_theta, en_matrices = self.jac_mut(return_ensembles=True)
-            if self.normalize:
-                gradient /= np.maximum(la.norm(gradient, np.inf), 1e-12)              # scale the gradient with inf-norm
-                gradient_theta /= np.maximum(la.norm(gradient_theta, np.inf), 1e-12)  # scale the mutation with inf-norm
-
-            # Initialize for this step
-            alpha_iter = 0
-
-            while improvement is False:  # backtracking loop
-
-                new_state, new_step = self.optimizer.apply_update(self.mean_state, gradient, iter=self.iteration)
-                new_state = ot.clip_state(new_state, self.bounds)
-
-                # Calculate new objective function
-                new_func_values = self.function(new_state)
-                self.nfev += 1
-
-                if np.mean(self.obj_func_values) - np.mean(new_func_values) > self.obj_func_tol:
-
-                    # Update objective function values and state
-                    self.obj_func_values = new_func_values
-                    self.mean_state = new_state
-                    self.state_step = new_step
-                    self.alpha = self.optimizer.get_step_size()
-
-                    # Update theta (currently we don't apply backtracking for theta)
-                    self.theta_step = self.beta*self.theta_step - self.alpha_theta*gradient_theta
-                    self.theta = self.theta + self.theta_step
-
-                    # update correlation matrix
-                    if isinstance(self.corr_adapt, CMA):
-                        enZ = en_matrices['gaussian']
-                        enJ = en_matrices['objective']
-                        self.corr = self.corr_adapt(cov  = self.corr, 
-                                                    step = new_step/self.alpha, 
-                                                    X = enZ, 
-                                                    J = enJ)
-                        
-                    elif callable(self.corr_adapt):
-                        self.corr = self.corr - self.alpha_corr*self.corr_adapt()
-                    
-                    # Write logging info
-                    if self.logger is not None:
-                        corr_max = round(np.max(self.corr-np.eye(self.corr.shape[0])), 3)
-                        corr_min = round(np.min(self.corr), 3)
-                        info_str_iter = '       {:<10} {:<10} {:<15.4e} {:<15} {:<10} {:<10} {:<10} {:<10}'.\
-                                        format(self.iteration,
-                                               alpha_iter, 
-                                               round(np.mean(self.obj_func_values),4),
-                                               self.alpha, 
-                                               round(self.theta[0, 0],2), 
-                                               round(self.theta[0, 1],2),
-                                               corr_max, 
-                                               corr_min)
-                        
-                        self.logger.info(info_str_iter)
-
-                    # Update step size in the one-dimensional case
-                    if new_state.size == 1:
-                        self.optimizer.step_size /= 2
-
-                    # Iteration was a success
-                    improvement = True
-                    success = True
-                    self.optimizer.restore_parameters()
-
-                    # Save variables defined in savedata keyword.
-                    self.optimize_result = ot.get_optimize_result(self)
-                    ot.save_optimize_results(self.optimize_result)
-
-                    # Update iteration counter if iteration was successful and save current state
-                    self.iteration += 1
-
-                else:
-
-                    # If we do not have a reduction in the objective function, we reduce the step limiter
-                    if alpha_iter < self.alpha_iter_max:
-                        self.optimizer.apply_backtracking()  # decrease alpha
-                        alpha_iter += 1
-                    elif (resampling_iter < self.max_resample and
-                            np.mean(new_func_values) - np.mean(self.obj_func_values) > 0):  # update gradient
-                        resampling_iter += 1
-                        self.optimizer.restore_parameters()
-                        break
-                    else:
-                        success = False
-                        return success
-
-        return success
diff --git a/src/popt/update_schemes/linesearch.py b/src/popt/update_schemes/linesearch.py
deleted file mode 100644
index b78a88ed..00000000
--- a/src/popt/update_schemes/linesearch.py
+++ /dev/null
@@ -1,598 +0,0 @@
-# External imports
-import numpy as np
-import time
-import pprint
-import warnings
-
-from numpy import linalg as la
-from scipy.optimize import OptimizeResult
-
-# Internal imports
-from popt.misc_tools import optim_tools as ot
-from popt.loop.optimize import Optimize
-from popt.update_schemes.subroutines import line_search, line_search_backtracking, bfgs_update, newton_cg
-
-# Some symbols for logger
-subk = '\u2096'
-sup2 = '\u00b2'
-jac_inf_symbol = f'‖jac(x{subk})‖\u221E'
-fun_xk_symbol  = f'fun(x{subk})'
-nabla_symbol = "\u2207"
-
-
-def LineSearch(fun, x, jac, method='GD', hess=None, args=(), bounds=None, callback=None, **options):
-    '''
-    A Line Search Optimizer.
-
-    Parameters
-    ----------
-    fun: callable
-        Objective function, fun(x, *args).
-    
-    x: ndarray
-        Initial control vector.
-
-    jac: callable
-        Jacobian/Gradient function, jac(x, *args)
-    
-    method: str
-        Which optimization method to use. Default is 'GD' for 'Gradient Descent'.
-        Other options are 'BFGS' for the 'Broyden-Fletcher-Goldfarb-Shanno' method,
-        and 'Newton-CG' for the Newton-conjugate gradient method.  
-    
-    hess: callable, optional
-        Hessian function, hess(x, *args). Default is None. 
-    
-    args: tuple, optional
-        Args passed to fun, jac and hess.
-
-    bounds: list, optional
-        (min, max) pairs for each element in x. None is used to specify no bound.
-    
-    callback: callable, optional
-        A callable called after each successful iteration. The class instance of LineSearch 
-        is passed as the only argument to the callback function: callback(self) 
-    
-    **options: 
-        keyword arguments, optional
-
-    
-    LineSearch Options (**options)
-    ------------------------------
-    - maxiter: int,
-        Maximum number of iterations. Default is 20.
-    
-    - lsmaxiter: int,
-        Maximum number of iterations for the line search. Default is 10.
-    
-    - step_size: float,
-        Step-size for optimizer. Default is 0.25/inf-norm(jac(x0)).
-
-    - step_size_max: float,
-        Maximum step-size. Default is 1e5. If bounds are specified, 
-        the maximum step-size is set to the maximum step-size allowed by the bounds.
-
-    - step_size_adapt: int,
-        Set method for choosing initial step-size for each iteration. If 0, step_size value is used.
-        If 1, Equation (3.6) from "Numercal Optimization" [1] is used. If 2, the equation above Equation (3.6) is used. 
-        Default is 0.
-                    
-    - c1: float,
-        Tolerance parameter for the Armijo condition. Default is 1e-4.
-
-    - c2: float,
-        Tolerance parameter for the Curvature condition. Default is 0.9.
-
-    - xtol: float,
-        Optimization stop whenever |dx|>> import numpy as np
-    >>> from scipy.optimize import rosen, rosen_der
-    >>> from popt.update_schemes.linesearch import LineSearch
-    >>> x0 = np.random.uniform(-3, 3, 2)
-    >>> kwargs = {'maxiter': 100,
-                  'lsmaxiter': 10,
-                  'step_size_adapt': 1,
-                  'saveit': False}
-    >>> res = LineSearch(fun=rosen, x=x0, jac=rosen_der, method='BFGS', **kwargs)
-    >>> print(res)
-    '''
-    ls_obj = LineSearchClass(
-        fun, 
-        x, 
-        jac, 
-        method, 
-        hess, 
-        args, 
-        bounds, 
-        callback, 
-        **options
-    )
-    return ls_obj.optimize_result
-
-
-class LineSearchClass(Optimize):
-
-    def  __init__(self, fun, x, jac, method='GD', hess=None, args=(), bounds=None, callback=None, **options):
-
-        # init PETEnsemble
-        super(LineSearchClass, self).__init__(**options)
-
-        # Set input as class variables
-        self._xk      = x
-        self.function = fun
-        self.jacobian = jac     
-        self.method   = method  
-        self.hessian  = hess     
-        self.args     = args
-        self.bounds   = bounds  
-        self.options  = options 
-
-        # Check for Callback function
-        if callable(callback):
-            self.callback = callback
-        else:
-            self.callback = None
-
-        # Remove 'datatype' from options if present (This is a temporary bugfix)
-        self.options.pop('datatype', None)
-
-        # Custom convergence criteria (callable)
-        convergence_criteria = options.get('convergence_criteria', None)
-        if callable(convergence_criteria):
-            self.convergence_criteria = self.convergence_criteria
-        else:
-            self.convergence_criteria = None
-        
-        # Set options for step-size
-        self.step_size       = options.get('step_size', None)
-        self.step_size_max   = options.get('step_size_max', 1e5)
-        self.step_size_adapt = options.get('step_size_adapt', 0)
-
-        # Set options for line-search 
-        self.lskwargs = {
-            'c1': options.get('c1', 1e-4),
-            'c2': options.get('c2', 0.9),
-            'rho': options.get('rho', 0.5),
-            'amax': self.step_size_max,
-            'maxiter': options.get('lsmaxiter', 10),
-            'method' : options.get('lsmethod', 1),
-            'logger' : self.logger
-        }
-
-        # Set other options
-        self.normalize = options.get('normalize', False)
-        self.resample  = options.get('resample', 0)
-        self.saveit    = options.get('saveit', True)
-
-        # set tolerance for convergence
-        self._xtol = options.get('xtol', 1e-8) # tolerance for control vector
-        self._ftol = options.get('ftol', 1e-4) # relative tolerance for function value
-        self._gtol = options.get('gtol', 1e-5) # tolerance for inf-norm of jacobian
-
-        # Check method
-        valid_methods = ['GD', 'BFGS', 'Newton-CG']
-        if not self.method in valid_methods:
-            raise ValueError(f"'{self.method}' is not a valid method. Valid methods are: {valid_methods}")
-        
-        if (self.method == 'Newton-CG') and (self.hessian is None):
-            print(f'Warning: No hessian function provided. Finite difference approximation is used: {nabla_symbol}{sup2}f(x{subk})d ≈ ({nabla_symbol}f(x{subk}+hd)-{nabla_symbol}f(x{subk}))/h')
-
-        # Calculate objective function of startpoint
-        if not self.restart:
-            self.start_time = time.perf_counter()
-
-            # Check for initial callable values
-            self._fk = options.get('fun0', None)
-            self._jk = options.get('jac0', None)
-            self._Hk = options.get('hess0', None)
-
-            if self._fk is None: self._fk = self.fun(self._xk)
-            if self._jk is None: self._jk = self.jac(self._xk)
-            if self._Hk is None: self._Hk = self.hess(self._xk)
-
-            # Check for initial inverse hessian for the BFGS method
-            if self.method == 'BFGS':
-                self._Hk_inv = options.get('hess0_inv', np.eye(x.size))
-            else:
-                self._Hk_inv = None
-
-            # Initialize some variables
-            self.f_old = None
-            self.j_old = None
-            self.p_old = None
-        
-            # Initial results
-            self.optimize_result = ot.get_optimize_result(self)
-            if self.saveit:
-                ot.save_optimize_results(self.optimize_result)
-            if self.logger is not None:
-                self.logger(f'========== Running optimization - Line search ({method}) ==========')
-                self.logger(f'\n \nUSER-SPECIFIED OPTIONS:\n{pprint.pformat(OptimizeResult(self.options))}\n')
-                self.logger(**{
-                    'iter.': 0,
-                    fun_xk_symbol: self._fk,
-                    jac_inf_symbol: la.norm(self._jk, np.inf),
-                    'step-size': self.step_size
-                })
-
-        self.run_loop() 
-
-    def fun(self, x, *args, **kwargs):
-        self.nfev += 1
-        x = ot.clip_state(x, self.bounds) # ensure bounds are respected
-        if self.args is None:
-            f = np.mean(self.function(x, epf=self.epf))
-        else:
-            f = np.mean(self.function(x, *self.args, epf=self.epf))
-        return f
-
-    @property
-    def xk(self):
-        return self._xk
-
-    @property
-    def fk(self):
-        return self._fk
-
-    @property
-    def ftol(self):
-        return self._ftol
-
-    @ftol.setter
-    def ftol(self, value):
-        self._ftol = value
-
-    def jac(self, x):
-        self.njev += 1
-        x = ot.clip_state(x, self.bounds) # ensure bounds are respected
-        if self.args is None:
-            g = self.jacobian(x, epf=self.epf)
-        else:
-            g = self.jacobian(x, *self.args, epf=self.epf)
-
-        # project gradient onto the feasible set
-        if self.bounds is not None:
-            g = - self._project_pk(-g, x)
-
-        return g
-    
-    def hess(self, x):
-        if self.hessian is None:
-            return None
-    
-        x = ot.clip_state(x, self.bounds) # ensure bounds are respected
-        if self.args is None:
-            h = self.hessian(x)
-        else:
-            h = self.hessian(x, *self.args)
-        return h
-    
-    
-    def calc_update(self, iter_resamp=0):
-
-        # Initialize variables for this step
-        success = False
-
-        # If in resampling mode, compute jacobian
-        # Else, jacobian from in __init__ or from latest line_search is used
-        if self._jk is None:
-            self._jk = self.jac(self._xk)
-
-        # Compute hessian
-        if (self.iteration != 1) or (iter_resamp > 0):
-            self._Hk = self.hess(self._xk)
-
-        # Check normalization
-        if self.normalize:
-            self._jk = self._jk/la.norm(self._jk, np.inf)
-            if not self._Hk is None:
-                self._Hk = self._Hk/np.maximum(la.norm(self._Hk, np.inf), 1e-12)
-
-        # Calculate search direction (pk)
-        if self.method == 'GD':
-            pk = - self._jk
-        if self.method == 'BFGS':
-            pk = - np.matmul(self._Hk_inv, self._jk)
-        if self.method == 'Newton-CG':
-            pk = newton_cg(self._jk, Hk=self._Hk, xk=self._xk, jac=self.jac, logger=self.logger)
-
-        # porject search direction onto the feasible set
-        if self.bounds is not None:
-            pk = self._project_pk(pk, self._xk)
-        
-        # Set step_size
-        if self.bounds is not None:
-            self.step_size_max = self._set_max_step_size(pk, self._xk)
-            self.lskwargs['amax'] = self.step_size_max
-        step_size = self._set_step_size(pk, self.step_size_max)
-
-        # Perform line-search 
-        if self.lskwargs['method'] == 0:
-            ls_res = line_search_backtracking(
-                step_size=step_size,
-                xk=self._xk,
-                pk=pk,
-                fun=self.fun,
-                jac=self.jac,
-                fk=self._fk,
-                jk=self._jk,
-                **self.lskwargs
-            )
-        else:
-            ls_res = line_search(
-                step_size=step_size,
-                xk=self._xk,
-                pk=pk,
-                fun=self.fun,
-                jac=self.jac,
-                fk=self._fk,
-                jk=self._jk,
-                **self.lskwargs
-            )
-        step_size, f_new, j_new, _, _ = ls_res
-    
-        if not (step_size is None):
-        
-            # Save old values
-            x_old = self._xk
-            j_old = self._jk
-            f_old = self._fk
-
-            # Update control
-            x_new = ot.clip_state(x_old + step_size*pk, self.bounds)
-
-            # Update state
-            self._xk = x_new
-            self._fk = f_new
-            self._jk = j_new
-            
-            # Update old fun, jac and pk values
-            self.j_old = j_old
-            self.f_old = f_old
-            self.p_old = pk
-            sk = x_new - x_old
-
-            # Call the callback function
-            if callable(self.callback):
-                self.callback(self) 
-
-            # Update BFGS
-            if self.method == 'BFGS':
-                yk = j_new - j_old
-                if self.iteration == 1: self._Hk_inv = np.dot(yk,sk)/np.dot(yk,yk) * np.eye(sk.size)
-                self._Hk_inv = bfgs_update(self._Hk_inv, sk, yk)
-
-            # Update status
-            success = True
-
-            # Save Results
-            self.optimize_result = ot.get_optimize_result(self)
-            if self.saveit:
-                ot.save_optimize_results(self.optimize_result)
-
-            # Write logging info
-            if self.logger is not None:
-                self.logger(**{
-                    'iter.': self.iteration,
-                    fun_xk_symbol: self._fk,
-                    jac_inf_symbol: la.norm(self._jk, np.inf),
-                    'step-size': step_size
-                })
-            
-            # Check for convergence
-            if (la.norm(sk, np.inf) < self._xtol):
-                self.msg = 'Convergence criteria met: |dx| < xtol'
-                self.logger.info(self.msg)
-                success = False
-                return success
-            if (np.abs(self._fk - f_old) < self._ftol * np.abs(f_old)):
-                self.msg = 'Convergence criteria met: |f(x+dx) - f(x)| < ftol * |f(x)|'
-                self.logger.info(self.msg)
-                success = False
-                return success
-            if (la.norm(self._jk, np.inf) < self._gtol):
-                self.msg = f'Convergence criteria met: {jac_inf_symbol} < gtol'
-                self.logger.info(self.msg)
-                success = False
-                return success
-
-            # Check for custom convergence
-            if callable(self.convergence_criteria):
-                if self.convergence_criteria(self):
-                    self.logger('Custom convergence criteria met. Stopping optimization.')
-                    success = False
-                    return success
-
-            if self.step_size_adapt == 2:
-                self.step_size = step_size
-
-            # Update iteration
-            self.iteration += 1
-        
-        else:
-            if iter_resamp < self.resample:
-
-                self.logger('Resampling Gradient')
-                iter_resamp += 1
-                self._jk = None
-
-                # Recursivly call function
-                success = self.calc_update(iter_resamp=iter_resamp)
-
-            else:
-                success = False
-    
-        return success
-    
-    def get_intermediate_results(self):
-
-        # Obsolete: use get_optimize_result in optim_tools
-
-        # Define default results
-        results = {
-            'fun': self._fk,
-            'x': self._xk, 
-            'jac': self._jk,
-            'nfev': self.nfev,
-            'njev': self.njev,
-            'nit': self.iteration,
-            'method': self.method,
-            'save_folder': self.options.get('save_folder', './')
-        }
-
-        if 'savedata' in self.options:
-            # Make sure "SAVEDATA" gives a list
-            if isinstance(self.options['savedata'], list):
-                savedata = self.options['savedata']
-            else:
-                savedata = [self.options['savedata']]
-
-            if 'args' in savedata:
-                for a, arg in enumerate(self.args):
-                    results[f'args[{a}]'] = arg
-
-            # Loop over variables to store in save list
-            for variable in savedata:
-                if variable in locals():
-                    results[variable] = eval('{}'.format(variable))
-                elif hasattr(self, variable):
-                    results[variable] = eval('self.{}'.format(variable))
-                else:
-                    print(f'Cannot save {variable}!\n\n')
-
-        return OptimizeResult(results)
-    
-    def _set_step_size(self, pk, amax):
-        ''' Sets the step-size '''
-
-        # If first iteration
-        if (self.iteration == 1):
-            if (self.step_size is None):
-                self.step_size = 0.25/la.norm(pk, np.inf)
-                alpha = self.step_size
-            else:
-                alpha = self.step_size
-
-        else:
-            if (self.step_size_adapt == 1) and (np.dot(pk, self._jk) != 0):
-                alpha = 2*(self._fk - self.f_old)/np.dot(pk, self._jk)
-            elif (self.step_size_adapt == 2) and (np.dot(pk, self._jk) != 0):
-                slope_old = np.dot(self.p_old, self.j_old)
-                slope_new = np.dot(pk, self._jk)
-                alpha = self.step_size*slope_old/slope_new
-            else:
-                alpha = self.step_size
-
-        if alpha < 0: 
-            alpha = abs(alpha)
-
-        if alpha >= amax:
-            alpha = 0.75*amax
-        
-        return alpha
-    
-    def _project_pk(self, pk, xk):
-        ''' Projects the jacobian onto the feasible set defined by bounds '''
-        lb = np.array(self.bounds)[:, 0]
-        ub = np.array(self.bounds)[:, 1]
-        for i, pk_val in enumerate(pk):
-            if (xk[i] <= lb[i] and pk_val < 0) or (xk[i] >= ub[i] and pk_val > 0):
-                pk[i] = 0
-        return pk
-    
-    def _set_max_step_size(self, pk, xk):
-        lb = np.array(self.bounds)[:, 0]
-        ub = np.array(self.bounds)[:, 1]
-
-        amax = []
-        for i, pk_val in enumerate(pk):
-            if pk_val < 0:
-                amax.append((lb[i] - xk[i])/pk_val)
-            elif pk_val > 0:
-                amax.append((ub[i] - xk[i])/pk_val)
-            else:
-                continue
-
-        return max(amax)
-
-
-
-                
-
-            
-
-
-
-
-
-
-    
-
-
-
diff --git a/src/popt/update_schemes/smcopt.py b/src/popt/update_schemes/smcopt.py
deleted file mode 100644
index 981cbcb3..00000000
--- a/src/popt/update_schemes/smcopt.py
+++ /dev/null
@@ -1,198 +0,0 @@
-"""Stochastic Monte-Carlo optimisation."""
-# External imports
-import numpy as np
-import time
-import pprint
-
-# Internal imports
-from popt.loop.optimize import Optimize
-import popt.update_schemes.subroutines.optimizers as opt
-from popt.misc_tools import optim_tools as ot
-
-
-class SmcOpt(Optimize):
-    """
-    TODO: Write docstring ala EnOpt
-    """
-
-    def __init__(self, fun, x, args, sens, bounds=None, **options):
-        """
-        Parameters
-        ----------
-        fun : callable
-            objective function
-
-        x : ndarray
-            Initial state
-
-        sens : callable
-            Ensemble sensitivity
-
-        bounds : list, optional
-            (min, max) pairs for each element in x. None is used to specify no bound.
-
-        options : dict
-            Optimization options
-
-            - maxiter: maximum number of iterations (default 10)
-            - restart: restart optimization from a restart file (default false)
-            - restartsave: save a restart file after each successful iteration (defalut false)
-            - tol: convergence tolerance for the objective function (default 1e-6)
-            - alpha: weight between previous and new step (default 0.1)
-            - alpha_maxiter: maximum number of backtracing trials (default 5)
-            - resample: number indicating how many times resampling is tried if no improvement is found
-            - cov_factor: factor used to shrink the covariance for each resampling trial (defalut 0.5)
-            - inflation_factor: term used to weight down prior influence (defalult 1)
-            - survival_factor: fraction of surviving samples
-            - savedata: specify which class variables to save to the result files (state, objective function
-                        value, iteration number, number of function evaluations, and number of gradient
-                        evaluations, are always saved)
-        """
-
-        # init PETEnsemble
-        super(SmcOpt, self).__init__(**options)
-
-        def __set__variable(var_name=None, defalut=None):
-            if var_name in options:
-                return options[var_name]
-            else:
-                return defalut
-
-        # Set input as class variables
-        self.options = options  # options
-        self.function = fun  # objective function
-        self.sens = sens  # gradient function
-        self.bounds = bounds  # parameter bounds
-        self.mean_state = x  # initial mean state
-        self.best_state = None  # best ensemble member
-        self.cov = args[0]  # covariance matrix for sampling
-
-        # Set other optimization parameters
-        self.obj_func_tol = __set__variable('tol', 1e-6)
-        self.alpha = __set__variable('alpha', 0.1)
-        self.alpha_iter_max = __set__variable('alpha_maxiter', 5)
-        self.max_resample = __set__variable('resample', 0)
-        self.cov_factor = __set__variable('cov_factor', 0.5)
-        self.inflation_factor = __set__variable('inflation_factor', 1.0)
-        self.survival_factor = __set__variable('survival_factor', 1.0)
-        self.survival_factor = np.clip(self.survival_factor,0.1, 1.0)
-
-        # Calculate objective function of startpoint
-        if not self.restart:
-            self.start_time = time.perf_counter()
-            self.obj_func_values = self.function(self.mean_state)
-            self.best_func = np.mean(self.obj_func_values)
-            self.nfev += 1
-            self.optimize_result = ot.get_optimize_result(self)
-            ot.save_optimize_results(self.optimize_result)
-            if self.logger is not None:
-                self.logger.info('       ====== Running optimization - SmcOpt ======')
-                self.logger.info('\n' + pprint.pformat(self.options))
-                info_str = '       {:<10} {:<10} {:<15} {:<15} '.format('iter', 'alpha_iter',
-                                                                           'obj_func', 'step-size')
-                self.logger.info(info_str)
-                self.logger.info('       {:<21} {:<15.4e}'.format(self.iteration, np.mean(self.obj_func_values)))
-
-        self.optimizer = opt.GradientDescent(self.alpha, 0)
-
-        # The SmcOpt class self-ignites
-        self.run_loop()  # run_loop resides in the Optimization class (super)
-
-    def fun(self, x, *args, **kwargs):
-        return self.function(x, *args, **kwargs)
-
-    @property
-    def xk(self):
-        return self._xk
-
-    @property
-    def fk(self):
-        return self.obj_func_values
-
-    @property
-    def ftol(self):
-        return self.obj_func_tol
-
-    @ftol.setter
-    def ftol(self, value):
-        self.obj_func_tol = value
-
-    def calc_update(self,):
-        """
-        Update using sequential monte carlo method
-        """
-
-        improvement = False
-        success = False
-        resampling_iter = 0
-        inflate = 2 * (self.inflation_factor + self.iteration)
-        self.optimizer.restore_parameters()
-
-        while improvement is False:  # resampling loop
-
-            # Shrink covariance and step size each time we try resampling
-            shrink = self.cov_factor ** resampling_iter
-            self.optimizer.apply_backtracking(np.sqrt(self.cov_factor) ** resampling_iter)
-
-            # Calc sensitivity
-            (sens_matrix, self.best_state, best_func_tmp) = self.sens(self.mean_state, inflate,
-                                                                      shrink*self.cov, self.survival_factor)
-            self.njev += 1
-
-            # Initialize for this step
-            alpha_iter = 0
-
-            while improvement is False:  # backtracking loop
-
-                search_direction = sens_matrix
-                new_state = self.optimizer.apply_smc_update(self.mean_state, search_direction, iter=self.iteration)
-                new_state = ot.clip_state(new_state, self.bounds)
-
-                # Calculate new objective function
-                new_func_values = self.function(new_state)
-                self.nfev += 1
-
-                if np.mean(self.obj_func_values) - np.mean(new_func_values) > self.obj_func_tol or \
-                          (self.best_func - best_func_tmp) > self.obj_func_tol:
-
-                    # Update objective function values and step
-                    self.obj_func_values = new_func_values
-                    self.mean_state = new_state
-                    if (self.best_func - best_func_tmp) > self.obj_func_tol:
-                        self.best_func = best_func_tmp
-
-                    # Write logging info
-                    if self.logger is not None:
-                        info_str_iter = '       {:<10} {:<10} {:<15.4e} {:<15.2e}'. \
-                            format(self.iteration, alpha_iter, self.best_func,
-                                   self.alpha)
-                        self.logger.info(info_str_iter)
-
-                    # Iteration was a success
-                    improvement = True
-                    success = True
-                    self.optimizer.restore_parameters()
-
-                    # Save variables defined in savedata keyword.
-                    self.optimize_result = ot.get_optimize_result(self)
-                    ot.save_optimize_results(self.optimize_result)
-
-                    # Update iteration counter if iteration was successful and save current state
-                    self.iteration += 1
-
-                else:
-
-                    # If we do not have a reduction in the objective function, we reduce the step limiter
-                    if alpha_iter < self.alpha_iter_max:
-                        self.optimizer.apply_backtracking()  # decrease alpha
-                        alpha_iter += 1
-                    elif (resampling_iter < self.max_resample and
-                          np.mean(new_func_values) - np.mean(self.obj_func_values) > 0):  # update gradient
-                        resampling_iter += 1
-                        self.optimizer.restore_parameters()
-                        break
-                    else:
-                        success = False
-                        return success
-
-        return success
diff --git a/src/popt/update_schemes/subroutines/__init__.py b/src/popt/update_schemes/subroutines/__init__.py
deleted file mode 100644
index eab7b843..00000000
--- a/src/popt/update_schemes/subroutines/__init__.py
+++ /dev/null
@@ -1,3 +0,0 @@
-from .subroutines import *
-from .cma import *
-from .optimizers import *
\ No newline at end of file
diff --git a/src/popt/update_schemes/trust_region.py b/src/popt/update_schemes/trust_region.py
deleted file mode 100644
index e0a21413..00000000
--- a/src/popt/update_schemes/trust_region.py
+++ /dev/null
@@ -1,546 +0,0 @@
-# External imports
-import numpy as np
-import time
-import pprint
-import warnings
-
-from numpy import linalg as la
-from scipy.optimize import OptimizeResult
-
-# Internal imports
-from popt.misc_tools import optim_tools as ot
-from popt.loop.optimize import Optimize
-from popt.update_schemes.subroutines.subroutines import solve_trust_region_subproblem
-
-# Some symbols for logger
-subk = '\u2096'
-fun_xk_symbol  = f'fun(x{subk})'
-delta_k_symbol = f'\u0394{subk}'
-rho_symbol     = f'\u03C1{subk}'
-
-check_symbol = '\u2713'
-cross_symbol = '\u2717'
-
-def TrustRegion(fun, x, jac, hess, method='iterative', args=(), bounds=None, callback=None, **options):
-    '''
-    Trust region optimization algorithm.
-
-    Parameters
-    ----------
-    fun : callable
-        Objective function to be minimized. The calling signature is `fun(x, *args)`.
-
-    x : array_like
-        Initial guess.
-    
-    jac : callable
-        Gradient (Jacobian) of objective function. The calling signature is `jac(x, *args)`.
-    
-    hess : callable
-        Hessian of objective function. The calling signature is `hess(x, *args)`.
-
-    method : str, optional
-        Method to use for solving the trust-region subproblem. Options are 'iterative' or 'CG-Steihaug'.
-        Default is 'iterative'.
-    
-    args : tuple, optional
-        Extra arguments passed to the objective function and its derivatives (Jacobian, Hessian).
-    
-    bounds : sequence, optional
-        Bounds for variables. Each element of the sequence must be a tuple of two scalars, 
-        representing the lower and upper bounds for that variable. Use None for one of the bounds if there are no bounds.
-        Bounds are handle by clipping the state to the bounds before evaluating the objective function and its derivatives.
-    
-    callback: callable, optional
-        A callable called after each successful iteration. The class instance 
-        is passed as the only argument to the callback function: callback(self) 
-
-    **options : keyword arguments, optional
-
-    TrustRegion Options (**options)
-    -------------------------------
-    maxiter: int
-        Maximum number of iterations. Default is 20.
-    
-    trust_radius: float
-        Inital trust-region radius. Default is 1.0.
-    
-    trust_radius_max: float
-        Maximum trust-region radius. Default is 10 times initial trust_radius.
-    
-    trust_radius_min: float
-        Minimum trust-region radius. Optimization is terminated if trust_radius = trust_radius_min.
-        Default is trust_radius/100.
-    
-    trust_radius_cuts: int
-        Number of allowed trust-region radius reductions if a step is not successful. Default is 4.
-    
-    rho_tol: float
-        Tolerance for rho (ratio of actual to predicted reduction). Default is 1e-6.
-        
-    eta1, eta2, gam1, gam2: float
-        Parameters for updateing the trust-region radius.
-
-        Δnew = max(gam2*Δold, Δmax)   if rho >= eta2. \n
-        Δnew = Δold                   if eta1 <= rho < eta2. \n
-        Δnew = gam1*Δold              if rho < eta1. \n
-
-        Defults:
-            eta1 = 0.001 \n
-            eta2 = 0.1 \n
-            gam1 = 0.7 \n
-            gam2 = 1.5 \n
-    
-    saveit: bool
-        If True, save the optimization results to a file. Default is True.
-    
-    convergence_criteria: callable
-        A callable that takes the current optimization object as an argument and returns True if the optimization should stop.
-        It can be used to implement custom convergence criteria. Default is None.
-
-    save_folder: str
-        Name of folder to save the results to. Defaul is ./ (the current directory).
-
-    fun0: float
-        Function value of the intial control.
-
-    jac0: ndarray
-        Jacobian of the initial control.
-    
-    hess0: ndarray
-        Hessian value of the initial control.
-
-    resample: bool
-        If True, resample the Jacobian and Hessian if a step is not successful. Default is False.
-        (Only makes sense if the Jacobian and Hessian are stochastic).
-
-    savedata: list[str]
-        Further specification of which class variables to save to the result files.
-
-    restart: bool
-        Restart optimization from a restart file. Default is False
-
-    restartsave: bool
-        Save a restart file after each successful iteration. Default is False
-
-
-    Returns
-    -------
-    OptimizeResult
-        The optimization result represented as a OptimizeResult object.
-        Important attributes:
-        - x: optimized control
-        - fun: objective function value
-        - nfev: number of function evaluations
-        - njev: number of jacobian evaluations
-    '''
-    tr_obj = TrustRegionClass(fun, x, jac, hess, method, args, bounds, callback, **options)
-    return tr_obj.optimize_result
-
-class TrustRegionClass(Optimize):
-
-    def __init__(self, fun, x, jac, hess, method='iterative', args=(), bounds=None, callback=None, **options):
-        
-        # Initialize the parent class
-        super().__init__(**options)
-
-        # Set class attributes
-        self.function = fun
-        self._xk      = x
-        self.jacobian = jac
-        self.hessian  = hess
-        self.method   = method
-        self.args     = args
-        self.bounds   = bounds
-        self.options  = options
-
-        # Check if the callback function is callable
-        if callable(callback):
-            self.callback = callback
-        else:
-            self.callback = None
-
-        # Custom convergence criteria (callable)
-        convergence_criteria = options.get('convergence_criteria', None)
-        if callable(convergence_criteria):
-            self.convergence_criteria = convergence_criteria
-        else:
-            self.convergence_criteria = None
-
-        # Set options for trust-region radius       
-        self.trust_radius      = options.get('trust_radius', 1.0) 
-        self.trust_radius_max  = options.get('trust_radius_max', 100*self.trust_radius)
-        self.trust_radius_min  = options.get('trust_radius_min', self.trust_radius/1000)
-        self.trust_radius_cuts = options.get('trust_radius_cuts', 4)
-
-        # Set other options
-        self.resample = options.get('resample', False)
-        self.saveit   = options.get('saveit', True)
-        self.rho_tol  = options.get('rho_tol', 1e-6)
-        self.eta1 = options.get('eta1', 0.05) # reduce raduis if rho < 5%
-        self.eta2 = options.get('eta2', 0.5)  # increase radius if rho > 50% 
-        self.gam1 = options.get('gam1', 0.5)  # reduce by 50%
-        self.gam2 = options.get('gam2', 1.5)  # increase by 50%
-        self.rho  = 0.0
-
-        # set tolerance for convergence
-        self._xtol = options.get('xtol', 1e-8) # tolerance for control vector
-        self._ftol = options.get('ftol', 1e-4) # relative tolerance for function value
-        self._gtol = options.get('gtol', 1e-5) # tolerance for inf-norm of jacobian
-
-        # Check if method is valid
-        if callable(self.method):
-            self.logger(f'Method is a callable!. Using custom subproblem solver.')
-        elif isinstance(self.method, str):
-            if self.method not in ['iterative', 'CG-Steihaug']:
-                self.method = 'iterative'
-                self.logger(f'Method {self.method} is not valid!. Method is set to "iterative"')
-        else:
-            self.logger(f'Method is a string or callable!. Method is set to "iterative"')
-            self.method = 'iterative'
-
-    
-        if not self.restart:
-            self.start_time = time.perf_counter()
-
-            # Check for initial callable values
-            self._fk = options.get('fun0', None)
-            self._jk = options.get('jac0', None)
-            self._Hk = options.get('hess0', None)
-
-            if self.hessian == 'BFGS':
-                self.hessian = None
-                self.quasi_newton = True
-                self.logger('Hessian approximation set to BFGS.')
-            else:
-                self.quasi_newton = False
-
-            if self._fk is None: self._fk = self.fun(self._xk)
-            if self._jk is None: self._jk = self.jac(self._xk)
-            if self._Hk is None: self._Hk = self.hess(self._xk)
-
-            if self.logger is not None:
-                self.logger('================= Running Optimization - Trust Region =================')
-                self.logger(f'\n \nUSER-SPECIFIED OPTIONS:\n{pprint.pformat(OptimizeResult(self.options))}\n')
-                info = {
-                    'Iter.': self.iteration,
-                    fun_xk_symbol: self._fk,
-                    f'{delta_k_symbol}': self.trust_radius,
-                    f'{rho_symbol}': self.rho,
-                    f'|p{subk}| = {delta_k_symbol}': 'N/A',
-                }
-                self.logger(**info)
-            
-
-            # Initial results
-            self.optimize_result = self.get_intermediate_results()
-            if self.saveit:
-                ot.save_optimize_results(self.optimize_result)
-
-        # Run the optimization
-        self.run_loop()
-
-    def fun(self, x, *args, **kwargs):
-        self.nfev += 1
-
-        if self.bounds is not None:
-            lb = np.array(self.bounds)[:, 0]
-            ub = np.array(self.bounds)[:, 1]
-            x = np.clip(x, lb, ub)  # ensure bounds are respected
-            
-        if self.args is None:
-            f = np.mean(self.function(x, epf=self.epf))
-        else:
-            f = np.mean(self.function(x, *self.args, epf=self.epf))
-        return f
-
-    @property
-    def xk(self):
-        return self._xk
-
-    @property
-    def fk(self):
-        return self._fk
-
-    @property
-    def ftol(self):
-        return self.obj_func_tol
-
-    @ftol.setter
-    def ftol(self, value):
-        self.obj_func_tol = value
-
-    def jac(self, x):
-        self.njev += 1
-        
-        if self.bounds is not None:
-            lb = np.array(self.bounds)[:, 0]
-            ub = np.array(self.bounds)[:, 1]
-            x = np.clip(x, lb, ub)  # ensure bounds are respected
-            
-        if self.args is None:
-            g = self.jacobian(x, epf=self.epf)
-        else:
-            g = self.jacobian(x, *self.args, epf=self.epf)
-        return g
-    
-    def hess(self, x):
-        if self.hessian is None:
-            return None
-        
-        if self.bounds is not None:
-            lb = np.array(self.bounds)[:, 0]
-            ub = np.array(self.bounds)[:, 1]
-            x = np.clip(x, lb, ub)  # ensure bounds are respected
-
-        if self.args is None:
-            h = self.hessian(x)
-        else:
-            h = self.hessian(x, *self.args)
-        return h
-
-    def calc_update(self, inner_iter=0):
-
-        # Initialize variables for this step
-        success = True
-
-        # Project the jacobian to respect bounds
-        if self.bounds is not None:
-            self._jk = self._project_jac(self._jk, self._xk)
-
-        #print(self.quasi_newton, self._Hk is None, self.iteration)
-        if self.quasi_newton and (self._Hk is None) and (self.iteration == 1):
-            # First iteration with BFGS and no initial Hessian: use steepest descent
-            sk = - self._jk
-            sk = sk / la.norm(sk, np.inf) * self.trust_radius
-            hits_boundary = True
-
-        else:
-            # Solve subproblem
-            self.logger(f'Solving subproblem ...................')
-            if callable(self.method):
-                sk, hits_boundary = self.method(
-                    self._xk, 
-                    self._fk, 
-                    self._jk, 
-                    self._Hk, 
-                    self.trust_radius, 
-                    **self.options
-                )
-            else:
-                sk, hits_boundary = solve_trust_region_subproblem(
-                    self._xk, 
-                    self._fk, 
-                    self._jk, 
-                    self._Hk, 
-                    self.trust_radius,
-                    method=self.method, 
-                    **self.options
-                )
-
-        # Truncate sk to respect bounds
-        if self.bounds is not None:
-            lb = np.array(self.bounds)[:, 0]
-            ub = np.array(self.bounds)[:, 1]
-            sk = np.clip(sk, lb - self._xk, ub - self._xk)
-
-        # Calculate the actual function value
-        xk_new = self._xk + sk
-        fk_new = self.fun(xk_new)
-
-        # Calculate rho (actual / predicted reduction)
-        df = self._fk - fk_new
-        if self.iteration == 1 and self.quasi_newton:
-            dm = - np.dot(self._jk, sk)
-        else:
-            dm = - np.dot(self._jk, sk) - np.dot(sk, np.dot(self._Hk, sk))/2
-
-        self.rho = df/dm
-        
-        if (self.rho > self.rho_tol) and (fk_new < self._fk):
-            
-            # Save old values
-            x_old = self._xk
-            f_old = self._fk
-            j_old = self._jk
-            h_old = self._Hk
-
-            # Update the control
-            self._xk = xk_new
-            self._fk = fk_new
-
-            # Save Results
-            self.optimize_result = ot.get_optimize_result(self)
-            if self.saveit:
-                ot.save_optimize_results(self.optimize_result)
-
-            # Write logging info
-            info = {
-                'Iter.': self.iteration,
-                f'{fun_xk_symbol}': self._fk,
-                f'{delta_k_symbol}': self.trust_radius,
-                f'{rho_symbol}': self.rho,
-                f'|p{subk}| = {delta_k_symbol}': 'yes' if hits_boundary else 'no',
-            }
-            self.logger(**info)
-
-            # Call the callback function
-            if callable(self.callback):
-                self.callback(self)
-
-            # Check for convergence
-            if (la.norm(sk, np.inf) < self._xtol):
-                self.msg = 'Convergence criteria met: |dx| < xtol'
-                self.logger.info(self.msg)
-                success = False
-                return success
-            if (np.abs(self._fk - f_old) < self._ftol * np.abs(f_old)):
-                self.msg = 'Convergence criteria met: |f(x+dx) - f(x)| < ftol * |f(x)|'
-                self.logger.info(self.msg)
-                success = False
-                return success
-
-            # Check for custom convergence
-            if callable(self.convergence_criteria):
-                if self.convergence_criteria(self):
-                    self.logger('Custom convergence criteria met. Stopping optimization.')
-                    success = False
-                    return success
-
-            # Update the trust region radius
-            delta_old = self.trust_radius
-            if (self.rho >= self.eta2) and hits_boundary: 
-                delta_new = min(self.gam2*delta_old, self.trust_radius_max)
-            elif self.rho < self.eta1:
-                delta_new = self.gam1*delta_old
-            else:
-                delta_new = delta_old
-            
-            # Log new trust-radius
-            self.trust_radius = np.clip(delta_new, self.trust_radius_min, self.trust_radius_max)
-            if not (delta_old == delta_new):
-                d_delta = (delta_new - delta_old)/delta_old * 100
-                self.logger(
-                    f'Tr-radius {delta_k_symbol} updated: {delta_old:<10.4e} ───> {delta_new:<10.4e} ({d_delta:<.2f}%)'
-                )
- 
-            # check for convergence
-            if self.iteration == self.max_iter:
-                success = False
-            else:
-                # Calculate the jacobian and hessian
-                self._jk = self.jac(self._xk)
-
-                if self.quasi_newton:
-                    yk = self._jk - j_old
-                    if self.iteration==1 and self._Hk is None:
-                        self._Hk = np.dot(yk, yk) / np.dot(yk, sk) * np.eye(self._xk.size) 
-
-                    self._Hk = self.bfgs_update(
-                        Bk = self._Hk, 
-                        sk = sk, 
-                        yk = yk)
-                else:
-                    self._Hk = self.hess(self._xk)
-            
-            # Update iteration
-            self.iteration += 1
-
-        else:
-            if inner_iter < self.trust_radius_cuts:
-                
-                if not (fk_new < self._fk):
-                    self.logger(f'Function value not reduced: {fun_xk_symbol} = {fk_new:<10.4e} >= {self._fk:<10.4e}')
-                else:
-                    # Log the failure
-                    self.logger(f'Step not successful: {rho_symbol} = {self.rho:<10.4e} < {self.rho_tol:<10.4e}')
-                
-                # Reduce trust region radius to 75% of current value
-                self.logger(f'Reducing {delta_k_symbol} by 75%: {self.trust_radius:<10.4e} ───> {0.25*self.trust_radius:<10.4e}')
-                self.trust_radius = 0.25*self.trust_radius
-
-                if self.trust_radius < self.trust_radius_min:
-                    self.msg = f'Tr-radius {delta_k_symbol} <= minimum {delta_k_symbol}'
-                    self.logger(f'Trust radius {self.trust_radius:<10.4e} is below minimum {self.trust_radius_min:<10.4e}. Stopping optimization.')
-                    success = False
-                    return success
-
-                # Check for resampling of Jac and Hess
-                if self.resample:
-                    self.logger('Resampling gradient and hessian')
-                    self._jk = self.jac(self._xk)
-
-                    if not self.quasi_newton:
-                        self._Hk = self.hess(self._xk)
-
-                # Recursivly call function
-                success = self.calc_update(inner_iter=inner_iter+1)
-
-            else:
-                success = False
-
-        return success
-    
-    def bfgs_update(self, Bk, sk, yk):
-        sk = sk.reshape(-1, 1)
-        yk = yk.reshape(-1, 1)
-        term1 = (yk @ yk.T) / (yk.T @ sk)
-        term2 = (Bk @ sk @ sk.T @ Bk) / (sk.T @ Bk @ sk)
-        Bk_new = Bk + term1 - term2
-        return Bk_new
-
-    def get_intermediate_results(self):
-        # Define default results
-        results = {
-            'fun': self._fk,
-            'x': self._xk, 
-            'jac': self._jk,
-            'nfev': self.nfev,
-            'njev': self.njev,
-            'nit': self.iteration,
-            'method': self.method,
-            'save_folder': self.options.get('save_folder', './')
-        }
-
-        if 'savedata' in self.options:
-            # Make sure "SAVEDATA" gives a list
-            if isinstance(self.options['savedata'], list):
-                savedata = self.options['savedata']
-            else:
-                savedata = [self.options['savedata']]
-
-            if 'args' in savedata:
-                for a, arg in enumerate(self.args):
-                    results[f'args[{a}]'] = arg
-
-            # Loop over variables to store in save list
-            for variable in savedata:
-                if variable in locals():
-                    results[variable] = eval('{}'.format(variable))
-                elif hasattr(self, variable):
-                    results[variable] = eval('self.{}'.format(variable))
-                else:
-                    print(f'Cannot save {variable}!\n\n')
-
-        return OptimizeResult(results)
-    
-    def _project_jac(self, jk, xk):
-        ''' Projects the jacobian onto the feasible set defined by bounds '''
-        lb = np.array(self.bounds)[:, 0]
-        ub = np.array(self.bounds)[:, 1]
-        for i, jk_val in enumerate(jk):
-            if (xk[i] <= lb[i] and jk_val > 0) or (xk[i] >= ub[i] and jk_val < 0):
-                jk[i] = 0
-        return jk
-                
-
-                    
-
-
-
-
-
-
-
-        
-
diff --git a/src/simulator/simple_models.py b/src/simulator/simple_models.py
index 58a3d5f8..ef1905f9 100644
--- a/src/simulator/simple_models.py
+++ b/src/simulator/simple_models.py
@@ -2,10 +2,8 @@
 # Imports
 import numpy as np  # Misc. numerical tools
 import os  # Misc. system tools
-import sys
-import scipy.stats as sc  # Extended numerical tools
 from copy import copy, deepcopy
-from multiprocessing import Process, Pipe  # To be able to run Python methods in background
+from multiprocessing import Process  # To be able to run Python methods in background
 import time  # To wait a bit before loading files
 
 import h5py  # To load matlab .mat files
@@ -50,6 +48,7 @@ def __init__(self, input_dict=None, m=None):
         self.keys = {}
 
     def setup_fwd_run(self, **kwargs):
+        """Store the keyword arguments as attributes before a forecast."""
         self.__dict__.update(kwargs)  # parse kwargs input into class attributes
         assimIndex = [i for i in range(len(self.l_prim))]
         trueOrder = self.true_order
@@ -65,6 +64,7 @@ def setup_fwd_run(self, **kwargs):
             self.true_prim = [trueOrder[0], [trueOrder[1]]]
 
     def run_fwd_sim(self, state, member_i, del_folder=True):
+        """Observe the state at the model's positions; one dict per report point."""
         inv_param = state.keys()
         for prim_ind in self.l_prim:
             for dat in self.all_data_types:
@@ -73,7 +73,10 @@ def run_fwd_sim(self, state, member_i, del_folder=True):
                     tmp_val.append(state[para][self.true_prim[1][prim_ind]])
                 self.pred_data[prim_ind][dat] = np.array(tmp_val)
 
-        return self.pred_data
+        # A fresh list per member: the serial forecast keeps every member's
+        # output, and handing back the shared attribute made them all alias
+        # the last one evaluated.
+        return deepcopy(self.pred_data)
 
 
 class nonlin_onedimmodel:
@@ -102,6 +105,7 @@ def __init__(self, input_dict=None):
         self.l_prim = [int(i) for i in range(len(self.true_prim[1]))]
 
     def setup_fwd_run(self, **kwargs):
+        """Store the keyword arguments as attributes before a forecast."""
         self.__dict__.update(kwargs)  # parse kwargs input into class attributes
         assimIndex = [i for i in range(len(self.l_prim))]
         trueOrder = self.true_order
@@ -117,6 +121,7 @@ def setup_fwd_run(self, **kwargs):
             self.true_prim = [trueOrder[0], [trueOrder[1]]]
 
     def run_fwd_sim(self, state, member_i, del_folder=True):
+        """Evaluate the nonlinear model on the state; one dict per report point."""
         # Fwd. model given by Chen & Oliver, Computat. Geosci., 17(4), p. 689-703, 2013.
         inv_param = state.keys()
         for prim_ind in self.l_prim:
@@ -127,7 +132,10 @@ def run_fwd_sim(self, state, member_i, del_folder=True):
                         (7 / 12) * (state[para] ** 3) - (7 / 2) * (state[para] ** 2) + 8 * state[para])
                 self.pred_data[prim_ind][dat] = np.array(tmp_val)
 
-        return self.pred_data
+        # A fresh list per member: the serial forecast keeps every member's
+        # output, and handing back the shared attribute made them all alias
+        # the last one evaluated.
+        return deepcopy(self.pred_data)
 
 
 class sevenmountains:
@@ -328,8 +336,7 @@ def call_sim(self, path=None):
             for i in range(n):
                 d[i] = func(control[0][i], control[1][i])
         else:
-            print('\033[1;31mERROR: Input to objective function has wrong dimension.\033[1;m')
-            sys.exit(1)
+            raise ValueError('Input to objective function has wrong dimension.')
         # # Calc. data
         # d = -self.m ** 2
 
@@ -379,6 +386,7 @@ def get_sim_results(which_resp, ext_data_info=None, member=None):
     # Create static method since the following function does not use 'self'
     @staticmethod
     def get_obj_func(obj_func_name, data_info=None, member=None):
+        """Objective value read from the results of one member (``En_/``) or of a single run."""
         # Ensemble runs
         if member is not None:
             filename = 'En_' + str(member) + os.sep
@@ -435,6 +443,7 @@ def check_sim_end(current_run):
 
 
 class noSimulation:
+    """A simulator that does nothing: the state itself is the prediction, for objectives that need no forward model."""
 
     def __init__(self, input_dict):
         # parse information from the input.
@@ -443,6 +452,7 @@ def __init__(self, input_dict):
         self.true_order = None
 
     def setup_fwd_run(self, **kwargs):
+        """Store the keyword arguments as attributes."""
         # do whatever initialization you need.
         # Useful to initialize the self.pred_data variable.
         # self.pred_data is a list of dictionaries. Where each list element represents
@@ -451,6 +461,7 @@ def setup_fwd_run(self, **kwargs):
         self.__dict__.update(kwargs)  # parse kwargs input into class attributes
 
     def run_fwd_sim(self, state, member):
+        """Return the state as the prediction."""
         # run simulator. Called from the main function using p_map from p_tqdm package.
         # Return pred_data if run is successfull, False if run failed.
         return [state]
diff --git a/src/simulator/vanderpol.py b/src/simulator/vanderpol.py
new file mode 100644
index 00000000..e36cdb20
--- /dev/null
+++ b/src/simulator/vanderpol.py
@@ -0,0 +1,335 @@
+"""
+Simulator wrapper for the Van der Pol oscillator.
+Van der Pol oscillator is a non-conservative oscillator with non-linear damping.
+
+The equation of motion is given by:
+
+    x'' - μ(1 - x^2)x' + x = 0
+
+where μ is a scalar parameter indicating the nonlinearity and the strength of the damping.
+"""
+
+import numpy as np
+import pandas as pd
+from scipy.integrate import solve_ivp
+from multiprocessing import Pool
+
+
+__author__ = "copilot, Mathias Methlie Nilsen, Andreas Stordal"
+__all__ = ["VanDerPolOscillator", "_integrate"]
+
+
+# ---------------------------------------------------------------------------
+# ODE definition
+# ---------------------------------------------------------------------------
+
+def _vdp_rhs(t, state, mu):
+    """Van der Pol ODE augmented with first-order sensitivity equations."""
+    x1, x2 = state[0], state[1]
+
+    # Sensitivity states
+    S11, S12, S13 = state[2], state[3], state[4]   # dx1/d[x1_0, x2_0, mu]
+    S21, S22, S23 = state[5], state[6], state[7]   # dx2/d[x1_0, x2_0, mu]
+
+    # Jacobian of f w.r.t. state
+    A11 =  0.0
+    A12 =  1.0
+    A21 = -2.0 * mu * x1 * x2 - 1.0
+    A22 =  mu * (1.0 - x1 ** 2)
+
+    # Derivative of f w.r.t. mu
+    B1 = 0.0
+    B2 = (1.0 - x1 ** 2) * x2
+
+    # State dynamics
+    dx1 = x2
+    dx2 = mu * (1.0 - x1 ** 2) * x2 - x1
+
+    # Sensitivity dynamics  dS/dt = A @ S + B  (column-wise)
+    dS11 = A11 * S11 + A12 * S21
+    dS12 = A11 * S12 + A12 * S22
+    dS13 = A11 * S13 + A12 * S23 + B1
+
+    dS21 = A21 * S11 + A22 * S21
+    dS22 = A21 * S12 + A22 * S22
+    dS23 = A21 * S13 + A22 * S23 + B2
+
+    return [dx1, dx2, dS11, dS12, dS13, dS21, dS22, dS23]
+
+
+def _integrate(x1_0, x2_0, mu, t_eval, atol=1e-5, rtol=1e-5):
+    """
+    Integrate the Van der Pol system (with sensitivities) for one member.
+
+    Returns
+    -------
+    sol_T : ndarray, shape (len(t_eval), 8)
+        Columns: [x1, x2, S11, S12, S13, S21, S22, S23]
+    """
+    state0 = [x1_0, x2_0,
+              1.0, 0.0, 0.0,   # S11, S12, S13
+              0.0, 1.0, 0.0]   # S21, S22, S23
+
+    sol = solve_ivp(
+        _vdp_rhs,
+        [t_eval[0], t_eval[-1]],
+        state0,
+        args=(mu,),
+        t_eval=t_eval,
+        method="RK45",
+        atol=atol,
+        rtol=rtol,
+    )
+    return sol.y.T  # (n_times, 8)
+
+
+# ---------------------------------------------------------------------------
+# Worker function (must be module-level for multiprocessing)
+# ---------------------------------------------------------------------------
+
+def _run_single(args):
+    """Run a single ensemble member; used by the parallel pool."""
+    member_input, idn, t_eval, datatypes, compute_adjoints, atol, rtol = args
+
+    x1_0 = float(member_input.get("x1", 1.0))
+    x2_0 = float(member_input.get("x2", 0.0))
+    mu   = float(member_input.get("mu", 1.0))
+
+    sol = _integrate(x1_0, x2_0, mu, t_eval, atol=atol, rtol=rtol)
+
+    # ------------------------------------------------------------------
+    # Build output list: one dict per reportpoint
+    # ------------------------------------------------------------------
+    _state_col = {"x1": 0, "x2": 1}
+    result = []
+    for it in range(sol.shape[0]):
+        row = {}
+        for key in datatypes:
+            col = _state_col.get(key)
+            if col is None:
+                raise ValueError(f"Unknown datatype '{key}'. Supported: 'x1', 'x2'.")
+            row[key] = float(sol[it, col])
+        result.append(row)
+
+    if not compute_adjoints:
+        return result
+
+    # ------------------------------------------------------------------
+    # Sensitivity matrix  dY/d[x1_0, x2_0, mu]
+    # Shape: (n_obs_total, 3)
+    # Sensitivity columns in sol:  S11=2, S12=3, S13=4  (for x1)
+    #                               S21=5, S22=6, S23=7  (for x2)
+    # ------------------------------------------------------------------
+    _sens_cols = {"x1": [2, 3, 4], "x2": [5, 6, 7]}
+    sens = {}
+    for key in datatypes:
+        cols = _sens_cols[key]
+        sens[key] = sol[:, cols].copy()     # (n_times, 3)
+
+    return result, sens
+
+
+# ---------------------------------------------------------------------------
+# Main wrapper class
+# ---------------------------------------------------------------------------
+
+class VanDerPolOscillator:
+    """
+    PET-compatible wrapper for the Van der Pol oscillator.
+
+    Parameters
+    ------------
+    options : dict
+        Configuration options for the simulator. Supported keys:
+        - ``reportpoint``: list of report points (default: [1, 2, ..., 15])
+        - ``reporttype``: type of report points, e.g. "times" (default: "times")
+        - ``datatype``: list of datatypes to extract, e.g. ["x1", "x2"] (default: ["x1"])
+        - ``compute_adjoints``: bool, whether to compute adjoints (default: False)
+        - ``atol``: absolute tolerance for ODE solver (default: 1e-5)
+        - ``rtol``: relative tolerance for ODE solver (default: 1e-5)
+        - ``parallel``: number of parallel processes to use (default: 1, i.e. no parallelism)
+    """
+
+    def __init__(self, options: dict):
+        # Report / index
+        self.report      = options.get("reportpoint", list(range(1, 16)))
+        self.report_type = options.get("reporttype", "times")
+        self.index       = [self.report_type, self.report]
+
+        # Datatypes to extract
+        self.datatype = options.get("datatype", ["x1"])
+
+        # Adjoint flag
+        self.compute_adjoints = options.get("compute_adjoints", False)
+
+        # Solver tolerances
+        self.atol = options.get("atol", 1e-5)
+        self.rtol = options.get("rtol", 1e-5)
+
+        # Parallelism
+        self.parallel = options.get("parallel", 1)
+
+        # Required by PET
+        self.input_dict = options
+        self.true_order = self.index
+        self.all_data_types = self.datatype
+        self.l_prim = [int(i) for i in range(len(self.report))]
+
+    # ------------------------------------------------------------------
+
+    def __call__(self, inputs: list | dict):
+        """
+        Run forward simulations for all ensemble members.
+
+        Parameters
+        ----------
+        inputs : list of dict  or  dict
+            One dict per ensemble member with keys ``x1``, ``x2``, ``mu``.
+
+        Returns
+        -------
+        results : list
+            One entry per ensemble member. Each entry is a list of dictionaries,
+            one dictionary per report point.
+        adjoints : list, optional
+            One adjoint DataFrame per ensemble member when
+            ``compute_adjoints=True``.
+        """
+        if isinstance(inputs, dict):
+            inputs = [inputs]
+
+        t_eval = np.asarray(self.report, dtype=float)
+        # Prepend t=0 if absent so the solver has a valid starting point
+        if t_eval[0] != 0.0:
+            t_eval_full = np.concatenate([[0.0], t_eval])
+            obs_mask = slice(1, None)
+        else:
+            t_eval_full = t_eval
+            obs_mask = slice(None)
+
+        args_list = [
+            (member, idn, t_eval_full, self.datatype,
+             self.compute_adjoints, self.atol, self.rtol)
+            for idn, member in enumerate(inputs)
+        ]
+
+        if self.parallel > 1:
+            with Pool(processes=self.parallel) as pool:
+                raw = pool.map(_run_single, args_list)
+        else:
+            raw = [_run_single(a) for a in args_list]
+
+        # Separate results / adjoints and trim t=0 padding
+        if self.compute_adjoints:
+            results, adjoints = [], []
+            for res, sens in raw:
+                res_trimmed = [
+                    {k: np.array([v], dtype=float) for k, v in d.items()}
+                    for d in res[obs_mask]
+                ]
+                results.append(res_trimmed)
+
+                adj_rows = []
+                for i in range(len(self.report)):
+                    row = {}
+                    for key in self.datatype:
+                        row[key] = np.asarray(sens[key][i + (0 if t_eval[0] == 0.0 else 1)], dtype=float)
+                    adj_rows.append(row)
+                adj_df = pd.DataFrame(adj_rows, index=self.report)
+                adj_df.index.name = self.report_type
+                adjoints.append(adj_df)
+            return results, adjoints
+
+        return [
+            [{k: np.array([v], dtype=float) for k, v in d.items()} for d in item[obs_mask]]
+            for item in raw
+        ]
+
+    # ------------------------------------------------------------------
+
+    def setup_fwd_run(self, **kwargs):
+        """PET compatibility hook (no setup required for this simulator)."""
+        return None
+
+    # ------------------------------------------------------------------
+
+    def run_fwd_sim(self, state: dict, member_i: int = 0, del_folder: bool = True):
+        """
+        Run the forward simulation for a single ensemble member.
+
+        Mirrors the ``run_fwd_sim`` signature used in the other
+        SimulatorWrap classes.
+
+        Parameters
+        ----------
+        state : dict
+            Keys: ``x1``, ``x2``, ``mu``. Values can be scalars or arrays with
+            one element.
+        member_i : int
+            Ensemble member index (unused internally, kept for API
+            compatibility).
+        del_folder : bool
+            Kept for PET compatibility. Unused.
+
+        Returns
+        -------
+        result : list[dict]
+            One dictionary per report point with keys equal to datatypes and
+            values as 1D arrays.
+        adj_df : pandas.DataFrame, optional
+            Adjoint matrix in PET-compatible format; each cell contains a
+            Jacobian row vector with derivatives w.r.t. [x1, x2, mu].
+        """
+        member_input = {
+            "x1": float(np.asarray(state.get("x1", [1.0])).ravel()[0]),
+            "x2": float(np.asarray(state.get("x2", [0.0])).ravel()[0]),
+            "mu": float(np.asarray(state.get("mu", [1.0])).ravel()[0]),
+        }
+
+        t_eval = np.asarray(self.report, dtype=float)
+        if t_eval[0] != 0.0:
+            t_eval_full = np.concatenate([[0.0], t_eval])
+            obs_mask = slice(1, None)
+        else:
+            t_eval_full = t_eval
+            obs_mask = slice(None)
+
+        args = (member_input, member_i, t_eval_full, self.datatype,
+                self.compute_adjoints, self.atol, self.rtol)
+        out = _run_single(args)
+
+        if self.compute_adjoints:
+            res, sens = out
+            res = res[obs_mask]
+            sens_offset = 0 if t_eval[0] == 0.0 else 1
+
+            # Build PET output: list of dicts over report points
+            pred = []
+            for i in range(len(res)):
+                row = {}
+                for key in self.datatype:
+                    row[key] = np.array([res[i][key]], dtype=float)
+                pred.append(row)
+
+            # Build adjoint dataframe: each cell holds d(y)/d[x1, x2, mu]
+            # sens dict entries have keys datatype, values shape (n_obs, 3)
+            adj_rows = []
+            for i in range(len(self.report)):
+                row = {}
+                for key in self.datatype:
+                    row[key] = np.asarray(sens[key][i + sens_offset], dtype=float)
+                adj_rows.append(row)
+
+            adj_df = pd.DataFrame(adj_rows, index=self.report)
+            adj_df.index.name = self.report_type
+            return pred, adj_df
+
+        # No adjoints
+        res = out[obs_mask]
+        pred = []
+        for i in range(len(res)):
+            row = {}
+            for key in self.datatype:
+                row[key] = np.array([res[i][key]], dtype=float)
+            pred.append(row)
+        return pred
diff --git a/tests/assimilation/characterisation_reference.npz b/tests/assimilation/characterisation_reference.npz
new file mode 100644
index 00000000..5bd55855
Binary files /dev/null and b/tests/assimilation/characterisation_reference.npz differ
diff --git a/tests/assimilation/test_adjoints.py b/tests/assimilation/test_adjoints.py
new file mode 100644
index 00000000..ad8b70b0
--- /dev/null
+++ b/tests/assimilation/test_adjoints.py
@@ -0,0 +1,35 @@
+"""Adjoints reach the analysis as an ``(nd, nx, ne)`` array aligned with the prediction rows."""
+
+import numpy as np
+
+from input_output import read_config
+from misc.structures import PETDataFrame
+from pipt.ensembles import AssimilationEnsemble
+from simulator.vanderpol import VanDerPolOscillator
+from test_numerical_characterisation import _write_config, _write_synthetic_case
+
+NE = 8
+
+
+def test_the_adjoint_array_is_what_the_frame_path_stacked(tmp_path, monkeypatch):
+    monkeypatch.chdir(tmp_path)
+    report_points = _write_synthetic_case(ne=NE)
+    cfg_da, cfg_sim, cfg_ens = read_config.read(_write_config("adj", "esmda", "approx", report_points, ne=NE))
+    cfg_sim["compute_adjoints"] = True
+    ensemble = AssimilationEnsemble(cfg_da, cfg_ens, VanDerPolOscillator(cfg_sim))
+    ensemble.forecast(ensemble.enX)
+
+    # The legacy construction: merge the members' adjoint frames, keep the observed
+    # data types, flatten as a Jacobian.
+    legacy = PETDataFrame.merge_dataframes(ensemble.member_adjoints)[ensemble.data_df.columns]
+    np.testing.assert_array_equal(ensemble.adjoints, legacy.to_matrix(is_jacobian=True))
+    assert ensemble.adjoints.shape == (ensemble.pred_data.nd, ensemble.enX.shape[0], NE)
+
+
+def test_without_adjoints_the_ensemble_carries_none(tmp_path, monkeypatch):
+    monkeypatch.chdir(tmp_path)
+    report_points = _write_synthetic_case(ne=NE)
+    cfg_da, cfg_sim, cfg_ens = read_config.read(_write_config("noadj", "esmda", "approx", report_points, ne=NE))
+    ensemble = AssimilationEnsemble(cfg_da, cfg_ens, VanDerPolOscillator(cfg_sim))
+    ensemble.forecast(ensemble.enX)
+    assert ensemble.adjoints is None and ensemble.member_adjoints is None
diff --git a/tests/assimilation/test_analysis_base.py b/tests/assimilation/test_analysis_base.py
new file mode 100644
index 00000000..fe390f8f
--- /dev/null
+++ b/tests/assimilation/test_analysis_base.py
@@ -0,0 +1,109 @@
+"""Tests for the shared analysis base.
+
+The three analysis flavours used to each carry a private copy of ``solve`` and
+``sqrtm``. Those copies had drifted: ``approx_update`` used ``A.ndim`` while the
+others used ``np.ndim(A)``, so only the latter tolerated a covariance supplied
+as a plain list or scalar. These tests pin the consolidated behaviour.
+"""
+
+import numpy as np
+import pytest
+
+from pipt.update_schemes.analysis import AnalysisBase
+from pipt.update_schemes.analysis.approx import approx_update
+from pipt.update_schemes.analysis.full import full_update
+from pipt.update_schemes.analysis.subspace import subspace_update
+from pipt.update_schemes.analysis.subspace2 import subspace2_update
+
+FLAVOURS = [approx_update, full_update, subspace_update, subspace2_update]
+
+
+@pytest.mark.parametrize("flavour", FLAVOURS, ids=lambda c: c.__name__)
+def test_flavours_share_the_strategy_base(flavour):
+    assert issubclass(flavour, AnalysisBase)
+
+
+@pytest.mark.parametrize("flavour", FLAVOURS, ids=lambda c: c.__name__)
+def test_flavours_no_longer_define_private_helpers(flavour):
+    """Helpers must come from the base, not a per-file copy."""
+    assert "solve" not in vars(flavour)
+    assert "sqrtm" not in vars(flavour)
+
+
+def test_base_is_abstract():
+    with pytest.raises(TypeError):
+        AnalysisBase()
+
+
+# ----------------------------------------------------------------------
+# solve
+# ----------------------------------------------------------------------
+
+def test_solve_diagonal_matches_dense_equivalent():
+    diag = np.array([2.0, 4.0])
+    B = np.array([[1.0, 3.0], [2.0, 8.0]])
+    np.testing.assert_allclose(
+        AnalysisBase.solve(diag, B),
+        AnalysisBase.solve(np.diag(diag), B),
+    )
+
+
+def test_solve_dense_is_a_true_inverse_apply():
+    A = np.array([[3.0, 1.0], [1.0, 2.0]])
+    B = np.array([[1.0], [2.0]])
+    np.testing.assert_allclose(A @ AnalysisBase.solve(A, B), B, atol=1e-12)
+
+
+def test_solve_accepts_list_covariance():
+    """Regression: approx_update's old `A.ndim` raised AttributeError here."""
+    out = AnalysisBase.solve([2.0, 4.0], np.ones((2, 2)))
+    np.testing.assert_allclose(out, [[0.5, 0.5], [0.25, 0.25]])
+
+
+# ----------------------------------------------------------------------
+# sqrtm
+# ----------------------------------------------------------------------
+
+def test_sqrtm_diagonal():
+    np.testing.assert_allclose(AnalysisBase.sqrtm(np.array([4.0, 9.0])), [2.0, 3.0])
+
+
+def test_sqrtm_accepts_list():
+    np.testing.assert_allclose(AnalysisBase.sqrtm([4.0, 9.0]), [2.0, 3.0])
+
+
+def test_sqrtm_dense_squares_back():
+    A = np.array([[4.0, 0.0], [0.0, 9.0]])
+    root = AnalysisBase.sqrtm(A)
+    np.testing.assert_allclose(root @ root, A, atol=1e-10)
+
+
+# ----------------------------------------------------------------------
+# Scheme + flavour combinations resolve to the right strategy
+# ----------------------------------------------------------------------
+
+def test_scheme_registry_selects_the_right_strategy():
+    """Each ``(scheme, analysis)`` combination binds the matching strategy.
+
+    The eighteen per-flavour classes (``esmda_approx``, ``lmenrml_full``, ...)
+    used to *inherit* their strategy, so ``issubclass(esmda_approx,
+    approx_update)`` held. They are gone now: ``ESMDA``/``LMEnRML``/``GNEnRML``
+    take ``analysis`` as a constructor argument and *hold* an analysis
+    instance instead. What matters -- which strategy a given combination
+    uses -- is what this asserts.
+    """
+    from pipt.update_schemes.esmda import ESMDA
+    from pipt.update_schemes.enrml import GNEnRML, LMEnRML
+    from pipt.update_schemes.registry import get_scheme
+
+    for scheme_name, flavour_name, algorithm, flavour_cls in [
+        ("esmda", "approx", ESMDA, approx_update),
+        ("lmenrml", "full", LMEnRML, full_update),
+        ("gnenrml", "subspace", GNEnRML, subspace_update),
+    ]:
+        ctor = get_scheme(scheme_name, flavour_name)
+        assert ctor.func is algorithm
+        assert ctor.keywords == {"analysis": flavour_name}
+        assert not issubclass(algorithm, AnalysisBase), (
+            f"{algorithm.__name__} should hold an analysis, not inherit one"
+        )
diff --git a/tests/assimilation/test_analysis_binding.py b/tests/assimilation/test_analysis_binding.py
new file mode 100644
index 00000000..e6d17519
--- /dev/null
+++ b/tests/assimilation/test_analysis_binding.py
@@ -0,0 +1,222 @@
+"""Binding an analysis to a scheme instead of mixing it in.
+
+Groundwork for making ``analysis`` a parameter of one scheme class rather than
+the thing that selects which of eighteen classes you get. Strategy code reads
+its context explicitly off ``self.scheme`` -- always that one object, never
+``scheme.ensemble``. Some of those names are the scheme's own (``lam``,
+``trunc_energy``, ``iteration``) and some belong to its ensemble
+(``localization``, ``keys_da``, ``proj``, ``prior_enX``, ``state_scaling``),
+but the scheme exposes both as properties, so an analysis never has to know
+which -- see :class:`~pipt.update_schemes.core.AssimilationScheme`.
+
+The load-bearing test is
+:func:`test_bound_strategy_matches_mixed_in_result`: bound and mixed-in must
+produce bit-identical steps, or the collapse would silently change every
+scheme's numbers.
+"""
+
+import numpy as np
+import pytest
+
+from pipt.update_schemes.analysis import AnalysisBase
+from pipt.update_schemes.analysis.registry import (
+    available_analyses,
+    get_analysis,
+    register_analysis,
+)
+from pipt.update_schemes.analysis.approx import approx_update
+from pipt.update_schemes.analysis.subspace import subspace_update
+
+
+class FakeLocalization:
+    name = None
+
+
+class FakeScheme:
+    """The context an analysis reads, and nothing else.
+
+    Flat on purpose: a real scheme exposes ensemble-owned state (``proj``,
+    ``prior_enX``, ``keys_da``, ...) as properties of its own, so an analysis
+    only ever reads ``scheme.``. A double just needs those names
+    present -- it does not have to reproduce the scheme/ensemble split.
+
+    Worth recording: the context is wider than what any one flavour needs on
+    its own. ``full_update`` also reads ``prior_enX``, ``Am``, ``ext_Am``
+    and ``state_scaling``. Anything binding analyses has to supply these.
+    """
+
+    def __init__(self, ne=8, nx=5, lam=0.0, trunc_energy=0.99):
+        self.lam = lam
+        self.trunc_energy = trunc_energy
+        self.keys_da = {}
+        self.localization = FakeLocalization()
+        self.proj = (np.eye(ne) - np.ones((ne, ne)) / ne) / np.sqrt(ne - 1)
+        self.prior_enX = np.random.default_rng(7).standard_normal((nx, ne))
+        self.Am = None
+        self.state_scaling = np.ones(nx)
+
+
+def _case(seed=0, nx=5, ny=4, ne=8):
+    rng = np.random.default_rng(seed)
+    return (
+        rng.standard_normal((nx, ne)),
+        rng.standard_normal((ny, ne)),
+        rng.standard_normal((ny, ne)),
+    )
+
+
+# ----------------------------------------------------------------------
+# Delegation
+# ----------------------------------------------------------------------
+def test_scheme_property_returns_the_bound_scheme():
+    """``self.scheme`` is what strategy code reads context off of and writes
+    results onto -- explicitly, at every use, not synced or resolved lazily.
+    """
+    scheme = FakeScheme(lam=3.5, trunc_energy=0.77)
+    strategy = approx_update(scheme)
+
+    assert strategy.scheme is scheme
+    assert strategy.scheme.lam == 3.5
+    assert strategy.scheme.trunc_energy == 0.77
+    assert strategy.scheme.localization.name is None
+
+
+def test_unbound_strategy_scheme_falls_back_to_self():
+    """An unbound analysis's ``self.scheme`` is itself, so a context read
+    goes looking on the analysis -- which does not have it -- and raises
+    a plain ``AttributeError`` rather than finding a half-initialised scheme.
+    """
+    strategy = approx_update()
+
+    assert strategy.scheme is strategy
+    with pytest.raises(AttributeError):
+        strategy.scheme.lam
+
+
+def test_writes_land_wherever_the_strategy_writes_them():
+    """No __setattr__ magic any more: state an analysis keeps between
+    iterations (``full_update``'s ``Am``, the weight-space flavours'
+    ``current_W``) lands exactly where it writes it, ``self.scheme``.
+    """
+    scheme = FakeScheme(lam=1.0)
+    strategy = approx_update(scheme)
+
+    strategy.scheme.lam = 99.0
+    assert scheme.lam == 99.0
+
+    # An analysis that (wrongly) wrote to itself instead of self.scheme would
+    # not be visible to the scheme -- there is nothing to catch that mistake
+    # any more, which is the tradeoff for there being no magic to misfire.
+    strategy.lam = -1.0
+    assert scheme.lam == 99.0
+
+
+# ----------------------------------------------------------------------
+# Equivalence with the mixin path -- the one that matters
+# ----------------------------------------------------------------------
+@pytest.mark.parametrize("flavour", ["approx", "full", "subspace"])
+def test_bound_strategy_matches_mixed_in_result(flavour):
+    """Bound and mixed-in must agree bit-for-bit.
+
+    This is what makes collapsing the eighteen classes safe: if the two paths
+    diverged, every scheme's numbers would move with no test to catch it.
+    """
+    strategy_cls = get_analysis(flavour)
+    enX, enY, enE = _case()
+
+    # Mixed in: `self` is the scheme, context resolves by inheritance.
+    class MixedIn(FakeScheme, strategy_cls):
+        pass
+
+    mixed = MixedIn()
+    mixed.iteration = 0
+    mixed_result = mixed.update(enX=enX, enY=enY, enE=enE)
+
+    # Bound: context resolves by delegation.
+    scheme = FakeScheme()
+    scheme.iteration = 0
+    bound_result = strategy_cls(scheme).update(enX=enX, enY=enY, enE=enE)
+
+    # Whichever kind of step the flavour returns, the two paths must agree.
+    for field in ("step", "w_step", "W_step"):
+        mixed_value, bound_value = getattr(mixed_result, field), getattr(bound_result, field)
+        assert (mixed_value is None) == (bound_value is None), f"{flavour}: paths return different kinds of step"
+        if mixed_value is not None:
+            np.testing.assert_array_equal(
+                np.asarray(bound_value, dtype=float),
+                np.asarray(mixed_value, dtype=float),
+                err_msg=(
+                    f"{flavour}: bound and mixed-in {field} disagree, so "
+                    f"collapsing the per-flavour classes would change the numerics."
+                ),
+            )
+
+    # State kept on the scheme between iterations (full_update caches Am) must
+    # land the same way. (Mixed in, self.scheme is self, so both land on `mixed`.)
+    for attr in ("Am",):
+        assert hasattr(scheme, attr) == hasattr(mixed, attr), (
+            f"{flavour}: bound path {'set' if hasattr(scheme, attr) else 'did not set'} "
+            f"{attr} but mixed-in path did the opposite"
+        )
+        if hasattr(mixed, attr) and getattr(mixed, attr) is not None:
+            np.testing.assert_array_equal(
+                np.asarray(getattr(scheme, attr), dtype=float),
+                np.asarray(getattr(mixed, attr), dtype=float),
+                err_msg=f"{flavour}: bound and mixed-in disagree on {attr}",
+            )
+
+
+def test_mixin_path_is_untouched_by_the_new_init():
+    """Adding __init__ to AnalysisBase must not perturb the mixin MRO.
+
+    Nothing in the scheme's __init__ chain calls super().__init__(), so
+    AnalysisBase.__init__ is never invoked there and `_scheme` is never
+    set -- which is exactly why mixed-in lookup is unaffected.
+    """
+    class MixedIn(FakeScheme, approx_update):
+        pass
+
+    mixed = MixedIn(lam=2.0)
+    assert "_scheme" not in vars(mixed)
+    assert mixed.lam == 2.0
+
+
+# ----------------------------------------------------------------------
+# Registry
+# ----------------------------------------------------------------------
+def test_registry_resolves_the_shipped_flavours():
+    assert get_analysis("approx") is approx_update
+    assert get_analysis("subspace") is subspace_update
+    assert available_analyses() == ["approx", "full", "subspace", "subspace2"]
+
+
+def test_registry_is_case_insensitive():
+    assert get_analysis("APPROX") is approx_update
+
+
+def test_unknown_flavour_lists_the_valid_ones():
+    with pytest.raises(KeyError, match="Unknown analysis flavour 'nope'"):
+        get_analysis("nope")
+
+
+def test_registering_a_duplicate_needs_overwrite():
+    class Extra(AnalysisBase):
+        def update(self, enX, enY, enE, **kwargs):
+            return None
+
+    with pytest.raises(ValueError, match="already registered"):
+        register_analysis("approx", Extra)
+
+
+def test_register_and_resolve_an_out_of_tree_flavour():
+    from pipt.update_schemes.analysis import registry
+
+    class Extra(AnalysisBase):
+        def update(self, enX, enY, enE, **kwargs):
+            return None
+
+    register_analysis("extra_flavour", Extra)
+    try:
+        assert get_analysis("extra_flavour") is Extra
+    finally:
+        del registry.ANALYSES["extra_flavour"]
diff --git a/tests/assimilation/test_assimilation_pipeline.py b/tests/assimilation/test_assimilation_pipeline.py
new file mode 100644
index 00000000..b7713e6a
--- /dev/null
+++ b/tests/assimilation/test_assimilation_pipeline.py
@@ -0,0 +1,326 @@
+"""
+Integration tests for Data Assimilation workflows using the Van der Pol oscillator.
+
+Tested algorithms:
+- ESMDA (Ensemble Smoother with Multiple Data Assimilation)
+- LM-EnRML (Levenberg-Marquardt Ensemble Randomized Maximum Likelihood)
+- GN-EnRML (Gauss-Newton Ensemble Randomized Maximum Likelihood)
+
+These tests validate multiple ensemble-based assimilation algorithms by
+verifying:
+1. Reduction in data misfit
+2. Improvement of inferred parameters relative to prior
+"""
+
+import os
+from pathlib import Path
+
+import yaml
+import pytest
+import numpy as np
+import pandas as pd
+
+from simulator.vanderpol import VanDerPolOscillator, _integrate
+from input_output import read_config
+from pipt import ES, ESMDA, EnKF, GNEnRML, LMEnRML
+
+
+# ----------------------------------------------------------------------
+# Fixtures
+# ----------------------------------------------------------------------
+
+@pytest.fixture
+def num_cores():
+    """
+    Return number of CPU cores for parallel execution.
+
+    Uses half of available cores, with a minimum of 1.
+    """
+    return max(os.cpu_count() // 2, 1)
+
+
+# ----------------------------------------------------------------------
+# Test utilities
+# ----------------------------------------------------------------------
+
+#: Members in the synthetic prior and in the config that consumes it. The
+#: quality thresholds in assert_assimilation_quality hold at this size; at
+#: 300 the posterior mean of mu misses the 0.2 x prior-error bar.
+ENSEMBLE_SIZE = 1000
+
+
+def setup_synthetic_case(seed: int = 12345):
+    """
+    Create synthetic prior ensemble and observation data.
+
+    Outputs:
+        - prior_ensemble.npz
+        - true_data.pkl
+        - var.pkl
+    """
+    rng = np.random.default_rng(seed)
+
+    # True parameters
+    x1_true, x2_true, mu_true = 1.0, 0.0, 1.0
+
+    # Prior ensemble
+    ne = ENSEMBLE_SIZE
+    X1 = 0.05 + 0.1 * rng.standard_normal(ne)
+    X2 = 0.05 + 0.1 * rng.standard_normal(ne)
+    MU = 1.5 + 0.5 * rng.standard_normal(ne)
+
+    np.savez(
+        "prior_ensemble.npz",
+        x1=X1[np.newaxis, :],
+        x2=X2[np.newaxis, :],
+        mu=MU[np.newaxis, :],
+    )
+
+    # Time configuration
+    time_steps = np.arange(0, 16, dtype=float)
+    report_points = np.arange(1, 16)
+
+    # True simulation
+    result = _integrate(x1_true, x2_true, mu_true, time_steps,
+                        atol=1e-5, rtol=1e-5)
+
+    # Observations (with noise)
+    sigma = 0.1
+    observations = result[report_points, 0] + sigma * rng.standard_normal(len(report_points))
+
+    # Store observations
+    df_obs = pd.DataFrame({"x1": observations}, index=report_points)
+    df_obs.index.name = "steps"
+    df_obs.to_pickle("true_data.pkl")
+
+    # Store variance (PET format)
+    variance = sigma ** 2
+    df_var = pd.DataFrame(
+        {"x1": [f"['abs', {variance}]" for _ in report_points]},
+        index=report_points,
+    )
+    df_var.index.name = "steps"
+    df_var.to_pickle("var.pkl")
+
+
+def create_config_file(filename: str, data_assimilation_cfg: dict, parallel_runs: int):
+    """
+    Write YAML configuration file for data assimilation run.
+    """
+    ensemble_cfg = {
+        "ne": ENSEMBLE_SIZE,
+        "state": ["x1", "x2", "mu"],
+        "importstate": "prior_ensemble.npz",
+        "prior_x1": {"var": 1.0},
+        "prior_x2": {"var": 1.0},
+        "prior_mu": {"var": 1.0},
+    }
+
+    simulator_cfg = {
+        "reporttype": "steps",
+        "reportpoints": list(range(1, 16)),
+        "datatype": ["x1"],
+        "parallel": parallel_runs,
+        "compute_adjoints": False,
+    }
+
+    config = {
+        "ensemble": ensemble_cfg,
+        "dataassim": data_assimilation_cfg,
+        "simulator": simulator_cfg,
+    }
+
+    with open(f"{filename}.yaml", "w") as f:
+        yaml.dump(config, f)
+
+
+def compute_data_misfit(observed, predicted, cov):
+    """
+    Compute normalized data misfit across ensemble members.
+    """
+    n_ens = predicted.shape[1]
+    misfit = 0.0
+
+    for i in range(n_ens):
+        residual = predicted[:, i] - observed
+        misfit += (residual.T @ np.linalg.solve(cov, residual)) / n_ens
+
+    return float(np.squeeze(misfit))
+
+
+#: The public class per algorithm.
+SCHEME_CLASSES = {
+    "enkf": EnKF,
+    "es": ES,
+    "esmda": ESMDA,
+    "lmenrml": LMEnRML,
+    "gnenrml": GNEnRML,
+}
+
+
+def run_case(config_file: str):
+    """Initialize and run assimilation given a config file.
+
+    Constructs the scheme class directly, as a user would. The scheme itself is
+    returned rather than only the result, because the assertions here read
+    `vecObs`, `pred_data` and `cov_data`, which the result object does not
+    carry.
+    """
+    cfg_da, cfg_sim, cfg_ens = read_config.read(config_file)
+
+    scheme = SCHEME_CLASSES[cfg_da["scheme"]](
+        cfg_da,
+        cfg_ens,
+        VanDerPolOscillator(cfg_sim),
+    )
+
+    scheme.run_assimilation()
+    return scheme
+
+
+def assert_assimilation_quality(ensemble, misfit_threshold=60.0):
+    """
+    Validate assimilation performance:
+        - Data misfit is below threshold
+        - Parameter estimate improves
+    """
+    # Data misfit check
+    dm = compute_data_misfit(
+        observed=ensemble.vecObs,
+        predicted=ensemble.pred_data.matrix,
+        cov=np.diag(ensemble.cov_data),
+    )
+
+    assert dm < misfit_threshold, f"Data mismatch too high: {dm:.2f} >= {misfit_threshold}"
+
+    # Parameter improvement (mu)
+    mu_true = 1.0
+    mu_prior = ensemble.prior_enX[2, :].mean()
+    mu_post = ensemble.enX[2, :].mean()
+
+    prior_error = abs(mu_prior - mu_true)
+    post_error = abs(mu_post - mu_true)
+
+    assert post_error < 0.2 * prior_error, (
+        f"Insufficient parameter improvement: "
+        f"{post_error:.3f} >= 0.2 * {prior_error:.3f}"
+    )
+
+
+def assert_savedata_files(scheme, expected):
+    """Every saved iteration file carries every requested variable.
+
+    Iteration 0 is the interesting one. Its file is written from
+    ``after_prior_forecast``, and the schemes used to compute the prior misfit
+    inside their first ``calc_analysis`` -- which runs later -- so
+    ``ensemble_misfit`` was silently dropped from step 0 with a printed
+    "Cannot save ... because it is a local variable!" and no failure.
+    """
+    folder = Path(scheme.save_folder)
+    saved = sorted(folder.glob("assimilation_result_*.npz"))
+    assert saved, f"no savedata files written to {folder}"
+
+    for path in saved:
+        with np.load(path, allow_pickle=True) as archive:
+            keys = set(archive.files)
+        missing = [name for name in expected if name not in keys]
+        assert not missing, f"{path.name} is missing {missing}; has {sorted(keys)}"
+
+
+def prepare_test_environment(tmp_path: Path, folder_name: str):
+    """
+    Create isolated test directory and initialize synthetic data.
+    """
+    path = tmp_path / folder_name
+    path.mkdir()
+    os.chdir(path)
+    setup_synthetic_case(seed=12345)
+    # The schemes perturb observations from the global numpy state; seed it so
+    # the quality thresholds below are checked against the same run every time.
+    np.random.seed(12345)
+
+
+# ----------------------------------------------------------------------
+# Tests
+# ----------------------------------------------------------------------
+
+@pytest.mark.slow
+def test_esmda_approx(tmp_path, num_cores):
+    """Test ESMDA (approx analysis)."""
+    prepare_test_environment(tmp_path, "esmda_test")
+
+    da_cfg = {
+        "scheme": "esmda",
+        "analysis": "approx",
+        "mda": {
+            "tot_assim_steps": 8,
+            "inflation_param": 8 * [8],
+        },
+        "energy": 0.99,
+        "obsname": "steps",
+        "data": "true_data.pkl",
+        "datavar": "var.pkl",
+        "save_folder": "results",
+        "savedata": ["state", "pred_data", "ensemble_misfit"],
+    }
+    create_config_file("config_esmda", da_cfg, num_cores)
+
+    ensemble = run_case("config_esmda.yaml")
+    assert_assimilation_quality(ensemble)
+    assert_savedata_files(ensemble, ["pred_data", "ensemble_misfit", "x1", "x2", "mu"])
+
+
+@pytest.mark.slow
+def test_lm_enrml_approx(tmp_path, num_cores):
+    """Test LM-EnRML (approx analysis)."""
+    prepare_test_environment(tmp_path, "lm_enrml_test")
+
+    da_cfg = {
+        "scheme": "lmenrml",
+        "analysis": "approx",
+        "iteration": {
+            "max_iter": 8,
+            "lambda": 10,
+            "lambda_factor": 5,
+            "trunc_energy": 0.99,
+        },
+        "energy": 0.99,
+        "obsname": "steps",
+        "data": "true_data.pkl",
+        "datavar": "var.pkl",
+        "save_folder": "results",
+        "savedata": ["state", "pred_data", "ensemble_misfit"],
+    }
+    create_config_file("config_lm_enrml", da_cfg, num_cores)
+
+    ensemble = run_case("config_lm_enrml.yaml")
+    assert_assimilation_quality(ensemble)
+    assert_savedata_files(ensemble, ["pred_data", "ensemble_misfit", "x1", "x2", "mu"])
+
+
+@pytest.mark.slow
+def test_gn_enrml_approx(tmp_path, num_cores):
+    """Test GN-EnRML (approx analysis)."""
+    prepare_test_environment(tmp_path, "gn_enrml_test")
+
+    da_cfg = {
+        "scheme": "gnenrml",
+        "analysis": "approx",
+        "iteration": {
+            "max_iter": 8,
+            "gamma": 0.5,
+            "gamma_factor": 5,
+            "trunc_energy": 0.99,
+        },
+        "energy": 0.99,
+        "obsname": "steps",
+        "data": "true_data.pkl",
+        "datavar": "var.pkl",
+        "save_folder": "results",
+        "savedata": ["state", "pred_data", "ensemble_misfit"],
+    }
+    create_config_file("config_gn_enrml", da_cfg, num_cores)
+
+    ensemble = run_case("config_gn_enrml.yaml")
+    assert_assimilation_quality(ensemble)
+    assert_savedata_files(ensemble, ["pred_data", "ensemble_misfit", "x1", "x2", "mu"])
diff --git a/tests/assimilation/test_autoadaloc.py b/tests/assimilation/test_autoadaloc.py
new file mode 100644
index 00000000..58cde6ca
--- /dev/null
+++ b/tests/assimilation/test_autoadaloc.py
@@ -0,0 +1,174 @@
+"""Comprehensive tests for localization methods and facade behavior."""
+
+import numpy as np
+from  pipt.misc_tools.analysis_tools import truncSVD
+from pipt.update_schemes.analysis import approx_update
+from pipt.localization import (
+    AutoAdaptiveLocalization,
+    build_localization_instance,
+)
+
+
+NX = 8
+NY = 4
+NE = 10
+
+X = np.array([
+    [1, 3, 2, 5, 4, 6, 7, 8, 9, 10],
+    [2, 1, 4, 3, 6, 5, 8, 7, 10, 9],
+    [5, 4, 6, 3, 7, 2, 8, 1, 10, 9],
+    [3, 6, 2, 7, 1, 8, 4, 9, 5, 10],
+    [7, 3, 8, 2, 9, 1, 10, 4, 6, 5],
+    [1, 4, 3, 6, 2, 7, 5, 9, 8, 10],
+    [8, 5, 9, 4, 10, 3, 7, 2, 6, 1],
+    [4, 2, 6, 1, 7, 3, 8, 5, 10, 9],
+], dtype=float) # shape: (NX, NE)
+
+Y = np.array([
+    [1, 2, 3, 5, 4, 6, 8, 7, 9, 10],
+    [9, 8, 7, 6, 5, 4, 3, 2, 1, 0],
+    [4, 6, 1, 8, 3, 7, 2, 10, 5, 9],
+    [2, 8, 4, 7, 1, 9, 3, 6, 10, 5],
+], dtype=float) # shape: (NY, NE)
+
+X = X[:, :NE]  # shape: (NX, NE)
+Y = Y[:, :NE]  # shape: (NY, NE)
+
+# Correlation matrix
+R = np.corrcoef(X, Y)[:NX, NX:] # Shape: (NX, NY)
+
+def test_config_autoadaloc():
+    loc_info = {
+        "name": "autoadaloc",
+        "field": [1, 5, 5],
+        "actnum": None,
+        "threshold": "fixed",
+        "cutoff": 0.4,
+        "type": "soft",
+        "projection": "rank-r"
+    }
+    loc = build_localization_instance(loc_info)
+
+    assert isinstance(loc, AutoAdaptiveLocalization)
+    assert loc.name == "autoadaloc"
+    assert loc.field == [1, 5, 5]
+    assert loc.actnum is None
+    assert loc.cutoff == 0.4
+    assert loc.tapertype == "soft"
+    assert loc.threshold == "fixed"
+
+
+def test_autoadaloc_no_trunc():
+    loc_info = {
+        "name": "autoadaloc",
+        "field": [4, 2],
+        "actnum": None,
+        "threshold": "fixed",
+        "cutoff": 0.005,
+        "type": "hard",
+        "projection": "rank-r",
+    }
+    loc = AutoAdaptiveLocalization(loc_info)
+    taper = loc(X, Y)
+    assert taper.shape == (NX, NY)
+    np.testing.assert_allclose(taper, np.ones((NX, NY)))
+
+
+def test_autoadaloc_partial_trunc():
+    loc_info = {
+        "name": "autoadaloc",
+        "field": [4, 2],
+        "actnum": None,
+        "threshold": "fixed",
+        "cutoff": 0.4,
+        "type": "hard",
+        "projection": "rank-r"
+    }
+    loc = AutoAdaptiveLocalization(loc_info)
+    taper_result = loc(X, Y)
+
+    # Expected taper matrix
+    taper_expected = np.where(np.abs(R) >= loc.cutoff, 1, 0)
+
+    np.testing.assert_allclose(taper_result, taper_expected)
+
+
+def test_autoadaloc_full_trunc():
+    loc_info = {
+        "name": "autoadaloc",
+        "field": [4, 2],
+        "actnum": None,
+        "threshold": "fixed",
+        "cutoff": 1.0,
+        "type": "hard",
+        "projection": "rank-r"
+    }
+    loc = AutoAdaptiveLocalization(loc_info)
+    taper = loc(X, Y)
+    assert taper.shape == (NX, NY)
+    np.testing.assert_allclose(taper, np.zeros((NX, NY)))
+
+
+def test_approx_update_with_autoadaloc():
+    np.random.seed(128928)  # the perturbed observations below are drawn from the global state
+
+    loc_info = {
+        "name": "autoadaloc",
+        "field": [4, 2],
+        "actnum": None,
+        "threshold": "fixed",
+        "cutoff": 0.4,
+        "type": "hard",
+        "projection": "rank-r"
+    }
+
+    # Define ensemble matrices
+    enX = X.copy()
+    enY = Y.copy()
+    enE = enY.mean(axis=1)[:, None] + np.random.normal(0, 0.1, size=enY.shape)
+    Cdd = 0.1*np.ones(NY)
+
+    # Fake scheme providing exactly the context approx_update reads. A real
+    # scheme exposes ensemble-owned state as properties of its own, so a
+    # strategy only ever reads scheme. -- a double can be flat.
+    class FakeScheme:
+        lam = 1.0
+        trunc_energy = 0.98
+        cov_data = Cdd
+        keys_da = {"emp_cov": False}
+
+        def __init__(self, localization):
+            self.localization = localization
+
+    # Step with localization
+    approx = approx_update(FakeScheme(AutoAdaptiveLocalization(loc_info)))
+    step_loc = approx.update(enX, enY, enE).step
+
+    # Step without localization
+    approx_no_loc = approx_update(
+        FakeScheme(type('localization', (object,), {'name': None})())
+    )
+    step_no_loc = approx_no_loc.update(enX, enY, enE).step
+
+    # Calculate step manually without localization
+    scy = np.sqrt(Cdd)
+    PI = (np.eye(NE) - np.ones((NE, NE)) / NE)/ np.sqrt(NE-1)
+    X_anom = enX @ PI
+    Y_anom = (enY @ PI)  / scy[:, None]
+    D_anom = (enE - enY) / scy[:, None]
+    Ur, Sr, VrT = truncSVD(Y_anom, energy=0.98)
+    X1 = Ur.T @ D_anom
+    X2 = X1 / (1 + 1.0 + Sr**2)[:, None]
+    X3 = VrT.T @ np.diag(Sr) @ X2
+    step_expected_no_loc = X_anom @ X3
+
+    # Calculate step manually with localization
+    loc = AutoAdaptiveLocalization(loc_info)
+    Y_anom_proj = np.diag(Sr) @ VrT
+    taper = loc(X=X_anom, Y=Y_anom_proj)
+    Cxy_loc = taper * (X_anom @ Y_anom_proj.T)
+    step_loc_expected = Cxy_loc @ X2
+
+    np.testing.assert_allclose(step_loc, step_loc_expected)
+    np.testing.assert_allclose(step_no_loc, step_expected_no_loc)
+    assert not np.array_equal(step_loc, step_no_loc)
diff --git a/tests/assimilation/test_compression.py b/tests/assimilation/test_compression.py
new file mode 100644
index 00000000..c1f91ab7
--- /dev/null
+++ b/tests/assimilation/test_compression.py
@@ -0,0 +1,150 @@
+"""Seismic vintages are compressed as they enter the prediction matrix, with the observations' leading indices.
+
+A small case shaped like a real one: a seismic type observed at two vintages,
+each a vector over a masked grid, reduced by wavelet thresholding when read;
+an uncompressed point type; a fake simulator that returns the raw vectors.
+"""
+
+import pickle
+
+import numpy as np
+import pandas as pd
+import pytest
+import yaml
+
+from input_output import read_config
+from pipt import ESMDA
+from pipt.ensembles import AssimilationEnsemble
+
+pytest.importorskip("pywt")
+
+DIM = [16, 12, 12]
+N_RAW = int(np.prod(DIM))
+LABELS = [1000, 2000, 3000, 4000]
+VINTAGES = [2000, 4000]
+NE = 6
+
+
+class SeismicSimulator:
+    """Returns one record per report point: a smooth seismic vector plus a scalar, both depending on the state."""
+
+    def __init__(self):
+        self.input_dict = {"parallel": 1, "reporttype": "time", "reportpoints": LABELS, "datatype": ["avo", "grav"]}
+        self.true_order = ["time", LABELS]
+        self.redund_sim = None
+        self.compute_adjoints = False
+
+    @staticmethod
+    def vintage(x1, label):
+        grid = np.linspace(0.0, 3.0, N_RAW)
+        return np.sin(grid * (1 + label / 4000.0)) * (1.0 + 0.2 * x1) + 0.05 * np.cos(7 * grid)
+
+    def run_fwd_sim(self, state, member_index):
+        x1 = float(np.ravel(state["x1"])[0])
+        return [{"avo": self.vintage(x1, label), "grav": 10.0 * x1 + label / 1000.0} for label in LABELS]
+
+
+def _write_case(tmp_path, use_ensemble=False, saveforecast=False):
+    rng = np.random.default_rng(3)
+    np.savez("prior_ensemble.npz", x1=(0.5 + 0.3 * rng.standard_normal(NE))[np.newaxis, :])
+    for i in range(len(VINTAGES)):
+        np.savez(f"mask_{i}.npz", mask=np.ones(DIM, dtype=bool))
+    truth = 0.6
+    obs = pd.DataFrame({"avo": [np.nan] * len(LABELS), "grav": [np.nan] * len(LABELS)}, index=LABELS, dtype=object)
+    obs.index.name = "time"
+    for label in VINTAGES:
+        np.savez(f"avo_{label}.npz", SeismicSimulator.vintage(truth, label) + 0.02 * rng.standard_normal(N_RAW))
+        obs.at[label, "avo"] = f"avo_{label}.npz"
+    for label in LABELS:
+        obs.at[label, "grav"] = 10.0 * truth + label / 1000.0 + 0.1 * rng.standard_normal()
+    obs.to_pickle("true_data.pkl")
+    var = pd.DataFrame({"avo": ["['abs', 1.0]"] * len(LABELS), "grav": ["['abs', 0.01]"] * len(LABELS)}, index=LABELS)
+    var.index.name = "time"
+    var.to_pickle("var.pkl")
+
+    config = {
+        "ensemble": {"ne": NE, "state": ["x1"], "importstate": "prior_ensemble.npz", "prior_x1": {"var": 1.0}},
+        "dataassim": {
+            "scheme": "esmda", "analysis": "approx", "energy": 0.99, "obsname": "time",
+            "data": "true_data.pkl", "datavar": "var.pkl", "nosave": True,
+            "mda": {"tot_assim_steps": 1, "inflation_param": [1]},
+            "compress": {
+                "compress_data": "avo", "dim": DIM, "mask": [f"mask_{i}.npz" for i in range(len(VINTAGES))],
+                "level": 2, "wname": "db2", "threshold_rule": "universal", "th_mult": 1, "use_hard_th": True,
+                "keep_ca": False, "inactive_value": 0.0, "use_ensemble": use_ensemble, "order": "F",
+                "min_noise": [1e-9, 1e-9], "colored_noise": False,
+            },
+        },
+        "simulator": {"reporttype": "time", "reportpoints": LABELS, "datatype": ["avo", "grav"], "parallel": 1},
+    }
+    if saveforecast:
+        config["simulator"]["saveforecast"] = True
+    with open("case.yaml", "w") as handle:
+        yaml.dump(config, handle)
+    cfg_da, cfg_sim, cfg_ens = read_config.read("case.yaml")
+    sim = SeismicSimulator()
+    sim.input_dict.update({k: v for k, v in cfg_sim.items() if k == "saveforecast"})
+    return cfg_da, cfg_ens, sim
+
+
+def test_observations_are_compressed_and_predictions_follow_with_the_same_leading_indices(tmp_path, monkeypatch):
+    monkeypatch.chdir(tmp_path)
+    cfg_da, cfg_ens, sim = _write_case(tmp_path)
+    ensemble = AssimilationEnsemble(cfg_da, cfg_ens, sim)
+
+    # The reader reduced each observed vintage; the layout rows are the coefficient counts.
+    assert len(ensemble.sparse_data) == len(VINTAGES)
+    for vintage, label in enumerate(VINTAGES):
+        row = ensemble.data_layout.row(label, "avo")
+        representation = ensemble.sparse_data[vintage]
+        assert 0 < row.size < representation.num_total_coeff          # thresholding dropped coefficients
+        assert row.size == representation.cd_leading_index.size + representation.ca_leading_index.size
+        np.testing.assert_allclose(ensemble.obs_variance[row.rows], representation.est_noise ** 2, rtol=1e-14)
+
+    ensemble.forecast(ensemble.enX)
+    pred = ensemble.pred_data
+    assert pred.nd == ensemble.obs_vector.size == ensemble.obs_variance.size
+
+    # Each member's raw vintage, compressed by hand with the observed vintage's representation, is what was filled.
+    for vintage, label in enumerate(VINTAGES):
+        row = ensemble.data_layout.row(label, "avo")
+        for j, member in enumerate(ensemble.member_outputs[0]):
+            raw = member[LABELS.index(label)]["avo"]
+            expected, _ = ensemble.sparse_data[vintage].compress(raw)
+            np.testing.assert_array_equal(pred.matrix[row.rows, j], expected)
+    # The uncompressed type is untouched.
+    row = ensemble.data_layout.row(1000, "grav")
+    np.testing.assert_array_equal(pred.matrix[row.rows, 0], ensemble.member_outputs[0][0][0]["grav"])
+
+
+def test_a_scheme_runs_on_the_compressed_data(tmp_path, monkeypatch):
+    monkeypatch.chdir(tmp_path)
+    cfg_da, cfg_ens, sim = _write_case(tmp_path)
+    result = ESMDA.assimilate(cfg_da, cfg_ens, sim, analysis="approx")
+    assert np.all(np.isfinite(result.x))
+    assert result.data_misfit < result.prior_data_misfit
+
+
+def test_use_ensemble_is_refused_with_the_reason(tmp_path, monkeypatch):
+    """Observations are perturbed at construction; there is no forecast yet to widen the indices with."""
+    monkeypatch.chdir(tmp_path)
+    cfg_da, cfg_ens, sim = _write_case(tmp_path, use_ensemble=True)
+    with pytest.raises(ValueError, match="use_ensemble"):
+        AssimilationEnsemble(cfg_da, cfg_ens, sim)
+
+
+def test_reconstructions_are_saved_only_when_the_forecast_is(tmp_path, monkeypatch):
+    monkeypatch.chdir(tmp_path)
+    cfg_da, cfg_ens, sim = _write_case(tmp_path, saveforecast=True)
+    ensemble = AssimilationEnsemble(cfg_da, cfg_ens, sim)
+    ensemble.forecast(ensemble.enX)
+    with open("rec_results.pkl", "rb") as file:
+        rec = pickle.load(file)
+    assert len(rec) == len(VINTAGES) and all(r.shape == (N_RAW, NE) for r in rec)
+
+    (tmp_path / "plain").mkdir()
+    monkeypatch.chdir(tmp_path / "plain")
+    cfg_da, cfg_ens, sim = _write_case(tmp_path / "plain")
+    ensemble = AssimilationEnsemble(cfg_da, cfg_ens, sim)
+    ensemble.forecast(ensemble.enX)
+    assert ensemble.data_rec == [[], []] and not (tmp_path / "plain" / "rec_results.pkl").exists()
diff --git a/tests/assimilation/test_config_boundary_ensemble.py b/tests/assimilation/test_config_boundary_ensemble.py
new file mode 100644
index 00000000..42e0bfa7
--- /dev/null
+++ b/tests/assimilation/test_config_boundary_ensemble.py
@@ -0,0 +1,24 @@
+"""The ensemble works on canonical copies of the config sections it is given."""
+
+import numpy as np
+
+from input_output import read_config
+from pipt.ensembles import AssimilationEnsemble
+from simulator.vanderpol import VanDerPolOscillator
+from test_numerical_characterisation import _write_config, _write_synthetic_case
+
+
+def test_the_ensemble_keeps_its_own_copy_of_the_sections(tmp_path, monkeypatch):
+    monkeypatch.chdir(tmp_path)
+    report_points = _write_synthetic_case(ne=6)
+    cfg_da, cfg_sim, cfg_ens = read_config.read(_write_config("copy", "esmda", "approx", report_points, ne=6))
+    cfg_da["save_folder"] = "elsewhere"                      # the alias, as a script might write it
+    cfg_da.pop("nosave", None)                               # so the folder is in use, not switched off
+    snapshot = {key: (value if not isinstance(value, (list, dict)) else repr(value)) for key, value in cfg_da.items()}
+    ensemble = AssimilationEnsemble(cfg_da, cfg_ens, VanDerPolOscillator(cfg_sim))
+
+    assert ensemble.keys_da["savefolder"] == "elsewhere" and ensemble.save_folder == "elsewhere"
+    assert "datatype" in ensemble.keys_da and ensemble.keys_da["assimindex"] is not None
+    for key in ("datatype", "truedataindex"):
+        assert key not in cfg_da or repr(cfg_da[key]) == snapshot[key]      # nothing written back into the caller's dict
+    np.testing.assert_array_equal(ensemble.enX.shape, (3, 6))
diff --git a/tests/assimilation/test_data_reader.py b/tests/assimilation/test_data_reader.py
new file mode 100644
index 00000000..a98fdff4
--- /dev/null
+++ b/tests/assimilation/test_data_reader.py
@@ -0,0 +1,285 @@
+"""
+Unit tests for DataReader and PETDataFrame integration.
+
+Covers:
+- Reading data from CSV and pickle
+- Handling absolute and relative variance definitions
+- Support for external NPZ-referenced data
+"""
+
+import numpy as np
+import pandas as pd
+import pytest
+from pandas.testing import assert_frame_equal
+
+from misc.structures import PETDataFrame
+from misc.read_input_csv import DataReader
+
+
+# ---------------------------------------------------------------------------
+# Fixtures
+# ---------------------------------------------------------------------------
+
+INDEX = ["idx1", "idx2"]
+INDEX_NAME = "index"
+
+
+@pytest.fixture
+def base_data():
+    """Simple 2x3 dataset."""
+    df = pd.DataFrame(
+        {
+            "keyA": [1.0, 2.0],
+            "keyB": [3.0, 4.0],
+            "keyC": [5.0, 6.0],
+        },
+        index=INDEX,
+    )
+    df.index.name = INDEX_NAME
+    return df
+
+
+@pytest.fixture
+def abs_variance(base_data):
+    """Absolute variance definition."""
+    df = pd.DataFrame(
+        {
+            col: [["abs", val] for val in values]
+            for col, values in {
+                "keyA": [0.1, 0.2],
+                "keyB": [0.3, 0.4],
+                "keyC": [0.5, 0.6],
+            }.items()
+        },
+        index=base_data.index,
+    )
+    df.index.name = INDEX_NAME
+    return df
+
+
+@pytest.fixture
+def rel_variance(base_data):
+    """Relative variance definition."""
+    def rel(val, obs):
+        return float(np.sqrt(val) / (obs * 0.01))
+
+    df = pd.DataFrame(
+        {
+            col: [
+                ["rel", rel(var, base_data.loc[idx, col])]
+                for idx, var in zip(INDEX, values)
+            ]
+            for col, values in {
+                "keyA": [0.1, 0.2],
+                "keyB": [0.3, 0.4],
+                "keyC": [0.5, 0.6],
+            }.items()
+        },
+        index=base_data.index,
+    )
+    df.index.name = INDEX_NAME
+    return df
+
+
+@pytest.fixture
+def expected_variance():
+    """Expected variance after processing."""
+    df = PETDataFrame(
+        {
+            "keyA": [0.1, 0.2],
+            "keyB": [0.3, 0.4],
+            "keyC": [0.5, 0.6],
+        },
+        index=INDEX,
+    )
+    df.index.name = INDEX_NAME
+    return df
+
+
+@pytest.fixture
+def data_with_npz(tmp_path):
+    """DataFrame referencing an external NPZ file."""
+    df = pd.DataFrame(
+        {
+            "keyA": [1.0, 2.0, 3.0],
+            "keyB": [4.0, 5.0, 6.0],
+            "keyC": [7.0, 8.0, 9.0],
+            "keyNPZ": [None, None, None],
+        },
+        index=["idx1", "idx2", "idx3"],
+    )
+    df.index.name = INDEX_NAME
+
+    # Create NPZ file
+    npz_path = tmp_path / "data.npz"
+    array = np.arange(10, 110, 10)
+    np.savez(npz_path, array)
+
+    df.loc["idx2", "keyNPZ"] = str(npz_path)
+
+    return df, array
+
+
+# ---------------------------------------------------------------------------
+# Helpers
+# ---------------------------------------------------------------------------
+
+def read_data(path):
+    reader = DataReader({"data": str(path), "datavar": ""})
+    return reader.get_data()
+
+
+def read_data_and_variance(data_path, var_path):
+    reader = DataReader(
+        {"data": str(data_path), "datavar": str(var_path)}
+    )
+    data = reader.get_data()
+    variance = reader.get_variance(data)
+    return data, variance
+
+
+# ---------------------------------------------------------------------------
+# Tests: Data Reading
+# ---------------------------------------------------------------------------
+
+class TestDataReading:
+
+    def test_read_pickle(self, tmp_path, base_data):
+        path = tmp_path / "data.pkl"
+        base_data.to_pickle(path)
+
+        result = read_data(path)
+
+        assert isinstance(result, PETDataFrame)
+        assert_frame_equal(result, base_data)
+
+    def test_read_csv(self, tmp_path, base_data):
+        path = tmp_path / "data.csv"
+        base_data.to_csv(path)
+
+        result = read_data(path)
+
+        assert isinstance(result, PETDataFrame)
+        assert_frame_equal(result, base_data)
+
+
+# ---------------------------------------------------------------------------
+# Tests: Variance Handling
+# ---------------------------------------------------------------------------
+
+class TestVarianceHandling:
+
+    def test_absolute_variance_pickle(
+        self, tmp_path, base_data, abs_variance, expected_variance
+    ):
+        data_path = tmp_path / "data.pkl"
+        var_path = tmp_path / "var.pkl"
+
+        base_data.to_pickle(data_path)
+        abs_variance.to_pickle(var_path)
+
+        _, result = read_data_and_variance(data_path, var_path)
+
+        assert isinstance(result, PETDataFrame)
+        assert_frame_equal(result, expected_variance, atol=1e-12, rtol=1e-12)
+
+    def test_relative_variance_pickle(
+        self, tmp_path, base_data, rel_variance, expected_variance
+    ):
+        data_path = tmp_path / "data.pkl"
+        var_path = tmp_path / "var.pkl"
+
+        base_data.to_pickle(data_path)
+        rel_variance.to_pickle(var_path)
+
+        _, result = read_data_and_variance(data_path, var_path)
+
+        assert isinstance(result, PETDataFrame)
+        assert_frame_equal(result, expected_variance, atol=1e-12, rtol=1e-12)
+
+    def test_absolute_variance_csv(
+        self, tmp_path, base_data, abs_variance, expected_variance
+    ):
+        data_path = tmp_path / "data.csv"
+        var_path = tmp_path / "var.csv"
+
+        base_data.to_csv(data_path)
+        abs_variance.to_csv(var_path)
+
+        _, result = read_data_and_variance(data_path, var_path)
+
+        assert isinstance(result, PETDataFrame)
+        assert_frame_equal(result, expected_variance, atol=1e-12, rtol=1e-12)
+
+
+# ---------------------------------------------------------------------------
+# Tests: NPZ Integration
+# ---------------------------------------------------------------------------
+
+class TestNPZHandling:
+
+    def test_npz_loading(self, tmp_path, data_with_npz):
+        df, expected_array = data_with_npz
+
+        path = tmp_path / "data.pkl"
+        df.to_pickle(path)
+
+        result = read_data(path)
+
+        flattened_expected = np.concatenate([
+            [1.0, 4.0, 7.0],
+            [2.0, 5.0, 8.0],
+            expected_array,
+            [3.0, 6.0, 9.0],
+        ])
+
+        assert isinstance(result, PETDataFrame)
+
+        # Check NPZ content
+        np.testing.assert_array_equal(
+            result.loc["idx2", "keyNPZ"],
+            expected_array,
+        )
+
+        # Check flattened representation
+        assert result.to_matrix().shape == (len(flattened_expected),)
+        np.testing.assert_array_equal(result.to_matrix(), flattened_expected)
+
+
+
+
+
+
+def test_the_ensemble_observation_vector_matches_the_frame_flatten(tmp_path, monkeypatch):
+    """`obs_vector` replaces `data_df.to_matrix()` on every scheme; the two must agree."""
+    from input_output import read_config
+    from pipt.ensembles import AssimilationEnsemble
+    from simulator.vanderpol import VanDerPolOscillator
+    from test_numerical_characterisation import _write_config, _write_synthetic_case
+
+    monkeypatch.chdir(tmp_path)
+    report_points = _write_synthetic_case(ne=8)
+    cfg_da, cfg_sim, cfg_ens = read_config.read(_write_config("layout", "esmda", "approx", report_points, ne=8))
+    ensemble = AssimilationEnsemble(cfg_da, cfg_ens, VanDerPolOscillator(cfg_sim))
+    np.testing.assert_array_equal(ensemble.obs_vector, ensemble.data_df.to_matrix())
+    assert ensemble.data_layout.nd == ensemble.obs_vector.shape[0]
+
+
+def test_the_observation_variance_matches_the_frame_flatten_and_rejects_nan(tmp_path, monkeypatch):
+    """`obs_variance` replaces construct_data_cov, whose NaN filter silently shortened the covariance."""
+    from input_output import read_config
+    from pipt.ensembles import AssimilationEnsemble
+    from simulator.vanderpol import VanDerPolOscillator
+    from test_numerical_characterisation import _write_config, _write_synthetic_case
+
+    monkeypatch.chdir(tmp_path)
+    report_points = _write_synthetic_case(ne=8)
+    cfg_da, cfg_sim, cfg_ens = read_config.read(_write_config("variance", "esmda", "approx", report_points, ne=8))
+    ensemble = AssimilationEnsemble(cfg_da, cfg_ens, VanDerPolOscillator(cfg_sim))
+    np.testing.assert_array_equal(ensemble.obs_variance, ensemble.data_var_df.to_matrix())
+    assert ensemble.obs_variance.shape == ensemble.obs_vector.shape
+
+    label, column = ensemble.data_var_df.index[2], ensemble.data_var_df.columns[0]
+    ensemble.data_var_df.at[label, column] = np.nan
+    with pytest.raises(ValueError, match="variance is NaN"):
+        ensemble._observation_variance()
diff --git a/tests/assimilation/test_distance_loc.py b/tests/assimilation/test_distance_loc.py
new file mode 100644
index 00000000..7a11b66f
--- /dev/null
+++ b/tests/assimilation/test_distance_loc.py
@@ -0,0 +1,589 @@
+"""Tests for distance-based localization (DistanceLocalization).
+
+Covers:
+- Kernel mathematical correctness (GaspariCohn, FurrerBengtsson, Region)
+- Geometry helpers (_build_transform, _crop_kernel)
+- DistanceLocalization configuration and factory
+- Integration: output shape, spatial mask values, multi-parameter behavior
+"""
+
+from __future__ import annotations
+
+import pickle
+
+import numpy as np
+import pandas as pd
+import pytest
+from scipy import sparse
+
+from pipt.localization import build_localization_instance
+from pipt.localization.distance_localization import (
+    DistanceLocalization,
+    FurrerBengtssonKernel,
+    GaspariCohnKernel,
+    RegionKernel,
+    _build_transform,
+    _crop_kernel,
+)
+
+# ---------------------------------------------------------------------------
+# Shared test fixtures
+# ---------------------------------------------------------------------------
+
+NZ, NX, NY = 1, 10, 10
+FIELD = [NZ, NX, NY]
+
+
+def _make_data(data_type: str = "pressure", time: float = 1.0, cell: int = 5) -> pd.DataFrame:
+    """Return a minimal one-column DataFrame for DistanceLocalization."""
+    return pd.DataFrame({data_type: [cell]}, index=[time])
+
+
+def _make_info(
+    taper: str = "region",
+    x_pos: int = 5,
+    y_pos: int = 5,
+    z_pos: int = 0,
+    radius: int = 4,
+    z_range: str = ":",
+    anisotropy: float = 1.0,
+    rotation: float = 0.0,
+    data_type: str = "pressure",
+    time: float = 1.0,
+    param: str = "perm",
+    taper_func: str = "region",
+) -> dict:
+    """Build a minimal info dict with one inline CSV row (trailing comma trick)."""
+    row = (
+        f"{taper} {x_pos} {y_pos} {z_pos} {radius} {z_range} "
+        f"{anisotropy} {rotation} {data_type} {time} {param},"
+    )
+    return {"field": FIELD, "taper_func": taper_func, row: None}
+
+
+# ===========================================================================
+# 1. GaspariCohn kernel – mathematical properties
+# ===========================================================================
+
+class TestGaspariCohnKernel:
+
+    def test_center_is_one(self):
+        """Value at the kernel center (ratio = 0) must be exactly 1."""
+        k = GaspariCohnKernel().build(
+            radius=4, anisotropy_ratio=1.0, rotation_deg=0.0, field_shape=FIELD
+        )
+        cy, cx = k.shape[0] // 2, k.shape[1] // 2
+        assert k[cy, cx] == pytest.approx(1.0)
+
+    def test_values_in_unit_interval(self):
+        """All GC values must lie in [0, 1]."""
+        k = GaspariCohnKernel().build(
+            radius=4, anisotropy_ratio=1.0, rotation_deg=0.0, field_shape=FIELD
+        )
+        assert np.all(k >= 0)
+        assert np.all(k <= 1.0 + 1e-12)
+
+    def test_outer_formula_zero_at_ratio_two(self):
+        """Outer-branch formula evaluates to 0 at ratio = 2 (compact support boundary)."""
+        r = 2.0
+        value = (
+            (1.0 / 12.0) * r ** 5
+            - 0.5  * r ** 4
+            + 0.625 * r ** 3
+            + (5.0 / 3.0) * r ** 2
+            - 5.0  * r
+            + 4.0
+            - (2.0 / 3.0) / r
+        )
+        assert value == pytest.approx(0.0, abs=1e-12)
+
+    def test_inner_outer_continuity_at_ratio_one(self):
+        """Inner and outer branch formulas must agree at ratio = 1 (C¹ junction)."""
+        r = 1.0
+        inner = (
+            -0.25 * r ** 5
+            + 0.5  * r ** 4
+            + 0.625 * r ** 3
+            - (5.0 / 3.0) * r ** 2
+            + 1.0
+        )
+        outer = (
+            (1.0 / 12.0) * r ** 5
+            - 0.5  * r ** 4
+            + 0.625 * r ** 3
+            + (5.0 / 3.0) * r ** 2
+            - 5.0  * r
+            + 4.0
+            - (2.0 / 3.0) / r
+        )
+        assert inner == pytest.approx(outer, abs=1e-12)
+
+    def test_center_is_global_maximum(self):
+        """Center cell must have the largest value in the kernel."""
+        k = GaspariCohnKernel().build(
+            radius=4, anisotropy_ratio=1.0, rotation_deg=0.0, field_shape=FIELD
+        )
+        cy, cx = k.shape[0] // 2, k.shape[1] // 2
+        assert k[cy, cx] == pytest.approx(k.max(), rel=1e-10)
+
+    def test_radially_symmetric_no_anisotropy(self):
+        """Without anisotropy or rotation the kernel must be symmetric about the center."""
+        k = GaspariCohnKernel().build(
+            radius=4, anisotropy_ratio=1.0, rotation_deg=0.0, field_shape=FIELD
+        )
+        np.testing.assert_allclose(k, k[::-1, :], atol=1e-12)
+        np.testing.assert_allclose(k, k[:, ::-1], atol=1e-12)
+
+    def test_decreases_from_center_along_central_row(self):
+        """GC kernel values must be non-increasing moving outward along the central row."""
+        k = GaspariCohnKernel().build(
+            radius=4, anisotropy_ratio=1.0, rotation_deg=0.0, field_shape=FIELD
+        )
+        cy, cx = k.shape[0] // 2, k.shape[1] // 2
+        # left half: columns 0..cx – values should increase toward center
+        assert np.all(np.diff(k[cy, : cx + 1]) >= -1e-12)
+        # right half: columns cx..end – values should decrease from center
+        assert np.all(np.diff(k[cy, cx:]) <= 1e-12)
+
+
+# ===========================================================================
+# 2. FurrerBengtsson kernel – mathematical properties
+# ===========================================================================
+
+class TestFurrerBengtssonKernel:
+
+    def test_center_value_formula(self):
+        """FB center value must equal ne / (ne + 2) (weight = 1 at d = 0)."""
+        ne = 50
+        k = FurrerBengtssonKernel().build(
+            radius=4, anisotropy_ratio=1.0, rotation_deg=0.0,
+            field_shape=FIELD, ensemble_size=ne,
+        )
+        cy, cx = k.shape[0] // 2, k.shape[1] // 2
+        # At d=0: weight=1  →  fb = (ne * 1) / (1*(ne+1) + 1) = ne/(ne+2)
+        assert k[cy, cx] == pytest.approx(ne / (ne + 2), rel=1e-6)
+
+    def test_values_non_negative(self):
+        """All FB values must be non-negative."""
+        k = FurrerBengtssonKernel().build(
+            radius=4, anisotropy_ratio=1.0, rotation_deg=0.0,
+            field_shape=FIELD, ensemble_size=20,
+        )
+        assert np.all(k >= 0)
+
+    def test_values_bounded_above(self):
+        """FB values must not exceed ne / (ne + 2) (the maximum at the center)."""
+        ne = 20
+        k = FurrerBengtssonKernel().build(
+            radius=4, anisotropy_ratio=1.0, rotation_deg=0.0,
+            field_shape=FIELD, ensemble_size=ne,
+        )
+        assert np.all(k <= ne / (ne + 2) + 1e-12)
+
+    def test_default_ensemble_size_is_50(self):
+        """Passing ensemble_size=None must produce the same kernel as ensemble_size=50."""
+        k_none = FurrerBengtssonKernel().build(
+            radius=4, anisotropy_ratio=1.0, rotation_deg=0.0,
+            field_shape=FIELD, ensemble_size=None,
+        )
+        k_50 = FurrerBengtssonKernel().build(
+            radius=4, anisotropy_ratio=1.0, rotation_deg=0.0,
+            field_shape=FIELD, ensemble_size=50,
+        )
+        np.testing.assert_array_equal(k_none, k_50)
+
+    def test_ensemble_size_affects_kernel(self):
+        """A larger ensemble size must produce a different kernel from a smaller one."""
+        k_small = FurrerBengtssonKernel().build(
+            radius=4, anisotropy_ratio=1.0, rotation_deg=0.0,
+            field_shape=FIELD, ensemble_size=5,
+        )
+        k_large = FurrerBengtssonKernel().build(
+            radius=4, anisotropy_ratio=1.0, rotation_deg=0.0,
+            field_shape=FIELD, ensemble_size=1000,
+        )
+        assert not np.allclose(k_small, k_large)
+
+
+# ===========================================================================
+# 3. Region kernel
+# ===========================================================================
+
+class TestRegionKernel:
+
+    def test_always_returns_1x1_ones(self):
+        """RegionKernel must return a (1, 1) array containing 1.0, ignoring all args."""
+        k = RegionKernel().build()
+        assert k.shape == (1, 1)
+        assert k[0, 0] == 1.0
+
+    def test_ignores_all_arguments(self):
+        """RegionKernel output must be independent of radius, anisotropy, rotation, etc."""
+        k1 = RegionKernel().build(
+            radius=100, anisotropy_ratio=3.0, rotation_deg=45.0,
+            field_shape=[5, 20, 20], ensemble_size=100,
+        )
+        k2 = RegionKernel().build()
+        np.testing.assert_array_equal(k1, k2)
+
+
+# ===========================================================================
+# 4. Geometry helpers
+# ===========================================================================
+
+class TestBuildTransform:
+
+    def test_identity_with_unit_ratio_and_zero_rotation(self):
+        """anisotropy_ratio=1, rotation_deg=0 must yield the 2×2 identity."""
+        T = _build_transform(anisotropy_ratio=1.0, rotation_deg=0.0)
+        np.testing.assert_allclose(T, np.eye(2), atol=1e-12)
+
+    def test_pure_anisotropy_scales_first_axis(self):
+        """anisotropy_ratio=2 with zero rotation should scale the x-axis by 0.5."""
+        T = _build_transform(anisotropy_ratio=2.0, rotation_deg=0.0)
+        np.testing.assert_allclose(T, np.array([[0.5, 0.0], [0.0, 1.0]]), atol=1e-12)
+
+    def test_pure_rotation_90_degrees(self):
+        """90° rotation with unit anisotropy must correspond to a 90° rotation matrix."""
+        T = _build_transform(anisotropy_ratio=1.0, rotation_deg=90.0)
+        # cos(90°)=0, sin(90°)=1 → [[0, 1], [-1, 0]]
+        expected = np.array([[0.0, 1.0], [-1.0, 0.0]])
+        np.testing.assert_allclose(T, expected, atol=1e-12)
+
+
+class TestCropKernel:
+
+    def test_removes_zero_border_rows_and_columns(self):
+        """_crop_kernel must trim zero-only rows and columns from all four sides."""
+        kernel = np.zeros((7, 7))
+        kernel[2:5, 2:5] = 1.0
+        cropped = _crop_kernel(kernel)
+        assert cropped.shape == (3, 3)
+        assert np.all(cropped == 1.0)
+
+    def test_no_trimming_when_borders_nonzero(self):
+        """Output must equal input when no zero-only borders exist."""
+        kernel = np.ones((4, 4))
+        cropped = _crop_kernel(kernel)
+        assert cropped.shape == (4, 4)
+
+    def test_asymmetric_zero_border(self):
+        """Trimming must handle asymmetric padding correctly."""
+        kernel = np.zeros((5, 6))
+        kernel[1:3, 2:5] = 1.0
+        cropped = _crop_kernel(kernel)
+        assert cropped.shape == (2, 3)
+        assert np.all(cropped == 1.0)
+
+
+# ===========================================================================
+# 5. DistanceLocalization configuration
+# ===========================================================================
+
+class TestDistanceLocalizationConfig:
+
+    def test_factory_returns_distance_loc_instance(self):
+        """`build_localization_instance` must return a DistanceLocalization for 'distance_loc'."""
+        info = {"name": "distance_loc", "field": FIELD, "taper_func": "region"}
+        loc = build_localization_instance(info)
+        assert isinstance(loc, DistanceLocalization)
+        assert loc.name == "distance_loc"
+
+    def test_unknown_taper_func_raises_value_error(self):
+        """An unrecognised taper_func must raise ValueError with informative message."""
+        info = {"field": FIELD, "taper_func": "bogus_kernel"}
+        with pytest.raises(ValueError, match="Unknown taper_func"):
+            DistanceLocalization(info)
+
+    def test_no_data_produces_empty_entries_and_cache(self):
+        """Without a data DataFrame, _entries and _mask_cache must both be empty."""
+        loc = DistanceLocalization({"field": FIELD, "taper_func": "region"})
+        assert loc._entries == {}
+        assert loc._mask_cache == {}
+
+    def test_region_kernel_is_selected(self):
+        """taper_func='region' must be accepted without error."""
+        loc = DistanceLocalization({"field": FIELD, "taper_func": "region"})
+        assert loc is not None
+
+    def test_gc_kernel_is_selected(self):
+        """taper_func='gc' must be accepted without error."""
+        loc = DistanceLocalization({"field": FIELD, "taper_func": "gc"})
+        assert loc is not None
+
+    def test_fb_kernel_is_selected(self):
+        """taper_func='fb' must be accepted without error."""
+        loc = DistanceLocalization({"field": FIELD, "taper_func": "fb"})
+        assert loc is not None
+
+    def test_field_stored_correctly(self):
+        """Field dimensions must be stored as-is from the info dict."""
+        loc = DistanceLocalization({"field": [2, 8, 12], "taper_func": "region"})
+        assert loc.field == [2, 8, 12]
+
+    def test_data_types_and_indices_extracted_from_dataframe(self):
+        """data_types and data_indices must be inferred from the DataFrame."""
+        data = _make_data(data_type="bhp", time=3.5, cell=2)
+        info = _make_info(data_type="bhp", time=3.5, param="perm")
+        loc = DistanceLocalization(info, data=data, parameters=["perm"])
+        assert loc.data_types == ["bhp"]
+        assert loc.data_indices == [3.5]
+
+    def test_inline_csv_row_populates_entry(self):
+        """An inline CSV row must create an entry with the correct taper and position."""
+        data = _make_data()
+        info = _make_info(taper="region", x_pos=3, y_pos=7, z_pos=0, radius=5)
+        loc = DistanceLocalization(info, data=data, parameters=["perm"])
+        key = ("pressure", 1.0, "perm")
+        assert key in loc._entries
+        entry = loc._entries[key]
+        assert entry.taper == "region"
+        assert entry.radius == 5
+        assert entry.positions == [[3, 7, 0]]
+
+    def test_mask_cache_built_for_active_entry(self):
+        """_mask_cache must contain a precomputed array for each distinct kernel config."""
+        data = _make_data()
+        info = _make_info(taper="region", radius=4)
+        loc = DistanceLocalization(info, data=data, parameters=["perm"])
+        assert len(loc._mask_cache) == 1
+        cache_key = ("region", 4, 1.0, 0.0)
+        assert cache_key in loc._mask_cache
+
+
+# ===========================================================================
+# 6. Integration – output shape and spatial values
+# ===========================================================================
+
+class TestDistanceLocalizationOutput:
+
+    # ------------------------------------------------------------------
+    # helpers
+    # ------------------------------------------------------------------
+
+    def _loc(self, taper="region", taper_func="region", radius=4, x_pos=5, y_pos=5):
+        data = _make_data()
+        info = _make_info(
+            taper=taper, taper_func=taper_func, radius=radius,
+            x_pos=x_pos, y_pos=y_pos,
+        )
+        return DistanceLocalization(info, data=data, parameters=["perm"])
+
+    # ------------------------------------------------------------------
+    # shape / type
+    # ------------------------------------------------------------------
+
+    def test_output_is_sparse_matrix(self):
+        """__call__ must return a scipy sparse matrix."""
+        result = self._loc()()
+        assert sparse.issparse(result)
+
+    def test_output_shape_single_obs_single_param(self):
+        """Output shape must be (n_active_cells, n_obs) = (NZ*NX*NY, 1)."""
+        result = self._loc()()
+        assert result.shape == (NZ * NX * NY, 1)
+
+    # ------------------------------------------------------------------
+    # Region kernel spatial correctness
+    # ------------------------------------------------------------------
+
+    def test_region_kernel_activates_exactly_one_cell(self):
+        """Region kernel at (x=5, y=5, z=0) must activate only cell index 5*NY+5."""
+        result = self._loc(x_pos=5, y_pos=5)()
+        dense = result.toarray().ravel()
+        expected_idx = 5 * NY + 5      # flat index in (NZ, NX, NY) field
+        assert dense[expected_idx] == pytest.approx(1.0)
+        mask = np.zeros(NZ * NX * NY, dtype=bool)
+        mask[expected_idx] = True
+        assert np.all(dense[~mask] == 0.0)
+
+    def test_region_kernel_position_corner(self):
+        """Region kernel placed at corner (x=0, y=0) must activate cell index 0."""
+        result = self._loc(x_pos=0, y_pos=0)()
+        dense = result.toarray().ravel()
+        assert dense[0] == pytest.approx(1.0)
+        assert np.sum(dense > 0) == 1
+
+    # ------------------------------------------------------------------
+    # GC kernel spatial correctness
+    # ------------------------------------------------------------------
+
+    def test_gc_output_in_unit_interval(self):
+        """All GC localization weights must lie in [0, 1]."""
+        result = self._loc(taper="gc", taper_func="gc", radius=5)()
+        dense = result.toarray()
+        assert np.all(dense >= 0)
+        assert np.all(dense <= 1.0 + 1e-10)
+
+    def test_gc_center_cell_is_maximum(self):
+        """GC weight at the kernel center cell must equal the global maximum."""
+        result = self._loc(taper="gc", taper_func="gc", radius=8, x_pos=5, y_pos=5)()
+        dense = result.toarray().ravel()
+        center_idx = 5 * NY + 5
+        assert dense[center_idx] == pytest.approx(dense.max(), rel=1e-10)
+
+    def test_gc_taper_decreases_from_center_along_row(self):
+        """GC weights along the row through the kernel center must taper outward."""
+        result = self._loc(taper="gc", taper_func="gc", radius=8, x_pos=5, y_pos=5)()
+        grid = result.toarray().reshape(NZ, NX, NY)[0]  # shape (NX, NY)
+        row = grid[5, :]                          # row at x=5, y=0..9
+        left_half  = row[:6]                      # y=0..5 → should increase to center
+        right_half = row[5:]                      # y=5..9 → should decrease from center
+        assert np.all(np.diff(left_half)  >= -1e-10), "GC must increase toward center"
+        assert np.all(np.diff(right_half) <= 1e-10),  "GC must decrease from center"
+
+    def test_gc_taper_decreases_from_center_along_column(self):
+        """GC weights along the column through the kernel center must also taper outward."""
+        result = self._loc(taper="gc", taper_func="gc", radius=8, x_pos=5, y_pos=5)()
+        grid = result.toarray().reshape(NZ, NX, NY)[0]  # shape (NX, NY)
+        col = grid[:, 5]                          # column at y=5, x=0..9
+        top_half    = col[:6]                     # x=0..5 → increase toward center
+        bottom_half = col[5:]                     # x=5..9 → decrease from center
+        assert np.all(np.diff(top_half)    >= -1e-10), "GC must increase toward center"
+        assert np.all(np.diff(bottom_half) <= 1e-10),  "GC must decrease from center"
+
+    # ------------------------------------------------------------------
+    # FB kernel spatial correctness
+    # ------------------------------------------------------------------
+
+    def test_fb_output_range(self):
+        """All FB localization weights must lie in [0, ne/(ne+2)]."""
+        ne = 20
+        data = _make_data()
+        info = _make_info(taper="fb", taper_func="fb", radius=5)
+        loc = DistanceLocalization(info, data=data, parameters=["perm"], ensemble_size=ne)
+        result = loc()
+        dense = result.toarray()
+        assert np.all(dense >= 0)
+        assert np.all(dense <= ne / (ne + 2) + 1e-10)
+
+    # ------------------------------------------------------------------
+    # Multi-parameter: unconfigured parameter → zero columns
+    # ------------------------------------------------------------------
+
+    def test_unconfigured_param_gives_zero_weights(self):
+        """Parameters with no localization entry must produce all-zero weight columns."""
+        data = _make_data()
+        info = _make_info()                       # configured only for "perm"
+        prior_info = {"other": {"nx": NX, "ny": NY, "nz": NZ}}
+        loc = DistanceLocalization(
+            info, data=data, parameters=["perm", "other"], prior_info=prior_info
+        )
+        result = loc()
+        n_cells = NZ * NX * NY
+        assert result.shape == (2 * n_cells, 1)
+        dense = result.toarray()
+        assert np.any(dense[:n_cells] > 0),    "perm weights should have non-zero entries"
+        np.testing.assert_array_equal(dense[n_cells:], 0.0)
+
+    def test_two_configured_params_correct_output_shape(self):
+        """With two configured parameters the output must span both cell-spaces."""
+        data = _make_data()
+        # Two rows: one for perm, one for poro
+        row_perm = "region 5 5 0 4 : 1.0 0.0 pressure 1.0 perm,"
+        row_poro = "region 3 3 0 4 : 1.0 0.0 pressure 1.0 poro"
+        # Combine as a single comma-separated multi-row key
+        multi_row_key = f"{row_perm}{row_poro}"
+        info = {"field": FIELD, "taper_func": "region", multi_row_key: None}
+        loc = DistanceLocalization(info, data=data, parameters=["perm", "poro"])
+        result = loc()
+        assert result.shape == (2 * NZ * NX * NY, 1)
+
+    # ------------------------------------------------------------------
+    # Active-cell mask
+    # ------------------------------------------------------------------
+
+    def test_actnum_reduces_a_localized_parameter_to_the_active_cells(self, tmp_path):
+        """A localized parameter used to contribute one row per grid cell while an
+        unlocalized one contributed a row per active cell, so the operator came out
+        with the wrong number of rows: 160 instead of 120 on this 60-of-100 case."""
+        n_cells = NZ * NX * NY
+        n_active = 60
+        actnum = np.zeros(n_cells, dtype=bool)
+        actnum[:n_active] = True
+        actnum_file = tmp_path / "active.npz"
+        np.savez(actnum_file, actnum=actnum)
+
+        info = {**_make_info(), "actnum": str(actnum_file)}
+        prior_info = {"other": {"nx": NX, "ny": NY, "nz": NZ}}
+        loc = DistanceLocalization(
+            info, data=_make_data(), parameters=["perm", "other"], prior_info=prior_info
+        )
+        result = loc()
+
+        assert result.shape == (2 * n_active, 1)
+        dense = result.toarray()
+        assert np.any(dense[:n_active] > 0)                  # the localized parameter
+        np.testing.assert_array_equal(dense[n_active:], 0.0)  # the unlocalized one
+
+    def test_an_all_active_actnum_matches_giving_none(self, tmp_path):
+        actnum_file = tmp_path / "all.npz"
+        np.savez(actnum_file, actnum=np.ones(NZ * NX * NY, dtype=bool))
+
+        without = DistanceLocalization(_make_info(), data=_make_data(), parameters=["perm"])()
+        with_all = DistanceLocalization(
+            {**_make_info(), "actnum": str(actnum_file)}, data=_make_data(), parameters=["perm"]
+        )()
+
+        np.testing.assert_array_equal(without.toarray(), with_all.toarray())
+
+    # ------------------------------------------------------------------
+    # Pickled mask files
+    # ------------------------------------------------------------------
+
+    def test_a_pickled_localization_file_is_read(self, tmp_path):
+        """Pickled files hold plain dicts. They were returned unconverted, so the first
+        thing that asked for `.taper` raised AttributeError and no pickled mask file
+        could be used at all."""
+        legacy = {
+            ("pressure", 1.0, "perm"): {"taper_func": "gc", "position": [[5, 5, 0]],
+                                        "range": [4, ":"], "anisotropi": [1.0, 0.0]},
+            ("pressure", 1.0, "poro"): {"taper_func": None, "position": None,
+                                        "range": None, "anisotropi": None},
+        }
+        path = tmp_path / "masks.p"
+        with open(path, "wb") as handle:
+            pickle.dump(legacy, handle)
+
+        prior_info = {p: {"nx": NX, "ny": NY, "nz": NZ} for p in ("perm", "poro")}
+        loc = DistanceLocalization(
+            {"field": FIELD, "taper_func": "gc", "locfile": str(path)},
+            data=_make_data(), parameters=["perm", "poro"], prior_info=prior_info,
+        )
+        dense = loc().toarray()
+        n_cells = NZ * NX * NY
+
+        assert dense.shape == (2 * n_cells, 1)
+        assert np.any(dense[:n_cells] > 0)                    # perm is tapered
+        np.testing.assert_array_equal(dense[n_cells:], 0.0)   # poro has no entry
+
+    def test_a_pickled_radius_without_a_z_range_still_reads(self, tmp_path):
+        """Older files wrote `range` as the radius alone rather than [radius, z_range]."""
+        path = tmp_path / "masks.pkl"
+        with open(path, "wb") as handle:
+            pickle.dump({("pressure", 1.0, "perm"): {
+                "taper_func": "gc", "position": [[5, 5, 0]], "range": 4, "anisotropi": [1.0, 0.0]
+            }}, handle)
+
+        loc = DistanceLocalization(
+            {"field": FIELD, "taper_func": "gc", "locfile": str(path)},
+            data=_make_data(), parameters=["perm"],
+        )
+
+        assert np.any(loc().toarray() > 0)
+
+    # ------------------------------------------------------------------
+    # z_range selection
+    # ------------------------------------------------------------------
+
+    def test_specific_z_range_limits_cells_to_one_layer(self):
+        """When z_range is a layer index, the mask must cover only that z-layer."""
+        nz_multi = 3
+        field_multi = [nz_multi, NX, NY]
+        data = _make_data()
+        row = "region 5 5 1 4 1 1.0 0.0 pressure 1.0 perm,"
+        info = {"field": field_multi, "taper_func": "region", row: None}
+        loc = DistanceLocalization(info, data=data, parameters=["perm"])
+        result = loc()
+        # With z_range="1", the mask is NX*NY cells (one layer)
+        assert result.shape == (NX * NY * nz_multi, 1)
diff --git a/tests/assimilation/test_ensemble_injection.py b/tests/assimilation/test_ensemble_injection.py
new file mode 100644
index 00000000..c8190353
--- /dev/null
+++ b/tests/assimilation/test_ensemble_injection.py
@@ -0,0 +1,63 @@
+"""A scheme can run on an ensemble it was handed, instead of building one.
+
+Two schemes can then share one prior and its forecasts, and a test can hand a
+scheme a stand-in without the config, data files and simulator a real ensemble
+needs.
+"""
+
+import numpy as np
+import pytest
+
+from input_output import read_config
+from pipt import ESMDA, EnKF, GNEnRML, LMEnRML
+from pipt.ensembles import AssimilationEnsemble
+from pipt.update_schemes.core import AssimilationScheme
+from simulator.vanderpol import VanDerPolOscillator
+from test_numerical_characterisation import _write_config, _write_synthetic_case
+
+
+@pytest.fixture
+def configs(tmp_path, monkeypatch):
+    monkeypatch.chdir(tmp_path)
+    report_points = _write_synthetic_case()
+    cfg_da, cfg_sim, cfg_ens = read_config.read(_write_config("inject", "esmda", "approx", report_points))
+    # The ES-MDA writer emits only the `mda` block; the iterative schemes read `iteration`.
+    cfg_da["iteration"] = {"max_iter": 3, "lambda": 10, "lambda_factor": 5, "trunc_energy": 0.99}
+    return cfg_da, cfg_sim, cfg_ens
+
+
+@pytest.mark.parametrize("scheme_cls, analysis", [(ESMDA, "approx"), (LMEnRML, "approx"), (GNEnRML, "subspace"), (EnKF, "approx")])
+def test_a_handed_in_ensemble_is_used_and_no_second_one_is_built(configs, monkeypatch, scheme_cls, analysis):
+    cfg_da, cfg_sim, cfg_ens = configs
+    ensemble = AssimilationEnsemble(cfg_da, cfg_ens, VanDerPolOscillator(cfg_sim))
+
+    built = []
+    original = AssimilationEnsemble.__init__
+
+    def counting_init(self, *args, **kwargs):
+        built.append(self)
+        original(self, *args, **kwargs)
+
+    monkeypatch.setattr(AssimilationEnsemble, "__init__", counting_init)
+    scheme = scheme_cls(cfg_da, cfg_ens, ensemble.sim, analysis=analysis, ensemble=ensemble)
+
+    assert scheme.ensemble is ensemble
+    assert built == []
+
+
+def test_the_default_collaborator_is_declared_on_the_base():
+    assert AssimilationScheme.ENSEMBLE_CLASS is AssimilationEnsemble
+    for scheme_cls in (ESMDA, LMEnRML, GNEnRML, EnKF):
+        assert scheme_cls.ENSEMBLE_CLASS is AssimilationEnsemble
+
+
+def test_two_schemes_can_share_one_prior(configs):
+    cfg_da, cfg_sim, cfg_ens = configs
+    ensemble = AssimilationEnsemble(cfg_da, cfg_ens, VanDerPolOscillator(cfg_sim))
+    prior = np.array(ensemble.enX, dtype=float)
+
+    first = ESMDA(cfg_da, cfg_ens, ensemble.sim, analysis="approx", ensemble=ensemble)
+    second = LMEnRML(cfg_da, cfg_ens, ensemble.sim, analysis="approx", ensemble=ensemble)
+
+    assert first.ensemble is second.ensemble
+    np.testing.assert_array_equal(np.array(second.prior_enX, dtype=float), prior)
diff --git a/tests/assimilation/test_failed_member_replacement.py b/tests/assimilation/test_failed_member_replacement.py
new file mode 100644
index 00000000..37c9b0e4
--- /dev/null
+++ b/tests/assimilation/test_failed_member_replacement.py
@@ -0,0 +1,119 @@
+"""A crashed realisation is replaced by a successful one, state and prediction together."""
+
+from types import SimpleNamespace
+
+import numpy as np
+
+from ensemble.ensemble import BaseEnsemble
+
+NE, NX = 6, 3
+
+
+def _host():
+    log = []
+    return SimpleNamespace(logger=SimpleNamespace(info=log.append), save=lambda: None, rng=np.random), log
+
+
+def _members():
+    # Column j of the state holds j; member j's output holds j too, so the
+    # member that replaced a crash can be read off both.
+    enX = np.tile(np.arange(NE, dtype=float), (NX, 1))
+    outputs = [[{"d": np.array([float(j)])}] for j in range(NE)]
+    return enX, outputs
+
+
+def test_crashed_member_takes_state_and_output_of_the_same_successful_member():
+    host, log = _host()
+    enX, outputs = _members()
+    outputs[2] = False                                   # member 2 crashed
+
+    np.random.seed(0)
+    new_out, new_enX, success = BaseEnsemble._replace_failed_simulations(host, outputs, enX)
+
+    assert success
+    k = int(new_out[2][0]["d"][0])
+    assert k != 2
+    np.testing.assert_array_equal(new_enX[:, 2], np.full(NX, float(k)))
+    for j in range(NE):
+        if j != 2:
+            np.testing.assert_array_equal(new_enX[:, j], np.full(NX, float(j)))
+    assert new_enX is enX                                # replaced in place, so the caller's state sees it
+    assert any("member 2 failed" in m for m in log)
+
+
+def test_nothing_changes_when_nothing_crashed():
+    host, _ = _host()
+    enX, outputs = _members()
+    before = np.array(enX)
+
+    new_out, new_enX, success = BaseEnsemble._replace_failed_simulations(host, outputs, enX)
+
+    assert success and new_out is outputs
+    np.testing.assert_array_equal(new_enX, before)
+
+
+def test_more_crashes_than_successes_draw_with_replacement():
+    host, _ = _host()
+    enX, outputs = _members()
+    for j in (0, 1, 2, 3):
+        outputs[j] = False
+
+    np.random.seed(1)
+    new_out, new_enX, success = BaseEnsemble._replace_failed_simulations(host, outputs, enX)
+
+    assert success
+    for j in (0, 1, 2, 3):
+        k = int(new_out[j][0]["d"][0])
+        assert k in (4, 5)
+        np.testing.assert_array_equal(new_enX[:, j], np.full(NX, float(k)))
+
+
+# ----------------------------------------------------------------------
+# Through the forecast itself: this is where the state matrix used to be
+# passed as the list of member inputs, so the first crash raised.
+# ----------------------------------------------------------------------
+
+class CrashingSimulator:
+    """Member 2 fails; every other member reports its own state value."""
+
+    input_dict = {"parallel": 1}
+    redund_sim = None
+    true_order = ["steps", [1, 2]]
+    datatype = ["d"]
+
+    def run_fwd_sim(self, state, member_index):
+        if member_index == 2:
+            return False
+        value = float(state["x"][0])
+        return [{"d": np.array([value])}, {"d": np.array([value + 100.0])}]
+
+
+def _bare_ensemble():
+    ens = object.__new__(BaseEnsemble)
+    ens.sim = CrashingSimulator()
+    ens.multilevel = None
+    ens.ne = NE
+    ens.idX = {"x": (0, NX)}
+    ens.aux_input = None
+    ens.keys_en = {}
+    ens.logger, _ = _host()
+    ens.logger = ens.logger.logger
+    ens.rng = np.random
+    return ens
+
+
+def test_forecast_survives_a_crashed_member_and_keeps_state_and_prediction_matched():
+    ens = _bare_ensemble()
+    enX, _ = _members()
+
+    np.random.seed(0)
+    ens.calc_prediction(enX)
+
+    predicted = ens.sim_data.loc[1, "d"]                 # one value per member
+    k = int(predicted[2])                                # member 2 now carries member k's prediction ...
+    assert k != 2
+    np.testing.assert_array_equal(enX[:, 2], np.full(NX, float(k)))   # ... and member k's state
+    for j in range(NE):
+        if j != 2:
+            assert predicted[j] == float(j)
+            np.testing.assert_array_equal(enX[:, j], np.full(NX, float(j)))
diff --git a/tests/assimilation/test_forecast_backends.py b/tests/assimilation/test_forecast_backends.py
new file mode 100644
index 00000000..488e5ae3
--- /dev/null
+++ b/tests/assimilation/test_forecast_backends.py
@@ -0,0 +1,31 @@
+"""The forecast backends give the same forecast for the same state."""
+
+import numpy as np
+import pytest
+
+from input_output import read_config
+from pipt.ensembles import AssimilationEnsemble
+from simulator.vanderpol import VanDerPolOscillator
+from test_numerical_characterisation import _write_config, _write_synthetic_case
+
+NE = 12
+
+
+def _forecast(tmp_path, monkeypatch, parallel):
+    tmp_path.mkdir(parents=True, exist_ok=True)
+    monkeypatch.chdir(tmp_path)
+    report_points = _write_synthetic_case(ne=NE)
+    cfg_da, cfg_sim, cfg_ens = read_config.read(_write_config("backend", "esmda", "approx", report_points, ne=NE))
+    cfg_sim["parallel"] = parallel
+    ensemble = AssimilationEnsemble(cfg_da, cfg_ens, VanDerPolOscillator(cfg_sim))
+    ensemble.forecast(ensemble.enX)
+    return ensemble.pred_data.matrix
+
+
+@pytest.mark.slow
+def test_the_process_pool_forecast_matches_the_serial_one(tmp_path, monkeypatch):
+    np.random.seed(5)
+    serial = _forecast(tmp_path / "serial", monkeypatch, parallel=1)
+    np.random.seed(5)
+    pooled = _forecast(tmp_path / "pooled", monkeypatch, parallel=2)
+    np.testing.assert_array_equal(pooled, serial)
diff --git a/tests/assimilation/test_hpc_extraction.py b/tests/assimilation/test_hpc_extraction.py
new file mode 100644
index 00000000..bcd29e3a
--- /dev/null
+++ b/tests/assimilation/test_hpc_extraction.py
@@ -0,0 +1,91 @@
+"""A failure while extracting one member's results costs that member, not the batch.
+
+``en_pred`` is positional -- ``calc_prediction`` reads member *i* out of slot *i* --
+so the invariant these tests defend is that the list comes back exactly ``ne`` long
+with the failure in its own slot, however the extraction failed.
+"""
+
+from types import SimpleNamespace
+
+import numpy as np
+
+import pipt.misc_tools.analysis_tools as at
+from ensemble.ensemble import BaseEnsemble
+
+NE, NX = 4, 2
+
+
+def _host(sim):
+    log = []
+    return SimpleNamespace(
+        ne=NE,
+        sim=sim,
+        logger=SimpleNamespace(info=log.append, error=log.append),
+    ), log
+
+
+def _sim(*, extract_raises_on=(), saveinfo=None):
+    """A simulator whose HPC hooks all succeed, except extraction for named members."""
+
+    def extract_data(member_i):
+        if member_i in extract_raises_on:
+            raise RuntimeError(f"no results for {member_i}")
+        sim.pred_data = [{"d": np.array([float(member_i)])}]
+
+    sim = SimpleNamespace(
+        file="case",
+        options={"mpiarray": False},
+        saveinfo=saveinfo,
+        pred_data=None,
+        run_fwd_sim=lambda state, member_index, nosim=True: None,
+        SLURM_HPC_run=lambda n_e, **kwargs: "job-1",
+        wait_for_jobs=lambda job_id: [True] * NE,
+        extract_data=extract_data,
+        remove_folder=lambda member_i: None,
+    )
+    return sim
+
+
+def _member_of(pred):
+    return int(pred[0]["d"][0])
+
+
+def test_an_extraction_failure_costs_only_its_own_member():
+    host, log = _host(_sim(extract_raises_on=(1,)))
+
+    en_pred = BaseEnsemble.run_on_HPC(host, np.zeros((NE, NX)), batch_size=NE)
+
+    assert len(en_pred) == NE
+    assert en_pred[1] is False
+    assert [_member_of(en_pred[i]) for i in (0, 2, 3)] == [0, 2, 3]
+    assert any("Could not extract data for ensemble member 1" in m for m in log)
+
+
+def test_a_saveinfo_failure_does_not_shift_the_members_after_it(monkeypatch):
+    """Upstream's c629c0f appends inside the try *and* in the except, so a raise from
+    store_ensemble_sim_information appends twice for one member and every later
+    member reads one slot too early."""
+    def boom(saveinfo, member_i):
+        if member_i == 1:
+            raise RuntimeError("disk full")
+
+    monkeypatch.setattr(at, "store_ensemble_sim_information", boom)
+    host, log = _host(_sim(saveinfo={"store": True}))
+
+    en_pred = BaseEnsemble.run_on_HPC(host, np.zeros((NE, NX)), batch_size=NE)
+
+    assert len(en_pred) == NE
+    assert [_member_of(p) for p in en_pred] == [0, 1, 2, 3]
+    assert any("Could not store sim information for member 1" in m for m in log)
+
+
+def test_a_crashed_simulation_still_gets_its_own_slot():
+    sim = _sim()
+    sim.wait_for_jobs = lambda job_id: [True, False, True, True]
+    host, _ = _host(sim)
+
+    en_pred = BaseEnsemble.run_on_HPC(host, np.zeros((NE, NX)), batch_size=NE)
+
+    assert len(en_pred) == NE
+    assert en_pred[1] is False
+    assert [_member_of(en_pred[i]) for i in (0, 2, 3)] == [0, 2, 3]
diff --git a/tests/assimilation/test_kernel_placement.py b/tests/assimilation/test_kernel_placement.py
new file mode 100644
index 00000000..3371f837
--- /dev/null
+++ b/tests/assimilation/test_kernel_placement.py
@@ -0,0 +1,52 @@
+"""A kernel is placed on the grid with its own axes, whatever its shape.
+
+Kernels are built ``(nx, ny)``-major, like the field ``(nz, nx, ny)``. Placement
+used to unpack the kernel as ``(ky, kx)``, which only worked for square,
+symmetric kernels placed away from the edges: an anisotropic kernel raised a
+shape error everywhere, and an isotropic one raised near any edge where the x
+and y clipping differed.
+"""
+
+import numpy as np
+import pytest
+
+from pipt.localization.distance_localization import DistanceLocalization
+
+
+def _placer(field):
+    loc = object.__new__(DistanceLocalization)   # _place_kernel reads only self.field
+    loc.field = field
+    return loc
+
+
+def test_anisotropic_kernel_is_placed_with_its_own_orientation():
+    loc = _placer((2, 20, 30))
+    kernel = np.arange(3 * 5, dtype=float).reshape(3, 5) + 1   # kx = 3, ky = 5
+
+    placed = loc._place_kernel(kernel, [10, 15, 0])
+
+    np.testing.assert_array_equal(placed[0, 9:12, 13:18], kernel)
+    assert placed.sum() == kernel.sum()
+    assert not placed[1].any()
+
+
+def test_kernel_is_clipped_consistently_at_a_corner():
+    loc = _placer((2, 20, 30))
+    kernel = np.arange(3 * 5, dtype=float).reshape(3, 5) + 1
+
+    placed = loc._place_kernel(kernel, [0, 0, 1])
+
+    # x_min = -1 keeps kernel rows 1:3 on grid rows 0:2; y_min = -2 keeps
+    # kernel columns 2:5 on grid columns 0:3.
+    np.testing.assert_array_equal(placed[1, 0:2, 0:3], kernel[1:3, 2:5])
+    assert placed.sum() == kernel[1:3, 2:5].sum()
+
+
+@pytest.mark.parametrize("position", [[1, 15, 0], [10, 1, 0], [19, 29, 1]])
+def test_isotropic_kernel_survives_every_edge(position):
+    loc = _placer((2, 20, 30))
+    kernel = np.ones((5, 5))
+
+    placed = loc._place_kernel(kernel, position)
+
+    assert 0 < placed.sum() <= kernel.sum()
diff --git a/tests/assimilation/test_legacy_scheme_names.py b/tests/assimilation/test_legacy_scheme_names.py
new file mode 100644
index 00000000..94e76d43
--- /dev/null
+++ b/tests/assimilation/test_legacy_scheme_names.py
@@ -0,0 +1,57 @@
+"""``co_lm_enrml`` and ``gn_enrml`` are names, not algorithms.
+
+Each is a thin subclass pinning one flavour of a live scheme -- ``co_lm_enrml``
+is ``LMEnRML(analysis="approx")``, ``gn_enrml`` is ``GNEnRML(analysis="subspace")``
+-- so on the same case, with the same seed, each must produce exactly the
+numbers of the algorithm it names, whether constructed directly or selected
+from a config by name.
+"""
+
+import numpy as np
+import pytest
+
+from input_output import read_config
+from pipt import GNEnRML, LMEnRML, pipt_init
+from pipt.update_schemes.enrml import co_lm_enrml, gn_enrml
+from simulator.vanderpol import VanDerPolOscillator
+from test_numerical_characterisation import GLOBAL_SEED, _write_config, _write_synthetic_case
+
+CASES = [
+    pytest.param("co_lm_enrml", co_lm_enrml, LMEnRML, "approx", id="co_lm_enrml"),
+    pytest.param("gn_enrml", gn_enrml, GNEnRML, "subspace", id="gn_enrml"),
+]
+
+
+def _run(scheme_name, analysis, build):
+    """Run the golden synthetic case; ``build(cfg_da, cfg_ens, sim)`` returns the result."""
+    report_points = _write_synthetic_case()
+    cfg_da, cfg_sim, cfg_ens = read_config.read(
+        _write_config("legacy_names", scheme_name, analysis, report_points)
+    )
+    np.random.seed(GLOBAL_SEED)
+    result = build(cfg_da, cfg_ens, VanDerPolOscillator(cfg_sim))
+    return np.asarray(result.x, dtype=float), np.asarray(result.data_misfit, dtype=float)
+
+
+@pytest.mark.parametrize("name, legacy, live, analysis", CASES)
+def test_class_gives_the_numbers_of_the_algorithm_it_names(tmp_path, monkeypatch, name, legacy, live, analysis):
+    monkeypatch.chdir(tmp_path)
+    x_live, misfit_live = _run(name, analysis, lambda da, en, sim: live.assimilate(da, en, sim, analysis=analysis))
+
+    def build_legacy(da, en, sim):
+        da.pop("analysis")            # the name alone must supply the flavour
+        return legacy.assimilate(da, en, sim)
+
+    x_legacy, misfit_legacy = _run(name, analysis, build_legacy)
+
+    np.testing.assert_array_equal(x_legacy, x_live)
+    np.testing.assert_array_equal(misfit_legacy, misfit_live)
+
+
+@pytest.mark.parametrize("name, legacy, live, analysis", CASES)
+def test_config_naming_the_scheme_runs_the_same_algorithm(tmp_path, monkeypatch, name, legacy, live, analysis):
+    monkeypatch.chdir(tmp_path)
+    x_live, _ = _run(name, analysis, lambda da, en, sim: live.assimilate(da, en, sim, analysis=analysis))
+    x_config, _ = _run(name, analysis, lambda da, en, sim: pipt_init.init_da(da, en, sim).run_assimilation())
+
+    np.testing.assert_array_equal(x_config, x_live)
diff --git a/tests/assimilation/test_linear_model.py b/tests/assimilation/test_linear_model.py
new file mode 100644
index 00000000..656cd75c
--- /dev/null
+++ b/tests/assimilation/test_linear_model.py
@@ -0,0 +1,130 @@
+"""
+Integration test for 1D linear model with LM-EnRML assimilation.
+"""
+
+import os
+import numpy as np
+
+from misc.structures import PETDataFrame
+from simulator.simple_models import lin_1d
+from pipt import LMEnRML
+
+
+# ---------------------------------------------------------------------------
+# Configuration
+# ---------------------------------------------------------------------------
+
+STATE_SIZE = 150
+
+CFG_ENS = {
+    "ne": 250,
+    "state": "x",
+    "prior_x": {
+        "vario": "sph",
+        "mean": [0.0] * STATE_SIZE,
+        "var": 1.0,
+        "range": 20.0,
+        "aniso": 1.0,
+        "angle": 0.0,
+        "grid": [STATE_SIZE, 1],
+    },
+}
+
+CFG_DA = {
+    "scheme": "lmenrml",
+    "analysis": "full",
+    "energy": 0.95,
+    "obsname": "position",
+    "data": "true_data.pkl",
+    "datavar": "var.pkl",
+    "iteration": {
+        # Four updates. The expected numbers below were pinned when `max_iter`
+        # counted the prior forecast as iteration 0, i.e. with `max_iter: 5`.
+        "max_iter": 4,
+        "data_misfit_tol": 1e-3,
+        "step_tol": 0.0,
+        "lambda": 50.0,
+        "lambda_factor": 4.0,
+        "lambda_max": 1e8,
+    },
+}
+
+CFG_SIM = {
+    "reporttype": "position",
+    "reportpoint": list(range(5, 150, 5)),
+    "datatype": ["value"],
+    "parallel": 4,
+}
+
+
+# ---------------------------------------------------------------------------
+# Helpers
+# ---------------------------------------------------------------------------
+
+def setup_synthetic_data():
+    """Generate synthetic observations and associated variances."""
+    np.random.seed(10)
+
+    simulator = lin_1d(CFG_SIM)
+    simulator.setup_fwd_run()
+
+    # Generate a random state realization
+    state = {
+        "x": np.random.multivariate_normal(
+            mean=np.zeros(STATE_SIZE),
+            cov=np.eye(STATE_SIZE),
+        )
+    }
+
+    # Forward simulation
+    prediction = simulator.run_fwd_sim(state, 0)
+    prediction = PETDataFrame.from_records(
+        prediction,
+        index=CFG_SIM["reportpoint"]
+    )
+
+    # Construct observation data and variance
+    data = prediction.copy()
+    data_var = prediction.copy()
+
+    for column in data.columns:
+        data[column] = data[column].apply(np.squeeze)
+        data_var[column] = data_var[column].apply(lambda _: ["abs", 1.0])
+
+    data.to_pickle("true_data.pkl")
+    data_var.to_pickle("var.pkl")
+
+
+# ---------------------------------------------------------------------------
+# Test
+# ---------------------------------------------------------------------------
+
+def test_lin_1d(tmp_path):
+    """
+    End-to-end test of the LM-EnRML assimilation workflow.
+    """
+    # --- Setup temporary working directory
+    workdir = tmp_path / "lin_1d_test"
+    workdir.mkdir()
+    os.chdir(workdir)
+
+    # --- Generate synthetic dataset
+    setup_synthetic_data()
+
+    # --- Initialize and run
+    np.random.seed(10)
+    result = LMEnRML.assimilate(CFG_DA, CFG_ENS, lin_1d(CFG_SIM), analysis="full")
+
+    # --- Validate results. `result.x` is the posterior state ensemble.
+    ensemble_mean = result.x.mean(axis=-1)
+    # Regenerated 2026-09-07 for the truncSVD energy-rank change (see CHANGELOG).
+    expected = np.array([
+        -0.08340785,
+         0.00542748,
+        -0.04776080,
+         0.47335038,
+         0.45950017,
+         0.37760764,
+    ])
+    result = ensemble_mean[[1, 2, 3, -3, -2, -1]]
+    np.testing.assert_array_almost_equal(result, expected, decimal=5)
diff --git a/tests/assimilation/test_localization_config_compat.py b/tests/assimilation/test_localization_config_compat.py
new file mode 100644
index 00000000..28211e8e
--- /dev/null
+++ b/tests/assimilation/test_localization_config_compat.py
@@ -0,0 +1,114 @@
+"""A LOCALIZATION block written before the strategies were named still runs.
+
+Localization used to be selected by which keyword appeared in the block rather than by
+a ``name``, and the auto-adaptive cutoff was carried as the value of the ``autoadaloc``
+keyword itself. Reading neither meant an existing config either died at startup naming
+three strings its author had never seen, or -- worse -- ran with a different taper and
+said nothing.
+"""
+
+import numpy as np
+import pytest
+
+from input_output.config import ConfigError
+from pipt.localization import build_localization_instance
+from pipt.localization.auto_ada_loc import AutoAdaptiveLocalization
+from pipt.localization.common import infer_name
+from pipt.localization.distance_localization import DistanceLocalization
+
+FIELD = [1, 10, 10]
+
+
+def _build(config):
+    return build_localization_instance(
+        config, data_indices=[0], data_types=["d"], parameters=["p"], ensemble_size=10
+    )
+
+
+# --------------------------------------------------------------------------
+# The mode is inferred from the keyword that used to select it
+# --------------------------------------------------------------------------
+
+@pytest.mark.parametrize("config, expected", [
+    ({"autoadaloc": 2},                    "autoadaloc"),
+    ({"localanalysis": True},              "localanalysis"),
+    ({"dist_loc": True},                   "distance_loc"),   # as a key
+    ({"mode": "dist_loc"},                 "distance_loc"),   # ... or as a bare value
+    ({"anything": "masks.p"},              "distance_loc"),   # a pickled mask file
+    ({"anything": "masks.pkl"},            "distance_loc"),
+    ({},                                   "parallel_update"),  # the old fallback
+])
+def test_the_mode_is_inferred_from_the_keyword_that_selected_it(config, expected):
+    assert infer_name(config) == expected
+
+
+def test_an_explicit_name_wins_over_inference():
+    assert _build({"name": "autoadaloc", "field": FIELD, "dist_loc": True}).name == "autoadaloc"
+
+
+@pytest.mark.parametrize("config", [
+    {"field": FIELD, "autoadaloc": 2},
+    {"field": FIELD, "dist_loc": True},
+])
+def test_a_config_without_a_name_still_builds(config):
+    assert _build(config) is not None
+
+
+# --------------------------------------------------------------------------
+# autoadaloc's value is the cutoff, and it is no longer discarded
+# --------------------------------------------------------------------------
+
+@pytest.mark.parametrize("config, expected", [
+    ({"autoadaloc": 2},                          2.0),    # the old spelling
+    ({"autoadaloc": 2, "cutoff": 0.5},           0.5),    # cutoff wins if both are given
+    ({"name": "autoadaloc", "nstd": 1.5},        1.5),    # the name it had inside the code
+    ({"name": "autoadaloc", "cutoff": 0.5},      0.5),
+    ({"autoadaloc": True},                       0.3),    # a bare flag is not a value
+    ({"name": "autoadaloc"},                     0.3),    # nothing given at all
+])
+def test_the_cutoff_comes_from_whichever_spelling_the_config_used(config, expected):
+    loc = _build({"field": FIELD, **config})
+
+    assert isinstance(loc, AutoAdaptiveLocalization)
+    assert loc.cutoff == expected
+
+
+def test_the_cutoff_actually_reaches_the_taper():
+    """The value has to change the threshold, not just land on the instance."""
+    rng = np.random.default_rng(0)
+    corr = np.linspace(0.0, 1.0, 50).reshape(-1, 1)
+    shuffled = rng.normal(scale=0.1, size=(50, 1))
+
+    strict = _build({"field": FIELD, "autoadaloc": 3}).tapering_function(corr, shuffled)
+    lenient = _build({"field": FIELD, "autoadaloc": 1}).tapering_function(corr, shuffled)
+
+    assert strict.sum() < lenient.sum()          # a higher cutoff keeps fewer correlations
+
+
+# --------------------------------------------------------------------------
+# The two modes that cannot run say so while the config is being read
+# --------------------------------------------------------------------------
+
+@pytest.mark.parametrize("config, expected", [
+    ({"localanalysis": True, "type": "gc", "range": 5}, "Local analysis is not supported"),
+    ({},                                                "The parallel update is not supported"),
+])
+def test_an_unsupported_mode_is_refused_at_config_time(config, expected):
+    with pytest.raises(ConfigError, match=expected):
+        _build({"field": FIELD, **config})
+
+
+def test_the_refusal_names_something_the_user_can_do_instead():
+    with pytest.raises(ConfigError, match="distance_loc"):
+        _build({"field": FIELD, "localanalysis": True})
+
+
+# --------------------------------------------------------------------------
+# A list is still accepted where a dict is
+# --------------------------------------------------------------------------
+
+def test_a_list_shaped_block_is_normalized_and_named():
+    loc = _build([["field", *FIELD], ["autoadaloc", 2]])
+
+    assert isinstance(loc, (AutoAdaptiveLocalization, DistanceLocalization))
+    assert loc.name == "autoadaloc"
diff --git a/tests/assimilation/test_localization_registry.py b/tests/assimilation/test_localization_registry.py
new file mode 100644
index 00000000..cb6330d0
--- /dev/null
+++ b/tests/assimilation/test_localization_registry.py
@@ -0,0 +1,72 @@
+"""Localization strategies are selected from a table, and the table is open."""
+
+import pytest
+
+from input_output.config import ConfigError
+from pipt.localization import (
+    LOCALIZATIONS,
+    available_localizations,
+    build_localization_instance,
+    register_localization,
+)
+
+
+class Custom:
+    name = "custom"
+
+    def __init__(self, info, ensemble_size):
+        self.info = info
+        self.ensemble_size = ensemble_size
+
+
+def _build_custom(*, info, ensemble_size, **_):
+    return Custom(info, ensemble_size)
+
+
+def test_the_shipped_strategies_are_registered():
+    assert available_localizations() == ["autoadaloc", "distance_loc"]
+
+
+@pytest.mark.parametrize("name, expected", [
+    ("localanalysis", "Local analysis is not supported"),
+    ("parallel_update", "The parallel update is not supported"),
+])
+def test_an_unsupported_mode_says_so_and_names_the_alternatives(name, expected):
+    """Both ran before the schemes were restructured. Refusing while the config is read
+    beats failing part way through the first update -- or, as local analysis used to,
+    reporting a misfit for a posterior that is still the prior."""
+    with pytest.raises(ConfigError, match=expected):
+        build_localization_instance({"name": name, "field": [1, 10, 10]}, None, None, None, 10)
+
+    assert name not in available_localizations()
+
+
+def test_a_registered_strategy_is_built_from_its_name(monkeypatch):
+    monkeypatch.setitem(LOCALIZATIONS, "custom", _build_custom)
+
+    loc = build_localization_instance({"name": "custom", "radius": 3}, None, None, None, 17)
+
+    assert isinstance(loc, Custom)
+    assert loc.info == {"radius": 3} and loc.ensemble_size == 17
+    assert "custom" in available_localizations()
+
+
+def test_registering_an_existing_name_needs_overwrite(monkeypatch):
+    monkeypatch.setitem(LOCALIZATIONS, "custom", _build_custom)
+    with pytest.raises(ValueError, match="already registered"):
+        register_localization("custom", _build_custom)
+    register_localization("custom", _build_custom, overwrite=True)
+
+
+def test_register_localization_adds_to_the_table(monkeypatch):
+    monkeypatch.delitem(LOCALIZATIONS, "brand_new", raising=False)
+    register_localization("brand_new", _build_custom)
+    try:
+        assert "brand_new" in LOCALIZATIONS
+    finally:
+        LOCALIZATIONS.pop("brand_new", None)
+
+
+def test_unknown_name_lists_what_is_available():
+    with pytest.raises(ValueError, match="autoadaloc"):
+        build_localization_instance({"name": "nope"}, None, None, None, 1)
diff --git a/tests/assimilation/test_max_iter.py b/tests/assimilation/test_max_iter.py
new file mode 100644
index 00000000..141f7391
--- /dev/null
+++ b/tests/assimilation/test_max_iter.py
@@ -0,0 +1,35 @@
+"""`max_iter` is the number of update iterations a run may take."""
+
+import numpy as np
+import pytest
+
+from input_output import read_config
+from pipt import ESMDA, GNEnRML, LMEnRML
+from simulator.vanderpol import VanDerPolOscillator
+from test_numerical_characterisation import _write_config, _write_synthetic_case
+
+NE = 20
+
+
+@pytest.mark.parametrize("scheme_cls, analysis", [(LMEnRML, "approx"), (GNEnRML, "subspace")])
+@pytest.mark.parametrize("max_iter", [1, 3])
+def test_an_iterative_scheme_takes_exactly_max_iter_updates_when_nothing_else_stops_it(tmp_path, monkeypatch, scheme_cls, analysis, max_iter):
+    monkeypatch.chdir(tmp_path)
+    report_points = _write_synthetic_case(ne=NE)
+    cfg_da, cfg_sim, cfg_ens = read_config.read(_write_config("budget", "lmenrml", analysis, report_points, ne=NE))
+    # A tolerance no step meets, and a generous inner budget, so the outer limit is what stops the run.
+    cfg_da["iteration"] = {"max_iter": max_iter, "lambda": 10, "lambda_factor": 5, "trunc_energy": 0.99,
+                           "data_misfit_tol": 1e-12, "max_inner_iter": 50}
+    np.random.seed(0)
+    result = scheme_cls.assimilate(cfg_da, cfg_ens, VanDerPolOscillator(cfg_sim), analysis=analysis)
+    assert result.nit == max_iter
+    assert result.message == "Maximum number of iterations reached"
+
+
+def test_esmda_takes_one_update_per_assimilation_step(tmp_path, monkeypatch):
+    monkeypatch.chdir(tmp_path)
+    report_points = _write_synthetic_case(ne=NE)
+    cfg_da, cfg_sim, cfg_ens = read_config.read(_write_config("steps", "esmda", "approx", report_points, ne=NE))
+    assert cfg_da["mda"]["tot_assim_steps"] == 3
+    result = ESMDA.assimilate(cfg_da, cfg_ens, VanDerPolOscillator(cfg_sim), analysis="approx")
+    assert result.nit == 3
diff --git a/tests/assimilation/test_multilevel.py b/tests/assimilation/test_multilevel.py
new file mode 100644
index 00000000..c7f5c8fe
--- /dev/null
+++ b/tests/assimilation/test_multilevel.py
@@ -0,0 +1,158 @@
+"""End-to-end coverage for the multilevel ES-MDA scheme.
+
+``esmda_hybrid`` had no runtime test at all, which is why four separate faults
+in the multilevel path went unnoticed -- three of them predating Phase 8. The
+suite stayed green throughout because nothing ever constructed the scheme, let
+alone ran it.
+
+There are no committed reference numbers here, unlike
+``test_numerical_characterisation``: the path had never completed a run, so
+there was no prior behaviour to pin. These tests assert that it runs, that the
+level structure is preserved, and that the assimilation actually moves the
+state and reduces the misfit.
+"""
+
+import os
+
+import numpy as np
+import pytest
+import yaml
+
+from input_output import read_config
+from pipt.update_schemes.multilevel import MultilevelEnsemble, esmda_hybrid, multilevel
+from simulator.vanderpol import VanDerPolOscillator
+
+from test_numerical_characterisation import _write_synthetic_case
+
+LEVELS = 2
+ML_NE = [10, 10]
+SEED = 42
+
+
+def _write_ml_config(name, report_points):
+    config = {
+        "ensemble": {
+            "ne": sum(ML_NE),
+            "state": ["x1", "x2", "mu"],
+            "importstate": "prior_ensemble.npz",
+            "prior_x1": {"var": 1.0},
+            "prior_x2": {"var": 1.0},
+            "prior_mu": {"var": 1.0},
+            "multilevel": {
+                "levels": LEVELS,
+                "en_size": ML_NE,
+                "ml_weights": [0.5, 0.5],
+            },
+        },
+        "dataassim": {
+            "scheme": "esmda",
+            "analysis": "hybrid",
+            "energy": 0.99,
+            "obsname": "steps",
+            "data": "true_data.pkl",
+            "datavar": "var.pkl",
+            "nosave": True,
+            "mda": {"tot_assim_steps": 2, "inflation_param": [2, 2]},
+        },
+        "simulator": {
+            "reporttype": "steps",
+            "reportpoints": [int(p) for p in report_points],
+            "datatype": ["x1"],
+            "parallel": 1,
+            "compute_adjoints": False,
+        },
+    }
+    with open(f"{name}.yaml", "w") as handle:
+        yaml.dump(config, handle)
+    return f"{name}.yaml"
+
+
+@pytest.fixture
+def ml_scheme(tmp_path):
+    """A constructed multilevel scheme in an isolated working directory."""
+    os.chdir(tmp_path)
+    report_points = _write_synthetic_case(ne=sum(ML_NE))
+    np.random.seed(SEED)
+    cfg_da, cfg_sim, cfg_ens = read_config.read(_write_ml_config("ml", report_points))
+    return esmda_hybrid(cfg_da, cfg_ens, VanDerPolOscillator(cfg_sim))
+
+
+# ----------------------------------------------------------------------
+# Structure
+# ----------------------------------------------------------------------
+def test_scheme_composes_a_multilevel_ensemble(ml_scheme):
+    """The scheme must *have* the ML ensemble, not *be* one.
+
+    While it inherited the ensemble, C3 linearisation routed
+    ``super().__init__()`` past the scheme's constructor once the schemes left
+    the ensemble hierarchy, so ES-MDA's ``__init__`` stopped running and
+    ``alpha`` was never set.
+    """
+    from pipt.ensembles import AssimilationEnsemble
+
+    assert isinstance(ml_scheme.ensemble, MultilevelEnsemble)
+    assert not isinstance(ml_scheme, AssimilationEnsemble)
+
+
+def test_inflation_parameters_are_set(ml_scheme):
+    """`alpha` comes from ESMDA.__init__; its absence was the regression."""
+    assert list(ml_scheme.alpha) == [2, 2]
+
+
+def test_state_is_partitioned_by_level(ml_scheme):
+    assert ml_scheme.tot_level == LEVELS
+    assert isinstance(ml_scheme.ensemble.enX, list)
+    assert len(ml_scheme.ensemble.enX) == LEVELS
+    for level, size in enumerate(ML_NE):
+        assert ml_scheme.ensemble.enX[level].shape[1] == size
+
+
+def test_hybrid_flavour_is_bound_like_any_other(ml_scheme):
+    """``hybrid`` is listed in esmda_hybrid's own COMPATIBLE_ANALYSES, so it
+    binds an analysis instance the same way approx/full/subspace do -- it is
+    no longer a mixed-in special case."""
+    from pipt.update_schemes.analysis.hybrid import hybrid_update
+    from pipt.update_schemes.core.analysis_binding import AnalysisBindingMixin
+
+    assert isinstance(ml_scheme.analysis, hybrid_update)
+    assert ml_scheme.analysis is not ml_scheme
+    assert type(ml_scheme).update is AnalysisBindingMixin.update
+
+
+def test_multilevel_alias_points_at_the_ensemble():
+    assert multilevel is MultilevelEnsemble
+
+
+# ----------------------------------------------------------------------
+# Running
+# ----------------------------------------------------------------------
+def test_multilevel_run_completes_and_updates_the_state(ml_scheme):
+    """The whole point: it runs, and the update is actually applied.
+
+    `hybrid_update` used to deliver its result by assigning `self.step` and
+    returning nothing, so `self.step = self.update(...)` overwrote it with
+    None and every update was silently discarded. It returns the per-level
+    steps now; comparing against the prior would catch either failure.
+    """
+    prior = [np.array(level, dtype=float) for level in ml_scheme.ensemble.prior_enX]
+
+    result = ml_scheme.run_assimilation()
+
+    assert result.nit == 2
+    assert isinstance(ml_scheme.ensemble.enX, list)
+    assert len(ml_scheme.ensemble.enX) == LEVELS
+
+    posterior = [np.array(level, dtype=float) for level in ml_scheme.ensemble.enX]
+    for level in range(LEVELS):
+        assert posterior[level].shape == prior[level].shape
+        assert not np.array_equal(posterior[level], prior[level]), (
+            f"level {level} posterior equals the prior: the update was discarded"
+        )
+
+
+def test_multilevel_run_reduces_the_data_misfit(ml_scheme):
+    result = ml_scheme.run_assimilation()
+
+    assert result.data_misfit < result.prior_data_misfit, (
+        f"misfit did not improve: {result.prior_data_misfit} -> {result.data_misfit}"
+    )
diff --git a/tests/assimilation/test_no_localization_is_picklable.py b/tests/assimilation/test_no_localization_is_picklable.py
new file mode 100644
index 00000000..c38cf056
--- /dev/null
+++ b/tests/assimilation/test_no_localization_is_picklable.py
@@ -0,0 +1,12 @@
+"""The stand-in for 'no localization' must survive pickling, because the
+ensemble that holds it is pickled by ``emergency_dump`` and by the restart
+file -- exactly when a run has crashed."""
+
+import pickle
+
+from pipt.ensembles.ensemble_base import NoLocalization
+
+
+def test_no_localization_round_trips_through_pickle():
+    restored = pickle.loads(pickle.dumps(NoLocalization()))
+    assert restored.name is None
diff --git a/tests/assimilation/test_numerical_characterisation.py b/tests/assimilation/test_numerical_characterisation.py
new file mode 100644
index 00000000..50cfd045
--- /dev/null
+++ b/tests/assimilation/test_numerical_characterisation.py
@@ -0,0 +1,337 @@
+"""Characterisation tests pinning the current numerical output of PIPT schemes.
+
+Purpose
+-------
+The rest of the assimilation suite asserts *properties* -- misfit went down,
+the parameter estimate improved -- with generous thresholds. That catches an
+algorithm that is badly broken, but not one that quietly produces different
+numbers. Before refactoring the assimilation mathematics, we need the stronger
+statement: *these inputs still produce exactly these outputs.*
+
+These tests run each scheme against a fixed synthetic case and compare the
+posterior ensemble and the data-misfit trajectory against committed reference
+values. A refactor that changes the numerics fails here with a diff, instead of
+sliding under a loose threshold.
+
+Determinism
+-----------
+The schemes draw observation perturbations from the *global* ``numpy.random``
+state, so a run is only reproducible if that state is seeded. The rest of the
+suite does not seed it, which makes those tests non-deterministic: repeated
+runs of the same case were measured to differ by up to 0.37 in the posterior
+state. Every test here seeds ``np.random`` explicitly and runs single-threaded
+(``parallel = 1``), which was verified to give bit-identical results across
+repeated runs.
+
+Regenerating the references
+---------------------------
+The references are floating-point results and can legitimately shift across
+BLAS implementations or numpy versions, so a mismatch is not automatically a
+regression -- check whether the environment moved before concluding the code
+did. To regenerate deliberately, after confirming a change is intended::
+
+    python tests/assimilation/test_numerical_characterisation.py --regenerate
+
+Then inspect the diff on ``characterisation_reference.npz`` before committing:
+a refactor that is meant to preserve behaviour should produce *no* diff.
+"""
+
+import os
+import sys
+from pathlib import Path
+
+import numpy as np
+import pytest
+
+import pandas as pd
+import yaml
+
+from input_output import read_config
+from pipt import ES, ESMDA, EnKF, GNEnRML, LMEnRML
+from simulator.vanderpol import VanDerPolOscillator, _integrate
+
+#: The public class per algorithm. Cases run through these so the numbers pin
+#: the documented entry point, not just the internals.
+SCHEME_CLASSES = {
+    "enkf": EnKF,
+    "es": ES,
+    "esmda": ESMDA,
+    "lmenrml": LMEnRML,
+    "gnenrml": GNEnRML,
+}
+
+REFERENCE_FILE = Path(__file__).with_name("characterisation_reference.npz")
+
+#: Small enough to run quickly, large enough that any change to the analysis
+#: mathematics moves the numbers well outside the comparison tolerance.
+ENSEMBLE_SIZE = 100
+GLOBAL_SEED = 42
+
+#: Tight enough to catch a real change in the mathematics, loose enough to
+#: absorb last-bit reassociation from an unrelated refactor.
+RTOL = 1e-9
+ATOL = 1e-11
+
+
+def _write_synthetic_case(seed=12345, ne=ENSEMBLE_SIZE):
+    """Create the prior ensemble and observations for the Van der Pol case.
+
+    A local, deliberately small copy of the pipeline test's setup: the shared
+    helper hardcodes a 1000-member ensemble, which made each characterisation
+    case take minutes. The physics is identical, just cheaper.
+    """
+    rng = np.random.default_rng(seed)
+    x1_true, x2_true, mu_true = 1.0, 0.0, 1.0
+
+    np.savez(
+        "prior_ensemble.npz",
+        x1=(0.05 + 0.1 * rng.standard_normal(ne))[np.newaxis, :],
+        x2=(0.05 + 0.1 * rng.standard_normal(ne))[np.newaxis, :],
+        mu=(1.5 + 0.5 * rng.standard_normal(ne))[np.newaxis, :],
+    )
+
+    time_steps = np.arange(0, 16, dtype=float)
+    report_points = np.arange(1, 16)
+    truth = _integrate(x1_true, x2_true, mu_true, time_steps, atol=1e-5, rtol=1e-5)
+
+    sigma = 0.1
+    observations = truth[report_points, 0] + sigma * rng.standard_normal(len(report_points))
+
+    df_obs = pd.DataFrame({"x1": observations}, index=report_points)
+    df_obs.index.name = "steps"
+    df_obs.to_pickle("true_data.pkl")
+
+    df_var = pd.DataFrame(
+        {"x1": [f"['abs', {sigma ** 2}]" for _ in report_points]}, index=report_points
+    )
+    df_var.index.name = "steps"
+    df_var.to_pickle("var.pkl")
+
+    return report_points
+
+
+def _write_config(name, scheme, analysis, report_points, ne=ENSEMBLE_SIZE):
+    """Write the YAML config for one characterisation case."""
+    if scheme == "esmda":
+        extra = {"mda": {"tot_assim_steps": 3, "inflation_param": 3 * [3]}}
+    else:
+        extra = {
+            "iteration": {
+                # Two updates. The reference numbers were generated when `max_iter`
+                # counted the prior forecast as iteration 0, i.e. with `max_iter: 3`;
+                # the meaning changed, the runs did not.
+                "max_iter": 2,
+                "lambda": 10,
+                "lambda_factor": 5,
+                "trunc_energy": 0.99,
+            }
+        }
+
+    config = {
+        "ensemble": {
+            "ne": ne,
+            "state": ["x1", "x2", "mu"],
+            "importstate": "prior_ensemble.npz",
+            "prior_x1": {"var": 1.0},
+            "prior_x2": {"var": 1.0},
+            "prior_mu": {"var": 1.0},
+        },
+        "dataassim": {
+            "scheme": scheme,
+            "analysis": analysis,
+            "energy": 0.99,
+            "obsname": "steps",
+            "data": "true_data.pkl",
+            "datavar": "var.pkl",
+            "nosave": True,
+            **extra,
+        },
+        "simulator": {
+            "reporttype": "steps",
+            # plain ints: yaml.dump emits numpy scalars as objects the loader
+            # cannot reconstruct
+            "reportpoints": [int(p) for p in report_points],
+            "datatype": ["x1"],
+            "parallel": 1,   # single-threaded: required for reproducibility
+            "compute_adjoints": False,
+        },
+    }
+
+    with open(f"{name}.yaml", "w") as handle:
+        yaml.dump(config, handle)
+    return f"{name}.yaml"
+
+
+#: (scheme, analysis) combinations under characterisation.
+#:
+#: The ``subspace`` flavour of both ``es`` and ``enkf`` is absent: it raises
+#: ``ValueError: Length of values (11) does not match length of index (15)`` on
+#: this case, which predates the Phase 8 work and is untested elsewhere.
+#: ``esmda/subspace`` is fine, so the fault is in the sequential path rather
+#: than in the subspace analysis.
+CASES = [
+    ("esmda", "approx"),
+    ("esmda", "full"),
+    ("esmda", "subspace"),
+    ("esmda", "subspace2"),
+    ("lmenrml", "approx"),
+    ("lmenrml", "full"),
+    ("lmenrml", "subspace"),
+    ("lmenrml", "subspace2"),
+    ("gnenrml", "approx"),
+    ("gnenrml", "full"),
+    ("gnenrml", "subspace"),
+    ("gnenrml", "subspace2"),
+    ("gnenrml", "margis"),
+    ("es", "approx"),
+    ("es", "full"),
+    ("enkf", "approx"),
+]
+
+
+def run_case(scheme, analysis, tmpdir):
+    """Run one case deterministically and return its numerical fingerprint."""
+    tmpdir = Path(tmpdir)
+    tmpdir.mkdir(parents=True, exist_ok=True)
+    os.chdir(tmpdir)
+
+    report_points = _write_synthetic_case()
+
+    # The schemes perturb observations from the global numpy random state, so
+    # this seed is what makes the run reproducible at all.
+    np.random.seed(GLOBAL_SEED)
+
+    config_file = _write_config(
+        f"characterise_{scheme}_{analysis}", scheme, analysis, report_points
+    )
+    cfg_da, cfg_sim, cfg_ens = read_config.read(config_file)
+
+    # Exactly what a user writes. Driving the cases through this means the
+    # reference numbers pin the public entry point and the result object's
+    # contents, not only the internal loop.
+    result = SCHEME_CLASSES[scheme].assimilate(
+        cfg_da, cfg_ens, VanDerPolOscillator(cfg_sim), analysis=analysis
+    )
+
+    return {
+        "enX": np.asarray(result.x, dtype=float),
+        "data_misfit": np.atleast_1d(np.asarray(result.data_misfit, dtype=float)),
+        "prior_data_misfit": np.atleast_1d(
+            np.asarray(result.prior_data_misfit, dtype=float)
+        ),
+    }
+
+
+def _key(scheme, analysis, field):
+    return f"{scheme}__{analysis}__{field}"
+
+
+@pytest.fixture(scope="module")
+def reference():
+    if not REFERENCE_FILE.exists():
+        pytest.skip(
+            f"No reference file at {REFERENCE_FILE.name}. Generate it with:\n"
+            f"  python {Path(__file__).name} --regenerate"
+        )
+    return np.load(REFERENCE_FILE)
+
+
+@pytest.mark.parametrize("scheme,analysis", CASES)
+def test_matches_reference(scheme, analysis, tmp_path, reference):
+    """The scheme still produces exactly the reference numbers."""
+    result = run_case(scheme, analysis, tmp_path)
+
+    for field, value in result.items():
+        key = _key(scheme, analysis, field)
+        if key not in reference:
+            pytest.skip(f"Reference has no entry for {key}; regenerate it.")
+
+        expected = reference[key]
+        assert value.shape == expected.shape, (
+            f"{scheme}/{analysis} {field}: shape changed "
+            f"{expected.shape} -> {value.shape}"
+        )
+        np.testing.assert_allclose(
+            value, expected, rtol=RTOL, atol=ATOL,
+            err_msg=(
+                f"{scheme}/{analysis} {field} no longer matches the reference. "
+                f"If this change is intended, regenerate the reference and "
+                f"review the diff; if not, the refactor changed the numerics."
+            ),
+        )
+
+
+@pytest.mark.parametrize("scheme,analysis", CASES[:1])
+def test_run_is_reproducible(scheme, analysis, tmp_path):
+    """Two seeded runs of the same case agree bit-for-bit.
+
+    Guards the determinism the other tests here depend on: if seeding stops
+    being sufficient, this fails directly rather than showing up as a confusing
+    reference mismatch.
+    """
+    first = run_case(scheme, analysis, tmp_path / "a")
+    second = run_case(scheme, analysis, tmp_path / "b")
+    np.testing.assert_array_equal(
+        first["enX"], second["enX"],
+        err_msg="Seeded runs diverged; the schemes have an unseeded random source.",
+    )
+
+
+def regenerate():
+    """Write the reference file from the current code."""
+    import tempfile
+
+    payload = {}
+    for scheme, analysis in CASES:
+        print(f"running {scheme}/{analysis} ...", flush=True)
+        with tempfile.TemporaryDirectory() as tmpdir:
+            for field, value in run_case(scheme, analysis, tmpdir).items():
+                payload[_key(scheme, analysis, field)] = value
+
+    np.savez_compressed(REFERENCE_FILE, **payload)
+    print(f"\nWrote {REFERENCE_FILE} with {len(payload)} arrays.")
+
+
+@pytest.mark.parametrize("scheme,analysis", [("esmda", "approx")])
+def test_config_driven_entry_point_matches_reference(scheme, analysis, tmp_path, reference):
+    """``init_da(...)`` then ``run_assimilation()`` agrees with ``assimilate()``.
+
+    The cases above all run through ``Scheme.assimilate(...)``, so this pins the
+    other supported path -- config-driven construction through the registry --
+    against the same reference. The roles used to be reversed, and
+    ``assimilate()`` was the entry point nothing exercised, which is how it
+    stayed inert through the whole Phase 8 migration.
+    """
+    from pipt import pipt_init
+
+    os.chdir(tmp_path)
+    report_points = _write_synthetic_case()
+    np.random.seed(GLOBAL_SEED)
+    config_file = _write_config(f"cfg_{scheme}_{analysis}", scheme, analysis, report_points)
+    cfg_da, cfg_sim, cfg_ens = read_config.read(config_file)
+
+    scheme_obj = pipt_init.init_da(cfg_da, cfg_ens, VanDerPolOscillator(cfg_sim))
+    result = scheme_obj.run_assimilation()
+
+    # Both spellings must work: AssimilationResult subclasses scipy's
+    # OptimizeResult so PIPT and POPT results are handled alike.
+    np.testing.assert_array_equal(
+        np.asarray(result["x"], dtype=float), np.asarray(result.x, dtype=float)
+    )
+    np.testing.assert_allclose(
+        np.asarray(result.x, dtype=float),
+        reference[_key(scheme, analysis, "enX")],
+        rtol=RTOL, atol=ATOL,
+        err_msg="init_da + run_assimilation does not reproduce the reference posterior.",
+    )
+
+
+if __name__ == "__main__":
+    if "--regenerate" in sys.argv:
+        cwd = os.getcwd()
+        try:
+            regenerate()
+        finally:
+            os.chdir(cwd)
+    else:
+        print(__doc__)
diff --git a/tests/assimilation/test_prediction_fill.py b/tests/assimilation/test_prediction_fill.py
new file mode 100644
index 00000000..94ffa44d
--- /dev/null
+++ b/tests/assimilation/test_prediction_fill.py
@@ -0,0 +1,42 @@
+"""The directly filled prediction matrix is what the frame path produced."""
+
+import numpy as np
+import pytest
+
+from input_output import read_config
+from pipt.ensembles import AssimilationEnsemble
+from simulator.vanderpol import VanDerPolOscillator
+from test_numerical_characterisation import _write_config, _write_synthetic_case
+
+NE = 10
+
+
+@pytest.mark.parametrize("scale_data", [False, True])
+def test_fill_matches_the_legacy_frame_flatten(tmp_path, monkeypatch, scale_data):
+    monkeypatch.chdir(tmp_path)
+    report_points = _write_synthetic_case(ne=NE)
+    cfg_da, cfg_sim, cfg_ens = read_config.read(_write_config("fill", "esmda", "approx", report_points, ne=NE))
+    if scale_data:
+        cfg_da["scale_data"] = True
+    ensemble = AssimilationEnsemble(cfg_da, cfg_ens, VanDerPolOscillator(cfg_sim))
+    ensemble.forecast(ensemble.enX)
+
+    legacy = ensemble.sim_to_pred_data(ensemble.sim_data).to_matrix()
+    np.testing.assert_array_equal(ensemble.pred_data.matrix, legacy)
+    assert ensemble.pred_data.layout is ensemble.data_layout
+    assert ensemble.pred_data.nd == ensemble.obs_vector.shape[0]
+
+
+def test_a_missing_observation_no_longer_misaligns_predictions(tmp_path, monkeypatch):
+    monkeypatch.chdir(tmp_path)
+    report_points = _write_synthetic_case(ne=NE)
+    cfg_da, cfg_sim, cfg_ens = read_config.read(_write_config("gap", "esmda", "approx", report_points, ne=NE))
+    ensemble = AssimilationEnsemble(cfg_da, cfg_ens, VanDerPolOscillator(cfg_sim))
+    # Blank one observation *before* the layout is built, as a data file with a gap would.
+    label, column = ensemble.data_df.index[1], ensemble.data_df.columns[0]
+    ensemble.data_df.at[label, column] = np.nan
+    ensemble.data_layout = type(ensemble.data_layout).from_frame(ensemble.data_df)
+    ensemble.obs_vector = ensemble.data_layout.vector(ensemble.data_df)
+
+    ensemble.forecast(ensemble.enX)
+    assert ensemble.pred_data.nd == ensemble.obs_vector.shape[0] == ensemble.data_layout.nd
diff --git a/tests/assimilation/test_qaqc.py b/tests/assimilation/test_qaqc.py
new file mode 100644
index 00000000..5094a7eb
--- /dev/null
+++ b/tests/assimilation/test_qaqc.py
@@ -0,0 +1,186 @@
+"""QA/QC diagnostics on the ensemble's frames.
+
+Unit tests build small observation, variance and prediction frames by hand;
+the end-to-end test enables ``qa`` and ``qc`` on the golden Van der Pol case
+and checks the run completes and leaves the expected artefacts.
+"""
+
+from pathlib import Path
+
+import numpy as np
+import pandas as pd
+import pytest
+
+from misc.structures import PETDataFrame
+from pipt.misc_tools.qaqc_tools import QAQC
+
+NE = 12
+POINTS = ["t0", "t1", "t2"]
+
+
+class Recorder:
+    def __init__(self):
+        self.lines = []
+
+    def info(self, message):
+        self.lines.append(str(message))
+
+    def text(self):
+        return "\n".join(self.lines)
+
+
+def _frame(cells, is_ensemble=False):
+    df = pd.DataFrame(cells, index=pd.Index(POINTS, name="steps"))
+    return PETDataFrame.from_pandas(df, is_ensemble=is_ensemble)
+
+
+def _case():
+    rng = np.random.default_rng(0)
+    x = rng.standard_normal(NE)                                  # scalar parameter
+    field = rng.standard_normal((5, NE))                         # field parameter
+    ini_state = {"x": x[None, :].copy(), "field": field.copy()}
+    # Data type "a" is 2x plus noise at every report point; "b" is missing at
+    # t1; "sim2seis" is a 4-value vector at t0 and t2.
+    a_pred = [2 * x + 0.1 * rng.standard_normal(NE) for _ in POINTS]
+    b_pred = [rng.standard_normal(NE) for _ in POINTS]
+    s_pred = [rng.standard_normal((4, NE)) for _ in POINTS]
+    pred = _frame({"a": a_pred, "b": b_pred, "sim2seis": [s_pred[0], None, s_pred[2]]}, is_ensemble=True)
+    obs = _frame({
+        "a": [np.array([2 * x.mean() + 3.0]) for _ in POINTS],   # above the whole ensemble
+        "b": [np.array([0.0]), None, np.array([0.1])],
+        "sim2seis": [np.zeros(4), None, np.zeros(4)],
+    })
+    var = _frame({
+        "a": [np.array([0.04]) for _ in POINTS],
+        "b": [np.array([1.0]), None, np.array([1.0])],
+        "sim2seis": [np.full(4, 0.5), None, np.full(4, 0.5)],
+    })
+    keys = {"assimindex": [[0, 1, 2]]}
+    prior_info = {"x": {"nx": 1, "ny": 1, "nz": 1}, "field": {"nx": 5, "ny": 1, "nz": 1}}
+    return keys, obs, var, pred, ini_state, prior_info
+
+
+def _qaqc(tmp_path, lam=0.0, **kwargs):
+    keys, obs, var, pred, ini_state, prior_info = _case()
+    log = Recorder()
+    qaqc = QAQC(keys, obs, var, logger=log, prior_info=prior_info, ini_state=ini_state,
+                folder=tmp_path / "QAQC", **kwargs)
+    qaqc.set(pred, {k: v.copy() for k, v in ini_state.items()}, lam)
+    return qaqc, log
+
+
+def test_frames_are_adapted_per_data_type(tmp_path):
+    qaqc, _ = _qaqc(tmp_path)
+    assert qaqc.ne == NE
+    assert qaqc.en_fcst["a"].shape == (3, NE) and qaqc.en_obs["a"].shape == (3, 1)
+    np.testing.assert_array_equal(qaqc.en_var["a"].ravel(), [0.04, 0.04, 0.04])   # variances, not observations
+    np.testing.assert_array_equal(qaqc.en_var["b"].ravel(), [1.0, 1.0])
+    np.testing.assert_array_equal(qaqc.en_var_vec["sim2seis"].ravel(), np.full(8, 0.5))
+    assert qaqc.en_time["b"] == [0, 2]                          # the None at t1 is skipped
+    assert qaqc.en_fcst["b"].shape == (2, NE)
+    assert qaqc.en_obs_vec["sim2seis"].shape == (8, 1)          # two vintages of four values
+    assert qaqc.en_fcst_vec["sim2seis"].shape == (8, NE)
+    assert qaqc.en_fcst["sim2seis"].shape == (0, NE)            # no point data of that type
+
+
+def test_multilevel_is_refused_explicitly(tmp_path):
+    keys, obs, var, *_ = _case()
+    with pytest.raises(NotImplementedError, match="multilevel"):
+        QAQC({**keys, "multilevel": {}}, obs, var, folder=tmp_path)
+
+
+def test_coverage_flags_observations_outside_the_ensemble(tmp_path):
+    qaqc, log = _qaqc(tmp_path)
+    qaqc.calc_coverage()
+    assert "coverage a: 3 of 3 observations outside" in log.text()
+    assert "coverage b: 0 of 2" in log.text()
+    assert (tmp_path / "QAQC" / "a.png").exists() and (tmp_path / "QAQC" / "b.png").exists()
+    assert "skipping the seismic maps" in log.text()          # no mask file, no field_dim
+
+
+def test_update_statistics_report_movement_in_prior_standard_deviations(tmp_path):
+    qaqc, log = _qaqc(tmp_path)
+    moved = {k: v.copy() for k, v in qaqc.ini_state.items()}
+    moved["x"] = moved["x"] + 5 * moved["x"].std()               # every x moved by 5 std
+    qaqc.set(qaqc.pred_data, moved, 0.0)
+    qaqc.calc_da_stat()
+    text = log.text()
+    assert "Group x:" in text and "100.0% / 100.0% / 100.0%" in text
+    assert "Group field:" in text and "0.0% / 0.0% / 0.0%" in text
+
+
+def test_mahalanobis_ranks_the_data_and_draws_crossplots(tmp_path):
+    qaqc, log = _qaqc(tmp_path)
+    qaqc.calc_mahalanobis((1, None, 2, None, 1, "time"))
+    text = log.text()
+    assert "Largest values are" in text and "Largest level-2 values" in text
+    assert any(p.name.startswith("crossplot_") for p in (tmp_path / "QAQC").iterdir())
+    # the observations of "a" sit far above the ensemble, so they score highest
+    first = text.split("Largest values are:\n")[1].splitlines()[0]
+    assert "'a'" in first
+
+
+def test_kalman_gain_has_the_sign_of_the_residual_and_is_ranked(tmp_path):
+    qaqc, log = _qaqc(tmp_path, lam=0.0)
+    gain = qaqc._gain("x", qaqc.en_fcst["a"], qaqc.en_obs["a"], qaqc.en_var["a"], localize=False)
+    assert gain.shape == (1,) and gain[0] > 0                    # data above forecast, positive correlation
+    qaqc.calc_kg({"num_store": 3})
+    text = log.text()
+    assert "largest Kg mean values" in text and "largest Kg max values" in text
+    assert "('a', 'field', None)" in text or "('sim2seis', 'field', None)" in text or "('b', 'field', None)" in text
+
+
+def test_kalman_gain_per_report_point_plots_scalar_parameters(tmp_path):
+    qaqc, _ = _qaqc(tmp_path)
+    qaqc.calc_kg({"unique_time": True, "only_log": False, "plot_all_kg": True})
+    assert (tmp_path / "QAQC" / "Kg_x_a.png").exists()
+
+
+def test_diagnostics_refuse_to_run_before_set(tmp_path):
+    keys, obs, var, pred, ini_state, prior_info = _case()
+    qaqc = QAQC(keys, obs, var, logger=Recorder(), prior_info=prior_info, ini_state=ini_state, folder=tmp_path)
+    with pytest.raises(ValueError, match="call set"):
+        qaqc.calc_coverage()
+
+
+# ----------------------------------------------------------------------
+# End to end: qa and qc through a scheme on the golden case
+# ----------------------------------------------------------------------
+
+from input_output import read_config  # noqa: E402
+from pipt import ESMDA, LMEnRML  # noqa: E402
+from simulator.vanderpol import VanDerPolOscillator  # noqa: E402
+from test_numerical_characterisation import GLOBAL_SEED, _write_config, _write_synthetic_case  # noqa: E402
+
+
+@pytest.mark.parametrize("scheme_cls, name, analysis", [(ESMDA, "esmda", "approx"), (LMEnRML, "lmenrml", "approx")],
+                         ids=["esmda", "lmenrml"])
+def test_qa_and_qc_run_through_a_scheme(tmp_path, monkeypatch, caplog, scheme_cls, name, analysis):
+    monkeypatch.chdir(tmp_path)
+    caplog.set_level("INFO")
+    report_points = _write_synthetic_case()
+    cfg_da, cfg_sim, cfg_ens = read_config.read(_write_config("qaqc_case", name, analysis, report_points))
+    cfg_da["qa"] = True
+    cfg_da["qc"] = True
+    np.random.seed(GLOBAL_SEED)
+
+    result = scheme_cls.assimilate(cfg_da, cfg_ens, VanDerPolOscillator(cfg_sim), analysis=analysis)
+
+    assert np.isfinite(result.x).all()
+    produced = {p.name for p in Path("QAQC").iterdir()}
+    assert "x1.png" in produced                                  # coverage of the one data type
+    assert any(n.startswith("crossplot_") for n in produced)
+    # The run logger propagates to the root logger, which pytest captures.
+    assert "Statistics for updated parameters" in caplog.text
+    assert "largest Kg mean values" in caplog.text
+    assert "Mahalanobis" in caplog.text
+
+
+def test_hls_conversion_round_trips():
+    """The numpy HLS conversion replaced OpenCV's; it must invert itself."""
+    from pipt.misc_tools.qaqc_tools import _hls_to_rgb, _rgb_to_hls
+
+    rgb = np.random.default_rng(3).random((6, 7, 3))
+    np.testing.assert_allclose(_hls_to_rgb(_rgb_to_hls(rgb)), rgb, atol=1e-12)
+    grey = np.full((2, 2, 3), 0.4)
+    np.testing.assert_allclose(_hls_to_rgb(_rgb_to_hls(grey)), grey, atol=1e-12)
diff --git a/tests/assimilation/test_remove_outliers.py b/tests/assimilation/test_remove_outliers.py
new file mode 100644
index 00000000..1beab6da
--- /dev/null
+++ b/tests/assimilation/test_remove_outliers.py
@@ -0,0 +1,116 @@
+"""``remove_outliers`` must move a replaced member's adjoint together with its
+state and predictions. The adjoint filter used to sit after the ``return``
+statement, so it never ran and a resampled member kept a stranger's gradient."""
+
+import numpy as np
+import pandas as pd
+
+from misc.structures import DataLayout, PredictedData
+from misc.structures.structures import PETDataFrame
+from pipt.ensembles.forecast import OutlierMixin
+
+# The 4-sigma rule can only flag a lone outlier when (ne - 1) / sqrt(ne) > 4.
+NE = 25
+NX = 3
+STEPS = ["t1", "t2"]
+TRUTH = {"t1": 1.0, "t2": 2.0}
+
+
+def _frame(cells, is_ensemble):
+    df = pd.DataFrame({"obs": [cells[s] for s in STEPS]}, index=pd.Index(STEPS, name="steps"))
+    return PETDataFrame.from_pandas(df, is_ensemble=is_ensemble)
+
+
+def _predictions(outlier_member=0):
+    """Every member predicts the truth except one, which is far off."""
+    cells = {}
+    for step in STEPS:
+        pred = np.full(NE, TRUTH[step])
+        if outlier_member is not None:
+            pred[outlier_member] = 100.0
+        cells[step] = pred
+    return cells
+
+
+class Host(OutlierMixin):
+    """The attributes remove_outliers reads, and nothing else."""
+
+    def __init__(self, pred_cells, with_adjoints):
+        self.ne = NE
+        self.rng = np.random
+        self.logger = lambda *args, **kwargs: None
+        self.data_df = _frame(TRUTH, is_ensemble=False)
+        self.data_var_df = _frame({s: 1.0 for s in STEPS}, is_ensemble=False)
+        self.data_layout = DataLayout.from_frame(self.data_df)
+        self.obs_vector = self.data_layout.vector(self.data_df)
+        self.obs_variance = self.data_layout.vector(self.data_var_df)
+        self.pred_data = PredictedData.from_frame(self.data_layout, _frame(pred_cells, is_ensemble=True), NE)
+        # The full forecast as the members returned it: one list of records per member.
+        self.member_outputs = [[[{"obs": pred_cells[s][j]} for s in STEPS] for j in range(NE)]]
+        self._sim_data = None
+        self.sim_data = None
+        # Adjoint of member j is 10*j in every entry, so the member it came
+        # from can be read straight off the array: (nd, nx, ne).
+        self.adjoints = np.tile(10.0 * np.arange(NE), (len(STEPS), NX, 1)) if with_adjoints else None
+        self.member_adjoints = None
+
+
+def _state():
+    # Column j holds j everywhere, so the member a column came from is readable.
+    return np.tile(np.arange(NE, dtype=float), (NX, 1))
+
+
+def test_adjoints_follow_the_resampled_member():
+    pred_cells = _predictions(outlier_member=0)
+    host = Host(pred_cells, with_adjoints=True)
+    enX = _state()
+
+    np.random.seed(1)
+    new_enX = host.remove_outliers(enX)
+
+    k = int(new_enX[0, 0])  # the member that replaced the outlier
+    assert k != 0
+    np.testing.assert_array_equal(new_enX[:, 0], enX[:, k])
+    np.testing.assert_array_equal(new_enX[:, 1:], enX[:, 1:])
+    np.testing.assert_array_equal(host.adjoints[:, :, 0], 10.0 * k)
+    np.testing.assert_array_equal(host.adjoints[:, :, 1:], np.tile(10.0 * np.arange(1, NE), (len(STEPS), NX, 1)))
+    for i, step in enumerate(STEPS):
+        assert host.pred_data.to_frame().loc[step, "obs"][0] == pred_cells[step][k]
+        assert host.member_outputs[0][0][i]["obs"] == pred_cells[step][k]      # the raw outputs follow too
+
+
+def test_without_adjoints_the_state_and_predictions_are_still_resampled():
+    pred_cells = _predictions(outlier_member=0)
+    host = Host(pred_cells, with_adjoints=False)
+
+    np.random.seed(1)
+    new_enX = host.remove_outliers(_state())
+
+    assert host.adjoints is None
+    assert int(new_enX[0, 0]) != 0
+    for step in STEPS:
+        assert host.pred_data.to_frame().loc[step, "obs"][0] == TRUTH[step]
+
+
+def test_no_outliers_returns_the_same_state_object():
+    host = Host(_predictions(outlier_member=None), with_adjoints=True)
+    enX = _state()
+    assert host.remove_outliers(enX) is enX
+
+
+def test_a_forecast_loaded_as_a_frame_is_resampled_cell_by_cell():
+    """A forecast read from a restart file exists only as a frame; its empty
+    cells are None and the filter used to call .ndim on them."""
+    pred_cells = _predictions(outlier_member=0)
+    host = Host(pred_cells, with_adjoints=False)
+    host.member_outputs = None
+    host.sim_data = _frame(pred_cells, is_ensemble=True)
+    host.sim_data.loc["t2", "obs"] = None
+
+    np.random.seed(1)
+    new_enX = host.remove_outliers(_state())
+
+    k = int(new_enX[0, 0])
+    assert k != 0
+    assert host.sim_data.loc["t1", "obs"][0] == pred_cells["t1"][k]
+    assert host.sim_data.loc["t2", "obs"] is None
diff --git a/tests/assimilation/test_restart_forecast_file.py b/tests/assimilation/test_restart_forecast_file.py
new file mode 100644
index 00000000..48504338
--- /dev/null
+++ b/tests/assimilation/test_restart_forecast_file.py
@@ -0,0 +1,66 @@
+"""A hand-placed `restart_sim_results.pkl` stands in for the forecast only on a restart.
+
+The file is how a user hands a crashed run the forecast it had already
+finished. It used to be consumed on any run that found it in the working
+directory, so a forgotten file silently replaced a fresh forecast.
+"""
+
+import pickle
+from pathlib import Path
+
+import numpy as np
+import pytest
+
+from input_output import read_config
+from pipt.ensembles import AssimilationEnsemble
+from pipt.ensembles.forecast import ForecastMixin
+from simulator.vanderpol import VanDerPolOscillator
+from test_numerical_characterisation import _write_config, _write_synthetic_case
+
+NE = 20
+
+
+@pytest.fixture(params=["saving", "nosave"])
+def ensemble_with_placed_file(request, tmp_path, monkeypatch):
+    monkeypatch.chdir(tmp_path)
+    report_points = _write_synthetic_case(ne=NE)
+    cfg_da, cfg_sim, cfg_ens = read_config.read(_write_config("restart_file", "esmda", "approx", report_points, ne=NE))
+    if request.param == "saving":
+        cfg_da.pop("nosave")
+        cfg_da["savefolder"] = "run_results"
+    ensemble = AssimilationEnsemble(cfg_da, cfg_ens, VanDerPolOscillator(cfg_sim))
+    ensemble.forecast(ensemble.enX)
+    placed = ensemble.sim_data
+    with open(ForecastMixin.RESTART_RESULTS_FILE, "wb") as file:
+        pickle.dump(placed, file)
+    return ensemble, placed
+
+
+def test_an_ordinary_run_ignores_the_file_and_forecasts(ensemble_with_placed_file, monkeypatch):
+    ensemble, _ = ensemble_with_placed_file
+    calls = []
+    original = ensemble.calc_prediction
+    monkeypatch.setattr(ensemble, "calc_prediction", lambda enX: calls.append(1) or original(enX))
+
+    assert ensemble.restart is False
+    ensemble.forecast(ensemble.enX)
+
+    assert calls == [1]
+    assert Path(ForecastMixin.RESTART_RESULTS_FILE).exists()
+
+
+def test_a_restart_uses_the_file_once_and_files_it_with_the_results(ensemble_with_placed_file, monkeypatch):
+    ensemble, placed = ensemble_with_placed_file
+
+    def no_forecast(enX):
+        raise AssertionError("the placed forecast should have been used instead of simulating")
+
+    monkeypatch.setattr(ensemble, "calc_prediction", no_forecast)
+    ensemble.restart = True
+    ensemble.forecast(ensemble.enX)
+
+    expected = ensemble._container_from_frame(ensemble.sim_to_pred_data(placed))
+    np.testing.assert_array_equal(ensemble.pred_data.matrix, expected.matrix)
+    assert not Path(ForecastMixin.RESTART_RESULTS_FILE).exists()
+    filed_under = Path(ensemble.save_folder or ".") / ForecastMixin.SIM_RESULTS_FILE
+    assert filed_under.exists()
diff --git a/tests/assimilation/test_restart_resume.py b/tests/assimilation/test_restart_resume.py
new file mode 100644
index 00000000..e569230f
--- /dev/null
+++ b/tests/assimilation/test_restart_resume.py
@@ -0,0 +1,97 @@
+"""A run resumed from a checkpoint continues the interrupted one exactly.
+
+The checkpoint is the scheme's (RestartMixin), driven by `restart`,
+`restartsave` and `restart_file` in the `[dataassim]` block. It carries the
+loop's bookkeeping, the scheme's declared state and the ensemble's state and
+random stream, so resuming does not depend on the random state of the
+process that resumes.
+"""
+
+import numpy as np
+import pytest
+
+from input_output import read_config
+from pipt import ESMDA, GNEnRML, LMEnRML
+from pipt.ensembles import AssimilationEnsemble
+from pipt.update_schemes.core import restart_options
+from simulator.vanderpol import VanDerPolOscillator
+from test_numerical_characterisation import _write_config, _write_synthetic_case
+
+NE = 20
+INTERRUPT_AT = 2
+
+
+class Interrupted(Exception):
+    pass
+
+
+def _configs(tmp_path, monkeypatch, name, **da):
+    tmp_path.mkdir(parents=True, exist_ok=True)
+    monkeypatch.chdir(tmp_path)
+    report_points = _write_synthetic_case(ne=NE)
+    cfg_da, cfg_sim, cfg_ens = read_config.read(_write_config(name, "esmda", "approx", report_points, ne=NE))
+    cfg_da["iteration"] = {"max_iter": 4, "lambda": 10, "lambda_factor": 5, "trunc_energy": 0.99}
+    cfg_da.update(da)
+    return cfg_da, cfg_sim, cfg_ens
+
+
+# EnKF is not here: with one assimilation index the case has one step, so there is nothing to interrupt.
+@pytest.mark.parametrize("scheme_cls, analysis", [(ESMDA, "approx"), (LMEnRML, "approx"), (GNEnRML, "subspace")])
+def test_a_resumed_run_matches_an_uninterrupted_one(tmp_path, monkeypatch, scheme_cls, analysis):
+    checkpoint = str(tmp_path / "checkpoint.pkl")
+
+    # Uninterrupted reference.
+    cfg_da, cfg_sim, cfg_ens = _configs(tmp_path / "ref", monkeypatch, "ref")
+    np.random.seed(1)
+    reference = scheme_cls.assimilate(cfg_da, cfg_ens, VanDerPolOscillator(cfg_sim), analysis=analysis)
+    assert reference.nit > INTERRUPT_AT, "the case must run past the interruption point"
+
+    # The same run, checkpointing, killed after its second accepted iteration.
+    cfg_da, cfg_sim, cfg_ens = _configs(tmp_path / "run", monkeypatch, "run", restartsave=True, restart_file=checkpoint)
+    np.random.seed(1)
+    scheme = scheme_cls(cfg_da, cfg_ens, VanDerPolOscillator(cfg_sim), analysis=analysis)
+    hook = scheme.after_accepted_iteration
+
+    def hook_then_die():
+        hook()
+        if scheme.iteration == INTERRUPT_AT:
+            raise Interrupted
+
+    monkeypatch.setattr(scheme, "after_accepted_iteration", hook_then_die)
+    with pytest.raises(Interrupted):
+        scheme.run_assimilation()
+
+    # Resume in a fresh process with a different random state.
+    cfg_da, cfg_sim, cfg_ens = _configs(tmp_path / "resume", monkeypatch, "resume", restart=True, restart_file=checkpoint)
+    np.random.seed(12345)
+    resumed_scheme = scheme_cls(cfg_da, cfg_ens, VanDerPolOscillator(cfg_sim), analysis=analysis)
+    resumed = resumed_scheme.run_assimilation()
+
+    assert resumed_scheme.ensemble.restart is True
+    assert resumed.nit == reference.nit
+    np.testing.assert_array_equal(np.asarray(resumed.x, dtype=float), np.asarray(reference.x, dtype=float))
+    np.testing.assert_array_equal(np.asarray(resumed.data_misfit), np.asarray(reference.data_misfit))
+
+
+def test_the_checkpoint_is_written_after_the_prior_forecast(tmp_path, monkeypatch):
+    checkpoint = tmp_path / "ck.pkl"
+    cfg_da, cfg_sim, cfg_ens = _configs(tmp_path, monkeypatch, "prior", restartsave="yes", restart_file=str(checkpoint))
+    scheme = ESMDA(cfg_da, cfg_ens, VanDerPolOscillator(cfg_sim), analysis="approx")
+    monkeypatch.setattr(scheme, "update_step", lambda: (_ for _ in ()).throw(Interrupted()))
+    with pytest.raises(Interrupted):
+        scheme.run_assimilation()
+    assert checkpoint.exists()
+
+
+def test_restart_options_read_the_dataassim_keys():
+    assert restart_options({}) == {"restart": False, "restartsave": False}
+    assert restart_options({"restart": "yes", "restartsave": "no", "restart_file": "x.pkl"}) == {
+        "restart": True, "restartsave": False, "restart_file": "x.pkl"}
+
+
+def test_the_ensemble_no_longer_looks_for_an_emergency_dump(tmp_path, monkeypatch):
+    # `restart = yes` used to make the ensemble assert that `emergency_dump` sat in the working directory.
+    cfg_da, cfg_sim, cfg_ens = _configs(tmp_path, monkeypatch, "nodump", restart="yes")
+    ensemble = AssimilationEnsemble(cfg_da, cfg_ens, VanDerPolOscillator(cfg_sim))
+    assert ensemble.restart is False
+    assert not hasattr(ensemble, "load")
diff --git a/tests/assimilation/test_save_prediction.py b/tests/assimilation/test_save_prediction.py
new file mode 100644
index 00000000..417136f1
--- /dev/null
+++ b/tests/assimilation/test_save_prediction.py
@@ -0,0 +1,33 @@
+"""`calc_prediction(..., save_prediction=name)` writes the forecast where the ensemble's options say.
+
+popt is the caller (its `save_prediction` option). The branch read
+`self.ensemble.keys_da`, an attribute the base ensemble never had, so using
+the option raised AttributeError; and it wrote into a folder it never created.
+"""
+
+import pickle
+from pathlib import Path
+
+import numpy as np
+import pytest
+
+from test_failed_member_replacement import _bare_ensemble, _members
+
+
+# `save_folder` is mapped to `savefolder` at the config boundary (tests/test_config_boundary.py);
+# a bare ensemble built without it holds canonical keys only.
+@pytest.mark.parametrize("options, folder", [({}, "Predictions"), ({"savefolder": "out"}, "out")])
+def test_the_forecast_is_pickled_under_the_named_folder(tmp_path, monkeypatch, options, folder):
+    monkeypatch.chdir(tmp_path)
+    ens = _bare_ensemble()
+    ens.keys_en = options
+    enX, _ = _members()
+
+    np.random.seed(0)
+    ens.calc_prediction(enX, save_prediction="forecast")
+
+    path = Path(folder) / "forecast.pkl"
+    assert path.exists()
+    with open(path, "rb") as file:
+        saved = pickle.load(file)
+    np.testing.assert_array_equal(np.asarray(saved.loc[1, "d"]), np.asarray(ens.sim_data.loc[1, "d"]))
diff --git a/tests/assimilation/test_savedata.py b/tests/assimilation/test_savedata.py
new file mode 100644
index 00000000..8ee95a2b
--- /dev/null
+++ b/tests/assimilation/test_savedata.py
@@ -0,0 +1,118 @@
+"""Per-iteration result saving: the ``savedata`` key and its output files.
+
+Unit-level counterpart to the end-to-end assertions in
+``test_assimilation_pipeline.py``. Those run a real scheme and are slow; these
+drive the saving path of :class:`~pipt.update_schemes.core.AssimilationScheme`
+directly, so the naming contract and the deprecated alias are cheap to pin.
+"""
+
+import warnings
+from types import SimpleNamespace
+
+import numpy as np
+import pytest
+
+from pipt.update_schemes.core import AssimilationScheme
+
+
+class FakeScheme(AssimilationScheme):
+    """Enough of a scheme for the saving path, and nothing else.
+
+    ``keys_da`` and ``save_folder`` are read-only views of the ensemble, so
+    they are supplied through a stand-in for it rather than assigned.
+    """
+
+    def __init__(self, keys_da, save_folder, iteration=0, **attrs):
+        self.ensemble = SimpleNamespace(
+            keys_da=keys_da,
+            save_folder=str(save_folder),
+            multilevel=None,
+        )
+        self.iteration = iteration
+        for name, value in attrs.items():
+            setattr(self, name, value)
+
+    def update_step(self):
+        """Never called: declared only because the class is abstract."""
+        raise NotImplementedError
+
+
+def _saved(folder, iteration):
+    path = folder / f"assimilation_result_{iteration}.npz"
+    assert path.exists(), f"expected {path.name}, found {sorted(p.name for p in folder.iterdir())}"
+    with np.load(path, allow_pickle=True) as archive:
+        return {name: archive[name] for name in archive.files}
+
+
+# ----------------------------------------------------------------------
+# Naming
+# ----------------------------------------------------------------------
+def test_file_is_named_for_the_iteration(tmp_path):
+    """``assimilation_result_{i}.npz``, mirroring popt's ``optimize_result_{i}``.
+
+    Was ``debug_analysis_step_{i}.npz``, which described the mechanism as a
+    debugging aid rather than as the record of the run that it is.
+    """
+    scheme = FakeScheme(
+        {"savedata": ["ensemble_misfit"]},
+        tmp_path,
+        iteration=3,
+        ensemble_misfit=np.array([1.0, 2.0]),
+    )
+    scheme._save_iteration_data()
+
+    np.testing.assert_array_equal(_saved(tmp_path, 3)["ensemble_misfit"], [1.0, 2.0])
+
+
+def test_a_single_name_need_not_be_a_list(tmp_path):
+    scheme = FakeScheme({"savedata": "data_misfit"}, tmp_path, data_misfit=7.5)
+    scheme._save_iteration_data()
+
+    assert _saved(tmp_path, 0)["data_misfit"] == 7.5
+
+
+def test_unresolvable_names_are_skipped_not_fatal(tmp_path):
+    """A variable can legitimately be absent for a given scheme.
+
+    ``lam`` exists for the Levenberg-Marquardt family and not for ES-MDA, so a
+    shared config naming it must not fail the ES-MDA run.
+    """
+    scheme = FakeScheme(
+        {"savedata": ["data_misfit", "lam"]}, tmp_path, data_misfit=1.0
+    )
+    with pytest.warns(UserWarning, match="Cannot save 'lam'"):
+        scheme._save_iteration_data()
+    assert set(_saved(tmp_path, 0)) == {"data_misfit"}
+
+
+# ----------------------------------------------------------------------
+# The deprecated spelling
+# ----------------------------------------------------------------------
+def test_analysisdebug_still_works_and_warns(tmp_path):
+    scheme = FakeScheme({"analysisdebug": ["data_misfit"]}, tmp_path, data_misfit=2.0)
+
+    with pytest.deprecated_call(match="analysisdebug"):
+        keys = scheme._savedata_keys
+
+    assert keys == ["data_misfit"]
+
+
+def test_savedata_wins_over_the_old_spelling(tmp_path):
+    """Not merged: a config carrying both is mid-migration.
+
+    Unioning them would keep honouring whichever one the user meant to delete.
+    """
+    scheme = FakeScheme(
+        {"savedata": ["data_misfit"], "analysisdebug": ["ensemble_misfit"]},
+        tmp_path,
+        data_misfit=1.0,
+        ensemble_misfit=np.array([1.0]),
+    )
+
+    with warnings.catch_warnings():
+        warnings.simplefilter("error", DeprecationWarning)
+        assert scheme._savedata_keys == ["data_misfit"]
+
+
+def test_no_key_means_no_saving(tmp_path):
+    assert FakeScheme({}, tmp_path)._savedata_keys == []
diff --git a/tests/assimilation/test_scheme_base.py b/tests/assimilation/test_scheme_base.py
new file mode 100644
index 00000000..00137b4d
--- /dev/null
+++ b/tests/assimilation/test_scheme_base.py
@@ -0,0 +1,334 @@
+"""Tests for the shared assimilation scheme base class.
+
+These exercise ``AssimilationScheme`` in isolation via a fake ensemble, so
+the loop/convergence/restart machinery is covered without running a simulator.
+"""
+
+import os
+from types import SimpleNamespace
+
+import numpy as np
+import pytest
+
+from pipt.update_schemes.core import (
+    AssimilationResult,
+    AssimilationScheme,
+    StepReport,
+)
+
+
+class FakeEnsemble:
+    """Minimal object satisfying the ensemble collaborator protocol.
+
+    ``keys_da``, ``sim`` and ``_saving_enabled`` are part of it because the
+    scheme carries the run workflow -- QA/QC, artifact saving, outlier
+    replacement -- and consults them at every hook. Saving is off, so nothing
+    here touches the filesystem.
+    """
+
+    def __init__(self, nx=3, ne=5):
+        self.enX = np.zeros((nx, ne))
+        self.pred_data = None
+        self.logger = None
+        self.forecast_calls = 0
+        self.keys_da = {}
+        self.sim = SimpleNamespace(input_dict={})
+        self._saving_enabled = False
+
+    def forecast(self, enX):
+        self.forecast_calls += 1
+        self.pred_data = enX.copy()
+
+    def restart_state(self):
+        return {"enX": self.enX}
+
+    def restore_restart_state(self, state):
+        self.enX = state["enX"]
+
+
+class DecreasingMisfitScheme(AssimilationScheme):
+    """Scheme whose misfit halves each step, converging on misfit_tol."""
+
+    def update_step(self):
+        # The loop derives data_misfit from the reported array, so the shift
+        # of current -> previous happens here, before the new value is sent.
+        self.prev_data_misfit_mean = self.data_misfit_mean
+        value = 100.0 if self.data_misfit_mean is None else self.data_misfit_mean / 2.0
+        if self.prior_data_misfit_mean is None:
+            self.prior_data_misfit_mean = value
+        self.enX_old = self.ensemble.enX.copy()
+        self.ensemble.enX = self.ensemble.enX + 1.0
+        self.ensemble.forecast(self.ensemble.enX)
+        return StepReport(accepted=True, state=self.ensemble.enX,
+                          misfit=np.full(self.ensemble.enX.shape[1], value))
+
+
+class NeverConvergingScheme(AssimilationScheme):
+    """Scheme that always accepts but never satisfies a tolerance."""
+
+    def update_step(self):
+        self.prev_data_misfit_mean = self.data_misfit_mean
+        value = 100.0 if self.data_misfit_mean is None else self.data_misfit_mean * 2.0
+        if self.prior_data_misfit_mean is None:
+            self.prior_data_misfit_mean = value
+        self.enX_old = self.ensemble.enX.copy()
+        self.ensemble.enX = self.ensemble.enX + 10.0
+        return StepReport(accepted=True, state=self.ensemble.enX,
+                          misfit=np.full(self.ensemble.enX.shape[1], value))
+
+
+class StallingScheme(AssimilationScheme):
+    """Accepts, but barely moves the state -- and does not snapshot enX_old.
+
+    The shipped schemes are all like this: none of them assign ``enX_old``,
+    so state convergence only works if the base loop takes the snapshot.
+    """
+
+    def update_step(self):
+        self.prev_data_misfit_mean = self.data_misfit_mean
+        value = 100.0 if self.data_misfit_mean is None else self.data_misfit_mean * 0.999
+        if self.prior_data_misfit_mean is None:
+            self.prior_data_misfit_mean = value
+        self.ensemble.enX = self.ensemble.enX + 1e-12
+        self.ensemble.forecast(self.ensemble.enX)
+        return StepReport(accepted=True, state=self.ensemble.enX,
+                          misfit=np.full(self.ensemble.enX.shape[1], value))
+
+
+class AlwaysRejectingScheme(AssimilationScheme):
+    """Scheme that reports it could not find an improving step.
+
+    A scheme retries internally, so a rejected report means it has given up;
+    the loop stops rather than asking again.
+    """
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.attempts = 0
+
+    def update_step(self):
+        self.attempts += 1
+        # Rejected: nothing moved, so report the misfit as it stands.
+        value = 100.0 if self.data_misfit_mean is None else self.data_misfit_mean
+        if self.prior_data_misfit_mean is None:
+            self.prior_data_misfit_mean = value
+        return StepReport(accepted=False, state=self.ensemble.enX,
+                          misfit=np.full(self.ensemble.enX.shape[1], value))
+
+
+@pytest.fixture
+def in_tmp_dir(tmp_path, monkeypatch):
+    monkeypatch.chdir(tmp_path)
+    return tmp_path
+
+
+# ----------------------------------------------------------------------
+# Construction
+# ----------------------------------------------------------------------
+
+def test_is_abstract():
+    """The base class cannot be instantiated without update_step."""
+    with pytest.raises(TypeError):
+        AssimilationScheme(FakeEnsemble())
+
+
+def test_defaults(in_tmp_dir):
+    scheme = DecreasingMisfitScheme(FakeEnsemble())
+    assert scheme.iteration == 0
+    assert scheme.maxiter == 100
+    assert scheme.misfit_tol == 0.01
+    assert scheme.restart is False
+    assert scheme.restart_file == "decreasingmisfitscheme_restart.pkl"
+
+
+# ----------------------------------------------------------------------
+# Loop behaviour
+# ----------------------------------------------------------------------
+
+def test_runs_prior_forecast_before_iterating(in_tmp_dir):
+    ens = FakeEnsemble()
+    DecreasingMisfitScheme(ens, maxiter=1).run_assimilation()
+    # one prior forecast plus one per accepted iteration
+    assert ens.forecast_calls == 2
+
+
+def test_stops_at_maxiter(in_tmp_dir):
+    scheme = NeverConvergingScheme(FakeEnsemble(), maxiter=4)
+    res = scheme.run_assimilation()
+    assert res.nit == 4
+    assert res.success is False
+    assert "Maximum number of iterations" in res.message
+
+
+def test_converges_on_misfit_tolerance(in_tmp_dir):
+    # misfit halves each step, so the relative change is 0.5 -- never below a
+    # 0.01 tolerance, but comfortably below a 0.9 one.
+    scheme = DecreasingMisfitScheme(FakeEnsemble(), maxiter=20, misfit_tol=0.9)
+    res = scheme.run_assimilation()
+    assert res.success is True
+    assert res.nit < 20
+    assert res.why_stop.get("misfit_tol") is True
+    assert "Data misfit change" in res.message
+
+
+def test_converges_on_state_tolerance(in_tmp_dir):
+    # step_tol is huge, so the first state change counts as convergence.
+    scheme = DecreasingMisfitScheme(FakeEnsemble(), maxiter=20, step_tol=1e9)
+    res = scheme.run_assimilation()
+    assert res.success is True
+    assert res.why_stop.get("step_tol") is True
+
+
+def test_state_convergence_works_without_the_scheme_snapshotting(in_tmp_dir):
+    """The base loop takes the enX_old snapshot, so a scheme gets state
+    convergence without doing any bookkeeping of its own -- which is the
+    situation every shipped scheme is in.
+    """
+    scheme = StallingScheme(FakeEnsemble(), maxiter=20, step_tol=1e-6)
+    res = scheme.run_assimilation()
+    assert res.success is True
+    assert res.why_stop.get("step_tol") is True
+    assert "did not move" not in res.message  # names the criterion
+    assert res.nit < 20                       # stopped early, not on maxiter
+
+
+def test_state_convergence_ignores_rejected_steps(in_tmp_dir):
+    """A rejected step leaves enX untouched, so the norm is exactly zero.
+
+    Without the step_accepted guard that would read as instant convergence,
+    when the truth is the scheme could not find an improvement.
+    """
+    scheme = AlwaysRejectingScheme(FakeEnsemble(), maxiter=5, step_tol=1e9)
+    res = scheme.run_assimilation()
+    assert res.why_stop.get("step_tol") is not True
+    assert res.success is False
+
+
+def test_no_snapshot_taken_when_the_criterion_is_off(in_tmp_dir):
+    """enX can be large; the copy is skipped entirely when step_tol == 0."""
+    scheme = NeverConvergingScheme(FakeEnsemble(), maxiter=3, step_tol=0.0)
+    scheme.enX_old = None
+    scheme.run_assimilation()
+    # NeverConvergingScheme sets enX_old itself, so prove the *loop* did not:
+    plain = AlwaysRejectingScheme(FakeEnsemble(), maxiter=2, step_tol=0.0)
+    plain.run_assimilation()
+    assert plain.enX_old is None
+
+
+def test_subclass_convergence_hook(in_tmp_dir):
+    class StopsAfterTwo(NeverConvergingScheme):
+        def check_convergence(self):
+            if self.iteration >= 2:
+                self.conv_msg = "scheme-specific criterion"
+                return True
+            return False
+
+    res = StopsAfterTwo(FakeEnsemble(), maxiter=50).run_assimilation()
+    assert res.success is True
+    assert res.nit == 2
+    assert res.message == "scheme-specific criterion"
+
+
+def test_a_rejected_step_stops_the_run(in_tmp_dir):
+    """The scheme has already retried inside update_step; asking again would
+    only repeat the step it just said it could not improve on."""
+    scheme = AlwaysRejectingScheme(FakeEnsemble(), maxiter=5)
+    res = scheme.run_assimilation()
+    assert res.nit == 0
+    assert scheme.attempts == 1
+    assert res.success is False
+    assert "No improving step" in res.message
+
+
+def test_a_scheme_that_stops_keeps_its_own_message(in_tmp_dir):
+    """A scheme explaining its own give-up is not overwritten by the loop."""
+
+    class ExplainsItself(AlwaysRejectingScheme):
+        def update_step(self):
+            self.conv_msg = "ran out of damping attempts"
+            return super().update_step()
+
+    res = ExplainsItself(FakeEnsemble(), maxiter=5).run_assimilation()
+    assert res.message == "ran out of damping attempts"
+
+
+def test_the_loop_logs_one_row_per_accepted_iteration(in_tmp_dir):
+    """Logging is the loop's job, so a scheme gets its rows without asking."""
+    rows = []
+
+    class Logging(DecreasingMisfitScheme):
+        def log_update(self, success=None, prior_run=False):
+            rows.append((self.iteration, prior_run))
+
+    Logging(FakeEnsemble(), maxiter=3).run_assimilation()
+    # No prior row: this scheme scores nothing, so there is no prior to report.
+    assert rows == [(0, False), (1, False), (2, False)]
+
+
+# ----------------------------------------------------------------------
+# Result object
+# ----------------------------------------------------------------------
+
+def test_result_is_attribute_accessible(in_tmp_dir):
+    res = DecreasingMisfitScheme(FakeEnsemble(), maxiter=2).run_assimilation()
+    assert isinstance(res, AssimilationResult)
+    assert res["nit"] == res.nit
+    assert res.prior_data_misfit == 100.0
+
+
+def test_assimilate_classmethod_matches_manual_run(in_tmp_dir):
+    res = DecreasingMisfitScheme.assimilate(FakeEnsemble(), maxiter=3)
+    manual = DecreasingMisfitScheme(FakeEnsemble(), maxiter=3).run_assimilation()
+    assert res.nit == manual.nit
+    assert res.data_misfit == manual.data_misfit
+
+
+# ----------------------------------------------------------------------
+# Restart
+# ----------------------------------------------------------------------
+
+def test_restart_roundtrip(in_tmp_dir):
+    scheme = DecreasingMisfitScheme(
+        FakeEnsemble(), maxiter=3, restartsave=True
+    )
+    scheme.run_assimilation()
+    assert os.path.exists(scheme.restart_file)
+    saved_iteration = scheme.iteration
+    saved_misfit = scheme.data_misfit_mean
+
+    resumed = DecreasingMisfitScheme(
+        FakeEnsemble(), maxiter=3, restart=True
+    )
+    resumed.load_restart()
+    assert resumed.iteration == saved_iteration
+    assert resumed.data_misfit_mean == saved_misfit
+
+
+def test_restart_file_rejects_foreign_scheme(in_tmp_dir):
+    scheme = DecreasingMisfitScheme(
+        FakeEnsemble(), maxiter=2, restartsave=True
+    )
+    scheme.run_assimilation()
+
+    foreign = NeverConvergingScheme(FakeEnsemble(), restart=True)
+    foreign.restart_file = scheme.restart_file
+    with pytest.raises(RuntimeError, match="does not match"):
+        foreign.load_restart()
+
+
+def test_convergence_summary_says_what_happened():
+    """It said 'Convergence was met.' after every run, including one that
+    stopped on the iteration limit."""
+    from pipt.update_schemes.esmda import ESMDA   # any concrete scheme; the base is abstract
+
+    lines = []
+    scheme = object.__new__(ESMDA)
+    scheme.logger = lines.append
+    scheme.prior_data_misfit_mean = 10.0
+    scheme.data_misfit_mean = 4.0
+    scheme.prev_data_misfit_mean = 5.0
+
+    scheme._log_convergence_summary(False)
+    assert "without convergence" in lines[-1] and "Convergence was met" not in lines[-1]
+    scheme._log_convergence_summary(True)
+    assert "Convergence was met" in lines[-1]
diff --git a/tests/assimilation/test_scheme_factory.py b/tests/assimilation/test_scheme_factory.py
new file mode 100644
index 00000000..80a54150
--- /dev/null
+++ b/tests/assimilation/test_scheme_factory.py
@@ -0,0 +1,209 @@
+"""Tests for the friendly scheme constructors.
+
+The flavour is a parameter of the algorithm, not a different algorithm, so
+``ESMDA(..., analysis="full")`` and ``registry.get_scheme("esmda", "full")``
+must resolve to the same behaviour: the ``ESMDA`` class with ``analysis``
+pre-bound.
+"""
+
+import pytest
+
+import pipt
+from pipt.update_schemes import registry
+
+
+ALGORITHMS = {
+    "EnKF": ("enkf", ["approx", "full", "subspace"]),
+    "ES": ("es", ["approx", "full", "subspace"]),
+    "ESMDA": ("esmda", ["approx", "full", "subspace", "subspace2", "hybrid"]),
+    "LMEnRML": ("lmenrml", ["approx", "full", "subspace", "subspace2"]),
+    "GNEnRML": ("gnenrml", ["approx", "full", "subspace", "subspace2", "margis"]),
+}
+
+
+def test_top_level_exports():
+    for name in ALGORITHMS:
+        assert hasattr(pipt, name), f"pipt.{name} should be importable"
+    assert hasattr(pipt, "build_scheme")
+
+
+@pytest.mark.parametrize("name", sorted(ALGORITHMS))
+def test_constructor_is_named_readably(name):
+    assert getattr(pipt, name).__name__ == name
+
+
+@pytest.mark.parametrize(
+    "name,scheme,flavour",
+    [(n, s, f) for n, (s, fs) in ALGORITHMS.items() for f in fs],
+)
+def test_every_flavour_documented_is_registered(name, scheme, flavour):
+    """Every advertised (scheme, flavour) pair must still resolve."""
+    assert registry.get_scheme(scheme, flavour) is not None
+
+
+def test_five_algorithms_cover_every_registered_combination():
+    """The five algorithm classes between them reach every registered combo."""
+    for name, (scheme, _) in ALGORITHMS.items():
+        flavours = [f for s, f in registry.available_schemes() if s == scheme]
+        assert flavours, f"{scheme} has no registered flavours"
+
+
+def test_registry_size_matches_the_algorithms_specials_and_historical_names():
+    """Down from eighteen hand-written classes: 5 algorithms x 3 flavours, ``subspace2``
+    on the three schemes that can apply an ensemble transform, the two combinations
+    backed by a distinct implementation, and the two historical names (co_lm_enrml,
+    gn_enrml) that each pin a single flavour."""
+    assert len(registry.available_schemes()) == 5 * 3 + 3 + 2 + 2
+    assert len(ALGORITHMS) == 5               # the public constructors above
+    assert len(registry.ALGORITHMS) == 5 + 2  # plus the two historical names
+
+
+def test_build_scheme_still_dispatches_through_the_registry(monkeypatch):
+    """`build_scheme` resolves by name; the classes no longer need to."""
+    captured = {}
+
+    class Spy:
+        def __init__(self, da, en, sim):
+            captured["args"] = (da, en, sim)
+
+    monkeypatch.setitem(registry.SPECIAL_SCHEMES, ("esmda", "approx"), Spy)
+
+    b = pipt.build_scheme("esmda", {"d": 1}, {"e": 2}, "sim", analysis="approx")
+    assert isinstance(b, Spy)
+    assert captured["args"] == ({"d": 1}, {"e": 2}, "sim")
+
+
+def test_full_coincides_with_approx_for_single_step_schemes():
+    """EnKF/ES never revisit a data group, so `full` resolves to `approx`.
+
+    This used to be encoded as `enkf_full`/`es_full` pinning `FLAVOUR =
+    "approx"`. It now lives directly in `EnKF.COMPATIBLE_ANALYSES`, inherited
+    unchanged by `ES`: `"full"` and `"approx"` point at the same class, so
+    binding either builds the identical strategy regardless of entry point.
+    """
+    from pipt.update_schemes.analysis.approx import approx_update
+    from pipt.update_schemes.analysis.subspace import subspace_update
+    from pipt.update_schemes.enkf import EnKF
+    from pipt.update_schemes.es import ES
+
+    assert EnKF.COMPATIBLE_ANALYSES["full"] is EnKF.COMPATIBLE_ANALYSES["approx"] is approx_update
+    # Other flavours are unaffected.
+    assert EnKF.COMPATIBLE_ANALYSES["subspace"] is subspace_update
+
+    assert ES.COMPATIBLE_ANALYSES is EnKF.COMPATIBLE_ANALYSES
+
+
+def test_esmda_and_enrml_do_not_fold_full_into_approx():
+    """The fold is specific to EnKF/ES; the iterative schemes keep `full` as is."""
+    from pipt.update_schemes.analysis.approx import approx_update
+    from pipt.update_schemes.analysis.full import full_update
+    from pipt.update_schemes.enrml import GNEnRML, LMEnRML
+    from pipt.update_schemes.esmda import ESMDA
+
+    for algorithm in (ESMDA, LMEnRML, GNEnRML):
+        assert algorithm.COMPATIBLE_ANALYSES["full"] is full_update
+        assert algorithm.COMPATIBLE_ANALYSES["full"] is not approx_update
+
+
+def test_geo_is_gone_and_hybrid_stays_a_separate_class():
+    """`geo` was dead code (a broken, untested `__init__`) and has been removed.
+
+    `hybrid` is a distinct algorithm sharing the ESMDA name, not an analysis,
+    so it remains its own class reachable through the registry rather than
+    through `ESMDA(analysis=...)`.
+    """
+    from pipt.update_schemes.analysis.registry import available_analyses
+
+    assert "geo" not in available_analyses()
+    assert "hybrid" not in available_analyses()
+    with pytest.raises(KeyError):
+        registry.get_scheme("esmda", "geo")
+    assert registry.get_scheme("esmda", "hybrid") is not None
+
+
+def test_default_analysis_is_approx(monkeypatch):
+    class Spy:
+        def __init__(self, da, en, sim):
+            pass
+
+    monkeypatch.setitem(registry.SPECIAL_SCHEMES, ("esmda", "approx"), Spy)
+    assert isinstance(pipt.build_scheme("esmda", {}, {}, None), Spy)
+
+
+def test_bad_flavour_reports_valid_ones():
+    with pytest.raises(KeyError, match="no 'nope' analysis flavour"):
+        pipt.build_scheme("esmda", {}, {}, None, analysis="nope")
+
+
+def test_per_flavour_class_names_no_longer_exist():
+    """The eighteen deprecated names (`esmda_approx`, `lmenrml_full`, ...) were
+    a documented backward-compatibility promise; it has been deliberately
+    retracted in favour of `ESMDA(..., analysis=...)` and friends."""
+    import pipt.update_schemes as us
+
+    for name in (
+        "esmda_approx", "esmda_full", "esmda_subspace", "esmda_geo",
+        "es_approx", "es_full", "es_subspace",
+        "enkf_approx", "enkf_full", "enkf_subspace",
+        "lmenrml_approx", "lmenrml_full", "lmenrml_subspace",
+        "gnenrml_approx", "gnenrml_full", "gnenrml_subspace",
+    ):
+        assert not hasattr(us, name), f"{name} should have been removed"
+
+
+def test_factory_honours_config_analysis():
+    """The factory must not silently disagree with init_da.
+
+    `analysis` used to default to "approx" in the factory while init_da read it
+    from the config, so a config asking for "subspace" built esmda_approx
+    through one entry point and esmda_subspace through the other.
+    """
+    import inspect
+
+    from pipt import ESMDA, build_scheme
+
+    # The defaults are what caused the disagreement: "approx" here vs the
+    # config's value in init_da.
+    assert inspect.signature(ESMDA).parameters["analysis"].default is None
+    assert inspect.signature(build_scheme).parameters["analysis"].default is None
+
+
+def test_factory_resolves_each_flavour_from_config():
+    from pipt.update_schemes.registry import get_scheme
+
+    for flavour in ("approx", "full", "subspace"):
+        cfg_da = {"scheme": "esmda", "analysis": flavour}
+        assert get_scheme(cfg_da["scheme"], cfg_da["analysis"]) is get_scheme(
+            "esmda", flavour
+        )
+
+
+def test_config_analysis_beats_the_fallback(monkeypatch):
+    """A config asking for a flavour must not be overridden by the default."""
+    class Spy:
+        def __init__(self, da, en, sim):
+            pass
+
+    monkeypatch.setitem(registry.SPECIAL_SCHEMES, ("esmda", "subspace"), Spy)
+    cfg = {"scheme": "esmda", "analysis": "subspace"}
+    assert isinstance(pipt.build_scheme("esmda", cfg, {}, None), Spy)
+
+
+def test_explicit_analysis_beats_the_config(monkeypatch):
+    class Spy:
+        def __init__(self, da, en, sim):
+            pass
+
+    monkeypatch.setitem(registry.SPECIAL_SCHEMES, ("esmda", "full"), Spy)
+    cfg = {"scheme": "esmda", "analysis": "subspace"}
+    assert isinstance(pipt.build_scheme("esmda", cfg, {}, None, analysis="full"), Spy)
+
+
+def test_class_resolves_flavour_by_the_same_precedence():
+    """The classes apply explicit -> config -> approx, as build_scheme does."""
+    from pipt.update_schemes.esmda import ESMDA
+
+    resolve = ESMDA.resolve_analysis
+    assert resolve(ESMDA, "full", {"analysis": "subspace"}) == "full"
+    assert resolve(ESMDA, None, {"analysis": "subspace"}) == "subspace"
+    assert resolve(ESMDA, None, {}) == "approx"
diff --git a/tests/assimilation/test_scheme_registry.py b/tests/assimilation/test_scheme_registry.py
new file mode 100644
index 00000000..dd0719fe
--- /dev/null
+++ b/tests/assimilation/test_scheme_registry.py
@@ -0,0 +1,186 @@
+"""Tests for the explicit scheme registry and init_da dispatch."""
+
+import pytest
+
+from pipt import pipt_init
+from pipt.update_schemes import registry
+
+
+# ----------------------------------------------------------------------
+# Registry
+# ----------------------------------------------------------------------
+
+def test_algorithms_cover_the_public_classes_and_the_historical_names():
+    from pipt.update_schemes.enkf import EnKF
+    from pipt.update_schemes.enrml import GNEnRML, LMEnRML, co_lm_enrml, gn_enrml
+    from pipt.update_schemes.es import ES
+    from pipt.update_schemes.esmda import ESMDA
+
+    assert set(registry.ALGORITHMS.values()) == {
+        EnKF, ES, ESMDA, LMEnRML, GNEnRML, co_lm_enrml, gn_enrml,
+    }
+
+
+def test_hybrid_is_a_special_scheme_not_a_registered_flavour():
+    """``hybrid`` is not a globally registered analysis flavour.
+
+    ``esmda_hybrid`` is a real, distinct implementation (multilevel ES-MDA)
+    that happens to share the ``esmda`` name, not an alias -- so it resolves
+    only through ``SPECIAL_SCHEMES``, never through ``ALGORITHMS`` + a bound
+    strategy.
+    """
+    from pipt.update_schemes.analysis.registry import available_analyses
+
+    assert "hybrid" not in available_analyses()
+    assert ("esmda", "hybrid") in registry.SPECIAL_SCHEMES
+
+
+def test_margis_is_a_gnenrml_specific_flavour_not_a_special_scheme():
+    """``margis`` binds normally on ``GNEnRML``, unlike ``hybrid``.
+
+    It is not a *globally* registered flavour (only ``GNEnRML`` offers it,
+    not every algorithm), but it is an ordinary ``COMPATIBLE_ANALYSES`` entry
+    on that one class -- resolved through ``ALGORITHMS`` + a bound analysis,
+    not through ``SPECIAL_SCHEMES`` the way ``hybrid`` is.
+    """
+    from pipt.update_schemes.analysis.registry import available_analyses
+    from pipt.update_schemes.analysis.margis import margIS_update
+    from pipt.update_schemes.enrml import GNEnRML
+
+    assert "margis" not in available_analyses()
+    assert ("gnenrml", "margis") not in registry.SPECIAL_SCHEMES
+    assert GNEnRML.COMPATIBLE_ANALYSES["margis"] is margIS_update
+    ctor = registry.get_scheme("gnenrml", "margis")
+    assert ctor.func is GNEnRML
+    assert ctor.keywords == {"analysis": "margis"}
+
+
+@pytest.mark.parametrize(
+    "name, parent_name, flavour, other",
+    [("co_lm_enrml", "lmenrml", "approx", "full"),
+     ("gn_enrml", "gnenrml", "subspace", "approx")],
+)
+def test_historical_names_pin_one_flavour_of_a_live_algorithm(name, parent_name, flavour, other):
+    """``co_lm_enrml`` and ``gn_enrml`` resolve like any scheme, to a subclass
+    of the algorithm they always were, and offer exactly the flavour the
+    name meant -- so a config asking for another flavour gets the usual
+    "no such flavour" error rather than silently running something else."""
+    cls = registry.ALGORITHMS[name]
+    assert issubclass(cls, registry.ALGORITHMS[parent_name])
+    assert cls.COMPATIBLE_ANALYSES == {flavour: registry.ALGORITHMS[parent_name].COMPATIBLE_ANALYSES[flavour]}
+    assert (name, flavour) in registry.available_schemes()
+    assert registry.get_scheme(name, flavour).func is cls
+    with pytest.raises(KeyError, match=f"no '{other}' analysis flavour"):
+        registry.get_scheme(name, other)
+
+
+def test_get_scheme_binds_the_algorithm_and_flavour():
+    from pipt.update_schemes.esmda import ESMDA
+
+    ctor = registry.get_scheme("esmda", "approx")
+    assert ctor.func is ESMDA
+    assert ctor.keywords == {"analysis": "approx"}
+
+
+def test_get_scheme_is_case_insensitive():
+    from pipt.update_schemes.esmda import ESMDA
+
+    assert registry.get_scheme("ESMDA", "Approx").func is ESMDA
+
+
+def test_get_scheme_resolves_special_schemes_directly():
+    from pipt.update_schemes.multilevel import esmda_hybrid
+
+    assert registry.get_scheme("esmda", "hybrid") is esmda_hybrid
+
+
+def test_available_schemes_is_sorted_and_covers_specials():
+    combos = registry.available_schemes()
+    assert combos == sorted(combos)
+    assert ("esmda", "hybrid") in combos
+    assert ("gnenrml", "margis") in combos
+    assert ("esmda", "geo") not in combos, "esmda_geo was dead code and has been removed"
+
+
+#: Flavour/algorithm pairs deliberately absent, and why. `subspace2` solves for an
+#: ne x ne transform, which the sequential schemes cannot apply one datum at a time;
+#: `subspace` is registered on them and already fails on the characterisation case
+#: (see the note on CASES in test_numerical_characterisation), so advertising a second
+#: weight-space flavour there would only widen a known fault.
+DELIBERATELY_UNREGISTERED = {("enkf", "subspace2"), ("es", "subspace2")}
+
+
+def test_every_algorithm_gets_every_registered_flavour():
+    from pipt.update_schemes.analysis.registry import available_analyses
+
+    combos = set(registry.available_schemes())
+    for algo in registry.ALGORITHMS:
+        if algo in ("co_lm_enrml", "gn_enrml"):
+            continue  # historical names pin one flavour by design
+        for flavour in available_analyses():
+            if (algo, flavour) in DELIBERATELY_UNREGISTERED:
+                assert (algo, flavour) not in combos, "remove it from the exception set"
+                continue
+            assert (algo, flavour) in combos
+
+
+def test_unknown_scheme_error_lists_alternatives():
+    with pytest.raises(KeyError, match="Unknown assimilation scheme") as err:
+        registry.get_scheme("esmdaa", "approx")
+    assert "esmda" in str(err.value)
+
+
+def test_unknown_flavour_error_is_distinct_and_lists_flavours():
+    with pytest.raises(KeyError, match="no 'banana' analysis flavour") as err:
+        registry.get_scheme("esmda", "banana")
+    message = str(err.value)
+    assert "hybrid" in message and "approx" in message
+
+
+def test_register_scheme_roundtrip():
+    class Dummy:
+        pass
+
+    registry.register_scheme("dummy", "approx", Dummy)
+    try:
+        assert registry.get_scheme("dummy", "approx") is Dummy
+        with pytest.raises(ValueError, match="already registered"):
+            registry.register_scheme("dummy", "approx", Dummy)
+        registry.register_scheme("dummy", "approx", Dummy, overwrite=True)
+    finally:
+        registry.SPECIAL_SCHEMES.pop(("dummy", "approx"), None)
+
+
+def test_register_scheme_rejects_clashing_with_a_generic_combo():
+    """A generic algorithm+flavour combo counts as "already registered" too."""
+    class Dummy:
+        pass
+
+    with pytest.raises(ValueError, match="already registered"):
+        registry.register_scheme("esmda", "approx", Dummy)
+
+
+# ----------------------------------------------------------------------
+# init_da validation
+# ----------------------------------------------------------------------
+
+def test_init_da_missing_scheme():
+    with pytest.raises(ValueError, match="SCHEME is missing"):
+        pipt_init.init_da({}, {}, None)
+
+
+def test_init_da_legacy_daalg_points_at_migrate():
+    """Clean break: the old key is rejected, but with a pointer to the tool."""
+    with pytest.raises(ValueError, match="pet migrate"):
+        pipt_init.init_da({"daalg": ["esmda", "esmda"], "analysis": "approx"}, {}, None)
+
+
+def test_init_da_missing_analysis():
+    with pytest.raises(ValueError, match="ANALYSIS is missing"):
+        pipt_init.init_da({"scheme": "esmda"}, {}, None)
+
+
+def test_init_da_unknown_scheme_reports_clearly():
+    """The old importlib path raised a bare ModuleNotFoundError here."""
+    with pytest.raises(KeyError, match="Unknown assimilation scheme"):
+        pipt_init.init_da({"scheme": "nope", "analysis": "approx"}, {}, None)
diff --git a/tests/assimilation/test_screendata_is_refused.py b/tests/assimilation/test_screendata_is_refused.py
new file mode 100644
index 00000000..d3300ed7
--- /dev/null
+++ b/tests/assimilation/test_screendata_is_refused.py
@@ -0,0 +1,13 @@
+"""Asking for data screening fails with an explanation, not an AttributeError."""
+
+import pytest
+
+from pipt.ensembles.ensemble_base import AssimilationEnsemble
+
+
+def test_screendata_raises_a_clear_error():
+    ens = object.__new__(AssimilationEnsemble)   # perturb_observations reads only keys_da first
+    ens.keys_da = {"screendata": True}
+
+    with pytest.raises(ValueError, match="'screendata' is not supported"):
+        ens.perturb_observations(None)
diff --git a/tests/assimilation/test_seed_option.py b/tests/assimilation/test_seed_option.py
new file mode 100644
index 00000000..c0c5eb74
--- /dev/null
+++ b/tests/assimilation/test_seed_option.py
@@ -0,0 +1,64 @@
+"""A run with a `seed` in its ensemble config is reproducible on its own.
+
+Every draw -- prior realisations, perturbed observations, outlier and crash
+replacement -- comes from the ensemble's private stream, so the result does
+not depend on NumPy's global state and does not disturb it either.
+"""
+
+import numpy as np
+import pytest
+
+from input_output import read_config
+from pipt import ESMDA
+from simulator.vanderpol import VanDerPolOscillator
+from test_numerical_characterisation import _write_config, _write_synthetic_case
+
+NE = 40
+
+
+def _run(tmp_path, monkeypatch, name, global_seed, seed=None):
+    tmp_path.mkdir(parents=True, exist_ok=True)
+    monkeypatch.chdir(tmp_path)
+    report_points = _write_synthetic_case(ne=NE)
+    cfg_da, cfg_sim, cfg_ens = read_config.read(_write_config(name, "esmda", "approx", report_points, ne=NE))
+    if seed is not None:
+        cfg_ens["seed"] = seed
+    np.random.seed(global_seed)
+    result = ESMDA.assimilate(cfg_da, cfg_ens, VanDerPolOscillator(cfg_sim), analysis="approx")
+    return np.asarray(result.x, dtype=float)
+
+
+def test_a_seeded_run_reproduces_regardless_of_the_global_state(tmp_path, monkeypatch):
+    first = _run(tmp_path / "a", monkeypatch, "seeded_a", global_seed=1, seed=7)
+    second = _run(tmp_path / "b", monkeypatch, "seeded_b", global_seed=2, seed=7)
+    np.testing.assert_array_equal(first, second)
+
+
+def test_a_seeded_run_leaves_the_global_stream_untouched(tmp_path, monkeypatch):
+    np.random.seed(3)
+    before = np.random.get_state()
+    _run(tmp_path, monkeypatch, "seeded_c", global_seed=3, seed=7)
+    after = np.random.get_state()
+    np.testing.assert_array_equal(before[1], after[1])
+    assert before[2] == after[2]
+
+
+def test_without_a_seed_the_global_state_still_governs_the_run(tmp_path, monkeypatch):
+    # Unchanged behaviour: np.random.seed(...) before the run is what reproduces it.
+    first = _run(tmp_path / "a", monkeypatch, "unseeded_a", global_seed=1)
+    second = _run(tmp_path / "b", monkeypatch, "unseeded_b", global_seed=1)
+    third = _run(tmp_path / "c", monkeypatch, "unseeded_c", global_seed=2)
+    np.testing.assert_array_equal(first, second)
+    assert not np.array_equal(first, third)
+
+
+@pytest.mark.parametrize("seed", [7, "7"])
+def test_the_seed_is_read_from_the_ensemble_config(tmp_path, monkeypatch, seed):
+    from pipt.ensembles import AssimilationEnsemble
+
+    monkeypatch.chdir(tmp_path)
+    report_points = _write_synthetic_case(ne=NE)
+    cfg_da, cfg_sim, cfg_ens = read_config.read(_write_config("seed_type", "esmda", "approx", report_points, ne=NE))
+    cfg_ens["seed"] = seed
+    ensemble = AssimilationEnsemble(cfg_da, cfg_ens, VanDerPolOscillator(cfg_sim))
+    assert isinstance(ensemble.rng, np.random.RandomState)
diff --git a/tests/assimilation/test_state_scaling_equivariance.py b/tests/assimilation/test_state_scaling_equivariance.py
new file mode 100644
index 00000000..aee435bd
--- /dev/null
+++ b/tests/assimilation/test_state_scaling_equivariance.py
@@ -0,0 +1,66 @@
+"""Rescaling a state variable must rescale its update, and nothing else.
+
+Both analyses work in a scaled state space: anomalies are divided by the prior
+standard deviation (``state_scaling``) and the step is multiplied back. If any
+term forgets one half of that, changing the units of a variable changes the
+update of the others, or its own update by the wrong factor. Multiplying one
+variable's ensemble, prior and standard deviation by ``c`` must therefore
+multiply that variable's rows of the step by ``c`` and leave the other rows
+untouched.
+"""
+
+import numpy as np
+import pytest
+
+from pipt.update_schemes.analysis.approx import approx_update
+from pipt.update_schemes.analysis.full import full_update
+
+
+class NoLocalization:
+    name = None
+
+
+class Scheme:
+    """Plain attributes: the context approx_update and full_update read."""
+
+    def __init__(self, enX_prior, state_scaling, cov, ne, seed=3):
+        self.lam = 0.5
+        self.trunc_energy = 0.99
+        self.keys_da = {"emp_cov": False}
+        self.localization = NoLocalization()
+        self.proj = (np.eye(ne) - np.ones((ne, ne)) / ne) / np.sqrt(ne - 1)
+        self.prior_enX = enX_prior
+        self.state_scaling = state_scaling
+        self.cov_data = cov
+        self.scale_data = np.sqrt(cov)
+        self.Am = None
+
+
+def _case(seed=0, nx=6, nd=20, ne=10):
+    rng = np.random.default_rng(seed)
+    prior = rng.standard_normal((nx, ne)) * np.array([1, 1, 1, 5, 5, 5])[:, None]
+    enX = prior + 0.3 * rng.standard_normal((nx, ne))
+    enY = rng.standard_normal((nd, ne)) * 2 + 1
+    enE = enY.mean(1)[:, None] + rng.normal(0, 0.4, size=enY.shape)
+    std = np.array([1.0, 1.0, 1.0, 5.0, 5.0, 5.0])
+    cov = 0.1 + rng.random(nd)
+    return prior, enX, enY, enE, std, cov
+
+
+@pytest.mark.parametrize("analysis", [approx_update, full_update], ids=["approx", "full"])
+def test_rescaling_one_variable_rescales_only_its_rows_of_the_step(analysis):
+    prior, enX, enY, enE, std, cov = _case()
+    ne = enX.shape[1]
+    rows = slice(3, 6)      # the variable whose units we change
+    c = 100.0
+
+    step = analysis(Scheme(prior, std, cov, ne)).update(enX, enY, enE, prior=prior).step
+
+    prior_c, enX_c, std_c = prior.copy(), enX.copy(), std.copy()
+    prior_c[rows] *= c
+    enX_c[rows] *= c
+    std_c[rows] *= c
+    step_c = analysis(Scheme(prior_c, std_c, cov, ne)).update(enX_c, enY, enE, prior=prior_c).step
+
+    np.testing.assert_allclose(step_c[rows], c * step[rows], rtol=1e-9)
+    np.testing.assert_allclose(step_c[:3], step[:3], rtol=1e-9)
diff --git a/tests/assimilation/test_step_and_score.py b/tests/assimilation/test_step_and_score.py
new file mode 100644
index 00000000..cc275f36
--- /dev/null
+++ b/tests/assimilation/test_step_and_score.py
@@ -0,0 +1,377 @@
+"""The scoring contract and the schemes' inner damping loops.
+
+Two structural properties are covered here, both of which the numerical
+characterisation tests would only catch indirectly:
+
+- ``score()`` is the single definition of a scheme's data misfit, used for the
+  prior and for every attempt inside a step. It replaced a per-scheme
+  ``score_prior()`` hook that duplicated both the expression and the
+  bookkeeping around it.
+- The damping parameter is iterated *inside* ``update_step()``. One call is one
+  iteration however many attempts it takes, mirroring popt's optimizers.
+"""
+
+from types import SimpleNamespace
+
+import numpy as np
+import pytest
+
+from misc.structures import PETDataFrame
+from pipt import ESMDA, EnKF, GNEnRML, LMEnRML
+from pipt.update_schemes.core import AssimilationScheme, StepReport
+
+
+class FakeLogger:
+    """Callable logger with the ``.info`` the schemes also use."""
+
+    def __init__(self):
+        self.rows = []
+
+    def __call__(self, *args, **kwargs):
+        self.rows.append(kwargs or args)
+
+    def info(self, *args, **kwargs):
+        self.rows.append(args)
+
+
+class FakeEnsemble:
+    """Minimal ensemble collaborator, as in test_scheme_base."""
+
+    def __init__(self, nx=3, ne=4):
+        self.enX = np.zeros((nx, ne))
+        self.pred_data = None
+        self.logger = None
+        self.forecast_calls = 0
+        self.keys_da = {}
+        self.sim = SimpleNamespace(input_dict={})
+        self._saving_enabled = False
+
+    def forecast(self, enX):
+        self.forecast_calls += 1
+        self.pred_data = np.ones((5, self.enX.shape[1]))
+
+
+class ScoringScheme(AssimilationScheme):
+    """Scheme with observations bound, so the base ``score()`` applies."""
+
+    def __init__(self, ensemble, **options):
+        super().__init__(ensemble, **options)
+        self.enObs = np.zeros((5, ensemble.enX.shape[1]))
+        self.cov_data = np.ones(5)
+
+    def update_step(self):
+        misfit = np.asarray(self.score(), dtype=float)
+        self.prev_data_misfit_mean = self.data_misfit_mean
+        return StepReport(accepted=True, state=self.ensemble.enX, misfit=misfit)
+
+
+# ----------------------------------------------------------------------
+# score()
+# ----------------------------------------------------------------------
+
+class TestScore:
+
+    def test_default_is_the_data_misfit(self, tmp_path, monkeypatch):
+        monkeypatch.chdir(tmp_path)
+        scheme = ScoringScheme(FakeEnsemble())
+        scheme.ensemble.forecast(scheme.ensemble.enX)
+
+        # (1 - 0)^2 summed over 5 observations, per realisation.
+        assert np.allclose(scheme.score(), 5.0)
+
+    def test_scores_an_explicit_forecast(self, tmp_path, monkeypatch):
+        monkeypatch.chdir(tmp_path)
+        scheme = ScoringScheme(FakeEnsemble())
+
+        assert np.allclose(scheme.score(np.full((5, 4), 2.0)), 20.0)
+
+    def test_accepts_a_petdataframe(self, tmp_path, monkeypatch):
+        """The ensemble hands over frames, not matrices."""
+        monkeypatch.chdir(tmp_path)
+        scheme = ScoringScheme(FakeEnsemble())
+        frame = PETDataFrame(
+            {"d": [np.full(4, 2.0) for _ in range(5)]}, index=range(5), is_ensemble=True
+        )
+
+        assert np.allclose(scheme.score(frame), 20.0)
+
+    def test_returns_none_without_observations(self, tmp_path, monkeypatch):
+        """A scheme that scores some other way opts out by having no enObs."""
+        monkeypatch.chdir(tmp_path)
+        scheme = ScoringScheme(FakeEnsemble())
+        del scheme.enObs
+
+        assert scheme.score() is None
+
+
+class TestRecordPriorScore:
+
+    def test_records_the_prior_from_score(self, tmp_path, monkeypatch):
+        monkeypatch.chdir(tmp_path)
+        scheme = ScoringScheme(FakeEnsemble())
+        scheme.ensemble.forecast(scheme.ensemble.enX)
+
+        scheme.record_prior_score()
+
+        assert scheme.prior_data_misfit_mean == pytest.approx(5.0)
+        assert scheme.data_misfit_mean == pytest.approx(5.0)
+        assert scheme.data_misfit_std == pytest.approx(0.0)
+        assert np.allclose(scheme.ensemble_misfit, 5.0)
+
+    def test_prior_is_scored_before_the_first_step(self, tmp_path, monkeypatch):
+        """The whole point of scoring the prior early: it is the *prior's*."""
+        monkeypatch.chdir(tmp_path)
+        scheme = ScoringScheme(FakeEnsemble(), maxiter=2)
+
+        result = scheme.run_assimilation()
+
+        assert result.prior_data_misfit == pytest.approx(5.0)
+
+    def test_a_scheme_without_a_misfit_is_left_alone(self, tmp_path, monkeypatch):
+        """score() returning None must not clobber the loop's bookkeeping."""
+        monkeypatch.chdir(tmp_path)
+        scheme = ScoringScheme(FakeEnsemble())
+        del scheme.enObs
+
+        scheme.record_prior_score()
+
+        assert scheme.prior_data_misfit_mean is None
+        assert scheme.data_misfit_mean is None
+
+
+class TestSchemeOverrides:
+    """ES-MDA scores its own way; the EnKF family scores the base's way."""
+
+    @staticmethod
+    def _bare(cls, **attrs):
+        scheme = object.__new__(cls)
+        for name, value in attrs.items():
+            setattr(scheme, name, value)
+        return scheme
+
+    def test_esmda_scores_against_uninflated_observations(self):
+        """`enObs` is redrawn inflated each step; `enObs_conv` is not."""
+        scheme = self._bare(
+            ESMDA,
+            enObs=np.full((5, 4), 99.0),          # inflated: must not be used
+            enObs_conv=np.zeros((5, 4)),
+            ensemble=SimpleNamespace(pred_data=np.ones((5, 4))),
+        )
+        scheme.cov_data = np.ones(5)
+
+        assert np.allclose(scheme.score(), 5.0)
+
+    def test_enkf_scores_with_the_data_covariance(self):
+        """It used to pass ``scale_data`` -- a square root -- where the
+        objective expects a variance, so the misfit came out as r**2/sigma
+        instead of r**2/sigma**2."""
+        scheme = self._bare(
+            EnKF,
+            enObs=np.zeros((5, 4)),
+            ensemble=SimpleNamespace(pred_data=np.ones((5, 4))),
+        )
+        scheme.scale_data = np.full(5, 99.0)     # must not be used
+        scheme.cov_data = np.full(5, 4.0)        # variance: 5 data x 1 / 4
+
+        assert np.allclose(scheme.score(), 5 * (1 / 4.0))
+
+
+# ----------------------------------------------------------------------
+# The damping loop inside update_step()
+# ----------------------------------------------------------------------
+
+class StubbedStep:
+    """Drives a real ``update_step`` with a scripted sequence of misfits.
+
+    Everything the step needs is set directly: the analysis, the forecast and
+    the score are stubbed, so what is exercised is the loop the scheme wraps
+    around them and nothing else.
+    """
+
+    def __init__(self, cls, misfits, **overrides):
+        self.scheme = object.__new__(cls)
+        self.misfits = list(misfits)
+        self.analyses = []          # lambda/gamma at each analysis
+        self.forecasts = 0
+
+        scheme = self.scheme
+        scheme.logger = FakeLogger()
+        scheme.iteration = 0
+        scheme.why_stop = {}
+        scheme.conv_msg = ""
+        scheme._converged = False
+        scheme.step_accepted = True
+        scheme.max_inner_iter = 10
+        scheme.data_misfit_tol = 1e-6
+        scheme.data_misfit_mean = 100.0
+        scheme.data_misfit_std = 10.0
+        scheme.prev_data_misfit_mean = 100.0
+        scheme.prev_data_misfit_std = 10.0
+        scheme.ensemble_misfit = np.full(4, 100.0)
+        scheme.prior_data_misfit_mean = 100.0
+        scheme.enX_proposal = np.zeros((3, 4))
+        for name, value in overrides.items():
+            setattr(scheme, name, value)
+
+        scheme.calc_analysis = self._calc_analysis
+        scheme.after_analysis = lambda: None
+        scheme.run_forecast = self._run_forecast
+        scheme.score = self._score
+
+    @property
+    def control(self):
+        """The damping parameter under test, whichever this scheme uses."""
+        return getattr(self.scheme, "lam", None) or self.scheme.gamma
+
+    def _calc_analysis(self):
+        self.analyses.append(self.control)
+
+    def _run_forecast(self, state):
+        self.forecasts += 1
+        return state
+
+    def _score(self, pred_data=None):
+        mean, std = self.misfits.pop(0)
+        return np.array([mean - std, mean, mean, mean + std], dtype=float)
+
+
+def lm(misfits, **overrides):
+    defaults = dict(lam=100.0, lam_max=1e10, lam_min=0.01, lam_factor=5.0)
+    return StubbedStep(LMEnRML, misfits, **(defaults | overrides))
+
+
+def gn(misfits, **overrides):
+    defaults = dict(gamma=0.4, gamma_max=0.5, gamma_factor=2.0, lam=0.0)
+    return StubbedStep(GNEnRML, misfits, **(defaults | overrides))
+
+
+class TestInnerDampingLoop:
+
+    def test_one_call_retries_until_it_improves(self):
+        """A worse misfit re-damps and tries again inside the same call."""
+        run = lm([(120.0, 12.0), (50.0, 5.0)])
+
+        report = run.scheme.update_step()
+
+        assert run.forecasts == 2                  # two attempts, one step
+        assert run.analyses == [100.0, 500.0]      # λ grew before the retry
+        assert report.accepted is True
+        assert np.mean(report.misfit) == pytest.approx(50.0)
+
+    def test_the_retry_starts_from_the_same_state(self):
+        """Nothing is committed between attempts, so each re-solves the prior."""
+        run = lm([(120.0, 12.0), (50.0, 5.0)])
+
+        run.scheme.update_step()
+
+        # prev_ is the last *accepted* misfit throughout, not the rejection's.
+        assert run.scheme.prev_data_misfit_mean == pytest.approx(100.0)
+
+    def test_accepting_first_time_takes_one_attempt(self):
+        run = lm([(50.0, 5.0)])
+
+        run.scheme.update_step()
+
+        assert run.forecasts == 1
+        assert run.analyses == [100.0]
+
+    def test_a_converged_verdict_ends_the_loop(self):
+        """λ_max is a stop, not another retry -- the loop must not spin on it."""
+        run = lm([(120.0, 12.0)], lam=1e10, lam_max=1e10)
+
+        report = run.scheme.update_step()
+
+        assert run.forecasts == 1
+        assert run.scheme._converged is True
+        assert report.accepted is False
+
+    def test_exhausting_the_attempts_stops_the_run(self):
+        run = lm([(120.0, 12.0)] * 5, max_inner_iter=3)
+
+        report = run.scheme.update_step()
+
+        assert run.forecasts == 3
+        assert report.accepted is False
+        assert run.scheme._converged is True
+        assert run.scheme.why_stop["inner_stop"] is True
+        assert "damping attempts" in run.scheme.conv_msg
+
+    def test_the_row_reports_the_damping_the_step_ran_with(self):
+        """The loop logs after score_and_commit has already adjusted λ, so the
+        column would otherwise report the *next* step's damping."""
+        run = lm([(50.0, 5.0)])                     # accepted: λ 100 -> 20
+
+        run.scheme.update_step()
+
+        assert run.scheme.lam == pytest.approx(20.0)
+        assert run.scheme.log_columns()["λ"] == pytest.approx(100.0)
+
+    def test_gauss_newton_shortens_its_step_the_same_way(self):
+        run = gn([(120.0, 12.0), (50.0, 5.0)])
+
+        report = run.scheme.update_step()
+
+        assert run.forecasts == 2
+        assert run.analyses == [0.4, 0.2]          # γ halved before the retry
+        assert report.accepted is True
+
+    def test_gauss_newton_gives_up_after_max_inner_iter(self):
+        """γ has no lower bound, so the attempt count is what stops it."""
+        run = gn([(120.0, 12.0)] * 9, max_inner_iter=4)
+
+        report = run.scheme.update_step()
+
+        assert run.forecasts == 4
+        assert report.accepted is False
+        assert run.scheme.why_stop["inner_stop"] is True
+        assert "step-length attempts" in run.scheme.conv_msg
+
+
+class TestAutoLambda:
+    """``lambda='auto'`` is sized by LM-EnRML's own ``score()`` override."""
+
+    @staticmethod
+    def _bare_lm(**attrs):
+        scheme = object.__new__(LMEnRML)
+        scheme.lam = "auto"
+        scheme.enObs = np.zeros((10, 4))
+        scheme.logger = FakeLogger()
+        scheme.iteration = 0
+        # 10 observations off by sqrt(5) each: a misfit of 50 per realisation.
+        scheme.ensemble = SimpleNamespace(pred_data=np.full((10, 4), np.sqrt(5.0)))
+        for name, value in attrs.items():
+            setattr(scheme, name, value)
+        scheme.cov_data = np.ones(10)
+        return scheme
+
+    def test_sized_from_the_first_score(self):
+        scheme = self._bare_lm()
+
+        misfit = scheme.score()
+
+        assert np.allclose(misfit, 50.0)
+        assert scheme.lam == pytest.approx(0.5 * 50.0 / 10)   # Φ / 2·nd
+
+    def test_resolved_before_the_prior_row_is_logged(self):
+        """The prior QA/QC pass computes with λ, so it cannot still be a str.
+
+        The row logged for the prior reports it too, and both happen before
+        the first update_step.
+        """
+        scheme = self._bare_lm()
+
+        scheme.record_prior_score()
+
+        assert scheme.lam == pytest.approx(2.5)
+        logged = [row for row in scheme.logger.rows if isinstance(row, dict)]
+        assert logged and logged[-1]["λ"] == pytest.approx(2.5)
+
+    def test_resolved_once_and_left_alone(self):
+        """Later scores must not re-size a λ the scheme has been adjusting."""
+        scheme = self._bare_lm()
+        scheme.score()
+        scheme.lam = 0.4          # as an accepted step would have reduced it
+
+        scheme.score()
+
+        assert scheme.lam == pytest.approx(0.4)
diff --git a/tests/assimilation/test_subspace2.py b/tests/assimilation/test_subspace2.py
new file mode 100644
index 00000000..4ffb32ee
--- /dev/null
+++ b/tests/assimilation/test_subspace2.py
@@ -0,0 +1,158 @@
+"""The ensemble-transform IES flavour, and what pins it.
+
+`subspace2` has no reference output to check against, so the anchor is an identity:
+it is exactly `margis` with the marginalised error scale `Ratio` fixed at 1, i.e.
+with the data uncertainty taken as known. That identity is what the method *is*, so
+a test of it documents the method as well as checking it.
+"""
+
+from types import SimpleNamespace
+
+import numpy as np
+import pytest
+
+from pipt.update_schemes.analysis import ANALYSES, available_analyses
+from pipt.update_schemes.analysis.margis import margIS_update
+from pipt.update_schemes.analysis.subspace2 import subspace2_update
+from pipt.update_schemes.enkf import EnKF
+from pipt.update_schemes.enrml import GNEnRML, LMEnRML
+from pipt.update_schemes.es import ES
+from pipt.update_schemes.esmda import ESMDA
+
+ND, NE = 12, 8
+
+
+def _scheme(scale_data, *, iteration=0, lam=0.0, current_W=None):
+    proj = (np.eye(NE) - np.ones((NE, NE)) / NE) / np.sqrt(NE - 1)
+    layout = SimpleNamespace(row_datatypes=lambda: np.array(["d"] * ND, dtype=object))
+    scheme = SimpleNamespace(
+        ne=NE, iteration=iteration, lam=lam, proj=proj,
+        scale_data=scale_data, data_layout=layout,
+    )
+    if current_W is not None:
+        scheme.current_W = current_W
+    return scheme
+
+
+def _inputs(seed=0):
+    rng = np.random.default_rng(seed)
+    return rng.normal(size=(ND, NE)), rng.normal(size=(ND, NE))
+
+
+# --------------------------------------------------------------------------
+# The identity that defines the method
+# --------------------------------------------------------------------------
+
+class _margis_ratio_one(margIS_update):
+    """margis with the inverse-chi2 belief on the error scale switched off."""
+
+    def update(self, enX, enY, enE, **kwargs):
+        scheme = self.scheme
+        ne = scheme.ne
+        if scheme.iteration == 0:
+            scheme.current_W = np.eye(ne)
+            scheme.D = self.solve(scheme.scale_data, enE)
+
+        sY = self.solve(scheme.scale_data, enY)
+        Y = np.linalg.solve(scheme.current_W.T, sY.T).T
+        Y = Y @ scheme.proj * np.sqrt(ne - 1)
+
+        delta = scheme.D - sY
+        ratio = 1.0                                     # <- the whole difference
+        deltaD = (Y * ratio).T @ delta
+        S = (Y * ratio).T @ Y + np.eye(ne) * (ne - 1)
+        deltaM = (ne - 1) * (np.eye(ne) - scheme.current_W)
+
+        from pipt.update_schemes.analysis.base import AnalysisResult
+        return AnalysisResult(W_step=np.linalg.solve(S, deltaM + deltaD) / (1 + scheme.lam))
+
+
+@pytest.mark.parametrize("scale_data", [
+    np.linspace(0.5, 2.0, ND),                                   # diagonal
+    np.diag(np.linspace(0.5, 2.0, ND)),                          # full matrix
+])
+@pytest.mark.parametrize("lam", [0.0, 3.0])
+def test_subspace2_is_margis_with_the_error_scale_known(scale_data, lam):
+    enY, enE = _inputs()
+
+    a = subspace2_update(_scheme(scale_data, lam=lam)).update(None, enY, enE)
+    b = _margis_ratio_one(_scheme(scale_data, lam=lam)).update(None, enY, enE)
+
+    np.testing.assert_array_equal(a.W_step, b.W_step)
+
+
+def test_the_identity_holds_away_from_the_first_iteration():
+    """W = I only at the start; the transform enters through `solve(W.T, sY.T)`."""
+    enY, enE = _inputs(seed=1)
+    scale_data = np.linspace(0.5, 2.0, ND)
+    W = np.eye(NE) + 0.1 * np.random.default_rng(2).normal(size=(NE, NE))
+
+    scheme_a = _scheme(scale_data, iteration=1, current_W=W.copy())
+    scheme_a.D = subspace2_update(scheme_a).solve(scale_data, enE)
+    scheme_b = _scheme(scale_data, iteration=1, current_W=W.copy())
+    scheme_b.D = scheme_a.D
+
+    a = subspace2_update(scheme_a).update(None, enY, enE)
+    b = _margis_ratio_one(scheme_b).update(None, enY, enE)
+
+    np.testing.assert_array_equal(a.W_step, b.W_step)
+
+
+# --------------------------------------------------------------------------
+# The transform starts at I, and the data uncertainty is divided out
+# --------------------------------------------------------------------------
+
+def test_the_transform_is_initialised_to_the_identity():
+    """`subspace` starts from W = 0 and `subspace2` from W = I; the reconstruction in
+    `propose_state` differs accordingly, so getting this wrong is silent."""
+    scheme = _scheme(np.ones(ND))
+    enY, enE = _inputs()
+
+    subspace2_update(scheme).update(None, enY, enE)
+
+    np.testing.assert_array_equal(scheme.current_W, np.eye(NE))
+
+
+def test_the_observations_are_rewhitened_every_call():
+    """ES-MDA redraws the observations and their scale at every assimilation step, so
+    a D cached on the first call would drive later steps with the first step's
+    observations whitened by the first step's factor."""
+    enY, enE = _inputs()
+    scheme = _scheme(np.ones(ND), iteration=1, current_W=np.eye(NE))
+    scheme.D = np.zeros((ND, NE))                # a stale cache, if one were consulted
+
+    result = subspace2_update(scheme).update(None, enY, enE)
+    expected = subspace2_update(_scheme(np.ones(ND), iteration=1, current_W=np.eye(NE))
+                                ).update(None, enY, enE)
+
+    np.testing.assert_array_equal(result.W_step, expected.W_step)
+
+
+def test_the_data_scale_divides_out():
+    """Scaling the observations and predictions together must not move the step."""
+    enY, enE = _inputs(seed=3)
+    plain  = subspace2_update(_scheme(np.ones(ND))).update(None, enY, enE)
+    scaled = subspace2_update(_scheme(np.full(ND, 7.0))).update(None, 7.0 * enY, 7.0 * enE)
+
+    np.testing.assert_allclose(plain.W_step, scaled.W_step, rtol=1e-10, atol=1e-12)
+
+
+# --------------------------------------------------------------------------
+# Registration
+# --------------------------------------------------------------------------
+
+def test_the_flavour_is_registered():
+    assert "subspace2" in available_analyses()
+    assert ANALYSES["subspace2"] is subspace2_update
+
+
+@pytest.mark.parametrize("scheme", [ESMDA, LMEnRML, GNEnRML])
+def test_the_schemes_that_accept_it(scheme):
+    assert scheme.COMPATIBLE_ANALYSES["subspace2"] is subspace2_update
+
+
+@pytest.mark.parametrize("scheme", [EnKF, ES])
+def test_the_sequential_schemes_do_not(scheme):
+    """Neither took it upstream, and the sequential path already fails for the
+    weight-space flavours -- see the note on CASES in test_numerical_characterisation."""
+    assert "subspace2" not in scheme.COMPATIBLE_ANALYSES
diff --git a/tests/assimilation/test_subspace_scale_invariance.py b/tests/assimilation/test_subspace_scale_invariance.py
new file mode 100644
index 00000000..43ae2e33
--- /dev/null
+++ b/tests/assimilation/test_subspace_scale_invariance.py
@@ -0,0 +1,41 @@
+"""A weight-space update must not depend on the units of the data.
+
+Scaling the predictions, the observations and the data scaling by the same
+factor changes nothing about the problem, so the ensemble weights must come
+out identical. ``subspace_update`` once took the SVD of the *unwhitened*
+anomalies while whitening the residual and the observation perturbations, and
+the weights depended on the units of the data; this pins the fix.
+"""
+
+import numpy as np
+
+from pipt.update_schemes.analysis.subspace import subspace_update
+
+
+class Scheme:
+    """Plain attributes only: exactly the context subspace_update reads."""
+
+    def __init__(self, scale, ne):
+        self.scale_data = scale
+        self.trunc_energy = 0.99
+        self.iteration = 0
+        self.lam = 0
+        self.proj = (np.eye(ne) - np.ones((ne, ne)) / ne) / np.sqrt(ne - 1)
+
+
+def _w_step(pred, obs, scale):
+    scheme = Scheme(scale, pred.shape[1])
+    return subspace_update(scheme).update(np.zeros((3, pred.shape[1])), pred, obs).w_step
+
+
+def test_weights_are_invariant_to_the_units_of_the_data():
+    rng = np.random.default_rng(0)
+    nd, ne = 30, 12
+    pred = rng.standard_normal((nd, ne)) * 3 + 1
+    obs = pred.mean(1)[:, None] + rng.normal(0, 0.5, size=pred.shape)
+    scale = 0.2 + 3 * rng.random(nd)
+
+    reference = _w_step(pred, obs, scale)
+    rescaled = _w_step(4 * pred, 4 * obs, 4 * scale)
+
+    np.testing.assert_allclose(rescaled, reference, rtol=1e-10)
diff --git a/tests/conftest.py b/tests/conftest.py
index 6641f22d..395f331a 100644
--- a/tests/conftest.py
+++ b/tests/conftest.py
@@ -1,14 +1,16 @@
-import subprocess
+"""Suite-wide fixtures.
+
+PET's ensembles and optimizers write to the current working directory by
+default: ``En_*`` folders, ``prior_ensemble.npz``, ``ASSIM.log``/``OPTIM.log``,
+restart files. Until that default changes, every test starts in its own
+temporary directory so nothing lands in the repository or wherever pytest was
+launched. Tests that need a particular layout still call ``monkeypatch.chdir``
+or ``os.chdir`` themselves; this fixture only sets the starting point.
+"""
 
 import pytest
-import shutil
-
-@pytest.fixture(scope="session")
-def temp_examples_dir(request, tmp_path_factory):
-    """Clone PET Examples repo to a temp dir. Return its path."""
-    pth = tmp_path_factory.mktemp("temp_dir")
-    subprocess.run(["git", "clone", "--depth", "1", "--branch", "examples-dev",
-                    "https://github.com/Python-Ensemble-Toolbox/Examples.git", pth],
-                   check=True)
-    yield pth
-    shutil.rmtree(str(pth))
+
+
+@pytest.fixture(autouse=True)
+def _run_in_tmp_path(tmp_path, monkeypatch):
+    monkeypatch.chdir(tmp_path)
diff --git a/tests/optimization/test_bound_transform.py b/tests/optimization/test_bound_transform.py
new file mode 100644
index 00000000..855fb476
--- /dev/null
+++ b/tests/optimization/test_bound_transform.py
@@ -0,0 +1,159 @@
+import numpy as np
+import pytest
+
+from popt.optimization_methods import BoundTransformHandler
+
+def test_finite_bounds():
+    bounds = [(0.0, 10.0)]
+    h = BoundTransformHandler(bounds, transform=True)
+    x = np.array([5.0])
+    u = h.state_to_unit_cube(x)
+    assert np.allclose(u, [0.5])
+
+
+def test_multiple_dimensions():
+    bounds = [
+        (0.0, 10.0),
+        (-5.0, 5.0),
+        (100.0, 200.0),
+    ]
+    h = BoundTransformHandler(bounds, transform=True)
+    x = np.array([5.0, 0.0, 150.0])
+    u = h.state_to_unit_cube(x)
+    expected = np.array([
+        0.5,
+        0.5,
+        0.5,
+    ])
+    assert np.allclose(u, expected)
+
+
+def test_lower_boundary():
+    bounds = [
+        (0.0, 10.0),
+        (-5.0, 5.0),
+    ]
+    h = BoundTransformHandler(bounds, transform=True)
+    x = np.array([0.0, -5.0])
+    u = h.state_to_unit_cube(x)
+    assert np.allclose(u, [0.0, 0.0])
+
+
+def test_upper_boundary():
+    bounds = [
+        (0.0, 10.0),
+        (-5.0, 5.0),
+    ]
+    h = BoundTransformHandler(bounds, transform=True)
+    x = np.array([10.0, 5.0])
+    u = h.state_to_unit_cube(x)
+    assert np.allclose(u, [1.0, 1.0])
+
+
+def test_no_transform():
+    bounds = [(0.0, 10.0)]
+    h = BoundTransformHandler(bounds, transform=False)
+    x = np.array([7.5])
+    assert np.allclose(
+        h.state_to_unit_cube(x),
+        x,
+    )
+
+
+def test_none_bounds():
+    h = BoundTransformHandler(None, transform=True)
+    x = np.array([1.0, 2.0])
+    assert np.allclose(
+        h.state_to_unit_cube(x),
+        x,
+    )
+
+
+def test_round_trip_single_dimension():
+    bounds = [(0.0, 10.0)]
+    h = BoundTransformHandler(bounds, transform=True)
+    x = np.array([7.5])
+    u = h.state_to_unit_cube(x)
+    x2 = h.unit_cube_to_state(u)
+    assert np.allclose(x, x2)
+
+
+def test_round_trip_multiple_dimensions():
+    bounds = [
+        (0.0, 10.0),
+        (-5.0, 5.0),
+        (100.0, 200.0),
+    ]
+    h = BoundTransformHandler(bounds, transform=True)
+    x = np.array([3.7,-1.4, 175.8])
+    u = h.state_to_unit_cube(x)
+    x2 = h.unit_cube_to_state(u)
+    assert np.allclose(x, x2)
+
+
+def test_round_trip_random_points():
+    bounds = [
+        (-5.0, 5.0),
+        (0.0, 100.0),
+        (10.0, 20.0),
+    ]
+    h = BoundTransformHandler(bounds, transform=True)
+    rng = np.random.default_rng(42)
+    for _ in range(1000):
+        x = np.array([
+            rng.uniform(-5.0, 5.0),
+            rng.uniform(0.0, 100.0),
+            rng.uniform(10.0, 20.0),
+        ])
+        u = h.state_to_unit_cube(x)
+        x2 = h.unit_cube_to_state(u)
+        assert np.allclose(x, x2)
+
+
+def test_project_state_space():
+    bounds = [
+        (0.0, 10.0),
+        (-5.0, 5.0),
+    ]
+    h = BoundTransformHandler(bounds, transform=False)
+    x = np.array([-1.0, 10.0])
+
+    projected = h.project_to_bounds(x)
+    assert np.allclose(
+        projected,
+        [0.0, 5.0],
+    )
+
+
+def test_project_unit_cube():
+    bounds = [
+        (0.0, 10.0),
+        (-5.0, 5.0),
+    ]
+    h = BoundTransformHandler(bounds, transform=True)
+    u = np.array([-0.2, 1.5])
+
+    projected = h.project_to_bounds(u)
+    assert np.allclose(
+        projected,
+        [0.0, 1.0],
+    )
+
+
+def test_invalid_state_outside_bounds():
+    bounds = [(0.0, 10.0)]
+    h = BoundTransformHandler(bounds, transform=True)
+    with pytest.raises(ValueError):
+        h.state_to_unit_cube(np.array([11.0]))
+
+
+def test_invalid_unit_cube_coordinate():
+    bounds = [(0.0, 10.0)]
+    h = BoundTransformHandler(bounds, transform=True)
+    with pytest.raises(ValueError):
+        h.unit_cube_to_state(np.array([1.1]))
+
+
+def test_invalid_bounds():
+    with pytest.raises(ValueError):
+        BoundTransformHandler([(10.0, 0.0)])
diff --git a/tests/optimization/test_crashed_evaluation.py b/tests/optimization/test_crashed_evaluation.py
new file mode 100644
index 00000000..f90609f9
--- /dev/null
+++ b/tests/optimization/test_crashed_evaluation.py
@@ -0,0 +1,117 @@
+"""A crashed simulation costs the trial point, not the optimization run.
+
+The optimizer proposes control vectors, some of which the simulator cannot run. Ending
+the run on the first of them throws away every iteration that came before it. Reporting
+`inf` instead lets backtracking reject the point and carry on from the last good one.
+"""
+
+from types import SimpleNamespace
+
+import numpy as np
+
+from popt.ensembles.ensemble_base import EnsembleOptimizationBase
+
+NX, NE = 3, 4
+
+
+def _host(*, sim_success, ne=NE):
+    """The attributes `function` reads, and nothing else."""
+    logged = []
+    return SimpleNamespace(
+        ne=ne,
+        num_models=1,
+        num_samples=ne,
+        aux_input=None,
+        idX={"x": (0, NX)},
+        save_prediction=None,
+        sim=SimpleNamespace(input_dict={}, true_order=None),
+        sim_data=None,
+        logger=SimpleNamespace(error=logged.append, info=logged.append),
+        calc_prediction=lambda x, save_prediction=None: sim_success,
+        obj_func=lambda *a, **k: np.arange(ne, dtype=float),
+        _aux_input=lambda: 1,
+        _reorganize_multilevel_ensemble=lambda x: x,
+        stateF=np.array([7.0]),
+        enF=None,
+    ), logged
+
+
+def test_a_crashed_ensemble_evaluation_reports_inf_instead_of_raising():
+    host, logged = _host(sim_success=False)
+
+    values = EnsembleOptimizationBase.function(host, np.zeros((NX, NE)))
+
+    assert np.all(np.isinf(values))
+    assert any("reject it" in m for m in logged)
+
+
+def test_a_crashed_single_point_leaves_the_current_objective_alone():
+    """`gradient` computes `enF - repeat(stateF, nr)`, so writing inf into stateF
+    would poison every later gradient rather than just rejecting this point."""
+    host, _ = _host(sim_success=False)
+    before = host.stateF.copy()
+
+    values = EnsembleOptimizationBase.function(host, np.zeros(NX))
+
+    assert np.all(np.isinf(values))
+    np.testing.assert_array_equal(host.stateF, before)
+
+
+def test_a_successful_evaluation_still_updates_the_state_objective():
+    host, _ = _host(sim_success=True)
+
+    values = EnsembleOptimizationBase.function(host, np.zeros(NX))
+
+    assert np.all(np.isfinite(values))
+    np.testing.assert_array_equal(host.stateF, values)
+
+
+def test_a_successful_ensemble_evaluation_still_updates_the_ensemble_objective():
+    host, _ = _host(sim_success=True)
+
+    values = EnsembleOptimizationBase.function(host, np.zeros((NX, NE)))
+
+    np.testing.assert_array_equal(host.enF, values)
+    np.testing.assert_array_equal(host.stateF, np.array([7.0]))   # untouched
+
+
+# --------------------------------------------------------------------------
+# End to end: the optimizer rejects the point and keeps going
+# --------------------------------------------------------------------------
+
+def test_the_optimizer_backtracks_past_a_crashed_trial_point(tmp_path, monkeypatch):
+    monkeypatch.chdir(tmp_path)
+    from popt.optimization_methods.optimizer_base import OptimizerBase, StepReport
+
+    class _Descent(OptimizerBase):
+        NAME = "descent"
+
+        def update_step(self) -> StepReport:
+            for shrink in (1.0, 0.5, 0.25):
+                x_new = self.xk - shrink * 0.5 * self.jk
+                f_new = self.fun(x_new)
+                if np.mean(f_new) < np.mean(self.fk):
+                    self._commit_step(x_new, f_new, jac=self.jac(x_new))
+                    return StepReport(True)
+            return StepReport(False, "no improving step")
+
+    crashed = []
+
+    def objective(x, *args, **kwargs):
+        x = np.asarray(x, dtype=float)
+        # The full step from (2, 2) lands on (0, 0), which the "simulator" cannot run;
+        # backtracking halves it to (1, 1), which it can.
+        if np.allclose(x, np.array([0.0, 0.0]), atol=1e-9):
+            crashed.append(tuple(x))
+            return np.inf
+        return float(np.sum(x ** 2))
+
+    result = _Descent.minimize(
+        np.array([2.0, 2.0]), objective, jac=lambda x: 2.0 * np.asarray(x, dtype=float),
+        logit=False, maxiter=3, xtol=1e-12, ftol=1e-12,
+    )
+
+    assert crashed, "the crashing point was never proposed; the test proves nothing"
+    assert np.all(np.isfinite(result.x))
+    assert np.mean(result.fun) < np.sum(np.array([2.0, 2.0]) ** 2)
+    assert result.nit >= 1
diff --git a/tests/optimization/test_ensemble_optimization.py b/tests/optimization/test_ensemble_optimization.py
new file mode 100644
index 00000000..bff65c0e
--- /dev/null
+++ b/tests/optimization/test_ensemble_optimization.py
@@ -0,0 +1,268 @@
+"""
+Tests for optimization workflows using Gaussian ensembles.
+
+These tests validate:
+1. Convergence of EnOpt on a quadratic objective
+2. Line search optimization behavior
+3. High-dimensional optimization (Rosenbrock function)
+"""
+
+import os
+from pathlib import Path
+
+import numpy as np
+import pytest
+from scipy.optimize import rosen
+
+from popt.ensembles import GaussianEnsemble
+from popt.optimization_methods import EnOpt
+from popt.optimization_methods import LineSearch
+from popt.cost_functions.quadratic import quadratic
+
+
+# ----------------------------------------------------------------------
+# Configuration
+# ----------------------------------------------------------------------
+
+ENSEMBLE_CONFIG = {
+    "ne": 10,
+    "natural_gradient": False,
+    "controls": {
+        "x": {
+            "mean": [5] * 2,
+            "var": 1.0e-5,
+            "limits": [-10, 10],
+        }
+    },
+}
+
+OPT_CONFIG = {
+    "transform": True,
+    "maxiter": 50,
+    "tol": 1e-2,
+    "alpha": 0.25,
+    "alpha_maxiter": 4,
+    "resample": 0,
+    "optimizer": "GD",
+    "restartsave": False,
+    "restart": False,
+    "save_data": ["alpha", "obj_func_values"],
+}
+
+
+# ----------------------------------------------------------------------
+# Utilities
+# ----------------------------------------------------------------------
+
+def prepare_test_environment(tmp_path: Path, seed: int):
+    """
+    Set working directory and initialize random seed.
+    """
+    np.random.seed(seed)
+    os.chdir(tmp_path)
+
+
+def create_ensemble(config, objective):
+    """
+    Initialize Gaussian ensemble and extract key components.
+    """
+    ensemble = GaussianEnsemble(config, None, objective)
+
+    return {
+        "ensemble": ensemble,
+        "x0": ensemble.get_state(),
+        "cov": ensemble.get_cov(),
+        "bounds": ensemble.get_bounds(),
+    }
+
+
+# ----------------------------------------------------------------------
+# Tests
+# ----------------------------------------------------------------------
+
+def test_quadratic_enopt(tmp_path):
+    """
+    Verify EnOpt converges to optimum for quadratic function.
+    """
+    prepare_test_environment(tmp_path, seed=101122)
+
+    data = create_ensemble(ENSEMBLE_CONFIG, quadratic)
+    ensemble = data["ensemble"]
+
+    res = EnOpt.minimize(
+        x0=data["x0"],
+        fun=ensemble.function,
+        jac=ensemble.gradient,
+        hess=ensemble.hessian,
+        args=(data["cov"],),
+        bounds=data["bounds"],
+        **OPT_CONFIG,
+    )
+
+    np.testing.assert_array_almost_equal(
+        res.x, [1.0, 1.0], decimal=1,
+        err_msg="EnOpt failed to converge to expected optimum"
+    )
+
+    np.testing.assert_array_almost_equal(
+        res.fun, [0.0], decimal=1,
+        err_msg="Objective value not minimized as expected"
+    )
+
+
+def test_quadratic_linesearch(tmp_path):
+    """
+    Verify LineSearch converges on quadratic objective.
+    """
+    prepare_test_environment(tmp_path, seed=101122)
+
+    data = create_ensemble(ENSEMBLE_CONFIG, quadratic)
+
+    result = LineSearch.minimize(
+        x0=data["x0"],
+        fun=data["ensemble"].function,
+        jac=data["ensemble"].gradient,
+        args=(data["cov"],),
+        bounds=data["bounds"],
+        transform=True,
+    )
+
+    np.testing.assert_array_almost_equal(
+        result.x, [1.0, 1.0], decimal=1,
+        err_msg="LineSearch did not converge to expected optimum"
+    )
+
+    np.testing.assert_almost_equal(
+        result.fun, 0.0, decimal=4,
+        err_msg="Final objective value is too large"
+    )
+
+def test_rosenbrock_linesearch(tmp_path):
+    """
+    Verify LineSearch (BFGS) converges on high-dimensional Rosenbrock problem.
+    """
+    prepare_test_environment(tmp_path, seed=10_08_1997)
+
+    dim = 100
+
+    ensemble_config = {
+        "ne": 100,
+        "natural_gradient": False,
+        "controls": {
+            "x": {
+                "mean": [-2] * dim,
+                "var": 0.001,
+                "limits": [-2, 2],
+            }
+        },
+    }
+
+    # Objective wrapped for compatibility with ensemble
+    def rosenbrock(x, *args, **kwargs):
+        return rosen(x)
+
+    data = create_ensemble(ensemble_config, rosenbrock)
+
+    result = LineSearch.minimize(
+        x0=data["x0"],
+        fun=data["ensemble"].function,
+        jac=data["ensemble"].gradient,
+        args=(data["cov"],),
+        bounds=data["bounds"],
+        method="BFGS",
+        maxiter=1000,
+        step_size=1.0,
+        ftol=1e-8,
+        step_size_adapt=0
+    )
+    print(result)
+    expected = np.ones(dim)
+
+    np.testing.assert_array_almost_equal(
+        result.x, expected, decimal=0,
+        err_msg="Solution deviates significantly from Rosenbrock optimum"
+    )
+
+    # Norm-based tolerance for high-dimensional case
+    error_norm = np.linalg.norm(result.x - expected)
+    tolerance = 0.1 * np.sqrt(dim)
+
+    assert error_norm < tolerance, (
+        f"Solution error too large: |x - x*| = {error_norm:.3f} "
+        f">= {tolerance:.3f}"
+    )
+
+
+
+# ----------------------------------------------------------------------
+# Objective-call dispatch
+# ----------------------------------------------------------------------
+
+def test_typeerror_inside_the_objective_is_not_swallowed(tmp_path):
+    """An error from within the objective must surface, not trigger a retry.
+
+    The optimizers support objectives that take only `x` as well as ones taking
+    the covariance and extras. That used to be decided by calling the rich form
+    and catching TypeError -- which cannot tell "rejected the arguments" from
+    "raised TypeError halfway through". The whole evaluation was then repeated,
+    and with a real simulator the repeat died on the scratch folders the first
+    attempt had created, reporting FileExistsError and hiding the real error.
+    """
+    prepare_test_environment(tmp_path, seed=1)
+
+    calls = []
+
+    def raises_inside(x, **kwargs):
+        calls.append(x)
+        raise TypeError("deep inside the objective")
+
+    data = create_ensemble(ENSEMBLE_CONFIG, raises_inside)
+
+    with pytest.raises(TypeError, match="deep inside the objective"):
+        EnOpt.minimize(
+            x0=data["x0"],
+            fun=data["ensemble"].function,
+            jac=data["ensemble"].gradient,
+            args=(data["cov"],),
+            bounds=data["bounds"],
+            **OPT_CONFIG,
+        )
+
+    assert len(calls) == 1, (
+        f"objective evaluated {len(calls)} times for one evaluation; "
+        f"the retry-on-TypeError path is back"
+    )
+
+
+def test_objective_taking_only_x_is_still_supported():
+    """The case the fallback exists for: no covariance, no extras."""
+    def fun(x):
+        return float(np.sum((np.asarray(x) - 0.5) ** 2))
+
+    def jac(x):
+        return 2.0 * (np.asarray(x, dtype=float) - 0.5)
+
+    res = EnOpt.minimize(
+        x0=np.array([2.0]), fun=fun, jac=jac, args=(np.eye(1) * 1e-3,),
+        bounds=[(-5, 5)], transform=True, maxiter=15, alpha=0.3, saveit=False,
+    )
+
+    np.testing.assert_array_almost_equal(res.x, [0.5], decimal=2)
+
+
+def test_objective_accepting_neither_shape_is_reported_clearly():
+    """Neither (x, *args, **kwargs) nor (x) -> say so, naming the signature.
+
+    Previously this fell through to `func(x)` and failed with whatever
+    TypeError that produced, which described the fallback rather than the
+    mismatch the user has to fix.
+    """
+    def wrong(x, y, z):
+        return 0.0
+
+    with pytest.raises(TypeError, match=r"accepts neither"):
+        EnOpt.minimize(
+            x0=np.array([2.0]), fun=wrong, jac=lambda x: np.zeros_like(x),
+            args=(np.eye(1) * 1e-3,), bounds=[(-5, 5)],
+            transform=True, maxiter=1, saveit=False,
+        )
diff --git a/tests/optimization/test_ensembles.py b/tests/optimization/test_ensembles.py
new file mode 100644
index 00000000..baef770a
--- /dev/null
+++ b/tests/optimization/test_ensembles.py
@@ -0,0 +1,225 @@
+"""
+Tests for Gaussian ensemble.
+"""
+import os
+import numpy as np
+from scipy.optimize import rosen, rosen_der
+from popt.ensembles import GaussianEnsemble, GeneralizedEnsemble
+
+
+# ----------------------------------------------------------------------
+# Configuration
+# ----------------------------------------------------------------------
+X0 = np.array([5.0, 5.0])
+NE = 10
+CFG = {
+    "ne": NE,
+    "natural_gradient": False,
+    "controls": {
+        "x": {
+            "mean": X0.tolist(),
+            "var": 1.0e-5,
+            "limits": [-2, 2],
+        }
+    },
+}
+
+def rosen_function_vectorized(x):
+    return np.apply_along_axis(rosen, axis=0, arr=x)
+
+
+def test_gaussian_ensemble_gradient(tmp_path):
+    """
+    Test the gradient estimation of the Gaussian ensemble.
+    """
+    os.chdir(tmp_path)
+
+    # =============================================================
+    # Compute ensmble gradient
+    # =============================================================
+    np.random.seed(42)
+    ensemble = GaussianEnsemble(
+        CFG,
+        simulator = None,
+        objective = rosen_function_vectorized
+    )
+    x0 = ensemble.get_state()
+    f0 = ensemble.function(x0)
+    cov = ensemble.get_cov()
+    grad_ensemble = ensemble.gradient(x0, cov)
+    # =============================================================
+
+    # =============================================================
+    # Compute ensmble gradient manually for comparison
+    # =============================================================
+    np.random.seed(42)
+    enX = np.random.multivariate_normal(x0, cov, NE).T
+    enX = enX - enX.mean(axis=1, keepdims=True) + x0[:, None]
+    enX = np.clip(enX, -2, 2)
+    enF = ensemble.function(enX)
+    dF  = enF - f0
+    dx  = enX - x0[:, None]
+    grad_expected = np.linalg.solve(cov, dx @ dF / NE)
+    # =============================================================
+
+    np.testing.assert_array_equal(grad_ensemble, grad_expected)
+
+
+def test_gaussian_ensemble_hessian(tmp_path):
+    """
+    Test the Hessian estimation of the Gaussian ensemble.
+    """
+    os.chdir(tmp_path)
+
+    # =============================================================
+    # Compute ensemble Hessian
+    # =============================================================
+    np.random.seed(42)
+    ensemble = GaussianEnsemble(
+        CFG,
+        simulator = None,
+        objective = rosen_function_vectorized
+    )
+    x0 = ensemble.get_state()
+    f0 = ensemble.function(x0)
+    # The return value is unused, but the call is required: hessian() below
+    # reuses the ensemble (self.enF) that gradient() populates, and also
+    # advances the global RNG that the manual comparison re-seeds against.
+    # Deleting this line makes hessian() raise TypeError on self.enF.
+    ensemble.gradient(x0, ensemble.get_cov())
+    cov = ensemble.get_cov()
+    hess_ensemble = ensemble.hessian(x0, cov)
+    # =============================================================
+
+    # =============================================================
+    # Compute ensemble Hessian manually for comparison
+    # =============================================================
+    np.random.seed(42)
+    enX = np.random.multivariate_normal(x0, cov, NE).T
+    enX = enX - enX.mean(axis=1, keepdims=True) + x0[:, None]
+    enX = np.clip(enX, -2, 2)
+    enF = ensemble.function(enX)
+    dF  = enF - f0
+    dX  = enX - x0[:, None]
+    hess_expected = (dX * dF) @ dX.T / NE - cov * np.mean(dF)
+    hess_expected = np.linalg.solve(
+        cov,
+        np.linalg.solve(cov, hess_expected).T
+    ).T
+    # =============================================================
+
+    np.testing.assert_array_equal(hess_ensemble, hess_expected)
+
+
+def test_gaussian_ensemble_gradient_convergence(tmp_path):
+    os.chdir(tmp_path)
+
+    ne = 100_000
+    cfg = {
+        "ne": ne,
+        "natural_gradient": False,
+        "controls": {
+            "x": {
+                "mean": [-1.0, -1.0],
+                "var": 1.0e-5,
+                "limits": [-2, 2],
+            }
+        },
+    }
+
+    # =============================================================
+    # Compute ensemble Gradient
+    # =============================================================
+    np.random.seed(42)
+    ensemble = GaussianEnsemble(
+        cfg,
+        simulator = None,
+        objective = rosen_function_vectorized
+    )
+    x0 = ensemble.get_state()
+    cov = ensemble.get_cov()
+    ensemble.function(x0)
+    grad_ensemble = ensemble.gradient(x0, cov)
+    # ============================================================
+
+    # ============================================================
+    # Compute true average gradient for comparison
+    # ============================================================
+    np.random.seed(42)
+    enX = np.random.multivariate_normal(x0, cov, ne).T
+    enX = enX - enX.mean(axis=1, keepdims=True) + x0[:, None]
+    enX = np.clip(enX, -2, 2)
+
+    grad_expected = np.mean(
+        np.apply_along_axis(rosen_der, axis=0, arr=enX),
+        axis=1
+    )
+    # ===========================================================
+
+    np.testing.assert_allclose(
+        grad_ensemble,
+        grad_expected,
+        rtol=1e-2,
+        atol=1e-6,
+    )
+
+
+def test_generalized_ensemble_gradient_convergence(tmp_path):
+    os.chdir(tmp_path)
+
+    ne = 100_000
+    cfg = {
+        "ne": ne,
+        #"marginal": "TruncGaussian",
+        "controls": {
+            "x": {
+                "mean": [-1.0, -1.0],
+                "var": 1.0e-5,
+                "limits": [-2, 2],
+            }
+        },
+    }
+
+    # =============================================================
+    # Compute ensemble Gradient
+    # =============================================================
+    np.random.seed(42)
+    ensemble = GeneralizedEnsemble(
+        cfg,
+        simulator = None,
+        objective = rosen_function_vectorized
+    )
+    x0 = ensemble.get_state()
+    corr = ensemble.get_corr()
+    theta = ensemble.get_theta()
+    ensemble.function(x0)
+    grad_ensemble = ensemble.gradient(x0, theta, corr)
+    # ============================================================
+
+    # ============================================================
+    # Compute true average gradient for comparison
+    # ============================================================
+    np.random.seed(42)
+    enX, _ = ensemble.sample(ne)
+    enX = np.clip(enX.T, -2, 2)
+
+    grad_expected = np.mean(
+        np.apply_along_axis(rosen_der, axis=0, arr=enX),
+        axis=1
+    )
+    # ===========================================================
+
+    np.testing.assert_allclose(
+        grad_ensemble,
+        grad_expected,
+        rtol=1e-2,
+        atol=1e-6,
+    )
+
+
+
+
+
+
+
+
diff --git a/tests/optimization/test_epf_convergence.py b/tests/optimization/test_epf_convergence.py
new file mode 100644
index 00000000..62fabc29
--- /dev/null
+++ b/tests/optimization/test_epf_convergence.py
@@ -0,0 +1,112 @@
+"""The outer EPF loop converges on the constraint violation, not on the step size.
+
+Measuring the relative change in the controls answered the wrong question: the loop
+declared success whenever the inner optimizer stalled, however badly the constraints
+were still violated, and refused to finish while one control kept jittering.
+"""
+
+from types import SimpleNamespace
+
+import numpy as np
+import pytest
+
+from popt.optimization_methods.optimizer_base import OptimizerBase, StepReport
+
+
+def _host(penalty, **epf):
+    """The attributes `check_epf_convergence` reads, and nothing else."""
+    log = []
+    options = {'r': 2.0, 'r_factor': 2.0, 'tol_factor': 0.9}
+    options.update(epf)
+    if penalty is not None:
+        options['penalty'] = penalty
+    return SimpleNamespace(
+        epf=options, epf_iteration=1, epf_maxiter=10, ftol=1e-4, logger=log.append
+    ), log
+
+
+def test_a_satisfied_constraint_ends_the_loop():
+    host, log = _host(np.array([1e-6, 1e-6]), conv_crit=1e-3)   # mean/r = 5e-7
+
+    assert OptimizerBase.check_epf_convergence(host) is True
+    assert any('penalty term smaller than' in m for m in log)
+
+
+def test_a_violated_constraint_tightens_the_penalty_and_continues():
+    host, log = _host(np.array([4.0, 6.0]), conv_crit=1e-3)     # mean/r = 2.5
+
+    assert OptimizerBase.check_epf_convergence(host) is False
+    assert host.epf['r'] == 4.0                                  # r doubled
+    assert host.ftol == pytest.approx(9e-5)                      # tolerance tightened
+
+
+def test_a_stalled_but_infeasible_point_is_not_convergence():
+    """The old criterion read `|xk - xk_old| / |xk_old|`, so an inner loop that stopped
+    moving reported success at a point that never satisfied the constraints."""
+    host, _ = _host(np.array([100.0]), conv_crit=1e-5)
+    host.xk = host.xk_old = np.array([1.0, 2.0])                 # nothing moved at all
+
+    assert OptimizerBase.check_epf_convergence(host) is False
+
+
+def test_the_maximum_outer_iteration_count_still_wins():
+    host, log = _host(np.array([100.0]), conv_crit=1e-5)
+    host.epf_iteration = host.epf_maxiter
+
+    assert OptimizerBase.check_epf_convergence(host) is True
+    assert any('Maximum number of outer EPF iterations' in m for m in log)
+
+
+def test_an_objective_that_never_writes_a_penalty_is_an_error():
+    host, _ = _host(None, conv_crit=1e-3)
+
+    with pytest.raises(KeyError, match="must write it"):
+        OptimizerBase.check_epf_convergence(host)
+
+
+def test_an_empty_penalty_is_an_error():
+    host, _ = _host(np.array([]), conv_crit=1e-3)
+
+    with pytest.raises(ValueError, match='penalty is empty'):
+        OptimizerBase.check_epf_convergence(host)
+
+
+def test_conv_crit_defaults_when_the_config_omits_it():
+    """1e-5 was chosen for a dimensionless relative state change and is kept, so a
+    config written for the old criterion still runs. It now means an absolute penalty
+    magnitude, which is why CHANGELOG records the changed meaning."""
+    host, _ = _host(np.array([1e-9]))                             # mean/r = 5e-10 < 1e-5
+
+    assert OptimizerBase.check_epf_convergence(host) is True
+
+
+# --------------------------------------------------------------------------
+# End to end: the outer loop runs exactly max_epf_iter times
+# --------------------------------------------------------------------------
+
+class _FixedStep(OptimizerBase):
+    NAME = "fixed step"
+
+    def update_step(self) -> StepReport:
+        x_new = self.xk - 0.25 * self.jk
+        self._commit_step(x_new, self.fun(x_new), jac=self.jac(x_new))
+        return StepReport(True)
+
+
+def test_the_outer_loop_runs_exactly_max_epf_iter_passes(tmp_path, monkeypatch):
+    monkeypatch.chdir(tmp_path)
+    penalty_factors = []
+
+    def objective(x, **kwargs):
+        epf = kwargs['epf']
+        epf['penalty'] = np.array([1e3])          # never satisfied, so the loop runs out
+        penalty_factors.append(epf['r'])
+        return float(np.sum(np.asarray(x) ** 2))
+
+    _FixedStep.minimize(
+        np.array([2.0, -1.0]), objective, jac=lambda x: 2.0 * np.asarray(x, dtype=float),
+        logit=False, maxiter=2,
+        epf={'r': 1.0, 'r_factor': 2.0, 'tol_factor': 0.9, 'conv_crit': 1e-5, 'max_epf_iter': 3},
+    )
+
+    assert sorted(set(penalty_factors)) == [1.0, 2.0, 4.0]        # three outer passes, r doubling
diff --git a/tests/optimization/test_genopt.py b/tests/optimization/test_genopt.py
new file mode 100644
index 00000000..4223678f
--- /dev/null
+++ b/tests/optimization/test_genopt.py
@@ -0,0 +1,187 @@
+"""GenOpt: the sampling distribution moves along with the controls.
+
+EnOpt draws from a fixed Gaussian; GenOpt draws from the generalized ensemble's
+marginals and advances `theta` and the correlation matrix as well, so an accepted
+step has to change three things, not one.
+"""
+
+import numpy as np
+import pytest
+from scipy.optimize import rosen
+
+from popt import CMA, GenOpt
+from popt.ensembles import GeneralizedEnsemble
+
+X0 = np.array([-1.0, -1.0])
+NE = 60
+
+
+def _rosen_vectorized(x, *args, **kwargs):
+    return np.apply_along_axis(rosen, axis=0, arr=x)
+
+
+def _ensemble(seed=42, ne=NE):
+    np.random.seed(seed)
+    cfg = {
+        "ne": ne,
+        "controls": {"x": {"mean": X0.tolist(), "var": 1.0e-2, "limits": [-2, 2]}},
+    }
+    return GeneralizedEnsemble(cfg, simulator=None, objective=_rosen_vectorized)
+
+
+def _run(corr_adapt=None, *, maxiter=3, seed=42, **options):
+    ensemble = _ensemble(seed)
+    x0 = ensemble.get_state()
+    ensemble.function(x0)
+    return ensemble, GenOpt.minimize(
+        x0, ensemble.function,
+        jac=ensemble.gradient, jac_mut=ensemble.mutation_gradient,
+        args=(ensemble.get_theta(), ensemble.get_corr()),
+        corr_adapt=corr_adapt, bounds=[(-2, 2)] * X0.size,
+        logit=False, maxiter=maxiter, **options,
+    )
+
+
+# --------------------------------------------------------------------------
+# It runs, and it optimizes
+# --------------------------------------------------------------------------
+
+def test_genopt_reduces_the_objective(tmp_path, monkeypatch):
+    monkeypatch.chdir(tmp_path)
+    ensemble, result = _run()
+
+    assert np.mean(result.fun) < rosen(X0)
+    assert result.nit >= 1
+
+
+def test_the_distribution_parameter_moves(tmp_path, monkeypatch):
+    """theta follows its own gradient on every accepted step; if it never moves the
+    method has silently degenerated into EnOpt with a fixed non-Gaussian sampler."""
+    monkeypatch.chdir(tmp_path)
+    ensemble = _ensemble()
+    theta0 = np.array(ensemble.get_theta(), dtype=float)
+    x0 = ensemble.get_state()
+    ensemble.function(x0)
+
+    optimizer = GenOpt(
+        x0, ensemble.function, jac=ensemble.gradient, jac_mut=ensemble.mutation_gradient,
+        args=(ensemble.get_theta(), ensemble.get_corr()),
+        bounds=[(-2, 2)] * X0.size, logit=False, maxiter=3,
+    )
+    optimizer.run_optimization()
+
+    assert not np.allclose(optimizer.theta, theta0)
+
+
+# --------------------------------------------------------------------------
+# Correlation adaptation
+# --------------------------------------------------------------------------
+
+def test_cma_adapts_the_correlation_matrix(tmp_path, monkeypatch):
+    monkeypatch.chdir(tmp_path)
+    ensemble = _ensemble()
+    corr0 = np.array(ensemble.get_corr(), dtype=float)
+    x0 = ensemble.get_state()
+    ensemble.function(x0)
+
+    optimizer = GenOpt(
+        x0, ensemble.function, jac=ensemble.gradient, jac_mut=ensemble.mutation_gradient,
+        args=(ensemble.get_theta(), ensemble.get_corr()),
+        corr_adapt=CMA(ne=NE, dim=X0.size, corr_update=True),
+        bounds=[(-2, 2)] * X0.size, logit=False, maxiter=3,
+    )
+    optimizer.run_optimization()
+
+    assert optimizer.corr.shape == corr0.shape
+    assert not np.allclose(optimizer.corr, corr0)
+
+
+def test_a_plain_callable_corr_adapt_is_descended_along(tmp_path, monkeypatch):
+    """Anything callable works, not just CMA: its result is a descent direction for
+    the correlation, scaled by `alpha_corr`."""
+    monkeypatch.chdir(tmp_path)
+    direction = np.array([[0.0, 1.0], [1.0, 0.0]])
+
+    ensemble = _ensemble()
+    corr0 = np.array(ensemble.get_corr(), dtype=float)
+    x0 = ensemble.get_state()
+    ensemble.function(x0)
+
+    optimizer = GenOpt(
+        x0, ensemble.function, jac=ensemble.gradient, jac_mut=ensemble.mutation_gradient,
+        args=(ensemble.get_theta(), ensemble.get_corr()),
+        corr_adapt=lambda: direction, alpha_corr=0.25,
+        bounds=[(-2, 2)] * X0.size, logit=False, maxiter=1,
+    )
+    optimizer.run_optimization()
+
+    steps = np.round((corr0 - optimizer.corr) / 0.25, 9)
+    assert np.allclose(steps % 1, 0)                    # a whole number of alpha_corr steps
+    assert not np.allclose(optimizer.corr, corr0)
+
+
+def test_no_corr_adapt_leaves_the_correlation_alone(tmp_path, monkeypatch):
+    monkeypatch.chdir(tmp_path)
+    ensemble = _ensemble()
+    corr0 = np.array(ensemble.get_corr(), dtype=float)
+    x0 = ensemble.get_state()
+    ensemble.function(x0)
+
+    optimizer = GenOpt(
+        x0, ensemble.function, jac=ensemble.gradient, jac_mut=ensemble.mutation_gradient,
+        args=(ensemble.get_theta(), ensemble.get_corr()),
+        bounds=[(-2, 2)] * X0.size, logit=False, maxiter=2,
+    )
+    optimizer.run_optimization()
+
+    np.testing.assert_array_equal(optimizer.corr, corr0)
+
+
+# --------------------------------------------------------------------------
+# The ensemble is drawn once, not twice
+# --------------------------------------------------------------------------
+
+def test_the_mutation_gradient_can_return_its_ensemble():
+    """CMA needs the Gaussian samples and their objective values. Asking for them in
+    the same call is what keeps GenOpt from simulating a second ensemble per step."""
+    ensemble = _ensemble()
+    x0 = ensemble.get_state()
+    ensemble.function(x0)
+
+    grad, matrices = ensemble.mutation_gradient(
+        x0, ensemble.get_theta(), ensemble.get_corr(), return_ensembles=True
+    )
+
+    assert set(matrices) == {"gaussian", "objective"}
+    assert matrices["gaussian"].shape[0] == NE
+    assert matrices["objective"].shape[0] == NE
+    np.testing.assert_array_equal(grad, ensemble.nat_grad)
+
+
+# --------------------------------------------------------------------------
+# Contract
+# --------------------------------------------------------------------------
+
+@pytest.mark.parametrize("missing, message", [
+    ("jac", "requires a Jacobian"),
+    ("jac_mut", "requires a jac_mut"),
+])
+def test_both_gradients_are_required(missing, message):
+    kwargs = {"jac": lambda *a, **k: np.zeros(2), "jac_mut": lambda *a, **k: np.zeros(2)}
+    kwargs.pop(missing)
+
+    with pytest.raises(ValueError, match=message):
+        GenOpt(X0, _rosen_vectorized, args=(np.ones((2, 2)), np.eye(2)), **kwargs)
+
+
+def test_theta_and_corr_are_required():
+    with pytest.raises(ValueError, match=r"args = \(theta, corr\)"):
+        GenOpt(X0, _rosen_vectorized, jac=lambda *a, **k: np.zeros(2),
+               jac_mut=lambda *a, **k: np.zeros(2), args=())
+
+
+def test_an_unknown_optimizer_is_refused():
+    with pytest.raises(ValueError, match="not recognized for GenOpt"):
+        GenOpt(X0, _rosen_vectorized, jac=lambda *a, **k: np.zeros(2),
+               jac_mut=lambda *a, **k: np.zeros(2),
+               args=(np.ones((2, 2)), np.eye(2)), optimizer="Steihaug")
diff --git a/tests/optimization/test_line_search.py b/tests/optimization/test_line_search.py
new file mode 100644
index 00000000..51f3facf
--- /dev/null
+++ b/tests/optimization/test_line_search.py
@@ -0,0 +1,122 @@
+from pathlib import Path
+from scipy.optimize import rosen, rosen_der, rosen_hess
+import numpy as np
+import pytest
+import os
+
+from popt.optimization_methods import LineSearch
+
+
+def test_line_search_gradient_descent(tmp_path: Path):
+    """Verify gradient descent converges with and without bound transforms."""
+    os.chdir(tmp_path)
+
+    x0 = np.array([-1.2, -1.0])
+    bounds = [(-2.0, 2.0), (-2.0, 2.0)]
+    expected = np.array([1.0, 1.0])
+
+    for transform in (False, True):
+        res = LineSearch.minimize(
+            x0,
+            fun=rosen,
+            jac=rosen_der,
+            method="GD",
+            bounds=bounds,
+            maxiter=50_000,
+            transform=transform,
+        )
+        np.testing.assert_allclose(res.x, expected, atol=1e-4)
+
+
+def test_line_search_bfgs(tmp_path: Path):
+    """Verify BFGS converges with and without bound transforms."""
+    os.chdir(tmp_path)
+
+    x0 = np.array([-1.2, -1.0])
+    bounds = [(-2.0, 2.0), (-2.0, 2.0)]
+    expected = np.array([1.0, 1.0])
+
+    for transform in (False, True):
+        res = LineSearch.minimize(
+            x0,
+            fun=rosen,
+            jac=rosen_der,
+            method="BFGS",
+            bounds=bounds,
+            transform=transform,
+        )
+        np.testing.assert_allclose(res.x, expected, atol=1e-4)
+
+
+def test_line_search_newton_cg(tmp_path: Path):
+    """Verify Newton-CG converges with and without bound transforms."""
+    os.chdir(tmp_path)
+
+    x0 = np.array([-1.2, -1.0])
+    bounds = [(-2.0, 2.0), (-2.0, 2.0)]
+    expected = np.array([1.0, 1.0])
+
+    for transform in (False, True):
+        res = LineSearch.minimize(
+            x0,
+            fun=rosen,
+            jac=rosen_der,
+            hess=rosen_hess,
+            method="Newton-CG",
+            bounds=bounds,
+            transform=transform,
+        )
+        np.testing.assert_allclose(res.x, expected, atol=1e-4)
+
+
+def test_line_search_restart(tmp_path: Path):
+    """Verify restart save and resume behavior for BFGS line search."""
+    restart_path = tmp_path / "line_search_restart.pkl"
+    interrupt_iteration = 4
+    x0 = np.array([-1.2, -1.0])
+
+    def stop_after_checkpoint(opt):
+        if opt.iteration == interrupt_iteration:
+            raise RuntimeError("Intentional stop after checkpoint")
+
+    with pytest.raises(RuntimeError, match="Intentional stop after checkpoint"):
+        LineSearch.minimize(
+            x0,
+            fun=rosen,
+            jac=rosen_der,
+            method="BFGS",
+            callback=stop_after_checkpoint,
+            restartsave=True,
+            restart_file=restart_path,
+        )
+    assert restart_path.exists(), "Expected callback to save a restart file."
+
+    def verify_resume_progress(opt):
+        assert opt.iteration >= interrupt_iteration, (
+            "Expected resumed optimization to continue after the interrupted iteration."
+        )
+
+    # Resume the optimization from the saved restart file and verify it continues correctly.
+    resumed = LineSearch.minimize(
+        x0,
+        fun=rosen,
+        jac=rosen_der,
+        method="BFGS",
+        callback=verify_resume_progress,
+        restart=True,
+        restart_file=restart_path,
+    )
+
+    # Compare the resumed optimization result with a fresh optimization run to ensure they match.
+    reference = LineSearch.minimize(
+        x0,
+        fun=rosen,
+        jac=rosen_der,
+        method="BFGS",
+    )
+
+    assert resumed.message == reference.message
+    for key in ["x", "fun", "nfev", "njev", "nit"]:
+        assert np.allclose(resumed[key], reference[key]), (
+            f"Mismatch in {key} between resumed and reference optimization."
+        )
diff --git a/tests/optimization/test_optimizer_choreography.py b/tests/optimization/test_optimizer_choreography.py
new file mode 100644
index 00000000..913c5c0c
--- /dev/null
+++ b/tests/optimization/test_optimizer_choreography.py
@@ -0,0 +1,101 @@
+"""The base owns everything around a step; an optimizer is `update_step` plus `log_columns`."""
+
+import numpy as np
+import pytest
+from scipy.optimize import rosen, rosen_der
+
+from popt.optimization_methods import EnOpt, LineSearch
+from popt.optimization_methods.optimizer_base import OptimizerBase, StepReport
+
+
+def quadratic(x):
+    return float(np.sum((np.asarray(x) - 1.0) ** 2))
+
+
+def quadratic_jac(x):
+    return 2.0 * (np.asarray(x, dtype=float) - 1.0)
+
+
+class FixedStepDescent(OptimizerBase):
+    """The smallest optimizer the contract allows."""
+
+    NAME = "Fixed-step descent"
+
+    def update_step(self) -> StepReport:
+        x_new = self.xk - 0.25 * self.jk
+        f_new = self.fun(x_new)
+        if f_new >= np.mean(self.fk):
+            return StepReport(False, "no descent along the gradient")
+        self._commit_step(x_new, f_new, jac=self.jac(x_new))
+        return StepReport(True)
+
+
+def test_an_optimizer_is_a_step_and_the_base_does_the_rest(tmp_path, monkeypatch):
+    monkeypatch.chdir(tmp_path)
+    seen = []
+    res = FixedStepDescent.minimize(np.array([4.0, -2.0]), quadratic, jac=quadratic_jac,
+                                    callback=lambda opt: seen.append(opt.iteration), logit=False, xtol=1e-12, ftol=1e-12)
+
+    np.testing.assert_allclose(res.x, [1.0, 1.0], atol=1e-4)
+    assert res.message.startswith("Projected gradient norm")      # the base's gradient check, no override needed
+    assert seen == list(range(1, res.nit + 1))                     # callback once per accepted step
+    assert res.nfev == res.nit + 1 and res.njev == res.nit + 1     # start evaluation + one per step
+
+
+def test_a_rejected_step_stops_the_run_with_its_message(tmp_path, monkeypatch):
+    monkeypatch.chdir(tmp_path)
+
+    class Stuck(OptimizerBase):
+        def update_step(self):
+            return StepReport(False, "nothing works here")
+
+    calls = []
+    res = Stuck.minimize(np.array([0.0]), quadratic, jac=quadratic_jac, callback=lambda opt: calls.append(1), logit=False)
+    assert res.message == "nothing works here"
+    assert res.nit == 0 and calls == []
+
+
+def test_commit_step_keeps_the_previous_iterate_for_the_convergence_checks(tmp_path, monkeypatch):
+    monkeypatch.chdir(tmp_path)
+    opt = FixedStepDescent(np.array([3.0]), quadratic, jac=quadratic_jac, logit=False)
+    assert opt.fk is None                                          # nothing is evaluated until the run starts
+    opt._start()
+    opt._commit_step(np.array([2.0]), 1.0, jac=np.array([2.0]))
+    assert opt.xk_old == np.array([3.0]) and opt.fk_old == 4.0
+    assert opt.xk == np.array([2.0]) and opt.fk == 1.0 and opt.jk == np.array([2.0])
+
+
+def test_minimize_and_the_constructor_take_the_same_arguments_in_the_same_order(tmp_path, monkeypatch):
+    monkeypatch.chdir(tmp_path)
+    x0, cov = np.array([2.0]), np.eye(1) * 1e-3
+    kwargs = dict(bounds=[(-5, 5)], transform=True, maxiter=15, alpha=0.3, logit=False)
+
+    via_minimize = EnOpt.minimize(x0, quadratic, quadratic_jac, args=(cov,), **kwargs)
+    built = EnOpt(x0, quadratic, quadratic_jac, args=(cov,), **kwargs)
+    built.run_optimization()
+
+    np.testing.assert_array_equal(built.optimize_results.x, via_minimize.x)
+    assert built.optimize_results.nit == via_minimize.nit
+
+
+def test_line_search_recomputes_the_gradient_and_retries(tmp_path, monkeypatch):
+    """`recompute_jac` cleared the gradient and then took `-None` as the next direction."""
+    monkeypatch.chdir(tmp_path)
+    calls = []
+
+    def flaky_der(x):
+        calls.append(1)
+        return -rosen_der(x) if len(calls) == 1 else rosen_der(x)   # first call: an ascent direction
+
+    res = LineSearch.minimize(np.array([-1.2, 1.0]), rosen, jac=flaky_der, method="GD", lsmethod=0,
+                              lsmaxiter=5, recompute_jac=1, maxiter=3, logit=False)
+    assert res.nit >= 1
+    assert len(calls) >= 3                                          # the bad one, the recomputed one, the accepted step's
+
+
+@pytest.mark.parametrize("cls", [FixedStepDescent])
+def test_log_columns_default_names_the_iteration_and_objective(cls, tmp_path, monkeypatch):
+    monkeypatch.chdir(tmp_path)
+    opt = cls(np.array([3.0]), quadratic, jac=quadratic_jac, logit=False)
+    opt._start()
+    assert opt.log_columns() == {"iter.": 0, "fun": 4.0}
diff --git a/tests/optimization/test_popt_fixes.py b/tests/optimization/test_popt_fixes.py
new file mode 100644
index 00000000..8800ad1b
--- /dev/null
+++ b/tests/optimization/test_popt_fixes.py
@@ -0,0 +1,87 @@
+"""Regression tests for verified bugs in popt's numerical subroutines."""
+
+import numpy as np
+import pytest
+
+from popt.misc_tools import optim_tools as ot
+from popt.optimization_methods.subroutines.optimizers import Steihaug
+from popt.optimization_methods.subroutines.subroutines import newton_cg
+
+
+def test_steihaug_tau_lands_exactly_on_the_trust_region_boundary():
+    """Only the square root used to be divided by ||d||^2."""
+    rng = np.random.default_rng(0)
+    rule = Steihaug(delta0=1.0)
+    rule.delta = 1.0
+    for _ in range(5):
+        p = rng.standard_normal(4) * 0.3          # inside the region
+        d = rng.standard_normal(4)
+        tau = rule.get_tau(p, d)
+        assert tau > 0
+        assert np.linalg.norm(p + tau * d) == pytest.approx(1.0, rel=1e-12)
+
+
+def test_newton_cg_returns_a_direction_when_it_runs_out_of_iterations():
+    """It used to fall off the loop and return None."""
+    H = np.diag([1.0, 10.0, 100.0])              # needs three CG steps
+    g = np.array([1.0, 1.0, 1.0])
+    d = newton_cg(g, H, maxiter=1, logger=lambda *a: None)
+    assert isinstance(d, np.ndarray) and d.shape == g.shape
+    assert np.dot(d, g) < 0                       # still a descent direction
+
+
+def test_newton_cg_with_no_iterations_falls_back_to_steepest_descent():
+    g = np.array([1.0, -2.0])
+    np.testing.assert_array_equal(newton_cg(g, np.eye(2), maxiter=0, logger=lambda *a: None), -g)
+
+
+@pytest.mark.parametrize(
+    "bounds, expected",
+    [
+        ([(0.0, 0.0), (0.0, 0.0)], [0.0, 0.0]),          # zero bounds used to be treated as no bounds
+        ([(None, 1.0), (-1.0, None)], [1.0, -1.0]),      # None means open on that side
+        ([(None, None), (None, None)], [5.0, -5.0]),     # fully open: unchanged
+        ([(-2.0, 2.0), (-2.0, 2.0)], [2.0, -2.0]),
+    ],
+)
+def test_clip_state_respects_every_kind_of_bound(bounds, expected):
+    np.testing.assert_array_equal(ot.clip_state(np.array([5.0, -5.0]), bounds), expected)
+
+
+# ----------------------------------------------------------------------
+# Backtracking factor: every step rule takes it, and EnOpt passes it through.
+# ----------------------------------------------------------------------
+
+from types import SimpleNamespace  # noqa: E402
+
+from scipy.optimize import rosen, rosen_der  # noqa: E402
+
+from popt.optimization_methods import EnOpt, LineSearch  # noqa: E402
+from popt.optimization_methods.subroutines.optimizers import Adam, GradientDescent  # noqa: E402
+
+
+@pytest.mark.parametrize("make, attr", [
+    (lambda: Adam(0.1, 0.0), "_step_size"),
+    (lambda: Steihaug(delta0=3.0), "delta"),
+    (lambda: GradientDescent(0.1, 0.0), "_step_size"),
+])
+def test_every_step_rule_scales_by_the_backtracking_factor(make, attr):
+    rule = make()
+    before = getattr(rule, attr)
+    rule.apply_backtracking(1.0)
+    assert getattr(rule, attr) == before                  # factor 1 is a no-op ...
+    rule.apply_backtracking(0.25)
+    assert getattr(rule, attr) == pytest.approx(0.25 * before)   # ... and the factor is honoured
+
+
+def test_enopt_no_longer_halves_adam_before_the_first_attempt():
+    host = SimpleNamespace(optimizer=Adam(0.1, 0.0))
+    EnOpt._apply_optimizer_backtracking(host, 1.0)
+    assert host.optimizer._step_size == 0.1
+
+
+def test_line_search_iteration_cap_reaches_the_line_search():
+    """`lsmaxiter` was stored under a key the subroutines never read."""
+    ls = LineSearch(np.array([-1.2, 1.0]), rosen, jac=rosen_der, lsmaxiter=3, maxiter=1)
+    assert ls.line_search_options["maxiter"] == 3
+    assert "lsmaxiter" not in ls.line_search_options
diff --git a/tests/optimization/test_trust_region.py b/tests/optimization/test_trust_region.py
new file mode 100644
index 00000000..6f898dd7
--- /dev/null
+++ b/tests/optimization/test_trust_region.py
@@ -0,0 +1,124 @@
+import numpy as np
+import pytest
+import os
+from scipy.optimize import rosen, rosen_der, rosen_hess
+from pathlib import Path
+
+from popt.optimization_methods import TrustRegion
+
+
+def test_trust_region_iterative(tmp_path: Path):
+    """Verify iterative trust-region converges with and without bound transforms."""
+    os.chdir(tmp_path)
+
+    x0 = np.array([-1.2, -1.0])
+    bounds = [(-2.0, 2.0), (-2.0, 2.0)]
+    expected = np.array([1.0, 1.0])
+
+    for transform in (False, True):
+        res = TrustRegion.minimize(
+            x0,
+            fun=rosen,
+            jac=rosen_der,
+            hess=rosen_hess,
+            method="iterative",
+            bounds=bounds,
+            transform=transform,
+        )
+        np.testing.assert_allclose(res.x, expected, atol=1e-4)
+
+
+def test_trust_region_cg_steihaug(tmp_path: Path):
+    """Verify CG-Steihaug trust-region converges with and without bound transforms."""
+    os.chdir(tmp_path)
+
+    x0 = np.array([-1.2, -1.0])
+    bounds = [(-2.0, 2.0), (-2.0, 2.0)]
+    expected = np.array([1.0, 1.0])
+
+    for transform in (False, True):
+        res = TrustRegion.minimize(
+            x0,
+            fun=rosen,
+            jac=rosen_der,
+            hess=rosen_hess,
+            method="CG-Steihaug",
+            bounds=bounds,
+            transform=transform,
+        )
+        np.testing.assert_allclose(res.x, expected, atol=1e-4)
+
+def test_trust_region_bfgs(tmp_path: Path):
+    """Verify BFGS trust-region converges with and without bound transforms."""
+    os.chdir(tmp_path)
+
+    x0 = np.array([-1.2, -1.0])
+    bounds = [(-2.0, 2.0), (-2.0, 2.0)]
+    expected = np.array([1.0, 1.0])
+
+    for method in ("iterative", "CG-Steihaug"):
+        for transform in (False, True):
+            res = TrustRegion.minimize(
+                x0,
+                fun=rosen,
+                jac=rosen_der,
+                hess="BFGS",
+                method=method,
+                bounds=bounds,
+                transform=transform,
+            )
+            np.testing.assert_allclose(res.x, expected, atol=1e-4)
+
+
+def test_trust_region_restart(tmp_path: Path):
+    """Verify restart save and resume behavior for BFGS trust-region."""
+    restart_path = tmp_path / "trust_region_restart.pkl"
+    interrupt_iteration = 4
+    x0 = np.array([-1.2, -1.0])
+
+    def stop_after_checkpoint(opt):
+        if opt.iteration == interrupt_iteration:
+            raise RuntimeError("Intentional stop after checkpoint")
+
+    with pytest.raises(RuntimeError, match="Intentional stop after checkpoint"):
+        TrustRegion.minimize(
+            x0,
+            fun=rosen,
+            jac=rosen_der,
+            hess="BFGS",
+            method="iterative",
+            callback=stop_after_checkpoint,
+            restartsave=True,
+            restart_file=restart_path,
+        )
+    assert restart_path.exists(), "Expected callback to save a restart file."
+
+    def verify_resume_progress(opt):
+        assert opt.iteration >= interrupt_iteration, (
+            "Expected resumed optimization to continue after the interrupted iteration."
+        )
+
+    resumed = TrustRegion.minimize(
+        x0,
+        fun=rosen,
+        jac=rosen_der,
+        hess="BFGS",
+        method="iterative",
+        callback=verify_resume_progress,
+        restart=True,
+        restart_file=restart_path,
+    )
+
+    reference = TrustRegion.minimize(
+        x0,
+        fun=rosen,
+        jac=rosen_der,
+        hess="BFGS",
+        method="iterative",
+    )
+
+    assert resumed.message == reference.message
+    for key in ["x", "fun", "nfev", "njev", "nit"]:
+        assert np.allclose(resumed[key], reference[key]), (
+            f"Mismatch in {key} between resumed and reference optimization."
+        )
diff --git a/tests/test_cli.py b/tests/test_cli.py
new file mode 100644
index 00000000..a64f1637
--- /dev/null
+++ b/tests/test_cli.py
@@ -0,0 +1,80 @@
+"""Tests for the `pet` command-line interface."""
+
+
+
+from pet_cli.__main__ import main
+
+MINIMAL_PIPT = """\
+DATAASSIM
+
+DAALG
+esmda\tesmda
+
+DATA
+truedata.csv
+
+DATAVAR
+var.csv
+
+OBSNAME
+obs
+
+ENERGY
+0.99
+
+FWDSIM
+
+PARALLEL
+1
+
+DATATYPE
+pressure
+
+"""
+
+
+def test_version(capsys):
+    assert main(["version"]) == 0
+    out = capsys.readouterr().out
+    assert out.strip()
+
+
+def test_validate_missing_file(capsys):
+    assert main(["validate", "does_not_exist.toml"]) == 1
+    assert "no such file" in capsys.readouterr().err
+
+
+def test_validate_valid_toml(tmp_path, capsys):
+    config_file = tmp_path / "config.toml"
+    config_file.write_text(
+        '[dataassim]\nscheme = "esmda"\ndata = "d.csv"\ndatavar = "v.csv"\n'
+        'obsname = "obs"\nenergy = 0.99\n\n[fwdsim]\nparallel = 1\ndatatype = ["pressure"]\n'
+    )
+    assert main(["validate", str(config_file)]) == 0
+    assert "No problems found." in capsys.readouterr().out
+
+
+def test_validate_reports_missing_mandatory_keyword(tmp_path, capsys):
+    config_file = tmp_path / "config.toml"
+    config_file.write_text('[fwdsim]\nparallel = 1\n')
+    assert main(["validate", str(config_file)]) == 1
+    assert "[simulator] datatype: required" in capsys.readouterr().out
+
+
+def test_convert_pipt_to_toml(tmp_path, capsys):
+    pipt_file = tmp_path / "case.pipt"
+    pipt_file.write_text(MINIMAL_PIPT)
+
+    assert main(["convert", str(pipt_file), "--to", "toml"]) == 0
+
+    toml_file = tmp_path / "case.toml"
+    assert toml_file.is_file()
+    assert "Wrote" in capsys.readouterr().out
+
+
+def test_convert_pipt_to_yaml(tmp_path):
+    pipt_file = tmp_path / "case.pipt"
+    pipt_file.write_text(MINIMAL_PIPT)
+
+    assert main(["convert", str(pipt_file), "--to", "yaml"]) == 0
+    assert (tmp_path / "case.yaml").is_file()
diff --git a/tests/test_config_boundary.py b/tests/test_config_boundary.py
new file mode 100644
index 00000000..727fdfec
--- /dev/null
+++ b/tests/test_config_boundary.py
@@ -0,0 +1,75 @@
+"""One boundary turns whatever a config looks like into the one form PET reads, and says what would fail."""
+
+import pytest
+
+from input_output import config, read_config
+from input_output.config import ConfigError
+
+
+def test_aliases_flags_and_row_blocks_become_canonical_and_the_caller_is_untouched():
+    raw = {"scheme": "esmda", "truedata": "d.pkl", "var": "v.pkl", "save_folder": "out", "restartfile": "r.pkl",
+           "emp_cov": "yes", "scale_data": "no", "restart": "true", "iteration": [["max_iter", 3], ["lambda", 1.0]],
+           "prior_x": [["mean", 1.0], ["var", 2.0]]}
+    before = {key: (list(value) if isinstance(value, list) else value) for key, value in raw.items()}
+
+    normalised = config.normalize_dataassim(raw)
+
+    assert normalised["data"] == "d.pkl" and normalised["datavar"] == "v.pkl"
+    assert normalised["savefolder"] == "out" and normalised["restart_file"] == "r.pkl"
+    assert normalised["emp_cov"] is True and normalised["scale_data"] is False and normalised["restart"] is True
+    assert normalised["iteration"] == {"max_iter": 3, "lambda": 1.0}
+    assert normalised["prior_x"] == {"mean": 1.0, "var": 2.0}
+    assert raw == before                                    # a copy was normalised, not the caller's dict
+    assert config.normalize_dataassim(normalised) == normalised   # idempotent
+
+
+def test_the_canonical_spelling_wins_when_both_are_given():
+    assert config.normalize_dataassim({"data": "new.pkl", "truedata": "old.pkl"})["data"] == "new.pkl"
+    assert config.normalize_ensemble({"importstaticvar": "a.npz", "save_folder": "f"}) == {"importstate": "a.npz", "savefolder": "f"}
+
+
+def test_validate_names_the_section_and_key():
+    problems = config.validate({"scheme": "esmda"}, {"parallel": 1}, {"state": ["x"]})
+    messages = [str(p) for p in problems]
+    assert "[dataassim] data: required: the observed data" in messages
+    assert "[dataassim] datavar: required: the observation variance" in messages
+    assert any(m.startswith("[dataassim] obsname") for m in messages)
+    assert any(m.startswith("[simulator] datatype") for m in messages)
+    assert any(m.startswith("[ensemble] ne") for m in messages)
+    assert any(m.startswith("[ensemble] prior_x") for m in messages)
+    fatal = {p.key for p in config.fatal_problems({"scheme": "esmda"}, {"parallel": 1}, {"state": ["x"]})}
+    assert fatal == {"data", "datavar", "obsname", "prior_x"}     # `ne` has a default, `datatype` can come from the data file
+
+
+def test_a_complete_config_has_no_problems_and_unknown_keys_are_pointed_out():
+    prb = {"scheme": "esmda", "data": "d.pkl", "datavar": "v.pkl", "obsname": "t", "restartsve": True}
+    ens = {"ne": 5, "state": ["x"], "prior_x": {"var": 1.0}}
+    assert config.validate(prb, {"datatype": ["x"]}, ens) == []
+    assert config.unknown_keys(prb, ens) == ["[dataassim] restartsve"]
+
+
+def test_every_reader_returns_three_normalised_sections(tmp_path):
+    (tmp_path / "c.toml").write_text('[dataassim]\nscheme = "esmda"\ntruedata = "d.pkl"\ndatavar = "v.pkl"\nobsname = "t"\n'
+                                     'emp_cov = "yes"\n[fwdsim]\ndatatype = ["x"]\n')
+    (tmp_path / "c.yaml").write_text('dataassim:\n  scheme: esmda\n  truedata: d.pkl\n  datavar: v.pkl\n  obsname: t\n'
+                                     '  emp_cov: "yes"\nfwdsim:\n  datatype: [x]\n')
+    (tmp_path / "c.pipt").write_text("DATAASSIM\n\nSCHEME\nesmda\n\nTRUEDATA\nd.pkl\n\nDATAVAR\nv.pkl\n\nOBSNAME\nt\n\n"
+                                     "EMP_COV\nyes\n\nFWDSIM\n\nDATATYPE\nx\n\nPARALLEL\n1\n")
+    for name in ("c.toml", "c.yaml", "c.pipt"):
+        sections = read_config.read(str(tmp_path / name))
+        assert len(sections) == 3, name
+        prb, sim, ens = sections
+        assert prb["data"] == "d.pkl" and "truedata" not in prb, name
+        assert prb["emp_cov"] is True, name
+        assert sim["datatype"] == ["x"] and ens == {}, name
+
+
+def test_building_an_ensemble_reports_what_is_missing_and_leaves_the_config_alone():
+    from pipt.ensembles import AssimilationEnsemble
+    from simulator.vanderpol import VanDerPolOscillator
+
+    keys_da = {"scheme": "esmda", "obsname": "steps"}     # no data, no variance
+    keys_en = {"ne": 4, "state": ["x1"], "prior_x1": {"var": 1.0}}
+    with pytest.raises(ConfigError, match=r"\[dataassim\] data: required.*\n.*\[dataassim\] datavar: required"):
+        AssimilationEnsemble(keys_da, keys_en, VanDerPolOscillator({"reporttype": "steps", "reportpoints": [1], "datatype": ["x1"]}))
+    assert keys_da == {"scheme": "esmda", "obsname": "steps"}
diff --git a/tests/test_data_layout.py b/tests/test_data_layout.py
new file mode 100644
index 00000000..bfe74216
--- /dev/null
+++ b/tests/test_data_layout.py
@@ -0,0 +1,56 @@
+"""`DataLayout` is the one order every data array follows, derived from the observed frame."""
+
+import numpy as np
+import pandas as pd
+import pytest
+
+from misc.structures import DataLayout, PETDataFrame
+
+
+def _frame(missing=False):
+    df = pd.DataFrame(index=pd.Index([1, 2, 3], name="time"), columns=["WOPR", "SEIS"], dtype=object)
+    df.at[1, "WOPR"], df.at[2, "WOPR"], df.at[3, "WOPR"] = 10.0, 20.0, 30.0
+    df.at[1, "SEIS"] = np.array([1.0, 2.0, 3.0, 4.0])
+    df.at[2, "SEIS"] = None if missing else np.array([5.0, 6.0, 7.0, 8.0])
+    df.at[3, "SEIS"] = np.nan
+    return PETDataFrame.from_pandas(df)
+
+
+def test_rows_follow_the_frame_walk_and_skip_empty_cells():
+    layout = DataLayout.from_frame(_frame(missing=True))
+    assert [(r.label, r.datatype, r.start, r.stop) for r in layout.rows] == [
+        (1, "WOPR", 0, 1), (1, "SEIS", 1, 5), (2, "WOPR", 5, 6), (3, "WOPR", 6, 7)]
+    assert layout.nd == 7
+    assert layout.row(1, "SEIS").size == 4
+    with pytest.raises(KeyError):
+        layout.row(2, "SEIS")
+    assert list(layout.row_datatypes()) == ["WOPR", "SEIS", "SEIS", "SEIS", "SEIS", "WOPR", "WOPR"]
+
+
+@pytest.mark.parametrize("missing", [False, True])
+def test_the_vector_is_what_the_frame_flatten_produced(missing):
+    frame = _frame(missing)
+    np.testing.assert_array_equal(DataLayout.from_frame(frame).vector(frame), frame.to_matrix())
+
+
+def test_an_ensemble_frame_reads_back_as_the_matrix_and_the_matrix_views_as_the_frame():
+    layout = DataLayout.from_frame(_frame())
+    ne = 3
+    matrix = np.arange(layout.nd * ne, dtype=float).reshape(layout.nd, ne)
+
+    view = layout.to_frame(matrix)
+    assert view.is_ensemble
+    assert view.at[1, "WOPR"].shape == (ne,) and view.at[1, "SEIS"].shape == (4, ne)
+    assert view.at[3, "SEIS"] is None
+    np.testing.assert_array_equal(view.to_matrix(), matrix)               # the legacy flatten agrees
+    np.testing.assert_array_equal(layout.matrix(view, ne), matrix)        # and so does the layout read
+
+
+def test_an_observation_vector_views_as_the_original_frame():
+    frame = _frame()
+    layout = DataLayout.from_frame(frame)
+    view = layout.to_frame(layout.vector(frame))
+    assert view.at[2, "WOPR"] == 20.0
+    np.testing.assert_array_equal(view.at[2, "SEIS"], [5.0, 6.0, 7.0, 8.0])
+    assert view.at[3, "SEIS"] is None
+    assert view.index.name == "time" and list(view.columns) == ["WOPR", "SEIS"]
diff --git a/tests/test_import_hygiene.py b/tests/test_import_hygiene.py
new file mode 100644
index 00000000..13687cc2
--- /dev/null
+++ b/tests/test_import_hygiene.py
@@ -0,0 +1,81 @@
+"""Guards against import cycles between the top-level packages.
+
+``ensemble`` is the foundation package that both ``pipt`` and ``popt`` build on.
+If it imports from either of them at module level, the layering inverts and
+importing ``ensemble`` first raises a partially-initialized-module error.
+
+That regression existed for a long time without being noticed, because the full
+test suite happened to import the packages in an order that avoided it -- only
+running a single test file surfaced it. These tests each import in a fresh
+subprocess so import order cannot mask the problem.
+"""
+
+import subprocess
+import sys
+
+import pytest
+
+TOP_LEVEL_PACKAGES = ["ensemble", "misc", "input_output", "pet_cli", "pipt", "popt", "simulator"]
+
+
+@pytest.mark.parametrize("package", TOP_LEVEL_PACKAGES)
+def test_package_imports_standalone(package):
+    """Each package must import cleanly as the very first import."""
+    result = subprocess.run(
+        [sys.executable, "-c", f"import {package}"],
+        capture_output=True,
+        text=True,
+    )
+    assert result.returncode == 0, (
+        f"`import {package}` failed as a first import:\n{result.stderr}"
+    )
+
+
+def test_ensemble_does_not_import_pipt_or_popt_at_module_level():
+    """The foundation package must not depend upward at import time.
+
+    Uses a fresh interpreter and checks which modules are resolved: importing
+    ``ensemble`` must not drag in ``pipt`` or ``popt``.
+    """
+    code = (
+        "import sys; import ensemble; "
+        "print(','.join(sorted(m for m in sys.modules "
+        "if m.split('.')[0] in ('pipt', 'popt'))))"
+    )
+    result = subprocess.run(
+        [sys.executable, "-c", code], capture_output=True, text=True
+    )
+    assert result.returncode == 0, result.stderr
+
+    leaked = [m for m in result.stdout.strip().split(",") if m]
+    assert not leaked, (
+        "Importing `ensemble` pulled in upward dependencies: "
+        f"{leaked}. Keep pipt/popt imports inside the functions that use them."
+    )
+
+
+def _modules_loaded_by(statement):
+    """Run ``statement`` in a fresh interpreter and return the modules it loaded."""
+    code = f"import sys; {statement}; print(','.join(sorted(sys.modules)))"
+    result = subprocess.run(
+        [sys.executable, "-c", code], capture_output=True, text=True
+    )
+    assert result.returncode == 0, result.stderr
+    return set(result.stdout.strip().split(","))
+
+
+def test_pipt_does_not_import_plotting_or_wavelets_at_module_level():
+    """QA/QC (matplotlib, cv2) and sparse compression (PyWavelets) are
+    optional features; a run that does not ask for them must not pay their
+    import cost, and a machine without them must still be able to assimilate."""
+    loaded = _modules_loaded_by("import pipt")
+    heavy = {"cv2", "pywt", "matplotlib.pyplot"}
+    assert not (loaded & heavy), f"`import pipt` loaded {sorted(loaded & heavy)}"
+
+
+def test_misc_does_not_import_pipt_or_geostat_at_module_level():
+    """``misc`` sits below ``pipt``: its data structures and readers must not
+    depend upward, nor need the geostat git dependency, at import time."""
+    loaded = _modules_loaded_by("import misc.structures, misc.read_input_csv")
+    upward = sorted(m for m in loaded if m.split(".")[0] in ("pipt", "popt", "geostat"))
+    assert not upward, f"importing misc pulled in {upward}"
diff --git a/tests/test_linear.py b/tests/test_linear.py
deleted file mode 100644
index 1d4d7cae..00000000
--- a/tests/test_linear.py
+++ /dev/null
@@ -1,41 +0,0 @@
-import os
-import sys
-from pathlib import Path, PosixPath
-
-import numpy as np
-import subprocess
-
-# Logger (since we cannot print during testing)
-# -- there is probably a more official way to do this.
-logfile = Path.cwd() / "PET-test-log"
-with open(logfile, "w") as file:
-    pass
-def prnt(*args, **kwargs):
-    with open(logfile, "a") as file:
-        print(*args, **kwargs, file=file)
-
-
-def test_git_clone(temp_examples_dir):
-    # prnt(cwd)
-    # prnt(os.listdir(cwd))
-    assert (temp_examples_dir / "3Spot").is_dir()
-
-
-def test_mod(temp_examples_dir: PosixPath):
-    """Validate a few values of the result of the `LinearModel` example."""
-    cwd = temp_examples_dir / "LinearModel"
-    old = Path.cwd()
-
-    try:
-        os.chdir(cwd)
-        sys.path.append(str(cwd))
-        subprocess.run(["python", "write_true_and_data.py"], cwd=temp_examples_dir)
-        import run_script
-    finally:
-        os.chdir(old)
-
-    result = run_script.assimilation.ensemble.enX.mean(axis=1)
-    np.testing.assert_array_almost_equal(
-        result[[1, 2, 3, -3, -2, -1]],
-        [-0.07294738, 0.00353635, -0.06393236, 0.45394362, 0.44388684, 0.37096157],
-        decimal=5)
diff --git a/tests/test_logging_and_paths.py b/tests/test_logging_and_paths.py
new file mode 100644
index 00000000..452b78db
--- /dev/null
+++ b/tests/test_logging_and_paths.py
@@ -0,0 +1,66 @@
+"""Library code keeps to its own logger and its own folder."""
+
+import logging
+from types import SimpleNamespace
+
+import numpy as np
+
+from ensemble.ensemble import BaseEnsemble
+from ensemble.logger import PetLogger
+from pipt.ensembles.forecast import ForecastMixin
+
+
+def test_two_loggers_write_to_their_own_files(tmp_path):
+    """A second PetLogger used to log into the first one's file: basicConfig
+    configures the root logger once per process and is a no-op afterwards."""
+    first = PetLogger(str(tmp_path / "first.log"))
+    second = PetLogger(str(tmp_path / "second.log"))
+    first("one")
+    second("two")
+    for handler in first._logger.handlers + second._logger.handlers:
+        handler.flush()
+
+    assert "one" in (tmp_path / "first.log").read_text() and "two" not in (tmp_path / "first.log").read_text()
+    assert "two" in (tmp_path / "second.log").read_text() and "one" not in (tmp_path / "second.log").read_text()
+
+
+def test_a_logger_does_not_configure_the_root_logger(tmp_path):
+    before = list(logging.getLogger().handlers)
+    PetLogger(str(tmp_path / "x.log"))
+    assert list(logging.getLogger().handlers) == before
+
+
+def test_the_log_file_is_written_as_utf8(tmp_path):
+    """The timestamp format embeds U+2502 and the tables draw with box characters.
+    Opened in the OS default encoding, every record raised UnicodeEncodeError on a
+    cp1252 Windows and the file stayed empty while the run carried on regardless."""
+    logger = PetLogger(str(tmp_path / "encoding.log"))
+    logger("one")
+    file_handlers = [h for h in logger._logger.handlers if isinstance(h, logging.FileHandler)]
+    for handler in file_handlers:
+        handler.flush()
+
+    assert [h.encoding for h in file_handlers] == ["utf-8"]
+    assert "│" in (tmp_path / "encoding.log").read_text(encoding="utf-8")
+
+
+def test_save_folder_is_not_created_by_reading_it(tmp_path, monkeypatch):
+    monkeypatch.chdir(tmp_path)
+    host = object.__new__(ForecastMixin)
+    host.keys_da = {"savefolder": "Out"}
+
+    assert host.save_folder == "Out"
+    assert not (tmp_path / "Out").exists()          # reading creates nothing ...
+    assert host._save_path("a.npz") == "Out/a.npz"
+    assert (tmp_path / "Out").is_dir()               # ... writing does
+
+
+def test_all_members_failing_raises_instead_of_exiting():
+    host = SimpleNamespace(logger=SimpleNamespace(info=lambda m: None), save=lambda: None, rng=np.random)
+    enX = np.zeros((2, 3))
+    try:
+        BaseEnsemble._replace_failed_simulations(host, [False, False, False], enX)
+    except RuntimeError as err:
+        assert "All started simulations failed" in str(err)
+    else:
+        raise AssertionError("expected a RuntimeError")
diff --git a/tests/test_migrate.py b/tests/test_migrate.py
new file mode 100644
index 00000000..db766657
--- /dev/null
+++ b/tests/test_migrate.py
@@ -0,0 +1,375 @@
+"""Tests for `pet migrate` and the config-schema change it implements."""
+
+import pytest
+
+from pet_cli.__main__ import main
+from pet_cli.migrate import MigrationReport, migrate_config, migrate_section
+
+LEGACY_TOML = """\
+[dataassim]
+daalg = ["esmda", "esmda"]
+analysis = "approx"
+energy = 0.99
+
+[fwdsim]
+parallel = 1
+datatype = ["pressure"]
+"""
+
+
+def _write(tmp_path, name, text):
+    path = tmp_path / name
+    path.write_text(text)
+    return path
+
+
+# ----------------------------------------------------------------------
+# Section-level migration
+# ----------------------------------------------------------------------
+
+def test_section_daalg_to_scheme():
+    report = MigrationReport()
+    section = migrate_section({"daalg": ["esmda", "esmda"], "analysis": "approx"}, report)
+    assert section["scheme"] == "esmda"
+    assert "daalg" not in section
+    assert report.changed
+
+
+def test_section_keeps_second_entry_and_warns_on_mismatch():
+    """The second entry is the one that selected the class historically."""
+    report = MigrationReport()
+    section = migrate_section({"daalg": ["enrml", "lmenrml"], "analysis": "full"}, report)
+    assert section["scheme"] == "lmenrml"
+    assert any("differing entries" in w for w in report.warnings)
+
+
+def test_section_accepts_bare_string():
+    report = MigrationReport()
+    assert migrate_section({"daalg": "esmda", "analysis": "approx"}, report)["scheme"] == "esmda"
+
+
+def test_section_warns_when_analysis_missing():
+    report = MigrationReport()
+    migrate_section({"daalg": ["esmda", "esmda"]}, report)
+    assert any("analysis" in w for w in report.warnings)
+
+
+def test_section_without_daalg_is_untouched():
+    report = MigrationReport()
+    section = migrate_section({"scheme": "esmda", "analysis": "approx"}, report)
+    assert section == {"scheme": "esmda", "analysis": "approx"}
+    assert not report.changed
+
+
+def test_section_leaves_unexpected_daalg_alone():
+    report = MigrationReport()
+    section = migrate_section({"daalg": 42}, report)
+    assert section["daalg"] == 42
+    assert report.warnings
+
+
+# ----------------------------------------------------------------------
+# File-level migration
+# ----------------------------------------------------------------------
+
+def test_migrate_toml_writes_backup(tmp_path):
+    path = _write(tmp_path, "case.toml", LEGACY_TOML)
+    report = migrate_config(path)
+    assert report.changed
+    assert (tmp_path / "case.toml.bak").exists()
+    assert "scheme" in path.read_text()
+    assert "daalg" not in path.read_text()
+
+
+def test_migrate_preserves_other_keys(tmp_path):
+    import tomli
+
+    path = _write(tmp_path, "case.toml", LEGACY_TOML)
+    migrate_config(path)
+    with open(path, "rb") as handle:
+        cfg = tomli.load(handle)
+    assert cfg["dataassim"]["analysis"] == "approx"
+    assert cfg["dataassim"]["energy"] == 0.99
+    assert cfg["fwdsim"]["datatype"] == ["pressure"]
+
+
+def test_migrate_dry_run_writes_nothing(tmp_path):
+    path = _write(tmp_path, "case.toml", LEGACY_TOML)
+    before = path.read_text()
+    report = migrate_config(path, dry_run=True)
+    assert report.changed
+    assert path.read_text() == before
+    assert not (tmp_path / "case.toml.bak").exists()
+
+
+def test_migrate_is_idempotent(tmp_path):
+    path = _write(tmp_path, "case.toml", LEGACY_TOML)
+    migrate_config(path)
+    assert not migrate_config(path).changed
+
+
+def test_migrate_yaml(tmp_path):
+    import yaml
+
+    path = _write(
+        tmp_path, "case.yaml",
+        "dataassim:\n  daalg: [esmda, esmda]\n  analysis: approx\n",
+    )
+    migrate_config(path)
+    cfg = yaml.safe_load(path.read_text())
+    assert cfg["dataassim"]["scheme"] == "esmda"
+
+
+def test_migrate_rejects_unsupported_format(tmp_path):
+    path = _write(tmp_path, "case.pipt", "DATAASSIM\n")
+    with pytest.raises(ValueError, match="only .toml and .yaml"):
+        migrate_config(path)
+
+
+def test_migrate_handles_optim_section(tmp_path):
+    path = _write(tmp_path, "case.toml", '[optim]\ndaalg = ["esmda", "esmda"]\nanalysis = "approx"\n')
+    assert migrate_config(path).changed
+
+
+# ----------------------------------------------------------------------
+# CLI
+# ----------------------------------------------------------------------
+
+def test_cli_migrate(tmp_path, capsys):
+    path = _write(tmp_path, "case.toml", LEGACY_TOML)
+    assert main(["migrate", str(path)]) == 0
+    out = capsys.readouterr().out
+    assert "scheme = 'esmda'" in out
+    assert ".bak" in out
+
+
+def test_cli_migrate_no_backup(tmp_path):
+    path = _write(tmp_path, "case.toml", LEGACY_TOML)
+    assert main(["migrate", str(path), "--no-backup"]) == 0
+    assert not (tmp_path / "case.toml.bak").exists()
+
+
+def test_cli_migrate_missing_file(capsys):
+    assert main(["migrate", "nope.toml"]) == 1
+    assert "no such file" in capsys.readouterr().err
+
+
+def test_cli_migrate_already_current(tmp_path, capsys):
+    path = _write(tmp_path, "case.toml", '[dataassim]\nscheme = "esmda"\nanalysis = "approx"\n')
+    assert main(["migrate", str(path)]) == 0
+    assert "already on the current schema" in capsys.readouterr().out
+
+
+# ----------------------------------------------------------------------
+# init_da must point users at the tool rather than failing cryptically
+# ----------------------------------------------------------------------
+
+def test_init_da_rejects_legacy_daalg_with_migration_hint():
+    from pipt import pipt_init
+
+    with pytest.raises(ValueError, match="pet migrate"):
+        pipt_init.init_da({"daalg": ["esmda", "esmda"], "analysis": "approx"}, {}, None)
+
+
+def test_init_da_accepts_new_scheme_key():
+    from pipt import pipt_init
+    from pipt.update_schemes import registry
+
+    class Spy:
+        def __init__(self, da, en, sim):
+            self.ok = True
+
+    registry.register_scheme("spy", "approx", Spy)
+    try:
+        obj = pipt_init.init_da({"scheme": "spy", "analysis": "approx"}, {}, None)
+        assert obj.ok
+    finally:
+        registry.SPECIAL_SCHEMES.pop(("spy", "approx"), None)
+
+
+def test_init_da_rejects_non_string_scheme():
+    from pipt import pipt_init
+
+    with pytest.raises(ValueError, match="as a string"):
+        pipt_init.init_da({"scheme": ["esmda"], "analysis": "approx"}, {}, None)
+
+
+# ----------------------------------------------------------------------
+# Formatting preservation
+#
+# A round trip through a TOML/YAML writer discards everything that is not
+# data. Real configs carry comments, commented-out alternative blocks,
+# hand-aligned columns and inline tables, so the migration must edit the
+# daalg line in place instead.
+# ----------------------------------------------------------------------
+
+REALISTIC_TOML = """\
+[ensemble]
+    ne = 100
+    state = "PORO"
+    prior_PORO  = {var=1.0, grid=[50, 50]} # var is used for scaling
+
+[dataassim]
+    daalg       = ["enrml", "gnenrml"]
+    energy      = 99
+    analysis    = "approx"
+
+    # Distance-based localization options
+    #[dataassim.localization]
+    #    name    = "distance_loc"
+    #    field   = [1, 50, 50]   # nz, nx, ny
+
+    [dataassim.localization]
+        name   = "autoadaloc"
+        field  = [50, 50]   # nx, ny
+"""
+
+
+def test_migration_changes_exactly_one_line(tmp_path):
+    path = _write(tmp_path, "case.toml", REALISTIC_TOML)
+    migrate_config(path)
+
+    before = REALISTIC_TOML.split("\n")
+    after = path.read_text().split("\n")
+    assert len(before) == len(after), "line count changed; the file was rewritten"
+
+    differing = [i for i, (a, b) in enumerate(zip(before, after)) if a != b]
+    assert len(differing) == 1, f"expected 1 changed line, got {len(differing)}"
+    assert "daalg" in before[differing[0]]
+    assert 'scheme' in after[differing[0]]
+
+
+def test_comments_and_commented_out_blocks_survive(tmp_path):
+    path = _write(tmp_path, "case.toml", REALISTIC_TOML)
+    migrate_config(path)
+    text = path.read_text()
+
+    assert "# var is used for scaling" in text
+    assert "# Distance-based localization options" in text
+    assert '#    name    = "distance_loc"' in text, "commented-out block was deleted"
+    assert "# nx, ny" in text
+
+
+def test_inline_table_and_indentation_survive(tmp_path):
+    path = _write(tmp_path, "case.toml", REALISTIC_TOML)
+    migrate_config(path)
+    text = path.read_text()
+
+    assert "prior_PORO  = {var=1.0, grid=[50, 50]}" in text, "inline table was expanded"
+    assert "    energy      = 99" in text, "indentation was flattened"
+
+
+def test_aligned_equals_column_is_kept(tmp_path):
+    """`scheme` is one char longer than `daalg`; padding absorbs the difference."""
+    path = _write(tmp_path, "case.toml", REALISTIC_TOML)
+    migrate_config(path)
+
+    lines = [ln for ln in path.read_text().split("\n") if "=" in ln and "#" not in ln]
+    scheme_line = next(ln for ln in lines if "scheme" in ln)
+    energy_line = next(ln for ln in lines if "energy" in ln)
+    assert scheme_line.index("=") == energy_line.index("=")
+
+
+def test_only_the_scheme_key_changes_semantically(tmp_path):
+    import tomli
+
+    path = _write(tmp_path, "case.toml", REALISTIC_TOML)
+    original = tomli.loads(REALISTIC_TOML)
+    migrate_config(path)
+    with open(path, "rb") as handle:
+        migrated = tomli.load(handle)
+
+    assert migrated["dataassim"]["scheme"] == "gnenrml"
+    original["dataassim"].pop("daalg")
+    migrated["dataassim"].pop("scheme")
+    assert original == migrated
+
+
+def test_single_space_spacing_is_left_alone(tmp_path):
+    path = _write(tmp_path, "case.toml", '[dataassim]\ndaalg = ["esmda", "esmda"]\n')
+    migrate_config(path)
+    assert 'scheme = "esmda"' in path.read_text()
+
+
+def test_yaml_inline_form_preserves_comments(tmp_path):
+    path = _write(
+        tmp_path, "case.yaml",
+        "dataassim:\n  # which algorithm\n  daalg: [esmda, esmda]\n  analysis: approx\n",
+    )
+    migrate_config(path)
+    text = path.read_text()
+    assert "# which algorithm" in text
+    assert "scheme:" in text and "daalg" not in text
+
+
+# ----------------------------------------------------------------------
+# analysisdebug -> savedata
+# ----------------------------------------------------------------------
+def test_analysisdebug_is_renamed_to_savedata(tmp_path):
+    path = _write(
+        tmp_path, "case.toml",
+        '[dataassim]\nscheme = "esmda"\nanalysisdebug = ["state", "pred_data"]\n',
+    )
+    report = migrate_config(path)
+
+    text = path.read_text()
+    assert 'savedata = ["state", "pred_data"]' in text
+    assert "analysisdebug" not in text
+    assert any("savedata" in change for change in report.changes)
+
+
+def test_renaming_the_key_preserves_a_multiline_value_and_comments(tmp_path):
+    """Only the name left of the separator moves, so the value is never parsed."""
+    path = _write(
+        tmp_path, "case.toml",
+        '[dataassim]\n'
+        'scheme = "esmda"\n'
+        '# what to record each iteration\n'
+        'analysisdebug = [\n'
+        '    "state",     # the ensemble\n'
+        '    "pred_data",\n'
+        ']\n',
+    )
+    migrate_config(path)
+    text = path.read_text()
+
+    assert "# what to record each iteration" in text
+    assert "# the ensemble" in text
+    assert text.count('"pred_data",\n') == 1
+    assert "savedata = [\n" in text
+
+
+def test_rename_and_daalg_migrate_together(tmp_path):
+    path = _write(
+        tmp_path, "case.toml",
+        '[dataassim]\ndaalg = ["esmda", "esmda"]\nanalysisdebug = ["state"]\n',
+    )
+    migrate_config(path)
+    text = path.read_text()
+
+    assert 'scheme = "esmda"' in text
+    assert 'savedata = ["state"]' in text
+    assert "daalg" not in text and "analysisdebug" not in text
+
+
+def test_both_spellings_present_is_reported_not_guessed(tmp_path):
+    path = _write(
+        tmp_path, "case.toml",
+        '[dataassim]\nscheme = "esmda"\nsavedata = ["state"]\nanalysisdebug = ["pred_data"]\n',
+    )
+    report = migrate_config(path)
+
+    assert any("savedata" in warning for warning in report.warnings)
+    assert "analysisdebug" in path.read_text()
+
+
+def test_yaml_rename_preserves_comments(tmp_path):
+    path = _write(
+        tmp_path, "case.yaml",
+        "dataassim:\n  scheme: esmda\n  # variables to keep\n  analysisdebug: [state]\n",
+    )
+    migrate_config(path)
+    text = path.read_text()
+
+    assert "# variables to keep" in text
+    assert "savedata: [state]" in text and "analysisdebug" not in text
diff --git a/tests/test_misc_fixes.py b/tests/test_misc_fixes.py
new file mode 100644
index 00000000..568b9d32
--- /dev/null
+++ b/tests/test_misc_fixes.py
@@ -0,0 +1,55 @@
+"""Regression tests for verified bugs in the small infrastructure modules."""
+
+import os
+
+import numpy as np
+import pytest
+
+from misc.system_tools.environ_var import OpenBlasSingleThread
+from pipt.localization.factory import build_localization_instance
+from simulator.simple_models import lin_1d, nonlin_onedimmodel
+
+
+def test_single_thread_context_exits_cleanly_when_the_variable_was_unset(monkeypatch):
+    """`__exit__` used to call the nonexistent os.environ.unsetenv."""
+    monkeypatch.delenv("OMP_NUM_THREADS", raising=False)
+    with OpenBlasSingleThread():
+        assert os.environ["OMP_NUM_THREADS"] == "1"
+    assert "OMP_NUM_THREADS" not in os.environ
+
+
+def test_single_thread_context_restores_a_previous_value(monkeypatch):
+    monkeypatch.setenv("OMP_NUM_THREADS", "7")
+    with OpenBlasSingleThread():
+        assert os.environ["OMP_NUM_THREADS"] == "1"
+    assert os.environ["OMP_NUM_THREADS"] == "7"
+
+
+@pytest.mark.parametrize("model", [lin_1d, nonlin_onedimmodel])
+def test_simple_models_return_a_fresh_output_per_member(model):
+    """They returned the shared attribute, so every member aliased the last one."""
+    sim = model({"reporttype": "steps", "reportpoint": [0, 1], "datatype": ["x"]})
+    sim.setup_fwd_run()
+    first = sim.run_fwd_sim({"p": np.array([1.0, 2.0])}, 0)
+    second = sim.run_fwd_sim({"p": np.array([10.0, 20.0])}, 1)
+    assert first is not second
+    assert not np.array_equal(first[0]["x"], second[0]["x"])
+
+
+def test_unknown_localization_name_raises_instead_of_returning_none():
+    with pytest.raises(ValueError, match="Unknown localization type 'banana'"):
+        build_localization_instance({"name": "banana"}, None, None, None, 10)
+
+
+def test_a_block_naming_no_mode_is_inferred_then_refused_by_that_mode():
+    """A nameless block used to be rejected for having no 'name' -- a key its author had
+    never written. The mode is now inferred the way it always was selected; a block that
+    names nothing meant the parallel update, so that is what it is refused as."""
+    with pytest.raises(ValueError, match="parallel update is not supported"):
+        build_localization_instance({}, None, None, None, 10)
+
+
+def test_an_explicitly_empty_localization_name_still_raises():
+    with pytest.raises(ValueError, match="no 'name'"):
+        build_localization_instance({"name": None}, None, None, None, 10)
+
diff --git a/tests/test_pipt_file_parser.py b/tests/test_pipt_file_parser.py
index ad068053..caeb6cf6 100644
--- a/tests/test_pipt_file_parser.py
+++ b/tests/test_pipt_file_parser.py
@@ -1,4 +1,5 @@
 import unittest
+from pathlib import Path
 
 from input_output.read_config import read_clean_file, remove_empty_lines, parse_keywords
 
@@ -10,7 +11,8 @@ class TestPiptInit(unittest.TestCase):
 
     def setUp(self):
         # Read "parser_input.pipt" and parse with core methods in read_txt
-        lines = read_clean_file('tests/parser_input.pipt')
+        parser_input = Path(__file__).with_name('parser_input.pipt')
+        lines = read_clean_file(str(parser_input))
         clean_lines = remove_empty_lines(lines)
         self.keys = parse_keywords(clean_lines)
 
diff --git a/tests/test_predicted_data.py b/tests/test_predicted_data.py
new file mode 100644
index 00000000..886594e7
--- /dev/null
+++ b/tests/test_predicted_data.py
@@ -0,0 +1,80 @@
+"""`PredictedData` is filled straight from the members' outputs, in the layout's row order."""
+
+import numpy as np
+import pandas as pd
+import pytest
+
+from misc.structures import DataLayout, PETDataFrame, PredictedData
+
+
+def _observations():
+    df = pd.DataFrame(index=pd.Index([10, 20, 30], name="time"), columns=["WOPR", "SEIS"], dtype=object)
+    df.at[10, "WOPR"], df.at[20, "WOPR"], df.at[30, "WOPR"] = 1.0, 2.0, 3.0
+    df.at[10, "SEIS"] = np.array([0.1, 0.2])
+    df.at[20, "SEIS"] = None                      # not observed at this label
+    df.at[30, "SEIS"] = np.array([0.3, 0.4])
+    return PETDataFrame.from_pandas(df)
+
+
+def _records(member):
+    """What a simulator returns: one dict per report point, here at times 10, 20, 30 plus an extra one."""
+    return [{"WOPR": 1.0 + member, "SEIS": np.array([0.1, 0.2]) + member, "EXTRA": 99.0},
+            {"WOPR": 2.0 + member, "SEIS": np.array([0.5, 0.6]) + member, "EXTRA": 99.0},   # SEIS here is unobserved: ignored
+            {"WOPR": 3.0 + member, "SEIS": np.array([0.3, 0.4]) + member, "EXTRA": 99.0},
+            {"WOPR": 4.0 + member, "SEIS": np.array([0.7, 0.8]) + member, "EXTRA": 99.0}]   # a report point nobody observed
+
+
+LAYOUT = DataLayout.from_frame(_observations())
+POSITION = {10: 0, 20: 1, 30: 2}
+
+
+def test_records_fill_the_layout_rows_and_nothing_else():
+    pred = PredictedData.from_members(LAYOUT, [_records(0), _records(10)], position=POSITION)
+    assert pred.matrix.shape == (LAYOUT.nd, 2) == (7, 2)
+    np.testing.assert_array_equal(pred.matrix[:, 0], [1.0, 0.1, 0.2, 2.0, 3.0, 0.3, 0.4])
+    np.testing.assert_array_equal(pred.matrix[:, 1], pred.matrix[:, 0] + 10)
+
+
+def test_frames_per_member_fill_the_same_way():
+    frames = [pd.DataFrame.from_records(_records(m), index=[10, 20, 30, 40]) for m in (0, 10)]
+    from_frames = PredictedData.from_members(LAYOUT, frames)
+    from_records = PredictedData.from_members(LAYOUT, [_records(0), _records(10)], position=POSITION)
+    np.testing.assert_array_equal(from_frames.matrix, from_records.matrix)
+
+
+def test_a_member_missing_an_observed_type_or_size_is_reported_not_dropped():
+    broken = _records(0)
+    del broken[2]["WOPR"]
+    with pytest.raises(KeyError, match="no 'WOPR' at 30"):
+        PredictedData.from_members(LAYOUT, [broken], position=POSITION)
+    short = _records(0)
+    short[0]["SEIS"] = np.array([0.1])
+    with pytest.raises(ValueError, match="has 1 values; the observation has 2"):
+        PredictedData.from_members(LAYOUT, [short], position=POSITION)
+
+
+def test_scaling_matches_the_frame_scaling():
+    # The frame's max-min scaling handles scalar cells (a minimum and maximum per data type), so compare on those.
+    obs = PETDataFrame.from_pandas(pd.DataFrame({"WOPR": [1.0, 2.0, 3.0], "WWPR": [5.0, 7.0, 9.0]},
+                                                index=pd.Index([10, 20, 30], name="time")))
+    layout = DataLayout.from_frame(obs)
+    obs.scale("max-min")
+    records = [[{"WOPR": 1.0 + m, "WWPR": 5.0 + 2 * m}, {"WOPR": 2.0 + m, "WWPR": 7.0 + 2 * m}, {"WOPR": 3.0 + m, "WWPR": 9.0 + 2 * m}]
+               for m in (0.0, 0.5)]
+    pred = PredictedData.from_members(layout, records, position=POSITION, scale=(obs.scale_min, obs.scale_max))
+
+    # The frame path: merge the members into cells, scale with the same min/max, flatten.
+    frames = [pd.DataFrame.from_records(r, index=[10, 20, 30]) for r in records]
+    merged = PETDataFrame.merge_dataframes(frames)
+    merged.scale("max-min", minimum=obs.scale_min, maximum=obs.scale_max)
+    np.testing.assert_array_equal(pred.matrix, layout.matrix(merged, 2))
+
+
+def test_the_view_and_member_selection():
+    pred = PredictedData.from_members(LAYOUT, [_records(m) for m in (0, 10, 20)], position=POSITION)
+    view = pred.to_frame()
+    assert view.at[10, "WOPR"].shape == (3,) and view.at[30, "SEIS"].shape == (2, 3) and view.at[20, "SEIS"] is None
+    np.testing.assert_array_equal(view.to_matrix(), pred.matrix)
+    picked = pred.take_members([2, 0])
+    np.testing.assert_array_equal(picked.matrix[:, 0], pred.matrix[:, 2])
+    assert pred.rows_of("SEIS") == [slice(1, 3), slice(5, 7)]
diff --git a/tests/test_quadratic.py b/tests/test_quadratic.py
deleted file mode 100644
index 531b04f9..00000000
--- a/tests/test_quadratic.py
+++ /dev/null
@@ -1,45 +0,0 @@
-import os
-import sys
-from pathlib import Path, PosixPath
-
-import numpy as np
-import subprocess
-
-# Logger (since we cannot print during testing)
-# -- there is probably a more official way to do this.
-logfile = Path.cwd() / "PET-test-log"
-with open(logfile, "w") as file:
-    pass
-
-
-def prnt(*args, **kwargs):
-    with open(logfile, "a") as file:
-        print(*args, **kwargs, file=file)
-
-
-def test_git_clone(temp_examples_dir):
-    # prnt(cwd)
-    # prnt(os.listdir(cwd))
-    assert (temp_examples_dir / "Quadratic").is_dir()
-
-
-def test_mod(temp_examples_dir: PosixPath):
-    """Validate a few values of the result of the `Quadratic` example."""
-    cwd = temp_examples_dir / "Quadratic"
-    old = Path.cwd()
-
-    try:
-        os.chdir(cwd)
-        sys.path.append(str(cwd))
-        import run_opt
-        run_opt.main()
-        files = os.listdir('./')
-        results = [name for name in files if "optimize_result" in name]
-        num_iter = len(results) - 1
-        state = np.load(f'optimize_result_{num_iter}.npz', allow_pickle=True)['x']
-        obj = np.load(f'optimize_result_{num_iter}.npz', allow_pickle=True)['obj_func_values']
-    finally:
-        os.chdir(old)
-
-    np.testing.assert_array_almost_equal(state, [0.5, 0.5], decimal=1)
-    np.testing.assert_array_almost_equal(obj, [0.0], decimal=0)
diff --git a/tests/test_report_point_reader.py b/tests/test_report_point_reader.py
new file mode 100644
index 00000000..cfe877a0
--- /dev/null
+++ b/tests/test_report_point_reader.py
@@ -0,0 +1,117 @@
+import pytest
+import datetime as dt
+import yaml
+
+from input_output.organize import report_point_file_reader
+
+DATETIMES_STR = [
+    "2024-01-01 12:00:00",
+    "2024-01-02 13:30:00",
+    "2024-01-03 14:45:00"
+]
+DATETIMES_STR_ISO = [
+    "2024-01-01T12:00:00",
+    "2024-01-02T13:30:00",
+    "2024-01-03T14:45:00"
+]
+DATETIMES = [
+    dt.datetime(2024, 1, 1, 12, 0, 0),
+    dt.datetime(2024, 1, 2, 13, 30, 0),
+    dt.datetime(2024, 1, 3, 14, 45, 0)
+]
+INDEX = [1, 2, 3]
+
+
+def test_report_point_file_reader_csv_int(tmp_path):
+    # Create a CSV file with integer report points
+    csv_content = "\n".join(str(i) for i in INDEX)
+    csv_file = tmp_path / "test_int.csv"
+    csv_file.write_text(csv_content)
+    points = report_point_file_reader(str(csv_file))
+    assert all(isinstance(val, int) for val in points)
+    assert points == INDEX
+
+
+def test_report_point_file_reader_csv_iso(tmp_path):
+    # Create a CSV file datetimes (ISO)
+    csv_content = "\n".join(DATETIMES_STR_ISO)
+    csv_file = tmp_path / "test.csv"
+    csv_file.write_text(csv_content)
+    points = report_point_file_reader(str(csv_file))
+    assert all(isinstance(dt_val, dt.datetime) for dt_val in points)
+    assert points == DATETIMES
+
+def test_report_point_file_reader_csv(tmp_path):
+    # Create a CSV file datetimes (non-ISO)
+    csv_content = "\n".join(DATETIMES_STR)
+    csv_file = tmp_path / "test.csv"
+    csv_file.write_text(csv_content)
+    points = report_point_file_reader(str(csv_file))
+    assert all(isinstance(dt_val, dt.datetime) for dt_val in points)
+    assert points == DATETIMES
+
+def test_report_point_file_reader_txt_iso(tmp_path):
+    # Create a TXT file with ISO datetimes
+    txt_content = "\n".join(DATETIMES_STR_ISO)
+    txt_file = tmp_path / "test.txt"
+    txt_file.write_text(txt_content)
+    result = report_point_file_reader(str(txt_file))
+    assert all(isinstance(dt_val, dt.datetime) for dt_val in result)
+    assert result == DATETIMES
+
+def test_report_point_file_reader_txt(tmp_path):
+    # Create a TXT file with non-ISO datetimes
+    txt_content = "\n".join(DATETIMES_STR)
+    txt_file = tmp_path / "test.txt"
+    txt_file.write_text(txt_content)
+    result = report_point_file_reader(str(txt_file))
+    assert all(isinstance(dt_val, dt.datetime) for dt_val in result)
+    assert result == DATETIMES
+
+def test_report_point_file_reader_txt_int(tmp_path):
+    # Create a TXT file with integer report points
+    txt_content = "\n".join(str(i) for i in INDEX)
+    txt_file = tmp_path / "test_int.txt"
+    txt_file.write_text(txt_content)
+    result = report_point_file_reader(str(txt_file))
+    assert all(isinstance(val, int) for val in result)
+    assert result == INDEX
+
+def test_report_point_file_reader_yaml_iso(tmp_path):
+    # Create a YAML file with ISO datetimes
+    yaml_content = yaml.dump(DATETIMES_STR_ISO)
+    yaml_file = tmp_path / "test.yaml"
+    yaml_file.write_text(yaml_content)
+    result = report_point_file_reader(str(yaml_file))
+    assert all(isinstance(dt_val, dt.datetime) for dt_val in result)
+    assert result == DATETIMES
+
+def test_report_point_file_reader_yaml(tmp_path):
+    # Create a YAML file with non-ISO datetimes
+    yaml_content = yaml.dump(DATETIMES_STR)
+    yaml_file = tmp_path / "test.yaml"
+    yaml_file.write_text(yaml_content)
+    result = report_point_file_reader(str(yaml_file))
+    assert all(isinstance(dt_val, dt.datetime) for dt_val in result)
+    assert result == DATETIMES
+
+def test_report_point_file_reader_yaml_int(tmp_path):
+    # Create a YAML file with integer report points
+    yaml_content = yaml.dump(INDEX)
+    yaml_file = tmp_path / "test_int.yaml"
+    yaml_file.write_text(yaml_content)
+    result = report_point_file_reader(str(yaml_file))
+    assert all(isinstance(val, int) for val in result)
+    assert result == INDEX
+
+
+def test_report_point_file_reader_unsupported(tmp_path):
+    # Create an unsupported file type
+    other_file = tmp_path / "test.unsupported"
+    other_file.write_text("dummy")
+    with pytest.raises(ValueError):
+        report_point_file_reader(str(other_file))
+
+def test_report_point_file_reader_missing_file():
+    with pytest.raises(FileNotFoundError):
+        report_point_file_reader("nonexistent.csv")
diff --git a/tests/test_sampling.py b/tests/test_sampling.py
new file mode 100644
index 00000000..163ced7b
--- /dev/null
+++ b/tests/test_sampling.py
@@ -0,0 +1,70 @@
+"""``misc.sampling`` draws exactly what geostat drew, from whichever stream it is handed."""
+
+import pickle
+
+import numpy as np
+import pytest
+from geostat.decomp import Cholesky
+
+from misc.sampling import GlobalRandomStream, gen_real, random_stream
+
+
+def _spd(n, seed):
+    a = np.random.RandomState(seed).randn(n, n)
+    return a @ a.T + n * np.eye(n)
+
+
+CASES = {
+    "variance vector": (np.arange(1.0, 5.0), np.array([0.5, 1.0, 2.0, 4.0])),
+    "diagonal covariance": (np.arange(1.0, 5.0), np.diag([0.5, 1.0, 2.0, 4.0])),
+    "full covariance": (np.arange(1.0, 5.0), _spd(4, 3)),
+    "single element": (np.array([2.0]), np.array(9.0)),
+}
+
+
+@pytest.mark.parametrize("mean, var", CASES.values(), ids=CASES.keys())
+@pytest.mark.parametrize("limits", [None, {"lower": 0.5, "upper": 3.0}])
+def test_gen_real_reproduces_geostat_draw_for_draw(mean, var, limits):
+    np.random.seed(11)
+    expected, expected_factor = Cholesky().gen_real(mean, var, 7, limits=limits, return_chol=True)
+    np.random.seed(11)
+    actual, actual_factor = gen_real(mean, var, 7, limits=limits, return_chol=True)
+
+    np.testing.assert_array_equal(actual, expected)
+    np.testing.assert_array_equal(actual_factor, expected_factor)
+
+
+def test_gen_real_draws_from_the_stream_it_is_handed():
+    mean, var = CASES["full covariance"]
+    a = gen_real(mean, var, 5, rng=np.random.RandomState(4))
+    b = gen_real(mean, var, 5, rng=np.random.RandomState(4))
+    c = gen_real(mean, var, 5, rng=np.random.RandomState(5))
+
+    np.testing.assert_array_equal(a, b)
+    assert not np.array_equal(a, c)
+
+
+def test_the_default_stream_is_the_global_one():
+    np.random.seed(2)
+    expected = np.random.randn(3, 2)
+    np.random.seed(2)
+    stream = random_stream(None)
+
+    assert isinstance(stream, GlobalRandomStream)
+    np.testing.assert_array_equal(stream.randn(3, 2), expected)
+
+
+def test_a_seed_gives_a_private_stream():
+    assert isinstance(random_stream(7), np.random.RandomState)
+    np.testing.assert_array_equal(random_stream(7).randn(4), random_stream(7).randn(4))
+    np.testing.assert_array_equal(random_stream("7").randn(4), random_stream(7).randn(4))
+
+
+def test_the_global_stream_survives_pickling():
+    # The ensemble is pickled by its emergency dump; the numpy.random module itself cannot be.
+    stream = pickle.loads(pickle.dumps(GlobalRandomStream()))
+    assert isinstance(stream, GlobalRandomStream)
+    np.random.seed(9)
+    expected = np.random.permutation(6)
+    np.random.seed(9)
+    np.testing.assert_array_equal(stream.permutation(6), expected)
diff --git a/tests/test_simulator_protocol.py b/tests/test_simulator_protocol.py
new file mode 100644
index 00000000..fda2f54e
--- /dev/null
+++ b/tests/test_simulator_protocol.py
@@ -0,0 +1,30 @@
+"""Every bundled simulator satisfies the contract the base ensemble drives it through."""
+
+import pytest
+
+from ensemble import ForwardSimulator
+from simulator.simple_models import lin_1d, noSimulation, nonlin_onedimmodel
+from simulator.vanderpol import VanDerPolOscillator
+
+SIM_CONFIG = {"reporttype": "steps", "reportpoint": [1, 2, 3], "datatype": ["x"]}
+
+
+@pytest.mark.parametrize(
+    "make",
+    [
+        lambda: lin_1d(SIM_CONFIG),
+        lambda: nonlin_onedimmodel(SIM_CONFIG),
+        lambda: noSimulation(SIM_CONFIG),
+        lambda: VanDerPolOscillator({}),
+    ],
+    ids=["lin_1d", "nonlin_onedimmodel", "noSimulation", "VanDerPolOscillator"],
+)
+def test_bundled_simulators_satisfy_the_protocol(make):
+    assert isinstance(make(), ForwardSimulator)
+
+
+def test_an_object_without_run_fwd_sim_does_not():
+    class Half:
+        input_dict = {}
+
+    assert not isinstance(Half(), ForwardSimulator)
diff --git a/tests/test_structures.py b/tests/test_structures.py
new file mode 100644
index 00000000..17c67dc8
--- /dev/null
+++ b/tests/test_structures.py
@@ -0,0 +1,468 @@
+"""
+Comprehensive tests for PETDataFrame and StateLayout.
+
+This suite preserves:
+- Exact numerical correctness
+- Deterministic behavior
+- Full operator coverage
+- Field data edge cases
+- Scaling consistency
+"""
+
+import datetime as dt
+
+import numpy as np
+import pandas as pd
+import pytest
+
+from misc.structures import StateLayout
+from misc.structures.structures import PETDataFrame
+
+
+# ---------------------------------------------------------------------------
+# Constants
+# ---------------------------------------------------------------------------
+
+NPARAMS = 3
+NX = 8
+NROWS = 2
+NCOLS = 3
+NY = NROWS * NCOLS
+NE = 10
+
+INDEX = ["idx1", "idx2"]
+INDEX_NAME = "index"
+
+
+# ---------------------------------------------------------------------------
+# Deterministic MultiIndex Data
+# ---------------------------------------------------------------------------
+
+@pytest.fixture(scope="module")
+def multicolumn_ensemble():
+    """Generate deterministic ensemble of multi-column DataFrames."""
+    np.random.seed(404)
+
+    dfs = []
+    for _ in range(NE):
+        data = {}
+        for key in ("keyA", "keyB", "keyC"):
+            for param in ("param1", "param2", "param3"):
+                data[(key, param)] = [
+                    np.random.rand(NX) for _ in range(NROWS)
+                ]
+
+        df = pd.DataFrame(data, index=INDEX)
+        df.columns = pd.MultiIndex.from_tuples(data.keys())
+        df.index.name = INDEX_NAME
+        dfs.append(df)
+
+    return dfs
+
+
+@pytest.fixture
+def multicolumn_df(multicolumn_ensemble):
+    return multicolumn_ensemble[0]
+
+
+@pytest.fixture
+def ensemble_singlelevel(multicolumn_ensemble):
+    return [
+        PETDataFrame._to_singlelevel_columns(df)
+        for df in multicolumn_ensemble
+    ]
+
+
+# ---------------------------------------------------------------------------
+# PETDataFrame: Basic
+# ---------------------------------------------------------------------------
+
+class TestPETDataFrameBasic:
+
+    def setup_method(self):
+        self.data = {
+            "keyA": [1.0, 2.0],
+            "keyB": [3.0, 4.0],
+            "keyC": [5.0, 6.0],
+        }
+
+        self.df = pd.DataFrame(self.data, index=INDEX)
+        self.df.index.name = INDEX_NAME
+        self.df.attrs["units"] = {
+            k: f"unit:{k}" for k in self.data
+        }
+
+    def test_from_pandas(self):
+        pdf = PETDataFrame.from_pandas(self.df)
+
+        expected = PETDataFrame(self.data, index=INDEX)
+        expected.index.name = INDEX_NAME
+
+        assert pdf.equals(expected)
+
+    def test_attrs_preserved(self):
+        pdf = PETDataFrame.from_pandas(self.df)
+        assert pdf.attrs["units"] == self.df.attrs["units"]
+
+    def test_to_matrix(self):
+        pdf = PETDataFrame.from_pandas(self.df)
+
+        vec = pdf.to_matrix(squeeze=False)
+        vec_sq = pdf.to_matrix(squeeze=True)
+
+        expected = np.array([1, 3, 5, 2, 4, 6], dtype=float)
+
+        assert vec.shape == (NY, 1)
+        assert np.array_equal(vec[:, 0], expected)
+
+        assert vec_sq.shape == (NY,)
+        assert np.array_equal(vec_sq, expected)
+
+    def test_return_types(self):
+        pdf = PETDataFrame.from_pandas(self.df)
+
+        assert isinstance(pdf.copy(), PETDataFrame)
+        assert isinstance(pdf.loc[["idx1"]], PETDataFrame)
+        assert isinstance(pdf + 1, PETDataFrame)
+
+# ---------------------------------------------------------------------------
+# PETDataFrame: Filtering
+# ---------------------------------------------------------------------------
+
+class TestFilterDataFrame:
+
+    def setup_method(self):
+        self.data = {
+            "A": [1, 2, 3],
+            "B": [4, 5, 6],
+            "C": [7, 8, 9],
+        }
+        self.index = pd.Index(["x", "y", "z"], name="idx")
+        self.df = PETDataFrame(self.data, index=self.index)
+
+    def test_filter_columns(self):
+        filtered = self.df.filter_dataframe(columns=["A", "C"])
+        assert list(filtered.columns) == ["A", "C"]
+        assert np.all(filtered["A"] == [1, 2, 3])
+        assert np.all(filtered["C"] == [7, 8, 9])
+        assert isinstance(filtered, PETDataFrame)
+
+    def test_filter_index(self):
+        filtered = self.df.filter_dataframe(index=["x", "z"])
+        assert list(filtered.index) == ["x", "z"]
+        assert np.all(filtered.loc["x"] == [1, 4, 7])
+        assert np.all(filtered.loc["z"] == [3, 6, 9])
+        assert isinstance(filtered, PETDataFrame)
+
+    def test_filter_both(self):
+        filtered = self.df.filter_dataframe(columns=["B"], index=["y"])
+        assert list(filtered.columns) == ["B"]
+        assert list(filtered.index) == ["y"]
+        assert filtered.at["y", "B"] == 5
+        assert isinstance(filtered, PETDataFrame)
+
+    def test_filter_none(self):
+        filtered = self.df.filter_dataframe()
+        pd.testing.assert_frame_equal(filtered, self.df)
+        assert isinstance(filtered, PETDataFrame)
+
+    def test_filter_wrong_index_dtype(self):
+        wrong_index = pd.Index([0, 1], dtype=int)
+        with pytest.raises(ValueError):
+            self.df.filter_dataframe(index=wrong_index)
+
+    def test_filter_missing_label(self):
+        with pytest.raises(ValueError):
+            self.df.filter_dataframe(index=["x", "missing"])
+
+    def test_filter_compatible_index_dtype(self):
+        # datetime.date labels select fine against a DatetimeIndex even though
+        # the dtypes differ (object vs datetime64[ns]).
+        dates = pd.to_datetime(["2023-02-05", "2024-03-11", "2025-04-15"])
+        df = PETDataFrame({"A": [1, 2, 3]}, index=dates)
+        wanted = pd.Index([dt.date(2023, 2, 5), dt.date(2025, 4, 15)])
+
+        filtered = df.filter_dataframe(index=wanted)
+
+        assert list(filtered["A"]) == [1, 3]
+        assert isinstance(filtered, PETDataFrame)
+
+    def test_return_type(self):
+        filtered = self.df.filter_dataframe(columns=["A"])
+        assert isinstance(filtered, PETDataFrame)
+
+# ---------------------------------------------------------------------------
+# Jacobian (Multi-column)
+# ---------------------------------------------------------------------------
+
+class TestMultiColumnJacobian:
+
+    def test_to_series(self, multicolumn_df):
+        pdf = PETDataFrame.from_pandas(multicolumn_df)
+        series = pdf.to_series()
+
+        assert isinstance(series, pd.Series)
+        assert series.shape == (NROWS * NCOLS * NPARAMS,)
+
+    def test_to_matrix_exact(self, multicolumn_df):
+        pdf = PETDataFrame.from_pandas(multicolumn_df)
+        matrix = pdf.to_matrix(is_jacobian=True)
+
+        expected_rows = []
+        keys = ("keyA", "keyB", "keyC")
+        params = ("param1", "param2", "param3")
+
+        for r in range(NROWS):
+            for key in keys:
+                row = np.concatenate([
+                    multicolumn_df[(key, param)].iloc[r]
+                    for param in params
+                ])
+                expected_rows.append(row)
+
+        expected = np.stack(expected_rows)
+
+        assert matrix.shape == (NY, NX * NPARAMS)
+        assert np.array_equal(matrix, expected)
+
+
+# ---------------------------------------------------------------------------
+# Ensemble handling
+# ---------------------------------------------------------------------------
+
+class TestEnsembleJacobian:
+
+    def test_merge(self, ensemble_singlelevel):
+        merged = PETDataFrame.merge_dataframes(ensemble_singlelevel)
+
+        assert merged.iloc[0]["keyA"].shape == (NX * NPARAMS, NE)
+
+    def test_matrix_shape(self, ensemble_singlelevel):
+        merged = PETDataFrame.merge_dataframes(ensemble_singlelevel)
+        matrix = merged.to_matrix(is_jacobian=True)
+
+        assert matrix.shape == (NY, NX * NPARAMS, NE)
+
+    def test_multi_vs_single_consistency(
+        self, multicolumn_ensemble, ensemble_singlelevel
+    ):
+        merged_multi = PETDataFrame.merge_dataframes(multicolumn_ensemble)
+        merged_single = PETDataFrame.merge_dataframes(ensemble_singlelevel)
+
+        mat1 = PETDataFrame.to_matrix(merged_multi, is_jacobian=True)
+        mat2 = PETDataFrame.to_matrix(merged_single, is_jacobian=True)
+
+        assert np.array_equal(mat1, mat2)
+
+
+# ---------------------------------------------------------------------------
+# Field data
+# ---------------------------------------------------------------------------
+
+class TestFieldData:
+
+    def setup_method(self):
+        self.pdf1 = PETDataFrame(
+            {
+                "keyScalar1": [1, 2, 3],
+                "keyScalar2": [4, 5, 6],
+                "keyField": [None, np.array([7, 8, 9, 10]), None],
+            },
+            index=["idx1", "idx2", "idx3"],
+        )
+
+        self.pdf2 = PETDataFrame(
+            {
+                "keyScalar1": [10, 20, 30],
+                "keyScalar2": [40, 50, 60],
+                "keyField": [None, np.array([70, 80, 90, 100]), None],
+            },
+            index=["idx1", "idx2", "idx3"],
+        )
+
+    def test_filtered_unfiltered_vectors(self):
+        vec_f = self.pdf1.to_matrix(filter=True, squeeze=True)
+        vec_u = self.pdf1.to_matrix(filter=False, squeeze=True)
+
+        expected_f = np.array([1,4,2,5,7,8,9,10,3,6], dtype=float)
+        expected_u = np.array(
+            [1,4,None,2,5,7,8,9,10,3,6,None], dtype=object
+        )
+
+        assert np.array_equal(vec_f, expected_f)
+        assert np.array_equal(vec_u, expected_u)
+
+    def test_ensemble_matrix(self):
+        merged = PETDataFrame.merge_dataframes([self.pdf1, self.pdf2])
+
+        mat_f = merged.to_matrix(filter=True)
+        mat_u = merged.to_matrix(filter=False)
+
+        expected_f = np.array([
+            [1,10],[4,40],[2,20],[5,50],
+            [7,70],[8,80],[9,90],[10,100],
+            [3,30],[6,60]
+        ])
+
+        expected_u = np.array([
+            [1,10],[4,40],[None,None],[2,20],[5,50],
+            [7,70],[8,80],[9,90],[10,100],
+            [3,30],[6,60],[None,None]
+        ], dtype=object)
+
+        assert np.array_equal(mat_f, expected_f)
+        assert np.array_equal(mat_u, expected_u)
+
+
+# ---------------------------------------------------------------------------
+# Scaling
+# ---------------------------------------------------------------------------
+
+class TestScaling:
+
+    def setup_method(self):
+        np.random.seed(404)
+
+        self.data = PETDataFrame(
+            {k: 10*np.random.rand(5) for k in ("keyA","keyB","keyC")}
+        )
+        self.var = PETDataFrame(
+            {k: 0.1*np.random.rand(5) for k in ("keyA","keyB","keyC")}
+        )
+        self.jac = PETDataFrame(
+            {
+                (k,"param1"): [50*np.random.rand(NX,NE) for _ in range(5)]
+                for k in ("keyA","keyB","keyC")
+            }
+        )
+
+    def test_max_min(self):
+        scaled = self.data.copy()
+        scaled.scale(type="max-min")
+
+        inv = scaled.copy()
+        inv.invert_scale(type="max-min")
+
+        assert scaled.is_scaled
+        assert np.all((scaled >= 0) & (scaled <= 1))
+        pd.testing.assert_frame_equal(inv, self.data)
+
+    def test_variance(self):
+        scaled = self.data.copy()
+        scaled.scale(type="max-min")
+
+        rng = scaled.scale_max - scaled.scale_min
+
+        expected = self.var / (rng**2)
+
+        var_scaled = self.var.copy()
+        var_scaled.scale(type="max-min", minimum=0, maximum=rng**2)
+
+        inv = var_scaled.copy()
+        inv.invert_scale(type="max-min")
+
+        pd.testing.assert_frame_equal(var_scaled, expected)
+        pd.testing.assert_frame_equal(inv, self.var)
+
+    def test_jacobian(self):
+        scaled = self.data.copy()
+        scaled.scale(type="max-min")
+
+        rng = scaled.scale_max - scaled.scale_min
+
+        expected = self.jac.div(rng, axis="columns", level=0)
+
+        jac_scaled = self.jac.copy()
+        jac_scaled.scale(type="max-min", minimum=0, maximum=rng)
+
+        inv = jac_scaled.copy()
+        inv.invert_scale(type="max-min")
+
+        pd.testing.assert_frame_equal(jac_scaled, expected)
+        pd.testing.assert_frame_equal(inv, self.jac)
+
+
+# ---------------------------------------------------------------------------
+# StateLayout
+# ---------------------------------------------------------------------------
+
+@pytest.fixture
+def state():
+    data = np.arange(1, NX * NPARAMS * NE + 1, dtype=float).reshape(NX * NPARAMS, NE)
+    layout = StateLayout({f"key{i+1}": (i * NX, (i + 1) * NX) for i in range(NPARAMS)})
+    return data, layout
+
+
+class TestStateLayout:
+    def test_shapes_and_variables(self, state):
+        data, layout = state
+        assert layout.nx == NX * NPARAMS and layout.variables == tuple(f"key{i+1}" for i in range(NPARAMS))
+        assert layout.rows("key2") == slice(NX, 2 * NX)
+
+    def test_dict_conversion_is_a_view_of_the_rows(self, state):
+        data, layout = state
+        d = layout.to_dict(data)
+        assert all(v.shape == (NX, NE) for v in d.values())
+        np.testing.assert_array_equal(d["key2"], data[NX:2 * NX])
+
+    def test_member_dicts_round_trip_through_from_dict(self, state):
+        data, layout = state
+        members = layout.member_dicts(data)
+        assert len(members) == NE and members[0]["key1"].shape == (NX,)
+        rebuilt, rebuilt_layout = StateLayout.from_dict(
+            {key: np.column_stack([m[key] for m in members]) for key in layout.variables})
+        np.testing.assert_array_equal(rebuilt, data)
+        assert rebuilt_layout == layout
+
+    def test_from_dict_keeps_only_the_first_ne_columns_when_asked(self, state):
+        data, layout = state
+        matrix, _ = StateLayout.from_dict(layout.to_dict(data), ne=2)
+        np.testing.assert_array_equal(matrix, data[:, :2])
+        with pytest.raises(ValueError):
+            StateLayout.from_dict({})
+
+    def test_clip_by_variable_pair_and_list(self, state):
+        data, layout = state
+        by_variable = data.copy()
+        layout.clip(by_variable, {"key1": (2.0, 4.0), "key2": (None, None)})
+        np.testing.assert_array_equal(by_variable[:NX], np.clip(data[:NX], 2.0, 4.0))
+        np.testing.assert_array_equal(by_variable[NX:], data[NX:])
+        everywhere = data.copy()
+        layout.clip(everywhere, (0.0, 3.0))
+        assert everywhere.max() == 3.0
+        as_list = data.copy()
+        layout.clip(as_list, [(None, 1.0)] + [(None, None)] * (NPARAMS - 1))
+        assert as_list[:NX].max() == 1.0 and np.array_equal(as_list[NX:], data[NX:])
+        with pytest.raises(ValueError):
+            layout.clip(data.copy(), "no")
+
+
+# ---------------------------------------------------------------------------
+# StateLayout: generation from prior info
+# ---------------------------------------------------------------------------
+
+class TestFromPriorInfo:
+    """A prior with more than one variable used to raise ``KeyError``: the
+    second variable's offset was read from an ``idX`` entry that did not exist
+    yet, so no multi-variable prior could be generated at all."""
+
+    @staticmethod
+    def _scalar(mean, variance):
+        # One cell, one layer: exercises the scalar path of gen_real and keeps
+        # the field-covariance machinery out of the picture.
+        return {"mean": [mean], "variance": [variance], "nx": 1, "ny": 1, "nz": 1}
+
+    def test_variables_are_stacked_with_consecutive_indices(self):
+        prior_info = {"a": self._scalar(1.0, 0.1), "b": self._scalar(2.0, 0.2), "c": self._scalar(3.0, 0.3)}
+        np.random.seed(0)
+        enX, layout = StateLayout.from_prior_info(prior_info, ne=NE, save=False)
+        assert enX.shape == (3, NE)
+        assert layout.indices == {"a": (0, 1), "b": (1, 2), "c": (2, 3)}
+
+    def test_indices_address_the_rows_of_their_own_variable(self):
+        prior_info = {"a": self._scalar(1.0, 1e-12), "b": self._scalar(2.0, 1e-12)}
+        np.random.seed(0)
+        enX, layout = StateLayout.from_prior_info(prior_info, ne=NE, save=False)
+        as_dict = layout.to_dict(enX)
+        np.testing.assert_allclose(as_dict["a"], 1.0, atol=1e-4)
+        np.testing.assert_allclose(as_dict["b"], 2.0, atol=1e-4)
diff --git a/tests/test_toggle_ml_state.py b/tests/test_toggle_ml_state.py
index 435bb6ac..de29fbf7 100644
--- a/tests/test_toggle_ml_state.py
+++ b/tests/test_toggle_ml_state.py
@@ -13,23 +13,23 @@ def test_toggle_ml_state_matrix_to_list():
     state_dim = 10
     total_ensemble = 15
     state = np.random.rand(state_dim, total_ensemble)
-    
+
     # Define multilevel ensemble sizes
     ml_ne = [5, 7, 3]  # 3 levels with 5, 7, and 3 members respectively
-    
+
     # Toggle to list format
     result = toggle_ml_state(state, ml_ne)
-    
+
     # Check that result is a list
     assert isinstance(result, list)
-    
+
     # Check that we have the correct number of levels
     assert len(result) == len(ml_ne)
-    
+
     # Check that each level has the correct ensemble size
     for i, ne in enumerate(ml_ne):
         assert result[i].shape == (state_dim, ne)
-    
+
     # Check that the data is correctly distributed
     start = 0
     for i, ne in enumerate(ml_ne):
@@ -43,23 +43,23 @@ def test_toggle_ml_state_list_to_matrix():
     # Create sample state as list of levels
     state_dim = 10
     ml_ne = [5, 7, 3]
-    
+
     state_list = [
         np.random.rand(state_dim, ml_ne[0]),
         np.random.rand(state_dim, ml_ne[1]),
         np.random.rand(state_dim, ml_ne[2])
     ]
-    
+
     # Toggle to matrix format
     result = toggle_ml_state(state_list, ml_ne)
-    
+
     # Check that result is a numpy array
     assert isinstance(result, np.ndarray)
-    
+
     # Check dimensions
     total_ensemble = sum(ml_ne)
     assert result.shape == (state_dim, total_ensemble)
-    
+
     # Check that data is correctly concatenated
     start = 0
     for i, ne in enumerate(ml_ne):
@@ -74,13 +74,13 @@ def test_toggle_ml_state_roundtrip():
     state_dim = 8
     total_ensemble = 12
     original_state = np.random.rand(state_dim, total_ensemble)
-    
+
     ml_ne = [4, 5, 3]
-    
+
     # Toggle to list then back to matrix
     state_list = toggle_ml_state(original_state, ml_ne)
     restored_state = toggle_ml_state(state_list, ml_ne)
-    
+
     # Check that we get back the original state
     np.testing.assert_array_equal(restored_state, original_state)
 
@@ -90,16 +90,16 @@ def test_toggle_ml_state_single_level():
     state_dim = 5
     ensemble_size = 10
     state = np.random.rand(state_dim, ensemble_size)
-    
+
     ml_ne = [ensemble_size]
-    
+
     # Toggle to list
     result = toggle_ml_state(state, ml_ne)
-    
+
     assert isinstance(result, list)
     assert len(result) == 1
     np.testing.assert_array_equal(result[0], state)
-    
+
     # Toggle back
     restored = toggle_ml_state(result, ml_ne)
     np.testing.assert_array_equal(restored, state)
@@ -110,16 +110,16 @@ def test_toggle_ml_state_many_levels():
     state_dim = 6
     ml_ne = [2, 3, 1, 4, 2, 3]  # 6 levels
     total_ensemble = sum(ml_ne)
-    
+
     state = np.random.rand(state_dim, total_ensemble)
-    
+
     # Toggle to list
     result = toggle_ml_state(state, ml_ne)
-    
+
     assert len(result) == len(ml_ne)
     for i, ne in enumerate(ml_ne):
         assert result[i].shape[1] == ne
-    
+
     # Toggle back and verify
     restored = toggle_ml_state(result, ml_ne)
     np.testing.assert_array_equal(restored, state)
@@ -132,16 +132,16 @@ def test_toggle_ml_state_preserves_values():
         [1.0, 2.0, 3.0, 4.0, 5.0],
         [10.0, 20.0, 30.0, 40.0, 50.0]
     ])
-    
+
     ml_ne = [2, 3]
-    
+
     # Toggle to list
     result = toggle_ml_state(state, ml_ne)
-    
+
     # Check first level
     expected_level0 = np.array([[1.0, 2.0], [10.0, 20.0]])
     np.testing.assert_array_equal(result[0], expected_level0)
-    
+
     # Check second level
     expected_level1 = np.array([[3.0, 4.0, 5.0], [30.0, 40.0, 50.0]])
     np.testing.assert_array_equal(result[1], expected_level1)
@@ -152,12 +152,12 @@ def test_toggle_ml_state_empty_level():
     state_dim = 4
     ml_ne = [3, 0, 2]  # Middle level has no members
     total_ensemble = sum(ml_ne)
-    
+
     state = np.random.rand(state_dim, total_ensemble)
-    
+
     # Toggle to list
     result = toggle_ml_state(state, ml_ne)
-    
+
     assert len(result) == len(ml_ne)
     assert result[0].shape == (state_dim, 3)
     assert result[1].shape == (state_dim, 0)  # Empty array
diff --git a/tests/test_trunc_svd.py b/tests/test_trunc_svd.py
new file mode 100644
index 00000000..935120c5
--- /dev/null
+++ b/tests/test_trunc_svd.py
@@ -0,0 +1,89 @@
+'''
+Tests for the analysis tools module.
+'''
+import pytest
+import numpy as np
+import pipt.misc_tools.analysis_tools as atools
+
+def test_truncSVD_big_matrix():
+    np.random.seed(10_08_1997)
+
+    A = np.random.rand(1000, 1000)
+    U, S, Vt = atools.truncSVD(A, energy=0.999)
+    A_approx = U @ np.diag(S) @ Vt
+    A_inv_approx = Vt.T @ np.diag(1/S) @ U.T
+
+    np.testing.assert_allclose(A, A_approx, rtol=1e-1, atol=1e-1)
+    np.testing.assert_allclose(A @ A_inv_approx, np.eye(1000), rtol=1e-2, atol=1e-1)
+
+
+def _reconstruct(U, S, Vt):
+    return U @ np.diag(S) @ Vt
+
+def _sorted_singular_values_desc(s):
+    return np.sort(np.asarray(s))[::-1]
+
+@pytest.mark.parametrize("shape,r", [((20, 15), 5), ((15, 20), 6)])
+def test_truncSVD_matches_rank_r(shape, r):
+    rng = np.random.default_rng(10081997)
+    A = rng.standard_normal(shape)
+
+    U, S, Vt = atools.truncSVD(A, r=r)
+    U_np, S_np, Vt_np = np.linalg.svd(A, full_matrices=False)
+
+    A_approx = _reconstruct(U, S, Vt)
+    A_expected = _reconstruct(U_np[:, :r], S_np[:r], Vt_np[:r, :])
+
+    np.testing.assert_allclose(A_approx, A_expected, rtol=1e-10, atol=1e-10)
+    np.testing.assert_allclose(S, S_np[:r], rtol=1e-12, atol=1e-12)
+
+
+def test_truncSVD_matches_scipy_svds_rank_r():
+    sp_linalg = pytest.importorskip("scipy.sparse.linalg")
+
+    rng = np.random.default_rng(10081997)
+    A = rng.standard_normal((30, 20))
+    r = 7
+
+    U_pet, S_pet, Vt_pet = atools.truncSVD(A, r=r)
+    U_sp, S_sp, Vt_sp = sp_linalg.svds(A, k=r, which='LM')
+
+    S_sp = _sorted_singular_values_desc(S_sp)
+    S_pet_sorted = _sorted_singular_values_desc(S_pet)
+
+    np.testing.assert_allclose(S_pet_sorted, S_sp, rtol=1e-6, atol=1e-6)
+
+    A_pet = _reconstruct(U_pet, S_pet, Vt_pet)
+    rel_err_pet = np.linalg.norm(A - A_pet, ord='fro') / np.linalg.norm(A, ord='fro')
+
+    U_np, S_np, Vt_np = np.linalg.svd(A, full_matrices=False)
+    A_best_rank_r = _reconstruct(U_np[:, :r], S_np[:r], Vt_np[:r, :])
+    rel_err_best = np.linalg.norm(A - A_best_rank_r, ord='fro') / np.linalg.norm(A, ord='fro')
+
+    np.testing.assert_allclose(rel_err_pet, rel_err_best, rtol=1e-8, atol=1e-10)
+
+
+def test_truncSVD_matches_sklearn_truncatedsvd_rank_r():
+    sklearn_decomp = pytest.importorskip("sklearn.decomposition")
+
+    rng = np.random.default_rng(10081997)
+    A = rng.standard_normal((25, 18))
+    r = 6
+
+    U_pet, S_pet, Vt_pet = atools.truncSVD(A, r=r)
+    model = sklearn_decomp.TruncatedSVD(n_components=r, algorithm='randomized', random_state=0)
+    A_proj = model.fit_transform(A)
+    Vt_sk = model.components_
+    S_sk = model.singular_values_
+
+    S_pet_sorted = _sorted_singular_values_desc(S_pet)
+    S_sk_sorted = _sorted_singular_values_desc(S_sk)
+    np.testing.assert_allclose(S_pet_sorted, S_sk_sorted, rtol=1e-5, atol=1e-7)
+
+    A_pet = _reconstruct(U_pet, S_pet, Vt_pet)
+    A_sk = A_proj @ Vt_sk
+
+    rel_err_pet = np.linalg.norm(A - A_pet, ord='fro') / np.linalg.norm(A, ord='fro')
+    rel_err_sk = np.linalg.norm(A - A_sk, ord='fro') / np.linalg.norm(A, ord='fro')
+
+    np.testing.assert_allclose(rel_err_pet, rel_err_sk, rtol=1e-4, atol=1e-6)