deploy: b8fb961

.buildinfo

@@ -0,0 +1,4 @@
+# Sphinx build info version 1
+# This file hashes the configuration used when building these files. When it is not found, a full rebuild will be done.
+config: 41749d055d2b2d79c607248c527c05e5
+tags: 645f666f9bcd5a90fca523b33c5a78b7

_downloads/073e157de6860283284de3d1698f0b22/resampling_interval_data.ipynb

@@ -0,0 +1,238 @@
+{
+  "cells": [
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "collapsed": false
+      },
+      "outputs": [],
+      "source": [
+        "%matplotlib inline"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "\n# Resampling Interval Data\n\nInterval (or fractional) data is common in metallurgy and mineral processing.  Samples are sized using sieves\nin a laboratory and each resultant fraction is often assayed to determine chemical composition.\nThe typical nomenclature is of the interval edges is size_retained, size passing - any particle within an interval\nor fraction was retained by the lower sieve size, but passed the sieve size above it.\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "collapsed": false
+      },
+      "outputs": [],
+      "source": [
+        "import logging\n\nimport numpy as np\nimport pandas as pd\nimport plotly\n\nfrom elphick.mass_composition import MassComposition\nfrom elphick.mass_composition.datasets.sample_data import size_by_assay"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "collapsed": false
+      },
+      "outputs": [],
+      "source": [
+        "logging.basicConfig(level=logging.INFO,\n                    format='%(asctime)s %(levelname)s %(module)s - %(funcName)s: %(message)s',\n                    datefmt='%Y-%m-%dT%H:%M:%S%z',\n                    )"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "## Create a MassComposition object\n\nWe get some demo data in the form of a pandas DataFrame\nWe create this object as 1D based on the pandas index\n\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "collapsed": false
+      },
+      "outputs": [],
+      "source": [
+        "df_data: pd.DataFrame = size_by_assay()\ndf_data"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "The size index is of the Interval type, maintaining the fractional information.\n\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "collapsed": false
+      },
+      "outputs": [],
+      "source": [
+        "mc_size: MassComposition = MassComposition(df_data, name='Sample')\nmc_size.data.to_dataframe()"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "collapsed": false
+      },
+      "outputs": [],
+      "source": [
+        "mc_size.aggregate()"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "First we'll plot the intervals\n\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "collapsed": false
+      },
+      "outputs": [],
+      "source": [
+        "fig = mc_size.plot_intervals(variables=['mass_dry', 'Fe', 'SiO2', 'Al2O3'],\n                             cumulative=False)\nfig"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "Size distributions are often plotted in the cumulative form. Cumulative passing is achieved by setting the\ndirection = ascending.\n\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "collapsed": false
+      },
+      "outputs": [],
+      "source": [
+        "fig = mc_size.plot_intervals(variables=['mass_dry', 'Fe', 'SiO2', 'Al2O3'],\n                             cumulative=True, direction='ascending')\nfig"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "Now we will resample on a defined grid (interval edges) and view the resampled fractions\n\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "collapsed": false
+      },
+      "outputs": [],
+      "source": [
+        "new_edges = np.unique(np.geomspace(1.0e-03, mc_size.data.to_dataframe().index.right.max() * 3, 50))\nnew_coords = np.insert(new_edges, 0, 0)\n\nmc_upsampled: MassComposition = mc_size.resample_1d(interval_edges=new_edges, precision=3, include_original_edges=True)\n\nfig = mc_upsampled.plot_intervals(variables=['mass_dry', 'Fe', 'SiO2', 'Al2O3'], cumulative=False)\n# noinspection PyTypeChecker\nplotly.io.show(fig)"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "Close inspection of the plot above reals some sharp dips for some mass intervals.  This is caused by those intervals\nbeing narrower than the adjacent neighbours, hence they have less absolute mass.\nThis is a visual artefact only, numerically it is correct, as shown by the cumulative plot.\n\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "collapsed": false
+      },
+      "outputs": [],
+      "source": [
+        "fig = mc_upsampled.plot_intervals(variables=['mass_dry', 'Fe', 'SiO2', 'Al2O3'], cumulative=True, direction='ascending')\nfig"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "We can upsample each of the original fraction by a factor.  Since adjacent fractions are similar, the fractional\nplot is reasonably smooth.  Note however, that fraction widths are still different, caused by the original sieve\nselection.\n\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "collapsed": false
+      },
+      "outputs": [],
+      "source": [
+        "mc_upsampled_2: MassComposition = mc_size.resample_1d(interval_edges=10, precision=3)\nfig = mc_upsampled_2.plot_intervals(variables=['mass_dry', 'Fe', 'SiO2', 'Al2O3'], cumulative=False)\nfig"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "Validate the head grade against the original sample\n\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "collapsed": false
+      },
+      "outputs": [],
+      "source": [
+        "pd.testing.assert_frame_equal(mc_size.aggregate().reset_index(drop=True),\n                              mc_upsampled.aggregate().reset_index(drop=True))\n\npd.testing.assert_frame_equal(mc_size.aggregate().reset_index(drop=True),\n                              mc_upsampled_2.aggregate().reset_index(drop=True))"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "Complete a round trip by converting the up-sampled objects back to the original intervals and validate.\n\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "collapsed": false
+      },
+      "outputs": [],
+      "source": [
+        "orig_index = mc_size.data.to_dataframe().index\noriginal_edges: np.ndarray = np.sort(np.unique(list(orig_index.left) + list(orig_index.right)))\n\nmc_downsampled: MassComposition = mc_upsampled.resample_1d(interval_edges=original_edges, precision=3)\nmc_downsampled_2: MassComposition = mc_upsampled_2.resample_1d(interval_edges=original_edges, precision=3)\n\npd.testing.assert_frame_equal(mc_size.data.to_dataframe(), mc_downsampled.data.to_dataframe())\npd.testing.assert_frame_equal(mc_size.data.to_dataframe(), mc_downsampled_2.data.to_dataframe())"
+      ]
+    }
+  ],
+  "metadata": {
+    "kernelspec": {
+      "display_name": "Python 3",
+      "language": "python",
+      "name": "python3"
+    },
+    "language_info": {
+      "codemirror_mode": {
+        "name": "ipython",
+        "version": 3
+      },
+      "file_extension": ".py",
+      "mimetype": "text/x-python",
+      "name": "python",
+      "nbconvert_exporter": "python",
+      "pygments_lexer": "ipython3",
+      "version": "3.10.12"
+    }
+  },
+  "nbformat": 4,
+  "nbformat_minor": 0
+}

