lessons/04_More_SMILE.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# More SMILE!!!\n",
    "## Computational Methods in Psychology and Neuroscience\n",
    "### Psychology 4215/7215 --- Fall 2023\n",
    "By: Per B. Sederberg, PhD\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Lesson Objectives\n",
    "\n",
    "Upon completion of this lesson, students should have learned:\n",
    "\n",
    "1. How to update SMILE to the latest version\n",
    "2. How to present images\n",
    "3. To visualize the DAG for an experiment\n",
    "4. How to lay out visual states on the screen\n",
    "5. To log information for easy analysis\n",
    "6. How to write subroutines to organize your code\n",
    "7. How to include mouse interaction\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Updating SMILE\n",
    "\n",
    "- First, activate your smile virtual environment:\n",
    "\n",
    "```bash\n",
    "conda activate smile\n",
    "```\n",
    "\n",
    "- You can test whether there is a new version Kivy, which is the primary dependency of SMILE:\n",
    "\n",
    "```bash\n",
    "conda install -c conda-forge kivy\n",
    "```\n",
    "\n",
    "- Then you can update SMILE right from the GitHub repository (note the upgrade option at the end):\n",
    "\n",
    "```bash\n",
    "pip install --upgrade git+https://github.com/compmem/smile\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Understanding Flow\n",
    "\n",
    "- By default, everything in SMILE proceeds sequentially (i.e., in *serial*) in the order the states are added.\n",
    "  - The `Serial` parent state manages starting the next child state when the previous child finishes.\n",
    "- The `Parallel` state allows for multiple states to run *at the same time*.\n",
    "  - By default the `Parallel` state is done with all its child states are done.\n",
    "  - The `blocking` attribute allows ending a `Parallel` state when all non-blocking states are done.\n",
    "  - The `UntilDone` and `Meanwhile` parent states simply create Serial/Parallel states with specific blocking values."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## These are the same"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# load in smile states\n",
    "from smile.common import *\n",
    "\n",
    "# create an experiment instance\n",
    "exp = Experiment(show_splash=False, resolution=(1024,768))\n",
    "\n",
    "# METHOD 1\n",
    "Label(text='Press Any Key')\n",
    "with UntilDone():\n",
    "    KeyPress()\n",
    "Wait(.5)\n",
    "\n",
    "# METHOD 2\n",
    "with Parallel():\n",
    "    Label(text='Press Any Key', blocking=False)\n",
    "    KeyPress()\n",
    "Wait(.5)\n",
    "\n",
    "# METHOD 3\n",
    "KeyPress()\n",
    "with Meanwhile():\n",
    "    Label(text='Press Any Key')\n",
    "\n",
    "    \n",
    "Wait(.5)\n",
    "\n",
    "exp.run()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Keeping track of variables\n",
    "\n",
    "Any variable needed at *run-time* must be *attached* to the state machine. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "# load in smile states\n",
    "from smile.common import *\n",
    "\n",
    "# create an experiment instance\n",
    "exp = Experiment(show_splash=False, resolution=(1024,768))\n",
    "\n",
    "KeyPress()\n",
    "with Meanwhile():\n",
    "    # attach a variable reference\n",
    "    exp.current_value = 0\n",
    "    with Loop():\n",
    "        exp.current_value = exp.current_value + 1\n",
    "        Label(text=Ref(str, exp.current_value), duration=1.0, \n",
    "              font_size=50)\n",
    "Wait(.5)\n",
    "\n",
    "exp.run()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Showing Images\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "# load in smile states\n",
    "from smile.common import *\n",
    "\n",
    "# create an experiment instance\n",
    "exp = Experiment(show_splash=False, resolution=(1024,768))\n",
    "\n",
    "# show an image until keypress\n",
    "Image(source=\"../assignments/outdoor/out0099_new.jpg\")\n",
    "with UntilDone():\n",
    "    KeyPress()\n",
    "\n",
    "# show a larger image until keypress (note allow_stretch)\n",
    "Image(source=\"../assignments/outdoor/out0099_new.jpg\", \n",
    "      width=200, height=400, allow_stretch=True, keep_ratio=False)\n",
    "with UntilDone():\n",
    "    KeyPress()\n",
    "\n",
    "# run the experiment\n",
    "exp.run()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Visualizing State Machines\n",
    "\n",
    "- A SMILE experiment is a directed acyclic graph (DAG)\n",
    "- It's possible to visualize the full hierarchy of states\n",
    "\n",
    "- Note, this will require that you install pydot:\n",
    "\n",
    "```bash\n",
    "conda install pydot\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<IPython.core.display.Image object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "from smile.dag import DAG\n",
    "d = DAG(exp)\n",
    "d.view_png()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Advanced Placement\n",
    "\n",
    "- All visual states have a coordinate system based on the screen.\n",
    "- You can place any visual state relative to either the screen or other visual states:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "# load in smile states\n",
    "from smile.common import *\n",
    "\n",
    "# create an experiment instance\n",
    "exp = Experiment(show_splash=False, resolution=(1024,768))\n",
    "\n",
    "# show images and labels until keypress\n",
    "with Parallel():\n",
    "    # place images based on the screen coords\n",
    "    out_im = Image(source=\"../assignments/outdoor/out0091_new.jpg\",\n",
    "                   left=exp.screen.center_x + 100)\n",
    "    in_im = Image(source=\"../assignments/indoor/in0021.jpg\",\n",
    "                  right=exp.screen.center_x - 100)\n",
    "    \n",
    "    # place labels based on the images\n",
    "    out_txt = Label(text='Outdoor', font_size=50, \n",
    "                    center_bottom=out_im.center_top)\n",
    "    in_txt = Label(text='Indoor', font_size=50, \n",
    "                   center_bottom=in_im.center_top)\n",
    "with UntilDone():\n",
    "    KeyPress()\n",
    "\n",
    "# run the experiment\n",
    "exp.run()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Conditional Execution\n",
    "\n",
    "Your state machine can branch by making use of conditionals, i.e., `If`, `Else`, and `Elif`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "# load in smile states\n",
    "from smile.common import *\n",
    "\n",
    "# create an experiment instance\n",
    "exp = Experiment(show_splash=False, resolution=(1024,768))\n",
    "\n",
    "with Parallel():\n",
    "    with Serial(blocking=False):\n",
    "        exp.current_value = 0\n",
    "        with Loop():\n",
    "            # set the new value\n",
    "            exp.current_value = exp.current_value + 1\n",
    "            \n",
    "            with If(exp.current_value % 2 == 0):\n",
    "                # it's an even number, so move it left\n",
    "                exp.offset = -100\n",
    "            with Else():\n",
    "                # it's odd, so move it right\n",
    "                exp.offset = 100\n",
    "\n",
    "            Label(text=Ref(str, exp.current_value), duration=1.0, \n",
    "                  font_size=50,\n",
    "                  center_x = exp.screen.center_x + exp.offset)\n",
    "    KeyPress()\n",
    "Wait(.5)\n",
    "\n",
    "exp.run()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Mouse States\n",
    "\n",
    "- The mouse is hidden by default\n",
    "- You can add in a mouse cursor with the `MouseCursor` state\n",
    "- It's possible to trigger events based on mouse location"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "from smile.common import *\n",
    "\n",
    "# set up an experiment\n",
    "exp = Experiment(show_splash=False, debug=True)\n",
    "\n",
    "Wait(0.5)\n",
    "\n",
    "KeyPress()\n",
    "with Meanwhile():\n",
    "    MouseCursor()\n",
    "    \n",
    "exp.run()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "DEBUG (file: '/tmp/ipykernel_1078212/1408427399.py', line: 30) - lag=0.002346s\n",
      "  choice: 'B'\n",
      "  rt: 1.6295217480510473\n"
     ]
    }
   ],
   "source": [
    "from smile.common import *\n",
    "\n",
    "# set up an experiment\n",
    "exp = Experiment(show_splash=False, debug=True)\n",
    "\n",
    "Wait(0.5)\n",
    "\n",
    "# display a rectangle and the mouse cursor\n",
    "with Parallel():\n",
    "    rect = Rectangle(center_bottom=exp.screen.center_bottom,\n",
    "                     color='white')\n",
    "    MouseCursor()\n",
    "with UntilDone():\n",
    "    Wait(until=MouseWithin(rect))\n",
    "\n",
    "# put up two new rectangles\n",
    "with Parallel():\n",
    "    choice_A = Rectangle(left_top=(exp.screen.left + 100, exp.screen.top - 100))\n",
    "    choice_B = Rectangle(right_top=(exp.screen.right - 100, exp.screen.top - 100))\n",
    "    mrec = Record(mouse_pos=MousePos())\n",
    "    MouseCursor()\n",
    "with UntilDone():\n",
    "    mwa = MouseWithin(choice_A)\n",
    "    mwb = MouseWithin(choice_B)\n",
    "    w = Wait(until= mwa | mwb)\n",
    "    with If(mwa):\n",
    "        Debug(choice='A',\n",
    "              rt=w.event_time['time'] - choice_A.appear_time['time'])\n",
    "    with Else():\n",
    "        Debug(choice='B',\n",
    "              rt=w.event_time['time'] - choice_B.appear_time['time'])\n",
    "\n",
    "exp.run()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Animations\n",
    "\n",
    "- It's possible to link the attributes of a visual state to a function.\n",
    "- Here we move rectangles based on the mouse position:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "from smile.common import *\n",
    "\n",
    "# set up an experiment\n",
    "exp = Experiment(show_splash=False, debug=True)\n",
    "\n",
    "Wait(1.0)\n",
    "\n",
    "with Parallel():\n",
    "    rect = Rectangle(center_bottom=exp.screen.center_bottom,\n",
    "                     color='white')\n",
    "    r2 = Rectangle(bottom=rect.bottom, color='purple')\n",
    "    r3 = Rectangle(center_top=exp.screen.center_top, color='green')\n",
    "    MouseCursor()\n",
    "with UntilDone():\n",
    "    Wait(until=MouseWithin(rect))\n",
    "    with Meanwhile():\n",
    "        with Parallel():\n",
    "            r2.animate(center_x=lambda t, initial: MousePos()[0])\n",
    "            r3.animate(center_y=lambda t, initial: MousePos()[1])\n",
    "\n",
    "exp.run()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Sliding\n",
    "\n",
    "- Visual States have a slide method to set new parameter values over a duration."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "from smile.common import *\n",
    "\n",
    "# set up the experiment\n",
    "exp = Experiment(show_splash=False, debug=True, resolution=(1024, 768))\n",
    "\n",
    "# initial wait\n",
    "Wait(.25)\n",
    "\n",
    "# Put up a circle\n",
    "circ = Ellipse(color=(jitter(0, 1),\n",
    "                      jitter(0, 1),\n",
    "                      jitter(0, 1)))\n",
    "with UntilDone():\n",
    "    Wait(until=circ.appear_time)\n",
    "    with Loop(5):\n",
    "        # slide to new loc and color\n",
    "        exp.new_col = (jitter(0, 1),\n",
    "                       jitter(0, 1),\n",
    "                       jitter(0, 1))\n",
    "        exp.new_loc = (jitter(0, exp.screen.width),\n",
    "                       jitter(0, exp.screen.height))\n",
    "        cu = circ.slide(duration=2.5,\n",
    "                        color=exp.new_col,\n",
    "                        center=exp.new_loc)\n",
    "\n",
    "Wait(.25)\n",
    "\n",
    "exp.run()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Animate and Slide together!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "from smile.common import *\n",
    "from math import cos\n",
    "\n",
    "exp = Experiment(show_splash=False)\n",
    "\n",
    "# add a circle off the screen\n",
    "ellipse = Ellipse(right=exp.screen.left,\n",
    "              center_y=exp.screen.center_y, width=50, height=50,\n",
    "              angle_start=90.0, angle_end=460.0,\n",
    "              color=(1.0, 1.0, 0.0), name=\"Pacman\")\n",
    "\n",
    "with UntilDone():\n",
    "    with Parallel(name=\"Pacman motion\"):\n",
    "        ellipse.slide(left=exp.screen.right, duration=8.0, name=\"Pacman travel\")\n",
    "        ellipse.animate(\n",
    "            angle_start=lambda t, initial: initial + (cos(t * 8) + 1) * 22.5,\n",
    "            angle_end=lambda t, initial: initial - (cos(t * 8) + 1) * 22.5,\n",
    "            duration=8.0, name=\"Pacman gobble\")\n",
    "\n",
    "exp.run()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Logging\n",
    "\n",
    "- SMILE states automatically log themselves, so you rarely will lose information if you forget to log it.\n",
    "- It's still much easier to analyze a well-organized log file from your experiment.\n",
    "- Make use of the `Log` state to save out data."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Subroutines\n",
    "\n",
    "- Functions are a great way to make clean programs when you have chunks of code that are called more than once.\n",
    "- The `Subroutine` decorator allows you to take chunks of state machine and call them like a function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# when defining the subroutine, you must include self as the first arg\n",
    "@Subroutine\n",
    "def MyTrial(self, text):\n",
    "    self.val = 33\n",
    "    Label(text=text)\n",
    "    with UntilDone():\n",
    "        KeyPress()\n",
    "        \n",
    "        \n",
    "MyTrial(text='Hello!')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Let's continue learning by building together!\n",
    "\n",
    "- Last class we wrote a list generation and initial Flanker task.\n",
    "- Let's update the frontend experiment to loop over those trials with a subroutine."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# List Gen Function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[{'condition': 'congruent', 'direction': 'right', 'stimulus': '>>>>>>>'}, {'condition': 'incongruent', 'direction': 'right', 'stimulus': '<<<><<<'}, {'condition': 'incongruent', 'direction': 'left', 'stimulus': '>>><>>>'}, {'condition': 'neutral', 'direction': 'right', 'stimulus': '===>==='}, {'condition': 'neutral', 'direction': 'left', 'stimulus': '===<==='}, {'condition': 'incongruent', 'direction': 'left', 'stimulus': '>>><>>>'}, {'condition': 'neutral', 'direction': 'right', 'stimulus': '===>==='}, {'condition': 'incongruent', 'direction': 'right', 'stimulus': '<<<><<<'}, {'condition': 'congruent', 'direction': 'right', 'stimulus': '>>>>>>>'}, {'condition': 'congruent', 'direction': 'left', 'stimulus': '<<<<<<<'}, {'condition': 'neutral', 'direction': 'left', 'stimulus': '===<==='}, {'condition': 'congruent', 'direction': 'left', 'stimulus': '<<<<<<<'}]\n"
     ]
    }
   ],
   "source": [
    "import random \n",
    "import copy\n",
    "\n",
    "# define the conditions\n",
    "conds = [{'condition': 'congruent',\n",
    "          'direction': 'left',\n",
    "          'stimulus': '<<<<<<<'\n",
    "         },\n",
    "         {'condition': 'congruent',\n",
    "          'direction': 'right',\n",
    "          'stimulus': '>>>>>>>'\n",
    "         },\n",
    "         {'condition': 'incongruent',\n",
    "          'direction': 'left',\n",
    "          'stimulus': '>>><>>>'\n",
    "         },\n",
    "         {'condition': 'incongruent',\n",
    "          'direction': 'right',\n",
    "          'stimulus': '<<<><<<'\n",
    "         },\n",
    "         {'condition': 'neutral',\n",
    "          'direction': 'left',\n",
    "          'stimulus': '===<==='\n",
    "         },\n",
    "         {'condition': 'neutral',\n",
    "          'direction': 'right',\n",
    "          'stimulus': '===>==='\n",
    "         },]\n",
    "\n",
    "# specify number of reps of these conditions\n",
    "num_reps = 2\n",
    "\n",
    "# loop and create the list\n",
    "trials = []\n",
    "for i in range(num_reps):\n",
    "    # extend the trials with copies of the conditions\n",
    "    trials.extend(copy.deepcopy(conds))\n",
    "\n",
    "# shuffle the trials\n",
    "random.shuffle(trials)\n",
    "\n",
    "print(trials)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Goal for each trial\n",
    "\n",
    "- Present the correct stimulus as text on the screen\n",
    "- Wait for a response\n",
    "- Remove the stimulus\n",
    "- Wait for an inter-stimulus interval\n",
    "- Log the result of the trial"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "DEBUG (file: '/tmp/ipykernel_1078212/1464657388.py', line: 18) - lag=0.000508s\n",
      "  loc: (479.99985970488456, 326.3414613541609)\n",
      "DEBUG (file: '/tmp/ipykernel_1078212/1464657388.py', line: 18) - lag=0.000401s\n",
      "  loc: (639.7010083692564, 378.3010260607458)\n",
      "DEBUG (file: '/tmp/ipykernel_1078212/1464657388.py', line: 18) - lag=0.000579s\n",
      "  loc: (348.76869104475975, 382.4922059141263)\n",
      "DEBUG (file: '/tmp/ipykernel_1078212/1464657388.py', line: 18) - lag=0.000489s\n",
      "  loc: (576.3878064885554, 416.5131118976383)\n",
      "DEBUG (file: '/tmp/ipykernel_1078212/1464657388.py', line: 18) - lag=0.000668s\n",
      "  loc: (624.2073634240905, 359.9639561055097)\n",
      "DEBUG (file: '/tmp/ipykernel_1078212/1464657388.py', line: 18) - lag=0.000902s\n",
      "  loc: (629.7718084559856, 363.52937991105506)\n",
      "DEBUG (file: '/tmp/ipykernel_1078212/1464657388.py', line: 18) - lag=0.000664s\n",
      "  loc: (340.0488763627348, 348.12093233895007)\n",
      "DEBUG (file: '/tmp/ipykernel_1078212/1464657388.py', line: 18) - lag=0.000523s\n",
      "  loc: (318.08992041898114, 473.72353672715985)\n",
      "DEBUG (file: '/tmp/ipykernel_1078212/1464657388.py', line: 18) - lag=0.000726s\n",
      "  loc: (430.3909736228729, 449.065154742117)\n",
      "DEBUG (file: '/tmp/ipykernel_1078212/1464657388.py', line: 18) - lag=0.000328s\n",
      "  loc: (406.0595665202965, 336.95936205375386)\n",
      "DEBUG (file: '/tmp/ipykernel_1078212/1464657388.py', line: 18) - lag=0.000526s\n",
      "  loc: (480.6364874502865, 473.17077413668073)\n",
      "DEBUG (file: '/tmp/ipykernel_1078212/1464657388.py', line: 18) - lag=0.001222s\n",
      "  loc: (359.38642119573973, 432.5418749883388)\n"
     ]
    }
   ],
   "source": [
    "from smile.common import *\n",
    "\n",
    "font_size = 75\n",
    "resp_keys = ['F', 'J']\n",
    "ISI_dur = 0.5\n",
    "ISI_jitter = 0.5\n",
    "\n",
    "# create the experiment\n",
    "exp = Experiment(show_splash=False, fullscreen=False,\n",
    "                 resolution=(1024, 768), debug=True)\n",
    "\n",
    "@Subroutine\n",
    "def Trial(self, cur_trial):\n",
    "    self.location = (jitter(self.exp.screen.center_x-200,\n",
    "                            400),\n",
    "                     jitter(self.exp.screen.center_y-100,\n",
    "                            200))\n",
    "    Debug(loc=self.location)\n",
    "    stim = Label(text=cur_trial['stimulus'],\n",
    "                 font_size=font_size,\n",
    "                 center=self.location)\n",
    "    with UntilDone():\n",
    "        Wait(until=stim.appear_time)\n",
    "        kp = KeyPress(keys=resp_keys)\n",
    "    \n",
    "    Wait(ISI_dur, jitter=ISI_jitter)\n",
    "    \n",
    "    Log(cur_trial, name='flanker',\n",
    "        stim_on=stim.appear_time,\n",
    "        resp=kp.pressed,\n",
    "        resp_time=kp.press_time,\n",
    "        location=self.location\n",
    "       )\n",
    "    \n",
    "# show the stimulus (will default to center of the screen)\n",
    "with Loop(trials) as trial:\n",
    "    with If(trial.i % 3 == 0):\n",
    "        # give someone a break\n",
    "        Label(text='Press any key to continue.')\n",
    "        with UntilDone():\n",
    "            KeyPress()\n",
    "        Wait(ISI_dur, jitter=ISI_jitter)\n",
    "        \n",
    "    Trial(trial.current)\n",
    "\n",
    "# run the experiment\n",
    "exp.run()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Assignment before next class\n",
    "\n",
    "- Your memory listgen assignment is due next week.\n",
    "- We'll be posting a small SMILE assignment soon.\n",
    "- Continue familiarizing yourself with SMILE, since that will be front and center for the next assignment.\n",
    "\n",
    "\n",
    "### See you next week!!!"
   ]
  }
 ],
 "metadata": {
  "celltoolbar": "Slideshow",
  "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.10.12"
  },
  "rise": {
   "scroll": true
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}