GUI_dev.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "import tkinter as tk\n",
    "import _pickle as pickle\n",
    "\n",
    "from matplotlib.backends.backend_tkagg import (\n",
    "    FigureCanvasTkAgg, NavigationToolbar2Tk)\n",
    "# Implement the default Matplotlib key bindings.\n",
    "from matplotlib.backend_bases import key_press_handler\n",
    "from matplotlib.figure import Figure\n",
    "\n",
    "import matplotlib.animation as animation\n",
    "\n",
    "import copy\n",
    "import importlib\n",
    "import inspect\n",
    "import math\n",
    "import multiprocessing\n",
    "import networkx as nx\n",
    "import numpy as np\n",
    "import os\n",
    "from pathlib import Path\n",
    "import pickle\n",
    "import sys\n",
    "import time\n",
    "import traceback\n",
    "\n",
    "\n",
    "import CDTtools # a package that contains, among other things, dyn_core_tools.py\n",
    "import custom_functions # a package that handles the various custom functions used for torque specification\n",
    "\n",
    "toplevel_path = os.path.dirname(os.path.realpath('__file__'))\n",
    "\n",
    "class CDT_GUI:\n",
    "    def __init__(self, master):\n",
    "        open('logfile', 'w').close() # wipe log file\n",
    "        self.cpr, self.cps = multiprocessing.Pipe(duplex=False) # one-way pipe from solver process to parent\n",
    "        # cpr is the receiving end\n",
    "        self.rp = 4 # number of digits after decimal in rounded values\n",
    "        self.cspcalls = 0\n",
    "        self.solver_runningB = tk.BooleanVar() # is a solver currently running? \n",
    "        self.solver_runningB.set(False) \n",
    "        self.solver_runningB.trace_add(\"write\", self._solver_state_change)\n",
    "        # needs to be set before adding the trace, else the state change callback tries to disable\n",
    "        # a button that doesn't yet exist\n",
    "        self.prev_solve_type = None # needed by postproc and solver diagnostics to tell what kind\n",
    "        # of run the self.sol object came from, as the user may have changed simTypeVar since the \n",
    "        # previous run\n",
    "        \n",
    "        self.master = master\n",
    "        master.title(\"Catapult Design Tool\")\n",
    "#         master.geometry(\"1470x900\")\n",
    "        tk.Tk.report_callback_exception = self.show_error # turns off the default \"silent failure mode\"...\n",
    "        self.back = tk.Frame(master=self.master)\n",
    "#         self.back.pack_propagate(0) #Don't allow the widgets inside to determine the frame's width / height\n",
    "        self.back.pack(fill=tk.BOTH, expand=1) #Expand the frame to fill the root window\n",
    "        \n",
    "        # PLOT WINDOW 1\n",
    "\n",
    "        self.fig1 = Figure(figsize=(5, 4), dpi=100, tight_layout=True)\n",
    "        t = np.arange(0, 3, .01)\n",
    "        self.ax1 = self.fig1.add_subplot(111)\n",
    "        self.ax1.plot(t, 2*np.sin(2*np.pi*t))\n",
    "        \n",
    "        self.plotFrame1 = tk.Frame(master=self.back)\n",
    "        self.plotFrame1.grid(row=2, column=0, rowspan=2)\n",
    "        self.canvas1 = FigureCanvasTkAgg(self.fig1, master=self.plotFrame1)  # A tk.DrawingArea.\n",
    "        self.canvas1.draw()\n",
    "        self.canvas1.get_tk_widget().pack()\n",
    "        self.toolbar1 = NavigationToolbar2Tk(self.canvas1, self.plotFrame1)\n",
    "        self.toolbar1.update()\n",
    "        \n",
    "        self.p1_conditional_controls = tk.Frame(master=self.plotFrame1)\n",
    "        self.p1_conditional_controls.pack() # stuff like the play button for the animation\n",
    "        # navigation toolbars use pack() internally, so you can't place them with grid\n",
    "        # so you create a frame that's a child of the main frame, position the *child frame* using grid, \n",
    "        # and the toolbar packs itself within that frame...\n",
    "        \n",
    "        tk.Label(master=self.plotFrame1, text=\"Plot Type\").pack()\n",
    "        self.p1TypeVar = tk.StringVar()\n",
    "        self.p1TypeVar.trace_add(\"write\", self._change_p1)\n",
    "        self.p1types = ['animation', 'arm load', 'projectile path', \n",
    "                       'efficiency', 'puller potential energy', 'axle reaction load']\n",
    "        self.prevP1Type = None # necessary because destroy doesn't properly destroy all widgets in p1 cond frame\n",
    "        self.p1TypeVar.set(self.p1types[0])\n",
    "        self.p1TypeMenu = tk.OptionMenu(self.plotFrame1, self.p1TypeVar, *self.p1types)\n",
    "        self.p1TypeMenu.pack()\n",
    "        # PLOT WINDOW 1\n",
    "        \n",
    "        # PLOT WINDOW 2\n",
    "        self.fig2 = Figure(figsize=(5, 4), dpi=100, tight_layout=True)\n",
    "        self.ax2 = self.fig2.add_subplot(111)\n",
    "        \n",
    "        self.plotFrame2 = tk.Frame(master=self.back)\n",
    "        self.plotFrame2.grid(row=2, column=2, rowspan=2)\n",
    "        self.canvas2 = FigureCanvasTkAgg(self.fig2, master=self.plotFrame2)  # A tk.DrawingArea.\n",
    "        self.canvas2.draw()\n",
    "        self.canvas2.get_tk_widget().pack()\n",
    "        self.toolbar2 = NavigationToolbar2Tk(self.canvas2, self.plotFrame2)\n",
    "        self.toolbar2.update()\n",
    "        \n",
    "        self.p2ControlF = tk.Frame(master=self.plotFrame2) # child frame for plot 2 controls\n",
    "        self.p2ControlF.pack()\n",
    "        tk.Label(master=self.p2ControlF, text=\"x axis\").grid(row=0, column=0)\n",
    "        self.p2xVar = tk.StringVar()\n",
    "        self.p2xOpts = ['time', 'theta', 'psi', 'projectile velocity']\n",
    "        self.p2xVar.set(self.p2xOpts[0])\n",
    "        self.p2xVar.trace_add(\"write\", self._change_p2)\n",
    "        self.p2xMenu = tk.OptionMenu(self.p2ControlF, self.p2xVar, *self.p2xOpts)\n",
    "        self.p2xMenu.grid(row=0, column=1)\n",
    "        tk.Label(master=self.p2ControlF, text=\"y axis\").grid(row=0, column=2)\n",
    "        self.p2yVar = tk.StringVar()\n",
    "        self.p2yOpts = ['sling tension', 'projectile velocity', 'theta', 'psi', \n",
    "                        'arm rotational speed', 'puller speed']\n",
    "        self.p2yVar.set(self.p2yOpts[0])\n",
    "        self.p2yVar.trace_add(\"write\", self._change_p2)\n",
    "        self.p2yMenu = tk.OptionMenu(self.p2ControlF, self.p2yVar, *self.p2yOpts)\n",
    "        self.p2yMenu.grid(row=0, column=3)\n",
    "        \n",
    "        \n",
    "        # PLOT WINDOW 2\n",
    "        \n",
    "        # MAIN CONTROLS\n",
    "        self.mcFrame = tk.Frame(master=self.back)\n",
    "        self.mcFrame.grid(row=3, column=1)\n",
    "        self.simMsgM = tk.Message(master=self.mcFrame, text=\"\", width=180, bg='white')\n",
    "        self.simMsgM.grid(row=0, column=0, columnspan=2)\n",
    "        self.msg_text = tk.StringVar()\n",
    "        self.msg_text.trace_add(\"write\", self._update_simMsg)\n",
    "        self.msg_text.set(\"\") # contents of simMsgM\n",
    "        \n",
    "        self.run_button = tk.Button(master=self.mcFrame, text=\"Start Solver\", command=self._simulate)\n",
    "        self.run_button.grid(row=1, column=0)\n",
    "        \n",
    "        self.stop_button = tk.Button(master=self.mcFrame, text=\"Stop Solver\", command=self._stopsolve)\n",
    "        self.stop_button.grid(row=1, column=1)\n",
    "        self.stop_button.config(state=tk.DISABLED)\n",
    "\n",
    "        self.quit_button = tk.Button(master=self.mcFrame, text=\"Quit\", command=self._quit)\n",
    "        self.quit_button.grid(row=2, column=0, columnspan=2)\n",
    "        # MAIN CONTROLS\n",
    "        \n",
    "        # SAVE AND LOAD BUTTONS\n",
    "        self.saveFrame = tk.Frame(master=self.back)\n",
    "        self.saveFrame.grid(row=0, column=0, stick=tk.W)\n",
    "        self.saveBtn = tk.Button(master=self.saveFrame, text=\"Save Design\", command=self._save_design)\n",
    "        self.saveBtn.grid(row=0, column=0)\n",
    "        \n",
    "        self.loadBtn = tk.Button(master=self.saveFrame, text=\"Load Design\", command=self._load_design)\n",
    "        self.loadBtn.grid(row=0, column=1)\n",
    "        # SAVE AND LOAD BUTTONS\n",
    "        \n",
    "        # DYNAMICS PARAMETERS\n",
    "        self.dpFrame = tk.LabelFrame(master=self.back, text=\"Dynamics Parameters\")\n",
    "        self.dpFrame.grid(row=1, column=0)\n",
    "        \n",
    "        DPF = self.dpFrame #shorthand name\n",
    "        # correct order: (La, Ls, ds, mb, rc, Ia, mp, g)\n",
    "        self.DPEL = (\"Arm Length\", \"Sling Length\", \"Sling Linear Density\", \"Arm Mass\", \n",
    "                \"Distance from Pivot to Arm COM\", \"Arm Rotational Inertia\", \"Projectile + Pouch Mass\", \n",
    "               \"Gravitational Acceleration\") # ORDER IS IMPORTANT!\n",
    "        DPF.CW = self._gen_entries2(DPF, self.DPEL, (0,0), dict(), maxcol=len(self.DPEL))\n",
    "        DPF.CW['Gravitational AccelerationE'].insert(0, \"9.8\")\n",
    "        # DYNAMICS PARAMETERS\n",
    "        \n",
    "        # INITIAL CONDITIONS\n",
    "        self.icFrame = tk.LabelFrame(master=self.back, text=\"Initial Conditions\")\n",
    "        self.icFrame.grid(row=1, column=1) # between the plot windows\n",
    "\n",
    "        tk.Label(master=self.icFrame, text=\"\\u03B8\").grid(row=0, column=0)\n",
    "        self.t0SV = tk.StringVar()\n",
    "        self.theta0E = tk.Entry(master=self.icFrame, textvariable=self.t0SV)\n",
    "        self.theta0E.grid(row=0, column=1)\n",
    "        self.theta0E.insert(0, \"3.14\")\n",
    "\n",
    "        self.ICEL = (\"d\\u03B8/dt\", \"\\u03C8\", \"d\\u03C8/dt\")\n",
    "        self.icFrame.CW = self._gen_entries2(self.icFrame, self.ICEL, (1,0), dict(), maxcol=len(self.ICEL))\n",
    "        self.icFrame.CW['d\\u03B8/dtE'].insert(0, \"0\")\n",
    "        self.icFrame.CW['d\\u03C8/dtE'].insert(0, \"0\")\n",
    "        # INITIAL CONDITIONS\n",
    "        \n",
    "        # SIMULATION CONTROLS\n",
    "        self.scFrame = tk.Frame(master=self.back)\n",
    "        self.scFrame.grid(row=2, column=1)\n",
    "\n",
    "        self.scCondFrame = tk.Frame(master=self.scFrame) \n",
    "        # frame containing the conditional entries, which depend on simtype\n",
    "        self.scCondFrame.grid(row=4, column=0, columnspan=2)\n",
    "        \n",
    "        # --- widget definition for scCondFrame ---\n",
    "        self.simtypes = ['psi', 'launch_angle', 'sling_len_opt', 'arm_inertia_opt']\n",
    "        self.sccw = {k: dict() for k in self.simtypes}\n",
    "        self.sccw['psi']['psi_label'] = tk.Label(master=self.scCondFrame, text=\"psi at release\")\n",
    "        self.sccw['psi']['psi_label'].grid(row=0, column=0)\n",
    "        self.sccw['psi']['psif'] = tk.Entry(master=self.scCondFrame, width=8)\n",
    "        self.sccw['psi']['psif'].grid(row=0, column=1)\n",
    "        \n",
    "        self.sccw['launch_angle']['pb_label'] = tk.Label(master=self.scCondFrame, \n",
    "                                                                   text=\"psi final bounds\", wraplength=80)\n",
    "        self.sccw['launch_angle']['pb_label'].grid(row=0, column=0)\n",
    "        self.sccw['launch_angle']['psifmin'] = tk.Entry(master=self.scCondFrame, width=8)\n",
    "        self.sccw['launch_angle']['psifmin'].grid(row=0, column=1)\n",
    "        self.sccw['launch_angle']['psifmax'] = tk.Entry(master=self.scCondFrame, width=8)\n",
    "        self.sccw['launch_angle']['psifmax'].grid(row=0, column=2)\n",
    "        self.sccw['launch_angle']['la_label'] = tk.Label(master=self.scCondFrame, text=\"launch angle\")\n",
    "        self.sccw['launch_angle']['la_label'].grid(row=2, column=0)\n",
    "        self.sccw['launch_angle']['vpa'] = tk.Entry(master=self.scCondFrame, width=8)\n",
    "        self.sccw['launch_angle']['vpa'].grid(row=2, column=1)\n",
    "        \n",
    "        self.sccw['sling_len_opt']['pb_label'] = self.sccw['launch_angle']['pb_label']\n",
    "        self.sccw['sling_len_opt']['psifmin'] = self.sccw['launch_angle']['psifmin']\n",
    "        self.sccw['sling_len_opt']['psifmax'] = self.sccw['launch_angle']['psifmax']\n",
    "        self.sccw['sling_len_opt']['slb_label'] = tk.Label(master=self.scCondFrame, \n",
    "                                                           text=\"sling length bounds\", wraplength=80)\n",
    "        self.sccw['sling_len_opt']['slb_label'].grid(row=1, column=0)\n",
    "        self.sccw['sling_len_opt']['lsmin'] = tk.Entry(master=self.scCondFrame, width=8)\n",
    "        self.sccw['sling_len_opt']['lsmin'].grid(row=1, column=1)\n",
    "        self.sccw['sling_len_opt']['lsmax'] = tk.Entry(master=self.scCondFrame, width=8)\n",
    "        self.sccw['sling_len_opt']['lsmax'].grid(row=1, column=2)\n",
    "        self.sccw['sling_len_opt']['la_label'] = self.sccw['launch_angle']['la_label']\n",
    "        self.sccw['sling_len_opt']['vpa'] = self.sccw['launch_angle']['vpa']\n",
    "        self.sccw['sling_len_opt']['tf_label'] = tk.Label(master=self.scCondFrame, text=\"\\u03B8 final\")\n",
    "        self.sccw['sling_len_opt']['tf_label'].grid(row=3, column=0)\n",
    "        self.sccw['sling_len_opt']['thetaf'] = tk.Entry(master=self.scCondFrame, width=8)\n",
    "        self.sccw['sling_len_opt']['thetaf'].grid(row=3, column=1)\n",
    "\n",
    "        self.sccw['arm_inertia_opt']['pb_label'] = self.sccw['launch_angle']['pb_label']\n",
    "        self.sccw['arm_inertia_opt']['psifmin'] = self.sccw['launch_angle']['psifmin']\n",
    "        self.sccw['arm_inertia_opt']['psifmax'] = self.sccw['launch_angle']['psifmax']\n",
    "        self.sccw['arm_inertia_opt']['aib_label'] = tk.Label(master=self.scCondFrame, \n",
    "                                                           text=\"arm inertia bounds\", wraplength=80)\n",
    "        self.sccw['arm_inertia_opt']['aib_label'].grid(row=1, column=0)\n",
    "        self.sccw['arm_inertia_opt']['aimin'] = tk.Entry(master=self.scCondFrame, width=8)\n",
    "        self.sccw['arm_inertia_opt']['aimin'].grid(row=1, column=1)\n",
    "        self.sccw['arm_inertia_opt']['aimax'] = tk.Entry(master=self.scCondFrame, width=8)\n",
    "        self.sccw['arm_inertia_opt']['aimax'].grid(row=1, column=2)\n",
    "        self.sccw['arm_inertia_opt']['la_label'] = self.sccw['launch_angle']['la_label']\n",
    "        self.sccw['arm_inertia_opt']['vpa'] = self.sccw['launch_angle']['vpa']\n",
    "        self.sccw['arm_inertia_opt']['tf_label'] = self.sccw['sling_len_opt']['tf_label']\n",
    "        self.sccw['arm_inertia_opt']['thetaf'] = self.sccw['sling_len_opt']['thetaf']\n",
    "        # -------------------------------\n",
    "\n",
    "        tk.Label(master=self.scFrame, text=\"Time Step\").grid(row=0, column=0)\n",
    "        self.dtE = tk.Entry(master=self.scFrame)\n",
    "        self.dtE.grid(row=0, column=1)\n",
    "        self.dtE.insert(0, \"0.001\")\n",
    "\n",
    "        self.platformVar = tk.BooleanVar()\n",
    "        tk.Label(master=self.scFrame, text=\"Platform\").grid(row=1, column=0)\n",
    "        tk.Checkbutton(master=self.scFrame, variable=self.platformVar).grid(row=1, column=1)\n",
    "        \n",
    "        tk.Label(master=self.scFrame, text=\"Simulation Type\").grid(row=2, column=0)\n",
    "        self.simTypeVar = tk.StringVar(root)\n",
    "        self.simTypeVar.trace_add(\"write\", self._stchange) # calls _stchange when simTypeVar is written to\n",
    "        self.simTypeVar.set(self.simtypes[1])\n",
    "        self.simTypeMenu = tk.OptionMenu(self.scFrame, self.simTypeVar, *self.simtypes)\n",
    "        self.simTypeMenu.grid(row=2, column=1)\n",
    "        \n",
    "        tk.Label(master=self.scFrame, text=\"Solver Timeout (s)\").grid(row=5, column=0)\n",
    "        self.timeoutE = tk.Entry(master=self.scFrame)\n",
    "        self.timeoutE.grid(row=5, column=1)\n",
    "        self.timeoutE.insert(0, \"10\")\n",
    "        # SIMULATION CONTROLS\n",
    "        \n",
    "        # TORQUE CONTROLS\n",
    "        self.tcFrame = tk.LabelFrame(master=self.back, text=\"Torque Source\")\n",
    "        self.tcFrame.grid(row=1, column=2)\n",
    "        \n",
    "        tk.Label(master=self.tcFrame, text=\"Torque Specification Type\").grid(row=0, column=0)\n",
    "        self.tsTypeVar = tk.StringVar() # constructor argument just specifies the Tk instance, and we only have 1\n",
    "        self.tsTypes = ['Configuration A', 'Configuration B', 'r(\\u03B8) and F(\\u03B8)', \n",
    "                        '\\u03C4(\\u03B8) and r(\\u03B8)']\n",
    "        self.tsTypeVar.trace_add(\"write\", self._tcchange)\n",
    "        self.tsTypeMenu = tk.OptionMenu(self.tcFrame, self.tsTypeVar, *self.tsTypes)\n",
    "        self.tsTypeMenu.grid(row=0, column=1)\n",
    "        \n",
    "        self.tcCondFrame = tk.Frame(master=self.tcFrame)\n",
    "        self.tcCondFrame.grid(row=1, column=0, columnspan=2)\n",
    "        \n",
    "        self.GPFpos = {'row': 1, 'column': 0, 'columnspan': 2, 'rowspan': 2} # shared b/w A, B\n",
    "        \n",
    "        tk.Label(master=self.tcFrame, text=\"Hysteresis Parameter (k_w)\").grid(row=2, column=0)\n",
    "        self.tc_kwE = tk.Entry(master=self.tcFrame)\n",
    "        self.tc_kwE.grid(row=2, column=1)\n",
    "        \n",
    "        self.torqueMsgM = tk.Message(master=self.tcFrame, text=\"\", width=430)\n",
    "        self.torqueMsgM.grid(row=3, column=0, columnspan=2)\n",
    "        \n",
    "        self.tfig = Figure(figsize=(3, 3), dpi=100, tight_layout=True)\n",
    "        self.tax = self.tfig.add_subplot(111)\n",
    "        self.tplotFrame = tk.Frame(master=self.tcFrame)\n",
    "        self.tplotFrame.grid(row=0, column=2, rowspan=4)\n",
    "        self.tCanvas = FigureCanvasTkAgg(self.tfig, master=self.tplotFrame)\n",
    "        self.tCanvas.draw()\n",
    "        self.tCanvas.get_tk_widget().pack()\n",
    "        \n",
    "        # DICTIONARIES OF custom_func: callable FOR ALL CUSTOM FUNCTION MODULES\n",
    "        self.RThetaDict = self.funcDict(custom_functions.RofTheta)\n",
    "        self.FLDict = self.funcDict(custom_functions.FofL)\n",
    "        self.TauThetaDict = self.funcDict(custom_functions.TauofTheta)\n",
    "        self.FThetaDict = self.funcDict(custom_functions.FofTheta)       \n",
    "        # ******************************************************\n",
    "        \n",
    "        self.tcFVar = tk.StringVar()\n",
    "        self.tcTauVar = tk.StringVar()\n",
    "        self.tcRVar = tk.StringVar()       \n",
    "        self.tcF2Var = tk.StringVar()\n",
    "        \n",
    "        IRlabels = ['\\u03B8 min', '\\u03B8 max']\n",
    "        IRstartpos = (4, 0)\n",
    "        \n",
    "        self.tccw = {k: dict() for k in self.tsTypes}\n",
    "        self.tccw['A'] = dict()\n",
    "        self.tccw['A']['gpl'] = tk.Label(master=self.tcCondFrame, text=\"Geometry Parameters\")\n",
    "        self.tccw['A']['gpl'].grid(row=0, column=0, columnspan=2)\n",
    "        self.tccw['A']['GPFrame'] = tk.Frame(master=self.tcCondFrame)\n",
    "        self.tccw['A']['GPFrame'].grid(**self.GPFpos)\n",
    "        GPFA = self.tccw['A']['GPFrame'] #shorthand name\n",
    "        GPFED = {'A': ('r_s', 'd', '\\u03B2'), 'B': ('r_w', 'r_c', 'd', '\\u03B2')}\n",
    "        GPFsp = {'A': (1, 0), 'B': (1, 0)}\n",
    "        GPFA.CW = self._gen_entries2(GPFA, GPFED['A'], GPFsp['A'], dict()) # adds all relevant entries & labels\n",
    "        \n",
    "        self.tccw['A']['fpl'] = tk.Label(master=self.tcCondFrame, text='Force Parameters')\n",
    "        self.tccw['A']['fpl'].grid(row=0, column=2, columnspan=2)\n",
    "        self.tccw['A']['fll'] = tk.Label(master=self.tcCondFrame, text='F(L)')\n",
    "        self.tccw['A']['fll'].grid(row=1, column=2)\n",
    "        self.tccw['A']['tsTypeMenu'] = tk.OptionMenu(self.tcCondFrame, self.tcFVar, *self.FLDict.keys())\n",
    "        self.tccw['A']['tsTypeMenu'].grid(row=1, column=3)\n",
    "        self.tccw['A']['irl'] = tk.Label(master=self.tcCondFrame, text=\"Interpolation Range\")\n",
    "        self.tccw['A']['irl'].grid(row=3, column=0, columnspan=2)       \n",
    "        self.tccw['common'] = dict()\n",
    "        self.tccw['common']['irl'] = tk.Label(master=self.tcCondFrame, text=\"Interpolation Range\")\n",
    "        self.tccw['common']['irl'].grid(row=3, column=0, columnspan=2)\n",
    "        self.tccw['common'] = self._gen_entries2(self.tcCondFrame, IRlabels, IRstartpos, self.tccw['common'])\n",
    "        self.t0SV.trace_add(\"write\", self._t0update) # NOW we can add the trace to the theta0 tracker\n",
    "        # interpolation range stuff\n",
    "        self.tccw['A']['cfBtn'] = tk.Button(master=self.tcCondFrame, text=\"Calculate Fit\", command=self._calcfit)\n",
    "        self.tccw['A']['cfBtn'].grid(row=5, column=2, columnspan=2)\n",
    "        self.tccw['A']['FLFrame'] = tk.Frame(master=self.tcCondFrame)\n",
    "        self.tccw['A']['FLFrame'].grid(row=2, column=2, columnspan=2) \n",
    "        # now we need to create all possible variations of FLFrame contents\n",
    "        FLFA = self.tccw['A']['FLFrame'] # shorthand\n",
    "        FLFA.CW = self._parameter_entry_initializer(dict(), FLFA, self.FLDict, (0,0)) # child widgets   \n",
    "        for w in FLFA.winfo_children():\n",
    "            w.grid_remove() # otherwise all parameters for F(L) are present despite no func being selected\n",
    "            \n",
    "        def FLchange(*args):\n",
    "            self._entry_change(self.tccw['A']['FLFrame'], self.tccw['A']['FLFrame'].CW, self.tcFVar.get())\n",
    "            \n",
    "        self.tcFVar.trace_add(\"write\", FLchange) # when the F(L) specification type changes\n",
    "        \n",
    "        # CONFIGURATION B *****************\n",
    "        self.tccw['B'] = dict()\n",
    "        self.tccw['B']['gpl'] = tk.Label(master=self.tcCondFrame, text=\"Geometry Parameters\")\n",
    "        self.tccw['B']['gpl'].grid(row=0, column=0, columnspan=2)\n",
    "        self.tccw['B']['GPFrame'] = tk.Frame(master=self.tcCondFrame)\n",
    "        self.tccw['B']['GPFrame'].grid(**self.GPFpos)\n",
    "        GPFB = self.tccw['B']['GPFrame'] #shorthand name\n",
    "        GPFB.CW = self._gen_entries2(GPFB, GPFED['B'], GPFsp['B'], dict()) # adds all relevant entries & labels\n",
    "        \n",
    "        self.tccw['B']['fpl'] = tk.Label(master=self.tcCondFrame, text='Force Parameters')\n",
    "        self.tccw['B']['fpl'].grid(row=0, column=2, columnspan=2)\n",
    "        self.tccw['B']['fll'] = tk.Label(master=self.tcCondFrame, text='F(L)')\n",
    "        self.tccw['B']['fll'].grid(row=1, column=2)\n",
    "        self.tccw['B']['tsTypeMenu'] = tk.OptionMenu(self.tcCondFrame, self.tcFVar, *self.FLDict.keys())\n",
    "        self.tccw['B']['tsTypeMenu'].grid(row=1, column=3)\n",
    "        \n",
    "        self.tccw['B']['cfBtn'] = tk.Button(master=self.tcCondFrame, text=\"Calculate Fit\", command=self._calcfit)\n",
    "        self.tccw['B']['cfBtn'].grid(row=5, column=2, columnspan=2)\n",
    "        self.tccw['B']['FLFrame'] = self.tccw['A']['FLFrame'] # shared b/w A & B\n",
    "                \n",
    "        # R(theta) and F(theta) *****************\n",
    "        self.tccw['C'] = dict() # R & F\n",
    "        self.tccw['C']['fpl'] = tk.Label(master=self.tcCondFrame, text=\"Force Parameters\")\n",
    "        self.tccw['C']['fpl'].grid(row=0, column=0, columnspan=2)\n",
    "        self.tccw['C']['ftl'] = tk.Label(master=self.tcCondFrame, text=\"F(\\u03B8)\")\n",
    "        self.tccw['C']['ftl'].grid(row=1, column=0)\n",
    "        self.tccw['C']['ftTypeMenu'] = tk.OptionMenu(self.tcCondFrame, self.tcF2Var, *self.FThetaDict.keys())\n",
    "        self.tccw['C']['ftTypeMenu'].grid(row=1, column=1)\n",
    "        self.tccw['C']['FPFrame'] = tk.Frame(master=self.tcCondFrame)\n",
    "        self.tccw['C']['FPFrame'].grid(row=2, column=0, columnspan=2)\n",
    "        FTFC = self.tccw['C']['FPFrame']\n",
    "        FTFC.CW = self._parameter_entry_initializer(dict(), FTFC, self.FThetaDict, (0,0))\n",
    "        for w in FTFC.winfo_children():\n",
    "            w.grid_remove()\n",
    "            \n",
    "        def FTchange(*args):\n",
    "            self._entry_change(self.tccw['C']['FPFrame'], self.tccw['C']['FPFrame'].CW, self.tcF2Var.get())\n",
    "            \n",
    "        self.tcF2Var.trace_add(\"write\", FTchange)\n",
    "        \n",
    "        self.tccw['C']['rpl'] = tk.Label(master=self.tcCondFrame, text=\"Radius Parameters\")\n",
    "        self.tccw['C']['rpl'].grid(row=0, column=2, columnspan=2)\n",
    "        self.tccw['C']['rtl'] = tk.Label(master=self.tcCondFrame, text=\"R(\\u03B8)\")\n",
    "        self.tccw['C']['rtl'].grid(row=1, column=2)\n",
    "        self.tccw['C']['rtTypeMenu'] = tk.OptionMenu(self.tcCondFrame, self.tcRVar, *self.RThetaDict.keys())\n",
    "        self.tccw['C']['rtTypeMenu'].grid(row=1, column=2)\n",
    "        self.tccw['C']['RPFrame'] = tk.Frame(master=self.tcCondFrame)\n",
    "        self.tccw['C']['RPFrame'].grid(row=2, column=2, columnspan=2)\n",
    "        RTFC = self.tccw['C']['RPFrame']\n",
    "        RTFC.CW = self._parameter_entry_initializer(dict(), RTFC, self.RThetaDict, (0,0))\n",
    "        for w in RTFC.winfo_children():\n",
    "            w.grid_remove()\n",
    "            \n",
    "        def RTchange(*args):\n",
    "            self._entry_change(self.tccw['C']['RPFrame'], self.tccw['C']['RPFrame'].CW, self.tcRVar.get())\n",
    "            \n",
    "        self.tcRVar.trace_add(\"write\", RTchange)\n",
    "        \n",
    "        self.tccw['C']['cfBtn'] = tk.Button(master=self.tcCondFrame, text=\"Calculate Fit\", command=self._calcfit)\n",
    "        self.tccw['C']['cfBtn'].grid(row=7, column=0, columnspan=4)      \n",
    "        \n",
    "        self.tccw['D'] = dict() # tau and R\n",
    "        self.tccw['D']['tpl'] = tk.Label(master=self.tcCondFrame, text=\"Torque Parameters\")\n",
    "        self.tccw['D']['tpl'].grid(row=0, column=0, columnspan=2)\n",
    "        self.tccw['D']['ttl'] = tk.Label(master=self.tcCondFrame, text=\"\\u03C4(\\u03B8)\")\n",
    "        self.tccw['D']['ttl'].grid(row=1, column=0)\n",
    "        self.tccw['D']['ttTypeMenu'] = tk.OptionMenu(self.tcCondFrame, self.tcTauVar, *self.TauThetaDict.keys())\n",
    "        self.tccw['D']['ttTypeMenu'].grid(row=1, column=1)\n",
    "        self.tccw['D']['TPFrame'] = tk.Frame(master=self.tcCondFrame)\n",
    "        self.tccw['D']['TPFrame'].grid(row=2, column=0, columnspan=2)\n",
    "        TTFD = self.tccw['D']['TPFrame']\n",
    "        TTFD.CW = self._parameter_entry_initializer(dict(), TTFD, self.TauThetaDict, (0, 0))\n",
    "        for w in TTFD.winfo_children():\n",
    "            w.grid_remove()\n",
    "        def TTchange(*args):\n",
    "            self._entry_change(self.tccw['D']['TPFrame'], self.tccw['D']['TPFrame'].CW, self.tcTauVar.get())\n",
    "            \n",
    "        self.tcTauVar.trace_add(\"write\", TTchange)\n",
    "        \n",
    "        self.tccw['D']['rpl'] = self.tccw['C']['rpl']\n",
    "        self.tccw['D']['rtl'] = self.tccw['C']['rtl']\n",
    "        self.tccw['D']['rtTypeMenu'] = self.tccw['C']['rtTypeMenu']\n",
    "        self.tccw['D']['RPFrame'] = self.tccw['C']['RPFrame']\n",
    "        self.tccw['D']['cfBtn'] = self.tccw['C']['cfBtn']\n",
    "\n",
    "#         self.ttoolbar = NavigationToolbar2Tk(self.tCanvas, self.tplotFrame)\n",
    "#         self.ttoolbar.update()\n",
    "        self.tsTypeVar.set('Configuration A')\n",
    "        # TORQUE CONTROLS\n",
    "    \n",
    "        # miscellaneous Vars\n",
    "        # for loading to go smoothly, these should all be defined at initialization\n",
    "        self.effxVar = tk.StringVar(root)\n",
    "        self.effxvals = ['time', 'theta', 'psi', 'projectile speed']\n",
    "        self.effxVar.set(self.effxvals[0])\n",
    "        self.effxVar.trace_add(\"write\", self._change_p1)\n",
    "        \n",
    "        \n",
    "    def _save_design(self):\n",
    "        classes_to_save = ['Frame', 'Labelframe', 'Entry', 'Checkbutton', 'Menubutton']\n",
    "        blacklist = [self.plotFrame1, self.plotFrame2]\n",
    "        D = dict()\n",
    "        G = nx.DiGraph()\n",
    "        G.add_node(0)\n",
    "        G.nodes[0]['level'] = 0\n",
    "        G.nodes[0]['wname'] = self.back.winfo_name()\n",
    "        G.nodes[0]['widget'] = self.back # this gets wiped before saving, and regenerated on loading\n",
    "        G.nodes[0]['class'] = self.back.winfo_class()\n",
    "            \n",
    "        def map_GUI(G, node):\n",
    "            current_widget = G.nodes[node]['widget']\n",
    "            if current_widget not in blacklist:\n",
    "                child_widgets = current_widget.winfo_children()\n",
    "                for cw in child_widgets:\n",
    "                    add_widget(G, cw, node)\n",
    "            # ignore any blacklisted widgets, like the frames that control plots\n",
    "            return G\n",
    "        \n",
    "        def add_widget(G, widget, parent_node):\n",
    "            C = widget.winfo_class()\n",
    "            if C in classes_to_save:\n",
    "                nnn = max(list(G.nodes)) + 1\n",
    "                G.add_node(nnn)\n",
    "                G.add_edge(parent_node, nnn)\n",
    "                G.nodes[nnn]['level'] = G.nodes[parent_node]['level'] + 1\n",
    "                G.nodes[nnn]['wname'] = widget.winfo_name()\n",
    "                G.nodes[nnn]['widget'] = widget\n",
    "\n",
    "                G.nodes[nnn]['class'] = C\n",
    "                if (C == 'Frame') or (C == 'Labelframe'):\n",
    "                    G = map_GUI(G, nnn) # the map_GUI->add_widget->map_GUI cycle is what does the recursive\n",
    "                    # mapping of the tree structure of the GUI\n",
    "                elif C == 'Entry':\n",
    "                    G.nodes[nnn]['value'] = widget.get()\n",
    "                elif C == 'Checkbutton':\n",
    "                    varname = widget.cget('variable')\n",
    "                    G.nodes[nnn]['value'] = widget.getvar(varname)\n",
    "                    # to set in Load, widget.setvar(varname, newvalue)\n",
    "                elif C == 'Menubutton':\n",
    "    #                 for item in widget.keys():\n",
    "    #                     print(\"item = \", item)\n",
    "    #                     print(\"widget.cget(item) = \", widget.cget(item))\n",
    "                    # above code allows inspecting all the valid cget options\n",
    "                    varname = widget.cget('textvariable')\n",
    "                    G.nodes[nnn]['value'] = widget.getvar(varname)\n",
    "            # does nothing if the widget isn't a class to be saved\n",
    "            return G       \n",
    "        # these two together should recursively map the entire family tree of self.back\n",
    "        G = map_GUI(G, 0)\n",
    "        for n in G.nodes:\n",
    "            G.nodes[n]['widget'] = False # can't pickle the widgets themselves, and they\n",
    "            # need to be reconstituted later anyway\n",
    "        default_dir = os.path.join(toplevel_path, \"saved_designs\")\n",
    "        f = tk.filedialog.asksaveasfile(mode='wb', defaultextension=\".pkl\", initialdir=default_dir)\n",
    "        if f is None:\n",
    "            return\n",
    "        else:\n",
    "            pickle.dump(G, f)\n",
    "        f.close()\n",
    "        \n",
    "                                \n",
    "    def _load_design(self):\n",
    "        default_dir = os.path.join(toplevel_path, \"saved_designs\")\n",
    "        f = tk.filedialog.askopenfile(mode='rb', initialdir=default_dir)\n",
    "        if f is None:\n",
    "            return\n",
    "        G = pickle.load(f)\n",
    "        G.nodes[0]['widget'] = self.back\n",
    "        \n",
    "        def repair_node(G, node, parent_node):\n",
    "            # reassign widgets to nodes, set entry values, and set variables associated with menus and checkboxes\n",
    "            parent_widget = G.nodes[parent_node]['widget']\n",
    "            try: \n",
    "                W = parent_widget.nametowidget(G.nodes[node]['wname'])\n",
    "                G.nodes[node]['widget'] = W\n",
    "                C = G.nodes[node]['class']\n",
    "                if C == 'Entry':\n",
    "    #                 varname = W.cget(\"variable\")\n",
    "                    W.delete(0, 'end')\n",
    "                    W.insert(0, G.nodes[node]['value'])\n",
    "    #                 W.setvar(varname, G.nodes[node]['value'])\n",
    "                elif C == 'Checkbutton':\n",
    "                    varname = W.cget('variable')\n",
    "                    W.setvar(varname, G.nodes[node]['value'])\n",
    "                elif C == 'Menubutton':\n",
    "                    varname = W.cget('textvariable')\n",
    "                    W.setvar(varname, G.nodes[node]['value'])\n",
    "            except:\n",
    "                print('\\n\\nERROR ON LEVEL: ' + str(G.nodes[node]['level']))\n",
    "                pw_children = parent_widget.winfo_children()\n",
    "                pw_children_names = [pwc.winfo_name() for pwc in pw_children]\n",
    "                target_name = G.nodes[node]['wname']\n",
    "                print(\"target name: \", target_name)\n",
    "                print(\"available names: \", pw_children_names)\n",
    "                print('--- END ERROR ---\\n')\n",
    "                \n",
    "                \n",
    "        def repair_G(G):\n",
    "            # have to build the GUI state level by level\n",
    "            # reassign widgets from top down, completing level n entirely before moving to level n+1\n",
    "            # while doing this, set entries and associated variable values\n",
    "            # sort nodes into list of lists. Inner lists are all nodes on a level, outer list is levels\n",
    "            # outer_list[0] contains level 0 nodes, and so on\n",
    "            max_level = max([G.nodes[n]['level'] for n in G.nodes])\n",
    "            for level in range(1, max_level+1):\n",
    "                # don't want to include the root node, as it has no predecessors\n",
    "                Lnodes = [n for n in G.nodes if (G.nodes[n]['level'] == level)]\n",
    "                for n in Lnodes:\n",
    "                    parent_node = list(G.predecessors(n))[0]\n",
    "                    repair_node(G, n, parent_node)\n",
    "            \n",
    "        repair_G(G)\n",
    "        try:\n",
    "            self._calcfit()\n",
    "        except:\n",
    "            pass\n",
    "        \n",
    "    def show_error(self, *args):\n",
    "        err = traceback.format_exception(*args)\n",
    "        tk.messagebox.showerror('Exception',err)\n",
    "        \n",
    "    def _update_simMsg(self, *args):\n",
    "        self.simMsgM.configure(text=self.msg_text.get())        \n",
    "        \n",
    "    def _quit(self):\n",
    "        self.master.quit()     # stops mainloop\n",
    "        self.master.destroy()  # this is necessary on Windows to prevent\n",
    "                        # Fatal Python Error: PyEval_RestoreThread: NULL tstate\n",
    "            \n",
    "    def _t0update(self, *args):\n",
    "        self.tccw['common']['\\u03B8 maxE'].delete(0, \"end\")\n",
    "        self.tccw['common']['\\u03B8 maxE'].insert(0, self.theta0E.get())\n",
    "        try:\n",
    "            self._calcfit()\n",
    "        except:\n",
    "            pass # might not currently have all the other necessary parameters specified\n",
    "            \n",
    "    def _stopsolve(self):\n",
    "        # user got sick of waiting for the solver to finish\n",
    "        self.solve_proc.terminate()\n",
    "        self.solver_runningB.set(False)\n",
    "        \n",
    "    def _solver_state_change(self, *args):\n",
    "        # callback for what it says on the lid\n",
    "        # *args is because tkinter passes some stuff by default\n",
    "        # no docs on what it is, but safely ignored\n",
    "        if self.solver_runningB.get():\n",
    "            # solver is running\n",
    "            self.run_button.config(state=tk.DISABLED)\n",
    "            self.stop_button.config(state=tk.NORMAL)\n",
    "        else:\n",
    "            self.run_button.config(state=tk.NORMAL)\n",
    "            self.stop_button.config(state=tk.DISABLED)\n",
    "            \n",
    "    def _p1destroyer(self):\n",
    "        self.p1_conditional_controls.destroy()\n",
    "        self.p1_conditional_controls = tk.Frame(master=self.plotFrame1)\n",
    "        self.p1_conditional_controls.pack()\n",
    "            \n",
    "    def _change_p1(self, *args):\n",
    "        # all the \"weird\" plots that draw multiple lines or mess with the axes / figures\n",
    "        # as there is no need to save plots, the whole frame is destroyed whenever the plot type is changed\n",
    "        p1T = self.p1TypeVar.get()          \n",
    "        if p1T == 'animation':\n",
    "            if self.prevP1Type == 'animation':\n",
    "                self._run_animation()\n",
    "            else:\n",
    "                self._conf_animation()\n",
    "                self._run_animation()\n",
    "                \n",
    "        elif p1T == 'arm load':\n",
    "            self._p1destroyer()\n",
    "            self.fig1.clear()\n",
    "            axF = self.fig1.add_subplot(311)\n",
    "            axO = self.fig1.add_subplot(312)\n",
    "            axA = self.fig1.add_subplot(313)\n",
    "            if hasattr(self, \"sol\"):\n",
    "                if not self.sol is None:\n",
    "                    group = (self.fig1, axF, axO, axA)\n",
    "                    h = self.sol['H']\n",
    "                    Y, Yd, t = (np.array(h['Y']), np.array(h['Yd']), np.array(h['t']))\n",
    "                    CDTtools.dyn_core_tools.load_info(Y, Yd, t, self.dp, plot=True, group=group)\n",
    "                    self.canvas1.draw()\n",
    "            \n",
    "            def sas():\n",
    "                # def y_hist(y0, dt, dp, tp, psif, N=0, platform=True):\n",
    "                Npoints = int(self.p1_snpE.get())\n",
    "                D = CDTtools.dyn_core_tools.y_hist(self.y0, self.dt, self.dp, self.tp, self.sol['yf'][2],\n",
    "                                                          N=Npoints, platform=self.p)\n",
    "                data = CDTtools.dyn_core_tools.load_info(D['ys'], D['yds'], D['ts'], self.dp, plot=False)\n",
    "                # {'Fx_tip': Ftx, 'Fy_tip': Fty, 'omega': omega, 'alpha': alpha}\n",
    "                data_arr = np.stack((D['ts'], data['Fx_tip'], data['Fy_tip'], data['omega'], data['alpha']), 1)\n",
    "                default_dir = os.path.join(toplevel_path, \"saved_data\")\n",
    "                fname = tk.filedialog.asksaveasfilename(initialdir=default_dir)\n",
    "                if fname is None:\n",
    "                    return\n",
    "                np.savetxt(fname, data_arr)\n",
    "            # def load_info(Y, Yd, t, dp, plot=False, group=None):\n",
    "            \n",
    "            tk.Label(master=self.p1_conditional_controls, text=\"Number of Points\").grid(row=0, column=0)\n",
    "            self.p1_snpE = tk.Entry(master=self.p1_conditional_controls)\n",
    "            self.p1_snpE.grid(row=0, column=1)\n",
    "            tk.Button(master=self.p1_conditional_controls, text=\"Save Path\", command=sas).grid(row=0, column=3)\n",
    "                \n",
    "        elif p1T == 'projectile path':\n",
    "            def sp():\n",
    "                if hasattr(self, \"sol\"):\n",
    "                    if not self.sol is None:\n",
    "                        Y = np.array(self.sol['H']['Y'])\n",
    "                        default_dir = os.path.join(toplevel_path, \"saved_data\")\n",
    "                        fname = tk.filedialog.asksaveasfilename(initialdir=default_dir)\n",
    "                        scale = float(pathSaveScaleE.get())\n",
    "                        CDTtools.dyn_core_tools.projectile_path(Y, self.dp, plot=False, fname=fname, \n",
    "                                                                scale_factor=scale, axPP=None)\n",
    "            self._p1destroyer()            \n",
    "            tk.Button(master=self.p1_conditional_controls, text=\"Save Path\", command=sp).grid(row=1, column=2)\n",
    "            tk.Label(master=self.p1_conditional_controls, text=\"scale factor\").grid(row=1, column=0)\n",
    "            pathSaveScaleE = tk.Entry(master=self.p1_conditional_controls)\n",
    "            pathSaveScaleE.grid(row=1, column=1)\n",
    "            pathSaveScaleE.insert(0, \"1\")\n",
    "            self.fig1.clear()\n",
    "            # def projectile_path(Y, dp, plot=False, fname=None, scale_factor=1, axPP=None):\n",
    "            self.ax1 = self.fig1.add_subplot(111)\n",
    "            if hasattr(self, \"sol\"):\n",
    "                if not self.sol is None:\n",
    "                    Y = np.array(self.sol['H']['Y'])\n",
    "                    CDTtools.dyn_core_tools.projectile_path(Y, self.dp, plot=True, axPP=self.ax1)\n",
    "                    self.canvas1.draw()\n",
    "                    # add msg if save is selected but no solution available\n",
    "                    \n",
    "        elif p1T == 'efficiency':\n",
    "            if self.prevP1Type != 'efficiency':\n",
    "                self._p1destroyer()\n",
    "                tk.Label(master=self.p1_conditional_controls, text=\"x axis\").grid(row=0, column=0)\n",
    "                self.effxMenu = tk.OptionMenu(self.p1_conditional_controls, self.effxVar, *self.effxvals)\n",
    "                self.effxMenu.grid(row=0, column=1)\n",
    "            self.fig1.clear()\n",
    "            self.ax1 = self.fig1.add_subplot(111)\n",
    "            if hasattr(self, \"sol\"):\n",
    "                if not self.sol is None:\n",
    "                    Y = np.array(self.sol['H']['Y'])\n",
    "                    Yd = np.array(self.sol['H']['Yd'])\n",
    "                    t = np.array(self.sol['H']['t'])\n",
    "                    # def energy_plot(Y, Yd, t, dp, x='time', axE=None):\n",
    "                    CDTtools.dyn_core_tools.energy_plot(Y, Yd, t, self.dp, x=self.effxVar.get(), axE=self.ax1)\n",
    "                    self.canvas1.draw()\n",
    "                    \n",
    "        elif p1T == 'puller potential energy':\n",
    "            if self.prevP1Type != 'puller potential energy':\n",
    "                self._p1destroyer()\n",
    "                tk.Label(master=self.p1_conditional_controls, text=\"plot domain (theta)\").grid(row=0, column=0)\n",
    "                self.ppe_tminE = tk.Entry(master=self.p1_conditional_controls)\n",
    "                self.ppe_tminE.grid(row=0, column=1)\n",
    "                self.ppe_tmaxE = tk.Entry(master=self.p1_conditional_controls)\n",
    "                self.ppe_tmaxE.grid(row=0, column=2)\n",
    "                self.ppe_plotB = tk.Button(master=self.p1_conditional_controls, text=\"Replot\", \n",
    "                                           command=self._change_p1)\n",
    "                self.ppe_plotB.grid(row=0, column=3)\n",
    "            self.fig1.clear()\n",
    "            self.ax1 = self.fig1.add_subplot(111)\n",
    "            if hasattr(self, \"tp\"):\n",
    "                # def puller_potential_energy(tp, theta0, plot=False, plotdomain=None, axPPE=None):\n",
    "                tmin = self.ppe_tminE.get()\n",
    "                tmax = self.ppe_tmaxE.get()\n",
    "                theta0 = float(self.theta0E.get())\n",
    "                if (tmin != \"\") and (tmax != \"\"):\n",
    "                    ppe = CDTtools.dyn_core_tools.puller_potential_energy(self.tp, theta0, plot=True, \n",
    "                                                                          plotdomain=(float(tmin), float(tmax)),\n",
    "                                                                         axPPE = self.ax1)\n",
    "                else:\n",
    "                    ppe = CDTtools.dyn_core_tools.puller_potential_energy(self.tp, theta0, plot=True, \n",
    "                                                                          axPPE=self.ax1)\n",
    "                msg1 = \"Puller potential energy: \" + str(round(ppe, self.rp))\n",
    "                if hasattr(self, \"vpf\"):\n",
    "                    Ekf = 0.5*float(self.dpFrame.CW['Projectile + Pouch MassE'].get())*(self.vpf)**2\n",
    "                    msg2 = \"\\nOverall system efficiency: \" + str(round(Ekf/ppe, self.rp))\n",
    "                else:\n",
    "                    msg2 = \"\"\n",
    "                if hasattr(self, \"ppeMsg\"):\n",
    "                    self.ppeMsg.configure(text=msg1+msg2)\n",
    "                else:\n",
    "                    self.ppeMsg = tk.Message(master=self.p1_conditional_controls, text=msg1+msg2, \n",
    "                                             bg='white', width=256)\n",
    "                    self.ppeMsg.grid(row=1, column=0, columnspan=3)\n",
    "                self.canvas1.draw()\n",
    "            \n",
    "        elif p1T == 'axle reaction load':\n",
    "            # more or less the same as the projectile path - needs an option to save the load data\n",
    "            def sarl():\n",
    "                if hasattr(self, \"sol\"):\n",
    "                    if not self.sol is None:\n",
    "                        # def y_hist(y0, dt, dp, tp, psif, N=0, platform=True):\n",
    "                        # return {'ts': sample_times, 'ys': ys, 'yds': yds}\n",
    "                        Npoints = int(arlSaveNE.get())\n",
    "                        D = CDTtools.dyn_core_tools.y_hist(self.y0, self.dt, self.dp, self.tp, self.sol['yf'][2],\n",
    "                                                          N=Npoints, platform=self.p)\n",
    "                        default_dir = os.path.join(toplevel_path, \"saved_data\")\n",
    "                        fname = tk.filedialog.asksaveasfilename(initialdir=default_dir)\n",
    "                        # axle_reaction_force(Y, Yd, dp, t, plot=False, fname=None, ax_arf=None)\n",
    "                        CDTtools.dyn_core_tools.axle_reaction_force(D['ys'], D['yds'], self.dp, \n",
    "                                                                    D['ts'], fname=fname)\n",
    "                        \n",
    "            self._p1destroyer()            \n",
    "            tk.Button(master=self.p1_conditional_controls, \n",
    "                      text=\"Save Load Data\", command=sarl).grid(row=1, column=2)\n",
    "            default_dir = os.path.join(toplevel_path, \"saved_designs\")\n",
    "            tk.Label(master=self.p1_conditional_controls, text=\"number of points\").grid(row=0, column=2)\n",
    "            arlSaveNE = tk.Entry(master=self.p1_conditional_controls)\n",
    "            arlSaveNE.grid(row=0, column=3)\n",
    "            arlSaveNE.insert(0, \"20\")\n",
    "            self.fig1.clear()\n",
    "            self.ax1 = self.fig1.add_subplot(111)\n",
    "            if hasattr(self, \"sol\"):\n",
    "                if not self.sol is None:\n",
    "                    Y = np.array(self.sol['H']['Y'])\n",
    "                    Yd = np.array(self.sol['H']['Yd'])\n",
    "                    t = np.array(self.sol['H']['t'])\n",
    "                    CDTtools.dyn_core_tools.axle_reaction_force(Y, Yd, self.dp, t, plot=True, ax_arf=self.ax1)\n",
    "                    self.canvas1.draw()\n",
    "                    # add msg if save is selected but no solution available    \n",
    "                               \n",
    "        else:\n",
    "            msg = self.msg_text.get() + \"Unimplemented plot 1 type: \" + self.p1TypeVar.get()\n",
    "            self.msg_text.set(msg)\n",
    "        self.prevP1Type = p1T\n",
    " \n",
    "\n",
    "    def _calc_ax2_data(self, s, Y, Yd, t):\n",
    "        if s == 'time':\n",
    "            return t\n",
    "        elif s == 'theta':\n",
    "            return Y[:,0]\n",
    "        elif s == 'psi':\n",
    "            return Y[:,2]\n",
    "        elif s == 'projectile velocity':\n",
    "            vp = [CDTtools.dyn_core_tools.vp(Y[i,:], self.dp) for i in range(len(t))]\n",
    "            return np.array([np.linalg.norm(v) for v in vp])\n",
    "        elif s == 'sling tension':\n",
    "            return CDTtools.dyn_core_tools.sling_tension(Y, Yd, t, self.dp)\n",
    "        elif s == 'arm rotational speed':\n",
    "            return Y[:,1]\n",
    "        elif s == 'puller speed':\n",
    "            theta_hist = (np.array(self.sol['H']['Y']))[:, 0]\n",
    "            omega_hist = (np.array(self.sol['H']['Y']))[:, 1]\n",
    "            t_hist = np.array(self.sol['H']['t'])\n",
    "            R_hist = np.array([self.puller_geometry.R(x) for x in theta_hist])\n",
    "            Ldot = np.array([omega_hist[i] * R_hist[i] for i in range(len(t_hist))])\n",
    "            return Ldot\n",
    "        else:\n",
    "            self.msg_text.set(self.msg_text.get() + \"Unimplemented axis option: \" + s)\n",
    "            return None\n",
    "            \n",
    "            \n",
    "    def _change_p2(self, *args):    \n",
    "        if hasattr(self, \"sol\"):\n",
    "            if not self.sol is None:\n",
    "                t = np.array(self.sol['H']['t'])\n",
    "                Y = np.array(self.sol['H']['Y'])\n",
    "                Yd = np.array(self.sol['H']['Yd'])\n",
    "                p2x = self.p2xVar.get()\n",
    "                p2y = self.p2yVar.get()\n",
    "                xdata = self._calc_ax2_data(p2x, Y, Yd, t)\n",
    "                ydata = self._calc_ax2_data(p2y, Y, Yd, t)\n",
    "                    \n",
    "                if (not xdata is None) and (not ydata is None):\n",
    "                    self.ax2.clear()\n",
    "                    self.ax2.plot(xdata, ydata)\n",
    "                    self.ax2.set_xlabel(p2x)\n",
    "                    self.ax2.set_ylabel(p2y)\n",
    "                    self.canvas2.draw()\n",
    "\n",
    "        \n",
    "    def _conf_animation(self, *args):\n",
    "        # def launch_animation(Y, dp, t, axLA=None, figLA=None):\n",
    "        self._p1destroyer()\n",
    "        self.play_button = tk.Button(master=self.p1_conditional_controls, text=\"PLAY\", \n",
    "                                     command=self._run_animation)\n",
    "        self.play_button.pack()\n",
    "        tk.Label(master=self.p1_conditional_controls, text=\"Animation Length\").pack()\n",
    "        self.aniLengthE = tk.Entry(master=self.p1_conditional_controls)\n",
    "        self.aniLengthE.pack()\n",
    "        self.aniLengthE.insert(0, \"2\")\n",
    "        \n",
    "                    \n",
    "    def _run_animation(self, *args):\n",
    "        # Totally impossible to disable the play button while the animation is running\n",
    "        # it just can't be done, not with after or by any other means, in Tkinter, while\n",
    "        # keeping the rest of the GUI alive. Only other option is to implement animation directly in\n",
    "        # Tkinter using after. And that sounds like an unpleasant to spend a day. The user\n",
    "        # is just going to have to deal with being able to make the plot glitch by hitting Play again\n",
    "        # it's not like it crashes the GUI or anything\n",
    "        self.fig1.clear()\n",
    "        self.ax1 = self.fig1.add_subplot(111)\n",
    "        if hasattr(self, \"sol\"):\n",
    "            if not self.sol is None:\n",
    "                h = self.sol['H']\n",
    "                # need to clean up data so it's evenly spaced in time using hist\n",
    "                # this also determines how long the animation runs (framerate is constant 25fps)\n",
    "                nframes = int(1 + 25*float(self.aniLengthE.get()))\n",
    "                # def y_hist(y0, dt, dp, tp, psif, N=0, platform=True):\n",
    "                # return {'ts': sample_times, 'ys': ys, 'yds': yds}\n",
    "                I = CDTtools.dyn_core_tools.y_hist(self.y0, self.dt, self.dp, self.tp, \n",
    "                                                          self.sol['yf'][2], N=nframes, platform=self.p)\n",
    "\n",
    "                CDTtools.dyn_core_tools.launch_animation(I['ys'], self.dp, I['ts'],\n",
    "                                                         axLA=self.ax1, figLA=self.fig1)\n",
    "                self.canvas1.draw()\n",
    "                # DON'T try to make the Play button grey when the animation is running\n",
    "                # only way to do it is to completely scrap the use of FuncAnimation and\n",
    "                # roll your own using tkinter's after method\n",
    "                \n",
    "                        \n",
    "    def _check_solveproc(self):\n",
    "        # as long as the solver is running, checks periodically to see if it's still alive\n",
    "        if not (self.solve_proc).is_alive():\n",
    "            self.solver_runningB.set(False)\n",
    "            with open('logfile', 'a') as f:\n",
    "                f.write('solve_proc is no longer alive, t = ' + str(time.time() - self.t0) + \"\\n\")\n",
    "            self.cspcalls = 0 # reset for next simulation run\n",
    "            self._wrapup() # displays basic results from the simulation in simMsgM\n",
    "        elif (self.solve_proc).is_alive and (time.time() - self.t0) > float(self.timeoutE.get()):\n",
    "            # timeout exceeded, stop the run\n",
    "            with open('logfile', 'a') as f:\n",
    "                f.write('terminating solve_proc due to timeout, t = ' + str(time.time() - self.t0) + '\\n')\n",
    "            self.solve_proc.terminate() # ran for too long\n",
    "            self._check_solveproc() # next call will find the process dead and return\n",
    "        else:\n",
    "            self.solver_runningB.set(True)\n",
    "            self.cspcalls += 1\n",
    "            with open('logfile', 'a') as f:\n",
    "                f.write(str(self.cspcalls) + ' calls after ' + str(time.time() - self.t0) + 's\\n')\n",
    "            self.master.after(500, self._check_solveproc)\n",
    "        return 0\n",
    "            \n",
    "    def _stchange(self, *args):\n",
    "        # called when simTypeVar changes to update conditional simulation controls\n",
    "        # needs to take three parameters, but I don't need them, and the docs don't say what they are...\n",
    "        for w in self.scCondFrame.winfo_children():\n",
    "            w.grid_remove() # removes all of scCondFrame's children\n",
    "        stv = self.simTypeVar.get()\n",
    "        for k in self.sccw[stv].keys():\n",
    "            self.sccw[stv][k].grid()\n",
    "            \n",
    "    def funcDict(self, module):\n",
    "        M = [t for t in inspect.getmembers(module) if inspect.isfunction(t[1])]\n",
    "        # list of tuples of form: (namestr, callable)\n",
    "        return {t[0]: t[1] for t in M} # dictionary of {name: callable}\n",
    "\n",
    "    def _tcchange(self, *args): \n",
    "        tst = self.tsTypeVar.get()\n",
    "        for w in self.tcCondFrame.winfo_children():\n",
    "            if not w in self.tccw['common'].values():\n",
    "                w.grid_remove()\n",
    "        if tst == 'Configuration A':\n",
    "            k = 'A'\n",
    "        elif tst == 'Configuration B':\n",
    "            k = 'B'\n",
    "        elif tst == 'r(\\u03B8) and F(\\u03B8)':\n",
    "            k = 'C'\n",
    "        elif tst == '\\u03C4(\\u03B8) and r(\\u03B8)':\n",
    "            k = 'D'\n",
    "        for w in self.tccw[k].keys():\n",
    "            self.tccw[k][w].grid()\n",
    "\n",
    "            \n",
    "    def _gen_entries2(self, frame, en, sp, D, entrywidth=None, maxcol=6):\n",
    "        # uses existing dict, includes labels\n",
    "        for i in range(len(en)):\n",
    "            c = math.floor(i/maxcol)\n",
    "            r = i - (maxcol*c)\n",
    "            label_string = en[i] + 'L'\n",
    "            entry_string = en[i] + 'E'\n",
    "            D[label_string] = tk.Label(master=frame, text=en[i])\n",
    "            D[label_string].grid(row=sp[0]+r, column=sp[1]+(2*c))\n",
    "            D[entry_string] = tk.Entry(master=frame)\n",
    "            if not entrywidth is None:\n",
    "                D[entry_string].configure(width=entrywidth)\n",
    "            D[entry_string].grid(row=sp[0]+r, column=sp[1]+1+(2*c))\n",
    "        return D\n",
    "    \n",
    "    def _parameter_entry_initializer(self, D, frame, funcDict, startpos, entrywidth=8, maxcol=6):\n",
    "        for funcname in funcDict.keys():\n",
    "            f = funcDict[funcname]\n",
    "            S = inspect.signature(f)\n",
    "            i = 0\n",
    "            SL = [s for s in S.parameters][1:] # L, theta, etc. should not be added\n",
    "            D_inner = dict()\n",
    "            D[funcname] = self._gen_entries2(frame, SL, startpos, D_inner, entrywidth=entrywidth)\n",
    "        return D\n",
    "        \n",
    "    def _entry_change(self, frame, cwd, funcname):\n",
    "        # changes entries / labels in frame to those matching funcname, as defined in cwd\n",
    "        for w in frame.winfo_children():\n",
    "            w.grid_remove()\n",
    "        if funcname != '':\n",
    "            # don't try to add any widgets if the function is unspecified\n",
    "            for k in cwd[funcname].keys():\n",
    "                cwd[funcname][k].grid()\n",
    "                \n",
    "                \n",
    "    def _calcfit(self):\n",
    "        tst = self.tsTypeVar.get()\n",
    "        theta_min = float(self.tccw['common']['\\u03B8 minE'].get())\n",
    "        theta_max = float(self.tccw['common']['\\u03B8 maxE'].get())\n",
    "        self.theta_range = (theta_min, theta_max)\n",
    "        if (tst == 'Configuration A') or (tst == 'Configuration B'):\n",
    "            # these two share most of their input structure\n",
    "            if tst == 'Configuration A':\n",
    "                # GPFED = {'A': ('r_s', 'd', '\\u03B2'), 'B': ('r_w', 'r_c', 'd', '\\u03B2')}\n",
    "                gp = self.tccw['A']['GPFrame'].CW\n",
    "                iD = {'rs': float(gp['r_sE'].get()), 'd': float(gp['dE'].get()), 'beta0': float(gp['\\u03B2E'].get()),\n",
    "                     'theta0': float(self.theta0E.get())}\n",
    "                self.puller_geometry = CDTtools.puller_tools.geometry_A(iD)\n",
    "            elif tst == 'Configuration B':\n",
    "                gp = self.tccw['B']['GPFrame'].CW\n",
    "                iD = {'rw': float(gp['r_wE'].get()), 'd': float(gp['dE'].get()),\n",
    "                     'rc': float(gp['r_cE'].get()), 'beta0': float(gp['\\u03B2E'].get()),\n",
    "                    'theta0': float(self.theta0E.get())}\n",
    "                self.puller_geometry = CDTtools.puller_tools.geometry_B(iD)\n",
    "                \n",
    "            def F(L):\n",
    "                Ffuncname = self.tcFVar.get()\n",
    "                flp = self.tccw['A']['FLFrame'].CW[Ffuncname] # widgets containing F(L) parameters\n",
    "                # this is shared between A and B, two names referring to same object\n",
    "                args = [flp[k].get() for k in flp.keys() if (flp[k].winfo_class() == 'Entry')]\n",
    "                argnames = [k for k in flp.keys() if (flp[k].winfo_class() == 'Entry')]\n",
    "                func = self.FLDict[Ffuncname]\n",
    "                return func(L, *args)\n",
    "            # def taugen(FofL, LofTheta, RofTheta):\n",
    "            self.tau_exact = CDTtools.puller_tools.taugen(F, self.puller_geometry.L, self.puller_geometry.R)\n",
    "            # self.tau_exact is tau(theta), without consideration to hysteresis\n",
    "            # i.e., only valid when contracting\n",
    "            self.L0 = self.puller_geometry.L(float(self.theta0E.get()))\n",
    "            self.F0 = F(self.L0)\n",
    "            self.Fmin = min([F(self.puller_geometry.L(t)) for t in np.linspace(*self.theta_range, endpoint=True)])\n",
    "            \n",
    "        elif tst == '\\u03C4(\\u03B8) and r(\\u03B8)' or 'r(\\u03B8) and F(\\u03B8)':\n",
    "            def R(theta):\n",
    "                Rfuncname = self.tcRVar.get()\n",
    "                rtp = self.tccw['C']['RPFrame'].CW[Rfuncname] # same frame shared between C & D\n",
    "                R_args = [rtp[k].get() for k in rtp.keys() if (rtp[k].winfo_class() == 'Entry')]\n",
    "                func = self.RThetaDict[Rfuncname]\n",
    "                return func(theta, *R_args)\n",
    "            if tst == '\\u03C4(\\u03B8) and r(\\u03B8)':\n",
    "                def tau(theta):\n",
    "                    taufuncname = self.tcTauVar.get()\n",
    "                    ttp = self.tccw['D']['TPFrame'].CW[taufuncname]\n",
    "                    tau_args = [ttp[k].get() for k in ttp.keys() if (ttp[k].winfo_class() == 'Entry')]\n",
    "                    func = self.TauThetaDict[self.tcTauVar.get()]\n",
    "                    return func(theta, *tau_args)\n",
    "            else:\n",
    "                def tau(theta):\n",
    "                    Ffuncname = self.tcF2Var.get()\n",
    "                    ftp = self.tccw['C']['FPFrame'].CW[Ffuncname] # widgets containing F(theta) entries & labels\n",
    "                    F_args = [ftp[k].get() for k in ftp.keys() if (ftp[k].winfo_class() == 'Entry')]\n",
    "                    F_func = self.FThetaDict[Ffuncname]\n",
    "                    return R(theta)*F_func(theta, *F_args)\n",
    "            self.puller_geometry = CDTtools.puller_tools.geometry_custom(R)\n",
    "            self.tau_exact = tau\n",
    "            theta0 = float(self.theta0E.get())\n",
    "            def F(theta):\n",
    "                return tau(theta)/R(theta)\n",
    "            self.F0 = F(theta0)\n",
    "            self.Fmin = min([F(t) for t in np.linspace(*self.theta_range, endpoint=True)])\n",
    "            \n",
    "        self.tau_fit = CDTtools.puller_tools.torque_fit(self.tau_exact, self.theta_range)\n",
    "        nc = 3\n",
    "        tf_msg = \"\\u03C4(\\u03B8) = \"\n",
    "        for i in range(len(self.tau_fit.coef)):\n",
    "            tf_msg = tf_msg + str(round(self.tau_fit.coef[i], nc)) + \"*\\u03B8^\" + str(i) + \" + \"\n",
    "        tf_msg = tf_msg[:-3]\n",
    "        F0_msg = '\\nPuller force at initial configuration: ' + str(round(self.F0, nc))\n",
    "        if self.Fmin < 0:\n",
    "            Fmin_warning = \"\\nWarning: puller in compression. Minimum force \" + str(round(self.Fmin, nc))\n",
    "        else:\n",
    "            Fmin_warning = \"\"\n",
    "        self.torqueMsgM.configure(text=tf_msg+F0_msg+Fmin_warning)\n",
    "        self._plotTfit()\n",
    "            \n",
    "                        \n",
    "    def _plotTfit(self):\n",
    "        self.tax.clear()\n",
    "        xtest = np.linspace(*self.theta_range, endpoint=True) # self.theta_range set by calcfit\n",
    "        # nothing but calcfit calls plotTfit\n",
    "        ytest = np.array([self.tau_fit(x) for x in xtest])\n",
    "        ytrue = np.array([self.tau_exact(x) for x in xtest])\n",
    "        ymin = min((min(ytest), min(ytrue)))\n",
    "        self.tax.plot(xtest, ytest, label=\"interpolation result\")\n",
    "        self.tax.plot(xtest, ytrue, label=\"true value\")\n",
    "        self.tax.legend(loc='best')\n",
    "        self.tax.set_xlabel(\"theta\")\n",
    "        self.tax.set_ylabel(\"torque\")\n",
    "        if ymin > 0:\n",
    "            self.tax.set_ylim(0)\n",
    "        self.tCanvas.draw()\n",
    "        \n",
    "    def _gen_dp(self):\n",
    "        # correct order: (La, Ls, ds, mb, rc, Ia, mp, g)\n",
    "        def P(S):\n",
    "            key = S+'E'\n",
    "            return float(self.dpFrame.CW[key].get())\n",
    "        self.dp = CDTtools.dyn_core_tools.dyn_params(*[P(S) for S in self.DPEL])\n",
    "                   \n",
    "    def _simulate(self):\n",
    "        # change what's run based on the selected optimization option\n",
    "        self._gen_dp()\n",
    "        self._calcfit() # don't want to cause the user headaches because they forgot to hit calculate fit\n",
    "        # also quietly solves the problem that arises if they change theta0 *after* calculating the torque fit\n",
    "        c = [ci for ci in self.tau_fit.coef]\n",
    "        k_w = float(self.tc_kwE.get())\n",
    "        self.tp = CDTtools.dyn_core_tools.T_params(k_w, *c)\n",
    "        ENL = (\"d\\u03B8/dtE\", \"\\u03C8E\", \"d\\u03C8/dtE\")\n",
    "        y0L = [float(self.theta0E.get())] + [float(self.icFrame.CW[en].get()) for en in ENL]\n",
    "        self.y0 = np.array(y0L)\n",
    "        self.dt = float(self.dtE.get()) # get this from simulation setup section\n",
    "        self.p = self.platformVar.get() # is there a platform? (BooleanVar)\n",
    "        # this is the value of platformVar that the PREVIOUS SIMULATION was run with\n",
    "\n",
    "        if self.simTypeVar.get() == 'psi':   \n",
    "            self.prev_solve_type = 'psi'\n",
    "            psi_release = float(self.sccw['psi']['psif'].get())\n",
    "            solver_args = (CDTtools.dyn_core_tools.dyn_general, self.cps, self.y0, self.dt, self.dp, \n",
    "                           self.tp, psi_release)\n",
    "            solver_kwargs = {'verbose': False, 'platform': self.p, 'history': True}\n",
    "           \n",
    "        elif self.simTypeVar.get() == 'launch_angle':\n",
    "            self.prev_solve_type = 'launch_angle'\n",
    "            psibounds = (float(self.sccw['launch_angle']['psifmin'].get()), \n",
    "                         float(self.sccw['launch_angle']['psifmax'].get()))\n",
    "            vpa_target = float(self.sccw['launch_angle']['vpa'].get())\n",
    "            solver_args = (CDTtools.dyn_core_tools.dft_vpastop, self.cps, self.y0, self.dt, self.dp,\n",
    "                          self.tp, psibounds, vpa_target)\n",
    "            solver_kwargs = {'verbose': False, 'platform': self.p, 'history': True}\n",
    "            \n",
    "        elif self.simTypeVar.get() == 'sling_len_opt':\n",
    "            self.prev_solve_type = 'sling_len_opt'\n",
    "            psibounds = (float(self.sccw['sling_len_opt']['psifmin'].get()),\n",
    "                       float(self.sccw['sling_len_opt']['psifmax'].get()))\n",
    "            Lsbounds = (float(self.sccw['sling_len_opt']['lsmin'].get()), \n",
    "                     float(self.sccw['sling_len_opt']['lsmax'].get()))\n",
    "            vpa_target = float(self.sccw['sling_len_opt']['vpa'].get())\n",
    "            theta_target = float(self.sccw['sling_len_opt']['thetaf'].get())\n",
    "            solver_args = (CDTtools.dyn_core_tools.dft_opt1a, self.cps, self.y0, self.dt, self.dp,\n",
    "                          self.tp, psibounds, vpa_target, Lsbounds, theta_target)\n",
    "            solver_kwargs = {'verbose': False, 'platform': self.p, 'history': True}\n",
    "            \n",
    "        elif self.simTypeVar.get() == 'arm_inertia_opt':\n",
    "            self.prev_solve_type = 'arm_inertia_opt'\n",
    "            psibounds = (float(self.sccw['arm_inertia_opt']['psifmin'].get()),\n",
    "                       float(self.sccw['arm_inertia_opt']['psifmax'].get()))\n",
    "            Iabounds = (float(self.sccw['arm_inertia_opt']['aimin'].get()), \n",
    "                     float(self.sccw['arm_inertia_opt']['aimax'].get()))\n",
    "            vpa_target = float(self.sccw['arm_inertia_opt']['vpa'].get())\n",
    "            theta_target = float(self.sccw['arm_inertia_opt']['thetaf'].get())\n",
    "            solver_args = (CDTtools.dyn_core_tools.dft_opt2, self.cps, self.y0, self.dt, self.dp,\n",
    "                          self.tp, psibounds, vpa_target, Iabounds, theta_target)\n",
    "            solver_kwargs = {'verbose': False, 'platform': self.p, 'history': True}\n",
    "            \n",
    "        self.solve_proc = multiprocessing.Process(target=CDTtools.dyn_core_tools.solver_wrapper,\n",
    "                                                 args=solver_args, kwargs=solver_kwargs)\n",
    "        self.solve_proc.start()\n",
    "        self.t0 = time.time()\n",
    "        self._check_solveproc()            \n",
    "\n",
    "        \n",
    "    def _wrapup(self):\n",
    "        # display results from the last simulation run and set self.sol for later use\n",
    "        self.sol = None # keeps the animation from running again if there's no new solution\n",
    "        if self.cpr.poll(0.1):\n",
    "            # YAY! We have a solution!\n",
    "            self.sol = self.cpr.recv() # this will be needed elsewhere for postproc\n",
    "            psif = self.sol['yf'][2]\n",
    "            theta_min_true = min(np.array(self.sol['H']['Y'])[:,0])\n",
    "            theta_min_guess = min(self.theta_range)\n",
    "            if self.prev_solve_type == 'psi':\n",
    "                extra_msg = (\"Launch angle: \" + \n",
    "                         str(round(CDTtools.dyn_core_tools.vp_angle(self.sol['yf'], self.dp), self.rp)) + \"\\n\")\n",
    "            elif self.prev_solve_type == 'launch_angle':\n",
    "                psibounds = (float(self.sccw['launch_angle']['psifmin'].get()), \n",
    "                             float(self.sccw['launch_angle']['psifmax'].get()))\n",
    "                extra_msg = \"Psi at release: \" + str(round(psif, self.rp)) + \"\\n\"\n",
    "                if np.isclose(psif, psibounds[0], atol=1e-3) or np.isclose(psif, psibounds[1], atol=1e-3):\n",
    "                    extra_msg = (extra_msg + \"\\nWarning: The target launch angle was not reachable given the\"\n",
    "                                 \" specified constraints on psi final\\n\\n\")\n",
    "            elif self.prev_solve_type == 'sling_len_opt':\n",
    "                psibounds = (float(self.sccw['launch_angle']['psifmin'].get()), \n",
    "                             float(self.sccw['launch_angle']['psifmax'].get()))\n",
    "                Lsbounds = (float(self.sccw['sling_len_opt']['lsmin'].get()), \n",
    "                             float(self.sccw['sling_len_opt']['lsmax'].get()))\n",
    "                self.dp.Ls = self.sol['Ls_opt']\n",
    "                extra_msg = (\"Psi at release: \" + str(round(self.sol['yf'][2], self.rp)) + \n",
    "                             \"\\nOptimized sling length: \" + str(round(self.sol['Ls_opt'], self.rp)) + \"\\n\")\n",
    "                if True in [np.isclose(psif, psibounds[0]), np.isclose(psif, psibounds[1]), \n",
    "                           np.isclose(self.dp.Ls, Lsbounds[0]), np.isclose(self.dp.Ls, Lsbounds[1])]:\n",
    "                    extra_msg = (extra_msg + \"\\nWarning: The target launch angle and final arm angle were not \"\n",
    "                                 \"reachable given the specified constraints on psi final and sling length\\n\\n\")\n",
    "            elif self.prev_solve_type == 'arm_inertia_opt':\n",
    "                psibounds = (float(self.sccw['launch_angle']['psifmin'].get()), \n",
    "                             float(self.sccw['launch_angle']['psifmax'].get()))\n",
    "                Iabounds = (float(self.sccw['arm_inertia_opt']['aimin'].get()), \n",
    "                             float(self.sccw['arm_inertia_opt']['aimax'].get()))\n",
    "                self.dp.Ia = self.sol['Ia_opt']\n",
    "                extra_msg = (\"Psi at release: \" + str(round(self.sol['yf'][2], self.rp)) + \n",
    "                             \"\\nOptimized arm inertia: \" + str(round(self.sol['Ia_opt'], self.rp)) + \"\\n\")\n",
    "                if True in [np.isclose(psif, psibounds[0]), np.isclose(psif, psibounds[1]), \n",
    "                           np.isclose(self.dp.Ia, Iabounds[0]), np.isclose(self.dp.Ia, Iabounds[1])]:\n",
    "                    extra_msg = (extra_msg + \"\\nWarning: The target launch angle and final arm angle were not \" \n",
    "                                 \"reachable given the specified constraints on psi final and arm inertia\\n\\n\")\n",
    "            else:\n",
    "                extra_msg = \"NOT YET IMPLEMENTED\"\n",
    "                \n",
    "            vpf = CDTtools.dyn_core_tools.vp(self.sol['yf'], self.dp) # dp has been updated if necessary\n",
    "            # crucially, it only gets changed again when simulate is run\n",
    "            self.vpf = np.linalg.norm(vpf)\n",
    "            thetaf = self.sol['yf'][0]\n",
    "            if theta_min_true < theta_min_guess:\n",
    "                extra_msg = (extra_msg + \n",
    "                             \"\\nWarning: Minimum arm angle outside of interpolation range: \\u03B8_min = \" + \n",
    "                                str(round(theta_min_true, self.rp)) + \"\\n\")\n",
    "            sim_res_msg = (extra_msg + \"Launch speed: \" + str(round(self.vpf, self.rp)) + \n",
    "                           \"\\nRelease time: \" + str(round(self.sol['tf'], self.rp)) +\n",
    "                          \"\\nTheta at release: \" + str(round(thetaf, self.rp)))\n",
    "                            \n",
    "        else:\n",
    "            # womp womp\n",
    "            sim_res_msg = (\"Solver did not finish. This may be caused by excessively short time steps, or the \" \n",
    "                           \"dynamics never encountering a stop condition. Remember that any configuration \"\n",
    "                           \"within the search space of an optimizing solver may be tried. It may also be \"\n",
    "                           \"helpful to read the logfile or increase the timeout\")\n",
    "        self.msg_text.set(sim_res_msg)\n",
    "        self._change_p2() # updates plot 2\n",
    "        self._change_p1()\n",
    "\n",
    "root = tk.Tk()\n",
    "gui = CDT_GUI(root)\n",
    "root.mainloop()\n",
    "# If you put root.destroy() here, it will cause an error if the window is\n",
    "# closed with the window manager."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "detected system: GNU/LINUX\n",
      "psi tending to decrease. Prevented by holder. Switching to captive-projectile dynamics\n",
      "transition to full dynamics at: y02 =  [   4.80649753 -160.08588705    0.6           0.        ]\n",
      "ydot at transition:  [-1.60085887e+02 -1.88479600e+04  0.00000000e+00 -5.54769364e-10]\n",
      "wmax =  288.55242259710764\n",
      "y_final =  [   2.65283446 -288.54211306    1.          150.8855524 ]\n",
      "vp =  243.47664707204993\n",
      "vp angle =  -1.8990621330177628\n",
      "final projectile acceleration =  107653.36256203272\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "import CDTtools\n",
    "\n",
    "La = 0.4\n",
    "Ls = 0.65\n",
    "ds = 0.001\n",
    "mb = 2.0\n",
    "rc = 0.1\n",
    "Ia = 0.01\n",
    "mp = 0.005\n",
    "g = 9.8\n",
    "\n",
    "tpa = np.array([ 1.27195914e+02, 2.43180113e+02, -7.73181155e+01, -9.14434932e+01,\n",
    "  2.81322537e+01,  3.11912957e+01, -2.07732533e+01,  4.85715466e+00,\n",
    " -4.50420886e-01,  2.19554674e-03,  1.42750751e-03])\n",
    "\n",
    "y0 = np.array([5.5, 0.0, 0.6, 0.0])\n",
    "dptest = CDTtools.dyn_core_tools.dyn_params(La, Ls, ds, mb, rc, Ia, mp, g)\n",
    "tptest = CDTtools.dyn_core_tools.T_params(2.0, *tpa)\n",
    "\n",
    "# dyn_general(y0, dt, dp, tp, psi_final, verbose=True, platform=True, history=False)\n",
    "sol = CDTtools.dyn_core_tools.dyn_general(y0, 0.0001, dptest, tptest, 1.0, verbose=True, platform=True, history=True)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[3]\n",
      "{'a': 42, 'b': 43}\n"
     ]
    }
   ],
   "source": [
    "H = nx.DiGraph()\n",
    "H.add_node(1)\n",
    "H.add_node(2)\n",
    "H.add_node(3)\n",
    "H.add_edge(1, 2)\n",
    "H.add_edge(1,3)\n",
    "H.add_node(4)\n",
    "H.add_edge(3, 4)\n",
    "P = H.predecessors(4) # predecessors contains only the PARENT of the node, not any of its parents\n",
    "print(list(P))\n",
    "H.nodes[3]['a'] = 42\n",
    "H.nodes[3]['b'] = 43\n",
    "print(H.nodes[3])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "col_offset =  2\n",
      "row_offset =  0\n"
     ]
    }
   ],
   "source": [
    "import math\n",
    "def index_magic(i, mc):\n",
    "    col_offset = math.floor(i/mc)\n",
    "    row_offset = i - (mc*col_offset)\n",
    "    print(\"col_offset = \", col_offset)\n",
    "    print(\"row_offset = \", row_offset)\n",
    "    \n",
    "index_magic(6, 3)"
   ]
  }
 ],
 "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.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}