SEAP.ipynb

{ 
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      
     ]
    }
   ],
   "source": [

   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "#imports and methods\n",
    "#you might have to install rdp with 'pip install rdp'\n",
    "import pandas as pd\n",
    "import tkinter as tk\n",
    "from tkinter import filedialog as fd\n",
    "from matplotlib import pyplot as plt\n",
    "import numpy as np\n",
    "from rdp import rdp\n",
    "from openpyxl import load_workbook\n",
    "\n",
    "\n",
    "def get_filename():\n",
    "    root = tk.Tk()\n",
    "    root.withdraw()\n",
    "    filename = fd.askopenfilename()\n",
    "    return filename\n",
    "    root.destroy()\n",
    "\n",
    "def get_slopes(filename, cb = True, res = 'funct', eps = 0.15, write = False):\n",
    "    #parameters:\n",
    "    #filename: name of the file to analyze, use get_filename()\n",
    "    #cb: when True, also copy the result to the clipboard\n",
    "    #res: chose the form of the results: 'funct' for funct formulars, 'slopes' for numeric values and 's_e' for\n",
    "    #-- a list of start- and endpoints\n",
    "    #create list to append funct formulars\n",
    "    funct = list()\n",
    "    #and one to add the slopes as numeric values\n",
    "    slopes = list()\n",
    "    #and one to add the start and end points\n",
    "    s_e = list()\n",
    "    #create the x values for the full measurement - a list with 60 entries, going from 0 to 59 in increases of 1\n",
    "    x = np.linspace(0,59,60)\n",
    "    #import the data series from the funct template\n",
    "    pdf = pd.read_excel(filename, sheet_name = 'SEAP vertical transformation', usecols = 'C:CT', skiprows = 35)\n",
    "    #create new instance of tkinter, used for accessing the clipboard\n",
    "    r = tk.Tk()\n",
    "    r.withdraw()\n",
    "    #clear the clipboard\n",
    "    r.clipboard_clear()\n",
    "    #iterate over the columns in the dataframe, representing a series of A405 measurements\n",
    "    for name, values in pdf.iteritems():\n",
    "        #converting the index of a well to an funct column index (+3 as the first 3 columns in the template are unused)\n",
    "        col = col_int_to_char(pdf.columns.get_loc(name)+3)\n",
    "        #transform the values to pairs (two dimensional coordinates)\n",
    "        vst = np.vstack((x, np.array(values))).T\n",
    "        #apply the RDP algorithm on the set of data\n",
    "        vst = rdp(vst, epsilon = eps)\n",
    "        #retreive the starting and ending point of the first RDP segment\n",
    "        s = int(vst[0][0])\n",
    "        e = int(vst[1][0])\n",
    "        #move the start to remove all 'dropping values' from the start to optimize the outcome\n",
    "        while values[s]>values[s+1]: \n",
    "            s = s+1\n",
    "        #calculate the slope from the linear segment\n",
    "        slope = (values[e]-values[s])/(e-s)\n",
    "        #generate the funct formular which calculates the slope in the template\n",
    "        code = \"=SLOPE({c}{s}:{c}{e},$A${s}:$A${e})\".format(c = col, s = s+37, e = e+37)\n",
    "        #when cb is True, append it to the clipboard and append a tabulator for simplifying the pasting\n",
    "        if cb: r.clipboard_append(code+'\\t')\n",
    "        #append the results to their respective lists\n",
    "        funct.append(code)\n",
    "        slopes.append(slope)\n",
    "        s_e.append((s,e))\n",
    "    #update the content of the clipboard\n",
    "    r.update()\n",
    "    #if write == True, the slopes will be directly written to the file\n",
    "    if write: write_slopes(filename, funct)\n",
    "    #return the slopes in the selected way\n",
    "    if res == 'funct': return funct\n",
    "    if res == 'slopes': return slopes\n",
    "    if res == 's_e': return s_e\n",
    "\n",
    "\n",
    "def plot_slopes(filename, plt_nr = 24, s_e = False):\n",
    "    #parameters:\n",
    "    #filename: name of the file to plot from, use get_filename()    \n",
    "    #n: number of plots to be generated, it must be a divider of 96\n",
    "    #s_e: if the output of get_slopes(...res='s_e') should be used, pass it here\n",
    "    color = ['#a6cee3','#1f78b4','#b2df8a','#33a02c','#fb9a99','#e31a1c','#fdbf6f','#ff7f00','#cab2d6','#6a3d9a','#ffff99']*9\n",
    "    if 96%plt_nr!=0: \n",
    "        print('96%plt_nr must be 0!')\n",
    "        return None\n",
    "    pdf = pd.read_excel(filename, sheet_name = 'SEAP vertical transformation', usecols = 'C:CT', skiprows = 35)\n",
    "    if not s_e: s_e = get_slopes(filename, res='s_e')\n",
    "    for i in range(0,plt_nr):\n",
    "        if plt_nr<12:  #yeah yeah, just don't comment it! :E\n",
    "            f = plt.figure()\n",
    "            f.set_figwidth(16)\n",
    "            f.set_figheight(8)\n",
    "        for j in range(0,int(96/plt_nr)):\n",
    "            col = pdf.iloc[:,int(i*(96/plt_nr)+j)]\n",
    "            x = np.linspace(10*j,59+10*j,60)\n",
    "            y = np.array(col)\n",
    "            plt.plot(x, y, c = color[j])\n",
    "            curse = s_e[int(i*(96/plt_nr)+j)]\n",
    "            x = np.linspace(curse[0]+10*j, curse[1]+10*j, curse[1]-curse[0])\n",
    "            y = np.linspace(col[curse[0]], col[curse[1]], curse[1]-curse[0])\n",
    "            plt.plot(x,y, c = color[j], lw = 4, alpha = .5)\n",
    "        plt.title(pdf.columns[int(i*(96/plt_nr))]+'-'+pdf.columns[int((i*(96/plt_nr)+j))])\n",
    "        plt.show()\n",
    "\n",
    "def write_slopes(filename, slopes):\n",
    "    slopes = pd.DataFrame([slopes])\n",
    "    book = load_workbook(filename)\n",
    "    writer = pd.ExcelWriter(filename, engine='openpyxl') \n",
    "    writer.book = book\n",
    "    writer.sheets = dict((ws.title, ws) for ws in book.worksheets)\n",
    "    slopes.to_excel(writer, \"SEAP vertical transformation\", header = False, index = False, startrow = 30, startcol = 2)\n",
    "    writer.save()\n",
    "    print('Saved to '+filename)\n",
    "\n",
    "def col_int_to_char(col_nr): #makes funct columns out of numbers (i.e. 96 -> 'CT')\n",
    "    ch = ''\n",
    "    while col_nr > 0:\n",
    "        col_nr,r = divmod(col_nr-1, 26)\n",
    "        ch = chr(r+ord('A'))+ch\n",
    "    return ch"
   ]
  }
 ],
 "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
}