wolfhece 2.1.128__py3-none-any.whl → 2.2.1__py3-none-any.whl

wolfhece/hydrology/read.py

@@ -14,6 +14,7 @@ import logging
 from datetime import datetime as date
 from datetime import timezone
 from struct import unpack, calcsize, unpack_from
+from pathlib import Path
 
 
 # Constants
@@ -102,8 +103,8 @@ def read_bin_old(path, fileName, nbBytes=[], uniform_format=-1, hydro=False) ->
     nbL = int.from_bytes(num, byteorder='little', signed=True)
     num = f.read(4)
     nbC = int.from_bytes(num, byteorder='little', signed=True)
-    print("nb lines = ", nbL)
-    print("nb col = ", nbC)
+    # print("nb lines = ", nbL)
+    # print("nb col = ", nbC)
 
     if nbBytes==[]:
         if uniform_format == -1:
@@ -201,6 +202,10 @@ def read_binary_file(path, fileName, format="", buffer_size=-1, init_offset=8):
 
 def is_relative_path(path:str):
 
+    if path is None:
+        logging.error("The path is None")
+        return False
+
     isRelativePath = False
 
     if len(path)>0:
@@ -240,7 +245,7 @@ def relative_2_absolute(fileName:str, prefix:str="", applyCWD:bool=True)-> tuple
 def read_hydro_file(path:str, fileName:str, nbCol:int=6, nbCol_data:int=1) -> tuple[np.array, np.array]:
     format_bin = "<bbhbbbd"
     header_offset = 8
-    
+
     data = read_binary_file(path, fileName, format=format_bin, init_offset=header_offset)
     data = np.array(data).astype("double")
     time, value = parse_hydro_data(data)
