{ "cells": [ { "cell_type": "code", "execution_count": 9, "metadata": {}, "outputs": [ { "ename": "SyntaxError", "evalue": "invalid syntax (, line 13)", "output_type": "error", "traceback": [ "\u001b[0;36m File \u001b[0;32m\"\"\u001b[0;36m, line \u001b[0;32m13\u001b[0m\n\u001b[0;31m {\u001b[0m\n\u001b[0m ^\u001b[0m\n\u001b[0;31mSyntaxError\u001b[0m\u001b[0;31m:\u001b[0m invalid syntax\n" ] } ], "source": [ "{\n", " \"cells\": [\n", " {\n", " \"cell_type\": \"markdown\",\n", " \"metadata\": {},\n", " \"source\": [\n", " \"# Statistics 3: Peak Integration and Internal Standards\\n\",\n", " \"\\n\",\n", " \"This Python exercise will cover how to use Python to do peak integration and quantitation using internal standards. The concepts are introduced in the context of separations, but they could also be applied to other analytical techniques and data analysis problems. We will start by importing all the libraries we need. Don't forget to run this line of code with Ctrl+Enter or Shift+Enter\"\n", " ],\n", " },\n", " ]\n", " {\n", " \"cell_type\": \"code\",\n", " \"execution_count\": 1,\n", " \"metadata\": {},\n", " \"outputs\": [],\n", " \"source\": [\n", " \"# Import Everything you Need\\n\",\n", " \"import numpy as np\\n\",\n", " \"import matplotlib.pyplot as plt\\n\",\n", " \"import matplotlib.patches as patches\"\n", " ]\n", " },\n", " {\n", " \"cell_type\": \"markdown\",\n", " \"metadata\": {},\n", " \"source\": [\n", " \"What is the area under the peak? The simplest explanation is that it is sum of the area from each data point. Remember that area is length times height for a rectangle. For discrete data points, we can calculate the area between two points from the [trapezoidal rule](https://en.wikipedia.org/wiki/Trapezoidal_rule). Here, the area of each data point $k$ is equal to the average $y$ value times the difference in $x$: $\\\\frac{y_k + y_{k+1}}{2} \\\\times \\\\Delta x$. Let's look at an example with two data points $(x_1, y_1)$ and $(x_2, y_2)$. The blue trapezoid shows the area between these two data points. We calculate this by calculating the area of the red rectangle, which is the average $y$ value times the difference in $x$ values. You can see that the area of the blue trapezoid is the same as the red rectangle. You can read more from the link above on the trapezoidal rule. \"\n", " ]\n", " },\n", " {\n", " \"cell_type\": \"code\",\n", " \"execution_count\": 68,\n", " \"metadata\": {},\n", " \"outputs\": [\n", " {\n", " \"name\": \"stdout\",\n", " \"output_type\": \"stream\",\n", " \"text\": [\n", " \"The integral is: 13.0\\n\"\n", " ]\n", " },\n", " {\n", " \"data\": {\n", " \"image/png\": \"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\\n\",\n", " \"text/plain\": [\n", " \"\"\n", " ]\n", " },\n", " \"metadata\": {},\n", " \"output_type\": \"display_data\"\n", " }\n", " ],\n", " \"source\": [\n", " \"# Define the data points\\n\",\n", " \"x1 = 1\\n\",\n", " \"x2 = 3\\n\",\n", " \"y1 = 5\\n\",\n", " \"y2 = 8\\n\",\n", " \"\\n\",\n", " \"# Calculate the average y and change in x\\n\",\n", " \"average_y = (y1 + y2)/2\\n\",\n", " \"delta_x = (x2-x1)\\n\",\n", " \"\\n\",\n", " \"# Calculate the integral\\n\",\n", " \"integral = average_y * delta_x\\n\",\n", " \"print(\\\"The integral is:\\\", integral)\\n\",\n", " \"\\n\",\n", " \"# Plot the results\\n\",\n", " \"plt.plot(x1, y1, marker=\\\"o\\\", color=\\\"blue\\\")\\n\",\n", " \"plt.plot(x2, y2, marker=\\\"o\\\", color=\\\"blue\\\")\\n\",\n", " \"plt.plot(2, average_y, marker=\\\"o\\\", color=\\\"red\\\")\\n\",\n", " \"plt.gca().add_patch(patches.Rectangle((x1, 0),delta_x,average_y, color=\\\"red\\\")) \\n\",\n", " \"x = [x1, x2, x2, x1]\\n\",\n", " \"y = [0, 0, y2, y1]\\n\",\n", " \"plt.gca().add_patch(patches.Polygon(xy=list(zip(x,y)), color = \\\"blue\\\", alpha = 0.5))\\n\",\n", " \"plt.ylim(0,8.5)\\n\",\n", " \"plt.xlabel(\\\"X\\\")\\n\",\n", " \"plt.ylabel(\\\"Y\\\")\\n\",\n", " \"plt.show()\"\n", " ]\n", " },\n", " {\n", " \"cell_type\": \"markdown\",\n", " \"metadata\": {\n", " \"slideshow\": {\n", " \"slide_type\": \"fragment\"\n", " }\n", " },\n", " \"source\": [\n", " \"For an array, we just need to sum all of these little trapezoids together. First, let's generate a Gaussian peak:\"\n", " ]\n", " },\n", " {\n", " \"cell_type\": \"code\",\n", " \"execution_count\": 5,\n", " \"metadata\": {},\n", " \"outputs\": [\n", " {\n", " \"data\": {\n", " \"image/png\": \"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\\n\",\n", " \"text/plain\": [\n", " \"\"\n", " ]\n", " },\n", " \"metadata\": {},\n", " \"output_type\": \"display_data\"\n", " }\n", " ],\n", " \"source\": [\n", " \"# Define a Gaussian distribution function (see Statistics 1 notebook)\\n\",\n", " \"def Gaussian(xvalues, mean, standard_deviation):\\n\",\n", " \" sdsquared = standard_deviation**2\\n\",\n", " \" exponent = -(xvalues - mean)**2/(2 * sdsquared)\\n\",\n", " \" preexponential = 1 / np.sqrt(2 * np.pi * sdsquared)\\n\",\n", " \" return preexponential * np.exp(exponent)\\n\",\n", " \"\\n\",\n", " \"# Generate a list of x values\\n\",\n", " \"x = np.arange(-6, 6, 0.1) \\n\",\n", " \"\\n\",\n", " \"# Generate a Gaussian for a given mean and standard deviation\\n\",\n", " \"mean = 0\\n\",\n", " \"std_dev = 1\\n\",\n", " \"y = Gaussian(x, mean, std_dev)\\n\",\n", " \"\\n\",\n", " \"# Plot the result\\n\",\n", " \"\\n\",\n", " \"plt.plot(x, y)\\n\",\n", " \"plt.show()\\n\"\n", " ]\n", " },\n", " {\n", " \"cell_type\": \"markdown\",\n", " \"metadata\": {},\n", " \"source\": [\n", " \"Before we write our function, we need to introduce the idea of a \\\"for\\\" loop. For loops keep repeating a specific operation for a specific number of times. In Python, for loops are defined by a variable cycling through an array or list. In the example below, the variable is $i$ and the array is $indexes$. On the first iteration of the loop, $i=0$ (the first element in the $indexes$ array). It will execute the block of code that is indented and then go on to the next element in the $indexes$ array, $i=1$. The variables inside the for loop can get overwritten and change. To exit the for loop, remove the indent. The code below loops through $indexes$ and prints the square of each index as it goes.\"\n", " ]\n", " },\n", " {\n", " \"cell_type\": \"code\",\n", " \"execution_count\": 6,\n", " \"metadata\": {},\n", " \"outputs\": [\n", " {\n", " \"name\": \"stdout\",\n", " \"output_type\": \"stream\",\n", " \"text\": [\n", " \"Starting to loop through elements in indexes: [0 1 2 3 4]\\n\",\n", " \"The value of k in this loop is: 0\\n\",\n", " \"Running Some Code...k squared is: 0\\n\",\n", " \"The value of k in this loop is: 1\\n\",\n", " \"Running Some Code...k squared is: 1\\n\",\n", " \"The value of k in this loop is: 2\\n\",\n", " \"Running Some Code...k squared is: 4\\n\",\n", " \"The value of k in this loop is: 3\\n\",\n", " \"Running Some Code...k squared is: 9\\n\",\n", " \"The value of k in this loop is: 4\\n\",\n", " \"Running Some Code...k squared is: 16\\n\",\n", " \"For loop done\\n\"\n", " ]\n", " }\n", " ],\n", " \"source\": [\n", " \"indexes = np.arange(0, 5)\\n\",\n", " \"print(\\\"Starting to loop through elements in indexes:\\\", indexes)\\n\",\n", " \"for k in indexes:\\n\",\n", " \" print(\\\"The value of k in this loop is:\\\", k)\\n\",\n", " \" s = k**2\\n\",\n", " \" print(\\\"Running Some Code...k squared is:\\\", s)\\n\",\n", " \"print(\\\"For loop done\\\")\"\n", " ]\n", " },\n", " {\n", " \"cell_type\": \"markdown\",\n", " \"metadata\": {},\n", " \"source\": [\n", " \"Now, let's write a function to calculate the integral. Our data point area function comes directly from the trapezoid rule above. Our integral function will just apply this to each data point in the $x$ and $y$ arrays using a for loop. Note, we need to start at the second element of the list rather than the first element because we need to compare two data points, $k$ and $k-1$. \"\n", " ]\n", " },\n", " {\n", " \"cell_type\": \"code\",\n", " \"execution_count\": 7,\n", " \"metadata\": {},\n", " \"outputs\": [\n", " {\n", " \"name\": \"stdout\",\n", " \"output_type\": \"stream\",\n", " \"text\": [\n", " \"0.999999997112\\n\"\n", " ]\n", " }\n", " ],\n", " \"source\": [\n", " \"# A function to calculate the trapezoid area for two points. This comes directly from the code above.\\n\",\n", " \"def data_point_area(x1, x2, y1, y2):\\n\",\n", " \" average_y = (y1 + y2)/2\\n\",\n", " \" delta_x = (x2-x1)\\n\",\n", " \" area = average_y * delta_x\\n\",\n", " \" return area\\n\",\n", " \"\\n\",\n", " \"# A function to calculate the integral for an array\\n\",\n", " \"def integral(x, y):\\n\",\n", " \" length = len(x) # Calculate the length of the x array\\n\",\n", " \" indexes = np.arange(1,length) # Create an array of indexes. Don't start at 0 but 1.\\n\",\n", " \" sum_value = 0 # Set the sum value to 0 initially\\n\",\n", " \" for k in indexes:\\n\",\n", " \" # Get the correct x and y values from the list based on their indexes\\n\",\n", " \" x1 = x[k-1]\\n\",\n", " \" y1 = y[k-1]\\n\",\n", " \" x2 = x[k]\\n\",\n", " \" y2 = y[k]\\n\",\n", " \" # Calculate the area for those set of two points from the function above\\n\",\n", " \" area = data_point_area(x1, x2, y1, y2)\\n\",\n", " \" # Add the area from the two points to the total sum\\n\",\n", " \" sum_value = sum_value + area\\n\",\n", " \" return sum_value\\n\",\n", " \"\\n\",\n", " \"print(integral(x, y)) \"\n", " ]\n", " },\n", " {\n", " \"cell_type\": \"markdown\",\n", " \"metadata\": {},\n", " \"source\": [\n", " \"The integral should be almost exactly one. That is because the area of a Gaussian distribution is normalized to 1. Numpy also has a trapezoidal integral function, trapz. You can see below that our homemade function should match this. Note, this function takes $x$ as the second argument because $x$ is optional in this function. If you don't have $x$, it will assume $\\\\Delta x$ is 1 for each data point.\"\n", " ]\n", " },\n", " {\n", " \"cell_type\": \"code\",\n", " \"execution_count\": 8,\n", " \"metadata\": {},\n", " \"outputs\": [\n", " {\n", " \"name\": \"stdout\",\n", " \"output_type\": \"stream\",\n", " \"text\": [\n", " \"0.999999997112\\n\"\n", " ]\n", " }\n", " ],\n", " \"source\": [\n", " \"print(np.trapz(y, x=x))\"\n", " ]\n", " },\n", " {\n", " \"cell_type\": \"markdown\",\n", " \"metadata\": {},\n", " \"source\": [\n", " \"The final thing we need to learn to put it all together is how to chop out specific parts of the data. I've included a function to do this using Boolean indexing. Basically, it grabs all the $x$ values that are both greater than $minx$ and less than $maxx$ and chops the array down to include only the values within that range. \\n\",\n", " \"\\n\",\n", " \"After doing that, we can calculate the area under that part of the curve only. \"\n", " ]\n", " },\n", " {\n", " \"cell_type\": \"code\",\n", " \"execution_count\": 10,\n", " \"metadata\": {},\n", " \"outputs\": [\n", " {\n", " \"name\": \"stdout\",\n", " \"output_type\": \"stream\",\n", " \"text\": [\n", " \"Integral from -1 to 1 is: 0.656883274351\\n\"\n", " ]\n", " },\n", " {\n", " \"data\": {\n", " \"image/png\": \"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\\n\",\n", " \"text/plain\": [\n", " \"\"\n", " ]\n", " },\n", " \"metadata\": {},\n", " \"output_type\": \"display_data\"\n", " }\n", " ],\n", " \"source\": [\n", " \"# Chop an array to include only x values between minx and maxx\\n\",\n", " \"def datachop(x, y, minx, maxx):\\n\",\n", " \" boo1 = np.logical_and(x <= maxx, x >= minx)\\n\",\n", " \" return x[boo1], y[boo1]\\n\",\n", " \"\\n\",\n", " \"# Set the min and max\\n\",\n", " \"minx = -1\\n\",\n", " \"maxx = 1\\n\",\n", " \"\\n\",\n", " \"# Get the new cut x and y arrays\\n\",\n", " \"cutx, cuty = datachop(x, y, minx, maxx)\\n\",\n", " \"\\n\",\n", " \"# Calculate the area under the cut arrays\\n\",\n", " \"area = integral(cutx, cuty)\\n\",\n", " \"print(\\\"Integral from\\\", minx, \\\"to\\\", maxx, \\\"is:\\\", area)\\n\",\n", " \"\\n\",\n", " \"# Plot the cut arrays in red against the original in black\\n\",\n", " \"plt.plot(x, y, color=\\\"black\\\")\\n\",\n", " \"plt.plot(cutx, cuty, marker=\\\"o\\\", color=\\\"red\\\")\\n\",\n", " \"plt.xlabel(\\\"z\\\")\\n\",\n", " \"plt.show()\"\n", " ]\n", " },\n", " {\n", " \"cell_type\": \"markdown\",\n", " \"metadata\": {},\n", " \"source\": [\n", " \"Now, we should put everything together to make it easier and in one function.\"\n", " ]\n", " },\n", " {\n", " \"cell_type\": \"code\",\n", " \"execution_count\": 11,\n", " \"metadata\": {},\n", " \"outputs\": [\n", " {\n", " \"name\": \"stdout\",\n", " \"output_type\": \"stream\",\n", " \"text\": [\n", " \"0.656883274351\\n\"\n", " ]\n", " }\n", " ],\n", " \"source\": [\n", " \"def integral_range(x, y, minx, maxx):\\n\",\n", " \" cutx, cuty = datachop(x, y, minx, maxx)\\n\",\n", " \" area = np.trapz(cuty, x = cutx)\\n\",\n", " \" return area\\n\",\n", " \"\\n\",\n", " \"# Test it\\n\",\n", " \"print(integral_range(x, y, minx,maxx))\"\n", " ]\n", " },\n", " {\n", " \"cell_type\": \"markdown\",\n", " \"metadata\": {},\n", " \"source\": [\n", " \"Because the mean is 0 and the standard deviation is 1, the $x$ axis is actually $z$ values from page 67 in the Harris textbook. Take a look at Figure 4-3 and compare it with the plot above. The values you calculate here should be very close to twice the value of $z=1$ from table 4-1. The reason it is twice is that the $z$ value in the table is from $z=0$ to $z=1$ and we are going from $z=-1$ to $z=1$.\\n\",\n", " \"\\n\",\n", " \"**Problem 1:** Using the code above, calculate the area under our Gaussian curve from the range of -2 to +2 standard deviations. This should be near 95%. \"\n", " ]\n", " },\n", " {\n", " \"cell_type\": \"code\",\n", " \"execution_count\": 75,\n", " \"metadata\": {},\n", " \"outputs\": [],\n", " \"source\": [\n", " \"# Your code here!\"\n", " ]\n", " },\n", " {\n", " \"cell_type\": \"markdown\",\n", " \"metadata\": {},\n", " \"source\": [\n", " \"Now, let's apply what you've learned to a simulated chromatogram. This code will generate two peaks with different retention times and widths.\"\n", " ]\n", " },\n", " {\n", " \"cell_type\": \"code\",\n", " \"execution_count\": 12,\n", " \"metadata\": {},\n", " \"outputs\": [\n", " {\n", " \"data\": {\n", " \"image/png\": \"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\\n\",\n", " \"text/plain\": [\n", " \"\"\n", " ]\n", " },\n", " \"metadata\": {},\n", " \"output_type\": \"display_data\"\n", " }\n", " ],\n", " \"source\": [\n", " \"# Set the retention times\\n\",\n", " \"t1 = 10\\n\",\n", " \"t2 = 15\\n\",\n", " \"\\n\",\n", " \"# Set the peak widths\\n\",\n", " \"w1 = 1\\n\",\n", " \"w2 = 1.5\\n\",\n", " \"\\n\",\n", " \"# Define the x axis\\n\",\n", " \"x = np.arange(0,20, 0.1)\\n\",\n", " \"\\n\",\n", " \"# Sum together two gaussians and some noise. Note, the second one is set to have half the area of the first\\n\",\n", " \"y = Gaussian(x, t1, w1/4) + 0.5*Gaussian(x, t2, w2/4) + np.random.normal(0,0.01, len(x))\\n\",\n", " \"\\n\",\n", " \"# Plot the results\\n\",\n", " \"plt.plot(x, y)\\n\",\n", " \"plt.xlabel(\\\"Retention Time\\\")\\n\",\n", " \"plt.ylabel(\\\"Absorbance\\\")\\n\",\n", " \"plt.text(t1+1, 1.4, \\\"A\\\")\\n\",\n", " \"plt.text(t2, 0.7, \\\"B\\\")\\n\",\n", " \"plt.show()\"\n", " ]\n", " },\n", " {\n", " \"cell_type\": \"markdown\",\n", " \"metadata\": {},\n", " \"source\": [\n", " \"**Problem 2:** Find the **a)** the area of peak A, **b)** the area of peak B, and **c)** the ratio of the area of A the area of B. Hint: the ratio of A/B should be around 2. \"\n", " ]\n", " },\n", " {\n", " \"cell_type\": \"code\",\n", " \"execution_count\": 78,\n", " \"metadata\": {},\n", " \"outputs\": [],\n", " \"source\": [\n", " \"# Your code here\\n\",\n", " \"# Hint: you should use the integral_range function from above\"\n", " ]\n", " },\n", " {\n", " \"cell_type\": \"markdown\",\n", " \"metadata\": {},\n", " \"source\": [\n", " \"**Problem 3:** Assume peak A is the internal standard with a known molar absorptivity of 4,500 M-1cm-1 and a known concentration of 5 mM. Assume peak B is our analyte with a known molar absorptivity of 3,700 M-1cm-1. **a)** What is the detector response factor, F? **b)** What is the concentration of our analyte from the chromatogram Problem 2?\"\n", " ]\n", " },\n", " {\n", " \"cell_type\": \"code\",\n", " \"execution_count\": 79,\n", " \"metadata\": {},\n", " \"outputs\": [],\n", " \"source\": [\n", " \"# Your code here\"\n", " ]\n", " }\n", " ],\n", " \"metadata\": {\n", " \"kernelspec\": {\n", " \"display_name\": \"Python 3\",\n", " \"language\": \"python\",\n", " \"name\": \"python3\"\n", " },\n", " \"language_info\": {\n", " \"codemirror_mode\": {\n", " \"name\": \"ipython\",\n", " \"version\": \"3\"\n", " },\n", " \"file_extension\": \".py\",\n", " \"mimetype\": \"text/x-python\",\n", " \"name\": \"python\",\n", " \"nbconvert_exporter\": \"python\",\n", " \"pygments_lexer\": \"ipython3\",\n", " \"version\": \"3.6.2\"\n", " }\n", " },\n", " \"nbformat\": 4,\n", " \"nbformat_minor\": 2\n", "}" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [] }, { "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.6.2" } }, "nbformat": 4, "nbformat_minor": 2 }