_downloads/079fc7d94a1d3363e8991794bfa25ec0/200_interval_data.py

@@ -0,0 +1,92 @@
+"""
+Interval Data
+=============
+
+This example adds a second dimension.  The second dimension is an interval, of the form interval_from, interval_to.
+It is also known as binned data, where each 'bin' is bounded between and upper and lower limit.
+
+An interval is relevant in geology, when analysing drill hole data.
+
+Intervals are also encountered in metallurgy, but in that discipline they are often called fractions,
+e.g. size fractions.  In that case the typical nomenclature is size_retained, size passing, since the data
+originates from a sieve stack.
+
+"""
+import logging
+
+import pandas as pd
+from matplotlib import pyplot as plt
+
+from elphick.mass_composition import MassComposition
+from elphick.mass_composition.datasets.sample_data import iron_ore_sample_data
+
+
+# %%
+logging.basicConfig(level=logging.INFO,
+                    format='%(asctime)s %(levelname)s %(module)s - %(funcName)s: %(message)s',
+                    datefmt='%Y-%m-%dT%H:%M:%S%z',
+                    )
+
+# %%
+#
+# Create a MassComposition object
+# -------------------------------
+#
+# We get some demo data in the form of a pandas DataFrame
+# We create this object as 1D based on the pandas index
+
+df_data: pd.DataFrame = iron_ore_sample_data()
+df_data.head()
+
+# %%
+
+obj_mc: MassComposition = MassComposition(df_data,
+                                          name='Drill program',
+                                          mass_units='kg')
+obj_mc
+
+# %%
+
+obj_mc.aggregate()
+
+# %%
+obj_mc.aggregate('DHID')
+
+# %%
+#
+# We will now make a 2D dataset using DHID and the interval.
+# We will first create a mean interval variable.  Then we will set the dataframe index to both variables before
+# constructing the object.
+
+print(df_data.columns)
+
+df_data['DHID'] = df_data['DHID'].astype('category')
+# make an int based drillhole identifier
+code, dh_id = pd.factorize(df_data['DHID'])
+df_data['DH'] = code
+df_data = df_data.reset_index().set_index(['DH', 'interval_from', 'interval_to'])
+
+obj_mc_2d: MassComposition = MassComposition(df_data,
+                                             name='Drill program',
+                                             mass_units='kg')
+# obj_mc_2d._data.assign(hole_id=dh_id)
+print(obj_mc_2d)
+print(obj_mc_2d.aggregate())
+print(obj_mc_2d.aggregate('DHID'))
+
+# %%
+#
+# View some plots
+#
+# First confirm the parallel plot still works
+
+# TODO: work on the display order
+# TODO - fails for DH (integer)
+
+# fig: Figure = obj_mc_2d.plot_parallel(color='Fe')
+# fig.show()
+
+# now plot using the xarray data - take advantage of the multi-dim nature of the package
+
+obj_mc_2d.data['Fe'].plot()
+plt.show()