wavyopen 0.1.4__tar.gz

wavyopen-0.1.4/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2021 bohlinger
+
+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.

wavyopen-0.1.4/PKG-INFO

@@ -0,0 +1,34 @@
+Metadata-Version: 2.1
+Name: wavyopen
+Version: 0.1.4
+Summary: A package for processing wave measurements and wave model output.
+Author: Patrik Bohlinger
+Author-email: patrikb@met.no
+Requires-Python: >=3.7.1,<3.12
+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
+Requires-Dist: Cartopy (>=0.20)
+Requires-Dist: PyYAML (>=5.4.1,<6.0.0)
+Requires-Dist: cmocean (>=2.0,<3.0)
+Requires-Dist: dask (>=2022.01.0,<2023.0.0)
+Requires-Dist: geojson (>=2.5.0,<3.0.0)
+Requires-Dist: joblib (>=1.0.1,<2.0.0)
+Requires-Dist: matplotlib (>=3.4.3,<4.0.0)
+Requires-Dist: netCDF4 (>=1.5.7,<2.0.0)
+Requires-Dist: numpy (>=1.21.2,<2.0.0)
+Requires-Dist: pandas (>=1.3.3,<2.0.0)
+Requires-Dist: pygam (>=0.8.0,<0.9.0)
+Requires-Dist: pyproj (>=3.1)
+Requires-Dist: pyresample (>=1.21.0,<2.0.0)
+Requires-Dist: python-dotenv (>=0.19.0,<0.20.0)
+Requires-Dist: roaring-landmask (>=0.5)
+Requires-Dist: scikit-learn (>=0.24.2,<0.25.0)
+Requires-Dist: scipy (>=1.7.1,<2.0.0)
+Requires-Dist: sentinelsat (>=1.1.0,<2.0.0)
+Requires-Dist: tqdm (>=4.62.2,<5.0.0)
+Requires-Dist: xarray (>=0.19.0,<0.20.0)
+Requires-Dist: xdg (>=5.1.1,<6.0.0)
+Requires-Dist: zarr (>=2.9.5,<3.0.0)

wavyopen-0.1.4/pyproject.toml

@@ -0,0 +1,67 @@
+[tool.poetry]
+name = "wavyopen"
+version = "0.1.4"
+description = "A package for processing wave measurements and wave model output."
+authors = ["Patrik Bohlinger <patrikb@met.no>"]
+packages = [
+    {include = "wavy"}
+]
+
+[tool.poetry.scripts]
+wavyQuick = "apps.standalone.wavyQuick:main"
+wavyDownload = "apps.standalone.download:main"
+
+[tool.poetry.dependencies]
+python = ">=3.7.1,<3.12"
+matplotlib = "^3.4.3"
+numpy = "^1.21.2"
+scipy = "^1.7.1"
+netCDF4 = "^1.5.7"
+PyYAML = "^5.4.1"
+pyproj = ">=3.1"
+Cartopy = ">=0.20"
+cmocean = "^2.0"
+joblib = "^1.0.1"
+scikit-learn = "^0.24.2"
+pandas = "^1.3.3"
+pygam = "^0.8.0"
+xarray = "^0.19.0"
+zarr = "^2.9.5"
+pyresample = "^1.21.0"
+dask = "^2022.01.0"
+tqdm = "^4.62.2"
+python-dotenv = "^0.19.0"
+sentinelsat = "^1.1.0"
+xdg = "^5.1.1"
+roaring-landmask = ">=0.5"
+geojson = "^2.5.0"
+
+[tool.poetry.dev-dependencies]
+pytest = "^6.2.5"
+pytest-benchmark = "^3.4.1"
+pylint = "^2.10.2"
+yapf = "^0.31.0"
+Sphinx = "^4.2.0"
+
+[build-system]
+requires = ["poetry-core>=1.0.0"]
+build-backend = "poetry.core.masonry.api"
+
+[tool.pytest.ini_options]
+minversion = "6.0"
+addopts = "--benchmark-disable"
+testpaths = [
+  "tests",
+]
+markers = [
+  "need_credentials:need credentials to run"
+]
+
+
+[tool.pylint.master]
+extension-pkg-whitelist="netCDF4,numpy,scipy,roaring_landmask"
+
+[tool.pylint.messages_control]
+disable = "all"
+enable = "F,unreachable,duplicate-key,unnecessary-semicolon,global-variable-not-assigned,unused-variable,unused-wildcard-import,binary-op-exception,bad-format-string,anomalous-backslash-in-string,bad-open-mode,E0001,E0011,E0012,E0100,E0101,E0102,E0103,E0104,E0105,E0107,E0108,E0110,E0111,E0112,E0113,E0114,E0115,E0116,E0117,E0118,E0202,E0203,E0211,E0213,E0236,E0237,E0238,E0239,E0240,E0241,E0301,E0302,E0303,E0401,E0402,E0601,E0602,E0603,E0604,E0611,E0632,E0633,E0701,E0702,E0703,E0704,E0710,E0711,E0712,E1003,E1101,E1102,E1111,E1120,E1121,E1123,E1124,E1125,E1126,E1127,E1128,E1129,E1130,E1131,E1132,E1133,E1134,E1135,E1137,E1138,E1139,E1200,E1201,E1205,E1206,E1300,E1301,E1302,E1303,E1304,E1305,E1306,E1310,E1700,E1701"
+

wavyopen-0.1.4/wavy/GPfcts.py

