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

wolfhece/PyDraw.py

@@ -1732,10 +1732,10 @@ class WolfMapViewer(wx.Frame):
         self.treewidth = 200  # largeur de la zone d'arbre "treelist"
 
         self.backcolor = wx.Colour(255, 255, 255)  # couleur de fond
-        self.mousedown = (0., 0.)  # position initiale du bouton position bas
-        self.mouseup = (0., 0.)  # position initiale du bouton position haut
+        self.mousedown = (-99999., -99999.)  # position initiale du bouton position bas
+        # self.mouseup   = (-99999., -99999.)  # position initiale du bouton position haut
         self.oneclick = True  # détection d'un simple click ou d'un double-click
-        self.move = False  # la souris est-elle en train de bouger?
+        # self.move = False  # la souris est-elle en train de bouger?
 
         self.linked = False
         self.link_shareopsvect = True
@@ -2553,6 +2553,7 @@ class WolfMapViewer(wx.Frame):
             self.menuwolf2d.AppendSeparator()
 
             self.menu2d_dangermap = self.menuwolf2d.Append(wx.ID_ANY, _("Danger map"), _("Compute the danger map"))
+            # self.menu2d_dangermap_mp = self.menuwolf2d.Append(wx.ID_ANY, _("Danger map (multiprocess)"), _("Compute the danger map using multiprocessing -- Need to duplicate the model, the memory usage can be very high for large model"))
             self.menu2d_dangermaph = self.menuwolf2d.Append(wx.ID_ANY, _("Danger map - only h"), _("Compute the danger map - only waterdepth"))
 
             self.menuwolf2d.AppendSeparator()
@@ -2992,7 +2993,7 @@ class WolfMapViewer(wx.Frame):
 
             danger_map.write_all(Path(outdir) / 'danger_h.tif')
 
-        elif itemlabel == _("Danger map"):
+        elif itemlabel in [_("Danger map"), _("Danger map (multiprocess)")]:
             if self.active_res2d is None:
                 logging.warning(_('No active 2D result !'))
                 return
@@ -3018,16 +3019,19 @@ class WolfMapViewer(wx.Frame):
 
                 every = dlg.GetValue()
 
-            pgbar = wx.ProgressDialog(_('Danger map'), _('Danger map'), maximum = end_step-1, parent=self, style = wx.PD_APP_MODAL | wx.PD_AUTO_HIDE)
-            def _callback(id, msg):
-                pgbar.Update(id+1-start_step, msg)
+            if itemlabel == _("Danger map"):
+                pgbar = wx.ProgressDialog(_('Danger map'), _('Danger map'), maximum = end_step-1, parent=self, style = wx.PD_APP_MODAL | wx.PD_AUTO_HIDE)
+                def _callback(id, msg):
+                    pgbar.Update(id+1-start_step, msg)
 
-            danger_maps = self.active_res2d.danger_map(start_step-1, end_step-1, every, _callback)
+                danger_maps = self.active_res2d.danger_map_multiprocess(start_step-1, end_step-1, every, _callback)
 
-            pgbar.Hide()
-            pgbar.Destroy()
+                pgbar.Hide()
+                pgbar.Destroy()
+            else:
+                danger_maps = self.active_res2d.danger_map_multiprocess(start_step-1, end_step-1, every)
 
-            with wx.DirDialog(None, _('Choose a directory'), style=wx.DD_DEFAULT_STYLE) as dlg:
+            with wx.DirDialog(None, _('Choose a directory to store results'), style=wx.DD_DEFAULT_STYLE) as dlg:
 
                 if dlg.ShowModal() == wx.ID_CANCEL:
                     return
@@ -4511,16 +4515,16 @@ class WolfMapViewer(wx.Frame):
 
         self.canvas.Bind(wx.EVT_CHAR_HOOK, self.OnHotKey)
 
