pygtide 0.8.2__cp314-cp314-macosx_15_0_arm64.whl

pygtide/update_etpred_data.py

@@ -0,0 +1,515 @@
+"""
+PyGTide Update - A python class to update the files upon which PyGTide depends
+-------------------------------------------------------------------------------
+Author: Gabriel C. Rau (gabriel@hydrogeo.science)
+Website: https://hydrogeo.science
+"""
+
+import pygtide.etpred as etpred
+
+from importlib import resources
+from pathlib import Path
+import numpy as np
+import time as tt
+import pandas as pd
+import datetime as dt
+import urllib
+import urllib.request
+import re
+import os
+
+
+def timestampToDecyear(ts):
+    year = ts.year
+    jan1 = pd.Timestamp(year, 1, 1)
+    jan1next = pd.Timestamp(year + 1, 1, 1)
+    yrlen = (jan1next - jan1).total_seconds()
+    return year + (ts - jan1).total_seconds() / yrlen
+
+
+class update_etpred_db(object):
+    """
+    The pygtide_update class will initialise internal variables
+    """
+
+    def __init__(self, msg=True):
+        self.msg = msg
+        # Resolve package data directory directly from filesystem.
+        # Avoid importlib.resources.as_file() which creates temp dirs that get cleaned up.
+        pkg_dir = os.path.dirname(__file__)
+        self.data_dir = os.path.join(pkg_dir, "commdat")
+        if not self.data_dir.endswith(os.sep):
+            self.data_dir += os.sep
+
+        # Fortran expects a fixed-length string (256 chars)
+        etpred.params.comdir = self.data_dir + " " * (256 - len(self.data_dir))
+
+        # OS-dependent null file
+        etpred.params.nullfile = os.devnull + " " * (10 - len(os.devnull))
+
+        # set OS dependent module output
+        etpred.params.nullfile = os.devnull + " " * (10 - len(os.devnull))
+        self.etddt_file = str(etpred.params.etddtdat, "UTF-8").strip()
+        self.etpolut1_dat_file = str(etpred.params.etpolutdat, "UTF-8").strip()
+        self.etpolut1_bin_file = str(etpred.params.etpolutbin, "UTF-8").strip()
+
+        # %% remote data files
+        # IERS leap seconds history file
+        self.etddt_tmpl = "etddt_tmpl.dat"
+        self.leapsec_rfile = (
+            "https://hpiers.obspm.fr/iers/bul/bulc/Leap_Second_History.dat"
+        )
+        # IERS pole coordinate observations
+        # self.iauhist_rfile = 'http://hpiers.obspm.fr/iers/eop/eopc04/eopc04_IAU2000.62-now'
+        self.iauhist_rfile = (
+            "ftp://hpiers.obspm.fr/iers/eop/eopc04/eopc04_IAU2000.62-now"
+        )
+        # US navy pole coordinate predictions
+        self.iaucurr_rfile = "https://datacenter.iers.org/data/9/finals2000A.all"
+        # self.iaucurr_rfile = 'ftp://cddis.gsfc.nasa.gov/pub/products/iers/finals2000A.all'
+
+    # %% update the pole coordinates and UT1 to TAI times
+    def update_etpolut1(self):
+        global etpolut
+        status = True
+        etpolut1_file = Path(self.data_dir + "/" + self.etpolut1_dat_file)
+        leapsec_file = Path(self.data_dir + "/" + "[raw]_Leap_Second_History.dat")
+        iauhist_file = Path(self.data_dir + "/" + "[raw]_eopc04_IAU2000.dat")
+        iaucurr_file = Path(self.data_dir + "/" + "[raw]_finals2000A.dat")
+
+        print("--------------------------------------")
+        print(
+            "-->> Updating the Earth orientation database '{:s}':".format(
+                etpolut1_file.as_posix()
+            )
+        )
+        start = tt.time()
+        if status:
+            try:
+                print("Start downloading: {:s} ...".format(self.leapsec_rfile))
+                urllib.request.urlopen(self.leapsec_rfile)
+            except OSError as error:
+                print(
+                    "ERROR: Could not connect to remote server: {:s}".format(
+                        self.leapsec_rfile
+                    )
+                )
+                print("MESSAGE: {0}.".format(error))
+                status = False
+                pass
+            else:
+                urllib.request.urlretrieve(self.leapsec_rfile, leapsec_file)
+                end = tt.time()
+                print("Finished downloading ({:.1f} s).".format((end - start)))
+
+        if status:
+            try:
+                print("Start downloading: {:s} ...".format(self.iauhist_rfile))
+                urllib.request.urlopen(self.iauhist_rfile, timeout=1)
+            except OSError as error:
+                print(
+                    "ERROR: Could not connect to remote server: {:s}".format(
+                        self.iauhist_rfile
+                    )
+                )
+                print("MESSAGE: {0}.".format(error))
+                status = False
+                pass
+            else:
+                urllib.request.urlretrieve(self.iauhist_rfile, iauhist_file)
+                end = tt.time()
+                print("Finished downloading ({:.1f} s).".format((end - start)))
+
+        if status:
+            try:
+                print("Start downloading: {:s} ...".format(self.iaucurr_rfile))
+                urllib.request.urlopen(self.iaucurr_rfile)
+            except OSError as error:
+                print(
+                    "ERROR: Could not connect to remote server: {:s}".format(
+                        self.iaucurr_rfile
+                    )
+                )
+                print("MESSAGE: {0}.".format(error))
+                status = False
+                pass
+            else:
+                urllib.request.urlretrieve(self.iaucurr_rfile, iaucurr_file)
+                end = tt.time()
+                print("Finished downloading ({:.1f} s).".format((end - start)))
+
+        # %%
+        if status:
+            try:
+                open(leapsec_file, "r")
+            except OSError as error:
+                print(
+                    "ERROR: Could not open file: {:s}".format(leapsec_file.as_posix())
+                )
+                print("MESSAGE: {0}.".format(error))
+                status = False
+                pass
+
+        if status:
+            try:
+                open(iauhist_file, "r")
+            except OSError as error:
+                print(
+                    "ERROR: Could not open file: {:s}".format(iauhist_file.as_posix())
+                )
+                print("MESSAGE: {0}.".format(error))
+                status = False
+                pass
+
+        if status:
+            try:
+                open(iaucurr_file, "r")
+            except OSError as error:
+                print(
+                    "ERROR: Could not open file: {:s}".format(iaucurr_file.as_posix())
+                )
+                print("MESSAGE: {0}.".format(error))
+                status = False
+                pass
+
+        if status:
+            # %% read leap second history
+            leapsdf = pd.read_csv(
+                leapsec_file,
+                comment="#",
+                header=None,
+                delimiter=r"\s+",
+                names=["MJD", "day", "month", "year", "leaps"],
+                usecols=[0, 1, 2, 3, 4],
+            )
+
+            # Create datetime column from day, month, year
+            leapsdf["date"] = pd.to_datetime(leapsdf[["year", "month", "day"]])
+
+            # Keep only 'date' and 'leaps'
+            leapsdf = leapsdf[["date", "leaps"]]
+
+            # Reindex starting at 1
+            leapsdf.index += 1
+
+            # Insert initial row at the beginning
+            leapsdf.loc[0] = [dt.datetime(1962, 1, 1), 10]
+
+            # Sort index to restore correct order
+            leapsdf.sort_index(inplace=True)
+
+            # %% read historic pole coordinates
+            # convert = {3: lambda x: np.around(np.float64(x), 3)}
+            iauhist = pd.read_csv(
+                iauhist_file,
+                skiprows=13,
+                header=None,
+                delimiter=r"\s+",
+                usecols=[0, 1, 2, 3, 4, 5, 6],
+                names=["year", "month", "day", "MJD", "x", "y", "UT1-UTC"],
+            )
+
+            # Combine year, month, day into a single datetime column
+            iauhist["date"] = pd.to_datetime(iauhist[["year", "month", "day"]])
+
+            # Keep only the desired columns
+            iauhist = iauhist[["date", "MJD", "x", "y", "UT1-UTC"]]
+
+            # %% read current pole coordinates
+            fw = [2, 2, 2, 9, 3, 9, 9, 10, 9, 3, 10, 10]
+            iaucurr = pd.read_fwf(
+                iaucurr_file, header=None, widths=fw, usecols=[0, 1, 2, 3, 5, 7, 10]
+            )
+
+            iaucurr_dates = (
+                iaucurr.iloc[:, 0].astype(str).str.zfill(2)
+                + "-"
+                + iaucurr.iloc[:, 1].astype(str).str.zfill(2)
+                + "-"
+                + iaucurr.iloc[:, 2].astype(str).str.zfill(2)
+            )
+
+            iaucurr["date"] = pd.to_datetime(iaucurr_dates, format="%y-%m-%d")
+
+            # Drop old columns used for date
+            iaucurr = iaucurr.drop(columns=iaucurr.columns[:3])
+            # Rename remaining columns
+            iaucurr.columns = ["MJD", "x", "y", "UT1-UTC", "date"]
+            # Move 'date' to first position if needed
+            iaucurr = iaucurr[["date", "MJD", "x", "y", "UT1-UTC"]]
+
+            mask = iaucurr["date"] > iauhist["date"].iloc[-1]
+            etpolut = pd.concat([iauhist, iaucurr.loc[mask]])
+            etpolut = etpolut[np.isfinite(etpolut["x"])]
+
+            # %%
+            etpolut["Date"] = etpolut["date"].dt.strftime("%Y%m%d")
+            etpolut["Time"] = etpolut["date"].dt.strftime("%H%M%S")
+            etpolut["MJD"] = etpolut["MJD"].map("{:8.3f}".format)
+            etpolut["x"] = etpolut["x"].map("{:9.5f}".format)
+            etpolut["y"] = etpolut["y"].map("{:9.5f}".format)
+            etpolut["TAI-UT1"] = etpolut["UT1-UTC"]
+            etpolut["UT1-UTC"] = etpolut["UT1-UTC"].map("{:9.6f}".format)
+
+            # %%
+            # prepare the last column
+            for idx, val in leapsdf.iterrows():
+                # print(idx, val[1])
+                # find mask for leap seconds
+                if idx + 1 in leapsdf.index:
+                    mask = (etpolut["date"] >= leapsdf["date"].loc[idx]) & (
+                        etpolut["date"] < leapsdf["date"].loc[idx + 1]
+                    )
+                    # print(mask)
+                    # subtract leap seconds from UTC
+                    etpolut.loc[mask, "TAI-UT1"] = (
+                        leapsdf["leaps"].loc[idx] - etpolut.loc[mask, "TAI-UT1"]
+                    )
+                else:
+                    mask = etpolut["date"] >= leapsdf["date"].loc[idx]
+                    etpolut.loc[mask, "TAI-UT1"] = (
+                        leapsdf["leaps"].loc[idx] - etpolut.loc[mask, "TAI-UT1"]
+                    )
+
+            etpolut["TAI-UT1"] = etpolut["TAI-UT1"].map("{:9.6f}".format)
+
+            # %%
+            # etpolut[0] = etpolut[0].map('${:,.2f}'.format)
+            header = """File     : etpolut1.dat
+Updated  : $1$
+Contents : Pole coordinates and earth rotation one day sampling interval,
+       given at 0 hours UTC. Historic data is combined with predictions.
+       Data are from IERS and USNO.
+Period   : $2$
+Historic : $3$
+Current  : $4$
+Leap sec.: $5$
+
+Date     Time   MJD         x         y       UT1-UTC   TAI-UT1
+                           ["]       ["]      [sec]     [sec]
+C****************************************************************\n"""
+            header = header.replace("$1$", dt.datetime.now(dt.timezone.utc).strftime("%d/%m/%Y"))
+            header = header.replace(
+                "$2$",
+                etpolut["date"].iloc[0].strftime("%d/%m/%Y")
+                + " to "
+                + etpolut["date"].iloc[-1].strftime("%d/%m/%Y"),
+            )
+            header = header.replace("$3$", self.iauhist_rfile)
+            header = header.replace("$4$", self.iaucurr_rfile)
+            header = header.replace("$5$", self.leapsec_rfile)
+
+            pd.options.display.max_colwidth = 200
+
+            # IMPORTANT: newline needs to comply with windows platform!
+            # https://pythonconquerstheuniverse.wordpress.com/2011/05/08/newline-conversion-in-python-3/
+            with open(etpolut1_file, "w", newline="") as myfile:
+                myfile.write(header)
+                # myfile.write(etpolut['combined'].to_string(index=False, header=False).replace('\n ', '\n'))
+                # etpolut['combined'].to_string(myfile, index=False, header=False)
+                # WEIRD PANDAS BUG: to_string() puts white space at beginning of each line
+                for index, row in etpolut.iterrows():
+                    string = "{:s} {:s} {:s} {:s} {:s} {:s} {:s}".format(
+                        row["Date"],
+                        row["Time"],
+                        row["MJD"],
+                        row["x"],
+                        row["y"],
+                        row["UT1-UTC"],
+                        row["TAI-UT1"],
+                    )
+                    myfile.write(string + "\r\n")
+                myfile.write("99999999")
+            myfile.close()
+            end = tt.time()
+            # update also bin file
+            self.etpolut1_dat2bin()
+            print(
+                "Finished updating {:s} ({:.1f} s).".format(
+                    etpolut1_file.as_posix(), (end - start)
+                )
+            )
+        else:
+            print("Update failed!")
+            pass
+
+        # %% remove temporary files
+        os.remove(leapsec_file)
+        os.remove(iauhist_file)
+        os.remove(iaucurr_file)
+        return
+
+    # %% update the etpolut1 binary file from the text file
+    def etpolut1_dat2bin(self):
+        etpolut1_dat = Path(self.data_dir + "/" + self.etpolut1_dat_file)
+        etpolut1_bin = Path(self.data_dir + "/" + self.etpolut1_bin_file)
+        header = []
+        # find the end of the header
+        with open(etpolut1_dat, "r") as f:
+            for num, line in enumerate(f, 1):
+                header.append(line)
+                if "C*******" in header[-1]:
+                    break
+
+        # read into dataframe
+        cols = ["Date", "Time", "MJD", "x", "y", "UT1-UTC", "TAI-UT1"]
+        etpolut = pd.read_csv(
+            etpolut1_dat, names=cols, skiprows=num, header=None, delimiter=r"\s+"
+        )
+        # drop the last row with EOL ('99999999')
+        etpolut = etpolut[:-1]
+        print(
+            "File '{:s}' has {:d} rows.".format(
+                etpolut1_dat.as_posix(), etpolut.shape[0]
+            )
+        )
+        # %%
+        # write as binary for use in fortran: each record has 4*8 bytes = 32 bytes
+        # header contains start date in MJD and number of rows + 1
+        head = np.array([np.int32(etpolut.iloc[0, 2]), np.int32(etpolut.shape[0] + 1)])
+        data = np.float64(etpolut.values[:, 3:])
+        # print(data)
+        with open(etpolut1_bin, "wb+") as f:
+            # write header integers
+            f.write(head.tobytes())
+            # advance to next record (32 bytes)
+            f.seek(32)
+            # write the flattened matrix (this may have 64 bytes)
+            f.write(data.flatten().tobytes())
+        f.close()
+        print(
+            "File '{:s}' has been updated (Header: {:.0f}, {:d}).".format(
+                etpolut1_bin.as_posix(), etpolut.iloc[0, 2], etpolut.shape[0] + 1
+            )
+        )
+
+    # %% update the time conversion database (leap seconds)
+    def update_etddt(self):
+        global etddt, leapsdf, tmp
+        leapsec_file = Path(self.data_dir + "/" + "[raw]_Leap_Second_History.dat")
+        old_etddt_file = Path(self.data_dir + "/" + self.etddt_tmpl)
+        etddt_file = Path(self.data_dir + "/" + self.etddt_file)
+
+        # %%
+        print("--------------------------------------")
+        print(
+            "-->> Updating time conversion database '{:s}':".format(
+                leapsec_file.as_posix()
+            )
+        )
+        # %% download leap second history
+        start = tt.time()
+        try:
+            print("Start downloading: {:s} ...".format(leapsec_file.as_posix()))
+            urllib.request.urlopen(self.leapsec_rfile)
+        except OSError as error:
+            print("ERROR: Could not connect to remote server!")
+            print("MESSAGE: {0}.".format(error))
+            pass
+        else:
+            urllib.request.urlretrieve(self.leapsec_rfile, leapsec_file)
+            end = tt.time()
+            print("Finished downloading ({:.1f} s).".format((end - start)))
+
+        # %% READ THE EXISTING FILE
+        # print(etddt_file)
+        # find the end of the header
+        with open(old_etddt_file, "r") as f:
+            print("Processing file '{:s}' ...".format(etddt_file.as_posix()))
+            header = []
+            regex = re.compile(r"^\s*updated\s*\:.*$", re.IGNORECASE)
+            for num, line in enumerate(f, 1):
+                line = regex.sub(
+                    "Updated    : %s" % dt.datetime.now(dt.timezone.utc).strftime("%d/%m/%Y"),
+                    line,
+                )
+                header.append(line)
+                if "C*******" in header[-1]:
+                    break
+
+        cols = ["year", "JD", "DDT"]
+        etddt = pd.read_csv(
+            old_etddt_file, names=cols, skiprows=num, header=None, delimiter=r"\s+"
+        )
+
+        # %% read leap second history
+        leapsdf = pd.read_csv(
+            leapsec_file,
+            comment="#",
+            header=None,
+            delimiter=r"\s+",
+            names=[
+                "MJD",
+                "day",
+                "month",
+                "year",
+                "leaps",
+            ],  # assign proper column names
+            usecols=[0, 1, 2, 3, 4],
+        )
+        # Combine day, month, year into a single datetime column
+        leapsdf["date"] = pd.to_datetime(leapsdf[["year", "month", "day"]])
+
+        # Keep only the relevant columns
+        leapsdf = leapsdf[["date", "MJD", "leaps"]]
+
+        # Compute DDT = leaps + 32.184 s
+        leapsdf["DDT"] = leapsdf["leaps"] + 32.184
+
+        # %%
+        leapsdf["JD"] = [dt.to_julian_date() for dt in leapsdf["date"]]
+        leapsdf["year"] = [timestampToDecyear(dt) for dt in leapsdf["date"]]
+
+        # %%
+        mask = leapsdf["year"] > etddt["year"].values[-1]
+        indices = leapsdf.index[mask]
+        # print(indices)
+        # tmp = []
+        for i, val in enumerate(indices):
+            # for each record create a new row
+            etddt.loc[len(etddt) + 1] = {
+                "year": leapsdf.loc[val, "year"],
+                "JD": leapsdf.loc[val, "JD"],
+                "DDT": leapsdf.loc[val, "DDT"],
+            }
+
+        # number of new records
+        records = sum(mask)
+        if records > 0:
+            # write header
+            with open(self.data_dir + "/" + self.etddt_file, "w+", newline="\r\n") as f:
+                f.write("".join(header))
+                # etddt['combined'].to_string(f, index=False, header=False)
+                # f.write("\n")
+                # WEIRD PANDAS BUG: to_string() puts white space at beginning of each line
+                for index, row in etddt.iterrows():
+                    string = "{:.5f} {:.5f} {:8.3f}".format(
+                        row["year"], row["JD"], row["DDT"]
+                    )
+                    # print(string)
+                    f.write(string + "\n")
+                f.close()
+            end = tt.time()
+            print(
+                "{:d} records were added to the template ({:.1f} s).".format(
+                    records, end - start
+                )
+            )
+        print(
+            "The leap second File ('{:s}') is now up to date ({:.1f} s).".format(
+                self.etddt_file, end - start
+            )
+        )
+
+
+# %% run the update
+def update(msg=True):
+    pt = update_etpred_db(msg)
+    pt.update_etddt()
+    print(etddt.iloc[-10:, :])
+    pt.update_etpolut1()
+    print("---------------------")
+
+
+if __name__ == "__main__":
+    update()

