wolfhece 2.0.55__py3-none-any.whl → 2.1.1__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 *
@@ -107,6 +108,108 @@ class draw_type(Enum):
     WMSFORE = 'wms-foreground'
     TILES = 'tiles'
 
+
+class DragdropFileTarget(wx.FileDropTarget):
+    def __init__(self, window:"WolfMapViewer"):
+        wx.FileDropTarget.__init__(self)
+        self.window = window
+
+    def OnDropFiles(self, x, y, filenames):
+
+        def test_if_array(filename):
+
+            ext = Path(filename).suffix
+
+            if ext.lower() in ['.bin', '.npy', '.hbin', '.qxin','.qybin', '.top',
+                               '.kbin', '.epsbin', '.tif', '.frot', '.topini_fine']:
+                return True
+            else:
+                return False
+
+        def test_if_arrayMB(filename):
+
+            ext = Path(filename).suffix
+
+            if ext.lower() in ['.hbinb', '.qxbinb','.qybinb', '.kbinb',
+                               '.epsbinb', '.topini', '.frotini']:
+                return True
+            else:
+                return False
+
+        def test_if_vector(filename):
+            ext = Path(filename).suffix
+
+            if ext.lower() in ['.vec', '.vecz', '.shp', '.dxf']:
+                return True
+            else:
+                return False
+
+        def test_if_cloud(filename):
+            ext = Path(filename).suffix
+
+            if ext.lower() in ['.xyz']:
+                return True
+            else:
+                return False
+
+        for name in filenames:
+
+            if Path(name).is_dir():
+                for file in scandir(name):
+                    if file.is_file():
+                        self.OnDropFiles(x, y, [file.path])
+                continue
+
+            if test_if_array(name):
+                ids = self.window.get_list_keys(draw_type.ARRAYS)
+                id = Path(name).stem
+                while id in ids:
+                    id = id + '_1'
+
+                try:
+                    newobj = WolfArray(fname=name)
+                    self.window.add_object('array', newobj = newobj, id  = id)
+                except:
+                    logging.error(_('Error while loading array : ') + name)
+
+            elif test_if_arrayMB(name):
+                ids = self.window.get_list_keys(draw_type.ARRAYS)
+                id = Path(name).stem
+                while id in ids:
+                    id = id + '_1'
+
+                try:
+                    newobj = WolfArrayMB(fname=name)
+                    self.window.add_object('array', newobj = newobj, id  = id)
+                except:
+                    logging.error(_('Error while loading array : ') + name)
+
+            elif test_if_vector(name):
+                ids = self.window.get_list_keys(draw_type.VECTORS)
+                id = Path(name).stem
+                while id in ids:
+                    id = id + '_1'
+
+                try:
+                    newobj = Zones(filename=name)
+                    self.window.add_object('vector', newobj = newobj, id  = id)
+                except:
+                    logging.error(_('Error while loading vector : ') + name)
+
+            elif test_if_cloud(name):
+                ids = self.window.get_list_keys(draw_type.CLOUD)
+                id = Path(name).stem
+                while id in ids:
+                    id = id + '_1'
+
+                try:
+                    newobj = cloud_vertices(fname=name)
+                    self.window.add_object('cloud', newobj = newobj, id  = id)
+                except:
+                    logging.error(_('Error while loading cloud : ') + name)
+
+        return True
+
 class WolfMapViewer(wx.Frame):
     """
     Fenêtre de visualisation de données WOLF grâce aux WxWidgets
@@ -151,7 +254,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
@@ -207,6 +330,9 @@ class WolfMapViewer(wx.Frame):
         self.treewidth = treewidth
         super(WolfMapViewer, self).__init__(wxparent, title=title, size=(w + self.treewidth, h))
 
+        self._dragdrop = DragdropFileTarget(self)
+        self.SetDropTarget(self._dragdrop)
+
         # Gestion des menus
         self.popupmenu = wx.Menu()
         self.popupmenu.Bind(wx.EVT_MENU, self.OnPopupItemSelected)
@@ -220,6 +346,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 +372,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'))
@@ -299,30 +433,40 @@ class WolfMapViewer(wx.Frame):
         self.filemenu.AppendSeparator()
         addscan = self.filemenu.Append(wx.ID_FILE5, _('Recursive scan...'), _('Add recursively'))
 
-        self.toolsmenu = wx.Menu()
-        self.link_cs_zones = self.toolsmenu.Append(wx.ID_ANY, _("Link cross sections to active zones"),
+        # Tools
+        # ----------------
+
+        self.tools_menu = wx.Menu()
+
+        self.menu_contour_from_arrays = self.tools_menu.Append(wx.ID_ANY, _("Create contour from checked arrays..."), _("Create contour"))
+
+        # Cross sections
+        # ----------------
+
+        self.cs_menu = wx.Menu()
+        self.link_cs_zones = self.cs_menu.Append(wx.ID_ANY, _("Link cross sections to active zones"),
                                                    _("Link cross section"))
-        self.sortalong = self.toolsmenu.Append(ID_SORTALONG, _("Sort along..."),
+        self.sortalong = self.cs_menu.Append(ID_SORTALONG, _("Sort along..."),
                                                _("Sort cross sections along support vector"))
-        self.select_cs = self.toolsmenu.Append(ID_SELECTCS, _("Pick one cross section"), _("Select cross section"),
+        self.select_cs = self.cs_menu.Append(ID_SELECTCS, _("Pick one cross section"), _("Select cross section"),
                                                kind=wx.ITEM_CHECK)
-        self.menumanagebanks = self.toolsmenu.Append(wx.ID_ANY, _("Manage banks..."), _("Manage banks"))
-        self.menucreatenewbanks = self.toolsmenu.Append(wx.ID_ANY, _("Create banks from vertices..."),
+        self.menumanagebanks = self.cs_menu.Append(wx.ID_ANY, _("Manage banks..."), _("Manage banks"))
+        self.menucreatenewbanks = self.cs_menu.Append(wx.ID_ANY, _("Create banks from vertices..."),
                                                         _("Manage banks"))
-        self.renamecs = self.toolsmenu.Append(wx.ID_ANY, _("Rename cross sections..."), _("Rename"))
-        self.menutrianglecs = self.toolsmenu.Append(wx.ID_ANY, _("Triangulate cross sections..."), _("Triangulate"))
-        self.menuexportgltfonebyone = self.toolsmenu.Append(wx.ID_ANY, _("Export cross sections to gltf..."),
+        self.renamecs = self.cs_menu.Append(wx.ID_ANY, _("Rename cross sections..."), _("Rename"))
+        self.menutrianglecs = self.cs_menu.Append(wx.ID_ANY, _("Triangulate cross sections..."), _("Triangulate"))
+        self.menuexportgltfonebyone = self.cs_menu.Append(wx.ID_ANY, _("Export cross sections to gltf..."),
                                                             _("Export gltf"))
-        self.menupontgltfonebyone = self.toolsmenu.Append(wx.ID_ANY, _("Create bridge and export gltf..."),
+        self.menupontgltfonebyone = self.cs_menu.Append(wx.ID_ANY, _("Create bridge and export gltf..."),
                                                           _("Bridge gltf"))
         # self.menuimport3dfaces_from_DXF = self.toolsmenu.Append(wx.ID_ANY, _("Import triangulation..."), _("DXF"))
-        self.menuinteractptri = self.toolsmenu.Append(wx.ID_ANY, _("Interpolate on active triangulation..."), _("InterpolateTri"))
-        self.menucomparecloud = self.toolsmenu.Append(wx.ID_ANY, _("Compare cloud to array..."), _("Comparison"))
-        self.menucomparetri = self.toolsmenu.Append(wx.ID_ANY, _("Compare triangles to array..."), _("Comparison"))
+        self.menuinteractptri = self.cs_menu.Append(wx.ID_ANY, _("Interpolate on active triangulation..."), _("InterpolateTri"))
+        self.menucomparecloud = self.cs_menu.Append(wx.ID_ANY, _("Compare cloud to array..."), _("Comparison"))
+        self.menucomparetri = self.cs_menu.Append(wx.ID_ANY, _("Compare triangles to array..."), _("Comparison"))
 
         #Profile plots
         #The action for plotting cross section's profile is initialised.
-        self.plot_cs = self.toolsmenu.Append(ID_PLOTCS, _("Plot cross section"),_("Plot cross section"),kind=wx.ITEM_CHECK)
+        self.plot_cs = self.cs_menu.Append(ID_PLOTCS, _("Plot cross section"),_("Plot cross section"),kind=wx.ITEM_CHECK)
 
         self.menuviewerinterpcs = None
         self.menuinterpcs = None
@@ -387,6 +531,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
@@ -424,7 +570,8 @@ class WolfMapViewer(wx.Frame):
         # ajout du menu pour les données LAZ
         self.menu_laz()
 
-        self.menubar.Append(self.toolsmenu, _('&Cross sections'))
+        self.menubar.Append(self.tools_menu, _('&Tools'))
+        self.menubar.Append(self.cs_menu, _('&Cross sections'))
 
         self.menubar.Append(self.minmaxmenu, _('&Colormap'))
         self.menubar.Append(self.analyzemenu, _('&Analyze'))
@@ -434,6 +581,8 @@ class WolfMapViewer(wx.Frame):
 
         # Ajout du conteneur OpenGL
         self.canvas = GLCanvas(self)
+        self.canvas.SetDropTarget(self._dragdrop)
+
         self.context = GLContext(self.canvas)
         self.mybackisloaded = False
         self.myfrontisloaded = False
@@ -515,6 +664,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
@@ -644,26 +819,355 @@ class WolfMapViewer(wx.Frame):
             bridgelaz = self.menulazdata.Append(wx.ID_ANY, _('Create cloud points from bridges'), _('LAZ Bridge'))
             buildinglaz = self.menulazdata.Append(wx.ID_ANY, _('Create cloud points from buildings'), _('LAZ Buildings'))
 
-            croplaz = self.menulaz.Append(wx.ID_ANY, _('Clip LAZ grid on current zoom'), _('Select LAZ data based on the visible screen extent'),)
-            viewlaz = self.menulaz.Append(wx.ID_ANY, _('Create LAZ viewer'), _('Create a LAZ Viewer based on loaded data'))
-            aroundlaz = self.menulaz.Append(wx.ID_ANY, _('Plot LAZ around active vector'), _('Display a Matplotlib plot with the LAZ values around the active vector/polyline'),)
-            pick_aroundlaz = self.menulaz.Append(wx.ID_ANY, _('Plot LAZ around temporary vector'), _('Display a Matplotlib plot with the LAZ values around a temporary vector/polyline -- Right clicks to add points + Enter'),)
-            updatecolors_laz = self.menulaz.Append(wx.ID_ANY, _('Change colors - Classification'), _('Change color map associated to the current classification'),)
+            croplaz = self.menulaz.Append(wx.ID_ANY, _('Clip LAZ grid on current zoom'), _('Select LAZ data based on the visible screen extent'),)
+            viewlaz = self.menulaz.Append(wx.ID_ANY, _('Create LAZ viewer'), _('Create a LAZ Viewer based on loaded data'))
+            aroundlaz = self.menulaz.Append(wx.ID_ANY, _('Plot LAZ around active vector'), _('Display a Matplotlib plot with the LAZ values around the active vector/polyline'),)
+            pick_aroundlaz = self.menulaz.Append(wx.ID_ANY, _('Plot LAZ around temporary vector'), _('Display a Matplotlib plot with the LAZ values around a temporary vector/polyline -- Right clicks to add points + Enter'),)
+            updatecolors_laz = self.menulaz.Append(wx.ID_ANY, _('Change colors - Classification'), _('Change color map associated to the current classification'),)
+
+    def menu_wolf2d(self):
+
+        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_video = self.menuwolf2d.Append(wx.ID_ANY, _("Create video..."), _("Video/Movie"))
+
+            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"):
 
-    def menu_wolf2d(self):
+            self.menu_filter_independent.IsChecked = not self.menu_filter_independent.IsChecked
 
-        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"))
+            for curmodel in self.iterator_over_objects(draw_type.RES2D):
+                curmodel: Wolfresults_2D
+                curmodel.to_filter_independent = not self.menu_filter_independent.IsChecked
 
-            self.menu_filter_independent = self.menuwolf2d.Append(wx.ID_ANY, _("Filter independent"), _("Filter independent"), kind=wx.ITEM_CHECK)
+        # elif itemlabel == _("Manage boundary conditions..."):
 
-            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"))
+        #     if self.active_res2d is not None:
+        #         self.active_res2d.myparams.editing_bc(self.myres2D)
 
-            self.menubar.Append(self.menuwolf2d, _('Options 2D'))
+        elif itemlabel ==_("Create video..."):
+            if self.active_res2d is not None:
+                self.create_video()
 
     def menu_2dgpu(self):
 
@@ -903,21 +1407,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 +1484,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
@@ -1085,10 +1733,10 @@ class WolfMapViewer(wx.Frame):
         self.add_object('vector', newobj=self.myinterp.myzones, ToCheck=False, id='Interp_mesh')
 
         if self.menuviewerinterpcs is None:
-            self.menuviewerinterpcs = self.toolsmenu.Append(wx.ID_ANY, _("New cloud Viewer..."),
+            self.menuviewerinterpcs = self.cs_menu.Append(wx.ID_ANY, _("New cloud Viewer..."),
                                                             _("Cloud viewer Interpolate"))
         if self.menuinterpcs is None:
-            self.menuinterpcs = self.toolsmenu.Append(wx.ID_ANY, _("Interpolate on active array..."), _("Interpolate"))
+            self.menuinterpcs = self.cs_menu.Append(wx.ID_ANY, _("Interpolate on active array..."), _("Interpolate"))
 
     def interpolate_cloud(self):
         """