-        self.canvas.Bind(wx.EVT_BUTTON, self.OnButton)
-        self.canvas.Bind(wx.EVT_RIGHT_DCLICK, self.OnRDClick)
-        self.canvas.Bind(wx.EVT_LEFT_DCLICK, self.OnLDClick)
-        self.canvas.Bind(wx.EVT_LEFT_DOWN, self.OnLDown)
-        self.canvas.Bind(wx.EVT_MIDDLE_DOWN, self.OnLDown)
-        self.canvas.Bind(wx.EVT_RIGHT_DOWN, self.OnRightDown)
-        self.canvas.Bind(wx.EVT_RIGHT_UP, self.OnRightUp)
-        self.canvas.Bind(wx.EVT_MOTION, self.OnMotion)
+        self.canvas.Bind(wx.EVT_BUTTON, self.On_Mouse_Button)
+        self.canvas.Bind(wx.EVT_RIGHT_DCLICK, self.On_Right_Double_Clicks)
+        self.canvas.Bind(wx.EVT_LEFT_DCLICK, self.On_Left_Double_Clicks)
+        self.canvas.Bind(wx.EVT_LEFT_DOWN, self.On_Mouse_Left_Down)
+        self.canvas.Bind(wx.EVT_MIDDLE_DOWN, self.On_Mouse_Left_Down)
+        self.canvas.Bind(wx.EVT_RIGHT_DOWN, self.On_Mouse_Right_Down)
+        self.canvas.Bind(wx.EVT_RIGHT_UP, self.On_Mouse_Right_Up)
+        self.canvas.Bind(wx.EVT_MOTION, self.On_Mouse_Motion)
         self.canvas.Bind(wx.EVT_LEAVE_WINDOW, self.OnLeave)
-        self.canvas.Bind(wx.EVT_MOUSEWHEEL, self.OnButton)
+        self.canvas.Bind(wx.EVT_MOUSEWHEEL, self.On_Mouse_Button)
 
         self.treelist.Bind(dataview.EVT_TREELIST_ITEM_CHECKED, self.OnCheckItem)
         self.treelist.Bind(dataview.EVT_TREELIST_ITEM_ACTIVATED, self.OnActivateTreeElem)
@@ -10936,7 +10940,7 @@ class WolfMapViewer(wx.Frame):
         self.myfigprof.cs_setter(mycross = self.active_cs, active_profile= self.active_profile, mapviewer = self)
 
 
