wolfhece 2.1.16__py3-none-any.whl → 2.1.17__py3-none-any.whl

wolfhece/PyDraw.py

@@ -852,6 +852,13 @@ class WolfMapViewer(wx.Frame):
             # self.menu2d_bc = self.menuwolf2d.Append(wx.ID_ANY, _("Manage boundary conditions..."), _("BC manager"))
             self.menu2d_video = self.menuwolf2d.Append(wx.ID_ANY, _("Create video..."), _("Video/Movie"))
 
+            self.menuwolf2d.AppendSeparator()
+
+            self.menu2d_dangermap = self.menuwolf2d.Append(wx.ID_ANY, _("Danger map"), _("Compute the danger map"))
+            self.menu2d_dangermaph = self.menuwolf2d.Append(wx.ID_ANY, _("Danger map - only h"), _("Compute the danger map"))
+
+            self.menuwolf2d.AppendSeparator()            
+
             self.menubar.Append(self.menuwolf2d, _('Results 2D'))
 
             self.menuwolf2d.Bind(wx.EVT_MENU, self.Onmenuwolf2d)
@@ -1182,6 +1189,82 @@ class WolfMapViewer(wx.Frame):
             if self.active_res2d is not None:
                 self.create_video()
 
+        elif itemlabel == _("Danger map - only h"):
+            if self.active_res2d is None:
+                logging.warning(_('No active 2D result !'))
+                return
+
+            with wx.NumberEntryDialog(None, _('Danger map'), _('From step'), _('Danger map'), 1, 1, self.active_res2d.get_nbresults()) as dlg:
+
+                if dlg.ShowModal() == wx.ID_CANCEL:
+                    return
+                
+                start_step = dlg.GetValue()
+            
+            with wx.NumberEntryDialog(None, _('Danger map'), _('To step'), _('Danger map'), self.active_res2d.get_nbresults(), start_step, self.active_res2d.get_nbresults()) as dlg:
+
+                if dlg.ShowModal() == wx.ID_CANCEL:
+                    return
+                
+                end_step = dlg.GetValue()
+
+            with wx.NumberEntryDialog(None, _('Danger map'), _('Every'), _('Danger map'), 1, 1, 60) as dlg:
+                
+                if dlg.ShowModal() == wx.ID_CANCEL:
+                    return
+                
+                every = dlg.GetValue()
+
+            danger_map = self.active_res2d.danger_map_only_h(start_step-1, end_step-1, every)
+
+            with wx.DirDialog(None, _('Choose a directory'), style=wx.DD_DEFAULT_STYLE) as dlg:
+
+                if dlg.ShowModal() == wx.ID_CANCEL:
+                    return
+                
+                outdir = dlg.GetPath()
+
+            danger_map.write_all(Path(outdir) / 'danger_h.tif')
+
+        elif itemlabel == _("Danger map"):
+            if self.active_res2d is None:
+                logging.warning(_('No active 2D result !'))
+                return
+
+            with wx.NumberEntryDialog(None, _('Danger map'), _('From step'), _('Danger map'), 1, 1, self.active_res2d.get_nbresults()) as dlg:
+
+                if dlg.ShowModal() == wx.ID_CANCEL:
+                    return
+                
+                start_step = dlg.GetValue()
+            
+            with wx.NumberEntryDialog(None, _('Danger map'), _('To step'), _('Danger map'), self.active_res2d.get_nbresults(), start_step, self.active_res2d.get_nbresults()) as dlg:
+
+                if dlg.ShowModal() == wx.ID_CANCEL:
+                    return
+                
+                end_step = dlg.GetValue()
+
+            with wx.NumberEntryDialog(None, _('Danger map'), _('Every'), _('Danger map'), 1, 1, 60) as dlg:
+                
+                if dlg.ShowModal() == wx.ID_CANCEL:
+                    return
+                
+                every = dlg.GetValue()
+
+            danger_maps = self.active_res2d.danger_map(start_step-1, end_step-1, every)
+
+            with wx.DirDialog(None, _('Choose a directory'), style=wx.DD_DEFAULT_STYLE) as dlg:
+
+                if dlg.ShowModal() == wx.ID_CANCEL:
+                    return
+                
+                outdir = dlg.GetPath()
+
+            names = ['danger_h.tif', 'danger_u.tif', 'danger_q.tif']
+            for name, danger_map in zip(names, danger_maps):
+                danger_map.write_all(Path(outdir) / name)
+
         elif itemlabel == _("Setup cache..."):
 
             if self.active_res2d is None:

wolfhece/PyGuiHydrology.py

@@ -3,6 +3,9 @@ import wx
 from .PyTranslate import _
 from .PyDraw import WolfMapViewer
 from .RatingCurve import *
+from.PyVertexvectors import vector, Zones, zone, getIfromRGB, getRGBfromI
+
+import logging
 
 
 class selectpoint(wx.Frame):
@@ -112,32 +115,62 @@ class selectpoint(wx.Frame):
 
 
 class GuiHydrology(WolfMapViewer):
+    """ Mapviewer of the hydrology model -- see HydrologyModel in PyGui.py """
+
+    def __init__(self, parent=None, title='WOLF Hydrological model - viewer', w=500, h=500, treewidth=200, wolfparent=None, wxlogging=None):
+        """ Constructor
+        
+        :param parent: parent window - wx.Frame
+        :param title: title of the window - str
+        :param w: width of the window - int
+        :param h: height of the window - int
+        :param treewidth: width of the tree - int
+        :param wolfparent: wolf parent instance -- PyGui.HydrologyModel
+        :type wolfparent: HydrologyModel
+        :param wxlogging: logging instance -- PyGui.WolfLog
+        """
 
-    def __init__(self, parent=None, title='MyForm', w=500, h=500, treewidth=200, wolfparent=None, wxlogging=None):
         super(GuiHydrology, self).__init__(parent, title=title, w=w, h=h, 
-                                           treewidth=treewidth, wolfparent=wolfparent,wxlogging=wxlogging)
+                                           treewidth=treewidth, 
+                                           wolfparent=wolfparent,
+                                           wxlogging=wxlogging)
 
-        self.parent = parent
+        from .PyGui import HydrologyModel
 
-        self.filemenu.Insert(0, 1100, _('New from scratch'), _('Create a new simulation from scratch...'))
+        self.wolfparent:HydrologyModel
 
-        self.toolsmenu = wx.Menu()
-        self.toolsmenu.Append(1200, _('Forced exchanges'), _('Manage the forced exchanges...'))
-        self.toolsmenu.Append(1201, _('Crop MNT/MNS'), _('Cropping data...'))
-        self.toolsmenu.Append(1202, _('Crop land use (COSW)'), _('Cropping data...'))
-        self.toolsmenu.Append(1205, _('Analyze slope'), _('Slope analyzer...'))
-        self.toolsmenu.Append(1203, _('IRM - QDF'), _('Manage data...'))
-        self.toolsmenu.Append(1204, _('SPW - Hydrometry'), _('Manage data...'))
-        self.menubar.Append(self.toolsmenu, _('&Tools'))
+        # self.filemenu.Insert(0, wx.ID_ANY, _('New from scratch'), _('Create a new simulation from scratch...'))
 
         self.modelmenu = wx.Menu()