@@ -272,7 +277,7 @@ def write_excel_from_dict(data:dict[str:dict[str:np.array]], path:str, fileName:
         # if the dictionary is empty, skip the station -> no creation of the sheet
         if values == {}:
             continue
-        
+
         excl_dict = {}
         if time is not None:
             excl_dict["Time [s]"] = time
@@ -283,7 +288,7 @@ def write_excel_from_dict(data:dict[str:dict[str:np.array]], path:str, fileName:
         curSheet.to_excel(writer, sheet_name=station, index=False)
         curSheet = writer.sheets[station]
         curSheet.autofit()
-    
+
     # if the summary is empty, skip the summary -> no creation of the sheet
     if summary != {}:
         curSheet = pd.DataFrame(summary)
@@ -292,7 +297,7 @@ def write_excel_from_dict(data:dict[str:dict[str:np.array]], path:str, fileName:
         curSheet.autofit()
 
     writer.close()
-    
+
     return
 
 def check_path(fileName:str, prefix:str="", applyCWD:bool=True) -> tuple[bool, str] :
@@ -302,6 +307,11 @@ def check_path(fileName:str, prefix:str="", applyCWD:bool=True) -> tuple[bool, s
         info = -2
         return info
 
+    if fileName is None:
+        logging.error("The file name is None")
+        info = -3
+        return info, fileName
+
     isPresent = os.path.exists(finalName)
 
     if(not(isPresent)):

wolfhece/lagrangian/particle_system_ui.py

@@ -397,7 +397,7 @@ class Particle_system_to_draw(Element_To_Draw):
             self._ps.nbx, self._ps.nby = value.array.shape
             self._ps.dx, self._ps.dy = value.dx, value.dy
         else:
-            assert value.dtype == np.bool8, 'Domain must be boolean'
+            assert value.dtype == np.bool, 'Domain must be boolean'
             self._ps.domain = value
             self._ps.nbx, self._ps.nby = value.shape
 

wolfhece/lagrangian/particles.py

@@ -38,7 +38,7 @@ class Particles():
 
         self.start_position = [x0, y0]
         self.end_position   = [x0.copy(), y0.copy()] # copy to define new memory storage
-        self._is_alive      = np.ones_like(x0, dtype=np.bool8)
+        self._is_alive      = np.ones_like(x0, dtype=np.bool)
 
     def copy_prop_from(self, other:'Particles') -> None:
         """

wolfhece/radar/wolfradar.py

@@ -19,7 +19,16 @@ from datetime import timezone
 from os import path
 from osgeo import gdal, osr
 from ..drawing_obj import Element_To_Draw
+from tqdm import tqdm
 
+RADQPE = 1
+RADCLIM = 2
+RADFLOOD = 3
+
+FILL_NONE = 0
+FILL_ZERO = 1
+FILL_NAN = 2
+FILL_INTERP = 3
 
 class L08L72:
     epsgL08:osr.SpatialReference
@@ -51,12 +60,13 @@ class RadarIRM(Element_To_Draw):
 
 
     def convert2rain(self, coordMin:tuple, coordMax:tuple, dateBegin:date, dateEnd:date, deltaT:tdelta, 
-                     dirIn:str="", dirOut:str="", 
-                     check_all_polygons:bool=False):
+                     dirIn:str="", dirOut:str="", file_name_conv:str=".radclim.accum", type_rain:int=RADCLIM, recursive_dir="",
+                     check_all_polygons:bool=False, fill_data:int=FILL_NONE):
         
-        from datetime import datetime as date
         # =================
         # ALL VERIFICATIONS :
+        logging.info("Starting the conversion of IRM data to rain data ...")
+        logging.info("Verification ongoing ...")
 
         # Checking the validity of the repository to read and write :
         isOk, dirIn = check_path(dirIn, applyCWD=True)
@@ -74,12 +84,21 @@ class RadarIRM(Element_To_Draw):
         dt = deltaT.total_seconds()
         nb_intervals = floor((dateEnd - dateBegin).total_seconds() / dt)
         time = [dateBegin + tdelta(seconds=dt*i) for i in range(nb_intervals + 1)]
-        # Prefix for dates
-        dt_str = "{:.0f}d".format(deltaT.days)*(deltaT.days>0) \
-                + "{:.0f}h".format(floor(deltaT.seconds)/3600)*(floor(deltaT.seconds/3600)>0) \
-                + "{:.0f}m".format(floor(deltaT.seconds%3600)/60)*(floor(deltaT.seconds%3600)/60>0)
-        suffix = "".join([".radclim.accum", dt_str, ".hdf"])
-        all_files = [os.path.join(dirIn,"".join([t.strftime("%Y%m%d%H%M%S"),suffix])) for t in time]
+        if recursive_dir == "":
+            # Prefix for dates -> only if it's not a recursive directory
+            dt_str = "{:.0f}d".format(deltaT.days)*(deltaT.days>0) \
+                    + "{:.0f}h".format(floor(deltaT.seconds)/3600)*(floor(deltaT.seconds/3600)>0) \
+                    + "{:.0f}m".format(floor(deltaT.seconds%3600)/60)*(floor(deltaT.seconds%3600)/60>0)
+            suffix = "".join([file_name_conv, dt_str, ".hdf"])
+            all_files = [os.path.join(dirIn,"".join([t.strftime("%Y%m%d%H%M%S"),suffix])) for t in time]
+        else:
+            suffix = "".join([file_name_conv, ".hdf"])
+            all_files = [os.path.join(dirIn, 
+                                      t.strftime("%Y"),
+                                      t.strftime("%m"),
+                                      t.strftime("%d"),
+                                      recursive_dir,
+                                      "".join([t.strftime("%Y%m%d%H%M%S"),suffix])) for t in time]
         # are_present = np.all(np.array( \
         #             [os.path.exists(os.path.join(dirIn,"".join([t.strftime("%Y%m%d%H%M%S"),suffix]))) for t in time] \
         #             ))
@@ -90,7 +109,14 @@ class RadarIRM(Element_To_Draw):
         
         if not are_present:
             logging.error("Rain files present in the selected directory are does not contain all the information between the desired interval.")
-            return 
+            i_problem = np.where(np.array([os.path.exists(el) for el in all_files]) == False)[0]
+            logging.error("The following files are missing :")
+            for i in i_problem:
+                logging.error(all_files[i])
+            if fill_data == FILL_NONE:
+                logging.error("The process stops because there are missing files!")
+                logging.error("To make an linear interpolation set to False 'no_missing_files' argument.")
+                return
         
         # Creating the direcory results
         # Directory of the shapefile
@@ -118,12 +144,15 @@ class RadarIRM(Element_To_Draw):
             else:
                 print ("Successfully created the directory %s" % timeSeriesDir)
 
+        logging.info("Verification validated!")
 
         # =================
         # CORE PROCEDURE
         # After all verifications, the core procedure can now start :
         # extract all the points in all the .hdf files and their values -> check whether to crop during this process of after
 
+        logging.info("Creation of the shapefile ongoing ...")
+
         # Definition of the domaine zone
         limits = vector()
         limits.add_vertex(wolfvertex(coordMin[0],coordMin[1]))
@@ -173,27 +202,52 @@ class RadarIRM(Element_To_Draw):
 
         # save the polygons in .shp shapefile
         polygons.export_shape(fileOut)
+        logging.info("Creation of the shapefile finished !")
 
-
+        logging.info("Creation of polygon time series ongoing ...")
         # Create a folder with the time serie for each polygone
         timeStps = [[str(t.day), str(t.month), str(t.year), str(t.hour), str(t.minute), str(t.second)] for t in time]
 
         all_values = np.zeros((len(all_files), polygons.nbvectors))
-        for i in range(len(all_files)):
+        for i in tqdm(range(len(all_files))):
             cur_file = all_files[i]
+            exists = os.path.exists(cur_file)
             try:
-                hdf_ds = gdal.Open(cur_file, gdal.GA_ReadOnly)
-                values, coord, proj = wrl.georef.raster.extract_raster_dataset(hdf_ds, mode="edge", nodata=0.0)
-                vec_values = values.reshape(-1)
-                all_values[i,:] = np.nan_to_num([vec_values[i] for i in zones_indices], copy=False, nan=0.0)
-                # FIXME this following line -> to check !!!! -> Convert [mm/h] to accumulated rain [mm] at each time step
-                all_values[i,:] = all_values[i,:]*(dt/3600.0)
+                if exists:
+                    hdf_ds = gdal.Open(cur_file, gdal.GA_ReadOnly)
+                    values, coord, proj = wrl.georef.raster.extract_raster_dataset(hdf_ds, mode="edge", nodata=0.0)
+                    vec_values = values.reshape(-1)
+                    all_values[i,:] = np.nan_to_num([vec_values[i] for i in zones_indices], copy=False, nan=0.0)
+                    # FIXME this following line -> to check !!!! -> Convert [mm/h] to accumulated rain [mm] at each time step
+                    # radflood
+                    if type_rain == RADFLOOD or type_rain == RADCLIM:
+                        all_values[i,:] = all_values[i,:]
+                    elif type_rain == RADQPE:
+                        # radqpe
+                        # TODO : check the conversion for radclim
+                        all_values[i,:] = all_values[i,:]*(dt/3600.0)
+                    # all_values[i,:] = all_values[i,:]*(dt/3600.0)
+                else:
+                    if fill_data == FILL_ZERO:
+                        all_values[i,:] = 0.0
+                    else:
+                        all_values[i,:] = np.nan
             except:
                 logging.error("".join(["Something bad happened while reading hdf file :", cur_file]))
                 all_values[i,:] = 0.0
-            
+        logging.info("Creation of polygon time series finished !")
+
+        logging.info("Writing polygon time series ongoing ...")
         # Writing the file
-        for iVec in range(polygons.nbvectors):            
+        for iVec in tqdm(range(polygons.nbvectors)):
+            # Clean the nan value with linear interpolation
+            # FIXME : to check the interpolation
+            if(fill_data == FILL_INTERP):
+                logging.warning('Interpolating missing values in the time series -> Still to test!')
+                valid = ~np.isnan(all_values[:,iVec])
+                invalid = np.isnan(all_values[:,iVec])
+                all_values[invalid,iVec] = np.interp(np.flatnonzero(invalid), np.flatnonzero(valid), all_values[valid,iVec])
+            # write in the file
             with open(os.path.join(timeSeriesDir,"".join([str(iVec+1),".rain"])), 'w') as f:
                 f.write("".join([str(iVec+1),"\n"]))
                 f.write("".join([str(1),"\n"]))
@@ -201,11 +255,10 @@ class RadarIRM(Element_To_Draw):
                 f.write("".join([str(len(all_files)),"\n"]))
                 for cur_t in range(len(timeStps)):
                     f.write("\t".join(timeStps[cur_t] + [str(all_values[cur_t,iVec])]) + "\n")
-
+        logging.info("Writing polygon time series finished !")
                 
         print(are_present)
 
-
     # def plot(self):
     #     pass
 

wolfhece/shapes/circle.py

@@ -0,0 +1,335 @@
+import math
+import numpy as np
+from numba import jit
+
+""" JIT is a decorator that tells Numba to compile this function using the Numba JIT compiler. """
+
+@jit(nopython=True)
+def A_from_h(h:float, diameter:float):
+    """ Compute the area of a circular segment from its height """
+    d = diameter / 2.0 - h
+    theta = math.acos(1.0 - 2.0 * h / diameter)
+    chord = math.sqrt(h * (diameter - h))
+    area = theta * diameter**2 / 4.0 - chord * d
+
+    return area
+
+@jit(nopython=True)
+def dichotomy_A2h(f, a:float, b:float, args, tol=1e-10, max_iter=1000):
+    """ Dichotomy algorithm to find the root of a function f between a and b.
+    The function f must be defined as f(x, *args) and must return a scalar.
+    The function must have a single root in the interval [a, b].
+    """
+    def cond_fun(val):
+        a, b, i = val
+        return (b - a) > tol
+
+    def body_fun(val):
+        a, b, i = val
+        c = (a + b) / 2.
+        diameter = args[0]
+        fa = f(a, diameter)
+        fc = f(c, diameter)
+        if fc == 0:
+            return (c, c, i + 1)
+        else:
+            if fa * fc < 0:
+                return (a, c, i + 1)
+            else:
+                return (c, b, i + 1)
+
+    i=0
+    while cond_fun((a, b, i)) and i < max_iter:
+        a, b, i = body_fun((a, b, 0))
+
+    return (a + b) / 2
+
+@jit(nopython=True)
+def segment_of_circle(diameter:float, h:float=None, chord:float=None,
+                      arc_length:float=None, area:float=None,
+                      from_which:int=None, init_val:bool=None,
+                      eps:float=1e-8) -> tuple:
+    """ Calcul des caractristiques d'un segment circulaire
+    plus d'infos sur http://mathworld.wolfram.com/CircularSegment.html.
+
+    :param diameter: diamtre du cercle [m]
+    :param h: hauteur du segment [m]
+    :param chord: longueur de la corde [m]
+    :param arc_length: longueur de l'arc soutenu par la corde [m]
+    :param area: aire du sgment [m]
+    :param from_which: variable de calcul sur base de laquelle les autres grandeurs doivent tre values [index dans l'ordre des paramètres (h = 1, area = 4...)]
+    :param init_val: utilise h comme valeur initiale pour le calcul de h depuis A [booléen]
+    """
+
+    R = diameter / 2.0
+
+    if from_which == 1: # from h
+        # The solution is unique
+
+        d = diameter / 2.0 - h
+        theta = math.acos(1.0 - 2.0 * h / diameter)
+
+        arc_length = theta * diameter
+        chord = math.sqrt(h * (diameter - h))
+        area = theta * diameter**2 / 4.0 - chord * d
+        chord = 2.0 * chord
+
+    elif from_which == 2: # from chord
+        # The solution is not unique --> two possible values for h
+        # Conserve the value of h that is the closest to the previous value of h
+
+        # h1 as root of the quadratic equation
+        h1 = (diameter - math.sqrt(diameter**2 - chord**2)) / 2.0
+
+        if init_val is not None:
+            if init_val:
+                h2 = diameter - h1
+                dh1 = abs(h - h1)
+                dh2 = abs(h + h1 - diameter)
+
+                h = h1 if dh1 < dh2 else h2
+            else:
+                # Conserve the lowest value of h
+                h = h1
+        else:
+            h = h1
+
+        d = diameter / 2.0 - h
+        theta = math.acos(1.0 - 2.0 * h / diameter)
+
+        arc_length = theta * diameter
+        area = theta * diameter**2 / 4.0 - chord /2. * d
+
+    elif from_which == 3: # from arc_length
+        # The solution is unique
+
+        theta = arc_length / diameter
+        h = R * (1.0 - math.cos(theta))
+        d = R - h
+
+        chord = math.sqrt(h * (diameter - h))
+        area = theta * diameter**2 / 4.0 - chord * d
+        chord = 2.0 * chord
+
+    elif from_which in [4,41]: # from area using Newton's method
+        # The solution is unique BUT the calculation is iterative
+
+        cur_error = 1.0
+
+        d2by4 = diameter**2 / 4.0
+        area_max = math.pi * d2by4
+
+        if area == 0.0:
+            h = 0.0
+            chord = 0.0
+            arc_length = 0.0
+
+        elif area_max > area:
+            if init_val is not None:
+                if not init_val or h == 0.0:
+                    h = R
+            else:
+                h = R
+
+            while abs(cur_error) > eps:
+                d = R - h
+                theta = math.acos(1.0 - h / R)
+                chord = math.sqrt(h * (diameter - h))
+                area_loc = theta * d2by4 - chord * d
+                dAdh = chord - ((h - R)**2 - d2by4) / (chord + 1e-200)
+
+                cur_error = (area_loc - area) / dAdh
+                if h - cur_error < 0.0:
+                    h = h / 2.0
+                elif h - cur_error > diameter:
+                    h = (h + diameter) / 2.0
+                else:
+                    h = h - cur_error
+
+            chord = 2.0 * chord
+            arc_length = theta * diameter
+
+        else:
+            h = diameter
+            chord = 0.0
+            arc_length = math.pi * diameter
+
+    elif from_which == 42: # from area but using dichotomy rather than Newton-Raphson
+        # The solution is unique BUT the calculation is iterative
+
+        cur_error = 1.0
+
+        d2by4 = diameter**2 / 4.0
+        area_max = math.pi * d2by4
+
+        if area == 0.0:
+            h = 0.0
+            chord = 0.0
+            arc_length = 0.0
+
+        elif area_max > area:
+            if init_val is not None:
+                if not init_val or h == 0.0:
+                    h = R
+            else:
+                h = R
+
+            h = dichotomy_A2h(f=A_from_h, a=0., b=diameter, args=(diameter,), tol=eps)
+
+            d = diameter / 2.0 - h
+            theta = math.acos(1.0 - 2.0 * h / diameter)
+            arc_length = theta * diameter
+            chord = math.sqrt(h * (diameter - h))
+            chord = 2.0 * chord
+
+        else:
+            h = diameter
+            chord = 0.0
+            arc_length = math.pi * diameter
+
+    return diameter, h, chord, arc_length, area
+
+
+if __name__ == '__main__':
+
+    diameter = 10.0
+    h = 5.0
+    chord = -1.
+    arc_length = -1.
+    area = -1.
+    from_which = 1
+    init_val = None
+
+    res1 = segment_of_circle(diameter, h, chord, arc_length, area, from_which, init_val)
+    diameter, h, chord, arc_length, area = res1
+
+    print(f"diameter = {diameter}")
+    print(f"h = {h}")
+    print(f"chord = {chord}")
+    print(f"arc_length = {arc_length}")
+    print(f"area = {area}")
+
+    from_which = 2
+    res2 = segment_of_circle(diameter, h, chord, arc_length, area, from_which, init_val)
+    diameter, h, chord, arc_length, area = res2
+
+    print(f"diameter = {diameter}")
+    print(f"h = {h}")
+    print(f"chord = {chord}")
+    print(f"arc_length = {arc_length}")
+    print(f"area = {area}")
+
+    from_which = 2
+    res2 = segment_of_circle(diameter, h, chord/2., arc_length, area, from_which, False)
+    diameter, h, chord, arc_length, area = res2
+
+    print(f"diameter = {diameter}")
+    print(f"h = {h}")
+    print(f"chord = {chord}")
+    print(f"arc_length = {arc_length}")
+    print(f"area = {area}")
+
+    from_which = 3
+    res3 = segment_of_circle(diameter, h, chord, arc_length, area, from_which, init_val)
+    diameter, h, chord, arc_length, area = res3
+
+    print(f"diameter = {diameter}")
+    print(f"h = {h}")
+    print(f"chord = {chord}")
+    print(f"arc_length = {arc_length}")
+    print(f"area = {area}")
+
+    from_which = 2
+    res2 = segment_of_circle(diameter, h, chord/2., arc_length, area, from_which, init_val)
+    diameter, h, chord, arc_length, area = res2
+
+    print(f"diameter = {diameter}")
+    print(f"h = {h}")
+    print(f"chord = {chord}")
+    print(f"arc_length = {arc_length}")
+    print(f"area = {area}")
+
+    diameter = 10.0
+    h = 1.
+    chord = -1.
+    arc_length = -1.
+    area = 10.0
+    from_which = 4
+    init_val = True
+
+    res4 = segment_of_circle(diameter, h, chord, arc_length, area, from_which, init_val)
+    diameter, h, chord, arc_length, area = res4
+
+    print(f"diameter = {diameter}")
+    print(f"h = {h}")
+    print(f"chord = {chord}")
+    print(f"arc_length = {arc_length}")
+    print(f"area = {area}")
+
+    diameter = 10.0
+    h = -1.
+    chord = -1.
+    arc_length = -1.
+    area = 10.0
+    from_which = 4
+    init_val = False
+
+    res5 = segment_of_circle(diameter, h, chord, arc_length, area, from_which, init_val)
+    diameter, h, chord, arc_length, area = res5
+
+    print(f"diameter = {diameter}")
+    print(f"h = {h}")
+    print(f"chord = {chord}")
+    print(f"arc_length = {arc_length}")
+    print(f"area = {area}")
+
+    diameter = 10.0
+    h = 9.
+    chord = -1.
+    arc_length = -1.
+    area = 10.0
+    from_which = 4
+    init_val = True
+
+    res6 = segment_of_circle(diameter, h, chord, arc_length, area, from_which, init_val)
+    diameter, h, chord, arc_length, area = res6
+
+    print(f"diameter = {diameter}")
+    print(f"h = {h}")
+    print(f"chord = {chord}")
+    print(f"arc_length = {arc_length}")
+    print(f"area = {area}")
+
+    diameter = 10.0
+    h = 2.
+    chord = -1.
+    arc_length = -1.
+    area = 10.0
+    from_which = 4 # from area using Newton's method
+    init_val = True
+
+    res7 = segment_of_circle(diameter, h, chord, arc_length, area, from_which, init_val, eps= 1e-12)
+    diameter, h, chord, arc_length, area = res7
+
+    print(f"diameter = {diameter}")
+    print(f"h = {h}")
+    print(f"chord = {chord}")
+    print(f"arc_length = {arc_length}")
+    print(f"area = {area}")
+
+    diameter = 10.0
+    h = 2.
+    chord = -1.
+    arc_length = -1.
+    area = 10.0
+    from_which = 42 # from area using dichotomy
+    init_val = True
+
+    res8 = segment_of_circle(diameter, h, chord, arc_length, area, from_which, init_val, eps= 1e-12)
+    diameter, h, chord, arc_length, area = res7
+
+    print(f"diameter = {diameter}")
+    print(f"h = {h}")
+    print(f"chord = {chord}")
+    print(f"arc_length = {arc_length}")
+    print(f"area = {area}")