qMT.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "kernel": "Python3",
    "scrolled": true,
    "tags": [
     "scratch"
    ]
   },
   "outputs": [],
   "source": [
    "# PYTHON CODE\n",
    "# Module imports\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "from PIL import Image\n",
    "from matplotlib.image import imread\n",
    "import scipy.io\n",
    "import plotly\n",
    "from plotly.subplots import make_subplots\n",
    "import plotly.graph_objs as go\n",
    "import numpy as np\n",
    "from plotly import __version__\n",
    "from plotly.offline import download_plotlyjs, init_notebook_mode, plot, iplot\n",
    "config={'showLink': False, 'displayModeBar': False}\n",
    "\n",
    "init_notebook_mode(connected=True)\n",
    "\n",
    "from IPython.core.display import display, HTML\n",
    "\n",
    "import os\n",
    "import markdown\n",
    "import random\n",
    "from scipy.integrate import quad\n",
    "\n",
    "import warnings\n",
    "warnings.filterwarnings('ignore')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import oct2py\n",
    "from oct2py import octave\n",
    "%load_ext oct2py.ipython"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%capture\n",
    "os.chdir(os.getcwd() + '/qMRLab')\n",
    "%octave startup"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Add fun folder\n",
    "octave.addpath('../fun')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "kernel": "SoS"
   },
   "source": [
    "<center><h1 style=\"font-family: timesnewroman;font-size: 40px;\">Quantitative Magnetization Transfer using Spoiled Gradient echo</h1></center>\n",
    "<p>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=blog_body>\n",
    "<p style=\"text-align:justify;\">\n",
    "Magnetization Transfer (MT) has been extensively applied to study macromolecular biological tissue composition. The imaging contrast resides in the magnetization transfer between free-water protons and macromolecular proton compartments, through chemical exchange and dipolar interactions. In the two-pool tissue model, highly mobile protons are associated with the free-water pool while protons found in semisolid macromolecular sites are defined as the restricted pool (Sled 2018). A simple method for visualizing MT effects includes acquiring two images with and without an off-resonance MT pulse to calculate the MT ratio (MTR), which is the normalized difference of these two images (Wolff and Balaban 1989). Despite its proven usefulness to study multiple sclerosis (Zheng et al. 2018), Alzheimer’s disease (Fornari et al. 2012) and psychiatric disorders (Chen et al. 2015), the MTR is a semi-quantitative metric that depends critically on the imaging sequence parameters (Wood and Malik 2020). Another semi-quantitative approach is the estimation of MT saturation (MTsat) by fitting the MT signal obtained from an MT-weighted (MTw), a proton density (PD) weighted and T<sub>1</sub>-weighted (T<sub>1</sub>w) contrast (Helms et al. 2008). Quantitative MT (qMT) consists of fitting multiple images to a mathematical model to extract tissue-specific parameters related to physical quantities, such as pool sizes, magnetization exchange rates between pools, and T<sub>1</sub>,T<sub>2</sub> relaxation times of each pool. Compared to semi-quantitative approaches (MTR, MTsat), qMT has long acquisition protocols and sometimes needs additional measurements (eg. B<sub>0</sub>, B<sub>1</sub>, T<sub>1</sub>), and the complex models required to fit the quantitative maps makes it a challenging imaging technique.\n",
    "</p>\n",
    "\n",
    "<p style=\"text-align:justify;\">\n",
    "In 2015, our lab published qMTLab (Cabana et al. 2015), an open-source software project seeking to unify three qMT methods in the same interface: qMT using spoiled gradient echo (qMT-SPGR), qMT using balanced steady-state free precession (qMT-bSSFP), and qMT using selective inversion recovery with fast spin echo (qMT-SIRFSE). qMTLab allowed users to simulate, evaluate, fit, and visualize qMT data with the possibility to share qMT protocols between researchers, allowing them to compare the performance of their methods (Cabana et al. 2015). Since then, we have extended the project and renamed it to qMRLab, (Karakuzu et al. 2020), which in addition to qMT now provides over 20 quantitative techniques under one umbrella, such as relaxation and diffusion models, quantitative susceptibility mapping, B<sub>0</sub> and B<sub>1</sub> mapping. In addition, we created interactive tutorials (Boudreau 2018a; Boudreau 2018b; Boudreau 2019) and blog posts for several qMRI techniques that were published under a creative commons license, and one of these tutorials (Boudreau 2018a) made it into a quantitative MRI book published by Elsevier (Seiberlich et al. 2020). This blog post is a continuation of our qMRLab outreach initiative, where we will focus on qMT and the tools we provide in qMRLab for this class of  techniques.\n",
    "</p>\n",
    "    \n",
    "<p style=\"text-align:justify;\">\n",
    "Below is an introduction to qMT (with a focus on qMT-SPGR), where we will cover signal modelling and data fitting.\n",
    "</p>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<center> <h2 style=\"font-family:timesnewroman;font-size:30px\">Signal Modelling</h2> </center>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=blog_body>\n",
    "<p style=\"text-align:justify;\">\n",
    "The magnetization transfer in a two-pool model is modelled by a set of coupled differential equations (Sled and Pike 2000):\n",
    "</p>\n",
    "\n",
    "<p style=\"text-align:justify;\">\n",
    "<center><img src=\"equation1-5.png\" style=\"width:auto;height:250px;margin-bottom: 30px;margin-top: 30px;\"></center>\n",
    "</p>\n",
    "\n",
    "<p style=\"text-align:justify;\">\n",
    "where the magnetization at time $t$ is given by M = [M<sub>x,f</sub>, M<sub>y,f</sub>, M<sub>z,f</sub>, M<sub>z,r</sub>] and M<sub>x,f</sub> and M<sub>y,f</sub> are the transverse magnetization for the free pool in the $x$ and $y$ direction, respectively. The longitudinal magnetization for the free and restricted pool is denoted by M<sub>z,f</sub> and M<sub>z,r</sub>. Due to the very short T<sub>2</sub> of the restricted pool (on the order of microseconds), the transverse magnetization of this pool is not explicitly modelled.\n",
    "</p>\n",
    "    \n",
    "<p style=\"text-align:justify;\">\n",
    "The constants k<sub>f</sub> and k<sub>r</sub> represent the exchange rate of the longitudinal magnetization from the free pool to the restricted pool (k<sub>f</sub>) and from the restricted to the free pool (k<sub>r</sub>). The ratio of these quantities is constrained by the size of the restricted to the free-water pool, expressed as k<sub>f</sub>/k<sub>r</sub> = M<sub>0,r</sub>/M<sub>0,f</sub>. This ratio is called the pool size ratio $F$ defined as F = M<sub>0,r</sub>/M<sub>0,f</sub>. The precessional frequency ω<sub>1</sub> is a measure of the power of the off-resonance radiofrequency pulse and ∆ is a frequency offset at which the magnetic B<sub>1</sub><sup>+</sup> field is applied. As shown in Figure 1, an on-resonance (∆ = 0) radiofrequency pulse is also part of the pulse sequence and is applied after the MT pulse. The relaxation time constants for the free and restricted pools are denoted by T<sub>1,f</sub> and T<sub>1,r</sub> for the longitudinal magnetization, and T<sub>2,f</sub> and T<sub>2,r</sub> for the transverse magnetization. Finally, $W$ is the saturation rate of the restricted pool, which is a function of the absorption lineshape $G$ that depends on the frequency offset and the transverse relaxation of the restricted pool (Figure 2).\n",
    "</p>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=figure_caption>\n",
    "<p style=\"text-align:justify;\">\n",
    "<b>\n",
    "Figure 1. Simplified pulse sequence diagram of a magnetization transfer spoiled gradient (MT-SPGR) experiment with an MT pulse followed by a spoiler gradient to destroy any transverse magnetization before the application of the on-resonance excitation pulse.\n",
    "</b>\n",
    "</p>\n",
    "</div>\n",
    "\n",
    "<p>\n",
    "<center><img src=\"mtspgr_pulsesequence.png\" style=\"width:500px;height:auto;\"></center>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=blog_body>\n",
    "<p style=\"text-align:justify;\">\n",
    "The absorption lineshape of the restricted pool that best characterizes the proton system depends on the environment. For simple systems such as agar gel phantoms, the Gaussian lineshape describes magnetization transfer effects well (Hankelman et al. 1993), while for more complicated and biologically relevant models, the super-Lorentzian lineshape is the best choice (Morrison et al. 1995). \n",
    "</p>\n",
    "\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=figure_caption>\n",
    "<p style=\"text-align:justify;\">\n",
    "<b>\n",
    "Figure 2. Gaussian, Lorentzian and super-Lorentzian absorption lineshapes plotted as a function of the frequency offset ∆ and T<sub>2,r</sub>.\n",
    "</b>\n",
    "</p>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def integrand(x, delta, t_2r):\n",
    "\n",
    "    return (1/abs(3*x**2 - 1))*np.exp(-2*((2*np.pi*delta*t_2r)/(3*x**2 - 1))**2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "init_notebook_mode(connected=True)\n",
    "\n",
    "delta = np.arange(-8000,8100,100) # in Hz\n",
    "t_2r = np.arange(6e-6,24e-6,2e-6) # in s\n",
    "G_gaussian = np.zeros((len(delta),len(t_2r)+1))\n",
    "G_lor = np.zeros((len(delta),len(t_2r)+1))\n",
    "G_superlor = np.zeros((len(delta),len(t_2r)+1))\n",
    "\n",
    "G_gaussian[:,0] = delta\n",
    "G_lor[:,0] = delta\n",
    "G_superlor[:,0] = delta\n",
    "\n",
    "for ii in range(len(t_2r)):\n",
    "    for jj in range(len(delta)):\n",
    "        G_gaussian[jj,ii+1] = (t_2r[ii]/np.sqrt(2*np.pi))*np.exp(-(2*np.pi*delta[jj]*t_2r[ii])**2/2)\n",
    "        \n",
    "        G_lor[jj,ii+1] = (t_2r[ii]/np.pi)*1/(1+((2*np.pi*delta[jj]*t_2r[ii])**2))\n",
    "        \n",
    "        integral = quad(integrand, 0, 1, args=(delta[jj],t_2r[ii]))\n",
    "        G_superlor[jj,ii+1] = (t_2r[ii])*(np.sqrt(2/np.pi))*integral[0]\n",
    "\n",
    "\n",
    "init_notebook_mode(connected=True)\n",
    "\n",
    "lineshape1 = [dict(\n",
    "        visible = False,\n",
    "        x = G_gaussian[:,0],\n",
    "        y = G_gaussian[:,ii+1],\n",
    "        line = dict(color = \"firebrick\"),\n",
    "        name = 'Gaussian',\n",
    "        hovertemplate = 'Gaussian, G(\\u0394,T<sub>2r</sub>) = %{y}<br>Frequency offset = %{x} Hz<extra></extra>') for ii in range(len(t_2r))]\n",
    "\n",
    "lineshape1[4]['visible'] = True\n",
    "\n",
    "lineshape2 = [dict(\n",
    "        visible = False,\n",
    "        x = G_lor[:,0],\n",
    "        y = G_lor[:,ii+1],\n",
    "        line = dict(color = \"royalblue\"),\n",
    "        name = 'Lorentzian',\n",
    "        hovertemplate = 'Lorentzian, G(\\u0394,T<sub>2r</sub>) = %{y}<br>Frequency offset = %{x} Hz<extra></extra>') for ii in range(len(t_2r))]\n",
    "\n",
    "lineshape2[4]['visible'] = True\n",
    "\n",
    "lineshape3 = [dict(\n",
    "        visible = False,\n",
    "        x = G_superlor[:,0],\n",
    "        y = G_superlor[:,ii+1],\n",
    "        line = dict(color = \"orange\"),\n",
    "        name = 'Super Lorentzian',\n",
    "        hovertemplate = 'Super Lorentzian, G(\\u0394,T<sub>2r</sub>) = %{y}<br>Frequency offset = %{x} Hz<extra></extra>') for ii in range(len(t_2r))]\n",
    "\n",
    "lineshape3[4]['visible'] = True\n",
    "\n",
    "data = lineshape1 + lineshape2 + lineshape3\n",
    "\n",
    "steps = []\n",
    "for i in range(len(t_2r)):\n",
    "    step = dict(\n",
    "        method = 'restyle',  \n",
    "        args = ['visible', [False] * len(lineshape1)],\n",
    "        label = str(round(t_2r[i], 7))\n",
    "    )\n",
    "    step['args'][1][i] = True # Toggle i'th trace to \"visible\"\n",
    "    steps.append(step)\n",
    "\n",
    "sliders = [dict(\n",
    "    x = 0,\n",
    "    y = -0.0,\n",
    "    active = 3,\n",
    "    currentvalue = {\"prefix\": \"T<sub>2r</sub>: <b>\"},\n",
    "    pad = {\"t\": 50, \"b\": 10},\n",
    "    steps = steps\n",
    ")]\n",
    "\n",
    "layout = go.Layout(\n",
    "    plot_bgcolor='rgba(0,0,0,0)',\n",
    "    width=580,\n",
    "    height=450,\n",
    "    margin=go.layout.Margin(\n",
    "        l=120,\n",
    "        r=80,\n",
    "        b=60,\n",
    "        t=10,\n",
    "    ),\n",
    "    annotations=[\n",
    "        dict(\n",
    "            x=0.5004254919715793,\n",
    "            y=-0.2,\n",
    "            showarrow=False,\n",
    "            text='Frequency offset \\u0394 (Hz)',\n",
    "            font=dict(\n",
    "                family='Times New Roman',\n",
    "                size=22\n",
    "            ),\n",
    "            xref='paper',\n",
    "            yref='paper'\n",
    "        ),\n",
    "        dict(\n",
    "            x=-0.2,\n",
    "            y=0.5,\n",
    "            showarrow=False,\n",
    "            text='Absorption lineshape G(\\u0394,T<sub>2r</sub>)',\n",
    "            font=dict(\n",
    "                family='Times New Roman',\n",
    "                size=22\n",
    "            ),\n",
    "            textangle=-90,\n",
    "            xref='paper',\n",
    "            yref='paper'\n",
    "        ),\n",
    "    ],\n",
    "    xaxis=dict(\n",
    "        autorange=False,\n",
    "        range=[-8000, 8000],\n",
    "        showgrid=False,\n",
    "        linecolor='black',\n",
    "        linewidth=2\n",
    "    ),\n",
    "    yaxis=dict(\n",
    "        autorange=True,\n",
    "        type=\"log\",\n",
    "        dtick=1,\n",
    "        showgrid=False,\n",
    "        linecolor='black',\n",
    "        linewidth=2\n",
    "    ),\n",
    "    legend=dict(\n",
    "        x=0.7,\n",
    "        y=0.85,\n",
    "        traceorder='normal',\n",
    "        font=dict(\n",
    "            family='Times New Roman',\n",
    "            size=12,\n",
    "            color='#000'\n",
    "        ),\n",
    "        bordercolor='#000000',\n",
    "        borderwidth=2\n",
    "    ), \n",
    "    sliders=sliders\n",
    ")\n",
    "\n",
    "fig = dict(data=data, layout=layout)\n",
    "\n",
    "iplot(fig, filename = 'basic-line', config = config)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=blog_body>\n",
    "<p style=\"text-align:justify;\">\n",
    "In a standard qMT experiment, multiple measurements are required where the off-resonance radiofrequency pulse angle (MT angle) and offset frequency are changed for each measurement, and at least one measurement is acquired in the absence of an MT pulse. The acquired signal plotted as a function of the the offset frequency is known as the “Z-spectrum”, and Figure 3 shows the Z-spectrum simulated using different absorption lineshapes. The off-resonance MT pulse is modelled either as a continuous wave or as a pulsed irradiation scheme. In a continuous wave irradiation mode, long off-resonance pulses of constant saturation and fixed frequency offset are applied to generate well-defined MT states in the two pools (Henkelman et al. 2001). For more practical implementations, pulsed off-resonance irradiations are used with a spoiled gradient echo sequence (SPGR) to generate MT-weighted images at different saturation rates and frequency offsets (Sled and Pike 2000). In the qMT-SPGR sequence shown in Figure 1, the MT preparation pulse is applied, followed by a spoiler gradient to eliminate any residual transverse magnetization produced by the long MT pulses, and to destroy the MR signal from previous measurements. A signal equation for this type of pulsed MT experiment can be derived by approximating the pulse sequence to a series of stages described by a continuous wave off-resonance irradiation period, followed by free precession, and instant saturation of the free-water pool (Cabana et al. 2015; Sled and Pike 2000; Sled and Pike 2001). This pulse sequence decomposition allows for analytically solving the Bloch-McConnell equations at a steady-state, but it is also possible to numerically solve the Bloch equations to perform simulations that provide a more realistic approximation when the system has not been driven to a steady-state. A comparison between the Bloch simulations and the analytical solution is shown in Figure 4 for different numbers of preparation MT pulses. As can be seen, different frequency offsets and MT flip angles require different numbers of repetition times to reach the steady-state, which is of paramount importance since the analytical solution used for parameter estimation is derived assuming the steady-state. In terms of data acquisition optimization, the k-space periphery is sampled during the preparation pulses whereas the center of k-space, that contains the overall image contrast, is acquired once the steady-state is achieved.\n",
    "</p>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-info\">\n",
    "<b>Optional code</b><br>\n",
    "    \n",
    "Code to generate the Z-spectrum fitted using different absorption lineshapes. <br>\n",
    "    \n",
    "<code>dataSim_lineshape, dataRaw_lineshape = octave.sim_lineshape(nout=2)</code>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#dataSim_lineshape, dataRaw_lineshape = octave.sim_lineshape(nout=2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Simulations have been performed and the results have been saved in the folder results.\n",
    "dataSim_lineshape_mat = scipy.io.loadmat('../results/dataSim_lineshape.mat')\n",
    "dataRaw_lineshape_mat = scipy.io.loadmat('../results/dataRaw_lineshape.mat')\n",
    "dataSim_lineshape = np.array(dataSim_lineshape_mat[\"dataSim_lineshape\"])\n",
    "dataRaw_lineshape = np.array(dataRaw_lineshape_mat[\"dataRaw_lineshape\"])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=figure_caption>\n",
    "<p style=\"text-align:justify;\">\n",
    "<b>\n",
    "Figure 3. Z-spectrum simulated using different absorption lineshapes (Gaussian, Lorentzian, and super-Lorentzian).\n",
    "</b>\n",
    "</p>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "init_notebook_mode(connected=True)\n",
    "\n",
    "absorption_lineshape = [\"Super-Lorentzian\", \"Lorentzian\", \"Gaussian\"]\n",
    "\n",
    "fig = go.Figure()\n",
    "\n",
    "#Add traces (three traces per fitting model)\n",
    "for ii in range(len(absorption_lineshape)):\n",
    "    if ii==0:\n",
    "        vis = True\n",
    "    else:\n",
    "        vis = False\n",
    "        \n",
    "    fig.add_trace(go.Scatter(x=dataSim_lineshape[:,0,0], y=dataSim_lineshape[:,1,ii],\n",
    "                             name=\"Fitted curve (angle = 142)\", mode='lines', line=dict(color=\"firebrick\"), visible = vis,\n",
    "                             hovertemplate=\"Fitted curve (angle = 142)<br>M<sub>z</sub> = %{y}<br>Offset = %{x} Hz<extra></extra>\"))\n",
    "    \n",
    "    fig.add_trace(go.Scatter(x=dataSim_lineshape[:,0,0], y=dataSim_lineshape[:,2,ii],\n",
    "                             name=\"Fitted curve (angle = 426)\", mode='lines', line=dict(color=\"royalblue\"), visible = vis,\n",
    "                             hovertemplate=\"Fitted curve (angle = 426)<br>M<sub>z</sub> = %{y}<br>Offset = %{x} Hz<extra></extra>\"))\n",
    "    \n",
    "    fig.add_trace(go.Scatter(x=dataRaw_lineshape[:,0,0], y=dataRaw_lineshape[:,1,ii],\n",
    "                             name=\"Raw data\", mode='markers', line=dict(color=\"darkslategray\"), visible = vis,\n",
    "                             hovertemplate=\"Raw data<br>M<sub>z</sub> = %{y}<br>Offset = %{x} Hz<extra></extra>\"))\n",
    "\n",
    "buttons = []\n",
    "for i, label in enumerate(absorption_lineshape):\n",
    "    visibility = [False] * 9\n",
    "    for j in range(3):\n",
    "        visibility[3*i+j] = True\n",
    "    button = dict(\n",
    "                label =  label,\n",
    "                method = 'update',\n",
    "                args = [{'visible': visibility}])\n",
    "    buttons.append(button)\n",
    "        \n",
    "updatemenus = list([\n",
    "    dict(active=0,\n",
    "         x=0.98,\n",
    "         y=1.1,\n",
    "         buttons=buttons\n",
    "    )\n",
    "])\n",
    "\n",
    "fig['layout']['updatemenus'] = updatemenus\n",
    "\n",
    "fig.update_layout(height=450, width=580, plot_bgcolor='rgba(0,0,0,0)',\n",
    "                 margin=go.layout.Margin(\n",
    "                     l=120,\n",
    "                     r=80,\n",
    "                     b=80,\n",
    "                     t=40,\n",
    "                     )\n",
    "                 )\n",
    "fig.update_layout(legend=dict(\n",
    "        x=0.55,\n",
    "        y=0.1,\n",
    "        traceorder='normal',\n",
    "        font=dict(\n",
    "            family='Times New Roman',\n",
    "            size=12,\n",
    "            color='#000'\n",
    "        ),\n",
    "        bordercolor='#000000',\n",
    "        borderwidth=2),\n",
    "    annotations=[\n",
    "        dict(\n",
    "            x=0.35,\n",
    "            y=1.1,\n",
    "            showarrow=False,\n",
    "            text='Absorption lineshape: ',\n",
    "            font=dict(\n",
    "                family='Times New Roman',\n",
    "                size=22\n",
    "            ),\n",
    "            xref='paper',\n",
    "            yref='paper'\n",
    "        ),\n",
    "        dict(\n",
    "            x=0.5004254919715793,\n",
    "            y=-0.2,\n",
    "            showarrow=False,\n",
    "            text='Frequency offset \\u0394 (Hz)',\n",
    "            font=dict(\n",
    "                family='Times New Roman',\n",
    "                size=22\n",
    "            ),\n",
    "            xref='paper',\n",
    "            yref='paper'\n",
    "        ),\n",
    "        dict(\n",
    "            x=-0.2,\n",
    "            y=0.5,\n",
    "            showarrow=False,\n",
    "            text='Magnetization |M<sub>z</sub>|',\n",
    "            font=dict(\n",
    "                family='Times New Roman',\n",
    "                size=22\n",
    "            ),\n",
    "            textangle=-90,\n",
    "            xref='paper',\n",
    "            yref='paper'\n",
    "        ),\n",
    "    ])\n",
    "\n",
    "fig.update_xaxes(type=\"log\", range=[2,5], showline=True, linewidth=2, linecolor='black', dtick=1, tickvals=[100,1000,10000,100000], ticktext=[\"10<sup>2</sup>\",\"10<sup>3</sup>\",\"10<sup>4</sup>\",\"10<sup>5</sup>\"])\n",
    "fig.update_yaxes(showline=True, linewidth=2, linecolor='black')\n",
    "\n",
    "iplot(fig, filename='dropdown', config=config)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-info\">\n",
    "<b>Optional code</b><br>\n",
    "    \n",
    "Code to run the Bloch simulations <br>\n",
    "    \n",
    "<code>numPulses = np.append(np.arange(10,100,10),np.arange(100,700,100))\n",
    "numPulses = np.append(np.arange(1,6,1),numPulses)\n",
    "dataSim_SNR, dataRaw_SNR = octave.BlochSim(numPulses,nout=2)</code>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#numPulses = np.arange(1,6,1)\n",
    "#dataSim_SNR, dataRaw_SNR = octave.BlochSim(numPulses,nout=2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=figure_caption>\n",
    "<p style=\"text-align:justify;\">\n",
    "<b>\n",
    "Figure 4. Z-spectrum simulated using Bloch simulations (dashed lines) for a number of MT pulses ranging from 1 to 600. Bloch simulations are compared with the Z-spectrum obtained from the analytical solution (solid lines).\n",
    "</b>\n",
    "</p>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "numPulses = np.append(np.arange(10,100,10),np.arange(100,700,100))\n",
    "numPulses = np.append(np.arange(1,6,1),numPulses)\n",
    "\n",
    "dataSim_Pulses_mat = scipy.io.loadmat('../results/blochSim/dataSim_Pulses.mat')\n",
    "datablochSim_Pulses_mat = scipy.io.loadmat('../results/blochSim/datablochSim_Pulses.mat')\n",
    "dataRaw_Pulses_mat = scipy.io.loadmat('../results/blochSim/dataRaw_Pulses.mat')\n",
    "datablochSimResetMz_Pulses_mat = scipy.io.loadmat('../results/blochSim/datablochSimResetMz_Pulses.mat')\n",
    "dataRawResetMz_Pulses_mat = scipy.io.loadmat('../results/blochSim/dataRawResetMz_Pulses.mat')\n",
    "\n",
    "dataSimAnalytical_Pulses = np.array(dataSim_Pulses_mat[\"dataSim_Pulses\"])\n",
    "dataBlochSim_Pulses = np.array(datablochSim_Pulses_mat[\"datablochSim_Pulses\"])\n",
    "dataRaw_Pulses = np.array(dataRaw_Pulses_mat[\"dataRaw_Pulses\"])\n",
    "dataBlochSimResetMz_Pulses = np.array(datablochSimResetMz_Pulses_mat[\"datablochSimResetMz_Pulses\"])\n",
    "dataRawResetMz_Pulses = np.array(dataRawResetMz_Pulses_mat[\"dataRawResetMz_Pulses\"])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# PYTHON CODE\n",
    "\n",
    "init_notebook_mode(connected=True)\n",
    "\n",
    "dataSimAnalyticalPulses1 = [dict(\n",
    "        visible = False,\n",
    "        x = dataSimAnalytical_Pulses[:,0,0],\n",
    "        y = dataSimAnalytical_Pulses[:,1,ii],\n",
    "        line = dict(color = \"firebrick\"),\n",
    "        name = 'Analytical Solution (angle = 142)',\n",
    "        hovertemplate = 'Analytical Solution (angle = 142)<br>M<sub>z</sub> = %{y}<br>Offset = %{x} Hz<extra></extra>') for ii in range(len(numPulses))]\n",
    "\n",
    "dataSimAnalyticalPulses1[4]['visible'] = True\n",
    "\n",
    "dataSimAnalyticalPulses2 = [dict(\n",
    "        visible = False,\n",
    "        x = dataSimAnalytical_Pulses[:,0,0],\n",
    "        y = dataSimAnalytical_Pulses[:,2,ii],\n",
    "        line = dict(color = \"royalblue\"),\n",
    "        name = 'Analytical Solution (angle = 426)',\n",
    "        hovertemplate = 'Analytical Solution (angle = 426)<br>M<sub>z</sub> = %{y}<br>Offset = %{x} Hz<extra></extra>') for ii in range(len(numPulses))]\n",
    "\n",
    "dataSimAnalyticalPulses2[4]['visible'] = True\n",
    "\n",
    "dataBlochSimPulses1 = [dict(\n",
    "        visible = False,\n",
    "        x = dataBlochSim_Pulses[:,0,0],\n",
    "        y = dataBlochSim_Pulses[:,1,ii],\n",
    "        line = dict(\n",
    "            color = \"firebrick\",\n",
    "            dash = 'dash'),\n",
    "        name = 'Bloch Simulation (angle = 142)',\n",
    "        text = 'Bloch Simulation (angle = 142)',\n",
    "        hovertemplate = 'Bloch Simulation (angle = 142)<br>M<sub>z</sub> = %{y}<br>Offset = %{x} Hz<extra></extra>') for ii in range(len(numPulses))]\n",
    "\n",
    "dataBlochSimPulses1[4]['visible'] = True\n",
    "\n",
    "dataBlochSimPulses2 = [dict(\n",
    "        visible = False,\n",
    "        x = dataBlochSim_Pulses[:,0,0],\n",
    "        y = dataBlochSim_Pulses[:,2,ii],\n",
    "        line = dict(\n",
    "            color = \"royalblue\",\n",
    "            dash = 'dash'),\n",
    "        name = 'Bloch Simulation (angle = 426)',\n",
    "        hovertemplate = 'Bloch Simulation (angle = 426)<br>M<sub>z</sub> = %{y}<br>Offset = %{x} Hz<extra></extra>') for ii in range(len(numPulses))]\n",
    "\n",
    "dataBlochSimPulses2[4]['visible'] = True\n",
    "\n",
    "dataRawPulses = [dict(\n",
    "        visible = False,\n",
    "        mode = 'markers',\n",
    "        marker = dict(color = \"darkslategray\"),\n",
    "        x = dataRaw_Pulses[:,0,0],\n",
    "        y = dataRaw_Pulses[:,1,ii],\n",
    "        name = 'Raw data',\n",
    "        hovertemplate = 'Raw data<br>M<sub>z</sub> = %{y}<br>Offset = %{x} Hz<extra></extra>') for ii in range(len(numPulses))]\n",
    "\n",
    "dataRawPulses[4]['visible'] = True\n",
    "\n",
    "data = dataSimAnalyticalPulses1 + dataSimAnalyticalPulses2 + dataBlochSimPulses1 + dataBlochSimPulses2 + dataRawPulses\n",
    "\n",
    "steps = []\n",
    "for i in range(len(numPulses)):\n",
    "    step = dict(\n",
    "        method = 'restyle',  \n",
    "        args = ['visible', [False] * len(dataSimAnalyticalPulses1)],\n",
    "        label = str(numPulses[i])\n",
    "    )\n",
    "    step['args'][1][i] = True # Toggle i'th trace to \"visible\"\n",
    "    steps.append(step)\n",
    "\n",
    "sliders = [dict(\n",
    "    x = 0,\n",
    "    y = -0.0,\n",
    "    active = 7,\n",
    "    currentvalue = {\"prefix\": \"# of Pulses: <b>\"},\n",
    "    pad = {\"t\": 50, \"b\": 10},\n",
    "    steps = steps\n",
    ")]\n",
    "\n",
    "layout = go.Layout(\n",
    "    plot_bgcolor='rgba(0,0,0,0)',\n",
    "    width=580,\n",
    "    height=450,\n",
    "    margin=go.layout.Margin(\n",
    "        l=80,\n",
    "        r=40,\n",
    "        b=60,\n",
    "        t=10,\n",
    "    ),\n",
    "    annotations=[\n",
    "        dict(\n",
    "            x=0.5004254919715793,\n",
    "            y=-0.2,\n",
    "            showarrow=False,\n",
    "            text='Frequency offset \\u0394 (Hz)',\n",
    "            font=dict(\n",
    "                family='Times New Roman',\n",
    "                size=22\n",
    "            ),\n",
    "            xref='paper',\n",
    "            yref='paper'\n",
    "        ),\n",
    "        dict(\n",
    "            x=-0.14,\n",
    "            y=0.5,\n",
    "            showarrow=False,\n",
    "            text='Magnetization |M<sub>z</sub>|',\n",
    "            font=dict(\n",
    "                family='Times New Roman',\n",
    "                size=22\n",
    "            ),\n",
    "            textangle=-90,\n",
    "            xref='paper',\n",
    "            yref='paper'\n",
    "        ),\n",
    "    ],\n",
    "    xaxis=dict(\n",
    "        autorange=False,\n",
    "        type=\"log\",\n",
    "        range=[2, 5],\n",
    "        dtick=1,\n",
    "        showgrid=False,\n",
    "        linecolor='black',\n",
    "        linewidth=2\n",
    "    ),\n",
    "    yaxis=dict(\n",
    "        autorange=False,\n",
    "        range=[0, 1.1],\n",
    "        showgrid=False,\n",
    "        linecolor='black',\n",
    "        linewidth=2\n",
    "    ),\n",
    "    legend=dict(\n",
    "        x=0.5,\n",
    "        y=0.05,\n",
    "        traceorder='normal',\n",
    "        font=dict(\n",
    "            family='Times New Roman',\n",
    "            size=12,\n",
    "            color='#000'\n",
    "        ),\n",
    "        bordercolor='#000000',\n",
    "        borderwidth=2\n",
    "    ), \n",
    "    sliders=sliders\n",
    ")\n",
    "\n",
    "fig = dict(data=data, layout=layout)\n",
    "\n",
    "iplot(fig, filename = 'basic-line', config = config)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<center> <h2 style=\"font-family:timesnewroman;font-size:30px\">Data Fitting</h2> </center>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=blog_body>\n",
    "<p style=\"text-align:justify;\">\n",
    "In qMT imaging, the biophysical model relates the parameters observed in the two-pool tissue model to physical quantities such as the fractional size of the pools, relaxation times and magnetization exchange rates of the free and restricted pool (Sled and Pike 2001; Sled 2018). However, qMT experiments usually consist of long acquisition imaging protocols accompanied by complex data fitting. To this end, some software solutions have been proposed (Karakuzu et al. 2020; Tabelow et al. 2019; Wood 2018). qMRLab is an open-source project for quantitative MR analysis that is an extension of qMTLab, a software for data simulation and analysis of three MT models: qMT-SPGR, qMT-bSSFP and qMT-SIRFSE. In addition to the quantitative MT methods, qMRLab also contains semi-quantitative MT models including the magnetization transfer ratio (MTR) and magnetization transfer saturation (MTsat).\n",
    "</p>\n",
    "    \n",
    "<p style=\"text-align:justify;\">\n",
    "The qMT-SPGR method in qMRLab contains three fitting models: Sled and Pike, Ramani, and Yarnykh and Yuan (Sled and Pike 2001; Ramani et al. 2002; Yarnykh 2002). For the Sled and Pike model, the saturation fraction effect of the MT pulse on the free pool is pre-computed to accelerate the processing times. The MT effect of the pulse is approximated as an instantaneous fractional saturation of the longitudinal magnetization of the free pool, assuming the absence of chemical exchange processes (Pike 1996; Sled and Pike 2001). To fit the model, additional parameters related to the pulse sequence are required, namely timing parameters, the absorption lineshape, and the characteristics of the MT pulse, such as the shape and the bandwidth or the time-bandwidth product. In Figure 5, the qMT-SPGR method is used to show a single voxel curve simulation for the same MT data fitted by three different models. The fitted parameters were the pool size ratio F, the magnetization transfer rate from the restricted to the free-water pool (k<sub>r</sub>), and the transverse relaxation time of the free-water (T<sub>2,f</sub>) and restricted (T<sub>2,r</sub>) pool.\n",
    "</p>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-info\">\n",
    "<b>Optional code</b><br>\n",
    "    \n",
    "Code to generate the data fitted using different models. <br>\n",
    "    \n",
    "<code>dataSim_model, dataRaw_model = octave.sim_modelFit(nout=2)</code>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#dataSim_model, dataRaw_model = octave.sim_modelFit(nout=2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=figure_caption>\n",
    "<p style=\"text-align:justify;\">\n",
    "<b>\n",
    "Figure 5. Sled and Pike, Ramani, and Yarnykh and Yuan models to fit the MT data from a qMT-SPGR experiment.\n",
    "</b>\n",
    "</p>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Simulations have been performed and the results have been saved in the folder results.\n",
    "dataSim_model_mat = scipy.io.loadmat('../results/dataSim_model.mat')\n",
    "dataRaw_model_mat = scipy.io.loadmat('../results/dataRaw_model.mat')\n",
    "dataSim_model = np.array(dataSim_model_mat[\"dataSim_modelFit\"])\n",
    "dataRaw_model = np.array(dataRaw_model_mat[\"dataRaw_modelFit\"])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# PYTHON CODE\n",
    "\n",
    "init_notebook_mode(connected=True)\n",
    "\n",
    "fitModel = [\"Sled Pike RP\", \"Sled Pike CW\", \"Yarnykh\", \"Ramani\"]\n",
    "\n",
    "fig = go.Figure()\n",
    "\n",
    "#Add traces (three traces per fitting model)\n",
    "for ii in range(len(fitModel)):\n",
    "    if ii==0:\n",
    "        vis = True\n",
    "    else:\n",
    "        vis = False\n",
    "    fig.add_trace(go.Scatter(x=dataSim_model[:,0,0], y=dataSim_model[:,1,ii],\n",
    "                             name=\"Fitted curve (angle = 142)\", mode='lines', line=dict(color=\"firebrick\"), visible = vis,\n",
    "                             hovertemplate=\"Fitted curve (angle = 142)<br>M<sub>z</sub> = %{y}<br>Offset = %{x} Hz<extra></extra>\"))\n",
    "    \n",
    "    fig.add_trace(go.Scatter(x=dataSim_model[:,0,0], y=dataSim_model[:,2,ii],\n",
    "                             name=\"Fitted curve (angle = 426)\", mode='lines', line=dict(color=\"royalblue\"), visible = vis,\n",
    "                             hovertemplate=\"Fitted curve (angle = 426)<br>M<sub>z</sub> = %{y}<br>Offset = %{x} Hz<extra></extra>\"))\n",
    "    \n",
    "    fig.add_trace(go.Scatter(x=dataRaw_model[:,0,0], y=dataRaw_model[:,1,ii],\n",
    "                             name=\"Raw data\", mode='markers', line=dict(color=\"darkslategray\"), visible = vis,\n",
    "                             hovertemplate=\"Raw data<br>M<sub>z</sub> = %{y}<br>Offset = %{x} Hz<extra></extra>\"))\n",
    "\n",
    "\n",
    "buttons = []\n",
    "for i, label in enumerate(fitModel):\n",
    "    visibility = [False] * 12\n",
    "    for j in range(3):\n",
    "        visibility[3*i+j] = True\n",
    "    button = dict(\n",
    "                label =  label,\n",
    "                method = 'update',\n",
    "                args = [{'visible': visibility}])\n",
    "    buttons.append(button)\n",
    "        \n",
    "updatemenus = list([\n",
    "    dict(active=0,\n",
    "         x=0.88,\n",
    "         y=1.1,\n",
    "         buttons=buttons\n",
    "    )\n",
    "])\n",
    "\n",
    "fig['layout']['updatemenus'] = updatemenus\n",
    "\n",
    "fig.update_layout(height=450, width=580, plot_bgcolor='rgba(0,0,0,0)')\n",
    "fig.update_layout(legend=dict(\n",
    "        x=0.55,\n",
    "        y=0.1,\n",
    "        traceorder='normal',\n",
    "        font=dict(\n",
    "            family='Times New Roman',\n",
    "            size=12,\n",
    "            color='#000'\n",
    "        ),\n",
    "        bordercolor='#000000',\n",
    "        borderwidth=2),\n",
    "    annotations=[\n",
    "        dict(\n",
    "            x=0.35,\n",
    "            y=1.1,\n",
    "            showarrow=False,\n",
    "            text='Fitting method: ',\n",
    "            font=dict(\n",
    "                family='Times New Roman',\n",
    "                size=22\n",
    "            ),\n",
    "            xref='paper',\n",
    "            yref='paper'\n",
    "        ),\n",
    "        dict(\n",
    "            x=0.5004254919715793,\n",
    "            y=-0.2,\n",
    "            showarrow=False,\n",
    "            text='Frequency offset \\u0394 (Hz)',\n",
    "            font=dict(\n",
    "                family='Times New Roman',\n",
    "                size=22\n",
    "            ),\n",
    "            xref='paper',\n",
    "            yref='paper'\n",
    "        ),\n",
    "        dict(\n",
    "            x=-0.14,\n",
    "            y=0.5,\n",
    "            showarrow=False,\n",
    "            text='Magnetization |M<sub>z</sub>|',\n",
    "            font=dict(\n",
    "                family='Times New Roman',\n",
    "                size=22\n",
    "            ),\n",
    "            textangle=-90,\n",
    "            xref='paper',\n",
    "            yref='paper'\n",
    "        ),\n",
    "    ])\n",
    "\n",
    "fig.update_xaxes(type=\"log\", range=[2,5], showline=True, linewidth=2, linecolor='black', dtick=1, tickvals=[100,1000,10000,100000], ticktext=[\"10<sup>2</sup>\",\"10<sup>3</sup>\",\"10<sup>4</sup>\",\"10<sup>5</sup>\"])\n",
    "fig.update_yaxes(showline=True, linewidth=2, linecolor='black')\n",
    "\n",
    "iplot(fig, filename='dropdown')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=blog_body>\n",
    "<p style=\"text-align:justify;\">\n",
    "In addition to acquiring the MT data, three more quantitative measurements are typically required for model correction purposes. The magnetic field B<sub>0</sub> inhomogeneity affects the actual off-resonance frequency experienced by the tissue at each voxel. In MT, B<sub>0</sub> maps are computed to correct for off-resonance frequency values of the MT pulse in the presence of magnetic field non-uniformity. Radiofrequency field B<sub>1</sub> inhomogeneity is another source of inaccuracies that depend on the operating frequency of the scanner, the pulse sequence, and the shape and electrical properties of the sample (Sled and Pike 1998). Therefore, B<sub>1</sub> maps are typically needed to correct the radiofrequency amplitude variations that affect the nominal values of the MT pulse flip angle and the excitation flip angle (Boudreau et al. 2018c). Longitudinal relaxation T<sub>1</sub> values vary naturally in biological tissue, but the choice of the T<sub>1</sub> mapping method, has also been shown to influence the variability of T<sub>1</sub> measurements (Stikov et al. 2015). In the context of a qMT experiment, T<sub>1</sub> maps are acquired with an independent measurement of the apparent relaxation time T<sub>1</sub> (T<sub>1</sub><sup>meas</sup>). The T<sub>1</sub> map is related to the relaxation rate of the free pool (R<sub>1,f</sub>) as described by equation 6, expressed in terms of $F$, k<sub>f</sub>, R<sub>1</sub><sup>meas</sup> and R<sub>1,r</sub>, where the relaxation rate of the restricted pool is arbitrarily set to 1 s<sup>-1</sup> because it is insensitive to this kind of MT experiments (Sled and Pike 2001). Multiple qMRI maps with a range of B<sub>0</sub> and B<sub>1</sub> inaccuracies, as well as T<sub>1</sub> maps with a variety of relaxation times, have been simulated to show the effect of the quality of these input maps on the qMT fitted parameters as shown in Figure 6.\n",
    "</p>\n",
    "    \n",
    "<p style=\"text-align:justify;\">\n",
    "<center><img src=\"equation6.png\" style=\"width:auto;height:50px;margin-bottom: 30px;margin-top: 30px;\"></center>\n",
    "</p>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-info\">\n",
    "<b>Optional code</b><br>\n",
    "    \n",
    "Code to fit MT data simulating input maps of different quality.<br>\n",
    "    \n",
    "<code>B0map = np.arange(-100,300,50)\n",
    "B1map = np.arange(0.7,1.4,0.1)\n",
    "R1map = np.append(np.arange(0.20,0.55,0.05),np.arange(0.6,1.6,0.1))\n",
    "b0FittedData,b0NormFittedData,b1FittedData,b1NormFittedData,r1FittedData,r1NormFittedData = octave.fit_SyntheticData(B0map,B1map,R1map,nout=6)</code>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#B0map = np.arange(-100,300,50)\n",
    "#B1map = np.arange(0.7,1.4,0.1)\n",
    "#R1map = np.append(np.arange(0.20,0.55,0.05),np.arange(0.6,1.6,0.1))\n",
    "#T1map = 1/R1map\n",
    "#b0FittedData,b0NormFittedData,b1FittedData,b1NormFittedData,t1FittedData,t1NormFittedData = octave.fit_SyntheticData(B0map,B1map,T1map,nout=6)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=figure_caption>\n",
    "<p style=\"text-align:justify;\">\n",
    "<b>\n",
    "Figure 6. Errors (%) in fitted parameters when input maps of different quality are used. A B<sub>1</sub> map of 0.9 means that the input has a 10% lower value than expected. The fitted parameters include the pool size ratio, F, the magnetization exchange rate, k<sub>f</sub>, the free pool T<sub>2,f</sub>, and the restricted pool T<sub>2,r</sub>. The errors were simulated for B<sub>0</sub>, B<sub>1</sub> and T<sub>1</sub> maps of different quality.\n",
    "</b>\n",
    "</p>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "B0map = np.arange(-100,300,50)\n",
    "B1map = np.arange(0.7,1.4,0.1)\n",
    "R1map = np.append(np.arange(0.20,0.55,0.05),np.arange(0.6,1.6,0.1))\n",
    "T1map = 1/R1map\n",
    "\n",
    "#Percentage error\n",
    "\n",
    "b1NormFittedData_mat = scipy.io.loadmat('../results/fitSyntheticData/b1NormFittedResults.mat')\n",
    "b1NormFittedData = np.array(b1NormFittedData_mat[\"b1NormFittedResults\"])\n",
    "\n",
    "b0NormFittedData_mat = scipy.io.loadmat('../results/fitSyntheticData/b0NormFittedResults.mat')\n",
    "b0NormFittedData = np.array(b0NormFittedData_mat[\"b0NormFittedResults\"])\n",
    "\n",
    "t1NormFittedData_mat = scipy.io.loadmat('../results/fitSyntheticData/t1NormFittedResults.mat')\n",
    "t1NormFittedData = np.array(t1NormFittedData_mat[\"t1NormFittedResults\"])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "init_notebook_mode(connected=True)\n",
    "\n",
    "labels = [\"B1 map\", \"B0 map\", \"T1 map\"]\n",
    "FittedParams = [\"F\", \"kf (s<sup>-1</sup>)\", \"T2,f (s)\", \"T2,r\"]\n",
    "\n",
    "fig = make_subplots(rows=2, cols=2)\n",
    "\n",
    "#F\n",
    "trace1_b1 = go.Scatter(x=b1NormFittedData[:,0], y=b1NormFittedData[:,1],\n",
    "                       name=\"F\", mode='lines', line=dict(color=\"royalblue\"), visible=True,\n",
    "                       hovertemplate=\"Error (%) = %{y}<br>B1 value = %{x} <extra></extra>\")\n",
    "trace1_b0 = go.Scatter(x=b0NormFittedData[:,0], y=b0NormFittedData[:,1],\n",
    "                       name=\"F\", mode='lines', line=dict(color=\"royalblue\"), visible=False,\n",
    "                       hovertemplate=\"Error (%) = %{y}<br>B0 value = %{x} Hz<extra></extra>\")\n",
    "trace1_t1 = go.Scatter(x=t1NormFittedData[:,0], y=t1NormFittedData[:,1],\n",
    "                       name=\"F\", mode='lines', line=dict(color=\"royalblue\"), visible=False,\n",
    "                       hovertemplate=\"Error (%) = %{y}<br>T1 value = %{x} s<extra></extra>\")\n",
    "\n",
    "fig.append_trace(trace1_b1, 1, 1)\n",
    "fig.append_trace(trace1_b0, 1, 1)\n",
    "fig.append_trace(trace1_t1, 1, 1)\n",
    "\n",
    "#kf\n",
    "trace2_b1 = go.Scatter(x=b1NormFittedData[:,0], y=b1NormFittedData[:,2],\n",
    "                       name=\"kf\", mode='lines', line=dict(color=\"royalblue\"), visible=True,\n",
    "                       hovertemplate=\"Error (%) = %{y}<br>B1 value = %{x} <extra></extra>\")\n",
    "trace2_b0 = go.Scatter(x=b0NormFittedData[:,0], y=b0NormFittedData[:,2],\n",
    "                       name=\"kf\", mode='lines', line=dict(color=\"royalblue\"), visible=False,\n",
    "                       hovertemplate=\"Error (%) = %{y}<br>B0 value = %{x} Hz<extra></extra>\")\n",
    "trace2_t1 = go.Scatter(x=t1NormFittedData[:,0], y=t1NormFittedData[:,2],\n",
    "                       name=\"kf\", mode='lines', line=dict(color=\"royalblue\"), visible=False,\n",
    "                       hovertemplate=\"Error (%) = %{y}<br>T1 value = %{x} s<extra></extra>\")\n",
    "\n",
    "fig.append_trace(trace2_b1, 1, 2)\n",
    "fig.append_trace(trace2_b0, 1, 2)\n",
    "fig.append_trace(trace2_t1, 1, 2)\n",
    "\n",
    "#T2f\n",
    "trace3_b1 = go.Scatter(x=b1NormFittedData[:,0], y=b1NormFittedData[:,3],\n",
    "                       name=\"kf\", mode='lines', line=dict(color=\"royalblue\"), visible=True,\n",
    "                       hovertemplate=\"Error (%) = %{y}<br>B1 value = %{x} <extra></extra>\")\n",
    "trace3_b0 = go.Scatter(x=b0NormFittedData[:,0], y=b0NormFittedData[:,3],\n",
    "                       name=\"kf\", mode='lines', line=dict(color=\"royalblue\"), visible=False,\n",
    "                       hovertemplate=\"Error (%) = %{y}<br>B0 value = %{x} Hz<extra></extra>\")\n",
    "trace3_t1 = go.Scatter(x=t1NormFittedData[:,0], y=t1NormFittedData[:,3],\n",
    "                       name=\"kf\", mode='lines', line=dict(color=\"royalblue\"), visible=False,\n",
    "                       hovertemplate=\"Error (%) = %{y}<br>T1 value = %{x} s<extra></extra>\")\n",
    "\n",
    "fig.append_trace(trace3_b1, 2, 1)\n",
    "fig.append_trace(trace3_b0, 2, 1)\n",
    "fig.append_trace(trace3_t1, 2, 1)\n",
    "\n",
    "#T2r\n",
    "trace4_b1 = go.Scatter(x=b1NormFittedData[:,0], y=b1NormFittedData[:,4],\n",
    "                       name=\"kf\", mode='lines', line=dict(color=\"royalblue\"), visible=True,\n",
    "                       hovertemplate=\"Error (%) = %{y}<br>B1 value = %{x} <extra></extra>\")\n",
    "trace4_b0 = go.Scatter(x=b0NormFittedData[:,0], y=b0NormFittedData[:,4],\n",
    "                       name=\"kf\", mode='lines', line=dict(color=\"royalblue\"), visible=False,\n",
    "                       hovertemplate=\"Error (%) = %{y}<br>B0 value = %{x} Hz<extra></extra>\")\n",
    "trace4_t1 = go.Scatter(x=t1NormFittedData[:,0], y=t1NormFittedData[:,4],\n",
    "                       name=\"kf\", mode='lines', line=dict(color=\"royalblue\"), visible=False,\n",
    "                       hovertemplate=\"Error (%) = %{y}<br>T1 value = %{x} s<extra></extra>\")\n",
    "\n",
    "fig.append_trace(trace4_b1, 2, 2)\n",
    "fig.append_trace(trace4_b0, 2, 2)\n",
    "fig.append_trace(trace4_t1, 2, 2)\n",
    "\n",
    "buttons = []\n",
    "for i, label in enumerate(labels):\n",
    "    visibility = [i==j for j in range(len(labels))]\n",
    "    button = dict(\n",
    "                label =  label,\n",
    "                method = 'update',\n",
    "                args = [{'visible': visibility}])\n",
    "    buttons.append(button)\n",
    "        \n",
    "updatemenus = list([\n",
    "    dict(active=0,\n",
    "         x=0.65,\n",
    "         y=1.1,\n",
    "         buttons=buttons\n",
    "    )\n",
    "])\n",
    "\n",
    "fig['layout']['showlegend'] = False\n",
    "fig['layout']['updatemenus'] = updatemenus\n",
    "\n",
    "fig.update_xaxes(title_text='Input map', title_font=dict(family='Times New Roman', size=18),\n",
    "                 row=1, col=1, showline=True, linewidth=2, linecolor='black')\n",
    "fig.update_xaxes(title_text='Input map', title_font=dict(family='Times New Roman', size=18),\n",
    "                 row=1, col=2, showline=True, linewidth=2, linecolor='black')\n",
    "fig.update_xaxes(title_text='Input map', title_font=dict(family='Times New Roman', size=18),\n",
    "                 row=2, col=1, showline=True, linewidth=2, linecolor='black')\n",
    "fig.update_xaxes(title_text='Input map', title_font=dict(family='Times New Roman', size=18),\n",
    "                 row=2, col=2, showline=True, linewidth=2, linecolor='black')\n",
    "fig.update_yaxes(range=[-100,100], row=1, col=1, showline=True, linewidth=2, linecolor='black')\n",
    "fig.update_yaxes(range=[-100,100], row=1, col=2, showline=True, linewidth=2, linecolor='black')\n",
    "fig.update_yaxes(range=[-100,100], row=2, col=1, showline=True, linewidth=2, linecolor='black')\n",
    "fig.update_yaxes(range=[-100,100], row=2, col=2, showline=True, linewidth=2, linecolor='black')\n",
    "\n",
    "fig.update_layout(height=500, width=600, plot_bgcolor='rgba(0,0,0,0)')\n",
    "fig.update_layout(annotations=[\n",
    "    dict(\n",
    "        x=0.20,\n",
    "        y=1.1,\n",
    "        showarrow=False,\n",
    "        text='Input map: ',\n",
    "        font=dict(\n",
    "            family='Times New Roman',\n",
    "            size=22\n",
    "            ),\n",
    "        xref='paper',\n",
    "        yref='paper'\n",
    "        ),\n",
    "    dict(\n",
    "        x=-0.1,\n",
    "        y=0.90,\n",
    "        showarrow=False,\n",
    "        text='% Error in ' + FittedParams[0],\n",
    "        font=dict(\n",
    "            family='Times New Roman',\n",
    "            size=18\n",
    "            ),\n",
    "        textangle=-90,\n",
    "        xref='paper',\n",
    "        yref='paper'\n",
    "        ),\n",
    "    dict(\n",
    "        x=0.48,\n",
    "        y=0.98,\n",
    "        showarrow=False,\n",
    "        text='% Error in ' + FittedParams[1],\n",
    "        font=dict(\n",
    "            family='Times New Roman',\n",
    "            size=18\n",
    "            ),\n",
    "        textangle=-90,\n",
    "        xref='paper',\n",
    "        yref='paper'\n",
    "        ),\n",
    "    dict(\n",
    "        x=-0.1,\n",
    "        y=0.03,\n",
    "        showarrow=False,\n",
    "        text='% Error in ' + FittedParams[2],\n",
    "        font=dict(\n",
    "            family='Times New Roman',\n",
    "            size=18\n",
    "            ),\n",
    "        textangle=-90,\n",
    "        xref='paper',\n",
    "        yref='paper'\n",
    "        ),\n",
    "    dict(\n",
    "        x=0.48,\n",
    "        y=0.07,\n",
    "        showarrow=False,\n",
    "        text='% Error in ' + FittedParams[3],\n",
    "        font=dict(\n",
    "            family='Times New Roman',\n",
    "            size=18\n",
    "            ),\n",
    "        textangle=-90,\n",
    "        xref='paper',\n",
    "        yref='paper'\n",
    "        )\n",
    "])\n",
    "fig.update_layout(plot_bgcolor='rgba(0,0,0,0)',\n",
    "                 margin=go.layout.Margin(\n",
    "                     l=120,\n",
    "                     r=40,\n",
    "                     b=60,\n",
    "                     t=50,\n",
    "                     )\n",
    "                 )\n",
    "fig.update_layout()\n",
    "\n",
    "iplot(fig, filename='basic-line', config=config)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=blog_body>\n",
    "<p style=\"text-align:justify;\">\n",
    "As described above in Figure 6, inaccurate MT pulse flip angles and excitation flip angles affect the fitted MT parameters, and there is an additional error source related to the T<sub>1</sub> mapping measurement. As Boudreau et al. (2018c) have shown, using specific acquisitions protocols, T<sub>1</sub> values can be affected by B<sub>1</sub> field non-uniformities, such as the variable flip angle method, while the inversion recovery method is insensitive to these field inhomogeneities (Stikov et al. 2015).\n",
    "</p>\n",
    "    \n",
    "<p style=\"text-align:justify;\">\n",
    "Figure 7 displays an example human dataset with the input qMRI maps used to fit the qMT parameters F, k<sub>f</sub>, T<sub>2,f</sub>, T<sub>2,r</sub>.\n",
    "</p>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=figure_caption>\n",
    "<p style=\"text-align:justify;\">\n",
    "<b>\n",
    "Figure 7. Example magnetization transfer spoiled gradient dataset showing qMRI maps used to fit the MT data (top), and the fitted parameters F, k<sub>f</sub>, T<sub>2,f</sub>, T<sub>2,r</sub> (bottom).\n",
    "</b>\n",
    "</p>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "b0map_mat = scipy.io.loadmat('../results/realData/b0mapMAT.mat')\n",
    "b0map = np.array(b0map_mat[\"b0mapMAT\"])\n",
    "b1map_mat = scipy.io.loadmat('../results/realData/b1mapMAT.mat')\n",
    "b1map = np.array(b1map_mat[\"b1mapMAT\"])\n",
    "r1map_mat = scipy.io.loadmat('../results/realData/r1mapMAT.mat')\n",
    "r1map = np.array(r1map_mat[\"r1mapMAT\"])\n",
    "mtdata_mat = scipy.io.loadmat('../results/realData/mtdataMAT.mat')\n",
    "mtdata = np.array(mtdata_mat[\"mtdataMAT\"])\n",
    "mask_mat = scipy.io.loadmat('../results/realData/maskMAT.mat')\n",
    "mask = np.array(mask_mat[\"maskMAT\"])\n",
    "\n",
    "Fmap_mat = scipy.io.loadmat('../results/realData/FmapMAT.mat')\n",
    "Fmap = np.array(Fmap_mat[\"FmapMAT\"])\n",
    "kfmap_mat = scipy.io.loadmat('../results/realData/kfmapMAT.mat')\n",
    "kfmap = np.array(kfmap_mat[\"kfmapMAT\"])\n",
    "T2fmap_mat = scipy.io.loadmat('../results/realData/T2fmapMAT.mat')\n",
    "T2fmap = np.array(T2fmap_mat[\"T2f\"])\n",
    "T2rmap_mat = scipy.io.loadmat('../results/realData/T2rmapMAT.mat')\n",
    "T2rmap = np.array(T2rmap_mat[\"T2r\"])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "from plotly import tools\n",
    "\n",
    "xAxis = np.arange(0,88)\n",
    "yAxis = np.arange(0,128)\n",
    "\n",
    "b0map = np.multiply(b0map,mask)\n",
    "b1map = np.multiply(b1map,mask)\n",
    "r1map = np.multiply(r1map,mask)\n",
    "mtdata_angle = np.multiply(mtdata[:,:,:,0].reshape((88,128)),mask)\n",
    "Fmap = np.multiply(Fmap,mask)\n",
    "kfmap = np.multiply(kfmap,mask)\n",
    "T2fmap = np.multiply(T2fmap,mask)\n",
    "T2rmap = np.multiply(T2rmap,mask)\n",
    "\n",
    "trace1 = go.Heatmap(x = xAxis,\n",
    "                   y = yAxis,\n",
    "                   z=np.rot90(b0map,3),\n",
    "                   zmin=-30,\n",
    "                   zmax=30,\n",
    "                   colorscale='Portland',\n",
    "                   colorbar=dict(title = \"B<sub>0</sub> (Hz)\", thickness=35,\n",
    "                           tickfont=dict(family='Times New Roman', size=15), ypad=1),\n",
    "                   visible=True,\n",
    "                   name = 'B<sub>0</sub> (Hz)')\n",
    "trace2 = go.Heatmap(x = xAxis,\n",
    "                   y = yAxis,\n",
    "                   z=np.rot90(b1map,3),\n",
    "                   zmin=0.7,\n",
    "                   zmax=1.3,\n",
    "                   colorscale='Portland',\n",
    "                   colorbar=dict(title = \"B<sub>1</sub>\", thickness=35,\n",
    "                           tickfont=dict(family='Times New Roman', size=15), ypad=1),\n",
    "                   visible=False,\n",
    "                   name = 'B<sub>1</sub> values')\n",
    "trace3 = go.Heatmap(x = xAxis,\n",
    "                   y = yAxis,\n",
    "                   z=np.rot90(r1map,3),\n",
    "                   zmin=0.5,\n",
    "                   zmax=1.2,\n",
    "                   colorscale='Portland',\n",
    "                   colorbar=dict(title = \"R<sub>1</sub> (s<sup>-1</sup>)\", thickness=35,\n",
    "                           tickfont=dict(family='Times New Roman', size=15), ypad=1),\n",
    "                   visible=False,\n",
    "                   name = 'R<sub>1</sub> (s<sup>-1</sup>)')\n",
    "trace4 = go.Heatmap(x = xAxis,\n",
    "                   y = yAxis,\n",
    "                   z=np.rot90(mtdata_angle,3),\n",
    "                   zmin=0.5,\n",
    "                   zmax=1,\n",
    "                   colorscale='Portland',\n",
    "                   colorbar=dict(title = \"MT\", thickness=35,\n",
    "                           tickfont=dict(family='Times New Roman', size=15), ypad=1),\n",
    "                   visible=False,\n",
    "                   name = 'MT (angle 142)')\n",
    "trace5 = go.Heatmap(x = xAxis,\n",
    "                   y = yAxis,\n",
    "                   z=np.rot90(Fmap,3),\n",
    "                   zmin=0.05,\n",
    "                   zmax=0.3,\n",
    "                   colorscale='Portland',\n",
    "                   colorbar=dict(title = \"F\", thickness=35,\n",
    "                           tickfont=dict(family='Times New Roman', size=15), ypad=1),\n",
    "                   visible=True,\n",
    "                   name = 'F')\n",
    "trace6 = go.Heatmap(x = xAxis,\n",
    "                   y = yAxis,\n",
    "                   z=np.rot90(kfmap,3),\n",
    "                   colorscale='Portland',\n",
    "                   colorbar=dict(title = \"k<sub>f</sub> (s<sup>-1</sup>)\", thickness=35,\n",
    "                           tickfont=dict(family='Times New Roman', size=15), ypad=1),\n",
    "                   visible=False,\n",
    "                   name = 'k<sub>f</sub> (s<sup>-1</sup>)')\n",
    "trace7 = go.Heatmap(x = xAxis,\n",
    "                   y = yAxis,\n",
    "                   z=np.rot90(T2fmap,3),\n",
    "                   zmin=0,\n",
    "                   zmax=0.05,\n",
    "                   colorscale='Portland',\n",
    "                   colorbar=dict(title = \"T<sub>2f</sub> (ms)\", thickness=35,\n",
    "                           tickfont=dict(family='Times New Roman', size=15)),\n",
    "                   visible=False,\n",
    "                   name = 'T<sub>2f</sub> (ms)')\n",
    "trace8 = go.Heatmap(x = xAxis,\n",
    "                   y = yAxis,\n",
    "                   z=np.rot90(T2rmap,3),\n",
    "                   zmin=5e-6,\n",
    "                   zmax=25e-6,\n",
    "                   colorscale='Portland',\n",
    "                   colorbar=dict(title = \"T<sub>2r</sub> (s)\", thickness=35, ticklen=7,\n",
    "                           tickfont=dict(family='Times New Roman', size=15)),\n",
    "                   visible=False,\n",
    "                   name = 'T<sub>2r</sub> (μs)')\n",
    "\n",
    "data1=[trace1, trace2, trace3, trace4]\n",
    "data2=[trace5, trace6, trace7, trace8]\n",
    "\n",
    "updatemenus = list([\n",
    "    dict(active=0,\n",
    "         x = 0.2,\n",
    "         xanchor = 'left',\n",
    "         y = -0.15,\n",
    "         yanchor = 'bottom',\n",
    "         direction = 'up',\n",
    "         font=dict(\n",
    "                family='Times New Roman',\n",
    "                size=16\n",
    "            ),\n",
    "         buttons=list([   \n",
    "            dict(label = 'B0 map',\n",
    "                 method = 'update',\n",
    "                 args = [{'visible': [True, False, False, False]},\n",
    "                         ]),\n",
    "            dict(label = 'B1 map',\n",
    "                 method = 'update',\n",
    "                 args = [{'visible': [False, True, False, False]},\n",
    "                         ]),\n",
    "            dict(label = 'R1 map',\n",
    "                 method = 'update',\n",
    "                 args = [{'visible': [False, False, True, False]},\n",
    "                         ]),\n",
    "            dict(label = 'MT data',\n",
    "                 method = 'update',\n",
    "                 args = [{'visible': [False, False, False, True]},\n",
    "                         ])\n",
    "        ]),\n",
    "    )\n",
    "])\n",
    "\n",
    "layout1 = dict(\n",
    "    width=345,\n",
    "    height=345,\n",
    "    margin = dict(\n",
    "                t=40,\n",
    "                r=50,\n",
    "                b=10,\n",
    "                l=50),\n",
    "    annotations=[\n",
    "        dict(\n",
    "            x=0.5,\n",
    "            y=1.15,\n",
    "            showarrow=False,\n",
    "            text='Input maps',\n",
    "            font=dict(\n",
    "                family='Times New Roman',\n",
    "                size=26\n",
    "            ),\n",
    "            xref='paper',\n",
    "            yref='paper'\n",
    "        )\n",
    "    ],\n",
    "    xaxis = dict(range = [0,85], autorange = False,\n",
    "             showgrid = False, zeroline = False, showticklabels = False,\n",
    "             ticks = '', domain=[0, 1]),\n",
    "    yaxis = dict(range = [0,127], autorange = False,\n",
    "             showgrid = False, zeroline = False, showticklabels = False,\n",
    "             ticks = '', domain=[0, 1]),\n",
    "    showlegend = False,\n",
    "    autosize = False,\n",
    "    updatemenus=updatemenus\n",
    ")\n",
    "\n",
    "fig = dict(data=data1,layout=layout1)\n",
    "\n",
    "iplot(fig, filename = 'basic-heatmap', config = config)\n",
    "\n",
    "updatemenus = list([    \n",
    "    dict(active=0,\n",
    "         x = 0.2,\n",
    "         xanchor = 'left',\n",
    "         y = -0.15,\n",
    "         yanchor = 'bottom',\n",
    "         direction = 'up',\n",
    "         font=dict(\n",
    "                family='Times New Roman',\n",
    "                size=16),\n",
    "         buttons=list([   \n",
    "            dict(label = 'F map',\n",
    "                 method = 'update',\n",
    "                 args = [{'visible': [True, False, False, False]},\n",
    "                         ]),\n",
    "            dict(label = 'kf map',\n",
    "                 method = 'update',\n",
    "                 args = [{'visible': [False, True, False, False]},\n",
    "                         ]),\n",
    "            dict(label = 'T2f map',\n",
    "                 method = 'update',\n",
    "                 args = [{'visible': [False, False, True, False]},\n",
    "                         ]),\n",
    "             dict(label = 'T2r map',\n",
    "                 method = 'update',\n",
    "                 args = [{'visible': [False, False, False, True]},\n",
    "                         ])\n",
    "        ]),\n",
    "    )\n",
    "])\n",
    "\n",
    "layout2 = dict(\n",
    "    width=345,\n",
    "    height=345,\n",
    "    margin = dict(\n",
    "                t=40,\n",
    "                r=50,\n",
    "                b=10,\n",
    "                l=50),\n",
    "    annotations=[\n",
    "        dict(\n",
    "            x=0.5,\n",
    "            y=1.15,\n",
    "            showarrow=False,\n",
    "            text='Fitted maps',\n",
    "            font=dict(\n",
    "                family='Times New Roman',\n",
    "                size=26\n",
    "            ),\n",
    "            xref='paper',\n",
    "            yref='paper'\n",
    "        )\n",
    "    ],\n",
    "    xaxis = dict(range = [0,85], autorange = False,\n",
    "             showgrid = False, zeroline = False, showticklabels = False,\n",
    "             ticks = '', domain=[0, 1]),\n",
    "    yaxis = dict(range = [0,127], autorange = False,\n",
    "             showgrid = False, zeroline = False, showticklabels = False,\n",
    "             ticks = '', domain=[0, 1]),\n",
    "    showlegend = False,\n",
    "    autosize = False,\n",
    "    updatemenus=updatemenus\n",
    ")\n",
    "\n",
    "fig = dict(data=data2,layout=layout2)\n",
    "\n",
    "iplot(fig, filename = 'basic-heatmap', config = config)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<center> <h2 style=\"font-family:timesnewroman;font-size:30px\">Summary</h2> </center>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=blog_body>\n",
    "<p style=\"text-align:justify;\">\n",
    "In summary, the Bloch-McConnell equations, an analytical solution to the steady-state signal can be derived and fitted with one of the existing models that make different approximations to fit the qMT data for a different set of parameters. The Sled and Pike model (2001) constrains the solution space by computing complementary T<sub>1</sub> maps, whose acquisition method influences the B<sub>1</sub> sensitivity of the fitted parameters (Boudreau et al. 2018c). This fitting model can be implemented with a continuous or a rectangular wave irradiation of the restricted pool (Cabana et al. 2015). Ramani’s fitting model is an alternative approach that assumes a continuous wave irradiation scheme with the MT pulse on both free and restricted pools (Ramani et al. 2002). Another fitting model was proposed by Yarnykh (2002) where an analytical solution to describe the magnetization is found when the direct saturation of the free pool is neglected.\n",
    "</p>\n",
    "    \n",
    "<p style=\"text-align:justify;\">\n",
    "In future blog posts, we will explore other MT methods, such as MTR (Wolff and Balaban 1989), MTsat (Helms et al. 2008) and qMT-bSSFP (Brieri and Scheffler 2007; Gloor et al. 2008). Additionally, we will also be looking at the effects of RF field inhomogeneity on the generated magnetization transfer maps.\n",
    "</p>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<center> <h2 style=\"font-family:timesnewroman;font-size:30px\">Works Cited</h2> </center>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=biblio_body>\n",
    "<p style=\"text-align:justify;\">\n",
    "Bieri, O. & Scheffler, K., 2007. Optimized balanced steady-state free precession magnetization transfer imaging. <i>Magn. Reson. Med.</i>, 58, pp.511-518. https://doi.org/10.1002/mrm.21326\n",
    "</p>\n",
    "    \n",
    "<p style=\"text-align:justify;\">\n",
    "Boudreau, M. (2018a, October 23). Relaxometry series: Inversion recovery. qMRLab. Retrieved April 26, 2022, from https://qmrlab.org/jekyll/2018/10/23/T1-mapping-inversion-recovery.html\n",
    "</p>\n",
    "   \n",
    "<p style=\"text-align:justify;\">\n",
    "Boudreau, M. (2018b, December 11). Relaxometry series: Variable flip angle. qMRLab. Retrieved April 26, 2022, from https://qmrlab.org/jekyll/2018/12/11/T1-mapping-variable-flip-angle.html\n",
    "</p>\n",
    "\n",
    "<p style=\"text-align:justify;\">\n",
    "Boudreau, M., Stikov, N. & Pike, G.B, 2018c. B1-sensitivity analysis of quantitative magnetization transfer imaging. <i>Magn. Reson. Med.</i>, 79, pp.276-285. https://doi.org/10.1002/mrm.26673\n",
    "</p>\n",
    "    \n",
    "<p style=\"text-align:justify;\">\n",
    "Boudreau, M. (2019, April 08). Relaxometry series: MP2RAGE. qMRLab. Retrieved April 26, 2022, from https://qmrlab.org/2019/04/08/T1-mapping-mp2rage.html\n",
    "</p>\n",
    "\n",
    "<p style=\"text-align:justify;\">\n",
    "Cabana, J.-F., Gu, Y., Boudreau, M., Levesque, I.R., Atchia, Y., Sled, J.G., Narayanan, S., Arnold, D.L., Pike, G.B., Cohen-Adad, J., Duval, T., Vuong, M.-T. & Stikov, N., 2015. Quantitative magnetization transfer imaging made easy with qMTLab: Software for data simulation, analysis, and visualization. <i>Concepts Magn. Reson.</i>, 44A, pp.263-277. https://doi.org/10.1002/cmr.a.21357\n",
    "</p>\n",
    "    \n",
    "<p style=\"text-align:justify;\">\n",
    "Chen, Z., Zhang, H., Jia, Z., Zhong, J., Huang, X., Du, M., Chen, L., Kuang, W., Sweeney, J.A. & Gong, Q., 2015. Magnetization Transfer Imaging of Suicidal Patients with Major Depressive Disorder. <i>Sci. Rep.</i>, 5, 9670. https://doi.org/10.1038/srep09670\n",
    "</p>\n",
    "    \n",
    "<p style=\"text-align:justify;\">\n",
    "Fornari, E., Maeder, P., Meuli, R., Ghika, J. & Knyazeva, M.G., 2012. Demyelination of superficial white matter in early Alzheimer's disease: a magnetization transfer imaging study. <i>Neurobiol. Aging.</i>, 33(2), pp.428.e7-19. https://doi.org/10.1016/j.neurobiolaging.2010.11.014\n",
    "</p>\n",
    "\n",
    "<p style=\"text-align:justify;\">\n",
    "Gloor, M., Scheffler, K. & Bieri, O., 2008. Quantitative magnetization transfer imaging using balanced SSFP. <i>Magn. Reson. Med.</i>, 60, pp.691-700. https://doi.org/10.1002/mrm.21705\n",
    "</p>\n",
    "\n",
    "<p style=\"text-align:justify;\">\n",
    "Helms, G., Dathe, H., Kallenberg, K. & Dechent, P., 2008. High-resolution maps of magnetization transfer with inherent correction for RF inhomogeneity and T1 relaxation obtained from 3D FLASH MRI. <i>Magn. Reson. Med.</i>, 60, pp.1396-1407. https://doi.org/10.1002/mrm.21732\n",
    "</p>\n",
    "\n",
    "<p style=\"text-align:justify;\">\n",
    "Henkelman, R.M., Huang, X., Xiang, Q.-S., Stanisz, G.J., Swanson, S.D. & Bronskill, M.J., 1993. Quantitative interpretation of magnetization transfer. <i>Magn. Reson. Med.</i>, 29, pp.759-766. https://doi.org/10.1002/mrm.1910290607\n",
    "</p>\n",
    "    \n",
    "<p style=\"text-align:justify;\">\n",
    "Henkelman, R.M., Stanisz, G.J. & Graham, S.J., 2001. Magnetization transfer in MRI: a review. <i>NMR Biomed.</i>, 14, pp.57-64. https://doi.org/10.1002/nbm.683\n",
    "</p>\n",
    "\n",
    "<p style=\"text-align:justify;\">\n",
    "Karakuzu, A., Boudreau, M., Duval, T.,Boshkovski, T., Leppert, I.R., Cabana, J.F., Gagnon, I., Beliveau, P., Pike, G.B., Cohen-Adad, J. & Stikov, N., 2020. qMRLab: Quantitative MRI analysis, under one umbrella. <i>Journal of Open Source Software</i>, 5(53), 2343 https://doi.org/10.21105/joss.02343\n",
    "</p>\n",
    "\n",
    "<p style=\"text-align:justify;\">\n",
    "Morrison, C., Stanisz, G. & Henkelman, R.M., 1995. Modeling magnetization transfer for biological-like systems using a semi-solid pool with a super-Lorentzian lineshape and dipolar reservoir. <i>J. Magn. Reson. B.</i>, 108(2), pp.103–113. https://doi.org/10.1006/jmrb.1995.1111\n",
    "</p>\n",
    "\n",
    "<p style=\"text-align:justify;\">\n",
    "Pike, G.B., 1996. Pulsed magnetization transfer contrast in gradient echo imaging: a two-pool analytic description of signal response. <i>Magn. Reson. Med.</i>, 36(1), pp.95-103.  https://doi.org/10.1002/mrm.1910360117\n",
    "</p>\n",
    "\n",
    "<p style=\"text-align:justify;\">\n",
    "Ramani, A., Dalton, C., Miller, D.H., Tofts, P.S. & Barker, G.J., 2002. Precise estimate of fundamental in-vivo MT parameters in human brain in clinically feasible times. <i>Magn. Reson. Imaging.</i>, 20(10), pp.721-731. https://doi.org/10.1016/s0730-725x(02)00598-2\n",
    "</p>\n",
    "    \n",
    "<p style=\"text-align:justify;\">\n",
    "Seiberlich, N., Gulani, V., Campbell, A., Sourbron, S., Ivanova Doneva, M., Calamante, F. & Hu, H.H., (Eds.), 2020. Quantitative magnetic resonance imaging (1st Ed.). Elsevier.\n",
    "</p>\n",
    "\n",
    "<p style=\"text-align:justify;\">\n",
    "Sled, J.G. & Pike, G.B., 1998. Standing-wave and RF penetration artifacts caused by elliptic geometry: an electrodynamic analysis of MRI. <i>IEEE Trans. Med. Imaging.</i>, 17(4), pp.653-662. https://doi.org/10.1109/42.730409\n",
    "</p>\n",
    "\n",
    "<p style=\"text-align:justify;\">\n",
    "Sled, J.G., & Pike, G.B., 2000. Quantitative Interpretation of Magnetization Transfer in Spoiled Gradient Echo MRI Sequences. <i>Journal of Magnetic Resonance.</i>, 145(1), pp.24-36. https://doi.org/10.1006/jmre.2000.2059\n",
    "</p>\n",
    "\n",
    "<p style=\"text-align:justify;\">\n",
    "Sled, J.G. & Pike, G.B., 2001. Quantitative imaging of magnetization transfer exchange and relaxation properties in vivo using MRI. <i>Magn. Reson. Med.</i>, 46, pp.923-931. https://doi.org/10.1002/mrm.1278\n",
    "</p>\n",
    "    \n",
    "<p style=\"text-align:justify;\">\n",
    "Stikov, N., Boudreau, M., Levesque, I.R., Tardif, C.L., Barral, J.K. & Pike, G.B., 2015. On the accuracy of T1 mapping: Searching for common ground. <i>Magn. Reson. Med.</i>, 73, pp.514-522. https://doi.org/10.1002/mrm.25135\n",
    "</p>\n",
    "    \n",
    "<p style=\"text-align:justify;\">\n",
    "Tabelow, K., Balteau, E., Ashburner, J., Callaghan, M.F., Draganski, B., Helms, G., Kherif, F., Leutritz, T., Lutti, A., Phillips, C., Reimer, E., Ruthotto, L., Seif, M., Weiskopf, N., Ziegler, G. & Mohammadi, S., (2019). hMRI - A toolbox for quantitative MRI in neuroscience and clinical research. <i>Neuroimage.</i>, 194, pp.191-210. https://doi.org/10.1016/j.neuroimage.2019.01.029\n",
    "</p>\n",
    "    \n",
    "<p style=\"text-align:justify;\">\n",
    "Wolff, S.D. and Balaban, R.S., (1989), Magnetization transfer contrast (MTC) and tissue water proton relaxation in vivo. <i>Magn. Reson. Med.</i>, 10, pp.135-144. https://doi.org/10.1002/mrm.1910100113\n",
    "</p>\n",
    "\n",
    "<p style=\"text-align:justify;\">\n",
    "Wood, (2018). QUIT: QUantitative Imaging Tools. <i>Journal of Open Source Software</i>, 3(26), 656. https://doi.org/10.21105/joss.00656\n",
    "</p>\n",
    "\n",
    "<p style=\"text-align:justify;\">\n",
    "Wood, T.C. & Malik, S.J., 2020. Magnetization transfer. In N. Seiberlich, V. Gulani, A. Campbell, S. Sourbron, M. I. Doneva, F. Calamante & H. H. Hu (Eds.), Quantitative Magnetic Resonance Imaging, Volume 1. (1st ed, pp.47-64). Elsevier.\n",
    "</p>\n",
    "\n",
    "<p style=\"text-align:justify;\">\n",
    "Yarnykh, V.L., 2002. Pulsed Z-spectroscopic imaging of cross-relaxation parameters in tissues for human MRI: Theory and clinical applications. <i>Magn. Reson. Med.</i>, 47, pp.929-939. https://doi.org/10.1002/mrm.10120\n",
    "</p>\n",
    "\n",
    "<p style=\"text-align:justify;\">\n",
    "Yarnykh, V.L., 2012. Fast macromolecular proton fraction mapping from a single off-resonance magnetization transfer measurement. <i>Magn. Reson. Med.</i>, 68, pp.166-178. https://doi.org/10.1002/mrm.23224\n",
    "</p>\n",
    "    \n",
    "<p style=\"text-align:justify;\">\n",
    "Zheng, Y., Lee, J.-C., Rudick, R. & Fisher, E., 2018. Long-Term Magnetization Transfer Ratio Evolution in Multiple Sclerosis White Matter Lesions. <i>Journal of Neuroimaging</i>, 28, pp.191-198. https://doi.org/10.1111/jon.12480\n",
    "</p>\n",
    "\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# PYTHON CODE\n",
    "\n",
    "display(HTML(\n",
    "    '<style type=\"text/css\">'\n",
    "    '.output_subarea {'\n",
    "        'display: block;'\n",
    "        'margin-left: auto;'\n",
    "        'margin-right: auto;'\n",
    "    '}'\n",
    "    '.blog_body {'\n",
    "        'line-height: 2;'\n",
    "        'font-family: timesnewroman;'\n",
    "        'font-size: 18px;'\n",
    "        'margin-left: 0px;'\n",
    "        'margin-right: 0px;'\n",
    "    '}'\n",
    "    '.biblio_body {'\n",
    "        'line-height: 1.5;'\n",
    "        'font-family: timesnewroman;'\n",
    "        'font-size: 18px;'\n",
    "        'margin-left: 0px;'\n",
    "        'margin-right: 0px;'\n",
    "    '}'\n",
    "    '.note_body {'\n",
    "        'line-height: 1.25;'\n",
    "        'font-family: timesnewroman;'\n",
    "        'font-size: 18px;'\n",
    "        'margin-left: 0px;'\n",
    "        'margin-right: 0px;'\n",
    "        'color: #696969'\n",
    "    '}'\n",
    "    '.figure_caption {'\n",
    "        'line-height: 1.5;'\n",
    "        'font-family: timesnewroman;'\n",
    "        'font-size: 16px;'\n",
    "        'margin-left: 0px;'\n",
    "        'margin-right: 0px'\n",
    "    '}'\n",
    "    'body {margin-left:0px !important;}'\n",
    "    '</style>'\n",
    "))"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "<style>div.prompt {display:none}</style>"
   ]
  }
 ],
 "metadata": {
  "celltoolbar": "Tags",
  "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.7.6"
  },
  "sos": {
   "kernels": [
    [
     "Octave",
     "octave",
     "Octave",
     "#dff8fb"
    ],
    [
     "Python3",
     "python3",
     "Python3",
     "#FFD91A"
    ]
   ],
   "panel": {
    "displayed": true,
    "height": 0,
    "style": "side"
   },
   "version": "0.16.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}