-        paramgen = self.modelmenu.Append(1500, _('New'), _('Wizard !'))
-        paramgen = self.modelmenu.Append(1501, _('Interior points'), _('Interior points'))
-        paramgen = self.modelmenu.Append(1502, _('Topology'), _('Topology manager'))
-        paramgen = self.modelmenu.Append(1503, _('Main model'), _('General parameters'))
-        paramgen = self.modelmenu.Append(1504, _('Basin'), _('Basin parameters'))
-        paramgen = self.modelmenu.Append(1505, _('Subbasins'), _('Sub-Basin parameters'))
-        self.menubar.Append(self.modelmenu, _('&Model'))
+        paramgen = self.modelmenu.Append(wx.ID_ANY, _('Choose outlet'), _('Wizard !'))
+        paramgen = self.modelmenu.Append(wx.ID_ANY, _('Interior points'), _('Interior points'))
+        paramgen = self.modelmenu.Append(wx.ID_ANY, _('Topology'), _('Topology manager'))
+        paramgen = self.modelmenu.Append(wx.ID_ANY, _('Main model'), _('General parameters'))
+        paramgen = self.modelmenu.Append(wx.ID_ANY, _('Basin'), _('Basin parameters'))
+        paramgen = self.modelmenu.Append(wx.ID_ANY, _('Subbasins'), _('Sub-Basin parameters'))
+        self.menubar.Append(self.modelmenu, _('&Hydrological model'))
+
+        self.toolsmenu = wx.Menu()
+        self.toolsmenu.Append(wx.ID_ANY, _('Forced exchanges'), _('Manage the forced exchanges...'))
+        self.toolsmenu.Append(wx.ID_ANY, _('Crop MNT/MNS'), _('Cropping data...'))
+        self.toolsmenu.Append(wx.ID_ANY, _('Crop land use (COSW)'), _('Cropping data...'))
+        self.toolsmenu.Append(wx.ID_ANY, _('Analyze slope'), _('Slope analyzer...'))
+        self.toolsmenu.Append(wx.ID_ANY, _('IRM - QDF'), _('Manage data...'))
+
+        self.toolsmenu.AppendSeparator()
+
+        self.toolsmenu.Append(wx.ID_ANY, _('Find upstream watershed'), _('Find upstream watershed based on click...'))
+        self.toolsmenu.Append(wx.ID_ANY, _('Find upstream watershed - limit to sub'), _('Find upstream watershed based on click but limit to subbasin...'))
+
+        self.toolsmenu.AppendSeparator()
+
+        self.toolsmenu.Append(wx.ID_ANY, _('Select upstream watershed'), _('Select upstream watershed based on click...'))
+        self.toolsmenu.Append(wx.ID_ANY, _('Select upstream watershed - limit to sub'), _('Select upstream watershed based on click but limit to subbasin...'))
+        self.toolsmenu.Append(wx.ID_ANY, _('Select upstream rivers'), _('Select upstream rivers based on click...'))
+        self.toolsmenu.Append(wx.ID_ANY, _('Select upstream rivers - limit to sub'), _('Select upstream rivers based on click but limit to subbasin...'))
+        self.toolsmenu.Append(wx.ID_ANY, _('Select downstream rivers'), _('Select downstream rivers based on click...'))
+
+        self.menubar.Append(self.toolsmenu, _('&Tools Hydrology'))
 
         # self.computemenu = wx.Menu()
         # paramgen = self.computemenu.Append(1300,_('Calibration/Optimisation'),_('Parameters calibration of the model'))
@@ -149,23 +182,169 @@ class GuiHydrology(WolfMapViewer):
         # paramgen = self.resultsmenu.Append(1401,_('Plot'),_('Plot'))
         # self.menubar.Append(self.resultsmenu,_('&Results'))
 
+    @property
+    def watershed(self):
+
+        if self.wolfparent is None:
+            return None
+        
+        if self.wolfparent.mycatchment is None:
+            return None
+
+        return self.wolfparent.mycatchment.charact_watrshd
+
     def OnMenubar(self, event):
+        """ Event handler for the menubar """
 
+        # Call the parent event handler
         super().OnMenubar(event)
 
+        # If not handled by the parent, handle it here
+
         id = event.GetId()
         item = self.menubar.FindItemById(id)
+        if item is None:
+            return
+
+        itemlabel = item.ItemLabel
 
-        if id == wx.ID_EXECUTE:
-            print(_('Do anything !!'))
-        elif id == 1503:
-            self.parent.mainparams.Show()
-        elif id == 1504:
-            self.parent.basinparams.Show()
-        # elif id==1300:
-        #     self.myoptimisation = Optimisation()
-        #     self.myoptimisation.Show()
-        elif id == 1500:
-            myselect = selectpoint(title=_('Outlet'), SPWstations=self.parent.SPWstations,
-                                   DCENNstations=self.parent.DCENNstations)
+        if itemlabel == _('Choose outlet'):
+            myselect = selectpoint(title=_('Outlet'), 
+                                   SPWstations=self.wolfparent.SPWstations,
+                                   DCENNstations=self.wolfparent.DCENNstations)
             myselect.Show()
+
+        elif itemlabel == _('Interior points'):
+            logging.warning(_('Not yet implemented !'))
+
+        elif itemlabel == _('Topology'):
+            logging.warning(_('Not yet implemented !'))
+
+        elif itemlabel == _('Main model'):
+            self.wolfparent.mainparams.Show()
+
+        elif itemlabel == _('Basin'):
+            self.wolfparent.basinparams.Show()
+
+        elif itemlabel == _('Subbasins'):
+            logging.warning(_('Not yet implemented !'))
+
+        elif itemlabel == _('Forced exchanges'):
+            logging.warning(_('Not yet implemented !'))
+
+        elif itemlabel == _('Crop MNT/MNS'):
+            logging.warning(_('Not yet implemented !'))
+
+        elif itemlabel == _('Crop land use (COSW)'):
+            logging.warning(_('Not yet implemented !'))
+
+        elif itemlabel == _('Analyze slope'):
+            logging.warning(_('Not yet implemented !'))
+
+        elif itemlabel == _('IRM - QDF'):
+            logging.warning(_('Not yet implemented !'))
+
+        elif itemlabel == _('Find upstream watershed'):
+            self.action = 'Find upstream watershed'
+
+        elif itemlabel == _('Find upstream watershed - limit to sub'):
+            self.action = 'Find upstream watershed - limit to sub'
+
+        elif itemlabel == _('Select upstream watershed'):
+            self.action = 'Select upstream watershed'
+
+        elif itemlabel == _('Select upstream watershed - limit to sub'):
+            self.action = 'Select upstream watershed - limit to sub'
+
+        elif itemlabel == _('Select upstream rivers'):
+            self.action = 'Select upstream rivers'
+
+        elif itemlabel == _('Select upstream rivers - limit to sub'):
+            self.action = 'Select upstream rivers - limit to sub'
+
+        elif itemlabel == _('Select downstream rivers'):
+            self.action = 'Select downstream rivers'
+
+
+    def OnRightDown(self, e: wx.MouseEvent):
+        
+        # Call the parent event handler
+        super().OnRightDown(e)
+
+        if self.action is None:
+            logging.info(_('No action selected !'))
+            return
+        
+        if self.action == '':
+            logging.info(_('No action selected !'))
+            return
+
+        pos = e.GetPosition()
+        x, y = self.getXY(pos)
+
+        alt = e.AltDown()
+        ctrl = e.ControlDown()
+        shiftdown = e.ShiftDown()
+
+        if self.active_array is None:
+            logging.warning(_('No active array !'))
+            return
+
+        if not (self.active_array.dx == self.watershed.header.dx and self.active_array.dy == self.watershed.header.dy):
+            logging.warning(_('Active array and watershed do not have the same resolution !'))
+            return
+
+        if 'Find upstream watershed' in self.action:
+            
+            starting_node = self.watershed.get_node_from_xy(x,y)
+            up_vect = self.watershed.get_vector_from_upstream_node(starting_node, limit_to_sub='limit to sub' in self.action)
+
+            if up_vect is None:
+                logging.warning(_('No upstream watershed found !'))
+                return
+
+            def props_vec(vec:vector):
+                vec.myprop.color = getIfromRGB((255,0,0))
+                vec.myprop.width = 3
+                vec.myprop.transparent = False
+                vec.myprop.alpha = 122
+                vec.myprop.filled = False
+
+            if self.active_array.Operations is not None:
+                newzone = zone(name = str(starting_node.sub))
+                
+                self.active_array.Operations.show_structure_OpsVectors()
+                self.active_array.Operations.myzones.add_zone(newzone, forceparent=True)
+                newzone.add_vector(up_vect, forceparent=True)
+
+                props_vec(up_vect)
+                
+                self.active_array.Operations.myzones.prep_listogl()
+                self.active_array.Operations.myzones.fill_structure()
+                
+                self.Refresh()           
+            else:
+                logging.warning(_('No operations frame in the active array!'))
+                
+        elif 'Select upstream watershed' in self.action:
+                        
+            xy = self.watershed.get_xy_upstream_node(self.watershed.get_node_from_xy(x,y), limit_to_sub='limit to sub' in self.action)
+            self.active_array.SelectionData.set_selection_from_list_xy(xy)            
+            self.Refresh()           
+
+        elif 'Select upstream rivers' in self.action:
+
+            xy = self.watershed.get_xy_upstream_node(self.watershed.get_node_from_xy(x,y), 
+                                                     limit_to_sub='limit to sub' in self.action,
+                                                     limit_to_river=True)
+            
+            self.active_array.SelectionData.set_selection_from_list_xy(xy)            
+            self.Refresh()           
+
+        elif 'Select downstream rivers' in self.action:
+
+            xy = self.watershed.get_xy_downstream_node(self.watershed.get_node_from_xy(x,y))
+            self.active_array.SelectionData.set_selection_from_list_xy(xy) 
+            self.Refresh()           
+
+

