From 2fc2729edf9ac274f68ecca4fece4ab78d537c21 Mon Sep 17 00:00:00 2001 From: vedina Date: Wed, 23 Nov 2022 10:55:47 +0200 Subject: [PATCH 1/4] hsds access example with a token --- examples/hsdsaccess_example.ipynb | 180 ++++++++++-------------------- 1 file changed, 61 insertions(+), 119 deletions(-) diff --git a/examples/hsdsaccess_example.ipynb b/examples/hsdsaccess_example.ipynb index c6a5d54a..ae972e9b 100644 --- a/examples/hsdsaccess_example.ipynb +++ b/examples/hsdsaccess_example.ipynb @@ -5,19 +5,59 @@ "metadata": {}, "source": [ "# Example how to access remote HDF5 files \n", - "-- at https://hsds-kc.ideaconsult.net\n", + "-- at https://hsds-kc.ideaconsult.net\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from keycloak import KeycloakOpenID\n", + "import h5pyd \n", + "class H5Wrapper:\n", + " def __init__(self,user,password):\n", + " self.tokens = H5Wrapper.get_token(user,password)\n", + "\n", + " @staticmethod\n", + " def get_token(user,password):\n", + " keycloak_openid = KeycloakOpenID(server_url=\"https://iam.ideaconsult.net/auth\",\n", + " client_id='idea-ui',\n", + " realm_name='nano',\n", + " client_secret_key='')\n", + "\n", + " token = keycloak_openid.token(user,password)\n", + " return token\n", "\n", - "```shell\n", - "# create .hscfg file with the following lines in your home folder\n", - "# for Windows it should be in C:\\Users\\{windows-username}\\.hscfg\n", - "# Set hs_username and hs_password to your CHARISMA database credentials\n", - "hs_endpoint = https://hsds-kc.ideaconsult.net\n", - "hs_username = your-username\n", - "hs_password = your-password\n", - "hs_keycloak_uri = https://iam.ideaconsult.net\n", - "hs_keycloak_client_id = solr-kc\n", - "hs_keycloak_realm = idea-test\n", - "```" + " def File(self,path,mode=\"r\",retries=3):\n", + " return h5pyd.File(path,mode=mode,retries=retries,api_key=self.tokens[\"access_token\"])\n", + "\n", + " def Folder(self,path):\n", + " return h5pyd.File(path,api_key=self.tokens[\"access_token\"]) " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import ipywidgets as widgets\n", + "from ipywidgets import interact, interactive, fixed, interact_manual\n", + "user_widget = widgets.Text(\n", + " value='',\n", + " placeholder='',\n", + " description='User:',\n", + " disabled=False\n", + ")\n", + "pass_widget = widgets.Password(\n", + " value='',\n", + " placeholder='',\n", + " description='Password:',\n", + " disabled=False\n", + ")\n", + "display(user_widget,pass_widget)" ] }, { @@ -26,9 +66,8 @@ "metadata": {}, "outputs": [], "source": [ - "#this cell is only to check if the .hscfg was set correctly ; uncomment print to do so\n", - "import h5pyd._apps.hsinfo as hsinfo\n", - "#print(hsinfo.cfg)" + "api_key = H5Wrapper.get_token(user_widget.value,pass_widget.value)\n", + "print(api_key[\"access_token\"])" ] }, { @@ -40,64 +79,9 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "annotation_sample \n", - "annotation_sample attribute sample Neon\n", - "annotation_study \n", - "annotation_study attribute instrument BWTek iRaman\n", - "annotation_study attribute investigation Round_Robin_1\n", - "annotation_study attribute laser_power \n", - "annotation_study attribute native_filename NeonSNQ043_iR532_Probe_stitched.csv\n", - "annotation_study attribute optical_path \n", - "annotation_study attribute provider FMNT-Madrid\n", - "annotation_study attribute wavelength 532\n", - "baseline_removed \n", - "baseline_removed attribute CHADA generated on Mon Aug 15 14:42:19 2022\n", - "baseline_removed attribute DIMENSION_LABELS ['Raman shift [1/cm]' 'raw counts [1]']\n", - "baseline_removed attribute Original file charisma_w_mxgm3a.csv\n", - "baseline_removed attribute Raman shift ['Dark Subtracted #1']\n", - "Dataset baseline_removed (2, 1800) 3600 2 float64\n", - "[[ 1.45990000e+02 1.48980000e+02 1.51980000e+02 ... 4.00582000e+03\n", - " 4.00731000e+03 4.00880000e+03]\n", - " [ 2.03990881e-02 3.47552553e-03 1.48592318e-02 ... -3.52250471e-03\n", - " 1.36033814e-02 1.52519105e-02]]\n", - "x [ 145.99 148.98 151.98 ... 4005.82 4007.31 4008.8 ]\n", - "y [ 0.02039909 0.00347553 0.01485923 ... -0.0035225 0.01360338\n", - " 0.01525191]\n", - "raw \n", - "raw attribute CHADA generated on Mon Aug 15 14:42:19 2022\n", - "raw attribute DIMENSION_LABELS [array(b'Raman shift [1/cm]', dtype='|S18')\n", - " array(b'raw counts [1]', dtype='|S14')]\n", - "raw attribute Original file charisma_w_mxgm3a.csv\n", - "raw attribute Raman shift ['Dark Subtracted #1']\n", - "Dataset raw (2, 1800) 3600 2 float64\n", - "[[ 1.45990e+02 1.48980e+02 1.51980e+02 ... 4.00582e+03 4.00731e+03\n", - " 4.00880e+03]\n", - " [ 8.45000e+05 1.50000e+04 5.75000e+05 ... -8.75000e+05 -4.00000e+04\n", - " 3.50000e+04]]\n", - "x [ 145.99 148.98 151.98 ... 4005.82 4007.31 4008.8 ]\n", - "y [ 845000. 15000. 575000. ... -875000. -40000. 35000.]\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "import h5pyd\n", "import matplotlib.pyplot as plt\n", @@ -105,7 +89,7 @@ "# This is a path to a remote h5 file, not a local path\n", "path = \"/Round_Robin_1/FMNT-Madrid/BWTek iRaman/532/NeonSNQ043_iR532_Probe_stitched.cha\"\n", "# example how to read the remote HDF5 files (without ramanchada1 or ramanchada2 dependencies)\n", - "with h5pyd.File(path) as f:\n", + "with h5pyd.File(path,api_key=api_key) as f:\n", " for key in f.keys():\n", " print(key, f[key])\n", " for a in f[key].attrs:\n", @@ -136,29 +120,6 @@ "## Example with ramanchada1" ] }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "from ramanchada.classes import RamanChada\n", - "# reads the raw dataset\n", - "R = RamanChada(path,raw=True,is_h5pyd=True)\n", - "R.plot()" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "#raw=False reads the latest processed dataset , i.e. baseline_removed in this case\n", - "R = RamanChada(path,raw=False,is_h5pyd=True)\n", - "R.plot()" - ] - }, { "cell_type": "markdown", "metadata": {}, @@ -174,7 +135,8 @@ "source": [ "from ramanchada2.io import HSDS\n", "\n", - "x, y, meta = HSDS.read_cha(path,dataset='/raw',h5module=h5pyd)\n", + "h5pyw = H5Wrapper(user_widget.value,pass_widget.value)\n", + "x, y, meta = HSDS.read_cha(path,dataset='/raw',h5module=h5pyw)\n", "#this is metadata from the native file, not the curated metadata from annotation_x groups as above\n", "print(meta)\n", "plt.plot(x,y)" @@ -188,7 +150,7 @@ "source": [ "from ramanchada2.io import HSDS\n", "\n", - "x, y, meta = HSDS.read_cha(path,dataset='/raw',h5module=h5pyd)\n", + "x, y, meta = HSDS.read_cha(path,dataset='/raw',h5module=h5pyw)\n", "#this is metadata from the native file, not the curated metadata from annotation_x groups as above\n", "print(meta)\n", "plt.plot(x,y)" @@ -203,7 +165,7 @@ "# example creating Spectrum class , reading raw dataset from a remote HDF5 file created by ramanchada2\n", "from ramanchada2.spectrum.creators.from_chada import from_chada\n", "\n", - "spe = from_chada(path,dataset=\"/raw\",h5module=h5pyd)\n", + "spe = from_chada(path,dataset=\"/raw\",h5module=h5pyw)\n", "spe.plot()\n", "\n" ] @@ -252,26 +214,6 @@ "spe = spe.normalize()\n", "spe.plot()" ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Read processed dataset example" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "# example creating Spectrum class , reading processed dataset from a remote HDF5 file created by ramanchada2\n", - "#throws an error ?\n", - "spe_processed = from_chada(path,dataset=\"/baseline_removed\",h5module=h5pyd)\n", - "print(spe_processed)\n", - "#spe.plot()" - ] } ], "metadata": { From 546b262f21bd46fa617a9a1c4b9f3ef47e13a2a3 Mon Sep 17 00:00:00 2001 From: vedina Date: Wed, 23 Nov 2022 12:01:35 +0200 Subject: [PATCH 2/4] hsds example notebook and pass the h5module in HSDS --- examples/hsdsaccess_example.ipynb | 123 +++++++++++++++++++++--------- src/ramanchada2/io/HSDS.py | 2 +- 2 files changed, 88 insertions(+), 37 deletions(-) diff --git a/examples/hsdsaccess_example.ipynb b/examples/hsdsaccess_example.ipynb index ae972e9b..845a25c2 100644 --- a/examples/hsdsaccess_example.ipynb +++ b/examples/hsdsaccess_example.ipynb @@ -34,7 +34,7 @@ " return h5pyd.File(path,mode=mode,retries=retries,api_key=self.tokens[\"access_token\"])\n", "\n", " def Folder(self,path):\n", - " return h5pyd.File(path,api_key=self.tokens[\"access_token\"]) " + " return h5pyd.Folder(path,api_key=self.tokens[\"access_token\"]) " ] }, { @@ -67,7 +67,7 @@ "outputs": [], "source": [ "api_key = H5Wrapper.get_token(user_widget.value,pass_widget.value)\n", - "print(api_key[\"access_token\"])" + "print(api_key[\"access_token\"][0:10])" ] }, { @@ -85,11 +85,24 @@ "source": [ "import h5pyd\n", "import matplotlib.pyplot as plt\n", + "with h5pyd.Folder(\"/\",api_key = api_key[\"access_token\"]) as f:\n", + " f._getSubdomains()\n", + " for domain in f._subdomains:\n", + " print(domain)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "\n", "\n", "# This is a path to a remote h5 file, not a local path\n", "path = \"/Round_Robin_1/FMNT-Madrid/BWTek iRaman/532/NeonSNQ043_iR532_Probe_stitched.cha\"\n", "# example how to read the remote HDF5 files (without ramanchada1 or ramanchada2 dependencies)\n", - "with h5pyd.File(path,api_key=api_key) as f:\n", + "with h5pyd.File(path,api_key=api_key[\"access_token\"]) as f:\n", " for key in f.keys():\n", " print(key, f[key])\n", " for a in f[key].attrs:\n", @@ -117,14 +130,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "## Example with ramanchada1" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Example with ramanchda2" + "## Example with ramanchada2" ] }, { @@ -142,20 +148,6 @@ "plt.plot(x,y)" ] }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "from ramanchada2.io import HSDS\n", - "\n", - "x, y, meta = HSDS.read_cha(path,dataset='/raw',h5module=h5pyw)\n", - "#this is metadata from the native file, not the curated metadata from annotation_x groups as above\n", - "print(meta)\n", - "plt.plot(x,y)" - ] - }, { "cell_type": "code", "execution_count": null, @@ -185,15 +177,48 @@ "source": [ "ss0 = spe - spe.moving_minimum(80)\n", "ss1 = spe - spe.moving_minimum(15)\n", - "fig, ax = plt.subplots(1, 2, figsize=(15, 5), tight_layout=True)\n", - "spe.plot(ax=ax[0], label='original')\n", - "ss0.plot(ax=ax[0], label='movmin(80)')\n", - "ss1.plot(ax=ax[0], label='movmin(15)')\n", + "fig, ax = plt.subplots(1, 1, figsize=(5,5), tight_layout=True)\n", + "spe.plot(ax=ax, label='original')\n", + "ss0.plot(ax=ax, label='movmin(80)')\n", + "ss1.plot(ax=ax, label='movmin(15)')\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "spe = spe.normalize()\n", + "spe.plot()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Explore HSDS content" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "def print_dataset(parentdomain,domain,h5module):\n", + " print(domain)\n", + " \n", "\n", - "#spe.plot(ax=ax[1], label='original')\n", - "ss0.plot(ax=ax[1], label='movmin(80)')\n", - "ss1.plot(ax=ax[1], label='movmin(15)')\n", - "ax[1].set_ylim(0, 8000)" + "h5pyw = H5Wrapper(user_widget.value,pass_widget.value)\n", + "HSDS.visit_domain(topdomain=\"/Round_Robin_1/\",process_dataset=print_dataset,h5module=h5pyw) " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Filter HSDS dataset" ] }, { @@ -202,7 +227,33 @@ "metadata": {}, "outputs": [], "source": [ - "### normalize" + "from ramanchada2.io.HSDS import visit_domain, read_cha\n", + "\n", + "def load_dataset(parentdomain,domain,h5module=h5pyw,results={}):\n", + " with h5module.File(domain) as f:\n", + " wavelength = f[\"annotation_study\"].attrs[\"wavelength\"]\n", + " sample = f[\"annotation_sample\"].attrs[\"sample\"]\n", + " spe = from_chada(domain,h5module=h5module)\n", + " spe.plot(label=sample)\n", + " spe = spe - spe.moving_minimum(16)\n", + " spe = spe.normalize()\n", + " results[domain] = (spe.x,spe.y,wavelength,sample)\n", + "\n", + "def filter_dataset(topdomain, domain, process_file, sample=None, wavelength=None, instrument=None,\n", + " provider=None, investigation=None, kwargs={}, h5module=None):\n", + " with h5module.File(domain) as dataset:\n", + " if sample is None:\n", + " process_file(topdomain, domain, h5module, **kwargs)\n", + " elif (sample is not None) and (dataset[\"annotation_sample\"].attrs[\"sample\"] == sample):\n", + " process_file(topdomain, domain, h5module, **kwargs)\n", + " \n", + "\n", + "\n", + "h5pyw = H5Wrapper(user_widget.value,pass_widget.value)\n", + "results = {}\n", + "HSDS.visit_domain(\"/TEST/FraunhoferLBF/\",\n", + " process_dataset=filter_dataset,kwargs={\"process_file\" : load_dataset,\"sample\": None, \n", + " \"kwargs\" : {\"results\" : results}},h5module=h5pyw) " ] }, { @@ -211,8 +262,8 @@ "metadata": {}, "outputs": [], "source": [ - "spe = spe.normalize()\n", - "spe.plot()" + "for domain in results:\n", + " print(domain)" ] } ], diff --git a/src/ramanchada2/io/HSDS.py b/src/ramanchada2/io/HSDS.py index 6ba41a45..cfe9fee8 100644 --- a/src/ramanchada2/io/HSDS.py +++ b/src/ramanchada2/io/HSDS.py @@ -48,7 +48,7 @@ def filter_dataset(topdomain, domain, process_file, sample=None, wavelength=None _h5 = h5module or h5py with _h5.File(domain) as dataset: if (sample is not None) and (dataset["annotation_sample"].attrs["sample"] == sample): - process_file(topdomain, domain, **kwargs) + process_file(topdomain, domain, **kwargs,h5module) def visit_domain(topdomain="/", process_dataset=None, kwargs={}, h5module=None): From 6a1891031b12e9ef6633f030f26f362cd1f1293e Mon Sep 17 00:00:00 2001 From: vedina Date: Wed, 23 Nov 2022 12:02:33 +0200 Subject: [PATCH 3/4] remove redundant examples --- examples/hsds_search.ipynb | 145 ---------------- examples/hsdsprocessing_example.ipynb | 237 -------------------------- 2 files changed, 382 deletions(-) delete mode 100644 examples/hsds_search.ipynb delete mode 100644 examples/hsdsprocessing_example.ipynb diff --git a/examples/hsds_search.ipynb b/examples/hsds_search.ipynb deleted file mode 100644 index ba1ad362..00000000 --- a/examples/hsds_search.ipynb +++ /dev/null @@ -1,145 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "from ramanchada2.io.HSDS import visit_domain, filter_dataset, read_cha\n", - "import h5pyd\n", - "import numpy as np\n", - "from scipy.interpolate import interp1d\n", - "import matplotlib.pyplot as plt" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "from ramanchada2.spectrum import from_chada\n", - "import math\n", - "\n", - "\n", - "def load_dataset(parentdomain,domain,results={}):\n", - " with h5pyd.File(domain) as f:\n", - " wavelength = f[\"annotation_study\"].attrs[\"wavelength\"]\n", - " sample = f[\"annotation_sample\"].attrs[\"sample\"]\n", - " spe = from_chada(domain,h5module=h5pyd)\n", - " spe = spe - spe.moving_minimum(16)\n", - " spe = spe.normalize()\n", - " results[domain] = (spe.x,spe.y,wavelength,sample)\n", - "\n", - "query_sample = \"PST\"\n", - "\n", - "#visit_domain(topdomain=\"/Round_Robin_1/\",process_dataset=print_dataset) \n", - "results = {}\n", - "visit_domain(\"/Round_Robin_1/\",\n", - " process_dataset=filter_dataset,kwargs={\"process_file\" : load_dataset,\"sample\": query_sample, \n", - " \"kwargs\" : {\"results\" : results}})" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "def ramanshift2wavelength(shift,laser):\n", - " return 1/((1/laser)-shift/10**7)\n", - "def wavelength2ramanshift(wavelength,laser):\n", - " return 10**7/laser-10**7/wavelength \n", - "\n", - "domain_len = 1024+2048\n", - "print(domain_len)\n", - "xnew0 = np.arange(0,domain_len,1)\n", - "for lex in (532,633,785):\n", - " xw = ramanshift2wavelength(xnew0,lex)\n", - " #print(xw,min(xw),max(xw),len(xw))\n", - "\n", - "for laser in (532,633,785):\n", - " max_vw = ramanshift2wavelength(4000,laser)\n", - " xw = np.arange(laser,math.ceil(max_vw),(max_vw-laser)/domain_len)\n", - " print(\"nm\",laser,max_vw,len(xw),(max_vw-laser)/domain_len)\n", - " x = wavelength2ramanshift(xw,laser)\n", - " ax = plt.plot(xw,x,marker='o',label=laser)\n", - " plt.ylabel('Raman shift, cm-1')\n", - " plt.xlabel('wavelength, nm')\n", - "plt.legend()\n", - "plt.show()" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "from matplotlib.pyplot import figure\n", - "\n", - "plt.figure(figsize=(1,1))\n", - "\n", - "\n", - "def spectrum_interpolate(x,y, newx):\n", - " f = interp1d(x, y)\n", - " xmin = np.where(newx>=min(x))\n", - " xmax = np.where(newx<=max(x)) \n", - " #returns a tuple , if empty, then max(spe.x) is beyond the new x\n", - " xmax = xmax[0][len(xmax[0])-1] if len(xmax[0]>0) else len(newx)\n", - " xmin = xmin[0][0] if len(xmin[0]>0) else 0\n", - " newy = np.zeros(len(newx))\n", - " newy[xmin:(xmax+1)] = f(newx[xmin:(xmax+1)]) \n", - " return newy\n", - "\n", - "domain_len=2048\n", - "offset = 100\n", - "\n", - "\n", - "ff, (ax2) = plt.subplots(1, 1, sharey=True)\n", - "#just for fun if we want more than one vector\n", - "_x0=np.linspace(offset,2000,domain_len)\n", - "_x1=np.linspace(2000,4000,domain_len)\n", - "for domain in results:\n", - " x,y,wavelength,sample = results[domain]\n", - " f = interp1d(x, y)\n", - " wavelength = int(wavelength)\n", - " _y0 = spectrum_interpolate(x,y,_x0)\n", - " _y1 = spectrum_interpolate(x,y,_x1)\n", - " plt.plot(x,y, 'x')\n", - " plt.plot(_x0,_y0, '-')\n", - " plt.plot(_x1,_y1, 'x')\n", - " plt.suptitle(domain)\n", - " plt.show()" - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3.9.13 ('charisma')", - "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.9.13" - }, - "orig_nbformat": 4, - "vscode": { - "interpreter": { - "hash": "fb04d3982f35e0acdef77e55e8b663fd61d1c7b237bd8280d18cbffb390c1e7d" - } - } - }, - "nbformat": 4, - "nbformat_minor": 2 -} diff --git a/examples/hsdsprocessing_example.ipynb b/examples/hsdsprocessing_example.ipynb deleted file mode 100644 index 9cd1f578..00000000 --- a/examples/hsdsprocessing_example.ipynb +++ /dev/null @@ -1,237 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Example\n", - "\n", - "- check if .hscfg file in your home folder is correctly configured (see hsdsaccess_example.ipynb)\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "import h5pyd\n", - "\n", - "def print_dataset(parentdomain,domain):\n", - " print(parentdomain,domain)\n", - "\n", - "def visit_domain(topdomain=\"/Round_Robin_1/\",process_dataset=None,kwargs={}):\n", - " if topdomain.endswith(\"/\"):\n", - " with h5pyd.Folder(topdomain) as domain:\n", - " n = domain._getSubdomains()\n", - " for domain in domain._subdomains:\n", - " #print(domain)\n", - " if domain[\"class\"]==\"folder\":\n", - " visit_domain(\"{}/\".format(domain[\"name\"]),process_dataset,kwargs)\n", - " else:\n", - " if process_dataset == None:\n", - " print_dataset(topdomain,domain[\"name\"])\n", - " else:\n", - " process_dataset(topdomain,domain[\"name\"],**kwargs)\n", - " else:\n", - " if process_dataset == None:\n", - " print_dataset(None,topdomain)\n", - " else:\n", - " process_dataset(None,topdomain,**kwargs) \n", - "\n", - "visit_domain(topdomain=\"/Round_Robin_1/\",process_dataset=print_dataset) " - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "import matplotlib.pyplot as plt\n", - "\n", - "def filter_dataset(topdomain,domain,process_file,sample=None,wavelength=None,instrument=None,provider=None,investigation=None):\n", - " with h5pyd.File(domain) as dataset:\n", - " if (sample != None) and (dataset[\"annotation_sample\"].attrs[\"sample\"] == sample):\n", - " process_file(topdomain,domain)\n", - "\n", - "def plot_dataset(topdomain,domain):\n", - " print_dataset(topdomain,domain)\n", - " with h5pyd.File(domain) as f: \n", - " dset = f[\"raw\"]\n", - " plt.plot(dset[0],dset[1])\n", - " plt.xlabel(dset.dims[0].label)\n", - " plt.ylabel(dset.dims[1].label)\n", - " sample = f[\"annotation_sample\"].attrs[\"sample\"]\n", - " instrument = f[\"annotation_study\"].attrs[\"instrument\"]\n", - " wavelength = f[\"annotation_study\"].attrs[\"wavelength\"]\n", - " partner = f[\"annotation_study\"].attrs[\"provider\"]\n", - " investigation = f[\"annotation_study\"].attrs[\"investigation\"]\n", - " plt.suptitle(\"{} ({},{}nm) by {} [{}]\".format(sample, instrument, wavelength, partner, investigation)) \n", - "\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "query_sample=\"S0N\"\n", - "query_sample=\"Neon\"" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "visit_domain(\"/Round_Robin_1/FMNT-Madrid/\",\n", - " process_dataset=filter_dataset,kwargs={\"process_file\" : plot_dataset,\"sample\": query_sample})" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "import ramanchada2 as rc2\n", - "test = \"/Round_Robin_1/ICV-CSIC/Zolix Finder Edge/785/PST02_Zolix785_Probe_100_190ms.cha\"\n", - "test = \"/Round_Robin_1/ICV-CSIC/Zolix Finder Edge/785/Ne_785nm_Zolix_6ms_v2.cha\"\n", - "test = \"/Round_Robin_1/FMNT-Madrid/BWTek iRaman/532/S0N10_iR532_Probe_100_30000msx3.cha\"\n", - "spe = rc2.spectrum.from_chada(test,h5module=h5pyd)\n", - "spe.plot()" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "import pandas as pd\n", - "def find_peaks(topdomain,domain,results={}):\n", - " spe = rc2.spectrum.from_chada(domain,h5module=h5pyd)\n", - " spe = spe.normalize()\n", - " kw_sharpening = dict(filter_fraction=1, sig_width=.4, der2_factor=0, der4_factor=.1)\n", - " #kw_sharpening = dict(filter_fraction=.6, sig_width=.5, der2_factor=1, der4_factor=.1)\n", - " #sharpened = spe.subtract_moving_minimum(60).normalize().derivative_sharpening(**kw_sharpening) \n", - " peak_candidates = spe.find_peak_groups(\n", - " prominence=.005,\n", - " wlen=40,\n", - " width=1,\n", - " n_sigma_group=1.5,\n", - " moving_minimum_window=40,\n", - " kw_derivative_sharpening=kw_sharpening) \n", - " fit_res = spe.fit_peak_groups(model='Voigt', peak_candidate_groups=peak_candidates) \n", - " results[domain] = fit_res \n", - " " - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "results = {}\n", - "visit_domain(test,\n", - " process_dataset=find_peaks,kwargs={\"results\": results})" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "df = None\n", - "for domain in results:\n", - " fit_res = results[domain]\n", - " tmp= pd.DataFrame(\n", - " [\n", - " dict(name=f'g{group:02d}_{key}', value=val.value, stderr=val.stderr)\n", - " for group, res in enumerate(fit_res)\n", - " for key, val in res.params.items()\n", - " ]\n", - " )\n", - " tmp[\"source\"]=domain\n", - " if df == None:\n", - " df = tmp\n", - " else:\n", - " df = pd.concat([df, tmp]) \n", - "df[['group', 'model', 'param']]=df[\"name\"].str.split(\"_\", expand=True) \n", - "display(df) " - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "pd.set_option('display.max_rows', None)\n", - "import plotly.express as px\n", - "import numpy as np\n", - "_filter = df[\"model\"]!=\"bl\"\n", - "table = pd.pivot_table(df.loc[_filter], values=['value','stderr'], index=['source','group', 'model'],columns=['param'],\n", - " aggfunc={'value': np.mean, 'stderr' : np.mean}).reset_index()\n", - "table.columns = [' '.join(col).strip() for col in table.columns.values]\n", - "table_stats = table.describe() \n", - "table_stats\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "_filter1 = table[\"value amplitude\"] > table_stats.iloc[6][\"value amplitude\"]\n", - "_filter2 = table[\"value height\"] > table_stats.iloc[6][\"value height\"]\n", - "table_filtered = table.loc[_filter1 & _filter2]\n", - "fig = px.scatter(table_filtered, x=\"value center\", y=\"stderr center\")\n", - "fig.show()\n", - "display(table_filtered)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "#PST_peaks = (621,795,1001,1031,1155,1450,1583,1602)" - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3.9.13 ('charisma')", - "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.9.13" - }, - "orig_nbformat": 4, - "vscode": { - "interpreter": { - "hash": "fb04d3982f35e0acdef77e55e8b663fd61d1c7b237bd8280d18cbffb390c1e7d" - } - } - }, - "nbformat": 4, - "nbformat_minor": 2 -} From e6fcd22799b33f97b7ca2fffe5dcf45c418e5b7b Mon Sep 17 00:00:00 2001 From: Luchesar ILIEV Date: Wed, 23 Nov 2022 12:47:21 +0200 Subject: [PATCH 4/4] style: fix arguments order --- src/ramanchada2/io/HSDS.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/ramanchada2/io/HSDS.py b/src/ramanchada2/io/HSDS.py index cfe9fee8..7e2e6e15 100644 --- a/src/ramanchada2/io/HSDS.py +++ b/src/ramanchada2/io/HSDS.py @@ -48,7 +48,7 @@ def filter_dataset(topdomain, domain, process_file, sample=None, wavelength=None _h5 = h5module or h5py with _h5.File(domain) as dataset: if (sample is not None) and (dataset["annotation_sample"].attrs["sample"] == sample): - process_file(topdomain, domain, **kwargs,h5module) + process_file(topdomain, domain, h5module, **kwargs) def visit_domain(topdomain="/", process_dataset=None, kwargs={}, h5module=None):