pyshbundle 1.0.0__py2.py3-none-any.whl

pyshbundle/GRACE_Data_Driven_Correction_Vishwakarma.py

@@ -0,0 +1,346 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+#Created on Tue Jun 28 14:17:50 2022
+#@author: Amin Shakya, Interdisciplinary Center for Water Research (ICWaR), Indian Institute of Science (IISc)
+# - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 
+# Original Codes
+
+#Data-driven approach for leakage and attenuation control
+#based on Vishwakarma et. al., (2021)
+
+#   Detailed explanation goes here
+
+# Input: F, a cell matrix with one column containing SH coefficients
+#      : cf, the column in F that contains SH coefficients from GRACE
+#      : GaussianR, radius of the Gaussian filter (recommened = 400)
+#      : basins, mask functions of basin, a cell data format with one
+#      column and each entry is a 360 x 720 matrix with 1 inside the
+#      catchment and 0 outside
+
+# Output : every output has a size (number of months x basins)
+#        : RecoveredTWS, corrected data-driven time-series (Least Squares fit method)
+#        : RecoveredTWS2, corrected data-driven time-series (shift and amplify method)
+#        : FilteredTS, gaussian filtered GRACE TWS time-series for all the basins. 
+# - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 
+
+# License:
+#    This file is part of PySHbundle.
+#    PySHbundle is free software: you can redistribute it and/or modify
+#    it under the terms of the GNU General Public License as published by
+#    the Free Software Foundation, either version 3 of the License, or
+#    (at your option) any later version.
+
+#    This program 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 program.  If not, see <http://www.gnu.org/licenses/>.
+# - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 
+
+# Acknowledgement Statement:
+#    Please note that PySHbundle has adapted the following code packages, 
+#    both licensed under GNU General Public License
+#       1. SHbundle: https://www.gis.uni-stuttgart.de/en/research/downloads/shbundle/
+
+#       2. Downscaling GRACE Total Water Storage Change using Partial Least Squares Regression
+#          https://springernature.figshare.com/collections/Downscaling_GRACE_Total_Water_Storage_Change_using_Partial_Least_Squares_Regression/5054564 
+    
+# Key Papers Referred:
+#    1. Vishwakarma, B. D., Horwath, M., Devaraju, B., Groh, A., & Sneeuw, N. (2017). 
+#       A data‐driven approach for repairing the hydrological catchment signal damage 
+#       due to filtering of GRACE products. Water Resources Research, 
+#       53(11), 9824-9844. https://doi.org/10.1002/2017WR021150
+
+#    2. Vishwakarma, B. D., Zhang, J., & Sneeuw, N. (2021). 
+#       Downscaling GRACE total water storage change using 
+#       partial least squares regression. Scientific data, 8(1), 95.
+#       https://doi.org/10.1038/s41597-021-00862-6
+# - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 
+
+import numpy as np
+import numpy.matlib as npm
+import scipy as sc
+import scipy.io
+#CS2SC, gsha, gshs, gaussian
+
+from . import gaussian
+from . import cs2sc
+from . import gshs
+from . import gsha
+from . import naninterp
+from . import Phase_calc
+
+def deg_to_rad(deg: float):
+    """Converts angle from degree to radian
+
+    Args:
+        deg (float): Angle in degree
+
+    Returns:
+        float: Angle in Radian
+    
+    Todo:
+        + Inbuilt function available in numpy module
+    """
+    return deg * np.pi/180
+
+def GRACE_Data_Driven_Correction_Vishwakarma(F, cf, GaussianR, basins):
+    """_summary_
+
+    Args:
+        F (_type_): a cell matrix with one column containing SH coefficients
+        cf (_type_): the column in F that contains SH coefficients from GRACE
+        GaussianR (_type_): radius of the Gaussian filter (recommened = 400)
+        basins (_type_): mask functions of basin, a cell data format with one
+                        column and each entry is a 360 x 720 matrix with 1 inside the
+                        catchment and 0 outside
+
+    Raises:
+        Exception: corrected data-driven time-series (Least Squares fit method)
+        Exception: corrected data-driven time-series (shift and amplify method)
+        Exception: gaussian filtered GRACE TWS time-series for all the basins.
+
+    Returns:
+        _type_: _description_
+    
+    Todo:
+        + TypeError
+    """
+    deg = 0.5
+    deg_rad = deg_to_rad(deg)
+    
+    x = np.linspace(0, 360-deg, int(360/deg))
+    y = np.linspace(0, 180-deg, int(180/deg))
+    x1 = np.linspace(deg, 360, int(360/deg))
+    y1 = np.linspace(deg, 180, int(180/deg))
+    lambdd,theta = np.meshgrid(x,y)  
+    lambdd1,theta1 = np.meshgrid(x1,y1)
+    
+    theta_rad = deg_to_rad(theta)
+    theta1_rad = deg_to_rad(theta1)
+    
+    #Areahalfdeg = (6378.137**2)*np.power(10,6)*np.pi/180*(np.multiply(a,b)) #Area matrix
+    Areahalfdeg = (6378.137**2)*(((np.pi/180)*lambdd1) - ((np.pi/180)*lambdd))*(np.sin((np.pi/2) - theta_rad) - np.sin((np.pi/2) - theta1_rad))
+    
+    qty = 'water'
+    
+    if type(F) != np.ndarray:
+        raise Exception("input GRACE field should be in Numpy Ndarray format, please check guidelines")
+        
+    
+    if type(basins) != np.ndarray:
+        raise Exception("input basin field should be in Numpy NdArray format, please check guidelines")
+        
+
+    r = F.shape[0] #No of entries in F numpy ndarrray
+    
+    cid = 1 #number of river catchments
+    
+    f = F[:,cf-1:cf]
+    l = f[0][0].shape[0]
+    cfield = f[0][0].shape[1]
+    if cfield == l:
+        flag_cs = 0
+    else:
+        flag_cs = 1
+
+    Weights = gaussian.gaussian(l-1, GaussianR) 
+    #gaussian returns weights as a list #gaussian is np.array()
+    
+    try: #Broadcase Weights into dimensions
+        filter_ = np.ones([1,(2*(l-1))+1]) * Weights
+    except:
+        w0 = Weights.shape[0]
+        Weights = Weights.reshape(w0,1)
+        filter_ = np.ones([1,(2*(l-1))+1]) * Weights
+    
+    
+    #SH Synthesis
+    if l == cfield:
+        for m in range(r):
+            if flag_cs == 0:
+                Ft = cs2sc.cs2sc(f[m][0]).astype('longdouble') 
+            else:
+                Ft = f[m][0].astype('longdouble') 
+                
+           
+            fFld__, _, _ = gshs.gshs(Ft * filter_, qty, 'cell', int(180/deg), 0, 0) 
+            ffFld__, _, _ = gshs.gshs((Ft * filter_ * filter_), qty, 'cell', int(180/deg), 0, 0)
+            
+            if m == 0:
+                fFld = np.zeros((r,fFld__.shape[0],fFld__.shape[1]), dtype = 'longdouble') 
+                ffFld = np.zeros((r, ffFld__.shape[0], ffFld__.shape[1]), dtype = 'longdouble')
+                
+            fFld[m] = fFld__
+            ffFld[m] = ffFld__
+            
+        long = 360/deg
+        Area = Areahalfdeg
+    else:
+        raise Exception("enter CS coefficients")
+        
+
+        
+    #Declaration of size of the vectors:
+    cid = len(basins) #Here basins is a dictionary with each element storing nd array
+    tsleaktotalf = np.zeros([r, cid], dtype = 'longdouble')
+    tsleaktotalff = np.zeros([r, cid], dtype = 'longdouble')
+    
+    ftsleaktotal = np.zeros([r, cid], dtype = 'longdouble')
+    fftsleaktotal = np.zeros([r, cid], dtype = 'longdouble')
+    
+    lhat = np.zeros([r, cid], dtype = 'longdouble')
+    
+    bfDevRegAv = np.zeros([r, cid], dtype = 'longdouble')
+    bbfDevRegAv = np.zeros([r, cid], dtype = 'longdouble')
+
+    FilteredTS = np.zeros([r, cid], dtype = 'longdouble')
+    filfilts = np.zeros([r, cid], dtype = 'longdouble')
+
+    leakage = np.zeros([r, cid], dtype = 'longdouble')
+    leakager = np.zeros([r, cid], dtype = 'longdouble')   
+    
+
+    
+    for rbasin in range(0, cid):
+        #Get the basin functions ready
+       
+        #Basin functions, filtered basin function and transfer function Kappa
+        Rb = basins[rbasin][0] 
+        csRb = gsha.gsha(Rb, 'mean', 'block', long/2) 
+        csF = cs2sc.cs2sc(csRb[0:l, 0:l]) 
+        filRb_ = gshs(csF * filter_, 'none', 'cell', int(long/2), 0, 0) 
+        filRb = filRb_[0]
+        kappa = (1-Rb) * filRb
+         
+        
+    
+        fF = np.zeros((fFld__.shape[0],fFld__.shape[1]), dtype = 'longdouble')
+        ffF = np.zeros((fFld__.shape[0],fFld__.shape[1]), dtype = 'longdouble')
+        for m in range(0,r):
+            
+            
+            fF = np.concatenate((fFld[m,:,int(fF.shape[1]/2):], fFld[m,:,:int(fF.shape[1]/2)]), axis=1)
+            ffF = np.concatenate((ffFld[m,:,int(ffF.shape[1]/2):], ffFld[m,:,:int(ffF.shape[1]/2)]), axis=1)
+            #if False:    
+            if np.isnan(fF[:20,:20]).any(): #if there is a gap in time series, fill it with NaNs
+                                                
+
+                tsleaktotalf[m][rbasin] = np.nan
+                tsleaktotalff[m][rbasin] = np.nan
+                FilteredTS[m][rbasin] = np.nan
+                filfilts[m][0:rbasin] = np.nan
+                bfDevRegAv[m][rbasin] = np.nan
+                bbfDevRegAv[m][0:rbasin] = np.nan
+            
+            else:
+                #leakage time series from filtered and twice filtered fields
+                tsleaktotalf[m][rbasin] = np.sum(fF * kappa * Area) / np.sum(Rb * Area)
+                tsleaktotalff[m][rbasin] = np.sum(ffF * kappa * Area) / np.sum(Rb * Area)
+                
+                #time series from filtered fields
+                FilteredTS[m][rbasin] = np.sum(fF * Rb * Area) / np.sum(Rb * Area)
+                filfilts[m][rbasin] = np.sum(ffF * Rb * Area) / np.sum(Rb * Area)
+                
+                #Deviation integral timeseries
+                bfDevRegAv[m][rbasin] = np.sum((fF * Rb - FilteredTS[m][rbasin]) * filRb * Area) / np.sum(Rb * Area) #working 2022-10-20
+                bbfDevRegAv[m][rbasin] = np.sum((ffF * Rb - filfilts[m][rbasin]) * filRb * Area) / np.sum(Rb * Area)
+                print(m)
+                
+                
+       
+    
+    
+    b = list()
+    bl = list()
+    for i in range(0, cid):
+                
+        A = np.ones([60,2])
+        A[:,1] = naninterp(bbfDevRegAv[:, i]) #Pchip interpolate should contain atleast two elements
+        
+        lssol_ = sc.linalg.lstsq(A, naninterp(bfDevRegAv[:, i])) #returns a tuple of solution "x", residue and rank of matrix A; for A x = B
+        lssol = lssol_[0] 
+        
+        b.append(lssol[2-1])
+        
+        
+        A = np.ones([60,2])
+        A[:,1] = naninterp.naninterp(tsleaktotalff[:, i])
+        lssol_ = sc.linalg.lstsq(A, naninterp.naninterp(tsleaktotalf[:, i])) #returns a tuple of solution "x", residue and rank of matrix A; for A x = B
+        lssol = lssol_[0]
+        bl.append(lssol[2-1])
+        #Working till here 2022-10-21 1530pm
+    
+    multp = npm.repmat(b, r, 1) 
+    devint = bfDevRegAv * multp
+    multp = npm.repmat(bl, r, 1)
+    leakLS = tsleaktotalf * multp
+    
+    
+    ps = Phase_calc.Phase_calc(tsleaktotalf,tsleaktotalff)
+    
+    
+    
+    #Compute the near true leakage
+    
+    for i in range(0, cid):   
+        ftsleaktotal[:,i] = naninterp.naninterp(tsleaktotalf[:,i]) #Replaces gaps (NaN values) with an itnerpolated value in the leakage time series from once filtered fields
+        fftsleaktotal[:,i] = naninterp.naninterp(tsleaktotalff[:,i]) #replace the gaps (NaN values) with an interpolated value in leakage time series from twice filtered fields
+        
+        X = sc.fft.fft(ftsleaktotal[:,i]) #take fast Fourier transform #check shape of X 2022-10-21
+        p = -ps[0,i] / r #compute the fraction of the time period by which the time series is to be shiftes
+        Y = np.exp(1j * np.pi * p * ((np.arange(r)) - r/2) / r) #compute the Conjugate-Symmetric shift 
+        Z = X * Y #Apply the shift
+        
+        a = sc.fft.ifft(Z) #apply inverse fft
+        
+        con = np.conj(a)
+        
+        s = a + con
+        
+        z = s/2
+        
+        leakage[:,i] = z #shifted timeseries
+        
+        
+        #Shift timeseriecs from once filtered fields in the direction of the time series from twice filtered fields, to later compute the amplitude ratio
+        p = ps[0,i] / r #Fraction of a time period to shift data
+        Y = np.exp(1j * np.pi * p * ((np.arange(r)) - r/2) / r) #compute the Conjugate-Symmetric shift
+        Z = X * Y
+        
+        a = sc.fft.ifft(Z) #apply inverse fft
+        
+        con = np.conj(a)
+        
+        s = a + con
+        
+        z = s/2
+        
+        leakager[:,i] = z #shifted timeseries
+        
+    
+    
+    #compute the ratio between the amplitude of the shifted leakage from once filtered fields and leakage from twice filtered fields
+    rfn = leakage/fftsleaktotal
+    rfn[(rfn) >= 2] = 1
+    rfn[(rfn) <= -2] = -1
+    rfn = np.sum(np.abs(rfn), axis = 0)
+    rfn=rfn/r # amplitude ratio
+    
+    
+    lhat = leakager * rfn #apply the amplitude ratio to the shifted leakage timeseries from the once filtered fields to get the near true leakage
+    lhat[np.isnan(FilteredTS)] = np.nan #reintroduce nan for data gaps
+    leakLS[np.isnan(FilteredTS)] = np.nan
+    RecoveredTWS = FilteredTS - leakLS - devint
+    RecoveredTWS2 = FilteredTS - lhat - devint
+    
+    return RecoveredTWS, RecoveredTWS2, FilteredTS
+        
+        
+        
+    
+    
+            

