diff --git a/book/tutorials/ICESat2_ATL15_dhdt/ICESat2_ATL15_dhdt.ipynb b/book/tutorials/ICESat2_ATL15_dhdt/ICESat2_ATL15_dhdt.ipynb new file mode 100644 index 0000000..bf56c53 --- /dev/null +++ b/book/tutorials/ICESat2_ATL15_dhdt/ICESat2_ATL15_dhdt.ipynb @@ -0,0 +1,1315 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "6ebcc534-7744-496f-8e67-fec73b05c0a4", + "metadata": {}, + "source": [ + "# Streaming cloud-hosted ICESat-2 ATL15 (Gridded Antarctic/Arctic Land Ice Height) to calculate dh/dt trends\n", + "
\n", + "\n", + "**Authors**\n", + "- Wilson Sauthoff (https://wsauthoff.github.io)\n", + "- Matthew Siegfried (https://mrsiegfried.github.io/)\n", + "\n", + "## Key learning outcomes\n", + "- Learn how to open, plot, and explore gridded raster data from the ICESat-2 ATL15 data product.\n", + "- Use Xarray to import multi-dimensional data stored in \"the cloud\" and apply a function across a data cube.\n", + "- Use gridded time series data to calculate per pixel height change (dh/dt) trends across the full duration of the ICESat-2 mission (2019 to latest release date)." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "8272df5f-23be-4cf8-a1e9-4ea44d43b202", + "metadata": {}, + "outputs": [], + "source": [ + "# This tutorial requires a ~8 GB server instance\n", + "\n", + "# Import libraries\n", + "import earthaccess\n", + "from IPython.display import Image, display\n", + "import matplotlib.colors as mpl_colors\n", + "import matplotlib.dates as mdates\n", + "import matplotlib.font_manager as fm\n", + "import matplotlib.gridspec as gridspec\n", + "import matplotlib.patches as patches\n", + "import matplotlib.pyplot as plt\n", + "import matplotlib.ticker as ticker\n", + "from mpl_toolkits.axes_grid1.anchored_artists import AnchoredSizeBar\n", + "from mpl_toolkits.axes_grid1 import make_axes_locatable\n", + "import numpy as np\n", + "import pandas as pd\n", + "import xarray as xr" + ] + }, + { + "cell_type": "markdown", + "id": "20d5dee6-b301-49ac-bf32-26578f7cb173", + "metadata": {}, + "source": [ + "## What is ICESat-2?\n", + "\n", + "ICESat-2 (Ice, Cloud, and land Elevation Satellite 2), part of NASA's Earth Observing System, is a satellite mission for measuring ice sheet elevation and sea ice thickness, as well as land topography, vegetation characteristics, and clouds. It does so using an altimeter or an altitude meter, which is an instrument used to measure the altitude of an object above a fixed level (the datum we talked about earlier). This is typically achieved by measuring the time it takes for a lidar or radar pulse, released by a satellite-based altimeter, to travel to a surface, reflect, and return to be recorded by an onboard instrument. ICESat-2 uses three pairs of laser pulsers and the detector to count the reflected photons. \n", + "\n", + "ICESat-2 laser configuration (from [Smith and others, 2019](https://doi.org/10.1016/j.rse.2019.111352)): \n", + "\n", + "![ICESat-2 laser configuration](images/Smith_2019_fig1.png)" + ] + }, + { + "cell_type": "markdown", + "id": "05b3dc62-46cc-4da3-bf1e-cc7043b736b7", + "metadata": {}, + "source": [ + "### What is ATL14/15?\n", + "ATL15 is one of the various [ICESat-2 data products](https://icesat-2.gsfc.nasa.gov/science/data-products). ATL15 provides various resolutions (1 km, 10 km, 20 km, and 40 km) of gridded (AKA raster) data of height change at 3-month intervals (Smith and others, 2022), allowing for estimation of dh/dt at each grid cell.\n", + "\n", + "ATL14 is an accompnaying high-resolution (100 m) digital elevation model (DEM) that provides spatially continuous gridded data of ice sheet surface height at a specific datetime. ATL15 height changes are relative to the ATL14 DEM.\n", + "\n", + "Learn more about the ICESat-2 ATL14/15 Gridded Antarctic and Arctic Land Ice Height Change data product dataset [here](https://doi.org/10.5067/ATLAS/ATL15.004)." + ] + }, + { + "cell_type": "markdown", + "id": "1216e790-ec0f-4dde-b515-8f4cc023a601", + "metadata": {}, + "source": [ + "## Streaming cloud-hosted data from NASA Earthdata Cloud\n", + "We will be working with cloud-hosted data files. This [guide](https://nsidc.org/data/user-resources/help-center/nasa-earthdata-cloud-data-access-guide) explains how to find and access Earthdata cloud-hosted data. [Here](https://nsidc.org/data/earthdata-cloud) is a complete list of earthdata cloud-hosted data products currently available from NSIDC.\n", + "\n", + "**Streaming cloud-hosted NASA Earthdata requires a free account. Get one [here](https://www.earthdata.nasa.gov/eosdis/science-system-description/eosdis-components/earthdata-login).**" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "f8b91462-b863-4845-89b5-30725c62b924", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Log into NASA Earthdata to search for datasets\n", + "earthaccess.login()" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "8b8ccef4-9915-4c60-bc59-91f6a495699c", + "metadata": {}, + "outputs": [], + "source": [ + "# Find ICESat-2 ATL15 version four data granules in the northern hemisphere\n", + "results = earthaccess.search_data(\n", + " doi='10.5067/ATLAS/ATL15.004',\n", + " bounding_box=(180, 60, -180, 90), # (lower_left_lon, lower_left_lat , upper_right_lon, upper_right_lat))\n", + " cloud_hosted=True,\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "0b65a573-cbd6-4554-abeb-3aeaed49bc9c", + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "e45652c599754bbf950dd908269ce518", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "QUEUEING TASKS | : 0%| | 0/24 [00:00,\n", + " ,\n", + " ,\n", + " ,\n", + " ,\n", + " ,\n", + " ,\n", + " ,\n", + " ,\n", + " ,\n", + " ,\n", + " ,\n", + " ,\n", + " ,\n", + " ,\n", + " ,\n", + " ,\n", + " ,\n", + " ,\n", + " ,\n", + " ,\n", + " ,\n", + " ,\n", + " ]" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Open data granules as s3 files to stream\n", + "files = earthaccess.open(results)\n", + "files" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "f0c48150-9846-4929-9aa4-eb5debd122c1", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n" + ] + } + ], + "source": [ + "# After viewing files, index the files you wish to open\n", + "print(files[19]) # 1-km resolution Greenland ATL15" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "e0291aae-6444-42f3-83e3-360f1d1885d7", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "
<xarray.Dataset> Size: 2GB\n",
+       "Dimensions:              (x: 1541, y: 2741, time: 21)\n",
+       "Coordinates:\n",
+       "  * x                    (x) float64 12kB -6.7e+05 -6.69e+05 ... 8.7e+05\n",
+       "  * y                    (y) float64 22kB -3.35e+06 -3.349e+06 ... -6.1e+05\n",
+       "  * time                 (time) datetime64[ns] 168B 2019-01-01T06:00:00 ... 2...\n",
+       "Data variables:\n",
+       "    Polar_Stereographic  int8 1B ...\n",
+       "    ice_area             (time, y, x) float32 355MB ...\n",
+       "    delta_h              (time, y, x) float32 355MB ...\n",
+       "    delta_h_sigma        (time, y, x) float32 355MB ...\n",
+       "    data_count           (time, y, x) float32 355MB ...\n",
+       "    misfit_rms           (time, y, x) float32 355MB ...\n",
+       "    misfit_scaled_rms    (time, y, x) float32 355MB ...\n",
+       "Attributes:\n",
+       "    description:  delta_h group includes variables describing height differen...
" + ], + "text/plain": [ + " Size: 2GB\n", + "Dimensions: (x: 1541, y: 2741, time: 21)\n", + "Coordinates:\n", + " * x (x) float64 12kB -6.7e+05 -6.69e+05 ... 8.7e+05\n", + " * y (y) float64 22kB -3.35e+06 -3.349e+06 ... -6.1e+05\n", + " * time (time) datetime64[ns] 168B 2019-01-01T06:00:00 ... 2...\n", + "Data variables:\n", + " Polar_Stereographic int8 1B ...\n", + " ice_area (time, y, x) float32 355MB ...\n", + " delta_h (time, y, x) float32 355MB ...\n", + " delta_h_sigma (time, y, x) float32 355MB ...\n", + " data_count (time, y, x) float32 355MB ...\n", + " misfit_rms (time, y, x) float32 355MB ...\n", + " misfit_scaled_rms (time, y, x) float32 355MB ...\n", + "Attributes:\n", + " description: delta_h group includes variables describing height differen..." + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Open ATL15 Greenland data granule into an xarray dataset\n", + "ATL15_ds = xr.open_dataset(files[19], group='delta_h')\n", + "\n", + "# View file structure and metadata of dataset\n", + "ATL15_ds" + ] + }, + { + "cell_type": "markdown", + "id": "cdc95e10-c127-4c43-b2a4-3d5afc403438", + "metadata": {}, + "source": [ + "## Define functions" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "6152d821-5500-41f3-9c24-a6aa222a52a5", + "metadata": { + "jupyter": { + "source_hidden": true + } + }, + "outputs": [], + "source": [ + "def linear_trend(y, time):\n", + " \"\"\"\n", + " Computes the linear trend (slope) of a time series using linear regression.\n", + " \n", + " Parameters:\n", + " -----------\n", + " y : array-like\n", + " The dependent variable (e.g., data values) for which the trend is to be computed. \n", + " This is typically a 1D array or list of observations over time.\n", + " \n", + " time : array-like\n", + " The independent variable (e.g., time points). This should be a 1D array of time values \n", + " corresponding to the `y` values. It is expected that `time` and `y` have the same length.\n", + " \n", + " Returns:\n", + " --------\n", + " slope : float\n", + " The slope of the linear trend. If there is not enough data or all values are NaN, \n", + " the function returns `np.nan`.\n", + " \n", + " Description:\n", + " ------------\n", + " This function computes the slope of the linear regression line that fits the given data \n", + " points `(time, y)`. It ignores any `NaN` values in `y` and performs the regression only \n", + " on valid data points. If there are fewer than two valid data points, the function returns `np.nan`.\n", + " \n", + " Example:\n", + " --------\n", + " >>> y = [2.0, 3.1, 4.2, 5.4, np.nan, 6.8]\n", + " >>> time = [0, 1, 2, 3, 4, 5]\n", + " >>> linear_trend(y, time)\n", + " 1.22 # Slope of the linear trend\n", + " \n", + " \"\"\"\n", + " # Create a mask that is True for finite (non-NaN) values in y, and False for NaN values\n", + " mask = np.isfinite(y)\n", + " \n", + " # If there are fewer than two valid data points, return NaN because we can't fit a line\n", + " if np.sum(mask) < 2: # Not enough valid data points to compute a trend\n", + " return np.nan\n", + " \n", + " # Perform a linear fit (regression) on the valid data points (ignoring NaNs)\n", + " # np.polyfit returns the slope and intercept, [0] extracts the slope\n", + " return np.polyfit(time[mask], y[mask], 1)[0] # Return the slope of the fitted line" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "da801b16-0256-47db-99fb-1d4b459e3763", + "metadata": { + "jupyter": { + "source_hidden": true + } + }, + "outputs": [], + "source": [ + "def plot_timeseries_stat(timeseries_stat_da, cmap_extent_abs_value, clb_label, scale_bar_len):\n", + " \"\"\"\n", + " Plots a timeseries statistic using a diverging colormap and displays a colorbar.\n", + " \n", + " Parameters:\n", + " -----------\n", + " timeseries_stat_da : xarray.DataArray\n", + " The data array containing the timeseries statistic to be plotted.\n", + " \n", + " cmap_extent_abs_value : float\n", + " This value is used to control the minimum/maximum value in the colormap to avoid extreme outliers\n", + " and have a symmetric colorbar.\n", + " \n", + " clb_label : str\n", + " The label for the colorbar. This should describe what the color scale represents.\n", + "\n", + " scale_bar_len: float\n", + " Length of the displayed scale bar in km.\n", + " \n", + " Returns:\n", + " --------\n", + " None\n", + " Displays a plot of the data with a colorbar.\n", + " \n", + " Description:\n", + " ------------\n", + " This function visualizes a 2D timeseries statistic using a diverging colormap \n", + " (Red-Blue). It computes the maximum value based on the provided percentile to \n", + " handle outliers and centers the colormap around zero for balance between \n", + " positive and negative values. It also adds a horizontal colorbar below the \n", + " plot, labels it, and hides axis tick marks and labels for a cleaner presentation.\n", + " \"\"\"\n", + " # Create a figure and axis with a specific size for the plot\n", + " fig, ax = plt.subplots(figsize=(10, 10))\n", + "\n", + " # Set the background of the plot area to grey\n", + " ax.set_facecolor('grey') # This changes the color inside the plot area\n", + "\n", + " # Customize the border around the plot\n", + " for spine in ax.spines.values():\n", + " spine.set_edgecolor('black') # Set border color to black\n", + " spine.set_linewidth(2) # Set the width of the border to 2 (thicker)\n", + "\n", + " # Get the minimum and maximum values of the x and y dimensions\n", + " # These values will be used to set the extent of the plot\n", + " x_min = timeseries_stat_da.x.min()\n", + " x_max = timeseries_stat_da.x.max()\n", + " y_min = timeseries_stat_da.y.min()\n", + " y_max = timeseries_stat_da.y.max()\n", + "\n", + " # Create a diverging normalization for the color scale\n", + " # This centers the color scale at 0, which is useful for visualizing differences\n", + " divnorm = mpl_colors.TwoSlopeNorm(vcenter=0.)\n", + "\n", + " # Create the normalization for the color scale, centered at 0\n", + " norm = mpl_colors.TwoSlopeNorm(vmin=-cmap_extent_abs_value, vcenter=0, vmax=cmap_extent_abs_value)\n", + "\n", + " # Plot the data array using imshow\n", + " # - extent sets the range of the x and y axes\n", + " # - cmap sets the color scheme (RdBu is red to blue for diverging data)\n", + " # - norm applies the normalization we defined above\n", + " # - origin='lower' makes sure the plot is oriented correctly\n", + " m = ax.imshow(timeseries_stat_da, \n", + " extent=[x_min, x_max, y_min, y_max],\n", + " cmap='RdBu', norm=norm,\n", + " origin='lower')\n", + "\n", + " # Set the limits for the x and y axes using the min and max values we got earlier\n", + " ax.set(xlim=(x_min, x_max), ylim=(y_min, y_max))\n", + "\n", + " # Remove the tick marks and labels on both the x and y axes to clean up the plot\n", + " ax.tick_params(left=False, right=False, top=False, bottom=False) # Hide tick marks\n", + " ax.set_xticklabels([]) # Remove labels on the x-axis\n", + " ax.set_yticklabels([]) # Remove labels on the y-axis\n", + "\n", + " # Add a colorbar below the plot to show the color scale for the data\n", + " # - divider is used to add the colorbar below the plot (bottom) with a specific size and padding\n", + " divider = make_axes_locatable(ax)\n", + " cax = divider.append_axes('bottom', size='2.5%', pad=0.2)\n", + " \n", + " # Add the colorbar to the plot and extend it both ways to indicate out-of-range values\n", + " # - extend='both' adds arrowheads to the colorbar to show that values extend beyond the range\n", + " # - orientation='horizontal' places the colorbar below the plot\n", + " cbar = fig.colorbar(m, cax=cax, extend='both', orientation='horizontal')\n", + " cbar.set_label(clb_label) # Add a label to the colorbar for clarity\n", + "\n", + " # Add a label to the colorbar\n", + " cbar.set_label(clb_label, fontsize=16) # Adjust the fontsize of the colorbar label\n", + " \n", + " # Adjust the fontsize of the colorbar tick labels\n", + " cbar.ax.tick_params(labelsize=14) # Adjust the fontsize of the colorbar ticks\n", + "\n", + " # Add a scale bar (e.g., for 100 km)\n", + " scalebar = AnchoredSizeBar(ax.transData,\n", + " scale_bar_len*1e3, # Length of the scale bar in km\n", + " '{} km'.format(scale_bar_len), # Label for the scale bar\n", + " loc='lower right', # Location on the plot\n", + " pad=0.5,\n", + " color='black',\n", + " frameon=False,\n", + " size_vertical=1,\n", + " fontproperties=fm.FontProperties(size=14)) # Font size for the label\n", + "\n", + " ax.add_artist(scalebar) # Add the scale bar to the axis\n", + "\n", + " # Show the plot on the screen\n", + " plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "547a887a-e4bf-429b-95b2-97c743f888d4", + "metadata": { + "jupyter": { + "source_hidden": true + } + }, + "outputs": [], + "source": [ + "def fractional_year_rounded(date):\n", + " \"\"\"\n", + " Converts a given date to a fractional year and rounds it to the nearest 0.25 increment.\n", + "\n", + " Parameters:\n", + " -----------\n", + " date : numpy.datetime64, pandas.Timestamp, or similar\n", + " The input date to be converted to a fractional year. It can be provided as a \n", + " numpy datetime64 object or any object convertible to a pandas datetime.\n", + " \n", + " Returns:\n", + " --------\n", + " rounded_fractional_year : float\n", + " The fractional year, rounded to the nearest quarter (0.25) year. The fractional year\n", + " represents the year plus the fraction of the year that has passed based on the day of the year.\n", + " \n", + " Description:\n", + " ------------\n", + " This function calculates the fractional part of the year based on how many days have passed \n", + " in the year (accounting for leap years if applicable). It then rounds the result to the \n", + " nearest 0.25 increment, representing the year in quarters.\n", + " \n", + " Example:\n", + " --------\n", + " >>> fractional_year_rounded(np.datetime64('2022-03-15'))\n", + " 2022.25\n", + " >>> fractional_year_rounded(pd.Timestamp('2022-11-20'))\n", + " 2022.75\n", + " \"\"\"\n", + " # Convert to pandas datetime to easily extract year and day information\n", + " date = pd.to_datetime(date.astype('datetime64[D]'))\n", + " \n", + " # Get the year and day of year\n", + " year = date.year\n", + " day_of_year = date.dayofyear\n", + " \n", + " # Determine if it's a leap year\n", + " days_in_year = 366 if pd.Timestamp(year, 12, 31).is_leap_year else 365\n", + " \n", + " # Compute the fractional year\n", + " fractional_year = year + (day_of_year / days_in_year)\n", + " \n", + " # Round to the nearest .25 increment\n", + " rounded_fractional_year = np.round(fractional_year * 4) / 4\n", + " \n", + " return rounded_fractional_year" + ] + }, + { + "cell_type": "markdown", + "id": "ad6b39fb-d075-4d35-8ac7-1a2a90caa32a", + "metadata": {}, + "source": [ + "## Greenland Ice Sheet dh/dt\n", + "\n", + "This code will take a few minutes to run." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "8999000b-434d-43c7-9a8a-7dcb9f43f152", + "metadata": {}, + "outputs": [], + "source": [ + "# Extract the time values from the DataArray's time coordinate\n", + "time = ATL15_ds['delta_h']['time'].values\n", + "\n", + "# Convert the time values from datetime64 to a numerical format (e.g., number of days since the first time point)\n", + "time_numeric = pd.to_datetime(time)\n", + "time_numeric = (time_numeric - time_numeric[0]) / pd.Timedelta(days=365.25) # Time in years\n", + "\n", + "# Apply the linear trend function over the time dimension\n", + "dhdt_trend = xr.apply_ufunc(\n", + " linear_trend, # The function to apply\n", + " ATL15_ds['delta_h'], # The DataArray on which to apply the function\n", + " input_core_dims=[['time']], # The core dimension for the input (time axis of the DataArray)\n", + " kwargs={'time': time_numeric}, # Pass 'time_numeric' as a keyword argument (numeric time values)\n", + " vectorize=True, # Vectorize the function (apply it element-wise)\n", + " dask=\"parallelized\", # If using Dask for larger datasets\n", + " output_dtypes=[float] # Output type (trend slope is a float)\n", + ")\n", + "\n", + "# Now 'dhdt_trend' contains the dh/dt linear trend for each pixel\n", + "# Name dataarray to reflect this\n", + "dhdt_trend.name = 'annual_dhdt_trend'" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "64237542-f539-4a9d-8c22-220adeb5a3f1", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Get the start and end dates for ATL15 dataset\n", + "start_date = ATL15_ds.time[0].values\n", + "end_date = ATL15_ds.time[-1].values\n", + "\n", + "# Compute fractional years for both dates\n", + "start_fractional_year = fractional_year_rounded(start_date)\n", + "end_fractional_year = fractional_year_rounded(end_date)\n", + "\n", + "# Combine the two dates with a hyphen\n", + "date_range = f\"{start_fractional_year}-{end_fractional_year}\"\n", + "\n", + "# Use function to plot dhdt_trend\n", + "plot_timeseries_stat(dhdt_trend, 1., 'dh/dt [m/yr]\\n'+date_range, 100)" + ] + }, + { + "cell_type": "markdown", + "id": "f0b0b047-deec-423a-bef3-774d4c42a34d", + "metadata": {}, + "source": [ + "## Antarctica Ice Sheet ATL15 pre-processing\n", + "\n", + "ATL15 data covering Antarctica requires an additional step of preprocessing because the data are served separately in four quadrants (A1, A2, A3, and A4), which are the cartesian quadrantes in polar stereographic coordinates about the geographic south pole. So in order to make a continental-scale plot of ATL15, we first need to stitch these individual data files together.\n", + "\n", + "(from ATL15 dataset user guide ([Smith and others, 2024](https://doi.org/10.5067/ATLAS/ATL15.004))):\n", + "![ICESat-2 ATL15 regions](images/Smith_2024_fig1.png)" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "84ef2616-944b-44fe-9861-0e3d102bdfa7", + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "7d2af36238d54bbba61b9b241936e477", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "QUEUEING TASKS | : 0%| | 0/16 [00:00,\n", + " ,\n", + " ,\n", + " ,\n", + " ,\n", + " ,\n", + " ,\n", + " ,\n", + " ,\n", + " ,\n", + " ,\n", + " ,\n", + " ,\n", + " ,\n", + " ,\n", + " ]" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Find ICESat-2 ATL15 version four data granules in the southern hemisphere\n", + "results = earthaccess.search_data(\n", + " doi='10.5067/ATLAS/ATL15.004',\n", + " bounding_box=(180, -90, -180, -60), # (lower_left_lon, lower_left_lat , upper_right_lon, upper_right_lat))\n", + " cloud_hosted=True,\n", + ")\n", + "\n", + "# Open data granules as s3 files to stream\n", + "files = earthaccess.open(results)\n", + "files" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "59faa820-f5ab-4119-80e1-2149e1e63e46", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "\n", + "\n", + "\n" + ] + } + ], + "source": [ + "# We first index the data files we wish to open\n", + "print(files[11])\n", + "print(files[0])\n", + "print(files[1])\n", + "print(files[-3])" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "b530c204-3d58-44d7-89ae-b6e32069a379", + "metadata": {}, + "outputs": [], + "source": [ + "# Open each file\n", + "ATL15_A1 = xr.open_dataset(files[11], group='delta_h')\n", + "ATL15_A2 = xr.open_dataset(files[0], group='delta_h')\n", + "ATL15_A3 = xr.open_dataset(files[1], group='delta_h')\n", + "ATL15_A4 = xr.open_dataset(files[-3], group='delta_h')" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "29a101cf-31a2-4ddd-a465-e10b19ee92df", + "metadata": {}, + "outputs": [], + "source": [ + "# We will drop unneeded variables to conserve memory\n", + "\n", + "# Specify the variables to keep\n", + "variables_to_keep = ['time', 'y', 'x', 'delta_h']\n", + "\n", + "# List of xarray datasets\n", + "datasets = [ATL15_A1, ATL15_A2, ATL15_A3, ATL15_A4]\n", + "\n", + "# Function to drop variables not in variables_to_keep from a dataset\n", + "def drop_unwanted_variables(dataset):\n", + " variables_to_drop = [var for var in dataset.variables if var not in variables_to_keep]\n", + " return dataset.drop_vars(variables_to_drop)\n", + "\n", + "# Apply the function to each dataset\n", + "ATL15_A1, ATL15_A2, ATL15_A3, ATL15_A4 = [drop_unwanted_variables(ds) for ds in datasets]" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "e78a9e63-a5cb-4ca2-9f2c-4a1d30d5e9fa", + "metadata": {}, + "outputs": [], + "source": [ + "# Use xarray concatenation to stitch two quadrants together \n", + "# Use xarray index selecting to occlude the duplicated x=0 vector of data\n", + "ATL15_A12 = xr.concat([ATL15_A2.isel(x=slice(0,-1)), ATL15_A1], dim=\"x\")" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "b5f7458d-61d6-41a4-8aa9-f5de60b4da65", + "metadata": {}, + "outputs": [], + "source": [ + "# Use xarray concatenation to stitch two quadrants togethers\n", + "# Use xarray index selecting to occlude the duplicated x=0 vector of data\n", + "ATL15_A34 = xr.concat([ATL15_A3.isel(x=slice(0,-1)), ATL15_A4], dim='x')" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "66d7db89-9d7f-48b3-bb66-b6284aea3a85", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "# Use xarray concatenation to stitch two-quadrant concatenated halves togethers\n", + "# Use xarray index selecting to occlude the duplicated y=0 vector of data\n", + "ATL15_ds = xr.concat([ATL15_A34.isel(y=slice(0,-1)), ATL15_A12], dim='y')" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "id": "3857c852-7c1c-426e-92d0-7809fac9964b", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "# Delete unneeded dataarrays and datasets to reduce memory consumption\n", + "del ATL15_A1, ATL15_A12, ATL15_A2, ATL15_A3, ATL15_A34, ATL15_A4" + ] + }, + { + "cell_type": "markdown", + "id": "95410b3d-96dc-47d7-a419-ec685b69d0d1", + "metadata": {}, + "source": [ + "### Antarctic Ice Sheet dh/dt\n", + "\n", + "The following code does continental-scale calculations of dh/dt and takes 20-30 minutes to run." + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "id": "d6fd1d52-1022-4032-8cdf-283b21b9945d", + "metadata": {}, + "outputs": [], + "source": [ + "# Extract the time values from the DataArray's time coordinate\n", + "time = ATL15_ds['delta_h']['time'].values\n", + "\n", + "# Convert the time values from datetime64 to a numerical format (e.g., number of days since the first time point)\n", + "time_numeric = pd.to_datetime(time)\n", + "time_numeric = (time_numeric - time_numeric[0]) / pd.Timedelta(days=365.25) # Time in years\n", + "\n", + "# Apply the linear trend function over the time dimension\n", + "dhdt_trend_2 = xr.apply_ufunc(\n", + " linear_trend, # The function to apply\n", + " ATL15_ds['delta_h'], # The DataArray on which to apply the function\n", + " input_core_dims=[['time']], # The core dimension for the input (time axis of the DataArray)\n", + " kwargs={'time': time_numeric}, # Pass 'time_numeric' as a keyword argument (numeric time values)\n", + " vectorize=True, # Vectorize the function (apply it element-wise)\n", + " dask=\"parallelized\", # If using Dask for larger datasets\n", + " output_dtypes=[float] # Output type (trend slope is a float)\n", + ")\n", + "\n", + "# Now 'dhdt_trend' contains the dh/dt linear trend for each pixel\n", + "# Name dataarray to reflect this\n", + "dhdt_trend_2.name = 'annual_dhdt_trend'" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "id": "5bf5bebd-b603-45b8-a7cb-840acb57a517", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Get the start and end dates for ATL15 dataset\n", + "start_date = ATL15_ds.time[0].values\n", + "end_date = ATL15_ds.time[-1].values\n", + "\n", + "# Compute fractional years for both dates\n", + "start_fractional_year = fractional_year_rounded(start_date)\n", + "end_fractional_year = fractional_year_rounded(end_date)\n", + "\n", + "# Combine the two dates with a hyphen\n", + "date_range = f\"{start_fractional_year} to {end_fractional_year}\"\n", + "\n", + "plot_timeseries_stat(dhdt_trend_2, 1., 'dh/dt [m/yr]\\n'+date_range, 1000)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "21c7a74a-9722-4031-b929-f18d223fcb0c", + "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.11.9" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/book/tutorials/ICESat2_ATL15_dhdt/images/Smith_2019_fig1.png b/book/tutorials/ICESat2_ATL15_dhdt/images/Smith_2019_fig1.png new file mode 100644 index 0000000..98ea05b Binary files /dev/null and b/book/tutorials/ICESat2_ATL15_dhdt/images/Smith_2019_fig1.png differ diff --git a/book/tutorials/ICESat2_ATL15_dhdt/images/Smith_2024_fig1.png b/book/tutorials/ICESat2_ATL15_dhdt/images/Smith_2024_fig1.png new file mode 100644 index 0000000..befae66 Binary files /dev/null and b/book/tutorials/ICESat2_ATL15_dhdt/images/Smith_2024_fig1.png differ diff --git a/book/tutorials/IS2_ATL15_surface_height_anomalies/IS2_ATL15_surface_height_anomalies.ipynb b/book/tutorials/IS2_ATL15_surface_height_anomalies/IS2_ATL15_surface_height_anomalies.ipynb index 58cc990..b55ad1a 100644 --- a/book/tutorials/IS2_ATL15_surface_height_anomalies/IS2_ATL15_surface_height_anomalies.ipynb +++ b/book/tutorials/IS2_ATL15_surface_height_anomalies/IS2_ATL15_surface_height_anomalies.ipynb @@ -49,1261 +49,27 @@ }, { "cell_type": "code", - "execution_count": 1, - "id": "b7f8503a-df4b-42db-9ca5-17848b5673ea", - "metadata": { - "collapsed": true, - "jupyter": { - "outputs_hidden": true - }, - "tags": [] - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Requirement already satisfied: icepyx==1.0.0 in /srv/conda/envs/notebook/lib/python3.10/site-packages (1.0.0)\n", - "Requirement already satisfied: h5py in /srv/conda/envs/notebook/lib/python3.10/site-packages (from icepyx==1.0.0) (3.9.0)\n", - "Requirement already satisfied: fiona in /srv/conda/envs/notebook/lib/python3.10/site-packages (from icepyx==1.0.0) (1.9.4)\n", - "Requirement already satisfied: datashader in /srv/conda/envs/notebook/lib/python3.10/site-packages (from icepyx==1.0.0) (0.16.0)\n", - "Requirement already satisfied: shapely in /srv/conda/envs/notebook/lib/python3.10/site-packages (from icepyx==1.0.0) (2.0.1)\n", - "Requirement already satisfied: geopandas in /srv/conda/envs/notebook/lib/python3.10/site-packages (from icepyx==1.0.0) (0.13.2)\n", - "Requirement already satisfied: s3fs in /srv/conda/envs/notebook/lib/python3.10/site-packages (from icepyx==1.0.0) (2023.6.0)\n", - "Requirement already satisfied: xarray in /srv/conda/envs/notebook/lib/python3.10/site-packages (from icepyx==1.0.0) (2023.12.0)\n", - "Requirement already satisfied: earthaccess>=0.5.1 in /srv/conda/envs/notebook/lib/python3.10/site-packages (from icepyx==1.0.0) (0.8.2)\n", - "Requirement already satisfied: matplotlib in /srv/conda/envs/notebook/lib/python3.10/site-packages (from icepyx==1.0.0) (3.8.2)\n", - "Requirement already satisfied: requests in /srv/conda/envs/notebook/lib/python3.10/site-packages (from icepyx==1.0.0) (2.31.0)\n", - "Requirement already satisfied: holoviews in /srv/conda/envs/notebook/lib/python3.10/site-packages (from icepyx==1.0.0) (1.18.1)\n", - "Requirement already satisfied: numpy in /srv/conda/envs/notebook/lib/python3.10/site-packages (from icepyx==1.0.0) (1.23.5)\n", - "Requirement already satisfied: h5netcdf in /srv/conda/envs/notebook/lib/python3.10/site-packages (from icepyx==1.0.0) (1.1.0)\n", - "Requirement already satisfied: backoff in /srv/conda/envs/notebook/lib/python3.10/site-packages (from icepyx==1.0.0) (2.2.1)\n", - "Requirement already satisfied: hvplot in /srv/conda/envs/notebook/lib/python3.10/site-packages (from icepyx==1.0.0) (0.8.4)\n", - "Requirement already satisfied: tinynetrc<2.0.0,>=1.3.1 in /srv/conda/envs/notebook/lib/python3.10/site-packages (from earthaccess>=0.5.1->icepyx==1.0.0) (1.3.1)\n", - "Requirement already satisfied: pqdm>=0.1 in /srv/conda/envs/notebook/lib/python3.10/site-packages (from earthaccess>=0.5.1->icepyx==1.0.0) (0.2.0)\n", - "Requirement already satisfied: multimethod>=1.8 in /srv/conda/envs/notebook/lib/python3.10/site-packages (from earthaccess>=0.5.1->icepyx==1.0.0) (1.9.1)\n", - "Requirement already satisfied: python-dateutil>=2.8.2 in /srv/conda/envs/notebook/lib/python3.10/site-packages (from earthaccess>=0.5.1->icepyx==1.0.0) (2.8.2)\n", - "Requirement already satisfied: fsspec>=2022.11 in /srv/conda/envs/notebook/lib/python3.10/site-packages (from earthaccess>=0.5.1->icepyx==1.0.0) (2023.6.0)\n", - "Requirement already satisfied: python-cmr>=0.9.0 in /srv/conda/envs/notebook/lib/python3.10/site-packages (from earthaccess>=0.5.1->icepyx==1.0.0) (0.9.0)\n", - "Requirement already satisfied: certifi>=2017.4.17 in /srv/conda/envs/notebook/lib/python3.10/site-packages (from requests->icepyx==1.0.0) (2023.7.22)\n", - "Requirement already satisfied: urllib3<3,>=1.21.1 in /srv/conda/envs/notebook/lib/python3.10/site-packages (from requests->icepyx==1.0.0) (1.26.18)\n", - "Requirement already satisfied: idna<4,>=2.5 in /srv/conda/envs/notebook/lib/python3.10/site-packages (from requests->icepyx==1.0.0) (3.4)\n", - "Requirement already satisfied: charset-normalizer<4,>=2 in /srv/conda/envs/notebook/lib/python3.10/site-packages (from requests->icepyx==1.0.0) (3.3.0)\n", - "Requirement already satisfied: aiohttp!=4.0.0a0,!=4.0.0a1 in /srv/conda/envs/notebook/lib/python3.10/site-packages (from s3fs->icepyx==1.0.0) (3.9.1)\n", - "Requirement already satisfied: aiobotocore~=2.5.0 in /srv/conda/envs/notebook/lib/python3.10/site-packages (from s3fs->icepyx==1.0.0) (2.5.0)\n", - "Requirement already satisfied: numba in /srv/conda/envs/notebook/lib/python3.10/site-packages (from datashader->icepyx==1.0.0) (0.56.4)\n", - "Requirement already satisfied: pillow in /srv/conda/envs/notebook/lib/python3.10/site-packages (from datashader->icepyx==1.0.0) (9.5.0)\n", - "Requirement already satisfied: multipledispatch in /srv/conda/envs/notebook/lib/python3.10/site-packages (from datashader->icepyx==1.0.0) (0.6.0)\n", - "Requirement already satisfied: scipy in /srv/conda/envs/notebook/lib/python3.10/site-packages (from datashader->icepyx==1.0.0) (1.9.3)\n", - "Requirement already satisfied: colorcet in /srv/conda/envs/notebook/lib/python3.10/site-packages (from datashader->icepyx==1.0.0) (3.0.1)\n", - "Requirement already satisfied: toolz in /srv/conda/envs/notebook/lib/python3.10/site-packages (from datashader->icepyx==1.0.0) (0.12.0)\n", - "Requirement already satisfied: pyct in /srv/conda/envs/notebook/lib/python3.10/site-packages (from datashader->icepyx==1.0.0) (0.5.0)\n", - "Requirement already satisfied: dask in /srv/conda/envs/notebook/lib/python3.10/site-packages (from datashader->icepyx==1.0.0) (2022.11.0)\n", - "Requirement already satisfied: param in /srv/conda/envs/notebook/lib/python3.10/site-packages (from datashader->icepyx==1.0.0) (1.13.0)\n", - "Requirement already satisfied: pandas in /srv/conda/envs/notebook/lib/python3.10/site-packages (from datashader->icepyx==1.0.0) (1.5.1)\n", - "Requirement already satisfied: click~=8.0 in /srv/conda/envs/notebook/lib/python3.10/site-packages (from fiona->icepyx==1.0.0) (8.1.7)\n", - "Requirement already satisfied: cligj>=0.5 in /srv/conda/envs/notebook/lib/python3.10/site-packages (from fiona->icepyx==1.0.0) (0.7.2)\n", - "Requirement already satisfied: click-plugins>=1.0 in /srv/conda/envs/notebook/lib/python3.10/site-packages (from fiona->icepyx==1.0.0) (1.1.1)\n", - "Requirement already satisfied: six in /srv/conda/envs/notebook/lib/python3.10/site-packages (from fiona->icepyx==1.0.0) (1.16.0)\n", - "Requirement already satisfied: attrs>=19.2.0 in /srv/conda/envs/notebook/lib/python3.10/site-packages (from fiona->icepyx==1.0.0) (23.1.0)\n", - "Requirement already satisfied: packaging in /srv/conda/envs/notebook/lib/python3.10/site-packages (from geopandas->icepyx==1.0.0) (23.2)\n", - "Requirement already satisfied: pyproj>=3.0.1 in /srv/conda/envs/notebook/lib/python3.10/site-packages (from geopandas->icepyx==1.0.0) (3.6.1)\n", - "Requirement already satisfied: pyviz-comms>=0.7.4 in /srv/conda/envs/notebook/lib/python3.10/site-packages (from holoviews->icepyx==1.0.0) (2.3.2)\n", - "Requirement already satisfied: panel>=1.0 in /srv/conda/envs/notebook/lib/python3.10/site-packages (from holoviews->icepyx==1.0.0) (1.2.3)\n", - "Requirement already satisfied: bokeh>=1.0.0 in /srv/conda/envs/notebook/lib/python3.10/site-packages (from hvplot->icepyx==1.0.0) (3.2.2)\n", - "Requirement already satisfied: pyparsing>=2.3.1 in /srv/conda/envs/notebook/lib/python3.10/site-packages (from matplotlib->icepyx==1.0.0) (3.1.1)\n", - "Requirement already satisfied: contourpy>=1.0.1 in /srv/conda/envs/notebook/lib/python3.10/site-packages (from matplotlib->icepyx==1.0.0) (1.2.0)\n", - "Requirement already satisfied: cycler>=0.10 in /srv/conda/envs/notebook/lib/python3.10/site-packages (from matplotlib->icepyx==1.0.0) (0.12.1)\n", - "Requirement already satisfied: kiwisolver>=1.3.1 in /srv/conda/envs/notebook/lib/python3.10/site-packages (from matplotlib->icepyx==1.0.0) (1.4.5)\n", - "Requirement already satisfied: fonttools>=4.22.0 in /srv/conda/envs/notebook/lib/python3.10/site-packages (from matplotlib->icepyx==1.0.0) (4.46.0)\n", - "Requirement already satisfied: aioitertools>=0.5.1 in /srv/conda/envs/notebook/lib/python3.10/site-packages (from aiobotocore~=2.5.0->s3fs->icepyx==1.0.0) (0.11.0)\n", - "Requirement already satisfied: botocore<1.29.77,>=1.29.76 in /srv/conda/envs/notebook/lib/python3.10/site-packages (from aiobotocore~=2.5.0->s3fs->icepyx==1.0.0) (1.29.76)\n", - "Requirement already satisfied: wrapt>=1.10.10 in /srv/conda/envs/notebook/lib/python3.10/site-packages (from aiobotocore~=2.5.0->s3fs->icepyx==1.0.0) (1.16.0)\n", - "Requirement already satisfied: async-timeout<5.0,>=4.0 in /srv/conda/envs/notebook/lib/python3.10/site-packages (from aiohttp!=4.0.0a0,!=4.0.0a1->s3fs->icepyx==1.0.0) (4.0.3)\n", - "Requirement already satisfied: yarl<2.0,>=1.0 in /srv/conda/envs/notebook/lib/python3.10/site-packages (from aiohttp!=4.0.0a0,!=4.0.0a1->s3fs->icepyx==1.0.0) (1.9.3)\n", - "Requirement already satisfied: frozenlist>=1.1.1 in /srv/conda/envs/notebook/lib/python3.10/site-packages (from aiohttp!=4.0.0a0,!=4.0.0a1->s3fs->icepyx==1.0.0) (1.4.0)\n", - "Requirement already satisfied: aiosignal>=1.1.2 in /srv/conda/envs/notebook/lib/python3.10/site-packages (from aiohttp!=4.0.0a0,!=4.0.0a1->s3fs->icepyx==1.0.0) (1.3.1)\n", - "Requirement already satisfied: multidict<7.0,>=4.5 in /srv/conda/envs/notebook/lib/python3.10/site-packages (from aiohttp!=4.0.0a0,!=4.0.0a1->s3fs->icepyx==1.0.0) (6.0.4)\n", - "Requirement already satisfied: PyYAML>=3.10 in /srv/conda/envs/notebook/lib/python3.10/site-packages (from bokeh>=1.0.0->hvplot->icepyx==1.0.0) (5.4.1)\n", - "Requirement already satisfied: Jinja2>=2.9 in /srv/conda/envs/notebook/lib/python3.10/site-packages (from bokeh>=1.0.0->hvplot->icepyx==1.0.0) (3.1.2)\n", - "Requirement already satisfied: xyzservices>=2021.09.1 in /srv/conda/envs/notebook/lib/python3.10/site-packages (from bokeh>=1.0.0->hvplot->icepyx==1.0.0) (2023.10.1)\n", - "Requirement already satisfied: tornado>=5.1 in /srv/conda/envs/notebook/lib/python3.10/site-packages (from bokeh>=1.0.0->hvplot->icepyx==1.0.0) (6.1)\n", - "Requirement already satisfied: pytz>=2020.1 in /srv/conda/envs/notebook/lib/python3.10/site-packages (from pandas->datashader->icepyx==1.0.0) (2023.3.post1)\n", - "Requirement already satisfied: mdit-py-plugins in /srv/conda/envs/notebook/lib/python3.10/site-packages (from panel>=1.0->holoviews->icepyx==1.0.0) (0.4.0)\n", - "Requirement already satisfied: typing-extensions in /srv/conda/envs/notebook/lib/python3.10/site-packages (from panel>=1.0->holoviews->icepyx==1.0.0) (4.8.0)\n", - "Requirement already satisfied: tqdm>=4.48.0 in /srv/conda/envs/notebook/lib/python3.10/site-packages (from panel>=1.0->holoviews->icepyx==1.0.0) (4.64.1)\n", - "Requirement already satisfied: linkify-it-py in /srv/conda/envs/notebook/lib/python3.10/site-packages (from panel>=1.0->holoviews->icepyx==1.0.0) (2.0.0)\n", - "Requirement already satisfied: bleach in /srv/conda/envs/notebook/lib/python3.10/site-packages (from panel>=1.0->holoviews->icepyx==1.0.0) (6.1.0)\n", - "Requirement already satisfied: markdown-it-py in /srv/conda/envs/notebook/lib/python3.10/site-packages (from panel>=1.0->holoviews->icepyx==1.0.0) (2.2.0)\n", - "Requirement already satisfied: markdown in /srv/conda/envs/notebook/lib/python3.10/site-packages (from panel>=1.0->holoviews->icepyx==1.0.0) (3.5.1)\n", - "Requirement already satisfied: bounded-pool-executor in /srv/conda/envs/notebook/lib/python3.10/site-packages (from pqdm>=0.1->earthaccess>=0.5.1->icepyx==1.0.0) (0.0.3)\n", - "Requirement already satisfied: cloudpickle>=1.1.1 in /srv/conda/envs/notebook/lib/python3.10/site-packages (from dask->datashader->icepyx==1.0.0) (3.0.0)\n", - "Requirement already satisfied: partd>=0.3.10 in /srv/conda/envs/notebook/lib/python3.10/site-packages (from dask->datashader->icepyx==1.0.0) (1.4.1)\n", - "Requirement already satisfied: setuptools in /srv/conda/envs/notebook/lib/python3.10/site-packages (from numba->datashader->icepyx==1.0.0) (68.2.2)\n", - "Requirement already satisfied: llvmlite<0.40,>=0.39.0dev0 in /srv/conda/envs/notebook/lib/python3.10/site-packages (from numba->datashader->icepyx==1.0.0) (0.39.1)\n", - "Requirement already satisfied: jmespath<2.0.0,>=0.7.1 in /srv/conda/envs/notebook/lib/python3.10/site-packages (from botocore<1.29.77,>=1.29.76->aiobotocore~=2.5.0->s3fs->icepyx==1.0.0) (1.0.1)\n", - "Requirement already satisfied: MarkupSafe>=2.0 in /srv/conda/envs/notebook/lib/python3.10/site-packages (from Jinja2>=2.9->bokeh>=1.0.0->hvplot->icepyx==1.0.0) (2.1.3)\n", - "Requirement already satisfied: locket in /srv/conda/envs/notebook/lib/python3.10/site-packages (from partd>=0.3.10->dask->datashader->icepyx==1.0.0) (1.0.0)\n", - "Requirement already satisfied: webencodings in /srv/conda/envs/notebook/lib/python3.10/site-packages (from bleach->panel>=1.0->holoviews->icepyx==1.0.0) (0.5.1)\n", - "Requirement already satisfied: uc-micro-py in /srv/conda/envs/notebook/lib/python3.10/site-packages (from linkify-it-py->panel>=1.0->holoviews->icepyx==1.0.0) (1.0.1)\n", - "Requirement already satisfied: mdurl~=0.1 in /srv/conda/envs/notebook/lib/python3.10/site-packages (from markdown-it-py->panel>=1.0->holoviews->icepyx==1.0.0) (0.1.0)\n", - "Note: you may need to restart the kernel to use updated packages.\n" - ] - } - ], - "source": [ - "%pip install icepyx==1.0.0" - ] - }, - { - "cell_type": "code", - "execution_count": 2, + "execution_count": null, "id": "0e226454-c730-4656-ae88-19297a8a855a", "metadata": { + "scrolled": true, "tags": [] }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Collecting openpyxl\n", - " Downloading openpyxl-3.1.2-py2.py3-none-any.whl (249 kB)\n", - "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m250.0/250.0 kB\u001b[0m \u001b[31m2.9 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m00:01\u001b[0m00:01\u001b[0m\n", - "\u001b[?25hCollecting et-xmlfile\n", - " Downloading et_xmlfile-1.1.0-py3-none-any.whl (4.7 kB)\n", - "Installing collected packages: et-xmlfile, openpyxl\n", - "Successfully installed et-xmlfile-1.1.0 openpyxl-3.1.2\n", - "Note: you may need to restart the kernel to use updated packages.\n" - ] - } - ], + "outputs": [], "source": [ "# Needed for pandas read_excel\n", - "%pip install openpyxl" + "%pip install openpyxl\n", + "%pip install ~/icepyx" ] }, { "cell_type": "code", - "execution_count": 1, + "execution_count": null, "id": "1a2db536-38fa-40b2-b01e-6f2f97881789", "metadata": { "tags": [] }, - "outputs": [ - { - "data": { - "application/javascript": [ - "(function(root) {\n", - " function now() {\n", - " return new Date();\n", - " }\n", - "\n", - " var force = true;\n", - " var py_version = '3.2.2'.replace('rc', '-rc.').replace('.dev', '-dev.');\n", - " var is_dev = py_version.indexOf(\"+\") !== -1 || py_version.indexOf(\"-\") !== -1;\n", - " var reloading = false;\n", - " var Bokeh = root.Bokeh;\n", - " var bokeh_loaded = Bokeh != null && (Bokeh.version === py_version || (Bokeh.versions !== undefined && Bokeh.versions.has(py_version)));\n", - "\n", - " if (typeof (root._bokeh_timeout) === \"undefined\" || force) {\n", - " root._bokeh_timeout = Date.now() + 5000;\n", - " root._bokeh_failed_load = false;\n", - " }\n", - "\n", - " function run_callbacks() {\n", - " try {\n", - " root._bokeh_onload_callbacks.forEach(function(callback) {\n", - " if (callback != null)\n", - " callback();\n", - " });\n", - " } finally {\n", - " delete root._bokeh_onload_callbacks;\n", - " }\n", - " console.debug(\"Bokeh: all callbacks have finished\");\n", - " }\n", - "\n", - " function load_libs(css_urls, js_urls, js_modules, js_exports, callback) {\n", - " if (css_urls == null) css_urls = [];\n", - " if (js_urls == null) js_urls = [];\n", - " if (js_modules == null) js_modules = [];\n", - " if (js_exports == null) js_exports = {};\n", - "\n", - " root._bokeh_onload_callbacks.push(callback);\n", - "\n", - " if (root._bokeh_is_loading > 0) {\n", - " console.debug(\"Bokeh: BokehJS is being loaded, scheduling callback at\", now());\n", - " return null;\n", - " }\n", - " if (js_urls.length === 0 && js_modules.length === 0 && Object.keys(js_exports).length === 0) {\n", - " run_callbacks();\n", - " return null;\n", - " }\n", - " if (!reloading) {\n", - " console.debug(\"Bokeh: BokehJS not loaded, scheduling load and callback at\", now());\n", - " }\n", - "\n", - " function on_load() {\n", - " root._bokeh_is_loading--;\n", - " if (root._bokeh_is_loading === 0) {\n", - " console.debug(\"Bokeh: all BokehJS libraries/stylesheets loaded\");\n", - " run_callbacks()\n", - " }\n", - " }\n", - " window._bokeh_on_load = on_load\n", - "\n", - " function on_error() {\n", - " console.error(\"failed to load \" + url);\n", - " }\n", - "\n", - " var skip = [];\n", - " if (window.requirejs) {\n", - " window.requirejs.config({'packages': {}, 'paths': {'jspanel': 'https://cdn.jsdelivr.net/npm/jspanel4@4.12.0/dist/jspanel', 'jspanel-modal': 'https://cdn.jsdelivr.net/npm/jspanel4@4.12.0/dist/extensions/modal/jspanel.modal', 'jspanel-tooltip': 'https://cdn.jsdelivr.net/npm/jspanel4@4.12.0/dist/extensions/tooltip/jspanel.tooltip', 'jspanel-hint': 'https://cdn.jsdelivr.net/npm/jspanel4@4.12.0/dist/extensions/hint/jspanel.hint', 'jspanel-layout': 'https://cdn.jsdelivr.net/npm/jspanel4@4.12.0/dist/extensions/layout/jspanel.layout', 'jspanel-contextmenu': 'https://cdn.jsdelivr.net/npm/jspanel4@4.12.0/dist/extensions/contextmenu/jspanel.contextmenu', 'jspanel-dock': 'https://cdn.jsdelivr.net/npm/jspanel4@4.12.0/dist/extensions/dock/jspanel.dock', 'gridstack': 'https://cdn.jsdelivr.net/npm/gridstack@7.2.3/dist/gridstack-all', 'notyf': 'https://cdn.jsdelivr.net/npm/notyf@3/notyf.min'}, 'shim': {'jspanel': {'exports': 'jsPanel'}, 'gridstack': {'exports': 'GridStack'}}});\n", - " require([\"jspanel\"], function(jsPanel) {\n", - "\twindow.jsPanel = jsPanel\n", - "\ton_load()\n", - " })\n", - " require([\"jspanel-modal\"], function() {\n", - "\ton_load()\n", - " })\n", - " require([\"jspanel-tooltip\"], function() {\n", - "\ton_load()\n", - " })\n", - " require([\"jspanel-hint\"], function() {\n", - "\ton_load()\n", - " })\n", - " require([\"jspanel-layout\"], function() {\n", - "\ton_load()\n", - " })\n", - " require([\"jspanel-contextmenu\"], function() {\n", - "\ton_load()\n", - " })\n", - " require([\"jspanel-dock\"], function() {\n", - "\ton_load()\n", - " })\n", - " require([\"gridstack\"], function(GridStack) {\n", - "\twindow.GridStack = GridStack\n", - "\ton_load()\n", - " })\n", - " require([\"notyf\"], function() {\n", - "\ton_load()\n", - " })\n", - " root._bokeh_is_loading = css_urls.length + 9;\n", - " } else {\n", - " root._bokeh_is_loading = css_urls.length + js_urls.length + js_modules.length + Object.keys(js_exports).length;\n", - " }\n", - "\n", - " var existing_stylesheets = []\n", - " var links = document.getElementsByTagName('link')\n", - " for (var i = 0; i < links.length; i++) {\n", - " var link = links[i]\n", - " if (link.href != null) {\n", - "\texisting_stylesheets.push(link.href)\n", - " }\n", - " }\n", - " for (var i = 0; i < css_urls.length; i++) {\n", - " var url = css_urls[i];\n", - " if (existing_stylesheets.indexOf(url) !== -1) {\n", - "\ton_load()\n", - "\tcontinue;\n", - " }\n", - " const element = document.createElement(\"link\");\n", - " element.onload = on_load;\n", - " element.onerror = on_error;\n", - " element.rel = \"stylesheet\";\n", - " element.type = \"text/css\";\n", - " element.href = url;\n", - " console.debug(\"Bokeh: injecting link tag for BokehJS stylesheet: \", url);\n", - " document.body.appendChild(element);\n", - " } if (((window['jsPanel'] !== undefined) && (!(window['jsPanel'] instanceof HTMLElement))) || window.requirejs) {\n", - " var urls = ['https://cdn.holoviz.org/panel/1.2.3/dist/bundled/floatpanel/jspanel4@4.12.0/dist/jspanel.js', 'https://cdn.holoviz.org/panel/1.2.3/dist/bundled/floatpanel/jspanel4@4.12.0/dist/extensions/modal/jspanel.modal.js', 'https://cdn.holoviz.org/panel/1.2.3/dist/bundled/floatpanel/jspanel4@4.12.0/dist/extensions/tooltip/jspanel.tooltip.js', 'https://cdn.holoviz.org/panel/1.2.3/dist/bundled/floatpanel/jspanel4@4.12.0/dist/extensions/hint/jspanel.hint.js', 'https://cdn.holoviz.org/panel/1.2.3/dist/bundled/floatpanel/jspanel4@4.12.0/dist/extensions/layout/jspanel.layout.js', 'https://cdn.holoviz.org/panel/1.2.3/dist/bundled/floatpanel/jspanel4@4.12.0/dist/extensions/contextmenu/jspanel.contextmenu.js', 'https://cdn.holoviz.org/panel/1.2.3/dist/bundled/floatpanel/jspanel4@4.12.0/dist/extensions/dock/jspanel.dock.js'];\n", - " for (var i = 0; i < urls.length; i++) {\n", - " skip.push(urls[i])\n", - " }\n", - " } if (((window['GridStack'] !== undefined) && (!(window['GridStack'] instanceof HTMLElement))) || window.requirejs) {\n", - " var urls = ['https://cdn.holoviz.org/panel/1.2.3/dist/bundled/gridstack/gridstack@7.2.3/dist/gridstack-all.js'];\n", - " for (var i = 0; i < urls.length; i++) {\n", - " skip.push(urls[i])\n", - " }\n", - " } if (((window['Notyf'] !== undefined) && (!(window['Notyf'] instanceof HTMLElement))) || window.requirejs) {\n", - " var urls = ['https://cdn.holoviz.org/panel/1.2.3/dist/bundled/notificationarea/notyf@3/notyf.min.js'];\n", - " for (var i = 0; i < urls.length; i++) {\n", - " skip.push(urls[i])\n", - " }\n", - " } var existing_scripts = []\n", - " var scripts = document.getElementsByTagName('script')\n", - " for (var i = 0; i < scripts.length; i++) {\n", - " var script = scripts[i]\n", - " if (script.src != null) {\n", - "\texisting_scripts.push(script.src)\n", - " }\n", - " }\n", - " for (var i = 0; i < js_urls.length; i++) {\n", - " var url = js_urls[i];\n", - " if (skip.indexOf(url) !== -1 || existing_scripts.indexOf(url) !== -1) {\n", - "\tif (!window.requirejs) {\n", - "\t on_load();\n", - "\t}\n", - "\tcontinue;\n", - " }\n", - " var element = document.createElement('script');\n", - " element.onload = on_load;\n", - " element.onerror = on_error;\n", - " element.async = false;\n", - " element.src = url;\n", - " console.debug(\"Bokeh: injecting script tag for BokehJS library: \", url);\n", - " document.head.appendChild(element);\n", - " }\n", - " for (var i = 0; i < js_modules.length; i++) {\n", - " var url = js_modules[i];\n", - " if (skip.indexOf(url) !== -1 || existing_scripts.indexOf(url) !== -1) {\n", - "\tif (!window.requirejs) {\n", - "\t on_load();\n", - "\t}\n", - "\tcontinue;\n", - " }\n", - " var element = document.createElement('script');\n", - " element.onload = on_load;\n", - " element.onerror = on_error;\n", - " element.async = false;\n", - " element.src = url;\n", - " element.type = \"module\";\n", - " console.debug(\"Bokeh: injecting script tag for BokehJS library: \", url);\n", - " document.head.appendChild(element);\n", - " }\n", - " for (const name in js_exports) {\n", - " var url = js_exports[name];\n", - " if (skip.indexOf(url) >= 0 || root[name] != null) {\n", - "\tif (!window.requirejs) {\n", - "\t on_load();\n", - "\t}\n", - "\tcontinue;\n", - " }\n", - " var element = document.createElement('script');\n", - " element.onerror = on_error;\n", - " element.async = false;\n", - " element.type = \"module\";\n", - " console.debug(\"Bokeh: injecting script tag for BokehJS library: \", url);\n", - " element.textContent = `\n", - " import ${name} from \"${url}\"\n", - " window.${name} = ${name}\n", - " window._bokeh_on_load()\n", - " `\n", - " document.head.appendChild(element);\n", - " }\n", - " if (!js_urls.length && !js_modules.length) {\n", - " on_load()\n", - " }\n", - " };\n", - "\n", - " function inject_raw_css(css) {\n", - " const element = document.createElement(\"style\");\n", - " element.appendChild(document.createTextNode(css));\n", - " document.body.appendChild(element);\n", - " }\n", - "\n", - " var js_urls = [\"https://cdn.bokeh.org/bokeh/release/bokeh-3.2.2.min.js\", \"https://cdn.bokeh.org/bokeh/release/bokeh-gl-3.2.2.min.js\", \"https://cdn.bokeh.org/bokeh/release/bokeh-widgets-3.2.2.min.js\", \"https://cdn.bokeh.org/bokeh/release/bokeh-tables-3.2.2.min.js\", \"https://cdn.holoviz.org/panel/1.2.3/dist/panel.min.js\"];\n", - " var js_modules = [];\n", - " var js_exports = {};\n", - " var css_urls = [];\n", - " var inline_js = [ function(Bokeh) {\n", - " Bokeh.set_log_level(\"info\");\n", - " },\n", - "function(Bokeh) {} // ensure no trailing comma for IE\n", - " ];\n", - "\n", - " function run_inline_js() {\n", - " if ((root.Bokeh !== undefined) || (force === true)) {\n", - " for (var i = 0; i < inline_js.length; i++) {\n", - " inline_js[i].call(root, root.Bokeh);\n", - " }\n", - " // Cache old bokeh versions\n", - " if (Bokeh != undefined && !reloading) {\n", - "\tvar NewBokeh = root.Bokeh;\n", - "\tif (Bokeh.versions === undefined) {\n", - "\t Bokeh.versions = new Map();\n", - "\t}\n", - "\tif (NewBokeh.version !== Bokeh.version) {\n", - "\t Bokeh.versions.set(NewBokeh.version, NewBokeh)\n", - "\t}\n", - "\troot.Bokeh = Bokeh;\n", - " }} else if (Date.now() < root._bokeh_timeout) {\n", - " setTimeout(run_inline_js, 100);\n", - " } else if (!root._bokeh_failed_load) {\n", - " console.log(\"Bokeh: BokehJS failed to load within specified timeout.\");\n", - " root._bokeh_failed_load = true;\n", - " }\n", - " root._bokeh_is_initializing = false\n", - " }\n", - "\n", - " function load_or_wait() {\n", - " // Implement a backoff loop that tries to ensure we do not load multiple\n", - " // versions of Bokeh and its dependencies at the same time.\n", - " // In recent versions we use the root._bokeh_is_initializing flag\n", - " // to determine whether there is an ongoing attempt to initialize\n", - " // bokeh, however for backward compatibility we also try to ensure\n", - " // that we do not start loading a newer (Panel>=1.0 and Bokeh>3) version\n", - " // before older versions are fully initialized.\n", - " if (root._bokeh_is_initializing && Date.now() > root._bokeh_timeout) {\n", - " root._bokeh_is_initializing = false;\n", - " root._bokeh_onload_callbacks = undefined;\n", - " console.log(\"Bokeh: BokehJS was loaded multiple times but one version failed to initialize.\");\n", - " load_or_wait();\n", - " } else if (root._bokeh_is_initializing || (typeof root._bokeh_is_initializing === \"undefined\" && root._bokeh_onload_callbacks !== undefined)) {\n", - " setTimeout(load_or_wait, 100);\n", - " } else {\n", - " Bokeh = root.Bokeh;\n", - " bokeh_loaded = Bokeh != null && (Bokeh.version === py_version || (Bokeh.versions !== undefined && Bokeh.versions.has(py_version)));\n", - " root._bokeh_is_initializing = true\n", - " root._bokeh_onload_callbacks = []\n", - " if (!reloading && (!bokeh_loaded || is_dev)) {\n", - "\troot.Bokeh = undefined;\n", - " }\n", - " load_libs(css_urls, js_urls, js_modules, js_exports, function() {\n", - "\tconsole.debug(\"Bokeh: BokehJS plotting callback run at\", now());\n", - "\trun_inline_js();\n", - " });\n", - " }\n", - " }\n", - " // Give older versions of the autoload script a head-start to ensure\n", - " // they initialize before we start loading newer version.\n", - " setTimeout(load_or_wait, 100)\n", - "}(window));" - ], - "application/vnd.holoviews_load.v0+json": "(function(root) {\n function now() {\n return new Date();\n }\n\n var force = true;\n var py_version = '3.2.2'.replace('rc', '-rc.').replace('.dev', '-dev.');\n var is_dev = py_version.indexOf(\"+\") !== -1 || py_version.indexOf(\"-\") !== -1;\n var reloading = false;\n var Bokeh = root.Bokeh;\n var bokeh_loaded = Bokeh != null && (Bokeh.version === py_version || (Bokeh.versions !== undefined && Bokeh.versions.has(py_version)));\n\n if (typeof (root._bokeh_timeout) === \"undefined\" || force) {\n root._bokeh_timeout = Date.now() + 5000;\n root._bokeh_failed_load = false;\n }\n\n function run_callbacks() {\n try {\n root._bokeh_onload_callbacks.forEach(function(callback) {\n if (callback != null)\n callback();\n });\n } finally {\n delete root._bokeh_onload_callbacks;\n }\n console.debug(\"Bokeh: all callbacks have finished\");\n }\n\n function load_libs(css_urls, js_urls, js_modules, js_exports, callback) {\n if (css_urls == null) css_urls = [];\n if (js_urls == null) js_urls = [];\n if (js_modules == null) js_modules = [];\n if (js_exports == null) js_exports = {};\n\n root._bokeh_onload_callbacks.push(callback);\n\n if (root._bokeh_is_loading > 0) {\n console.debug(\"Bokeh: BokehJS is being loaded, scheduling callback at\", now());\n return null;\n }\n if (js_urls.length === 0 && js_modules.length === 0 && Object.keys(js_exports).length === 0) {\n run_callbacks();\n return null;\n }\n if (!reloading) {\n console.debug(\"Bokeh: BokehJS not loaded, scheduling load and callback at\", now());\n }\n\n function on_load() {\n root._bokeh_is_loading--;\n if (root._bokeh_is_loading === 0) {\n console.debug(\"Bokeh: all BokehJS libraries/stylesheets loaded\");\n run_callbacks()\n }\n }\n window._bokeh_on_load = on_load\n\n function on_error() {\n console.error(\"failed to load \" + url);\n }\n\n var skip = [];\n if (window.requirejs) {\n window.requirejs.config({'packages': {}, 'paths': {'jspanel': 'https://cdn.jsdelivr.net/npm/jspanel4@4.12.0/dist/jspanel', 'jspanel-modal': 'https://cdn.jsdelivr.net/npm/jspanel4@4.12.0/dist/extensions/modal/jspanel.modal', 'jspanel-tooltip': 'https://cdn.jsdelivr.net/npm/jspanel4@4.12.0/dist/extensions/tooltip/jspanel.tooltip', 'jspanel-hint': 'https://cdn.jsdelivr.net/npm/jspanel4@4.12.0/dist/extensions/hint/jspanel.hint', 'jspanel-layout': 'https://cdn.jsdelivr.net/npm/jspanel4@4.12.0/dist/extensions/layout/jspanel.layout', 'jspanel-contextmenu': 'https://cdn.jsdelivr.net/npm/jspanel4@4.12.0/dist/extensions/contextmenu/jspanel.contextmenu', 'jspanel-dock': 'https://cdn.jsdelivr.net/npm/jspanel4@4.12.0/dist/extensions/dock/jspanel.dock', 'gridstack': 'https://cdn.jsdelivr.net/npm/gridstack@7.2.3/dist/gridstack-all', 'notyf': 'https://cdn.jsdelivr.net/npm/notyf@3/notyf.min'}, 'shim': {'jspanel': {'exports': 'jsPanel'}, 'gridstack': {'exports': 'GridStack'}}});\n require([\"jspanel\"], function(jsPanel) {\n\twindow.jsPanel = jsPanel\n\ton_load()\n })\n require([\"jspanel-modal\"], function() {\n\ton_load()\n })\n require([\"jspanel-tooltip\"], function() {\n\ton_load()\n })\n require([\"jspanel-hint\"], function() {\n\ton_load()\n })\n require([\"jspanel-layout\"], function() {\n\ton_load()\n })\n require([\"jspanel-contextmenu\"], function() {\n\ton_load()\n })\n require([\"jspanel-dock\"], function() {\n\ton_load()\n })\n require([\"gridstack\"], function(GridStack) {\n\twindow.GridStack = GridStack\n\ton_load()\n })\n require([\"notyf\"], function() {\n\ton_load()\n })\n root._bokeh_is_loading = css_urls.length + 9;\n } else {\n root._bokeh_is_loading = css_urls.length + js_urls.length + js_modules.length + Object.keys(js_exports).length;\n }\n\n var existing_stylesheets = []\n var links = document.getElementsByTagName('link')\n for (var i = 0; i < links.length; i++) {\n var link = links[i]\n if (link.href != null) {\n\texisting_stylesheets.push(link.href)\n }\n }\n for (var i = 0; i < css_urls.length; i++) {\n var url = css_urls[i];\n if (existing_stylesheets.indexOf(url) !== -1) {\n\ton_load()\n\tcontinue;\n }\n const element = document.createElement(\"link\");\n element.onload = on_load;\n element.onerror = on_error;\n element.rel = \"stylesheet\";\n element.type = \"text/css\";\n element.href = url;\n console.debug(\"Bokeh: injecting link tag for BokehJS stylesheet: \", url);\n document.body.appendChild(element);\n } if (((window['jsPanel'] !== undefined) && (!(window['jsPanel'] instanceof HTMLElement))) || window.requirejs) {\n var urls = ['https://cdn.holoviz.org/panel/1.2.3/dist/bundled/floatpanel/jspanel4@4.12.0/dist/jspanel.js', 'https://cdn.holoviz.org/panel/1.2.3/dist/bundled/floatpanel/jspanel4@4.12.0/dist/extensions/modal/jspanel.modal.js', 'https://cdn.holoviz.org/panel/1.2.3/dist/bundled/floatpanel/jspanel4@4.12.0/dist/extensions/tooltip/jspanel.tooltip.js', 'https://cdn.holoviz.org/panel/1.2.3/dist/bundled/floatpanel/jspanel4@4.12.0/dist/extensions/hint/jspanel.hint.js', 'https://cdn.holoviz.org/panel/1.2.3/dist/bundled/floatpanel/jspanel4@4.12.0/dist/extensions/layout/jspanel.layout.js', 'https://cdn.holoviz.org/panel/1.2.3/dist/bundled/floatpanel/jspanel4@4.12.0/dist/extensions/contextmenu/jspanel.contextmenu.js', 'https://cdn.holoviz.org/panel/1.2.3/dist/bundled/floatpanel/jspanel4@4.12.0/dist/extensions/dock/jspanel.dock.js'];\n for (var i = 0; i < urls.length; i++) {\n skip.push(urls[i])\n }\n } if (((window['GridStack'] !== undefined) && (!(window['GridStack'] instanceof HTMLElement))) || window.requirejs) {\n var urls = ['https://cdn.holoviz.org/panel/1.2.3/dist/bundled/gridstack/gridstack@7.2.3/dist/gridstack-all.js'];\n for (var i = 0; i < urls.length; i++) {\n skip.push(urls[i])\n }\n } if (((window['Notyf'] !== undefined) && (!(window['Notyf'] instanceof HTMLElement))) || window.requirejs) {\n var urls = ['https://cdn.holoviz.org/panel/1.2.3/dist/bundled/notificationarea/notyf@3/notyf.min.js'];\n for (var i = 0; i < urls.length; i++) {\n skip.push(urls[i])\n }\n } var existing_scripts = []\n var scripts = document.getElementsByTagName('script')\n for (var i = 0; i < scripts.length; i++) {\n var script = scripts[i]\n if (script.src != null) {\n\texisting_scripts.push(script.src)\n }\n }\n for (var i = 0; i < js_urls.length; i++) {\n var url = js_urls[i];\n if (skip.indexOf(url) !== -1 || existing_scripts.indexOf(url) !== -1) {\n\tif (!window.requirejs) {\n\t on_load();\n\t}\n\tcontinue;\n }\n var element = document.createElement('script');\n element.onload = on_load;\n element.onerror = on_error;\n element.async = false;\n element.src = url;\n console.debug(\"Bokeh: injecting script tag for BokehJS library: \", url);\n document.head.appendChild(element);\n }\n for (var i = 0; i < js_modules.length; i++) {\n var url = js_modules[i];\n if (skip.indexOf(url) !== -1 || existing_scripts.indexOf(url) !== -1) {\n\tif (!window.requirejs) {\n\t on_load();\n\t}\n\tcontinue;\n }\n var element = document.createElement('script');\n element.onload = on_load;\n element.onerror = on_error;\n element.async = false;\n element.src = url;\n element.type = \"module\";\n console.debug(\"Bokeh: injecting script tag for BokehJS library: \", url);\n document.head.appendChild(element);\n }\n for (const name in js_exports) {\n var url = js_exports[name];\n if (skip.indexOf(url) >= 0 || root[name] != null) {\n\tif (!window.requirejs) {\n\t on_load();\n\t}\n\tcontinue;\n }\n var element = document.createElement('script');\n element.onerror = on_error;\n element.async = false;\n element.type = \"module\";\n console.debug(\"Bokeh: injecting script tag for BokehJS library: \", url);\n element.textContent = `\n import ${name} from \"${url}\"\n window.${name} = ${name}\n window._bokeh_on_load()\n `\n document.head.appendChild(element);\n }\n if (!js_urls.length && !js_modules.length) {\n on_load()\n }\n };\n\n function inject_raw_css(css) {\n const element = document.createElement(\"style\");\n element.appendChild(document.createTextNode(css));\n document.body.appendChild(element);\n }\n\n var js_urls = [\"https://cdn.bokeh.org/bokeh/release/bokeh-3.2.2.min.js\", \"https://cdn.bokeh.org/bokeh/release/bokeh-gl-3.2.2.min.js\", \"https://cdn.bokeh.org/bokeh/release/bokeh-widgets-3.2.2.min.js\", \"https://cdn.bokeh.org/bokeh/release/bokeh-tables-3.2.2.min.js\", \"https://cdn.holoviz.org/panel/1.2.3/dist/panel.min.js\"];\n var js_modules = [];\n var js_exports = {};\n var css_urls = [];\n var inline_js = [ function(Bokeh) {\n Bokeh.set_log_level(\"info\");\n },\nfunction(Bokeh) {} // ensure no trailing comma for IE\n ];\n\n function run_inline_js() {\n if ((root.Bokeh !== undefined) || (force === true)) {\n for (var i = 0; i < inline_js.length; i++) {\n inline_js[i].call(root, root.Bokeh);\n }\n // Cache old bokeh versions\n if (Bokeh != undefined && !reloading) {\n\tvar NewBokeh = root.Bokeh;\n\tif (Bokeh.versions === undefined) {\n\t Bokeh.versions = new Map();\n\t}\n\tif (NewBokeh.version !== Bokeh.version) {\n\t Bokeh.versions.set(NewBokeh.version, NewBokeh)\n\t}\n\troot.Bokeh = Bokeh;\n }} else if (Date.now() < root._bokeh_timeout) {\n setTimeout(run_inline_js, 100);\n } else if (!root._bokeh_failed_load) {\n console.log(\"Bokeh: BokehJS failed to load within specified timeout.\");\n root._bokeh_failed_load = true;\n }\n root._bokeh_is_initializing = false\n }\n\n function load_or_wait() {\n // Implement a backoff loop that tries to ensure we do not load multiple\n // versions of Bokeh and its dependencies at the same time.\n // In recent versions we use the root._bokeh_is_initializing flag\n // to determine whether there is an ongoing attempt to initialize\n // bokeh, however for backward compatibility we also try to ensure\n // that we do not start loading a newer (Panel>=1.0 and Bokeh>3) version\n // before older versions are fully initialized.\n if (root._bokeh_is_initializing && Date.now() > root._bokeh_timeout) {\n root._bokeh_is_initializing = false;\n root._bokeh_onload_callbacks = undefined;\n console.log(\"Bokeh: BokehJS was loaded multiple times but one version failed to initialize.\");\n load_or_wait();\n } else if (root._bokeh_is_initializing || (typeof root._bokeh_is_initializing === \"undefined\" && root._bokeh_onload_callbacks !== undefined)) {\n setTimeout(load_or_wait, 100);\n } else {\n Bokeh = root.Bokeh;\n bokeh_loaded = Bokeh != null && (Bokeh.version === py_version || (Bokeh.versions !== undefined && Bokeh.versions.has(py_version)));\n root._bokeh_is_initializing = true\n root._bokeh_onload_callbacks = []\n if (!reloading && (!bokeh_loaded || is_dev)) {\n\troot.Bokeh = undefined;\n }\n load_libs(css_urls, js_urls, js_modules, js_exports, function() {\n\tconsole.debug(\"Bokeh: BokehJS plotting callback run at\", now());\n\trun_inline_js();\n });\n }\n }\n // Give older versions of the autoload script a head-start to ensure\n // they initialize before we start loading newer version.\n setTimeout(load_or_wait, 100)\n}(window));" - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "application/javascript": [ - "\n", - "if ((window.PyViz === undefined) || (window.PyViz instanceof HTMLElement)) {\n", - " window.PyViz = {comms: {}, comm_status:{}, kernels:{}, receivers: {}, plot_index: []}\n", - "}\n", - "\n", - "\n", - " function JupyterCommManager() {\n", - " }\n", - "\n", - " JupyterCommManager.prototype.register_target = function(plot_id, comm_id, msg_handler) {\n", - " if (window.comm_manager || ((window.Jupyter !== undefined) && (Jupyter.notebook.kernel != null))) {\n", - " var comm_manager = window.comm_manager || Jupyter.notebook.kernel.comm_manager;\n", - " comm_manager.register_target(comm_id, function(comm) {\n", - " comm.on_msg(msg_handler);\n", - " });\n", - " } else if ((plot_id in window.PyViz.kernels) && (window.PyViz.kernels[plot_id])) {\n", - " window.PyViz.kernels[plot_id].registerCommTarget(comm_id, function(comm) {\n", - " comm.onMsg = msg_handler;\n", - " });\n", - " } else if (typeof google != 'undefined' && google.colab.kernel != null) {\n", - " google.colab.kernel.comms.registerTarget(comm_id, (comm) => {\n", - " var messages = comm.messages[Symbol.asyncIterator]();\n", - " function processIteratorResult(result) {\n", - " var message = result.value;\n", - " console.log(message)\n", - " var content = {data: message.data, comm_id};\n", - " var buffers = []\n", - " for (var buffer of message.buffers || []) {\n", - " buffers.push(new DataView(buffer))\n", - " }\n", - " var metadata = message.metadata || {};\n", - " var msg = {content, buffers, metadata}\n", - " msg_handler(msg);\n", - " return messages.next().then(processIteratorResult);\n", - " }\n", - " return messages.next().then(processIteratorResult);\n", - " })\n", - " }\n", - " }\n", - "\n", - " JupyterCommManager.prototype.get_client_comm = function(plot_id, comm_id, msg_handler) {\n", - " if (comm_id in window.PyViz.comms) {\n", - " return window.PyViz.comms[comm_id];\n", - " } else if (window.comm_manager || ((window.Jupyter !== undefined) && (Jupyter.notebook.kernel != null))) {\n", - " var comm_manager = window.comm_manager || Jupyter.notebook.kernel.comm_manager;\n", - " var comm = comm_manager.new_comm(comm_id, {}, {}, {}, comm_id);\n", - " if (msg_handler) {\n", - " comm.on_msg(msg_handler);\n", - " }\n", - " } else if ((plot_id in window.PyViz.kernels) && (window.PyViz.kernels[plot_id])) {\n", - " var comm = window.PyViz.kernels[plot_id].connectToComm(comm_id);\n", - " comm.open();\n", - " if (msg_handler) {\n", - " comm.onMsg = msg_handler;\n", - " }\n", - " } else if (typeof google != 'undefined' && google.colab.kernel != null) {\n", - " var comm_promise = google.colab.kernel.comms.open(comm_id)\n", - " comm_promise.then((comm) => {\n", - " window.PyViz.comms[comm_id] = comm;\n", - " if (msg_handler) {\n", - " var messages = comm.messages[Symbol.asyncIterator]();\n", - " function processIteratorResult(result) {\n", - " var message = result.value;\n", - " var content = {data: message.data};\n", - " var metadata = message.metadata || {comm_id};\n", - " var msg = {content, metadata}\n", - " msg_handler(msg);\n", - " return messages.next().then(processIteratorResult);\n", - " }\n", - " return messages.next().then(processIteratorResult);\n", - " }\n", - " }) \n", - " var sendClosure = (data, metadata, buffers, disposeOnDone) => {\n", - " return comm_promise.then((comm) => {\n", - " comm.send(data, metadata, buffers, disposeOnDone);\n", - " });\n", - " };\n", - " var comm = {\n", - " send: sendClosure\n", - " };\n", - " }\n", - " window.PyViz.comms[comm_id] = comm;\n", - " return comm;\n", - " }\n", - " window.PyViz.comm_manager = new JupyterCommManager();\n", - " \n", - "\n", - "\n", - "var JS_MIME_TYPE = 'application/javascript';\n", - "var HTML_MIME_TYPE = 'text/html';\n", - "var EXEC_MIME_TYPE = 'application/vnd.holoviews_exec.v0+json';\n", - "var CLASS_NAME = 'output';\n", - "\n", - "/**\n", - " * Render data to the DOM node\n", - " */\n", - "function render(props, node) {\n", - " var div = document.createElement(\"div\");\n", - " var script = document.createElement(\"script\");\n", - " node.appendChild(div);\n", - " node.appendChild(script);\n", - "}\n", - "\n", - "/**\n", - " * Handle when a new output is added\n", - " */\n", - "function handle_add_output(event, handle) {\n", - " var output_area = handle.output_area;\n", - " var output = handle.output;\n", - " if ((output.data == undefined) || (!output.data.hasOwnProperty(EXEC_MIME_TYPE))) {\n", - " return\n", - " }\n", - " var id = output.metadata[EXEC_MIME_TYPE][\"id\"];\n", - " var toinsert = output_area.element.find(\".\" + CLASS_NAME.split(' ')[0]);\n", - " if (id !== undefined) {\n", - " var nchildren = toinsert.length;\n", - " var html_node = toinsert[nchildren-1].children[0];\n", - " html_node.innerHTML = output.data[HTML_MIME_TYPE];\n", - " var scripts = [];\n", - " var nodelist = html_node.querySelectorAll(\"script\");\n", - " for (var i in nodelist) {\n", - " if (nodelist.hasOwnProperty(i)) {\n", - " scripts.push(nodelist[i])\n", - " }\n", - " }\n", - "\n", - " scripts.forEach( function (oldScript) {\n", - " var newScript = document.createElement(\"script\");\n", - " var attrs = [];\n", - " var nodemap = oldScript.attributes;\n", - " for (var j in nodemap) {\n", - " if (nodemap.hasOwnProperty(j)) {\n", - " attrs.push(nodemap[j])\n", - " }\n", - " }\n", - " attrs.forEach(function(attr) { newScript.setAttribute(attr.name, attr.value) });\n", - " newScript.appendChild(document.createTextNode(oldScript.innerHTML));\n", - " oldScript.parentNode.replaceChild(newScript, oldScript);\n", - " });\n", - " if (JS_MIME_TYPE in output.data) {\n", - " toinsert[nchildren-1].children[1].textContent = output.data[JS_MIME_TYPE];\n", - " }\n", - " output_area._hv_plot_id = id;\n", - " if ((window.Bokeh !== undefined) && (id in Bokeh.index)) {\n", - " window.PyViz.plot_index[id] = Bokeh.index[id];\n", - " } else {\n", - " window.PyViz.plot_index[id] = null;\n", - " }\n", - " } else if (output.metadata[EXEC_MIME_TYPE][\"server_id\"] !== undefined) {\n", - " var bk_div = document.createElement(\"div\");\n", - " bk_div.innerHTML = output.data[HTML_MIME_TYPE];\n", - " var script_attrs = bk_div.children[0].attributes;\n", - " for (var i = 0; i < script_attrs.length; i++) {\n", - " toinsert[toinsert.length - 1].childNodes[1].setAttribute(script_attrs[i].name, script_attrs[i].value);\n", - " }\n", - " // store reference to server id on output_area\n", - " output_area._bokeh_server_id = output.metadata[EXEC_MIME_TYPE][\"server_id\"];\n", - " }\n", - "}\n", - "\n", - "/**\n", - " * Handle when an output is cleared or removed\n", - " */\n", - "function handle_clear_output(event, handle) {\n", - " var id = handle.cell.output_area._hv_plot_id;\n", - " var server_id = handle.cell.output_area._bokeh_server_id;\n", - " if (((id === undefined) || !(id in PyViz.plot_index)) && (server_id !== undefined)) { return; }\n", - " var comm = window.PyViz.comm_manager.get_client_comm(\"hv-extension-comm\", \"hv-extension-comm\", function () {});\n", - " if (server_id !== null) {\n", - " comm.send({event_type: 'server_delete', 'id': server_id});\n", - " return;\n", - " } else if (comm !== null) {\n", - " comm.send({event_type: 'delete', 'id': id});\n", - " }\n", - " delete PyViz.plot_index[id];\n", - " if ((window.Bokeh !== undefined) & (id in window.Bokeh.index)) {\n", - " var doc = window.Bokeh.index[id].model.document\n", - " doc.clear();\n", - " const i = window.Bokeh.documents.indexOf(doc);\n", - " if (i > -1) {\n", - " window.Bokeh.documents.splice(i, 1);\n", - " }\n", - " }\n", - "}\n", - "\n", - "/**\n", - " * Handle kernel restart event\n", - " */\n", - "function handle_kernel_cleanup(event, handle) {\n", - " delete PyViz.comms[\"hv-extension-comm\"];\n", - " window.PyViz.plot_index = {}\n", - "}\n", - "\n", - "/**\n", - " * Handle update_display_data messages\n", - " */\n", - "function handle_update_output(event, handle) {\n", - " handle_clear_output(event, {cell: {output_area: handle.output_area}})\n", - " handle_add_output(event, handle)\n", - "}\n", - "\n", - "function register_renderer(events, OutputArea) {\n", - " function append_mime(data, metadata, element) {\n", - " // create a DOM node to render to\n", - " var toinsert = this.create_output_subarea(\n", - " metadata,\n", - " CLASS_NAME,\n", - " EXEC_MIME_TYPE\n", - " );\n", - " this.keyboard_manager.register_events(toinsert);\n", - " // Render to node\n", - " var props = {data: data, metadata: metadata[EXEC_MIME_TYPE]};\n", - " render(props, toinsert[0]);\n", - " element.append(toinsert);\n", - " return toinsert\n", - " }\n", - "\n", - " events.on('output_added.OutputArea', handle_add_output);\n", - " events.on('output_updated.OutputArea', handle_update_output);\n", - " events.on('clear_output.CodeCell', handle_clear_output);\n", - " events.on('delete.Cell', handle_clear_output);\n", - " events.on('kernel_ready.Kernel', handle_kernel_cleanup);\n", - "\n", - " OutputArea.prototype.register_mime_type(EXEC_MIME_TYPE, append_mime, {\n", - " safe: true,\n", - " index: 0\n", - " });\n", - "}\n", - "\n", - "if (window.Jupyter !== undefined) {\n", - " try {\n", - " var events = require('base/js/events');\n", - " var OutputArea = require('notebook/js/outputarea').OutputArea;\n", - " if (OutputArea.prototype.mime_types().indexOf(EXEC_MIME_TYPE) == -1) {\n", - " register_renderer(events, OutputArea);\n", - " }\n", - " } catch(err) {\n", - " }\n", - "}\n" - ], - "application/vnd.holoviews_load.v0+json": "\nif ((window.PyViz === undefined) || (window.PyViz instanceof HTMLElement)) {\n window.PyViz = {comms: {}, comm_status:{}, kernels:{}, receivers: {}, plot_index: []}\n}\n\n\n function JupyterCommManager() {\n }\n\n JupyterCommManager.prototype.register_target = function(plot_id, comm_id, msg_handler) {\n if (window.comm_manager || ((window.Jupyter !== undefined) && (Jupyter.notebook.kernel != null))) {\n var comm_manager = window.comm_manager || Jupyter.notebook.kernel.comm_manager;\n comm_manager.register_target(comm_id, function(comm) {\n comm.on_msg(msg_handler);\n });\n } else if ((plot_id in window.PyViz.kernels) && (window.PyViz.kernels[plot_id])) {\n window.PyViz.kernels[plot_id].registerCommTarget(comm_id, function(comm) {\n comm.onMsg = msg_handler;\n });\n } else if (typeof google != 'undefined' && google.colab.kernel != null) {\n google.colab.kernel.comms.registerTarget(comm_id, (comm) => {\n var messages = comm.messages[Symbol.asyncIterator]();\n function processIteratorResult(result) {\n var message = result.value;\n console.log(message)\n var content = {data: message.data, comm_id};\n var buffers = []\n for (var buffer of message.buffers || []) {\n buffers.push(new DataView(buffer))\n }\n var metadata = message.metadata || {};\n var msg = {content, buffers, metadata}\n msg_handler(msg);\n return messages.next().then(processIteratorResult);\n }\n return messages.next().then(processIteratorResult);\n })\n }\n }\n\n JupyterCommManager.prototype.get_client_comm = function(plot_id, comm_id, msg_handler) {\n if (comm_id in window.PyViz.comms) {\n return window.PyViz.comms[comm_id];\n } else if (window.comm_manager || ((window.Jupyter !== undefined) && (Jupyter.notebook.kernel != null))) {\n var comm_manager = window.comm_manager || Jupyter.notebook.kernel.comm_manager;\n var comm = comm_manager.new_comm(comm_id, {}, {}, {}, comm_id);\n if (msg_handler) {\n comm.on_msg(msg_handler);\n }\n } else if ((plot_id in window.PyViz.kernels) && (window.PyViz.kernels[plot_id])) {\n var comm = window.PyViz.kernels[plot_id].connectToComm(comm_id);\n comm.open();\n if (msg_handler) {\n comm.onMsg = msg_handler;\n }\n } else if (typeof google != 'undefined' && google.colab.kernel != null) {\n var comm_promise = google.colab.kernel.comms.open(comm_id)\n comm_promise.then((comm) => {\n window.PyViz.comms[comm_id] = comm;\n if (msg_handler) {\n var messages = comm.messages[Symbol.asyncIterator]();\n function processIteratorResult(result) {\n var message = result.value;\n var content = {data: message.data};\n var metadata = message.metadata || {comm_id};\n var msg = {content, metadata}\n msg_handler(msg);\n return messages.next().then(processIteratorResult);\n }\n return messages.next().then(processIteratorResult);\n }\n }) \n var sendClosure = (data, metadata, buffers, disposeOnDone) => {\n return comm_promise.then((comm) => {\n comm.send(data, metadata, buffers, disposeOnDone);\n });\n };\n var comm = {\n send: sendClosure\n };\n }\n window.PyViz.comms[comm_id] = comm;\n return comm;\n }\n window.PyViz.comm_manager = new JupyterCommManager();\n \n\n\nvar JS_MIME_TYPE = 'application/javascript';\nvar HTML_MIME_TYPE = 'text/html';\nvar EXEC_MIME_TYPE = 'application/vnd.holoviews_exec.v0+json';\nvar CLASS_NAME = 'output';\n\n/**\n * Render data to the DOM node\n */\nfunction render(props, node) {\n var div = document.createElement(\"div\");\n var script = document.createElement(\"script\");\n node.appendChild(div);\n node.appendChild(script);\n}\n\n/**\n * Handle when a new output is added\n */\nfunction handle_add_output(event, handle) {\n var output_area = handle.output_area;\n var output = handle.output;\n if ((output.data == undefined) || (!output.data.hasOwnProperty(EXEC_MIME_TYPE))) {\n return\n }\n var id = output.metadata[EXEC_MIME_TYPE][\"id\"];\n var toinsert = output_area.element.find(\".\" + CLASS_NAME.split(' ')[0]);\n if (id !== undefined) {\n var nchildren = toinsert.length;\n var html_node = toinsert[nchildren-1].children[0];\n html_node.innerHTML = output.data[HTML_MIME_TYPE];\n var scripts = [];\n var nodelist = html_node.querySelectorAll(\"script\");\n for (var i in nodelist) {\n if (nodelist.hasOwnProperty(i)) {\n scripts.push(nodelist[i])\n }\n }\n\n scripts.forEach( function (oldScript) {\n var newScript = document.createElement(\"script\");\n var attrs = [];\n var nodemap = oldScript.attributes;\n for (var j in nodemap) {\n if (nodemap.hasOwnProperty(j)) {\n attrs.push(nodemap[j])\n }\n }\n attrs.forEach(function(attr) { newScript.setAttribute(attr.name, attr.value) });\n newScript.appendChild(document.createTextNode(oldScript.innerHTML));\n oldScript.parentNode.replaceChild(newScript, oldScript);\n });\n if (JS_MIME_TYPE in output.data) {\n toinsert[nchildren-1].children[1].textContent = output.data[JS_MIME_TYPE];\n }\n output_area._hv_plot_id = id;\n if ((window.Bokeh !== undefined) && (id in Bokeh.index)) {\n window.PyViz.plot_index[id] = Bokeh.index[id];\n } else {\n window.PyViz.plot_index[id] = null;\n }\n } else if (output.metadata[EXEC_MIME_TYPE][\"server_id\"] !== undefined) {\n var bk_div = document.createElement(\"div\");\n bk_div.innerHTML = output.data[HTML_MIME_TYPE];\n var script_attrs = bk_div.children[0].attributes;\n for (var i = 0; i < script_attrs.length; i++) {\n toinsert[toinsert.length - 1].childNodes[1].setAttribute(script_attrs[i].name, script_attrs[i].value);\n }\n // store reference to server id on output_area\n output_area._bokeh_server_id = output.metadata[EXEC_MIME_TYPE][\"server_id\"];\n }\n}\n\n/**\n * Handle when an output is cleared or removed\n */\nfunction handle_clear_output(event, handle) {\n var id = handle.cell.output_area._hv_plot_id;\n var server_id = handle.cell.output_area._bokeh_server_id;\n if (((id === undefined) || !(id in PyViz.plot_index)) && (server_id !== undefined)) { return; }\n var comm = window.PyViz.comm_manager.get_client_comm(\"hv-extension-comm\", \"hv-extension-comm\", function () {});\n if (server_id !== null) {\n comm.send({event_type: 'server_delete', 'id': server_id});\n return;\n } else if (comm !== null) {\n comm.send({event_type: 'delete', 'id': id});\n }\n delete PyViz.plot_index[id];\n if ((window.Bokeh !== undefined) & (id in window.Bokeh.index)) {\n var doc = window.Bokeh.index[id].model.document\n doc.clear();\n const i = window.Bokeh.documents.indexOf(doc);\n if (i > -1) {\n window.Bokeh.documents.splice(i, 1);\n }\n }\n}\n\n/**\n * Handle kernel restart event\n */\nfunction handle_kernel_cleanup(event, handle) {\n delete PyViz.comms[\"hv-extension-comm\"];\n window.PyViz.plot_index = {}\n}\n\n/**\n * Handle update_display_data messages\n */\nfunction handle_update_output(event, handle) {\n handle_clear_output(event, {cell: {output_area: handle.output_area}})\n handle_add_output(event, handle)\n}\n\nfunction register_renderer(events, OutputArea) {\n function append_mime(data, metadata, element) {\n // create a DOM node to render to\n var toinsert = this.create_output_subarea(\n metadata,\n CLASS_NAME,\n EXEC_MIME_TYPE\n );\n this.keyboard_manager.register_events(toinsert);\n // Render to node\n var props = {data: data, metadata: metadata[EXEC_MIME_TYPE]};\n render(props, toinsert[0]);\n element.append(toinsert);\n return toinsert\n }\n\n events.on('output_added.OutputArea', handle_add_output);\n events.on('output_updated.OutputArea', handle_update_output);\n events.on('clear_output.CodeCell', handle_clear_output);\n events.on('delete.Cell', handle_clear_output);\n events.on('kernel_ready.Kernel', handle_kernel_cleanup);\n\n OutputArea.prototype.register_mime_type(EXEC_MIME_TYPE, append_mime, {\n safe: true,\n index: 0\n });\n}\n\nif (window.Jupyter !== undefined) {\n try {\n var events = require('base/js/events');\n var OutputArea = require('notebook/js/outputarea').OutputArea;\n if (OutputArea.prototype.mime_types().indexOf(EXEC_MIME_TYPE) == -1) {\n register_renderer(events, OutputArea);\n }\n } catch(err) {\n }\n}\n" - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/html": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "application/javascript": [ - "(function(root) {\n", - " function now() {\n", - " return new Date();\n", - " }\n", - "\n", - " var force = true;\n", - " var py_version = '3.2.2'.replace('rc', '-rc.').replace('.dev', '-dev.');\n", - " var is_dev = py_version.indexOf(\"+\") !== -1 || py_version.indexOf(\"-\") !== -1;\n", - " var reloading = true;\n", - " var Bokeh = root.Bokeh;\n", - " var bokeh_loaded = Bokeh != null && (Bokeh.version === py_version || (Bokeh.versions !== undefined && Bokeh.versions.has(py_version)));\n", - "\n", - " if (typeof (root._bokeh_timeout) === \"undefined\" || force) {\n", - " root._bokeh_timeout = Date.now() + 5000;\n", - " root._bokeh_failed_load = false;\n", - " }\n", - "\n", - " function run_callbacks() {\n", - " try {\n", - " root._bokeh_onload_callbacks.forEach(function(callback) {\n", - " if (callback != null)\n", - " callback();\n", - " });\n", - " } finally {\n", - " delete root._bokeh_onload_callbacks;\n", - " }\n", - " console.debug(\"Bokeh: all callbacks have finished\");\n", - " }\n", - "\n", - " function load_libs(css_urls, js_urls, js_modules, js_exports, callback) {\n", - " if (css_urls == null) css_urls = [];\n", - " if (js_urls == null) js_urls = [];\n", - " if (js_modules == null) js_modules = [];\n", - " if (js_exports == null) js_exports = {};\n", - "\n", - " root._bokeh_onload_callbacks.push(callback);\n", - "\n", - " if (root._bokeh_is_loading > 0) {\n", - " console.debug(\"Bokeh: BokehJS is being loaded, scheduling callback at\", now());\n", - " return null;\n", - " }\n", - " if (js_urls.length === 0 && js_modules.length === 0 && Object.keys(js_exports).length === 0) {\n", - " run_callbacks();\n", - " return null;\n", - " }\n", - " if (!reloading) {\n", - " console.debug(\"Bokeh: BokehJS not loaded, scheduling load and callback at\", now());\n", - " }\n", - "\n", - " function on_load() {\n", - " root._bokeh_is_loading--;\n", - " if (root._bokeh_is_loading === 0) {\n", - " console.debug(\"Bokeh: all BokehJS libraries/stylesheets loaded\");\n", - " run_callbacks()\n", - " }\n", - " }\n", - " window._bokeh_on_load = on_load\n", - "\n", - " function on_error() {\n", - " console.error(\"failed to load \" + url);\n", - " }\n", - "\n", - " var skip = [];\n", - " if (window.requirejs) {\n", - " window.requirejs.config({'packages': {}, 'paths': {'jspanel': 'https://cdn.jsdelivr.net/npm/jspanel4@4.12.0/dist/jspanel', 'jspanel-modal': 'https://cdn.jsdelivr.net/npm/jspanel4@4.12.0/dist/extensions/modal/jspanel.modal', 'jspanel-tooltip': 'https://cdn.jsdelivr.net/npm/jspanel4@4.12.0/dist/extensions/tooltip/jspanel.tooltip', 'jspanel-hint': 'https://cdn.jsdelivr.net/npm/jspanel4@4.12.0/dist/extensions/hint/jspanel.hint', 'jspanel-layout': 'https://cdn.jsdelivr.net/npm/jspanel4@4.12.0/dist/extensions/layout/jspanel.layout', 'jspanel-contextmenu': 'https://cdn.jsdelivr.net/npm/jspanel4@4.12.0/dist/extensions/contextmenu/jspanel.contextmenu', 'jspanel-dock': 'https://cdn.jsdelivr.net/npm/jspanel4@4.12.0/dist/extensions/dock/jspanel.dock', 'gridstack': 'https://cdn.jsdelivr.net/npm/gridstack@7.2.3/dist/gridstack-all', 'notyf': 'https://cdn.jsdelivr.net/npm/notyf@3/notyf.min'}, 'shim': {'jspanel': {'exports': 'jsPanel'}, 'gridstack': {'exports': 'GridStack'}}});\n", - " require([\"jspanel\"], function(jsPanel) {\n", - "\twindow.jsPanel = jsPanel\n", - "\ton_load()\n", - " })\n", - " require([\"jspanel-modal\"], function() {\n", - "\ton_load()\n", - " })\n", - " require([\"jspanel-tooltip\"], function() {\n", - "\ton_load()\n", - " })\n", - " require([\"jspanel-hint\"], function() {\n", - "\ton_load()\n", - " })\n", - " require([\"jspanel-layout\"], function() {\n", - "\ton_load()\n", - " })\n", - " require([\"jspanel-contextmenu\"], function() {\n", - "\ton_load()\n", - " })\n", - " require([\"jspanel-dock\"], function() {\n", - "\ton_load()\n", - " })\n", - " require([\"gridstack\"], function(GridStack) {\n", - "\twindow.GridStack = GridStack\n", - "\ton_load()\n", - " })\n", - " require([\"notyf\"], function() {\n", - "\ton_load()\n", - " })\n", - " root._bokeh_is_loading = css_urls.length + 9;\n", - " } else {\n", - " root._bokeh_is_loading = css_urls.length + js_urls.length + js_modules.length + Object.keys(js_exports).length;\n", - " }\n", - "\n", - " var existing_stylesheets = []\n", - " var links = document.getElementsByTagName('link')\n", - " for (var i = 0; i < links.length; i++) {\n", - " var link = links[i]\n", - " if (link.href != null) {\n", - "\texisting_stylesheets.push(link.href)\n", - " }\n", - " }\n", - " for (var i = 0; i < css_urls.length; i++) {\n", - " var url = css_urls[i];\n", - " if (existing_stylesheets.indexOf(url) !== -1) {\n", - "\ton_load()\n", - "\tcontinue;\n", - " }\n", - " const element = document.createElement(\"link\");\n", - " element.onload = on_load;\n", - " element.onerror = on_error;\n", - " element.rel = \"stylesheet\";\n", - " element.type = \"text/css\";\n", - " element.href = url;\n", - " console.debug(\"Bokeh: injecting link tag for BokehJS stylesheet: \", url);\n", - " document.body.appendChild(element);\n", - " } if (((window['jsPanel'] !== undefined) && (!(window['jsPanel'] instanceof HTMLElement))) || window.requirejs) {\n", - " var urls = ['https://cdn.holoviz.org/panel/1.2.3/dist/bundled/floatpanel/jspanel4@4.12.0/dist/jspanel.js', 'https://cdn.holoviz.org/panel/1.2.3/dist/bundled/floatpanel/jspanel4@4.12.0/dist/extensions/modal/jspanel.modal.js', 'https://cdn.holoviz.org/panel/1.2.3/dist/bundled/floatpanel/jspanel4@4.12.0/dist/extensions/tooltip/jspanel.tooltip.js', 'https://cdn.holoviz.org/panel/1.2.3/dist/bundled/floatpanel/jspanel4@4.12.0/dist/extensions/hint/jspanel.hint.js', 'https://cdn.holoviz.org/panel/1.2.3/dist/bundled/floatpanel/jspanel4@4.12.0/dist/extensions/layout/jspanel.layout.js', 'https://cdn.holoviz.org/panel/1.2.3/dist/bundled/floatpanel/jspanel4@4.12.0/dist/extensions/contextmenu/jspanel.contextmenu.js', 'https://cdn.holoviz.org/panel/1.2.3/dist/bundled/floatpanel/jspanel4@4.12.0/dist/extensions/dock/jspanel.dock.js'];\n", - " for (var i = 0; i < urls.length; i++) {\n", - " skip.push(urls[i])\n", - " }\n", - " } if (((window['GridStack'] !== undefined) && (!(window['GridStack'] instanceof HTMLElement))) || window.requirejs) {\n", - " var urls = ['https://cdn.holoviz.org/panel/1.2.3/dist/bundled/gridstack/gridstack@7.2.3/dist/gridstack-all.js'];\n", - " for (var i = 0; i < urls.length; i++) {\n", - " skip.push(urls[i])\n", - " }\n", - " } if (((window['Notyf'] !== undefined) && (!(window['Notyf'] instanceof HTMLElement))) || window.requirejs) {\n", - " var urls = ['https://cdn.holoviz.org/panel/1.2.3/dist/bundled/notificationarea/notyf@3/notyf.min.js'];\n", - " for (var i = 0; i < urls.length; i++) {\n", - " skip.push(urls[i])\n", - " }\n", - " } var existing_scripts = []\n", - " var scripts = document.getElementsByTagName('script')\n", - " for (var i = 0; i < scripts.length; i++) {\n", - " var script = scripts[i]\n", - " if (script.src != null) {\n", - "\texisting_scripts.push(script.src)\n", - " }\n", - " }\n", - " for (var i = 0; i < js_urls.length; i++) {\n", - " var url = js_urls[i];\n", - " if (skip.indexOf(url) !== -1 || existing_scripts.indexOf(url) !== -1) {\n", - "\tif (!window.requirejs) {\n", - "\t on_load();\n", - "\t}\n", - "\tcontinue;\n", - " }\n", - " var element = document.createElement('script');\n", - " element.onload = on_load;\n", - " element.onerror = on_error;\n", - " element.async = false;\n", - " element.src = url;\n", - " console.debug(\"Bokeh: injecting script tag for BokehJS library: \", url);\n", - " document.head.appendChild(element);\n", - " }\n", - " for (var i = 0; i < js_modules.length; i++) {\n", - " var url = js_modules[i];\n", - " if (skip.indexOf(url) !== -1 || existing_scripts.indexOf(url) !== -1) {\n", - "\tif (!window.requirejs) {\n", - "\t on_load();\n", - "\t}\n", - "\tcontinue;\n", - " }\n", - " var element = document.createElement('script');\n", - " element.onload = on_load;\n", - " element.onerror = on_error;\n", - " element.async = false;\n", - " element.src = url;\n", - " element.type = \"module\";\n", - " console.debug(\"Bokeh: injecting script tag for BokehJS library: \", url);\n", - " document.head.appendChild(element);\n", - " }\n", - " for (const name in js_exports) {\n", - " var url = js_exports[name];\n", - " if (skip.indexOf(url) >= 0 || root[name] != null) {\n", - "\tif (!window.requirejs) {\n", - "\t on_load();\n", - "\t}\n", - "\tcontinue;\n", - " }\n", - " var element = document.createElement('script');\n", - " element.onerror = on_error;\n", - " element.async = false;\n", - " element.type = \"module\";\n", - " console.debug(\"Bokeh: injecting script tag for BokehJS library: \", url);\n", - " element.textContent = `\n", - " import ${name} from \"${url}\"\n", - " window.${name} = ${name}\n", - " window._bokeh_on_load()\n", - " `\n", - " document.head.appendChild(element);\n", - " }\n", - " if (!js_urls.length && !js_modules.length) {\n", - " on_load()\n", - " }\n", - " };\n", - "\n", - " function inject_raw_css(css) {\n", - " const element = document.createElement(\"style\");\n", - " element.appendChild(document.createTextNode(css));\n", - " document.body.appendChild(element);\n", - " }\n", - "\n", - " var js_urls = [];\n", - " var js_modules = [];\n", - " var js_exports = {};\n", - " var css_urls = [];\n", - " var inline_js = [ function(Bokeh) {\n", - " Bokeh.set_log_level(\"info\");\n", - " },\n", - "function(Bokeh) {} // ensure no trailing comma for IE\n", - " ];\n", - "\n", - " function run_inline_js() {\n", - " if ((root.Bokeh !== undefined) || (force === true)) {\n", - " for (var i = 0; i < inline_js.length; i++) {\n", - " inline_js[i].call(root, root.Bokeh);\n", - " }\n", - " // Cache old bokeh versions\n", - " if (Bokeh != undefined && !reloading) {\n", - "\tvar NewBokeh = root.Bokeh;\n", - "\tif (Bokeh.versions === undefined) {\n", - "\t Bokeh.versions = new Map();\n", - "\t}\n", - "\tif (NewBokeh.version !== Bokeh.version) {\n", - "\t Bokeh.versions.set(NewBokeh.version, NewBokeh)\n", - "\t}\n", - "\troot.Bokeh = Bokeh;\n", - " }} else if (Date.now() < root._bokeh_timeout) {\n", - " setTimeout(run_inline_js, 100);\n", - " } else if (!root._bokeh_failed_load) {\n", - " console.log(\"Bokeh: BokehJS failed to load within specified timeout.\");\n", - " root._bokeh_failed_load = true;\n", - " }\n", - " root._bokeh_is_initializing = false\n", - " }\n", - "\n", - " function load_or_wait() {\n", - " // Implement a backoff loop that tries to ensure we do not load multiple\n", - " // versions of Bokeh and its dependencies at the same time.\n", - " // In recent versions we use the root._bokeh_is_initializing flag\n", - " // to determine whether there is an ongoing attempt to initialize\n", - " // bokeh, however for backward compatibility we also try to ensure\n", - " // that we do not start loading a newer (Panel>=1.0 and Bokeh>3) version\n", - " // before older versions are fully initialized.\n", - " if (root._bokeh_is_initializing && Date.now() > root._bokeh_timeout) {\n", - " root._bokeh_is_initializing = false;\n", - " root._bokeh_onload_callbacks = undefined;\n", - " console.log(\"Bokeh: BokehJS was loaded multiple times but one version failed to initialize.\");\n", - " load_or_wait();\n", - " } else if (root._bokeh_is_initializing || (typeof root._bokeh_is_initializing === \"undefined\" && root._bokeh_onload_callbacks !== undefined)) {\n", - " setTimeout(load_or_wait, 100);\n", - " } else {\n", - " Bokeh = root.Bokeh;\n", - " bokeh_loaded = Bokeh != null && (Bokeh.version === py_version || (Bokeh.versions !== undefined && Bokeh.versions.has(py_version)));\n", - " root._bokeh_is_initializing = true\n", - " root._bokeh_onload_callbacks = []\n", - " if (!reloading && (!bokeh_loaded || is_dev)) {\n", - "\troot.Bokeh = undefined;\n", - " }\n", - " load_libs(css_urls, js_urls, js_modules, js_exports, function() {\n", - "\tconsole.debug(\"Bokeh: BokehJS plotting callback run at\", now());\n", - "\trun_inline_js();\n", - " });\n", - " }\n", - " }\n", - " // Give older versions of the autoload script a head-start to ensure\n", - " // they initialize before we start loading newer version.\n", - " setTimeout(load_or_wait, 100)\n", - "}(window));" - ], - "application/vnd.holoviews_load.v0+json": "(function(root) {\n function now() {\n return new Date();\n }\n\n var force = true;\n var py_version = '3.2.2'.replace('rc', '-rc.').replace('.dev', '-dev.');\n var is_dev = py_version.indexOf(\"+\") !== -1 || py_version.indexOf(\"-\") !== -1;\n var reloading = true;\n var Bokeh = root.Bokeh;\n var bokeh_loaded = Bokeh != null && (Bokeh.version === py_version || (Bokeh.versions !== undefined && Bokeh.versions.has(py_version)));\n\n if (typeof (root._bokeh_timeout) === \"undefined\" || force) {\n root._bokeh_timeout = Date.now() + 5000;\n root._bokeh_failed_load = false;\n }\n\n function run_callbacks() {\n try {\n root._bokeh_onload_callbacks.forEach(function(callback) {\n if (callback != null)\n callback();\n });\n } finally {\n delete root._bokeh_onload_callbacks;\n }\n console.debug(\"Bokeh: all callbacks have finished\");\n }\n\n function load_libs(css_urls, js_urls, js_modules, js_exports, callback) {\n if (css_urls == null) css_urls = [];\n if (js_urls == null) js_urls = [];\n if (js_modules == null) js_modules = [];\n if (js_exports == null) js_exports = {};\n\n root._bokeh_onload_callbacks.push(callback);\n\n if (root._bokeh_is_loading > 0) {\n console.debug(\"Bokeh: BokehJS is being loaded, scheduling callback at\", now());\n return null;\n }\n if (js_urls.length === 0 && js_modules.length === 0 && Object.keys(js_exports).length === 0) {\n run_callbacks();\n return null;\n }\n if (!reloading) {\n console.debug(\"Bokeh: BokehJS not loaded, scheduling load and callback at\", now());\n }\n\n function on_load() {\n root._bokeh_is_loading--;\n if (root._bokeh_is_loading === 0) {\n console.debug(\"Bokeh: all BokehJS libraries/stylesheets loaded\");\n run_callbacks()\n }\n }\n window._bokeh_on_load = on_load\n\n function on_error() {\n console.error(\"failed to load \" + url);\n }\n\n var skip = [];\n if (window.requirejs) {\n window.requirejs.config({'packages': {}, 'paths': {'jspanel': 'https://cdn.jsdelivr.net/npm/jspanel4@4.12.0/dist/jspanel', 'jspanel-modal': 'https://cdn.jsdelivr.net/npm/jspanel4@4.12.0/dist/extensions/modal/jspanel.modal', 'jspanel-tooltip': 'https://cdn.jsdelivr.net/npm/jspanel4@4.12.0/dist/extensions/tooltip/jspanel.tooltip', 'jspanel-hint': 'https://cdn.jsdelivr.net/npm/jspanel4@4.12.0/dist/extensions/hint/jspanel.hint', 'jspanel-layout': 'https://cdn.jsdelivr.net/npm/jspanel4@4.12.0/dist/extensions/layout/jspanel.layout', 'jspanel-contextmenu': 'https://cdn.jsdelivr.net/npm/jspanel4@4.12.0/dist/extensions/contextmenu/jspanel.contextmenu', 'jspanel-dock': 'https://cdn.jsdelivr.net/npm/jspanel4@4.12.0/dist/extensions/dock/jspanel.dock', 'gridstack': 'https://cdn.jsdelivr.net/npm/gridstack@7.2.3/dist/gridstack-all', 'notyf': 'https://cdn.jsdelivr.net/npm/notyf@3/notyf.min'}, 'shim': {'jspanel': {'exports': 'jsPanel'}, 'gridstack': {'exports': 'GridStack'}}});\n require([\"jspanel\"], function(jsPanel) {\n\twindow.jsPanel = jsPanel\n\ton_load()\n })\n require([\"jspanel-modal\"], function() {\n\ton_load()\n })\n require([\"jspanel-tooltip\"], function() {\n\ton_load()\n })\n require([\"jspanel-hint\"], function() {\n\ton_load()\n })\n require([\"jspanel-layout\"], function() {\n\ton_load()\n })\n require([\"jspanel-contextmenu\"], function() {\n\ton_load()\n })\n require([\"jspanel-dock\"], function() {\n\ton_load()\n })\n require([\"gridstack\"], function(GridStack) {\n\twindow.GridStack = GridStack\n\ton_load()\n })\n require([\"notyf\"], function() {\n\ton_load()\n })\n root._bokeh_is_loading = css_urls.length + 9;\n } else {\n root._bokeh_is_loading = css_urls.length + js_urls.length + js_modules.length + Object.keys(js_exports).length;\n }\n\n var existing_stylesheets = []\n var links = document.getElementsByTagName('link')\n for (var i = 0; i < links.length; i++) {\n var link = links[i]\n if (link.href != null) {\n\texisting_stylesheets.push(link.href)\n }\n }\n for (var i = 0; i < css_urls.length; i++) {\n var url = css_urls[i];\n if (existing_stylesheets.indexOf(url) !== -1) {\n\ton_load()\n\tcontinue;\n }\n const element = document.createElement(\"link\");\n element.onload = on_load;\n element.onerror = on_error;\n element.rel = \"stylesheet\";\n element.type = \"text/css\";\n element.href = url;\n console.debug(\"Bokeh: injecting link tag for BokehJS stylesheet: \", url);\n document.body.appendChild(element);\n } if (((window['jsPanel'] !== undefined) && (!(window['jsPanel'] instanceof HTMLElement))) || window.requirejs) {\n var urls = ['https://cdn.holoviz.org/panel/1.2.3/dist/bundled/floatpanel/jspanel4@4.12.0/dist/jspanel.js', 'https://cdn.holoviz.org/panel/1.2.3/dist/bundled/floatpanel/jspanel4@4.12.0/dist/extensions/modal/jspanel.modal.js', 'https://cdn.holoviz.org/panel/1.2.3/dist/bundled/floatpanel/jspanel4@4.12.0/dist/extensions/tooltip/jspanel.tooltip.js', 'https://cdn.holoviz.org/panel/1.2.3/dist/bundled/floatpanel/jspanel4@4.12.0/dist/extensions/hint/jspanel.hint.js', 'https://cdn.holoviz.org/panel/1.2.3/dist/bundled/floatpanel/jspanel4@4.12.0/dist/extensions/layout/jspanel.layout.js', 'https://cdn.holoviz.org/panel/1.2.3/dist/bundled/floatpanel/jspanel4@4.12.0/dist/extensions/contextmenu/jspanel.contextmenu.js', 'https://cdn.holoviz.org/panel/1.2.3/dist/bundled/floatpanel/jspanel4@4.12.0/dist/extensions/dock/jspanel.dock.js'];\n for (var i = 0; i < urls.length; i++) {\n skip.push(urls[i])\n }\n } if (((window['GridStack'] !== undefined) && (!(window['GridStack'] instanceof HTMLElement))) || window.requirejs) {\n var urls = ['https://cdn.holoviz.org/panel/1.2.3/dist/bundled/gridstack/gridstack@7.2.3/dist/gridstack-all.js'];\n for (var i = 0; i < urls.length; i++) {\n skip.push(urls[i])\n }\n } if (((window['Notyf'] !== undefined) && (!(window['Notyf'] instanceof HTMLElement))) || window.requirejs) {\n var urls = ['https://cdn.holoviz.org/panel/1.2.3/dist/bundled/notificationarea/notyf@3/notyf.min.js'];\n for (var i = 0; i < urls.length; i++) {\n skip.push(urls[i])\n }\n } var existing_scripts = []\n var scripts = document.getElementsByTagName('script')\n for (var i = 0; i < scripts.length; i++) {\n var script = scripts[i]\n if (script.src != null) {\n\texisting_scripts.push(script.src)\n }\n }\n for (var i = 0; i < js_urls.length; i++) {\n var url = js_urls[i];\n if (skip.indexOf(url) !== -1 || existing_scripts.indexOf(url) !== -1) {\n\tif (!window.requirejs) {\n\t on_load();\n\t}\n\tcontinue;\n }\n var element = document.createElement('script');\n element.onload = on_load;\n element.onerror = on_error;\n element.async = false;\n element.src = url;\n console.debug(\"Bokeh: injecting script tag for BokehJS library: \", url);\n document.head.appendChild(element);\n }\n for (var i = 0; i < js_modules.length; i++) {\n var url = js_modules[i];\n if (skip.indexOf(url) !== -1 || existing_scripts.indexOf(url) !== -1) {\n\tif (!window.requirejs) {\n\t on_load();\n\t}\n\tcontinue;\n }\n var element = document.createElement('script');\n element.onload = on_load;\n element.onerror = on_error;\n element.async = false;\n element.src = url;\n element.type = \"module\";\n console.debug(\"Bokeh: injecting script tag for BokehJS library: \", url);\n document.head.appendChild(element);\n }\n for (const name in js_exports) {\n var url = js_exports[name];\n if (skip.indexOf(url) >= 0 || root[name] != null) {\n\tif (!window.requirejs) {\n\t on_load();\n\t}\n\tcontinue;\n }\n var element = document.createElement('script');\n element.onerror = on_error;\n element.async = false;\n element.type = \"module\";\n console.debug(\"Bokeh: injecting script tag for BokehJS library: \", url);\n element.textContent = `\n import ${name} from \"${url}\"\n window.${name} = ${name}\n window._bokeh_on_load()\n `\n document.head.appendChild(element);\n }\n if (!js_urls.length && !js_modules.length) {\n on_load()\n }\n };\n\n function inject_raw_css(css) {\n const element = document.createElement(\"style\");\n element.appendChild(document.createTextNode(css));\n document.body.appendChild(element);\n }\n\n var js_urls = [];\n var js_modules = [];\n var js_exports = {};\n var css_urls = [];\n var inline_js = [ function(Bokeh) {\n Bokeh.set_log_level(\"info\");\n },\nfunction(Bokeh) {} // ensure no trailing comma for IE\n ];\n\n function run_inline_js() {\n if ((root.Bokeh !== undefined) || (force === true)) {\n for (var i = 0; i < inline_js.length; i++) {\n inline_js[i].call(root, root.Bokeh);\n }\n // Cache old bokeh versions\n if (Bokeh != undefined && !reloading) {\n\tvar NewBokeh = root.Bokeh;\n\tif (Bokeh.versions === undefined) {\n\t Bokeh.versions = new Map();\n\t}\n\tif (NewBokeh.version !== Bokeh.version) {\n\t Bokeh.versions.set(NewBokeh.version, NewBokeh)\n\t}\n\troot.Bokeh = Bokeh;\n }} else if (Date.now() < root._bokeh_timeout) {\n setTimeout(run_inline_js, 100);\n } else if (!root._bokeh_failed_load) {\n console.log(\"Bokeh: BokehJS failed to load within specified timeout.\");\n root._bokeh_failed_load = true;\n }\n root._bokeh_is_initializing = false\n }\n\n function load_or_wait() {\n // Implement a backoff loop that tries to ensure we do not load multiple\n // versions of Bokeh and its dependencies at the same time.\n // In recent versions we use the root._bokeh_is_initializing flag\n // to determine whether there is an ongoing attempt to initialize\n // bokeh, however for backward compatibility we also try to ensure\n // that we do not start loading a newer (Panel>=1.0 and Bokeh>3) version\n // before older versions are fully initialized.\n if (root._bokeh_is_initializing && Date.now() > root._bokeh_timeout) {\n root._bokeh_is_initializing = false;\n root._bokeh_onload_callbacks = undefined;\n console.log(\"Bokeh: BokehJS was loaded multiple times but one version failed to initialize.\");\n load_or_wait();\n } else if (root._bokeh_is_initializing || (typeof root._bokeh_is_initializing === \"undefined\" && root._bokeh_onload_callbacks !== undefined)) {\n setTimeout(load_or_wait, 100);\n } else {\n Bokeh = root.Bokeh;\n bokeh_loaded = Bokeh != null && (Bokeh.version === py_version || (Bokeh.versions !== undefined && Bokeh.versions.has(py_version)));\n root._bokeh_is_initializing = true\n root._bokeh_onload_callbacks = []\n if (!reloading && (!bokeh_loaded || is_dev)) {\n\troot.Bokeh = undefined;\n }\n load_libs(css_urls, js_urls, js_modules, js_exports, function() {\n\tconsole.debug(\"Bokeh: BokehJS plotting callback run at\", now());\n\trun_inline_js();\n });\n }\n }\n // Give older versions of the autoload script a head-start to ensure\n // they initialize before we start loading newer version.\n setTimeout(load_or_wait, 100)\n}(window));" - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "application/javascript": [ - "\n", - "if ((window.PyViz === undefined) || (window.PyViz instanceof HTMLElement)) {\n", - " window.PyViz = {comms: {}, comm_status:{}, kernels:{}, receivers: {}, plot_index: []}\n", - "}\n", - "\n", - "\n", - " function JupyterCommManager() {\n", - " }\n", - "\n", - " JupyterCommManager.prototype.register_target = function(plot_id, comm_id, msg_handler) {\n", - " if (window.comm_manager || ((window.Jupyter !== undefined) && (Jupyter.notebook.kernel != null))) {\n", - " var comm_manager = window.comm_manager || Jupyter.notebook.kernel.comm_manager;\n", - " comm_manager.register_target(comm_id, function(comm) {\n", - " comm.on_msg(msg_handler);\n", - " });\n", - " } else if ((plot_id in window.PyViz.kernels) && (window.PyViz.kernels[plot_id])) {\n", - " window.PyViz.kernels[plot_id].registerCommTarget(comm_id, function(comm) {\n", - " comm.onMsg = msg_handler;\n", - " });\n", - " } else if (typeof google != 'undefined' && google.colab.kernel != null) {\n", - " google.colab.kernel.comms.registerTarget(comm_id, (comm) => {\n", - " var messages = comm.messages[Symbol.asyncIterator]();\n", - " function processIteratorResult(result) {\n", - " var message = result.value;\n", - " console.log(message)\n", - " var content = {data: message.data, comm_id};\n", - " var buffers = []\n", - " for (var buffer of message.buffers || []) {\n", - " buffers.push(new DataView(buffer))\n", - " }\n", - " var metadata = message.metadata || {};\n", - " var msg = {content, buffers, metadata}\n", - " msg_handler(msg);\n", - " return messages.next().then(processIteratorResult);\n", - " }\n", - " return messages.next().then(processIteratorResult);\n", - " })\n", - " }\n", - " }\n", - "\n", - " JupyterCommManager.prototype.get_client_comm = function(plot_id, comm_id, msg_handler) {\n", - " if (comm_id in window.PyViz.comms) {\n", - " return window.PyViz.comms[comm_id];\n", - " } else if (window.comm_manager || ((window.Jupyter !== undefined) && (Jupyter.notebook.kernel != null))) {\n", - " var comm_manager = window.comm_manager || Jupyter.notebook.kernel.comm_manager;\n", - " var comm = comm_manager.new_comm(comm_id, {}, {}, {}, comm_id);\n", - " if (msg_handler) {\n", - " comm.on_msg(msg_handler);\n", - " }\n", - " } else if ((plot_id in window.PyViz.kernels) && (window.PyViz.kernels[plot_id])) {\n", - " var comm = window.PyViz.kernels[plot_id].connectToComm(comm_id);\n", - " comm.open();\n", - " if (msg_handler) {\n", - " comm.onMsg = msg_handler;\n", - " }\n", - " } else if (typeof google != 'undefined' && google.colab.kernel != null) {\n", - " var comm_promise = google.colab.kernel.comms.open(comm_id)\n", - " comm_promise.then((comm) => {\n", - " window.PyViz.comms[comm_id] = comm;\n", - " if (msg_handler) {\n", - " var messages = comm.messages[Symbol.asyncIterator]();\n", - " function processIteratorResult(result) {\n", - " var message = result.value;\n", - " var content = {data: message.data};\n", - " var metadata = message.metadata || {comm_id};\n", - " var msg = {content, metadata}\n", - " msg_handler(msg);\n", - " return messages.next().then(processIteratorResult);\n", - " }\n", - " return messages.next().then(processIteratorResult);\n", - " }\n", - " }) \n", - " var sendClosure = (data, metadata, buffers, disposeOnDone) => {\n", - " return comm_promise.then((comm) => {\n", - " comm.send(data, metadata, buffers, disposeOnDone);\n", - " });\n", - " };\n", - " var comm = {\n", - " send: sendClosure\n", - " };\n", - " }\n", - " window.PyViz.comms[comm_id] = comm;\n", - " return comm;\n", - " }\n", - " window.PyViz.comm_manager = new JupyterCommManager();\n", - " \n", - "\n", - "\n", - "var JS_MIME_TYPE = 'application/javascript';\n", - "var HTML_MIME_TYPE = 'text/html';\n", - "var EXEC_MIME_TYPE = 'application/vnd.holoviews_exec.v0+json';\n", - "var CLASS_NAME = 'output';\n", - "\n", - "/**\n", - " * Render data to the DOM node\n", - " */\n", - "function render(props, node) {\n", - " var div = document.createElement(\"div\");\n", - " var script = document.createElement(\"script\");\n", - " node.appendChild(div);\n", - " node.appendChild(script);\n", - "}\n", - "\n", - "/**\n", - " * Handle when a new output is added\n", - " */\n", - "function handle_add_output(event, handle) {\n", - " var output_area = handle.output_area;\n", - " var output = handle.output;\n", - " if ((output.data == undefined) || (!output.data.hasOwnProperty(EXEC_MIME_TYPE))) {\n", - " return\n", - " }\n", - " var id = output.metadata[EXEC_MIME_TYPE][\"id\"];\n", - " var toinsert = output_area.element.find(\".\" + CLASS_NAME.split(' ')[0]);\n", - " if (id !== undefined) {\n", - " var nchildren = toinsert.length;\n", - " var html_node = toinsert[nchildren-1].children[0];\n", - " html_node.innerHTML = output.data[HTML_MIME_TYPE];\n", - " var scripts = [];\n", - " var nodelist = html_node.querySelectorAll(\"script\");\n", - " for (var i in nodelist) {\n", - " if (nodelist.hasOwnProperty(i)) {\n", - " scripts.push(nodelist[i])\n", - " }\n", - " }\n", - "\n", - " scripts.forEach( function (oldScript) {\n", - " var newScript = document.createElement(\"script\");\n", - " var attrs = [];\n", - " var nodemap = oldScript.attributes;\n", - " for (var j in nodemap) {\n", - " if (nodemap.hasOwnProperty(j)) {\n", - " attrs.push(nodemap[j])\n", - " }\n", - " }\n", - " attrs.forEach(function(attr) { newScript.setAttribute(attr.name, attr.value) });\n", - " newScript.appendChild(document.createTextNode(oldScript.innerHTML));\n", - " oldScript.parentNode.replaceChild(newScript, oldScript);\n", - " });\n", - " if (JS_MIME_TYPE in output.data) {\n", - " toinsert[nchildren-1].children[1].textContent = output.data[JS_MIME_TYPE];\n", - " }\n", - " output_area._hv_plot_id = id;\n", - " if ((window.Bokeh !== undefined) && (id in Bokeh.index)) {\n", - " window.PyViz.plot_index[id] = Bokeh.index[id];\n", - " } else {\n", - " window.PyViz.plot_index[id] = null;\n", - " }\n", - " } else if (output.metadata[EXEC_MIME_TYPE][\"server_id\"] !== undefined) {\n", - " var bk_div = document.createElement(\"div\");\n", - " bk_div.innerHTML = output.data[HTML_MIME_TYPE];\n", - " var script_attrs = bk_div.children[0].attributes;\n", - " for (var i = 0; i < script_attrs.length; i++) {\n", - " toinsert[toinsert.length - 1].childNodes[1].setAttribute(script_attrs[i].name, script_attrs[i].value);\n", - " }\n", - " // store reference to server id on output_area\n", - " output_area._bokeh_server_id = output.metadata[EXEC_MIME_TYPE][\"server_id\"];\n", - " }\n", - "}\n", - "\n", - "/**\n", - " * Handle when an output is cleared or removed\n", - " */\n", - "function handle_clear_output(event, handle) {\n", - " var id = handle.cell.output_area._hv_plot_id;\n", - " var server_id = handle.cell.output_area._bokeh_server_id;\n", - " if (((id === undefined) || !(id in PyViz.plot_index)) && (server_id !== undefined)) { return; }\n", - " var comm = window.PyViz.comm_manager.get_client_comm(\"hv-extension-comm\", \"hv-extension-comm\", function () {});\n", - " if (server_id !== null) {\n", - " comm.send({event_type: 'server_delete', 'id': server_id});\n", - " return;\n", - " } else if (comm !== null) {\n", - " comm.send({event_type: 'delete', 'id': id});\n", - " }\n", - " delete PyViz.plot_index[id];\n", - " if ((window.Bokeh !== undefined) & (id in window.Bokeh.index)) {\n", - " var doc = window.Bokeh.index[id].model.document\n", - " doc.clear();\n", - " const i = window.Bokeh.documents.indexOf(doc);\n", - " if (i > -1) {\n", - " window.Bokeh.documents.splice(i, 1);\n", - " }\n", - " }\n", - "}\n", - "\n", - "/**\n", - " * Handle kernel restart event\n", - " */\n", - "function handle_kernel_cleanup(event, handle) {\n", - " delete PyViz.comms[\"hv-extension-comm\"];\n", - " window.PyViz.plot_index = {}\n", - "}\n", - "\n", - "/**\n", - " * Handle update_display_data messages\n", - " */\n", - "function handle_update_output(event, handle) {\n", - " handle_clear_output(event, {cell: {output_area: handle.output_area}})\n", - " handle_add_output(event, handle)\n", - "}\n", - "\n", - "function register_renderer(events, OutputArea) {\n", - " function append_mime(data, metadata, element) {\n", - " // create a DOM node to render to\n", - " var toinsert = this.create_output_subarea(\n", - " metadata,\n", - " CLASS_NAME,\n", - " EXEC_MIME_TYPE\n", - " );\n", - " this.keyboard_manager.register_events(toinsert);\n", - " // Render to node\n", - " var props = {data: data, metadata: metadata[EXEC_MIME_TYPE]};\n", - " render(props, toinsert[0]);\n", - " element.append(toinsert);\n", - " return toinsert\n", - " }\n", - "\n", - " events.on('output_added.OutputArea', handle_add_output);\n", - " events.on('output_updated.OutputArea', handle_update_output);\n", - " events.on('clear_output.CodeCell', handle_clear_output);\n", - " events.on('delete.Cell', handle_clear_output);\n", - " events.on('kernel_ready.Kernel', handle_kernel_cleanup);\n", - "\n", - " OutputArea.prototype.register_mime_type(EXEC_MIME_TYPE, append_mime, {\n", - " safe: true,\n", - " index: 0\n", - " });\n", - "}\n", - "\n", - "if (window.Jupyter !== undefined) {\n", - " try {\n", - " var events = require('base/js/events');\n", - " var OutputArea = require('notebook/js/outputarea').OutputArea;\n", - " if (OutputArea.prototype.mime_types().indexOf(EXEC_MIME_TYPE) == -1) {\n", - " register_renderer(events, OutputArea);\n", - " }\n", - " } catch(err) {\n", - " }\n", - "}\n" - ], - "application/vnd.holoviews_load.v0+json": "\nif ((window.PyViz === undefined) || (window.PyViz instanceof HTMLElement)) {\n window.PyViz = {comms: {}, comm_status:{}, kernels:{}, receivers: {}, plot_index: []}\n}\n\n\n function JupyterCommManager() {\n }\n\n JupyterCommManager.prototype.register_target = function(plot_id, comm_id, msg_handler) {\n if (window.comm_manager || ((window.Jupyter !== undefined) && (Jupyter.notebook.kernel != null))) {\n var comm_manager = window.comm_manager || Jupyter.notebook.kernel.comm_manager;\n comm_manager.register_target(comm_id, function(comm) {\n comm.on_msg(msg_handler);\n });\n } else if ((plot_id in window.PyViz.kernels) && (window.PyViz.kernels[plot_id])) {\n window.PyViz.kernels[plot_id].registerCommTarget(comm_id, function(comm) {\n comm.onMsg = msg_handler;\n });\n } else if (typeof google != 'undefined' && google.colab.kernel != null) {\n google.colab.kernel.comms.registerTarget(comm_id, (comm) => {\n var messages = comm.messages[Symbol.asyncIterator]();\n function processIteratorResult(result) {\n var message = result.value;\n console.log(message)\n var content = {data: message.data, comm_id};\n var buffers = []\n for (var buffer of message.buffers || []) {\n buffers.push(new DataView(buffer))\n }\n var metadata = message.metadata || {};\n var msg = {content, buffers, metadata}\n msg_handler(msg);\n return messages.next().then(processIteratorResult);\n }\n return messages.next().then(processIteratorResult);\n })\n }\n }\n\n JupyterCommManager.prototype.get_client_comm = function(plot_id, comm_id, msg_handler) {\n if (comm_id in window.PyViz.comms) {\n return window.PyViz.comms[comm_id];\n } else if (window.comm_manager || ((window.Jupyter !== undefined) && (Jupyter.notebook.kernel != null))) {\n var comm_manager = window.comm_manager || Jupyter.notebook.kernel.comm_manager;\n var comm = comm_manager.new_comm(comm_id, {}, {}, {}, comm_id);\n if (msg_handler) {\n comm.on_msg(msg_handler);\n }\n } else if ((plot_id in window.PyViz.kernels) && (window.PyViz.kernels[plot_id])) {\n var comm = window.PyViz.kernels[plot_id].connectToComm(comm_id);\n comm.open();\n if (msg_handler) {\n comm.onMsg = msg_handler;\n }\n } else if (typeof google != 'undefined' && google.colab.kernel != null) {\n var comm_promise = google.colab.kernel.comms.open(comm_id)\n comm_promise.then((comm) => {\n window.PyViz.comms[comm_id] = comm;\n if (msg_handler) {\n var messages = comm.messages[Symbol.asyncIterator]();\n function processIteratorResult(result) {\n var message = result.value;\n var content = {data: message.data};\n var metadata = message.metadata || {comm_id};\n var msg = {content, metadata}\n msg_handler(msg);\n return messages.next().then(processIteratorResult);\n }\n return messages.next().then(processIteratorResult);\n }\n }) \n var sendClosure = (data, metadata, buffers, disposeOnDone) => {\n return comm_promise.then((comm) => {\n comm.send(data, metadata, buffers, disposeOnDone);\n });\n };\n var comm = {\n send: sendClosure\n };\n }\n window.PyViz.comms[comm_id] = comm;\n return comm;\n }\n window.PyViz.comm_manager = new JupyterCommManager();\n \n\n\nvar JS_MIME_TYPE = 'application/javascript';\nvar HTML_MIME_TYPE = 'text/html';\nvar EXEC_MIME_TYPE = 'application/vnd.holoviews_exec.v0+json';\nvar CLASS_NAME = 'output';\n\n/**\n * Render data to the DOM node\n */\nfunction render(props, node) {\n var div = document.createElement(\"div\");\n var script = document.createElement(\"script\");\n node.appendChild(div);\n node.appendChild(script);\n}\n\n/**\n * Handle when a new output is added\n */\nfunction handle_add_output(event, handle) {\n var output_area = handle.output_area;\n var output = handle.output;\n if ((output.data == undefined) || (!output.data.hasOwnProperty(EXEC_MIME_TYPE))) {\n return\n }\n var id = output.metadata[EXEC_MIME_TYPE][\"id\"];\n var toinsert = output_area.element.find(\".\" + CLASS_NAME.split(' ')[0]);\n if (id !== undefined) {\n var nchildren = toinsert.length;\n var html_node = toinsert[nchildren-1].children[0];\n html_node.innerHTML = output.data[HTML_MIME_TYPE];\n var scripts = [];\n var nodelist = html_node.querySelectorAll(\"script\");\n for (var i in nodelist) {\n if (nodelist.hasOwnProperty(i)) {\n scripts.push(nodelist[i])\n }\n }\n\n scripts.forEach( function (oldScript) {\n var newScript = document.createElement(\"script\");\n var attrs = [];\n var nodemap = oldScript.attributes;\n for (var j in nodemap) {\n if (nodemap.hasOwnProperty(j)) {\n attrs.push(nodemap[j])\n }\n }\n attrs.forEach(function(attr) { newScript.setAttribute(attr.name, attr.value) });\n newScript.appendChild(document.createTextNode(oldScript.innerHTML));\n oldScript.parentNode.replaceChild(newScript, oldScript);\n });\n if (JS_MIME_TYPE in output.data) {\n toinsert[nchildren-1].children[1].textContent = output.data[JS_MIME_TYPE];\n }\n output_area._hv_plot_id = id;\n if ((window.Bokeh !== undefined) && (id in Bokeh.index)) {\n window.PyViz.plot_index[id] = Bokeh.index[id];\n } else {\n window.PyViz.plot_index[id] = null;\n }\n } else if (output.metadata[EXEC_MIME_TYPE][\"server_id\"] !== undefined) {\n var bk_div = document.createElement(\"div\");\n bk_div.innerHTML = output.data[HTML_MIME_TYPE];\n var script_attrs = bk_div.children[0].attributes;\n for (var i = 0; i < script_attrs.length; i++) {\n toinsert[toinsert.length - 1].childNodes[1].setAttribute(script_attrs[i].name, script_attrs[i].value);\n }\n // store reference to server id on output_area\n output_area._bokeh_server_id = output.metadata[EXEC_MIME_TYPE][\"server_id\"];\n }\n}\n\n/**\n * Handle when an output is cleared or removed\n */\nfunction handle_clear_output(event, handle) {\n var id = handle.cell.output_area._hv_plot_id;\n var server_id = handle.cell.output_area._bokeh_server_id;\n if (((id === undefined) || !(id in PyViz.plot_index)) && (server_id !== undefined)) { return; }\n var comm = window.PyViz.comm_manager.get_client_comm(\"hv-extension-comm\", \"hv-extension-comm\", function () {});\n if (server_id !== null) {\n comm.send({event_type: 'server_delete', 'id': server_id});\n return;\n } else if (comm !== null) {\n comm.send({event_type: 'delete', 'id': id});\n }\n delete PyViz.plot_index[id];\n if ((window.Bokeh !== undefined) & (id in window.Bokeh.index)) {\n var doc = window.Bokeh.index[id].model.document\n doc.clear();\n const i = window.Bokeh.documents.indexOf(doc);\n if (i > -1) {\n window.Bokeh.documents.splice(i, 1);\n }\n }\n}\n\n/**\n * Handle kernel restart event\n */\nfunction handle_kernel_cleanup(event, handle) {\n delete PyViz.comms[\"hv-extension-comm\"];\n window.PyViz.plot_index = {}\n}\n\n/**\n * Handle update_display_data messages\n */\nfunction handle_update_output(event, handle) {\n handle_clear_output(event, {cell: {output_area: handle.output_area}})\n handle_add_output(event, handle)\n}\n\nfunction register_renderer(events, OutputArea) {\n function append_mime(data, metadata, element) {\n // create a DOM node to render to\n var toinsert = this.create_output_subarea(\n metadata,\n CLASS_NAME,\n EXEC_MIME_TYPE\n );\n this.keyboard_manager.register_events(toinsert);\n // Render to node\n var props = {data: data, metadata: metadata[EXEC_MIME_TYPE]};\n render(props, toinsert[0]);\n element.append(toinsert);\n return toinsert\n }\n\n events.on('output_added.OutputArea', handle_add_output);\n events.on('output_updated.OutputArea', handle_update_output);\n events.on('clear_output.CodeCell', handle_clear_output);\n events.on('delete.Cell', handle_clear_output);\n events.on('kernel_ready.Kernel', handle_kernel_cleanup);\n\n OutputArea.prototype.register_mime_type(EXEC_MIME_TYPE, append_mime, {\n safe: true,\n index: 0\n });\n}\n\nif (window.Jupyter !== undefined) {\n try {\n var events = require('base/js/events');\n var OutputArea = require('notebook/js/outputarea').OutputArea;\n if (OutputArea.prototype.mime_types().indexOf(EXEC_MIME_TYPE) == -1) {\n register_renderer(events, OutputArea);\n }\n } catch(err) {\n }\n}\n" - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/html": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "%matplotlib widget\n", "\n", @@ -1351,9 +117,7 @@ { "cell_type": "markdown", "id": "19ded922-7e2e-42a4-9435-5399d92fb289", - "metadata": { - "user_expressions": [] - }, + "metadata": {}, "source": [ "## Greenland subglacial lakes\n", "\n", @@ -1407,106 +171,12 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": null, "id": "7a5d4ad8-cef2-4d6e-bc88-2ee1d3673c8e", "metadata": { "tags": [] }, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
Name / LocationLat. oNLon. oELake TypeReferences
0NaN78.000000-48.000000NaNEkholm et al. (1998)
1L278.005022-68.393971StablePalmer et al. (2013)
2L177.969500-68.440875StablePalmer et al. (2013)
3Flade Isblink ice cap81.160000-16.580000ActiveWillis et al. (2015)
4Inuppaat Quuat67.611136-48.709000ActiveHowat et al. (2015); Palmer et al. (2015)
\n", - "
" - ], - "text/plain": [ - " Name / Location Lat. oN Lon. oE Lake Type \\\n", - "0 NaN 78.000000 -48.000000 NaN \n", - "1 L2 78.005022 -68.393971 Stable \n", - "2 L1 77.969500 -68.440875 Stable \n", - "3 Flade Isblink ice cap 81.160000 -16.580000 Active \n", - "4 Inuppaat Quuat 67.611136 -48.709000 Active \n", - "\n", - " References \n", - "0 Ekholm et al. (1998) \n", - "1 Palmer et al. (2013) \n", - "2 Palmer et al. (2013) \n", - "3 Willis et al. (2015) \n", - "4 Howat et al. (2015); Palmer et al. (2015) " - ] - }, - "execution_count": 2, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "# Read in spreadsheet using pandas read_excel\n", "use_cols = ['Name / Location', 'Lat. oN', 'Lon. oE', 'Lake Type', 'References']\n", @@ -1540,106 +210,12 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": null, "id": "047bbc78-a049-4055-8002-425d6881b70a", "metadata": { "tags": [] }, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
Name / LocationLat. oNLon. oELake TypeReferences
0NaN78.000000-48.000000NaNEkholm et al. (1998)
1L278.005022-68.393971StablePalmer et al. (2013)
2L177.969500-68.440875StablePalmer et al. (2013)
3Flade Isblink ice cap81.160000-16.580000ActiveWillis et al. (2015)
4Inuppaat Quuat67.611136-48.709000ActiveHowat et al. (2015); Palmer et al. (2015)
\n", - "
" - ], - "text/plain": [ - " Name / Location Lat. oN Lon. oE Lake Type \\\n", - "0 NaN 78.000000 -48.000000 NaN \n", - "1 L2 78.005022 -68.393971 Stable \n", - "2 L1 77.969500 -68.440875 Stable \n", - "3 Flade Isblink ice cap 81.160000 -16.580000 Active \n", - "4 Inuppaat Quuat 67.611136 -48.709000 Active \n", - "\n", - " References \n", - "0 Ekholm et al. (1998) \n", - "1 Palmer et al. (2013) \n", - "2 Palmer et al. (2013) \n", - "3 Willis et al. (2015) \n", - "4 Howat et al. (2015); Palmer et al. (2015) " - ] - }, - "execution_count": 3, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "# Read in spreadsheet using pandas read_excel\n", "url = 'https://static-content.springer.com/esm/art%3A10.1038%2Fs43017-021-00246-9/MediaObjects/43017_2021_246_MOESM1_ESM.xlsx'\n", @@ -1654,190 +230,19 @@ { "cell_type": "markdown", "id": "539d0285-380e-4e16-9979-73f73170e1cd", - "metadata": { - "user_expressions": [] - }, + "metadata": {}, "source": [ "This is looking good, but we can make it even better by storing the data in a GeoPandas GeoDataFrame which offers additional functionality beyond pandas. You can add a geometry column of Shapely objects that make geospatial data processing and visualization easier. Here we have Shapely points:" ] }, { "cell_type": "code", - "execution_count": 4, + "execution_count": null, "id": "0a7195c0-606b-4467-8b2d-1deb94030b04", "metadata": { "tags": [] }, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
Name / LocationLat. oNLon. oELake TypeReferencesgeometry
0NaN78.000000-48.000000NaNEkholm et al. (1998)POINT (-48.00000 78.00000)
1L278.005022-68.393971StablePalmer et al. (2013)POINT (-68.39397 78.00502)
2L177.969500-68.440875StablePalmer et al. (2013)POINT (-68.44088 77.96950)
3Flade Isblink ice cap81.160000-16.580000ActiveWillis et al. (2015)POINT (-16.58000 81.16000)
4Inuppaat Quuat67.611136-48.709000ActiveHowat et al. (2015); Palmer et al. (2015)POINT (-48.70900 67.61114)
.....................
59Sermeq Kujalleq (Jakobshavn)69.109843-42.055159StableBowling et al. (2019)POINT (-42.05516 69.10984)
60Sermeq Kujalleq (Jakobshavn)69.108047-41.954370StableBowling et al. (2019)POINT (-41.95437 69.10805)
61Isunguata Sermia 167.180000-50.188000ActiveLivingstone et al. (2019)POINT (-50.18800 67.18000)
62Isunguata Sermia 267.178000-50.149000ActiveLivingstone et al. (2019)POINT (-50.14900 67.17800)
63Isunguata Sermia 367.180000-50.128000ActiveLivingstone et al. (2019)POINT (-50.12800 67.18000)
\n", - "

64 rows × 6 columns

\n", - "
" - ], - "text/plain": [ - " Name / Location Lat. oN Lon. oE Lake Type \\\n", - "0 NaN 78.000000 -48.000000 NaN \n", - "1 L2 78.005022 -68.393971 Stable \n", - "2 L1 77.969500 -68.440875 Stable \n", - "3 Flade Isblink ice cap 81.160000 -16.580000 Active \n", - "4 Inuppaat Quuat 67.611136 -48.709000 Active \n", - ".. ... ... ... ... \n", - "59 Sermeq Kujalleq (Jakobshavn) 69.109843 -42.055159 Stable \n", - "60 Sermeq Kujalleq (Jakobshavn) 69.108047 -41.954370 Stable \n", - "61 Isunguata Sermia 1 67.180000 -50.188000 Active \n", - "62 Isunguata Sermia 2 67.178000 -50.149000 Active \n", - "63 Isunguata Sermia 3 67.180000 -50.128000 Active \n", - "\n", - " References geometry \n", - "0 Ekholm et al. (1998) POINT (-48.00000 78.00000) \n", - "1 Palmer et al. (2013) POINT (-68.39397 78.00502) \n", - "2 Palmer et al. (2013) POINT (-68.44088 77.96950) \n", - "3 Willis et al. (2015) POINT (-16.58000 81.16000) \n", - "4 Howat et al. (2015); Palmer et al. (2015) POINT (-48.70900 67.61114) \n", - ".. ... ... \n", - "59 Bowling et al. (2019) POINT (-42.05516 69.10984) \n", - "60 Bowling et al. (2019) POINT (-41.95437 69.10805) \n", - "61 Livingstone et al. (2019) POINT (-50.18800 67.18000) \n", - "62 Livingstone et al. (2019) POINT (-50.14900 67.17800) \n", - "63 Livingstone et al. (2019) POINT (-50.12800 67.18000) \n", - "\n", - "[64 rows x 6 columns]" - ] - }, - "execution_count": 4, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "# Create GeoPandas GeoDataFrame from Pandas DataFrame\n", "gdf = gpd.GeoDataFrame(\n", @@ -1864,134 +269,12 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": null, "id": "9d1751a6-f1fa-4e66-9bc4-c0fed6dcf6ba", "metadata": { "tags": [] }, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
Name / LocationLat. oNLon. oELake TypeReferencesgeometry
3Flade Isblink ice cap81.160000-16.580000ActiveWillis et al. (2015)POINT (-16.58000 81.16000)
4Inuppaat Quuat67.611136-48.709000ActiveHowat et al. (2015); Palmer et al. (2015)POINT (-48.70900 67.61114)
5Sioqqap Sermia, [SS1]63.541856-48.450597ActiveBowling et al. (2019)POINT (-48.45060 63.54186)
6Sioqqap Sermia, [SS2]63.260248-48.206633ActiveBowling et al. (2019)POINT (-48.20663 63.26025)
61Isunguata Sermia 167.180000-50.188000ActiveLivingstone et al. (2019)POINT (-50.18800 67.18000)
62Isunguata Sermia 267.178000-50.149000ActiveLivingstone et al. (2019)POINT (-50.14900 67.17800)
63Isunguata Sermia 367.180000-50.128000ActiveLivingstone et al. (2019)POINT (-50.12800 67.18000)
\n", - "
" - ], - "text/plain": [ - " Name / Location Lat. oN Lon. oE Lake Type \\\n", - "3 Flade Isblink ice cap 81.160000 -16.580000 Active \n", - "4 Inuppaat Quuat 67.611136 -48.709000 Active \n", - "5 Sioqqap Sermia, [SS1] 63.541856 -48.450597 Active \n", - "6 Sioqqap Sermia, [SS2] 63.260248 -48.206633 Active \n", - "61 Isunguata Sermia 1 67.180000 -50.188000 Active \n", - "62 Isunguata Sermia 2 67.178000 -50.149000 Active \n", - "63 Isunguata Sermia 3 67.180000 -50.128000 Active \n", - "\n", - " References geometry \n", - "3 Willis et al. (2015) POINT (-16.58000 81.16000) \n", - "4 Howat et al. (2015); Palmer et al. (2015) POINT (-48.70900 67.61114) \n", - "5 Bowling et al. (2019) POINT (-48.45060 63.54186) \n", - "6 Bowling et al. (2019) POINT (-48.20663 63.26025) \n", - "61 Livingstone et al. (2019) POINT (-50.18800 67.18000) \n", - "62 Livingstone et al. (2019) POINT (-50.14900 67.17800) \n", - "63 Livingstone et al. (2019) POINT (-50.12800 67.18000) " - ] - }, - "execution_count": 5, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "# Let's look at Greenland's active subglacial lake inventory\n", "gdf[gdf['Lake Type'] == 'Active']" @@ -2039,38 +322,12 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": null, "id": "d33b2914-2a57-40aa-ba26-113e15adf373", "metadata": { "tags": [] }, - "outputs": [ - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "95840c19526b422b8e869d0ac49758e6", - "version_major": 2, - "version_minor": 0 - }, - "image/png": "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", - "text/html": [ - "\n", - "
\n", - "
\n", - " Figure\n", - "
\n", - " \n", - "
\n", - " " - ], - "text/plain": [ - "Canvas(toolbar=Toolbar(toolitems=[('Home', 'Reset original view', 'home', 'home'), ('Back', 'Back to previous …" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "# Load \"Natural Earth” countries dataset, bundled with GeoPandas\n", "world = gpd.read_file(gpd.datasets.get_path('naturalearth_lowres'))\n", @@ -2108,143 +365,12 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": null, "id": "24e94b90-a04d-4d8a-9a8b-fb499f9bbc53", "metadata": { "tags": [] }, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
Name / LocationLat. oNLon. oELake TypeReferencesgeometry
3Flade Isblink ice cap81.160000-16.580000ActiveWillis et al. (2015)POLYGON ((-16.06723 81.11390, -16.09787 81.106...
4Inuppaat Quuat67.611136-48.709000ActiveHowat et al. (2015); Palmer et al. (2015)POLYGON ((-48.47640 67.61446, -48.47613 67.605...
5Sioqqap Sermia, [SS1]63.541856-48.450597ActiveBowling et al. (2019)POLYGON ((-48.25472 63.54482, -48.25457 63.536...
6Sioqqap Sermia, [SS2]63.260248-48.206633ActiveBowling et al. (2019)POLYGON ((-48.01287 63.26285, -48.01281 63.254...
61Isunguata Sermia 167.180000-50.188000ActiveLivingstone et al. (2019)POLYGON ((-49.96016 67.18562, -49.95932 67.176...
62Isunguata Sermia 267.178000-50.149000ActiveLivingstone et al. (2019)POLYGON ((-49.92117 67.18356, -49.92035 67.174...
63Isunguata Sermia 367.180000-50.128000ActiveLivingstone et al. (2019)POLYGON ((-49.90015 67.18552, -49.89933 67.176...
\n", - "
" - ], - "text/plain": [ - " Name / Location Lat. oN Lon. oE Lake Type \\\n", - "3 Flade Isblink ice cap 81.160000 -16.580000 Active \n", - "4 Inuppaat Quuat 67.611136 -48.709000 Active \n", - "5 Sioqqap Sermia, [SS1] 63.541856 -48.450597 Active \n", - "6 Sioqqap Sermia, [SS2] 63.260248 -48.206633 Active \n", - "61 Isunguata Sermia 1 67.180000 -50.188000 Active \n", - "62 Isunguata Sermia 2 67.178000 -50.149000 Active \n", - "63 Isunguata Sermia 3 67.180000 -50.128000 Active \n", - "\n", - " References \\\n", - "3 Willis et al. (2015) \n", - "4 Howat et al. (2015); Palmer et al. (2015) \n", - "5 Bowling et al. (2019) \n", - "6 Bowling et al. (2019) \n", - "61 Livingstone et al. (2019) \n", - "62 Livingstone et al. (2019) \n", - "63 Livingstone et al. (2019) \n", - "\n", - " geometry \n", - "3 POLYGON ((-16.06723 81.11390, -16.09787 81.106... \n", - "4 POLYGON ((-48.47640 67.61446, -48.47613 67.605... \n", - "5 POLYGON ((-48.25472 63.54482, -48.25457 63.536... \n", - "6 POLYGON ((-48.01287 63.26285, -48.01281 63.254... \n", - "61 POLYGON ((-49.96016 67.18562, -49.95932 67.176... \n", - "62 POLYGON ((-49.92117 67.18356, -49.92035 67.174... \n", - "63 POLYGON ((-49.90015 67.18552, -49.89933 67.176... " - ] - }, - "execution_count": 7, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "# Create GeoSeries of our GeoDataFrame that converts to Arcic polar stereographic projection \n", "# and makes 10-km radius buffered polygon around each lake point\n", @@ -2328,25 +454,41 @@ "### Using icepyx to simplify searching for ICESat-2 data\n", "[icepyx](https://icepyx.readthedocs.io/en/latest/) is a community and Python software library that simplifies the process of searching (querying), accessing (via download or in the cloud), and working with (including subsetting, visualizing, and reading in) ICESat-2 data products. A series of [examples](https://github.com/icesat2py/icepyx/tree/main/doc/source/example_notebooks) introduce users to its functionality, and the icepyx community always welcomes new members, feature requests, bug reports, etc.\n", "\n", - "To search for data spatially, icepyx accepts shapefiles, kml files, and geopackage files, as well as bounding boxes and polygons, as input bounding regions. So we'll first save one of the lakes' geometries as a geopackage and use it to query ICESat-2 data for that region." + "To search for data spatially, icepyx accepts shapefiles, kml files, and geopackage files, as well as bounding boxes and polygons, as input bounding regions. We have two options for supplying this information: (1) save one of the lakes' geometries as a geopackage or (2) extract the exterior coordinates and supply them directly. You may run either of the next two cells; then we'll use the spatial information to query ICESat-2 data for that region." ] }, { "cell_type": "code", - "execution_count": 8, + "execution_count": null, "id": "a6ea8f8c-ce47-4090-919f-d30863309495", "metadata": { "tags": [] }, "outputs": [], "source": [ + "# (1) save one of the lakes' geometries as a geopackage\n", "# Export to geopackage to subset ICESat-2 data\n", - "gdf_polys[gdf_polys['Name / Location'] == 'Flade Isblink ice cap'].to_file(os.getcwd() + '/Flade_Isblink_poly.gpkg')" + "gdf_polys[gdf_polys['Name / Location'] == 'Flade Isblink ice cap'].to_file(os.getcwd() + '/Flade_Isblink_poly.gpkg')\n", + "spatial_extent = 'Flade_Isblink_poly.gpkg'" ] }, { "cell_type": "code", - "execution_count": 9, + "execution_count": null, + "id": "3f3f1628-0fc1-407c-a8e5-a85cb8735345", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "# (2) use the shapely package to supply the polygon coordinates directly as a list\n", + "from shapely.geometry import mapping\n", + "spatial_extent = list(mapping(gdf_polys[gdf_polys['Name / Location'] == 'Flade Isblink ice cap'].geometry.iloc[0])[\"coordinates\"][0])" + ] + }, + { + "cell_type": "code", + "execution_count": null, "id": "3e15602f-3fc1-40de-9519-a75ae5b3b4b1", "metadata": { "tags": [] @@ -2355,13 +497,12 @@ "source": [ "# Specifying the necessary icepyx parameters\n", "short_name = 'ATL15' # The data product we would like to query\n", - "spatial_extent = 'Flade_Isblink_poly.gpkg'\n", "date_range = ['2018-09-15','2023-03-02']" ] }, { "cell_type": "code", - "execution_count": 10, + "execution_count": null, "id": "1a352b60-b203-47d6-9785-2cfdbcfdeb6b", "metadata": { "tags": [] @@ -2385,749 +526,12 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": null, "id": "e852347c-fafd-4db0-b81e-e70e3e98ed98", "metadata": { "tags": [] }, - "outputs": [ - { - "data": { - "application/javascript": [ - "(function(root) {\n", - " function now() {\n", - " return new Date();\n", - " }\n", - "\n", - " var force = true;\n", - " var py_version = '3.2.2'.replace('rc', '-rc.').replace('.dev', '-dev.');\n", - " var is_dev = py_version.indexOf(\"+\") !== -1 || py_version.indexOf(\"-\") !== -1;\n", - " var reloading = false;\n", - " var Bokeh = root.Bokeh;\n", - " var bokeh_loaded = Bokeh != null && (Bokeh.version === py_version || (Bokeh.versions !== undefined && Bokeh.versions.has(py_version)));\n", - "\n", - " if (typeof (root._bokeh_timeout) === \"undefined\" || force) {\n", - " root._bokeh_timeout = Date.now() + 5000;\n", - " root._bokeh_failed_load = false;\n", - " }\n", - "\n", - " function run_callbacks() {\n", - " try {\n", - " root._bokeh_onload_callbacks.forEach(function(callback) {\n", - " if (callback != null)\n", - " callback();\n", - " });\n", - " } finally {\n", - " delete root._bokeh_onload_callbacks;\n", - " }\n", - " console.debug(\"Bokeh: all callbacks have finished\");\n", - " }\n", - "\n", - " function load_libs(css_urls, js_urls, js_modules, js_exports, callback) {\n", - " if (css_urls == null) css_urls = [];\n", - " if (js_urls == null) js_urls = [];\n", - " if (js_modules == null) js_modules = [];\n", - " if (js_exports == null) js_exports = {};\n", - "\n", - " root._bokeh_onload_callbacks.push(callback);\n", - "\n", - " if (root._bokeh_is_loading > 0) {\n", - " console.debug(\"Bokeh: BokehJS is being loaded, scheduling callback at\", now());\n", - " return null;\n", - " }\n", - " if (js_urls.length === 0 && js_modules.length === 0 && Object.keys(js_exports).length === 0) {\n", - " run_callbacks();\n", - " return null;\n", - " }\n", - " if (!reloading) {\n", - " console.debug(\"Bokeh: BokehJS not loaded, scheduling load and callback at\", now());\n", - " }\n", - "\n", - " function on_load() {\n", - " root._bokeh_is_loading--;\n", - " if (root._bokeh_is_loading === 0) {\n", - " console.debug(\"Bokeh: all BokehJS libraries/stylesheets loaded\");\n", - " run_callbacks()\n", - " }\n", - " }\n", - " window._bokeh_on_load = on_load\n", - "\n", - " function on_error() {\n", - " console.error(\"failed to load \" + url);\n", - " }\n", - "\n", - " var skip = [];\n", - " if (window.requirejs) {\n", - " window.requirejs.config({'packages': {}, 'paths': {'jspanel': 'https://cdn.jsdelivr.net/npm/jspanel4@4.12.0/dist/jspanel', 'jspanel-modal': 'https://cdn.jsdelivr.net/npm/jspanel4@4.12.0/dist/extensions/modal/jspanel.modal', 'jspanel-tooltip': 'https://cdn.jsdelivr.net/npm/jspanel4@4.12.0/dist/extensions/tooltip/jspanel.tooltip', 'jspanel-hint': 'https://cdn.jsdelivr.net/npm/jspanel4@4.12.0/dist/extensions/hint/jspanel.hint', 'jspanel-layout': 'https://cdn.jsdelivr.net/npm/jspanel4@4.12.0/dist/extensions/layout/jspanel.layout', 'jspanel-contextmenu': 'https://cdn.jsdelivr.net/npm/jspanel4@4.12.0/dist/extensions/contextmenu/jspanel.contextmenu', 'jspanel-dock': 'https://cdn.jsdelivr.net/npm/jspanel4@4.12.0/dist/extensions/dock/jspanel.dock', 'gridstack': 'https://cdn.jsdelivr.net/npm/gridstack@7.2.3/dist/gridstack-all', 'notyf': 'https://cdn.jsdelivr.net/npm/notyf@3/notyf.min'}, 'shim': {'jspanel': {'exports': 'jsPanel'}, 'gridstack': {'exports': 'GridStack'}}});\n", - " require([\"jspanel\"], function(jsPanel) {\n", - "\twindow.jsPanel = jsPanel\n", - "\ton_load()\n", - " })\n", - " require([\"jspanel-modal\"], function() {\n", - "\ton_load()\n", - " })\n", - " require([\"jspanel-tooltip\"], function() {\n", - "\ton_load()\n", - " })\n", - " require([\"jspanel-hint\"], function() {\n", - "\ton_load()\n", - " })\n", - " require([\"jspanel-layout\"], function() {\n", - "\ton_load()\n", - " })\n", - " require([\"jspanel-contextmenu\"], function() {\n", - "\ton_load()\n", - " })\n", - " require([\"jspanel-dock\"], function() {\n", - "\ton_load()\n", - " })\n", - " require([\"gridstack\"], function(GridStack) {\n", - "\twindow.GridStack = GridStack\n", - "\ton_load()\n", - " })\n", - " require([\"notyf\"], function() {\n", - "\ton_load()\n", - " })\n", - " root._bokeh_is_loading = css_urls.length + 9;\n", - " } else {\n", - " root._bokeh_is_loading = css_urls.length + js_urls.length + js_modules.length + Object.keys(js_exports).length;\n", - " }\n", - "\n", - " var existing_stylesheets = []\n", - " var links = document.getElementsByTagName('link')\n", - " for (var i = 0; i < links.length; i++) {\n", - " var link = links[i]\n", - " if (link.href != null) {\n", - "\texisting_stylesheets.push(link.href)\n", - " }\n", - " }\n", - " for (var i = 0; i < css_urls.length; i++) {\n", - " var url = css_urls[i];\n", - " if (existing_stylesheets.indexOf(url) !== -1) {\n", - "\ton_load()\n", - "\tcontinue;\n", - " }\n", - " const element = document.createElement(\"link\");\n", - " element.onload = on_load;\n", - " element.onerror = on_error;\n", - " element.rel = \"stylesheet\";\n", - " element.type = \"text/css\";\n", - " element.href = url;\n", - " console.debug(\"Bokeh: injecting link tag for BokehJS stylesheet: \", url);\n", - " document.body.appendChild(element);\n", - " } if (((window['jsPanel'] !== undefined) && (!(window['jsPanel'] instanceof HTMLElement))) || window.requirejs) {\n", - " var urls = ['https://cdn.holoviz.org/panel/1.2.3/dist/bundled/floatpanel/jspanel4@4.12.0/dist/jspanel.js', 'https://cdn.holoviz.org/panel/1.2.3/dist/bundled/floatpanel/jspanel4@4.12.0/dist/extensions/modal/jspanel.modal.js', 'https://cdn.holoviz.org/panel/1.2.3/dist/bundled/floatpanel/jspanel4@4.12.0/dist/extensions/tooltip/jspanel.tooltip.js', 'https://cdn.holoviz.org/panel/1.2.3/dist/bundled/floatpanel/jspanel4@4.12.0/dist/extensions/hint/jspanel.hint.js', 'https://cdn.holoviz.org/panel/1.2.3/dist/bundled/floatpanel/jspanel4@4.12.0/dist/extensions/layout/jspanel.layout.js', 'https://cdn.holoviz.org/panel/1.2.3/dist/bundled/floatpanel/jspanel4@4.12.0/dist/extensions/contextmenu/jspanel.contextmenu.js', 'https://cdn.holoviz.org/panel/1.2.3/dist/bundled/floatpanel/jspanel4@4.12.0/dist/extensions/dock/jspanel.dock.js'];\n", - " for (var i = 0; i < urls.length; i++) {\n", - " skip.push(urls[i])\n", - " }\n", - " } if (((window['GridStack'] !== undefined) && (!(window['GridStack'] instanceof HTMLElement))) || window.requirejs) {\n", - " var urls = ['https://cdn.holoviz.org/panel/1.2.3/dist/bundled/gridstack/gridstack@7.2.3/dist/gridstack-all.js'];\n", - " for (var i = 0; i < urls.length; i++) {\n", - " skip.push(urls[i])\n", - " }\n", - " } if (((window['Notyf'] !== undefined) && (!(window['Notyf'] instanceof HTMLElement))) || window.requirejs) {\n", - " var urls = ['https://cdn.holoviz.org/panel/1.2.3/dist/bundled/notificationarea/notyf@3/notyf.min.js'];\n", - " for (var i = 0; i < urls.length; i++) {\n", - " skip.push(urls[i])\n", - " }\n", - " } var existing_scripts = []\n", - " var scripts = document.getElementsByTagName('script')\n", - " for (var i = 0; i < scripts.length; i++) {\n", - " var script = scripts[i]\n", - " if (script.src != null) {\n", - "\texisting_scripts.push(script.src)\n", - " }\n", - " }\n", - " for (var i = 0; i < js_urls.length; i++) {\n", - " var url = js_urls[i];\n", - " if (skip.indexOf(url) !== -1 || existing_scripts.indexOf(url) !== -1) {\n", - "\tif (!window.requirejs) {\n", - "\t on_load();\n", - "\t}\n", - "\tcontinue;\n", - " }\n", - " var element = document.createElement('script');\n", - " element.onload = on_load;\n", - " element.onerror = on_error;\n", - " element.async = false;\n", - " element.src = url;\n", - " console.debug(\"Bokeh: injecting script tag for BokehJS library: \", url);\n", - " document.head.appendChild(element);\n", - " }\n", - " for (var i = 0; i < js_modules.length; i++) {\n", - " var url = js_modules[i];\n", - " if (skip.indexOf(url) !== -1 || existing_scripts.indexOf(url) !== -1) {\n", - "\tif (!window.requirejs) {\n", - "\t on_load();\n", - "\t}\n", - "\tcontinue;\n", - " }\n", - " var element = document.createElement('script');\n", - " element.onload = on_load;\n", - " element.onerror = on_error;\n", - " element.async = false;\n", - " element.src = url;\n", - " element.type = \"module\";\n", - " console.debug(\"Bokeh: injecting script tag for BokehJS library: \", url);\n", - " document.head.appendChild(element);\n", - " }\n", - " for (const name in js_exports) {\n", - " var url = js_exports[name];\n", - " if (skip.indexOf(url) >= 0 || root[name] != null) {\n", - "\tif (!window.requirejs) {\n", - "\t on_load();\n", - "\t}\n", - "\tcontinue;\n", - " }\n", - " var element = document.createElement('script');\n", - " element.onerror = on_error;\n", - " element.async = false;\n", - " element.type = \"module\";\n", - " console.debug(\"Bokeh: injecting script tag for BokehJS library: \", url);\n", - " element.textContent = `\n", - " import ${name} from \"${url}\"\n", - " window.${name} = ${name}\n", - " window._bokeh_on_load()\n", - " `\n", - " document.head.appendChild(element);\n", - " }\n", - " if (!js_urls.length && !js_modules.length) {\n", - " on_load()\n", - " }\n", - " };\n", - "\n", - " function inject_raw_css(css) {\n", - " const element = document.createElement(\"style\");\n", - " element.appendChild(document.createTextNode(css));\n", - " document.body.appendChild(element);\n", - " }\n", - "\n", - " var js_urls = [\"https://cdn.bokeh.org/bokeh/release/bokeh-3.2.2.min.js\", \"https://cdn.bokeh.org/bokeh/release/bokeh-gl-3.2.2.min.js\", \"https://cdn.bokeh.org/bokeh/release/bokeh-widgets-3.2.2.min.js\", \"https://cdn.bokeh.org/bokeh/release/bokeh-tables-3.2.2.min.js\", \"https://cdn.holoviz.org/panel/1.2.3/dist/panel.min.js\", \"https://cdn.jsdelivr.net/npm/@holoviz/geoviews@1.10.1/dist/geoviews.min.js\"];\n", - " var js_modules = [];\n", - " var js_exports = {};\n", - " var css_urls = [];\n", - " var inline_js = [ function(Bokeh) {\n", - " Bokeh.set_log_level(\"info\");\n", - " },\n", - "function(Bokeh) {} // ensure no trailing comma for IE\n", - " ];\n", - "\n", - " function run_inline_js() {\n", - " if ((root.Bokeh !== undefined) || (force === true)) {\n", - " for (var i = 0; i < inline_js.length; i++) {\n", - " inline_js[i].call(root, root.Bokeh);\n", - " }\n", - " // Cache old bokeh versions\n", - " if (Bokeh != undefined && !reloading) {\n", - "\tvar NewBokeh = root.Bokeh;\n", - "\tif (Bokeh.versions === undefined) {\n", - "\t Bokeh.versions = new Map();\n", - "\t}\n", - "\tif (NewBokeh.version !== Bokeh.version) {\n", - "\t Bokeh.versions.set(NewBokeh.version, NewBokeh)\n", - "\t}\n", - "\troot.Bokeh = Bokeh;\n", - " }} else if (Date.now() < root._bokeh_timeout) {\n", - " setTimeout(run_inline_js, 100);\n", - " } else if (!root._bokeh_failed_load) {\n", - " console.log(\"Bokeh: BokehJS failed to load within specified timeout.\");\n", - " root._bokeh_failed_load = true;\n", - " }\n", - " root._bokeh_is_initializing = false\n", - " }\n", - "\n", - " function load_or_wait() {\n", - " // Implement a backoff loop that tries to ensure we do not load multiple\n", - " // versions of Bokeh and its dependencies at the same time.\n", - " // In recent versions we use the root._bokeh_is_initializing flag\n", - " // to determine whether there is an ongoing attempt to initialize\n", - " // bokeh, however for backward compatibility we also try to ensure\n", - " // that we do not start loading a newer (Panel>=1.0 and Bokeh>3) version\n", - " // before older versions are fully initialized.\n", - " if (root._bokeh_is_initializing && Date.now() > root._bokeh_timeout) {\n", - " root._bokeh_is_initializing = false;\n", - " root._bokeh_onload_callbacks = undefined;\n", - " console.log(\"Bokeh: BokehJS was loaded multiple times but one version failed to initialize.\");\n", - " load_or_wait();\n", - " } else if (root._bokeh_is_initializing || (typeof root._bokeh_is_initializing === \"undefined\" && root._bokeh_onload_callbacks !== undefined)) {\n", - " setTimeout(load_or_wait, 100);\n", - " } else {\n", - " Bokeh = root.Bokeh;\n", - " bokeh_loaded = Bokeh != null && (Bokeh.version === py_version || (Bokeh.versions !== undefined && Bokeh.versions.has(py_version)));\n", - " root._bokeh_is_initializing = true\n", - " root._bokeh_onload_callbacks = []\n", - " if (!reloading && (!bokeh_loaded || is_dev)) {\n", - "\troot.Bokeh = undefined;\n", - " }\n", - " load_libs(css_urls, js_urls, js_modules, js_exports, function() {\n", - "\tconsole.debug(\"Bokeh: BokehJS plotting callback run at\", now());\n", - "\trun_inline_js();\n", - " });\n", - " }\n", - " }\n", - " // Give older versions of the autoload script a head-start to ensure\n", - " // they initialize before we start loading newer version.\n", - " setTimeout(load_or_wait, 100)\n", - "}(window));" - ], - "application/vnd.holoviews_load.v0+json": "(function(root) {\n function now() {\n return new Date();\n }\n\n var force = true;\n var py_version = '3.2.2'.replace('rc', '-rc.').replace('.dev', '-dev.');\n var is_dev = py_version.indexOf(\"+\") !== -1 || py_version.indexOf(\"-\") !== -1;\n var reloading = false;\n var Bokeh = root.Bokeh;\n var bokeh_loaded = Bokeh != null && (Bokeh.version === py_version || (Bokeh.versions !== undefined && Bokeh.versions.has(py_version)));\n\n if (typeof (root._bokeh_timeout) === \"undefined\" || force) {\n root._bokeh_timeout = Date.now() + 5000;\n root._bokeh_failed_load = false;\n }\n\n function run_callbacks() {\n try {\n root._bokeh_onload_callbacks.forEach(function(callback) {\n if (callback != null)\n callback();\n });\n } finally {\n delete root._bokeh_onload_callbacks;\n }\n console.debug(\"Bokeh: all callbacks have finished\");\n }\n\n function load_libs(css_urls, js_urls, js_modules, js_exports, callback) {\n if (css_urls == null) css_urls = [];\n if (js_urls == null) js_urls = [];\n if (js_modules == null) js_modules = [];\n if (js_exports == null) js_exports = {};\n\n root._bokeh_onload_callbacks.push(callback);\n\n if (root._bokeh_is_loading > 0) {\n console.debug(\"Bokeh: BokehJS is being loaded, scheduling callback at\", now());\n return null;\n }\n if (js_urls.length === 0 && js_modules.length === 0 && Object.keys(js_exports).length === 0) {\n run_callbacks();\n return null;\n }\n if (!reloading) {\n console.debug(\"Bokeh: BokehJS not loaded, scheduling load and callback at\", now());\n }\n\n function on_load() {\n root._bokeh_is_loading--;\n if (root._bokeh_is_loading === 0) {\n console.debug(\"Bokeh: all BokehJS libraries/stylesheets loaded\");\n run_callbacks()\n }\n }\n window._bokeh_on_load = on_load\n\n function on_error() {\n console.error(\"failed to load \" + url);\n }\n\n var skip = [];\n if (window.requirejs) {\n window.requirejs.config({'packages': {}, 'paths': {'jspanel': 'https://cdn.jsdelivr.net/npm/jspanel4@4.12.0/dist/jspanel', 'jspanel-modal': 'https://cdn.jsdelivr.net/npm/jspanel4@4.12.0/dist/extensions/modal/jspanel.modal', 'jspanel-tooltip': 'https://cdn.jsdelivr.net/npm/jspanel4@4.12.0/dist/extensions/tooltip/jspanel.tooltip', 'jspanel-hint': 'https://cdn.jsdelivr.net/npm/jspanel4@4.12.0/dist/extensions/hint/jspanel.hint', 'jspanel-layout': 'https://cdn.jsdelivr.net/npm/jspanel4@4.12.0/dist/extensions/layout/jspanel.layout', 'jspanel-contextmenu': 'https://cdn.jsdelivr.net/npm/jspanel4@4.12.0/dist/extensions/contextmenu/jspanel.contextmenu', 'jspanel-dock': 'https://cdn.jsdelivr.net/npm/jspanel4@4.12.0/dist/extensions/dock/jspanel.dock', 'gridstack': 'https://cdn.jsdelivr.net/npm/gridstack@7.2.3/dist/gridstack-all', 'notyf': 'https://cdn.jsdelivr.net/npm/notyf@3/notyf.min'}, 'shim': {'jspanel': {'exports': 'jsPanel'}, 'gridstack': {'exports': 'GridStack'}}});\n require([\"jspanel\"], function(jsPanel) {\n\twindow.jsPanel = jsPanel\n\ton_load()\n })\n require([\"jspanel-modal\"], function() {\n\ton_load()\n })\n require([\"jspanel-tooltip\"], function() {\n\ton_load()\n })\n require([\"jspanel-hint\"], function() {\n\ton_load()\n })\n require([\"jspanel-layout\"], function() {\n\ton_load()\n })\n require([\"jspanel-contextmenu\"], function() {\n\ton_load()\n })\n require([\"jspanel-dock\"], function() {\n\ton_load()\n })\n require([\"gridstack\"], function(GridStack) {\n\twindow.GridStack = GridStack\n\ton_load()\n })\n require([\"notyf\"], function() {\n\ton_load()\n })\n root._bokeh_is_loading = css_urls.length + 9;\n } else {\n root._bokeh_is_loading = css_urls.length + js_urls.length + js_modules.length + Object.keys(js_exports).length;\n }\n\n var existing_stylesheets = []\n var links = document.getElementsByTagName('link')\n for (var i = 0; i < links.length; i++) {\n var link = links[i]\n if (link.href != null) {\n\texisting_stylesheets.push(link.href)\n }\n }\n for (var i = 0; i < css_urls.length; i++) {\n var url = css_urls[i];\n if (existing_stylesheets.indexOf(url) !== -1) {\n\ton_load()\n\tcontinue;\n }\n const element = document.createElement(\"link\");\n element.onload = on_load;\n element.onerror = on_error;\n element.rel = \"stylesheet\";\n element.type = \"text/css\";\n element.href = url;\n console.debug(\"Bokeh: injecting link tag for BokehJS stylesheet: \", url);\n document.body.appendChild(element);\n } if (((window['jsPanel'] !== undefined) && (!(window['jsPanel'] instanceof HTMLElement))) || window.requirejs) {\n var urls = ['https://cdn.holoviz.org/panel/1.2.3/dist/bundled/floatpanel/jspanel4@4.12.0/dist/jspanel.js', 'https://cdn.holoviz.org/panel/1.2.3/dist/bundled/floatpanel/jspanel4@4.12.0/dist/extensions/modal/jspanel.modal.js', 'https://cdn.holoviz.org/panel/1.2.3/dist/bundled/floatpanel/jspanel4@4.12.0/dist/extensions/tooltip/jspanel.tooltip.js', 'https://cdn.holoviz.org/panel/1.2.3/dist/bundled/floatpanel/jspanel4@4.12.0/dist/extensions/hint/jspanel.hint.js', 'https://cdn.holoviz.org/panel/1.2.3/dist/bundled/floatpanel/jspanel4@4.12.0/dist/extensions/layout/jspanel.layout.js', 'https://cdn.holoviz.org/panel/1.2.3/dist/bundled/floatpanel/jspanel4@4.12.0/dist/extensions/contextmenu/jspanel.contextmenu.js', 'https://cdn.holoviz.org/panel/1.2.3/dist/bundled/floatpanel/jspanel4@4.12.0/dist/extensions/dock/jspanel.dock.js'];\n for (var i = 0; i < urls.length; i++) {\n skip.push(urls[i])\n }\n } if (((window['GridStack'] !== undefined) && (!(window['GridStack'] instanceof HTMLElement))) || window.requirejs) {\n var urls = ['https://cdn.holoviz.org/panel/1.2.3/dist/bundled/gridstack/gridstack@7.2.3/dist/gridstack-all.js'];\n for (var i = 0; i < urls.length; i++) {\n skip.push(urls[i])\n }\n } if (((window['Notyf'] !== undefined) && (!(window['Notyf'] instanceof HTMLElement))) || window.requirejs) {\n var urls = ['https://cdn.holoviz.org/panel/1.2.3/dist/bundled/notificationarea/notyf@3/notyf.min.js'];\n for (var i = 0; i < urls.length; i++) {\n skip.push(urls[i])\n }\n } var existing_scripts = []\n var scripts = document.getElementsByTagName('script')\n for (var i = 0; i < scripts.length; i++) {\n var script = scripts[i]\n if (script.src != null) {\n\texisting_scripts.push(script.src)\n }\n }\n for (var i = 0; i < js_urls.length; i++) {\n var url = js_urls[i];\n if (skip.indexOf(url) !== -1 || existing_scripts.indexOf(url) !== -1) {\n\tif (!window.requirejs) {\n\t on_load();\n\t}\n\tcontinue;\n }\n var element = document.createElement('script');\n element.onload = on_load;\n element.onerror = on_error;\n element.async = false;\n element.src = url;\n console.debug(\"Bokeh: injecting script tag for BokehJS library: \", url);\n document.head.appendChild(element);\n }\n for (var i = 0; i < js_modules.length; i++) {\n var url = js_modules[i];\n if (skip.indexOf(url) !== -1 || existing_scripts.indexOf(url) !== -1) {\n\tif (!window.requirejs) {\n\t on_load();\n\t}\n\tcontinue;\n }\n var element = document.createElement('script');\n element.onload = on_load;\n element.onerror = on_error;\n element.async = false;\n element.src = url;\n element.type = \"module\";\n console.debug(\"Bokeh: injecting script tag for BokehJS library: \", url);\n document.head.appendChild(element);\n }\n for (const name in js_exports) {\n var url = js_exports[name];\n if (skip.indexOf(url) >= 0 || root[name] != null) {\n\tif (!window.requirejs) {\n\t on_load();\n\t}\n\tcontinue;\n }\n var element = document.createElement('script');\n element.onerror = on_error;\n element.async = false;\n element.type = \"module\";\n console.debug(\"Bokeh: injecting script tag for BokehJS library: \", url);\n element.textContent = `\n import ${name} from \"${url}\"\n window.${name} = ${name}\n window._bokeh_on_load()\n `\n document.head.appendChild(element);\n }\n if (!js_urls.length && !js_modules.length) {\n on_load()\n }\n };\n\n function inject_raw_css(css) {\n const element = document.createElement(\"style\");\n element.appendChild(document.createTextNode(css));\n document.body.appendChild(element);\n }\n\n var js_urls = [\"https://cdn.bokeh.org/bokeh/release/bokeh-3.2.2.min.js\", \"https://cdn.bokeh.org/bokeh/release/bokeh-gl-3.2.2.min.js\", \"https://cdn.bokeh.org/bokeh/release/bokeh-widgets-3.2.2.min.js\", \"https://cdn.bokeh.org/bokeh/release/bokeh-tables-3.2.2.min.js\", \"https://cdn.holoviz.org/panel/1.2.3/dist/panel.min.js\", \"https://cdn.jsdelivr.net/npm/@holoviz/geoviews@1.10.1/dist/geoviews.min.js\"];\n var js_modules = [];\n var js_exports = {};\n var css_urls = [];\n var inline_js = [ function(Bokeh) {\n Bokeh.set_log_level(\"info\");\n },\nfunction(Bokeh) {} // ensure no trailing comma for IE\n ];\n\n function run_inline_js() {\n if ((root.Bokeh !== undefined) || (force === true)) {\n for (var i = 0; i < inline_js.length; i++) {\n inline_js[i].call(root, root.Bokeh);\n }\n // Cache old bokeh versions\n if (Bokeh != undefined && !reloading) {\n\tvar NewBokeh = root.Bokeh;\n\tif (Bokeh.versions === undefined) {\n\t Bokeh.versions = new Map();\n\t}\n\tif (NewBokeh.version !== Bokeh.version) {\n\t Bokeh.versions.set(NewBokeh.version, NewBokeh)\n\t}\n\troot.Bokeh = Bokeh;\n }} else if (Date.now() < root._bokeh_timeout) {\n setTimeout(run_inline_js, 100);\n } else if (!root._bokeh_failed_load) {\n console.log(\"Bokeh: BokehJS failed to load within specified timeout.\");\n root._bokeh_failed_load = true;\n }\n root._bokeh_is_initializing = false\n }\n\n function load_or_wait() {\n // Implement a backoff loop that tries to ensure we do not load multiple\n // versions of Bokeh and its dependencies at the same time.\n // In recent versions we use the root._bokeh_is_initializing flag\n // to determine whether there is an ongoing attempt to initialize\n // bokeh, however for backward compatibility we also try to ensure\n // that we do not start loading a newer (Panel>=1.0 and Bokeh>3) version\n // before older versions are fully initialized.\n if (root._bokeh_is_initializing && Date.now() > root._bokeh_timeout) {\n root._bokeh_is_initializing = false;\n root._bokeh_onload_callbacks = undefined;\n console.log(\"Bokeh: BokehJS was loaded multiple times but one version failed to initialize.\");\n load_or_wait();\n } else if (root._bokeh_is_initializing || (typeof root._bokeh_is_initializing === \"undefined\" && root._bokeh_onload_callbacks !== undefined)) {\n setTimeout(load_or_wait, 100);\n } else {\n Bokeh = root.Bokeh;\n bokeh_loaded = Bokeh != null && (Bokeh.version === py_version || (Bokeh.versions !== undefined && Bokeh.versions.has(py_version)));\n root._bokeh_is_initializing = true\n root._bokeh_onload_callbacks = []\n if (!reloading && (!bokeh_loaded || is_dev)) {\n\troot.Bokeh = undefined;\n }\n load_libs(css_urls, js_urls, js_modules, js_exports, function() {\n\tconsole.debug(\"Bokeh: BokehJS plotting callback run at\", now());\n\trun_inline_js();\n });\n }\n }\n // Give older versions of the autoload script a head-start to ensure\n // they initialize before we start loading newer version.\n setTimeout(load_or_wait, 100)\n}(window));" - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "application/javascript": [ - "\n", - "if ((window.PyViz === undefined) || (window.PyViz instanceof HTMLElement)) {\n", - " window.PyViz = {comms: {}, comm_status:{}, kernels:{}, receivers: {}, plot_index: []}\n", - "}\n", - "\n", - "\n", - " function JupyterCommManager() {\n", - " }\n", - "\n", - " JupyterCommManager.prototype.register_target = function(plot_id, comm_id, msg_handler) {\n", - " if (window.comm_manager || ((window.Jupyter !== undefined) && (Jupyter.notebook.kernel != null))) {\n", - " var comm_manager = window.comm_manager || Jupyter.notebook.kernel.comm_manager;\n", - " comm_manager.register_target(comm_id, function(comm) {\n", - " comm.on_msg(msg_handler);\n", - " });\n", - " } else if ((plot_id in window.PyViz.kernels) && (window.PyViz.kernels[plot_id])) {\n", - " window.PyViz.kernels[plot_id].registerCommTarget(comm_id, function(comm) {\n", - " comm.onMsg = msg_handler;\n", - " });\n", - " } else if (typeof google != 'undefined' && google.colab.kernel != null) {\n", - " google.colab.kernel.comms.registerTarget(comm_id, (comm) => {\n", - " var messages = comm.messages[Symbol.asyncIterator]();\n", - " function processIteratorResult(result) {\n", - " var message = result.value;\n", - " console.log(message)\n", - " var content = {data: message.data, comm_id};\n", - " var buffers = []\n", - " for (var buffer of message.buffers || []) {\n", - " buffers.push(new DataView(buffer))\n", - " }\n", - " var metadata = message.metadata || {};\n", - " var msg = {content, buffers, metadata}\n", - " msg_handler(msg);\n", - " return messages.next().then(processIteratorResult);\n", - " }\n", - " return messages.next().then(processIteratorResult);\n", - " })\n", - " }\n", - " }\n", - "\n", - " JupyterCommManager.prototype.get_client_comm = function(plot_id, comm_id, msg_handler) {\n", - " if (comm_id in window.PyViz.comms) {\n", - " return window.PyViz.comms[comm_id];\n", - " } else if (window.comm_manager || ((window.Jupyter !== undefined) && (Jupyter.notebook.kernel != null))) {\n", - " var comm_manager = window.comm_manager || Jupyter.notebook.kernel.comm_manager;\n", - " var comm = comm_manager.new_comm(comm_id, {}, {}, {}, comm_id);\n", - " if (msg_handler) {\n", - " comm.on_msg(msg_handler);\n", - " }\n", - " } else if ((plot_id in window.PyViz.kernels) && (window.PyViz.kernels[plot_id])) {\n", - " var comm = window.PyViz.kernels[plot_id].connectToComm(comm_id);\n", - " comm.open();\n", - " if (msg_handler) {\n", - " comm.onMsg = msg_handler;\n", - " }\n", - " } else if (typeof google != 'undefined' && google.colab.kernel != null) {\n", - " var comm_promise = google.colab.kernel.comms.open(comm_id)\n", - " comm_promise.then((comm) => {\n", - " window.PyViz.comms[comm_id] = comm;\n", - " if (msg_handler) {\n", - " var messages = comm.messages[Symbol.asyncIterator]();\n", - " function processIteratorResult(result) {\n", - " var message = result.value;\n", - " var content = {data: message.data};\n", - " var metadata = message.metadata || {comm_id};\n", - " var msg = {content, metadata}\n", - " msg_handler(msg);\n", - " return messages.next().then(processIteratorResult);\n", - " }\n", - " return messages.next().then(processIteratorResult);\n", - " }\n", - " }) \n", - " var sendClosure = (data, metadata, buffers, disposeOnDone) => {\n", - " return comm_promise.then((comm) => {\n", - " comm.send(data, metadata, buffers, disposeOnDone);\n", - " });\n", - " };\n", - " var comm = {\n", - " send: sendClosure\n", - " };\n", - " }\n", - " window.PyViz.comms[comm_id] = comm;\n", - " return comm;\n", - " }\n", - " window.PyViz.comm_manager = new JupyterCommManager();\n", - " \n", - "\n", - "\n", - "var JS_MIME_TYPE = 'application/javascript';\n", - "var HTML_MIME_TYPE = 'text/html';\n", - "var EXEC_MIME_TYPE = 'application/vnd.holoviews_exec.v0+json';\n", - "var CLASS_NAME = 'output';\n", - "\n", - "/**\n", - " * Render data to the DOM node\n", - " */\n", - "function render(props, node) {\n", - " var div = document.createElement(\"div\");\n", - " var script = document.createElement(\"script\");\n", - " node.appendChild(div);\n", - " node.appendChild(script);\n", - "}\n", - "\n", - "/**\n", - " * Handle when a new output is added\n", - " */\n", - "function handle_add_output(event, handle) {\n", - " var output_area = handle.output_area;\n", - " var output = handle.output;\n", - " if ((output.data == undefined) || (!output.data.hasOwnProperty(EXEC_MIME_TYPE))) {\n", - " return\n", - " }\n", - " var id = output.metadata[EXEC_MIME_TYPE][\"id\"];\n", - " var toinsert = output_area.element.find(\".\" + CLASS_NAME.split(' ')[0]);\n", - " if (id !== undefined) {\n", - " var nchildren = toinsert.length;\n", - " var html_node = toinsert[nchildren-1].children[0];\n", - " html_node.innerHTML = output.data[HTML_MIME_TYPE];\n", - " var scripts = [];\n", - " var nodelist = html_node.querySelectorAll(\"script\");\n", - " for (var i in nodelist) {\n", - " if (nodelist.hasOwnProperty(i)) {\n", - " scripts.push(nodelist[i])\n", - " }\n", - " }\n", - "\n", - " scripts.forEach( function (oldScript) {\n", - " var newScript = document.createElement(\"script\");\n", - " var attrs = [];\n", - " var nodemap = oldScript.attributes;\n", - " for (var j in nodemap) {\n", - " if (nodemap.hasOwnProperty(j)) {\n", - " attrs.push(nodemap[j])\n", - " }\n", - " }\n", - " attrs.forEach(function(attr) { newScript.setAttribute(attr.name, attr.value) });\n", - " newScript.appendChild(document.createTextNode(oldScript.innerHTML));\n", - " oldScript.parentNode.replaceChild(newScript, oldScript);\n", - " });\n", - " if (JS_MIME_TYPE in output.data) {\n", - " toinsert[nchildren-1].children[1].textContent = output.data[JS_MIME_TYPE];\n", - " }\n", - " output_area._hv_plot_id = id;\n", - " if ((window.Bokeh !== undefined) && (id in Bokeh.index)) {\n", - " window.PyViz.plot_index[id] = Bokeh.index[id];\n", - " } else {\n", - " window.PyViz.plot_index[id] = null;\n", - " }\n", - " } else if (output.metadata[EXEC_MIME_TYPE][\"server_id\"] !== undefined) {\n", - " var bk_div = document.createElement(\"div\");\n", - " bk_div.innerHTML = output.data[HTML_MIME_TYPE];\n", - " var script_attrs = bk_div.children[0].attributes;\n", - " for (var i = 0; i < script_attrs.length; i++) {\n", - " toinsert[toinsert.length - 1].childNodes[1].setAttribute(script_attrs[i].name, script_attrs[i].value);\n", - " }\n", - " // store reference to server id on output_area\n", - " output_area._bokeh_server_id = output.metadata[EXEC_MIME_TYPE][\"server_id\"];\n", - " }\n", - "}\n", - "\n", - "/**\n", - " * Handle when an output is cleared or removed\n", - " */\n", - "function handle_clear_output(event, handle) {\n", - " var id = handle.cell.output_area._hv_plot_id;\n", - " var server_id = handle.cell.output_area._bokeh_server_id;\n", - " if (((id === undefined) || !(id in PyViz.plot_index)) && (server_id !== undefined)) { return; }\n", - " var comm = window.PyViz.comm_manager.get_client_comm(\"hv-extension-comm\", \"hv-extension-comm\", function () {});\n", - " if (server_id !== null) {\n", - " comm.send({event_type: 'server_delete', 'id': server_id});\n", - " return;\n", - " } else if (comm !== null) {\n", - " comm.send({event_type: 'delete', 'id': id});\n", - " }\n", - " delete PyViz.plot_index[id];\n", - " if ((window.Bokeh !== undefined) & (id in window.Bokeh.index)) {\n", - " var doc = window.Bokeh.index[id].model.document\n", - " doc.clear();\n", - " const i = window.Bokeh.documents.indexOf(doc);\n", - " if (i > -1) {\n", - " window.Bokeh.documents.splice(i, 1);\n", - " }\n", - " }\n", - "}\n", - "\n", - "/**\n", - " * Handle kernel restart event\n", - " */\n", - "function handle_kernel_cleanup(event, handle) {\n", - " delete PyViz.comms[\"hv-extension-comm\"];\n", - " window.PyViz.plot_index = {}\n", - "}\n", - "\n", - "/**\n", - " * Handle update_display_data messages\n", - " */\n", - "function handle_update_output(event, handle) {\n", - " handle_clear_output(event, {cell: {output_area: handle.output_area}})\n", - " handle_add_output(event, handle)\n", - "}\n", - "\n", - "function register_renderer(events, OutputArea) {\n", - " function append_mime(data, metadata, element) {\n", - " // create a DOM node to render to\n", - " var toinsert = this.create_output_subarea(\n", - " metadata,\n", - " CLASS_NAME,\n", - " EXEC_MIME_TYPE\n", - " );\n", - " this.keyboard_manager.register_events(toinsert);\n", - " // Render to node\n", - " var props = {data: data, metadata: metadata[EXEC_MIME_TYPE]};\n", - " render(props, toinsert[0]);\n", - " element.append(toinsert);\n", - " return toinsert\n", - " }\n", - "\n", - " events.on('output_added.OutputArea', handle_add_output);\n", - " events.on('output_updated.OutputArea', handle_update_output);\n", - " events.on('clear_output.CodeCell', handle_clear_output);\n", - " events.on('delete.Cell', handle_clear_output);\n", - " events.on('kernel_ready.Kernel', handle_kernel_cleanup);\n", - "\n", - " OutputArea.prototype.register_mime_type(EXEC_MIME_TYPE, append_mime, {\n", - " safe: true,\n", - " index: 0\n", - " });\n", - "}\n", - "\n", - "if (window.Jupyter !== undefined) {\n", - " try {\n", - " var events = require('base/js/events');\n", - " var OutputArea = require('notebook/js/outputarea').OutputArea;\n", - " if (OutputArea.prototype.mime_types().indexOf(EXEC_MIME_TYPE) == -1) {\n", - " register_renderer(events, OutputArea);\n", - " }\n", - " } catch(err) {\n", - " }\n", - "}\n" - ], - "application/vnd.holoviews_load.v0+json": "\nif ((window.PyViz === undefined) || (window.PyViz instanceof HTMLElement)) {\n window.PyViz = {comms: {}, comm_status:{}, kernels:{}, receivers: {}, plot_index: []}\n}\n\n\n function JupyterCommManager() {\n }\n\n JupyterCommManager.prototype.register_target = function(plot_id, comm_id, msg_handler) {\n if (window.comm_manager || ((window.Jupyter !== undefined) && (Jupyter.notebook.kernel != null))) {\n var comm_manager = window.comm_manager || Jupyter.notebook.kernel.comm_manager;\n comm_manager.register_target(comm_id, function(comm) {\n comm.on_msg(msg_handler);\n });\n } else if ((plot_id in window.PyViz.kernels) && (window.PyViz.kernels[plot_id])) {\n window.PyViz.kernels[plot_id].registerCommTarget(comm_id, function(comm) {\n comm.onMsg = msg_handler;\n });\n } else if (typeof google != 'undefined' && google.colab.kernel != null) {\n google.colab.kernel.comms.registerTarget(comm_id, (comm) => {\n var messages = comm.messages[Symbol.asyncIterator]();\n function processIteratorResult(result) {\n var message = result.value;\n console.log(message)\n var content = {data: message.data, comm_id};\n var buffers = []\n for (var buffer of message.buffers || []) {\n buffers.push(new DataView(buffer))\n }\n var metadata = message.metadata || {};\n var msg = {content, buffers, metadata}\n msg_handler(msg);\n return messages.next().then(processIteratorResult);\n }\n return messages.next().then(processIteratorResult);\n })\n }\n }\n\n JupyterCommManager.prototype.get_client_comm = function(plot_id, comm_id, msg_handler) {\n if (comm_id in window.PyViz.comms) {\n return window.PyViz.comms[comm_id];\n } else if (window.comm_manager || ((window.Jupyter !== undefined) && (Jupyter.notebook.kernel != null))) {\n var comm_manager = window.comm_manager || Jupyter.notebook.kernel.comm_manager;\n var comm = comm_manager.new_comm(comm_id, {}, {}, {}, comm_id);\n if (msg_handler) {\n comm.on_msg(msg_handler);\n }\n } else if ((plot_id in window.PyViz.kernels) && (window.PyViz.kernels[plot_id])) {\n var comm = window.PyViz.kernels[plot_id].connectToComm(comm_id);\n comm.open();\n if (msg_handler) {\n comm.onMsg = msg_handler;\n }\n } else if (typeof google != 'undefined' && google.colab.kernel != null) {\n var comm_promise = google.colab.kernel.comms.open(comm_id)\n comm_promise.then((comm) => {\n window.PyViz.comms[comm_id] = comm;\n if (msg_handler) {\n var messages = comm.messages[Symbol.asyncIterator]();\n function processIteratorResult(result) {\n var message = result.value;\n var content = {data: message.data};\n var metadata = message.metadata || {comm_id};\n var msg = {content, metadata}\n msg_handler(msg);\n return messages.next().then(processIteratorResult);\n }\n return messages.next().then(processIteratorResult);\n }\n }) \n var sendClosure = (data, metadata, buffers, disposeOnDone) => {\n return comm_promise.then((comm) => {\n comm.send(data, metadata, buffers, disposeOnDone);\n });\n };\n var comm = {\n send: sendClosure\n };\n }\n window.PyViz.comms[comm_id] = comm;\n return comm;\n }\n window.PyViz.comm_manager = new JupyterCommManager();\n \n\n\nvar JS_MIME_TYPE = 'application/javascript';\nvar HTML_MIME_TYPE = 'text/html';\nvar EXEC_MIME_TYPE = 'application/vnd.holoviews_exec.v0+json';\nvar CLASS_NAME = 'output';\n\n/**\n * Render data to the DOM node\n */\nfunction render(props, node) {\n var div = document.createElement(\"div\");\n var script = document.createElement(\"script\");\n node.appendChild(div);\n node.appendChild(script);\n}\n\n/**\n * Handle when a new output is added\n */\nfunction handle_add_output(event, handle) {\n var output_area = handle.output_area;\n var output = handle.output;\n if ((output.data == undefined) || (!output.data.hasOwnProperty(EXEC_MIME_TYPE))) {\n return\n }\n var id = output.metadata[EXEC_MIME_TYPE][\"id\"];\n var toinsert = output_area.element.find(\".\" + CLASS_NAME.split(' ')[0]);\n if (id !== undefined) {\n var nchildren = toinsert.length;\n var html_node = toinsert[nchildren-1].children[0];\n html_node.innerHTML = output.data[HTML_MIME_TYPE];\n var scripts = [];\n var nodelist = html_node.querySelectorAll(\"script\");\n for (var i in nodelist) {\n if (nodelist.hasOwnProperty(i)) {\n scripts.push(nodelist[i])\n }\n }\n\n scripts.forEach( function (oldScript) {\n var newScript = document.createElement(\"script\");\n var attrs = [];\n var nodemap = oldScript.attributes;\n for (var j in nodemap) {\n if (nodemap.hasOwnProperty(j)) {\n attrs.push(nodemap[j])\n }\n }\n attrs.forEach(function(attr) { newScript.setAttribute(attr.name, attr.value) });\n newScript.appendChild(document.createTextNode(oldScript.innerHTML));\n oldScript.parentNode.replaceChild(newScript, oldScript);\n });\n if (JS_MIME_TYPE in output.data) {\n toinsert[nchildren-1].children[1].textContent = output.data[JS_MIME_TYPE];\n }\n output_area._hv_plot_id = id;\n if ((window.Bokeh !== undefined) && (id in Bokeh.index)) {\n window.PyViz.plot_index[id] = Bokeh.index[id];\n } else {\n window.PyViz.plot_index[id] = null;\n }\n } else if (output.metadata[EXEC_MIME_TYPE][\"server_id\"] !== undefined) {\n var bk_div = document.createElement(\"div\");\n bk_div.innerHTML = output.data[HTML_MIME_TYPE];\n var script_attrs = bk_div.children[0].attributes;\n for (var i = 0; i < script_attrs.length; i++) {\n toinsert[toinsert.length - 1].childNodes[1].setAttribute(script_attrs[i].name, script_attrs[i].value);\n }\n // store reference to server id on output_area\n output_area._bokeh_server_id = output.metadata[EXEC_MIME_TYPE][\"server_id\"];\n }\n}\n\n/**\n * Handle when an output is cleared or removed\n */\nfunction handle_clear_output(event, handle) {\n var id = handle.cell.output_area._hv_plot_id;\n var server_id = handle.cell.output_area._bokeh_server_id;\n if (((id === undefined) || !(id in PyViz.plot_index)) && (server_id !== undefined)) { return; }\n var comm = window.PyViz.comm_manager.get_client_comm(\"hv-extension-comm\", \"hv-extension-comm\", function () {});\n if (server_id !== null) {\n comm.send({event_type: 'server_delete', 'id': server_id});\n return;\n } else if (comm !== null) {\n comm.send({event_type: 'delete', 'id': id});\n }\n delete PyViz.plot_index[id];\n if ((window.Bokeh !== undefined) & (id in window.Bokeh.index)) {\n var doc = window.Bokeh.index[id].model.document\n doc.clear();\n const i = window.Bokeh.documents.indexOf(doc);\n if (i > -1) {\n window.Bokeh.documents.splice(i, 1);\n }\n }\n}\n\n/**\n * Handle kernel restart event\n */\nfunction handle_kernel_cleanup(event, handle) {\n delete PyViz.comms[\"hv-extension-comm\"];\n window.PyViz.plot_index = {}\n}\n\n/**\n * Handle update_display_data messages\n */\nfunction handle_update_output(event, handle) {\n handle_clear_output(event, {cell: {output_area: handle.output_area}})\n handle_add_output(event, handle)\n}\n\nfunction register_renderer(events, OutputArea) {\n function append_mime(data, metadata, element) {\n // create a DOM node to render to\n var toinsert = this.create_output_subarea(\n metadata,\n CLASS_NAME,\n EXEC_MIME_TYPE\n );\n this.keyboard_manager.register_events(toinsert);\n // Render to node\n var props = {data: data, metadata: metadata[EXEC_MIME_TYPE]};\n render(props, toinsert[0]);\n element.append(toinsert);\n return toinsert\n }\n\n events.on('output_added.OutputArea', handle_add_output);\n events.on('output_updated.OutputArea', handle_update_output);\n events.on('clear_output.CodeCell', handle_clear_output);\n events.on('delete.Cell', handle_clear_output);\n events.on('kernel_ready.Kernel', handle_kernel_cleanup);\n\n OutputArea.prototype.register_mime_type(EXEC_MIME_TYPE, append_mime, {\n safe: true,\n index: 0\n });\n}\n\nif (window.Jupyter !== undefined) {\n try {\n var events = require('base/js/events');\n var OutputArea = require('notebook/js/outputarea').OutputArea;\n if (OutputArea.prototype.mime_types().indexOf(EXEC_MIME_TYPE) == -1) {\n register_renderer(events, OutputArea);\n }\n } catch(err) {\n }\n}\n" - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/html": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/html": [ - "\n", - "
\n", - "\n", - "\n", - "\n", - " \n", - " \n", - "\n", - "\n", - "\n", - "\n", - "
\n" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": {}, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "application/vnd.holoviews_exec.v0+json": "", - "text/html": [ - "
\n", - "
\n", - "
\n", - "" - ], - "text/plain": [ - ":Overlay\n", - " .WMTS.I :WMTS [Longitude,Latitude]\n", - " .Path.I :Path [Longitude,Latitude]" - ] - }, - "execution_count": 11, - "metadata": { - "application/vnd.holoviews_exec.v0+json": { - "id": "p1005" - } - }, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "# Visualize area of interest\n", "region.visualize_spatial_extent()" @@ -3135,25 +539,12 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": null, "id": "b68bdc52-4de8-44fa-8f8e-fcdd89da01bf", "metadata": { "tags": [] }, - "outputs": [ - { - "data": { - "text/plain": [ - "{'Number of available granules': 4,\n", - " 'Average size of granules (MB)': 193.56415557861328,\n", - " 'Total size of all granules (MB)': 774.2566223144531}" - ] - }, - "execution_count": 12, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "# Let's find out some information about the available data granuales (files)\n", "region.avail_granules()" @@ -3161,30 +552,7 @@ }, { "cell_type": "code", - "execution_count": 14, - "id": "e3543fdb-cb0d-4562-b6b2-457f7065c603", - "metadata": { - "tags": [] - }, - "outputs": [ - { - "data": { - "text/plain": [ - "'1.0.0'" - ] - }, - "execution_count": 14, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "ipx.__version__" - ] - }, - { - "cell_type": "code", - "execution_count": 15, + "execution_count": null, "id": "87dc30f0-dc2e-4dc4-a13b-305944246691", "metadata": { "tags": [] @@ -3193,29 +561,17 @@ "source": [ "# Let's see the granule IDs and cloud access urls\n", "gran_ids = region.avail_granules(ids=True, cloud=True)\n", - "gran_ids\n", - "s3url='s3://nsidc-cumulus-prod-protected/ATLAS/ATL15/002/2019/ATL15_GL_0314_01km_002_01.nc'" + "gran_ids" ] }, { "cell_type": "code", - "execution_count": 15, + "execution_count": null, "id": "bc3e741b-9f35-4598-accf-827e4eb6b447", "metadata": { "tags": [] }, - "outputs": [ - { - "data": { - "text/plain": [ - "'s3://nsidc-cumulus-prod-protected/ATLAS/ATL15/002/2019/ATL15_GL_0314_01km_002_01.nc'" - ] - }, - "execution_count": 15, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "# Let's grab the s3 URL of the highest resolution available product\n", "s3url = gran_ids[1][3]\n", @@ -3243,705 +599,51 @@ "source": [ "The next step (accessing data in the cloud) requires a NASA Earthdata user account.\n", "You can register for a free account [here](https://www.earthdata.nasa.gov/eosdis/science-system-description/eosdis-components/earthdata-login).\n", + "We provide two options for reading in your data: (1) by setting up an s3 file system and using Xarray directly; or (2) by using icepyx (which uses Xarray under the hood).\n", + "Currently, the read time is similar with both methods.\n", + "The h5coro library will soon be available to help speed up this process.\n", + "\n", + "The file system method requires you complete a login step.\n", "icepyx will automatically ask for your credentials when you perform a task that needs them.\n", "If you do not have them stored as environment variables or in a .netrc file, you will be prompted to enter them." ] }, { "cell_type": "code", - "execution_count": 19, + "execution_count": null, + "id": "b2af9f40-c9a8-48ed-9f81-c93d52d960e6", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "# (1) authenticate\n", + "auth = earthaccess.login()" + ] + }, + { + "cell_type": "code", + "execution_count": null, "id": "e16e81f6-9092-4523-8565-34a75d8631f1", "metadata": { "tags": [] }, "outputs": [], "source": [ - "# set up our s3 file system using our credentials\n", - "s3 = earthaccess.get_s3fs_session(daac='NSIDC', provider=region._s3login_credentials)" + "# (1) set up our s3 file system using our credentials\n", + "s3 = earthaccess.get_s3fs_session(daac='NSIDC')" ] }, { "cell_type": "code", - "execution_count": 20, + "execution_count": null, "id": "7377ae88-8552-4ee8-8595-d15b786b003c", "metadata": { "tags": [] }, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "
<xarray.Dataset>\n",
-       "Dimensions:              (x: 1541, y: 2701, time: 15)\n",
-       "Coordinates:\n",
-       "  * x                    (x) float64 -6.7e+05 -6.69e+05 ... 8.69e+05 8.7e+05\n",
-       "  * y                    (y) float64 -3.35e+06 -3.349e+06 ... -6.51e+05 -6.5e+05\n",
-       "  * time                 (time) datetime64[ns] 2018-10-01T22:30:00 ... 2022-0...\n",
-       "Data variables:\n",
-       "    Polar_Stereographic  int8 -127\n",
-       "    ice_area             (time, y, x) float32 nan nan nan nan ... nan nan nan\n",
-       "    delta_h              (time, y, x) float32 nan nan nan nan ... nan nan nan\n",
-       "    delta_h_sigma        (time, y, x) float32 nan nan nan nan ... nan nan nan\n",
-       "    data_count           (time, y, x) float32 nan nan nan nan ... nan nan nan\n",
-       "    misfit_rms           (time, y, x) float32 nan nan nan nan ... nan nan nan\n",
-       "    misfit_scaled_rms    (time, y, x) float32 nan nan nan nan ... nan nan nan\n",
-       "Attributes:\n",
-       "    description:  delta_h group includes variables describing height differen...
" - ], - "text/plain": [ - "\n", - "Dimensions: (x: 1541, y: 2701, time: 15)\n", - "Coordinates:\n", - " * x (x) float64 -6.7e+05 -6.69e+05 ... 8.69e+05 8.7e+05\n", - " * y (y) float64 -3.35e+06 -3.349e+06 ... -6.51e+05 -6.5e+05\n", - " * time (time) datetime64[ns] 2018-10-01T22:30:00 ... 2022-0...\n", - "Data variables:\n", - " Polar_Stereographic int8 -127\n", - " ice_area (time, y, x) float32 nan nan nan nan ... nan nan nan\n", - " delta_h (time, y, x) float32 nan nan nan nan ... nan nan nan\n", - " delta_h_sigma (time, y, x) float32 nan nan nan nan ... nan nan nan\n", - " data_count (time, y, x) float32 nan nan nan nan ... nan nan nan\n", - " misfit_rms (time, y, x) float32 nan nan nan nan ... nan nan nan\n", - " misfit_scaled_rms (time, y, x) float32 nan nan nan nan ... nan nan nan\n", - "Attributes:\n", - " description: delta_h group includes variables describing height differen..." - ] - }, - "execution_count": 20, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ - "# Open s3url data file and store in Xarray Dataset\n", + "# (1) Open s3url data file and store in Xarray Dataset\n", "# This cell takes 10s of secs to load\n", "with s3.open(s3url,'rb') as f:\n", " # ATL15_dh = rioxarray.open_rasterio(f, group='delta_h').load() # FIXME: preferred, but giving error\n", @@ -3953,52 +655,72 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": null, "id": "f4e72f9a-c6bc-448c-891a-3b4870c0ecea", "metadata": { "tags": [] }, - "outputs": [ - { - "name": "stdin", - "output_type": "stream", - "text": [ - "Enter your Earthdata Login username: icepyx_devteam\n", - "Enter your Earthdata password: ········\n" - ] - } - ], + "outputs": [], "source": [ + "# (2) create a Read object; you'll be asked to authenticate at this step if you haven't already\n", "reader = ipx.Read(s3url)" ] }, { "cell_type": "code", - "execution_count": 22, + "execution_count": null, + "id": "cc752711-13aa-4d0a-b15d-b21a79894b21", + "metadata": { + "scrolled": true, + "tags": [] + }, + "outputs": [], + "source": [ + "# (2) see what variables are available\n", + "reader.vars.avail()" + ] + }, + { + "cell_type": "code", + "execution_count": null, "id": "52e93f16-b98e-4690-b273-aeeadb5bfdb4", "metadata": { "tags": [] }, - "outputs": [ - { - "ename": "ValueError", - "evalue": "list.remove(x): x not in list", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mValueError\u001b[0m Traceback (most recent call last)", - "Cell \u001b[0;32mIn [22], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m \u001b[43mreader\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mvars\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mappend\u001b[49m\u001b[43m(\u001b[49m\u001b[43mvar_list\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43m[\u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mdelta_h\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m]\u001b[49m\u001b[43m)\u001b[49m\n", - "File \u001b[0;32m/srv/conda/envs/notebook/lib/python3.10/site-packages/icepyx/core/variables.py:496\u001b[0m, in \u001b[0;36mVariables.append\u001b[0;34m(self, defaults, var_list, beam_list, keyword_list)\u001b[0m\n\u001b[1;32m 487\u001b[0m \u001b[38;5;28;01massert\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m (\n\u001b[1;32m 488\u001b[0m defaults \u001b[38;5;241m==\u001b[39m \u001b[38;5;28;01mFalse\u001b[39;00m\n\u001b[1;32m 489\u001b[0m \u001b[38;5;129;01mand\u001b[39;00m var_list \u001b[38;5;241m==\u001b[39m \u001b[38;5;28;01mNone\u001b[39;00m\n\u001b[1;32m 490\u001b[0m \u001b[38;5;129;01mand\u001b[39;00m beam_list \u001b[38;5;241m==\u001b[39m \u001b[38;5;28;01mNone\u001b[39;00m\n\u001b[1;32m 491\u001b[0m \u001b[38;5;129;01mand\u001b[39;00m keyword_list \u001b[38;5;241m==\u001b[39m \u001b[38;5;28;01mNone\u001b[39;00m\n\u001b[1;32m 492\u001b[0m ), \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mYou must enter parameters to add to a variable subset list. If you do not want to subset by variable, ensure your is2.subsetparams dictionary does not contain the key \u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mCoverage\u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;124m.\u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[1;32m 494\u001b[0m final_vars \u001b[38;5;241m=\u001b[39m {}\n\u001b[0;32m--> 496\u001b[0m vgrp, allpaths \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mavail\u001b[49m\u001b[43m(\u001b[49m\u001b[43moptions\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43;01mTrue\u001b[39;49;00m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43minternal\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43;01mTrue\u001b[39;49;00m\u001b[43m)\u001b[49m\n\u001b[1;32m 497\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_check_valid_lists(vgrp, allpaths, var_list, beam_list, keyword_list)\n\u001b[1;32m 499\u001b[0m \u001b[38;5;66;03m# Instantiate self.wanted to an empty dictionary if it doesn't exist\u001b[39;00m\n", - "File \u001b[0;32m/srv/conda/envs/notebook/lib/python3.10/site-packages/icepyx/core/variables.py:150\u001b[0m, in \u001b[0;36mVariables.avail\u001b[0;34m(self, options, internal)\u001b[0m\n\u001b[1;32m 148\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28mhasattr\u001b[39m(\u001b[38;5;28mself\u001b[39m, \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124m_avail\u001b[39m\u001b[38;5;124m\"\u001b[39m) \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_avail \u001b[38;5;241m==\u001b[39m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[1;32m 149\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28mhasattr\u001b[39m(\u001b[38;5;28mself\u001b[39m, \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mpath\u001b[39m\u001b[38;5;124m\"\u001b[39m) \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mpath\u001b[38;5;241m.\u001b[39mstartswith(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124ms3\u001b[39m\u001b[38;5;124m\"\u001b[39m):\n\u001b[0;32m--> 150\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_avail \u001b[38;5;241m=\u001b[39m \u001b[43mis2ref\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_get_custom_options\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 151\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43msession\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mproduct\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mversion\u001b[49m\n\u001b[1;32m 152\u001b[0m \u001b[43m \u001b[49m\u001b[43m)\u001b[49m[\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mvariables\u001b[39m\u001b[38;5;124m\"\u001b[39m]\n\u001b[1;32m 153\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m 154\u001b[0m \u001b[38;5;66;03m# If a path was given, use that file to read the variables\u001b[39;00m\n\u001b[1;32m 155\u001b[0m \u001b[38;5;28;01mimport\u001b[39;00m \u001b[38;5;21;01mh5py\u001b[39;00m\n", - "File \u001b[0;32m/srv/conda/envs/notebook/lib/python3.10/site-packages/icepyx/core/is2ref.py:112\u001b[0m, in \u001b[0;36m_get_custom_options\u001b[0;34m(session, product, version)\u001b[0m\n\u001b[1;32m 110\u001b[0m format_vals \u001b[38;5;241m=\u001b[39m [formats[i][\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mvalue\u001b[39m\u001b[38;5;124m\"\u001b[39m] \u001b[38;5;28;01mfor\u001b[39;00m i \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mrange\u001b[39m(\u001b[38;5;28mlen\u001b[39m(formats))]\n\u001b[1;32m 111\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[0;32m--> 112\u001b[0m \u001b[43mformat_vals\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mremove\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m)\u001b[49m\n\u001b[1;32m 113\u001b[0m \u001b[38;5;28;01mexcept\u001b[39;00m \u001b[38;5;167;01mKeyError\u001b[39;00m:\n\u001b[1;32m 114\u001b[0m \u001b[38;5;66;03m# ATL23 does not have an empty value\u001b[39;00m\n\u001b[1;32m 115\u001b[0m \u001b[38;5;28;01mpass\u001b[39;00m\n", - "\u001b[0;31mValueError\u001b[0m: list.remove(x): x not in list" - ] - } - ], + "outputs": [], "source": [ - "# Indicate which variables you'd like to read in.\n", + "# (2) Indicate which variables you'd like to read in.\n", "# More information on managing ICESat-2 variables is available in the icepyx documentation and examples.\n", - "reader.vars.append(var_list=[\"delta_h\"])" + "reader.vars.append(keyword_list=[\"delta_h\"])\n", + "# view the variables that will be loaded into memory in your DataSet\n", + "reader.vars.wanted" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "5475a92f-4b55-4307-acca-1c16f76144c5", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "# (2) load your data into memory\n", + "# if you are asked if you want to proceed, enter 'y' and press return/enter\n", + "# Depending on your hub settings, the warning letting you know this operation will take a moment may or may not show up\n", + "ATL15_dh = reader.load()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "e589974d-78ec-4747-a4de-223d17252dfe", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "ATL15_dh" ] }, { @@ -4031,38 +753,12 @@ }, { "cell_type": "code", - "execution_count": 20, + "execution_count": null, "id": "ced9c230-1b92-4468-8231-5f90a9f119ff", "metadata": { "tags": [] }, - "outputs": [ - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "8bba32a2573f4894bb202a76384d5831", - "version_major": 2, - "version_minor": 0 - }, - "image/png": "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", - "text/html": [ - "\n", - "
\n", - "
\n", - " Figure\n", - "
\n", - " \n", - "
\n", - " " - ], - "text/plain": [ - "Canvas(toolbar=Toolbar(toolitems=[('Home', 'Reset original view', 'home', 'home'), ('Back', 'Back to previous …" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "# Let's make a simple plot of the first minus the zeroth time slices\n", "fig, ax = plt.subplots(figsize=(6,3))\n", @@ -4086,21 +782,12 @@ }, { "cell_type": "code", - "execution_count": 21, + "execution_count": null, "id": "1e2b2eae-00fc-4a4b-8343-28b38688433a", "metadata": { "tags": [] }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "-3.6538086\n", - "10.285828\n" - ] - } - ], + "outputs": [], "source": [ "# Let's calculate some basic stats to determine appropriate coloarbar bounds\n", "print(dhdt.min().values)\n", @@ -4119,38 +806,12 @@ }, { "cell_type": "code", - "execution_count": 22, + "execution_count": null, "id": "faf7223f-02fa-4570-9704-9c631b3b996b", "metadata": { "tags": [] }, - "outputs": [ - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "68c2221c171440f79b7a80e661b11b7e", - "version_major": 2, - "version_minor": 0 - }, - "image/png": "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", - "text/html": [ - "\n", - "
\n", - "
\n", - " Figure\n", - "
\n", - " \n", - "
\n", - " " - ], - "text/plain": [ - "Canvas(toolbar=Toolbar(toolitems=[('Home', 'Reset original view', 'home', 'home'), ('Back', 'Back to previous …" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "# We can make that same plot with more representative colorbar bounds\n", "fig, ax = plt.subplots(figsize=(6,3))\n", @@ -4175,395 +836,12 @@ }, { "cell_type": "code", - "execution_count": 23, + "execution_count": null, "id": "82678fa1-fd9a-469f-9eac-2254624f5e3e", "metadata": { "tags": [] }, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "
<xarray.DataArray 'delta_h' (quantile: 2)>\n",
-       "array([-0.37408447,  1.45697021])\n",
-       "Coordinates:\n",
-       "  * quantile  (quantile) float64 0.01 0.99
" - ], - "text/plain": [ - "\n", - "array([-0.37408447, 1.45697021])\n", - "Coordinates:\n", - " * quantile (quantile) float64 0.01 0.99" - ] - }, - "execution_count": 23, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "# Let's use the Xarray DataArray quantile method to find the 1% and 99% quantiles (Q1 and Q3) of the data\n", "dhdt.quantile([0.01,0.99])" @@ -4581,38 +859,12 @@ }, { "cell_type": "code", - "execution_count": 24, + "execution_count": null, "id": "8320be7d-73dd-45ec-8a7f-7efdb9b629d3", "metadata": { "tags": [] }, - "outputs": [ - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "c9449cb9ecdd425fbe9e59230e7046ba", - "version_major": 2, - "version_minor": 0 - }, - "image/png": "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", - "text/html": [ - "\n", - "
\n", - "
\n", - " Figure\n", - "
\n", - " \n", - "
\n", - " " - ], - "text/plain": [ - "Canvas(toolbar=Toolbar(toolitems=[('Home', 'Reset original view', 'home', 'home'), ('Back', 'Back to previous …" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "# Let's make the same plot but using the quantiles as the colorbar bounds\n", "fig, ax = plt.subplots(figsize=(6,3))\n", @@ -4628,7 +880,7 @@ }, { "cell_type": "code", - "execution_count": 25, + "execution_count": null, "id": "b53dab15-820d-45d9-bf17-72a8702af057", "metadata": { "tags": [] @@ -4695,143 +947,12 @@ }, { "cell_type": "code", - "execution_count": 26, + "execution_count": null, "id": "7eb6cefc-7794-45e3-a5d6-3900d7204d85", "metadata": { "tags": [] }, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
Name / LocationLat. oNLon. oELake TypeReferencesgeometry
3Flade Isblink ice cap81.160000-16.580000ActiveWillis et al. (2015)POLYGON ((-16.06723 81.11390, -16.09787 81.106...
4Inuppaat Quuat67.611136-48.709000ActiveHowat et al. (2015); Palmer et al. (2015)POLYGON ((-48.47640 67.61446, -48.47613 67.605...
5Sioqqap Sermia, [SS1]63.541856-48.450597ActiveBowling et al. (2019)POLYGON ((-48.25472 63.54482, -48.25457 63.536...
6Sioqqap Sermia, [SS2]63.260248-48.206633ActiveBowling et al. (2019)POLYGON ((-48.01287 63.26285, -48.01281 63.254...
61Isunguata Sermia 167.180000-50.188000ActiveLivingstone et al. (2019)POLYGON ((-49.96016 67.18562, -49.95932 67.176...
62Isunguata Sermia 267.178000-50.149000ActiveLivingstone et al. (2019)POLYGON ((-49.92117 67.18356, -49.92035 67.174...
63Isunguata Sermia 367.180000-50.128000ActiveLivingstone et al. (2019)POLYGON ((-49.90015 67.18552, -49.89933 67.176...
\n", - "
" - ], - "text/plain": [ - " Name / Location Lat. oN Lon. oE Lake Type \\\n", - "3 Flade Isblink ice cap 81.160000 -16.580000 Active \n", - "4 Inuppaat Quuat 67.611136 -48.709000 Active \n", - "5 Sioqqap Sermia, [SS1] 63.541856 -48.450597 Active \n", - "6 Sioqqap Sermia, [SS2] 63.260248 -48.206633 Active \n", - "61 Isunguata Sermia 1 67.180000 -50.188000 Active \n", - "62 Isunguata Sermia 2 67.178000 -50.149000 Active \n", - "63 Isunguata Sermia 3 67.180000 -50.128000 Active \n", - "\n", - " References \\\n", - "3 Willis et al. (2015) \n", - "4 Howat et al. (2015); Palmer et al. (2015) \n", - "5 Bowling et al. (2019) \n", - "6 Bowling et al. (2019) \n", - "61 Livingstone et al. (2019) \n", - "62 Livingstone et al. (2019) \n", - "63 Livingstone et al. (2019) \n", - "\n", - " geometry \n", - "3 POLYGON ((-16.06723 81.11390, -16.09787 81.106... \n", - "4 POLYGON ((-48.47640 67.61446, -48.47613 67.605... \n", - "5 POLYGON ((-48.25472 63.54482, -48.25457 63.536... \n", - "6 POLYGON ((-48.01287 63.26285, -48.01281 63.254... \n", - "61 POLYGON ((-49.96016 67.18562, -49.95932 67.176... \n", - "62 POLYGON ((-49.92117 67.18356, -49.92035 67.174... \n", - "63 POLYGON ((-49.90015 67.18552, -49.89933 67.176... " - ] - }, - "execution_count": 26, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "gdf_polys_active = gdf_polys[gdf_polys['Lake Type'] == 'Active']\n", "gdf_polys_active" @@ -4839,7 +960,7 @@ }, { "cell_type": "code", - "execution_count": 27, + "execution_count": null, "id": "eb54bca1-def0-46cd-b2c0-d08a1e79611d", "metadata": { "tags": [] @@ -4862,38 +983,12 @@ }, { "cell_type": "code", - "execution_count": 28, + "execution_count": null, "id": "5e949e39-f84f-42ff-8e7f-7b45270d9a39", "metadata": { "tags": [] }, - "outputs": [ - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "b069a7b2ac3f4d82a477bab378c4e8b7", - "version_major": 2, - "version_minor": 0 - }, - "image/png": "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", - "text/html": [ - "\n", - "
\n", - "
\n", - " Figure\n", - "
\n", - " \n", - "
\n", - " " - ], - "text/plain": [ - "Canvas(toolbar=Toolbar(toolitems=[('Home', 'Reset original view', 'home', 'home'), ('Back', 'Back to previous …" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "# If the figure doesn't pop up, it is because the holoviews plot was run immediately after and interferred with \n", "# matplotlib. Just rerun this cell and it will be fixed\n", @@ -4916,522 +1011,12 @@ }, { "cell_type": "code", - "execution_count": 29, + "execution_count": null, "id": "f6a59c54-792e-4a6b-8cbb-590d555405a3", "metadata": { "tags": [] }, - "outputs": [ - { - "data": { - "application/javascript": [ - "(function(root) {\n", - " function now() {\n", - " return new Date();\n", - " }\n", - "\n", - " var force = true;\n", - "\n", - " if (typeof root._bokeh_onload_callbacks === \"undefined\" || force === true) {\n", - " root._bokeh_onload_callbacks = [];\n", - " root._bokeh_is_loading = undefined;\n", - " }\n", - "\n", - " if (typeof (root._bokeh_timeout) === \"undefined\" || force === true) {\n", - " root._bokeh_timeout = Date.now() + 5000;\n", - " root._bokeh_failed_load = false;\n", - " }\n", - "\n", - " function run_callbacks() {\n", - " try {\n", - " root._bokeh_onload_callbacks.forEach(function(callback) {\n", - " if (callback != null)\n", - " callback();\n", - " });\n", - " } finally {\n", - " delete root._bokeh_onload_callbacks\n", - " }\n", - " console.debug(\"Bokeh: all callbacks have finished\");\n", - " }\n", - "\n", - " function load_libs(css_urls, js_urls, js_modules, callback) {\n", - " if (css_urls == null) css_urls = [];\n", - " if (js_urls == null) js_urls = [];\n", - " if (js_modules == null) js_modules = [];\n", - "\n", - " root._bokeh_onload_callbacks.push(callback);\n", - " if (root._bokeh_is_loading > 0) {\n", - " console.debug(\"Bokeh: BokehJS is being loaded, scheduling callback at\", now());\n", - " return null;\n", - " }\n", - " if (js_urls.length === 0 && js_modules.length === 0) {\n", - " run_callbacks();\n", - " return null;\n", - " }\n", - " console.debug(\"Bokeh: BokehJS not loaded, scheduling load and callback at\", now());\n", - "\n", - " function on_load() {\n", - " root._bokeh_is_loading--;\n", - " if (root._bokeh_is_loading === 0) {\n", - " console.debug(\"Bokeh: all BokehJS libraries/stylesheets loaded\");\n", - " run_callbacks()\n", - " }\n", - " }\n", - "\n", - " function on_error() {\n", - " console.error(\"failed to load \" + url);\n", - " }\n", - "\n", - " for (var i = 0; i < css_urls.length; i++) {\n", - " var url = css_urls[i];\n", - " const element = document.createElement(\"link\");\n", - " element.onload = on_load;\n", - " element.onerror = on_error;\n", - " element.rel = \"stylesheet\";\n", - " element.type = \"text/css\";\n", - " element.href = url;\n", - " console.debug(\"Bokeh: injecting link tag for BokehJS stylesheet: \", url);\n", - " document.body.appendChild(element);\n", - " }\n", - "\n", - " var skip = [];\n", - " if (window.requirejs) {\n", - " window.requirejs.config({'packages': {}, 'paths': {'gridstack': 'https://cdn.jsdelivr.net/npm/gridstack@4.2.5/dist/gridstack-h5', 'notyf': 'https://cdn.jsdelivr.net/npm/notyf@3/notyf.min'}, 'shim': {'gridstack': {'exports': 'GridStack'}}});\n", - " require([\"gridstack\"], function(GridStack) {\n", - "\twindow.GridStack = GridStack\n", - "\ton_load()\n", - " })\n", - " require([\"notyf\"], function() {\n", - "\ton_load()\n", - " })\n", - " root._bokeh_is_loading = css_urls.length + 2;\n", - " } else {\n", - " root._bokeh_is_loading = css_urls.length + js_urls.length + js_modules.length;\n", - " } if (((window['GridStack'] !== undefined) && (!(window['GridStack'] instanceof HTMLElement))) || window.requirejs) {\n", - " var urls = ['https://cdn.holoviz.org/panel/0.14.4/dist/bundled/gridstack/gridstack@4.2.5/dist/gridstack-h5.js'];\n", - " for (var i = 0; i < urls.length; i++) {\n", - " skip.push(urls[i])\n", - " }\n", - " } if (((window['Notyf'] !== undefined) && (!(window['Notyf'] instanceof HTMLElement))) || window.requirejs) {\n", - " var urls = ['https://cdn.holoviz.org/panel/0.14.4/dist/bundled/notificationarea/notyf@3/notyf.min.js'];\n", - " for (var i = 0; i < urls.length; i++) {\n", - " skip.push(urls[i])\n", - " }\n", - " } for (var i = 0; i < js_urls.length; i++) {\n", - " var url = js_urls[i];\n", - " if (skip.indexOf(url) >= 0) {\n", - "\tif (!window.requirejs) {\n", - "\t on_load();\n", - "\t}\n", - "\tcontinue;\n", - " }\n", - " var element = document.createElement('script');\n", - " element.onload = on_load;\n", - " element.onerror = on_error;\n", - " element.async = false;\n", - " element.src = url;\n", - " console.debug(\"Bokeh: injecting script tag for BokehJS library: \", url);\n", - " document.head.appendChild(element);\n", - " }\n", - " for (var i = 0; i < js_modules.length; i++) {\n", - " var url = js_modules[i];\n", - " if (skip.indexOf(url) >= 0) {\n", - "\tif (!window.requirejs) {\n", - "\t on_load();\n", - "\t}\n", - "\tcontinue;\n", - " }\n", - " var element = document.createElement('script');\n", - " element.onload = on_load;\n", - " element.onerror = on_error;\n", - " element.async = false;\n", - " element.src = url;\n", - " element.type = \"module\";\n", - " console.debug(\"Bokeh: injecting script tag for BokehJS library: \", url);\n", - " document.head.appendChild(element);\n", - " }\n", - " if (!js_urls.length && !js_modules.length) {\n", - " on_load()\n", - " }\n", - " };\n", - "\n", - " function inject_raw_css(css) {\n", - " const element = document.createElement(\"style\");\n", - " element.appendChild(document.createTextNode(css));\n", - " document.body.appendChild(element);\n", - " }\n", - "\n", - " var js_urls = [\"https://cdn.bokeh.org/bokeh/release/bokeh-2.4.3.min.js\", \"https://cdn.bokeh.org/bokeh/release/bokeh-gl-2.4.3.min.js\", \"https://cdn.bokeh.org/bokeh/release/bokeh-widgets-2.4.3.min.js\", \"https://cdn.bokeh.org/bokeh/release/bokeh-tables-2.4.3.min.js\", \"https://cdn.bokeh.org/bokeh/release/bokeh-mathjax-2.4.3.min.js\", \"https://unpkg.com/@holoviz/panel@0.14.4/dist/panel.min.js\"];\n", - " var js_modules = [];\n", - " var css_urls = [\"https://cdn.holoviz.org/panel/0.14.4/dist/css/alerts.css\", \"https://cdn.holoviz.org/panel/0.14.4/dist/css/card.css\", \"https://cdn.holoviz.org/panel/0.14.4/dist/css/dataframe.css\", \"https://cdn.holoviz.org/panel/0.14.4/dist/css/debugger.css\", \"https://cdn.holoviz.org/panel/0.14.4/dist/css/json.css\", \"https://cdn.holoviz.org/panel/0.14.4/dist/css/loading.css\", \"https://cdn.holoviz.org/panel/0.14.4/dist/css/markdown.css\", \"https://cdn.holoviz.org/panel/0.14.4/dist/css/widgets.css\"];\n", - " var inline_js = [ function(Bokeh) {\n", - " inject_raw_css(\"\\n .bk.pn-loading.arc:before {\\n background-image: url(\\\"data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHN0eWxlPSJtYXJnaW46IGF1dG87IGJhY2tncm91bmQ6IG5vbmU7IGRpc3BsYXk6IGJsb2NrOyBzaGFwZS1yZW5kZXJpbmc6IGF1dG87IiB2aWV3Qm94PSIwIDAgMTAwIDEwMCIgcHJlc2VydmVBc3BlY3RSYXRpbz0ieE1pZFlNaWQiPiAgPGNpcmNsZSBjeD0iNTAiIGN5PSI1MCIgZmlsbD0ibm9uZSIgc3Ryb2tlPSIjYzNjM2MzIiBzdHJva2Utd2lkdGg9IjEwIiByPSIzNSIgc3Ryb2tlLWRhc2hhcnJheT0iMTY0LjkzMzYxNDMxMzQ2NDE1IDU2Ljk3Nzg3MTQzNzgyMTM4Ij4gICAgPGFuaW1hdGVUcmFuc2Zvcm0gYXR0cmlidXRlTmFtZT0idHJhbnNmb3JtIiB0eXBlPSJyb3RhdGUiIHJlcGVhdENvdW50PSJpbmRlZmluaXRlIiBkdXI9IjFzIiB2YWx1ZXM9IjAgNTAgNTA7MzYwIDUwIDUwIiBrZXlUaW1lcz0iMDsxIj48L2FuaW1hdGVUcmFuc2Zvcm0+ICA8L2NpcmNsZT48L3N2Zz4=\\\");\\n background-size: auto calc(min(50%, 400px));\\n }\\n \");\n", - " }, function(Bokeh) {\n", - " Bokeh.set_log_level(\"info\");\n", - " },\n", - "function(Bokeh) {} // ensure no trailing comma for IE\n", - " ];\n", - "\n", - " function run_inline_js() {\n", - " if ((root.Bokeh !== undefined) || (force === true)) {\n", - " for (var i = 0; i < inline_js.length; i++) {\n", - " inline_js[i].call(root, root.Bokeh);\n", - " }} else if (Date.now() < root._bokeh_timeout) {\n", - " setTimeout(run_inline_js, 100);\n", - " } else if (!root._bokeh_failed_load) {\n", - " console.log(\"Bokeh: BokehJS failed to load within specified timeout.\");\n", - " root._bokeh_failed_load = true;\n", - " }\n", - " }\n", - "\n", - " if (root._bokeh_is_loading === 0) {\n", - " console.debug(\"Bokeh: BokehJS loaded, going straight to plotting\");\n", - " run_inline_js();\n", - " } else {\n", - " load_libs(css_urls, js_urls, js_modules, function() {\n", - " console.debug(\"Bokeh: BokehJS plotting callback run at\", now());\n", - " run_inline_js();\n", - " });\n", - " }\n", - "}(window));" - ], - "application/vnd.holoviews_load.v0+json": "(function(root) {\n function now() {\n return new Date();\n }\n\n var force = true;\n\n if (typeof root._bokeh_onload_callbacks === \"undefined\" || force === true) {\n root._bokeh_onload_callbacks = [];\n root._bokeh_is_loading = undefined;\n }\n\n if (typeof (root._bokeh_timeout) === \"undefined\" || force === true) {\n root._bokeh_timeout = Date.now() + 5000;\n root._bokeh_failed_load = false;\n }\n\n function run_callbacks() {\n try {\n root._bokeh_onload_callbacks.forEach(function(callback) {\n if (callback != null)\n callback();\n });\n } finally {\n delete root._bokeh_onload_callbacks\n }\n console.debug(\"Bokeh: all callbacks have finished\");\n }\n\n function load_libs(css_urls, js_urls, js_modules, callback) {\n if (css_urls == null) css_urls = [];\n if (js_urls == null) js_urls = [];\n if (js_modules == null) js_modules = [];\n\n root._bokeh_onload_callbacks.push(callback);\n if (root._bokeh_is_loading > 0) {\n console.debug(\"Bokeh: BokehJS is being loaded, scheduling callback at\", now());\n return null;\n }\n if (js_urls.length === 0 && js_modules.length === 0) {\n run_callbacks();\n return null;\n }\n console.debug(\"Bokeh: BokehJS not loaded, scheduling load and callback at\", now());\n\n function on_load() {\n root._bokeh_is_loading--;\n if (root._bokeh_is_loading === 0) {\n console.debug(\"Bokeh: all BokehJS libraries/stylesheets loaded\");\n run_callbacks()\n }\n }\n\n function on_error() {\n console.error(\"failed to load \" + url);\n }\n\n for (var i = 0; i < css_urls.length; i++) {\n var url = css_urls[i];\n const element = document.createElement(\"link\");\n element.onload = on_load;\n element.onerror = on_error;\n element.rel = \"stylesheet\";\n element.type = \"text/css\";\n element.href = url;\n console.debug(\"Bokeh: injecting link tag for BokehJS stylesheet: \", url);\n document.body.appendChild(element);\n }\n\n var skip = [];\n if (window.requirejs) {\n window.requirejs.config({'packages': {}, 'paths': {'gridstack': 'https://cdn.jsdelivr.net/npm/gridstack@4.2.5/dist/gridstack-h5', 'notyf': 'https://cdn.jsdelivr.net/npm/notyf@3/notyf.min'}, 'shim': {'gridstack': {'exports': 'GridStack'}}});\n require([\"gridstack\"], function(GridStack) {\n\twindow.GridStack = GridStack\n\ton_load()\n })\n require([\"notyf\"], function() {\n\ton_load()\n })\n root._bokeh_is_loading = css_urls.length + 2;\n } else {\n root._bokeh_is_loading = css_urls.length + js_urls.length + js_modules.length;\n } if (((window['GridStack'] !== undefined) && (!(window['GridStack'] instanceof HTMLElement))) || window.requirejs) {\n var urls = ['https://cdn.holoviz.org/panel/0.14.4/dist/bundled/gridstack/gridstack@4.2.5/dist/gridstack-h5.js'];\n for (var i = 0; i < urls.length; i++) {\n skip.push(urls[i])\n }\n } if (((window['Notyf'] !== undefined) && (!(window['Notyf'] instanceof HTMLElement))) || window.requirejs) {\n var urls = ['https://cdn.holoviz.org/panel/0.14.4/dist/bundled/notificationarea/notyf@3/notyf.min.js'];\n for (var i = 0; i < urls.length; i++) {\n skip.push(urls[i])\n }\n } for (var i = 0; i < js_urls.length; i++) {\n var url = js_urls[i];\n if (skip.indexOf(url) >= 0) {\n\tif (!window.requirejs) {\n\t on_load();\n\t}\n\tcontinue;\n }\n var element = document.createElement('script');\n element.onload = on_load;\n element.onerror = on_error;\n element.async = false;\n element.src = url;\n console.debug(\"Bokeh: injecting script tag for BokehJS library: \", url);\n document.head.appendChild(element);\n }\n for (var i = 0; i < js_modules.length; i++) {\n var url = js_modules[i];\n if (skip.indexOf(url) >= 0) {\n\tif (!window.requirejs) {\n\t on_load();\n\t}\n\tcontinue;\n }\n var element = document.createElement('script');\n element.onload = on_load;\n element.onerror = on_error;\n element.async = false;\n element.src = url;\n element.type = \"module\";\n console.debug(\"Bokeh: injecting script tag for BokehJS library: \", url);\n document.head.appendChild(element);\n }\n if (!js_urls.length && !js_modules.length) {\n on_load()\n }\n };\n\n function inject_raw_css(css) {\n const element = document.createElement(\"style\");\n element.appendChild(document.createTextNode(css));\n document.body.appendChild(element);\n }\n\n var js_urls = [\"https://cdn.bokeh.org/bokeh/release/bokeh-2.4.3.min.js\", \"https://cdn.bokeh.org/bokeh/release/bokeh-gl-2.4.3.min.js\", \"https://cdn.bokeh.org/bokeh/release/bokeh-widgets-2.4.3.min.js\", \"https://cdn.bokeh.org/bokeh/release/bokeh-tables-2.4.3.min.js\", \"https://cdn.bokeh.org/bokeh/release/bokeh-mathjax-2.4.3.min.js\", \"https://unpkg.com/@holoviz/panel@0.14.4/dist/panel.min.js\"];\n var js_modules = [];\n var css_urls = [\"https://cdn.holoviz.org/panel/0.14.4/dist/css/alerts.css\", \"https://cdn.holoviz.org/panel/0.14.4/dist/css/card.css\", \"https://cdn.holoviz.org/panel/0.14.4/dist/css/dataframe.css\", \"https://cdn.holoviz.org/panel/0.14.4/dist/css/debugger.css\", \"https://cdn.holoviz.org/panel/0.14.4/dist/css/json.css\", \"https://cdn.holoviz.org/panel/0.14.4/dist/css/loading.css\", \"https://cdn.holoviz.org/panel/0.14.4/dist/css/markdown.css\", \"https://cdn.holoviz.org/panel/0.14.4/dist/css/widgets.css\"];\n var inline_js = [ function(Bokeh) {\n inject_raw_css(\"\\n .bk.pn-loading.arc:before {\\n background-image: url(\\\"data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHN0eWxlPSJtYXJnaW46IGF1dG87IGJhY2tncm91bmQ6IG5vbmU7IGRpc3BsYXk6IGJsb2NrOyBzaGFwZS1yZW5kZXJpbmc6IGF1dG87IiB2aWV3Qm94PSIwIDAgMTAwIDEwMCIgcHJlc2VydmVBc3BlY3RSYXRpbz0ieE1pZFlNaWQiPiAgPGNpcmNsZSBjeD0iNTAiIGN5PSI1MCIgZmlsbD0ibm9uZSIgc3Ryb2tlPSIjYzNjM2MzIiBzdHJva2Utd2lkdGg9IjEwIiByPSIzNSIgc3Ryb2tlLWRhc2hhcnJheT0iMTY0LjkzMzYxNDMxMzQ2NDE1IDU2Ljk3Nzg3MTQzNzgyMTM4Ij4gICAgPGFuaW1hdGVUcmFuc2Zvcm0gYXR0cmlidXRlTmFtZT0idHJhbnNmb3JtIiB0eXBlPSJyb3RhdGUiIHJlcGVhdENvdW50PSJpbmRlZmluaXRlIiBkdXI9IjFzIiB2YWx1ZXM9IjAgNTAgNTA7MzYwIDUwIDUwIiBrZXlUaW1lcz0iMDsxIj48L2FuaW1hdGVUcmFuc2Zvcm0+ICA8L2NpcmNsZT48L3N2Zz4=\\\");\\n background-size: auto calc(min(50%, 400px));\\n }\\n \");\n }, function(Bokeh) {\n Bokeh.set_log_level(\"info\");\n },\nfunction(Bokeh) {} // ensure no trailing comma for IE\n ];\n\n function run_inline_js() {\n if ((root.Bokeh !== undefined) || (force === true)) {\n for (var i = 0; i < inline_js.length; i++) {\n inline_js[i].call(root, root.Bokeh);\n }} else if (Date.now() < root._bokeh_timeout) {\n setTimeout(run_inline_js, 100);\n } else if (!root._bokeh_failed_load) {\n console.log(\"Bokeh: BokehJS failed to load within specified timeout.\");\n root._bokeh_failed_load = true;\n }\n }\n\n if (root._bokeh_is_loading === 0) {\n console.debug(\"Bokeh: BokehJS loaded, going straight to plotting\");\n run_inline_js();\n } else {\n load_libs(css_urls, js_urls, js_modules, function() {\n console.debug(\"Bokeh: BokehJS plotting callback run at\", now());\n run_inline_js();\n });\n }\n}(window));" - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "application/javascript": [ - "\n", - "if ((window.PyViz === undefined) || (window.PyViz instanceof HTMLElement)) {\n", - " window.PyViz = {comms: {}, comm_status:{}, kernels:{}, receivers: {}, plot_index: []}\n", - "}\n", - "\n", - "\n", - " function JupyterCommManager() {\n", - " }\n", - "\n", - " JupyterCommManager.prototype.register_target = function(plot_id, comm_id, msg_handler) {\n", - " if (window.comm_manager || ((window.Jupyter !== undefined) && (Jupyter.notebook.kernel != null))) {\n", - " var comm_manager = window.comm_manager || Jupyter.notebook.kernel.comm_manager;\n", - " comm_manager.register_target(comm_id, function(comm) {\n", - " comm.on_msg(msg_handler);\n", - " });\n", - " } else if ((plot_id in window.PyViz.kernels) && (window.PyViz.kernels[plot_id])) {\n", - " window.PyViz.kernels[plot_id].registerCommTarget(comm_id, function(comm) {\n", - " comm.onMsg = msg_handler;\n", - " });\n", - " } else if (typeof google != 'undefined' && google.colab.kernel != null) {\n", - " google.colab.kernel.comms.registerTarget(comm_id, (comm) => {\n", - " var messages = comm.messages[Symbol.asyncIterator]();\n", - " function processIteratorResult(result) {\n", - " var message = result.value;\n", - " console.log(message)\n", - " var content = {data: message.data, comm_id};\n", - " var buffers = []\n", - " for (var buffer of message.buffers || []) {\n", - " buffers.push(new DataView(buffer))\n", - " }\n", - " var metadata = message.metadata || {};\n", - " var msg = {content, buffers, metadata}\n", - " msg_handler(msg);\n", - " return messages.next().then(processIteratorResult);\n", - " }\n", - " return messages.next().then(processIteratorResult);\n", - " })\n", - " }\n", - " }\n", - "\n", - " JupyterCommManager.prototype.get_client_comm = function(plot_id, comm_id, msg_handler) {\n", - " if (comm_id in window.PyViz.comms) {\n", - " return window.PyViz.comms[comm_id];\n", - " } else if (window.comm_manager || ((window.Jupyter !== undefined) && (Jupyter.notebook.kernel != null))) {\n", - " var comm_manager = window.comm_manager || Jupyter.notebook.kernel.comm_manager;\n", - " var comm = comm_manager.new_comm(comm_id, {}, {}, {}, comm_id);\n", - " if (msg_handler) {\n", - " comm.on_msg(msg_handler);\n", - " }\n", - " } else if ((plot_id in window.PyViz.kernels) && (window.PyViz.kernels[plot_id])) {\n", - " var comm = window.PyViz.kernels[plot_id].connectToComm(comm_id);\n", - " comm.open();\n", - " if (msg_handler) {\n", - " comm.onMsg = msg_handler;\n", - " }\n", - " } else if (typeof google != 'undefined' && google.colab.kernel != null) {\n", - " var comm_promise = google.colab.kernel.comms.open(comm_id)\n", - " comm_promise.then((comm) => {\n", - " window.PyViz.comms[comm_id] = comm;\n", - " if (msg_handler) {\n", - " var messages = comm.messages[Symbol.asyncIterator]();\n", - " function processIteratorResult(result) {\n", - " var message = result.value;\n", - " var content = {data: message.data};\n", - " var metadata = message.metadata || {comm_id};\n", - " var msg = {content, metadata}\n", - " msg_handler(msg);\n", - " return messages.next().then(processIteratorResult);\n", - " }\n", - " return messages.next().then(processIteratorResult);\n", - " }\n", - " }) \n", - " var sendClosure = (data, metadata, buffers, disposeOnDone) => {\n", - " return comm_promise.then((comm) => {\n", - " comm.send(data, metadata, buffers, disposeOnDone);\n", - " });\n", - " };\n", - " var comm = {\n", - " send: sendClosure\n", - " };\n", - " }\n", - " window.PyViz.comms[comm_id] = comm;\n", - " return comm;\n", - " }\n", - " window.PyViz.comm_manager = new JupyterCommManager();\n", - " \n", - "\n", - "\n", - "var JS_MIME_TYPE = 'application/javascript';\n", - "var HTML_MIME_TYPE = 'text/html';\n", - "var EXEC_MIME_TYPE = 'application/vnd.holoviews_exec.v0+json';\n", - "var CLASS_NAME = 'output';\n", - "\n", - "/**\n", - " * Render data to the DOM node\n", - " */\n", - "function render(props, node) {\n", - " var div = document.createElement(\"div\");\n", - " var script = document.createElement(\"script\");\n", - " node.appendChild(div);\n", - " node.appendChild(script);\n", - "}\n", - "\n", - "/**\n", - " * Handle when a new output is added\n", - " */\n", - "function handle_add_output(event, handle) {\n", - " var output_area = handle.output_area;\n", - " var output = handle.output;\n", - " if ((output.data == undefined) || (!output.data.hasOwnProperty(EXEC_MIME_TYPE))) {\n", - " return\n", - " }\n", - " var id = output.metadata[EXEC_MIME_TYPE][\"id\"];\n", - " var toinsert = output_area.element.find(\".\" + CLASS_NAME.split(' ')[0]);\n", - " if (id !== undefined) {\n", - " var nchildren = toinsert.length;\n", - " var html_node = toinsert[nchildren-1].children[0];\n", - " html_node.innerHTML = output.data[HTML_MIME_TYPE];\n", - " var scripts = [];\n", - " var nodelist = html_node.querySelectorAll(\"script\");\n", - " for (var i in nodelist) {\n", - " if (nodelist.hasOwnProperty(i)) {\n", - " scripts.push(nodelist[i])\n", - " }\n", - " }\n", - "\n", - " scripts.forEach( function (oldScript) {\n", - " var newScript = document.createElement(\"script\");\n", - " var attrs = [];\n", - " var nodemap = oldScript.attributes;\n", - " for (var j in nodemap) {\n", - " if (nodemap.hasOwnProperty(j)) {\n", - " attrs.push(nodemap[j])\n", - " }\n", - " }\n", - " attrs.forEach(function(attr) { newScript.setAttribute(attr.name, attr.value) });\n", - " newScript.appendChild(document.createTextNode(oldScript.innerHTML));\n", - " oldScript.parentNode.replaceChild(newScript, oldScript);\n", - " });\n", - " if (JS_MIME_TYPE in output.data) {\n", - " toinsert[nchildren-1].children[1].textContent = output.data[JS_MIME_TYPE];\n", - " }\n", - " output_area._hv_plot_id = id;\n", - " if ((window.Bokeh !== undefined) && (id in Bokeh.index)) {\n", - " window.PyViz.plot_index[id] = Bokeh.index[id];\n", - " } else {\n", - " window.PyViz.plot_index[id] = null;\n", - " }\n", - " } else if (output.metadata[EXEC_MIME_TYPE][\"server_id\"] !== undefined) {\n", - " var bk_div = document.createElement(\"div\");\n", - " bk_div.innerHTML = output.data[HTML_MIME_TYPE];\n", - " var script_attrs = bk_div.children[0].attributes;\n", - " for (var i = 0; i < script_attrs.length; i++) {\n", - " toinsert[toinsert.length - 1].childNodes[1].setAttribute(script_attrs[i].name, script_attrs[i].value);\n", - " }\n", - " // store reference to server id on output_area\n", - " output_area._bokeh_server_id = output.metadata[EXEC_MIME_TYPE][\"server_id\"];\n", - " }\n", - "}\n", - "\n", - "/**\n", - " * Handle when an output is cleared or removed\n", - " */\n", - "function handle_clear_output(event, handle) {\n", - " var id = handle.cell.output_area._hv_plot_id;\n", - " var server_id = handle.cell.output_area._bokeh_server_id;\n", - " if (((id === undefined) || !(id in PyViz.plot_index)) && (server_id !== undefined)) { return; }\n", - " var comm = window.PyViz.comm_manager.get_client_comm(\"hv-extension-comm\", \"hv-extension-comm\", function () {});\n", - " if (server_id !== null) {\n", - " comm.send({event_type: 'server_delete', 'id': server_id});\n", - " return;\n", - " } else if (comm !== null) {\n", - " comm.send({event_type: 'delete', 'id': id});\n", - " }\n", - " delete PyViz.plot_index[id];\n", - " if ((window.Bokeh !== undefined) & (id in window.Bokeh.index)) {\n", - " var doc = window.Bokeh.index[id].model.document\n", - " doc.clear();\n", - " const i = window.Bokeh.documents.indexOf(doc);\n", - " if (i > -1) {\n", - " window.Bokeh.documents.splice(i, 1);\n", - " }\n", - " }\n", - "}\n", - "\n", - "/**\n", - " * Handle kernel restart event\n", - " */\n", - "function handle_kernel_cleanup(event, handle) {\n", - " delete PyViz.comms[\"hv-extension-comm\"];\n", - " window.PyViz.plot_index = {}\n", - "}\n", - "\n", - "/**\n", - " * Handle update_display_data messages\n", - " */\n", - "function handle_update_output(event, handle) {\n", - " handle_clear_output(event, {cell: {output_area: handle.output_area}})\n", - " handle_add_output(event, handle)\n", - "}\n", - "\n", - "function register_renderer(events, OutputArea) {\n", - " function append_mime(data, metadata, element) {\n", - " // create a DOM node to render to\n", - " var toinsert = this.create_output_subarea(\n", - " metadata,\n", - " CLASS_NAME,\n", - " EXEC_MIME_TYPE\n", - " );\n", - " this.keyboard_manager.register_events(toinsert);\n", - " // Render to node\n", - " var props = {data: data, metadata: metadata[EXEC_MIME_TYPE]};\n", - " render(props, toinsert[0]);\n", - " element.append(toinsert);\n", - " return toinsert\n", - " }\n", - "\n", - " events.on('output_added.OutputArea', handle_add_output);\n", - " events.on('output_updated.OutputArea', handle_update_output);\n", - " events.on('clear_output.CodeCell', handle_clear_output);\n", - " events.on('delete.Cell', handle_clear_output);\n", - " events.on('kernel_ready.Kernel', handle_kernel_cleanup);\n", - "\n", - " OutputArea.prototype.register_mime_type(EXEC_MIME_TYPE, append_mime, {\n", - " safe: true,\n", - " index: 0\n", - " });\n", - "}\n", - "\n", - "if (window.Jupyter !== undefined) {\n", - " try {\n", - " var events = require('base/js/events');\n", - " var OutputArea = require('notebook/js/outputarea').OutputArea;\n", - " if (OutputArea.prototype.mime_types().indexOf(EXEC_MIME_TYPE) == -1) {\n", - " register_renderer(events, OutputArea);\n", - " }\n", - " } catch(err) {\n", - " }\n", - "}\n" - ], - "application/vnd.holoviews_load.v0+json": "\nif ((window.PyViz === undefined) || (window.PyViz instanceof HTMLElement)) {\n window.PyViz = {comms: {}, comm_status:{}, kernels:{}, receivers: {}, plot_index: []}\n}\n\n\n function JupyterCommManager() {\n }\n\n JupyterCommManager.prototype.register_target = function(plot_id, comm_id, msg_handler) {\n if (window.comm_manager || ((window.Jupyter !== undefined) && (Jupyter.notebook.kernel != null))) {\n var comm_manager = window.comm_manager || Jupyter.notebook.kernel.comm_manager;\n comm_manager.register_target(comm_id, function(comm) {\n comm.on_msg(msg_handler);\n });\n } else if ((plot_id in window.PyViz.kernels) && (window.PyViz.kernels[plot_id])) {\n window.PyViz.kernels[plot_id].registerCommTarget(comm_id, function(comm) {\n comm.onMsg = msg_handler;\n });\n } else if (typeof google != 'undefined' && google.colab.kernel != null) {\n google.colab.kernel.comms.registerTarget(comm_id, (comm) => {\n var messages = comm.messages[Symbol.asyncIterator]();\n function processIteratorResult(result) {\n var message = result.value;\n console.log(message)\n var content = {data: message.data, comm_id};\n var buffers = []\n for (var buffer of message.buffers || []) {\n buffers.push(new DataView(buffer))\n }\n var metadata = message.metadata || {};\n var msg = {content, buffers, metadata}\n msg_handler(msg);\n return messages.next().then(processIteratorResult);\n }\n return messages.next().then(processIteratorResult);\n })\n }\n }\n\n JupyterCommManager.prototype.get_client_comm = function(plot_id, comm_id, msg_handler) {\n if (comm_id in window.PyViz.comms) {\n return window.PyViz.comms[comm_id];\n } else if (window.comm_manager || ((window.Jupyter !== undefined) && (Jupyter.notebook.kernel != null))) {\n var comm_manager = window.comm_manager || Jupyter.notebook.kernel.comm_manager;\n var comm = comm_manager.new_comm(comm_id, {}, {}, {}, comm_id);\n if (msg_handler) {\n comm.on_msg(msg_handler);\n }\n } else if ((plot_id in window.PyViz.kernels) && (window.PyViz.kernels[plot_id])) {\n var comm = window.PyViz.kernels[plot_id].connectToComm(comm_id);\n comm.open();\n if (msg_handler) {\n comm.onMsg = msg_handler;\n }\n } else if (typeof google != 'undefined' && google.colab.kernel != null) {\n var comm_promise = google.colab.kernel.comms.open(comm_id)\n comm_promise.then((comm) => {\n window.PyViz.comms[comm_id] = comm;\n if (msg_handler) {\n var messages = comm.messages[Symbol.asyncIterator]();\n function processIteratorResult(result) {\n var message = result.value;\n var content = {data: message.data};\n var metadata = message.metadata || {comm_id};\n var msg = {content, metadata}\n msg_handler(msg);\n return messages.next().then(processIteratorResult);\n }\n return messages.next().then(processIteratorResult);\n }\n }) \n var sendClosure = (data, metadata, buffers, disposeOnDone) => {\n return comm_promise.then((comm) => {\n comm.send(data, metadata, buffers, disposeOnDone);\n });\n };\n var comm = {\n send: sendClosure\n };\n }\n window.PyViz.comms[comm_id] = comm;\n return comm;\n }\n window.PyViz.comm_manager = new JupyterCommManager();\n \n\n\nvar JS_MIME_TYPE = 'application/javascript';\nvar HTML_MIME_TYPE = 'text/html';\nvar EXEC_MIME_TYPE = 'application/vnd.holoviews_exec.v0+json';\nvar CLASS_NAME = 'output';\n\n/**\n * Render data to the DOM node\n */\nfunction render(props, node) {\n var div = document.createElement(\"div\");\n var script = document.createElement(\"script\");\n node.appendChild(div);\n node.appendChild(script);\n}\n\n/**\n * Handle when a new output is added\n */\nfunction handle_add_output(event, handle) {\n var output_area = handle.output_area;\n var output = handle.output;\n if ((output.data == undefined) || (!output.data.hasOwnProperty(EXEC_MIME_TYPE))) {\n return\n }\n var id = output.metadata[EXEC_MIME_TYPE][\"id\"];\n var toinsert = output_area.element.find(\".\" + CLASS_NAME.split(' ')[0]);\n if (id !== undefined) {\n var nchildren = toinsert.length;\n var html_node = toinsert[nchildren-1].children[0];\n html_node.innerHTML = output.data[HTML_MIME_TYPE];\n var scripts = [];\n var nodelist = html_node.querySelectorAll(\"script\");\n for (var i in nodelist) {\n if (nodelist.hasOwnProperty(i)) {\n scripts.push(nodelist[i])\n }\n }\n\n scripts.forEach( function (oldScript) {\n var newScript = document.createElement(\"script\");\n var attrs = [];\n var nodemap = oldScript.attributes;\n for (var j in nodemap) {\n if (nodemap.hasOwnProperty(j)) {\n attrs.push(nodemap[j])\n }\n }\n attrs.forEach(function(attr) { newScript.setAttribute(attr.name, attr.value) });\n newScript.appendChild(document.createTextNode(oldScript.innerHTML));\n oldScript.parentNode.replaceChild(newScript, oldScript);\n });\n if (JS_MIME_TYPE in output.data) {\n toinsert[nchildren-1].children[1].textContent = output.data[JS_MIME_TYPE];\n }\n output_area._hv_plot_id = id;\n if ((window.Bokeh !== undefined) && (id in Bokeh.index)) {\n window.PyViz.plot_index[id] = Bokeh.index[id];\n } else {\n window.PyViz.plot_index[id] = null;\n }\n } else if (output.metadata[EXEC_MIME_TYPE][\"server_id\"] !== undefined) {\n var bk_div = document.createElement(\"div\");\n bk_div.innerHTML = output.data[HTML_MIME_TYPE];\n var script_attrs = bk_div.children[0].attributes;\n for (var i = 0; i < script_attrs.length; i++) {\n toinsert[toinsert.length - 1].childNodes[1].setAttribute(script_attrs[i].name, script_attrs[i].value);\n }\n // store reference to server id on output_area\n output_area._bokeh_server_id = output.metadata[EXEC_MIME_TYPE][\"server_id\"];\n }\n}\n\n/**\n * Handle when an output is cleared or removed\n */\nfunction handle_clear_output(event, handle) {\n var id = handle.cell.output_area._hv_plot_id;\n var server_id = handle.cell.output_area._bokeh_server_id;\n if (((id === undefined) || !(id in PyViz.plot_index)) && (server_id !== undefined)) { return; }\n var comm = window.PyViz.comm_manager.get_client_comm(\"hv-extension-comm\", \"hv-extension-comm\", function () {});\n if (server_id !== null) {\n comm.send({event_type: 'server_delete', 'id': server_id});\n return;\n } else if (comm !== null) {\n comm.send({event_type: 'delete', 'id': id});\n }\n delete PyViz.plot_index[id];\n if ((window.Bokeh !== undefined) & (id in window.Bokeh.index)) {\n var doc = window.Bokeh.index[id].model.document\n doc.clear();\n const i = window.Bokeh.documents.indexOf(doc);\n if (i > -1) {\n window.Bokeh.documents.splice(i, 1);\n }\n }\n}\n\n/**\n * Handle kernel restart event\n */\nfunction handle_kernel_cleanup(event, handle) {\n delete PyViz.comms[\"hv-extension-comm\"];\n window.PyViz.plot_index = {}\n}\n\n/**\n * Handle update_display_data messages\n */\nfunction handle_update_output(event, handle) {\n handle_clear_output(event, {cell: {output_area: handle.output_area}})\n handle_add_output(event, handle)\n}\n\nfunction register_renderer(events, OutputArea) {\n function append_mime(data, metadata, element) {\n // create a DOM node to render to\n var toinsert = this.create_output_subarea(\n metadata,\n CLASS_NAME,\n EXEC_MIME_TYPE\n );\n this.keyboard_manager.register_events(toinsert);\n // Render to node\n var props = {data: data, metadata: metadata[EXEC_MIME_TYPE]};\n render(props, toinsert[0]);\n element.append(toinsert);\n return toinsert\n }\n\n events.on('output_added.OutputArea', handle_add_output);\n events.on('output_updated.OutputArea', handle_update_output);\n events.on('clear_output.CodeCell', handle_clear_output);\n events.on('delete.Cell', handle_clear_output);\n events.on('kernel_ready.Kernel', handle_kernel_cleanup);\n\n OutputArea.prototype.register_mime_type(EXEC_MIME_TYPE, append_mime, {\n safe: true,\n index: 0\n });\n}\n\nif (window.Jupyter !== undefined) {\n try {\n var events = require('base/js/events');\n var OutputArea = require('notebook/js/outputarea').OutputArea;\n if (OutputArea.prototype.mime_types().indexOf(EXEC_MIME_TYPE) == -1) {\n register_renderer(events, OutputArea);\n }\n } catch(err) {\n }\n}\n" - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/html": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": {}, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": {}, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "application/vnd.holoviews_exec.v0+json": "", - "text/html": [ - "
\n", - "
\n", - "
\n", - "" - ], - "text/plain": [ - "Column\n", - " [0] HoloViews(DynamicMap, widget_location='bottom', widget_type='scrubber')\n", - " [1] Row\n", - " [0] HSpacer()\n", - " [1] WidgetBox\n", - " [0] Player(end=14, width=550)\n", - " [2] HSpacer()" - ] - }, - "execution_count": 29, - "metadata": { - "application/vnd.holoviews_exec.v0+json": { - "id": "1119" - } - }, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "# Let's explore plotting the data interactively using Xarray and Holoviews\n", "hvplot.extension('matplotlib')\n", @@ -5443,7 +1028,7 @@ }, { "cell_type": "code", - "execution_count": 30, + "execution_count": null, "id": "64f4a56e-23dd-492d-b433-14412e22590a", "metadata": { "tags": [] @@ -5481,20 +1066,12 @@ }, { "cell_type": "code", - "execution_count": 32, + "execution_count": null, "id": "339bcb88-0bcc-40bc-8a83-fdef598b0c91", "metadata": { "tags": [] }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Using earthaccess v0.5.3\n" - ] - } - ], + "outputs": [], "source": [ "# Import earthaccess Library and view version\n", "import earthaccess\n", @@ -5526,21 +1103,12 @@ }, { "cell_type": "code", - "execution_count": 37, + "execution_count": null, "id": "4be86745-179a-4010-b033-3e2e10438fdd", "metadata": { "tags": [] }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "We are already authenticated with NASA EDL\n", - "True\n" - ] - } - ], + "outputs": [], "source": [ "# Try to authenticate\n", "auth = earthaccess.login()\n", @@ -5559,40 +1127,12 @@ }, { "cell_type": "code", - "execution_count": 35, + "execution_count": null, "id": "c0e74d67-7dc5-4404-a8fe-fbec06801bca", "metadata": { "tags": [] }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Datasets found: 131\n", - "{'concept-id': 'C1595422627-ASF',\n", - " 'file-type': '',\n", - " 'get-data': [],\n", - " 'short-name': 'SENTINEL-1_INTERFEROGRAMS',\n", - " 'version': '1'}\n", - "{'cloud-info': {'Region': 'us-west-2',\n", - " 'S3BucketAndObjectPrefixNames': ['s3://lp-prod-protected/HLSS30.020',\n", - " 's3://lp-prod-public/HLSS30.020'],\n", - " 'S3CredentialsAPIDocumentationURL': 'https://data.lpdaac.earthdatacloud.nasa.gov/s3credentialsREADME',\n", - " 'S3CredentialsAPIEndpoint': 'https://data.lpdaac.earthdatacloud.nasa.gov/s3credentials'},\n", - " 'concept-id': 'C2021957295-LPCLOUD',\n", - " 'file-type': \"[{'Format': 'Cloud Optimized GeoTIFF (COG)', 'FormatType': \"\n", - " \"'Native', 'Media': ['Earthdata Cloud', 'HTTPS'], \"\n", - " \"'AverageFileSize': 20.0, 'AverageFileSizeUnit': 'MB', \"\n", - " \"'TotalCollectionFileSizeBeginDate': \"\n", - " \"'2015-11-28T00:00:00.000Z'}]\",\n", - " 'get-data': ['https://search.earthdata.nasa.gov/search?q=C2021957295-LPCLOUD',\n", - " 'https://appeears.earthdatacloud.nasa.gov/'],\n", - " 'short-name': 'HLSS30',\n", - " 'version': '2.0'}\n" - ] - } - ], + "outputs": [], "source": [ "# Using a keyword search\n", "\n", @@ -5606,59 +1146,12 @@ }, { "cell_type": "code", - "execution_count": 36, + "execution_count": null, "id": "197a6bb3-9ca7-4353-99e8-b3acb0691f53", "metadata": { "tags": [] }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Datasets found: 1\n", - "{'cloud-info': {'Region': 'us-west-2',\n", - " 'S3BucketAndObjectPrefixNames': ['s3://lp-prod-protected/HLSS30.020',\n", - " 's3://lp-prod-public/HLSS30.020'],\n", - " 'S3CredentialsAPIDocumentationURL': 'https://data.lpdaac.earthdatacloud.nasa.gov/s3credentialsREADME',\n", - " 'S3CredentialsAPIEndpoint': 'https://data.lpdaac.earthdatacloud.nasa.gov/s3credentials'},\n", - " 'concept-id': 'C2021957295-LPCLOUD',\n", - " 'file-type': \"[{'Format': 'Cloud Optimized GeoTIFF (COG)', 'FormatType': \"\n", - " \"'Native', 'Media': ['Earthdata Cloud', 'HTTPS'], \"\n", - " \"'AverageFileSize': 20.0, 'AverageFileSizeUnit': 'MB', \"\n", - " \"'TotalCollectionFileSizeBeginDate': \"\n", - " \"'2015-11-28T00:00:00.000Z'}]\",\n", - " 'get-data': ['https://search.earthdata.nasa.gov/search?q=C2021957295-LPCLOUD',\n", - " 'https://appeears.earthdatacloud.nasa.gov/'],\n", - " 'short-name': 'HLSS30',\n", - " 'version': '2.0'}\n", - "('The Harmonized Landsat Sentinel-2 (HLS) project provides consistent surface '\n", - " 'reflectance data from the Operational Land Imager (OLI) aboard the joint '\n", - " 'NASA/USGS Landsat 8 satellite and the Multi-Spectral Instrument (MSI) aboard '\n", - " 'Europe’s Copernicus Sentinel-2A and Sentinel-2B satellites. The combined '\n", - " 'measurement enables global observations of the land every 2–3 days at '\n", - " '30-meter (m) spatial resolution. The HLS project uses a set of algorithms to '\n", - " 'obtain seamless products from OLI and MSI that include atmospheric '\n", - " 'correction, cloud and cloud-shadow masking, spatial co-registration and '\n", - " 'common gridding, illumination and view angle normalization, and spectral '\n", - " 'bandpass adjustment. \\r\\n'\n", - " '\\r\\n'\n", - " 'The HLSS30 product provides 30-m Nadir Bidirectional Reflectance '\n", - " 'Distribution Function (BRDF)-Adjusted Reflectance (NBAR) and is derived from '\n", - " 'Sentinel-2A and Sentinel-2B MSI data products. The HLSS30 and HLSL30 '\n", - " 'products are gridded to the same resolution and Military Grid Reference '\n", - " 'System (MGRS) '\n", - " '(https://hls.gsfc.nasa.gov/products-description/tiling-system/) tiling '\n", - " 'system, and thus are “stackable” for time series analysis.\\r\\n'\n", - " '\\r\\n'\n", - " 'The HLSS30 product is provided in Cloud Optimized GeoTIFF (COG) format, and '\n", - " 'each band is distributed as a separate COG. There are 13 bands included in '\n", - " 'the HLSS30 product along with four angle bands and a quality assessment (QA) '\n", - " 'band. See the User Guide for a more detailed description of the individual '\n", - " 'bands provided in the HLSS30 product.\\r\\n')\n" - ] - } - ], + "outputs": [], "source": [ "# Using a known short name\n", "datasets = earthaccess.search_datasets(short_name=\"HLSS30\",\n", @@ -5695,25 +1188,12 @@ }, { "cell_type": "code", - "execution_count": 37, + "execution_count": null, "id": "c61b74b9-6a08-4938-8ed1-3ef8545eae43", "metadata": { "tags": [] }, - "outputs": [ - { - "data": { - "text/plain": [ - "{'concept_id': ['C2021957295-LPCLOUD'],\n", - " 'bounding_box': '-22.1649,63.3052,-11.9366,65.597',\n", - " 'temporal': ['2020-01-01T00:00:00Z,2023-01-01T00:00:00Z']}" - ] - }, - "execution_count": 37, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "# Using a specific concept-id, which is unique to the specific product and version\n", "\n", @@ -5727,23 +1207,12 @@ }, { "cell_type": "code", - "execution_count": 38, + "execution_count": null, "id": "ef5ba481-f579-4a5c-a34b-8f19097ae1b6", "metadata": { "tags": [] }, - "outputs": [ - { - "data": { - "text/plain": [ - "5380" - ] - }, - "execution_count": 38, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "granules_query.hits()" ] @@ -5760,40 +1229,12 @@ }, { "cell_type": "code", - "execution_count": 39, + "execution_count": null, "id": "c92d48d0-524c-4a08-8845-4c1a8326c4d1", "metadata": { "tags": [] }, - "outputs": [ - { - "data": { - "text/plain": [ - "['https://data.lpdaac.earthdatacloud.nasa.gov/lp-prod-protected/HLSS30.020/HLS.S30.T27VWL.2020048T131259.v2.0/HLS.S30.T27VWL.2020048T131259.v2.0.B09.tif',\n", - " 'https://data.lpdaac.earthdatacloud.nasa.gov/lp-prod-protected/HLSS30.020/HLS.S30.T27VWL.2020048T131259.v2.0/HLS.S30.T27VWL.2020048T131259.v2.0.B05.tif',\n", - " 'https://data.lpdaac.earthdatacloud.nasa.gov/lp-prod-protected/HLSS30.020/HLS.S30.T27VWL.2020048T131259.v2.0/HLS.S30.T27VWL.2020048T131259.v2.0.B10.tif',\n", - " 'https://data.lpdaac.earthdatacloud.nasa.gov/lp-prod-protected/HLSS30.020/HLS.S30.T27VWL.2020048T131259.v2.0/HLS.S30.T27VWL.2020048T131259.v2.0.B03.tif',\n", - " 'https://data.lpdaac.earthdatacloud.nasa.gov/lp-prod-protected/HLSS30.020/HLS.S30.T27VWL.2020048T131259.v2.0/HLS.S30.T27VWL.2020048T131259.v2.0.B08.tif',\n", - " 'https://data.lpdaac.earthdatacloud.nasa.gov/lp-prod-protected/HLSS30.020/HLS.S30.T27VWL.2020048T131259.v2.0/HLS.S30.T27VWL.2020048T131259.v2.0.B06.tif',\n", - " 'https://data.lpdaac.earthdatacloud.nasa.gov/lp-prod-protected/HLSS30.020/HLS.S30.T27VWL.2020048T131259.v2.0/HLS.S30.T27VWL.2020048T131259.v2.0.B07.tif',\n", - " 'https://data.lpdaac.earthdatacloud.nasa.gov/lp-prod-protected/HLSS30.020/HLS.S30.T27VWL.2020048T131259.v2.0/HLS.S30.T27VWL.2020048T131259.v2.0.Fmask.tif',\n", - " 'https://data.lpdaac.earthdatacloud.nasa.gov/lp-prod-protected/HLSS30.020/HLS.S30.T27VWL.2020048T131259.v2.0/HLS.S30.T27VWL.2020048T131259.v2.0.B8A.tif',\n", - " 'https://data.lpdaac.earthdatacloud.nasa.gov/lp-prod-protected/HLSS30.020/HLS.S30.T27VWL.2020048T131259.v2.0/HLS.S30.T27VWL.2020048T131259.v2.0.SAA.tif',\n", - " 'https://data.lpdaac.earthdatacloud.nasa.gov/lp-prod-protected/HLSS30.020/HLS.S30.T27VWL.2020048T131259.v2.0/HLS.S30.T27VWL.2020048T131259.v2.0.VAA.tif',\n", - " 'https://data.lpdaac.earthdatacloud.nasa.gov/lp-prod-protected/HLSS30.020/HLS.S30.T27VWL.2020048T131259.v2.0/HLS.S30.T27VWL.2020048T131259.v2.0.SZA.tif',\n", - " 'https://data.lpdaac.earthdatacloud.nasa.gov/lp-prod-protected/HLSS30.020/HLS.S30.T27VWL.2020048T131259.v2.0/HLS.S30.T27VWL.2020048T131259.v2.0.B02.tif',\n", - " 'https://data.lpdaac.earthdatacloud.nasa.gov/lp-prod-protected/HLSS30.020/HLS.S30.T27VWL.2020048T131259.v2.0/HLS.S30.T27VWL.2020048T131259.v2.0.B01.tif',\n", - " 'https://data.lpdaac.earthdatacloud.nasa.gov/lp-prod-protected/HLSS30.020/HLS.S30.T27VWL.2020048T131259.v2.0/HLS.S30.T27VWL.2020048T131259.v2.0.B11.tif',\n", - " 'https://data.lpdaac.earthdatacloud.nasa.gov/lp-prod-protected/HLSS30.020/HLS.S30.T27VWL.2020048T131259.v2.0/HLS.S30.T27VWL.2020048T131259.v2.0.B04.tif',\n", - " 'https://data.lpdaac.earthdatacloud.nasa.gov/lp-prod-protected/HLSS30.020/HLS.S30.T27VWL.2020048T131259.v2.0/HLS.S30.T27VWL.2020048T131259.v2.0.VZA.tif',\n", - " 'https://data.lpdaac.earthdatacloud.nasa.gov/lp-prod-protected/HLSS30.020/HLS.S30.T27VWL.2020048T131259.v2.0/HLS.S30.T27VWL.2020048T131259.v2.0.B12.tif']" - ] - }, - "execution_count": 39, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "granule = granules_query.get(1)[0]\n", "granule.data_links()" @@ -5846,29 +1287,12 @@ }, { "cell_type": "code", - "execution_count": 40, + "execution_count": null, "id": "a7f173ef-fb02-4d83-8c35-2fc1b4efd699", "metadata": { "tags": [] }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Querying 2018\n", - "Granules found: 1\n", - "Querying 2019\n", - "Granules found: 2\n", - "Querying 2020\n", - "Granules found: 2\n", - "Querying 2021\n", - "Granules found: 4\n", - "Querying 2022\n", - "Granules found: 3\n" - ] - } - ], + "outputs": [], "source": [ "iceland_bbox = (-22.1649, 63.3052, -11.9366, 65.5970)\n", "# We are going to save our granules for each year on this list\n", @@ -5886,63 +1310,12 @@ }, { "cell_type": "code", - "execution_count": 41, + "execution_count": null, "id": "55302fcc-8396-420f-b3ea-f0587ee5efa1", "metadata": { "tags": [] }, - "outputs": [ - { - "data": { - "text/html": [ - "\n", - "
\n", - " \n", - "
\n", - " \n", - " " - ], - "text/plain": [ - "Collection: {'EntryTitle': 'HLS Sentinel-2 Multi-spectral Instrument Surface Reflectance Daily Global 30m v2.0'}\n", - "Spatial coverage: {'HorizontalSpatialDomain': {'Geometry': {'GPolygons': [{'Boundary': {'Points': [{'Longitude': -20.77975676, 'Latitude': 63.04157071}, {'Longitude': -19.80583813, 'Latitude': 64.02224734}, {'Longitude': -21.00040929, 'Latitude': 64.02715388}, {'Longitude': -21.00039541, 'Latitude': 63.041742}, {'Longitude': -20.77975676, 'Latitude': 63.04157071}]}}]}}}\n", - "Temporal coverage: {'RangeDateTime': {'BeginningDateTime': '2018-02-17T13:12:50.460Z', 'EndingDateTime': '2018-02-17T13:12:50.460Z'}}\n", - "Size(MB): 72.62060165405273\n", - "Data: ['https://data.lpdaac.earthdatacloud.nasa.gov/lp-prod-protected/HLSS30.020/HLS.S30.T27VWL.2018048T131249.v2.0/HLS.S30.T27VWL.2018048T131249.v2.0.VAA.tif', 'https://data.lpdaac.earthdatacloud.nasa.gov/lp-prod-protected/HLSS30.020/HLS.S30.T27VWL.2018048T131249.v2.0/HLS.S30.T27VWL.2018048T131249.v2.0.B06.tif', 'https://data.lpdaac.earthdatacloud.nasa.gov/lp-prod-protected/HLSS30.020/HLS.S30.T27VWL.2018048T131249.v2.0/HLS.S30.T27VWL.2018048T131249.v2.0.B8A.tif', 'https://data.lpdaac.earthdatacloud.nasa.gov/lp-prod-protected/HLSS30.020/HLS.S30.T27VWL.2018048T131249.v2.0/HLS.S30.T27VWL.2018048T131249.v2.0.B10.tif', 'https://data.lpdaac.earthdatacloud.nasa.gov/lp-prod-protected/HLSS30.020/HLS.S30.T27VWL.2018048T131249.v2.0/HLS.S30.T27VWL.2018048T131249.v2.0.B08.tif', 'https://data.lpdaac.earthdatacloud.nasa.gov/lp-prod-protected/HLSS30.020/HLS.S30.T27VWL.2018048T131249.v2.0/HLS.S30.T27VWL.2018048T131249.v2.0.B07.tif', 'https://data.lpdaac.earthdatacloud.nasa.gov/lp-prod-protected/HLSS30.020/HLS.S30.T27VWL.2018048T131249.v2.0/HLS.S30.T27VWL.2018048T131249.v2.0.SZA.tif', 'https://data.lpdaac.earthdatacloud.nasa.gov/lp-prod-protected/HLSS30.020/HLS.S30.T27VWL.2018048T131249.v2.0/HLS.S30.T27VWL.2018048T131249.v2.0.B02.tif', 'https://data.lpdaac.earthdatacloud.nasa.gov/lp-prod-protected/HLSS30.020/HLS.S30.T27VWL.2018048T131249.v2.0/HLS.S30.T27VWL.2018048T131249.v2.0.B04.tif', 'https://data.lpdaac.earthdatacloud.nasa.gov/lp-prod-protected/HLSS30.020/HLS.S30.T27VWL.2018048T131249.v2.0/HLS.S30.T27VWL.2018048T131249.v2.0.B12.tif', 'https://data.lpdaac.earthdatacloud.nasa.gov/lp-prod-protected/HLSS30.020/HLS.S30.T27VWL.2018048T131249.v2.0/HLS.S30.T27VWL.2018048T131249.v2.0.B05.tif', 'https://data.lpdaac.earthdatacloud.nasa.gov/lp-prod-protected/HLSS30.020/HLS.S30.T27VWL.2018048T131249.v2.0/HLS.S30.T27VWL.2018048T131249.v2.0.B09.tif', 'https://data.lpdaac.earthdatacloud.nasa.gov/lp-prod-protected/HLSS30.020/HLS.S30.T27VWL.2018048T131249.v2.0/HLS.S30.T27VWL.2018048T131249.v2.0.SAA.tif', 'https://data.lpdaac.earthdatacloud.nasa.gov/lp-prod-protected/HLSS30.020/HLS.S30.T27VWL.2018048T131249.v2.0/HLS.S30.T27VWL.2018048T131249.v2.0.B01.tif', 'https://data.lpdaac.earthdatacloud.nasa.gov/lp-prod-protected/HLSS30.020/HLS.S30.T27VWL.2018048T131249.v2.0/HLS.S30.T27VWL.2018048T131249.v2.0.VZA.tif', 'https://data.lpdaac.earthdatacloud.nasa.gov/lp-prod-protected/HLSS30.020/HLS.S30.T27VWL.2018048T131249.v2.0/HLS.S30.T27VWL.2018048T131249.v2.0.Fmask.tif', 'https://data.lpdaac.earthdatacloud.nasa.gov/lp-prod-protected/HLSS30.020/HLS.S30.T27VWL.2018048T131249.v2.0/HLS.S30.T27VWL.2018048T131249.v2.0.B03.tif', 'https://data.lpdaac.earthdatacloud.nasa.gov/lp-prod-protected/HLSS30.020/HLS.S30.T27VWL.2018048T131249.v2.0/HLS.S30.T27VWL.2018048T131249.v2.0.B11.tif']" - ] - }, - "execution_count": 41, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "scene = granule_list[0]\n", "scene" @@ -5960,21 +1333,12 @@ }, { "cell_type": "code", - "execution_count": 42, + "execution_count": null, "id": "1fcca3fa-1319-4a1c-94de-50fb071e06c0", "metadata": { "tags": [] }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Direct access links: s3://lp-prod-protected/HLSS30.020/HLS.S30.T27VWL.2018048T131249.v2.0/HLS.S30.T27VWL.2018048T131249.v2.0.VAA.tif\n", - "External links: https://data.lpdaac.earthdatacloud.nasa.gov/lp-prod-protected/HLSS30.020/HLS.S30.T27VWL.2018048T131249.v2.0/HLS.S30.T27VWL.2018048T131249.v2.0.VAA.tif\n" - ] - } - ], + "outputs": [], "source": [ "print(\"Direct access links: \", scene.data_links(access=\"direct\")[0])\n", "print(\"External links: \", scene.data_links(access=\"external\")[0])" @@ -5982,94 +1346,12 @@ }, { "cell_type": "code", - "execution_count": 43, + "execution_count": null, "id": "41e1cbfc-8bdc-4a10-b7de-14185ab86c1d", "metadata": { "tags": [] }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - " Opening 1 granules, approx size: 0.07 GB\n" - ] - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "c7f7f5f3e34d44a9b853629bea975e7f", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "QUEUEING TASKS | : 0it [00:00, ?it/s]" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Warning: This collection contains more than one file per granule. earthaccess will only open the first data link, try filtering the links before opening them.\n" - ] - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "59de8650d7564407b0ff073eabb494c2", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "PROCESSING TASKS | : 0%| | 0/1 [00:00\n", - "
\n", - " Figure\n", - "
\n", - " \n", - " \n", - " " - ], - "text/plain": [ - "Canvas(toolbar=Toolbar(toolitems=[('Home', 'Reset original view', 'home', 'home'), ('Back', 'Back to previous …" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "%matplotlib widget\n", "import rasterio as rio\n", @@ -6090,471 +1372,12 @@ }, { "cell_type": "code", - "execution_count": 44, + "execution_count": null, "id": "d55122f3-3989-4589-9b0f-9c378a782e21", "metadata": { "tags": [] }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - " Opening 1 granules, approx size: 0.07 GB\n" - ] - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "44a27a7a670c4d5096d96c55d61e761a", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "QUEUEING TASKS | : 0it [00:00, ?it/s]" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Warning: This collection contains more than one file per granule. earthaccess will only open the first data link, try filtering the links before opening them.\n" - ] - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "ceb5c1236ac74d68a53332552990f6ef", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "PROCESSING TASKS | : 0%| | 0/1 [00:00\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "
<xarray.Dataset>\n",
-       "Dimensions:      (band: 1, x: 3660, y: 3660)\n",
-       "Coordinates:\n",
-       "  * band         (band) int64 1\n",
-       "  * x            (x) float64 5e+05 5e+05 5.001e+05 ... 6.097e+05 6.098e+05\n",
-       "  * y            (y) float64 7.1e+06 7.1e+06 7.1e+06 ... 6.99e+06 6.99e+06\n",
-       "    spatial_ref  int64 ...\n",
-       "Data variables:\n",
-       "    band_data    (band, y, x) float32 ...
" - ], - "text/plain": [ - "\n", - "Dimensions: (band: 1, x: 3660, y: 3660)\n", - "Coordinates:\n", - " * band (band) int64 1\n", - " * x (x) float64 5e+05 5e+05 5.001e+05 ... 6.097e+05 6.098e+05\n", - " * y (y) float64 7.1e+06 7.1e+06 7.1e+06 ... 6.99e+06 6.99e+06\n", - " spatial_ref int64 ...\n", - "Data variables:\n", - " band_data (band, y, x) float32 ..." - ] - }, - "execution_count": 44, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "hls_scene = xr.open_dataset(earthaccess.open(granule_list[1:2])[0], engine='rasterio')\n", "hls_scene" @@ -6584,20 +1407,12 @@ }, { "cell_type": "code", - "execution_count": 45, + "execution_count": null, "id": "b5577154-f15c-464c-b68a-57a280d484d1", "metadata": { "tags": [] }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Granules found: 9\n" - ] - } - ], + "outputs": [], "source": [ "iceland_bbox = (-22.1649, 63.3052, -11.9366, 65.5970)\n", "\n", @@ -6610,21 +1425,12 @@ }, { "cell_type": "code", - "execution_count": 46, + "execution_count": null, "id": "a89d0974-ecfd-45c5-9c6d-7a1595c167b2", "metadata": { "tags": [] }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Direct access link: ['s3://prod-lads/MOD07_L2/MOD07_L2.A2020001.0015.061.2020002183420.hdf']\n", - "External link: ['https://ladsweb.modaps.eosdis.nasa.gov/archive/allData/61/MOD07_L2/2020/001/MOD07_L2.A2020001.0015.061.2020002183420.hdf']\n" - ] - } - ], + "outputs": [], "source": [ "print(\"Direct access link: \", granules[0].data_links(access=\"direct\"))\n", "print(\"External link: \", granules[0].data_links(access=\"external\"))" @@ -6677,23 +1483,12 @@ }, { "cell_type": "code", - "execution_count": 48, + "execution_count": null, "id": "05800373-0640-44e2-9f7b-09c39ce03059", "metadata": { "tags": [] }, - "outputs": [ - { - "data": { - "text/plain": [ - "['https://ladsweb.modaps.eosdis.nasa.gov/opendap/RemoteResources/laads/allData/61/MOD07_L2/2020/001/MOD07_L2.A2020001.0015.061.2020002183420.hdf.html']" - ] - }, - "execution_count": 48, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "# We are going to retrieve the html endpoint link for one granule\n", "granules[0]._filter_related_links(\"USE SERVICE API\")" @@ -6701,23 +1496,12 @@ }, { "cell_type": "code", - "execution_count": 49, + "execution_count": null, "id": "82568336-a8be-4fa2-9135-c5bebb4148c2", "metadata": { "tags": [] }, - "outputs": [ - { - "data": { - "text/plain": [ - "'https://ladsweb.modaps.eosdis.nasa.gov/opendap/RemoteResources/laads/allData/61/MOD07_L2/2020/001/MOD07_L2.A2020001.0015.061.2020002183420.hdf.nc4'" - ] - }, - "execution_count": 49, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "netcdf_list = [g._filter_related_links(\"USE SERVICE API\")[0].replace(\".html\", \".nc4\") for g in granules]\n", "netcdf_list[0]" @@ -6725,55 +1509,12 @@ }, { "cell_type": "code", - "execution_count": 50, + "execution_count": null, "id": "5116ef2f-e27f-49a2-9e3f-07f70337226f", "metadata": { "tags": [] }, - "outputs": [ - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "47e48bcb713c4256a73ef6b8a7adea90", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "QUEUEING TASKS | : 0%| | 0/3 [00:00\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "
<xarray.Dataset>\n",
-       "Dimensions:                            (Band_Number: 12, Pressure_Level: 20,\n",
-       "                                        Cell_Along_Swath: 406,\n",
-       "                                        Cell_Across_Swath: 270,\n",
-       "                                        Output_Parameter: 10,\n",
-       "                                        Water_Vapor_QA_Bytes: 5)\n",
-       "Coordinates:\n",
-       "  * Band_Number                        (Band_Number) int32 24 25 27 ... 34 35 36\n",
-       "  * Pressure_Level                     (Pressure_Level) float32 5.0 ... 1e+03\n",
-       "    Latitude                           (Cell_Along_Swath, Cell_Across_Swath) float32 ...\n",
-       "    Longitude                          (Cell_Along_Swath, Cell_Across_Swath) float32 ...\n",
-       "  * Output_Parameter                   (Output_Parameter) int32 0 1 2 ... 7 8 9\n",
-       "  * Water_Vapor_QA_Bytes               (Water_Vapor_QA_Bytes) int32 0 1 2 3 4\n",
-       "Dimensions without coordinates: Cell_Along_Swath, Cell_Across_Swath\n",
-       "Data variables: (12/29)\n",
-       "    Pressure_Levels                    (Pressure_Level) int16 ...\n",
-       "    Scan_Start_Time                    (Cell_Along_Swath, Cell_Across_Swath) datetime64[ns] ...\n",
-       "    Solar_Zenith                       (Cell_Along_Swath, Cell_Across_Swath) float32 ...\n",
-       "    Solar_Azimuth                      (Cell_Along_Swath, Cell_Across_Swath) float32 ...\n",
-       "    Sensor_Zenith                      (Cell_Along_Swath, Cell_Across_Swath) float32 ...\n",
-       "    Sensor_Azimuth                     (Cell_Along_Swath, Cell_Across_Swath) float32 ...\n",
-       "    ...                                 ...\n",
-       "    Water_Vapor                        (Cell_Along_Swath, Cell_Across_Swath) float32 ...\n",
-       "    Water_Vapor_Direct                 (Cell_Along_Swath, Cell_Across_Swath) float32 ...\n",
-       "    Water_Vapor_Low                    (Cell_Along_Swath, Cell_Across_Swath) float32 ...\n",
-       "    Water_Vapor_High                   (Cell_Along_Swath, Cell_Across_Swath) float32 ...\n",
-       "    Quality_Assurance                  (Cell_Along_Swath, Cell_Across_Swath, Output_Parameter) float64 ...\n",
-       "    Quality_Assurance_Infrared         (Cell_Along_Swath, Cell_Across_Swath, Water_Vapor_QA_Bytes) float64 ...\n",
-       "Attributes:\n",
-       "    HDFEOSVersion:                      HDFEOS_V2.19\n",
-       "    ScaleFactor_AddOffset_Application:  Value=scale_factor*(stored integer - ...\n",
-       "    Pressure_Levels:                    5, 10, 20, 30, 50, 70, 100, 150, 200,...\n",
-       "    title:                              MODIS Level 2 Atmospheric Profiles   ...\n",
-       "    identifier_product_doi:             10.5067/MODIS/MOD07_L2.061\n",
-       "    identifier_product_doi_authority:   http://dx.doi.org\n",
-       "    history:                            $Id: MOD07.V2.CDL,v 1.1 2005/12/14 16...\n",
-       "    history_json:                       [{"$schema":"https:\\/\\/harmony.earthd...
" - ], - "text/plain": [ - "\n", - "Dimensions: (Band_Number: 12, Pressure_Level: 20,\n", - " Cell_Along_Swath: 406,\n", - " Cell_Across_Swath: 270,\n", - " Output_Parameter: 10,\n", - " Water_Vapor_QA_Bytes: 5)\n", - "Coordinates:\n", - " * Band_Number (Band_Number) int32 24 25 27 ... 34 35 36\n", - " * Pressure_Level (Pressure_Level) float32 5.0 ... 1e+03\n", - " Latitude (Cell_Along_Swath, Cell_Across_Swath) float32 ...\n", - " Longitude (Cell_Along_Swath, Cell_Across_Swath) float32 ...\n", - " * Output_Parameter (Output_Parameter) int32 0 1 2 ... 7 8 9\n", - " * Water_Vapor_QA_Bytes (Water_Vapor_QA_Bytes) int32 0 1 2 3 4\n", - "Dimensions without coordinates: Cell_Along_Swath, Cell_Across_Swath\n", - "Data variables: (12/29)\n", - " Pressure_Levels (Pressure_Level) int16 ...\n", - " Scan_Start_Time (Cell_Along_Swath, Cell_Across_Swath) datetime64[ns] ...\n", - " Solar_Zenith (Cell_Along_Swath, Cell_Across_Swath) float32 ...\n", - " Solar_Azimuth (Cell_Along_Swath, Cell_Across_Swath) float32 ...\n", - " Sensor_Zenith (Cell_Along_Swath, Cell_Across_Swath) float32 ...\n", - " Sensor_Azimuth (Cell_Along_Swath, Cell_Across_Swath) float32 ...\n", - " ... ...\n", - " Water_Vapor (Cell_Along_Swath, Cell_Across_Swath) float32 ...\n", - " Water_Vapor_Direct (Cell_Along_Swath, Cell_Across_Swath) float32 ...\n", - " Water_Vapor_Low (Cell_Along_Swath, Cell_Across_Swath) float32 ...\n", - " Water_Vapor_High (Cell_Along_Swath, Cell_Across_Swath) float32 ...\n", - " Quality_Assurance (Cell_Along_Swath, Cell_Across_Swath, Output_Parameter) float64 ...\n", - " Quality_Assurance_Infrared (Cell_Along_Swath, Cell_Across_Swath, Water_Vapor_QA_Bytes) float64 ...\n", - "Attributes:\n", - " HDFEOSVersion: HDFEOS_V2.19\n", - " ScaleFactor_AddOffset_Application: Value=scale_factor*(stored integer - ...\n", - " Pressure_Levels: 5, 10, 20, 30, 50, 70, 100, 150, 200,...\n", - " title: MODIS Level 2 Atmospheric Profiles ...\n", - " identifier_product_doi: 10.5067/MODIS/MOD07_L2.061\n", - " identifier_product_doi_authority: http://dx.doi.org\n", - " history: $Id: MOD07.V2.CDL,v 1.1 2005/12/14 16...\n", - " history_json: [{\"$schema\":\"https:\\/\\/harmony.earthd..." - ] - }, - "execution_count": 53, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "# Open a file into xarray for analysis\n", "ds = xr.open_dataset(dir_list[0])\n", @@ -7559,9 +1622,9 @@ ], "metadata": { "kernelspec": { - "display_name": "Python 3 (ipykernel)", + "display_name": "icepyx", "language": "python", - "name": "python3" + "name": "icepyx" }, "language_info": { "codemirror_mode": { @@ -7573,7 +1636,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.10.13" + "version": "3.12.1" } }, "nbformat": 4,