wolfhece/PyParams.py

@@ -927,6 +927,7 @@ class Wolf_Param(wx.Frame):
             # priority to default parameters
             if key_Param.ADDED_JSON in param_def.keys():
                 param[key_Param.ADDED_JSON] = param_def[key_Param.ADDED_JSON]
+                
             param[key_Param.COMMENT] = param_def[key_Param.COMMENT]
             param[key_Param.TYPE] = param_def[key_Param.TYPE]
 
@@ -1223,6 +1224,7 @@ class Wolf_Param(wx.Frame):
                 # PARAMETRE
                 # ---------
                 curparam = self._add_param_from_str(param, groupname, groupdict)
+                curparam[key_Param.ADDED_JSON]=None
 
     def _CreateDefaultFile(self):
         """ Create a default file """
@@ -2266,7 +2268,8 @@ class Wolf_Param(wx.Frame):
                 self.myparams[curGroup][curParam][key_Param.TYPE] = templateDict[key_Param.TYPE]
                 if key_Param.ADDED_JSON in templateDict:
                     self.myparams[curGroup][curParam][key_Param.ADDED_JSON] = templateDict[key_Param.ADDED_JSON]
-
+                else:
+                    self.myparams[curGroup][curParam][key_Param.ADDED_JSON] = None
         # transfert des paramètres en surplus dans le dictionnaire savedDict
         for i in range(nbElements+1, iterMax+1):
             curParam = curIncParam.replace("$n$",str(i))

wolfhece/PyVertexvectors.py

@@ -729,6 +729,10 @@ class vectorproperties:
         try:
             if updateOGL:
                 self.parent.parentzone.prep_listogl()
+
+                if self.parent.parentzone.parent is None:
+                    logging.critical('Problem with OpenGL update - parent/mapviewer is None -- Track this issue')
+
                 self.parent.parentzone.parent.mapviewer.Refresh()
         except:
             logging.warning('Problem with OpenGL update - vectorproperties.fill_property')

wolfhece/RatingCurve.py

@@ -501,13 +501,13 @@ class SPWMIGaugingStations(Element_To_Draw):
         self.ymin = min(y)
         self.ymax = max(y)
 
-    def _plot(self, size:float=10.):
-        for curstation in self.mystations.values:
+    def _plot(self, sx=None, sy=None, xmin=None, ymin=None, xmax=None, ymax=None, size:float=10.):
+        for curstation in self.mystations.values():
             curstation.plot(size)
 
 class SPWDCENNGaugingStations(Element_To_Draw):
 
-    mystations:dict
+    mystations:dict[int:gaugingstation]
     myrivers:dict
     gaugings:SPWGaugings
     hrefs:SPWhrefs
@@ -633,6 +633,18 @@ class SPWDCENNGaugingStations(Element_To_Draw):
 
         pass
 
-    def plot(self,size:float=10.):
-        for id in self.mystations:
-            self.mystations[id].plot(size)
+    def plot(self, sx=None, sy=None, xmin=None, ymin=None, xmax=None, ymax=None, size:float=10.):
+        self._plot(size)
+
+    def find_minmax(self,update=False):
+        x = [cur.x for cur in self.mystations.values()]
+        y = [cur.y for cur in self.mystations.values()]
+
+        self.xmin = min(x)
+        self.xmax = max(x)
+        self.ymin = min(y)
+        self.ymax = max(y)
+
+    def _plot(self, size:float=10.):
+        for curstation in self.mystations.values():
+            curstation.plot(size)

wolfhece/Results2DGPU.py

@@ -380,24 +380,94 @@ class wolfres2DGPU(Wolfresults_2D):
             else:
                 _, _, _, _, wd_np, qx_np, qy_np = self._result_store.get_result(which+1)
         else:
-            _, _, _, _, wd_np, qx_np, qy_np = self._result_store.get_result(which+1)
+            __, __, __, __, wd_np, qx_np, qy_np = self._result_store.get_result(which+1)
+
+        wd_np = wd_np.T
+        qx_np = qx_np.T
+        qy_np = qy_np.T
 
         curblock = self.myblocks[getkeyblock(1,False)]
+        
+        curblock.waterdepth.array.data[:,:] = curblock.waterdepth.nullvalue
+        curblock.qx.array.data[:,:] = curblock.qx.nullvalue
+        curblock.qy.array.data[:,:] = curblock.qy.nullvalue
+
+        curblock.waterdepth.array.mask[:,:] = True
+        curblock.qx.array.mask[:,:] = True
+        curblock.qy.array.mask[:,:] = True
+        
         if self.epsilon > 0.:
-            curblock.waterdepth.array=ma.masked_less_equal(wd_np.astype(np.float32).T, self.epsilon)
+            # curblock.waterdepth.array=ma.masked_less_equal(wd_np.astype(np.float32).T, self.epsilon)
+            
+            ij = np.where(wd_np >= self.epsilon)
+            curblock.waterdepth.array.data[ij] = wd_np[ij]
+            curblock.waterdepth.array.mask[ij] = False
         else:
-            curblock.waterdepth.array=ma.masked_equal(wd_np.astype(np.float32).T, 0.)
+            # curblock.waterdepth.array=ma.masked_equal(wd_np.astype(np.float32).T, 0.)
+            
+            ij = np.where(wd_np > 0.)
+            curblock.waterdepth.array.data[ij] = wd_np[ij]
+            curblock.waterdepth.array.mask[ij] = False
+
+        # curblock.qx.array=ma.masked_where(curblock.waterdepth.array.mask,qx_np.astype(np.float32).T)
+        # curblock.qy.array=ma.masked_where(curblock.waterdepth.array.mask,qy_np.astype(np.float32).T)
 
-        curblock.qx.array=ma.masked_where(curblock.waterdepth.array.mask,qx_np.astype(np.float32).T)
-        curblock.qy.array=ma.masked_where(curblock.waterdepth.array.mask,qy_np.astype(np.float32).T)
+        curblock.qx.array.data[ij]  = qx_np[ij]
+        curblock.qy.array.data[ij]  = qy_np[ij]
+
+        curblock.qx.array.mask[ij] = False
+        curblock.qy.array.mask[ij] = False
 
         curblock.waterdepth.count()
         curblock.qx.count()
         curblock.qy.count()
 