-    def OnRightDown(self, e: wx.MouseEvent):
+    def On_Mouse_Right_Down(self, e: wx.MouseEvent):
         """
         Event when the right button of the mouse is pressed.
 
@@ -11361,7 +11365,7 @@ class WolfMapViewer(wx.Frame):
             self.rightdown = (x, y)
 
 
-    def OnRightUp(self, e):
+    def On_Mouse_Right_Up(self, e):
         pos = e.GetPosition()
         x, y = self.getXY(pos)
 
@@ -11389,7 +11393,7 @@ class WolfMapViewer(wx.Frame):
                 except:
                     pass
 
-    def OnButton(self, e: wx.MouseEvent):
+    def On_Mouse_Button(self, e: wx.MouseEvent):
         d = e.GetWheelDelta()
         r = e.GetWheelRotation()
         a = e.GetWheelAxis()
@@ -11457,10 +11461,10 @@ class WolfMapViewer(wx.Frame):
         # will translate and rescale the map view so that it fits the window.
         self.setbounds()
 
-    def OnRDClick(self, e):
+    def On_Right_Double_Clicks(self, e):
         self._endactions()
 
-    def OnLDClick(self, e:wx.MouseEvent):
+    def On_Left_Double_Clicks(self, e:wx.MouseEvent):
         pos = e.GetPosition()
 
         ctrldown = e.ControlDown()
@@ -11469,9 +11473,12 @@ class WolfMapViewer(wx.Frame):
 
         x, y = self.getXY(pos)
 
-        self.mousex = self.mousedown[0]
-        self.mousey = self.mousedown[1]
-        # self.mousedown = (0., 0.)
+        if self.mousedown[0] == -99999:
+            # Manage the case when the user double click rapidly on the map
+            # self.mousedown can not be set in On_Mouse_Left_Down
+            self.mousedown = (x, y)
+
+        self.mousex, self.mousey = self.mousedown
         self.oneclick = False
         self.setbounds()
 
@@ -11493,13 +11500,14 @@ class WolfMapViewer(wx.Frame):
                     if self.active_laz.viewer is not None:
                         self.active_laz.force_view(self.mousex, self.mousey)
 
-    def OnLDown(self, e):
+    def On_Mouse_Left_Down(self, e):
+        """ Event when the left button of the mouse is pressed """
 
-        if not self.move:
-            pos = e.GetPosition()
-            x, y = self.getXY(pos)
-            self.mousedown = (x, y)
-            self.move=True
+        # if not self.move:
+        pos = e.GetPosition()
+        x, y = self.getXY(pos)
+        self.mousedown = (x, y)
+        # self.move = True
 
     def _set_active_bc(self):
         """Search and activate BCManager according to active_array"""
@@ -11973,23 +11981,33 @@ class WolfMapViewer(wx.Frame):
         self.mytooltip.PopulateOnePage()
 
 
-    def OnMotion(self, e: wx.MouseEvent):
+    def On_Mouse_Motion(self, e: wx.MouseEvent):
         """ Mouse move event """
 
         # Déplacement de la souris sur le canvas OpenGL
-        posframe = self.GetPosition()
-        pos = e.GetPosition()
-        x, y = self.getXY(pos)
-        altdown = e.AltDown()
-        shiftdown = e.ShiftDown()
+        posframe = self.GetPosition() # Get the position of the frame -> useful to set the tooltip position
+        pos = e.GetPosition() # Get the position of the mouse in the canvas
+        x, y = self.getXY(pos) # Get the coordinates of the mouse in the map
+        altdown = e.AltDown()       # Alt key pressed
+        shiftdown = e.ShiftDown()   # Shift key pressed
 
         if e.LeftIsDown() or e.MiddleIsDown():
+            # Left mouse button or middle mouse button is pressed
+            #
+            # Moving the map relative to the position where the mouse was clicked
+            # the first time
+
+            if self.mousedown[0] == -99999: # only if the mouse was clicked before
+                self.mousedown = [x, y]
+
             self.mousex -= x - self.mousedown[0]
             self.mousey -= y - self.mousedown[1]
 
-            self.setbounds(False)
+            self.setbounds(updatescale = False)
             return
+
         elif e.RightIsDown():
+            # Right mouse button is pressed
             if self.action == 'select bc':
                 if self.active_vector is None:
 
@@ -12002,7 +12020,10 @@ class WolfMapViewer(wx.Frame):
                                                wolfvertex(x,self.rightdown[1]),
                                                wolfvertex(self.rightdown[0],self.rightdown[1])]
         else:
-            self.move=False
+            # No mouse button is pressed
+            # self.move=False
+            self.mousedown = (-99999, -99999)
+            # self.mouseup   = (-99999, -99999)
 
         if self.action is not None:
 
@@ -12112,10 +12133,14 @@ class WolfMapViewer(wx.Frame):
 
             self.Paint()
 
+        # Store the position of the mouse as last known position
         self._last_mouse_pos = (x,y,pos)
+
+        # Update the tooltip with the values of the active arrays and results at position x,y
         self._update_mytooltip()
 
         if e.ControlDown():
+            # Control key is pressed, so the tooltip must be near the mouse position
             if self._oldpos_tooltip is None:
                 # Store the position of the tooltip
                 # Useful to restore it after CTRL is released
@@ -12165,6 +12190,7 @@ class WolfMapViewer(wx.Frame):
                 # self.mytooltip.SetIcon(self.GetIcon()) # update icon
                 self.mytooltip.SetWindowStyle(wx.DEFAULT_FRAME_STYLE) # | wx.STAY_ON_TOP) # on top, with Title bar
 
+            #Force to show the tooltip --> useful when the tooltip was hidden by the user
             self.mytooltip.Show(True)
 
         e.Skip()
@@ -12383,6 +12409,16 @@ class WolfMapViewer(wx.Frame):
         """ Check for updates """
         from .apps.version import WolfVersion
         import requests
+        import importlib.metadata
+
+        # check_gpu = False
+        # try:
+        #     import wolfgpu
+        #     check_gpu = True
+        # except:
+        #     pass
+
+        msg = ''
 
         current_version = str(WolfVersion())
         package_name = "wolfhece"
@@ -12391,15 +12427,42 @@ class WolfMapViewer(wx.Frame):
             available_version = requests.get(f"https://pypi.org/pypi/{package_name}/json").json()["info"]["version"]
 
             if available_version > current_version:
-                with wx.MessageDialog(None, _("A new version is available: {}\n\nYour version is {}\n\nIf you want to upgrade, 'pip install wolfhece --upgrade' from your Python environment.").format(available_version, current_version), _("Upgrade"), wx.OK | wx.ICON_INFORMATION) as dlg:
-                    dlg.ShowModal()
+                msg += _("A new version is available: {}\n\nYour version is {}\n\nIf you want to upgrade, 'pip install wolfhece --upgrade' from your Python environment.").format(available_version, current_version)
             else:
-                with wx.MessageDialog(None, _("You have the latest version."), _("Upgrade"), wx.OK | wx.ICON_INFORMATION) as dlg:
-                    dlg.ShowModal()
+                msg += _("You have the latest version.")
 
         except Exception as e:
             logging.error("Package not found on PyPI. -- {}".format(e))
 
+        # if check_gpu:
+        #     # find the version
+        #     package_name = "wolfgpu"
+        #     current_version = importlib.metadata.version(package_name)
+        #     url_wolfgpu = "https://gitlab.uliege.be/api/v4/projects/4180/packages/pypi/simple/" #+ package_name
+        #     try:
+        #         response = requests.get(url_wolfgpu).json()
+        #         update_wolfgpu = False
+        #         #parcourir toutes le entrées et ne conserver que la version la plus récente
+        #         for one in response:
+        #             one["version"] > current_version
+        #             update_wolfgpu = True
+
+        #         if update_wolfgpu:
+        #             msg += '\n'
+        #             msg += _("A new version of WolfGPU is available: {}.{}.{}, please update it.").format(current_version[0], current_version[1], current_version[2])
+        #         else:
+        #             msg += '\n'
+        #             msg+= _("You have the latest version of WolfGPU.")
+
+        #     except Exception as e:
+        #         logging.error("Package not found on PyPI. -- {}".format(e))
+
+        msg+= '\n\n'
+        msg+= _('If you use wolfgpu, please check the GPU version independently.')
+
+        with wx.MessageDialog(None, msg, _("Upgrade"), wx.OK | wx.ICON_INFORMATION) as dlg:
+            dlg.ShowModal()
+
     def print_shortcuts(self, inframe:bool = None):
         """ Print the list of shortcuts into logging """
 

wolfhece/PyGui.py

@@ -3669,6 +3669,9 @@ class Wolf2DGPUModel(GenMapManager):
             self._append_magnetic_grid_to_prop()
 
             if self._sim.sim is not None:
+                # FIXME : Not the right place -> check in SimpleSimulation
+                self._wp.add_param(_('Scheme'), _('Time step strategy'), 2, Type_Param.Integer, jsonstr={"Values":{"Fixed time step":1,"Optimized time step":2}})
+                self._wp.add_param(_('Infiltration'), _('Interpolation mode'), 0, Type_Param.Integer, jsonstr={"Values":{"None":0, "Linear":1}})
                 self._sim.sim.add_to_wolfparam(self._wp)
                 self._wp.Populate(sorted_groups=True)
 

wolfhece/PyGuiHydrology.py

@@ -129,7 +129,7 @@ class GuiHydrology(WolfMapViewer):
 
     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
@@ -140,8 +140,8 @@ class GuiHydrology(WolfMapViewer):
         :param wxlogging: logging instance -- PyGui.WolfLog
         """
 
