ctdproc 0.1.3__tar.gz → 0.2.0__tar.gz

ctdproc-0.2.0/PKG-INFO

@@ -0,0 +1,76 @@
+Metadata-Version: 2.4
+Name: ctdproc
+Version: 0.2.0
+Summary: CTD data processing
+Author: Gunnar Voet
+Author-email: Gunnar Voet <gvoet@ucsd.edu>
+License-Expression: MIT
+License-File: LICENSE
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Science/Research
+Classifier: Topic :: Scientific/Engineering :: Physics
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Natural Language :: English
+Classifier: Programming Language :: Python :: 3
+Requires-Dist: gsw>=3.6.20
+Requires-Dist: matplotlib>=3.9.4
+Requires-Dist: munch>=4.0.0
+Requires-Dist: netcdf4>=1.7.2
+Requires-Dist: numpy>=2.0.2
+Requires-Dist: pandas>=2.3.3
+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
+Description-Content-Type: text/x-rst
+
+=======
+ctdproc
+=======
+
+
+.. image:: https://img.shields.io/pypi/v/ctdproc.svg
+        :target: https://pypi.python.org/pypi/ctdproc
+
+.. image:: https://readthedocs.org/projects/ctdproc/badge/?version=latest
+        :target: https://ctdproc.readthedocs.io/en/latest/?badge=latest
+        :alt: Documentation Status
+
+.. image:: https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json
+        :target: https://docs.astral.sh/ruff/
+        :alt: Ruff
+
+
+
+CTD data processing in python. 
+
+* Free software: MIT license
+* Documentation: https://ctdproc.readthedocs.io.
+
+
+Features
+--------
+
+* Convert CTD data collected with Seabird 9/11 systems in hex-format to human-readable formats and physical units.
+
+* Process CTD time series data into depth-binned profiles.
+
+
+Additional Information
+----------------------
+Information on the Seabird hex data format saved by SBE 11 Deck Units can be found in the `SBE manual <./misc/manual-11pV2_018.pdf>`_ on p. 65ff.
+
+
+Credits
+-------
+
+This package borrows heavily from a toolbox written in MATLAB® with contributions from Jennifer MacKinnon, Shaun Johnston, Daniel Rudnick, Robert Todd and others.
+
+
+Docs
+----
+`uv run make docs` will generate the docs. 

{ctdproc-0.1.3 → ctdproc-0.2.0}/README.rst

@@ -6,13 +6,14 @@ ctdproc
 .. image:: https://img.shields.io/pypi/v/ctdproc.svg
         :target: https://pypi.python.org/pypi/ctdproc
 
-.. image:: https://img.shields.io/travis/gunnarvoet/ctdproc.svg
-        :target: https://travis-ci.com/gunnarvoet/ctdproc
-
 .. image:: https://readthedocs.org/projects/ctdproc/badge/?version=latest
         :target: https://ctdproc.readthedocs.io/en/latest/?badge=latest
         :alt: Documentation Status
 
+.. image:: https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json
+        :target: https://docs.astral.sh/ruff/
+        :alt: Ruff
+
 
 
 CTD data processing in python. 
@@ -28,7 +29,18 @@ Features
 
 * Process CTD time series data into depth-binned profiles.
 
+
+Additional Information
+----------------------
+Information on the Seabird hex data format saved by SBE 11 Deck Units can be found in the `SBE manual <./misc/manual-11pV2_018.pdf>`_ on p. 65ff.
+
+
 Credits
 -------
 
-This package borrows heavily from a toolbox written in MATLAB® with contributions from Jennifer MacKinnon, Shaun Johnston, Daniel Rudnick, Robert Todd and others.
+This package borrows heavily from a toolbox written in MATLAB® with contributions from Jennifer MacKinnon, Shaun Johnston, Daniel Rudnick, Robert Todd and others.
+
+
+Docs
+----
+`uv run make docs` will generate the docs. 

ctdproc-0.2.0/pyproject.toml

@@ -0,0 +1,74 @@
+[project]
+name = "ctdproc"
+version = "0.2.0"
+description = "CTD data processing"
+readme = "README.rst"
+authors = [ { name = "Gunnar Voet", email = "gvoet@ucsd.edu" }, ]
+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.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",
+    "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", # Warn about undeclared markers
+    "--import-mode=importlib", # Recommended for modern projects
+]
+testpaths = [
+    "tests", # Directory where your tests are located
+]
+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/src/ctdproc/__init__.py