-        curblock.waterdepth.set_nullvalue_in_mask()
-        curblock.qx.set_nullvalue_in_mask()
-        curblock.qy.set_nullvalue_in_mask()
+        # curblock.waterdepth.set_nullvalue_in_mask()
+        # curblock.qx.set_nullvalue_in_mask()
+        # curblock.qy.set_nullvalue_in_mask()
+
+        if self.to_filter_independent:
+            self.filter_independent_zones()
+
+        self.current_result = which
+        self.loaded=True
+
+    def _read_oneresult_only_h(self, which:int=-1):
+        """
+        Lecture d'un pas de sauvegarde
+
+        which: result number to read; 0-based; -1 == last one
+        """
+
+        which = self._sanitize_result_step(which)
+
+        # stored result files are 1-based -> which+1
+        if self._cache is not None:
+            if (which >= self._cache.start_idx and which < self._cache.end_idx):
+                wd_np = self._cache.get_h(which+1, True)
+            else:
+                _, _, _, _, wd_np, qx_np, qy_np = self._result_store.get_result(which+1)
+        else:
+            __, __, __, __, wd_np, qx_np, qy_np = self._result_store.get_result(which+1)
+
+        wd_np = wd_np.T
+
+        curblock = self.myblocks[getkeyblock(1,False)]
+        
+        curblock.waterdepth.array.data[:,:] = curblock.waterdepth.nullvalue
+
+        curblock.waterdepth.array.mask[:,:] = True
+        
+        if self.epsilon > 0.:
+            ij = np.where(wd_np >= self.epsilon)
+            curblock.waterdepth.array.data[ij] = wd_np[ij]
+            curblock.waterdepth.array.mask[ij] = False
+        else:
+            ij = np.where(wd_np > 0.)
+            curblock.waterdepth.array.data[ij] = wd_np[ij]
+            curblock.waterdepth.array.mask[ij] = False
+
+        curblock.waterdepth.count()
 
         if self.to_filter_independent:
             self.filter_independent_zones()

wolfhece/apps/version.py

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

wolfhece/hydrology/PyWatershed.py

@@ -130,6 +130,33 @@ class Node_Watershed:
 
         return np.sqrt(pow(self.x-x,2)+pow(self.y-y,2))
     
+    def get_up_nodes(self, excluded_node:list["Node_Watershed"]=[]):
+        """
+        Get all upstream nodes
+        """
+
+        all_up = [self]
+        all_rivers = [self] if self.river else []
+        all_runoff = [] if self.river else [self]
+        
+        for curup in self.up:
+
+            if curup in excluded_node:
+                continue
+
+            all_up.append(curup)
+            if curup.river:
+                all_rivers.append(curup)
+            else:
+                all_runoff.append(curup)
+
+            up, river, runoff = curup.get_up_nodes(excluded_node)
+            all_up.extend(up)
+            all_rivers.extend(river)
+            all_runoff.extend(runoff)
+        
+        return all_up, all_rivers, all_runoff
+
     def get_up_nodes_same_sub(self, excluded_node:list["Node_Watershed"]=[]):
         """
         Get all upstream nodes in the same sub-basin
@@ -162,30 +189,50 @@ class Node_Watershed:
         
         return all_up, all_rivers, all_runoff
     
+    def get_up_runoff_nodes(self):
+        """
+        Get all upstream runoff nodes
+        """
+
+        all_up = [self]
+        for curup in self.up:
+            if not curup.river:
+                all_up += curup.get_up_runoff_nodes()
+        
+        return all_up
+    
     def get_up_runoff_nodes_same_sub(self):
         """
         Get all upstream runoff nodes in the same sub-basin
         """
 
-        all_up = []
+        all_up = [self]
         for curup in self.up:
             if curup.sub == self.sub and not curup.river:
-                all_up.append(curup)
-
                 all_up += curup.get_up_runoff_nodes_same_sub()
         
         return all_up
 
+    
+    def get_up_rivernodes(self):
+        """
+        Get all upstream river nodes
+        """
+
+        all_up = [self]
+        for curup in self.upriver:
+            all_up += curup.get_up_rivernodes()
+        
+        return all_up
+    
     def get_up_rivernodes_same_sub(self):
         """
         Get all upstream river nodes in the same sub-basin
         """
 
-        all_up = []
+        all_up = [self]
         for curup in self.upriver:
             if curup.sub == self.sub:
-                all_up.append(curup)
-
                 all_up += curup.get_up_rivernodes_same_sub()
         
         return all_up
@@ -214,6 +261,28 @@ class Node_Watershed:
 
         return np.unique(all_down).tolist() 
 
+    def get_down_nodes(self):
+        """
+        Get all downstream nodes
+        """
+
+        all_down = [self]
+        if self.down is not None:
+            all_down += self.down.get_down_nodes()
+        
+        return all_down
+
+    def get_down_nodes_same_sub(self):
+        """
+        Get all downstream nodes in the same sub-basin
+        """
+
+        all_down = [self]
+        if self.down is not None:
+            if self.down.sub == self.sub:
+                all_down += self.down.get_down_nodes_same_sub()
+        
+        return all_down
 
 class RiverSystem:
     """
@@ -1716,6 +1785,102 @@ class Watershed:
 
         return newsub
 
+    def get_xy_downstream_node(self, 
+                               starting_node:Node_Watershed,
+                               limit_to_sub:bool = False):
+        """
+        Récupération des coordonnées du noeud aval
+        """
+
+        if limit_to_sub:
+            down = starting_node.get_down_nodes_same_sub()
+        else:
+            down = starting_node.get_down_nodes()
+
+        return [[cur.x, cur.y] for cur in down]
+
+    def get_xy_upstream_node(self, 
+                             starting_node:Node_Watershed, 
+                             limit_to_sub:bool = False, 
+                             limit_to_river:bool = False,
+                             limit_to_runoff:bool = False) -> list[list[float]]:
+        """
+        Récupération des coordonnées des noeuds amont
+        """
+
+        if limit_to_sub:
+
+            if limit_to_river:
+                up = starting_node.get_up_rivernodes_same_sub()
+            elif limit_to_runoff:
+                up = starting_node.get_up_runoff_nodes_same_sub()
+            else:
+                up, all_river, all_runoff = starting_node.get_up_nodes_same_sub()
+
+        else:
+            if limit_to_river:
+                up = starting_node.get_up_rivernodes()
+            elif limit_to_runoff:
+                up = starting_node.get_up_runoff_nodes()
+            else:
+                up, all_river, all_runoff = starting_node.get_up_nodes()
+
+        return [[cur.x, cur.y] for cur in up]
+    
+    def get_array_from_upstream_node(self, 
+                                     starting_node:Node_Watershed, 
+                                     limit_to_sub:bool = False):
+        """
+        Récupération de l'array à partir d'un noeud amont
+        """
+
+        up = self.get_xy_upstream_node(starting_node, limit_to_sub=limit_to_sub)
+
+        xmin = min([x[0] for x in up])
+        xmax = max([x[0] for x in up])
+        ymin = min([x[1] for x in up])
+        ymax = max([x[1] for x in up])
+
+        newhead = header_wolf()
+        newhead.dx = self.header.dx
+        newhead.dy = self.header.dy
+
+        newhead.origx = xmin - self.header.dx/2. - self.header.dx
+        newhead.origy = ymin - self.header.dy/2. - self.header.dy
+
+        newhead.nbx = int(np.ceil((xmax - xmin) / self.header.dx) + 3)
+        newhead.nby = int(np.ceil((ymax - ymin) / self.header.dy) + 3)
+
+        if newhead.nbx == 0 or newhead.nby == 0:
+            logging.error(_('No upstream nodes found!'))
+            return None
+
+        newarray = WolfArray(srcheader=newhead)
+        newarray.array[:,:] = 0.
+
+        ij = newhead.xy2ij_np(up)
+
+        newarray.array[ij[:,0], ij[:,1]] = 1.
+
+        newarray.mask_data(0.)
+
+        return newarray
+    
+    def get_vector_from_upstream_node(self, 
+                                      starting_node:Node_Watershed,
+                                      limit_to_sub:bool = False):
+        """ Return a vector contouring the upstream area """
+
+        up_array = self.get_array_from_upstream_node(starting_node, limit_to_sub=limit_to_sub)
+
+        if up_array is None:
+            return None
+
+        __, __, vect, __ = up_array.suxsuy_contour()
+
+        vect.find_minmax()
+        return vect
+
     def get_subwatershed(self, idx_sorted_or_name:int | str) -> SubWatershed:
         """
         Récupération d'un sous-bassin sur base de l'index trié

wolfhece/wolf_array.py

@@ -357,12 +357,23 @@ class header_wolf():
         :return : numpy array containing (i, j, [k]) indices - shape (n, 2) or (n, 3)
         """
 