@@ -1748,6 +2396,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 +2459,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 +2529,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 +2548,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 +2577,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')
 
@@ -2464,6 +3141,91 @@ class WolfMapViewer(wx.Frame):
                     if cur is not self:
                         cur.update()
 
+    def zoom_on_id(self, id:str, draw_type:draw_type = draw_type.ARRAYS, forceupdate=True, canvas_height=1024):
+        """
+        Zoom on id
+
+        :param id: id of the object to zoom on
+        :param drawtype: type of object to zoom on - Different types elements can have the same id
+
+        """
+
+        if draw_type not in [draw_type.ARRAYS, draw_type.VECTORS]:
+            logging.warning(_('Draw type must be either ARRAYS or VECTORS'))
+            return
+
+        obj = self.get_obj_from_id(id, draw_type)
+
+        if obj is None:
+            logging.warning(_('No object found with id {} and drawtype {}'.format(id, draw_type)))
+            return
+
+        if draw_type == draw_type.ARRAYS:
+            self.zoom_on_array(obj, forceupdate=forceupdate, canvas_height=canvas_height)
+        elif draw_type == draw_type.VECTORS:
+            self.zoom_on_vector(obj, forceupdate=forceupdate, canvas_height=canvas_height)
+
+    def zoom_on_array(self, array:WolfArray, forceupdate=True, canvas_height=1024):
+        """ Zoom on array """
+
+        if array.xmin == -99999:
+            array.find_minmax()
+
+        bounds = array.get_bounds()
+
+        center = [(bounds[0][1] + bounds[0][0]) / 2., (bounds[1][1] + bounds[1][0]) / 2.]
+        width  = bounds[0][1] - bounds[0][0]
+        height = bounds[1][1] - bounds[1][0]
+
+        self.zoom_on({'center':center, 'width':width, 'height':height}, forceupdate=forceupdate, canvas_height=canvas_height)
+
+    def zoom_on_vector(self, vector:vector, forceupdate=True, canvas_height=1024):
+        """ Zoom on vector """
+
+        if vector.xmin == -99999:
+            vector.find_minmax()
+
+        bounds = vector.get_bounds_xx_yy()
+
+        center = [(bounds[0][1] + bounds[0][0]) / 2., (bounds[1][1] + bounds[1][0]) / 2.]
+        width  = bounds[0][1] - bounds[0][0]
+        height = bounds[1][1] - bounds[1][0]
+
+        self.zoom_on({'center':center, 'width':width, 'height':height}, forceupdate=forceupdate, canvas_height=canvas_height)
+
+    def create_Zones_from_arrays(self, arrays:list[WolfArray], id:str = None, add_legend:bool=True) -> Zones:
+        """
+        Create a Zones instance from list of WolfArrays
+
+        One zone per array.
+
+        One vector per zone with the masked contour.
+
+        :param arrays: list of WolfArrays
+        :param id: id of the Zones instance
+        :param add_legend: add legend to the vector -- centroid of the contour
+
+        """
+
+        # création de l'instance de Zones
+        new_zones = Zones(idx = 'contour' if id is None else id.lower(), mapviewer=self)
+
+        for curarray in arrays:
+
+            if isinstance(curarray, WolfArray):
+                new_zone = zone(name = curarray.idx)
+                new_zones.add_zone(new_zone, forceparent=True)
+
+                sux, sux, curvect, interior = curarray.suxsuy_contour()
+                new_zone.add_vector(curvect, forceparent=True)
+                curvect.set_legend_to_centroid(curarray.idx)
+                logging.info(_('{} treated'.format(curarray.idx)))
+            else:
+                logging.warning(_('All elements in the list must be of type WolfArray'))
+
+        return new_zones
+
+
     def zoom_on(self, zoom_dict = None, width = 500, height = 500, center = None, xll = None, yll = None, forceupdate=True, canvas_height=1024):
         """
         Zoom on a specific area
@@ -2543,7 +3305,7 @@ class WolfMapViewer(wx.Frame):
                     if cur is not self:
                         cur.update()
 
-    def zoomon_active_profile(self, size:float=500., forceupdate:bool=True):
+    def zoom_on_active_profile(self, size:float=500., forceupdate:bool=True):
         """ Zoom on active profile """
 
         curvec = self.active_profile
@@ -3122,123 +3884,49 @@ class WolfMapViewer(wx.Frame):
             dlg.Destroy()
 
             if idx == 0:
-                laz_source = self.mylazdata
-            else:
-                laz_source = self.mylazgrid
-
-        return laz_source
-
-    def OnMenubar(self, event: wx.MenuEvent):
-        """
-        Gestion des clicks sur le menu quel que soit le niveau
-
-        Idée générale :
-            - récupérer le label du menu sur base de l'id de l'event WX passé en argument --> itemlabel
-            - tester le label du menu sur base de la chaîne traduite
-            - a priori appeler une autre routine spécifique au traitement choisi
-            - éviter autant que possible de coder des fonctions directement dans cette routine ce qui la rendrait complexe à lire
-
-        AUTRE POSSIBILITE:
-            - mettre en place un dictionnaire avec key==label, value==action qui se contenterait de tester la présence du label dans les clés et d'appeler l'action
-            - dans ce dernier cas, il faudrait que les routines possèdent idéalement une interface unique
-        """
-        id = event.GetId()
-        item = self.menubar.FindItemById(event.GetId())
-
-        if item is None:
-            return
-
-        itemlabel = item.ItemLabel
-
-        autoscale = True
-
-        if id == wx.ID_OPEN:
-            filterProject = "proj (*.proj)|*.proj|param (*.param)|*.param|all (*.*)|*.*"
-            file = wx.FileDialog(self, "Choose file", wildcard=filterProject)
-            if file.ShowModal() == wx.ID_CANCEL:
-                file.Destroy()
-                return
-            else:
-                # récuparétaion du nom de fichier avec chemin d'accès
-                filename = file.GetPath()
-                file.Destroy()
-
-            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()
+                laz_source = self.mylazdata
+            else:
+                laz_source = self.mylazgrid
 
-        elif itemlabel == _('Update model from current mask'):
+        return laz_source
 
-            if type(self.active_array) != WolfArray_Sim2D:
-                msg = _('Please select a mono-block array !')+'\n'
-                dlg=wx.MessageBox(msg,style=wx.OK)
-                return
+    def OnMenubar(self, event: wx.MenuEvent):
+        """
+        Gestion des clicks sur le menu quel que soit le niveau
 
