{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# include controllers to the path\n",
    "import sys, os\n",
    "sys.path.append(os.getcwd())\n",
    "sys.path.append(os.path.join(os.getcwd(), 'controllers'))\n",
    "\n",
    "# include pipeline repo to compute performance\n",
    "sys.path.append(os.path.join(os.getcwd(), '..'))\n",
    "sys.path.append(os.path.join(os.getcwd(), '..', 'pipeline'))\n",
    "sys.path.append(os.path.join(os.getcwd(), '..', 'pipeline', 'postprocessing'))\n",
    "\n",
    "import cv2\n",
    "import threading\n",
    "import math\n",
    "import time\n",
    "import random\n",
    "import json\n",
    "import datetime\n",
    "import os, shutil\n",
    "import numpy as np\n",
    "import multiprocess as mp\n",
    "\n",
    "# controllers\n",
    "import nbimporter\n",
    "from controllers.situtils import FPSTimes\n",
    "from controllers.camera import WebcamStream\n",
    "from controllers.video import VideoWriter\n",
    "from controllers.microphones import MicrophoneController\n",
    "from controllers.position import PositionTrackerSingle, PositionTrackerDouble\n",
    "from controllers.sound import SoundController, ContinuousSoundStream\n",
    "from controllers.serial import MCSArduino, FakeArduino, SpeakerMotor, CableMotor\n",
    "from controllers.display import SITDisplay\n",
    "from controllers.island import IslandFactory\n",
    "\n",
    "from pipeline.postprocessing.pack import pack\n",
    "from pipeline.postprocessing.performance import calculate_performance, dump_performance_to_H5"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Load experiment settings\n",
    "\n",
    "For every experimental cofiguration you can copy the original 'settings.json' file, build your own specific experimental preset, save it in this folder as e.g. 'settings_elena.json' and load it here instead of 'settings.json'."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "cfg_filename = os.path.join('profiles', 'passive_FDA.json')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "with open(os.path.join('profiles', 'default.json')) as json_file:\n",
    "    cfg = json.load(json_file)\n",
    "with open(cfg_filename) as json_file:\n",
    "    cfg_local = json.load(json_file)\n",
    "\n",
    "for key in cfg.keys():\n",
    "    if key in cfg_local: # only update if the key exists in the local config, otherwise keep default (important for backward compatibility with cfg files before microphones)\n",
    "        cfg[key].update(cfg_local[key])\n",
    "cfg['experiment']['experiment_date'] = datetime.datetime.now().strftime('%Y-%m-%d_%H-%M-%S')\n",
    "\n",
    "# print loaded settings\n",
    "#print(json.dumps(cfg, indent=4))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Initialize session folder\n",
    "\n",
    "Run the upcoming cell, to create a session folder and to save the chosen experimetal parameters to a JSON-file (\"experiment_id_parameters.json\"). The session folder will be created here where this notebook is located."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# This session's protocols will be saved to this folder\n",
    "cfg_exp = cfg['experiment']\n",
    "experiment_id = \"%s_%s_%s\" % (cfg_exp['subject'], cfg_exp['experiment_type'], cfg_exp['experiment_date'])\n",
    "save_to = os.path.join('sessions', experiment_id)\n",
    "             \n",
    "if not os.path.exists(save_to):\n",
    "    os.makedirs(save_to)\n",
    "\n",
    "# update paths (assuming this paths are relative to this notebook)\n",
    "cfg['video']['file_path'] = os.path.join(save_to, cfg['video']['file_path'])\n",
    "cfg['video']['csv_path'] = os.path.join(save_to, cfg['video']['csv_path'])\n",
    "cfg['microphones']['file_path'] = os.path.join(save_to, cfg['microphones']['file_path'])\n",
    "cfg['microphones']['csv_path'] = os.path.join(save_to, cfg['microphones']['csv_path'])\n",
    "cfg['position']['file_path'] = os.path.join(save_to, cfg['position']['file_path'])\n",
    "cfg['position']['contour_path'] = os.path.join(save_to, cfg['position']['contour_path'])\n",
    "cfg['experiment']['file_path'] = os.path.join(save_to, cfg['experiment']['file_path'])\n",
    "cfg['experiment']['islands_path'] = os.path.join(save_to, 'islands.csv')\n",
    "cfg['sound']['file_path'] = os.path.join(save_to, cfg['sound']['file_path'])\n",
    "cfg['position']['background_light'] = os.path.join('assets', cfg['position']['background_light'])\n",
    "cfg['position']['background_dark'] = os.path.join('assets', cfg['position']['background_dark'])\n",
    "if 'wav_file' in cfg['sound']:\n",
    "    cfg['sound']['wav_file'] = os.path.join('assets', cfg['sound']['wav_file'])\n",
    "if 'continuous' in cfg['sound']:\n",
    "    cfg['sound']['continuous']['wav_file'] = os.path.join('assets', cfg['sound']['continuous']['wav_file'])\n",
    "    \n",
    "# Saves all parameters to a JSON file with the user-defined \"Experiment ID\" as filename\n",
    "with open(os.path.join(save_to, experiment_id + '.json'), 'w') as f:\n",
    "    json.dump(cfg, f, indent=4)\n",
    "    \n",
    "with open(cfg['experiment']['file_path'], 'w') as f:\n",
    "    # state: 0 - trial start, 1 - trial success, 2 - trial fail\n",
    "    f.write('time, target_x, target_y, target_r, trial, state\\n')\n",
    "\n",
    "with open(cfg['experiment']['islands_path'], 'w') as f:\n",
    "    f.write('tgt_x, tgt_y, tgt_r, d1_x, d1_y, d1_r, d2_x, d2_y, d2_r, d3_x, d3_y, d3_r\\n')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "def timeout(t_start):\n",
    "    return time.time() - t_start > cfg_exp['session_duration'] if t_start is not None else False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "def log_event(*args):  # log start / end of a trial\n",
    "    with open(cfg_exp['file_path'], 'a') as f:\n",
    "        f.write(\",\".join([str(x) for x in args]) + \"\\n\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "def log_islands(islands):  # log position of the islands\n",
    "    sorted_islands = sorted(islands, key=lambda x: x.sound_id, reverse=False)\n",
    "    args = [(i.x, i.y, i.r) for i in sorted_islands]\n",
    "    to_dump = [x for xs in args for x in xs]\n",
    "        \n",
    "    with open(cfg_exp['islands_path'], 'a') as f:    \n",
    "        f.write(\",\".join([str(round(x, 4)) for x in to_dump]) + \"\\n\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "def switch_light(pt, board):\n",
    "    pt.switch_background()\n",
    "    board.switch_light()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Start the experiment\n",
    "\n",
    "This cell contains code for animal tracking. We hope that the comments provided in the code suffice to understand the individual steps and to adjust them to your own setup and needs, if necessary.\n",
    "\n",
    "- press 's' to start recording\n",
    "- press 's' again to stop recording\n",
    "- press 'q' to quit\n",
    "\n",
    "The experiment will stop automatically if the pre-defined session duration is reached."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Webcam stream 1024.0:768.0 at 30.00 FPS started\n",
      "{-1: 'noise', 0: 'silence', 1: 'D6', 2: 'F5', 3: 'I3', 4: 'F4', 5: 'D1', 6: 'F3', 7: 'F1', 8: 'D5', 9: 'I1', 10: 'F2', 11: 'D2', 12: 'D3', 13: 'I4', 14: 'I2', 15: 'D4'}\n",
      "Position tracker stopped\n",
      "Video writer stopped\n",
      "Camera released\n"
     ]
    }
   ],
   "source": [
    "# actual sound selector: -1 - noise, 0 - silence, 1 - foraging, 2 - target, 3 - distractor\n",
    "sound = mp.Value('i', 1)\n",
    "if 'noise_when_idle' in cfg_exp and cfg_exp['noise_when_idle']:\n",
    "    sound.value = -1\n",
    "\n",
    "# experiment status: 1 - idle, 2 - running (recording, logging), 0 - stopped\n",
    "status = mp.Value('i', 1)\n",
    "\n",
    "# init the sync with the acquisition system and feeder via Arduino\n",
    "if cfg['experiment']['MCSArduinoPort'] == 'fake':\n",
    "    board = FakeArduino()\n",
    "else:\n",
    "    board = MCSArduino(cfg['experiment']['MCSArduinoPort'])\n",
    "\n",
    "# init speaker motor control\n",
    "if 'motors_port' in cfg['experiment'] and cfg['experiment']['enable_motors']:\n",
    "    motor_board = SpeakerMotor(cfg['experiment']['motors_port'])\n",
    "    \n",
    "# init ephys cable rotation motor\n",
    "if 'cable_motor_port' in cfg['experiment']:\n",
    "    cable_board = CableMotor(cfg['experiment']['cable_motor_port'])\n",
    "\n",
    "# init continuous sound, if required\n",
    "if 'continuous' in cfg['sound']:\n",
    "    cst = ContinuousSoundStream(cfg['sound']['continuous'])\n",
    "    cst.start()\n",
    "    \n",
    "# start the camera stream\n",
    "vs = WebcamStream(cfg['camera'])\n",
    "vs.start()\n",
    "\n",
    "# init video recorder\n",
    "vw = VideoWriter(status, vs, cfg['video'])\n",
    "vw.start()\n",
    "\n",
    "# init microphone controller, if required\n",
    "if cfg['microphones']['record_audio']:\n",
    "    mc = mp.Process(target=MicrophoneController.run, args=(status,cfg[\"microphones\"]))\n",
    "    mc.start()\n",
    "\n",
    "# start position tracking\n",
    "pt = PositionTrackerSingle(status, vs, cfg['position']) if cfg['position']['single_agent'] else PositionTrackerDouble(status, vs, cfg['position'])\n",
    "pt.start()\n",
    "# print(pt.mask.shape)\n",
    "# init frame renderer\n",
    "dc = SITDisplay(pt, cfg['video'])\n",
    "\n",
    "# playing sound in a separate process for performance\n",
    "sounds = cfg['sound']['sounds']\n",
    "commutator = {\n",
    "    -1: 'noise',\n",
    "    0:  'silence'\n",
    "}\n",
    "\n",
    "# ordered sound presentations - F, D, I, L\n",
    "# sound_order = 1\n",
    "# for s_type in ('F', 'D', 'I', 'L'):\n",
    "#     keys = sorted([key for key in sounds.keys() if key.startswith(s_type)])\n",
    "#     for key in keys:\n",
    "#         commutator[sound_order] = key\n",
    "#         sound_order += 1\n",
    "\n",
    "# random sound presentations\n",
    "sound_keys = [key for key in sounds.keys() if not key.startswith('noise')]\n",
    "comm_keys  = [i+1 for i in list(range(len(sound_keys)))]\n",
    "for i in comm_keys:\n",
    "    key = sound_keys.pop(random.randrange(len(sound_keys)))\n",
    "    commutator[i] = key\n",
    "\n",
    "print(commutator)\n",
    "\n",
    "sc = mp.Process(target=SoundController.run, args=(sound, status, cfg['sound'], commutator))\n",
    "sc.start()\n",
    "\n",
    "cfg_pos = cfg['position']\n",
    "isl_factory = IslandFactory(cfg_pos['floor_r_in_meters'], cfg_pos['angle_compensation'], cfg['experiment'])\n",
    "\n",
    "timers = []\n",
    "fps = FPSTimes()\n",
    "names = ['camera', 'video', 'position', 'main']\n",
    "distr_count = cfg['experiment']['distractor_islands']\n",
    "trial = 0\n",
    "rewards = 0\n",
    "t_start = None\n",
    "target_since = None\n",
    "distractor_since = None\n",
    "punishment_since = None\n",
    "trial_start = time.time()\n",
    "phase = 0  # 0 - idle, 1 - foraging, 2 - inter-trial interval\n",
    "cfg_exp = cfg['experiment']\n",
    "cfg_pos = cfg['position']\n",
    "islands = []\n",
    "iti_distance = 0.0\n",
    "last_x, last_y = None, None\n",
    "cfg_exp['trial_number'] = max([int(key) for key in commutator.keys()])  # equals number of diff sounds\n",
    "\n",
    "try:\n",
    "    while trial <= cfg_exp['trial_number'] and not timeout(t_start):\n",
    "        \n",
    "        # ---------- rendering logic -----------\n",
    "        frame = vs.read()\n",
    "        if frame is None:\n",
    "            time.sleep(0.1)\n",
    "            continue # wait for the stream\n",
    "            \n",
    "        c_time = time.time()\n",
    "        fps.count()\n",
    "        angles, text_infos = [], []\n",
    "        \n",
    "        if not cfg_exp['target_angle'] == 'random':\n",
    "            phi = isl_factory.phi_initial\n",
    "            angles = [pt.correct_angle(phi), pt.correct_angle(phi) + np.deg2rad(cfg_exp['phi_max'])]\n",
    "        \n",
    "        for i, ctrl in enumerate([vs, vw, pt, fps]):  # FPS indicators\n",
    "            text_infos.append('%s: %.2f FPS' % (names[i], ctrl.get_avg_fps()))\n",
    "        \n",
    "        if len(islands) > 0:  # target island X, Y\n",
    "            target = [i for i in islands if not i.is_distractor][0]\n",
    "            text_infos.append('Target: %.3f %.3f' % (target.x, target.y))\n",
    "\n",
    "        text_infos.append('Time: %.2f' % float(c_time - t_start) if t_start is not None else 'Time: Idle')  # stopwatch\n",
    "        text_infos.append('Trial: %.2f' % float(cfg_exp['trial_duration'] - (c_time - trial_start)) if phase == 1 else 'Trial: not started')\n",
    "        text_infos.append('Trial: %s' % trial)\n",
    "        text_infos.append('Rewards: %s' % rewards)  # rewards\n",
    "        text_infos.append('In target: %.2f' % float(c_time - target_since) if target_since is not None else 'In target: --')\n",
    "        text_infos.append('ITI distance: %.2f' % iti_distance if iti_distance > 0 else 'ITI distance: --')\n",
    "\n",
    "        frame, frame_to_save = dc.render(frame, status, islands=islands, angles=angles, text_infos=text_infos)\n",
    "            \n",
    "        # assign the frame back to the video stream for other controllers\n",
    "        vs.frame_with_infos = frame_to_save\n",
    "        \n",
    "        cv2.imshow('Press (s)-to start/stop, (q)-to end', frame)\n",
    "\n",
    "        # -------- experiment logic ---------------\n",
    "        \n",
    "        if status.value == 2 and c_time - trial_start > cfg_exp['trial_duration']:\n",
    "            log_event(c_time, 0, 0, 0, trial, 1) # log trial end\n",
    "            trial += 1\n",
    "            if int(sound.value) < cfg_exp['trial_number']:\n",
    "                sound.value += 1\n",
    "            trial_start = c_time\n",
    "            log_event(c_time, 0, 0, 0, trial, 0) # log trial start\n",
    "        \n",
    "        # -------- key press events ---------------\n",
    "        \n",
    "        k = cv2.waitKey(33)\n",
    "        \n",
    "        # light on/off\n",
    "        if k == ord('l'):\n",
    "            switch_light(pt, board)\n",
    "        \n",
    "        # motors\n",
    "        if k == ord('d'):\n",
    "            if cfg['experiment']['enable_motors']:\n",
    "                motor_board.switch_diodes()\n",
    "         \n",
    "        # ephys cable on top\n",
    "        if k == ord('i') and 'cable_motor_port' in cfg['experiment']:\n",
    "            tf = threading.Timer(0, cable_board.turn_CCW, args=[])\n",
    "            tf.start()\n",
    "        if k == ord('o') and 'cable_motor_port' in cfg['experiment']:\n",
    "            tf = threading.Timer(0, cable_board.turn_CW, args=[])\n",
    "            tf.start()\n",
    "            \n",
    "        # feeding\n",
    "        if k == ord('f'):\n",
    "            tf = threading.Timer(0, board.feed, args=[])\n",
    "            tf.start()\n",
    "\n",
    "        if k == ord('c'):\n",
    "            f_name = cfg_pos['background_light'] if pt.is_light else cfg_pos['background_dark']\n",
    "            cv2.imwrite(f_name, dc.masked_frame)\n",
    "            tf = threading.Timer(0.2, pt.reload_background, args=[])\n",
    "            tf.start()            \n",
    "\n",
    "        # quit the session\n",
    "        if k == ord('q'):\n",
    "            break\n",
    "\n",
    "        # start the experiment\n",
    "        if k == ord('s'):\n",
    "            board.start_or_stop()  # start/stop data acquisition\n",
    "            c_time = time.time()   # more accurate time\n",
    "            \n",
    "            if cfg['experiment']['enable_motors']:\n",
    "                if not motor_board.diodes_on:\n",
    "                    motor_board.switch_diodes()\n",
    "\n",
    "            if status.value == 1: # start the session\n",
    "                if t_start is None:\n",
    "                    t_start = c_time\n",
    "                trial_start = c_time\n",
    "                status.value = 2\n",
    "                \n",
    "                # init_new_trial\n",
    "                sound.value = 1\n",
    "                phase = 1\n",
    "                trial += 1\n",
    "\n",
    "                # log trial start\n",
    "                log_event(c_time, 0, 0, 0, trial, 0) # log trial start\n",
    "                \n",
    "            elif status.value == 2:  # pause the session\n",
    "                if len(islands) > 0:\n",
    "                    tgt = [i for i in islands if not i.is_distractor][0]\n",
    "                    x, y, r = round(tgt.x, 4), round(tgt.y, 4), round(tgt.r, 4)\n",
    "                else:\n",
    "                    x, y, r = 0, 0, 0\n",
    "                log_event(c_time, x, y, r, trial, -1)  # log experiment break\n",
    "                \n",
    "                if 'noise_when_idle' in cfg_exp and cfg_exp['noise_when_idle']:\n",
    "                    sound.value = -1\n",
    "                status.value = 1\n",
    "                phase = 0\n",
    "                islands = []\n",
    "                for t in timers:\n",
    "                    t.cancel()\n",
    "                    \n",
    "        if k == ord('a'):\n",
    "            sound.value = -1 if sound.value >= 0 else 0\n",
    "            switch_light(pt, board)  # turn lights off \n",
    "\n",
    "finally:\n",
    "    if status.value == 2:  # stop data acquisition, in case exited via timeout\n",
    "        board.start_or_stop()\n",
    "        if len(islands) > 0:\n",
    "            tgt = [i for i in islands if not i.is_distractor][0]\n",
    "            x, y, r = round(tgt.x, 4), round(tgt.y, 4), round(tgt.r, 4)\n",
    "        else:  \n",
    "            x, y, r = 0, 0, 0\n",
    "        log_event(c_time, x, y, r, trial, -1)  # log experiment end\n",
    "        \n",
    "    status.value = 0\n",
    "    time.sleep(0.01)\n",
    "    for t in timers:\n",
    "        t.cancel()\n",
    "    \n",
    "    #if board.is_light_off:\n",
    "    #    board.switch_light()  # turn light back on\n",
    "    #    time.sleep(0.1)\n",
    "    board.exit()\n",
    "    \n",
    "    if cfg['experiment']['enable_motors']:\n",
    "        if motor_board.diodes_on:\n",
    "            motor_board.switch_diodes()\n",
    "        motor_board.exit()\n",
    "    if 'cable_motor_port' in cfg['experiment']:\n",
    "        cable_board.exit()\n",
    "    \n",
    "    cv2.destroyAllWindows()\n",
    "    sc.join()\n",
    "    for ctrl in [pt, vw, vs]:\n",
    "        ctrl.stop()\n",
    "\n",
    "    # stop microphones recording process\n",
    "    if cfg['microphones']['record_audio']:\n",
    "        mc.join()\n",
    "\n",
    "    if 'continuous' in cfg['sound']:\n",
    "        time.sleep(cfg['sound']['continuous']['end_sleep'])\n",
    "        cst.stop()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Merge data in HDF5 file"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "session_path = save_to\n",
    "#trial = 5\n",
    "#session_path = os.path.join('sessions', '2021-07-30_09-24-14')  # some particular session\n",
    "#session_path = 'Y:\\\\Michael\\\\FreeBehaving\\\\SIT_sessions\\\\51_aSIT_2021-12-03_13-31-51'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "D:\\runSIT\\..\\pipeline\\postprocessing\\pack.py:59: UserWarning: loadtxt: Empty input file: \"sessions\\57_SIT_passive_2024-02-01_16-22-22\\islands.csv\"\n",
      "  data = np.loadtxt(filename, delimiter=',', skiprows=1)\n"
     ]
    }
   ],
   "source": [
    "if not trial > 0:\n",
    "    raise SystemExit('Nothing recorded. No sense to continue.')\n",
    "\n",
    "# do pack data to HDF5\n",
    "h5name = pack(session_path)\n",
    "trial = 0"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Plot sessions stats"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "import h5py\n",
    "import numpy as np\n",
    "from scipy import signal"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "arena_r = 0.4  # in meters\n",
    "\n",
    "with h5py.File(h5name, 'r') as f:\n",
    "    tl = np.array(f['processed']['timeline'])\n",
    "    trial_idxs = np.array(f['processed']['trial_idxs'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Text(0.5, 1.0, 'Speed')"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x864 with 4 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig = plt.figure(figsize=(12, 12))\n",
    "\n",
    "# trajectory and islands\n",
    "ax = fig.add_subplot(221)\n",
    "ax.scatter(tl[:, 1], tl[:, 2], s=1, alpha=0.1)  # positions\n",
    "scat = ax.scatter(trial_idxs[:, 2], trial_idxs[:, 3], s=1000, facecolors='none', edgecolors='r')  # islands, radius approx.\n",
    "ax.add_patch(plt.Circle((0, 0), arena_r, color='r', fill=False))\n",
    "ax.set_aspect('equal')\n",
    "ax.set_xlabel('X, m', fontsize=14)\n",
    "ax.set_ylabel('Y, m', fontsize=14)\n",
    "ax.set_title('Running', fontsize=14)\n",
    "ax.grid()\n",
    "\n",
    "# occupancy\n",
    "sigma = 0.1\n",
    "lin_profile = np.linspace(-15, 15, 20)\n",
    "bump = np.exp(-sigma * lin_profile**2)\n",
    "bump /= np.trapz(bump)  # normalize to 1\n",
    "kernel = bump[:, np.newaxis] * bump[np.newaxis, :]\n",
    "occupancy_map, _, _ = np.histogram2d(tl[:, 1], tl[:, 2], bins=[40, 40], range=np.array([[-0.5, 0.5], [-0.5, 0.5]]))\n",
    "occupancy_map = signal.convolve2d(occupancy_map, kernel, mode='same')\n",
    "\n",
    "ax = fig.add_subplot(222)\n",
    "ax.imshow(occupancy_map.T, origin='lower', extent=(-0.5, 0.5, -0.5, 0.5), cmap='Blues')\n",
    "ax.add_patch(plt.Circle((0, 0), arena_r, color='r', fill=False))\n",
    "ax.set_xlabel('X, m', fontsize=14)\n",
    "ax.set_title('Occupancy', fontsize=14)\n",
    "ax.grid()\n",
    "\n",
    "# trials\n",
    "durations = tl[trial_idxs[:, 1].astype(int)][:, 0] - tl[trial_idxs[:, 0].astype(int)][:, 0]\n",
    "colors = ['red' if x == 1 else 'grey' for x in trial_idxs[:, 5]]\n",
    "\n",
    "ax = fig.add_subplot(223)\n",
    "ax.barh(np.arange(len(trial_idxs)), durations, color=colors, align='center')\n",
    "ax.set_xlabel('Time, s', fontsize=14)\n",
    "ax.set_ylabel('Trial, #', fontsize=14)\n",
    "ax.set_title('Trials', fontsize=14)\n",
    "\n",
    "# speed\n",
    "ax = fig.add_subplot(224)\n",
    "\n",
    "s_rate = 100  # Hz\n",
    "window = 60   # secs\n",
    "step = 10     # secs\n",
    "duration = tl[-1][0]\n",
    "x_vals = np.arange(int(duration/step))\n",
    "\n",
    "inst_speed = [tl[x*step*s_rate:(x*step + window)*s_rate][:, 3].mean() for x in x_vals]\n",
    "ax.plot(x_vals*step, inst_speed)\n",
    "ax.set_ylabel('Speed, m/s', fontsize=14)\n",
    "ax.set_xlabel('Time, s', fontsize=14)\n",
    "ax.set_title('Speed', fontsize=14)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Performance"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "ename": "IndexError",
     "evalue": "index 0 is out of bounds for axis 0 with size 0",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mIndexError\u001b[0m                                Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-15-2773e6550683>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m     28\u001b[0m     \u001b[0mtr_idxs\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mtrial_idxs\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mtrial_starts\u001b[0m \u001b[1;33m>=\u001b[0m \u001b[0mt_start\u001b[0m\u001b[1;33m)\u001b[0m \u001b[1;33m&\u001b[0m \u001b[1;33m(\u001b[0m\u001b[0mtrial_ends\u001b[0m \u001b[1;33m<=\u001b[0m \u001b[0mt_end\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     29\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m---> 30\u001b[1;33m     \u001b[0mdataset\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mcalculate_performance\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mtl\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mtr_idxs\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mcfg\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m     31\u001b[0m     \u001b[0mdump_performance_to_H5\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mh5name\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mds_name\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mdataset\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32mD:\\runSIT\\..\\pipeline\\postprocessing\\performance.py\u001b[0m in \u001b[0;36mcalculate_performance\u001b[1;34m(tl, trial_idxs, cfg)\u001b[0m\n\u001b[0;32m    103\u001b[0m         \u001b[0mtemp_index\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0marange\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mtrial_idxs\u001b[0m\u001b[1;33m[\u001b[0m\u001b[0mtrial\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m0\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mtrial_idxs\u001b[0m\u001b[1;33m[\u001b[0m\u001b[0mtrial\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m1\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mpos_downsample\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mastype\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mnp\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mint32\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    104\u001b[0m         \u001b[0mtemp_traj\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mtl\u001b[0m\u001b[1;33m[\u001b[0m\u001b[0mtemp_index\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m--> 105\u001b[1;33m         \u001b[0mtemp_traj\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;36m0\u001b[0m\u001b[1;33m]\u001b[0m \u001b[1;33m-=\u001b[0m \u001b[0mtemp_traj\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m0\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m0\u001b[0m\u001b[1;33m]\u001b[0m  \u001b[1;31m# time relative to trial start\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m    106\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    107\u001b[0m         \u001b[1;32mfor\u001b[0m \u001b[0msurr\u001b[0m \u001b[1;32min\u001b[0m \u001b[0mrange\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mno_fake_islands\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;31mIndexError\u001b[0m: index 0 is out of bounds for axis 0 with size 0"
     ]
    }
   ],
   "source": [
    "h5name = os.path.join(session_path, experiment_id + '.h5')\n",
    "jsname = os.path.join(session_path, experiment_id + '.json')\n",
    "\n",
    "# loading position and trial data\n",
    "with h5py.File(h5name, 'r') as f:\n",
    "    tl = np.array(f['processed']['timeline'])  # time, X, Y, speed\n",
    "    trial_idxs = np.array(f['processed']['trial_idxs'])  # idx start, idx end, X, Y, R, trial result (idx to tl)\n",
    "\n",
    "# loading session configuration\n",
    "with open(jsname, 'r') as f:\n",
    "    cfg = json.load(f)\n",
    "\n",
    "timepoints = cfg['experiment']['timepoints']\n",
    "s_duration = cfg['experiment']['session_duration']\n",
    "if len(timepoints) > 0:\n",
    "    periods = [[0, s_duration], [0, timepoints[0]], [timepoints[1], timepoints[2]], [timepoints[3], s_duration]]\n",
    "else:\n",
    "    periods = [[0, s_duration]]\n",
    "\n",
    "# separate ALL, L, D, L'\n",
    "ds_names = ['performance_ALL', 'performance_L', 'performance_D', 'performance_Lp']\n",
    "ds_names = ['performance_ALL']  # only light\n",
    "\n",
    "for i, ds_name in enumerate(ds_names):\n",
    "    t_start, t_end = periods[i]\n",
    "    trial_starts = tl[trial_idxs[:, 0].astype(np.int32)][:, 0]\n",
    "    trial_ends   = tl[trial_idxs[:, 1].astype(np.int32)][:, 0]\n",
    "    tr_idxs = trial_idxs[(trial_starts >= t_start) & (trial_ends <= t_end)]\n",
    "\n",
    "    dataset = calculate_performance(tl, tr_idxs, cfg)\n",
    "    dump_performance_to_H5(h5name, ds_name, dataset)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig = plt.figure(figsize=(4, 4))\n",
    "\n",
    "with h5py.File(h5name, 'r') as f:\n",
    "    perf = np.array(f['analysis']['performance_ALL'])\n",
    "    x = perf[:, 6]\n",
    "\n",
    "ax = fig.add_subplot(111)\n",
    "\n",
    "ax.plot(x, perf[:, 0])  # performance\n",
    "ax.plot(x, perf[:, 3])  # chance\n",
    "ax.fill_between(x, perf[:, 0] + perf[:, 1], perf[:, 0] + perf[:, 2], alpha=0.4)\n",
    "ax.fill_between(x, perf[:, 3] + perf[:, 4], perf[:, 3] + perf[:, 5], alpha=0.4)\n",
    "ax.set_ylim(0, 110)\n",
    "ax.set_xlim(0, 65)\n",
    "ax.grid()\n",
    "ax.set_title(experiment_id[-19:], fontsize=14)\n",
    "ax.set_xlabel('Time, s', fontsize=14)\n",
    "\n",
    "if i == 0:\n",
    "    ax.set_ylabel('Successful trials, %', fontsize=14)\n",
    "        \n",
    "fig.tight_layout()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import this\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}