-        locxy = xy.copy()
+        if isinstance(xy,tuple):
+            if len(xy) == 2:
+                if (isinstance(xy[0],np.ndarray)) and (isinstance(xy[1],np.ndarray)):
+                    if len(xy[0]) == len(xy[1]):
+                        locxy = np.vstack((xy[0], xy[1])).T
+                        logging.warning(_('get_ij_from_xy_array - xy is a tuple of 2 arrays, it is converted to a 2D array'))
+            else:
+                locxy = np.array(xy)
+        elif isinstance(xy,list):
+            locxy = np.array(xy)
+        else:
+            locxy = xy.copy()
 
         if forcedims2:
-            locij = np.zeros((xy.shape[0],2), dtype=np.int32)
+            locij = np.zeros((locxy.shape[0],2), dtype=np.int32)
         else:
-            locij = np.zeros(xy.shape, dtype=np.int32)
+            locij = np.zeros(locxy.shape, dtype=np.int32)
 
         locxy[:,0] -= self.origx
         locxy[:,1] -= self.origy
@@ -446,7 +457,7 @@ class header_wolf():
         """
         Converts array coordinates (numpy cells) to this array's world coodinates.
 
-        :param ij = numpy array containing (i, j, [k]) indices
+        :param ij = numpy array containing (i, j, [k]) indices - shape (n, 2) or (n, 3)
         :param scale = scaling of the spatial resolution (dx,dy,[dz])
         :param aswolf = if True, input is one-based (as Wolf VB6 or Fortran), otherwise 0-based (default Python standard)
         :param abs = if True, add translation to results (x, y, [z]) (coordinate to global space)
@@ -464,7 +475,18 @@ class header_wolf():
                     if len(ij[0]) == len(ij[1]):
                         ij = np.vstack((ij[0], ij[1])).T
                         logging.warning(_('get_xy_from_ij_array - ij is a tuple of 2 arrays, it is converted to a 2D array'))
-
+            else:
+                ij = np.array(ij)
+        
+        elif isinstance(ij,list):
+            if len(ij) == 2:
+                if (isinstance(ij[0],np.ndarray)) and (isinstance(ij[1],np.ndarray)):
+                    if len(ij[0]) == len(ij[1]):
+                        ij = np.vstack((ij[0], ij[1])).T
+                        logging.warning(_('get_xy_from_ij_array - ij is a list of 2 arrays, it is converted to a 2D array'))
+            else:
+                ij = np.array(ij)
+            
         if abs:
             tr_x = self.translx
             tr_y = self.transly
@@ -529,7 +551,7 @@ class header_wolf():
 
         :return : numpy array containing (i, j, [k]) indices - shape (n, 2) or (n, 3)
         """
-        return self.get_xy_from_ij_array(xy, scale, aswolf, abs)
+        return self.get_ij_from_xy_array(xy, scale, aswolf, abs)
 
     def xyz2ijk_np(self, xyz:np.ndarray, scale:float=1., aswolf:bool=False, abs:bool=True) -> np.ndarray:
         """ alias for get_xy_from_ij_array """
@@ -1192,8 +1214,10 @@ class Ops_Array(wx.Frame):
         self.vectmp = vector(name='tmp')
         self.fnsave = ''
 
-        self.myzonetmp.add_vector(self.vectmp)
-        self.myzones.add_zone(self.myzonetmp)
+        self.myzonetmp.add_vector(self.vectmp, forceparent=True)
+        self.myzones.add_zone(self.myzonetmp, forceparent=True)
+
+        self.myzones.mapviewer = mapviewer
 
         if self.wx_exists:
             self.set_GUI()
@@ -2123,14 +2147,22 @@ class Ops_Array(wx.Frame):
     def OnManageVectors(self, event:wx.MouseEvent):
         """ Open vector manager  """
 
+        self.show_structure_OpsVectors()
+
+    def show_structure_OpsVectors(self):
+        """ Show the structure of the vector manager """
+
         if self.mapviewer is not None:
             if self.mapviewer.linked:
+                # The viewer is linked to other viewers
                 if self.mapviewer.link_shareopsvect:
-                        if self.myzones.get_mapviewer() in self.mapviewer.linkedList:
-                            self.myzones.showstructure()
-                        return
+                    # The viewer shares the vector manager with the other viewers
+                    if self.myzones.get_mapviewer() in self.mapviewer.linkedList:
+                        # The viewer is in the active linked viewers
+                        self.myzones.showstructure()
+                    return
 
-        self.myzones.showstructure()
+        self.myzones.showstructure()   
 
     def OnLoadvec(self, event:wx.MouseEvent):
         """ Load vector file """
@@ -2593,6 +2625,12 @@ class SelectionData():
         self.hideselection = False
         self.numlist_select = 0 # OpenGL list index
 
+    def set_selection_from_list_xy(self, xylist: list[tuple[float, float]]):
+        """ Set the current selection from a list of (x, y) coordinates """
+
+        self.myselection = xylist
+        self.update_nb_nodes_selection()
+
     @property
     def dx(self) -> float:
         """ Resolution in x """
@@ -4285,6 +4323,11 @@ class WolfArray(Element_To_Draw, header_wolf):
 
         return self.mngselection
 
+    @property
+    def Operations(self) -> Ops_Array:
+        """ Return the operations on the array """
+        return self.myops
+
     @property
     def active_blocks(self) -> list["WolfArray"]:
         """ Return the active blocks """
@@ -7663,7 +7706,7 @@ class WolfArrayMB(WolfArray):
         """
 
         if copyarray:
-            arr = WolfArray(mold=arr)
+            arr = WolfArray(mold=arr, nullvalue=arr.nullvalue)
             force_idx = True
 
         if force_idx:

wolfhece/wolfresults_2D.py

@@ -2459,14 +2459,14 @@ class Wolfresults_2D(Element_To_Draw):
 
         if self.nb_blocks>1 or force_mb:
 
-            retarray = WolfArrayMB()
+            retarray = WolfArrayMB(nullvalue=self[0].nullvalue)
             retarray.set_header(self.get_header())
             for i in range(self.nb_blocks):
                 retarray.add_block(self[i], copyarray=copyarray)
 
         else:
             if copyarray :
-                retarray = WolfArray(mold=self[0])
+                retarray = WolfArray(mold=self[0], nullvalue=self[0].nullvalue)
             else:
                 retarray = self[0]
 
@@ -2824,6 +2824,24 @@ class Wolfresults_2D(Element_To_Draw):
             block.k.array, block.eps.array = wolfpy.r2d_getturbresults(which_step+1, nbx, nby, whichblock)
             block._force_update_shields = True
 
+    def _read_oneblockresult_withoutmask_only_h(self, which_step:int=-1,whichblock:int=-1):
+        """
+        Lecture d'un résultat pour un bloc spécifique --> utilisation de la librairie Fortran
+
+        :param which_step : timestep ; 0-based; -1 == last one
+        :param whichblock : block index
+        """
+        which_step = self._sanitize_result_step(which_step)
+
+        if whichblock!=-1:
+            block = self.myblocks[getkeyblock(whichblock,False)]
+            nbx = block.waterdepth.nbx
+            nby = block.waterdepth.nby
+
+            # Fortran is 1-based --> which_step+1
+            block.waterdepth.array, block.qx.array, block.qy.array = wolfpy.r2d_getresults(which_step+1, nbx, nby, whichblock)
+            block._force_update_shields = True
+
     def read_oneblockresult(self, which_step:int=-1, whichblock:int=-1):
         """
         Lecture d'un résultat pour un bloc spécifique et application d'un masque sur base d'nu epsilon de hauteur d'eau
