small_scale_ammonium_sulfate_precipitation_calc.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Calculating Saturated Ammonium Sulfate to use in Small Scale Ammonium Sulfate Precipitations"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The screen this tool designs is based on Rebecca Oot's Small Scale Ammonium Sulfate Precipitation Screen. Rebbeca is a post-doc in Stephan Wilkens' laboratory, Department of Biochemistry and Molecular Biology, Upstate Medical University, Syracuse, New York, and she initially got the protocol for the screen from Erik Kish-Trier, a former graduate student in Stephan's lab.<br>\n",
    "A webserver version of this tool can be found [here](http://fomightez.pythonanywhere.com/ammonium_screen/) for those looking for a simpler interface.<br>\n",
    "(If you are viewing this in a github repo, then it is the non-interactive version of the Notebook. In order to have the fully functional interactive version, you can click [here to open at mybinder.org](http://mybinder.org/repo/fomightez/small_scale_ammonium_sulfate_precipatation_calculator/notebooks/small_scale_ammonium_sulfate_precipitation_calc.ipynb). Alternatively, you can download it and run it somewhere you have set to work with IPython or Jupyter Notebooks or run and edit it in the cloud at [Domino Data Lab](http://www.dominodatalab.com/), [Wakari.io](https://www.wakari.io/), or [SageMath Cloud](https://cloud.sagemath.com) and working in the cloud.)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Investigator-provided values and options:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Below enter the volume in microliters of protein samples you would like to use in each precipitation mixture. \n",
    "\n",
    "(50 ul or 500 ul seem reasonable suggestions depending on what you have available.)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "protein_sample_volume_microliters = 500"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Below enter in a list with the values separated by commas each of the percent salt conditions at which you'd like to perform the precipitations.\n",
    "\n",
    "(For example, for 30, 40, 50, and 60% salt as the final concentration, enter \n",
    "\n",
    "    percent_salt_values_list = [30, 40, 50, 60]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "percent_salt_values_list = [30, 40, 50, 60]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### That is all that is needed. You can now run this notebook and see the result at the bottom. You can view the individual steps prior to the results."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Calculating volume of a saturated ammonium sulfate solution to mix with the protein sample volumes:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### IF YOU JUST WANT THE RESULT BASED ON WHAT YOU ENTERED ABOVE, SKIP TO BOTTOM OF THIS NOTEBOOK."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### (This is just the behind the scenes stuff.)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# this is the main function of this notebook --> function to calculate needed volume\n",
    "def volume_sat_ammonium_sulfate_required (protein_sample_volume, percent_salt):\n",
    "    '''\n",
    "    given a protein sample volume and a target percent salt (in decimal form) \n",
    "    for the mix, it calculates the volume of a \n",
    "    saturated ammonium sulfate solution (sat. A.S.) to add.\n",
    "    \n",
    "    It is based on the math that:\n",
    "    \n",
    "    volume sat. A.S. / (volume sat. A.S. + protein_sample_volume) = percent_salt\n",
    "    \n",
    "    For example, for a 500 ul protein sample, to obtain 37.5% final salt concentration,\n",
    "    that would be worked out as below:\n",
    "    \n",
    "    x /( 500 + x) = 0.375\n",
    "    \n",
    "    x = 187.5 + 0.375x \n",
    "    1.0x - 0.375x = 187.5\n",
    "    0.625x = 187.5\n",
    "    x = 187.5/0.625\n",
    "    x = 300.0 ul\n",
    "    \n",
    "    So adding 300 ul of saturated ammonium sulfate solution to a 500 ul protein sample\n",
    "    would result in the final ammonium sulfate concentration of 37.5%\n",
    "    \n",
    "    Example of the function in use:\n",
    "        volume_sat_ammonium_sulfate_required (500, 0.375)\n",
    "    \n",
    "    returns\n",
    "        300.0\n",
    "    '''\n",
    "    volume_ammonium_sulfate_required = (protein_sample_volume * percent_salt)/(1.0 - percent_salt)\n",
    "    return float(volume_ammonium_sulfate_required)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# helper function to convert percents to decimal value\n",
    "def convert_percent_to_float(percent):\n",
    "    '''\n",
    "    takes a percent as a number (or even string of a number) \n",
    "    and converts it to decimal form. \n",
    "    \n",
    "    I made it so if includes a '%' symbol, it still works.\n",
    "    \n",
    "    Examples of the function in use:\n",
    "        convert_percent_to_float(20)\n",
    "    returns\n",
    "        0.2\n",
    "        \n",
    "         convert_percent_to_float(37.5)\n",
    "    returns\n",
    "        0.375\n",
    "        \n",
    "        convert_percent_to_float('30%')\n",
    "    returns\n",
    "        0.3\n",
    "        \n",
    "        convert_percent_to_float('37.5%')\n",
    "    returns\n",
    "        0.375\n",
    "    '''\n",
    "    if type(percent) == str:\n",
    "        percent = percent.strip() # strips any exess spaces so % strip will work\n",
    "        # even if space occurs after due to user text entry\n",
    "        if '%' in percent:\n",
    "            return float(percent.strip('%')) / 100.0\n",
    "        else:\n",
    "            return float(percent)/ 100.0\n",
    "    return float(percent)/ 100.0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "#performing the actual calculations\n",
    "volumes_needed_list = []\n",
    "for percent_salts in percent_salt_values_list:\n",
    "    percent_salts_deci = convert_percent_to_float(percent_salts)\n",
    "    volume_needed = volume_sat_ammonium_sulfate_required (protein_sample_volume_microliters, percent_salts_deci)\n",
    "    volumes_needed_list.append(volume_needed)  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Formatting of the output:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### IF YOU JUST WANT THE RESULT BASED ON WHAT YOU ENTERED ABOVE, SKIP TO BOTTOM OF THIS NOTEBOOK."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### (This is just more behind the scenes stuff.)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "def make_markdown_table_of_values(chosen_sample_volume,volumes_list, percents_values_list):\n",
    "    '''\n",
    "    takes the sample, volume, the list of needed volumes of ammonium sulfate needed,\n",
    "    and the percents list and arranges this into an easily readable table in markdown\n",
    "    '''\n",
    "    # originally I had the next line brokwn up using '\\' but I continue to have to \n",
    "    # the problem that when it is in a string, it adds several spaces in middle of\n",
    "    # string where it occurs. So to make table look good I deleted the '\\'\n",
    "    table_header_text = \"| Protein Sample | A.S. (saturated) | % Salt resulting |\\n|:-------------- |:----------------:|:----------------:|\\n\"\n",
    "    table_text = table_header_text\n",
    "    for idx, volume_needed in enumerate(volumes_list):\n",
    "        formatted_volume_needed_str= \"%.2f\" % volume_needed\n",
    "        #next if will help allow use of strings as percent values in\n",
    "        # case entered here as that and will keep code consistent with Django\n",
    "        # implementation where need handling of possible spaces because\n",
    "        # in Django version percents are parts of unicode at first which I converted to string\n",
    "        if type(percents_values_list[idx]) == str:\n",
    "            percent_value = percents_values_list[idx].strip()\n",
    "            # also add a way to deal with % in case user added\n",
    "            if '%' in percent_value:\n",
    "                percent_value = percent_value.strip('%')\n",
    "        else:\n",
    "            percent_value = percents_values_list[idx]\n",
    "        next_line = \"| \" + str(chosen_sample_volume) + \" ul\" \\\n",
    "        + (\" \"* (12 - len(str(chosen_sample_volume))))+ \"| \"\\\n",
    "        +  formatted_volume_needed_str + \" ul\"+ \\\n",
    "        (\" \"* (14 - len(str(formatted_volume_needed_str))))+ \"| \" \\\n",
    "        + str(percent_value) + \"%\" + \\\n",
    "        (\" \"* (16 - len(str(percent_value))))+\"|\\n\"\n",
    "        table_text = table_text + next_line\n",
    "    return table_text\n",
    "\n",
    "\n",
    "# Originally I just had the uncommented, next code line below as the \"THE OUTPUT\" cell below. It generated as output the\n",
    "# raw markdown of the table and was okay looking.\n",
    "#-------------------\n",
    "# print make_markdown_table_of_values(protein_sample_volume_microliters,volumes_needed_list,percent_salt_values_list)\n",
    "#-------------------\n",
    "# However, I had wanted to display a nicely formatted table as the raw markdown would generate if treated as markdown.\n",
    "# I had tried several solutions but none seemed to do it satisifactorily, and then when I was looking for how to do something else in a\n",
    "# Jupyter Notebook, I found the solution at http://stackoverflow.com/questions/32026727/format-output-of-code-cell-with-markdown.\n",
    "from IPython.display import Markdown, display\n",
    "def printmd(string):\n",
    "    display(Markdown(string))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### THE OUTPUT:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "| Protein Sample | A.S. (saturated) | % Salt resulting |\n",
      "|:-------------- |:----------------:|:----------------:|\n",
      "| 500 ul         | 214.29 ul        | 30%              |\n",
      "| 500 ul         | 333.33 ul        | 40%              |\n",
      "| 500 ul         | 500.00 ul        | 50%              |\n",
      "| 500 ul         | 750.00 ul        | 60%              |\n",
      "\n"
     ]
    }
   ],
   "source": [
    "print make_markdown_table_of_values(protein_sample_volume_microliters,volumes_needed_list,percent_salt_values_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "After selecting it, copy and paste the text in the box above into a text editor. The table is formatted to also work well with markdown editors.  \n",
    "Or to display here a fancier version of the table as it would appear in markdown editors:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/markdown": [
       "| Protein Sample | A.S. (saturated) | % Salt resulting |\n",
       "|:-------------- |:----------------:|:----------------:|\n",
       "| 500 ul         | 214.29 ul        | 30%              |\n",
       "| 500 ul         | 333.33 ul        | 40%              |\n",
       "| 500 ul         | 500.00 ul        | 50%              |\n",
       "| 500 ul         | 750.00 ul        | 60%              |\n"
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "printmd (make_markdown_table_of_values(protein_sample_volume_microliters,volumes_needed_list,percent_salt_values_list))"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 2",
   "language": "python",
   "name": "python2"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}