wolfhece 2.0.54__py3-none-any.whl → 2.1.0__py3-none-any.whl

wolfhece/PyDraw.py

@@ -12,6 +12,7 @@ from PIL.PngImagePlugin import PngInfo
 import io
 import json
 import glob
+import traceback
 try:
     from osgeo import gdal
 except ModuleNotFoundError:
@@ -50,7 +51,7 @@ from .wolfresults_2D import Wolfresults_2D, views_2D
 from .PyTranslate import _
 from .PyVertex import cloud_vertices, getIfromRGB
 from .RatingCurve import SPWMIGaugingStations, SPWDCENNGaugingStations
-from .wolf_array import WOLF_ARRAY_MB, SelectionData, WolfArray, WolfArray_Sim2D, WolfArrayMB, CropDialog, header_wolf, WolfArrayMNAP, WOLF_ARRAY_FULL_SINGLE, WOLF_ARRAY_FULL_INTEGER8, WOLF_ARRAY_FULL_INTEGER16, WOLF_ARRAY_FULL_DOUBLE, WOLF_ARRAY_FULL_INTEGER
+from .wolf_array import WOLF_ARRAY_MB, SelectionData, WolfArray, WolfArrayMB, CropDialog, header_wolf, WolfArrayMNAP, WOLF_ARRAY_FULL_SINGLE, WOLF_ARRAY_FULL_INTEGER8, WOLF_ARRAY_FULL_INTEGER16, WOLF_ARRAY_FULL_DOUBLE, WOLF_ARRAY_FULL_INTEGER
 from .PyParams import Wolf_Param, key_Param, Type_Param
 from .mesh2d.bc_manager import BcManager
 from .PyVertexvectors import *
@@ -151,7 +152,27 @@ class WolfMapViewer(wx.Frame):
     active_particle_system: Particle_system
     active_viewer3d: Wolf_Viewer3D
 
-    def __init__(self, wxparent, title, w=500, h=500, treewidth=200, wolfparent=None, wxlogging=None):
+    def __init__(self,
+                 wxparent = None,
+                 title:str = _('Default Wolf Map Viewer'),
+                 w:int=500,
+                 h:int=500,
+                 treewidth:int=200,
+                 wolfparent=None,
+                 wxlogging=None):
+
+        """
+        Create a Viewer for WOLF data/simulation
+
+        :params wxparent: wx parent - set to None if main window
+        :params title: title of the window
+        :params w: width of the window in pixels
+        :params h: height of the window in pixels
+        :params treewidth: width of the tree list in pixels
+        :params wolfparent: WOLF object parent -- see PyGui.py
+        :params wxlogging: wx logging object
+
+        """
 
         self._wxlogging = wxlogging
         self.action = None  # Action à entreprendre
@@ -220,6 +241,7 @@ class WolfMapViewer(wx.Frame):
         self.menu2d_cache_setup = None
         self.menuparticlesystem = None
         self.menu2dGPU = None
+        self.menuwalous = None
         self.timer_ps = None
         self.menusim2D  = None
         self.menulaz    = None
@@ -245,9 +267,16 @@ class WolfMapViewer(wx.Frame):
         updategltf = self.menugltf.Append(wx.ID_ANY, _('Update...'), _('Update data from gltf files'))
 
         self.filemenu.AppendSeparator()
-        check2D = self.filemenu.Append(wx.ID_ANY, _('Check 2D simulation headers'), _('Check 2D sim'))
+
+        # SIMULATION 2D
+
+        sim2d = self.filemenu.Append(wx.ID_ANY, _('Create/Open multiblock model'), _('Create or open a multiblock model in a new viewer'))
+        check2D = self.filemenu.Append(wx.ID_ANY, _('Check headers'), _('Check the header .txt files from an existing 2D simulation'))
 
         self.filemenu.AppendSeparator()
+
+        # MULTIVIEWER
+
         compareitem = self.filemenu.Append(wx.ID_ANY, _('Set comparison'), _('Set comparison'))
         multiview = self.filemenu.Append(wx.ID_ANY, _('Multiviewer'), _('Multiviewer'))
         viewer3d = self.filemenu.Append(wx.ID_ANY, _('3D viewer'), _('3D viewer'))
@@ -387,6 +416,8 @@ class WolfMapViewer(wx.Frame):
         curtool['menu'] = self.plot_cs
         curtool['name'] = 'Plot cross section'
 
+        self.mybc = []
+
         self.active_vector = None
         self.active_zone = None
         self.active_zones = None
@@ -515,6 +546,32 @@ class WolfMapViewer(wx.Frame):
     def wxlogging(self, value):
         self._wxlogging = value
 
+
+    def create_2D_MB_model(self):
+        """ Create a 2D model """
+
+        from .PyGui import Wolf2DModel
+
+        newview = Wolf2DModel(splash = False)
+
+    def check_2D_MB_headers(self):
+        """ Check headers of a 2D simulation without opening viewer"""
+
+        # Check 2D simulation
+        dlg = wx.FileDialog(self, _("Choose 2D simulation file"), wildcard="all (*.*)|*.*", style=wx.FD_OPEN)
+        if dlg.ShowModal() == wx.ID_CANCEL:
+            dlg.Destroy()
+            return
+
+        filename = dlg.GetPath()
+        dlg.Destroy()
+
+        from .mesh2d.wolf2dprev import prev_sim2D
+
+        sim = prev_sim2D(filename)
+        sim.verify_files()
+
+
     def get_mapviewer(self):
         """ Retourne une instance WolfMapViewer """
         return self
@@ -654,16 +711,345 @@ class WolfMapViewer(wx.Frame):
 
         if self.menuwolf2d is None:
             self.menuwolf2d = wx.Menu()
+
             self.menu2d_curentview = self.menuwolf2d.Append(wx.ID_ANY, _("Change current view"), _("Current view"))
             self.menu2d_lastres = self.menuwolf2d.Append(wx.ID_ANY, _("Read last result"), _("Current view"))
             self.menu2d_epsilon = self.menuwolf2d.Append(wx.ID_ANY, _("Set epsilon water depth"), _("Set the epsilon used in the mask"))
 
             self.menu_filter_independent = self.menuwolf2d.Append(wx.ID_ANY, _("Filter independent"), _("Filter independent"), kind=wx.ITEM_CHECK)
 