@@ -2861,6 +2879,29 @@ class Wolfresults_2D(Element_To_Draw):
             self.myblocks[getkeyblock(whichblock,False)].k.set_nullvalue_in_mask()
             self.myblocks[getkeyblock(whichblock,False)].eps.set_nullvalue_in_mask()
 
+    def _read_oneblockresult_only_h(self, which_step:int=-1, whichblock:int=-1):
+        """
+        Lecture d'un résultat pour un bloc spécifique et application d'un masque sur base d'nu epsilon de hauteur d'eau
+
+        which_step: result number to read ; 0-based; -1 == last one
+        whichblock : block index ; 1-based
+        """
+
+        which_step = self._sanitize_result_step(which_step)
+
+        if whichblock!=-1:
+
+            self._read_oneblockresult_withoutmask_only_h(which_step, whichblock)
+
+            if self.epsilon > 0.:
+                self.myblocks[getkeyblock(whichblock,False)].waterdepth.array=ma.masked_less_equal(self.myblocks[getkeyblock(whichblock,False)].waterdepth.array,self.epsilon)
+            else:
+                self.myblocks[getkeyblock(whichblock,False)].waterdepth.array=ma.masked_equal(self.myblocks[getkeyblock(whichblock,False)].waterdepth.array,0.)
+
+            self.myblocks[getkeyblock(whichblock,False)].waterdepth.count()
+
+            self.myblocks[getkeyblock(whichblock,False)].waterdepth.set_nullvalue_in_mask()
+
     def read_oneresult(self, which:int=-1):
         """
         Lecture d'un pas de sauvegarde
@@ -2884,6 +2925,29 @@ class Wolfresults_2D(Element_To_Draw):
         self.current_result = which
         self.loaded=True
 
+    def _read_oneresult_only_h(self, which:int=-1):
+        """
+        Lecture d'un pas de sauvegarde
+
+        :param which: result number to read; 0-based; -1 == last one
+        """
+
+        which = self._sanitize_result_step(which)
+
+        if exists(self.filename+'.head'):
+            logging.info(_('Reading from results - step :{}'.format(which+1)))
+            wolfpy.r2d_init(self.filename.ljust(255).encode('ansi'))
+            for i in range(self.nb_blocks):
+                self._read_oneblockresult_only_h(which, i+1)
+        else:
+            logging.info(_('No ".head" file --> Initial Conditions'))
+
+        if self.to_filter_independent:
+            self.filter_independent_zones()
+
+        self.current_result = which
+        self.loaded=True
+
     def read_next(self):
         """
         Lecture du pas suivant
@@ -4055,6 +4119,12 @@ class Wolfresults_2D(Element_To_Draw):
     def danger_map(self, start:int=0, end:int=-1, every:int=1) -> Union[tuple[WolfArray, WolfArray, WolfArray], tuple[WolfArrayMB, WolfArrayMB, WolfArrayMB]]:
         """
         Create Danger Maps
+
+        :param start: start time step - 0-based
+        :param end: end time step - 0-based
+        :param every: step interval
+
+        :return : tuple of WolfArray or WolfArrayMB - H, U_norm, Q_norm
         """
 
         # Number of  time steps
@@ -4069,38 +4139,38 @@ class Wolfresults_2D(Element_To_Draw):
         danger_map_matrix_v = self.as_WolfArray(copyarray=True)
         danger_map_matrix_mom = self.as_WolfArray(copyarray=True)
 
-        # Reset data -> Set null values
-        danger_map_matrix_h.reset()
-        danger_map_matrix_v.reset()
-        danger_map_matrix_mom.reset()
-
-        danger_map_matrix_h.mask_reset()
-        danger_map_matrix_v.mask_reset()
-        danger_map_matrix_mom.mask_reset()
-
         danger = [danger_map_matrix_h, danger_map_matrix_v, danger_map_matrix_mom]
 
+        for curdanger in danger:
+            curdanger.nullvalue = 0.
+            curdanger.reset()
+            curdanger.mask_reset()
+
         for time_step in tqdm(range(start, end, every)):
 
             self.read_oneresult(time_step+1)
 
             if self.nb_blocks>1:
                 for curblock in self.myblocks.keys():
+
                     # Get WolfArray
                     wd = self.get_h_for_block(curblock)
                     qx = self.get_qx_for_block(curblock)
                     qy = self.get_qy_for_block(curblock)
 
-                    # Math operations are overloaded
-                    v = (qx**2.+qy**2.)**.5/wd
-                    mom = v*wd
+                    ij = np.where(~wd.array.mask)
 
-                    comp = [wd, v, mom]
+                    # 
+                    mom = np.zeros_like(wd.array)
+                    v   = np.zeros_like(wd.array)
+                    mom[ij] = (qx.array[ij]**2.+qy.array[ij]**2.)**.5
+                    v[ij]   = mom[ij]/wd.array[ij]
 
                     # Comparison
-                    for curdanger, curcomp in zip(danger, comp):
-                        i,j = np.where(curdanger.myblocks[curblock].array < curcomp.array)
-                        curdanger.myblocks[curblock].array.data[i,j] = curcomp.array.data[i,j]
+                    for curdanger, curcomp in zip(danger, [wd.array, v, mom]):
+                        ij = np.where((curdanger.array < curcomp) & (~wd.array.mask))
+                        curdanger.array.data[ij] = curcomp[ij]
+                        curdanger.array.mask[ij] = False
 
             else:
                 curblock = getkeyblock(0)
@@ -4108,25 +4178,84 @@ class Wolfresults_2D(Element_To_Draw):
                 qx = self.get_qx_for_block(curblock)
                 qy = self.get_qy_for_block(curblock)
 
-                v = (qx**2.+qy**2.)**.5/wd
-
-                mom = v*wd
+                ij = np.where(~wd.array.mask)
 
-                comp = [wd, v, mom]
+                # 
+                mom = np.zeros_like(wd.array)
+                v   = np.zeros_like(wd.array)
+                mom[ij] = (qx.array[ij]**2.+qy.array[ij]**2.)**.5
+                v[ij]   = mom[ij]/wd.array[ij]
 
                 # Comparison
-                for curdanger, curcomp in zip(danger, comp):
-                    i,j = np.where(curdanger.array < curcomp.array)
-                    curdanger.array.data[i,j] = curcomp.array.data[i,j]
+                for curdanger, curcomp in zip(danger, [wd.array, v, mom]):
+                    ij = np.where((curdanger.array < curcomp) & (~wd.array.mask))
+                    curdanger.array.data[ij] = curcomp[ij]
+                    curdanger.array.mask[ij] = False
 
         danger_map_matrix_h.mask_lower(self.epsilon)
+
         if self.nb_blocks>1:
             for i in range(self.nb_blocks):
-                danger_map_matrix_v[i].array.mask = danger_map_matrix_h[i].array.mask.copy()
-                danger_map_matrix_mom[i].array.mask = danger_map_matrix_h[i].array.mask.copy()
+                danger_map_matrix_v[i].array.mask[:,:] = danger_map_matrix_h[i].array.mask[:,:]
+                danger_map_matrix_mom[i].array.mask[:,:] = danger_map_matrix_h[i].array.mask[:,:]
         else:
-            danger_map_matrix_v.array.mask = danger_map_matrix_h.array.mask.copy()
-            danger_map_matrix_mom.array.mask = danger_map_matrix_h.array.mask.copy()
+            danger_map_matrix_v.array.mask[:,:] = danger_map_matrix_h.array.mask[:,:]
+            danger_map_matrix_mom.array.mask[:,:] = danger_map_matrix_h.array.mask[:,:]
 
 
         return (danger_map_matrix_h, danger_map_matrix_v, danger_map_matrix_mom)
+
+    def danger_map_only_h(self, start:int=0, end:int=-1, every:int=1) -> WolfArray:
+        """
+        Create Danger Maps
+
+        :param start: start time step - 0-based
+        :param end: end time step - 0-based
+        :param every: step interval
+
+        :return : tuple of WolfArray or WolfArrayMB - H, U_norm, Q_norm
+        """
+
+        # Number of  time steps
+        number_of_time_steps = self.get_nbresults()
+        if end ==-1:
+            end = number_of_time_steps
+
+        # Init Danger Maps basde on results type
+        #    If only one block --> WolfArray
+        #    If only multiple blocks --> WolfArrayMB
+        danger_map_matrix_h = self.as_WolfArray(copyarray=True)
+
+        danger_map_matrix_h.nullvalue = 0.
+        danger_map_matrix_h.reset()
+        danger_map_matrix_h.mask_reset()
+
+        for time_step in tqdm(range(start, end, every)):
+
+            self._read_oneresult_only_h(time_step+1)
+
+            if self.nb_blocks>1:
+                for curblock in self.myblocks.keys():
+
+                    # Get WolfArray
+                    wd = self.get_h_for_block(curblock)
+
+                    # Comparison
+                    ij = np.where((danger_map_matrix_h.array < wd.array.data) & (~wd.array.mask))
+                    danger_map_matrix_h.array.data[ij] = wd.array[ij]
+                    danger_map_matrix_h.array.mask[ij] = False
+
+            else:
+                curblock = getkeyblock(0)
+
+                # Get WolfArray
+                wd = self.get_h_for_block(curblock)
+
+                # Comparison
+                ij = np.where((danger_map_matrix_h.array < wd.array.data) & (~wd.array.mask))
+                danger_map_matrix_h.array.data[ij] = wd.array[ij]
+                danger_map_matrix_h.array.mask[ij] = False
+
+        danger_map_matrix_h.mask_lower(self.epsilon)
+
+        return danger_map_matrix_h

