{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# GEONE - GEOSCLASSIC - categorical variable\n",
    "\n",
    "## Estimation (kriging) and simulation (Sequential Indicator Simulation, SIS)\n",
    "\n",
    "The following functions are used for a grid, i.e. the evaluation are done at the centers of the grid cells:\n",
    "\n",
    "- `geone.geosclassicinterface.estimateIndicator`: for estimation, kriging of the indicator of each category, producing probabilities of for the categories\n",
    "- `geone.geosclassicinterface.simulate`: for simulation (sequential Indicator simulation, SIS)\n",
    "\n",
    "*Note: these functions detect the space dimension (1, 2, or 3) based on the parameter `dimension` that gives the number of cells along each axis.*\n",
    "\n",
    "These functions launch a C program running in parallel (based on *OpenMP*) for the simulation / estimation **in a grid**, assuming conditioning data located at the center of the grid cells. The conditioning data are treated as follows: (one of) the most frequent categories of the data point(s) falling in the same grid cell is attributed to that cell.\n",
    "\n",
    "## Interpolation type (kriging type)\n",
    "Estimation and simulation are done based on the kriging of the indicator of each category (consisered as a continuous variable for the presence of the category); simple kriging or ordinary kriging can be used according to the parameter `method`: \n",
    "- `method='simple_kriging'`: simple kriging\n",
    "- `method='oridinary_kriging'`: ordinary kriging (default)\n",
    "\n",
    "Kriging systems are based on a covariance model: required parameter `cov_model`. A single covariance model can be used for all the categories or a covariance model per category can be specified. See the notebook `ex_general_multiGaussian.ipynb` for available covariance models and examples. \n",
    "\n",
    "*Note: non-stationarities may be handled: local rotation, local multiplier for sill and/or range(s), see the notebook `ex_geosclassic_indicator_1d_2_non_stat_cov.ipynb`.*\n",
    "\n",
    "Simple kriging allows to specify the probabilities of the presence of the categories (kriging mean values of the indicator variable), stationary (global) or non-stationary (local). By default the probabilities are set to the proportions of the data values (stationary) or uniform probabilities if no data point is present.\n",
    "\n",
    "Ordinary kriging accounts for the proportion (mean value) at the vinicity of the estimated / simulated point. Note that one can also specify probabilities, which is used when no informed points is present in the search neighborhood of the estimated / simulated point.\n",
    "\n",
    "## Conditioning data\n",
    "Data consists of an ensemble of points, where each data point is given by a location (in the grid), a category value:\n",
    "- `x`: data locations\n",
    "- `v`: data category values\n",
    "\n",
    "The conditioning data are treated as follows: (one of) the most frequent categories of the data point(s) falling in the same grid cell is attributed to that cell.\n",
    "\n",
    "## Search neighborhood \n",
    "See notebook `ex_geosclassic_1d_1.ipynb` for details.\n",
    "\n",
    "## Computational resources - multiprocessing\n",
    "The external C function (Geos-Classic library) is launched in parallel (based on *OpenMP*), using a given number of threads. Moreover, for simulation, multiple parallel processes can be considered (several parallel calls of the function).\n",
    "\n",
    "The parameter to specify the computational resources for the estimation (interpolation), function `geone.geosclassicinterface.estimateIndicator`:\n",
    "- `nthreads` : number of threads for the interpolation in the grid (C function, 1 process)\n",
    "\n",
    "and the parameters for the simulation, function `geone.geosclassicinterface.simulateIndicator`:\n",
    "- `nproc`: number of parallel process(es) for the simulations in the grid (C function)\n",
    "- `nthreads_per_proc` : number of threads used per process (C function)\n",
    "\n",
    "Note that for the simulation, this represents, in terms of computational resources, a total of `nproc * nthreads_per_proc` CPUs (for the part with the C function); this number should not exceed the the total number of CPUs of the system (retrieved by `multiprocessing.cpu_count()` or `os.cpu_count()`).\n",
    "\n",
    "### Computational resources - Important remark\n",
    "Although some default values are proposed, it is strongly recommended to specify the above parameters controlling the computational resources; a few tests on the machine used allows to select a good set-up.\n",
    "\n",
    "## Ouput - getting the results\n",
    "The functions `geone.geosclassicinterface.estimate` and `geone.geosclassicinterface.simulate` returns a dictionary\n",
    "- `geosclassic_output = {'image':image, 'nwarning':nwarning, 'warnings':warnings}`\n",
    "\n",
    "with\n",
    "- `geosclassic_output['image']`: a geone image (instance of the class `geone.img.Img`) with \n",
    "    - for `geone.geosclassicinterface.estimateIndicator`: `ncategory` variables, where `ncategory` is the number of categories, the i-th variable (index i) is the estimated proportion for the i-th category (kriging mean value of the indicator variable of the i-th category)\n",
    "    - for `geone.geosclassicinterface.simulate`: `nreal` variables, where `nreal` is the number of realizations done, the i-th variable (index i) being the i-th realization\n",
    "- `geosclassic_output['nwarning']`: an `int`, the total number of warning(s) encountered during the run\n",
    "- `geosclassic_output['warnings']`: a list of strings (possibly empty), the list of all distinct warning messages\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Examples in 1D\n",
    "In this notebook, examples in 1D are given."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Import what is required"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import time\n",
    "\n",
    "# import package 'geone'\n",
    "import geone as gn"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "sys.version_info(major=3, minor=13, micro=7, releaselevel='final', serial=0)\n",
      "geone version: 1.3.1\n"
     ]
    }
   ],
   "source": [
    "# Show version of python and version of geone\n",
    "import sys \n",
    "print(sys.version_info)\n",
    "print('geone version: ' + gn.__version__)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Remark\n",
    "The matplotlib figures can be visualized in *interactive* mode:\n",
    "\n",
    "- `%matplotlib notebook`: enable interactive mode\n",
    "- `%matplotlib inline`: disable interactive mode"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Category values\n",
    "A list of category values (facies) must be defined. Let `ncategory` be the length of this list, *i.e.* the number of categories:\n",
    "\n",
    "- if `ncategory == 1`: the unique category value given must not be equal to 0; this is used for a binary case with values (\"unique category value\", 0), where 0 indicates the absence of the considered medium; conditioning data values should be \"unique category value\" or 0\n",
    "- if `ncategory >= 2`: this is used for a multi-category case with given values (distinct); conditioning data values should be in the list of given values\n",
    "\n",
    "Then, set color for each category, and color maps for proportions (for further plots).\n",
    "\n",
    "**Below: select the case with `ncategory` greater than one or equal to one below, comment the undesired cell.**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Case with ncategory > 1\n",
    "# -----------------------\n",
    "category_values = [1., 2., 3.]\n",
    "ncategory = len(category_values)\n",
    "\n",
    "# Set colors ...\n",
    "categVal = category_values\n",
    "categCol = ['lightblue', 'orange', 'darkgreen'] # must be of length len(categVal)\n",
    "cmap_categ = [gn.customcolors.custom_cmap(['white', c]) for c in categCol]\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# # Case with ncategory = 1\n",
    "# # -----------------------\n",
    "# category_values = [2.] # all categories are 2. and 0.\n",
    "# ncategory = len(category_values)\n",
    "\n",
    "# # Set colors ...\n",
    "# categVal = [category_values[0], 0]\n",
    "# categCol = ['tab:red', 'lightblue'] # must be of length len(categVal)\n",
    "# cmap_categ = [gn.customcolors.custom_cmap(['white', c]) for c in categCol]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Grid (1D)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "nx = 1000  # number of cells\n",
    "sx = 1.0  # cell unit\n",
    "ox = 0.0  # origin"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Covariance model(s)\n",
    "\n",
    "A covariance model is required for each category. If only one is defined, it is used for every category (it is ''recycled'').\n",
    "\n",
    "In 1D, a covariance model is given by an instance of the class `geone.covModel.covModel1D`.\n",
    "\n",
    "A covariance model is defined by its elementary contributions given as a list of 2-tuples, \n",
    "whose the first component is the type given by a string (`nugget`, `spherical`, `exponential`, `gaussian`, ...) and the second component is a dictionary used to pass the required parameters (the weight (`w`), the range (`r`), ...).\n",
    "\n",
    "*Note: see the notebook `ex_general_multiGaussian.ipynb` for available covariance models and examples.*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "cov_model = gn.covModel.CovModel1D(elem=[\n",
    "    ('exponential', {'w':9., 'r':100}), # elementary contribution\n",
    "    ], name='model-1D example')\n",
    "\n",
    "\n",
    "plt.figure()\n",
    "cov_model.plot_model()\n",
    "plt.title('Covariance function')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1. Example"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Settings - using data (optional) and probability (constant, optional)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "if ncategory > 1:\n",
    "    # Case with ncategory > 1\n",
    "    # -----------------------\n",
    "    # Data\n",
    "    x = [50.5, 300.1, 550.2, 849.4]  # data locations (real coordinates)\n",
    "    v = [ 1., 2., 1., 3.]            # data values\n",
    "    # x = None\n",
    "    # v = None\n",
    "\n",
    "    # Probability, proportion of each category\n",
    "    probability = [.1, .2, .7] # should sum to 1\n",
    "    # probability = None\n",
    "\n",
    "    # Type of kriging\n",
    "    method = 'simple_kriging'\n",
    "\n",
    "else:\n",
    "    # Case with ncategory = 1\n",
    "    # -----------------------\n",
    "    # Data\n",
    "    x = [50.5, 300.1, 550.2, 849.4]  # data locations (real coordinates)\n",
    "    v = [ 0., 2., 2., 0.]            # data values\n",
    "    # x = None\n",
    "    # v = None\n",
    "\n",
    "    # Probability, proportion (of non-zero category)\n",
    "    probability = [.7] # list of one number in the interval [0, 1]\n",
    "    # probability = None\n",
    "\n",
    "    # Type of kriging\n",
    "    method = 'simple_kriging'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Estimation of probabilities (by kriging)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "estimateIndicator: call `run_MPDSOMPGeosClassicIndicatorSim` [1 process of 8 thread(s) (OpenMP)] ...\n",
      "estimateIndicator: `run_MPDSOMPGeosClassicIndicatorSim` [1 process] complete\n",
      "Elapsed time: 0.0048 sec\n"
     ]
    }
   ],
   "source": [
    "# Computational resources\n",
    "nthreads = 8\n",
    "\n",
    "t1 = time.time() # start time\n",
    "geosclassic_output = gn.geosclassicinterface.estimateIndicator(\n",
    "                            category_values,               # list of categories (required)\n",
    "                            cov_model,                     # covariance model(s) (required)\n",
    "                            nx, sx, ox,                    # grid geometry (nx is required)\n",
    "                            x=x, v=v,                      # data\n",
    "                            probability=probability,       # probability\n",
    "                            method=method,                 # type of kriging\n",
    "                            use_unique_neighborhood=True,  # search neighborhood ...\n",
    "                            # searchRadius=None,             \n",
    "                            # searchRadiusRelative=1.2, \n",
    "                            nneighborMax=12,\n",
    "                            nthreads=nthreads,              # computational resources\n",
    "                            verbose=2                       # verbose mode\n",
    "                        )\n",
    "t2 = time.time() # end time\n",
    "print('Elapsed time: {:.2g} sec'.format(t2-t1))\n",
    "\n",
    "krig_img = geosclassic_output['image'] # output image\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(0, [])"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Total number of warning(s), and warning messages\n",
    "geosclassic_output['nwarning'], geosclassic_output['warnings']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "estimateIndicator: call `run_MPDSOMPGeosClassicIndicatorSim` [1 process of 1 thread(s) (OpenMP)] ...\n",
      "estimateIndicator: `run_MPDSOMPGeosClassicIndicatorSim` [1 process] complete\n",
      "Elapsed time: 0.0068 sec\n",
      "Same results ? True\n"
     ]
    }
   ],
   "source": [
    "# %%script false --no-raise-error # skip this cell! (comment this line to run the cell)\n",
    "\n",
    "# Equivalent, using other computational resources\n",
    "# -----------------------------------------------\n",
    "# Computational resources\n",
    "nthreads = 1\n",
    "\n",
    "t1 = time.time() # start time\n",
    "geosclassic_output = gn.geosclassicinterface.estimateIndicator(\n",
    "                            category_values,               # list of categories (required)\n",
    "                            cov_model,                     # covariance model(s) (required)\n",
    "                            nx, sx, ox,                    # grid geometry (nx is required)\n",
    "                            x=x, v=v,                      # data\n",
    "                            probability=probability,       # probability\n",
    "                            method=method,                 # type of kriging\n",
    "                            use_unique_neighborhood=True,  # search neighborhood ...\n",
    "                            # searchRadius=None,             \n",
    "                            # searchRadiusRelative=1.2, \n",
    "                            nneighborMax=12,\n",
    "                            nthreads=nthreads,              # computational resources\n",
    "                            verbose=2                       # verbose mode\n",
    "                        )\n",
    "t2 = time.time() # end time\n",
    "print('Elapsed time: {:.2g} sec'.format(t2-t1))\n",
    "\n",
    "krig_img_2 = geosclassic_output['image'] # output image\n",
    "\n",
    "print(f\"Same results ? {np.allclose(krig_img.val, krig_img_2.val)}\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Simulations"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "simulateIndicator: call `run_MPDSOMPGeosClassicIndicatorSim` [2 process(es) of 4 thread(s) (OpenMP)] ...\n",
      "simulateIndicator: `run_MPDSOMPGeosClassicIndicatorSim` [2 process(es)] complete\n",
      "Elapsed time: 2.7 sec\n"
     ]
    }
   ],
   "source": [
    "# Number of realizations\n",
    "nreal = 1000\n",
    "\n",
    "# Seed\n",
    "seed = 321\n",
    "\n",
    "# Computational resources\n",
    "nproc = 2\n",
    "nthreads_per_proc = 4\n",
    "\n",
    "t1 = time.time() # start time\n",
    "geosclassic_output = gn.geosclassicinterface.simulateIndicator(\n",
    "                            category_values,               # list of categories (required)\n",
    "                            cov_model,                     # covariance model(s) (required)\n",
    "                            nx, sx, ox,                    # grid geometry (nx is required)\n",
    "                            x=x, v=v,                      # data\n",
    "                            probability=probability,       # probability\n",
    "                            method=method,                 # type of kriging\n",
    "                            searchRadius=None,             # search neighborhood ...\n",
    "                            searchRadiusRelative=1.2, \n",
    "                            nneighborMax=12,\n",
    "                            nreal=nreal,                   # number of realizations\n",
    "                            seed=seed,                     # seed\n",
    "                            nproc=nproc,                   # computational resources ...\n",
    "                            nthreads_per_proc=nthreads_per_proc, \n",
    "                            verbose=2                      # verbose mode\n",
    "                        )\n",
    "t2 = time.time() # end time\n",
    "print('Elapsed time: {:.2g} sec'.format(t2-t1))\n",
    "\n",
    "simul_img = geosclassic_output['image'] # output image\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(0, [])"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Total number of warning(s), and warning messages\n",
    "geosclassic_output['nwarning'], geosclassic_output['warnings']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "simulateIndicator: call `run_MPDSOMPGeosClassicIndicatorSim` [1 process of 1 thread(s) (OpenMP)] ...\n",
      "simulateIndicator: `run_MPDSOMPGeosClassicIndicatorSim` [1 process] complete\n",
      "Elapsed time: 12 sec\n",
      "Same results ? True\n"
     ]
    }
   ],
   "source": [
    "# %%script false --no-raise-error # skip this cell! (comment this line to run the cell)\n",
    "\n",
    "# Equivalent, using other computational resources\n",
    "# -----------------------------------------------\n",
    "# Computational resources\n",
    "nproc = 1\n",
    "nthreads_per_proc = 1\n",
    "\n",
    "t1 = time.time() # start time\n",
    "geosclassic_output = gn.geosclassicinterface.simulateIndicator(\n",
    "                            category_values,               # list of categories (required)\n",
    "                            cov_model,                     # covariance model(s) (required)\n",
    "                            nx, sx, ox,                    # grid geometry (nx is required)\n",
    "                            x=x, v=v,                      # data\n",
    "                            probability=probability,       # probability\n",
    "                            method=method,                 # type of kriging\n",
    "                            searchRadius=None,             # search neighborhood ...\n",
    "                            searchRadiusRelative=1.2, \n",
    "                            nneighborMax=12,\n",
    "                            nreal=nreal,                   # number of realizations\n",
    "                            seed=seed,                     # seed\n",
    "                            nproc=nproc,                   # computational resources ...\n",
    "                            nthreads_per_proc=nthreads_per_proc, \n",
    "                            verbose=2                      # verbose mode\n",
    "                        )\n",
    "t2 = time.time() # end time\n",
    "print('Elapsed time: {:.2g} sec'.format(t2-t1))\n",
    "\n",
    "simul_img_2 = geosclassic_output['image'] # output image\n",
    "\n",
    "print(f\"Same results ? {np.allclose(simul_img.val, simul_img_2.val)}\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Plot the results"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Set sapcing (cell size) in y direction (1 cell in 1D) to visualize images using gn.imgplot.drawImage2D\n",
    "sy = 0.2 * (simul_img.xmax() - simul_img.xmin())\n",
    "simul_img.sy = sy\n",
    "krig_img.sy = sy\n",
    "\n",
    "if x is not None:\n",
    "    # Set y-coordinates for conditioning data points for visualization\n",
    "    y = len(x) * [simul_img.oy + 0.5*simul_img.sy]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Compute proportion of each category (pixel-wise)\n",
    "simul_img_prop = gn.img.imageCategProp(simul_img, category_values)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1200x800 with 16 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Plot\n",
    "plt.subplots(1+ncategory, 2, figsize=(12, 2*(1+ncategory)), sharex=True, sharey=True)\n",
    "\n",
    "for i in range(2):\n",
    "    plt.subplot(1+ncategory, 2, i+1)\n",
    "    gn.imgplot.drawImage2D(simul_img, iv=i, categ=True, categVal=categVal, categCol=categCol)\n",
    "    if x is not None:\n",
    "        plt.plot(x, y, '+', c='black', markersize=5) # add conditioning point locations\n",
    "    plt.title(f'real #{i}')\n",
    "\n",
    "for i in range(ncategory):\n",
    "    plt.subplot(1+ncategory, 2, 2*i+3)\n",
    "    gn.imgplot.drawImage2D(simul_img_prop, iv=i, vmin=0, vmax=1, cmap=cmap_categ[i])\n",
    "    if x is not None:\n",
    "        plt.plot(x, y, '+', c='black', markersize=5) # add conditioning point locations\n",
    "    plt.title(f'Proportion of categ {categVal[i]} over {nreal} real')\n",
    "\n",
    "    plt.subplot(1+ncategory, 2, 2*i+4)\n",
    "    gn.imgplot.drawImage2D(krig_img, iv=i, vmin=0, vmax=1, cmap=cmap_categ[i])\n",
    "    if x is not None:\n",
    "        plt.plot(x, y, '+', c='black', markersize=5) # add conditioning point locations\n",
    "    plt.title(f'Estimate probability of categ {categVal[i]} (kriging)')\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Check results"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Estimation: all data respected ? True\n",
      "Simulation: all data respected ? True\n"
     ]
    }
   ],
   "source": [
    "# Check data\n",
    "# ----------\n",
    "if x is not None:\n",
    "    # Get index of conditioning location in the grid\n",
    "    data_grid_index = [gn.img.pointToGridIndex(xk, 0, 0, sx, 1., 1., ox, 0., 0.) for xk in x] # (ix, iy, iz) for each data point\n",
    "    # Check estimation\n",
    "    krig_v = [krig_img.val[:, iz, iy, ix] for ix, iy, iz in data_grid_index]\n",
    "    if ncategory == 1:\n",
    "        print(f'Estimation: all data respected ? {np.all(np.asarray(krig_v).reshape(-1) == np.asarray([1 if vi == category_values[0] else 0 for vi in v]))}')\n",
    "    else:\n",
    "        print(f'Estimation: all data respected ? {np.all([np.all(krig_v[i] == np.eye(ncategory)[np.where(np.asarray(category_values) == v[i])[0][0]]) for i in range(len(x))])}')\n",
    "    # Check simulation\n",
    "    sim_v = [simul_img.val[:, iz, iy, ix] for ix, iy, iz in data_grid_index]\n",
    "    print(f'Simulation: all data respected ? {np.all([np.all(sim_v[i] == v[i]) for i in range(len(x))])}')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Prescribed probabilities                                    = [0.1, 0.2, 0.7]\n",
      "Estimation: probabilities (mean over the grid)              = [0.2000514  0.21483179 0.58511682]\n",
      "Simulation: probabilities (mean over the grid and all real.)= [np.float64(0.189052), np.float64(0.214658), np.float64(0.59629)]\n"
     ]
    }
   ],
   "source": [
    "# Compare probabilities\n",
    "# ---------------------\n",
    "if probability is not None:\n",
    "    print(f'Prescribed probabilities                                    = {probability}')\n",
    "    print(f'Estimation: probabilities (mean over the grid)              = {krig_img.val.mean(axis=(1,2,3))}')\n",
    "    print(f'Simulation: probabilities (mean over the grid and all real.)= {[np.mean(simul_img.val == cv) for cv in category_values]}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2. Example - using non-stationary probabilities"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Setting probability (proportion) maps"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Coordinates of the center of grid cells\n",
    "xg = ox + sx*(0.5+np.arange(nx))\n",
    "\n",
    "if ncategory > 1:\n",
    "    # Case with ncategory > 1\n",
    "    # -----------------------\n",
    "    # Define probability maps for each category\n",
    "    c = 0.9\n",
    "    p1 = np.linspace(c, 0., nx)     \n",
    "    p2 = c - p1\n",
    "    p0 = (1. - c) * np.ones_like(p1) # 1.0 - p1 - p2 # constant map (0.1)\n",
    "\n",
    "    probability = np.array((p0, p1, p2))\n",
    "\n",
    "else:\n",
    "    # Case with ncategory = 1\n",
    "    # -----------------------\n",
    "    c = 1.0\n",
    "    # Define probability map for non-zero category\n",
    "    probability = np.linspace(0., c, nx)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x800 with 6 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Plot\n",
    "# ----\n",
    "# Fill image for display\n",
    "probability_img = gn.img.Img(nx, 1, 1, sx, 1., 1., 0., 0., 0., nv=ncategory, val=probability)\n",
    "probability_img.sy = .2 * probability_img.sx * probability_img.nx # set spacing in y direction (1 cell) to visualize images using gn.imgplot.drawImage2D\n",
    "\n",
    "# Display probability maps\n",
    "plt.subplots(ncategory, 1, figsize=(10,8), sharey=True)\n",
    "\n",
    "for i in range(ncategory):\n",
    "    plt.subplot(ncategory, 1, 1+i)\n",
    "    gn.imgplot.drawImage2D(probability_img, iv=i, title = f'Probability for categ. {categVal[i]}')\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Settings - using data (optional)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "if ncategory > 1:\n",
    "    # Case with ncategory > 1\n",
    "    # -----------------------\n",
    "    # Data\n",
    "    x = [50.5, 300.1, 550.2, 849.4]  # data locations (real coordinates)\n",
    "    v = [ 1., 2., 1., 3.]            # data values\n",
    "    # x = None\n",
    "    # v = None\n",
    "\n",
    "    # Probability : `probability` defined above\n",
    "\n",
    "    # Type of kriging\n",
    "    method = 'simple_kriging'\n",
    "\n",
    "else:\n",
    "    # Case with ncategory = 1\n",
    "    # -----------------------\n",
    "    # Data\n",
    "    x = [50.5, 300.1, 550.2, 849.4]  # data locations (real coordinates)\n",
    "    v = [ 0., 2., 2., 0.]            # data values\n",
    "    # x = None\n",
    "    # v = None\n",
    "\n",
    "    # Probability : `probability` defined above\n",
    "\n",
    "    # Type of kriging\n",
    "    method = 'simple_kriging'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Estimation of probabilities (by kriging)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "estimateIndicator: call `run_MPDSOMPGeosClassicIndicatorSim` [1 process of 8 thread(s) (OpenMP)] ...\n",
      "estimateIndicator: `run_MPDSOMPGeosClassicIndicatorSim` [1 process] complete\n",
      "Elapsed time: 0.0032 sec\n"
     ]
    }
   ],
   "source": [
    "# Computational resources\n",
    "nthreads = 8\n",
    "\n",
    "t1 = time.time() # start time\n",
    "geosclassic_output = gn.geosclassicinterface.estimateIndicator(\n",
    "                            category_values,               # list of categories (required)\n",
    "                            cov_model,                     # covariance model(s) (required)\n",
    "                            nx, sx, ox,                    # grid geometry (nx is required)\n",
    "                            x=x, v=v,                      # data\n",
    "                            probability=probability,       # probability\n",
    "                            method=method,                 # type of kriging\n",
    "                            use_unique_neighborhood=True,  # search neighborhood ...\n",
    "                            # searchRadius=None,             \n",
    "                            # searchRadiusRelative=1.2, \n",
    "                            nneighborMax=12,\n",
    "                            nthreads=nthreads,              # computational resources\n",
    "                            verbose=2                      # verbose mode\n",
    "                        )\n",
    "t2 = time.time() # end time\n",
    "print('Elapsed time: {:.2g} sec'.format(t2-t1))\n",
    "\n",
    "krig_img = geosclassic_output['image'] # output image\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(0, [])"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Total number of warning(s), and warning messages\n",
    "geosclassic_output['nwarning'], geosclassic_output['warnings']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "estimateIndicator: call `run_MPDSOMPGeosClassicIndicatorSim` [1 process of 1 thread(s) (OpenMP)] ...\n",
      "estimateIndicator: `run_MPDSOMPGeosClassicIndicatorSim` [1 process] complete\n",
      "Elapsed time: 0.0059 sec\n",
      "Same results ? True\n"
     ]
    }
   ],
   "source": [
    "# %%script false --no-raise-error # skip this cell! (comment this line to run the cell)\n",
    "\n",
    "# Equivalent, using other computational resources\n",
    "# -----------------------------------------------\n",
    "# Computational resources\n",
    "nthreads = 1\n",
    "\n",
    "t1 = time.time() # start time\n",
    "geosclassic_output = gn.geosclassicinterface.estimateIndicator(\n",
    "                            category_values,               # list of categories (required)\n",
    "                            cov_model,                     # covariance model(s) (required)\n",
    "                            nx, sx, ox,                    # grid geometry (nx is required)\n",
    "                            x=x, v=v,                      # data\n",
    "                            probability=probability,       # probability\n",
    "                            method=method,                 # type of kriging\n",
    "                            use_unique_neighborhood=True,  # search neighborhood ...\n",
    "                            # searchRadius=None,             \n",
    "                            # searchRadiusRelative=1.2, \n",
    "                            nneighborMax=12,\n",
    "                            nthreads=nthreads,              # computational resources\n",
    "                            verbose=2                      # verbose mode\n",
    "                        )\n",
    "t2 = time.time() # end time\n",
    "print('Elapsed time: {:.2g} sec'.format(t2-t1))\n",
    "\n",
    "krig_img_2 = geosclassic_output['image'] # output image\n",
    "\n",
    "print(f\"Same results ? {np.allclose(krig_img.val, krig_img_2.val)}\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Simulations"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "simulateIndicator: call `run_MPDSOMPGeosClassicIndicatorSim` [2 process(es) of 4 thread(s) (OpenMP)] ...\n",
      "simulateIndicator: `run_MPDSOMPGeosClassicIndicatorSim` [2 process(es)] complete\n",
      "Elapsed time: 2.7 sec\n"
     ]
    }
   ],
   "source": [
    "# Number of realizations\n",
    "nreal = 1000\n",
    "\n",
    "# Seed\n",
    "seed = 321\n",
    "\n",
    "# Computational resources\n",
    "nproc = 2\n",
    "nthreads_per_proc = 4\n",
    "\n",
    "t1 = time.time() # start time\n",
    "geosclassic_output = gn.geosclassicinterface.simulateIndicator(\n",
    "                            category_values,               # list of categories (required)\n",
    "                            cov_model,                     # covariance model(s) (required)\n",
    "                            nx, sx, ox,                    # grid geometry (nx is required)\n",
    "                            x=x, v=v,                      # data\n",
    "                            probability=probability,       # probability\n",
    "                            method=method,                 # type of kriging\n",
    "                            searchRadius=None,             # search neighborhood ...\n",
    "                            searchRadiusRelative=1.2, \n",
    "                            nneighborMax=12,\n",
    "                            nreal=nreal,                   # number of realizations\n",
    "                            seed=seed,                     # seed\n",
    "                            nproc=nproc,                   # computational resources ...\n",
    "                            nthreads_per_proc=nthreads_per_proc, \n",
    "                            verbose=2                      # verbose mode\n",
    "                        )\n",
    "t2 = time.time() # end time\n",
    "print('Elapsed time: {:.2g} sec'.format(t2-t1))\n",
    "\n",
    "simul_img = geosclassic_output['image'] # output image\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(0, [])"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Total number of warning(s), and warning messages\n",
    "geosclassic_output['nwarning'], geosclassic_output['warnings']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "simulateIndicator: call `run_MPDSOMPGeosClassicIndicatorSim` [1 process of 1 thread(s) (OpenMP)] ...\n",
      "simulateIndicator: `run_MPDSOMPGeosClassicIndicatorSim` [1 process] complete\n",
      "Elapsed time: 12 sec\n",
      "Same results ? True\n"
     ]
    }
   ],
   "source": [
    "# %%script false --no-raise-error # skip this cell! (comment this line to run the cell)\n",
    "\n",
    "# Equivalent, using other computational resources\n",
    "# -----------------------------------------------\n",
    "# Computational resources\n",
    "nproc = 1\n",
    "nthreads_per_proc = 1\n",
    "\n",
    "t1 = time.time() # start time\n",
    "geosclassic_output = gn.geosclassicinterface.simulateIndicator(\n",
    "                            category_values,               # list of categories (required)\n",
    "                            cov_model,                     # covariance model(s) (required)\n",
    "                            nx, sx, ox,                    # grid geometry (nx is required)\n",
    "                            x=x, v=v,                      # data\n",
    "                            probability=probability,       # probability\n",
    "                            method=method,                 # type of kriging\n",
    "                            searchRadius=None,             # search neighborhood ...\n",
    "                            searchRadiusRelative=1.2, \n",
    "                            nneighborMax=12,\n",
    "                            nreal=nreal,                   # number of realizations\n",
    "                            seed=seed,                     # seed\n",
    "                            nproc=nproc,                   # computational resources ...\n",
    "                            nthreads_per_proc=nthreads_per_proc, \n",
    "                            verbose=2                      # verbose mode\n",
    "                        )\n",
    "t2 = time.time() # end time\n",
    "print('Elapsed time: {:.2g} sec'.format(t2-t1))\n",
    "\n",
    "simul_img_2 = geosclassic_output['image'] # output image\n",
    "\n",
    "print(f\"Same results ? {np.allclose(simul_img.val, simul_img_2.val)}\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Plot the results"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Set sapcing (cell size) in y direction (1 cell in 1D) to visualize images using gn.imgplot.drawImage2D\n",
    "sy = 0.2 * (simul_img.xmax() - simul_img.xmin())\n",
    "simul_img.sy = sy\n",
    "krig_img.sy = sy\n",
    "\n",
    "if x is not None:\n",
    "    # Set y-coordinates for conditioning data points for visualization\n",
    "    y = len(x) * [simul_img.oy + 0.5*simul_img.sy]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Compute proportion of each category (pixel-wise)\n",
    "simul_img_prop = gn.img.imageCategProp(simul_img, category_values)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1500x800 with 24 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Plot\n",
    "plt.subplots(1+ncategory, 3, figsize=(15, (1+ncategory)*2), sharex=True, sharey=True)\n",
    "\n",
    "for i in range(3):\n",
    "    plt.subplot(1+ncategory, 3, i+1)\n",
    "    gn.imgplot.drawImage2D(simul_img, iv=i, categ=True, categVal=categVal, categCol=categCol)\n",
    "    if x is not None:\n",
    "        plt.plot(x, y, '+', c='black', markersize=5) # add conditioning point locations\n",
    "    plt.title(f'real #{i}')\n",
    "\n",
    "for i in range(ncategory):\n",
    "    plt.subplot(1+ncategory, 3, 3*i+4)\n",
    "    gn.imgplot.drawImage2D(simul_img_prop, iv=i, vmin=0, vmax=1, cmap=cmap_categ[i])\n",
    "    if x is not None:\n",
    "        plt.plot(x, y, '+', c='black', markersize=5) # add conditioning point locations\n",
    "    plt.title(f'Proportion of categ {categVal[i]} over {nreal} real')\n",
    "\n",
    "    plt.subplot(1+ncategory, 3, 3*i+5)\n",
    "    gn.imgplot.drawImage2D(krig_img, iv=i, vmin=0, vmax=1, cmap=cmap_categ[i])\n",
    "    if x is not None:\n",
    "        plt.plot(x, y, '+', c='black', markersize=5) # add conditioning point locations\n",
    "    plt.title(f'Estimate probability of categ {categVal[i]} (kriging)')\n",
    "\n",
    "    plt.subplot(1+ncategory, 3, 3*i+6)\n",
    "    gn.imgplot.drawImage2D(probability_img, iv=i, vmin=0, vmax=1, cmap=cmap_categ[i])\n",
    "    if x is not None:\n",
    "        plt.plot(x, y, '+', c='black', markersize=5) # add conditioning point locations\n",
    "    plt.title(f'Prescribed probability for categ {categVal[i]}')\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Check results"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Estimation: all data respected ? True\n",
      "Simulation: all data respected ? True\n"
     ]
    }
   ],
   "source": [
    "# Check data\n",
    "# ----------\n",
    "if x is not None:\n",
    "    # Get index of conditioning location in the grid\n",
    "    data_grid_index = [gn.img.pointToGridIndex(xk, 0, 0, sx, 1., 1., ox, 0., 0.) for xk in x] # (ix, iy, iz) for each data point\n",
    "    # Check estimation\n",
    "    krig_v = [krig_img.val[:, iz, iy, ix] for ix, iy, iz in data_grid_index]\n",
    "    if ncategory == 1:\n",
    "        print(f'Estimation: all data respected ? {np.all(np.asarray(krig_v).reshape(-1) == np.asarray([1 if vi == category_values[0] else 0 for vi in v]))}')\n",
    "    else:\n",
    "        print(f'Estimation: all data respected ? {np.all([np.all(krig_v[i] == np.eye(ncategory)[np.where(np.asarray(category_values) == v[i])[0][0]]) for i in range(len(x))])}')\n",
    "    # Check simulation\n",
    "    sim_v = [simul_img.val[:, iz, iy, ix] for ix, iy, iz in data_grid_index]\n",
    "    print(f'Simulation: all data respected ? {np.all([np.all(sim_v[i] == v[i]) for i in range(len(x))])}')\n"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "py313",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.13.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}