wolfhece 2.1.127__py3-none-any.whl → 2.1.129__py3-none-any.whl

wolfhece/lagrange_multiplier.py

@@ -0,0 +1,205 @@
+import numpy as np
+
+def junction_q_lagrangemult(q:np.ndarray):
+    """ Compute the junction flow rate q_junction
+    from the flow rates q of the branches.
+
+    :param q: np.ndarray, estimated signed flow rates of the branches
+    """
+
+    # Number of incoming branches
+    n = q.size
+    
+    # Compute the flow rate ensuring mass conservation
+    # using the Lagrange multiplier method 
+    #
+    # We minimize the following function:
+    #   sum_{i=1}^{n} 1/2 * (qnew_i - q_i) ** 2 
+    # subject to the constraint:
+    #   sum_{i=1}^{n} qnew_i
+    #
+    # The solution is given by inversing the matrix A
+    # A = [1 1 1 ... 1 0]
+    #     [1 0 0 ... 0 1]
+    #     [0 1 0 ... 0 1]
+    #     [0 0 1 ... 0 1]
+    #     ...
+    #     [0 0 0 ... 1 1]
+    # 
+    # [lambda qnew] = A^(-1) * [0 q1 q2 ... qn]
+
+    # Create the matrix A
+    A = np.zeros((n+1, n+1))
+    A[0, :-1] = 1
+    A[1:, :-1] = np.eye(n)
+    A[1:, -1] = 1
+
+    # Compute the inverse of A
+    A_inv = np.linalg.inv(A)
+
+    # Compute the new flow rates
+    qnew = A_inv @ np.concatenate(([0], q))
+
+    # Return the junction flow rates and the lambda
+    return qnew[:n], qnew[-1]
+
+def junction_wse_head_lagrangemult(q:np.ndarray, 
+                                     a:np.ndarray, 
+                                     h_width_froma, 
+                                     z:np.ndarray, 
+                                     epsilon:float=1e-6,
+                                     energy:bool=False):
+    """ Compute the new area at the junction a_junction
+    from the flow rates q of the branches and the area a.
+
+    We ensure a same water elevation (z+h) at the junction in each branch
+    or a same head if energy is True.
+
+    :param q: np.ndarray, estimated signed flow rates of the branches
+    :param a: np.ndarray, estimated area of the branches
+    :param h_l_froma: function converting area to water height and width
+    :param z: np.ndarray, elevation of the branches
+    :param epsilon: float, tolerance of the method
+    :param energy: bool, if True, ensure the same energy at the junction
+    """
+
+    n = q.size
+
+    # Compute the area ensuring the same water elevation at the junction
+    # using the Lagrange multiplier method
+    #
+    # We minimize the following function:
+    #   sum_{i=1}^{n} 1/2 * (anew_i - a_i) ** 2
+    # subject to the constraint:
+    #   (Z_i + h_i) - (Z_i+1 + h_i+1) = 0
+    # or
+    #   (Z_i + h_i + 1/2 * (q_i / a_i) ^2 / g) - (Z_i+1 + h_i+1 + 1/2 * (q_i+1 / a_i+1) ^2 / g) = 0
+    #
+    # The problem is generally non-linear, we use the Newton-Raphson method to solve it.
+    #
+    # The Jacobian of the system is:
+    #   dH_i / da_i = 1 / width_i
+    #   dH_i / da_i+1 = -1 / width_i+1
+    #   dZ_i / da_i = 0
+    #   dZ_i / da_i+1 = 0
+    # if energy is True:
+    #   d1/2 * (q_i / a_i) ^2 / g) / da_i = -q_i^2 / (a_i^3 * g)
+    #   d1/2 * (q_i+1 / a_i+1) ^2 / g) / da_i+1 = q_i+1^2 / (a_i+1^3 * g)
+    #
+    # The system is solved iteratively using the Newton-Raphson method.
+
+
+    KITERMAX=100
+    GRAVITY = 9.81
+
+    ncompl  = 2*n-1
+
+    # !Mise en correspondance deux par deux des altitudes de surface ou des énérgies
+    kiter = 0
+    error = 1.
+
+    while error > epsilon and kiter<KITERMAX:
+
+        A = np.zeros((ncompl, ncompl))
+        A[:n, :n] = np.eye(n)
+        b = np.zeros(ncompl)
+
+        kiter=kiter+1
+        if kiter>100:
+            print('Max iteration in junction')
+
+        h, width = h_width_froma(a)
+
+        # imposition des contraintes
+        if energy:
+            for i in range(n-1):
+                ipos = n + i
+                jpos = i + 1
+
+                # Termes suppl si égalisation d'énergie
+                v1_carre = (q[i]    / a[i])**2.    / GRAVITY
+                v2_carre = (q[jpos] / a[jpos])**2. / GRAVITY
+
+                A[ipos,i]       =    1./width[i]      - v1_carre / a[i]
+                A[ipos,jpos]    =   -1./width[jpos]   + v2_carre / a[jpos]
+                A[i,ipos]       =   -A[ipos,i]
+                A[jpos,ipos]    =   -A[ipos,jpos]
+
+                b[ipos]         =   (v2_carre/2.0 + z[jpos] + h[jpos]) - (v1_carre/2.0 + z[i] + h[i])
+
+        else:
+            for i in range(n-1):
+                ipos = n + i
+                jpos = i + 1
+
+                # !dérivée de H vis-à-vis de la section --> largeur courante
+                A[ipos,i]       =    1.0/width[i]
+                A[ipos,jpos]    =   -1.0/width[jpos]
+                A[i,ipos]       =   -A[ipos,i]
+                A[jpos,ipos]    =   -A[ipos,jpos]
+
+                # membre de droite --> delta d'altitude de fond
+                b[ipos]         =   (z[jpos]+h[jpos]) - (z[i]+h[i])
+
+        # résolution du système
+        incr = np.linalg.solve(A, b)
+
+        # mise à jour de l'inconnue de section sur base des incréments
+        a = a + incr[:n]
+
+        # mise à jour des propriétés indirectes
+        h, width = h_width_froma(a)
+
+        # calcul de l'erreur résiduelle
+        error = np.sum(np.abs(incr[:n]))
+
+    return a
+
+if __name__ == "__main__":
+    # Test the function
+    q = np.array([-1, 2, 3, -4])
+    q_junction, lambda_ = junction_q_lagrangemult(q)
+    print("q_junction:", q_junction)
+    print("lambda:", lambda_)
+
+    # Test the function
+    q = np.array([-1.1, 2.2, 3.001, -3.99])
+    q_junction, lambda_ = junction_q_lagrangemult(q)
+    print("q_junction:", q_junction)
+    print("lambda:", lambda_)
+
+    def h_width_froma(a:np.ndarray):
+        L = 5.
+        h = a / L
+        dl = np.ones(a.shape) * L
+        return h, dl
+    
+    a = np.array([1, 2, 3, 4])
+    z = np.array([0, 0, 0, 0])
+
+    a_junction = junction_wse_head_lagrangemult(q, a, h_width_froma, z, energy=False)
+    print("a_junction:", a_junction + z)
+
+    a = a_junction
+    a_junction = junction_wse_head_lagrangemult(q, a, h_width_froma, z, energy=True)
+    print("a_junction:", a_junction)
+
+    L = 5.
+    z = np.array([0, -1, .5, -.5])
+    a = (1. - z) * L
+
+    a_junction = junction_wse_head_lagrangemult(q, a, h_width_froma, z, energy=False)
+    h, width = h_width_froma(a_junction)
+    print("wse:", h + z)
+
+    z = np.array([0, -1, .5, -.5])
+    a = (1. - z)*5.
+    a[0] += 0.1
+    a[1] += 0.1
+    a[2] -= 0.1
+    a[3] -= 0.1
+
+    a_junction = junction_wse_head_lagrangemult(q, a, h_width_froma, z, energy=False)
+    h, width = h_width_froma(a_junction)
+    print("wse:", h + z)
+    pass

