wolfhece 2.0.55__py3-none-any.whl → 2.1.1__py3-none-any.whl

wolfhece/PyGui.py

@@ -3,14 +3,15 @@ from os.path import exists, join, isdir, isfile, dirname, normpath, splitext
 from pathlib import Path
 import numpy.ma as ma
 import wx
+import wx.adv
 from wx.lib.busy import BusyInfo
 import logging
 from pathlib import Path
 
 from .apps.splashscreen import WolfLauncher
-from .wolf_array import WOLF_ARRAY_FULL_LOGICAL, WOLF_ARRAY_MB_SINGLE, WolfArray, getkeyblock, WolfArray_Sim2D, WOLF_ARRAY_FULL_INTEGER16, WOLF_ARRAY_MB_INTEGER
+from .wolf_array import WOLF_ARRAY_FULL_LOGICAL, WOLF_ARRAY_MB_SINGLE, WolfArray, getkeyblock, WOLF_ARRAY_FULL_INTEGER16, WOLF_ARRAY_MB_INTEGER
 from .PyTranslate import _
-from .PyDraw import WolfMapViewer,imagetexture
+from .PyDraw import WolfMapViewer,imagetexture, draw_type
 
 from .hydrometry.kiwis_wolfgui import hydrometry_wolfgui
 
@@ -27,6 +28,11 @@ from .hydrology.forcedexchanges import forced_exchanges
 from .PyParams import Wolf_Param
 from .picc import Picc_data, Cadaster_data
 from .wolf_zi_db import ZI_Databse_Elt, PlansTerrier
+from .CpGrid import CpGrid
+
+
+GEOM_GROUP_NAME = _('Block geometry')
+MAGN_GROUP_NAME = _('Magnetic grid')
 
 # FIXME : Is it necessary to override wx.Frame ? WolfMapManager is a wx.Frame.
 #         Is it sufficient to run a wx.App ?
@@ -156,6 +162,7 @@ class MapManager(GenMapManager):
         self.picc          = Picc_data(data_dir=Path(r'data/PICC'), mapviewer=self.mapviewer)
         self.cadaster      = Cadaster_data(data_dir=Path(r'data/Cadaster'), mapviewer=self.mapviewer)
         self.landmaps      = PlansTerrier(mapviewer=self.mapviewer, parent = self, idx='LandMaps', plotted=True)