-            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'
+        Idée générale :
+            - récupérer le label du menu sur base de l'id de l'event WX passé en argument --> itemlabel
+            - tester le label du menu sur base de la chaîne traduite
+            - a priori appeler une autre routine spécifique au traitement choisi
+            - éviter autant que possible de coder des fonctions directement dans cette routine ce qui la rendrait complexe à lire
 
-            dlg = wx.MessageDialog(self,msg,caption = _('Attention'), style = wx.YES_NO)
-            ret = dlg.ShowModal()
-            dlg.Destroy()
-            if ret == wx.ID_NO:
-                return
+        AUTRE POSSIBILITE:
+            - mettre en place un dictionnaire avec key==label, value==action qui se contenterait de tester la présence du label dans les clés et d'appeler l'action
+            - dans ce dernier cas, il faudrait que les routines possèdent idéalement une interface unique
+        """
+        id = event.GetId()
+        item = self.menubar.FindItemById(event.GetId())
 
-            with wx.lib.busy.BusyInfo(_('Updating 2D model')):
-                wait = wx.BusyCursor()
+        if item is None:
+            return
 
-                sux,suy,cont,interior = self.active_array.suxsuy_contour(self.wolfparent.filenamegen,True)
+        itemlabel = item.ItemLabel
 
-                self.wolfparent.mimic_mask(self.active_array)
-                self.wolfparent.replace_external_contour(cont,interior)
+        autoscale = True
 
-                del wait
+        if id == wx.ID_OPEN:
+            filterProject = "proj (*.proj)|*.proj|param (*.param)|*.param|all (*.*)|*.*"
+            file = wx.FileDialog(self, "Choose file", wildcard=filterProject)
+            if file.ShowModal() == wx.ID_CANCEL:
+                file.Destroy()
+                return
+            else:
+                # récuparétaion du nom de fichier avec chemin d'accès
+                filename = file.GetPath()
+                file.Destroy()
 
-            self.wolfparent.extend_bed_elevation()
+            os.chdir(os.path.dirname(filename))
+            self.read_project(filename)
 
         elif itemlabel == _('Shortcuts'):
             # show shortcuts in log
@@ -3297,7 +3985,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 +4220,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 +4425,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')
@@ -3802,6 +4483,12 @@ class WolfMapViewer(wx.Frame):
         elif itemlabel==_("Compare triangles to array..."):
             self.compare_tri2array()
 
+        elif itemlabel ==  _("Create contour from checked arrays..."):
+
+            # Create contour from checked arrays and add it to the list of objects
+            newzones = self.create_Zones_from_arrays(self.get_list_objects(draw_type.ARRAYS, checked_state=True))
+            self.add_object('vector', newobj=newzones, ToCheck=True, id='Contours from arrays')
+
         elif itemlabel == _("Create bridge and export gltf..."):
 
             if self.active_cs is None:
@@ -3998,22 +4685,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 +5095,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 +5518,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 +5625,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 +6054,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 != '':
@@ -5395,6 +6082,7 @@ class WolfMapViewer(wx.Frame):
 
     def get_obj_from_treeitem(self, treeitem):
         """ Find the object associated with treeitem """
+
         return self.treelist.GetItemData(treeitem)
 
     def getobj_from_id(self, id: str):
@@ -5409,6 +6097,24 @@ class WolfMapViewer(wx.Frame):
                 except:
                     return None
 
+    def get_obj_from_id(self, id: str, drawtype: draw_type):
+        """ Find the object associated with id in a specifid drawtype
+
+        If you want to search in all drawtypes, use getobj_from_id instead.
+
+        :param id: str : id of the object
+        :param drawtype: draw_type : type of object to search
+
+        """
+
+        keys = self.get_list_keys(draw_type, checked_state=None)
+        if id.lower() in keys:
+            try:
+                idx = keys.index(id.lower())
+                return self.get_list_objects(draw_type, checked_state=None)[idx]
+            except:
+                return None
+
     def _get_list(self, drawing_type:draw_type):
         """ return the list of objects of type drawing_type """
 
@@ -5455,6 +6161,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 +6169,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 +6391,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 +6429,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 +6486,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 +6528,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 +6536,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 +6643,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()
@@ -6095,7 +6838,7 @@ class WolfMapViewer(wx.Frame):
 
             #on met le profil en rouge et plus épais
             self.active_profile.color_active_profile()
-            self.zoomon_active_profile()
+            self.zoom_on_active_profile()
 
             self.Paint()
 
@@ -6176,13 +6919,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 +7038,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 +7068,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 +7183,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 +7191,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 +7657,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 +7730,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 +7741,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 +7753,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 +7769,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 +8146,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 +8161,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 +8189,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 +8206,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 +8230,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 +8277,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 +8311,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 +8378,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 +8474,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 """
 