@@ -0,0 +1,6 @@
+import importlib.metadata
+from . import calcs, helpers, io, proc
+
+__all__ = ["io", "proc", "calcs", "helpers"]
+# version is defined in pyproject.toml
+__version__ = importlib.metadata.version("ctdproc")

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

@@ -1,9 +1,9 @@
 #!/usr/bin/env python
 # coding: utf-8
-import numpy as np
-import xarray as xr
 import gsw
+import numpy as np
 from scipy import signal
+
 from . import helpers
 
 
@@ -38,7 +38,7 @@ def swcalcs(data):
     """
     # Most derived variables are now calculated in proc.ctd_cleanup2()
     # Not sure why they are calculated two times in the Matlab package.
-    
+
     # data = calc_sal(data)
     # data = calc_temp(data)
     # data = calc_sigma(data)
@@ -55,12 +55,44 @@ def calc_sal(data):
     SA2, SP2 = calc_allsal(data.c2, data.t2, data.p, data.lon, data.lat)
 
     # Absolute salinity
-    data["SA1"] = (["time"], SA1, {"long_name": "absolute salinity", "units": "g/kg"})
-    data["SA2"] = (["time"], SA2, {"long_name": "absolute salinity", "units": "g/kg"})
+    data["SA1"] = (
+        ("time",),
+        SA1.data,
+        {
+            "long_name": "absolute salinity",
+            "units": "g kg-1",
+            "standard_name": "sea_water_absolute_salinity",
+        },
+    )
+    data["SA2"] = (
+        ("time",),
+        SA2.data,
+        {
+            "long_name": "absolute salinity",
+            "units": "g kg-1",
+            "standard_name": "sea_water_absolute_salinity",
+        },
+    )
 
     # Practical salinity
-    data["s1"] = (["time"], SP1, {"long_name": "practical salinity", "units": ""})
-    data["s2"] = (["time"], SP2, {"long_name": "practical salinity", "units": ""})
+    data["s1"] = (
+        ("time",),
+        SP1.data,
+        {
+            "long_name": "practical salinity",
+            "units": "",
+            "standard_name": "sea_water_practical_salinity",
+        },
+    )
+    data["s2"] = (
+        ("time",),
+        SP2.data,
+        {
+            "long_name": "practical salinity",
+            "units": "",
+            "standard_name": "sea_water_practical_salinity",
+        },
+    )
 
     return data
 
@@ -69,19 +101,32 @@ def calc_temp(data):
     # 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),
-            {"long_name": "conservative temperature", "units": "°C"},
+            ("time",),
+            gsw.CT_from_t(
+                data["s{:s}".format(si)], data["t{:s}".format(si)], data.p
+            ).data,
+            {
+                "long_name": "conservative temperature",
+                "units": "degree_C",
+                "standard_name": "sea_water_conservative_temperature",
+            },
         )
 
     # Potential temperature
     for si in ["1", "2"]:
         data["th{:s}".format(si)] = (
-            ["time"],
+            ("time",),
             gsw.pt_from_t(
-                data["SA{:s}".format(si)], data["t{:s}".format(si)], p=data.p, p_ref=0
-            ),
-            {"long_name": "potential temperature", "units": "°C"},
+                data["SA{:s}".format(si)],
+                data["t{:s}".format(si)],
+                p=data.p,
+                p_ref=0,
+            ).data,
+            {
+                "long_name": "potential temperature",
+                "units": "degree_C",
+                "standard_name": "sea_water_potential_temperature",
+            },
         )
 
     return data
@@ -91,9 +136,17 @@ def calc_sigma(data):
     # Potential density anomaly
     for si in ["1", "2"]:
         data["sg{:s}".format(si)] = (
-            ["time"],
-            gsw.sigma0(data["SA{:s}".format(si)], data["CT{:s}".format(si)],),
-            {"long_name": "potential density anomaly", "units": "kg/m$^3$"},
+            ("time",),
+            gsw.sigma0(
+                data["SA{:s}".format(si)],
+                data["CT{:s}".format(si)],
+            ).data,
+            {
+                "long_name": "potential density anomaly",
+                "units": "kg m-3",
+                "standard_name": "sea_water_sigma_theta",
+                "reference_pressure": "0 dbar",
+            },
         )
     return data
 
@@ -101,9 +154,14 @@ def calc_sigma(data):
 def calc_depth(data):
     # Depth
     data.coords["depth"] = (
-        ["time"],
-        -1 * gsw.z_from_p(data.p, data.lat),
-        {"long_name": "depth", "units": "m"},
+        ("time",),
+        -1 * gsw.z_from_p(data.p, data.lat).data,
+        {
+            "long_name": "depth",
+            "units": "m",
+            "standard_name": "depth",
+            "positive": "down",
+        },
     )
     return data
 
@@ -148,7 +206,7 @@ def wsink(p, Ts, Fs):
     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. 
+    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.
 

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

@@ -1,8 +1,10 @@
-import numpy as np
 import datetime
-from scipy.interpolate import interp1d
 import warnings
 
+import numpy as np
+import pandas as pd
+from scipy.interpolate import interp1d
+
 
 def unique_arrays(*arrays):
     """
