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

wolfhece/scenario/config_manager.py

@@ -110,6 +110,8 @@ class GPU_2D_file(Enum):
     MANNING      = _gpu_file('manning'   , np.float32, GPU_2D_file_extensions.NPY.value)
     COMPUTATION_MASK = _gpu_file('nap'   , np.uint8  , GPU_2D_file_extensions.NPY.value)
     INFILTRATION = _gpu_file('infiltration_zones', np.int32, GPU_2D_file_extensions.NPY.value)
+    ROOF         = _gpu_file('bridge_roof'       , np.float32, GPU_2D_file_extensions.NPY.value)
+    # DECK         = _gpu_file('bridge_deck'        , np.float32, GPU_2D_file_extensions.NPY.value)
 
 # répertoire de sortie des simulations GPU
 RESULT_DIR = 'simul_gpu_results'
@@ -240,6 +242,8 @@ class Config_Manager_2D_GPU:
         self._epsilon = 0.01
         self._filter_independent = True
 
+        self._active_simulation = None
+
         self.load_data()
 
     def find_wolfgpu(self):
@@ -559,15 +563,172 @@ class Config_Manager_2D_GPU:
 
         logging.info(_('Hydrographs...'))
         hydro = self.get_hydrographs()
-        nb = hydro[0].data.shape[1]
+        if len(hydro) == 0:
+            logging.info(_('No hydrographs found !'))
+            log += _('No hydrographs found !') + '\n'
+        else:
+            try:
+                nb = hydro[0].data.shape[1]
+
+                logging.info(_('Number of hydrographs : {}'.format(len(hydro))))
+                for curhydro in hydro:
+                    if curhydro.data.shape[1] != nb:
+                        loclog = _('Bad number of columns for {} !'.format(curhydro[0]._filename))
+                        log += loclog + '\n'
+                        logging.warning(loclog)
+            except Exception as e:
+                logging.error(_('Error while checking hydrographs: {}').format(e))
+                log += _('Error while checking hydrographs: {}').format(e) + '\n'
+
+        return log
+
+    def check_one_simulation(self) -> str:
+        """
+        Check consistency of one simulation
+
+        """
+
+        if self._active_simulation is None:
+            logging.error(_('No active simulation !'))
+            return _('No active simulation !')
+
+        logging.info(_('Checking consistency of one simulation...\n'))
+
+        logging.info(_('NPY files...'))
+        numpyfiles = self._active_simulation[GPU_2D_file_extensions.NPY.value]
+        numpynames = [file.name.lower() for file in numpyfiles]
+
+        logging.info(_('Number of numpy files : {}'.format(len(numpyfiles))))
+
+        if self._header.nbx == 0 or self._header.nby == 0:
+            logging.error(_('No header found !'))
+            logging.info(_('Trying to get header from first numpy file...'))
+            try:
+                wa = WolfArray(numpyfiles[0])
+                self._header = wa.get_header()
+            except Exception as e:
+                logging.error(_('Error while getting header from first numpy file: {}').format(e))
+                return _('Error while getting header from first numpy file: {}').format(e)
+
+        log = ''
+        for curnpy in numpyfiles:
+
+            # test if the shape of the numpy file is the same as the tif file
+            # using memmap to avoid loading the whole array in memory -> faster
+            arr = np.lib.format.open_memmap(curnpy, mode='r')
 
-        logging.info(_('Number of hydrographs : {}'.format(len(hydro))))
-        for curhydro in hydro:
-            if curhydro.data.shape[1] != nb:
-                loclog = _('Bad number of columns for {} !'.format(curhydro[0]._filename))
+            if arr.shape != (self._header.nbx, self._header.nby):
+                loclog = _('Bad shape for {} !'.format(curnpy))
                 log += loclog + '\n'
                 logging.warning(loclog)
 
