rhythm_training.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "e4c7504b-58e6-47b7-9a4f-1cdeddb99400",
   "metadata": {
    "jp-MarkdownHeadingCollapsed": true,
    "tags": []
   },
   "source": [
    "### Code section"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "75ed3471-67aa-4be9-9182-528ad62288c3",
   "metadata": {
    "tags": []
   },
   "source": [
    "##### Initialize SC server and MIDI input"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "659c4d6e-b52e-4844-bf1a-80cfb8366dfe",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "application/javascript": [
       "if (typeof Jupyter !== 'undefined') {\n",
       "                        Jupyter.keyboard_manager.command_shortcuts.add_shortcut(\n",
       "                        'Ctrl-.', {\n",
       "                        help : 'Free all nodes on SC server',\n",
       "                        help_index : 'zz',\n",
       "                        handler : function (event) {\n",
       "                            IPython.notebook.kernel.execute(\n",
       "                                \"import sc3nb; sc3nb.SC.get_default().server.free_all(root=True)\"\n",
       "                            )\n",
       "                            return true;}\n",
       "                        });\n",
       "                    }"
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Starting sclang process... Done.\n",
      "Registering OSC /return callback in sclang... Done.\n",
      "Loading default sc3nb SynthDefs... Done.\n",
      "Booting SuperCollider Server... Done.\n"
     ]
    }
   ],
   "source": [
    "import sc3nb as scn\n",
    "import numpy as np\n",
    "sc = scn.startup()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "fd60051d-ee51-492d-bc98-754ee70a55aa",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "MIDI: device 0 3 1832551344  (Microsoft GS Wavetable Synth)\n",
      "MIDI: device 1 4 1832551352  (V61)\n",
      "MIDI: device 2 5 1832551360  (MIDIOUT2 (V61))\n",
      "MIDI Sources:\n",
      "\tMIDIEndPoint(\"V61\", \"V61\")\n",
      "\tMIDIEndPoint(\"MIDIIN2 (V61)\", \"MIDIIN2 (V61)\")\n",
      "MIDI Destinations:\n",
      "\tMIDIEndPoint(\"Microsoft GS Wavetable Synth\", \"Microsoft GS Wavetable Synth\")\n",
      "\tMIDIEndPoint(\"V61\", \"V61\")\n",
      "\tMIDIEndPoint(\"MIDIOUT2 (V61)\", \"MIDIOUT2 (V61)\")\n",
      "-> MIDIClient\n",
      "Requested notification messages from server 'sc3nb_remote'\n",
      "sc3nb_remote: server process has maxLogins 8 - adjusting my options accordingly.\n",
      "sc3nb_remote: keeping clientID (0) as confirmed by server process.\n",
      "-> MIDIIn\n"
     ]
    }
   ],
   "source": [
    "%sc MIDIClient.init;\n",
    "%sc MIDIIn.connectAll;"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3a00ea59-0b37-49e2-b1d1-b58bb92f7b3c",
   "metadata": {
    "tags": []
   },
   "source": [
    "##### Setup SC synths and global parameters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "d0994e55-9ae9-49a8-9a86-de40bb7f5788",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> a SynthDef\n"
     ]
    }
   ],
   "source": [
    "%%sc \n",
    "// Setting up general parameters used by the training tasks\n",
    "\n",
    "~metronome_rates = [1, 0.75, 0.75, 0.75];\n",
    "~metronome_amp = 0.05;\n",
    "~metronome_amps = Pseq([~metronome_amp], inf);\n",
    "~number_all_notes = 0;\n",
    "~dur_per_beat = 1.0;\n",
    "\n",
    "\n",
    "// Setting up SynthDefs used by the training tasks\n",
    "\n",
    "~drumstick_buf = Buffer.read(s, \"./sounds/drumstick.wav\";);\n",
    "\n",
    "// Metronome sound\n",
    "SynthDef(\\play_buf, {\n",
    "    |out=0, buf, amp=0.5, rate=1|\n",
    "    var sig = PlayBuf.ar(1, buf, BufRateScale.kr(buf) * rate, doneAction: 2) * amp;\n",
    "    Out.ar(out, sig!2)\n",
    "}).add;\n",
    "\n",
    "// Generic piano sound the player hears when hitting keys on the keyboard\n",
    "SynthDef(\\train_note, { \n",
    "    |freq=440, amp=0.2, pan=0.5, gate=1, distortion_length=0, \n",
    "    noise_level=0, freq_distort_level=0, amp_reduction_level=0|\n",
    "    var sig, env, note, noise, env_distortion;\n",
    "    \n",
    "    env = EnvGen.kr(Env.adsr(releaseTime: 0.5), gate, doneAction: Done.freeSelf);\n",
    "    env_distortion = EnvGen.kr(Env.linen(0, distortion_length * ~dur_per_beat, 0, 1));\n",
    "    \n",
    "    note = LFTri.ar((1 - (noise_level * env_distortion)) * freq + (SinOsc.kr(20, 0, 15, 0) * freq_distort_level * env_distortion));\n",
    "    \n",
    "    sig = (noise_level * env_distortion) * BrownNoise.ar(0.25) + note;\n",
    "    sig = sig * (amp - (amp_reduction_level * amp * env_distortion));\n",
    "    sig = sig * env;\n",
    "    Out.ar(0, 1-pan * sig);\n",
    "    Out.ar(1, pan * sig);\n",
    "}).add;\n",
    "\n",
    "// Signal sound for Method 1\n",
    "SynthDef(\\default_note, { |freq=440, amp=0.2, sustain=0.5, pan=0.5|\n",
    "    var sig;\n",
    "    sig = LFTri.ar(freq, mul: amp) * EnvGen.kr(Env.perc(0.001, sustain), doneAction: Done.freeSelf);\n",
    "    Out.ar(0, 1-pan * sig);\n",
    "    Out.ar(1, pan * sig);\n",
    "}).add;\n",
    "\n",
    "// Signal sound for Method 2\n",
    "SynthDef(\\blip, { |freq=440, amp=0.2, sustain=0.5, pan=0.5|\n",
    "    var sig;\n",
    "    sig = Blip.ar(freq, mul: amp) * EnvGen.kr(Env.perc(0.001, sustain), doneAction: Done.freeSelf);\n",
    "    Out.ar(0, 1-pan * sig);\n",
    "    Out.ar(1, pan * sig);\n",
    "}).add;\n",
    "\n",
    "// Signal sound for Method 3\n",
    "SynthDef(\\tick, { |rate=2, amp=0.3, sustain=0.5, pan=0.5|\n",
    "    var sig;\n",
    "    sig = PlayBuf.ar(1, ~drumstick_buf, BufRateScale.kr(~drumstick_buf) * rate, doneAction: Done.freeSelf) * amp;\n",
    "    Out.ar(0, 1-pan * sig);\n",
    "    Out.ar(1, pan * sig);\n",
    "}).add;"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "c5ada327-9dfd-44aa-ade7-7f043b10b316",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> MIDIdef(note_off, noteOff, nil, nil, nil)\n"
     ]
    }
   ],
   "source": [
    "%%sc\n",
    "~notes = Array.newClear(128);    // array has one slot per possible MIDI note\n",
    "\n",
    "MIDIdef.noteOn(\\note_on, { \n",
    "    |veloc, num, chan, src, default_synth=\\train_note|\n",
    "    ~notes[num] = Synth(default_synth, [\\freq, num.midicps, \\amp, veloc * 0.00315]);\n",
    "    }\n",
    ");\n",
    "\n",
    "MIDIdef.noteOff(\\note_off, {\n",
    "    |veloc, num, chan, src|\n",
    "    ~notes[num].release;\n",
    "    }\n",
    ");"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ff7886ca-68e0-45ab-8732-7948615a5300",
   "metadata": {
    "jp-MarkdownHeadingCollapsed": true,
    "tags": []
   },
   "source": [
    "##### Setup SC functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "3d1ccb98-eab3-49a1-82ce-8e52ab3ce0c1",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> a Function\n"
     ]
    }
   ],
   "source": [
    "%%sc\n",
    "// A function that plays different signal sounds depending on which sonification method\n",
    "// is passed as argument.\n",
    "~play_control_note = { |method, midi, pan|\n",
    "                          switch(method,\n",
    "                                1, { Synth(\\default_note, [\\freq, midi.midicps, \\pan, pan]) },\n",
    "                                2, { Synth(\\blip, [\\freq, midi.midicps, \\pan, pan]) },\n",
    "                                3, { Synth(\\tick, [\\freq, midi.midicps, \\pan, pan]) })\n",
    "                     };\n",
    "\n",
    "// A function that returns a Task object which plays a set of notes in some rhythm.\n",
    "// This function and the control task returned by it are used to realize interactive\n",
    "// sonification feedback for notes played too late.\n",
    "// The Task plays along the training rhythm in silent and produces a signal sound when\n",
    "// the player has not played a note after the correct time for that note has passed. \n",
    "~setup_control_task = { |train_notes, train_rhythms, method, pan = 0.5|\n",
    "                        Task({\n",
    "                            var current_note, task_rhythm = Pseq(train_rhythms, inf).asStream;\n",
    "                            current_note = 0;\n",
    "                            loop {\n",
    "                                train_notes.do({ |midi|\n",
    "                                    if ((~train_inputs[current_note].size == 0), {\n",
    "                                        ~play_control_note.value(method, midi, pan);\n",
    "                                    });\n",
    "                                    task_rhythm.next.wait;\n",
    "                                    current_note = current_note + 1;\n",
    "                                });\n",
    "                            }\n",
    "                        })\n",
    "                      };\n",
    "\n",
    "// Creates control task for left hand for two-hands tasks\n",
    "~setup_control_task_left = { |train_notes, train_rhythms, method, pan = 0.5|\n",
    "                        Task({\n",
    "                            var current_note, task_rhythm = Pseq(train_rhythms, inf).asStream;\n",
    "                            current_note = 0;\n",
    "                            loop {\n",
    "                                train_notes.do({ |midi|\n",
    "                                    if ((~train_inputs_left[current_note].size == 0), {\n",
    "                                        ~play_control_note.value(method, midi, pan);\n",
    "                                    });\n",
    "                                    task_rhythm.next.wait;\n",
    "                                    current_note = current_note + 1;\n",
    "                                });\n",
    "                            }\n",
    "                        })\n",
    "                      };\n",
    "\n",
    "// Creates control task for right hand for two-hands tasks\n",
    "~setup_control_task_right = { |train_notes, train_rhythms, method, pan = 0.5|\n",
    "                        Task({\n",
    "                            var current_note, task_rhythm = Pseq(train_rhythms, inf).asStream;\n",
    "                            current_note = 0;\n",
    "                            loop {\n",
    "                                train_notes.do({ |midi|\n",
    "                                    if ((~train_inputs_right[current_note].size == 0), {\n",
    "                                        ~play_control_note.value(method, midi, pan);\n",
    "                                    });\n",
    "                                    task_rhythm.next.wait;\n",
    "                                    current_note = current_note + 1;\n",
    "                                });\n",
    "                            }\n",
    "                        })\n",
    "                      };\n",
    "\n",
    "// Defines advanced MIDIdef for noteon messages (signals indicating that a key on the MIDI keyboard is pressed).\n",
    "// Upon pressing a key, the time errors are calculated.\n",
    "// The sonification feedback for early notes is activated when the player hits the key too early.\n",
    "~setup_train_note_on = { |method|\n",
    "                         MIDIdef(\\note_on).free;\n",
    "                         MIDIdef(\\note_on_left).free;\n",
    "                         MIDIdef(\\note_on_right).free; \n",
    "                         MIDIdef.noteOn(\\note_on, {\n",
    "                             |veloc, num, chan, src|\n",
    "                             var error_beat, error_beats, current_train_note;\n",
    "                             ~notes[num] = Synth(\\train_note, [\\freq, num.midicps, \\amp, veloc * 0.00315]);\n",
    "                             error_beats =  ~train_clock.beats - ~solutions_time;\n",
    "                             current_train_note = error_beats.minIndex({|item, i| item.abs});\n",
    "                             error_beat = error_beats[current_train_note];\n",
    "                             ~notes[num].set(\\distortion_length, error_beat * (-1));\n",
    "                             switch(method, \n",
    "                                    0, {},\n",
    "                                    1, { ~notes[num].set(\\amp_reduction_level, 0.8) },\n",
    "                                    2, { ~notes[num].set(\\freq_distort_level, 1) },\n",
    "                                    3, { ~notes[num].set(\\noise_level, 1) });\n",
    "                             ~train_inputs[current_train_note] = ~train_inputs[current_train_note].add([num, ~train_clock.beats]);\n",
    "                         });\n",
    "                       };\n",
    "\n",
    "\n",
    "\n",
    "// Defines advanced MIDIdef for noteon messages for two-hands tasks\n",
    "~setup_train_note_on_2h = { |method|\n",
    "                         MIDIdef(\\note_on).free;\n",
    "                         MIDIdef(\\note_on_left).free;\n",
    "                         MIDIdef(\\note_on_right).free;    \n",
    "                         MIDIdef.noteOn(\\note_on_left, { // Define noteOn function for left note\n",
    "                             |veloc, num, chan, src|\n",
    "                             if( num == ~train_note_left, {\n",
    "                                 var error_beat, error_beats, current_train_note;\n",
    "                                 ~notes[num] = Synth(\\train_note, [\\freq, num.midicps, \\amp, veloc * 0.00315, \\pan, 0]);\n",
    "                                 error_beats =  ~train_clock.beats - ~solutions_time_left;\n",
    "                                 current_train_note = error_beats.minIndex({|item, i| item.abs});\n",
    "                                 error_beat = error_beats[current_train_note];\n",
    "                                 ~notes[num].set(\\distortion_length, error_beat * (-1));\n",
    "                                 switch(method, \n",
    "                                        0, {},\n",
    "                                        1, { ~notes[num].set(\\amp_reduction_level, 0.8) },\n",
    "                                        2, { ~notes[num].set(\\freq_distort_level, 1) },\n",
    "                                        3, { ~notes[num].set(\\noise_level, 1) });\n",
    "                                 ~train_inputs_left[current_train_note] = ~train_inputs_left[current_train_note].add([num, ~train_clock.beats]);\n",
    "                             });\n",
    "                         });\n",
    "                         MIDIdef.noteOn(\\note_on_right, { // Define noteOn function for right note\n",
    "                             |veloc, num, chan, src|\n",
    "                             if( num == ~train_note_right, {\n",
    "                                 var error_beat, error_beats, current_train_note;\n",
    "                                 ~notes[num] = Synth(\\train_note, [\\freq, num.midicps, \\amp, veloc * 0.00315, \\pan, 1]);\n",
    "                                 error_beats =  ~train_clock.beats - ~solutions_time_right;\n",
    "                                 current_train_note = error_beats.minIndex({|item, i| item.abs});\n",
    "                                 error_beat = error_beats[current_train_note];\n",
    "                                 ~notes[num].set(\\distortion_length, error_beat * (-1));\n",
    "                                 switch(method, \n",
    "                                        0, {},\n",
    "                                        1, { ~notes[num].set(\\amp_reduction_level, 0.8) },\n",
    "                                        2, { ~notes[num].set(\\freq_distort_level, 1) },\n",
    "                                        3, { ~notes[num].set(\\noise_level, 1) });\n",
    "                                 ~train_inputs_right[current_train_note] = ~train_inputs_right[current_train_note].add([num, ~train_clock.beats]);\n",
    "                             });\n",
    "                         });    \n",
    "                       };\n",
    "\n",
    "// Resets all MIDIdefs\n",
    "~setup_default_note_on = {\n",
    "                            MIDIdef(\\note_on).free;\n",
    "                            MIDIdef(\\note_on_left).free;\n",
    "                            MIDIdef(\\note_on_right).free;\n",
    "                            MIDIdef.noteOn(\\note_on, { \n",
    "                                |veloc, num, chan, src|\n",
    "                                ~notes[num] = Synth(\\train_note, [\\freq, num.midicps, \\amp, veloc * 0.00315]);\n",
    "                                }\n",
    "                            );\n",
    "                         }"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8c3650fa-443e-4de8-9198-70ca3c0f557e",
   "metadata": {
    "tags": []
   },
   "source": [
    "##### Python classes and functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "9dfb1a47-13fd-4d0e-9308-3bd969abaa8e",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "class TrainingTask:\n",
    "    \"\"\"\n",
    "    A class used to represent a rhythm training task.\n",
    "    \n",
    "    Attributes\n",
    "    ----------\n",
    "    signature: str\n",
    "        the time signature for this task\n",
    "    hands: int\n",
    "        indicates whether the task is played with one hand or both hands\n",
    "    notes: list of int\n",
    "        a list of the notes to be played in the task given as MIDI notation\n",
    "    rhythms: list of float\n",
    "        a list of the time intervals between the notes\n",
    "    offbeats: list of float\n",
    "        a list containing the offsets (for both hands if hands == 2) \n",
    "        between start of the first note and beginning of the first bar\n",
    "    beats_per_bar: int\n",
    "        number of beats contained in one bar\n",
    "    dur_per_beat: float\n",
    "        duration of one beat measured in seconds\n",
    "    \"\"\"\n",
    "    \n",
    "    def __init__(self, signature, hands, notes, rhythms, offbeats):\n",
    "        \"\"\"\n",
    "        Parameters\n",
    "        ----------\n",
    "        signature: str\n",
    "            the time signature for this task\n",
    "        hands: int\n",
    "            indicates whether the task is played with one hand or both hands\n",
    "        notes: list of int\n",
    "            a list of the notes to be played in the task given as MIDI notation\n",
    "        rhythms: list of float\n",
    "            a list of the time intervals between the notes\n",
    "        offbeats: list of float\n",
    "            a list containing the offsets (for both hands if hands == 2) \n",
    "            between start of the first note and beginning of the first bar\n",
    "        \"\"\"\n",
    "        self.signature = signature\n",
    "        self.hands = hands\n",
    "        self.notes = notes\n",
    "        self.rhythms = rhythms\n",
    "        self.offbeats = offbeats\n",
    "        self.beats_per_bar = int(signature.split('/')[0])\n",
    "        self.dur_per_beat = 4 / int(signature.split('/')[1])\n",
    "\n",
    "class TrainingData:\n",
    "    \"\"\"\n",
    "    A class used to store training data for one playthrough.\n",
    "    \n",
    "    Attributes\n",
    "    ----------\n",
    "    task_name: str\n",
    "        name of the TrainingTask that is played in this playthrough\n",
    "    task: TrainingTask\n",
    "        the TrainingTask object named by task_name\n",
    "    method: int\n",
    "        index of sonification method used in this playthrough\n",
    "    bpm: int\n",
    "        tempo (in beats-per-minute) to be followed in this playthrough\n",
    "    run_number: int\n",
    "        index of the playthrough\n",
    "    solutions_note: list of int\n",
    "        list of correct note numbers for every note played in the playthrough\n",
    "    solutions_time: list of float\n",
    "        list of correct time values for every note played in the playthrough\n",
    "    train_inputs: list of list\n",
    "        list of input data recorded from the player, an element in train_inputs\n",
    "        should be in the form [note number in midi (int), note time value (float),\n",
    "        index of slot which the note belongs to (int)]\n",
    "    absolute_errors: list of float\n",
    "        list of absolute time errors, the deviation between note time values\n",
    "        in solutions_time and note time values in train_inputs\n",
    "    relative_errors: list of float, optional\n",
    "        list of relative time errors, the deviation between time intervals\n",
    "        between notes from solutions_time and from time data of train_input\n",
    "    mean_abs: float\n",
    "        mean value of the relative time errors\n",
    "    std_abs: float\n",
    "        standard deviation of the absolute time errors\n",
    "    mear_rel: float\n",
    "        mean value of the relative time errors\n",
    "    std_rel: float\n",
    "        standard deviation of the relative time errors\n",
    "    \"\"\"\n",
    "    \n",
    "    def __init__(self, task_name, task, method, bpm, run_number, solutions_note, solutions_time, train_inputs):\n",
    "        \"\"\"\n",
    "        Parameters\n",
    "        ----------\n",
    "        task_name: str\n",
    "            name of the TrainingTask that is played in this playthrough\n",
    "        task: TrainingTask\n",
    "            the TrainingTask object named by task_name\n",
    "        method: int\n",
    "            index of sonification method used in this playthrough\n",
    "        bpm: int\n",
    "            tempo (in beats-per-minute) to be followed in this playthrough\n",
    "        run_number: int\n",
    "            index of the playthrough\n",
    "        solutions_note: list of int\n",
    "            list of correct note numbers for every note played in the playthrough\n",
    "        solutions_time: list of float\n",
    "            list of correct time values for every note played in the playthrough\n",
    "        train_inputs: list of list\n",
    "            list of input data recorded from the player, an element in train_inputs\n",
    "            should be in the form [note number in midi (int), note time value (float)]\n",
    "        \"\"\"\n",
    "        \n",
    "        self.task_name = task_name\n",
    "        self.task = task\n",
    "        self.method = method\n",
    "        self.bpm = bpm\n",
    "        self.run_number = run_number\n",
    "        self.solutions_note = np.array(solutions_note)\n",
    "        self.solutions_time = np.array(solutions_time)\n",
    "        self.train_inputs = []\n",
    "        for i in range(len(train_inputs)):\n",
    "            for note in train_inputs[i]:\n",
    "                note.append(i)\n",
    "                self.train_inputs.append(note)\n",
    "        self.train_inputs = np.array(self.train_inputs)\n",
    "        self.absolute_errors = []\n",
    "        self.relative_errors = []\n",
    "        self.mean_abs = 0\n",
    "        self.std_abs = 0\n",
    "        self.mean_rel = 0\n",
    "        self.std_rel = 0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "41a584f8-a5f4-45ae-af48-55a89b97e602",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "import os\n",
    "import pickle\n",
    "import time\n",
    "\n",
    "def setup_task_sc(task, settings, method):\n",
    "    \"\"\"Sets up global parameters for a playthrough.\n",
    "    \n",
    "    Parameters\n",
    "    ----------\n",
    "    task: TrainingTask\n",
    "        the TrainingTask object which will be played in this playthrough,\n",
    "        its attributes are inherited to control tempo of the metronome,\n",
    "        one hand or two hands mode etc.\n",
    "    settings: dict\n",
    "        a dictionary containing setting parameters from the GUI\n",
    "    method: int\n",
    "        index of sonification method\n",
    "    \"\"\"\n",
    "    \n",
    "    global bpm, wait_bars, train_bars, allow_error, task_mode, beats_per_bar, dur_per_beat\n",
    "    bpm = settings['bpm']\n",
    "    wait_bars = settings['wait_bars']\n",
    "    train_bars = settings['train_bars']\n",
    "    allow_error = settings['allow_error']\n",
    "    task_mode = settings['task_mode']\n",
    "    beats_per_bar = task.beats_per_bar\n",
    "    dur_per_beat = task.dur_per_beat\n",
    "    %scs ~dur_per_beat = ^dur_per_beat\n",
    "    setup_metronome_sc(task_mode)\n",
    "    if task.hands == 1:\n",
    "        setup_task_1h_sc(task, method)\n",
    "    elif task.hands == 2:\n",
    "        setup_task_2h_sc(task, method)\n",
    "        \n",
    "def setup_metronome_sc(mode):\n",
    "    \"\"\"Sets up metronome that will play along in a playthrough.\n",
    "    \n",
    "    Creates a SuperCollider Task object which plays a drumstick sound\n",
    "    with a certain tempo and time signature.\n",
    "    The volume of the metronome is controlled by the global sc variable\n",
    "    ~metronome_amp.\n",
    "    \n",
    "    Parameters\n",
    "    ----------\n",
    "    mode: str\n",
    "        if the mode is equal 'test', a special pattern of metronome sounds\n",
    "        will be played so that with each passing bar the beats that can be\n",
    "        heard are halved, else a continuously playing metronome is set\n",
    "    \"\"\"\n",
    "    \n",
    "    if mode == 'test':\n",
    "        if beats_per_bar == 4:\n",
    "            sc.lang.cmds(r\"\"\"\n",
    "                ~metronome_amps = Pseq([~metronome_amp], ^wait_bars*^beats_per_bar) ++\n",
    "                                  Pseq([~metronome_amp], ^beats_per_bar) ++ Pseq([~metronome_amp, 0], 2) ++\n",
    "                                  Pseq([~metronome_amp], 1) ++ Pseq([0], ^beats_per_bar-1) ++\n",
    "                                  Pseq([0], inf);\n",
    "            \"\"\")\n",
    "        else:\n",
    "            sc.lang.cmds(r\"\"\"\n",
    "                ~metronome_amps = Pseq([~metronome_amp], ^wait_bars*^beats_per_bar) ++\n",
    "                                  Pseq([~metronome_amp], ^beats_per_bar) ++ \n",
    "                                  Pseq([~metronome_amp], 1) ++ Pseq([0], ^beats_per_bar-1) ++\n",
    "                                  Pseq([0], inf);\n",
    "            \"\"\") \n",
    "    else:\n",
    "        %scs ~metronome_amps = Pseq([~metronome_amp], inf);\n",
    "    sc.lang.cmds(r\"\"\"\n",
    "        ~metronome = Task({\n",
    "            var rate_pattern = Pseq(~metronome_rates.reshape(^beats_per_bar), ^wait_bars + ^train_bars).asStream;\n",
    "            var amp_pattern = ~metronome_amps.asStream;\n",
    "            loop {\n",
    "                Synth(\\play_buf, [buf: ~drumstick_buf, amp: amp_pattern.next, rate: rate_pattern.next]);\n",
    "                1.wait;\n",
    "            }\n",
    "        });\n",
    "    \"\"\")\n",
    "        \n",
    "def setup_task_1h_sc(task, method):\n",
    "    \"\"\"Sets up global parameters in SuperCollider environment \n",
    "    for a playthrough with one-hand task.\n",
    "    \n",
    "    Computes list of correct note numbers and list of correct\n",
    "    note timings (starting at 0) for the entire playthrough.\n",
    "    Sets up sonifications for the given method. ~setup_train_note_on\n",
    "    is used to set up sonification feedback for early notes,\n",
    "    ~control_task is used to set up sonification feedback for late notes.\n",
    "    \n",
    "    Parameters\n",
    "    ----------\n",
    "    task: TrainingTask\n",
    "        the TrainingTask object which will be played\n",
    "    method: int\n",
    "        index of sonification method\n",
    "    \"\"\"\n",
    "    \n",
    "    global train_notes, train_rhythms, train_offbeat, task_mode, use_method\n",
    "    train_notes = task.notes\n",
    "    train_rhythms = task.rhythms\n",
    "    train_offbeat = task.offbeats\n",
    "    use_method = method\n",
    "    sc.lang.cmds(r\"\"\"\n",
    "        var playthrough_duration = ^train_offbeat, number_all_notes = 0, all_note_durs = Pseq(^train_rhythms, inf).asStream, timing_all_notes = List[];\n",
    "        while({playthrough_duration < (^train_bars * ^beats_per_bar)}, {\n",
    "            number_all_notes = number_all_notes + 1;\n",
    "            timing_all_notes.add(playthrough_duration);\n",
    "            playthrough_duration = playthrough_duration + all_note_durs.next;\n",
    "            });\n",
    "        ~number_all_notes = number_all_notes;\n",
    "        ~timing_all_notes = timing_all_notes.array;\n",
    "    \"\"\") \n",
    "    if task_mode == 'demo':\n",
    "        sc.lang.cmds(r\"\"\"\n",
    "            ~control_task = Task({\n",
    "                var task_rhythm = Pseq(^train_rhythms, inf).asStream;\n",
    "                loop {\n",
    "                    ^train_notes.do({ |midi|\n",
    "                    Synth(\\default_note, [\\freq, midi.midicps]);\n",
    "                    task_rhythm.next.wait;\n",
    "                    });\n",
    "                }\n",
    "            })\n",
    "        \"\"\")\n",
    "    elif task_mode == 'train':\n",
    "        if method == 0:\n",
    "            %scs ~control_task = Task({});\n",
    "        else:\n",
    "            %scs ~control_task = ~setup_control_task.value(^train_notes, ^train_rhythms, ^use_method);\n",
    "        %scs ~setup_train_note_on.value(^use_method)\n",
    "    elif task_mode == 'test':\n",
    "        %scs ~setup_train_note_on.value(0)\n",
    "\n",
    "def setup_task_2h_sc(task, method):\n",
    "    \"\"\"Sets up global parameters in SuperCollider environment \n",
    "    for a playthrough with two-hands task.\n",
    "    \n",
    "    Computes lists of correct note numbers and lists of correct\n",
    "    note timings (starting at 0) for the entire playthrough for\n",
    "    both left and right hand.\n",
    "    Sets up sonifications for the given method for both hands. \n",
    "    ~setup_train_note_on_left and ~setup_train_note_on_right\n",
    "    are used to set up sonification feedback for early notes,\n",
    "    ~control_task_left and ~control_task_right are used to \n",
    "    set up sonification feedback for late notes.\n",
    "    \n",
    "    Parameters\n",
    "    ----------\n",
    "    task: TrainingTask\n",
    "        the TrainingTask object which will be played\n",
    "    method: int\n",
    "        index of sonification method\n",
    "    \"\"\"\n",
    "    \n",
    "    global train_notes_left, train_notes_right, train_rhythms_left, train_rhythms_right, train_offbeat_left, train_offbeat_right, task_mode, use_method\n",
    "    train_notes_left = task.notes[0]\n",
    "    train_notes_right = task.notes[1]\n",
    "    train_rhythms_left = task.rhythms[0]\n",
    "    train_rhythms_right = task.rhythms[1]\n",
    "    train_offbeat_left = task.offbeats[0]\n",
    "    train_offbeat_right = task.offbeats[1]\n",
    "    use_method = method\n",
    "    %scs ~train_note_left = ^train_notes_left[0]\n",
    "    %scs ~train_note_right = ^train_notes_right[0]\n",
    "    sc.lang.cmds(r\"\"\"\n",
    "        var playthrough_duration = ^train_offbeat_left, \n",
    "        number_all_notes_left = 0, all_note_durs_left = Pseq(^train_rhythms_left, inf).asStream, timing_all_notes_left = List[],\n",
    "        number_all_notes_right = 0, all_note_durs_right = Pseq(^train_rhythms_right, inf).asStream, timing_all_notes_right = List[];\n",
    "        while({playthrough_duration < (^train_bars * ^beats_per_bar)}, {\n",
    "            number_all_notes_left = number_all_notes_left + 1;\n",
    "            timing_all_notes_left.add(playthrough_duration);\n",
    "            playthrough_duration = playthrough_duration + all_note_durs_left.next;\n",
    "            });\n",
    "        playthrough_duration = ^train_offbeat_right;\n",
    "        while({playthrough_duration < (^train_bars * ^beats_per_bar)}, {\n",
    "            number_all_notes_right = number_all_notes_right + 1;\n",
    "            timing_all_notes_right.add(playthrough_duration);\n",
    "            playthrough_duration = playthrough_duration + all_note_durs_right.next;\n",
    "            });\n",
    "        ~number_all_notes_left = number_all_notes_left;\n",
    "        ~timing_all_notes_left = timing_all_notes_left.array;\n",
    "        ~number_all_notes_right = number_all_notes_right;\n",
    "        ~timing_all_notes_right = timing_all_notes_right.array;\n",
    "    \"\"\")\n",
    "    if task_mode == 'demo':\n",
    "        sc.lang.cmds(r\"\"\"\n",
    "            ~control_task_left = Task({\n",
    "                var task_rhythm = Pseq(^train_rhythms_left, inf).asStream;\n",
    "                loop {\n",
    "                    ^train_notes_left.do({ |midi|\n",
    "                    Synth(\\default_note, [\\freq, midi.midicps, \\pan, 0]);\n",
    "                    task_rhythm.next.wait;\n",
    "                    });\n",
    "                }\n",
    "            });\n",
    "            ~control_task_right = Task({\n",
    "                var task_rhythm = Pseq(^train_rhythms_right, inf).asStream;\n",
    "                loop {\n",
    "                    ^train_notes_right.do({ |midi|\n",
    "                    Synth(\\default_note, [\\freq, midi.midicps, \\pan, 1]);\n",
    "                    task_rhythm.next.wait;\n",
    "                    });\n",
    "                }\n",
    "            });\n",
    "        \"\"\")\n",
    "    elif task_mode == 'train':\n",
    "        if method == 0:\n",
    "            %scs ~control_task_left = Task({});\n",
    "            %scs ~control_task_right = Task({}); \n",
    "        else:\n",
    "            %scs ~control_task_left = ~setup_control_task_left.value(^train_notes_left, ^train_rhythms_left, ^use_method, pan: 0);\n",
    "            %scs ~control_task_right = ~setup_control_task_right.value(^train_notes_right, ^train_rhythms_right, ^use_method, pan: 1);\n",
    "        %scs ~setup_train_note_on_2h.value(^use_method)\n",
    "    elif task_mode == 'test':\n",
    "        %scs ~setup_train_note_on_2h.value(0)\n",
    "\n",
    "def play_task_sc(task):\n",
    "    \"\"\"Starts a playthrough.\n",
    "    \n",
    "    Creates a SuperCollider TempoClock, sets up the tempo\n",
    "    using global parameters that are configured before and\n",
    "    schedules the start of a one-hand task playthrough or\n",
    "    two-hands task playthrough according to the respective\n",
    "    attribute from the TrainingTask object.\n",
    "    \n",
    "    Parameters\n",
    "    ----------\n",
    "    task: TrainingTask\n",
    "        the TrainingTask object which will be played in this\n",
    "        playthrough\n",
    "    \"\"\"\n",
    "    \n",
    "    %scs ~train_clock = TempoClock.new\n",
    "    %scs ~train_clock.tempo = ^bpm/60\n",
    "    if task.hands == 1:\n",
    "        play_task_1h_sc()\n",
    "    elif task.hands == 2:\n",
    "        play_task_2h_sc()            \n",
    "            \n",
    "def play_task_1h_sc():\n",
    "    \"\"\"Starts a one-hand task playthrough.\n",
    "    \n",
    "    Uses the TempoClock defined in previous function to schedule\n",
    "    events.\n",
    "    Starts the metronome and activates interactive sonification feedback.\n",
    "    \"\"\"\n",
    "    \n",
    "    sc.lang.cmds(r\"\"\"\n",
    "        ~train_clock.schedAbs(~train_clock.beats.ceil, {\n",
    "            ~train_inputs = ([]!~number_all_notes);\n",
    "            ~solutions_time = ~timing_all_notes + ((~train_clock.beats + (^wait_bars * ^beats_per_bar)) ! ~number_all_notes);\n",
    "            ~solutions_note = Pseq(^train_notes, inf).asStream.nextN(~number_all_notes);\n",
    "            ~metronome.play(~train_clock);\n",
    "            if((^task_mode != \"test\"), {\n",
    "                ~train_clock.schedAbs(~train_clock.beats + (^wait_bars * ^beats_per_bar) + ^train_offbeat + ^allow_error, {\n",
    "                    ~control_task.play(~train_clock);\n",
    "                })\n",
    "            });\n",
    "            ~train_clock.sched((^wait_bars + ^train_bars) * ^beats_per_bar - 0.01, {\n",
    "                ~metronome.stop;\n",
    "            });      \n",
    "            ~train_clock.sched((^wait_bars + ^train_bars) * ^beats_per_bar + ^allow_error - 0.01, {\n",
    "                ~control_task.stop;  \n",
    "                ~setup_default_note_on.value;\n",
    "                ~train_clock.stop;\n",
    "            })\n",
    "        });\n",
    "    \"\"\")    \n",
    "    \n",
    "def play_task_2h_sc():\n",
    "    \"\"\"Starts a two-hands task playthrough.\n",
    "    \n",
    "    Uses the TempoClock defined in previous function to schedule\n",
    "    events for left and right hand.\n",
    "    Starts the metronome and activates interactive sonification feedback.\n",
    "    \"\"\"\n",
    "    \n",
    "    sc.lang.cmds(r\"\"\"\n",
    "        ~train_clock.schedAbs(~train_clock.beats.ceil, {\n",
    "            ~train_inputs_left = ([]!~number_all_notes_left); ~train_inputs_right = ([]!~number_all_notes_right);\n",
    "            ~solutions_time_left = ~timing_all_notes_left + ((~train_clock.beats + (^wait_bars * ^beats_per_bar)) ! ~number_all_notes_left);\n",
    "            ~solutions_time_right = ~timing_all_notes_right + ((~train_clock.beats + (^wait_bars * ^beats_per_bar)) ! ~number_all_notes_right);\n",
    "            ~solutions_note_left = Pseq(^train_notes_left, inf).asStream.nextN(~number_all_notes_left);\n",
    "            ~solutions_note_right = Pseq(^train_notes_right, inf).asStream.nextN(~number_all_notes_right);\n",
    "            ~metronome.play(~train_clock);\n",
    "            if((^task_mode != \"test\"), {\n",
    "                ~train_clock.schedAbs(~train_clock.beats + (^wait_bars * ^beats_per_bar) + ^train_offbeat_left + ^allow_error, {\n",
    "                    ~control_task_left.play(~train_clock);\n",
    "                });\n",
    "                ~train_clock.schedAbs(~train_clock.beats + (^wait_bars * ^beats_per_bar) + ^train_offbeat_right + ^allow_error, {\n",
    "                    ~control_task_right.play(~train_clock);\n",
    "                })\n",
    "            });\n",
    "            ~train_clock.sched((^wait_bars + ^train_bars) * ^beats_per_bar - 0.01, {\n",
    "                ~metronome.stop;\n",
    "            }); \n",
    "            ~train_clock.sched((^wait_bars + ^train_bars) * ^beats_per_bar + ^allow_error - 0.01, {\n",
    "                ~control_task_left.stop; ~control_task_right.stop;\n",
    "                ~setup_default_note_on.value;\n",
    "                ~train_clock.stop;\n",
    "            })\n",
    "        });\n",
    "    \"\"\")\n",
    "\n",
    "def collect_training_data(participant_id, training_data_list, task_name, task, method, bpm, run_number):\n",
    "    \"\"\"Retrieves playthrough information stored in global parameters\n",
    "    in the SuperCollider environment. Creates a TrainingData object\n",
    "    and saves the information inside it.\n",
    "    \n",
    "    Parameters\n",
    "    ----------\n",
    "    participant_id: str\n",
    "        a unique random id for naming the save file\n",
    "    training_data_list: list of TrainingData\n",
    "        a list to which the created TrainingData will be added\n",
    "    task_name: str\n",
    "        name of the TrainingTask that is played in this playthrough\n",
    "    task: TrainingTask\n",
    "        the TrainingTask object named by task_name\n",
    "    method: int\n",
    "        index of sonification method used in this playthrough\n",
    "    bpm: int\n",
    "        tempo (in beats-per-minute) to be followed in this playthrough\n",
    "    run_number: int\n",
    "        index of the playthrough\n",
    "    \"\"\"\n",
    "    \n",
    "    if task.hands == 1:\n",
    "        solutions_note_all = %scgs ~solutions_note\n",
    "        solutions_time_all = %scgs ~solutions_time\n",
    "        train_inputs_all = %scgs ~train_inputs\n",
    "    elif task.hands == 2:\n",
    "        solutions_note_left = %scgs ~solutions_note_left\n",
    "        solutions_note_right = %scgs ~solutions_note_right\n",
    "        solutions_time_left = %scgs ~solutions_time_left\n",
    "        solutions_time_right = %scgs ~solutions_time_right\n",
    "        train_inputs_left = %scgs ~train_inputs_left\n",
    "        train_inputs_right = %scgs ~train_inputs_right\n",
    "        solutions_note_all = [solutions_note_left, solutions_note_right]\n",
    "        solutions_time_all = [solutions_time_left, solutions_time_right]\n",
    "        train_inputs_all = [train_inputs_left, train_inputs_right]\n",
    "    \n",
    "    new_training_data = TrainingData(task_name, task, method, bpm, run_number, solutions_note_all, solutions_time_all, train_inputs_all)\n",
    "    training_data_list.append(new_training_data)\n",
    "    save_data_to_file(new_training_data, './' + participant_id, task_name)\n",
    "\n",
    "def save_data_to_file(data, path, name):\n",
    "    \"\"\"Saves data to a file via pickle.\n",
    "    \n",
    "    Parameters\n",
    "    ----------\n",
    "    data: any\n",
    "        data to be saved\n",
    "    path: str\n",
    "        path to the directory where the file is saved\n",
    "    name: str\n",
    "        name for the created file\n",
    "    \"\"\"\n",
    "    if not os.path.exists(path):\n",
    "        os.makedirs(path, exist_ok=True)\n",
    "    f = open(path + '/' + name + '_' + time.strftime('%b%d%Y_%H%M%S', time.localtime()), 'wb')\n",
    "    pickle.dump(data, f)\n",
    "    f.close()\n",
    "\n",
    "def load_data_from_file(filename):\n",
    "    \"\"\"Loads data from a file via pickle.\n",
    "    \n",
    "    Parameters\n",
    "    ----------\n",
    "    filename: str\n",
    "        name of the file to be read\n",
    "    \"\"\"\n",
    "    \n",
    "    result = None\n",
    "    with (open(filename, \"rb\")) as f:\n",
    "        result = pickle.load(f)\n",
    "    return result"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f567cdee-7a87-40bd-882f-582cee88beb6",
   "metadata": {
    "tags": []
   },
   "source": [
    "##### GUI elements"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "c72161cc-1154-4620-868b-a664a198098b",
   "metadata": {},
   "outputs": [],
   "source": [
    "import ipywidgets as widgets\n",
    "import time\n",
    "from time import sleep\n",
    "\n",
    "############################\n",
    "### FUNCTION DEFINITIONS ###\n",
    "############################\n",
    "def demo_sound(b):\n",
    "    \"\"\"Plays a default piano note in middle c for 1.5 seconds\"\"\"\n",
    "    \n",
    "    %scs x = Synth(\\train_note, [\\freq, 60.midicps])\n",
    "    sleep(1.5)\n",
    "    %scs x.release\n",
    "\n",
    "def test_sound_method1_early(b):\n",
    "    \"\"\"Plays a default piano note in middle c with the first\n",
    "    sonification feedback method, treated as a note played\n",
    "    too early for half second.\n",
    "    \"\"\"\n",
    "    \n",
    "    %scs x = Synth(\\train_note, [\\freq, 60.midicps, \\distortion_length, 0.5, \\amp_reduction_level, 0.8])\n",
    "    sleep(1.5)\n",
    "    %scs x.release\n",
    "\n",
    "def test_sound_method1_late(b):\n",
    "    \"\"\"Plays a signal sound as described in the first\n",
    "    sonification feedback method.\n",
    "    \"\"\"\n",
    "    \n",
    "    %scs Synth(\\default_note, [\\freq, 60.midicps])\n",
    "\n",
    "def test_sound_method2_early(b):\n",
    "    \"\"\"Plays a default piano note in middle c with the second\n",
    "    sonification feedback method, treated as a note played\n",
    "    too early for half second.\n",
    "    \"\"\"\n",
    "    \n",
    "    %scs x = Synth(\\train_note, [\\freq, 60.midicps, \\distortion_length, 0.5, \\freq_distort_level, 1])\n",
    "    sleep(1.5)\n",
    "    %scs x.release\n",
    "\n",
    "def test_sound_method2_late(b):\n",
    "    \"\"\"Plays a signal sound as described in the second\n",
    "    sonification feedback method.\n",
    "    \"\"\"\n",
    "    \n",
    "    %scs Synth(\\blip, [\\freq, 60.midicps])\n",
    "    \n",
    "def test_sound_method3_early(b):\n",
    "    \"\"\"Plays a default piano note in middle c with the third\n",
    "    sonification feedback method, treated as a note played\n",
    "    too early for half second.\n",
    "    \"\"\"\n",
    "    \n",
    "    %scs x = Synth(\\train_note, [\\freq, 60.midicps, \\distortion_length, 0.5, \\noise_level, 1])\n",
    "    sleep(1.5)\n",
    "    %scs x.release\n",
    "\n",
    "def test_sound_method3_late(b):  \n",
    "    \"\"\"Plays a signal sound as described in the third\n",
    "    sonification feedback method.\n",
    "    \"\"\"\n",
    "    \n",
    "    %scs Synth(\\tick)\n",
    "    \n",
    "#################\n",
    "### GUI SETUP ###\n",
    "#################    \n",
    "play_demo_note = widgets.Button(description='Play demo note')\n",
    "play_demo_note.on_click(demo_sound)\n",
    "\n",
    "method1_early = widgets.Button(description='Early')\n",
    "method1_early.on_click(test_sound_method1_early)\n",
    "method1_late = widgets.Button(description='Late')\n",
    "method1_late.on_click(test_sound_method1_late)\n",
    "\n",
    "method2_early = widgets.Button(description='Early')\n",
    "method2_early.on_click(test_sound_method2_early)\n",
    "method2_late = widgets.Button(description='Late')\n",
    "method2_late.on_click(test_sound_method2_late)\n",
    "\n",
    "method3_early = widgets.Button(description='Early')\n",
    "method3_early.on_click(test_sound_method3_early)\n",
    "method3_late = widgets.Button(description='Late')\n",
    "method3_late.on_click(test_sound_method3_late)\n",
    "\n",
    "demo_sound_panel = widgets.GridBox([widgets.HTML('<b>Demo note:</b>'), play_demo_note], layout=widgets.Layout(grid_template_columns='repeat(2, 200px)'))\n",
    "test_sounds_panel = widgets.GridBox([\n",
    "    widgets.HTML('<b>Method 1:</b>'), method1_early, method1_late,\n",
    "    widgets.HTML('<b>Method 2:</b>'), method2_early, method2_late,\n",
    "    widgets.HTML('<b>Method 3:</b>'), method3_early, method3_late,], layout=widgets.Layout(grid_template_columns='repeat(3, 200px)'))\n",
    "test_sounds_menu = widgets.VBox([demo_sound_panel, test_sounds_panel])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "e1acad07-e02c-4d8e-8045-25575f853268",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "import ipywidgets as widgets\n",
    "from fractions import Fraction\n",
    "import time\n",
    "import random\n",
    "import string\n",
    "\n",
    "participant_id = 'dummy'\n",
    "task_list = {}\n",
    "training_data = []\n",
    "method_list = [('No method', 0), ('Method 1', 1), ('Method 2', 2), ('Method 3', 3)]\n",
    "experiment_tasks_hard = {\n",
    "                    'Task 0': TrainingTask('4/4', 1, [60], [1/2, 1, 1/2, 2], 0),\n",
    "                    'Task 1': TrainingTask('4/4', 1, [60], [1, 1/2, 3/2, 1], 0),\n",
    "                    'Task 2': TrainingTask('4/4', 1, [60], [1/2, 1, 1, 3/2], 0.5),\n",
    "                    'Task 3': TrainingTask('4/4', 1, [60], [1, 1/2, 1/2, 2], 1)}\n",
    "\n",
    "experiment_tasks_easy = {\n",
    "                    'Task 0': TrainingTask('4/4', 1, [60], [1, 1, 2], 0),\n",
    "                    'Task 1': TrainingTask('4/4', 1, [60], [1, 2, 1], 0),\n",
    "                    'Task 2': TrainingTask('4/4', 1, [60], [2, 1, 1], 0),\n",
    "                    'Task 3': TrainingTask('4/4', 1, [60], [1, 1, 2], 1)}\n",
    "\n",
    "experiment_bpm = 60\n",
    "experiment_wait_bars = 1\n",
    "experiment_train_bars = 4\n",
    "experiment_allow_error = 0.05\n",
    "runs_per_routine = 2\n",
    "current_run_number = 0\n",
    "experiment_mode = False\n",
    "\n",
    "############################\n",
    "### FUNCTION DEFINITIONS ###\n",
    "############################\n",
    "\n",
    "# General functions used by the GUI\n",
    "def get_playthrough_duration():\n",
    "    \"\"\"Returns playthrough duration.\n",
    "    \n",
    "    Returns\n",
    "    -------\n",
    "    float\n",
    "        length of the full playthrough in seconds\n",
    "    \"\"\"\n",
    "    return 60/bpm_setting.value * (wait_bars_setting.value+train_bars_setting.value) * int(signature_setting.value.split('/')[0])\n",
    "\n",
    "def play_task(mode):\n",
    "    \"\"\"Retrieves settings, sets up and starts a training task.\n",
    "    \n",
    "    Parameters\n",
    "    ----------\n",
    "    mode: str\n",
    "        the training mode in this playthrough,\n",
    "        it can be 'demo', 'test' or 'train'\n",
    "            demo: only listen to the rhythm\n",
    "            test: perform the rhythm without help\n",
    "            train: train the rhythm with (or without) auditory feedback\n",
    "    \"\"\"\n",
    "    \n",
    "    settings = {'task_mode': mode,\n",
    "                'bpm': bpm_setting.value,\n",
    "                'wait_bars': wait_bars_setting.value,\n",
    "                'train_bars': train_bars_setting.value,\n",
    "                'allow_error': allow_error_setting.value\n",
    "               }\n",
    "    if mode == 'demo':\n",
    "        settings.update({'allow_error': 0})\n",
    "    setup_task_sc(task_list[select_task.value], settings, select_method.value)\n",
    "    play_task_sc(task_list[select_task.value])\n",
    "\n",
    "def disable_settings():\n",
    "    \"\"\"Disables task settings and general settings in the GUI.\"\"\"\n",
    "    \n",
    "    add_save_task_button.disabled = True\n",
    "    delete_task_button.disabled = True\n",
    "    select_task.disabled = True\n",
    "    select_method.disabled = True\n",
    "    bpm_setting.disabled = True\n",
    "    wait_bars_setting.disabled = True\n",
    "    train_bars_setting.disabled = True\n",
    "    allow_error_setting.disabled = True\n",
    "    \n",
    "def enable_settings():\n",
    "    \"\"\"Enables task settings and general settings in the GUI.\"\"\"\n",
    "    \n",
    "    add_save_task_button.disabled = False\n",
    "    delete_task_button.disabled = False\n",
    "    select_task.disabled = False\n",
    "    select_method.disabled = False\n",
    "    bpm_setting.disabled = False\n",
    "    wait_bars_setting.disabled = False\n",
    "    train_bars_setting.disabled = False\n",
    "    allow_error_setting.disabled = False\n",
    "    \n",
    "def disable_plays():\n",
    "    \"\"\"Disable buttons in the GUI\"\"\"\n",
    "    \n",
    "    play_demo_button.disabled = True\n",
    "    start_test_button.disabled = True\n",
    "    start_training_button.disabled = True\n",
    "        \n",
    "def enable_plays():\n",
    "    \"\"\"Enable buttons in the GUI\"\"\"\n",
    "    \n",
    "    play_demo_button.disabled = False\n",
    "    start_test_button.disabled = False\n",
    "    start_training_button.disabled = False\n",
    "    \n",
    "    \n",
    "# Functions for controlling the experiment procedure\n",
    "def start_new_experiment(experiment_tasks):\n",
    "    \"\"\"Starts a new experiment with a set of experiment tasks.\n",
    "    \n",
    "    Sets up and re-initializes global parameters.\n",
    "    \n",
    "    Parameters\n",
    "    ----------\n",
    "    experiment_tasks: list of TrainingTask\n",
    "        list of training tasks to be performed in this experiment\n",
    "    \"\"\"\n",
    "    \n",
    "    global task_list, training_data, experiment_mode\n",
    "    task_list = experiment_tasks\n",
    "    training_data = []\n",
    "    disable_settings()\n",
    "    experiment_mode = True\n",
    "    \n",
    "def start_new_routine():\n",
    "    \"\"\"Starts a new training routine for the current task selected.\n",
    "    \n",
    "    Re-initializes global parameters and adjusts GUI elements.\n",
    "    \"\"\"\n",
    "    \n",
    "    global current_run_number\n",
    "    disable_plays()\n",
    "    current_run_number = 0\n",
    "    run_counter.value = '1. test'\n",
    "    play_demo_button.disabled = False\n",
    "    start_test_button.disabled = False\n",
    "    next_task_button.disabled = True\n",
    "\n",
    "def proceed_to_next_phase(last_action):\n",
    "    \"\"\"Updates the state after a playthrough is completed.\n",
    "    \n",
    "    Keeps track of the total number of playthroughs performed\n",
    "    for the current task selected.\n",
    "    Switches to training phase if the 1. testing phase is\n",
    "    completed, switches to 2. testing phase if the training\n",
    "    phase is completed, etc.\n",
    "    \n",
    "    Parameters\n",
    "    ----------\n",
    "    last_action: str\n",
    "        type of the last playthrough that just completed\n",
    "    \"\"\"\n",
    "    \n",
    "    global current_run_number\n",
    "    if last_action == 'Play Demo':\n",
    "        play_demo_button.disabled = False\n",
    "        if current_run_number == 0 or current_run_number == runs_per_routine + 1:\n",
    "            start_test_button.disabled = False\n",
    "        else:\n",
    "            start_training_button.disabled = False\n",
    "    elif last_action == 'Start Test':\n",
    "        if current_run_number == 0:\n",
    "            play_demo_button.disabled = False\n",
    "            start_training_button.disabled = False\n",
    "            current_run_number += 1\n",
    "            run_counter.value = str(current_run_number)\n",
    "        elif select_task.index < len(select_task.options) - 1:     # End of routine reached\n",
    "            next_task_button.disabled = False\n",
    "            run_counter.value = 'End of this routine. Please proceed to the next task.'\n",
    "        else:                                                      # End of whole experiment reached\n",
    "            run_counter.value = 'End of this experiment. You can see results or quit.'\n",
    "            view_results_button.disabled = False\n",
    "    elif last_action == 'Start Training':\n",
    "        play_demo_button.disabled = False\n",
    "        if current_run_number < runs_per_routine:\n",
    "            start_training_button.disabled = False\n",
    "            current_run_number += 1\n",
    "            run_counter.value = str(current_run_number)\n",
    "        else:\n",
    "            start_test_button.disabled = False\n",
    "            current_run_number += 1\n",
    "            run_counter.value = '2. test'\n",
    "    \n",
    "def quit_experiment():\n",
    "    \"\"\"Quits the current experiment.\"\"\"\n",
    "    \n",
    "    global task_list, training_data, experiment_mode\n",
    "    task_list = {}\n",
    "    training_data = []\n",
    "    enable_settings()\n",
    "    enable_plays()\n",
    "    experiment_mode = False   \n",
    "    \n",
    "    \n",
    "# Event functions\n",
    "def add_save_task_from_gui(b):\n",
    "    \"\"\"Adds or saves a task with parameters defined in task settings\n",
    "    to the global task list.\n",
    "    \"\"\"\n",
    "    \n",
    "    if hand_settings.selected_index == 0:\n",
    "        task_list.update({task_name.value : TrainingTask(\n",
    "            signature_setting.value, 1, \n",
    "            [int(x) for x in notes_setting.value.split(',')], \n",
    "            [float(Fraction(x)) for x in rhythms_setting.value.split(',')],\n",
    "            float(Fraction(offbeat_setting.value))\n",
    "        )})\n",
    "    else:\n",
    "        task_list.update({task_name.value : TrainingTask(\n",
    "            signature_setting.value, 2,\n",
    "            [[int(x) for x in note_left_setting.value.split(',')], [int(x) for x in note_right_setting.value.split(',')]],\n",
    "            [[float(Fraction(x)) for x in rhythm_left_setting.value.split(',')], [float(Fraction(x)) for x in rhythm_right_setting.value.split(',')]],\n",
    "            [float(Fraction(offbeat_left_setting.value)), float(Fraction(offbeat_right_setting.value))]\n",
    "        )})\n",
    "    select_task.options = task_list.keys()\n",
    "\n",
    "def delete_task_from_gui(b):\n",
    "    \"\"\"Deletes the task with task name given in the task settings\n",
    "    from the global task list.\n",
    "    \"\"\"\n",
    "    \n",
    "    task_list.pop(task_name.value)\n",
    "    select_task.options = task_list.keys()\n",
    "\n",
    "def play_task_from_gui(b): \n",
    "    \"\"\"Starts a playthrough with the currently selected task.\n",
    "    \n",
    "    Depending on which button is pressed, the playthrough will\n",
    "    be performed with one of the following modes:\n",
    "        demo: only listen to the rhythm\n",
    "        test: perform the rhythm without help\n",
    "        train: train the rhythm with (or without) auditory feedback\n",
    "    \"\"\"\n",
    "    \n",
    "    if select_task.value != None: \n",
    "        if b.description == 'Play Demo':\n",
    "            play_task('demo')\n",
    "        elif b.description == 'Start Test':\n",
    "            play_task('test')\n",
    "        elif b.description == 'Start Training':\n",
    "            if select_method.value == None: return\n",
    "            else: play_task('train')\n",
    "        playthrough_duration = get_playthrough_duration() \n",
    "        disable_plays()\n",
    "        time.sleep(playthrough_duration + 1)\n",
    "        if b.description != 'Play Demo':\n",
    "            collect_training_data(participant_id, training_data, select_task.value, task_list[select_task.value], \n",
    "                                  select_method.value, bpm_setting.value, current_run_number)\n",
    "        if experiment_mode == False:\n",
    "            enable_plays()\n",
    "        else:\n",
    "            proceed_to_next_phase(b.description)\n",
    "\n",
    "def start_experiment_from_gui(b):\n",
    "    \"\"\"Creates a new participant id and starts a new experiment.\"\"\"\n",
    "    \n",
    "    global runs_per_routine, participant_id\n",
    "    participant_id = ''.join([random.choice(string.ascii_letters + string.digits) for n in range(8)])\n",
    "    if hard_mode_toggle.value == True:\n",
    "        start_new_experiment(experiment_tasks_hard)\n",
    "        runs_per_routine = 3\n",
    "    else:     \n",
    "        start_new_experiment(experiment_tasks_easy)\n",
    "        runs_per_routine = 4\n",
    "    bpm_setting.value = experiment_bpm\n",
    "    wait_bars_setting.value = experiment_wait_bars\n",
    "    train_bars_setting.value = experiment_train_bars\n",
    "    allow_error_setting.value = experiment_allow_error\n",
    "    select_task.options = task_list.keys()\n",
    "    select_task.index = 0\n",
    "    select_method.index = 0\n",
    "    start_new_routine()\n",
    "    start_experiment_button.disabled = True\n",
    "    quit_experiment_button.disabled = False\n",
    "\n",
    "def proceed_to_next_task(b):\n",
    "    \"\"\"Selects the next task (if there are any) in the task list\n",
    "    and starts a new training routine. This method is only used\n",
    "    during an experiment.\n",
    "    \"\"\"\n",
    "    if select_task.index < len(select_task.options):\n",
    "        select_task.index += 1\n",
    "        select_method.index += 1\n",
    "        start_new_routine()\n",
    "\n",
    "def quit_experiment_from_gui(b):\n",
    "    \"\"\"Quit the current experiment.\"\"\"\n",
    "    \n",
    "    quit_experiment()\n",
    "    start_experiment_button.disabled = False\n",
    "    quit_experiment_button.disabled = True\n",
    "    view_results_button.disabled = True\n",
    "    select_task.options = task_list.keys()\n",
    "\n",
    "def view_results(b):\n",
    "    \"\"\"Saves training data to file and plots the result.\"\"\"\n",
    "    \n",
    "    if len(training_data) > 0:\n",
    "        save_data_to_file(training_data, './experiment_data', participant_id)\n",
    "        plot_all_training_data(training_data)\n",
    "\n",
    "#################\n",
    "### GUI SETUP ###\n",
    "#################\n",
    "\n",
    "# Task Settings\n",
    "signature_setting = widgets.Combobox(options=[('2/4'), ('3/4'), ('4/4')],value='4/4')\n",
    "\n",
    "\n",
    "# Settings for 1-hand tasks\n",
    "notes_setting = widgets.Text(value='60')\n",
    "rhythms_setting = widgets.Text(value='1')\n",
    "offbeat_setting = widgets.Text(value='0', layout=widgets.Layout(width='50px'))\n",
    "\n",
    "one_hand_settings = widgets.GridBox([\n",
    "    widgets.Label('Notes:'), notes_setting,\n",
    "    widgets.Label('Rhythm:'), rhythms_setting,\n",
    "    widgets.Label('Offbeat:'), offbeat_setting\n",
    "    ], layout=widgets.Layout(grid_template_columns='repeat(6, auto)'))\n",
    "\n",
    "\n",
    "# Settings for 2-hands tasks\n",
    "note_left_setting = widgets.Text(value='48')\n",
    "note_right_setting = widgets.Text(value='60')\n",
    "\n",
    "rhythm_left_setting = widgets.Text(value='1')\n",
    "rhythm_right_setting = widgets.Text(value='1')\n",
    "\n",
    "offbeat_left_setting = widgets.Text(value='0', layout=widgets.Layout(width='50px'))\n",
    "offbeat_right_setting = widgets.Text(value='0', layout=widgets.Layout(width='50px'))\n",
    "\n",
    "info_two_hands = widgets.HTML(value='<p><b>Training with two hands only supports tapping a single note per hand.</b><br>Please assign two different notes for the right and the left hand. (Default settings are C for the right hand and CC for the left hand.)</p>')\n",
    "\n",
    "two_hands_settings = widgets.GridBox([\n",
    "    widgets.Label('Left hand note:'), note_left_setting,\n",
    "    widgets.Label('Right hand note:'), note_right_setting,\n",
    "    widgets.Label('Left hand rhythm:'), rhythm_left_setting,\n",
    "    widgets.Label('Right hand rhythm:'), rhythm_right_setting,\n",
    "    widgets.Label('Left hand offbeat:'), offbeat_left_setting,\n",
    "    widgets.Label('Right hand offbeat:'), offbeat_right_setting,\n",
    "    ], layout=widgets.Layout(grid_template_columns='repeat(4, auto)'))\n",
    "\n",
    "\n",
    "# Combining settings into one tab\n",
    "hand_settings = widgets.Tab(children=[one_hand_settings, widgets.VBox([info_two_hands, two_hands_settings])], selected_index=0)\n",
    "hand_settings.set_title(0, '1-hand')\n",
    "hand_settings.set_title(1, '2-hands')\n",
    "\n",
    "\n",
    "# Add, save and delete task\n",
    "task_name = widgets.Text()\n",
    "\n",
    "add_save_task_button = widgets.Button(\n",
    "    description='Add / Save Task',\n",
    "    button_style='info',\n",
    "    tooltip='Create a new task or update the task with the given name',\n",
    "    icon='plus'\n",
    ")\n",
    "add_save_task_button.on_click(add_save_task_from_gui)\n",
    "\n",
    "delete_task_button = widgets.Button(\n",
    "    description='Delete Task',\n",
    "    button_style='danger',\n",
    "    tooltip='Delete the task with the given name',\n",
    "    icon='times'\n",
    ")\n",
    "delete_task_button.on_click(delete_task_from_gui)\n",
    "\n",
    "task_settings = widgets.VBox([widgets.HBox([widgets.Label('Signature:'), signature_setting,]),\n",
    "                              hand_settings, \n",
    "                              widgets.HBox([widgets.Label('Name:'), task_name, add_save_task_button, delete_task_button])\n",
    "                             ])\n",
    "\n",
    "\n",
    "# General Settings\n",
    "bpm_setting = widgets.IntSlider(value=60, min=30, max=200, description='BPM:')\n",
    "wait_bars_setting = widgets.IntSlider(value=1, min=1, max=4, description='Wait:')\n",
    "train_bars_setting = widgets.IntSlider(value=1, min=1, max=10, description='Train:')\n",
    "allow_error_setting = widgets.FloatSlider(value=0.05, step=0.01, min=0, max=0.5, description='Allow error:')\n",
    "\n",
    "general_settings = widgets.VBox([bpm_setting, \n",
    "                                 widgets.HBox([wait_bars_setting, widgets.Label('bars')]), \n",
    "                                 widgets.HBox([train_bars_setting, widgets.Label('bars')]),\n",
    "                                 widgets.HBox([allow_error_setting, widgets.Label('beat')])\n",
    "                                ])\n",
    "\n",
    "\n",
    "# Combining settings into one accordion\n",
    "settings = widgets.Accordion(children=[task_settings, general_settings], selected_index=None)\n",
    "settings.set_title(0, 'Task Settings')\n",
    "settings.set_title(1, 'General Settings')\n",
    "\n",
    "\n",
    "# Main layout for testing and training\n",
    "play_demo_button = widgets.Button(\n",
    "    description='Play Demo',\n",
    "    button_style='',\n",
    "    tooltip='Hear the full task',\n",
    "    icon='music'\n",
    ")\n",
    "play_demo_button.on_click(play_task_from_gui)\n",
    "\n",
    "start_test_button = widgets.Button(\n",
    "    description='Start Test',\n",
    "    button_style='info',\n",
    "    tooltip='Start the test',\n",
    "    icon='play'\n",
    ")\n",
    "start_test_button.on_click(play_task_from_gui)\n",
    "\n",
    "start_training_button = widgets.Button(\n",
    "    description='Start Training',\n",
    "    button_style='warning',\n",
    "    tooltip='Start training session for the task',\n",
    "    icon='dumbbell'\n",
    ")\n",
    "start_training_button.on_click(play_task_from_gui)\n",
    "\n",
    "next_task_button = widgets.Button(\n",
    "    description='Next Task',\n",
    "    button_style='success',\n",
    "    tooltip='Proceed to the next task',\n",
    "    icon='forward',\n",
    "    disabled=True\n",
    ")\n",
    "next_task_button.on_click(proceed_to_next_task)\n",
    "\n",
    "hard_mode_toggle = widgets.ToggleButton(\n",
    "    value=False,\n",
    "    description='Hard Mode',\n",
    "    disabled=False,\n",
    "    button_style='',\n",
    "    tooltip='Toggle to start an experiment with more complex tasks',\n",
    "    icon='bomb'\n",
    ")\n",
    "\n",
    "start_experiment_button = widgets.Button(\n",
    "    description='Start New Experiment',\n",
    "    button_style='success',\n",
    "    tooltip='Play through a serie of experiment tasks',\n",
    "    icon='plus',\n",
    "    layout=widgets.Layout(width='auto')\n",
    ")\n",
    "start_experiment_button.on_click(start_experiment_from_gui)\n",
    "\n",
    "quit_experiment_button = widgets.Button(\n",
    "    description='Quit Experiment',\n",
    "    button_style='danger',\n",
    "    tooltip='Quit experiment',\n",
    "    icon='door-open',\n",
    "    disabled=True\n",
    ")\n",
    "quit_experiment_button.on_click(quit_experiment_from_gui)\n",
    "\n",
    "view_results_button = widgets.Button(\n",
    "    description='View Results',\n",
    "    button_style='info',\n",
    "    tooltip='Quit experiment',\n",
    "    icon='chart-line',\n",
    "    disabled=True\n",
    ")\n",
    "view_results_button.on_click(view_results)\n",
    "\n",
    "select_task = widgets.Dropdown(options=task_list.keys(), description=\"Task:\")\n",
    "select_method = widgets.Dropdown(options=method_list, description=\"Method:\")\n",
    "run_counter = widgets.Label(str(current_run_number))\n",
    "\n",
    "api_gui = widgets.VBox([settings, \n",
    "                        widgets.HBox([hard_mode_toggle, start_experiment_button, quit_experiment_button, view_results_button]), \n",
    "                        widgets.HBox([select_task, play_demo_button, start_test_button, next_task_button]), \n",
    "                        widgets.HBox([select_method, start_training_button, widgets.Label('Current run:'), run_counter])])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "76f6d266-c5ff-489a-b589-afde471134f9",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "%matplotlib widget\n",
    "import ipywidgets as widgets\n",
    "import matplotlib.pyplot as plt\n",
    "from matplotlib.lines import Line2D\n",
    "\n",
    "sorted_training_data = {}\n",
    "round_decimal = 6\n",
    "input_selected = []\n",
    "input_selected_fig = None\n",
    "input_selected_ax = None\n",
    "ax_err_ylim = [-0.5, 1]\n",
    "\n",
    "############################\n",
    "### FUNCTION DEFINITIONS ###\n",
    "############################\n",
    "\n",
    "# General functions used by the GUI\n",
    "def compute_absolute_training_errors(solutions, train_inputs, missed_input_error):\n",
    "    \"\"\"Computes absolute time errors between a list of solutions\n",
    "    and a list of input values.\n",
    "    \n",
    "    Parameters\n",
    "    ----------\n",
    "    solutions: list of float\n",
    "        a list of time values indicating the correct time for each note\n",
    "        in a playthrough\n",
    "    train_inputs: list of list\n",
    "        a list of all inputs made by the player\n",
    "    missed_input_error: float\n",
    "        a default error value to be added when the player has missed\n",
    "        the note completely\n",
    "    \n",
    "    Returns\n",
    "    -------\n",
    "    absolutes: list of float\n",
    "        a list of absolute time errors\n",
    "    \"\"\"\n",
    "    \n",
    "    absolutes = [[] for _ in range(len(solutions))]\n",
    "    for train_input in train_inputs:\n",
    "        index = int(train_input[2])\n",
    "        absolute_error = np.abs(train_input[1] - solutions[index])\n",
    "        absolutes[index].append(absolute_error)\n",
    "    for result in absolutes:\n",
    "        if len(result) == 0:     # There is no input for this note\n",
    "            result.append(missed_input_error)\n",
    "        elif len(result) > 1:    # There are multiple inputs registered for this note\n",
    "            result_mean = np.mean(result)\n",
    "            result.clear()\n",
    "            result.append(result_mean)\n",
    "    absolutes = np.array(absolutes).flatten()\n",
    "    return absolutes\n",
    "    \n",
    "def compute_relative_training_errors(solutions, train_inputs, missed_input_error):\n",
    "    solutions_relatives = np.diff(solutions)\n",
    "    relatives = [[] for _ in range(len(solutions_relatives))]\n",
    "    time_last_notes = [[] for _ in range(len(solutions))]\n",
    "    for train_input in train_inputs:\n",
    "        index = int(train_input[2])\n",
    "        time_last_notes[index].append(train_input[1])\n",
    "        if index > 0:\n",
    "            for time in time_last_notes[index-1]:\n",
    "                relative_distance = train_input[1] - time\n",
    "                relative_error = np.abs(relative_distance - solutions_relatives[index-1])\n",
    "                relatives[index-1].append(relative_error)\n",
    "    for result in relatives:\n",
    "        if len(result) == 0:     # There is no input for this note\n",
    "            result.append(missed_input_error)\n",
    "        elif len(result) > 1:    # There are multiple inputs registered for this note\n",
    "            result_mean = np.mean(result)\n",
    "            result.clear()\n",
    "            result.append(result_mean)   \n",
    "    relatives = np.array(relatives).flatten()\n",
    "    return relatives\n",
    "    \n",
    "def compute_errors(training_data):\n",
    "    \"\"\"Computes mean and standard deviation of absloute and relative \n",
    "    time errors for a set of training data, then saves the results\n",
    "    in the TrainingData object as attributes.\n",
    "    \n",
    "    Parameters\n",
    "    ----------\n",
    "    training_data: TrainingData\n",
    "        a set of data to be analyzed\n",
    "    \"\"\"\n",
    "    absolute_errors = compute_absolute_training_errors(training_data.solutions_time, training_data.train_inputs, 0.5)\n",
    "    relative_errors = compute_relative_training_errors(training_data.solutions_time, training_data.train_inputs, 0.5)\n",
    "    mean_abs = np.around(np.mean(absolute_errors), round_decimal)\n",
    "    std_abs = np.around(np.std(absolute_errors), round_decimal)\n",
    "    mean_rel = np.around(np.mean(relative_errors), round_decimal)\n",
    "    std_rel = np.around(np.std(relative_errors), round_decimal)\n",
    "    training_data.absolute_errors = absolute_errors\n",
    "    training_data.relative_errors = relative_errors\n",
    "    training_data.mean_abs = mean_abs\n",
    "    training_data.std_abs = std_abs\n",
    "    training_data.mean_rel = mean_rel\n",
    "    training_data.std_rel = std_rel\n",
    "    \n",
    "def sort_all_training_data(training_data_list):\n",
    "    \"\"\"Sorts a list of TrainingData into a dictionary\n",
    "    with task names as keys and a list of all training data\n",
    "    belonging to the task as their value.\n",
    "    \n",
    "    Parameters\n",
    "    ----------\n",
    "    training_data_list: list of TrainingData\n",
    "        a list of training data to be sorted and sorted\n",
    "    \n",
    "    Retunrs\n",
    "    -------\n",
    "    result: dict\n",
    "        a dictionary with sorted training data\n",
    "    \"\"\"\n",
    "    \n",
    "    result = {}\n",
    "    for data in training_data_list:\n",
    "        compute_errors(data)\n",
    "        if not data.task_name in result:\n",
    "            task_name = data.task_name\n",
    "            result.update({task_name: []})\n",
    "        result[task_name].append(data)\n",
    "    for task_name in result:\n",
    "        result[task_name].sort(key=lambda training_data: training_data.run_number)\n",
    "    return result\n",
    "            \n",
    "def plot_all_training_data(training_data_list):\n",
    "    \"\"\"Creates plots given a list of training data. Groups the data\n",
    "    by their tasks and plots training data for the first task.\n",
    "    \n",
    "    Parameters\n",
    "    ----------\n",
    "    training_data_list: list of TrainingData\n",
    "        a list of training data to be sorted and plotted\n",
    "    \"\"\"\n",
    "    \n",
    "    assert len(training_data_list) > 0, 'No training data provided.'\n",
    "    global sorted_training_data\n",
    "    sorted_training_data = sort_all_training_data(training_data_list)\n",
    "    select_task_data.options = sorted_training_data.keys()\n",
    "    select_task_data.index = 0\n",
    "    plot_full_task(select_task_data.value) \n",
    "\n",
    "def plot_full_task(task_name):\n",
    "    \"\"\"Plots training data for first testing phase, training phase\n",
    "    and second testing phase onto respective figures and axes for a\n",
    "    given task.\n",
    "    \n",
    "    Parameters\n",
    "    ----------\n",
    "    task_name: str\n",
    "        the name of the training task to be plotted.\n",
    "    \"\"\"\n",
    "    \n",
    "    training_data_list = sorted_training_data[task_name]\n",
    "    global fig_test1, fig_train, fig_test2, ax_test1, ax_train, ax_test2\n",
    "    plot_training_data(fig_test1, ax_test1, training_data_list[0])\n",
    "    if len(training_data_list) > 2:\n",
    "        plot_training_data(fig_train, ax_train, training_data_list[1])\n",
    "        select_run.value = 1\n",
    "        select_run.max = len(training_data_list) - 2\n",
    "        plot_training_data(fig_test2, ax_test2, training_data_list[-1])\n",
    "    plot_errors_for_task(task_name)\n",
    "\n",
    "def plot_training_data(fig, ax, training_data):\n",
    "    \"\"\"Plots training data onto selected axes and redraws the\n",
    "    corresponding figure to display the changes.\n",
    "    \n",
    "    The correct notes recreated from note solutions and time\n",
    "    solutions are plotted as crosses, the notes played by\n",
    "    the player are plotted as star shaped points.\n",
    "    \n",
    "    Parameters\n",
    "    ----------\n",
    "    fig: matplotlib.pyplot.figure\n",
    "        the figure that will be updated\n",
    "    ax: matplotlib.axes\n",
    "        the axes that will be updated\n",
    "    training_data: TrainingData\n",
    "        the training data to be plotted on ax\n",
    "    \"\"\"\n",
    "    \n",
    "    clear_axes(ax)\n",
    "    ax.grid(axis='x')\n",
    "    start_beat = np.floor(training_data.solutions_time[0])\n",
    "    x_solutions = training_data.solutions_time - start_beat\n",
    "    y_solutions = training_data.solutions_note\n",
    "    inputs = np.hsplit(training_data.train_inputs, 3)\n",
    "    x_inputs = inputs[1].flatten() - start_beat\n",
    "    y_inputs = inputs[0].flatten()\n",
    "    ax.plot(x_solutions, y_solutions, 'x')\n",
    "    ax.plot(x_inputs, y_inputs, '*', picker=5)\n",
    "    fig.canvas.draw()\n",
    "    update_errors_display(ax, training_data.mean_abs, training_data.std_abs, training_data.mean_rel, training_data.std_rel)\n",
    "    \n",
    "def update_errors_display(ax, mean_abs, std_abs, mean_rel, std_rel):\n",
    "    \"\"\"Updates labels to display new error values.\n",
    "    \n",
    "    Parameters\n",
    "    ----------\n",
    "    ax: matplotlib.axes\n",
    "        the axes with updated data\n",
    "    mean_abs: float\n",
    "        new mean of absolute time errorr\n",
    "    std_abs: float\n",
    "        new standard deviation of absolute time errors\n",
    "    mean_rel: float\n",
    "        new mean of relative time errorr\n",
    "    std_rel: float\n",
    "        new standard deviation of relative time errors\n",
    "    \"\"\"\n",
    "    \n",
    "    if ax == ax_test1:\n",
    "        absolute_error_test1.value = 'mean: ' + str(mean_abs) + '; std: ' + str(std_abs)\n",
    "        relative_error_test1.value = 'mean: ' + str(mean_rel) + '; std: ' + str(std_rel)\n",
    "    elif ax == ax_train:\n",
    "        absolute_error_train.value = 'mean: ' + str(mean_abs) + '; std: ' + str(std_abs)\n",
    "        relative_error_train.value = 'mean: ' + str(mean_rel) + '; std: ' + str(std_rel)\n",
    "    elif ax == ax_test2:\n",
    "        absolute_error_test2.value = 'mean: ' + str(mean_abs) + '; std: ' + str(std_abs)\n",
    "        relative_error_test2.value = 'mean: ' + str(mean_rel) + '; std: ' + str(std_rel)\n",
    "\n",
    "def plot_errors_for_task(task_name):\n",
    "    \"\"\"Plots the average absolute and relative time errors\n",
    "    for each playthrough in a task as errorbar diagrams.\n",
    "    \n",
    "    Parameters\n",
    "    ----------\n",
    "    task_name: str\n",
    "        the name of the training task to be plotted.\n",
    "    \"\"\"\n",
    "    \n",
    "    global fig_abserr, ax_abserr, fig_relerr, ax_relerr\n",
    "    training_data_list = sorted_training_data[task_name]\n",
    "    attempts = range(len(training_data_list))\n",
    "    means_abs = [data.mean_abs for data in training_data_list]\n",
    "    stds_abs = [data.std_abs for data in training_data_list]\n",
    "    means_rel = [data.mean_rel for data in training_data_list]\n",
    "    stds_rel = [data.std_rel for data in training_data_list]\n",
    "    clear_axes(ax_abserr)\n",
    "    ax_abserr.axhline(color='black')\n",
    "    ax_abserr.set_ylim(ax_err_ylim)\n",
    "    ax_abserr.set_xticks(attempts)\n",
    "    ax_abserr.errorbar(attempts, means_abs, stds_abs, fmt='o', capsize=6)\n",
    "    fig_abserr.canvas.draw()\n",
    "    clear_axes(ax_relerr)\n",
    "    ax_relerr.axhline(color='black')\n",
    "    ax_relerr.set_ylim(ax_err_ylim)\n",
    "    ax_relerr.set_xticks(attempts)\n",
    "    ax_relerr.errorbar(attempts, means_rel, stds_rel, fmt='o', capsize=6)\n",
    "    fig_relerr.canvas.draw()\n",
    "    \n",
    "def clear_axes(ax):\n",
    "    \"\"\"Clears the content of selected axes.\n",
    "    \n",
    "    Parameters\n",
    "    ----------\n",
    "    ax: matplotlib.axes\n",
    "        the axes to be cleared\n",
    "    \"\"\"\n",
    "    \n",
    "    ax_title = ax.get_title()\n",
    "    ax_xlabel = ax.get_xlabel()\n",
    "    ax_ylabel = ax.get_ylabel()\n",
    "    ax.clear()\n",
    "    ax.set_title(ax_title)\n",
    "    ax.set_xlabel(ax_xlabel)\n",
    "    ax.set_ylabel(ax_ylabel)\n",
    "    \n",
    "def clear_all():\n",
    "    \"\"\"Clears and redraws all axes.\"\"\"\n",
    "    \n",
    "    clear_axes(ax_test1)\n",
    "    ax_test1.grid(axis='x')\n",
    "    clear_axes(ax_train)\n",
    "    ax_train.grid(axis='x')\n",
    "    clear_axes(ax_test2)\n",
    "    ax_test2.grid(axis='x')\n",
    "    clear_axes(ax_abserr)\n",
    "    ax_abserr.axhline(color='black')\n",
    "    ax_abserr.set_ylim([-0.5, 1])\n",
    "    clear_axes(ax_relerr)\n",
    "    ax_relerr.axhline(color='black')\n",
    "    ax_relerr.set_ylim([-0.5, 1])\n",
    "    fig_test1.canvas.draw()\n",
    "    fig_train.canvas.draw()\n",
    "    fig_test2.canvas.draw()\n",
    "    fig_abserr.canvas.draw()\n",
    "    fig_relerr.canvas.draw()\n",
    "\n",
    "# Event functions\n",
    "def update_training_run_plot(change):\n",
    "    \"\"\"Re-plots the training run figure with new training data\n",
    "    when a training run with another index is selected.\n",
    "    \"\"\"\n",
    "    \n",
    "    training_data_list = sorted_training_data[select_task_data.value]\n",
    "    plot_training_data(fig_train, ax_train, training_data_list[change.new])\n",
    "\n",
    "def update_task_plot(change):\n",
    "    \"\"\"Re-plots all figures with training data from the new task\n",
    "    when another training task is selected.\"\"\"\n",
    "    \n",
    "    plot_full_task(change.new)\n",
    "\n",
    "def note_index_changed(change):\n",
    "    \"\"\"Enables the change index button\"\"\"\n",
    "    \n",
    "    update_note_index_button.disabled = False\n",
    "\n",
    "def update_note_index_for_input_selected(b):\n",
    "    \"\"\"Changes the note index of a selecetd input note\n",
    "    and re-plots absolute and relative errors.\n",
    "    \"\"\"\n",
    "    \n",
    "    new_index = int(select_note_index.value)\n",
    "    training_data = input_selected[0]\n",
    "    input_index = input_selected[1]\n",
    "    training_data.train_inputs[input_index][2] = new_index\n",
    "    compute_errors(training_data)\n",
    "    plot_training_data(input_selected_fig, input_selected_ax, training_data)\n",
    "    plot_errors_for_task(select_task_data.value)\n",
    "    update_note_index_button.disabled = True\n",
    "\n",
    "def on_pick(event):\n",
    "    \"\"\"An on pick event for when the player selects a\n",
    "    data point, that indicates a note played by them,\n",
    "    with the mouse.\n",
    "    \n",
    "    The selected note is registered in a global variable\n",
    "    so that it can be modified when the player wishies to\n",
    "    change its properties.\n",
    "    \"\"\"\n",
    "    \n",
    "    global input_selected, input_selected_fig, input_selected_ax\n",
    "    if isinstance(event.artist, Line2D):\n",
    "        thisline = event.artist\n",
    "        xdata = thisline.get_xdata()\n",
    "        ydata = thisline.get_ydata()\n",
    "        ind = event.ind\n",
    "        if thisline in ax_test1.lines:\n",
    "            training_data_index = 0\n",
    "            input_selected_fig = fig_test1\n",
    "            input_selected_ax = ax_test1\n",
    "        elif thisline in ax_train.lines:\n",
    "            training_data_index = select_run.value\n",
    "            input_selected_fig = fig_train\n",
    "            input_selected_ax = ax_train\n",
    "        elif thisline in ax_test2.lines:\n",
    "            training_data_index = -1\n",
    "            input_selected_fig = fig_test2\n",
    "            input_selected_ax = ax_test2\n",
    "        training_data = sorted_training_data[select_task_data.value][training_data_index]\n",
    "        input_selected = [training_data, ind[0]]\n",
    "        select_note_index.options = list(range(len(training_data.solutions_time)))\n",
    "        select_note_index.index = int(training_data.train_inputs[ind[0]][2])\n",
    "        input_selected_description.value = '[' + str(np.around(np.take(xdata, ind)[0], 2)) + ', ' + str(int(np.take(ydata, ind))) + ']'\n",
    "        update_note_index_button.disabled = True\n",
    "        \n",
    "\n",
    "    \n",
    "#################\n",
    "### GUI SETUP ###\n",
    "#################\n",
    "\n",
    "# Setup GUI for plotting results   \n",
    "plt.ioff()\n",
    "\n",
    "select_task_data = widgets.Dropdown(options=sorted_training_data.keys(), description=\"Task:\")\n",
    "select_task_data.observe(update_task_plot, names='value')\n",
    "\n",
    "input_selected_description = widgets.Label('none')\n",
    "select_note_index = widgets.Dropdown(options=[], layout=widgets.Layout(width='50px'))\n",
    "select_note_index.observe(note_index_changed, names='value')\n",
    "update_note_index_button = widgets.Button(\n",
    "    description='Update Index',\n",
    "    button_style='',\n",
    "    tooltip='Change the note to which this input belongs',\n",
    "    icon='',\n",
    "    disabled=True\n",
    ")\n",
    "update_note_index_button.on_click(update_note_index_for_input_selected)\n",
    "\n",
    "select_run = widgets.IntSlider(\n",
    "    description='Train run:',\n",
    "    value=1,\n",
    "    min=1,\n",
    "    max=3\n",
    ")\n",
    "select_run.observe(update_training_run_plot, names='value')\n",
    "\n",
    "absolute_error_test1 = widgets.Label(value='mean: N/A; std: N/A')\n",
    "relative_error_test1 = widgets.Label(value='mean: N/A; std: N/A')\n",
    "absolute_error_train = widgets.Label(value='mean: N/A; std: N/A')\n",
    "relative_error_train = widgets.Label(value='mean: N/A; std: N/A')\n",
    "absolute_error_test2 = widgets.Label(value='mean: N/A; std: N/A')\n",
    "relative_error_test2 = widgets.Label(value='mean: N/A; std: N/A')\n",
    "\n",
    "errors_test1 = widgets.VBox([widgets.HBox([widgets.Label('Absolute error'), absolute_error_test1]),\n",
    "                             widgets.HBox([widgets.Label('Relative error'), relative_error_test1])])\n",
    "errors_train = widgets.VBox([widgets.HBox([widgets.Label('Absolute error'), absolute_error_train]),\n",
    "                             widgets.HBox([widgets.Label('Relative error'), relative_error_train])])\n",
    "errors_test2 = widgets.VBox([widgets.HBox([widgets.Label('Absolute error'), absolute_error_test2]),\n",
    "                             widgets.HBox([widgets.Label('Relative error'), relative_error_test2])])\n",
    "\n",
    "\n",
    "# Plot figure for the 1. testing phase\n",
    "fig_test1, ax_test1 = plt.subplots()\n",
    "fig_test1.canvas.header_visible = False\n",
    "ax_test1.grid(axis='x')\n",
    "ax_test1.set_title('1. Test Run')\n",
    "ax_test1.set_xlabel('Time in Beats')\n",
    "ax_test1.set_ylabel('Note in MIDI')\n",
    "fig_test1.canvas.mpl_connect('pick_event', on_pick)\n",
    "\n",
    "# Plot figure for the training phase\n",
    "fig_train, ax_train = plt.subplots()\n",
    "fig_train.canvas.header_visible = False\n",
    "ax_train.grid(axis='x')\n",
    "ax_train.set_title('Training Runs')\n",
    "ax_train.set_xlabel('Time in Beats')\n",
    "ax_train.set_ylabel('Note in MIDI')\n",
    "fig_train.canvas.mpl_connect('pick_event', on_pick)\n",
    "\n",
    "# Plot figure for the 2. testing phase\n",
    "fig_test2, ax_test2 = plt.subplots()\n",
    "fig_test2.canvas.header_visible = False\n",
    "ax_test2.grid(axis='x')\n",
    "ax_test2.set_title('2. Test Run')\n",
    "ax_test2.set_xlabel('Time in Beats')\n",
    "ax_test2.set_ylabel('Note in MIDI')\n",
    "fig_test2.canvas.mpl_connect('pick_event', on_pick)\n",
    "\n",
    "#Plot figure for absloute time errors\n",
    "fig_abserr, ax_abserr = plt.subplots()\n",
    "fig_abserr.canvas.header_visible = False\n",
    "ax_abserr.axhline(color='black')\n",
    "ax_abserr.set_ylim([-0.5, 1])\n",
    "ax_abserr.set_title('Absolute Time Errors')\n",
    "ax_abserr.set_xlabel('Attempts')\n",
    "ax_abserr.set_ylabel('Error in Beats')\n",
    "\n",
    "#Plot figure for relative time errors\n",
    "fig_relerr, ax_relerr = plt.subplots()\n",
    "fig_relerr.canvas.header_visible = False\n",
    "ax_relerr.axhline(color='black')\n",
    "ax_relerr.set_ylim([-0.5, 1])\n",
    "ax_relerr.set_title('Relative Time Errors')\n",
    "ax_relerr.set_xlabel('Attempts')\n",
    "ax_relerr.set_ylabel('Error in Beats')\n",
    "\n",
    "\n",
    "select_task_point = widgets.HBox([widgets.Label('Selected input:'), input_selected_description,\n",
    "                                  widgets.Label('at note index'), select_note_index, update_note_index_button])\n",
    "\n",
    "# Plotting results in 3 figures\n",
    "results_plot = widgets.GridspecLayout(4, 2)\n",
    "results_plot[0, 0] = fig_test1.canvas\n",
    "results_plot[0, 1] = widgets.VBox([select_task_point, errors_test1], layout=widgets.Layout(height='auto', width='auto', justify_content='center'))\n",
    "results_plot[1, 0] = fig_train.canvas\n",
    "results_plot[1, 1] = widgets.VBox([select_run, select_task_point, errors_train], layout=widgets.Layout(height='auto', width='auto', justify_content='center'))\n",
    "results_plot[2, 0] = fig_test2.canvas\n",
    "results_plot[2, 1] = widgets.VBox([select_task_point, errors_test2], layout=widgets.Layout(height='auto', width='auto', justify_content='center'))\n",
    "results_plot[3, 0] = fig_abserr.canvas\n",
    "results_plot[3, 1] = fig_relerr.canvas\n",
    "\n",
    "plot_gui = widgets.VBox([select_task_data, results_plot])\n",
    "plot_gui.layout.align_items = 'center'"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "02d922aa-8477-43f6-a018-a83af16e5178",
   "metadata": {
    "tags": []
   },
   "source": [
    "# rhythm_training\n",
    "This application is dedicated to the accurate performing of a given rhythm. You can setup tasks to play after and hear real-time audio feedback while playing.\n",
    "\n",
    "### Initialization\n",
    "It is recommended to use JupyterLab to open this notebook. The following Python packages are required:\n",
    "* [sc3nb](https://pypi.org/project/sc3nb/)\n",
    "* [ipywidgets](https://pypi.org/project/ipywidgets/) (version 7.6.5 and later)\n",
    "* [ipympl](https://matplotlib.org/ipympl/) for interactive matplotlib functions\n",
    "\n",
    "Please make sure a MIDI keyboard is connected to the device this notebook is running on, then restart the kernel and run all cells."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "92cfe249-b264-44d6-b6cb-40bcf402f403",
   "metadata": {
    "jp-MarkdownHeadingCollapsed": true,
    "tags": []
   },
   "source": [
    "## Free Play\n",
    "You can set up and play training tasks manually."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cc45e7c9-e640-43d1-a47f-44e09bd4be18",
   "metadata": {
    "tags": []
   },
   "source": [
    "### Task Settings\n",
    "<b>Signature:</b> The desired time signature of the task. You can choose between 2/4, 3/4 and 4/4. Manual inputs should follow the same format.\n",
    "\n",
    "<b>Notes:</b> A sequence of notes to be repeatedly played during the task. The values should be MIDI values: Middle C is 60, C# is 61, D is 62 etc. Notes are seperated by a single comma. E.g. a sequence C D E will be written as 60,62,64\n",
    "\n",
    "Please note that this application only deals with rhythm and timing issues, so even if you can specify the notes you play, only temporal errors are processed.\n",
    "\n",
    "<b>Rhythm:</b> A sequence of time intervals between the notes played during the task. The values should be relative to quarternote: a quarter note is 1, an eighth note is 1/2 etc. Intervals are seperated by a single comma. E.g., a sequence of one quarter note and two eighth notes will be written as 1,1/2,1/2\n",
    "\n",
    "<b>Offbeat:</b> An offset at the beginning of the Task. Should be written as whole numbers or fractions (1/2 for half beat off).\n",
    "\n",
    "<b>Name:</b> The name of the task. If the name already exist in the task list, the corresponding task in the task list will be updated.\n",
    "\n",
    "### General Settings\n",
    "<b>BPM:</b> Tempo of the task.\n",
    "\n",
    "<b>Wait:</b> How many bars to wait before the task starts. The metronome will play during the waiting bars.\n",
    "\n",
    "<b>Train:</b> How many bars to be played during the task.\n",
    "\n",
    "<b>Allow error:</b> Input latency within this range will not be considered missing the note, so no control sound will be played to remind you to play the note.\n",
    "\n",
    "### Start Test\n",
    "Play the selected Task without any help. You can use Play Demo to hear the full task.\n",
    "\n",
    "### Start Training\n",
    "Play the selected Task with the selected sonification method. Different method will use different sound cues when you play the note at a wrong time."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cc72ca2f-b2cc-4afe-aeaa-03121f38215c",
   "metadata": {},
   "source": [
    "## Methods\n",
    "Three sets of audio feedback are available, each with a different style.\n",
    "\n",
    "**Method 1:** When you play a note too early, the note will be dampened so that it sounds quieter. When you miss a note, the correct note will be played.\n",
    "\n",
    "**Method 2:** When you play a note too early, the note will be distorted in frequency. When you miss a note, a blip sound will be played.\n",
    "\n",
    "**Method 3:** When you play a note too early, you will hear a static noise. When you miss a note, a tick sound will be played.\n",
    "\n",
    "You can listen to these sounds using the following panel. Middle C is the pitch for the demo note."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "d59e074c-0df3-4204-aeb0-5a9b0cd57098",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "fa7c09c306ca4ff9ab1eb98d6816f38b",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "VBox(children=(GridBox(children=(HTML(value='<b>Demo note:</b>'), Button(description='Play demo note', style=B…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "display(test_sounds_menu)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "18d2660c-16d4-4c01-8d31-e570c2dd3d02",
   "metadata": {
    "tags": []
   },
   "source": [
    "## Experiment\n",
    "Play through a set of designed tasks. After you complete the experiment, you can view your training results in the following cell."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "a00d741e-7821-4c3c-aeac-7d4ec8f7b9b7",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "9ec1362043814cf3bdc95be59bdc5183",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "VBox(children=(Accordion(children=(VBox(children=(HBox(children=(Label(value='Signature:'), Combobox(value='4/…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "display(api_gui)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "2694719c-e81b-4acf-9f22-77a3a64fedd3",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "e9fc6b7756d5429ba8df70f84fe0fd11",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "VBox(children=(Dropdown(description='Task:', options=(), value=None), GridspecLayout(children=(Canvas(header_v…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "display(plot_gui)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1666558e-3334-433d-abda-70f225b8e451",
   "metadata": {
    "tags": []
   },
   "source": [
    "## Exit\n",
    "Run the following cell to exit the SC server."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "5ed067d0-c76f-4a8e-ad51-4b42aefa2b97",
   "metadata": {
    "jupyter": {
     "source_hidden": true
    },
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "a6e07276671a40b1bdc50f5d152d1f29",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Button(button_style='danger', description='Exit', style=ButtonStyle())"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "def exit_program(b):\n",
    "    plt.close(fig_test1)\n",
    "    plt.close(fig_train)\n",
    "    plt.close(fig_test2)\n",
    "    plt.close(fig_abserr)\n",
    "    plt.close(fig_relerr)\n",
    "    sc.exit()\n",
    "\n",
    "exit_program_button = widgets.Button(\n",
    "    description='Exit',\n",
    "    button_style='danger'\n",
    ")\n",
    "exit_program_button.on_click(exit_program)\n",
    "\n",
    "exit_program_button"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.9.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}