@@ -10,21 +12,19 @@ def unique_arrays(*arrays):
 
     Parameters
     ----------
-    arrays : np.array or list
-        Numpy arrays either in a list or separated by commas.
+    arrays : A tuple of np.array.ndarray
 
     Returns
     -------
     unique : np.array
-        Numpy array with unique elements from the input arrays.
+        numpy array with unique elements from the input arrays
     """
-    h = np.hstack(np.squeeze(arrays))
-    return np.unique(h)
+    return np.unique(np.hstack(arrays))
 
 
 def findsegments(ibad):
     """
-    Find contiguous segments in an array of indices. 
+    Find contiguous segments in an array of indices.
 
     Parameters
     ----------
@@ -42,7 +42,6 @@ def findsegments(ibad):
     """
     dibad = np.diff(ibad)
     jj = np.argwhere(dibad > 1)
-    nseg = jj.size + 1
 
     istart = jj + 1
     istart = np.insert(istart, 0, 0)
@@ -86,10 +85,10 @@ def inearby(ibad, inearm, inearp, n):
         k = np.array([]).astype("int64")
     else:
         istart, istop, seglength = findsegments(ibad)
-        new_ind = []
+        new_ind = np.array([]).astype("int64")
         for ia, ib in zip(istart, istop):
-            new_ind.append(list(range(ia - inearm, ib + inearp + 1)))
-        k = unique_arrays(new_ind)
+            new_ind = np.append(new_ind, np.arange(ia - inearm, ib + inearp + 1))
+        k = np.unique(new_ind)
         k = k[((k >= 0) & (k < n))]
     return k
 
@@ -110,17 +109,25 @@ def interpbadsegments(x, ibad):
     y : np.array
         Interpolated array
     """
+
+    def start_end_warning(loc):
+        warnings.warn(
+            message=f"no interpolation at {loc}",
+            category=RuntimeWarning,
+        )
+
     istart, istop, seglen = findsegments(ibad)
-    nsegs = istart.size
     y = x.copy()
     for iia, iis, iilen in zip(istart, istop, seglen):
         i1 = iia - 1
         i2 = range(iia, iis + 1)
         i3 = iis + 1
         if i1 < 0:
-            print("interpbadsegments: bad at istart - no interpolation at start")
+            # start_end_warning("start")
+            pass
         elif i3 > x.size:
-            print("interpbadsegments: bad at istop - no interpolation at stop")
+            # start_end_warning("end")
+            pass
         else:
             y[i2] = interp1d(np.array([i1, i3]), x[[i1, i3]])(i2)
     return y