-            self.menu2d_bc = self.menuwolf2d.Append(wx.ID_ANY, _("Manage boundary conditions..."), _("BC manager"))
+            # 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.menubar.Append(self.menuwolf2d, _('Options 2D'))
+            self.menubar.Append(self.menuwolf2d, _('Results 2D'))
+
+            self.menuwolf2d.Bind(wx.EVT_MENU, self.Onmenuwolf2d)
+
+    def menu_walous(self):
+
+        if self.menuwalous is None:
+            self.menuwalous = wx.Menu()
+
+            self.menuwalous_crop = self.menuwalous.Append(wx.ID_ANY, _("Crop on active array"), _("Crop active array"))
+            self.menuwalous_cropscreen = self.menuwalous.Append(wx.ID_ANY, _("Crop on screen"), _("Crop screen"))
+            self.menuwalous_map = self.menuwalous.Append(wx.ID_ANY, _("Map active array"), _("Map active array"))
+            self.menuwalous_legend = self.menuwalous.Append(wx.ID_ANY, _("Legend"), _("Legend"))
+            self._walous_filepath = None
+            self._walous_layer = None
+            self._walous_map = None
+
+            self.menubar.Append(self.menuwalous, _('Walous'))
+
+            self.menuwalous.Bind(wx.EVT_MENU, self.Onmenuwalous)
+
+
+    def get_canvas_bounds(self, gridsize:float = None):
+        """ Retourne les limites de la zone d'affichage """
+
+        if gridsize is None:
+
+            return [self.xmin, self.ymin, self.xmax, self.ymax]
+
+        else:
+
+            xmin = float(np.rint(self.xmin / gridsize) * gridsize)
+            ymin = float(np.rint(self.ymin / gridsize) * gridsize)
+            xmax = float(np.rint(self.xmax / gridsize) * gridsize)
+            ymax = float(np.rint(self.ymax / gridsize) * gridsize)
+
+            return [xmin, ymin, xmax, ymax]
+
+    def Onmenuwalous(self, event: wx.MenuEvent):
+
+        id = event.GetId()
+        item = self.menubar.FindItemById(event.GetId())
+
+        if item is None:
+            return
+
+        itemlabel = item.ItemLabel
+
+        if itemlabel in [_("Crop on active array"), _("Crop on screen")]:
+
+
+            if itemlabel == _("Crop on screen"):
+
+                bounds = self.get_canvas_bounds(gridsize=1.)
+
+                def_outdrir = ''
+                spatial_res = 1.
+
+                if self.active_array is not None:
+                    spatial_res = self.active_array.dx
+
+                dlg = wx.TextEntryDialog(None,_("Spatial resolution [m] ?"), value = str(spatial_res))
+
+                dlg.ShowModal()
+                try:
+                    spatial_res = float(dlg.GetValue())
+                    dlg.Destroy()
+                except:
+                    dlg.Destroy()
+                    logging.warning(_("Bad value -- Rety"))
+                    return
+
+            else:
+
+                if self.active_array is None:
+                    logging.warning(_('No active array -- Please activate data first'))
+                    return
+
+                bounds = self.active_array.get_bounds()
+                def_outdrir = Path(self.active_array.filename).parent
+                spatial_res = self.active_array.dx
+
+            from .pywalous import Walous_data, WALOUS2MANNING_MAJ_NIV1, WALOUS2MANNING_MAJ_NIV2, update_palette_walous
+
+            if self._walous_filepath is None:
+                dlg = wx.FileDialog(self, _("Choose the Walous shape file"), wildcard="Shapefile (*.shp)|*.shp|all (*.*)|*.*", style=wx.FD_OPEN)
+                if dlg.ShowModal() == wx.ID_CANCEL:
+                    dlg.Destroy()
+                    return
+
+                self._walous_filepath = Path(dlg.GetPath())
+                dlg.Destroy()
+
+
+            dlg = wx.FileDialog(self, _("Choose the output file"), wildcard="Geotif (*.tif)|*.tif|all (*.*)|*.*", style=wx.FD_SAVE, defaultDir=def_outdrir)
+            if dlg.ShowModal() == wx.ID_CANCEL:
+                dlg.Destroy()
+                return
+
+            output = Path(dlg.GetPath())
+            dlg.Destroy()
+
+            # choix de la couche entre MAJ_NIV1 et MAJ_NIV2
+            dlg = wx.SingleChoiceDialog(None, _("Choose a layer"), "Choices", ['MAJ_NIV1', 'MAJ_NIV2'])
+            ret = dlg.ShowModal()
+            if ret == wx.ID_CANCEL:
+                dlg.Destroy()
+                return
+
+            self._walous_layer = dlg.GetStringSelection()
+
+            locwalous = Walous_data(self._walous_filepath.parent, self._walous_filepath.name)
+            ret = locwalous.rasterize(bounds=bounds,
+                                      layer=self._walous_layer,
+                                      fn_out=output,
+                                      pixel_size=spatial_res)
+
+            if isinstance(ret, int):
+                logging.error(_('Error {}').format(ret))
+                return
+
+            if Path(output).exists():
+                logging.info(_('File {} created').format(output))
+            else:
+                logging.error(_('File {} not created').format(output))
+                return
+
+            dlg = wx.MessageDialog(self, _('Do you want to load the created file ?'), _('Load file'), wx.YES_NO | wx.ICON_QUESTION)
+            ret = dlg.ShowModal()
+
+            if ret == wx.ID_CANCEL:
+                dlg.Destroy()
+                return
+
+            elif ret == wx.ID_YES:
+                walousarray = WolfArray(fname=output)
+                update_palette_walous(self._walous_layer, walousarray.mypal)
+                self.add_object('array', newobj=walousarray, id = 'walous_crop')
+                dlg.Destroy()
+
+        elif itemlabel == _("Legend"):
+
+            from .pywalous import WalousLegend
+
+            newlegend = WalousLegend(self)
+            newlegend.Show()
+
+        elif itemlabel == _("Map active array"):
+
+            from .pywalous import DlgMapWalous, WALOUS2MANNING_MAJ_NIV1, WALOUS2MANNING_MAJ_NIV2
+
+            if self.active_array is None:
+                logging.warning(_('No active array -- Please activate data first'))
+                return
+
+            vals = self.active_array.get_unique_values()
+
+            if self._walous_layer is None:
+
+                if vals[0] > 10:
+                    self._walous_layer = 'MAJ_NIV2'
+                else:
+                    self._walous_layer = 'MAJ_NIV1'
+
+            dlg = DlgMapWalous(self, which=self._walous_layer)
+
+            ret = dlg.ShowModal()
+
+            if ret == wx.ID_CANCEL:
+                dlg.Destroy()
+                return
+
+            mapvals = dlg.get_mapping()
+            dlg.Destroy()
+
+            if mapvals == -1:
+                logging.error(_('Bad values -- retry'))
+                return
+
+            self.active_array.map_values(mapvals)
+
+            self.active_array.reset_plot()
+
+    def Onmenuwolf2d(self, event: wx.MenuEvent):
+
+        id = event.GetId()
+        item = self.menubar.FindItemById(event.GetId())
+
+        if item is None:
+            return
+
+        itemlabel = item.ItemLabel
+
+
+        if itemlabel == _("Read last result"):
+
+            self.read_last_result()
+
+        elif itemlabel == _("Change current view"):
+
+            # Change view for results
+
+            autoscale = False
+            choices = [cur.value for cur in views_2D]
+            dlg = wx.SingleChoiceDialog(None, _("Pick a view"), "Choices", choices)
+            ret = dlg.ShowModal()
+            if ret == wx.ID_CANCEL:
+                dlg.Destroy()
+                return
+
+            method = dlg.GetStringSelection()
+
+            method = list(views_2D)[choices.index(method)]
+
+            dlg.Destroy()
+
+            diamsize = None
+            if method == views_2D.SHIELDS_NUMBER :
+
+                if self.active_res2d is not None:
+                    sediment_diam = self.active_res2d.sediment_diameter
+                    sediment_density = self.active_res2d.sediment_density
+                elif self.compare_results is not None:
+                    sediment_diam = 0.001
+                    sediment_density = 2.650
+                else:
+                    logging.warning(_('No active 2D result or comparison !'))
+                    return
+
+                dlg = wx.TextEntryDialog(None,_("Diameter grain size [m] ?"), value = str(sediment_diam))
+                ret = dlg.ShowModal()
+                if ret == wx.ID_CANCEL:
+                    dlg.Destroy()
+                    return
+                try:
+                    diamsize = float(dlg.GetValue())
+                except:
+                    dlg.Destroy()
+                    logging.warning(_("Bad value -- Rety"))
+                    return
+
+                dlg = wx.TextEntryDialog(None,_("Density grain [-] ?"), value = str(sediment_density))
+                ret = dlg.ShowModal()
+                if ret == wx.ID_CANCEL:
+                    dlg.Destroy()
+                    return
+                try:
+                    density = float(dlg.GetValue())
+                except:
+                    dlg.Destroy()
+                    logging.warning(_("Bad value -- Rety"))
+                    return
+
+            if len(self.myres2D)>1:
+
+                dlg = wx.MessageDialog(None, _('Apply to all results?'), style=wx.YES_NO)
+                ret = dlg.ShowModal()
+                if ret == wx.ID_NO:
+                    if diamsize is not None:
+                        self.active_res2d.sediment_diameter = diamsize
+                        self.active_res2d.sediment_density = density
+                        self.active_res2d.load_default_colormap('shields_cst')
+
+                    self.active_res2d.set_currentview(method, force_wx = True, force_updatepal = True)
+                else:
+                    for curarray in self.iterator_over_objects(draw_type.RES2D):
+                        curarray:Wolfresults_2D
+                        if diamsize is not None:
+                            curarray.sediment_diameter = diamsize
+                            curarray.sediment_density  = density
+                            curarray.load_default_colormap('shields_cst')
+
+                        curarray.set_currentview(method, force_wx = True, force_updatepal = True)
+
+            else:
+                if self.active_res2d is not None:
+                    if diamsize is not None:
+                        self.active_res2d.sediment_diameter = diamsize
+                        self.active_res2d.sediment_density = density
+                        self.active_res2d.load_default_colormap('shields_cst')
+                    self.active_res2d.set_currentview(method, force_wx = True, force_updatepal = True)
+
+            if self.compare_results is not None:
+                # update compare results
+                if diamsize is not None:
+                    self.compare_results.set_shields_param(diamsize, density)
+                self.compare_results.update_type_result(method)
+
+        elif itemlabel == _("Set epsilon water depth"):
+
+            dlg = wx.TextEntryDialog(self, _('Enter an epsilon [m]'),value='0.0')
+
+            ret = dlg.ShowModal()
+
+            if ret == wx.ID_CANCEL:
+                dlg.Destroy()
+                return
+
+            try:
+                neweps = float(dlg.GetValue())
+                dlg.Destroy()
+            except:
+                logging.error(_('Bad value -- retry !'))
+                dlg.Destroy()
+                return
+
+            for curmodel in self.iterator_over_objects(draw_type.RES2D):
+                curmodel: Wolfresults_2D
+                curmodel.epsilon = neweps
+                curmodel._epsilon_default = neweps
+                curmodel.read_oneresult(curmodel.current_result)
+                curmodel.set_currentview()
+
+        elif itemlabel == _("Filter independent"):
+
+            self.menu_filter_independent.IsChecked = not self.menu_filter_independent.IsChecked
+
+            for curmodel in self.iterator_over_objects(draw_type.RES2D):
+                curmodel: Wolfresults_2D
+                curmodel.to_filter_independent = not self.menu_filter_independent.IsChecked
+
+        # elif itemlabel == _("Manage boundary conditions..."):
+
+        #     if self.active_res2d is not None:
+        #         self.active_res2d.myparams.editing_bc(self.myres2D)
+
+        elif itemlabel ==_("Create video..."):
+            if self.active_res2d is not None:
+                self.create_video()
 
     def menu_2dgpu(self):
 
