wolfhece 2.1.90__py3-none-any.whl → 2.1.93__py3-none-any.whl

wolfhece/pypolygons_scen.py

@@ -392,16 +392,25 @@ class Polygons_Analyze(Zones):
         self.linked:Union[dict,list] = None # type is depending on the type of linked arrays
         self.river_values:dict = None
 
+        # The riverbed axis is the second vector of the first zone
         self.riverbed = self.get_zone(0).myvectors[1]
         self.riverbed.prepare_shapely()
 
         self.polygons_zone:zone
         self.polygons_zone = self.get_zone(-1)
 
+        # The curvilinear distance of the polygons is stored in the 'z' attribute of the vertices
         self.polygons_curvi = {}
         for curvert in self.polygons_zone.myvectors:
             self.polygons_curvi[curvert.myname] = curvert.myvertices[0].z
 
+        # The mean center of the polygons
+        self.polygons_meanxy = {}
+        for curvert in self.polygons_zone.myvectors:
+            # Centre du polygone
+            centroid = curvert.asshapely_pol().centroid
+            self.polygons_meanxy[curvert.myname] = (centroid.x, centroid.y)
+
         for vec in self.polygons_zone.myvectors:
             vec.myprop.used=False # cache les polygones pour ne pas surcharger l'affichage éventuel
 
@@ -495,7 +504,9 @@ class Polygons_Analyze(Zones):
                         locdict = self.river_values[curproj][curpoly][curgroup] = {}
 
                         for cursim, curnparray in curarray.items():
-                            locdict[cursim] = np.array([np.array([ tuple(lst1), np.array(lst2, dtype= np.int32)], dtype=object ) for lst1, lst2 in curnparray], dtype=object)
+                            vals = curnparray[0]
+                            xy   = curnparray[1]
+                            locdict[cursim] = (np.array([np.array([ tuple(lst1), np.array(lst2, dtype= np.int32)], dtype=object ) for lst1, lst2 in vals], dtype=object), np.array(xy))
 
         elif isinstance(tmp_linked, list):
             self.linked = [(curlink[0], Wolfresults_2D if curlink[1] == 'CPU' else wolfres2DGPU) for curlink in tmp_linked]
@@ -508,7 +519,9 @@ class Polygons_Analyze(Zones):
                         locdict = self.river_values[curpoly][curgroup] = {}
 
                         for cursim, curnparray in curarray.items():
-                            locdict[cursim] = np.array([np.array([ tuple(lst1), np.array(lst2, dtype= np.int32)], dtype=object ) for lst1, lst2 in curnparray], dtype=object)
+                            vals = curnparray[0]
+                            xy   = curnparray[1]
+                            locdict[cursim] = (np.array([np.array([ tuple(lst1), np.array(lst2, dtype= np.int32)], dtype=object ) for lst1, lst2 in vals], dtype=object), np.array(xy))
 
 
     def compute_distance(self, poly:LineString | vector):
@@ -523,10 +536,8 @@ class Polygons_Analyze(Zones):
 
         for curvert in self.polygons_zone.myvectors:
             # Centre du polygone
-            centerx = np.sum(np.asarray([cur.x for cur in curvert.myvertices[:4]]))/4.
-            centery = np.sum(np.asarray([cur.y for cur in curvert.myvertices[:4]]))/4.
-
-            self.polygons_curvi[curvert.myname] = poly.project(Point([centerx,centery]))
+            centroid = curvert.asshapely_pol().centroid
+            self.polygons_curvi[curvert.myname] = poly.project(Point([centroid.x, centroid.y]))
 
     def find_values_inside_parts(self, linked_arrays:Union[dict,list]):
         """
@@ -560,11 +571,11 @@ class Polygons_Analyze(Zones):
             if isinstance(linked_arrays, dict):
                 self.river_values={}
                 for curkey, curgroup in linked_arrays.items():
-                    self.river_values[curkey] = curzone.get_all_values_linked_polygon(curgroup, key_idx_names='name')
+                    self.river_values[curkey] = curzone.get_all_values_linked_polygon(curgroup, key_idx_names='name', getxy=True)
 
             elif isinstance(linked_arrays, list):
 
-                self.river_values = curzone.get_all_values_linked_polygon(linked_arrays, key_idx_names='name')
+                self.river_values = curzone.get_all_values_linked_polygon(linked_arrays, key_idx_names='name', getxy=True)
 
     def _get_river_heads(self, which_group= None):
         """Compute Head
