02_patch.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "0",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "source": [
    "# Patch Basics\n",
    "\n",
    "December 2, 2024\n",
    "\n",
    "This notebook Shows how to work with DASCore's [`Patch`](https://dascore.org/api/dascore/core/patch/Patch.html). It is a shortened version of the [DASCore's Patch tutorial](https://dascore.org/tutorial/patch.html). \n",
    "\n",
    "<a target=\"_blank\" href=\"https://colab.research.google.com/github/DASDAE/seg_tutorial/blob/master/02_patch.ipynb\">\n",
    "</a>  <img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/>\n",
    "\n",
    "#### Useful links: \n",
    "* [Colab link](https://colab.research.google.com/github/DASDAE/seg_tutorial/blob/master/02_patch.ipynb)\n",
    "* [DASCore documentation](https://dascore.org)\n",
    "* [ObsPy documentation](https://github.com/obspy/obspy/wiki/)\n",
    "* [Xarray documentation](https://docs.xarray.dev/en/stable/)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "%%capture\n",
    "\n",
    "# First ensure DASCore is installed. If not, install and restart the kernel.\n",
    "try:\n",
    "    import dascore as dc\n",
    "except ImportError:\n",
    "    !pip install dascore\n",
    "    !pip install ipympl\n",
    "    # resetart kernel\n",
    "    import IPython\n",
    "    IPython.Application.instance().kernel.do_shutdown(True) #automatically restarts kernel\n",
    "\n",
    "import numpy as np\n",
    "from rich import print"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "source": [
    "# Patch\n",
    "To demonstrate the patch, we use an example seismic event recorded shown in [this study](https://www.frontiersin.org/journals/earth-science/articles/10.3389/feart.2022.907749/full).\n",
    "\n",
    "The `Patch` is composed of:\n",
    "- data: the array of measurements\n",
    "- attrs: the non-coordinate metdata\n",
    "- dims: a tuple of dimension names (eg 'time', 'distance')\n",
    "- coords: The coordinates of each dimension (plus others)\n",
    "\n",
    "It is *immutable* which means that once a patch is created it cannot (easily) be changed. This makes it safe to share compontents between patches and simplifies parallel processing. "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "source": [
    "The patch design was inspired by [Xarray's DataArray](https://docs.xarray.dev/en/stable/generated/xarray.DataArray.html)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "# The get_example_patch function is useful for loading example/test patches.\n",
    "patch = dc.get_example_patch(\"example_event_1\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5",
   "metadata": {},
   "outputs": [],
   "source": [
    "# The patch str rep. provides a summary\n",
    "print(patch)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "source": [
    "## Patch Components: Data and Dims\n",
    "\n",
    "The data array can be accessed with `data` and updated with (`Patch.update`)[https://dascore.org/tutorial/patch.html#update]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "# Get the data array\n",
    "array = patch.data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "# Divide the data by 1_000_0000 and create a new patch.\n",
    "patch_new_data = patch.update(data=array / 1_000_000)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "source": [
    "The dimensions are accessed via the `dims` attribute."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "10",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "print(patch.dims)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "11",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "source": [
    "### **Exercise** (Patch Data)\n",
    "Calculate and print following:\n",
    "\n",
    "1. The number of samples in the data\n",
    "2. The minimum and maximum value of the data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "12",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "13",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "source": [
    "## Patch Components: Attrs\n",
    "Attrs contain non-dimensional metdata. Acquisition/interrogator identifiers, custom tags, etc.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "14",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "print(patch.attrs)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "15",
   "metadata": {},
   "source": [
    "Notice the data units, `acquisition_id`, and `cable_id` are not set. We could set them like so:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "16",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "patch_updated_attrs = patch.update_attrs(\n",
    "    acquisition_id=\"experiment_12\",\n",
    "    cable_id=\"b202393ad\",\n",
    ")\n",
    "print(patch_updated_attrs)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "17",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "source": [
    "Note: [Patch.set_units](https://dascore.org/api/dascore/proc/units/set_units.html) and [Patch.convert_units](https://dascore.org/api/dascore/proc/units/convert_units.html) are preferrible for handling data unit conversions.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "18",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "source": [
    "### **Exercise** (Patch Attrs)\n",
    "Do the following:\n",
    "\n",
    "1. Print the cable_id from the patch with updated attrs.\n",
    "2. Create a new patch with a station name of \"DAS1\"."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "19",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "20",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "source": [
    "## Patch Components: Coords\n",
    "\n",
    "`Coords` represent information about the coordinates (not coordinate systems) associated with a patch. These include, but arent limited to, the dimensions such as 'time' and 'distance'. Non-dimensional coordinates are also supported which can be associated with a dimension or independent. \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "21",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "print(patch.coords) # The coordinates and their labels. "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "22",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "source": [
    "Coordinate objects can be accessed with [`Patch.get_coord`](https://dascore.org/api/dascore/proc/coords/get_coord.html). "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "23",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "dist_coord = patch.get_coord(\"distance\")\n",
    "\n",
    "# Get the start, stop, step, and units of the distance coord\n",
    "dist_start = dist_coord.min()\n",
    "dist_stop = dist_coord.max()\n",
    "dist_step = dist_coord.step\n",
    "dist_units = dist_coord.units\n",
    "\n",
    "# Get the underlying array data in the coordinate.\n",
    "dist_array = dist_coord.values"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "24",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "source": [
    "Alternatively, [`Patch.get_array`](https://dascore.org/api/dascore/proc/coords/get_array.html) simply returns the numpy array of the coordinate. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "25",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "# The values of the distance dimension\n",
    "dist = patch.get_array(\"distance\")\n",
    "\n",
    "# The value of the time dimension using a numpy datetime64 array.\n",
    "time = patch.get_array(\"time\")\n",
    "\n",
    "# Convert the array to seconds from 1970 (floats)\n",
    "time_s = dc.to_float(time)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "26",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "source": [
    "Coordinates can be renamed using [`Patch.rename_coord`](https://dascore.org/api/dascore/proc/coords/rename_coords.html)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "27",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "patch_renamed_coords = patch.rename_coords(distance=\"depth\")\n",
    "print(patch_renamed_coords.dims)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "28",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "source": [
    "Or updated using [`Patch.update_coords`](https://dascore.org/api/dascore/proc/coords/update_coords.html)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "29",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "from dascore.units import m\n",
    "\n",
    "# Add 12 to the current distance values.\n",
    "dist = patch.get_array(\"distance\")\n",
    "patch_new_dist = patch.update_coords(distance=(dist + 12)*m)\n",
    "\n",
    "dist2 = patch_new_dist.get_coord(\"distance\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "30",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "print(dist2)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "31",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "source": [
    "### **Exercise** (Patch Coords)\n",
    "\n",
    "Calculate the and print following parameters:\n",
    "\n",
    "1. The duration (time) of the patch recording using the time coordinate.\n",
    "\n",
    "2. Reset the start of the time coordiante to noon on the release date of Elton John's single Rocket Man (17 April 1972)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "32",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "33",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "source": [
    "## Visualization\n",
    "DASCore provides visualization in the `patch.viz` namespace.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "34",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "# The classic waterfall plot\n",
    "patch.viz.waterfall();"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "35",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "# A wiggle plot\n",
    "patch.viz.wiggle();"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "36",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "source": [
    "### **Exercise** (Patch Viz)\n",
    "Redo the waterfall plot, but play with the `scale` parameter to make the event more visible."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "37",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "38",
   "metadata": {
    "editable": true,
    "jp-MarkdownHeadingCollapsed": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "source": [
    "## Trimming and sub-selection\n",
    "[`Patch.select`]() is used to trim patches. For example, to zoom in on the down-going reflection in our example patch. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "39",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "trimmed = patch.select(time=(.16, .22), distance =(600,800))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "40",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "trimmed.viz.waterfall(scale=0.1);"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "41",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "source": [
    "Trimming can also be done via samples"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "42",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "# Remove 20 samples from start and end of time dimension using samples=True\n",
    "trimmed_patch = patch.select(time=(20, -20), samples=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "43",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "# Remove .05 seconds from start and 0.03 seconds from the end of patch using relative=True\n",
    "trimmed_patch = patch.select(time=(0.05, -0.03), relative=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "44",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "source": [
    "### **Exercise** (Patch Select)\n",
    "Remove the first 10 spatial channels then the last .05 seconds. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "45",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "46",
   "metadata": {
    "editable": true,
    "jp-MarkdownHeadingCollapsed": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "source": [
    "## Patch Processing\n",
    "DASCore provides many [processing](https://dascore.org/api/dascore/proc.html) patch methods. This section will highlight a few of these.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "47",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "source": [
    "### Pass Filtering\n",
    "The `Patch.pass_filter` method is used to apply bandpass, lowpass, and highpass SOS filters to the data along a specified dimension."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "48",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "patch_bp = patch.pass_filter(time=(100, 300))  # apply a 100Hz to 300Hz highpass\n",
    "patch_lp = patch.pass_filter(time=(..., 300))  # apply a 300Hz lowpass\n",
    "patch_hp = patch.pass_filter(time=(50, ...))  # apply a 50Hz highpass"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "49",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "source": [
    "### **Exercise** (Patch Processing 1)\n",
    "Plot each of the filtered patches above. Which filtering technique did the best at accentuating the event signal? "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "50",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "51",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "source": [
    "### Decimate\n",
    "`decimate` reduces the number of samples in the specified dimension. By default, a lowpass filter is applied to avoid aliasing."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "52",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "patch_dec = patch.decimate(time=10)  # keep every 10th sample along time axis"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "53",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "source": [
    "### Detrend\n",
    "\n",
    "`Patch.detrend` applies a linear detrend along a specified dimension (axis)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "54",
   "metadata": {},
   "outputs": [],
   "source": [
    "patch_detrended = patch.detrend(\"time\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "55",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "source": [
    "### Resample\n",
    "\n",
    "Like `decimate`, `resample` is used to change the sampling rate of the patch along a specific dimension. Unlike `decimate`, however, non-integar multiples can be used."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "56",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "patch_resamp = patch.resample(distance=15)  # change spatial sampling to 15m"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "57",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "source": [
    "### **Exercise** (Processing 2)\n",
    "\n",
    "Find some methods in the [processing module documentation](https://dascore.org/api/dascore/proc.html) and apply them to the event patch. Visualize the results. "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "58",
   "metadata": {},
   "source": [
    "### Aggregate\n",
    "[`Patch.aggregate`](https://dascore.org/api/dascore/proc/aggregate/aggregate.html) performs aggregations along specified dimension(s). Shortcuts for `min`, `max`, `mean`, etc. are also provided."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "59",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "# Use aggregate and mean to calculate the same patch.\n",
    "mean_1 = patch.aggregate(\"time\", method=\"mean\")\n",
    "mean_2 = patch.mean(\"time\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "60",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Aggregate supports any tensor reduction operation. \n",
    "reduced = patch.aggregate(\"time\", np.sum)\n",
    "print(reduced)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "61",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "62",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "63",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "source": [
    "## Patch Transformations\n",
    "In addition to the processing methods, DASCore includes several patch [transformation methods](https://dascore.org/api/dascore/transform.html). This section shows some examples."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "64",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "import dascore as dc\n",
    "# Load a cleaned-up patch from the previous example.\n",
    "patch = dc.get_example_patch(\"example_event_2\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "65",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "# Perform an real dft along the time axis. \n",
    "patch_fft = patch.dft(\"time\", real=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "66",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "# Integrate along time domain\n",
    "patch_int = patch.integrate(\"distance\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "67",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "source": [
    "### **Exercise** (Transformation)\n",
    "\n",
    "Do the following to the patch above:\n",
    "\n",
    "1. Perform a real discrete Fourier transform along the time axis\n",
    "2. Get the amplitude spectra\n",
    "3. Take the mean along the distance dimension\n",
    "4. Select frequencies (`ft_time` dimension) less than 500 Hz\n",
    "5. Plot using matplotlib and the `ft_time` dimension's values\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "68",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "69",
   "metadata": {},
   "source": [
    "In the next section we explore the `Spool` in more detail.\n",
    "- [Github link](https://github.com/DASDAE/seg_tutorial/blob/master/03_spool.ipynb)\n",
    "- [CoLab link](https://colab.research.google.com/github/DASDAE/seg_tutorial/blob/master/03_spool.ipynb)"
   ]
  }
 ],
 "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.10.11"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}