wolfhece 2.2.29__py3-none-any.whl → 2.2.30__py3-none-any.whl

wolfhece/PyCrosssections.py

@@ -1759,8 +1759,9 @@ class crosssections(Element_To_Draw):
                 f=open(myfile,'r')
                 lines=f.read().splitlines()
                 f.close()
-            else:
-                lines=[]
+        # For other formats (e.g.  vecz)
+        else:
+            lines=[]
 
         self.myprofiles={}
         self.mygenprofiles={}
@@ -1880,36 +1881,6 @@ class crosssections(Element_To_Draw):
                             logging.debug(name)
 
                     nameprev=name
-            elif format=='vecz' or format=='zones':
-
-                if isinstance(myfile, Zones):
-                    self.filename=myfile.filename
-                    tmpzones=myfile
-                elif isinstance(myfile, str):
-                    self.filename=myfile
-                    tmpzones=Zones(myfile, find_minmax=False)
-
-                curzone:zone
-                curvec:vector
-                curzone=tmpzones.myzones[0]
-                index=0
-                for curvec in curzone.myvectors:
-
-                    self.myprofiles[curvec.myname]={}
-                    curdict=self.myprofiles[curvec.myname]
-
-                    curdict['index']=index
-                    curdict['left']=None
-                    curdict['bed']=None
-                    curdict['right']=None
-
-                    index+=1
-                    curdict['cs']=profile(name=curvec.myname,parent=self)
-                    cursect:profile
-                    cursect=curdict['cs']
-
-                    cursect.myvertices = curvec.myvertices
-
             elif format=='sxy':
                 self.format='sxy'
                 nbpotsect = int(lines[0])
@@ -1982,6 +1953,38 @@ class crosssections(Element_To_Draw):
                         cursect.bankright=wolfvertex(rbs,rbz)
                         curdict['right']=cursect.bankright
 
+        # To make a distinction between cases for vecz
+        elif len(lines)==0:
+            if format=='vecz' or format=='zones':
+
+                if isinstance(myfile, Zones):
+                    self.filename=myfile.filename
+                    tmpzones=myfile
+                elif isinstance(myfile, str):
+                    self.filename=myfile
+                    tmpzones=Zones(myfile, find_minmax=False)
+
+                curzone:zone
+                curvec:vector
+                curzone=tmpzones.myzones[0]
+                index=0
+                for curvec in curzone.myvectors:
+
+                    self.myprofiles[curvec.myname]={}
+                    curdict=self.myprofiles[curvec.myname]
+
+                    curdict['index']=index
+                    curdict['left']=None
+                    curdict['bed']=None
+                    curdict['right']=None
+
+                    index+=1
+                    curdict['cs']=profile(name=curvec.myname,parent=self)
+                    cursect:profile
+                    cursect=curdict['cs']
+
+                    cursect.myvertices = curvec.myvertices
+
         self.verif_bed()
         self.find_minmax(True)
         self.init_cloud()
@@ -2506,7 +2509,7 @@ class crosssections(Element_To_Draw):
             self.xmax = 0
             self.ymax = 0
             return
-
+        
         if update:
             for idx,vect in self.myprofiles.items():
                 vect['cs'].find_minmax(only_firstlast = True)

wolfhece/PyDraw.py

@@ -4208,6 +4208,15 @@ class WolfMapViewer(wx.Frame):
         else:
             return config[ConfigurationKeys.ACTIVE_VECTOR_COLOR]
 
+    @property
+    def active_vector_square_size(self) -> list[int]:
+        """ Return the active vector square size from configs """
+        config = self.get_configuration()
+        if config is None:
+            return 0
+        else:
+            return config[ConfigurationKeys.ACTIVE_VECTOR_SIZE_SQUARE]
+
     @property
     def default_dem(self) -> Path:
         """ Return the default DEM file from configs """
@@ -15081,8 +15090,10 @@ class WolfMapViewer(wx.Frame):
                     old = self.active_vector.myprop.color
                     self.active_vector.myprop.color = getIfromRGB(self.active_vector_color)
                     self.active_vector.plot()
-                    self.active_vector._plot_square_at_vertices()
+                    self.active_vector._plot_square_at_vertices(size = self.active_vector_square_size)
                     self.active_vector.myprop.color = old
