diff --git a/Examples/pk_two_comp.ipynb b/Examples/pk_two_comp.ipynb
deleted file mode 100644
index 7c1f882824b424b80ff8ea8ecb4c09ff311a67ed..0000000000000000000000000000000000000000
--- a/Examples/pk_two_comp.ipynb
+++ /dev/null
@@ -1,585 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "code",
-   "execution_count": 1,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "\"\"\"The pk2Comp object is a two compartment PK model\n",
-    "    that outputs graphs of concentration of tracer over time.\n",
-    "\"\"\"\n",
-    "#!/usr/bin/env python\n",
-    "# coding: utf-8\n",
-    "\n",
-    "# In[1]:\n",
-    "import pathlib\n",
-    "import os\n",
-    "import csv\n",
-    "import re\n",
-    "import math\n",
-    "import numpy as np\n",
-    "import matplotlib.pyplot as plt\n",
-    "\n",
-    "from scipy.integrate import solve_ivp\n",
-    "from scipy.optimize import fmin\n",
-    "# %matplotlib inline\n",
-    "# np.set_printoptions(threshold=sys.maxsize)\n",
-    "\n",
-    "\n",
-    "class pk_two_comp:\n",
-    "    \"\"\"The pk2Comp object is a two compartment PK model\n",
-    "    that outputs graphs of concentration of tracer over time.\n",
-    "    \"\"\"\n",
-    "\n",
-    "    def __init__(self, wd=pathlib.Path('Data').absolute(), filename='CTPERF005_stress.csv'):\n",
-    "        \"\"\"Initializes the model with default parameter values for flow, Vp, Visf, and PS.\n",
-    "        Parameters\n",
-    "        ----------\n",
-    "        time : double[]\n",
-    "            list of all timepoints\n",
-    "        aorta : double[]\n",
-    "            concentration of tracer in aorta (input function)\n",
-    "        myo : double[]\n",
-    "            concentration of tracer in myocardial tissue (conc_isf)\n",
-    "\n",
-    "        Flow : double\n",
-    "            Flow is the flow of plasma through the blood vessel in mL/(mL*min). Defaults to 1/60.\n",
-    "\n",
-    "        Vp : double\n",
-    "            Vp is the volume of plasma in mL. Defaults to 0.05.\n",
-    "\n",
-    "        Visf : double\n",
-    "            Visf is the volume of interstitial fluid in mL. Defaults to 0.15.\n",
-    "\n",
-    "        PS : double\n",
-    "            PS is the permeability-surface area constant in mL/(g*min). Defaults to 1/60.\n",
-    "        \"\"\"\n",
-    "        # Subject Data\n",
-    "        if os.path.basename(os.path.normpath(pathlib.Path().absolute())) != 'Data':\n",
-    "            self.wd = pathlib.Path('Data').absolute()\n",
-    "        else:\n",
-    "            self.wd = wd\n",
-    "\n",
-    "        self.filename = filename\n",
-    "        self.time = []\n",
-    "        self.aorta = []\n",
-    "        self.myo = []\n",
-    "\n",
-    "        # Declare Variables for initial conditions\n",
-    "        # Compartment variables to be fitted\n",
-    "        self.flow = 1/60\n",
-    "        self.visf = 0.15\n",
-    "        self.baseline = 60\n",
-    "\n",
-    "        # Other Compartmental Modelvariables\n",
-    "        self.perm_surf = 0.35\n",
-    "        self.vol_plasma = 0.10\n",
-    "\n",
-    "        # Solved ode\n",
-    "        self.sol = []\n",
-    "\n",
-    "        # Gamma variables\n",
-    "        self.ymax = 250\n",
-    "        self.tmax = 6.5\n",
-    "        self.alpha = 2.5\n",
-    "        self.delay = 0\n",
-    "\n",
-    "        self.deriv_sol = np.array([])\n",
-    "        self.fit_myo = np.array([])\n",
-    "\n",
-    "    def Get_data(self, filename):\n",
-    "        \"\"\"Imports data from all .csv files in directory.\n",
-    "        Parameters\n",
-    "        ----------\n",
-    "        wd : str\n",
-    "            wd is the working directory path\n",
-    "\n",
-    "        Attributes\n",
-    "        ----------\n",
-    "        time : double[]\n",
-    "            list of all timepoints\n",
-    "        aorta : double[]\n",
-    "            concentration of tracer in aorta (input function)\n",
-    "        myo : double[]\n",
-    "            concentration of tracer in myocardial tissue (conc_isf)\n",
-    "\n",
-    "        Returns\n",
-    "        -------\n",
-    "        time : double[]\n",
-    "            list of all timepoints\n",
-    "        aorta : double[]\n",
-    "            concentration of tracer in aorta (input function)\n",
-    "        myo : double[]\n",
-    "            concentration of tracer in myocardial tissue (conc_isf)\n",
-    "        \"\"\"\n",
-    "        os.chdir(self.wd)\n",
-    "        # File not found error\n",
-    "        if not os.path.isfile(filename):\n",
-    "            raise ValueError(\n",
-    "                \"Input file does not exist: {0}. I'll quit now.\".format(filename))\n",
-    "\n",
-    "        data = list(csv.reader(open(filename), delimiter='\\t'))\n",
-    "\n",
-    "        for i in range(12):\n",
-    "            self.time.append(\n",
-    "                float(re.compile('\\d+[.]+\\d+|\\d+').findall(data[i+1][0])[0]))\n",
-    "            self.aorta.append(\n",
-    "                float(re.compile('\\d+[.]+\\d+|\\d+').findall(data[i+1][1])[0]))\n",
-    "            self.myo.append(\n",
-    "                float(re.compile('\\d+[.]+\\d+|\\d+').findall(data[i+1][2])[0]))\n",
-    "\n",
-    "        return self.time, self.aorta, self.myo\n",
-    "\n",
-    "    # gamma_var distribution curve\n",
-    "    def gamma_var(self, time=np.arange(0, 25), ymax=10, tmax=10, alpha=2, delay=0):\n",
-    "        \"\"\"Creates a gamma variate probability density function with given alpha,\n",
-    "        location, and scale values.\n",
-    "        Parameters\n",
-    "        ----------\n",
-    "        t : double[]\n",
-    "            array of timepoints\n",
-    "        ymax : double\n",
-    "            peak y value of gamma distribution\n",
-    "        tmax : double\n",
-    "            location of 50th percentile of function\n",
-    "        alpha : double\n",
-    "            scale parameter\n",
-    "        delay : double\n",
-    "            time delay of which to start gamma distribution\n",
-    "\n",
-    "        Returns\n",
-    "        -------\n",
-    "        y : double[]\n",
-    "            probability density function of your gamma variate.\n",
-    "        \"\"\"\n",
-    "        # Following Madsen 1992 simplified parameterization for gamma variate\n",
-    "        t = time\n",
-    "        self.ymax = ymax\n",
-    "        self.tmax = tmax\n",
-    "        self.alpha = alpha\n",
-    "        self.delay = delay\n",
-    "\n",
-    "        y = np.zeros(np.size(t))  # preallocate output\n",
-    "\n",
-    "        # For odeint, checks if t input is array or float\n",
-    "        if isinstance(t, (list, np.ndarray)):\n",
-    "            for i in range(np.size(y)):\n",
-    "                if t[i] < delay:\n",
-    "                    y[i] = 0\n",
-    "                else:\n",
-    "                    y[i] = round((ymax*tmax**(-alpha)*math.exp(alpha))*(t[i]-delay)\n",
-    "                                 ** alpha*math.exp(-alpha*(t[i]-delay)/tmax), 3)\n",
-    "            return y\n",
-    "\n",
-    "        else:\n",
-    "            y = round((ymax*tmax**(-alpha)*math.exp(alpha))*(t-delay)\n",
-    "                      ** alpha*math.exp(-alpha*(t-delay)/tmax), 3)\n",
-    "            return y\n",
-    "\n",
-    "    # gamma_var_error\n",
-    "    def inputMSE(self, guess=[10, 10, 2, 5]):\n",
-    "        \"\"\"Calculates Mean squared error (MSE) between data and\n",
-    "        gamma variate with given parameters values.\n",
-    "        Parameters\n",
-    "        ----------\n",
-    "        param : ndarray[]\n",
-    "            time : double[]\n",
-    "                array of timepoints\n",
-    "            ymax : double\n",
-    "                peak y value of gamma distribution\n",
-    "            tmax : double\n",
-    "                location of 50th percentile of function\n",
-    "            alpha : double\n",
-    "                scale parameter\n",
-    "            delay : double\n",
-    "                time delay of which to start gamma distribution\n",
-    "\n",
-    "        Returns\n",
-    "        -------\n",
-    "        MSE : double\n",
-    "            Mean squared error\n",
-    "        \"\"\"\n",
-    "        if len(guess) < 1:\n",
-    "            self.ymax = 10\n",
-    "            self.tmax = 10\n",
-    "            self.alpha = 2\n",
-    "            self.delay = 5\n",
-    "        elif len(guess) < 2:\n",
-    "            self.ymax = guess[0]\n",
-    "            self.tmax = 10\n",
-    "            self.alpha = 2\n",
-    "            self.delay = 5\n",
-    "        elif len(guess) < 3:\n",
-    "            self.ymax = guess[0]\n",
-    "            self.tmax = guess[1]\n",
-    "            self.alpha = 2\n",
-    "            self.delay = 5\n",
-    "        elif len(guess) < 4:\n",
-    "            self.ymax = guess[0]\n",
-    "            self.tmax = guess[1]\n",
-    "            self.alpha = guess[2]\n",
-    "            self.delay = 5\n",
-    "        else:\n",
-    "            # Mean squared error (MSE) between data and gamma variate with given parameters\n",
-    "            self.ymax = guess[0]\n",
-    "            self.tmax = guess[1]\n",
-    "            self.alpha = guess[2]\n",
-    "            self.delay = guess[3]\n",
-    "\n",
-    "        mse = 0\n",
-    "\n",
-    "        if self.tmax <= 0 or self.ymax <= 10 or self.delay < 0 or self.alpha < 0 \\\n",
-    "                or self.alpha > 1000 or self.tmax > 1000:\n",
-    "            mse = 1000000  # just return a big number\n",
-    "\n",
-    "        else:\n",
-    "            model_vals = self.gamma_var(\n",
-    "                self.time, self.ymax, self.tmax, self.alpha, self.delay)\n",
-    "\n",
-    "            for i in range(len(self.aorta)):\n",
-    "                mse = (self.aorta[i] - model_vals[i])**2 + mse\n",
-    "            mse = mse / len(self.aorta)\n",
-    "        return round(mse, 3)\n",
-    "\n",
-    "    def inputFuncFit(self, initGuesses):\n",
-    "        \"\"\"Uses fmin algorithm (Nelder-Mead simplex algorithm) to\n",
-    "        minimize loss function (MSE) of input function.\n",
-    "        Parameters\n",
-    "        ----------\n",
-    "        initGuesses : ndarray[]\n",
-    "            Array of initial guesses containing:\n",
-    "                time : double[]\n",
-    "                    array of timepoints\n",
-    "                ymax : double\n",
-    "                    peak y value of gamma distribution\n",
-    "                tmax : double\n",
-    "                    location of 50th percentile of function\n",
-    "                alpha : double\n",
-    "                    scale parameter\n",
-    "                delay : double\n",
-    "                    time delay of which to start gamma distribution\n",
-    "        Returns\n",
-    "        -------\n",
-    "        opt : double[]\n",
-    "            optimized parameters\n",
-    "        \"\"\"\n",
-    "        # Mean squared error (MSE) between data and gamma variate with given parameters\n",
-    "        opt = fmin(self.inputMSE, initGuesses, maxiter=1000)\n",
-    "\n",
-    "        self.ymax = opt[0]\n",
-    "        self.tmax = opt[1]\n",
-    "        self.alpha = opt[2]\n",
-    "        self.delay = opt[3]\n",
-    "\n",
-    "        return opt.round(2)\n",
-    "\n",
-    "    # Derivative function\n",
-    "    def derivs(self, time, curr_vals):\n",
-    "        \"\"\"Finds derivatives of ODEs.\n",
-    "\n",
-    "        Parameters\n",
-    "        ----------\n",
-    "        curr_vals : double[]\n",
-    "            curr_vals it he current values of the variables we wish to\n",
-    "            \"update\" from the curr_vals list.\n",
-    "\n",
-    "        time : double[]\n",
-    "            time is our time array from 0 to tmax with timestep dt.\n",
-    "\n",
-    "        Returns\n",
-    "        -------\n",
-    "        dconc_plasma_dt : double[]\n",
-    "            contains the derivative of concentration in plasma with respect to time.\n",
-    "        dconc_isf_dt : double[]\n",
-    "            contains the derivative of concentration in interstitial fluid with respect to time.\n",
-    "        \"\"\"\n",
-    "        # Unpack the current values of the variables we wish to \"update\" from the curr_vals list\n",
-    "        conc_plasma, conc_isf = curr_vals\n",
-    "\n",
-    "        # Define value of input function conc_in\n",
-    "        conc_in = self.gamma_var(time, self.ymax, self.tmax,\\\n",
-    "                                 self.alpha, self.delay)\n",
-    "\n",
-    "        # Right-hand side of odes, which are used to computer the derivative\n",
-    "        dconc_plasma_dt = (self.flow/self.vol_plasma)*(conc_in - conc_plasma) \\\n",
-    "        + (self.perm_surf/self.vol_plasma)*(conc_isf - conc_plasma)\n",
-    "        dconc_isf_dt = (self.perm_surf/self.visf)*(conc_plasma - conc_isf)\n",
-    "        return dconc_plasma_dt, dconc_isf_dt\n",
-    "\n",
-    "    def outputMSE(self, guess):\n",
-    "        \"\"\"Calculates Mean squared error (MSE) between data and\n",
-    "        gamma variate with given parameters values.\n",
-    "        Parameters\n",
-    "        ----------\n",
-    "        guess : ndarray[]\n",
-    "\n",
-    "            Flow : double\n",
-    "                Flow is the flow of plasma through the blood vessel in mL/(mL*min).\n",
-    "                Defaults to 1/60.\n",
-    "\n",
-    "            Vp : double\n",
-    "                Vp is the volume of plasma in mL. Defaults to 0.05.\n",
-    "\n",
-    "            Visf : double\n",
-    "                Visf is the volume of interstitial fluid in mL. Defaults to 0.15.\n",
-    "\n",
-    "            PS : double\n",
-    "                PS is the permeability-surface area constant in mL/(g*min). Defaults to 1/60.\n",
-    "        Returns\n",
-    "        -------\n",
-    "        MSE : double\n",
-    "            Mean squared error\n",
-    "        \"\"\"\n",
-    "        self.flow = guess[0]\n",
-    "        self.visf = guess[1]\n",
-    "        self.baseline = guess[2]\n",
-    "\n",
-    "        mse = 0\n",
-    "\n",
-    "        if self.flow <= 0 or self.flow >= 25 or self.visf > 100 or self.visf < 0 \\\n",
-    "                or self.baseline > 150 or self.baseline < 0:\n",
-    "            mse = 100000  # just return a big number\n",
-    "\n",
-    "        else:\n",
-    "            sol = solve_ivp(self.derivs, [0, 30], [0, 0], t_eval=self.time)\n",
-    "            MBF = sol.y[0] + sol.y[1]\n",
-    "\n",
-    "            temp = np.asarray(self.myo) - self.baseline\n",
-    "\n",
-    "            for i in range(len(self.myo)):\n",
-    "                mse = (temp[i] - MBF[i])**2 + mse\n",
-    "\n",
-    "            mse = mse / len(self.myo)\n",
-    "        return mse\n",
-    "\n",
-    "    def outputFuncFit(self, initGuesses):\n",
-    "        \"\"\"Uses fmin algorithm (Nelder-Mead simplex algorithm) to minimize\n",
-    "        loss function (MSE) of input function.\n",
-    "        Parameters\n",
-    "        ----------\n",
-    "        initGuesses : ndarray[]\n",
-    "            Array of initial guesses containing:\n",
-    "                time : double[]\n",
-    "                    array of timepoints\n",
-    "                ymax : double\n",
-    "                    peak y value of gamma distribution\n",
-    "                tmax : double\n",
-    "                    location of 50th percentile of function\n",
-    "                alpha : double\n",
-    "                    scale parameter\n",
-    "                delay : double\n",
-    "                    time delay of which to start gamma distribution\n",
-    "        Returns\n",
-    "        -------\n",
-    "        opt : double[]\n",
-    "            optimized parameters\n",
-    "        \"\"\"\n",
-    "        # Mean squared error (MSE) between data and gamma variate with given parameters\n",
-    "        opt1 = fmin(self.outputMSE, initGuesses, maxiter=10000)\n",
-    "\n",
-    "        self.flow = opt1[0]\n",
-    "        self.visf = opt1[1]\n",
-    "        self.baseline = opt1[2]\n",
-    "\n",
-    "        return opt1.round(4)\n",
-    "\n",
-    "    def main(self):\n",
-    "\n",
-    "        # Gets data from file\n",
-    "        self.Get_data(self.filename)\n",
-    "\n",
-    "        # Plots original data\n",
-    "        plt.plot(self.time, self.aorta, 'bo')\n",
-    "        plt.plot(self.time, self.myo, 'ro')\n",
-    "\n",
-    "        # Fit gamma_var input function and plots it\n",
-    "        opt = self.inputFuncFit([250, 7, 4, 0])\n",
-    "        plt.plot(np.arange(0, 25, 0.01), self.gamma_var(np.arange(0, 25, 0.01),\n",
-    "                                                        opt[0], opt[1], opt[2], opt[3]), 'k-')\n",
-    "\n",
-    "        # Fit uptake function and plot it\n",
-    "        opt2 = self.outputFuncFit([.011418, .62, self.myo[0]])\n",
-    "        self.deriv_sol = solve_ivp(self.derivs, [0, 30], [0, 0], t_eval=self.time)\n",
-    "        self.fit_myo = self.deriv_sol.y[0] + self.deriv_sol.y[1]\n",
-    "        plt.plot(self.time, self.fit_myo + self.baseline, 'm-')"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 2,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Optimization terminated successfully.\n",
-      "         Current function value: 225.048000\n",
-      "         Iterations: 82\n",
-      "         Function evaluations: 189\n",
-      "Optimization terminated successfully.\n",
-      "         Current function value: 17.715727\n",
-      "         Iterations: 153\n",
-      "         Function evaluations: 342\n"
-     ]
-    },
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 432x288 with 1 Axes>"
-      ]
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "pk = pk_two_comp()\n",
-    "pk.main()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 3,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Optimization terminated successfully.\n",
-      "         Current function value: 127.579000\n",
-      "         Iterations: 123\n",
-      "         Function evaluations: 246\n",
-      "Optimization terminated successfully.\n",
-      "         Current function value: 8.080500\n",
-      "         Iterations: 88\n",
-      "         Function evaluations: 197\n"
-     ]
-    },
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 432x288 with 1 Axes>"
-      ]
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "pk1 = pk_two_comp(filename = 'CTPERF005_rest.csv')\n",
-    "pk1.main()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 4,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Optimization terminated successfully.\n",
-      "         Current function value: 66.216000\n",
-      "         Iterations: 136\n",
-      "         Function evaluations: 281\n",
-      "Optimization terminated successfully.\n",
-      "         Current function value: 7.342903\n",
-      "         Iterations: 126\n",
-      "         Function evaluations: 243\n"
-     ]
-    },
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 432x288 with 1 Axes>"
-      ]
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "pk2 = pk_two_comp(filename = 'CTPERF006_rest.csv')\n",
-    "pk2.main()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 11,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Optimization terminated successfully.\n",
-      "         Current function value: 109.357000\n",
-      "         Iterations: 110\n",
-      "         Function evaluations: 225\n",
-      "Optimization terminated successfully.\n",
-      "         Current function value: 7.649120\n",
-      "         Iterations: 123\n",
-      "         Function evaluations: 277\n"
-     ]
-    },
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 432x288 with 1 Axes>"
-      ]
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "pk3 = pk_two_comp(filename = 'CTPERF006_stress.csv')\n",
-    "pk3.main()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  }
- ],
- "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.7.1"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 2
-}