@@ -129,7 +136,7 @@ def interpbadsegments(x, ibad):
 def glitchcorrect(x, diffx, prodx, ibefore=0, iafter=0):
     """
     Remove glitches/spikes in array.
-    
+
     Adapted from tms_tc_glitchcorrect.m
 
     Parameters
@@ -157,27 +164,35 @@ def glitchcorrect(x, diffx, prodx, ibefore=0, iafter=0):
     with warnings.catch_warnings():
         # Prevent warning due to nans present in nanmin being printed
         warnings.simplefilter("ignore")
-        dmin2 = np.nanmin(np.vstack([np.absolute(dx[0:-1]), np.absolute(dx[1:])]), axis=0)
-        dmin3 = np.nanmin(np.vstack([np.absolute(dx[0:-2]), np.absolute(dx[2:])]), axis=0)
+        dmin2 = np.nanmin(
+            np.vstack([np.absolute(dx[0:-1]), np.absolute(dx[1:])]), axis=0
+        )
+        dmin3 = np.nanmin(
+            np.vstack([np.absolute(dx[0:-2]), np.absolute(dx[2:])]), axis=0
+        )
 
     dmul2 = -dx[0:-1] * dx[1:]
     dmul3 = -dx[0:-2] * dx[2:]
 
-    ii2 = np.argwhere(
-        np.greater(dmul2, prodx, where=np.isfinite(dmul2)) &
-        np.greater(dmin2, diffx, where=np.isfinite(dmin2))
+    ii2 = np.squeeze(
+        np.argwhere(
+            np.greater(dmul2, prodx, where=np.isfinite(dmul2))
+            & np.greater(dmin2, diffx, where=np.isfinite(dmin2))
         )
-    ii3 = np.argwhere(
-        np.greater(dmul3, prodx, where=np.isfinite(dmul3)) &
-        np.greater(dmin3, diffx, where=np.isfinite(dmin3))
+    )
+    ii3 = np.squeeze(
+        np.argwhere(
+            np.greater(dmul3, prodx, where=np.isfinite(dmul3))
+            & np.greater(dmin3, diffx, where=np.isfinite(dmin3))
         )
+    )
 
     ii2 = unique_arrays(ii2, ii2 + 1)
     ii3 = unique_arrays(ii3, ii3 + 1, ii3 + 2)
-    ii = unique_arrays(ii2, ii3)
 
     jj2 = inearby(ii2, ibefore, iafter, nx)
     jj3 = inearby(ii3, ibefore, iafter, nx)
+
     jj = unique_arrays(jj2, jj3)
 
     if jj.size > 0:
@@ -205,29 +220,30 @@ def preen(x, xmin, xmax):
         Cleaned array
     """
     indexall = np.array(range(0, x.size))
-    ii = np.squeeze(np.where(((x<xmin) | (x>xmax) | (np.imag(x)!=0))))
+    ii = np.squeeze(np.where(((x < xmin) | (x > xmax) | (np.imag(x) != 0))))
     indexclean = np.delete(indexall, ii)
     x = np.delete(x, ii)
-    xp = interp1d(indexclean, x)(indexall)
+    fint = interp1d(indexclean, x, bounds_error=False, fill_value=np.nan)
+    xp = fint(indexall)
     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)
+    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])
-    
+    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])
-    
+    p = p - p0
+    p = p0 + np.insert(p, -1, -p[: -nPad - 1 : -1])
+
     return p
 
 
@@ -280,7 +296,7 @@ def mtlb2datetime(matlab_datenum, strip_microseconds=False, strip_seconds=False)
             ]
         elif strip_microseconds:
             tt = [datetime.datetime.replace(tval, microsecond=0) for tval in tt]
-        tt = [np.datetime64(ti) for ti in tt]
+        tt = [np.datetime64(ti, "ns") for ti in tt]
         xi = np.where(nonan)[0]
         for i, ii in enumerate(xi):
             t1[ii] = tt[i]
@@ -290,3 +306,20 @@ def mtlb2datetime(matlab_datenum, strip_microseconds=False, strip_seconds=False)
         t1 = np.array(t1)
 
     return t1
+
+
+def datetime2mtlb(dt):
+    pt = pd.to_datetime(dt)
+    dt = pt.to_pydatetime()
+    mdn = dt + datetime.timedelta(days=366)
+    frac_seconds = [
+        (dti - datetime.datetime(dti.year, dti.month, dti.day, 0, 0, 0)).seconds
+        / (24.0 * 60.0 * 60.0)
+        for dti in dt
+    ]
+    frac_microseconds = [
+        dti.microsecond / (24.0 * 60.0 * 60.0 * 1000000.0) for dti in dt
+    ]
+    out = np.array([mdni.toordinal() for mdni in mdn])
+    out = out.astype(float) + frac_seconds + frac_microseconds
+    return out