From c44b39895f0afb118d759420a1deb4859288db9d Mon Sep 17 00:00:00 2001 From: MatthiasProbst Date: Mon, 29 Apr 2024 17:55:06 +0200 Subject: [PATCH] update and unify extension imlementation --- docs/practical_examples/tmp.grpah.html | 4 +- docs/userguide/misc/Extensions.ipynb | 696 ++++++++++++++++---- docs/userguide/wrapper/DatasetSlicing.ipynb | 195 +++--- h5rdmtoolbox/convention/_h5tbx.py | 36 - h5rdmtoolbox/extensions/magnitude.py | 118 ++-- h5rdmtoolbox/extensions/normalize.py | 253 +++---- h5rdmtoolbox/extensions/units.py | 2 +- h5rdmtoolbox/extensions/vector.py | 151 +++-- h5rdmtoolbox/protocols.py | 12 + h5rdmtoolbox/wrapper/core.py | 19 +- tests/conventions/test_conventions.py | 4 +- tests/test_extensions.py | 222 ++----- tests/wrapper/test_core.py | 11 + 13 files changed, 1004 insertions(+), 719 deletions(-) delete mode 100644 h5rdmtoolbox/convention/_h5tbx.py diff --git a/docs/practical_examples/tmp.grpah.html b/docs/practical_examples/tmp.grpah.html index c1260647..55ea8555 100644 --- a/docs/practical_examples/tmp.grpah.html +++ b/docs/practical_examples/tmp.grpah.html @@ -88,8 +88,8 @@