@@ -0,0 +1,119 @@
+import numpy as np
+from numpy.linalg import inv
+from numpy.linalg import cholesky, det, lstsq
+import scipy as sp
+
+def kernel(X1, X2, l=1.0, sigma_f=1.0):
+    '''
+    Isotropic squared exponential kernel. Computes
+    a covariance matrix from points in X1 and X2.
+    Args:
+        X1: Array of m points (m x d).
+        X2: Array of n points (n x d).
+    Returns:
+        Covariance matrix (m x n).
+    '''
+    sqdist = np.sum(X1**2, 1).reshape(-1, 1) \
+            + np.sum(X2**2, 1) - 2 * np.dot(X1, X2.T)
+    M = sigma_f**2 * np.exp(-0.5 / l**2 * sqdist)
+    return M
+
+def posterior_predictive_nigp(X_s, X_train, Y_train,
+l=None,sigma_f=None, sigma_y=None, sigma_x=None,
+Grad_fmean=None):
+    '''
+    Computes statistics of the GP posterior predictive distribution
+    from m training data X_train and Y_train and n new inputs X_s.
+    Args:
+        X_s: New input locations (n x d)
+        X_train: Training locations (m x d)
+        Y_train: Training targets (m x 1)
+        l: length scale parameter
+        sigma_f: signal variance parameter
+        sigma_y: noise paramter on y
+        sigma_x: noise parameter on x
+    Returns:
+        Posterior mean vector (n x d) and covariance matrix (n x n)
+    '''
+    # Gradient at training points
+    Grad_fmean_train = np.interp(
+            X_train.ravel(), X_s.ravel(), Grad_fmean.ravel())
+    Grad_fmean_train = Grad_fmean_train.reshape(-1,1)
+    Grad_fmean_input = Grad_fmean.copy()
+    Grad_fmean_input = Grad_fmean_input.reshape(-1,1)
+    # constituents of equations for mean and covariance
+    K = kernel(X_train, X_train, l, sigma_f) + \
+        sigma_y**2 * np.eye(len(X_train)) + \
+        np.diag(np.diag(np.dot(Grad_fmean_train,
+            np.atleast_2d(Grad_fmean_train.ravel())))) * sigma_x**2
+    K_s = kernel(X_train, X_s, l, sigma_f)
+    K_ss = kernel(X_s, X_s, l, sigma_f) + \
+        sigma_y**2 * np.eye(len(X_s)) + \
+        np.diag(np.diag(np.dot(Grad_fmean_input,
+            np.atleast_2d(Grad_fmean_input.ravel())))) * sigma_x**2
+    ### possible solutions:
+    ## 1. classical
+    K_inv = inv(K)
+    # Equation (4)
+    mu_s = K_s.T.dot(K_inv).dot(Y_train)
+    # Equation (5)
+    cov_s = K_ss - K_s.T.dot(K_inv).dot(K_s)
+#    ## 2. use of cholesky decomposition
+#    L = sp.linalg.cholesky(K, lower=True)
+#    a1 = np.linalg.lstsq(L, Y_train, rcond=None)[0]
+#    alpha = np.linalg.lstsq(L.T, a1, rcond=None)[0]
+#    # Equation (4) of Krasser
+#    mu_s = K_s.T.dot(alpha)
+#    # Equation (5) of Krasser
+#    v = np.linalg.lstsq(L, K_s, rcond=None)[0]
+#    cov_s = K_ss - v.T.dot(v)
+    return mu_s, cov_s
+
+def nll_fn_nigp(X_train,Y_train,Grad_fmean,naive=False):
+    '''
+    Returns a function that computes the negative log marginal
+    likelihood for training data X_train and Y_train and given
+    noise level.
+    Args:
+        X_train: training locations (m x d).
+        Y_train: training targets (m x 1).
+        noise: known noise level of Y_train.
+        naive: if True use a naive implementation of Eq. (7), if
+               False use a numerically more stable implementation.
+    Returns:
+        Minimization objective.
+    '''
+    def nll_naive(theta):
+        # Naive implementation of Eq. (7). Works well for the examples
+        # in this article but is numerically less stable compared to
+        # the implementation in nll_stable below.
+        K = kernel(X_train, X_train, l=theta[0], sigma_f=theta[1]) + \
+            theta[2]**2 * np.eye(len(X_train)) + \
+            np.diag(np.diag(np.dot(Grad_fmean,
+                np.atleast_2d(Grad_fmean.ravel())))) * theta[3]**2
+        F = 0.5 * np.log(det(K)) + \
+               0.5 * Y_train.T.dot(inv(K).dot(Y_train)) + \
+               0.5 * len(X_train) * np.log(2*np.pi)
+        return F.ravel()
+    def nll_stable(theta):
+        # Numerically more stable implementation of Eq. (7) as described
+        # in http://www.gaussianprocess.org/gpml/chapters/RW2.pdf, Section
+        # 2.2, Algorithm 2.1.
+        K = kernel(X_train, X_train, l=theta[0], sigma_f=theta[1]) + \
+            theta[2]**2 * np.eye(len(X_train)) + \
+            np.diag(np.diag(np.dot(Grad_fmean,
+                np.atleast_2d(Grad_fmean.ravel())))) * theta[3]**2
+        #L = cholesky(K)
+        L = sp.linalg.cholesky(K,lower=True)
+        F = np.sum(np.log(np.diagonal(L))) + \
+                  0.5 * Y_train.T.dot(lstsq(
+                  L.T, lstsq(
+                    L, Y_train,rcond=None
+                    )[0],rcond=None)[0]
+                  ) + \
+                  0.5 * len(X_train) * np.log(2*np.pi)
+        return F.ravel()
+    if naive:
+        return nll_naive
+    else:
+        return nll_stable