@@ -586,7 +597,9 @@ class Polygons_Analyze(Zones):
         return head
 
     def get_river_values(self,
-                         which_value:Union[stored_values_unk,stored_values_pos],
+                         which_value:Union[stored_values_unk,
+                                           stored_values_pos,
+                                           stored_values_coords],
                          which_group=None) -> dict:
         """
         Get values for the river polygons
@@ -619,15 +632,35 @@ class Polygons_Analyze(Zones):
 
                 create=False
                 for curarray in curarrays.values():
-                    if len(curarray)>0:
-                        create=True
+                    # if len(curarray)>0:
+                    #     create=True
+                    if isinstance(curarray, tuple):
+                        # on a également repris les coordonnées
+                        if len(curarray[0])>0:
+                            create=True
+                    else:
+                        if len(curarray)>0:
+                            create=True
 
                 if create:
                     for idarray, curarray in enumerate(curarrays.values()):
-                        if len(curarray)>0:
-                            vallist = [curval[pos1][pos2] for curval in curarray]
-                            curdict[part_names[idarray][0]] = vallist
-
+                        # if len(curarray)>0:
+                        #     vallist = [curval[pos1][pos2] for curval in curarray]
+                        #     curdict[part_names[idarray][0]] = vallist
+
+                        if isinstance(curarray, tuple):
+                            if pos1==-1:
+                                if len(curarray[1])>0:
+                                    vallist = [curval[pos2] for curval in curarray[1]]
+                                    curdict[part_names[idarray][0]] = vallist
+                            else:
+                                if len(curarray[0])>0:
+                                    vallist = [curval[pos1][pos2] for curval in curarray[0]]
+                                    curdict[part_names[idarray][0]] = vallist
+                        else:
+                            if len(curarray)>0:
+                                vallist = [curval[pos1][pos2] for curval in curarray]
+                                curdict[part_names[idarray][0]] = vallist
             return locvalues
 
         if isinstance(self.linked, dict):
@@ -641,6 +674,9 @@ class Polygons_Analyze(Zones):
                 elif which_value in stored_values_pos:
                     values = fillin(1, which_value.value[0], self.river_values[which_group], self.linked[which_group])
                     return values
+                elif which_value in stored_values_coords:
+                    values = fillin(-1, which_value.value[0], self.river_values[which_group], self.linked[which_group])
+                    return values
                 else:
                     return None
             else:
@@ -653,6 +689,8 @@ class Polygons_Analyze(Zones):
                             values[curkey] = fillin(0, which_value.value[0], curgroup, curnames)
                     elif which_value in stored_values_pos:
                         values[curkey] = fillin(1, which_value.value[0], curgroup, curnames)
+                    elif which_value in stored_values_coords:
+                        values[curkey] = fillin(-1, which_value.value[0], curgroup, curnames)
                 return values
         else:
             if which_value in stored_values_unk:
@@ -666,11 +704,15 @@ class Polygons_Analyze(Zones):
             elif which_value in stored_values_pos:
                 values = fillin(1, which_value.value[0], self.river_values, self.linked)
                 return values
+            elif which_value in stored_values_coords:
+                values = fillin(-1, which_value.value[0], self.river_values, self.linked)
             else:
                 return None
 
     def get_river_values_op(self,
-                            which_value:Union[stored_values_unk,stored_values_pos],
+                            which_value:Union[stored_values_unk,
+                                              stored_values_pos,
+                                              stored_values_coords],
                             which_group=None,
                             operator:operators=operators.MEDIAN) -> dict:
         """
@@ -741,10 +783,13 @@ class Polygons_Analyze(Zones):
             return ret
 
     def get_s_values(self,
-                     which_value:Union[stored_values_unk,stored_values_pos]=stored_values_unk.WATERLEVEL,
+                     which_value:Union[stored_values_unk,
+                                       stored_values_pos,
+                                       stored_values_coords]=stored_values_unk.WATERLEVEL,
                      which_group:str=None,
                      which_sim:str=None,
                      operator:operators=operators.MEDIAN):
