Stream_Timepix_examples.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8981933e-6c8a-475d-aeda-c693b19ed6ed",
   "metadata": {
    "jupyter": {
     "source_hidden": true
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "# Imports\n",
    "\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "\n",
    "import asyncio\n",
    "\n",
    "from pymepix.channel.channel_types import ChannelDataType, Commands\n",
    "\n",
    "from online_data.timepix_monitor.tpx_acquisition import initialize_timepix_monitor, unregister_all\n",
    "from online_data.timepix_monitor.tpx_acquisition import callback\n",
    "\n",
    "from collections import deque\n",
    "\n",
    "import time\n",
    "import holoviews as hv\n",
    "from holoviews import opts\n",
    "from holoviews import streams\n",
    "from holoviews.streams import Pipe\n",
    "from bokeh.plotting import show\n",
    "hv.extension('bokeh')\n",
    "\n",
    "import sys\n",
    "import os"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8cdb924d",
   "metadata": {},
   "outputs": [],
   "source": [
    "initialize_timepix_monitor()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "453ec398",
   "metadata": {},
   "outputs": [],
   "source": [
    "'''A callback function declaration is:\n",
    "    \n",
    "@callback\n",
    "def on_data(in_data):\n",
    "    print(in_data['type'])\n",
    "    \n",
    "Stop sending data to callback functions:\n",
    "\n",
    "unregister_all()\n",
    "    \n",
    "'''\n",
    "unregister_all()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4bd05506",
   "metadata": {},
   "outputs": [],
   "source": [
    "\"\"\"Receiving the pixel data and plotting it\"\"\"\n",
    "\n",
    "H_VMI = np.zeros((255, 255))\n",
    "bins_VMI = (range(0, 256), range(0, 256))\n",
    "\n",
    "pixel_df_data = pd.DataFrame({'x': [], 'y': [], 'toa': [], 'tot': [],})\n",
    "pixel_buffer = Pipe(pixel_df_data)\n",
    "\n",
    "def my_VMI(data):\n",
    "    global H_VMI, bins_VMI\n",
    "    \n",
    "    H_VMI += np.histogram2d(data['x'], data['y'], bins=bins_VMI)[0]\n",
    "    #H_VMI += np.histogram2d(np.random.randint(255, size=100), np.random.randint(255, size=100),\\\n",
    "    #                       bins=bins_VMI)[0]\n",
    "    \n",
    "    #H_VMI_bg += np.histogram2d(df_bg['x'], df_bg['y'], bins=bins_VMI)[0]\n",
    "    return hv.Image(H_VMI.T[::-1], bounds=[bins_VMI[0][0], bins_VMI[1][0], bins_VMI[0][-1], bins_VMI[1][-1]], label='All').opts(logz=True, clim=(1e-3, None), cmap=\"jet\", frame_height=400, frame_width=400)\n",
    "\n",
    "@callback\n",
    "def on_data_pixel(in_data):\n",
    "    global pixel_buffer\n",
    "    if in_data['type'] == ChannelDataType.PIXEL.value:\n",
    "        '''recieved pixel data'''\n",
    "        #print(type(in_data['data']))\n",
    "        \n",
    "        pixel_buffer.send(in_data['data'])        \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1bdcb748",
   "metadata": {},
   "outputs": [],
   "source": [
    "hv.DynamicMap(my_VMI, streams=[pixel_buffer]) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "38e8d0b9",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9f5deee8",
   "metadata": {},
   "outputs": [],
   "source": [
    "\"\"\"Receiving the ToF data during recording (from scans) and accumulating it in records dictionary \"\"\"\n",
    "\n",
    "records = {}\n",
    "in_record = False\n",
    "records_accu = pd.DataFrame()\n",
    "record_num = 0\n",
    "\n",
    "@callback\n",
    "def on_data_command(in_data):\n",
    "    global in_record\n",
    "    global records_accu\n",
    "    global record_num\n",
    "    global records\n",
    "    \n",
    "    if in_data['type'] == ChannelDataType.COMMAND.value:\n",
    "        '''received COMMAND data'''\n",
    "        if in_data['data'] == Commands.START_RECORD.value:\n",
    "            in_record = True\n",
    "            records_accu = pd.DataFrame()\n",
    "            record_num += 1\n",
    "        elif in_data['data'] == Commands.STOP_RECORD.value:\n",
    "            in_record = False\n",
    "            records[record_num] = records_accu\n",
    "            \n",
    "    elif in_data['type'] == ChannelDataType.TOF.value and in_record == True:\n",
    "        '''TOF data'''\n",
    "        #print('added to accu')\n",
    "        records_accu = pd.concat([records_accu, in_data['data']])\n",
    "    \n",
    "        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "351e314d",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Plotting data (simple averaging) from records dictionary in upper cell\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "bde2de62",
   "metadata": {},
   "outputs": [],
   "source": [
    "records"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b4d8e5d6",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f122c6a5",
   "metadata": {},
   "outputs": [],
   "source": [
    "\"\"\"Plotting pixel (y) vs ToF\"\"\"\n",
    "\n",
    "tof_df_data = pd.DataFrame({'nr':[], 'x': [], 'y': [], 'tof': [], 'tot': [],})\n",
    "tof_buffer = Pipe(tof_df_data)\n",
    "\n",
    "bins_y_tof = (np.linspace(0, 10, 1000), range(256))\n",
    "H_y_tof = np.zeros((len(bins_y_tof[0])-1, len(bins_y_tof[1])-1))\n",
    "\n",
    "def my_x_tof(data):\n",
    "    global H_y_tof, bins_y_tof\n",
    "    \n",
    "    #print(data)    \n",
    "    #H_y_tof += np.histogram2d(data['tof'], data['y'], bins=bins_y_tof)[0]\n",
    "    H_y_tof += np.histogram2d( data['tof']*1e6, data['y'], bins=bins_y_tof)[0]\n",
    "    \n",
    "    \n",
    "    return hv.Image(H_y_tof.T[::-1], bounds=[bins_y_tof[0][0], bins_y_tof[1][0], bins_y_tof[0][-1], bins_y_tof[1][-1]]).opts(xlabel='ToF (µs)', ylabel='pixel (y)', width=900, logz=True, clim=(1e-3, None), cmap=\"jet\")\n",
    "\n",
    "@callback\n",
    "def on_data_tof(in_data):\n",
    "    global tof_buffer\n",
    "    if in_data['type'] == ChannelDataType.TOF.value:\n",
    "        '''recieved TOF data'''\n",
    "        #print(in_data['data'])\n",
    "        tof_buffer.send(in_data['data']) \n",
    "        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4630de1b",
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "hv.DynamicMap(my_x_tof, streams=[tof_buffer])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b5ba5741",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "77e0bd86",
   "metadata": {},
   "outputs": [],
   "source": [
    "'''Plotting rolling average'''\n",
    "\n",
    "#centroid_data=None\n",
    "\n",
    "averaging_window = 10\n",
    "\n",
    "rolling_length = 200\n",
    "\n",
    "rolling_array = deque(maxlen=rolling_length)\n",
    "\n",
    "centroid_df_data = pd.DataFrame({'nr':[], 'x':[], 'y':[], 'tof':[], 'tot_avg':[],\\\n",
    "                                 'tot_max':[], 'clustersize':[],})\n",
    "\n",
    "roll_buffer = Pipe(centroid_df_data)\n",
    "\n",
    "\n",
    "def my_roll_average(data):\n",
    "    global roll_buffer\n",
    "    global averaging_window\n",
    "    global rolling_length\n",
    "    \n",
    "    for i in data['clustersize'].rolling(averaging_window, center=True).mean()[::averaging_window]:\n",
    "        if not pd.isnull(i):\n",
    "            rolling_array.append(i)\n",
    "    \n",
    "    return (hv.Curve(rolling_array).opts(xlim=(0, rolling_length), ylim=(0, 120))).opts(width=900)\n",
    "\n",
    "\n",
    "@callback\n",
    "def on_data_centroid(in_data):\n",
    "    global rolling_buffer\n",
    "    global centroid_data\n",
    "    \n",
    "    if in_data['type'] == ChannelDataType.CENTROID.value:\n",
    "        '''recieved centroid data'''\n",
    "\n",
    "        #centroid_data = in_data['data']['clustersize'].rolling(averaging_window).mean()        \n",
    "\n",
    "        roll_buffer.send(in_data['data'])\n",
    "        \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "69b26e55",
   "metadata": {},
   "outputs": [],
   "source": [
    "hv.DynamicMap(my_roll_average, streams=[roll_buffer])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e8264f3e",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c80a076c",
   "metadata": {},
   "outputs": [],
   "source": [
    "@callback\n",
    "def on_data_test(in_data):\n",
    "    print(in_data['type'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f9d59547",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.8.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}