wolfhece/math_parser/calculator.py

@@ -203,6 +203,7 @@ class Calculator(wx.Frame):
                 while id in ids:
                     id += '_'
 
+                res.set_nullvalue_in_mask()
                 self._mapviewer.add_object('array', newobj=res, id = id)
                 self.command = ''
 

wolfhece/pybridges.py

@@ -1009,11 +1009,11 @@ class Bridges(Element_To_Draw):
 
         return self.active_elt
 
-    def find_inside_poly(self, poly:vector)->list:
+    def find_inside_poly(self, vec:vector)->list:
         """
         Find bridges inside polygon/vector
         """
-        polyls = poly.asshapely_pol()
+        polyls = vec.polygon
         bridges = list(self.myelts.values())
 
         mysel=[]

wolfhece/pypolygons_scen.py

@@ -408,7 +408,7 @@ class Polygons_Analyze(Zones):
         self.polygons_meanxy = {}
         for curvert in self.polygons_zone.myvectors:
             # Centre du polygone
-            centroid = curvert.asshapely_pol().centroid
+            centroid = curvert.centroid
             self.polygons_meanxy[curvert.myname] = (centroid.x, centroid.y)
 
         for vec in self.polygons_zone.myvectors:
@@ -536,7 +536,7 @@ class Polygons_Analyze(Zones):
 
         for curvert in self.polygons_zone.myvectors:
             # Centre du polygone
-            centroid = curvert.asshapely_pol().centroid
+            centroid = curvert.centroid
             self.polygons_curvi[curvert.myname] = poly.project(Point([centroid.x, centroid.y]))
 
     def find_values_inside_parts(self, linked_arrays:Union[dict,list]):

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