wolfhece 2.0.11__py3-none-any.whl → 2.0.13__py3-none-any.whl

wolfhece/wolf_array.py

@@ -1364,15 +1364,30 @@ class Ops_Array(wx.Frame):
                                         _("Reset"), wx.DefaultPosition,
                                         wx.DefaultSize, 0)
         self.ResetSelection.SetToolTip(_("Reset the current selection list (keyboard shortcut r)"))
+
         bSizer16.Add(self.ResetSelection, 0, wx.EXPAND)
+
         self.ResetAllSelection = wx.Button(self.selection, wx.ID_ANY,
                                            _("Reset All"), wx.DefaultPosition,
                                            wx.DefaultSize, 0)
         self.ResetAllSelection.SetToolTip(_("Reset the current selection list and the indexed lists (keyboard shortcut R)"))
         bSizer16.Add(self.ResetAllSelection, 0, wx.EXPAND)
 
+        self.to_clipboard_str = wx.Button(self.selection, wx.ID_ANY, _("To clipboard (str)"), wx.DefaultPosition,
+                                            wx.DefaultSize, 0)
+        self.to_clipboard_str.SetToolTip(_("Copy the current selection to the clipboard as a string"))
+
+        self.to_clipboard_script = wx.Button(self.selection, wx.ID_ANY, _("To clipboard (script)"), wx.DefaultPosition,
+                                            wx.DefaultSize, 0)
+        self.to_clipboard_script.SetToolTip(_("Copy the current selection to the clipboard as a script"))
+
+        bSizer16.Add(self.to_clipboard_str, 0, wx.EXPAND)
+        bSizer16.Add(self.to_clipboard_script, 0, wx.EXPAND)
+
         bSizer21.Add(bSizer16, 1, wx.EXPAND, 5)
 
