cht-tide 0.0.1__tar.gz

cht_tide-0.0.1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) Deltares
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

cht_tide-0.0.1/PKG-INFO

@@ -0,0 +1,15 @@
+Metadata-Version: 2.1
+Name: cht_tide
+Version: 0.0.1
+Summary: Combining of tidal components to time series
+Author-email: Maarten van Ormondt <maarten.vanormondt@deltares.nl>, Julian Hofer <Julian.Hofer@deltares.nl>, Sarwan Peiter <Sarwan.Peiter@deltares.nl>
+License: MIT
+Project-URL: Source, https://github.com/Deltares/cht_tide
+Classifier: Intended Audience :: Science/Research
+Classifier: Topic :: Scientific/Engineering :: Hydrology
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Provides-Extra: tests
+License-File: LICENSE
+
+# Coastal Hazards Toolkit -Tides

cht_tide-0.0.1/README.md

@@ -0,0 +1 @@
+# Coastal Hazards Toolkit -Tides

cht_tide-0.0.1/cht_tide/__init__.py

@@ -0,0 +1,7 @@
+# -*- coding: utf-8 -*-
+"""
+Created on Sun Apr 25 10:58:08 2021
+
+@author: ormondt
+"""
+__version__ = "0.0.1"

cht_tide-0.0.1/cht_tide/astro.py