pygtide-0.8.2.dist-info/METADATA

@@ -0,0 +1,124 @@
+Metadata-Version: 2.4
+Name: pygtide
+Version: 0.8.2
+Summary: A Python module and wrapper for ETERNA PREDICT to compute gravitational tides on Earth
+Author: Tom Eulenfeld
+Author-email: "Gabriel C. Rau" <gabriel@hydrogeo.science>
+License-Expression: MPL-2.0
+Project-URL: Homepage, https://github.com/hydrogeoscience/pygtide
+Project-URL: Documentation, https://hydrogeo.science
+Project-URL: Repository, https://github.com/hydrogeoscience/pygtide.git
+Project-URL: Issues, https://github.com/hydrogeoscience/pygtide/issues
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Science/Research
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Scientific/Engineering :: Physics
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy>=1.21.0
+Requires-Dist: pandas
+Dynamic: license-file
+
+# PyGTide
+[![DOI](https://zenodo.org/badge/DOI/10.5281/zenodo.1346260.svg)](https://doi.org/10.5281/zenodo.1346260)
+
+## A Python module and wrapper for ETERNA PREDICT to compute gravitational tides on Earth
+
+PyGTide is a Python module that wraps around ETERNA PREDICT 3.4 which is compiled from Fortran into an executable using [f2py](https://docs.scipy.org/doc/numpy/f2py/). The original ETERNA PREDICT 3.3 was written by the late Prof. H.-G. Wenzel (Wenzel, 1996) in a mix of Fortran 77 and 90. This was updated by Kudryavtsev (2004) to include the latest tidal catalogue. Note that the original Fortran code was comprehensively revised in order to facilitate integration into Python. The original Fortran code for ETERNA PREDICT can be downloaded from the [International Geodynamics and Earth Tide Service (IGETS)](http://igets.u-strasbg.fr/soft_and_tool.php).
+
+## How to use
+
+There are two options:
+* Download and install on your system (see below instructions)
+* Via our online calculator: <a href="https://groundwater.app/app.php?app=pygtide" target="_blank">groundwater.app</a>
+
+
+## How to install and run
+
+### Prerequisites
+
+* Download and install [*Anaconda*](https://www.anaconda.com/products/distribution) or [*Miniconda*](https://docs.conda.io/en/latest/miniconda.html)
+* Install required packages:
+  ```
+  conda install numpy pandas
+  ```
+
+### Installation options
+
+#### Option 1: Install and compile source distribution from PyPi (Python 3.8–3.11) or install pre-compiled distribution (Linux, macOS, Windows; Python>=3.12)
+
+```bash
+pip install pygtide
+```
+
+#### Option 2: Build from source locally (Linux, macOS, Windows; Python>=3.8)
+
+**Requirements for building:**
+- A Fortran compiler (e.g., `gfortran` via MinGW on Windows; included in Linux/macOS gcc toolchains) `conda install gfortran`
+- Meson build system with ninja: automatically installed via `pip`
+
+**Clone repo from git:**
+```bash
+git clone https://github.com/hydrogeoscience/pygtide.git
+```
+
+**Install from local repository:**
+```bash
+cd /path/to/pygtide
+
+pip install .
+```
+
+### After installation
+
+* Run tests to verify installation:
+  ```
+  python -c "import pygtide; pygtide.test(msg=True)"
+  ```
+
+* Update internal database files (downloads latest leap seconds and pole data):
+  ```
+  python -c "import pygtide; pygtide.update()"
+  ```
+
+### Example usage
+
+See `pygtide/tests.py` for complete examples. Quick start:
+
+```python
+from pygtide import predict_series
+args = (-20.82071, -70.15288, 830.0, '2020-01-01', 6, 600)
+series = predict_series(*args, statazimut=90, tidalcompo=8)
+```
+
+## How to use
+
+An updated user guide is currently in progress ...
+
+
+## How to cite
+If you use PyGTide, please cite the work as:
+
+*Rau, Gabriel C. (2018) hydrogeoscience/pygtide: PyGTid. Zenodo. [https://doi.org/10.5281/zenodo.1346260](https://doi.org/10.5281/zenodo.1346260)*
+
+## Example
+<img src="https://raw.githubusercontent.com/hydrogeoscience/pygtide/master/earth_tide_example.png" width="500">
+This image shows Earth tides calculated for the city Karlsruhe (Germany) in the year 2018.
+
+## References
+* Hartmann, T., and H.-G. Wenzel (1995), The HW95 tidal potential catalogue, Geophysical Research Letters, 22(24), 3553–3556, https://doi.org/10.1029/95GL03324.
+* Kudryavtsev, S. M. (2004), Improved harmonic development of the Earth tide-generating potential, Journal of Geodesy, 17(12), 829-838, https://doi.org/10.1007/s00190-003-0361-2.
+* Wenzel, H.-G. (1996), The nanogal software: Earth tide data processing package ETERNA 3.30, Bulletin d’Informations des Marées Terrestres, 124, 9425–9439.
+* McMillan, T. C., and Rau, G. C., and Timms, W. A., and Andersen, M. S. (2019), Utilizing the impact of Earth and atmospheric tides on groundwater systems: A review reveals the future potential, Reviews of Geophysics, https://dx.doi.org/10.1029/2018RG000630.
+
+## License
+PyGTide is released by [Gabriel C. Rau](https://hydrogeo.science) and [Tom Eulenfeld](https://scholar.google.com/citations?user=SJXF3mwAAAAJ&hl=en) under the [Mozilla Public License 2.0](https://www.mozilla.org/en-US/MPL/2.0/)

pygtide-0.8.2.dist-info/RECORD

@@ -0,0 +1,27 @@
+pygtide/update_etpred_data.py,sha256=Qq1L18dIBmcljY1scYlhq4R-dCvAiRovWa0TvSyLeJY,20099
+pygtide/__init__.py,sha256=GDTiNIuNxlnnNxt9ZzuOTM6pnAP0xTKOHP2b1cL6jlg,550
+pygtide/core.py,sha256=cFVr4MIh6zdaSWji4GSQWJR7y0vUPKiUGv3chFyTUZ8,24870
+pygtide/tests.py,sha256=a_ISOCP0ZQqX7RZEpWs8Cgy3sOpuMz7U_hby-ELkOJg,2836
+pygtide/etpred.so,sha256=GJAXZ7gp5qdNmoHrUyHA8-bBHaJuAQ3v7jXzfTv-hUw,255808
+pygtide/commdat/[raw]_eopc04_IAU2000.dat,sha256=KxG3418Ei3PTLpVhUiUb4Xfe3wei2RUkPdrxcf4tEXg,3438828
+pygtide/commdat/ksm03.dat,sha256=Vm9Ki0syDWFElATnipPYdbKzAOjq0suXLpCZPoDaeOM,3376311
+pygtide/commdat/[raw]_finals2000A.dat,sha256=IVpyQIn1SF31QSXlmauHEde3EYlZ5Cje8BAtd2VRof8,3472736
+pygtide/commdat/etddt.dat,sha256=dGlRn_1mr24PfYe21uYBTCMfK4lgLyvB4WASqFpvMi8,8804
+pygtide/commdat/hw95s.dat,sha256=5jTmVgtBGT4u0y419izudWtRvkTLVBIShDGnIIrJBQ4,1387984
+pygtide/commdat/buellehw.dat,sha256=rdPoy3_ti_EAQVVh52LopEjdK6vzwmuRvL5zz36FErw,74886
+pygtide/commdat/etpolut1.dat,sha256=_8m8-C7MRgKzyxCWzg5fwo5PY3c-bTZhOPxcGtFVBo4,1539863
+pygtide/commdat/tamurahw.dat,sha256=IEA7UCyXPhtawMSFcaLo5lAiXBUjlFFrhzEVi7fJJgI,132651
+pygtide/commdat/cted73hw.dat,sha256=MgXpux18c8_vzYFyxj4o0LBuhUzyau6_Kn_ocyi7ZHA,60593
+pygtide/commdat/doodsehw.dat,sha256=WrjGdssZnMnK8Ou77Y7m3T7DlKWqS1KKExdt5zpTBWY,45589
+pygtide/commdat/ratgp95.dat,sha256=3OJplSsT7Tlhqks2dd9tpt6SQpN3UyMNR-WJOKWm2NU,694252
+pygtide/commdat/[raw]_Leap_Second_History.dat,sha256=I3OPHsFPfRKzsLDzaU3TSNID419loYq4s10qvuUMX64,1359
+pygtide/commdat/etddt_tmpl.dat,sha256=oqf7mXP0w2XpeFn34pdec7csDGlkU1fpS5fnVw8a0S8,8191
+pygtide/commdat/xi1989hw.dat,sha256=gz4ALMVjDRfcQ2wxJjSLPl5HCsp_wQJNfyMfKeMz0Go,316600
+pygtide/.dylibs/libgfortran.5.dylib,sha256=99789i_-NnS7IQbTwqkda12OBSYyRDNYQ_ysaPqPeB8,2215232
+pygtide/.dylibs/libquadmath.0.dylib,sha256=AlETbt6vE9tgihFfxma6uF1DpgZ31j4KjXbXpQ8gVGI,362768
+pygtide/.dylibs/libgcc_s.1.1.dylib,sha256=clc36rqoUnzTS9oS0bDTJl4UJBomeWLlxBOzbueYO-I,220288
+pygtide-0.8.2.dist-info/RECORD,,
+pygtide-0.8.2.dist-info/WHEEL,sha256=59HIdHQbECqK4HZdSy7PNtdzqg2EbF0lIn3L0mnWAxA,137
+pygtide-0.8.2.dist-info/top_level.txt,sha256=MHVHiiI0GXxh3mAyQttFc1S0jXkE2Z7Zkl2iTnkV-NQ,8
+pygtide-0.8.2.dist-info/METADATA,sha256=ozP6p4DlLEF5nmLE6DaIvOwA1Sl3pD1nA_TXpKqK6HU,5352
+pygtide-0.8.2.dist-info/licenses/LICENSE,sha256=HyVuytGSiAUQ6ErWBHTqt1iSGHhLmlC8fO7jTCuR8dU,16725

pygtide-0.8.2.dist-info/WHEEL

@@ -0,0 +1,6 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.10.2)
+Root-Is-Purelib: false
+Tag: cp314-cp314-macosx_15_0_arm64
+Generator: delocate 0.13.0
+