glider_vertical_section_plot.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Dashboard for exploring glider section\n",
    "\n",
    "Here we create a panel dashboard that allows us to explore the pressure-time section of the variables measured by the glider."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import hvplot.xarray \n",
    "import numpy as np\n",
    "import panel as pn\n",
    "import xarray as xr\n",
    "import holoviews as hv\n",
    "from holoviews import opts\n",
    "from holoviews import streams\n",
    "import matplotlib.pyplot as plt\n",
    "import param"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Load Data \n",
    "\n",
    "data_dir = './data/'\n",
    "\n",
    "ds_659_Tgrid = xr.open_dataset(data_dir + '659_Tgrid.nc')\n",
    "ds_660_Tgrid = xr.open_dataset(data_dir + '660_Tgrid.nc')\n",
    "\n",
    "ds_659_Tgrid_anom = xr.open_dataset(data_dir + '659_Tgrid_anomaly.nc')\n",
    "ds_660_Tgrid_anom = xr.open_dataset(data_dir + '660_Tgrid_anomaly.nc')\n",
    "\n",
    "ds_659_Dgrid = xr.open_dataset(data_dir + '659_Dgrid.nc')\n",
    "ds_660_Dgrid = xr.open_dataset(data_dir + '660_Dgrid.nc')\n",
    "\n",
    "ds_659_Dgrid_anom = xr.open_dataset(data_dir + '659_Dgrid_anomaly.nc')\n",
    "ds_660_Dgrid_anom = xr.open_dataset(data_dir + '660_Dgrid_anomaly.nc')\n",
    "\n",
    "# These files were created before by interpolating from the glider's\n",
    "# see-saw sampling to a uniform time-pressure grid or distance-pressure grid. \n",
    "# Code in data_preprocess_2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "glider_nums = ['sg659', 'sg660']\n",
    "glider_vars = list(ds_659_Tgrid.keys()) # just need to do once bevause all data sets have same variables\n",
    "#cmap_options = ['RdBu_r', 'Purples', 'YlGnBu', 'Greens', 'YlOrBr']\n",
    "cmap_options = plt.colormaps()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "var_select_map = {\n",
    "            'oxygen': {\n",
    "                'bin_range': (175, 375), # remove these since we don't use these anymore \n",
    "                'cmap_sel': 'YlOrBr'\n",
    "            },\n",
    "            'Chl': {\n",
    "                'bin_range': (0, 0.5),\n",
    "                'cmap_sel': 'Greens'\n",
    "            },\n",
    "            'salinity': {\n",
    "                'bin_range': (33.75, 35),\n",
    "                'cmap_sel': 'YlGnBu'\n",
    "            },\n",
    "            'temperature': {\n",
    "                'bin_range': (0,4),\n",
    "                'cmap_sel': 'RdBu_r'\n",
    "            },\n",
    "            'potdens': {\n",
    "                'bin_range': (1026.8, 1027.8),\n",
    "                'cmap_sel': 'Purples'\n",
    "            }\n",
    "        }\n",
    "# For future versions would be nice if some of these things are read in from the\n",
    "# attributes. \n",
    "\n",
    "glider_map = {\n",
    "            'sg659': {'Tgrid': ds_659_Tgrid, 'Dgrid': ds_659_Dgrid},\n",
    "            'sg660': {'Tgrid': ds_660_Tgrid, 'Dgrid': ds_660_Dgrid},\n",
    "        }\n",
    "\n",
    "glider_map_anom = {\n",
    "            'sg659': {'Tgrid': ds_659_Tgrid_anom, 'Dgrid': ds_659_Dgrid_anom},\n",
    "            'sg660': {'Tgrid': ds_660_Tgrid_anom, 'Dgrid': ds_660_Dgrid_anom},\n",
    "        }\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# working \n",
    "class GliderPlot(param.Parameterized):\n",
    "    # Setup all the parameters for the widgets\n",
    "    glider_num = param.Selector(glider_nums, default='sg659', \n",
    "                                label='Glider Num#', precedence=0)\n",
    "    glider_grid = param.Selector(['Tgrid', 'Dgrid'], default='Tgrid', \n",
    "                                label='Grid Type', precedence=0)\n",
    "    glider_var = param.Selector(glider_vars, default='temperature', \n",
    "                                label='Glider Variable', precedence=1)\n",
    "    var_colormap = param.Selector(default='RdBu_r', objects=cmap_options, \n",
    "                                  label='Colormap', precedence=2)\n",
    "    time_slider = param.Range(label='Days in 2019', \n",
    "                             bounds=(119, 209), \n",
    "                             default=(119, 135), precedence=3)\n",
    "    distance_slider = param.Range(label='Along Track Distance',\n",
    "                                 bounds=(0, 2e3), default=(0, 400), \n",
    "                                 precedence=-1) # start with a negative precedence, in accordance with default being Tgrid\n",
    "    anomaly_boolean = param.Boolean(default=False, label='Anomaly', precedence=3)\n",
    "    density_boolean = param.Boolean(default=True, label='Show Density Contours', precedence=4)\n",
    "    density_range = param.Range(label='Density range', bounds=(1026.8, 1027.9), default=(1026.8, 1027.9),precedence=10)\n",
    "    density_gradation = param.Integer(label='Density levels', default=11, bounds=(2, 21),precedence=10)\n",
    "    \n",
    "    rangex = streams.RangeX(x_range=(0,0))\n",
    "    \n",
    "#    rangex.x_range = (0,0)\n",
    "    title =''\n",
    "    \n",
    "    ## The Methods\n",
    "    # function to not have active toolbars by default\n",
    "    def _set_tools(self, plot, element):\n",
    "        plot.state.toolbar.active_drag = None\n",
    "        plot.state.toolbar.active_inspect = None\n",
    "    \n",
    "    # function to update default colormap choices with changing variables\n",
    "    @param.depends('glider_var', watch=True)\n",
    "    def _update_colormap(self):\n",
    "        self.var_colormap = var_select_map[self.glider_var]['cmap_sel']\n",
    "    \n",
    "    # The next couple of functions toggle the widgets visible or not. \n",
    "    @param.depends('density_boolean', watch=True)\n",
    "    def _update_density_widgets(self):\n",
    "        # helps to hide widgets when they are not being used. \n",
    "        if self.density_boolean:\n",
    "            self.param.density_range.precedence=10\n",
    "            self.param.density_gradation.precedence=10\n",
    "        else:\n",
    "            self.param.density_range.precedence=-1\n",
    "            self.param.density_gradation.precedence=-1\n",
    "            \n",
    "    @param.depends('glider_grid', watch=True)\n",
    "    def _update_grid_widgets(self):\n",
    "        if self.glider_grid == 'Tgrid':\n",
    "            self.param.time_slider.precedence=3\n",
    "            self.param.distance_slider.precedence=-1\n",
    "        else: \n",
    "            self.param.time_slider.precedence=-1\n",
    "            self.param.distance_slider.precedence=3\n",
    "            \n",
    "    # function to make density contours\n",
    "    @param.depends('density_range', 'density_gradation', 'glider_grid','glider_num')\n",
    "    def density_contours(self):\n",
    "        #print('in contour')\n",
    "        contour = glider_map[self.glider_num][self.glider_grid]['potdens'].hvplot.contour(flip_yaxis=True, \n",
    "                                                                     levels=np.linspace(self.density_range[0],\n",
    "                                                                                        self.density_range[1],\n",
    "                                                                                        self.density_gradation)\n",
    "                                                                       ).opts(tools=[])\n",
    "        return contour\n",
    "    \n",
    "    # function to make the image for the glider section\n",
    "    @param.depends('anomaly_boolean', 'glider_grid', 'glider_num', 'glider_var')\n",
    "    def glider_image(self):\n",
    "        # Change the data set if wanting to plot anomaly\n",
    "        if self.anomaly_boolean:\n",
    "            glid_ds = glider_map_anom\n",
    "        else:\n",
    "            glid_ds = glider_map\n",
    "\n",
    "        # plot the image in Distance or Time\n",
    "        if self.glider_grid=='Dgrid':\n",
    "            image = hv.Image( (glid_ds[self.glider_num][self.glider_grid].distance, \n",
    "                           glid_ds[self.glider_num][self.glider_grid].pressure,\n",
    "                           glid_ds[self.glider_num][self.glider_grid][self.glider_var]), \n",
    "                             ['Distance [km]', 'Pressure [dBar]'], self.glider_var)\n",
    "            self.rangex.source = image\n",
    "        else:\n",
    "            image = hv.Image( (glid_ds[self.glider_num][self.glider_grid].time, \n",
    "                           glid_ds[self.glider_num][self.glider_grid].pressure,\n",
    "                           glid_ds[self.glider_num][self.glider_grid][self.glider_var]), \n",
    "                             ['Time [days]', 'Pressure [dBar]'], self.glider_var)\n",
    "            self.rangex.source = image\n",
    "        \n",
    "        # estimate the color range so that outliers don't create problems\n",
    "        bin_range = np.nanpercentile(glid_ds[self.glider_num][self.glider_grid][self.glider_var], [.5,99.5])\n",
    "        \n",
    "        # set properties for image like colorbar etcs.\n",
    "        image = image.opts(opts.Image(\n",
    "                        colorbar=True,\n",
    "                        cmap=self.var_colormap,\n",
    "                        invert_yaxis=True,\n",
    "                        clim=(bin_range[0], bin_range[1]),\n",
    "                        width=800,\n",
    "                        tools=['hover'], hooks=[self._set_tools]\n",
    "                        ) )\n",
    "        return image\n",
    "    \n",
    "    # function to update the title\n",
    "#     @param.depends('rangex.params', watch=True)\n",
    "#     def _update_title(self):\n",
    "#         self.title = str(self.rangex.x_range)\n",
    "        #print(self.rangex.x_range)\n",
    "        \n",
    "    # function to set the xlimits \n",
    "    #@param.depends('glider_grid', 'time_slider', 'distance_slider')\n",
    "    #def adjusted_xlim_image(self):\n",
    "     \n",
    "\n",
    "        # add the adjoint histogram\n",
    "        #image = image.hist()# bin_range = (bin_range[0], bin_range[1]) )\n",
    "#         return image \n",
    "    \n",
    "   # @param.depends('distance_slider', 'time_slider', watch=True)\n",
    "    def viewable(self):\n",
    "        # add the density contours or not. \n",
    "        #if self.density_boolean:\n",
    "        #    return hv.DynamicMap(self.adjusted_xlim_image)*hv.DynamicMap(self.density_contours)\n",
    "        #else:\n",
    "        image = hv.DynamicMap(self.glider_image).hist()\n",
    "        \n",
    "        if self.glider_grid=='Dgrid':\n",
    "            image.opts(opts.Image(xlim = self.distance_slider))\n",
    "        else:\n",
    "            image.opts(opts.Image(xlim = self.time_slider))\n",
    "\n",
    "        return image*hv.DynamicMap(self.density_contours)\n",
    "            "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "test = GliderPlot()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#pn.Column(test.param, test.viewable())\n",
    "#pn.Row(test.param, test.viewable())\n",
    "pn.Row(test.param, test.viewable)\n",
    "# it makes a big difference if test.viewable is passed or test.viewable() is passed. \n",
    "# In the latter the dependencies are not automatically inferred. \n",
    "# In it's current form - using .viewable, even though we have explicitly defined \n",
    "# dependencies for many things in the class. A lot of the code gets called when widgets change. \n",
    "\n",
    "#https://examples.pyviz.org/datashader_dashboard/dashboard.html#datashader-dashboard-gallery-dashboard"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python [conda env:gliderviz]",
   "language": "python",
   "name": "conda-env-gliderviz-py"
  },
  "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
}