{wolfhece-2.1.16.dist-info → wolfhece-2.1.17.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: wolfhece
-Version: 2.1.16
+Version: 2.1.17
 Author-email: Pierre Archambeau <pierre.archambeau@uliege.be>
 License: AGPL-v3 License
 Project-URL: Homepage, https://uee.uliege.be/hece

{wolfhece-2.1.16.dist-info → wolfhece-2.1.17.dist-info}/RECORD

@@ -6,22 +6,22 @@ wolfhece/ManageParams.py,sha256=Wgt5Zh7QBtyiwTAltPHunSLqt4XuVuRH76GTUrXabS4,219
 wolfhece/Model1D.py,sha256=-cMz-ePSYzrKVVDidiDOz6cojEZ3y6u9gIb7RPwT6Y8,476593
 wolfhece/PyConfig.py,sha256=oGSL1WsLM9uinlNP4zGBLK3uHPmBfduUi7R-VtWuRFA,8034
 wolfhece/PyCrosssections.py,sha256=f4dNYRUGZKePruaaBiTcn5vlrw8TFTj9XwTDrdiF_uU,112450
-wolfhece/PyDraw.py,sha256=Kfu3uoxwP6ZK9LqE5Br-GBex_bSS6k4F3tfsK-qIZvU,379565
+wolfhece/PyDraw.py,sha256=ayK8YWZGOj79auURpkHaDCUreOlaAtMVq2ZpuzL3s_Q,383008
 wolfhece/PyGui.py,sha256=fqy8f3tLt7myJskVvspTQ_ZO7kaiSNKmcfFLrfr4w7M,103174
-wolfhece/PyGuiHydrology.py,sha256=wKhR-KthPRyzJ887NmsozmUpm2CIQIwO3IbYORCYjrE,7290
+wolfhece/PyGuiHydrology.py,sha256=r8kcY2eGAQzSwVtLpyMUiBL5xBpMBsi7ovs0PgStGWw,14648
 wolfhece/PyHydrographs.py,sha256=GKK8U0byI45H9O_e4LAOOi7Aw0Tg7Q0Lx322stPg5IQ,3453
 wolfhece/PyPalette.py,sha256=Vl5RrBIC_a5-mZKUtBd5kG0mif946B7OtS3fnehkmOc,25012
-wolfhece/PyParams.py,sha256=V1Pe4rsBpWBA5kI5rRG7B5ijPHAdpM1i2uyxhnrwX94,96896
+wolfhece/PyParams.py,sha256=Aj8kcT044abwBYU_OiEcJWcyNVqxYithNfbzdHyI-QA,97072
 wolfhece/PyPictures.py,sha256=-mJB0JL2YYiEK3D7_ssDkvYiMWK4ve9kXhozQXNeSx8,2216
 wolfhece/PyTranslate.py,sha256=4appkmNeHHZLFmUtaA_k5_5QL-5ymxnbVN4R2OblmtE,622
 wolfhece/PyVertex.py,sha256=dHTjyYYTn0F_NWerlAOBKHV79RUzEEtMJMldQtVc1Cs,40092
-wolfhece/PyVertexvectors.py,sha256=C0uB7MTUeNB3XNxf1R98epvcqoLJIlExvI1zwom48jA,223945
+wolfhece/PyVertexvectors.py,sha256=4K0T74MUH-ycX79hFa2618vKVTu9qOSh49hlbKrydMg,224123
 wolfhece/PyWMS.py,sha256=t6jVZpTxTNSLJxABk8A79cEMWTKoRM_S_SXRipsHLzw,4493
-wolfhece/RatingCurve.py,sha256=YSQvSvdMHE6hSlWVBF5Oe0-Fh3waNMpOdmcymaCCTis,21706
+wolfhece/RatingCurve.py,sha256=f6IGLS5aJBJD_t_k903m_yRZ60MzKNKanzD6njXZxa8,22200
 wolfhece/RatingCurveData.py,sha256=5UvnIm89BwqjnEbLCcY3CA8WoFd_xHJbooNy62fX5iY,57660
 wolfhece/RatingCurve_xml.py,sha256=vbLxSWwHPsCAsR13KaG5WVmVn_cha7-6cF4zj7Diiz8,33593
 wolfhece/ReadDataDCENN.py,sha256=4OMDBgkZ_v7OWmVhyQ-reab7MPxGhFEDY2qS8yThhdM,1240
-wolfhece/Results2DGPU.py,sha256=pC7jHQhzSJPmGiboNNLG619yVYaOUT_O5_yhKMzslxA,20563
+wolfhece/Results2DGPU.py,sha256=-EGeWQcg_XsDh3XOqnuEnFgPSoAD4q0YUjM7u8ESRD8,23038
 wolfhece/__init__.py,sha256=FRDE8PiJAWxX9PMXsShRMZ8YADAY4WIgKMRh52rmhiw,23
 wolfhece/_add_path.py,sha256=nudniS-lsgHwXXq5o626XRDzIeYj76GoGKYt6lcu2Nc,616
 wolfhece/cli.py,sha256=rHxZGgs_R776VCWhs36pYFoiuiQycwgGTVOLK-JNzjE,1937
@@ -48,13 +48,13 @@ wolfhece/rain_SPWMI.py,sha256=YqsF-yFro3y_a6MfVRFfr-Rxi7NR1gl_i8VX7scmzes,13548
 wolfhece/test_Results2DGPU.py,sha256=NOJ_hFXrcLSQXS1dtsqXRQltqIZtDSHMz_EgAJ2_FHU,307
 wolfhece/textpillow.py,sha256=zEfLrKhfCDyMaVuQOUjHqz6MGKeQ4aewMxOsWi5-wKI,13832
 wolfhece/tools_mpl.py,sha256=q8Yc4aukPPiUcEzREvZRM_em67XqXaahdoaNt0DETfE,266
-wolfhece/wolf_array.py,sha256=vf3S7vIdN0ziYtpHSyQRCjwneQCKlGOdCYpZE3xQcLk,335853
+wolfhece/wolf_array.py,sha256=tYzkVd4Zrvr6FotO571IfW6Kkvx9Kli9QnzbiXVwZEo,337760
 wolfhece/wolf_hist.py,sha256=JpRXvzJLUP-RkSkvth3DQWglgTMFI2ZEUDb4RYOfeeI,3284
 wolfhece/wolf_texture.py,sha256=llQ7aV8scWXIkhpri9XjaPejzoBJsGfsln2ZnlRbFkU,16270
 wolfhece/wolf_tiles.py,sha256=F2JsJHdAP8fIffNJdG_J26bonCIRtIwMmxKFqdSCRDA,10088
 wolfhece/wolf_vrt.py,sha256=un5CKzAUmzSsjLXK7YLnQEWz8FLoafXJs8oqUvS_-h0,10271
 wolfhece/wolf_zi_db.py,sha256=Ok0MxQYZMMLRJN1QY-HSplLhUzzb6gkXgBQ3ihhLQHk,12669
-wolfhece/wolfresults_2D.py,sha256=6VbONzD2lMFCnZ2-gyBk7pW9LcBmSWkZxiVLTMKVPIQ,159403
+wolfhece/wolfresults_2D.py,sha256=6CkXD_X4pOBFce0nFZjR6VjKzLKSYqqY4UhXKzzrKuM,164515
 wolfhece/xyz_file.py,sha256=aQOcTHkHRhXHxL_WxTHwzygp6e47San7SHSpxKQU0dw,5457
 wolfhece/apps/ManageParams.py,sha256=heg5L4fMn0ettR7Bad_Q680o_JWnTbe3WFkL_9IziAk,312
 wolfhece/apps/Optimisation_hydro.py,sha256=mHazBazTUGyxPbHPXhaQim8vqIeOOuKPjH0B48VWduA,374
@@ -66,7 +66,7 @@ wolfhece/apps/check_install.py,sha256=jrKR-njqnpIh6ZJqvP6KbDUPVCfwTNQj4glQhcyzs9
 wolfhece/apps/curvedigitizer.py,sha256=avWERHuVxPnJBOD_ibczwW_XG4vAenqWS8W1zjhBox8,4898
 wolfhece/apps/isocurrent.py,sha256=4XnNWPa8mYUK7V4zdDRFrHFIXNG2AN2og3TqWKKcqjY,3811
 wolfhece/apps/splashscreen.py,sha256=LkEVMK0eCc84NeCWD3CGja7fuQ_k1PrZdyqD3GQk_8c,2118
-wolfhece/apps/version.py,sha256=Au2GSzDykgzYPAppTSSnywndJOLWVYMTR2cNQ5pYAeU,388
+wolfhece/apps/version.py,sha256=YX9tmGcv0oDZgHzLyJ-fs3F4ENyIBZMuarvn4elQtAo,388
 wolfhece/apps/wolf.py,sha256=gqfm-ZaUJqNsfCzmdtemSeqLw-GVdSVix-evg5WArJI,293
 wolfhece/apps/wolf2D.py,sha256=gWD9ee2-1pw_nUxjgRaJMuSe4kUT-RWhOeoTt_Lh1mM,267
 wolfhece/apps/wolf_logo.bmp,sha256=ruJ4MA51CpGO_AYUp_dB4SWKHelvhOvd7Q8NrVOjDJk,3126
@@ -102,7 +102,7 @@ wolfhece/hydrology/Dumping.py,sha256=GKYvkKgCfJQT1XEF1ceh7evdhlpZRPcuf6VlBdH-TaM
 wolfhece/hydrology/Optimisation.py,sha256=JD72GXAWL6fwagCrCVb0qMEFuYvUlO1vDigteV4EIuA,142220
 wolfhece/hydrology/Outlet.py,sha256=fpetH2ZKnTKIBNuVclxrncc5OAxWUGI5_ed9gXh6fD4,10201
 wolfhece/hydrology/PostProcessHydrology.py,sha256=SiW5FIf8FeQL9ItWG8ODt612k5m59aogSLgpsXinr8I,6944
-wolfhece/hydrology/PyWatershed.py,sha256=NO2f4XVA8JxW06ysUhlAN4VYVlv3oCqhhyQ8BeTC7d4,92823
+wolfhece/hydrology/PyWatershed.py,sha256=VC38Cglf23yD9lz5u5xy5lxYI9c1FW8ZLd2tmKF_d1Y,97928
 wolfhece/hydrology/RetentionBasin.py,sha256=cV-Rn-Ya7vWHnkl6pHcQ8GFx5HX-wM7uHI4_Zry-kks,82605
 wolfhece/hydrology/SubBasin.py,sha256=b5RawgPmfVWUJhkv-nEVSbdN3ytIxpov7kjBSvMrd1c,171159
 wolfhece/hydrology/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -267,8 +267,8 @@ wolfhece/sounds/sonsw2.wav,sha256=pFLVt6By0_EPQNt_3KfEZ9a1uSuYTgQSX1I_Zurv9Rc,11
 wolfhece/ui/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 wolfhece/ui/wolf_multiselection_collapsiblepane.py,sha256=yGbU_JsF56jsmms0gh7mxa7tbNQ_SxqhpAZxhm-mTy4,14860
 wolfhece/ui/wolf_times_selection_comparison_models.py,sha256=wCxGRnE3kzEkWlWA6-3X8ADOFux_B0a5QWJ2GnXTgJw,4709
-wolfhece-2.1.16.dist-info/METADATA,sha256=vRdgkIGgAYvpxLhBEtKJH3C_oax5iHhWg1ryYEr1tC4,2282
-wolfhece-2.1.16.dist-info/WHEEL,sha256=y4mX-SOX4fYIkonsAGA5N0Oy-8_gI4FXw5HNI1xqvWg,91
-wolfhece-2.1.16.dist-info/entry_points.txt,sha256=AIu1KMswrdsqNq_2jPtrRIU4tLjuTnj2dCY-pxIlshw,276
-wolfhece-2.1.16.dist-info/top_level.txt,sha256=EfqZXMVCn7eILUzx9xsEu2oBbSo9liWPFWjIHik0iCI,9
-wolfhece-2.1.16.dist-info/RECORD,,
+wolfhece-2.1.17.dist-info/METADATA,sha256=jWnXOeve-xUr_A3ZHX9uCTDFNr8GVLlUTepoSZN0HD0,2282
+wolfhece-2.1.17.dist-info/WHEEL,sha256=y4mX-SOX4fYIkonsAGA5N0Oy-8_gI4FXw5HNI1xqvWg,91
+wolfhece-2.1.17.dist-info/entry_points.txt,sha256=AIu1KMswrdsqNq_2jPtrRIU4tLjuTnj2dCY-pxIlshw,276
+wolfhece-2.1.17.dist-info/top_level.txt,sha256=EfqZXMVCn7eILUzx9xsEu2oBbSo9liWPFWjIHik0iCI,9
+wolfhece-2.1.17.dist-info/RECORD,,