{ "cells": [ { "cell_type": "markdown", "id": "63a02e7e-0705-4813-ba10-31d44fb0d416", "metadata": { "editable": true, "slideshow": { "slide_type": "" }, "tags": [] }, "source": [ "Tide Signal Filters\n", "===================\n", "There are three filters for tidal water elevations or current speeds. The \"tide_doodson\" and \"tide_usgs\" are kernel convolutions against 30 hour kernels. The \"tide_fft\" filter is a high pass filter completely damping periods less than 30 hours with a smooth transition to accepting all periods greater than 40 hours." ] }, { "cell_type": "code", "execution_count": 27, "id": "ec28c81a-918e-4e4b-a0f3-a979cbc93e38", "metadata": { "execution": { "iopub.execute_input": "2024-02-24T22:22:56.414386Z", "iopub.status.busy": "2024-02-24T22:22:56.413861Z", "iopub.status.idle": "2024-02-24T22:22:56.416981Z", "shell.execute_reply": "2024-02-24T22:22:56.416639Z", "shell.execute_reply.started": "2024-02-24T22:22:56.414368Z" } }, "outputs": [], "source": [ "%matplotlib inline\n", "import tstoolbox" ] }, { "cell_type": "code", "execution_count": 28, "id": "9e68385c-d67d-43d8-9b2f-894a8e601c19", "metadata": { "collapsed": true, "execution": { "iopub.execute_input": "2024-02-24T22:22:58.501596Z", "iopub.status.busy": "2024-02-24T22:22:58.501099Z", "iopub.status.idle": "2024-02-24T22:22:58.504868Z", "shell.execute_reply": "2024-02-24T22:22:58.504416Z", "shell.execute_reply.started": "2024-02-24T22:22:58.501581Z" }, "jupyter": { "outputs_hidden": true } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Help on function filter in module tstoolbox.functions.filter:\n", "\n", "filter(filter_types: Union[Literal['bartlett', 'blackman', 'butterworth', 'fft', 'flat', 'hamming', 'hanning', 'kalman', 'lecolazet1', 'lecolazet2', 'tide_doodson', 'tide_fft', 'tide_usgs'], List[Literal['bartlett', 'blackman', 'butterworth', 'fft', 'flat', 'hamming', 'hanning', 'kalman', 'lecolazet1', 'lecolazet2', 'tide_doodson', 'tide_fft', 'tide_usgs']]], filter_pass: Literal['lowpass', 'highpass', 'bandpass', 'bandstop'], butterworth_order: typing.Annotated[int, FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=1)])] = 10, lowpass_cutoff: Optional[Annotated[float, Gt(gt=0)]] = None, highpass_cutoff: Optional[Annotated[float, Gt(gt=0)]] = None, window_len: typing.Annotated[int, Gt(gt=0)] = 3, pad_mode: Optional[Literal['edge', 'maximum', 'mean', 'median', 'minimum', 'reflect', 'symmetric', 'wrap']] = 'reflect', input_ts='-', start_date=None, end_date=None, columns=None, dropna='no', skiprows=None, index_type='datetime', names=None, clean=False, print_input=False, source_units=None, target_units=None, round_index=None, float_format='g', tablefmt='csv')\n", " Apply different filters to the time-series.\n", " \n", " Parameters\n", " ----------\n", " filter_types\n", " One or more of\n", " bartlett, blackman, butterworth, fft, flat, hamming, hanning, kalman, lecolazet1, lecolazet2, tide_doodson, tide_fft, tide_usgs\n", " \n", " The \"fft\" and \"butterworth\" types are configured by cutoff frequencies\n", " `lowpass_cutoff`, and `highpass_cutoff`, by process defined in\n", " `filter_pass`. The \"fft\" is the Fast Fourier Transform filter in the\n", " frequency domain.\n", " \n", " Doodson filter\n", " \n", " The Doodson X0 filter is a simple filter designed to damp out\n", " the main tidal frequencies. It takes hourly values, 19 values\n", " either side of the central one. A weighted average is taken\n", " with the following weights\n", " \n", " (1010010110201102112 0 2112011020110100101)/30.\n", " \n", " In \"Data Analysis and Methods in Oceanography\":\n", " \n", " \"The cosine-Lanczos filter, the transform filter, and the\n", " Butterworth filter are often preferred to the Godin filter,\n", " to earlier Doodson filter, because of their superior ability\n", " to remove tidal period variability from oceanic signals.\"\n", " filter_pass\n", " OneOf(\"lowpass\", \"highpass\", \"bandpass\", \"bandstop\")\n", " Indicates what frequencies to block for the \"fft\" and \"butterworth\"\n", " filters.\n", " butterworth_order\n", " [optional, default is 10]\n", " \n", " The order of the butterworth filter.\n", " lowpass_cutoff\n", " [optional, default is None, used only if `filter` is \"fft\" or\n", " \"butterworth\" and required if `filter_pass` equals \"lowpass\",\n", " \"bandpass\" or \"bandstop\"]\n", " \n", " The low frequency cutoff when `filter_pass` equals \"lowpass\",\n", " \"bandpass\", or \"bandstop\".\n", " highpass_cutoff\n", " [optional, default is None, used only if `filter` is \"fft\" or\n", " \"butterworth\" and required if `filter_pass` equals \"highpass\",\n", " \"bandpass\" or \"bandstop\"]\n", " \n", " The high frequency cutoff when `filter_pass` equals \"highpass\",\n", " \"bandpass\", or \"bandstop\".\n", " window_len\n", " [optional, default is 3]\n", " \n", " \"flat\", \"hanning\", \"hamming\", \"bartlett\", \"blackman\"\n", " Time-series is padded by one half the window length on each end. The\n", " `window_len` is then used for the length of the convolution kernel.\n", " \n", " \"fft\"\n", " Will soften the edges of the \"fft\" filter in the frequency domain.\n", " The larger the number the softer the filter edges. A value of 1\n", " will have a brick wall step function which may introduce\n", " frequencies into the filtered output.\n", " \n", " \"tide_usgs\", \"tide_doodson\"\n", " The `window_len` is set to 33 for \"tide_usgs\" and 39 for \"tide_doodson\".\n", " pad_mode\n", " [optional, default is \"reflect\"]\n", " \n", " The method used to pad the time-series. Uses some of the methods in\n", " numpy.pad.\n", " \n", " The pad methods \"edge\", \"maximum\", \"mean\", \"median\", \"minimum\",\n", " \"reflect\", \"symmetric\", \"wrap\" are available because they require no\n", " extra arguments.\n", " input_ts : str\n", " [optional though required if using within Python, default is '-'\n", " (stdin)]\n", " \n", " Whether from a file or standard input, data requires a single line\n", " header of column names. The default header is the first line of\n", " the input, but this can be changed for CSV files using the\n", " 'skiprows' option.\n", " \n", " Most common date formats can be used, but the closer to ISO 8601\n", " date/time standard the better.\n", " \n", " Comma-separated values (CSV) files or tab-separated values (TSV)::\n", " \n", " File separators will be automatically detected.\n", " \n", " Columns can be selected by name or index, where the index for\n", " data columns starts at 1.\n", " \n", " Command line examples:\n", " \n", " +---------------------------------+---------------------------+\n", " | Keyword Example | Description |\n", " +=================================+===========================+\n", " | --input_ts=fn.csv | read all columns from |\n", " | | 'fn.csv' |\n", " +---------------------------------+---------------------------+\n", " | --input_ts=fn.csv,2,1 | read data columns 2 and 1 |\n", " | | from 'fn.csv' |\n", " +---------------------------------+---------------------------+\n", " | --input_ts=fn.csv,2,skiprows=2 | read data column 2 from |\n", " | | 'fn.csv', skipping first |\n", " | | 2 rows so header is read |\n", " | | from third row |\n", " +---------------------------------+---------------------------+\n", " | --input_ts=fn.xlsx,2,Sheet21 | read all data from 2nd |\n", " | | sheet all data from |\n", " | | \"Sheet21\" of 'fn.xlsx' |\n", " +---------------------------------+---------------------------+\n", " | --input_ts=fn.hdf5,Table12,T2 | read all data from table |\n", " | | \"Table12\" then all data |\n", " | | from table \"T2\" of |\n", " | | 'fn.hdf5' |\n", " +---------------------------------+---------------------------+\n", " | --input_ts=fn.wdm,210,110 | read DSNs 210, then 110 |\n", " | | from 'fn.wdm' |\n", " +---------------------------------+---------------------------+\n", " | --input_ts='-' | read all columns from |\n", " | | standard input (stdin) |\n", " +---------------------------------+---------------------------+\n", " | --input_ts='-' --columns=4,1 | read column 4 and 1 from |\n", " | | standard input (stdin) |\n", " +---------------------------------+---------------------------+\n", " \n", " If working with CSV or TSV files you can use redirection rather\n", " than use `--input_ts=fname.csv`. The following are identical:\n", " \n", " From a file:\n", " \n", " command subcmd --input_ts=fname.csv\n", " \n", " From standard input (since '--input_ts=-' is the default:\n", " \n", " command subcmd < fname.csv\n", " \n", " Can also combine commands by piping:\n", " \n", " command subcmd < filein.csv | command subcmd1 > fileout.csv\n", " \n", " Python library examples::\n", " \n", " You must use the `input_ts=...` option where `input_ts` can be\n", " one of a [pandas DataFrame, pandas Series, dict, tuple, list,\n", " StringIO, or file name].\n", " start_date : str\n", " [optional, defaults to first date in time-series, input filter]\n", " \n", " The start_date of the series in ISOdatetime format, or 'None' for\n", " beginning.\n", " end_date : str\n", " [optional, defaults to last date in time-series, input filter]\n", " \n", " The end_date of the series in ISOdatetime format, or 'None' for\n", " end.\n", " columns\n", " [optional, defaults to all columns, input filter]\n", " \n", " Columns to select out of input. Can use column names from the\n", " first line header or column numbers. If using numbers, column\n", " number 1 is the first data column. To pick multiple columns;\n", " separate by commas with no spaces. As used in `toolbox_utils pick`\n", " command.\n", " \n", " This solves a big problem so that you don't have to create a data\n", " set with a certain column order, you can rearrange columns when\n", " data is read in.\n", " dropna : str\n", " [optional, defauls it 'no', input filter]\n", " \n", " Set `dropna` to 'any' to have records dropped that have NA value in\n", " any column, or 'all' to have records dropped that have NA in all\n", " columns. Set to 'no' to not drop any records. The default is 'no'.\n", " skiprows: list-like or integer or callable\n", " [optional, default is None which will infer header from first line,\n", " input filter]\n", " \n", " Line numbers to skip (0-indexed) if a list or number of lines to\n", " skip at the start of the file if an integer.\n", " \n", " If used in Python can be a callable, the callable function will be\n", " evaluated against the row indices, returning True if the row should\n", " be skipped and False otherwise. An example of a valid callable\n", " argument would be\n", " \n", " ``lambda x: x in [0, 2]``.\n", " index_type : str\n", " [optional, default is 'datetime', output format]\n", " \n", " Can be either 'number' or 'datetime'. Use 'number' with index\n", " values that are Julian dates, or other epoch reference.\n", " names: str\n", " [optional, default is None, transformation]\n", " \n", " If None, the column names are taken from the first row after\n", " 'skiprows' from the input dataset.\n", " \n", " MUST include a name for all columns in the input dataset, including\n", " the index column.\n", " clean\n", " [optional, default is False, input filter]\n", " \n", " The 'clean' command will repair a input index, removing duplicate\n", " index values and sorting.\n", " print_input\n", " [optional, default is False, output format]\n", " \n", " If set to 'True' will include the input columns in the output\n", " table.\n", " source_units: str\n", " [optional, default is None, transformation]\n", " \n", " If unit is specified for the column as the second field of a ':'\n", " delimited column name, then the specified units and the\n", " 'source_units' must match exactly.\n", " \n", " Any unit string compatible with the 'pint' library can be used.\n", " target_units: str\n", " [optional, default is None, transformation]\n", " \n", " The purpose of this option is to specify target units for unit\n", " conversion. The source units are specified in the header line of\n", " the input or using the 'source_units' keyword.\n", " \n", " The units of the input time-series or values are specified as the\n", " second field of a ':' delimited name in the header line of the\n", " input or in the 'source_units' keyword.\n", " \n", " Any unit string compatible with the 'pint' library can be used.\n", " \n", " This option will also add the 'target_units' string to the\n", " column names.\n", " round_index\n", " [optional, default is None which will do nothing to the index,\n", " output format]\n", " \n", " Round the index to the nearest time point. Can significantly\n", " improve the performance since can cut down on memory and processing\n", " requirements, however be cautious about rounding to a very course\n", " interval from a small one. This could lead to duplicate values in\n", " the index.\n", " float_format\n", " [optional, output format]\n", " \n", " Format for float numbers.\n", " tablefmt : str\n", " [optional, default is 'csv', output format]\n", " \n", " The table format. Can be one of 'csv', 'tsv', 'plain', 'simple',\n", " 'grid', 'pipe', 'orgtbl', 'rst', 'mediawiki', 'latex', 'latex_raw'\n", " and 'latex_booktabs'.\n", "\n" ] } ], "source": [ "help(tstoolbox.filter)" ] }, { "cell_type": "code", "execution_count": 29, "id": "fd4846af-2715-4cad-ac27-a1233c377ed8", "metadata": { "execution": { "iopub.execute_input": "2024-02-24T22:23:05.767567Z", "iopub.status.busy": "2024-02-24T22:23:05.767002Z", "iopub.status.idle": "2024-02-24T22:23:05.782020Z", "shell.execute_reply": "2024-02-24T22:23:05.781701Z", "shell.execute_reply.started": "2024-02-24T22:23:05.767550Z" } }, "outputs": [], "source": [ "tdf = tstoolbox.filter(\n", " [\"tide_doodson\", \"tide_usgs\", \"tide_fft\"],\n", " \"lowpass\",\n", " input_ts=\"data_mayport_8720220_water_level.csv,1\",\n", " print_input=True,\n", ")" ] }, { "cell_type": "code", "execution_count": 30, "id": "74568bf5-f8ae-4e22-9e0e-6983857e0267", "metadata": { "execution": { "iopub.execute_input": "2024-02-24T22:23:08.424246Z", "iopub.status.busy": "2024-02-24T22:23:08.423750Z", "iopub.status.idle": "2024-02-24T22:23:08.650197Z", "shell.execute_reply": "2024-02-24T22:23:08.649831Z", "shell.execute_reply.started": "2024-02-24T22:23:08.424230Z" } }, "outputs": [ { "data": { "text/plain": [ "" ] }, "execution_count": 30, "metadata": {}, "output_type": "execute_result" }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "tdf.plot()" ] } ], "metadata": { "jupytext": { "formats": "ipynb,py:percent" }, "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.7" } }, "nbformat": 4, "nbformat_minor": 5 }