@@ -7969,6 +8792,8 @@ class WolfMapViewer(wx.Frame):
         return [cur.idx for cur in self.mywmsfore]
 
     def check_id(self, id=str, gridsize = 100.):
+        """ Check an element from its id """
+
         curobj = self.getobj_from_id(id)
 
         if curobj is None:
@@ -7984,13 +8809,15 @@ class WolfMapViewer(wx.Frame):
             curobj.creategrid(gridsize, self.xmin, self.ymin, self.xmax, self.ymax)
 
     def uncheck_id(self, id=str, unload=True, forceresetOGL=True, askquestion=False):
+        """ Uncheck an element from its id """
+
         curobj = self.getobj_from_id(id)
 
         if curobj is None:
             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()
@@ -7999,6 +8826,12 @@ class WolfMapViewer(wx.Frame):
         self.treelist.CheckItem(curitem, False)
 
     def get_current_zoom(self):
+        """
+        Get the current zoom
+
+        :return: dict with keys 'center', 'xmin', 'xmax', 'ymin', 'ymax', 'width', 'height'
+
+        """
 
         return {'center': (self.mousex, self.mousey),
                 'xmin' :  self.xmin,
@@ -8009,12 +8842,15 @@ class WolfMapViewer(wx.Frame):
                 'height' : self.ymax-self.ymin}
 
     def save_current_zoom(self, filepath):
+        """ Save the current zoom in a json file """
 
         zoom = self.get_current_zoom()
         with open(filepath, 'w') as fp:
             json.dump(zoom, fp)
 
     def read_current_zoom(self, filepath):
+        """ Read the current zoom from a json file """
+
         if exists(filepath):
             with open(filepath, 'r') as fp:
                 zoom = json.load(fp)