@@ -0,0 +1,241 @@
+#   Copyright notice
+#   --------------------------------------------------------------------
+#   Copyright (C) 2020 Deltares
+#       Freek Scheel
+#
+#       freek.scheel@deltares.nl
+#
+#       P.O. Box 177
+#       2600 MH Delft
+#       The Netherlands
+#
+#   This library is free software: you can redistribute it and/or modify
+#   it under the terms of the GNU Lesser General Public License as published by
+#   the Free Software Foundation, either version 3 of the License, or
+#   (at your option) any later version.
+#
+#   This library is distributed in the hope that it will be useful,
+#   but WITHOUT ANY WARRANTY; without even the implied warranty of
+#   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#   GNU General Public License for more details.
+#
+#   You should have received a copy of the GNU General Public License
+#   along with this library.  If not, see <http://www.gnu.org/licenses/>.
+#   --------------------------------------------------------------------
+from collections import namedtuple
+
+import numpy as np
+
+d2r, r2d = np.pi / 180.0, 180.0 / np.pi
+
+# Most of this is based around Meeus's Astronomical Algorithms, since it
+# presents reasonably good approximations of all the quantities we require in a
+# clear fashion.  Reluctant to go all out and use VSOP87 unless it can be shown
+# to make a significant difference to the resulting accuracy of harmonic
+# analysis.
+
+
+# Convert a sexagesimal angle into decimal degrees
+def s2d(degrees, arcmins=0, arcsecs=0, mas=0, muas=0):
+    return (
+        degrees
+        + (arcmins / 60.0)
+        + (arcsecs / (60.0 * 60.0))
+        + (mas / (60.0 * 60.0 * 1e3))
+        + (muas / (60.0 * 60.0 * 1e6))
+    )
+
+
+# Evaluate a polynomial at argument
+def polynomial(coefficients, argument):
+    return sum([c * (argument**i) for i, c in enumerate(coefficients)])
+
+
+# Evaluate the first derivative of a polynomial at argument
+def d_polynomial(coefficients, argument):
+    return sum([c * i * (argument ** (i - 1)) for i, c in enumerate(coefficients)])
+
+
+# Meeus formula 11.1
+def T(t):
+    return (JD(t) - 2451545.0) / 36525
+
+
+# Meeus formula 7.1
+def JD(t):
+    Y, M = t.year, t.month
+    D = (
+        t.day
+        + t.hour / (24.0)
+        + t.minute / (24.0 * 60.0)
+        + t.second / (24.0 * 60.0 * 60.0)
+        + t.microsecond / (24.0 * 60.0 * 60.0 * 1e6)
+    )
+    if M <= 2:
+        Y = Y - 1
+        M = M + 12
+    A = np.floor(Y / 100.0)
+    B = 2 - A + np.floor(A / 4.0)
+    return np.floor(365.25 * (Y + 4716)) + np.floor(30.6001 * (M + 1)) + D + B - 1524.5
+
+
+# Meeus formula 21.3
+terrestrial_obliquity_coefficients = (
+    s2d(23, 26, 21.448),
+    -s2d(0, 0, 4680.93),
+    -s2d(0, 0, 1.55),
+    s2d(0, 0, 1999.25),
+    -s2d(0, 0, 51.38),
+    -s2d(0, 0, 249.67),
+    -s2d(0, 0, 39.05),
+    s2d(0, 0, 7.12),
+    s2d(0, 0, 27.87),
+    s2d(0, 0, 5.79),
+    s2d(0, 0, 2.45),
+)
+
+# Adjust these coefficients for parameter T rather than U
+terrestrial_obliquity_coefficients = [
+    c * (1e-2) ** i for i, c in enumerate(terrestrial_obliquity_coefficients)
+]
+
+# Not entirely sure about this interpretation, but this is the difference
+# between Meeus formulae 24.2 and 24.3 and seems to work
+solar_perigee_coefficients = (
+    280.46645 - 357.52910,
+    36000.76932 - 35999.05030,
+    0.0003032 + 0.0001559,
+    0.00000048,
+)
+
+# Meeus formula 24.2
+solar_longitude_coefficients = (280.46645, 36000.76983, 0.0003032)
+
+# This value is taken from JPL Horizon and is essentially constant
+lunar_inclination_coefficients = (5.145,)
+
+# Meeus formula 45.1
+lunar_longitude_coefficients = (
+    218.3164591,
+    481267.88134236,
+    -0.0013268,
+    1 / 538841.0 - 1 / 65194000.0,
+)
+
+# Meeus formula 45.7
+lunar_node_coefficients = (
+    125.0445550,
+    -1934.1361849,
+    0.0020762,
+    1 / 467410.0,
+    -1 / 60616000.0,
+)
+
+# Meeus, unnumbered formula directly preceded by 45.7
+lunar_perigee_coefficients = (
+    83.3532430,
+    4069.0137111,
+    -0.0103238,
+    -1 / 80053.0,
+    1 / 18999000.0,
+)
+
+
+# Now follow some useful auxiliary values, we won't need their speed.
+# See notes on Table 6 in Schureman for I, nu, xi, nu', 2nu''
+def _I(N, i, omega):
+    N, i, omega = d2r * N, d2r * i, d2r * omega
+    cosI = np.cos(i) * np.cos(omega) - np.sin(i) * np.sin(omega) * np.cos(N)
+    return r2d * np.arccos(cosI)
+
+
+def _xi(N, i, omega):
+    N, i, omega = d2r * N, d2r * i, d2r * omega
+    e1 = np.cos(0.5 * (omega - i)) / np.cos(0.5 * (omega + i)) * np.tan(0.5 * N)
+    e2 = np.sin(0.5 * (omega - i)) / np.sin(0.5 * (omega + i)) * np.tan(0.5 * N)
+    e1, e2 = np.arctan(e1), np.arctan(e2)
+    e1, e2 = e1 - 0.5 * N, e2 - 0.5 * N
+    return -(e1 + e2) * r2d
+
+
+def _nu(N, i, omega):
+    N, i, omega = d2r * N, d2r * i, d2r * omega
+    e1 = np.cos(0.5 * (omega - i)) / np.cos(0.5 * (omega + i)) * np.tan(0.5 * N)
+    e2 = np.sin(0.5 * (omega - i)) / np.sin(0.5 * (omega + i)) * np.tan(0.5 * N)
+    e1, e2 = np.arctan(e1), np.arctan(e2)
+    e1, e2 = e1 - 0.5 * N, e2 - 0.5 * N
+    return (e1 - e2) * r2d
+
+
+# Schureman equation 224
+# Can we be more precise than B "the solar coefficient" = 0.1681?
+def _nup(N, i, omega):
+    I = d2r * _I(N, i, omega)
+    nu = d2r * _nu(N, i, omega)
+    return r2d * np.arctan(
+        np.sin(2 * I) * np.sin(nu) / (np.sin(2 * I) * np.cos(nu) + 0.3347)
+    )
+
+
+# Schureman equation 232
+def _nupp(N, i, omega):
+    I = d2r * _I(N, i, omega)
+    nu = d2r * _nu(N, i, omega)
+    tan2nupp = (np.sin(I) ** 2 * np.sin(2 * nu)) / (
+        np.sin(I) ** 2 * np.cos(2 * nu) + 0.0727
+    )
+    return r2d * 0.5 * np.arctan(tan2nupp)
+
+
+AstronomicalParameter = namedtuple("AstronomicalParameter", ["value", "speed"])
+
+
+def astro(t):
+    a = {}
+    # We can use polynomial fits from Meeus to obtain good approximations to
+    # some astronomical values (and therefore speeds).
+    polynomials = {
+        "s": lunar_longitude_coefficients,
+        "h": solar_longitude_coefficients,
+        "p": lunar_perigee_coefficients,
+        "N": lunar_node_coefficients,
+        "pp": solar_perigee_coefficients,
+        "90": (90.0,),
+        "omega": terrestrial_obliquity_coefficients,
+        "i": lunar_inclination_coefficients,
+    }
+    # Polynomials are in T, that is Julian Centuries; we want our speeds to be
+    # in the more convenient unit of degrees per hour.
+    dT_dHour = 1 / (24 * 365.25 * 100)
+    for name, coefficients in polynomials.items():
+        a[name] = AstronomicalParameter(
+            np.mod(polynomial(coefficients, T(t)), 360.0),
+            d_polynomial(coefficients, T(t)) * dT_dHour,
+        )
+
+    # Some other parameters defined by Schureman which are dependent on the
+    # parameters N, i, omega for use in node factor calculations. We don't need
+    # their speeds.
+    args = [each.value for each in [a["N"], a["i"], a["omega"]]]
+    for name, function in {
+        "I": _I,
+        "xi": _xi,
+        "nu": _nu,
+        "nup": _nup,
+        "nupp": _nupp,
+    }.items():
+        a[name] = AstronomicalParameter(np.mod(function(*args), 360.0), None)
+
+    # We don't work directly with the T (hours) parameter, instead our spanning
+    # set for equilibrium arguments #is given by T+h-s, s, h, p, N, pp, 90.
+    # This is in line with convention.
+    hour = AstronomicalParameter((JD(t) - np.floor(JD(t))) * 360.0, 15.0)
+    a["T+h-s"] = AstronomicalParameter(
+        hour.value + a["h"].value - a["s"].value,
+        hour.speed + a["h"].speed - a["s"].speed,
+    )
+    # It is convenient to calculate Schureman's P here since several node
+    # factors need it, although it could be argued that these
+    # (along with I, xi, nu etc) belong somewhere else.
+    a["P"] = AstronomicalParameter(np.mod(a["p"].value - a["xi"].value, 360.0), None)
+    return a