+        self.mapviewer.menu_walous()
 
         self.mapviewer.add_object(which='other',
                                   newobj=self.SPWhydrometry,
@@ -339,190 +346,490 @@ class HydrologyModel(GenMapManager):
             self.mainparams.Hide()
             self.basinparams.Hide()
 
+
+class Wolf2DPartArrays():
+
+    def __init__(self, sim:prev_sim2D, mapviewer:WolfMapViewer) -> None:
+
+        self.wx_exists = wx.App.Get() is not None # test if wx App is running
+        self.sim = sim
+        self._gui = None
+        self.mapviewer = mapviewer
+
+        self._cur_list = None
+
+        if self.wx_exists:
+            self.setup_gui()
+
+    def setup_gui(self):
+        """
+        Create the GUI
+
+        A listbox in the upper part of the window will list the different part arrays.
+
+        When a part array is selected, the listbox on the left will list the files
+        associated with the selected part array. The listbox on the right will list
+        the blocks associated with the selected file.
+
+        """
+
+        self._gui = wx.Frame(None, title="Part Arrays", size=(400, 600))
+
+        self._panel = wx.Panel(self._gui)
+
+        sizer_vert = wx.BoxSizer(wx.VERTICAL)
+        sizer_hor = wx.BoxSizer(wx.HORIZONTAL)
+        sizer_vert_left = wx.BoxSizer(wx.VERTICAL)
+        sizer_vert_right = wx.BoxSizer(wx.VERTICAL)
+        sizer_btns = wx.BoxSizer(wx.HORIZONTAL)
+
+        sizer_hor.Add(sizer_vert_left, 1, wx.EXPAND)
+        sizer_hor.Add(sizer_vert_right, 1, wx.EXPAND)
+
+        self._lists = wx.ListBox(self._panel,
+                                 choices = [_("Topography"),
+                                            _("Friction"),
+                                            _("Water depth"),
+                                            _("Discharge X"),
+                                            _("Discharge Y"),
+                                            _("Buildings"),
+                                            _("Bridges"),
+                                            _("Infiltration")],
+                                 style= wx.LB_SINGLE | wx.LB_HSCROLL | wx.LB_NEEDED_SB)
+
+        self._lists.Bind(wx.EVT_LISTBOX, self.on_list)
+
+        sizer_vert.Add(self._lists, 0, wx.EXPAND)
+        sizer_vert.Add(sizer_hor, 1, wx.EXPAND)
+
+        self._list_files = wx.ListBox(self._panel,
+                                        style=wx.LB_SINGLE,
+                                        choices = [])
+
+        self._list_files.Bind(wx.EVT_LISTBOX, self.on_list_files)
+
+        self._list_blocks = wx.ListBox(self._panel,
+                                        style=wx.LB_MULTIPLE,
+                                        choices = [str(i+1) for i in range(self.sim.nb_blocks)])
+
+        self._list_blocks.Bind(wx.EVT_LISTBOX, self.on_list_blocks)
+
+
+        self_btn_addfile = wx.Button(self._panel, label=_("Add file"))
+        self_btn_addfile.Bind(wx.EVT_BUTTON, self.on_addfile)
+        self_btn_addfile.SetToolTipString(_("Add a file to the selected part array"))
+
+        self_btn_delfile = wx.Button(self._panel, label=_("Delete file"))
+        self_btn_delfile.Bind(wx.EVT_BUTTON, self.on_delfile)
+        self_btn_delfile.SetToolTipString(_("Delete the selected file from the selected part array"))
+
+        self._btn_apply = wx.Button(self._panel, label=_("Apply"))
+        self._btn_apply.Bind(wx.EVT_BUTTON, self.on_apply)
+        self._btn_apply.SetToolTipString(_("Apply the values in the grid to the in-memory simulation (without writing to disk)"))
+
+        self._btn_toviewer = wx.Button(self._panel, label=_("To viewer"))
+        self._btn_toviewer.Bind(wx.EVT_BUTTON, self.on_toviewer)
+
+        sizer_btns.Add(self_btn_addfile, 1, wx.EXPAND | wx.ALL, 2)
+        sizer_btns.Add(self_btn_delfile, 1, wx.EXPAND | wx.ALL, 2)
+        sizer_btns.Add(self._btn_apply, 2, wx.EXPAND | wx.ALL, 2)
+        sizer_btns.Add(self._btn_toviewer, 2, wx.EXPAND | wx.ALL, 2)
+
+        sizer_vert.Add(sizer_btns, 0, wx.EXPAND)
+
+        sizer_vert_left.Add(self._list_files, 1, wx.EXPAND)
+        sizer_vert_right.Add(self._list_blocks, 1, wx.EXPAND)
+
+
+        self._panel.SetSizer(sizer_vert)
+        self._panel.SetAutoLayout(1)
+
+
+    def on_toviewer(self, event):
+        """ Add the selected array to the mapviewer """
+
+        if self.mapviewer is None:
+            logging.error("No mapviewer created")
+            return
+
+        selected = self._list_files.GetSelection()
+
+        if selected != wx.NOT_FOUND:
+
+            fpath = Path(self.sim.filenamegen).parent / self._cur_list[selected][0]
+            locarray = WolfArray(fpath)
+
+            try:
+
+                self.mapviewer.add_object(which='array',
+                                          newobj=locarray,
+                                          id=fpath.name,
+                                          ToCheck=True)
+
+                self.mapviewer.Refresh()
+
+            except:
+                logging.error(_(f"Can't add {fpath} to the mapviewer"))
+
+
+    def on_list(self, event):
+        """ When a part array is selected """
+
+        selected = self._lists.GetSelection()
+
+        if selected == 0:
+            self._cur_list = self.sim.part_arrays._topography
+
+        elif selected == 1:
+            self._cur_list = self.sim.part_arrays._friction
+
+        elif selected == 2:
+            self._cur_list = self.sim.part_arrays._watedepth
+
+        elif selected == 3:
+            self._cur_list = self.sim.part_arrays._dischargeX
+
+        elif selected == 4:
+            self._cur_list = self.sim.part_arrays._dischargeY
+
+        elif selected == 5:
+            self._cur_list = self.sim.part_arrays._buildings
+
+        elif selected == 6:
+            self._cur_list = self.sim.part_arrays._bridges
+
+        elif selected == 7:
+            self._cur_list = self.sim.part_arrays._infiltration
+
+        self._list_files.Set([cur[0] for cur in self._cur_list])
+
+    def on_list_files(self, event):
+        """ When a file is selected """
+
+        selected = self._list_files.GetSelection()
+
+        self._list_blocks.Set([str(i+1) for i in range(self.sim.nb_blocks)])
+
+        for i in self._cur_list[selected][2]:
+            self._list_blocks.SetSelection(i-1)
+
+    def on_list_blocks(self, event):
+        pass
+
+    def on_addfile(self, event):
+        """ Add a file to the selected part array """
+
+        dlg = wx.FileDialog(self._gui, _("Choose a file"), "", "", "All files (*.bin)|*.bin", wx.FD_OPEN | wx.FD_FILE_MUST_EXIST)
+
+        if dlg.ShowModal() == wx.ID_OK:
+
+            file = Path(dlg.GetPath())
+
+            head = file / '.txt'
+
+            if head.exists():
+                locarray = WolfArray(file)
+
+                relative = file.relative_to(self.sim.filenamegen)
+
+                self._cur_list.append([relative, locarray.get_header(), [1]])
+                self._list_files.Set([cur[0] for cur in self._cur_list])
+
+    def on_delfile(self, event):
+        """ Delete the selected file """
+
+        selected = self._list_files.GetSelection()
+
+        if selected != wx.NOT_FOUND:
+
+            dlg = wx.MessageDialog(self._gui, _("Are you sure you want to delete this file ?"), _("Delete file"), wx.YES_NO | wx.ICON_QUESTION)
+            if dlg.ShowModal() == wx.ID_YES:
+                self._cur_list.pop(selected)
+                self._list_files.Set([cur[0] for cur in self._cur_list])
+
+            dlg.Destroy()
+
+    def on_apply(self, event):
+
+        selected = self._list_files.GetSelection()
+
+        if selected != wx.NOT_FOUND:
+
+            self._cur_list[selected][2] = [int(i) for i in self._list_blocks.GetSelections()]
+
+    def Show(self):
+
+        if self._gui is not None:
+            self._gui.Show()
+        else:
+            logging.error("No GUI created")
+
+class Wolf2DInfiltration():
+
+    def __init__(self, sim:prev_sim2D = None):
+
+        self.wx_exists = wx.App.Get() is not None # test if wx App is running
+        self.sim = sim
+        self._gui = None
+
+        if self.wx_exists:
+            self.setup_gui()
+
+    @property
+    def number_of_infiltration(self):
+
+        return self.sim.infiltration.nb_zones
+
+    def setup_gui(self):
+
+        if not self.wx_exists:
+            logging.error("You can't create a GUI outside a wx.App")
+
+        self._gui = wx.Frame(None, title="Infiltration", size=(600, 400))
+
+        self._panel = wx.Panel(self._gui)
+
+        sizer_hor = wx.BoxSizer(wx.HORIZONTAL)
+        sizer_vert = wx.BoxSizer(wx.VERTICAL)
+        sizer_btns = wx.BoxSizer(wx.HORIZONTAL)
+
+        self._grid = CpGrid(self._panel,wx.ID_ANY, wx.WANTS_CHARS)
+        self._grid.CreateGrid(10, 3)
+
+        self._btn_apply = wx.Button(self._panel, label=_("Apply"))
+        self._btn_apply.Bind(wx.EVT_BUTTON, self.on_apply)
+        self._btn_apply.SetToolTipString(_("Apply the values in the grid to the in-memory simulation (without writing to disk)"))
+
+        self._btn_check = wx.Button(self._panel, label=_("Check"))
+        self._btn_check.Bind(wx.EVT_BUTTON, self.on_check)
+        self._btn_check.SetToolTipString(_("Check the consistency of the in-memory simulation (.fil and .inf files)"))
+
+        self._btn_reload = wx.Button(self._panel, label=_("Reload"))
+        self._btn_reload.Bind(wx.EVT_BUTTON, self.on_reload)
+        self._btn_reload.SetToolTipString(_("Reload the values from the in-memory simulation"))
+
+        self._btn_plot = wx.Button(self._panel, label=_("Plot"))
+        self._btn_plot.Bind(wx.EVT_BUTTON, self.on_plot)
+        self._btn_plot.SetToolTipString(_("Plot the discharges"))
+
+        self._btn_plus = wx.Button(self._panel, label="+")
+        self._btn_plus.Bind(wx.EVT_BUTTON, self.on_plus)
+        self._btn_plus.SetToolTipString(_("Add zone(s) or step(s)"))
+
+        self._btn_minus = wx.Button(self._panel, label="-")
+        self._btn_minus.Bind(wx.EVT_BUTTON, self.on_minus)
+        self._btn_minus.SetToolTipString(_("Remove zone(s) or step(s)"))
+
+        self._btn_adjust = wx.Button(self._panel, label=_("Adjust"))
+        self._btn_adjust.Bind(wx.EVT_BUTTON, self.on_adjust)
+        self._btn_adjust.SetToolTipString(_("Adjust the number of rows and columns of the grid"))
+
+        sizer_btns.Add(self._btn_apply, 2, wx.EXPAND | wx.ALL, 2)
+        sizer_btns.Add(self._btn_check, 2, wx.EXPAND | wx.ALL, 2)
+        sizer_btns.Add(self._btn_reload, 2, wx.EXPAND | wx.ALL, 2)
+        sizer_btns.Add(self._btn_plot, 2, wx.EXPAND | wx.ALL, 2)
+        sizer_btns.Add(self._btn_plus, 1, wx.EXPAND | wx.ALL, 2)
+        sizer_btns.Add(self._btn_minus, 1, wx.EXPAND | wx.ALL, 2)
+        sizer_btns.Add(self._btn_adjust, 2, wx.EXPAND | wx.ALL, 2)
+
+        self._txt_info = wx.TextCtrl(self._panel, style=wx.TE_MULTILINE|wx.TE_READONLY)
+
+        sizer_vert.Add(self._grid, 1, wx.EXPAND)
+        sizer_vert.Add(sizer_btns, 0, wx.EXPAND)
+        sizer_vert.Add(self._txt_info, 1, wx.EXPAND)
+
+        sizer_hor.Add(sizer_vert, 1, wx.EXPAND)
+
+        self._panel.SetSizer(sizer_hor)
+        self._panel.SetAutoLayout(1)
+
+    def on_apply(self, event):
+
+        i_max = 0
+        while self._grid.GetCellValue(i_max, 0) != "" and i_max < self._grid.GetNumberRows()-1:
+            i_max += 1
+
+        j_max = 1
+        while self._grid.GetCellValue(0, j_max) != "" and j_max < self._grid.GetNumberCols()-1:
+            j_max += 1
+
+        chronos = np.zeros((i_max, j_max), dtype=np.float64)
+
+        for i in range(i_max+1):
+            for j in range(j_max+1):
+                chronos[i,j] = self._grid.GetCellValue(i, j)
+
+        self.sim.infiltration.infiltrations_chronology = chronos
+        self._btn_check(1)
+
+
+    def _fillgrid(self):
+        """ Fill the CpGrid """
+
+        if self.sim is None:
+            logging.error("No simulation loaded")
+            return
+
+        grid = self._grid
+
+        nb_steps = self.sim.infiltration.nb_steps
+        nb_zones = self.sim.infiltration.nb_zones
+
+        chronos = self.sim.infiltration.infiltrations_chronology
+
+        if nb_steps > grid.GetNumberRows():
+            grid.AppendRows(nb_steps - grid.GetNumberRows())
+
+        if nb_zones > grid.GetNumberCols()-1:
+            grid.AppendCols(nb_zones+1 - grid.GetNumberCols())
+
+        grid.ClearGrid()
+
+        grid.SetColLabelValue(0, _("Time"))
+        for i in range(1,nb_zones+1):
+            grid.SetColLabelValue(i, f"Zone {i}")
+
+        for i in range(nb_steps):
+            for j in range(nb_zones+1):
+                grid.SetCellValue(i, j, str(chronos[i][j]))
+
+    def on_adjust(self, event):
+        """ Adjust the number of rows and columns of the CpGrid """
+
+        nb_steps = self.sim.infiltration.nb_steps
+        nb_zones = self.sim.infiltration.nb_zones
+
+        if self._grid.GetNumberCols() < nb_zones+1:
+            self._grid.AppendCols(nb_zones+1-self._grid.GetNumberCols())
+        elif self._grid.GetNumberCols() > nb_zones+1:
+            self._grid.DeleteCols(nb_zones, self._grid.GetNumberCols()-nb_zones-1)
+
+        if self._grid.GetNumberRows() < nb_steps:
+            self._grid.AppendRows(nb_steps-self._grid.GetNumberRows())
+        elif self._grid.GetNumberRows() > nb_steps:
+            self._grid.DeleteRows(nb_steps, self._grid.GetNumberRows()-nb_steps)
+
+        self._btn_check.SetBackgroundColour(wx.NullColour)
+
+    def on_plus(self, event):
+        """ Add a zone or steps"""
+
+        nb_zones = 0
+        nb_steps = 0
+
+        dlg = wx.NumberEntryDialog(self._gui, _('Number of zones to add'), _('Add zones'), _('Add'), value = 1, min=0, max=1000)
+        if dlg.ShowModal() == wx.ID_OK:
+            nb_zones = int(dlg.GetValue())
+
+        dlg.Destroy()
+
+        dlg = wx.NumberEntryDialog(self._gui, _('Number of steps to add'), _('Add steps'), _('Add'), value = 1, min=0, max=1000)
+        if dlg.ShowModal() == wx.ID_OK:
+            nb_steps = int(dlg.GetValue())
+
+        dlg.Destroy()
+
+        self._fillgrid()
+
+        self._grid.AppendCols(nb_zones)
+        self._grid.AppendRows(nb_steps)
+
+        self._btn_check.SetBackgroundColour(wx.NullColour)
+
+    def on_minus(self, event):
+        """ Remove a zone or steps"""
+
+        nb_zones = 0
+        nb_steps = 0
+
+        dlg = wx.NumberEntryDialog(self._gui, _('Number of zones to remove'), _('Remove zones'), _('Remove'), value = 0, min=0, max=self._grid.GetNumberCols())
+        if dlg.ShowModal() == wx.ID_OK:
+            nb_zones = int(dlg.GetValue())
+
+        dlg.Destroy()
+
+        dlg = wx.NumberEntryDialog(self._gui, _('Number of steps to remove'), _('Remove steps'), _('Remove'), value=0, min=0, max=self._grid.GetNumberRows())
+        if dlg.ShowModal() == wx.ID_OK:
+            nb_steps = int(dlg.GetValue())
+
+        dlg.Destroy()
+
+        self._fillgrid()
+
+        self._grid.DeleteCols(nb_zones)
+        self._grid.DeleteRows(nb_steps)
+
+        self._btn_check.SetBackgroundColour(wx.NullColour)
+
+    def on_check(self, event):
+
+        if self.sim is None:
+            self._txt_info.SetValue("No simulation loaded")
+            return
+
+        ret = self.sim.check_infiltration()
+        self._txt_info.SetValue(ret)
+
+        if "Warning" in ret:
+            self._btn_check.SetBackgroundColour(wx.RED)
+        else:
+            self._btn_check.SetBackgroundColour(wx.GREEN)
+
+    def on_reload(self, event):
+
+        self._fillgrid()
+
+    def on_plot(self, event):
+
+        if self.sim is None:
+            self._txt_info.SetValue("No simulation loaded")
+            return
+
+        self.sim.infiltration.plot_plt()
+
+        self._btn_check.SetBackgroundColour(wx.NullColour)
+
+    def Show(self):
+
+        if self._gui is not None:
+            self._fillgrid()
+            self._gui.Show()
+        else:
+            logging.error("No GUI created")
+
 class Wolf2DModel(GenMapManager):
 
     mydir:str
+    sim:prev_sim2D
+
     # A path to the beacon file (not just the filename)
     filenamegen:str
-    files_others:dict
-    files_fine_array:dict
-    files_MB_array:dict
-    files_vectors:dict
-    mainparams:Wolf_Param
 
     # When updating these, pay attention to the fact they are heavliy intertwined.
     # - Boundary conditions coordinates must coincide with cell borders
 
-    myparam: prev_parameters_simul # Parameters of the simulation
-    mynap: np.ndarray # Active cells in the simulation (-1 == active; 0 == inactive)
-    napbin: WolfArray_Sim2D
-    mysuxy: prev_suxsuy # Coordinates of cells border acting as limits of simulation
-    xyfile: xy_file
-    myinfil: prev_infiltration # Infiltration
-
-    top: WolfArray_Sim2D # Sim2D will wire their masks onto self.napbin.array.mask
-    frot: WolfArray_Sim2D
-    hbin: WolfArray_Sim2D
-    qxbin: WolfArray_Sim2D
-    qybin: WolfArray_Sim2D
-    zbin: WolfArray_Sim2D
-    topinifine: WolfArray_Sim2D
-
-    hbinb: WolfArrayMB # Initial condition: water height (multibloc)
-    qxbinb: WolfArrayMB # Initial condition: discharge horizontal (multibloc)
-    qybinb: WolfArrayMB # Initial condition: discharge vertical (multibloc)
-    topini: WolfArrayMB # Bathymetry (multibloc)
-
-    # A WolfArrayMB with several Zones that makes its contour
-    # The MNAP is the multiblock NAP.  It's a big array covering the
-    # all the arrays of each block. It is used as a NAP but also as an
-    # index from one block's border to another block's border (so it's
-    # not filled with zero and ones only but also with block-indices)
-    # The MNAP array is a *result* array.
-    mymnap: WolfArrayMNAP
-    myblocfile: bloc_file
-
-    xyzones: Zones # A link to self.xyfile.myzones FIXME replace that with a property
-    curmask: np.ndarray # A link to self.napbin.array.mask
-    fines_array: list[WolfArray_Sim2D] # list containing: napbin, top, frot, inf, hbin, qxbin, qybin
-
     SPWstations:SPWMIGaugingStations
     DCENNstations:SPWDCENNGaugingStations
 
-    def _from_params(self, base_file, myparam: prev_parameters_simul):
-        """ This is a __init__ helper. This will be used in the constructor
-        to create a mono-block model from scratch (i.e. not reading from disk;
-        providing base matrices).
+    @property
+    def mymnap(self):
+        return self.sim.mymnap
+
+    @property
+    def xyzones(self):
+        return self.sim.xyfile.myzones
+
+    @property
+    def mysuxsuy(self):
+        return self.sim.sux_suy
+
+    @property
+    def blocfile(self):
+        return self.sim.bloc_description
 
-        @base_file Directroy where the model should reside.
-        @myparam The parameters to build the model with.
+    def __init__(self, *args, dir:str='',  **kw):
         """
-        assert isdir(Path(base_file).parent), \
-            f"When creating from parameters you must give a path containing the generic final name, prepended by a an existing directory (you gave a directory: {base_file} which doesn't exist)"
-
-        self.mydir = Path(base_file).parent.as_posix()
-        self.filenamegen = Path(base_file).name
-
-        if len(myparam.my_param_blocks) == 0:
-            myparam.my_param_blocks.append(prev_parameters_blocks())
-
-        self.myparam = myparam
-        self.myparam.parent = self
-
-        self.mynap= np.ones([self.myparam.nxfin, self.myparam.nyfin], order='F', dtype=np.int16)
-
-        self.mysuxy = prev_suxsuy(self)
-        self.xyfile = xy_file(self)
-        self.xyzones = self.xyfile.myzones
-        self.myinfil=prev_infiltration(self)
-        self.myblocfile=bloc_file(self)
-
-        general = zone(name='General',parent=self.myblocfile.my_vec_blocks)
-        # FIXME Line None should be removed but then it fails on some ellipsis later on.
-        external_border = bloc_external_border(is2D=True, name='external border', lines=None)  ##< vecteur du contour externe
-        general.add_vector(external_border)
-        self.myblocfile.my_vec_blocks.add_zone(general)
-
-        myextents = zone(name='Blocks extents',parent=self.myblocfile.my_vec_blocks)
-        self.myblocfile.my_vec_blocks.add_zone(myextents)
-        self.myblocfile.interior = True
-
-
-        header = self.get_header()
-
-        self.napbin = WolfArray_Sim2D(whichtype=WOLF_ARRAY_FULL_LOGICAL,
-                                      preload=True,
-                                      srcheader=header,
-                                      masksrc=None)
-
-        # FIXME NAPBIN is special, it is np.int16
-        # should it be handled by `whichtype ???`
-        # masksrc = None avoid snake eating his own tail
-        d = np.zeros_like(self.napbin.array.data, dtype=np.int16)
-        self.napbin.array = ma.MaskedArray(d, np.zeros_like(d,dtype=bool))
-
-        # Warning! Without hardening, a write to a masked array
-        # will *clear* the mask. But then one is facing another issue.
-        # If one wants to write into the array, it has to unmask it. But
-        # if the mask is shared, then that will unmask every arrays that
-        # share the mask.
-        self.napbin.array.harden_mask()
-        self.napbin.filename = self.filenamegen+'.napbin'
-        self.curmask = self.napbin.array.mask
-
-        def wire_wolf_array(filename,
-                            whichtype=WOLF_ARRAY_FULL_SINGLE,
-                            preload=False,
-                            srcheader=header,
-                            masksrc=self.curmask,
-                            nullvalue=-99999):
-
-            wa = WolfArray_Sim2D(
-                fname = filename,
-                whichtype=whichtype,
-                preload=preload,
-                masksrc=masksrc,
-                srcheader=srcheader,
-                nullvalue=nullvalue)
-
-            # Warning! This is the only way I have found working to
-            # share a mask between several arrays. So, to do that
-            # one must pass the mask in the constructor call.
-            # (replacing the mask with wa.array.mask == ... won't
-            # do !).
-            # Other issue: hardening the mask really means: "harden the
-            # mask applied to this array". So if one hardens the mask
-            # for one array, it will not protect the other arrays
-            # sharing the mask. So hardening must be done on all arrays.
-            wa.array = ma.MaskedArray(
-                np.ones((wa.nbx, wa.nby), order='F', dtype=np.float32)*float(wa.nullvalue),
-                mask = masksrc)
-            wa.array.harden_mask() # See note about sharing hardened masks
-            return wa
-
-        self.top = wire_wolf_array(self.filenamegen+'.top')
-        self.topinifine = wire_wolf_array(self.filenamegen+'.topinifine')
-        self.frot = wire_wolf_array(self.filenamegen+'.frot')
-        self.hbin = wire_wolf_array(self.filenamegen+'.hbin')
-        self.qxbin = wire_wolf_array(self.filenamegen+'.qxbin')
-        self.qybin = wire_wolf_array(self.filenamegen+'.qybin')
-        self.zbin = wire_wolf_array(self.filenamegen+'.zbin')
-
-        # FIXME Why is inf not a WolfArray_Sim2D like the others ?
-        self.inf = self.myinfil.myarray
-        self.myinfil.masksrc=self.curmask
-        self.myinfil.myarray.add_ops_sel()
-
-
-    # def _init_multibloc(self, mapviewer=None):
-    #     # FIXME MultiBlock come after processing by WolfCli
-    #     # This code is not yet tested
-
-    #     self.mymnap= WolfArrayMNAP()
-    #     self.mymnap.mapviewer=mapviewer
-    #     self.mymnap.add_ops_sel()
-
-    #     self.hbinb = WolfArrayMB(whichtype=WOLF_ARRAY_MB_SINGLE,preload=False,mapviewer=mapviewer)
-    #     self.hbinb.filename = self.filenamegen+'.hbinb'
-    #     # get_header_MB will pick its information from the mnap array.
-    #     self.hbinb.set_header(self.get_header_MB())
-
-    #     self.qxbinb = WolfArrayMB( whichtype=WOLF_ARRAY_MB_SINGLE,preload=False,mapviewer=mapviewer)
-    #     self.qxbinb.filename = self.filenamegen+'.qxbinb'
-    #     self.qxbinb.set_header(self.get_header_MB())
-
-    #     self.qybinb = WolfArrayMB(whichtype=WOLF_ARRAY_MB_SINGLE,preload=False,mapviewer=mapviewer)
-    #     self.qybinb.filename = self.filenamegen+'.qybinb'
-    #     self.qybinb.set_header(self.get_header_MB())
-
-    #     self.topini = WolfArrayMB(whichtype=WOLF_ARRAY_MB_SINGLE,preload=False,mapviewer=mapviewer)
-    #     self.topini.filename = self.filenamegen+'.topini'
-    #     self.topini.set_header(self.get_header_MB())
-
-
-    def __init__(self, *args, dir:str='', from_params: Union[None,prev_parameters_simul]=None,  **kw):
-        """ @dir: directory containing the simulation, the
-                  base file name (e.g. "simul") will be autodetected.
+        :param dir: directory containing the simulation, the base file name (e.g. "simul") will be autodetected.
                   If you create a model from scracth, then you must provide
                   the base file name as well (e.g. "d:/mywolfsim/sim")
 
@@ -533,12 +840,11 @@ class Wolf2DModel(GenMapManager):
 
         super(Wolf2DModel, self).__init__(*args, **kw)
 
-        self.SPWstations=SPWMIGaugingStations()
-        self.DCENNstations=SPWDCENNGaugingStations()
+        self._ref_block = None
 
-        if from_params is not None:
-            self._from_params(base_file=dir, myparam=from_params)
-            return
+        # Gauging stations - SPW
+        self.SPWstations    = SPWMIGaugingStations()
+        self.DCENNstations  = SPWDCENNGaugingStations()
 
         if dir != '':
             # Either a directory or a file "/_/_/_/dir/simul" for example.
@@ -547,6 +853,8 @@ class Wolf2DModel(GenMapManager):
 
         if dir=='':
             if self.wx_exists:
+                # Propose a dialog window to choose the directory
+
                 idir=wx.DirDialog(None,"Choose Directory")
                 if idir.ShowModal() == wx.ID_CANCEL:
                     self.setup_mapviewer(title='Blank 2D model',wolfparent=self)
@@ -562,7 +870,7 @@ class Wolf2DModel(GenMapManager):
             self.mydir=normpath(dir)
 
         if self.wx_exists:
-            wait_dlg, wait_cursor = BusyInfo(_('Opening 2D model')), wx.BusyCursor()
+
             self.setup_mapviewer(title='2D model : '+self.mydir, wolfparent=self)
 
         try:
@@ -583,6 +891,7 @@ class Wolf2DModel(GenMapManager):
 
                 self.filenamegen=""
                 second_choice = None
+
                 #recherche du nom générique --> sans extension
                 scandir_obj = scandir(self.mydir)
                 for curfile in scandir_obj:
@@ -607,340 +916,1437 @@ class Wolf2DModel(GenMapManager):
                         self.filenamegen = second_choice
                     else:
                         logging.info(_(f"The provided directory doesn't seem to be a Wolf simulation"))
+                        self.filenamegen = str(Path(self.mydir) /'newsim')
 
 
             logging.info(_(f'Generic file is : {self.filenamegen}'))
             logging.info(_('Creating GUI'))
 
-            self.files_others={'Generic file':[
-                ('','First parametric file - historical'),
-                ('.par','Parametric file - multiblocks')],
-                            'Characteristics':[
-                ('.fil','Infiltration hydrographs [m³/s]'),
-                ('.mnap','Resulting mesh [-]'),
-                ('.trl','Translation to real world [m]')
-                ]}
-
-            self.files_vectors={'Block file':[
-                ('.bloc','Blocks geometry')],
-                                'Borders':[
-                ('.sux','X borders'),
-                ('.suy','Y borders')],
-                                'Contour':[
-                ('.xy','General perimeter')
-            ]}
-
-            self.files_MB_array={'Initial Conditions':[
-                ('.topini','Bed elevation [m]',WOLF_ARRAY_MB_SINGLE),
-                ('.hbinb','Water depth [m]',WOLF_ARRAY_MB_SINGLE),
-                ('.qxbinb','Discharge X [m²/s]',WOLF_ARRAY_MB_SINGLE),
-                ('.qybinb','Discharge Y [m²/s]',WOLF_ARRAY_MB_SINGLE),
-                ('.frotini','Roughness coeff',WOLF_ARRAY_MB_SINGLE)
-            ]}
-
-            self.files_fine_array={'Characteristics':[
-                ('.napbin','Mask [-]',WOLF_ARRAY_FULL_LOGICAL),
-                ('.top','Bed Elevation [m]',WOLF_ARRAY_FULL_SINGLE),
-                ('.topini_fine','Bed Elevation - computed [m]',WOLF_ARRAY_FULL_SINGLE),
-                ('.frot','Roughness coefficient [law dependent]',WOLF_ARRAY_FULL_SINGLE),
-                ('.inf','Infiltration zone [-]', WOLF_ARRAY_FULL_INTEGER),
-                ('.hbin','Initial water depth [m]',WOLF_ARRAY_FULL_SINGLE),
-                ('.qxbin','Initial discharge along X [m^2/s]',WOLF_ARRAY_FULL_SINGLE),
-                ('.qybin','Initial discharge along Y [m^2/s]',WOLF_ARRAY_FULL_SINGLE)
-            ]}
+            # Initilisation d'une simulation 2D sur base des fichiers
+            self.sim = prev_sim2D(self.filenamegen)
 
+            # Liste des objets à ajouter au GUI
             self.fines_array=[]
 
-            logging.info(_('Importing global parameters'))
-            self.myparam=prev_parameters_simul(self)
-            self.myparam.read_file()
+            logging.info(_('Treating arrays'))
 
-            logging.info(_('Reading mask'))
-            self.mynap = self.read_fine_nap()
+            self._add_arrays_to_mapviewer()
+            self._add_vectors_to_mapviewer()
 
-            logging.info(_('Reading sux-suy'))
-            self.mysuxy = prev_suxsuy(self)
-            self.mysuxy.read_file()
+            logging.info(_('Zooming'))
+            self.mapviewer.findminmax(True)
+            self.mapviewer.Autoscale(False)
 
-            logging.info(_('Reading xy'))
-            self.xyfile = xy_file(self)
-            self.xyzones = self.xyfile.myzones
+            self.show_properties()
 
-            logging.info(_('Reading infiltration'))
-            self.myinfil=prev_infiltration(self)
-            try:
-                self.myinfil.read_file()
-                self.myinfil.read_array()
-            except Exception as ex:
-                logging.error(_("Error while reading infinltration file (.INF, .FIL) -- Check you files -- Continuing but without infiltration or Bad positioning"))
-                self.myinfil=prev_infiltration(self)
+            if self.wx_exists:
+                self.mapviewer.add_object(which='other',newobj=self.SPWstations,ToCheck=False,id='SPW-MI stations')
+                self.mapviewer.add_object(which='other',newobj=self.DCENNstations,ToCheck=False,id='SPW-DCENN stations')
 
-            logging.info(_('Reading blocks'))
-            self.myblocfile=bloc_file(self)
-            self.myblocfile.read_file()
+                logging.info(_('Adapting menu'))
+                self.mapviewer.menu_sim2D()
 
-            logging.info(_('Reading MNAP'))
-            self.mymnap= WolfArrayMNAP(self.filenamegen)
+            logging.info(_('Verifying files'))
+            self.sim.verify_files()
 
-            # self.cont_sauv:Zones
-            # self.filaire:Zones
+            logging.info(_('Model loaded !!'))
 
-            logging.info(_('Treating arrays'))
+        except Exception as ex:
+            logging.error(str(ex), exc_info=True)
 
-            #fine resolution
-            self.napbin = WolfArray_Sim2D(fname=self.filenamegen+'.napbin',
-                                          whichtype=WOLF_ARRAY_FULL_LOGICAL,
-                                          preload=True,
-                                          mapviewer=self.mapviewer,
-                                          srcheader=self.get_header())
-
-            self.curmask = self.napbin.array.mask
+    @property
+    def writing_mode(self):
+        return self.sim.parameters._writing_mode
 
+    @property
+    def writing_frequency(self):
+        return self.sim.parameters._writing_frequency
 
-            self.top = WolfArray_Sim2D(fname=self.filenamegen+'.top',
-                                       whichtype=WOLF_ARRAY_FULL_SINGLE,
-                                       preload=False,
-                                       mapviewer=self.mapviewer,
-                                       masksrc=self.curmask,
-                                       srcheader=self.get_header())
+    @property
+    def dx_fine(self):
+        return self.sim.parameters._fine_mesh_dx
 
+    @property
+    def dy_fine(self):
+        return self.sim.parameters._fine_mesh_dy
 
-            self.topinifine = WolfArray_Sim2D(fname=self.filenamegen+'.topini_fine',
-                                              whichtype=WOLF_ARRAY_FULL_SINGLE,
-                                              preload=False,
-                                              mapviewer=self.mapviewer,
-                                              masksrc=self.curmask,
-                                              srcheader=self.get_header())
+    def _dx_block(self, idx):
+        return self.sim.bloc_description.my_blocks[idx].dx
 
+    def _dy_block(self, idx):
+        return self.sim.bloc_description.my_blocks[idx].dy
 
-            self.frot = WolfArray_Sim2D(fname=self.filenamegen+'.frot',
-                                        whichtype=WOLF_ARRAY_FULL_SINGLE,
-                                        preload=False,
-                                        mapviewer=self.mapviewer,
-                                        masksrc=self.curmask,
-                                        srcheader=self.get_header())
+    @property
+    def scheme_rk(self):
+        return self.sim.parameters._scheme_rk
 
 
-            self.inf = self.myinfil.myarray
-            self.myinfil.myarray.mapviewer=self.mapviewer
-            self.myinfil.masksrc=self.curmask
-            self.myinfil.myarray.add_ops_sel()
+    def _add_arrays_to_mapviewer(self, force_reload=False):
+        """ Add arrays to the mapviewer """
 
-            self.hbin = WolfArray_Sim2D(fname=self.filenamegen+'.hbin',
-                                        whichtype=WOLF_ARRAY_FULL_SINGLE,
-                                        preload=False,
-                                        mapviewer=self.mapviewer,
-                                        masksrc=self.curmask,
-                                        srcheader=self.get_header())
+        # Mono-blocks
+        # ------------
 
+        fines = self.sim.files_fine_array['Characteristics']
 
-            self.qxbin = WolfArray_Sim2D(fname=self.filenamegen+'.qxbin',
-                                         whichtype=WOLF_ARRAY_FULL_SINGLE,
-                                         preload=False,
-                                         mapviewer=self.mapviewer,
-                                         masksrc=self.curmask,
-                                         srcheader=self.get_header())
+        existing_id = self.mapviewer.get_list_keys(drawing_type=draw_type.ARRAYS, checked_state=None)
 
+        for ext, name, wolftype in fines:
 
-            self.qybin = WolfArray_Sim2D(fname=self.filenamegen+'.qybin',
-                                         whichtype=WOLF_ARRAY_FULL_SINGLE,
-                                         preload=False,
-                                         mapviewer=self.mapviewer,
-                                         masksrc=self.curmask,
-                                         srcheader=self.get_header())
+            locarray = self.sim.get_wolf_array(ext)
 
+            if locarray is not None:
 
-            #altitude de surface libre --> si le fichier n'existe pas, la matrice est créée sur base de l'addition de la topo et de la hauteur
-            #  cf surcharge de la lecture dans WolfArray_Sim2D
-            self.zbin = WolfArray_Sim2D(fname=self.filenamegen+'.zbin',
-                                        whichtype=WOLF_ARRAY_FULL_SINGLE,
-                                        preload=False,
-                                        mapviewer=self.mapviewer,
-                                        masksrc=self.curmask,
-                                        srcheader=self.get_header())
+                if name.lower() not in existing_id:
 
+                    # locarray.nullvalue = 99999.
 
-            self.fines_array.append(self.napbin)
-            self.fines_array.append(self.top)
-            self.fines_array.append(self.frot)
-            self.fines_array.append(self.inf)
-            self.fines_array.append(self.hbin)
-            self.fines_array.append(self.qxbin)
-            self.fines_array.append(self.qybin)
+                    self.mapviewer.add_object(which='array',
+                                            ToCheck=False,
+                                            newobj=locarray,
+                                            id=name.lower())
+                elif force_reload:
+                    self.sim.force_reload(locarray)
 
-            #MB resolution
-            self.hbinb = WolfArrayMB(fname=self.filenamegen+'.hbinb',
-                                     whichtype=WOLF_ARRAY_MB_SINGLE,
-                                     preload=True,
-                                     mapviewer=self.mapviewer)
+                    if locarray.plotted:
+                        locarray.reset_plot()
 
-            self.hbinb.set_header(self.get_header_MB())
+        locarray = self.sim.zbin
+        name = _('Water level [m]')
+        if locarray is not None:
 
-            self.qxbinb = WolfArrayMB(fname=self.filenamegen+'.qxbinb',
-                                      whichtype=WOLF_ARRAY_MB_SINGLE,
-                                      preload=False,
-                                      mapviewer=self.mapviewer)
+            if name.lower() not in existing_id:
 
-            self.qxbinb.set_header(self.get_header_MB())
+                # locarray.nullvalue = 99999.
 
-            self.qybinb = WolfArrayMB(fname=self.filenamegen+'.qybinb',
-                                      whichtype=WOLF_ARRAY_MB_SINGLE,
-                                      preload=False,
-                                      mapviewer=self.mapviewer)
+                self.mapviewer.add_object(which='array',
+                                        ToCheck=False,
+                                        newobj=locarray,
+                                        id=name.lower())
 
-            self.qybinb.set_header(self.get_header_MB())
+            elif force_reload:
 
-            self.topini = WolfArrayMB(fname=self.filenamegen+'.topini',
-                                      whichtype=WOLF_ARRAY_MB_SINGLE,
-                                      preload=True,
-                                      mapviewer=self.mapviewer)
+                self.sim.force_reload(locarray)
 
-            self.topini.set_header(self.get_header_MB())
-            self.zbinb = self.topini + self.hbinb
-            self.zbinb.loaded=True
+                if locarray.checked:
+                    locarray.reset_plot()
 
+        # Multi-blocks
+        # ------------
 
+        # MNAP
+        multiblocks = self.sim.files_MB_array['Characteristics']
 
-            if self.wx_exists:
-                logging.info(_('Adding arrays to GUI'))
-
-                self.mymnap.mapviewer=self.mapviewer
-                self.mymnap.add_ops_sel()
-
-                self.mapviewer.add_object(which='array',newobj=self.napbin,id='mask - fine',ToCheck=True)
-                self.mapviewer.add_object(which='array',newobj=self.top,id='bed elevation - fine',ToCheck=False)
-                self.mapviewer.add_object(which='array',newobj=self.topinifine,id='bed elevation - computed',ToCheck=False)
-                self.mapviewer.add_object(which='array',newobj=self.frot,id='manning roughness - fine',ToCheck=False)
-                self.mapviewer.add_object(which='array',newobj=self.inf,id='infiltration',ToCheck=False)
-                self.mapviewer.add_object(which='array',newobj=self.mymnap,id='mnap',ToCheck=False)
-                self.mapviewer.add_object(which='array',newobj=self.hbin,id='H - IC',ToCheck=False)
-                self.mapviewer.add_object(which='array',newobj=self.qxbin,id='QX - IC',ToCheck=False)
-                self.mapviewer.add_object(which='array',newobj=self.qybin,id='QY - IC',ToCheck=False)
-                self.mapviewer.add_object(which='array',newobj=self.zbin,id='Water level - IC',ToCheck=False)
-                self.mapviewer.add_object(which='array',newobj=self.qxbinb,id='QX - IC - MB',ToCheck=False)
-                self.mapviewer.add_object(which='array',newobj=self.qybinb,id='QY - IC - MB',ToCheck=False)
-                self.mapviewer.add_object(which='array',newobj=self.topini,id='bed elevation - MB',ToCheck=False)
-                self.mapviewer.add_object(which='array',newobj=self.zbinb,id='water level - IC - MB',ToCheck=False)
-
-                #vectors
-                logging.info(_('Adding vectors to GUI'))
-                self.mapviewer.add_object(which='array',newobj=self.hbinb,id='H - IC - MB',ToCheck=False)
-                self.mapviewer.add_object(which='vector',newobj=self.xyzones,id='XY',ToCheck=True)
-                self.mapviewer.add_object(which='vector',newobj=self.mysuxy.myborders,id='Borders',ToCheck=False)
-                self.mapviewer.add_object(which='vector',newobj=self.myblocfile.my_vec_blocks,id='Blocks',ToCheck=False)
+        for ext, name, wolftype in multiblocks:
 
-                self.mapviewer.add_object(which='other',newobj=self.SPWstations,ToCheck=False,id='SPW-MI stations')
-                self.mapviewer.add_object(which='other',newobj=self.DCENNstations,ToCheck=False,id='SPW-DCENN stations')
+            locarray = self.sim.get_wolf_array(ext)
 
-                logging.info(_('Zooming'))
-                self.mapviewer.findminmax(True)
-                self.mapviewer.Autoscale(False)
+            if locarray is not None:
 
-                self.mysuxy.myborders.prep_listogl()
-                self.myblocfile.my_vec_blocks.prep_listogl()
+                if name.lower() not in existing_id:
 
-                #Fichiers de paramètres
-                # self.mainparams=Wolf_Param(self.allviews,filename=self.mydir+'\\Main_model.param',title="Model parameters",DestroyAtClosing=False)
-                # self.mainparams.Hide()
+                    # locarray.nullvalue = 99999.
 
-                logging.info(_('Adapting menu'))
-                self.mapviewer.menu_sim2D()
+                    self.mapviewer.add_object(which='array',
+                                              ToCheck=False,
+                                              newobj=locarray,
+                                              id=name.lower())
+                elif force_reload:
+                    self.sim.force_reload(locarray)
 
-                logging.info(_('Verifying files'))
+                    if locarray.checked:
+                        locarray.reset_plot()
 
-            self.verify_files()
 
-        except Exception as ex:
-            logging.error(str(ex), exc_info=True)
-        finally:
-            if self.wx_exists:
-                del wait_cursor
-                del wait_dlg
+        multiblocks = self.sim.files_MB_array['Initial Conditions']
 
+        for ext, name, wolftype in multiblocks:
 
-    def verify_files(self):
-        """
-        Vérification de la présence des en-têtes dans les différents fichiers
-        """
+            locarray = self.sim.get_wolf_array(ext)
 
-        fhead = self.get_header()
-        mbhead = self.get_header_MB()
+            if locarray is not None:
 
-        fine = self.files_fine_array['Characteristics']
-        for curextent,text,wolftype in fine:
-            fname = self.filenamegen + curextent
-            if exists(fname):
-                fname += '.txt'
-                fhead.write_txt_header(fname, wolftype, forceupdate=True)
+                if name.lower() not in existing_id:
 
-        mb = self.files_MB_array['Initial Conditions']
-        for curextent,text,wolftype in mb:
-            fname = self.filenamegen + curextent
-            if exists(fname):
-                fname += '.txt'
-                mbhead.write_txt_header(fname, wolftype, forceupdate=True)
+                    # locarray.nullvalue = 99999.
 
-        fname = self.filenamegen + '.lst'
-        if not exists(fname):
-            with open(fname,'w') as f:
-                f.write('0\n')
+                    self.mapviewer.add_object(which='array',
+                                              ToCheck=False,
+                                              newobj=locarray,
+                                              id=name.lower())
+                elif force_reload:
+                    self.sim.force_reload(locarray)
 
-    def mimic_mask(self,source:WolfArray_Sim2D):
+                    if locarray.checked:
+                        locarray.reset_plot()
 
-        logging.info(_('Copying mask to all arrays'))
-        self.curmask = source.array.mask
+        locarray = self.sim.zbinb
+        name = _('MB - Water level [m]')
+        if locarray is not None:
 
-        for curarray in self.fines_array:
-            curarray:WolfArray_Sim2D
-            if curarray is not source and curarray.loaded:
-                curarray.copy_mask_log(self.curmask)
+            if name.lower() not in existing_id:
 
-        logging.info(_('Updating mask array and .nap file'))
-        self.napbin.array.data[np.where(np.logical_not(self.curmask))] = -1
-        self.napbin.write_all()
+                # locarray.nullvalue = 99999.
 
-    def extend_bed_elevation(self):
-        """
-        Extension du modèle topographique
-        """
-        if not self.wx_exists:
-            raise Warning('Must be operated by GUI --> Nothing will be done !! or generalize the source code :-) ')
+                self.mapviewer.add_object(which='array',
+                                          ToCheck=False,
+                                          newobj=locarray,
+                                          id=name.lower())
+            elif force_reload:
 
-        dlg = wx.MessageDialog(self,_('Do you want to autocomplete elevation from external file?'),style=wx.YES_NO|wx.YES_DEFAULT)
-        ret=dlg.ShowModal()
-        dlg.Destroy()
+                self.sim.force_reload(locarray)
 
-        if ret == wx.ID_NO:
-            logging.info(_('Nothing to do !'))
-            return
+                if locarray.checked:
+                    locarray.reset_plot()
 
-        if not self.top.loaded:
-            self.top.check_plot()
-            self.top.copy_mask_log(self.curmask)
-            self.top.loaded=True
 
-        filterArray = "bin (*.bin)|*.bin|all (*.*)|*.*"
-        fdlg = wx.FileDialog(self, "Choose file", wildcard=filterArray, style=wx.FD_OPEN)
-        if fdlg.ShowModal() != wx.ID_OK:
-            fdlg.Destroy()
-            return
+    def _add_vectors_to_mapviewer(self):
+        """ Add vectors to the mapviewer """
 
-        filename = fdlg.GetPath()
-        fdlg.Destroy()
+        existing_id = self.mapviewer.get_list_keys(drawing_type=draw_type.ARRAYS, checked_state=False)
 
-        logging.info(_('Importing data from file'))
-        newtop = WolfArray(fname=filename,mapviewer=self.mapviewer)
+        # for key, values in self.sim.files_vectors.items():
+        values = self.sim.files_vectors['Block file']
 
-        logging.info(_('Finding nodes -- plotting disabled for speed'))
-        self.top.mngselection.hideselection = True
-        self.top.mngselection.condition_select(2,0., usemask=True)
+        for cur in values:
 
-        if len(self.top.mngselection.myselection)>0:
-            newtop.mngselection.myselection = self.top.mngselection.myselection
-            newtop.mngselection.hideselection = True
-            newtop.mngselection.update_nb_nodes_sections()
+            ext, name = cur
 
-            logging.info(_('Copying values'))
+            if Path(self.filenamegen+ext).exists():
+
+                if name not in existing_id:
+
+                    locZones = self.sim.get_Zones_from_extension(ext)
+
+                    if locZones is not None:
+
+                        assert isinstance(locZones, Zones), 'locZones is not a Zones object'
+
+                        self.mapviewer.add_object(which='vector',
+                                                ToCheck=False if ext != '.bloc' else True,
+                                                newobj=locZones,
+                                                id=name)
+
+        # We must set the parent of the "Zones" object to permit access to the mapviewer
+        # prep_listogl() is called to prepare the display of the zones and "mapviewer" is needed
+        if self.sim.bloc_description is not None:
+            self.sim.bloc_description.my_vec_blocks.parent = self
+            self.sim.bloc_description.my_vec_blocks.set_mapviewer()
+            self.sim.bloc_description.my_vec_blocks.prep_listogl()
+
+        # self.sim.sux_suy.myborders.parent = self
+        # self.sim.sux_suy.myborders.set_mapviewer()
+        # self.sim.sux_suy.myborders.prep_listogl()
+
+
+    def mimic_mask(self, source:WolfArray):
+        """ Copy the mask of the source array to all arrays in the model. """
+
+        self.som.mime_mask(source)
+
+    def show_properties(self):
+        """
+        Show the properties of the model
+        """
+
+        if self.wx_exists:
+
+            # Création d'un wx Frame pour les paramètres
+            self._prop_frame = wx.Frame(self,
+                                        title=_('Parameters') + self.filenamegen,
+                                        size=(650, 800),
+                                        style = wx.DEFAULT_FRAME_STYLE)
+
+            # add a panel
+            self._panel = wx.Panel(self._prop_frame)
+
+            # Set sizers
+            #
+            # The panel is decomposed in three parts:
+            # - List of toogle buttons + properties
+            # - Buttons to add/remove blocks/update structure
+            # - Information zone (multiline text)
+
+            self._sizer_gen = wx.BoxSizer(wx.HORIZONTAL)
+
+            self._sizer_run_results = wx.BoxSizer(wx.VERTICAL)
+
+            self._sizer_principal = wx.BoxSizer(wx.VERTICAL)
+
+            self._sizer_properties = wx.BoxSizer(wx.HORIZONTAL)
+
+            self._sizer_btnsblocks = wx.BoxSizer(wx.VERTICAL)
+
+            self._sizer_btnsactions = wx.BoxSizer(wx.HORIZONTAL)
+            self._sizer_btnsactions_left = wx.BoxSizer(wx.VERTICAL)
+            self._sizer_btnsactions_right = wx.BoxSizer(wx.VERTICAL)
+
+            self._sizer_btnsactions.Add(self._sizer_btnsactions_left, 1, wx.EXPAND)
+            self._sizer_btnsactions.Add(self._sizer_btnsactions_right, 1, wx.EXPAND)
+
+            self._sizer_btns_creation = wx.BoxSizer(wx.HORIZONTAL)
+
+            # Buttons
+            # ********
+
+            # Boundary conditions
+            # ---------------------
+
+            self._btn_bc = wx.Button(self._panel, label=_('BCs'))
+            self._btn_bc.SetToolTip(_('Set the boundary conditions'))
+            self._btn_bc.Bind(wx.EVT_BUTTON, self._set_bc)
+
+            self._sizer_run_results.Add(self._btn_bc, 1, wx.EXPAND)
+
+            # Infiltration
+            # --------------
+
+            self._btn_infiltration = wx.Button(self._panel, label=_('Infiltration'))
+            self._btn_infiltration.SetToolTip(_('Set the infiltration'))
+            self._btn_infiltration.Bind(wx.EVT_BUTTON, self._set_infiltration)
+
+            self._sizer_run_results.Add(self._btn_infiltration, 1, wx.EXPAND)
+
+            # Part arrays
+            # ------------
+
+            self._btn_part_arrays = wx.Button(self._panel, label=_('Part arrays'))
+            self._btn_part_arrays.SetToolTip(_('Set the part arrays'))
+            self._btn_part_arrays.Bind(wx.EVT_BUTTON, self._set_part_arrays)
+
+            self._sizer_run_results.Add(self._btn_part_arrays, 1, wx.EXPAND)
+
+            # Check
+            # -----
+
+            self._btn_checkerrors = wx.Button(self._panel, label=_('Check errors'))
+            self._btn_checkerrors.SetToolTip(_('Check the errors in the model'))
+            self._btn_checkerrors.Bind(wx.EVT_BUTTON, self._check_errors)
+
+            self._sizer_run_results.Add(self._btn_checkerrors, 1, wx.EXPAND)
+
+            # Write files
+            # ------------
+
+            self._btn_write = wx.Button(self._panel, label=_('Write files'))
+            self._btn_write.SetToolTip(_('Write the files to disk'))
+            self._btn_write.Bind(wx.EVT_BUTTON, self._write_files)
+
+            self._sizer_run_results.Add(self._btn_write, 1, wx.EXPAND)
+
+            # Run simulation
+            # ---------------
+
+            self._btn_run = wx.Button(self._panel, label=_('Run'))
+            self._btn_run.SetToolTip(_('Run the simulation - wolfcli.exe code'))
+            self._btn_run.Bind(wx.EVT_BUTTON, self._run)
+
+            self._sizer_run_results.Add(self._btn_run, 1, wx.EXPAND)
+
+            # Results
+            # --------
+
+            self._btn_results = wx.Button(self._panel, label=_('Results'))
+            self._btn_results.SetToolTip(_('Display the results of the simulation'))
+            self._btn_results.Bind(wx.EVT_BUTTON, self._results)
+
+            self._sizer_run_results.Add(self._btn_results, 1, wx.EXPAND)
+
+            # Result as IC
+            # ------------
+
+            self._btn_rs2ic = wx.Button(self._panel, label=_('Results as IC'))
+            self._btn_rs2ic.SetToolTip(_('Set one result as initial conditions'))
+            self._btn_rs2ic.Bind(wx.EVT_BUTTON, self._results2ic)
+
+            self._sizer_run_results.Add(self._btn_rs2ic, 1, wx.EXPAND)
+
+            # Copy 2 GPU
+            # -----------
+
+            self._btn_copy2gpu = wx.Button(self._panel, label=_('Copy 2 GPU'))
+            self._btn_copy2gpu.SetToolTip(_('Copy/Convert the simulation to the GPU framework'))
+            self._btn_copy2gpu.Bind(wx.EVT_BUTTON, self._copy2gpu)
+
+            self._sizer_run_results.Add(self._btn_copy2gpu, 1, wx.EXPAND)
+
+            # Wizard
+            # ------
+
+            self._btn_wizard = wx.Button(self._panel, label=_('Wizard'))
+            self._btn_wizard.SetToolTip(_('Launch the wizard to create a new model'))
+            self._btn_wizard.Bind(wx.EVT_BUTTON, self._wizard)
+
+            self._sizer_principal.Add(self._btn_wizard, 1, wx.EXPAND)
+
+            # Creation
+            # ---------
+
+            self._btn_fromvector = wx.Button(self._panel, label=_('Create From vector'))
+            self._btn_fromarray  = wx.Button(self._panel, label=_('Create From array'))
+            self._btn_fromfootprint = wx.Button(self._panel, label=_('Create From footprint'))
+
+            self._btn_fromvector.SetToolTip(_('Create a simulation from an existing polygon'))
+            self._btn_fromarray.SetToolTip(_('Create a simulation from the active array'))
+            self._btn_fromfootprint.SetToolTip(_('Create a simulation from the footprint (ox, oy, nbx, nby, dy, dy)'))
+
+            self.Bind(wx.EVT_BUTTON, self._create_from_vector, self._btn_fromvector)
+            self.Bind(wx.EVT_BUTTON, self._create_from_array, self._btn_fromarray)
+            self.Bind(wx.EVT_BUTTON, self._create_from_footprint, self._btn_fromfootprint)
+
+            self._sizer_btns_creation.Add(self._btn_fromvector, 1, wx.EXPAND)
+            self._sizer_btns_creation.Add(self._btn_fromarray, 1, wx.EXPAND)
+            self._sizer_btns_creation.Add(self._btn_fromfootprint, 1, wx.EXPAND)
+
+            self._sizer_principal.Add(self._sizer_btns_creation, 1, wx.EXPAND)
+
+
+            self._sizer_magn_res = wx.BoxSizer(wx.HORIZONTAL)
+
+            # Magnetic grid
+            # -------------
+
+            self._btn_magnetic_grid = wx.Button(self._panel, label=_('Magnetic grid'))
+            self._btn_magnetic_grid.SetToolTip(_('Set a magnetic grid for the model'))
+            self._btn_magnetic_grid.Bind(wx.EVT_BUTTON, self._set_magnetic_grid)
+
+            self._sizer_magn_res.Add(self._btn_magnetic_grid, 1, wx.EXPAND)
+
+            # Resolution
+            # -----------
+
+            self._btn_set_fine_res = wx.Button(self._panel, label=_('Set fine resolution'))
+            self._btn_set_fine_res.SetToolTip(_('Set the fine resolution of the model'))
+            self._btn_set_fine_res.Bind(wx.EVT_BUTTON, self._choose_fine_resolution)
+
+            self._sizer_magn_res.Add(self._btn_set_fine_res, 1, wx.EXPAND)
+
+
+            # Chesk Translation
+            # -----------------
+
+            self._chk_translation = wx.CheckBox(self._panel, label=_('Shift to (0., 0.)'), style=wx.ALIGN_CENTER)
+            self._chk_translation.SetToolTip(_('Shift the global coordinates to (0., 0.) and define shifting parameters'))
+            self._chk_translation.SetValue(True)
+
+            self._sizer_magn_res.Add(self._chk_translation, 1, wx.EXPAND)
+
+            self._sizer_principal.Add(self._sizer_magn_res, 1, wx.EXPAND)
+
+
+            self._sizer_add_mesh_create = wx.BoxSizer(wx.HORIZONTAL)
+
+            # Add blocks
+            # -----------
+
+            self._btn_add_blocks = wx.Button(self._panel, label=_('Add blocks'))
+            self._btn_add_blocks.SetToolTip(_('Add blocks to the model'))
+            self._btn_add_blocks.Bind(wx.EVT_BUTTON, self._add_blocks)
+
+            self._sizer_add_mesh_create.Add(self._btn_add_blocks, 1, wx.EXPAND)
+
+            # Mesher
+            # -------
+
+            self._btn_mesher = wx.Button(self._panel, label=_('Mesher'))
+            self._btn_mesher.SetToolTip(_('Mesh the model -- call to the Fortran code wolfcli.exe'))
+            self._btn_mesher.Bind(wx.EVT_BUTTON, self._mesher)
+
+            self._sizer_add_mesh_create.Add(self._btn_mesher, 1, wx.EXPAND)
+
+            # Create arrays
+            # -------------
+
+            self._btn_create_arrays = wx.Button(self._panel, label=_('Create arrays'))
+            self._btn_create_arrays.SetToolTip(_('Create the fine arrays for the model'))
+            self._btn_create_arrays.Bind(wx.EVT_BUTTON, self._create_arrays)
+
+            self._sizer_add_mesh_create.Add(self._btn_create_arrays, 1, wx.EXPAND)
+
+            self._sizer_principal.Add(self._sizer_add_mesh_create, 1, wx.EXPAND)
+
+            # Apply changes
+            # -------------
+            self._btn_apply = wx.Button(self._panel, label=_('Apply changes'))
+            self._btn_apply.SetToolTip(_('Apply the changes to the memory (not saved on disk)'))
+            self._btn_apply.Bind(wx.EVT_BUTTON, self._apply_changes)
+
+            # Update structure
+            # ----------------
+            self._btn_update_struct = wx.Button(self._panel, label=_('Update structure'))
+            self._btn_update_struct.SetToolTip(_('Update the structure of the model (add/remove blocks)'))
+            self._btn_update_struct.Bind(wx.EVT_BUTTON, self._update_structure)
+
+            # Add/remove blocks
+            # -----------------
+            self._btn_plus = wx.Button(self._panel, label='+')
+            self._btn_plus.SetToolTip(_('Add a block to the model'))
+            self._btn_plus.Bind(wx.EVT_BUTTON, self._add_block)
+
+            self._btn_minus = wx.Button(self._panel, label='-')
+            self._btn_minus.SetToolTip(_('Remove a block from the model'))
+            self._btn_minus.Bind(wx.EVT_BUTTON, self._remove_block)
+
+            # Checkboxes
+            # **********
+
+            # Show all parameters
+            # -------------------
+            self._check_show_all = wx.CheckBox(self._panel, label=_('All parameters'))
+            self._check_show_all.SetToolTip(_('Show all parameters even if they have the default value (default: show only modified parameters)'))
+            self._check_show_all.Bind(wx.EVT_CHECKBOX, self._all_parameters)
+
+            # Force update if multiple blocks are toggled
+            # -------------------------------------------
+            self._check_force = wx.CheckBox(self._panel, label=_('Force update'))
+            self._check_force.SetToolTip(_('Force the update of some parameters in all selected blocks (default: update only the first one - considered as the reference block)'))
+            self._check_force.Bind(wx.EVT_CHECKBOX, self._force_update)
+
+
+            # add widgets to sizers
+            # *********************
+
+            self._sizer_btnsactions_left.Add(self._btn_apply, 1, wx.EXPAND)
+            self._sizer_btnsactions_left.Add(self._btn_update_struct, 1, wx.EXPAND)
+
+            self._sizer_btnsactions_right.Add(self._btn_plus, 1, wx.EXPAND)
+            self._sizer_btnsactions_right.Add(self._btn_minus, 1, wx.EXPAND)
+            self._sizer_btnsactions_right.Add(self._check_show_all, 1, wx.EXPAND)
+            self._sizer_btnsactions_right.Add(self._check_force, 1, wx.EXPAND)
+
+            self._panel.SetSizer(self._sizer_gen)
+
+            self._sizer_principal.Add(self._sizer_properties, 4, wx.EXPAND)
+            self._sizer_principal.Add(self._sizer_btnsactions, 1, wx.EXPAND)
+
+            self._txt_info = wx.TextCtrl(self._panel, style=wx.TE_MULTILINE|wx.TE_READONLY)
+
+            self._sizer_principal.Add(self._txt_info, 2, wx.EXPAND)
+
+            self._sizer_gen.Add(self._sizer_principal, 5, wx.EXPAND)
+            self._sizer_gen.Add(self._sizer_run_results, 1, wx.EXPAND)
+
+
+            # Create the local list of parameters
+            # - for global parameters
+            # - for blocks
+            self._prop_gen = prev_parameters_simul()
+            self._prop_block = prev_parameters_blocks()
+
+            # Create the widget PropertyGridManager for the parameters
+            self._prop_gen._params.ensure_prop(wxparent = self._panel, show_in_active_if_default= False)
+            self._prop_block._params.ensure_prop(wxparent = self._panel, show_in_active_if_default= False)
+
+            # Create the buttons for the blocks and the global parameters
+            self._fill_buttons_genblocks()
+
+            self._sizer_properties.Add(self._sizer_btnsblocks, 1, wx.EXPAND)
+
+            # add the properties to the sizer
+            self._sizer_properties.Add(self._prop_gen._params.prop, 5, wx.EXPAND)
+            self._sizer_properties.Add(self._prop_block._params.prop, 5, wx.EXPAND)
+
+
+            # Hide the block properties
+            self._prop_gen._params.prop.Show()
+            self._prop_block._params.prop.Hide()
+
+
+            # The default view is the global parameters
+            self._show_glob_properties()
+
+            # Show the frame
+            self._prop_frame.Show()
+
+        else:
+            logging.info(_('No GUI available'))
+
+    def _set_bc(self, e:wx.EVT_BUTTON):
+        """ Set the boundary conditions """
+
+        from .mesh2d.bc_manager import BcManager, choose_bc_type
+
+        if self.mapviewer.active_bc is None:
+
+            newbc = BcManager(self,
+                            linked_array=self.sim.napbin,
+                            version = 1,
+                            DestroyAtClosing=True,
+                            Callback=self.mapviewer.pop_boundary_manager,
+                            mapviewer=self.mapviewer,
+                            wolfparent = self)
+
+
+            self.mapviewer.mybc.append(newbc)
+
+            self.mapviewer.active_bc = newbc
+
+            self.mapviewer.Refresh()
+
+        else:
+            self.mapviewer.active_bc.Show()
+
+    def _set_infiltration(self, e:wx.EVT_BUTTON):
+
+        inf_frame = Wolf2DInfiltration(self.sim)
+        inf_frame.Show()
+
+    def _set_part_arrays(self, e:wx.EVT_BUTTON):
+
+        part_frame = Wolf2DPartArrays(self.sim, self.mapviewer)
+        part_frame.Show()
+
+    def add_boundary_condition(self, i: int, j: int, bc_type:BCType_2D,  bc_value: float, border:Direction):
+        """ alias """
+
+        self.sim.add_boundary_condition(i, j, bc_type, bc_value, border)
+
+    def reset_boundary_conditions(self):
+        """ Reset the boundary conditions """
+
+        self.sim.parameters.reset_all_boundary_conditions()
+
+
+    def _check_errors(self, e:wx.EVT_BUTTON):
+        """ Check the errors in the model """
+
+        self._txt_info.Clear()
+
+        valid, ret = self.sim.parameters.check_all(1)
+
+        if valid:
+            self._btn_checkerrors.SetBackgroundColour(wx.GREEN)
+        else:
+            self._btn_checkerrors.SetBackgroundColour(wx.RED)
+
+        self._txt_info.AppendText(ret)
+
+
+    def _write_files(self, e:wx.EVT_BUTTON):
+        """ Write the files to disk """
+
+        if self.sim.parameters._mesher_only:
+
+            dlg = wx.MessageDialog(None, _('You have selected "Mesh only" - Do you want to uncheck it ?'), _('Warning'), wx.YES_NO)
+            ret = dlg.ShowModal()
+            dlg.Destroy()
+
+            if ret == wx.ID_YES:
+                self.sim.unset_mesh_only()
+
+        self.sim.save()
+
+
+    def _run(self, e:wx.EVT_BUTTON):
+        """ Run the simulation """
+
+        valid, ret = self.sim.parameters.check_all()
+
+        if not valid:
+            self._txt_info.AppendText(_('\n\nWe can not run the simulation\n\n'))
+            logging.error(_('We can not run the simulation -- Check the errors !'))
+
+            self._btn_checkerrors.SetBackgroundColour(wx.RED)
+
+            return
+
+        self._btn_checkerrors.SetBackgroundColour(wx.GREEN)
+
+        self.sim.run_wolfcli()
+
+    def _results(self, e:wx.EVT_BUTTON):
+        """ Display the results """
+
+        self.mapviewer.add_object(which='res2d',
+                                  filename=self.filenamegen,
+                                  id='Results')
+
+    def _results2ic(self, e:wx.EVT_BUTTON):
+        """ Choose one result as initial conditions """
+
+        from .wolfresults_2D import Wolfresults_2D
+        from datetime import timedelta
+
+        myres = Wolfresults_2D(self.filenamegen, plotted=False)
+
+        times, steps = myres.get_times_steps()
+
+        times_hms = [timedelta(seconds=int(curtime), milliseconds=int(curtime-int(curtime))*1000) for curtime in times]
+
+        choices = [_('Last one')] + ['{:3f} [s] - {} [h:m:s] - {} [step index]'.format(curtime, curtimehms, curstep) for curtime, curtimehms, curstep in zip(times, times_hms, steps)]
+
+        dlg = wx.SingleChoiceDialog(None, _('Choose the time step to set as initial conditions'), _('Results as IC'), choices)
+
+        ret = dlg.ShowModal()
+
+        if ret == wx.ID_CANCEL:
+            logging.info(_('Aborting - No time step selected'))
+            return
+
+        idx = dlg.GetSelection() - 1 # -1 because of the first choice is the last one and it is the convention used in the code
+
+        dlg.Destroy()
+
+        as_multiblocks = False # Default value
+
+        if self.sim.is_multiblock:
+
+            dlg = wx.SingleChoiceDialog(None, _('Choose the type of storage'), _('Results as IC'), [_('Multi-blocks'), _('Mono-block')])
+
+            ret = dlg.ShowModal()
+
+            if ret == wx.ID_CANCEL:
+                logging.info(_('Aborting - No storage type selected'))
+                return
+
+            storage = dlg.GetSelection()
+
+            as_multiblocks = storage == 0
+
+        myres.set_hqxqy_as_initial_conditions(idx, as_multiblocks)
+
+        if self.sim.parameters.has_turbulence:
+            myres.set_keps_as_initial_conditions(idx, as_multiblocks)
+
+        # update the arrays
+        self._add_arrays_to_mapviewer(force_reload=True)
+
+    def _copy2gpu(self, e:wx.EVT_BUTTON):
+        """ Click on the button to copy to the GPU """
+
+        if self.sim.nb_blocks > 1:
+            logging.error(_('Multiple blocks defined - Copy to GPU not possible'))
+            self._txt_info.AppendText(_('Multiple blocks defined - Copy to GPU not possible !\n'))
+            self._txt_info.AppendText(_('Please define only one block or convert you simulation manually.\n'))
+            return
+
+        if self.sim.parameters.has_turbulence:
+            logging.error(_('Turbulence is defined - Copy to GPU not yet possible'))
+            self._txt_info.AppendText(_('Turbulence is defined - Copy to GPU not yet possible !\n'))
+            self._txt_info.AppendText(_('Please remove the turbulence or help to implement the turbulence model in the GPU framework.\n'))
+            return
+
+        if self.sim.parameters.blocks[0]._friction_law != 0:
+            logging.error(_('Friction law is not Manning-Strickler or a more sophisticated surface evaluation - Copy to GPU not yet possible'))
+            self._txt_info.AppendText(_('Friction law is not Manning-Strickler or a more sophisticated surface evaluation - Copy to GPU not yet possible !\n'))
+            self._txt_info.AppendText(_('Please change the friction law or help to implement the friction law in the GPU framework.\n'))
+            return
+
+        if self.sim.inf.array.min() < 0:
+            logging.error(_('Negative infiltration zoning values - Copy to GPU not yet possible'))
+            self._txt_info.AppendText(_('Negative infiltration zoning values - Copy to GPU not yet possible !\n'))
+            self._txt_info.AppendText(_('Please change the infiltration mode or help to implement ther variable infiltration in the GPU framework.\n'))
+            return
+
+        dirout = wx.DirDialog(None, _('Choose the output directory for the GPU simulation'))
+
+        if dirout.ShowModal() == wx.ID_CANCEL:
+            return
+
+        gpudir = dirout.GetPath()
+
+        ret = self.sim.copy2gpu(gpudir)
+
+        self._txt_info.AppendText(ret)
+
+        if _('All files copied successfully') in ret:
+            logging.info(_('All files copied successfully'))
+
+
+    def _wizard(self, e:wx.EVT_BUTTON):
+        """ Launch the wizard """
+
+        from wx.adv import Wizard, WizardPageSimple
+
+        wizard_text = self.sim.get_wizard_text()
+
+        self.wizard = Wizard(None, -1, _('Wizard Multiblocks simulation'))
+
+        self.wizard.SetPageSize((400, 300))
+
+        self.wiz_pages:list[WizardPageSimple] = []
+
+        for curpage in wizard_text:
+            self.wiz_pages.append(WizardPageSimple(self.wizard))
+            self.wiz_pages[-1].SetBackgroundColour(wx.Colour(255, 255, 255))
+            self.wiz_pages[-1].SetSizer(wx.BoxSizer(wx.VERTICAL))
+
+        for idx, curpage in enumerate(wizard_text):
+            for curstep in curpage:
+                self.wiz_pages[idx].GetSizer().Add(wx.StaticText(self.wiz_pages[idx], -1, curstep), 0, wx.ALIGN_LEFT)
+
+        for i in range(len(self.wiz_pages)-1):
+            self.wiz_pages[i].Chain(self.wiz_pages[i+1])
+
+
+        ret = self.wizard.RunWizard(self.wiz_pages[0])
+
+        if ret:
+            logging.info(_('Wizard finished'))
+        else:
+            logging.warning(_('Wizard cancelled - Are you sure ?'))
+
+    def _mesher(self, e:wx.EVT_BUTTON):
+        """ Call the mesher """
+
+        if self.nb_blocks == 0:
+            logging.error(_('No block defined -- Please add a block to the model (see "+ button")'))
+            return
+
+        nb_vert = [len(self.sim.bloc_description.my_blocks[i].contour.myvertices) for i in range(self.nb_blocks)]
+        nb_vert.sort()
+
+        if nb_vert[0] ==0:
+            logging.error(_(' At least one block is not defined -- Please draw the polygons for each block'))
+            return
+
+        self.sim.translate_origin2zero = self._chk_translation.GetValue()
+        self.sim.mesh()
+
+        self._add_arrays_to_mapviewer()
+        self._add_vectors_to_mapviewer()
+
+    def _create_arrays(self, e:wx.EVT_BUTTON):
+        """ Create the fine arrays """
+
+        if self.nb_blocks == 0:
+            logging.error(_('No block defined -- Please add a block to the model and mesh'))
+            return
+
+        self.sim.create_fine_arrays(with_tubulence= self.sim.parameters.has_turbulence)
+        self.sim.create_sux_suy()
+
+        self._add_arrays_to_mapviewer()
+
+
+    def _add_blocks(self, e:wx.EVT_BUTTON):
+        """ Add blocks to the model """
+
+        dlg = wx.TextEntryDialog(None, _('How many blocks do you want to add ?'), _('Add blocks'), '1', wx.OK | wx.CANCEL | wx.CENTRE)
+
+        dlg.ShowModal()
+
+        if dlg.GetReturnCode() == wx.ID_CANCEL:
+            dlg.Destroy()
+            return
+
+        nb = int(dlg.GetValue())
+
+        dlg.Destroy()
+
+
+        for i in range(nb):
+
+            name = f'Block {self.nb_blocks+1}'
+            # Set the external border as the first block
+            newvec = self.sim.bloc_description.external_border
+            self.sim.add_block(newvec, self.dx_fine, self.dy_fine, name)
+
+
+        self._update_structure(0)
+
+        dlg = wx.MessageDialog(None, _('Block(s) added\n\nYou must define the polygons'), _('Information'), wx.OK)
+
+        pass
+
+    def _create_from_vector(self, e:wx.EVT_BUTTON):
+        """ Create a simulation from a vector """
+
+        if self.mapviewer.active_vector is None:
+            logging.error(_('No active vector defined - Please select or create a vector/polygon as external border'))
+            return
+
+        self.sim.set_external_border_vector(self.mapviewer.active_vector)
+
+    def _create_from_array(self, e:wx.EVT_BUTTON):
+        """ Create a simulation from an array """
+
+        if self.mapviewer.active_array is None:
+            logging.error(_('No active array defined - Please select or create an array as external border'))
+            return
+
+        self.sim.set_external_border_wolfarray(self.mapviewer.active_array)
+        self.sim.set_mesh_fine_size(self.mapviewer.active_array.dx, self.mapviewer.active_array.dy)
+
+        self._show_glob_properties()
+
+    def _create_from_footprint(self, e:wx.EVT_BUTTON):
+        """ Create a simulation from a footprint """
+
+        dlg = wx.TextEntryDialog(None, _('Footprint'), _('Footprint'), 'ox, oy, nbx, nby, dx, dy')
+
+        if dlg.ShowModal() == wx.ID_OK:
+            try:
+                ox, oy, nbx, nby, dx, dy = dlg.GetValue().split(',')
+
+                newhead = header_wolf()
+                newhead.nbx = int(nbx)
+                newhead.nby = int(nby)
+                newhead.dx = float(dx)
+                newhead.dy = float(dy)
+                newhead.origx = float(ox)
+                newhead.origy = float(oy)
+
+                self.sim.set_external_border_header(newhead)
+
+                self.sim.set_mesh_fine_size(float(dx), float(dy))
+                self._show_glob_properties()
+            except:
+                logging.error(_('Invalid footprint'))
+
+        dlg.Destroy()
+
+    def _set_magnetic_grid(self, e:wx.EVT_BUTTON):
+        """ Set the magnetic grid """
+
+        dlg = wx.TextEntryDialog(None, _('Magnetic grid'), _('Magnetic grid'), 'ox, oy, dx, dy')
+
+        if dlg.ShowModal() == wx.ID_OK:
+            try:
+                ox, oy, dx, dy = dlg.GetValue().split(',')
+                self.sim.set_magnetic_grid(float(dx), float(dy), float(ox), float(oy))
+                self._show_glob_properties()
+            except:
+                logging.error(_('Invalid magnetic grid'))
+
+        dlg.Destroy()
+
+    def _choose_fine_resolution(self, e:wx.EVT_BUTTON):
+        """ Choose the fine resolution """
+
+        dlg = wx.TextEntryDialog(None, _('Choose the fine resolution'), _('Fine resolution'), 'dx, dy')
+
+        if dlg.ShowModal() == wx.ID_OK:
+            try:
+                dx, dy = dlg.GetValue().split(',')
+                self.sim.set_mesh_fine_size(float(dx), float(dy))
+                self._show_glob_properties()
+            except:
+                logging.error(_('Invalid fine resolution'))
+
+        dlg.Destroy()
+
+        self._show_glob_properties()
+
+
+    def _add_block(self, e:wx.EVT_BUTTON):
+        """ Add a block to the model """
+
+        newvec = vector()
+        self.sim.add_block(newvec, self.dx_fine, self.dy_fine)
+
+        dlg = wx.MessageDialog(None, _('Block added\nDo not forget to :\n - draw the contour\n - set the spatial resolution if not the same that the fine one'), _('Information'), wx.OK)
+
+        dlg.ShowModal()
+        dlg.Destroy()
+
+        self._update_structure(0)
+
+        pass
+
+    def _remove_block(self, e:wx.EVT_BUTTON):
+        """ Remove a block from the model """
+
+        dlg = wx.MessageDialog(None, _('Are you sure you want to remove the block ?'), _('Warning'), wx.YES_NO)
+
+        if dlg.ShowModal() == wx.ID_YES:
+            dlg.Destroy()
+
+            select = wx.MultiChoiceDialog(None, _('Select the block to remove'), _('Remove block'), [f'Block {idx+1}' for idx in range(self.nb_blocks)])
+
+            if select.ShowModal() == wx.ID_OK:
+                selected = select.GetSelections()
+
+                for idx in selected:
+                    self.sim.remove_block(idx)
+
+                dlg = wx.MessageDialog(None, _('Block(s) removed'), _('Information'), wx.OK)
+
+                dlg.ShowModal()
+                dlg.Destroy()
+
+                self._update_structure(0)
+
+            select.Destroy()
+
+        else:
+            dlg.Destroy()
+
+
+    def _update_structure(self, e:wx.EVT_BUTTON):
+        """ Update the structure of the model """
+
+        self._fill_buttons_genblocks()
+        self._show_glob_properties()
+
+
+    def _all_parameters(self, e:wx.EVT_CHECKBOX):
+        """ Show all parameters """
+
+        show_all = self._check_show_all.GetValue()
+
+        if self._prop_block._params.show_in_active_if_default != show_all:
+            self._prop_block._params.show_in_active_if_default = show_all
+            self._prop_block._params.Populate(sorted_groups=True)
+
+        if self._prop_gen._params.show_in_active_if_default != show_all:
+            self._prop_gen._params.show_in_active_if_default = show_all
+            self._prop_gen._params.Populate(sorted_groups=True)
+
+    def _force_update(self, e:wx.EVT_CHECKBOX):
+        """ Force the update """
+        pass
+
+    def _update_layout(self):
+        """ Update the layout of the frame """
+
+        self._panel.Layout()
+        self._prop_frame.Layout()
+
+    def _fill_buttons_genblocks(self):
+        """
+        Fill the buttons for the blocks
+        """
+
+        self._sizer_btnsblocks.Clear(True)
+
+        self._btn_gen = wx.ToggleButton(self._panel, label=_('Global'))
+
+        self._btn_blocks = [wx.ToggleButton(self._panel, label=_('Blocks ')+str(idx)) for idx in range(1, self.nb_blocks+1)]
+
+        self._sizer_btnsblocks.Add(self._btn_gen, 1, wx.EXPAND)
+        for btn in self._btn_blocks:
+            self._sizer_btnsblocks.Add(btn, 1, wx.EXPAND)
+
+        self._btn_gen.Bind(wx.EVT_TOGGLEBUTTON, self.OnToggleGen)
+        for btn in self._btn_blocks:
+            btn.Bind(wx.EVT_TOGGLEBUTTON, self.OnToggleBlock)
+
+        # self._sizer_properties.Clear(True)
+
+        # self._sizer_properties.Add(self._sizer_btnsblocks, 1, wx.EXPAND)
+
+        # # add the properties to the sizer
+        # self._sizer_properties.Add(self._prop_gen._params.prop, 5, wx.EXPAND)
+        # self._sizer_properties.Add(self._prop_block._params.prop, 5, wx.EXPAND)
+
+        self._update_layout()
+
+    def _get_togglestates(self):
+        """ Get the toggle states of the buttons """
+
+        return self._btn_gen.GetValue(), [btn.GetValue() for btn in self._btn_blocks] # True if toggled, False otherwise
+
+
+    def _show_glob_properties(self):
+        """ Show the general properties """
+
+        self._btn_gen.SetValue(True)
+
+        self._prop_gen.copy(self.sim.parameters)
+
+        if self._prop_block._params.prop.IsShown():
+            self._prop_gen._params.prop.Show()
+            self._prop_block._params.prop.Hide()
+
+        self._append_magnetic_grid_to_prop()
+
+        self._txt_info.Clear()
+        self._txt_info.AppendText(_('Global parameters are shown'))
+
+        self._update_layout()
+
+    def _set_default_background(self):
+        """ Set the default background """
+
+        self._btn_gen.SetBackgroundColour(wx.NullColour)
+
+        for btn in self._btn_blocks:
+            btn.SetBackgroundColour(wx.NullColour)
+
+    def _set_color_background(self):
+        """ Set the color background """
+
+        self._set_default_background()
+
+        toggle_gen, toggle_blocks = self._get_togglestates()
+
+        if self._ref_block is None:
+            return
+
+        for btn, idx, toggled in zip(self._btn_blocks, range(self.nb_blocks), toggle_blocks):
+
+            if toggled and idx != self._ref_block:
+
+                color = wx.Colour(255, 0, 0) if self.sim.parameters.blocks[idx] != self.sim.parameters.blocks[self._ref_block] else wx.Colour(0, 255, 0)
+                btn.SetBackgroundColour(color)
+
+    def OnToggleGen(self, e:wx.EVT_TOGGLEBUTTON):
+        """
+        Toggle the global properties
+        """
+
+        toggle_gen, toggle_blocks = self._get_togglestates()
+
+        if toggle_gen:
+            # General is toggled --> untoggle all blocks
+            logging.info(_('General is toggled --> untoggling blocks'))
+            for btn in self._btn_blocks:
+                btn.SetValue(False)
+
+            self._show_glob_properties()
+
+        elif any(toggle_blocks):
+            # At least one block is toggled --> untoggle the general
+            pass
+        else:
+            # No block is toggled --> toggle the general
+            self._show_glob_properties()
+
+        self._set_color_background()
+
+    def OnToggleBlock(self, e:wx.EVT_TOGGLEBUTTON):
+        """
+        Toggle the properties of a block
+        """
+
+        toggle_gen, toggle_blocks = self._get_togglestates()
+
+        if toggle_gen:
+            logging.info(_('General is toggled --> untoggling it'))
+            self._btn_gen.SetValue(False)
+
+        if any(toggle_blocks):
+            # At least one block is toggled --> untoggle the general
+
+            nb = toggle_blocks.count(True)
+
+            if nb == 1:
+                # One block is toggled --> show its properties
+                idx = toggle_blocks.index(True)
+                logging.info(_(f'Block {idx} is toggled'))
+
+                self._prop_block.copy(self.sim.parameters.blocks[idx])
+
+                if self._prop_gen._params.prop.IsShown():
+                    self._prop_block._params.prop.Show()
+                    self._prop_gen._params.prop.Hide()
+
+                self._txt_info.Clear()
+                self._txt_info.AppendText(_(f'Block {idx+1} parameters are shown'))
+
+                self._ref_block = idx
+
+                self._append_geometry_block_to_prop(idx)
+
+            else:
+                # test is ref block is toggled
+                if not toggle_blocks[self._ref_block]:
+                    self._ref_block = toggle_blocks.index(True)
+                    logging.info(_('Changing reference block to ') + str(self._ref_block+1))
+                    self._prop_block.copy(self.sim.parameters.blocks[self._ref_block])
+
+
+                # multiple blocks are toggled
+                # --> Find the difference
+                # The first one is the "reference"
+                self._txt_info.Clear()
+                chain = _('Multiple blocks are toggled')
+                self._txt_info.AppendText(chain + '\n')
+                self._txt_info.AppendText('-'*len(chain) + '\n\n')
+
+                self._txt_info.AppendText(_('Differences between the blocks') + '\n')
+                self._txt_info.AppendText(_('  - Reference block : ')  + str(self._ref_block+1) + '\n')
+
+                idx_comp = [idx+1 for idx in range(self.nb_blocks) if idx != self._ref_block and toggle_blocks[idx]]
+                self._txt_info.AppendText(_('  - Other blocks : ') + str(idx_comp) + '\n\n')
+
+                others = [self.sim.parameters.blocks[idx] for idx in range(self.nb_blocks) if idx != self._ref_block and toggle_blocks[idx]]
+
+                self._txt_info.AppendText(self._prop_block.diff_print(others))
+
+                dx_dy = [(idx, self._dx_block(idx),self._dy_block(idx)) for idx in range(self.nb_blocks) if idx != self._ref_block and toggle_blocks[idx]]
+
+                dx_ref = self._dx_block(self._ref_block)
+                dy_ref = self._dy_block(self._ref_block)
+
+                self._txt_info.AppendText('\n')
+
+                for idx, dx, dy in dx_dy:
+                    if dx != dx_ref or dy != dy_ref:
+                        self._txt_info.AppendText(_(f'Block {idx+1} has different resolution)') + '\n')
+                        self._txt_info.AppendText(_(f'  - dx : {dx} (ref : {dx_ref})') + '\n')
+                        self._txt_info.AppendText(_(f'  - dy : {dy} (ref : {dy_ref})') + '\n\n')
+
+        else:
+            self._show_glob_properties()
+
+        self._set_color_background()
+
+        self._update_layout()
+
+    def _append_magnetic_grid_to_prop(self):
+        """ Append the magnetic grid to the properties """
+
+        self._prop_gen._params.add_param(MAGN_GROUP_NAME,
+                                         'Dx',
+                                            0.,
+                                            Type_Param.Float,
+                                            _('Spatial resolution of the magnetic grid along X-axis'),
+                                            whichdict='All'
+                                            )
+        self._prop_gen._params.add_param(MAGN_GROUP_NAME,
+                                            'Dy',
+                                            0.,
+                                            Type_Param.Float,
+                                            _('Spatial resolution of the magnetic grid along Y-axis'),
+                                            whichdict='All'
+                                            )
+
+        self._prop_gen._params.add_param(MAGN_GROUP_NAME,
+                                            'Ox',
+                                            -99999.,
+                                            Type_Param.Float,
+                                            _('Origin of the magnetic grid along X-axis'),
+                                            whichdict='All'
+                                            )
+
+        self._prop_gen._params.add_param(MAGN_GROUP_NAME,
+                                            'Oy',
+                                            -99999.,
+                                            Type_Param.Float,
+                                            _('Origin of the magnetic grid along Y-axis'),
+                                            whichdict='All'
+                                            )
+
+        if self.sim.magnetic_grid is None:
+            self.sim.set_magnetic_grid(1., 1., 0., 0.)
+
+        self._prop_gen._params[(MAGN_GROUP_NAME, 'Dx')] = self.sim.magnetic_grid.dx
+        self._prop_gen._params[(MAGN_GROUP_NAME, 'Dy')] = self.sim.magnetic_grid.dy
+
+        self._prop_gen._params[(MAGN_GROUP_NAME, 'Ox')] = self.sim.magnetic_grid.origx
+        self._prop_gen._params[(MAGN_GROUP_NAME, 'Oy')] = self.sim.magnetic_grid.origy
+
+        self._prop_gen._params.Populate(sorted_groups=True)
+
+    def _append_geometry_block_to_prop(self, idx:int):
+        """ Append the geometry of the block to the properties """
+
+        self._prop_block._params.add_param(GEOM_GROUP_NAME,
+                                            _('Dx'),
+                                            0.,
+                                            Type_Param.Float,
+                                            _('Spatial resolution of the block along X-axis'),
+                                            whichdict='All'
+                                            )
+        self._prop_block._params.add_param(GEOM_GROUP_NAME,
+                                            _('Dy'),
+                                            0.,
+                                            Type_Param.Float,
+                                            _('Spatial resolution of the block along Y-axis'),
+                                            whichdict='All'
+                                            )
+
+        self._prop_block._params.add_param(GEOM_GROUP_NAME,
+                                            _('X min (info)'),
+                                            -99999.,
+                                            Type_Param.Float,
+                                            _('Origin of the block along X-axis'),
+                                            whichdict='All'
+                                            )
+
+        self._prop_block._params.add_param(GEOM_GROUP_NAME,
+                                            _('Y min (info)'),
+                                            -99999.,
+                                            Type_Param.Float,
+                                            _('Origin of the block along X-axis'),
+                                            whichdict='All'
+                                            )
+
+        self._prop_block._params.add_param(GEOM_GROUP_NAME,
+                                            _('X max (info)'),
+                                            99999.,
+                                            Type_Param.Float,
+                                            _('End of the block along X-axis'),
+                                            whichdict='All'
+                                            )
+
+        self._prop_block._params.add_param(GEOM_GROUP_NAME,
+                                            _('Y max (info)'),
+                                            99999.,
+                                            Type_Param.Float,
+                                            _('End of the block along X-axis'),
+                                            whichdict='All'
+                                            )
+
+
+        self._prop_block._params.add_param(GEOM_GROUP_NAME,
+                                            _('Associated polygon (info)'),
+                                            '',
+                                            Type_Param.String,
+                                            _('Name of the polygon associated to the block'),
+                                            whichdict='All'
+                                            )
+
+        self._prop_block._params[(GEOM_GROUP_NAME, _('Dx'))] = self._dx_block(idx)
+        self._prop_block._params[(GEOM_GROUP_NAME, _('Dy'))] = self._dy_block(idx)
+        self._prop_block._params[(GEOM_GROUP_NAME, _('X min (info)'))]= self.sim.bloc_description[idx+1].xmin
+        self._prop_block._params[(GEOM_GROUP_NAME, _('Y min (info)'))]= self.sim.bloc_description[idx+1].ymin
+        self._prop_block._params[(GEOM_GROUP_NAME, _('X max (info)'))]= self.sim.bloc_description[idx+1].xmax
+        self._prop_block._params[(GEOM_GROUP_NAME, _('Y max (info)'))]= self.sim.bloc_description[idx+1].ymax
+        self._prop_block._params[(GEOM_GROUP_NAME, _('Associated polygon (info)'))]= self.sim.bloc_description[idx+1].contour.myname
+
+        self._prop_block._params.Populate(sorted_groups=True)
+
+    def _apply_changes(self, e:wx.EVT_BUTTON):
+        """
+        Apply the changes to the parameters
+        """
+
+        toggle_gen, toggle_blocks = self._get_togglestates()
+
+        if toggle_gen:
+            self._prop_gen.apply_changes_to_memory()
+
+            self.sim.parameters._set_debug_params(self._prop_gen._get_debug_params())
+            self.sim.parameters._set_general_params(self._prop_gen._get_general_params())
+
+            mag_dx = self._prop_gen._params[(MAGN_GROUP_NAME, 'Dx')]
+            mag_dy = self._prop_gen._params[(MAGN_GROUP_NAME, 'Dy')]
+            mag_ox = self._prop_gen._params[(MAGN_GROUP_NAME, 'Ox')]
+            mag_oy = self._prop_gen._params[(MAGN_GROUP_NAME, 'Oy')]
+
+            if mag_dx != self.sim.magnetic_grid.dx or mag_dy != self.sim.magnetic_grid.dy or mag_ox != self.sim.magnetic_grid.origx or mag_oy != self.sim.magnetic_grid.origy:
+
+                dlg = wx.MessageDialog(None, _('Do you want to update the magnetic grid?'), _('Update magnetic grid'), wx.YES_NO)
+
+                if dlg.ShowModal() == wx.ID_YES:
+
+                    self.sim.set_magnetic_grid(mag_dx, mag_dy, mag_ox, mag_oy)
+
+                dlg.Destroy()
+
+
+        elif any(toggle_blocks):
+
+            nb = toggle_blocks.count(True)
+
+            if nb == 1:
+
+                idx = self._ref_block
+
+                dx = self._prop_gen._params[(GEOM_GROUP_NAME, _('Dx'))]
+                dy = self._prop_gen._params[(GEOM_GROUP_NAME, _('Dy'))]
+
+                self.sim.bloc_description[idx+1].set_dx_dy(dx, dy)
+
+                self._prop_block.apply_changes_to_memory()
+
+                self.sim.parameters.blocks[idx]._set_debug_params(self._prop_block._get_debug_params())
+                self.sim.parameters.blocks[idx]._set_general_params(self._prop_block._get_general_params())
+
+            else:
+
+                dx = self._prop_gen._params[(GEOM_GROUP_NAME, _('Dx'))]
+                dy = self._prop_gen._params[(GEOM_GROUP_NAME, _('Dy'))]
+
+                self._prop_block.apply_changes_to_memory()
+
+                force = self._check_force.GetValue()
+
+                if not force:
+                    logging.info(_('No force update - Apply to the reference block only'))
+
+                    idx = self._ref_block
+                    self.sim.parameters.blocks[idx]._set_debug_params(self._prop_block._get_debug_params())
+                    self.sim.parameters.blocks[idx]._set_general_params(self._prop_block._get_general_params())
+
+                    self.sim.bloc_description[idx+1].set_dx_dy(dx, dy)
+
+                else:
+                    groups = self._prop_block.gen_groups + self._prop_block.debug_groups
+                    names = self._prop_block.gen_names + self._prop_block.debug_names
+
+                    choices = ['{} - {}'.format(GEOM_GROUP_NAME, _('Dx')), '{} - {}'.format(GEOM_GROUP_NAME, _('Dy'))] + [f'{group} - {name}' for group, name in zip(groups, names) if NOT_USED not in group]
+
+                    dlg = wx.MultiChoiceDialog(self,
+                                               _('Which parameters should be updated in all blocks?'),
+                                               _('Parameters'),
+                                                choices = choices,
+                                                style = wx.CHOICEDLG_STYLE | wx.OK | wx.CANCEL)
+
+                    if dlg.ShowModal() == wx.ID_OK:
+                        selections = dlg.GetSelections()
+                        for sel in selections:
+                            group, name = choices[sel].split(' - ')
+
+                            if group == GEOM_GROUP_NAME:
+                                if name == _('Dx'):
+                                    for idx in range(self.nb_blocks):
+                                        if toggle_blocks[idx]:
+                                            self.sim.bloc_description.my_blocks[idx+1].dx = dx
+                                elif name == _('Dy'):
+                                    for idx in range(self.nb_blocks):
+                                        if toggle_blocks[idx]:
+                                            self.sim.bloc_description.my_blocks[idx+1].dy = dy
+                            else:
+
+                                for idx in range(self.nb_blocks):
+                                    if toggle_blocks[idx]:
+                                        # idx+1 because the blocks are 1-indexed in the __getitem__ method
+                                        self.sim[idx+1].set_parameter(group, name, self._prop_block._params[(group, name)])
+                    dlg.Destroy()
+
+            self._prop_block._params.Populate(sorted_groups=True)
+
+
+        self._txt_info.Clear()
+        self._txt_info.AppendText(_('Changes applied'))
+
+
+    def extend_bed_elevation(self):
+        """
+        Extension du modèle topographique
+        """
+        if not self.wx_exists:
+            raise Warning('Must be operated by GUI --> Nothing will be done !! or generalize the source code :-) ')
+
+        dlg = wx.MessageDialog(self,_('Do you want to autocomplete elevation from external file?'),style=wx.YES_NO|wx.YES_DEFAULT)
+        ret=dlg.ShowModal()
+        dlg.Destroy()
+
+        if ret == wx.ID_NO:
+            logging.info(_('Nothing to do !'))
+            return
+
+        if not self.top.loaded:
+            self.top.check_plot()
+            self.top.copy_mask_log(self.curmask)
+            self.top.loaded=True
+
+        filterArray = "bin (*.bin)|*.bin|all (*.*)|*.*"
+        fdlg = wx.FileDialog(self, "Choose file", wildcard=filterArray, style=wx.FD_OPEN)
+        if fdlg.ShowModal() != wx.ID_OK:
+            fdlg.Destroy()
+            return
+
+        filename = fdlg.GetPath()
+        fdlg.Destroy()
+
+        logging.info(_('Importing data from file'))
+        newtop = WolfArray(fname=filename,mapviewer=self.mapviewer)
+
+        logging.info(_('Finding nodes -- plotting disabled for speed'))
+        self.top.mngselection.hideselection = True
+        self.top.mngselection.condition_select(2,0., usemask=True)
+
+        if len(self.top.mngselection.myselection)>0:
+            newtop.mngselection.myselection = self.top.mngselection.myselection
+            newtop.mngselection.hideselection = True
+            newtop.mngselection.update_nb_nodes_selection()
+
+            logging.info(_('Copying values'))
             z = newtop.mngselection.get_values_sel()
             logging.info(_('Pasting values'))
             self.top.set_values_sel(self.top.mngselection.myselection, z, False)
@@ -1091,14 +2497,18 @@ class Wolf2DModel(GenMapManager):
             curarray.copy_mask_log(self.curmask)
             curarray.mngselection.myselection=[]
             curarray.mngselection.hideselection = False
-            curarray.mngselection.update_nb_nodes_sections()
+            curarray.mngselection.update_nb_nodes_selection()
             curarray.reset_plot()
 
         logging.info('')
         logging.info(_('Do not forget to save your changes to files !'))
         logging.info('')
 
-    def set_type_ic(self,which=2,dialog=True):
+
+
+
+    def set_type_ic(self, which:Literal[1,2,3]=2, dialog:bool=True):
+        """ Définition du type de conditions initiales """
 
         if (not self.wx_exists) and dialog:
             raise Warning('Must be operated by GUI --> Nothing will be done !! or generalize the source code :-) ')
@@ -1116,130 +2526,37 @@ class Wolf2DModel(GenMapManager):
         if which<1 or which>3:
             return
 
-        self.myparam.ntyperead = which
-        self.myparam.write_file()
+        self.sim.parameters._initial_cond_reading_mode = which
+        self.sim.parameters.write_file()
 
-    def replace_external_contour(self,newvec:vector,interior):
+
+    def replace_external_contour(self, newvec:vector, interior:bool):
+        """ Remplacement du contour externe """
 
         logging.info(_('Copying extrenal contour'))
 
         logging.info(_('   ... in .bloc'))
         ext_zone:zone
-        ext_zone = self.myblocfile.my_vec_blocks.myzones[0]
+        ext_zone = self.sim.bloc_description.my_vec_blocks.myzones[0]
         ext_zone.myvectors[0] = newvec
 
         logging.info(_('   ... in xy --> Fortran will update this file after internal meshing process'))
         self.xyzones.myzones[0].myvectors[0] = newvec
 
-        self.myblocfile.my_vec_blocks.reset_listogl()
-        self.myblocfile.my_vec_blocks.prep_listogl()
-
-        logging.info(_('Updating .bloc file'))
-        self.myblocfile.interior=interior
-        self.myblocfile.my_vec_blocks.find_minmax(True)
-        self.myblocfile.update_nbmax()
-        self.myblocfile.write_file()
-
-    def write_bloc_file(self):
+        self.sim.bloc_description.my_vec_blocks.reset_listogl()
+        self.sim.bloc_description.my_vec_blocks.prep_listogl()
 
         logging.info(_('Updating .bloc file'))
-        self.myblocfile.my_vec_blocks.find_minmax(True)
-        self.myblocfile.write_file()
-
-    def get_header_MB(self, abs=False):
-        """Renvoi d'un header avec les infos multi-blocs"""
-        myheader:header_wolf
-        myheader = self.mymnap.get_header(abs=abs)
-        for curblock in self.mymnap.myblocks.values():
-            myheader.head_blocks[getkeyblock(curblock.blockindex)] = curblock.get_header(abs=abs)
-        return  myheader
-
-    def get_header(self, abs=False):
-        """
-        Renvoi d'un header de matrice "fine" non MB
-
-        @param abs: If True, the header will be absolute, if False, it will be relative
-        @type abs: bool
-
-        @return: header_wolf
-        """
-
-        curhead = header_wolf()
-
-        curhead.nbx = self.myparam.nxfin
-        curhead.nby = self.myparam.nyfin
-
-        curhead.dx = self.myparam.dxfin
-        curhead.dy = self.myparam.dyfin
-
-        if abs:
-            curhead.origx = self.myparam.xminfin + self.myparam.translx
-            curhead.origy = self.myparam.yminfin + self.myparam.transly
-
-            curhead.translx = 0.
-            curhead.transly = 0.
-
-        else:
-
-            curhead.origx = self.myparam.xminfin
-            curhead.origy = self.myparam.yminfin
-
-            curhead.translx = self.myparam.translx
-            curhead.transly = self.myparam.transly
-
-        return curhead
-
-    def read_fine_array(self, which:str=''):
-        """
-        Lecture d'une matrice fine
-
-        @param which: suffixe du fichier
-        @type which: str
-        """
+        self.sim.bloc_description.interior=interior
+        self.sim.bloc_description.my_vec_blocks.find_minmax(True)
+        self.sim.bloc_description.write_file()
 
-        if Path(self.filenamegen + which).exists():
-            myarray = WolfArray(fname = self.filenamegen + which)
-
-        else:
-            logging.error(f"File {self.filenamegen + which} does not exist")
-            myarray = None
-
-        # myarray.set_header(self.get_header())
-        # myarray.filename = self.filenamegen+which
-        # myarray.read_data()
-
-        return myarray
-
-    def read_MB_array(self, which:str=''):
-        """
-        Lecture d'une matrice MB
-
-        @param which: suffixe du fichier
-        @type which: str
-        """
-
-        myarray =WolfArrayMB()
-        myarray.set_header(self.get_header_MB())
-        myarray.filename = self.filenamegen+which
-        myarray.read_data()
-
-        return myarray
-
-    def read_fine_nap(self) -> np.ndarray:
-        """Lecture de la matrice nap sur le maillage fin"""
-        nbx=self.myparam.nxfin
-        nby=self.myparam.nyfin
-
-        with open(self.filenamegen +'.napbin', 'rb') as f:
-            mynap = np.frombuffer(f.read(nbx*nby*2), dtype=np.int16).copy()
-            mynap=np.abs(mynap)
-
-        return mynap.reshape([nbx,nby], order='F')
 
     def transfer_ic(self,vector):
         """
         Transfert de conditions initiales
         """
+
         if not self.wx_exists:
             raise Warning('Must be operated by GUI --> Nothing will be done !! or generalize the source code :-) ')
 
@@ -1285,158 +2602,104 @@ class Wolf2DModel(GenMapManager):
 
         pass
 
-    @property
-    def is_multiblock(self):
-        return self.myblocfile.nb_blocks>1
-
-    @property
-    def nb_blocks(self):
-        return self.myblocfile.nb_blocks
-
-    def help_files(self):
-
-        ret=  _('Text files\n')
-        ret+=  ('----------\n')
 
-        for key, val in self.files_others['Characteristics']:
-            ret += f"{val} : {key}\n"
 
-        ret +='\n\n'
+    # **********
+    # DEPRECATED
+    # **********
 
-        ret += _('Fine array - monoblock\n')
-        ret +=  ('----------------------\n')
+    @property
+    def is_multiblock(self):
+        """ Deprecated, use the property from the infiltration object """
 
-        for key, val, dtype in self.files_fine_array['Characteristics']:
+        return self.sim.is_multiblock
 
-            if dtype == WOLF_ARRAY_FULL_LOGICAL:
-                ret += f"{val} : {key} [int16]\n"
-            elif dtype == WOLF_ARRAY_FULL_INTEGER:
-                ret += f"{val} : {key} [int32]\n"
-            elif dtype == WOLF_ARRAY_FULL_SINGLE:
-                ret += f"{val} : {key} [float32]\n"
-            else:
-                ret += f"{val} : {key} error - check code\n"
+    @property
+    def nb_blocks(self):
+        """ Deprecated, use the property from the infiltration object """
 
-        ret +='\n\n'
+        return self.sim.nb_blocks
 
-        ret += _('Multiblock arrays\n')
-        ret +=  ('-----------------\n')
+    def help_files(self):
+        """
+        Aide sur les fichiers
 
-        for key, val, dtype in self.files_MB_array['Initial Conditions']:
+        Deprecated, use the method from the infiltration object
+        """
 
-            if dtype == WOLF_ARRAY_MB_INTEGER:
-                ret += f"{val} : {key} [int32]\n"
-            elif dtype == WOLF_ARRAY_MB_SINGLE:
-                ret += f"{val} : {key} [float32]\n"
-            else:
-                ret += f"{val} : {key} error - check code\n"
+        return self.sim.help_files()
 
-        return ret
 
     def check_infiltration(self):
+        """ Vérification des zones d'infiltration
 
-        ret =  _('inside .inf binary file') + '\n'
-        ret +=  ('-----------------------') + '\n'
-
-        inf = self.read_fine_array('.inf')
-
-        maxinf = inf.array.data.max()
-        ret += _('Maximum infiltration zone : ') + str(maxinf) + '\n'
-        for i in range(1,maxinf+1):
-
-            nb = np.sum(inf.array.data == i)
-            if nb>0:
-                indices = np.where(inf.array.data == i)
-                ret += f"Zone {i} : {nb} cells -- Indices (i,j) of the zone's first cell ({indices[0][0]+1} ; {indices[1][0]+1}) (1-based)\n"
-            else:
-                ret += f"Zone {i} : 0 cells\n"
-
-        ret += '\n'
-
-        ret += _('inside .fil text file') + '\n'
-        ret +=  ('----------------------') + '\n'
-
-        ret += f"Zones {self.myinfil.nb_zones}" + '\n'
-        ret += f"Time steps {self.myinfil.nb_steps}" + '\n'
-
-        if maxinf != self.myinfil.nb_zones:
-            ret += _('Warning : number of zones in .inf and .fil files are different') + '\n'
+        Deprecated, use the method from the infiltration object
+        """
 
-        return ret
+        return self.sim.check_infiltration()
 
 
     def copy2gpu(self, dirout:str=''):
         """
         Copie des matrices pour le code GPU
-        """
 
-        def to_absolute(array:WolfArray):
-            array.origx += array.translx
-            array.origy += array.transly
-            array.translx = 0.
-            array.transly = 0.
+        Deprecated, use the method from the simulation object
+        """
 
-        ret = ''
+        return self.sim.copy2gpu(dirout)
 
-        dirout = Path(dirout)
-        makedirs(dirout, exist_ok=True)
+    def write_bloc_file(self):
+        """ Mise à jour du fichier de blocs """
 
-        inf = self.read_fine_array('.inf')
-        to_absolute(inf)
-        inf.write_all(dirout / 'infiltration_zones.npy')
-        del(inf)
+        logging.info(_('Updating .bloc file'))
+        self.sim.bloc_description.modify_extent()
+        self.sim.bloc_description.write_file()
 
-        ret += '.inf --> infiltration_zones.npy [np.int32]\n'
 
-        frot = self.read_fine_array('.frot')
-        to_absolute(frot)
-        frot.write_all(dirout / 'manning.npy')
-        del(frot)
+    def get_header_MB(self, abs=False):
+        """Renvoi d'un header avec les infos multi-blocs
 
-        ret += '.frot --> manning.npy [np.float32]\n'
+        :param abs: If True, the header will be absolute, if False, it will be relative
+        :type abs: bool
 
-        hbin = self.read_fine_array('.hbin')
-        to_absolute(hbin)
-        hbin.write_all(dirout / 'h.npy')
-        del(hbin)
+        :return: header_wolf
+        """
 
-        ret += '.hbin --> h.npy [np.float32]\n'
+        return self.sim.get_header_MB(abs)
 
-        qxbin = self.read_fine_array('.qxbin')
-        to_absolute(qxbin)
-        qxbin.write_all(dirout / 'qx.npy')
-        del(qxbin)
+    def get_header(self, abs=False):
+        """
+        Renvoi d'un header de matrice "fine" non MB
 
-        ret += '.qxbin --> qx.npy [np.float32]\n'
+        :param abs: If True, the header will be absolute, if False, it will be relative
+        :type abs: bool
 
-        qybin = self.read_fine_array('.qybin')
-        to_absolute(qybin)
-        qybin.write_all(dirout / 'qy.npy')
-        del(qybin)
+        :return: header_wolf
+        """
 
-        ret += '.qybin --> qy.npy [np.float32]\n'
+        self.sim.get_header(abs)
 
-        nap = self.read_fine_array('.napbin')
-        napgpu = np.zeros_like(nap.array.data, dtype = np.uint8)
-        napgpu[np.where(nap.array.data != 0)] = 1
-        np.save(dirout / 'nap.npy', napgpu)
+    def read_fine_array(self, which:str=''):
+        """
+        Lecture d'une matrice fine
 
-        ret += '.napbin --> nap.npy [np.uint8]\n'
+        :param which: suffixe du fichier
+        :type which: str
+        """
 
-        top = self.read_fine_array('.top')
-        to_absolute(top)
-        top.array.data[np.where(napgpu != 1)] = 99999.
-        top.nullvalue = 99999.
-        top.write_all(dirout / 'bathymetry.npy')
+        return self.sim.read_fine_array(which)
 
-        ret += '.top --> bathymetry.npy [np.float32]\n'
-        ret += _('Force a value 99999. outside nap')
+    def read_MB_array(self, which:str=''):
+        """
+        Lecture d'une matrice MB
 
-        nb = np.sum(top.array.data != 99999.)
-        assert  nb == np.sum(napgpu == 1), 'Error in couting active cells'
+        :param which: suffixe du fichier
+        :type which: str
+        """
 
-        ret += f'\n{nb} active cells in bathymetry.npy'
+        return self.sim.read_MB_array(which)
 
-        del(top)
+    def read_fine_nap(self) -> np.ndarray:
+        """Lecture de la matrice nap sur le maillage fin"""
 
-        return ret
+        return self.sim.read_fine_array('.napbin')