// parsing and collecting nodes and edges from the python - nodes = new vis.DataSet([{"color": "black", "id": 0, "label": "_:N25", "shape": "dot", "size": 20, "title": "_:N25"}, {"color": "#97c2fc", "id": 1, "label": "A hint", "shape": "dot", "title": "A hint"}, {"color": "#97c2fc", "id": 2, "label": "prov:Person", "shape": "dot", "title": "prov:Person"}, {"color": "#97c2fc", "id": 3, "label": "Probst", "shape": "dot", "title": "Probst"}, {"color": "#97c2fc", "id": 4, "label": "Matthias", "shape": "dot", "title": "Matthias"}]); - edges = new vis.DataSet([{"from": 0, "label": "skos:definition", "to": 1}, {"from": 2, "label": "foaf:lastName", "to": 3}, {"from": 2, "label": "foaf:firstName", "to": 4}]); + nodes = new vis.DataSet([{"color": "#97c2fc", "id": 0, "label": "prov:Person", "shape": "dot", "title": "prov:Person"}, {"color": "#97c2fc", "id": 1, "label": "Matthias", "shape": "dot", "title": "Matthias"}, {"color": "#97c2fc", "id": 2, "label": "Probst", "shape": "dot", "title": "Probst"}, {"color": "black", "id": 3, "label": "_:N25", "shape": "dot", "size": 20, "title": "_:N25"}, {"color": "#97c2fc", "id": 4, "label": "A hint", "shape": "dot", "title": "A hint"}]); + edges = new vis.DataSet([{"from": 0, "label": "foaf:firstName", "to": 1}, {"from": 0, "label": "foaf:lastName", "to": 2}, {"from": 3, "label": "skos:definition", "to": 4}]); nodeColors = {}; allNodes = nodes.get({ returnType: "Object" }); diff --git a/docs/userguide/misc/Extensions.ipynb b/docs/userguide/misc/Extensions.ipynb index 818743f1..7140752e 100644 --- a/docs/userguide/misc/Extensions.ipynb +++ b/docs/userguide/misc/Extensions.ipynb @@ -9,14 +9,20 @@ "\n", "The wrapper class functionalities can be extended using composition or inheritance.\n", "\n", - "## Composition\n", + "The concept of composition adds a component to a composite class. The relationship is such, that the composite class does not know the component class but wise versa. This allows to add additional functionality without changing the original code. Adding components to an existing wrapper class will be called \"registering\" here.\n", "\n", - "The concept of composition adds a component to a composite class. The relationship is such, that the composite class does not know the component class but wise versa. This allows to add additional functionality without changing the original code. Adding components to an existing wrapper class will be called \"registering\" here." + "Concretely, four different so-called accessory classes are implemented:\n", + "- `Vector`\n", + "- `Magnitude`\n", + "- `normalize`\n", + "- `to_units`\n", + "\n", + "These accessories interfaces must be activated by an import call. They generally are designed such, that they are called on a dataset or group with respective arguments, which prepares a the action being performed when data is selected. Best is, to learn by example:" ] }, { "cell_type": "code", - "execution_count": 1, + "execution_count": 20, "id": "a1cbc998-a747-4370-b362-d04c4d6508be", "metadata": { "tags": [] @@ -28,7 +34,7 @@ "using(\"h5py\")" ] }, - "execution_count": 1, + "execution_count": 20, "metadata": {}, "output_type": "execute_result" } @@ -43,28 +49,25 @@ "id": "a3edcad1-6c32-4d07-a581-1aa57f917259", "metadata": {}, "source": [ - "## Built-in extensions\n", - "You may add your own extensions, but the packages comes already with some, that may be useful:\n", - "\n", - "### 1. Vector\n", - "The `Vector` extension returns a `xr.Dataset` including the provided datasets when the `Vector` object is sliced. It just saves some time and makes it a one-liner to create the `xr.Dataset`." + "## 1. Vector\n", + "The `Vector` extension returns a `xr.Dataset`. First specify which of the datasets from the HDF5 should be contained in the resulting `xr.Dataset`. Then, index the data array using numpy notation or `sel()` or `isel()`. Only then, the data is loaded from the file:" ] }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 23, "id": "7eecb901-7e7c-473d-848c-409e1f0a0e8c", "metadata": { "tags": [] }, "outputs": [], "source": [ - "from h5rdmtoolbox.extensions import vector" + "from h5rdmtoolbox.extensions import vector # make `Vector` appear as a property of groups" ] }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 24, "id": "aa41f9f9-64d2-4d3d-8cd3-4cbcca88ae88", "metadata": { "tags": [] @@ -442,10 +445,13 @@ " * y (y) int32 2 3\n", " * x (x) int32 1 2 3\n", "Data variables:\n", - " xvel (y, x) float64 0.03456 0.9389 0.03886 0.1708 0.5039 0.8131\n", - " yvel (y, x) float64 0.1247 0.3435 0.5736 0.8872 0.6234 0.06209" + " xvel (y, x) float64 0.9042 0.06279 0.2518 0.7133 0.5988 0.09251\n", + " yvel (y, x) float64 0.2222 0.5316 0.9987 0.251 0.3073 0.8381\n", + "Attributes:\n", + " long_name: x vel\n", + " units: m/s" ], "text/plain": [ "\n", @@ -454,11 +460,14 @@ " * y (y) int32 2 3\n", " * x (x) int32 1 2 3\n", "Data variables:\n", - " xvel (y, x) float64 0.03456 0.9389 0.03886 0.1708 0.5039 0.8131\n", - " yvel (y, x) float64 0.1247 0.3435 0.5736 0.8872 0.6234 0.06209" + " xvel (y, x) float64 0.9042 0.06279 0.2518 0.7133 0.5988 0.09251\n", + " yvel (y, x) float64 0.2222 0.5316 0.9987 0.251 0.3073 0.8381\n", + "Attributes:\n", + " long_name: x vel\n", + " units: m/s" ] }, - "execution_count": 3, + "execution_count": 24, "metadata": {}, "output_type": "execute_result" } @@ -470,8 +479,10 @@ " \n", " h5.create_dataset('x', data=[1, 2, 3], make_scale=True, attrs={'units': 'm'})\n", " h5.create_dataset('y', data=[1, 2, 3, 4], make_scale=True, attrs={'units': 'm'})\n", - " h5.create_dataset('u', data=np.random.random((4, 3)), attach_scales=('y', 'x'))\n", - " h5.create_dataset('v', data=np.random.random((4, 3)), attach_scales=('y', 'x'))\n", + " h5.create_dataset('u', data=np.random.random((4, 3)), attach_scales=('y', 'x'),\n", + " attrs=dict(units='m/s', long_name='x vel'))\n", + " h5.create_dataset('v', data=np.random.random((4, 3)), attach_scales=('y', 'x'),\n", + " attrs=dict(units='m/s'))\n", " \n", " vec = h5.Vector(xvel='u', yvel='v')[1:3]\n", "vec" @@ -482,8 +493,8 @@ "id": "d3cddc5a-d646-4d20-a2ce-b024fa10e9c2", "metadata": {}, "source": [ - "### 2. Magnitude\n", - "This extension let's you compute the magnitude of given `xr.DataArray` objects, which goes well with the above extension:" + "## 2. Magnitude\n", + "Similar to `Vector`, the `Magnitude` accessory takes two or more datasets and calculates the magnitude from them. Again, data is only loaded after the involved dtasets are specified. If unit attributes are given, the calculation will check for mismatching units." ] }, { @@ -495,16 +506,90 @@ }, "outputs": [], "source": [ - "from h5rdmtoolbox.extensions import magnitude # automatically available when vetor is imported" + "from h5rdmtoolbox.extensions import magnitude" ] }, { "cell_type": "code", "execution_count": 5, + "id": "0700f532-2443-4ed0-8f78-697c5e42385a", + "metadata": {}, + "outputs": [], + "source": [ + "with h5tbx.File(h5.hdf_filename) as h5:\n", + " mag = h5.Magnitude('u', 'v', name='mag')[1:3, 0:2]" + ] + }, + { + "cell_type": "code", + "execution_count": 6, "id": "0f017c63-70c1-4007-9a55-6d5de6e3997b", "metadata": { "tags": [] }, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "mag.plot()" + ] + }, + { + "cell_type": "markdown", + "id": "fb9894f1-3e62-4199-9e20-0209ce1f5975", + "metadata": {}, + "source": [ + "## 3 Normalization\n", + "\n", + "Data is generally stored in one form (and physical unit) in the HDF5 file. However, in some scientific cases, data may be required in a normalized value.\n", + "\n", + "Consider the following example of a velocity dataset. The accessory `normalize` allows to normalize the data values or the coordinates.\n", + "\n", + "We will show two scenarios: Either the data values are normalized or the attached coordinates, too (or both)." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "8d4ed2f8-3e47-4534-aa11-8e51a09703c1", + "metadata": {}, + "outputs": [], + "source": [ + "from h5rdmtoolbox.extensions import normalize" + ] + }, + { + "cell_type": "markdown", + "id": "008c140e-2127-47de-81fe-c1559484fa47", + "metadata": {}, + "source": [ + "Normalize the data by various reference values, here `x_ref` and `phi`. Note, that a unit may be provided:" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "144da84f-5bd6-44d1-a24e-e55ebc4ecbae", + "metadata": {}, "outputs": [ { "data": { @@ -872,128 +957,474 @@ " stroke: currentColor;\n", " fill: currentColor;\n", "}\n", - "
<xarray.Dataset>\n",
-       "Dimensions:                 (y: 2, x: 3)\n",
-       "Coordinates:\n",
-       "  * y                       (y) int32 2 3\n",
-       "  * x                       (x) int32 1 2 3\n",
-       "Data variables:\n",
-       "    xvel                    (y, x) float64 0.03456 0.9389 ... 0.5039 0.8131\n",
-       "    yvel                    (y, x) float64 0.1247 0.3435 ... 0.6234 0.06209\n",
-       "    magnitude_of_xvel_yvel  (y, x) float64 0.1294 0.9998 ... 0.8016 0.8154
" + "
<xarray.DataArray 'x/x_ref/phi' ()>\n",
+       "0.3333\n",
+       "Attributes:\n",
+       "    units:    
" ], "text/plain": [ - "\n", - "Dimensions: (y: 2, x: 3)\n", - "Coordinates:\n", - " * y (y) int32 2 3\n", - " * x (x) int32 1 2 3\n", - "Data variables:\n", - " xvel (y, x) float64 0.03456 0.9389 ... 0.5039 0.8131\n", - " yvel (y, x) float64 0.1247 0.3435 ... 0.6234 0.06209\n", - " magnitude_of_xvel_yvel (y, x) float64 0.1294 0.9998 ... 0.8016 0.8154" + "\n", + "0.3333\n", + "Attributes:\n", + " units: " ] }, - "execution_count": 5, + "execution_count": 8, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "vec.magnitude.compute_from('xvel', 'yvel')" + "with h5tbx.File() as h5:\n", + " h5.create_dataset('x', data=[1, 2, 3], make_scale=True, attrs={'units': 'm'})\n", + " h5.create_dataset('y', data=[1, 2, 3, 4], make_scale=True, attrs={'units': 'm'})\n", + " h5.create_dataset('u', data=np.random.random((4, 3)), attach_scales=('y', 'x'))\n", + " h5.create_dataset('v', data=np.random.random((4, 3)), attach_scales=('y', 'x'))\n", + "\n", + " x_norm = h5.x.normalize(x_ref='2 m', phi=3)[1]\n", + "\n", + "x_norm" ] }, { "cell_type": "markdown", - "id": "fb9894f1-3e62-4199-9e20-0209ce1f5975", + "id": "fc22af39-e75b-4c05-b991-20af9a4616c0", "metadata": {}, "source": [ - "### 3 Normalization\n", - "Oftentimes, scientific plots show dimensionless data or in relation to another variable. The accessor `normalize` allows to normalize the data values or the coordinates." + "Now, let's normalize the velocity \"u\" **and its coordinate** x:" ] }, { "cell_type": "code", - "execution_count": 6, - "id": "af7129af-1ec4-4bee-9aad-52bea6d43791", - "metadata": { - "tags": [] - }, - "outputs": [], - "source": [ - "from h5rdmtoolbox.extensions import normalize\n", - "\n", - "import matplotlib.pyplot as plt" - ] - }, - { - "cell_type": "markdown", - "id": "d71b7238-6c62-499a-a593-f83b15e9e594", + "execution_count": 9, + "id": "a6b8c83e-9c97-475a-903d-3478ffd92eee", "metadata": {}, + "outputs": [], "source": [ - "### 3.1 Normalize array data\n", - "\n", - "In the below example, the `xvel` data is normalized by `v_ref=3.5 m/s`. Note, that the data is divided by 3.5 while considering the unit (`m/s`), so the resulting dataset (right plot) is dimensionless. Also note, that the **dataset name is changed** accordingly." + "with h5tbx.File(h5.hdf_filename) as h5:\n", + " u_norm = h5.u.normalize(u_ref='2 m/s', name='uu').x(x_ref='2 m', phi=3, name='epsilon').isel(y=0)" ] }, { "cell_type": "code", - "execution_count": 7, - "id": "be5f90b8-5bc0-4618-b74c-f6052ac28e1e", - "metadata": { - "tags": [] - }, + "execution_count": 10, + "id": "99ac8eff-1069-45c2-b943-e2efd3cec0f5", + "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "text/html": [ + "
\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "
<xarray.DataArray 'uu' (epsilon: 3)>\n",
+       "0.4201 0.2418 0.02388\n",
+       "Coordinates:\n",
+       "    y        int32 1\n",
+       "  * epsilon  (epsilon) float64 0.1667 0.3333 0.5\n",
+       "Attributes:\n",
+       "    units:    s/m
" + ], "text/plain": [ - "
" + "\n", + "0.4201 0.2418 0.02388\n", + "Coordinates:\n", + " y int32 1\n", + " * epsilon (epsilon) float64 0.1667 0.3333 0.5\n", + "Attributes:\n", + " units: s/m" ] }, + "execution_count": 10, "metadata": {}, - "output_type": "display_data" + "output_type": "execute_result" } ], "source": [ - "fig, axs = plt.subplots(1, 2, figsize=(8, 3))\n", - "\n", - "vec.xvel.plot(ax=axs[0])\n", - "# normalize ALL coordinates:\n", - "norm_vec = vec.xvel.normalize(v_ref='3.5 m/s', rename=True)\n", - "norm_vec.plot(ax=axs[1])\n", - "\n", - "axs[0].set_title('original')\n", - "axs[1].set_title('normalized data')\n", - "\n", - "plt.tight_layout()\n", - "plt.show()" - ] - }, - { - "cell_type": "markdown", - "id": "767048b8-7070-472d-86ef-6af53f044da7", - "metadata": {}, - "source": [ - "### 3.1 Normalize coordinates\n", - "\n", - "Now, let's normalize the coordinates with `L=100 mm`:" + "u_norm" ] }, { "cell_type": "code", - "execution_count": 8, - "id": "0adfb995-76c4-4cb5-b346-aa059dcc5a9e", + "execution_count": 11, + "id": "b3f9c0dc-e6e1-46ad-980f-dd120302b53b", "metadata": {}, "outputs": [ { "data": { - "image/png": "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", "text/plain": [ - "
" + "[]" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" ] }, "metadata": {}, @@ -1001,30 +1432,7 @@ } ], "source": [ - "fig, _axs = plt.subplots(2, 2, figsize=(6, 6),\n", - " tight_layout=True)\n", - "axs = _axs.ravel()\n", - "\n", - "vec.xvel.plot(ax=axs[0])\n", - "\n", - "norm_vec = vec.xvel.normalize.coords(L='100 mm', rename=True) # no units!\n", - "norm_vec.plot(ax=axs[1])\n", - "\n", - "norm_vec = vec.xvel.normalize.coords(x={'L': '100 mm'}, rename=True)\n", - "norm_vec.plot(ax=axs[2])\n", - "\n", - "norm_vec = vec.xvel.normalize.coords(y={'L': '100 mm'}, rename=True)\n", - "norm_vec.plot(ax=axs[3])\n", - "\n", - "axs[0].set_title('original')\n", - "axs[1].set_title('normalize all coords')\n", - "axs[2].set_title('normalize x-coord')\n", - "axs[3].set_title('normalize y-coord')\n", - "# for ax in axs:\n", - "# ax.set_aspect(1)\n", - "\n", - "plt.tight_layout()\n", - "plt.show()" + "u_norm.plot()" ] }, { @@ -1042,7 +1450,7 @@ }, { "cell_type": "code", - "execution_count": 18, + "execution_count": 12, "id": "e614bf4a-556b-44c0-ac00-11a5113e5cb1", "metadata": {}, "outputs": [], @@ -1052,7 +1460,7 @@ }, { "cell_type": "code", - "execution_count": 19, + "execution_count": 13, "id": "76cf75b0-3935-42ec-a3b6-0165db7d8264", "metadata": {}, "outputs": [ @@ -1427,7 +1835,7 @@ "Coordinates:\n", " * x (x) float64 -4.5e+03\n", "Attributes:\n", - " units: mm/s" + " units: mm/s" ], "text/plain": [ "\n", @@ -1438,7 +1846,7 @@ " units: mm/s" ] }, - "execution_count": 19, + "execution_count": 13, "metadata": {}, "output_type": "execute_result" } @@ -1458,13 +1866,14 @@ "id": "b7730172-11e8-47f0-93b1-9bc47aa0e1dd", "metadata": {}, "source": [ - "### Registration of datasets\n", - "We can also \"register\" dataset accessory. In the following example, we add \"device\" as a \"property with methods\". So \"device\" seems to be a property which has a method \"add\". Such an implementation facilitates the interaction with HDF data, too. Note, that this \"property-like\" accessory is available for all `Dataset` objects from now on in this session:" + "## Custom accessory\n", + "\n", + "Besides the already implemented ones, users can register custom accessories, too. In the following example, we add \"device\" as a \"property with methods\". So \"device\" appears as a property which has a method \"add\". Such an implementation facilitates the interaction with HDF data, too. Note, that this \"property-like\" accessory is available for all `Dataset` objects from now on in this session:" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 16, "id": "41f5c2c1-7de5-4e1c-b44e-4d350328f7ef", "metadata": {}, "outputs": [], @@ -1490,10 +1899,19 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 17, "id": "2af29af0-aa80-4887-bd6f-8c93d719f2e8", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "my device\n" + ] + } + ], "source": [ "with h5tbx.File() as h5:\n", " ds = h5.create_dataset('test', shape=(2,))\n", @@ -1501,6 +1919,14 @@ " ds.device.add('my device')\n", " print(ds.device.name)" ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "c569c3ff-aa88-4bf9-968f-5a3c210ac6b2", + "metadata": {}, + "outputs": [], + "source": [] } ], "metadata": { diff --git a/docs/userguide/wrapper/DatasetSlicing.ipynb b/docs/userguide/wrapper/DatasetSlicing.ipynb index 55a6754c..ea8d9f15 100644 --- a/docs/userguide/wrapper/DatasetSlicing.ipynb +++ b/docs/userguide/wrapper/DatasetSlicing.ipynb @@ -20,13 +20,6 @@ "id": "9fc2b312-16d5-4aa7-8f10-9107a2e53c08", "metadata": {}, "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Failed to import module h5tbx\n" - ] - }, { "data": { "text/plain": [ @@ -282,32 +275,32 @@ "\n", "
    \n", "
  • \n", - " \n", - "