+            del(arr)
+
+        logging.info(_('Hydrographs...'))
+        hydro = self.get_hydrographs()
+        if len(hydro) == 0:
+            logging.info(_('No hydrographs found !'))
+            log += _('No hydrographs found !') + '\n'
+        else:
+            try:
+                nb = hydro[0].data.shape[1]
+
+                logging.info(_('Number of hydrographs : {}'.format(len(hydro))))
+                for curhydro in hydro:
+                    if curhydro.data.shape[1] != nb:
+                        loclog = _('Bad number of columns for {} !'.format(curhydro[0]._filename))
+                        log += loclog + '\n'
+                        logging.warning(loclog)
+            except Exception as e:
+                logging.error(_('Error while checking hydrographs: {}').format(e))
+                log += _('Error while checking hydrographs: {}').format(e) + '\n'
+
+        for curfile in GPU_2D_file:
+            if curfile.value.extension == '.npy':
+                if curfile.value.name + curfile.value.extension not in numpynames:
+                    loclog = _('Missing file {} !').format(curfile.value.name + curfile.value.extension)
+                    log += loclog + '\n'
+                    logging.warning(loclog)
+                else:
+                    try:
+                        wa = WolfArray(numpyfiles[numpynames.index(curfile.value.name + curfile.value.extension)])
+                        if wa.dtype != curfile.value.type:
+                            loclog = _('Bad dtype for {} ! Expected {}, got {}').format(
+                                curfile.value.name + curfile.value.extension,
+                                curfile.value.type, wa.dtype)
+                            log += loclog + '\n'
+                            logging.warning(loclog)
+                        del(wa)
+                    except Exception as e:
+                        loclog = _('Error while checking {}: {}').format(
+                            curfile.value.name + curfile.value.extension, e)
+                        log += loclog + '\n'
+                        logging.error(loclog)
+
+        if 'nap.npy' in numpynames:
+            nap =  WolfArray(numpyfiles[numpynames.index('nap.npy')])
+        else:
+            nap = None
+            logging.error(_('No nap file found !'))
+            log += _('No nap file found !') + '\n'
+
+        if nap is not None:
+            if 'infiltration_zones.npy' in numpynames:
+                # Check if infiltration zones are consistent
+                infil_zones = WolfArray(numpyfiles[numpynames.index('infiltration_zones.npy')])
+
+                if np.any(infil_zones.array[nap.array == 0] != 0):
+                    loclog = _('Infiltration zones are not consistent with the nap file !')
+                    log += loclog + '\n'
+
+                # find all non zero infiltration zones
+                non_zero_infil_zones = list(set(np.unique(infil_zones.array[nap.array == 1])))
+                if len(non_zero_infil_zones) == 0:
+                    loclog = _('No infiltration zones found !')
+                    log += loclog + '\n'
+                else:
+                    if non_zero_infil_zones[0] == 0:
+                        #pop
+                        non_zero_infil_zones.pop(0)
+                    if len(non_zero_infil_zones) == 0:
+                        loclog = _('No infiltration zones found !')
+                        log += loclog + '\n'
+
+                    elif non_zero_infil_zones[0] !=1:
+                        loclog = _('Infiltration zones should start at 1 ! Found {} instead.').format(non_zero_infil_zones[0])
+                        log += loclog + '\n'
+                        logging.warning(loclog)
+
+                        # increments
+                        if not all([non_zero_infil_zones[i] - non_zero_infil_zones[i-1] == 1 for i in range(1, len(non_zero_infil_zones))]):
+                            loclog = _('Infiltration zones are not consecutive !')
+                            log += loclog + '\n'
+                            logging.warning(loclog)
+                del(infil_zones)
+
+            if 'bathymetry.npy' in numpynames:
+                # Check if infiltration zones are consistent
+                bath = WolfArray(numpyfiles[numpynames.index('bathymetry.npy')])
+
+                if np.any(bath.array[nap.array == 0] != 99999.):
+                    loclog = _("Some bathymetry's cells are different of 99999 outside the computation domain !\n")
+                    loclog += _('This may lead to unexpected results !')
+                    log += loclog + '\n'
+
+                del(bath)
+
+            for file in ['h.npy', 'qx.npy', 'qy.npy']:
+                if file in numpynames:
+                    # Check if infiltration zones are consistent
+                    bath = WolfArray(numpyfiles[numpynames.index(file)])
+
+                    if np.any(bath.array[nap.array == 0] != 0.):
+                        loclog = _("Some cells are different of 0.0 outside the computation domain in {}!\n").format(file)
+                        loclog += _('This may lead to unexpected results !')
+                        log += loclog + '\n'
+
+                    del(bath)
+
         return log
 
     # Analyze files
