table_selection-17AB.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ea9b3426-89b7-41d0-9414-bdd23c9f6c26",
   "metadata": {},
   "outputs": [],
   "source": [
    "import os, colorcet, param as pm, holoviews as hv, panel as pn, datashader as ds\n",
    "from holoviews.element import tiles as hvts\n",
    "from holoviews.operation.datashader import rasterize, shade, spread\n",
    "import holoviews.operation.datashader as hd\n",
    "from collections import OrderedDict as odict\n",
    "import geoviews\n",
    "from cartopy import crs\n",
    "import pandas as pd\n",
    "from astropy.coordinates import Angle\n",
    "import astropy.units as u\n",
    "\n",
    "geoviews.extension('bokeh', logo=False)\n",
    "pn.extension()\n",
    "\n",
    "from holoviews import opts\n",
    "from holoviews.plotting.links import DataLink\n",
    "from astropy.time import Time\n",
    "import datetime as dt\n",
    "import numpy as np\n",
    "\n",
    "from bokeh import models\n",
    "from bokeh.models import ColumnDataSource, HoverTool\n",
    "from holoviews.streams import RangeXY\n",
    "from holoviews.selection import link_selections\n",
    "from holoviews.operation import decimate"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4e2ddb6b-5fd6-4c73-bed9-424a0b6bfd2b",
   "metadata": {},
   "outputs": [],
   "source": [
    "filename = \"/users/elowe/repos/antenna-plots/modified_ant_pos_17AB_plus.parquet\"\n",
    "\n",
    "# dataframes for each data set\n",
    "df = pd.read_parquet(filename)\n",
    "df = df[::10000]\n",
    "df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "705253a2-9ba0-4d60-aee3-72a5bd22f880",
   "metadata": {},
   "outputs": [],
   "source": [
    "%%time\n",
    "\n",
    "# get unique list of the receivers and backends\n",
    "recs_list=df['Receiver'].unique().tolist()\n",
    "backs_list = df['Backend'].unique().tolist()\n",
    "\n",
    "cmaps  = odict([(n,colorcet.palette[n]) for n in ['fire', 'rainbow4', 'bmy', 'gray', 'kbc', 'blues']])\n",
    "bg_colors  = {color.capitalize(): color for color in [\"grey\", \"black\", \"white\", \"grey\"]}\n",
    "recs = {receiver: receiver for receiver in recs_list}\n",
    "backends = {backends: backends for backends in backs_list}\n",
    "\n",
    "# adding the option of All to the receiver\n",
    "updict = {\"All\" : 'All'}\n",
    "\n",
    "# ** operator for packing and unpacking items in order\n",
    "recs = {**updict, **recs}\n",
    "\n",
    "# Made the tools set\n",
    "my_tools =['box_select','lasso_select','help']\n",
    "\n",
    "# creating the pairing of backends to the reciever\n",
    "pairingBackends = {}\n",
    "for rec in recs:\n",
    "    selectedReceiver = df[df['Receiver']==rec]\n",
    "    backendOptions = selectedReceiver['Backend'].drop_duplicates()\n",
    "    backendOptions = backendOptions.tolist()\n",
    "    backendOptions.insert(0,'All')\n",
    "    pairingBackends[rec] = backendOptions\n",
    "pairingBackends['All'] = ['All',*backs_list]\n",
    "\n",
    "# get unique list of the sessions\n",
    "sess_list=df['Session'].unique().tolist()\n",
    "sess_list.sort()\n",
    "sess_list.insert(0,'All')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "36a38b5b-82a0-4da8-b4e8-b981f4bd2a54",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create all the widgets \n",
    "background_color = pn.widgets.Select(name=\"Background Color\", value='grey', options=bg_colors)\n",
    "cmap = pn.widgets.Select(name=\"Cmap Color\", value='fire', options=cmaps)\n",
    "spread_threshold = pn.widgets.FloatSlider(name='Spread Threshold', start=0, end=1, step=.1, value=.4)\n",
    "spread_max_pixels = pn.widgets.IntSlider(name='Spread Max Pixels', start=0, end=10, step=1, value=1)\n",
    "ra_rotation = pn.widgets.IntSlider(name='RA Rotation (Degrees)', start=-180, end=180, step=1, value=0)\n",
    "dec_rotation = pn.widgets.IntSlider(name='Dec Rotation (Degrees)', start=-180, end=180, step=1, value=0)\n",
    "receiver_selection = pn.widgets.Select(name='Receivers',value='All',options=recs)\n",
    "backend_selection = pn.widgets.MultiSelect(name='Backends', value=['All'],options=pairingBackends[receiver_selection.value],size = 8)\n",
    "session_selection = pn.widgets.MultiSelect(name='Session', value=['All'],options=sess_list,size = 8)\n",
    "date_range_slider = pn.widgets.DateRangeSlider(\n",
    "    name='Date Range Slider',\n",
    "    start=Time(df[\"DMJD\"].min(), format=\"mjd\").to_datetime(), end=Time(df[\"DMJD\"].max(), format=\"mjd\").to_datetime(),\n",
    "    value=(Time(df[\"DMJD\"].min(), format=\"mjd\").to_datetime(), Time(df[\"DMJD\"].max(), format=\"mjd\").to_datetime()),\n",
    ")\n",
    "\n",
    "# widgets to hold the place for the projections\n",
    "ra_dec = pn.widgets\n",
    "gal_ra_dec = pn.widgets\n",
    "azi_el =pn.widgets\n",
    "\n",
    "# List of all the widgets\n",
    "widgets = [\n",
    "    background_color,\n",
    "    cmap,\n",
    "    spread_threshold,\n",
    "    spread_max_pixels,\n",
    "    ra_rotation,\n",
    "    dec_rotation,\n",
    "    date_range_slider,\n",
    "    session_selection,\n",
    "    receiver_selection,\n",
    "    backend_selection\n",
    "]\n",
    "\n",
    "# Add all the widgets to the WidgetBox\n",
    "option_box = pn.WidgetBox(*widgets)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "542ec2f5-34cb-44c9-9fcd-c1c19dcb81d5",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Add all three projections into a column\n",
    "my_column = pn.Column(\n",
    "    pn.Column('# RA/Dec J2000', ra_dec),\n",
    "    pn.Column('# Galactic Ra/Dec', gal_ra_dec),\n",
    "    pn.Column('# Az/El', azi_el),\n",
    ")\n",
    "\n",
    "# create dict of values for projections\n",
    "refs = {0:['RAJ2000','DECJ2000', 400,crs.Mollweide()],\n",
    "        1:['gal_ra','gal_dec',400,crs.Mollweide()],\n",
    "        2:['MNT_AZ','MNT_EL',800,crs.AzimuthalEquidistant()]}\n",
    "\n",
    "\n",
    "# Creating the plots\n",
    "def update_proj(event):\n",
    "\n",
    "    # lists that hold the points and the projections\n",
    "    list_new_points = []\n",
    "    list_quadmesh = []\n",
    "    \n",
    "    # Loop through and make each plot\n",
    "    for i in range(3):\n",
    "        \n",
    "        # create condtions to check\n",
    "        isValidDateRange = (date_range_slider.value_start <  df['date']) & (df['date'] < date_range_slider.value_end) \n",
    "        isValidReceiver = receiver_selection.value=='All' or df['Receiver']==receiver_selection.value\n",
    "        isValidBackend = backend_selection.value==['All'] or df['Backend'].isin(backend_selection.value)\n",
    "        session_select = session_selection.value==['All'] or df['Session'].isin(session_selection.value)\n",
    "        \n",
    "        \n",
    "        # create mask that will only have the points in the valid range\n",
    "        mask = session_select &  isValidDateRange & isValidReceiver & isValidBackend\n",
    "\n",
    "        # get new points based on rotation\n",
    "        ra_rotated = df[refs[i][0]].where(mask) + ra_rotation.value\n",
    "        ra_rotated[ra_rotated > 180] -= 360\n",
    "\n",
    "        dec_rotated = df[refs[i][1]].where(mask) + dec_rotation.value\n",
    "        dec_rotated[dec_rotated > 90] -= 180\n",
    "\n",
    "        # New dataframe with the new positions\n",
    "        new_df = pd.DataFrame({refs[i][0]: ra_rotated, refs[i][1]: dec_rotated})\n",
    "        \n",
    "        new_points = geoviews.Points(new_df, [refs[i][0], refs[i][1]])\n",
    "        new_points = new_points.opts(opts.Points(tools=['box_select', 'lasso_select', 'hover'],projection=refs[i][3], global_extent=True, width=800, height=refs[i][2]))\n",
    "        new_projected = geoviews.operation.project_points(new_points, projection=refs[i][3])\n",
    "        \n",
    "        # decimated_points = decimate(new_projected).opts(tools=['lasso_select', 'box_select', 'hover'], projection=refs[i][3], alpha=.9)\n",
    "#         # Shading the data\n",
    "#         hv_shaded = hv.operation.datashader.datashade(rasterize(hv.DynamicMap(new_projected)), dynamic=True, precompute=True, cmap=cmap.value)\n",
    "#         hv_spread = hv.operation.datashader.dynspread(hv_shaded, threshold=spread_threshold.value, max_px=spread_max_pixels.value)\n",
    "#         hv_spread = hv_spread.opts(tools=['box_select','lasso_select','help'], bgcolor=background_color.value,projection=refs[i][3], global_extent=True, frame_width=800, frame_height=refs[i][2])\n",
    "        \n",
    "        # for the quadmesh\n",
    "        # dynamic = hv.util.Dynamic(hd.aggregate(new_projected, width=12, height=12, streams=[RangeXY]),operation=hv.QuadMesh).opts(tools=['hover'], projection=refs[i][3],alpha=0, hover_alpha=0.6)\n",
    "        \n",
    "        # my_column[i][1] = (hv_spread * dynamic) \n",
    "        list_new_points.append(new_projected)\n",
    "        \n",
    "    # Calling the method to link the plots\n",
    "    link(list_new_points)\n",
    "\n",
    "# dataset and table link for linking the projections to the table\n",
    "dataset = hv.Dataset(df)\n",
    "table_link = link_selections.instance()\n",
    "\n",
    "# function to create the datalink. only working with the unshaded data. \n",
    "def link(ls_points):\n",
    "    \n",
    "    #table link that only works with one projection at a time\n",
    "    ls_points[0] = table_link(ls_points[0])\n",
    "    \n",
    "    # set columns  \n",
    "    my_column[0][1] = ls_points[0]\n",
    "    my_column[1][1] = ls_points[1] \n",
    "    my_column[2][1] = ls_points[2] \n",
    "\n",
    "    \n",
    "# creates the selection table\n",
    "@pm.depends(table_link.param.selection_expr)\n",
    "def selection_table(_):\n",
    "    return hv.Table(dataset.select(table_link.selection_expr)).opts(width=900, height=200)  \n",
    "\n",
    "# the method that populates the beckends based on the receiver selected\n",
    "@pn.depends(receiver_selection.param.value, watch=True)\n",
    "def _update_backend(receiver_selection):\n",
    "    backendList = pairingBackends[receiver_selection]\n",
    "    backend_selection.options = backendList\n",
    "    valueList = [backendList[0]]\n",
    "    backend_selection.value = valueList\n",
    "    \n",
    "# To loop through all the widgets  \n",
    "def add_trigger(widget):\n",
    "    widget.param.watch(update_proj, 'value')\n",
    "\n",
    "# position.param.watch(update_proj, 'value')\n",
    "# position.param.trigger('value')\n",
    "# replaced by:\n",
    "# widget.param.trigger('value')\n",
    "for widget in widgets:\n",
    "    add_trigger(widget)\n",
    "\n",
    "# GBO logo \n",
    "logo = \"https://i0.wp.com/greenbankobservatory.org/wp-content/uploads/2016/10/logo_purp-green_grad.png\"\n",
    "\n",
    "\n",
    "# Adding them to a row\n",
    "pn.Row(\n",
    "    pn.Column(logo,\n",
    "    option_box),\n",
    "    my_column, selection_table\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5eb2e51f-b14c-425a-8ae4-92393ca31845",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9e8cff24-2b30-4a58-a3ac-f3883b286e47",
   "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.9.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}