pyVPRM 5.0__tar.gz → 5.2__tar.gz

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

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: pyVPRM
-Version: 5.0
+Version: 5.2
 Summary: Vegetation Photosynthesis and Respiration Model
 Home-page: https://github.com/tglauch/pyVPRM/
 Author: Theo Glauch
@@ -12,6 +12,7 @@ Classifier: Environment :: Console
 Classifier: Intended Audience :: Science/Research
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Topic :: Scientific/Engineering :: Atmospheric Science
+Classifier: Programming Language :: Python :: 3.14
 License-File: LICENSE
 Requires-Dist: numpy
 Requires-Dist: scipy
@@ -37,5 +38,15 @@ Requires-Dist: requests
 Requires-Dist: statsmodels
 Requires-Dist: loguru
 Requires-Dist: fiona
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: home-page
+Dynamic: keywords
+Dynamic: license
+Dynamic: license-file
+Dynamic: requires-dist
+Dynamic: summary
 
 A tool to calculate the CO2 exchange flux between atmosphere and terrestrial biosphere using the Vegetation Photosynthesis and Respiration Model

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

@@ -1,13 +1,41 @@
 [![DOI](https://zenodo.org/badge/626435494.svg)](https://doi.org/10.5281/zenodo.14216613)
+[![PyPI version](https://img.shields.io/pypi/v/pyVPRM.svg)](https://pypi.org/project/pyVPRM/)
+[![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)
 
 
+<figure>
+<img src="https://github.com/tglauch/pyVPRM/assets/29706254/ba2565e6-1434-4a95-8086-936462f8d05d", height=150pt>
+</figure> 
+  
+A description of the model is published in Geoscientific Model Development (GMD) https://gmd.copernicus.org/articles/18/4713/2025/. If you use this package for you scientific work please cite as follows
 
-<img src="https://github.com/tglauch/pyVPRM/assets/29706254/ba2565e6-1434-4a95-8086-936462f8d05d" width=45% height=50%>
+```
+Glauch, T., Marshall, J., Gerbig, C., Botía, S., Gałkowski, M., Vardag, S. N., & Butz, A. (2025). pyVPRM: A next-generation vegetation photosynthesis and respiration model for the post-MODIS era. Geoscientific Model Development, 18(14), 4713–4742. https://doi.org/10.5194/gmd-18-4713-2025
+```
+
+or using BibTeX:
+```
+@Article{gmd-18-4713-2025,
+AUTHOR = {Glauch, T. and Marshall, J. and Gerbig, C. and Bot\'{\i}a, S. and Ga{\l}kowski, M. and Vardag, S. N. and Butz, A.},
+TITLE = {\textit{pyVPRM}: a next-generation vegetation photosynthesis and respiration model for the post-MODIS era},
+JOURNAL = {Geoscientific Model Development},
+VOLUME = {18},
+YEAR = {2025},
+NUMBER = {14},
+PAGES = {4713--4742},
+URL = {https://gmd.copernicus.org/articles/18/4713/2025/},
+DOI = {10.5194/gmd-18-4713-2025}
+}
+```
+
+In case of any questions please write an E-Mail to theo.glauch@dlr.de.
 
 # About
 
 
-`pyVPRM` is a software package to calculate the CO2 exchange flux between atmosphere and terrestrial biosphere using the Vegetation Photosynthesis and Respriation Model (VPRM). It takes into account both, the primary productivity (GPP) as well as the respiration. The net flux between both of them is the net ecosystem exchange (NEE). The implementation is flexible and can be run with different satellite products (Sentinel-2, MODIS, VIIRS,...), land cover products (Copernicus Land Cover Service, ESA 10-m World Cover Map, MapBiomas) and climate models like the ECMWFS ERA5 Reanalysis. Through its modular structure it is also easily extendable. 
+`pyVPRM` is a software package to calculate the CO2 exchange flux between atmosphere and terrestrial biosphere using the Vegetation Photosynthesis and Respriation Model (VPRM). It takes into account both, the primary productivity (GPP) as well as the respiration. The net flux between both of them is the net ecosystem exchange (NEE). The implementation is flexible and can be run with different satellite products (Sentinel-2, MODIS, VIIRS,...), land cover products (Copernicus Land Cover Service, ESA 10-m World Cover Map, MapBiomas) and meteorological drivers like ECMWFS ERA5 Reanalysis. Through its modular structure it is also easily extendable.  
 
 Among others it can be used for 
 
@@ -15,16 +43,14 @@ Among others it can be used for
 2. Making CO2 flux predictions for a given region of interest
 3. Generating input files to run VPRM in the Weather Research and Forecasting Model (WRF)
 
-In case of any questions please write an E-Mail to theo.glauch@dlr.de.
-
 ## Example Net Ecosystem Fluxes generated with pyVPRM
 
 <figure>
-<img src="https://github.com/user-attachments/assets/def61395-f90e-421b-9264-f0608161bd7a", height=300pt>
+<img src="https://github.com/user-attachments/assets/c099ef1f-6c5a-445c-bc6e-f6697c47b641", height=300pt>
 </figure> 
 
 <figure>
-<img src="https://github.com/user-attachments/assets/48c412b2-cf5f-4573-9db8-e60909893218", height=300pt>
+<img src="https://github.com/user-attachments/assets/26913805-f188-477a-9a85-08911a165b1e", height=300pt>
 </figure> 
 
 
@@ -63,7 +89,7 @@ In order to start your own project you need to at least follow theses steps:
 Remarks: 
 - If there is not yet an interface for your satellite data or land cover map, implement a new subclass in `pyVPRM/sat_managers/`
 - For new land cover maps you need to additionaly provide a mapping of the land cover classes to the VPRM classes in a config file which is stored in  `pyVPRM/vprm_configs`
-- Open access to land cover maps: Copernicus: https://lcviewer.vito.be/2019 | ESA World Cover: https://viewer.esa-worldcover.org
+- Open access to land cover maps: Copernicus: https://land.copernicus.eu/en/products/global-dynamic-land-cover/copernicus-global-land-service-land-cover-100m-collection-3-epoch-2019-globe#download | ESA World Cover: https://viewer.esa-worldcover.org
 - Open access to satellite data: MODIS,VIIRS: https://e4ftl01.cr.usgs.gov | Sentinel-2: https://scihub.copernicus.eu/
 
 ## Examples

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

@@ -12,6 +12,7 @@ from pyVPRM.lib.functions import (
     do_lowess_smoothing,
     make_xesmf_grid,
     to_esmf_grid,
+    replace_inf_runs_ignore_nans
 )
 from scipy.ndimage import uniform_filter
 from pyproj import Transformer
@@ -36,13 +37,13 @@ regridder_options = dict()
 regridder_options["conservative"] = "conserve"
 
 
-class vprm:
+class vprm_preprocessor:
     """
     Main class for the  Vegetation Photosynthesis and Respiration Model
     """
 
     def __init__(
-        self, vprm_config_path, land_cover_map=None, verbose=False, n_cpus=1, sites=None
+        self, vprm_config_path, land_cover_map=None, verbose=False, n_cpus=1, flux_tower_instances=None
     ):
         """
         Initialize a class instance
@@ -51,7 +52,7 @@ class vprm:
                 land_cover_map (xarray): A pre calculated map with the land cover types
                 verbose (bool): Set true for additional output when debugging
                 n_cpus: Number of CPUs
-                sites: For fitting. Provide a list of sites.
+                flux_tower_instances: For fitting. Provide a list of flux_tower_instances.
 
         Returns:
                 The lowess smoothed array
@@ -60,55 +61,57 @@ class vprm:
         logger.info("Running with pyVPRM version {}".format(pyVPRM.__version__))
         self.sat_imgs = []
 
-        self.sites = sites
-        if self.sites is not None:
-            self.lonlats = [i.get_lonlat() for i in sites]
+        self.set_flux_tower_inst(flux_tower_instances)
         self.n_cpus = n_cpus
         self.counter = 0
         self.fit_params_dict = None
-        self.res = None
 
         self.new = True
         self.timestamps = []
         self.t2m = None
 
         # self.target_shape = None
-
-        self.sat_img_buffer = dict()
+        
         self.buffer = dict()
         self.buffer["cur_lat"] = None
         self.buffer["cur_lon"] = None
-        self.prototype_lat_lon = None
+        self.empty_xr_lat_lon_grid = None
 
         self.land_cover_type = land_cover_map
         # land_cover_type: tmin, topt, tmax
 
         with open(vprm_config_path, "r") as stream:
             try:
-                cfg = yaml.safe_load(stream)
+                self.vprm_cfg = yaml.safe_load(stream)
             except yaml.YAMLError as exc:
                 logger.info(exc)
 
         self.temp_coefficients = dict()
         self.map_to_vprm_class = dict()
-        for key in cfg:
-            if "tmin" in cfg[key].keys():
-                self.temp_coefficients[cfg[key]["vprm_class"]] = [
-                    cfg[key]["tmin"],
-                    cfg[key]["topt"],
-                    cfg[key]["tmax"],
-                    cfg[key]["tlow"],
+        for key in self.vprm_cfg:
+            if "tmin" in self.vprm_cfg[key].keys():
+                self.temp_coefficients[self.vprm_cfg[key]["vprm_class"]] = [
+                    self.vprm_cfg[key]["tmin"],
+                    self.vprm_cfg[key]["topt"],
+                    self.vprm_cfg[key]["tmax"],
+                    self.vprm_cfg[key]["tlow"],
                 ]
-            for c in cfg[key]["class_numbers"]:
-                self.map_to_vprm_class[c] = cfg[key]["vprm_class"]
+            for c in self.vprm_cfg[key]["class_numbers"]:
+                self.map_to_vprm_class[c] = self.vprm_cfg[key]["vprm_class"]
         return
 
+    def set_flux_tower_inst(self, flux_tower_instances):
+        self.flux_tower_instances = flux_tower_instances
+        if self.flux_tower_instances is not None:
+            self.lonlats = [i.get_lonlat() for i in flux_tower_instances]
+        return
+    
     def to_wrf_output(
         self,
         out_grid,
         weights_for_regridder=None,
         regridder_save_path=None,
-        driver="xEMSF",
+        driver="xESMF",
         interp_method="conservative",
         n_cpus=None,
         mpi=True,
@@ -144,7 +147,7 @@ class vprm:
             logger.info(
                 "Need to generate the weights for the regridder. This can be very slow and memory intensive"
             )
-            if driver == "xEMSF":
+            if driver == "xESMF":
                 regridder = xe.Regridder(src_grid, ds_out, interp_method)
                 if regridder_save_path is not None:
                     regridder.to_netcdf(regridder_save_path)
@@ -182,7 +185,7 @@ class vprm:
                 # os.remove(dest_temp_path)
                 weights_for_regridder = regridder_save_path
             else:
-                logger.info("Driver needs to be xEMSF or ESMF_RegridWeightGen")
+                logger.info("Driver needs to be xESMF or ESMF_RegridWeightGen")
         if weights_for_regridder is not None:
             regridder = xe.Regridder(
                 src_grid,
@@ -277,7 +280,12 @@ class vprm:
             "evi_max": ds_t_max_evi,
             "evi_min": ds_t_min_evi,
         }
-
+        
+        veg_classes_def = 'VPRM class definition: '
+        for k in self.vprm_cfg.keys():
+            veg_classes_def += '{} {}, '.format(self.vprm_cfg[k]['vprm_class'], k)
+        veg_classes_def = veg_classes_def[:-2]
+        
         for key in ret_dict.keys():
             ret_dict[key] = ret_dict[key].assign_attrs(
                 title="VPRM input data for WRF: {}".format(key),
@@ -289,7 +297,7 @@ class vprm:
                 institution2="Deutsches Zentrum für Luft- und Raumfahrt (DLR)",
                 contact="theo.glauch@dlr.de",
                 date_created=str(datetime.now()),
-                comment="Used VPRM classes: 1 Evergreen forest, 2 Deciduous forest, 3 Mixed forest, 4 Shrubland, 5 Trees and grasses, 6 Cropland, 7 Grassland, 8 Barren, Urban and built-up, water, permanent snow and ice",
+                comment=veg_classes_def,
             )
         return ret_dict
 
@@ -302,10 +310,12 @@ class vprm:
         b_swir=None,
         drop_bands=False,
         which_evi=None,
+        add_ndvi=False,
         timestamp_key=None,
         mask_bad_pixels=True,
         mask_clouds=True,
         mask_snow=True,
+        mask_water=True,
     ):
         """
         Add a new satellite image and calculate EVI and LSWI if desired
@@ -375,12 +385,20 @@ class vprm:
             temp_lswi = xr.where((temp_lswi < -1) | (temp_lswi > 1), np.nan, temp_lswi)
             handler.sat_img["evi"] = temp_evi
             handler.sat_img["lswi"] = temp_lswi
+        if add_ndvi:
+            nir = handler.sat_img[b_nir]
+            red = handler.sat_img[b_red]
+            temp_ndvi = (nir-red)/(nir+red)
+            handler.sat_img['ndvi'] = temp_ndvi
+            
         if timestamp_key is not None:
             handler.sat_img = handler.sat_img.rename({timestamp_key: "timestamps"})
 
         bands_to_mask = []
         if which_evi in ["evi", "evi2"]:
             bands_to_mask = ["evi", "lswi"]
+        if add_ndvi:
+            bands_to_mask.append('ndvi')
         else:
             for btm in [b_nir, b_red, b_blue, b_swir]:
                 if btm is not None:
@@ -390,6 +408,11 @@ class vprm:
                 handler.mask_snow()
             else:
                 handler.mask_snow(bands_to_mask)
+        if mask_water:
+            if bands_to_mask == []:
+                handler.mask_water()
+            else:
+                handler.mask_water(bands_to_mask)
         if mask_clouds:
             if bands_to_mask == []:
                 handler.mask_clouds()
@@ -443,6 +466,7 @@ class vprm:
                 x, y = t.transform(ll[0], ll[1])
                 x_ind = np.argmin(np.abs(x - xs))
                 y_ind = np.argmin(np.abs(y - ys))
+                arsz = 3 # Hard Coded. Means only 3 by 3 pixes around the lonlat location are smoothed
                 for key in keys:
                     logger.info(key)
                     self.sat_imgs.sat_img[key][
@@ -464,20 +488,21 @@ class vprm:
             interp_method="nearest",
         )
         self.sat_imgs.sat_img = self.sat_imgs.sat_img.assign_coords(
-            {"site_names": [i.get_site_name() for i in self.sites]}
+            {"site_names": [i.get_site_name() for i in self.flux_tower_instances]}
         )
 
-    def sort_and_merge_by_timestamp(self):
+    def sort_and_merge_by_timestamp(self, min_lenght_snow_period=21): 
         """
         Called after adding the satellite images with 'add_sat_img'. Sorts the satellite
         images by timestamp and merges everything to one satellite_data_manager.
 
             Parameters:
-
+            min_lenght_snow_period defines how long a period should be until gaps are 
+            filled to stabilize lowess fits
             Returns:
                     None
         """
-        if self.sites is None:
+        if self.flux_tower_instances is None:
             x_time_y = 0
             for h in self.sat_imgs:
                 size_dict = dict(h.sat_img.sizes)
@@ -485,15 +510,15 @@ class vprm:
                 if prod > x_time_y:
                     biggest = h
                     x_time_y = prod
-            self.prototype = copy.deepcopy(biggest)
-            keys = list(self.prototype.sat_img.keys())
-            self.prototype.sat_img = self.prototype.sat_img.drop(keys)
+            self.prototype_satellite_manager = copy.deepcopy(biggest)
+            keys = list(self.prototype_satellite_manager.sat_img.keys())
+            self.prototype_satellite_manager.sat_img = self.prototype_satellite_manager.sat_img.drop(keys)
         #  for h in self.sat_imgs:
-        #      h.sat_img = h.sat_img.rio.reproject_match(self.prototype.sat_img, nodata=np.nan)
+        #      h.sat_img = h.sat_img.rio.reproject_match(self.prototype_satellite_manager.sat_img, nodata=np.nan)
         else:
-            self.prototype = copy.deepcopy(self.sat_imgs[0])
-            keys = list(self.prototype.sat_img.keys())
-            self.prototype.sat_img = self.prototype.sat_img.drop(keys)
+            self.prototype_satellite_manager = copy.deepcopy(self.sat_imgs[0])
+            keys = list(self.prototype_satellite_manager.sat_img.keys())
+            self.prototype_satellite_manager.sat_img = self.prototype_satellite_manager.sat_img.drop(keys)
         self.sat_imgs = satellite_data_manager(
             sat_img=xr.concat([k.sat_img for k in self.sat_imgs], "time")
         )
@@ -510,7 +535,7 @@ class vprm:
         )
         day_steps = [i.days for i in (self.timestamps - self.timestamp_start)]
         self.sat_imgs.sat_img = self.sat_imgs.sat_img.assign_coords({"time": day_steps})
-        self.prototype.sat_img = self.prototype.sat_img.assign_coords(
+        self.prototype_satellite_manager.sat_img = self.prototype_satellite_manager.sat_img.assign_coords(
             {"time": day_steps}
         )
 
@@ -531,19 +556,33 @@ class vprm:
                 {"timestamps": (dims, tismp)}
             )
         self.time_key = "time"
+
+        N = int(min_lenght_snow_period / np.diff(self.sat_imgs.sat_img['time']).mean())
         if "evi" in list(self.sat_imgs.sat_img.data_vars):
-            self.sat_imgs.sat_img["evi"] = xr.where(
-                (self.sat_imgs.sat_img["evi"] == np.inf),
-                self.sat_imgs.sat_img["evi"].min(dim=self.time_key),
-                self.sat_imgs.sat_img["evi"],
-            )
+            self.sat_imgs.sat_img["evi"] = replace_inf_runs_ignore_nans(self.sat_imgs.sat_img["evi"],
+                                                                        N = N,
+                                                                        time_dim = self.time_key)
+            # self.sat_imgs.sat_img["evi"] = xr.where(
+            #     (self.sat_imgs.sat_img["evi"] == np.inf),
+            #     self.sat_imgs.sat_img["evi"].min(dim=self.time_key),
+            #     self.sat_imgs.sat_img["evi"],
+            # )
 
         if "lswi" in list(self.sat_imgs.sat_img.data_vars):
-            self.sat_imgs.sat_img["lswi"] = xr.where(
-                (self.sat_imgs.sat_img["lswi"] == np.inf),
-                self.sat_imgs.sat_img["lswi"].min(dim=self.time_key),
-                self.sat_imgs.sat_img["lswi"],
-            )
+            self.sat_imgs.sat_img["lswi"] = replace_inf_runs_ignore_nans(self.sat_imgs.sat_img["lswi"],
+                                                                         N = N,
+                                                                         time_dim = self.time_key)
+            # self.sat_imgs.sat_img["lswi"] = xr.where(
+            #     (self.sat_imgs.sat_img["lswi"] == np.inf),
+            #     self.sat_imgs.sat_img["lswi"].min(dim=self.time_key),
+            #     self.sat_imgs.sat_img["lswi"],
+            # )
+
+        if "ndvi" in list(self.sat_imgs.sat_img.data_vars):
+            self.sat_imgs.sat_img["ndvi"] = replace_inf_runs_ignore_nans(self.sat_imgs.sat_img["ndvi"],
+                                                                         N = N,
+                                                                         time_dim = self.time_key)
+            
         return
 
     def clip_to_box(self, sat_to_crop):
@@ -552,7 +591,7 @@ class vprm:
             bounds[0], bounds[1], bounds[2], bounds[3]
         )
         keys = list(self.sat_imgs.sat_img.keys())
-        self.prototype = satellite_data_manager(
+        self.prototype_satellite_manager = satellite_data_manager(
             sat_img=self.sat_imgs.sat_img.drop(keys)
         )
         return
@@ -708,7 +747,7 @@ class vprm:
                     .to_array()
                     .values[0]
                 )
-                self.land_cover_type = copy.deepcopy(self.prototype)
+                self.land_cover_type = copy.deepcopy(self.prototype_satellite_manager)
                 self.land_cover_type.sat_img = self.land_cover_type.sat_img.assign(
                     {var_name: (["y", "x"], t)}
                 )
@@ -740,11 +779,11 @@ class vprm:
             Returns:
                     None
         """
-        self.max_lswi = copy.deepcopy(self.prototype)
-        self.min_lswi = copy.deepcopy(self.prototype)
-        self.min_max_evi = copy.deepcopy(self.prototype)
+        self.max_lswi = copy.deepcopy(self.prototype_satellite_manager)
+        self.min_lswi = copy.deepcopy(self.prototype_satellite_manager)
+        self.min_max_evi = copy.deepcopy(self.prototype_satellite_manager)
         shortcut = self.sat_imgs.sat_img
-        # if self.sites is None:
+        # if self.flux_tower_instances is None:
         self.min_lswi.sat_img["min_lswi"] = shortcut["lswi"].min(
             self.time_key, skipna=True
         )
@@ -764,7 +803,8 @@ class vprm:
         )
         return
 
-    def lowess(self, keys, lonlats=None, times=False, frac=0.25, it=3, n_cpus=None):
+    def lowess(self, keys, lonlats=None, times=False, frac=0.25, it=3,
+               n_cpus=None, smooth_all=False):
         """
         Performs the lowess smoothing
 
@@ -808,7 +848,7 @@ class vprm:
             xvals = self.sat_imgs.sat_img["time"]
         logger.info("Lowess timestamps {}".format(xvals))
 
-        if self.sites is not None:  # Is flux tower sites are given
+        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(
@@ -924,13 +964,21 @@ class vprm:
         )
         return
 
-    def clip_values(self, key, min_val, max_val):
-        self.sat_imgs.sat_img[key].values[
-            self.sat_imgs.sat_img[key].values < min_val
-        ] = min_val
-        self.sat_imgs.sat_img[key].values[
-            self.sat_imgs.sat_img[key].values > max_val
-        ] = max_val
+    def clip_values(self, key, min_val, max_val, to_nan=False):
+        if to_nan:
+            self.sat_imgs.sat_img[key].values[
+                self.sat_imgs.sat_img[key].values < min_val
+            ] = np.nan
+            self.sat_imgs.sat_img[key].values[
+                self.sat_imgs.sat_img[key].values > max_val
+            ] = np.nan
+        else:
+            self.sat_imgs.sat_img[key].values[
+                self.sat_imgs.sat_img[key].values < min_val
+            ] = min_val
+            self.sat_imgs.sat_img[key].values[
+                self.sat_imgs.sat_img[key].values > max_val
+            ] = max_val
         return
 
     def clip_non_finite(self, data_var, val, sel):
@@ -1024,7 +1072,7 @@ class vprm:
             ).values.flatten()
         else:
             self.buffer[key] = self.sat_imgs.sat_img[key].isel(select_dict)
-        return self.sat_img_buffer[key]
+        return self.buffer[key]
 
     def get_sat_img_values_for_all_keys(self, lon=None, lat=None, counter_range=None):
         """
@@ -1057,9 +1105,11 @@ class vprm:
         days_after_first_image = (
             datetime_utc - self.timestamp_start
         ).total_seconds() / (24 * 60 * 60)
+        # Calculate a list of time differences between the xarray time and the datetime_utc both with respect to timestamp_start. 
+        # Take the index (argmin) with smallest difference 
         counter_new = np.argmin(
             np.abs(self.sat_imgs.sat_img[self.time_key].values - days_after_first_image)
-        )
+        ) 
         if (days_after_first_image < 0) | (
             days_after_first_image > self.sat_imgs.sat_img[self.time_key][-1]
         ):
@@ -1074,21 +1124,21 @@ class vprm:
             self.new = False
             return  # Still same satellite image
 
-    def _set_prototype_lat_lon(self):
-        src_x = self.prototype.sat_img.coords["x"].values
-        src_y = self.prototype.sat_img.coords["y"].values
+    def _set_empty_xr_lat_lon_grid(self):
+        src_x = self.prototype_satellite_manager.sat_img.coords["x"].values
+        src_y = self.prototype_satellite_manager.sat_img.coords["y"].values
         X, Y = np.meshgrid(src_x, src_y)
         t = Transformer.from_crs(
-            self.prototype.sat_img.rio.crs, "+proj=longlat +datum=WGS84"
+            self.prototype_satellite_manager.sat_img.rio.crs, "+proj=longlat +datum=WGS84"
         )
         x_long, y_lat = t.transform(X, Y)
-        self.prototype_lat_lon = xr.Dataset(
+        self.empty_xr_lat_lon_grid = xr.Dataset(
             {
                 "lon": (["y", "x"], x_long, {"units": "degrees_east"}),
                 "lat": (["y", "x"], y_lat, {"units": "degrees_north"}),
             }
         )
-        self.prototype_lat_lon = self.prototype_lat_lon.set_coords(["lon", "lat"])
+        self.empty_xr_lat_lon_grid = self.empty_xr_lat_lon_grid.set_coords(["lon", "lat"])
         return
 
     def save(self, save_path):
@@ -1099,7 +1149,7 @@ class vprm:
         return
 
     def is_disjoint(self, this_sat_img):
-        bounds = self.prototype.sat_img.rio.transform_bounds(
+        bounds = self.prototype_satellite_manager.sat_img.rio.transform_bounds(
             this_sat_img.sat_img.rio.crs
         )
         dj = rasterio.coords.disjoint_bounds(bounds, this_sat_img.sat_img.rio.bounds())
@@ -1112,7 +1162,7 @@ class vprm:
                 [v.sat_imgs for v in vprm_insts], reproject=allow_reproject
             )
             keys = list(self.sat_imgs.sat_img.keys())
-            self.prototype = satellite_data_manager(
+            self.prototype_satellite_manager = satellite_data_manager(
                 sat_img=self.sat_imgs.sat_img.drop(keys)
             )
 

pyvprm-5.2/pyVPRM/__init__.py

@@ -0,0 +1,3 @@
+__version__ = "5.2"
+
+

{pyvprm-5.0 → pyvprm-5.2}/pyVPRM/lib/flux_tower_class.py

@@ -103,7 +103,7 @@ class brazil_flux_data(flux_tower_data):
                 "par_fill",
                 "ust",
             ]
-        if use_vars is "all":
+        if use_vars == "all":
             self.vars = "all"
         site_info_dict = dict()
         site_info_dict["K67"] = dict(lat=-2.857, lon=-54.959, veg_class="EF")
@@ -188,7 +188,7 @@ class ameri_fluxnet(flux_tower_data):
         self.data_path = data_path
 
         super().__init__(t_start, t_stop, ssrd_key, t2m_key, site_name)
-        if (use_vars is None) | (use_vars is "all"):
+        if (use_vars is None) | (use_vars == "all"):
             self.vars = "all"
         else:
             self.vars = use_vars
@@ -205,7 +205,7 @@ class ameri_fluxnet(flux_tower_data):
         return
 
     def add_tower_data(self):
-        if self.vars is "all":
+        if self.vars == "all":
             idata = pd.read_csv(
                 glob.glob(os.path.join(self.data_path, "*.csv"))[0], skiprows=2
             )
@@ -286,7 +286,7 @@ class fluxnet(flux_tower_data):
                 "TA_F_QC",
                 "SW_IN_F_QC",
             ]
-        elif use_vars is "all":
+        elif use_vars == "all":
             self.vars = "all"
         else:
             self.vars = use_vars
@@ -351,6 +351,7 @@ class icos(flux_tower_data):
         use_vars=None,
         t_start=None,
         t_stop=None,
+        icos_2025=True,
     ):
 
         self.data_path = data_path
@@ -380,18 +381,44 @@ class icos(flux_tower_data):
                 "TA_F_QC",
                 "SW_IN_F_QC",
             ]
-        elif use_vars is "all":
+        elif use_vars == "all":
             self.vars = "all"
         else:
             self.vars = use_vars
-
-        site_info = pd.read_csv(
-            os.path.join(
-                os.path.dirname(self.data_path),
-                "ICOSETC_{}_SITEINFO_L2.csv".format(self.site_name),
-            ),
-            on_bad_lines="skip",
-        )
+        if icos_2025:
+            site_info = pd.read_csv(
+                os.path.join(
+                    os.path.dirname(self.data_path).replace('FLUXNET_HH_L2', 'ARCHIVE_L2'),
+                    "ICOSETC_{}_SITEINFO_L2.csv".format(self.site_name),
+                ),
+                on_bad_lines="skip",
+            )
+            self.footprint = pd.read_csv(
+                os.path.join(
+                    os.path.dirname(self.data_path).replace('FLUXNET_HH_L2', 'ARCHIVE_L2'),
+                    "ICOSETC_{}_FLUXES_L2.csv".format(self.site_name),
+                ),
+                on_bad_lines="skip",
+            )
+            if 'FETCH_50' in self.footprint.keys():
+                self.fetch50 = np.percentile(self.footprint['FETCH_50'][self.footprint['FETCH_50']>0], 90)
+            else:
+                self.fetch50 = None
+
+            if 'FETCH_90' in self.footprint.keys():
+                self.fetch90 = np.percentile(self.footprint['FETCH_90'][self.footprint['FETCH_90']>0], 50)
+            else:
+                self.fetch90 = None
+        else:
+            site_info = pd.read_csv(
+                os.path.join(
+                    os.path.dirname(self.data_path),
+                    "ICOSETC_{}_SITEINFO_L2.csv".format(self.site_name),
+                ),
+                on_bad_lines="skip",
+            )
+            self.fetch90 = None # Not yet implemented
+            
         self.land_cover_type = site_info.loc[site_info["VARIABLE"] == "IGBP"][
             "DATAVALUE"
         ].values[0]
@@ -405,7 +432,7 @@ class icos(flux_tower_data):
         return
 
     def add_tower_data(self):
-        if self.vars is "all":
+        if self.vars == "all":
             idata = pd.read_csv(self.data_path, on_bad_lines="skip")
         else:
             idata = pd.read_csv(