pyTMD 2.2.5__tar.gz → 2.2.7__tar.gz

{pytmd-2.2.5 → pytmd-2.2.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyTMD
-Version: 2.2.5
+Version: 2.2.7
 Summary: Python-based tidal prediction software for estimating ocean, load, solid Earth and pole tides
 Author: Tyler Sutterley
 Author-email: tsutterl@uw.edu
@@ -55,12 +55,9 @@ Requires-Dist: numpy
 Requires-Dist: pyproj
 Requires-Dist: python-dateutil
 Requires-Dist: scipy>=1.10.1
-Requires-Dist: setuptools_scm
 Requires-Dist: timescale>=0.0.8
 Provides-Extra: doc
 Requires-Dist: docutils; extra == "doc"
-Requires-Dist: fontconfig; extra == "doc"
-Requires-Dist: freetype; extra == "doc"
 Requires-Dist: graphviz; extra == "doc"
 Requires-Dist: myst-nb; extra == "doc"
 Requires-Dist: numpydoc; extra == "doc"
@@ -133,7 +130,7 @@ To include all optional dependencies:
 
    python3 -m pip install pyTMD[all]
 
-Using `conda` or `mamba` from conda-forge:
+Using ``conda`` or ``mamba`` from conda-forge:
 
 .. code-block:: bash
 
@@ -149,6 +146,33 @@ Development version from GitHub:
 
    python3 -m pip install git+https://github.com/pyTMD/pyTMD.git
 
+Running with Pixi
+-----------------
+
+Alternatively, you can use `Pixi <https://pixi.sh/>`_ for a streamlined workspace environment:
+
+1. Install Pixi following the `installation instructions <https://pixi.sh/latest/#installation>`_
+
+2. Clone the project repository:
+
+.. code-block:: bash
+
+   git clone https://github.com/pyTMD/pyTMD.git
+
+3. Move into the ``pyTMD`` directory
+
+.. code-block:: bash
+
+   cd pyTMD
+
+4. Install dependencies and start JupyterLab:
+
+.. code-block:: bash
+
+   pixi run start
+
+This will automatically create the environment, install all dependencies, and launch JupyterLab in the `notebooks <./doc/source/notebooks/>`_ directory.
+
 Dependencies
 ############
 
@@ -158,7 +182,6 @@ Dependencies
 - `numpy: Scientific Computing Tools For Python <https://www.numpy.org>`_
 - `pyproj: Python interface to PROJ library <https://pypi.org/project/pyproj/>`_
 - `scipy: Scientific Tools for Python <https://www.scipy.org/>`_
-- `setuptools_scm: manager for python package versions using scm metadata <https://pypi.org/project/setuptools-scm>`_
 - `timescale: Python tools for time and astronomical calculations <https://pypi.org/project/timescale/>`_
 
 References
@@ -202,7 +225,7 @@ Contributing
 ############
 
 This project contains work and contributions from the `scientific community <./CONTRIBUTORS.rst>`_.
-If you would like to contribute to the project, please have a look at the `open issues <https://github.com/pyTMD/pyTMD/issues>`_ and `discussions board <https://github.com/pyTMD/pyTMD/discussions>`_.
+If you would like to contribute to the project, please have a look at the `contribution guidelines <./doc/source/getting_started/Contributing.rst>`_, `open issues <https://github.com/pyTMD/pyTMD/issues>`_ and `discussions board <https://github.com/pyTMD/pyTMD/discussions>`_.
 
 Credits
 #######

{pytmd-2.2.5 → pytmd-2.2.7}/README.rst

@@ -46,7 +46,7 @@ To include all optional dependencies:
 
    python3 -m pip install pyTMD[all]
 
-Using `conda` or `mamba` from conda-forge:
+Using ``conda`` or ``mamba`` from conda-forge:
 
 .. code-block:: bash
 
@@ -62,6 +62,33 @@ Development version from GitHub:
 
    python3 -m pip install git+https://github.com/pyTMD/pyTMD.git
 
+Running with Pixi
+-----------------
+
+Alternatively, you can use `Pixi <https://pixi.sh/>`_ for a streamlined workspace environment:
+
+1. Install Pixi following the `installation instructions <https://pixi.sh/latest/#installation>`_
+
+2. Clone the project repository:
+
+.. code-block:: bash
+
+   git clone https://github.com/pyTMD/pyTMD.git
+
+3. Move into the ``pyTMD`` directory
+
+.. code-block:: bash
+
+   cd pyTMD
+
+4. Install dependencies and start JupyterLab:
+
+.. code-block:: bash
+
+   pixi run start
+
+This will automatically create the environment, install all dependencies, and launch JupyterLab in the `notebooks <./doc/source/notebooks/>`_ directory.
+
 Dependencies
 ############
 
@@ -71,7 +98,6 @@ Dependencies
 - `numpy: Scientific Computing Tools For Python <https://www.numpy.org>`_
 - `pyproj: Python interface to PROJ library <https://pypi.org/project/pyproj/>`_
 - `scipy: Scientific Tools for Python <https://www.scipy.org/>`_
-- `setuptools_scm: manager for python package versions using scm metadata <https://pypi.org/project/setuptools-scm>`_
 - `timescale: Python tools for time and astronomical calculations <https://pypi.org/project/timescale/>`_
 
 References
@@ -115,7 +141,7 @@ Contributing
 ############
 
 This project contains work and contributions from the `scientific community <./CONTRIBUTORS.rst>`_.
-If you would like to contribute to the project, please have a look at the `open issues <https://github.com/pyTMD/pyTMD/issues>`_ and `discussions board <https://github.com/pyTMD/pyTMD/discussions>`_.
+If you would like to contribute to the project, please have a look at the `contribution guidelines <./doc/source/getting_started/Contributing.rst>`_, `open issues <https://github.com/pyTMD/pyTMD/issues>`_ and `discussions board <https://github.com/pyTMD/pyTMD/discussions>`_.
 
 Credits
 #######

{pytmd-2.2.5 → pytmd-2.2.7}/pyTMD/__init__.py

@@ -36,7 +36,7 @@ from pyTMD.compute_tide_corrections import (
     compute_SET_corrections,
 )
 
-# get semantic version from setuptools-scm
+# get version information
 __version__ = pyTMD.version.version
 # read model database
 models = io.load_database()

{pytmd-2.2.5 → pytmd-2.2.7}/pyTMD/arguments.py

@@ -1,7 +1,7 @@
 #!/usr/bin/env python
 u"""
 arguments.py
-Written by Tyler Sutterley (04/2025)
+Written by Tyler Sutterley (08/2025)
 Calculates the nodal corrections for tidal constituents
 Modification of ARGUMENTS fortran subroutine by Richard Ray 03/1999
 
@@ -39,6 +39,13 @@ REFERENCES:
         Ocean Tides", Journal of Atmospheric and Oceanic Technology, (2002).
 
 UPDATE HISTORY:
+    Updated 08/2025: add Cartwright and Tayler table with radiational tides
+        make frequency function a wrapper around one that calculates using
+            Doodson coefficients (Cartwright numbers)
+        add complex love numbers function for correcting out-of-phase effects
+        use Mathews et al. (2002) functions for diurnal complex love numbers
+        take the absolute value of the constituent angular frequencies
+        convert angles with numpy radians and degrees functions
     Updated 04/2025: convert longitudes p and n to radians within nodal function
         use schureman_arguments function to get nodal variables for FES models
         added Schureman to list of M1 options in nodal arguments
@@ -113,7 +120,9 @@ __all__ = [
     "_arguments_table",
     "_minor_table",
     "_constituent_parameters",
+    "_frequency",
     "_love_numbers",
+    "_complex_love_numbers",
     "_parse_tide_potential_table",
     "_to_constituent_id",
     "_to_doodson_number",
@@ -233,8 +242,6 @@ def minor_arguments(
     kwargs.setdefault('deltat', 0.0)
     kwargs.setdefault('corrections', 'OTIS')
 
-    # degrees to radians
-    dtr = np.pi/180.0
     # set function for astronomical longitudes
     # use ASTRO5 routines if not using an OTIS type model
     if kwargs['corrections'] in ('OTIS','ATLAS','TMD3','netcdf'):
@@ -259,8 +266,8 @@ def minor_arguments(
     arg = np.dot(fargs, _minor_table())
 
     # convert mean longitudes to radians
-    P = p*dtr
-    N = n*dtr
+    P = np.radians(p)
+    N = np.radians(n)
     # determine nodal corrections f and u
     sinn = np.sin(N)
     cosn = np.cos(N)
@@ -554,11 +561,9 @@ def nodal_modulation(
     FES_TYPE = kwargs['corrections'] in ('FES',)
     PERTH3_TYPE = kwargs['corrections'] in ('perth3',)
 
-    # degrees to radians
-    dtr = np.pi/180.0
     # convert longitudes to radians
-    N = dtr*n
-    P = dtr*p
+    N = np.radians(n)
+    P = np.radians(p)
     # trigonometric factors for nodal corrections
     sinn = np.sin(N)
     cosn = np.cos(N)
@@ -615,7 +620,7 @@ def nodal_modulation(
             term2 = 1.0 - 0.1308*cosn - 0.0534*cos2p - 0.0219*np.cos(2.0*P - N)
         elif c in ('mf','msqm','msp','mq','mtm') and OTIS_TYPE:
             f[:,i] = 1.043 + 0.414*cosn
-            u[:,i] = dtr*(-23.7*sinn + 2.7*sin2n - 0.4*sin3n)
+            u[:,i] = np.radians(-23.7*sinn + 2.7*sin2n - 0.4*sin3n)
             continue
         elif c in ('mf','msqm','msp','mq','mt','mtm') and FES_TYPE:
             # Schureman: Table 2, Page 164
@@ -651,7 +656,7 @@ def nodal_modulation(
             term1 = 0.189*sinn - 0.0058*sin2n
             term2 = 1.0 + 0.189*cosn - 0.0058*cos2n
             f[:,i] = np.sqrt(term1**2 + term2**2) # O1
-            u[:,i] = dtr*(10.8*sinn - 1.3*sin2n + 0.2*sin3n)
+            u[:,i] = np.radians(10.8*sinn - 1.3*sin2n + 0.2*sin3n)
             continue
         elif c in ('o1','so3','op2','2q1','q1','rho1','sigma1') and FES_TYPE:
             # Schureman: Table 2, Page 164
@@ -661,7 +666,7 @@ def nodal_modulation(
             continue
         elif c in ('q1','o1') and PERTH3_TYPE:
             f[:,i] = 1.009 + 0.187*cosn - 0.015*cos2n
-            u[:,i] = dtr*(10.8*sinn - 1.3*sin2n)
+            u[:,i] = np.radians(10.8*sinn - 1.3*sin2n)
             continue
         elif c in ('o1','so3','op2'):
             term1 = 0.1886*sinn - 0.0058*sin2n - 0.0065*sin2p
@@ -725,7 +730,7 @@ def nodal_modulation(
             continue
         elif c in ('k1',) and PERTH3_TYPE:
             f[:,i] = 1.006 + 0.115*cosn - 0.009*cos2n
-            u[:,i] = dtr*(-8.9*sinn + 0.7*sin2n)
+            u[:,i] = np.radians(-8.9*sinn + 0.7*sin2n)
             continue
         elif c in ('k1','sk3','2sk5'):
             term1 = -0.1554*sinn + 0.0031*sin2n
@@ -754,7 +759,7 @@ def nodal_modulation(
             continue
         elif c in ('m2','n2') and PERTH3_TYPE:
             f[:,i] = 1.000 - 0.037*cosn
-            u[:,i] = dtr*(-2.1*sinn)
+            u[:,i] = np.radians(-2.1*sinn)
             continue
         elif c in ('m2','2n2','mu2','n2','nu2','lambda2','ms4','eps2','2sm6',
                 '2sn6','mp1','mp3','sn4'):
@@ -789,7 +794,7 @@ def nodal_modulation(
             continue
         elif c in ('k2',) and PERTH3_TYPE:
             f[:,i] = 1.024 + 0.286*cosn + 0.008*cos2n
-            u[:,i] = dtr*(-17.7*sinn + 0.7*sin2n)
+            u[:,i] = np.radians(-17.7*sinn + 0.7*sin2n)
             continue
         elif c in ('k2','sk4','2sk6','kp1'):
             term1 = -0.3108*sinn - 0.0324*sin2n
@@ -855,7 +860,7 @@ def nodal_modulation(
         elif c in ('mfdw',):
             # special test of Doodson-Warburg formula
             f[:,i] = 1.043 + 0.414*cosn
-            u[:,i] = dtr*(-23.7*sinn + 2.7*sin2n - 0.4*sin3n)
+            u[:,i] = np.radians(-23.7*sinn + 2.7*sin2n - 0.4*sin3n)
             continue
         elif c in ('so1','2so3','2po1'):
             # compound tides calculated using recursion
@@ -1267,13 +1272,11 @@ def group_modulation(
         angle correction (radians)
     """
 
-    # degrees to radians
-    dtr = np.pi/180.0
     # convert longitudes to radians
-    H = dtr*h
-    Np = -dtr*n
-    P = dtr*p
-    Ps = dtr*ps
+    H = np.radians(h)
+    Np = -np.radians(n)
+    P = np.radians(p)
+    Ps = np.radians(ps)
     # mean anomaly of the sun
     lp = H - Ps
 
@@ -1521,8 +1524,8 @@ def frequency(
         **kwargs
     ):
     """
-    Calculates the angular frequency for tidal constituents
-    :cite:p:`Ray:1999vm`
+    Wrapper function for calculating the angular frequency
+    for tidal constituents :cite:p:`Ray:1999vm`
 
     Parameters
     ----------
@@ -1549,31 +1552,13 @@ def frequency(
     # set function for astronomical longitudes
     # use ASTRO5 routines if not using an OTIS type model
     if kwargs['corrections'] in ('OTIS','ATLAS','TMD3','netcdf'):
-        method = 'Cartwright'
+        kwargs.setdefault('method', 'Cartwright')
     else:
-        method = 'ASTRO5'
-    # Modified Julian Dates at J2000
-    MJD = np.array([51544.5, 51544.55])
-    # time interval in seconds
-    deltat = 86400.0*(MJD[1] - MJD[0])
-    # calculate the mean longitudes of the sun and moon
-    s, h, p, n, pp = pyTMD.astro.mean_longitudes(MJD, method=method)
-
-    # number of temporal values
-    nt = len(np.atleast_1d(MJD))
-    # initial time conversions
-    hour = 24.0*np.mod(MJD, 1)
-    # convert from hours solar time into mean lunar time in degrees
-    tau = 15.0*hour - s + h
-    # variable for multiples of 90 degrees (Ray technical note 2017)
-    k = 90.0 + np.zeros((nt))
-
-    # determine equilibrium arguments
-    fargs = np.c_[tau, s, h, p, n, pp, k]
-    rates = (fargs[1,:] - fargs[0,:])/deltat
-    fd = np.dot(rates, coefficients_table(constituents, **kwargs))
-    # convert to radians per second
-    omega = 2.0*np.pi*fd/360.0
+        kwargs.setdefault('method', 'ASTRO5')
+    # get Doodson coefficients
+    coef = coefficients_table(constituents, **kwargs)
+    # calculate the angular frequency
+    omega = _frequency(coef, **kwargs)
     return omega
 
 def aliasing_period(
@@ -1769,9 +1754,62 @@ def _constituent_parameters(c: str, **kwargs):
     # return the values for the constituent
     return (amplitude, phase, omega, alpha, species)
 
+def _frequency(
+        coef: np.ndarray,
+        **kwargs
+    ):
+    """
+    Calculates the angular frequency for Doodson coefficients
+    (Cartwright numbers) :cite:p:`Ray:1999vm`
+
+    Parameters
+    ----------
+    coef: list or np.ndarray
+        Doodson coefficients (Cartwright numbers) for constituents
+    method: str, default 'Cartwright'
+        Method for computing the mean longitudes
+
+            - ``'Cartwright'``
+            - ``'Meeus'``
+            - ``'ASTRO5'`` 
+            - ``'IERS'``
+
+    Returns
+    -------
+    omega: np.ndarray
+        angular frequency in radians per second
+    """
+    # set default keyword arguments
+    kwargs.setdefault('method', 'Cartwright')
+    # Modified Julian Dates at J2000
+    MJD = np.array([51544.5, 51544.55])
+    # time interval in seconds
+    deltat = 86400.0*(MJD[1] - MJD[0])
+    # calculate the mean longitudes of the sun and moon
+    s, h, p, n, pp = pyTMD.astro.mean_longitudes(MJD,
+        method=kwargs['method'])
+
+    # number of temporal values
+    nt = len(np.atleast_1d(MJD))
+    # initial time conversions
+    hour = 24.0*np.mod(MJD, 1)
+    # convert from hours solar time into mean lunar time in degrees
+    tau = 15.0*hour - s + h
+    # variable for multiples of 90 degrees (Ray technical note 2017)
+    k = 90.0 + np.zeros((nt))
+
+    # determine equilibrium arguments
+    fargs = np.c_[tau, s, h, p, n, pp, k]
+    rates = (fargs[1,:] - fargs[0,:])/deltat
+    fd = np.dot(rates, coef)
+    # convert to radians per second
+    omega = 2.0*np.pi*fd/360.0
+    return np.abs(omega)
+
 def _love_numbers(
         omega: np.ndarray,
-        model: str = 'PREM'
+        model: str = 'PREM',
+        **kwargs
     ):
     """
     Compute the body tide Love/Shida numbers for a given frequency
@@ -1790,6 +1828,8 @@ def _love_numbers(
             - 'PEM-C'
             - 'C2'
             - 'PREM'
+    astype: np.dtype, default np.float64
+        data type for the output Love numbers
 
     Returns
     -------
@@ -1800,6 +1840,8 @@ def _love_numbers(
     l2: float
         Degree-2 Love (Shida) number of horizontal displacement
     """
+    # set default keyword arguments
+    kwargs.setdefault('astype', np.float64)
     # free core nutation frequencies (cycles per sidereal day) and
     # Love number parameters from Wahr (1981) table 6
     # and Mathews et al. (1995) table 3
@@ -1850,7 +1892,7 @@ def _love_numbers(
         # calculate love numbers following J. Wahr (1979)
         # use resonance formula for tides in the diurnal band
         # frequency of the o1 tides (radians/second)
-        omega_o1, = frequency('o1')
+        omega_o1, = frequency('o1', **kwargs)
         # convert frequency from cycles per sidereal day
         # frequency of free core nutation (radians/second)
         omega_fcn = lambda_fcn*7292115e-11
@@ -1861,22 +1903,127 @@ def _love_numbers(
         k2 = k0 + k1*ratio
         l2 = l0 + l1*ratio
     # return the Love numbers for frequency
-    return (h2, k2, l2)
+    return np.array([h2, k2, l2], dtype=kwargs['astype'])
+
+def _complex_love_numbers(
+        omega: np.ndarray,
+        **kwargs
+    ):
+    """
+    Compute the complex body tide Love/Shida numbers with in-phase
+    and out-of-phase components for a given frequency
+    :cite:p:`Mathews:1997js,Mathews:2002cr,Petit:2010tp`
+
+    Parameters
+    ----------
+    omega: np.ndarray
+        angular frequency (radians per second)
+    kwargs: dict
+        additional keyword arguments for love number calculation
+
+    Returns
+    -------
+    h2: complex
+        Degree-2 Love number of vertical displacement
+    k2: complex
+        Degree-2 Love number of gravitational potential
+    l2: complex
+        Degree-2 Love (Shida) number of horizontal displacement
+    """
+    # (number of sidereal days per solar day)
+    sidereal_ratio = 1.002737909
+    # number of seconds in a sidereal day (approx 86164.1)
+    sidereal_day = 86400.0/sidereal_ratio
+    # frequency in cycles per sidereal day
+    f = omega*sidereal_day/(2.0*np.pi)
+    # Love numbers for different frequency bands
+    if (omega == 0.0):
+        # use real-valued body tide love numbers for permanent tide
+        h2, k2, l2 = _love_numbers(omega, **kwargs)
+    elif (omega > 1e-4):
+        # in-phase and out-of-phase components for the semi-diurnal band
+        h2 = 0.6078 - 0.0022j
+        k2 = 0.30102 - 0.0013j
+        l2 = 0.0847 - 0.0007j
+    elif (omega < 2e-5):
+        # compute in-phase and out-of-phase components for the long period band
+        # variation largely due to mantle anelasticity
+        alpha = 0.15
+        # frequency equivalent to 200s
+        fm = sidereal_day/200.0
+        factor = np.tan(alpha*np.pi/2.0)**(-1)
+        anelasticity_model = factor*(1.0 - (fm/f)**alpha) + 1j*(fm/f)**alpha
+        # model for the variation of love numbers across the zonal tide band
+        h2 = 0.5998 - 9.96e-4*anelasticity_model
+        k2 = 0.29525 - 5.796e-4*anelasticity_model
+        l2 = 0.0831 - 3.01e-4*anelasticity_model
+    else:
+        # in-phase and out-of-phase components for the diurnal band
+        # following IERS conventions and Mathews et al. (2002)
+        # values from equation 6.10 of IERS conventions 2010
+        # and from Mathews et al. (2002)
+        sigma = np.zeros((4), dtype=np.complex128)
+        # factor for calculating L0
+        sigma[0] = f - 1.0
+        # Chandler wobble
+        sigma[1] = -0.0026010 - 0.0001361j
+        # retrograde free core nutation
+        sigma[2] = 1.0023181 + 0.000025j
+        # prograde free core nutation
+        sigma[3] = 0.999026 + 0.000780j
+        # frequency dependence of Love number h2
+        H2 = np.zeros((4), dtype=np.complex128)
+        H2[0] = 0.60671 - 0.242e-2j
+        H2[1] = -0.15777e-2 - 0.7630e-4j
+        H2[2] = 0.18053e-3 - 0.6292e-5j
+        H2[3] = -0.18616e-5 + 0.1379e-6j
+        # frequency dependence of Love number k2
+        K2 = np.zeros((4), dtype=np.complex128)
+        K2[0] = 0.29954 - 0.1412e-2j
+        K2[1] = -0.77896e-3 - 0.3711e-4j
+        K2[2] = 0.90963e-4 - 0.2963e-5j
+        K2[3] = -0.11416e-5 + 0.5325e-7j
+        # frequency dependence of Love number l2
+        L2 = np.zeros((4), dtype=np.complex128)
+        L2[0] = 0.84963e-1 - 0.7395e-3j
+        L2[1] = -0.22107e-3 - 0.9446e-5j
+        L2[2] = 0.54710e-5 - 0.2990e-6j
+        L2[3] = -0.29904e-7 - 0.7717e-8j
+        # estimate the complex Love number fors diurnal tides
+        # equation 6.9 of IERS conventions 2010
+        h2 = np.sum(H2/(f - sigma))
+        k2 = np.sum(K2/(f - sigma))
+        l2 = np.sum(L2/(f - sigma))
+
+    # return the Love numbers as a complex number
+    return np.array([h2, k2, l2], dtype=np.complex128)
 
 # Doodson (1921) table with values missing from Cartwright tables
+# Hs1: amplitude for epoch span 1 (1900 epoch)
 _d1921_table = get_data_path(['data','d1921_tab.txt'])
 # Cartwright and Tayler (1971) table with 3rd-degree values
+# Hs1: amplitude for epoch span 1 (1861-09-21 to 1879-09-22)
+# Hs2: amplitude for epoch span 2 (1915-05-16 to 1933-05-22)
+# Hs3: amplitude for epoch span 2 (1951-05-23 to 1969-05-22)
 _ct1971_table_5 = get_data_path(['data','ct1971_tab5.txt'])
 # Cartwright and Edden (1973) table with updated values
 _ce1973_table_1 = get_data_path(['data','ce1973_tab1.txt'])
+# Cartwright and Tayler (1971) table with radiational tides
+# Hs1: amplitude for epoch span 1 (1900 epoch)
+_ct1971_table_6 = get_data_path(['data','ct1971_tab6.txt'])
 
-def _parse_tide_potential_table(table: str | pathlib.Path):
+def _parse_tide_potential_table(
+        table: str | pathlib.Path,
+        columns: int = 3,
+    ):
     """Parse tables of tide-generating potential
 
     Parameters
     ----------
     table: str or pathlib.Path
         table of tide-generating potentials
+    columns: int, default 3
+        number of amplitude columns in the table
 
     Returns
     -------
@@ -1895,18 +2042,26 @@ def _parse_tide_potential_table(table: str | pathlib.Path):
     # p: coefficient for mean longitude of lunar perigee
     # n: coefficient for mean longitude of ascending lunar node
     # pp: coefficient for mean longitude of solar perigee
-    # Hs1: amplitude for epoch span 1 (1861-09-21 to 1879-09-22)
-    # Hs2: amplitude for epoch span 2 (1915-05-16 to 1933-05-22)
-    # Hs3: amplitude for epoch span 2 (1951-05-23 to 1969-05-22)
-    # DO: Doodson number for coefficient
-    # Hs0: Doodson scaled amplitude for 1900
-    names = ('tau','s','h','p','n','pp','Hs1','Hs2','Hs3','DO','Hs0')
-    formats = ('i','i','i','i','i','i','f','f','f','U7','f')
+    names = ['tau','s','h','p','n','pp']
+    formats = ['i','i','i','i','i','i']
+    for c in range(columns):
+        # add amplitude columns to names and formats
+        names.append(f'Hs{c+1}')
+        formats.append('f8')
+    # add Doodson number
+    names.append('DO')
+    formats.append('U7')
+    # create a structured numpy dtype for the table
+    # names: names of the columns in the table
+    # formats: data types for each column in the table
     dtype = np.dtype({'names':names, 'formats':formats})
     CTE = np.zeros((file_lines), dtype=dtype)
+    # number of output columns
+    columns = len(names)
+    # iterate over each line in the file
     for i,line in enumerate(file_contents):
         # drop last column with values from Doodson (1921)
-        CTE[i] = np.array(tuple(line.split()[:11]), dtype=dtype)
+        CTE[i] = np.array(tuple(line.split()[:columns]), dtype=dtype)
     # return the table values
     return CTE