ctdproc 0.2.0__tar.gz → 0.3.0__tar.gz

{ctdproc-0.2.0 → ctdproc-0.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ctdproc
-Version: 0.2.0
+Version: 0.3.0
 Summary: CTD data processing
 Author: Gunnar Voet
 Author-email: Gunnar Voet <gvoet@ucsd.edu>
@@ -22,10 +22,10 @@ Requires-Dist: scipy>=1.13.1
 Requires-Dist: xarray>=2024.7.0
 Requires-Dist: xmltodict>=1.0.2
 Requires-Python: >=3.9
-Project-URL: Bug Tracker, https://github.com/gunnarvoet/ctdproc/issues
-Project-URL: Changelog, https://github.com/gunnarvoet/ctdproc/blob/main/HISTORY.rst
-Project-URL: Documentation, https://ctdproc.readthedocs.io
 Project-URL: Homepage, https://github.com/gunnarvoet/ctdproc
+Project-URL: Documentation, https://ctdproc.readthedocs.io
+Project-URL: Changelog, https://github.com/gunnarvoet/ctdproc/blob/main/HISTORY.rst
+Project-URL: Bug Tracker, https://github.com/gunnarvoet/ctdproc/issues
 Description-Content-Type: text/x-rst
 
 =======

ctdproc-0.3.0/pyproject.toml

@@ -0,0 +1,78 @@
+[project]
+name = "ctdproc"
+version = "0.3.0"
+description = "CTD data processing"
+readme = "README.rst"
+license = "MIT"
+license-files = ["LICENSE"]
+requires-python = ">=3.9"
+dependencies = [
+    "gsw>=3.6.20",
+    "matplotlib>=3.9.4",
+    "munch>=4.0.0",
+    "netcdf4>=1.7.2",
+    "numpy>=2.0.2",
+    "pandas>=2.3.3",
+    "scipy>=1.13.1",
+    "xarray>=2024.7.0",
+    "xmltodict>=1.0.2",
+]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Science/Research",
+    "Topic :: Scientific/Engineering :: Physics",
+    "License :: OSI Approved :: MIT License",
+    "Natural Language :: English",
+    "Programming Language :: Python :: 3",
+]
+
+[[project.authors]]
+name = "Gunnar Voet"
+email = "gvoet@ucsd.edu"
+
+[project.urls]
+Homepage = "https://github.com/gunnarvoet/ctdproc"
+Documentation = "https://ctdproc.readthedocs.io"
+Changelog = "https://github.com/gunnarvoet/ctdproc/blob/main/HISTORY.rst"
+"Bug Tracker" = "https://github.com/gunnarvoet/ctdproc/issues"
+
+[build-system]
+requires = ["uv_build>=0.8.22,<0.10.0"]
+build-backend = "uv_build"
+
+[dependency-groups]
+dev = [
+    "pytest>=8.4.2",
+    "ruff>=0.14.2",
+    { include-group = "docs" },
+]
+docs = [
+    "sphinx>=7.4.7",
+    "sphinx-issues>=5.0.1",
+    "sphinx-rtd-theme>=3.0.2",
+]
+
+[tool.pytest.ini_options]
+minversion = "6.0"
+addopts = [
+    "--strict-markers",
+    "--import-mode=importlib",
+]
+testpaths = ["tests"]
+norecursedirs = [
+    ".git",
+    ".venv",
+    "dist",
+    "build",
+    "__pycache__",
+]
+xfail_strict = true
+
+[tool.ruff]
+exclude = [".venv"]
+
+[[tool.uv.index]]
+name = "testpypi"
+url = "https://test.pypi.org/simple/"
+publish-url = "https://test.pypi.org/legacy/"
+explicit = true

ctdproc-0.2.0/pyproject.toml → ctdproc-0.3.0/pyproject.toml.orig

@@ -1,6 +1,6 @@
 [project]
 name = "ctdproc"
-version = "0.2.0"
+version = "0.3.0"
 description = "CTD data processing"
 readme = "README.rst"
 authors = [ { name = "Gunnar Voet", email = "gvoet@ucsd.edu" }, ]