@@ -903,21 +1289,21 @@ class WolfMapViewer(wx.Frame):
                 if self.active_array is None:
                     logging.warning(_('No active array -- Please activate an array first'))
                     return
-                if len(self.active_array.mngselection.myselection) == 0 and len(self.active_array.mngselection.selections) ==0:
+                if len(self.active_array.SelectionData.myselection) == 0 and len(self.active_array.SelectionData.selections) ==0:
                     logging.warning(_('No selection -- Please select some nodes first'))
                     return
 
                 from .lagrangian.emitter import Emitter
 
                 newemitters=[]
-                if len(self.active_array.mngselection.myselection) > 0:
-                    indices = [self.active_array.get_ij_from_xy(cur[0], cur[1]) for cur in self.active_array.mngselection.myselection]
+                if len(self.active_array.SelectionData.myselection) > 0:
+                    indices = [self.active_array.get_ij_from_xy(cur[0], cur[1]) for cur in self.active_array.SelectionData.myselection]
                     newemitters = [Emitter(indices,
                                          header = (self.active_array.origx, self.active_array.origy, self.active_array.dx, self.active_array.dy))]
 
-                if len(self.active_array.mngselection.selections) > 0:
+                if len(self.active_array.SelectionData.selections) > 0:
 
-                    for cursel in self.active_array.mngselection.selections.values():
+                    for cursel in self.active_array.SelectionData.selections.values():
                         indices = [self.active_array.get_ij_from_xy(cur[0], cur[1]) for cur in cursel['select']]
                         newemitters += [Emitter(indices, header = (self.active_array.origx, self.active_array.origy, self.active_array.dx, self.active_array.dy))]
 
@@ -980,18 +1366,162 @@ class WolfMapViewer(wx.Frame):
                 self.timer_ps.Stop()
 
     def menu_sim2D(self):
+        """ Menu for 2D simulations """
+
         if self.menusim2D is None:
             self.menusim2D = wx.Menu()
             self.menubar.Append(self.menusim2D, _('Tools 2D'))
 
-            update = self.menusim2D.Append(wx.ID_ANY, _('Update model from current mask'), _('Update model'))
-            updateblocfile = self.menusim2D.Append(wx.ID_ANY, _('Update .bloc file'), _('Update bloc'))
-            updatefreesurface = self.menusim2D.Append(wx.ID_ANY, _('Update free surface elevation - IC'), _('Update free surface elevation'))
-            updaterough = self.menusim2D.Append(wx.ID_ANY, _('Update roughness coeff'), _('Update roughness coefficient'))
-            updateic = self.menusim2D.Append(wx.ID_ANY, _('Update IC reading mode'), _('Update IC'))
-            menu2d_tft_ic = self.menusim2D.Append(wx.ID_ANY,_("Transfer initial conditions..."),_("Transfer IC"))
+            menu2d_options = self.menusim2D.Append(wx.ID_ANY, _("Parameters..."), _("Parameters"))
+            menu2d_zbin2hbin = self.menusim2D.Append(wx.ID_ANY, _("Convert zbin to hbin"), _("Convert zbin to hbin"))
+            menu2d_hbin2zbin = self.menusim2D.Append(wx.ID_ANY, _("Convert hbin to zbin"), _("Convert hbin to zbin"))
+            menu2D_zbinb2hbinb = self.menusim2D.Append(wx.ID_ANY, _("Convert zbinb to hbinb"), _("Convert zbinb to hbinb"))
+            menu2d_hbinb2zbinb = self.menusim2D.Append(wx.ID_ANY, _("Convert hbinb to zbinb"), _("Convert hbinb to zbinb"))
+            menu2d_forcemask = self.menusim2D.Append(wx.ID_ANY, _("Reset mask of all arrays"), _("Reset mask"))
+
+            # update = self.menusim2D.Append(wx.ID_ANY, _('Update model from current mask'), _('Update model'))
+            # updateblocfile = self.menusim2D.Append(wx.ID_ANY, _('Update .bloc file'), _('Update bloc'))
+            # updatefreesurface = self.menusim2D.Append(wx.ID_ANY, _('Update free surface elevation - IC'), _('Update free surface elevation'))
+            # updaterough = self.menusim2D.Append(wx.ID_ANY, _('Update roughness coeff'), _('Update roughness coefficient'))
+            # updateic = self.menusim2D.Append(wx.ID_ANY, _('Update IC reading mode'), _('Update IC'))
+            # menu2d_tft_ic = self.menusim2D.Append(wx.ID_ANY,_("Transfer initial conditions..."),_("Transfer IC"))
+
+            self.menusim2D.Bind(wx.EVT_MENU, self.Onmenusim2D)
+
+    def Onmenusim2D(self, event: wx.MenuEvent):
+        """ Action to perform whern menu 2D entry is selected """
+
+        id = event.GetId()
+        item = self.menubar.FindItemById(event.GetId())
+
+        if item is None:
+            return
+
+        itemlabel = item.ItemLabel
+
+        from .PyGui import Wolf2DModel
+
+        if not isinstance(self.wolfparent, Wolf2DModel):
+            logging.error(_('This is not a 2D model'))
+            return
+
+        self.wolfparent:Wolf2DModel
+
+        if itemlabel == _('Update .bloc file'):
+
+            msg = _('If you continue the .bloc file will be relpaced !')+'\n'
+            msg += '\n'
+            msg += _('Continue ?')+'\n'
+
+            dlg = wx.MessageDialog(self,msg,caption = _('Attention'), style = wx.YES_NO)
+            ret = dlg.ShowModal()
+            dlg.Destroy()
+            if ret == wx.ID_NO:
+                return
+
+            self.wolfparent.write_bloc_file()
+
+        elif itemlabel == _('Reset mask of all arrays'):
+
+            self.wolfparent.sim.force_mask()
+
+        elif itemlabel == _('Convert zbin to hbin'):
+
+            if self.wolfparent.sim._zbin is not None:
+                self.wolfparent.sim.zbin2hbin()
+                self.wolfparent.sim.hbin.reset_plot()
+
+        elif itemlabel == _('Convert hbin to zbin'):
+
+            if self.wolfparent.sim._hbin is not None:
+                self.wolfparent.sim.hbin2zbin()
+                self.wolfparent.sim.zbin.reset_plot()
+
+        elif itemlabel == _('Convert zbinb to hbinb'):
+
+            if self.wolfparent.sim._zbinb is not None:
+                self.wolfparent.sim.zbinb2hbinb()
+                self.wolfparent.sim.hbinb.reset_plot()
+
+        elif itemlabel == _('Convert hbinb to zbinb'):
+
+            if self.wolfparent.sim._hbinb is not None:
+                self.wolfparent.sim.hbinb2zbinb()
+                self.wolfparent.sim.zbinb.reset_plot()
+
+        elif itemlabel == _("Transfer initial conditions..."):
+
+            if self.active_array is not None:
+                from .PyGui import Wolf2DModel
+                if isinstance(self.wolfparent,Wolf2DModel):
+                    self.wolfparent.transfer_ic(self.active_vector)
+
+        elif itemlabel == _("Parameters..."):
+            self.wolfparent.show_properties()
+
+        elif itemlabel == _('Update free surface elevation - IC'):
+
+            if len(self.active_array.SelectionData.myselection)==0:
+
+                msg = _('There is none selected nodes in the active array !')+'\n'
+                msg += '\n'
+                msg += _('Please select the desired zone and retry !')+'\n'
+
+                logging.warning(msg)
+                return
+
+            self.wolfparent.extend_freesurface_elevation(self.active_array.SelectionData.myselection)
+
+        elif itemlabel== _('Update roughness coeff'):
+
+            if len(self.active_array.SelectionData.myselection)==0:
+
+                msg = _('There is none selected nodes in the active array !')+'\n'
+                msg += '\n'
+                msg += _('Please select the desired zone and retry !')+'\n'
+
+                logging.warning(msg)
+                return
+
+            self.wolfparent.extend_roughness(self.active_array.SelectionData.myselection)
+
+        # elif itemlabel == _('Update IC reading mode'):
+
+        #     self.wolfparent.set_type_ic()
+
+        elif itemlabel == _('Update model from current mask'):
+
+            if type(self.active_array) not in [WolfArray]:
+                msg = _('Please select a mono-block array !')+'\n'
+                dlg=wx.MessageBox(msg,style=wx.OK)
+                return
+
+            msg = _('If you continue, the mask of all arrays will be replaced by the current mask !')+'\n'
+            msg += _('The external contour in the .bloc file will also be relpaced.')+'\n'
+            msg += '\n'
+            msg += _('Continue ?')+'\n'
+
+            dlg = wx.MessageDialog(self,msg,caption = _('Attention'), style = wx.YES_NO)
+            ret = dlg.ShowModal()
+            dlg.Destroy()
+            if ret == wx.ID_NO:
+                return
+
+            with wx.lib.busy.BusyInfo(_('Updating 2D model')):
+                wait = wx.BusyCursor()
+
+                sux,suy,cont,interior = self.active_array.suxsuy_contour(self.wolfparent.filenamegen,True)
+
+                self.wolfparent.mimic_mask(self.active_array)
+                self.wolfparent.replace_external_contour(cont,interior)
+
+                del wait
+
+            self.wolfparent.extend_bed_elevation()
 
     def get_configuration(self) -> Union[WolfConfiguration, None]:
+        """ Get global configuration parameters """
+
         # At this point, I'm not too sure about
         # which window/frame does what. So to be on
         # the safe side, I make sure that the configuration
@@ -1748,6 +2278,8 @@ class WolfMapViewer(wx.Frame):
         self.all_lists = [self.myarrays, self.myvectors, self.myclouds, self.mytri, self.myothers, self.myviews, self.myres2D, self.mytiles, self.mypartsystems, self.myviewers3d]
 
         if self.get_configuration() is not None:
+            # see PyGui.py if necessary
+
             self.menu_options = wx.Menu()
             self.menubar.Append(self.menu_options, _('Options'))
             self.option_global = self.menu_options.Append(wx.ID_ANY,_("Global"),_("Modify global options"))
@@ -1809,9 +2341,30 @@ class WolfMapViewer(wx.Frame):
                     mydiag = wx.MessageDialog(self, msg, _('Sort along'))
                     mydiag.ShowModal()
 
+    def center_view_on(self, cx, cy):
+        """
+        Center the view on the point of (map) coordinates (x,y)
+        """
+
+        self.mousex, self.mousey = cx, cy
+
+        # retrouve la taille de la fenêtre OpenGL
+        width, height = self.canvas.GetSize()
+
+        # calcule la taille selon X et Y en coordonnées réelles
+        width = width / self.sx
+        height = height / self.sy
+
+        # retrouve les bornes min et max sur base de la valeur centrale qui est censée ne pas bouger
+        self.xmin = self.mousex - width / 2.
+        self.xmax = self.xmin + width
+        self.ymin = self.mousey - height / 2.
+        self.ymax = self.ymin + height
+
     def setbounds(self,updatescale=True):
         """
-        Calcule les limites visibles de la fenêtrte graphique sur base des facteurs d'échelle courants
+        Calcule les limites visibles de la fenêtrte graphique sur base des
+        facteurs d'échelle courants
         """
 
         if updatescale:
@@ -1858,7 +2411,11 @@ class WolfMapViewer(wx.Frame):
         self.canvas.SetClientSize(width, height)
 
     def updatescalefactors(self):
-        """ Mise à jour des facteurs d'échelle """
+        """ Mise à jour des facteurs d'échelle
+            This one updates the scale factors based on the relative sizes
+            of the GLCanvas and the footprint that should fit in it.
+        """
+
         width, height = self.canvas.GetSize()
 
         self.sx = 1
@@ -1873,6 +2430,7 @@ class WolfMapViewer(wx.Frame):
 
     def add_viewer_and_link(self):
         """ Ajout d'une nouvelle fenêtre de visualisation et liaison avec la fenêtre courante """
+
         dlg = wx.TextEntryDialog(self, _('Enter a caption for the new window'))
 
         ret = dlg.ShowModal()
@@ -1901,6 +2459,7 @@ class WolfMapViewer(wx.Frame):
 
     def add_grid(self):
         """ Ajout d'une grille """
+
         mygrid = Grid(1000.)
         self.add_object('vector', newobj=mygrid, ToCheck=False, id='Grid')
 
@@ -3166,80 +3725,6 @@ class WolfMapViewer(wx.Frame):
             os.chdir(os.path.dirname(filename))
             self.read_project(filename)
 
-        elif itemlabel == _('Update .bloc file'):
-
-            msg = _('If you continue the .bloc file will be relpaced !')+'\n'
-            msg += '\n'
-            msg += _('Continue ?')+'\n'
-
-            dlg = wx.MessageDialog(self,msg,caption = _('Attention'), style = wx.YES_NO)
-            ret = dlg.ShowModal()
-            dlg.Destroy()
-            if ret == wx.ID_NO:
-                return
-
-            self.wolfparent.write_bloc_file()
-
-        elif itemlabel == _('Update free surface elevation - IC'):
-
-            if len(self.active_array.mngselection.myselection)==0:
-
-                msg = _('There is none selected nodes in the active array !')+'\n'
-                msg += '\n'
-                msg += _('Please select the desired zone and retry !')+'\n'
-
-                logging.warning(msg)
-                return
-
-            self.wolfparent.extend_freesurface_elevation(self.active_array.mngselection.myselection)
-
-        elif itemlabel== _('Update roughness coeff'):
-
-            if len(self.active_array.mngselection.myselection)==0:
-
-                msg = _('There is none selected nodes in the active array !')+'\n'
-                msg += '\n'
-                msg += _('Please select the desired zone and retry !')+'\n'
-
-                logging.warning(msg)
-                return
-
-            self.wolfparent.extend_roughness(self.active_array.mngselection.myselection)
-
-        elif itemlabel == _('Update IC reading mode'):
-
-            self.wolfparent.set_type_ic()
-
-        elif itemlabel == _('Update model from current mask'):
-
-            if type(self.active_array) != WolfArray_Sim2D:
-                msg = _('Please select a mono-block array !')+'\n'
-                dlg=wx.MessageBox(msg,style=wx.OK)
-                return
-
-            msg = _('If you continue, the mask of all arrays will be replaced by the current mask !')+'\n'
-            msg += _('The external contour in the .bloc file will also be relpaced.')+'\n'
-            msg += '\n'
-            msg += _('Continue ?')+'\n'
-
-            dlg = wx.MessageDialog(self,msg,caption = _('Attention'), style = wx.YES_NO)
-            ret = dlg.ShowModal()
-            dlg.Destroy()
-            if ret == wx.ID_NO:
-                return
-
-            with wx.lib.busy.BusyInfo(_('Updating 2D model')):
-                wait = wx.BusyCursor()
-
-                sux,suy,cont,interior = self.active_array.suxsuy_contour(self.wolfparent.filenamegen,True)
-
-                self.wolfparent.mimic_mask(self.active_array)
-                self.wolfparent.replace_external_contour(cont,interior)
-
-                del wait
-
-            self.wolfparent.extend_bed_elevation()
-
         elif itemlabel == _('Shortcuts'):
             # show shortcuts in log
             self.print_shortcuts(True)
@@ -3297,7 +3782,7 @@ class WolfMapViewer(wx.Frame):
             elif unknown == _('Head'):
                 unknown = 'head'
 
