wavespectra 3.18.0__tar.gz → 4.0.0__tar.gz

{wavespectra-3.18.0/wavespectra.egg-info → wavespectra-4.0.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: wavespectra
-Version: 3.18.0
+Version: 4.0.0
 Summary: Library for ocean wave spectra
 Author-email: Wavespectra Developers <r.guedes@oceanum.science>
 Maintainer-email: Rafael Guedes <r.guedes@oceanum.science>, Tom Durrant <t.durrant@oceanum.science>
@@ -41,22 +41,18 @@ Classifier: Programming Language :: Python :: 3.8
 Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
-Requires-Python: <3.12,>=3.8
+Classifier: Programming Language :: Python :: 3.12
+Requires-Python: >=3.8
 Description-Content-Type: text/x-rst
 License-File: LICENSE.txt
 License-File: AUTHORS.rst
 Requires-Dist: click
-Requires-Dist: cmocean
 Requires-Dist: dask
 Requires-Dist: matplotlib
-Requires-Dist: numba
-Requires-Dist: pandas
 Requires-Dist: python-dateutil
 Requires-Dist: pyyaml
 Requires-Dist: sortedcontainers
 Requires-Dist: scipy
-Requires-Dist: toolz
-Requires-Dist: typing_extensions
 Requires-Dist: xarray
 Provides-Extra: test
 Requires-Dist: pytest; extra == "test"
@@ -65,13 +61,17 @@ Requires-Dist: ruff; extra == "test"
 Provides-Extra: extra
 Requires-Dist: fsspec; extra == "extra"
 Requires-Dist: gcsfs; extra == "extra"
+Requires-Dist: h5netcdf; extra == "extra"
 Requires-Dist: netCDF4; extra == "extra"
 Requires-Dist: zarr; extra == "extra"
-Requires-Dist: h5netcdf; extra == "extra"
 Provides-Extra: docs
 Requires-Dist: autodoc; extra == "docs"
+Requires-Dist: cmocean; extra == "docs"
 Requires-Dist: ipython; extra == "docs"
+Requires-Dist: pickleshare; extra == "docs"
 Requires-Dist: pydata_sphinx_theme; extra == "docs"
+Requires-Dist: sphinxcontrib-programoutput; extra == "docs"
+Requires-Dist: sphinx-book-theme; extra == "docs"
 Requires-Dist: sphinx; extra == "docs"
 Requires-Dist: sphinx-autobuild; extra == "docs"
 Requires-Dist: sphinx-autodoc-typehints; extra == "docs"

{wavespectra-3.18.0 → wavespectra-4.0.0}/pyproject.toml

@@ -29,21 +29,17 @@ classifiers = [
     "Programming Language :: Python :: 3.9",
     "Programming Language :: Python :: 3.10",
     "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
 ]
-requires-python = ">=3.8,<3.12"
+requires-python = ">=3.8"
 dependencies = [
     "click",
-    "cmocean",
     "dask",
     "matplotlib",
-    "numba",
-    "pandas",
     "python-dateutil",
     "pyyaml",
     "sortedcontainers",
     "scipy",
-    "toolz",
-    "typing_extensions",
     "xarray",
 ]
 dynamic = ["version"]
@@ -57,19 +53,41 @@ dynamic = ["version"]
 [project.scripts]
 wavespectra = "wavespectra.cli:main"
 
+[project.entry-points."xarray.backends"]
+era5 = "wavespectra.input.era5:ERA5BackendEntrypoint"
+funwave = "wavespectra.input.funwave:FunwaveBackendEntrypoint"
+json = "wavespectra.input.json:JsonBackendEntrypoint"
+ncswan = "wavespectra.input.ncswan:NCSwanBackendEntrypoint"
+ndbc = "wavespectra.input.ndbc:NDBCBackendEntrypoint"
+ndbc_ascii = "wavespectra.input.ndbc_ascii:NDBCASCIIBackendEntrypoint"
+netcdf = "wavespectra.input.netcdf:NetCDFBackendEntrypoint"
+octopus = "wavespectra.input.octopus:OctopusBackendEntrypoint"
+spotter = "wavespectra.input.spotter:SpotterBackendEntrypoint"
+swan = "wavespectra.input.swan:SWANBackendEntrypoint"
+triaxys = "wavespectra.input.triaxys:TRIAXYSBackendEntrypoint"
+wavespectra = "wavespectra.input.wavespectra:WavespectraBackendEntrypoint"
+wwm = "wavespectra.input.wwm:WWMBackendEntrypoint"
+ww3 = "wavespectra.input.ww3:WW3BackendEntrypoint"
+ww3_station = "wavespectra.input.ww3_station:WW3StationBackendEntrypoint"
+xwaves = "wavespectra.input.xwaves:XWavesBackendEntrypoint"
+
 [project.optional-dependencies]
 test = ["pytest", "tox", "ruff"]
 extra = [
     "fsspec",
     "gcsfs",
+    "h5netcdf",
     "netCDF4",
     "zarr",
-    "h5netcdf",
 ]
 docs = [
     "autodoc",
+    "cmocean",
     "ipython",
+    "pickleshare",
     "pydata_sphinx_theme",
+    "sphinxcontrib-programoutput",
+    "sphinx-book-theme",
     "sphinx",
     "sphinx-autobuild",
     "sphinx-autodoc-typehints",
@@ -79,11 +97,14 @@ docs = [
 [tool.setuptools.package-data]
 "wavespectra.core" = ["*.yml"]
 "wavespectra.output" = ["*.yml"]
-"wavespectra.specpart" = ["specpart.f90", "specpart.pyf"]
+"wavespectra.specpartc" = ["specpartc.c", "specpartc.h", "specpartc_wrap.c"]
 
 [tool.setuptools.dynamic]
 version = {attr = "wavespectra.__version__"}
 
+[tool.ruff]
+line-length = 88
+
 [tool.ruff.extend-per-file-ignores]
 "wavespectra/__init__.py" = ["F401"]
 "wavespectra/specdataset.py" = ["F401"]
@@ -95,6 +116,16 @@ version = {attr = "wavespectra.__version__"}
 "wavespectra/input/spotter.py" = ["F401"]
 "wavespectra/input/dataset.py" = ["F401"]
 "wavespectra/input/swan.py" = ["F401"]
+"wavespectra/construct.py" = ["F401"]
+"wavespectra/directional.py" = ["F401"]
+"wavespectra/fit/pierson_moskowitz.py" = ["F401"]
+"wavespectra/fit/tma.py" = ["F401"]
+"wavespectra/input/funwave.py" = ["F401"]
+"wavespectra/input/ndbc.py" = ["F401"]
+"wavespectra/input/ndbc_ascii.py" = ["F401"]
+"wavespectra/input/octopus.py" = ["F401"]
+"wavespectra/input/wavespectra.py" = ["F401"]
+"wavespectra/input/xwaves.py" = ["F401"]
 
 [tool.tox]
 legacy_tox_ini = """

wavespectra-4.0.0/setup.py

@@ -0,0 +1,16 @@
+from setuptools import setup, Extension
+from numpy import get_include as get_numpy_include
+
+setup(
+    name="wavespectra",
+    ext_modules=[
+        Extension(
+            name="wavespectra.partition.specpartc",
+            sources=[
+                "wavespectra/partition/specpart/specpartc_wrap.c",
+                "wavespectra/partition/specpart/specpartc.c",
+            ],
+            include_dirs=[get_numpy_include()],
+        )
+    ],
+)

wavespectra-4.0.0/tests/test_cli.py

@@ -0,0 +1,103 @@
+"""Test model wrapper."""
+from pathlib import Path
+import pytest
+import xarray as xr
+from click.testing import CliRunner
+
+from wavespectra import cli
+
+
+DATADIR = Path(__file__).parent / "sample_files"
+INFILE = str(DATADIR / "ww3file.nc")
+ENGINE = "ww3"
+
+
+@pytest.fixture(scope="module")
+def runner():
+    instance = CliRunner()
+    yield instance
+
+
+def test_main(runner):
+    result = runner.invoke(cli.main)
+    assert result.exit_code == 0
+    assert "main" in result.output
+
+
+def test_main_convert(runner):
+    result = runner.invoke(cli.main, "convert")
+    assert result.exit_code == 0
+    assert "convert" in result.output
+
+
+def test_main_convert_format(runner, tmpdir):
+    OUTFILE = str(tmpdir / "outspec.nc")
+
+    result = runner.invoke(
+        cli.main, ["convert", "format", INFILE, ENGINE, OUTFILE, "swan"]
+    )
+    assert result.exit_code == 0
+
+    xr.open_dataset(OUTFILE, engine="swan")
+
+
+def test_main_convert_stats(runner, tmpdir):
+    OUTFILE = str(tmpdir / "outstats.nc")
+
+    result = runner.invoke(
+        cli.main, ["convert", "stats", INFILE, ENGINE, OUTFILE, "-p", "hs", "-p", "tp"]
+    )
+    assert result.exit_code == 0
+
+    dset = xr.open_dataset(OUTFILE)
+    assert "hs" in dset.data_vars and "tp" in dset.data_vars
+
+
+def test_main_reconstruct(runner):
+    result = runner.invoke(cli.main, "reconstruct")
+    assert result.exit_code == 0
+    assert "reconstruct" in result.output
+
+
+def test_main_reconstruct_spectra(runner, tmpdir):
+    OUTFILE = str(tmpdir / "outspec.nc")
+
+    result = runner.invoke(
+        cli.main, ["reconstruct", "spectra", INFILE, ENGINE, OUTFILE]
+    )
+    assert result.exit_code == 0
+
+    result = runner.invoke(cli.main, ["reconstruct", "spectra", INFILE, ENGINE, INFILE])
+    assert isinstance(result.exception, ValueError)
+
+    result = runner.invoke(
+        cli.main,
+        [
+            "reconstruct",
+            "spectra",
+            INFILE,
+            ENGINE,
+            OUTFILE,
+            "-p",
+            "3",
+            "-d",
+            "cartwright,cartwright,cartwright",
+        ],
+    )
+    assert result.exit_code == 0
+
+    result = runner.invoke(
+        cli.main,
+        [
+            "reconstruct",
+            "spectra",
+            INFILE,
+            ENGINE,
+            OUTFILE,
+            "-p",
+            "3",
+            "-f",
+            "jonswap,jonswap,jonswap",
+        ],
+    )
+    assert result.exit_code == 0

wavespectra-4.0.0/tests/test_cookiecutter_template.py

@@ -0,0 +1,37 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+"""Tests for `wavespectra` package."""
+
+import pytest
+
+from click.testing import CliRunner
+
+from wavespectra import cli
+
+
+# @pytest.fixture
+# def response():
+#     """Sample pytest fixture.
+
+#     See more at: http://doc.pytest.org/en/latest/fixture.html
+#     """
+#     # import requests
+#     # return requests.get('https://github.com/audreyr/cookiecutter-pypackage')
+
+
+# def test_content(response):
+#     """Sample pytest test function with the pytest fixture as an argument."""
+#     # from bs4 import BeautifulSoup
+#     # assert 'GitHub' in BeautifulSoup(response.content).title.string
+
+
+# def test_command_line_interface():
+#     """Test the CLI."""
+#     runner = CliRunner()
+#     result = runner.invoke(cli.main)
+#     assert result.exit_code == 0
+#     assert "wavespectra.cli.main" in result.output
+#     help_result = runner.invoke(cli.main, ["--help"])
+#     assert help_result.exit_code == 0
+#     assert "--help  Show this message and exit." in help_result.output

wavespectra-4.0.0/tests/test_partition.py

@@ -0,0 +1,397 @@
+import pytest
+from pathlib import Path
+import numpy as np
+import xarray as xr
+
+from wavespectra import read_ww3
+from wavespectra.partition.partition import (
+    Partition,
+    np_ptm1,
+    np_ptm2,
+    np_ptm3,
+    np_hp01,
+)
+from wavespectra.core.utils import waveage
+from wavespectra.core import npstats
+from wavespectra.partition.tracking import track_partitions
+
+
+HERE = Path(__file__).parent
+
+
+class BasePTM:
+    def setup_class(self):
+        self.dset = read_ww3(HERE / "sample_files/ww3file.nc")
+        self.efth = self.dset.isel(time=0, site=0).efth.values
+        self.freq = self.dset.freq.values
+        self.dir = self.dset.dir.values
+        self.pt = Partition(self.dset)
+
+    @property
+    def hs_full(self):
+        return npstats.hs(self.efth, self.freq, self.dir)
+
+    @property
+    def hs_from_partitions(self):
+        hs_partitions = [npstats.hs(efth, self.freq, self.dir) for efth in self.out]
+        return np.sqrt(np.sum(np.power(hs_partitions, 2)))
+
+
+class TestPTM1(BasePTM):
+    def setup_class(self):
+        super().setup_class(self)
+        self.wspd = self.dset.isel(time=0, site=0).wspd.values
+        self.wdir = self.dset.isel(time=0, site=0).wdir.values
+        self.dpt = self.dset.isel(time=0, site=0).dpt.values
+        self.agefac = 1.7
+        self.wscut = 0.3333
+        self.swells = 3
+
+    def _exec(self, **kwargs):
+        out = np_ptm1(
+            spectrum=self.efth,
+            spectrum_smooth=self.efth,
+            freq=self.freq,
+            dir=self.dir,
+            wspd=self.wspd,
+            wdir=self.wdir,
+            dpt=self.dpt,
+            agefac=kwargs.get("agefac", self.agefac),
+            wscut=kwargs.get("wscut", self.wscut),
+            swells=kwargs.get("swells", self.swells),
+        )
+        return out
+
+    def test_defaults(self):
+        self.out = self._exec()
+        assert self.out.shape[0] == self.swells + 1
+        assert self.hs_full == pytest.approx(self.hs_from_partitions)
+
+    def test_request_all_partitions(self):
+        self.out = self._exec(swells=None)
+        assert self.out.shape[0] == 3
+        assert self.hs_full == pytest.approx(self.hs_from_partitions)
+
+    def test_request_less_partitions(self):
+        swells = 2
+        self.out = self._exec(swells=swells)
+        assert self.hs_from_partitions < self.hs_full
+        assert len(self.out) == swells + 1
+
+    def test_partition_class(self):
+        swells = 2
+        self.out = self._exec(swells=swells)
+        dspart = self.pt.ptm1(
+            wspd=self.dset.wspd,
+            wdir=self.dset.wdir,
+            dpt=self.dset.dpt,
+            swells=swells,
+        )
+        hs_dspart = np.sqrt(np.sum(dspart.isel(time=0, site=0).spec.hs().values ** 2))
+        assert hs_dspart == pytest.approx(self.hs_from_partitions, rel=1e-2)
+
+    def test_smoothing(self):
+        swells = 2
+        ds_nosmoothing = self.pt.ptm1(
+            wspd=self.dset.wspd,
+            wdir=self.dset.wdir,
+            dpt=self.dset.dpt,
+            swells=swells,
+        )
+        ds_smoothing = self.pt.ptm1(
+            wspd=self.dset.wspd,
+            wdir=self.dset.wdir,
+            dpt=self.dset.dpt,
+            swells=swells,
+            smooth=True,
+        )
+        assert not ds_nosmoothing.spec.hs().equals(ds_smoothing.spec.hs())
+
+
+class TestPTM2(BasePTM):
+    def setup_class(self):
+        super().setup_class(self)
+        self.wspd = self.dset.isel(time=0, site=0).wspd.values
+        self.wdir = self.dset.isel(time=0, site=0).wdir.values
+        self.dpt = self.dset.isel(time=0, site=0).dpt.values
+        self.agefac = 1.7
+        self.wscut = 0.3333
+        self.swells = 3
+
+    def _exec(self, **kwargs):
+        out = np_ptm2(
+            spectrum=self.efth,
+            spectrum_smooth=self.efth,
+            freq=self.freq,
+            dir=self.dir,
+            wspd=self.wspd,
+            wdir=self.wdir,
+            dpt=self.dpt,
+            agefac=kwargs.get("agefac", self.agefac),
+            wscut=kwargs.get("wscut", self.wscut),
+            swells=kwargs.get("swells", self.swells),
+        )
+        return out
+
+    def test_defaults(self):
+        self.out = self._exec()
+        assert self.out.shape[0] == self.swells + 2
+        assert self.hs_full == pytest.approx(self.hs_from_partitions)
+
+    def test_request_all_partitions(self):
+        self.out = self._exec(swells=None)
+        assert self.out.shape[0] == 4
+        assert self.hs_full == pytest.approx(self.hs_from_partitions)
+
+    def test_request_less_partitions(self):
+        swells = 2
+        self.out = self._exec(swells=swells)
+        assert self.hs_from_partitions < self.hs_full
+        assert len(self.out) == swells + 2
+
+    def test_less_partitions_combined(self):
+        swells = 2
+        self.out = self._exec(swells=swells)
+        assert self.hs_full == pytest.approx(self.hs_from_partitions)
+        assert len(self.out) == swells + 2
+
+    def test_partition_class(self):
+        swells = 2
+        combine = False
+        self.out = self._exec(swells=swells)
+        dspart = self.pt.ptm2(
+            wspd=self.dset.wspd,
+            wdir=self.dset.wdir,
+            dpt=self.dset.dpt,
+            swells=swells,
+        )
+        hs_dspart = np.sqrt(np.sum(dspart.isel(time=0, site=0).spec.hs().values ** 2))
+        assert hs_dspart == pytest.approx(self.hs_from_partitions, rel=1e-2)
+
+    def test_smoothing(self):
+        swells = 2
+        ds_nosmoothing = self.pt.ptm1(
+            wspd=self.dset.wspd,
+            wdir=self.dset.wdir,
+            dpt=self.dset.dpt,
+            swells=swells,
+        )
+        ds_smoothing = self.pt.ptm1(
+            wspd=self.dset.wspd,
+            wdir=self.dset.wdir,
+            dpt=self.dset.dpt,
+            swells=swells,
+            smooth=True,
+        )
+        assert not ds_nosmoothing.spec.hs().equals(ds_smoothing.spec.hs())
+
+
+class TestPTM3(BasePTM):
+    def _exec(self, parts):
+        out = np_ptm3(
+            spectrum=self.dset.efth.isel(time=0, site=0).values,
+            spectrum_smooth=self.dset.efth.isel(time=0, site=0).values,
+            freq=self.dset.freq.values,
+            dir=self.dset.dir.values,
+            parts=parts,
+        )
+        return out
+
+    def test_request_all_partitions(self):
+        self.out = self._exec(parts=None)
+        assert self.hs_full == pytest.approx(self.hs_from_partitions)
+
+    def test_request_less_partitions(self):
+        parts = 2
+        self.out = self._exec(parts=parts)
+        assert self.hs_from_partitions < self.hs_full
+        assert len(self.out) == parts
+
+    def test_more_partitions(self):
+        parts = 5
+        self.out = self._exec(parts=parts)
+        assert self.hs_full == pytest.approx(self.hs_from_partitions)
+        assert len(self.out) == parts
+        assert self.out[3:4].sum() == 0
+
+    def test_partition_class(self):
+        parts = 2
+        self.out = self._exec(parts=parts)
+        dspart = self.pt.ptm3(parts=parts, smooth=False)
+        hs_dspart = np.sqrt(np.sum(dspart.isel(time=0, site=0).spec.hs().values ** 2))
+        assert hs_dspart == pytest.approx(self.hs_from_partitions)
+
+    def test_partition_class_smoothing(self):
+        parts = 3
+        ds_nosmoothing = self.pt.ptm3(parts=parts)
+        ds_smoothing = self.pt.ptm3(parts=parts, smooth=True)
+        assert not ds_nosmoothing.spec.hs().equals(ds_smoothing.spec.hs())
+
+
+class TestPTM4(BasePTM):
+    def test_agefac(self):
+        ds_agefac15 = self.pt.ptm4(
+            wspd=self.dset.wspd, wdir=self.dset.wdir, dpt=self.dset.dpt, agefac=1.5
+        )
+        ds_agefac17 = self.pt.ptm4(
+            wspd=self.dset.wspd,
+            wdir=self.dset.wdir,
+            dpt=self.dset.dpt,
+        )
+        sea_agefac15 = ds_agefac15.isel(part=0).spec.hs()
+        sea_agefac17 = ds_agefac17.isel(part=0).spec.hs()
+        assert np.all((sea_agefac17.values - sea_agefac15.values) > 0)
+
+
+class TestPTM5(BasePTM):
+    def test_default(self):
+        fcut = 0.1
+        ds = self.pt.ptm5(fcut=0.1)
+        assert fcut in ds.freq
+        assert ds.isel(part=0).sel(freq=slice(None, fcut - 0.001)).spec.hs().max() == 0
+        assert ds.isel(part=1).sel(freq=slice(fcut + 0.001, None)).spec.hs().max() == 0
+
+    def test_not_interpolate(self):
+        fcut = 0.1
+        ds = self.pt.ptm5(fcut=0.1, interpolate=False)
+        assert fcut not in ds.freq
+
+
+class TestHP01(BasePTM):
+    def setup_class(self):
+        super().setup_class(self)
+        self.agefac = 1.7
+        self.wscut = 0.3333
+        self.swells = 3
+        wspd = self.dset.wspd.isel(time=0, site=0)
+        wdir = self.dset.wdir.isel(time=0, site=0)
+        dpt = self.dset.dpt.isel(time=0, site=0)
+        self.windseamask = waveage(
+            self.dset.freq, self.dset.dir, wspd, wdir, dpt, self.agefac
+        )
+
+    def _exec(self, **kwargs):
+        out = np_hp01(
+            spectrum=self.efth,
+            spectrum_smooth=self.efth,
+            windseamask=self.windseamask,
+            freq=self.freq,
+            dir=self.dir,
+            wscut=kwargs.get("wscut", self.wscut),
+            swells=kwargs.get("swells", self.swells),
+        )
+        return out
+
+    def test_defaults(self):
+        self.out = self._exec()
+        # assert self.out.shape[0] == self.swells + 1
+        # assert self.hs_full == pytest.approx(self.hs_from_partitions)
+
+    # def test_request_all_partitions(self):
+    #     self.out = self._exec(swells=None)
+    #     assert self.out.shape[0] == 3
+    #     assert self.hs_full == pytest.approx(self.hs_from_partitions)
+
+    # def test_request_less_partitions(self):
+    #     swells = 2
+    #     self.out = self._exec(swells=swells)
+    #     assert self.hs_from_partitions < self.hs_full
+    #     assert len(self.out) == swells + 1
+
+    def test_partition_class(self):
+        swells = 2
+        self.out = self._exec(swells=swells)
+        dspart = self.pt.hp01(
+            wspd=self.dset.wspd,
+            wdir=self.dset.wdir,
+            dpt=self.dset.dpt,
+            agefac=self.agefac,
+            swells=swells,
+        )
+        hs_dspart = np.sqrt(np.sum(dspart.isel(time=0, site=0).spec.hs().values ** 2))
+        # assert hs_dspart == pytest.approx(self.hs_from_partitions, rel=1e-2)
+
+    # def test_smoothing(self):
+    #     swells = 2
+    #     ds_nosmoothing = self.pt.ptm1(
+    #         wspd=self.dset.wspd,
+    #         wdir=self.dset.wdir,
+    #         dpt=self.dset.dpt,
+    #         swells=swells,
+    #     )
+    #     ds_smoothing = self.pt.ptm1(
+    #         wspd=self.dset.wspd,
+    #         wdir=self.dset.wdir,
+    #         dpt=self.dset.dpt,
+    #         swells=swells,
+    #         smooth=True,
+    #     )
+    #     assert not ds_nosmoothing.spec.hs().equals(ds_smoothing.spec.hs())
+
+    # def test_compare_legacy(self):
+    #     kwargs = {"agefac": self.agefac, "wscut": self.wscut, "swells": self.swells}
+    #     old = self.dset.spec.partition_deprecated(
+    #         wsp_darr=self.dset.wspd,
+    #         wdir_darr=self.dset.wdir,
+    #         dep_darr=self.dset.dpt,
+    #         **kwargs,
+    #     )
+    #     new = self.pt.ptm1(
+    #         wspd=self.dset.wspd, wdir=self.dset.wdir, dpt=self.dset.dpt, **kwargs,
+    #     )
+    #     assert  np.array_equal(old.spec.hs().values, new.spec.hs().values)
+
+
+class TestBbox(BasePTM):
+    def test_default(self):
+        bboxes = [
+            dict(fmin=0.1, fmax=0.2, dmin=None, dmax=None),
+            dict(fmin=0.2, fmax=0.3, dmin=None, dmax=None),
+        ]
+        ds = self.pt.bbox(bboxes=bboxes)
+        assert ds.part.size == 3
+
+    def test_ignore_dlimits(self):
+        bboxes = [dict(fmin=0.1, fmax=0.2), dict(fmin=0.2, fmax=0.3)]
+        ds = self.pt.bbox(bboxes=bboxes)
+        assert ds.part.size == 3
+
+    def test_overlap(self):
+        bboxes = [
+            dict(fmin=0.1, fmax=0.2, dmin=None, dmax=None),
+            dict(fmin=0.15, fmax=0.3, dmin=None, dmax=None),
+        ]
+        with pytest.raises(ValueError):
+            ds = self.pt.bbox(bboxes=bboxes)
+
+    def test_freq_increasing(self):
+        bboxes = [dict(fmin=0.2, fmax=0.1, dmin=None, dmax=None)]
+        with pytest.raises(ValueError):
+            ds = self.pt.bbox(bboxes=bboxes)
+
+
+class TestPartitionAndTrack(BasePTM):
+    def setup_class(self):
+        super().setup_class(self)
+
+    def test_partition_class(self):
+        swells = 2
+        dspart = self.pt.ptm1(
+            wspd=self.dset.wspd,
+            wdir=self.dset.wdir,
+            dpt=self.dset.dpt,
+            swells=swells,
+        )
+        stats = dspart.spec.stats(["fp", "dpm"]).load()
+        part_ids = track_partitions(stats, wspd=self.dset.wspd)
+
+    def test_class(self):
+        swells = 2
+        dspart = self.pt.ptm1_track(
+            wspd=self.dset.wspd,
+            wdir=self.dset.wdir,
+            dpt=self.dset.dpt,
+            swells=swells,
+        )
+        assert "part_id" in dspart
+        assert "npart_id" in dspart