pyshbundle/GRACEconstants.py

@@ -0,0 +1,76 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+# Created on Sat May  9 18:49:45 2022
+# This file contains some basic constants:
+#  - physical
+#  - geodetic (GRS80)
+# @author: Dr. Bramha Dutt Vishwakarma, Interdisciplinary Center for Water Research (ICWaR), Indian Institute of Science (IISc)
+
+# License:
+#    This file is part of PySHbundle.
+#    PySHbundle is free software: you can redistribute it and/or modify
+#    it under the terms of the GNU General Public License as published by
+#    the Free Software Foundation, either version 3 of the License, or
+#    (at your option) any later version.
+
+#    This program 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 program.  If not, see <http://www.gnu.org/licenses/>.
+    
+
+# Acknowledgement Statement:
+#    Please note that PySHbundle has adapted the following code packages, 
+#    both licensed under GNU General Public License
+#       1. SHbundle: https://www.gis.uni-stuttgart.de/en/research/downloads/shbundle/
+
+#       2. Downscaling GRACE Total Water Storage Change using Partial Least Squares Regression
+#          https://springernature.figshare.com/collections/Downscaling_GRACE_Total_Water_Storage_Change_using_Partial_Least_Squares_Regression/5054564 
+    
+# Key Papers Referred:
+#    1. Vishwakarma, B. D., Horwath, M., Devaraju, B., Groh, A., & Sneeuw, N. (2017). 
+#       A data‐driven approach for repairing the hydrological catchment signal damage 
+#       due to filtering of GRACE products. Water Resources Research, 
+#       53(11), 9824-9844. https://doi.org/10.1002/2017WR021150
+
+#    2. Vishwakarma, B. D., Zhang, J., & Sneeuw, N. (2021). 
+#       Downscaling GRACE total water storage change using 
+#       partial least squares regression. Scientific data, 8(1), 95.
+#       https://doi.org/10.1038/s41597-021-00862-6 
+
+""" This script contains some of the major relavant Physical and Geodetic(GRS80) constants:
+
+    + `clight` speed of light - $2.99792458e+8$ $m/s$
+    + `G` Gravitational constant- $6.67259e-11$ $\frac{m^3} {kg \cdot s^2}$
+    + `au` astronomical unit - $149.597870691e+9$ $m$
+
+    + `ae` semi-major axis of ellipsoid `GRS 80`- $6378137$ m
+    + `GM` geocentric grav. constant `GRS 80`- $3.986005e+14$ $\frac{m^3}{s^2}$
+    + `J2` earth's dynamic form factor `GRS 80` - $1.08263e-3$ [unitless C20 unnormalized coefficient]
+    + `Omega` mean ang. velocity `GRS 80` - $7.292115e-5 $\frac{rad}{s}$
+
+    + `flat` flattening - $\frac{1}{298.257222101}$
+
+
+"""
+
+clight = 2.99792458e8	      # speed of light [m/s]
+G      = 6.67259e-11         # gravitational constant [m^3 /(kg s^2)]
+au     = 149.597870691e9     # astronomical unit [m]
+
+# GRS80 defining constants:
+ae     = 6378137             # semi-major axis of ellipsoid [m]
+GM     = 3.986005e14         # geocentric grav. constant [m^3 / s^2]
+J2     = 1.08263e-3          # earth's dyn. form factor (= -C20 unnormalized)
+Omega  = 7.292115e-5         # mean ang. velocity [rad/s]
+
+# GRS80 derived constants:
+flat = 1/298.257222101     # flattening
+J4   = -0.237091222e-5     # -C40 unnormalized
+J6   =  0.608347e-8        # -C60 unnormalized
+J8   = -0.1427e-10         # -C80 unnormalized
+

