DEMO_Getdata_local.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"\"\"\n",
    "install the upgraded givernylocal package.\n",
    "    - n.b. this only needs to be run once.\n",
    "\"\"\"\n",
    "!pip install --upgrade givernylocal"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<hr style = \"height:6px;border:none;background-color:sienna\">\n",
    "\n",
    "<h2 style = \"font-weight:bold;font-style:italic\">\n",
    "    Getdata demo notebook\n",
    "</h2>\n",
    "\n",
    "<p style = \"font-weight:bold;font-size:13px\">\n",
    "    &emsp;n.b. requires python 3.9+\n",
    "</p>\n",
    "\n",
    "<p style = \"font-weight:bold;font-size:13px\">\n",
    "    <u>purpose</u> :\n",
    "    <br>\n",
    "    &emsp;- local processing of JHTDB datasets.\n",
    "    <br><br>\n",
    "    <u>supported datasets</u> :\n",
    "</p>\n",
    "\n",
    "<ul>\n",
    "    <li style = \"font-weight:bold;font-size:13px\">\n",
    "        isotropic1024coarse &ensp;: &ensp;isotropic 1024-cube (coarse).\n",
    "    </li>\n",
    "    <li style = \"font-weight:bold;font-size:13px\">\n",
    "        isotropic1024fine &ensp;: &ensp;isotropic 1024-cube (fine).\n",
    "    </li>\n",
    "    <li style = \"font-weight:bold;font-size:13px\">\n",
    "        isotropic4096 &ensp;: &ensp;isotropic 4096-cube.\n",
    "    </li>\n",
    "    <li style = \"font-weight:bold;font-size:13px\">\n",
    "        isotropic8192 &ensp;: &ensp;isotropic 8192-cube.\n",
    "    </li>\n",
    "    <li style = \"font-weight:bold;font-size:13px\">\n",
    "        sabl2048low &ensp;: &ensp;stable atmospheric boundary layer 2048-cube, low-rate timestep.\n",
    "    </li>\n",
    "    <li style = \"font-weight:bold;font-size:13px\">\n",
    "        sabl2048high &ensp;: &ensp;stable atmospheric boundary layer 2048-cube, high-rate timestep.\n",
    "    </li>\n",
    "    <li style = \"font-weight:bold;font-size:13px\">\n",
    "        rotstrat4096 &ensp;: &ensp;rotating stratified 4096-cube.\n",
    "    </li>\n",
    "    <li style = \"font-weight:bold;font-size:13px\">\n",
    "        mhd1024 &ensp;: &ensp;magneto-hydrodynamic isotropic 1024-cube.\n",
    "    </li>\n",
    "    <li style = \"font-weight:bold;font-size:13px\">\n",
    "        mixing &ensp;: &ensp;homogeneous buoyancy driven 1024-cube.\n",
    "    </li>\n",
    "    <li style = \"font-weight:bold;font-size:13px\">\n",
    "        channel &ensp;: &ensp;channel flow.\n",
    "    </li>\n",
    "    <li style = \"font-weight:bold;font-size:13px\">\n",
    "        channel5200 &ensp;: &ensp;channel flow (reynolds number 5200).\n",
    "    </li>\n",
    "    <li style = \"font-weight:bold;font-size:13px\">\n",
    "        transition_bl &ensp;: &ensp;transitional boundary layer.\n",
    "    </li>\n",
    "</ul>\n",
    "\n",
    "<p style = \"font-weight:bold;font-size:13px\">\n",
    "    <u>functions</u> :\n",
    "</p>\n",
    "\n",
    "<ul>\n",
    "    <li style = \"font-weight:bold;font-size:13px\">\n",
    "        getData &ensp;: &ensp;retrieve (interpolate and/or differentiate) field data on a set of specified spatial points for the specified variable.\n",
    "    </li>\n",
    "    <li style = \"font-weight:bold;font-size:13px\">\n",
    "        write_interpolation_tsv_file &ensp;: &ensp;write getData results to a .tsv file.\n",
    "    </li>\n",
    "</ul>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<hr style = \"height:6px;border:none;background-color:sienna\">\n",
    "\n",
    "<h4 style = \"font-weight:bold;font-style:italic\">\n",
    "    instantiate dataset\n",
    "</h4>\n",
    "\n",
    "<p style = \"font-weight:bold;font-size:13px\">\n",
    "    <u>purpose</u> : \n",
    "    <br>\n",
    "    &emsp;- instantiate the dataset and cache the metadata.\n",
    "    <br>\n",
    "\n",
    "</p>\n",
    "\n",
    "<p style = \"font-weight:bold;font-size:13px\">\n",
    "    <u>parameters</u> :\n",
    "</p>\n",
    "\n",
    "<ul>\n",
    "    <li style = \"font-weight:bold;font-size:13px\">\n",
    "        auth_token &ensp;: &ensp;turbulence user authorization token.\n",
    "    </li>\n",
    "    <li style = \"font-weight:bold;font-size:13px\">\n",
    "        dataset_title &ensp;: &ensp;name of the turbulence dataset.\n",
    "    </li>\n",
    "    <li style = \"font-weight:bold;font-size:13px\">\n",
    "        output_path &ensp;: &ensp;folder path where output files will be to saved to.\n",
    "        <br>\n",
    "        &emsp;- n.b. &ensp;: &ensp;cannot be left blank.\n",
    "    </li>\n",
    "</ul>\n",
    "\n",
    "<hr style = \"height:6px;border:none;background-color:sienna\">"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "\"\"\"\n",
    "instantiate dataset\n",
    "\"\"\"\n",
    "from givernylocal.turbulence_dataset import *\n",
    "from givernylocal.turbulence_toolkit import *\n",
    "\n",
    "auth_token = 'edu.jhu.pha.turbulence.testing-201406'\n",
    "dataset_title = 'channel'\n",
    "output_path = './giverny_output'\n",
    "\n",
    "# instantiate the dataset.\n",
    "dataset = turb_dataset(dataset_title = dataset_title, output_path = output_path, auth_token = auth_token)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": []
   },
   "source": [
    "<hr style = \"height:6px;border:none;background-color:sienna\">\n",
    "\n",
    "<h4 style = \"font-weight:bold;font-style:italic\">\n",
    "    getData\n",
    "</h4>\n",
    "\n",
    "<p style = \"font-weight:bold;font-size:13px\">\n",
    "    <u>purpose</u> : \n",
    "    <br>\n",
    "    &emsp;- retrieve (interpolate and/or differentiate) a group of sparse data points.\n",
    "    <br>\n",
    "</p>\n",
    "\n",
    "<p style = \"font-weight:bold;font-size:13px\">\n",
    "    <u>steps</u> :\n",
    "</p>\n",
    "\n",
    "<ul>\n",
    "    <li style = \"font-weight:bold;font-size:13px\">\n",
    "        step 1 &ensp;: &ensp;identify the database files to be read.\n",
    "    </li>\n",
    "    <li style = \"font-weight:bold;font-size:13px\">\n",
    "        step 2 &ensp;: &ensp;read the database files and store the interpolated points in an array.\n",
    "    </li>\n",
    "</ul>\n",
    "\n",
    "<p style = \"font-weight:bold;font-size:13px\">\n",
    "    <u>parameters</u> :\n",
    "</p>\n",
    "\n",
    "<ul>\n",
    "    <li style = \"font-weight:bold;font-size:13px\">\n",
    "         dataset &ensp;: &ensp;the instantiated dataset.\n",
    "    </li>\n",
    "    <li style = \"font-weight:bold;font-size:13px\">\n",
    "        points &ensp;: &ensp;array of points in the domain [0, 2pi).\n",
    "    </li>\n",
    "    <li style = \"font-weight:bold;font-size:13px\">\n",
    "        variable &ensp;: &ensp;type of data (velocity, pressure, energy, temperature, force, magneticfield, vectorpotential, density, position).\n",
    "    </li>\n",
    "    <li style = \"font-weight:bold;font-size:13px\">\n",
    "        time &ensp;: &ensp;time (snapshot number for datasets without a full time evolution).\n",
    "    </li>\n",
    "    <li style = \"font-weight:bold;font-size:13px\">\n",
    "        time_end &ensp;: &ensp;ending time for 'position' variable and time series queries.\n",
    "    </li>\n",
    "    <li style = \"font-weight:bold;font-size:13px\">\n",
    "        delta_t &ensp;: &ensp;time step for 'position' variable and time series queries.\n",
    "    </li>\n",
    "    <li style = \"font-weight:bold;font-size:13px\">\n",
    "        temporal_method &ensp;: &ensp;temporal interpolation methods.\n",
    "        <br>\n",
    "        &emsp;- none &ensp;: &ensp;No temporal interpolation (the value at the closest stored time will be returned).\n",
    "        <br>\n",
    "        &emsp;- pchip &ensp;: &ensp;Piecewise Cubic Hermite Interpolation Polynomial method is used, in which the value from the two nearest times<br>\n",
    "        &emsp;&emsp;&emsp;&emsp;&emsp;&emsp;&nbsp;is interpolated at time t using Cubic Hermite Interpolation Polynomial, with centered finite difference evaluation of the<br>\n",
    "        &emsp;&emsp;&emsp;&emsp;&emsp;&emsp;&nbsp;end-point time derivatives (i.e. a total of four temporal points are used).\n",
    "        <br>\n",
    "    </li>\n",
    "    <li style = \"font-weight:bold;font-size:13px\">\n",
    "        spatial_method &ensp;: &ensp;spatial interpolation and differentiation methods.\n",
    "        <br>\n",
    "        &emsp;- none &ensp;: &ensp;No spatial interpolation (value at the datapoint closest to each coordinate value).\n",
    "        <br>\n",
    "        &emsp;- lag4 &ensp;: &ensp;4th-order Lagrange Polynomial interpolation along each spatial direction.\n",
    "        <br>\n",
    "        &emsp;- lag6 &ensp;: &ensp;6th-order Lagrange Polynomial interpolation along each spatial direction.\n",
    "        <br>\n",
    "        &emsp;- lag8 &ensp;: &ensp;8th-order Lagrange Polynomial interpolation along each spatial direction.\n",
    "        <br>\n",
    "        &emsp;- m1q4 &ensp;: &ensp;Splines with smoothness 1 (3rd order) over 4 data points.\n",
    "        <br>\n",
    "        &emsp;- m2q8 &ensp;: &ensp;Splines with smoothness 2 (5th order) over 8 data points. \n",
    "        <br>\n",
    "        &emsp;- m2q14 &ensp;: &ensp;Splines with smoothness 2 (5th order) over 14 data points. \n",
    "        <br>\n",
    "        &emsp;- fd4noint &ensp;: &ensp;4th-order centered finite differencing (without spatial interpolation).\n",
    "        <br>\n",
    "        &emsp;- fd6noint &ensp;: &ensp;6th-order centered finite differencing (without spatial interpolation).\n",
    "        <br>\n",
    "        &emsp;- fd8noint &ensp;: &ensp;8th-order centered finite differencing (without spatial interpolation).\n",
    "        <br>\n",
    "        &emsp;- fd4lag4 &ensp;: &ensp;4th-order Lagrange Polynomial interpolation in each direction, of the 4th-order finite difference values on the grid.\n",
    "        <br>\n",
    "    </li>\n",
    "    <li style = \"font-weight:bold;font-size:13px\">\n",
    "        spatial_operator &ensp;: &ensp;spatial interpolation and differentiation operator.\n",
    "        <br>\n",
    "        &emsp;- field &ensp;: &ensp;function evaluation &amp; interpolation.\n",
    "        <br>\n",
    "        &emsp;- gradient &ensp;: &ensp;differentiation &amp; interpolation.\n",
    "        <br>\n",
    "        &emsp;- hessian &ensp;: &ensp;differentiation &amp; interpolation.\n",
    "        <br>\n",
    "        &emsp;- laplacian &ensp;: &ensp;differentiation &amp; interpolation.\n",
    "        <br>\n",
    "    </li>\n",
    "</ul>\n",
    "\n",
    "<p style = \"font-weight:bold;font-size:13px\">\n",
    "    <u>output</u> :\n",
    "</p>\n",
    "\n",
    "<ul>\n",
    "    <li style = \"font-weight:bold;font-size:13px\">\n",
    "        result &ensp;: &ensp;interpolated/differentiated values array.\n",
    "    </li>\n",
    "</ul>\n",
    "\n",
    "<hr style = \"height:6px;border:none;background-color:sienna\">"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "\"\"\"\n",
    "initialize getData parameters (except time and points)\n",
    "\"\"\"\n",
    "variable = 'velocity'\n",
    "temporal_method = 'none'\n",
    "spatial_method = 'lag8'\n",
    "spatial_operator = 'field'\n",
    "\n",
    "\"\"\"\n",
    "example point distributions (2D plane, 3D box, random, time series) are provided below...\n",
    "\"\"\";"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "\"\"\"\n",
    "2D plane demo points : evenly spaced over a 2D plane lying along one of the primary axes\n",
    "    - time : the time to be queried (snapshot number for datasets without a full time evolution).\n",
    "    - nx, nz : number of points along each axis. total number of points queried will be n_points = nx * nz.\n",
    "    - x_points, y_points, z_points : point distributions along each axis, evenly spaced over the specified ranges.\n",
    "        - np.linspace(axis minimum, axis maximum, number of points).\n",
    "    - points : the points array evenly spaced out over the 2D plane.\n",
    "        - points array is instantiated as an empty array that will be filled inside the for loops.\n",
    "\"\"\"\n",
    "time = 1.0\n",
    "\n",
    "nx = 64\n",
    "nz = 64\n",
    "n_points = nx * nz\n",
    "\n",
    "x_points = np.linspace(0.0, 0.4 * np.pi, nx, dtype = np.float64)\n",
    "y_points = 0.9\n",
    "z_points = np.linspace(0.0, 0.15 * np.pi, nz, dtype = np.float64)\n",
    "        \n",
    "points = np.zeros((n_points, 3), dtype = np.float64)\n",
    "for i in range(nx):\n",
    "    for j in range(nz):\n",
    "        points[i * nz + j, 0] = x_points[i]  \n",
    "        points[i * nz + j, 1] = y_points\n",
    "        points[i * nz + j, 2] = z_points[j]\n",
    "\n",
    "\"\"\"\n",
    "use the tools and processing gizmos.\n",
    "\"\"\"\n",
    "# process interpolation/differentiation of points.\n",
    "result = getData(dataset, variable, time, temporal_method, spatial_method, spatial_operator, points)\n",
    "\n",
    "\"\"\"\n",
    "display sample results on screen.\n",
    "\"\"\"\n",
    "# set threshold for the number of numpy array elements to display.\n",
    "np.set_printoptions(threshold = 10)\n",
    "\n",
    "print(f'num points = {len(points)}')\n",
    "print(f'\\npoints = \\n-\\n{points}')\n",
    "# the 1st time index of result corresponds to the final time for the \"position\" variable and the initial time for all other variables.\n",
    "print(f'\\nresult (1st time index) = \\n-\\n{result[0]}\\n')\n",
    "\n",
    "\"\"\"\n",
    "with result, generate a 2D contour plot.\n",
    "    - a simple plot to quickly visualize the queried 2D plane.\n",
    "\"\"\";\n",
    "if nx >= 2 and nz >= 2:\n",
    "    # user-defined plot parameters.\n",
    "    # which time of the data to plot (0-based index, so the first time component is specified as 0).\n",
    "    time_component = 0\n",
    "    # which component (column) of the data to plot (0-based index, so the first component is specified as 0).\n",
    "    plot_component = 0\n",
    "\n",
    "    # reformat 'result' for plotting.\n",
    "    result_time = result[time_component]\n",
    "    result_array = np.array(result_time)\n",
    "    data_plot = np.zeros((nx, nz, len(result_time.columns)), dtype = np.float32)\n",
    "    x_plot = np.zeros((nx, nz), dtype = np.float64)\n",
    "    z_plot = np.zeros((nx, nz), dtype = np.float64)\n",
    "\n",
    "    for i in range(nx):\n",
    "        for j in range(nz):\n",
    "            x_plot[i, j] = x_points[i]\n",
    "            z_plot[i, j] = z_points[j]\n",
    "            data_plot[i, j, :] = result_array[i * nz + j, :]\n",
    "\n",
    "    # plot the data.\n",
    "    fig = plt.figure(figsize = (7, 7), dpi = 67)\n",
    "    contour = plt.contourf(x_plot, z_plot, data_plot[:, :, plot_component], levels = 500, cmap = 'inferno')\n",
    "    plt.gca().set_aspect('equal')\n",
    "    # select the colorbar orientation depending on which axis is larger.\n",
    "    colorbar_orientation = 'vertical' if (np.max(z_plot) - np.min(z_plot)) >= (np.max(x_plot) - np.min(x_plot)) else 'horizontal'\n",
    "    cbar = plt.colorbar(contour, shrink = 0.67, orientation = colorbar_orientation)\n",
    "    # rotate the horizontal colorbar labels.\n",
    "    if colorbar_orientation == 'horizontal':\n",
    "        for label in cbar.ax.get_xticklabels():\n",
    "            label.set_rotation(90)\n",
    "    cbar.set_label(f'{variable} {spatial_operator}', labelpad = 12, fontsize = 14)\n",
    "    plt.title(f'{dataset_title}', fontsize = 16)\n",
    "    plt.xlabel('x', labelpad = 7, fontsize = 14)\n",
    "    plt.ylabel('z', labelpad = 7, fontsize = 14)\n",
    "    cbar.ax.tick_params(labelsize = 12)\n",
    "    plt.tick_params(axis = 'both', labelsize = 12)\n",
    "    plt.tight_layout()\n",
    "    plt.show()\n",
    "    plt.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "\"\"\"\n",
    "3D box demo points : evenly spaced over a 3D volume\n",
    "    - time : the time to be queried (snapshot number for datasets without a full time evolution).\n",
    "    - nx,ny,nz : number of points along each axis. total number of points queried will be n_points= nx * ny * nz.\n",
    "    - x_points, y_points, z_points : point distributions along each axis, evenly spaced over the specified ranges.\n",
    "        - np.linspace(axis minimum, axis maximum, number of points).\n",
    "    - points : the points array evenly spaced out over the 3D volume.\n",
    "        - points array is instantiated as an empty array that will be filled inside the for loops.\n",
    "\"\"\"\n",
    "time = 1.0\n",
    "\n",
    "nx = 16\n",
    "ny = 16\n",
    "nz = 16\n",
    "n_points = nx * ny * nz\n",
    "\n",
    "x_points = np.linspace(3.0, 3.3, nx, dtype = np.float64)\n",
    "y_points = np.linspace(-0.9, -0.6, ny, dtype = np.float64)\n",
    "z_points = np.linspace(0.2, 0.5, nz, dtype = np.float64)\n",
    "\n",
    "points = np.zeros((n_points, 3), dtype = np.float64)\n",
    "for i in range(nx):\n",
    "    for j in range(ny):\n",
    "        for k in range(nz):      \n",
    "            points[i * ny * nz + j * nz + k, 0] = x_points[i]  \n",
    "            points[i * ny * nz + j * nz + k, 1] = y_points[j]\n",
    "            points[i * ny * nz + j * nz + k, 2] = z_points[k]\n",
    "\n",
    "\"\"\"\n",
    "use the tools and processing gizmos.\n",
    "\"\"\"\n",
    "# process interpolation/differentiation of points.\n",
    "result = getData(dataset, variable, time, temporal_method, spatial_method, spatial_operator, points)\n",
    "\n",
    "\"\"\"\n",
    "display sample results on screen.\n",
    "\"\"\"\n",
    "# set threshold for the number of numpy array elements to display.\n",
    "np.set_printoptions(threshold = 10)\n",
    "\n",
    "print(f'num points = {len(points)}')\n",
    "print(f'\\npoints = \\n-\\n{points}')\n",
    "# the 1st time index of result corresponds to the final time for the \"position\" variable and the initial time for all other variables.\n",
    "print(f'\\nresult (1st time index) = \\n-\\n{result[0]}\\n')\n",
    "\n",
    "\"\"\"\n",
    "with result, generate a 2D contour plot.\n",
    "    - a simple plot to quickly visualize the queried 3D volume on a sample plane at y.\n",
    "\"\"\";\n",
    "if nx >= 2 and ny >= 2 and nz >= 2:\n",
    "    # user-defined plot parameters.\n",
    "    # which time of the data to plot (0-based index, so the first time component is specified as 0).\n",
    "    time_component = 0\n",
    "    # which component (column) of the data to plot (0-based index, so the first component is specified as 0).\n",
    "    plot_component = 0\n",
    "    \n",
    "    # reformat 'result' for plotting.\n",
    "    result_time = result[time_component]\n",
    "    result_array = np.array(result_time)\n",
    "    data_plot = np.zeros((nx, ny, nz, len(result_time.columns)), dtype = np.float32)\n",
    "    x_plot = np.zeros((nx, ny, nz), dtype = np.float64)\n",
    "    y_plot = np.zeros((nx, ny, nz), dtype = np.float64)\n",
    "    z_plot = np.zeros((nx, ny, nz), dtype = np.float64)\n",
    "\n",
    "    for i in range(nx):\n",
    "        for j in range(ny):\n",
    "            for k in range(nz):\n",
    "                x_plot[i, j, k] = x_points[i]\n",
    "                y_plot[i, j, k] = y_points[j]\n",
    "                z_plot[i, j, k] = z_points[k]\n",
    "                data_plot[i, j, k, :] = result_array[i * ny * nz + j * nz + k, :]\n",
    "\n",
    "    # plot the data.\n",
    "    fig = go.Figure(\n",
    "        data = go.Volume(\n",
    "            x = x_plot.flatten(), y = y_plot.flatten(), z = z_plot.flatten(),\n",
    "            value = data_plot[:, :, :, plot_component].flatten(),\n",
    "            isomin = data_plot[:, :, :, plot_component].min(),\n",
    "            isomax = data_plot[:, :, :, plot_component].max(),\n",
    "            opacity = 0.2, surface_count = 17, colorscale = 'inferno',\n",
    "            colorbar = dict(\n",
    "                title = dict(text = f'{variable} {spatial_operator}', side = 'right', font = dict(size = 14)),\n",
    "                thickness = 15, len = 0.75,\n",
    "                x = 1.05, y = 0.5, xanchor = 'left', yanchor = 'middle'),\n",
    "            hovertemplate =\n",
    "                '<i>x</i> : %{x:.2f}' +\n",
    "                '<br><i>y</i> : %{y:.2f}' +\n",
    "                '<br><i>z</i> : %{z:.2f}' +\n",
    "                '<br><i>value</i> : %{value:.3f}' +\n",
    "                '<extra></extra>',\n",
    "            showlegend = False))\n",
    "\n",
    "    # update figure layout.\n",
    "    fig.update_layout(\n",
    "        title = dict(\n",
    "            text = f'{dataset_title} (click and drag to rotate)', x = 0.5, y = 0.95, xanchor = 'center', yanchor = 'top', font = dict(size = 16)),\n",
    "        scene = dict(\n",
    "            xaxis = dict(title = 'x', gridcolor = 'lightgrey', showline = True, linecolor = 'black'),\n",
    "            yaxis = dict(title = 'y', gridcolor = 'lightgrey', showline = True, linecolor = 'black'),\n",
    "            zaxis = dict(title = 'z', gridcolor = 'lightgrey', showline = True, linecolor = 'black'),\n",
    "            aspectmode = 'data',\n",
    "            camera = dict(eye = dict(x = 1.5, y = 1.5, z = 1.5)),\n",
    "            bgcolor = 'white'),\n",
    "        width = 600, height = 600, plot_bgcolor = 'white', paper_bgcolor = 'white',\n",
    "        showlegend = False)\n",
    "\n",
    "    fig.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "\"\"\"\n",
    "random box demo points : uniformly distributed over the specified domain\n",
    "    - time : the time to be queried (snapshot number for datasets without a full time evolution).\n",
    "    - n_points : number of points.\n",
    "    - min_xyz, max_xyz : minimum and maximum (x, y, z) axes boundaries for generating the random distribution of points within.\n",
    "    - points : the points array containing a random distribution of points in the specified domain.\n",
    "\"\"\"\n",
    "time = 1.0\n",
    "\n",
    "n_points = 1000\n",
    "\n",
    "min_xyz = [6.1359, -0.61359, 0.6]\n",
    "max_xyz = [21.8656, 0.8656, 8.8656]\n",
    "\n",
    "points = np.random.uniform(low = [min_xyz[0], min_xyz[1], min_xyz[2]],\n",
    "                           high = [max_xyz[0], max_xyz[1], max_xyz[2]],\n",
    "                           size = (n_points, 3))\n",
    "\n",
    "\"\"\"\n",
    "use the tools and processing gizmos.\n",
    "\"\"\"\n",
    "# process interpolation/differentiation of points.\n",
    "result = getData(dataset, variable, time, temporal_method, spatial_method, spatial_operator, points)\n",
    "\n",
    "\"\"\"\n",
    "display sample results on screen.\n",
    "\"\"\"\n",
    "# set threshold for the number of numpy array elements to display.\n",
    "np.set_printoptions(threshold = 10)\n",
    "\n",
    "print(f'num points = {len(points)}')\n",
    "print(f'\\npoints = \\n-\\n{points}')\n",
    "# the 1st time index of result corresponds to the final time for the \"position\" variable and the initial time for all other variables.\n",
    "print(f'\\nresult (1st time index) = \\n-\\n{result[0]}\\n')\n",
    "\n",
    "\"\"\"\n",
    "with result, generate a 3D scatter plot and histogram.\n",
    "    - simple plots to quickly visualize the queried box volume.\n",
    "\"\"\";\n",
    "# user-defined plot parameters.\n",
    "# which time of the data to plot (0-based index, so the first time component is specified as 0).\n",
    "time_component = 0\n",
    "# which component (column) of the data to plot (0-based index, so the first component is specified as 0).\n",
    "plot_component = 0\n",
    "# number of bins for the histogram.\n",
    "bins = 20\n",
    "\n",
    "x_plot, y_plot, z_plot = points[:, 0], points[:, 1], points[:, 2]\n",
    "data_plot = np.array(result[time_component])[:, plot_component]\n",
    "\n",
    "# plot the data.\n",
    "# scatter subplot.\n",
    "scatter = go.Scatter3d(\n",
    "    x = x_plot, y = y_plot, z = z_plot, mode = 'markers',\n",
    "    marker = dict(\n",
    "        size = 4,\n",
    "        color = data_plot,\n",
    "        colorscale = 'inferno',\n",
    "        opacity = 0.8,\n",
    "        colorbar = dict(\n",
    "            title = dict(text = f'{variable} {spatial_operator}', side = 'bottom', font = dict(size = 14)),\n",
    "            thickness = 15, len = 0.4, orientation = 'h',ticks = 'outside', outlinecolor = 'black', outlinewidth = 1,\n",
    "            x = 0.23, y = -0.2, xanchor = 'center', yanchor = 'bottom')),\n",
    "    hovertemplate =\n",
    "        '<i>x</i> : %{x:.2f}' +\n",
    "        '<br><i>y</i> : %{y:.2f}' +\n",
    "        '<br><i>z</i> : %{z:.2f}' +\n",
    "        '<br><i>value</i> : %{marker.color:.3f}' +\n",
    "        '<extra></extra>',\n",
    "    showlegend = False)\n",
    "\n",
    "# histogram subplot.\n",
    "histogram = go.Histogram(\n",
    "    x = data_plot, nbinsx = bins,\n",
    "    marker_color = 'forestgreen', marker_line = dict(color = 'black', width = 1), opacity = 0.85,\n",
    "    hovertemplate = 'bin range : %{x}<br>count : %{y}<extra></extra>',\n",
    "    showlegend = False)\n",
    "\n",
    "# make subplots.\n",
    "fig = make_subplots(\n",
    "    rows = 1, cols = 2, \n",
    "    specs = [[{'type': 'scene'}, {'type': 'xy'}]],\n",
    "    subplot_titles = ('scatter (click and drag to rotate)', 'histogram'),\n",
    "    column_widths = [0.47, 0.47], horizontal_spacing = 0.06)\n",
    "\n",
    "# add scatter and histogram traces to subplots.\n",
    "fig.add_trace(scatter, row = 1, col = 1)\n",
    "fig.add_trace(histogram, row = 1, col = 2)\n",
    "\n",
    "# update figure layout.\n",
    "fig.update_layout(\n",
    "    title = dict(\n",
    "        text = f'{dataset_title}', x = 0.5, y = 0.95, xanchor = 'center', yanchor = 'top', font = dict(size = 16)),\n",
    "    scene = dict(\n",
    "        xaxis = dict(title = 'x', gridcolor = 'lightgrey', showline = True, linecolor = 'black'),\n",
    "        yaxis = dict(title = 'y', gridcolor = 'lightgrey', showline = True, linecolor = 'black'),\n",
    "        zaxis = dict(title = 'z', gridcolor = 'lightgrey', showline = True, linecolor = 'black'),\n",
    "        aspectmode = 'data',\n",
    "        camera = dict(eye = dict(x = 2.5, y = 2.5, z = 2.5)),\n",
    "        bgcolor = 'white'),\n",
    "    xaxis_title = variable, yaxis_title = 'count',\n",
    "    height = 600, width = 1200, plot_bgcolor = 'white', paper_bgcolor = 'white',\n",
    "    showlegend = False)\n",
    "\n",
    "# display plot boundaries.\n",
    "fig.update_xaxes(showline = True, linewidth = 1, linecolor = 'black', mirror = True)\n",
    "fig.update_yaxes(showline = True, linewidth = 1, linecolor = 'black', mirror = True)\n",
    "\n",
    "fig.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "\"\"\"\n",
    "time series demo point(s)\n",
    "    - time : the start time of the time series (snapshot number for datasets without a full time evolution).\n",
    "    - time_end : the end time of the time series (snapshot number for datasets without a full time evolution).\n",
    "    - delta_t : time step.\n",
    "    - points : the points array.\n",
    "\"\"\"\n",
    "# create a temporary variable for the temporal method to set to 'pchip' for this time series example.\n",
    "temporal_method_tmp = 'pchip'\n",
    "\n",
    "time = 0.1\n",
    "time_end = 0.5\n",
    "delta_t = 0.008\n",
    "option = [time_end, delta_t]\n",
    "\n",
    "points = np.array([[10.33, 0.9, 4.6]], dtype = np.float64)\n",
    "\n",
    "\"\"\"\n",
    "use the tools and processing gizmos.\n",
    "\"\"\"\n",
    "# process interpolation/differentiation of points.\n",
    "result = getData(dataset, variable, time, temporal_method_tmp, spatial_method, spatial_operator, points, option)\n",
    "\n",
    "\"\"\"\n",
    "display sample results on screen.\n",
    "\"\"\"\n",
    "# set threshold for the number of numpy array elements to display.\n",
    "np.set_printoptions(threshold = 10)\n",
    "\n",
    "print(f'num points = {len(points)}')\n",
    "print(f'\\npoints = \\n-\\n{points}')\n",
    "# the 1st time index of result corresponds to the final time for the \"position\" variable and the initial time for all other variables.\n",
    "print(f'\\nresult (1st time index) = \\n-\\n{result[0]}\\n')\n",
    "\n",
    "\"\"\"\n",
    "with result, generate an x-y signal plot.\n",
    "    - a simple plot to quickly visualize the queried point over time.\n",
    "\"\"\";\n",
    "if variable != 'position':\n",
    "    # user-defined plot parameters.\n",
    "    # which point of the data to plot (0-based index, so the first point component is specified as 0).\n",
    "    point_component = 0\n",
    "    # which component (column) of the data to plot (0-based index, so the first component is specified as 0).\n",
    "    plot_component = 0\n",
    "\n",
    "    times_plot = np.arange(time, time_end, delta_t)\n",
    "    # append time_end if the final time in times_plot is delta_t less than time_end due to machine precision.\n",
    "    if math.isclose(times_plot[-1] + delta_t, time_end, rel_tol = 10**-9, abs_tol = 0.0):\n",
    "        times_plot = np.append(times_plot, time_end)\n",
    "    data_plot = np.array(result)[:, point_component][:, plot_component]\n",
    "\n",
    "    # plot the data.\n",
    "    fig = plt.figure(figsize = (7, 7), dpi = 67)\n",
    "    signal = plt.plot(times_plot, data_plot, color = 'forestgreen', linewidth = 3)\n",
    "    plt.title(f'{dataset_title}, time series at xyz = ({points[0][0]:.2f}, {points[0][1]:.2f}, {points[0][2]:.2f})', fontsize = 16)\n",
    "    plt.xlabel(f'time', labelpad = 7, fontsize = 14)\n",
    "    plt.ylabel(f'{variable}', labelpad = 7, fontsize = 14)\n",
    "    plt.tick_params(axis = 'both', labelsize = 12)\n",
    "    plt.tight_layout()\n",
    "    plt.show()\n",
    "    plt.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<hr style = \"height:6px;border:none;background-color:sienna\">\n",
    "\n",
    "<h4 style = \"font-weight:bold;font-style:italic\">\n",
    "    save interpolation results\n",
    "</h4>\n",
    "\n",
    "<p style = \"font-weight:bold;font-size:13px\">\n",
    "    <u>purpose</u> : \n",
    "    <br>\n",
    "    &emsp;- save the interpolated/differentiated points retrieved by the getData function.\n",
    "    <br>\n",
    "</p>\n",
    "\n",
    "<p style = \"font-weight:bold;font-size:13px\">\n",
    "    <u>parameters</u> :\n",
    "</p>\n",
    "\n",
    "<ul>\n",
    "    <li style = \"font-weight:bold;font-size:13px\">\n",
    "         dataset &ensp;: &ensp;the instantiated dataset.\n",
    "    </li>\n",
    "    <li style = \"font-weight:bold;font-size:13px\">\n",
    "         points &ensp;: &ensp;input points to getData.\n",
    "    </li>\n",
    "    <li style = \"font-weight:bold;font-size:13px\">\n",
    "         result &ensp;: &ensp;output from getData.\n",
    "    </li>\n",
    "    <li style = \"font-weight:bold;font-size:13px\">\n",
    "        output_filename &ensp;: &ensp;filename for the tsv file to be saved in the output_path folder.\n",
    "    </li>\n",
    "</ul>\n",
    "\n",
    "<p style = \"font-weight:bold;font-size:13px\">\n",
    "    <u>output</u> :\n",
    "</p>\n",
    "\n",
    "<ul>\n",
    "    <li style = \"font-weight:bold;font-size:13px\">\n",
    "        tsv file &ensp;: &ensp;saved to output_filename in the output_path folder.\n",
    "    </li>\n",
    "</ul>\n",
    "\n",
    "<hr style = \"height:6px;border:none;background-color:sienna\">"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "\"\"\"\n",
    "write the interpolation results to a tab-separated value (tsv) file\n",
    "\"\"\"\n",
    "output_filename = 'turbulence-interpolation'\n",
    "\n",
    "\"\"\"\n",
    "use the tsv writing gizmo.\n",
    "\"\"\"\n",
    "# write the tsv output file.\n",
    "write_interpolation_tsv_file(dataset, points, result, output_filename)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3.9 (py39)",
   "language": "python",
   "name": "py39"
  },
  "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.13"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}