@@ -1188,6 +1349,22 @@ class Config_Manager_2D_GPU:
         else:
             logging.error(_("No 'bathymetry.tif' file found in the root directory !"))
 
+    def create_void_dtm(self):
+        """ create void dtm file """
+        if (self.workingdir / 'bathymetry.tif').exists():
+            locheader = self.get_header()
+            dtm = WolfArray(srcheader=locheader, whichtype= WOLF_ARRAY_FULL_SINGLE)
+            dtm.array.data[:,:] = 99999.
+            dtm.nullvalue = 99999.
+            dtm.write_all(str(self.workingdir / 'dtm.tif'))
+
+            if (self.workingdir / 'dtm.tif').exists():
+                logging.info(_('dtm.tif created and set to 99999. ! -- Please edit it !'))
+            else:
+                logging.error(_("dtm.tif not created ! --  Does 'bathymetry.tif' or any '.tif' file exist in the root directory ?"))
+        else:
+            logging.error(_("No 'bathymetry.tif' file found in the root directory !"))
+
     def create_void_roof(self):
         """ create void roof file """
 
@@ -1774,10 +1951,18 @@ class UI_Manager_2D_GPU():
         self._reload.Bind(wx.EVT_BUTTON,self.onupdate_structure)
         self._reload.SetToolTip(_('reScan the directory and reload the entire structure'))
 
+        tif_sizer = wx.BoxSizer(wx.HORIZONTAL)
         self._create_void_infil = wx.Button(self._frame,label = _('Create .tif infiltration zones'))
         self._create_void_infil.Bind(wx.EVT_BUTTON,self.oncreate_void_infil)
         self._create_void_infil.SetToolTip(_('Create a void infiltration zones file based on bathymetry.tif'))
 
+        self._create_dtm = wx.Button(self._frame,label = _('Create .tif DTM'))
+        self._create_dtm.Bind(wx.EVT_BUTTON,self.oncreate_dtm)
+        self._create_dtm.SetToolTip(_('Create a DTM file based on bathymetry.tif\n\n - bathymetry.tif must be present in the root directory'))
+
+        tif_sizer.Add(self._create_void_infil, 1, wx.EXPAND)
+        tif_sizer.Add(self._create_dtm, 1, wx.EXPAND)
+
         bridge_sizer = wx.BoxSizer(wx.HORIZONTAL)
         self._create_void_roof = wx.Button(self._frame,label = _('Create .tif bridge/culvert roof elevation'))
         self._create_void_roof.Bind(wx.EVT_BUTTON,self.oncreate_void_roof)
@@ -1818,6 +2003,10 @@ class UI_Manager_2D_GPU():
         self._checkconsistency.Bind(wx.EVT_BUTTON,self.oncheck_consistency)
         self._checkconsistency.SetToolTip(_('Check consistency of the scenario\n\n - bathymetry.tif\n - manning.tif\n - infiltration.tif\n - hydrographs\n - initial conditions\n - boundary conditions\n - scripts'))
 
+        self._checkonesimulation = wx.Button(self._frame,label = _('Check one simulation'))
+        self._checkonesimulation.Bind(wx.EVT_BUTTON,self.oncheck_one_simulation)
+        self._checkonesimulation.SetToolTip(_('Check consistency of one simulation'))
+
         self._createsim = wx.Button(self._frame,label = _('Create simulation(s)'))
         self._createsim.Bind(wx.EVT_BUTTON,self.oncreate_simulation)
         self._createsim.SetToolTip(_('Create simulation(s) from selected hydrographs'))