+                else:
+                    self.active_vector._plot_square_at_vertices(size = self.active_vector_square_size)
 
                 if self.active_vector.myprop.plot_indices:
                     self.active_vector._plot_all_indices(sx = self.sx, sy=self.sy,
@@ -15328,6 +15339,7 @@ class WolfMapViewer(wx.Frame):
                 self.Active_zone(vect.parentzone)
 
         self.mimicme()
+        self.Paint()
 
     def Active_zone(self, zone: zone):
         """ Active une zone et son parent si existant """

wolfhece/PyVertexvectors.py

@@ -2594,6 +2594,13 @@ class vector:
         """
         Retrouve le segment associé aux paramètres passés
         """
+
+        if self.length2D is None or self.length3D is None:
+            self.update_lengths()
+        else:
+            if len(self._lengthparts2D) != self.nbvertices-1 or len(self._lengthparts3D) != self.nbvertices-1:
+                self.update_lengths()
+
         if is3D:
             length = self.length3D
             lengthparts = self._lengthparts3D
@@ -2601,15 +2608,6 @@ class vector:
             length = self.length2D
             lengthparts = self._lengthparts2D
 
-        if length is None:
-            self.update_lengths()
-            if is3D:
-                length = self.length3D
-                lengthparts = self._lengthparts3D
-            else:
-                length = self.length2D
-                lengthparts = self._lengthparts2D
-
         cums = np.cumsum(lengthparts)
 
         if adim:
@@ -2628,7 +2626,7 @@ class vector:
 
         if frombegin:
             k=0
-            while s>cums[k]:
+            while s>cums[k] and k < self.nbvertices-2:
                 k+=1
         else:
             k=self.nbvertices-2
@@ -4868,19 +4866,23 @@ class zone:
         veccenter = self.myvectors[0]
         veccenter.update_lengths()
 
+        logging.info(_('Length of the center vector: {}').format(veccenter.length2D))
+
         # Returned zone
         myparallels = zone()
 
         if interval_parallel is None :
+            logging.warning(_('Interval between parallels is not defined --> set to farthest_parallel'))
             interval_parallel : farthest_parallel
 
         if interval_parallel > farthest_parallel:
-            logging.warning(_('dspar is greater than dpar --> dspar is set to dpar'))
+            logging.warning(_('Interval between parallels is greater than farthest_parallel --> set to farthest_parallel'))
             interval_parallel = farthest_parallel
 
         # All parallel distances
         all_par = np.arange(0, farthest_parallel, interval_parallel)[1:]
         all_par = np.concatenate((all_par,[farthest_parallel]))
+        logging.info(_('All parallel distances: {}').format(all_par))
 
         for curpar in tqdm(all_par):
             # add current parallel to the dicts
@@ -4895,22 +4897,28 @@ class zone:
                 #
                 # gestion de vecteurs d'intersection
                 for curint in intersect.myvectors:
+                    if not curint.used:
+                        continue
+
                     # bouclage sur les vecteurs
-                    curint2 = curint.parallel_offset(eps_offset, side='right')
+                    curint1 = curint.parallel_offset(-eps_offset/2., side='left')
+                    curint2 = curint.parallel_offset( eps_offset/2., side='right')
 
                     # recherche si une intersection existe
-                    pt, dist = vecleft[curpar].intersection(curint, eval_dist=True, force_single=True)
+                    pt, dist = vecleft[curpar].intersection(curint1, eval_dist=True, force_single=True)
                     if pt is not None:
+                        logging.debug(_('Intersection found on left parallel at distance {}').format(dist))
                         #Une intersection existe --> on ajoute la portion de vecteur
 
                         # Projection du point d'intersection sur le vecteur à suivre
-                        curls = curint.asshapely_ls()
-                        dist2 = curls.project(pt)
+                        dist2 = curint1.linestring.project(pt)
+
                         # recherche de la portion de vecteur
                         # subs = extrêmité -> intersection
                         # subs_inv = intersection -> extrêmité
-                        subs  = curint.substring(0. , dist2, is3D=False, adim=False)
+                        subs  = curint1.substring(0. , dist2, is3D=False, adim=False)
                         subs.reverse()
+
                         subs2 = curint2.substring(0., dist2, is3D=False, adim=False)
 
                         vec1 = vecleft[curpar].substring(0., dist, is3D=False, adim=False)
@@ -4925,13 +4933,19 @@ class zone:
                         # mise à jour des caractéristiques
                         vecleft[curpar].find_minmax()
                         vecleft[curpar].update_lengths()
+                        vecleft[curpar].reset_linestring()
+                        curint1.reset_linestring()
+                        curint2.reset_linestring()
 
-                    pt, dist = vecright[curpar].intersection(curint, eval_dist=True, force_single=True)
+                    pt, dist = vecright[curpar].intersection(curint1, eval_dist=True, force_single=True)
                     if pt is not None:
-                        curls = curint.asshapely_ls()
-                        dist2 = curls.project(pt)
+                        logging.debug(_('Intersection found on right parallel at distance {}').format(dist))
+
+                        dist2 = curint1.linestring.project(pt)
+
                         #Une intersection existe --> on ajoute la portion de vecteur
-                        subs = curint.substring(0., dist2, is3D=False, adim=False)
+                        subs  = curint1.substring(0., dist2, is3D=False, adim=False)
+
                         subs2 = curint2.substring(0., dist2, is3D=False, adim=False)
                         subs2.reverse()
 
@@ -4940,8 +4954,11 @@ class zone:
 
                         vecright[curpar].myvertices = vec1.myvertices.copy() + subs2.myvertices.copy() + subs.myvertices.copy() + vec2.myvertices.copy()
 
-                        vecright[curpar].update_lengths()
                         vecright[curpar].find_minmax()
+                        vecright[curpar].update_lengths()
+                        vecright[curpar].reset_linestring()
+                        curint1.reset_linestring()
+                        curint2.reset_linestring()
 
         #Shapely LineString
         lsl:dict[str,LineString] = {key:vec.asshapely_ls() for key,vec in vecleft.items()}
@@ -4960,7 +4977,7 @@ class zone:
         ptsc  = [veccenter.interpolate(curs, is3D=False, adim=False) for curs in sloc]
         ptsc2 = [veccenter.interpolate(curs, is3D=False, adim=False) for curs in sloc2]
 
-        sc = [lsc.project(Point(curs.x, curs.y)) for curs in ptsc]
+        sc  = [lsc.project(Point(curs.x, curs.y)) for curs in ptsc]
         sc2 = [lsc.project(Point(curs.x, curs.y)) for curs in ptsc2]
 
         #Real distances along left, right and center vector
@@ -5001,9 +5018,9 @@ class zone:
 
         if howmanypoly==1:
             #un seul polygone sur base des // gauche et droite
-            zonepoly = zone(name='polygons_'+self.myname,parent=self.parent)
+            zonepoly = zone(name='polygons_'+self.myname, parent=self.parent)
 
-            self.parent.add_zone(zonepoly)
+            self.parent.add_zone(zonepoly, forceparent=True)
 
             for i in range(nb):
                 ptc1 = sc[i]
@@ -5037,16 +5054,16 @@ class zone:
                 #force to close the polygon
                 curvec.close_force()
                 #add vector to zone
-                zonepoly.add_vector(curvec)
+                zonepoly.add_vector(curvec, forceparent=True)
 
             #force to update minmax in the zone --> mandatory to plot
             zonepoly.find_minmax(True)
         else:
             #deux polygones sur base des // gauche et droite
-            zonepolyleft = zone(name='polygons_left_'+self.myname,parent=self.parent)
-            zonepolyright = zone(name='polygons_right_'+self.myname,parent=self.parent)
-            self.parent.add_zone(zonepolyleft)
-            self.parent.add_zone(zonepolyright)
+            zonepolyleft = zone(name='polygons_left_'+self.myname, parent=self.parent)
+            zonepolyright = zone(name='polygons_right_'+self.myname, parent=self.parent)
+            self.parent.add_zone(zonepolyleft, forceparent=True)
+            self.parent.add_zone(zonepolyright, forceparent=True)
 
             for i in range(nb):
                 ptc1 = sc[i]
@@ -5058,8 +5075,8 @@ class zone:
 
                 #mean distance along center will be stored as Z value of each vertex
                 smean =(ptc1+ptc2)/2.
-                curvecleft=vector(name='poly'+str(i+1),parentzone=zonepolyleft)
-                curvecright=vector(name='poly'+str(i+1),parentzone=zonepolyright)
+                curvecleft=vector(name='poly'+str(i+1), parentzone=zonepolyleft)
+                curvecright=vector(name='poly'+str(i+1), parentzone=zonepolyright)
 
                 #Substring for Left and Right
                 sublsl=vecleft[farthest_parallel].substring(pt1[-1], pt2[-1], is3D=False, adim=False)
@@ -5077,8 +5094,8 @@ class zone:
                 downl.reverse()
                 downr = [wolfvertex(pt[i].x, pt[i].y) for pt in ptr2.values()]
 
-                curvecleft.myvertices  = sublsl.myvertices.copy() + downl[1:-1].copy() + [sublscr.myvertices.copy()] + upl[1:-1].copy()
-                curvecright.myvertices = sublsc.myvertices.copy() + downr[1:-1].copy() + [sublsr.myvertices.copy()] + upr[1:-1].copy()
+                curvecleft.myvertices  = sublsl.myvertices.copy() + downl[1:-1].copy() + sublscr.myvertices.copy() + upl[1:-1].copy()
+                curvecright.myvertices = sublsc.myvertices.copy() + downr[1:-1].copy() + sublsr.myvertices.copy() + upr[1:-1].copy()
 
                 for curvert in curvecleft.myvertices:
                     curvert.z = smean
@@ -5096,6 +5113,9 @@ class zone:
 
         self._fill_structure()
 
+        if self.get_mapviewer() is not None:
+            self.get_mapviewer().Paint()
+
         return myparallels
 
     def get_values_linked_polygons(self, linked_arrays, stats=True) -> dict:
@@ -7804,6 +7824,7 @@ class Zones(wx.Frame, Element_To_Draw):
         """
 
         if self.active_zone is None:
+            logging.warning(_('No active zone - Nothing to do !'))
             return
 
         if self.wx_exists:
@@ -7813,25 +7834,81 @@ class Zones(wx.Frame, Element_To_Draw):
                 logging.warning(_('The active zone must contain 3 vectors and only 3'))
                 return
 
-            dlg=wx.NumberEntryDialog(None,_('What is the desired longitudinal size [cm] ?'),'ds','ds size',500,1,10000)
-            ret=dlg.ShowModal()
-            if ret==wx.ID_CANCEL:
-                dlg.Destroy()
-                return
+            self.active_zone.myvectors[1].update_lengths()
 
-            ds=float(dlg.GetValue())/100.
-            dlg.Destroy()
+            poly_dlg = wx.Dialog(None, title=_('Polygons from parallels options'), size=(400, 350))
+            poly_dlg.SetBackgroundColour(wx.Colour(240, 240, 240))
+            poly_sizer = wx.BoxSizer(wx.VERTICAL)
+            poly_sizer.Add(wx.StaticText(poly_dlg, label=_('Polygons from parallels options')), 0, wx.ALL | wx.CENTER, 5)
+            poly_sizer.Add(wx.StaticText(poly_dlg, label=_('This will create polygons from the parallels in the active zone')), 0, wx.ALL | wx.CENTER, 5)
+            poly_sizer.Add(wx.StaticText(poly_dlg, label=_('Please enter the parameters below:')), 0, wx.ALL | wx.CENTER, 5)
+            poly_sizer.Add(wx.StaticText(poly_dlg, label=_('Longitudinal size [cm]:')), 0, wx.ALL | wx.LEFT, 5)
+            ds_text = wx.TextCtrl(poly_dlg, value='5000')  # Default
+            poly_sizer.Add(ds_text, 0, wx.ALL | wx.EXPAND, 5)
+            poly_sizer.Add(wx.StaticText(poly_dlg, label=_('How many polygons? \n\n 1 = one large polygon from left to right\n 2 = two polygons - one left and one right')), 0, wx.ALL | wx.LEFT, 5)
+            nb_text = wx.TextCtrl(poly_dlg, value='1')  # Default
+            poly_sizer.Add(nb_text, 0, wx.ALL | wx.EXPAND, 5)
+            ok_button = wx.Button(poly_dlg, label=_('OK'))
+            ok_button.Bind(wx.EVT_BUTTON, lambda evt: self._OnCreatePolygons(evt, ds_text, nb_text, poly_dlg))
+            poly_sizer.Add(ok_button, 0, wx.ALL | wx.CENTER, 5)
+            poly_dlg.SetSizer(poly_sizer)
+            poly_dlg.Layout()
+            poly_dlg.CentreOnParent()
+            poly_dlg.ShowModal()
 
-            dlg=wx.NumberEntryDialog(None,_('How many polygons ? \n\n 1 = one large polygon from left to right\n 2 = two polygons - one left and one right'),'Number','Polygons',1,1,2)
-            ret=dlg.ShowModal()
-            if ret==wx.ID_CANCEL:
-                dlg.Destroy()
+            # dlg=wx.NumberEntryDialog(None,_('What is the desired longitudinal size [cm] ?'),'ds','ds size',500,1,10000)
+            # ret=dlg.ShowModal()
+            # if ret==wx.ID_CANCEL:
+            #     dlg.Destroy()
+            #     return
+
+            # ds=float(dlg.GetValue())/100.
+            # dlg.Destroy()
+
+            # dlg=wx.NumberEntryDialog(None,_('How many polygons ? \n\n 1 = one large polygon from left to right\n 2 = two polygons - one left and one right'),'Number','Polygons',1,1,2)
+            # ret=dlg.ShowModal()
+            # if ret==wx.ID_CANCEL:
+            #     dlg.Destroy()
+            #     return
+
+            # nb=int(dlg.GetValue())
+            # dlg.Destroy()
+
+
+    def _OnCreatePolygons(self, event:wx.MouseEvent, ds_text:wx.TextCtrl, nb_text:wx.TextCtrl, option_dialog:wx.Dialog):
+        """
+        Handle the creation of polygons based on user input from the dialog.
+        """
+
+        try:
+            ds = float(ds_text.GetValue()) / 100.0  # Convert cm to
+            nb = int(nb_text.GetValue())  # Number of polygons
+
+            if ds <= 0:
+                wx.MessageBox(_('Please enter a valid distance greater than 0.'), _('Input Error'), wx.OK | wx.ICON_ERROR)
                 return
 
-            nb=int(dlg.GetValue())
-            dlg.Destroy()
+            if ds > self.active_zone.myvectors[1].length2D:
+                wx.MessageBox(_('The distance must be less than the length of the center vector in the active zone.'), _('Input Error'), wx.OK | wx.ICON_ERROR)
+                return
+
+            if nb < 1 or nb > 2:
+                wx.MessageBox(_('Please enter a valid number of polygons (1 or 2).'), _('Input Error'), wx.OK | wx.ICON_ERROR)
+                return
+        except ValueError:
+            wx.MessageBox(_('Please enter valid numeric values for all fields.'), _('Input Error'), wx.OK | wx.ICON_ERROR)
+            return
 
+        try:
             self.active_zone.create_polygon_from_parallel(ds,nb)
+        except Exception as e:
+            logging.error(_('Error during polygon creation: {}').format(str(e)))
+
+        if self.get_mapviewer() is not None:
+            self.get_mapviewer().Paint()
+
+        option_dialog.Destroy()
+
 
     def Oncreateslidingpoly(self, event:wx.MouseEvent):
         """
@@ -7849,71 +7926,145 @@ class Zones(wx.Frame, Element_To_Draw):
             dlg.Destroy()
             return
 
-        #dialog box for length, sliding length, farthest parallel and parallel interval
-        dlg=wx.NumberEntryDialog(None,_('What is the desired longitudinal size [cm] ?'),'ds','ds size',5000,1,100000)
-        ret=dlg.ShowModal()
-        if ret==wx.ID_CANCEL:
-            dlg.Destroy()
-            return
+        option_dialog = wx.Dialog(None, title=_('Sliding polygons options'), size=(450, 520))
+        option_dialog.SetBackgroundColour(wx.Colour(240, 240, 240))
+        option_sizer = wx.BoxSizer(wx.VERTICAL)
+        option_sizer.Add(wx.StaticText(option_dialog, label=_('Sliding polygons options')), 0, wx.ALL | wx.CENTER, 5)
+        option_sizer.Add(wx.StaticText(option_dialog, label=_('This will create sliding polygons from the active vector in the active zone')), 0, wx.ALL | wx.CENTER, 5)
+        option_sizer.Add(wx.StaticText(option_dialog, label=_('Please enter the parameters below:')), 0, wx.ALL | wx.CENTER, 5)
+        option_sizer.Add(wx.StaticText(option_dialog, label=_('Longitudinal size [cm]:')), 0, wx.ALL | wx.LEFT, 5)
+        ds_text = wx.TextCtrl(option_dialog, value='5000')  # Default value in cm
+        option_sizer.Add(ds_text, 0, wx.ALL | wx.EXPAND, 5)
+        option_sizer.Add(wx.StaticText(option_dialog, label=_('Sliding length [cm]:')), 0, wx.ALL | wx.LEFT, 5)
+        sliding_text = wx.TextCtrl(option_dialog, value='5000')  # Default value
+        option_sizer.Add(sliding_text, 0, wx.ALL | wx.EXPAND, 5)
+        option_sizer.Add(wx.StaticText(option_dialog, label=_('Farthest parallel [cm]:')), 0, wx.ALL | wx.LEFT, 5)
+        farthest_text = wx.TextCtrl(option_dialog, value='10000')  # Default
+        option_sizer.Add(farthest_text, 0, wx.ALL | wx.EXPAND, 5)
+        option_sizer.Add(wx.StaticText(option_dialog, label=_('Parallel interval [cm]:')), 0, wx.ALL | wx.LEFT, 5)
+        interval_text = wx.TextCtrl(option_dialog, value='1000')  # Default
+        option_sizer.Add(interval_text, 0, wx.ALL | wx.EXPAND, 5)
+
+        intersect_sizer = wx.BoxSizer(wx.HORIZONTAL)
+        inter_checkbox = wx.CheckBox(option_dialog, label=_('Use intersect zone if available'))
+        inter_checkbox.SetValue(True)  # Default to True
+        offset_text = wx.TextCtrl(option_dialog, value='10')  # Default offset value
+        intersect_sizer.Add(inter_checkbox, 0, wx.ALL | wx.LEFT, 5)
+        intersect_sizer.Add(wx.StaticText(option_dialog, label=_('Offset [cm]:')), 0, wx.ALL | wx.LEFT, 5)
+        intersect_sizer.Add(offset_text, 0, wx.ALL | wx.EXPAND, 5)
+        option_sizer.Add(wx.StaticText(option_dialog, label=_('If you have a zone named "intersect", you can use it to constrain the polygons.\nWhen constraint vectors are present, they cannot intersect the central vector.\nLikewise, they must be drawn moving away from the central vector.')), 0, wx.ALL | wx.CENTER, 5)
+
+        option_sizer.Add(intersect_sizer, 0, wx.ALL | wx.LEFT, 5)
+        separate_checkbox = wx.CheckBox(option_dialog, label=_('Separate left and right polygons'))
+        separate_checkbox.SetValue(False)  # Default to False
+        option_sizer.Add(separate_checkbox, 0, wx.ALL | wx.LEFT, 5)
+        ok_button = wx.Button(option_dialog, label=_('OK'))
+        ok_button.Bind(wx.EVT_BUTTON, lambda evt: self._OnCreateSlidingPolygon(evt, ds_text, sliding_text, farthest_text, interval_text, inter_checkbox, offset_text, separate_checkbox, option_dialog))
+        option_sizer.Add(ok_button, 0, wx.ALL | wx.CENTER, 5)
+        option_dialog.SetSizer(option_sizer)
+        option_dialog.Layout()
+        option_dialog.Centre()
 
-        ds=float(dlg.GetValue())/100.
+        try:
+            option_dialog.ShowModal()
+        except:
+            logging.error(_('Error during sliding polygons calculation.'))
 
-        dlg.Destroy()
+        option_dialog.Destroy()
 
-        dlg=wx.NumberEntryDialog(None,_('What is the desired sliding length [cm] ?'),'sliding','sliding size',5000,1,100000)
-        ret=dlg.ShowModal()
-        if ret==wx.ID_CANCEL:
-            dlg.Destroy()
+    def _OnCreateSlidingPolygon(self, event, ds_text, sliding_text, farthest_text, interval_text, inter_checkbox, offset_text, separate_checkbox, option_dialog:wx.Dialog):
+        """
+        Handle the creation of sliding polygons based on user input from the dialog.
+        """
+
+        try:
+            ds = float(ds_text.GetValue()) / 100.0  # Convert cm to m
+            sliding = float(sliding_text.GetValue()) / 100.0  # Convert cm
+            farthest = float(farthest_text.GetValue()) / 100.0  # Convert cm to m
+            interval = float(interval_text.GetValue()) / 100.0  # Convert cm to
+            intersect = inter_checkbox.GetValue()  # Boolean value
+            separate = separate_checkbox.GetValue()  # Boolean value
+            offset = float(offset_text.GetValue())/100.0  # Offset value in m
+        except ValueError:
+            wx.MessageBox(_('Please enter valid numeric values for all fields.'), _('Input Error'), wx.OK | wx.ICON_ERROR)
             return
 
-        sliding=float(dlg.GetValue())/100.
+        if separate:
+            howmany = 2  # Separate left and right polygons
+        else:
+            howmany = 1  # Single polygon
 
-        dlg.Destroy()
+        # #dialog box for length, sliding length, farthest parallel and parallel interval
+        # dlg=wx.NumberEntryDialog(None,_('What is the desired longitudinal size [cm] ?'),'ds','ds size',5000,1,100000)
+        # ret=dlg.ShowModal()
+        # if ret==wx.ID_CANCEL:
+        #     dlg.Destroy()
+        #     return
 
-        dlg=wx.NumberEntryDialog(None,_('What is the desired farthest parallel [cm] ?'),'farthest','farthest size',10000,1,100000)
-        ret=dlg.ShowModal()
-        if ret==wx.ID_CANCEL:
-            dlg.Destroy()
-            return
+        # ds=float(dlg.GetValue())/100.
 
-        farthest=float(dlg.GetValue())/100.
+        # dlg.Destroy()
 
-        dlg.Destroy()
+        # dlg=wx.NumberEntryDialog(None,_('What is the desired sliding length [cm] ?'),'sliding','sliding size',5000,1,100000)
+        # ret=dlg.ShowModal()
+        # if ret==wx.ID_CANCEL:
+        #     dlg.Destroy()
+        #     return
 
-        dlg=wx.NumberEntryDialog(None,_('What is the desired parallel interval [cm] ?'),'interval','interval size',int(farthest*10.),1,int(farthest*100.))
-        ret=dlg.ShowModal()
-        if ret==wx.ID_CANCEL:
-            dlg.Destroy()
-            return
+        # sliding=float(dlg.GetValue())/100.
 
-        interval=float(dlg.GetValue())/100.
+        # dlg.Destroy()
 
-        dlg.Destroy()
+        # dlg=wx.NumberEntryDialog(None,_('What is the desired farthest parallel [cm] ?'),'farthest','farthest size',10000,1,100000)
+        # ret=dlg.ShowModal()
+        # if ret==wx.ID_CANCEL:
+        #     dlg.Destroy()
+        #     return
 
-        zones_names=[curz.myname for curz in self.myzones]
-        if "intersect" in zones_names:
-            dlg = wx.MessageDialog(None,_('Do you want to use the intersect zone ?'),style=wx.YES_NO)
-            ret=dlg.ShowModal()
-            if ret==wx.ID_YES:
-                inter = True
-            else:
-                inter = False
-            dlg.Destroy()
-        else:
-            inter = False
+        # farthest=float(dlg.GetValue())/100.
+
+        # dlg.Destroy()
+
+        # dlg=wx.NumberEntryDialog(None,_('What is the desired parallel interval [cm] ?'),'interval','interval size',int(farthest*10.),1,int(farthest*100.))
+        # ret=dlg.ShowModal()
+        # if ret==wx.ID_CANCEL:
+        #     dlg.Destroy()
+        #     return
+
+        # interval=float(dlg.GetValue())/100.
+
+        # dlg.Destroy()
+
+        zones_names=[curz.myname.lower() for curz in self.myzones]
+        # if "intersect" in zones_names:
+        #     dlg = wx.MessageDialog(None,_('Do you want to use the intersect zone ?'),style=wx.YES_NO)
+        #     ret=dlg.ShowModal()
+        #     if ret==wx.ID_YES:
+        #         inter = True
+        #     else:
+        #         inter = False
+        #     dlg.Destroy()
+        # else:
+        #     inter = False
 
         inter_zone = None
-        if inter:
-            inter_zone = self.myzones[zones_names.index("intersect")]
+        if intersect:
+            if "intersect" in zones_names:
+                inter_zone = self.myzones[zones_names.index("intersect")]
+
+        # dlg = wx.MessageDialog(None,_('Do you want to separate left and right polygons ?'),style=wx.YES_NO)
+        # ret=dlg.ShowModal()
+        # if ret==wx.ID_YES:
+        #     howmany = 2
+        # else:
+        #     howmany = 1
 
-        dlg = wx.MessageDialog(None,_('Do you want to separate left and right polygons ?'),style=wx.YES_NO)
-        ret=dlg.ShowModal()
-        if ret==wx.ID_YES:
-            howmany = 2
-        else:
-            howmany = 1
+        try:
+            self.active_zone.create_sliding_polygon_from_parallel(ds, sliding, farthest, interval, inter_zone, howmany, eps_offset=offset)
+        except:
+            logging.error(_('Error during sliding polygons calculation.'))
 
-        self.active_zone.create_sliding_polygon_from_parallel(ds, sliding, farthest, interval, inter_zone, howmany)
+        option_dialog.Close()
 
 
     def Oncreatebin(self,event:wx.MouseEvent):
@@ -8605,9 +8756,15 @@ class Zones(wx.Frame, Element_To_Draw):
 
             self.active_zone.reset_listogl()
             self.myzones.pop(int(self.myzones.index(self.active_zone)))
+            self.Activate_vector(None)
+            self.Activate_zone(None)
+
             self.fill_structure()
             self.find_minmax(True)
 
+            if self.get_mapviewer() is not None:
+                self.get_mapviewer().Paint()
+
     def OnClickfindactivate_vector(self, event:wx.MouseEvent):
         """
         Recherche et activation d'un vecteur dans toutes les zones
@@ -8714,11 +8871,7 @@ class Zones(wx.Frame, Element_To_Draw):
                 return
 
             curname=self.active_vector.myname
-            r = wx.MessageDialog(
-                None,
-                _('The vector {n} will be deleted. Continue?').format(n=curname),
-                style=wx.YES_NO | wx.ICON_QUESTION
-            ).ShowModal()
+            r = wx.MessageDialog(None, _('The vector {n} will be deleted. Continue?').format(n=curname), style=wx.YES_NO | wx.ICON_QUESTION).ShowModal()
 
             if r != wx.ID_YES:
                 return
@@ -8730,14 +8883,23 @@ class Zones(wx.Frame, Element_To_Draw):
 
             idx = int(actzone.myvectors.index(self.active_vector))
             if idx >= 0 and idx < actzone.nbvectors:
+                actzone.reset_listogl()
                 actzone.myvectors.pop(idx)
 
-                if actzone.nbvectors==0:
+                if actzone.nbvectors == 0:
                     self.Activate_vector(None)
+                elif idx < actzone.nbvectors:
+                    self.Activate_vector(actzone.myvectors[idx])
+                else:
+                    self.Activate_vector(actzone.myvectors[-1])
 
                 self.fill_structure()
                 self.find_minmax(True)
 
+            if self.get_mapviewer() is not None:
+                self.get_mapviewer().Paint()
+
+
     def OnClickup_vector(self, event:wx.MouseEvent):
         """Remonte le vecteur actif dans la liste de la zone"""
         if self.verify_activevec():

wolfhece/apps/version.py

@@ -5,7 +5,7 @@ class WolfVersion():
 
         self.major = 2
         self.minor = 2
-        self.patch = 29
+        self.patch = 30
 
     def __str__(self):
 

wolfhece/pyshields.py

@@ -19,6 +19,7 @@ from .friction_law import f_barr_bathurst, f_colebrook, f_colebrook_pure
 
 RHO_PUREWATER = 1000. # kg/m3
 RHO_SEAWATER = 1025.  # kg/m3
+RHO_SEDIMENT = 2650. # kg/m3
 KIN_VISCOSITY = 1.e-6 # m2/s
 GRAVITY = 9.81 # m/s2
 
@@ -90,7 +91,7 @@ Autres :
 
 """
 
-def get_sadim(d:float, rhom:float =2650., rho:float =RHO_PUREWATER) -> float:
+def get_sadim(d:float, rhom:float = RHO_SEDIMENT, rho:float =RHO_PUREWATER) -> float:
       """
       s_adim = d**(3/2) * ((s-1) * g)**.5 / (4 * nu)
 
@@ -99,7 +100,7 @@ def get_sadim(d:float, rhom:float =2650., rho:float =RHO_PUREWATER) -> float:
       s=rhom/rho
       return d**(3./2.) * ((s-1) * GRAVITY)**.5 / (4 * KIN_VISCOSITY)
 
-def get_dstar(d:float, rhom:float =2650., rho:float=RHO_PUREWATER) -> float:
+def get_dstar(d:float, rhom:float = RHO_SEDIMENT, rho:float=RHO_PUREWATER) -> float:
       """ compute d* """
       s = rhom/rho
       return d*(GRAVITY*(s-1)/KIN_VISCOSITY**2)**(1./3.) #VanRijn Formula
@@ -110,7 +111,7 @@ def sadim2dstar(sadim:float) -> float:
 def dstar2sadim(dstar:float) -> float:
       return dstar**(3./2.) / 4
 
-def get_d_from_sadim(sadim:float, rhom:float=2650., rho:float=RHO_PUREWATER) -> float:
+def get_d_from_sadim(sadim:float, rhom:float= RHO_SEDIMENT, rho:float=RHO_PUREWATER) -> float:
       """
       s_adim = d**(3/2) * ((s-1) * g)**.5 / (4 * nu)
 
@@ -119,7 +120,7 @@ def get_d_from_sadim(sadim:float, rhom:float=2650., rho:float=RHO_PUREWATER) ->
       s=rhom/rho
       return (sadim*(4*KIN_VISCOSITY)/math.sqrt((s-1)*GRAVITY))**(2/3)
 
-def get_d_from_dstar(dstar:float, rhom:float=2650., rho:float=RHO_PUREWATER) -> float:
+def get_d_from_dstar(dstar:float, rhom:float= RHO_SEDIMENT, rho:float=RHO_PUREWATER) -> float:
       """
       d_star = d * (g * (s-1) / nu**2)**(1/3)
 
@@ -166,26 +167,38 @@ def get_psi_cr3(dstar:float) -> float:
       psicr = 0.13*dstar**-0.392*math.exp(-0.015*dstar**2.)+0.045*(1-math.exp(-0.068*dstar))
       return psicr
 
-# def get_shields_cr(d, rhom=2650., rho=RHO_PUREWATER, which=2):
-#       """
-#        Example:
-#         [critical_shear_velocity, tau_cr,xadim_val, psicr] = get_shields_cr(0.2E-3, 2650)
-#       """
+def get_shields_cr(d, rhom = RHO_SEDIMENT, rho = RHO_PUREWATER, which=2):
+      """
+      :param d: grain diameter [m]
+      :param rhom: sediment density [kg/m3]
+      :param rho: water density [kg/m3]
+      :param which: which formula to use (default 2) -- see funcs = [(get_sadim, get_psi_cr), (get_dstar, get_psi_cr2), (get_dstar, get_psi_cr3)]
+
+      :return: [critical_shear_velocity, tau_cr, xadim_val, psicr]
+
+       Example:
+        [critical_shear_velocity, tau_cr, xadim_val, psicr] = get_shields_cr(0.2E-3, 2650)
+      """
+
+      assert which in [0, 1, 2], "which must be 0, 1 or 2"
 
-#       funcs = [(get_sadim,get_psi_cr),(get_dstar,get_psi_cr2),(get_dstar,get_psi_cr3)]
-#       # % Getting the sediment-fluid parameter
-#       s = rhom/rho # [-]
-#       denom_shields= (s-1)*GRAVITY*d  # [m²/s²] en réalité denom/rho
+      funcs = [(get_sadim,get_psi_cr),
+               (get_dstar,get_psi_cr2),
+               (get_dstar,get_psi_cr3)]
 
-#       xadim_val = funcs[which][0](d,rhom,rho)
-#       psicr = funcs[which][1](xadim_val)
+      # % Getting the sediment-fluid parameter
+      s = rhom/rho # [-]
+      denom_shields= (s-1)*GRAVITY*d  # [m²/s²] en réalité denom/rho
 
-#       # Using the critical value of Shields parameter
-#       # Knowing the maximum bottom shear stress
-#       tau_cr = rho * denom_shields * psicr  # Pa
-#       critical_shear_velocity = math.sqrt(denom_shields * psicr) # m/s
+      xadim_val = funcs[which][0](d,rhom,rho)
+      psicr = funcs[which][1](xadim_val)
 
-#       return [critical_shear_velocity, tau_cr,xadim_val, psicr]
+      # Using the critical value of Shields parameter
+      # Knowing the maximum bottom shear stress
+      tau_cr = rho * denom_shields * psicr  # Pa
+      critical_shear_velocity = math.sqrt(denom_shields * psicr) # m/s
+
+      return [critical_shear_velocity, tau_cr, xadim_val, psicr]
 
 def _poly(x:float) -> float:
       return ((0.002235*x**5)-(0.06043*x**4)+(0.20307*x**3)+ \
@@ -204,7 +217,7 @@ def get_tau_from_psiadim(psiadim, d:float, rhom:float=2650, rho:float=RHO_PUREWA
       denom_shields= (s-1)*GRAVITY*d  ## en réalité denom/rho
       return rho * denom_shields * psiadim
 
-def get_d_min(rhom:float=2650., rho:float=RHO_PUREWATER) -> float:
+def get_d_min(rhom:float = RHO_SEDIMENT, rho:float=RHO_PUREWATER) -> float:
       return get_d_from_sadim(get_sadim_min(),rhom,rho)
 
 def _d_cr(x:float, tau_obj:float, rhom:float, rho:float, xadim:float, yadim:float) -> float:
@@ -215,66 +228,91 @@ def _d_cr(x:float, tau_obj:float, rhom:float, rho:float, xadim:float, yadim:floa
       psi_cr=yadim(xadim(x,rhom,rho))
       return psi_obj-psi_cr
 
-# def _get_d_cr(tau_cr,rhom=2650,rho=RHO_PUREWATER):
+def _get_d_cr(tau_cr, rhom = RHO_SEDIMENT, rho=RHO_PUREWATER, which=2) -> float:
+      """ Critical diameter d_cr for Shields criterion
+
+      :param tau_cr: critical shear stress [Pa]
+      :param rhom: sediment density [kg/m3]
+      :param rho: water density [kg/m3]
+      :param which: which formula to use (default 2) -- see funcs = [(get_sadim, get_psi_cr), (get_dstar, get_psi_cr2), (get_dstar, get_psi_cr3)]
+      """
+
+      assert which in [0, 1, 2], "which must be 0, 1 or 2"
+
+      dminabs = 1.e-100
+      dmaxabs = 20
+      funcs = [(get_sadim, get_psi_cr),
+               (get_dstar, get_psi_cr2),
+               (get_dstar, get_psi_cr3)]
 
-#       dminabs = 1.e-6
-#       dmaxabs = .5
-#       d_cr = root_scalar(_d_cr,(tau_cr,rhom,rho,get_sadim,get_psi_cr),'bisect',bracket=[dminabs, dmaxabs])
+      d_cr = root_scalar(_d_cr,(tau_cr, rhom, rho, funcs[which][0],funcs[which][1]), 'bisect', bracket=[dminabs, dmaxabs])
 
-#       return d_cr
+      return d_cr.root
 
-def get_d_cr(q:float, h:float, K:float, rhom:float=2650., rho:float=RHO_PUREWATER, method='brenth', which=2) -> list[float]:
+def get_d_cr(q:float, h:float, K:float,
+             rhom:float = RHO_SEDIMENT, rho:float=RHO_PUREWATER,
+             method='brenth', which=2,
+             friction_law:Literal['Strickler', 'Colebrook'] = 'Strickler') -> list[float]:
       """
       Diamètre critique d'emportement par :
             - Shields
             - Izbach
 
-      :param q : discharge [m3/s]
-      :param h : water depth [m]
-      :param K : Strickler friction coefficient [m1/3/s]
-      :param rhom : sediment density [kg/m3]
-      :param rho : water density [kg/m3]
-      :param method : method to solve the equation (default 'brenth')
-      :param which : which formula to use (default 2)  -- see funcs = [(get_sadim,get_psi_cr),(get_dstar,get_psi_cr2),(get_dstar,get_psi_cr3)]
+      :param q: discharge [m3/s]
+      :param h: water depth [m]
+      :param K: Strickler friction coefficient [m1/3/s]
+      :param rhom: sediment density [kg/m3]
+      :param rho: water density [kg/m3]
+      :param method: method to solve the equation (default 'brenth')
+      :param which: which formula to use (default 2)  -- see funcs = [(get_sadim,get_psi_cr),(get_dstar,get_psi_cr2),(get_dstar,get_psi_cr3)]
       """
+
+      assert which in [0, 1, 2], "which must be 0, 1 or 2"
+      assert friction_law in ['Strickler', 'Colebrook'], "friction_law must be 'Strickler' or 'Colebrook'"
+
       if q==0.:
             return 0.,0.
 
-      tau_cr = (q/K)**2 / h**(7/3) * rho  * GRAVITY # rho*g*h*J
+      # tau_cr = (q/K)**2 / h**(7/3) * rho  * GRAVITY # rho*g*h*J
+      if friction_law == 'Strickler':
+            tau_cr = get_friction_slope_2D_Manning(q, h, 1/K)  * rho * GRAVITY * h # rho*g*h*J
+      elif friction_law == 'Colebrook':
+            tau_cr = get_friction_slope_2D_Colebrook(q, h, K) * rho * GRAVITY * h
+
       dminabs = 1.e-100
       dmaxabs = 20
 
       funcs = [(get_sadim, get_psi_cr),(get_dstar, get_psi_cr2),(get_dstar, get_psi_cr3)]
 
       try:
-            d_cr = root_scalar(_d_cr,(tau_cr,rhom,rho,funcs[which][0],funcs[which][1]),method,bracket=[dminabs, dmaxabs],rtol = 1e-2)
+            d_cr = root_scalar(_d_cr,(tau_cr,rhom,rho,funcs[which][0],funcs[which][1]), method, bracket=[dminabs, dmaxabs], rtol = 1e-2)
             return d_cr.root, izbach_d_cr(q,h,rhom,rho)
       except:
             izbach = izbach_d_cr(q,h,rhom,rho)
             return izbach,izbach
 
-def get_settling_vel(d:float, rhom:float=2650., rho:float=RHO_PUREWATER) -> float:
+def get_settling_vel(d:float, rhom:float= RHO_SEDIMENT, rho:float=RHO_PUREWATER) -> float:
       """
       Vitesse de chute
 
-      :param d : grain diameter [m]
-      :param rhom : sediment density [kg/m3]
-      :param rho : water density [kg/m3]
+      :param d: grain diameter [m]
+      :param rhom: sediment density [kg/m3]
+      :param rho: water density [kg/m3]
       """
       dstar = get_dstar(d,rhom,rho)
       ws = KIN_VISCOSITY/d*(math.sqrt(25+1.2*dstar**2.)-5)**(3./2.)
       return ws
 
-def get_Rouse(d:float, q:float, h:float, K:float, rhom:float=2650., rho:float=RHO_PUREWATER) -> float:
+def get_Rouse(d:float, q:float, h:float, K:float, rhom:float= RHO_SEDIMENT, rho:float=RHO_PUREWATER) -> float:
       """
       Vitesse de chute
 
-      :param d : grain diameter [m]
-      :param q : discharge [m3/s]
-      :param h : water depth [m]
-      :param K : Strickler friction coefficient [m1/3/s]
-      :param rhom : sediment density [kg/m3]
-      :param rho : water density [kg/m3]
+      :param d: grain diameter [m]
+      :param q: discharge [m3/s]
+      :param h: water depth [m]
+      :param K: Strickler friction coefficient [m1/3/s]
+      :param rhom: sediment density [kg/m3]
+      :param rho: water density [kg/m3]
       """
       # tau_cr = (q/K)**2 / h**(7/3) * rho  * GRAVITY
       # shear_vel = math.sqrt(tau_cr/rho)
@@ -285,16 +323,16 @@ def get_Rouse(d:float, q:float, h:float, K:float, rhom:float=2650., rho:float=RH
 
       return ws/(k*shear_vel)
 
-def _get_Rouse(d:float, q:float, h:float, K:float, rhom:float=2650., rho:float=RHO_PUREWATER, frac:float=50) -> float:
+def _get_Rouse(d:float, q:float, h:float, K:float, rhom:float= RHO_SEDIMENT, rho:float=RHO_PUREWATER, frac:float=50) -> float:
       """
       Settling velocity function -- used in root_scalar
 
-      :param d : grain diameter [m]
-      :param q : discharge [m3/s]
-      :param h : water depth [m]
-      :param K : Strickler friction coefficient [m1/3/s]
-      :param rhom : sediment density [kg/m3]
-      :param rho : water density [kg/m3]
+      :param d: grain diameter [m]
+      :param q: discharge [m3/s]
+      :param h: water depth [m]
+      :param K: Strickler friction coefficient [m1/3/s]
+      :param rhom: sediment density [kg/m3]
+      :param rho: water density [kg/m3]
       """
       # tau_cr = (q/K)**2 / h**(7/3) * rho  * GRAVITY
       # shear_vel = math.sqrt(tau_cr/rho)
@@ -313,18 +351,18 @@ def _get_Rouse(d:float, q:float, h:float, K:float, rhom:float=2650., rho:float=R
       elif frac==100:
             return rouse-1.2
 
-def get_transport_mode(d:float, q:float, h:float, K:float, rhom:float=2650., rho:float=RHO_PUREWATER): # -> BED_LOAD | SUSPENDED_LOAD_50 | SUSPENDED_LOAD_100 | WASH_LOAD:
+def get_transport_mode(d:float, q:float, h:float, K:float, rhom:float= RHO_SEDIMENT, rho:float=RHO_PUREWATER): # -> BED_LOAD | SUSPENDED_LOAD_50 | SUSPENDED_LOAD_100 | WASH_LOAD:
       """
       Transport mode
 
       return in [BED_LOAD, SUSPENDED_LOAD_50, SUSPENDED_LOAD_100, WASH_LOAD]
 
-      :param d : grain diameter [m]
-      :param q : discharge [m3/s]
-      :param h : water depth [m]
-      :param K : Strickler friction coefficient [m1/3/s]
-      :param rhom : sediment density [kg/m3]
-      :param rho : water density [kg/m3]
+      :param d: grain diameter [m]
+      :param q: discharge [m3/s]
+      :param h: water depth [m]
+      :param K: Strickler friction coefficient [m1/3/s]
+      :param rhom: sediment density [kg/m3]
+      :param rho: water density [kg/m3]
 
       """
 
@@ -338,15 +376,15 @@ def get_transport_mode(d:float, q:float, h:float, K:float, rhom:float=2650., rho
       else:
             return WASH_LOAD
 
-def get_d_cr_susp(q:float, h:float, K:float, rhom:float=2650., rho:float=RHO_PUREWATER, method='brenth', which=50) -> float:
+def get_d_cr_susp(q:float, h:float, K:float, rhom:float= RHO_SEDIMENT, rho:float=RHO_PUREWATER, method='brenth', which=50) -> float:
       """
       Diamètre critique d'emportement par suspension à 50% --> cf Rouse 1.2
 
-      :param q : discharge [m3/s]
-      :param h : water depth [m]
-      :param K : Strickler friction coefficient [m1/3/s]
-      :param rhom : sediment density [kg/m3]
-      :param rho : water density [kg/m3]
+      :param q: discharge [m3/s]
+      :param h: water depth [m]
+      :param K: Strickler friction coefficient [m1/3/s]
+      :param rhom: sediment density [kg/m3]
+      :param rho: water density [kg/m3]
 
       """
       if q==0.:
@@ -360,8 +398,13 @@ def get_d_cr_susp(q:float, h:float, K:float, rhom:float=2650., rho:float=RHO_PUR
       except:
             return 0.
 
-def shieldsdia_sadim(s_psicr=None, dstar_psicr=None, rhom=2650., rho=RHO_PUREWATER, figax=None) -> tuple[plt.Figure,plt.Axes]:
-      """ Plot Shields diagram with sadim"""
+def shieldsdia_sadim(s_psicr=None, dstar_psicr=None, figax=None) -> tuple[plt.Figure,plt.Axes]:
+      """ Plot Shields diagram with sadim as x-axis
+
+      :param s_psicr: tuple (S, psicr) for a specific point to plot on the diagram
+      :param dstar_psicr: tuple (dstar, psicr) for a specific point to plot on the diagram
+      :param figax: tuple (fig, ax) to plot on a specific figure and axes
+      """
 
       smax = 1000
       rangoS = np.arange(0.1,smax,0.1)
@@ -416,8 +459,13 @@ def shieldsdia_sadim(s_psicr=None, dstar_psicr=None, rhom=2650., rho=RHO_PUREWAT
 
       return fig,ax
 
-def shieldsdia_dstar(s_psicr=None, dstar_psicr=None, rhom=2650., rho=RHO_PUREWATER, figax=None) -> tuple[plt.Figure,plt.Axes]:
-      """ Plot Shields diagram with dstar"""
+def shieldsdia_dstar(s_psicr=None, dstar_psicr=None, figax=None) -> tuple[plt.Figure,plt.Axes]:
+      """ Plot Shields diagram with dstar as x-axis
+
+      :param s_psicr: tuple (S, psicr) for a specific point to plot on the diagram
+      :param dstar_psicr: tuple (dstar, psicr) for a specific point to plot on the diagram
+      :param figax: tuple (fig, ax) to plot on a specific figure and axes
+      """
 
       smax = 1000
       d_stars = np.arange(0.1,smax,0.1)
@@ -517,9 +565,9 @@ 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]
+      :param q: discharge [m3/s]
+      :param h: water depth [m]
+      :param n: Manning friction coefficient [m^{-1/3}.s]
       """
 
       denom = h**(4./3.)
@@ -530,13 +578,24 @@ def get_friction_slope_2D_Manning(q:float, h:float, n:float) -> float:
 
       return j
 
+def get_friction_slope_2D_Strickler(q:float, h:float, K:float) -> float:
+      """
+      Compute friction slope j for 2D flow with Strickler friction law
+
+      :param q: discharge [m3/s]
+      :param h: water depth [m]
+      :param K: Strickler friction coefficient [m^{1/3}/s]
+      """
+
+      return get_friction_slope_2D_Manning(q, h, 1./K)  # n = 1/K
+
 def get_friction_slope_2D_Colebrook(q:float, h:float, K:float) -> float:
       """
       Compute friction slope j for 2D flow with Colebrook-White friction law
 
-      :param q : discharge [m3/s]
-      :param h : water depth [m]
-      :param K : Colebrook-White friction coefficient [m]
+      :param q: discharge [m3/s]
+      :param h: water depth [m]
+      :param K: height of roughness [m] - will be used to compute k/D or k/(4h) in 2D flow
       """
 
       four_hydraulic_radius = 4.0 * h
@@ -554,10 +613,10 @@ 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]
+      :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)
@@ -570,10 +629,10 @@ def get_shear_velocity_2D_Colebrook(q:float, h:float, K:float) -> float:
       """
       Compute shear velocity u_* for 2D flow with Colebrook-White friction law
 
-      :param j : friction slope [-]
-      :param h : water depth [m]
-      :param q : discharge [m3/s]
-      :param K : Colebrook-White friction coefficient [m]
+      :param j: friction slope [-]
+      :param h: water depth [m]
+      :param q: discharge [m3/s]
+      :param K: Colebrook-White friction coefficient [m]
       """
 
       j = get_friction_slope_2D_Colebrook(q,h,K)
@@ -586,11 +645,11 @@ 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
 
-      :param s : sediment density / water density [-]
-      :param d : sediment diameter [m]
-      :param q : discharge [m3/s]
-      :param h : water depth [m]
-      :param n : Manning friction coefficient [m-1/3.s]
+      :param s: sediment density / water density [-]
+      :param d: sediment diameter [m]
+      :param q: discharge [m3/s]
+      :param h: water depth [m]
+      :param n: Manning friction coefficient [m-1/3.s]
 
       See also get_Shields_2D_Strickler
       """
@@ -607,11 +666,11 @@ def get_Shields_2D_Strickler(s:float, d:float, q:float, h:float, K:float) -> flo
       """
       Compute Shields dimensionless parameter for 2D flow with Manning/Strickler friction law
 
-      :param s : sediment density / water density [-]
-      :param d : sediment diameter [m]
-      :param q : discharge [m3/s]
-      :param h : water depth [m]
-      :param K : Strickler friction coefficient [m1/3/s]
+      :param s: sediment density / water density [-]
+      :param d: sediment diameter [m]
+      :param q: discharge [m3/s]
+      :param h: water depth [m]
+      :param K: Strickler friction coefficient [m1/3/s]
 
       See also get_Shields_2D_Manning
       """
@@ -631,21 +690,23 @@ def izbach_d_cr(q:float, h:float, rhom:float=2650, rho:float=RHO_PUREWATER, meth
             (s-1) = (rho_m - rho) / rho
             u_c = 85% u_moyen)
 
-      --> d = u_c**2 / (s * g) / 1.7**2
+      --> d = u_c**2 / ((s-1) * g) / 1.7**2
 
-      --> d = (0.85 * q/h)**2 / (s * g) / 1.7**2
+      --> d = (0.85 * q/h)**2 / ((s-1) * g) / 1.7**2
 
-      :param q : discharge [m3/s]
-      :param h : water depth [m]
-      :param rhom : sediment density [kg/m3]
-      :param rho : water density [kg/m3]
-      :param method : method to solve the equation (default 'ridder')
+      :param q: discharge [m3/s]
+      :param h: water depth [m]
+      :param rhom: sediment density [kg/m3]
+      :param rho: water density [kg/m3]
+      :param method: method to solve the equation (default 'ridder')
       """
       s = rhom/rho
       #      (0.85 * q/h)**2. / ((s-1.) * GRAVITY) / 1.7**2.
-      # <=>  0.7 * (0.85*q/h)**2. / (2 * GRAVITY) / (s-1.)
-      # <=>  (q/h)**2. / (2 * GRAVITY) / (s-1.) / .86**2
-      return (q/h)**2. / (2 * GRAVITY) / (s-1.) / 1.2**2
+      # avec (2 / 1.7**2) = 0.692041... = 0.7
+      # <=>  0.7 * (0.85 * q/h)**2. / (2 * GRAVITY) / (s-1.)
+      # <=>  (q/h)**2. / (2 * GRAVITY) / (s-1.) / 1.406**2
+
+      return (q/h)**2. / (2 * GRAVITY) / (s-1.) / 1.2**2 # We are using 1.2 instead of 1.406 -- see GCIV2035-1 - Hydrodynamique fluviale
 
 
 ## Portage de WOLF2D - Fortran pour Barr-Bathurst

{wolfhece-2.2.29.dist-info → wolfhece-2.2.30.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: wolfhece
-Version: 2.2.29
+Version: 2.2.30
 Author-email: Pierre Archambeau <pierre.archambeau@uliege.be>
 Project-URL: Homepage, https://uee.uliege.be/hece
 Project-URL: Issues, https://uee.uliege.be/hece

{wolfhece-2.2.29.dist-info → wolfhece-2.2.30.dist-info}/RECORD

@@ -7,8 +7,8 @@ wolfhece/ManageParams.py,sha256=EeuUI5Vvh9ixCvYf8YShMC1s1Yacc7OxOCN7q81gqiQ,517
 wolfhece/Model1D.py,sha256=snEmu8Uj2YGcp1ybPnly-4A389XRnuOujGduqInNcgw,477001
 wolfhece/PandasGrid.py,sha256=YIleVkUkoP2MjtQBZ9Xgwk61zbgMj4Pmjj-clVTfPRs,2353
 wolfhece/PyConfig.py,sha256=Zs9852UnTMDjiH9RhC_-cQdOowDaS1U5PbmmU9nEpv0,18265
-wolfhece/PyCrosssections.py,sha256=igU_ELrg5VrHU6RNbF5tHxPyVImpR3xdpfopJYc7haw,114711
-wolfhece/PyDraw.py,sha256=-hPVoASNtB7k9_P7F3uq-4Vqytie4wjEL36OUiqtszQ,671455
+wolfhece/PyCrosssections.py,sha256=iSmuQ1753bWxRLgOkrRLPd3tiMwGRCvfKD2Mim26_8c,114836
+wolfhece/PyDraw.py,sha256=cloYUTYk6tTCuSmBehVcz2DOadkb7J5w9i1ihBilT2Q,671960
 wolfhece/PyGui.py,sha256=DqMTDsC9GthnMdYOXvkMKfl5pNciExVzxG4ogptWf6g,146010
 wolfhece/PyGuiHydrology.py,sha256=sKafpOopBg50L5llZCI_fZtbebVTDtxvoRI6-osUwhg,14745
 wolfhece/PyHydrographs.py,sha256=1P5XAURNqCvtSsMQXhOn1ihjTpr725sRsZdlCEhhk6M,3730
@@ -17,7 +17,7 @@ wolfhece/PyParams.py,sha256=BgTAwxxq831rYEq_KLcFBX_upjiSUpVtfoQnCxCNWUI,100443
 wolfhece/PyPictures.py,sha256=m1kY0saW6Y9Q0bDCo47lW6XxDkBrbQG-Fd8uVn8G5ic,2514
 wolfhece/PyTranslate.py,sha256=4appkmNeHHZLFmUtaA_k5_5QL-5ymxnbVN4R2OblmtE,622
 wolfhece/PyVertex.py,sha256=a56oY1NB45QnwARg96Tbnq-z-mhZKFkYOkFOO1lNtlk,51056
-wolfhece/PyVertexvectors.py,sha256=DZpuqfzAEWAtGJ5oSzRY0kRMlkwErogcGMJQOh6niDE,341983
+wolfhece/PyVertexvectors.py,sha256=-MIgo6-PVir2NxQn6RoOdpEkqfrJv8Ts6_FjEZqXJC4,351630
 wolfhece/PyWMS.py,sha256=XcSlav5icct2UwV7K2r7vpxa5rKZWiHkp732lI94HFI,31534
 wolfhece/RatingCurve.py,sha256=bUjIrQjvIjkD4V-z8bZmA6pe1ILtYNM0-3fT6YUY1RU,22498
 wolfhece/RatingCurveData.py,sha256=5UvnIm89BwqjnEbLCcY3CA8WoFd_xHJbooNy62fX5iY,57660
@@ -53,7 +53,7 @@ wolfhece/pybridges.py,sha256=bFAqjL4ColeJtwvyCPGQ8VllWoq1RbVWXxFrdfrvqm8,65954
 wolfhece/pydike.py,sha256=dRb6qGkqoTXjf107KcajcIk1F_FuMPaOZLSwixT3dgA,11196
 wolfhece/pylogging.py,sha256=4TI8hgBB65z-zpvU5Rfa2jkPXPhJaqXjHVPwbcdzTNc,4528
 wolfhece/pypolygons_scen.py,sha256=dG4zyJL_t5wgDqRfe-OqSH-fnxUt-su1H-tM3K3wHnc,46339
-wolfhece/pyshields.py,sha256=ymH393EQys2aZmh41ccJnWmmlF7dVa-eTY32jFgwK08,25269
+wolfhece/pyshields.py,sha256=KMtUO5kD0lisKnJD1NsDz-qaY5DpFcmS4O3WkXtUSmo,27898
 wolfhece/pyviews.py,sha256=zuZjWUptRDm1MTE1PN4Xj_qSITnojgDMG0LlFIBH3SE,13739
 wolfhece/pywalous.py,sha256=mWB7UxlYMIbPxNUDlONQEjcOOy9VSaRU9aYWZ5IFLu8,19164
 wolfhece/rain_SPWMI.py,sha256=qCfcmF7LajloOaCwnTrrSMzyME03YyilmRUOqrPrv3U,13846
@@ -88,7 +88,7 @@ wolfhece/apps/curvedigitizer.py,sha256=lEJJwgAfulrrWQc-U6ij6sj59hWN3SZl4Yu1kQxVz
 wolfhece/apps/hydrometry.py,sha256=lhhJsFeb4zGL4bNQTs0co85OQ_6ssL1Oy0OUJCzhfYE,656
 wolfhece/apps/isocurrent.py,sha256=dagmGR8ja9QQ1gwz_8fU-N052hIw-W0mWGVkzLu6C7I,4247
 wolfhece/apps/splashscreen.py,sha256=EdGDN9NhudIiP7c3gVqj7dp4MWFB8ySizM_tpMnsgpE,3091
-wolfhece/apps/version.py,sha256=MsRPVPFz_Nd-g9QBhzEMZR5szCY4WxPCUofNwlSWVMA,388
+wolfhece/apps/version.py,sha256=TbVLaOlu0bvthJf8mZ0I5HvlwlTNg4-IrIDSbM0cAAU,388
 wolfhece/apps/wolf.py,sha256=mRnjYsUu4KIsRuamdQWAINFMuwN4eJgMo9erG-hkZ70,729
 wolfhece/apps/wolf2D.py,sha256=4z_OPQ3IgaLtjexjMKX9ppvqEYyjFLt1hcfFABy3-jU,703
 wolfhece/apps/wolf_logo.bmp,sha256=ruJ4MA51CpGO_AYUp_dB4SWKHelvhOvd7Q8NrVOjDJk,3126
@@ -307,8 +307,8 @@ wolfhece/ui/wolf_multiselection_collapsiblepane.py,sha256=u4C7CXe_bUyGKx7c_Bi0x9
 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.2.29.dist-info/METADATA,sha256=35R9m7_Q5LYcKUXvUBBwZ8p1A-JMWrMYn5VtO4ncgNw,2729
-wolfhece-2.2.29.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-wolfhece-2.2.29.dist-info/entry_points.txt,sha256=Jr187pyvA3EeJiQLjZK9yo6mJX7IAn6ygZU9T8qF_gQ,658
-wolfhece-2.2.29.dist-info/top_level.txt,sha256=EfqZXMVCn7eILUzx9xsEu2oBbSo9liWPFWjIHik0iCI,9
-wolfhece-2.2.29.dist-info/RECORD,,
+wolfhece-2.2.30.dist-info/METADATA,sha256=6DgxvLnytFPLyQpPZ2b0ZoyBqOe-rb98b-jm6FTw9Os,2729
+wolfhece-2.2.30.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+wolfhece-2.2.30.dist-info/entry_points.txt,sha256=Jr187pyvA3EeJiQLjZK9yo6mJX7IAn6ygZU9T8qF_gQ,658
+wolfhece-2.2.30.dist-info/top_level.txt,sha256=EfqZXMVCn7eILUzx9xsEu2oBbSo9liWPFWjIHik0iCI,9
+wolfhece-2.2.30.dist-info/RECORD,,