+
         """ Get the values of the river polygons for a specific simulation
 
         :param which_value: value to get
@@ -763,6 +808,10 @@ class Polygons_Analyze(Zones):
                 val.append(curval[which_sim])
                 s.append(self.polygons_curvi[curkey])
 
+        if len(s) != len(val):
+            logging.error(_('Error in get_s_values'))
+            return [], []
+
         # Tri des valeurs selon l'absisse curviligne
         ret = sorted(zip(s, val))
 
@@ -771,6 +820,97 @@ class Polygons_Analyze(Zones):
 
         return s, val
 
+    def get_s_xy(self):
+        """ Get the centroids of the river polygons """
+
+        s = []
+        x = []
+        y = []
+
+        for curval in self.polygons_curvi.values():
+            s.append(curval)
+
+        for curval in self.polygons_meanxy.values():
+            x.append(curval[0])
+            y.append(curval[1])
+
+        if len(s) != len(x) or len(s) != len(y):
+            logging.error(_('Error in get_s_centroidsxy'))
+            return [], [], []
+
+        # Tri des valeurs selon l'absisse curviligne
+        ret = sorted(zip(s, x, y))
+
+        # Séparation des listes triées
+        s, x, y = zip(*ret)
+
+        return s, x, y
+
+    def get_s_xy4sim(self, which_group:str, which_sim:str, operator:operators=operators.MEDIAN):
+        """ Get the position for a specific simulation """
+
+        s1, x = self.get_s_values(which_value= stored_values_coords.X, which_group= which_group, which_sim= which_sim, operator= operator)
+        s2, y = self.get_s_values(which_value= stored_values_coords.Y, which_group= which_group, which_sim= which_sim, operator= operator)
+
+        assert s1 == s2, _('Error in get_s_xy4sim')
+
+        return s1, x, y
+
+    def save_xy_s_tofile(self, outputfile:str):
+        """ Save the centroids of the river polygons to a file """
+
+        s, x, y = self.get_s_xy()
+
+        with open(outputfile, 'w') as f:
+            f.write('x,y,s\n')
+            for curs, curx, cury in zip(s, x, y):
+                f.write('{0},{1},{2}\n'.format(curx, cury, curs))
+
+    def save_xy_s_tofile_4sim(self, outputfile:str, which_group:str, which_sim:str):
+        """ Save the centroids of the river polygons to a file """
+
+        s, x, y = self.get_s_xy4sim(which_group= which_group, which_sim= which_sim)
+
+        with open(outputfile, 'w') as f:
+            f.write('x,y,s\n')
+            for curs, curx, cury in zip(s, x, y):
+                f.write('{0},{1},{2}\n'.format(curx, cury, curs))
+
+    def export_as(self, outputfile:Path, unks:list[stored_values_unk | stored_values_coords], which_group:str, which_sim:str, operator:operators=operators.MEDIAN):
+        """ Export the values of the river polygons to a file
+
+        :param outputfile: output file (supported formats: csv, xlsx)
+        :param unks: list of values to export
+        :param which_group: group to export
+        :param which_sim: simulation to export
+        :param operator: operator to use for values (coordinates will be exported as MEDIAN)
+        """
+
+        outputfile = Path(outputfile)
+        if not (outputfile.suffix == '.csv' or outputfile.suffix == '.xlsx'):
+            logging.error(_('Unsupported format for export -- Must be csv or xlsx'))
+            return
+
+        import pandas as pd
+
+        s,x,y = self.get_s_xy4sim(which_group, which_sim, operators.MEDIAN)
+
+        vals = {curunk.value[1]:self.get_s_values(which_value= curunk,
+                                                  which_group = which_group,
+                                                  which_sim= which_sim,
+                                                  operator= operator)[1] for curunk in unks}
+
+        cols_names = ['s [m]', 'x centroid [m]', 'y centroid [m]']
+        vals[cols_names[0]] = s
+        vals[cols_names[1]] = x
+        vals[cols_names[2]] = y
+
+        df = pd.DataFrame(vals, columns = [cur for cur in cols_names] + [curunk.value[1] for curunk in unks])
+
+        if outputfile.suffix == '.csv':
+            df.to_csv(outputfile, index=False)
+        elif outputfile.suffix == '.xlsx':
+            df.to_excel(outputfile, index=False)
 
     def plot_unk(self,
                  figax = None,

wolfhece/pyshields.py

@@ -278,7 +278,7 @@ def get_Rouse(d:float, q:float, h:float, K:float, rhom:float=2650., rho:float=RH
       """
       # tau_cr = (q/K)**2 / h**(7/3) * rho  * GRAVITY
       # shear_vel = math.sqrt(tau_cr/rho)
-      shear_vel = q/K / h**(7/6)* math.sqrt(GRAVITY)
+      shear_vel = q/K / h**(7./6.)* math.sqrt(GRAVITY)
       ws = get_settling_vel(d,rhom,rho)
       # von Kármán constant
       k = 0.40
@@ -513,6 +513,39 @@ def shieldsdia_dim(figax=None) -> tuple[plt.Figure,plt.Axes]:
 
       return fig,ax
 