-            fig, ax = self.active_res2d.plot_h(self.active_res2d.mngselection.myselection,
+            fig, ax = self.active_res2d.plot_h(self.active_res2d.SelectionData.myselection,
                                                unknown, toshow=True)
 
         elif itemlabel == _("Plot stats unknown (inside active vector)..."):
@@ -3532,141 +4017,141 @@ class WolfMapViewer(wx.Frame):
             ax.legend()
             fig.show()
 
-        elif itemlabel == _("Change current view"):
-
-            # Change view for results
-
-            autoscale = False
-            choices = [cur.value for cur in views_2D]
-            dlg = wx.SingleChoiceDialog(None, _("Pick a view"), "Choices", choices)
-            ret = dlg.ShowModal()
-            if ret == wx.ID_CANCEL:
-                dlg.Destroy()
-                return
-
-            method = dlg.GetStringSelection()
-
-            method = list(views_2D)[choices.index(method)]
-
-            dlg.Destroy()
-
-            diamsize = None
-            if method == views_2D.SHIELDS_NUMBER :
-
-                if self.active_res2d is not None:
-                    sediment_diam = self.active_res2d.sediment_diameter
-                    sediment_density = self.active_res2d.sediment_density
-                elif self.compare_results is not None:
-                    sediment_diam = 0.001
-                    sediment_density = 2.650
-                else:
-                    logging.warning(_('No active 2D result or comparison !'))
-                    return
-
-                dlg = wx.TextEntryDialog(None,_("Diameter grain size [m] ?"), value = str(sediment_diam))
-                ret = dlg.ShowModal()
-                if ret == wx.ID_CANCEL:
-                    dlg.Destroy()
-                    return
-                try:
-                    diamsize = float(dlg.GetValue())
-                except:
-                    dlg.Destroy()
-                    logging.warning(_("Bad value -- Rety"))
-                    return
-
-                dlg = wx.TextEntryDialog(None,_("Density grain [-] ?"), value = str(sediment_density))
-                ret = dlg.ShowModal()
-                if ret == wx.ID_CANCEL:
-                    dlg.Destroy()
-                    return
-                try:
-                    density = float(dlg.GetValue())
-                except:
-                    dlg.Destroy()
-                    logging.warning(_("Bad value -- Rety"))
-                    return
-
-            if len(self.myres2D)>1:
-
-                dlg = wx.MessageDialog(None, _('Apply to all results?'), style=wx.YES_NO)
-                ret = dlg.ShowModal()
-                if ret == wx.ID_NO:
-                    if diamsize is not None:
-                        self.active_res2d.sediment_diameter = diamsize
-                        self.active_res2d.sediment_density = density
-                        self.active_res2d.load_default_colormap('shields_cst')
-
-                    self.active_res2d.set_currentview(method, force_wx = True, force_updatepal = True)
-                else:
-                    for curarray in self.iterator_over_objects(draw_type.RES2D):
-                        curarray:Wolfresults_2D
-                        if diamsize is not None:
-                            curarray.sediment_diameter = diamsize
-                            curarray.sediment_density  = density
-                            curarray.load_default_colormap('shields_cst')
-
-                        curarray.set_currentview(method, force_wx = True, force_updatepal = True)
-
-            else:
-                if self.active_res2d is not None:
-                    if diamsize is not None:
-                        self.active_res2d.sediment_diameter = diamsize
-                        self.active_res2d.sediment_density = density
-                        self.active_res2d.load_default_colormap('shields_cst')
-                    self.active_res2d.set_currentview(method, force_wx = True, force_updatepal = True)
-
-            if self.compare_results is not None:
-                # update compare results
-                if diamsize is not None:
-                    self.compare_results.set_shields_param(diamsize, density)
-                self.compare_results.update_type_result(method)
-
-        elif itemlabel == _("Read last result"):
-
-            self.read_last_result()
-
-        elif itemlabel == _("Filter independent"):
-
-            self.menu_filter_independent.IsChecked = not self.menu_filter_independent.IsChecked
-
-            for curmodel in self.iterator_over_objects(draw_type.RES2D):
-                curmodel: Wolfresults_2D
-                curmodel.to_filter_independent = not self.menu_filter_independent.IsChecked
-
-        elif itemlabel == _("Set epsilon water depth"):
-
-            dlg = wx.TextEntryDialog(self, _('Enter an epsilon [m]'),value='0.0')
-
-            ret = dlg.ShowModal()
-
-            if ret == wx.ID_CANCEL:
-                dlg.Destroy()
-                return
-
-            try:
-                neweps = float(dlg.GetValue())
-                dlg.Destroy()
-            except:
-                logging.error(_('Bad value -- retry !'))
-                dlg.Destroy()
-                return
-
-            for curmodel in self.iterator_over_objects(draw_type.RES2D):
-                curmodel: Wolfresults_2D
-                curmodel.epsilon = neweps
-                curmodel._epsilon_default = neweps
-                curmodel.read_oneresult(curmodel.current_result)
-                curmodel.set_currentview()
-
-        elif itemlabel == _("Manage boundary conditions..."):
-
-            if self.active_res2d is not None:
-                self.active_res2d.myparams.editing_bc(self.myres2D)
-
-        elif itemlabel ==_("Create video..."):
-            if self.active_res2d is not None:
-                self.create_video()
+        # elif itemlabel == _("Change current view"):
+
+        #     # Change view for results
+
+        #     autoscale = False
+        #     choices = [cur.value for cur in views_2D]
+        #     dlg = wx.SingleChoiceDialog(None, _("Pick a view"), "Choices", choices)
+        #     ret = dlg.ShowModal()
+        #     if ret == wx.ID_CANCEL:
+        #         dlg.Destroy()
+        #         return
+
+        #     method = dlg.GetStringSelection()
+
+        #     method = list(views_2D)[choices.index(method)]
+
+        #     dlg.Destroy()
+
+        #     diamsize = None
+        #     if method == views_2D.SHIELDS_NUMBER :
+
+        #         if self.active_res2d is not None:
+        #             sediment_diam = self.active_res2d.sediment_diameter
+        #             sediment_density = self.active_res2d.sediment_density
+        #         elif self.compare_results is not None:
+        #             sediment_diam = 0.001
+        #             sediment_density = 2.650
+        #         else:
+        #             logging.warning(_('No active 2D result or comparison !'))
+        #             return
+
+        #         dlg = wx.TextEntryDialog(None,_("Diameter grain size [m] ?"), value = str(sediment_diam))
+        #         ret = dlg.ShowModal()
+        #         if ret == wx.ID_CANCEL:
+        #             dlg.Destroy()
+        #             return
+        #         try:
+        #             diamsize = float(dlg.GetValue())
+        #         except:
+        #             dlg.Destroy()
+        #             logging.warning(_("Bad value -- Rety"))
+        #             return
+
+        #         dlg = wx.TextEntryDialog(None,_("Density grain [-] ?"), value = str(sediment_density))
+        #         ret = dlg.ShowModal()
+        #         if ret == wx.ID_CANCEL:
+        #             dlg.Destroy()
+        #             return
+        #         try:
+        #             density = float(dlg.GetValue())
+        #         except:
+        #             dlg.Destroy()
+        #             logging.warning(_("Bad value -- Rety"))
+        #             return
+
+        #     if len(self.myres2D)>1:
+
+        #         dlg = wx.MessageDialog(None, _('Apply to all results?'), style=wx.YES_NO)
+        #         ret = dlg.ShowModal()
+        #         if ret == wx.ID_NO:
+        #             if diamsize is not None:
+        #                 self.active_res2d.sediment_diameter = diamsize
+        #                 self.active_res2d.sediment_density = density
+        #                 self.active_res2d.load_default_colormap('shields_cst')
+
+        #             self.active_res2d.set_currentview(method, force_wx = True, force_updatepal = True)
+        #         else:
+        #             for curarray in self.iterator_over_objects(draw_type.RES2D):
+        #                 curarray:Wolfresults_2D
+        #                 if diamsize is not None:
+        #                     curarray.sediment_diameter = diamsize
+        #                     curarray.sediment_density  = density
+        #                     curarray.load_default_colormap('shields_cst')
+
+        #                 curarray.set_currentview(method, force_wx = True, force_updatepal = True)
+
+        #     else:
+        #         if self.active_res2d is not None:
+        #             if diamsize is not None:
+        #                 self.active_res2d.sediment_diameter = diamsize
+        #                 self.active_res2d.sediment_density = density
+        #                 self.active_res2d.load_default_colormap('shields_cst')
+        #             self.active_res2d.set_currentview(method, force_wx = True, force_updatepal = True)
+
+        #     if self.compare_results is not None:
+        #         # update compare results
+        #         if diamsize is not None:
+        #             self.compare_results.set_shields_param(diamsize, density)
+        #         self.compare_results.update_type_result(method)
+
+        # elif itemlabel == _("Read last result"):
+
+        #     self.read_last_result()
+
+        # elif itemlabel == _("Filter independent"):
+
+        #     self.menu_filter_independent.IsChecked = not self.menu_filter_independent.IsChecked
+
+        #     for curmodel in self.iterator_over_objects(draw_type.RES2D):
+        #         curmodel: Wolfresults_2D
+        #         curmodel.to_filter_independent = not self.menu_filter_independent.IsChecked
+
+        # elif itemlabel == _("Set epsilon water depth"):
+
+        #     dlg = wx.TextEntryDialog(self, _('Enter an epsilon [m]'),value='0.0')
+
+        #     ret = dlg.ShowModal()
+
+        #     if ret == wx.ID_CANCEL:
+        #         dlg.Destroy()
+        #         return
+
+        #     try:
+        #         neweps = float(dlg.GetValue())
+        #         dlg.Destroy()
+        #     except:
+        #         logging.error(_('Bad value -- retry !'))
+        #         dlg.Destroy()
+        #         return
+
+        #     for curmodel in self.iterator_over_objects(draw_type.RES2D):
+        #         curmodel: Wolfresults_2D
+        #         curmodel.epsilon = neweps
+        #         curmodel._epsilon_default = neweps
+        #         curmodel.read_oneresult(curmodel.current_result)
+        #         curmodel.set_currentview()
+
+        # elif itemlabel == _("Manage boundary conditions..."):
+
+        #     if self.active_res2d is not None:
+        #         self.active_res2d.myparams.editing_bc(self.myres2D)
+
+        # elif itemlabel ==_("Create video..."):
+        #     if self.active_res2d is not None:
+        #         self.create_video()
 
         elif itemlabel == _("Setup cache..."):
 
@@ -3737,13 +4222,6 @@ class WolfMapViewer(wx.Frame):
 
             self.active_res2d.show_tiles()
 
-        elif itemlabel == _("Transfer initial conditions..."):
-
-            if self.active_array is not None:
-                from .PyGui import Wolf2DModel
-                if isinstance(self.wolfparent,Wolf2DModel):
-                    self.wolfparent.transfer_ic(self.active_vector)
-
         elif itemlabel == _("Manage banks..."):
             if self.active_vector is None:
                 msg = _('Active vector is None\nPlease activate the one desired')
@@ -3998,22 +4476,13 @@ class WolfMapViewer(wx.Frame):
 
             pass
 
-        elif itemlabel == _('Check 2D simulation headers'):
-
-            # Check 2D simulation
-            dlg = wx.FileDialog(self, _("Choose 2D simulation file"), wildcard="all (*.*)|*.*", style=wx.FD_OPEN)
-            if dlg.ShowModal() == wx.ID_CANCEL:
-                dlg.Destroy()
-                return
-
-            filename = dlg.GetPath()
-            dlg.Destroy()
+        elif itemlabel == _('Create/Open multiblock model'):
 
-            from .mesh2d.wolf2dprev import prev_sim2D
+            self.create_2D_MB_model()
 
-            sim = prev_sim2D(filename)
-            sim.verify_files()
+        elif itemlabel == _('Check headers'):
 
+            self.check_2D_MB_headers()
 
         elif itemlabel == _('Set comparison'):
 
@@ -4417,14 +4886,19 @@ class WolfMapViewer(wx.Frame):
             self.Autoscale()
 
     def pop_boundary_manager(self, which:BcManager):
-        """ pop a boundary manager after Destroying """
+        """ Pop a boundary condition manager after Destroying """
+
         idx = self.mybc.index(which)
         if self.active_bc is which:
             self.active_bc = None
         self.mybc.pop(idx)
 
+        self.Refresh()
+
+
     def get_boundary_manager(self, which:WolfArray):
-        """ get a boundary manager """
+        """ Get a boundary manager """
+
         for curbc in self.mybc:
             if curbc.linked_array is which:
                 return curbc
@@ -4835,6 +5309,7 @@ class WolfMapViewer(wx.Frame):
                 logging.warning("Warning : the following file is not present here : " + filename)
                 return -1
 
+        curtree = None
         if which.lower() == 'array' or which.lower() == 'array_crop':
             curdict = self.myarrays
             curtree = self.myitemsarray
@@ -4941,9 +5416,9 @@ class WolfMapViewer(wx.Frame):
                         newobj.dx = tmpdx
                         newobj.dy = tmpdy
 
-                        if newobj.mngselection is not None:
-                            newobj.mngselection.dx = tmpdx
-                            newobj.mngselection.dy = tmpdy
+                        if newobj.SelectionData is not None:
+                            newobj.SelectionData.dx = tmpdx
+                            newobj.SelectionData.dy = tmpdy
 
                         if cropini[0][0] != 99999. and cropini[1][0]!=99999.:
                             newobj.origx = cropini[0][0]
@@ -5370,13 +5845,16 @@ class WolfMapViewer(wx.Frame):
 
         newobj.idx = id.lower()
 
-        myitem = self.treelist.AppendItem(curtree, id, data=newobj)
+        if curtree is not None:
+            myitem = self.treelist.AppendItem(curtree, id, data=newobj)
 
-        if ToCheck:
-            self.treelist.CheckItem(myitem)
-            self.treelist.CheckItem(self.treelist.GetItemParent(myitem))
+            if ToCheck:
+                self.treelist.CheckItem(myitem)
+                self.treelist.CheckItem(self.treelist.GetItemParent(myitem))
 
-            newobj.check_plot()
+                newobj.check_plot()
+        else:
+            logging.info(f'No tree item for this object {newobj.idx}')
 
         # curdict[id.lower()] = newobj
         if filename != '':
@@ -5455,6 +5933,7 @@ class WolfMapViewer(wx.Frame):
 
     def get_list_keys(self, drawing_type:draw_type, checked_state:bool=True):
         """ Create a list of keys of type draw_type """
+
         if checked_state is None:
             return [curobj.idx for curobj in self._get_list(drawing_type)]
         else:
@@ -5462,6 +5941,7 @@ class WolfMapViewer(wx.Frame):
 
     def get_list_objects(self, drawing_type:draw_type, checked_state:bool=True):
         """ Create a list of objects of type draw_type """
+
         if checked_state is None:
             return [curobj for curobj in self._get_list(drawing_type)]
         else:
@@ -5683,7 +6163,7 @@ class WolfMapViewer(wx.Frame):
 
         if text == _('Save'):
             if self.selected_object is not None:
-                if type(self.selected_object) is WolfArray or type(self.selected_object) is WolfArray_Sim2D:
+                if issubclass(type(self.selected_object), WolfArray):
                     self.selected_object.write_all()
                 elif type(self.selected_object) is Zones:
                     self.selected_object.saveas()
@@ -5721,7 +6201,7 @@ class WolfMapViewer(wx.Frame):
                 newlab = dlg.GetValue()
                 dlg.Destroy()
 
-                if isinstance(self.selected_object, WolfArray) and (not type(self.selected_object) in [WolfArrayMB, WolfArrayMNAP, WolfArray_Sim2D]):
+                if isinstance(self.selected_object, WolfArray) and (not type(self.selected_object) in [WolfArrayMB, WolfArrayMNAP]):
 
                     curtype = self.selected_object.dtype
 
@@ -5778,7 +6258,7 @@ class WolfMapViewer(wx.Frame):
             # save objet to file, choosing the file name
 
             if self.selected_object is not None:
-                if type(self.selected_object) is WolfArray or type(self.selected_object) is WolfArray_Sim2D:
+                if issubclass(type(self.selected_object), WolfArray):
                     filterArray = "bin (*.bin)|*.bin|Geotif (*.tif)|*.tif|Numpy (*.npy)|*.npy|all (*.*)|*.*"
                     fdlg = wx.FileDialog(self, "Choose file name for Array : " + self.selected_object.idx, wildcard=filterArray,
                                          style=wx.FD_SAVE)
@@ -5820,7 +6300,7 @@ class WolfMapViewer(wx.Frame):
         elif text == _('Properties'):
 
             myobj = self.selected_object
-            if type(myobj) in [WolfArray, WolfArray_Sim2D, WolfArrayMB, WolfArrayMNAP, Zones, Wolfresults_2D, wolfres2DGPU, Particle_system, Picc_data, Cadaster_data, hydrometry_wolfgui]:
+            if type(myobj) in [WolfArray, WolfArrayMB, WolfArrayMNAP, Zones, Wolfresults_2D, wolfres2DGPU, Particle_system, Picc_data, Cadaster_data, hydrometry_wolfgui]:
                 myobj.show_properties()
 
         elif text == _('Boundary conditions'):
@@ -5828,6 +6308,41 @@ class WolfMapViewer(wx.Frame):
             if bc is not None:
                 bc.Show()
 
+        elif _('Convert to mono-block') in text:
+
+            if isinstance(self.selected_object, WolfArrayMB):
+                mono = self.selected_object.as_WolfArray()
+                self.add_object('array', newobj=mono, id=self.selected_object.idx + '_mono')
+                logging.info(_('Mono-block created and added to the viewer'))
+
+            elif isinstance(self.selected_object, Wolfresults_2D):
+                mono = self.selected_object.as_WolfArray()
+
+                if isinstance(mono, WolfArrayMB):
+                    mono = mono.as_WolfArray()
+
+                self.add_object('array', newobj=mono, id=self.selected_object.idx + '_mono')
+                logging.info(_('Mono-block created and added to the viewer'))
+
+            else:
+                logging.warning(_('Convert to mono-blocks not yet implemented for this type of object'))
+
+        elif _('Convert to multi-blocks') in text:
+
+            if isinstance(self.selected_object, Wolfresults_2D):
+                mb = self.selected_object.as_WolfArray(force_mb=True)
+
+                if isinstance(mb, WolfArrayMB):
+                    logging.info(_('Multi-blocks created and added to the viewer'))
+
+                elif isinstance(mb, WolfArray):
+                    logging.warning(_('Mono-blocks created and added to the viewer -- Instead of multi-blocks as only one block was found'))
+
+                self.add_object('array', newobj=mb, id=self.selected_object.idx + '_mb')
+            else:
+                logging.warning(_('Convert to multi-blocks not yet implemented for this type of object'))
+
+
     def OnClose(self, event):
         nb = 0
         if self.linked:
@@ -5900,7 +6415,7 @@ class WolfMapViewer(wx.Frame):
                     wx.LogMessage(str(ex))
                     wx.MessageBox(str(ex), _("Error"), wx.ICON_ERROR)
             else:
-                if type(curobj) in [WolfArray, WolfArrayMB]:
+                if issubclass(type(curobj), WolfArray):
                     curobj.uncheck_plot(not ctrl,ctrl)
                 else:
                     curobj.uncheck_plot()
@@ -6176,13 +6691,13 @@ class WolfMapViewer(wx.Frame):
 
             if 'results' in self.action:
                 curobj:Wolfresults_2D
-                curobj = self.active_res2d.mngselection
+                curobj = self.active_res2d.SelectionData
             else:
                 curobj: WolfArray
-                curobj = self.active_array.mngselection
+                curobj = self.active_array.SelectionData
 
             curobj.add_node_to_selection(x, y)
-            curobj.update_nb_nodes_sections()
+            curobj.update_nb_nodes_selection()
             self.Paint()
 
         elif 'select by tmp vector' in self.action or 'select by vector' in self.action:
@@ -6295,6 +6810,7 @@ class WolfMapViewer(wx.Frame):
         altdown = e.AltDown()
         ctrldown = e.ControlDown()
         shiftdown = e.ShiftDown()
+        spacedown = wx.GetKeyState(wx.WXK_SPACE)
 
         if self.action == 'dynamic parallel' and shiftdown and not ctrldown:
             self.dynapar_dist *= (1 - .1 * (r / max(d, 1)))
@@ -6324,9 +6840,34 @@ class WolfMapViewer(wx.Frame):
             self.Refresh()
             return
 
+        # Allow the user to zoom onto the pixel where the
+        # mouse cursor is
+
+        # Step1: move the map so that the pixem under the mouse cursor
+        # ends up right in the middle of the screen (this move is
+        # not visible from the end user point of view, it's just
+        # here to make computation seasier)
+        if spacedown:
+            self.center_view_on( *self.getXY( e.GetPosition()))
+
+        # Zoom/dezoom, center pf the tranfromation is the center of the screen
         self.width = self.width * (1 - .1 * (r / max(d, 1)))
         self.height = self.height * (1 - .1 * (r / max(d, 1)))
 
+        if spacedown:
+            self.updatescalefactors() # not base on mousex
+
+            # Translate back the pixel at the center of the screen to where the
+            # mouse cursor is. For that we measure the delta in screen coordinates
+            # and transform it to map space coordinates.
+            x_mid, y_mid = self.canvas.GetSize()
+            x_mid, y_mid = self.getXY((0.5*x_mid, y_mid*0.5))
+            x, y = self.getXY( e.GetPosition())
+            dx, dy = x_mid - x, y_mid - y
+            self.mousex +=  dx
+            self.mousey +=  dy
+
+        # will translate and rescale the map view so that it fits the window.
         self.setbounds()
 
     def OnRDClick(self, e):
@@ -6414,7 +6955,7 @@ class WolfMapViewer(wx.Frame):
         elif type(myobj) == Tiles:
             self.active_tile= myobj
 
-        elif type(myobj) in [WolfArray, WolfArray_Sim2D, WolfArrayMB, WolfArrayMNAP]:
+        elif issubclass(type(myobj), WolfArray):
             if ctrl:
                 myobj.show_properties()
                 # myobj.myops.SetTitle(_('Operations on array: ')+myobj.idx)
@@ -6422,8 +6963,22 @@ class WolfMapViewer(wx.Frame):
 
             logging.info(_('Activating array : ' + nameitem))
             self.active_array = myobj
+
+            # If BC maneger is attached to the array, we activate it
             self._set_active_bc()
 
+            #Print info in the status bar
+            txt  = 'Dx : {:4f} ; Dy : {:4f}'.format(self.active_array.dx, self.active_array.dy)
+            txt += ' ; Xmin : {:4f} ; Ymin : {:4f}'.format(self.active_array.xmin, self.active_array.ymin)
+            txt += ' ; Xmax : {:4f} ; Ymax : {:4f}'.format(self.active_array.xmax, self.active_array.ymax)
+            txt += ' ; Nx : {:d} ; Ny : {:d}'.format(self.active_array.nbx, self.active_array.nby)
+
+            if self.active_array.nb_blocks > 0:
+                txt += ' ; Nb blocks : {:d}'.format(self.active_array.nb_blocks)
+
+            self.StatusBar.SetStatusText(txt)
+
+
         elif type(myobj) in [WolfViews]:
             logging.info(_('Activating view : ' + nameitem))
             self.active_view = myobj
@@ -6874,9 +7429,9 @@ class WolfMapViewer(wx.Frame):
 
                 if inside_under:
                     self.active_vector.close_force()
-                    self.active_array.mngselection.select_insidepoly(self.active_vector)
+                    self.active_array.SelectionData.select_insidepoly(self.active_vector)
                 else:
-                    self.active_array.mngselection.select_underpoly(self.active_vector)
+                    self.active_array.SelectionData.select_underpoly(self.active_vector)
 
                 if 'tmp' in locaction:
                     # we must reset the temporary vector
@@ -6947,7 +7502,7 @@ class WolfMapViewer(wx.Frame):
                 # Le test not(self in self.linkedList) permet de ne pas créer le liste OpenGL en cas de multi-viewers
                 # car une liste OpenGL ne sera pas tracée sur les autres fenêtres
                 # C'est donc plus lent mais plus sûr pour que l'affichage dynamique soit correct
-                self.active_vector.parentzone.plot(prep = not(self in self.linkedList))
+                self.active_vector.parentzone.plot(prep = self.linkedList is None or not(self in self.linkedList))
 
             elif self.action == 'modify vertices':
 
@@ -6958,7 +7513,7 @@ class WolfMapViewer(wx.Frame):
                 # Le test not(self in self.linkedList) permet de ne pas créer le liste OpenGL en cas de multi-viewers
                 # car une liste OpenGL ne sera pas tracée sur les autres fenêtres
                 # C'est donc plus lent mais plus sûr pour que l'affichage dynamique soit correct
-                self.active_vector.parentzone.plot(prep = not(self in self.linkedList))
+                self.active_vector.parentzone.plot(prep = self.linkedList is None or not(self in self.linkedList))
                 self.active_zones.find_minmax(True)
 
                 self.active_vertex = None
@@ -6970,7 +7525,7 @@ class WolfMapViewer(wx.Frame):
                 # Le test not(self in self.linkedList) permet de ne pas créer le liste OpenGL en cas de multi-viewers
                 # car une liste OpenGL ne sera pas tracée sur les autres fenêtres
                 # C'est donc plus lent mais plus sûr pour que l'affichage dynamique soit correct
-                self.active_vector.parentzone.plot(prep = not(self in self.linkedList))
+                self.active_vector.parentzone.plot(prep = self.linkedList is None or not(self in self.linkedList))
                 self.active_zones.find_minmax(True)
 
                 self.active_vertex = None
@@ -6986,7 +7541,7 @@ class WolfMapViewer(wx.Frame):
                 # Le test not(self in self.linkedList) permet de ne pas créer le liste OpenGL en cas de multi-viewers
                 # car une liste OpenGL ne sera pas tracée sur les autres fenêtres
                 # C'est donc plus lent mais plus sûr pour que l'affichage dynamique soit correct
-                self.active_vector.parentzone.plot(prep = not(self in self.linkedList))
+                self.active_vector.parentzone.plot(prep = self.linkedList is None or not(self in self.linkedList))
 
                 self.active_vertex = None
 
@@ -7363,7 +7918,7 @@ class WolfMapViewer(wx.Frame):
                 self.copyfrom = self.active_array
                 self.mimicme_copyfrom()  # force le recopiage de copyfrom dans les autres matrices liées
 
-                self.active_array.mngselection.copy_to_clipboard()
+                self.active_array.SelectionData.copy_to_clipboard()
 
             elif key == ord('C') and ctrldown and altdown:
                 if self.active_array is None:
@@ -7378,7 +7933,7 @@ class WolfMapViewer(wx.Frame):
                 self.copyfrom = self.active_array
                 self.mimicme_copyfrom()  # force le recopiage de copyfrom dans les autres matrices liées
 
-                self.active_array.mngselection.copy_to_clipboard(typestr='script')
+                self.active_array.SelectionData.copy_to_clipboard(typestr='script')
 
             elif key == ord('V') and ctrldown:
                 # CTRL+V
@@ -7406,16 +7961,16 @@ class WolfMapViewer(wx.Frame):
                     logging.warning(_('No selection to be pasted !'))
                     return
 
-                cursel = fromarray.mngselection.myselection
+                cursel = fromarray.SelectionData.myselection
 
                 if e.AltDown():
                     logging.info(_('Paste selection position'))
 
                     if cursel == 'all':
-                        self.active_array.mngselection.OnAllSelect(0)
+                        self.active_array.SelectionData.OnAllSelect(0)
                     elif len(cursel) > 0:
-                        self.active_array.mngselection.myselection = cursel.copy()
-                        self.active_array.mngselection.update_nb_nodes_sections()
+                        self.active_array.SelectionData.myselection = cursel.copy()
+                        self.active_array.SelectionData.update_nb_nodes_selection()
 
                 else:
                     logging.info(_('Copy selection values'))
@@ -7423,7 +7978,7 @@ class WolfMapViewer(wx.Frame):
                         self.active_array.paste_all(fromarray)
 
                     elif len(cursel) > 0:
-                        z = fromarray.mngselection.get_values_sel()
+                        z = fromarray.SelectionData.get_values_sel()
                         self.active_array.set_values_sel(cursel, z)
 
                 self.Refresh()
@@ -7447,6 +8002,8 @@ class WolfMapViewer(wx.Frame):
                 self.active_vertex = None
                 self.active_cloud = None
 
+                self.StatusBar.SetStatusText(_('Esc pressed - No more action in progress'))
+
             elif key == ord('C'):
 
                  self.copy_canvasogl(mpl = False)
@@ -7492,7 +8049,7 @@ class WolfMapViewer(wx.Frame):
                     if idx > 8:
                         idx -= 9
 
-                    self.active_array.mngselection.move_selectionto(str(idx+1), colors[idx])
+                    self.active_array.SelectionData.move_selectionto(str(idx+1), colors[idx])
 
             elif key == wx.WXK_F1:
                 self.read_last_result()
@@ -7526,8 +8083,8 @@ class WolfMapViewer(wx.Frame):
             elif key == wx.WXK_F9:
 
                 if self.active_array is not None:
-                    if self.active_array.mngselection is not None:
-                        self.active_array.mngselection.myselection = 'all'
+                    if self.active_array.SelectionData is not None:
+                        self.active_array.SelectionData.myselection = 'all'
                         logging.info(_('Selecting all nodes in the active array !'))
                     else:
                         logging.warning(_('No selection manager for this array !'))
@@ -7593,34 +8150,69 @@ class WolfMapViewer(wx.Frame):
 
     def paste_values(self,fromarray:WolfArray):
         logging.info(_('Copy selection values'))
-        cursel = fromarray.mngselection.myselection
+        cursel = fromarray.SelectionData.myselection
         if cursel == 'all':
             self.active_array.paste_all(fromarray)
         elif len(cursel) > 0:
-            z = fromarray.mngselection.get_values_sel()
+            z = fromarray.SelectionData.get_values_sel()
             self.active_array.set_values_sel(cursel, z)
 
     def paste_selxy(self,fromarray:WolfArray):
         logging.info(_('Paste selection position'))
-        cursel = fromarray.mngselection.myselection
+        cursel = fromarray.SelectionData.myselection
         if cursel == 'all':
-            self.active_array.mngselection.OnAllSelect(0)
+            self.active_array.SelectionData.OnAllSelect(0)
         elif len(cursel) > 0:
-            self.active_array.mngselection.myselection = cursel.copy()
-            self.active_array.mngselection.update_nb_nodes_sections()
+            self.active_array.SelectionData.myselection = cursel.copy()
+            self.active_array.SelectionData.update_nb_nodes_selection()
 
     def OntreeRight(self, e: wx.MouseEvent):
         """ Gestion du menu contextuel sur l'arbre des objets """
 
         if self.selected_object is not None:
+
+            # On va nettoyer le menu contextuel car certaines entrées ne sont
+            # pas nécessairement pertinentes
+
+            # Chaînes à supprimer
+            tracks=[]
+            tracks.append(_('Boundary conditions'))
+            tracks.append(_('Convert to mono-block'))
+            tracks.append(_('Convert to mono-block (result)'))
+            tracks.append(_('Convert to multi-blocks (result)'))
+
+            # Récupération des items du menu contextuel
+            menuitems = self.popupmenu.GetMenuItems()
+            text = [cur.GetItemLabelText() for cur in menuitems]
+
+            # Liste des indices à supprimer
+            # Pas possible de supprimer à la volée car cela modifie la liste
+            to_delete = []
+            for track in tracks:
+                if track in text:
+                    to_delete.append(text.index(track))
+
+            # Suppression des items
+            if len(to_delete) > 0:
+                # Suppression en ordre décroissant pour ne pas décaler les indices
+                to_delete.sort(reverse=True)
+                for idx in to_delete:
+                    self.popupmenu.Remove(menuitems[idx])
+
+            # Add specific menu items for WolfArray
             if isinstance(self.selected_object, WolfArray):
                 bc = self.get_boundary_manager(self.selected_object)
                 if bc is not None:
                     self.popupmenu.Append(wx.ID_ANY, _('Boundary conditions'), _('Boundary conditions'))
-            else:
-                text = [cur.GetItemLabelText() for cur in self.popupmenu.GetMenuItems()]
-                if _('Boundary conditions') in text:
-                    self.popupmenu.RemoveItem(text.index(_('Boundary conditions')))
+
+            # Add specific menu items for WolfArrayMB
+            if isinstance(self.selected_object, WolfArrayMB):
+                self.popupmenu.Append(wx.ID_ANY, _('Convert to mono-block'), _('Convert to mono-block'))
+
+            # Add specific menu items for Wolfresults_2D
+            if isinstance(self.selected_object, Wolfresults_2D):
+                self.popupmenu.Append(wx.ID_ANY, _('Convert to mono-block (result)'), _('Convert to mono-block'))
+                self.popupmenu.Append(wx.ID_ANY, _('Convert to multi-blocks (result)'), _('Convert to multi-blocks'))
 
             self.treelist.PopupMenu(self.popupmenu)
 
@@ -7654,10 +8246,13 @@ class WolfMapViewer(wx.Frame):
                     curobj.plotting = True
                     curobj.plot(sx = self.sx, sy=self.sy, xmin=self.xmin, ymin=self.ymin, xmax=self.xmax, ymax=self.ymax, size = (self.xmax - self.xmin) / 100.)
                     curobj.plotting = False
-        except:
+        except Exception as ex:
             curobj.plotting = False
             logging.error(_('Error while plotting objects of type {}').format(drawing_type.name))
 
+            traceback.print_exc()
+            logging.error(ex)
+
     def get_MVP_Viewport_matrix(self):
         """ Get the modelview projection matrix """
 
@@ -7990,7 +8585,7 @@ class WolfMapViewer(wx.Frame):
             logging.warning('Bad id')
             return
 
-        if type(curobj) in [WolfArray, WolfArrayMB]:
+        if issubclass(type(curobj), WolfArray):
             curobj.uncheck_plot(unload, forceresetOGL, askquestion)
         else:
             curobj.uncheck_plot()