From 79ad58d12bab210a9c60dd8c2ad3de32e23d5bef Mon Sep 17 00:00:00 2001 From: mjt320 Date: Fri, 22 Apr 2022 18:16:32 +0100 Subject: [PATCH 1/3] add notebook for enh->conc --- .idea/SEPAL.iml | 1 + .idea/other.xml | 7 ++ demo/demo_aif_module.ipynb | 121 ++++++++++++++---- demo/demo_conc_to_enh.ipynb | 100 --------------- demo/demo_enh_to_conc.ipynb | 242 ++++++++++++++++++++++++++++++++++++ 5 files changed, 350 insertions(+), 121 deletions(-) create mode 100644 .idea/other.xml delete mode 100644 demo/demo_conc_to_enh.ipynb create mode 100644 demo/demo_enh_to_conc.ipynb diff --git a/.idea/SEPAL.iml b/.idea/SEPAL.iml index d49a298..4606b2f 100644 --- a/.idea/SEPAL.iml +++ b/.idea/SEPAL.iml @@ -11,5 +11,6 @@ \ No newline at end of file diff --git a/.idea/other.xml b/.idea/other.xml new file mode 100644 index 0000000..640fd80 --- /dev/null +++ b/.idea/other.xml @@ -0,0 +1,7 @@ + + + + + \ No newline at end of file diff --git a/demo/demo_aif_module.ipynb b/demo/demo_aif_module.ipynb index 8fcecee..4a23fa7 100644 --- a/demo/demo_aif_module.ipynb +++ b/demo/demo_aif_module.ipynb @@ -3,7 +3,11 @@ { "cell_type": "markdown", "id": "eb332c7d-4589-47da-81d0-e2697ee70254", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "## AIF module demo" ] @@ -11,7 +15,11 @@ { "cell_type": "markdown", "id": "4276273d-31f5-4625-bfc8-9018b7cd984d", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "### Import modules" ] @@ -21,7 +29,10 @@ "execution_count": 2, "id": "42671502-6096-4107-8c21-3f876b950a66", "metadata": { - "tags": [] + "tags": [], + "pycharm": { + "name": "#%%\n" + } }, "outputs": [ { @@ -46,7 +57,11 @@ { "cell_type": "markdown", "id": "0c2eae34-da30-465b-9b23-3dbadd7dc0d8", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "### The AIF Class\n", "AIF objects define an arterial input function. This can either be a population average function or an AIF based on individual patient measurements." @@ -55,7 +70,11 @@ { "cell_type": "markdown", "id": "reported-projector", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "### Classic Parker AIF\n", "Create a Parker AIF object of the Parker subclass of AIF:" @@ -65,7 +84,11 @@ "cell_type": "code", "execution_count": 3, "id": "4f59a6a6-69b0-4f28-a4a1-03b0b846f6e8", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [], "source": [ "parker_aif = aifs.Parker(hct=0.42)" @@ -74,7 +97,11 @@ { "cell_type": "markdown", "id": "f9a0f8e5-ddd6-4164-a4df-7f50a3af82eb", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "We can use the c_ap method to get concentration at arbitrary time points:" ] @@ -83,7 +110,11 @@ "cell_type": "code", "execution_count": 4, "id": "f65ca4cc-58d3-422a-822b-6c52cd9328c9", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [ { "data": { @@ -110,7 +141,11 @@ { "cell_type": "markdown", "id": "electoral-tamil", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "### Patient-specific AIF\n", "Now we create an individual AIF object based on a series of time-concentration data points. We use the PatientSpecific subclass of AIF." @@ -120,7 +155,11 @@ "cell_type": "code", "execution_count": 5, "id": "2d0a1c5b-7972-4be9-aa1b-9029e5645685", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [], "source": [ "t_patient = np.array([19.810000,59.430000,99.050000,138.670000,178.290000,217.910000,257.530000,297.150000,336.770000,376.390000,416.010000,455.630000,495.250000,534.870000,574.490000,614.110000,653.730000,693.350000,732.970000,772.590000,812.210000,851.830000,891.450000,931.070000,970.690000,1010.310000,1049.930000,1089.550000,1129.170000,1168.790000,1208.410000,1248.030000])\n", @@ -132,7 +171,11 @@ { "cell_type": "markdown", "id": "9a03a459-93d7-4779-9709-6389bf265024", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "Again, using the c_ap method we can get concentration at arbitrary time points. This is achieved using interpolation function." ] @@ -141,7 +184,11 @@ "cell_type": "code", "execution_count": 6, "id": "c9d16286-d0df-4ab8-b918-4486652200f0", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [ { "data": { @@ -176,7 +223,11 @@ { "cell_type": "markdown", "id": "d30c7325-3453-4e38-a869-7439ed256437", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "### Other standard AIF functions\n", "The following function is described in Manning et al., Magn Reson Med. 2021;86:1888–1903. \n", @@ -188,7 +239,11 @@ "cell_type": "code", "execution_count": 7, "id": "e7274fdd-ef51-40fd-8ce9-d1b2820aa37e", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [], "source": [ "manning_fast_aif = aifs.ManningFast(hct=0.42, t_start=3*39.62)" @@ -197,7 +252,11 @@ { "cell_type": "markdown", "id": "83da4ffa-24c2-4e24-b1ec-30ed89a823c2", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "Manning et al. also reports an AIF for *slow* contrast injections in the same patient population, based on patient measurements:" ] @@ -206,7 +265,11 @@ "cell_type": "code", "execution_count": 8, "id": "a9cd6fa3-3347-4c4d-9cc4-da0d2d027c69", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [], "source": [ "manning_slow_aif = aifs.ManningSlow()" @@ -215,7 +278,11 @@ { "cell_type": "markdown", "id": "f3d27241-b579-4b38-9ecd-1658184e6253", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "A similar population average function (for Bolus injection) was reported in Heye et al., NeuroImage 2016;125:446-455:" ] @@ -224,7 +291,11 @@ "cell_type": "code", "execution_count": 9, "id": "a3fb3120-0b2c-420b-9e1f-0625ab9a4fff", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [], "source": [ "heye_aif = aifs.Heye(hct=0.45, t_start=3*39.62)" @@ -233,7 +304,11 @@ { "cell_type": "markdown", "id": "65d7c712-3ef0-4f87-a7b1-2dfa03c0e45d", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "Plot the above AIFs (and the original Parker model) for comparison:" ] @@ -242,7 +317,11 @@ "cell_type": "code", "execution_count": 11, "id": "f7d24797-32ac-467d-8ea8-66b24079fa49", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [ { "data": { @@ -293,4 +372,4 @@ }, "nbformat": 4, "nbformat_minor": 5 -} +} \ No newline at end of file diff --git a/demo/demo_conc_to_enh.ipynb b/demo/demo_conc_to_enh.ipynb deleted file mode 100644 index 0d467fc..0000000 --- a/demo/demo_conc_to_enh.ipynb +++ /dev/null @@ -1,100 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": 34, - "id": "3b2d4aa7-5b11-44fc-ad48-069caaeab47a", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "The autoreload extension is already loaded. To reload it, use:\n", - " %reload_ext autoreload\n" - ] - } - ], - "source": [ - "import sys\n", - "import matplotlib.pyplot as plt\n", - "import numpy as np\n", - "sys.path.append('../src')\n", - "import dce_fit, relaxivity, signal_models, water_ex_models, aifs, pk_models\n", - "%load_ext autoreload\n", - "%autoreload 2" - ] - }, - { - "cell_type": "code", - "execution_count": 41, - "id": "9439e538-cdd8-4849-bedf-1ead532f0811", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "[,\n", - " ]" - ] - }, - "execution_count": 41, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "r1, r2 = 5.0, 0\n", - "tr, fa, te = 3.4e-3, 15, 1.7e-3\n", - "t10 = 2\n", - "k_fa = 1.4\n", - "\n", - "enh = np.arange(3000)\n", - "\n", - "c_to_r_model = relaxivity.CRLinear(r1, r2)\n", - "signal_model = signal_models.SPGR(tr, fa, te)\n", - "e_to_c_num = dce_fit.EnhToConc(c_to_r_model, signal_model)\n", - "C_t_num = e_to_c_num.proc(enh, t10, k_fa)\n", - "\n", - "e_to_c_ana = dce_fit.EnhToConcSPGR(tr, fa, r1)\n", - "C_t_ana = e_to_c_ana.proc(enh, t10, k_fa)\n", - "\n", - "plt.plot(enh, C_t_num, 'k-',\n", - " enh, C_t_ana, 'r-')" - ] - } - ], - "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.8.8" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} diff --git a/demo/demo_enh_to_conc.ipynb b/demo/demo_enh_to_conc.ipynb new file mode 100644 index 0000000..6fdef46 --- /dev/null +++ b/demo/demo_enh_to_conc.ipynb @@ -0,0 +1,242 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "source": [ + "## Enhancement to concentration" + ], + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%% md\n" + } + } + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "3b2d4aa7-5b11-44fc-ad48-069caaeab47a", + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The autoreload extension is already loaded. To reload it, use:\n", + " %reload_ext autoreload\n" + ] + } + ], + "source": [ + "import sys\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "sys.path.append('../src')\n", + "import dce_fit, relaxivity, signal_models, aifs\n", + "%load_ext autoreload\n", + "%autoreload 2" + ] + }, + { + "cell_type": "markdown", + "source": [ + "### Set parameters" + ], + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%% md\n" + } + } + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "9439e538-cdd8-4849-bedf-1ead532f0811", + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [], + "source": [ + "r1, r2 = 5.0, 0\n", + "tr, fa, te = 3.4e-3, 15, 1.7e-3\n", + "t10 = 2\n", + "k_fa = 1.0\n", + "c_to_r_model = relaxivity.CRLinear(r1, r2)\n", + "signal_model = signal_models.SPGR(tr, fa, te)" + ] + }, + { + "cell_type": "markdown", + "source": [ + "Plot enh vs. concentration:" + ], + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%% md\n" + } + } + }, + { + "cell_type": "code", + "execution_count": 37, + "outputs": [ + { + "data": { + "text/plain": "[]" + }, + "execution_count": 37, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "text/plain": "
", + "image/png": "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\n" + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "conc_range = np.arange(-3, -2, 0.005)\n", + "enh = dce_fit.conc_to_enh(conc_range, t10, k_fa, c_to_r_model, signal_model)\n", + "plt.plot(conc_range, enh)" + ], + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%%\n" + } + } + }, + { + "cell_type": "markdown", + "source": [ + "First use the general method to convert enhancement to concentration.\n", + "This uses a numerical method to estimate concentration.\n", + "Accounts for pulse sequence and T2* dephasing." + ], + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%% md\n" + } + } + }, + { + "cell_type": "code", + "execution_count": null, + "outputs": [], + "source": [ + "c_to_r_model = relaxivity.CRLinear(r1, r2)\n", + "signal_model = signal_models.SPGR(tr, fa, te)\n", + "e_to_c_general = dce_fit.EnhToConc(c_to_r_model, signal_model)" + ], + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%%\n" + } + } + }, + { + "cell_type": "markdown", + "source": [ + "Now use the analytical method.\n", + "This assumes the SPGR pulse sequence.\n", + "It does not account for T2* dephasing." + ], + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%% md\n" + } + } + }, + { + "cell_type": "code", + "execution_count": 51, + "outputs": [ + { + "data": { + "text/plain": "
", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXcAAAD4CAYAAAAXUaZHAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8QVMy6AAAACXBIWXMAAAsTAAALEwEAmpwYAAAaR0lEQVR4nO3dfZAc9X3n8fd3ZvaB1Wr1uAihZ8lAeIgt8AbbZ0NIHAdM3RmT8wOcK+buuMi+mCq7knMdxFVnJzmnEifYuZTP9okzB0nZgG3MmSPYMeY4c+Ecw8oWQkIIJJDQsqvV6mkl7dPsTH/vj+7ZnV3N6mFne6an+byqpqb71w+/b2tmvvrtr3/dbe6OiIikS6beAYiIyNxTchcRSSEldxGRFFJyFxFJISV3EZEUytU7AIClS5f62rVr6x2GiEhD2bJlyyF376y0LBHJfe3atXR3d9c7DBGRhmJm+2Zapm4ZEZEUUnIXEUkhJXcRkRRSchcRSSEldxGRFFJyFxFJISV3EZEUUnIXEamT//HMa/z9tr5Y9q3kLiJSJ3/3s338aMeBWPat5C4iUieBOxbTvpXcRUTqxIFMTNldyV1EpE4Cd8ziye5K7iIideIOMeV2JXcRkXpxB4up113JXUSkTtxdfe4iImkTqFtGRCR9HCejE6oiIumilruISAqFo2XUchcRSRWv5xWqZnavmR00s+1lZQ+Z2dbotdfMtkbla81spGzZN2KKW0Sk4YVXqMaT3nNnsc59wFeBv50IyP2jpWkzuxsYLFt/j7tvnKP4RERSK7xCNZ59nzG5u/vTZra20jILO4s+AvzmHMclIpJ67vG13Kvtc78G6Hf3V8rK1pnZL83sp2Z2zUwbmtkmM+s2s+6BgYEqwxARaTyBe2z7rja53wo8UDbfB6x29yuBPwC+bWYdlTZ0983u3uXuXZ2dnVWGISLSgJLYcjezHPA7wEOlMncfc/fD0fQWYA9wcbVBioikUZx97tW03H8LeMnde0oFZtZpZtloej1wEfBqdSGKiKSTQ12HQj4A/Ay4xMx6zOz2aNEtTO2SAbgW2GZmzwPfAz7p7kfmMmARkbQoBk42pjuHnc1omVtnKP/XFcoeBh6uPiwRkfRzh0xMyV1XqIqI1ElRt/wVEUmfwJ1s0kbLiIjI7Lm7bhwmIpI2xSC8gCmuE6pK7iIidRDldiV3EZE0Kd16IIkXMYmIyCyVkrtOqIqIpEipzz1x95YREZHZK/W56yImEZEUCSZa7vHsX8ldRKQOJvrc1XIXEUmP4sRoGSV3EZHUKD2ESaNlRERSpKg+dxGR9JlI7upzFxFJD3XLiIikUOmEaiamLHw2j9m718wOmtn2srIvmNkbZrY1et1YtuwuM9ttZrvM7Pp4whYRaWyloZD1vEL1PuCGCuVfcfeN0etxADO7jPDZqpdH23yt9MBsERGZFNT79gPu/jRwtg+5vgl40N3H3P01YDdwdRXxiYikUpJv+XuHmW2Lum0WRWUrgP1l6/REZacws01m1m1m3QMDA1WEISLSeJI6FPLrwAZgI9AH3B2VVwrTK+3A3Te7e5e7d3V2ds4yDBGRxpSEPvdTuHu/uxfdPQDuYbLrpQdYVbbqSqC3uhBFRNInkcndzJaXzd4MlEbSPArcYmYtZrYOuAh4troQRUTSJ+4+99yZVjCzB4DrgKVm1gN8HrjOzDYSdrnsBT4B4O47zOw7wItAAfiUuxdjiVxEpIGV+tzjeszeGZO7u99aofibp1n/i8AXqwlKRCTtdMtfEZEUqvs4dxERmXvFJJ5QFRGR6niCL2ISEZFZSupFTCIiUoWJce5quYuIpEciL2ISEZHqFIphcs+p5S4ikh6FqM89l1VyFxFJjYnkHtOjmJTcRUTqoFAMAHXLiIikirplRERSaPKEqrplRERSoxhE3TJquYuIpMe4hkKKiKRPcaLPXd0yIiKpMR5otIyISOoU690tY2b3mtlBM9teVvaXZvaSmW0zs0fMbGFUvtbMRsxsa/T6RixRi4g0uPGg/k9iug+4YVrZE8AV7v5W4GXgrrJle9x9Y/T65NyEKSKSLsUgIJcxrF43DnP3p4Ej08p+7O6FaPafgJUxxCYiklqFosfWaoe56XP/t8APy+bXmdkvzeynZnbNTBuZ2SYz6zaz7oGBgTkIQ0SkcRQCj62/HapM7mb2OaAAfCsq6gNWu/uVwB8A3zazjkrbuvtmd+9y967Ozs5qwhARaTiFYhDbMEioIrmb2W3APwc+5h7edd7dx9z9cDS9BdgDXDwXgYqIpEkiW+5mdgPwH4EPuPtwWXmnmWWj6fXARcCrcxGoiEiaFIoe260HAHJnWsHMHgCuA5aaWQ/wecLRMS3AE9GZ3n+KRsZcC/yJmRWAIvBJdz9SccciIm9iYcs9vm6ZMyZ3d7+1QvE3Z1j3YeDhaoMSEUm7QhDE2nLXFaoiInVQCJI/FFJERM5Rseg0xdgto+QuIlIHhSBQy11EJG0KgdOkPncRkXRphNsPiIjIOcoXA5qSeIWqiIjM3lghoKUpG9v+ldxFROogXwhoVstdRCRd8oUiLTkldxGRVMkXA5qV3EVE0mVsPFDLXUQkbdRyFxFJIZ1QFRFJoXxBLXcRkVQpBk4hcFpyGucuIpIa+UIAoJa7iEiaJCK5m9m9ZnbQzLaXlS02syfM7JXofVHZsrvMbLeZ7TKz6+MKXESkUY0VigB1Hwp5H3DDtLI7gSfd/SLgyWgeM7sMuAW4PNrma6UHZouISGgsCS13d38amP6Q65uA+6Pp+4EPlpU/6O5j7v4asBu4em5CFRFJh3wxTO71brlXsszd+wCi9/Oj8hXA/rL1eqKyU5jZJjPrNrPugYGBWYYhItJ4JvrcG2ice6U7z3ulFd19s7t3uXtXZ2fnHIchIpJcpW6ZlqbkJfd+M1sOEL0fjMp7gFVl660EemcfnohI+ky23JM3zv1R4LZo+jbgB2Xlt5hZi5mtAy4Cnq0uRBGRdKnFUMjcmVYwsweA64ClZtYDfB74c+A7ZnY78DrwYQB332Fm3wFeBArAp9y9GFPsIiINqTQUsq7J3d1vnWHRe2dY/4vAF6sJSkQkzUbGw+Te1py8bhkREZml4XyY3M/TM1RFRNJjpJTc1XIXEUkPdcuIiKRQqVumVbf8FRFJj5F8gdamDJlMpes+54aSu4hIjQ3ni7Q1n3GwYlWU3EVEamxkvBjrSBlQchcRqbmRfDHWk6mg5C4iUnPD+WKswyBByV1EpOZG8uqWERFJnZFxdcuIiKTOcL6gbhkRkbQZGivS3qKhkCIiqXJidJz2lqZY61ByFxGpoWLgDOWLzG9Vy11EJDVOjhYAlNxFRNLk+Og4AB2t8XbLzPq/DjO7BHiorGg98J+AhcDvAQNR+R+5++OzrUdEJE1O1KjlPuu9u/suYCOAmWWBN4BHgH8DfMXd/2ouAhQRSZMTUct9fswt97nqlnkvsMfd983R/kREUunkWGP1ud8CPFA2f4eZbTOze81sUaUNzGyTmXWbWffAwEClVUREUqdW3TJVJ3czawY+AHw3Kvo6sIGwy6YPuLvSdu6+2d273L2rs7Oz2jBERBpCI3XLvB/4hbv3A7h7v7sX3T0A7gGunoM6RERS4XijtNyBWynrkjGz5WXLbga2z0EdIiKpcHx0nOZshpZcvCPRq/qvw8zagPcBnygr/pKZbQQc2DttmYjIm9rRoTyL5jVhFt/zU6HK5O7uw8CSaWW/W1VEIiIpdmRonEVtzbHXoytURURq6OhwniXtSu4iIqlyZCivlruISNocGcqzeJ6Su4hIahSKAYMj40ruIiJpcnQ4vIBJyV1EJEWODucB1OcuIpImR4bC5K6Wu4hIihw6OQYouYuIpMqBwVEALuhojb0uJXcRkRrpPz5Kcy7DwrZ47wgJSu4iIjXTf3yMCzpaY7+vDCi5i4jUzIHjozXpkgEldxGRmuk/PsqyBUruIiKp4e4cGBzlgo6WmtSn5C4iUgODI+OMFQKWqVtGRCQ99h8ZAWDloraa1KfkLiJSA/uODAGwZkltknu1j9nbC5wAikDB3bvMbDHwELCW8DF7H3H3o9WFKSLS2PYdHgZg1eLGabn/hrtvdPeuaP5O4El3vwh4MpoXEXlT239kmKXtzbS3VNWmPmtxdMvcBNwfTd8PfDCGOkREGsq+w8OsrlGrHapP7g782My2mNmmqGyZu/cBRO/nV9rQzDaZWbeZdQ8MDFQZhohIsr1+pLbJvdq/D97t7r1mdj7whJm9dLYbuvtmYDNAV1eXVxmHiEhijY4X6R0cYc2SlTWrs6qWu7v3Ru8HgUeAq4F+M1sOEL0frDZIEZFGtvvgSdzh4mXza1bnrJO7mc0zs/mlaeC3ge3Ao8Bt0Wq3AT+oNkgRkUb2cv8JAC65oL1mdVbTLbMMeCS6u1kO+La7/8jMngO+Y2a3A68DH64+TBGRxrWr/wTN2QxrlsyrWZ2zTu7u/irwtgrlh4H3VhOUiEiavHzgBOs759GUrd11o7pCVUQkZrsOnOCSC2rX3w5K7iIisTp4fJTewVF+dcWCmtar5C4iEqOt+48BsHHVwprWq+QuIhKj53uOkc0YV6jlLiKSHlv3H+NXLphPa1O2pvUquYuIxGS8GLD19WNctXpRzetWchcRicnz+48xlC/yzzYsqXndSu4iIjF5ZvdhzOBdSu4iIunxzO5DXHHhAha2Nde8biV3EZEYDI6M84vXj/LutyytS/1K7iIiMXjqpYMUAud9ly2rS/1K7iIiMfjh9j6WdbRwZY0vXipRchcRmWNDYwV++vIA119+AZmM1SUGJXcRkTn29y/0MToe8C/edmHdYlByFxGZYw89t58NnfPoWlP7i5dKlNxFRObQK/0n2LLvKLf82mqihxnVhZK7iMgcuuf/vkpLLsPvXLWirnFU8wzVVWb2lJntNLMdZvbpqPwLZvaGmW2NXjfOXbgiIsnVNzjCI798g4/+2iqWtLfUNZZqnqFaAP7Q3X8RPSh7i5k9ES37irv/VfXhiYg0jv/201cJHH7vmvX1DqWqZ6j2AX3R9Akz2wnU9+8QEZE6ee3QEN/6+T4+dNVKVi1uq3c4c9PnbmZrgSuBn0dFd5jZNjO718wqni42s01m1m1m3QMDA3MRhohI3fzZ4ztpzmb4w+svrncowBwkdzNrBx4GPuPux4GvAxuAjYQt+7srbefum929y927Ojs7qw1DRKRunnixnyde7Of3f+MtnD+/td7hAFUmdzNrIkzs33L37wO4e7+7F909AO4Brq4+TBGRZDo6lOeu77/Apcs7EtHXXlLNaBkDvgnsdPcvl5UvL1vtZmD77MMTEUmuIHA++73nGRzJ8+WPvI3mXHJGl1czWubdwO8CL5jZ1qjsj4BbzWwj4MBe4BNV1CEiklh//eQr/GTnQf74A5dz6fKOeoczRTWjZf4RqHT51eOzD0dEpDE8vKWHv3nyFT7StZKPv2tNvcM5RXL+hhARaRCPbevls997nve8ZSl/ctMVdb3NwEyU3EVEzsFDz73Opx/cytvXLGLzx99Oa1O23iFVVE2fu4jIm0YxcL7yxMt89andXHtxJ1/72FW0NSc3hSY3MhGRhDh4fJTPPLSV/7fnMB/tWsV/vvkKmrLJ7vhQchcRmYG784OtvfzpYy8ylC/wpX/5Vj7ctTKRfezTKbmLiFTwSv8J/vh/vcg/7j7E21Yt5C8/9FYuXja/3mGdNSV3EZEy+w4P8dc/eYX/ufUN2ptz/OlNl/Ov3rGGbJ2ehTpbSu4i8qbn7nTvO8p9z+zlRzsO0JQ1Nl2znk/8+gYWz2uud3izouQuIm9ah06O8djzvXx3Sw87eo/T0Zrj9ves49+9Zx3ndyTjBmCzpeQuIm8qAyfGeGrXQR7b1sczuw9RDJxLl3fwZzf/Kh+88sJED288F+k4ChGRGYwVirzQM8jTLw/w1K4BXnhjEIBVi8/j3//6Bj6w8cKGOlF6tpTcRSRVjgzleb7nGM+9doTuvUfZ2nOMfCEgY3DV6kV89vpLuO6STi5b3tEQQxpnS8ldRBpSMXB6jg6zs+84L/YeZ0fvcV7sO07f4CgAuYxx+YoFfPyda+hau5h3rFvMogY9OTobSu4iklhB4Bw6Ocbew8O8dugkrx4a4rWBIV47NMS+w8PkiwEA2YyxoXMe71y/hMuWd3D5ig6uXLWI85qTed+XWlByF5G6KAbO0eE8h06OcWBwlN5jo/QeG6H32AhvHBuhd3CEA4OjjBd9YpvmbIY1S9pYt3Qev3np+WxY2s6vLJ/PxcvmJ/YGXvWi5C4icyJfCBgcGWdwJB+9j3NkaJxDJ8c4dGIsfD+Zn3g/MjRG4FP3kc0YF3S0cuHCVq5avYjlC87jwoWtrF7cxvql7axYdF7DXUxUL0ruIm9y7s5wvshQvsDQWJGhsUL4yhc4OVZkeKzAybFw2fHR8YnEPTgyzuDw5PTIeHHGOlqbMixtb2FpewsrF7Vx5eqFE/NL2ptZvqCV5QvO4/z5LeQSfkOuRhFbcjezG4D/AmSB/+7ufx5XXSJp4+4UAme8GDA2HjBaKDKSLzIaTY+OF8Py8WI0H02XlU0sHy8yUrZsOB8m8JNjhYmk7n7mmADamrMsOK9p4rVmSduU+YVtTXSUzS+e18zS9hbamrOpHpmSRLEkdzPLAv8VeB/QAzxnZo+6+4tx1CcyXRCEybEYOIUgoBg448XTzxcCp1A8db4YBJP7ipaXluULAfliQL4QMF4MX2GZT0yXyscmpn2ifOq2k/sbLwZnnXArac5lOK8pS2tThtamLK25cLqlKUvn/BbWLGmjvSXHvJYc85qz4XtLjnktWeY152hvydHWkqO9JVzW1hyup1Z144ir5X41sNvdXwUwsweBm4CGTe7ujjsE7jjRu3NqWQCOE3i4Tem9tHxi3if3Udp+cv3SupN1lPY5WTatDirss7RdMLm/4pTpaJ+BU4zmPXovRvsuRsvcwxNg4TbT9hWtE0T7K01P7N+nbze13onpiboqxBBMbjs1MUfJtzg1mU/vy62FXMZozmVoyoavllyGpqzRlM1MlDdnw6Tb0ZqbKG+O1p/YNme0ZEvT4X5aS4k6l6W1eTJZh+Vly5qytOQyZNQv/aYXV3JfAewvm+8B3lG+gpltAjYBrF69elaVvHTgOHd8+5cVE28QjpCakiTDH/zUJHlKsuTUBFyPRJFkZpAxI2tGJkP4bkYmY2QzRqa0PFMqj9aJ5ienmVynbDqXzdCSi/YX7SucNrJZIxfV05TJTJ3PZshmJudzmXBf0+enrpMhlz39fLjvsvloeZjEo4SeUUKVZIkruVf6lk9Jke6+GdgM0NXVNav02ZrLcvGydixKLgYTiYVSUjAwwgQDk4nHyt4tKp8sKy1nYr9Wtk24btk+KNvXRJ2QyUT7onw7ppZlwvptWlxhnpisa8bjMsrKJuO2aXGVlmczRjYTLs9G8xYl1lMT8LQkHa2nvlOR5IsrufcAq8rmVwK9c13J2qXz+NrH3j7XuxURaXhxnR15DrjIzNaZWTNwC/BoTHWJiMg0sbTc3b1gZncA/0A4FPJed98RR10iInKq2Ma5u/vjwONx7V9ERGamQasiIimk5C4ikkJK7iIiKaTkLiKSQkruIiIpZF7N3YnmKgizAWBfFbtYChyao3DqKS3HATqWJErLcYCOpWSNu3dWWpCI5F4tM+t29656x1GttBwH6FiSKC3HATqWs6FuGRGRFFJyFxFJobQk9831DmCOpOU4QMeSRGk5DtCxnFEq+txFRGSqtLTcRUSkjJK7iEgKJT65m9mHzWyHmQVm1jVt2V1mttvMdpnZ9WXlbzezF6Jlf2PRo4PMrMXMHorKf25ma2t8OOWxf8HM3jCzrdHrxrJl53RcSWJmN0Rx7zazO+sdz9kws73Rv+tWM+uOyhab2RNm9kr0vqhs/YqfTz2Y2b1mdtDMtpeVnXPsSfhuzXAsDfc7MbNVZvaUme2Mcteno/Lafi4ePZA4qS/gUuAS4P8AXWXllwHPAy3AOmAPkI2WPQu8i/Bpdz8E3h+V/z7wjWj6FuChOh7XF4D/UKH8nI8rKS/Ce/fvAdYDzdFxXFbvuM4i7r3A0mllXwLujKbvBP7iTJ9PnWK/FrgK2F5N7En4bs1wLA33OwGWA1dF0/OBl6N4a/q5JL7l7u473X1XhUU3AQ+6+5i7vwbsBq42s+VAh7v/zMN/nb8FPli2zf3R9PeA9yaw9Tub40qKq4Hd7v6qu+eBBwmPpxGVf1fuZ+p36JTPp/bhhdz9aeDItOJzij0p360ZjmUmiT0Wd+9z919E0yeAncAKavy5JD65n8YKYH/ZfE9UtiKanl4+ZRt3LwCDwJLYI53ZHWa2LfpztPQn2myOKylmij3pHPixmW0xs01R2TJ374PwxwqcH5U3wjGea+xJ/2417O8k6vq9Evg5Nf5cEpHczewnZra9wut0rb5KLW4/TfnptonFGY7r68AGYCPQB9x9hhhrGvssNUKMlbzb3a8C3g98ysyuPc26jXqM0JjfrYb9nZhZO/Aw8Bl3P366VSuUVX0ssT1m71y4+2/NYrMeYFXZ/EqgNypfWaG8fJseM8sBCzj7PwPP2dkel5ndAzwWzc7muJJiptgTzd17o/eDZvYIYTdLv5ktd/e+6M/jg9HqjXCM5xp7Yr9b7t5fmm6k34mZNREm9m+5+/ej4pp+Lolouc/So8AtFo6AWQdcBDwb/blzwszeGfWnfxz4Qdk2t0XTHwL+d9SXVXPRh1tyM1AaITCb40qK54CLzGydmTUTnrR+tM4xnZaZzTOz+aVp4LcJP4vy78ptTP0OnfL51DbqMzqn2JP83WrE30lU7zeBne7+5bJFtf1cankWeZZnnm8m/B9sDOgH/qFs2ecIzyzvouwsMtBF+CXYA3yVyStxW4HvEp6weBZYX8fj+jvgBWBb9OEun+1xJekF3Eg4OmAP8Ll6x3MW8a4nHKnwPLCjFDPhuZgngVei98Vn+nzqFP8DhN0V49Hv5PbZxJ6E79YMx9JwvxPgPYTdJ9uArdHrxlp/Lrr9gIhICjVyt4yIiMxAyV1EJIWU3EVEUkjJXUQkhZTcRURSSMldRCSFlNxFRFLo/wOe0TOloksS9gAAAABJRU5ErkJggg==\n" + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "e_to_c_ana = dce_fit.EnhToConcSPGR(tr, fa, r1)\n", + "e_range = np.arange(-1000,2000,1.1)\n", + "C_t_ana = e_to_c_ana.proc(e_range, t10, k_fa=k_fa)\n", + "plt.plot(e_range, C_t_ana);\n" + ], + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%%\n" + } + } + }, + { + "cell_type": "code", + "execution_count": null, + "outputs": [], + "source": [ + "\n", + "enh = np.arange(3000)\n", + "\n", + "c_to_r_model = relaxivity.CRLinear(r1, r2)\n", + "signal_model = signal_models.SPGR(tr, fa, te)\n", + "e_to_c_num = dce_fit.EnhToConc(c_to_r_model, signal_model)\n", + "C_t_num = e_to_c_num.proc(enh, t10, k_fa)\n", + "\n", + "e_to_c_ana = dce_fit.EnhToConcSPGR(tr, fa, r1)\n", + "C_t_ana = e_to_c_ana.proc(enh, t10, k_fa)\n", + "\n", + "plt.plot(enh, C_t_num, 'k-',\n", + " enh, C_t_ana, 'r-')" + ], + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%%\n" + } + } + } + ], + "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.8.8" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} \ No newline at end of file From 5979d560d66bee95c67edf22f5c8d1c9372c8542 Mon Sep 17 00:00:00 2001 From: mjt320 Date: Tue, 22 Nov 2022 13:55:54 +0000 Subject: [PATCH 2/3] correct float32/float64 error --- src/dce_fit.py | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/src/dce_fit.py b/src/dce_fit.py index 4db5286..4b2adf6 100644 --- a/src/dce_fit.py +++ b/src/dce_fit.py @@ -23,9 +23,9 @@ import numpy as np from scipy.signal import argrelextrema from scipy.interpolate import interp1d -from fitting import Fitter -from pk_models import Patlak -from utils.utilities import least_squares_global +from .fitting import Fitter +from .pk_models import Patlak +from .utils.utilities import least_squares_global class SigToEnh(Fitter): @@ -63,7 +63,7 @@ def proc(self, s): s_pre = np.mean(s[self.base_idx]) if s_pre <= 0: raise ArithmeticError('Baseline signal is zero or negative.') - enh = np.empty(s.shape, dtype=np.float32) + enh = np.empty(s.shape, dtype=np.float64) enh[:] = 100. * ((s - s_pre) / s_pre) if s_pre > 0 else np.nan return enh From deb6fe17e228bce8bfac97b994fcb6881aa5e694 Mon Sep 17 00:00:00 2001 From: mjt320 Date: Tue, 22 Nov 2022 14:30:42 +0000 Subject: [PATCH 3/3] add enh_to_conc notebook --- demo/demo_enh_to_conc.ipynb | 130 +++++++++++++++++++++--------------- src/dce_fit.py | 6 +- 2 files changed, 79 insertions(+), 57 deletions(-) diff --git a/demo/demo_enh_to_conc.ipynb b/demo/demo_enh_to_conc.ipynb index 6fdef46..230cf48 100644 --- a/demo/demo_enh_to_conc.ipynb +++ b/demo/demo_enh_to_conc.ipynb @@ -3,7 +3,9 @@ { "cell_type": "markdown", "source": [ - "## Enhancement to concentration" + "## Enhancement to concentration\n", + "Demonstrate 2 classes for converting enhancement to concentration using analytical and numerical approaches.\n", + "### Imports" ], "metadata": { "collapsed": false, @@ -14,23 +16,14 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 1, "id": "3b2d4aa7-5b11-44fc-ad48-069caaeab47a", "metadata": { "pycharm": { "name": "#%%\n" } }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "The autoreload extension is already loaded. To reload it, use:\n", - " %reload_ext autoreload\n" - ] - } - ], + "outputs": [], "source": [ "import sys\n", "import matplotlib.pyplot as plt\n", @@ -44,7 +37,9 @@ { "cell_type": "markdown", "source": [ - "### Set parameters" + "### Setup\n", + "First define some parameters.\n", + "Then define concentration-relaxation and relaxation-signal relationships." ], "metadata": { "collapsed": false, @@ -55,7 +50,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 2, "id": "9439e538-cdd8-4849-bedf-1ead532f0811", "metadata": { "pycharm": { @@ -64,9 +59,9 @@ }, "outputs": [], "source": [ - "r1, r2 = 5.0, 0\n", - "tr, fa, te = 3.4e-3, 15, 1.7e-3\n", - "t10 = 2\n", + "r1, r2 = 5.0, 0 # /s/mM\n", + "tr, fa, te = 3.4e-3, 15, 1.7e-3 # s/deg\n", + "t10 = 2 # s\n", "k_fa = 1.0\n", "c_to_r_model = relaxivity.CRLinear(r1, r2)\n", "signal_model = signal_models.SPGR(tr, fa, te)" @@ -75,7 +70,7 @@ { "cell_type": "markdown", "source": [ - "Plot enh vs. concentration:" + "Calculate and plot the predicted enhancement for a range of concentrations." ], "metadata": { "collapsed": false, @@ -86,20 +81,12 @@ }, { "cell_type": "code", - "execution_count": 37, + "execution_count": 3, "outputs": [ - { - "data": { - "text/plain": "[]" - }, - "execution_count": 37, - "metadata": {}, - "output_type": "execute_result" - }, { "data": { "text/plain": "
", - "image/png": "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\n" + "image/png": "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\n" }, "metadata": { "needs_background": "light" @@ -108,9 +95,11 @@ } ], "source": [ - "conc_range = np.arange(-3, -2, 0.005)\n", + "conc_range = np.arange(-0.5, 12, 0.005) # mM\n", "enh = dce_fit.conc_to_enh(conc_range, t10, k_fa, c_to_r_model, signal_model)\n", - "plt.plot(conc_range, enh)" + "plt.plot(conc_range, enh)\n", + "plt.xlabel('C (mM)')\n", + "plt.ylabel('enhancement (%)');" ], "metadata": { "collapsed": false, @@ -122,6 +111,8 @@ { "cell_type": "markdown", "source": [ + "### Enhancement to concentration conversion\n", + "Now take these enhancments and go backwards to estimate concentration.\n", "First use the general method to convert enhancement to concentration.\n", "This uses a numerical method to estimate concentration.\n", "Accounts for pulse sequence and T2* dephasing." @@ -135,12 +126,27 @@ }, { "cell_type": "code", - "execution_count": null, - "outputs": [], + "execution_count": 4, + "outputs": [ + { + "data": { + "text/plain": "
", + "image/png": "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\n" + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], "source": [ "c_to_r_model = relaxivity.CRLinear(r1, r2)\n", "signal_model = signal_models.SPGR(tr, fa, te)\n", - "e_to_c_general = dce_fit.EnhToConc(c_to_r_model, signal_model)" + "e_to_c_num = dce_fit.EnhToConc(c_to_r_model, signal_model) # EnhToConc (numerical) object\n", + "C_t_num = e_to_c_num.proc(enh, t10, k_fa=k_fa) # mM\n", + "plt.plot(enh, C_t_num)\n", + "plt.xlabel('enhancement (%)')\n", + "plt.ylabel('C (mM)');" ], "metadata": { "collapsed": false, @@ -165,12 +171,12 @@ }, { "cell_type": "code", - "execution_count": 51, + "execution_count": 5, "outputs": [ { "data": { "text/plain": "
", - "image/png": "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\n" + "image/png": "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\n" }, "metadata": { "needs_background": "light" @@ -179,10 +185,11 @@ } ], "source": [ - "e_to_c_ana = dce_fit.EnhToConcSPGR(tr, fa, r1)\n", - "e_range = np.arange(-1000,2000,1.1)\n", - "C_t_ana = e_to_c_ana.proc(e_range, t10, k_fa=k_fa)\n", - "plt.plot(e_range, C_t_ana);\n" + "e_to_c_ana = dce_fit.EnhToConcSPGR(tr, fa, r1) # EnhToConcSPGR object\n", + "C_t_ana = e_to_c_ana.proc(enh, t10, k_fa=k_fa) # mM\n", + "plt.plot(enh, C_t_ana)\n", + "plt.xlabel('enhancement (%)')\n", + "plt.ylabel('C (mM)');" ], "metadata": { "collapsed": false, @@ -191,24 +198,39 @@ } } }, + { + "cell_type": "markdown", + "source": [ + "Plot difference between estimated and true concentrations" + ], + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%% md\n" + } + } + }, { "cell_type": "code", - "execution_count": null, - "outputs": [], + "execution_count": 7, + "outputs": [ + { + "data": { + "text/plain": "
", + "image/png": "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\n" + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], "source": [ - "\n", - "enh = np.arange(3000)\n", - "\n", - "c_to_r_model = relaxivity.CRLinear(r1, r2)\n", - "signal_model = signal_models.SPGR(tr, fa, te)\n", - "e_to_c_num = dce_fit.EnhToConc(c_to_r_model, signal_model)\n", - "C_t_num = e_to_c_num.proc(enh, t10, k_fa)\n", - "\n", - "e_to_c_ana = dce_fit.EnhToConcSPGR(tr, fa, r1)\n", - "C_t_ana = e_to_c_ana.proc(enh, t10, k_fa)\n", - "\n", - "plt.plot(enh, C_t_num, 'k-',\n", - " enh, C_t_ana, 'r-')" + "plt.plot(enh, C_t_num - conc_range, 'k-', label='numerical (general)')\n", + "plt.plot(enh, C_t_ana - conc_range, 'b-', label='analytical (SPGR)');\n", + "plt.legend()\n", + "plt.xlabel('enhancement (%)')\n", + "plt.ylabel('C error (mM)');" ], "metadata": { "collapsed": false, diff --git a/src/dce_fit.py b/src/dce_fit.py index 4b2adf6..d4a8e53 100644 --- a/src/dce_fit.py +++ b/src/dce_fit.py @@ -23,9 +23,9 @@ import numpy as np from scipy.signal import argrelextrema from scipy.interpolate import interp1d -from .fitting import Fitter -from .pk_models import Patlak -from .utils.utilities import least_squares_global +from fitting import Fitter +from pk_models import Patlak +from utils.utilities import least_squares_global class SigToEnh(Fitter):