From e63ad0cd1959a5383bedc58bbac789d13c899eda Mon Sep 17 00:00:00 2001 From: n0228a Date: Thu, 25 Jun 2026 15:30:16 +0200 Subject: [PATCH] feat: add MPS module with multivariate Direct Sampling --- examples/13_mps/00_mps_overview.ipynb | 658 +++++ examples/13_mps/00_simple_unconditional.py | 56 + examples/13_mps/01_conditional.py | 58 + examples/13_mps/02_continuous.py | 62 + examples/13_mps/03_channel_strebelle.py | 85 + examples/13_mps/README.rst | 38 + .../13_mps/_preview/00_training_image.png | Bin 0 -> 89290 bytes examples/13_mps/_preview/01_unconditional.png | Bin 0 -> 42515 bytes examples/13_mps/_preview/02_conditioning.png | Bin 0 -> 50554 bytes examples/13_mps/_preview/03_ensemble.png | Bin 0 -> 57017 bytes .../_preview/04_pattern_reproduction.png | Bin 0 -> 120764 bytes .../13_mps/_preview/05_continuous_srf_ti.png | Bin 0 -> 153307 bytes examples/13_mps/_preview/06_parameters.png | Bin 0 -> 28507 bytes examples/13_mps/strebelle.npz | Bin 0 -> 2466 bytes src/gstools/__init__.py | 19 +- src/gstools/mps/__init__.py | 20 + src/gstools/mps/direct_sampling.py | 638 +++++ src/gstools/mps/distance.py | 274 ++ src/gstools/mps/model.py | 182 ++ src/gstools/mps/neighbors.py | 331 +++ src/gstools/mps/runner.py | 218 ++ src/gstools/mps/scan.py | 164 ++ src/gstools/mps/simulate.py | 461 ++++ src/gstools/mps/training_image.py | 458 ++++ tests/test_mps.py | 2198 +++++++++++++++++ 25 files changed, 5919 insertions(+), 1 deletion(-) create mode 100644 examples/13_mps/00_mps_overview.ipynb create mode 100644 examples/13_mps/00_simple_unconditional.py create mode 100644 examples/13_mps/01_conditional.py create mode 100644 examples/13_mps/02_continuous.py create mode 100644 examples/13_mps/03_channel_strebelle.py create mode 100644 examples/13_mps/README.rst create mode 100755 examples/13_mps/_preview/00_training_image.png create mode 100755 examples/13_mps/_preview/01_unconditional.png create mode 100755 examples/13_mps/_preview/02_conditioning.png create mode 100755 examples/13_mps/_preview/03_ensemble.png create mode 100755 examples/13_mps/_preview/04_pattern_reproduction.png create mode 100755 examples/13_mps/_preview/05_continuous_srf_ti.png create mode 100755 examples/13_mps/_preview/06_parameters.png create mode 100755 examples/13_mps/strebelle.npz mode change 100644 => 100755 src/gstools/__init__.py create mode 100755 src/gstools/mps/__init__.py create mode 100755 src/gstools/mps/direct_sampling.py create mode 100755 src/gstools/mps/distance.py create mode 100644 src/gstools/mps/model.py create mode 100644 src/gstools/mps/neighbors.py create mode 100644 src/gstools/mps/runner.py create mode 100644 src/gstools/mps/scan.py create mode 100644 src/gstools/mps/simulate.py create mode 100755 src/gstools/mps/training_image.py create mode 100755 tests/test_mps.py diff --git a/examples/13_mps/00_mps_overview.ipynb b/examples/13_mps/00_mps_overview.ipynb new file mode 100644 index 00000000..fe935d54 --- /dev/null +++ b/examples/13_mps/00_mps_overview.ipynb @@ -0,0 +1,658 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "40757bdc", + "metadata": {}, + "source": [ + "# Multiple Point Statistics with GSTools\n", + "\n", + "Two-point geostatistics (covariance models, kriging, SRFs) describes spatial\n", + "structure through pairs of points and a variogram. This is powerful, but it\n", + "cannot reproduce *curvilinear* or *connected* features such as meandering\n", + "channels, fractures, or other patterns that depend on the joint configuration\n", + "of many points at once.\n", + "\n", + "**Multiple Point Statistics (MPS)** addresses this by learning patterns\n", + "directly from a **training image (TI)** — an example image deemed\n", + "representative of the spatial structure to simulate. Instead of fitting a\n", + "variogram, MPS borrows whole patterns from the TI.\n", + "\n", + "GSTools provides the **Direct Sampling (DS)** algorithm\n", + "([Mariethoz et al., 2010](https://doi.org/10.1029/2008WR007621)), together\n", + "with the **Direct Sampling Best Candidate (DSBC)** parametrization\n", + "([Juda et al., 2022](https://doi.org/10.1016/j.acags.2022.100091)), through\n", + "two classes:\n", + "\n", + "* `TrainingImage` — the MPS model: the training image plus the distance\n", + " used to compare patterns (the analogue of a `CovModel`).\n", + "* `DirectSampling` — the generator that produces realizations on a\n", + " structured grid (the analogue of `SRF`).\n", + "\n", + "The core idea: to fill each grid cell, DS looks at the values already present\n", + "around it (its *data event*), scans the training image for a location whose\n", + "surroundings look similar enough, and copies that cell's value over.\n", + "\"Similar enough\" is decided by a **distance** between the two surroundings,\n", + "controlled by three parameters — the number of neighbours `n`, the scan\n", + "fraction `f`, and the acceptance threshold `t` (with `t = 0` giving the\n", + "recommended DSBC mode).\n", + "\n", + "This notebook gathers the `examples/13_mps/` gallery into one place and\n", + "builds up from a minimal unconditional simulation to conditioning,\n", + "continuous variables, and a real, published training image:\n", + "\n", + "1. [A first Direct Sampling simulation](#1.-A-first-Direct-Sampling-simulation)\n", + "2. [Conditioning to hard data](#2.-Conditioning-to-hard-data)\n", + "3. [Continuous variables and distance metrics](#3.-Continuous-variables-and-distance-metrics)\n", + "4. [A real training image: the Strebelle channels](#4.-A-real-training-image:-the-Strebelle-channels)" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "f8e45cf7", + "metadata": {}, + "outputs": [], + "source": [ + "%matplotlib inline\n", + "import matplotlib.pyplot as plt\n", + "\n", + "plt.ioff()\n", + "# turn off warnings for a cleaner notebook\n", + "import warnings\n", + "\n", + "warnings.filterwarnings(\"ignore\")" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "a656ab3f", + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "from matplotlib.colors import ListedColormap\n", + "\n", + "import gstools as gs" + ] + }, + { + "cell_type": "markdown", + "id": "5fc8896d", + "metadata": {}, + "source": [ + "## 1. A first Direct Sampling simulation\n", + "\n", + "This is the minimal Multiple Point Statistics example: build a training\n", + "image, wrap it in a `TrainingImage`, and generate one unconditional\n", + "realization with `DirectSampling`.\n", + "\n", + "We use a small, synthetic *channelized* training image generated with\n", + "NumPy, so the example is fast and needs no downloads." + ] + }, + { + "cell_type": "markdown", + "id": "13d2c57d", + "metadata": {}, + "source": [ + "Create a synthetic binary training image with curvilinear \"channels\".\n", + "The two facies (0 and 1) form connected, meandering bands — exactly the kind\n", + "of structure two-point statistics struggles to reproduce." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "46451d6d", + "metadata": {}, + "outputs": [], + "source": [ + "gx, gy = np.meshgrid(np.arange(60), np.arange(60), indexing=\"ij\")\n", + "ti_data = ((np.sin(gx / 5.0) + np.sin((gx + gy) / 8.0)) > 0).astype(float)" + ] + }, + { + "cell_type": "markdown", + "id": "0c28bb1a", + "metadata": {}, + "source": [ + "Wrap the array in a `TrainingImage`. For a categorical variable (facies\n", + "codes) the distance is the fraction of mismatching neighbours, so the\n", + "`distance` argument is ignored here." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "208d0ea1", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "TrainingImage(shape=(60, 60), categorical=True, distance='l1')\n" + ] + } + ], + "source": [ + "ti = gs.TrainingImage(ti_data, categorical=True)\n", + "print(ti)" + ] + }, + { + "cell_type": "markdown", + "id": "b11a879b", + "metadata": {}, + "source": [ + "Create the `DirectSampling` generator and simulate on a 40x40 grid.\n", + "\n", + "* `n_neighbors` — how many already-known cells define each data event.\n", + "* `scan_fraction` — fraction of the training image scanned per cell\n", + " (smaller is faster, slightly noisier).\n", + "* `threshold=0.0` — the recommended DSBC mode: always take the best match." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "2651225f", + "metadata": {}, + "outputs": [], + "source": [ + "ds = gs.DirectSampling(\n", + " gs.MPSModel(ti, n_neighbors=12, scan_fraction=0.3, threshold=0.0)\n", + ")\n", + "field_simple = ds([np.arange(40, dtype=float)] * 2, seed=20250616)" + ] + }, + { + "cell_type": "markdown", + "id": "ce25b847", + "metadata": {}, + "source": [ + "Plot the training image next to the realization. The realization is not a\n", + "copy of the TI, but it reproduces the same channel patterns." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "b3b6f2f8", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, (ax0, ax1) = plt.subplots(1, 2, figsize=(10, 5))\n", + "ax0.imshow(ti_data, cmap=\"cividis\", origin=\"lower\")\n", + "ax0.set_title(\"Training image\")\n", + "ax1.imshow(field_simple, cmap=\"cividis\", origin=\"lower\")\n", + "ax1.set_title(\"DS realization\")\n", + "fig.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "5e7a8b30", + "metadata": {}, + "source": [ + "## 2. Conditioning to hard data\n", + "\n", + "Real simulations must honour measured data (boreholes, samples). Direct\n", + "Sampling supports this through `DirectSampling.set_condition`: conditioning\n", + "values are pinned into the grid before simulation and preserved exactly,\n", + "while the rest of the field is filled in around them.\n", + "\n", + "We reuse the synthetic channel training image from the first example." + ] + }, + { + "cell_type": "markdown", + "id": "4b4b9dcb", + "metadata": {}, + "source": [ + "Draw 40 random \"hard data\" points and read their facies from the TI. In a\n", + "real study these would be field measurements; here we sample the TI so the\n", + "conditioning data are consistent with the patterns." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "7a754e7c", + "metadata": {}, + "outputs": [], + "source": [ + "rng = np.random.default_rng(0)\n", + "cond_x = rng.integers(0, 40, 40).astype(float)\n", + "cond_y = rng.integers(0, 40, 40).astype(float)\n", + "cond_val = ti_data[cond_x.astype(int), cond_y.astype(int)]" + ] + }, + { + "cell_type": "markdown", + "id": "ed690ca0", + "metadata": {}, + "source": [ + "Set the conditioning data and simulate. `set_condition` snaps each point to\n", + "its nearest grid node, so the values are honoured exactly at those cells." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "bcb598a1", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "conditioning honoured: 40/40\n" + ] + } + ], + "source": [ + "ds_cond = gs.DirectSampling(\n", + " gs.MPSModel(ti, n_neighbors=12, scan_fraction=0.3, threshold=0.0)\n", + ")\n", + "ds_cond.set_condition([cond_x, cond_y], cond_val)\n", + "field_cond = ds_cond([np.arange(40, dtype=float)] * 2, seed=7)\n", + "\n", + "honored = int(\n", + " (field_cond[cond_x.astype(int), cond_y.astype(int)] == cond_val).sum()\n", + ")\n", + "print(f\"conditioning honoured: {honored}/{cond_val.size}\")" + ] + }, + { + "cell_type": "markdown", + "id": "abbb1153", + "metadata": {}, + "source": [ + "Plot the realization with the conditioning points overlaid. Every marker sits\n", + "on a cell whose simulated facies matches the datum." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "640ef1df", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAdsAAAHqCAYAAABMXOQ8AAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjExLjAsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvlcelbwAAAAlwSFlzAAAPYQAAD2EBqD+naQAAXd9JREFUeJzt3Qd4VFXaB/D/nUnvBVKA0Kt0ELAgioCIiAUVFPksa0FBxY6suvbFvpZdRdEVu+IiKCgIKhaKIkUUBekQQiCk9zZzvuc9YUImBTIhN5ny/z3PiLlzZ+b2955z3nOuoZRSICIiItNYzPtqIiIiYrAlIiJqAizZEhERmYzBloiIyGQMtkRERCZjsCUiIjIZgy0REZHJGGyJiIhMxmBLRERkMgZbFzzwwAMwDAPl5eWV06655hq0adOm3t/h6vxmc7flaS5+fn647777jjutOZenKRUUFKB169Z49dVXm+T3Vq5cqc+txYsXe9Vvucvvz549W//mnj170Jzuu+8+vRzN9fkT9X//938499xzvSvYrl69GpMmTULbtm0RGBiI+Ph4DB48GI8++igOHDgAd3b55Zejffv28Ca33367Psgdr5CQEH0xPuecc/D8888jKyur1s/Nnz8fZ555JhISEhAWFoY+ffrgrrvuwrZt2+DL5IZNtqPcwLmjp556Cv7+/rjuuuuae1GIGsWll16Kzp07n9B3PPzww/jmm2+wZMkS7wi2skJDhw5FeHg4Fi1ahJycHPz555+488478e677+Jvf/sb3MXcuXOxf/9+0+Z3N8nJyZDhtLOzsytviKT00717d33HXtWDDz6oD/DTTz8da9euxeHDh/Hiiy/ixx9/xHnnnQdPCIhPPvmkz/22lGpfeuklTJkyBQEBAc2yDETuqFOnThg9ejT++c9/en6w/fDDD/HII4/oEuxrr72Gvn37IigoCLGxsbrE+Ouvv+Lss89u7sX0eXIRbteuna6GXr9+PWJiYnDBBRcgIyNDb5uSkhI8++yzGDFihD4wpYYiODgYw4cPx6pVq3SQJvck56Dc4E6ePLm5F4XI7ch5IQWLzZs3e3awlUCbmJhYZ3tVaGgo7r33XqdpCxcuxKmnnqqrNqWqUqotv/76a6d5LrroIl36Sk9Px2WXXaZLzS1atMDUqVN1YKjuzTff1PNLoJeAv3Tp0nq1eZ5yyin4+OOPsXfvXqdq1+Li4lrnN2sdHG0b8rJYLIiOjtZVvhLoGltERIS+OZKq5Ndff11PKyoq0ussVc3VSfWkzH88jvVNTU3VJeTIyEicddZZ+j0pXf/nP/9Bv379dBCX9yTYSw1IVbKtHdtBfleC/s0334zMzEyX203lZq/qPq36uummm+r9mzt27NDTxRNPPFE5r6xjXb/t2KZ///vf0bFjR32zI+eJ1PLI9nHIz8/X3/X444/r46d///76GO7WrZs+LutDapO6dOmCpKQkp+lVv/vLL7/EgAEDdBPPG2+8od8/ePCg3g6y/rJ8st5yrjqOfQep5Rg2bJjebzLvrFmz4Cozfuunn37CGWec4TRvXe2rTbmujclut+Ohhx7Sx45ca6SUtmvXLqd5vvvuuxpNRrKvpfBTWzuwHM/3338/WrVq5XStmzNnjj7u5Pjr168fli1b5tKy1vfzd999d41rnbSrrlmzpnKek08+WTdp7dy502ndHPk39fkOB0dhT84Tlyg3snv3bnncn7rqqqvq/Zk333xTf+bOO+9UKSkpau/eveq6665TFotFffrpp5XzXXjhhapTp05qwoQJ6rvvvlO5ublq3rx5yt/fXz300ENO3/nKK6/o75TpaWlpaufOnerSSy9VY8eO1dPLysoq57366qtV69atnT4/ceJE1a5du1qXt7b5zViHqmR5t2/frrdrWFiYXp9jLU9tpk+frpcxOTm51vezsrL0+6NHj66c1rNnTxUZGalWrVqlGsKxvuPGjVPffvutysjIUO+8845+75prrtHr8sYbb6j09HS9zSZNmqR/b8eOHbV+X35+vlqxYoXq0qWL03IKq9WqZsyYcdxp1d1+++16vV9++WWXflP2iXzu/vvvr/Vz1X/bZrOpkSNHqqioKDV//nyVk5Oj1qxZo7p27arat2+vt43Iy8vT33vxxRfrfbtr1y51+PBhde211+rjaevWrep4YmJi1BVXXFFjuuO7ZX/I+7Kdt23bppYvX65SU1NVUlKSGjBggFq9erWe94cfflAdO3ZU5557buV3bN68WYWEhKgxY8boz8qy/fOf/9TLK9+9aNGi4y6fGb/122+/qeDgYH2Oy7ki8z799NNq/PjxNeZtqnXdsmWLnq8+r8cee+yY3/Xqq6/q+eS8mTNnjsrMzFS//vqrXuYhQ4Yc87NyDXzxxRf1Mfnuu+/W+M7LL79czZ49W5+Hc+fOVcXFxeqll15ShmGoRx99VH9+x44der3PO+88/Znjaejn5bySbX3llVeqiIgItWfPnsr3LrnkEn09OZ5jfYeDXN+r7uv6cKtgKwFENuQDDzxQr/lLSkpUixYt1LBhw5ym2+121bt3b30Rqnrhlu+Wk6Kqyy67TCUmJjp9Z2xsrD7pqiosLFRxcXGNHmzNWIe6lJeXq9DQUPX4448fc/kbEmyFBD9ZZodNmzapbt266c917txZB0M5iaoG+2NxrO9XX33lNP3777+vNcDJtpTtLut0LP/73//056ueRA0JtvL78j0SyI6n+m+6Gmw///xzPf/rr7/uNN/GjRudvscREOUiWvU4leAcFBSk7rnnnmMup9wcOG78qnN8d6tWrVRpaanTezfccIMOLPv373ea/vXXX+vPSEB2HKtywyA3ilXJzWx9g60ZvyUX4ujoaL2OVUkgqT5vU62rGcH273//e603+nKuHs9FF12khg4dWuM777jjDqf5JNjKtpTzt/qxFRsbe9xge6KfF3J8ys3Tk08+6XKwPdZ3OJxyyimqR48eyhVuV43sit9++01XqY4fP95pulQFyDRJc5dqAwepdpVqoqp69eqlq+Gkik5s2rRJtztKlWRVUg0k1bCesA5Cqiwlg1ga9KWqT75PqiYl+UWqfcwgN29V0/Il81iqdaXq+sYbb9TVM4899hi6du2KGTNm1Os7pQqp+nZ3VN9UrXYVUp0n2+b77793qhocN24c4uLiYLVanaprT2Q7SLWibF9pk65evWbGb0oGpKh+nEj1muxjx/sOUj0o+7tqVb9UC1evMqxOEt8cx1ldxowZU1kNXnWfnHbaaTWaDaQ5ROZ17BNZTmm3r/790mRQlRz31avqP/roI1N+S6xYsULPK004VVW/Dpj1+7WRJpQjBaLjvuqb1T527Nga1w5R9biQ73v55ZcxcOBAvT0c21+aumo7fqtvow0bNugmperTQ0NDMWrUqOMuo6ufl+v19OnTna51ci2Q62F9zzdXv0POJ8e5Ul9uFWwl4Ubs27evXvM7knGkW0l1jmkSyByknaK2jSYkIaTqd0pXo+pqm3aizFgHx0klbRSSKXzo0CHdViMnkbTxlpWVNfp6yIEngVzabaqSACsXpnvuuUdnkktbtgSMp59+GgsWLDju91b/Pkd7mZA2MAkoEtDkd+T13nvvVW7TP/74Q7fxSsCWdihZPtkGjvb3hm4HSQiT9lu5GMo2rhp4zPpNWSdZV0kUrO04qXqMHOs4Od4FIioqSv+bm5tb5zy1tcPLMSbBxbE/HPtEto2ss2OfyEX0RM8tM35L5pWbo+pqm9aU69rYqh8XjmtH1eNC8mbuuOMOXH/99di+fbtu15RjWBKDajt+qx8PJ3oNzXDh87Jc0rYqNwJy05uWllZ5rZNjuT7nW0O+Q84Padd1xdFbXzcgfVOlQVwSO2QHV70zr41kwDoO/uoc0yS4ONSnM7TjYnas72xMZqyD9GGV0pUkEFUtFUqCS/WLcmNxJC84EpjqIjUEUqr95JNPdBegiy+++JjzVy9BObaHXNzkYnasEpgkBEnimCRaOIKI2L17NxpKbgSl1Cq/K0lCkphl9m86jhM5J6TGwnHMVD1Oqh4joqEd/6X0IOeA44amvvtEPiPd9Y53AyUXqPqcW3ItkItdbRr7txzzykW2utqmmfH7tdm6dSt69OhRr3mlxqg+pdv6HBfvvPOO7ponSX1V1XUMVz8eTvQaGuvC57ds2YJ169bpIDly5MjK6XLzUN+SZ0O+Q2oSTzrpJHhsyVZIppwMWvHMM8/U+r6UFBzvSZaw7JjqB72cpDJNTlipFnCFfKdczKpnmkmGXX2z6eSCVVuGc12/19jr4CDVIdVPIjPIXZ7sN9luUl3sKGVLP9vaLpgpKSn636rByBUS7OTOUwL28UhQrt5XVErYDSHrJDUGsr5SjSwZqA39TbmRlP1T3+NEqqtF9eNEmj2kmcHxfmOQQCIXH1f3iZTkawtO1TM5ZT658avqs88+a9bfkupeR01EVbWN8tSU69pcql87pCpVbuDrQzLg5dyufg0tLCys0cOisT5fn2vd8a7L9b1eyn6XGrrqzXkeF2yvuOIK/OMf/9Cp5HJnJW2asoHkjl7abKSNytE+JRc0SaWXA1rS7uVuQwaMkJR8+Zz083SVfKd0S/niiy/03aKUBOWO7uqrr8agQYPq9R3SDiI7RA5OCQrH+73GXgcZJUXuuuSzv//+uw4SH3zwgT7Ja6tebAipWpFSngzSIWn1UsqUk8NRtSJBVrqIyAEpVahywZF5Pv/8c9xyyy36BuPaa69t0G/LRUw+K22mUnqX4C0XSdless+ke4w4//zz9b8yYpUcP3KCyEANtVVN14ccA9IGLf1QpT2rNq78Zs+ePXXpvj61DfK9EhDkGJHqLgn4P//8s67OlrZYqfZrLBJMpPpQBjCpL+nCJKV8ac/99ttv9fLJOSBtoXJOOwY8kXNbblxlueUCLlWGMlqVzWZr1t+Sm0Vpn5P+33LzIvPKyGi1XZybal3NaLOtD2krlXNZzlU5r+Q6JlXI9b2hkyYUGZhIrjfSx16O7127dunzR0YBbMzPS02ovKQAJk04cq2TpiS55lRvAnDktvzyyy9O12VXvkPIPnecJy5RbmrlypU6E7BNmzYqICBAtWzZUg0aNEg98sgjuntM9UxPSV+XzDHJEjzjjDPU0qVLneaRzDbJjK3uX//6l85uk3T+qiTrU7pryG/36tVLLV68WGd81icbuaCgQGckS0adI1uwqKiozvnNWAdJlZeMaukKI8sxefJk3T1EfltS2o+1/MfKRna8AgMDdQa0dEd57rnndFeC6tauXatuvfVWnaEsmcryGckGnDJliu7mdTx1ra8jW1syKSUrUL5bXv369VMPP/yw7irg8PHHH+suSJKJKxm60oVBuuLIOixZssSlbGRZ9rqyQWWdXP1N6bozcOBAvV3kPcmWPNbyyHEl0yRDXbp7SXa87L+qWbGOjOHaslPlt0aMGHHc7S6/I8eNdFOp6ljfLaRri3SFku0k501CQoI+PmR7SCZ81fWWrFZZb8lslu+TDPv6ZiOb9VvSjef000+vnFfWXzKLZd5ly5Y127o2BkfmcPXzzpHx/NZbbznt/9tuu02f33Itkp4S69at090RJRv4eN9Z9X3phSDbp3fv3vrYl+O3vmGnvp+XbjrSvUqOWem2Jl0cpStifHy8U88EyWZ2ZIg7zlvHtby+3yHkulo1K7u+DPmPa+GZiLydlCyk1kLa/315yMa3335bD0QjtSa9e/du7sWhZia1HlLjIKV+qdlwBYMtEdUg1YfSRUuac2SEMl8lVapSjSp5JMdL2CTvd9VVV+kmg7pGFDwWHj1EVGsyiSORzVdICVZeMjShtLfLcITSdil9Thlo6USTTFmyJSI6kvgiyYobN27UJXtJMrztttt0Yg7RiWKwJSIiMpnbdf0hIiLyNgy2REREJnPLBCnpcCzZfzIkXkOHnSMiIjKD9JjNy8vTg9XIiHEeG2wl0FZ/cDUREZE7kVHW5IEoHhtsKweXbzsSsLjlItIRWcsOc1sQUaOIPqelZ2xJezmw7+tjPgilOreMZJVVxxJoLTWfMELuIyLcLQ8hIvJEFs+63rvSzMkEKSIiIpMx2BIREZmMwZaIiMhkDLZEREQmY7AlIiIyGYMtERGRyRhsiYiITMZgS0REZDKOSEA12FalcasQeSubArYWAuUAugUDQRavv/ZYT49Dc2OwJSLyFe+lwXghBUZKqf5TRfsBf4uHuqM1YOVDX8zEYEtE5Atmp8LyyD6oS2KhroyvKNF+lg5I8E0thXquY3MvoVdjsCUi8nZ55TCe2Q91fQLwePuj0weEAR2DYczYDXVjAtAtpDmX0qu5T2U9ERGZ4+tsGIV2YFqrmu9d0VJXJxufZXLrm4jBlojI2+XZoKRJNr6Wp+oEWIBYPz0PmYfBlojI250UAkMB+CGn5nt7i4GdxVAnBTfHkvkMBlsiIm83MAyqdwhw/x5gf8nR6TnlwJ27gCg/4MLY5lxCr8cEKSIib2cYULO7wLhsC3DKr8BZkUCgBViRrYtc6t1uQIi1uZfSqzHYEhH5go5BUN/2Bualw/g6Cyi0ATcnQk2OAxICmnvpvB6DLRGRr4j0A25IgLohobmXxOcw2PoQDsNIBOCvQhgLMoDscqiuwcAlLSqCEHktWyMPA5mbV47orq59hglSROQb7ArGfbthOet34J004Jd8GA/tgzFwI/BNdnMvHXk5Blsi8g2vpuogq55oD2waAHzbB1jfHxgaAeP6bcDu4uZeQvJiDLZE5P3K7DDmHAT+Lw64LqFiIAcRHwDM7qozcY25h5p7KcmLMdgSkffbWwLjUBkwrpa+pMEW4Jxo4Oe85lgy8hEMtkTk/fyPPD6uyF77+0W2o/MQmYDBloi8X9vAiszjdw8BSsYtrOJQKfBVFtSoqOZaOvIBDLZE5BsjKN3VGsbybOD2nRXJUOWqYgQlGVVJuv5cGdfcS0lejJ3LiMg3XBALe74NxmP7YHycXjlZ9QqB+qQHEFvLE3GIGgmDLRH5jklxUBe3gPouG8ixAVK13D9Ul3yJzMRgS0S+RbKPx8Q091KQj2GwJapLXjkw52BFlWNaGdAuEEra9a6OO9pPk4ioHhhsiWqTUw7jki3ArmJgfAugWzCwPg/Go/t0Uo2a25UBl4jqjcGWqBbGCynAvhLgy15Aj5AjUxOBH3OAiVuADw8DV8dz2xFRvbAujKg6uwI+OgzIcz4rA+0RZ0Tq0YaMDw5zuxFRvTHYElVXYIORbQP6hta+bfqFAftLuN2IqN4YbImqC7FChVuBPwtr3zZ/FACJAdxuRFRvDLZE1VkNYEIL4J1DNR+79ksesCQL6vKW3G5EVG9MkCKqhbqjNYzvcoDRvwNXtAS6hQDr8oD56cDJYRXtuURE9cRgS1SbWH+oz0+C8e9UYN5hGBnlUK0DoKa3Bm5KBIJYKURE9cdgS1SXGH+of7QF/tEWyqYqqpeJiJoi2G7duhWLFy9Geno6unbtigkTJiAsLKzy/a+++gqLFi1y+kxISAiefvrphiwfHYdtVRq3UVNgoCWiE+BSXdgzzzyDyZMnIyMjA5GRkZg9ezZOOukkpKSkVM7zyy+/4IsvvkD37t0rX126dDmRZSQiIvKdku1FF12Ee+65p/LvO++8E61bt8b777+Pe++9t3J6fHw8brnllsZdUiIiIl8IttVLqEVFRSgrK0NsbKzT9EOHDmHmzJkICgrC4MGDMWbMmMZZWiIiIl9os01NTcUTTzyBgoICrF69GlOnTsXVV1/tNI+UdqWdNjs7G5MmTcKwYcOwYMECWCy111qXlJTol0Nubm5D1oWIiMgtudx/ITAwULfDdurUCeHh4fj2229x+PDRcWIl8K5cuRIPPvggnnvuOR2Qly5dirfffrvO75w1a5ZuA3a8kpKSGr5GREREbsZQSqmGfliqkPv164ehQ4fitddeq3O+0047DT169MCbb75Z75KtDrjtzwUs/g1dPJ/AbGQioqaVm1eO6K7rkZOTg4iICPP72fr7++tgu23btmPOJ4G0vLz8mKVleREREcHXq5GXLVvm9LdUH69YsQIDBw506mdb1TfffIONGzdi9OjRJ7qsREREHsmlku17772HGTNmoE+fPjoTefny5RgyZIhun3X46KOPdDcgKfHKwBcSbG+//XZcccUVZiw/ERGR97XZSpXx2rVrdRVyz5490atXrzrnkYzkAQMGoH379i4tlLTZSqKUr7bZsh2WiMjH22xliEZ5neg8vsxf2XFpwQFcVHAQwcqOnwOj8EZ4WxzyC2ruRaOGKrQBn2bA+DYbsCuoUyOAiS2BqCYafjyrHPj4MIyfcgGLAXV2FDA+Vj+bl4iaHx9d0sRibSX4KeVHfJC2EW3Ki2FRCjOzd2BH8rcYUXi0CxV5kH3FMIb/DuPe3UBOOVCsYDyRDGPoJuC3AvN/f1OB/i3jn8n6t5FdrpfFOPt3IPlolj8RNR8+9aeJvXF4E1rbijGw9TBsCIzS06JspfggbT0+PbQOHdqOaOpFohOhFIwbdlTctq7qC3QMrph+qBS46i8Y126DWtMXCDDpvrbEDuPav4B2gcDcbkB8QMX0nUXApK0wbtwO9WVPwOATi4iaE0u2TahdWSEuKDyEmdEnVQZakW0NwFVxAxCo7LgmL7kpF4lO1Lp8GFJ6fbLD0UArJOi91AnGgVJgSZZ52/nLTBipZcBLnY8GWtEpGPhnexi/FgAb8s37fSKqFwbbJtSvNEdv8MWh8TXeS7cG4uegKAwozWnKRaIT9XsBVIABDIus+V63EKi2gTB+N68q2fi9EKpDINClSqB3GB4F5WcAvxea9vtEVD8Mtk0o36iotY+31dKOphTibCUoMJjQ4lEkAamsop20hlK7bsNVIeadZirUAmTbgDJ7zTczy2GUK8DE3yei+uFZ2IR+DI5BmiUAd2TvrPHeuUVp6F5WgE9CWzXlItGJGhUFSMl2zsGa7807DCPHBoyNMW87j42BIZnIn6TXfO+Ng1CBBjDyaJMFETUPJkg1oVLDigdiuuP19N8QADv+HdEBmZYAXFyYigeztmF5cAt8E9xCxuZqysWiExHrD9ycCONfKVCSiXxFHOBvAAszgH8fgJrQQlcnm6Z7CNRlLYAZuysyjy+KBUoV8H4ajLmHoO5sDcT4Xl91InfDYNvE5kS0gw0GHsn6C5PzU/S0YsOCd8La4I7YnlDMGvU46t42UKFWGK+kwvjvoYppYRZgSgLUjDbm//5zHWC08AdeT9VBX0+L8YP9wSR9I0BEHv7UH7P4wghSVmXHoJJsBCk7fguIQKb1aCYpR5DyUMV23ecVNgX0CQXCmrj9Pa+8IhnKagB9Q4EgthIRecVTf8g1dQfRbG5Kd1ZiB/JtQIQV8D9GAJPgNiQczSbcDzitfic+ETUtBluiuhwogfFsCrAgHUaxgoq06iEY1V2tgQieOkRUf7xiENUmtRTGuD8B6TozvTWUJDmtzwPeSYOxOhdq4UlAKLtpEVH9MNgS1cJ4PqWin+zyPkDikfb082KA8S2A8zYDcw8B09hNi4jqhxkURNVJafbTdODq+KOB1qFnaEXf1tr6tRIR1YHBlqi6IhuMQnvtQyCKriFAehm3GxHVG4MtUXWhVqgWfsAvdQzgvzYXaM9nDxNR/THYEtU4Kwzgyjjgg7SKpKiqvsgEVuRA/V8ctxsR1RsTpIhqoW5rpbOOccEfwOjoiiEX1+fB+CEX6sIY4FIZVpOIqH4YbIlqE2KFmtdDl26NeenAxnygbRDsL3WsyEiWUZqIiOqJwZboWCNC/S0B6m8J3EZEdEIYbE8QxzEmMtGuYmBFdsV406dEVIw53ZQ2FwDSnCA1GWdFAp3qyFAnOg4GWyJyP0V2GHftgrEgA0qeF2wxYBTboc6IgHq1c8WjDc2UVQ7jpu0VbfRSw6EUjAeUbq9Xz3fUzQxErmA2MhG5HePe3cCSLKhnOwB/DQJ2DIJ6syvwZyGMa7fp4GcaCax/26afoKTmdNG/Lcugg+yybBh37zbvt8lrsWRLRO5lXzEwPx2Y1R6YHH90+tgYINQC4/KtUGvyzHvC0dp8GD/lQb3XDRgZXTHNzwAmxQF2BdyzG7i3Dftak0tYsiUi9/JDbsW/l7Ws+d6ZkVAJ/jCkHdckxnfZUC39gbOjar55ScuKq+b3Oab9PnknBlsici9SepSeVXV1r5JBR0ysRYZdfluibm2/LdNN/n3ySgy2ROReTo+AIQFvYS0Pe/gpD8aBUqjTI8xrsh0aAeNgGbDqSAm7qs8zYMiDKsyqwiavxWBLRO6lUzDUedHAg3t1cNNPYZKEqB9zgGk7oHqF6Opk0wyNgOobCtyyA/g+u+K3pevR4gzg/j1QMqJYV3YBItcwQYqI3I56sROMm3bAuHE7VJRVJygZ6eU6CKq5XSuqks1iGFBvd9VZz8bErVCxfrpq2cgqhzorEurljub9NnktBlsicj9hVp0NrDYVAN9kw7Ar2E8Nr6i+lTZTs8UHQH3RU2c9yxjZymJAnR0J9Asz/7fJKzHYEvkA6+lxnjnSmlTnSmkWzUCC+mkRUGyfpUbANlsiIiKTMdgSERGZjMGWiIjIZAy2REREJmOwJSIiMhmDLRERkckYbImIiEzGYEtERGQyBlsiIiKTMdgSERG523CN2dnZ+O6775Ceno6uXbvijDPOgFFtrNLy8nIsW7YMe/fuRZcuXTBixIga8xCR5w/D6G3LeUJDS3qjnHJgTwkQaQXaBzX30vhOyfbtt9/GySefjPfffx9r1qzBlVdeiVNOOQU5OTmV8+Tn52Po0KG49dZb8dNPP+Gaa67Beeedh7KyMjOWn4iIGltuOYy7dsHotwGWczfDcuomGGM2A6trecYvNX7JtlOnTti8eTOCgirucLKystCuXTvMnTsX06dP19OefPJJpKSk4LfffkN0dDSSk5PRs2dPvP7665g2bZorP0dERE2txA7j8q3ArmLgrjZQwyKBlFLg1QN6uvqoe8XTl8i8kq2UWB2BVoSGhiIwMNBpnnnz5mHixIk60IqkpCScf/75ejoREbm5hRkwNhYAH/UAbm0N9A0DzosBPj0J6BcK4/F9zb2EvtFmm5GRgXfffRcFBQX48ssvcdZZZ+H666/X75WWlmLHjh3o3r2702fk7+XLl9f5nSUlJfrlkJvLqgoiouZgfJYBdUYE0L/as3v9LcCURBjXb4faVwy0ZRuuqdnI0va6Z88ebN++Hfv370dAQADsdrt+TwKwUgpRUVFOn5FSbl5eXp3fOWvWLERGRla+pDRMRETNIM8GtHKusazkmJ5ra9JF8slgm5CQgBdeeEG300q77KpVq/Doo4/q90JCQvS/1QOrlFQd79Vm5syZOsnK8ZJ2XiIiagbdgoEfc4ByVfO977KhgixAuzqCMZnTz1ZKodKOu27dOv23tN+2bdsWO3fudJpP/pYuQHWRz0VERDi9iIio6alr4oHUUuDRvc4Bd10e8GoqcFkLINzlFkif51Kw3bp1q9PfRUVF+Pnnn3V/W4cLL7wQn3zySWUbrPTLXbRoES666CKf39hERG6vVyjUE+2AOQeBQRuAW3YAF/8B4/w/gO7BUP9o29xL6JEMJY2s9TR8+HDExsaib9++OtB++umnevrXX3+NNm3a6P9PS0vTfW+lunnUqFFYuHChHtBi5cqVCAur1uBeB6l2llIz2p8LWPzhztgBnpqTJw0W4Sl4Th/xRwGMt9OArYVApB/URbHAuBgggAMP5uaVI7rret3sWd+aWJeCrcy6dOlSXZr19/fX/WfHjRsHq9XqNJ8swHvvvYd9+/bp6mMZ/CI4OLjeBzuDLVH9MNg2PgZbavZg21QYbMmXuU0AVQqDSrIxvuAggpUN6wIj8UloK5RYnG+uibzyRielBJifDuNQGVSbQODSFkBL/wYHW7ZyE1ENgXYbPkjbgPGFB5FqDUSWxR/Tc3fjqcwtOD9hMDYGOnfvI/Iqr6bCeGIfEGgB2gbC2FMMzEqGmtUeuLJhN8MMtkRUw78y/sCYojRcHjdQl2bthoEupfl47/AGLDn4M7oknY08N8+nIGqQLzNheXQf1NRE4M42QJgVyCoHntgHy927Ye8QBPSuuytrXdjSTUROYm0luDY/GY9Ed8PHYa11oBXbA8IwPn4QYm1luCpvP7caeSVjdirU6RHAg20rAq2I9gOe7gDVMwTGa6kN+l4GWyJyIu20QcqOj0Nb1dgyKX7BWBkUg2HFGdxq5H1sCsYv+cCFsUD1x8JaDOCCWOCnukdDPBYGWyJyUnbkshCsKoZhrS5E2VBm8NJBXsgAlBRmi2s/9lFkB/wa9mx2njFE5GR1ULROiLoxd2+NLdO3JAeDS7KxOCSeW428j8UARkQBH6YBZfaagfaTw8CohiUHMtgSkfM1xeKHZyI74fbcXXgicwviyovhp+wYn38Aiw/+jM3+4ZgfmsitRl5J3doK2F4MXLsN+LNAd4HDhnzgyi1ARjnUzQ079pmNTEQ1zIrqjABlx4ycHfh79vbK6SuCYjEpbgCrkcl7nRwO9VYXGHfvhnH275WTVVIg1PvdgG4hQF65y1/LYEtENRkGHonphhcjO+DcosMIsVcMavFbYCS3Fnm/kdFQv0RC/ZBb8VCGpEBgaARgbVh7rWCw9YSRTMjjuc2oUC7Ktgbgo7DWzb0Y5COsJp0nDbqe+1sq2m8bCdtsiYiITMZgS0REZDIGWyIiIpMx2BIREZmMwZaIiMhkDLZEREQmY7AlIiIyGYMtERGRyRhsiYiITMZgS0REZDIO1+iGw+t50lCRrmwnT1ovbx+GkciXWBv7PLWXufwRlmyJiIhMxmBLRERkMgZbIiIikzHYEhERmYzBloiIyGQMtkRERCZjsCUiIjIZgy0REZHJGGyJiIhMxhGk6IRwVCgiouNjsCUiOkE9S3Nxfe4+dCwvxEFrIN4OT8LqwGjAMLhtSWM1MhHRCZiRvR2b93+PywsOwAKFEUXpWHVgFV5P/w2GUty2pLFkS0TUQOcUpuHJzK14LKorHovuijLDogPs3/L24fX0TdgUEIH/RHbg9iWWbImIGuq2nN1YHxCJf0R304FWKMPAmxHt8HFoK9yWuxtg6ZZYjUxE1HADS3PweWhCrW2zi0IT0LWsAGHKxk1MLNkSETVUgWFFnK2k1vdkejkMlDJJiliyJSJquPmhiZiUn4KW1QJukN2GKbl7sSgkHqWGlZuYWLIlImqoFyI7otiw4McDKzExPwVtywoxpvAQvk1djXblhXg0uis3LmnMRiYiaqBUvyAMa3UaXj/8Gz5KW185fWNABEYmnopfAyO5bUljsCUiOgE7/MNwdqvT0KmsAB3LCnDQGoTfA8I5oAWdWLAtKirCpk2bUFZWhp49eyImJsbp/W3btuHPP/90mubv74+xY8eiKUgftyh7GQosVrdrK/HGoQ19gZ+yI9xejhyLP+xMdqE67PQP1a9GpRQi7eUoMSwotrjX9YxMDLZPPPEEXnnlFSQlJcFqteqg+9hjj+GOO+6onGfevHl4/vnnMWzYsMppoaGhpgfbQLsN92XvwJS8vUi0laAEFnwSloiHo7s1/glAPiGxvBgPZ/2FK/NTEKpsyLT4483wtngsugvyLP7NvXjkzZTCTXl7cXvOLnQrK4AdwNLgODwS3RVrg6Kbe+nI7GAbGRmpS63yr5g/fz4uvfRSnHHGGTj55JMr5+vatSsWLlyIpix5fH5oLYYVZ+qL4YqgFuhYXoBpuXvwU8qPOK3VUGwPCGuy5SHvCLRrDqxEkLLh6ajO+MM/HKeUZOkM0+FF6Tiz1WkotLAVhszxcsZm3JK7Bx+GtsJD0d0RYyvVBYkfDqzGeYmD8W1wS256D+PS1eKWW25x+nv8+PEICAjAhg0bnIKtVDV/8803CAoKQq9evSqDs1kuz0/BOUXpODvxVKyochC+Ed4Oa1N+wNOZf+LihMGmLgN5l39kbdOBdmDrM5HiF6ynzQ9rhffC2uDnlB8xNXcPno3q3NyLSV5oQEm2DrRTY3vj1SpDPb4R0Q5LU9fglfTf0b3NcLYJ+9KDCH766SeUlpaiR48eTtN37NiBRx99FFOnTkWrVq3w4osvHvN7SkpKkJub6/RyxdX5+/F1cAunQCuyrAF4PrITxhUeQrSt1KXvJN9lVXZMzt+P2eHtKwOtw6bASPwvLBFX5e1vtuUj7ybHVrI1CK9FtHeaLsNBPhrdTVcrDynJbrbloyYOttnZ2bj22msxZswYXY3sIG21+/btw/fff6/bdF977TXdprtixYo6v2vWrFm69Ot4SZuwK+LLS7DFP7zW9/4MCIekFbRgsKV6ClE2PcTeloA6jin/cCTUMWoQ0YmKt5Vgm39Yrcl4cj0TCbZibmhfCLb5+fk477zzdOLTBx984PSeBNvY2NjKvydPnqyrko/Vhjtz5kzk5ORUvpKTk11anp3+ITitOLPWAb9lepFh0f3hiOoj3/BDmiWg4piqhUyXY47IDLv8Q9C/NEePQlXbsSeY9OkDwVYCrZRmi4uLsXz5ckRFRR33MzJPWlrd3V4CAwMRERHh9HLF6xHt9IDg1+ftc5retTQfd+TswgdhrZHPZBaqJ3lqy5yItrgubx9OLs5yeu+CglSMKUrD6+HtuD3JFJLkKd0Xn8ja4lSAiLWV4PHMrVgTGI3NAa5dI8nDEqQKCgp0iVb+/frrr2v0sRXp6elo0aJF5d/79+/XCVTjxo2DWZYEx+GViHaYk74Jk/OTdaaedDC/rOAAdvmFYEaMc5sy0fHMiuqC4UUZWH1gJRaEJuCPgAicUpyJMUWH8UloIt4Od62pg6i+dvmHYnpsL52RPLLoMD4LSUSMvRRX5KfoBxtMiB/IjemBDKXq/7DFESNGYO3atTrhqWqg7d69u36JIUOG4PTTT0f//v114H3ppZf0vN999x3Cw2tvA6tOEqR0BnP7c4H69mdUCpcUpOos0e5l+ci0BOC98NZ4NaI9ct2kTyQHtfAM1tPj9L9SjXdj3l5cnZes+27LjduciHZ4N6wNB7cg0w0rSsf0nN06GUqawj4NTcSLkR1woFrSHjUDexmwZ6lu9qxvTaxLwXbChAk6+7i6yy+/XL+EVC+/9dZb+PnnnxESEoLBgwfrdls/v/oXohsUbD0Ag61nBVsiomYJtk3FEWyztg1ERLif11xEGWw9Q3MfJ0TkBtfoIjuwLAs4WAq0CQRGRQEBFWlOuXnliO663qVgyyFwiIiIqlqUAePe3TCybVAhFhiFdqiW/lAvdATOPn5ScKMPakFERORVVufCuGkHMCwS6qd+wK7BUN/3AfqEwrh2G/B7QYO+lsGWiIjoCOPfB4CeIcCrXYD2R8Zn6BYCvNUVaBUAY3YqGoLBloiISNgV8H0OMLElYK02gpe0145vAazIQUMw2BIREQl15OVXc6hMzd+oCMgNwGBLREQkpDR7SjgwP73m8L82BSzIAE5r2OhdDLZERERHqGmtYPySD9y3B8goq5h4qBS4dQewowjq5kQ0BLv+EBEROYyIgv3J9jAe2gt8mAbEBwCppboKWb3cCRgUDuSVw1UMtkRERFVdHQ91fgzwWQaM1FIoGdTiolggsuEh0+ODLUf7IR4nRGROPGl99H9frzZco4vYZktERGQyBlsiIiKTMdgSERGZjMGWiIjIZAy2REREJmOwJSIiMhmDLRERkckYbImIiEzGYEtERGQyBlsiIiKTefxwjc3NtiqtuReByOMklhcj3laC/X5BSLcGNvfikA8JstvQtSwfxYYV2/xDAaOOZ9c2MgZbImoyPUrz8HzGHzi36LD+uxwGFoQm4I7YnkjxC+aeINP4KzseyfoLN+XuRfSRsY3/9A/DAzHdsSC0YY/NcwWrkYmoSXQqK8CPB1ahfXkhrm3ZD4NanYHbY3vhlOIsPb2FrYR7gsyhFD5I24A7s3dhTnhbnNpqKM5LGILdfiH49NA6XJG/H2ZjyZaImsQ/srYh3+KHU1udgWxrgJ62Ligan4fGY3Pyd7gtZzf+EdOde4Ma3dDiTFxakIqJcQMxL+zok3yWBMfho7T1eCZjCz4JbYVyw7zyJ0u2RGQ6i1KYUHAAr4W3qwy0Dsl+IXg/rDUm5adwT5AprihIwS6/EB1QnRgGnorqjNa2YpxRnAkzMdgSkekClQ1Byo59dbTL7vMLQWQDnhFKVB+R9nIk+wVB1ZIM5Tgmo0w+/hhsich0RYZVlyxGHUmMqu6cojRsDojgniBTbPYPx6CSbETZSmu8d86RY/IP/3CYicGWiMxnGPhPRHtcmZ+CiwpSj05XCjfn7Mbw4gy8EtGee4JM8d/wtpAy7WvpmxBot1VO71SWj1mZW7A8uAW2BYTBTEyQIqIm8WJkB5xakoUFh37B2sAoXdoYUpKFnmX5eDGiAz5pgu4X5JvS/AIxKW4APjq0AfuLluHLkHjd/WdMYZrOSJbseLOxZEtETcJmWDAhbiAujB+EFGsQTirLw28BETg78VTcHtuzyQYXIN+0MDQRvZLOxDvhSehcVoAQu00fdwPaDGuSPt4s2RJRk5EElc9DE/SLqKnt8A/DXXJj1ww8PthyuEQiMqu7klQznlWcDhsMLA2Jw3dBsSyBn+A2PbcoDcOL0mE/sk1X+Mg29fhgS0TU2JLKC/FF6lr0LsvTWdQy1N+MnJ34MSgGF8UPQma1vsJ0fG3Ki7D44Fr0Lc3V29RP2XFvzk6sCozGhQmDkOHlY2SzzZaIqApDKR0UwlQ5hrQ6A53ajkTbtqNwTsIp6F6aj/fTNnB7NWCbfn5wre7LKkMlyjZt13YURiacii5lBfjQB7Ypgy0RUbV+l31K8zA5bgDWBkVXTDQMLA+Jwy0teuuHKPQqzeU2c8GIonT0L83F/7UcgJ+CYiq36TchLTG1RR+MKkpH35Icr96mDLZERFUMK85AsjUIqwOPBIUqPg1NRCkMDCvK4DZzwZnFGThgDdTV8NUtDE1AsWHR292bMdgSEVUhj/0LVJK+U1OAsuuLZrkPJPQ09jYNOLLtqpPpVqVQ7uXhyLvXjojIRV+ExCPOXooLCg/WeO/avGQYUFgaHMft6uI2bWEvcx497Iir85NhhcKSEO/epgy2RERVyOhWXwW3xNzDG3FN3j4E2W0Is5fjtpxdeDbzD7wdloR9/iHcZi5YFxSFL4Pj8N/Dv+La3KPb9JacXfhXxh94N6wN9nj5NjWUUgpuJjc3F5GRkcjaNhAR4eydRCfOerp33zVT4wq3l+GttF9xSZXSrYyo+1Z4W0xr0QulhpWb3EVh9nIdbC+rUrqVbSo3L1Nb9EaJxYO2qTwhaM9S5OTkICKifg/QYCQjIqomz+KPSxMGoUtpvk7csRkGvg5uif1NMKyft8q3+GFC/MnoVFaAs44MarE8xHe2aYOC7eHDh1FeXo7ExLoHDs/Pz0dqairatGmD4OCGbczoc1oCFv9jzsMRpIjILNsDwvSLGs9O/1D98jUutdl+8MEH6NmzJ0466ST0798fSUlJ+PTTT2vMN2PGDLRo0QJnnXUWYmNj8cwzzzR4AfuU5ODttI04tOcrHN6zFB8fWofBxVkN/j4iT9HCVoLHM7dg176vkblnKVamrMQV+fv1Y+mIyIuD7YYNG/C///1Pl2wPHjyI6dOn4/LLL8fWrVsr5/nvf/+L//znP1i1ahVSUlKwcOFCzJw5E0uWLHF54c4uPIyfD6zE0OJMvBbRHv+O6IDepXlYdWAVLss/4PL3EXmKVuVF+DllJW7J2YMlIfF4MqozCixWfJC2Ea+k/86AS+RLCVI2m01XEb/yyiu4/vrr9bQhQ4agR48emDt3buV8I0eORFhYmA68riRIbbf4Y1tgNC5OGFSZkGBVdrybtgHnFx5C63ajkL2GpVzyvgSpDw+txxnFmTi19VAk+x3N0rwudy/eSN+E0QlDsMzLu0oQeVOC1Al1/dm2bRvKysp0dbL+fbsdv/76qw64VZ122mlYv369y98fZy/Tj0Oqmvknz8S8O7YngpUdE1m6JS8UbSvFJQWpeDqqs1OgFW+Gt8WvARG4IW9fsy0fEbmuwdnIpaWlujQ7cOBAXXIVeXl5erq001Ylf6enp9f5XSUlJfpVtWSrvw8WbA0IrzH/Ab9g7PcLQvvyQgC+kclGvqO1rRj+ULq/Zw2GgbWB0RhQkt0ci0ZEDdSgkq1kIk+aNAn79+/XCVJWa0XJ08+vInZLwK1KAqm/f91ZxbNmzdLVxo6Xo6QcDjvalxXUmD/WVoLE8hIcsAY1ZPGJ3NohayDsAHqV5tX6fu/SXBzw47FP5NXBVtppJ0+ejLVr12LFihVo27Zt5XuhoaGIjo7WXX6qkr8dAbQ2kkAldd+OV3Jysp6ebVjxROZW/XimSkrhkay/oAzg47BWri4+kds7bA3Uw9vdm70DMTbnG9cLClJxakkW5obXfT4RkYdXIzsC7erVq/Hdd9+hY8eONeYZPnw4vvzyS9xzzz36b8m/kr9HjRpV5/cGBgbqV3V3xvbCvPRN6HygQI8yIoN/X5m/H8OKM3Fzi95e/7Bh8l13xZyks+437f8Or0e0wx6/EIwsOowr8lMwPyQBC0MSmnsRicisbOSrrroKCxYswPvvv+8UaOPi4vRLbNy4Eaeeeipuu+02jBs3Dm+//bbuLiSJU+3bt3cpGxntz8Xwkhzcl70dI4vSdTH8h6AYPB3ZGV+Exut5OagFeWM2suhQVoD7s7frABui7NjhF4JXI9rjxcgOOlGQiDwnG9mlYCvJUFUTmRymTp2qXw5r1qzB008/jX379qFLly64//770bt37/r+jFOwdYwgJV1+5KFW5dUuMgy25K3B1kGaUfxh53i8RL4SbD39QQSuXHAZxL2LJwfb5hRot+lBZUKUDRsDI31mHFuiY+KDCIiosUzN2Y2Hs7ahpb208gkt80MTMaVFH2RbA7ihiVzAhh8iquHmnD34T8ZmLAxNQO82ZyGx7TmY1qIPRhSl48uDa3WzDhHVHx+xR0ROApQND2f9hTfC2+LGlv0qp8v45JsDwrHywCo9XOpnoXU/9YuInLFkS0ROTivOQpy9VD/4o7pVQbHYGBCB8QVHH6pORMfHYEtEToKVtM4CmdbaR33LtARUzkNE9cNgS0RONgZEogwGLqyl9CrP2JXs5J8Do7nViFzAYEtETg76BeGjsFZ4LGsrzi46XPns3Ja2EnyYth7FhgVvcbhIIpcwQYqIapjWojfaHSzCN6lrsNk/HBlWf5xanIUiw4oLEwYhk11/iFzCYEtENeRZ/DE88TSMLkrTz9YNsdtwX0wP/QCELAZaIpf5VLDlqFBE9Wc3DCwJidcvIjoxbLMlIiIyGYMtERGRyRhsiYiITMZgS0REZDIGWyIiIpMx2BIREZmMwZaIiMhkDLZEREQmY7AlIiIyGYMtERGRyXxquEbyXa4M1Wk9Pc7UZSHfG36VxxSxZEtERGQyBlsiIiKTMdgSERGZjMGWiIjIZAy2REREJmOwJSIiMhmDLRERkckYbImIiEzGYEtERGQyBlsiIiKTcbhG8glOw+UphSEl2RhUko1Cw4rFIfFI8wusfJtDO5IvDy1pBiuHQGWwJd/StqwQ89LW62BbAgv8YIcNBv4V2REzY3pAGUZzLyIReSGWbMlnBNltWH7wJ/gphXMTTsGy4JaIspdhWu5uPJL1FwosfngsumtzLyYReSEGW/IZEwoOoGtZAU5qMxxbAsL1tCxrAB6P7qaD7p05O/FcZMfmXkwi8kJMkCKfcW5hGlYHRlcG2qreDG+HKHs5TinJapZlIyLvxmBLPsMKhVKj9kO+9EhbrVWpJl4qIvIFDLbkM74LaoGhxZlIKi+s8d6k/BQUGhasDYxulmUjIu/GYEs+473w1kizBuCzg2vRuyRHT/NXdvwtdy/uz9qO18LbIcfq39yLSUReiAlS5DPyLP4YnXgKFh1ci99Svsduv2DdThttL8N7Ya0xI/ak5l5EIvJSDLbkUzYHRKBL0tm4sOAgTi7JQaHFivmhifizlqQpIqJmDbZKKRQUFCAoKAh+fs5fUVZWhpKSEqdphmEgNDT0xJbUh7gy2oqvj0zT8O0kx22s/r+HUQToV2N8b+04gg75MlszX6fc4fxzqc02KysL//rXv9C9e3eEh4fjo48+qjHPU089hcjISCQkJFS+unXr1pjLTEREnii5BMbj+2CM2Qxj7GYYz+4HDpXCF7gUbOfNm4e9e/fis88+O+Z8gwYNQn5+fuVr//79J7qcRETkyVbnwhj+G/BeGtAlGGgfBLyaCmP478DvBfB2LlUjT5kypd7z2mw2WCwWXYVMREQ+rMgO48btQP8wYG43IMxaMT2zDLh8K4wp26FW9gUs3hsvTOn6s2HDBoSEhCAsLAxnnnkm1q5da8bPEBGRJ/giE0ZGOfBMx6OBVsT4A7Paw9hdAnxf0R3PWzV6sG3bti3mz5+PnJwc7NmzB126dMHZZ5+NXbt21fkZSajKzc11ehERkXcw/iqEahMAdAiq+eaAMKhgC7CtYUmKPhtsr7rqKowbN05nKrds2RKzZ89GdHQ03nzzzTo/M2vWLJ1U5XglJSU19mIREVEzUdF+gJRsC2w13zxcBhTbgSjv7olq+ghS0jWoc+fOxyzZzpw5U5eEHa/k5GSzF4uIiJrKuFigxA68cbDmey8fAAItwLnePVSq6bcSxcXF2LJli85QrktgYKB+ERGRF0oKBKYmwpiVDLWzCLikBVCugA8Pw1icCftDbYFI7y7ZurR2kmFcVFTk1NYqXXv8/f0rg+XYsWMxbdo09O/fH+np6XjwwQf1Z2666abGX3oiIvII6u9JUAkBMF5JhTEvvWJaxyDYX+gITGwJb+dSNfKPP/5YOVCFjAg1ffp0/f933XVX5TyPP/64bp+Vkuwll1yiM5LXr1+Pjh35UG4iIp9lGMB1CVBr+8G+sg/sq/tC/djHJwKtMJSMvehmJBtZEqWytg1ERLh3Vy2Qb3CH4eI8RXMP7Ud0PLl55Yjuul7nGEVERKA++Ig9IiIikzHYEhERmYzBloiIyGQMtkRERCZjsCUiIjIZgy0REZHJGGyJiIhMxmBLRERkMgZbIiIikzHYEhERmYxjIRI1AV8fgpDDVZJXHaf2Mpe/myVbIiIikzHYEhERmYzBloiIyGQMtkRERCZjsCUiIjIZgy0REZHJGGyJiIhMxmBLRERkMgZbIiIik3EEKSIyna+PoEXedZzm5pUjuqu3BdsthTBmpwLf5QB2BQyNhJqSAPQLa+4lIyIi8oJq5JW5MMZsBlbnApe3BP4vHvitAMa4P4HFmc29dERERJ5fsjXu2Q2cGgHM7QYEHbkvuKsNMHU7jDt2Qp0VCYRZm3sxiYiIPLdka2SUA4+0OxpohZ8BPNwOKLIDn2U05+IRERF5frBVIQbQLaTmG60CgcQAGPtKmmOxiIiIvCfYGoUK2Fdc842MMiCtDCrevzkWi4iIyHuCrQq3AE8mV2QhV05UwHP7K/7/wthmWzYiIiKvSJBS/2gH3Lsb2FsCTGhZ0V47/zCM1XmwP9EOiGXJloiI3J9bB1tcGAPVNhDGywdgzNitJ6lBYbDP7QqMjm7upSMiIvKCYCuGRULJq9QOSG1yoFvXfBMREXlgsHUIYJAlImpSe4uBbUVAuBUYFA5YDffcAaV24Jc8oNAO9Ayp6LHiZjwn2BIRUdM4WArj7t0wvsmunKRaB0A91BYY52aJqe+nwXh6P4y0Mv2nknLZ2BiopzoA0e4T4lhcJCKiowpsMC7dAvxZAPViJ6hfB0B90RPoHQrLjTuApW40VO6HabDcvbuiuXF5b6gN/YFZHSqG+p20FSizw124T9gnIqLm90k6sKcY+L4v0Dm4YlpCAPDfrlBXbIXx1H4oSVA1mrlKucyuS7RqfCzwcqejy3N1PNArBMbYP6C+ygLOd4+SOEu2RERUyfgyExgedTTQVkYLA7guAcbWImC3G4zet7EAxsEy4PrEmoF/YDhUv1AYX2TBXTDYEhHRUcV2IKqOSs+YI9OLbO6xnKKudlmZ7g7LeQSDLRERHdU3DFiRDZTU0t65NAsqwgp0CGr+LXZSCJS/AUhVcXXZ5cCaPCg3eu45gy0REVVSV8cBuTbg9p1AXvmRiQqQ6uU5qcDkOCDEDR5t2sIfuDgWeDYZ+DGnYhlFZhkwbUdFdJvUEu6CCVJERHRU52Cof3eCcetOYFkWMDAMSCmFsbMYanQU1L1t3GZrqSfaw0gugXHZFqjuwRUBeF2ebl9Wb3YB4gLgLhhsiYjI2QWxUDKIxQdpFQlRbQJhf7I9cHpE82chVxVmhfqkB9SKbBiLM/WgFuquNsDlLSsCrxthsCUiopoSA4C72uhRct2a1QBGRkONdO/x8l1qs7XZbFi0aBHOO+88JCQkYP78+bXOt2TJEgwbNgzt2rXDyJEjsXr1aviEvwphPLwXxvXbYDywB/itoLmXiIiIPC3Yvvjii3jttdcwdepUHDp0CEVFRTXmWbVqFS644AKcf/75WLp0KQYMGKAD7tatW+HVXkiB5azfgU8zgHw7sCQLltGbYTy092jDPRER+SRDqfpHArvdDoulIj4bhoF3330XkydPdppHgqyUgKV069CnTx8MGTIEc+bMqdfv5ObmIjIyElnbBiIi3ANqupdnwXLVNqg7WwO3t654aEK5At46COPBvbC/0BGY6D5ZcURE1HC5eeWI7roeOTk5iIiIaPySrSPQHsuPP/6IUaNGOU0bPXo0fvjhB3grY85BqJPDgHvaHH06kTzo/oZEnb0n7xMRke9q1H62eXl5ulQaHx/vNF3+PnDgQJ2fKykp0Z+r+vIomwoqHmZfW5be6BgYfxRWPAKKiIh8UqMGW0eNtJ+fc9Wv/C1Vy3WZNWuWrjZ2vJKSkuBRgixA5pHO39VllleMciIlXSIi8kmNGmzDwsIQFBSE9PR0p+mHDx9GXFxcnZ+bOXOmrvt2vJKTk+FRxsYAnxyuGCKsqkIb8P4h4LzoikG8iYjIJzVqsJU23ZNPPhkrV650mi7ttYMHD67zc4GBgbqRuerLk6ibEwEpuI//s+JZjwdLK8YWvWwLcLAM6rbWzb2IRETkTWMj33LLLViwYAGWLVumq5U//PBD3c922rRp8FpJgVDzewBBBoxrtsHotwHGFVt1yVbN664HzCYiIt/lUr8ayTS+7LLLnALr3XffjSuvvBLPPfecnjZx4kTs27cPEyZM0IlP4eHhusvPmWeeCa/WIwTqi15QWwuB5BIgPgDoHeJeQ5sREZH797MtLS1FZmZmjekhISE1qn4lIcrRX7Y+XYY8up8tEZGPsZ5edx6Op7KtSjOtn61LkSwgIEAP01gfVqsV0dHuPVYlERFRU+DzbImIiEzGYEtERGQyBlsiIiKTMdgSERGZjMGWiIjIZAy2REREJmOwJSIiMhmDLRERkckYbImIiEzGsRCJiMhrh2A0Zf3tZS5/N0u2REREJmOwJSIiMhmDLRERkckYbImIiEzGYEtERGQyBlsiIiKTMdgSERGZjMGWiIjIZAy2REREJuMIUkREXs7XR4ZyBwy21DiK7cCCdBgLM4BcG9AtGOqaeKBfWMO/UynguxwYHxwGkkuAeH+oCS2Bc6MBq8E9R0Qeg9XIdOJyy2GM/xPGXbsBwwB6hgJr8mAZ8wcwO7Vh36kUjJl7YJn0F7C7GOgdCmSWw3L9dhg3bgfK7NxzROQxWLKlE2Y8ug/YWQws6XW0JGtXUP9MhuWRfbCfEu56CXdhBoy306Ce7QBcGVcRxCUGf5UJXLcdeOMQcHMi9x4ReQSWbOnE5JYD89OBaa2cA6rFAGYmQbUJgPFOmstfa7x1CGpYBDA5vjLQaqNjgItjYbx9qKKamYjIAzDY0olJLoFRrIAzImq+J+2qQyOBvwpd/97tRcAZkbW/NywSxt4SoITBlog8A4MtnZiIIy0RyaW1vy+JTY55XP1e+Wwd36mCLEAAk6SIyDMw2NKJSQqEGhQGzD4AlFRLWlqfB2NVLtT4WNe/9+JY4NP0mgE3swx49xBwUWxFVTURkQdgsKUTph5oC/xZCFz4B7AwHfglD3h2PzBxS0UgvsD1YKtuSABi/IFxm4HXU4F1ecB7h4Cxm3X1sbq9FfccEXkMZiPTiRscDjWvB4wnkmHctENPUiEW4LIWFYE4sAH3dLH+UAtPgvHIXuDRfTDKFZQUZEdEQT3UFmgXxD1HRB6DwZYaL+B+dhJUSgmQZ9PVywi1nth3JgZAze4CZJVDHSwFWvoDLfy5x4jI4zDYUuNqHdj4WzTar+JFROSh2GZLRERkMgZbIiIikzHYEhERmYzBloiIyGQMtkRERCZjsCUiIjIZgy0REZHJGGyJiIhMxmBLRERkMgZbIiIikzX6GHhz587F7NmznaaFh4dj+fLljf1TREREvhls9+/fj/z8fLzxxhtHf8SP49oSEZHvMiUKhoWF4ZRTTjHjq4mIiDyOKcF2586dGDVqFIKCgjB48GDccccdOgATERH5okYPtv7+/pg0aRLOPfdcZGdn46mnnsJ7772HDRs2IDQ0tNbPlJSU6JdDbm5uYy8WERGR9wTb22+/HYGBR59pKiXczp0749VXX8Xdd99d62dmzZqFRx55pLEXhYiIyDu7/lQNtKJFixbo168fNm3aVOdnZs6ciZycnMpXcnJyYy8WERFRs2mSNOGDBw+ie/fuxwzQ1YM0ERGRt2j0kq200UrXH6GUwrPPPou//voLEydObOyfIiIi8s2SrWQgd+nSBTExMcjMzIRhGHj//fcxfPjwxv4pIiIij2AoKX42MpvNhu3btyMkJARt2rSBxeJaAVqykSMjI5G1bSAiwjkgBhHRibCeHscN2JjsZcCepTrHKCIiol4fMSWSWa3WY7bREhER+RI+iICIiMhkDLZEREQmY7AlIiIyGYMtERGRyRhsiYiITMZgS0REZDIGWyIiIpMx2BIREZmMwZaIiMhkbj0WYvQ5LQGLf6N9n21VWpU/FLAhH8i1AV2DgSQ+dYhOUKENWJ9fcWz1CwOi3Pr0qp9SO7AuHyi2Az1DgPiA5l4ij2TGcIlO1zNye15wNWiAxRkwHk2GkVyi/1QGgHOioJ7uAMTxYkIusivghQMwXkuFITdvckwFWYDJcVAPJgEBHlqB9F4ajGf2w0gr038qPwO4IAZqVnsgwjcvHUQN5aFXgRPwVRaMG3cAJ4VALeoJtb4/8FxH4NcCGJdtrSidELnAmJUM49n9wBVxUN/3gVrTD7i1FfDOIRh37PLMbfleGiz37AbOjIT6qhfUL/2Bh9sCX2fDmPxXRemdiOrNt25PldIXRrmA4K2ugEWKtAAmxQEDw4DhvwH/Sweuim/uJSVPkV4GvHYQuLsNcFebo9Pl/xMDYNy5C0oCb/cQeIxSO4yn90NNaAG81Pno9OsTgR4hMC7ZAvVNNnBOdHMuJZFH8a2S7c5iGH8VAdcnHA20Dt1CgGGRML7IbK6lI0+0PAsoV8DfEmq+d2kLqCgr4GnH1Lp8GIfLgBsSa753eiTUSSEwFnvYOhE1M98KtkX2in9j6ki6auF/dB6i+h5T/gYQaa35nrTVRvjB8LRjqvI8qaPiK9aP5wmRi3wr2HYKggqzAMuyar5XYge+zQb6hjXHkpGn6hcGo1QBK7JrvrelEMa+Eqi+ofAoks8g9w5f1XKeZJYBa/M8b52ImplvBdsQK3BlHDD7QEXAVUeSPPJtwB07dTcgdXXjp+iTF+sfCtU/FLhvD/BX4dHpKSXArTugWgcA53pY22ZiADAuFng6Gfg59+j0rHJg2g5AspIvb9mcS0jkcXwrQUpypO5LgrGjGMZVf0FJ/9pWAcC6PKBUQf27E9A5uLkXkTyJYUC91gXG5VthnPkb1MlhFdXKa/OAWH+oD7sD/p53T6uebK+zjo0L/4TqFVJRpSzrZDWg/tu1osmFiOrN54ItgixQ73SF+jEXxsIMILccuDERalJLoDUHtqAGSAqE+qY31OcZMFbk6IQp9Xh74JJYINxDT7FIP6gFJ0Etz6pIGiyyQ93ZBriiJQMtUQN46JXgBEkmsvQflC5ARI1BBrGY0BJqghdVr0p18ZgYqDExzb0kRB7Pp4KtGUOmuYLDqxFRY10nmvt6Rq7xvMYkIiIiD8NgS0REZDIGWyIiIpMx2BIREZmMwZaIiMhkDLZEREQmY7AlIiIyGYMtERGRyRhsiYiITOZTI0h5o+YeRYajYpEnnieGUghUdhQbFv0wiUYZwUkpBNXxnSeyrOR+16ncvHJEd3XtMwy2ROQz2pcV4sGsbbi8IAUhyo7dfsF4JaI9XojsiHIJkg0QYi/HjOwduCFvHxJtJci2+OGdsCQ8Ht0Fh618uAlVYLAlIp/QuSwfq1JWocyw4MmoLtjtF4IRRYfxz8ytOL04E5fED4LdxRJpkN2GZak/oX9pDuaGt8XqwGj0LMvDjbl7MbbwEE5rNRRpfgy4xGBLRD7imYw/kWfxw5DWZyDjSInzvfAk/C+0FRYfWovxBan4X1grl75zSt5eDC7JxtBWQ7E2KLpy+mvh7bEu5Xs8lP0XprXo0+jrQp6HCVJE5PVibSUYV3gIz0R1rgy0Dl+EJmBlYDSuyUt2+XvlM5+GJjoFWrHXPwSzI9rj//L2w6LUCS8/eT4GWyLyenG2UlgBbA4Ir/X93wMikGgrdvl75TPy2bq+M1zZEKbKXf5e8j4MtkTk9Q5Yg1AKA4OLs2u+qRSGlGRhj1+Iy98rn5HP1kamp1v8kWcwNYYYbInIB+RY/fFJWCvcnbMD7coKnd67Jj8ZA0pzMSeircvf+0Z4W50INabwkNP0PiU5uD53H/4b3hbqBLoBkffgLRcR+YR7Yk7CDwdW4ff9K/B+WBvs9g/ByKLDGFWUjtfD22JpsOv9W98KT8L5hYew6ODPWBQSj9VBMehZmoeJBQfwh3+47v5DJBhsicgnpPoF4ZTWQzE9Zzcm5acguqAMf/qH4cqW/fFBWOsGDURhMyy4JP5kXJe3Dzfk7sPM7B04aA3Ew9Fd8e+IDiiw8BJLFXgkEJHPkEzkf8R016/GIgH39Yj2+kXUpME2NTUVc+bMwd69e9GlSxdMmTIF0dHOqfHewteHK2zuoeVM3/7FduDbbOBwGdA2EBgWCVjZBud2pHvNz3nAX0VApB8wMgoIk/zjpjmmpXuPVEl3LC/UJdslwXEosTTs98k7r72NHmyTk5MxePBg9O/fH2PGjMG8efPw5ptvYu3atV4bcMlLLc6Acd8eGBnlUDLcrR1QSYFQL3cChtTehYSawV+FMG7eAWNL0dH9FGaBui8JuC7B9J8/vTgD76ZtRIfyItgkWAM4bAnAtBa9dVIWkSldfx577DHExcVh0aJFuPXWW/HVV18hPz8fL7zwArc4eY5VOTCm7ABOjYD6sS+QMgRqSS+gdQCMSVuBHUXNvYQkMspgTNgKKED9r0fFflrfH7ikJSwP7AXmHTZ1O3UpzceS1J+R7BeMwa3OgF+HcejW5mysCI7Fh2nrMbwonfuJzAm2ixcvxvjx42G1VlShhISE4IILLtDTiTyF8eIBoG8o8FoXoEtwRfJM/zDg/e5AhBXG6webexFJvJ8G5JYDH/cAhkZW7KfWgcCT7aHGRsN4IQWwmzeC0505u/QQkGMSTsEvMoqUYWBbQBiuiDsZ6wKjcH/Wdu4navxgW1RUpNtr27Vr5zRd/t61a1ednyspKUFubq7Ti6jZFNth/JgLXB5Xs3021Apc3AL4ppbBEajJGd/kACOjgfiAam8YwJXxMHaXALtdHxmqvs4rPIQPwtqgsFrWsTzQQPrYjihO1w8rIGrUYFtcXHFQh4WFOU0PDw/Xgbgus2bNQmRkZOUrKSmJe4aaj6MkFFhHIlSQBSjneLduwaYq9kdtHNNN3Fd+UBXPr61FkVFRu2eVOm7yeY0abCXIWiwWZGU5D1+WmZmpg2hdZs6ciZycnMqXJFkRNZsQK1SfUOCzjNov7p9nAKcwQcotyH5YngUU1FJ6XJgOFecPdAwy7ed/CIrFhIIDtT5s4Ir8/VgfEMm+ttT4wdbf3x/du3fH5s2bnab//vvv6N27d52fCwwMREREhNOLqDmpqYkwVuQAT+wD8o9cyKX7z/SdulpSTUnkDnID6up4oEwBf9sGJJcc7a41JxV4Nw3qhgTA37wh4J+P7IiOZYWYe3gDWtoqfj/MXo4nMrdgTNFhPBPVybTfJvh2159Jkybh5Zdf1qXVhIQE/PXXX1iyZImeRuQxLoyFfV8JjKeSgTcP6ixk7C0BLAbUS52AAc5NJdRMpCvW3K4wbtwODNlYUYo9XAYjxwZ1bTww1dybIkmK+r+4/njz8K+YkJ+Knf4haFtehCBlx8zo7vhYRqYikjQCpRr3YYvSbnvRRRdh48aNOPnkk7FmzRrd3/bdd9/VVcz1IVXJUVFRQNuRgJsPd5a1zNyuBccTfU5L+DLTt39qKbAoE8bhMqg2gcAFMUC0ex+TPqnADnyZCWN7EVS4FTg/BugQ1GTnSZStDBPyD6B9eSHS/ALwcWhrPTwkeee1NzffhnYDfkV2dvYxm0hNDbZCvlIGsdi3b58eQapfv34ufX7//v1MkiIiIrcm+UVt2rRpvmB7oux2Ow4cOKCzmI0jg4NLdyDJUpaV85Y2Xa6TZ/DG/eSt68V18gy5Hn7sSdjMy8tDq1at6l1j65b1YbLwdd0teGMCFdfJM3jjfvLW9eI6eYYIDz726lt97GBemh4RERFpDLZEREQm85hgK31xH3roIf2vt+A6eQZv3E/eul5cJ88Q6IXHnkcmSBEREXkTjynZEhEReSoGWyIiIpMx2BIREZnMLfvZ1jZ846pVq/QAF0OHDtWDXXiyr776qsaTkTp16oRBgwbBk8g6fPPNN2jdujVOPfXUWueRTusbNmxAdHQ0TjvtNPj5ufchJ4+CXLZsGYKDg3HOOec4vVdeXo7//e9/NT4zZMgQdOjQAe5qx44d2Lp1K+Li4jBw4EBYrRWPfqtKOuivXLlSd9Y//fTTXe5D2NRklLnffvtND+s6YMAABAU5D40o+1CeNlaV7CPZV+4qPz8f69at00Pe9urVq9axBmw2mx4CNz09XY/M1759e7gzWRc5/7OysvRDauQ6V5Xswz///NNpWkhICC644AJ4G/e+8gH6Yn7ppZeia9eu+kDbvXs3FixYgGHDhsFTzZgxQ984dOvWrXLa2Wef7THBVsYDvfPOO7F06VIdgGTZawu2zz33HB588EH93q5du/RJtHz5cj3qijuOWnbXXXfh448/1sEoPj6+RrCVC8cVV1yBkSNHIjY2tnJ6YmKiWwbb7du344YbbkBKSoq+0MlFTZ7MJedPjx49Kuf74YcfcPHFF+t1kHXftm2bvqkYMWIE3E1aWppep19//VUHpL179+rj8cMPP8QZZ5xROd/f//53lJWVOa3nmWee6bbB9sUXX8Tzzz+vr3Nyw7N69Wq9njK96rqPGjVKFz46d+6s55HzSx764o4++ugj3H///XqkqODgYH0zJ+Pkv//++/o4FB988AHmzp2Ls846q/Jzcm55Y7CVHeu2CgsLVUJCgrrrrrsqp02ZMkUlJSWp0tJS5an69u2rnnnmGeWp9u/fr9544w1VUFCgxo4dqyZOnFhjnk2bNinDMNSCBQv030VFRerkk09Wl156qXJHcjw9//zzKiMjQ02fPl0NHDiwxjx5eXmSua/WrFmjPMH69evV999/X/l3WVmZGj16tDr11FOd1lvOp2nTplVOk/WX8072mbvZtWuX+uyzzyr/ttvt6vrrr1eJiYlO88n+mzVrlvIU8+bN0+eTww8//KCPNfnX4corr1T9+/fX10WxaNEiPc8vv/yi3JHsp8zMTKd95+fnp955553KaTNmzFAjRoxQvsDi7qXagwcP4vbbb6+cJqUPqZqUu3FPJnfkUsKQBzaUlBx5DqeHkGrj6667TpdU6yJ3rO3atdNPgBJSzTd16lR89tlnusrS3cid9h133IGYmJjjzivVYrIe8txmd+45J9WrVWuApApfSgxSKnT4/vvv9fkkNRUO8v9y3sn5526k9F211CM1RFIqT01N1SW/quRBKI5zTGol3Nlll13mdD45ar0c54osv9Q23HTTTbqUKM4//3xdEpaSojuS/STNRw5JSUl6Hauf//L3okWLsGLFCmRkZMBbuXU1sjx0XnZW1bYLeYqQXLjlPXes5qqvxYsX6ypxuWDLBUNOGGnT9Bayf3r37u00Tf6Wqj15xrE8ftFTvf7667rq+Oeff0bPnj111bM7Vo3X5uuvv9bVr1X3k1y8O3bsWDmtbdu2us1W3hs7diw8YZ2kPVpeVX355Zc64P7xxx+6meC9995zqmp2N7KsUjUs7ZtStSpNFueee25lk4DclFfdd45zSvaTu5LgKU1H+fn5+jwZPHgwrrrqKqd5pNniP//5j26H3rJlC5566inccsst8DZuHWylbaK2koZMk3YaT/Xkk09i9OjROshK8Ln22mv1na0cdKGhofAGjnalqhztnJ6676T0K6U9aaMWkoAjbU3StvbFF1/A3b399tu6RC4Jesc7x2RfecJ+kv3x8ssv6xugqh5//PHKc0zyCq6//npMmDBBn2PummApbesLFy7EoUOHdOCdOHFi5RNlZD+J6vtK9tOePXvgruTGQdYpMzMTmzZt0vuhajKb3Mw98MADCAsL03+/9dZbutZMamW8qfAh3LoaWYbykjui6mRa9exDTyJ3q45HB8oFXIYtk0cKrl+/Ht6itn3n+NtT952skyPQOi58UvUsma/u3hQgQfbGG2/Eq6++qhO8vOEc++mnn3QV8r333qtvWOs6x6T6XM4xqRr/5Zdf4K4kkVCSiqQ6VapV77vvPnzyySf6PcewhrWdU+68n+SGW9Zp2bJlujr/tddew7/+9a/K96WmwRFohexHqWWRmj9v49bBVtLEpRqisLCwcprcbcuzEKtWe3k6xyOmDh8+DG8h+07uzqu3Uwtv23dScnLnUuDnn3+uS0kvvPCCDrjV95OUmhwlJ1FQUKDPO3feT1KFLyVXyQN44oknvO4ck2YWyaT+8ccf9d+OfVHbOeXO+6mq9u3b666bjnWqi9Q8eMp+8ppgK2nucncqSQ4OUu8vd3me2l4r1SrVkzU+/fRTXV0kfSC9xXnnnaf7DEq7dNV9J30DPaV9szopGVUn+07aOKWrkDuSEoJUn0q3kptvvrnG+3IeyflUtf+w/L8cj9W7PrkLKZ1KoJX1kSaZ6uTGp7ZzTK4l7pgrIMta/WZNql2leliSihzVxdJtyVHSdQReKd27a7u6JK1VVVJSotvPHetU2zySzyHzeEo3SK9ps5UkFOlDJnevcmBJP9tZs2bh4Ycfdurn6Ekk8/PKK6/E+PHjdbauZLbOmTNH95dz9w7qVclJL/tDqr+lGkuqiiTR5sILL9Tvy79yIZd+ddOmTdOJDxJspW+uu5Jlk4uetOvJTZGsk5B+3lIVuWTJEt2mJFmgMpiCJOBI8odjPncjgx/Iskv/Uqnyrrqcl1xyiW7CkPNIqlinT5+uL3zSz1bOMemnmpCQAHezc+dOfRMgpTm5cau6TlJ1LPtF2j6lJC/nmJxTGzdu1OeYrFP1QRXcgdQkSHWqZO9KFrKU6v773//qm7iqNRHPPvusPqdkWp8+fXSTgAxAIvvYHckN0fDhw3USV0FBgU4ClYAr1f4Ocn2Qde/bt6++mf33v/+t1+nqq6+Gt/GIp/5IA7skoMidqRyQcrHzZHIxeOedd3SGoXSjke4xnlaqlYzC0tJSp2lyoZs9e3bl3/K+XOSkJCJZ5ddcc40+qdzVPffco2+GaksscrSZyc2RlPzkgigXfNkOsg/dNUv3jTfeqPU9uZhX7WoiJWCpbpbLgZSUHF223I0k2cjNQG0ki1VuYIXcOMh+k3NMalLkuuHOpSWpxpcMZMkslipvWVZJmqw+4pr0XpB9J9X8cs2YMmWK2z6mTkrs7777rj7/g4KC9A2CFDQcXZeqzyPVx9JuLTeCjvZ2b+IRwZaIiMiTuXWbLRERkTdgsCUiIjIZgy0REZHJGGyJiIhMxmBLRERkMgZbIiIikzHYEhERmYzBloiIyGQMtkRERCZjsCUiIjIZgy0REZHJGGyJiIhgrv8HK+p7w1QZ5HsAAAAASUVORK5CYII=", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = plt.subplots(figsize=(6, 5))\n", + "ax.imshow(field_cond, cmap=\"cividis\", origin=\"lower\")\n", + "ax.scatter(\n", + " cond_y, cond_x, c=cond_val, cmap=\"cividis\", edgecolors=\"red\", s=30\n", + ")\n", + "ax.set_title(\"Conditional DS realization (red-edged = hard data)\")\n", + "fig.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "d60992eb", + "metadata": {}, + "source": [ + "## 3. Continuous variables and distance metrics\n", + "\n", + "Direct Sampling is not limited to categorical facies: with\n", + "`categorical=False` it simulates continuous variables (permeability,\n", + "porosity, elevation, ...). The `distance` argument then selects how two\n", + "patterns are compared:\n", + "\n", + "* `\"l1\"` / `\"l2\"` — Manhattan / Euclidean distance on the raw values\n", + " (Mariethoz et al., 2010, Eq. 6 / Eq. 4).\n", + "* `\"variation\"` — compares only the *relative* variations within a pattern\n", + " (Eq. 9), tolerating a locally varying mean. Useful for non-stationary data.\n", + "\n", + "Here we use a smooth continuous training image and a small acceptance\n", + "`threshold` (standard DS mode) to allow approximate matches." + ] + }, + { + "cell_type": "markdown", + "id": "7aaef7f6", + "metadata": {}, + "source": [ + "A smooth, continuous synthetic training image." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "3fdcae36", + "metadata": {}, + "outputs": [], + "source": [ + "gx, gy = np.meshgrid(np.arange(60), np.arange(60), indexing=\"ij\")\n", + "ti_cont_data = np.sin(gx / 6.0) * np.cos(gy / 8.0)" + ] + }, + { + "cell_type": "markdown", + "id": "9ae54017", + "metadata": {}, + "source": [ + "Build a continuous training image with the Euclidean (`\"l2\"`) distance." + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "c6f47f49", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "TrainingImage(shape=(60, 60), categorical=False, distance='l2')\n" + ] + } + ], + "source": [ + "ti_cont = gs.TrainingImage(ti_cont_data, categorical=False, distance=\"l2\")\n", + "print(ti_cont)" + ] + }, + { + "cell_type": "markdown", + "id": "d94fc2be", + "metadata": {}, + "source": [ + "Simulate. `threshold=0.03` accepts the first pattern within that distance\n", + "(standard DS), which is faster than the exhaustive best-candidate search for\n", + "continuous variables." + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "f316fb3f", + "metadata": {}, + "outputs": [], + "source": [ + "ds_cont = gs.DirectSampling(\n", + " gs.MPSModel(ti_cont, n_neighbors=12, scan_fraction=0.3, threshold=0.03)\n", + ")\n", + "field_cont = ds_cont([np.arange(32, dtype=float)] * 2, seed=3)" + ] + }, + { + "cell_type": "markdown", + "id": "d52a52ae", + "metadata": {}, + "source": [ + "Plot. The realization reproduces the smooth wavy structure of the TI without\n", + "copying it. A shared colour scale makes the comparison fair." + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "105a2d5f", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "vmin, vmax = ti_cont_data.min(), ti_cont_data.max()\n", + "fig, (ax0, ax1) = plt.subplots(1, 2, figsize=(10, 5))\n", + "im = ax0.imshow(\n", + " ti_cont_data, cmap=\"RdBu_r\", origin=\"lower\", vmin=vmin, vmax=vmax\n", + ")\n", + "ax0.set_title(\"Training image (continuous)\")\n", + "ax1.imshow(field_cont, cmap=\"RdBu_r\", origin=\"lower\", vmin=vmin, vmax=vmax)\n", + "ax1.set_title(\"DS realization\")\n", + "fig.colorbar(im, ax=(ax0, ax1), shrink=0.7)\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "017d0c21", + "metadata": {}, + "source": [ + "## 4. A real training image: the Strebelle channels\n", + "\n", + "The previous examples used tiny synthetic training images. Here we use the\n", + "classic **Strebelle (2002) channelized fluvial training image**, the de-facto\n", + "benchmark for MPS, and condition the simulation on random hard data.\n", + "\n", + "> **Data source / license.** The training image is downloaded from the\n", + "> [GeoDataSets](https://github.com/GeostatsGuy/GeoDataSets) repository by\n", + "> Michael Pyrcz (GeostatsGuy), which is distributed under the **MIT license**\n", + "> (redistribution permitted with attribution). The underlying channel TI is\n", + "> due to Strebelle, S. (2002), *Conditional simulation of complex geological\n", + "> structures using multiple-point statistics*, Mathematical Geology, 34(1),\n", + "> 1-21. If the download is unavailable, the example falls back to a synthetic\n", + "> training image so it still runs offline." + ] + }, + { + "cell_type": "markdown", + "id": "a322ccd4", + "metadata": {}, + "source": [ + "Load the Strebelle training image, with a synthetic fallback for offline use." + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "d3d46961", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "TI (256, 256) (Strebelle (2002) via GeoDataSets (MIT)), sand fraction = 0.291\n" + ] + } + ], + "source": [ + "import os\n", + "import urllib.request\n", + "\n", + "TI_URL = (\n", + " \"https://raw.githubusercontent.com/GeostatsGuy/\"\n", + " \"GeoDataSets/master/MPS_Training_image_and_Realizations_500.npz\"\n", + ")\n", + "CACHE = \"mps_strebelle.npz\"\n", + "try:\n", + " if not os.path.exists(CACHE):\n", + " urllib.request.urlretrieve(TI_URL, CACHE)\n", + " ti_strebelle_arr = np.load(CACHE)[\"array1\"].astype(float)\n", + " source = \"Strebelle (2002) via GeoDataSets (MIT)\"\n", + "except Exception as err: # network fallback\n", + " print(f\"download failed ({err}); using a synthetic channel TI instead\")\n", + " gx, gy = np.meshgrid(np.arange(150), np.arange(150), indexing=\"ij\")\n", + " ti_strebelle_arr = (\n", + " (np.sin(gx / 6.0) + np.sin((gx + gy) / 10.0)) > 0\n", + " ).astype(float)\n", + " source = \"synthetic fallback\"\n", + "\n", + "ti_strebelle = gs.TrainingImage(ti_strebelle_arr, categorical=True)\n", + "print(f\"TI {ti_strebelle.shape} ({source}), sand fraction = {ti_strebelle_arr.mean():.3f}\")" + ] + }, + { + "cell_type": "markdown", + "id": "ea12c5fc", + "metadata": {}, + "source": [ + "Take 80 random conditioning points from the training image patterns." + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "53752f84", + "metadata": {}, + "outputs": [], + "source": [ + "sg_size = 80\n", + "rng = np.random.default_rng(0)\n", + "cond_x = rng.integers(0, sg_size, 80).astype(float)\n", + "cond_y = rng.integers(0, sg_size, 80).astype(float)\n", + "cond_val = ti_strebelle_arr[cond_x.astype(int), cond_y.astype(int)]" + ] + }, + { + "cell_type": "markdown", + "id": "3db056f5", + "metadata": {}, + "source": [ + "Simulate with DSBC-style parameters (best-candidate + partial scan)." + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "513e273e", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "conditioning honoured: 80/80\n" + ] + } + ], + "source": [ + "ds_strebelle = gs.DirectSampling(\n", + " gs.MPSModel(ti_strebelle, n_neighbors=30, scan_fraction=0.2, threshold=0.0)\n", + ")\n", + "ds_strebelle.set_condition([cond_x, cond_y], cond_val)\n", + "field_strebelle = ds_strebelle([np.arange(sg_size, dtype=float)] * 2, seed=42)\n", + "\n", + "honored = int(\n", + " (\n", + " field_strebelle[cond_x.astype(int), cond_y.astype(int)] == cond_val\n", + " ).sum()\n", + ")\n", + "print(f\"conditioning honoured: {honored}/{cond_val.size}\")" + ] + }, + { + "cell_type": "markdown", + "id": "5d64acde", + "metadata": {}, + "source": [ + "Plot the training image crop next to the conditional realization." + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "f3ba3037", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "cmap = ListedColormap([\"#c9a96e\", \"#2b6cb0\"]) # shale / sand\n", + "fig, (ax0, ax1) = plt.subplots(1, 2, figsize=(11, 5.5))\n", + "ax0.imshow(ti_strebelle_arr[:sg_size, :sg_size], cmap=cmap, origin=\"lower\")\n", + "ax0.set_title(\"Training image (crop)\")\n", + "ax1.imshow(field_strebelle, cmap=cmap, origin=\"lower\")\n", + "ax1.scatter(cond_y, cond_x, c=cond_val, cmap=cmap, edgecolors=\"k\", s=18)\n", + "ax1.set_title(\"Conditional DS realization\")\n", + "fig.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "52495d79", + "metadata": {}, + "source": [ + "## Next steps\n", + "\n", + "* The standalone, sphinx-gallery versions of these four examples live in\n", + " this same folder (`00_simple_unconditional.py`, `01_conditional.py`,\n", + " `02_continuous.py`, `03_channel_strebelle.py`) and are built into the\n", + " online documentation gallery.\n", + "* For a deeper dive into the algorithm internals (the distance layer, the\n", + " parallel DAG engine, and an equation map to Mariethoz (2010) / Juda\n", + " (2022)), see `src/gstools/mps/CODE_GUIDE.md`." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "4895092d-349a-4948-9470-a1ee803e96c3", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python (gstools)", + "language": "python", + "name": "gstools" + }, + "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.14.6" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/examples/13_mps/00_simple_unconditional.py b/examples/13_mps/00_simple_unconditional.py new file mode 100644 index 00000000..341c1b54 --- /dev/null +++ b/examples/13_mps/00_simple_unconditional.py @@ -0,0 +1,56 @@ +r""" +A first Direct Sampling simulation +---------------------------------- + +This is the minimal Multiple Point Statistics example: build a training image, +wrap it in a :any:`TrainingImage`, and generate one unconditional realization +with :any:`DirectSampling`. + +We use a small, synthetic *channelized* training image generated with NumPy, so +the example is fast and needs no downloads. +""" + +import matplotlib.pyplot as plt +import numpy as np + +import gstools as gs + +############################################################################### +# Create a synthetic binary training image with curvilinear "channels". +# The two facies (0 and 1) form connected, meandering bands — exactly the kind +# of structure two-point statistics struggles to reproduce. + +gx, gy = np.meshgrid(np.arange(60), np.arange(60), indexing="ij") +ti_data = ((np.sin(gx / 5.0) + np.sin((gx + gy) / 8.0)) > 0).astype(float) + +############################################################################### +# Wrap the array in a :any:`TrainingImage`. For a categorical variable (facies +# codes) the distance is the fraction of mismatching neighbours, so the +# ``distance`` argument is ignored here. + +ti = gs.TrainingImage(ti_data, categorical=True) +print(ti) + +############################################################################### +# Create the :any:`DirectSampling` generator and simulate on a 40x40 grid. +# +# * ``n_neighbors`` — how many already-known cells define each data event. +# * ``scan_fraction`` — fraction of the training image scanned per cell +# (smaller is faster, slightly noisier). +# * ``threshold=0.0`` — the recommended DSBC mode: always take the best match. + +ds = gs.DirectSampling( + gs.MPSModel(ti, n_neighbors=12, scan_fraction=0.3, threshold=0.0) +) +field = ds([np.arange(40, dtype=float)] * 2, seed=20250616) + +############################################################################### +# Plot the training image next to the realization. The realization is not a +# copy of the TI, but it reproduces the same channel patterns. + +fig, (ax0, ax1) = plt.subplots(1, 2, figsize=(10, 5)) +ax0.imshow(ti_data, cmap="cividis", origin="lower") +ax0.set_title("Training image") +ax1.imshow(field, cmap="cividis", origin="lower") +ax1.set_title("DS realization") +fig.tight_layout() diff --git a/examples/13_mps/01_conditional.py b/examples/13_mps/01_conditional.py new file mode 100644 index 00000000..ac9bf6ea --- /dev/null +++ b/examples/13_mps/01_conditional.py @@ -0,0 +1,58 @@ +r""" +Conditioning to hard data +------------------------- + +Real simulations must honour measured data (boreholes, samples). Direct +Sampling supports this through :meth:`~gstools.DirectSampling.set_condition`: +conditioning values are pinned into the grid before simulation and preserved +exactly, while the rest of the field is filled in around them. + +We reuse the synthetic channel training image from the first example. +""" + +import matplotlib.pyplot as plt +import numpy as np + +import gstools as gs + +############################################################################### +# Same synthetic channelized training image as before. + +gx, gy = np.meshgrid(np.arange(60), np.arange(60), indexing="ij") +ti_data = ((np.sin(gx / 5.0) + np.sin((gx + gy) / 8.0)) > 0).astype(float) +ti = gs.TrainingImage(ti_data, categorical=True) + +############################################################################### +# Draw 40 random "hard data" points and read their facies from the TI. In a +# real study these would be field measurements; here we sample the TI so the +# conditioning data are consistent with the patterns. + +rng = np.random.default_rng(0) +cond_x = rng.integers(0, 40, 40).astype(float) +cond_y = rng.integers(0, 40, 40).astype(float) +cond_val = ti_data[cond_x.astype(int), cond_y.astype(int)] + +############################################################################### +# Set the conditioning data and simulate. ``set_condition`` snaps each point to +# its nearest grid node, so the values are honoured exactly at those cells. + +ds = gs.DirectSampling( + gs.MPSModel(ti, n_neighbors=12, scan_fraction=0.3, threshold=0.0) +) +ds.set_condition([cond_x, cond_y], cond_val) +field = ds([np.arange(40, dtype=float)] * 2, seed=7) + +honored = int( + (field[cond_x.astype(int), cond_y.astype(int)] == cond_val).sum() +) +print(f"conditioning honoured: {honored}/{cond_val.size}") + +############################################################################### +# Plot the realization with the conditioning points overlaid. Every marker sits +# on a cell whose simulated facies matches the datum. + +fig, ax = plt.subplots(figsize=(6, 5)) +ax.imshow(field, cmap="cividis", origin="lower") +ax.scatter(cond_y, cond_x, c=cond_val, cmap="cividis", edgecolors="red", s=30) +ax.set_title("Conditional DS realization (red-edged = hard data)") +fig.tight_layout() diff --git a/examples/13_mps/02_continuous.py b/examples/13_mps/02_continuous.py new file mode 100644 index 00000000..92f876b3 --- /dev/null +++ b/examples/13_mps/02_continuous.py @@ -0,0 +1,62 @@ +r""" +Continuous variables and distance metrics +----------------------------------------- + +Direct Sampling is not limited to categorical facies: with ``categorical=False`` +it simulates continuous variables (permeability, porosity, elevation, ...). The +``distance`` argument then selects how two patterns are compared: + +* ``"l1"`` / ``"l2"`` — Manhattan / Euclidean distance on the raw values + (Mariethoz et al., 2010, Eq. 6 / Eq. 4). +* ``"variation"`` — compares only the *relative* variations within a pattern + (Eq. 9), tolerating a locally varying mean. Useful for non-stationary data. + +Here we use a smooth continuous training image and a small acceptance +``threshold`` (standard DS mode) to allow approximate matches. + +.. note:: + + The acceptance ``threshold`` is **not comparable across metrics**: the + ``"variation"`` distance is normalised by ``2·d_max``, so the same value is + stricter than it would be for ``"l1"``/``"l2"``. Re-tune it when you switch + the distance metric. +""" + +import matplotlib.pyplot as plt +import numpy as np + +import gstools as gs + +############################################################################### +# A smooth, continuous synthetic training image. + +gx, gy = np.meshgrid(np.arange(60), np.arange(60), indexing="ij") +ti_data = np.sin(gx / 6.0) * np.cos(gy / 8.0) + +############################################################################### +# Build a continuous training image with the Euclidean (``"l2"``) distance. + +ti = gs.TrainingImage(ti_data, categorical=False, distance="l2") +print(ti) + +############################################################################### +# Simulate. ``threshold=0.03`` accepts the first pattern within that distance +# (standard DS), which is faster than the exhaustive best-candidate search for +# continuous variables. + +ds = gs.DirectSampling( + gs.MPSModel(ti, n_neighbors=12, scan_fraction=0.3, threshold=0.03) +) +field = ds([np.arange(32, dtype=float)] * 2, seed=3) + +############################################################################### +# Plot. The realization reproduces the smooth wavy structure of the TI without +# copying it. A shared colour scale makes the comparison fair. + +vmin, vmax = ti_data.min(), ti_data.max() +fig, (ax0, ax1) = plt.subplots(1, 2, figsize=(10, 5)) +im = ax0.imshow(ti_data, cmap="RdBu_r", origin="lower", vmin=vmin, vmax=vmax) +ax0.set_title("Training image (continuous)") +ax1.imshow(field, cmap="RdBu_r", origin="lower", vmin=vmin, vmax=vmax) +ax1.set_title("DS realization") +fig.colorbar(im, ax=(ax0, ax1), shrink=0.7) diff --git a/examples/13_mps/03_channel_strebelle.py b/examples/13_mps/03_channel_strebelle.py new file mode 100644 index 00000000..fd2262fc --- /dev/null +++ b/examples/13_mps/03_channel_strebelle.py @@ -0,0 +1,85 @@ +r""" +A real training image: the Strebelle channels +---------------------------------------------- + +The previous examples used tiny synthetic training images. Here we use the +classic **Strebelle (2002) channelized fluvial training image**, the de-facto +benchmark for MPS, and condition the simulation on random hard data. + +.. note:: + + **Data source / license.** The training image is downloaded from the + `GeoDataSets `_ repository by + Michael Pyrcz (GeostatsGuy), which is distributed under the **MIT license** + (redistribution permitted with attribution). The underlying channel TI is + due to Strebelle, S. (2002), *Conditional simulation of complex geological + structures using multiple-point statistics*, Mathematical Geology, 34(1), + 1-21. If the download is unavailable, the example falls back to a synthetic + training image so it still runs offline. +""" + +import os +import urllib.request + +import matplotlib.pyplot as plt +import numpy as np +from matplotlib.colors import ListedColormap + +import gstools as gs + +############################################################################### +# Load the Strebelle training image, with a synthetic fallback for offline use. + +TI_URL = ( + "https://raw.githubusercontent.com/GeostatsGuy/" + "GeoDataSets/master/MPS_Training_image_and_Realizations_500.npz" +) +CACHE = "mps_strebelle.npz" +try: + if not os.path.exists(CACHE): + urllib.request.urlretrieve(TI_URL, CACHE) + ti_arr = np.load(CACHE)["array1"].astype(float) + source = "Strebelle (2002) via GeoDataSets (MIT)" +except Exception as err: # pragma: no cover - network fallback + print(f"download failed ({err}); using a synthetic channel TI instead") + gx, gy = np.meshgrid(np.arange(150), np.arange(150), indexing="ij") + ti_arr = ((np.sin(gx / 6.0) + np.sin((gx + gy) / 10.0)) > 0).astype(float) + source = "synthetic fallback" + +ti = gs.TrainingImage(ti_arr, categorical=True) +print(f"TI {ti.shape} ({source}), sand fraction = {ti_arr.mean():.3f}") + +############################################################################### +# Take 80 random conditioning points from the training image patterns. + +sg_size = 80 +rng = np.random.default_rng(0) +cond_x = rng.integers(0, sg_size, 80).astype(float) +cond_y = rng.integers(0, sg_size, 80).astype(float) +cond_val = ti_arr[cond_x.astype(int), cond_y.astype(int)] + +############################################################################### +# Simulate with DSBC-style parameters (best-candidate + partial scan). + +ds = gs.DirectSampling( + gs.MPSModel(ti, n_neighbors=30, scan_fraction=0.2, threshold=0.0) +) +ds.set_condition([cond_x, cond_y], cond_val) +field = ds([np.arange(sg_size, dtype=float)] * 2, seed=42) + +honored = int( + (field[cond_x.astype(int), cond_y.astype(int)] == cond_val).sum() +) +print(f"conditioning honoured: {honored}/{cond_val.size}") + +############################################################################### +# Plot the training image crop next to the conditional realization. + +cmap = ListedColormap(["#c9a96e", "#2b6cb0"]) # shale / sand +fig, (ax0, ax1) = plt.subplots(1, 2, figsize=(11, 5.5)) +ax0.imshow(ti_arr[:sg_size, :sg_size], cmap=cmap, origin="lower") +ax0.set_title("Training image (crop)") +ax1.imshow(field, cmap=cmap, origin="lower") +ax1.scatter(cond_y, cond_x, c=cond_val, cmap=cmap, edgecolors="k", s=18) +ax1.set_title("Conditional DS realization") +fig.tight_layout() diff --git a/examples/13_mps/README.rst b/examples/13_mps/README.rst new file mode 100644 index 00000000..a5ecfca8 --- /dev/null +++ b/examples/13_mps/README.rst @@ -0,0 +1,38 @@ +Multiple Point Statistics +========================= + +Two-point geostatistics (covariance models, kriging, SRFs) describes spatial +structure through pairs of points and a variogram. This is powerful, but it +cannot reproduce *curvilinear* or *connected* features such as meandering +channels, fractures, or other patterns that depend on the joint configuration +of many points at once. + +**Multiple Point Statistics (MPS)** addresses this by learning patterns +directly from a **training image (TI)** — an example image deemed +representative of the spatial structure to simulate. Instead of fitting a +variogram, MPS borrows whole patterns from the TI. + +GSTools provides the **Direct Sampling (DS)** algorithm +(`Mariethoz et al., 2010 `_), together +with the **Direct Sampling Best Candidate (DSBC)** parametrization +(`Juda et al., 2022 `_), through +two classes: + +* :any:`TrainingImage` — the MPS model: the training image plus the distance + used to compare patterns (the analogue of a :any:`CovModel`). +* :any:`DirectSampling` — the generator that produces realizations on a + structured grid (the analogue of :any:`SRF`). + +The core idea: to fill each grid cell, DS looks at the values already present +around it (its *data event*), scans the training image for a location whose +surroundings look similar enough, and copies that cell's value over. +"Similar enough" is decided by a **distance** between the two surroundings, +controlled by three parameters — the number of neighbours ``n``, the scan +fraction ``f``, and the acceptance threshold ``t`` (with ``t = 0`` giving the +recommended DSBC mode). + +The following tutorials build up from a minimal unconditional simulation to +conditioning and continuous variables. + +Examples +-------- diff --git a/examples/13_mps/_preview/00_training_image.png b/examples/13_mps/_preview/00_training_image.png new file mode 100755 index 0000000000000000000000000000000000000000..bdadd21761fe1b4bb8d57b20c7ba2681a358e70c GIT binary patch literal 89290 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�X)xLX{@<7b8y)JK>${Xlngo(ogZ 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 Le~8{F7uebd~+z{Hq`gX;tb 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 literal 0 HcmV?d00001 diff --git a/examples/13_mps/_preview/02_conditioning.png b/examples/13_mps/_preview/02_conditioning.png new file mode 100755 index 0000000000000000000000000000000000000000..899f4de6a5e2929debfc4e4a82a52955b5293ba1 GIT binary patch literal 50554 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 GzxiL6jfw#P literal 0 HcmV?d00001 diff --git a/examples/13_mps/_preview/03_ensemble.png b/examples/13_mps/_preview/03_ensemble.png new file mode 100755 index 0000000000000000000000000000000000000000..139e7d028d0f8556ab60e24767a4ec1a0ef0bd99 GIT binary patch literal 57017 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

6G9qofawFJc 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 Z&u!4xOMckvDM)|JP*mHKu5kF={{iWLYzP1V literal 0 HcmV?d00001 diff --git a/examples/13_mps/_preview/05_continuous_srf_ti.png b/examples/13_mps/_preview/05_continuous_srf_ti.png new file mode 100755 index 0000000000000000000000000000000000000000..a7b0313a41f151230e69cebdafa7240ce67f0d02 GIT binary patch literal 153307 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

"`` -> ``(p, None)``; ``"variation"`` -> ``(None, 2.0)``; + ``"variation

"`` -> ``(None, p)``. + + Returns + ------- + tuple of (float or None, float or None) + """ + distance_lower = str(distance).lower() + if distance_lower.startswith("l"): + try: + p_val = float(distance_lower[1:]) + except ValueError: + raise ValueError( + f"TrainingImage: distance starting with 'l' must be followed by " + f"a positive number (e.g. 'l1', 'l2', 'l3.5'). Got {distance!r}" + ) + if p_val <= 0: + raise ValueError( + f"TrainingImage: Lp norm exponent must be > 0, got {p_val}." + ) + return p_val, None + if distance_lower == "variation": + return None, 2.0 + if distance_lower.startswith("variation"): + try: + p_val = float(distance_lower[len("variation") :]) + except ValueError: + raise ValueError( + f"TrainingImage: distance starting with 'variation' must be " + f"followed by a positive number (e.g. 'variation1', 'variation1.5'). " + f"Got {distance!r}" + ) + if p_val <= 0: + raise ValueError( + f"TrainingImage: variation exponent must be > 0, got {p_val}." + ) + return None, p_val + raise ValueError( + f"TrainingImage: distance must be 'l

' (e.g. 'l1', 'l2'), " + f"'variation', or 'variation

' (e.g. 'variation1'). " + f"Got {distance!r}" + ) + + def _init_multivariate(self, data, categorical, weights, distance): + """Initialise a multivariate (dict-valued) training image. + + Parameters + ---------- + data : dict of {str: numpy.ndarray} + Named variable arrays (all the same shape). + categorical : bool or dict of {str: bool} + Categorical flag, scalar (broadcast) or per-variable. + weights : dict of {str: float} or None + Per-variable distance weights (must sum to 1); ``None`` → uniform. + distance : str or dict of {str: str} + Continuous-distance metric, scalar (broadcast) or per-variable. + """ + self._multivariate = True + self._data = None + self._variables = {k: np.array(v, copy=True) for k, v in data.items()} + if len(self._variables) == 0: + raise ValueError("TrainingImage: multivariate data dict is empty.") + shapes = {v.shape for v in self._variables.values()} + if len(shapes) != 1: + raise ValueError("All variables must have the same shape.") + self._shape = shapes.pop() + names = list(self._variables) + _warn_if_nan(*self._variables.values()) + + self._categorical = ( + {k: bool(categorical[k]) for k in names} + if isinstance(categorical, dict) + else {k: bool(categorical) for k in names} + ) + self._distance_type = ( + {k: distance[k] for k in names} + if isinstance(distance, dict) + else {k: distance for k in names} + ) + self._p_norm, self._variation_p_norm, self._d_max = {}, {}, {} + for k in names: + if self._categorical[k]: + self._p_norm[k] = None + self._variation_p_norm[k] = None + self._d_max[k] = None + else: + self._p_norm[k], self._variation_p_norm[k] = ( + self._parse_distance(self._distance_type[k]) + ) + self._d_max[k] = _data_range(self._variables[k]) + + if weights is None: + self._weights = {k: 1.0 / len(names) for k in names} + else: + missing = set(names) - set(weights) + if missing: + raise ValueError( + f"TrainingImage: weights missing for variables {sorted(missing)}." + ) + extra = set(weights) - set(names) + if extra: + raise ValueError( + f"TrainingImage: weights has unknown variables {sorted(extra)}." + ) + wsum = float(sum(weights[k] for k in names)) + if not np.isclose(wsum, 1.0): + raise ValueError(f"weights must sum to 1.0, got {wsum}.") + self._weights = {k: float(weights[k]) for k in names} + + # ------------------------------------------------------------------ + # Properties + # ------------------------------------------------------------------ + + @property + def data(self): + """numpy.ndarray: Raw training image data.""" + return self._data + + @property + def ndim(self): + """int: Number of spatial dimensions.""" + return len(self._shape) + + @property + def shape(self): + """tuple: Shape of the training image (shared across variables).""" + return self._shape + + @property + def multivariate(self): + """bool: Whether the TI holds multiple co-simulated variables.""" + return self._multivariate + + @property + def variables(self): + """list or None: Variable names (insertion order, all equal), or None if univariate.""" + return list(self._variables) if self._multivariate else None + + @property + def weights(self): + """dict or None: Per-variable distance weights (sum to 1), or None.""" + return dict(self._weights) if self._multivariate else None + + def variable(self, name): + """numpy.ndarray: Data array for one variable (multivariate TIs). + + Parameters + ---------- + name : str + Variable name. + + Returns + ------- + numpy.ndarray + """ + if not self._multivariate: + raise TypeError( + "variable() is only available on multivariate TrainingImages." + ) + return self._variables[name] + + @property + def categorical(self): + """bool or dict of {str: bool}: Whether the variable(s) are categorical.""" + return self._categorical + + @property + def distance_type(self): + """str or dict of {str: str}: Distance metric(s) (e.g. ``"l1"``, ``"l2"``, ``"variation"``).""" + return self._distance_type + + @property + def distance_power(self): + """float: Spatial-decay exponent δ for node weighting.""" + return self._distance_power + + # ------------------------------------------------------------------ + # Distance + # ------------------------------------------------------------------ + + def _dispatch_metric( + self, + categorical, + p_norm, + vp_norm, + d_max, + de_sim, + all_de_ti, + w, + has_nan=False, + ): + """Select and call the right vectorized distance function. + + Parameters + ---------- + categorical : bool + p_norm : float or None + vp_norm : float or None + d_max : float or None + de_sim : numpy.ndarray, shape (n,) + all_de_ti : numpy.ndarray, shape (max_scan, n) + w : numpy.ndarray, shape (n,) + has_nan : bool, optional + Enable per-row exclusion of undefined (NaN) TI positions, with + per-row weight renormalization. Default ``False``. + + Returns + ------- + numpy.ndarray, shape (max_scan,) + Distance in [0, 1] for each candidate. + """ + if categorical: + return vec_categorical_dist(de_sim, all_de_ti, w, has_nan=has_nan) + if p_norm == 1.0: + return vec_l1_dist(de_sim, all_de_ti, w, d_max, has_nan=has_nan) + if p_norm == 2.0: + return vec_l2_dist(de_sim, all_de_ti, w, d_max, has_nan=has_nan) + if p_norm is not None: + return vec_lp_dist( + de_sim, all_de_ti, w, d_max, p_norm, has_nan=has_nan + ) + return vec_variation_dist( + de_sim, all_de_ti, w, d_max, vp_norm, has_nan=has_nan + ) + + def adjust_value(self, ti_val, data_event_sim, data_event_ti, var=None): + """Adjust matched TI value before assignment to SG. + + For ``distance="variation"``, applies the mean-shift correction + (Mariethoz2010 Eq. 9): Z(x_i) = Z(y) − Z̄(y) + Z̄(x_i). + For all other metrics returns *ti_val* unchanged. + + Parameters + ---------- + ti_val : float + Raw value at the matched TI node. + data_event_sim : array-like + SG data event (used to compute Z̄(x_i)). + data_event_ti : array-like + TI data event (used to compute Z̄(y)). + var : str, optional + Variable name for multivariate TIs. When ``None``, uses the + univariate attributes. + + Returns + ------- + float + """ + if var is None: + categorical = self._categorical + vp_norm = self._variation_p_norm + else: + categorical = self._categorical[var] + vp_norm = self._variation_p_norm[var] + if vp_norm is None or categorical: + return ti_val + data_event_sim = np.asarray(data_event_sim, dtype=np.float64) + data_event_ti = np.asarray(data_event_ti, dtype=np.float64) + if data_event_sim.size == 0 or data_event_ti.size == 0: + return ti_val + # nanmean: the matched TI event may include undefined (NaN) neighbours + # on a masked TI; de-mean over the defined positions only. For a fully + # finite event this is identical to ``mean``. If every TI neighbour is + # undefined, drop the TI mean-shift term (treat as 0). + ti_mean = ( + np.nanmean(data_event_ti) + if np.isfinite(data_event_ti).any() + else 0.0 + ) + return float(ti_val - ti_mean + np.nanmean(data_event_sim)) + + def vec_distance_var( + self, + var, + de_sim, + all_de_ti, + cond_mask=None, + cond_weight=1.0, + lag_norms=None, + weights=None, + has_nan=False, + ): + """Vectorized distance for one variable over all TI scan candidates. + + Parameters + ---------- + var : str + Variable name. + de_sim : array-like, shape (n,) + SG data event for this variable. + all_de_ti : array-like, shape (max_scan, n) + TI data events for every scan candidate. + cond_mask : array-like of bool, optional + cond_weight : float, optional + lag_norms : array-like, shape (n,), optional + weights : numpy.ndarray, optional + Pre-computed node weights. If given, skips the internal + ``compute_node_weights`` call. + has_nan : bool, optional + Enable per-row exclusion of undefined (NaN) TI positions, with + per-row weight renormalization. Default ``False``. + + Returns + ------- + numpy.ndarray, shape (max_scan,) + Distance in [0, 1] for each candidate. + """ + de_sim = np.asarray(de_sim, dtype=np.float64) + all_de_ti = np.asarray(all_de_ti, dtype=np.float64) + n = len(de_sim) + if n == 0: + return np.zeros(len(all_de_ti)) + w = ( + weights + if weights is not None + else compute_node_weights( + n, lag_norms, self._distance_power, cond_mask, cond_weight + ) + ) + return self._dispatch_metric( + self._categorical[var], + self._p_norm[var], + self._variation_p_norm[var], + self._d_max[var], + de_sim, + all_de_ti, + w, + has_nan=has_nan, + ) + + def __repr__(self): + return ( + f"TrainingImage(shape={self.shape}, " + f"categorical={self._categorical}, " + f"distance={self._distance_type!r})" + ) diff --git a/tests/test_mps.py b/tests/test_mps.py new file mode 100755 index 00000000..2b0d49ae --- /dev/null +++ b/tests/test_mps.py @@ -0,0 +1,2198 @@ +#!/usr/bin/env python +"""Unittest for the MPS module (TrainingImage and DirectSampling).""" + +import unittest +import warnings + +import numpy as np + +import gstools as gs +from gstools import config as gs_config +from gstools.mps.direct_sampling import DirectSampling +from gstools.mps.distance import ( + compute_node_weights, + vec_categorical_dist, + vec_l1_dist, + vec_l2_dist, + vec_lp_dist, + vec_variation_dist, +) +from gstools.mps.model import MPSModel +from gstools.mps.neighbors import ( + _precompute_offsets, + _reduce_to_fit, + _transform_lags, + _window_bounds, +) +from gstools.mps.scan import _scan_window +from gstools.mps.simulate import _MV_VAR, _univar_as_mv_ti, ds_simulate +from gstools.mps.training_image import TrainingImage + + +def _uni_dist(ti, de_sim, de_ti, **kw): + """Univariate data-event distance via the vectorized production path. + + The scalar ``TrainingImage.distance`` was removed; tests exercise the same + ``vec_distance_var`` the simulation uses by wrapping the univariate TI as + the engine does and reading out the single candidate row. + """ + mv = _univar_as_mv_ti(ti) + row = np.asarray(de_ti, dtype=float)[np.newaxis, :] + return float(mv.vec_distance_var(_MV_VAR, de_sim, row, **kw)[0]) + + +def _mv_dist(ti, de_sim, de_ti, **kw): + """Multivariate joint data-event distance via the vectorized path.""" + total = 0.0 + for k in ti.variables: + row = np.asarray(de_ti[k], dtype=float)[np.newaxis, :] + total += ti.weights[k] * float( + ti.vec_distance_var(k, de_sim[k], row, **kw)[0] + ) + return total + + +class TestDirectSamplingParallel(unittest.TestCase): + def test_valid_values(self): + rng = np.random.default_rng(0) + data = rng.integers(0, 3, (20, 20)) + ti = TrainingImage(data) + ds = DirectSampling(MPSModel(ti, n_neighbors=8, scan_fraction=0.2)) + ds.num_threads = 2 + field = ds([np.arange(8, dtype=float)] * 2, seed=0) + self.assertEqual(field.shape, (8, 8)) + self.assertTrue(np.all(np.isin(field, [0, 1, 2]))) + + def test_reproducible(self): + # DAG parallelism is deterministic: same seed → same parallel result + rng = np.random.default_rng(0) + data = rng.integers(0, 3, (20, 20)) + ti = TrainingImage(data) + ds = DirectSampling(MPSModel(ti, n_neighbors=8, scan_fraction=0.2)) + ds.num_threads = 2 + pos = [np.arange(8, dtype=float)] * 2 + self.assertTrue(np.array_equal(ds(pos, seed=7), ds(pos, seed=7))) + + def test_conditioning_preserved(self): + rng = np.random.default_rng(0) + data = rng.integers(0, 3, (20, 20)) + ti = TrainingImage(data) + ds = DirectSampling(MPSModel(ti, n_neighbors=4, scan_fraction=0.2)) + ds.num_threads = 2 + ds.set_condition([[5.0], [5.0]], [2]) + field = ds([np.arange(10, dtype=float)] * 2, seed=0) + self.assertEqual(field[5, 5], 2) + + def test_global_config(self): + # num_threads=None reads gs_config.NUM_THREADS + rng = np.random.default_rng(0) + data = rng.integers(0, 3, (20, 20)) + ti = TrainingImage(data) + pos = [np.arange(8, dtype=float)] * 2 + old = gs_config.NUM_THREADS + try: + gs_config.NUM_THREADS = 2 + field = DirectSampling( + MPSModel(ti, n_neighbors=8, scan_fraction=0.2) + )(pos, seed=7) + finally: + gs_config.NUM_THREADS = old + self.assertEqual(field.shape, (8, 8)) + self.assertTrue(np.all(np.isin(field, [0, 1, 2]))) + + def test_large_batches(self): + # n_neighbors=2 → sparse DAG → large ready batches + rng = np.random.default_rng(1) + data = rng.integers(0, 2, (30, 30)) + ti = TrainingImage(data) + pos = [np.arange(12, dtype=float)] * 2 + ds = DirectSampling(MPSModel(ti, n_neighbors=2, scan_fraction=0.3)) + ds.num_threads = 4 + field = ds(pos, seed=42) + self.assertEqual(field.shape, (12, 12)) + self.assertTrue(np.all(np.isin(field, [0.0, 1.0]))) + + def test_stress(self): + # large grid, sparse DAG, conditioning, varying thread counts + rng = np.random.default_rng(3) + data = rng.integers(0, 4, (40, 40)) + ti = TrainingImage(data) + pos = [np.arange(25, dtype=float)] * 2 + cond_pos = [ + rng.integers(0, 25, 20).astype(float), + rng.integers(0, 25, 20).astype(float), + ] + cond_val = rng.integers(0, 4, 20).astype(float) + for nt in (2, 4, 8): + ds = DirectSampling(MPSModel(ti, n_neighbors=3, scan_fraction=0.4)) + ds.num_threads = nt + ds.set_condition(cond_pos, cond_val) + field = ds(pos, seed=11) + self.assertEqual(field.shape, (25, 25)) + self.assertTrue(np.all(np.isin(field, [0, 1, 2, 3]))) + + def test_all_nan_ti_no_typeerror(self): + # Regression test for _scan_window None return on all-NaN TI. + # When every candidate distance is NaN, best_y stays None without + # the fallback. Verify the fallback is triggered and no TypeError occurs + # (ValueError from NaN output is acceptable for all-NaN TI). + ti_data = np.full((5, 5), np.nan, dtype=float) + ti = TrainingImage(ti_data, categorical=False, distance="l2") + ds = DirectSampling(MPSModel(ti, n_neighbors=2, scan_fraction=0.2)) + ds.num_threads = 1 + try: + field = ds([np.arange(3, dtype=float)] * 2, seed=42) + # If we get here, simulation completed without TypeError. + # Field may contain NaN due to the all-NaN TI. + self.assertIsNotNone(field) + except TypeError as e: + self.fail(f"Fallback did not prevent TypeError: {e}") + except ValueError: + # ValueError from _write_result NaN check is acceptable when + # TI is all-NaN; the important thing is no TypeError occurs. + pass + + +class TestTrainingImage(unittest.TestCase): + def setUp(self): + arr_cat = np.array([[0, 1, 0], [1, 0, 1], [0, 1, 0]], dtype=float) + self.ti_cat = TrainingImage(arr_cat, categorical=True) + + arr_cont = np.linspace(0.0, 1.0, 20) + self.ti_cont = TrainingImage( + arr_cont, categorical=False, distance="l1" + ) + + def test_properties(self): + np.testing.assert_array_equal( + self.ti_cat.data, + np.array([[0, 1, 0], [1, 0, 1], [0, 1, 0]], dtype=float), + ) + self.assertEqual(self.ti_cat.ndim, 2) + self.assertEqual(self.ti_cat.shape, (3, 3)) + self.assertTrue(self.ti_cat.categorical) + self.assertEqual( + self.ti_cat.distance_type, "l1" + ) # default ignored for cat + self.assertIsInstance(repr(self.ti_cat), str) + self.assertIn("TrainingImage", repr(self.ti_cat)) + + self.assertEqual(self.ti_cont.ndim, 1) + self.assertEqual(self.ti_cont.shape, (20,)) + self.assertFalse(self.ti_cont.categorical) + self.assertEqual(self.ti_cont.distance_type, "l1") + + def test_raise(self): + with self.assertRaises(ValueError): + TrainingImage(np.ones(10), categorical=False, distance="l0") + with self.assertRaises(ValueError): + TrainingImage(np.ones(10), categorical=False, distance="labc") + with self.assertRaises(ValueError): + TrainingImage(np.ones(10), categorical=False, distance="invalid") + + def test_distance_categorical(self): + # Identical events → 0.0 + a = np.array([0.0, 1.0, 0.0]) + dist = _uni_dist(self.ti_cat, a, a) + self.assertAlmostEqual(dist, 0.0) + + # Completely mismatched, uniform weights → 1.0 + b = np.array([1.0, 0.0, 1.0]) + dist = _uni_dist(self.ti_cat, a, b) + self.assertAlmostEqual(dist, 1.0) + + # One of three mismatched → 1/3 + c = np.array([1.0, 1.0, 0.0]) + dist = _uni_dist(self.ti_cat, a, c) + self.assertAlmostEqual(dist, 1.0 / 3.0) + + # Two of four mismatched → 0.5 (spec-required half-mismatch case) + a4 = np.array([0.0, 1.0, 0.0, 1.0]) + c4 = np.array([1.0, 0.0, 0.0, 1.0]) + dist = _uni_dist(self.ti_cat, a4, c4) + self.assertAlmostEqual(dist, 0.5) + + def test_distance_continuous(self): + x = np.array([0.0, 0.5, 1.0]) + y = np.array([0.2, 0.3, 0.8]) + + # l1 + ti_l1 = TrainingImage( + np.linspace(0.0, 1.0, 10), categorical=False, distance="l1" + ) + self.assertAlmostEqual(_uni_dist(ti_l1, x, x), 0.0) + self.assertAlmostEqual(_uni_dist(ti_l1, x, y), 0.2, places=6) + + # l2 + ti_l2 = TrainingImage( + np.linspace(0.0, 1.0, 10), categorical=False, distance="l2" + ) + self.assertAlmostEqual(_uni_dist(ti_l2, x, x), 0.0) + self.assertAlmostEqual(_uni_dist(ti_l2, x, y), 0.2, places=6) + + # lp (p=3.5) — non-uniform diffs [0.3, 0.1, 0.3] distinguish lp from l1/l2 + y_lp = np.array([0.3, 0.4, 0.7]) + ti_lp = TrainingImage( + np.linspace(0.0, 1.0, 10), categorical=False, distance="l3.5" + ) + self.assertAlmostEqual(_uni_dist(ti_lp, x, x), 0.0) + self.assertAlmostEqual(_uni_dist(ti_lp, x, y_lp), 0.2680, places=3) + self.assertGreater( + _uni_dist(ti_lp, x, y_lp), _uni_dist(ti_l1, x, y_lp) + ) + + # variation (default p=2) + ti_var = TrainingImage( + np.linspace(0.0, 1.0, 10), categorical=False, distance="variation" + ) + self.assertAlmostEqual(_uni_dist(ti_var, x, x), 0.0) + self.assertAlmostEqual(_uni_dist(ti_var, x, y), 0.094281, places=5) + # constant shift → distance = 0 (key behavioral property of variation distance) + self.assertAlmostEqual(_uni_dist(ti_var, x, x + 0.15), 0.0, places=10) + + # variation1 (L^1 aggregation) + ti_var1 = TrainingImage( + np.linspace(0.0, 1.0, 10), categorical=False, distance="variation1" + ) + self.assertAlmostEqual(_uni_dist(ti_var1, x, x), 0.0) + self.assertAlmostEqual(_uni_dist(ti_var1, x, y), 0.08889, places=4) + self.assertAlmostEqual(_uni_dist(ti_var1, x, x + 0.15), 0.0, places=10) + # L^1 < L^2 for non-uniform diffs + self.assertLess(_uni_dist(ti_var1, x, y), _uni_dist(ti_var, x, y)) + + # variation2 explicit matches variation (regression guard) + ti_var2 = TrainingImage( + np.linspace(0.0, 1.0, 10), categorical=False, distance="variation2" + ) + self.assertAlmostEqual( + _uni_dist(ti_var2, x, y), _uni_dist(ti_var, x, y), places=10 + ) + + def test_adjust_value(self): + # Categorical and lp: passthrough + self.assertAlmostEqual( + self.ti_cat.adjust_value( + 0.7, np.array([0.1, 0.3]), np.array([0.4, 0.6]) + ), + 0.7, + ) + self.assertAlmostEqual( + self.ti_cont.adjust_value( + 0.7, np.array([0.1, 0.3]), np.array([0.4, 0.6]) + ), + 0.7, + ) + + # variation: Z(y) - Z_bar(y) + Z_bar(x) = 0.7 - 0.6 + 0.3 = 0.4 + ti_var = TrainingImage( + np.linspace(0.0, 1.0, 20), categorical=False, distance="variation" + ) + result = ti_var.adjust_value( + 0.7, np.array([0.1, 0.3, 0.5]), np.array([0.4, 0.6, 0.8]) + ) + self.assertAlmostEqual(result, 0.4, places=6) + self.assertNotAlmostEqual(result, 0.7) # must not be passthrough + + def test_distance_weights(self): + a = np.array([0.0, 1.0, 0.0]) + b = np.array([1.0, 1.0, 0.0]) # first element differs + + # cond_weight=2 on first node → it gets weight 0.5 (double) + d1 = _uni_dist( + self.ti_cat, a, b, cond_mask=[True, False, False], cond_weight=1.0 + ) + d2 = _uni_dist( + self.ti_cat, a, b, cond_mask=[True, False, False], cond_weight=2.0 + ) + self.assertGreater(d2, d1) + + # distance_power shifts weight toward closer neighbours — use non-uniform + # differences so the weighted sums actually differ: diffs = [0, 0, 0.5] + ti_p = TrainingImage( + np.linspace(0.0, 1.0, 10), + categorical=False, + distance="l1", + distance_power=1.0, + ) + ti_flat = TrainingImage( + np.linspace(0.0, 1.0, 10), + categorical=False, + distance="l1", + distance_power=0.0, + ) + x = np.array([0.0, 0.5, 1.0]) + z = np.array([0.0, 0.5, 0.5]) # only third element differs + lags = np.array([1.0, 2.0, 3.0]) + d_power = _uni_dist(ti_p, x, z, lag_norms=lags) + d_flat = _uni_dist(ti_flat, x, z, lag_norms=lags) + # power=1 weights far neighbours less → smaller distance for far mismatch + self.assertLess(d_power, d_flat) + + def test_distance_empty_event(self): + dist = _uni_dist(self.ti_cat, np.array([]), np.array([])) + self.assertAlmostEqual(dist, 0.0) + + def test_distance_functions_directly(self): + a = np.array([0.0, 1.0, 0.0]) + b = np.array([1.0, 0.0, 1.0]) + w = np.array([1 / 3, 1 / 3, 1 / 3]) + + # weights sum to 1 + w2 = compute_node_weights(3, None, 0.0) + self.assertAlmostEqual(w2.sum(), 1.0) + + # cond_weight=2 on first node → uniform spatial weights → w[0] = 2/(2+1+1) = 0.5 + w3 = compute_node_weights( + 3, + None, + 0.0, + cond_mask=[True, False, False], + cond_weight=2.0, + ) + self.assertAlmostEqual(w3.sum(), 1.0) + self.assertAlmostEqual(w3[0], 0.5, places=6) + + # The simulation calls only the vectorized distance functions; test + # them directly by passing a single candidate as a shape-(1, n) row and + # reading element [0] out. + def cat(s, t): + return float(vec_categorical_dist(s, t[np.newaxis, :], w)[0]) + + def l1(s, t, dm): + return float(vec_l1_dist(s, t[np.newaxis, :], w, dm)[0]) + + def l2(s, t, dm): + return float(vec_l2_dist(s, t[np.newaxis, :], w, dm)[0]) + + def lp(s, t, dm, p): + return float(vec_lp_dist(s, t[np.newaxis, :], w, dm, p)[0]) + + def var(s, t, dm, p=2.0): + return float(vec_variation_dist(s, t[np.newaxis, :], w, dm, p)[0]) + + # categorical: identical → 0, opposite → 1 + self.assertAlmostEqual(cat(a, a), 0.0) + self.assertAlmostEqual(cat(a, b), 1.0) + + # continuous: identical → 0 + x = np.array([0.0, 0.5, 1.0]) + d_max = 1.0 + self.assertAlmostEqual(l1(x, x, d_max), 0.0) + self.assertAlmostEqual(l2(x, x, d_max), 0.0) + self.assertAlmostEqual(lp(x, x, d_max, 3.5), 0.0) + self.assertAlmostEqual(var(x, x, d_max), 0.0) + self.assertAlmostEqual(var(x, x, d_max, p=1.0), 0.0) + + # distances in [0, 1] + y = np.array([0.2, 0.3, 0.8]) + self.assertAlmostEqual(l1(x, y, d_max), 0.2, places=6) + self.assertAlmostEqual(l2(x, y, d_max), 0.2, places=6) + self.assertAlmostEqual(var(x, y, d_max), 0.094281, places=5) + self.assertAlmostEqual(var(x, y, d_max, p=1.0), 0.08889, places=4) + # p=2 explicit matches default + self.assertAlmostEqual( + var(x, y, d_max, p=2.0), var(x, y, d_max), places=10 + ) + + # lp: non-uniform diffs [0.3, 0.1, 0.3] verify the p-norm exponent is used + y_lp = np.array([0.3, 0.4, 0.7]) + self.assertAlmostEqual(lp(x, y_lp, d_max, 3.5), 0.2680, places=3) + self.assertGreater(lp(x, y_lp, d_max, 3.5), l1(x, y_lp, d_max)) + + def test_variation_dist_bounded(self): + """variation_dist with distance_power > 0 must stay in [0, 1].""" + # Adversarial: weight concentrated on maximally anti-correlated element + x = np.array([0.0, 1.0, 0.0]) + y = np.array([1.0, 0.0, 1.0]) + lags = np.array([10.0, 0.1, 10.0]) + w = compute_node_weights(3, lags, 1.0) + d = float(vec_variation_dist(x, y[np.newaxis, :], w, 1.0)[0]) + self.assertGreaterEqual(d, 0.0) + self.assertLessEqual(d, 1.0) + self.assertAlmostEqual(d, 0.661747, places=5) + # Also via the vectorized per-variable production path + ti = TrainingImage( + np.linspace(0.0, 1.0, 10), + categorical=False, + distance="variation", + distance_power=1.0, + ) + self.assertLessEqual(_uni_dist(ti, x, y, lag_norms=lags), 1.0) + + def test_variation_dist_out_of_range_clamped(self): + """Out-of-range SG values (from conditioning / mean-shift) must clamp to [0, 1].""" + ti = TrainingImage( + np.linspace(0.0, 1.0, 10), # d_max == 1.0 + categorical=False, + distance="variation", + ) + de_sim = np.array([5.0, 0.0]) # 5.0 is far outside the TI range + de_ti = np.array([0.0, 1.0]) + self.assertLessEqual(_uni_dist(ti, de_sim, de_ti), 1.0) + mv = _univar_as_mv_ti(ti) + vec = mv.vec_distance_var(_MV_VAR, de_sim, de_ti[np.newaxis, :]) + self.assertEqual(vec.shape, (1,)) + self.assertLessEqual(vec[0], 1.0) + + def test_variation_lp_parsing(self): + """variation

string is parsed correctly and rejects bad inputs.""" + data = np.linspace(0.0, 1.0, 10) + for spec in ("variation", "variation1", "variation1.5", "variation2"): + ti = TrainingImage(data, categorical=False, distance=spec) + self.assertEqual(ti.distance_type, spec) + # invalid suffix + with self.assertRaises(ValueError): + TrainingImage(data, categorical=False, distance="variationX") + # non-positive exponent + with self.assertRaises(ValueError): + TrainingImage(data, categorical=False, distance="variation0") + with self.assertRaises(ValueError): + TrainingImage(data, categorical=False, distance="variation-1") + + def test_variation_lp_adjust_value(self): + """adjust_value mean-shift applies for all variation

variants.""" + de_sim = np.array([0.1, 0.3, 0.5]) # mean = 0.3 + de_ti = np.array([0.4, 0.6, 0.8]) # mean = 0.6 + # expected: 0.7 - 0.6 + 0.3 = 0.4 + for spec in ("variation", "variation1", "variation1.5"): + ti = TrainingImage( + np.linspace(0.0, 1.0, 20), categorical=False, distance=spec + ) + self.assertAlmostEqual( + ti.adjust_value(0.7, de_sim, de_ti), 0.4, places=6 + ) + + def test_node_weights_zero_cond_weight(self): + """All-conditioning event with cond_weight=0 → ignored (Me13 δ_c=0). + + The conditioning data is dropped from the distance entirely (zero + weights, non-informative data event → unconditional behaviour), not + re-weighted uniformly. Weights must still be finite (no NaNs). + """ + w = compute_node_weights( + 3, + lag_norms=None, + distance_power=0.0, + cond_mask=np.array([True, True, True]), + cond_weight=0.0, + ) + self.assertTrue(np.all(np.isfinite(w))) + np.testing.assert_allclose(w, np.zeros(3)) + + def test_node_weights_zero_lag_norm_not_amplified(self): + """A true zero lag-norm (collocated h=0) must keep the unit baseline + weight under distance_power > 0, not the divergent 1e-10**(-power), and + cond_weight must be the knob that scales it.""" + # raw = [baseline 1.0, 1**-2=1.0, 2**-2=0.25] -> zero-lag == unit-lag, + # and never dominates the data event. + w = compute_node_weights(3, [0.0, 1.0, 2.0], 2.0) + self.assertTrue(np.all(np.isfinite(w))) + self.assertAlmostEqual(w[0], w[1]) + self.assertGreater(w[0], w[2]) + self.assertLess(w[0], 0.9) # not the old ~1.0 blow-up + # cond_weight scales the collocated entry (it carries cond_mask=True). + w_c = compute_node_weights( + 3, + [0.0, 1.0, 2.0], + 2.0, + cond_mask=np.array([True, False, False]), + cond_weight=5.0, + ) + self.assertGreater(w_c[0], w[0]) + + +class TestDirectSampling(unittest.TestCase): + def setUp(self): + # 1-D categorical TI: alternating 0/1, length 20 + arr1d = np.tile([0, 1], 10).astype(float) + self.ti1d = TrainingImage(arr1d, categorical=True) + + # 2-D categorical TI: 8×8 checkerboard + self.ti2d = TrainingImage( + (np.indices((8, 8)).sum(axis=0) % 2).astype(float), + categorical=True, + ) + + rng = np.random.default_rng(0) + self.ti2d_rand = TrainingImage( + rng.integers(0, 2, size=(20, 20)).astype(float), + categorical=True, + ) + + # 1-D continuous TI + self.ti1d_cont = TrainingImage( + np.linspace(0.0, 1.0, 20), categorical=False, distance="l1" + ) + + self.x1d = np.arange(10, dtype=float) + self.x2d = np.arange(6, dtype=float) + self.y2d = np.arange(6, dtype=float) + + def test_raise(self): + with self.assertRaises(ValueError): + MPSModel(self.ti1d, boundary="bad") + with self.assertRaises(ValueError): + MPSModel(self.ti1d, max_radius=0) + with self.assertRaises(ValueError): + MPSModel(self.ti1d, max_radius=-1.0) + ds = DirectSampling(MPSModel(self.ti1d)) + with self.assertRaises(ValueError): + ds([self.x1d], seed=42, mesh_type="unstructured") + + def test_repr(self): + ds = DirectSampling(MPSModel(self.ti1d)) + r = repr(ds) + self.assertIsInstance(r, str) + self.assertIn("DirectSampling", r) + + def test_properties_and_setters(self): + ds = DirectSampling( + MPSModel( + self.ti1d, + n_neighbors=16, + scan_fraction=0.5, + threshold=0.05, + cond_weight=2.0, + boundary="partial", + max_radius=3.0, + ) + ) + self.assertIs(ds.ti, self.ti1d) + self.assertEqual(ds.n_neighbors, 16) + self.assertAlmostEqual(ds.scan_fraction, 0.5) + self.assertAlmostEqual(ds.threshold, 0.05) + self.assertAlmostEqual(ds.cond_weight, 2.0) + self.assertEqual(ds.boundary, "partial") + self.assertAlmostEqual(ds.max_radius, 3.0) + + ds.n_neighbors = 8 + self.assertEqual(ds.n_neighbors, 8) + ds.scan_fraction = 1.0 + self.assertAlmostEqual(ds.scan_fraction, 1.0) + ds.threshold = 0.0 + self.assertAlmostEqual(ds.threshold, 0.0) + ds.cond_weight = 1.0 + self.assertAlmostEqual(ds.cond_weight, 1.0) + + def test_offsets_shape(self): + off = _precompute_offsets((5, 5)) + # shape: (N, 2) for 2-D, no zero row + self.assertEqual(off.ndim, 2) + self.assertEqual(off.shape[1], 2) + self.assertFalse(np.any(np.all(off == 0, axis=1))) + # sorted by Euclidean norm + norms = np.linalg.norm(off, axis=1) + self.assertTrue(np.all(norms[:-1] <= norms[1:])) + + def test_offsets_1d(self): + off = _precompute_offsets((10,)) + self.assertEqual(off.shape[1], 1) + self.assertFalse(np.any(off == 0)) + + def test_offsets_max_offset(self): + off = _precompute_offsets((5, 5), max_offset=1) + self.assertLessEqual(np.abs(off).max(), 1) + # 2-D, max_offset=1: 3^2 - 1 = 8 neighbours + self.assertEqual(off.shape, (8, 2)) + + def test_shape_1d(self): + ds = DirectSampling( + MPSModel(self.ti1d, n_neighbors=4, scan_fraction=1.0) + ) + field = ds([self.x1d], seed=42) + self.assertEqual(field.shape, (10,)) + self.assertFalse(np.any(np.isnan(field))) + + def test_shape_2d(self): + ds = DirectSampling( + MPSModel(self.ti2d, n_neighbors=4, scan_fraction=1.0) + ) + field = ds([self.x2d, self.y2d], seed=42) + self.assertEqual(field.shape, (6, 6)) + self.assertFalse(np.any(np.isnan(field))) + # All output values must be in the TI value set {0, 1} + unique_vals = set(np.unique(field)) + self.assertTrue(unique_vals.issubset({0.0, 1.0})) + + def test_regression_1d(self): + ds = DirectSampling( + MPSModel(self.ti1d, n_neighbors=4, scan_fraction=1.0) + ) + field = ds([self.x1d], seed=42) + self.assertAlmostEqual(field[0], 1.0) + self.assertAlmostEqual(field[5], 0.0) + self.assertAlmostEqual(field[9], 0.0) + + def test_regression_2d(self): + ds = DirectSampling( + MPSModel(self.ti2d, n_neighbors=4, scan_fraction=1.0) + ) + field = ds([self.x2d, self.y2d], seed=42) + self.assertAlmostEqual(field[0, 0], 1.0) + self.assertAlmostEqual(field[2, 3], 0.0) + self.assertAlmostEqual(field[5, 5], 1.0) + + def test_seeded_reproducibility(self): + ds = DirectSampling( + MPSModel(self.ti2d_rand, n_neighbors=8, scan_fraction=0.5) + ) + pos = [self.x2d, self.y2d] + fa = ds(pos, seed=99) + fb = ds(pos, seed=99) + fc = ds(pos, seed=100) + # Same seed → identical output + self.assertTrue(np.allclose(fa, fb)) + # Different seed → different output + self.assertFalse(np.allclose(fa, fc)) + # Pin two values for seed=99; stable across NumPy versions because DS + # uses RandomState (MT19937) throughout, matching the rest of GSTools. + self.assertAlmostEqual(fa[0, 0], 0.0) + self.assertAlmostEqual(fa[3, 4], 0.0) + + def test_conditioning_honored(self): + ds = DirectSampling( + MPSModel(self.ti1d, n_neighbors=4, scan_fraction=1.0) + ) + # Three exact grid node positions — spec requires ≥ 3 to exercise multi-point handling + cond_pos = [np.array([2.0, 4.0, 7.0])] + cond_val = np.array([0.0, 1.0, 1.0]) + ds.set_condition(cond_pos, cond_val) + field = ds([self.x1d], seed=5) + self.assertAlmostEqual(field[2], 0.0) + self.assertAlmostEqual(field[4], 1.0) + self.assertAlmostEqual(field[7], 1.0) + + def test_boundary_partial(self): + ds = DirectSampling( + MPSModel( + self.ti2d, + n_neighbors=4, + scan_fraction=1.0, + boundary="partial", + ) + ) + field = ds([self.x2d, self.y2d], seed=42) + self.assertEqual(field.shape, (6, 6)) + self.assertFalse(np.any(np.isnan(field))) + + def test_boundary_partial_collapse_recovers(self): + # TI far smaller than lag span → partial mode must recover, not raise + ti_tiny = TrainingImage( + np.random.default_rng(0).random((3, 3)), + categorical=False, + distance="l1", + ) + ds = DirectSampling( + MPSModel( + ti_tiny, + n_neighbors=32, + scan_fraction=1.0, + boundary="partial", + ) + ) + field = ds([np.arange(30, dtype=float)] * 2, seed=1) + self.assertEqual(field.shape, (30, 30)) + self.assertFalse(np.any(np.isnan(field))) + + def test_threshold_above_one_warns_in_constructor(self): + with self.assertWarns(UserWarning): + MPSModel(self.ti1d, threshold=5.0) + + def test_scan_fraction_window_semantics(self): + """scan_fraction=0.1 applies to the window, not the TI — no crash, valid output.""" + rng = np.random.default_rng(0) + ti = TrainingImage( + rng.integers(0, 2, (20, 20)).astype(float), categorical=True + ) + ds = DirectSampling(MPSModel(ti, n_neighbors=4, scan_fraction=0.1)) + field = ds([np.arange(6, dtype=float)] * 2, seed=0) + self.assertEqual(field.shape, (6, 6)) + self.assertFalse(np.any(np.isnan(field))) + self.assertTrue(set(np.unique(field)).issubset({0.0, 1.0})) + + def test_max_radius(self): + ds = DirectSampling( + MPSModel( + self.ti2d, n_neighbors=4, scan_fraction=1.0, max_radius=2.0 + ) + ) + field = ds([self.x2d, self.y2d], seed=42) + self.assertEqual(field.shape, (6, 6)) + self.assertFalse(np.any(np.isnan(field))) + + def test_continuous_ti(self): + ds = DirectSampling( + MPSModel( + self.ti1d_cont, + n_neighbors=4, + scan_fraction=1.0, + threshold=0.05, + ) + ) + field = ds([np.arange(8, dtype=float)], seed=42) + self.assertEqual(field.shape, (8,)) + self.assertFalse(np.any(np.isnan(field))) + self.assertTrue(np.all(field >= 0.0)) + self.assertTrue(np.all(field <= 1.0)) + + def test_ds_simulate_direct(self): + rng = np.random.RandomState(7) + result = ds_simulate( + _univar_as_mv_ti(self.ti1d), + sim_shape=(8,), + n_neighbors=4, + threshold=0.0, + scan_fraction=1.0, + rng_path=rng, + rng_nodes=rng, + )["_v"] + self.assertEqual(result.shape, (8,)) + self.assertFalse(np.any(np.isnan(result))) + self.assertTrue(set(np.unique(result)).issubset({0.0, 1.0})) + + def test_empty_search_window_recovery(self): + # n_neighbors >> TI size collapses search windows → must recover silently + ti_tiny = TrainingImage(np.array([0.0, 1.0, 0.0]), categorical=True) + ds = DirectSampling( + MPSModel(ti_tiny, n_neighbors=10, scan_fraction=1.0) + ) + field = ds([np.arange(5, dtype=float)], seed=1) + self.assertEqual(field.shape, (5,)) + self.assertFalse(np.any(np.isnan(field))) + self.assertTrue(set(np.unique(field)).issubset({0.0, 1.0})) + + def test_gstools_namespace(self): + self.assertIs(gs.DirectSampling, DirectSampling) + self.assertIs(gs.TrainingImage, TrainingImage) + self.assertIs(gs.mps.DirectSampling, DirectSampling) + self.assertIs(gs.mps.TrainingImage, TrainingImage) + + +class TestMultivariateTrainingImage(unittest.TestCase): + def test_shape_mismatch(self): + with self.assertRaisesRegex(ValueError, "same shape"): + TrainingImage({"a": np.zeros((4, 4)), "b": np.zeros((3, 3))}) + + def test_equal_weights(self): + ti = TrainingImage( + {"a": np.zeros((4, 4), dtype=int), "b": np.ones((4, 4), dtype=int)} + ) + self.assertTrue(ti.multivariate) + self.assertEqual(ti.variables, ["a", "b"]) + self.assertAlmostEqual(ti.weights["a"], 0.5) + self.assertAlmostEqual(ti.weights["b"], 0.5) + self.assertEqual(ti.shape, (4, 4)) + self.assertEqual(ti.ndim, 2) + + def test_weights_must_sum_to_one(self): + with self.assertRaisesRegex(ValueError, "sum to 1"): + TrainingImage( + { + "a": np.zeros((4, 4), dtype=int), + "b": np.zeros((4, 4), dtype=int), + }, + weights={"a": 0.3, "b": 0.3}, + ) + + def test_distance_weighted_sum(self): + # w=0.5 each; d_a=1.0 (full mismatch), d_b=0.0 -> joint = 0.5 + ti = TrainingImage( + { + "a": np.zeros((4, 4), dtype=int), + "b": np.zeros((4, 4), dtype=int), + }, + weights={"a": 0.5, "b": 0.5}, + ) + de_sg = {"a": np.array([1, 1]), "b": np.array([0, 0])} + de_ti = {"a": np.array([0, 0]), "b": np.array([0, 0])} + self.assertAlmostEqual(_mv_dist(ti, de_sg, de_ti), 0.5) + + def test_per_variable_categorical_and_distance(self): + ti = TrainingImage( + { + "cat": np.zeros((4, 4), dtype=int), + "cont": np.linspace(0, 100, 16).reshape(4, 4), + }, + categorical={"cat": True, "cont": False}, + distance={"cat": "l1", "cont": "l2"}, + ) + self.assertTrue(ti.categorical["cat"]) + self.assertFalse(ti.categorical["cont"]) + self.assertAlmostEqual(ti._d_max["cont"], 100.0) + + def test_univariate_variation_p_preserved(self): + # Regression guard: the shared _parse_distance refactor must keep + # variation

support and the _variation_p_norm attribute intact. + ti = TrainingImage( + np.linspace(0, 100, 16).reshape(4, 4), + categorical=False, + distance="variation1.5", + ) + self.assertFalse(ti.multivariate) + self.assertIsNone(ti.variables) + self.assertIsNone(ti.weights) + self.assertEqual(ti._variation_p_norm, 1.5) + self.assertIsNone(ti._p_norm) + + def test_variable_accessor(self): + a = np.arange(16).reshape(4, 4) + ti = TrainingImage({"a": a, "b": np.zeros((4, 4), dtype=int)}) + np.testing.assert_array_equal(ti.variable("a"), a) + # univariate TIs have no named variables + uni = TrainingImage(np.zeros((4, 4), dtype=int)) + with self.assertRaises(TypeError): + uni.variable("a") + + def test_adjust_value_multivariate(self): + ti = TrainingImage( + { + "v": np.linspace(0, 100, 16).reshape(4, 4), + "c": np.zeros((4, 4), dtype=int), + }, + categorical={"v": False, "c": True}, + distance={"v": "variation", "c": "l1"}, + ) + # variation: Z(y) - mean(de_ti) + mean(de_sim) = 50 - 50 + 20 = 20 + self.assertAlmostEqual( + ti.adjust_value( + 50.0, + np.array([10.0, 20.0, 30.0]), + np.array([40.0, 50.0, 60.0]), + var="v", + ), + 20.0, + ) + # categorical variable: returned unchanged + self.assertEqual( + ti.adjust_value(1.0, np.array([0, 1]), np.array([1, 0]), var="c"), + 1.0, + ) + # empty data event: returned unchanged even for variation + self.assertAlmostEqual( + ti.adjust_value(7.0, np.array([]), np.array([]), var="v"), 7.0 + ) + + def test_weights_unknown_variable(self): + with self.assertRaisesRegex(ValueError, "unknown"): + TrainingImage( + { + "a": np.zeros((4, 4), dtype=int), + "b": np.zeros((4, 4), dtype=int), + }, + weights={"a": 0.5, "b": 0.5, "ghost": 0.0}, + ) + + +class TestMultivariateDirectSampling(unittest.TestCase): + def test_fills_all_nodes(self): + # Node-wise path must leave no NaN in any variable. + rng = np.random.default_rng(42) + data = { + "a": rng.integers(0, 2, (20, 20)), + "b": rng.integers(0, 2, (20, 20)), + } + ti = TrainingImage(data) + ds = DirectSampling(MPSModel(ti, n_neighbors=4, scan_fraction=0.3)) + field = ds([np.arange(6, dtype=float)] * 2, seed=1) + self.assertFalse(np.any(np.isnan(field["a"]))) + self.assertFalse(np.any(np.isnan(field["b"]))) + + def test_output_shapes(self): + rng = np.random.default_rng(0) + data = { + "primary": rng.integers(0, 3, (20, 20)), + "secondary": rng.integers(0, 2, (20, 20)), + } + ti = TrainingImage(data) + ds = DirectSampling(MPSModel(ti, n_neighbors=8, scan_fraction=0.1)) + field = ds([np.arange(10, dtype=float)] * 2, seed=0) + self.assertEqual(field["primary"].shape, (10, 10)) + self.assertIn("secondary", field) + self.assertEqual(field["secondary"].shape, (10, 10)) + + def test_values_valid(self): + rng = np.random.default_rng(1) + data = { + "a": rng.integers(0, 4, (20, 20)), + "b": rng.integers(0, 2, (20, 20)), + } + ti = TrainingImage(data) + ds = DirectSampling(MPSModel(ti, n_neighbors=4, scan_fraction=0.2)) + field = ds([np.arange(8, dtype=float)] * 2, seed=5) + self.assertTrue(np.all(np.isin(field["a"], [0, 1, 2, 3]))) + self.assertTrue(np.all(np.isin(field["b"], [0, 1]))) + + def test_per_variable_n_neighbors(self): + rng = np.random.default_rng(3) + data = { + "primary": rng.integers(0, 3, (20, 20)), + "secondary": rng.integers(0, 2, (20, 20)), + } + ti = TrainingImage(data) + ds = DirectSampling( + MPSModel( + ti, + n_neighbors={"primary": 8, "secondary": 2}, + scan_fraction=0.2, + ) + ) + field = ds([np.arange(8, dtype=float)] * 2, seed=7) + self.assertEqual(field["primary"].shape, (8, 8)) + self.assertFalse(np.any(np.isnan(field["primary"]))) + self.assertFalse(np.any(np.isnan(field["secondary"]))) + + def test_3d_runs(self): + rng = np.random.default_rng(8) + data = { + "a": rng.integers(0, 2, (10, 10, 10)), + "b": rng.integers(0, 2, (10, 10, 10)), + } + ti = TrainingImage(data) + ds = DirectSampling(MPSModel(ti, n_neighbors=4, scan_fraction=0.2)) + field = ds([np.arange(4, dtype=float)] * 3, seed=0) + self.assertEqual(field["a"].shape, (4, 4, 4)) + self.assertFalse(np.any(np.isnan(field["a"]))) + self.assertFalse(np.any(np.isnan(field["b"]))) + + def test_partial_boundary_runs(self): + rng = np.random.default_rng(11) + data = { + "a": rng.integers(0, 2, (20, 20)), + "b": rng.integers(0, 2, (20, 20)), + } + ti = TrainingImage(data) + ds = DirectSampling( + MPSModel(ti, n_neighbors=6, scan_fraction=0.3, boundary="partial") + ) + field = ds([np.arange(8, dtype=float)] * 2, seed=2) + self.assertFalse(np.any(np.isnan(field["a"]))) + self.assertFalse(np.any(np.isnan(field["b"]))) + self.assertTrue(np.all(np.isin(field["a"], [0, 1]))) + + def test_ds_mode_threshold(self): + rng = np.random.default_rng(12) + data = { + "a": rng.integers(0, 3, (20, 20)), + "b": rng.integers(0, 2, (20, 20)), + } + ti = TrainingImage(data) + ds = DirectSampling( + MPSModel(ti, n_neighbors=4, scan_fraction=0.5, threshold=0.3) + ) + field = ds([np.arange(8, dtype=float)] * 2, seed=4) + self.assertFalse(np.any(np.isnan(field["a"]))) + self.assertTrue(np.all(np.isin(field["a"], [0, 1, 2]))) + self.assertTrue(np.all(np.isin(field["b"], [0, 1]))) + + def test_continuous_variation_variable(self): + # A continuous variable with variation distance exercises the + # mean-shift adjust_value_var path end to end. + rng = np.random.default_rng(13) + data = { + "cont": rng.random((20, 20)) * 10.0, + "cat": rng.integers(0, 2, (20, 20)), + } + ti = TrainingImage( + data, + categorical={"cont": False, "cat": True}, + distance={"cont": "variation", "cat": "l1"}, + ) + ds = DirectSampling(MPSModel(ti, n_neighbors=6, scan_fraction=0.3)) + field = ds([np.arange(8, dtype=float)] * 2, seed=6) + self.assertEqual(field["cont"].shape, (8, 8)) + self.assertTrue(np.all(np.isfinite(field["cont"]))) + self.assertTrue(np.all(np.isin(field["cat"], [0, 1]))) + + def test_joint_cell_invariant(self): + # Core acceptance test for node-wise co-simulation: every node's vector + # must be copied from a SINGLE TI cell. Build a TI where ``b`` is an + # injective function of ``a`` (b = a + 100), so a consistent (a, b) pair + # exists at exactly one TI cell. If both variables at every node trace + # to one cell, ``b == a + 100`` must hold everywhere. + ids = np.arange(64).reshape(8, 8) + ti = TrainingImage( + {"a": ids, "b": ids + 100}, + categorical={"a": True, "b": True}, + ) + ds = DirectSampling( + MPSModel(ti, n_neighbors=8, scan_fraction=1.0, threshold=0.0) + ) + field = ds([np.arange(6, dtype=float)] * 2, seed=0) + np.testing.assert_array_equal(field["b"], field["a"] + 100) + + def test_equal_treatment_named_fields(self): + # No privileged primary: all variables are first-class named fields. + rng = np.random.default_rng(20) + ti = TrainingImage( + { + "x": rng.integers(0, 2, (15, 15)), + "y": rng.integers(0, 2, (15, 15)), + } + ) + ds = DirectSampling(MPSModel(ti, n_neighbors=4, scan_fraction=0.3)) + field = ds([np.arange(6, dtype=float)] * 2, seed=0) + self.assertEqual(set(field), {"x", "y"}) + self.assertIn("x", ds.field_names) + self.assertIn("y", ds.field_names) + np.testing.assert_array_equal(ds["x"], field["x"]) + np.testing.assert_array_equal(ds["y"], field["y"]) + + def test_invalid_variable_name_raises(self): + ti = TrainingImage( + { + "a b": np.zeros((5, 5), dtype=int), + "c": np.zeros((5, 5), dtype=int), + } + ) + with self.assertRaisesRegex(ValueError, "field name"): + DirectSampling(MPSModel(ti, n_neighbors=4)) + + def test_n_neighbors_dict_requires_multivariate(self): + ti = TrainingImage(np.zeros((10, 10), dtype=int)) + with self.assertRaisesRegex(ValueError, "multivariate"): + DirectSampling(MPSModel(ti, n_neighbors={"a": 4})) + + def test_n_neighbors_dict_keys_must_match(self): + ti = TrainingImage( + { + "a": np.zeros((10, 10), dtype=int), + "b": np.zeros((10, 10), dtype=int), + } + ) + with self.assertRaisesRegex(ValueError, "keys must match"): + DirectSampling(MPSModel(ti, n_neighbors={"a": 4})) + + def test_set_condition_basic(self): + rng = np.random.default_rng(0) + data = { + "a": rng.integers(0, 2, (20, 20)), + "b": rng.integers(0, 2, (20, 20)), + } + ti = TrainingImage(data) + ds = DirectSampling(MPSModel(ti, n_neighbors=4, scan_fraction=0.3)) + ds.set_condition( + cond_pos=[[2.0, 5.0], [2.0, 5.0]], + cond_val={"a": np.array([1, 0]), "b": np.array([0, 1])}, + ) + field = ds([np.arange(8, dtype=float)] * 2, seed=0) + self.assertEqual(field["a"][2, 2], 1) + self.assertEqual(field["b"][2, 2], 0) + self.assertEqual(field["a"][5, 5], 0) + self.assertEqual(field["b"][5, 5], 1) + + def test_set_condition_partial_nan(self): + # NaN for b at the conditioning point -> b unconstrained there; only a + # is conditioned, and b is filled by the simulation (not NaN). + rng = np.random.default_rng(1) + data = { + "a": rng.integers(0, 2, (20, 20)), + "b": rng.integers(0, 2, (20, 20)), + } + ti = TrainingImage(data) + ds = DirectSampling(MPSModel(ti, n_neighbors=4, scan_fraction=0.3)) + ds.set_condition( + cond_pos=[[3.0], [3.0]], + cond_val={"a": np.array([1]), "b": np.array([np.nan])}, + ) + field = ds([np.arange(8, dtype=float)] * 2, seed=2) + self.assertEqual(field["a"][3, 3], 1) + self.assertFalse(np.isnan(field["b"][3, 3])) + + def test_set_condition_collision(self): + # Both points snap to node (4, 4); (4.1, 4.1) is closer than (4.4, 4.4) + # -> the closer point's values win for all variables. + rng = np.random.default_rng(2) + data = { + "a": rng.integers(0, 2, (20, 20)), + "b": rng.integers(0, 2, (20, 20)), + } + ti = TrainingImage(data) + ds = DirectSampling(MPSModel(ti, n_neighbors=4, scan_fraction=0.3)) + ds.set_condition( + cond_pos=[[4.4, 4.1], [4.4, 4.1]], + cond_val={"a": np.array([0, 1]), "b": np.array([0, 1])}, + ) + field = ds([np.arange(8, dtype=float)] * 2, seed=3) + self.assertEqual(field["a"][4, 4], 1) + self.assertEqual(field["b"][4, 4], 1) + + def test_collocated_constraint(self): + # b is a unique index per TI cell; a is a deterministic function of b. + # Conditioning b at the single simulated node forces the collocated + # (h=0) term to select the TI cell whose b matches, so the co-simulated + # a must equal that cell's a. DSBC full scan => exact global argmin. + # 1x1 sim grid: exactly one node is simulated; with b conditioned there, + # the collocated h=0 term alone determines which TI cell is matched. + nb = np.arange(36).reshape(6, 6) + na = (nb * 7) % 5 + ti = TrainingImage({"a": na, "b": nb}) + ds = DirectSampling( + MPSModel(ti, n_neighbors=4, scan_fraction=1.0, threshold=0.0) + ) + ds.set_condition( + cond_pos=[[0.0], [0.0]], + cond_val={"a": np.array([np.nan]), "b": np.array([20])}, + ) + field = ds([np.arange(1, dtype=float)] * 2, seed=0) + # b=20 sits at TI cell (3, 2); a there is (20*7) % 5 == 0 + self.assertEqual(field["a"][0, 0], (20 * 7) % 5) + + def test_univariate_set_condition_still_works(self): + # Regression guard: scalar set_condition path is unchanged. + rng = np.random.default_rng(0) + ti = TrainingImage(rng.integers(0, 3, (20, 20))) + ds = DirectSampling(MPSModel(ti, n_neighbors=8, scan_fraction=0.2)) + ds.set_condition([[5.0], [5.0]], [2]) + field = ds([np.arange(10, dtype=float)] * 2, seed=0) + self.assertEqual(field[5, 5], 2) + + def test_set_condition_length_mismatch(self): + ti = TrainingImage( + { + "a": np.zeros((10, 10), dtype=int), + "b": np.zeros((10, 10), dtype=int), + } + ) + ds = DirectSampling(MPSModel(ti, n_neighbors=4, scan_fraction=0.3)) + # cond_pos has 1 point but cond_val has 2 -> length mismatch + with self.assertRaisesRegex(ValueError, "mismatch"): + ds.set_condition( + cond_pos=[[3.0], [3.0]], + cond_val={"a": np.array([1, 0]), "b": np.array([1, 0])}, + ) + # per-variable arrays of different lengths + with self.assertRaisesRegex(ValueError, "same"): + ds.set_condition( + cond_pos=[[3.0, 4.0], [3.0, 4.0]], + cond_val={"a": np.array([1, 0]), "b": np.array([1])}, + ) + + def test_parallel_valid_values(self): + rng = np.random.default_rng(4) + data = { + "a": rng.integers(0, 3, (20, 20)), + "b": rng.integers(0, 2, (20, 20)), + } + ti = TrainingImage(data) + ds = DirectSampling(MPSModel(ti, n_neighbors=4, scan_fraction=0.2)) + ds.num_threads = 2 + field = ds([np.arange(8, dtype=float)] * 2, seed=0) + self.assertTrue(np.all(np.isin(field["a"], [0, 1, 2]))) + self.assertTrue(np.all(np.isin(field["b"], [0, 1]))) + + def test_parallel_matches_serial(self): + # The node-vertex DAG commits every per-variable neighbour before a node + # runs, so num_threads > 1 is bit-identical to serial. + rng = np.random.default_rng(5) + data = { + "a": rng.integers(0, 3, (20, 20)), + "b": rng.integers(0, 2, (20, 20)), + } + ti = TrainingImage(data) + pos = [np.arange(8, dtype=float)] * 2 + ds_s = DirectSampling(MPSModel(ti, n_neighbors=4, scan_fraction=0.2)) + ds_s.num_threads = 1 + ds_p = DirectSampling(MPSModel(ti, n_neighbors=4, scan_fraction=0.2)) + ds_p.num_threads = 2 + f_s = ds_s(pos, seed=7) + f_p = ds_p(pos, seed=7) + np.testing.assert_array_equal(f_s["a"], f_p["a"]) + np.testing.assert_array_equal(f_s["b"], f_p["b"]) + + def test_parallel_conditioning_preserved(self): + rng = np.random.default_rng(6) + data = { + "a": rng.integers(0, 2, (20, 20)), + "b": rng.integers(0, 2, (20, 20)), + } + ti = TrainingImage(data) + ds = DirectSampling(MPSModel(ti, n_neighbors=4, scan_fraction=0.3)) + ds.num_threads = 2 + ds.set_condition( + cond_pos=[[3.0], [3.0]], + cond_val={"a": np.array([1]), "b": np.array([0])}, + ) + field = ds([np.arange(8, dtype=float)] * 2, seed=9) + self.assertEqual(field["a"][3, 3], 1) + self.assertEqual(field["b"][3, 3], 0) + + def test_set_condition_array_on_multivariate_raises(self): + ti = TrainingImage( + { + "a": np.zeros((10, 10), dtype=int), + "b": np.zeros((10, 10), dtype=int), + } + ) + ds = DirectSampling(MPSModel(ti, n_neighbors=4, scan_fraction=0.3)) + with self.assertRaisesRegex(ValueError, "dict"): + ds.set_condition([[3.0], [3.0]], np.array([1])) + + def test_set_condition_empty_dict_raises(self): + ti = TrainingImage( + { + "a": np.zeros((10, 10), dtype=int), + "b": np.zeros((10, 10), dtype=int), + } + ) + ds = DirectSampling(MPSModel(ti, n_neighbors=4, scan_fraction=0.3)) + with self.assertRaisesRegex(ValueError, "empty"): + ds.set_condition([[3.0], [3.0]], {}) + + def test_set_condition_unknown_variable_raises(self): + ti = TrainingImage( + { + "a": np.zeros((10, 10), dtype=int), + "b": np.zeros((10, 10), dtype=int), + } + ) + ds = DirectSampling(MPSModel(ti, n_neighbors=4, scan_fraction=0.3)) + with self.assertRaisesRegex(ValueError, "unknown variable"): + ds.set_condition( + [[3.0], [3.0]], + {"a": np.array([1.0]), "c": np.array([1.0])}, + ) + + def test_set_condition_collision_per_variable_merge(self): + # Two points snap to node (4,4). The closer point {a:1, b:nan} wins + # variable a; the farther point {a:0, b:0} still fills variable b, which + # the closer point left NaN (per-variable collision resolution, C1). + rng = np.random.default_rng(7) + data = { + "a": rng.integers(0, 2, (20, 20)), + "b": rng.integers(0, 2, (20, 20)), + } + ti = TrainingImage(data) + ds = DirectSampling(MPSModel(ti, n_neighbors=4, scan_fraction=0.3)) + ds.set_condition( + # point 0 at (4.4,4.4) {a:0,b:0}; point 1 at (4.1,4.1) {a:1,b:nan} + cond_pos=[[4.4, 4.1], [4.4, 4.1]], + cond_val={"a": np.array([0, 1]), "b": np.array([0, np.nan])}, + ) + field = ds([np.arange(8, dtype=float)] * 2, seed=1) + # closer point wins a; farther point's finite b is not discarded + self.assertEqual(field["a"][4, 4], 1) + self.assertEqual(field["b"][4, 4], 0) + + def test_distance_power_multivariate(self): + # distance_power > 0 exercises the per-variable lag-norm weighting path. + rng = np.random.default_rng(8) + data = { + "cont": rng.random((20, 20)) * 10.0, + "cat": rng.integers(0, 2, (20, 20)), + } + ti = TrainingImage( + data, + categorical={"cont": False, "cat": True}, + distance={"cont": "l2", "cat": "l1"}, + distance_power=1.0, + ) + ds = DirectSampling(MPSModel(ti, n_neighbors=6, scan_fraction=0.3)) + field = ds([np.arange(8, dtype=float)] * 2, seed=3) + self.assertEqual(field["cont"].shape, (8, 8)) + self.assertTrue(np.all(np.isfinite(field["cont"]))) + self.assertTrue(np.all(np.isin(field["cat"], [0, 1]))) + + def test_single_variable_multivariate(self): + rng = np.random.default_rng(9) + ti = TrainingImage({"only": rng.integers(0, 3, (20, 20))}) + ds = DirectSampling(MPSModel(ti, n_neighbors=4, scan_fraction=0.3)) + field = ds([np.arange(8, dtype=float)] * 2, seed=0) + self.assertEqual(set(field), {"only"}) + self.assertEqual(field["only"].shape, (8, 8)) + self.assertTrue(np.all(np.isin(field["only"], [0, 1, 2]))) + + def test_threshold_renormalization_with_empty_variable(self): + # Fix 1 regression guard: when variable 'b' has no informed neighbours + # (first node on the path), the joint distance must still be renormalized + # to [0,1] so the threshold comparison is meaningful. + # Build a TI where 'a' and 'b' are injective: b = a + 100 (same as + # test_joint_cell_invariant). Use threshold > 0 (DS mode, not DSBC). + # The first simulated node has zero neighbours for both variables, so + # it falls back to a random TI cell — both variables must be drawn from + # the same cell (b == a + 100 for that node too). + ids = np.arange(64).reshape(8, 8) + ti = TrainingImage( + {"a": ids, "b": ids + 100}, + categorical={"a": True, "b": True}, + ) + # scan_fraction=1.0, threshold=0.01: very strict but must still complete + # without NaN and must reproduce the joint relationship everywhere. + ds = DirectSampling( + MPSModel(ti, n_neighbors=8, scan_fraction=1.0, threshold=0.01) + ) + field = ds([np.arange(6, dtype=float)] * 2, seed=0) + self.assertFalse(np.any(np.isnan(field["a"]))) + self.assertFalse(np.any(np.isnan(field["b"]))) + np.testing.assert_array_equal(field["b"], field["a"] + 100) + + def test_mv_custom_store_name_raises(self): + # Finding #6: a custom store name has no single field to bind to for a + # multivariate run; reject it instead of silently dropping it. + rng = np.random.default_rng(0) + ti = TrainingImage( + { + "a": rng.integers(0, 2, (20, 20)), + "b": rng.integers(0, 2, (20, 20)), + } + ) + ds = DirectSampling(MPSModel(ti, n_neighbors=4, scan_fraction=0.3)) + with self.assertRaisesRegex(ValueError, "custom store name"): + ds([np.arange(6, dtype=float)] * 2, seed=0, store="myrun") + + def test_mv_store_false_not_stored(self): + # store=False must still work for MV (no fields persisted on the model). + rng = np.random.default_rng(0) + ti = TrainingImage( + { + "a": rng.integers(0, 2, (20, 20)), + "b": rng.integers(0, 2, (20, 20)), + } + ) + ds = DirectSampling(MPSModel(ti, n_neighbors=4, scan_fraction=0.3)) + out = ds([np.arange(6, dtype=float)] * 2, seed=0, store=False) + self.assertEqual(set(out), {"a", "b"}) + self.assertEqual(list(ds.field_names), []) + + +class TestNonstationarity(unittest.TestCase): + """Geometric non-stationarity for DirectSampling (set_nonstationary).""" + + def _make_ds(self, ti_shape=(20, 20), **kw): + rng = np.random.default_rng(0) + data = rng.integers(0, 3, ti_shape) + ti = gs.mps.TrainingImage(data) + defaults = dict(n_neighbors=4, scan_fraction=0.2) + defaults.update(kw) + return gs.mps.DirectSampling(MPSModel(ti, **defaults)), ti + + def test_scalar_rotation_valid_values(self): + ds, ti = self._make_ds() + ds.set_nonstationary(rotation=np.pi / 4) + pos = [np.arange(8, dtype=float)] * 2 + field = ds(pos, seed=0) + self.assertEqual(field.shape, (8, 8)) + self.assertTrue(np.all(np.isin(field, [0, 1, 2]))) + + def test_rotation_changes_output(self): + ds_plain, ti = self._make_ds(ti_shape=(30, 30), n_neighbors=8) + pos = [np.arange(10, dtype=float)] * 2 + f_plain = ds_plain(pos, seed=7) + + ds_rot = gs.mps.DirectSampling( + MPSModel(ti, n_neighbors=8, scan_fraction=0.2) + ) + ds_rot.set_nonstationary(rotation=np.pi / 4) + f_rot = ds_rot(pos, seed=7) + self.assertFalse(np.array_equal(f_plain, f_rot)) + + def test_array_rotation_map_runs(self): + ds, _ = self._make_ds() + angle_map = np.linspace(0, np.pi / 2, 64).reshape(8, 8) + ds.set_nonstationary(rotation=angle_map) + field = ds([np.arange(8, dtype=float)] * 2, seed=1) + self.assertEqual(field.shape, (8, 8)) + self.assertTrue(np.all(np.isin(field, [0, 1, 2]))) + + def test_anis_changes_output(self): + ds_plain, ti = self._make_ds(ti_shape=(30, 30), n_neighbors=8) + pos = [np.arange(10, dtype=float)] * 2 + f_plain = ds_plain(pos, seed=3) + + ds_anis = gs.mps.DirectSampling( + MPSModel(ti, n_neighbors=8, scan_fraction=0.2) + ) + ds_anis.set_nonstationary(anis=0.5) + f_anis = ds_anis(pos, seed=3) + self.assertFalse(np.array_equal(f_plain, f_anis)) + + def test_combined_rotation_anis_runs(self): + ds, _ = self._make_ds() + ds.set_nonstationary(rotation=np.pi / 6, anis=0.5) + field = ds([np.arange(8, dtype=float)] * 2, seed=2) + self.assertEqual(field.shape, (8, 8)) + self.assertTrue(np.all(np.isin(field, [0, 1, 2]))) + + def test_conditioning_preserved(self): + ds, _ = self._make_ds(scan_fraction=0.3) + ds.set_nonstationary(rotation=np.pi / 4) + ds.set_condition([[4.0], [4.0]], [2]) + field = ds([np.arange(8, dtype=float)] * 2, seed=0) + self.assertEqual(int(field[4, 4]), 2) + + def test_partial_boundary_runs(self): + ds, _ = self._make_ds(boundary="partial") + ds.set_nonstationary(rotation=np.pi / 4) + field = ds([np.arange(8, dtype=float)] * 2, seed=0) + self.assertTrue(np.all(np.isin(field, [0, 1, 2]))) + + def test_3d_rotation_runs(self): + rng = np.random.default_rng(0) + data = rng.integers(0, 2, (12, 12, 12)) + ti = gs.mps.TrainingImage(data) + ds = gs.mps.DirectSampling( + MPSModel(ti, n_neighbors=4, scan_fraction=0.1) + ) + ds.set_nonstationary(rotation=np.pi / 4) + field = ds([np.arange(5, dtype=float)] * 3, seed=0) + self.assertEqual(field.shape, (5, 5, 5)) + self.assertTrue(np.all(np.isin(field, [0, 1]))) + + def test_collapsed_window_fallback(self): + # 90° rotation on a tiny TI can force all windows to collapse. + # Output must be finite and within TI values — no crash, no NaN. + rng = np.random.default_rng(0) + data = rng.integers(0, 2, (4, 4)) + ti = gs.mps.TrainingImage(data) + ds = gs.mps.DirectSampling( + MPSModel(ti, n_neighbors=8, scan_fraction=1.0) + ) + ds.set_nonstationary(rotation=np.pi / 2) + field = ds([np.arange(6, dtype=float)] * 2, seed=0) + self.assertTrue(np.all(np.isfinite(field))) + self.assertTrue(np.all(np.isin(field, [0, 1]))) + + def test_identity_matches_no_transform(self): + # θ=0, anis=1 must produce bit-identical output to the plain path. + ds_plain, ti = self._make_ds(ti_shape=(20, 20), n_neighbors=8) + pos = [np.arange(8, dtype=float)] * 2 + f_plain = ds_plain(pos, seed=5) + + ds_id = gs.mps.DirectSampling( + MPSModel(ti, n_neighbors=8, scan_fraction=0.2) + ) + ds_id.set_nonstationary(rotation=0.0, anis=1.0) + f_id = ds_id(pos, seed=5) + np.testing.assert_array_equal(f_plain, f_id) + + def test_multivariate_rotation_valid_output(self): + # Exercises the ds_simulate_mv transform path: shape, value subsets, + # and that rotation changes output vs no rotation (same seed). + rng = np.random.default_rng(0) + ti = gs.mps.TrainingImage( + {"a": rng.integers(0, 3, (20, 20)), "b": rng.random((20, 20))}, + categorical={"a": True, "b": False}, + ) + pos = [np.arange(8, dtype=float)] * 2 + + ds_plain = gs.mps.DirectSampling( + MPSModel(ti, n_neighbors=4, scan_fraction=0.2) + ) + result_plain = ds_plain(pos, seed=9) + + ds_rot = gs.mps.DirectSampling( + MPSModel(ti, n_neighbors=4, scan_fraction=0.2) + ) + ds_rot.set_nonstationary(rotation=np.pi / 4) + result_rot = ds_rot(pos, seed=9) + + self.assertEqual(result_rot["a"].shape, (8, 8)) + self.assertEqual(result_rot["b"].shape, (8, 8)) + self.assertTrue(np.all(np.isin(result_rot["a"], [0, 1, 2]))) + self.assertTrue(np.all(np.isfinite(result_rot["b"]))) + self.assertFalse(np.array_equal(result_plain["a"], result_rot["a"])) + + def test_flattened_rotation_map_raises(self): + # Finding #5: a per-node map passed flattened (length Nx*Ny) on a 2-D + # grid must raise, not silently apply only element [0]. + ds, _ = self._make_ds(ti_shape=(20, 20)) + ds.set_nonstationary(rotation=np.linspace(0, np.pi, 25)) + with self.assertRaisesRegex(ValueError, "flattened|per-node"): + ds([np.arange(5, dtype=float)] * 2, seed=0) + + def test_3d_stationary_rotation_triple_runs(self): + # A genuine stationary multi-component value (3 Tait-Bryan angles for a + # 3-D grid) is still accepted (length == no_of_angles(3) == 3). + rng = np.random.default_rng(0) + ti = gs.mps.TrainingImage(rng.integers(0, 2, (12, 12, 12))) + ds = gs.mps.DirectSampling( + MPSModel(ti, n_neighbors=4, scan_fraction=0.1) + ) + ds.set_nonstationary(rotation=np.array([0.1, 0.2, 0.3])) + field = ds([np.arange(5, dtype=float)] * 3, seed=0) + self.assertEqual(field.shape, (5, 5, 5)) + self.assertTrue(np.all(np.isin(field, [0, 1]))) + + +class TestFullArraySnapshot(unittest.TestCase): + """Bit-identical full-array regression pins — the step-by-step acceptance gate. + + These arrays are captured from the pre-refactoring engine with fixed seeds and + must remain bit-identical (np.testing.assert_array_equal) after every + refactoring step. + """ + + # --- Reference TIs (seeded deterministically) --- + @classmethod + def setUpClass(cls): + arr1d = np.tile([0.0, 1.0], 10) + cls.ti1d = TrainingImage(arr1d, categorical=True) + cls.ti2d = TrainingImage( + (np.indices((8, 8)).sum(axis=0) % 2).astype(float), + categorical=True, + ) + rng0 = np.random.default_rng(0) + cls.ti2d_rand = TrainingImage( + rng0.integers(0, 3, (20, 20)).astype(float), categorical=True + ) + rng_mv = np.random.default_rng(7) + cls.ti_mv = TrainingImage( + { + "a": rng_mv.integers(0, 3, (20, 20)).astype(float), + "b": rng_mv.integers(0, 2, (20, 20)).astype(float), + } + ) + cls.x1d = np.arange(10, dtype=float) + cls.x2d = np.arange(6, dtype=float) + cls.y2d = np.arange(6, dtype=float) + + def test_snapshot(self): + # --- univariate 1D, seed=42 --- + ds = DirectSampling( + MPSModel(self.ti1d, n_neighbors=4, scan_fraction=1.0) + ) + f = ds([self.x1d], seed=42) + np.testing.assert_array_equal( + f, + [1.0, 0.0, 1.0, 0.0, 1.0, 0.0, 1.0, 0.0, 1.0, 0.0], + err_msg="snap_uni_1d seed=42", + ) + # seed=99 + f = ds([self.x1d], seed=99) + np.testing.assert_array_equal( + f, + [0.0, 1.0, 0.0, 1.0, 0.0, 1.0, 0.0, 1.0, 0.0, 1.0], + err_msg="snap_uni_1d seed=99", + ) + + # --- univariate 2D checkerboard, seed=42 --- + ds2 = DirectSampling( + MPSModel(self.ti2d, n_neighbors=4, scan_fraction=1.0) + ) + f = ds2([self.x2d, self.y2d], seed=42) + np.testing.assert_array_equal( + f, + [ + [1.0, 0.0, 1.0, 0.0, 1.0, 0.0], + [0.0, 1.0, 0.0, 1.0, 0.0, 1.0], + [1.0, 0.0, 1.0, 0.0, 1.0, 0.0], + [0.0, 1.0, 0.0, 1.0, 0.0, 1.0], + [1.0, 0.0, 1.0, 0.0, 1.0, 0.0], + [0.0, 1.0, 0.0, 1.0, 0.0, 1.0], + ], + err_msg="snap_uni_2d_checker seed=42", + ) + # seed=99 + f = ds2([self.x2d, self.y2d], seed=99) + np.testing.assert_array_equal( + f, + [ + [0.0, 1.0, 0.0, 1.0, 0.0, 1.0], + [1.0, 0.0, 1.0, 0.0, 1.0, 0.0], + [0.0, 1.0, 0.0, 1.0, 0.0, 1.0], + [1.0, 0.0, 1.0, 0.0, 1.0, 0.0], + [0.0, 1.0, 0.0, 1.0, 0.0, 1.0], + [1.0, 0.0, 1.0, 0.0, 1.0, 0.0], + ], + err_msg="snap_uni_2d_checker seed=99", + ) + + # --- univariate 2D random TI, seed=42 --- + ds3 = DirectSampling( + MPSModel(self.ti2d_rand, n_neighbors=8, scan_fraction=0.5) + ) + f = ds3([self.x2d, self.y2d], seed=42) + np.testing.assert_array_equal( + f, + [ + [2.0, 0.0, 1.0, 2.0, 2.0, 1.0], + [1.0, 0.0, 1.0, 1.0, 2.0, 0.0], + [2.0, 2.0, 0.0, 0.0, 2.0, 2.0], + [2.0, 0.0, 1.0, 2.0, 0.0, 0.0], + [2.0, 2.0, 1.0, 2.0, 0.0, 1.0], + [2.0, 1.0, 2.0, 2.0, 2.0, 0.0], + ], + err_msg="snap_uni_rand seed=42", + ) + + # --- multivariate 2D, seed=42 --- + ds_mv = DirectSampling( + MPSModel(self.ti_mv, n_neighbors=4, scan_fraction=0.5) + ) + res = ds_mv([self.x2d, self.y2d], seed=42) + np.testing.assert_array_equal( + res["a"], + [ + [1.0, 1.0, 0.0, 2.0, 2.0, 0.0], + [2.0, 2.0, 1.0, 2.0, 1.0, 2.0], + [2.0, 1.0, 1.0, 1.0, 1.0, 2.0], + [2.0, 0.0, 0.0, 0.0, 1.0, 0.0], + [0.0, 0.0, 2.0, 2.0, 2.0, 2.0], + [0.0, 0.0, 1.0, 0.0, 0.0, 0.0], + ], + err_msg="snap_mv var=a seed=42", + ) + np.testing.assert_array_equal( + res["b"], + [ + [0.0, 1.0, 0.0, 0.0, 1.0, 0.0], + [0.0, 0.0, 0.0, 1.0, 0.0, 1.0], + [0.0, 0.0, 0.0, 0.0, 0.0, 1.0], + [1.0, 1.0, 1.0, 1.0, 0.0, 0.0], + [0.0, 0.0, 0.0, 1.0, 0.0, 0.0], + [0.0, 0.0, 0.0, 1.0, 1.0, 1.0], + ], + err_msg="snap_mv var=b seed=42", + ) + + +class TestDSSeedControl(unittest.TestCase): + def setUp(self): + rng = np.random.default_rng(0) + data = rng.integers(0, 3, (20, 20)) + self.ti = TrainingImage(data.astype(float)) + self.pos = [np.arange(8, dtype=float)] * 2 + + def test_fixed_path_seed_different_node_seed(self): + # Same visit order, different TI search → different output + ds = DirectSampling( + MPSModel(self.ti, n_neighbors=4, scan_fraction=0.3) + ) + fa = ds(self.pos, path_seed=1, node_seed=10) + fb = ds(self.pos, path_seed=1, node_seed=99) + self.assertFalse(np.array_equal(fa, fb)) + + def test_fixed_node_seed_different_path_seed(self): + # Same TI search, different visit order → different output + ds = DirectSampling( + MPSModel(self.ti, n_neighbors=4, scan_fraction=0.3) + ) + fa = ds(self.pos, path_seed=1, node_seed=10) + fb = ds(self.pos, path_seed=99, node_seed=10) + self.assertFalse(np.array_equal(fa, fb)) + + def test_both_seeds_fixed_reproducible(self): + # Explicit seeds on both → fully reproducible across calls + ds = DirectSampling( + MPSModel(self.ti, n_neighbors=4, scan_fraction=0.3) + ) + fa = ds(self.pos, path_seed=7, node_seed=42) + fb = ds(self.pos, path_seed=7, node_seed=42) + self.assertTrue(np.array_equal(fa, fb)) + + def test_default_still_reproducible(self): + # No explicit seeds → same seed= value still reproducible + ds = DirectSampling( + MPSModel(self.ti, n_neighbors=4, scan_fraction=0.3) + ) + fa = ds(self.pos, seed=5) + fb = ds(self.pos, seed=5) + self.assertTrue(np.array_equal(fa, fb)) + + +class TestUnivarEqualsSingleVarMv(unittest.TestCase): + """Permanent guard: univariate engine == single-variable multivariate engine. + + Proves bit-identical output before the univariate body is replaced with a + thin wrapper in the unification step. Must remain green permanently. + """ + + @classmethod + def setUpClass(cls): + rng0 = np.random.default_rng(0) + cls.ti_uni = TrainingImage( + rng0.integers(0, 3, (20, 20)).astype(float), categorical=True + ) + cls.ti_mv1 = TrainingImage( + { + "_v": np.random.default_rng(0) + .integers(0, 3, (20, 20)) + .astype(float) + }, + categorical=True, + ) + cls.pos = [np.arange(8, dtype=float)] * 2 + cls.sim_shape = (8, 8) + + def test_equality(self): + rng_seed = 42 + + # univariate TI wrapped as single-var mv + uni_rng = np.random.RandomState(rng_seed) + result_uni = ds_simulate( + _univar_as_mv_ti(self.ti_uni), + sim_shape=self.sim_shape, + n_neighbors=8, + threshold=0.0, + scan_fraction=1.0, + rng_path=uni_rng, + rng_nodes=uni_rng, + )["_v"] + + # native single-variable mv TI + mv_rng = np.random.RandomState(rng_seed) + result_mv = ds_simulate( + self.ti_mv1, + sim_shape=self.sim_shape, + n_neighbors=8, + threshold=0.0, + scan_fraction=1.0, + rng_path=mv_rng, + rng_nodes=mv_rng, + )["_v"] + + np.testing.assert_array_equal( + result_uni, + result_mv, + err_msg="_univar_as_mv_ti != native single-var mv", + ) + + +class TestTransformLagsCollapse(unittest.TestCase): + def test_collapsed_lags_warn(self): + # Strong anisotropy flattens the y-axis: SG lags (0,1) and (0,2) both + # round to TI lag (0,0). The dropped neighbour must be warned about. + M = np.array([[1.0, 0.0], [0.0, 0.1]]) + lags = np.array([[0.0, 1.0], [0.0, 2.0]]) + de = np.array([5.0, 9.0]) + with self.assertWarns(RuntimeWarning): + lags_ti, de_out = _transform_lags(lags, M, de) + self.assertEqual(len(lags_ti), 1) + self.assertEqual(de_out.tolist(), [5.0]) # first occurrence kept + + def test_no_collapse_no_warning(self): + # Identity transform keeps both lags distinct → no warning. + M = np.eye(2) + lags = np.array([[0.0, 1.0], [0.0, 2.0]]) + de = np.array([5.0, 9.0]) + with warnings.catch_warnings(): + warnings.simplefilter("error", RuntimeWarning) + lags_ti, de_out = _transform_lags(lags, M, de) + self.assertEqual(len(lags_ti), 2) + + +class TestReduceToFit(unittest.TestCase): + """M10 para [43]: global reduce-to-fit, drop most-outside node by rank (#3).""" + + def test_drops_oob_regardless_of_rank(self): + # The near (low-rank) lag maps out of a 4x4 TI; the far (high-rank) lag + # is feasible. para [43] keeps the feasible one and drops the OOB one — + # the opposite of partial-mode furthest-first truncation. + lags_ti = np.array([[0.0, 10.0], [1.0, 0.0]]) + de = np.array([5.0, 9.0]) + out_lags, out_de = _reduce_to_fit(lags_ti, (4, 4), de) + np.testing.assert_array_equal(out_lags, [[1.0, 0.0]]) + np.testing.assert_array_equal( + out_de, [9.0] + ) # parallel array sliced too + + def test_both_extremes_overspan_reduced(self): + # Two lags each fit alone but jointly over-span a 4-wide TI (ti-1==3): + # extent 3-(-3)=6 > 3. One outermost node is dropped until it fits. + lags_ti = np.array([[0.0, 3.0], [0.0, -3.0]]) + (out_lags,) = _reduce_to_fit(lags_ti, (4, 4)) + self.assertEqual(len(out_lags), 1) + + def test_collocated_never_dropped_and_inbounds_kept(self): + # h=0 and an in-bounds lag survive; the over-long lag is removed. + lags_ti = np.array([[0.0, 0.0], [3.0, 0.0], [9.0, 0.0]]) + (out_lags,) = _reduce_to_fit(lags_ti, (4, 4)) # ti-1 == 3 + self.assertIn([0.0, 0.0], out_lags.tolist()) # collocated kept + self.assertNotIn([9.0, 0.0], out_lags.tolist()) # most-outside dropped + + def test_already_fits_is_noop(self): + lags_ti = np.array([[1.0, 0.0], [0.0, -1.0]]) + (out_lags,) = _reduce_to_fit(lags_ti, (20, 20)) + np.testing.assert_array_equal(out_lags, lags_ti) + + def test_empty(self): + (out,) = _reduce_to_fit(np.empty((0, 2)), (4, 4)) + self.assertEqual(out.size, 0) + + def test_strong_anis_retains_pattern_neighbour(self): + # End to end: strong anisotropy on a small TI used to collapse the + # window to a random draw; with para [43] the feasible neighbour is + # retained, so output stays valid and finite (no crash, no NaN). + rng = np.random.default_rng(0) + ti = gs.mps.TrainingImage(rng.integers(0, 2, (6, 6))) + ds = gs.mps.DirectSampling( + MPSModel(ti, n_neighbors=8, scan_fraction=1.0) + ) + ds.set_nonstationary(anis=0.1) + field = ds([np.arange(8, dtype=float)] * 2, seed=0) + self.assertTrue(np.all(np.isfinite(field))) + self.assertTrue(set(np.unique(field)).issubset({0.0, 1.0})) + + +class TestVariationNNeighbors(unittest.TestCase): + def test_variation_n1_raises_at_construction(self): + ti = TrainingImage( + np.linspace(0.0, 1.0, 20), categorical=False, distance="variation" + ) + with self.assertRaisesRegex(ValueError, "variation"): + DirectSampling(MPSModel(ti, n_neighbors=1, scan_fraction=0.5)) + + def test_variation_n2_ok(self): + ti = TrainingImage( + np.linspace(0.0, 1.0, 20), categorical=False, distance="variation" + ) + ds = DirectSampling(MPSModel(ti, n_neighbors=2, scan_fraction=0.5)) + self.assertEqual(ds.n_neighbors, 2) + + def test_variation_n_neighbors_setter_rejects_1(self): + ti = TrainingImage( + np.linspace(0.0, 1.0, 20), categorical=False, distance="variation" + ) + ds = DirectSampling(MPSModel(ti, n_neighbors=3, scan_fraction=0.5)) + with self.assertRaisesRegex(ValueError, "variation"): + ds.n_neighbors = 1 + + def test_non_variation_n1_ok(self): + ti = TrainingImage( + np.linspace(0.0, 1.0, 20), categorical=False, distance="l2" + ) + ds = DirectSampling(MPSModel(ti, n_neighbors=1, scan_fraction=0.5)) + self.assertEqual(ds.n_neighbors, 1) + + +class TestStrictBoundaryWarning(unittest.TestCase): + def test_strict_infeasible_warns_and_falls_back(self): + # A lag larger than the TI cannot fit any anchor in strict mode, so the + # function must warn before falling back to partial truncation. + ti_shape = np.array([5]) + lags_ti = np.array( + [[10.0]] + ) # |lag| 10 > TI size 5 → strict infeasible + with self.assertWarns(RuntimeWarning): + lo, hi, keep = _window_bounds(lags_ti, ti_shape, "strict") + # falls back: partial loop drops the over-long lag → keep < len(lags_ti) + self.assertLess(keep, len(lags_ti) + 1) + + def test_strict_feasible_no_warning(self): + # A lag that fits leaves strict mode satisfied → no warning. + ti_shape = np.array([20]) + lags_ti = np.array([[1.0]]) + with warnings.catch_warnings(): + warnings.simplefilter("error", RuntimeWarning) + lo, hi, keep = _window_bounds(lags_ti, ti_shape, "strict") + self.assertEqual(keep, 1) + + +class TestScanWindowThreshold(unittest.TestCase): + def test_ds_mode_strict_threshold(self): + # Mariethoz2010 ¶23: DS acceptance is strict d < t. A candidate at + # exactly the threshold (0.1) must be rejected; the 0.05 candidate is + # accepted instead. With the old inclusive d <= t the at-threshold + # candidate would win first (scan order). + win_shape = (2,) + lo = np.array([0]) + dists = np.array([0.1, 0.05]) + + def dist_fn(y_blk): + return dists[: len(y_blk)] + + y = _scan_window(lo, win_shape, 0, 2, 0.1, dist_fn) + self.assertEqual(int(y[0]), 1) # the 0.05 candidate, not the 0.1 one + + def test_scan_window_greedy_first_under_threshold(self): + # DS mode (threshold > 0) must return the FIRST candidate in scan order + # with d < threshold — NOT the global-argmin candidate. + # Design: candidate 0 has d=0.15 (under threshold 0.2, not the argmin); + # candidate 1 has d=0.05 (under threshold 0.2, IS the argmin). + # np.argmax(under) returns the first True in [True, True] == index 0, + # confirming greedy (first-under-threshold) semantics, not argmin semantics. + win_shape = (3,) + lo = np.array([0]) + # distances for positions 0, 1, 2 in scan order + dists = np.array([0.15, 0.05, 0.30]) + + def dist_fn(y_blk): + idxs = (y_blk[:, 0] - lo[0]).astype(int) + return dists[idxs] + + # Argmin candidate is position 1 (d=0.05); first-under-threshold is + # position 0 (d=0.15 < 0.2). The function must return position 0. + y = _scan_window(lo, win_shape, 0, 3, 0.2, dist_fn) + self.assertEqual( + int(y[0]), 0 + ) # first-under-threshold, not argmin (pos 1) + + def test_dsbc_accepts_exact_match(self): + # DSBC (t=0): exact match d == 0 is still accepted (d <= 0). + win_shape = (2,) + lo = np.array([0]) + dists = np.array([0.0, 0.5]) + + def dist_fn(y_blk): + return dists[: len(y_blk)] + + y = _scan_window(lo, win_shape, 0, 2, 0.0, dist_fn) + self.assertEqual(int(y[0]), 0) # the exact-match candidate + + +class TestNaNTrainingImage(unittest.TestCase): + """Masked / incomplete TIs: NaN cells are undefined (warn + handle). + + Contract: NaN cells are treated as undefined. They are (a) excluded from + the continuous data range ``d_max``, (b) excluded per-position from every + candidate distance, and (c) never pasted into the field. Construction warns + once. A TI with no fully-defined cell cannot be simulated and raises. + """ + + def test_nan_excluded_from_dmax(self): + # Finding #1: a NaN must not collapse d_max to the 1.0 fallback. + with warnings.catch_warnings(): + warnings.simplefilter("ignore") + ti = TrainingImage( + np.array([0.0, np.nan, 100.0]), + categorical=False, + distance="l1", + ) + self.assertAlmostEqual(ti._d_max, 100.0) + + def test_construction_warns_on_nan(self): + with self.assertWarns(UserWarning): + TrainingImage( + np.array([0.0, np.nan, 1.0]), categorical=False, distance="l1" + ) + + def test_partial_nan_continuous_runs_finite(self): + # Finding #2: a NaN patch must not crash (was IndexError) and must + # produce finite output within the defined data range. + data = np.random.RandomState(0).rand(20, 20) + data[5:8, 5:8] = np.nan + with warnings.catch_warnings(): + warnings.simplefilter("ignore") + ti = TrainingImage(data, categorical=False, distance="l1") + ds = DirectSampling(MPSModel(ti, n_neighbors=8, scan_fraction=1.0)) + field = ds([np.arange(15, dtype=float)] * 2, seed=1) + self.assertEqual(field.shape, (15, 15)) + self.assertTrue(np.all(np.isfinite(field))) + self.assertGreaterEqual(field.min(), np.nanmin(data)) + self.assertLessEqual(field.max(), np.nanmax(data)) + + def test_partial_nan_categorical_runs_subset(self): + # Finding #2: categorical NaN patch must not crash (was "produced NaN" + # ValueError) and output must be a subset of the *defined* categories. + data = np.random.RandomState(0).randint(0, 2, (20, 20)).astype(float) + data[5:8, 5:8] = np.nan + with warnings.catch_warnings(): + warnings.simplefilter("ignore") + ti = TrainingImage(data, categorical=True) + ds = DirectSampling(MPSModel(ti, n_neighbors=8, scan_fraction=1.0)) + field = ds([np.arange(15, dtype=float)] * 2, seed=1) + self.assertTrue(np.all(np.isfinite(field))) + self.assertTrue(set(np.unique(field)).issubset({0.0, 1.0})) + + def test_all_nan_ti_raises(self): + # No fully-defined cell → cannot paste any value → clear error. + with warnings.catch_warnings(): + warnings.simplefilter("ignore") + ti = TrainingImage( + np.full((5, 5), np.nan), categorical=False, distance="l2" + ) + ds = DirectSampling(MPSModel(ti, n_neighbors=2, scan_fraction=1.0)) + with self.assertRaises(ValueError): + ds([np.arange(3, dtype=float)] * 2, seed=0) + + +class TestPrecomputeOffsetsGuard(unittest.TestCase): + def test_large_3d_grid_raises_valueerror(self): + # 200^3 with default max_offset=200 → (401)^3 > 5M → guard fires + with self.assertRaises(ValueError) as ctx: + _precompute_offsets((200, 200, 200)) + msg = str(ctx.exception) + self.assertIn("max_offset", msg) + self.assertIn("max_radius", msg) + + def test_large_3d_grid_with_max_radius_ok(self): + # explicit small max_offset bypasses the guard + off = _precompute_offsets((200, 200, 200), max_offset=10) + self.assertEqual(off.shape[1], 3) + + def test_small_grid_ok(self): + # small 2-D grid stays under threshold + off = _precompute_offsets((20, 20)) + self.assertFalse(np.any(np.all(off == 0, axis=1))) + + +class TestStatisticalValidity(unittest.TestCase): + """Core correctness contract: relaxed thresholds and large TIs must reproduce TI statistics.""" + + def test_categorical_histogram_reproduced(self): + """Simulated category proportions must stay within 0.08 of the TI proportions.""" + rng = np.random.default_rng(0) + data = rng.choice( + [0, 1, 2], size=(100, 100), p=[0.5, 0.3, 0.2] + ).astype(float) + ti = TrainingImage(data, categorical=True) + ti_props = np.array([np.mean(data == v) for v in [0, 1, 2]]) + + ds = DirectSampling( + MPSModel( + ti, + n_neighbors=16, + scan_fraction=1.0, + threshold=0.0, + ) + ) + pos = [np.arange(50, dtype=float)] * 2 + field = ds(pos, seed=0) + + # (a) every category must appear — collapse to a single value is a bug + self.assertEqual( + set(np.unique(field)), + {0.0, 1.0, 2.0}, + msg="At least one TI category is missing from the simulated field.", + ) + + # (b) per-category proportions within 0.08 of TI proportions + sim_props = np.array([np.mean(field == v) for v in [0, 1, 2]]) + np.testing.assert_allclose( + sim_props, + ti_props, + atol=0.08, + err_msg="Simulated category proportions deviate more than 0.08 from TI.", + ) + + def test_continuous_mean_preserved(self): + """Simulated mean and std must be within 0.25 / 0.30 of the TI values.""" + rng = np.random.default_rng(0) + data = rng.standard_normal((100, 100)) + ti = TrainingImage(data, categorical=False, distance="l2") + ti_mean = float(data.mean()) + ti_std = float(data.std()) + + ds = DirectSampling( + MPSModel( + ti, + n_neighbors=12, + scan_fraction=1.0, + threshold=0.05, + ) + ) + pos = [np.arange(40, dtype=float)] * 2 + field = ds(pos, seed=0) + + self.assertAlmostEqual( + float(field.mean()), + ti_mean, + delta=0.25, + msg="Simulated field mean deviates by more than 0.25 from TI mean.", + ) + self.assertAlmostEqual( + float(field.std()), + ti_std, + delta=0.30, + msg="Simulated field std deviates by more than 0.30 from TI std.", + ) + + +class TestMVTransformsAndReporting(unittest.TestCase): + """Behaviour tests for set_mv_transforms, post_process, progress, and cond_weight.""" + + @classmethod + def setUpClass(cls): + rng = np.random.default_rng(0) + cls.mv_data = { + "a": rng.integers(0, 3, (20, 20)).astype(float), + "b": rng.integers(0, 2, (20, 20)).astype(float), + } + cls.mv_ti = TrainingImage(cls.mv_data) + cls.pos = [np.arange(6, dtype=float)] * 2 + + def test_set_mv_transforms_mean_applied(self): + """set_mv_transforms(mean={'a': 100.0}) must shift variable 'a' by 100.""" + ds = DirectSampling( + MPSModel(self.mv_ti, n_neighbors=4, scan_fraction=0.3) + ) + ds.set_mv_transforms(mean={"a": 100.0}) + + field_pp = ds(self.pos, seed=5) + field_raw = ds(self.pos, seed=5, post_process=False) + + # post-processed 'a' == raw 'a' + 100 everywhere + np.testing.assert_allclose( + field_pp["a"], + field_raw["a"] + 100.0, + err_msg="Post-processed 'a' should equal raw 'a' + 100.", + ) + # variable 'b' has no transform — must be unaffected + np.testing.assert_array_equal( + field_pp["b"], + field_raw["b"], + err_msg="Variable 'b' should be unaffected by the 'a' mean transform.", + ) + + def test_post_process_false_returns_raw(self): + """post_process=False must return values that are a subset of TI categories.""" + ds = DirectSampling( + MPSModel(self.mv_ti, n_neighbors=4, scan_fraction=0.3) + ) + ds.set_mv_transforms(mean={"a": 100.0}) + field_raw = ds(self.pos, seed=7, post_process=False) + + ti_a_values = set(np.unique(self.mv_data["a"])) + sim_a_values = set(np.unique(field_raw["a"])) + self.assertTrue( + sim_a_values.issubset(ti_a_values), + msg=f"post_process=False 'a' values {sim_a_values} are not a subset of TI values {ti_a_values}.", + ) + + def test_progress_callback_invoked(self): + """progress callable must be called exactly n_nodes times; final call done == total == n_nodes.""" + rng = np.random.default_rng(1) + data = rng.integers(0, 3, (20, 20)).astype(float) + ti = TrainingImage(data) + ds = DirectSampling(MPSModel(ti, n_neighbors=4, scan_fraction=0.3)) + pos = [np.arange(6, dtype=float)] * 2 + n_nodes = 6 * 6 + + calls = [] + + def cb(done, total): + calls.append((done, total)) + + ds(pos, seed=0, progress=cb) + + self.assertEqual( + len(calls), + n_nodes, + msg=f"Progress callback should be called {n_nodes} times, got {len(calls)}.", + ) + last_done, last_total = calls[-1] + self.assertEqual(last_done, n_nodes) + self.assertEqual(last_total, n_nodes) + + def test_cond_weight_changes_output(self): + """Different cond_weight values must yield different fields while honoring the conditioned node.""" + rng = np.random.default_rng(2) + data = rng.integers(0, 3, (20, 20)).astype(float) + ti = TrainingImage(data) + pos = [np.arange(8, dtype=float)] * 2 + cond_pos = [[4.0], [4.0]] + cond_val = [2] + + ds1 = DirectSampling( + MPSModel(ti, n_neighbors=8, scan_fraction=0.3, cond_weight=1.0) + ) + ds1.set_condition(cond_pos, cond_val) + f1 = ds1(pos, seed=0) + + ds5 = DirectSampling( + MPSModel(ti, n_neighbors=8, scan_fraction=0.3, cond_weight=5.0) + ) + ds5.set_condition(cond_pos, cond_val) + f5 = ds5(pos, seed=0) + + # the two fields must differ (cond_weight propagates through the distance) + self.assertFalse( + np.array_equal(f1, f5), + msg="cond_weight=1.0 and cond_weight=5.0 produced identical output; cond_weight has no effect.", + ) + # the conditioned node must keep its value in both runs + self.assertEqual(int(f1[4, 4]), 2) + self.assertEqual(int(f5[4, 4]), 2) + + +if __name__ == "__main__": + unittest.main()

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 Y0rOlFtMT^N#G{bUDE^jo`tq&+1?C5YivR!s literal 0 HcmV?d00001 diff --git a/examples/13_mps/_preview/06_parameters.png b/examples/13_mps/_preview/06_parameters.png new file mode 100755 index 0000000000000000000000000000000000000000..9f5e80281d14001fe88a6c3bb58983a71906a300 GIT binary patch literal 28507 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 literal 0 HcmV?d00001 diff --git a/examples/13_mps/strebelle.npz b/examples/13_mps/strebelle.npz new file mode 100755 index 0000000000000000000000000000000000000000..46d314f717f6f0791674f3b22aeddd24e7a8f8f2 GIT binary patch literal 2466 zcmV;T30?M3O9KQg000080000X0K=j!DgXcf|NsC0{{{dQ0CZ_CZg6=401yCx00961 z0000W2><{90002(oiUFiMHGbXlwYygf^-Q;5by)YKqLf2=)@fY32|r-kpRDfKg^!s zmi0`(?y6VydS-Ur0TOnR!{r%N9Uw-}V`SkngkK0$T-+q60`}xi7pFe$k z`{L&Ihc|b>-M#$fyEk{QUcY<%ipJ>6zh7H}Y_rbi0~KJ0JTI14-M9)Um)ZB+Km}tv|E>xM5FMmN zvZmD!Za}RoR$gFs4OLJr>xT+1HL#jzbc^!m(q|fI3^Tel`SbBvoc1g(oM@aOs;!_q zhDj$XCy;6z7!Co-gdGh8q{=sd?H?75x*;oVkwHRtPb@$Z*YfAMoCO$EiFwkcya10R zDnh$d=eMarV7wEO-^iR4!by3jSizn@DKkb@^2c8gh~(z*T~;N2Bzy6&iIbHfq*a&Z zbXL<&2Ws0&Zn(Md9E6j?Us`EkR?d0xsr+zyope@w;?7B%r?P}o@U~@LC~uUmHvfBl zhf>#IXcLF)o&x2^PhSWokms-sj47co&}p#G9{Pw(0JMai71BduS&vvijK-7l`FBu3 z0pzhdr~srJ$W$=zPwy&S$s-R&q83W0jQosUN>$qYx1*szN>|Zjd_XfpgN(AEm-2Jm z*GXefjo&sj6pu4&*s;u}P-pw~5QH`GJZ8OyM(@#dPl#CWIedrUb@y*}LZU z@W3@{Y(AgPZ33!B+ls@t9c*TVUbu1F{N^94;G0)Z2plA&rvh4NkiV(`Apfje8vXn= z1zb4#3P@@+H&^EG*rgkg##{T#@&|BQ0a|&juw^GeBrFslRrg2%;?!0LuU$aqJC-b0 zQ#T>jcj>B-8fs){MYx>jb=7LK$!3hnxiC)Fz)BltU@gHXodfgP$qNJgETA!i5Bd zE-N7I<07KtTMJ10IH1U+<^q()*|yRE!9+SV=RV{R3XpuY=)%`ii|NrlC*3?4-XeR8 zt_y2%Hy5BLUb1yz9o~`1w#gqcAkbs?&OrMKOL(CvZ?Rp7bOF38o``P@_it#@`6X{a zfp3fih_??E4BjKPlqri4PplquTVG&+H&Y7y!&xqG$~&eZXjOz@Iv?Nhr<#;M>1kO? zb{Do$YJaIAYNOPCX2S#4+IP$F3j@!R9||2SI>L z{DU@dT7Q|HOy6wayuM?-zeVQn?P zYOs@l)~3=*1!&z->>d?k0Xii^N(&R(89y1*%;V0_{1gG3l4yoRs3pUeNK%!(%LC@; zc83!@q9=W#0CE^H9W{*pH6yx$sIBkc=On10~^eOvzu$ z!OOz!i_hIB(Bm6^EI1U=iGZD?2?)Izq(K#ao;>j1EK&_VIFo0UnC@uVR?7(eZy zhzuvq@teq5eoKvmK{#dvtg8Wq8GQqQj!%q9=HyR*qPL;p5kPA~__eP#jlT&%VoT+U^b1#60p1M2%!z;L zDl5QyhbYVAQkZ{k0Xe6_^e0ET)diHs&z%ABxeCpt0J$Mro^fc$S3d;$X4DL~nEX+6 zP$Hdww1tvvTZmte5(V&V5E3KX6v1{$1+btaRkHrR3;<#&zzD|LXMKpP^sy0(MP4=I z@=L7|$I68ECjmQx=_5cpA!ixtKPA7r06-t~C-GvrUiw@U?fr!0coPjJ$5#uW1c%#L zCNzFP%GR*j$*T1Cvd07vT0O5-aIr5_VQ+#w7*YNKlvKc@jhXt^{_V#xrRJL-z|?C1 zJ%Q8lqi;q9rA{!6fXI<94)-UIe*AKzuGX~tAhK)^YG68X-+uDXUe7%K!+Nf{uj}cpXMPSp>(}rT zdjp3*ke=qJ7!ax-{NNR!;r3rZ2FICx(*kl_=J;C`kfgJx->8EGnn@?whW zBeQ0_f8ZZbO928c11$gm00;m803iUwqAe*P2><|q0096700000000000001h0RR91 g0CZ_CZg6=}O9ci1000010096r000132><{90M5RqVgLXD literal 0 HcmV?d00001 diff --git a/src/gstools/__init__.py b/src/gstools/__init__.py old mode 100644 new mode 100755 index 4d12007c..4094f500 --- a/src/gstools/__init__.py +++ b/src/gstools/__init__.py @@ -23,10 +23,22 @@ tools transform normalizer + mps Classes ======= +Multiple Point Statistics +^^^^^^^^^^^^^^^^^^^^^^^^^ +Classes for Multiple Point Statistics (MPS) simulations + +.. currentmodule:: gstools.mps + +.. autosummary:: + DirectSampling + MPSModel + TrainingImage + Kriging ^^^^^^^ Swiss-Army-Knife for Kriging. For short cut classes see: :any:`gstools.krige` @@ -139,6 +151,7 @@ covmodel, field, krige, + mps, normalizer, random, tools, @@ -169,6 +182,7 @@ ) from gstools.field import PGS, SRF, CondSRF from gstools.krige import Krige +from gstools.mps import DirectSampling, MPSModel, TrainingImage from gstools.tools import ( DEGREE_SCALE, EARTH_RADIUS, @@ -200,7 +214,7 @@ __all__ = ["__version__"] __all__ += ["covmodel", "field", "variogram", "krige", "random", "tools"] -__all__ += ["transform", "normalizer", "config"] +__all__ += ["transform", "normalizer", "config", "mps"] __all__ += [ "CovModel", "SumModel", @@ -237,6 +251,9 @@ "SRF", "CondSRF", "PGS", + "DirectSampling", + "MPSModel", + "TrainingImage", "rotated_main_axes", "generate_grid", "generate_st_grid", diff --git a/src/gstools/mps/__init__.py b/src/gstools/mps/__init__.py new file mode 100755 index 00000000..1e726157 --- /dev/null +++ b/src/gstools/mps/__init__.py @@ -0,0 +1,20 @@ +""" +GStools subpackage for Multiple Point Statistics (MPS). + +.. currentmodule:: gstools.mps + +Multiple Point Statistics +^^^^^^^^^^^^^^^^^^^^^^^^^ +.. autosummary:: + :toctree: + + DirectSampling + MPSModel + TrainingImage +""" + +from gstools.mps.direct_sampling import DirectSampling +from gstools.mps.model import MPSModel +from gstools.mps.training_image import TrainingImage + +__all__ = ["DirectSampling", "MPSModel", "TrainingImage"] diff --git a/src/gstools/mps/direct_sampling.py b/src/gstools/mps/direct_sampling.py new file mode 100755 index 00000000..592bb9a1 --- /dev/null +++ b/src/gstools/mps/direct_sampling.py @@ -0,0 +1,638 @@ +""" +GStools subpackage providing the Direct Sampling MPS simulation class. + +.. currentmodule:: gstools.mps + +The following classes and functions are provided + +.. autosummary:: + DirectSampling +""" + +import numpy as np + +from gstools.field.base import Field +from gstools.mps.model import MPSModel +from gstools.mps.model import _validate_boundary as _mv_validate_boundary +from gstools.mps.model import _validate_max_radius as _mv_validate_max_radius +from gstools.mps.model import _validate_n_neighbors as _mv_validate_n_neighbors +from gstools.mps.model import ( + _validate_scan_fraction as _mv_validate_scan_fraction, +) +from gstools.mps.model import _validate_threshold as _mv_validate_threshold +from gstools.mps.simulate import _MV_VAR, _univar_as_mv_ti, ds_simulate +from gstools.normalizer.tools import apply_mean_norm_trend +from gstools.random.rng import RNG +from gstools.tools.geometric import no_of_angles + +__all__ = ["DirectSampling"] + + +def _resolve_nonstationary_map(param, sim_shape, n_stationary): + """Return ``None`` or an array broadcastable to ``sim_shape``. + + Scalars and 0-d arrays are broadcast to the grid. A 1-D vector is a + *stationary* multi-component value (e.g. a 3-element Tait–Bryan angle triple + for a 3-D grid) and is accepted only when its length equals + ``n_stationary`` — the number of components a stationary value has for this + parameter and grid dimension. A *per-node* map must have leading dimensions + equal to ``sim_shape`` (i.e. a full-shape array, not a flattened vector). + + Parameters + ---------- + param : scalar or array-like or None + User-supplied rotation/anis value. + sim_shape : tuple + Simulation grid shape. + n_stationary : int + Component count of a stationary value for this parameter/dimension + (``no_of_angles(dim)`` for rotation, ``dim - 1`` for anis). + + Raises + ------ + ValueError + If a 1-D vector matches neither a stationary value nor the grid — the + common cause is a per-node map passed *flattened* instead of shaped + like the grid, which would otherwise silently apply only element [0]. + """ + if param is None: + return None + arr = np.asarray(param, dtype=np.float64) + if arr.ndim == 0 or arr.size == 1: + return np.full(sim_shape, float(arr.flat[0])) + if arr.ndim == 1: + # Only a genuine stationary multi-component value is accepted as 1-D. + # A per-node map is multi-dimensional (leading dims == grid); a 1-D + # array of any other length is almost certainly a flattened per-node + # map and would silently degrade to its first element — reject it. + if arr.size == n_stationary: + return arr + raise ValueError( + f"1-D non-stationary value of length {arr.size} matches neither a " + f"stationary value ({n_stationary} component(s) for a " + f"{len(sim_shape)}-D grid) nor a per-node map. For per-node values " + f"pass an array shaped like the grid {tuple(sim_shape)!r}, not a " + f"flattened vector." + ) + if arr.shape[: len(sim_shape)] == tuple(sim_shape): + return arr + raise ValueError( + f"Non-stationary map shape {arr.shape!r} is incompatible with " + f"simulation grid shape {tuple(sim_shape)!r}. Pass a scalar or " + f"1-D vector for a stationary value, or an array whose leading " + f"dimensions match the grid." + ) + + +class DirectSampling(Field): + """Multiple Point Statistics simulation using Direct Sampling. + + Subclasses :class:`gstools.field.base.Field`. Takes an :class:`MPSModel` + that bundles a :class:`TrainingImage` and all algorithm parameters, and + produces fields on structured grids. + + Parameters + ---------- + model : MPSModel + Algorithm configuration: training image, neighbour count, scan + fraction, threshold, conditioning weight, boundary strategy, and + maximum search radius. Build one with + ``MPSModel(ti, n_neighbors=…, scan_fraction=…, …)``. + seed : int or nan, optional + Master RNG seed. Default: nan. + + Notes + ----- + Runtime concerns (thread count, progress reporting) are set on the + instance via :attr:`num_threads` or passed as keyword arguments to + :meth:`__call__`. + + See Also + -------- + MPSModel : holds the algorithm parameters. + TrainingImage : training data holder. + """ + + default_field_names = ["field"] + + @staticmethod + def _validate_variation_n_neighbors(n_neighbors, ti): + """Reject variation distance with a single-neighbour data event. + + The variation distance (Mariethoz2010 Eq. 9) compares each event to its + own local mean. With ``n_neighbors == 1`` the local mean equals the sole + value, so every deviation is zero and every TI candidate matches — the + scan degenerates to a random draw. Fail fast instead. + """ + dist_type = ti.distance_type + if isinstance(dist_type, dict): + dist_map = dist_type + n_map = ( + n_neighbors + if isinstance(n_neighbors, dict) + else {v: n_neighbors for v in dist_map} + ) + else: + dist_map = {None: dist_type} + n_map = {None: n_neighbors} + for var, dt in dist_map.items(): + if isinstance(dt, str) and dt.lower().startswith("variation"): + if int(n_map[var]) < 2: + where = "" if var is None else f" for variable {var!r}" + raise ValueError( + f"distance='variation' requires n_neighbors >= 2{where}: " + "a single-point data event has no local mean deviation." + ) + + def __init__( + self, + model, + seed=np.nan, + ): + if not isinstance(model, MPSModel): + raise TypeError( + "DirectSampling requires an MPSModel as its first argument. " + "Wrap a TrainingImage first: " + "DirectSampling(MPSModel(ti, n_neighbors=…, …))" + ) + + self._model = model + super().__init__(model=None, dim=model.ti.ndim, value_type="scalar") + self._ti = model.ti + self._n_neighbors = model.n_neighbors + DirectSampling._validate_variation_n_neighbors( + self._n_neighbors, self._ti + ) + self._scan_fraction = model.scan_fraction + self._threshold = model.threshold + self._cond_weight = model.cond_weight + self._boundary = model.boundary + self._max_radius = model.max_radius + self._num_threads = None + self._cond_pos = None + self._cond_val = None + self._mv_mean = {} + self._mv_normalizer = {} + self._mv_trend = {} + self._rotation = None + self._anis = None + self.rng = RNG(None if np.isnan(seed) else int(seed)) + if model.ti.multivariate: + for v in model.ti.variables: + if not v.isidentifier() or v in dir(self): + raise ValueError( + f"DirectSampling: variable name {v!r} cannot be used as " + f"a field name; use a valid Python identifier that does " + f"not collide with an existing attribute." + ) + + def __call__( + self, + pos=None, + seed=np.nan, + path_seed=np.nan, + node_seed=np.nan, + mesh_type="structured", + post_process=True, + store=True, + progress=None, + num_threads=None, + ): + """Generate the spatial random field via Direct Sampling. + + The field is saved as ``self.field`` and is also returned. + + Parameters + ---------- + pos : :class:`list`, optional + The position tuple, containing main direction and transversal + directions. Only structured grids are supported. + seed : :class:`int`, optional + Seed for the RNG. If ``np.nan``, the current seed is kept. + Default: ``np.nan`` + path_seed : :class:`int` or :any:`numpy.nan`, optional + Seed controlling the order in which simulation grid nodes are + visited. If ``np.nan`` (default), derived from the master RNG + together with ``node_seed``. Fix this while varying ``node_seed`` + to study the effect of TI search randomness under a constant + visit order, or vice versa. + Default: ``np.nan`` + node_seed : :class:`int` or :any:`numpy.nan`, optional + Seed controlling the TI scan entry point and fallback cell for + every node. If ``np.nan`` (default), derived from the master RNG. + Default: ``np.nan`` + mesh_type : :class:`str`, optional + Grid type. Must be ``"structured"``. + Default: ``"structured"`` + post_process : :class:`bool`, optional + Whether to apply post-processing transformations (mean, + normalizer, trend) to the field. Default: :any:`True` + store : :class:`bool` or :class:`str`, optional + Whether to store the field (``True``), not store it (``False``), + or store it under a custom name (string). + Default: :any:`True` + progress : :class:`bool` or callable or None, optional + Show simulation progress. ``True`` displays a :mod:`tqdm` bar (or a + plain percentage line if ``tqdm`` is not installed); a callable is + invoked as ``progress(n_done, n_total)`` once per completed node. + ``None``/``False`` (default) disables it. + + Returns + ------- + field : :class:`numpy.ndarray` or :class:`dict` + For a univariate training image, the simulated field (also saved as + ``self.field``). For a multivariate training image, a + ``{variable: numpy.ndarray}`` dict with all variables on equal + footing — each is also stored as a named field accessible via + ``self[variable]`` / :attr:`all_fields`. + """ + if mesh_type != "structured": + raise ValueError( + "DirectSampling: only structured grids are supported." + ) + if self._ti.multivariate and isinstance(store, str): + # A multivariate run produces one field per variable; there is no + # single privileged field to store under a custom name. Reject it + # explicitly rather than silently dropping the name (the fields are + # always stored under their variable names). + raise ValueError( + "DirectSampling: a custom store name is not supported for " + "multivariate training images; each variable is stored under " + "its own name. Use store=True/False instead." + ) + name, save = self.get_store_config(store) + pos, shape = self.pre_pos(pos, mesh_type) + # Stationary component counts disambiguate a 1-D value from a flattened + # per-node map: rotation has no_of_angles(dim) angles, anis has dim-1. + rotation_map = _resolve_nonstationary_map( + self._rotation, shape, no_of_angles(len(shape)) + ) + anis_map = _resolve_nonstationary_map( + self._anis, shape, max(len(shape) - 1, 1) + ) + conditions = self._conditions_to_grid(self.pos) + if not np.isnan(seed): + self.rng.seed = int(seed) + rng_path = ( + self.rng.random + if np.isnan(path_seed) + else RNG(int(path_seed)).random + ) + rng_nodes = ( + self.rng.random + if np.isnan(node_seed) + else RNG(int(node_seed)).random + ) + # Call-time num_threads overrides the instance default. + n_threads = ( + num_threads if num_threads is not None else self._num_threads + ) + if self._ti.multivariate: + result = ds_simulate( + training_image=self._ti, + sim_shape=shape, + n_neighbors=self._n_neighbors, + threshold=self._threshold, + scan_fraction=self._scan_fraction, + rng_path=rng_path, + rng_nodes=rng_nodes, + conditions=conditions, + cond_weight=self._cond_weight, + boundary=self._boundary, + max_radius=self._max_radius, + num_threads=n_threads, + rotation_map=rotation_map, + anis_map=anis_map, + progress=progress, + ) + # Equal treatment: every variable is a first-class named field + # (no privileged primary). Returned as a dict keyed by variable name. + # Per-variable transforms (mean/normalizer/trend) are applied here + # using the dicts set via set_mv_transforms(); variables absent from + # those dicts fall back to the inherited self.mean/normalizer/trend. + # post_field is then called with process=False to handle storage only. + out = {} + for v in self._ti.variables: + fld = result[v] + if post_process: + mv_mean = self._mv_mean.get(v, self.mean) + mv_norm = self._mv_normalizer.get(v, self.normalizer) + mv_trend = self._mv_trend.get(v, self.trend) + fld = apply_mean_norm_trend( + pos=self.pos, + field=fld, + mesh_type=self.mesh_type, + value_type=self.value_type, + mean=mv_mean, + normalizer=mv_norm, + trend=mv_trend, + check_shape=False, + stacked=False, + ) + out[v] = self.post_field(fld, name=v, process=False, save=save) + return out + mv_ti = _univar_as_mv_ti(self._ti) + mv_cond = ( + {idx: {_MV_VAR: val} for idx, val in conditions.items()} + if conditions + else None + ) + mv_result = ds_simulate( + training_image=mv_ti, + sim_shape=shape, + n_neighbors=self._n_neighbors, + threshold=self._threshold, + scan_fraction=self._scan_fraction, + rng_path=rng_path, + rng_nodes=rng_nodes, + conditions=mv_cond, + cond_weight=self._cond_weight, + boundary=self._boundary, + max_radius=self._max_radius, + num_threads=n_threads, + rotation_map=rotation_map, + anis_map=anis_map, + progress=progress, + ) + return self.post_field(mv_result[_MV_VAR], name, post_process, save) + + def _conditions_to_grid(self, axes): + """Snap conditioning points to nearest grid nodes (Mariethoz2010 §3 ¶12). + + Univariate returns ``{idx: value}``; multivariate returns + ``{idx: {variable: value}}`` with non-finite (NaN) entries skipped. When + two points snap to the same node, the conflict is resolved + **per variable**: for each variable the closest colliding point with a + finite value wins. A farther point therefore still contributes its + finite values for any variable the closer point left ``NaN``, so valid + conditioning data is never silently discarded. + + Parameters + ---------- + axes : tuple of numpy.ndarray + Raw grid axis arrays (``self.pos``). + + Returns + ------- + dict + """ + if self._cond_pos is None: + return {} + if self._ti.multivariate and isinstance(self._cond_val, dict): + if not self._cond_val: + raise ValueError("cond_val must not be empty") + # idx -> {variable: (value, dist_sq)}; the closest finite value per + # variable wins, so a farther point fills variables the closer one + # left NaN (per-variable collision resolution). + candidates = {} + n_cond = len(next(iter(self._cond_val.values()))) + for k in range(n_cond): + idx, dist_sq = self._snap_to_nearest(axes, k) + var_best = candidates.setdefault(idx, {}) + for v in self._cond_val: + val = self._cond_val[v][k] + if not np.isfinite(val): + continue + if v not in var_best or dist_sq < var_best[v][1]: + var_best[v] = (float(val), dist_sq) + return { + idx: {v: val for v, (val, _) in var_best.items()} + for idx, var_best in candidates.items() + } + # univariate (unchanged) + candidates = {} # idx -> (val, dist_sq) + for k in range(self._cond_val.shape[0]): + idx, dist_sq = self._snap_to_nearest(axes, k) + if idx not in candidates or dist_sq < candidates[idx][1]: + candidates[idx] = (self._cond_val[k], dist_sq) + return {idx: val for idx, (val, _) in candidates.items()} + + def _snap_to_nearest(self, axes, k): + """Return (grid_index_tuple, dist_sq) for the k-th conditioning point.""" + idx = tuple( + int(np.argmin(np.abs(axes[d] - self._cond_pos[d][k]))) + for d in range(self.dim) + ) + dist_sq = sum( + (axes[d][idx[d]] - self._cond_pos[d][k]) ** 2 + for d in range(self.dim) + ) + return idx, dist_sq + + def set_condition(self, cond_pos, cond_val, cond_weight=None): + """Set the conditioning data for the simulation. + + Parameters + ---------- + cond_pos : :class:`list` + The position tuple of the conditioning data ``(x, [y, z])``. + cond_val : :class:`numpy.ndarray` or :class:`dict` + Univariate: values at the conditioning positions. Multivariate: a + ``{variable: numpy.ndarray}`` mapping (use ``numpy.nan`` for a + variable that is not conditioned at a given point). + cond_weight : :class:`float`, optional + Conditioning weight delta. If given, overrides the ``cond_weight`` set + at construction. Default: :any:`None` (keep existing weight) + """ + if cond_weight is not None: + self._cond_weight = float(cond_weight) + if self._ti.multivariate and isinstance(cond_val, dict): + if not cond_val: + raise ValueError("cond_val must not be empty") + unknown = set(cond_val) - set(self._ti.variables) + if unknown: + raise ValueError( + f"cond_val contains unknown variable(s): {sorted(unknown)}. " + f"TI variables are: {sorted(self._ti.variables)}" + ) + cond_pos_arr = np.asarray(cond_pos, dtype=np.double).reshape( + self.dim, -1 + ) + n_cond = len(next(iter(cond_val.values()))) + for v, arr in cond_val.items(): + if len(arr) != n_cond: + raise ValueError( + "DirectSampling: all cond_val arrays must have the same " + f"length; got {n_cond} for {next(iter(cond_val))!r} but " + f"{len(arr)} for {v!r}." + ) + if cond_pos_arr.shape[1] != n_cond: + raise ValueError( + "DirectSampling: cond_pos and cond_val length mismatch." + ) + self._cond_pos = cond_pos_arr + self._cond_val = { + v: np.asarray(a, dtype=np.double) for v, a in cond_val.items() + } + elif self._ti.multivariate: + raise ValueError( + "DirectSampling: cond_val must be a dict {variable: array} " + "for multivariate TrainingImages." + ) + else: + from gstools.krige.tools import set_condition as _gs_set_condition + + self._cond_pos, self._cond_val = _gs_set_condition( + cond_pos, cond_val, self.dim + ) + + def set_mv_transforms(self, mean=None, normalizer=None, trend=None): + """Set per-variable post-processing transforms for multivariate simulations. + + Only meaningful when the training image is multivariate. Variables not + listed here fall back to the instance-level ``self.mean``, + ``self.normalizer``, and ``self.trend``. + + Parameters + ---------- + mean : dict of {str: scalar or callable}, optional + Per-variable mean. + normalizer : dict of {str: Normalizer}, optional + Per-variable normalizer. + trend : dict of {str: scalar or callable}, optional + Per-variable trend (applied after denormalization). + """ + from gstools.field.base import _set_mean_trend + from gstools.normalizer.tools import _check_normalizer + + if mean is not None: + self._mv_mean = { + v: _set_mean_trend(m, self.dim) for v, m in mean.items() + } + if normalizer is not None: + self._mv_normalizer = { + v: _check_normalizer(n) for v, n in normalizer.items() + } + if trend is not None: + self._mv_trend = { + v: _set_mean_trend(t, self.dim) for v, t in trend.items() + } + + def set_nonstationary(self, rotation=None, anis=None): + """Set per-node geometric transform for non-stationary simulation. + + Transforms lag vectors from the simulation-grid frame into the training + image's own frame before each TI scan (Mariethoz2010 §6.2). Enables + spatially varying orientation and anisotropy without modifying the TI. + + Parameters + ---------- + rotation : float or numpy.ndarray, optional + Rotation angle(s) in radians. Scalar → stationary (same angle at + every node). Array whose leading dimensions match the simulation + grid shape → per-node angles. Convention matches + :class:`gstools.CovModel` ``angles`` (2-D: one angle; 3-D: + Tait–Bryan yaw/pitch/roll). ``None`` → no rotation applied. + anis : float or numpy.ndarray, optional + Anisotropy ratio(s). Scalar → stationary. Array → per-node. Values + less than 1 compress the TI search in transversal directions. + Convention matches :class:`gstools.CovModel` ``anis``. + ``None`` → isotropic. + """ + if rotation is not None: + self._rotation = np.asarray(rotation, dtype=np.float64) + if anis is not None: + anis_arr = np.asarray(anis, dtype=np.float64) + if np.any(anis_arr <= 0): + raise ValueError( + f"DirectSampling: anis must be positive everywhere, " + f"got minimum value {float(anis_arr.min())!r}" + ) + self._anis = anis_arr + + @property + def ti(self): + """TrainingImage: The training image model.""" + return self._ti + + @property + def n_neighbors(self): + """:class:`int` or :class:`dict`: Maximum neighbours in the data event (per-variable dict for multivariate TIs).""" + return self._n_neighbors + + @n_neighbors.setter + def n_neighbors(self, value): + validated = _mv_validate_n_neighbors(value, self._ti) + DirectSampling._validate_variation_n_neighbors(validated, self._ti) + self._n_neighbors = validated + + @property + def scan_fraction(self): + """:class:`float`: Fraction of the TI to scan per node (capped at the search window).""" + return self._scan_fraction + + @scan_fraction.setter + def scan_fraction(self, value): + self._scan_fraction = _mv_validate_scan_fraction(value) + + @property + def threshold(self): + """:class:`float`: Distance threshold (0.0 → DSBC mode).""" + return self._threshold + + @threshold.setter + def threshold(self, value): + self._threshold = _mv_validate_threshold(value) + + @property + def cond_weight(self): + """:class:`float`: Weight for conditioning nodes in distance.""" + return self._cond_weight + + @cond_weight.setter + def cond_weight(self, value): + self._cond_weight = float(value) + + @property + def boundary(self): + """:class:`str`: Search-window strategy (``"strict"`` or ``"partial"``).""" + return self._boundary + + @boundary.setter + def boundary(self, value): + self._boundary = _mv_validate_boundary(value) + + @property + def max_radius(self): + """:class:`float` or :any:`None`: Euclidean cap on SG neighbour selection. + + Values in ``(0, 1)`` disable all neighbours (nearest grid cell is + at distance 1.0), causing every node to fall back to a random TI + sample. + """ + return self._max_radius + + @max_radius.setter + def max_radius(self, value): + self._max_radius = _mv_validate_max_radius(value) + + @property + def num_threads(self): + """:class:`int` or :any:`None`: Number of threads for outer DAG parallelism.""" + return self._num_threads + + @num_threads.setter + def num_threads(self, value): + self._num_threads = None if value is None else int(value) + + def __repr__(self): + parts = [ + f"DirectSampling(dim={self.dim}, ", + f"n_neighbors={self.n_neighbors}, ", + f"scan_fraction={self.scan_fraction}, ", + f"threshold={self.threshold}, ", + f"boundary={self.boundary!r}", + ] + if self._rotation is not None: + rot_val = ( + float(self._rotation) + if self._rotation.ndim == 0 + else self._rotation + ) + parts.append(f", rotation={rot_val!r}") + if self._anis is not None: + anis_val = ( + float(self._anis) if self._anis.ndim == 0 else self._anis + ) + parts.append(f", anis={anis_val!r}") + return "".join(parts) + ")" diff --git a/src/gstools/mps/distance.py b/src/gstools/mps/distance.py new file mode 100755 index 00000000..3497a5b5 --- /dev/null +++ b/src/gstools/mps/distance.py @@ -0,0 +1,274 @@ +"""Pure distance functions for MPS pattern comparison. + +No class state — takes arrays and scalars, returns floats. +``TrainingImage.distance()`` uses these internally; other algorithms +can import them directly. +""" + +import numpy as np + +__all__ = [ + "compute_node_weights", + "vec_categorical_dist", + "vec_l1_dist", + "vec_l2_dist", + "vec_lp_dist", + "vec_variation_dist", +] + + +def compute_node_weights( + n, lag_norms, distance_power, cond_mask=None, cond_weight=1.0 +): + """Compute normalized spatial-decay weights for a data event. + + Combines spatial decay (Mariethoz2010 Eq. 5) with conditioning data + multipliers (Mariethoz2010 §3 ¶26). + + Parameters + ---------- + n : int + Number of neighbours in the data event. + lag_norms : array-like or None, shape (n,) + Euclidean norms ``‖h_i‖`` of each lag vector. ``None`` or + ``distance_power == 0`` → uniform spatial weights. A zero lag-norm + (collocated ``h=0`` entry) keeps the unit baseline weight and is not + amplified by the spatial decay — its weight is scaled by ``cond_weight``. + distance_power : float + Exponent δ. ``0.0`` → uniform. + cond_mask : array-like of bool, optional + ``True`` where the neighbour is a conditioning datum. + cond_weight : float, optional + Bonus weight multiplier for conditioning nodes. + + Returns + ------- + numpy.ndarray, shape (n,) + Node weights normalized to sum to 1. + """ + raw_w = np.ones(n, dtype=np.float64) + if lag_norms is not None and distance_power != 0.0: + norms = np.asarray(lag_norms, dtype=np.float64) + # Only non-zero lags decay with distance. A *true* zero lag-norm is a + # collocated/conditioning entry (h=0, e.g. the multivariate same-node + # constraint); it keeps the unit-cell baseline weight 1.0 rather than the + # divergent norm**(-power), and its importance is governed by the + # cond_weight multiplier below (it always carries cond_mask=True). + nz = norms != 0.0 + raw_w[nz] = norms[nz] ** (-distance_power) + + if cond_mask is not None: + # ``raw_w`` is a freshly allocated array (np.ones above, modified in + # place), so no defensive copy is needed before scaling. + raw_w[np.asarray(cond_mask, dtype=bool)] *= cond_weight + + total = raw_w.sum() + if total == 0.0: + # Every neighbour was zeroed out — the canonical case is an all- + # conditioning data event with cond_weight == 0 (δ_c = 0 → conditioning + # ignored entirely, Me13 p.323 → unconditional behaviour). Returning + # zero weights makes the data event non-informative so the node is drawn + # unconditionally, rather than re-weighting the ignored nodes uniformly. + return np.zeros(n, dtype=np.float64) + if not np.isfinite(total): + # Defensive: non-finite weight sum should be unreachable for grid lags + # (‖h‖ >= 1) — fall back to uniform rather than emit NaNs. + return np.full(n, 1.0 / n, dtype=np.float64) + return raw_w / total + + +# --------------------------------------------------------------------------- +# Vectorized variants — same maths, operate on all TI candidates at once. +# Each accepts all_de_ti of shape (max_scan, n) and returns (max_scan,). +# np.dot(X, w) with X (max_scan, n) and w (n,) is a standard BLAS matvec. +# +# NaN handling (``has_nan``): when the TI contains undefined (NaN) cells, a +# candidate data event may have NaN at some positions. With ``has_nan=True`` +# those positions are excluded per-row and the weights are renormalized over +# the defined positions (a proper convex combination); a candidate whose data +# event is *entirely* undefined gets distance ``+inf`` so it is never selected. +# ``has_nan=False`` (the default) is the original, NaN-free computation, kept +# byte-identical and overhead-free for the common case. +# --------------------------------------------------------------------------- + + +def _masked_weights(all_de_ti, node_weights): + """Per-row weights with undefined (NaN) TI positions zeroed. + + Returns + ------- + valid : numpy.ndarray of bool, shape (max_scan, n) + ``True`` where the TI value is defined (finite). + we : numpy.ndarray, shape (max_scan, n) + ``node_weights`` broadcast, zeroed at undefined positions. + wsum : numpy.ndarray, shape (max_scan,) + Row sums of ``we``; ``0`` for a fully-undefined data event. + """ + valid = ~np.isnan(all_de_ti) + we = node_weights[np.newaxis, :] * valid + return valid, we, we.sum(axis=1) + + +def _renorm(numerator, wsum): + """``numerator / wsum`` per row, with ``+inf`` where ``wsum == 0``.""" + out = np.full(numerator.shape, np.inf, dtype=np.float64) + nz = wsum > 0 + out[nz] = numerator[nz] / wsum[nz] + return out + + +def vec_categorical_dist( + data_event_sim, all_de_ti, node_weights, has_nan=False +): + """Vectorized categorical distance over all TI scan candidates. + + Parameters + ---------- + data_event_sim : numpy.ndarray, shape (n,) + all_de_ti : numpy.ndarray, shape (max_scan, n) + node_weights : numpy.ndarray, shape (n,) + has_nan : bool, optional + Enable per-row NaN exclusion. Default ``False``. + + Returns + ------- + numpy.ndarray, shape (max_scan,) + Distance in [0, 1] for each candidate. + """ + if not has_nan: + return np.dot( + (data_event_sim != all_de_ti).astype(np.float64), node_weights + ) + _, we, wsum = _masked_weights(all_de_ti, node_weights) + # NaN positions compare unequal, but ``we`` is zero there so they do not + # contribute to the mismatch sum. + mism = (we * (data_event_sim != all_de_ti)).sum(axis=1) + return _renorm(mism, wsum) + + +def vec_l1_dist(data_event_sim, all_de_ti, node_weights, d_max, has_nan=False): + """Vectorized L1 distance over all TI scan candidates. + + Parameters + ---------- + data_event_sim : numpy.ndarray, shape (n,) + all_de_ti : numpy.ndarray, shape (max_scan, n) + node_weights : numpy.ndarray, shape (n,) + d_max : float + has_nan : bool, optional + + Returns + ------- + numpy.ndarray, shape (max_scan,) + """ + if not has_nan: + return np.dot(np.abs(data_event_sim - all_de_ti) / d_max, node_weights) + valid, we, wsum = _masked_weights(all_de_ti, node_weights) + ad = np.where(valid, np.abs(data_event_sim - all_de_ti) / d_max, 0.0) + return _renorm((we * ad).sum(axis=1), wsum) + + +def vec_l2_dist(data_event_sim, all_de_ti, node_weights, d_max, has_nan=False): + """Vectorized L2 distance over all TI scan candidates. + + Parameters + ---------- + data_event_sim : numpy.ndarray, shape (n,) + all_de_ti : numpy.ndarray, shape (max_scan, n) + node_weights : numpy.ndarray, shape (n,) + d_max : float + has_nan : bool, optional + + Returns + ------- + numpy.ndarray, shape (max_scan,) + """ + if not has_nan: + return np.sqrt( + np.dot(((data_event_sim - all_de_ti) / d_max) ** 2, node_weights) + ) + valid, we, wsum = _masked_weights(all_de_ti, node_weights) + sq = np.where(valid, ((data_event_sim - all_de_ti) / d_max) ** 2, 0.0) + return np.sqrt(_renorm((we * sq).sum(axis=1), wsum)) + + +def vec_lp_dist( + data_event_sim, all_de_ti, node_weights, d_max, p, has_nan=False +): + """Vectorized Lp distance over all TI scan candidates. + + Parameters + ---------- + data_event_sim : numpy.ndarray, shape (n,) + all_de_ti : numpy.ndarray, shape (max_scan, n) + node_weights : numpy.ndarray, shape (n,) + d_max : float + p : float + has_nan : bool, optional + + Returns + ------- + numpy.ndarray, shape (max_scan,) + """ + if not has_nan: + diffs = np.abs(data_event_sim - all_de_ti) / d_max + return np.dot(diffs**p, node_weights) ** (1.0 / p) + valid, we, wsum = _masked_weights(all_de_ti, node_weights) + dp = np.where( + valid, (np.abs(data_event_sim - all_de_ti) / d_max) ** p, 0.0 + ) + return _renorm((we * dp).sum(axis=1), wsum) ** (1.0 / p) + + +def vec_variation_dist( + data_event_sim, all_de_ti, node_weights, d_max, p=2.0, has_nan=False +): + """Vectorized variation distance over all TI scan candidates. + + Parameters + ---------- + data_event_sim : numpy.ndarray, shape (n,) + all_de_ti : numpy.ndarray, shape (max_scan, n) + node_weights : numpy.ndarray, shape (n,) + d_max : float + p : float, optional + Lp aggregation exponent. Default ``2.0``. + has_nan : bool, optional + + Returns + ------- + numpy.ndarray, shape (max_scan,) + Distance in [0, 1]. + """ + if not has_nan: + de_sim_c = data_event_sim - data_event_sim.mean() + all_de_ti_c = all_de_ti - all_de_ti.mean(axis=1, keepdims=True) + diffs = de_sim_c - all_de_ti_c + # 2*d_max normalises the common case to [0, 1]; SG values are not + # bounded by the TI range (conditioning / mean-shifts), so clamp. + return np.minimum( + 1.0, + np.dot(np.abs(diffs / (2 * d_max)) ** p, node_weights) + ** (1.0 / p), + ) + # De-mean each event over its *defined* positions only, so the comparison + # uses a common support per candidate row. + valid = ~np.isnan(all_de_ti) + cnt = valid.sum(axis=1, keepdims=True) + safe_cnt = np.where(cnt > 0, cnt, 1) + m_sim = ( + np.where(valid, data_event_sim[np.newaxis, :], 0.0).sum( + axis=1, keepdims=True + ) + / safe_cnt + ) + m_ti = ( + np.where(valid, all_de_ti, 0.0).sum(axis=1, keepdims=True) / safe_cnt + ) + diffs = (data_event_sim[np.newaxis, :] - m_sim) - (all_de_ti - m_ti) + contr = np.where(valid, np.abs(diffs / (2 * d_max)) ** p, 0.0) + we = node_weights[np.newaxis, :] * valid + agg = _renorm((we * contr).sum(axis=1), we.sum(axis=1)) ** (1.0 / p) + # Clamp only finite aggregates so a fully-undefined row keeps its +inf + # (never selected), matching the other metrics' exclusion contract. + return np.where(np.isfinite(agg), np.minimum(1.0, agg), np.inf) diff --git a/src/gstools/mps/model.py b/src/gstools/mps/model.py new file mode 100644 index 00000000..5bc3a0f5 --- /dev/null +++ b/src/gstools/mps/model.py @@ -0,0 +1,182 @@ +"""MPS configuration object — training image and search parameters.""" + +import warnings + +from gstools.mps.training_image import TrainingImage + +__all__ = ["MPSModel"] + +_VALID_BOUNDARY = ("strict", "partial") + + +def _validate_boundary(value): + """Validate boundary; return normalized value or raise ValueError.""" + if value not in _VALID_BOUNDARY: + raise ValueError( + f"MPSModel: boundary must be one of {_VALID_BOUNDARY!r}, " + f"got {value!r}" + ) + return value + + +def _validate_scan_fraction(value): + """Validate scan_fraction in (0, 1]; return float or raise ValueError.""" + if not (0 < float(value) <= 1): + raise ValueError( + f"MPSModel: scan_fraction must be in (0, 1], got {value!r}" + ) + return float(value) + + +def _validate_threshold(value): + """Validate threshold >= 0, warn if > 1; return float or raise ValueError.""" + if float(value) < 0: + raise ValueError(f"MPSModel: threshold must be >= 0, got {value!r}") + if float(value) > 1.0: + warnings.warn( + "threshold > 1.0 guarantees the first candidate is always accepted.", + UserWarning, + stacklevel=3, + ) + return float(value) + + +def _validate_max_radius(value): + """Validate max_radius is positive or None; return float/None or raise ValueError.""" + if value is not None and float(value) <= 0: + raise ValueError( + f"MPSModel: max_radius must be a positive float, got {value!r}" + ) + return float(value) if value is not None else None + + +def _validate_n_neighbors(value, ti): + """Validate and normalise *n_neighbors*; return ``int`` or ``dict of int``.""" + if isinstance(value, dict): + if not ti.multivariate: + raise ValueError( + "MPSModel: dict n_neighbors is only valid for " + "multivariate TrainingImages." + ) + missing = set(ti.variables) - set(value) + extra = set(value) - set(ti.variables) + if missing or extra: + raise ValueError( + f"MPSModel: n_neighbors dict keys must match TI " + f"variables {ti.variables!r}. Missing: {sorted(missing)}, " + f"extra: {sorted(extra)}." + ) + for k, v in value.items(): + if int(v) < 1: + raise ValueError( + f"MPSModel: n_neighbors[{k!r}] must be >= 1, got {v!r}" + ) + return {k: int(v) for k, v in value.items()} + else: + if int(value) < 1: + raise ValueError( + f"MPSModel: n_neighbors must be >= 1, got {value!r}" + ) + return int(value) + + +class MPSModel: + """MPS configuration: training image and search algorithm parameters. + + Analogous to ``CovModel``: holds the training image and the search + hyper-parameters. Carries no seed, thread count, or backend selector — + those are call-time concerns on :class:`~gstools.mps.DirectSampling`. + + Parameters + ---------- + ti : TrainingImage + Training image (univariate or multivariate). + n_neighbors : int or dict, optional + Maximum neighbours per node. A dict maps variable name to int for + multivariate TIs; an int broadcasts to all variables. Default: 32. + scan_fraction : float, optional + Fraction of the TI to scan per node (capped at the valid search + window). Must be in (0, 1]. Default: 1.0. + threshold : float, optional + Distance threshold for early acceptance. 0.0 → DSBC mode. Default: 0.0. + cond_weight : float, optional + Weight multiplier for conditioning nodes in distance. Default: 1.0. + boundary : str, optional + Search-window strategy: ``"strict"`` (default) or ``"partial"``. + max_radius : float or None, optional + Exclude SG neighbours beyond this Euclidean distance from the data + event. ``None`` → no limit (default). + """ + + def __init__( + self, + ti, + n_neighbors=32, + scan_fraction=1.0, + threshold=0.0, + cond_weight=1.0, + boundary="strict", + max_radius=None, + ): + if not isinstance(ti, TrainingImage): + raise TypeError( + f"MPSModel: ti must be a TrainingImage, got {type(ti)!r}" + ) + self._ti = ti + self._n_neighbors = _validate_n_neighbors(n_neighbors, ti) + self._scan_fraction = _validate_scan_fraction(scan_fraction) + self._threshold = _validate_threshold(threshold) + self._cond_weight = float(cond_weight) + self._boundary = _validate_boundary(boundary) + self._max_radius = _validate_max_radius(max_radius) + + @property + def ti(self): + """The training image.""" + return self._ti + + @property + def n_neighbors(self): + """Maximum number of neighbours in the data event.""" + return self._n_neighbors + + @property + def scan_fraction(self): + """Fraction of the TI scanned per node.""" + return self._scan_fraction + + @property + def threshold(self): + """Distance threshold for early acceptance.""" + return self._threshold + + @property + def cond_weight(self): + """Weight multiplier for conditioning nodes.""" + return self._cond_weight + + @property + def boundary(self): + """Search-window boundary strategy (``"strict"`` or ``"partial"``).""" + return self._boundary + + @property + def max_radius(self): + """Maximum neighbour radius, or ``None`` for no limit.""" + return self._max_radius + + def __repr__(self): + args = [repr(self._ti)] + defaults = dict( + n_neighbors=32, + scan_fraction=1.0, + threshold=0.0, + cond_weight=1.0, + boundary="strict", + max_radius=None, + ) + for name, default in defaults.items(): + val = getattr(self, f"_{name}") + if val != default: + args.append(f"{name}={val!r}") + return f"MPSModel({', '.join(args)})" diff --git a/src/gstools/mps/neighbors.py b/src/gstools/mps/neighbors.py new file mode 100644 index 00000000..30d2a55f --- /dev/null +++ b/src/gstools/mps/neighbors.py @@ -0,0 +1,331 @@ +"""Data-event geometry for Direct Sampling. + +Neighbour selection, geometric lag transform, and TI search-window bounds. +Pure NumPy + gstools.tools.geometric; no TrainingImage, no simulation state. +""" + +import warnings + +import numpy as np + +from gstools.tools.geometric import matrix_isometrize, set_angles, set_anis + + +def _precompute_offsets(shape, max_offset=None): + """Neighbour offsets from the origin, sorted by Euclidean distance. + + Among equidistant offsets the order is a **canonical lexicographic** + tie-break (by squared distance, then by each coordinate). This is + platform- and NumPy-version-independent — unlike the default ``argsort`` + (unstable quicksort), whose tie order is implementation-defined — so that + ``n_neighbors`` cutting mid-shell yields the same neighbour subset, and the + simulation is reproducible across machines. + + Parameters + ---------- + shape : tuple + Simulation grid shape. + max_offset : int, optional + Maximum offset in any dimension. + Default: ``max(shape)``. + + Returns + ------- + numpy.ndarray, shape (N, dim) + """ + dim = len(shape) + if max_offset is None: + max_offset = max(shape) + estimated_elements = (2 * max_offset + 1) ** dim + if estimated_elements > 5_000_000: + raise ValueError( + f"_precompute_offsets would allocate ~{estimated_elements * dim * 8 // 1_000_000} MB " + f"(max_offset={max_offset}, dim={dim}). Set max_radius to bound the " + "neighbourhood search radius." + ) + rng_vals = np.arange(-max_offset, max_offset + 1) + grid = np.array(np.meshgrid(*[rng_vals] * dim, indexing="ij")) + offsets = grid.reshape(dim, -1).T + offsets = offsets[np.any(offsets != 0, axis=1)] + dist_sq = np.sum(offsets**2, axis=1) + # lexsort: last key is primary. Primary = squared distance; ties broken by + # coordinate 0, then 1, ... for a deterministic, portable ordering. + keys = [offsets[:, d] for d in range(dim - 1, -1, -1)] + [dist_sq] + idx = np.lexsort(keys) + return offsets[idx] + + +def _select_neighbors( + x_i, + offset_arr, + sim_shape_arr, + sim_shape, + path_pos_map, + curr_idx, + informed, + max_radius, + n_neighbors, +): + """Closest valid neighbours of ``x_i``, with their path indices. + + A candidate is valid when it is in bounds, has path index ``< curr_idx`` + (already-simulated in path order) or ``-1`` (conditioning data), and — if + ``informed`` is given — is marked informed. ``offset_arr`` is + distance-sorted, so slicing the first ``n_neighbors`` survivors yields the + closest ones. + + Passing ``informed=None`` treats every in-bounds lower-index/conditioning + cell as available; this is correct when building the dependency DAG, where + all earlier-path nodes are informed by definition. + + Returns + ------- + coords : numpy.ndarray, shape (m, dim) + Neighbour coordinates, ``m <= n_neighbors``. + path_idx : numpy.ndarray, shape (m,) + Path index of each neighbour (``-1`` for conditioning data). + """ + # ``offset_arr`` is distance-sorted, so the closest ``n_neighbors`` valid + # candidates are the first ``n_neighbors`` survivors and we can stop the + # moment we have them. Iterating with an early break avoids masking the + # whole offset array for every node (O(N**2) on large grids without a + # ``max_radius`` cap). Tradeoff: when fewer than ``n_neighbors`` valid + # candidates exist (sparse early-path nodes), the scan still walks the full + # ``offset_arr`` in Python; this affects only the first few nodes and is + # bounded by the ``max_radius`` ball when one is set. + dim = offset_arr.shape[1] + r_sq = max_radius * max_radius if max_radius is not None else None + found_coords = [] + found_vidx = [] + for off in offset_arr: + # Distance-sorted: the first offset beyond the radius ends the scan. + if r_sq is not None and float(off @ off) > r_sq: + break + cand = x_i + off + if np.any(cand < 0) or np.any(cand >= sim_shape_arr): + continue + vi = path_pos_map[int(np.ravel_multi_index(tuple(cand), sim_shape))] + if not (vi < curr_idx or vi == -1): + continue + if informed is not None and not informed[tuple(cand)]: + continue + found_coords.append(cand) + found_vidx.append(vi) + if len(found_coords) >= n_neighbors: + break + if found_coords: + return ( + np.array(found_coords, dtype=offset_arr.dtype), + np.array(found_vidx, dtype=path_pos_map.dtype), + ) + return ( + np.empty((0, dim), dtype=offset_arr.dtype), + np.empty(0, dtype=path_pos_map.dtype), + ) + + +def _transform_lags(lags, M, *arrays): + """Apply geometric transform M and deduplicate collapsed lags. + + Parameters + ---------- + lags : numpy.ndarray, shape (k, dim) + Integer SG lag offsets (float64). + M : numpy.ndarray, shape (dim, dim) + Isometrization matrix from :func:`matrix_isometrize`. + *arrays : numpy.ndarray + Parallel arrays of length k to slice by the same keep_idx. + + Returns + ------- + lags_ti : numpy.ndarray, shape (k', dim) + Transformed lags (rounded to nearest integer, deduped). + *sliced : numpy.ndarray + Input arrays sliced to keep_idx. + """ + lags_ti = np.rint(lags @ M.T) + if len(lags_ti): + _, keep_idx = np.unique(lags_ti, axis=0, return_index=True) + keep_idx = np.sort(keep_idx) + if len(keep_idx) < len(lags_ti): + # Constant message (no per-call count) so the stdlib default + # "once per location" filter collapses the routine anisotropic case + # to a single warning per session instead of one per node. + warnings.warn( + "Anisotropy/rotation transform collapsed neighbour lag(s) onto " + "duplicate TI positions; the duplicates are excluded from the " + "data event. Reduce the anisotropy ratio or rotation to retain " + "them.", + RuntimeWarning, + stacklevel=2, + ) + lags_ti = lags_ti[keep_idx] + arrays = tuple(a[keep_idx] for a in arrays) + return (lags_ti,) + arrays + + +def _reduce_to_fit(lags_ti, ti_shape, *arrays): + """Globally reduce an over-large (transformed) data event to fit the TI. + + Implements Mariethoz2010 para [43]: *"rotation or affinity may result in + large data events that do not fit in the TI. In such cases, the data event + nodes located outside of the TI are ignored until it becomes possible to + scan the TI with this new, reduced data event."* + + The most-outside node — the one with the largest ``|lag|`` in the + most-violating dimension — is dropped first and the test repeated, until a + non-empty TI scan window exists for the reduced event. Nodes are dropped by + being *outside the TI* (geometry), **regardless of SG neighbour rank**, + which is the explicit distinction from :func:`_window_bounds` partial mode + (furthest-first). The reduction is **global** — computed once per simulation + node from the transformed lags and the TI shape alone, independent of which + TI cell is being scanned. The collocated ``h=0`` row is never dropped. + + A window over a lag set exists iff, including the anchor at the origin, the + per-dimension extent ``max(0, max h_d) - min(0, min h_d)`` is at most + ``ti_shape_d - 1`` (a single lag with ``|h_d| > ti_d - 1`` therefore does + not fit and is reduced away). + + Parameters + ---------- + lags_ti : numpy.ndarray, shape (k, dim) + Transformed (TI-frame) integer lag vectors. + ti_shape : array-like, shape (dim,) + Training image shape. + *arrays : numpy.ndarray + Parallel arrays of length ``k`` sliced identically to ``lags_ti``. + + Returns + ------- + tuple + ``(reduced_lags_ti, *reduced_arrays)``. + """ + ti1 = np.asarray(ti_shape) - 1 + idx = np.arange(len(lags_ti)) + while len(idx): + sub = lags_ti[idx] + nzmask = np.any(sub != 0, axis=1) + if not nzmask.any(): + break + nz = sub[nzmask] + # Include the anchor (origin) so a lone far lag is correctly infeasible. + extent = np.maximum(0, nz.max(axis=0)) - np.minimum(0, nz.min(axis=0)) + over = extent - ti1 + if np.all(over <= 0): + break + d = int(np.argmax(over)) # most-violating dimension + cand = np.flatnonzero(nzmask) + drop = cand[int(np.argmax(np.abs(sub[cand, d])))] + idx = np.delete(idx, drop) + return (lags_ti[idx],) + tuple(a[idx] for a in arrays) + + +def _window_bounds(lags_ti, ti_shape, boundary): + """Compute the TI search window for a set of lag vectors. + + h=0 rows (collocated constraints) do not constrain the window — they map + anchor ``y`` to ``y`` itself so every window position is valid for them. + + Parameters + ---------- + lags_ti : numpy.ndarray, shape (k, dim) + Lag vectors in TI frame (integer-valued float64). May include h=0 rows. + ti_shape : numpy.ndarray, shape (dim,) + TI shape as an integer array. + boundary : str + ``"strict"`` or ``"partial"``. + + Returns + ------- + win_lo : numpy.ndarray, shape (dim,), dtype int + win_hi : numpy.ndarray, shape (dim,), dtype int + valid_count : int + Number of lags to use (``lags_ti[:valid_count]``). ``-1`` signals that + no subset of the data event fits inside the TI; the caller should draw a + random TI value instead of scanning. + """ + ti_shape_arr = np.asarray(ti_shape, dtype=int) + dim = len(ti_shape_arr) + nz = np.flatnonzero(np.any(lags_ti != 0, axis=1)) + if not len(nz): + return np.zeros(dim, dtype=int), ti_shape_arr - 1, len(lags_ti) + + lags_nz = lags_ti[nz] + if boundary == "strict": + win_lo = np.maximum(0, np.ceil(-lags_nz.min(axis=0))).astype(int) + win_hi = np.minimum( + ti_shape_arr - 1, + np.floor(ti_shape_arr - 1 - lags_nz.max(axis=0)), + ).astype(int) + if np.all(win_lo <= win_hi): + return win_lo, win_hi, len(lags_ti) + # Strict window infeasible (TI too small for the full data event). + # Fall through to partial truncation, but do not do so silently. + warnings.warn( + "boundary='strict' could not fit the full data event inside the " + "TI; falling back to partial mode (dropping the furthest " + "neighbour(s)). Ensure the TI is at least as large as the data " + "event extent to enforce strict mode.", + RuntimeWarning, + stacklevel=2, + ) + + keep = len(lags_ti) + while keep > 0: + lv_k = lags_ti[:keep] + nzk = lv_k[np.any(lv_k != 0, axis=1)] + if not len(nzk): + return np.zeros(dim, dtype=int), ti_shape_arr - 1, keep + sw_lo = np.maximum(0, np.ceil(-nzk.min(axis=0))).astype(int) + sw_hi = np.minimum( + ti_shape_arr - 1, + np.floor(ti_shape_arr - 1 - nzk.max(axis=0)), + ).astype(int) + if np.all(sw_lo <= sw_hi): + return sw_lo, sw_hi, keep + keep -= 1 + return None, None, -1 + + +def _lag_transform_matrix(dim, rotation_map, anis_map, x_i): + """Isometrization matrix M for a node's per-node rotation/anisotropy. + + Mirrors the inline build in the engine: a 1-D map is a stationary value + broadcast to all nodes; a full-shape map is indexed at ``x_i``. + + Parameters + ---------- + dim : int + Spatial dimensionality of the simulation grid. + rotation_map : numpy.ndarray or None + Rotation angle(s). ``None`` → no rotation (identity contribution). + A 1-D array is a stationary multi-component angle vector applied to + every node; a full-shape array is indexed at ``x_i`` for per-node + angles. + anis_map : numpy.ndarray or None + Anisotropy ratio(s). ``None`` → isotropic (ratio 1.0 in all + transversal directions). Same broadcast rules as ``rotation_map``. + x_i : numpy.ndarray, shape (dim,) + Integer grid coordinates of the current simulation node. Used to + index into per-node maps; ignored when the maps are stationary (1-D). + + Returns + ------- + M : numpy.ndarray, shape (dim, dim) + Isometrization matrix from :func:`gstools.tools.geometric.matrix_isometrize`. + Apply as ``lags_ti = lags_sg @ M.T`` to transform SG lag vectors into + the TI frame. + """ + angles_i = set_angles( + dim, + (rotation_map if rotation_map.ndim == 1 else rotation_map[tuple(x_i)]) + if rotation_map is not None + else 0.0, + ) + anis_i = set_anis( + dim, + (anis_map if anis_map.ndim == 1 else anis_map[tuple(x_i)]) + if anis_map is not None + else 1.0, + ) + return matrix_isometrize(dim, angles_i, anis_i) diff --git a/src/gstools/mps/runner.py b/src/gstools/mps/runner.py new file mode 100644 index 00000000..e92fbdbd --- /dev/null +++ b/src/gstools/mps/runner.py @@ -0,0 +1,218 @@ +"""Execution layer for Direct Sampling. + +Drives the node-simulation path either serially or in parallel over a +dependency DAG (deterministic regardless of thread count), plus the optional +progress display. Pure stdlib + NumPy; no TrainingImage, no engine import. +""" + +import queue + +import numpy as np + +from gstools.mps.neighbors import _select_neighbors + + +def _build_dag_base( + path, sim_shape, offset_arr, vmap_dict, n_k_dict, max_radius=None +): + """Unified dependency-DAG builder for both univariate and multivariate DS. + + Parameters + ---------- + vmap_dict : dict of {key: numpy.ndarray} + One position map per key. For univariate DS pass ``{"": path_pos_map}``. + n_k_dict : dict of {key: int} + Maximum neighbours per key, matching ``vmap_dict``. + + Returns + ------- + indegree : dict of {key: numpy.ndarray of int32, shape (N,)} + out_edges : list of list of (int, key) + ``out_edges[j]`` → ``(i, key)`` pairs to process when node ``j`` completes. + + Notes + ----- + Dependencies must be computed via the same :func:`neighbors._select_neighbors` + call the engine uses per node, so the DAG edges exactly match the actual + simulation neighbour relation — this is the invariant that makes parallel + execution produce bit-identical output to the serial path. + """ + N = len(path) + sim_shape_arr = np.array(sim_shape) + + indegree = {k: np.zeros(N, dtype=np.int32) for k in vmap_dict} + out_edges = [[] for _ in range(N)] + for i in range(N): + x_i = path[i] + for key, vmap in vmap_dict.items(): + _, vidx = _select_neighbors( + x_i, + offset_arr, + sim_shape_arr, + sim_shape, + vmap, + i, + None, + max_radius, + n_k_dict[key], + ) + for j in vidx[vidx >= 0]: + indegree[key][i] += 1 + out_edges[int(j)].append((i, key)) + return indegree, out_edges + + +def _make_progress(progress, total, desc): + """Build ``(update, close)`` callbacks for an optional progress display. + + Parameters + ---------- + progress : bool or callable or None + ``None``/``False`` disables it. ``True`` shows a :mod:`tqdm` bar when + ``tqdm`` is importable, otherwise prints the percentage at 5 % steps on + a single overwritten line. A callable is invoked as + ``progress(n_done, total)`` once per completed simulation node. + total : int + Number of nodes that will be simulated (``len(path)``). + desc : str + Short label for the bar (e.g. ``"DS"``). + + Returns + ------- + update : callable + Call (no arguments) once per completed node. + close : callable + Call once when the simulation finishes. + """ + if not progress or total <= 0: + return (lambda: None), (lambda: None) + if callable(progress): + state = {"done": 0} + + def update(): + state["done"] += 1 + progress(state["done"], total) + + return update, (lambda: None) + try: + from tqdm import tqdm + except ImportError: + tqdm = None + if tqdm is not None: + bar = tqdm(total=total, desc=desc, unit="node") + return (lambda: bar.update(1)), bar.close + # Dependency-free fallback: overwrite a single line at 5 % steps. + state = {"done": 0, "last": -1} + + def update(): + state["done"] += 1 + pct = 5 * (state["done"] * 20 // total) + if pct != state["last"]: + state["last"] = pct + print( + f"\r{desc}: {pct:3d}% ({state['done']}/{total})", + end="", + flush=True, + ) + + def close(): + print() + + return update, close + + +def _run_path( + path, + u_start, + u_fallback, + simulate_fn, + write_fn, + update_fn, + executor, + offset_arr, + vmap, + n_k, + sim_shape, + max_radius, +): + """Dispatch the node simulation path: serial or parallel DAG. + + Parameters + ---------- + path : numpy.ndarray, shape (N, dim) + Ordered sequence of grid coordinates to simulate. + u_start : numpy.ndarray, shape (N,) + Per-node uniform random values controlling TI scan entry points. + u_fallback : numpy.ndarray, shape (N, dim) + Per-node uniform random values for fallback cell draws. + simulate_fn : callable + ``simulate_fn(i, x_i, u_start_i, u_fallback_i)`` → result dict + mapping variable names to simulated values for node ``i``. + write_fn : callable + ``write_fn(node_tuple, result)`` → None. Writes the result dict + into the simulation grid and marks the node informed. + update_fn : callable + ``update_fn()`` → None. Called once per completed node (progress). + executor : concurrent.futures.ThreadPoolExecutor or None + If not ``None``, nodes are dispatched in parallel over the DAG built + by :func:`_build_dag_base`. ``None`` → strictly serial execution. + offset_arr : numpy.ndarray, shape (M, dim) + Distance-sorted neighbour offsets from :func:`neighbors._precompute_offsets`. + vmap : dict of {str: numpy.ndarray} + Per-variable position maps (path index or ``-1`` for conditioning). + n_k : dict of {str: int} + Maximum neighbour count per variable. + sim_shape : tuple + Simulation grid shape. + max_radius : float or None + Euclidean cap on neighbour selection; ``None`` → unlimited. + + Notes + ----- + Extracted so a future syn-processing path strategy (which re-opens + simulated nodes) can replace this function without touching the scan + kernel. Note: syn-processing is incompatible with DAG parallelism; + replace the whole _run_path, not just the serial branch. + """ + variables = list(vmap) + + if executor is not None: + indegree, out_edges = _build_dag_base( + path, sim_shape, offset_arr, vmap, n_k, max_radius + ) + remaining = {v: indegree[v].copy() for v in variables} + submitted = np.zeros(len(path), dtype=bool) + done_q = queue.Queue() + counts = {"submitted": 0, "done": 0} + + def _ready(i): + return all(remaining[v][i] == 0 for v in variables) + + def _run(i): + return i, simulate_fn(i, path[i], u_start[i], u_fallback[i]) + + def _submit(i): + if submitted[i]: + return + submitted[i] = True + executor.submit(_run, i).add_done_callback(done_q.put) + counts["submitted"] += 1 + + for i in range(len(path)): + if _ready(i): + _submit(i) + + while counts["done"] < counts["submitted"]: + i, result = done_q.get().result() + counts["done"] += 1 + write_fn(tuple(int(c) for c in path[i]), result) + update_fn() + for j, v in out_edges[i]: + remaining[v][j] -= 1 + if _ready(j): + _submit(j) + else: + for i in range(len(path)): + result = simulate_fn(i, path[i], u_start[i], u_fallback[i]) + write_fn(tuple(int(c) for c in path[i]), result) + update_fn() diff --git a/src/gstools/mps/scan.py b/src/gstools/mps/scan.py new file mode 100644 index 00000000..e3827ba9 --- /dev/null +++ b/src/gstools/mps/scan.py @@ -0,0 +1,164 @@ +"""TI search-window scanning for Direct Sampling. + +Scans a candidate window for the best weighted-distance match (greedy +early-exit in DS mode, running-best argmin in DSBC mode). Depends only on +distance.py; receives TI arrays and the vectorized distance callable as +parameters (does not own a TrainingImage). +""" + +import numpy as np + +from gstools.mps.distance import compute_node_weights + +# DS-mode scan block size. Large enough that per-call NumPy overhead is +# negligible (essentially full vectorization speed), small enough that the +# greedy DS scan does not overcompute far past the first accepted match. +# This is a call-overhead-amortization constant, not a cache-tuned one. +_SCAN_BLOCK = 4096 + + +def _scan_window(lo, win_shape, start, max_scan, threshold, dist_fn): + """Chunked vectorized TI window scan (pure-Python path). + + Parameters + ---------- + lo : numpy.ndarray + Lower-left anchor of the search window in TI coordinates. + win_shape : tuple of int + Shape of the search window. + start : int + Starting position (flat index into window) for the random scan order. + max_scan : int + Maximum number of candidates to evaluate. + threshold : float + Distance threshold for early exit (DS mode). ``<= 0`` → DSBC (no early exit). + dist_fn : callable + ``dist_fn(y_blk)`` → 1-D distance array for a block of candidate + anchor coordinates ``y_blk`` of shape ``(b, dim)``. + + Returns + ------- + y : numpy.ndarray, shape (dim,) or None + Coordinate of the best matching TI anchor, or ``None`` when no candidate + in the window has a finite distance (every candidate excluded — e.g. an + all-undefined window on a masked TI). The caller treats ``None`` as the + empty-neighbourhood case and draws a defined TI cell. + """ + win_size = int(np.prod(win_shape)) + positions = (start + np.arange(max_scan)) % win_size + y_all = lo + np.column_stack(np.unravel_index(positions, win_shape)) + + # DSBC (threshold <= 0) has no threshold-based early exit, but an exact + # match d == 0 is the best attainable candidate, so accept it immediately + # (retained for categorical, where d == 0 is common — Juda2022 §2). Both + # modes therefore scan in blocks of ``_SCAN_BLOCK`` and track the running + # best, so a full-window DSBC scan never materialises one giant distance + # array. Block argmin + strict ``<`` keep the first-in-scan-order winner, + # matching a single ``argmin`` over the whole window. + accept = threshold if threshold > 0 else 0.0 + + # DS mode (threshold > 0): strict acceptance d < t (Mariethoz2010 ¶23). + # DSBC mode (threshold <= 0, accept == 0): accept the exact match d == 0, + # i.e. d <= 0, since distances are non-negative (Juda2022 §2). + dsbc = threshold <= 0 + best_d, best_y = np.inf, None + for b0 in range(0, max_scan, _SCAN_BLOCK): + y_blk = y_all[b0 : b0 + _SCAN_BLOCK] + d_blk = dist_fn(y_blk) + under = d_blk <= accept if dsbc else d_blk < accept + if np.any(under): + return y_blk[int(np.argmax(under))] + k = int(np.argmin(d_blk)) + if d_blk[k] < best_d: + best_d = float(d_blk[k]) + best_y = y_blk[k] + # ``best_y is None`` means every candidate had a non-finite (excluded) + # distance — only reachable on a masked TI where the whole window is + # undefined. Signal the caller to fall back to a defined TI draw (M10 + # para [15] empty-neighbourhood handling). For a fully-defined TI the loop + # always sets best_y, so this returns a real anchor unchanged. + return best_y + + +def _scan_for_match( + lo, + win_shape, + int_lags, + de_v, + cm_v, + ln_v, + u_start_i, + scan_targets, + *, + variables, + weights, + ti_vars, + ti_shape, + scan_fraction, + threshold, + cond_weight, + distance_power, + vec_distance_var, + ti_has_nan, +): + """Joint multivariate DS scan over a TI search window. + + Scans candidates in randomized order (greedy DS early-exit when the first + candidate with distance ``< threshold`` is found; DSBC running-best argmin + when ``threshold <= 0``). The window is the per-variable intersection so + every ``y + lag`` is in bounds and the gather needs no clipping; the h=0 + lag maps to ``y`` itself. Returns the single best TI anchor coordinate + ``y``, or ``None`` when every candidate in the window is undefined (masked + TI — caller falls back to a random defined cell). + """ + win_size = int(np.prod(win_shape)) + ti_size = int(np.prod(ti_shape)) + # Scan fraction is of the TI (Mariethoz2010 ¶24, Juda2022 §2), capped at + # the valid search window so we never wrap around and re-scan anchors. + max_scan = max(1, min(win_size, int(scan_fraction * ti_size))) + start = int(u_start_i * win_size) + + active_vars = [v for v in variables if v in int_lags] + active_w_total = sum(weights[v] for v in active_vars) + precomp_w = { + v: compute_node_weights( + len(de_v[v]), ln_v[v], distance_power, cm_v[v], cond_weight + ) + for v in active_vars + } + + def _dist_block(y_blk): + d = np.zeros(len(y_blk)) + for v in active_vars: + il = int_lags[v] + coords = y_blk[:, None, :] + il[None, :, :] + all_de_ti = ti_vars[v][tuple(coords.transpose(2, 0, 1))] + d += weights[v] * vec_distance_var( + v, + de_v[v], + all_de_ti, + cm_v[v], + cond_weight, + ln_v[v], + weights=precomp_w[v], + has_nan=ti_has_nan, + ) + # Renormalize so the joint distance stays in [0, 1] even when + # some variables have no data event and are excluded from int_lags. + # Without this, the threshold fires on a compressed scale and + # accepts matches that should be rejected. + if 0.0 < active_w_total < 1.0: + d /= active_w_total + if ti_has_nan: + # Never select an anchor whose pasted value would be undefined: + # the matched cell must be defined in every target variable. + center_ok = np.ones(len(y_blk), dtype=bool) + ys = tuple(y_blk.T) + for v in scan_targets: + cv = ti_vars[v][ys] + if np.issubdtype(cv.dtype, np.floating): + center_ok &= np.isfinite(cv) + d = np.where(center_ok, d, np.inf) + return d + + return _scan_window(lo, win_shape, start, max_scan, threshold, _dist_block) diff --git a/src/gstools/mps/simulate.py b/src/gstools/mps/simulate.py new file mode 100644 index 00000000..16fdcefc --- /dev/null +++ b/src/gstools/mps/simulate.py @@ -0,0 +1,461 @@ +"""Direct Sampling simulation engine. + +`ds_simulate` is the entry point; `_DirectSamplingEngine` holds one run's +state (output grids, informed masks, config) explicitly — what used to be +captured by closures inside `ds_simulate`. The engine orchestrates per-node +simulation by calling the stateless `neighbors`, `scan`, and `runner` modules. +""" + +import warnings +from concurrent.futures import ThreadPoolExecutor + +import numpy as np + +from gstools import config +from gstools.mps.neighbors import ( + _lag_transform_matrix, + _precompute_offsets, + _reduce_to_fit, + _select_neighbors, + _transform_lags, + _window_bounds, +) +from gstools.mps.runner import _make_progress, _run_path +from gstools.mps.scan import _scan_for_match +from gstools.mps.training_image import TrainingImage + +# Sentinel variable name used when wrapping a univariate TI for the MV engine. +_MV_VAR = "_v" + + +def _univar_as_mv_ti(ti): + """Wrap a univariate TrainingImage as a single-variable multivariate TI. + + The resulting TI is bit-identical to a hand-crafted single-variable MV TI + using the same data and distance parameters. Used by ``ds_simulate`` and + ``DirectSampling.__call__`` to route univariate work through ``ds_simulate``. + + Re-wraps the *same* data the user already constructed, so any NaN/masked-TI + warning was already raised at the user's construction; suppress the + duplicate here. + """ + with warnings.catch_warnings(): + warnings.simplefilter("ignore", UserWarning) + return TrainingImage( + {_MV_VAR: ti.data}, + categorical={_MV_VAR: ti.categorical}, + distance={_MV_VAR: ti.distance_type}, + distance_power=ti.distance_power, + ) + + +class _DirectSamplingEngine: + """Holds one Direct Sampling run's state and orchestrates it.""" + + def __init__( + self, + training_image, + sim_shape, + n_neighbors, + threshold, + scan_fraction, + rng_path, + rng_nodes, + conditions=None, + cond_weight=1.0, + boundary="strict", + max_radius=None, + rotation_map=None, + anis_map=None, + ): + self.training_image = training_image + self.variables = training_image.variables + self.weights = ( + training_image.weights + ) # hoisted once (avoid per-block dict copy) + self.ti_shape = np.array(training_image.shape) + self.sim_shape = sim_shape + self.sim_shape_arr = np.array(sim_shape) + self.dim = len(sim_shape) + self.threshold = threshold + self.scan_fraction = scan_fraction + self.cond_weight = cond_weight + self.boundary = boundary + self.max_radius = max_radius + self.rotation_map = rotation_map + self.anis_map = anis_map + + self.n_k = ( + {v: int(n_neighbors[v]) for v in self.variables} + if isinstance(n_neighbors, dict) + else {v: int(n_neighbors) for v in self.variables} + ) + + self.sg = {v: np.full(sim_shape, np.nan) for v in self.variables} + self.informed = { + v: np.zeros(sim_shape, dtype=bool) for v in self.variables + } + self.is_cond = { + v: np.zeros(sim_shape, dtype=bool) for v in self.variables + } + if conditions: + for idx, vd in conditions.items(): + for v, val in vd.items(): + self.sg[v][idx] = val + self.is_cond[v][idx] = True + self.informed[v][idx] = True + + max_off_int = ( + int(np.ceil(max_radius)) if max_radius is not None else None + ) + self.offset_arr = _precompute_offsets(sim_shape, max_off_int) + + # Node path: every node with >= 1 uninformed variable. Fully-conditioned + # nodes need no simulation and are excluded (they stay -1 / always available). + unknown = np.zeros(sim_shape, dtype=bool) + for v in self.variables: + unknown |= np.isnan(self.sg[v]) + path = np.argwhere(unknown) + path = path[rng_path.permutation(len(path))] + self.path = path + n_nodes = len(path) + self.u_start = rng_nodes.uniform(size=n_nodes) + self.u_fallback = rng_nodes.uniform(size=(n_nodes, self.dim)) + + sg_size = int(np.prod(sim_shape)) + path_flat = ( + np.ravel_multi_index(path.T, sim_shape) + if len(path) + else np.empty(0, dtype=np.intp) + ) + # Per-variable position maps over the node path. A path node carries its + # node-path index; a cell conditioned in variable v is set to -1 in vmap[v] + # (always available for v, like univariate conditioning) — essential for a + # partially-conditioned node, whose known value must not be gated by path + # order. Cells absent from the path are already -1. + self.vmap = {} + for v in self.variables: + m = np.full(sg_size, -1, dtype=np.intp) + m[path_flat] = np.arange(len(path_flat)) + m[np.flatnonzero(self.is_cond[v].reshape(-1))] = -1 + self.vmap[v] = m + + # Hoist TI variable arrays once — avoids repeated method-call overhead + # inside the per-node scan loop; all inner closures read from this dict. + self.ti_vars = {v: training_image.variable(v) for v in self.variables} + + # Masked-TI support: NaN cells are undefined. When present, distances + # exclude them per-position and fallback draws are restricted to cells that + # are defined in *every* variable (so a joint draw never yields NaN). The + # ``ti_has_nan`` gate keeps the fully-defined path byte-identical. + self.ti_has_nan = any( + np.issubdtype(a.dtype, np.floating) and np.isnan(a).any() + for a in self.ti_vars.values() + ) + if self.ti_has_nan: + finite_all = np.ones(self.ti_shape, dtype=bool) + for a in self.ti_vars.values(): + if np.issubdtype(a.dtype, np.floating): + finite_all &= ~np.isnan(a) + self.finite_flat = np.flatnonzero(finite_all.reshape(-1)) + if self.finite_flat.size == 0: + raise ValueError( + "TrainingImage has no cell defined in all variables (every " + "cell is NaN in at least one variable); cannot simulate." + ) + else: + self.finite_flat = None + + def _rand_fallback(self, targets, u_fb_i): + # Single random TI cell supplies the whole node-vector (preserves the + # joint relationship); never an independent draw per variable. On a + # masked TI the draw is restricted to cells defined in every variable. + if self.ti_has_nan: + flat = self.finite_flat[int(u_fb_i[0] * len(self.finite_flat))] + cell = tuple( + int(c) for c in np.unravel_index(flat, tuple(self.ti_shape)) + ) + else: + cell = tuple( + int(u_fb_i[d] * s) for d, s in enumerate(self.ti_shape) + ) + return {v: float(self.ti_vars[v][cell]) for v in targets} + + def _simulate_node(self, curr_idx, x_i, u_start_i, u_fallback_i): + x_i_t = tuple(int(c) for c in x_i) + targets = [v for v in self.variables if np.isnan(self.sg[v][x_i_t])] + + lags_v, de_v, cm_v, ln_v = {}, {}, {}, {} + for var in self.variables: + coords, _ = _select_neighbors( + x_i, + self.offset_arr, + self.sim_shape_arr, + self.sim_shape, + self.vmap[var], + curr_idx, + self.informed[var], + self.max_radius, + self.n_k[var], + ) + if len(coords): + lv = (coords - x_i).astype(np.float64) + dv = self.sg[var][tuple(coords.T)] + cv = self.is_cond[var][tuple(coords.T)] + lnv = np.linalg.norm(lv, axis=1) + else: + lv = np.empty((0, self.dim), dtype=np.float64) + dv = np.empty(0) + cv = np.empty(0, dtype=bool) + lnv = np.empty(0) + # collocated h=0 — a variable known at this very node (only possible + # via conditioning, as the node's unknown variables are what we fill). + # Never added for a target variable (uninformed here by definition). + if self.informed[var][x_i_t]: + lv = np.concatenate([np.zeros((1, self.dim)), lv], axis=0) + dv = np.concatenate([[self.sg[var][x_i_t]], dv]) + cv = np.concatenate([[self.is_cond[var][x_i_t]], cv]) + lnv = np.concatenate([[0.0], lnv]) + lags_v[var], de_v[var], cm_v[var], ln_v[var] = lv, dv, cv, lnv + + # Geometric transform: map all per-variable SG lags into TI frame. + # de_v / cm_v / ln_v stay on original SG geometry for SG-side ops. + # dict(lags_v) creates a shallow-copy dict so partial-mode truncation + # of lags_ti_v does not alias back into lags_v. + if self.rotation_map is not None or self.anis_map is not None: + M = _lag_transform_matrix( + self.dim, self.rotation_map, self.anis_map, x_i + ) + lags_ti_v = {} + for v in self.variables: + lv_ti, lags_v[v], de_v[v], cm_v[v], ln_v[v] = _transform_lags( + lags_v[v], M, lags_v[v], de_v[v], cm_v[v], ln_v[v] + ) + # M10 para [43]: globally reduce an over-large transformed event + # to fit the TI, dropping the most-outside node first (by TI + # extent, regardless of SG rank). One reduction per simulation + # node, independent of the TI scan position. + lv_ti, lags_v[v], de_v[v], cm_v[v], ln_v[v] = _reduce_to_fit( + lv_ti, self.ti_shape, lags_v[v], de_v[v], cm_v[v], ln_v[v] + ) + lags_ti_v[v] = lv_ti + else: + lags_ti_v = dict(lags_v) + + if all(len(lags_v[v]) == 0 for v in self.variables): + return self._rand_fallback(targets, u_fallback_i) + + # Per-variable search window computed via _window_bounds, then intersected. + # h=0 lags are excluded inside _window_bounds — they map to y itself and + # never constrain the window. + win_lo = np.zeros(self.dim, dtype=int) + win_hi = self.ti_shape - 1 + for var in self.variables: + lv_ti = lags_ti_v[var] + lo, hi, valid_count = _window_bounds( + lv_ti, self.ti_shape, self.boundary + ) + if valid_count == -1: + return self._rand_fallback(targets, u_fallback_i) + if valid_count < len(lv_ti): + # Truncate TI-frame and original arrays to the same keep count. + # lags_ti_v uses a separate dict so this does not affect lags_v. + lags_ti_v[var] = lv_ti[:valid_count] + lags_v[var] = lags_v[var][:valid_count] + de_v[var] = de_v[var][:valid_count] + cm_v[var] = cm_v[var][:valid_count] + ln_v[var] = ln_v[var][:valid_count] + win_lo = np.maximum(win_lo, lo) + win_hi = np.minimum(win_hi, hi) + + if np.any(win_lo > win_hi): + return self._rand_fallback(targets, u_fallback_i) + + # Integer lags per variable (already exact integers as float64, incl. + # the 0.0 h=0 row); reused for the scan and the mean-shift gather. + int_lags = { + v: lags_ti_v[v].astype(int) + for v in self.variables + if len(lags_ti_v[v]) + } + y = _scan_for_match( + win_lo, + tuple(win_hi - win_lo + 1), + int_lags, + de_v, + cm_v, + ln_v, + u_start_i, + targets, + variables=self.variables, + weights=self.weights, + ti_vars=self.ti_vars, + ti_shape=self.ti_shape, + scan_fraction=self.scan_fraction, + threshold=self.threshold, + cond_weight=self.cond_weight, + distance_power=self.training_image.distance_power, + vec_distance_var=self.training_image.vec_distance_var, + ti_has_nan=self.ti_has_nan, + ) + if y is None: + # No candidate in the window was defined (masked TI): treat as the + # empty-neighbourhood case and draw a defined TI cell. Avoids the + # ``y + lag`` gather below, which an unconstrained cell could send + # out of bounds. + return self._rand_fallback(targets, u_fallback_i) + y_t = tuple(int(c) for c in y) + # Copy the single matched cell's vector to every uninformed variable. + result = {} + for v in targets: + ti_val = float(self.ti_vars[v][y_t]) + il = int_lags.get(v) + de_ti_v = ( + self.ti_vars[v][tuple((y + il).T)] + if il is not None + else np.empty(0) + ) + result[v] = self.training_image.adjust_value( + ti_val, de_v[v], de_ti_v, var=v + ) + return result + + def _write_result(self, node, result): + for v, val in result.items(): + if np.isnan(val): + raise ValueError( + f"Simulation produced NaN for {(v, node)}. Check TI data." + ) + self.sg[v][node] = val + self.informed[v][node] = True + + def run(self, num_threads=None, progress=None): + n_threads = ( + num_threads + if num_threads is not None + else (config.NUM_THREADS or 1) + ) + executor = ( + ThreadPoolExecutor(max_workers=n_threads) + if n_threads > 1 + else None + ) + update_progress, close_progress = _make_progress( + progress, len(self.path), "DS" + ) + + try: + _run_path( + self.path, + self.u_start, + self.u_fallback, + lambda i, x_i, u_st, u_fb: self._simulate_node( + i, x_i, u_st, u_fb + ), + self._write_result, + update_progress, + executor, + self.offset_arr, + self.vmap, + self.n_k, + self.sim_shape, + self.max_radius, + ) + finally: + close_progress() + if executor is not None: + executor.shutdown(wait=True) + + return self.sg + + +def ds_simulate( + training_image, + sim_shape, + n_neighbors, + threshold, + scan_fraction, + rng_path, + rng_nodes, + conditions=None, + cond_weight=1.0, + boundary="strict", + max_radius=None, + num_threads=None, + rotation_map=None, + anis_map=None, + progress=None, +): + """Node-wise multivariate Direct Sampling (Mariethoz2010 §3, Eq. 8). + + Co-simulates every variable of a dict-valued :class:`TrainingImage` on one + structured grid, treating all variables equally. The path visits every + *node* with at least one unknown variable; at each node a single joint scan + finds the TI cell ``y`` minimising the weighted distance ``Σ_k w_k d_k`` over + all variables, and that one cell's whole vector ``{TI[v][y]}`` is copied to + the node's *uninformed* variables. Because every variable at a node is drawn + from the same TI cell, the joint (cross-variable) relationship is reproduced + exactly. Variables already known at the node (only ever via conditioning + data) act as collocated ``h = 0`` constraints, weighted by ``cond_weight``. + + Parameters + ---------- + training_image : TrainingImage + Multivariate training image (``training_image.multivariate`` is True). + sim_shape : tuple + Simulation grid shape. + n_neighbors : int or dict + Maximum neighbours per variable. An ``int`` broadcasts to all variables; + a dict gives one value per variable name. + threshold : float + Distance threshold (Juda2022 §2). ``0.0`` -> DSBC mode. + scan_fraction : float + Fraction of the TI to scan per node, capped at the valid search window. + rng_path : numpy.random.RandomState + RandomState controlling the simulation path (node visit order). + rng_nodes : numpy.random.RandomState + RandomState controlling TI scan entry points and fallback cells. + conditions : dict, optional + ``{node_index: {variable: value}}`` conditioning data. + cond_weight : float, optional + Weight delta for conditioning nodes (Mariethoz2010 §3 ¶26). + boundary : str, optional + ``"strict"`` (default) or ``"partial"`` search-window strategy. + max_radius : float, optional + Euclidean cap on neighbour selection. + num_threads : int or None, optional + Threads for the node-wise DAG. ``None`` -> ``config.NUM_THREADS``. + rotation_map : numpy.ndarray or None, optional + Per-node rotation angles, shape matching the simulation grid. ``None`` + → no rotation (stationary). Use ``DirectSampling.set_nonstationary`` + to produce this array from user-facing scalar or array inputs. + anis_map : numpy.ndarray or None, optional + Per-node anisotropy ratios, shape matching the simulation grid. + ``None`` → isotropic (stationary). All values must be positive. + progress : bool or callable or None, optional + Show simulation progress. ``True`` displays a :mod:`tqdm` bar (or a + plain percentage line if ``tqdm`` is not installed); a callable is + invoked as ``progress(n_done, n_total)`` once per completed node. + ``None``/``False`` (default) disables it. + + Returns + ------- + dict + ``{variable: numpy.ndarray}`` — one simulated field per variable. + """ + engine = _DirectSamplingEngine( + training_image, + sim_shape, + n_neighbors, + threshold, + scan_fraction, + rng_path, + rng_nodes, + conditions=conditions, + cond_weight=cond_weight, + boundary=boundary, + max_radius=max_radius, + rotation_map=rotation_map, + anis_map=anis_map, + ) + return engine.run(num_threads=num_threads, progress=progress) diff --git a/src/gstools/mps/training_image.py b/src/gstools/mps/training_image.py new file mode 100755 index 00000000..2c14c7d7 --- /dev/null +++ b/src/gstools/mps/training_image.py @@ -0,0 +1,458 @@ +""" +GStools subpackage providing the TrainingImage class for MPS simulations. + +.. currentmodule:: gstools.mps + +The following classes and functions are provided + +.. autosummary:: + TrainingImage +""" + +import warnings + +import numpy as np + +from gstools.mps.distance import ( + compute_node_weights, + vec_categorical_dist, + vec_l1_dist, + vec_l2_dist, + vec_lp_dist, + vec_variation_dist, +) + +__all__ = ["TrainingImage"] + + +def _warn_if_nan(*arrays): + """Warn once if any (float) TI array contains undefined (NaN) cells.""" + for arr in arrays: + if np.issubdtype(arr.dtype, np.floating) and np.isnan(arr).any(): + warnings.warn( + "TrainingImage contains NaN cell(s); they are treated as " + "undefined (masked): excluded from the continuous data range " + "and from pattern distances, and never pasted into the " + "simulation.", + UserWarning, + stacklevel=3, + ) + return + + +def _data_range(arr): + """Continuous data range over *defined* cells (NaN excluded). + + Returns the ``max - min`` spread of the finite values, or ``1.0`` when the + array is constant or entirely undefined (avoids a zero/NaN normalizer). + """ + finite = arr[np.isfinite(arr)] + dmax = float(finite.max() - finite.min()) if finite.size else 0.0 + return dmax if dmax > 0 else 1.0 + + +class TrainingImage: + """Training image for multiple point statistics simulation. + + The MPS analogue of :class:`gstools.CovModel`: encapsulates training + data and the distance function for comparing data events. + + Parameters + ---------- + data : numpy.ndarray or dict of {str: numpy.ndarray} + Training image data (n-d array). Pass a dict of named arrays to create + a multivariate (co-simulation) training image; all arrays must share + the same shape. + categorical : bool or dict of {str: bool}, optional + Whether the variable is categorical. For multivariate TIs, a dict gives + one flag per variable (a scalar is broadcast to all). Default: ``True``. + weights : dict of {str: float}, optional + Per-variable distance weights for multivariate TIs (must sum to 1). + Default: uniform. Ignored for univariate TIs. + distance : str or dict of {str: str}, optional + Distance metric for continuous variables: ``"l1"`` (Juda2022 + Eq. 7, default), ``"l2"`` (Mariethoz2010 Eq. 4–5), or + ``"variation"`` (Mariethoz2010 Eq. 9). Ignored when categorical. + distance_power : float, optional + Exponent δ for spatial-decay weighting of neighbours + (Mariethoz2010 Eq. 3). Applied to **all** distance types. + ``0.0`` → uniform weights (oracle-compatible default). + ``1.0`` → closer neighbours weighted more heavily. + """ + + def __init__( + self, + data, + categorical=True, + distance="l1", + distance_power=0.0, + weights=None, + ): + self._distance_power = float(distance_power) + if self._distance_power < 0: + raise ValueError("distance_power must be >= 0") + + if isinstance(data, dict): + self._init_multivariate(data, categorical, weights, distance) + return + + # ---- univariate (unchanged behaviour) ---- + self._multivariate = False + self._variables = None + self._weights = None + self._data = np.array(data, copy=True) + self._shape = self._data.shape + self._categorical = bool(categorical) + self._distance_type = distance + self._p_norm = None + self._variation_p_norm = None + _warn_if_nan(self._data) + if not self._categorical: + self._p_norm, self._variation_p_norm = self._parse_distance( + distance + ) + self._d_max = _data_range(self._data) + else: + self._d_max = None + + @staticmethod + def _parse_distance(distance): + """Parse a continuous-distance string into (p_norm, variation_p_norm). + + Exactly one of the two return values is non-``None``: + ``"l