Jupyter_Plot_Lin_Fit.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Python Notebook: <u> Graph Plotting and Linear Fitting for Experimental Lab\n",
    "# University of York, Department of Physics\n",
    "\n",
    "This python notebook reads x-y data, with errors if used, from a data file and plots a graph. If required, a linear least-squares fit is perfomed to determine the gradient and intercept with errors.\n",
    "\n",
    "<i> Version 1.1, November 3rd 2020. This notebook was written by Mike Bentley, University of York. Feel free to copy, use and adapt for your own purposes. Any suggestions for improvement to michael.bentley@york.ac.uk. [Thanks to Sachin Mysorekar for testing and useful additions] \n",
    "\n",
    "This version has been updated to include the option of using a comma-separated (i.e. .csv) data file. </i>  \n",
    "\n",
    "Instructions:\n",
    "\n",
    "Part 1: (User preferences and options)\n",
    "    1. Enter file name containing data\n",
    "    2. Enter User preferences (see comments for instructions)\n",
    "Part 2: (code)\n",
    "    3. Run the \"Check Data File\" section to check that all the data is read in properly\n",
    "    4. Run the rest of the cells in the notebook\n",
    "Part 3: (Graph)\n",
    "    5. Modify the options in the final cell for secific graph options\n",
    "\n",
    "# Part 1:  User data and preferences\n",
    "\n",
    "## Enter name of file containing data\n",
    "\n",
    "Data file needs to be in the same directory as this notebook. Otherwise, put in the full path.\n",
    "\n",
    "Data file should be a plain text file with data in columns and no other entries. The separator between data points can be spaces, tabs or commas. If saving data from Excel, Origin, etc, save as \"Tab delimited\" (.txt) file or a Comma separated (i.e. .csv) file. \n",
    "    \n",
    "The data file can have as many columns as you like. In the cell below you will specify which columns contain the required parameters."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "Filename=\"data_fitting_test.txt\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Enter user preferences \n",
    "\n",
    "Here you need to specify the columns, and other preferences"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "xcolumn = 1                   # Specify the column containing the x data points \n",
    "ycolumn = 2                   # Specify the column containing the y data points \n",
    "include_x_errors = False      # Enter True or False only (True if x errors needed on plot)\n",
    "include_y_errors = True       # Enter True or False only (True if y errors needed on plot)\n",
    "xerrcolumn = 3                # Specify the column containing the x errors \n",
    "yerrcolumn = 4                # Specify the column containing the y errors \n",
    "fit_line = True               # Enter True or False only (True if line of best fit needed)\n",
    "header = True                 # Does your data file contain one of more header lines (e.g. column titles)\n",
    "head_lines = 1                # Enter the number of header lines in your data file\n",
    "save_graph = True             # Enter True or False only (True if you wish to save the figure)\n",
    "CSV=False                     # Is the data separated by commas (True if yes - e.g. a .csv file)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Specify the name of the file if you wish to save the graph. (It will be saved in the same directory as this notebook). The format of the file is determined by the file extension, e.g. $\\texttt{.jpg, .pdf, .png}$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig_file=\"figure.png\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Check data file \n",
    "\n",
    "This script will check the data file, count the number of data points, make sure that there are no anomalies, check for blank lines, and print out the first and last line of the data file for you to check."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      " 10 rows of data, in 4 columns, found in file\n",
      " 0 blank lines found in file, and 1 lines of headers skipped\n",
      "\n",
      " First data row: 2.1\t24.9\t0.042\t5\n",
      " Last data row: 20.5\t95\t0.41\t5\n"
     ]
    }
   ],
   "source": [
    "raw_data = open(Filename,'r')          # Open the data file for input\n",
    "\n",
    "lines=0                                # This counts the number of data lines that have been read\n",
    "first=True                             # A flag is set for the first non-blank line found\n",
    "warning=False                          # A warning flag for a unexpected number of data points in a row \n",
    "blank_lines=0                          # This counts the number of blank lines found\n",
    "\n",
    "# Skip any header lines\n",
    "if header:                             # Are there any header rows?\n",
    "    for i in range(head_lines):\n",
    "        next(raw_data)                 # Skip each header row\n",
    "\n",
    "# Now we loop through every line in the file\n",
    "\n",
    "for data_line in raw_data:             # loops through the file, one line at a time\n",
    "        row = data_line.strip()    # \"row\" is now a string variable contains the text of that line\n",
    "        \n",
    "# check for blank lines\n",
    "        if row == \"\":                  # is it blank?\n",
    "            blank_lines=blank_lines+1  # counts the number of blank lines\n",
    "            continue                   # skip straight to the next line (i.e. the next step of the loop)\n",
    "        elif CSV and row.strip(',')==\"\": # is it just commas?\n",
    "            blank_lines=blank_lines+1  # counts the number of blank lines\n",
    "            continue                   # skip straight to the next line (i.e. the next step of the loop)\n",
    "\n",
    "# for a non-blank line, split the line into columns\n",
    "        lines = lines + 1              # counts the number of lines of data\n",
    "        if CSV:                        # is it a CSV?\n",
    "            data = row.split(',')      # split line into data points (\"data\" is now a list of strings)\n",
    "        else:                          # it's not a CSV\n",
    "            data = row.split()         # split line into data points (\"data\" is now a list of strings)\n",
    "        num_values = len(data)         # counts the number of data points in the line\n",
    "        \n",
    "# Checks the number of data points is the same as in the last line\n",
    "\n",
    "        if first:                      # Is it the first line? (no check possible)\n",
    "            first=False                # Resets the flag\n",
    "            first_row = row            # Stores the first row of data\n",
    "        elif num_values != num_last:   # checks if number of data points is different from last row\n",
    "            warning=True               # Sets a warning flag\n",
    "        num_last = num_values          # Stores current number of data points for the next comparison\n",
    "        last_row = row                 # Stores the most recent (i.e. last) row of data\n",
    "\n",
    "# Now we have finished reading the file\n",
    "\n",
    "raw_data.close()                       # Close the data file\n",
    "\n",
    "# Tell the user what we have found\n",
    "if warning:\n",
    "    print(\"\\n \\n WARNING \\n WARNING - COLUMNS do not have the same number of data points \\n WARNING\\n\")\n",
    "print(\"\\n\",lines,\"rows of data, in\",num_last,\"columns, found in file\")\n",
    "print(\"\",blank_lines,\"blank lines found in file, and\",head_lines,\"lines of headers skipped\") \n",
    "print(\"\\n First data row:\",first_row)\n",
    "print(\" Last data row:\",last_row)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Part 2: Code (run, but don't modify)\n",
    "\n",
    "Now run all the cells below to read the data file into arrays, perform the fits and plot the graph\n",
    "\n",
    "## Read data file"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      " 10 rows of data successfully stored in arrays\n"
     ]
    }
   ],
   "source": [
    "# Import the libraries\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "raw_data = open(Filename,'r')              # Open the data file again\n",
    "\n",
    "# Skip any header lines\n",
    "if header:                                 # Are there any header rows?\n",
    "    for i in range(head_lines):\n",
    "        next(raw_data)                     # Skip each header row\n",
    "\n",
    "# Set up the arrays for storing data:\n",
    "x_data = np.zeros(lines)        # Defines array for the x data points, and sets each of the elements to zero\n",
    "y_data = np.zeros(lines)        # Defines array for the y data points, and sets each of the elements to zero\n",
    "x_err = np.zeros(lines)         # Defines array for the x error bars, and sets each of the elements to zero\n",
    "y_err = np.zeros(lines)         # Defines array for the y error bars, and sets each of the elements to zero\n",
    "\n",
    "# Read the data:\n",
    "i=0\n",
    "for data_line in raw_data:                        # loops through the file, one line at a time\n",
    "        row = data_line.strip()                   # row is a string variable contains the text of that line\n",
    "        if row == \"\":                             # skip any blank lines\n",
    "            continue\n",
    "        elif CSV and row.strip(',')==\"\":          # is it just commas?\n",
    "            continue                              # skip straight to the next line (i.e. the next step of the loop)\n",
    "        else:\n",
    "            if CSV:\n",
    "                data = row.split(',')             # split line into data points (\"data\" is now a list of strings)\n",
    "            else:\n",
    "                data = row.split()                # split line into data points (\"data\" is now a list of strings)\n",
    "        x_data[i] = float(data[xcolumn-1])        # put the x data point, from the right column, in the x array\n",
    "        y_data[i] = float(data[ycolumn-1])        # put the y data point, from the right column, in the y array\n",
    "        if include_x_errors:\n",
    "            x_err[i] = float(data[xerrcolumn-1])  # put the x error bar in the x error array, if used\n",
    "        if include_y_errors:\n",
    "            y_err[i] = float(data[yerrcolumn-1])  # put the y error bar in the y error array, if used\n",
    "        i=i+1                                     # counts the number of data lines read\n",
    "print(\"\\n\",i,\"rows of data successfully stored in arrays\") \n",
    "raw_data.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Perform the linear fit"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Performs a fit calling the numpy polyfit function (polynomial order 1):\n",
    "\n",
    "# If y errors are included, they will be used as weights in the fit calculation:\n",
    "\n",
    "if include_y_errors:                                           # Are y errors are included?\n",
    "    weights=1/y_err                                            # fit \"weights\" are the inverse of the y errors\n",
    "    para,covar=np.polyfit(x_data,y_data,1,w=weights,cov=True)  # Performs a \"weighted\" fit\n",
    "else:\n",
    "    para,covar=np.polyfit(x_data,y_data,1,cov=True)            # Performs an \"unweighted\" fit\n",
    "\n",
    "# Extract the parameters from the fit:\n",
    "\n",
    "errors=np.sqrt(np.diag(covar))                  # Creates a list called \"errors\" from the covariance matrix\n",
    "grad = para[0]                                  # gradient is the first entry in the \"para\" list\n",
    "grad_error = errors[0]                          # error on gradient is the first entry in the \"errors\" list\n",
    "inter = para[1]                                 # intercept is the second entry in the \"para\" list\n",
    "inter_error = errors[1]                         # error on intercept is the second entry in the \"errors\" list\n",
    "\n",
    "\n",
    "x_fit=[min(x_data),max(x_data)]\n",
    "y_fit=[grad*min(x_data)+inter,grad*max(x_data)+inter]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Part 3: Plotting the graph (edit this part)\n",
    "\n",
    "There are several options for plotting that you can modify. Some are commented out with a $\\#$. Remove the $\\#$ to activate them.\n",
    " - $\\texttt{x}\\_\\texttt{lim( )}$, $\\texttt{y}\\_\\texttt{lim( )}$ set the axis ranges\n",
    " - $\\texttt{x}\\_\\texttt{ticks( )}$, $\\texttt{y}\\_\\texttt{ticks( )}$ set the properties of the x and y labels. You can also use these functions to specify custom tick points and custom labels. For example, $\\texttt{x}\\_\\texttt{ticks((2,4,6,8),fontsize=12)}$ will put four labels at x = 2,4,6 and 8 with fontisize 12.\n",
    " - $\\texttt{text( )}$ puts some text on the plot. Note the co-ordinates of the text are in the data co-ordinate system, so the position has the same units as x and y.  \n",
    " - Wherever there is text on the graph i.e. $\\texttt{title( ), text( ), xticks( ), xlabel( )}$ etc, you can modify the text properties using a number of arguments. e.g. $\\texttt{fontsize =} $ (e.g. 10), $\\texttt{color = }$ (e.g. 'black'), $\\texttt{fontsyle =}$ (e.g. 'normal' or 'italic'), $\\texttt{weight =}$ (e.g. 'normal' or 'bold' etc). You can also change the font using $\\texttt{fontfamily =} $ ('arial', or 'calibri', or 'times new roman' etc)\n",
    " - To insert special symbols, superscripts, etc, you can use the LaTeX maths environment by putting commands within dollar signs $\\$$ $\\$$. Examples include $\\texttt{x}\\$\\texttt{^{-2}}\\$ $ for x$^{-2}$, $\\$\\texttt{\\pm}\\$ $ for $\\pm$, $\\$\\texttt{\\sigma}\\$ $ for $\\sigma$, etc. \n",
    " - You can find many many other tricks to format your graph on the [matplotlib.pyplot web page]\n",
    "(https://matplotlib.org/3.1.1/api/pyplot_summary.html) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 900x600 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Fit Results:\n",
      "\n",
      "Gradient: 3.4634064603268477 +/- 0.38434029280327486\n",
      "Intercept: 21.967409192116396 +/- 4.957855703154267\n"
     ]
    }
   ],
   "source": [
    "plt.rcParams['figure.dpi'] = 150   # Controls the size and resolution of the figures as displayed in Jupyter\n",
    "\n",
    "plt.errorbar(x_data,y_data,yerr=y_err,xerr=x_err,fmt='s',color='black',markersize=4,elinewidth=1,capsize=2,label='data')\n",
    "\n",
    "if fit_line:\n",
    "    plt.plot(x_fit,y_fit,'-',color='blue',linewidth=1, label=\"linear fit\")\n",
    "    \n",
    "#plt.xlim(0,2.5)\n",
    "#plt.ylim(0,25)\n",
    "plt.xlabel('X-Axis Label (units)',fontsize=14)\n",
    "plt.ylabel('Y-Axis Label (units)',fontsize=14)\n",
    "plt.title(\"This is a title\",fontsize=16,loc=\"center\")\n",
    "#plt.minorticks_on()\n",
    "#plt.text(7.5,95,\"Here is some text on the graph\",color='red',fontsize=10,weight=\"normal\",fontstyle=\"italic\")\n",
    "plt.xticks(fontsize=12)\n",
    "plt.yticks(fontsize=12)\n",
    "plt.legend()\n",
    "#plt.grid(True)\n",
    "\n",
    "if save_graph:\n",
    "    plt.savefig(fig_file,dpi=500)\n",
    "\n",
    "plt.show()\n",
    "\n",
    "if fit_line:\n",
    "    print(\"\\nFit Results:\\n\")\n",
    "    print(\"Gradient:\",grad,\"+/-\",grad_error)\n",
    "    print(\"Intercept:\",inter,\"+/-\",inter_error)"
   ]
  },
  {
   "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.8.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}