cht_tide-0.0.1/cht_tide/constituent.py

@@ -0,0 +1,245 @@
+#   Copyright notice
+#   --------------------------------------------------------------------
+#   Copyright (C) 2020 Deltares
+#       Freek Scheel
+#
+#       freek.scheel@deltares.nl
+#
+#       P.O. Box 177
+#       2600 MH Delft
+#       The Netherlands
+#
+#   This library is free software: you can redistribute it and/or modify
+#   it under the terms of the GNU Lesser General Public License as published by
+#   the Free Software Foundation, either version 3 of the License, or
+#   (at your option) any later version.
+#
+#   This library is distributed in the hope that it will be useful,
+#   but WITHOUT ANY WARRANTY; without even the implied warranty of
+#   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#   GNU General Public License for more details.
+#
+#   You should have received a copy of the GNU General Public License
+#   along with this library.  If not, see <http://www.gnu.org/licenses/>.
+#   --------------------------------------------------------------------
+
+import operator as op
+import string
+from functools import reduce
+
+import numpy as np
+
+import cht_tide.nodal_corrections as nc
+
+
+class BaseConstituent(object):
+    xdo_int = {
+        "A": 1,
+        "B": 2,
+        "C": 3,
+        "D": 4,
+        "E": 5,
+        "F": 6,
+        "G": 7,
+        "H": 8,
+        "I": 9,
+        "J": 10,
+        "K": 11,
+        "L": 12,
+        "M": 13,
+        "N": 14,
+        "O": 15,
+        "P": 16,
+        "Q": 17,
+        "R": -8,
+        "S": -7,
+        "T": -6,
+        "U": -5,
+        "V": -4,
+        "W": -3,
+        "X": -2,
+        "Y": -1,
+        "Z": 0,
+    }
+
+    int_xdo = {v: k for k, v in xdo_int.items()}
+
+    def __init__(self, name, xdo="", coefficients=[], u=nc.u_zero, f=nc.f_unity):
+        if xdo == "":
+            self.coefficients = np.array(coefficients)
+        else:
+            self.coefficients = np.array(self.xdo_to_coefficients(xdo))
+        self.name = name
+        self.u = u
+        self.f = f
+
+    def xdo_to_coefficients(self, xdo):
+        return [self.xdo_int[l.upper()] for l in xdo if l in string.ascii_letters]
+
+    def coefficients_to_xdo(self, coefficients):
+        return "".join([self.int_xdo[c] for c in coefficients])
+
+    def V(self, astro):
+        return np.dot(self.coefficients, self.astro_values(astro))
+
+    def xdo(self):
+        return self.coefficients_to_xdo(self.coefficients)
+
+    def speed(self, a):
+        return np.dot(self.coefficients, self.astro_speeds(a))
+
+    def astro_xdo(self, a):
+        return [a["T+h-s"], a["s"], a["h"], a["p"], a["N"], a["pp"], a["90"]]
+
+    def astro_speeds(self, a):
+        return np.array([each.speed for each in self.astro_xdo(a)])
+
+    def astro_values(self, a):
+        return np.array([each.value for each in self.astro_xdo(a)])
+
+    # Consider two out of phase constituents which travel at the same speed to
+    # be identical
+    def __eq__(self, c):
+        return np.all(self.coefficients[:-1] == c.coefficients[:-1])
+
+    def __hash__(self):
+        return hash(tuple(self.coefficients[:-1]))
+
+
+class CompoundConstituent(BaseConstituent):
+    def __init__(self, members=[], **kwargs):
+        self.members = members
+
+        if "u" not in kwargs:
+            kwargs["u"] = self.u
+        if "f" not in kwargs:
+            kwargs["f"] = self.f
+
+        super(CompoundConstituent, self).__init__(**kwargs)
+
+        self.coefficients = reduce(op.add, [c.coefficients * n for (c, n) in members])
+
+    def speed(self, a):
+        return reduce(op.add, [n * c.speed(a) for (c, n) in self.members])
+
+    def V(self, a):
+        return reduce(op.add, [n * c.V(a) for (c, n) in self.members])
+
+    def u(self, a):
+        return reduce(op.add, [n * c.u(a) for (c, n) in self.members])
+
+    def f(self, a):
+        return reduce(op.mul, [c.f(a) ** abs(n) for (c, n) in self.members])
+
+
+###### Base Constituents
+# Long Term
+_Z0 = BaseConstituent(name="Z0", xdo="Z ZZZ ZZZ", u=nc.u_zero, f=nc.f_unity)
+_Sa = BaseConstituent(name="Sa", xdo="Z ZAZ ZZZ", u=nc.u_zero, f=nc.f_unity)
+_Ssa = BaseConstituent(name="Ssa", xdo="Z ZBZ ZZZ", u=nc.u_zero, f=nc.f_unity)
+_Mm = BaseConstituent(name="Mm", xdo="Z AZY ZZZ", u=nc.u_zero, f=nc.f_Mm)
+_Mf = BaseConstituent(name="Mf", xdo="Z BZZ ZZZ", u=nc.u_Mf, f=nc.f_Mf)
+
+# Diurnals
+_Q1 = BaseConstituent(name="Q1", xdo="A XZA ZZA", u=nc.u_O1, f=nc.f_O1)
+_O1 = BaseConstituent(name="O1", xdo="A YZZ ZZA", u=nc.u_O1, f=nc.f_O1)
+_K1 = BaseConstituent(name="K1", xdo="A AZZ ZZY", u=nc.u_K1, f=nc.f_K1)
+_J1 = BaseConstituent(name="J1", xdo="A BZY ZZY", u=nc.u_J1, f=nc.f_J1)
+
+# M1 is a tricky business for reasons of convention, rather than theory.  The
+# reasons for this are best summarised by Schureman paragraphs 126, 127 and in
+# the comments found in congen_input.txt of xtides, so I won't go over all this
+# again here.
+
+_M1 = BaseConstituent(name="M1", xdo="A ZZZ ZZA", u=nc.u_M1, f=nc.f_M1)
+_P1 = BaseConstituent(name="P1", xdo="A AXZ ZZA", u=nc.u_zero, f=nc.f_unity)
+_S1 = BaseConstituent(name="S1", xdo="A AYZ ZZZ", u=nc.u_zero, f=nc.f_unity)
+_OO1 = BaseConstituent(name="OO1", xdo="A CZZ ZZY", u=nc.u_OO1, f=nc.f_OO1)
+
+# Semi-Diurnals
+_2N2 = BaseConstituent(name="2N2", xdo="B XZB ZZZ", u=nc.u_M2, f=nc.f_M2)
+_N2 = BaseConstituent(name="N2", xdo="B YZA ZZZ", u=nc.u_M2, f=nc.f_M2)
+_nu2 = BaseConstituent(name="nu2", xdo="B YBY ZZZ", u=nc.u_M2, f=nc.f_M2)
+_M2 = BaseConstituent(name="M2", xdo="B ZZZ ZZZ", u=nc.u_M2, f=nc.f_M2)
+_lambda2 = BaseConstituent(name="lambda2", xdo="B AXA ZZB", u=nc.u_M2, f=nc.f_M2)
+_L2 = BaseConstituent(name="L2", xdo="B AZY ZZB", u=nc.u_L2, f=nc.f_L2)
+_T2 = BaseConstituent(name="T2", xdo="B BWZ ZAZ", u=nc.u_zero, f=nc.f_unity)
+_S2 = BaseConstituent(name="S2", xdo="B BXZ ZZZ", u=nc.u_zero, f=nc.f_unity)
+_R2 = BaseConstituent(name="R2", xdo="B BYZ ZYB", u=nc.u_zero, f=nc.f_unity)
+_K2 = BaseConstituent(name="K2", xdo="B BZZ ZZZ", u=nc.u_K2, f=nc.f_K2)
+
+# Third-Diurnals
+_M3 = BaseConstituent(
+    name="M3", xdo="C ZZZ ZZZ", u=lambda a: nc.u_Modd(a, 3), f=lambda a: nc.f_Modd(a, 3)
+)
+
+###### Compound Constituents
+# Long Term
+_MSF = CompoundConstituent(name="MSF", members=[(_S2, 1), (_M2, -1)])
+
+# Diurnal
+_2Q1 = CompoundConstituent(name="2Q1", members=[(_N2, 1), (_J1, -1)])
+_rho1 = CompoundConstituent(name="rho1", members=[(_nu2, 1), (_K1, -1)])
+
+# Semi-Diurnal
+
+_mu2 = CompoundConstituent(name="mu2", members=[(_M2, 2), (_S2, -1)])  # 2MS2
+_2SM2 = CompoundConstituent(name="2SM2", members=[(_S2, 2), (_M2, -1)])
+
+# Third-Diurnal
+_2MK3 = CompoundConstituent(name="2MK3", members=[(_M2, 1), (_O1, 1)])
+_MK3 = CompoundConstituent(name="MK3", members=[(_M2, 1), (_K1, 1)])
+
+# Quarter-Diurnal
+_MN4 = CompoundConstituent(name="MN4", members=[(_M2, 1), (_N2, 1)])
+_M4 = CompoundConstituent(name="M4", members=[(_M2, 2)])
+_MS4 = CompoundConstituent(name="MS4", members=[(_M2, 1), (_S2, 1)])
+_S4 = CompoundConstituent(name="S4", members=[(_S2, 2)])
+
+# Sixth-Diurnal
+_M6 = CompoundConstituent(name="M6", members=[(_M2, 3)])
+_S6 = CompoundConstituent(name="S6", members=[(_S2, 3)])
+
+# Eighth-Diurnals
+_M8 = CompoundConstituent(name="M8", members=[(_M2, 4)])
+
+
+noaa = [
+    _M2,
+    _S2,
+    _N2,
+    _K1,
+    _M4,
+    _O1,
+    _M6,
+    _MK3,
+    _S4,
+    _MN4,
+    _nu2,
+    _S6,
+    _mu2,
+    _2N2,
+    _OO1,
+    _lambda2,
+    _S1,
+    _M1,
+    _J1,
+    _Mm,
+    _Ssa,
+    _Sa,
+    _MSF,
+    _Mf,
+    _rho1,
+    _Q1,
+    _T2,
+    _R2,
+    _2Q1,
+    _P1,
+    _2SM2,
+    _M3,
+    _L2,
+    _2MK3,
+    _K2,
+    _M8,
+    _MS4,
+]