From 3d4567cdd6b980d201354a587ec372edbef5c9fa Mon Sep 17 00:00:00 2001 From: Cassio-Chae Date: Tue, 26 Apr 2022 14:59:12 -0400 Subject: [PATCH] was I here or was I not I do not know --- .DS_Store | Bin 0 -> 6148 bytes .../Model fitting lab-checkpoint.ipynb | 1341 +++++++++++++++++ .../Model fitting lab.ipynb | 6 +- 3 files changed, 1345 insertions(+), 2 deletions(-) create mode 100644 .DS_Store create mode 100644 Second term - model fitting and computation chemistry/.ipynb_checkpoints/Model fitting lab-checkpoint.ipynb diff --git a/.DS_Store b/.DS_Store new file mode 100644 index 0000000000000000000000000000000000000000..44ac7a1d094ccb988ebe21d98f433a9e52ab5d0f GIT binary patch literal 6148 zcmeHK&2G~`5S~rbvI(l10}?&%g98^=bKe_2sMWn-H#ldk)v| z4aOZ(_%SStOc$5fb^S!^C-LYR@Ca5MfJ!wp6$)hOp)EE0-5IY%JPx5@u(t<8~JAh9b=F z@GFx}BCzO3&wyv(CIee`+T-*8`JeCqH;eqtGvFEcrx+0J)9`eRS8`|T#>??ptDxsl p7S3xdUYEcyM=^5wDBgz}fnTu!3>-EV;eq%c0YifyJOg*iz)$FkbDaPH literal 0 HcmV?d00001 diff --git a/Second term - model fitting and computation chemistry/.ipynb_checkpoints/Model fitting lab-checkpoint.ipynb b/Second term - model fitting and computation chemistry/.ipynb_checkpoints/Model fitting lab-checkpoint.ipynb new file mode 100644 index 0000000..9eeade7 --- /dev/null +++ b/Second term - model fitting and computation chemistry/.ipynb_checkpoints/Model fitting lab-checkpoint.ipynb @@ -0,0 +1,1341 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## A note on how you got this file\n", + "\n", + "You got this file in one of two ways: you either downloaded it directly from github to your computer, or you use `nbgitpuller` to pull the repository over to your account on Chem Compute. There are also a couple of other files that need to travel along with this file.\n", + "\n", + "Ideally, if you used `nbgitpuller`, I have it set up to grab the extra files. If you scroll down to \"Taking it further: the search algorithm\" you should see an image that I drew with a squiggly line and some letter annotations.\n", + "\n", + "If you got the Jupyter notebook directly from github, grab the other files as well. It's not complicated, just download all the files from the model fitting lab folder on github, and put them all in a folder on your local computer. Then you should be able to see the image I described, and load up the sample data.\n", + "\n", + "At least, this is how it should work in theory. Let me know if that's not true in practice.\n", + "\n", + "\n", + "# Getting started\n", + "\n", + "The goal of this lab is to twofold:\n", + "1. To give you the programming skills you need to fit data to a model\n", + "2. To teach you how to decide which model is the best model for a given data set\n", + "\n", + "This file is split into three sections. In the first, I import raw data and clean it up for fitting. In the second, I fit the same data set to several functions, and discuss how to decide which is the best model for my data. The final section is your turn: you'll be given a data set and you'll need to fit it yourself.\n", + "\n", + "During the first two sections, I've already done everything. However, as you read, you'll want to interact with the code. Execute each cell, and convince yourself that you understand what it's doing. For some of them, I had to guess-and-check to find a value. In those cases, what you see is usually my final answer. You should repeat the guess-and-check on your own to see how I arrived at the place I'm in. Feel free to edit any cells you like to make sure you understand what's going on. If you want to add a cell of your own to play with, use `Insert->Insert Cell Above/Below`. The keyboard shortcut is `Esc->A` or `Esc->B`.\n", + "\n", + "#### Don't forget the help\n", + "\n", + "Experienced programmers spend much of their time accessing documentation. The trick here is to know what is the best way to get help. Remember that you can type `help(functionname)` in a cell and execute this cell to get inline help. I also recommend having the following documentation websites to hand:\n", + "\n", + "https://docs.python.org/3/tutorial/controlflow.html#defining-functions\n", + "We're doing a lot of work with functions, both ones that you write and ones that exist. It'll be helpful to know the lingo (what is a kwarg??). This is the section in the first Python tutorial on how to write functions, and talks a lot about what goes into a function call. Also, that's the Python tutorial there. You might find it helpful to work through any parts that cover topics you're struggling with.\n", + "\n", + "https://matplotlib.org/index.html\n", + "This is the documentation for matplotlib, the plotting package we're using. I like to open up the Examples, find a graph that looks like what I need, then read.\n", + "\n", + "https://docs.scipy.org/doc/numpy/user/index.html\n", + "Numpy (numeric + python = numpy) is the library that makes Python handle numbers and data wonderfully. This is the documentation link for all of Numpy. Consider poking around the tutorials to get a general familiarity of how Numpy works. If you learn how array broadcasting works, you'll realize that Numpy is magic.\n", + "\n", + "https://docs.scipy.org/doc/numpy/reference/\n", + "In day-to-day work, a reference guide is super helpful, so this is the Numpy reference. It's worth clicking on things like \"Array creation routines\" to realize that Numpy can just *make* make of the arrays that you end up needed.\n", + "\n", + "https://docs.scipy.org/doc/scipy/reference/tutorial/optimize.html\n", + "Scipy is a set of useful tools for scientists (scipy = science + python). This is the documentation for the optimize package, which has all of the model fitting tools we're going to use.\n", + "\n", + "Along the way, realize that I'm showing you how to do new skills in action. It's your job to read the documentation to figure out how I'm doing what I'm doing. To get started, execute the cell below to import the libraries that you'll need, and get rolling.\n", + "\n", + "(Did you forget how to execute a cell? Click on the cell and press `shift+enter`.\n", + "\n", + "***Cassio was here...maybe?***" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "from scipy.optimize import curve_fit" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Help on function loadtxt in module numpy:\n", + "\n", + "loadtxt(fname, dtype=, comments='#', delimiter=None, converters=None, skiprows=0, usecols=None, unpack=False, ndmin=0, encoding='bytes', max_rows=None)\n", + " Load data from a text file.\n", + " \n", + " Each row in the text file must have the same number of values.\n", + " \n", + " Parameters\n", + " ----------\n", + " fname : file, str, or pathlib.Path\n", + " File, filename, or generator to read. If the filename extension is\n", + " ``.gz`` or ``.bz2``, the file is first decompressed. Note that\n", + " generators should return byte strings.\n", + " dtype : data-type, optional\n", + " Data-type of the resulting array; default: float. If this is a\n", + " structured data-type, the resulting array will be 1-dimensional, and\n", + " each row will be interpreted as an element of the array. In this\n", + " case, the number of columns used must match the number of fields in\n", + " the data-type.\n", + " comments : str or sequence of str, optional\n", + " The characters or list of characters used to indicate the start of a\n", + " comment. None implies no comments. For backwards compatibility, byte\n", + " strings will be decoded as 'latin1'. The default is '#'.\n", + " delimiter : str, optional\n", + " The string used to separate values. For backwards compatibility, byte\n", + " strings will be decoded as 'latin1'. The default is whitespace.\n", + " converters : dict, optional\n", + " A dictionary mapping column number to a function that will parse the\n", + " column string into the desired value. E.g., if column 0 is a date\n", + " string: ``converters = {0: datestr2num}``. Converters can also be\n", + " used to provide a default value for missing data (but see also\n", + " `genfromtxt`): ``converters = {3: lambda s: float(s.strip() or 0)}``.\n", + " Default: None.\n", + " skiprows : int, optional\n", + " Skip the first `skiprows` lines, including comments; default: 0.\n", + " usecols : int or sequence, optional\n", + " Which columns to read, with 0 being the first. For example,\n", + " ``usecols = (1,4,5)`` will extract the 2nd, 5th and 6th columns.\n", + " The default, None, results in all columns being read.\n", + " \n", + " .. versionchanged:: 1.11.0\n", + " When a single column has to be read it is possible to use\n", + " an integer instead of a tuple. E.g ``usecols = 3`` reads the\n", + " fourth column the same way as ``usecols = (3,)`` would.\n", + " unpack : bool, optional\n", + " If True, the returned array is transposed, so that arguments may be\n", + " unpacked using ``x, y, z = loadtxt(...)``. When used with a structured\n", + " data-type, arrays are returned for each field. Default is False.\n", + " ndmin : int, optional\n", + " The returned array will have at least `ndmin` dimensions.\n", + " Otherwise mono-dimensional axes will be squeezed.\n", + " Legal values: 0 (default), 1 or 2.\n", + " \n", + " .. versionadded:: 1.6.0\n", + " encoding : str, optional\n", + " Encoding used to decode the inputfile. Does not apply to input streams.\n", + " The special value 'bytes' enables backward compatibility workarounds\n", + " that ensures you receive byte arrays as results if possible and passes\n", + " 'latin1' encoded strings to converters. Override this value to receive\n", + " unicode arrays and pass strings as input to converters. If set to None\n", + " the system default is used. The default value is 'bytes'.\n", + " \n", + " .. versionadded:: 1.14.0\n", + " max_rows : int, optional\n", + " Read `max_rows` lines of content after `skiprows` lines. The default\n", + " is to read all the lines.\n", + " \n", + " .. versionadded:: 1.16.0\n", + " \n", + " Returns\n", + " -------\n", + " out : ndarray\n", + " Data read from the text file.\n", + " \n", + " See Also\n", + " --------\n", + " load, fromstring, fromregex\n", + " genfromtxt : Load data with missing values handled as specified.\n", + " scipy.io.loadmat : reads MATLAB data files\n", + " \n", + " Notes\n", + " -----\n", + " This function aims to be a fast reader for simply formatted files. The\n", + " `genfromtxt` function provides more sophisticated handling of, e.g.,\n", + " lines with missing values.\n", + " \n", + " .. versionadded:: 1.10.0\n", + " \n", + " The strings produced by the Python float.hex method can be used as\n", + " input for floats.\n", + " \n", + " Examples\n", + " --------\n", + " >>> from io import StringIO # StringIO behaves like a file object\n", + " >>> c = StringIO(\"0 1\\n2 3\")\n", + " >>> np.loadtxt(c)\n", + " array([[0., 1.],\n", + " [2., 3.]])\n", + " \n", + " >>> d = StringIO(\"M 21 72\\nF 35 58\")\n", + " >>> np.loadtxt(d, dtype={'names': ('gender', 'age', 'weight'),\n", + " ... 'formats': ('S1', 'i4', 'f4')})\n", + " array([(b'M', 21, 72.), (b'F', 35, 58.)],\n", + " dtype=[('gender', 'S1'), ('age', '>> c = StringIO(\"1,0,2\\n3,0,4\")\n", + " >>> x, y = np.loadtxt(c, delimiter=',', usecols=(0, 2), unpack=True)\n", + " >>> x\n", + " array([1., 3.])\n", + " >>> y\n", + " array([2., 4.])\n", + " \n", + " This example shows how `converters` can be used to convert a field\n", + " with a trailing minus sign into a negative number.\n", + " \n", + " >>> s = StringIO('10.01 31.25-\\n19.22 64.31\\n17.57- 63.94')\n", + " >>> def conv(fld):\n", + " ... return -float(fld[:-1]) if fld.endswith(b'-') else float(fld)\n", + " ...\n", + " >>> np.loadtxt(s, converters={0: conv, 1: conv})\n", + " array([[ 10.01, -31.25],\n", + " [ 19.22, 64.31],\n", + " [-17.57, 63.94]])\n", + "\n" + ] + } + ], + "source": [ + "help(np.loadtxt)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Importing the sample data\n", + "\n", + "The first thing to do is load up the data." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[]" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "data=np.loadtxt(\"F0000CH1.csv\", delimiter=',', usecols=(3,4))\n", + "plt.plot(data[:,0],data[:,1])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "What's going on here? I have my data file saved in a subdirectory, so the first argument tells Jupyter where to look for the file. If you saved the test data somewhere else, then you'll need to edit this line accordingly. The next argument specifies the delimeter, which is the character between each number. You don't always have to specify the delimeter, but if you know it then it's a good idea to put it in.\n", + "\n", + "The third argument gets into data handling. Go ahead and open up the data file in Excel. This file came off of the oscilloscope we're using in the laser experiments. It has a bunch of metadata in the first two columns, which tells us things like what units the data is in and what equipment did the collecting. The metadata is important to know, but not important for data processing. `loadtxt()` wants rectangular data: rows and columns all full of numbers, no gaps or words. Since the metadata is part of the first two columns, and then a gap, I want to tell `loadtxt()` to skip those first three columns, which is what `usecols=()` does. \"But Dr. V\", you say, \"why do you say to use columns 3 and 4? Shouldn't that be columns 4 and 5?\" And that'd be right...if you were in MATLAB. Python uses what's called 0 indexing, which means you start counting at 0 instead of at 1. There are a lot of reasons why, and basically it's wonderful almost all the time, once you get over the hurdle of learning to count from 0.\n", + "\n", + "Now, that way of importing the data is just fine, but accessing the data is a bit cludgy. Depending on how you're accessing your data, it can be nice to put the time vector as one array, and the voltage vector as another array. In the cell below, I import the data a second time, but split up the two arrays. Check the helpful on `loadtxt()` for more info, either by typing `help(np.loadtxt)` into a cell, or by going here: https://docs.scipy.org/doc/numpy/reference/generated/numpy.loadtxt.html" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[]" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "raw_time, raw_voltage = np.loadtxt(\"F0000CH1.csv\", delimiter=',', unpack = True, skiprows=1, usecols=(3,4))\n", + "plt.plot(raw_time,raw_voltage)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Cleaning up the data\n", + "\n", + "### The vertical offset\n", + "\n", + "Notice that the initial signal intensity is not zero. The oscilloscope allows a zero point to be set, but I wasn't very careful that day in lab. I want to shift the whole spectrum down so that that initial intensity is zero. The following cells are me figuring out where that zero section is, then subtracting it off. This is not strictly necessary, as I habitually fit model data to allow for a vertical offset, but it's a nice skill to have, so I show it to you anyway." + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[1 2 3 4 5 6 7 8 9]\n", + "[5 6 7]\n", + "[5 6 7 8 9]\n", + "[1 2 3 4 5 6 7]\n" + ] + } + ], + "source": [ + "thingy = np.arange(1,10,1)\n", + "print(thingy)\n", + "print(thingy[4:7])\n", + "print(thingy[4:])\n", + "print(thingy[:7])" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.021735999999999995\n" + ] + }, + { + "data": { + "text/plain": [ + "[]" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "np.shape(raw_voltage)\n", + "index=400\n", + "plt.plot(raw_time[:index],raw_voltage[:index]) #there are clever ways to grab the derivative of voltage,\n", + " # find the index of the sudden rise,and work from there. If I was doing 100 samples I'd work out that algorithm.\n", + " # but I'm just doing one. So I did a guess-and-check on the plot until I figured\n", + " # out which index gave me just the zero portion of the spectrum.\n", + " # Try playing with the index I gave, to zoom the plot horizontally and see how I did it.\n", + "initialAverage = np.average(raw_voltage[:index]) #this calculates the average value for the initial section of voltage\n", + "print(initialAverage) #prints that average so I can see what's happening\n", + "voltageAdj = raw_voltage - initialAverage #create a new voltage array subtracting off that initial value\n", + "plt.figure(2) #open a second figure window so it doesn't overwrite the previous graph\n", + "plt.plot(raw_time,voltageAdj)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Trimming it horizontally\n", + "\n", + "Now, I don't want to fit this whole shape. I just want the decay portion of my signal. So I'm gonna zoom around a bit and figure out where the signal stops rising and begins to show the decay. I'll then work out the index for that, and grab store a new time and voltage vector with the rise portion chopped off." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXoAAAEFCAYAAADt1CyEAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8vihELAAAACXBIWXMAAAsTAAALEwEAmpwYAAAk5UlEQVR4nO3deXiU5b3/8fc3G4QtIITFAAZkB0ExIggqalUWLUrVup96XGpx72LRVqt1AW2P26lgUVuP/bnWrSiIuwIqSwABAwgBAoQ1IIQ1ZLt/f8wwZJJJMpDlmcx8XtfFdT3L/cx8Zxw/3DzLfZtzDhERiV5xXhcgIiJ1S0EvIhLlFPQiIlFOQS8iEuUU9CIiUS7B6wJCadOmjUtPT/e6DBGRBmPBggXbnXOpofZFZNCnp6eTmZnpdRkiIg2Gma2rbJ9O3YiIRDkFvYhIlFPQi4hEOQW9iEiUU9CLiEQ5Bb2ISJRT0IuIRLmoCvr5OT+yYstur8sQEYkoEfnA1NG69LlvAciZONrjSkREIkdU9egP2V1Q5HUJIiIRIyqDfsG6nV6XICISMaIy6K/753wmf7na6zJERCJCVAX9yH7tA8uPzVjhYSUiIpEjqoJ+8tUnB63PWpXnUSUiIpEjqoIe4N1xpwWW//7VGg8rERGJDFEX9Cd1bsXwnr6x92dnb/e4GhER70Vd0ANMHNvf6xJERCJGVAZ9+5TGXpcgIhIxojLoy9q1v9DrEkREPBVW0JvZCDP7wcyyzWx8iP1mZs/49y8xs4Fl9t1lZllm9r2ZvWZm9drd/ihrS32+nYhIxKk26M0sHngWGAn0Aa4wsz7lmo0Euvv/3ARM9h+bBtwOZDjn+gHxwOW1Vn0Vsh48H4Dfv72UHXsP1sdbiohEpHB69IOAbOfcGudcIfA6MKZcmzHAy85nDtDSzDr49yUAyWaWADQBNtVS7VVqkhQfWP5/c9bXx1uKiESkcII+DdhQZj3Xv63aNs65jcBfgfXAZiDfOfdxqDcxs5vMLNPMMvPyav6gk5nRorFvcM4nP11Jaamr8WuKiDRE4QS9hdhWPjVDtjGzVvh6+12AY4GmZnZ1qDdxzk1xzmU45zJSU1PDKKt6/7xuUGB5w879tfKaIiINTThBnwt0KrPekYqnXypr8xNgrXMuzzlXBLwDnEY9GdAxJbA8c6WGQxCR2BRO0M8HuptZFzNLwncxdWq5NlOBa/133wzGd4pmM75TNoPNrImZGXAOsLwW669SQvzhj7duh3r0IhKbqg1651wxcCvwEb6QftM5l2VmN5vZzf5m04E1QDbwPDDOf+xc4C1gIbDU/35TavtDhOOF2WspKCrx4q1FRDxlzkXeRcqMjAyXmZlZK6+1cusezntyJgAf33UGPdo1r5XXFRGJJGa2wDmXEWpf1D8ZWzbYDwW+iEgsifqgB5h77zmB5dmrNKKliMSWmAj6di0Oj7pw9YtzNXm4iMSUmAj68hZv2OV1CSIi9SZmgj6tZXJg+ZoX53lYiYhI/YqZoP96/Nm8/ashgfXiklIPqxERqT8xE/QA3doevgPnsxXbPKxERKT+xFTQpyQnBpaX5uZ7WImISP2JqaAHuOOc7gD87YtsjysREakfMRf0/csMdCYiEgtiLujP6tkWgDEnHutxJSIi9SPmgj4uzjd0/n++26T5ZEUkJsRc0Jf1/Mw1XpcgIlLnYjLo7x3VC4Af9xV6XImISN2LyaC/8fSuAKzZvo+73viORet3elyRiEjdicmg90125fPuoo1cPOkbD6sREalbMRn0oZSWRt4ELCIitSFmg/7mM48PWs/O2+tRJSIidStmg/6aIccFrZ/35Exue22RR9WIiNSdmA36Di0ac1lGRwaUeVL2/cWbPKxIRKRuxGzQx8UZj18ygP/cOixo+6QvNQaOiESXmA36sp6+/MTA8uMzfvCuEBGROqCgB8acmBa0fuZfvvCoEhGR2qegD2Hdjv1elyAiUmsU9H6XntzR6xJEROqEgt7v/gv78JdL+gOQFK+vRUSihxLNr3njRC7N6ARAYUkpzulJWRGJDgr6Spz66Gdszj/gdRkiIjWmoC8nKcH3lWzbc5AhEz73uBoRkZpT0JeT9eD5Qet5ew56VImISO1Q0JeTWO5C7EXPfu1RJSIitUNBH8I7404LLG/cdYB1O/Z5WI2ISM0o6EMY0LFl0Pof3/vem0JERGqBgj6E+Djj7hE9A+sJcVZFaxGRyKagr8T1w7oElnu2b+FhJSIiNaOgr0SjhPjAclFJqYeViIjUjIK+CjN/dxYAHy7dzDert3tcjYjI0Qkr6M1shJn9YGbZZjY+xH4zs2f8+5eY2cAy+1qa2VtmtsLMlpvZkNr8AHWpc+sm9OnQgk35BVz5/Fzmrf3R65JERI5YtUFvZvHAs8BIoA9whZn1KddsJNDd/+cmYHKZfU8DM5xzvYABwPJaqLvevPiLjMDyyq17PKxEROTohNOjHwRkO+fWOOcKgdeBMeXajAFedj5zgJZm1sHMWgBnAC8COOcKnXO7aq/8utchJTmw3LxxgoeViIgcnXCCPg3YUGY9178tnDZdgTzgn2a2yMxeMLOmNajXE9Nu980rO/nL1R5XIiJy5MIJ+lA3kZcfw7eyNgnAQGCyc+4kYB9Q4Rw/gJndZGaZZpaZl5cXRln1p2OrJgCs2KJTNyLS8IQT9LlApzLrHYFNYbbJBXKdc3P929/CF/wVOOemOOcynHMZqamp4dReb1KSEwPLr8xd52ElIiJHLpygnw90N7MuZpYEXA5MLddmKnCt/+6bwUC+c26zc24LsMHMDj1meg6wrLaKr08/909K8sqc9R5XIiJyZKq9uuicKzazW4GPgHjgH865LDO72b//OWA6MArIBvYD15V5iduAV/x/Sawpt6/BeOyS/pQ4xzfZ27nnnSW8Nm8Dr9xwKkO7tfG6NBGRKlkkTpmXkZHhMjMzvS6jgkenL+flb3MoKDr8pGzOxNEeViQi4mNmC5xzGaH26cnYI3BM06SgkBcRaQgU9Edg7MDyd5X6HqIq1lg4IhLBFPRHoG3zxpzdq23QtvOenEnv+2d4VJGISPX0qOcRevbKgby/eBNZm/L5v299t1oWlUTedQ4RkUPUoz9CyUnxXHZKJ64b2qX6xiIiEUBBf5TS2zTli98OJynB9xUWFJV4XJGISGgK+hro0qYpp6S3AmDWKo1XLyKRSUFfQ49fMgCAG1/O5PbXFrF8826PKxIRCaagr6G2zRsFlqcu3sTIp2d5WI2ISEUK+hpKjI/jZwM7Bm1btkm9ehGJHAr6WrBj38Gg9We/yPaoEhGRihT0taB100ZB69OWbvaoEhGRihT0teD+C/twxaDOQdsicbA4EYlNCvpakJKcyISxJwSNZHndS/M9rEhE5DAFfR358oc8SkrVqxcR7yno69D7i8vPuCgiUv8U9LVsxUMjePxn/QG4843vyN9f5HFFIhLrFPS1rHGib9CzQwb8+WMPqxERUdDXC01MIiJeUtDXkad+fmJg+bV5670rRERinoK+jlx00uFpB+/7TxYHCjWMsYh4Q0FfhyZfNTCw/MrcdR5WIiKxTEFfh0ae0CGw/PC05fywZY+H1YhIrFLQ17GHxvQNLP/5gywPKxGRWKWgr2PXDEkPLH+dvYP08dNIHz/Nu4JEJOYo6D2iQc9EpL4o6OtB2dM3h+w9WOxBJSISixT09eDqwcdx29ndGNmvfWBbZs5ODysSkViioK8HZsZvzuvJ5KtPZso1JwO+YYzzD2gcHBGpewr6enbyca0Cyznb93lYiYjECgV9PWvZJCmwfOlz33pYiYjECgV9PYuPM564bAAAhSWlvDp3Pd9kb/e4KhGJZgleFxCLzurZNrB877tLAYKmIRQRqU3q0XugVdOkCtuW5uZ7UImIxAIFvUfeGXda0Pr9U7/3qBIRiXYKeo8M7NyKKwZ1DqwvWr+L9PHT2LW/0MOqRCQaKeg99MszutL32BZB277O3uFRNSISrRT0Hkpv05Rpt5/Ou2VO49zy6kI25x/wsCoRiTZhBb2ZjTCzH8ws28zGh9hvZvaMf/8SMxtYbn+8mS0ysw9qq/Bo0i8tJWj9+427PapERKJRtUFvZvHAs8BIoA9whZn1KddsJNDd/+cmYHK5/XcAy2tcbZRKjA/+z7Bis4JeRGpPOD36QUC2c26Nc64QeB0YU67NGOBl5zMHaGlmHQDMrCMwGnihFuuOOh/cNowJY08A4H8+WcnkL1ezJb/A46pEJBqEE/RpwIYy67n+beG2eQq4Gyit6k3M7CYzyzSzzLy8vDDKii790lKC7sJ5bMYKBk/4zMOKRCRahBP0FmJb+VkzQrYxswuAbc65BdW9iXNuinMuwzmXkZqaGkZZ0alJUnzQ+qxVsfeXnojUrnCCPhfoVGa9I7ApzDZDgZ+aWQ6+Uz5nm9n/O+pqY8ChcXAOuebFeR5VIiLRIpygnw90N7MuZpYEXA5MLddmKnCt/+6bwUC+c26zc+4e51xH51y6/7jPnXNX1+YHiDYj+nWosO37jfmkj5/G7a8t8qAiEWnoqg1651wxcCvwEb47Z950zmWZ2c1mdrO/2XRgDZANPA+Mq6N6Y8IjF/ejUcLh/zQX/O9sAKYu3qS5ZkXkiFkkBkdGRobLzMz0ugzPpY+fVmHb45f057KMTiFai0gsM7MFzrmMUPv0ZGwDc/dbS7wuQUQaGAV9BHvwp31Dbi8oKqnnSkSkIVPQR7CrTu3M787vyaD0Y/jPLUMD27M27aa0NPJOuYlIZNI5+gbkk2VbufFl3/fy84xOPHZJf48rEpFIoXP0UeLETi0Dy29kbtApHBEJi4K+AWldbgrC3/x7sUeViEhDoqBvQOLijLn3nkPXNk0BmLZkM1MXb+KBqVk8+0W2x9WJSKRK8LoAOTLtWjTm1rO78es3fb35sk/LntipJUO7tfGqNBGJUOrRN0BjB3bkv4d2qbD9qhfmMuHD5by1INeDqkQkUqlH30Ctztsbcvvfv1oDwE8HHEtSgv4eFxH16Buspo0OD2ecM3F0hf2TvtQ5exHxUdA3UA9c6Htq9tUbTgXg5jOPD9r/1Ker6r0mEYlMCvoGqm2LxuRMHM1p/ouv40f2qtDmpa/X1ndZIhKBFPRR5KYzugatP/D+Mo8qEZFIoqCPIveO6s2ce84J2pa356BH1YhIpFDQR5n2KY2ZMPaEwPrUxZsoKqlyXnYRiXIK+ih0xaDOgeWHPljGlc/P8bAaEfGagj5Kzbr7LAb4B0Gbn7OTpbn5FBarZy8SixT0UarTMU145KJ+gfUL/zabR6cv97AiEfGKgj6K9UtL4dohxwXWF6zbyfycH8netsfDqkSkvmkIhCjXLy0lsFxc6rj0uW+B0E/Tikh0Uo8+yp18XKvA8vLNuz2sRES8oqCPcsc0Saq+kYhENZ26iXItkhNDbk8fPy2w/NXvhnNc66b1VZKI1DP16KNcfJxx94ieDOnautI2N728oB4rEpH6Zs45r2uoICMjw2VmZnpdRlQq25MP5e1fnRZ0Xl9EGgYzW+Ccywi1Tz36GDPt9mFV7n/ikx9CbnfOUVoaeZ0CEamegj7G9D02hU7HJAPQumnFC7VZm0LfmdPvTx9x0aSv67Q2Eakbuhgbg94dN5Qt+QW0a9GYL1ZsY+2OfUz+cjUABUUlLFq/k427DtCtbTMOFpVSXOrYV1jCktx8jysXkaOhoI9BbZo1ok2zRgBcdkongDJBX8rFk77xrDYRqX06dSMAZP7xJ2G1O/XRT3lgahaReBFfREJT0Avg6+X3S2tRbbutuw/y0jc5TF28qR6qEpHaoKCXgA9uO50VD40Iq+0dr39HcYgJTTbnH+CtBbm1XZqI1ICCXoI0ToznxE4t+fW5PUht3oj7LuhTads3MysG+lXPz+W3/17MvoPFdVmmiBwBXYyVCt67ZSgAt5/THYDrh3UBKj5stfdgEYXFpfT444cAzLv3HNZs3wdA3z99xOs3DWZwFU/kikj9UI9ewja8ZyotmxweO8c5+HzF1sD6ra8tCmp/+RRNYSgSCRT0EraXrhvEd/efR4p/oLQJH67g+42HH7Cat/bHCsfoaVoR74UV9GY2wsx+MLNsMxsfYr+Z2TP+/UvMbKB/eycz+8LMlptZlpndUdsfQOrf9DtODywfLC6psu2eAp2rF/FatUFvZvHAs8BIoA9whZmVv0I3Euju/3MTMNm/vRj4jXOuNzAYuCXEsdLApLVMDiw/P2tthf2P/eyEwPLO/YX1UpOIVC6cHv0gINs5t8Y5Vwi8Dowp12YM8LLzmQO0NLMOzrnNzrmFAM65PcByIK0W6xePnNenXdD6H0f3DixfltEpsLy7oAiA7XsPsr9QvXsRL4QT9GnAhjLruVQM62rbmFk6cBIwN9SbmNlNZpZpZpl5eXlhlCVeGjuwY9D6SZ0PD21sZoHl37+9lB17D5Lx8Kf0uf+jeqtPRA4L5/ZKC7Gt/BW2KtuYWTPgbeBO51zI4RGdc1OAKeAbjz6MusRD5/ZpxxOXDaBt88aktUqmS5vQM1Qt37ybl77JCazn7TlIavNGrMnbS3ycaWYrkXoQTo8+F+hUZr0jUP7590rbmFkivpB/xTn3ztGXKpEkPs4YO7Ajw7q3CQr5UJOW/O/n2YHlUx75FIART89irAZPE6kX4QT9fKC7mXUxsyTgcmBquTZTgWv9d98MBvKdc5vN92/4F4HlzrknarVyiThZD57PazcOBmDlwyM5rnWTkO0u+/u3FBaXsmNfIV/8sI1vsrfXZ5kiMafaoHfOFQO3Ah/hu5j6pnMuy8xuNrOb/c2mA2uAbOB5YJx/+1DgGuBsM/vO/2dUbX8IiQxNGyWQlOD7SSUlxDFu+PGBfad2OSawXPZ+++v+OZ8rXwh52UZEaonmjJU6VeJ/YCo+zqqcr3ZE3/Y8dfmJNE6Mr6/SRKKK5owVz8THGfFxoa7VB5uRtYXMnJ31UJFI7FHQiydyJo7ml2d2Ddp29YtzNWSCSB1Q0Eu9ee+WofRLa8EjF/cDYNyZ3bhiUGdO794m0GZT/gGvyhOJWjpHL547UFhC7/tnBNZzJo4GYMzfZjOiXwd+VeairoiEpnP0EtGSk+IZ0DElsO6co6TUsTg3n8dmrPCwMpHooKCXiPDGL4cEln/77yUcf+/0wHr6+GnMWqVhMUSOloJeIkLZ2yrfXlhxisK731rC2u37WJO3ly35BfVZmkiDp6kEpUHYnF/AWX/9MrB+6Dy+iFRPPXqJGPPuPSfstg99sIxvsrfz7qJcJny4nMLiUgBWbNnN1t3q8YuUpR69RIy2LRpzw7AuvDC74mQm5b04ey0vlmm3Nb+Apy4/iRFPzcIM1k5Qj1/kEN1eKRHFOcfO/UU0a5RAnEG3P3wIwIqHRrBzfyFDJnwe1ut8ctcZTP5yNZvyD/DSdYOqHFphyszV5OzYz6MXn1BpG5FIV9XtlerRS0QxM45pmhRYH3VCe5omJdA4MZ4OKcmc2SOVr1ZWfwfOuU/ODCw/+clK7hnVO2S74pJSHp3uu4Xz+mFdOD61WQ0/gUjkUY9eGpyqBkcLpUe7ZpSUOsYO7MgtZ3ULbM/Zvo/hZS7wAky7fRh9j01BpKHRA1MSVf51/SCuOrVz2O1Xbt3L6rx9/OWjH4K2/33mmgptL/zf2TWuTyTSKOilwTm9eyqPlDmfnhQfR87E0eRMHM2zVw6s8tjRz8wCYGluPq/NWw9Av7QW3H62r6df6uDO1xfVUeUi3lDQS4P19OUncn7fdrx/27CQ+1s1SaywLWuTb8risvPYThzbn5Qmh68LvPfdJiLxlKbI0VLQS4M15sQ0/n5NBj3bNw9sa5Hsu7/guqHpLLr/vJDHpY+fFvT0bb+0FPp3DD4vf+cb39V+wSIeUdBLVBnWrQ1PXDaA34/oBcD7tw5jeM9U/lDJXTeHZBzXKmiS8/98t4mNuw6wp6BID2BJg6e7biRmhLpbp3eHFnx4x+kAfL8xnwsquRg7+/dn0bFV6MnORSKB7qMXCeGVG06la+rhXny/tBQeGtOX+/6TVaHtM5+tYsLY/qzYspv4OKNX+xYhX3Paks3MWbODod3a0OmYZLq28d2X/9XKbWzaVUCpv2PlHPRNa8Fpx7fhq5V57NpfyNm92tK8ccXrCiI1paCXmNIoIY6D/nFxhnZrU2H/NUPSyd15oMKtl29m5vLxsq3s2l8EwIw7T68Q9lvyC7jl1YUA/GvOOsA36XmnY5J5flboYR1m3X0W//WPeQBcltGRxy8ZUINPJxKagl5ixpIHzqNxQjxbdxeQ2rxRpe3uHtGL64d1YdCjnwVtPxTyACOemsWZPVJxQLfUZkxdvJEOKckVXmtG1pYqa5qf82NgedH6XWzJL2Dt9n0MOb51mJ9KpHo6Ry9SiSN9Arem0lomc7C4hO17CzUMsxwxPRkrchQOPYS1+tFRR3TcH0eHvsMn+5GRVb7Wxl0H2L63EIBJX2aTPn4aY/42mxdnr61wX//a7fsCp4fq2ub8A7wwa42eLWjAFPQi1YiPM35zbo+w2/90wLHcWmZMHYDjU5uSEB9HfJzx0Ji+1b7G4zN8wzUszs3noQ+WsXX3waD9Yyd9zX3vfR8Yh78ujXtlIQ9PW07uzgN1/l5SN3TqRqQGnHN0uefw/LblT7kcOv1TfvuqrXuCRtgM1/I/j+CLH7Yx7pWFgW0vXXcKw3u2pfd9MzhQVMLiP51HSnKop4LzeX3eBvoc24L4OOOyjE7Vvt9fPlrBs1+sBuCKQZ2ZMFZDOUcqnboRqSNmxtiT0gBC9tR/fW6PwDg6ZXUtMxzy5ad0YtJVVY/Rc8iMrM28v3hT0LbbX1tESanjQFEJAC+XGd6hrBv+L5N/zVnHPe8s5e63loT1fodCHgiMDSQNj3r0IhGg/L8MaqrsA17//HotD76/rEKbGXeezrJNu/n1m4sD27747fDAE8J/+3wVf/14ZdAxT/58ABef1LHW6owVT3yykuWbd/P8tSE73LVCPXqRCGdmPHxRP9JaJjPqhPb89dIBJCfG0zW1KXf+pDunpLeqcMywEM8BHLJw/S6KS0rZXVAUMuQB/jk7JyjkAf717brAef+5a323fpYdHO6uN4LbVyXc6weFxaXsLyzmYHFJ2K/d0Dzz2So+WbbVs/dXj16kAdhTUMQJD3wctC1n4uhKbwG9YlAnXpu34ajf79krBwYe/sqZOJq3FuTy23/7Qv75azM4t0870sdP42cDO/I/lwU/5LVzXyEnPfRJYL1Hu2bsO1jC1+PPrvA+Yyd9zcL1uwLrP+ndljlrfuT7B88PfLZ+aS344DbfMBWlpY6u904P1HXIra8u5KOsLax6ZBSPz1jBpC9Xs3bCKMzsiD53+WsnHVslM/v3Fes+Eic88BF7CoqB4AftDv0rbtzw47nbPzZTTahHL9LANW+cGDTW/kMX9QvZ7q6f+O4OChXyF5+UxmM/C+9i6t9nrg5av3BAh8Dyg+9nMc/f2397YS6ZOT8yc2UeC9bt5PuN+Xy2YlvQsSu37mXjrgMs37ybZZt2s2t/IYs37GLFlt1BIQ/w6fJt7D1YzLod+wLbvt+4m/2FxWzJL+Dr1dsD25dv3s3C9TvZua+QD5ZspqjEsXLrHiZ96at96uJNLMndFfK20JJSx4Yf97No/U42/Lgf5xzzc37kmc+zg9rl7jxAQdHR/0ujsLg0EPIAr85dz+xV2/lk2dZAD3/Sl6vZkl9Qp7evqkcv0oBMmbmaR6evCEx5+N8vzedzf7DeeHoX7h3Vu9Jz/a/fNJjBXVsz+NHP2HIEI3Ie6jlfPuVb5qz5sZrWkeedcacxsHPwqa+HP1jGC7MPD0tx8UlpvLtoY8jjrx/Whfsu6HNU7/3cV6uZ+OGKsNred0Efrh/W5ajeB6ru0SvoRRoQ5xxrtu8LTGJeUFTC9r0HKSpxdGqVTEJ8XNDpnPsu6MNZPVMpdY5ubX3j9u8pKOLO17/jsxXb6NGuGXf9pAfd2zVndd7ewDhAKcmJ7NpfyOndUwOTtW/OP8CQCZ9XWltVYem1r343nONaN6W01DFn7Q6ufH7uER3/4n9lkLvzAOf1bcfjM35g38FimjVOYNzw48nbU8js7DxaN23EhQOODQyvsWDdTn42+RsA/jCqN49MX17t+8z83Vl0bn10o6Qq6EViyKinZ7Fss28mrawHz6dpo4pDWmVtymf0M7P5xy8yOLtXu7Bet7iklG5/+LDS/S9cm8ENLx/5/7ftWjSq8EBYXciZOJp/fZsTcnTS2pKSnMjiP53Htj0FDHrk8FhJVV1PKe9oh79Q0IvEkJJSx17/eeGUENMpHlJYXEpSwpFdpjtYXML+gyWBi62L7juXfYXFtG7aiOSkeLbkFzB4QvBgcHPuOYeU5ETeWrAhELIpyYlMu30YLZITSYyLIyHeKC5x7DlYFAjIn2d04g8X9KZ/uYvQ2Y+MZNeBIjIe/rTSOnu1b857twzlzx8s49W5vvv/WzZJDBqYLpS+x7bguatPpk2zRsTFQa/7ZlAbEZkzcTSzVuVxzYvzAtteueFUTurckpFPz2Ldjv1BbY+GLsaKxJD4OCOlSWKVIQ8cccgDNEqIp1XTJEb2a8/5fdvRqmkSHVs1ITkpHoD2KY1Ja5nMPSN70bZ5I+4d1Yv2KY1JTopn1AmHL+g+fFE/OrZqQovGiSQnxZMYH0dyUjxtmzcOtLluWDotyo3Pf2aPVBLi42jTrBFn9EgNbE+IC7675nfn96RxYjz/PfTwOe/qQh7ggZ/2pdMxvs/TKCGeyWE+yFaVG0/31TCgU0vK3gTUv2MKTZISqp39rDaoRy8i9aayISFq6tW567n33aX8PKMTj13SP+R7ltWlTVO++O3wI3qP8q9z3wV9eOiD0M8olBXOZy372p716M1shJn9YGbZZjY+xH4zs2f8+5eY2cBwjxWR2DHpqoH84rT0Wn/d0f07MKRra247p+JwE2VvRW3i/5fH5Ktr1lMfP7IX5/c9fG0jKT50lD5xWXgTyfzPpb52HVIaV9Py6FTbozezeGAlcC6QC8wHrnDOLSvTZhRwGzAKOBV42jl3ajjHhqIevYhEmqc/XcWTn67knpG9+OWZx3tdTgU1nTN2EJDtnFvjf7HXgTFA2bAeA7zsfH9rzDGzlmbWAUgP41gRkYh34xld2FdYzH/Vwb9I6lo4p27SgLKP2eX6t4XTJpxjATCzm8ws08wy8/LywihLRKT+NElK4N5RvWmcGO91KUcsnKAPNVhE+fM9lbUJ51jfRuemOOcynHMZqampoZqIiMhRCOfUTS5QdoaCjsCmMNskhXGsiIjUoXB69POB7mbWxcySgMuBqeXaTAWu9d99MxjId85tDvNYERGpQ9X26J1zxWZ2K/AREA/8wzmXZWY3+/c/B0zHd8dNNrAfuK6qY+vkk4iISEh6YEpEJApoCAQRkRimoBcRiXIKehGRKBeR5+jNLA9YdwSHtAG2V9sqNum7qZy+m9D0vVQukr+b45xzIR9CisigP1JmllnZRYhYp++mcvpuQtP3UrmG+t3o1I2ISJRT0IuIRLloCfopXhcQwfTdVE7fTWj6XirXIL+bqDhHLyIilYuWHr2IiFRCQS8iEuUaTNDXZN7aaBfGdzPczPLN7Dv/n/u9qNMLZvYPM9tmZt9Xsj8mfzdhfC+x/JvpZGZfmNlyM8sysztCtGlYvxvnXMT/wTfy5WqgK74x7hcDfcq1GQV8iG+yk8HAXK/rjqDvZjjwgde1evT9nAEMBL6vZH+s/m6q+15i+TfTARjoX26Ob97rBp03DaVHH5i31jlXCByae7aswLy1zrk5wKF5a6NdON9NzHLOzQR+rKJJTP5uwvheYpZzbrNzbqF/eQ+wnIpToDao301DCfqazFsb7cL93EPMbLGZfWhmfeuntAYhVn834Yj534yZpQMnAXPL7WpQv5twphKMBDWZtzbahfO5F+IbB2OvmY0C3gO613VhDUSs/m6qE/O/GTNrBrwN3Omc211+d4hDIvZ301B69DWZtzbaVfu5nXO7nXN7/cvTgUQza1N/JUa0WP3dVCnWfzNmlogv5F9xzr0TokmD+t00lKCvyby10a7a78bM2puZ+ZcH4fvvvqPeK41Msfq7qVIs/2b8n/tFYLlz7olKmjWo302DOHXjajBvbbQL87u5BPiVmRUDB4DLnf/WgWhnZq/hu4OkjZnlAn8CEiG2fzdhfC8x+5sBhgLXAEvN7Dv/tnuBztAwfzcaAkFEJMo1lFM3IiJylBT0IiJRTkEvIhLlFPQiIlFOQS8iUoeqG0DuKF6vs5l97B90bZn/6d0qKehFROrWS8CIWny9l4G/OOd64xvralt1ByjoRUTqUKgB5MzseDObYWYLzGyWmfUK57XMrA+Q4Jz7xP/ae51z+6s7TkEvIlL/pgC3OedOBn4LTArzuB7ALjN7x8wWmdlfzCy+uoMaxJOxIiLRwj9Y2mnAv/2jTAA08u8bC/w5xGEbnXPn48vs0/GNqLkeeAP4Bb4hGyqloBcRqV9xwC7n3Inld/gHUAs1iNohucAi59waADN7D9/EJ1UGvU7diIjUI/+Qx2vN7FIITEs4IMzD5wOtzCzVv342sKy6gxT0IiJ1yD+A3LdATzPLNbPrgauA681sMZBFmLPCOedK8J3T/8zMluIbF//5amvQoGYiItFNPXoRkSinoBcRiXIKehGRKKegFxGJcgp6EZEop6AXEYlyCnoRkSj3/wEk2yDx3PpB9gAAAABJRU5ErkJggg==\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "index = 350 # I don't have to store this as a separate variable, it's just easier when I'm doing guess-and-check work.\n", + " #I guessed how many points were in the initial portion, executed this cell to see the plot,\n", + " # then adjusted the value of the index variable until I was only seeing the decay portion of the plot.\n", + "plt.plot(raw_time[index:],voltageAdj[index:])\n", + "time = raw_time[index:]\n", + "voltage = voltageAdj[index:]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now, I could have stored the time and voltage under the same name. But, every time I execute the cell above, it trims off 350 points from the array. It's more robust to store the arrays under a new name. I've done this enough to learn to call the arrays `raw_thingy` when I first import the data, so that I have `thingy` available as a name for the version I actually want to work with." + ] + }, + { + "attachments": { + "parameter%20surface.png": { + "image/png": "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" + } + }, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Fitting the sample data\n", + "\n", + "## How fitting works\n", + "You've all used Excel or a similar program to add on a treadline. You may or may not know the process by which that line gets generated. There's a lot of layers here, so I'm gonna give you some theory before I go ahead and do it. This whole process gets called Optimization in the programming literature. You can see the options for Scipy (the Python scientific programming library) here: https://docs.scipy.org/doc/scipy/reference/optimize.html As you can see, there are a lot of ways to approach this.\n", + "\n", + "### A bit about linear least squares\n", + "\n", + "The fit method Excel uses for a linear trendline is called linear least squares. The 'least squares' part of the name refers to how we decide we have the best fit: we want to minimize the sum of the residuals squared. Let's break that down. Given a set of experimental data points $y_{obs}$, we want to calculate the set of calculated points $y_{calc}$ which best fit that data within the model we have chosen. The residuals, $r$ are the difference between the two points:\n", + "\n", + "\\begin{equation}\n", + "r = y_{obs} - y_{calc}\n", + "\\end{equation}\n", + "\n", + "The least squares method says we want to minimize the following quantity:\n", + "\\begin{equation}\n", + "\\Sigma r^2\n", + "\\end{equation}\n", + "\n", + "We're saying that the line of best fit has the overall smallest differences between that line and the experimental data.\n", + "\n", + "The 'linear' part in the least squares name has nothing to do with only fitting lines. Rather, it's any function form that is linear with the fit parameters, that is, each fit parameter can be multiplied by an function of x. For example, the equation below is linear with respect to parameters $a$, $b$, and $c$, so it can be fit using linear least squares.\n", + "\n", + "\\begin{equation}\n", + "ax + bx^2 + c \\sin(x)\n", + "\\end{equation}\n", + "\n", + "It turns out the linear least squares problem is analytically solveable: there is one unique solution for any data set and model combination. You can solve it with paper and pencil using some matrix algebra. No one actually does that outside of math classes, but you could, if you felt motivated. Realistically, outside of very small problems for illustration of the concept, everyone uses a computerized fitter.\n", + "\n", + "### Taking it further: The search algorithm\n", + "\n", + "More complicated functional forms and larger data sets tend to demand actual search functions. These are functions that do a guess-and-check routine, often with some randomness, and a fair bit of calculus thrown in, to attempt to find the minimum of some function. Why minimum? You set up the problem to define the difference between the model fit and the experimental data, and then attempt to minimize the difference between them. Usually this is the sum of the residuals squared. To visualize what's happening, take a look at the figure below:\n", + "\n", + "![parameter%20surface.png](attachment:parameter%20surface.png)\n", + "\n", + "The y-axis on this graph is the function we're trying to minimize, the difference between the model data and our data. The computer is trying to find the global minimum, but it doesn't know the surface. The computer starts at some point and starts walking. Each step it picks a set of parameters, calculates $\\Sigma r^2$, and compares with the previous value. Then, based on the algorithm, it decides a new set of parameters, and repeats. The goal, for this graph, would be to find the set of parameters corresponding to point `A`.\n", + "\n", + "You can imagine that where you start is really important. If you start searching at point `D`, it's pretty easy to fall downhill and hit the global minmum. If you start at point `C`, it's much harder. There's that deep well at point `B` between your original starting point and the real answer. This is why sometimes it's helpful to give an initial guess at the paramters.\n", + "\n", + "Another complication is the number of axies. I've drawn one paramter axis, but really, there are as many search axes as there are parmeters. This means that, for a linear fit, the computer can decide to take a step along the slope axis, or along the y-intercept axis, or diagonally and change both. Models with more parameters, therefore, tend to take longer to fit, as well as sometimes running into problems finding a minimum value.\n", + "\n", + "There are a lot of ways to decide how to take these steps, which is where the particular *optimization algorithm* comes in. Nelder-Mead and nonlinear-conjugate-gradient are two that Scipy can handle. If you don't know enough to know how to pick them, don't worry. Just go with the default, but keep it in your head that some of these althorithms are specalized, and if you can't get a weird data set to fit, maybe you should learn about different algorithms.\n", + "\n", + "### Then there's the fitter itself\n", + "\n", + "If you look at the Scipy Optimize page linked above, you'll see a lot of options for functions. Some find roots, others minimize. Some allow you to set bounds, some require you to know what a Jacobian and a Hessian matrix are. It's good to poke around there to see what's available, and how the functions differ, but don't feel like you need to know them all. I usually have one or two that I remember how to use, and learn new ones as I need them. We're going to use the `curve_fit` function. This function lets us define any functional form, lets us put in uncertainty on the data, and gives us the covariance matrix (more on that below), so it's pretty spiffy. The way we work `curve_fit` is to first define our model function.\n", + "\n", + "### Wait, we have a search algorith, a fitter, AND a model??\n", + "\n", + "Yes. And the model is the most important part. Is your data best fit by a line or by an expontial? Are we justified in adding in a quadradtic parameter or is that overkill? Is there physical meaning to fitting this data to two exponentials? Defining the model is key to having *meaning* from your data, not just a pile of numbers. As we're scientists, we want our data to have physical meaning whenever possible. So I'm going to start by hoping that my sample data is best fit to a decaying exponential. After all, it's from a kinetics experiment. If the signal is proportional to some chemical species that is reacting away, a decaying exponential functional form means that my reaction is first order in that reactant.\n", + "\n", + "## The first fit: an exponential\n", + "\n", + "### Getting the fit set up\n", + "\n", + "I'll start by defining my own function, which is an exponential. In the cell below my new function, I use it to plot with some arbitrary data, just to show that it works. Note that I've defined my function without a negative sign in the `exp()`. This means that `k` has a negative value for a decay." + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [], + "source": [ + "def exponential(x, a, k, b):\n", + " ''' Returns y = a exp(k*x) + b for any data set x sent to the function'''\n", + " return a*np.exp(k*x) + b" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[]" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXQAAAD4CAYAAAD8Zh1EAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8vihELAAAACXBIWXMAAAsTAAALEwEAmpwYAAAYjUlEQVR4nO3de3DcV3338fd3L7qsJFsrW04k78ZKHkLIxZETFJNCaakJ4JpgeidtKSUl9WSaUnobKJ1p+2SYpzOUtgOdFjx+wtOS0pbwpKEEE0iTFkMpk8RyYjuJ7YBDguVEtuT4El2i2+63f+zKlteStbJX+9P+fp/XzI52f3u0+q5sf/b4nPM7P3N3RESk9sWCLkBERCpDgS4iEhIKdBGRkFCgi4iEhAJdRCQkEkH94JUrV3pXV1dQP15EpCbt2rXrmLu3z/ZcYIHe1dVFb29vUD9eRKQmmdmP5npOQy4iIiGhQBcRCQkFuohISCjQRURCQoEuIhISZQe6mcXN7Ckz2z7Lc2Zmf2NmB81sr5ndWNkyRURkPgvpoX8E2D/Hcz8NXFm8bQE+d5F1iYjIApUV6GaWAd4N3DNHk/cC93rBY0CrmXVUqMazHDjyKn/xzQOcem1yMV5eRKRmldtD/zTwUSA/x/Orgb4Zjw8Xj53FzLaYWa+Z9Q4ODi6kztMOvTLKZ3c8z4vHRi7o+0VEwmreQDezW4EBd991vmazHDvnyhnuvs3de9y9p7191jNX55VtSwHQd2L0gr5fRCSsyumhvwXYbGYvAl8CNpjZF0vaHAayMx5ngJcrUmGJTLqx8ANPvLYYLy8iUrPmDXR3/7i7Z9y9C7gN+E93f39JsweBDxRXu9wMnHL3/sqXCy0NSVpTSfqOq4cuIjLTBW/OZWZ3Arj7VuAhYBNwEBgFbq9IdXPIplP0qYcuInKWBQW6u+8AdhTvb51x3IG7KlnY+WTbGjnQP1StHyciUhNq8kzRbDrF4ROvkc+fM+8qIhJZNRnombYUE7k8A0PjQZciIrJk1Gagn17poolREZFpNRno2bTWoouIlKrJQJ/uofcd10oXEZFpNRnoDck4q1rqtRZdRGSGmgx0KGwBoCEXEZEzajfQ0406/V9EZIaaDfRMOkX/qTGmcnNtACkiEi01G+jZtkZyeaf/1FjQpYiILAm1G+jTSxc1MSoiAtRyoGtfdBGRs9RsoHcsbyAeM61FFxEpqtlAT8RjXLqsQaf/i4gU1WygQ2FiVPuii4gU1Hagp1OaFBURKartQG9LMTA0zthkLuhSREQCV+OBrgtGi4hMq+1A1za6IiKn1XSgZ4qBrh66iEiNB/qqlnrqEjEOa2JURKS2Az0WMzKtjRpyERGhxgMdCheM1tmiIiIhCPRsWj10EREIQ6C3pTg5OsnQ2GTQpYiIBKrmA336gtFa6SIiUVfzga590UVECmo/0E/vi64euohEW80HejqVpKkurh66iERezQe6mZFtS2lfdBGJvJoPdChsAaBJURGJunkD3cwazOwJM9tjZs+a2d2ztFluZl+b0eb2xSl3dpl0I33HR3H3av5YEZElpZwe+jiwwd27gXXARjO7uaTNXcC+Ypu3AX9lZnWVLPR8sm0pRiZynBjVWnQRia55A90LhosPk8VbaVfYgRYzM6AZOA5MVbLQ88kW16JrYlREoqysMXQzi5vZbmAAeMTdHy9p8rfA1cDLwNPAR9w9P8vrbDGzXjPrHRwcvLjKZzizdFGBLiLRVVagu3vO3dcBGWC9mV1X0uRdwG6gk8KwzN+a2bJZXmebu/e4e097e/vF1H2WzOkeuiZGRSS6FrTKxd1PAjuAjSVP3Q48UByeOQi8ALyhEgWWo6UhSWsqqaWLIhJp5axyaTez1uL9RuAW4EBJs0PA24ttLgGuAn5Y0UrnkU2ndLaoiERaoow2HcAXzCxO4QPgy+6+3czuBHD3rcAngH8ws6cBAz7m7scWq+jZZNsaOdA/VM0fKSKypMwb6O6+F7hhluNbZ9x/GXhnZUtbmGw6xaP7BsjnnVjMgixFRCQQoThTFApXLprI5RkYGg+6FBGRQIQm0LOn90XXxKiIRFNoAj2T1lp0EYm2EAW61qKLSLSFJtAbknFWtdTr9H8RiazQBDoUtgDQkIuIRFW4Aj3dqCEXEYmscAV6W4ojr44xlTtnXzARkdALVaBn0o3k8k7/qbGgSxERqbpQBXp2eumiJkZFJILCFejaF11EIixUgd6xvIF4zDQxKiKRFKpAT8RjdCxv0On/IhJJoQp0KEyMal90EYmi0AV6Np3SpKiIRFL4Ar0txcDQOGOTuaBLERGpqhAG+vQ2uhp2EZFoCV+gaxtdEYmo8AV6cS26eugiEjWhC/T25nrqEjEOa2JURCImdIEeixmZ1kYNuYhI5IQu0KFwwWidLSoiURPKQM+m1UMXkegJZ6C3pTg5OsnQ2GTQpYiIVE04Az2tlS4iEj2hDPRMunBykbYAEJEoCWWgn9kXXT10EYmOUAZ6OpWkqS6uHrqIREooA93MyLaltC+6iERKKAMdIJNOaVJURCJl3kA3swYze8LM9pjZs2Z29xzt3mZmu4ttvl35Uhcmk26k7/go7h50KSIiVZEoo804sMHdh80sCXzXzL7h7o9NNzCzVuCzwEZ3P2Rmqxan3PJl21KMTOQ4MTpJW1Nd0OWIiCy6eXvoXjBcfJgs3kq7vb8CPODuh4rfM1DRKi9AVksXRSRiyhpDN7O4me0GBoBH3P3xkiavB9JmtsPMdpnZB+Z4nS1m1mtmvYODgxdV+HzOLF1UoItINJQV6O6ec/d1QAZYb2bXlTRJAG8E3g28C/gTM3v9LK+zzd173L2nvb394iqfx+lA1yZdIhIRC1rl4u4ngR3AxpKnDgPfdPcRdz8GfAforkSBF6q5PkE6ldTSRRGJjHJWubQXJz0xs0bgFuBASbOvAm81s4SZpYA3AfsrXOuCZdIpnS0qIpFRziqXDuALZhan8AHwZXffbmZ3Arj7Vnffb2bfBPYCeeAed39m0aouU7atkQP9Q0GXISJSFfMGurvvBW6Y5fjWksefAj5VudIuXjad4tF9A+TzTixmQZcjIrKoQnumKBSuXDSRyzMwNB50KSIiiy7UgT69Fl0ToyISBeEOdK1FF5EICXWgr26dPltUK11EJPxCHegNyTirWup1+r+IREKoAx0Kwy4achGRKAh/oKcbNeQiIpEQ/kBvS3Hk1TGmcvmgSxERWVThD/R0ilze6T81FnQpIiKLKvSBntG+6CISEaEPdK1FF5GoCH2gdyxvIB4zTYyKSOiFPtAT8RgdyxvUQxeR0At9oENhYvSw9kUXkZCLRKBn0o2aFBWR0ItEoGfbUgwMjTM2mQu6FBGRRRORQJ/eRlfDLiISXtEI9LSWLopI+EUj0Itr0dVDF5Ewi0SgtzfXU5eIcVgToyISYpEI9FjMyLQ2ashFREItEoEOhQtG62xREQmzyAR6Nq0euoiEW3QCvS3FydFJhsYmgy5FRGRRRCfQ01rpIiLhFp1Ab9O+6CISbpEJ9Mzpk4vUQxeRcIpMoKdTSZrq4uqhi0hoRSbQzYxsW4rDWukiIiEVmUCHwrCL1qKLSFhFKtCzbY0cPjGKuwddiohIxc0b6GbWYGZPmNkeM3vWzO4+T9ubzCxnZr9Q2TIrI5NOMTKR48So1qKLSPiU00MfBza4ezewDthoZjeXNjKzOPBJ4OGKVlhB2bSWLopIeM0b6F4wXHyYLN5mG7P4MPCvwEDlyqus6W10tQWAiIRRWWPoZhY3s90UwvoRd3+85PnVwM8CW+d5nS1m1mtmvYODgxdY8oU7HeiaGBWRECor0N095+7rgAyw3syuK2nyaeBj7n7ei3a6+zZ373H3nvb29gup96I01ydIp5JauigioZRYSGN3P2lmO4CNwDMznuoBvmRmACuBTWY25e7/VqE6KybbltLZoiISSuWscmk3s9bi/UbgFuDAzDbufrm7d7l7F3A/8FtLMcwBMulGXblIREKpnCGXDuBbZrYX2ElhDH27md1pZncubnmVl02nOHziNfJ5rUUXkXCZd8jF3fcCN8xyfNYJUHf/4MWXtXgybSkmcnkGhsa5dHlD0OWIiFRMpM4UBbjqkhYAdr54POBKREQqK3KB/sY1aVa11PPgnpeDLkVEpKIiF+jxmHHr9Z18+7lBTr2mLQBEJDwiF+gA713XyUQuz8PPHAm6FBGRiolkoF+fWc6aFSkNu4hIqEQy0M2Mzd2dfO/5YwwMjQVdjohIRUQy0AE2d3eSd/j63v6gSxERqYjIBvqVl7RwdccyDbuISGhENtCh0Et/6tBJ7Y8uIqEQ6UB/T3cHgHrpIhIKkQ70TDrFG9ekeXC3Al1Eal+kAx0Kwy7PHR3iuSNDQZciInJRIh/om9Z2EI8ZD+55KehSREQuSuQDvb2lnjf/rxV8bU8/7tpSV0RqV+QDHQrDLoeOj7K772TQpYiIXDAFOvCu6y6lLhHjq5ocFZEapkAHljUk2XDVKr7+dD85XclIRGqUAr1o87pOBofGeeyHrwRdiojIBVGgF214wyqa6xNaky4iNUuBXtSQjPPOay7hoWf6GZ/KBV2OiMiCKdBneM+6TobGpvj2c4NBlyIismAK9Bl+/HUraWuq094uIlKTFOgzJOMxNq29lEf3H2VkfCrockREFkSBXmJz92rGJvM8uv9o0KWIiCyIAr1Ez5o0HcsbdJKRiNQcBXqJWMx4T3cn3/n+ICdGJoIuR0SkbAr0WWzu7mQq73zjmSNBlyIiUjYF+iyu7VzGFe1N2lJXRGqKAn0WZsbm7k4ef+E4R06NBV2OiEhZFOhz2NzdiTts36vJURGpDfMGupk1mNkTZrbHzJ41s7tnafOrZra3ePuemXUvTrnVc0V7M2tXL9dJRiJSM8rpoY8DG9y9G1gHbDSzm0vavAD8pLtfD3wC2FbRKgOyubuTvYdP8cKxkaBLERGZ17yB7gXDxYfJ4s1L2nzP3U8UHz4GZCpaZUBu7e7ADL6mXrqI1ICyxtDNLG5mu4EB4BF3f/w8zT8EfGOO19liZr1m1js4uPQ3wOpY3shNXW18dfdLut6oiCx5ZQW6u+fcfR2Fnvd6M7tutnZm9lMUAv1jc7zONnfvcfee9vb2Cyy5ujZ3d/L84Aj7+l8NuhQRkfNa0CoXdz8J7AA2lj5nZtcD9wDvdffQXPZn09oOEjHT5KiILHnlrHJpN7PW4v1G4BbgQEmby4AHgF9z9+8vQp2BaWuq461XrmT7nn7yut6oiCxh5fTQO4BvmdleYCeFMfTtZnanmd1ZbPOnwArgs2a228x6F6neQGxe18lLJ1/jyUMn5m8sIhKQxHwN3H0vcMMsx7fOuH8HcEdlS1s63nHNpdQnnuaru1+mp6st6HJERGalM0XL0Fyf4JZrLuGhp/uZyuWDLkdEZFYK9DJt7u7klZEJ/vv50Mz3ikjIKNDL9Lar2mlpSPCgLnwhIkuUAr1M9Yk4G6+9lIefPcLYZC7ockREzqFAX4DN6zoZHp/iWwcGgi5FROQcCvQF+LErVrCyuV4nGYnIkqRAX4BEPMat13fwHwcGdL1REVlyFOgL9Es9Wdyd37y3l9GJqaDLERE5TYG+QNd0LuMzt93Ak4dOsOXeXZogFZElQ4F+ATat7eCTP3893z14jA//y1NM6mQjEVkCFOgX6Bd7sty9+Voe2XeUP/z/e7Rxl4gEbt69XGRuv/7mLobHp/jUw8/RVJ/g//zMdZhZ0GWJSEQp0C/SXT/1OobHp/jcjudpqovzx5uuVqiLSCAU6BXw0Xddxcj4FP/3v16gpSHJ77z9yqBLEpEIUqBXgJnxv99zLSPjOf76ke/TVJ/gQz9+edBliUjEKNArJBYzPvnzaxmdmOIT2/fRVBfntvWXBV2WiESIVrlUUCIe4zO33cBPvr6dj3/laW0RICJVpUCvsLpEjK3vfyM3dbXx+/ft5tF9R4MuSUQiQoG+CBrr4nz+13u4tnMZv/XPT/LfB48FXZKIRIACfZG0NCT5h9vXc/mKJn7z3l52/UgXmBaRxaVAX0Tppjr+8Y71rGqp54N//wTPvnwq6JJEJMQU6ItsVUsDX7zjTbTUJ/jA55/g4MBw0CWJSEgp0Ksgk07xxTvehJnx/nsep+/4aNAliUgIKdCr5Ir2Zv7xQ+t5bTLHr9zzGF/f28/4lLbeFZHKUaBX0dUdy/jCb6wnn4e7/vlJbv7z/+AT2/fx/aNDQZcmIiFg7sFs+9rT0+O9vb2B/Oyg5fLOdw8e48s7+/j3fUeYzDnrsq3cdlOWW7s7aa7XCbwiMjsz2+XuPbM+p0AP1ivD43zlqZe4b2cfPxgYJlUX59brO3jfTVluvCytnRtF5CwK9Brg7jzVd5L7nujja3tfZnQix+tWNfO+niw/e+NqVjbXB12iiCwBCvQaMzI+xdf39vOlnYd48tBJEjHjHddcwi/dlOUnrmwnHlOvXSSqFOg17AdHh7hvZx8PPPUSx0cm6FjewM/duJq1q5fTtbKJNW1NNNbFgy5TRKpEgR4CE1N5Ht1/lPt29vGdHwwy84/t0mUNrFmR4vKVTaxZ0cTlK1OsWdFE1wqFvUjYnC/Q511OYWYNwHeA+mL7+939z0raGPAZYBMwCnzQ3Z+82MLljLpEjE1rO9i0toOhsUlePDbKi6+M8OKxEV58pXD/0f1HOTY8cdb3XbKsnq4VTWeFfbYtRWuqjua6BE31cRJxrV4VCYNy1seNAxvcfdjMksB3zewb7v7YjDY/DVxZvL0J+FzxqyyCloYkazPLWZtZfs5zr45N8qNZwv6RfUd5ZWRilleDhmSM5voEzfUJmopfm+sTNDcUHreUHG+qT5CMG8l4jETciMeK92NnjiViMZJxIxGPkYwVvibiRjJW+BozI2ZoFY9IBc0b6F4Yk5negCRZvJWO07wXuLfY9jEzazWzDnfvr2i1Mq9lZYR934lRhsYmGR7PMTw2xcjEFENjU4yMF25D41MceXWM4cHi47Epxqfyi1ZzzCgGvIGd/dhO3+f0YzNj+mOg8C024/708TMfFNN3S9vOVPqxUvpBc87HzjyfQ/N9TNX6B1ltVx+8992U5Y63XlHx1y3rDBYziwO7gNcBf+fuj5c0WQ30zXh8uHjsrEA3sy3AFoDLLtPl2artfGE/n8lcnpHxKYbHpxgZzzGZyzOZyzOV98LXnJObvj/j2FQ+z2TOmTp9vHDfgbw7eS8s2Zy+n3cH56zHfvrxmfYA7pyeS3B8xn3OPM+Zg2eOn90fKe2dlE4rnfv8+eed5p2VCmbaqmK81t/AErBYy5DLCnR3zwHrzKwV+IqZXefuz8xoMtsH9jl/6u6+DdgGhUnRhZcrQUnGY7Sm6mhN1QVdiojMYUGzYe5+EtgBbCx56jCQnfE4A+iCmiIiVTRvoJtZe7Fnjpk1ArcAB0qaPQh8wApuBk5p/FxEpLrKGXLpAL5QHEePAV929+1mdieAu28FHqKwZPEghWWLty9SvSIiModyVrnsBW6Y5fjWGfcduKuypYmIyELojBIRkZBQoIuIhIQCXUQkJBToIiIhEdhui2Y2CPzoAr99JXCsguXUmqi/f9DvQO8/uu9/jbu3z/ZEYIF+Mcysd67tI6Mg6u8f9DvQ+4/2+5+LhlxEREJCgS4iEhK1Gujbgi4gYFF//6Dfgd6/nKMmx9BFRORctdpDFxGREgp0EZGQqLlAN7ONZvacmR00sz8Kup5qMrOsmX3LzPab2bNm9pGgawqCmcXN7Ckz2x50LdVWvLzj/WZ2oPj34MeCrqmazOz3in/3nzGzfylexF6KairQi1v4/h2Fi1JfA/yymV0TbFVVNQX8gbtfDdwM3BWx9z/tI8D+oIsIyGeAb7r7G4BuIvR7MLPVwO8APe5+HRAHbgu2qqWlpgIdWA8cdPcfuvsE8CUKF6iOBHfvd/cni/eHKPxjXh1sVdVlZhng3cA9QddSbWa2DPgJ4PMA7j5RvIpYlCSARjNLACl0ZbSz1Fqgz3Ux6sgxsy4K+9SXXrA77D4NfBTIB1xHEK4ABoG/Lw453WNmTUEXVS3u/hLwl8AhChegP+Xu/x5sVUtLrQV6WRejDjszawb+Ffhdd3816HqqxcxuBQbcfVfQtQQkAdwIfM7dbwBGgMjMI5lZmsL/yC8HOoEmM3t/sFUtLbUW6JG/GLWZJSmE+T+5+wNB11NlbwE2m9mLFIbbNpjZF4MtqaoOA4fdffp/ZfdTCPiouAV4wd0H3X0SeAB4c8A1LSm1Fug7gSvN7HIzq6MwIfJgwDVVjZkZhfHT/e7+10HXU23u/nF3z7h7F4U/+/9098j00Nz9CNBnZlcVD70d2BdgSdV2CLjZzFLFfwtvJ0KTwuUo5yLRS4a7T5nZbwMPU5jh/n/u/mzAZVXTW4BfA542s93FY3/s7g8FV5JU2YeBfyp2aH5IhC7I7u6Pm9n9wJMUVnw9hbYAOItO/RcRCYlaG3IREZE5KNBFREJCgS4iEhIKdBGRkFCgi4iEhAJdRCQkFOgiIiHxP4qcEmwubZvsAAAAAElFTkSuQmCC\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "thing1 = np.arange(0,10,.5) #this makes an array going from 0 to 10 in steps of 0.5. linspace() is similar and also good to know\n", + "thing2 = exponential(thing1, 1, -2, 3)\n", + "plt.plot(thing1,thing2)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Next, let's check out the help on the `curve_fit` function:" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Help on function curve_fit in module scipy.optimize.minpack:\n", + "\n", + "curve_fit(f, xdata, ydata, p0=None, sigma=None, absolute_sigma=False, check_finite=True, bounds=(-inf, inf), method=None, jac=None, **kwargs)\n", + " Use non-linear least squares to fit a function, f, to data.\n", + " \n", + " Assumes ``ydata = f(xdata, *params) + eps``.\n", + " \n", + " Parameters\n", + " ----------\n", + " f : callable\n", + " The model function, f(x, ...). It must take the independent\n", + " variable as the first argument and the parameters to fit as\n", + " separate remaining arguments.\n", + " xdata : array_like or object\n", + " The independent variable where the data is measured.\n", + " Should usually be an M-length sequence or an (k,M)-shaped array for\n", + " functions with k predictors, but can actually be any object.\n", + " ydata : array_like\n", + " The dependent data, a length M array - nominally ``f(xdata, ...)``.\n", + " p0 : array_like, optional\n", + " Initial guess for the parameters (length N). If None, then the\n", + " initial values will all be 1 (if the number of parameters for the\n", + " function can be determined using introspection, otherwise a\n", + " ValueError is raised).\n", + " sigma : None or M-length sequence or MxM array, optional\n", + " Determines the uncertainty in `ydata`. If we define residuals as\n", + " ``r = ydata - f(xdata, *popt)``, then the interpretation of `sigma`\n", + " depends on its number of dimensions:\n", + " \n", + " - A 1-D `sigma` should contain values of standard deviations of\n", + " errors in `ydata`. In this case, the optimized function is\n", + " ``chisq = sum((r / sigma) ** 2)``.\n", + " \n", + " - A 2-D `sigma` should contain the covariance matrix of\n", + " errors in `ydata`. In this case, the optimized function is\n", + " ``chisq = r.T @ inv(sigma) @ r``.\n", + " \n", + " .. versionadded:: 0.19\n", + " \n", + " None (default) is equivalent of 1-D `sigma` filled with ones.\n", + " absolute_sigma : bool, optional\n", + " If True, `sigma` is used in an absolute sense and the estimated parameter\n", + " covariance `pcov` reflects these absolute values.\n", + " \n", + " If False (default), only the relative magnitudes of the `sigma` values matter.\n", + " The returned parameter covariance matrix `pcov` is based on scaling\n", + " `sigma` by a constant factor. This constant is set by demanding that the\n", + " reduced `chisq` for the optimal parameters `popt` when using the\n", + " *scaled* `sigma` equals unity. In other words, `sigma` is scaled to\n", + " match the sample variance of the residuals after the fit. Default is False.\n", + " Mathematically,\n", + " ``pcov(absolute_sigma=False) = pcov(absolute_sigma=True) * chisq(popt)/(M-N)``\n", + " check_finite : bool, optional\n", + " If True, check that the input arrays do not contain nans of infs,\n", + " and raise a ValueError if they do. Setting this parameter to\n", + " False may silently produce nonsensical results if the input arrays\n", + " do contain nans. Default is True.\n", + " bounds : 2-tuple of array_like, optional\n", + " Lower and upper bounds on parameters. Defaults to no bounds.\n", + " Each element of the tuple must be either an array with the length equal\n", + " to the number of parameters, or a scalar (in which case the bound is\n", + " taken to be the same for all parameters). Use ``np.inf`` with an\n", + " appropriate sign to disable bounds on all or some parameters.\n", + " \n", + " .. versionadded:: 0.17\n", + " method : {'lm', 'trf', 'dogbox'}, optional\n", + " Method to use for optimization. See `least_squares` for more details.\n", + " Default is 'lm' for unconstrained problems and 'trf' if `bounds` are\n", + " provided. The method 'lm' won't work when the number of observations\n", + " is less than the number of variables, use 'trf' or 'dogbox' in this\n", + " case.\n", + " \n", + " .. versionadded:: 0.17\n", + " jac : callable, string or None, optional\n", + " Function with signature ``jac(x, ...)`` which computes the Jacobian\n", + " matrix of the model function with respect to parameters as a dense\n", + " array_like structure. It will be scaled according to provided `sigma`.\n", + " If None (default), the Jacobian will be estimated numerically.\n", + " String keywords for 'trf' and 'dogbox' methods can be used to select\n", + " a finite difference scheme, see `least_squares`.\n", + " \n", + " .. versionadded:: 0.18\n", + " kwargs\n", + " Keyword arguments passed to `leastsq` for ``method='lm'`` or\n", + " `least_squares` otherwise.\n", + " \n", + " Returns\n", + " -------\n", + " popt : array\n", + " Optimal values for the parameters so that the sum of the squared\n", + " residuals of ``f(xdata, *popt) - ydata`` is minimized.\n", + " pcov : 2-D array\n", + " The estimated covariance of popt. The diagonals provide the variance\n", + " of the parameter estimate. To compute one standard deviation errors\n", + " on the parameters use ``perr = np.sqrt(np.diag(pcov))``.\n", + " \n", + " How the `sigma` parameter affects the estimated covariance\n", + " depends on `absolute_sigma` argument, as described above.\n", + " \n", + " If the Jacobian matrix at the solution doesn't have a full rank, then\n", + " 'lm' method returns a matrix filled with ``np.inf``, on the other hand\n", + " 'trf' and 'dogbox' methods use Moore-Penrose pseudoinverse to compute\n", + " the covariance matrix.\n", + " \n", + " Raises\n", + " ------\n", + " ValueError\n", + " if either `ydata` or `xdata` contain NaNs, or if incompatible options\n", + " are used.\n", + " \n", + " RuntimeError\n", + " if the least-squares minimization fails.\n", + " \n", + " OptimizeWarning\n", + " if covariance of the parameters can not be estimated.\n", + " \n", + " See Also\n", + " --------\n", + " least_squares : Minimize the sum of squares of nonlinear functions.\n", + " scipy.stats.linregress : Calculate a linear least squares regression for\n", + " two sets of measurements.\n", + " \n", + " Notes\n", + " -----\n", + " With ``method='lm'``, the algorithm uses the Levenberg-Marquardt algorithm\n", + " through `leastsq`. Note that this algorithm can only deal with\n", + " unconstrained problems.\n", + " \n", + " Box constraints can be handled by methods 'trf' and 'dogbox'. Refer to\n", + " the docstring of `least_squares` for more information.\n", + " \n", + " Examples\n", + " --------\n", + " >>> import matplotlib.pyplot as plt\n", + " >>> from scipy.optimize import curve_fit\n", + " \n", + " >>> def func(x, a, b, c):\n", + " ... return a * np.exp(-b * x) + c\n", + " \n", + " Define the data to be fit with some noise:\n", + " \n", + " >>> xdata = np.linspace(0, 4, 50)\n", + " >>> y = func(xdata, 2.5, 1.3, 0.5)\n", + " >>> np.random.seed(1729)\n", + " >>> y_noise = 0.2 * np.random.normal(size=xdata.size)\n", + " >>> ydata = y + y_noise\n", + " >>> plt.plot(xdata, ydata, 'b-', label='data')\n", + " \n", + " Fit for the parameters a, b, c of the function `func`:\n", + " \n", + " >>> popt, pcov = curve_fit(func, xdata, ydata)\n", + " >>> popt\n", + " array([ 2.55423706, 1.35190947, 0.47450618])\n", + " >>> plt.plot(xdata, func(xdata, *popt), 'r-',\n", + " ... label='fit: a=%5.3f, b=%5.3f, c=%5.3f' % tuple(popt))\n", + " \n", + " Constrain the optimization to the region of ``0 <= a <= 3``,\n", + " ``0 <= b <= 1`` and ``0 <= c <= 0.5``:\n", + " \n", + " >>> popt, pcov = curve_fit(func, xdata, ydata, bounds=(0, [3., 1., 0.5]))\n", + " >>> popt\n", + " array([ 2.43708906, 1. , 0.35015434])\n", + " >>> plt.plot(xdata, func(xdata, *popt), 'g--',\n", + " ... label='fit: a=%5.3f, b=%5.3f, c=%5.3f' % tuple(popt))\n", + " \n", + " >>> plt.xlabel('x')\n", + " >>> plt.ylabel('y')\n", + " >>> plt.legend()\n", + " >>> plt.show()\n", + "\n" + ] + } + ], + "source": [ + "help(curve_fit)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "`curve_fit` has three required argments. The first is the user-defined function that you'll be fitting your data to. The second is the x-values that you want to fit, and the third is the y- values. It also has the optional argument `sigma`, which is the weight you wish to assign to each value. We'll get to that later.\n", + "\n", + "If you scroll down in the help, you'll see that `curve_fit` returns two values: `popt`, an array of parameters, and `pcov`, the covariance matrix. `popt` are the optimized parameters. You have to save the value of `pcov` as a variable, but we aren't ready to deal with it yet.\n", + "\n", + "The cell below has an example call of `curve_fit`, using the function and arrays I've defined above, so that you can see how to use it. It assignes an array of fit parameters to the variable `popt`, which I'm printing so that you can see them." + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "ename": "RuntimeError", + "evalue": "Optimal parameters not found: Number of calls to function has reached maxfev = 800.", + "output_type": "error", + "traceback": [ + "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[1;31mRuntimeError\u001b[0m Traceback (most recent call last)", + "\u001b[1;32m\u001b[0m in \u001b[0;36m\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0mpopt_first\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mpcov_first\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mcurve_fit\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mexponential\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mtime\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mvoltage\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m 2\u001b[0m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mpopt\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[1;32m~\\anaconda3\\lib\\site-packages\\scipy\\optimize\\minpack.py\u001b[0m in \u001b[0;36mcurve_fit\u001b[1;34m(f, xdata, ydata, p0, sigma, absolute_sigma, check_finite, bounds, method, jac, **kwargs)\u001b[0m\n\u001b[0;32m 787\u001b[0m \u001b[0mcost\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0msum\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0minfodict\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;34m'fvec'\u001b[0m\u001b[1;33m]\u001b[0m \u001b[1;33m**\u001b[0m \u001b[1;36m2\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 788\u001b[0m \u001b[1;32mif\u001b[0m \u001b[0mier\u001b[0m \u001b[1;32mnot\u001b[0m \u001b[1;32min\u001b[0m \u001b[1;33m[\u001b[0m\u001b[1;36m1\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;36m2\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;36m3\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;36m4\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m--> 789\u001b[1;33m \u001b[1;32mraise\u001b[0m \u001b[0mRuntimeError\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m\"Optimal parameters not found: \"\u001b[0m \u001b[1;33m+\u001b[0m \u001b[0merrmsg\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m 790\u001b[0m \u001b[1;32melse\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 791\u001b[0m \u001b[1;31m# Rename maxfev (leastsq) to max_nfev (least_squares), if specified.\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[1;31mRuntimeError\u001b[0m: Optimal parameters not found: Number of calls to function has reached maxfev = 800." + ] + } + ], + "source": [ + "popt_first, pcov_first = curve_fit(exponential, time, voltage)\n", + "print(popt)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Oh no! Panic! It's throwing a `RuntimeError`. Just kidding about the panic. Let's look at the error more carefully. It says that it reaced 800 calls to the function. This means that it took 800 steps and hasn't found the answer, so it's stopping. The nice thing about modern fitting altorithms is that they're not dumb. `curve_fit` is programmed to stop if it's not getting close to the answer. The default is to stop after 800 steps. Now, I could just override that and increase that to 1000 (or 10,000, or a zillion) calls to see if it works. But let's think a bit first.\n", + "\n", + "Remember, `curve_fit` knows **nothing** about the data you're fitting. Is it huge or tiny, is it strongly varying or basically flat? `curve_fit` has no information until it gets started. The more info we can give it, the easier the data is to fit. A really useful piece of information to give a curve fitter is a guess at the initial paramters, and it doesn't even have to be close. I'm gonna make the following guesses:\n", + "\n", + " - a = .1, because the y-intercept is a bit above 0.08 in my plot above\n", + " - k = 1, because I struggle to estimate rate constants, so I'm gonna see if I can be lazy and avoid it\n", + " - b = 0, because the data flatlines at about 0 at long time.\n", + "\n", + "Notice that my guesses aren't really that careful. But they narrow down a starting point for `a` from \"any number ever\" to \"probably near .1\", which is a lot. In the line below, I re-run `curve_fit` with my initial guesses for the parameter values, and this time it fints a set of values. " + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[ 8.89851466e-02 -2.25909875e+06 1.42742818e-03]\n" + ] + } + ], + "source": [ + "popt_first, pcov_first = curve_fit(exponential, time, voltage, p0=(.1, 1, 0))\n", + "print(popt_first)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Verifying that the fit makes sense and checking the residuals\n", + "\n", + "While these fitters are generally very good, always keep in mind that they're basically a black box with no brain that we're feeding data into and hoping we get a good result. Sometimes it'll find a really weird fit, so it's a good idea to plot the fitted model on top of the original data, to make sure that it's not dumb.\n", + "\n", + "A next step to check your fit is to generate a residual plot, that is, $y_obs - y_calc$. You want to look for recognizable functions within the residual plot. If it shows a straight line, or a parabola, or an oscillation, that means that your model isn't capturing all of the features of your data. An ideal residual plot shows data that is randomly positive and negative, with no discernable pattern across the plot.\n", + "\n", + "In the cell below, I put both of these things on one plt by using the `subplot()` function. Check the help. I also do a fancy bit (`sharex=plt.gca()`) to get the two plots to use the same x axis, and add in some labels." + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.subplot(211)\n", + "plt.plot(time, voltage-exponential(time, popt_first[0],popt_first[1], popt_first[2]),'g')\n", + "plt.ylabel(\"residuals\")\n", + "plt.subplot(212, sharex=plt.gca())\n", + "plt.plot(time,voltage)\n", + "plt.plot(time, exponential(time, popt_first[0],popt_first[1], popt_first[2]))\n", + "plt.legend((\"Raw data\", \"Model\"))\n", + "plt.ylabel(\"Counts (au)\")\n", + "plt.xlabel(\"time (s)\")\n", + "plt.subplots_adjust(hspace=0)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Looking at the parameter errors\n", + "\n", + "Alright let's get back to the other data that `curve_fit` generates, the covariance matrix. The diagonal elements of this matrix are the variance in each parameter, so the square root of the diagonals are the standard deviation of that parameter. What does that mean? It means these elements are an estimate of how strongly the model function depends on this parameter, or, conversely, how carefully we know that parameter. If a parameter is completely unnecessary to the fit, or is very poorly determined, then it will have a large error. In the cell below, I grab the diagonal elements, take their square root, and print them out." + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[9.33611399e-05 4.98384579e+03 3.88955727e-05]\n" + ] + } + ], + "source": [ + "perr_first = np.sqrt(np.diag(pcov_first))\n", + "print(perr_first)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Note how those errors compare to the parameter size. I've re-written my results in the table below in a human readable format:\n", + "\n", + "|Parameter|Value |Uncertainty |\n", + "|---------|----- |----------- |\n", + "|a |0.08897 |0.00009 |\n", + "|k | -2.258$\\times 10^6$ |0.005$\\times 10^3$ |\n", + "|b | 0.00143 |0.00004 |\n", + "\n", + "Consider the size of the uncertainty relative to each number. We don't care about the absolute value of the uncertainty, we care about how it looks relative to it's base value. It can be helpful to convert to a percent relative uncertainty when deciding how you feel about any given uncertainty value. One way to visualize that is the following bar graph. The y-axis is the percent uncertainty on each parameter. Note that, while `b` has the greatest uncertainty, they're all pretty small percentages." + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 20, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.bar(('a','k','b'), perr_first/popt_first*100)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "### A brief reminder on sig figs and uncertainty\n", + "\n", + "When your value has an uncertainty, you round that to one digit. Then you round the value itself to match the uncertainty. Write uncertainties in a way to make it as clear as possible how big they are relative to the base number. If you're going to use scientific notation, make the base number and the uncertainty match if that's at all reasonable.\n", + "\n", + "## Let's try a second model\n", + "\n", + "### Setting it up\n", + "\n", + "The first model I tried was a decaying exponential function. This is the function form that you expect if the signal is proportional to a chemical species that is varying according to a first order reaction. Let's test if this is a good hypothesis, and see if the data is better fit as a second order reaction." + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [], + "source": [ + "def twoexponents(x, a1, k1, b, a2, k2):\n", + " '''returns a double exponential'''\n", + " return a1*np.exp(k1*x) + a2*np.exp(k2*x) + b" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [], + "source": [ + "def secondorder(x, a, k, b):\n", + " ''' Returns the kinetics trace for a second order reaction for any data set x sent to the function'''\n", + " return a/(1 - k*x*a)+b\n" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[ 1.14665922e-01 -2.62000696e+07 -1.59757518e-02]\n", + "[2.66599315e-04 2.25849477e+05 1.74948389e-04]\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "popt_sec, pcov_sec = curve_fit(secondorder, time, voltage, p0=(.1, 1, 0))\n", + "perr_sec = np.sqrt(np.diag(pcov_sec))\n", + "print(popt_sec)\n", + "print(perr_sec)\n", + "\n", + "plt.figure(1)\n", + "plt.bar(('a','k','b'), perr_sec/popt_sec*100)\n", + "\n", + "plt.figure(2)\n", + "plt.subplot(211)\n", + "plt.plot(time, voltage-secondorder(time, popt_sec[0],popt_sec[1], popt_sec[2]),'g')\n", + "plt.ylabel(\"residuals\")\n", + "plt.subplot(212, sharex=plt.gca())\n", + "plt.plot(time,voltage)\n", + "plt.plot(time, secondorder(time, popt_sec[0],popt_sec[1], popt_sec[2]))\n", + "plt.legend((\"Raw data\", \"Model\"))\n", + "plt.ylabel(\"Counts (au)\")\n", + "plt.xlabel(\"time (s)\")\n", + "plt.subplots_adjust(hspace=0)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Comparing the two models\n", + "\n", + "How do we decide between the two fits? On the one hand, the second order fit gives lower uncertainties overall in the parameters. That makes it attractive. But lok at the plot of the residuals and the raw data. The residuals show a clear functional form. This is refelected in the bottom subplot, where you can see that the model wanders above and below the raw data across the length of the data set. Given these two function forms, I think first order kinetics fits the data better than second order.\n", + "\n", + "## Looking at a poly fit\n", + "\n", + "You may have heard me ranting about polynomial fits in 311L. Let's explore the two reasons why I prefer other fit functions. Here, I'll fit the data to a third order polynomail." + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[-1.89875620e+16 9.13996047e+10 -1.47916382e+05 8.49278465e-02]\n", + "[1.58667845e+14 5.28345080e+08 5.00508658e+02 1.27816162e-04]\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "def polyfit(x, a, b, c, d):\n", + " ''' Returns a third order polynomial in x'''\n", + " return a*x**3 +b*x**2 + c*x + d\n", + " \n", + "popt_poly, pcov_poly = curve_fit(polyfit, time, voltage, p0=(2*10**16, 10*10**10, .1, 0))\n", + "perr_poly = np.sqrt(np.diag(pcov_poly))\n", + "print(popt_poly)\n", + "print(perr_poly)\n", + "\n", + "plt.figure(1)\n", + "plt.bar(('a','b','c', 'd'), perr_poly/popt_poly*100)\n", + "\n", + "plt.figure(2)\n", + "plt.subplot(211)\n", + "plt.plot(time, voltage-polyfit(time, popt_poly[0],popt_poly[1], popt_poly[2], popt_poly[3]),'g')\n", + "plt.ylabel(\"residuals\")\n", + "plt.subplot(212, sharex=plt.gca())\n", + "plt.plot(time,voltage)\n", + "plt.plot(time, polyfit(time, popt_poly[0],popt_poly[1], popt_poly[2], popt_poly[3]))\n", + "plt.legend((\"Raw data\", \"Model\"))\n", + "plt.ylabel(\"Counts (au)\")\n", + "plt.xlabel(\"time (s)\")\n", + "plt.subplots_adjust(hspace=0)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "On the surface, this isn't a bad fit. The parameters are well determined. The residuals are weird, but not super weird. The plot of the model on top of the experimental data seems okay, though something odd is happening at the end. That's where poly fits can get in trouble. Remember, we're chemists, and we have intuition about how this data should look. In this case, it should decay to zero, and then stay there for ever. Both first-order and second-order kinetics models give us this behavior. I'm going to create a longer time vector and replot the comparison, allowing the model function to extend beyond my experimental data." + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[]" + ] + }, + "execution_count": 26, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.plot(time,voltage)\n", + "time_extended=np.linspace(0, 3*10**-6, 1000)\n", + "plt.plot(time_extended, polyfit(time_extended, popt_poly[0],popt_poly[1], popt_poly[2], popt_poly[3]))\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The polynomial fit turns down after we have no data to constrain it. So this is my first reason for avoiding poly fits: they can behave very oddly outside the data region. The higher order you allow your polynomial fit to go, the more sharp turns and bends it can take. If you intend to extrapolate your data, you need to remember this behavior is possible.\n", + "\n", + "The second reason to generally avoid a polynomial fit is that they usually aren't physically meaningful. While the `k` value in the kinetics models tells us the reaction rate, what do any of the parameters in the poly fit tell us? If you have a reasonable physical model available, it's a good idea to try that.\n", + "\n", + "One place where a poly fit **can** be helpful is something called a spline, which is a piecewise polynomial that you use to stick two functions together or interpolate between points. They're not helpful here, but it's a nifty tool if you get the chance to use one.\n", + "\n", + "# Other useful things\n", + "\n", + "## Fitting spectra and other data\n", + "\n", + "While it's not necessary for this experiment, it's useful to know that you can use this method to extract fit parameters from *any* shape you feel like. For instance, peaks in many spectra are well fit as Gaussian, lognormal, or Lorentzian. Some analysis software (often packaged with the spectrometer) have robust peak finding routines that use functions like `curve_fit` to find and characterize all of the peaks in a spectrum. You can also fit a simple spectrum manually using the functions I've shown you here. Basically, you can use this method to fit any data set to any functional form and extract the model parameters.\n", + "\n", + "## Weighting data\n", + "\n", + "A great advantage to using `curve_fit` is the ability to weight your data. Consider data where you have some measurement of the uncertainty (**alert, this is all data**), and that uncertainty is different across the data set. It would be useful to tell `curve_fit` that you know there is more uncertainty on some of the points, and that they should therefore be less important in the overall fit. This is what it means to weight your data. The optional argument `sigma` gets passed to `curve_fit` to tell it the weights of each data set. Remember that least squares minimization means to minimize:\n", + "\n", + "\\begin{equation\n", + "\\Sigma (y_{obs} - y_{calc})^2\n", + "\\end{equation}\n", + "\n", + "In a weighted least squares fit, we weight each data point by some measure of how we trust it, `w`, and minimize the following:\n", + "\n", + "\\begin{equation}\n", + "\\Sigma w(y_{obs} - y_{calc})^2\n", + "\\end{equation}\n", + "\n", + "There are several ways to come up with reasonable weighting factors. If you're minizing data with repeated measurements, then\n", + "\n", + "\\begin{equation}\n", + "w = \\frac{1}{\\sigma^2}\n", + "\\end{equation}\n", + "\n", + "where $\\sigma$ is the standard deviation of the repeated measurement.\n", + "\n", + "A special case of this becomes useful in some of the experiments we'll be working on. As you'll learn in chemistry 461, there are different types of noise. One, called shot noise, is known to follow Poisson statistics. This is basically the type of error that comes from having a small number of discrete elements causing the observed signal. Shot noise is the dominant source of uncertainty in processes that produce a countable number of photons. In this case, it turns out that the $\\sigma = \\sqrt{y_i}$, and we end up with the weight\n", + "\n", + "\\begin{equation}\n", + "w = \\frac{1}{y_i}\n", + "\\end{equation}\n", + "\n", + "where $y_i$ is the value of the signal at the $i$th point. This gives us a unique weighting factor for each data point. Let's assume for the sake of argument that the sample data I've been working is dominated by shot noise. I re-fit my data using this weighting scheme below. Notice the way the uncertainty is put into `curve_fit` - it wants the uncertainties, not the weighting factor." + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[ 8.98775983e-02 -2.29114115e+06 1.37575853e-03]\n", + "[2.74632175e-04 8.29304996e+03 3.31192662e-05]\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "popt_weighted, pcov_weighted = curve_fit(exponential, time, voltage, p0=(.1, -1000000, 0), sigma=voltage**.5)\n", + "perr_weighted = np.sqrt(np.diag(pcov_weighted))\n", + "print(popt_weighted)\n", + "print(perr_weighted)\n", + "\n", + "plt.figure(1)\n", + "plt.bar(('a','k','b'), perr_weighted/popt_weighted*100)\n", + "\n", + "plt.figure(2)\n", + "plt.subplot(211)\n", + "plt.plot(time, voltage-exponential(time, popt_weighted[0],popt_weighted[1], popt_weighted[2]),'g')\n", + "plt.ylabel(\"residuals\")\n", + "plt.subplot(212, sharex=plt.gca())\n", + "plt.plot(time,voltage)\n", + "plt.plot(time, exponential(time, popt_weighted[0],popt_weighted[1], popt_weighted[2]))\n", + "plt.legend((\"Raw data\", \"Model\"))\n", + "plt.ylabel(\"Counts (au)\")\n", + "plt.xlabel(\"time (s)\")\n", + "plt.subplots_adjust(hspace=0)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In this case, the weighting factor only altered the parameters slightly, but adjusted the fit so that it is stronger at smaller signal values.\n", + "\n", + "It is not always necessary to weight your data, however, when you have a good reason to trust some points more than others, it's a good tool in your toolbox. You should be sure that you have a reason for how you decide the weighting factor, and that information belongs in any description of how you fit your data when you write it up.\n", + "\n", + "## Automating your work\n", + "\n", + "The code I've provided you with gets the fit done. However, if you want to change models, or fit many data sets, it's clunky. You could combine all the code into a function or a script that does more of the work for you. This is not at all necessary, but for those of you who like to code, go ahead and do it.\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Your turn\n", + "\n", + "We recorded video of the foam from adding Mentos to Diet Coke as a class. Your assignment is to extract foam volume as a function of time, fit the data, and convince me that you're right.\n", + "\n", + "### Group work?\n", + "\n", + "You're welcome to chat with your classmates as you work. Actually, that's encouraged. We've got a whole space in Webex just for programming talk. Ask your questions, answer questions, rant about your difficulties. But at the end of the assignment, you should be turning in your own work.\n", + "\n", + "### Extracting the data\n", + "\n", + "I will put the video file(s) in the class shared Google Drive folder, which is linked on Blackboard, probably in more than one location. I will also extract frames from one of the video files and post them in the shared folder. You'll need to either watch the video or step through the still frames and get foam volume at each time.\n", + "\n", + " - You may simply grab one set of data and move on with your life\n", + " - You may also choose to work together with some or all of the class to assemble a data set\n", + " - You might want to create a spreadsheet in the shared folder where different students can put in their reading of foam volume and a description of how they did it\n", + " - Different students could read the same time points which gives you more statistical power\n", + " - Or you could break up the data set to get through it faster\n", + " - This is as much an exercise in self orginization as a class as it is in your experimental abilities\n", + " - Consider how to record the volumes. The measurement device is graduated in 25mL increments but is upside down. There is also some head space that I have not measured, though you're welcome to do so.\n", + " - Probably don't obesses too much, just try to think carefully about it as you go.\n", + " - Based on results from Spring 2020, it'll be really hard to fit if you only have ~20 points. 50 is better. 100 is even better.\n", + "\n", + "### Fitting the data\n", + "\n", + "Set up a new Jupyter notebook. Import your data. Now decide which portion of your data you wish to fit. Any of the following is acceptable:\n", + "\n", + " - Fit the initial rise\n", + " - Fit the decay of foam volume\n", + " - Fit the entire data set\n", + "\n", + "Obviously, each of those is a different shape and will require a different fuctional form. Do what you need to do in order to fit your data set as rigorously as possible. You'll want to consider if you have any chemical intuition about what functional form might be relevant. You'll also need to pick a function form that can be the shape of the data.\n", + "\n", + "### Cleaning it up and turning it in\n", + "\n", + "You're going to turn in your Jupyter notebook, but clean it up first. The top section of your notebook should be your data import, showing any work you needed to do to get the data ready to fit. Next, show me a fit you rejected that's not totally implausible, but that you rejected. I need to see the raw data, your fit, a residuals plot, and a representation of parameter error. Then discuss how this information caused you to reject the model. Finally, show me your final choice model fit. I need to see the raw data, your fit, residuals, and parameter error. Discuss why this is your best choice for a fit.\n", + "\n", + "You should make this notebook easy for me to follow. That means you're going to need to comment as you go, and make the plots pretty enough for me to read. There is no need to obsess, but consider if an axis label, legend, or zoom is necessary for me to see what you want me to see. You're also going to need to type plain text describing what you did, just like the cell I'm typing in right now. These cells are called **markdown** cells. You can convert a cell to markdown using the drop down menu at the top of a notebook, or by pressing escape (so the side of the cell turns blue) and then pressing `m`. Your discussion of fits should be done in markdown cells. You may add any extra markdown cells needed to make your notebook easy for me to follow.\n", + "\n", + "When you are done, save the file with your name(s) as the filename, and upload both your notebook and your datafile to Blackboard. You will be graded as follows:\n", + "\n", + "\n", + "| Thing | Points|\n", + "|-------|-------|\n", + "| You upload the .ipynb file and your data file, both with filenames that include your name | 1|\n", + "|All your code executes | 4|\n", + "|Your notebook is cleaned up enough that I can follow it | 5|\n", + "|You have raw data, a fit, a residuals plot, and a representation of parameter error for a fit that doesn't work|10|\n", + "|You have a rigorous discussion of why that fit is not optimal|10|\n", + "|You have raw data, a fit, a residuals plot, and a representation of parameter error for a fit that does work|10|\n", + "|You convince me that this fit is an accemptable fit | 10|" + ] + }, + { + "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.8.8" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/Second term - model fitting and computation chemistry/Model fitting lab.ipynb b/Second term - model fitting and computation chemistry/Model fitting lab.ipynb index d84faab..9eeade7 100644 --- a/Second term - model fitting and computation chemistry/Model fitting lab.ipynb +++ b/Second term - model fitting and computation chemistry/Model fitting lab.ipynb @@ -46,7 +46,9 @@ "\n", "Along the way, realize that I'm showing you how to do new skills in action. It's your job to read the documentation to figure out how I'm doing what I'm doing. To get started, execute the cell below to import the libraries that you'll need, and get rolling.\n", "\n", - "(Did you forget how to execute a cell? Click on the cell and press `shift+enter`." + "(Did you forget how to execute a cell? Click on the cell and press `shift+enter`.\n", + "\n", + "***Cassio was here...maybe?***" ] }, { @@ -1331,7 +1333,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.8.5" + "version": "3.8.8" } }, "nbformat": 4,