+def get_friction_slope_2D_Manning(q:float, h:float, n:float) -> float:
+      """
+      Compute friction slope j for 2D flow with Manning/Strickler friction law
+
+      :param q : discharge [m3/s]
+      :param h : water depth [m]
+      :param n : Manning friction coefficient [m-1/3.s]
+      """
+
+      denom = h**(4./3.)
+      if denom > 0.:
+            j = (q/h * n)**2.0 / denom
+      else:
+            j = 0.
+
+      return j
+
+def get_shear_velocity_2D_Manning(q:float, h:float, n:float) -> float:
+      """
+      Compute shear velocity u_* for 2D flow with Manning/Strickler friction law
+
+      :param j : friction slope [-]
+      :param h : water depth [m]
+      :param q : discharge [m3/s]
+      :param n : Manning friction coefficient [m-1/3.s]
+      """
+
+      j = get_friction_slope_2D_Manning(q,h,n)
+
+      ushear = (h*j*GRAVITY)**0.5
+
+      return ushear
+
 def get_Shields_2D_Manning(s:float, d:float, q:float, h:float, n:float) -> float:
       """
       Compute Shields dimensionless parameter for 2D flow with Manning/Strickler friction law
@@ -528,11 +561,7 @@ def get_Shields_2D_Manning(s:float, d:float, q:float, h:float, n:float) -> float
       # calcul de terme de pente de frottement
 
       # j = (q/h)**2.0 / K**2. / h**(4./3.)
-      denom = h**(4./3.)
-      if denom > 0.:
-            j = (q/h * n)**2.0 / denom
-      else:
-            j = 0.
+      j = get_friction_slope_2D_Manning(q,h,n)
 
       shields = j*h / (d*(s-1))
 

wolfhece/rem/REMMaker.py

@@ -10,13 +10,13 @@ from osgeo import ogr
 from shapely.geometry import box  # for cropping centerlines to extent of DEM
 import geopandas as gpd
 from geopandas import clip, read_file
-import osmnx  # for querying OpenStreetMaps data to get river centerlines
+import logging
+
 import requests
 from scipy.spatial import KDTree as KDTree  # for finding nearest neighbors/interpolating
 from itertools import combinations
 import time
 from .RasterViz import RasterViz
-import logging
 
 level = logging.INFO
 fmt = '[%(levelname)s] %(asctime)s - %(message)s'
@@ -281,6 +281,14 @@ class REMMaker(object):
 
     def get_river_centerline(self):
         """Find centerline of river(s) within DEM area using OSM Ways"""
+
+        try:
+            import osmnx  # for querying OpenStreetMaps data to get river centerlines
+        except ImportError:
+            logging.error("osmnx not installed. Please install osmnx to use this script.")
+            logging.error("Install with: 'pip install osmnx' but beware of dependencies especially Shapely, which may be forced to an older version.")
+            raise ImportError("osmnx not installed. Please install osmnx to use this script.")
+
         logging.info("Finding river centerline.")
         # get OSM Ways within bbox of DEM (returns geopandas geodataframe)
         osmnx.settings.cache_folder = './.osm_cache'

wolfhece/wolf_array.py

@@ -1484,6 +1484,8 @@ class Ops_Array(wx.Frame):
 
         self.myzones.mapviewer = mapviewer
 
+        self._levels = []
+
         if self.wx_exists:
             self.set_GUI()
 
@@ -1746,12 +1748,20 @@ class Ops_Array(wx.Frame):
 
         self.extract_selection = wx.Button(self.tools, wx.ID_ANY, _("Extract selection"), wx.DefaultPosition,wx.DefaultSize, 0)
 
+        cont_sizer = wx.BoxSizer(wx.HORIZONTAL)
+        self._contour_int = wx.Button(self.tools, wx.ID_ANY, _("Contour"), wx.DefaultPosition, wx.DefaultSize, 0)
+        self._contour_list = wx.Button(self.tools, wx.ID_ANY, _("Contour specific"), wx.DefaultPosition, wx.DefaultSize, 0)
+
+        cont_sizer.Add(self._contour_int, 1, wx.EXPAND)
+        cont_sizer.Add(self._contour_list, 1, wx.EXPAND)
+
         Toolssizer.Add(hbox, 0, wx.EXPAND)
         Toolssizer.Add(self.ApplyTools, 1, wx.EXPAND)
         Toolssizer.Add(self.nullborder, 1, wx.EXPAND)
         Toolssizer.Add(self.filter_zone, 1, wx.EXPAND)
         Toolssizer.Add(self.labelling, 1, wx.EXPAND)
         Toolssizer.Add(self.extract_selection, 1, wx.EXPAND)
+        Toolssizer.Add(cont_sizer, 1, wx.EXPAND)
 
         self.ApplyTools.SetToolTip(_("Apply Nullvalue into memory/object"))
         self.nullborder.SetToolTip(_("Set null value on the border of the array\n\nYou will be asked for the width of the border (in cells)"))
@@ -2130,6 +2140,8 @@ class Ops_Array(wx.Frame):
         self.filter_zone.Bind(wx.EVT_BUTTON, self.OnFilterZone)
         self.labelling.Bind(wx.EVT_BUTTON, self.OnLabelling)
         self.extract_selection.Bind(wx.EVT_BUTTON, self.OnExtractSelection)
+        self._contour_int.Bind(wx.EVT_BUTTON, self.OnContourInt)
+        self._contour_list.Bind(wx.EVT_BUTTON, self.OnContourList)
 
         self.SelectOp.Bind(wx.EVT_BUTTON, self.OnApplyOpSelect)
         self.palapply.Bind(wx.EVT_BUTTON, self.Onupdatepal)
@@ -2586,6 +2598,70 @@ class Ops_Array(wx.Frame):
 
         self.parentarray.extract_selection()
 
+    def OnContourInt(self, event:wx.MouseEvent):
+        """ Create contour - number of contours """
+        
+        with wx.NumberEntryDialog(None, 'Number of contours', 'Number of contours', 'Number of contours', 20, 1, 1000) as dlg:
+            if dlg.ShowModal() == wx.ID_OK:
+                nbcontours = dlg.GetValue()
+
+                logging.info(_('Baking contour'))
+                cont = self.parentarray.contour(levels = nbcontours)
+                logging.info(_('Add contour to viewer'))
+                cont.prep_listogl()
+                mapv = self.get_mapviewer()
+                mapv.add_object('vector', newobj = cont, id = cont.idx)
+                self.get_mapviewer().Paint()
+                logging.info(_('Done !'))
+
+    def OnContourList(self, event:wx.MouseEvent):
+        """ Create contour - list of values """
+
+        with wx.TextEntryDialog(None, 'List of specific values separated by comma or tuple (min;max;step)', 
+                                'List of values', f'{self.parentarray.array.min()}, {self.parentarray.array.max()}') as dlg:
+
+            if dlg.ShowModal() == wx.ID_OK:
+                txt = dlg.GetValue()
+
+                self._levels = []
+                if ',' in txt:
+                    for cur in txt.split(','):
+                        if '(' in cur:
+                            cur = cur.replace('(', '').replace(')', '')
+                            cur = cur.split(';')
+                            if len(cur) == 3:
+                                minval = float(cur[0])
+                                maxval = float(cur[1])
+                                step = float(cur[2])
+                                self._levels.extend(np.arange(minval, maxval, step))
+                elif '(' in txt:
+                    cur = txt.replace('(', '').replace(')', '')
+                    cur = cur.split(';')
+                    if len(cur) == 3:
+                        minval = float(cur[0])
+                        maxval = float(cur[1])
+                        step = float(cur[2])
+                        self._levels.extend(np.arange(minval, maxval, step))
+                else:
+                    try:
+                        self._levels = float(txt)
+                    except:
+                        logging.error('Error in chain text to float')
+                        return
+
+                if isinstance(self._levels, list):
+                    if len(self._levels) == 0:
+                        logging.error('Nothing to do !')
+                        return
+
+                logging.info(_('Baking contour'))
+                cont = self.parentarray.contour(levels = self._levels)
+                logging.info(_('Add contour to viewer'))
+                cont.prep_listogl()
+                self.get_mapviewer().add_object('vector', newobj = cont, id = cont.idx)
+                self.get_mapviewer().Paint()
+                logging.info(_('Done !'))
+
     def OnApplyOpMath(self, event:wx.MouseEvent):
         """ Apply math operator to the array """
 
@@ -8978,6 +9054,28 @@ class WolfArray(Element_To_Draw, header_wolf):
             Array3 = WolfArray(output_raster_path, nullvalue=-9999)
         return Array3
 
+    def contour(self, levels:Union[int, list[float]] = 10) -> Zones:
+        """ Compute contour lines """
+
+        if isinstance(levels, int):
+            levels = np.linspace(self.array.min(), self.array.max(), levels)
+        
+        x, y = self.meshgrid()
+        cs = plt.contour(x, y, self.array, levels=levels)
+
+        zones = Zones(idx = self.idx + '_contour', mapviewer = self.get_mapviewer())
+        for collection, level in zip(cs.collections, cs.levels):
+            zone_level = zone(name=f'Contour {level}')
+            for idx, path in enumerate(collection.get_paths()):
+                vector_level = vector(name=f'Contour {level} - {idx}')
+                for vertices in path.to_polygons(closed_only=False):
+                    for vertex in vertices:
+                        vector_level.add_vertex(wolfvertex(vertex[0], vertex[1]))
+                zone_level.add_vector(vector_level, forceparent=True)
+            zones.add_zone(zone_level, forceparent=True)
+
+        return zones
+
 class WolfArrayMB(WolfArray):
     """
     Matrice multiblocks