-        super(GuiHydrology, self).__init__(parent, title=title, w=w, h=h, 
-                                           treewidth=treewidth, 
+        super(GuiHydrology, self).__init__(parent, title=title, w=w, h=h,
+                                           treewidth=treewidth,
                                            wolfparent=wolfparent,
                                            wxlogging=wxlogging)
 
@@ -197,7 +197,7 @@ class GuiHydrology(WolfMapViewer):
 
         if self.wolfparent is None:
             return None
-        
+
         if self.wolfparent.mycatchment is None:
             return None
 
@@ -219,7 +219,7 @@ class GuiHydrology(WolfMapViewer):
         itemlabel = item.ItemLabel
 
         if itemlabel == _('Choose outlet'):
-            myselect = selectpoint(title=_('Outlet'), 
+            myselect = selectpoint(title=_('Outlet'),
                                    SPWstations=self.wolfparent.SPWstations,
                                    DCENNstations=self.wolfparent.DCENNstations)
             myselect.Show()
@@ -276,15 +276,15 @@ class GuiHydrology(WolfMapViewer):
             self.action = 'Select downstream rivers'
 
 
-    def OnRightDown(self, e: wx.MouseEvent):
-        
+    def On_Mouse_Right_Down(self, e: wx.MouseEvent):
+
         # Call the parent event handler
-        super().OnRightDown(e)
+        super().On_Mouse_Right_Down(e)
 
         if self.action is None:
             logging.info(_('No action selected !'))
             return
-        
+
         if self.action == '':
             logging.info(_('No action selected !'))
             return
@@ -305,7 +305,7 @@ class GuiHydrology(WolfMapViewer):
             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)
 
@@ -322,39 +322,39 @@ class GuiHydrology(WolfMapViewer):
 
             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()           
+
+                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()           
+            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), 
+            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()           
+
+            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()           
+            self.active_array.SelectionData.set_selection_from_list_xy(xy)
+            self.Refresh()
 
 