+
+
         bSizer17 = wx.BoxSizer(wx.VERTICAL)
 
         self.m_button2 = wx.Button(self.selection, wx.ID_ANY, _("Manage vectors"), wx.DefaultPosition, wx.DefaultSize,
@@ -1392,7 +1407,7 @@ class Ops_Array(wx.Frame):
 
         bSizer17.Add(self.CurActiveparent, 0, wx.EXPAND)
 
-        self.loadvec = wx.Button(self.selection, wx.ID_ANY, _("Read from file..."), wx.DefaultPosition, wx.DefaultSize,
+        self.loadvec = wx.Button(self.selection, wx.ID_ANY, _("Load from file..."), wx.DefaultPosition, wx.DefaultSize,
                                  0)
         self.loadvec.SetToolTip(_("Load a vector file into the vector manager"))
         bSizer17.Add(self.loadvec, 0, wx.EXPAND)
@@ -1539,6 +1554,9 @@ class Ops_Array(wx.Frame):
         self.MoveSelection.Bind(wx.EVT_BUTTON, self.OnMoveSelect)
         self.ResetSelection.Bind(wx.EVT_BUTTON, self.OnResetSelect)
         self.ResetAllSelection.Bind(wx.EVT_BUTTON, self.OnResetAllSelect)
+        self.to_clipboard_str.Bind(wx.EVT_BUTTON, self.OnToClipboardStr)
+        self.to_clipboard_script.Bind(wx.EVT_BUTTON, self.OnToClipboardStr)
+
         self.m_button2.Bind(wx.EVT_BUTTON, self.OnManageVectors)
         self.loadvec.Bind(wx.EVT_BUTTON, self.OnLoadvec)
         self.saveas.Bind(wx.EVT_BUTTON, self.OnSaveasvec)
@@ -1811,6 +1829,72 @@ class Ops_Array(wx.Frame):
         self.reset_all_selection()
         self.refresh_array()
 
+    def OnToClipboardStr(self, event):
+        """
+        Copy the current selection to the clipboard as a string
+        """
+
+        if event.GetId() == self.to_clipboard_str.GetId():
+            whichtype = 'string'
+        elif event.GetId() == self.to_clipboard_script.GetId():
+            whichtype = 'script'
+
+        if self.parentarray.mngselection is not None:
+
+            selectobj = self.parentarray.mngselection
+
+            if len(selectobj.selections) > 0:
+                choices = [_("Current selection")]
+                for cur in selectobj.selections.items():
+                    choices.append(cur[0])
+
+                dlg = wx.MultiChoiceDialog(None, "Choose the selection to copy", "Choices", choices)
+                ret = dlg.ShowModal()
+                if ret == wx.ID_CANCEL:
+                    dlg.Destroy()
+                    return
+
+                sel = dlg.GetSelections()
+                dlg.Destroy()
+
+            else:
+                sel = [0]
+
+            if len(sel) == 0:
+                return
+            elif len(sel) == 1:
+                sel = int(sel[0])
+
+                if sel == 0:
+                    sel = None
+                else:
+                    sel =choices[sel]
+
+                self.parentarray.mngselection.copy_to_clipboard(which = sel, typestr=whichtype)
+
+            else:
+                txt = ''
+                for cursel in sel:
+                    if cursel == 0:
+                        cursel = None
+                    else:
+                        cursel = choices[cursel]
+
+                    if whichtype == 'script':
+                        txt += self.parentarray.mngselection.get_script(which = cursel)
+                    else:
+                        txt += self.parentarray.mngselection.get_string(which = cursel)
+
+                    txt += '\n'
+
+                if wx.TheClipboard.Open():
+                    wx.TheClipboard.Clear()
+                    wx.TheClipboard.SetData(wx.TextDataObject(txt))
+                    wx.TheClipboard.Close()
+
+        else:
+            logging.error('Error in OnToClipboardStr')
+
     def OnApplyOpSelect(self, event):
         """ Select nodes based on condition """
 
@@ -1925,6 +2009,7 @@ class Ops_Array(wx.Frame):
                         if curViewer.link_shareopsvect:
                             curViewer.active_array.myops.myzones = self.myzones
                             curViewer.active_array.myops.fnsave = self.fnsave
+            self.mapviewer.Refresh()
 
     def OnSaveasvec(self, event:wx.MouseEvent):
         """ Save vector file """
@@ -1990,6 +2075,10 @@ class Ops_Array(wx.Frame):
             logging.warning(_('Please select an active vector !'))
             return
 
+        if self.active_vector.nbvertices == 0:
+            logging.warning(_('Please add points to vector or select another !'))
+            return
+
         self._select_vector_inside_manager(self.active_vector)
         self.refresh_array()
 
@@ -2314,6 +2403,8 @@ class SelectionData():
         self.parent: WolfArray
         self.parent = parent
 
+        self.wx_exists = wx.GetApp() is not None
+
         #copy of the resolution
         self.dx = parent.dx
         self.dy = parent.dy
@@ -2325,15 +2416,89 @@ class SelectionData():
         self.hideselection = False
         self.numlist_select = 0 # OpenGL list index
 
+    def get_string(self, which:str = None) -> str:
+        """ Get string of the current selection or of a stored one """
+
+        if which is None:
+            curlist = self.myselection
+            txt = 'X\tY'
+        else:
+            if str(which) in self.selections:
+                curlist = self.selections[str(which)]['select']
+                txt = 'Selection {}\n'.format(which) + 'X\tY\n'
+            else:
+                logging.error(_('Selection {} does not exist').format(which))
+                return ''
+
+        for cur in curlist:
+            txt += str(cur[0]) + '\t' + str(cur[1]) + '\n'
+
+        txt += 'i\tj\t1-based indices\n'
+        for cur in curlist:
+            i,j = self.parent.get_ij_from_xy(cur[0], cur[1], aswolf=True)
+            txt += str(i) + '\t' + str(j) + '\n'
+
+        return txt
+
+    def get_script(self, which:int = None) -> str:
+        """ Get script of the current selection or of a stored one """
+
+        txt = '# script adapted to a WolfGPU script\n'
+        txt += '#  - (i,j) are 1-based for add_boundary_condition -- Do not forget to adapt BC type, value and direction or use BC Manager\n'
+        txt += '#  - (i,j) are 0-based for infiltration zones\n\n'
+
+        if which is None:
+            curlist = self.myselection
+            idx = 0
+        else:
+            if str(which) in self.selections:
+                txt += '# Selection {}\n'.format(which)
+                curlist = self.selections[str(which)]['select']
+                idx = which
+            else:
+                logging.error(_('Selection {} does not exist').format(which))
+                return ''
+
+        txt += '# For boundary conditions :\n'
+        for cur in curlist:
+            i,j = self.parent.get_ij_from_xy(cur[0], cur[1], aswolf=True)
+            txt += "simul.add_boundary_condition(i={}, j={}, bc_type=BoundaryConditionsTypes.FROUDE_NORMAL, bc_value=.3, border=Direction.LEFT)".format(i, j) + '\n'
+
+        txt += '\n\n# For infiltration zones :\n'
+        for cur in curlist:
+            i,j = self.parent.get_ij_from_xy(cur[0], cur[1], aswolf=True)
+            txt += "infiltration_zones.array[{},{}]={}".format(i-1, j-1, idx) + '\n'
+
+        txt += '\n\n"""If needed, selection as string :\n'
+        txt += self.get_string(which)
+        txt += '"""\n'
+
+        return txt
+
+    def copy_to_clipboard(self, which:int = None, typestr:Literal['string', 'script'] = 'string'):
+        """ Copy current selection to clipboard """
+        if self.wx_exists:
+            if wx.TheClipboard.Open():
+                wx.TheClipboard.Clear()
+                if typestr == 'string':
+                    wx.TheClipboard.SetData(wx.TextDataObject(self.get_string(which)))
+                else:
+                    wx.TheClipboard.SetData(wx.TextDataObject(self.get_script(which)))
+
+                wx.TheClipboard.Close()
+            else:
+                logging.warning(_('Cannot open the clipboard'))
+
+
     def move_selectionto(self, idx:str, color:list[float]):
         """
         Transfer current selection to dictionary
 
         :param idx: id/key of the selection
-        :param color: color of the selection - list of 3 floats between 0 and 255
+        :param color: color of the selection - list of 4 integers between 0 and 255
         """
 
-        assert len(color) == 3, "color must be a list of 3 floats between 0 and 255"
+        assert len(color) == 4, "color must be a list of 4 integers between 0 and 255"
 
         # force idx to be a string
         idtxt = str(idx)
@@ -2440,7 +2605,8 @@ class SelectionData():
         # le but est de ne conserver que les coordonnées des CG de mailles
         i, j = self.parent.get_ij_from_xy(x, y)
 
-        if i>=0 and j>=0 and i<self.parent.nbx and j<self.parent.nby:
+        if self.parent.check_bounds_ij(i, j):
+        # if i>=0 and j>=0 and i<self.parent.nbx and j<self.parent.nby:
             self.add_node_to_selectionij(i, j, verif)
 
     def add_nodes_to_selection(self, xy:list[float], verif:bool=True):
@@ -2515,9 +2681,12 @@ class SelectionData():
                 sel = [tuple(x[1]) for x in locsort]
 
                 # on recherche le premier 1
-                idx = counts.index(1)
-                # on ne conserve que la portion de liste utile
-                self.myselection = sel[idx:]
+                if 1 in counts:
+                    idx = counts.index(1)
+                    # on ne conserve que la portion de liste utile
+                    self.myselection = sel[idx:]
+                else:
+                    self.myselection = []
             else:
                 self.myselection = np.unique(self.myselection, axis=0)
 
@@ -2531,12 +2700,17 @@ class SelectionData():
         path = mpltPath.Path(myvect.asnparray())
         inside = path.contains_points(mypoints)
 
-        if self.parent.myops.selectrestricttomask.IsChecked():
-            self.hideselection=True
+        self.hideselection=False
+        if self.parent.myops is not None:
+            if self.parent.myops.selectrestricttomask.IsChecked():
+                self.hideselection=True
 
         self.add_nodes_to_selection(mypoints[np.where(inside)], verif=nbini != 0)
-        if self.parent.myops.selectrestricttomask.IsChecked():
-            self.condition_select('Mask',0)
+
+        if self.parent.myops is not None:
+            if len(self.myselection) > 0:
+                if self.parent.myops.selectrestricttomask.IsChecked():
+                    self.condition_select('Mask',0)
 
         self.hideselection=False
         self.update_nb_nodes_sections()
@@ -2551,13 +2725,14 @@ class SelectionData():
 
         self.add_nodes_to_selectionij(mypoints, verif=nbini != 0)
 
-        if self.parent.myops.selectrestricttomask.IsChecked():
-            self.condition_select('Mask',0)
+        if self.parent.myops is not None:
+            if self.parent.myops.selectrestricttomask.IsChecked():
+                self.condition_select('Mask',0)
 
         self.update_nb_nodes_sections()
 
     def update_nb_nodes_sections(self):
-
+        """ Update the number of selected nodes """
         if self.myselection=='all':
             nb = self.parent.nbnotnull
         else:
@@ -2579,12 +2754,13 @@ class SelectionData():
         else:
             self.update_plot_selection = True
 
-        self.parent.myops.nbselect.SetLabelText(str(nb))
-        if nb>0:
-            self.parent.myops.minx.SetLabelText(str(np.min(np.asarray(self.myselection)[:, 0])))
-            self.parent.myops.miny.SetLabelText(str(np.min(np.asarray(self.myselection)[:, 1])))
-            self.parent.myops.maxx.SetLabelText(str(np.max(np.asarray(self.myselection)[:, 0])))
-            self.parent.myops.maxy.SetLabelText(str(np.max(np.asarray(self.myselection)[:, 1])))
+        if self.parent.myops is not None:
+            self.parent.myops.nbselect.SetLabelText(str(nb))
+            if nb>0:
+                self.parent.myops.minx.SetLabelText(str(np.min(np.asarray(self.myselection)[:, 0])))
+                self.parent.myops.miny.SetLabelText(str(np.min(np.asarray(self.myselection)[:, 1])))
+                self.parent.myops.maxx.SetLabelText(str(np.max(np.asarray(self.myselection)[:, 0])))
+                self.parent.myops.maxy.SetLabelText(str(np.max(np.asarray(self.myselection)[:, 1])))
 
     def condition_select(self, cond, condval, condval2=0, usemask=False):
         array = self.parent.array
@@ -2616,145 +2792,161 @@ class SelectionData():
         if usemask :
             mask=np.logical_not(array.mask)
             if nbini == 0:
-                if cond == 0 or cond=='<':
-                    # <
-                    ij = np.argwhere((array < condval) & mask)
-                elif cond == 1 or cond=='<=':
-                    # <=
-                    ij = np.argwhere((array <= condval) & mask)
-                elif cond == 2 or cond=='==':
-                    # ==
-                    ij = np.argwhere((array == condval) & mask)
-                elif cond == 3 or cond=='>=':
-                    # >=
-                    ij = np.argwhere((array >= condval) & mask)
-                elif cond == 4 or cond=='>':
-                    # >
-                    ij = np.argwhere((array > condval) & mask)
-                elif cond == 5 or cond=='NaN':
-                    # NaN
-                    ij = np.argwhere((np.isnan(array)) & mask)
-                elif cond == 6 or cond=='>=<=':
-                    # interval with equality
-                    ij = np.argwhere(((array>=condval) & (array<=condval2)) & mask)
-                elif cond == 7 or cond=='><':
-                    # interval without equality
-                    ij = np.argwhere(((array>condval) & (array<condval2)) & mask)
-                elif cond == 8 or cond=='<>':
-                    # interval without equality
-                    ij = np.argwhere(((array<condval) | (array>condval2)) & mask)
-
-                self.add_nodes_to_selectionij(ij, nbini != 0)
+                try:
+                    if cond == 0 or cond=='<':
+                        # <
+                        ij = np.argwhere((array < condval) & mask)
+                    elif cond == 1 or cond=='<=':
+                        # <=
+                        ij = np.argwhere((array <= condval) & mask)
+                    elif cond == 2 or cond=='==':
+                        # ==
+                        ij = np.argwhere((array == condval) & mask)
+                    elif cond == 3 or cond=='>=':
+                        # >=
+                        ij = np.argwhere((array >= condval) & mask)
+                    elif cond == 4 or cond=='>':
+                        # >
+                        ij = np.argwhere((array > condval) & mask)
+                    elif cond == 5 or cond=='NaN':
+                        # NaN
+                        ij = np.argwhere((np.isnan(array)) & mask)
+                    elif cond == 6 or cond=='>=<=':
+                        # interval with equality
+                        ij = np.argwhere(((array>=condval) & (array<=condval2)) & mask)
+                    elif cond == 7 or cond=='><':
+                        # interval without equality
+                        ij = np.argwhere(((array>condval) & (array<condval2)) & mask)
+                    elif cond == 8 or cond=='<>':
+                        # interval without equality
+                        ij = np.argwhere(((array<condval) | (array>condval2)) & mask)
+
+                    self.add_nodes_to_selectionij(ij, nbini != 0)
+                except:
+                    logging.error(_('Error in condition_select -- nbini == 0 ! -- Please report this bug, specifying the context'))
+                    return
             else:
-                sel = np.asarray(self.myselection)
-                ijall = np.asarray(self.parent.get_ij_from_xy(sel[:, 0], sel[:, 1])).transpose()
-                if cond == 0 or cond=='<':
-                    # <
-                    ij = np.argwhere((array[ijall[:, 0], ijall[:, 1]] < condval) & (mask[ijall[:, 0], ijall[:, 1]]))
-                elif cond == 1 or cond=='<=':
-                    # <=
-                    ij = np.argwhere((array[ijall[:, 0], ijall[:, 1]] <= condval) & (mask[ijall[:, 0], ijall[:, 1]]))
-                elif cond == 2 or cond=='==':
-                    # ==
-                    ij = np.argwhere((array[ijall[:, 0], ijall[:, 1]] == condval) & (mask[ijall[:, 0], ijall[:, 1]]))
-                elif cond == 3 or cond=='>=':
-                    # >=
-                    ij = np.argwhere((array[ijall[:, 0], ijall[:, 1]] >= condval) & (mask[ijall[:, 0], ijall[:, 1]]))
-                elif cond == 4 or cond=='>':
-                    # >
-                    ij = np.argwhere((array[ijall[:, 0], ijall[:, 1]] > condval) & (mask[ijall[:, 0], ijall[:, 1]]))
-                elif cond == 5 or cond=='NaN':
-                    # NaN
-                    ij = np.argwhere((np.isnan(array[ijall[:, 0], ijall[:, 1]])) & (mask[ijall[:, 0], ijall[:, 1]]))
-                elif cond == 6 or cond=='>=<=':
-                    # interval with equality
-                    ij = np.argwhere(((array[ijall[:, 0], ijall[:, 1]]>=condval) & (array[ijall[:, 0], ijall[:, 1]]<=condval2)) & (mask[ijall[:, 0], ijall[:, 1]]))
-                elif cond == 7 or cond=='><':
-                    # interval without equality
-                    ij = np.argwhere(((array[ijall[:, 0], ijall[:, 1]]>condval) & (array[ijall[:, 0], ijall[:, 1]]<condval2)) & (mask[ijall[:, 0], ijall[:, 1]]))
-                elif cond == 8 or cond=='<>':
-                    # interval without equality
-                    ij = np.argwhere(((array[ijall[:, 0], ijall[:, 1]]<condval) | (array[ijall[:, 0], ijall[:, 1]]>condval2)) & (mask[ijall[:, 0], ijall[:, 1]]))
-
-                ij = ij.flatten()
-                self.add_nodes_to_selectionij(ijall[ij], nbini != 0)
+                try:
+                    sel = np.asarray(self.myselection)
+                    ijall = np.asarray(self.parent.get_ij_from_xy(sel[:, 0], sel[:, 1])).transpose()
+                    if cond == 0 or cond=='<':
+                        # <
+                        ij = np.argwhere((array[ijall[:, 0], ijall[:, 1]] < condval) & (mask[ijall[:, 0], ijall[:, 1]]))
+                    elif cond == 1 or cond=='<=':
+                        # <=
+                        ij = np.argwhere((array[ijall[:, 0], ijall[:, 1]] <= condval) & (mask[ijall[:, 0], ijall[:, 1]]))
+                    elif cond == 2 or cond=='==':
+                        # ==
+                        ij = np.argwhere((array[ijall[:, 0], ijall[:, 1]] == condval) & (mask[ijall[:, 0], ijall[:, 1]]))
+                    elif cond == 3 or cond=='>=':
+                        # >=
+                        ij = np.argwhere((array[ijall[:, 0], ijall[:, 1]] >= condval) & (mask[ijall[:, 0], ijall[:, 1]]))
+                    elif cond == 4 or cond=='>':
+                        # >
+                        ij = np.argwhere((array[ijall[:, 0], ijall[:, 1]] > condval) & (mask[ijall[:, 0], ijall[:, 1]]))
+                    elif cond == 5 or cond=='NaN':
+                        # NaN
+                        ij = np.argwhere((np.isnan(array[ijall[:, 0], ijall[:, 1]])) & (mask[ijall[:, 0], ijall[:, 1]]))
+                    elif cond == 6 or cond=='>=<=':
+                        # interval with equality
+                        ij = np.argwhere(((array[ijall[:, 0], ijall[:, 1]]>=condval) & (array[ijall[:, 0], ijall[:, 1]]<=condval2)) & (mask[ijall[:, 0], ijall[:, 1]]))
+                    elif cond == 7 or cond=='><':
+                        # interval without equality
+                        ij = np.argwhere(((array[ijall[:, 0], ijall[:, 1]]>condval) & (array[ijall[:, 0], ijall[:, 1]]<condval2)) & (mask[ijall[:, 0], ijall[:, 1]]))
+                    elif cond == 8 or cond=='<>':
+                        # interval without equality
+                        ij = np.argwhere(((array[ijall[:, 0], ijall[:, 1]]<condval) | (array[ijall[:, 0], ijall[:, 1]]>condval2)) & (mask[ijall[:, 0], ijall[:, 1]]))
+
+                    ij = ij.flatten()
+                    self.add_nodes_to_selectionij(ijall[ij], nbini != 0)
+                except:
+                    logging.error(_('Error in condition_select ! -- Please report this bug, specifying the context'))
+                    return
         else:
             if nbini == 0:
-                if cond == 0 or cond=='<':
-                    # <
-                    ij = np.argwhere(array < condval)
-                elif cond == 1 or cond=='<=':
-                    # <=
-                    ij = np.argwhere(array <= condval)
-                elif cond == 2 or cond=='==':
-                    # ==
-                    ij = np.argwhere(array == condval)
-                elif cond == 3 or cond=='>=':
-                    # >=
-                    ij = np.argwhere(array >= condval)
-                elif cond == 4 or cond=='>':
-                    # >
-                    ij = np.argwhere(array > condval)
-                elif cond == 5 or cond=='NaN':
-                    # NaN
-                    ij = np.argwhere(np.isnan(array))
-                elif cond == 6 or cond=='>=<=':
-                    # interval with equality
-                    ij = np.argwhere((array>=condval) & (array<=condval2))
-                elif cond == 7 or cond=='><':
-                    # interval without equality
-                    ij = np.argwhere((array>condval) & (array<condval2))
-                elif cond == 8 or cond=='<>':
-                    # interval without equality
-                    ij = np.argwhere((array<condval) | (array>condval2))
-                elif cond == -1 or cond=='Mask':
-                    # Mask
-                    ij = np.argwhere(array.mask)
-                elif cond == -2 or cond=='NotMask':
-                    # Mask
-                    ij = np.argwhere(np.logical_not(array.mask))
-
-                self.add_nodes_to_selectionij(ij, nbini != 0)
+                try:
+                    if cond == 0 or cond=='<':
+                        # <
+                        ij = np.argwhere(array < condval)
+                    elif cond == 1 or cond=='<=':
+                        # <=
+                        ij = np.argwhere(array <= condval)
+                    elif cond == 2 or cond=='==':
+                        # ==
+                        ij = np.argwhere(array == condval)
+                    elif cond == 3 or cond=='>=':
+                        # >=
+                        ij = np.argwhere(array >= condval)
+                    elif cond == 4 or cond=='>':
+                        # >
+                        ij = np.argwhere(array > condval)
+                    elif cond == 5 or cond=='NaN':
+                        # NaN
+                        ij = np.argwhere(np.isnan(array))
+                    elif cond == 6 or cond=='>=<=':
+                        # interval with equality
+                        ij = np.argwhere((array>=condval) & (array<=condval2))
+                    elif cond == 7 or cond=='><':
+                        # interval without equality
+                        ij = np.argwhere((array>condval) & (array<condval2))
+                    elif cond == 8 or cond=='<>':
+                        # interval without equality
+                        ij = np.argwhere((array<condval) | (array>condval2))
+                    elif cond == -1 or cond=='Mask':
+                        # Mask
+                        ij = np.argwhere(array.mask)
+                    elif cond == -2 or cond=='NotMask':
+                        # Mask
+                        ij = np.argwhere(np.logical_not(array.mask))
+
+                    self.add_nodes_to_selectionij(ij, nbini != 0)
+                except:
+                    logging.error(_('Error in condition_select -- nbini == 0 ! -- Please report this bug, specifying the context'))
+                    return
             else:
-                sel = np.asarray(self.myselection)
-                ijall = np.asarray(self.parent.get_ij_from_xy(sel[:, 0], sel[:, 1])).transpose()
-
-                if cond == 0 or cond=='<':
-                    # <
-                    ij = np.argwhere(array[ijall[:, 0], ijall[:, 1]] < condval)
-                elif cond == 1 or cond=='<=':
-                    # <=
-                    ij = np.argwhere(array[ijall[:, 0], ijall[:, 1]] <= condval)
-                elif cond == 2 or cond=='==':
-                    # ==
-                    ij = np.argwhere(array[ijall[:, 0], ijall[:, 1]] == condval)
-                elif cond == 3 or cond=='>=':
-                    # >=
-                    ij = np.argwhere(array[ijall[:, 0], ijall[:, 1]] >= condval)
-                elif cond == 4 or cond=='>':
-                    # >
-                    ij = np.argwhere(array[ijall[:, 0], ijall[:, 1]] > condval)
-                elif cond == 5 or cond=='NaN':
-                    # NaN
-                    ij = np.argwhere(np.isnan(array[ijall[:, 0], ijall[:, 1]]))
-                elif cond == 6 or cond=='>=<=':
-                    # interval with equality
-                    ij = np.argwhere((array[ijall[:, 0], ijall[:, 1]]>=condval) & (array[ijall[:, 0], ijall[:, 1]]<=condval2))
-                elif cond == 7 or cond=='><':
-                    # interval without equality
-                    ij = np.argwhere((array[ijall[:, 0], ijall[:, 1]]>condval) & (array[ijall[:, 0], ijall[:, 1]]<condval2))
-                elif cond == 8 or cond=='<>':
-                    # interval without equality
-                    ij = np.argwhere((array[ijall[:, 0], ijall[:, 1]]<condval) | (array[ijall[:, 0], ijall[:, 1]]>condval2) )
-                elif cond == -1 or cond=='Mask':
-                    # Mask
-                    ij = np.argwhere(array.mask[ijall[:, 0], ijall[:, 1]])
-                elif cond == -2 or cond=='NotMask':
-                    # Mask
-                    ij = np.argwhere(np.logical_not(array.mask[ijall[:, 0], ijall[:, 1]]))
-
-                ij = ij.flatten()
-                self.add_nodes_to_selectionij(ijall[ij], nbini != 0)
+                try:
+                    sel = np.asarray(self.myselection)
+                    ijall = np.asarray(self.parent.get_ij_from_xy(sel[:, 0], sel[:, 1])).transpose()
+
+                    if cond == 0 or cond=='<':
+                        # <
+                        ij = np.argwhere(array[ijall[:, 0], ijall[:, 1]] < condval)
+                    elif cond == 1 or cond=='<=':
+                        # <=
+                        ij = np.argwhere(array[ijall[:, 0], ijall[:, 1]] <= condval)
+                    elif cond == 2 or cond=='==':
+                        # ==
+                        ij = np.argwhere(array[ijall[:, 0], ijall[:, 1]] == condval)
+                    elif cond == 3 or cond=='>=':
+                        # >=
+                        ij = np.argwhere(array[ijall[:, 0], ijall[:, 1]] >= condval)
+                    elif cond == 4 or cond=='>':
+                        # >
+                        ij = np.argwhere(array[ijall[:, 0], ijall[:, 1]] > condval)
+                    elif cond == 5 or cond=='NaN':
+                        # NaN
+                        ij = np.argwhere(np.isnan(array[ijall[:, 0], ijall[:, 1]]))
+                    elif cond == 6 or cond=='>=<=':
+                        # interval with equality
+                        ij = np.argwhere((array[ijall[:, 0], ijall[:, 1]]>=condval) & (array[ijall[:, 0], ijall[:, 1]]<=condval2))
+                    elif cond == 7 or cond=='><':
+                        # interval without equality
+                        ij = np.argwhere((array[ijall[:, 0], ijall[:, 1]]>condval) & (array[ijall[:, 0], ijall[:, 1]]<condval2))
+                    elif cond == 8 or cond=='<>':
+                        # interval without equality
+                        ij = np.argwhere((array[ijall[:, 0], ijall[:, 1]]<condval) | (array[ijall[:, 0], ijall[:, 1]]>condval2) )
+                    elif cond == -1 or cond=='Mask':
+                        # Mask
+                        ij = np.argwhere(array.mask[ijall[:, 0], ijall[:, 1]])
+                    elif cond == -2 or cond=='NotMask':
+                        # Mask
+                        ij = np.argwhere(np.logical_not(array.mask[ijall[:, 0], ijall[:, 1]]))
+
+                    ij = ij.flatten()
+                    self.add_nodes_to_selectionij(ijall[ij], nbini != 0)
+                except:
+                    logging.error(_('Error in condition_select ! -- Please report this bug, specifying the context'))
+                    return
 
         self.update_nb_nodes_sections()
 
@@ -3248,6 +3440,16 @@ class WolfArray(Element_To_Draw, header_wolf):
 
         self.add_ops_sel() # Ajout d'un gestionnaire de sélection et d'opérations
 
+
+    def check_bounds_ij(self, i:int, j:int):
+        """Check if i and j are inside the array bounds"""
+        return i>=0 and j>=0 and i<self.nbx and j<self.nby
+
+    def check_bounds_xy(self, x:float, y:float):
+        """Check if i and j are inside the array bounds"""
+        i,j = self.get_ij_from_xy(x,y)
+        return self.check_bounds_ij(i,j)
+
     def show_properties(self):
         """ Affichage des propriétés de la matrice dans une fenêtre wxPython """
         if self.wx_exists and self.myops is not None:
@@ -3322,6 +3524,15 @@ class WolfArray(Element_To_Draw, header_wolf):
             - mask data outisde linkedvec
         """
         self.array[np.where(self.array<eps)] = 0.
+
+        idx_nan  = np.where(np.isnan(self.array))
+        if len(idx_nan[0])>0:
+            self.array[idx_nan] = 0.
+            self.array.mask[idx_nan] = True
+            logging.warning(_('NaN values found in the array'))
+            for i,j in zip(idx_nan[0],idx_nan[1]):
+                logging.warning(f'NaN at {i+1},{j+1} -- 1-based')
+
         if self.linkedvec is not None:
             self.mask_outsidepoly(self.linkedvec)
 
@@ -5491,7 +5702,6 @@ class WolfArray(Element_To_Draw, header_wolf):
 
         self.plotting = False
 
-        # glFinish()
         # Plot selected nodes
         if self.mngselection is not None:
             self.mngselection.plot_selection()
@@ -5503,7 +5713,7 @@ class WolfArray(Element_To_Draw, header_wolf):
     def delete_lists(self):
         """ Delete OpenGL lists """
 
-        logging.info(_('OpenGL lists - deletion -- array {}'.format(self.idx)))
+        logging.debug(_('OpenGL lists - deletion -- array {}'.format(self.idx)))
         for idx, cursize in enumerate(self.mygrid):
             curlist = self.mygrid[cursize]
             nbx = curlist['nbx']
@@ -5828,6 +6038,18 @@ class WolfArrayMB(WolfArray):
         super().__init__(fname, mold, masknull, crop, whichtype, preload, create, mapviewer, nullvalue, srcheader)
         # self.wolftype = whichtype
 
+    def check_bounds_ij(self, i:int, j:int):
+        """Check if i and j are inside the array bounds"""
+        x,y = self.get_xy_from_ij(i,j)
+        return self.check_bounds_xy(x,y)
+
+    def check_bounds_xy(self, x:float, y:float):
+        """Check if i and j are inside the array bounds"""
+
+        xmin, xmax, ymin, ymax = self.get_bounds()
+
+        return x>=xmin and x<=xmax and y>=ymin and y<=ymax
+
     def __getitem__(self, block_key:Union[int,str]) -> WolfArray:
         """Access a block of this multi-blocks array."""
         if isinstance(block_key,int):