pyVPRM 5.2__tar.gz → 5.3__tar.gz

{pyvprm-5.2/pyVPRM.egg-info → pyvprm-5.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyVPRM
-Version: 5.2
+Version: 5.3
 Summary: Vegetation Photosynthesis and Respiration Model
 Home-page: https://github.com/tglauch/pyVPRM/
 Author: Theo Glauch
@@ -38,6 +38,7 @@ Requires-Dist: requests
 Requires-Dist: statsmodels
 Requires-Dist: loguru
 Requires-Dist: fiona
+Requires-Dist: pykalman
 Dynamic: author
 Dynamic: author-email
 Dynamic: classifier

{pyvprm-5.2 → pyvprm-5.3}/README.md

@@ -3,6 +3,7 @@
 [![License](https://img.shields.io/pypi/l/pyVPRM.svg)](https://pypi.org/project/pyVPRM/)
 [![Downloads](https://img.shields.io/pypi/dm/pyVPRM.svg)](https://pypi.org/project/pyVPRM/)
 ![GitHub stars](https://img.shields.io/github/stars/tglauch/pyVPRM?style=social)
+![Python Version](https://img.shields.io/pypi/pyversions/pyVPRM)
 
 
 <figure>

{pyvprm-5.2 → pyvprm-5.3}/pyVPRM/VPRM.py

@@ -10,6 +10,7 @@ from pyVPRM.sat_managers.base_manager import satellite_data_manager
 from pyVPRM.lib.functions import (
     add_corners_to_1d_grid,
     do_lowess_smoothing,
+    do_kalman_smoothing,
     make_xesmf_grid,
     to_esmf_grid,
     replace_inf_runs_ignore_nans
@@ -964,6 +965,155 @@ class vprm_preprocessor:
         )
         return
 
+    def kalman(self, keys, times=None, lonlats=None, n_cpus=None, smooth_all=False):
+        """
+        Performs the lowess smoothing
+
+            Parameters:
+                    lonlats (str): If given the smearing is only performed at the
+                                   given lats and lons
+            Returns:
+                    None
+        """
+        self.sat_imgs.sat_img.load()
+
+        if n_cpus is None:
+            n_cpus = self.n_cpus
+        if isinstance(times, pd.core.indexes.datetimes.DatetimeIndex):
+            times = list(times)
+        if isinstance(times, list):
+            times = np.array(sorted(times))
+            if (times[-1] > self.timestamp_end) | (times[0] < self.timestamp_start):
+                logger.info(
+                    "You have provied some timestamps that are not covered from satellite images.\
+                They will be ignored in the following, to avoid unreliable results"
+                )
+            times = times[
+                (times <= self.timestamp_end) & (times >= self.timestamp_start)
+            ]
+            xvals = [
+                int(
+                    np.round(
+                        (i - self.timestamp_start).total_seconds() / (24 * 60 * 60)
+                    )
+                )
+                for i in times
+            ]
+        elif isinstance(times, str):
+            if times == "daily":
+                xvals = np.arange(self.tot_num_days+1)
+            else:
+                logger.info("{} is not a valid str for times".format(times))
+                return
+        else:
+            xvals = self.sat_imgs.sat_img["time"]
+        logger.info("Lowess timestamps {}".format(xvals))
+
+        if (self.flux_tower_instances is not None) and (smooth_all is False):  # Is flux tower sites are given
+            if "timestamps" in list(self.sat_imgs.sat_img.data_vars):
+                for key in keys:
+                    self.sat_imgs.sat_img = self.sat_imgs.sat_img.assign(
+                        {
+                            key: (
+                                ["time_gap_filled", "site_names"],
+                                np.array(
+                                    [
+                                        do_kalman_smoothing(
+                                            self.sat_imgs.sat_img.sel(site_names=i)[
+                                                key
+                                            ].values,
+                                            timestamps=self.sat_imgs.sat_img.sel(
+                                                site_names=i
+                                            )["timestamps"].values,
+                                        )
+                                        for i in self.sat_imgs.sat_img.site_names.values
+                                    ]
+                                ).T,
+                            )
+                        }
+                    )
+            else:
+                for key in keys:
+                    self.sat_imgs.sat_img = self.sat_imgs.sat_img.assign(
+                        {
+                            key: (
+                                ["time_gap_filled", "site_names"],
+                                np.array(
+                                    [
+                                        do_kalman_smoothing(
+                                            self.sat_imgs.sat_img.sel(site_names=i)[
+                                                key
+                                            ].values,
+                                            timestamps=self.sat_imgs.sat_img[
+                                                "time"
+                                            ].values,
+                                        )
+                                        for i in self.sat_imgs.sat_img.site_names.values
+                                    ]
+                                ).T,
+                            )
+                        }
+                    )
+
+        elif lonlats is None:  # If smoothing the entire array
+            if "timestamps" in list(self.sat_imgs.sat_img.data_vars):
+                for key in keys:
+                    self.sat_imgs.sat_img = self.sat_imgs.sat_img.assign(
+                        {
+                            key: (
+                                ["time_gap_filled", "y", "x"],
+                                np.array(
+                                    Parallel(n_jobs=n_cpus, max_nbytes=None)(
+                                        delayed(do_kalman_smoothing)(
+                                            self.sat_imgs.sat_img[key][:, :, i].values,
+                                            timestamps=self.sat_imgs.sat_img[
+                                                "timestamps"
+                                            ][:, :, i].values,
+                                        )
+                                        for i, x_coord in enumerate(
+                                            self.sat_imgs.sat_img.x.values
+                                        )
+                                    )
+                                ).T,
+                            )
+                        }
+                    )
+            else:
+                for key in keys:
+                    self.sat_imgs.sat_img = self.sat_imgs.sat_img.assign(
+                        {
+                            key: (
+                                ["time_gap_filled", "y", "x"],
+                                np.array(
+                                    Parallel(n_jobs=n_cpus, max_nbytes=None)(
+                                        delayed(do_kalman_smoothing)(
+                                            self.sat_imgs.sat_img[key][:, :, i].values,
+                                            timestamps=self.sat_imgs.sat_img[
+                                                "time"
+                                            ].values,
+                                        )
+                                        for i, x_coord in enumerate(
+                                            self.sat_imgs.sat_img.x.values
+                                        )
+                                    )
+                                ).T,
+                            )
+                        }
+                    )
+
+        else:
+            logger.info("Not implemented")
+            # Originally had a function to smooth only at specific lat/long.
+            # That doesn't make sense anymore, because the time dimension will change through lowess smoothing.
+            # If this is your plan then try to crop the sat image first and then do the lowess filtering.
+
+        self.time_key = "time_gap_filled"
+        self.sat_imgs.sat_img = self.sat_imgs.sat_img.assign_coords(
+            {"time_gap_filled": list(np.arange(self.tot_num_days+1))}
+        )
+        self.sat_imgs.sat_img = self.sat_imgs.sat_img.sel({"time_gap_filled": list(xvals)})
+        return
+
     def clip_values(self, key, min_val, max_val, to_nan=False):
         if to_nan:
             self.sat_imgs.sat_img[key].values[

pyvprm-5.3/pyVPRM/__init__.py

@@ -0,0 +1,4 @@
+__version__ = "5.3"
+
+
+

pyvprm-5.3/pyVPRM/flux_tower_libs/FFP_footprint_class.py

@@ -0,0 +1,108 @@
+import os
+import numpy as np 
+import pandas as pd
+import xarray as xr
+from scipy.special import gamma
+from pyVPRM.flux_tower_libs.base_footprint_class import base_footprint_manager
+
+
+class FFP_footprint_manager(base_footprint_manager):
+    def __init__(self, time_stamps, flux_tower_manager, calculation_grid_side_length, calculation_grid_pixels_per_side, era5_instance = None):
+        super().__init__(time_stamps, flux_tower_manager, calculation_grid_side_length, calculation_grid_pixels_per_side, era5_instance)
+        self.footprint_model = 'FFP'
+
+    def print_parameters(self):
+        print('Parameters of model', self.footprint_model)
+        print('u')
+        print(self.u)
+        print('ZL')
+        print(self.ZL)
+        print('u dir')
+        print(self.u_dir)
+        print('u*')
+        print(self.u_star)
+        print('sigma v')
+        print(self.sigma_v)
+        print('boundary layer h')
+        print(self.h_pbl)
+        print('z')
+        print(self.z)
+        print('t')
+        print(self.time_stamps)
+    
+    def calculate_footprints(self):  
+        k_karman = 0.4
+        #calculate secondary parameters
+        X_star = self.X_calculation_grid_rotated/np.expand_dims(self.z, axis =(1,2)) * np.expand_dims((1-self.z/self.h_pbl)*(self.u/self.u_star*k_karman)**-1, axis=(1,2))
+        p = np.where(self.ZL<=0, 0.8, 0.55)
+        ps1 = np.minimum(1, np.abs(self.ZL)**-1*10**-5+p)
+
+        
+        #calculate crosswind_integrated_flux
+        a = 1.452
+        b = -1.991
+        c = 1.462
+        d = 0.136
+        k_karman = 0.4
+        Fy_star = a*(X_star-d)**b*np.exp(-c/(X_star-d))
+        crosswind_integrated_flux = Fy_star*np.expand_dims((1-self.z/self.h_pbl)*self.u_star/(self.z*self.u*k_karman), axis=(1,2))
+        if not np.all(np.logical_or(np.isnan(crosswind_integrated_flux), crosswind_integrated_flux==0)):
+            crosswind_integrated_flux = np.where(np.isnan(crosswind_integrated_flux), 0, crosswind_integrated_flux)
+        
+        #calculate crosswind_distribution
+        a_c = 2.17
+        b_c = 1.66
+        c_c = 20.0
+        sigma_y_star = a_c*(b_c*(X_star)**2/(1+c_c*X_star))**.5
+        sigma_y = sigma_y_star*np.expand_dims((self.z*self.sigma_v)/(ps1*self.u_star), axis=(1,2))
+        crosswind_distribution = 1/((2*np.pi)**.5*sigma_y) * np.exp(-self.Y_calculation_grid_rotated**2/(2*sigma_y**2))
+        crosswind_distribution = np.where(np.isnan(crosswind_distribution), 0, crosswind_distribution)
+            
+        #calculate footprints
+        footprint = crosswind_distribution*crosswind_integrated_flux
+        integrated_footprint = np.nansum(footprint, axis=(1,2))*self.side_length_pixel**2
+
+        #calculate peak estimator
+        x_peak = 0.87 * self.z * (1-self.z/self.h_pbl)**-1 * (self.u/self.u_star*k_karman)
+
+        #calculate fetch estimator
+        x_70 = (-c/np.log(0.7)+d) * self.z * (1-self.z/self.h_pbl)**-1 * (self.u/self.u_star*k_karman)
+        x_90 = (-c/np.log(0.9)+d) * self.z * (1-self.z/self.h_pbl)**-1 * (self.u/self.u_star*k_karman)
+        
+        #store in xarray
+        self.footprint_on_calculation_grid  =  xr.Dataset(
+            data_vars=dict(
+                footprint = (["t", "y", "x"], footprint),
+                integrated = (["t"], integrated_footprint),
+                x_peak = (["t"], x_peak),
+                x_70 = (["t"], x_70),
+                x_90 = (["t"], x_90),
+                
+            ),
+            coords=dict(
+                t=("t", self.time_stamps), 
+                y=("y", self.ys_for_calculation_grid),
+                x=("x", self.xs_for_calculation_grid), 
+            ),
+        )
+
+
+    def calculate_crosswind_integrated_flux(self):  
+        k_karman = 0.4
+        #calculate secondary parameters
+        X_star = self.xs_for_calculation_grid/np.expand_dims(self.z, axis =(1)) * np.expand_dims((1-self.z/self.h_pbl)*(self.u/self.u_star*k_karman)**-1, axis=(1))
+        p = np.where(self.ZL<=0, 0.8, 0.55)
+        ps1 = np.minimum(1, np.abs(self.ZL)**-1*10**-5+p)
+
+        
+        #calculate crosswind_integrated_flux
+        a = 1.452
+        b = -1.991
+        c = 1.462
+        d = 0.136
+        k_karman = 0.4
+        Fy_star = a*(X_star-d)**b*np.exp(-c/(X_star-d))
+        crosswind_integrated_flux = Fy_star*np.expand_dims((1-self.z/self.h_pbl)*self.u_star/(self.z*self.u*k_karman), axis=(1))
+        if not np.all(np.logical_or(np.isnan(crosswind_integrated_flux), crosswind_integrated_flux==0)):
+            crosswind_integrated_flux = np.where(np.isnan(crosswind_integrated_flux), 0, crosswind_integrated_flux)
+        self.crosswind_integrated_flux = crosswind_integrated_flux

pyvprm-5.3/pyVPRM/flux_tower_libs/KM_footprint_class.py

@@ -0,0 +1,101 @@
+import os
+import numpy as np 
+import pandas as pd
+import xarray as xr
+from scipy.special import gamma
+from pyVPRM.flux_tower_libs.base_footprint_class import base_footprint_manager
+
+class KM_footprint_manager(base_footprint_manager):
+    def __init__(self, time_stamps, flux_tower_manager, calculation_grid_side_length, calculation_grid_pixels_per_side):
+        super().__init__(time_stamps, flux_tower_manager, calculation_grid_side_length, calculation_grid_pixels_per_side)
+        self.footprint_model = 'KM'
+
+    def print_parameters(self):
+        print('Parameters of model', self.footprint_model)
+        print('u')
+        print(self.u)
+        print('L')
+        print(self.ZL)
+        print('u dir')
+        print(self.u_dir)
+        print('u*')
+        print(self.u_star)
+        print('sigma v')
+        print(self.sigma_v)
+        print('t')
+        print(self.time_stamps)
+
+
+    def calculate_footprints(self):
+        #print('calculate KM footprint')
+        k_karman = 0.4
+        #calculate secondary parameters
+        stability_c = np.where(self.ZL > 0, (1+5*self.ZL), (1-16*self.ZL)**(-1/2))       
+        stability_m = np.where(self.ZL > 0, (1+5*self.ZL), (1-16*self.ZL)**(-1/4))
+        n = np.where(self.ZL > 0, 1/(1+5*self.ZL), (1-24*self.ZL)/(1-16*self.ZL))
+        #stability_c = np.where(self.L > 0, (1+5*self.z/self.L), (1-16*self.z/self.L)**(-1/2))       
+        #stability_m = np.where(self.L > 0, (1+5*self.z/self.L), (1-16*self.z/self.L)**(-1/4))
+        #n = np.where(self.L > 0, 1/(1+5*self.z/self.L), (1-24*self.z/self.L)/(1-16*self.z/self.L))
+        kappa = k_karman*self.u_star*self.z/(stability_c*self.z**n)
+        m = self.u_star*stability_m/(k_karman*self.u)
+        r = 2+m-n
+        mu = (1+m)/r
+        #U = self.u/self.z**m
+        U = self.u_star*stability_m/(k_karman*m*self.z**m)
+        xi = U*self.z**r/(r**2*kappa)
+        
+        #calculate crosswind_integrated_flux
+        crosswind_integrated_flux = np.expand_dims(xi**mu/gamma(mu), axis=(1,2)) / self.X_calculation_grid_rotated**np.expand_dims((1+mu), axis=(1,2)) * np.exp(-np.expand_dims(xi, axis=(1,2))/self.X_calculation_grid_rotated) 
+        if not np.all(np.logical_or(np.isnan(crosswind_integrated_flux), crosswind_integrated_flux==0)):
+            crosswind_integrated_flux = np.where(np.isnan(crosswind_integrated_flux), 0, crosswind_integrated_flux)
+            
+        #calculate crosswind_distribution
+        u_bar = np.expand_dims(gamma(mu)/gamma(1/r)*(r**2*kappa/U)**(m/r)*U, axis=(1,2))*self.X_calculation_grid_rotated**np.expand_dims((m/r), axis=(1,2))
+        sigma_y = self.X_calculation_grid_rotated*np.expand_dims(self.sigma_v, axis=(1,2))/u_bar
+        crosswind_distribution = 1/((2*np.pi)**.5*sigma_y) * np.exp(-self.Y_calculation_grid_rotated**2/(2*sigma_y**2))
+        #if not np.all(np.logical_or(np.isnan(crosswind_distribution), crosswind_distribution==0)):
+        crosswind_distribution = np.where(np.isnan(crosswind_distribution), 0, crosswind_distribution)
+            
+        #calculate footprints:
+        footprint = crosswind_distribution*crosswind_integrated_flux
+        integrated_footprint = np.nansum(footprint, axis=(1,2))*self.side_length_pixel**2
+
+        #calculate peak estimator
+        x_peak = xi/(1+mu)
+        
+        #store in xarray
+        self.footprint_on_calculation_grid  =  xr.Dataset(
+            data_vars=dict(
+                footprint = (["t", "y", "x"], footprint),
+                integrated = (["t"], integrated_footprint),
+                x_peak = (["t"], x_peak),
+            ),
+            coords=dict(
+                t=("t", self.time_stamps), 
+                y=("y", self.ys_for_calculation_grid),
+                x=("x", self.xs_for_calculation_grid), 
+            ),
+        )
+        
+    def calculate_crosswind_integrated_flux(self): 
+        k_karman = 0.4
+        #calculate secondary parameters
+        stability_c = np.where(self.ZL > 0, (1+5*self.ZL), (1-16*self.ZL)**(-1/2))       
+        stability_m = np.where(self.ZL > 0, (1+5*self.ZL), (1-16*self.ZL)**(-1/4))
+        n = np.where(self.ZL > 0, 1/(1+5*self.ZL), (1-24*self.ZL)/(1-16*self.ZL))
+        #stability_c = np.where(self.L > 0, (1+5*self.z/self.L), (1-16*self.z/self.L)**(-1/2))       
+        #stability_m = np.where(self.L > 0, (1+5*self.z/self.L), (1-16*self.z/self.L)**(-1/4))
+        #n = np.where(self.L > 0, 1/(1+5*self.z/self.L), (1-24*self.z/self.L)/(1-16*self.z/self.L))
+        kappa = k_karman*self.u_star*self.z/(stability_c*self.z**n)
+        m = self.u_star*stability_m/(k_karman*self.u)
+        r = 2+m-n
+        mu = (1+m)/r
+        #U = self.u/self.z**m
+        U = self.u_star*stability_m/(k_karman*m*self.z**m)
+        xi = U*self.z**r/(r**2*kappa)
+        
+        #calculate crosswind_integrated_flux
+        crosswind_integrated_flux = np.expand_dims(xi**mu/gamma(mu), axis=(1)) / self.xs_for_calculation_grid**np.expand_dims((1+mu), axis=(1)) * np.exp(-np.expand_dims(xi, axis=(1))/self.xs_for_calculation_grid) 
+        if not np.all(np.logical_or(np.isnan(crosswind_integrated_flux), crosswind_integrated_flux==0)):
+            crosswind_integrated_flux = np.where(np.isnan(crosswind_integrated_flux), 0, crosswind_integrated_flux)
+        self.crosswind_integrated_flux = crosswind_integrated_flux