@@ -41,6 +41,9 @@ build-backend = "uv_build"
 dev = [
     "pytest>=8.4.2",
     "ruff>=0.14.2",
+    {include-group = "docs"},
+]
+docs = [
     "sphinx>=7.4.7",
     "sphinx-issues>=5.0.1",
     "sphinx-rtd-theme>=3.0.2",

{ctdproc-0.2.0 → ctdproc-0.3.0}/src/ctdproc/calcs.py

@@ -2,9 +2,15 @@
 # coding: utf-8
 import gsw
 import numpy as np
-from scipy import signal
 
-from . import helpers
+__all__ = [
+    "swcalcs",
+    "calc_sal",
+    "calc_temp",
+    "calc_sigma",
+    "calc_depth",
+    "calc_allsal",
+]
 
 
 def swcalcs(data):
@@ -50,6 +56,25 @@ def swcalcs(data):
 
 
 def calc_sal(data):
+    """
+    Add absolute and practical salinity for both sensor pairs.
+
+    Adds variables ``SA1``, ``SA2`` (absolute salinity, g/kg) and ``s1``,
+    ``s2`` (practical salinity) to the dataset, computed from
+    conductivity, temperature, pressure, and the cast position via
+    :func:`calc_allsal`.
+
+    Parameters
+    ----------
+    data : xarray.Dataset
+        CTD time series with ``c1``, ``c2``, ``t1``, ``t2``, ``p``,
+        ``lon``, ``lat``.
+
+    Returns
+    -------
+    xarray.Dataset
+        Input augmented with ``SA1``, ``SA2``, ``s1``, ``s2``.
+    """
     # Salinity
     SA1, SP1 = calc_allsal(data.c1, data.t1, data.p, data.lon, data.lat)
     SA2, SP2 = calc_allsal(data.c2, data.t2, data.p, data.lon, data.lat)
@@ -98,13 +123,29 @@ def calc_sal(data):
 
 
 def calc_temp(data):
+    """
+    Add conservative and potential temperature for both sensor pairs.
+
+    Adds variables ``CT1``, ``CT2`` (conservative temperature, deg C) and
+    ``th1``, ``th2`` (potential temperature, deg C, referenced to 0 dbar)
+    to the dataset.
+
+    Parameters
+    ----------
+    data : xarray.Dataset
+        CTD time series with ``SA1``/``SA2``, ``t1``/``t2``, and ``p``. Run
+        :func:`calc_sal` first.
+
+    Returns
+    -------
+    xarray.Dataset
+        Input augmented with ``CT1``, ``CT2``, ``th1``, ``th2``.
+    """
     # Conservative temperature
     for si in ["1", "2"]:
         data["CT{:s}".format(si)] = (
             ("time",),
-            gsw.CT_from_t(
-                data["s{:s}".format(si)], data["t{:s}".format(si)], data.p
-            ).data,
+            gsw.CT_from_t(data[f"SA{si}"], data[f"t{si}"], data.p).data,
             {
                 "long_name": "conservative temperature",
                 "units": "degree_C",
@@ -133,6 +174,23 @@ def calc_temp(data):
 
 
 def calc_sigma(data):
+    """
+    Add potential density anomaly for both sensor pairs.
+
+    Adds variables ``sg1``, ``sg2`` (potential density anomaly, kg/m^3,
+    referenced to 0 dbar) to the dataset.
+
+    Parameters
+    ----------
+    data : xarray.Dataset
+        CTD time series with ``SA1``/``SA2`` and ``CT1``/``CT2``. Run
+        :func:`calc_sal` and :func:`calc_temp` first.
+
+    Returns
+    -------
+    xarray.Dataset
+        Input augmented with ``sg1``, ``sg2``.
+    """
     # Potential density anomaly
     for si in ["1", "2"]:
         data["sg{:s}".format(si)] = (
@@ -152,6 +210,21 @@ def calc_sigma(data):
 
 
 def calc_depth(data):
+    """
+    Add a ``depth`` coordinate (m, positive down) computed from pressure.
+
+    Uses :func:`gsw.z_from_p` with latitude.
+
+    Parameters
+    ----------
+    data : xarray.Dataset
+        CTD time series with ``p`` and ``lat``.
+
+    Returns
+    -------
+    xarray.Dataset
+        Input with a new ``depth`` coordinate.
+    """
     # Depth
     data.coords["depth"] = (
         ("time",),
@@ -197,50 +270,3 @@ def calc_allsal(c, t, p, lon, lat):
         SP = gsw.SP_from_C(10 * c, t, p)
     SA = gsw.SA_from_SP(SP, p, lon, lat)
     return SA, SP
-
-
-def wsink(p, Ts, Fs):
-    """
-    Compute sinking velocity from pressure record.
-
-    Computes the sinking (or rising) velocity from the pressure signal p
-    by first differencing. The pressure signal is smoothed with a low-pass
-    filter for differentiation. If the input signal is shorter than the
-    smoothing time scale, w is taken as the slope of the linear regression of p.
-
-    Adapted from wsink.m - Fabian Wolk, Rockland Oceanographic Services Inc.
-
-    Parameters
-    ----------
-    p : array-like
-        Pressure [dbar]
-    Ts : float
-        Smoothing time scale [s]
-    Fs : float
-        Sampling frequency [Hz]
-
-    Returns
-    -------
-    w : array-like
-        Sinking velocity [dbar/s]
-    """
-    FORDER = 1
-    # low pass filter coefficients
-    [b, a] = signal.butter(FORDER, 1 / Ts * 2 / Fs)
-    N = p.size
-    if N <= Fs * Ts * FORDER:
-        pol = np.polyfit(np.array(range(N)), p, 1)
-        w = pol[0] * Fs * np.ones(N)
-    else:
-        # pad the pressure vector left and right
-        nPad = int(FORDER * Ts * Fs)
-        if nPad > N:
-            print(
-                "warning: length of pressure vector is smaller than padding length.\n",
-                "Filter transients may occur.",
-            )
-        p = helpers.pad_lr(p, nPad)
-        w = np.gradient(Fs * signal.filtfilt(b, a, p))
-        w = w[nPad:-nPad]
-
-    return w

{ctdproc-0.2.0 → ctdproc-0.3.0}/src/ctdproc/helpers.py

@@ -5,6 +5,17 @@ import numpy as np
 import pandas as pd
 from scipy.interpolate import interp1d
 
+__all__ = [
+    "findsegments",
+    "inearby",
+    "interpbadsegments",
+    "glitchcorrect",
+    "preen",
+    "unique_arrays",
+    "mtlb2datetime",
+    "datetime2mtlb",
+]
+
 
 def unique_arrays(*arrays):
     """
@@ -125,14 +136,29 @@ def interpbadsegments(x, ibad):
         if i1 < 0:
             # start_end_warning("start")
             pass
-        elif i3 > x.size:
+        elif i3 >= x.size:
             # start_end_warning("end")
             pass
+        elif np.isnan(x[i1]) or np.isnan(x[i3]):
+            # a NaN neighbor, such as a sample removed by despiking, would
+            # turn the whole segment into NaN; leave the segment as it is
+            pass
         else:
             y[i2] = interp1d(np.array([i1, i3]), x[[i1, i3]])(i2)
     return y
 
 
+def _greater(a, b):
+    """``a > b`` where ``a`` is finite, False elsewhere.
+
+    ``np.greater`` with ``where=`` and no ``out=`` leaves the masked entries
+    uninitialized, so a comparison against NaN came back True or False at
+    random and processing was not repeatable.
+    """
+    a = np.asarray(a)
+    return np.greater(a, b, out=np.zeros(a.shape, dtype=bool), where=np.isfinite(a))
+
+
 def glitchcorrect(x, diffx, prodx, ibefore=0, iafter=0):
     """
     Remove glitches/spikes in array.
@@ -174,18 +200,8 @@ def glitchcorrect(x, diffx, prodx, ibefore=0, iafter=0):
     dmul2 = -dx[0:-1] * dx[1:]
     dmul3 = -dx[0:-2] * dx[2:]
 
-    ii2 = np.squeeze(
-        np.argwhere(
-            np.greater(dmul2, prodx, where=np.isfinite(dmul2))
-            & np.greater(dmin2, diffx, where=np.isfinite(dmin2))
-        )
-    )
-    ii3 = np.squeeze(
-        np.argwhere(
-            np.greater(dmul3, prodx, where=np.isfinite(dmul3))
-            & np.greater(dmin3, diffx, where=np.isfinite(dmin3))
-        )
-    )
+    ii2 = np.squeeze(np.argwhere(_greater(dmul2, prodx) & _greater(dmin2, diffx)))
+    ii3 = np.squeeze(np.argwhere(_greater(dmul3, prodx) & _greater(dmin3, diffx)))
 
     ii2 = unique_arrays(ii2, ii2 + 1)
     ii3 = unique_arrays(ii3, ii3 + 1, ii3 + 2)
@@ -228,25 +244,6 @@ def preen(x, xmin, xmax):
     return xp
 
 
-def atanfit(x, f, Phi, W):
-    f = np.arctan(2 * np.pi * f * x[0]) + 2 * np.pi * f * x[1] + Phi
-    f = np.matmul(np.matmul(f.transpose(), W ** 4), f)
-    return f
-
-
-def pad_lr(p, nPad):
-    """Pad array left and right"""
-    p0 = p[0]
-    p = p - p0
-    p = p0 + np.insert(p, 0, -p[nPad - 1 :: -1])
-
-    p0 = p[-1]
-    p = p - p0
-    p = p0 + np.insert(p, -1, -p[: -nPad - 1 : -1])
-
-    return p
-
-
 def mtlb2datetime(matlab_datenum, strip_microseconds=False, strip_seconds=False):
     """
     Convert Matlab datenum format to python datetime.
@@ -309,6 +306,19 @@ def mtlb2datetime(matlab_datenum, strip_microseconds=False, strip_seconds=False)
 
 
 def datetime2mtlb(dt):
+    """
+    Convert a numpy datetime64 array to MATLAB datenum.
+
+    Parameters
+    ----------
+    dt : array-like of numpy.datetime64
+        Input timestamps.
+
+    Returns
+    -------
+    numpy.ndarray of float
+        MATLAB datenum values (days since the MATLAB epoch).
+    """
     pt = pd.to_datetime(dt)
     dt = pt.to_pydatetime()
     mdn = dt + datetime.timedelta(days=366)