wolfhece/PyPalette.py

@@ -47,6 +47,8 @@ class wolfpalette(wx.Frame, LinearSegmentedColormap):
         self.nseg = nseg
         self.automatic = True
         self.interval_cst = False
+        self.colors = np.zeros((self.nb, 4), dtype=np.float64)
+        self.values = np.zeros((self.nb), dtype=np.float64)
 
         self.wx_exists = wx.App.Get() is not None
 
@@ -57,6 +59,18 @@ class wolfpalette(wx.Frame, LinearSegmentedColormap):
         LinearSegmentedColormap.__init__(self, 'wolf', {}, nseg)
         self.set_bounds()
 
+    def __getstate__(self):
+        """ Récupération de l'état de l'objet pour la sérialisation """
+        state = self.__dict__.copy()
+        return state
+
+    def __setstate__(self, state):
+        """ Récupération de l'état de l'objet pour la désérialisation """
+        self.__dict__.update(state)
+
+        # Reinitialize the LinearSegmentedColormap with the current state
+        self.fill_segmentdata()
+
     @property
     def colormin_uint8(self):
         return self.colormin.astype(np.uint8)*255
@@ -671,21 +685,23 @@ class wolfpalette(wx.Frame, LinearSegmentedColormap):
         self.colorsflt = self.colors.astype(float)/255.
         self.colorsuint8 = self.colors.astype(np.uint8)
 
-        dval = self.values[-1]-self.values[0]
+        if self.nb > 1:
+
+            dval = self.values[-1]-self.values[0]
 
-        normval = np.ones([len(self.values)])
+            normval = np.ones([len(self.values)])
 
-        if dval > 0.:
-            normval = (self.values-self.values[0])/(self.values[-1]-self.values[0])
+            if dval > 0.:
+                normval = (self.values-self.values[0])/(self.values[-1]-self.values[0])
 
-        normval[0] = 0.
-        normval[-1] = 1.
-        segmentdata = {"red": np.column_stack([normval, self.colorsflt[:, 0], self.colorsflt[:, 0]]),
-                       "green": np.column_stack([normval, self.colorsflt[:, 1], self.colorsflt[:, 1]]),
-                       "blue": np.column_stack([normval, self.colorsflt[:, 2], self.colorsflt[:, 2]]),
-                       "alpha": np.column_stack([normval, self.colorsflt[:, 3], self.colorsflt[:, 3]])}
+            normval[0] = 0.
+            normval[-1] = 1.
+            segmentdata = {"red": np.column_stack([normval, self.colorsflt[:, 0], self.colorsflt[:, 0]]),
+                        "green": np.column_stack([normval, self.colorsflt[:, 1], self.colorsflt[:, 1]]),
+                        "blue": np.column_stack([normval, self.colorsflt[:, 2], self.colorsflt[:, 2]]),
+                        "alpha": np.column_stack([normval, self.colorsflt[:, 3], self.colorsflt[:, 3]])}
 
-        LinearSegmentedColormap.__init__(self, 'wolf', segmentdata, self.nseg)
+            LinearSegmentedColormap.__init__(self, 'wolf', segmentdata, self.nseg)
 
     def readfile(self, *args):
         """Lecture de la palette sur base d'un fichier WOLF .pal"""

wolfhece/PyParams.py

@@ -1973,10 +1973,14 @@ class Wolf_Param(wx.Frame):
         elif not self.is_in_active(group, name) and self.is_in_default(group, name):
             # le paramètre est dans les paramètres par défaut mais pas dans les paramètres actifs --> on l'ajoute
             default_value = self.myparams_default[group][name]