@@ -1861,14 +2050,19 @@ class UI_Manager_2D_GPU():
 
         # buttons -> sizer
         sizer_buttons.Add(self._reload,1,wx.EXPAND)
-        sizer_buttons.Add(self._create_void_infil,1,wx.EXPAND)
+        sizer_buttons.Add(tif_sizer,1,wx.EXPAND)
         sizer_buttons.Add(bridge_sizer,1,wx.EXPAND)
         sizer_buttons.Add(self._create_void_scripts,1,wx.EXPAND)
         sizer_buttons.Add(self._check_prefix,1,wx.EXPAND)
         sizer_buttons.Add(self._create_vrt,1,wx.EXPAND)
         sizer_buttons.Add(self._translate_vrt,1,wx.EXPAND)
         sizer_buttons.Add(self._apply_scripts,1,wx.EXPAND)
-        sizer_buttons.Add(self._checkconsistency,1,wx.EXPAND)
+
+        _sizer_check = wx.BoxSizer(wx.HORIZONTAL)
+        _sizer_check.Add(self._checkconsistency, 1, wx.EXPAND)
+        _sizer_check.Add(self._checkonesimulation, 1, wx.EXPAND)
+
+        sizer_buttons.Add(_sizer_check,1,wx.EXPAND)
         sizer_buttons.Add(self._create_vec,1,wx.EXPAND)
         sizer_buttons.Add(self.listsims,1,wx.EXPAND)
         sizer_buttons.Add(self._createsim,1,wx.EXPAND)
@@ -1931,6 +2125,12 @@ class UI_Manager_2D_GPU():
         self._parent.create_void_infil()
         self.reload()
 
+    def oncreate_dtm(self, e:wx.MouseEvent):
+        """ Création d'un fichier DTM vide """
+
+        self._parent.create_void_dtm()
+        self.reload()
+
     def oncreate_void_roof(self, e:wx.MouseEvent):
         """ Création d'un fichier de toit de pont vide """
 
@@ -2122,6 +2322,40 @@ class UI_Manager_2D_GPU():
         else:
             self._txtctrl.WriteText(log)
 
+    def oncheck_one_simulation(self, e:wx.MouseEvent):
+        """ Vérification de la cohérence d'une simulation
+        """
+        self._txtctrl.Clear()
+        log = self._parent.check_one_simulation()
+        if log == '':
+            self._txtctrl.WriteText("\n\n".join([_("All seems fine !")]))
+        else:
+            self._txtctrl.WriteText("\n\n".join([log]))
+
+        # Info on Python Environment and wolfgpu Path and version
+        # -------------------------------------------------------
+
+        import sys
+        # Python Environment
+        self._txtctrl.write(_('\nPython Environment\n'))
+        self._txtctrl.write('-------------------\n')
+        self._txtctrl.write('Python version : {}\n'.format(sys.version))
+        self._txtctrl.write('Python path : {}\n'.format(sys.executable))
+        self._txtctrl.write('Python version info : {}\n'.format(sys.version_info))
+
+        # Test if wolfgpu.exe exists in script directory
+        # wolfgpu Path and version
+        self._txtctrl.write('\nWolfgpu Path and version\n')
+        self._txtctrl.write('------------------------\n')
+
+        wolfgpu = self._parent.wolfgpu
+        if wolfgpu.exists():
+            self._txtctrl.write('Wolfgpu.exe found in : {}\n'.format(self._parent.wolfgpu.parent))
+        else:
+            self._txtctrl.write('Wolfgpu.exe not found !\n')
+            self._parent.wolfgpu = None
+
+
     def oncheck_consistency(self,e:wx.MouseEvent):
         """ Vérification de la cohérence des fichiers """
 
@@ -2422,10 +2656,12 @@ class UI_Manager_2D_GPU():
         self._txtctrl.SetBackgroundColour(wx.WHITE)
         self._txtctrl.SetForegroundColour(wx.BLACK)
 
