tutorial.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# nwb-photostim tutorial\n",
    "\n",
    "In the following tutorial, we demonstrate use of the `nwb-photostim` extension to the NWB data standard. Specifically we:\n",
    "1. Create `SpatialLightModulator` and `PhotostimulationDevice` containers, representing the devices used in the paradigm.\n",
    "2. Use the `HolographicPattern` object to store the photostimulation stimuli\n",
    "3. Record the time series of stimulus presentation with the `PresentationSeries` container\n",
    "4. Record all photostimulation data for a given experiment using a proecessing module and the `PresentationTable` container\n",
    "5. Write all devices, stimuli, and presentation tables to an `.nwb` file and confirm it can be read back"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "First, we import then necessary files and create an empty `NWBFile`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "from pynwb import NWBFile, NWBHDF5IO\n",
    "from ndx_photostim import SpatialLightModulator, Laser, PhotostimulationMethod, HolographicPattern, \\\n",
    "        PhotostimulationSeries, PhotostimulationTable\n",
    "import numpy as np\n",
    "from dateutil.tz import tzlocal\n",
    "from datetime import datetime\n",
    "\n",
    "nwbfile = NWBFile('my first synthetic recording','EXAMPLE_ID',datetime.now(tzlocal()))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Spatial light modulator and laser\n",
    "\n",
    "We begin by creating optional `SpatialLightModulator` and `Laser` containers, to represent the spatial light modulator and laser used in the stimulation paradigm, respectively."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "slm = SpatialLightModulator(name='slm',\n",
    "                                model='Meadowlark',\n",
    "                                size=np.array([512, 512]))\n",
    "\n",
    "laser = Laser(name='laser',\n",
    "                  model='Coherent Monaco',\n",
    "                  wavelength=1030,\n",
    "                  power=8,\n",
    "                  peak_pulse_energy=20,\n",
    "                  pulse_rate=500)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## PhotostimulationMethod\n",
    "\n",
    "We can then add these to a `PhotostimulationMethod` using the `add_slm` and `add_laser` methods."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "methodA ndx_photostim.photostim.PhotostimulationMethod at 0x140289625857136\n",
      "Fields:\n",
      "  laser: laser ndx_photostim.photostim.Laser at 0x140289625813584\n",
      "Fields:\n",
      "  model: Coherent\n",
      "  peak_pulse_energy: 20\n",
      "  power: 8\n",
      "  pulse_rate: 500\n",
      "  wavelength: 1030\n",
      "\n",
      "  num_sweeps: 0\n",
      "  slm: slm ndx_photostim.photostim.SpatialLightModulator at 0x140289625813824\n",
      "Fields:\n",
      "  model: Meadowlark\n",
      "  size: [512 512]\n",
      "\n",
      "  stimulus_method: scanless\n",
      "  sweep_pattern: none\n",
      "  sweep_size: 0\n",
      "  time_per_sweep: 0\n",
      "\n"
     ]
    }
   ],
   "source": [
    "ps_method = PhotostimulationMethod(name=\"methodA\",\n",
    "                                       stimulus_method=\"scanless\",\n",
    "                                       sweep_pattern=\"none\",\n",
    "                                       sweep_size=0,\n",
    "                                       time_per_sweep=0,\n",
    "                                       num_sweeps=0)\n",
    "ps_method.add_slm(slm)\n",
    "ps_method.add_laser(laser)\n",
    "print(ps_method)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Holographic stimulation pattern\n",
    "\n",
    "The container `HolographicPattern` is used to store data corresponding to the pattern of stimulation for a given trial. The primary\n",
    "input to the function is a set of ROIs, that denote whether a given pixel is stimulated (encoded as 1) or not stimulated (encoded as 0)\n",
    "when that stimulus is presented. There are two ways to specify the ROIs: as an `image_mask_roi` or a `pixel_roi` (described below)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### ROIs specified using an image mask\n",
    "\n",
    "In the `image_mask_roi`, the input to `HolographicPattern` is an array or list with dimensionality `[width, height]` or `[width, height, depth`] covering the entire field of view. ROIs that are stimulated are encoded by 1 values, and unstimulated regions by zeros.\n",
    "\n",
    "In the example below, we simulate a `[50, 50]` pixel field of view, and randomly select 5 ROIs with a width and height of 5 pixels. To store the pattern in a `HolographicPattern` object, we use specify the ROIs using the `mask_roi` input argument on construction. A helper method `show_mask()` shows the simulated stimulated regions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYUAAAGFCAYAAAASI+9IAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjYuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8o6BhiAAAACXBIWXMAAA9hAAAPYQGoP6dpAAAFWUlEQVR4nO3cwYoiURBFQXOo///lnN2hQRicBn3aHbEW6m7kkKA1u7s3ALjdbn9ODwDgfYgCABEFACIKAEQUAIgoABBRACCiAECuRz84M8/cAcCTPfJfZZcCABEFACIKAEQUAIgoABBRACCiAEBEAYCIAgARBQAiCgBEFACIKAAQUQAgogBARAGAiAIAEQUAIgoARBQAiCgAEFEAIKIAQEQBgIgCABEFACIKAEQUAIgoAJDr9IDfZHdPT7gzM6cnAG/EpQBARAGAiAIAEQUAIgoARBQAiCgAEFEAIKIAQEQBgIgCABEFACIKAEQUAIgoABBRACCiAEBEAYCIAgARBQAiCgBEFACIKAAQUQAgogBARAGAiAIAEQUAIgoARBQAiCgAEFEAIKIAQEQBgIgCABEFAHKdHvCbzMzpCQD/5FIAIKIAQEQBgIgCABEFACIKAEQUAIgoABBRACCiAEBEAYCIAgARBQDiLanAR9jd0xPu/MQ3H7sUAIgoABBRACCiAEBEAYCIAgARBQAiCgBEFACIKAAQUQAgogBARAGAiAIAEQUAIgoARBQAiCgAEFEAIKIAQEQBgIgCABEFACIKAEQUAIgoABBRACCiAEBEAYCIAgARBQAiCgBEFACIKAAQUQAgogBArtMDAB4xM6cn/AouBQAiCgBEFACIKAAQUQAgogBARAGAiAIAEQUAIgoARBQAiCgAEFEAIKIAQEQBgIgCABEFACIKAEQUAIgoABBRACCiAEBEAYCIAgARBQAiCgBEFACIKAAQUQAgogBARAGAiAIAEQUAIgoARBQAiCgAEFEAIKIAQEQBgIgCABEFACIKAEQUAIgoABBRACCiAEBEAYCIAgARBQAiCgBEFACIKAAQUQAgogBARAGAiAIAEQUAIgoARBQAiCgAEFEAIKIAQEQBgIgCABEFACIKAEQUAIgoABBRACCiAEBEAYCIAgARBQAiCgBEFACIKAAQUQAgogBARAGAiAIAEQUAcp0e8Il29/SEOzNzegLwA7gUAIgoABBRACCiAEBEAYCIAgARBQAiCgBEFACIKAAQUQAgogBARAGAiAIAEQUAIgoARBQAiCgAEFEAIKIAQEQBgIgCABEFACIKAEQUAIgoABBRACCiAEBEAYCIAgARBQAiCgBEFACIKAAQUQAgogBArtMDPtHMnJ4A8BQuBQAiCgBEFACIKAAQUQAgogBARAGAiAIAEQUAIgoARBQAiCgAEFEAIKIAQEQBgIgCABEFACIKAEQUAIgoABBRACCiAEBEAYCIAgARBQAiCgBEFACIKAAQUQAgogBARAGAiAIAEQUAIgoARBQAiCgAEFEAIKIAQEQBgIgCABEFACIKAEQUAIgoABBRACCiAEBEAYCIAgARBQAiCgBEFACIKAAQUQAgogBARAGAiAIAEQUAIgoARBQAiCgAEFEAIKIAQEQBgIgCABEFACIKAEQUAIgoABBRACCiAEBEAYCIAgARBQAiCgBEFACIKAAQUQAgogBARAGAiAIAEQUAIgoARBQAiCgAEFEAIKIAQEQBgIgCALle8ZDdfcVj/svMnJ4AT+V7x3e4FACIKAAQUQAgogBARAGAiAIAEQUAIgoARBQAiCgAEFEAIKIAQEQBgIgCABEFACIKAEQUAIgoABBRACCiAEBEAYCIAgARBQAiCgBEFACIKAAQUQAgogBARAGAiAIAEQUAIgoARBQAiCgAEFEAIKIAQK5XPGRmXvEY4AvfO77DpQBARAGAiAIAEQUAIgoARBQAyMM/Sd3dZ+4A4A24FACIKAAQUQAgogBARAGAiAIAEQUAIgoARBQAyF8tGxwmldozQAAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "image_mask_roi = np.zeros((50, 50))\n",
    "\n",
    "n_rois = 5\n",
    "for _ in range(n_rois):\n",
    "    x = np.random.randint(0, 45)\n",
    "    y = np.random.randint(0, 45)\n",
    "    image_mask_roi[x:x + 5, y:y + 5] = 1\n",
    "\n",
    "hp_1 = HolographicPattern(name='pattern 1', image_mask_roi=image_mask_roi, stim_duration=0.300,\n",
    "                            power_per_target=8)\n",
    "hp_1.show_mask()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### ROIs specified by the center and diameter of each region\n",
    "\n",
    "Additionally, we provide a second method for specifying ROIs, the `pixel_roi`. `pixel_roi` inputs are a two- or three-dimensional vector of size `[num_rois, 3]` (in 2D stimulation) or `[num_rois, 4]` (in 3D stimulation). In the 2D case, `pixel_roi` takes the form `[(x1, y1), (x2, y2), ...]`, where `x` and `y` values correspond with the center of the ROI (in pixels). Similarly, in the 3D case, each element in the input takes the form `(x, y, z)`, where `z` denotes the depth of stimulation.\n",
    "\n",
    "As compared to `image_mask_roi`, `pixel_roi` construction require two additional specifications: `stimulation_diameter` and `dimension`. `stimulation_diameter` denotes, in pixels, the radius of the ROI centered at input location `(x, y)` or `(x, y, z)`. That is, each row of `pixel_roi` corresponds to an ROI at a given location, extending `stimulation_diameter` pixels in every direction. Additionally, the dimensions of the field of view, in pixels, must be specified by the `dimension` parameter, where `dimension=[width, height]` or `[width, height, depth]`.\n",
    "\n",
    "An example of a `HolographicPattern` with a `pixel_roi` input is shown below. This example includes 5 randomly-selected ROIs in a `[100, 100]` field of view, with a `stimulation_diameter` of 8 pixels. We use the helper function `show_mask()` to visualize the pattern."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "pixel_roi = []\n",
    "\n",
    "for i in range(5):\n",
    "    x = np.random.randint(0, 95)\n",
    "    y = np.random.randint(0, 95)\n",
    "\n",
    "    for ix in range(x, x + 1):\n",
    "        for iy in range(y, y + 1):\n",
    "            pixel_roi.append((ix, iy))\n",
    "\n",
    "hp_2 = HolographicPattern(name='pattern 2', pixel_roi=pixel_roi, roi_size=8, dimension=[100, 100], stim_duration=0.300,\n",
    "                            power_per_target=8)\n",
    "hp_2.show_mask()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Alternatively, ROIs can also be specified as rectangles (2D) or cuboids (3D) via two- or three-dimensional `roi_size` inputs, with format `[width, height]` or `[width, height, depth]`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "pixel_roi = []\n",
    "\n",
    "for i in range(5):\n",
    "    x = np.random.randint(0, 95)\n",
    "    y = np.random.randint(0, 95)\n",
    "\n",
    "    for ix in range(x, x + 1):\n",
    "        for iy in range(y, y + 1):\n",
    "            pixel_roi.append((ix, iy))\n",
    "\n",
    "hp_2 = HolographicPattern(name='pattern 2', pixel_roi=pixel_roi, roi_size=[6, 2], dimension=[100, 100], stim_duration=0.300,\n",
    "                            power_per_target=8)\n",
    "hp_2.show_mask()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Stimulation series\n",
    "\n",
    "The presentation of a given stimulation pattern over time is stored via the `PhotostimulationSeries` container.\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Interval format\n",
    "\n",
    "In the `'interval'` format, we store the onset and end of stimulus presentation using a 1D array consisting of the values 1 (stimulus on) and -1 (stimulus off). The corresponding times for the start and stop of the stimulus are specified via the `timestamps` property, where `data[i]==1` denotes that the stimulus was presented at time `timestamps[i]`, and `data[i+1]==-1` denotes it stopped at time `timestamps[i+1]` (time is specified in seconds). For example, in the cell below, we note that pattern `hp_1` was presented from seconds `0.5` to `1`, and then again from seconds `2` to `4`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "stim_series_1 = PhotostimulationSeries(name=\"series_1\", format='interval', data=[1, -1, 1, -1],\n",
    "                                       timestamps=[0.5, 1, 2, 4], pattern=hp_1,\n",
    "                                       method=ps_method)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "While we can specify the `data` and `timestamps` directly, we can also initialize an empty `PhotostimulationSeries` (by not providing a `data` or `timestamps` input), and use the function `add_interval(start, stop)` to store the presentation of the stimulus from time `start` to time `stop`. In the example below, the first call indicates presentation of the stimulus between seconds `10` and `20`, and then again from seconds `35` to `40`. We can call the helper method `to_dataframe()` to display `data` and `timestamps` simultaneously."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "   data  timestamps\n",
      "0     1        10.0\n",
      "1    -1        20.0\n",
      "2     1        35.0\n",
      "3    -1        40.0\n"
     ]
    }
   ],
   "source": [
    "stim_series_2 = PhotostimulationSeries(name=\"series_2\", format='interval',  pattern=hp_2, method=ps_method)\n",
    "stim_series_2.add_interval(10., 20.)\n",
    "stim_series_2.add_interval(35., 40.)\n",
    "\n",
    "print(stim_series_2.to_dataframe())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Series format\n",
    "\n",
    "In addition to the interval format, we can also encode presentation time series data as a \"series.\" In this format, rather than indicating the start and stop of stimulation,`data` consists of a 1D array of 0s and 1s denoting whether a stimulus was on or off at a given time step. In the example below, we note that the data is `[0, 1, 0, 1, 1, 0]`, the rate (i.e., the rate at which data are sampled, in Hz) is `10`, and the `stimulus_duration` is `0.05` (meaning that, at each time point where the stimulus is \"on\", denoted by a value of 1, it remains on for 0.05 seconds). In the case of the fourth element (`data[3]=1`), for example, the `rate` indicates that this point corresponds to 0.4 seconds into the trial (since `rate=10`, meaning there are 10 evenly-sampled data points per second). Since the value of the element is `1`, the stimulus was presented at that time, for `stimulus_duration=0.05` seconds. Expressed as an interval, the fourth time step indicates the stimulus was presented from *t*=0.4 to *t=0.05*.\n",
    "\n",
    "While less easily interpretable, we include `format='series'` as an option for the time series format because it may more closely align with the data collection modalities used in photostimulation methods."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "   data  timestamps\n",
      "0     0         0.0\n",
      "1     1         0.1\n",
      "2     0         0.2\n",
      "3     1         0.3\n",
      "4     1         0.4\n",
      "5     0         0.5\n"
     ]
    }
   ],
   "source": [
    "stim_series_3 = PhotostimulationSeries(name=\"series_3\", pattern=hp_1, format='series', stim_duration = 0.05, data=[0, 1, 0, 1, 1, 0], rate=10., method=ps_method)\n",
    "print(stim_series_3.to_dataframe())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the example above, we use the `rate` parameter instead of `timestamps` to express the times `data` correspond to. In the `'series'` format, we can still specify timestamps directly, as we did for the interval series. Here, the data `data[i]` corresponds to an interval beginning at time `timestamps[i]` and ending at time `timestamps[i]+stimulus_duration`. Note that `PhotostimulationSeries` requires one of either `rate` or `timestamps` to be specified for the series format, in order for data to be added.\n",
    "\n",
    "In addition to adding data directly, we can also add data using the `add_onset(time)` method, which denotes the onset of the stimulus at time `time` (for duration `stimulus_duration`)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "   data  timestamps\n",
      "0     0         0.0\n",
      "1     1         0.5\n",
      "2     0         2.0\n",
      "3     1         4.0\n",
      "4     1         5.0\n",
      "5     1        10.0\n",
      "6     1        14.0\n",
      "7     1        50.0\n"
     ]
    }
   ],
   "source": [
    "stim_series_4 = PhotostimulationSeries(name=\"series_4\", pattern=hp_2, format='series', stim_duration = 0.05, data=[0, 1, 0, 1], timestamps=[0, 0.5, 2, 4], method=ps_method)\n",
    "stim_series_4.add_onset(5)\n",
    "stim_series_4.add_onset([10, 14, 50])\n",
    "print(stim_series_4.to_dataframe())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `add_onset` function also works for the `'interval'` format:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "   data  timestamps\n",
      "0     1           1\n",
      "1    -1           3\n",
      "2     1          10\n",
      "3    -1          12\n",
      "4     1          18\n",
      "5    -1          20\n",
      "6     1          24\n",
      "7    -1          26\n"
     ]
    }
   ],
   "source": [
    "stim_series_5 = PhotostimulationSeries(name=\"series_5\", format='interval', pattern=hp_1, stim_duration=2, method=ps_method)\n",
    "stim_series_5.add_onset(1)\n",
    "stim_series_5.add_onset([10, 18, 24])\n",
    "print(stim_series_5.to_dataframe())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We then have to add each stimulus to the NWB file (to prevent parent/child errors below)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "for stim in [stim_series_1, stim_series_2, stim_series_3, stim_series_4, stim_series_5]:\n",
    "    nwbfile.add_stimulus(stim)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## PhotostimulationTable\n",
    "\n",
    "We store all the series and associated metadata for a given experiment in a `PhotostimulationTable`. The table constructor table takes as inputs the device used in simulation (`photostimulation_device`), as well as optional collection parameters (`stimulus_method`, `sweep_pattern`, `time_per_sweep` and `num_sweeps`). To add the `PhotostimulationSeries` containers, we call the `add_series` function, specifying a list of `PhotostimulationSeries` objects, as well as an optional list of names for each row. To display the table contents, we call the function `to_dataframe()` on the table."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "   row_name                                             series series_name  \\\n",
      "id                                                                           \n",
      "0     row_0  series_1 ndx_photostim.photostim.Photostimulat...    series_1   \n",
      "1     row_1  series_2 ndx_photostim.photostim.Photostimulat...    series_2   \n",
      "2     row_2  series_3 ndx_photostim.photostim.Photostimulat...    series_3   \n",
      "3     row_3  series_4 ndx_photostim.photostim.Photostimulat...    series_4   \n",
      "4     row_4  series_5 ndx_photostim.photostim.Photostimulat...    series_5   \n",
      "\n",
      "   series_format  num_samples  start_time  stop_time pattern_name method_name  \n",
      "id                                                                             \n",
      "0       interval            4         0.0       4.00    pattern 1     methodA  \n",
      "1       interval            4         0.0      40.00    pattern 2     methodA  \n",
      "2         series            6         0.0       0.25    pattern 1     methodA  \n",
      "3         series            8         0.0      50.00    pattern 2     methodA  \n",
      "4       interval            8         0.0      26.00    pattern 1     methodA  \n"
     ]
    }
   ],
   "source": [
    "sp = PhotostimulationTable(name='test', description='test desc')\n",
    "sp.add_series(series=[stim_series_1, stim_series_2, stim_series_3, stim_series_4, stim_series_5], row_name=['row_0', 'row_1', 'row_2', 'row_3', 'row_4'])\n",
    "print(sp.to_dataframe())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Plotting PhotostimulationTable timestamps\n",
    "\n",
    "The timestamps for each series in the `PhotostimulationTable` can be plotted simultaneously using the visualization function `plot()`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "sp.plot_presentation_times()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Creating a photostimulation processing module\n",
    "\n",
    "We then save the table to an `NWBFile` by creating a processing module, as shown below."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "test ndx_photostim.photostim.PhotostimulationTable at 0x140289625930912\n",
       "Fields:\n",
       "  colnames: ['row_name' 'series' 'series_name' 'series_format' 'num_samples'\n",
       " 'start_time' 'stop_time' 'pattern_name' 'method_name']\n",
       "  columns: (\n",
       "    row_name <class 'hdmf.common.table.VectorData'>,\n",
       "    series <class 'hdmf.common.table.VectorData'>,\n",
       "    series_name <class 'hdmf.common.table.VectorData'>,\n",
       "    series_format <class 'hdmf.common.table.VectorData'>,\n",
       "    num_samples <class 'hdmf.common.table.VectorData'>,\n",
       "    start_time <class 'hdmf.common.table.VectorData'>,\n",
       "    stop_time <class 'hdmf.common.table.VectorData'>,\n",
       "    pattern_name <class 'hdmf.common.table.VectorData'>,\n",
       "    method_name <class 'hdmf.common.table.VectorData'>\n",
       "  )\n",
       "  description: test desc\n",
       "  id: id <class 'hdmf.common.table.ElementIdentifiers'>"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "module = nwbfile.create_processing_module(name=\"photostimulation\", description=\"example photostimulation table\")\n",
    "module.add(sp)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Writing the file\n",
    "\n",
    "We can then write `nwbfile` file to an `.nwb` file as follows:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Users/harriscaw/anaconda3/envs/nwb-photostim/lib/python3.8/site-packages/hdmf/build/objectmapper.py:260: DtypeConversionWarning: Spec 'PhotostimulationSeries/timestamps': Value with data type int64 is being converted to data type float64 as specified.\n",
      "  warnings.warn(full_warning_msg, DtypeConversionWarning)\n"
     ]
    }
   ],
   "source": [
    "with NWBHDF5IO(\"basics_tutorial.nwb\", \"w\") as io:\n",
    "    io.write(nwbfile)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Reading the file\n",
    "\n",
    "We can then check that the file was saved correctly by reading it back, and accessing the \"`photostimulation`\" processing module."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "root pynwb.file.NWBFile at 0x140288820696592\n",
      "Fields:\n",
      "  file_create_date: [datetime.datetime(2023, 4, 25, 13, 32, 35, 560110, tzinfo=tzoffset(None, -14400))]\n",
      "  identifier: EXAMPLE_ID\n",
      "  processing: {\n",
      "    photostimulation <class 'pynwb.base.ProcessingModule'>\n",
      "  }\n",
      "  session_description: my first synthetic recording\n",
      "  session_start_time: 2023-04-25 13:32:35.559877-04:00\n",
      "  stimulus: {\n",
      "    series_1 <class 'ndx_photostim.photostim.PhotostimulationSeries'>,\n",
      "    series_2 <class 'ndx_photostim.photostim.PhotostimulationSeries'>,\n",
      "    series_3 <class 'ndx_photostim.photostim.PhotostimulationSeries'>,\n",
      "    series_4 <class 'ndx_photostim.photostim.PhotostimulationSeries'>,\n",
      "    series_5 <class 'ndx_photostim.photostim.PhotostimulationSeries'>\n",
      "  }\n",
      "  timestamps_reference_time: 2023-04-25 13:32:35.559877-04:00\n",
      "\n",
      "photostimulation pynwb.base.ProcessingModule at 0x140288829157184\n",
      "Fields:\n",
      "  data_interfaces: {\n",
      "    test <class 'ndx_photostim.photostim.PhotostimulationTable'>\n",
      "  }\n",
      "  description: example photostimulation table\n",
      "\n"
     ]
    }
   ],
   "source": [
    "with NWBHDF5IO(\"basics_tutorial.nwb\", \"r\", load_namespaces=True) as io:\n",
    "    read_nwbfile = io.read()\n",
    "print(read_nwbfile)\n",
    "print(read_nwbfile.processing['photostimulation'])"
   ]
  }
 ],
 "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": 4
}