Stream_Timepix_panel_multitab.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8981933e-6c8a-475d-aeda-c693b19ed6ed",
   "metadata": {
    "jupyter": {
     "source_hidden": true
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "# Imports\n",
    "import time\n",
    "import copy\n",
    "import yaml\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "from enum import Enum\n",
    "import os\n",
    "\n",
    "import panel as pn\n",
    "import param\n",
    "\n",
    "from pymepix.channel.channel_types import ChannelDataType, Commands\n",
    "\n",
    "from online_data.timepix_monitor.tpx_acquisition import initialize_timepix_monitor \n",
    "from online_data.timepix_monitor.tpx_acquisition import unregister_all as tpxmon_unregister_all\n",
    "from online_data.timepix_monitor.tpx_acquisition import callback as tpxmon_callback\n",
    "\n",
    "from online_data.scan_monitor.scan_acquisition import callback as scanmon_callback\n",
    "from online_data.scan_monitor.scan_acquisition import initialize_scan_monitor\n",
    "from online_data.scan_monitor.scan_acquisition import unregister_all as scanmon_unregister_all\n",
    "\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",
    "from holoviews import opts\n",
    "\n",
    "hv.extension('bokeh')\n",
    "pn.extension('texteditor')\n",
    "#pn.extension()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a48ee5d2",
   "metadata": {},
   "outputs": [],
   "source": [
    "tpx_jobs = initialize_timepix_monitor()\n",
    "scan_jobs = initialize_scan_monitor()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d3ee0e63",
   "metadata": {},
   "source": [
    "## Globals ##"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f3cd41a2",
   "metadata": {},
   "outputs": [],
   "source": [
    "TOF_BINS_NUMBER = 10000\n",
    "TOF_RANGE = 20.0\n",
    "TOF_YLOG = False\n",
    "\n",
    "bins_VMI = (range(0, 256), range(0, 256))\n",
    "H_VMI = np.zeros((255, 255), dtype=float)\n",
    "\n",
    "bins_series = np.linspace(0, TOF_RANGE, TOF_BINS_NUMBER)\n",
    "x_axe = bins_series[:-1]\n",
    "\n",
    "mass_calibration_data = None # otherwise it is tuple(A, t0), m=A(t-t0)\n",
    "mass_calibration_pairs = None # otherwise it is tuple(A, t0), m=A(t-t0)\n",
    "\n",
    "settings_filename = 'multitab_panel_settings'\n",
    "\n",
    "class States(Enum):\n",
    "    ON = 1\n",
    "    SCANNING = 2\n",
    "    \n",
    "scan_info = {}\n",
    "scan_step = 0\n",
    "    \n",
    "State = States.ON\n",
    "\n",
    "scan_data = []\n",
    "scan_table = pd.DataFrame()\n",
    "df_mov_centroids = pd.DataFrame()\n",
    "\n",
    "full_range_roi_init_data = {\n",
    "    'full_range':{\n",
    "        'tof_roi': (0,TOF_RANGE),\n",
    "        'spatial_roi': ((0,0), (255,255)),\n",
    "        'roi_tof_histo': np.zeros((len(bins_series)-1), dtype=float),\n",
    "        'roi_H_VMI': np.zeros((255, 255), dtype=float),\n",
    "        'roi_color': '#99ef78',\n",
    "        'n_tiggers': 0\n",
    "    }\n",
    "}\n",
    "    \n",
    "scan_data.append(full_range_roi_init_data)  #always at least one record data\n",
    "\n",
    "pipe_roi_scan = Pipe(data=pd.DataFrame())\n",
    "pipe_image = Pipe(data=[])\n",
    "pipe_tof = Pipe(data=[])\n",
    "\n",
    "pipe_roi_scan.send(scan_table)\n",
    "pipe_image.send(H_VMI)\n",
    "pipe_tof.send(np.zeros((len(bins_series)-1),) )\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6903aaf3",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "fad0c67b",
   "metadata": {},
   "source": [
    "## Utilities ##"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "87ca19f7",
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_movable_label():\n",
    "    global scan_info\n",
    "    global State\n",
    "    xlabel = 'scan step'\n",
    "    if State == States.SCANNING:\n",
    "        xlabel = scan_info['movable_names'][0]\n",
    "    return xlabel\n",
    "\n",
    "# mass calibration functions##########\n",
    "# had to remove it here, because of no forward declaration in notebook\n",
    "\n",
    "def calculate_mass_from_tof(time_series):\n",
    "    global mass_calibration_data\n",
    "    if mass_calibration_data != None:\n",
    "        return mass_calibration_data[0]*pow((time_series - mass_calibration_data[1]),2)\n",
    "    return time_series\n",
    "\n",
    "def mass_calibrate(t1,m1,t2,m2):\n",
    "    \n",
    "    global mass_calibration_data, bins_series, x_axe\n",
    "    \n",
    "    mass1_sqrt = pow(m1,0.5)\n",
    "    mass2_sqrt = pow(m2,0.5)\n",
    "    \n",
    "    t0 = (mass2_sqrt*t1 - mass1_sqrt*t2)/(mass2_sqrt-mass1_sqrt)\n",
    "    A = m2/pow((t2 - t0),2)\n",
    "    \n",
    "    mass_calibration_data = (A, t0)\n",
    "    \n",
    "    bins_series = np.linspace(0, TOF_RANGE, TOF_BINS_NUMBER)\n",
    "    bins_series = calculate_mass_from_tof(bins_series)\n",
    "    \n",
    "    min_mass_index = np.argmin(bins_series)\n",
    "    if min_mass_index > 0:\n",
    "        bins_series[:min_mass_index] = -bins_series[:min_mass_index]\n",
    "   \n",
    "    x_axe = bins_series[:-1]\n",
    "\n",
    "# save/load settings functions########################################\n",
    "\n",
    "def load_settings(settings_filename):\n",
    "    global scan_data, mass_calibration_pairs\n",
    "    \n",
    "    if os.path.exists(f'{settings_filename}.yaml'):\n",
    "        with open(f'{settings_filename}.yaml','r') as f:\n",
    "            loaded_settings_data = yaml.load(f, Loader=yaml.Loader)\n",
    "        if loaded_settings_data is None:\n",
    "            return\n",
    "        if 'roi' in loaded_settings_data.keys():\n",
    "            for r_name, roi in loaded_settings_data['roi'].items():\n",
    "                roi['roi_tof_histo'] = np.zeros((len(bins_series)-1), dtype=float)\n",
    "                roi['roi_H_VMI'] = np.zeros((255, 255), dtype=float)\n",
    "                scan_data[-1][r_name] = roi\n",
    "\n",
    "        if 'mass_calibration_pairs' in loaded_settings_data.keys():\n",
    "            mass_calibration_pairs = loaded_settings_data['mass_calibration_pairs']\n",
    "            mass_calibrate(mass_calibration_pairs['t1'], mass_calibration_pairs['m1'], \n",
    "                           mass_calibration_pairs['t2'], mass_calibration_pairs['m2'])\n",
    "    \n",
    "\n",
    "\n",
    "def save_settings(Event):\n",
    "    global scan_data, mass_calibration_pairs, bins_series, settings_filename\n",
    "\n",
    "    roi_dict = {}\n",
    "    for roi_name, roi in scan_data[-1].items():\n",
    "        if roi_name == 'full_range':\n",
    "            continue\n",
    "\n",
    "        roi_copy = copy.copy(roi)\n",
    "        del roi_copy['roi_tof_histo']\n",
    "        del roi_copy['roi_H_VMI']\n",
    "        roi_dict[roi_name] = roi_copy\n",
    "        \n",
    "    settings_dict = {'roi': roi_dict}\n",
    "    if mass_calibration_pairs != None:\n",
    "        settings_dict['mass_calibration_pairs'] = mass_calibration_pairs\n",
    "        \n",
    "\n",
    "    with open(f'{settings_filename}.yaml', 'w',) as f :\n",
    "        yaml.dump(settings_dict,f,sort_keys=False)    \n",
    "    \n",
    "load_settings(settings_filename) # Load settings from yaml"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "86cefd2b",
   "metadata": {},
   "outputs": [],
   "source": [
    "#save_settings(settings_filename)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6a67ff35",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "f0076cda",
   "metadata": {},
   "source": [
    "### Image&Spectrum panel  ###"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "53c962a6",
   "metadata": {},
   "outputs": [],
   "source": [
    "#def on_roi_select_change(Event):\n",
    "#    pass    \n",
    "\n",
    "def reset_button_callback(Event):\n",
    "    global scan_data, scan_table\n",
    "    \n",
    "    newRecord = copy.deepcopy(scan_data[-1])\n",
    "    for roi_name, roi_record in newRecord.items():\n",
    "        roi_record['roi_tof_histo'] = np.zeros((len(bins_series)-1), dtype=float)\n",
    "        roi_record['roi_H_VMI'] =  np.zeros((255, 255), dtype=float)\n",
    "        roi_record['n_tiggers'] = 0\n",
    "    scan_data = [newRecord]\n",
    "    scan_table = pd.DataFrame()\n",
    "    \n",
    "roi_select = pn.widgets.MultiChoice(\n",
    "    name='ToF/mass ROI', value=list(scan_data[-1].keys()),\n",
    "    options=list(scan_data[-1].keys()),)\n",
    "\n",
    "reset_button = pn.widgets.Button(name='Reset data', button_type='primary')\n",
    "reset_button.on_click(reset_button_callback)\n",
    "\n",
    "save_settings_button = pn.widgets.Button(name='Save settings', button_type='primary')\n",
    "save_settings_button.on_click(save_settings)\n",
    "\n",
    "#roi_select.param.watch(on_roi_select_change, 'value')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "25112619",
   "metadata": {},
   "source": [
    "### mass calibration panel ###"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6374982b",
   "metadata": {},
   "outputs": [],
   "source": [
    "df_widget_mov_centroids = pn.widgets.DataFrame(pd.DataFrame(), height=800, frozen_columns=1, autosize_mode='none')\n",
    "df_widget_mov_centroids = pn.widgets.DataFrame(pd.DataFrame(), height=800, frozen_columns=1, autosize_mode='none')\n",
    "\n",
    "time_point1 = pn.widgets.FloatInput(name='Time 1', value=0., start=0, end=TOF_RANGE)\n",
    "time_point2 = pn.widgets.FloatInput(name='Time 2', value=1., start=0, end=TOF_RANGE)\n",
    "mass_point1 = pn.widgets.FloatInput(name='Mass 1', value=0., start=0,)\n",
    "mass_point2 = pn.widgets.FloatInput(name='Mass 2', value=1., start=0,)\n",
    "\n",
    "\n",
    "def mass_calibrate_callback(Event):\n",
    "    global mass_calibration_pairs, mass_calibration_data\n",
    "    m1 = mass_point1.value\n",
    "    m2 = mass_point2.value\n",
    "    t1 = time_point1.value\n",
    "    t2 = time_point2.value\n",
    "    \n",
    "    mass_calibration_pairs = {'t1':t1,'m1':m1, 't2': t2, 'm2':m2}\n",
    "                              \n",
    "    mass_calibrate(t1,m1,t2,m2)\n",
    "    \n",
    "    mass_calib_string.value = f'{mass_calibration_data[0]}  {mass_calibration_data[1]}'\n",
    "    \n",
    "\n",
    "\n",
    "def reset_calibration_callback(Event):\n",
    "    global mass_calibration_data, bins_series, x_axe\n",
    "    mass_calibration_data = None\n",
    "    bins_series = np.linspace(0, TOF_RANGE, TOF_BINS_NUMBER)\n",
    "    x_axe = bins_series[:-1]\n",
    "    mass_calib_string.value = 'None'\n",
    "\n",
    "mass_calibrate_button = pn.widgets.Button(name='Calibrate ToF spectra', button_type='primary')\n",
    "mass_calibrate_button.on_click(mass_calibrate_callback)\n",
    "\n",
    "reset_calibration_button = pn.widgets.Button(name='Reset mass calibration', button_type='primary')\n",
    "reset_calibration_button.on_click(reset_calibration_callback)\n",
    "\n",
    "mass_calib_string = pn.widgets.StaticText(name='Calibration const.', value=mass_calibration_data)\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c15228d6",
   "metadata": {},
   "source": [
    "### ROI management panel ###"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5b63012c",
   "metadata": {},
   "outputs": [],
   "source": [
    "m1_point = pn.widgets.FloatInput(name='m1', value=0., start=0)\n",
    "m2_point = pn.widgets.FloatInput(name='m2', value=0., start=0)\n",
    "\n",
    "x1_point = pn.widgets.IntInput(name='X1', value=0,   start=0, end=255)\n",
    "x2_point = pn.widgets.IntInput(name='X2', value=255, start=0, end=255)\n",
    "y1_point = pn.widgets.IntInput(name='Y1', value=0,   start=0, end=255)\n",
    "y2_point = pn.widgets.IntInput(name='Y2', value=255, start=0, end=255)\n",
    "\n",
    "text_input_roi_name = pn.widgets.TextInput(name='ROI name', placeholder='Enter the name of ROI here...')\n",
    "\n",
    "colorpicker = pn.widgets.ColorPicker(name='ROI color', value='#99ef78')\n",
    "\n",
    "def add_roi_callback(Event):\n",
    "    \n",
    "    if text_input_roi_name.value == '':\n",
    "        return\n",
    "    \n",
    "    new_roi= {\n",
    "            'tof_roi': (m1_point.value, m2_point.value),\n",
    "            'spatial_roi': ((x1_point.value, y1_point.value), (x2_point.value,y2_point.value)),\n",
    "            'roi_tof_histo': np.zeros((len(bins_series)-1), dtype=float),\n",
    "            'roi_H_VMI': np.zeros((255, 255), dtype=float),\n",
    "            'roi_color': colorpicker.value,\n",
    "            'n_tiggers': 0\n",
    "    }\n",
    "    \n",
    "    scan_data[-1][text_input_roi_name.value] = new_roi\n",
    "    \n",
    "    if not (text_input_roi_name.value in roi_select.options):\n",
    "        options_list = roi_select.options.copy()\n",
    "        options_list.append(text_input_roi_name.value)\n",
    "        roi_select.options = []\n",
    "        roi_select.options = options_list\n",
    "        roi_select.value=[text_input_roi_name.value]\n",
    "    \n",
    "\n",
    "def remove_roi_by_name_callback(Event):\n",
    "    if text_input_roi_name.value == 'full_range':\n",
    "        return \n",
    "    \n",
    "    del scan_data[-1][text_input_roi_name.value]\n",
    "    \n",
    "    value_list = roi_select.value.copy()\n",
    "    if text_input_roi_name.value in value_list:\n",
    "        value_list.remove(text_input_roi_name.value)\n",
    "        roi_select.value = []\n",
    "        #roi_select.values = []\n",
    "    \n",
    "    if text_input_roi_name.value in roi_select.options:\n",
    "        options_list = roi_select.options.copy()\n",
    "        options_list.remove(text_input_roi_name.value)\n",
    "        roi_select.options = []\n",
    "        roi_select.options = options_list\n",
    "        #roi_select.values = []\n",
    "    \n",
    "    if roi_select.value == [] and value_list != []:\n",
    "        roi_select.value = value_list\n",
    "  \n",
    "\n",
    "\n",
    "add_roi_button = pn.widgets.Button(name='Add ROI', button_type='primary')\n",
    "add_roi_button.on_click(add_roi_callback)\n",
    "\n",
    "remove_roi_by_name_button = pn.widgets.Button(name='Remove ROI by name', button_type='primary')\n",
    "remove_roi_by_name_button.on_click(remove_roi_by_name_callback)\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "99e8ed5a",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "3dad3399",
   "metadata": {},
   "source": [
    "### New panel ###"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4669f009",
   "metadata": {},
   "source": [
    "## Main callback routine where the data processing takes place ##"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "586b4c5f",
   "metadata": {},
   "outputs": [],
   "source": [
    "@tpxmon_callback\n",
    "def main_loop(in_data):\n",
    "    \n",
    "    #global tof_accu\n",
    "    global x_axe\n",
    "    global scan_data\n",
    "    global scan_table\n",
    "    global scan_step\n",
    "    global roi_select\n",
    "    global State\n",
    "    \n",
    "    if not in_data['type'] in [ChannelDataType.TOF.value, ChannelDataType.COMMAND.value]:\n",
    "        return\n",
    "\n",
    "    if in_data['type'] == ChannelDataType.TOF.value:\n",
    "        \n",
    "        last_record_data = scan_data[-1]\n",
    "        \n",
    "        tof_data = in_data['data']\n",
    "        \n",
    "        number_of_triggers = len(np.unique(tof_data['nr']))\n",
    "                \n",
    "        if number_of_triggers == 0:\n",
    "            return\n",
    "        \n",
    "        mass_series = calculate_mass_from_tof(np.copy(tof_data['tof']*1e6)) #timeseries is in microseconds, mass calibration\n",
    "\n",
    "        last_record_data['full_range']['roi_H_VMI'] += np.histogram2d(tof_data['x'],\\\n",
    "                                        tof_data['y'], bins=bins_VMI)[0]/number_of_triggers\n",
    "        for roi_key, roi_val in last_record_data.items():\n",
    "            if roi_key == 'full_range':\n",
    "                continue\n",
    "            roi_indxs = np.logical_and(mass_series>roi_val['tof_roi'][0],\\\n",
    "                                       mass_series<roi_val['tof_roi'][1])\n",
    "            roi_val['roi_H_VMI'] += np.histogram2d(tof_data['x'][roi_indxs],\\\n",
    "                                        tof_data['y'][roi_indxs], bins=bins_VMI)[0]/number_of_triggers\n",
    "\n",
    "\n",
    "        if 'full_range' in roi_select.value:\n",
    "            roi_H_VMI = last_record_data['full_range']['roi_H_VMI']\n",
    "        else:\n",
    "            roi_H_VMI = np.zeros((255, 255), dtype=float)\n",
    "            for roi_key, roi_val in last_record_data.items():\n",
    "                if roi_key == 'full_range':\n",
    "                    continue\n",
    "                if roi_key in roi_select.value:\n",
    "                    roi_H_VMI += roi_val['roi_H_VMI']\n",
    "        pipe_image.send(roi_H_VMI)\n",
    "        \n",
    "        last_record_data['full_range']['roi_tof_histo'] += np.histogram(mass_series, bins=bins_series)[0]/number_of_triggers\n",
    "        series_data = last_record_data['full_range']['roi_tof_histo']\n",
    "        pipe_tof.send(series_data/max(series_data.max(),1))\n",
    "        \n",
    "        last_record_data['full_range']['n_tiggers'] += number_of_triggers # triggers number stored only here\n",
    "        return\n",
    "\n",
    "\n",
    "    if in_data['type'] == ChannelDataType.COMMAND.value:  \n",
    "        if in_data['data'] == Commands.START_RECORD.value:\n",
    "            # init new record data with all ROIs\n",
    "            newRecord = copy.copy(scan_data[-1])\n",
    "            for roi_name, roi_record in newRecord.items():\n",
    "                roi_record['roi_tof_histo'] = np.zeros((len(bins_series)-1), dtype=float)\n",
    "                roi_record['roi_H_VMI'] =  np.zeros((255, 255), dtype=float)\n",
    "                roi_record['n_tiggers'] = 0\n",
    "            scan_data.append(newRecord)\n",
    "\n",
    "        elif in_data['data'] == Commands.STOP_RECORD.value:\n",
    "            # fill data frame with data from ROIs            \n",
    "\n",
    "            for roi_name, roi_record in scan_data[-1].items():\n",
    "                if roi_name == 'full_range':\n",
    "                    continue\n",
    "\n",
    "                pix_roi = roi_record['spatial_roi']\n",
    "                val = roi_record['roi_H_VMI'][pix_roi[0][0]:pix_roi[1][0], pix_roi[0][1]:pix_roi[1][1]]\n",
    "                if scan_data[-1]['full_range']['n_tiggers'] > 0:\n",
    "                    val = np.sum(val)/scan_data[-1]['full_range']['n_tiggers']\n",
    "                else:\n",
    "                    val = 0.0\n",
    "                    \n",
    "                #print(scan_table)\n",
    "                    \n",
    "                scan_table[roi_name][scan_step] = val\n",
    "\n",
    "            scan_step += 1\n",
    "            \n",
    "            # no defined order of calls this function and sardana callback, need to close scan anyway with full dataset\n",
    "            if scan_step >= len(scan_table.index) and (not scan_table.iloc[-1].isnull().any()):\n",
    "                State = States.ON\n",
    "\n",
    "            process_scan_roi_data(scan_table)                    \n",
    "            pipe_roi_scan.send(scan_table)\n",
    "            \n",
    "        return"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3791673d",
   "metadata": {},
   "outputs": [],
   "source": [
    "def process_scan_roi_data(in_table):    \n",
    "    global df_widget_mov_centroids\n",
    "    global df_mov_centroids\n",
    "    global scan_info\n",
    "    \n",
    "    if df_mov_centroids.empty:\n",
    "        df_mov_centroids = pd.DataFrame(index=scan_info['movable_names'], columns=scan_info['roi_names'])\n",
    "    \n",
    "    for roi_name in scan_info['roi_names']:\n",
    "        integral_val = np.nansum(scan_table[roi_name])\n",
    "        for movable_name in scan_info['movable_names']:\n",
    "            if integral_val > 0:\n",
    "                df_mov_centroids[roi_name][movable_name] = np.nansum(scan_table[roi_name]*scan_table[movable_name])/integral_val\n",
    "            else:\n",
    "                df_mov_centroids[roi_name][movable_name] = float('nan')\n",
    "            \n",
    "    df_widget_mov_centroids.value = df_mov_centroids\n",
    " "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4a727098",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "75645a64",
   "metadata": {},
   "outputs": [],
   "source": [
    "# retriving scan information from sardana\n",
    "@scanmon_callback\n",
    "def on_scandata_received(in_data): \n",
    "    #print(in_data)\n",
    "    global State\n",
    "    global scan_info\n",
    "    global scan_table\n",
    "    global df_mov_centroids\n",
    "    global scan_step\n",
    "    global scan_data\n",
    "    if in_data['type'] == 'data_desc':\n",
    "        #print('total_scan_intervals: ', in_data['data']['total_scan_intervals'])\n",
    "        scan_info['total_scan_intervals'] = in_data['data']['total_scan_intervals']\n",
    "        scan_info['serial_number'] = in_data['data']['serialno']\n",
    "        scan_info['ref_moveables'] = in_data['data']['ref_moveables']\n",
    "        # enumerate all movables\n",
    "        \n",
    "        movable_names = []\n",
    "       \n",
    "        for column_descr in in_data['data']['column_desc']:\n",
    "            if 'instrument' in column_descr.keys() and not 'output' in column_descr.keys():\n",
    "                #print(column_descr['name'])\n",
    "                movable_names.append(column_descr['name'])\n",
    "                \n",
    "        scan_info['movable_names'] = movable_names\n",
    "                \n",
    "        roi_names = [roi_name for roi_name in scan_data[-1].keys() if roi_name != 'full_range']\n",
    "        scan_info['roi_names'] = roi_names\n",
    "        table_columns = ['point_nb'] + movable_names + roi_names\n",
    "        #print(table_columns)\n",
    "                \n",
    "        scan_table = pd.DataFrame(index=range(0,scan_info['total_scan_intervals']+1), columns=table_columns)\n",
    "\n",
    "        scan_step = 0\n",
    "        \n",
    "        df_mov_centroids = pd.DataFrame()\n",
    "        \n",
    "        State = States.SCANNING\n",
    "        \n",
    "        return \n",
    "    \n",
    "    if in_data['type'] == 'record_data':\n",
    "        point_nb = in_data['data']['point_nb']\n",
    "        scan_table['point_nb'][point_nb] = point_nb\n",
    "        for mov_name in scan_info['movable_names']:\n",
    "            scan_table[mov_name][point_nb] = in_data['data'][mov_name]\n",
    "            \n",
    "        process_scan_roi_data(scan_table)                    \n",
    "        pipe_roi_scan.send(scan_table)\n",
    "            \n",
    "        return\n",
    "    \n",
    "    if in_data['type'] == 'record_end':\n",
    "        if not scan_table.iloc[-1].isnull().any():\n",
    "            State = States.ON"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9f56b126",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "93dc5288",
   "metadata": {},
   "source": [
    "## Panel GUI, server start ##"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2c5264cf",
   "metadata": {},
   "outputs": [],
   "source": [
    "def make_roi_scan_plot(data):\n",
    "    global roi_select  \n",
    "    global State\n",
    "    global scan_info\n",
    "    \n",
    "    roi_names = [i for i in roi_select.value if i != 'full_range']\n",
    "\n",
    "    if roi_names != [] and data.empty == False and not data['point_nb'].isnull().all():\n",
    "        \n",
    "        scan_steps = max(data['point_nb'])\n",
    "        \n",
    "        if State == States.SCANNING:\n",
    "            x_vals = np.array(data[scan_info['movable_names'][0]])[:scan_steps+1]\n",
    "        else:\n",
    "            x_vals = np.array(data['point_nb'])[:scan_steps+1]\n",
    "        \n",
    "\n",
    "        xmax = x_vals.max()\n",
    "        xmin = x_vals.min()\n",
    "        ymax = max(data[roi_names].max())\n",
    "        ymin = min(data[roi_names].min())\n",
    "\n",
    "        if xmax==xmin:\n",
    "            xlimits = (xmax-1,xmax+1,)\n",
    "        else:\n",
    "            xrange = xmax-xmin\n",
    "            xlimits = (xmin - xrange*0.1,xmax+xrange*0.1,)\n",
    "\n",
    "        if ymax==ymin:\n",
    "            ylimits = (ymax-1,ymax+1,)\n",
    "        else:\n",
    "            yrange = ymax-ymin\n",
    "            ylimits = (ymin - yrange*0.1,ymax+yrange*0.1,)\n",
    "\n",
    "        colors = {}\n",
    "        for roi_name, roi in scan_data[-1].items():\n",
    "            colors[roi_name]=roi['roi_color']\n",
    "        \n",
    "        xlabel = get_movable_label()\n",
    "        \n",
    "        if 'serial_number' in scan_info.keys() and State == States.SCANNING:\n",
    "            figure_title = f\"Scan: {scan_info['serial_number']}\"\n",
    "        else:\n",
    "            figure_title = ''\n",
    "       \n",
    "        curves=[hv.Curve((x_vals, data[roi_name][:scan_steps+1])).opts(xlabel=xlabel, \\\n",
    "                            ylabel='Amplitude, [au]', width=600, height=450, show_grid=True, tools=['hover'],\\\n",
    "                            color=colors[roi_name], xlim=xlimits, ylim=ylimits, axiswise=True, \\\n",
    "                            framewise=True,)*hv.Scatter((x_vals,\\\n",
    "                            data[roi_name][:scan_steps+1])).opts(xlabel='scan num.',\\\n",
    "                            ylabel='Amplitude, [au]', width=600, height=450, show_grid=True,\\\n",
    "                            tools=['hover'], color=colors[roi_name], xlim=xlimits, ylim=ylimits, axiswise=True,\\\n",
    "                            framewise=True, size=10) for roi_name in roi_select.value if roi_name != 'full_range' ]\n",
    "\n",
    "               \n",
    "\n",
    "        return hv.Overlay(curves).opts( title=figure_title, axiswise=True, framewise=True,) #.redim.range(Sample=(0,10))\n",
    "    else:\n",
    "        hv_curve = hv.Curve([]).opts(xlabel='scan num.', ylabel='Amplitude, [au]', width=600, height=450, show_grid=True, tools=['hover'],  axiswise=True, framewise=True,)\n",
    "        return hv.Overlay([hv_curve , hv_curve ],).opts(axiswise=True, framewise=True,)\n",
    "\n",
    "    \n",
    "    \n",
    "def make_image_plot(data):\n",
    "    \n",
    "        \n",
    "    #print('make_image_plot data received')\n",
    "    #print(data.min())\n",
    "    #print(data.max())\n",
    "\n",
    "    global roi_select, scan_data\n",
    "    \n",
    "    #print('got image data')\n",
    "    #print(data)\n",
    "    \n",
    "    rois_coord = [scan_data[-1][roi_name]['spatial_roi'] for roi_name in roi_select.value]\n",
    "    rois_colors = [scan_data[-1][roi_name]['roi_color'] for roi_name in roi_select.value]\n",
    "\n",
    "    rois_props = list(zip(rois_coord, rois_colors))\n",
    "\n",
    "    image_plot = hv.Image((range(256), range(256), data.T), bounds=[bins_VMI[0][0], bins_VMI[1][0], bins_VMI[0][-1], \\\n",
    "                                        bins_VMI[1][-1]],).opts(xlabel='x', ylabel='y', axiswise=True, \\\n",
    "                                        logz=True, clim=(1e-3, None), cmap=\"jet\", frame_height=500, \\\n",
    "                                        frame_width=500)\n",
    "\n",
    "    bounds = [hv.Bounds((roi[0][0][0], roi[0][0][1], roi[0][1][0], roi[0][1][1])).opts(opts.Bounds(color=roi[1],\\\n",
    "                            axiswise=True, line_width=2)) for roi in rois_props ]\n",
    "\n",
    "    return (image_plot * hv.Overlay(bounds).opts(axiswise=True)).opts(axiswise=True)\n",
    "\n",
    "def make_tof_histo_plot(data):\n",
    "    global roi_select\n",
    "    \n",
    "    last_roi_data = scan_data[-1]\n",
    " \n",
    "    selected_rois = [(last_roi_data[i]['tof_roi'], last_roi_data[i]['roi_color']) for i in roi_select.value if i != 'full_range']\n",
    "    \n",
    "    if mass_calibration_data == None:\n",
    "        xlabel='ToF (µs)'\n",
    "    else:\n",
    "        xlabel='Mass (amu)'\n",
    "        \n",
    "    ylabel='Normalized amplitude'\n",
    "    \n",
    "    tof_hist_plot_log = hv.Curve((x_axe, data)).opts(xlabel=xlabel, ylabel=ylabel, axiswise=True, height=400,\\\n",
    "                                     width=1200, show_grid=True, tools=['hover'], ylim=(1e-7,1),xlim=(x_axe[0],\\\n",
    "                                     x_axe[-1]), logy=TOF_YLOG)\n",
    "    \n",
    "    \n",
    "    #rng = hv.streams.RangeY(source=p)\n",
    "    \n",
    "    mass_rois = [hv.Rectangles((i[0], 1e-7, i[1], 1)).opts(alpha=0.3, color=c) for i, c in selected_rois]\n",
    "    #mass_rois = [hv.Rectangles((i[0], rng[0], i[1], rng[1])).opts(alpha=0.3, color=c) for i, c in selected_rois]\n",
    "    return tof_hist_plot_log * hv.Overlay(mass_rois)\n",
    "\n",
    "\n",
    "main_panel = pn.Column(reset_button, save_settings_button)\n",
    "\n",
    "mass_calibrate_panel = pn.Row(pn.Column(time_point1, mass_point1, time_point2, mass_point2,\\\n",
    "                                mass_calibrate_button, reset_calibration_button, mass_calib_string),)\n",
    "\n",
    "roi_panel = pn.Column(m1_point, m2_point, x1_point, y1_point, x2_point,\\\n",
    "                            y2_point,text_input_roi_name, colorpicker, add_roi_button,\\\n",
    "                            remove_roi_by_name_button)\n",
    "\n",
    "settings_tabs = pn.Tabs(('Main', main_panel),\n",
    "        ('Mass calibration', mass_calibrate_panel),\n",
    "        ('ROI settings',roi_panel))\n",
    "\n",
    "viz_panel = pn.Tabs(('Plots', pn.Column(roi_select, pn.Row(hv.DynamicMap(make_image_plot, streams=[pipe_image]),\\\n",
    "                                hv.DynamicMap(make_roi_scan_plot, streams=[pipe_roi_scan])),\n",
    "                                   hv.DynamicMap(make_tof_histo_plot,  streams=[pipe_tof]))),\n",
    "             (\"Movable' centroids table\", df_widget_mov_centroids))\n",
    "\n",
    "#viz_panel = pn.Column( roi_select, hv.DynamicMap(make_tof_histo_plot,  streams=[pipe_tof]),\\\n",
    "#                      hv.DynamicMap(make_image_plot, streams=[pipe_image]), )\n",
    "\n",
    "page = pn.Row(settings_tabs, viz_panel)\n",
    "\n",
    "\n",
    "\n",
    "pn.serve(page)\n",
    "\n",
    "\n",
    "#         , port=SERVE_PORT)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "805d6889",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c1c972eb",
   "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
}