+        self._parent._active_simulation = None
         if isinstance(mydata, dict):
             self._txtctrl.write(_('Yous have selected : {}\n\n'.format(str(mydata['path']))))
 
             if mydata[IS_SIMUL]:
+                self._parent._active_simulation = mydata
                 self._txtctrl.write(_('GPU SIMULATION\n\n'))
 
                 if ctrl and not shift and not alt:

wolfhece/ui/wolf_multiselection_collapsiblepane.py

@@ -211,6 +211,8 @@ class Wolf_MultipleSelection(wx.Dialog):
             assert len(self.delete_if_transfer) == len(values_dict), "delete_if_transfer must be a list of len(values_dict)"
             for i, values in enumerate(values_dict.values()):
                 assert isinstance(self.delete_if_transfer[i], bool), "delete_if_transfer must be a list of boolean"
+        else:
+            self.delete_if_transfer = None
 
         super().__init__(parent, title=title)
 
@@ -339,6 +341,145 @@ class Wolf_MultipleSelection(wx.Dialog):
         if self.callback is not None:
             self.callback(self)
 
+class Wolf_CompareArrays_Selection(Wolf_MultipleSelection):
+    """
+    Dialog with multiple 'collapsiblepanes' containing 2 lists to select multiple items
+    This class is a specific case of Wolf_MultipleSelection for comparing arrays
+    """
+    def __init__(self,
+                 parent,
+                 title,
+                 values_dict:dict,
+                 callback = None,
+                 info:str='',
+                 cmdApply:bool=False,
+                 styles = wx.LB_EXTENDED,
+                 destroyOK = False,
+                 **kwargs):
+        """
+        :param parent : wx.Window
+        :param title : str - title of the frame
+        :param values_dict : dict - {'label1':[item1, item2, ...], 'label2':[item1, item2, ...], ...}
+        :param callback : function - callback function when OK or Apply button is pressed
+        :param info : str - information to display upper the collapsiblepanes
+        :param cmdApply : bool - if True, Apply button is displayed
+        :param styles : wx.ListBox styles - wx constant or list of wx constants
+        :param kwargs : dict - other arguments for wx.Frame (example : max_selected_items=[1, 2, 3], delete_if_transfer=[True, False, True])
+        """
+        super().__init__(parent=parent,
+                         title=title,
+                         values_dict=values_dict,
+                         callback=callback,
+                         info=info,
+                         cmdApply=cmdApply,
+                         styles=styles,
+                         destroyOK=destroyOK,
+                         max_selected_items=[1]*len(values_dict),
+                         delete_if_transfer=[True]*len(values_dict),
+                         **kwargs)
+        
+        # add some UI specific to the compare arrays selection
+
+        # textbox for a threshold value
+        self.threshold_label = wx.StaticText(self, label="Threshold value [m]:")
+        self.threshold_value = wx.TextCtrl(self, value="0.01", style=wx.TE_PROCESS_ENTER | wx.TE_CENTER)
+        self.threshold_value.Bind(wx.EVT_TEXT_ENTER, self._on_threshold_enter)
+        self.threshold_value.Bind(wx.EVT_KILL_FOCUS, self._on_threshold_enter)
+        self.threshold_value.SetToolTip("Enter a threshold value - All differences below this threshold will be considered as equal")
+        # add the threshold label and value to the sizer
+        sizer = self.GetSizer()
+
+        sizer_threshold = wx.BoxSizer(wx.HORIZONTAL)
+        sizer_threshold.Add(self.threshold_label, proportion=0, flag=wx.ALIGN_CENTER_VERTICAL | wx.ALL, border=5)
+        sizer_threshold.Add(self.threshold_value, proportion=1, flag=wx.EXPAND | wx.ALL, border=5)
+        sizer.Add(sizer_threshold, proportion=0, flag=wx.EXPAND | wx.ALL, border=5)
+
+        # textbox for a minimal area value
+        self.min_area_label = wx.StaticText(self, label="Minimal area value [m²]:")
+        self.min_area_value = wx.TextCtrl(self, value="2.0", style=wx.TE_PROCESS_ENTER | wx.TE_CENTER)
+        self.min_area_value.Bind(wx.EVT_TEXT_ENTER, self._on_min_area_enter)    
+        self.min_area_value.Bind(wx.EVT_KILL_FOCUS, self._on_min_area_enter)
+        self.min_area_value.SetToolTip("Enter a minimal area value - All patches below this area will be ignored")
+        # add the minimal area label and value to the sizer
+        sizer_min_area = wx.BoxSizer(wx.HORIZONTAL)
+        sizer_min_area.Add(self.min_area_label, proportion=0, flag=wx.ALIGN_CENTER_VERTICAL | wx.ALL, border=5)
+        sizer_min_area.Add(self.min_area_value, proportion=1, flag=wx.EXPAND | wx.ALL, border=5)
+        sizer.Add(sizer_min_area, proportion=0, flag=wx.EXPAND | wx.ALL, border=5)
+        # Maximum patches to include in the report
+        self.max_patches_label = wx.StaticText(self, label="Maximum patches to include in the report:")
+        self.max_patches_value = wx.TextCtrl(self, value="10", style=wx.TE_PROCESS_ENTER | wx.TE_CENTER)
+        self.max_patches_value.Bind(wx.EVT_TEXT_ENTER, self._on_max_patches_enter)
+        self.max_patches_value.Bind(wx.EVT_KILL_FOCUS, self._on_max_patches_enter)
+        self.max_patches_value.SetToolTip("Enter a maximum number of patches to include in the report - If more patches are found, only the first ones will be included")
+        # add the maximum patches label and value to the sizer
+        sizer_max_patches = wx.BoxSizer(wx.HORIZONTAL)
+        sizer_max_patches.Add(self.max_patches_label, proportion=0, flag=wx.ALIGN_CENTER_VERTICAL | wx.ALL, border=5)
+        sizer_max_patches.Add(self.max_patches_value, proportion=1, flag= wx.EXPAND | wx.ALL, border=5)
+        sizer.Add(sizer_max_patches, proportion=0, flag=wx.EXPAND | wx.ALL, border=5)
+        # add the sizer to the main sizer
+        self.SetSizer(sizer)
+        self.Fit()
+        self.Layout()
+
+
+    def _on_threshold_enter(self, event):
+        """ Callback when the threshold value is changed """
+        try:
+            value = float(self.threshold_value.GetValue())
+            if value < 0:
+                self.threshold_value.SetValue("0.01")
+        except ValueError as e:
+            wx.MessageBox(f"Invalid threshold value: {e}", "Error", wx.OK | wx.ICON_ERROR)
+            self.threshold_value.SetValue("0.01")
+        event.Skip()
+
+    def _on_min_area_enter(self, event):
+        """ Callback when the minimal area value is changed """
+        try:
+            value = float(self.min_area_value.GetValue())
+            if value < 0:
+                self.min_area_value.SetValue("2.0")
+        except ValueError as e:
+            wx.MessageBox(f"Invalid minimal area value: {e}", "Error", wx.OK | wx.ICON_ERROR)
+            self.min_area_value.SetValue("2.0")
+        event.Skip()
+
+    def _on_max_patches_enter(self, event):
+        """ Callback when the maximum patches value is changed """
+        try:
+            value = int(self.max_patches_value.GetValue())
+            if value < 1:
+                self.max_patches_value.SetValue("10")
+        except ValueError as e:
+            wx.MessageBox(f"Invalid maximum patches value: {e}", "Error", wx.OK | wx.ICON_ERROR)
+            self.max_patches_value.SetValue("10")
+        event.Skip()
+
+    def get_threshold(self):
+        """ Get the threshold value """
+        try:
+            return float(self.threshold_value.GetValue())
+        except ValueError:
+            wx.MessageBox("Invalid threshold value", "Error", wx.OK | wx.ICON_ERROR)
+            return 0.01
+        
+    def get_min_area(self):
+        """ Get the minimal area value """
+        try:
+            return float(self.min_area_value.GetValue())
+        except ValueError:
+            wx.MessageBox("Invalid minimal area value", "Error", wx.OK | wx.ICON_ERROR)
+            return 2.0
+        
+    def get_max_patches(self):
+        """ Get the maximum patches value """
+        try:
+            return int(self.max_patches_value.GetValue())
+        except ValueError:
+            wx.MessageBox("Invalid maximum patches value", "Error", wx.OK | wx.ICON_ERROR)
+            return 10
+        
+
 if __name__ == "__main__":
     # Utilisation de la classe Wolf_MultipleSelection
     app = wx.App()
