SEED2_0.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Main SEED 2.0 Code\n",
    "# Initially created by Michael Vause, 12/06/2020\n",
    "\n",
    "# Import all required modules\n",
    "try:\n",
    "    import pkg_resources.py2_warn\n",
    "    import sys\n",
    "    from sys import platform # Used to detect the operating system used by the user to change the dimensions of the GUI\n",
    "    import tkinter as tk # tkinter is the GUI module used for this project\n",
    "    from tkinter import ttk\n",
    "    from tkinter import messagebox\n",
    "    from tkinter import filedialog as fd\n",
    "    import numpy as np\n",
    "    import os\n",
    "    import io\n",
    "    from PIL import Image, ImageTk # Used for the addition of the Durham University logo to the GUI\n",
    "    from urllib.request import urlopen # Used for the addition of the Durham University logo to the GUI\n",
    "    import ssl # Needed for the Durham University logo to open properly\n",
    "    import pysindy as ps\n",
    "    import ast # ast is used to find the class name to use when instantiating the optimization and differentiation variable\n",
    "    from scipy.signal import savgol_filter # Although unused in the code, this is needed for the smoothed finite difference differentiation option to work\n",
    "    from scipy.integrate import odeint # used when generating the lorenz data for the \"Generate Lorenz System\" option\n",
    "    import csv\n",
    "    import webbrowser # Used for opening the GitHub page when the \"Tutorial\" button is pressed so the user can read the readme file\n",
    "    from math import ceil\n",
    "    import matplotlib\n",
    "    import matplotlib.pyplot as plt\n",
    "    from matplotlib.backends.backend_tkagg import FigureCanvasTkAgg, NavigationToolbar2Tk\n",
    "    import pandas as pd # Used when saving the output coefficient matrix to a .csv file\n",
    "except ImportError as mod: # If the user didn't install the required modules beore trying to run SEED 2.0\n",
    "    print(\"Install the required modules before starting:\\n\" + str(mod))\n",
    "    messagebox.showerror(title=\"Module Import Error\", message=\"Install the required modules before starting:\\n\" + str(mod))\n",
    "    sys.exit()\n",
    "except Exception as err: # Any other exception that should occur (nothing else should happen, hence generalising all other exceptions)\n",
    "    print(\"Error while importing:\\n\" + str(err))\n",
    "    sys.exit()\n",
    "\n",
    "# Any global variables used throughout Seed 2.0\n",
    "\n",
    "pysindypath = os.path.dirname(ps.__file__) # Find file path for pysindy module within the python files\n",
    "hidden = False # Is the own data file browser button shown\n",
    "to_open = \" \" # Variable storing the filepath for the own data file\n",
    "adv = False # Is the advanced options panel shown\n",
    "opt_widgets = [] # Storing information for the advanced optimization option widgets, structure of each item in list (the difference in structure for different types is important!): \n",
    "                        #if the variable is a boolean : [label widget with name of variable,option menu with True/False,type of variable (bool in this case),the input value of the widget on the GUI]\n",
    "                        #for other variables : [label widget with name of variable,type of variable (e.g int or string),entry box widget with input value from GUI]\n",
    "diff_widgets = [] # Storing information for the advanced differentiation option widgets, structure of each item in list (the difference in structure for different types is important!):\n",
    "                        #for empty variables: [label widget with name of variable,string type,entry widget (empty by default)]\n",
    "                        #if the variable is a boolean: [label widget with name of variable,option menu with True/False,type of variable (bool in this case),the input value of the widget on the GUI]\n",
    "                        #for other variables: [label widget with name of variable,type of variable,entry box widget with input value from GUI]\n",
    "\n",
    "                        #When the item is \"type of variable\", that means the type of the inbuilt variable in the actual optimization/differentiation class\n",
    "\n",
    "# Any functions used throughout SEED 2.0\n",
    "\n",
    "# Function to run on pressing the exit button when closing SEED 2.0\n",
    "def on_closing():    \n",
    "    if messagebox.askokcancel(\"Quit\", \"Are you sure you want to quit?\"): # tkinter message box, returning True when \"ok\" is pressed\n",
    "        window.destroy() # Destroy the window mainloop\n",
    "\n",
    "# Take a file path and return all of the non hidden files in that path\n",
    "def non_hidden(path):\n",
    "    files = [file for file in os.listdir(path) if not file.startswith(\".\")]\n",
    "    return files\n",
    "\n",
    "# Show/hide the file browser button depending on whether or not own data is selected\n",
    "def toggle_browser(command):\n",
    "    global hidden\n",
    "    global to_open\n",
    "    filename = to_open.split('/')[-1] # Show filename portion of filepath\n",
    "    sel_op = sel_var.get() # The option selected in the Example/Own Data dropdown\n",
    "\n",
    "    if sel_op == \"Own Data\":\n",
    "        if hidden: # Show browser widgets\n",
    "            file_button.grid()\n",
    "            file_label.configure(text=\"File Selected: \" + filename)\n",
    "            hidden = False\n",
    "        else: # Keep the widgets shown\n",
    "            pass\n",
    "    else:# If own data not selected, hide everything\n",
    "        if not hidden: # Hide browser widgets\n",
    "            file_button.grid_remove()\n",
    "            file_label.configure(text=\" \")\n",
    "            hidden = True\n",
    "        else: # Keep the widgets hidden\n",
    "            pass\n",
    "\n",
    "# Show file browser - called when \"Select File\" button pressed\n",
    "def browse():\n",
    "    global to_open\n",
    "    to_open = fd.askopenfilename(initialdir = \"/\", filetypes = ((\"CSV files\", \"*.csv\"), (\"all files\", \"*.*\"))) # tkinter file browser window, returning filepath of selected file\n",
    "    filename = to_open.split('/')[-1] # Name of selected file\n",
    "    file_label.configure(text=\"File Selected: \" + filename) # Update label to show selected file, saved globally so that the programme remembers the selected file\n",
    "\n",
    "# Hide and show optimization/differentiation option variable selection\n",
    "def advanced():\n",
    "    global adv\n",
    "\n",
    "    if(adv): # Hide advanced options\n",
    "        size = str(min_w)+\"x\"+str(min_h)\n",
    "        adv_button[\"text\"] = \"Show Advanced\" # Set the button text\n",
    "        adv = False\n",
    "    elif(not adv): # Show advanced options\n",
    "        size = adv_size\n",
    "        adv_button[\"text\"] = \"Hide Advanced\" # Set the button text\n",
    "        adv = True\n",
    "    \n",
    "    window.geometry(size) # Set GUI window's size\n",
    "\n",
    "# Get optimizer or differentiator selection class name\n",
    "def get_od_class(selection):\n",
    "    if(selection == \"opt\"):\n",
    "        opt = str(opt_var.get()) # Get the optimization option selected\n",
    "        fil = open(pysindypath+\"/optimizers/\"+opt+\".py\") # Open the optimization option file\n",
    "    elif(selection == \"diff\"):\n",
    "        diff = str(diff_var.get()) # Get the differentiation option selected\n",
    "        fil = open(pysindypath+\"/differentiation/\"+diff+\".py\") # Open the differentiation option file selected\n",
    "\n",
    "    # Read the file, return all of the names of the lasses in the file and return the class name for the option\n",
    "    contents = fil.read()\n",
    "    par = ast.parse(contents)\n",
    "    classes = [node.name for node in ast.walk(par) if isinstance(node, ast.ClassDef)]\n",
    "    return classes[0]\n",
    "\n",
    "# Get optimization option variables and update on advanced option panel\n",
    "def get_opt(command):\n",
    "    class_name = get_od_class(\"opt\")\n",
    "    opt_inst = eval(\"ps.\"+class_name+\"()\") # Instantiate the optimization option\n",
    "    opt_params = opt_inst.get_params() # Get the inbuilt parameters and values from the instance (inbuilt function to the optimizer class - *Not the same for the differentiation options*)\n",
    "\n",
    "    disp_opt_select(opt_params)\n",
    "\n",
    "# Display the optimization option variables on advanced option panel\n",
    "def disp_opt_select(opt_params):\n",
    "    global opt_fram\n",
    "    global opt_widgets\n",
    "    opt_widgets = []\n",
    "    opt_fram.destroy() # Remove all current widgets in advanced option panel to repopulate with new selection variables\n",
    "\n",
    "    opt_fram = tk.Frame(window,bd=2,bg=bgc,width=5) # Rebuild the optimization option frame\n",
    "\n",
    "    ofram_label = tk.Label(opt_fram,text=\"Optimization Option Variables\",font=(\"Times\",18,\"bold\"),pady=10,bg=bgc)\n",
    "    ofram_label.grid(row=0,column=0,sticky=\"W\")\n",
    "\n",
    "    var_list = list(opt_params)\n",
    "    for x in range(len(var_list)): # Create a widget for all inbuilt parameters \n",
    "        var_label = tk.Label(opt_fram,text=var_list[x],font=(\"Times\",15,\"bold\"),pady=10,bg=bgc) # Label widget for all inbuilt parameters containing the parameter name\n",
    "        var_label.grid(row=x+1,column=0,sticky=\"E\")\n",
    "\n",
    "        if str(opt_params[var_list[x]]) == \"True\" or str(opt_params[var_list[x]]) == \"False\": # Create dropdown with True/False option for boolean variables\n",
    "            ovar_x = tk.StringVar(opt_fram) # The value of the inbuilt parameter\n",
    "            ovar_options = [\"True\", \"False\"] # The dropdown has the options True or False\n",
    "            ovar_x.set(str(opt_params[var_list[x]])) # Set the dropdown selection to the default value of the parameter\n",
    "\n",
    "            opt_widgets.append([var_label,tk.OptionMenu(opt_fram,ovar_x,*ovar_options),type(opt_params[var_list[x]]),ovar_x])\n",
    "            opt_widgets[x][1].config(width=drop_w,font=(\"Times\",15),bg=bgc) # Format the dropdown widget\n",
    "        else: # For any other variable input type, create an entry box and enter default value\n",
    "            opt_widgets.append([var_label,type(opt_params[var_list[x]]),tk.Entry(opt_fram,font=(\"Times\",15),highlightbackground=bgc,width=drop_w)])\n",
    "            opt_widgets[x][2].insert(0, str(opt_params[var_list[x]])) # Instert the default parameter value to the entry widget\n",
    "\n",
    "        opt_widgets[x][5-len(opt_widgets[x])].grid(row=x+1,column=1) # Put the newly created widget on the frame\n",
    "\n",
    "    opt_fram.grid(row=4,column=4,rowspan=len(var_list),padx=5,sticky=\"W\") # Display the optimization option frame on the GUI\n",
    "\n",
    "# Get differentiation option variables and update on advanced option panel\n",
    "def get_diff(command):\n",
    "    diff_param_def = []\n",
    "    class_name = get_od_class(\"diff\")\n",
    "\n",
    "    diff_params = list(eval(\"ps.\"+class_name+\".__init__.__code__.co_varnames\")) # Instantiate the differentiation option class and get inbuilt parameter names\n",
    "    if \"self\" in diff_params:\n",
    "        diff_params.remove(\"self\") # Remove self from the list of parameters\n",
    "\n",
    "    temp_params = eval(\"ps.\"+class_name+\".__init__.__defaults__\") # Get differentiation option inbuilt parameter default values\n",
    "    diff_param_def[:] = [((\"func \"+thing.__name__) if(callable(thing)) else thing) for thing in temp_params] # If the input type for a deafult value is a function, enter func at the start\n",
    "\n",
    "    disp_diff_select(diff_params, diff_param_def)\n",
    "\n",
    "# Display the differentiation option variables on GUI\n",
    "def disp_diff_select(diff_params, diff_param_def):\n",
    "    global diff_fram\n",
    "    global diff_widgets\n",
    "    diff_widgets = []\n",
    "    diff_fram.destroy() # Remove all current widgets in advanced option panel to repopulate with new selection variables\n",
    "\n",
    "    diff_fram = tk.Frame(window,bd=2,bg=bgc,width=5) # Rebuild the differentiation option frame\n",
    "\n",
    "    dfram_label = tk.Label(diff_fram,text=\"Differentiation Option Variables\",font=(\"Times\",18,\"bold\"),pady=10,bg=bgc)\n",
    "    dfram_label.grid(row=0,column=0,sticky=\"W\")\n",
    "\n",
    "    for x in range(len(diff_params)): # Create a widget for all inbuilt parameters\n",
    "        var_label = tk.Label(diff_fram,text=diff_params[x],font=(\"Times\",15,\"bold\"),pady=10,bg=bgc) # Label widget for all inbuilt parameters containing the parameter name\n",
    "        var_label.grid(row=x+1,column=0,sticky=\"E\")\n",
    "\n",
    "        if(x+1>len(diff_param_def)): # If there's an empty variable, create an empty entry box\n",
    "            diff_widgets.append([var_label,type(\"\"),tk.Entry(diff_fram,font=(\"Times\",15),highlightbackground=bgc,width=drop_w)])\n",
    "        elif str(diff_param_def[x]) == \"True\" or str(diff_param_def[x]) == \"False\": # Create dropdown for boolean variables\n",
    "            dvar_x = tk.StringVar(diff_fram) # The value of the inbuilt parameter\n",
    "            dvar_options = [\"True\", \"False\"] # The dropdown has the options True or False\n",
    "            dvar_x.set(str(diff_param_def[x])) # Set the dropdown selection to the default value of the parameter\n",
    "\n",
    "            diff_widgets.append([var_label,tk.OptionMenu(diff_fram,dvar_x,*dvar_options),type(diff_param_def[x]),dvar_x])\n",
    "            diff_widgets[x][1].config(width=drop_w,font=(\"Times\",15),bg=bgc) # Format the dropdown widget\n",
    "        else: # Create an entry box for any other variables and enter deafualt value\n",
    "            diff_widgets.append([var_label,type(diff_param_def[x]),tk.Entry(diff_fram,font=(\"Times\",15),highlightbackground=bgc,width=drop_w)])\n",
    "            diff_widgets[x][2].insert(0, diff_param_def[x]) # Instert the default parameter value to the entry widget\n",
    "\n",
    "        diff_widgets[x][5-len(diff_widgets[x])].grid(row=x+1,column=1) # Put the newly created widget on the frame\n",
    "\n",
    "    for y in range(len(diff_params)+1,4): # Fill in the rest of the frame with blank lines, the frame is 5 lines long (including the title)\n",
    "        blank = tk.Label(diff_fram,text=\" \",font=(\"Times\",15,\"bold\"),pady=10,bg=bgc)\n",
    "        blank.grid(row=y,column=0)\n",
    "    \n",
    "    diff_fram.grid(row=0,column=4,rowspan=4,padx=5,sticky=\"W\") # Display the differentiation option frame on the GUI\n",
    "\n",
    "# Instantiate the differentiator or optimizer\n",
    "def od_inst(widget_list, selection):\n",
    "    class_name = get_od_class(selection)\n",
    "\n",
    "    instance = \"ps.\"+class_name+\"(\" # Text string to instantiate after looping through populating with parameter values\n",
    "    count = 0\n",
    "\n",
    "    for widget in widget_list: # Form executable line in a string\n",
    "        value = None # Input value from GUI\n",
    "        try: # For option menu widgets\n",
    "            value = widget[3].get()\n",
    "        except Exception: # For entry widgets\n",
    "            value = widget[2].get()\n",
    "\n",
    "        if(str(widget[-2]) == \"<class 'str'>\" and not value.startswith(\"func\")): # For inbuilt parameters that are functions, func must be added before the name (savgol_filter)\n",
    "            value = \"\\\"\" + value + \"\\\"\"\n",
    "        elif(str(widget[-2]) == \"<class 'str'>\" and value.startswith(\"func\")):\n",
    "            value = value.split(' ', 1)[1]\n",
    "\n",
    "        var_name = widget[0].cget(\"text\") # Name of the inbuilt parameter, stored in the label widgets on the GUI\n",
    "\n",
    "        if(not value == \"\\\"\\\"\"): # Entry widgets for parameters with no inbuilt value store the value as \"\"\n",
    "            instance = instance + var_name + \"=\" + value\n",
    "            if(count+1<len(widget_list)):\n",
    "                instance = instance + \",\"\n",
    "        \n",
    "        count += 1\n",
    "\n",
    "    instance = instance + \")\"\n",
    "\n",
    "    inst = eval(instance) # Instantiate the line\n",
    "    return inst\n",
    "\n",
    "# Get feature library selection class name\n",
    "def get_feat_class():\n",
    "    feat = str(feat_var.get()) # Get the selected feature library option\n",
    "    fil = open(pysindypath+\"/feature_library/\"+feat+\".py\") # Open the selected option's code file\n",
    "\n",
    "    # Read the code file and return the name of the feature library class (Not the same as the name of the file)\n",
    "    contents = fil.read()\n",
    "    par = ast.parse(contents)\n",
    "    classes = [node.name for node in ast.walk(par) if isinstance(node, ast.ClassDef)]\n",
    "    return classes[0]\n",
    "\n",
    "# Instantiate the feature library\n",
    "def feat_inst():\n",
    "    class_name = get_feat_class() # Get the class name of the selected feature library\n",
    "    instance = \"ps.\"+class_name+\"()\" # Instantiate the selected feature library\n",
    "    inst = eval(instance)\n",
    "    return inst # Return the instance\n",
    "\n",
    "# Reset opt and diff advanced options to default values\n",
    "def reset():\n",
    "    get_opt(\"<command>\")\n",
    "    get_diff(\"<command>\")\n",
    "\n",
    "# Read selected file (from \"Example/Own Data\" dropdown) and return an array containing its data\n",
    "def read_file():\n",
    "    if(sel_var.get() == \"Own Data\"):\n",
    "        to_read = to_open      \n",
    "    else:\n",
    "        to_read = \"./data/\" + sel_var.get()\n",
    "\n",
    "    with open(to_read, newline='') as csvfile:\n",
    "        data = list(csv.reader(csvfile))  \n",
    "\n",
    "    return(data)\n",
    "\n",
    "# Create output window - containing coefficient value table, ouput equations and model score\n",
    "def show_output(table_size, coefs, feats, variable_names, window_name, score):\n",
    "    out_window = tk.Tk() # The new window\n",
    "    out_window.title(\"Model Output: \" + str(window_name))\n",
    "    out_window.config(bg=bgc)\n",
    "\n",
    "    # Create all output widgets\n",
    "    tv = create_table(out_window, table_size, variable_names) # Create the empty coefficient table\n",
    "    create_eq_box(out_window, coefs, feats, variable_names) # Create and populate the equation box\n",
    "    pop_table(tv, coefs, feats)    # Populate the coefficient table\n",
    "\n",
    "    score_label = tk.Label(out_window,text=\"Model Score: \"+str(score),font=(\"Times\",15),bg=bgc) # Create and display the ouput model score\n",
    "    score_label.grid(row=7,column=0,sticky=\"W\")\n",
    "\n",
    "    return out_window\n",
    "\n",
    "# Create output table\n",
    "def create_table(out_window, table_size, variable_names):\n",
    "    # Create frame for output values title & treeview table\n",
    "    fig1_fram = tk.Frame(out_window,bd=2,bg=bgc,width=5)\n",
    "\n",
    "    fig1_label = tk.Label(fig1_fram,text=\"Coefficient Values\",font=(\"Times\",18,\"bold\"),pady=10,bg=bgc)\n",
    "    fig1_label.grid(row=0,column=0,sticky=\"W\")\n",
    "\n",
    "    # Scrollbars to activate when the table is too large for the frame\n",
    "    y_scroll = tk.Scrollbar(fig1_fram)\n",
    "    y_scroll.grid(row=1,column=1,rowspan=4,sticky=\"nsew\")\n",
    "    x_scroll = tk.Scrollbar(fig1_fram,orient=tk.HORIZONTAL)\n",
    "    x_scroll.grid(row=2,column=0,columnspan=1,sticky=\"nsew\")\n",
    "\n",
    "    tv = ttk.Treeview(fig1_fram, xscrollcommand = x_scroll.set, yscrollcommand = y_scroll.set) # The table to contain the output coefficients\n",
    "    tv = resize_table(table_size, tv, fig1_fram, x_scroll, y_scroll, variable_names) # Make table the correct size (in terms of number of columns) for the output model\n",
    "\n",
    "    fig1_fram.grid(row=0,column=0,rowspan=3,columnspan=3,padx=5,sticky=\"NW\") # Add the empty table to the output window\n",
    "\n",
    "    return tv # Return the table object so that it can be populated with the output coefficients\n",
    "\n",
    "# Create scrollable box for output equations\n",
    "def create_eq_box(out_window, coefs, feats, variable_names):\n",
    "    # Create frame for a scrollable box for the output equations\n",
    "    fig3_fram = tk.Frame(out_window,bd=2,bg=bgc)\n",
    "\n",
    "    fig3_label = tk.Label(fig3_fram,text=\"Output Equations\",font=(\"Times\",18,\"bold\"),pady=10,bg=bgc)  \n",
    "    fig3_label.grid(row=0,column=0,sticky=\"NW\")\n",
    "\n",
    "    # Scrollbars to activate when the equations are too large for the text box \n",
    "    x_scroll = tk.Scrollbar(fig3_fram,orient=\"horizontal\")\n",
    "    x_scroll.grid(row=2,column=0,sticky=\"nsew\")\n",
    "    y_scroll = tk.Scrollbar(fig3_fram)\n",
    "    y_scroll.grid(row=1,column=3,rowspan=3,sticky=\"nsew\")\n",
    "\n",
    "    eq_text = tk.Text(fig3_fram,wrap=\"none\",xscrollcommand=x_scroll.set,yscrollcommand=y_scroll.set,font=(\"Times\",15),height=10,pady=10,bg=bgc)\n",
    "    eq_text.grid(row=1,column=0)\n",
    "\n",
    "    eqn_num = len(coefs) # Number of equations to display in the text box\n",
    "\n",
    "    for num in range(eqn_num): # Form each of the equations to print to the text box\n",
    "        eqn = coefs[num] # Coefficient values for the output equation\n",
    "        eqn = [round(float(item),3) for item in eqn] # Round each coefficient value to 3.d.p.\n",
    "        out = \"d\" + str(variable_names[num]) + \"/dt = \" # String used to built the output equation\n",
    "        for val in range(len(feats)):\n",
    "            coef = eqn[val]\n",
    "            desc = feats[val]\n",
    "            if(coef != 0):\n",
    "                if(float(coef) < 0): # If the next coefficient value is negative, don't add a \"+\" before it (e.g. x + -5y -> x -5y )\n",
    "                    out = out.rstrip(\"+ \") # Remove the previous \"+\" sign\n",
    "                    out = out + \" \"\n",
    "\n",
    "                out = out + str(coef) + \" \" # Add the next coefficient and descriptor to equation\n",
    "                if(desc == \"1\"): # Don't add the descriptor if it is equal to 1 (e.g. 0.364 1 + 7x -> 0.364 + 7x )\n",
    "                    out = out + \"+ \"\n",
    "                else: # Add the descriptor if it is not equal to 1\n",
    "                    out = out + str(desc) + \" + \"\n",
    "\n",
    "        out = out.rstrip(\"+ \") # Remove the trailing \"+\" sign after generating the equation\n",
    "        out = out + \"    \\n \\n\" # Add a blank line after each equaiton for readability\n",
    "        eq_text.insert(\"end\", out) # Insert the newly generated equation to the end of the output equation text box\n",
    "\n",
    "    eq_text.config(state=\"disabled\") # Disable the ability for the user to edit the output equations\n",
    "    x_scroll.config(command=eq_text.xview) # Add scrolling functionality to the scrollbars (link the x&y scrolling functions to each scrollbar respectively)\n",
    "    y_scroll.config(command=eq_text.yview)\n",
    "\n",
    "    fig3_fram.grid(row=3,column=0,rowspan=4,columnspan=3,padx=5,sticky=\"NW\") # Display the output equation text box\n",
    "\n",
    "# Resize the output table\n",
    "def resize_table(cols, tv, fig1_fram, x_scroll, y_scroll, variable_names):\n",
    "    tv = ttk.Treeview(fig1_fram, xscrollcommand = x_scroll.set, yscrollcommand = y_scroll.set) # Create the treeview table\n",
    "\n",
    "    # Create the correct number of columns (not including the descrptor column) to populate in the table depending on the number of variables in the system (cols contains this number)\n",
    "    tv['columns'] = ('col1',) # The first system variable\n",
    "    if(cols > 1): # More system variables if the number is greater than 1\n",
    "        for x in range(2, cols+1):\n",
    "            name = 'col' + str(x)\n",
    "            tv['columns'] = tv['columns']+(name,)\n",
    "\n",
    "    tv.heading(\"#0\", text='Descriptor', anchor='w') # This is the heading for the descriptor column\n",
    "\n",
    "    # The descriptor column in the table is set to the width of the table so that the scrolling functionality can work. It's a bit strange, but it's the only way I could get it to work.\n",
    "    if(cols<3): # If there are fewer than 3 system variables, the width is set so that the table is smaller than 4 columns\n",
    "        tv.column(\"#0\", anchor=\"w\", width=(cols+1)*col_width, minwidth=col_width, stretch=True) \n",
    "    else: # If there are more system variables, the width is only set to (4* the width of one column) so that more columns pushes the overall size outside of the viewable area\n",
    "        tv.column(\"#0\", anchor=\"w\", width=4*col_width, minwidth=col_width, stretch=True)\n",
    "\n",
    "    for x in range(cols): # Set the heading of each column\n",
    "        head = 'd' + str(variable_names[x]) + \"/dt\"\n",
    "        column = 'col' + str(x+1)\n",
    "        tv.heading(column,text=head)\n",
    "        tv.column(column, anchor='center', width=0, minwidth=col_width, stretch=True) # Format each column\n",
    "\n",
    "    tv.grid(row=1,column=0,columnspan=1) # Add the table to the frame\n",
    "\n",
    "    # Add scrolling functionality to the scrollbars (link the x&y scrolling functions to each scrollbar respectively)\n",
    "    y_scroll.config(command = tv.yview)\n",
    "    x_scroll.config(command = tv.xview)\n",
    "\n",
    "    fig1_fram.grid() # Display the frame on the GUI\n",
    "    return tv # Return the new table to pass to further functions\n",
    "\n",
    "# Populate the output table with coefficients\n",
    "def pop_table(tv, coefs, feats):\n",
    "    for item in range(len(coefs[0])): # \"coefs\" is a list of lists, each list containing the coefficient values for each output equation\n",
    "        new_val = [] # The values for each ROW of the output table\n",
    "        for col in range(len(coefs)):\n",
    "            new_val.append(str(coefs[col,item])) # Adding values to the ROW, one at a time\n",
    "        tv.insert('', 'end', text=str(feats[item]), values=new_val) # Add the row of values to the output table\n",
    "\n",
    "# Lorenz system for generation - This is taken from the PySINDy feature overview file\n",
    "def lorenz(z, t):\n",
    "    return [\n",
    "        10 * (z[1] - z[0]),\n",
    "        z[0] * (28 - z[2]) - z[1],\n",
    "        z[0] * z[1] - (8 / 3) * z[2]\n",
    "    ]\n",
    "\n",
    "# Pop up window for Lorenz generation\n",
    "def lorenz_gen():\n",
    "    dt,t_min,t_max,conds = show_lorenz() # Shows the Lorenz system generation popup window, returning the input values. By default the values are the same as the data generated in the PySINDy feature overview file\n",
    "    \n",
    "    # Convert the returned system values to the correct types\n",
    "    dt = float(dt) # The time step of the data readings\n",
    "    t_min = float(t_min) # The start time of the data readings\n",
    "    t_max = float(t_max) # The end time of the data readings\n",
    "    conds = list(conds.split(\",\")) # The initial conditions of the data - a.k.a the first data point\n",
    "\n",
    "    time_series = np.arange(t_min, t_max, dt) # Using the start and end times, and the time step, the time series can be created\n",
    "    contents = odeint(lorenz, conds, time_series) # Generate the data for the user defined Lorenz system\n",
    "    points_no = ceil((t_max-t_min)/dt) # Find the number of generated data points\n",
    "    return contents, dt, points_no, time_series\n",
    "\n",
    "# Create Lorenz generation window\n",
    "def show_lorenz():\n",
    "    lorenz_window = tk.Tk() # Create the Lorenz generation popup window\n",
    "    lorenz_window.title(\"Lorenz Data Generation\")\n",
    "    lorenz_window.config(bg=bgc)\n",
    "\n",
    "    # Create widgets for dt input\n",
    "    dt_label = tk.Label(lorenz_window,text=\"dt\",font=(\"Times\",15,\"bold\"),bg=bgc)\n",
    "    dt_label.grid(row=0,column=0,sticky=\"E\")\n",
    "    dt_entry = tk.Entry(lorenz_window,font=(\"Times\",15),highlightbackground=bgc,width=10)\n",
    "    dt_entry.grid(row=0,column=1,columnspan=2,sticky=\"EW\")\n",
    "    dt_entry.insert(0,\"0.002\")\n",
    "    \n",
    "    # Create widgets for start and end times\n",
    "    time_label = tk.Label(lorenz_window,text=\"Times\",font=(\"Times\",15,\"bold\"),bg=bgc)\n",
    "    time_label.grid(row=1,column=0,sticky=\"E\")\n",
    "    time_entry1 = tk.Entry(lorenz_window,font=(\"Times\",15),highlightbackground=bgc,width=5)\n",
    "    time_entry1.grid(row=1,column=1)\n",
    "    time_entry1.insert(0,\"0\")\n",
    "    time_entry2 = tk.Entry(lorenz_window,font=(\"Times\",15),highlightbackground=bgc,width=5)\n",
    "    time_entry2.grid(row=1,column=2)\n",
    "    time_entry2.insert(0,\"10\")\n",
    "\n",
    "    # Create widgets for the initial conditions\n",
    "    conds_label = tk.Label(lorenz_window,text=\"Initial Conditions x,y,z\",font=(\"Times\",15,\"bold\"),bg=bgc)\n",
    "    conds_label.grid(row=2,column=0,sticky=\"E\")\n",
    "    conds_entry = tk.Entry(lorenz_window,font=(\"Times\",15),highlightbackground=bgc,width=10)\n",
    "    conds_entry.grid(row=2,column=1,columnspan=2,sticky=\"EW\")\n",
    "    conds_entry.insert(0,\"-8,8,27\")\n",
    "\n",
    "    # Create widgets to display the number of generated points\n",
    "    number = ceil((float(time_entry2.get())-float(time_entry1.get()))/float(dt_entry.get()))\n",
    "    points_label = tk.Label(lorenz_window,text=\"Number of Points: \" + str(number),font=(\"Times\",15,\"bold\"),bg=bgc)\n",
    "    points_label.grid(row=3,column=0,columnspan=2,sticky=\"W\")\n",
    "\n",
    "    # Create the button that continues onto generating the system from the input conditions\n",
    "    cont_button = tk.Button(lorenz_window,text=\"Continue\",font=(\"Times\",15),width=10,highlightbackground=bgc,command=lambda: lorenz_window.quit())\n",
    "    cont_button.grid(row=3,column=2,sticky=\"EW\")\n",
    "\n",
    "    # Bind any key press (within the popup window) with updating the number of generated points\n",
    "    lorenz_window.bind('<Key>', lambda event: update_number(event, dt_entry, time_entry1, time_entry2, points_label))\n",
    "    lorenz_window.mainloop()\n",
    "\n",
    "    # Before destroying the popup window, grab the input conditions\n",
    "    dt = dt_entry.get()\n",
    "    t_min = time_entry1.get()\n",
    "    t_max = time_entry2.get()\n",
    "    conds = conds_entry.get()\n",
    "\n",
    "    lorenz_window.destroy() # Destroy the window\n",
    "\n",
    "    return dt, t_min, t_max, conds\n",
    "\n",
    "# Update number of points display on generate Lorenz window\n",
    "def update_number(event, dt_entry, time_entry1, time_entry2, points_label):\n",
    "    try: \n",
    "        number = (float(time_entry2.get())-float(time_entry1.get()))/float(dt_entry.get()) # Calculate the number of points based on the input values\n",
    "        points_label.configure(text = \"Number of Points: \" + str(ceil(number)))\n",
    "    except ZeroDivisionError: # If one of the numbers is equal to 0\n",
    "        points_label.configure(text = \"Number of Points: \")\n",
    "    except ValueError: # If one of the input values are non numeric\n",
    "        points_label.configure(text = \"Number of Points: \")\n",
    "    except Exception as e: # Any other exception. This shouldn't happen\n",
    "        print(\"Error!\\n\" + str(e))\n",
    "\n",
    "# Display the figure with the original data vs obtained model\n",
    "def show_plots(contents, sim_data, coefs, feats, time_series, variable_names, window_name):\n",
    "    # Create plot window\n",
    "    plot_window = tk.Tk()\n",
    "    plot_window.title(\"Model Plots: \" + str(window_name))\n",
    "    plot_window.maxsize(fig_w, fig_h)\n",
    "\n",
    "    # This is here so that resizing the window doesn't resize the plot\n",
    "    plot_window.rowconfigure(1, weight=1)\n",
    "    plot_window.columnconfigure(1, weight=1)\n",
    "\n",
    "    # Create the frame for the plot and scrollbars\n",
    "    canvas_frame = tk.Frame(plot_window)\n",
    "    canvas_frame.grid(column=1, row=1, sticky=tk.constants.NSEW)\n",
    "    canvas_frame.rowconfigure(1, weight=1)\n",
    "    canvas_frame.columnconfigure(1, weight=1)\n",
    "\n",
    "    # Create a figure with the correct number of subplots\n",
    "    fig, axs = plt.subplots(contents.shape[1], 2, sharex=False, sharey=False, figsize=(11, 2*len(variable_names)))\n",
    "\n",
    "    # Plot the data on the subplots\n",
    "    for i in range(contents.shape[1]): # For every row of subplots\n",
    "        if(len(variable_names) == 1): # This is needed to enable the plotting of one dimensional systems\n",
    "            dim = (1)\n",
    "        else:\n",
    "            dim = (i, 1)\n",
    "\n",
    "        # Plot the input data and the forward simulated data obtained after creating the model\n",
    "        axs[dim].plot(time_series, contents[:, i], 'k', label='input data')\n",
    "        axs[dim].plot(time_series, sim_data[:, i], 'r--', label='model simulation')\n",
    "        if(i == 0):\n",
    "            axs[dim].legend()\n",
    "        axs[dim].set(xlabel='t', ylabel=variable_names[i].format(i))\n",
    "\n",
    "        # Loop through the coefficient matrix to extract the non zero values\n",
    "        coef_plt = [] # List of non zero coefficients (coefficient values)\n",
    "        desc_plt = [] # List of descriptors for the non zero variables\n",
    "        row = coefs[i]\n",
    "        for item in range(len(coefs[0])):\n",
    "            val = row[item]\n",
    "            des = feats[item]\n",
    "            if val != 0:\n",
    "                coef_plt.append(val)\n",
    "                desc_plt.append(des)\n",
    "\n",
    "        if(len(variable_names) == 1): # This is needed to enable the plotting of one dimensional systems\n",
    "            dim = (0)\n",
    "        else:\n",
    "            dim = (i, 0)\n",
    "\n",
    "        # Plot the non zero coefficient values as a bar plot\n",
    "        axs[dim].bar(desc_plt,coef_plt)\n",
    "        axs[dim].axhline(y=0, color='k')\n",
    "        axs[dim].set_title(\"d\" + str(variable_names[i]) + \"/dt\",size=10)\n",
    "\n",
    "        # If the number of output coefficients is greater than 6, change the font size to 8\n",
    "        if len(coef_plt) > 6:\n",
    "            size = 8\n",
    "        else:\n",
    "            size = 10\n",
    "        plot_label = axs[dim].get_xticklabels() # Get all of the font label objects for the subplot\n",
    "        [each_label.set_fontsize(size) for each_label in plot_label] # Set the font size of the specific subplot\n",
    "\n",
    "    fig.subplots_adjust(hspace=0.3) # Add vertical space in between each row of subplots so they don't overlap\n",
    "    fig.tight_layout() # Remove excess whitespace from the top and bottom of the figure\n",
    "\n",
    "    # set up a canvas with scrollbars\n",
    "    canvas = tk.Canvas(canvas_frame)\n",
    "    canvas.grid(row=1, column=1, sticky=tk.constants.NSEW)\n",
    "\n",
    "    xScrollbar = tk.Scrollbar(canvas_frame, orient=tk.constants.HORIZONTAL)\n",
    "    yScrollbar = tk.Scrollbar(canvas_frame)\n",
    "\n",
    "    xScrollbar.grid(row=2, column=1, sticky=tk.constants.EW)\n",
    "    yScrollbar.grid(row=1, column=2, sticky=tk.constants.NS)\n",
    "\n",
    "    # Add the commands to allow scrolling\n",
    "    canvas.config(xscrollcommand=xScrollbar.set)\n",
    "    xScrollbar.config(command=canvas.xview)\n",
    "    canvas.config(yscrollcommand=yScrollbar.set)\n",
    "    yScrollbar.config(command=canvas.yview)\n",
    "\n",
    "    # Plug the figure into the canvas\n",
    "    figAgg = FigureCanvasTkAgg(fig, canvas)\n",
    "    mplCanvas = figAgg.get_tk_widget()\n",
    "\n",
    "    # Connect figure with scrolling region\n",
    "    cwid = canvas.create_window(0, 0, window=mplCanvas, anchor=tk.constants.NW)\n",
    "    canvas.config(scrollregion=canvas.bbox(tk.constants.ALL),width=fig_w,height=fig_h)\n",
    "\n",
    "    # Add in the toolbar to the output window\n",
    "    toolbar_frame = tk.Frame(plot_window)\n",
    "    toolbar = NavigationToolbar2Tk(figAgg, toolbar_frame)\n",
    "    toolbar.children['!button5'].config(command=lambda: save_output(fig, coefs, feats, variable_names))\n",
    "    toolbar_frame.grid(row=0, column=1)\n",
    "\n",
    "    return plot_window\n",
    "\n",
    "# Save the output figure & coefficient matrix to file\n",
    "def save_output(fig, coefs, feats, variable_names):\n",
    "    save_filepath = fd.asksaveasfilename() # The file browser popup that return the filepath the user would like to save to\n",
    "\n",
    "    # Exit the saving code if the user cancels the save or doesn't give the file a name\n",
    "    if(save_filepath == \"\"):\n",
    "        return None\n",
    "\n",
    "    fig.savefig(save_filepath) # Save the figure as a .png\n",
    "\n",
    "    total = np.append([feats], coefs, axis=0) # Adds the descriptors to the output coefficient matrix\n",
    "    total = np.transpose(total) # Obtain the transpose of the total matrix to output as expected\n",
    "\n",
    "    head = [(\"d \"+variable_names[i]+\"/dt\") for i in range(len(variable_names))] # The derivative of each system variable\n",
    "    head.insert(0,'') # Add a blank value to the start so that the columns of the coefficent matrix line up with the correct derivative\n",
    "\n",
    "    pd.DataFrame(total).to_csv(save_filepath + \".csv\", header=head, index=None) # Use pandas to save the matrix to a .csv file with the same filepath as above\n",
    "\n",
    "# Run the main computation\n",
    "def comp():\n",
    "    window_name = sel_var.get() # Obtain the name of the data file to use as the output window name\n",
    "\n",
    "    # Stop the computation if \"Own Data\" is selected and no file has been selected\n",
    "    if((to_open.split('/')[-1] == \"\" or to_open.split('/')[-1] == \" \") and sel_var.get() == \"Own Data\"):\n",
    "        messagebox.showerror(title=\"Select File\", message=\"You need to select a file to compute!\")\n",
    "        return None\n",
    "\n",
    "    # Try to instantiate the optimizer with the advanced variables. Stop the computation if an invalid variable is input (will throw an error when instantiating)\n",
    "    try:\n",
    "        opt = od_inst(opt_widgets,\"opt\")\n",
    "    except Exception:\n",
    "        messagebox.showerror(title=\"Invalid Option\", message=\"You have input an invalid optimization variable, check the PySINDy documentation for valid options.\\n\\nExiting the computation.\")\n",
    "        return None\n",
    "\n",
    "    # Try to instantiate the differentiator with the advanced variables. Stop the computation if an invalid variable is input (will throw an error when instantiating)\n",
    "    try:\n",
    "        diff = od_inst(diff_widgets,\"diff\")\n",
    "    except Exception:\n",
    "        messagebox.showerror(title=\"Invalid Option\", message=\"You have input an invalid differentation variable, check the PySINDy documentation for valid options.\\n\\nExiting the computation.\")\n",
    "        return None\n",
    "\n",
    "    # Instatiate the feature library\n",
    "    feat = feat_inst()\n",
    "\n",
    "    # If \"Generate Lorenz System\" is selected, show the Lorenz popup window and generate with the input conditions. Stop the computation if an invalid condition is input\n",
    "    if(window_name == \"Generate Lorenz System\"):\n",
    "        try:\n",
    "            contents, dt, points_no, time_series = lorenz_gen()\n",
    "            window_name = window_name + \", Number of points: \" + str(points_no)\n",
    "        except Exception:\n",
    "            messagebox.showerror(title=\"Invalid Condition\", message=\"You have input an invalid condition. \\n\\nExiting the data generation.\")\n",
    "            return None\n",
    "\n",
    "        variable_names = [\"x\",\"y\",\"z\"] # Default system variable names if \"Generate Lorenz System\" is selected\n",
    "    elif(window_name.endswith(\".csv\") or ((window_name == \"Own Data\") and to_open.endswith(\".csv\"))):\n",
    "        data = read_file() # Obtain the data in the selected .csv file. This is a list of lists\n",
    "        contents = data\n",
    "    \n",
    "        # Separate the input file into data points, time series and variable names\n",
    "        variable_names = contents[0][1:] # Obtain the system variable names from the data\n",
    "        del contents[0] # Remove the system variable names from the data matrix\n",
    "        time_series = [val[0] for val in contents] # From the first column of the data file, obtain the time series data for the data\n",
    "        dt = float(time_series[1])-float(time_series[0]) # From the time series data, obtain dt\n",
    "\n",
    "        contents = [val[1:] for val in contents] # Remove the time series data from the data matrix\n",
    "        contents = np.array([[float(val) for val in item] for item in contents]) # Turn the list of lists into a numpy array as this is what the PySINDy model expects as an input\n",
    "    else: # If the selected file isn't a .csv file, stop the computation\n",
    "        messagebox.showerror(title=\"Invalid File Type\", message=\"The selected file needs to be a .csv file in the correct format. Read to tutorial for more information.\\n\\nExiting the computation.\")\n",
    "        return None\n",
    "\n",
    "    model = ps.SINDy(optimizer=opt,differentiation_method=diff,feature_library=feat,feature_names=variable_names) # Instantiate the model with the previously obtained instances and variable names\n",
    "    model.fit(contents, t=dt) # Fit the input data to the model\n",
    "    coefs = model.coefficients() # Obtain the coefficient matrix from the obtained model\n",
    "    feats = model.get_feature_names() # Get the feature names from the obtained model\n",
    "\n",
    "    time_series = np.array([float(val) for val in time_series]) # Create a numpy array with the time series data stored as floats\n",
    "    \n",
    "    score = model.score(contents, t=time_series) # Obtain the model score for the system\n",
    "\n",
    "    conds = np.array([float(val) for val in contents[0]]) # Convert the system's initial conditions into a numpy array of float values as this is what is expected by the model.simulate() function\n",
    "    sim_data = model.simulate(conds,time_series) # Create the forward simulated data. This uses the original initial conditions evolved with the model output equations to obtain new data\n",
    "    plot_window = show_plots(contents, sim_data, coefs, feats, time_series, variable_names, window_name) # Show the output plots\n",
    "\n",
    "    table_size = len(contents[0]) # Obtain the number of system variables, used to define the number of columns in the output table\n",
    "    out_window = show_output(table_size, coefs, feats, variable_names, window_name, score) # Show the output coefficient and equation window\n",
    "\n",
    "    out_window.mainloop()\n",
    "    plot_window.mainloop()\n",
    "\n",
    "# GUI design\n",
    "\n",
    "bgc = \"lightgray\" # GUI background colour\n",
    "\n",
    "# Size Correction based on operating system\n",
    "if platform == \"darwin\": # MacOS\n",
    "    print(\"MacOS detected\")\n",
    "    min_w = 520 # Minimum main window width\n",
    "    max_w = 1200 # Maximum main window width\n",
    "    min_h = 590 # Minimum main window height\n",
    "    max_h = 680 # Maximum main window height\n",
    "    drop_w = 30 # Width of the dropdown widgets on the main window\n",
    "    fram_w = 62 # Width of the frames on the main window (for the button frame)\n",
    "    line_w = 61 # Width of the blank lines on the button frame\n",
    "    col_width = 160 # Width of the columns in the output table\n",
    "    fig_w = 1115 # Width of the output figure\n",
    "    fig_h = 645 # height of the output figure\n",
    "    adv_size = \"1050x610\" # Size of the window when the advanced options are shown\n",
    "else:\n",
    "    print(platform + \" detected\")\n",
    "    min_w = 690\n",
    "    max_w = 1500\n",
    "    min_h = 650\n",
    "    max_h =800\n",
    "    drop_w = 30\n",
    "    fram_w = 55\n",
    "    line_w = 60\n",
    "    col_width = 200\n",
    "    fig_w = 1115\n",
    "    fig_h = 645\n",
    "    adv_size = \"1380x700\"\n",
    "\n",
    "# Create the main GUI window\n",
    "window = tk.Tk()\n",
    "window.title(\"Extracting Equations from Data\")\n",
    "window.minsize(min_w,min_h)\n",
    "window.maxsize(max_w,max_h)\n",
    "window.config(bg=bgc)\n",
    "\n",
    "# Add Durham University logo to GUI\n",
    "if (not os.environ.get('PYTHONHTTPSVERIFY', '') and getattr(ssl, '_create_unverified_context', None)): # This is needed to validate the server identity for the pictuer URL\n",
    "    ssl._create_default_https_context = ssl._create_unverified_context\n",
    "\n",
    "try:\n",
    "    pic_url = \"https://github.com/M-Vause/SEED2.0/blob/master/images/DurhamUniversityMasterLogo_RGB.png?raw=true\" # URL for the Durham University logo\n",
    "    my_page = urlopen(pic_url)\n",
    "    my_picture = io.BytesIO(my_page.read())\n",
    "    pil_img = Image.open(my_picture)\n",
    "    newsize = (167, 69) # The size of the logo on the GUI\n",
    "    pil_img = pil_img.resize(newsize)\n",
    "\n",
    "    tk_img = ImageTk.PhotoImage(pil_img)\n",
    "    label = tk.Label(window, image=tk_img, bg=bgc) # Add the image to a label widget to display on the GUI\n",
    "    label.grid(row=0,column=0,padx=5, pady=5,rowspan=2)\n",
    "except Exception: # If anything goes wrong, don't display the logo, probably internet connection error\n",
    "    print(\"Durham University Logo Not Printing\")\n",
    "\n",
    "# Add main title to the GUI\n",
    "main_label1 = tk.Label(window,text=\"Extracting Equations\",font=(\"Times\",30,\"bold\",\"underline\"),padx=5,pady=10,bg=bgc)\n",
    "main_label1.grid(row=0,column=1,columnspan=3,sticky=\"S\")\n",
    "\n",
    "main_label2 = tk.Label(window,text=\"from Data\",font=(\"Times\",30,\"bold\",\"underline\"),padx=5,pady=10,bg=bgc)\n",
    "main_label2.grid(row=1,column=1,columnspan=3,sticky=\"N\")\n",
    "\n",
    "# Creating the label and dropdown for data selection\n",
    "select_label = tk.Label(window,text=\"Example/Own Data:\",font=(\"Times\",15,\"bold\"),pady=10,bg=bgc)\n",
    "select_label.grid(row=2,column=0,sticky=\"E\")\n",
    "\n",
    "sel_var = tk.StringVar(window) # Variable storing the selected value in the dropdown\n",
    "sel_options = non_hidden(\"./data\")\n",
    "if \"__pycache__\" in sel_options: # Remove \"__pycache__\" from the options to display in the dropdown\n",
    "    sel_options.remove(\"__pycache__\")\n",
    "sel_options.sort()\n",
    "sel_options.append(\"Generate Lorenz System\") # Add this option to the dropdown options\n",
    "sel_options.append(\"Own Data\") # Add this option to the dropdown options\n",
    "sel_var.set(\"data_Lorenz3d.csv\") # Set the deafualt selected value for the data dropdown\n",
    "\n",
    "    # Create, configure and display the data selection dropdown on the GUI\n",
    "select_menu = tk.OptionMenu(window,sel_var,*sel_options,command=toggle_browser)\n",
    "select_menu.config(width=drop_w,font=(\"Times\",15),bg=bgc)\n",
    "select_menu.grid(row=2,column=1,columnspan=3,sticky=\"nsew\")\n",
    "\n",
    "# All file browser widgets\n",
    "file_button = tk.Button(window,text=\"Select File\",font=(\"Times\",15),width=15,highlightbackground=bgc,command=browse)\n",
    "file_button.grid(row=3,column=0,sticky=\"E\")\n",
    "\n",
    "file_label = tk.Label(window,text=\" \",font=(\"Times\",15),pady=10,bg=bgc)\n",
    "file_label.grid(row=3,column=1,columnspan=3,sticky=\"W\")\n",
    "\n",
    "toggle_browser(\"<command>\") # Called to initially hide the browser widgets as \"data_Lorenz3d.csv\" is selected by default\n",
    "\n",
    "# All optimization option widgets\n",
    "opt_label = tk.Label(window,text=\"Optimization Option:\",font=(\"Times\",15,\"bold\"),pady=10,bg=bgc)\n",
    "opt_label.grid(row=5,column=0,sticky=\"E\")\n",
    "\n",
    "opt_var = tk.StringVar(window) # Variable storing the selected value in the dropdown\n",
    "temp_options = non_hidden(pysindypath+\"/optimizers\") # Get a list of the optimizer file names from the PySINDy source files\n",
    "    # Remove the files that aren't optimizer options\n",
    "if \"__pycache__\" in temp_options:\n",
    "    temp_options.remove(\"__pycache__\")\n",
    "if \"__init__.py\" in temp_options:\n",
    "    temp_options.remove(\"__init__.py\")\n",
    "if \"base.py\" in temp_options:\n",
    "    temp_options.remove(\"base.py\")\n",
    "if \"sindy_optimizer.py\" in temp_options:\n",
    "    temp_options.remove(\"sindy_optimizer.py\")\n",
    "#temp_options.append(\"Lasso\") # This would be where more options are added if required, e.g. the Lasso method\n",
    "ext = \".py\"\n",
    "opt_options = [eg.split(ext, 1)[0] for eg in temp_options] # Remove the extension from all of the remaining options\n",
    "opt_options.sort()\n",
    "opt_var.set(\"stlsq\") # Set the default value for the optimization option\n",
    "temp_options.clear()\n",
    "\n",
    "    # Create, configure and display the optimization option dropdown on the GUI\n",
    "opt_menu = tk.OptionMenu(window,opt_var,*opt_options,command=get_opt)\n",
    "opt_menu.config(width=drop_w,font=(\"Times\",15),bg=bgc)\n",
    "opt_menu.grid(row=5,column=1,columnspan=3,sticky=\"nsew\")\n",
    "\n",
    "# All differentiation option widgets\n",
    "diff_label = tk.Label(window,text=\"Differentiation Option:\",font=(\"Times\",15,\"bold\"),pady=10,bg=bgc)\n",
    "diff_label.grid(row=4,column=0,sticky=\"E\")\n",
    "\n",
    "diff_var = tk.StringVar(window) # Variable storing the selected value in the dropdown\n",
    "temp_options = non_hidden(pysindypath+\"/differentiation\") # Get a list of the differentiator file names from the PySINDy source files\n",
    "    # Remove the files that aren't differentiator options\n",
    "if \"__pycache__\" in temp_options:\n",
    "    temp_options.remove(\"__pycache__\")\n",
    "if \"__init__.py\" in temp_options:\n",
    "    temp_options.remove(\"__init__.py\")\n",
    "if \"base.py\" in temp_options:\n",
    "    temp_options.remove(\"base.py\")\n",
    "if \"sindy_derivative.py\" in temp_options: # This came in a PySINDy update at the end of the project, support for this options needs to be added\n",
    "    temp_options.remove(\"sindy_derivative.py\")\n",
    "ext = \".py\"\n",
    "diff_options = [eg.split(ext, 1)[0] for eg in temp_options] # Remove the extension from all of the remaining options\n",
    "diff_options.sort()\n",
    "#diff_options.append(\"pre-computed\") # This would be where more options are added if required, e.g. pre-computed derivatives\n",
    "diff_var.set(\"finite_difference\") # Set the default value for the differentiation option\n",
    "temp_options.clear()\n",
    "\n",
    "    # Create, configure and display the differentiation option dropdown on the GUI\n",
    "diff_menu = tk.OptionMenu(window,diff_var,*diff_options,command=get_diff)\n",
    "diff_menu.config(width=drop_w,font=(\"Times\",15),bg=bgc)\n",
    "diff_menu.grid(row=4,column=1,columnspan=3,sticky=\"nsew\")\n",
    "\n",
    "# All feature library widgets\n",
    "feat_label = tk.Label(window,text=\"Feature Library Option:\",font=(\"Times\",15,\"bold\"),pady=10,bg=bgc)\n",
    "feat_label.grid(row=6,column=0,sticky=\"E\")\n",
    "\n",
    "feat_var = tk.StringVar(window) # Variable storing the selected value in the dropdown\n",
    "temp_options = non_hidden(pysindypath+\"/feature_library\") # Get a list of the feature library file names from the PySINDy source files\n",
    "    # Remove the files that aren't feature library options\n",
    "if \"__pycache__\" in temp_options:\n",
    "    temp_options.remove(\"__pycache__\")\n",
    "if \"__init__.py\" in temp_options:\n",
    "    temp_options.remove(\"__init__.py\")\n",
    "if \"custom_library.py\" in temp_options:\n",
    "    temp_options.remove(\"custom_library.py\")\n",
    "if \"feature_library.py\" in temp_options:\n",
    "    temp_options.remove(\"feature_library.py\")\n",
    "ext = \".py\"\n",
    "feat_options = [eg.split(ext, 1)[0] for eg in temp_options] # Remove the extension from all of the remaining options\n",
    "feat_options.sort()\n",
    "feat_var.set(\"polynomial_library\") # Set the default value for the differentiation option\n",
    "temp_options.clear()\n",
    "\n",
    "    # Create, configure and display the feature library option dropdown on the GUI\n",
    "feat_menu = tk.OptionMenu(window,feat_var,*feat_options)\n",
    "feat_menu.config(width=drop_w,font=(\"Times\",15),bg=bgc)\n",
    "feat_menu.grid(row=6,column=1,columnspan=3,sticky=\"nsew\")\n",
    "\n",
    "# Add frame for all buttons on the GUI\n",
    "button_fram = tk.Frame(window,bg=bgc,bd=2,relief=\"sunken\",pady=10,width=fram_w)\n",
    "\n",
    "    # Tutorial button\n",
    "tut_button = tk.Button(button_fram,text=\"Tutorial\",font=(\"Times\",15,\"bold\"),width=15,highlightbackground=bgc,command=lambda : webbrowser.open(\"https://github.com/M-Vause/SEED2.0\"))\n",
    "tut_button.grid(row=0,column=0,columnspan=2,sticky=\"EW\")\n",
    "\n",
    "    # Show advanced options button\n",
    "adv_button = tk.Button(button_fram,text=\"Show Advanced\",font=(\"Times\",15,\"bold\"),width=15,highlightbackground=bgc,command=advanced)\n",
    "adv_button.grid(row=0,column=2,columnspan=2,sticky=\"EW\")\n",
    "\n",
    "    # Blank line in the frame\n",
    "blank_line1 = tk.Label(button_fram,text=\" \",font=(\"Times\",15),width=round(line_w/2),highlightbackground=bgc,bg=bgc)\n",
    "blank_line1.grid(row=1,column=0,columnspan=2)\n",
    "\n",
    "    # Reset advanced options button\n",
    "reset_button = tk.Button(button_fram,text=\"Reset to Defaults\",font=(\"Times\",15,\"bold\"),width=15,highlightbackground=bgc,command=reset)\n",
    "reset_button.grid(row=1,column=2,columnspan=2,sticky=\"EW\")\n",
    "\n",
    "    # Blank line in the frame\n",
    "blank_line2 = tk.Label(button_fram,text=\" \",font=(\"Times\",15),width=line_w,highlightbackground=bgc,bg=bgc)\n",
    "blank_line2.grid(row=2,column=0,columnspan=4)\n",
    "\n",
    "    # Compute button\n",
    "comp_button = tk.Button(button_fram,text=\"Compute\",font=(\"Times\",15,\"bold\"),width=10,highlightbackground=bgc,command=comp)\n",
    "comp_button.grid(row=3,column=0,columnspan=4,sticky=\"EW\")\n",
    "\n",
    "button_fram.grid(row=7,column=0,columnspan=4,padx=5,sticky=\"SEW\") # Display the frame on the GUI - ,rowspan=4\n",
    "\n",
    "# Frame for optimization option variable selection (advanced options)\n",
    "opt_fram = tk.Frame(window,bd=2,bg=bgc,width=5)\n",
    "get_opt(\"<command>\")\n",
    "\n",
    "# Frame for differentitation option variable selection (advanced options)\n",
    "diff_fram = tk.Frame(window,bd=2,bg=bgc,width=5)\n",
    "get_diff(\"<command>\")\n",
    "\n",
    "# Resize the main GUI window\n",
    "size = str(min_w) + \"x\" + str(min_h)\n",
    "window.geometry(size)\n",
    "\n",
    "# Enter mainloop\n",
    "window.protocol(\"WM_DELETE_WINDOW\", on_closing)\n",
    "window.mainloop()"
   ]
  },
  {
   "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.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}