+            if key_Param.ADDED_JSON in default_value.keys():
+                json = default_value[key_Param.ADDED_JSON]
+            else:
+                json = None
             self.add_param(group, name, value,
                            default_value[key_Param.TYPE],
                            comment=default_value[key_Param.COMMENT],
-                           jsonstr=default_value[key_Param.ADDED_JSON],
+                           jsonstr=json,
                            whichdict='Active')
         elif self.is_in_active(group, name):
             param = self.myparams[group][name]

wolfhece/PyVertexvectors.py

@@ -7883,22 +7883,67 @@ class Zones(wx.Frame, Element_To_Draw):
 
         sz = []
 
+        # Getting s values and Z values from the xls grid
+        # s in column 4 and z in column 2
+        # The first row is the header
         i = 0
         while self.xls.GetCellValue(i,4) != '':
-            sz.append((float(self.xls.GetCellValue(i,4)), float(self.xls.GetCellValue(i,2))))
-            i += 1
+                s = self.xls.GetCellValue(i,4)
+                z = self.xls.GetCellValue(i,2)
+                try:
+                    s = float(s)
+                except:
+                    logging.error(_('Error during update from sz support - check your s data and types (only float)'))
+                    return
+
+                try:
+                    if z == '':
+                        logging.warning(_('No z value -- setting to 0.0'))
+                        z = 0.0
+                    else:
+                        z = float(z)
+                except:
+                    logging.error(_('Error during update from sz support - check your z data and types (only float)'))
+                    return
+
+                sz.append((s, z))
+                i += 1
+
+        if len(sz) == 0:
+            logging.warning(_('No data to update -- Please set s in column "s curvi" (5th) and z in column Z (3th)'))
+            return
 
         logging.info(f'Number of points: {len(sz)}')
 
         vec_sz = np.array(sz)
 
-        self.update_from_sz_support(vec=self.active_vector, sz=vec_sz)
+        memory_xyz = []
+        i = 0
+        while self.xls.GetCellValue(i,0) != '':
+            memory_xyz.append((float(self.xls.GetCellValue(i,0)), float(self.xls.GetCellValue(i,1)), float(self.xls.GetCellValue(i,2))))
+            i += 1
 
-        # update of the xls grid
-        for k in range(self.active_vector.nbvertices ):
-            self.xls.SetCellValue(k,0,str(self.active_vector.myvertices[k].x))
-            self.xls.SetCellValue(k,1,str(self.active_vector.myvertices[k].y))
+        try:
+            self.update_from_sz_support(vec=self.active_vector, sz=vec_sz)
+
+            # update of the xls grid
+            for k in range(self.active_vector.nbvertices ):
+                self.xls.SetCellValue(k,0,str(self.active_vector.myvertices[k].x))
+                self.xls.SetCellValue(k,1,str(self.active_vector.myvertices[k].y))
+        except:
+            logging.error(_('Error during update from sz support - check your data'))
+            logging.info(_('Resetting the active vector to its original state'))
+
+            self.active_vector.myvertices = []
+            for cur in memory_xyz:
+                self.active_vector.add_vertex(wolfvertex(cur[0], cur[1], cur[2]))
+            self.active_vector._reset_listogl()
+            self.active_vector.update_lengths()
+            self.active_vector.find_minmax(True)
 
+            for k in range(self.active_vector.nbvertices ):
+                self.xls.SetCellValue(k,0,str(self.active_vector.myvertices[k].x))
+                self.xls.SetCellValue(k,1,str(self.active_vector.myvertices[k].y))
 
     def update_from_sz_direction(self, xy1:np.ndarray, xy2:np.ndarray, sz:np.ndarray):
         """ Update the active vector from the sz values in the xls grid """

wolfhece/Results2DGPU.py

@@ -185,6 +185,23 @@ class wolfres2DGPU(Wolfresults_2D):
 
         self._cache = None
 
+    def __getstate__(self):
+        dct= super().__getstate__()
+
+        to_pop = ['_result_store', '_cache']
+        for key in to_pop:
+            if key in dct:
+                dct.pop(key)
+
+        return dct
+
+    def __setstate__(self, dct):
+        super().__setstate__(dct)
+
+        self._result_store = None
+        self._cache = None
+        self.setup_store(self._result_store)
+
     def setup_store(self, store = None):
         """
         Setup results store