@@ -351,6 +492,17 @@ if __name__ == "__main__":
                                 callback=None,
                                 styles=[wx.LB_SINGLE, wx.LB_EXTENDED, wx.LB_EXTENDED],
                                 max_selected_items=[1, -1, -1],)
-    frame.ShowModal()
+    
+    fram2 = Wolf_CompareArrays_Selection(None,
+                                         title="Exemple de Wolf_CompareArrays_Selection",
+                                            values_dict={'domain':["Item 1", "Item 2", "Item 3", "Item 4"],
+                                                        'u':["Item 3", "Item 4", "Item 5", "Item 6"],
+                                                        'v':["Item v1", "Item v2", "Item v3", "Item v4"]},
+                                            info="You can define :                     \n   - the domain\n   - u\n   -v",
+                                            callback=None,
+                                            styles=[wx.LB_SINGLE, wx.LB_SINGLE, wx.LB_SINGLE],
+                                            destroyOK=True)
+    
+    fram2.ShowModal()
     pass
     app.MainLoop()

wolfhece/wolf_array.py

@@ -3953,6 +3953,10 @@ class SelectionData():
     def get_script(self, which:int = None) -> str:
         """ Get script of the current selection or of a stored one """
 
+        if self.myselection == 'all':
+            logging.error(_('Cannot create script for "all" selection'))
+            return ''
+
         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'
