From b42d9d4d02c95cff6a170a2a2b0bf05174565031 Mon Sep 17 00:00:00 2001 From: Robbi Bishop-Taylor Date: Tue, 26 Nov 2024 06:04:41 +0000 Subject: [PATCH 01/10] Fix bug where dask chunks exist but are empty --- eo_tides/eo.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/eo_tides/eo.py b/eo_tides/eo.py index 1fe4fea..c4ff757 100644 --- a/eo_tides/eo.py +++ b/eo_tides/eo.py @@ -39,7 +39,7 @@ def _resample_chunks( return data.shape # if data has chunks, then return just spatial chunks - if data.chunks is not None: + if data.chunks: y_dim, x_dim = data.odc.spatial_dims return data.chunks[y_dim], data.chunks[x_dim] From d2012ca448a5335ac2ffc0c4cabaeda8f5fc78e5 Mon Sep 17 00:00:00 2001 From: Robbi Bishop-Taylor Date: Tue, 26 Nov 2024 06:09:44 +0000 Subject: [PATCH 02/10] Doco updates, update testing notebook --- docs/migration.md | 15 + eo_tides/model.py | 35 +- eo_tides/utils.py | 26 +- eo_tides/validation.py | 44 +- tests/testing.ipynb | 7333 ++++------------------------------------ 5 files changed, 667 insertions(+), 6786 deletions(-) diff --git a/docs/migration.md b/docs/migration.md index 9e18ed1..b45ce26 100644 --- a/docs/migration.md +++ b/docs/migration.md @@ -49,6 +49,21 @@ The `ds` param in all satellite data functions (`tag_tides`, `pixel_tides`, `tid tag_tides(data=your_data) ``` +## `times` param renamed to `time`, accepts any format supported by `pandas.to_datetime()` + +The `times` parameter has been renamed to `time`, and updated to more flexibly accept any time format that can be converted by `pandas.to_datetime()`; e.g. `np.ndarray[datetime64]`, `pd.DatetimeIndex`, `pd.Timestamp`, `datetime.datetime` and strings (e.g. `"2020-01-01 23:00"`). For example: `time=pd.date_range(start="2000", end="2001", freq="5h")`. + +!!! tip "Action required" + + Update: + ``` + model_tides(..., times=...) + ``` + To: + ``` + model_tides(..., time=...) + ``` + ### `tag_tides` now returns an array instead of updating data in-place The `tag_tides` function now returns an `xarray.DataArray` output containing tide heights, rather than appending tide height data to the original input dataset in-place. This change provides better consistency with `pixel_tides`, which also returns an array of tide heights. diff --git a/eo_tides/model.py b/eo_tides/model.py index 59e8aa3..1cd93bf 100644 --- a/eo_tides/model.py +++ b/eo_tides/model.py @@ -30,7 +30,7 @@ def _ensemble_model( ensemble_models, ensemble_func=None, ensemble_top_n=3, - ranking_points="https://dea-public-data-dev.s3-ap-southeast-2.amazonaws.com/derivative/dea_intertidal/supplementary/rankings_ensemble_2017-2019.geojson", + ranking_points="https://dea-public-data-dev.s3-ap-southeast-2.amazonaws.com/derivative/dea_intertidal/supplementary/rankings_ensemble_2017-2019.fgb", ranking_valid_perc=0.02, **idw_kwargs, ): @@ -42,7 +42,7 @@ def _ensemble_model( This function performs the following steps: 1. Takes a dataframe of tide heights from multiple tide models, as produced by `eo_tides.model.model_tides` - 1. Loads model ranking points from a GeoJSON file, filters them + 1. Loads model ranking points from an external file, filters them based on the valid data percentage, and retains relevant columns 2. Interpolates the model rankings into the "x" and "y" coordinates of the original dataframe using Inverse Weighted Interpolation (IDW) @@ -77,8 +77,8 @@ def _ensemble_model( If `ensemble_func` is None, this sets the number of top models to include in the mean ensemble calculation. Defaults to 3. ranking_points : str, optional - Path to the GeoJSON file containing model ranking points. This - dataset should include columns containing rankings for each tide + Path to the file containing model ranking points. This dataset + should include columns containing rankings for each tide model, named with the prefix "rank_". e.g. "rank_EOT20". Low values should represent high rankings (e.g. 1 = top ranked). ranking_valid_perc : float, optional @@ -110,12 +110,20 @@ def _ensemble_model( # Load model ranks points and reproject to same CRS as x and y model_ranking_cols = [f"rank_{m}" for m in ensemble_models] - model_ranks_gdf = ( - gpd.read_file(ranking_points) - .to_crs(crs) - .query(f"valid_perc > {ranking_valid_perc}") - .dropna()[model_ranking_cols + ["geometry"]] - ) + try: + model_ranks_gdf = ( + gpd.read_file(ranking_points, engine="pyogrio") + .to_crs(crs) + .query(f"valid_perc > {ranking_valid_perc}") + .dropna()[model_ranking_cols + ["geometry"]] + ) + except KeyError: + error_msg = f""" + Not all of the expected "rank_" columns {model_ranking_cols} were + found in the columns of the ranking points file ({ranking_points}). + Consider passing a custom list of models using `ensemble_models`. + """ + raise Exception(textwrap.dedent(error_msg).strip()) from None # Use points to interpolate model rankings into requested x and y id_kwargs_str = "" if idw_kwargs == {} else idw_kwargs @@ -419,6 +427,7 @@ def model_tides( any format that can be converted by `pandas.to_datetime()`; e.g. np.ndarray[datetime64], pd.DatetimeIndex, pd.Timestamp, datetime.datetime and strings (e.g. "2020-01-01 23:00"). + For example: `time=pd.date_range(start="2000", end="2001", freq="5h")` model : str or list of str, optional The tide model (or models) to use to model tides. Defaults to "EOT20"; for a full list of available/supported @@ -494,8 +503,9 @@ def model_tides( ensemble_models : list of str, optional An optional list of models used to generate the ensemble tide model if "ensemble" tide modelling is requested. Defaults to - ["FES2014", "TPXO9-atlas-v5", "EOT20", "HAMTIDE11", "GOT4.10", - "FES2012", "TPXO8-atlas-v1"]. + `["EOT20", "FES2012", "FES2014_extrapolated", "FES2022_extrapolated", + "GOT4.10", "GOT5.5_extrapolated", "GOT5.6_extrapolated", + "TPXO10-atlas-v2-nc", "TPXO8-atlas-nc", "TPXO9-atlas-v5-nc"]`. **ensemble_kwargs : Keyword arguments used to customise the generation of optional ensemble tide models if "ensemble" modelling are requested. @@ -701,6 +711,7 @@ def model_phases( any format that can be converted by `pandas.to_datetime()`; e.g. np.ndarray[datetime64], pd.DatetimeIndex, pd.Timestamp, datetime.datetime and strings (e.g. "2020-01-01 23:00"). + For example: `time=pd.date_range(start="2000", end="2001", freq="5h")` model : str or list of str, optional The tide model (or models) to use to compute tide phases. Defaults to "EOT20"; for a full list of available/supported diff --git a/eo_tides/utils.py b/eo_tides/utils.py index a880a46..1a4c2ad 100644 --- a/eo_tides/utils.py +++ b/eo_tides/utils.py @@ -6,6 +6,7 @@ import pathlib import textwrap import warnings +from collections import Counter from typing import List, Union import numpy as np @@ -23,6 +24,14 @@ DatetimeLike = Union[np.ndarray, pd.DatetimeIndex, pd.Timestamp, datetime.datetime, str, List[str]] +def _get_duplicates(array): + """ + Return any duplicates in a list or array. + """ + c = Counter(array) + return [k for k in c if c[k] > 1] + + def _set_directory( directory: str | os.PathLike | None = None, ) -> os.PathLike: @@ -87,6 +96,11 @@ def _standardise_models( # Turn inputs into arrays for consistent handling models_requested = list(np.atleast_1d(model)) + # Raise error if list contains duplications + duplicates = _get_duplicates(models_requested) + if len(duplicates) > 0: + raise ValueError(f"The model parameter contains duplicate values: {duplicates}") + # Get full list of supported models from pyTMD database available_models, valid_models = list_models( directory, show_available=False, show_supported=False, raise_error=True @@ -124,13 +138,15 @@ def _standardise_models( ensemble_models if ensemble_models is not None else [ - "FES2014", - "TPXO9-atlas-v5", "EOT20", - "HAMTIDE11", - "GOT4.10", "FES2012", - "TPXO8-atlas-v1", + "FES2014_extrapolated", + "FES2022_extrapolated", + "GOT4.10", + "GOT5.6_extrapolated", + "TPXO10-atlas-v2-nc", + "TPXO8-atlas-nc", + "TPXO9-atlas-v5-nc", ] ) diff --git a/eo_tides/validation.py b/eo_tides/validation.py index c407450..4e310de 100644 --- a/eo_tides/validation.py +++ b/eo_tides/validation.py @@ -5,6 +5,7 @@ import geopandas as gpd import pandas as pd +import tqdm from odc.geo.geom import BoundingBox from pandas.tseries.offsets import MonthBegin, MonthEnd, YearBegin, YearEnd from scipy import stats @@ -152,21 +153,24 @@ def _load_gauge_metadata(metadata_path): def _load_gesla_dataset(site, path, na_value): - with warnings.catch_warnings(): - warnings.simplefilter("ignore", FutureWarning) - gesla_df = ( - pd.read_csv( - path, - skiprows=41, - names=["date", "time", "sea_level", "qc_flag", "use_flag"], - sep=r"\s+", # sep="\s+", - parse_dates=[[0, 1]], - index_col=0, - na_values=na_value, - ) - .rename_axis("time") - .assign(site_code=site) + # Read dataset + gesla_df = pd.read_csv( + path, + skiprows=41, + names=["date", "time", "sea_level", "qc_flag", "use_flag"], + sep=r"\s+", + na_values=na_value, + ) + + # Combine two date fields + gesla_df = ( + gesla_df.assign( + time=pd.to_datetime(gesla_df["date"] + " " + gesla_df["time"]), + site_code=site, ) + .drop(columns=["date"]) + .set_index("time") + ) return gesla_df @@ -301,13 +305,11 @@ def load_gauge_gesla( paths_na = metadata_df.loc[site_code, ["file_name", "null_value"]] # Load and combine into a single dataframe - data_df = ( - pd.concat([_load_gesla_dataset(s, p, na_value=na) for s, p, na in paths_na.itertuples()]) - .sort_index() - .loc[slice(start_time, end_time)] - .reset_index() - .set_index("site_code") - ) + gauge_list = [ + _load_gesla_dataset(s, p, na_value=na) + for s, p, na in tqdm.tqdm(paths_na.itertuples(), total=len(paths_na), desc="Loading GESLA gauges") + ] + data_df = pd.concat(gauge_list).sort_index().loc[slice(start_time, end_time)].reset_index().set_index("site_code") # Optionally filter by use flag column if filter_use_flag: diff --git a/tests/testing.ipynb b/tests/testing.ipynb index 0be1c52..9de9529 100644 --- a/tests/testing.ipynb +++ b/tests/testing.ipynb @@ -2,27 +2,11 @@ "cells": [ { "cell_type": "code", - "execution_count": 1, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Collecting uv\n", - " Downloading uv-0.4.29-py3-none-manylinux_2_17_x86_64.manylinux2014_x86_64.whl.metadata (11 kB)\n", - "Downloading uv-0.4.29-py3-none-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (13.8 MB)\n", - "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m13.8/13.8 MB\u001b[0m \u001b[31m143.3 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", - "\u001b[?25hInstalling collected packages: uv\n", - "Successfully installed uv-0.4.29\n", - "\u001b[31mERROR: pip's dependency resolver does not currently take into account all the packages that are installed. This behaviour is the source of the following dependency conflicts.\n", - "dea-tools 0.3.5 requires pyTMD<=2.1.6, but you have pytmd 2.1.7 which is incompatible.\u001b[0m\u001b[31m\n", - "\u001b[0m" - ] - } - ], + "outputs": [], "source": [ - "!pip install uv\n", + "!pip install uv==0.5.0\n", "!pip install -e .. --quiet\n" ] }, @@ -32,7 +16,7 @@ "metadata": {}, "outputs": [], "source": [ - "!pip install -e /home/jovyan/Robbi/pyTMD" + "# !pip install -e /home/jovyan/Robbi/pyTMD" ] }, { @@ -110,6 +94,7 @@ "\n", "satellite_ds = load_satellite_ds()\n", "\n", + "\n", "def load_measured_tides_ds():\n", " \"\"\"\n", " Load measured sea level data from the Broome ABSLMP tidal station:\n", @@ -137,6 +122,7 @@ " # Return as xarray dataset\n", " return measured_tides_df.to_xarray()\n", "\n", + "\n", "satellite_ds = load_satellite_ds()\n", "measured_tides_ds = load_measured_tides_ds()" ] @@ -150,204 +136,519 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "cd .." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "!export EO_TIDES_TIDE_MODELS=./tests/data/tide_models && pytest tests/test_model.py --verbose -k test_parallel_splits" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "!export EO_TIDES_TIDE_MODELS=./tests/data/tide_models && pytest tests --verbose" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Ensemble updates" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from eo_tides.model import model_tides\n", + "\n", + "df = model_tides(x= 123.73412090186251, \n", + " y=-16.997767837915056, \n", + " model=\"ensemble\",\n", + " time=pd.date_range(start=\"2000\", end=\"2001\", freq=\"5h\"),\n", + " ranking_points=\"/home/jovyan/Robbi/dea-intertidal/data/raw/tide_correlation_points_test.geojson\",\n", + " k=5,\n", + " output_format=\"wide\",\n", + " directory=\"/var/share/tide_models/\")\n", + "\n", + "with pd.option_context('display.max_rows', 5, 'display.max_columns', None): \n", + " display(df)\n", + "\n", + "# u, c = np.unique(a, return_counts=True)" + ] + }, + { + "cell_type": "code", + "execution_count": 10, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "/workspaces/eo-tides\n" + "Running ensemble tide modelling\n", + "Modelling tides with EOT20, FES2012, FES2014_extrapolated, FES2022_extrapolated, GOT4.10, GOT5.6_extrapolated, HAMTIDE11, TPXO10-atlas-v2-nc, TPXO8-atlas-nc, TPXO9-atlas-v5-nc in parallel (models: 10, splits: 1)\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "/workspaces/eo-tides/.venv/lib/python3.12/site-packages/IPython/core/magics/osm.py:417: UserWarning: using dhist requires you to install the `pickleshare` library.\n", - " self.shell.db['dhist'] = compress_dhist(dhist)[-100:]\n" + "100%|██████████| 10/10 [00:13<00:00, 1.38s/it]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Interpolating model rankings using IDW interpolation \n", + "Combining models into single ensemble model\n", + "Converting to a wide format dataframe\n" ] + }, + { + "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", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
tide_modelEOT20FES2012FES2014_extrapolatedFES2022_extrapolatedGOT4.10GOT5.6_extrapolatedHAMTIDE11TPXO10-atlas-v2-ncTPXO8-atlas-ncTPXO9-atlas-v5-ncensemble
timexy
2018-01-01 00:00:00145.372051-38.260667-0.0540680.687800-0.0469300.7366870.6566250.0221400.2095770.8186120.5882470.8301290.795143
2018-01-01 01:00:00145.372051-38.260667-0.0883180.480949-0.0321350.7442310.4713520.0093890.3087810.8176490.4420390.7535400.771807
2018-01-01 02:00:00145.372051-38.260667-0.1329420.102051-0.0838820.6293390.115855-0.0214840.3551440.5886090.1424660.4549410.557630
2018-01-01 03:00:00145.372051-38.260667-0.213443-0.377484-0.2633610.282223-0.341372-0.1165720.3289380.080393-0.253323-0.0640880.099510
2018-01-01 04:00:00145.372051-38.260667-0.320080-0.847298-0.406669-0.281990-0.784016-0.2692350.227173-0.601902-0.647516-0.681982-0.521958
..........................................
2020-12-30 20:00:00145.372051-38.2606670.221464-0.3199070.212133-0.273928-0.2555060.1914820.158968-0.386745-0.243656-0.366988-0.342554
2020-12-30 21:00:00145.372051-38.2606670.153694-0.3187970.078701-0.563003-0.2615270.1470280.060131-0.425891-0.262007-0.359812-0.449568
2020-12-30 22:00:00145.372051-38.2606670.073088-0.2037790.022568-0.650761-0.1627750.087353-0.019473-0.302963-0.174997-0.213937-0.389220
2020-12-30 23:00:00145.372051-38.260667-0.023588-0.0060340.015223-0.4837080.0046780.000023-0.056254-0.091032-0.014051-0.002233-0.192324
2020-12-31 00:00:00145.372051-38.260667-0.1140980.243842-0.057904-0.1623630.200150-0.083307-0.0396610.1558670.1791780.2248580.072787
\n", + "

26281 rows × 11 columns

\n", + "
" + ], + "text/plain": [ + "tide_model EOT20 FES2012 \\\n", + "time x y \n", + "2018-01-01 00:00:00 145.372051 -38.260667 -0.054068 0.687800 \n", + "2018-01-01 01:00:00 145.372051 -38.260667 -0.088318 0.480949 \n", + "2018-01-01 02:00:00 145.372051 -38.260667 -0.132942 0.102051 \n", + "2018-01-01 03:00:00 145.372051 -38.260667 -0.213443 -0.377484 \n", + "2018-01-01 04:00:00 145.372051 -38.260667 -0.320080 -0.847298 \n", + "... ... ... \n", + "2020-12-30 20:00:00 145.372051 -38.260667 0.221464 -0.319907 \n", + "2020-12-30 21:00:00 145.372051 -38.260667 0.153694 -0.318797 \n", + "2020-12-30 22:00:00 145.372051 -38.260667 0.073088 -0.203779 \n", + "2020-12-30 23:00:00 145.372051 -38.260667 -0.023588 -0.006034 \n", + "2020-12-31 00:00:00 145.372051 -38.260667 -0.114098 0.243842 \n", + "\n", + "tide_model FES2014_extrapolated \\\n", + "time x y \n", + "2018-01-01 00:00:00 145.372051 -38.260667 -0.046930 \n", + "2018-01-01 01:00:00 145.372051 -38.260667 -0.032135 \n", + "2018-01-01 02:00:00 145.372051 -38.260667 -0.083882 \n", + "2018-01-01 03:00:00 145.372051 -38.260667 -0.263361 \n", + "2018-01-01 04:00:00 145.372051 -38.260667 -0.406669 \n", + "... ... \n", + "2020-12-30 20:00:00 145.372051 -38.260667 0.212133 \n", + "2020-12-30 21:00:00 145.372051 -38.260667 0.078701 \n", + "2020-12-30 22:00:00 145.372051 -38.260667 0.022568 \n", + "2020-12-30 23:00:00 145.372051 -38.260667 0.015223 \n", + "2020-12-31 00:00:00 145.372051 -38.260667 -0.057904 \n", + "\n", + "tide_model FES2022_extrapolated GOT4.10 \\\n", + "time x y \n", + "2018-01-01 00:00:00 145.372051 -38.260667 0.736687 0.656625 \n", + "2018-01-01 01:00:00 145.372051 -38.260667 0.744231 0.471352 \n", + "2018-01-01 02:00:00 145.372051 -38.260667 0.629339 0.115855 \n", + "2018-01-01 03:00:00 145.372051 -38.260667 0.282223 -0.341372 \n", + "2018-01-01 04:00:00 145.372051 -38.260667 -0.281990 -0.784016 \n", + "... ... ... \n", + "2020-12-30 20:00:00 145.372051 -38.260667 -0.273928 -0.255506 \n", + "2020-12-30 21:00:00 145.372051 -38.260667 -0.563003 -0.261527 \n", + "2020-12-30 22:00:00 145.372051 -38.260667 -0.650761 -0.162775 \n", + "2020-12-30 23:00:00 145.372051 -38.260667 -0.483708 0.004678 \n", + "2020-12-31 00:00:00 145.372051 -38.260667 -0.162363 0.200150 \n", + "\n", + "tide_model GOT5.6_extrapolated HAMTIDE11 \\\n", + "time x y \n", + "2018-01-01 00:00:00 145.372051 -38.260667 0.022140 0.209577 \n", + "2018-01-01 01:00:00 145.372051 -38.260667 0.009389 0.308781 \n", + "2018-01-01 02:00:00 145.372051 -38.260667 -0.021484 0.355144 \n", + "2018-01-01 03:00:00 145.372051 -38.260667 -0.116572 0.328938 \n", + "2018-01-01 04:00:00 145.372051 -38.260667 -0.269235 0.227173 \n", + "... ... ... \n", + "2020-12-30 20:00:00 145.372051 -38.260667 0.191482 0.158968 \n", + "2020-12-30 21:00:00 145.372051 -38.260667 0.147028 0.060131 \n", + "2020-12-30 22:00:00 145.372051 -38.260667 0.087353 -0.019473 \n", + "2020-12-30 23:00:00 145.372051 -38.260667 0.000023 -0.056254 \n", + "2020-12-31 00:00:00 145.372051 -38.260667 -0.083307 -0.039661 \n", + "\n", + "tide_model TPXO10-atlas-v2-nc TPXO8-atlas-nc \\\n", + "time x y \n", + "2018-01-01 00:00:00 145.372051 -38.260667 0.818612 0.588247 \n", + "2018-01-01 01:00:00 145.372051 -38.260667 0.817649 0.442039 \n", + "2018-01-01 02:00:00 145.372051 -38.260667 0.588609 0.142466 \n", + "2018-01-01 03:00:00 145.372051 -38.260667 0.080393 -0.253323 \n", + "2018-01-01 04:00:00 145.372051 -38.260667 -0.601902 -0.647516 \n", + "... ... ... \n", + "2020-12-30 20:00:00 145.372051 -38.260667 -0.386745 -0.243656 \n", + "2020-12-30 21:00:00 145.372051 -38.260667 -0.425891 -0.262007 \n", + "2020-12-30 22:00:00 145.372051 -38.260667 -0.302963 -0.174997 \n", + "2020-12-30 23:00:00 145.372051 -38.260667 -0.091032 -0.014051 \n", + "2020-12-31 00:00:00 145.372051 -38.260667 0.155867 0.179178 \n", + "\n", + "tide_model TPXO9-atlas-v5-nc ensemble \n", + "time x y \n", + "2018-01-01 00:00:00 145.372051 -38.260667 0.830129 0.795143 \n", + "2018-01-01 01:00:00 145.372051 -38.260667 0.753540 0.771807 \n", + "2018-01-01 02:00:00 145.372051 -38.260667 0.454941 0.557630 \n", + "2018-01-01 03:00:00 145.372051 -38.260667 -0.064088 0.099510 \n", + "2018-01-01 04:00:00 145.372051 -38.260667 -0.681982 -0.521958 \n", + "... ... ... \n", + "2020-12-30 20:00:00 145.372051 -38.260667 -0.366988 -0.342554 \n", + "2020-12-30 21:00:00 145.372051 -38.260667 -0.359812 -0.449568 \n", + "2020-12-30 22:00:00 145.372051 -38.260667 -0.213937 -0.389220 \n", + "2020-12-30 23:00:00 145.372051 -38.260667 -0.002233 -0.192324 \n", + "2020-12-31 00:00:00 145.372051 -38.260667 0.224858 0.072787 \n", + "\n", + "[26281 rows x 11 columns]" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" } ], "source": [ - "cd .." + "from eo_tides.model import model_tides\n", + "\n", + "df = model_tides(\n", + " x=145.372051,\n", + " y=-38.260667,\n", + " model=[\n", + " \"EOT20\",\n", + " \"FES2012\",\n", + " \"FES2014_extrapolated\",\n", + " \"FES2022_extrapolated\",\n", + " \"HAMTIDE11\",\n", + " \"GOT4.10\",\n", + " \"GOT5.6_extrapolated\",\n", + " \"TPXO10-atlas-v2-nc\",\n", + " \"TPXO8-atlas-nc\",\n", + " \"TPXO9-atlas-v5-nc\",\n", + " \"ensemble\",\n", + " ],\n", + " time=pd.date_range(start=\"2018-01-01\", end=\"2020-12-31\", freq=\"1h\"),\n", + " output_format=\"wide\",\n", + " directory=\"/var/share/tide_models/\",\n", + " ensemble_models=[\n", + " \"EOT20\",\n", + " \"FES2012\",\n", + " \"FES2014_extrapolated\",\n", + " \"FES2022_extrapolated\",\n", + " # \"HAMTIDE11\",\n", + " # \"GOT4.10\",\n", + " \"GOT5.6_extrapolated\",\n", + " \"TPXO10-atlas-v2-nc\",\n", + " # \"TPXO8-atlas-nc\",\n", + " \"TPXO9-atlas-v5-nc\",\n", + " ]\n", + ")\n", + "df" ] }, { "cell_type": "code", - "execution_count": 111, + "execution_count": 11, "metadata": {}, "outputs": [ { - "name": "stdout", - "output_type": "stream", - "text": [ - "============================= test session starts ==============================\n", - "platform linux -- Python 3.10.15, pytest-8.3.3, pluggy-1.5.0 -- /env/bin/python3.10\n", - "cachedir: .pytest_cache\n", - "rootdir: /home/jovyan/Robbi/eo-tides\n", - "configfile: pyproject.toml\n", - "plugins: anyio-4.6.2.post1, nbval-0.11.0\n", - "collected 51 items / 42 deselected / 9 selected \n", - "\n", - "tests/test_model.py::test_parallel_splits[10000-2-8-4] PASSED [ 11%]\n", - "tests/test_model.py::test_parallel_splits[5000-1-4-4] PASSED [ 22%]\n", - "tests/test_model.py::test_parallel_splits[900-1-4-1] PASSED [ 33%]\n", - "tests/test_model.py::test_parallel_splits[2000-2-2-1] PASSED [ 44%]\n", - "tests/test_model.py::test_parallel_splits[100000-2-4-2] PASSED [ 55%]\n", - "tests/test_model.py::test_parallel_splits[100000-4-8-2] PASSED [ 66%]\n", - "tests/test_model.py::test_parallel_splits[1-1-1-1] PASSED [ 77%]\n", - "tests/test_model.py::test_parallel_splits[999999-1-8-8] PASSED [ 88%]\n", - "tests/test_model.py::test_parallel_splits[10000-8-8-1] PASSED [100%]\n", - "\n", - "=============================== warnings summary ===============================\n", - ":241\n", - " :241: RuntimeWarning: numpy.ndarray size changed, may indicate binary incompatibility. Expected 16 from C header, got 96 from PyObject\n", - "\n", - "-- Docs: https://docs.pytest.org/en/stable/how-to/capture-warnings.html\n", - "================= 9 passed, 42 deselected, 1 warning in 1.83s ==================\n" - ] + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" } ], "source": [ - "!export EO_TIDES_TIDE_MODELS=./tests/data/tide_models && pytest tests/test_model.py --verbose -k test_parallel_splits" + "import matplotlib.pyplot as plt\n", + "df.droplevel([\"x\", \"y\"]).head(50).drop(\"ensemble\", axis=1).plot(linewidth=0.8, figsize=(10, 6))\n", + "df.droplevel([\"x\", \"y\"]).head(50).ensemble.plot(linewidth=3, c=\"black\")\n", + "plt.legend(bbox_to_anchor=(1.05, 1), loc='upper left', borderaxespad=0)" ] }, { "cell_type": "code", - "execution_count": 146, + "execution_count": 7, "metadata": {}, "outputs": [ { - "name": "stdout", - "output_type": "stream", - "text": [ - "============================= test session starts ==============================\n", - "platform linux -- Python 3.10.15, pytest-8.3.3, pluggy-1.5.0 -- /env/bin/python3.10\n", - "cachedir: .pytest_cache\n", - "rootdir: /home/jovyan/Robbi/eo-tides\n", - "configfile: pyproject.toml\n", - "plugins: anyio-4.6.2.post1, nbval-0.11.0\n", - "collected 96 items \n", - "\n", - "tests/test_eo.py::test_tag_tides[satellite_ds_epsg3577-None-None] PASSED [ 1%]\n", - "tests/test_eo.py::test_tag_tides[satellite_ds_epsg3577--18.0008-122.2183] PASSED [ 2%]\n", - "tests/test_eo.py::test_tag_tides_multiple[satellite_ds_epsg3577] PASSED [ 3%]\n", - "tests/test_eo.py::test_pixel_tides[satellite_ds_epsg3577-None] PASSED [ 4%]\n", - "tests/test_eo.py::test_pixel_tides[satellite_ds_epsg3577-custom] PASSED [ 5%]\n", - "tests/test_eo.py::test_pixel_tides_times[satellite_ds_epsg3577] PASSED [ 6%]\n", - "tests/test_eo.py::test_pixel_tides_quantile[satellite_ds_epsg3577] PASSED [ 7%]\n", - "tests/test_eo.py::test_pixel_tides_multiplemodels[satellite_ds_epsg3577-None] PASSED [ 8%]\n", - "tests/test_eo.py::test_pixel_tides_multiplemodels[satellite_ds_epsg3577-quantiles1] PASSED [ 9%]\n", - "tests/test_eo.py::test_pixel_tides_dask[satellite_ds_epsg3577-None] PASSED [ 10%]\n", - "tests/test_eo.py::test_pixel_tides_dask[satellite_ds_epsg3577-dask_chunks1] PASSED [ 11%]\n", - "tests/test_eo.py::test_pixel_tides_dask[satellite_ds_epsg3577-dask_chunks2] PASSED [ 12%]\n", - "tests/test_eo.py::test_pixel_tides_ensemble[satellite_ds_epsg3577] PASSED [ 13%]\n", - "tests/test_stats.py::test_tidal_stats[satellite_ds_epsg3577-2h] PASSED [ 14%]\n", - "tests/test_stats.py::test_tidal_stats[satellite_ds_epsg3577-120min] PASSED [ 15%]\n", - "tests/test_stats.py::test_pixel_stats[satellite_ds_epsg3577-models0-False] PASSED [ 16%]\n", - "tests/test_stats.py::test_pixel_stats[satellite_ds_epsg3577-models1-False] PASSED [ 17%]\n", - "tests/test_stats.py::test_pixel_stats[satellite_ds_epsg3577-models2-True] PASSED [ 18%]\n", - "tests/test_eo.py::test_tag_tides[satellite_ds_epsg4326-None-None] PASSED [ 19%]\n", - "tests/test_eo.py::test_tag_tides[satellite_ds_epsg4326--18.0008-122.2183] PASSED [ 20%]\n", - "tests/test_eo.py::test_tag_tides_multiple[satellite_ds_epsg4326] PASSED [ 21%]\n", - "tests/test_eo.py::test_pixel_tides[satellite_ds_epsg4326-None] PASSED [ 22%]\n", - "tests/test_eo.py::test_pixel_tides[satellite_ds_epsg4326-custom] PASSED [ 23%]\n", - "tests/test_eo.py::test_pixel_tides_times[satellite_ds_epsg4326] PASSED [ 25%]\n", - "tests/test_eo.py::test_pixel_tides_quantile[satellite_ds_epsg4326] PASSED [ 26%]\n", - "tests/test_eo.py::test_pixel_tides_multiplemodels[satellite_ds_epsg4326-None] PASSED [ 27%]\n", - "tests/test_eo.py::test_pixel_tides_multiplemodels[satellite_ds_epsg4326-quantiles1] PASSED [ 28%]\n", - "tests/test_eo.py::test_pixel_tides_dask[satellite_ds_epsg4326-None] PASSED [ 29%]\n", - "tests/test_eo.py::test_pixel_tides_dask[satellite_ds_epsg4326-dask_chunks1] PASSED [ 30%]\n", - "tests/test_eo.py::test_pixel_tides_dask[satellite_ds_epsg4326-dask_chunks2] PASSED [ 31%]\n", - "tests/test_eo.py::test_pixel_tides_ensemble[satellite_ds_epsg4326] PASSED [ 32%]\n", - "tests/test_stats.py::test_tidal_stats[satellite_ds_epsg4326-2h] PASSED [ 33%]\n", - "tests/test_stats.py::test_tidal_stats[satellite_ds_epsg4326-120min] PASSED [ 34%]\n", - "tests/test_stats.py::test_pixel_stats[satellite_ds_epsg4326-models0-False] PASSED [ 35%]\n", - "tests/test_stats.py::test_pixel_stats[satellite_ds_epsg4326-models1-False] PASSED [ 36%]\n", - "tests/test_stats.py::test_pixel_stats[satellite_ds_epsg4326-models2-True] PASSED [ 37%]\n", - "tests/test_model.py::test_standardise_time[None-None] PASSED [ 38%]\n", - "tests/test_model.py::test_standardise_time[input_value1-expected_output1] PASSED [ 39%]\n", - "tests/test_model.py::test_standardise_time[input_value2-expected_output2] PASSED [ 40%]\n", - "tests/test_model.py::test_standardise_time[input_value3-expected_output3] PASSED [ 41%]\n", - "tests/test_model.py::test_standardise_time[input_value4-expected_output4] PASSED [ 42%]\n", - "tests/test_model.py::test_standardise_time[input_value5-expected_output5] PASSED [ 43%]\n", - "tests/test_model.py::test_standardise_time[input_value6-expected_output6] PASSED [ 44%]\n", - "tests/test_model.py::test_standardise_time[input_value7-expected_output7] PASSED [ 45%]\n", - "tests/test_model.py::test_standardise_time[2020-01-12 21:14-expected_output8] PASSED [ 46%]\n", - "tests/test_model.py::test_standardise_time[input_value9-expected_output9] PASSED [ 47%]\n", - "tests/test_model.py::test_parallel_splits[10000-2-8-4] PASSED [ 48%]\n", - "tests/test_model.py::test_parallel_splits[5000-1-4-4] PASSED [ 50%]\n", - "tests/test_model.py::test_parallel_splits[900-1-4-1] PASSED [ 51%]\n", - "tests/test_model.py::test_parallel_splits[2000-2-2-1] PASSED [ 52%]\n", - "tests/test_model.py::test_parallel_splits[100000-2-4-2] PASSED [ 53%]\n", - "tests/test_model.py::test_parallel_splits[100000-4-8-2] PASSED [ 54%]\n", - "tests/test_model.py::test_parallel_splits[1-1-1-1] PASSED [ 55%]\n", - "tests/test_model.py::test_parallel_splits[999999-1-8-8] PASSED [ 56%]\n", - "tests/test_model.py::test_parallel_splits[10000-8-8-1] PASSED [ 57%]\n", - "tests/test_model.py::test_list_models PASSED [ 58%]\n", - "tests/test_model.py::test_model_tides[122.2183--18.0008-EPSG:4326-bilinear-EOT20] PASSED [ 59%]\n", - "tests/test_model.py::test_model_tides[122.2183--18.0008-EPSG:4326-spline-EOT20] PASSED [ 60%]\n", - "tests/test_model.py::test_model_tides[-1034913--1961916-EPSG:3577-bilinear-EOT20] PASSED [ 61%]\n", - "tests/test_model.py::test_model_tides[122.2183--18.0008-EPSG:4326-spline-GOT5.5] PASSED [ 62%]\n", - "tests/test_model.py::test_model_tides[122.2183--18.0008-EPSG:4326-spline-HAMTIDE11] PASSED [ 63%]\n", - "tests/test_model.py::test_model_tides_multiplemodels[single_model_long] PASSED [ 64%]\n", - "tests/test_model.py::test_model_tides_multiplemodels[single_model_wide] PASSED [ 65%]\n", - "tests/test_model.py::test_model_tides_multiplemodels[multiple_models_long] PASSED [ 66%]\n", - "tests/test_model.py::test_model_tides_multiplemodels[multiple_models_wide] PASSED [ 67%]\n", - "tests/test_model.py::test_model_tides_units[metres] PASSED [ 68%]\n", - "tests/test_model.py::test_model_tides_units[centimetres] PASSED [ 69%]\n", - "tests/test_model.py::test_model_tides_units[millimetres] PASSED [ 70%]\n", - "tests/test_model.py::test_model_tides_mode[one-to-many-models0-long] PASSED [ 71%]\n", - "tests/test_model.py::test_model_tides_mode[one-to-one-models1-long] PASSED [ 72%]\n", - "tests/test_model.py::test_model_tides_mode[one-to-many-models2-wide] PASSED [ 73%]\n", - "tests/test_model.py::test_model_tides_mode[one-to-one-models3-wide] PASSED [ 75%]\n", - "tests/test_model.py::test_model_tides_mode[one-to-many-models4-long] PASSED [ 76%]\n", - "tests/test_model.py::test_model_tides_mode[one-to-one-models5-long] PASSED [ 77%]\n", - "tests/test_model.py::test_model_tides_mode[one-to-many-models6-wide] PASSED [ 78%]\n", - "tests/test_model.py::test_model_tides_mode[one-to-one-models7-wide] PASSED [ 79%]\n", - "tests/test_model.py::test_model_tides_ensemble PASSED [ 80%]\n", - "tests/test_model.py::test_model_phases[15 min] PASSED [ 81%]\n", - "tests/test_model.py::test_model_phases[20 min] PASSED [ 82%]\n", - "tests/test_model.py::test_model_phases_format[models0-long-False-expected_cols0] PASSED [ 83%]\n", - "tests/test_model.py::test_model_phases_format[models1-long-True-expected_cols1] PASSED [ 84%]\n", - "tests/test_model.py::test_model_phases_format[models2-long-False-expected_cols2] PASSED [ 85%]\n", - "tests/test_model.py::test_model_phases_format[models3-long-True-expected_cols3] PASSED [ 86%]\n", - "tests/test_model.py::test_model_phases_format[models4-wide-False-expected_cols4] PASSED [ 87%]\n", - "tests/test_model.py::test_model_phases_format[models5-wide-True-expected_cols5] PASSED [ 88%]\n", - "tests/test_model.py::test_model_phases_format[models6-wide-False-expected_cols6] PASSED [ 89%]\n", - "tests/test_model.py::test_model_phases_format[models7-wide-True-expected_cols7] PASSED [ 90%]\n", - "tests/test_utils.py::test_idw PASSED [ 91%]\n", - "tests/test_validation.py::test_load_gauge_gesla[broome_xy] PASSED [ 92%]\n", - "tests/test_validation.py::test_load_gauge_gesla[sandiego_xy] PASSED [ 93%]\n", - "tests/test_validation.py::test_load_gauge_gesla[syd_xy_correctmean] PASSED [ 94%]\n", - "tests/test_validation.py::test_load_gauge_gesla[no_nearest] XFAIL (N...) [ 95%]\n", - "tests/test_validation.py::test_load_gauge_gesla[broome_bbox] PASSED [ 96%]\n", - "tests/test_validation.py::test_load_gauge_gesla[aus_bbox] PASSED [ 97%]\n", - "tests/test_validation.py::test_load_gauge_gesla[broome_code] PASSED [ 98%]\n", - "tests/test_validation.py::test_load_gauge_gesla[aus_code] PASSED [100%]\n", - "\n", - "=============================== warnings summary ===============================\n", - ":241\n", - " :241: RuntimeWarning: numpy.ndarray size changed, may indicate binary incompatibility. Expected 16 from C header, got 96 from PyObject\n", - "\n", - "tests/test_eo.py: 8 warnings\n", - "tests/test_stats.py: 32 warnings\n", - "tests/test_model.py: 54 warnings\n", - " /env/lib/python3.10/site-packages/pyproj/transformer.py:817: DeprecationWarning: Conversion of an array with ndim > 0 to a scalar is deprecated, and will error in future. Ensure you extract a single element from your array before performing this operation. (Deprecated NumPy 1.25.)\n", - " return self._transformer._transform_point(\n", - "\n", - "tests/test_eo.py: 14 warnings\n", - " /env/lib/python3.10/site-packages/rasterio/warp.py:387: NotGeoreferencedWarning: Dataset has no geotransform, gcps, or rpcs. The identity matrix will be returned.\n", - " dest = _reproject(\n", - "\n", - "-- Docs: https://docs.pytest.org/en/stable/how-to/capture-warnings.html\n", - "=========== 95 passed, 1 xfailed, 109 warnings in 256.12s (0:04:16) ============\n" - ] + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" } ], "source": [ - "!export EO_TIDES_TIDE_MODELS=./tests/data/tide_models && pytest tests --verbose" + "import matplotlib.pyplot as plt\n", + "df.droplevel([\"x\", \"y\"]).head(50).drop(\"ensemble\", axis=1).plot(linewidth=0.8, figsize=(10, 6))\n", + "df.droplevel([\"x\", \"y\"]).head(50).ensemble.plot(linewidth=3, c=\"black\")\n", + "plt.legend(bbox_to_anchor=(1.05, 1), loc='upper left', borderaxespad=0)" ] }, { @@ -359,31 +660,9 @@ }, { "cell_type": "code", - "execution_count": 107, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Running ensemble tide modelling\n", - "Models to process: ['EOT20', 'GOT5.5', 'HAMTIDE11']\n", - "Models requested: ['ensemble', 'GOT5.5']\n", - "Ensemble models: ['EOT20', 'HAMTIDE11']\n" - ] - }, - { - "ename": "AssertionError", - "evalue": "", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mAssertionError\u001b[0m Traceback (most recent call last)", - "Cell \u001b[0;32mIn[107], line 167\u001b[0m\n\u001b[1;32m 164\u001b[0m \u001b[38;5;28mprint\u001b[39m(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mEnsemble models: \u001b[39m\u001b[38;5;124m\"\u001b[39m, ensemble_models)\n\u001b[1;32m 166\u001b[0m \u001b[38;5;28;01massert\u001b[39;00m models_to_process \u001b[38;5;241m==\u001b[39m exp_process\n\u001b[0;32m--> 167\u001b[0m \u001b[38;5;28;01massert\u001b[39;00m models_requested \u001b[38;5;241m==\u001b[39m exp_request\n\u001b[1;32m 168\u001b[0m \u001b[38;5;28;01massert\u001b[39;00m ensemble_models \u001b[38;5;241m==\u001b[39m exp_ensemble\n", - "\u001b[0;31mAssertionError\u001b[0m: " - ] - } - ], + "outputs": [], "source": [ "from eo_tides.utils import _set_directory, list_models\n", "\n", @@ -557,68 +836,27 @@ }, { "cell_type": "code", - "execution_count": 106, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "['EOT20', 'GOT5.5', 'HAMTIDE11', 'ensemble']" - ] - }, - "execution_count": 106, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "models_requested" ] }, { "cell_type": "code", - "execution_count": 60, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "['GOT5.5',\n", - " 'HAMTIDE11',\n", - " 'ensemble',\n", - " 'FES2012',\n", - " 'TPXO8-atlas-v1',\n", - " 'TPXO9-atlas-v5',\n", - " 'FES2014',\n", - " 'GOT4.10',\n", - " 'EOT20']" - ] - }, - "execution_count": 60, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "list(set(models_requested + ensemble_models))" ] }, { "cell_type": "code", - "execution_count": 24, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "['ensemble', 'GOT5.5']" - ] - }, - "execution_count": 24, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "ensemble_models\n", "\n", @@ -627,27 +865,9 @@ }, { "cell_type": "code", - "execution_count": 29, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "['HAMTIDE11',\n", - " 'GOT5.5',\n", - " 'FES2012',\n", - " 'TPXO8-atlas-v1',\n", - " 'TPXO9-atlas-v5',\n", - " 'FES2014',\n", - " 'GOT4.10',\n", - " 'EOT20']" - ] - }, - "execution_count": 29, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [] }, { @@ -663,39 +883,9 @@ }, { "cell_type": "code", - "execution_count": 148, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'version': 'FES2022', 'compressed': False, 'type': 'z', 'crop': True, 'bounds': None, 'method': 'spline', 'extrapolate': True, 'cutoff': inf, 'append_node': False, 'apply_flexure': False, 'scale': 0.01}\n", - "{'version': 'FES2022', 'compressed': False, 'type': 'z', 'crop': True, 'bounds': None, 'method': 'spline', 'extrapolate': True, 'cutoff': inf, 'append_node': False, 'apply_flexure': False, 'scale': 0.01}\n" - ] - }, - { - "ename": "KeyboardInterrupt", - "evalue": "", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mKeyboardInterrupt\u001b[0m Traceback (most recent call last)", - "Cell \u001b[0;32mIn[148], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m \u001b[43mget_ipython\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mrun_cell_magic\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[38;5;124;43mtimeit\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[38;5;124;43m-n 1 -r 1\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[38;5;130;43;01m\\n\u001b[39;49;00m\u001b[38;5;124;43mx=np.linspace(122.2183, 122.219, 10)\u001b[39;49m\u001b[38;5;130;43;01m\\n\u001b[39;49;00m\u001b[38;5;124;43my=np.linspace(-18.0008, -18.01, 10)\u001b[39;49m\u001b[38;5;130;43;01m\\n\u001b[39;49;00m\u001b[38;5;124;43mtime=pd.date_range(\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43m2020\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43m, \u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43m2021\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43m, periods=10)\u001b[39;49m\u001b[38;5;130;43;01m\\n\u001b[39;49;00m\u001b[38;5;124;43mcrs=\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mEPSG:4326\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;130;43;01m\\n\u001b[39;49;00m\u001b[38;5;124;43mmethod=\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mspline\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;130;43;01m\\n\u001b[39;49;00m\u001b[38;5;124;43mmodel=\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mFES2022\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;130;43;01m\\n\u001b[39;49;00m\u001b[38;5;130;43;01m\\n\u001b[39;49;00m\u001b[38;5;124;43m# Run equivalent pyTMD code to verify same results\u001b[39;49m\u001b[38;5;130;43;01m\\n\u001b[39;49;00m\u001b[38;5;124;43mpytmd_tides = tide_elevations(\u001b[39;49m\u001b[38;5;130;43;01m\\n\u001b[39;49;00m\u001b[38;5;124;43m x=x, \u001b[39;49m\u001b[38;5;130;43;01m\\n\u001b[39;49;00m\u001b[38;5;124;43m y=y, \u001b[39;49m\u001b[38;5;130;43;01m\\n\u001b[39;49;00m\u001b[38;5;124;43m delta_time=time,\u001b[39;49m\u001b[38;5;130;43;01m\\n\u001b[39;49;00m\u001b[38;5;124;43m DIRECTORY=\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43m/gdata1/data/tide_models/\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43m,\u001b[39;49m\u001b[38;5;130;43;01m\\n\u001b[39;49;00m\u001b[38;5;124;43m MODEL=model,\u001b[39;49m\u001b[38;5;130;43;01m\\n\u001b[39;49;00m\u001b[38;5;124;43m EPSG=int(crs[-4:]),\u001b[39;49m\u001b[38;5;130;43;01m\\n\u001b[39;49;00m\u001b[38;5;124;43m TIME=\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mdatetime\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43m,\u001b[39;49m\u001b[38;5;130;43;01m\\n\u001b[39;49;00m\u001b[38;5;124;43m EXTRAPOLATE=True,\u001b[39;49m\u001b[38;5;130;43;01m\\n\u001b[39;49;00m\u001b[38;5;124;43m CUTOFF=np.inf,\u001b[39;49m\u001b[38;5;130;43;01m\\n\u001b[39;49;00m\u001b[38;5;124;43m METHOD=method,\u001b[39;49m\u001b[38;5;130;43;01m\\n\u001b[39;49;00m\u001b[38;5;124;43m CROP=True,\u001b[39;49m\u001b[38;5;130;43;01m\\n\u001b[39;49;00m\u001b[38;5;124;43m # CROP=False,\u001b[39;49m\u001b[38;5;130;43;01m\\n\u001b[39;49;00m\u001b[38;5;124;43m # BOUNDS=bounds,\u001b[39;49m\u001b[38;5;130;43;01m\\n\u001b[39;49;00m\u001b[38;5;124;43m )\u001b[39;49m\u001b[38;5;130;43;01m\\n\u001b[39;49;00m\u001b[38;5;124;43mpytmd_tides\u001b[39;49m\u001b[38;5;130;43;01m\\n\u001b[39;49;00m\u001b[38;5;124;43m'\u001b[39;49m\u001b[43m)\u001b[49m\n", - "File \u001b[0;32m/env/lib/python3.10/site-packages/IPython/core/interactiveshell.py:2541\u001b[0m, in \u001b[0;36mInteractiveShell.run_cell_magic\u001b[0;34m(self, magic_name, line, cell)\u001b[0m\n\u001b[1;32m 2539\u001b[0m \u001b[38;5;28;01mwith\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mbuiltin_trap:\n\u001b[1;32m 2540\u001b[0m args \u001b[38;5;241m=\u001b[39m (magic_arg_s, cell)\n\u001b[0;32m-> 2541\u001b[0m result \u001b[38;5;241m=\u001b[39m \u001b[43mfn\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 2543\u001b[0m \u001b[38;5;66;03m# The code below prevents the output from being displayed\u001b[39;00m\n\u001b[1;32m 2544\u001b[0m \u001b[38;5;66;03m# when using magics with decorator @output_can_be_silenced\u001b[39;00m\n\u001b[1;32m 2545\u001b[0m \u001b[38;5;66;03m# when the last Python token in the expression is a ';'.\u001b[39;00m\n\u001b[1;32m 2546\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mgetattr\u001b[39m(fn, magic\u001b[38;5;241m.\u001b[39mMAGIC_OUTPUT_CAN_BE_SILENCED, \u001b[38;5;28;01mFalse\u001b[39;00m):\n", - "File \u001b[0;32m/env/lib/python3.10/site-packages/IPython/core/magics/execution.py:1189\u001b[0m, in \u001b[0;36mExecutionMagics.timeit\u001b[0;34m(self, line, cell, local_ns)\u001b[0m\n\u001b[1;32m 1186\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m time_number \u001b[38;5;241m>\u001b[39m\u001b[38;5;241m=\u001b[39m \u001b[38;5;241m0.2\u001b[39m:\n\u001b[1;32m 1187\u001b[0m \u001b[38;5;28;01mbreak\u001b[39;00m\n\u001b[0;32m-> 1189\u001b[0m all_runs \u001b[38;5;241m=\u001b[39m \u001b[43mtimer\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mrepeat\u001b[49m\u001b[43m(\u001b[49m\u001b[43mrepeat\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mnumber\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 1190\u001b[0m best \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mmin\u001b[39m(all_runs) \u001b[38;5;241m/\u001b[39m number\n\u001b[1;32m 1191\u001b[0m worst \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mmax\u001b[39m(all_runs) \u001b[38;5;241m/\u001b[39m number\n", - "File \u001b[0;32m/env/lib/python3.10/timeit.py:206\u001b[0m, in \u001b[0;36mTimer.repeat\u001b[0;34m(self, repeat, number)\u001b[0m\n\u001b[1;32m 204\u001b[0m r \u001b[38;5;241m=\u001b[39m []\n\u001b[1;32m 205\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m i \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mrange\u001b[39m(repeat):\n\u001b[0;32m--> 206\u001b[0m t \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mtimeit\u001b[49m\u001b[43m(\u001b[49m\u001b[43mnumber\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 207\u001b[0m r\u001b[38;5;241m.\u001b[39mappend(t)\n\u001b[1;32m 208\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m r\n", - "File \u001b[0;32m/env/lib/python3.10/site-packages/IPython/core/magics/execution.py:173\u001b[0m, in \u001b[0;36mTimer.timeit\u001b[0;34m(self, number)\u001b[0m\n\u001b[1;32m 171\u001b[0m gc\u001b[38;5;241m.\u001b[39mdisable()\n\u001b[1;32m 172\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[0;32m--> 173\u001b[0m timing \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43minner\u001b[49m\u001b[43m(\u001b[49m\u001b[43mit\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[43mtimer\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 174\u001b[0m \u001b[38;5;28;01mfinally\u001b[39;00m:\n\u001b[1;32m 175\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m gcold:\n", - "File \u001b[0;32m:9\u001b[0m, in \u001b[0;36minner\u001b[0;34m(_it, _timer)\u001b[0m\n", - "File \u001b[0;32m~/Robbi/pyTMD/pyTMD/compute.py:361\u001b[0m, in \u001b[0;36mtide_elevations\u001b[0;34m(x, y, delta_time, DIRECTORY, MODEL, GZIP, DEFINITION_FILE, CROP, BOUNDS, EPSG, EPOCH, TYPE, TIME, METHOD, EXTRAPOLATE, CUTOFF, CORRECTIONS, INFER_MINOR, MINOR_CONSTITUENTS, APPEND_NODE, APPLY_FLEXURE, FILL_VALUE, **kwargs)\u001b[0m\n\u001b[1;32m 358\u001b[0m nt \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mlen\u001b[39m(ts)\n\u001b[1;32m 360\u001b[0m \u001b[38;5;66;03m# read tidal constants and interpolate to grid points\u001b[39;00m\n\u001b[0;32m--> 361\u001b[0m amp, ph, c \u001b[38;5;241m=\u001b[39m \u001b[43mmodel\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mextract_constants\u001b[49m\u001b[43m(\u001b[49m\u001b[43mlon\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mlat\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43mtype\u001b[39;49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mmodel\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mtype\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 362\u001b[0m \u001b[43m \u001b[49m\u001b[43mcrop\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mCROP\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mbounds\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mBOUNDS\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mmethod\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mMETHOD\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 363\u001b[0m \u001b[43m \u001b[49m\u001b[43mextrapolate\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mEXTRAPOLATE\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mcutoff\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mCUTOFF\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 364\u001b[0m \u001b[43m \u001b[49m\u001b[43mappend_node\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mAPPEND_NODE\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mapply_flexure\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mAPPLY_FLEXURE\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 365\u001b[0m \u001b[38;5;66;03m# calculate complex phase in radians for Euler's\u001b[39;00m\n\u001b[1;32m 366\u001b[0m cph \u001b[38;5;241m=\u001b[39m \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m1\u001b[39mj\u001b[38;5;241m*\u001b[39mph\u001b[38;5;241m*\u001b[39mnp\u001b[38;5;241m.\u001b[39mpi\u001b[38;5;241m/\u001b[39m\u001b[38;5;241m180.0\u001b[39m\n", - "File \u001b[0;32m~/Robbi/pyTMD/pyTMD/io/model.py:1037\u001b[0m, in \u001b[0;36mmodel.extract_constants\u001b[0;34m(self, lon, lat, **kwargs)\u001b[0m\n\u001b[1;32m 1035\u001b[0m model_file \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mmodel_file\n\u001b[1;32m 1036\u001b[0m \u001b[38;5;66;03m# extract tidal constants for model type\u001b[39;00m\n\u001b[0;32m-> 1037\u001b[0m amp,ph \u001b[38;5;241m=\u001b[39m \u001b[43mFES\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mextract_constants\u001b[49m\u001b[43m(\u001b[49m\u001b[43mlon\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mlat\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 1038\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mmodel_file\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mversion\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mversion\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 1039\u001b[0m \u001b[43m \u001b[49m\u001b[43mcompressed\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mcompressed\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 1040\u001b[0m \u001b[38;5;66;03m# available model constituents\u001b[39;00m\n\u001b[1;32m 1041\u001b[0m c \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mconstituents\n", - "File \u001b[0;32m~/Robbi/pyTMD/pyTMD/io/FES.py:297\u001b[0m, in \u001b[0;36mextract_constants\u001b[0;34m(ilon, ilat, model_files, **kwargs)\u001b[0m\n\u001b[1;32m 293\u001b[0m hci\u001b[38;5;241m.\u001b[39mdata[hci\u001b[38;5;241m.\u001b[39mmask] \u001b[38;5;241m=\u001b[39m hci\u001b[38;5;241m.\u001b[39mfill_value\n\u001b[1;32m 294\u001b[0m \u001b[38;5;28;01melif\u001b[39;00m (kwargs[\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mmethod\u001b[39m\u001b[38;5;124m'\u001b[39m] \u001b[38;5;241m==\u001b[39m \u001b[38;5;124m'\u001b[39m\u001b[38;5;124mspline\u001b[39m\u001b[38;5;124m'\u001b[39m):\n\u001b[1;32m 295\u001b[0m \u001b[38;5;66;03m# interpolate complex form of the constituent\u001b[39;00m\n\u001b[1;32m 296\u001b[0m \u001b[38;5;66;03m# use scipy splines to interpolate values\u001b[39;00m\n\u001b[0;32m--> 297\u001b[0m hci \u001b[38;5;241m=\u001b[39m \u001b[43mpyTMD\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43minterpolate\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mspline\u001b[49m\u001b[43m(\u001b[49m\u001b[43mlon\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mlat\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mhc\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43milon\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43milat\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 298\u001b[0m \u001b[43m \u001b[49m\u001b[43mdtype\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mhc\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mdtype\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 299\u001b[0m \u001b[43m \u001b[49m\u001b[43mreducer\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mnp\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mceil\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 300\u001b[0m \u001b[43m \u001b[49m\u001b[43mkx\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;241;43m1\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mky\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;241;43m1\u001b[39;49m\u001b[43m)\u001b[49m\n\u001b[1;32m 301\u001b[0m \u001b[38;5;66;03m# replace invalid values with fill_value\u001b[39;00m\n\u001b[1;32m 302\u001b[0m hci\u001b[38;5;241m.\u001b[39mdata[hci\u001b[38;5;241m.\u001b[39mmask] \u001b[38;5;241m=\u001b[39m hci\u001b[38;5;241m.\u001b[39mfill_value\n", - "File \u001b[0;32m~/Robbi/pyTMD/pyTMD/interpolate.py:181\u001b[0m, in \u001b[0;36mspline\u001b[0;34m(ilon, ilat, idata, lon, lat, fill_value, dtype, reducer, **kwargs)\u001b[0m\n\u001b[1;32m 179\u001b[0m \u001b[38;5;66;03m# construct splines for input data and mask\u001b[39;00m\n\u001b[1;32m 180\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m np\u001b[38;5;241m.\u001b[39miscomplexobj(idata):\n\u001b[0;32m--> 181\u001b[0m s1 \u001b[38;5;241m=\u001b[39m \u001b[43mscipy\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43minterpolate\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mRectBivariateSpline\u001b[49m\u001b[43m(\u001b[49m\u001b[43milon\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43milat\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 182\u001b[0m \u001b[43m \u001b[49m\u001b[43midata\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mdata\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mreal\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mT\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 183\u001b[0m s2 \u001b[38;5;241m=\u001b[39m scipy\u001b[38;5;241m.\u001b[39minterpolate\u001b[38;5;241m.\u001b[39mRectBivariateSpline(ilon, ilat,\n\u001b[1;32m 184\u001b[0m idata\u001b[38;5;241m.\u001b[39mdata\u001b[38;5;241m.\u001b[39mimag\u001b[38;5;241m.\u001b[39mT, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs)\n\u001b[1;32m 185\u001b[0m s3 \u001b[38;5;241m=\u001b[39m scipy\u001b[38;5;241m.\u001b[39minterpolate\u001b[38;5;241m.\u001b[39mRectBivariateSpline(ilon, ilat,\n\u001b[1;32m 186\u001b[0m idata\u001b[38;5;241m.\u001b[39mmask\u001b[38;5;241m.\u001b[39mT, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs)\n", - "File \u001b[0;32m/env/lib/python3.10/site-packages/scipy/interpolate/_fitpack2.py:1602\u001b[0m, in \u001b[0;36mRectBivariateSpline.__init__\u001b[0;34m(self, x, y, z, bbox, kx, ky, s)\u001b[0m\n\u001b[1;32m 1600\u001b[0m z \u001b[38;5;241m=\u001b[39m ravel(z)\n\u001b[1;32m 1601\u001b[0m xb, xe, yb, ye \u001b[38;5;241m=\u001b[39m bbox\n\u001b[0;32m-> 1602\u001b[0m nx, tx, ny, ty, c, fp, ier \u001b[38;5;241m=\u001b[39m \u001b[43mdfitpack\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mregrid_smth\u001b[49m\u001b[43m(\u001b[49m\u001b[43mx\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43my\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mz\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mxb\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mxe\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43myb\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 1603\u001b[0m \u001b[43m \u001b[49m\u001b[43mye\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mkx\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mky\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43ms\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 1605\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m ier \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;129;01min\u001b[39;00m [\u001b[38;5;241m0\u001b[39m, \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m1\u001b[39m, \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m2\u001b[39m]:\n\u001b[1;32m 1606\u001b[0m msg \u001b[38;5;241m=\u001b[39m _surfit_messages\u001b[38;5;241m.\u001b[39mget(ier, \u001b[38;5;124m'\u001b[39m\u001b[38;5;124mier=\u001b[39m\u001b[38;5;132;01m%s\u001b[39;00m\u001b[38;5;124m'\u001b[39m \u001b[38;5;241m%\u001b[39m (ier))\n", - "\u001b[0;31mKeyboardInterrupt\u001b[0m: " - ] - } - ], + "outputs": [], "source": [ "%%timeit -n 1 -r 1\n", "\n", @@ -736,241 +926,9 @@ }, { "cell_type": "code", - "execution_count": 114, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "The line_profiler extension is already loaded. To reload it, use:\n", - " %reload_ext line_profiler\n" - ] - }, - { - "data": { - "text/plain": [ - "Timer unit: 1 s\n", - "\n", - "Total time: 670.222 s\n", - "File: /home/jovyan/Robbi/pyTMD/pyTMD/io/FES.py\n", - "Function: extract_constants at line 134\n", - "\n", - "Line # Hits Time Per Hit % Time Line Contents\n", - "==============================================================\n", - " 134 def extract_constants(\n", - " 135 ilon: np.ndarray,\n", - " 136 ilat: np.ndarray,\n", - " 137 model_files: str | list | pathlib.Path | None = None,\n", - " 138 **kwargs\n", - " 139 ):\n", - " 140 \"\"\"\n", - " 141 Reads files for a FES ascii or netCDF4 tidal model\n", - " 142 \n", - " 143 Makes initial calculations to run the tide program\n", - " 144 \n", - " 145 Spatially interpolates tidal constituents to input coordinates\n", - " 146 \n", - " 147 Parameters\n", - " 148 ----------\n", - " 149 ilon: np.ndarray\n", - " 150 longitude to interpolate\n", - " 151 ilat: np.ndarray\n", - " 152 latitude to interpolate\n", - " 153 model_files: str, list, pathlib.Path or NoneType, default None\n", - " 154 list of model files for each constituent\n", - " 155 type: str, default 'z'\n", - " 156 Tidal variable to read\n", - " 157 \n", - " 158 - ``'z'``: heights\n", - " 159 - ``'u'``: horizontal transport velocities\n", - " 160 - ``'v'``: vertical transport velocities\n", - " 161 version: str or NoneType, default None\n", - " 162 Model version to read\n", - " 163 \n", - " 164 - ``'FES1999'``\n", - " 165 - ``'FES2004'``\n", - " 166 - ``'FES2012'``\n", - " 167 - ``'FES2014'``\n", - " 168 - ``'FES2022'``\n", - " 169 - ``'EOT20'``\n", - " 170 - ``'HAMTIDE11'``\n", - " 171 compressed: bool, default False\n", - " 172 Input files are gzip compressed\n", - " 173 crop: bool, default False\n", - " 174 Crop tide model data to (buffered) bounds\n", - " 175 bounds: list or NoneType, default None\n", - " 176 Boundaries for cropping tide model data\n", - " 177 method: str, default 'spline'\n", - " 178 Interpolation method\n", - " 179 \n", - " 180 - ``'bilinear'``: quick bilinear interpolation\n", - " 181 - ``'spline'``: scipy bivariate spline interpolation\n", - " 182 - ``'linear'``, ``'nearest'``: scipy regular grid interpolations\n", - " 183 extrapolate: bool, default False\n", - " 184 Extrapolate model using nearest-neighbors\n", - " 185 cutoff: float, default 10.0\n", - " 186 Extrapolation cutoff in kilometers\n", - " 187 \n", - " 188 Set to ``np.inf`` to extrapolate for all points\n", - " 189 scale: float, default 1.0\n", - " 190 Scaling factor for converting to output units\n", - " 191 \n", - " 192 Returns\n", - " 193 -------\n", - " 194 amplitude: np.ndarray\n", - " 195 amplitudes of tidal constituents\n", - " 196 phase: np.ndarray\n", - " 197 phases of tidal constituents\n", - " 198 \"\"\"\n", - " 199 # set default keyword arguments\n", - " 200 1 0.0 0.0 0.0 kwargs.setdefault('type', 'z')\n", - " 201 1 0.0 0.0 0.0 kwargs.setdefault('version', None)\n", - " 202 1 0.0 0.0 0.0 kwargs.setdefault('compressed', False)\n", - " 203 1 0.0 0.0 0.0 kwargs.setdefault('crop', False)\n", - " 204 1 0.0 0.0 0.0 kwargs.setdefault('method', 'spline')\n", - " 205 1 0.0 0.0 0.0 kwargs.setdefault('extrapolate', False)\n", - " 206 1 0.0 0.0 0.0 kwargs.setdefault('cutoff', 10.0)\n", - " 207 1 0.0 0.0 0.0 kwargs.setdefault('scale', 1.0)\n", - " 208 # raise warnings for deprecated keyword arguments\n", - " 209 2 0.0 0.0 0.0 deprecated_keywords = dict(TYPE='type',VERSION='version',\n", - " 210 1 0.0 0.0 0.0 METHOD='method',EXTRAPOLATE='extrapolate',CUTOFF='cutoff',\n", - " 211 1 0.0 0.0 0.0 GZIP='compressed',SCALE='scale')\n", - " 212 8 0.0 0.0 0.0 for old,new in deprecated_keywords.items():\n", - " 213 7 0.0 0.0 0.0 if old in kwargs.keys():\n", - " 214 warnings.warn(f\"\"\"Deprecated keyword argument {old}.\n", - " 215 Changed to '{new}'\"\"\", DeprecationWarning)\n", - " 216 # set renamed argument to not break workflows\n", - " 217 kwargs[new] = copy.copy(kwargs[old])\n", - " 218 \n", - " 219 # raise warning if model files are entered as a string or path\n", - " 220 1 0.0 0.0 0.0 if isinstance(model_files, (str, pathlib.Path)):\n", - " 221 warnings.warn(\"Tide model is entered as a string\")\n", - " 222 model_files = [model_files]\n", - " 223 \n", - " 224 # adjust dimensions of input coordinates to be iterable\n", - " 225 1 0.0 0.0 0.0 ilon = np.atleast_1d(np.copy(ilon))\n", - " 226 1 0.0 0.0 0.0 ilat = np.atleast_1d(np.copy(ilat))\n", - " 227 # set default bounds if cropping\n", - " 228 1 0.0 0.0 0.0 xmin, xmax = np.min(ilon), np.max(ilon)\n", - " 229 1 0.0 0.0 0.0 ymin, ymax = np.min(ilat), np.max(ilat)\n", - " 230 # kwargs.setdefault('bounds', [xmin, xmax, ymin, ymax])\n", - " 231 1 0.0 0.0 0.0 kwargs[\"bounds\"] = [xmin, xmax, ymin, ymax] if kwargs[\"bounds\"] is None else kwargs[\"bounds\"]\n", - " 232 1 0.0 0.0 0.0 if kwargs[\"crop\"]:\n", - " 233 print(f\"Cropping to bounds: {kwargs['bounds']}, {kwargs['method']} interpolation\")\n", - " 234 # number of points\n", - " 235 1 0.0 0.0 0.0 npts = len(ilon)\n", - " 236 # number of constituents\n", - " 237 1 0.0 0.0 0.0 nc = len(model_files)\n", - " 238 \n", - " 239 # amplitude and phase\n", - " 240 1 0.0 0.0 0.0 amplitude = np.ma.zeros((npts,nc))\n", - " 241 1 0.0 0.0 0.0 amplitude.mask = np.zeros((npts,nc),dtype=bool)\n", - " 242 1 0.0 0.0 0.0 ph = np.ma.zeros((npts,nc))\n", - " 243 1 0.0 0.0 0.0 ph.mask = np.zeros((npts,nc),dtype=bool)\n", - " 244 # read and interpolate each constituent\n", - " 245 35 0.0 0.0 0.0 for i, model_file in enumerate(model_files):\n", - " 246 # check that model file is accessible\n", - " 247 34 0.0 0.0 0.0 model_file = pathlib.Path(model_file).expanduser()\n", - " 248 34 0.2 0.0 0.0 if not model_file.exists():\n", - " 249 raise FileNotFoundError(str(model_file))\n", - " 250 # read constituent from elevation file\n", - " 251 34 0.0 0.0 0.0 if kwargs['version'] in _ascii_versions:\n", - " 252 # FES ascii constituent files\n", - " 253 hc, lon, lat = read_ascii_file(model_file, **kwargs)\n", - " 254 34 0.0 0.0 0.0 elif kwargs['version'] in _netcdf_versions:\n", - " 255 # FES netCDF4 constituent files\n", - " 256 34 306.7 9.0 45.8 hc, lon, lat = read_netcdf_file(model_file, **kwargs)\n", - " 257 # grid step size of tide model\n", - " 258 34 0.0 0.0 0.0 dlon = lon[1] - lon[0]\n", - " 259 # crop tide model data to (buffered) bounds\n", - " 260 # or adjust longitudinal convention to fit tide model\n", - " 261 34 0.0 0.0 0.0 if kwargs['crop'] and np.any(kwargs['bounds']):\n", - " 262 hc, lon, lat = _crop(hc, lon, lat,\n", - " 263 bounds=kwargs['bounds'],\n", - " 264 buffer=4*dlon\n", - " 265 )\n", - " 266 34 0.0 0.0 0.0 elif (np.min(ilon) < 0.0) & (np.max(lon) > 180.0):\n", - " 267 # input points convention (-180:180)\n", - " 268 # tide model convention (0:360)\n", - " 269 ilon[ilon<0.0] += 360.0\n", - " 270 34 0.0 0.0 0.0 elif (np.max(ilon) > 180.0) & (np.min(lon) < 0.0):\n", - " 271 # input points convention (0:360)\n", - " 272 # tide model convention (-180:180)\n", - " 273 ilon[ilon>180.0] -= 360.0\n", - " 274 \n", - " 275 # replace original values with extend arrays/matrices\n", - " 276 34 0.0 0.0 0.0 if np.isclose(lon[-1] - lon[0], 360.0 - dlon):\n", - " 277 lon = _extend_array(lon, dlon)\n", - " 278 hc = _extend_matrix(hc)\n", - " 279 # determine if any input points are outside of the model bounds\n", - " 280 102 0.0 0.0 0.0 invalid = (ilon < lon.min()) | (ilon > lon.max()) | \\\n", - " 281 68 0.0 0.0 0.0 (ilat < lat.min()) | (ilat > lat.max())\n", - " 282 \n", - " 283 # interpolate amplitude and phase of the constituent\n", - " 284 34 0.0 0.0 0.0 if (kwargs['method'] == 'bilinear'):\n", - " 285 # replace invalid values with nan\n", - " 286 hc.data[hc.mask] = np.nan\n", - " 287 # use quick bilinear to interpolate values\n", - " 288 hci = pyTMD.interpolate.bilinear(lon, lat, hc, ilon, ilat,\n", - " 289 dtype=hc.dtype)\n", - " 290 # replace nan values with fill_value\n", - " 291 hci.mask[:] |= np.isnan(hci.data)\n", - " 292 hci.data[hci.mask] = hci.fill_value\n", - " 293 34 0.0 0.0 0.0 elif (kwargs['method'] == 'spline'):\n", - " 294 # interpolate complex form of the constituent\n", - " 295 # use scipy splines to interpolate values\n", - " 296 68 363.3 5.3 54.2 hci = pyTMD.interpolate.spline(lon, lat, hc, ilon, ilat,\n", - " 297 34 0.0 0.0 0.0 dtype=hc.dtype,\n", - " 298 34 0.0 0.0 0.0 reducer=np.ceil,\n", - " 299 34 0.0 0.0 0.0 kx=1, ky=1)\n", - " 300 # replace invalid values with fill_value\n", - " 301 34 0.0 0.0 0.0 hci.data[hci.mask] = hci.fill_value\n", - " 302 else:\n", - " 303 # interpolate complex form of the constituent\n", - " 304 # use scipy regular grid to interpolate values\n", - " 305 hci = pyTMD.interpolate.regulargrid(lon, lat, hc, ilon, ilat,\n", - " 306 dtype=hc.dtype,\n", - " 307 method=kwargs['method'],\n", - " 308 reducer=np.ceil,\n", - " 309 bounds_error=False)\n", - " 310 # replace invalid values with fill_value\n", - " 311 hci.mask[:] |= (hci.data == hci.fill_value)\n", - " 312 hci.data[hci.mask] = hci.fill_value\n", - " 313 # extrapolate data using nearest-neighbors\n", - " 314 34 0.0 0.0 0.0 if kwargs['extrapolate'] and np.any(hci.mask):\n", - " 315 # find invalid data points\n", - " 316 inv, = np.nonzero(hci.mask)\n", - " 317 # replace invalid values with nan\n", - " 318 hc.data[hc.mask] = np.nan\n", - " 319 # extrapolate points within cutoff of valid model points\n", - " 320 hci[inv] = pyTMD.interpolate.extrapolate(lon, lat, hc,\n", - " 321 ilon[inv], ilat[inv], dtype=hc.dtype,\n", - " 322 cutoff=kwargs['cutoff'])\n", - " 323 # convert amplitude from input units to meters\n", - " 324 34 0.0 0.0 0.0 amplitude.data[:,i] = np.abs(hci.data)*kwargs['scale']\n", - " 325 34 0.0 0.0 0.0 amplitude.mask[:,i] = np.copy(hci.mask)\n", - " 326 # phase of the constituent in radians\n", - " 327 34 0.0 0.0 0.0 ph.data[:,i] = np.arctan2(-np.imag(hci.data),np.real(hci.data))\n", - " 328 34 0.0 0.0 0.0 ph.mask[:,i] = np.copy(hci.mask)\n", - " 329 # update mask to invalidate points outside model domain\n", - " 330 34 0.0 0.0 0.0 amplitude.mask[:,i] |= invalid\n", - " 331 34 0.0 0.0 0.0 ph.mask[:,i] |= invalid\n", - " 332 \n", - " 333 # convert phase to degrees\n", - " 334 1 0.0 0.0 0.0 phase = ph*180.0/np.pi\n", - " 335 1 0.0 0.0 0.0 phase.data[phase.data < 0] += 360.0\n", - " 336 # replace data for invalid mask values\n", - " 337 1 0.0 0.0 0.0 amplitude.data[amplitude.mask] = amplitude.fill_value\n", - " 338 1 0.0 0.0 0.0 phase.data[phase.mask] = phase.fill_value\n", - " 339 # return the interpolated values\n", - " 340 1 0.0 0.0 0.0 return (amplitude, phase)" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "%load_ext line_profiler\n", "\n", @@ -981,241 +939,9 @@ }, { "cell_type": "code", - "execution_count": 117, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "The line_profiler extension is already loaded. To reload it, use:\n", - " %reload_ext line_profiler\n" - ] - }, - { - "data": { - "text/plain": [ - "Timer unit: 1 s\n", - "\n", - "Total time: 269.384 s\n", - "File: /home/jovyan/Robbi/pyTMD/pyTMD/io/FES.py\n", - "Function: extract_constants at line 134\n", - "\n", - "Line # Hits Time Per Hit % Time Line Contents\n", - "==============================================================\n", - " 134 def extract_constants(\n", - " 135 ilon: np.ndarray,\n", - " 136 ilat: np.ndarray,\n", - " 137 model_files: str | list | pathlib.Path | None = None,\n", - " 138 **kwargs\n", - " 139 ):\n", - " 140 \"\"\"\n", - " 141 Reads files for a FES ascii or netCDF4 tidal model\n", - " 142 \n", - " 143 Makes initial calculations to run the tide program\n", - " 144 \n", - " 145 Spatially interpolates tidal constituents to input coordinates\n", - " 146 \n", - " 147 Parameters\n", - " 148 ----------\n", - " 149 ilon: np.ndarray\n", - " 150 longitude to interpolate\n", - " 151 ilat: np.ndarray\n", - " 152 latitude to interpolate\n", - " 153 model_files: str, list, pathlib.Path or NoneType, default None\n", - " 154 list of model files for each constituent\n", - " 155 type: str, default 'z'\n", - " 156 Tidal variable to read\n", - " 157 \n", - " 158 - ``'z'``: heights\n", - " 159 - ``'u'``: horizontal transport velocities\n", - " 160 - ``'v'``: vertical transport velocities\n", - " 161 version: str or NoneType, default None\n", - " 162 Model version to read\n", - " 163 \n", - " 164 - ``'FES1999'``\n", - " 165 - ``'FES2004'``\n", - " 166 - ``'FES2012'``\n", - " 167 - ``'FES2014'``\n", - " 168 - ``'FES2022'``\n", - " 169 - ``'EOT20'``\n", - " 170 - ``'HAMTIDE11'``\n", - " 171 compressed: bool, default False\n", - " 172 Input files are gzip compressed\n", - " 173 crop: bool, default False\n", - " 174 Crop tide model data to (buffered) bounds\n", - " 175 bounds: list or NoneType, default None\n", - " 176 Boundaries for cropping tide model data\n", - " 177 method: str, default 'spline'\n", - " 178 Interpolation method\n", - " 179 \n", - " 180 - ``'bilinear'``: quick bilinear interpolation\n", - " 181 - ``'spline'``: scipy bivariate spline interpolation\n", - " 182 - ``'linear'``, ``'nearest'``: scipy regular grid interpolations\n", - " 183 extrapolate: bool, default False\n", - " 184 Extrapolate model using nearest-neighbors\n", - " 185 cutoff: float, default 10.0\n", - " 186 Extrapolation cutoff in kilometers\n", - " 187 \n", - " 188 Set to ``np.inf`` to extrapolate for all points\n", - " 189 scale: float, default 1.0\n", - " 190 Scaling factor for converting to output units\n", - " 191 \n", - " 192 Returns\n", - " 193 -------\n", - " 194 amplitude: np.ndarray\n", - " 195 amplitudes of tidal constituents\n", - " 196 phase: np.ndarray\n", - " 197 phases of tidal constituents\n", - " 198 \"\"\"\n", - " 199 # set default keyword arguments\n", - " 200 1 0.0 0.0 0.0 kwargs.setdefault('type', 'z')\n", - " 201 1 0.0 0.0 0.0 kwargs.setdefault('version', None)\n", - " 202 1 0.0 0.0 0.0 kwargs.setdefault('compressed', False)\n", - " 203 1 0.0 0.0 0.0 kwargs.setdefault('crop', False)\n", - " 204 1 0.0 0.0 0.0 kwargs.setdefault('method', 'spline')\n", - " 205 1 0.0 0.0 0.0 kwargs.setdefault('extrapolate', False)\n", - " 206 1 0.0 0.0 0.0 kwargs.setdefault('cutoff', 10.0)\n", - " 207 1 0.0 0.0 0.0 kwargs.setdefault('scale', 1.0)\n", - " 208 # raise warnings for deprecated keyword arguments\n", - " 209 2 0.0 0.0 0.0 deprecated_keywords = dict(TYPE='type',VERSION='version',\n", - " 210 1 0.0 0.0 0.0 METHOD='method',EXTRAPOLATE='extrapolate',CUTOFF='cutoff',\n", - " 211 1 0.0 0.0 0.0 GZIP='compressed',SCALE='scale')\n", - " 212 8 0.0 0.0 0.0 for old,new in deprecated_keywords.items():\n", - " 213 7 0.0 0.0 0.0 if old in kwargs.keys():\n", - " 214 warnings.warn(f\"\"\"Deprecated keyword argument {old}.\n", - " 215 Changed to '{new}'\"\"\", DeprecationWarning)\n", - " 216 # set renamed argument to not break workflows\n", - " 217 kwargs[new] = copy.copy(kwargs[old])\n", - " 218 \n", - " 219 # raise warning if model files are entered as a string or path\n", - " 220 1 0.0 0.0 0.0 if isinstance(model_files, (str, pathlib.Path)):\n", - " 221 warnings.warn(\"Tide model is entered as a string\")\n", - " 222 model_files = [model_files]\n", - " 223 \n", - " 224 # adjust dimensions of input coordinates to be iterable\n", - " 225 1 0.0 0.0 0.0 ilon = np.atleast_1d(np.copy(ilon))\n", - " 226 1 0.0 0.0 0.0 ilat = np.atleast_1d(np.copy(ilat))\n", - " 227 # set default bounds if cropping\n", - " 228 1 0.0 0.0 0.0 xmin, xmax = np.min(ilon), np.max(ilon)\n", - " 229 1 0.0 0.0 0.0 ymin, ymax = np.min(ilat), np.max(ilat)\n", - " 230 # kwargs.setdefault('bounds', [xmin, xmax, ymin, ymax])\n", - " 231 1 0.0 0.0 0.0 kwargs[\"bounds\"] = [xmin, xmax, ymin, ymax] if kwargs[\"bounds\"] is None else kwargs[\"bounds\"]\n", - " 232 1 0.0 0.0 0.0 if kwargs[\"crop\"]:\n", - " 233 print(f\"Cropping to bounds: {kwargs['bounds']}, {kwargs['method']} interpolation\")\n", - " 234 # number of points\n", - " 235 1 0.0 0.0 0.0 npts = len(ilon)\n", - " 236 # number of constituents\n", - " 237 1 0.0 0.0 0.0 nc = len(model_files)\n", - " 238 \n", - " 239 # amplitude and phase\n", - " 240 1 0.0 0.0 0.0 amplitude = np.ma.zeros((npts,nc))\n", - " 241 1 0.0 0.0 0.0 amplitude.mask = np.zeros((npts,nc),dtype=bool)\n", - " 242 1 0.0 0.0 0.0 ph = np.ma.zeros((npts,nc))\n", - " 243 1 0.0 0.0 0.0 ph.mask = np.zeros((npts,nc),dtype=bool)\n", - " 244 # read and interpolate each constituent\n", - " 245 35 0.0 0.0 0.0 for i, model_file in enumerate(model_files):\n", - " 246 # check that model file is accessible\n", - " 247 34 0.0 0.0 0.0 model_file = pathlib.Path(model_file).expanduser()\n", - " 248 34 0.1 0.0 0.0 if not model_file.exists():\n", - " 249 raise FileNotFoundError(str(model_file))\n", - " 250 # read constituent from elevation file\n", - " 251 34 0.0 0.0 0.0 if kwargs['version'] in _ascii_versions:\n", - " 252 # FES ascii constituent files\n", - " 253 hc, lon, lat = read_ascii_file(model_file, **kwargs)\n", - " 254 34 0.0 0.0 0.0 elif kwargs['version'] in _netcdf_versions:\n", - " 255 # FES netCDF4 constituent files\n", - " 256 34 265.6 7.8 98.6 hc, lon, lat = read_netcdf_file(model_file, **kwargs)\n", - " 257 # grid step size of tide model\n", - " 258 34 0.0 0.0 0.0 dlon = lon[1] - lon[0]\n", - " 259 # crop tide model data to (buffered) bounds\n", - " 260 # or adjust longitudinal convention to fit tide model\n", - " 261 34 0.0 0.0 0.0 if kwargs['crop'] and np.any(kwargs['bounds']):\n", - " 262 hc, lon, lat = _crop(hc, lon, lat,\n", - " 263 bounds=kwargs['bounds'],\n", - " 264 buffer=4*dlon\n", - " 265 )\n", - " 266 34 0.0 0.0 0.0 elif (np.min(ilon) < 0.0) & (np.max(lon) > 180.0):\n", - " 267 # input points convention (-180:180)\n", - " 268 # tide model convention (0:360)\n", - " 269 ilon[ilon<0.0] += 360.0\n", - " 270 34 0.0 0.0 0.0 elif (np.max(ilon) > 180.0) & (np.min(lon) < 0.0):\n", - " 271 # input points convention (0:360)\n", - " 272 # tide model convention (-180:180)\n", - " 273 ilon[ilon>180.0] -= 360.0\n", - " 274 \n", - " 275 # replace original values with extend arrays/matrices\n", - " 276 34 0.0 0.0 0.0 if np.isclose(lon[-1] - lon[0], 360.0 - dlon):\n", - " 277 lon = _extend_array(lon, dlon)\n", - " 278 hc = _extend_matrix(hc)\n", - " 279 # determine if any input points are outside of the model bounds\n", - " 280 102 0.0 0.0 0.0 invalid = (ilon < lon.min()) | (ilon > lon.max()) | \\\n", - " 281 68 0.0 0.0 0.0 (ilat < lat.min()) | (ilat > lat.max())\n", - " 282 \n", - " 283 # interpolate amplitude and phase of the constituent\n", - " 284 34 0.0 0.0 0.0 if (kwargs['method'] == 'bilinear'):\n", - " 285 # replace invalid values with nan\n", - " 286 hc.data[hc.mask] = np.nan\n", - " 287 # use quick bilinear to interpolate values\n", - " 288 hci = pyTMD.interpolate.bilinear(lon, lat, hc, ilon, ilat,\n", - " 289 dtype=hc.dtype)\n", - " 290 # replace nan values with fill_value\n", - " 291 hci.mask[:] |= np.isnan(hci.data)\n", - " 292 hci.data[hci.mask] = hci.fill_value\n", - " 293 34 0.0 0.0 0.0 elif (kwargs['method'] == 'spline'):\n", - " 294 # interpolate complex form of the constituent\n", - " 295 # use scipy splines to interpolate values\n", - " 296 hci = pyTMD.interpolate.spline(lon, lat, hc, ilon, ilat,\n", - " 297 dtype=hc.dtype,\n", - " 298 reducer=np.ceil,\n", - " 299 kx=1, ky=1)\n", - " 300 # replace invalid values with fill_value\n", - " 301 hci.data[hci.mask] = hci.fill_value\n", - " 302 else:\n", - " 303 # interpolate complex form of the constituent\n", - " 304 # use scipy regular grid to interpolate values\n", - " 305 68 3.7 0.1 1.4 hci = pyTMD.interpolate.regulargrid(lon, lat, hc, ilon, ilat,\n", - " 306 34 0.0 0.0 0.0 dtype=hc.dtype,\n", - " 307 34 0.0 0.0 0.0 method=kwargs['method'],\n", - " 308 34 0.0 0.0 0.0 reducer=np.ceil,\n", - " 309 34 0.0 0.0 0.0 bounds_error=False)\n", - " 310 # replace invalid values with fill_value\n", - " 311 34 0.0 0.0 0.0 hci.mask[:] |= (hci.data == hci.fill_value)\n", - " 312 34 0.0 0.0 0.0 hci.data[hci.mask] = hci.fill_value\n", - " 313 # extrapolate data using nearest-neighbors\n", - " 314 34 0.0 0.0 0.0 if kwargs['extrapolate'] and np.any(hci.mask):\n", - " 315 # find invalid data points\n", - " 316 inv, = np.nonzero(hci.mask)\n", - " 317 # replace invalid values with nan\n", - " 318 hc.data[hc.mask] = np.nan\n", - " 319 # extrapolate points within cutoff of valid model points\n", - " 320 hci[inv] = pyTMD.interpolate.extrapolate(lon, lat, hc,\n", - " 321 ilon[inv], ilat[inv], dtype=hc.dtype,\n", - " 322 cutoff=kwargs['cutoff'])\n", - " 323 # convert amplitude from input units to meters\n", - " 324 34 0.0 0.0 0.0 amplitude.data[:,i] = np.abs(hci.data)*kwargs['scale']\n", - " 325 34 0.0 0.0 0.0 amplitude.mask[:,i] = np.copy(hci.mask)\n", - " 326 # phase of the constituent in radians\n", - " 327 34 0.0 0.0 0.0 ph.data[:,i] = np.arctan2(-np.imag(hci.data),np.real(hci.data))\n", - " 328 34 0.0 0.0 0.0 ph.mask[:,i] = np.copy(hci.mask)\n", - " 329 # update mask to invalidate points outside model domain\n", - " 330 34 0.0 0.0 0.0 amplitude.mask[:,i] |= invalid\n", - " 331 34 0.0 0.0 0.0 ph.mask[:,i] |= invalid\n", - " 332 \n", - " 333 # convert phase to degrees\n", - " 334 1 0.0 0.0 0.0 phase = ph*180.0/np.pi\n", - " 335 1 0.0 0.0 0.0 phase.data[phase.data < 0] += 360.0\n", - " 336 # replace data for invalid mask values\n", - " 337 1 0.0 0.0 0.0 amplitude.data[amplitude.mask] = amplitude.fill_value\n", - " 338 1 0.0 0.0 0.0 phase.data[phase.mask] = phase.fill_value\n", - " 339 # return the interpolated values\n", - " 340 1 0.0 0.0 0.0 return (amplitude, phase)" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "%load_ext line_profiler\n", "\n", @@ -1458,20 +1184,9 @@ }, { "cell_type": "code", - "execution_count": 126, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Modelling tides using FES2014\n", - "Modelling tides using FES2014\n", - "Spline method time: 456.673351 seconds\n", - "Linear method time: 332.520261 seconds\n" - ] - } - ], + "outputs": [], "source": [ "import time\n", "\n", @@ -1522,19 +1237,9 @@ }, { "cell_type": "code", - "execution_count": 128, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Modelling tides using FES2014\n", - "Cropping to bounds: [112.71844319378742, 154.71220797815425, -44.17936876485997, -10.053536747347778], linear interpolation\n", - "Linear method time: 73.067080 seconds\n" - ] - } - ], + "outputs": [], "source": [ "import time\n", "\n", @@ -1585,5088 +1290,9 @@ }, { "cell_type": "code", - "execution_count": 50, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Modelling tides using EOT20, GOT5.5 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 2/2 [00:02<00:00, 1.46s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 1, 'parallel_max': 2, 'time': 3.243055582046509, 'points': 100, 'points_per_split': 100, 'split_per_parallel': 0.5, 'directory': '/gdata1/data/tide_models_clipped/', 'model': ['EOT20', 'GOT5.5']}\n", - "Modelling tides using EOT20, GOT5.5 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 4/4 [00:03<00:00, 1.02it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 2, 'parallel_max': 2, 'time': 4.2193474769592285, 'points': 100, 'points_per_split': 50, 'split_per_parallel': 1.0, 'directory': '/gdata1/data/tide_models_clipped/', 'model': ['EOT20', 'GOT5.5']}\n", - "Modelling tides using EOT20, GOT5.5 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 6/6 [00:05<00:00, 1.01it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 3, 'parallel_max': 2, 'time': 6.260916709899902, 'points': 100, 'points_per_split': 33, 'split_per_parallel': 1.5, 'directory': '/gdata1/data/tide_models_clipped/', 'model': ['EOT20', 'GOT5.5']}\n", - "Modelling tides using EOT20, GOT5.5 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 8/8 [00:07<00:00, 1.06it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 4, 'parallel_max': 2, 'time': 7.84906792640686, 'points': 100, 'points_per_split': 25, 'split_per_parallel': 2.0, 'directory': '/gdata1/data/tide_models_clipped/', 'model': ['EOT20', 'GOT5.5']}\n", - "Modelling tides using EOT20, GOT5.5 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 10/10 [00:09<00:00, 1.09it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 5, 'parallel_max': 2, 'time': 9.473124742507935, 'points': 100, 'points_per_split': 20, 'split_per_parallel': 2.5, 'directory': '/gdata1/data/tide_models_clipped/', 'model': ['EOT20', 'GOT5.5']}\n", - "Modelling tides using EOT20, GOT5.5 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 12/12 [00:10<00:00, 1.12it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 6, 'parallel_max': 2, 'time': 10.993525981903076, 'points': 100, 'points_per_split': 16, 'split_per_parallel': 3.0, 'directory': '/gdata1/data/tide_models_clipped/', 'model': ['EOT20', 'GOT5.5']}\n", - "Modelling tides using EOT20, GOT5.5 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 16/16 [00:14<00:00, 1.13it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 8, 'parallel_max': 2, 'time': 14.431707620620728, 'points': 100, 'points_per_split': 12, 'split_per_parallel': 4.0, 'directory': '/gdata1/data/tide_models_clipped/', 'model': ['EOT20', 'GOT5.5']}\n", - "Modelling tides using EOT20, GOT5.5 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 20/20 [00:17<00:00, 1.18it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 10, 'parallel_max': 2, 'time': 17.341492891311646, 'points': 100, 'points_per_split': 10, 'split_per_parallel': 5.0, 'directory': '/gdata1/data/tide_models_clipped/', 'model': ['EOT20', 'GOT5.5']}\n", - "Modelling tides using EOT20, GOT5.5 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 24/24 [00:20<00:00, 1.19it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 12, 'parallel_max': 2, 'time': 20.59138798713684, 'points': 100, 'points_per_split': 8, 'split_per_parallel': 6.0, 'directory': '/gdata1/data/tide_models_clipped/', 'model': ['EOT20', 'GOT5.5']}\n", - "Modelling tides using EOT20, GOT5.5 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 32/32 [00:26<00:00, 1.21it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 16, 'parallel_max': 2, 'time': 26.767624378204346, 'points': 100, 'points_per_split': 6, 'split_per_parallel': 8.0, 'directory': '/gdata1/data/tide_models_clipped/', 'model': ['EOT20', 'GOT5.5']}\n", - "Modelling tides using EOT20, GOT5.5 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 40/40 [00:32<00:00, 1.23it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 20, 'parallel_max': 2, 'time': 32.733094453811646, 'points': 100, 'points_per_split': 5, 'split_per_parallel': 10.0, 'directory': '/gdata1/data/tide_models_clipped/', 'model': ['EOT20', 'GOT5.5']}\n", - "Modelling tides using EOT20, GOT5.5 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 2/2 [00:03<00:00, 1.50s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 1, 'parallel_max': 4, 'time': 3.549738883972168, 'points': 100, 'points_per_split': 100, 'split_per_parallel': 0.25, 'directory': '/gdata1/data/tide_models_clipped/', 'model': ['EOT20', 'GOT5.5']}\n", - "Modelling tides using EOT20, GOT5.5 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 4/4 [00:02<00:00, 1.38it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 2, 'parallel_max': 4, 'time': 3.3015990257263184, 'points': 100, 'points_per_split': 50, 'split_per_parallel': 0.5, 'directory': '/gdata1/data/tide_models_clipped/', 'model': ['EOT20', 'GOT5.5']}\n", - "Modelling tides using EOT20, GOT5.5 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 6/6 [00:03<00:00, 1.83it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 3, 'parallel_max': 4, 'time': 3.663120746612549, 'points': 100, 'points_per_split': 33, 'split_per_parallel': 0.75, 'directory': '/gdata1/data/tide_models_clipped/', 'model': ['EOT20', 'GOT5.5']}\n", - "Modelling tides using EOT20, GOT5.5 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 8/8 [00:04<00:00, 1.74it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 4, 'parallel_max': 4, 'time': 4.980994939804077, 'points': 100, 'points_per_split': 25, 'split_per_parallel': 1.0, 'directory': '/gdata1/data/tide_models_clipped/', 'model': ['EOT20', 'GOT5.5']}\n", - "Modelling tides using EOT20, GOT5.5 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 10/10 [00:05<00:00, 1.84it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 5, 'parallel_max': 4, 'time': 5.800908088684082, 'points': 100, 'points_per_split': 20, 'split_per_parallel': 1.25, 'directory': '/gdata1/data/tide_models_clipped/', 'model': ['EOT20', 'GOT5.5']}\n", - "Modelling tides using EOT20, GOT5.5 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 12/12 [00:06<00:00, 1.91it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 6, 'parallel_max': 4, 'time': 6.713530778884888, 'points': 100, 'points_per_split': 16, 'split_per_parallel': 1.5, 'directory': '/gdata1/data/tide_models_clipped/', 'model': ['EOT20', 'GOT5.5']}\n", - "Modelling tides using EOT20, GOT5.5 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 16/16 [00:07<00:00, 2.03it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 8, 'parallel_max': 4, 'time': 8.271213054656982, 'points': 100, 'points_per_split': 12, 'split_per_parallel': 2.0, 'directory': '/gdata1/data/tide_models_clipped/', 'model': ['EOT20', 'GOT5.5']}\n", - "Modelling tides using EOT20, GOT5.5 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 20/20 [00:09<00:00, 2.08it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 10, 'parallel_max': 4, 'time': 9.997656106948853, 'points': 100, 'points_per_split': 10, 'split_per_parallel': 2.5, 'directory': '/gdata1/data/tide_models_clipped/', 'model': ['EOT20', 'GOT5.5']}\n", - "Modelling tides using EOT20, GOT5.5 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 24/24 [00:11<00:00, 2.11it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 12, 'parallel_max': 4, 'time': 11.794151782989502, 'points': 100, 'points_per_split': 8, 'split_per_parallel': 3.0, 'directory': '/gdata1/data/tide_models_clipped/', 'model': ['EOT20', 'GOT5.5']}\n", - "Modelling tides using EOT20, GOT5.5 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 32/32 [00:14<00:00, 2.26it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 16, 'parallel_max': 4, 'time': 14.622455596923828, 'points': 100, 'points_per_split': 6, 'split_per_parallel': 4.0, 'directory': '/gdata1/data/tide_models_clipped/', 'model': ['EOT20', 'GOT5.5']}\n", - "Modelling tides using EOT20, GOT5.5 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 40/40 [00:17<00:00, 2.30it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 20, 'parallel_max': 4, 'time': 17.984022617340088, 'points': 100, 'points_per_split': 5, 'split_per_parallel': 5.0, 'directory': '/gdata1/data/tide_models_clipped/', 'model': ['EOT20', 'GOT5.5']}\n", - "Modelling tides using EOT20, GOT5.5 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 2/2 [00:02<00:00, 1.49s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 1, 'parallel_max': 8, 'time': 3.5839710235595703, 'points': 100, 'points_per_split': 100, 'split_per_parallel': 0.125, 'directory': '/gdata1/data/tide_models_clipped/', 'model': ['EOT20', 'GOT5.5']}\n", - "Modelling tides using EOT20, GOT5.5 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 4/4 [00:02<00:00, 1.35it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 2, 'parallel_max': 8, 'time': 3.5672194957733154, 'points': 100, 'points_per_split': 50, 'split_per_parallel': 0.25, 'directory': '/gdata1/data/tide_models_clipped/', 'model': ['EOT20', 'GOT5.5']}\n", - "Modelling tides using EOT20, GOT5.5 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 6/6 [00:03<00:00, 1.86it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 3, 'parallel_max': 8, 'time': 3.840934991836548, 'points': 100, 'points_per_split': 33, 'split_per_parallel': 0.375, 'directory': '/gdata1/data/tide_models_clipped/', 'model': ['EOT20', 'GOT5.5']}\n", - "Modelling tides using EOT20, GOT5.5 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 8/8 [00:03<00:00, 2.31it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 4, 'parallel_max': 8, 'time': 4.094923257827759, 'points': 100, 'points_per_split': 25, 'split_per_parallel': 0.5, 'directory': '/gdata1/data/tide_models_clipped/', 'model': ['EOT20', 'GOT5.5']}\n", - "Modelling tides using EOT20, GOT5.5 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 10/10 [00:03<00:00, 2.95it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 5, 'parallel_max': 8, 'time': 4.031742811203003, 'points': 100, 'points_per_split': 20, 'split_per_parallel': 0.625, 'directory': '/gdata1/data/tide_models_clipped/', 'model': ['EOT20', 'GOT5.5']}\n", - "Modelling tides using EOT20, GOT5.5 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 12/12 [00:03<00:00, 3.26it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 6, 'parallel_max': 8, 'time': 4.320927381515503, 'points': 100, 'points_per_split': 16, 'split_per_parallel': 0.75, 'directory': '/gdata1/data/tide_models_clipped/', 'model': ['EOT20', 'GOT5.5']}\n", - "Modelling tides using EOT20, GOT5.5 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 16/16 [00:05<00:00, 3.12it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 8, 'parallel_max': 8, 'time': 5.7838099002838135, 'points': 100, 'points_per_split': 12, 'split_per_parallel': 1.0, 'directory': '/gdata1/data/tide_models_clipped/', 'model': ['EOT20', 'GOT5.5']}\n", - "Modelling tides using EOT20, GOT5.5 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 20/20 [00:06<00:00, 3.31it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 10, 'parallel_max': 8, 'time': 6.58468770980835, 'points': 100, 'points_per_split': 10, 'split_per_parallel': 1.25, 'directory': '/gdata1/data/tide_models_clipped/', 'model': ['EOT20', 'GOT5.5']}\n", - "Modelling tides using EOT20, GOT5.5 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 24/24 [00:07<00:00, 3.34it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 12, 'parallel_max': 8, 'time': 7.838033676147461, 'points': 100, 'points_per_split': 8, 'split_per_parallel': 1.5, 'directory': '/gdata1/data/tide_models_clipped/', 'model': ['EOT20', 'GOT5.5']}\n", - "Modelling tides using EOT20, GOT5.5 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 32/32 [00:08<00:00, 3.56it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 16, 'parallel_max': 8, 'time': 9.692872762680054, 'points': 100, 'points_per_split': 6, 'split_per_parallel': 2.0, 'directory': '/gdata1/data/tide_models_clipped/', 'model': ['EOT20', 'GOT5.5']}\n", - "Modelling tides using EOT20, GOT5.5 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 40/40 [00:11<00:00, 3.47it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 20, 'parallel_max': 8, 'time': 12.213189601898193, 'points': 100, 'points_per_split': 5, 'split_per_parallel': 2.5, 'directory': '/gdata1/data/tide_models_clipped/', 'model': ['EOT20', 'GOT5.5']}\n", - "Modelling tides using EOT20, GOT5.5 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 2/2 [00:03<00:00, 1.52s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 1, 'parallel_max': 16, 'time': 3.9789793491363525, 'points': 100, 'points_per_split': 100, 'split_per_parallel': 0.0625, 'directory': '/gdata1/data/tide_models_clipped/', 'model': ['EOT20', 'GOT5.5']}\n", - "Modelling tides using EOT20, GOT5.5 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 4/4 [00:03<00:00, 1.30it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 2, 'parallel_max': 16, 'time': 4.004520654678345, 'points': 100, 'points_per_split': 50, 'split_per_parallel': 0.125, 'directory': '/gdata1/data/tide_models_clipped/', 'model': ['EOT20', 'GOT5.5']}\n", - "Modelling tides using EOT20, GOT5.5 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 6/6 [00:03<00:00, 1.94it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 3, 'parallel_max': 16, 'time': 4.018305540084839, 'points': 100, 'points_per_split': 33, 'split_per_parallel': 0.1875, 'directory': '/gdata1/data/tide_models_clipped/', 'model': ['EOT20', 'GOT5.5']}\n", - "Modelling tides using EOT20, GOT5.5 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 8/8 [00:03<00:00, 2.34it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 4, 'parallel_max': 16, 'time': 4.409335613250732, 'points': 100, 'points_per_split': 25, 'split_per_parallel': 0.25, 'directory': '/gdata1/data/tide_models_clipped/', 'model': ['EOT20', 'GOT5.5']}\n", - "Modelling tides using EOT20, GOT5.5 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 10/10 [00:03<00:00, 2.73it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 5, 'parallel_max': 16, 'time': 4.634673595428467, 'points': 100, 'points_per_split': 20, 'split_per_parallel': 0.3125, 'directory': '/gdata1/data/tide_models_clipped/', 'model': ['EOT20', 'GOT5.5']}\n", - "Modelling tides using EOT20, GOT5.5 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 12/12 [00:03<00:00, 3.29it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 6, 'parallel_max': 16, 'time': 4.6058759689331055, 'points': 100, 'points_per_split': 16, 'split_per_parallel': 0.375, 'directory': '/gdata1/data/tide_models_clipped/', 'model': ['EOT20', 'GOT5.5']}\n", - "Modelling tides using EOT20, GOT5.5 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 16/16 [00:04<00:00, 3.45it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 8, 'parallel_max': 16, 'time': 5.617724895477295, 'points': 100, 'points_per_split': 12, 'split_per_parallel': 0.5, 'directory': '/gdata1/data/tide_models_clipped/', 'model': ['EOT20', 'GOT5.5']}\n", - "Modelling tides using EOT20, GOT5.5 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 20/20 [00:04<00:00, 4.11it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 10, 'parallel_max': 16, 'time': 5.889828681945801, 'points': 100, 'points_per_split': 10, 'split_per_parallel': 0.625, 'directory': '/gdata1/data/tide_models_clipped/', 'model': ['EOT20', 'GOT5.5']}\n", - "Modelling tides using EOT20, GOT5.5 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 24/24 [00:04<00:00, 5.55it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 12, 'parallel_max': 16, 'time': 5.353975772857666, 'points': 100, 'points_per_split': 8, 'split_per_parallel': 0.75, 'directory': '/gdata1/data/tide_models_clipped/', 'model': ['EOT20', 'GOT5.5']}\n", - "Modelling tides using EOT20, GOT5.5 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 32/32 [00:06<00:00, 4.85it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 16, 'parallel_max': 16, 'time': 7.742544412612915, 'points': 100, 'points_per_split': 6, 'split_per_parallel': 1.0, 'directory': '/gdata1/data/tide_models_clipped/', 'model': ['EOT20', 'GOT5.5']}\n", - "Modelling tides using EOT20, GOT5.5 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 40/40 [00:07<00:00, 5.10it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 20, 'parallel_max': 16, 'time': 8.698545694351196, 'points': 100, 'points_per_split': 5, 'split_per_parallel': 1.25, 'directory': '/gdata1/data/tide_models_clipped/', 'model': ['EOT20', 'GOT5.5']}\n", - "Modelling tides using EOT20, GOT5.5 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 2/2 [00:04<00:00, 2.39s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 1, 'parallel_max': 2, 'time': 5.165438652038574, 'points': 1000, 'points_per_split': 1000, 'split_per_parallel': 0.5, 'directory': '/gdata1/data/tide_models_clipped/', 'model': ['EOT20', 'GOT5.5']}\n", - "Modelling tides using EOT20, GOT5.5 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 4/4 [00:05<00:00, 1.50s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 2, 'parallel_max': 2, 'time': 6.393255233764648, 'points': 1000, 'points_per_split': 500, 'split_per_parallel': 1.0, 'directory': '/gdata1/data/tide_models_clipped/', 'model': ['EOT20', 'GOT5.5']}\n", - "Modelling tides using EOT20, GOT5.5 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 6/6 [00:08<00:00, 1.41s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 3, 'parallel_max': 2, 'time': 8.881940841674805, 'points': 1000, 'points_per_split': 333, 'split_per_parallel': 1.5, 'directory': '/gdata1/data/tide_models_clipped/', 'model': ['EOT20', 'GOT5.5']}\n", - "Modelling tides using EOT20, GOT5.5 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 8/8 [00:09<00:00, 1.20s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 4, 'parallel_max': 2, 'time': 9.976561784744263, 'points': 1000, 'points_per_split': 250, 'split_per_parallel': 2.0, 'directory': '/gdata1/data/tide_models_clipped/', 'model': ['EOT20', 'GOT5.5']}\n", - "Modelling tides using EOT20, GOT5.5 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 10/10 [00:11<00:00, 1.18s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 5, 'parallel_max': 2, 'time': 12.158897638320923, 'points': 1000, 'points_per_split': 200, 'split_per_parallel': 2.5, 'directory': '/gdata1/data/tide_models_clipped/', 'model': ['EOT20', 'GOT5.5']}\n", - "Modelling tides using EOT20, GOT5.5 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 12/12 [00:12<00:00, 1.08s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 6, 'parallel_max': 2, 'time': 13.381953477859497, 'points': 1000, 'points_per_split': 166, 'split_per_parallel': 3.0, 'directory': '/gdata1/data/tide_models_clipped/', 'model': ['EOT20', 'GOT5.5']}\n", - "Modelling tides using EOT20, GOT5.5 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 16/16 [00:16<00:00, 1.04s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 8, 'parallel_max': 2, 'time': 17.228297233581543, 'points': 1000, 'points_per_split': 125, 'split_per_parallel': 4.0, 'directory': '/gdata1/data/tide_models_clipped/', 'model': ['EOT20', 'GOT5.5']}\n", - "Modelling tides using EOT20, GOT5.5 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 20/20 [00:20<00:00, 1.01s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 10, 'parallel_max': 2, 'time': 20.583512783050537, 'points': 1000, 'points_per_split': 100, 'split_per_parallel': 5.0, 'directory': '/gdata1/data/tide_models_clipped/', 'model': ['EOT20', 'GOT5.5']}\n", - "Modelling tides using EOT20, GOT5.5 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 24/24 [00:24<00:00, 1.00s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 12, 'parallel_max': 2, 'time': 24.490197896957397, 'points': 1000, 'points_per_split': 83, 'split_per_parallel': 6.0, 'directory': '/gdata1/data/tide_models_clipped/', 'model': ['EOT20', 'GOT5.5']}\n", - "Modelling tides using EOT20, GOT5.5 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 32/32 [00:30<00:00, 1.04it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 16, 'parallel_max': 2, 'time': 31.263490915298462, 'points': 1000, 'points_per_split': 62, 'split_per_parallel': 8.0, 'directory': '/gdata1/data/tide_models_clipped/', 'model': ['EOT20', 'GOT5.5']}\n", - "Modelling tides using EOT20, GOT5.5 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 40/40 [00:37<00:00, 1.06it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 20, 'parallel_max': 2, 'time': 38.26747488975525, 'points': 1000, 'points_per_split': 50, 'split_per_parallel': 10.0, 'directory': '/gdata1/data/tide_models_clipped/', 'model': ['EOT20', 'GOT5.5']}\n", - "Modelling tides using EOT20, GOT5.5 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 2/2 [00:04<00:00, 2.36s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 1, 'parallel_max': 4, 'time': 5.357771873474121, 'points': 1000, 'points_per_split': 1000, 'split_per_parallel': 0.25, 'directory': '/gdata1/data/tide_models_clipped/', 'model': ['EOT20', 'GOT5.5']}\n", - "Modelling tides using EOT20, GOT5.5 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 4/4 [00:04<00:00, 1.03s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 2, 'parallel_max': 4, 'time': 4.622193813323975, 'points': 1000, 'points_per_split': 500, 'split_per_parallel': 0.5, 'directory': '/gdata1/data/tide_models_clipped/', 'model': ['EOT20', 'GOT5.5']}\n", - "Modelling tides using EOT20, GOT5.5 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 6/6 [00:05<00:00, 1.13it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 3, 'parallel_max': 4, 'time': 5.817925214767456, 'points': 1000, 'points_per_split': 333, 'split_per_parallel': 0.75, 'directory': '/gdata1/data/tide_models_clipped/', 'model': ['EOT20', 'GOT5.5']}\n", - "Modelling tides using EOT20, GOT5.5 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 8/8 [00:05<00:00, 1.44it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 4, 'parallel_max': 4, 'time': 6.040789842605591, 'points': 1000, 'points_per_split': 250, 'split_per_parallel': 1.0, 'directory': '/gdata1/data/tide_models_clipped/', 'model': ['EOT20', 'GOT5.5']}\n", - "Modelling tides using EOT20, GOT5.5 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 10/10 [00:06<00:00, 1.44it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 5, 'parallel_max': 4, 'time': 7.42947244644165, 'points': 1000, 'points_per_split': 200, 'split_per_parallel': 1.25, 'directory': '/gdata1/data/tide_models_clipped/', 'model': ['EOT20', 'GOT5.5']}\n", - "Modelling tides using EOT20, GOT5.5 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 12/12 [00:07<00:00, 1.55it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 6, 'parallel_max': 4, 'time': 8.228006601333618, 'points': 1000, 'points_per_split': 166, 'split_per_parallel': 1.5, 'directory': '/gdata1/data/tide_models_clipped/', 'model': ['EOT20', 'GOT5.5']}\n", - "Modelling tides using EOT20, GOT5.5 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 16/16 [00:09<00:00, 1.71it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 8, 'parallel_max': 4, 'time': 9.86604380607605, 'points': 1000, 'points_per_split': 125, 'split_per_parallel': 2.0, 'directory': '/gdata1/data/tide_models_clipped/', 'model': ['EOT20', 'GOT5.5']}\n", - "Modelling tides using EOT20, GOT5.5 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 20/20 [00:11<00:00, 1.69it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 10, 'parallel_max': 4, 'time': 12.331735134124756, 'points': 1000, 'points_per_split': 100, 'split_per_parallel': 2.5, 'directory': '/gdata1/data/tide_models_clipped/', 'model': ['EOT20', 'GOT5.5']}\n", - "Modelling tides using EOT20, GOT5.5 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 24/24 [00:13<00:00, 1.79it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 12, 'parallel_max': 4, 'time': 13.996634244918823, 'points': 1000, 'points_per_split': 83, 'split_per_parallel': 3.0, 'directory': '/gdata1/data/tide_models_clipped/', 'model': ['EOT20', 'GOT5.5']}\n", - "Modelling tides using EOT20, GOT5.5 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 32/32 [00:16<00:00, 1.94it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 16, 'parallel_max': 4, 'time': 17.055161952972412, 'points': 1000, 'points_per_split': 62, 'split_per_parallel': 4.0, 'directory': '/gdata1/data/tide_models_clipped/', 'model': ['EOT20', 'GOT5.5']}\n", - "Modelling tides using EOT20, GOT5.5 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 40/40 [00:20<00:00, 1.95it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 20, 'parallel_max': 4, 'time': 21.018187522888184, 'points': 1000, 'points_per_split': 50, 'split_per_parallel': 5.0, 'directory': '/gdata1/data/tide_models_clipped/', 'model': ['EOT20', 'GOT5.5']}\n", - "Modelling tides using EOT20, GOT5.5 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 2/2 [00:04<00:00, 2.41s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 1, 'parallel_max': 8, 'time': 5.499439001083374, 'points': 1000, 'points_per_split': 1000, 'split_per_parallel': 0.125, 'directory': '/gdata1/data/tide_models_clipped/', 'model': ['EOT20', 'GOT5.5']}\n", - "Modelling tides using EOT20, GOT5.5 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 4/4 [00:04<00:00, 1.09s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 2, 'parallel_max': 8, 'time': 4.996423244476318, 'points': 1000, 'points_per_split': 500, 'split_per_parallel': 0.25, 'directory': '/gdata1/data/tide_models_clipped/', 'model': ['EOT20', 'GOT5.5']}\n", - "Modelling tides using EOT20, GOT5.5 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 6/6 [00:04<00:00, 1.43it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 3, 'parallel_max': 8, 'time': 5.037170171737671, 'points': 1000, 'points_per_split': 333, 'split_per_parallel': 0.375, 'directory': '/gdata1/data/tide_models_clipped/', 'model': ['EOT20', 'GOT5.5']}\n", - "Modelling tides using EOT20, GOT5.5 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 8/8 [00:04<00:00, 1.80it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 4, 'parallel_max': 8, 'time': 5.146196603775024, 'points': 1000, 'points_per_split': 250, 'split_per_parallel': 0.5, 'directory': '/gdata1/data/tide_models_clipped/', 'model': ['EOT20', 'GOT5.5']}\n", - "Modelling tides using EOT20, GOT5.5 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 10/10 [00:04<00:00, 2.01it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 5, 'parallel_max': 8, 'time': 5.687551021575928, 'points': 1000, 'points_per_split': 200, 'split_per_parallel': 0.625, 'directory': '/gdata1/data/tide_models_clipped/', 'model': ['EOT20', 'GOT5.5']}\n", - "Modelling tides using EOT20, GOT5.5 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 12/12 [00:05<00:00, 2.28it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 6, 'parallel_max': 8, 'time': 5.957857608795166, 'points': 1000, 'points_per_split': 166, 'split_per_parallel': 0.75, 'directory': '/gdata1/data/tide_models_clipped/', 'model': ['EOT20', 'GOT5.5']}\n", - "Modelling tides using EOT20, GOT5.5 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 16/16 [00:06<00:00, 2.53it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 8, 'parallel_max': 8, 'time': 7.025585412979126, 'points': 1000, 'points_per_split': 125, 'split_per_parallel': 1.0, 'directory': '/gdata1/data/tide_models_clipped/', 'model': ['EOT20', 'GOT5.5']}\n", - "Modelling tides using EOT20, GOT5.5 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 20/20 [00:07<00:00, 2.70it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 10, 'parallel_max': 8, 'time': 8.076916694641113, 'points': 1000, 'points_per_split': 100, 'split_per_parallel': 1.25, 'directory': '/gdata1/data/tide_models_clipped/', 'model': ['EOT20', 'GOT5.5']}\n", - "Modelling tides using EOT20, GOT5.5 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 24/24 [00:08<00:00, 2.82it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 12, 'parallel_max': 8, 'time': 9.199008703231812, 'points': 1000, 'points_per_split': 83, 'split_per_parallel': 1.5, 'directory': '/gdata1/data/tide_models_clipped/', 'model': ['EOT20', 'GOT5.5']}\n", - "Modelling tides using EOT20, GOT5.5 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 32/32 [00:09<00:00, 3.25it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 16, 'parallel_max': 8, 'time': 10.505664825439453, 'points': 1000, 'points_per_split': 62, 'split_per_parallel': 2.0, 'directory': '/gdata1/data/tide_models_clipped/', 'model': ['EOT20', 'GOT5.5']}\n", - "Modelling tides using EOT20, GOT5.5 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 40/40 [00:11<00:00, 3.34it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 20, 'parallel_max': 8, 'time': 12.669795036315918, 'points': 1000, 'points_per_split': 50, 'split_per_parallel': 2.5, 'directory': '/gdata1/data/tide_models_clipped/', 'model': ['EOT20', 'GOT5.5']}\n", - "Modelling tides using EOT20, GOT5.5 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 2/2 [00:04<00:00, 2.41s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 1, 'parallel_max': 16, 'time': 5.831315517425537, 'points': 1000, 'points_per_split': 1000, 'split_per_parallel': 0.0625, 'directory': '/gdata1/data/tide_models_clipped/', 'model': ['EOT20', 'GOT5.5']}\n", - "Modelling tides using EOT20, GOT5.5 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 4/4 [00:04<00:00, 1.04s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 2, 'parallel_max': 16, 'time': 5.128083944320679, 'points': 1000, 'points_per_split': 500, 'split_per_parallel': 0.125, 'directory': '/gdata1/data/tide_models_clipped/', 'model': ['EOT20', 'GOT5.5']}\n", - "Modelling tides using EOT20, GOT5.5 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 6/6 [00:04<00:00, 1.42it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 3, 'parallel_max': 16, 'time': 5.169249057769775, 'points': 1000, 'points_per_split': 333, 'split_per_parallel': 0.1875, 'directory': '/gdata1/data/tide_models_clipped/', 'model': ['EOT20', 'GOT5.5']}\n", - "Modelling tides using EOT20, GOT5.5 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 8/8 [00:04<00:00, 1.76it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 4, 'parallel_max': 16, 'time': 5.4696550369262695, 'points': 1000, 'points_per_split': 250, 'split_per_parallel': 0.25, 'directory': '/gdata1/data/tide_models_clipped/', 'model': ['EOT20', 'GOT5.5']}\n", - "Modelling tides using EOT20, GOT5.5 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 10/10 [00:04<00:00, 2.01it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 5, 'parallel_max': 16, 'time': 5.932654619216919, 'points': 1000, 'points_per_split': 200, 'split_per_parallel': 0.3125, 'directory': '/gdata1/data/tide_models_clipped/', 'model': ['EOT20', 'GOT5.5']}\n", - "Modelling tides using EOT20, GOT5.5 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 12/12 [00:05<00:00, 2.36it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 6, 'parallel_max': 16, 'time': 6.110931158065796, 'points': 1000, 'points_per_split': 166, 'split_per_parallel': 0.375, 'directory': '/gdata1/data/tide_models_clipped/', 'model': ['EOT20', 'GOT5.5']}\n", - "Modelling tides using EOT20, GOT5.5 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 16/16 [00:05<00:00, 2.85it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 8, 'parallel_max': 16, 'time': 6.56880259513855, 'points': 1000, 'points_per_split': 125, 'split_per_parallel': 0.5, 'directory': '/gdata1/data/tide_models_clipped/', 'model': ['EOT20', 'GOT5.5']}\n", - "Modelling tides using EOT20, GOT5.5 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 20/20 [00:06<00:00, 3.20it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 10, 'parallel_max': 16, 'time': 7.181562423706055, 'points': 1000, 'points_per_split': 100, 'split_per_parallel': 0.625, 'directory': '/gdata1/data/tide_models_clipped/', 'model': ['EOT20', 'GOT5.5']}\n", - "Modelling tides using EOT20, GOT5.5 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 24/24 [00:05<00:00, 4.03it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 12, 'parallel_max': 16, 'time': 6.9272284507751465, 'points': 1000, 'points_per_split': 83, 'split_per_parallel': 0.75, 'directory': '/gdata1/data/tide_models_clipped/', 'model': ['EOT20', 'GOT5.5']}\n", - "Modelling tides using EOT20, GOT5.5 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 32/32 [00:07<00:00, 4.45it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 16, 'parallel_max': 16, 'time': 8.17851209640503, 'points': 1000, 'points_per_split': 62, 'split_per_parallel': 1.0, 'directory': '/gdata1/data/tide_models_clipped/', 'model': ['EOT20', 'GOT5.5']}\n", - "Modelling tides using EOT20, GOT5.5 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 40/40 [00:08<00:00, 4.60it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 20, 'parallel_max': 16, 'time': 9.803722143173218, 'points': 1000, 'points_per_split': 50, 'split_per_parallel': 1.25, 'directory': '/gdata1/data/tide_models_clipped/', 'model': ['EOT20', 'GOT5.5']}\n", - "Modelling tides using EOT20, GOT5.5 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 2/2 [00:22<00:00, 11.21s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 1, 'parallel_max': 2, 'time': 22.900603532791138, 'points': 10000, 'points_per_split': 10000, 'split_per_parallel': 0.5, 'directory': '/gdata1/data/tide_models_clipped/', 'model': ['EOT20', 'GOT5.5']}\n", - "Modelling tides using EOT20, GOT5.5 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 4/4 [00:23<00:00, 5.94s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 2, 'parallel_max': 2, 'time': 24.26825761795044, 'points': 10000, 'points_per_split': 5000, 'split_per_parallel': 1.0, 'directory': '/gdata1/data/tide_models_clipped/', 'model': ['EOT20', 'GOT5.5']}\n", - "Modelling tides using EOT20, GOT5.5 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 6/6 [00:26<00:00, 4.39s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 3, 'parallel_max': 2, 'time': 26.869187116622925, 'points': 10000, 'points_per_split': 3333, 'split_per_parallel': 1.5, 'directory': '/gdata1/data/tide_models_clipped/', 'model': ['EOT20', 'GOT5.5']}\n", - "Modelling tides using EOT20, GOT5.5 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 8/8 [00:27<00:00, 3.49s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 4, 'parallel_max': 2, 'time': 28.539355039596558, 'points': 10000, 'points_per_split': 2500, 'split_per_parallel': 2.0, 'directory': '/gdata1/data/tide_models_clipped/', 'model': ['EOT20', 'GOT5.5']}\n", - "Modelling tides using EOT20, GOT5.5 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 10/10 [00:30<00:00, 3.04s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 5, 'parallel_max': 2, 'time': 30.889484643936157, 'points': 10000, 'points_per_split': 2000, 'split_per_parallel': 2.5, 'directory': '/gdata1/data/tide_models_clipped/', 'model': ['EOT20', 'GOT5.5']}\n", - "Modelling tides using EOT20, GOT5.5 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 12/12 [00:32<00:00, 2.72s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 6, 'parallel_max': 2, 'time': 33.13550090789795, 'points': 10000, 'points_per_split': 1666, 'split_per_parallel': 3.0, 'directory': '/gdata1/data/tide_models_clipped/', 'model': ['EOT20', 'GOT5.5']}\n", - "Modelling tides using EOT20, GOT5.5 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 16/16 [00:35<00:00, 2.21s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 8, 'parallel_max': 2, 'time': 35.95601677894592, 'points': 10000, 'points_per_split': 1250, 'split_per_parallel': 4.0, 'directory': '/gdata1/data/tide_models_clipped/', 'model': ['EOT20', 'GOT5.5']}\n", - "Modelling tides using EOT20, GOT5.5 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 20/20 [00:38<00:00, 1.93s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 10, 'parallel_max': 2, 'time': 39.1878080368042, 'points': 10000, 'points_per_split': 1000, 'split_per_parallel': 5.0, 'directory': '/gdata1/data/tide_models_clipped/', 'model': ['EOT20', 'GOT5.5']}\n", - "Modelling tides using EOT20, GOT5.5 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 24/24 [00:42<00:00, 1.75s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 12, 'parallel_max': 2, 'time': 42.74210977554321, 'points': 10000, 'points_per_split': 833, 'split_per_parallel': 6.0, 'directory': '/gdata1/data/tide_models_clipped/', 'model': ['EOT20', 'GOT5.5']}\n", - "Modelling tides using EOT20, GOT5.5 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 32/32 [00:47<00:00, 1.49s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 16, 'parallel_max': 2, 'time': 48.30967473983765, 'points': 10000, 'points_per_split': 625, 'split_per_parallel': 8.0, 'directory': '/gdata1/data/tide_models_clipped/', 'model': ['EOT20', 'GOT5.5']}\n", - "Modelling tides using EOT20, GOT5.5 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 40/40 [00:55<00:00, 1.38s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 20, 'parallel_max': 2, 'time': 55.995895862579346, 'points': 10000, 'points_per_split': 500, 'split_per_parallel': 10.0, 'directory': '/gdata1/data/tide_models_clipped/', 'model': ['EOT20', 'GOT5.5']}\n", - "Modelling tides using EOT20, GOT5.5 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 2/2 [00:22<00:00, 11.23s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 1, 'parallel_max': 4, 'time': 23.05580997467041, 'points': 10000, 'points_per_split': 10000, 'split_per_parallel': 0.25, 'directory': '/gdata1/data/tide_models_clipped/', 'model': ['EOT20', 'GOT5.5']}\n", - "Modelling tides using EOT20, GOT5.5 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 4/4 [00:13<00:00, 3.36s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 2, 'parallel_max': 4, 'time': 14.143684387207031, 'points': 10000, 'points_per_split': 5000, 'split_per_parallel': 0.5, 'directory': '/gdata1/data/tide_models_clipped/', 'model': ['EOT20', 'GOT5.5']}\n", - "Modelling tides using EOT20, GOT5.5 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 6/6 [00:17<00:00, 2.97s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 3, 'parallel_max': 4, 'time': 18.470566987991333, 'points': 10000, 'points_per_split': 3333, 'split_per_parallel': 0.75, 'directory': '/gdata1/data/tide_models_clipped/', 'model': ['EOT20', 'GOT5.5']}\n", - "Modelling tides using EOT20, GOT5.5 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 8/8 [00:15<00:00, 1.93s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 4, 'parallel_max': 4, 'time': 16.05748462677002, 'points': 10000, 'points_per_split': 2500, 'split_per_parallel': 1.0, 'directory': '/gdata1/data/tide_models_clipped/', 'model': ['EOT20', 'GOT5.5']}\n", - "Modelling tides using EOT20, GOT5.5 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 10/10 [00:18<00:00, 1.87s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 5, 'parallel_max': 4, 'time': 19.352588176727295, 'points': 10000, 'points_per_split': 2000, 'split_per_parallel': 1.25, 'directory': '/gdata1/data/tide_models_clipped/', 'model': ['EOT20', 'GOT5.5']}\n", - "Modelling tides using EOT20, GOT5.5 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 12/12 [00:18<00:00, 1.52s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 6, 'parallel_max': 4, 'time': 18.946587800979614, 'points': 10000, 'points_per_split': 1666, 'split_per_parallel': 1.5, 'directory': '/gdata1/data/tide_models_clipped/', 'model': ['EOT20', 'GOT5.5']}\n", - "Modelling tides using EOT20, GOT5.5 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 16/16 [00:19<00:00, 1.24s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 8, 'parallel_max': 4, 'time': 20.531039714813232, 'points': 10000, 'points_per_split': 1250, 'split_per_parallel': 2.0, 'directory': '/gdata1/data/tide_models_clipped/', 'model': ['EOT20', 'GOT5.5']}\n", - "Modelling tides using EOT20, GOT5.5 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 20/20 [00:22<00:00, 1.11s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 10, 'parallel_max': 4, 'time': 22.82627844810486, 'points': 10000, 'points_per_split': 1000, 'split_per_parallel': 2.5, 'directory': '/gdata1/data/tide_models_clipped/', 'model': ['EOT20', 'GOT5.5']}\n", - "Modelling tides using EOT20, GOT5.5 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 24/24 [00:23<00:00, 1.04it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 12, 'parallel_max': 4, 'time': 23.852038383483887, 'points': 10000, 'points_per_split': 833, 'split_per_parallel': 3.0, 'directory': '/gdata1/data/tide_models_clipped/', 'model': ['EOT20', 'GOT5.5']}\n", - "Modelling tides using EOT20, GOT5.5 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 32/32 [00:26<00:00, 1.21it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 16, 'parallel_max': 4, 'time': 27.036839962005615, 'points': 10000, 'points_per_split': 625, 'split_per_parallel': 4.0, 'directory': '/gdata1/data/tide_models_clipped/', 'model': ['EOT20', 'GOT5.5']}\n", - "Modelling tides using EOT20, GOT5.5 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 40/40 [00:30<00:00, 1.31it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 20, 'parallel_max': 4, 'time': 31.188039541244507, 'points': 10000, 'points_per_split': 500, 'split_per_parallel': 5.0, 'directory': '/gdata1/data/tide_models_clipped/', 'model': ['EOT20', 'GOT5.5']}\n", - "Modelling tides using EOT20, GOT5.5 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 2/2 [00:21<00:00, 10.83s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 1, 'parallel_max': 8, 'time': 22.58897566795349, 'points': 10000, 'points_per_split': 10000, 'split_per_parallel': 0.125, 'directory': '/gdata1/data/tide_models_clipped/', 'model': ['EOT20', 'GOT5.5']}\n", - "Modelling tides using EOT20, GOT5.5 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 4/4 [00:13<00:00, 3.26s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 2, 'parallel_max': 8, 'time': 13.880143880844116, 'points': 10000, 'points_per_split': 5000, 'split_per_parallel': 0.25, 'directory': '/gdata1/data/tide_models_clipped/', 'model': ['EOT20', 'GOT5.5']}\n", - "Modelling tides using EOT20, GOT5.5 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 6/6 [00:10<00:00, 1.75s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 3, 'parallel_max': 8, 'time': 11.362075090408325, 'points': 10000, 'points_per_split': 3333, 'split_per_parallel': 0.375, 'directory': '/gdata1/data/tide_models_clipped/', 'model': ['EOT20', 'GOT5.5']}\n", - "Modelling tides using EOT20, GOT5.5 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 8/8 [00:09<00:00, 1.19s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 4, 'parallel_max': 8, 'time': 10.333516359329224, 'points': 10000, 'points_per_split': 2500, 'split_per_parallel': 0.5, 'directory': '/gdata1/data/tide_models_clipped/', 'model': ['EOT20', 'GOT5.5']}\n", - "Modelling tides using EOT20, GOT5.5 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 10/10 [00:12<00:00, 1.21s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 5, 'parallel_max': 8, 'time': 12.877896070480347, 'points': 10000, 'points_per_split': 2000, 'split_per_parallel': 0.625, 'directory': '/gdata1/data/tide_models_clipped/', 'model': ['EOT20', 'GOT5.5']}\n", - "Modelling tides using EOT20, GOT5.5 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 12/12 [00:12<00:00, 1.07s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 6, 'parallel_max': 8, 'time': 13.7094247341156, 'points': 10000, 'points_per_split': 1666, 'split_per_parallel': 0.75, 'directory': '/gdata1/data/tide_models_clipped/', 'model': ['EOT20', 'GOT5.5']}\n", - "Modelling tides using EOT20, GOT5.5 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 16/16 [00:12<00:00, 1.26it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 8, 'parallel_max': 8, 'time': 13.51665735244751, 'points': 10000, 'points_per_split': 1250, 'split_per_parallel': 1.0, 'directory': '/gdata1/data/tide_models_clipped/', 'model': ['EOT20', 'GOT5.5']}\n", - "Modelling tides using EOT20, GOT5.5 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 20/20 [00:14<00:00, 1.36it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 10, 'parallel_max': 8, 'time': 15.559411525726318, 'points': 10000, 'points_per_split': 1000, 'split_per_parallel': 1.25, 'directory': '/gdata1/data/tide_models_clipped/', 'model': ['EOT20', 'GOT5.5']}\n", - "Modelling tides using EOT20, GOT5.5 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 24/24 [00:14<00:00, 1.65it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 12, 'parallel_max': 8, 'time': 15.41647720336914, 'points': 10000, 'points_per_split': 833, 'split_per_parallel': 1.5, 'directory': '/gdata1/data/tide_models_clipped/', 'model': ['EOT20', 'GOT5.5']}\n", - "Modelling tides using EOT20, GOT5.5 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 32/32 [00:16<00:00, 1.92it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 16, 'parallel_max': 8, 'time': 17.506346225738525, 'points': 10000, 'points_per_split': 625, 'split_per_parallel': 2.0, 'directory': '/gdata1/data/tide_models_clipped/', 'model': ['EOT20', 'GOT5.5']}\n", - "Modelling tides using EOT20, GOT5.5 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 40/40 [00:18<00:00, 2.13it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 20, 'parallel_max': 8, 'time': 19.70543336868286, 'points': 10000, 'points_per_split': 500, 'split_per_parallel': 2.5, 'directory': '/gdata1/data/tide_models_clipped/', 'model': ['EOT20', 'GOT5.5']}\n", - "Modelling tides using EOT20, GOT5.5 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 2/2 [00:21<00:00, 11.00s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 1, 'parallel_max': 16, 'time': 23.020490169525146, 'points': 10000, 'points_per_split': 10000, 'split_per_parallel': 0.0625, 'directory': '/gdata1/data/tide_models_clipped/', 'model': ['EOT20', 'GOT5.5']}\n", - "Modelling tides using EOT20, GOT5.5 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 4/4 [00:13<00:00, 3.29s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 2, 'parallel_max': 16, 'time': 14.192427158355713, 'points': 10000, 'points_per_split': 5000, 'split_per_parallel': 0.125, 'directory': '/gdata1/data/tide_models_clipped/', 'model': ['EOT20', 'GOT5.5']}\n", - "Modelling tides using EOT20, GOT5.5 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 6/6 [00:10<00:00, 1.79s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 3, 'parallel_max': 16, 'time': 11.834304571151733, 'points': 10000, 'points_per_split': 3333, 'split_per_parallel': 0.1875, 'directory': '/gdata1/data/tide_models_clipped/', 'model': ['EOT20', 'GOT5.5']}\n", - "Modelling tides using EOT20, GOT5.5 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 8/8 [00:09<00:00, 1.17s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 4, 'parallel_max': 16, 'time': 10.566474199295044, 'points': 10000, 'points_per_split': 2500, 'split_per_parallel': 0.25, 'directory': '/gdata1/data/tide_models_clipped/', 'model': ['EOT20', 'GOT5.5']}\n", - "Modelling tides using EOT20, GOT5.5 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 10/10 [00:09<00:00, 1.06it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 5, 'parallel_max': 16, 'time': 10.519251823425293, 'points': 10000, 'points_per_split': 2000, 'split_per_parallel': 0.3125, 'directory': '/gdata1/data/tide_models_clipped/', 'model': ['EOT20', 'GOT5.5']}\n", - "Modelling tides using EOT20, GOT5.5 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 12/12 [00:09<00:00, 1.30it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 6, 'parallel_max': 16, 'time': 10.311842203140259, 'points': 10000, 'points_per_split': 1666, 'split_per_parallel': 0.375, 'directory': '/gdata1/data/tide_models_clipped/', 'model': ['EOT20', 'GOT5.5']}\n", - "Modelling tides using EOT20, GOT5.5 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 16/16 [00:09<00:00, 1.76it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 8, 'parallel_max': 16, 'time': 10.208220481872559, 'points': 10000, 'points_per_split': 1250, 'split_per_parallel': 0.5, 'directory': '/gdata1/data/tide_models_clipped/', 'model': ['EOT20', 'GOT5.5']}\n", - "Modelling tides using EOT20, GOT5.5 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 20/20 [00:10<00:00, 1.98it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 10, 'parallel_max': 16, 'time': 11.23732042312622, 'points': 10000, 'points_per_split': 1000, 'split_per_parallel': 0.625, 'directory': '/gdata1/data/tide_models_clipped/', 'model': ['EOT20', 'GOT5.5']}\n", - "Modelling tides using EOT20, GOT5.5 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 24/24 [00:11<00:00, 2.10it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 12, 'parallel_max': 16, 'time': 12.573827266693115, 'points': 10000, 'points_per_split': 833, 'split_per_parallel': 0.75, 'directory': '/gdata1/data/tide_models_clipped/', 'model': ['EOT20', 'GOT5.5']}\n", - "Modelling tides using EOT20, GOT5.5 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 32/32 [00:12<00:00, 2.55it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 16, 'parallel_max': 16, 'time': 13.904297828674316, 'points': 10000, 'points_per_split': 625, 'split_per_parallel': 1.0, 'directory': '/gdata1/data/tide_models_clipped/', 'model': ['EOT20', 'GOT5.5']}\n", - "Modelling tides using EOT20, GOT5.5 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 40/40 [00:14<00:00, 2.85it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 20, 'parallel_max': 16, 'time': 15.160867929458618, 'points': 10000, 'points_per_split': 500, 'split_per_parallel': 1.25, 'directory': '/gdata1/data/tide_models_clipped/', 'model': ['EOT20', 'GOT5.5']}\n", - "Modelling tides using EOT20, GOT5.5 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 2/2 [03:35<00:00, 107.61s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 1, 'parallel_max': 2, 'time': 216.1456756591797, 'points': 100000, 'points_per_split': 100000, 'split_per_parallel': 0.5, 'directory': '/gdata1/data/tide_models_clipped/', 'model': ['EOT20', 'GOT5.5']}\n", - "Modelling tides using EOT20, GOT5.5 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 4/4 [03:36<00:00, 54.11s/it] \n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 2, 'parallel_max': 2, 'time': 217.80726861953735, 'points': 100000, 'points_per_split': 50000, 'split_per_parallel': 1.0, 'directory': '/gdata1/data/tide_models_clipped/', 'model': ['EOT20', 'GOT5.5']}\n", - "Modelling tides using EOT20, GOT5.5 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 6/6 [03:28<00:00, 34.70s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 3, 'parallel_max': 2, 'time': 209.56946969032288, 'points': 100000, 'points_per_split': 33333, 'split_per_parallel': 1.5, 'directory': '/gdata1/data/tide_models_clipped/', 'model': ['EOT20', 'GOT5.5']}\n", - "Modelling tides using EOT20, GOT5.5 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 8/8 [03:27<00:00, 25.97s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 4, 'parallel_max': 2, 'time': 209.03941464424133, 'points': 100000, 'points_per_split': 25000, 'split_per_parallel': 2.0, 'directory': '/gdata1/data/tide_models_clipped/', 'model': ['EOT20', 'GOT5.5']}\n", - "Modelling tides using EOT20, GOT5.5 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 10/10 [03:27<00:00, 20.76s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 5, 'parallel_max': 2, 'time': 208.94756078720093, 'points': 100000, 'points_per_split': 20000, 'split_per_parallel': 2.5, 'directory': '/gdata1/data/tide_models_clipped/', 'model': ['EOT20', 'GOT5.5']}\n", - "Modelling tides using EOT20, GOT5.5 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 12/12 [03:26<00:00, 17.21s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 6, 'parallel_max': 2, 'time': 207.80913043022156, 'points': 100000, 'points_per_split': 16666, 'split_per_parallel': 3.0, 'directory': '/gdata1/data/tide_models_clipped/', 'model': ['EOT20', 'GOT5.5']}\n", - "Modelling tides using EOT20, GOT5.5 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 16/16 [03:28<00:00, 13.03s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 8, 'parallel_max': 2, 'time': 209.8010458946228, 'points': 100000, 'points_per_split': 12500, 'split_per_parallel': 4.0, 'directory': '/gdata1/data/tide_models_clipped/', 'model': ['EOT20', 'GOT5.5']}\n", - "Modelling tides using EOT20, GOT5.5 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 20/20 [03:32<00:00, 10.63s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 10, 'parallel_max': 2, 'time': 214.03874039649963, 'points': 100000, 'points_per_split': 10000, 'split_per_parallel': 5.0, 'directory': '/gdata1/data/tide_models_clipped/', 'model': ['EOT20', 'GOT5.5']}\n", - "Modelling tides using EOT20, GOT5.5 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 24/24 [03:36<00:00, 9.03s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 12, 'parallel_max': 2, 'time': 218.1385862827301, 'points': 100000, 'points_per_split': 8333, 'split_per_parallel': 6.0, 'directory': '/gdata1/data/tide_models_clipped/', 'model': ['EOT20', 'GOT5.5']}\n", - "Modelling tides using EOT20, GOT5.5 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 32/32 [03:43<00:00, 6.99s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 16, 'parallel_max': 2, 'time': 225.20102787017822, 'points': 100000, 'points_per_split': 6250, 'split_per_parallel': 8.0, 'directory': '/gdata1/data/tide_models_clipped/', 'model': ['EOT20', 'GOT5.5']}\n", - "Modelling tides using EOT20, GOT5.5 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 40/40 [03:55<00:00, 5.88s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 20, 'parallel_max': 2, 'time': 236.50390100479126, 'points': 100000, 'points_per_split': 5000, 'split_per_parallel': 10.0, 'directory': '/gdata1/data/tide_models_clipped/', 'model': ['EOT20', 'GOT5.5']}\n", - "Modelling tides using EOT20, GOT5.5 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 2/2 [03:37<00:00, 108.73s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 1, 'parallel_max': 4, 'time': 218.76454377174377, 'points': 100000, 'points_per_split': 100000, 'split_per_parallel': 0.25, 'directory': '/gdata1/data/tide_models_clipped/', 'model': ['EOT20', 'GOT5.5']}\n", - "Modelling tides using EOT20, GOT5.5 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 4/4 [01:51<00:00, 27.82s/it] \n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 2, 'parallel_max': 4, 'time': 112.75051069259644, 'points': 100000, 'points_per_split': 50000, 'split_per_parallel': 0.5, 'directory': '/gdata1/data/tide_models_clipped/', 'model': ['EOT20', 'GOT5.5']}\n", - "Modelling tides using EOT20, GOT5.5 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 6/6 [02:19<00:00, 23.33s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 3, 'parallel_max': 4, 'time': 141.4061987400055, 'points': 100000, 'points_per_split': 33333, 'split_per_parallel': 0.75, 'directory': '/gdata1/data/tide_models_clipped/', 'model': ['EOT20', 'GOT5.5']}\n", - "Modelling tides using EOT20, GOT5.5 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 8/8 [01:47<00:00, 13.39s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 4, 'parallel_max': 4, 'time': 108.53772020339966, 'points': 100000, 'points_per_split': 25000, 'split_per_parallel': 1.0, 'directory': '/gdata1/data/tide_models_clipped/', 'model': ['EOT20', 'GOT5.5']}\n", - "Modelling tides using EOT20, GOT5.5 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 10/10 [02:05<00:00, 12.53s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 5, 'parallel_max': 4, 'time': 126.68567848205566, 'points': 100000, 'points_per_split': 20000, 'split_per_parallel': 1.25, 'directory': '/gdata1/data/tide_models_clipped/', 'model': ['EOT20', 'GOT5.5']}\n", - "Modelling tides using EOT20, GOT5.5 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 12/12 [01:46<00:00, 8.87s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 6, 'parallel_max': 4, 'time': 107.88863778114319, 'points': 100000, 'points_per_split': 16666, 'split_per_parallel': 1.5, 'directory': '/gdata1/data/tide_models_clipped/', 'model': ['EOT20', 'GOT5.5']}\n", - "Modelling tides using EOT20, GOT5.5 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 16/16 [01:47<00:00, 6.74s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 8, 'parallel_max': 4, 'time': 109.28071689605713, 'points': 100000, 'points_per_split': 12500, 'split_per_parallel': 2.0, 'directory': '/gdata1/data/tide_models_clipped/', 'model': ['EOT20', 'GOT5.5']}\n", - "Modelling tides using EOT20, GOT5.5 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 20/20 [01:50<00:00, 5.51s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 10, 'parallel_max': 4, 'time': 111.61476230621338, 'points': 100000, 'points_per_split': 10000, 'split_per_parallel': 2.5, 'directory': '/gdata1/data/tide_models_clipped/', 'model': ['EOT20', 'GOT5.5']}\n", - "Modelling tides using EOT20, GOT5.5 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 24/24 [01:52<00:00, 4.69s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 12, 'parallel_max': 4, 'time': 114.15351700782776, 'points': 100000, 'points_per_split': 8333, 'split_per_parallel': 3.0, 'directory': '/gdata1/data/tide_models_clipped/', 'model': ['EOT20', 'GOT5.5']}\n", - "Modelling tides using EOT20, GOT5.5 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 32/32 [01:56<00:00, 3.65s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 16, 'parallel_max': 4, 'time': 118.3428122997284, 'points': 100000, 'points_per_split': 6250, 'split_per_parallel': 4.0, 'directory': '/gdata1/data/tide_models_clipped/', 'model': ['EOT20', 'GOT5.5']}\n", - "Modelling tides using EOT20, GOT5.5 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 40/40 [02:03<00:00, 3.08s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 20, 'parallel_max': 4, 'time': 124.77188372612, 'points': 100000, 'points_per_split': 5000, 'split_per_parallel': 5.0, 'directory': '/gdata1/data/tide_models_clipped/', 'model': ['EOT20', 'GOT5.5']}\n", - "Modelling tides using EOT20, GOT5.5 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 2/2 [03:41<00:00, 110.94s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 1, 'parallel_max': 8, 'time': 223.4452419281006, 'points': 100000, 'points_per_split': 100000, 'split_per_parallel': 0.125, 'directory': '/gdata1/data/tide_models_clipped/', 'model': ['EOT20', 'GOT5.5']}\n", - "Modelling tides using EOT20, GOT5.5 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 4/4 [01:52<00:00, 28.06s/it] \n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 2, 'parallel_max': 8, 'time': 113.88393425941467, 'points': 100000, 'points_per_split': 50000, 'split_per_parallel': 0.25, 'directory': '/gdata1/data/tide_models_clipped/', 'model': ['EOT20', 'GOT5.5']}\n", - "Modelling tides using EOT20, GOT5.5 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 6/6 [01:14<00:00, 12.35s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 3, 'parallel_max': 8, 'time': 75.75654006004333, 'points': 100000, 'points_per_split': 33333, 'split_per_parallel': 0.375, 'directory': '/gdata1/data/tide_models_clipped/', 'model': ['EOT20', 'GOT5.5']}\n", - "Modelling tides using EOT20, GOT5.5 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 8/8 [00:55<00:00, 6.94s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 4, 'parallel_max': 8, 'time': 57.20682334899902, 'points': 100000, 'points_per_split': 25000, 'split_per_parallel': 0.5, 'directory': '/gdata1/data/tide_models_clipped/', 'model': ['EOT20', 'GOT5.5']}\n", - "Modelling tides using EOT20, GOT5.5 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 10/10 [01:23<00:00, 8.32s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 5, 'parallel_max': 8, 'time': 84.68120646476746, 'points': 100000, 'points_per_split': 20000, 'split_per_parallel': 0.625, 'directory': '/gdata1/data/tide_models_clipped/', 'model': ['EOT20', 'GOT5.5']}\n", - "Modelling tides using EOT20, GOT5.5 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 12/12 [01:11<00:00, 5.96s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 6, 'parallel_max': 8, 'time': 73.19063377380371, 'points': 100000, 'points_per_split': 16666, 'split_per_parallel': 0.75, 'directory': '/gdata1/data/tide_models_clipped/', 'model': ['EOT20', 'GOT5.5']}\n", - "Modelling tides using EOT20, GOT5.5 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 16/16 [00:58<00:00, 3.63s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 8, 'parallel_max': 8, 'time': 59.815208196640015, 'points': 100000, 'points_per_split': 12500, 'split_per_parallel': 1.0, 'directory': '/gdata1/data/tide_models_clipped/', 'model': ['EOT20', 'GOT5.5']}\n", - "Modelling tides using EOT20, GOT5.5 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 20/20 [01:08<00:00, 3.42s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 10, 'parallel_max': 8, 'time': 69.98841643333435, 'points': 100000, 'points_per_split': 10000, 'split_per_parallel': 1.25, 'directory': '/gdata1/data/tide_models_clipped/', 'model': ['EOT20', 'GOT5.5']}\n", - "Modelling tides using EOT20, GOT5.5 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 24/24 [01:01<00:00, 2.54s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 12, 'parallel_max': 8, 'time': 62.834444761276245, 'points': 100000, 'points_per_split': 8333, 'split_per_parallel': 1.5, 'directory': '/gdata1/data/tide_models_clipped/', 'model': ['EOT20', 'GOT5.5']}\n", - "Modelling tides using EOT20, GOT5.5 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 32/32 [01:04<00:00, 2.02s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 16, 'parallel_max': 8, 'time': 66.36685395240784, 'points': 100000, 'points_per_split': 6250, 'split_per_parallel': 2.0, 'directory': '/gdata1/data/tide_models_clipped/', 'model': ['EOT20', 'GOT5.5']}\n", - "Modelling tides using EOT20, GOT5.5 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 40/40 [01:07<00:00, 1.69s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 20, 'parallel_max': 8, 'time': 69.40264368057251, 'points': 100000, 'points_per_split': 5000, 'split_per_parallel': 2.5, 'directory': '/gdata1/data/tide_models_clipped/', 'model': ['EOT20', 'GOT5.5']}\n", - "Modelling tides using EOT20, GOT5.5 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 2/2 [03:37<00:00, 108.61s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 1, 'parallel_max': 16, 'time': 219.03950691223145, 'points': 100000, 'points_per_split': 100000, 'split_per_parallel': 0.0625, 'directory': '/gdata1/data/tide_models_clipped/', 'model': ['EOT20', 'GOT5.5']}\n", - "Modelling tides using EOT20, GOT5.5 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 4/4 [01:50<00:00, 27.67s/it] \n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 2, 'parallel_max': 16, 'time': 112.62936043739319, 'points': 100000, 'points_per_split': 50000, 'split_per_parallel': 0.125, 'directory': '/gdata1/data/tide_models_clipped/', 'model': ['EOT20', 'GOT5.5']}\n", - "Modelling tides using EOT20, GOT5.5 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 6/6 [01:14<00:00, 12.44s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 3, 'parallel_max': 16, 'time': 76.6215124130249, 'points': 100000, 'points_per_split': 33333, 'split_per_parallel': 0.1875, 'directory': '/gdata1/data/tide_models_clipped/', 'model': ['EOT20', 'GOT5.5']}\n", - "Modelling tides using EOT20, GOT5.5 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 8/8 [00:55<00:00, 6.88s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 4, 'parallel_max': 16, 'time': 57.048078536987305, 'points': 100000, 'points_per_split': 25000, 'split_per_parallel': 0.25, 'directory': '/gdata1/data/tide_models_clipped/', 'model': ['EOT20', 'GOT5.5']}\n", - "Modelling tides using EOT20, GOT5.5 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 10/10 [00:45<00:00, 4.56s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 5, 'parallel_max': 16, 'time': 47.484530210494995, 'points': 100000, 'points_per_split': 20000, 'split_per_parallel': 0.3125, 'directory': '/gdata1/data/tide_models_clipped/', 'model': ['EOT20', 'GOT5.5']}\n", - "Modelling tides using EOT20, GOT5.5 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 12/12 [00:40<00:00, 3.35s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 6, 'parallel_max': 16, 'time': 42.28424668312073, 'points': 100000, 'points_per_split': 16666, 'split_per_parallel': 0.375, 'directory': '/gdata1/data/tide_models_clipped/', 'model': ['EOT20', 'GOT5.5']}\n", - "Modelling tides using EOT20, GOT5.5 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 16/16 [00:32<00:00, 2.06s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 8, 'parallel_max': 16, 'time': 34.97290015220642, 'points': 100000, 'points_per_split': 12500, 'split_per_parallel': 0.5, 'directory': '/gdata1/data/tide_models_clipped/', 'model': ['EOT20', 'GOT5.5']}\n", - "Modelling tides using EOT20, GOT5.5 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 20/20 [00:47<00:00, 2.36s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 10, 'parallel_max': 16, 'time': 49.525190353393555, 'points': 100000, 'points_per_split': 10000, 'split_per_parallel': 0.625, 'directory': '/gdata1/data/tide_models_clipped/', 'model': ['EOT20', 'GOT5.5']}\n", - "Modelling tides using EOT20, GOT5.5 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 24/24 [00:43<00:00, 1.81s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 12, 'parallel_max': 16, 'time': 45.5628559589386, 'points': 100000, 'points_per_split': 8333, 'split_per_parallel': 0.75, 'directory': '/gdata1/data/tide_models_clipped/', 'model': ['EOT20', 'GOT5.5']}\n", - "Modelling tides using EOT20, GOT5.5 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 32/32 [00:38<00:00, 1.20s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 16, 'parallel_max': 16, 'time': 40.69628596305847, 'points': 100000, 'points_per_split': 6250, 'split_per_parallel': 1.0, 'directory': '/gdata1/data/tide_models_clipped/', 'model': ['EOT20', 'GOT5.5']}\n", - "Modelling tides using EOT20, GOT5.5 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 40/40 [00:44<00:00, 1.12s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 20, 'parallel_max': 16, 'time': 46.97895050048828, 'points': 100000, 'points_per_split': 5000, 'split_per_parallel': 1.25, 'directory': '/gdata1/data/tide_models_clipped/', 'model': ['EOT20', 'GOT5.5']}\n", - "Modelling tides using EOT20\n", - "{'split': 1, 'parallel_max': 2, 'time': 3.334383487701416, 'points': 100, 'points_per_split': 100, 'split_per_parallel': 0.5, 'directory': '/gdata1/data/tide_models_clipped/', 'model': 'EOT20'}\n", - "Modelling tides using EOT20 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 2/2 [00:02<00:00, 1.43s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 2, 'parallel_max': 2, 'time': 3.4773685932159424, 'points': 100, 'points_per_split': 50, 'split_per_parallel': 1.0, 'directory': '/gdata1/data/tide_models_clipped/', 'model': 'EOT20'}\n", - "Modelling tides using EOT20 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 3/3 [00:05<00:00, 1.73s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 3, 'parallel_max': 2, 'time': 5.8094482421875, 'points': 100, 'points_per_split': 33, 'split_per_parallel': 1.5, 'directory': '/gdata1/data/tide_models_clipped/', 'model': 'EOT20'}\n", - "Modelling tides using EOT20 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 4/4 [00:05<00:00, 1.38s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 4, 'parallel_max': 2, 'time': 6.097298860549927, 'points': 100, 'points_per_split': 25, 'split_per_parallel': 2.0, 'directory': '/gdata1/data/tide_models_clipped/', 'model': 'EOT20'}\n", - "Modelling tides using EOT20 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 5/5 [00:07<00:00, 1.58s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 5, 'parallel_max': 2, 'time': 8.52026891708374, 'points': 100, 'points_per_split': 20, 'split_per_parallel': 2.5, 'directory': '/gdata1/data/tide_models_clipped/', 'model': 'EOT20'}\n", - "Modelling tides using EOT20 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 6/6 [00:08<00:00, 1.35s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 6, 'parallel_max': 2, 'time': 8.732183694839478, 'points': 100, 'points_per_split': 16, 'split_per_parallel': 3.0, 'directory': '/gdata1/data/tide_models_clipped/', 'model': 'EOT20'}\n", - "Modelling tides using EOT20 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 8/8 [00:10<00:00, 1.34s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 8, 'parallel_max': 2, 'time': 11.297289609909058, 'points': 100, 'points_per_split': 12, 'split_per_parallel': 4.0, 'directory': '/gdata1/data/tide_models_clipped/', 'model': 'EOT20'}\n", - "Modelling tides using EOT20 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 10/10 [00:12<00:00, 1.28s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 10, 'parallel_max': 2, 'time': 13.449850797653198, 'points': 100, 'points_per_split': 10, 'split_per_parallel': 5.0, 'directory': '/gdata1/data/tide_models_clipped/', 'model': 'EOT20'}\n", - "Modelling tides using EOT20 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 12/12 [00:15<00:00, 1.26s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 12, 'parallel_max': 2, 'time': 15.898078441619873, 'points': 100, 'points_per_split': 8, 'split_per_parallel': 6.0, 'directory': '/gdata1/data/tide_models_clipped/', 'model': 'EOT20'}\n", - "Modelling tides using EOT20 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 16/16 [00:19<00:00, 1.25s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 16, 'parallel_max': 2, 'time': 20.615198850631714, 'points': 100, 'points_per_split': 6, 'split_per_parallel': 8.0, 'directory': '/gdata1/data/tide_models_clipped/', 'model': 'EOT20'}\n", - "Modelling tides using EOT20 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 20/20 [00:24<00:00, 1.23s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 20, 'parallel_max': 2, 'time': 25.16162872314453, 'points': 100, 'points_per_split': 5, 'split_per_parallel': 10.0, 'directory': '/gdata1/data/tide_models_clipped/', 'model': 'EOT20'}\n", - "Modelling tides using EOT20\n", - "{'split': 1, 'parallel_max': 4, 'time': 3.14968204498291, 'points': 100, 'points_per_split': 100, 'split_per_parallel': 0.25, 'directory': '/gdata1/data/tide_models_clipped/', 'model': 'EOT20'}\n", - "Modelling tides using EOT20 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 2/2 [00:02<00:00, 1.44s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 2, 'parallel_max': 4, 'time': 3.5613956451416016, 'points': 100, 'points_per_split': 50, 'split_per_parallel': 0.5, 'directory': '/gdata1/data/tide_models_clipped/', 'model': 'EOT20'}\n", - "Modelling tides using EOT20 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 3/3 [00:03<00:00, 1.01s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 3, 'parallel_max': 4, 'time': 3.689911127090454, 'points': 100, 'points_per_split': 33, 'split_per_parallel': 0.75, 'directory': '/gdata1/data/tide_models_clipped/', 'model': 'EOT20'}\n", - "Modelling tides using EOT20 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 4/4 [00:03<00:00, 1.03it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 4, 'parallel_max': 4, 'time': 4.587037563323975, 'points': 100, 'points_per_split': 25, 'split_per_parallel': 1.0, 'directory': '/gdata1/data/tide_models_clipped/', 'model': 'EOT20'}\n", - "Modelling tides using EOT20 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 5/5 [00:05<00:00, 1.12s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 5, 'parallel_max': 4, 'time': 6.299825191497803, 'points': 100, 'points_per_split': 20, 'split_per_parallel': 1.25, 'directory': '/gdata1/data/tide_models_clipped/', 'model': 'EOT20'}\n", - "Modelling tides using EOT20 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 6/6 [00:05<00:00, 1.12it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 6, 'parallel_max': 4, 'time': 6.046776294708252, 'points': 100, 'points_per_split': 16, 'split_per_parallel': 1.5, 'directory': '/gdata1/data/tide_models_clipped/', 'model': 'EOT20'}\n", - "Modelling tides using EOT20 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 8/8 [00:05<00:00, 1.35it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 8, 'parallel_max': 4, 'time': 6.627188444137573, 'points': 100, 'points_per_split': 12, 'split_per_parallel': 2.0, 'directory': '/gdata1/data/tide_models_clipped/', 'model': 'EOT20'}\n", - "Modelling tides using EOT20 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 10/10 [00:08<00:00, 1.24it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 10, 'parallel_max': 4, 'time': 8.743812322616577, 'points': 100, 'points_per_split': 10, 'split_per_parallel': 2.5, 'directory': '/gdata1/data/tide_models_clipped/', 'model': 'EOT20'}\n", - "Modelling tides using EOT20 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 12/12 [00:08<00:00, 1.45it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 12, 'parallel_max': 4, 'time': 8.98261284828186, 'points': 100, 'points_per_split': 8, 'split_per_parallel': 3.0, 'directory': '/gdata1/data/tide_models_clipped/', 'model': 'EOT20'}\n", - "Modelling tides using EOT20 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 16/16 [00:10<00:00, 1.46it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 16, 'parallel_max': 4, 'time': 11.718202352523804, 'points': 100, 'points_per_split': 6, 'split_per_parallel': 4.0, 'directory': '/gdata1/data/tide_models_clipped/', 'model': 'EOT20'}\n", - "Modelling tides using EOT20 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 20/20 [00:13<00:00, 1.50it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 20, 'parallel_max': 4, 'time': 14.138868570327759, 'points': 100, 'points_per_split': 5, 'split_per_parallel': 5.0, 'directory': '/gdata1/data/tide_models_clipped/', 'model': 'EOT20'}\n", - "Modelling tides using EOT20\n", - "{'split': 1, 'parallel_max': 8, 'time': 3.1279547214508057, 'points': 100, 'points_per_split': 100, 'split_per_parallel': 0.125, 'directory': '/gdata1/data/tide_models_clipped/', 'model': 'EOT20'}\n", - "Modelling tides using EOT20 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 2/2 [00:02<00:00, 1.45s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 2, 'parallel_max': 8, 'time': 3.735466957092285, 'points': 100, 'points_per_split': 50, 'split_per_parallel': 0.25, 'directory': '/gdata1/data/tide_models_clipped/', 'model': 'EOT20'}\n", - "Modelling tides using EOT20 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 3/3 [00:03<00:00, 1.14s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 3, 'parallel_max': 8, 'time': 4.25137734413147, 'points': 100, 'points_per_split': 33, 'split_per_parallel': 0.375, 'directory': '/gdata1/data/tide_models_clipped/', 'model': 'EOT20'}\n", - "Modelling tides using EOT20 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 4/4 [00:03<00:00, 1.20it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 4, 'parallel_max': 8, 'time': 4.144881725311279, 'points': 100, 'points_per_split': 25, 'split_per_parallel': 0.5, 'directory': '/gdata1/data/tide_models_clipped/', 'model': 'EOT20'}\n", - "Modelling tides using EOT20 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 5/5 [00:03<00:00, 1.43it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 5, 'parallel_max': 8, 'time': 4.324579238891602, 'points': 100, 'points_per_split': 20, 'split_per_parallel': 0.625, 'directory': '/gdata1/data/tide_models_clipped/', 'model': 'EOT20'}\n", - "Modelling tides using EOT20 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 6/6 [00:03<00:00, 1.65it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 6, 'parallel_max': 8, 'time': 4.473366022109985, 'points': 100, 'points_per_split': 16, 'split_per_parallel': 0.75, 'directory': '/gdata1/data/tide_models_clipped/', 'model': 'EOT20'}\n", - "Modelling tides using EOT20 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 8/8 [00:04<00:00, 1.93it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 8, 'parallel_max': 8, 'time': 5.012174844741821, 'points': 100, 'points_per_split': 12, 'split_per_parallel': 1.0, 'directory': '/gdata1/data/tide_models_clipped/', 'model': 'EOT20'}\n", - "Modelling tides using EOT20 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 10/10 [00:05<00:00, 1.68it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 10, 'parallel_max': 8, 'time': 6.803356647491455, 'points': 100, 'points_per_split': 10, 'split_per_parallel': 1.25, 'directory': '/gdata1/data/tide_models_clipped/', 'model': 'EOT20'}\n", - "Modelling tides using EOT20 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 12/12 [00:06<00:00, 1.98it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 12, 'parallel_max': 8, 'time': 6.916663646697998, 'points': 100, 'points_per_split': 8, 'split_per_parallel': 1.5, 'directory': '/gdata1/data/tide_models_clipped/', 'model': 'EOT20'}\n", - "Modelling tides using EOT20 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 16/16 [00:06<00:00, 2.32it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 16, 'parallel_max': 8, 'time': 7.747692346572876, 'points': 100, 'points_per_split': 6, 'split_per_parallel': 2.0, 'directory': '/gdata1/data/tide_models_clipped/', 'model': 'EOT20'}\n", - "Modelling tides using EOT20 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 20/20 [00:08<00:00, 2.30it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 20, 'parallel_max': 8, 'time': 9.657457828521729, 'points': 100, 'points_per_split': 5, 'split_per_parallel': 2.5, 'directory': '/gdata1/data/tide_models_clipped/', 'model': 'EOT20'}\n", - "Modelling tides using EOT20\n", - "{'split': 1, 'parallel_max': 16, 'time': 3.063443422317505, 'points': 100, 'points_per_split': 100, 'split_per_parallel': 0.0625, 'directory': '/gdata1/data/tide_models_clipped/', 'model': 'EOT20'}\n", - "Modelling tides using EOT20 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 2/2 [00:02<00:00, 1.49s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 2, 'parallel_max': 16, 'time': 4.097646713256836, 'points': 100, 'points_per_split': 50, 'split_per_parallel': 0.125, 'directory': '/gdata1/data/tide_models_clipped/', 'model': 'EOT20'}\n", - "Modelling tides using EOT20 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 3/3 [00:03<00:00, 1.07s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 3, 'parallel_max': 16, 'time': 4.319326400756836, 'points': 100, 'points_per_split': 33, 'split_per_parallel': 0.1875, 'directory': '/gdata1/data/tide_models_clipped/', 'model': 'EOT20'}\n", - "Modelling tides using EOT20 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 4/4 [00:03<00:00, 1.16it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 4, 'parallel_max': 16, 'time': 4.569660663604736, 'points': 100, 'points_per_split': 25, 'split_per_parallel': 0.25, 'directory': '/gdata1/data/tide_models_clipped/', 'model': 'EOT20'}\n", - "Modelling tides using EOT20 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 5/5 [00:03<00:00, 1.57it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 5, 'parallel_max': 16, 'time': 4.290369749069214, 'points': 100, 'points_per_split': 20, 'split_per_parallel': 0.3125, 'directory': '/gdata1/data/tide_models_clipped/', 'model': 'EOT20'}\n", - "Modelling tides using EOT20 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 6/6 [00:03<00:00, 1.53it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 6, 'parallel_max': 16, 'time': 5.029247045516968, 'points': 100, 'points_per_split': 16, 'split_per_parallel': 0.375, 'directory': '/gdata1/data/tide_models_clipped/', 'model': 'EOT20'}\n", - "Modelling tides using EOT20 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 8/8 [00:04<00:00, 1.88it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 8, 'parallel_max': 16, 'time': 5.3499274253845215, 'points': 100, 'points_per_split': 12, 'split_per_parallel': 0.5, 'directory': '/gdata1/data/tide_models_clipped/', 'model': 'EOT20'}\n", - "Modelling tides using EOT20 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 10/10 [00:04<00:00, 2.33it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 10, 'parallel_max': 16, 'time': 5.415190696716309, 'points': 100, 'points_per_split': 10, 'split_per_parallel': 0.625, 'directory': '/gdata1/data/tide_models_clipped/', 'model': 'EOT20'}\n", - "Modelling tides using EOT20 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 12/12 [00:05<00:00, 2.36it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 12, 'parallel_max': 16, 'time': 6.193004608154297, 'points': 100, 'points_per_split': 8, 'split_per_parallel': 0.75, 'directory': '/gdata1/data/tide_models_clipped/', 'model': 'EOT20'}\n", - "Modelling tides using EOT20 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 16/16 [00:06<00:00, 2.47it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 16, 'parallel_max': 16, 'time': 7.601003646850586, 'points': 100, 'points_per_split': 6, 'split_per_parallel': 1.0, 'directory': '/gdata1/data/tide_models_clipped/', 'model': 'EOT20'}\n", - "Modelling tides using EOT20 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 20/20 [00:07<00:00, 2.66it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 20, 'parallel_max': 16, 'time': 8.80680537223816, 'points': 100, 'points_per_split': 5, 'split_per_parallel': 1.25, 'directory': '/gdata1/data/tide_models_clipped/', 'model': 'EOT20'}\n", - "Modelling tides using EOT20\n", - "{'split': 1, 'parallel_max': 2, 'time': 4.7310943603515625, 'points': 1000, 'points_per_split': 1000, 'split_per_parallel': 0.5, 'directory': '/gdata1/data/tide_models_clipped/', 'model': 'EOT20'}\n", - "Modelling tides using EOT20 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 2/2 [00:03<00:00, 1.96s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 2, 'parallel_max': 2, 'time': 4.629370450973511, 'points': 1000, 'points_per_split': 500, 'split_per_parallel': 1.0, 'directory': '/gdata1/data/tide_models_clipped/', 'model': 'EOT20'}\n", - "Modelling tides using EOT20 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 3/3 [00:06<00:00, 2.23s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 3, 'parallel_max': 2, 'time': 7.393319845199585, 'points': 1000, 'points_per_split': 333, 'split_per_parallel': 1.5, 'directory': '/gdata1/data/tide_models_clipped/', 'model': 'EOT20'}\n", - "Modelling tides using EOT20 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 4/4 [00:06<00:00, 1.63s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 4, 'parallel_max': 2, 'time': 7.228583335876465, 'points': 1000, 'points_per_split': 250, 'split_per_parallel': 2.0, 'directory': '/gdata1/data/tide_models_clipped/', 'model': 'EOT20'}\n", - "Modelling tides using EOT20 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 5/5 [00:09<00:00, 1.84s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 5, 'parallel_max': 2, 'time': 9.939010381698608, 'points': 1000, 'points_per_split': 200, 'split_per_parallel': 2.5, 'directory': '/gdata1/data/tide_models_clipped/', 'model': 'EOT20'}\n", - "Modelling tides using EOT20 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 6/6 [00:09<00:00, 1.55s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 6, 'parallel_max': 2, 'time': 10.017518281936646, 'points': 1000, 'points_per_split': 166, 'split_per_parallel': 3.0, 'directory': '/gdata1/data/tide_models_clipped/', 'model': 'EOT20'}\n", - "Modelling tides using EOT20 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 8/8 [00:11<00:00, 1.49s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 8, 'parallel_max': 2, 'time': 12.602005004882812, 'points': 1000, 'points_per_split': 125, 'split_per_parallel': 4.0, 'directory': '/gdata1/data/tide_models_clipped/', 'model': 'EOT20'}\n", - "Modelling tides using EOT20 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 10/10 [00:14<00:00, 1.43s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 10, 'parallel_max': 2, 'time': 15.180304288864136, 'points': 1000, 'points_per_split': 100, 'split_per_parallel': 5.0, 'directory': '/gdata1/data/tide_models_clipped/', 'model': 'EOT20'}\n", - "Modelling tides using EOT20 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 12/12 [00:17<00:00, 1.42s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 12, 'parallel_max': 2, 'time': 17.808774948120117, 'points': 1000, 'points_per_split': 83, 'split_per_parallel': 6.0, 'directory': '/gdata1/data/tide_models_clipped/', 'model': 'EOT20'}\n", - "Modelling tides using EOT20 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 16/16 [00:22<00:00, 1.38s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 16, 'parallel_max': 2, 'time': 22.807422876358032, 'points': 1000, 'points_per_split': 62, 'split_per_parallel': 8.0, 'directory': '/gdata1/data/tide_models_clipped/', 'model': 'EOT20'}\n", - "Modelling tides using EOT20 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 20/20 [00:27<00:00, 1.36s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 20, 'parallel_max': 2, 'time': 27.842896223068237, 'points': 1000, 'points_per_split': 50, 'split_per_parallel': 10.0, 'directory': '/gdata1/data/tide_models_clipped/', 'model': 'EOT20'}\n", - "Modelling tides using EOT20\n", - "{'split': 1, 'parallel_max': 4, 'time': 4.86713981628418, 'points': 1000, 'points_per_split': 1000, 'split_per_parallel': 0.25, 'directory': '/gdata1/data/tide_models_clipped/', 'model': 'EOT20'}\n", - "Modelling tides using EOT20 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 2/2 [00:04<00:00, 2.11s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 2, 'parallel_max': 4, 'time': 5.01958155632019, 'points': 1000, 'points_per_split': 500, 'split_per_parallel': 0.5, 'directory': '/gdata1/data/tide_models_clipped/', 'model': 'EOT20'}\n", - "Modelling tides using EOT20 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 3/3 [00:03<00:00, 1.29s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 3, 'parallel_max': 4, 'time': 4.692673921585083, 'points': 1000, 'points_per_split': 333, 'split_per_parallel': 0.75, 'directory': '/gdata1/data/tide_models_clipped/', 'model': 'EOT20'}\n", - "Modelling tides using EOT20 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 4/4 [00:04<00:00, 1.08s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 4, 'parallel_max': 4, 'time': 5.133579730987549, 'points': 1000, 'points_per_split': 250, 'split_per_parallel': 1.0, 'directory': '/gdata1/data/tide_models_clipped/', 'model': 'EOT20'}\n", - "Modelling tides using EOT20 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 5/5 [00:06<00:00, 1.26s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 5, 'parallel_max': 4, 'time': 7.13028883934021, 'points': 1000, 'points_per_split': 200, 'split_per_parallel': 1.25, 'directory': '/gdata1/data/tide_models_clipped/', 'model': 'EOT20'}\n", - "Modelling tides using EOT20 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 6/6 [00:06<00:00, 1.12s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 6, 'parallel_max': 4, 'time': 7.5119805335998535, 'points': 1000, 'points_per_split': 166, 'split_per_parallel': 1.5, 'directory': '/gdata1/data/tide_models_clipped/', 'model': 'EOT20'}\n", - "Modelling tides using EOT20 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 8/8 [00:06<00:00, 1.15it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 8, 'parallel_max': 4, 'time': 7.761422157287598, 'points': 1000, 'points_per_split': 125, 'split_per_parallel': 2.0, 'directory': '/gdata1/data/tide_models_clipped/', 'model': 'EOT20'}\n", - "Modelling tides using EOT20 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 10/10 [00:09<00:00, 1.06it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 10, 'parallel_max': 4, 'time': 10.226359367370605, 'points': 1000, 'points_per_split': 100, 'split_per_parallel': 2.5, 'directory': '/gdata1/data/tide_models_clipped/', 'model': 'EOT20'}\n", - "Modelling tides using EOT20 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 12/12 [00:09<00:00, 1.25it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 12, 'parallel_max': 4, 'time': 10.439139127731323, 'points': 1000, 'points_per_split': 83, 'split_per_parallel': 3.0, 'directory': '/gdata1/data/tide_models_clipped/', 'model': 'EOT20'}\n", - "Modelling tides using EOT20 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 16/16 [00:11<00:00, 1.37it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 16, 'parallel_max': 4, 'time': 12.605883121490479, 'points': 1000, 'points_per_split': 62, 'split_per_parallel': 4.0, 'directory': '/gdata1/data/tide_models_clipped/', 'model': 'EOT20'}\n", - "Modelling tides using EOT20 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 20/20 [00:14<00:00, 1.35it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 20, 'parallel_max': 4, 'time': 15.64789080619812, 'points': 1000, 'points_per_split': 50, 'split_per_parallel': 5.0, 'directory': '/gdata1/data/tide_models_clipped/', 'model': 'EOT20'}\n", - "Modelling tides using EOT20\n", - "{'split': 1, 'parallel_max': 8, 'time': 4.749791860580444, 'points': 1000, 'points_per_split': 1000, 'split_per_parallel': 0.125, 'directory': '/gdata1/data/tide_models_clipped/', 'model': 'EOT20'}\n", - "Modelling tides using EOT20 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 2/2 [00:03<00:00, 1.97s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 2, 'parallel_max': 8, 'time': 4.915995121002197, 'points': 1000, 'points_per_split': 500, 'split_per_parallel': 0.25, 'directory': '/gdata1/data/tide_models_clipped/', 'model': 'EOT20'}\n", - "Modelling tides using EOT20 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 3/3 [00:04<00:00, 1.34s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 3, 'parallel_max': 8, 'time': 5.00717830657959, 'points': 1000, 'points_per_split': 333, 'split_per_parallel': 0.375, 'directory': '/gdata1/data/tide_models_clipped/', 'model': 'EOT20'}\n", - "Modelling tides using EOT20 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 4/4 [00:04<00:00, 1.10s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 4, 'parallel_max': 8, 'time': 5.360293626785278, 'points': 1000, 'points_per_split': 250, 'split_per_parallel': 0.5, 'directory': '/gdata1/data/tide_models_clipped/', 'model': 'EOT20'}\n", - "Modelling tides using EOT20 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 5/5 [00:04<00:00, 1.09it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 5, 'parallel_max': 8, 'time': 5.571909666061401, 'points': 1000, 'points_per_split': 200, 'split_per_parallel': 0.625, 'directory': '/gdata1/data/tide_models_clipped/', 'model': 'EOT20'}\n", - "Modelling tides using EOT20 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 6/6 [00:05<00:00, 1.19it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 6, 'parallel_max': 8, 'time': 6.079857587814331, 'points': 1000, 'points_per_split': 166, 'split_per_parallel': 0.75, 'directory': '/gdata1/data/tide_models_clipped/', 'model': 'EOT20'}\n", - "Modelling tides using EOT20 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 8/8 [00:05<00:00, 1.52it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 8, 'parallel_max': 8, 'time': 6.372717618942261, 'points': 1000, 'points_per_split': 125, 'split_per_parallel': 1.0, 'directory': '/gdata1/data/tide_models_clipped/', 'model': 'EOT20'}\n", - "Modelling tides using EOT20 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 10/10 [00:06<00:00, 1.48it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 10, 'parallel_max': 8, 'time': 7.761810541152954, 'points': 1000, 'points_per_split': 100, 'split_per_parallel': 1.25, 'directory': '/gdata1/data/tide_models_clipped/', 'model': 'EOT20'}\n", - "Modelling tides using EOT20 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 12/12 [00:07<00:00, 1.61it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 12, 'parallel_max': 8, 'time': 8.45742416381836, 'points': 1000, 'points_per_split': 83, 'split_per_parallel': 1.5, 'directory': '/gdata1/data/tide_models_clipped/', 'model': 'EOT20'}\n", - "Modelling tides using EOT20 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 16/16 [00:07<00:00, 2.14it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 16, 'parallel_max': 8, 'time': 8.473357915878296, 'points': 1000, 'points_per_split': 62, 'split_per_parallel': 2.0, 'directory': '/gdata1/data/tide_models_clipped/', 'model': 'EOT20'}\n", - "Modelling tides using EOT20 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 20/20 [00:09<00:00, 2.07it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 20, 'parallel_max': 8, 'time': 10.66265320777893, 'points': 1000, 'points_per_split': 50, 'split_per_parallel': 2.5, 'directory': '/gdata1/data/tide_models_clipped/', 'model': 'EOT20'}\n", - "Modelling tides using EOT20\n", - "{'split': 1, 'parallel_max': 16, 'time': 4.76704740524292, 'points': 1000, 'points_per_split': 1000, 'split_per_parallel': 0.0625, 'directory': '/gdata1/data/tide_models_clipped/', 'model': 'EOT20'}\n", - "Modelling tides using EOT20 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 2/2 [00:04<00:00, 2.11s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 2, 'parallel_max': 16, 'time': 5.491879463195801, 'points': 1000, 'points_per_split': 500, 'split_per_parallel': 0.125, 'directory': '/gdata1/data/tide_models_clipped/', 'model': 'EOT20'}\n", - "Modelling tides using EOT20 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 3/3 [00:04<00:00, 1.38s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 3, 'parallel_max': 16, 'time': 5.422261476516724, 'points': 1000, 'points_per_split': 333, 'split_per_parallel': 0.1875, 'directory': '/gdata1/data/tide_models_clipped/', 'model': 'EOT20'}\n", - "Modelling tides using EOT20 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 4/4 [00:04<00:00, 1.14s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 4, 'parallel_max': 16, 'time': 5.856306552886963, 'points': 1000, 'points_per_split': 250, 'split_per_parallel': 0.25, 'directory': '/gdata1/data/tide_models_clipped/', 'model': 'EOT20'}\n", - "Modelling tides using EOT20 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 5/5 [00:04<00:00, 1.17it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 5, 'parallel_max': 16, 'time': 5.858165740966797, 'points': 1000, 'points_per_split': 200, 'split_per_parallel': 0.3125, 'directory': '/gdata1/data/tide_models_clipped/', 'model': 'EOT20'}\n", - "Modelling tides using EOT20 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 6/6 [00:04<00:00, 1.27it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 6, 'parallel_max': 16, 'time': 6.159771680831909, 'points': 1000, 'points_per_split': 166, 'split_per_parallel': 0.375, 'directory': '/gdata1/data/tide_models_clipped/', 'model': 'EOT20'}\n", - "Modelling tides using EOT20 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 8/8 [00:05<00:00, 1.45it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 8, 'parallel_max': 16, 'time': 6.990351438522339, 'points': 1000, 'points_per_split': 125, 'split_per_parallel': 0.5, 'directory': '/gdata1/data/tide_models_clipped/', 'model': 'EOT20'}\n", - "Modelling tides using EOT20 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 10/10 [00:05<00:00, 1.74it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 10, 'parallel_max': 16, 'time': 7.187536954879761, 'points': 1000, 'points_per_split': 100, 'split_per_parallel': 0.625, 'directory': '/gdata1/data/tide_models_clipped/', 'model': 'EOT20'}\n", - "Modelling tides using EOT20 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 12/12 [00:07<00:00, 1.64it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 12, 'parallel_max': 16, 'time': 8.789670705795288, 'points': 1000, 'points_per_split': 83, 'split_per_parallel': 0.75, 'directory': '/gdata1/data/tide_models_clipped/', 'model': 'EOT20'}\n", - "Modelling tides using EOT20 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 16/16 [00:06<00:00, 2.30it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 16, 'parallel_max': 16, 'time': 8.321991205215454, 'points': 1000, 'points_per_split': 62, 'split_per_parallel': 1.0, 'directory': '/gdata1/data/tide_models_clipped/', 'model': 'EOT20'}\n", - "Modelling tides using EOT20 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 20/20 [00:07<00:00, 2.79it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 20, 'parallel_max': 16, 'time': 8.487577199935913, 'points': 1000, 'points_per_split': 50, 'split_per_parallel': 1.25, 'directory': '/gdata1/data/tide_models_clipped/', 'model': 'EOT20'}\n", - "Modelling tides using EOT20\n", - "{'split': 1, 'parallel_max': 2, 'time': 21.68295192718506, 'points': 10000, 'points_per_split': 10000, 'split_per_parallel': 0.5, 'directory': '/gdata1/data/tide_models_clipped/', 'model': 'EOT20'}\n", - "Modelling tides using EOT20 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 2/2 [00:13<00:00, 6.52s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 2, 'parallel_max': 2, 'time': 14.026057481765747, 'points': 10000, 'points_per_split': 5000, 'split_per_parallel': 1.0, 'directory': '/gdata1/data/tide_models_clipped/', 'model': 'EOT20'}\n", - "Modelling tides using EOT20 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 3/3 [00:18<00:00, 6.11s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 3, 'parallel_max': 2, 'time': 19.17806053161621, 'points': 10000, 'points_per_split': 3333, 'split_per_parallel': 1.5, 'directory': '/gdata1/data/tide_models_clipped/', 'model': 'EOT20'}\n", - "Modelling tides using EOT20 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 4/4 [00:15<00:00, 3.84s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 4, 'parallel_max': 2, 'time': 16.2370023727417, 'points': 10000, 'points_per_split': 2500, 'split_per_parallel': 2.0, 'directory': '/gdata1/data/tide_models_clipped/', 'model': 'EOT20'}\n", - "Modelling tides using EOT20 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 5/5 [00:19<00:00, 3.95s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 5, 'parallel_max': 2, 'time': 20.611429691314697, 'points': 10000, 'points_per_split': 2000, 'split_per_parallel': 2.5, 'directory': '/gdata1/data/tide_models_clipped/', 'model': 'EOT20'}\n", - "Modelling tides using EOT20 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 6/6 [00:18<00:00, 3.04s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 6, 'parallel_max': 2, 'time': 19.21670365333557, 'points': 10000, 'points_per_split': 1666, 'split_per_parallel': 3.0, 'directory': '/gdata1/data/tide_models_clipped/', 'model': 'EOT20'}\n", - "Modelling tides using EOT20 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 8/8 [00:20<00:00, 2.61s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 8, 'parallel_max': 2, 'time': 21.765028953552246, 'points': 10000, 'points_per_split': 1250, 'split_per_parallel': 4.0, 'directory': '/gdata1/data/tide_models_clipped/', 'model': 'EOT20'}\n", - "Modelling tides using EOT20 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 10/10 [00:23<00:00, 2.34s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 10, 'parallel_max': 2, 'time': 24.29056668281555, 'points': 10000, 'points_per_split': 1000, 'split_per_parallel': 5.0, 'directory': '/gdata1/data/tide_models_clipped/', 'model': 'EOT20'}\n", - "Modelling tides using EOT20 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 12/12 [00:25<00:00, 2.16s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 12, 'parallel_max': 2, 'time': 26.943108081817627, 'points': 10000, 'points_per_split': 833, 'split_per_parallel': 6.0, 'directory': '/gdata1/data/tide_models_clipped/', 'model': 'EOT20'}\n", - "Modelling tides using EOT20 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 16/16 [00:30<00:00, 1.91s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 16, 'parallel_max': 2, 'time': 31.49936294555664, 'points': 10000, 'points_per_split': 625, 'split_per_parallel': 8.0, 'directory': '/gdata1/data/tide_models_clipped/', 'model': 'EOT20'}\n", - "Modelling tides using EOT20 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 20/20 [00:35<00:00, 1.78s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 20, 'parallel_max': 2, 'time': 36.52475309371948, 'points': 10000, 'points_per_split': 500, 'split_per_parallel': 10.0, 'directory': '/gdata1/data/tide_models_clipped/', 'model': 'EOT20'}\n", - "Modelling tides using EOT20\n", - "{'split': 1, 'parallel_max': 4, 'time': 21.668402433395386, 'points': 10000, 'points_per_split': 10000, 'split_per_parallel': 0.25, 'directory': '/gdata1/data/tide_models_clipped/', 'model': 'EOT20'}\n", - "Modelling tides using EOT20 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 2/2 [00:12<00:00, 6.43s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 2, 'parallel_max': 4, 'time': 13.828262329101562, 'points': 10000, 'points_per_split': 5000, 'split_per_parallel': 0.5, 'directory': '/gdata1/data/tide_models_clipped/', 'model': 'EOT20'}\n", - "Modelling tides using EOT20 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 3/3 [00:09<00:00, 3.29s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 3, 'parallel_max': 4, 'time': 10.802367448806763, 'points': 10000, 'points_per_split': 3333, 'split_per_parallel': 0.75, 'directory': '/gdata1/data/tide_models_clipped/', 'model': 'EOT20'}\n", - "Modelling tides using EOT20 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 4/4 [00:09<00:00, 2.30s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 4, 'parallel_max': 4, 'time': 10.173426866531372, 'points': 10000, 'points_per_split': 2500, 'split_per_parallel': 1.0, 'directory': '/gdata1/data/tide_models_clipped/', 'model': 'EOT20'}\n", - "Modelling tides using EOT20 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 5/5 [00:13<00:00, 2.77s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 5, 'parallel_max': 4, 'time': 14.819823741912842, 'points': 10000, 'points_per_split': 2000, 'split_per_parallel': 1.25, 'directory': '/gdata1/data/tide_models_clipped/', 'model': 'EOT20'}\n", - "Modelling tides using EOT20 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 6/6 [00:13<00:00, 2.27s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 6, 'parallel_max': 4, 'time': 14.693720817565918, 'points': 10000, 'points_per_split': 1666, 'split_per_parallel': 1.5, 'directory': '/gdata1/data/tide_models_clipped/', 'model': 'EOT20'}\n", - "Modelling tides using EOT20 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 8/8 [00:11<00:00, 1.49s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 8, 'parallel_max': 4, 'time': 12.84511137008667, 'points': 10000, 'points_per_split': 1250, 'split_per_parallel': 2.0, 'directory': '/gdata1/data/tide_models_clipped/', 'model': 'EOT20'}\n", - "Modelling tides using EOT20 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 10/10 [00:14<00:00, 1.48s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 10, 'parallel_max': 4, 'time': 15.768202543258667, 'points': 10000, 'points_per_split': 1000, 'split_per_parallel': 2.5, 'directory': '/gdata1/data/tide_models_clipped/', 'model': 'EOT20'}\n", - "Modelling tides using EOT20 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 12/12 [00:14<00:00, 1.18s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 12, 'parallel_max': 4, 'time': 15.13057255744934, 'points': 10000, 'points_per_split': 833, 'split_per_parallel': 3.0, 'directory': '/gdata1/data/tide_models_clipped/', 'model': 'EOT20'}\n", - "Modelling tides using EOT20 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 16/16 [00:16<00:00, 1.05s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 16, 'parallel_max': 4, 'time': 17.83345913887024, 'points': 10000, 'points_per_split': 625, 'split_per_parallel': 4.0, 'directory': '/gdata1/data/tide_models_clipped/', 'model': 'EOT20'}\n", - "Modelling tides using EOT20 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 20/20 [00:19<00:00, 1.02it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 20, 'parallel_max': 4, 'time': 20.75438380241394, 'points': 10000, 'points_per_split': 500, 'split_per_parallel': 5.0, 'directory': '/gdata1/data/tide_models_clipped/', 'model': 'EOT20'}\n", - "Modelling tides using EOT20\n", - "{'split': 1, 'parallel_max': 8, 'time': 21.766361236572266, 'points': 10000, 'points_per_split': 10000, 'split_per_parallel': 0.125, 'directory': '/gdata1/data/tide_models_clipped/', 'model': 'EOT20'}\n", - "Modelling tides using EOT20 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 2/2 [00:12<00:00, 6.27s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 2, 'parallel_max': 8, 'time': 13.665264129638672, 'points': 10000, 'points_per_split': 5000, 'split_per_parallel': 0.25, 'directory': '/gdata1/data/tide_models_clipped/', 'model': 'EOT20'}\n", - "Modelling tides using EOT20 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 3/3 [00:09<00:00, 3.28s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 3, 'parallel_max': 8, 'time': 10.947334051132202, 'points': 10000, 'points_per_split': 3333, 'split_per_parallel': 0.375, 'directory': '/gdata1/data/tide_models_clipped/', 'model': 'EOT20'}\n", - "Modelling tides using EOT20 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 4/4 [00:09<00:00, 2.32s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 4, 'parallel_max': 8, 'time': 10.52197265625, 'points': 10000, 'points_per_split': 2500, 'split_per_parallel': 0.5, 'directory': '/gdata1/data/tide_models_clipped/', 'model': 'EOT20'}\n", - "Modelling tides using EOT20 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 5/5 [00:08<00:00, 1.65s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 5, 'parallel_max': 8, 'time': 9.36280369758606, 'points': 10000, 'points_per_split': 2000, 'split_per_parallel': 0.625, 'directory': '/gdata1/data/tide_models_clipped/', 'model': 'EOT20'}\n", - "Modelling tides using EOT20 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 6/6 [00:08<00:00, 1.47s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 6, 'parallel_max': 8, 'time': 9.949939012527466, 'points': 10000, 'points_per_split': 1666, 'split_per_parallel': 0.75, 'directory': '/gdata1/data/tide_models_clipped/', 'model': 'EOT20'}\n", - "Modelling tides using EOT20 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 8/8 [00:09<00:00, 1.17s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 8, 'parallel_max': 8, 'time': 10.472018480300903, 'points': 10000, 'points_per_split': 1250, 'split_per_parallel': 1.0, 'directory': '/gdata1/data/tide_models_clipped/', 'model': 'EOT20'}\n", - "Modelling tides using EOT20 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 10/10 [00:10<00:00, 1.08s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 10, 'parallel_max': 8, 'time': 12.007705450057983, 'points': 10000, 'points_per_split': 1000, 'split_per_parallel': 1.25, 'directory': '/gdata1/data/tide_models_clipped/', 'model': 'EOT20'}\n", - "Modelling tides using EOT20 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 12/12 [00:10<00:00, 1.15it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 12, 'parallel_max': 8, 'time': 11.651570081710815, 'points': 10000, 'points_per_split': 833, 'split_per_parallel': 1.5, 'directory': '/gdata1/data/tide_models_clipped/', 'model': 'EOT20'}\n", - "Modelling tides using EOT20 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 16/16 [00:10<00:00, 1.53it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 16, 'parallel_max': 8, 'time': 11.755990266799927, 'points': 10000, 'points_per_split': 625, 'split_per_parallel': 2.0, 'directory': '/gdata1/data/tide_models_clipped/', 'model': 'EOT20'}\n", - "Modelling tides using EOT20 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 20/20 [00:13<00:00, 1.50it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 20, 'parallel_max': 8, 'time': 14.515588283538818, 'points': 10000, 'points_per_split': 500, 'split_per_parallel': 2.5, 'directory': '/gdata1/data/tide_models_clipped/', 'model': 'EOT20'}\n", - "Modelling tides using EOT20\n", - "{'split': 1, 'parallel_max': 16, 'time': 21.664205074310303, 'points': 10000, 'points_per_split': 10000, 'split_per_parallel': 0.0625, 'directory': '/gdata1/data/tide_models_clipped/', 'model': 'EOT20'}\n", - "Modelling tides using EOT20 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 2/2 [00:13<00:00, 6.54s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 2, 'parallel_max': 16, 'time': 14.494793891906738, 'points': 10000, 'points_per_split': 5000, 'split_per_parallel': 0.125, 'directory': '/gdata1/data/tide_models_clipped/', 'model': 'EOT20'}\n", - "Modelling tides using EOT20 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 3/3 [00:10<00:00, 3.45s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 3, 'parallel_max': 16, 'time': 11.869606494903564, 'points': 10000, 'points_per_split': 3333, 'split_per_parallel': 0.1875, 'directory': '/gdata1/data/tide_models_clipped/', 'model': 'EOT20'}\n", - "Modelling tides using EOT20 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 4/4 [00:09<00:00, 2.32s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 4, 'parallel_max': 16, 'time': 10.705569982528687, 'points': 10000, 'points_per_split': 2500, 'split_per_parallel': 0.25, 'directory': '/gdata1/data/tide_models_clipped/', 'model': 'EOT20'}\n", - "Modelling tides using EOT20 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 5/5 [00:08<00:00, 1.71s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 5, 'parallel_max': 16, 'time': 9.93360948562622, 'points': 10000, 'points_per_split': 2000, 'split_per_parallel': 0.3125, 'directory': '/gdata1/data/tide_models_clipped/', 'model': 'EOT20'}\n", - "Modelling tides using EOT20 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 6/6 [00:08<00:00, 1.37s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 6, 'parallel_max': 16, 'time': 9.642301559448242, 'points': 10000, 'points_per_split': 1666, 'split_per_parallel': 0.375, 'directory': '/gdata1/data/tide_models_clipped/', 'model': 'EOT20'}\n", - "Modelling tides using EOT20 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 8/8 [00:08<00:00, 1.09s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 8, 'parallel_max': 16, 'time': 10.17075800895691, 'points': 10000, 'points_per_split': 1250, 'split_per_parallel': 0.5, 'directory': '/gdata1/data/tide_models_clipped/', 'model': 'EOT20'}\n", - "Modelling tides using EOT20 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 10/10 [00:09<00:00, 1.05it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 10, 'parallel_max': 16, 'time': 10.977132320404053, 'points': 10000, 'points_per_split': 1000, 'split_per_parallel': 0.625, 'directory': '/gdata1/data/tide_models_clipped/', 'model': 'EOT20'}\n", - "Modelling tides using EOT20 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 12/12 [00:08<00:00, 1.35it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 12, 'parallel_max': 16, 'time': 10.468158721923828, 'points': 10000, 'points_per_split': 833, 'split_per_parallel': 0.75, 'directory': '/gdata1/data/tide_models_clipped/', 'model': 'EOT20'}\n", - "Modelling tides using EOT20 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 16/16 [00:09<00:00, 1.64it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 16, 'parallel_max': 16, 'time': 11.378776788711548, 'points': 10000, 'points_per_split': 625, 'split_per_parallel': 1.0, 'directory': '/gdata1/data/tide_models_clipped/', 'model': 'EOT20'}\n", - "Modelling tides using EOT20 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 20/20 [00:10<00:00, 1.83it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 20, 'parallel_max': 16, 'time': 12.403078317642212, 'points': 10000, 'points_per_split': 500, 'split_per_parallel': 1.25, 'directory': '/gdata1/data/tide_models_clipped/', 'model': 'EOT20'}\n", - "Modelling tides using EOT20\n", - "{'split': 1, 'parallel_max': 2, 'time': 206.48058152198792, 'points': 100000, 'points_per_split': 100000, 'split_per_parallel': 0.5, 'directory': '/gdata1/data/tide_models_clipped/', 'model': 'EOT20'}\n", - "Modelling tides using EOT20 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 2/2 [01:47<00:00, 53.84s/it] \n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 2, 'parallel_max': 2, 'time': 109.08918809890747, 'points': 100000, 'points_per_split': 50000, 'split_per_parallel': 1.0, 'directory': '/gdata1/data/tide_models_clipped/', 'model': 'EOT20'}\n", - "Modelling tides using EOT20 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 3/3 [02:19<00:00, 46.56s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 3, 'parallel_max': 2, 'time': 141.13791918754578, 'points': 100000, 'points_per_split': 33333, 'split_per_parallel': 1.5, 'directory': '/gdata1/data/tide_models_clipped/', 'model': 'EOT20'}\n", - "Modelling tides using EOT20 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 4/4 [01:40<00:00, 25.21s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 4, 'parallel_max': 2, 'time': 102.24982476234436, 'points': 100000, 'points_per_split': 25000, 'split_per_parallel': 2.0, 'directory': '/gdata1/data/tide_models_clipped/', 'model': 'EOT20'}\n", - "Modelling tides using EOT20 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 5/5 [02:04<00:00, 24.94s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 5, 'parallel_max': 2, 'time': 126.11200904846191, 'points': 100000, 'points_per_split': 20000, 'split_per_parallel': 2.5, 'directory': '/gdata1/data/tide_models_clipped/', 'model': 'EOT20'}\n", - "Modelling tides using EOT20 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 6/6 [01:43<00:00, 17.25s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 6, 'parallel_max': 2, 'time': 104.85350227355957, 'points': 100000, 'points_per_split': 16666, 'split_per_parallel': 3.0, 'directory': '/gdata1/data/tide_models_clipped/', 'model': 'EOT20'}\n", - "Modelling tides using EOT20 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 8/8 [01:46<00:00, 13.28s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 8, 'parallel_max': 2, 'time': 107.63330364227295, 'points': 100000, 'points_per_split': 12500, 'split_per_parallel': 4.0, 'directory': '/gdata1/data/tide_models_clipped/', 'model': 'EOT20'}\n", - "Modelling tides using EOT20 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 10/10 [01:49<00:00, 10.92s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 10, 'parallel_max': 2, 'time': 110.59881782531738, 'points': 100000, 'points_per_split': 10000, 'split_per_parallel': 5.0, 'directory': '/gdata1/data/tide_models_clipped/', 'model': 'EOT20'}\n", - "Modelling tides using EOT20 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 12/12 [01:51<00:00, 9.33s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 12, 'parallel_max': 2, 'time': 113.39743661880493, 'points': 100000, 'points_per_split': 8333, 'split_per_parallel': 6.0, 'directory': '/gdata1/data/tide_models_clipped/', 'model': 'EOT20'}\n", - "Modelling tides using EOT20 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 16/16 [01:57<00:00, 7.36s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 16, 'parallel_max': 2, 'time': 119.18248271942139, 'points': 100000, 'points_per_split': 6250, 'split_per_parallel': 8.0, 'directory': '/gdata1/data/tide_models_clipped/', 'model': 'EOT20'}\n", - "Modelling tides using EOT20 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 20/20 [02:03<00:00, 6.19s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 20, 'parallel_max': 2, 'time': 125.23232054710388, 'points': 100000, 'points_per_split': 5000, 'split_per_parallel': 10.0, 'directory': '/gdata1/data/tide_models_clipped/', 'model': 'EOT20'}\n", - "Modelling tides using EOT20\n", - "{'split': 1, 'parallel_max': 4, 'time': 207.57323265075684, 'points': 100000, 'points_per_split': 100000, 'split_per_parallel': 0.25, 'directory': '/gdata1/data/tide_models_clipped/', 'model': 'EOT20'}\n", - "Modelling tides using EOT20 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 2/2 [01:53<00:00, 56.52s/it] \n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 2, 'parallel_max': 4, 'time': 114.5426197052002, 'points': 100000, 'points_per_split': 50000, 'split_per_parallel': 0.5, 'directory': '/gdata1/data/tide_models_clipped/', 'model': 'EOT20'}\n", - "Modelling tides using EOT20 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 3/3 [01:11<00:00, 23.88s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 3, 'parallel_max': 4, 'time': 73.1483039855957, 'points': 100000, 'points_per_split': 33333, 'split_per_parallel': 0.75, 'directory': '/gdata1/data/tide_models_clipped/', 'model': 'EOT20'}\n", - "Modelling tides using EOT20 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 4/4 [00:54<00:00, 13.52s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 4, 'parallel_max': 4, 'time': 55.540321588516235, 'points': 100000, 'points_per_split': 25000, 'split_per_parallel': 1.0, 'directory': '/gdata1/data/tide_models_clipped/', 'model': 'EOT20'}\n", - "Modelling tides using EOT20 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 5/5 [01:24<00:00, 16.82s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 5, 'parallel_max': 4, 'time': 85.42603087425232, 'points': 100000, 'points_per_split': 20000, 'split_per_parallel': 1.25, 'directory': '/gdata1/data/tide_models_clipped/', 'model': 'EOT20'}\n", - "Modelling tides using EOT20 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 6/6 [01:09<00:00, 11.65s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 6, 'parallel_max': 4, 'time': 71.45185613632202, 'points': 100000, 'points_per_split': 16666, 'split_per_parallel': 1.5, 'directory': '/gdata1/data/tide_models_clipped/', 'model': 'EOT20'}\n", - "Modelling tides using EOT20 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 8/8 [00:55<00:00, 6.90s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 8, 'parallel_max': 4, 'time': 56.7194709777832, 'points': 100000, 'points_per_split': 12500, 'split_per_parallel': 2.0, 'directory': '/gdata1/data/tide_models_clipped/', 'model': 'EOT20'}\n", - "Modelling tides using EOT20 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 10/10 [01:07<00:00, 6.72s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 10, 'parallel_max': 4, 'time': 68.70168733596802, 'points': 100000, 'points_per_split': 10000, 'split_per_parallel': 2.5, 'directory': '/gdata1/data/tide_models_clipped/', 'model': 'EOT20'}\n", - "Modelling tides using EOT20 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 12/12 [00:58<00:00, 4.88s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 12, 'parallel_max': 4, 'time': 60.217631578445435, 'points': 100000, 'points_per_split': 8333, 'split_per_parallel': 3.0, 'directory': '/gdata1/data/tide_models_clipped/', 'model': 'EOT20'}\n", - "Modelling tides using EOT20 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 16/16 [01:01<00:00, 3.82s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 16, 'parallel_max': 4, 'time': 62.69625210762024, 'points': 100000, 'points_per_split': 6250, 'split_per_parallel': 4.0, 'directory': '/gdata1/data/tide_models_clipped/', 'model': 'EOT20'}\n", - "Modelling tides using EOT20 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 20/20 [01:05<00:00, 3.27s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 20, 'parallel_max': 4, 'time': 67.09255361557007, 'points': 100000, 'points_per_split': 5000, 'split_per_parallel': 5.0, 'directory': '/gdata1/data/tide_models_clipped/', 'model': 'EOT20'}\n", - "Modelling tides using EOT20\n", - "{'split': 1, 'parallel_max': 8, 'time': 206.0199911594391, 'points': 100000, 'points_per_split': 100000, 'split_per_parallel': 0.125, 'directory': '/gdata1/data/tide_models_clipped/', 'model': 'EOT20'}\n", - "Modelling tides using EOT20 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 2/2 [01:48<00:00, 54.06s/it] \n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 2, 'parallel_max': 8, 'time': 109.81371188163757, 'points': 100000, 'points_per_split': 50000, 'split_per_parallel': 0.25, 'directory': '/gdata1/data/tide_models_clipped/', 'model': 'EOT20'}\n", - "Modelling tides using EOT20 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 3/3 [01:11<00:00, 24.00s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 3, 'parallel_max': 8, 'time': 73.70318651199341, 'points': 100000, 'points_per_split': 33333, 'split_per_parallel': 0.375, 'directory': '/gdata1/data/tide_models_clipped/', 'model': 'EOT20'}\n", - "Modelling tides using EOT20 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 4/4 [00:53<00:00, 13.46s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 4, 'parallel_max': 8, 'time': 55.54593014717102, 'points': 100000, 'points_per_split': 25000, 'split_per_parallel': 0.5, 'directory': '/gdata1/data/tide_models_clipped/', 'model': 'EOT20'}\n", - "Modelling tides using EOT20 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 5/5 [00:44<00:00, 8.99s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 5, 'parallel_max': 8, 'time': 46.519240379333496, 'points': 100000, 'points_per_split': 20000, 'split_per_parallel': 0.625, 'directory': '/gdata1/data/tide_models_clipped/', 'model': 'EOT20'}\n", - "Modelling tides using EOT20 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 6/6 [00:38<00:00, 6.49s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 6, 'parallel_max': 8, 'time': 40.687695026397705, 'points': 100000, 'points_per_split': 16666, 'split_per_parallel': 0.75, 'directory': '/gdata1/data/tide_models_clipped/', 'model': 'EOT20'}\n", - "Modelling tides using EOT20 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 8/8 [00:31<00:00, 3.94s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 8, 'parallel_max': 8, 'time': 33.14250874519348, 'points': 100000, 'points_per_split': 12500, 'split_per_parallel': 1.0, 'directory': '/gdata1/data/tide_models_clipped/', 'model': 'EOT20'}\n", - "Modelling tides using EOT20 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 10/10 [00:45<00:00, 4.56s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 10, 'parallel_max': 8, 'time': 47.311853647232056, 'points': 100000, 'points_per_split': 10000, 'split_per_parallel': 1.25, 'directory': '/gdata1/data/tide_models_clipped/', 'model': 'EOT20'}\n", - "Modelling tides using EOT20 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 12/12 [00:40<00:00, 3.39s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 12, 'parallel_max': 8, 'time': 42.34663009643555, 'points': 100000, 'points_per_split': 8333, 'split_per_parallel': 1.5, 'directory': '/gdata1/data/tide_models_clipped/', 'model': 'EOT20'}\n", - "Modelling tides using EOT20 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 16/16 [00:34<00:00, 2.16s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 16, 'parallel_max': 8, 'time': 36.282265424728394, 'points': 100000, 'points_per_split': 6250, 'split_per_parallel': 2.0, 'directory': '/gdata1/data/tide_models_clipped/', 'model': 'EOT20'}\n", - "Modelling tides using EOT20 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 20/20 [00:41<00:00, 2.09s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 20, 'parallel_max': 8, 'time': 43.34943342208862, 'points': 100000, 'points_per_split': 5000, 'split_per_parallel': 2.5, 'directory': '/gdata1/data/tide_models_clipped/', 'model': 'EOT20'}\n", - "Modelling tides using EOT20\n", - "{'split': 1, 'parallel_max': 16, 'time': 206.40290689468384, 'points': 100000, 'points_per_split': 100000, 'split_per_parallel': 0.0625, 'directory': '/gdata1/data/tide_models_clipped/', 'model': 'EOT20'}\n", - "Modelling tides using EOT20 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 2/2 [01:48<00:00, 54.26s/it] \n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 2, 'parallel_max': 16, 'time': 110.53279614448547, 'points': 100000, 'points_per_split': 50000, 'split_per_parallel': 0.125, 'directory': '/gdata1/data/tide_models_clipped/', 'model': 'EOT20'}\n", - "Modelling tides using EOT20 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 3/3 [01:12<00:00, 24.10s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 3, 'parallel_max': 16, 'time': 74.35631084442139, 'points': 100000, 'points_per_split': 33333, 'split_per_parallel': 0.1875, 'directory': '/gdata1/data/tide_models_clipped/', 'model': 'EOT20'}\n", - "Modelling tides using EOT20 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 4/4 [00:54<00:00, 13.58s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 4, 'parallel_max': 16, 'time': 56.3756320476532, 'points': 100000, 'points_per_split': 25000, 'split_per_parallel': 0.25, 'directory': '/gdata1/data/tide_models_clipped/', 'model': 'EOT20'}\n", - "Modelling tides using EOT20 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 5/5 [00:46<00:00, 9.38s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 5, 'parallel_max': 16, 'time': 48.81891632080078, 'points': 100000, 'points_per_split': 20000, 'split_per_parallel': 0.3125, 'directory': '/gdata1/data/tide_models_clipped/', 'model': 'EOT20'}\n", - "Modelling tides using EOT20 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 6/6 [00:38<00:00, 6.35s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 6, 'parallel_max': 16, 'time': 40.126490116119385, 'points': 100000, 'points_per_split': 16666, 'split_per_parallel': 0.375, 'directory': '/gdata1/data/tide_models_clipped/', 'model': 'EOT20'}\n", - "Modelling tides using EOT20 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 8/8 [00:31<00:00, 3.97s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 8, 'parallel_max': 16, 'time': 33.65049457550049, 'points': 100000, 'points_per_split': 12500, 'split_per_parallel': 0.5, 'directory': '/gdata1/data/tide_models_clipped/', 'model': 'EOT20'}\n", - "Modelling tides using EOT20 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 10/10 [00:27<00:00, 2.77s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 10, 'parallel_max': 16, 'time': 29.807040452957153, 'points': 100000, 'points_per_split': 10000, 'split_per_parallel': 0.625, 'directory': '/gdata1/data/tide_models_clipped/', 'model': 'EOT20'}\n", - "Modelling tides using EOT20 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 12/12 [00:25<00:00, 2.10s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 12, 'parallel_max': 16, 'time': 27.244994163513184, 'points': 100000, 'points_per_split': 8333, 'split_per_parallel': 0.75, 'directory': '/gdata1/data/tide_models_clipped/', 'model': 'EOT20'}\n", - "Modelling tides using EOT20 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 16/16 [00:22<00:00, 1.38s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 16, 'parallel_max': 16, 'time': 24.17734694480896, 'points': 100000, 'points_per_split': 6250, 'split_per_parallel': 1.0, 'directory': '/gdata1/data/tide_models_clipped/', 'model': 'EOT20'}\n", - "Modelling tides using EOT20 in parallel\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 20/20 [00:29<00:00, 1.50s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'split': 20, 'parallel_max': 16, 'time': 32.10411834716797, 'points': 100000, 'points_per_split': 5000, 'split_per_parallel': 1.25, 'directory': '/gdata1/data/tide_models_clipped/', 'model': 'EOT20'}\n" - ] - } - ], + "outputs": [], "source": [ "import time\n", "\n", @@ -6728,7 +1354,7 @@ }, { "cell_type": "code", - "execution_count": 268, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -6741,7 +1367,7 @@ }, { "cell_type": "code", - "execution_count": 273, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -6750,20 +1376,9 @@ }, { "cell_type": "code", - "execution_count": 274, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "import matplotlib.pyplot as plt\n", "import seaborn as sns\n", @@ -6779,24 +1394,13 @@ "axes[1].set_title('Time by Points per split')\n", "\n", "plt.tight_layout()\n" - ] - }, - { - "cell_type": "code", - "execution_count": 233, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ "import matplotlib.pyplot as plt\n", "import seaborn as sns\n", @@ -6816,30 +1420,9 @@ }, { "cell_type": "code", - "execution_count": 64, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "Text(0.5, 1.0, 'Time by Splits per parallel')" - ] - }, - "execution_count": 64, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "data[\"split_per_parallel\"] = data[\"split\"] / data[\"parallel_max\"]\n", "\n", @@ -6855,47 +1438,18 @@ }, { "cell_type": "code", - "execution_count": 99, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 99, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "data.query(\"model == 'EOT20'\").query(\"parallel_max == 2\").query(\"points == 10000\").set_index(\"points_per_split\").time_per_point.plot()" ] }, { "cell_type": "code", - "execution_count": 266, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "16 12500.0\n" - ] - } - ], + "outputs": [], "source": [ "\n", "parallel_max = 16\n", @@ -6916,20 +1470,9 @@ }, { "cell_type": "code", - "execution_count": 140, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "1" - ] - }, - "execution_count": 140, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "def _parallel_splits(\n", " total_points,\n", @@ -6976,100 +1519,43 @@ }, { "cell_type": "code", - "execution_count": 107, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "ename": "NameError", - "evalue": "name 'pytest' is not defined", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mNameError\u001b[0m Traceback (most recent call last)", - "Cell \u001b[0;32mIn[107], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m \u001b[38;5;129m@pytest\u001b[39m\u001b[38;5;241m.\u001b[39mmark\u001b[38;5;241m.\u001b[39mparametrize(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mtotal_points, model_count, parallel_max, expected_splits\u001b[39m\u001b[38;5;124m\"\u001b[39m, [\n\u001b[1;32m 2\u001b[0m \u001b[38;5;66;03m# Basic cases\u001b[39;00m\n\u001b[1;32m 3\u001b[0m (\u001b[38;5;241m10000\u001b[39m, \u001b[38;5;241m2\u001b[39m, \u001b[38;5;241m8\u001b[39m, \u001b[38;5;241m4\u001b[39m), \u001b[38;5;66;03m# Standard case with explicit parallel_max\u001b[39;00m\n\u001b[1;32m 4\u001b[0m (\u001b[38;5;241m5000\u001b[39m, \u001b[38;5;241m1\u001b[39m, \u001b[38;5;241m4\u001b[39m, \u001b[38;5;241m4\u001b[39m), \u001b[38;5;66;03m# Single model case\u001b[39;00m\n\u001b[1;32m 5\u001b[0m \n\u001b[1;32m 6\u001b[0m \u001b[38;5;66;03m# Minimum split size cases\u001b[39;00m\n\u001b[1;32m 7\u001b[0m (\u001b[38;5;241m900\u001b[39m, \u001b[38;5;241m1\u001b[39m, \u001b[38;5;241m4\u001b[39m, \u001b[38;5;241m1\u001b[39m), \u001b[38;5;66;03m# Less than min_points_per_split\u001b[39;00m\n\u001b[1;32m 8\u001b[0m (\u001b[38;5;241m2000\u001b[39m, \u001b[38;5;241m2\u001b[39m, \u001b[38;5;241m2\u001b[39m, \u001b[38;5;241m1\u001b[39m), \u001b[38;5;66;03m# Just enough for 1 split with 2 models\u001b[39;00m\n\u001b[1;32m 9\u001b[0m \n\u001b[1;32m 10\u001b[0m \u001b[38;5;66;03m# Maximum parallelization cases\u001b[39;00m\n\u001b[1;32m 11\u001b[0m (\u001b[38;5;241m100000\u001b[39m, \u001b[38;5;241m2\u001b[39m, \u001b[38;5;241m4\u001b[39m, \u001b[38;5;241m2\u001b[39m), \u001b[38;5;66;03m# Limited by CPU cores / model_count\u001b[39;00m\n\u001b[1;32m 12\u001b[0m (\u001b[38;5;241m100000\u001b[39m, \u001b[38;5;241m4\u001b[39m, \u001b[38;5;241m8\u001b[39m, \u001b[38;5;241m2\u001b[39m), \u001b[38;5;66;03m# Testing with more models\u001b[39;00m\n\u001b[1;32m 13\u001b[0m \n\u001b[1;32m 14\u001b[0m \u001b[38;5;66;03m# Edge cases\u001b[39;00m\n\u001b[1;32m 15\u001b[0m (\u001b[38;5;241m1\u001b[39m, \u001b[38;5;241m1\u001b[39m, \u001b[38;5;241m1\u001b[39m, \u001b[38;5;241m1\u001b[39m), \u001b[38;5;66;03m# Minimum possible values\u001b[39;00m\n\u001b[1;32m 16\u001b[0m (\u001b[38;5;241m999999\u001b[39m, \u001b[38;5;241m1\u001b[39m, \u001b[38;5;241m8\u001b[39m, \u001b[38;5;241m8\u001b[39m), \u001b[38;5;66;03m# Large number of points\u001b[39;00m\n\u001b[1;32m 17\u001b[0m (\u001b[38;5;241m10000\u001b[39m, \u001b[38;5;241m8\u001b[39m, \u001b[38;5;241m8\u001b[39m, \u001b[38;5;241m1\u001b[39m), \u001b[38;5;66;03m# Many models relative to cores\u001b[39;00m\n\u001b[1;32m 18\u001b[0m ])\n\u001b[1;32m 19\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mtest_parallel_splits\u001b[39m(total_points, model_count, parallel_max, expected_splits):\n\u001b[1;32m 20\u001b[0m \u001b[38;5;250m \u001b[39m\u001b[38;5;124;03m\"\"\"\u001b[39;00m\n\u001b[1;32m 21\u001b[0m \u001b[38;5;124;03m Test the _parallel_splits function with various parameter combinations.\u001b[39;00m\n\u001b[1;32m 22\u001b[0m \u001b[38;5;124;03m \"\"\"\u001b[39;00m\n\u001b[1;32m 23\u001b[0m result \u001b[38;5;241m=\u001b[39m _parallel_splits(\n\u001b[1;32m 24\u001b[0m total_points\u001b[38;5;241m=\u001b[39mtotal_points,\n\u001b[1;32m 25\u001b[0m model_count\u001b[38;5;241m=\u001b[39mmodel_count,\n\u001b[1;32m 26\u001b[0m parallel_max\u001b[38;5;241m=\u001b[39mparallel_max,\n\u001b[1;32m 27\u001b[0m min_points_per_split\u001b[38;5;241m=\u001b[39mmin_points_per_split\n\u001b[1;32m 28\u001b[0m )\n", - "\u001b[0;31mNameError\u001b[0m: name 'pytest' is not defined" - ] - } - ], + "outputs": [], "source": [] }, { "cell_type": "code", - "execution_count": 83, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "10" - ] - }, - "execution_count": 83, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "(10.6666)" ] }, { "cell_type": "code", - "execution_count": 261, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "ename": "TypeError", - "evalue": "posix.cpu_count() takes no keyword arguments", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mTypeError\u001b[0m Traceback (most recent call last)", - "Cell \u001b[0;32mIn[261], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m \u001b[43mos\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mcpu_count\u001b[49m\u001b[43m(\u001b[49m\u001b[43maffinity\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[0;31mTypeError\u001b[0m: posix.cpu_count() takes no keyword arguments" - ] - } - ], + "outputs": [], "source": [ "os.cpu_count(affinity=True)" ] }, { "cell_type": "code", - "execution_count": 257, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "64" - ] - }, - "execution_count": 257, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "len(os.sched_getaffinity(0))" ] }, { "cell_type": "code", - "execution_count": 253, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "64" - ] - }, - "execution_count": 253, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "# os.cpu_count()\n", "\n", @@ -7080,7 +1566,7 @@ }, { "cell_type": "code", - "execution_count": 241, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -7092,467 +1578,51 @@ }, { "cell_type": "code", - "execution_count": 150, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Modelling tides with EOT20 in parallel (models: 1, splits: 10)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 0%| | 0/10 [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", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
tide_modeltide_height
timexy
2020-01-01 00:00:00.000000000145.907482-29.246355EOT200.276023
2020-01-04 16:43:38.181818181145.907482-29.246355EOT200.328505
2020-01-08 09:27:16.363636363145.907482-29.246355EOT200.246467
2020-01-12 02:10:54.545454545145.907482-29.246355EOT200.146102
2020-01-15 18:54:32.727272727145.907482-29.246355EOT20-0.367979
...............
2020-12-17 05:05:27.272727272149.345285-38.854142GOT5.5-0.498254
2020-12-20 21:49:05.454545456149.345285-38.854142GOT5.5-0.152091
2020-12-24 14:32:43.636363636149.345285-38.854142GOT5.5-0.169135
2020-12-28 07:16:21.818181816149.345285-38.854142GOT5.5-0.055665
2021-01-01 00:00:00.000000000149.345285-38.854142GOT5.50.655934
\n", - "

60000000 rows × 2 columns

\n", - "" - ], - "text/plain": [ - " tide_model tide_height\n", - "time x y \n", - "2020-01-01 00:00:00.000000000 145.907482 -29.246355 EOT20 0.276023\n", - "2020-01-04 16:43:38.181818181 145.907482 -29.246355 EOT20 0.328505\n", - "2020-01-08 09:27:16.363636363 145.907482 -29.246355 EOT20 0.246467\n", - "2020-01-12 02:10:54.545454545 145.907482 -29.246355 EOT20 0.146102\n", - "2020-01-15 18:54:32.727272727 145.907482 -29.246355 EOT20 -0.367979\n", - "... ... ...\n", - "2020-12-17 05:05:27.272727272 149.345285 -38.854142 GOT5.5 -0.498254\n", - "2020-12-20 21:49:05.454545456 149.345285 -38.854142 GOT5.5 -0.152091\n", - "2020-12-24 14:32:43.636363636 149.345285 -38.854142 GOT5.5 -0.169135\n", - "2020-12-28 07:16:21.818181816 149.345285 -38.854142 GOT5.5 -0.055665\n", - "2021-01-01 00:00:00.000000000 149.345285 -38.854142 GOT5.5 0.655934\n", - "\n", - "[60000000 rows x 2 columns]" - ] - }, - "execution_count": 78, - "metadata": {}, - "output_type": "execute_result" - } - ], + "\n", + "n = 10000\n", + "directory = \"/gdata1/data/tide_models_clipped/\"\n", + "directory = \"./tests/data/tide_models/\"\n", + "# models = [\"EOT20\", \"GOT5.5\", \"HAMTIDE11\"]\n", + "models = [\"EOT20\"]\n", + "\n", + "\n", + "start_time = time.time()\n", + "modelled_tides_df_linear = model_tides(\n", + " x = np.random.uniform(112.715430, 154.727149, n),\n", + " y = np.random.uniform(-44.199061, -10.035282, n),\n", + " time = pd.date_range(\"2020\", \"2021\", periods=100),\n", + " model=models,\n", + " method=\"linear\",\n", + " directory=directory,\n", + " parallel=True,\n", + " parallel_splits=\"auto\",\n", + " parallel_max=16,\n", + " crop=False,\n", + ")\n", + "split_time = time.time() - start_time\n", + "print(split_time)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ "modelled_tides_df_linear" ] }, { "cell_type": "code", - "execution_count": 206, + "execution_count": null, "metadata": {}, - "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", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
 splitparallel_maxtimepointspoints_per_splitsplit_per_paralleldirectorymodeltime_per_pointmodel_multiple
2751421.66840210000100000.250000/gdata1/data/tide_models_clipped/EOT200.002167False
2762413.8282621000050000.500000/gdata1/data/tide_models_clipped/EOT200.001383False
2773410.8023671000033330.750000/gdata1/data/tide_models_clipped/EOT200.001080False
2784410.1734271000025001.000000/gdata1/data/tide_models_clipped/EOT200.001017False
2795414.8198241000020001.250000/gdata1/data/tide_models_clipped/EOT200.001482False
2806414.6937211000016661.500000/gdata1/data/tide_models_clipped/EOT200.001469False
2818412.8451111000012502.000000/gdata1/data/tide_models_clipped/EOT200.001285False
28210415.7682031000010002.500000/gdata1/data/tide_models_clipped/EOT200.001577False
28312415.130573100008333.000000/gdata1/data/tide_models_clipped/EOT200.001513False
28416417.833459100006254.000000/gdata1/data/tide_models_clipped/EOT200.001783False
28520420.754384100005005.000000/gdata1/data/tide_models_clipped/EOT200.002075False
\n" - ], - "text/plain": [ - "" - ] - }, - "execution_count": 206, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "# n = 10000\n", "data.query(\"(points == @n) & (parallel_max == @parallel_max) & (~model_multiple)\").style.background_gradient(cmap=\"YlOrRd\", subset=\"time_per_point\")" @@ -7560,224 +1630,45 @@ }, { "cell_type": "code", - "execution_count": 214, + "execution_count": null, "metadata": {}, - "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", - "
model_multipleFalseTrue
0NaN3.243056
1NaN4.219347
2NaN6.260917
3NaN7.849068
4NaN9.473125
.........
34733.650495NaN
34829.807040NaN
34927.244994NaN
35024.177347NaN
35132.104118NaN
\n", - "

352 rows × 2 columns

\n", - "
" - ], - "text/plain": [ - "model_multiple False True \n", - "0 NaN 3.243056\n", - "1 NaN 4.219347\n", - "2 NaN 6.260917\n", - "3 NaN 7.849068\n", - "4 NaN 9.473125\n", - ".. ... ...\n", - "347 33.650495 NaN\n", - "348 29.807040 NaN\n", - "349 27.244994 NaN\n", - "350 24.177347 NaN\n", - "351 32.104118 NaN\n", - "\n", - "[352 rows x 2 columns]" - ] - }, - "execution_count": 214, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "data.pivot(columns=\"model_multiple\", values=\"time\")" ] }, { "cell_type": "code", - "execution_count": 221, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 221, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "data.query(\"(points == @n) & (parallel_max == @parallel_max) & (model_multiple)\").time.plot.hist()" ] }, { "cell_type": "code", - "execution_count": 225, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 225, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "data.query(\"(points == @n) & (parallel_max == @parallel_max) & (~model_multiple)\").time.plot.hist()" ] }, { "cell_type": "code", - "execution_count": 119, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 119, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAi8AAAGdCAYAAADaPpOnAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8hTgPZAAAACXBIWXMAAA9hAAAPYQGoP6dpAAAtfElEQVR4nO3dfXRU9b3v8c8QkgnFEJWQZEIkCYjAAa0YlIBKBEp4UKkPbUXXqbBUWg5gFcq1obaX4FICXlSuj0jFtBS50FvAgzes8lBItDy00YNVBCIqT3kqJxwJgk1CYN8/PERCkkkm+e3J7D3v11qzlnvmt3/z22x0Pn6/e894LMuyBAAA4BCdOnoBAAAAgSC8AAAARyG8AAAARyG8AAAARyG8AAAARyG8AAAARyG8AAAARyG8AAAAR+nc0QswrWvXrqqurlZERITi4+M7ejkAAKAVjh8/rnPnzik6OlpnzpzxO9bjtm/YjYiI0Pnz5zt6GQAAoA06deqkc+fO+R3jusrLhfDSqVMn+Xy+jl4OAABohfLycp0/f14REREtjnVdeImPj1dpaal8Pp9KSko6ejkAAKAVkpOTVVpa2qpLPrhgFwAAOArhBQAAOArhBQAAOArhBQAAOArhBQAAOArhBQAAOArhBQAAOArhBQAAOIrrvqQOAADY43R1nWat2aOjX/5Tva7oohfuG6zLooMfJQgvAACgRRNffk8flZyq3y6u+EqDcjbpuuRu2jDz1qCuhbYRAADw69LgcrGPSk5p4svvBXU9hBcAANCs09V1zQaXCz4qOaXT1XVBWhHhBQAANON0dZ1GLNraqrEzV71v82q+xTUvAACg3unqOs1c9b4KPz0hK4D9ig5/aduaLkV4AQAAkqTb/3ehPik/3ca9PUbX4g/hBQAAqE92vs61Y/+bUq8wtpaWcM0LAABh7HR1nVLbGVwk6aUH0o2spzWovAAAEKZGPbtFX/xXbbvnuS65W1C/rI7wAgBAGErNzjcyT0d8SR3hBQCAMHK6uk6Dcja1e56R18TppQfS+XkAAABgnzGL/6yDldXtnue65G7Ke2iogRW1DeEFAIAw4OQ20aUILwAAuJyJ4HJZVCft/uWYDmkTXarjVwAAAGxh6vqWgb7LlP9YpoEVmUF4AQDAhYbm5Osf7b+8JSTaRJcivAAA4CIVJ6uVsfDPRubamzM2JNpElwq9FQEAgDYxdVFuWvcobf8fY4zMZQfCCwAADmfq2hYpdKstFwvt1QEAAL/a90vQDR1eeLuReexGeAEAwKGueXKjas9ZRuZySnCR+FVpAAAc58IvQZsILpEeZwUXicoLAACOMv6FAu3/xxkjc+3OHq3Ey6ONzBVMhBcAABzC1N1EkvOqLRejbQQAQIi70CYyobMD20SXovICAEAIG7N4qw5W1hiZy6ltoksRXgAACFG0iZpG2wgAgBBEcGmereElNTVVHo+n0WPGjBlNji8oKGhy/IEDB+xcJgAAIaPiZLWx4LL18UzXBRfJ5rZRUVGRzp07V7+9d+9ejRkzRj/84Q/97ldcXKxu3brVb/fo0cO2NQIAECqotrSOreHl0tCxcOFC9enTR5mZmX73i4+P1+WXX27jygAACC2mgktUJ+nTBe4NLlIQr3mpra3VypUr9dBDD8nj8fgdO3jwYPl8Po0ePVrbt2/3O7ampkanTp2qf1iWma9JBgAgGD48fNJYcNmdPdr1wUUK4t1Gb7/9tk6ePKkpU6Y0O8bn82nZsmVKT09XTU2Nfv/732v06NEqKCjQiBEjmtwnNzdX8+fPt2nVAADYhzZR23isIJUqxo4dq6ioKL3zzjsB7XfnnXfK4/Fow4YNTb5eU1Ojmppv738fMGCAysrK1LNnT5WUlLRrzQAA2OGzitP63pJCI3NdFdNJ7z053shcHSk5OVmlpaWt+vwOSuXlyJEj2rp1q9atWxfwvhkZGVq5cmWzr3u9Xnm93vrtllpSAAB0JJPVlr05Y3VZdPh9ZVtQjjgvL0/x8fG6/fbAS1p79uyRz+ezYVUAAAQXbSIzbA8v58+fV15eniZPnqzOnRu+3dy5c1VaWqoVK1ZIkpYsWaLU1FQNHDiw/gLftWvXau3atXYvEwAA21ScrFbGwj8bmSu6s0cHnp5gZC6nsj28bN26VUePHtVDDz3U6LXy8nIdPXq0fru2tlZz5sxRaWmpunTpooEDByo/P18TJoT3SQIAOJfJaotbfpuovYJ2wW6wBHLBDwAAdqJN1HqBfH7z20YAABi27cMKY8El9YpI1weXQIXfJcoAANiIu4nsx58IAACG0CYKDtpGAAC008a/lRgLLoldCC4tofICAEA70CYKPv6EAABoI9pEHYO2EQAAATLZJrqqWyeCS4CovAAAEADaRB2PPzEAAFqJNlFoILwAANCCP+44pDnv7DMy15uT0jXq+kQjc4UrwgsAAH5QbQk9XLALAEAzCC6hicoLAACXmLWqQOs/OmNkrp8MT9AvJw4xMhe+QXgBAOAiVFtCH20jAAD+G8HFGai8AADC3uz/U6h1fz9tZK6U2M4qnDvWyFxoGuEFABDW+NI55+FPGAAQlnYeqNQDv/2rsfloEwUP4QUAEHZMVluenzhQ9wxPNTYfWkZ4AQCEFS7KdT7uNgIAhIWdByoJLi5B5QUA4HomQ8sbP7pB37vBZ2w+BI7wAgBwNaot7kPbCADgSts+rCC4uBSVFwCA65gMLQsm9NMDI642Nh/aj/ACAHAVqi3uR9sIAOAKW/+jnOASJqi8AAAcz2Roefnu63TH0KuMzQfzCC8AAEej2hJ+CC8AAEf62e//rA2fVBubj+DiHIQXAIDjmKy2PD3+Gv1rZl9j88F+hBcAgKPQJgJ3GwEAHGHdzsMEF0ii8gIAcADaRLgY4QUAENKotuBShBcAQEha+M4HWrqjwth8BBf3sPWal5ycHHk8ngaPxMREv/sUFhYqPT1d0dHR6t27t5YuXWrnEgEAISg1O99YcFny/UEEF5exvfIycOBAbd26tX47IiKi2bGHDh3ShAkTNHXqVK1cuVI7duzQ9OnT1aNHD9177712LxUAEAJoE6EltoeXzp07t1htuWDp0qXq1auXlixZIkkaMGCA3n//fS1evJjwAgAut6LgU/3PPx00Nh/Bxb1sDy8HDx5UUlKSvF6vhg4dqgULFqh3795Njt21a5eysrIaPDd27FgtX75cZ8+eVWRkZKN9ampqVFNTU79tWZbZAwAA2M5kteUPjwzTTVdfaWw+hB5br3kZOnSoVqxYoU2bNuk3v/mNKioqNHz4cJ04caLJ8RUVFUpISGjwXEJCgurq6lRZWdnkPrm5uYqNja1/lJWVGT8OAIB9TLeJCC7uZ2t4GT9+vO69915de+21+t73vqf8/G/+gv7ud79rdh+Px9Ng+0Il5dLnL5g7d66qqqrqH0lJSYZWDwCw0yOv53N9C9okqLdKd+3aVddee60OHmy6p5mYmKiKioZXlx8/flydO3dW9+7dm9zH6/XK6/XWbzcXcgAAocNkaFn9UIYyrmn6MwLuFNSfB6ipqdH+/fvl8/mafH3YsGHasmVLg+c2b96sIUOGNHm9CwDAeUxXWwgu4cfW8DJnzhwVFhbq0KFD+utf/6of/OAHOnXqlCZPnizpm5bPgw8+WD9+2rRpOnLkiGbPnq39+/frzTff1PLlyzVnzhw7lwkACII75tMmghm2to1KSkp0//33q7KyUj169FBGRoZ2796tlJQUSVJ5ebmOHj1aPz4tLU0bN27UrFmz9MorrygpKUkvvvgit0kDgMOZDC1Fv/yeenTztjwQruWxXHZvcXJyskpLS9WzZ0+VlJR09HIAIKz91+la3fD0lpYHthLVFvcK5POb3zYCANjCZLVFIrjgW4QXAIBxJoPLygdv0i3/0sPYfHA+wgsAwJjisq809sV3jc1HtQVNIbwAAIygTYRgIbwAANrNZHDZnT1aiZdHG5sP7kN4AQC02enqOg3K2WRsPqotaA3CCwCgTUxWW/7FK22cT3BB6xBeAAAB45ty0ZGC+ttGAABn2/i3EoILOhyVFwBAq5gMLdfHSG8/SXBB2xBeAAAtotqCUEJ4AQA0a+E7H2jpjgpj8xFcYALhBQDQJJPVlqFx0po5BBeYQXgBADRCmwihjPACAKiX/X93aPUHJ43NR3CBHQgvAABJZqst8ZL+RnCBTQgvAADaRHAUwgsAhLFHV2zVO/tqjM1HcEEwEF4AIEyZrLaM69tJSx8eb2w+wB/CCwCEIdpEcDLCCwCEkR8+m6+i/zI3H8EFHYHwAgBhwmS1ZWQvKW86wQUdg/ACAGGANhHchPACAC6WkZ0vc79MRHBBaOjU0QsAANgj1WBwGdyN4ILQQeUFAFyINhHcjPACAC5iMrRIBBeEJtpGAOASJoPL6FSCC0IXlRcAcAHaRAgnhBcAcLDvZueryuB8BBc4AW0jAHCoVIPBZUK/zgQXOAaVFwBwINpECGeEFwBwEO4mAmgbAYBjmAwutIngZFReAMABaBMB3yK8AEAIo00ENGZr2yg3N1c33nijYmJiFB8fr7vuukvFxcV+9ykoKJDH42n0OHDggJ1LBYCQYzK4/PJ7aQQXuIatlZfCwkLNmDFDN954o+rq6vTkk08qKytL+/btU9euXf3uW1xcrG7dutVv9+jRw86lAkDIOHT8jEY+X2BsPkIL3MbW8PKnP/2pwXZeXp7i4+P1wQcfaMSIEX73jY+P1+WXX27j6gAg9NAmAloW1LuNqqq++TqlK6+8ssWxgwcPls/n0+jRo7V9+/Zmx9XU1OjUqVP1D8uyjK0XAILJZHB5evw1BBe4VtDCi2VZmj17tm655RYNGjSo2XE+n0/Lli3T2rVrtW7dOvXr10+jR4/Wu+++2+T43NxcxcbG1j/KysrsOgQAsMXq9z43fjfRv2b2NTYfEGo8VpBKFTNmzFB+fr7+8pe/KDk5OaB977zzTnk8Hm3YsKHRazU1NaqpqanfHjBggMrKytSzZ0+VlJS0e90AYCfaRMA3kpOTVVpa2qrP76DcKv3oo49qw4YNevfddwMOLpKUkZGhlStXNvma1+uV1+ut3/Z4PG1eJwAEk8ngsuwHg5U1JMnYfEAoszW8WJalRx99VOvXr1dBQYHS0tLaNM+ePXvk8/kMrw4AOsaM325W/oGzxuaj2oJwY2t4mTFjhlatWqV///d/V0xMjCoqKiRJsbGx6tKliyRp7ty5Ki0t1YoVKyRJS5YsUWpqqgYOHKja2lqtXLlSa9eu1dq1a+1cKgAEBW0ioP1sDS+vvfaaJOm2225r8HxeXp6mTJkiSSovL9fRo0frX6utrdWcOXNUWlqqLl26aODAgcrPz9eECRPsXCoA2M5kcNk++zalxfv/vizArYJ2wW6wBHLBDwAEw13P5OvDr8zNR7UFbhRyF+wCQLiiTQSYR3gBAJvwS9CAPQgvAGAY1RbAXkH9eQAAcDuCC2A/Ki8AYAhtIiA4CC8A0E5UW4Dgom0EAO1AcAGCj8oLALQRbSKgYxBeACBAVFuAjkXbCAACQHABOh6VFwBoJdpEQGggvABAC6i2AKGFthEA+EFwAUIPlRcAaAZtIiA0EV4A4BJUW4DQRtsIAC5CcAFCH5UXAPhvtIkAZyC8AAh7VFsAZ6FtBCCsEVwA56HyAiBs0SYCnInwAiDsUG0BnI22EYCwQnABnI/KC4CwQZsIcAfCCwDXo9oCuAttIwCuRnAB3IfKCwDXok0EuBPhBYDrUG0B3I22EQBXIbgA7kflBYArEFqA8EHlBYDjEVyA8EJ4AeBoBBcg/NA2AuBIhBYgfFF5AeA4BBcgvBFeADgKwQUAbSMAjkBoAXABlRcAIY/gAuBiQQkvr776qtLS0hQdHa309HS99957fscXFhYqPT1d0dHR6t27t5YuXRqMZQIIQQQXAJeyvW20Zs0aPf7443r11Vd188036/XXX9f48eO1b98+9erVq9H4Q4cOacKECZo6dapWrlypHTt2aPr06erRo4fuvfdeu5cLIEQQWgA0x2NZlmXnGwwdOlQ33HCDXnvttfrnBgwYoLvuuku5ubmNxv/iF7/Qhg0btH///vrnpk2bpr///e/atWtXi++XnJys0tJS9ezZUyUlJWYOAkBQEVyA8BPI57etlZfa2lp98MEHys7ObvB8VlaWdu7c2eQ+u3btUlZWVoPnxo4dq+XLl+vs2bOKjIxs8FpNTY1qamrqt23OYgBsxi9BA2iJrde8VFZW6ty5c0pISGjwfEJCgioqKprcp6KiosnxdXV1qqysbDQ+NzdXsbGx9Y+ysjJzBwAgaFKz8wkuAFolKBfsejyeBtuWZTV6rqXxTT0vSXPnzlVVVVX9IykpycCKAQQTbSIAgbC1bRQXF6eIiIhGVZbjx483qq5ckJiY2OT4zp07q3v37o3Ge71eeb3e+m1/oQhA6KHaAiBQtlZeoqKilJ6eri1btjR4fsuWLRo+fHiT+wwbNqzR+M2bN2vIkCGNrncB4Fy0iQC0le1to9mzZ+uNN97Qm2++qf3792vWrFk6evSopk2bJumbts+DDz5YP37atGk6cuSIZs+erf379+vNN9/U8uXLNWfOHLuXCiBIaBMBaA/bv+flvvvu04kTJ/TUU0+pvLxcgwYN0saNG5WSkiJJKi8v19GjR+vHp6WlaePGjZo1a5ZeeeUVJSUl6cUXX+Q7XgCXoNoCoL1s/56XYON7XoDQRLUFgD+BfH7z20YAbEdwAWASvyoNwFa0iQCYRngBYAuqLQDsQtsIgHEEFwB2ovICwCjaRADsRngBYATVFgDBQtsIQLsRXAAEE5UXAO1CmwhAsBFeALQJ1RYAHYW2EYCAEVwAdCQqLwACQpsIQEcjvABoFaotAEIFbSMALSK4AAglVF4A+EWbCECoIbwAaBLVFgChirYRgEYILgBCGZUXAA3QJgIQ6ggvACRRbQHgHLSNABBcADgKlRcgzNEmAuA0hBcgTFFtAeBUtI2AMERwAeBkVF6AMPLinz7S8wXHjM1HaAHQEQgvQJig2gLALWgbAWGA4ALATai8AC72s9//WRs+qTY2H6EFQCggvAAuRbUFgFvRNgJcyGRw+cnwBIILgJBC5QVwkR+/mK/3yszNR2gBEIoIL4BL0CYCEC4IL4AL8BX/AMIJ4QVwsNHZ+frc4HwEFwBOQHgBHIo2EYBwRXgBHIg2EYBwRngBHOSm7HwdNzgfwQWAExFeAIegTQQA37DtS+oOHz6shx9+WGlpaerSpYv69OmjefPmqba21u9+U6ZMkcfjafDIyMiwa5mAI5huExFcADiZbZWXAwcO6Pz583r99dd19dVXa+/evZo6darOnDmjxYsX+9133LhxysvLq9+Oioqya5lASONuIgBozLbwMm7cOI0bN65+u3fv3iouLtZrr73WYnjxer1KTEy0a2mAI9AmAoCmBfWal6qqKl155ZUtjisoKFB8fLwuv/xyZWZm6plnnlF8fHyTY2tqalRTU1O/bVmWsfUCHYW7iQCgeUH7YcbPP/9cL730kqZNm+Z33Pjx4/XWW29p27Zteu6551RUVKRRo0Y1CCgXy83NVWxsbP2jrMzgD7sAQTYyO5/gAgAt8FgBlipycnI0f/58v2OKioo0ZMiQ+u2ysjJlZmYqMzNTb7zxRkALLC8vV0pKilavXq177rmn0euXVl4GDBigsrIy9ezZUyUlJQG9F9CRaBMBCGfJyckqLS1t1ed3wG2jmTNnatKkSX7HpKam1v9zWVmZRo4cqWHDhmnZsmWBvp18Pp9SUlJ08ODBJl/3er3yer312x6PJ+D3ADoa1RYAaL2Aw0tcXJzi4uJaNba0tFQjR45Uenq68vLy1KlT4F2qEydO6NixY/L5fAHvC4S69Ox8nTA4H8EFQDiw7ZqXsrIy3Xbbbbrqqqu0ePFi/ed//qcqKipUUVHRYFz//v21fv16SdLp06c1Z84c7dq1S4cPH1ZBQYHuvPNOxcXF6e6777ZrqUCHSCW4AECb2Ha30ebNm/XZZ5/ps88+U3JycoPXLr7Mpri4WFVVVZKkiIgIffzxx1qxYoVOnjwpn8+nkSNHas2aNYqJibFrqUDQ0SYCgLYL+ILdUBfIBT9AsN2cna9Sg/MRXAC4ha0X7AJoG+4mAgAzCC9AENAmAgBzCC+AjYZl56vc4HwEFwAgvAC2MVltiZL0KcEFACQRXgBb0CYCAPsQXgCDHnghXzv/YW4+ggsANEZ4AQwxWW25NUn6/c8ILgDQFMILYABtIgAIHsIL0A5ZT+br03Pm5iO4AEDLbPttI8DtUrPNBZfMZIILALQWlRegDWgTAUDHIbwAARj7q3wV15mbj+ACAIEjvACtZLLa8uwdA/SjW3obmw8AwgnhBWjB6eo6DcrZZGw+qi0A0D6EF8CPtOx8WQbnI7gAQPsRXoBmmGwTvXz3dbpj6FXG5gOAcEZ4AS5R8NE/NGXV+8bmo9oCAGYRXoCLmKy2SAQXALAD4QX4byaDy9vTbtb1qZcbmw8A8C3CC8Le7k9PaNKbu43NR7UFAOxFeEFYM1ltSZD0V4ILANiO8IKwxVf8A4Az8cOMCDu7Pz1BcAEAB6PygrBiMrT8i1faOJ/gAgDBRnhB2KDaAgDuQNsIrrfxbyUEFwBwESovcDWToeUHg7tp8X23GpsPANA2hBe4FtUWAHAn2kZwnVXvfkZwAQAXo/ICVzEZWn50Q6ye/dEtxuYDAJhBeIFrUG0BgPBA2wiO98af9xNcACCMUHmBo5kMLT8b0VOzJ1xvbD4AgD0IL3Asqi0AEJ5oG8Fxtn1YQXABgDBG5QWOYjK0vHjXtZqY0cvYfACA4LC18pKamiqPx9PgkZ2d7Xcfy7KUk5OjpKQkdenSRbfddps++eQTO5cJhzBdbSG4AIAz2d42euqpp1ReXl7/+NWvfuV3/LPPPqvnn39eL7/8soqKipSYmKgxY8boq6++snupCFGL8/fQJgIA1LO9bRQTE6PExMRWjbUsS0uWLNGTTz6pe+65R5L0u9/9TgkJCVq1apV++tOf2rlUhCCToeUnwxP0y4lDjM0HAOgYtldeFi1apO7du+v666/XM888o9ra2mbHHjp0SBUVFcrKyqp/zuv1KjMzUzt37mxyn5qaGp06dar+YVmW8WNAxzBdbSG4AIA72Fp5eeyxx3TDDTfoiiuu0N/+9jfNnTtXhw4d0htvvNHk+IqKCklSQkJCg+cTEhJ05MiRJvfJzc3V/PnzzS4cHer5jR/qxXdLjc1HmwgA3CXgyktOTk6ji3Avfbz//vuSpFmzZikzM1PXXXedHnnkES1dulTLly/XiRMn/L6Hx+NpsG1ZVqPnLpg7d66qqqrqH0lJSYEeEkJIana+seDy7B0DCC4A4EIBV15mzpypSZMm+R2Tmpra5PMZGRmSpM8++0zdu3dv9PqFa2MqKirk8/nqnz9+/HijaswFXq9XXq+3fru5kIPQx0W5AIDWCDi8xMXFKS4urk1vtmfPHklqEEwulpaWpsTERG3ZskWDBw+WJNXW1qqwsFCLFi1q03si9OWs/6t++9dKY/MRXADA3Wy75mXXrl3avXu3Ro4cqdjYWBUVFWnWrFmaOHGievX69vs1+vfvr9zcXN19993yeDx6/PHHtWDBAvXt21d9+/bVggUL9J3vfEcPPPCAXUtFBzJZbXliVIqmZw0yNh8AIDTZFl68Xq/WrFmj+fPnq6amRikpKZo6daqeeOKJBuOKi4tVVVVVv/3EE0/on//8p6ZPn64vv/xSQ4cO1ebNmxUTE2PXUtFBaBMBANrCY7ns3uLk5GSVlpaqZ8+eKikp6ejloAncTQQAuFQgn9/8thGCymS1ZdkPBitrCHeXAUC4IbwgaGgTAQBMsP0bdoHN75cRXAAAxlB5ga1MhpZNPxuhfklcuA0A4Y7wAltUfX1W331qs7H5qLYAAC4gvMC4ftn5qjE4H8EFAHAxwguMMtkm+sMjw3TT1Vcamw8A4A6EFxhxurpOg3I2GZuPagsAoDmEF7Tbddn5OmVwPoILAMAfwgvaxWSbaOvjmbo68TJj8wEA3InwgjahTQQA6CiEFwRsyK/yVVlnZq7pt/j0xB03mJkMABAWCC8ICN+UCwDoaPw8AFrldHUdwQUAEBKovKBFty74k46dOmdkrhX/eqNGDIo3MhcAIDwRXuAX1RYAQKihbYQmfVZxmuACAAhJVF7QiMnQsmBCPz0w4mpj8wEAQHhBA1RbAAChjrYRJHE3EQDAOai8QDfl5Ot4tZm5Vj+UoYxrupuZDACAJhBewhzVFgCA09A2ClO0iQAATkXlJQwNnZ+vf/zTzFz8EjQAINgIL2GGagsAwOloG4WJipPVBBcAgCtQeQkDV2fnq87QXLSJAAAdjfDiclRbAABuQ9vIpYrLviK4AABcicqLC5kMLbSJAAChhvDiMlRbAABuR9vIJT48fNJYcLkqphPBBQAQsqi8uIDJasvenLG6LJq/FgCA0MWnlMPRJgIAhBvaRg7FbxMBAMIVlRcHysz9k45UnTMyF3cTAQCcxrbKS0FBgTweT5OPoqKiZvebMmVKo/EZGRl2LdNxUrPzjQWXwwtvJ7gAABzHtsrL8OHDVV5e3uC5X//619q6dauGDBnid99x48YpLy+vfjsqKsqWNTrJ6eo6DcrZZGSuKztJ/7GANhEAwJlsCy9RUVFKTEys3z579qw2bNigmTNnyuPx+N3X6/U22DfcZT23XZ/+59dG5uJuIgCA0wXtU2zDhg2qrKzUlClTWhxbUFCg+Ph4XX755crMzNQzzzyj+Pj4JsfW1NSopqamftuyLFNLDglclAsAQENBu9to+fLlGjt2rK666iq/48aPH6+33npL27Zt03PPPaeioiKNGjWqQUC5WG5urmJjY+sfZWVldiw/6EzeTdQ3LprgAgBwDY8VYKkiJydH8+fP9zumqKiowXUtJSUlSklJ0R/+8Afde++9AS2wvLxcKSkpWr16te65555Gr19aeRkwYIDKysrUs2dPlZSUBPReoWLU/9qqL040HdYCRZsIAOAEycnJKi0tbdXnd8CfajNnztSkSZP8jklNTW2wnZeXp+7du2vixImBvp18Pp9SUlJ08ODBJl/3er3yer312y1dTxPqTFVb1v5kuNJ7X2FkLgAAQknA4SUuLk5xcXGtHm9ZlvLy8vTggw8qMjIy0LfTiRMndOzYMfl8voD3dZIPD5/UXUt3GJmLFhEAwM1sv+Zl27ZtOnTokB5++OEmX+/fv7/Wr18vSTp9+rTmzJmjXbt26fDhwyooKNCdd96puLg43X333XYvtcOkZucTXAAAaCXbL4ZYvny5hg8frgEDBjT5enFxsaqqqiRJERER+vjjj7VixQqdPHlSPp9PI0eO1Jo1axQTE2P3UjsEdxMBABAY28PLqlWr/L5+8fXCXbp00aZNZr6ILdSZ/NI5vuIfABBOuA2lA4x/oUD7/3HGyFxUWwAA4YbwEmS0iQAAaB/CS5CYvJto1ZShGt6/9Xd8AQDgJoSXIKDaAgCAOUH7eYBwRXABAMAsKi82qThZrYyFfzYyF3cTAQDwLcKLDa75Zb5qz5uZi2oLAAAN0TYyLDXbTHAZkNCV4AIAQBOovBhi8kvn+CVoAACaxyekAeOe364Dx79u9zx9e3TRlp+PMrAiAADci/DSTqbuJrouuZs2zLzVyFwAALgZ4aWNaBMBANAx+MRsg4kvv6ePSk61e57eV0Zp2xNjDKwIAIDwQXgJkKngQrUFAIC24dOzlU5X12nmqveNBBdugQYAoO0IL61gqtoiEVwAAGgvvqSuBaaCS984L8EFAAADqLz4cbq6rt3BpZOkj7i+BQAAY/hE9WPWmj3t2n+QL0b/77ERhlYDAAAkwotfR7/8Z5v35W4iAADswTUvfvS6okvA+0R6vrkol+ACAIA9CC9+vHDf4IDGD/LF6GAuF+UCAGAnygN+XBbdWdcld/N70a63s0cj+vbQC/cNptoCAEAQ8Gnbgg0zb232dml+TBEAgOAjvLTChpm36nR1nWat2aOjX/5Tva7oQqUFAIAOwqdvK10W3Vm/mXxjRy8DAICwxwW7AADAUQgvAADAUQgvAADAUQgvAADAUQgvAADAUQgvAADAUQgvAADAUQgvAADAUQgvAADAUTyWZVkdvQiToqKidPbsWXXq1Ek+n6+jlwMAAFqhvLxc58+fV2RkpGpra/2OdV14iYiI0Pnz5zt6GQAAoA06deqkc+fO+R3jut82io6OVnV1tSIiIhQfH9/Ry7GVZVkqKytTUlKSPB5PRy8nqDh2jp1jDx8ce3gc+/Hjx3Xu3DlFR0e3ONZ1lZdwcurUKcXGxqqqqkrdunXr6OUEFcfOsXPs4YNjD89j94cLdgEAgKMQXgAAgKMQXhzM6/Vq3rx58nq9Hb2UoOPYOfZww7Fz7PgW17wAAABHofICAAAchfACAAAchfACAAAchfACAAAchfDiEAUFBfJ4PE0+ioqKmt1vypQpjcZnZGQEceVmpKamNjqO7Oxsv/tYlqWcnBwlJSWpS5cuuu222/TJJ58EacVmHD58WA8//LDS0tLUpUsX9enTR/PmzWvxdz+cfN5fffVVpaWlKTo6Wunp6Xrvvff8ji8sLFR6erqio6PVu3dvLV26NEgrNSc3N1c33nijYmJiFB8fr7vuukvFxcV+92nuvwkHDhwI0qrNyMnJaXQMiYmJfvdxwzmXmv7vmsfj0YwZM5oc75ZzboLrfh7ArYYPH67y8vIGz/3617/W1q1bNWTIEL/7jhs3Tnl5efXbUVFRtqzRbk899ZSmTp1av33ZZZf5Hf/ss8/q+eef129/+1tdc801evrppzVmzBgVFxcrJibG7uUaceDAAZ0/f16vv/66rr76au3du1dTp07VmTNntHjxYr/7OvG8r1mzRo8//rheffVV3XzzzXr99dc1fvx47du3T7169Wo0/tChQ5owYYKmTp2qlStXaseOHZo+fbp69Oihe++9twOOoG0KCws1Y8YM3Xjjjaqrq9OTTz6prKws7du3T127dvW7b3FxcYNvXu3Ro4fdyzVu4MCB2rp1a/12REREs2Pdcs4lqaioqMFv+Ozdu1djxozRD3/4Q7/7ueGct5sFR6qtrbXi4+Otp556yu+4yZMnW9///veDsygbpaSkWC+88EKrx58/f95KTEy0Fi5cWP9cdXW1FRsbay1dutSGFQbPs88+a6Wlpfkd49TzftNNN1nTpk1r8Fz//v2t7OzsJsc/8cQTVv/+/Rs899Of/tTKyMiwbY3BcPz4cUuSVVhY2OyY7du3W5KsL7/8MngLs8G8efOs7373u60e79ZzblmW9dhjj1l9+vSxzp8/3+TrbjnnJtA2cqgNGzaosrJSU6ZMaXFsQUGB4uPjdc0112jq1Kk6fvy4/Qu0waJFi9S9e3ddf/31euaZZ/y2Tg4dOqSKigplZWXVP+f1epWZmamdO3cGY7m2qaqq0pVXXtniOKed99raWn3wwQcNzpkkZWVlNXvOdu3a1Wj82LFj9f777+vs2bO2rdVuVVVVktSq8zx48GD5fD6NHj1a27dvt3tptjh48KCSkpKUlpamSZMm6Ysvvmh2rFvPeW1trVauXKmHHnqoxR9gdMM5by/Ci0MtX75cY8eO1VVXXeV33Pjx4/XWW29p27Zteu6551RUVKRRo0appqYmSCs147HHHtPq1au1fft2zZw5U0uWLNH06dObHV9RUSFJSkhIaPB8QkJC/WtO9Pnnn+ull17StGnT/I5z4nmvrKzUuXPnAjpnFRUVTY6vq6tTZWWlbWu1k2VZmj17tm655RYNGjSo2XE+n0/Lli3T2rVrtW7dOvXr10+jR4/Wu+++G8TVtt/QoUO1YsUKbdq0Sb/5zW9UUVGh4cOH68SJE02Od+M5l6S3335bJ0+e9Ps/pG4550Z0dOkn3M2bN8+S5PdRVFTUYJ9jx45ZnTp1sv74xz8G/H5lZWVWZGSktXbtWlOH0GZtOfYL/vjHP1qSrMrKyiZf37FjhyXJKisra/D8I488Yo0dO9b4sQSqLcdeWlpqXX311dbDDz8c8PuF0nlvTmlpqSXJ2rlzZ4Pnn376aatfv35N7tO3b19rwYIFDZ77y1/+YkmyysvLbVurnaZPn26lpKRYx44dC3jfO+64w7rzzjttWFXwnD592kpISLCee+65Jl934zm3LMvKysqy7rjjjoD3c8M5bwsu2O1gM2fO1KRJk/yOSU1NbbCdl5en7t27a+LEiQG/n8/nU0pKig4ePBjwvqa15dgvuHDnzGeffabu3bs3ev3C3QoVFRXy+Xz1zx8/frzR/7V1hECPvaysTCNHjtSwYcO0bNmygN8vlM57c+Li4hQREdGoyuLvnCUmJjY5vnPnzk3+vQh1jz76qDZs2KB3331XycnJAe+fkZGhlStX2rCy4OnatauuvfbaZv+uuu2cS9KRI0e0detWrVu3LuB93XDO24Lw0sHi4uIUFxfX6vGWZSkvL08PPvigIiMjA36/EydO6NixYw0+0DtKoMd+sT179khSs8eRlpamxMREbdmyRYMHD5b0TU+5sLBQixYtatuCDQrk2EtLSzVy5Eilp6crLy9PnToF3u0NpfPenKioKKWnp2vLli26++6765/fsmWLvv/97ze5z7Bhw/TOO+80eG7z5s0aMmRIm/796CiWZenRRx/V+vXrVVBQoLS0tDbNs2fPnpA+x61RU1Oj/fv369Zbb23ydbec84vl5eUpPj5et99+e8D7uuGct0lHl34QmK1bt1qSrH379jX5er9+/ax169ZZlmVZX331lfXzn//c2rlzp3Xo0CFr+/bt1rBhw6yePXtap06dCuay22Xnzp3W888/b+3Zs8f64osvrDVr1lhJSUnWxIkTG4y7+Ngty7IWLlxoxcbGWuvWrbM+/vhj6/7777d8Pp+jjv1Cq2jUqFFWSUmJVV5eXv+4mFvO++rVq63IyEhr+fLl1r59+6zHH3/c6tq1q3X48GHLsiwrOzvb+vGPf1w//osvvrC+853vWLNmzbL27dtnLV++3IqMjGxTS7Uj/du//ZsVGxtrFRQUNDjHX3/9df2YS4/9hRdesNavX299+umn1t69e63s7GxLUki3Bpvy85//3CooKLC++OILa/fu3dYdd9xhxcTEuP6cX3Du3DmrV69e1i9+8YtGr7n1nJtAeHGY+++/3xo+fHizr0uy8vLyLMuyrK+//trKysqyevToYUVGRlq9evWyJk+ebB09ejRIqzXjgw8+sIYOHWrFxsZa0dHRVr9+/ax58+ZZZ86caTDu4mO3rG9ul543b56VmJhoeb1ea8SIEdbHH38c5NW3T15eXrPXxFzMTef9lVdesVJSUqyoqCjrhhtuaHC78OTJk63MzMwG4wsKCqzBgwdbUVFRVmpqqvXaa68FecXt19w5vvjv86XHvmjRIqtPnz5WdHS0dcUVV1i33HKLlZ+fH/zFt9N9991n+Xw+KzIy0kpKSrLuuece65NPPql/3a3n/IJNmzZZkqzi4uJGr7n1nJvgsSzLCnKxBwAAoM24VRoAADgK4QUAADgK4QUAADgK4QUAADgK4QUAADgK4QUAADgK4QUAADgK4QUAADgK4QUAADgK4QUAADgK4QUAADgK4QUAADjK/we3HmcC1KyjMgAAAABJRU5ErkJggg==", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "plt.scatter(modelled_tides_df_spline.droplevel([\"x\", \"y\"]).tide_height, modelled_tides_df_linear.droplevel([\"x\", \"y\"]).tide_height)" ] }, { "cell_type": "code", - "execution_count": 89, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Cropping to bounds: [149.722622, 149.722622, -22.132984, -22.132984]\n" - ] - } - ], + "outputs": [], "source": [ "# # Run equivalent pyTMD code to verify same results\n", "# pytmd_tides_spline = tide_elevations(\n", @@ -7813,54 +1704,18 @@ }, { "cell_type": "code", - "execution_count": 88, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "masked_array(data=[-1.5019747272607185, -1.094174075181175,\n", - " -0.36239775028562476, ..., -2.975406042155719,\n", - " -2.399842126206709, -1.1423142620897144],\n", - " mask=[False, False, False, ..., False, False, False],\n", - " fill_value=nan)" - ] - }, - "execution_count": 88, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "pytmd_tides_linear" ] }, { "cell_type": "code", - "execution_count": 51, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 51, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "import matplotlib.pyplot as plt\n", "plt.scatter(pytmd_tides_spline.data, pytmd_tides_linear.data)" @@ -7919,27 +1774,9 @@ }, { "cell_type": "code", - "execution_count": 145, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Modelling tides with EOT20\n" - ] - }, - { - "data": { - "text/plain": [ - "True" - ] - }, - "execution_count": 145, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "from eo_tides import model_tides\n", "\n", From c6da3fb2065ab9f7202fa43783327e7d82f1c137 Mon Sep 17 00:00:00 2001 From: Robbi Bishop-Taylor Date: Fri, 13 Dec 2024 06:23:57 +0000 Subject: [PATCH 03/10] Add buffer param, re-order --- eo_tides/model.py | 87 ++-- tests/testing.ipynb | 1008 ++++++++++++++++++++++++++++--------------- 2 files changed, 708 insertions(+), 387 deletions(-) diff --git a/eo_tides/model.py b/eo_tides/model.py index 1cd93bf..8d32cc1 100644 --- a/eo_tides/model.py +++ b/eo_tides/model.py @@ -115,7 +115,7 @@ def _ensemble_model( gpd.read_file(ranking_points, engine="pyogrio") .to_crs(crs) .query(f"valid_perc > {ranking_valid_perc}") - .dropna()[model_ranking_cols + ["geometry"]] + .dropna(how="all")[model_ranking_cols + ["geometry"]] ) except KeyError: error_msg = f""" @@ -248,12 +248,13 @@ def _model_tides( time, directory, crs, - crop, + mode, + output_units, method, extrapolate, cutoff, - output_units, - mode, + crop, + crop_buffer, ): """Worker function applied in parallel by `model_tides`. Handles the extraction of tide modelling constituents and tide modelling using @@ -276,11 +277,11 @@ def _model_tides( lat, type=pytmd_model.type, crop=crop, + buffer=crop_buffer, method=method, extrapolate=extrapolate, cutoff=cutoff, append_node=False, - # append_node=True, ) # TODO: Return constituents @@ -379,16 +380,17 @@ def model_tides( model: str | list[str] = "EOT20", directory: str | os.PathLike | None = None, crs: str = "EPSG:4326", - crop: bool = True, + mode: str = "one-to-many", + output_format: str = "long", + output_units: str = "m", method: str = "linear", extrapolate: bool = True, cutoff: float | None = None, - mode: str = "one-to-many", + crop: bool = True, + crop_buffer: float | None = None, parallel: bool = True, parallel_splits: int | str = "auto", parallel_max: int | None = None, - output_units: str = "m", - output_format: str = "long", ensemble_models: list[str] | None = None, **ensemble_kwargs, ) -> pd.DataFrame: @@ -442,10 +444,29 @@ def model_tides( crs : str, optional Input coordinate reference system for x and y coordinates. Defaults to "EPSG:4326" (WGS84; degrees latitude, longitude). - crop : bool, optional - Whether to crop tide model constituent files on-the-fly to - improve performance. Cropping will be performed based on a - 1 degree buffer around all input points. Defaults to True. + mode : str, optional + The analysis mode to use for tide modelling. Supports two options: + + - "one-to-many": Models tides for every timestep in "time" at + every input x and y coordinate point. This is useful if you + want to model tides for a specific list of timesteps across + multiple spatial points (e.g. for the same set of satellite + acquisition times at various locations across your study area). + - "one-to-one": Model tides using a unique timestep for each + set of x and y coordinates. In this mode, the number of x and + y points must equal the number of timesteps provided in "time". + output_format : str, optional + Whether to return the output dataframe in long format (with + results stacked vertically along "tide_model" and "tide_height" + columns), or wide format (with a column for each tide model). + Defaults to "long". + output_units : str, optional + Whether to return modelled tides in floating point metre units, + or integer centimetre units (i.e. scaled by 100) or integer + millimetre units (i.e. scaled by 1000. Returning outputs in + integer units can be useful for reducing memory usage. + Defaults to "m" for metres; set to "cm" for centimetres or "mm" + for millimetres. method : str, optional Method used to interpolate tidal constituents from model files. Defaults to "linear"; options include: @@ -460,18 +481,14 @@ def model_tides( Extrapolation cutoff in kilometers. The default is None, which will extrapolate for all points regardless of distance from the valid tide modelling domain. - mode : str, optional - The analysis mode to use for tide modelling. Supports two options: - - - "one-to-many": Models tides for every timestep in "time" at - every input x and y coordinate point. This is useful if you - want to model tides for a specific list of timesteps across - multiple spatial points (e.g. for the same set of satellite - acquisition times at various locations across your study area). - - "one-to-one": Model tides using a unique timestep for each - set of x and y coordinates. In this mode, the number of x and - y points must equal the number of timesteps provided in "time". - + crop : bool, optional + Whether to crop tide model constituent files on-the-fly to + improve performance. Defaults to True; set `crop_buffer` + to customise the buffer distance used to crop the files. + crop_buffer : int or float, optional + The buffer distance in degrees used to crop tide model + constituent files around the modelling area. Defaults to None, + which will apply a four model-domain pixel buffer. parallel : bool, optional Whether to parallelise tide modelling using `concurrent.futures`. If multiple tide models are requested, these will be run in @@ -488,18 +505,6 @@ def model_tides( parallel_max : int, optional Maximum number of processes to run in parallel. The default of None will automatically determine this from your available CPUs. - output_units : str, optional - Whether to return modelled tides in floating point metre units, - or integer centimetre units (i.e. scaled by 100) or integer - millimetre units (i.e. scaled by 1000. Returning outputs in - integer units can be useful for reducing memory usage. - Defaults to "m" for metres; set to "cm" for centimetres or "mm" - for millimetres. - output_format : str, optional - Whether to return the output dataframe in long format (with - results stacked vertically along "tide_model" and "tide_height" - columns), or wide format (with a column for each tide model). - Defaults to "long". ensemble_models : list of str, optional An optional list of models used to generate the ensemble tide model if "ensemble" tide modelling is requested. Defaults to @@ -563,12 +568,13 @@ def model_tides( _model_tides, directory=directory, crs=crs, - crop=crop, + mode=mode, + output_units=output_units, method=method, extrapolate=extrapolate, cutoff=np.inf if cutoff is None else cutoff, - output_units=output_units, - mode=mode, + crop=crop, + crop_buffer=crop_buffer, ) # If automatic parallel splits, calculate optimal value @@ -587,7 +593,6 @@ def model_tides( raise ValueError(f"Parallel splits ({parallel_splits}) cannot be larger than the number of points ({len(x)}).") # Parallelise if either multiple models or multiple splits requested - if parallel & ((len(models_to_process) > 1) | (parallel_splits > 1)): with ProcessPoolExecutor(max_workers=parallel_max) as executor: print( diff --git a/tests/testing.ipynb b/tests/testing.ipynb index 9de9529..c6bdabf 100644 --- a/tests/testing.ipynb +++ b/tests/testing.ipynb @@ -136,13 +136,212 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 3, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "/home/jovyan/Robbi/eo-tides\n" + ] + } + ], "source": [ "cd .." ] }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m============================= test session starts ==============================\u001b[0m\n", + "platform linux -- Python 3.10.15, pytest-8.3.3, pluggy-1.5.0 -- /env/bin/python3.10\n", + "cachedir: .pytest_cache\n", + "rootdir: /home/jovyan/Robbi/eo-tides\n", + "configfile: pyproject.toml\n", + "plugins: anyio-4.6.2.post1, nbval-0.11.0, dependency-0.6.0, cov-6.0.0\n", + "collected 40 items / 39 deselected / 1 selected \u001b[0m\u001b[1m\n", + "\n", + "tests/test_model.py::test_model_tides_ensemble \u001b[31mFAILED\u001b[0m\u001b[31m [100%]\u001b[0m\n", + "\n", + "=================================== FAILURES ===================================\n", + "\u001b[31m\u001b[1m__________________________ test_model_tides_ensemble ___________________________\u001b[0m\n", + "\n", + " \u001b[0m\u001b[94mdef\u001b[39;49;00m \u001b[92mtest_model_tides_ensemble\u001b[39;49;00m():\u001b[90m\u001b[39;49;00m\n", + " \u001b[90m# Input params\u001b[39;49;00m\u001b[90m\u001b[39;49;00m\n", + " good_hamtide11 = -\u001b[94m17.58549\u001b[39;49;00m, \u001b[94m123.59414\u001b[39;49;00m\u001b[90m\u001b[39;49;00m\n", + " good_eot20 = -\u001b[94m17.1611\u001b[39;49;00m, \u001b[94m123.3406\u001b[39;49;00m\u001b[90m\u001b[39;49;00m\n", + " y = [good_eot20[\u001b[94m0\u001b[39;49;00m], good_hamtide11[\u001b[94m0\u001b[39;49;00m]]\u001b[90m\u001b[39;49;00m\n", + " x = [good_eot20[\u001b[94m1\u001b[39;49;00m], good_hamtide11[\u001b[94m1\u001b[39;49;00m]]\u001b[90m\u001b[39;49;00m\n", + " \u001b[90m\u001b[39;49;00m\n", + " times = pd.date_range(\u001b[33m\"\u001b[39;49;00m\u001b[33m2020\u001b[39;49;00m\u001b[33m\"\u001b[39;49;00m, \u001b[33m\"\u001b[39;49;00m\u001b[33m2021\u001b[39;49;00m\u001b[33m\"\u001b[39;49;00m, periods=\u001b[94m2\u001b[39;49;00m)\u001b[90m\u001b[39;49;00m\n", + " \u001b[90m\u001b[39;49;00m\n", + " \u001b[90m# Default, only ensemble requested\u001b[39;49;00m\u001b[90m\u001b[39;49;00m\n", + " modelled_tides_df = model_tides(\u001b[90m\u001b[39;49;00m\n", + " x=x,\u001b[90m\u001b[39;49;00m\n", + " y=y,\u001b[90m\u001b[39;49;00m\n", + " time=times,\u001b[90m\u001b[39;49;00m\n", + " model=\u001b[33m\"\u001b[39;49;00m\u001b[33mensemble\u001b[39;49;00m\u001b[33m\"\u001b[39;49;00m,\u001b[90m\u001b[39;49;00m\n", + " ensemble_models=ENSEMBLE_MODELS,\u001b[90m\u001b[39;49;00m\n", + " )\u001b[90m\u001b[39;49;00m\n", + " \u001b[90m\u001b[39;49;00m\n", + " \u001b[94massert\u001b[39;49;00m modelled_tides_df.index.names == [\u001b[33m\"\u001b[39;49;00m\u001b[33mtime\u001b[39;49;00m\u001b[33m\"\u001b[39;49;00m, \u001b[33m\"\u001b[39;49;00m\u001b[33mx\u001b[39;49;00m\u001b[33m\"\u001b[39;49;00m, \u001b[33m\"\u001b[39;49;00m\u001b[33my\u001b[39;49;00m\u001b[33m\"\u001b[39;49;00m]\u001b[90m\u001b[39;49;00m\n", + " \u001b[94massert\u001b[39;49;00m modelled_tides_df.columns.tolist() == [\u001b[33m\"\u001b[39;49;00m\u001b[33mtide_model\u001b[39;49;00m\u001b[33m\"\u001b[39;49;00m, \u001b[33m\"\u001b[39;49;00m\u001b[33mtide_height\u001b[39;49;00m\u001b[33m\"\u001b[39;49;00m]\u001b[90m\u001b[39;49;00m\n", + " \u001b[94massert\u001b[39;49;00m \u001b[96mall\u001b[39;49;00m(modelled_tides_df.tide_model == \u001b[33m\"\u001b[39;49;00m\u001b[33mensemble\u001b[39;49;00m\u001b[33m\"\u001b[39;49;00m)\u001b[90m\u001b[39;49;00m\n", + " \u001b[90m\u001b[39;49;00m\n", + " \u001b[90m# Default, ensemble + other models requested\u001b[39;49;00m\u001b[90m\u001b[39;49;00m\n", + " models = [\u001b[33m\"\u001b[39;49;00m\u001b[33mEOT20\u001b[39;49;00m\u001b[33m\"\u001b[39;49;00m, \u001b[33m\"\u001b[39;49;00m\u001b[33mHAMTIDE11\u001b[39;49;00m\u001b[33m\"\u001b[39;49;00m, \u001b[33m\"\u001b[39;49;00m\u001b[33mensemble\u001b[39;49;00m\u001b[33m\"\u001b[39;49;00m]\u001b[90m\u001b[39;49;00m\n", + " modelled_tides_df = model_tides(\u001b[90m\u001b[39;49;00m\n", + " x=x,\u001b[90m\u001b[39;49;00m\n", + " y=y,\u001b[90m\u001b[39;49;00m\n", + " time=times,\u001b[90m\u001b[39;49;00m\n", + " model=models,\u001b[90m\u001b[39;49;00m\n", + " ensemble_models=ENSEMBLE_MODELS,\u001b[90m\u001b[39;49;00m\n", + " )\u001b[90m\u001b[39;49;00m\n", + " \u001b[90m\u001b[39;49;00m\n", + " \u001b[94massert\u001b[39;49;00m modelled_tides_df.index.names == [\u001b[33m\"\u001b[39;49;00m\u001b[33mtime\u001b[39;49;00m\u001b[33m\"\u001b[39;49;00m, \u001b[33m\"\u001b[39;49;00m\u001b[33mx\u001b[39;49;00m\u001b[33m\"\u001b[39;49;00m, \u001b[33m\"\u001b[39;49;00m\u001b[33my\u001b[39;49;00m\u001b[33m\"\u001b[39;49;00m]\u001b[90m\u001b[39;49;00m\n", + " \u001b[94massert\u001b[39;49;00m modelled_tides_df.columns.tolist() == [\u001b[33m\"\u001b[39;49;00m\u001b[33mtide_model\u001b[39;49;00m\u001b[33m\"\u001b[39;49;00m, \u001b[33m\"\u001b[39;49;00m\u001b[33mtide_height\u001b[39;49;00m\u001b[33m\"\u001b[39;49;00m]\u001b[90m\u001b[39;49;00m\n", + " \u001b[94massert\u001b[39;49;00m \u001b[96mset\u001b[39;49;00m(modelled_tides_df.tide_model) == \u001b[96mset\u001b[39;49;00m(models)\u001b[90m\u001b[39;49;00m\n", + " \u001b[94massert\u001b[39;49;00m np.allclose(\u001b[90m\u001b[39;49;00m\n", + " modelled_tides_df.tide_height.values,\u001b[90m\u001b[39;49;00m\n", + " [\u001b[90m\u001b[39;49;00m\n", + " \u001b[94m0.094\u001b[39;49;00m,\u001b[90m\u001b[39;49;00m\n", + " -\u001b[94m3.202\u001b[39;49;00m,\u001b[90m\u001b[39;49;00m\n", + " \u001b[94m0.409\u001b[39;49;00m,\u001b[90m\u001b[39;49;00m\n", + " -\u001b[94m3.098\u001b[39;49;00m,\u001b[90m\u001b[39;49;00m\n", + " \u001b[94m0.803\u001b[39;49;00m,\u001b[90m\u001b[39;49;00m\n", + " \u001b[94m0.664\u001b[39;49;00m,\u001b[90m\u001b[39;49;00m\n", + " \u001b[94m0.989\u001b[39;49;00m,\u001b[90m\u001b[39;49;00m\n", + " \u001b[94m1.011\u001b[39;49;00m,\u001b[90m\u001b[39;49;00m\n", + " \u001b[94m0.449\u001b[39;49;00m,\u001b[90m\u001b[39;49;00m\n", + " -\u001b[94m1.269\u001b[39;49;00m,\u001b[90m\u001b[39;49;00m\n", + " \u001b[94m0.699\u001b[39;49;00m,\u001b[90m\u001b[39;49;00m\n", + " -\u001b[94m1.043\u001b[39;49;00m,\u001b[90m\u001b[39;49;00m\n", + " ],\u001b[90m\u001b[39;49;00m\n", + " atol=\u001b[94m0.02\u001b[39;49;00m,\u001b[90m\u001b[39;49;00m\n", + " )\u001b[90m\u001b[39;49;00m\n", + " \u001b[90m\u001b[39;49;00m\n", + " \u001b[90m# One-to-one mode\u001b[39;49;00m\u001b[90m\u001b[39;49;00m\n", + " modelled_tides_df = model_tides(\u001b[90m\u001b[39;49;00m\n", + " x=x,\u001b[90m\u001b[39;49;00m\n", + " y=y,\u001b[90m\u001b[39;49;00m\n", + " time=times,\u001b[90m\u001b[39;49;00m\n", + " model=models,\u001b[90m\u001b[39;49;00m\n", + " mode=\u001b[33m\"\u001b[39;49;00m\u001b[33mone-to-one\u001b[39;49;00m\u001b[33m\"\u001b[39;49;00m,\u001b[90m\u001b[39;49;00m\n", + " ensemble_models=ENSEMBLE_MODELS,\u001b[90m\u001b[39;49;00m\n", + " )\u001b[90m\u001b[39;49;00m\n", + " \u001b[90m\u001b[39;49;00m\n", + " \u001b[94massert\u001b[39;49;00m modelled_tides_df.index.names == [\u001b[33m\"\u001b[39;49;00m\u001b[33mtime\u001b[39;49;00m\u001b[33m\"\u001b[39;49;00m, \u001b[33m\"\u001b[39;49;00m\u001b[33mx\u001b[39;49;00m\u001b[33m\"\u001b[39;49;00m, \u001b[33m\"\u001b[39;49;00m\u001b[33my\u001b[39;49;00m\u001b[33m\"\u001b[39;49;00m]\u001b[90m\u001b[39;49;00m\n", + " \u001b[94massert\u001b[39;49;00m modelled_tides_df.columns.tolist() == [\u001b[33m\"\u001b[39;49;00m\u001b[33mtide_model\u001b[39;49;00m\u001b[33m\"\u001b[39;49;00m, \u001b[33m\"\u001b[39;49;00m\u001b[33mtide_height\u001b[39;49;00m\u001b[33m\"\u001b[39;49;00m]\u001b[90m\u001b[39;49;00m\n", + " \u001b[94massert\u001b[39;49;00m \u001b[96mset\u001b[39;49;00m(modelled_tides_df.tide_model) == \u001b[96mset\u001b[39;49;00m(models)\u001b[90m\u001b[39;49;00m\n", + " \u001b[90m\u001b[39;49;00m\n", + " \u001b[90m# Wide mode, default\u001b[39;49;00m\u001b[90m\u001b[39;49;00m\n", + " modelled_tides_df = model_tides(\u001b[90m\u001b[39;49;00m\n", + " x=x,\u001b[90m\u001b[39;49;00m\n", + " y=y,\u001b[90m\u001b[39;49;00m\n", + " time=times,\u001b[90m\u001b[39;49;00m\n", + " model=models,\u001b[90m\u001b[39;49;00m\n", + " output_format=\u001b[33m\"\u001b[39;49;00m\u001b[33mwide\u001b[39;49;00m\u001b[33m\"\u001b[39;49;00m,\u001b[90m\u001b[39;49;00m\n", + " ensemble_models=ENSEMBLE_MODELS,\u001b[90m\u001b[39;49;00m\n", + " )\u001b[90m\u001b[39;49;00m\n", + " \u001b[90m\u001b[39;49;00m\n", + " \u001b[90m# Check that expected models exist, and that ensemble is approx average\u001b[39;49;00m\u001b[90m\u001b[39;49;00m\n", + " \u001b[90m# of other two models\u001b[39;49;00m\u001b[90m\u001b[39;49;00m\n", + " \u001b[94massert\u001b[39;49;00m \u001b[96mset\u001b[39;49;00m(modelled_tides_df.columns) == \u001b[96mset\u001b[39;49;00m(models)\u001b[90m\u001b[39;49;00m\n", + " \u001b[94massert\u001b[39;49;00m np.allclose(\u001b[90m\u001b[39;49;00m\n", + " \u001b[94m0.5\u001b[39;49;00m * (modelled_tides_df.EOT20 + modelled_tides_df.HAMTIDE11),\u001b[90m\u001b[39;49;00m\n", + " modelled_tides_df.ensemble,\u001b[90m\u001b[39;49;00m\n", + " )\u001b[90m\u001b[39;49;00m\n", + " \u001b[90m\u001b[39;49;00m\n", + " \u001b[90m# Wide mode, top n == 1\u001b[39;49;00m\u001b[90m\u001b[39;49;00m\n", + " modelled_tides_df = model_tides(\u001b[90m\u001b[39;49;00m\n", + " x=x,\u001b[90m\u001b[39;49;00m\n", + " y=y,\u001b[90m\u001b[39;49;00m\n", + " time=times,\u001b[90m\u001b[39;49;00m\n", + " model=models,\u001b[90m\u001b[39;49;00m\n", + " output_format=\u001b[33m\"\u001b[39;49;00m\u001b[33mwide\u001b[39;49;00m\u001b[33m\"\u001b[39;49;00m,\u001b[90m\u001b[39;49;00m\n", + " ensemble_top_n=\u001b[94m1\u001b[39;49;00m,\u001b[90m\u001b[39;49;00m\n", + " ensemble_models=ENSEMBLE_MODELS,\u001b[90m\u001b[39;49;00m\n", + " )\u001b[90m\u001b[39;49;00m\n", + " \u001b[90m\u001b[39;49;00m\n", + " \u001b[90m# Check that expected models exist, and that ensemble is equal to at\u001b[39;49;00m\u001b[90m\u001b[39;49;00m\n", + " \u001b[90m# least one of the other models\u001b[39;49;00m\u001b[90m\u001b[39;49;00m\n", + " \u001b[94massert\u001b[39;49;00m \u001b[96mset\u001b[39;49;00m(modelled_tides_df.columns) == \u001b[96mset\u001b[39;49;00m(models)\u001b[90m\u001b[39;49;00m\n", + " \u001b[94massert\u001b[39;49;00m \u001b[96mall\u001b[39;49;00m(\u001b[90m\u001b[39;49;00m\n", + " (modelled_tides_df.EOT20 == modelled_tides_df.ensemble)\u001b[90m\u001b[39;49;00m\n", + " | (modelled_tides_df.HAMTIDE11 == modelled_tides_df.ensemble)\u001b[90m\u001b[39;49;00m\n", + " )\u001b[90m\u001b[39;49;00m\n", + " \u001b[90m\u001b[39;49;00m\n", + " \u001b[90m# Check that correct model is the closest at each row\u001b[39;49;00m\u001b[90m\u001b[39;49;00m\n", + " closer_model = modelled_tides_df.apply(\u001b[90m\u001b[39;49;00m\n", + " \u001b[94mlambda\u001b[39;49;00m row: (\u001b[90m\u001b[39;49;00m\n", + " \u001b[33m\"\u001b[39;49;00m\u001b[33mEOT20\u001b[39;49;00m\u001b[33m\"\u001b[39;49;00m \u001b[94mif\u001b[39;49;00m \u001b[96mabs\u001b[39;49;00m(row[\u001b[33m\"\u001b[39;49;00m\u001b[33mensemble\u001b[39;49;00m\u001b[33m\"\u001b[39;49;00m] - row[\u001b[33m\"\u001b[39;49;00m\u001b[33mEOT20\u001b[39;49;00m\u001b[33m\"\u001b[39;49;00m]) < \u001b[96mabs\u001b[39;49;00m(row[\u001b[33m\"\u001b[39;49;00m\u001b[33mensemble\u001b[39;49;00m\u001b[33m\"\u001b[39;49;00m] - row[\u001b[33m\"\u001b[39;49;00m\u001b[33mHAMTIDE11\u001b[39;49;00m\u001b[33m\"\u001b[39;49;00m]) \u001b[94melse\u001b[39;49;00m \u001b[33m\"\u001b[39;49;00m\u001b[33mHAMTIDE11\u001b[39;49;00m\u001b[33m\"\u001b[39;49;00m\u001b[90m\u001b[39;49;00m\n", + " ),\u001b[90m\u001b[39;49;00m\n", + " axis=\u001b[94m1\u001b[39;49;00m,\u001b[90m\u001b[39;49;00m\n", + " ).tolist()\u001b[90m\u001b[39;49;00m\n", + "> \u001b[94massert\u001b[39;49;00m closer_model == [\u001b[33m\"\u001b[39;49;00m\u001b[33mEOT20\u001b[39;49;00m\u001b[33m\"\u001b[39;49;00m, \u001b[33m\"\u001b[39;49;00m\u001b[33mHAMTIDE11\u001b[39;49;00m\u001b[33m\"\u001b[39;49;00m, \u001b[33m\"\u001b[39;49;00m\u001b[33mEOT20\u001b[39;49;00m\u001b[33m\"\u001b[39;49;00m, \u001b[33m\"\u001b[39;49;00m\u001b[33mHAMTIDE11\u001b[39;49;00m\u001b[33m\"\u001b[39;49;00m]\u001b[90m\u001b[39;49;00m\n", + "\u001b[1m\u001b[31mE AssertionError: assert ['EOT20', 'EO...T20', 'EOT20'] == ['EOT20', 'HA..., 'HAMTIDE11']\u001b[0m\n", + "\u001b[1m\u001b[31mE \u001b[0m\n", + "\u001b[1m\u001b[31mE At index 1 diff: \u001b[0m\u001b[33m'\u001b[39;49;00m\u001b[33mEOT20\u001b[39;49;00m\u001b[33m'\u001b[39;49;00m\u001b[90m\u001b[39;49;00m != \u001b[0m\u001b[33m'\u001b[39;49;00m\u001b[33mHAMTIDE11\u001b[39;49;00m\u001b[33m'\u001b[39;49;00m\u001b[90m\u001b[39;49;00m\u001b[0m\n", + "\u001b[1m\u001b[31mE \u001b[0m\n", + "\u001b[1m\u001b[31mE Full diff:\u001b[0m\n", + "\u001b[1m\u001b[31mE \u001b[0m\u001b[90m \u001b[39;49;00m [\u001b[90m\u001b[39;49;00m\u001b[0m\n", + "\u001b[1m\u001b[31mE \u001b[90m \u001b[39;49;00m 'EOT20',\u001b[90m\u001b[39;49;00m\u001b[0m\n", + "\u001b[1m\u001b[31mE \u001b[91m- 'HAMTIDE11',\u001b[39;49;00m\u001b[90m\u001b[39;49;00m...\u001b[0m\n", + "\u001b[1m\u001b[31mE \u001b[0m\n", + "\u001b[1m\u001b[31mE ...Full output truncated (5 lines hidden), use '-vv' to show\u001b[0m\n", + "\n", + "\u001b[1m\u001b[31mtests/test_model.py\u001b[0m:377: AssertionError\n", + "----------------------------- Captured stdout call -----------------------------\n", + "Running ensemble tide modelling\n", + "Modelling tides with EOT20, HAMTIDE11 in parallel (models: 2, splits: 1)\n", + "Interpolating model rankings using IDW interpolation \n", + "Combining models into single ensemble model\n", + "Running ensemble tide modelling\n", + "Modelling tides with EOT20, HAMTIDE11 in parallel (models: 2, splits: 1)\n", + "Interpolating model rankings using IDW interpolation \n", + "Combining models into single ensemble model\n", + "Running ensemble tide modelling\n", + "Modelling tides with EOT20, HAMTIDE11 in parallel (models: 2, splits: 1)\n", + "Interpolating model rankings using IDW interpolation \n", + "Combining models into single ensemble model\n", + "Running ensemble tide modelling\n", + "Modelling tides with EOT20, HAMTIDE11 in parallel (models: 2, splits: 1)\n", + "Interpolating model rankings using IDW interpolation \n", + "Combining models into single ensemble model\n", + "Converting to a wide format dataframe\n", + "Running ensemble tide modelling\n", + "Modelling tides with EOT20, HAMTIDE11 in parallel (models: 2, splits: 1)\n", + "Interpolating model rankings using IDW interpolation \n", + "Combining models into single ensemble model\n", + "Converting to a wide format dataframe\n", + "----------------------------- Captured stderr call -----------------------------\n", + "100%|██████████| 2/2 [00:00<00:00, 14.59it/s]\n", + "100%|██████████| 2/2 [00:00<00:00, 16.97it/s]\n", + "100%|██████████| 2/2 [00:00<00:00, 17.09it/s]\n", + "100%|██████████| 2/2 [00:00<00:00, 17.76it/s]\n", + "100%|██████████| 2/2 [00:00<00:00, 17.48it/s]\n", + "\u001b[33m=============================== warnings summary ===============================\u001b[0m\n", + ":241\n", + " :241: RuntimeWarning: numpy.ndarray size changed, may indicate binary incompatibility. Expected 16 from C header, got 96 from PyObject\n", + "\n", + "-- Docs: https://docs.pytest.org/en/stable/how-to/capture-warnings.html\n", + "\u001b[36m\u001b[1m=========================== short test summary info ============================\u001b[0m\n", + "\u001b[31mFAILED\u001b[0m tests/test_model.py::\u001b[1mtest_model_tides_ensemble\u001b[0m - AssertionError: assert ['EOT20', 'EO...T20', 'EOT20'] == ['EOT20', 'HA..., ...\n", + "\u001b[31m================= \u001b[31m\u001b[1m1 failed\u001b[0m, \u001b[33m39 deselected\u001b[0m, \u001b[33m1 warning\u001b[0m\u001b[31m in 13.68s\u001b[0m\u001b[31m =================\u001b[0m\n" + ] + } + ], + "source": [ + "!export EO_TIDES_TIDE_MODELS=./tests/data/tide_models && pytest tests/test_model.py --verbose -k test_model_tides_ensemble" + ] + }, { "cell_type": "code", "execution_count": null, @@ -170,56 +369,210 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 8, "metadata": {}, - "outputs": [], + "outputs": [ + { + "ename": "AssertionError", + "evalue": "", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mAssertionError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[0;32mIn[8], line 122\u001b[0m\n\u001b[1;32m 115\u001b[0m \u001b[38;5;66;03m# Check that correct model is the closest at each row\u001b[39;00m\n\u001b[1;32m 116\u001b[0m closer_model \u001b[38;5;241m=\u001b[39m modelled_tides_df\u001b[38;5;241m.\u001b[39mapply(\n\u001b[1;32m 117\u001b[0m \u001b[38;5;28;01mlambda\u001b[39;00m row: (\n\u001b[1;32m 118\u001b[0m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mEOT20\u001b[39m\u001b[38;5;124m\"\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mabs\u001b[39m(row[\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mensemble\u001b[39m\u001b[38;5;124m\"\u001b[39m] \u001b[38;5;241m-\u001b[39m row[\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mEOT20\u001b[39m\u001b[38;5;124m\"\u001b[39m]) \u001b[38;5;241m<\u001b[39m \u001b[38;5;28mabs\u001b[39m(row[\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mensemble\u001b[39m\u001b[38;5;124m\"\u001b[39m] \u001b[38;5;241m-\u001b[39m row[\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mHAMTIDE11\u001b[39m\u001b[38;5;124m\"\u001b[39m]) \u001b[38;5;28;01melse\u001b[39;00m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mHAMTIDE11\u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[1;32m 119\u001b[0m ),\n\u001b[1;32m 120\u001b[0m axis\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m1\u001b[39m,\n\u001b[1;32m 121\u001b[0m )\u001b[38;5;241m.\u001b[39mtolist()\n\u001b[0;32m--> 122\u001b[0m \u001b[38;5;28;01massert\u001b[39;00m closer_model \u001b[38;5;241m==\u001b[39m [\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mEOT20\u001b[39m\u001b[38;5;124m\"\u001b[39m, \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mHAMTIDE11\u001b[39m\u001b[38;5;124m\"\u001b[39m, \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mEOT20\u001b[39m\u001b[38;5;124m\"\u001b[39m, \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mHAMTIDE11\u001b[39m\u001b[38;5;124m\"\u001b[39m]\n\u001b[1;32m 124\u001b[0m \u001b[38;5;66;03m# # Check values are expected\u001b[39;00m\n\u001b[1;32m 125\u001b[0m \u001b[38;5;66;03m# assert np.allclose(modelled_tides_df.ensemble, [0.09, 0.98, -3.20, 1.01], atol=0.02)\u001b[39;00m\n\u001b[1;32m 126\u001b[0m \n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 178\u001b[0m \u001b[38;5;66;03m# \"ensemble-mean\",\u001b[39;00m\n\u001b[1;32m 179\u001b[0m \u001b[38;5;66;03m# ])\u001b[39;00m\n", + "\u001b[0;31mAssertionError\u001b[0m: " + ] + } + ], "source": [ + "dir_path = \"./tests/data/tide_models\"\n", + "\n", + "\n", "from eo_tides.model import model_tides\n", "\n", - "df = model_tides(x= 123.73412090186251, \n", - " y=-16.997767837915056, \n", - " model=\"ensemble\",\n", - " time=pd.date_range(start=\"2000\", end=\"2001\", freq=\"5h\"),\n", - " ranking_points=\"/home/jovyan/Robbi/dea-intertidal/data/raw/tide_correlation_points_test.geojson\",\n", - " k=5,\n", - " output_format=\"wide\",\n", - " directory=\"/var/share/tide_models/\")\n", + "# Input params\n", + "good_hamtide11 = -17.58549, 123.59414\n", + "good_eot20 = -17.1611, 123.3406\n", + "y = [good_eot20[0], good_hamtide11[0]]\n", + "x = [good_eot20[1], good_hamtide11[1]]\n", "\n", - "with pd.option_context('display.max_rows', 5, 'display.max_columns', None): \n", - " display(df)\n", + "ENSEMBLE_MODELS = [\"EOT20\", \"HAMTIDE11\"]\n", "\n", - "# u, c = np.unique(a, return_counts=True)" + "# times = pd.date_range(\"2020\", \"2021\", periods=2)\n", + "\n", + "# # Default, only ensemble requested\n", + "# modelled_tides_df = model_tides(\n", + "# x=x,\n", + "# y=y,\n", + "# time=times,\n", + "# model=\"ensemble\",\n", + "# directory=dir_path,\n", + "# ensemble_models=ENSEMBLE_MODELS,\n", + "# )\n", + "\n", + "# assert modelled_tides_df.index.names == [\"time\", \"x\", \"y\"]\n", + "# assert modelled_tides_df.columns.tolist() == [\"tide_model\", \"tide_height\"]\n", + "# assert all(modelled_tides_df.tide_model == \"ensemble\")\n", + "\n", + "# Default, ensemble + other models requested\n", + "models = [\"EOT20\", \"HAMTIDE11\", \"ensemble\"]\n", + "# modelled_tides_df = model_tides(\n", + "# x=x,\n", + "# y=y,\n", + "# time=times,\n", + "# model=models,\n", + "# directory=dir_path,\n", + "# ensemble_models=ENSEMBLE_MODELS,\n", + "# )\n", + "\n", + "# assert modelled_tides_df.index.names == [\"time\", \"x\", \"y\"]\n", + "# assert modelled_tides_df.columns.tolist() == [\"tide_model\", \"tide_height\"]\n", + "# assert set(modelled_tides_df.tide_model) == set(models)\n", + "# assert np.allclose(\n", + "# modelled_tides_df.tide_height.values,\n", + "# [\n", + "# 0.094,\n", + "# -3.202,\n", + "# 0.409,\n", + "# -3.098,\n", + "# 0.803,\n", + "# 0.664,\n", + "# 0.989,\n", + "# 1.011,\n", + "# 0.449,\n", + "# -1.269,\n", + "# 0.699,\n", + "# -1.043,\n", + "# ],\n", + "# atol=0.02,\n", + "# )\n", + "\n", + "# # One-to-one mode\n", + "# modelled_tides_df = model_tides(\n", + "# x=x,\n", + "# y=y,\n", + "# time=times,\n", + "# model=models,\n", + "# mode=\"one-to-one\",\n", + "# directory=dir_path,\n", + "# ensemble_models=ENSEMBLE_MODELS,\n", + "# )\n", + "\n", + "# assert modelled_tides_df.index.names == [\"time\", \"x\", \"y\"]\n", + "# assert modelled_tides_df.columns.tolist() == [\"tide_model\", \"tide_height\"]\n", + "# assert set(modelled_tides_df.tide_model) == set(models)\n", + "\n", + "# # Wide mode, default\n", + "# modelled_tides_df = model_tides(\n", + "# x=x,\n", + "# y=y,\n", + "# time=times,\n", + "# model=models,\n", + "# output_format=\"wide\",\n", + "# directory=dir_path,\n", + "# ensemble_models=ENSEMBLE_MODELS,\n", + "# )\n", + "\n", + "# # Check that expected models exist, and that ensemble is approx average\n", + "# # of other two models\n", + "# assert set(modelled_tides_df.columns) == set(models)\n", + "# assert np.allclose(\n", + "# 0.5 * (modelled_tides_df.EOT20 + modelled_tides_df.HAMTIDE11),\n", + "# modelled_tides_df.ensemble,\n", + "# )\n", + "\n", + "# # Wide mode, top n == 1\n", + "# modelled_tides_df = model_tides(\n", + "# x=x,\n", + "# y=y,\n", + "# time=times,\n", + "# model=models,\n", + "# output_format=\"wide\",\n", + "# ensemble_top_n=1,\n", + "# directory=dir_path,\n", + "# ensemble_models=ENSEMBLE_MODELS,\n", + "# )\n", + "\n", + "# Check that expected models exist, and that ensemble is equal to at\n", + "# least one of the other models\n", + "assert set(modelled_tides_df.columns) == set(models)\n", + "assert all(\n", + " (modelled_tides_df.EOT20 == modelled_tides_df.ensemble)\n", + " | (modelled_tides_df.HAMTIDE11 == modelled_tides_df.ensemble)\n", + ")\n", + "\n", + "# Check that correct model is the closest at each row\n", + "closer_model = modelled_tides_df.apply(\n", + " lambda row: (\n", + " \"EOT20\" if abs(row[\"ensemble\"] - row[\"EOT20\"]) < abs(row[\"ensemble\"] - row[\"HAMTIDE11\"]) else \"HAMTIDE11\"\n", + " ),\n", + " axis=1,\n", + ").tolist()\n", + "assert closer_model == [\"EOT20\", \"HAMTIDE11\", \"EOT20\", \"HAMTIDE11\"]\n", + "\n", + "# # Check values are expected\n", + "# assert np.allclose(modelled_tides_df.ensemble, [0.09, 0.98, -3.20, 1.01], atol=0.02)\n", + "\n", + "# # Wide mode, custom functions\n", + "# ensemble_funcs = {\n", + "# \"ensemble-best\": lambda x: x[\"rank\"] == 1,\n", + "# \"ensemble-worst\": lambda x: x[\"rank\"] == 2,\n", + "# \"ensemble-mean-top2\": lambda x: x[\"rank\"].isin([1, 2]),\n", + "# \"ensemble-mean-weighted\": lambda x: 3 - x[\"rank\"],\n", + "# \"ensemble-mean\": lambda x: x[\"rank\"] <= 2,\n", + "# }\n", + "# modelled_tides_df = model_tides(\n", + "# x=x,\n", + "# y=y,\n", + "# time=times,\n", + "# model=models,\n", + "# output_format=\"wide\",\n", + "# ensemble_func=ensemble_funcs,\n", + "# directory=dir_path,\n", + "# ensemble_models=ENSEMBLE_MODELS,\n", + "# )\n", + "\n", + "# # Check that expected models exist, and that valid data is produced\n", + "# assert set(modelled_tides_df.columns) == set([\n", + "# \"EOT20\",\n", + "# \"HAMTIDE11\",\n", + "# \"ensemble-best\",\n", + "# \"ensemble-worst\",\n", + "# \"ensemble-mean-top2\",\n", + "# \"ensemble-mean-weighted\",\n", + "# \"ensemble-mean\",\n", + "# ])\n", + "# assert all(modelled_tides_df.notnull())\n", + "\n", + "# # Long mode, custom functions\n", + "# modelled_tides_df = model_tides(\n", + "# x=x,\n", + "# y=y,\n", + "# time=times,\n", + "# model=models,\n", + "# output_format=\"long\",\n", + "# ensemble_func=ensemble_funcs,\n", + "# directory=dir_path,\n", + "# ensemble_models=ENSEMBLE_MODELS,\n", + "# )\n", + "\n", + "# # Check that expected models exist in \"tide_model\" column\n", + "# assert set(modelled_tides_df.tide_model) == set([\n", + "# \"EOT20\",\n", + "# \"HAMTIDE11\",\n", + "# \"ensemble-best\",\n", + "# \"ensemble-worst\",\n", + "# \"ensemble-mean-top2\",\n", + "# \"ensemble-mean-weighted\",\n", + "# \"ensemble-mean\",\n", + "# ])" ] }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 12, "metadata": {}, "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Running ensemble tide modelling\n", - "Modelling tides with EOT20, FES2012, FES2014_extrapolated, FES2022_extrapolated, GOT4.10, GOT5.6_extrapolated, HAMTIDE11, TPXO10-atlas-v2-nc, TPXO8-atlas-nc, TPXO9-atlas-v5-nc in parallel (models: 10, splits: 1)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 10/10 [00:13<00:00, 1.38s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Interpolating model rankings using IDW interpolation \n", - "Combining models into single ensemble model\n", - "Converting to a wide format dataframe\n" - ] - }, { "data": { "text/html": [ @@ -244,15 +597,7 @@ " \n", " tide_model\n", " EOT20\n", - " FES2012\n", - " FES2014_extrapolated\n", - " FES2022_extrapolated\n", - " GOT4.10\n", - " GOT5.6_extrapolated\n", " HAMTIDE11\n", - " TPXO10-atlas-v2-nc\n", - " TPXO8-atlas-nc\n", - " TPXO9-atlas-v5-nc\n", " ensemble\n", " \n", " \n", @@ -262,291 +607,304 @@ " \n", " \n", " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", " \n", " \n", " \n", " \n", - " 2018-01-01 00:00:00\n", - " 145.372051\n", - " -38.260667\n", - " -0.054068\n", - " 0.687800\n", - " -0.046930\n", - " 0.736687\n", - " 0.656625\n", - " 0.022140\n", - " 0.209577\n", - " 0.818612\n", - " 0.588247\n", - " 0.830129\n", - " 0.795143\n", - " \n", - " \n", - " 2018-01-01 01:00:00\n", - " 145.372051\n", - " -38.260667\n", - " -0.088318\n", - " 0.480949\n", - " -0.032135\n", - " 0.744231\n", - " 0.471352\n", - " 0.009389\n", - " 0.308781\n", - " 0.817649\n", - " 0.442039\n", - " 0.753540\n", - " 0.771807\n", + " 2020-01-01\n", + " 123.34060\n", + " -17.16110\n", + " 0.094431\n", + " 0.802646\n", + " 0.094431\n", " \n", " \n", - " 2018-01-01 02:00:00\n", - " 145.372051\n", - " -38.260667\n", - " -0.132942\n", - " 0.102051\n", - " -0.083882\n", - " 0.629339\n", - " 0.115855\n", - " -0.021484\n", - " 0.355144\n", - " 0.588609\n", - " 0.142466\n", - " 0.454941\n", - " 0.557630\n", + " 123.59414\n", + " -17.58549\n", + " 0.409453\n", + " 0.988605\n", + " 0.409453\n", " \n", " \n", - " 2018-01-01 03:00:00\n", - " 145.372051\n", - " -38.260667\n", - " -0.213443\n", - " -0.377484\n", - " -0.263361\n", - " 0.282223\n", - " -0.341372\n", - " -0.116572\n", - " 0.328938\n", - " 0.080393\n", - " -0.253323\n", - " -0.064088\n", - " 0.099510\n", + " 2021-01-01\n", + " 123.34060\n", + " -17.16110\n", + " -3.201904\n", + " 0.664067\n", + " -3.201904\n", " \n", " \n", - " 2018-01-01 04:00:00\n", - " 145.372051\n", - " -38.260667\n", - " -0.320080\n", - " -0.847298\n", - " -0.406669\n", - " -0.281990\n", - " -0.784016\n", - " -0.269235\n", - " 0.227173\n", - " -0.601902\n", - " -0.647516\n", - " -0.681982\n", - " -0.521958\n", + " 123.59414\n", + " -17.58549\n", + " -3.098302\n", + " 1.011445\n", + " -3.098302\n", " \n", - " \n", - " ...\n", - " ...\n", - " ...\n", - " ...\n", - " ...\n", - " ...\n", - " ...\n", - " ...\n", - " ...\n", - " ...\n", - " ...\n", - " ...\n", - " ...\n", - " ...\n", + " \n", + "\n", + "" + ], + "text/plain": [ + "tide_model EOT20 HAMTIDE11 ensemble\n", + "time x y \n", + "2020-01-01 123.34060 -17.16110 0.094431 0.802646 0.094431\n", + " 123.59414 -17.58549 0.409453 0.988605 0.409453\n", + "2021-01-01 123.34060 -17.16110 -3.201904 0.664067 -3.201904\n", + " 123.59414 -17.58549 -3.098302 1.011445 -3.098302" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "modelled_tides_df" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [], + "source": [ + "ENSEMBLE_MODELS = [\"EOT20\", \"HAMTIDE11\"]\n", + "ensemble_models = ENSEMBLE_MODELS\n", + "\n", + "x = tide_df.index.get_level_values(level=\"x\")\n", + "y = tide_df.index.get_level_values(level=\"y\")\n", + "model_ranking_cols = [f\"rank_{m}\" for m in ensemble_models]" + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "rank_EOT20 0\n", + "rank_HAMTIDE11 87\n", + "geometry 0\n", + "dtype: int64" + ] + }, + "execution_count": 36, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "model_ranks_gdf.isnull().sum(axis=0)" + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "metadata": {}, + "outputs": [], + "source": [ + "import geopandas as gpd\n", + "ranking_points=\"https://dea-public-data-dev.s3-ap-southeast-2.amazonaws.com/derivative/dea_intertidal/supplementary/rankings_ensemble_2017-2019.fgb\"\n", + "crs = \"EPSG:4326\"\n", + "ranking_valid_perc=0.02\n", + "\n", + "try:\n", + " model_ranks_gdf = (\n", + " gpd.read_file(ranking_points, engine=\"pyogrio\")\n", + " .to_crs(crs)\n", + " .query(f\"valid_perc > {ranking_valid_perc}\")\n", + " .dropna(how=\"all\")[model_ranking_cols + [\"geometry\"]]\n", + " )\n", + "except KeyError:\n", + " error_msg = f\"\"\"\n", + " Not all of the expected \"rank_\" columns {model_ranking_cols} were\n", + " found in the columns of the ranking points file ({ranking_points}).\n", + " Consider passing a custom list of models using `ensemble_models`.\n", + " \"\"\"\n", + " raise Exception(textwrap.dedent(error_msg).strip()) from None" + ] + }, + { + "cell_type": "code", + "execution_count": 37, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Interpolating model rankings using IDW interpolation \n" + ] + } + ], + "source": [ + "from eo_tides.utils import idw\n", + "\n", + "idw_kwargs = {}\n", + "\n", + "# Use points to interpolate model rankings into requested x and y\n", + "id_kwargs_str = \"\" if idw_kwargs == {} else idw_kwargs\n", + "print(f\"Interpolating model rankings using IDW interpolation {id_kwargs_str}\")\n", + "ensemble_ranks_df = (\n", + " # Run IDW interpolation on subset of ranking columns\n", + " pd.DataFrame(\n", + " idw(\n", + " input_z=model_ranks_gdf[model_ranking_cols],\n", + " input_x=model_ranks_gdf.geometry.x,\n", + " input_y=model_ranks_gdf.geometry.y,\n", + " output_x=x,\n", + " output_y=y,\n", + " **idw_kwargs,\n", + " ),\n", + " columns=model_ranking_cols,\n", + " )\n", + " .assign(x=x, y=y)\n", + " # Drop any duplicates then melt columns into long format\n", + " .drop_duplicates()\n", + " .melt(id_vars=[\"x\", \"y\"], var_name=\"tide_model\", value_name=\"rank\")\n", + " # Remore \"rank_\" prefix to get plain model names\n", + " .replace({\"^rank_\": \"\"}, regex=True)\n", + " # Set index columns and rank across groups\n", + " .set_index([\"tide_model\", \"x\", \"y\"])\n", + " .groupby([\"x\", \"y\"])\n", + " .rank()\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 40, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "rank_EOT20 0\n", + "rank_HAMTIDE11 87\n", + "dtype: int64" + ] + }, + "execution_count": 40, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "model_ranks_gdf[model_ranking_cols].isnull()" + ] + }, + { + "cell_type": "code", + "execution_count": 38, + "metadata": {}, + "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", "
rank
2020-12-30 20:00:00145.372051-38.2606670.221464-0.3199070.212133-0.273928-0.2555060.1914820.158968-0.386745-0.243656-0.366988-0.342554tide_modelxy
2020-12-30 21:00:00145.372051-38.2606670.153694-0.3187970.078701-0.563003-0.2615270.1470280.060131-0.425891-0.262007-0.359812-0.449568EOT20123.34060-17.161101.0
2020-12-30 22:00:00145.372051-38.2606670.073088-0.2037790.022568-0.650761-0.1627750.087353-0.019473-0.302963-0.174997-0.213937-0.389220123.59414-17.585492.0
2020-12-30 23:00:00145.372051-38.260667-0.023588-0.0060340.015223-0.4837080.0046780.000023-0.056254-0.091032-0.014051-0.002233-0.192324HAMTIDE11123.34060-17.161102.0
2020-12-31 00:00:00145.372051-38.260667-0.1140980.243842-0.057904-0.1623630.200150-0.083307-0.0396610.1558670.1791780.2248580.072787123.59414-17.585491.0
\n", - "

26281 rows × 11 columns

\n", "
" ], "text/plain": [ - "tide_model EOT20 FES2012 \\\n", - "time x y \n", - "2018-01-01 00:00:00 145.372051 -38.260667 -0.054068 0.687800 \n", - "2018-01-01 01:00:00 145.372051 -38.260667 -0.088318 0.480949 \n", - "2018-01-01 02:00:00 145.372051 -38.260667 -0.132942 0.102051 \n", - "2018-01-01 03:00:00 145.372051 -38.260667 -0.213443 -0.377484 \n", - "2018-01-01 04:00:00 145.372051 -38.260667 -0.320080 -0.847298 \n", - "... ... ... \n", - "2020-12-30 20:00:00 145.372051 -38.260667 0.221464 -0.319907 \n", - "2020-12-30 21:00:00 145.372051 -38.260667 0.153694 -0.318797 \n", - "2020-12-30 22:00:00 145.372051 -38.260667 0.073088 -0.203779 \n", - "2020-12-30 23:00:00 145.372051 -38.260667 -0.023588 -0.006034 \n", - "2020-12-31 00:00:00 145.372051 -38.260667 -0.114098 0.243842 \n", - "\n", - "tide_model FES2014_extrapolated \\\n", - "time x y \n", - "2018-01-01 00:00:00 145.372051 -38.260667 -0.046930 \n", - "2018-01-01 01:00:00 145.372051 -38.260667 -0.032135 \n", - "2018-01-01 02:00:00 145.372051 -38.260667 -0.083882 \n", - "2018-01-01 03:00:00 145.372051 -38.260667 -0.263361 \n", - "2018-01-01 04:00:00 145.372051 -38.260667 -0.406669 \n", - "... ... \n", - "2020-12-30 20:00:00 145.372051 -38.260667 0.212133 \n", - "2020-12-30 21:00:00 145.372051 -38.260667 0.078701 \n", - "2020-12-30 22:00:00 145.372051 -38.260667 0.022568 \n", - "2020-12-30 23:00:00 145.372051 -38.260667 0.015223 \n", - "2020-12-31 00:00:00 145.372051 -38.260667 -0.057904 \n", - "\n", - "tide_model FES2022_extrapolated GOT4.10 \\\n", - "time x y \n", - "2018-01-01 00:00:00 145.372051 -38.260667 0.736687 0.656625 \n", - "2018-01-01 01:00:00 145.372051 -38.260667 0.744231 0.471352 \n", - "2018-01-01 02:00:00 145.372051 -38.260667 0.629339 0.115855 \n", - "2018-01-01 03:00:00 145.372051 -38.260667 0.282223 -0.341372 \n", - "2018-01-01 04:00:00 145.372051 -38.260667 -0.281990 -0.784016 \n", - "... ... ... \n", - "2020-12-30 20:00:00 145.372051 -38.260667 -0.273928 -0.255506 \n", - "2020-12-30 21:00:00 145.372051 -38.260667 -0.563003 -0.261527 \n", - "2020-12-30 22:00:00 145.372051 -38.260667 -0.650761 -0.162775 \n", - "2020-12-30 23:00:00 145.372051 -38.260667 -0.483708 0.004678 \n", - "2020-12-31 00:00:00 145.372051 -38.260667 -0.162363 0.200150 \n", - "\n", - "tide_model GOT5.6_extrapolated HAMTIDE11 \\\n", - "time x y \n", - "2018-01-01 00:00:00 145.372051 -38.260667 0.022140 0.209577 \n", - "2018-01-01 01:00:00 145.372051 -38.260667 0.009389 0.308781 \n", - "2018-01-01 02:00:00 145.372051 -38.260667 -0.021484 0.355144 \n", - "2018-01-01 03:00:00 145.372051 -38.260667 -0.116572 0.328938 \n", - "2018-01-01 04:00:00 145.372051 -38.260667 -0.269235 0.227173 \n", - "... ... ... \n", - "2020-12-30 20:00:00 145.372051 -38.260667 0.191482 0.158968 \n", - "2020-12-30 21:00:00 145.372051 -38.260667 0.147028 0.060131 \n", - "2020-12-30 22:00:00 145.372051 -38.260667 0.087353 -0.019473 \n", - "2020-12-30 23:00:00 145.372051 -38.260667 0.000023 -0.056254 \n", - "2020-12-31 00:00:00 145.372051 -38.260667 -0.083307 -0.039661 \n", - "\n", - "tide_model TPXO10-atlas-v2-nc TPXO8-atlas-nc \\\n", - "time x y \n", - "2018-01-01 00:00:00 145.372051 -38.260667 0.818612 0.588247 \n", - "2018-01-01 01:00:00 145.372051 -38.260667 0.817649 0.442039 \n", - "2018-01-01 02:00:00 145.372051 -38.260667 0.588609 0.142466 \n", - "2018-01-01 03:00:00 145.372051 -38.260667 0.080393 -0.253323 \n", - "2018-01-01 04:00:00 145.372051 -38.260667 -0.601902 -0.647516 \n", - "... ... ... \n", - "2020-12-30 20:00:00 145.372051 -38.260667 -0.386745 -0.243656 \n", - "2020-12-30 21:00:00 145.372051 -38.260667 -0.425891 -0.262007 \n", - "2020-12-30 22:00:00 145.372051 -38.260667 -0.302963 -0.174997 \n", - "2020-12-30 23:00:00 145.372051 -38.260667 -0.091032 -0.014051 \n", - "2020-12-31 00:00:00 145.372051 -38.260667 0.155867 0.179178 \n", - "\n", - "tide_model TPXO9-atlas-v5-nc ensemble \n", - "time x y \n", - "2018-01-01 00:00:00 145.372051 -38.260667 0.830129 0.795143 \n", - "2018-01-01 01:00:00 145.372051 -38.260667 0.753540 0.771807 \n", - "2018-01-01 02:00:00 145.372051 -38.260667 0.454941 0.557630 \n", - "2018-01-01 03:00:00 145.372051 -38.260667 -0.064088 0.099510 \n", - "2018-01-01 04:00:00 145.372051 -38.260667 -0.681982 -0.521958 \n", - "... ... ... \n", - "2020-12-30 20:00:00 145.372051 -38.260667 -0.366988 -0.342554 \n", - "2020-12-30 21:00:00 145.372051 -38.260667 -0.359812 -0.449568 \n", - "2020-12-30 22:00:00 145.372051 -38.260667 -0.213937 -0.389220 \n", - "2020-12-30 23:00:00 145.372051 -38.260667 -0.002233 -0.192324 \n", - "2020-12-31 00:00:00 145.372051 -38.260667 0.224858 0.072787 \n", - "\n", - "[26281 rows x 11 columns]" + " rank\n", + "tide_model x y \n", + "EOT20 123.34060 -17.16110 1.0\n", + " 123.59414 -17.58549 2.0\n", + "HAMTIDE11 123.34060 -17.16110 2.0\n", + " 123.59414 -17.58549 1.0" ] }, - "execution_count": 10, + "execution_count": 38, "metadata": {}, "output_type": "execute_result" } ], + "source": [ + "ensemble_ranks_df" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from eo_tides.model import model_tides\n", + "\n", + "df = model_tides(x= 123.73412090186251, \n", + " y=-16.997767837915056, \n", + " model=\"ensemble\",\n", + " time=pd.date_range(start=\"2000\", end=\"2001\", freq=\"5h\"),\n", + " ranking_points=\"/home/jovyan/Robbi/dea-intertidal/data/raw/tide_correlation_points_test.geojson\",\n", + " k=5,\n", + " output_format=\"wide\",\n", + " directory=\"/var/share/tide_models/\")\n", + "\n", + "with pd.option_context('display.max_rows', 5, 'display.max_columns', None): \n", + " display(df)\n", + "\n", + "# u, c = np.unique(a, return_counts=True)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ "from eo_tides.model import model_tides\n", "\n", @@ -587,30 +945,9 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 11, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "import matplotlib.pyplot as plt\n", "df.droplevel([\"x\", \"y\"]).head(50).drop(\"ensemble\", axis=1).plot(linewidth=0.8, figsize=(10, 6))\n", @@ -620,30 +957,9 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 7, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "import matplotlib.pyplot as plt\n", "df.droplevel([\"x\", \"y\"]).head(50).drop(\"ensemble\", axis=1).plot(linewidth=0.8, figsize=(10, 6))\n", From 71c58eb75fd36b3d0f801223832fc4a0b715926e Mon Sep 17 00:00:00 2001 From: Robbi Bishop-Taylor Date: Thu, 19 Dec 2024 03:53:17 +0000 Subject: [PATCH 04/10] Ensemble updates, make top level func --- eo_tides/__init__.py | 3 +- eo_tides/eo.py | 20 ++- eo_tides/model.py | 390 ++++++++++++++++++++++--------------------- eo_tides/stats.py | 10 +- eo_tides/utils.py | 4 +- pyproject.toml | 2 + uv.lock | 2 + 7 files changed, 227 insertions(+), 204 deletions(-) diff --git a/eo_tides/__init__.py b/eo_tides/__init__.py index 236afb2..e6e810e 100644 --- a/eo_tides/__init__.py +++ b/eo_tides/__init__.py @@ -28,7 +28,7 @@ # Import commonly used functions for convenience from .eo import pixel_tides, tag_tides -from .model import model_phases, model_tides +from .model import ensemble_tides, model_phases, model_tides from .stats import pixel_stats, tide_stats from .utils import clip_models, idw, list_models from .validation import eval_metrics, load_gauge_gesla @@ -38,6 +38,7 @@ "list_models", "model_tides", "model_phases", + "ensemble_tides", "tag_tides", "pixel_tides", "tide_stats", diff --git a/eo_tides/eo.py b/eo_tides/eo.py index c4ff757..95429ca 100644 --- a/eo_tides/eo.py +++ b/eo_tides/eo.py @@ -197,10 +197,12 @@ def tag_tides( that can be converted by `pandas.to_datetime()`. For example: `time=pd.date_range(start="2000", end="2001", freq="5h")` model : str or list of str, optional - The tide model (or models) used to model tides. If a list is - provided, a new "tide_model" dimension will be added to the - `xarray.DataArray` outputs. Defaults to "EOT20"; for a full - list of available/supported models, run `eo_tides.model.list_models`. + The tide model (or list of models) to use to model tides. + If a list is provided, a new "tide_model" dimension will be + added to the `xarray.DataArray` outputs. Defaults to "EOT20"; + specify "all" to use all models available in `directory`. + For a full list of available and supported models, run + `eo_tides.model.list_models`. directory : str, optional The directory containing tide model data files. If no path is provided, this will default to the environment variable @@ -326,10 +328,12 @@ def pixel_tides( that can be converted by `pandas.to_datetime()`. For example: `time=pd.date_range(start="2000", end="2001", freq="5h")` model : str or list of str, optional - The tide model (or models) used to model tides. If a list is - provided, a new "tide_model" dimension will be added to the - `xarray.DataArray` outputs. Defaults to "EOT20"; for a full - list of available/supported models, run `eo_tides.model.list_models`. + The tide model (or list of models) to use to model tides. + If a list is provided, a new "tide_model" dimension will be + added to the `xarray.DataArray` outputs. Defaults to "EOT20"; + specify "all" to use all models available in `directory`. + For a full list of available and supported models, run + `eo_tides.model.list_models`. directory : str, optional The directory containing tide model data files. If no path is provided, this will default to the environment variable diff --git a/eo_tides/model.py b/eo_tides/model.py index 8d32cc1..895b46d 100644 --- a/eo_tides/model.py +++ b/eo_tides/model.py @@ -24,179 +24,6 @@ from .utils import DatetimeLike, _set_directory, _standardise_models, _standardise_time, idw, list_models -def _ensemble_model( - tide_df, - crs, - ensemble_models, - ensemble_func=None, - ensemble_top_n=3, - ranking_points="https://dea-public-data-dev.s3-ap-southeast-2.amazonaws.com/derivative/dea_intertidal/supplementary/rankings_ensemble_2017-2019.fgb", - ranking_valid_perc=0.02, - **idw_kwargs, -): - """Combine multiple tide models into a single locally optimised - ensemble tide model using external model ranking data (e.g. - satellite altimetry or NDWI-tide correlations along the coastline) - to inform the selection of the best local models. - - This function performs the following steps: - 1. Takes a dataframe of tide heights from multiple tide models, as - produced by `eo_tides.model.model_tides` - 1. Loads model ranking points from an external file, filters them - based on the valid data percentage, and retains relevant columns - 2. Interpolates the model rankings into the "x" and "y" coordinates - of the original dataframe using Inverse Weighted Interpolation (IDW) - 3. Uses rankings to combine multiple tide models into a single - optimised ensemble model (by default, by taking the mean of the - top 3 ranked models) - 4. Returns a new dataFrame with the combined ensemble model predictions - - Parameters - ---------- - tide_df : pandas.DataFrame - DataFrame produced by `eo_tides.model.model_tides`, containing - tide model predictions with columns: - `["time", "x", "y", "tide_height", "tide_model"]`. - crs : string - Coordinate reference system for the "x" and "y" coordinates in - `tide_df`. Used to ensure that interpolations are performed - in the correct CRS. - ensemble_models : list - A list of models to include in the ensemble modelling process. - All values must exist as columns with the prefix "rank_" in - `ranking_points`. - ensemble_func : dict, optional - By default, a simple ensemble model will be calculated by taking - the mean of the `ensemble_top_n` tide models at each location. - However, a dictionary containing more complex ensemble - calculations can also be provided. Dictionary keys are used - to name output ensemble models; functions should take a column - named "rank" and convert it to a weighting, e.g.: - `ensemble_func = {"ensemble-custom": lambda x: x["rank"] <= 3}` - ensemble_top_n : int, optional - If `ensemble_func` is None, this sets the number of top models - to include in the mean ensemble calculation. Defaults to 3. - ranking_points : str, optional - Path to the file containing model ranking points. This dataset - should include columns containing rankings for each tide - model, named with the prefix "rank_". e.g. "rank_EOT20". - Low values should represent high rankings (e.g. 1 = top ranked). - ranking_valid_perc : float, optional - Minimum percentage of valid data required to include a model - rank point in the analysis, as defined in a column named - "valid_perc". Defaults to 0.02. - **idw_kwargs - Optional keyword arguments to pass to the `idw` function used - for interpolation. Useful values include `k` (number of nearest - neighbours to use in interpolation), `max_dist` (maximum - distance to nearest neighbours), and `k_min` (minimum number of - neighbours required after `max_dist` is applied). - - Returns - ------- - pandas.DataFrame - DataFrame containing the ensemble model predictions, matching - the format of the input `tide_df` (e.g. columns `["time", "x", - "y", "tide_height", "tide_model"]`. By default the 'tide_model' - column will be labeled "ensemble" for the combined model - predictions (but if a custom dictionary of ensemble functions is - provided via `ensemble_func`, each ensemble will be named using - the provided dictionary keys). - - """ - # Extract x and y coords from dataframe - x = tide_df.index.get_level_values(level="x") - y = tide_df.index.get_level_values(level="y") - - # Load model ranks points and reproject to same CRS as x and y - model_ranking_cols = [f"rank_{m}" for m in ensemble_models] - try: - model_ranks_gdf = ( - gpd.read_file(ranking_points, engine="pyogrio") - .to_crs(crs) - .query(f"valid_perc > {ranking_valid_perc}") - .dropna(how="all")[model_ranking_cols + ["geometry"]] - ) - except KeyError: - error_msg = f""" - Not all of the expected "rank_" columns {model_ranking_cols} were - found in the columns of the ranking points file ({ranking_points}). - Consider passing a custom list of models using `ensemble_models`. - """ - raise Exception(textwrap.dedent(error_msg).strip()) from None - - # Use points to interpolate model rankings into requested x and y - id_kwargs_str = "" if idw_kwargs == {} else idw_kwargs - print(f"Interpolating model rankings using IDW interpolation {id_kwargs_str}") - ensemble_ranks_df = ( - # Run IDW interpolation on subset of ranking columns - pd.DataFrame( - idw( - input_z=model_ranks_gdf[model_ranking_cols], - input_x=model_ranks_gdf.geometry.x, - input_y=model_ranks_gdf.geometry.y, - output_x=x, - output_y=y, - **idw_kwargs, - ), - columns=model_ranking_cols, - ) - .assign(x=x, y=y) - # Drop any duplicates then melt columns into long format - .drop_duplicates() - .melt(id_vars=["x", "y"], var_name="tide_model", value_name="rank") - # Remore "rank_" prefix to get plain model names - .replace({"^rank_": ""}, regex=True) - # Set index columns and rank across groups - .set_index(["tide_model", "x", "y"]) - .groupby(["x", "y"]) - .rank() - ) - - # If no custom ensemble funcs are provided, use a default ensemble - # calculation that takes the mean of the top N tide models - if ensemble_func is None: - ensemble_func = {"ensemble": lambda x: x["rank"] <= ensemble_top_n} - - # Create output list to hold computed ensemble model outputs - ensemble_list = [] - - # Loop through all provided ensemble generation functions - for ensemble_n, ensemble_f in ensemble_func.items(): - print(f"Combining models into single {ensemble_n} model") - - # Join ranks to input tide data, compute weightings and group - grouped = ( - # Add tide model as an index so we can join with model ranks - tide_df.set_index("tide_model", append=True) - .join(ensemble_ranks_df) - # Add temp columns containing weightings and weighted values - .assign( - weights=ensemble_f, # use custom func to compute weights - weighted=lambda i: i.tide_height * i.weights, - ) - # Groupby is specified in a weird order here as this seems - # to be the easiest way to preserve correct index sorting - .groupby(["x", "y", "time"]) - ) - - # Use weightings to combine multiple models into single ensemble - ensemble_df = ( - # Calculate weighted mean and convert back to dataframe - grouped.weighted.sum() - .div(grouped.weights.sum()) - .to_frame("tide_height") - # Label ensemble model and ensure indexes are in expected order - .assign(tide_model=ensemble_n) - .reorder_levels(["time", "x", "y"], axis=0) - ) - - ensemble_list.append(ensemble_df) - - # Combine all ensemble models and return as a single dataframe - return pd.concat(ensemble_list) - - def _parallel_splits( total_points: int, model_count: int, @@ -373,6 +200,188 @@ def _model_tides( return tide_df +def ensemble_tides( + tide_df, + crs, + ensemble_models, + ensemble_func=None, + ensemble_top_n=3, + ranking_points="https://dea-public-data-dev.s3-ap-southeast-2.amazonaws.com/derivative/dea_intertidal/supplementary/rankings_ensemble_2017-2019.fgb", + ranking_valid_perc=0.02, + **idw_kwargs, +): + """Combine multiple tide models into a single locally optimised + ensemble tide model using external model ranking data (e.g. + satellite altimetry or NDWI-tide correlations along the coastline) + to inform the selection of the best local models. + + This function performs the following steps: + 1. Takes a dataframe of tide heights from multiple tide models, as + produced by `eo_tides.model.model_tides` + 1. Loads model ranking points from an external file, filters them + based on the valid data percentage, and retains relevant columns + 2. Interpolates the model rankings into the coordinates of the + original dataframe using Inverse Weighted Interpolation (IDW) + 3. Uses rankings to combine multiple tide models into a single + optimised ensemble model (by default, by taking the mean of the + top 3 ranked models) + 4. Returns a new dataFrame with the combined ensemble model predictions + + Parameters + ---------- + tide_df : pandas.DataFrame + DataFrame produced by `eo_tides.model.model_tides`, containing + tide model predictions in long format with columns: + `["time", "x", "y", "tide_height", "tide_model"]`. + crs : string + Coordinate reference system for the "x" and "y" coordinates in + `tide_df`. Used to ensure that interpolations are performed + in the correct CRS. + ensemble_models : list + A list of models to include in the ensemble modelling process. + All values must exist as columns with the prefix "rank_" in + `ranking_points`. + ensemble_func : dict, optional + By default, a simple ensemble model will be calculated by taking + the mean of the `ensemble_top_n` tide models at each location. + However, a dictionary containing more complex ensemble + calculations can also be provided. Dictionary keys are used + to name output ensemble models; functions should take a column + named "rank" and convert it to a weighting, e.g.: + `ensemble_func = {"ensemble-custom": lambda x: x["rank"] <= 3}` + ensemble_top_n : int, optional + If `ensemble_func` is None, this sets the number of top models + to include in the mean ensemble calculation. Defaults to 3. + ranking_points : str, optional + Path to the file containing model ranking points. This dataset + should include columns containing rankings for each tide + model, named with the prefix "rank_". e.g. "rank_EOT20". + Low values should represent high rankings (e.g. 1 = top ranked). + The default value points to an example file covering Australia. + ranking_valid_perc : float, optional + Minimum percentage of valid data required to include a model + rank point in the analysis, as defined in a column named + "valid_perc". Defaults to 0.02. + **idw_kwargs + Optional keyword arguments to pass to the `idw` function used + for interpolation. Useful values include `k` (number of nearest + neighbours to use in interpolation), `max_dist` (maximum + distance to nearest neighbours), and `k_min` (minimum number of + neighbours required after `max_dist` is applied). + + Returns + ------- + pandas.DataFrame + DataFrame containing the ensemble model predictions, matching + the format of the input `tide_df` (e.g. columns `["time", "x", + "y", "tide_height", "tide_model"]`. By default the 'tide_model' + column will be labeled "ensemble" for the combined model + predictions (but if a custom dictionary of ensemble functions is + provided via `ensemble_func`, each ensemble will be named using + the provided dictionary keys). + + """ + # Raise data if `tide_df` provided in wide format + if "tide_model" not in tide_df: + raise Exception( + "`tide_df` does not contain the expected 'tide_model' and " + "'tide_height' columns. Ensure that tides were modelled in " + "long format (i.e. `output_format='long'` in `model_tides`)." + ) + + # Extract x and y coords from dataframe + x = tide_df.index.get_level_values(level="x") + y = tide_df.index.get_level_values(level="y") + + # Load model ranks points and reproject to same CRS as x and y + model_ranking_cols = [f"rank_{m}" for m in ensemble_models] + try: + model_ranks_gdf = ( + gpd.read_file(ranking_points, engine="pyogrio") + .to_crs(crs) + .query(f"valid_perc > {ranking_valid_perc}") + .dropna(how="all")[model_ranking_cols + ["geometry"]] + ) + except KeyError: + error_msg = f""" + Not all of the expected "rank_" columns {model_ranking_cols} were + found in the columns of the ranking points file ({ranking_points}). + Consider passing a custom list of models using `ensemble_models`. + """ + raise Exception(textwrap.dedent(error_msg).strip()) from None + + # Use points to interpolate model rankings into requested x and y + id_kwargs_str = "" if idw_kwargs == {} else idw_kwargs + print(f"Interpolating model rankings using IDW interpolation {id_kwargs_str}") + ensemble_ranks_df = ( + # Run IDW interpolation on subset of ranking columns + pd.DataFrame( + idw( + input_z=model_ranks_gdf[model_ranking_cols], + input_x=model_ranks_gdf.geometry.x, + input_y=model_ranks_gdf.geometry.y, + output_x=x, + output_y=y, + **idw_kwargs, + ), + columns=model_ranking_cols, + ) + .assign(x=x, y=y) + # Drop any duplicates then melt columns into long format + .drop_duplicates() + .melt(id_vars=["x", "y"], var_name="tide_model", value_name="rank") + # Remore "rank_" prefix to get plain model names + .replace({"^rank_": ""}, regex=True) + # Set index columns and rank across groups + .set_index(["tide_model", "x", "y"]) + .groupby(["x", "y"]) + .rank() + ) + + # If no custom ensemble funcs are provided, use a default ensemble + # calculation that takes the mean of the top N tide models + if ensemble_func is None: + ensemble_func = {"ensemble": lambda x: x["rank"] <= ensemble_top_n} + + # Create output list to hold computed ensemble model outputs + ensemble_list = [] + + # Loop through all provided ensemble generation functions + for ensemble_n, ensemble_f in ensemble_func.items(): + print(f"Combining models into single {ensemble_n} model") + + # Join ranks to input tide data, compute weightings and group + grouped = ( + # Add tide model as an index so we can join with model ranks + tide_df.set_index("tide_model", append=True) + .join(ensemble_ranks_df) + # Add temp columns containing weightings and weighted values + .assign( + weights=ensemble_f, # use custom func to compute weights + weighted=lambda i: i.tide_height * i.weights, + ) + # Groupby is specified in a weird order here as this seems + # to be the easiest way to preserve correct index sorting + .groupby(["x", "y", "time"]) + ) + + # Use weightings to combine multiple models into single ensemble + ensemble_df = ( + # Calculate weighted mean and convert back to dataframe + grouped.weighted.sum() + .div(grouped.weights.sum()) + .to_frame("tide_height") + # Label ensemble model and ensure indexes are in expected order + .assign(tide_model=ensemble_n) + .reorder_levels(["time", "x", "y"], axis=0) + ) + + ensemble_list.append(ensemble_df) + + # Combine all ensemble models and return as a single dataframe + return pd.concat(ensemble_list) + + def model_tides( x: float | list[float] | xr.DataArray, y: float | list[float] | xr.DataArray, @@ -387,7 +396,7 @@ def model_tides( extrapolate: bool = True, cutoff: float | None = None, crop: bool = True, - crop_buffer: float | None = None, + crop_buffer: float | None = 5, parallel: bool = True, parallel_splits: int | str = "auto", parallel_max: int | None = None, @@ -431,9 +440,10 @@ def model_tides( datetime.datetime and strings (e.g. "2020-01-01 23:00"). For example: `time=pd.date_range(start="2000", end="2001", freq="5h")` model : str or list of str, optional - The tide model (or models) to use to model tides. - Defaults to "EOT20"; for a full list of available/supported - models, run `eo_tides.model.list_models`. + The tide model (or list of models) to use to model tides. + Defaults to "EOT20"; specify "all" to use all models available + in `directory`. For a full list of available and supported models, + run `eo_tides.model.list_models`. directory : str, optional The directory containing tide model data files. If no path is provided, this will default to the environment variable @@ -483,18 +493,19 @@ def model_tides( valid tide modelling domain. crop : bool, optional Whether to crop tide model constituent files on-the-fly to - improve performance. Defaults to True; set `crop_buffer` + improve performance. Defaults to True; use `crop_buffer` to customise the buffer distance used to crop the files. crop_buffer : int or float, optional The buffer distance in degrees used to crop tide model - constituent files around the modelling area. Defaults to None, - which will apply a four model-domain pixel buffer. + constituent files around the modelling area. Defaults to 5, + which will crop constituents using a five degree buffer on either + side of the analysis extent. parallel : bool, optional - Whether to parallelise tide modelling using `concurrent.futures`. - If multiple tide models are requested, these will be run in - parallel. Optionally, tide modelling can also be run in parallel - across input x and y coordinates (see "parallel_splits" below). - Default is True. + Whether to parallelise tide modelling. If multiple tide models are + requested, these will be run in parallel using `concurrent.futures`. + If enough workers are available, the analysis will also be split + into spatial chunks for additional parallelisation (see "parallel_splits" + below). Default is True. parallel_splits : str or int, optional Whether to split the input x and y coordinates into smaller, evenly-sized chunks that are processed in parallel. This can @@ -654,7 +665,7 @@ def model_tides( # Optionally compute ensemble model and add to dataframe if "ensemble" in models_requested: - ensemble_df = _ensemble_model(tide_df, crs, ensemble_models, **ensemble_kwargs) + ensemble_df = ensemble_tides(tide_df, crs, ensemble_models, **ensemble_kwargs) # Update requested models with any custom ensemble models, then # filter the dataframe to keep only models originally requested @@ -718,9 +729,10 @@ def model_phases( datetime.datetime and strings (e.g. "2020-01-01 23:00"). For example: `time=pd.date_range(start="2000", end="2001", freq="5h")` model : str or list of str, optional - The tide model (or models) to use to compute tide phases. - Defaults to "EOT20"; for a full list of available/supported - models, run `eo_tides.model.list_models`. + The tide model (or list of models) to use to model tides. + Defaults to "EOT20"; specify "all" to use all models available + in `directory`. For a full list of available and supported models, + run `eo_tides.model.list_models`. directory : str, optional The directory containing tide model data files. If no path is provided, this will default to the environment variable diff --git a/eo_tides/stats.py b/eo_tides/stats.py index fe00f9b..660f0ac 100644 --- a/eo_tides/stats.py +++ b/eo_tides/stats.py @@ -450,10 +450,12 @@ def pixel_stats( that can be converted by `pandas.to_datetime()`. For example: `time=pd.date_range(start="2000", end="2001", freq="5h")` model : str or list of str, optional - The tide model (or models) to use to model tides. If a list is - provided, a new "tide_model" dimension will be added to `data`. - Defaults to "EOT20"; for a full list of available/supported - models, run `eo_tides.model.list_models`. + The tide model (or list of models) to use to model tides. + If a list is provided, a new "tide_model" dimension will be + added to the `xarray.DataArray` outputs. Defaults to "EOT20"; + specify "all" to use all models available in `directory`. + For a full list of available and supported models, run + `eo_tides.model.list_models`. directory : str, optional The directory containing tide model data files. If no path is provided, this will default to the environment variable diff --git a/eo_tides/utils.py b/eo_tides/utils.py index 1a4c2ad..483ac83 100644 --- a/eo_tides/utils.py +++ b/eo_tides/utils.py @@ -280,7 +280,7 @@ def clip_models( output_directory: str | os.PathLike, bbox: tuple[float, float, float, float], model: list | None = None, - buffer: float = 1, + buffer: float = 5, overwrite: bool = False, ): """ @@ -313,7 +313,7 @@ def clip_models( in the input directly. buffer : float, optional Buffer distance (in degrees) added to the bounding box to provide - sufficient data on edges of study area. Defaults to 1 degree. + sufficient data on edges of study area. Defaults to 5 degrees. overwrite : bool, optional If True, overwrite existing files in the output directory. Defaults to False. diff --git a/pyproject.toml b/pyproject.toml index bc4206d..b33df1e 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -43,6 +43,7 @@ dependencies = [ "odc-geo>=0.4.7", "pandas>=2.2.0", "psutil>=5.8.0", + "pyogrio>=0.3.0", "pyproj>=3.6.1", "pyTMD==2.1.8", "scikit-learn>=1.4.0", @@ -114,6 +115,7 @@ preview = true [tool.deptry.per_rule_ignores] DEP002 = [ "folium", + "pyogrio", ] [tool.coverage.report] diff --git a/uv.lock b/uv.lock index caa22de..34c41fd 100644 --- a/uv.lock +++ b/uv.lock @@ -728,6 +728,7 @@ dependencies = [ { name = "odc-geo" }, { name = "pandas" }, { name = "psutil" }, + { name = "pyogrio" }, { name = "pyproj" }, { name = "pytmd" }, { name = "scikit-learn" }, @@ -778,6 +779,7 @@ requires-dist = [ { name = "pandas", specifier = ">=2.2.0" }, { name = "planetary-computer", marker = "extra == 'notebooks'", specifier = ">=1.0.0" }, { name = "psutil", specifier = ">=5.8.0" }, + { name = "pyogrio", specifier = ">=0.3.0" }, { name = "pyproj", specifier = ">=3.6.1" }, { name = "pystac-client", marker = "extra == 'notebooks'", specifier = ">=0.8.3" }, { name = "pytmd", specifier = "==2.1.8" }, From 9c43102ed2cb5c3bdfc1cd39c19ea79fe650e284 Mon Sep 17 00:00:00 2001 From: Robbi Bishop-Taylor Date: Thu, 19 Dec 2024 03:56:37 +0000 Subject: [PATCH 05/10] Try upgrading pyogrio --- pyproject.toml | 2 +- uv.lock | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/pyproject.toml b/pyproject.toml index b33df1e..3d321c0 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -43,7 +43,7 @@ dependencies = [ "odc-geo>=0.4.7", "pandas>=2.2.0", "psutil>=5.8.0", - "pyogrio>=0.3.0", + "pyogrio>=0.4.0", "pyproj>=3.6.1", "pyTMD==2.1.8", "scikit-learn>=1.4.0", diff --git a/uv.lock b/uv.lock index 34c41fd..ebfcb74 100644 --- a/uv.lock +++ b/uv.lock @@ -779,7 +779,7 @@ requires-dist = [ { name = "pandas", specifier = ">=2.2.0" }, { name = "planetary-computer", marker = "extra == 'notebooks'", specifier = ">=1.0.0" }, { name = "psutil", specifier = ">=5.8.0" }, - { name = "pyogrio", specifier = ">=0.3.0" }, + { name = "pyogrio", specifier = ">=0.4.0" }, { name = "pyproj", specifier = ">=3.6.1" }, { name = "pystac-client", marker = "extra == 'notebooks'", specifier = ">=0.8.3" }, { name = "pytmd", specifier = "==2.1.8" }, From 0f642b59dbe3aac121b5323cfe0825be9a57d1a6 Mon Sep 17 00:00:00 2001 From: Robbi Bishop-Taylor Date: Thu, 19 Dec 2024 03:57:54 +0000 Subject: [PATCH 06/10] Try upgrading pyogrio --- pyproject.toml | 2 +- uv.lock | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/pyproject.toml b/pyproject.toml index 3d321c0..80bdd3e 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -43,7 +43,7 @@ dependencies = [ "odc-geo>=0.4.7", "pandas>=2.2.0", "psutil>=5.8.0", - "pyogrio>=0.4.0", + "pyogrio>=0.5.0", "pyproj>=3.6.1", "pyTMD==2.1.8", "scikit-learn>=1.4.0", diff --git a/uv.lock b/uv.lock index ebfcb74..34e4906 100644 --- a/uv.lock +++ b/uv.lock @@ -779,7 +779,7 @@ requires-dist = [ { name = "pandas", specifier = ">=2.2.0" }, { name = "planetary-computer", marker = "extra == 'notebooks'", specifier = ">=1.0.0" }, { name = "psutil", specifier = ">=5.8.0" }, - { name = "pyogrio", specifier = ">=0.4.0" }, + { name = "pyogrio", specifier = ">=0.5.0" }, { name = "pyproj", specifier = ">=3.6.1" }, { name = "pystac-client", marker = "extra == 'notebooks'", specifier = ">=0.8.3" }, { name = "pytmd", specifier = "==2.1.8" }, From 88e439bd3ada0b2e588b262dd1f9434a5d16d5f7 Mon Sep 17 00:00:00 2001 From: Robbi Bishop-Taylor Date: Thu, 19 Dec 2024 03:58:44 +0000 Subject: [PATCH 07/10] Try upgrading pyogrio --- pyproject.toml | 2 +- uv.lock | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/pyproject.toml b/pyproject.toml index 80bdd3e..1ae9b7b 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -43,7 +43,7 @@ dependencies = [ "odc-geo>=0.4.7", "pandas>=2.2.0", "psutil>=5.8.0", - "pyogrio>=0.5.0", + "pyogrio>=0.6.0", "pyproj>=3.6.1", "pyTMD==2.1.8", "scikit-learn>=1.4.0", diff --git a/uv.lock b/uv.lock index 34e4906..dd11c47 100644 --- a/uv.lock +++ b/uv.lock @@ -779,7 +779,7 @@ requires-dist = [ { name = "pandas", specifier = ">=2.2.0" }, { name = "planetary-computer", marker = "extra == 'notebooks'", specifier = ">=1.0.0" }, { name = "psutil", specifier = ">=5.8.0" }, - { name = "pyogrio", specifier = ">=0.5.0" }, + { name = "pyogrio", specifier = ">=0.6.0" }, { name = "pyproj", specifier = ">=3.6.1" }, { name = "pystac-client", marker = "extra == 'notebooks'", specifier = ">=0.8.3" }, { name = "pytmd", specifier = "==2.1.8" }, From 33d2d783cbc64ac0d9c42e4f8fd10e28cba7c865 Mon Sep 17 00:00:00 2001 From: Robbi Bishop-Taylor Date: Thu, 19 Dec 2024 04:00:38 +0000 Subject: [PATCH 08/10] Try upgrading pyogrio --- pyproject.toml | 2 +- uv.lock | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/pyproject.toml b/pyproject.toml index 1ae9b7b..719ff5d 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -43,7 +43,7 @@ dependencies = [ "odc-geo>=0.4.7", "pandas>=2.2.0", "psutil>=5.8.0", - "pyogrio>=0.6.0", + "pyogrio>=0.7.0", "pyproj>=3.6.1", "pyTMD==2.1.8", "scikit-learn>=1.4.0", diff --git a/uv.lock b/uv.lock index dd11c47..3aea1b4 100644 --- a/uv.lock +++ b/uv.lock @@ -779,7 +779,7 @@ requires-dist = [ { name = "pandas", specifier = ">=2.2.0" }, { name = "planetary-computer", marker = "extra == 'notebooks'", specifier = ">=1.0.0" }, { name = "psutil", specifier = ">=5.8.0" }, - { name = "pyogrio", specifier = ">=0.6.0" }, + { name = "pyogrio", specifier = ">=0.7.0" }, { name = "pyproj", specifier = ">=3.6.1" }, { name = "pystac-client", marker = "extra == 'notebooks'", specifier = ">=0.8.3" }, { name = "pytmd", specifier = "==2.1.8" }, From 10ca60136f3a8c74a3d5604634b70594e74c4a6a Mon Sep 17 00:00:00 2001 From: Robbi Bishop-Taylor Date: Thu, 19 Dec 2024 04:34:06 +0000 Subject: [PATCH 09/10] Fix typo --- eo_tides/model.py | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/eo_tides/model.py b/eo_tides/model.py index 895b46d..6ccedf1 100644 --- a/eo_tides/model.py +++ b/eo_tides/model.py @@ -218,14 +218,14 @@ def ensemble_tides( This function performs the following steps: 1. Takes a dataframe of tide heights from multiple tide models, as produced by `eo_tides.model.model_tides` - 1. Loads model ranking points from an external file, filters them + 2. Loads model ranking points from an external file, filters them based on the valid data percentage, and retains relevant columns - 2. Interpolates the model rankings into the coordinates of the + 3. Interpolates the model rankings into the coordinates of the original dataframe using Inverse Weighted Interpolation (IDW) - 3. Uses rankings to combine multiple tide models into a single + 4. Uses rankings to combine multiple tide models into a single optimised ensemble model (by default, by taking the mean of the top 3 ranked models) - 4. Returns a new dataFrame with the combined ensemble model predictions + 5. Returns a new dataFrame with the combined ensemble model predictions Parameters ---------- From f734d831dff6a0c7d98bf0186cbb9c668e4035c1 Mon Sep 17 00:00:00 2001 From: Robbi Bishop-Taylor Date: Thu, 19 Dec 2024 04:42:04 +0000 Subject: [PATCH 10/10] Update changelog --- docs/changelog.md | 15 +++++++++++++++ 1 file changed, 15 insertions(+) diff --git a/docs/changelog.md b/docs/changelog.md index 81ad377..5382efa 100644 --- a/docs/changelog.md +++ b/docs/changelog.md @@ -1,5 +1,20 @@ # Changelog +## v0.3.2 (upcoming) + +### New features + +- Publishes ensemble tide modelling code for combining multiple global ocean tide models into a single locally optimised ensemble tide model using external model ranking data (e.g. satellite altimetry or NDWI-tide correlations along the coastline) + - Update ensemble code to latest version that includes FES2022, GOT5.6 and TPXO10 + - Make ensemble model calculation function a top level function (i.e. rename from `_ensemble_model` to `ensemble_tides`) + - Load tide model ranking points from external flatgeobuff format file for faster cloud access +- Make buffer distance applied when cropping model files configurable via the `crop_buffer` param, with a default of 5 degrees +- Reorder `model_tides` params to provide more logical flow and move more common params like `mode`, `output_format` and `output_units` higher + +### Bug fixes + +- Fix warnings from `load_gauge_gesla` function + ## v0.3.1 (2024-11-15) ### New features