wolfhece/wolfresults_2D.py

@@ -35,7 +35,7 @@ from .drawing_obj import Element_To_Draw
 from .PyPalette import wolfpalette
 from .PyTranslate import _
 from .gpuview import GRID_N, Rectangle, VectorField
-from .pyshields import get_d_cr, get_d_cr_susp, izbach_d_cr, get_Shields_2D_Manning
+from .pyshields import get_d_cr, get_d_cr_susp, izbach_d_cr, get_Shields_2D_Manning, get_friction_slope_2D_Manning, get_shear_velocity_2D_Manning
 from .pyviews import WolfViews
 from .mesh2d.wolf2dprev import prev_parameters_simul, blocks_file
 from .GraphNotebook import PlotPanel
@@ -1414,6 +1414,7 @@ class views_2D(Enum):
     TURB_VISC_3D = _('Turbulent viscosity 3D')
     VECTOR_FIELD_Q = _('Discharge vector field')
     VECTOR_FIELD_U = _('Velocity vector field')
+    U_SHEAR = _('Shear velocity [ms-1]')
     SHIELDS_NUMBER = _('Shields number - Manning-Strickler')
     CRITICAL_DIAMETER_SHIELDS = _('Critical grain diameter - Shields')
     CRITICAL_DIAMETER_IZBACH = _('Critical grain diameter - Izbach')
@@ -1726,6 +1727,13 @@ class OneWolfResult:
 
             nullvalue = self.waterdepth.nullvalue
 
+        elif which==views_2D.U_SHEAR:
+            self.U_Shear = self.get_u_shear()
+            self._current = self.U_Shear
+            self._view = WolfViews()
+
+            nullvalue = self.waterdepth.nullvalue
+
         elif which==views_2D.SHIELDS_NUMBER:
             if self.ShieldsNumber is None or self._force_update_shields:
                 self.ShieldsNumber = self.get_shieldsnumber()
@@ -1891,6 +1899,33 @@ class OneWolfResult:
         logging.info(_('End of computing critical diameters'))
 
         return diamcrit
+    
+    def get_u_shear(self) -> WolfArray:
+        """
+        Calcul de la vitesse de cisaillement
+        """
+
+        def compute() -> WolfArray:
+
+            ij = np.argwhere(self.waterdepth.array>0.)
+
+            u_shear = WolfArray(mold=self.waterdepth)
+            qnorm = (self.qx**2.+self.qy**2.)**.5
+            qnorm.array.mask=self.waterdepth.array.mask
+
+            _u_shear = np.asarray([get_shear_velocity_2D_Manning(qnorm.array[i,j],
+                                                     self.waterdepth.array[i,j],
+                                                     self.rough_n.array.data[i,j]) for i,j in ij])
+
+            u_shear.array[ij[:,0],ij[:,1]] = _u_shear
+
+            return u_shear
+
+        logging.info(_('Computing shear velocity'))
+        u_shear = compute()
+        logging.info(_('End of computing shear velocity'))
+
+        return u_shear
 
     def get_shieldsnumber(self) -> WolfArray:
         """

{wolfhece-2.1.90.dist-info → wolfhece-2.1.93.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: wolfhece
-Version: 2.1.90
+Version: 2.1.93
 Author-email: Pierre Archambeau <pierre.archambeau@uliege.be>
 License: Copyright (c) 2024 University of Liege. All rights reserved.
 Project-URL: Homepage, https://uee.uliege.be/hece
@@ -51,7 +51,6 @@ Requires-Dist: pygltflib
 Requires-Dist: ezdxf
 Requires-Dist: pyvista
 Requires-Dist: tqdm==4.64.*
-Requires-Dist: osmnx
 Requires-Dist: tifffile
 Requires-Dist: numba==0.58.*
 Requires-Dist: xmltodict

{wolfhece-2.1.90.dist-info → wolfhece-2.1.93.dist-info}/RECORD

@@ -7,11 +7,11 @@ wolfhece/ManageParams.py,sha256=EeuUI5Vvh9ixCvYf8YShMC1s1Yacc7OxOCN7q81gqiQ,517
 wolfhece/Model1D.py,sha256=SI4oNF_J3MdjiWZoizS8kuRXLMVyymX9dYfYJNVCQVI,476989
 wolfhece/PyConfig.py,sha256=UNtl5UzZ399JqjJT67-4DWaIkv76sc1FiEsSDJpXlL0,10458
 wolfhece/PyCrosssections.py,sha256=FnmM9DWY_SAF2EDH9Gu2PojXNtSTRF4-aYQuAAJXBh4,112771
-wolfhece/PyDraw.py,sha256=CvnaK7NgeB25hlzlF-BxU38LT7-3ffuPnana6Mm9PDE,427447
+wolfhece/PyDraw.py,sha256=KkqxUazcXhenwBVCE69EHd_lt0g9fiX6R4p3IBS2pnI,442172
 wolfhece/PyGui.py,sha256=HY0beOMSp1JEyq8-vfVynzVrmKxvaO_sJSMwlNqCNrg,105289
 wolfhece/PyGuiHydrology.py,sha256=f60E8K9eGTnRq5RDF6yvt-ahf2AYegwQ9t25zZ2Mk1A,14946
 wolfhece/PyHydrographs.py,sha256=jwtSNMMACwarxrtN1UeQYth99UNrhwPx1IGgUwcooHA,3774
-wolfhece/PyPalette.py,sha256=QCzXBnYlv7YfHjpJWyO_8F-uOLOe7O_RbkyrnMYzgM4,28146
+wolfhece/PyPalette.py,sha256=81n1P-olOe4wElTLv-miSDhqvJU_RHcxgfpHt794dSw,31436
 wolfhece/PyParams.py,sha256=6fREK5cUCGw84SDyPvuSzidnX-9BXOX3fve5XBG1K_I,98114
 wolfhece/PyPictures.py,sha256=m1kY0saW6Y9Q0bDCo47lW6XxDkBrbQG-Fd8uVn8G5ic,2514
 wolfhece/PyTranslate.py,sha256=4appkmNeHHZLFmUtaA_k5_5QL-5ymxnbVN4R2OblmtE,622
@@ -38,23 +38,23 @@ wolfhece/ismember.py,sha256=fkLvaH9fhx-p0QrlEzqa6ySO-ios3ysjAgXVXzLgSpY,2482
 wolfhece/multiprojects.py,sha256=Sd6Bl6YP33jlR79A6rvSLu23vq8sqbFYL8lWuVPkEpE,21549
 wolfhece/picc.py,sha256=ueujnw03BQz-nPxKGzfDzZbtruTzvnqd6Gm8lOvBYzw,8802
 wolfhece/pyGui1D.py,sha256=9g7OS3YiKsqy--6y0cBD7x2gaqTTYFXWkxImpgnTA20,121937
-wolfhece/pybridges.py,sha256=xbZPuX40c4EKqws4OKNbUVUBPKIzLTbSdYVyrNf_kIE,57418
+wolfhece/pybridges.py,sha256=EU_r6yRYDf5zKmwwXEBsGYvTKFbSfE3iTxPwusKR-1I,57398
 wolfhece/pydike.py,sha256=hPBQsmSTW4QAp1wcOzb-TL3L7eet2WT1sJx2q-WNQ-Q,2241
 wolfhece/pylogging.py,sha256=4TI8hgBB65z-zpvU5Rfa2jkPXPhJaqXjHVPwbcdzTNc,4528
-wolfhece/pypolygons_scen.py,sha256=C0qxVUsBHWZVkurZV-DI1GMN1J1B-ul93n2fs16UjoI,39718
-wolfhece/pyshields.py,sha256=7k-qe2EJgr9fJE62jyPmlWQwRj8T0DK4iuMU844ZhYs,23281
+wolfhece/pypolygons_scen.py,sha256=vMfAKXKrW6vKR7l9Fl2hEt-jihLwIiMur7qNTNfwRg4,46101
+wolfhece/pyshields.py,sha256=6YncgmcA6QvbyIl4jbFRf24uJVjhiSplQKWtZH42lXI,24108
 wolfhece/pyviews.py,sha256=5Hqqo9MRw1eiomYkmc7QywNu1KmEkytLJG-wH_aG38Y,13748
 wolfhece/pywalous.py,sha256=yRaWJjKckXef1d9D5devP0yFHC9uc6kRV4G5x9PNq9k,18972
 wolfhece/rain_SPWMI.py,sha256=qCfcmF7LajloOaCwnTrrSMzyME03YyilmRUOqrPrv3U,13846
 wolfhece/textpillow.py,sha256=map7HsGYML_o5NHRdFg2s_TVQed_lDnpYNDv27MM0Vw,14130
 wolfhece/tools_mpl.py,sha256=gQ3Jg1iuZiecmMqa5Eli2ZLSkttu68VXL8YmMDBaEYU,564
-wolfhece/wolf_array.py,sha256=L6OV70nFSmzfO_beNbPRQ_VoklC_cx6fyhoslI3AMXg,401812
+wolfhece/wolf_array.py,sha256=HasKFOCiFzM55YSXPvpWJ7O4tOoxyTm_LHytE2ZQq8o,406444
 wolfhece/wolf_hist.py,sha256=7jeVrgSkM3ErJO6SRMH_PGzfLjIdw8vTy87kesldggk,3582
 wolfhece/wolf_texture.py,sha256=DS5eobLxrq9ljyebYfpMSQPn8shkUAZZVfqrOKN_QUU,16951
 wolfhece/wolf_tiles.py,sha256=2Ho2I20rHRY81KXxjgLOYISdF4OkJ2d6omeY4shDoGI,10386
 wolfhece/wolf_vrt.py,sha256=89XoDhCJMHiwPQUuOduxtTRKuIa8RDxgNqX65S4xp9M,10569
 wolfhece/wolf_zi_db.py,sha256=baE0niMCzybWGSvPJc5FNxo9ZxsGfU4p-FmfiavFHAs,12967
-wolfhece/wolfresults_2D.py,sha256=5RAvOfO0ua-5hMEdtXKZWznh4NN_q-PLfZdANm7W33M,168478
+wolfhece/wolfresults_2D.py,sha256=p0v3FT6CAzf6aP4AEEXNkuHG01c2Eqbio_a8ghJIt7k,169709
 wolfhece/xyz_file.py,sha256=Se4nCPwYAYLSA5i0zsbnZUKoAMAD0mK1FJea5WSZUkk,5755
 wolfhece/acceptability/Parallels.py,sha256=h4tu3SpC_hR5Hqa68aruxhtAyhs8u666YuZ40_fR5zg,3979
 wolfhece/acceptability/__init__.py,sha256=hfgoPKLDpX7drN1Vpvux-_5Lfyc_7feT2C2zQr5v-Os,258
@@ -75,7 +75,7 @@ wolfhece/apps/curvedigitizer.py,sha256=Yps4bcayzbsz0AoVc_dkSk35dEhhn_esIBy1Ziefg
 wolfhece/apps/hydrometry.py,sha256=lhhJsFeb4zGL4bNQTs0co85OQ_6ssL1Oy0OUJCzhfYE,656
 wolfhece/apps/isocurrent.py,sha256=dagmGR8ja9QQ1gwz_8fU-N052hIw-W0mWGVkzLu6C7I,4247
 wolfhece/apps/splashscreen.py,sha256=SrustmIQeXnsiD-92OzjdGhBi-S7c_j-cSvuX4T6rtg,2929
-wolfhece/apps/version.py,sha256=0ewKEdaYlj_bYhGOPsIk1mktB1LQK_EnKtWL-Vk3Dl8,388
+wolfhece/apps/version.py,sha256=uhn_xV3CTGZbQdI3Z2ZnOh4S6W8nowYt7Tj4x2XrHlo,388
 wolfhece/apps/wolf.py,sha256=j_CgvsL8rwixbVvVD5Z0s7m7cHZ86gmFLojKGuetMls,729
 wolfhece/apps/wolf2D.py,sha256=4z_OPQ3IgaLtjexjMKX9ppvqEYyjFLt1hcfFABy3-jU,703
 wolfhece/apps/wolf_logo.bmp,sha256=ruJ4MA51CpGO_AYUp_dB4SWKHelvhOvd7Q8NrVOjDJk,3126
@@ -254,7 +254,7 @@ wolfhece/pythonfortran/example_numpy_memory.py,sha256=o3hzJDw7YtE4v0FXI3-l2VzupC
 wolfhece/pythonfortran/tools.py,sha256=oYh9MguRYEGNGKVbHqQW2V9okZJLs3n4Qs-vLWPmBe4,2462
 wolfhece/radar/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 wolfhece/radar/wolfradar.py,sha256=mvsVf6-4KCqVF6kWsKfPuM7KPqRdYHuIZAbb8kzXAZU,10032
-wolfhece/rem/REMMaker.py,sha256=k1kOb_69kNw00HRPbTc_E2XTypiyV0mADDbW5etkBAs,31079
+wolfhece/rem/REMMaker.py,sha256=zkiAo36MmusPhgv1qJmpDgtoTWbh_eJ6qJqtCfeC1M8,31480
 wolfhece/rem/RasterViz.py,sha256=fnyMfAJZDoS-rjagsNRGLndS-UYNUzMY4DgenjD3Y_4,29068
 wolfhece/rem/__init__.py,sha256=S2-J5uEGK_VaMFjRUYFIdSScJjZyuXH4RmMmnG3OG7I,19
 wolfhece/report/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -285,8 +285,8 @@ wolfhece/ui/wolf_multiselection_collapsiblepane.py,sha256=8PlMYrb_8jI8h9F0_EagpM
 wolfhece/ui/wolf_times_selection_comparison_models.py,sha256=ORy7fz4dcp691qKzaOZHrRLZ0uXNhL-LIHxmpDGL6BI,5007
 wolfhece/wintab/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 wolfhece/wintab/wintab.py,sha256=8A-JNONV6ujgsgG3lM5Uw-pVgglPATwKs86oBzzljoc,7179
-wolfhece-2.1.90.dist-info/METADATA,sha256=Nf-U-idNQhjOSifNKkIGDY8shuwNX8TV1B3AyAZcXlA,2570
-wolfhece-2.1.90.dist-info/WHEEL,sha256=UvcQYKBHoFqaQd6LKyqHw9fxEolWLQnlzP0h_LgJAfI,91
-wolfhece-2.1.90.dist-info/entry_points.txt,sha256=ZZ-aSfbpdcmo-wo84lRFzBN7LaSnD1XRGSaAKVX-Gpc,522
-wolfhece-2.1.90.dist-info/top_level.txt,sha256=EfqZXMVCn7eILUzx9xsEu2oBbSo9liWPFWjIHik0iCI,9
-wolfhece-2.1.90.dist-info/RECORD,,
+wolfhece-2.1.93.dist-info/METADATA,sha256=Rws7W6QN1NdDV2S30eXAeX-vTVauNTaWIzCTfEzkOpk,2548
+wolfhece-2.1.93.dist-info/WHEEL,sha256=GV9aMThwP_4oNCtvEC2ec3qUYutgWeAzklro_0m4WJQ,91
+wolfhece-2.1.93.dist-info/entry_points.txt,sha256=ZZ-aSfbpdcmo-wo84lRFzBN7LaSnD1XRGSaAKVX-Gpc,522
+wolfhece-2.1.93.dist-info/top_level.txt,sha256=EfqZXMVCn7eILUzx9xsEu2oBbSo9liWPFWjIHik0iCI,9
+wolfhece-2.1.93.dist-info/RECORD,,