@@ -5779,63 +5783,6 @@ class WolfArray(Element_To_Draw, header_wolf):
         if mapviewer is not None:
             mapviewer.add_object('array', newobj = newarray, ToCheck = True, id = self.idx + '_extracted')
 
-    def crop_array(self, bbox:list[list[float],list[float]], setnull_trx_try:bool = False) -> "WolfArray":
-        """ Crop the data based on the bounding box.
-
-        Beware of the grid:
-        - If the cropped region is smaller than a cell, then the cropped array
-          will be empty.
-        - If the cropped region doesn't align with the source array grid, it
-          will be forced to do so.
-
-        :param bbox: bounding box [[xmin, xmax], [ymin, ymax]].
-        :param setnull_trx_try: set the translation to 0 if True, origx and
-          origy will be set to the lower left corner of the bbox. Default is
-          `False`.
-        """
-
-        xmin, xmax = bbox[0]
-        ymin, ymax = bbox[1]
-
-        # Make sure the bounding box can be used.
-        if xmin > xmax:
-            xmin, xmax = xmax, xmin
-        if ymin > ymax:
-            ymin, ymax = ymax, ymin
-
-        imin, jmin = self.get_ij_from_xy(xmin, ymin)
-        imax, jmax = self.get_ij_from_xy(xmax, ymax)
-
-        imin = int(imin)
-        jmin = int(jmin)
-        imax = int(imax)
-        jmax = int(jmax)
-
-        newheader = header_wolf()
-        newheader.nbx = imax-imin
-        newheader.nby = jmax-jmin
-        newheader.dx  = self.dx
-        newheader.dy  = self.dy
-        newheader.origx, newheader.origy = self.get_xy_from_ij(imin, jmin, abs = setnull_trx_try)
-        newheader.origx -= self.dx / 2.
-        newheader.origy -= self.dy / 2.
-        newheader.translx = self.translx
-        newheader.transly = self.transly
-
-        if setnull_trx_try:
-            newheader.translx = 0.
-            newheader.transly = 0.
-
-        newarray = WolfArray(srcheader=newheader)
-
-        if imin < imax and jmin < jmax:
-            newarray.array[:,:] = self.array[imin:imax, jmin:jmax]
-        else:
-            # One of the dimensions has 0 size => the array is empty
-            pass
-
-        return newarray
-
     def get_centers(self, usenap:bool = True):
         """ Get the centers of the cells """
 
