048-Grosch-4.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"https://gitlab.version.fz-juelich.de/grosch1/pvlink_demo_for_jupytercon/-/raw/JupyterCon2020/img/logo.png\"\n",
    "     style=\"float:right; width:25%; height:25%; margin-top:25px;\">\n",
    "\n",
    "# Jupyter for interactive in-situ visualization with ParaView/Catalyst\n",
    "\n",
    "[![Binder](https://mybinder.org/badge_logo.svg)](https://mybinder.org/v2/git/https%3A%2F%2Fgitlab.version.fz-juelich.de%2Fgrosch1%2Fpvlink_demo_for_jupytercon/JupyterCon2020)  \n",
    "Try out the *pvlink* extension and the example notebooks in binder."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Catalyst example"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "import ipywidgets as widgets\n",
    "\n",
    "from paraview import simple\n",
    "from pvlink import RemoteRenderer\n",
    "from pvlink.utility import SetRecommendedRenderSettings, ResetCamera"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Start a pvserver"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%bash --bg --proc server_process\n",
    "export OMP_NUM_THREADS=1\n",
    "pvserver --server-port=11223 > ${JUPYTER_LOG_DIR}/pvserver.log 2>&1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Start the Catalyst enabled simulation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%bash --bg --proc catalyst_process\n",
    "export OMP_NUM_THREADS=1\n",
    "cd CatalystEnabledSimulation\n",
    "pvpython ./fedriver.py ./cpscript.py > ${JUPYTER_LOG_DIR}/simulation.log 2>&1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Setup the RemoteRenderer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "jupyter_url = 'jupyter-jsc.fz-juelich.de' + os.environ.get('JUPYTERHUB_SERVICE_PREFIX', '/')\n",
    "renderer = RemoteRenderer(pvserverHost='localhost', pvserverPort = 11223, \n",
    "                          baseURL=jupyter_url, \n",
    "                          useJupyterServerProxyHttps=True, disableExternalPort=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create a view\n",
    "view1 = simple.FindViewOrCreate('view1', 'RenderView')\n",
    "SetRecommendedRenderSettings(view1)\n",
    "view1.Background = [0, 0, 0]\n",
    "view1.ShowAnnotation = 1\n",
    "renderer.viewID = view1.GetGlobalIDAsString()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Establish a Catalyst connection"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> Currently, this uses a custom python library patched into ParaView to enable establishing Catayst connections with python without a GUI interface.  \n",
    "> Starting from ParaView 5.9, a Catalyst python library capable of such a thing should be included by default."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "catalyst = simple.CatalystConnection()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "# open port for catalyst connection\n",
    "catalyst.Start()\n",
    "catalyst.AddUpdateFunction(renderer.update_render)\n",
    "catalyst.BlockTillConnected();"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "# wait till simulation connected\n",
    "catalyst.BlockTillConnected()\n",
    "# extract data from simulation\n",
    "# supplying a source name, that can be used to find the ParaView source.\n",
    "# In case of different named input, or multiple input ports, alows to choose the desired input, that should be extracted\n",
    "extract = catalyst.Extract('extract')\n",
    "# block till there is an update for the simulation data\n",
    "catalyst.BlockTillNextUpdate()\n",
    "# display simulation data\n",
    "simple.SetActiveSource(extract)\n",
    "extractDisplay = simple.Show(extract, view1)\n",
    "\n",
    "ResetCamera(view1, renderer)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Handle data with ParaView"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "# set scalar coloring\n",
    "simple.ColorBy(extractDisplay, ('CELLS', 'pressure'))\n",
    "\n",
    "# rescale color and/or opacity maps used to include current data range\n",
    "extractDisplay.RescaleTransferFunctionToDataRange(True, False)\n",
    "\n",
    "# show color bar/color legend\n",
    "extractDisplay.SetScalarBarVisibility(view1, True)\n",
    "\n",
    "# get color transfer function/color map for 'pressure'\n",
    "pressureLUT = simple.GetColorTransferFunction('pressure')\n",
    "pressureLUT.RescaleTransferFunction(0.0, 1.0)\n",
    "pressureLUT.ApplyPreset('Rainbow Desaturated', True)\n",
    "\n",
    "# get opacity transfer function/opacity map for 'pressure'\n",
    "pressurePWF = simple.GetOpacityTransferFunction('pressure')\n",
    "pressurePWF.RescaleTransferFunction(0.0, 1.0)\n",
    "\n",
    "# change representation type, for example wireframe or volume rendering\n",
    "extractDisplay.SetRepresentationType('Wireframe');\n",
    "# extractDisplay.SetRepresentationType('Volume');"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Setup interacts with ipywidgets"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Set representation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "dropdown = widgets.Dropdown(\n",
    "    options=['Wireframe', 'Volume'],\n",
    "#     value='Wireframe',\n",
    "    description='Representation:',\n",
    "    style={'description_width': '100pt'}\n",
    ")\n",
    "\n",
    "def change_representation(change):\n",
    "    if change['new'] == 'Wireframe':\n",
    "        extractDisplay.SetRepresentationType('Wireframe')\n",
    "    elif change['new'] == 'Volume':\n",
    "        extractDisplay.SetRepresentationType('Volume')\n",
    "        \n",
    "dropdown.observe(change_representation, 'value')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Pause/unpause"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "pause_button = widgets.Button(\n",
    "    description='Pause',\n",
    "    button_style='warning',\n",
    "    tooltip='Pause catalyst simulation',\n",
    "    icon='pause',\n",
    "    disabled=False\n",
    ")\n",
    "unpause_button = widgets.Button(\n",
    "    description='Unpause',\n",
    "    button_style='success', \n",
    "    tooltip='Unpause catalyst simulation',\n",
    "    icon='play',\n",
    "    disabled=True\n",
    ")\n",
    "\n",
    "def pause(button):\n",
    "    pause_button.disabled = True\n",
    "    unpause_button.disabled = False\n",
    "    catalyst.SetPauseSimulation(True)\n",
    "\n",
    "def unpause(button):\n",
    "    pause_button.disabled = False\n",
    "    unpause_button.disabled = True\n",
    "    catalyst.SetPauseSimulation(False)\n",
    "\n",
    "pause_button.on_click(pause)\n",
    "unpause_button.on_click(unpause)\n",
    "\n",
    "buttons = widgets.HBox([unpause_button, pause_button])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Show timestep"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "from threading import Thread\n",
    "from time import sleep\n",
    "\n",
    "timestep = widgets.Label(\n",
    "    value=\"timestep: 0\"\n",
    ")\n",
    "\n",
    "def show_timestep(widget):\n",
    "    while True:\n",
    "        step = catalyst.GetTimeStep()\n",
    "        widget.value = \"timestep: {}\".format(step)\n",
    "        sleep(0.5)\n",
    "    \n",
    "thread = Thread(target=show_timestep, args=(timestep,))\n",
    "thread.start()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Display widgets and renderer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "widget_layout = widgets.HBox(children=[dropdown, buttons, timestep],\n",
    "                             layout={'margin': '4px', 'justify_content': 'space-between'})\n",
    "renderer.layout.height = '100%'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "26cddb46ff914ff7ac23810181efc442",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "VBox(children=(HBox(children=(Dropdown(description='Representation:', options=('Wireframe', 'Volume'), style=D…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "widgets.VBox(children=[widget_layout, renderer], layout={'height': '800px'}) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "PyParaView-5.8",
   "language": "python",
   "name": "pyparaview-5.8"
  },
  "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.6.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}