pyshbundle/GRACEpy.py

@@ -0,0 +1,172 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+# License:
+#    This file is part of PySHbundle.
+#    PySHbundle is free software: you can redistribute it and/or modify
+#    it under the terms of the GNU General Public License as published by
+#    the Free Software Foundation, either version 3 of the License, or
+#    (at your option) any later version.
+
+#    This program 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 program.  If not, see <http://www.gnu.org/licenses/>.
+    
+# - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 
+
+# Acknowledgement Statement:
+#    Please note that PySHbundle has adapted the following code packages, 
+#    both licensed under GNU General Public License
+#       1. SHbundle: https://www.gis.uni-stuttgart.de/en/research/downloads/shbundle/
+
+#       2. Downscaling GRACE Total Water Storage Change using Partial Least Squares Regression
+#          https://springernature.figshare.com/collections/Downscaling_GRACE_Total_Water_Storage_Change_using_Partial_Least_Squares_Regression/5054564 
+    
+# Key Papers Referred:
+#    1. Vishwakarma, B. D., Horwath, M., Devaraju, B., Groh, A., & Sneeuw, N. (2017). 
+#       A data‐driven approach for repairing the hydrological catchment signal damage 
+#       due to filtering of GRACE products. Water Resources Research, 
+#       53(11), 9824-9844. https://doi.org/10.1002/2017WR021150
+
+#    2. Vishwakarma, B. D., Zhang, J., & Sneeuw, N. (2021). 
+#       Downscaling GRACE total water storage change using 
+#       partial least squares regression. Scientific data, 8(1), 95.
+#       https://doi.org/10.1038/s41597-021-00862-6
+
+import numpy
+from . import GRACEconstants as GC
+
+
+def upwcon(degree: int, height):
+    """returns the upward continuation $(R/r)^l$
+
+    Args:
+        degree (int): Spherical harmonic degree
+        height (int): Height above mean Earth radius [m] [scalar/vector]
+    
+    Returns:
+        uc (_type_): Upward continuation terms
+    
+    Uses:
+        `GRACEconstants.GC`
+    
+    Todo:
+        + Add input checking functionality and raise exceptions
+        + Add reference to formula
+    """
+    # Created on Sat May  9 18:49:45 2022
+    rr = numpy.divide(GC.ae, numpy.add(GC.ae,height))
+    uc = numpy.power(rr, degree)
+
+    return(uc)    
+
+def lovenr(lmax: int):
+    """
+    Created on Mon May 11 11:09:28 2022
+
+    Todo:
+        + Add type and input checking functionality
+    
+    _author_: Dr. Bramha Dutt Vishwakarma, Interdisciplinary Center for Water Research (ICWaR), Indian Institute of Science (IISc)
+    """
+    l  = [0,  1,    2,    3,    4,    5,   6,   7,   8,   9,  10,  12,  15,  20,  30,  40,  50,  70, 100, 150, 200]
+    kl = numpy.divide([0,270,-3030,-1940,-1320,-1040,-890,-810,-760,-720,-690,-640,-580,-510,-400,-330,-270,-200,-140,-100, -700],1e4)
+    n = range(0, lmax+1, 1)
+    kn = numpy.interp(n,l,kl)
+    return(kn)
+
+def lovenrPREM(lmax:int, frame):
+    """
+    Created on Mon May 11 11:51:29 2022
+    
+    @author:  Dr. Bramha Dutt Vishwakarma, Interdisciplinary Center for Water Research (ICWaR), Indian Institute of Science (IISc)
+    """
+    
+    data = numpy.array([[ 1,  -0.28476,   0.00000,   0.10462],
+    [2,  -0.99297,  -0.61274,   0.04661] ,
+    [3,  -1.05142,  -0.58897 ,  0.21048] ,
+    [4,  -1.05378,  -0.53513 ,  0.23564] ,
+    [5,  -1.08658,  -0.52382 ,  0.23186] ,
+    [6,  -1.14404,  -0.54222 ,  0.23263] ,
+    [7,  -1.21254,  -0.57464 ,  0.24058] ,
+    [8,  -1.28403,  -0.61256 ,  0.25308] ,
+    [9,  -1.35479,  -0.65203 ,  0.26799] ,
+    [10,  -1.42330,  -0.69140,   0.28419] ,
+    [11,  -1.48909,  -0.72998,   0.30121] ,
+    [12,  -1.55204,  -0.76749,   0.31880] ,
+    [13,  -1.61221,  -0.80381,   0.33684] ,
+    [14,  -1.66968,  -0.83886,   0.35522] ,
+    [15,  -1.72454,  -0.87260,   0.37382] ,
+    [16,  -1.77684,  -0.90499,   0.39251] ,
+    [17,  -1.82668,  -0.93599,   0.41119] ,
+    [18,  -1.87414,  -0.96560,   0.42973] ,    
+    [19,  -1.91928,  -0.99382,   0.44804] ,
+    [20,  -1.96220,  -1.02066,   0.46603] ,
+    [21,  -2.00297,  -1.04614,   0.48363] ,
+    [22,  -2.04169,  -1.07029,   0.50078] ,
+    [23,  -2.07844,  -1.09313,   0.51742] ,
+    [24,  -2.11332,  -1.11472,   0.53355] ,
+    [25,  -2.14642,  -1.13511,   0.54912] ,
+    [30,  -2.28839,  -1.22067,   0.61848] ,
+    [40,  -2.48641,  -1.33024,   0.71925] ,
+    [50,  -2.61710,  -1.39016,   0.78410] ,
+    [60,  -2.71254,  -1.42377,   0.82683] ,
+    [70,  -2.78865,  -1.44313,   0.85550] ,
+    [80,  -2.85368,  -1.45474,   0.87479] ,
+    [90,  -2.91216,  -1.46226,   0.88764] ,
+    [100,  -2.96672,  -1.46787,   0.89598] ,
+    [120,  -3.06983,  -1.47811,   0.90421] ,
+    [140,  -3.16950,  -1.49082,   0.90634] ,
+    [160,  -3.26809,  -1.50771,   0.90603] ,
+    [180,  -3.36633,  -1.52909,   0.90532] ,
+    [200,  -3.48436,  -1.55473,   0.90547] ,
+    [250,  -3.70773,  -1.63448,   0.91388] ,
+    [300,  -3.94607,  -1.73053,   0.93714] ,
+    [350,  -4.17591,  -1.83593,   0.97495] ,
+    [400,  -4.39433,  -1.94515,   1.02467] ,
+    [500,  -4.78872,  -2.15940,   1.14615] ,
+    [600,  -5.12008,  -2.35243,   1.27714] ,
+    [800,  -5.59959,  -2.64798,   1.50995] ,
+    [1000,  -5.88447,  -2.83157,  1.67325] ,
+    [1500,  -6.15106,  -3.00957,   1.84797] ,
+    [2000,  -6.20058,  -3.04408,   1.88423] ,
+    [3000,  -6.21044,  -3.05176,   1.89114] ,
+    [5000,  -6.21155,  -3.05324,   1.89118] ,
+    [10000,  -6.21226,  -3.05427,   1.89110]])
+    
+    l  =  data[:,0]
+    hl =  data[:,1]
+    kl =  numpy.divide(data[:,2], l)
+    ll =  numpy.divide(data[:,3], l)
+    
+    if frame == 'CM':
+        hl[0] = hl[0] - 1
+        ll[0] = ll[0] - 1
+        kl[0] = kl[0] - 1
+        print('Love numbers are in center of mass frame')
+    elif frame == 'CF':
+        hlo = hl[0]
+        llo = ll[0]
+        hl[0] = (hlo - llo) * 2/3
+        ll[0] = (hlo - llo) * (-1/3)
+        kl[0] = ((-2/3)*llo) - ((-1/3)*hlo)
+        print('Love numbers are in center of figure frame')
+    elif frame == 'CE':
+        print('Love numbers are in center of solid Earth frame')
+    else:
+        lovenrPREM.exit('Please choose a compatible frame of reference: one of CM, CF, or CE')
+    
+    
+    n = range(0, lmax+1, 1)
+    kn = numpy.interp(n,l,kl)
+    hn = numpy.interp(n,l,hl)
+    ln = numpy.interp(n,l,ll)
+    kn[0] = 0 
+    hn[0] = 0
+    ln[0] = 0
+    return(kn,hn,ln)
+    

pyshbundle/Phase_calc.py

@@ -0,0 +1,100 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+# Created on Thu Jul 14 09:10:27 2022
+
+# - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 
+# Summary of this function goes here
+# calculates the phase difference between two time series based on the
+# Hilbert transform method explained by Phillip et al.
+
+# Phillips, T., R. S. Nerem, B. Fox-Kemper, J. S. Famiglietti, and B. Rajagopalan (2012),
+# The influence of ENSO on global terrestrial water storage using GRACE, Geophysical
+# Research Letters, 39 (16), L16,705, doi:10.1029/2012GL052495.
+# - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 
+
+# License:
+#    This file is part of PySHbundle.
+#    PySHbundle is free software: you can redistribute it and/or modify
+#    it under the terms of the GNU General Public License as published by
+#    the Free Software Foundation, either version 3 of the License, or
+#    (at your option) any later version.
+
+#    This program 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 program.  If not, see <http://www.gnu.org/licenses/>. 
+# - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 
+
+# Acknowledgement Statement:
+#    Please note that PySHbundle has adapted the following code packages, 
+#    both licensed under GNU General Public License
+#       1. SHbundle: https://www.gis.uni-stuttgart.de/en/research/downloads/shbundle/
+
+#       2. Downscaling GRACE Total Water Storage Change using Partial Least Squares Regression
+#          https://springernature.figshare.com/collections/Downscaling_GRACE_Total_Water_Storage_Change_using_Partial_Least_Squares_Regression/5054564 
+    
+# Key Papers Referred:
+#    1. Vishwakarma, B. D., Horwath, M., Devaraju, B., Groh, A., & Sneeuw, N. (2017). 
+#       A data‐driven approach for repairing the hydrological catchment signal damage 
+#       due to filtering of GRACE products. Water Resources Research, 
+#       53(11), 9824-9844. https://doi.org/10.1002/2017WR021150
+
+#    2. Vishwakarma, B. D., Zhang, J., & Sneeuw, N. (2021). 
+#       Downscaling GRACE total water storage change using 
+#       partial least squares regression. Scientific data, 8(1), 95.
+#       https://doi.org/10.1038/s41597-021-00862-6
+   
+# @author: Amin Shakya, Interdisciplinary Center for Water Research (ICWaR), Indian Institute of Science (IISc)
+# - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 
+
+import scipy as sc
+from scipy import signal as signal
+import numpy as np
+
+def Phase_calc(fts, ffts):
+    """calculates the phase difference between two time series based on the
+    Hilbert transform method explained by Phillip et al.
+
+    Args:
+        fts (np.ndarray): _description_
+        ffts (np.ndarray): _description_
+
+    Returns:
+        _type_: _description_
+    
+    References:
+        1. Phillips, T., R. S. Nerem, B. Fox-Kemper, J. S. Famiglietti, and B. Rajagopalan (2012),
+        The influence of ENSO on global terrestrial water storage using GRACE, Geophysical
+        Research Letters, 39 (16), L16,705, doi:10.1029/2012GL052495.
+    """
+    c = fts.shape[1]
+    
+    ps = np.zeros((1, c))
+    
+    filter_ = ~np.isnan(fts)
+    filter__ = ~np.isnan(ffts)
+    
+    fts_ = fts[filter_] #Extract values and leave Nan
+    ffts_ = ffts[filter__] #Extract values and leave Nan
+    
+    fts = fts_.reshape(int(fts_.shape[0]/c),c)
+    ffts = ffts_.reshape(int(ffts_.shape[0]/c),c)
+    
+    rn = fts.shape[0]
+    
+    for i in range(c):
+        # A = np.concatenate(np.ones((rn,1)), np.real(signal.hilbert(ffts[:, i])), np.imag(signal.hilbert(ffts[:, i]))) #design matrix
+        
+        A = np.array((np.ones((rn)), np.real(signal.hilbert(ffts[:, i])), np.imag(signal.hilbert(ffts[:, i])))).T
+        
+        A = A.astype('double')
+        B = fts[:,i]
+        B = B.astype('double')
+        abc = np.linalg.lstsq(A.T @ A, A.T @ B)[0]
+        
+        ps[0,i] = np.arctan2(abc[3-1],abc[2-1])*(180/np.pi) #check indices and degree/radian
+    return ps