@@ -10023,12 +9970,67 @@ class WolfArray(Element_To_Draw, header_wolf):
             newWolfArray.count()
             return newWolfArray
 
-    def crop_masked_at_edges(self):
+    def crop_array(self, bbox:list[list[float],list[float]], setnull_trx_try:bool = False) -> "WolfArray":
+        """ Crop the data based on the bounding box.
+
+        Beware of the grid:
+        - If the cropped region is smaller than a cell, then the cropped array
+          will be empty.
+        - If the cropped region doesn't align with the source array grid, it
+          will be forced to do so.
+
+        :param bbox: bounding box [[xmin, xmax], [ymin, ymax]].
+        :param setnull_trx_try: set the translation to 0 if True, origx and
+          origy will be set to the lower left corner of the bbox. Default is
+          `False`.
+        """
+
+        xmin, xmax = bbox[0]
+        ymin, ymax = bbox[1]
+
+        # Make sure the bounding box can be used.
+        if xmin > xmax:
+            xmin, xmax = xmax, xmin
+        if ymin > ymax:
+            ymin, ymax = ymax, ymin
+
+        imin, jmin = self.get_ij_from_xy(xmin, ymin)
+        imax, jmax = self.get_ij_from_xy(xmax, ymax)
+
+        imin = int(imin)
+        jmin = int(jmin)
+        imax = int(imax)
+        jmax = int(jmax)
+
+        newheader = header_wolf()
+        newheader.nbx = imax-imin
+        newheader.nby = jmax-jmin
+        newheader.dx  = self.dx
+        newheader.dy  = self.dy
+        newheader.origx, newheader.origy = self.get_xy_from_ij(imin, jmin, abs = setnull_trx_try)
+        newheader.origx -= self.dx / 2.
+        newheader.origy -= self.dy / 2.
+        newheader.translx = self.translx
+        newheader.transly = self.transly
+
+        if setnull_trx_try:
+            newheader.translx = 0.
+            newheader.transly = 0.
+
+        newarray = WolfArray(srcheader=newheader)
 
+        if imin < imax and jmin < jmax:
+            newarray.array[:,:] = self.array[imin:imax, jmin:jmax]
+        else:
+            # One of the dimensions has 0 size => the array is empty
+            pass
+
+        return newarray
+
+    def crop_masked_at_edges(self):
         """
         Crop the array to remove masked cells at the edges of the array
         :return: cropped array, WolfArray instance
-
         """
 
         # Get max indexes
@@ -10083,9 +10085,9 @@ class WolfArray(Element_To_Draw, header_wolf):
             newWolfArray.origz = self.origz + float(k_start) * self.dz
             newWolfArray.translz = self.translz
 
-            newWolfArray.array = self.array[i_start:i_start + nbx, j_start:j_start + nby, k_start:k_start + nbz]
+            newWolfArray.array = self.array[i_start:i_start + nbx, j_start:j_start + nby, k_start:k_start + nbz].copy()
         elif self.nbdims == 2:
-            newWolfArray.array = self.array[i_start:i_start + nbx, j_start:j_start + nby]
+            newWolfArray.array = self.array[i_start:i_start + nbx, j_start:j_start + nby].copy()
 
         return newWolfArray
 
@@ -10343,7 +10345,10 @@ class WolfArray(Element_To_Draw, header_wolf):
             self._ymax_plot = ymax
 
         nbpix = min(sx * self.dx, sy * self.dy)
-        if nbpix >= 1.:
+        if nbpix == 0.:
+            logging.warning(_('WolfArray.plot - No pixels to plot'))
+            return
+        elif nbpix >= 1.:
             # si une maille est tracée sur au moins 2 pixels
             curscale = 1
         elif math.ceil(1. / nbpix) <= 3: