wolfhece 2.1.99__py3-none-any.whl → 2.1.101__py3-none-any.whl

wolfhece/PyGui.py

@@ -68,6 +68,9 @@ try:
     from .picc import Picc_data, Cadaster_data
     from .wolf_zi_db import ZI_Databse_Elt, PlansTerrier
     from .CpGrid import CpGrid
+    from .mesh2d.gpu_2d import Sim_2D_GPU
+    from .mesh2d.wolf2dprev import prev_sim2D
+    from .mesh2d.cst_2D_boundary_conditions import BCType_2D, BCType_2D_OO, BCType_2D_GPU, Direction
 except ImportError as e:
     print(f"Import Error: {e} - RatingCurve, mesh2d, Results2DGPU, PyGuiHydrology, RatingCurve, hydrology, PyParams, picc, wolf_zi_db, CpGrid")
     print("Please install the required modules using 'pip install -r requirements.txt'")
@@ -208,44 +211,44 @@ class MapManager(GenMapManager):
 
         self.mapviewer.menu_walous()
 
-class GPU2DModel(GenMapManager):
+# class GPU2DModel(GenMapManager):
 
-    mydir:str
-    files_results_array:dict
-    mybed:WolfArray
+#     mydir:str
+#     files_results_array:dict
+#     mybed:WolfArray
 
-    def __init__(self,dir:str='', *args, **kw):
-        super(GPU2DModel, self).__init__(*args, **kw)
+#     def __init__(self,dir:str='', *args, **kw):
+#         super(GPU2DModel, self).__init__(*args, **kw)
 
-        self.setup_mapviewer(title='Wolf GPU 2D')
+#         self.setup_mapviewer(title='Wolf GPU 2D')
 
-        if dir=='':
-            idir=wx.DirDialog(None,"Choose Directory")
-            if idir.ShowModal() == wx.ID_CANCEL:
-                return
-            self.mydir =idir.GetPath()
-        else:
-            self.mydir=normpath(dir)
+#         if dir=='':
+#             idir=wx.DirDialog(None,"Choose Directory")
+#             if idir.ShowModal() == wx.ID_CANCEL:
+#                 return
+#             self.mydir =idir.GetPath()
+#         else:
+#             self.mydir=normpath(dir)
 
-        ext=['.top','.frott','.cls_pos','.cls_Z','.hbin','.zbin','.srcq']
-        for myext in ext:
-            if exists(self.mydir+'//simul'+myext):
+#         ext=['.top','.frott','.cls_pos','.cls_Z','.hbin','.zbin','.srcq']
+#         for myext in ext:
+#             if exists(self.mydir+'//simul'+myext):
 
-                self.mapviewer.add_object(which='array',
-                                          filename=self.mydir+'//simul'+myext,
-                                          id=myext,
-                                          ToCheck=False)
+#                 self.mapviewer.add_object(which='array',
+#                                           filename=self.mydir+'//simul'+myext,
+#                                           id=myext,
+#                                           ToCheck=False)
 
-        self.mybed=WolfArray(self.mydir +'//simul.top')
-        self.result = wolfres2DGPU(self.mydir,self.mybed,parent=self)
+#         self.mybed=WolfArray(self.mydir +'//simul.top')
+#         self.result = wolfres2DGPU(self.mydir,self.mybed,parent=self)
 
-        self.mapviewer.add_object(which='array',
-                                  newobj=self.result,
-                                  id='res1',
-                                  ToCheck=False)
+#         self.mapviewer.add_object(which='array',
+#                                   newobj=self.result,
+#                                   id='res1',
+#                                   ToCheck=False)
 
-        self.mapviewer.findminmax(True)
-        self.mapviewer.Autoscale(False)
+#         self.mapviewer.findminmax(True)
+#         self.mapviewer.Autoscale(False)
 
 class HydrologyModel(GenMapManager):
 
@@ -451,15 +454,15 @@ class Wolf2DPartArrays():
 
         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_addfile.SetToolTip(_("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_delfile.SetToolTip(_("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_apply.SetToolTip(_("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)
@@ -628,35 +631,35 @@ class Wolf2DInfiltration():
         sizer_btns = wx.BoxSizer(wx.HORIZONTAL)
 
         self._grid = CpGrid(self._panel,wx.ID_ANY, wx.WANTS_CHARS)
-        self._grid.CreateGrid(10, 3)
+        self._grid.CreateGrid(self.sim.infiltration.nb_steps, self.sim.infiltration.nb_zones)
 
         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_apply.SetToolTip(_("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_check.SetToolTip(_("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_reload.SetToolTip(_("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_plot.SetToolTip(_("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_plus.SetToolTip(_("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_minus.SetToolTip(_("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"))
+        self._btn_adjust.SetToolTip(_("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)
@@ -687,15 +690,18 @@ class Wolf2DInfiltration():
         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)
+        chronos = np.zeros((i_max, j_max+1), 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)
+        try:
+            for i in range(i_max):
+                for j in range(j_max+1):
+                    chronos[i,j] = self._grid.GetCellValue(i, j)
+        except:
+            logging.error("Error converting the grid to Float")
+            return
 
         self.sim.infiltration.infiltrations_chronology = chronos
-        self._btn_check(1)
-
+        self.on_check(1)
 
     def _fillgrid(self):
         """ Fill the CpGrid """
@@ -720,7 +726,7 @@ class Wolf2DInfiltration():
         grid.ClearGrid()
 
         grid.SetColLabelValue(0, _("Time"))
-        for i in range(1,nb_zones+1):
+        for i in range(1,max(nb_zones, grid.GetNumberCols())+1):
             grid.SetColLabelValue(i, f"Zone {i}")
 
         for i in range(nb_steps):
@@ -788,11 +794,11 @@ class Wolf2DInfiltration():
 
         dlg.Destroy()
 
-        self._fillgrid()
-
         self._grid.DeleteCols(nb_zones)
         self._grid.DeleteRows(nb_steps)
 
+        self._fillgrid()
+
         self._btn_check.SetBackgroundColour(wx.NullColour)
 
     def on_check(self, event):
@@ -958,7 +964,8 @@ class Wolf2DModel(GenMapManager):
             logging.info(_('Creating GUI'))
 
             # Initilisation d'une simulation 2D sur base des fichiers
-            self.sim:prev_sim2D = prev_sim2D(self.filenamegen)
+            self.sim:prev_sim2D
+            self.sim = prev_sim2D(self.filenamegen)
 
             # Liste des objets à ajouter au GUI
             self.fines_array=[]
@@ -1177,7 +1184,7 @@ class Wolf2DModel(GenMapManager):
     def mimic_mask(self, source:WolfArray):
         """ Copy the mask of the source array to all arrays in the model. """
 
-        self.som.mime_mask(source)
+        self.sim.mimic_mask(source)
 
     def show_properties(self):
         """
@@ -1188,6 +1195,7 @@ class Wolf2DModel(GenMapManager):
 
             if self._prop_frame is not None:
                 self._prop_frame.CenterOnScreen()
+                self._prop_frame.Iconize(False)
                 self._prop_frame.Show()
                 return
 
@@ -1702,7 +1710,7 @@ class Wolf2DModel(GenMapManager):
 
         wizard_text = self.sim.get_wizard_text()
 
-        self.wizard = Wizard(None, -1, _('Wizard Multiblocks simulation'))
+        self.wizard = Wizard(None, -1, _('Wizard GPU simulation'))
 
         self.wizard.SetPageSize((400, 300))
 
@@ -1869,7 +1877,7 @@ class Wolf2DModel(GenMapManager):
                     logging.error(_('Invalid fine resolution'))
                     return
 
-                self.sim.set_mesh_fine_size(float(dx), float(dy))
+                self.sim.set_mesh_fine_size(floatdx, floatdy)
                 self._show_glob_properties()
             except:
                 logging.error(_('Invalid fine resolution'))
@@ -2753,3 +2761,981 @@ class Wolf2DModel(GenMapManager):
         """Lecture de la matrice nap sur le maillage fin"""
 
         return self.sim.read_fine_array('.napbin')
+
+class Wolf2DGPUModel(GenMapManager):
+
+    def __init__(self, *args, dir:str='',  **kw):
+        """
+        :param dir: directory containing the simulation
+
+        self.wx_exists : If True, then this model will connect itself to the GUI.
+                    If False, the model will stand alone (so you can use it outside
+                    of the GUI).
+        """
+
+        super(Wolf2DGPUModel, self).__init__(*args, **kw)
+
+        self._wp = None
+        self.dir = ''
+        self._prop_frame = None
+        self._sim:Sim_2D_GPU = None
+
+        # Liste des objets à ajouter au GUI
+        self.arrays={}
+
+        # Gauging stations - SPW
+        self.SPWstations    = SPWMIGaugingStations()
+        self.DCENNstations  = SPWDCENNGaugingStations()
+
+        if dir != '':
+            # Either a directory or a file "/_/_/_/dir/simul" for example.
+
+            assert exists(dir) or dirname(dir), f"'{dir}' does not exists"
+
+        if dir=='':
+            if self.wx_exists:
+                # Propose a dialog window to choose the directory
+
+                idir=wx.DirDialog(None,"Choose Directory -- Abort for a new model from scratch", style=wx.DD_DEFAULT_STYLE)
+                ret = idir.ShowModal()
+
+                dir =Path(idir.GetPath())
+                if 'simul_gpu_results' in dir.name:
+                    dir = dir.parent
+
+                if ret == wx.ID_CANCEL or not (dir / 'parameters.json').exists():
+                    self.setup_mapviewer(title='Blank 2D model',wolfparent=self)
+                    self.mapviewer.findminmax(True)
+                    self.mapviewer.Autoscale(False)
+                    self.mapviewer.menu_sim2DGPU()
+                    if ret == wx.ID_CANCEL:
+                        self._sim = Sim_2D_GPU()
+                    else:
+                        self._sim = Sim_2D_GPU(idir.GetPath())
+                    self.show_properties()
+                    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')
+                    idir.Destroy()
+                    return
+            else:
+                return
+
+            self.dir = dir
+            idir.Destroy()
+        else:
+            self.dir=Path(normpath(dir))
+
+            if 'simul_gpu_results' in self.dir:
+                self.dir = self.dir.parent
+
+        try:
+            logging.info(_(f'Simulation directory is : {self.dir}'))
+            logging.info(_('Creating GUI'))
+
+            self._sim = Sim_2D_GPU(self.dir)
+
+            if self.wx_exists:
+
+                self.setup_mapviewer(title='2D GPU model : '+ str(self.dir), wolfparent=self)
+                self.show_properties()
+
+                if self.sim._sim is not None:
+                    self._btn_fromarray.Enable(False)
+                    self._btn_fromfootprint.Enable(False)
+                    self._btn_fromvector.Enable(False)
+                    self._btn_magnetic_grid.Enable(False)
+
+                    self._btn_add_arrays2viewer.SetLabel(_('Reload arrays'))
+
+            logging.info(_('Treating arrays'))
+
+            self._add_arrays_to_mapviewer()
+            self._add_vectors_to_mapviewer()
+
+            logging.info(_('Zooming'))
+            self.mapviewer.findminmax(True)
+            self.mapviewer.Autoscale(False)
+
+            self.show_properties()
+
+            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(_('Adapting menu'))
+                self.mapviewer.menu_sim2DGPU()
+
+            logging.info(_('Verifying files'))
+            self._sim.verify_files()
+
+            logging.info(_('Model loaded !!'))
+
+        except Exception as ex:
+            logging.error(str(ex), exc_info=True)
+
+    @property
+    def sim(self):
+        """ Alias """
+
+        return self._sim
+
+    def _add_arrays_to_mapviewer(self, force_reload:bool=False):
+        """
+        Add the arrays to the mapviewer
+        """
+
+        logging.info(_('Adding arrays to mapviewer'))
+
+        arrays_in_viewer = self.mapviewer.get_list_objects(draw_type.ARRAYS, checked_state=None)
+
+        if force_reload:
+            self._sim.reload_all()
+            for cur in self.arrays.values():
+                cur.reset_plot()
+            # self.mapviewer.Refresh()
+        else:
+
+            self.arrays = self._sim.get_arraysasdict()
+
+            for array in self.arrays.values():
+                if array.loaded:
+                    if array.idx not in [cur.idx for cur in arrays_in_viewer]:
+                        self.mapviewer.add_object(which='array', newobj=array, ToCheck=False, id= array.idx)
+
+
+    def _add_vectors_to_mapviewer(self):
+        """
+        Add the vectors to the mapviewer
+        """
+
+        logging.info(_('Adding vectors to mapviewer'))
+        pass
+
+    def show_properties_sim(self):
+        """
+        Show the properties of the model
+        """
+
+        logging.info(_('Opening parameters for simulation {}'.format(self.dir)))
+
+        self._wp:Wolf_Param
+        self._wp = self._sim.sim.to_wolfparam()
+        self._wp.show_in_active_if_default = True
+        self._wp.set_callbacks(self._callbackwp, self._callbackwp_destroy)
+        self._wp._set_gui(title='Parameters for simulation {}'.format(self.dir), toShow=False)
+        self._wp.hide_selected_buttons()
+        self._wp.Show()
+
+    def _callbackwp(self):
+        """ Callback for wolfparam """
+
+        if self._wp is not None:
+            try:
+                if self._wp.Shown:
+                    self._sim.sim.from_wolfparam(self._wp)
+                    self._sim.sim._save_json()
+            except Exception as e:
+                self._wp = None
+                logging.debug(_('Error while saving parameters for simulation {}'.format(self._sim.sim.path.name)))
+                logging.debug(str(e))
+
+    def _callbackwp_destroy(self):
+        """ Callback for wolfparam """
+
+        if self._wp is not None:
+            try:
+                if self._wp.Shown:
+                    self._sim.sim.from_wolfparam(self._wp)
+                    self._sim.sim._save_json()
+            except Exception as e:
+                self._wp = None
+                logging.debug(_('Error while saving parameters for simulation {}'.format(self._sim.sim.path.name)))
+                logging.debug(str(e))
+
+    def _set_bc(self, e:wx.EVT_BUTTON):
+        """ Set the boundary conditions """
+
+        from .mesh2d.bc_manager import BcManager, choose_bc_type
+
+        if self._sim is None:
+            logging.error(_('No simulation found'))
+            return
+
+        if 'nap' not in self.arrays:
+            logging.error(_('No nap array found'))
+            return
+
+        if self.mapviewer.active_bc is None:
+
+            newbc = BcManager(self,
+                            linked_array=self.arrays['nap'],
+                            version = 'gpu',
+                            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()
+            # self.mapviewer.active_bc.
+
+    def _set_infiltration(self, e:wx.EVT_BUTTON):
+
+        inf_frame = Wolf2DInfiltration(self._sim)
+        inf_frame.Show()
+
+    def add_boundary_condition(self, i: int, j: int, bc_type:BCType_2D_GPU,  bc_value: float, border:Direction):
+        """ alias """
+        from wolfgpu.simple_simulation import BoundaryConditionsTypes, Direction as ss_direction
+
+        def convert_dirhece2gpu(direction:Direction) -> ss_direction:
+            """ Convert the boundary conditions from HECE to GPU """
+            if direction == Direction.LEFT:
+                return ss_direction.LEFT
+            if direction == Direction.BOTTOM:
+                return ss_direction.BOTTOM
+
+        def convert_bchece2gpu(bctype:BCType_2D_GPU) -> BoundaryConditionsTypes:
+            """ Convert the boundary conditions from HECE to GPU """
+            if bctype == BCType_2D_GPU.FROUDE_NORMAL:
+                return BoundaryConditionsTypes.FROUDE_NORMAL
+            if bctype == BCType_2D_GPU.HMOD:
+                return BoundaryConditionsTypes.HMOD
+            if bctype == BCType_2D_GPU.NONE:
+                return BoundaryConditionsTypes.NONE
+            if bctype == BCType_2D_GPU.QX:
+                return BoundaryConditionsTypes.QX
+            if bctype == BCType_2D_GPU.QY:
+                return BoundaryConditionsTypes.QY
+
+        self._sim.sim.add_boundary_condition(i, j, convert_bchece2gpu(bc_type), bc_value, convert_dirhece2gpu(border))
+
+
+    def reset_boundary_conditions(self):
+        """ Reset the boundary conditions """
+
+        self._sim.sim.clear_boundary_conditions()
+
+
+    def _check_errors(self, e:wx.EVT_BUTTON):
+        """ Check the errors in the model """
+
+        ret_warnings = self._sim.sim.check_warnings()
+        ret_errors = self._sim.sim.check_errors()
+        ret_wolfgpu = self._sim.check_environment()
+
+        ret_infil=[]
+        nmax = ma.max(self.arrays['infiltration_zones'].array)
+        nmin = ma.min(self.arrays['infiltration_zones'].array[self.arrays['infiltration_zones'].array > 0])
+        l = ma.unique(self.arrays['infiltration_zones'].array[self.arrays['infiltration_zones'].array > 0]).tolist()
+        chronos = self.sim.sim.infiltrations_chronology
+
+        if nmin !=1:
+            ret_infil.append(_('Infiltration zones index must be strictly positive. the first one is 1.'))
+        if nmax != len(l):
+            ret_infil.append(_('Infiltration zones must be between 1 and N'))
+            ret_infil.append(_('N is the number of infiltration zones'))
+            ret_infil.append(_('You have {} zones in the arrays and the maximum index in the array is {}'.format(len(l), nmax)))
+        if len(chronos[0][1]) != len(l):
+            ret_infil.append(_('Infiltration zones must be between 1 and N'))
+            ret_infil.append(_('N is the number of infiltration zones'))
+            ret_infil.append(_('You have {} zones in the chronology and the maximum index in the array is {}'.format(len(chronos[0][1]), nmax)))
+            ret_infil.append(_('You have {} different zones in the array and the maximum index in the array is {}'.format(len(l), nmax)))
+            ret_infil.append(_('Check the chronology file and the array !'))
+
+
+        if ret_warnings is None:
+            ret_warnings = []
+        if ret_errors is None:
+            ret_errors = []
+
+        self._txt_info.Clear()
+
+        if len(ret_wolfgpu) > 0:
+            self.append_infos(_('Environment :\n'))
+            self.append_infos('\n'.join(ret_wolfgpu))
+            self.append_infos('\n')
+
+        if len(ret_warnings) + len(ret_errors) + len(ret_infil) == 0:
+            self.append_infos(_('No errors found'))
+            self._enable_disable_buttons(False)
+            self._btn_checkerrors.SetBackgroundColour(wx.Colour(0, 255, 0))
+            return
+
+        if len(ret_warnings) > 0:
+            self.append_infos(_('\n**WARNINGS** found :\n\n'))
+            self.append_infos('\n'.join(ret_warnings))
+            self._btn_checkerrors.SetBackgroundColour(wx.Colour(255, 255, 0))
+            self._enable_disable_buttons(False)
+
+        if len(ret_errors) > 0:
+            self.append_infos(_('\n**ERRORS** found :\n\n'))
+            self.append_infos('\n'.join(ret_errors))
+            self._btn_checkerrors.SetBackgroundColour(wx.Colour(255, 0, 0))
+            self._enable_disable_buttons(True)
+
+        if len(ret_infil) > 0:
+            self.append_infos(_('\n**ERRORS** in Infiltration zones :\n\n'))
+            self.append_infos('\n'.join(ret_infil))
+            self._btn_checkerrors.SetBackgroundColour(wx.Colour(255, 0, 0))
+            self._enable_disable_buttons(True)
+
+    def _enable_disable_buttons(self, errors:bool = False):
+        """ Enable or isable buttons"""
+
+        self._btn_write.Enable(not errors)
+        self._btn_run.Enable(not errors)
+
+        self._btn_results.Enable((Path(self.dir) / 'simul_gpu_results').exists())
+        self._btn_rs2ic.Enable((Path(self.dir) / 'simul_gpu_results').exists())
+        self._btn_copy2newdir.Enable((Path(self.dir) / 'simul_gpu_results').exists())
+
+
+    def _write_files(self, e:wx.EVT_BUTTON):
+        """ Write the files to disk """
+
+        if self.dir == '':
+            dlg = wx.DirDialog(None, _('Choose directory to save the simulation'), style=wx.DD_DEFAULT_STYLE | wx.DD_DIR_MUST_EXIST)
+            if dlg.ShowModal() == wx.ID_CANCEL:
+                dlg.Destroy()
+                return
+
+            self.dir = dlg.GetPath()
+            dlg.Destroy()
+
+        curdir = Path(self.dir)
+        if not curdir.exists():
+            logging.error(_('Directory does not exist'))
+            return
+
+        if self.mapviewer.active_bc is not None:
+            # Transfer boundary conditions
+            self.mapviewer.active_bc.send_to_wolfparent()
+
+        self._sim.sim.save(Path(self.dir))
+
+
+    def _run(self, e:wx.EVT_BUTTON):
+        """ Run the simulation """
+
+        dlg = wx.MessageDialog(None, _('Do you want to run the simulation in a separate process ?'), _('Run simulation'), wx.YES_NO)
+        if dlg.ShowModal() == wx.ID_NO:
+            dlg.Destroy()
+            return
+
+        dlg.Destroy()
+
+
+        dlg = wx.MessageDialog(None, _("Do you want to limit dryup loops?"), _("Dryup loops"), wx.YES_NO)
+        ret = dlg.ShowModal()
+        if ret == wx.ID_YES:
+            nbloops = wx.GetNumberFromUser(_("Number of dryup loops"), _("Dryup loops"), _("Dryup loops"), 2, 0, 1000)
+        else:
+            nbloops = -1
+
+        dlg.Destroy()
+
+        # Run wolfgpu in a separate command line
+        self._sim.run(limit_dryuploops=nbloops)
+
+
+    def _results(self, e:wx.EVT_BUTTON):
+        """ Display the results """
+
+        self.mapviewer.add_object(which='res2d_gpu',
+                                  filename=str(self.dir),
+                                  id=Path(self.dir).name)
+        self.mapviewer.menu_wolf2d()
+        self.mapviewer.Refresh()
+
+    def _results2ic(self, e:wx.EVT_BUTTON):
+        """ Choose one result as initial conditions """
+
+        from .wolfresults_2D import Wolfresults_2D
+        from .Results2DGPU import wolfres2DGPU
+        from datetime import timedelta
+
+        myres = wolfres2DGPU(self.dir, 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()
+
+        myres.set_hqxqy_as_initial_conditions(idx)
+
+        # update the arrays
+        self._add_arrays_to_mapviewer(force_reload=True)
+
+    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 _add_arrays2viewer(self, e:wx.EVT_BUTTON):
+        """ Create the fine arrays """
+
+        self._add_arrays_to_mapviewer(force_reload= self._btn_add_arrays2viewer.GetLabel() == _('Reload arrays'))
+
+    def _apply_mask(self, e:wx.EVT_BUTTON):
+        """ Apply the mask """
+
+        if self.mapviewer.active_array is None:
+            logging.error(_('No active array defined - Please select an array'))
+            return
+
+        if self.mapviewer.active_array not in self.arrays.values():
+            logging.error(_("Active array not found in the list of model's arrays"))
+            return
+
+        keys = self.sim._get_description_arrays()
+        self._sim.mimic_mask(self.mapviewer.active_array, [cur for key,cur in zip(keys,self.arrays.values()) if key != self.mapviewer.active_array.idx])
+        for cur in self.arrays.values():
+            cur.reset_plot()
+
+        self.mapviewer.Refresh()
+
+    def _create_from_vector(self, e:wx.EVT_BUTTON):
+        """ Create a simulation from a vector """
+
+        if self._sim.sim is not None:
+            dlg = wx.MessageDialog(None, _('Do you want to erase the current simulation ?'), _('Erase simulation'), wx.YES_NO)
+            if dlg.ShowModal() == wx.ID_NO:
+                dlg.Destroy()
+                return
+
+            dlg.Destroy()
+            self._sim.sim = None
+
+        if self.mapviewer.active_vector is None:
+            logging.error(_('No active vector defined - Please select or create a vector/polygon as external border'))
+            return
+
+        dlg = wx.TextEntryDialog(None, _('Size/Spatial resolution'), _('Spatial resolution'), 'dx, dy')
+        if dlg.ShowModal() == wx.ID_OK:
+
+            try:
+                dx, dy = dlg.GetValue().split(',')
+                self._sim.create_from_vector(self.mapviewer.active_vector, float(dx), float(dy))
+                self.update_wp()
+                self.clear_infos()
+                self.append_infos(str(self._sim.sim))
+            except Exception as e:
+                logging.error(_('Invalid mesh sizes or error {e}'))
+
+        dlg.Destroy()
+
+        self._btn_fromvector.Enable(False)
+        self._btn_fromfootprint.Enable(False)
+        self._btn_fromarray.Enable(False)
+
+    def _create_from_array(self, e:wx.EVT_BUTTON):
+        """ Create a simulation from an array """
+
+        if self._sim.sim is not None:
+            dlg = wx.MessageDialog(None, _('Do you want to erase the current simulation ?'), _('Erase simulation'), wx.YES_NO)
+            if dlg.ShowModal() == wx.ID_NO:
+                dlg.Destroy()
+                return
+
+            dlg.Destroy()
+            self._sim.sim = None
+
+        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.create_from_array(self.mapviewer.active_array)
+
+        dlg = wx.MessageDialog(None, _('Do you want to use the data from the array as bathymetry?'), _('Use bathymetry'), wx.YES_NO)
+        if dlg.ShowModal() == wx.ID_YES:
+            self._sim.sim._bathymetry[:,:] = self.mapviewer.active_array.array[:,:] # copy the array
+
+        dlg.Destroy()
+
+        self.update_wp()
+        self.clear_infos()
+        self.append_infos(str(self._sim.sim))
+
+        self._btn_fromvector.Enable(False)
+        self._btn_fromfootprint.Enable(False)
+        self._btn_fromarray.Enable(False)
+
+    def _create_from_footprint(self, e:wx.EVT_BUTTON):
+        """ Create a simulation from a footprint """
+
+        if self._sim.sim is not None:
+            dlg = wx.MessageDialog(None, _('Do you want to erase the current simulation ?'), _('Erase simulation'), wx.YES_NO)
+            if dlg.ShowModal() == wx.ID_NO:
+                dlg.Destroy()
+                return
+
+            dlg.Destroy()
+            self._sim.sim = None
+
+        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.create_from_header(newhead)
+                self.update_wp()
+                self.clear_infos()
+                self.append_infos(str(self._sim.sim))
+
+            except:
+                logging.error(_('Invalid footprint'))
+
+        dlg.Destroy()
+
+        self._btn_fromvector.Enable(False)
+        self._btn_fromfootprint.Enable(False)
+        self._btn_fromarray.Enable(False)
+
+
+    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.update_wp()
+            except:
+                logging.error(_('Invalid magnetic grid'))
+
+        dlg.Destroy()
+
+    def _choose_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(',')
+
+                try:
+                    floatdx = float(dx)
+                    floatdy = float(dy)
+                except:
+                    logging.error(_('Invalid fine resolution'))
+                    return
+
+                self._sim.set_mesh_size(floatdx, floatdy)
+            except:
+                logging.error(_('Invalid fine resolution'))
+
+        dlg.Destroy()
+
+    def _copy2dir(self, e:wx.EVT_BUTTON):
+        """ Copy the simulation to another directory """
+
+        dlg = wx.DirDialog(None, _('Choose the destination directory'))
+
+        if dlg.ShowModal() == wx.ID_OK:
+            newdir = dlg.GetPath()
+            self._sim.copy2dir(newdir)
+
+        dlg.Destroy()
+
+    def _apply_changes(self, e:wx.EVT_BUTTON):
+        """ Apply the changes """
+
+        if self._wp is not None:
+            self._callbackwp()
+
+    def show_properties(self):
+        """
+        Show the properties of the model
+        """
+
+        if self.wx_exists:
+
+            if self._prop_frame is not None:
+                self._prop_frame.CenterOnScreen()
+                self._prop_frame.Iconize(False)
+                self._prop_frame.Show()
+                return
+
+            # Création d'un wx Frame pour les paramètres
+            self._prop_frame = wx.Frame(self,
+                                        title=_('Parameters') + str(self.dir),
+                                        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)
+
+            # 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._btn_write.Enable(False)
+
+
+            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 - wolfgpu.exe code'))
+            self._btn_run.Bind(wx.EVT_BUTTON, self._run)
+            self._btn_run.Enable(False)
+
+            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._btn_results.Enable(False)
+
+            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._btn_rs2ic.Enable(False)
+
+            self._sizer_run_results.Add(self._btn_rs2ic, 1, wx.EXPAND)
+
+            # Copy Simulation
+            # ---------------
+
+            self._btn_copy2newdir = wx.Button(self._panel, label=_('Copy to...'))
+            self._btn_copy2newdir.SetToolTip(_('Copy the simulation to another directory'))
+            self._btn_copy2newdir.Bind(wx.EVT_BUTTON, self._copy2dir)
+            self._btn_copy2newdir.Enable(False)
+
+            self._sizer_run_results.Add(self._btn_copy2newdir, 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)
+
+            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_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)
+
+            # 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_magn_res.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)
+
+
+            # Create arrays
+            # -------------
+
+            self._btn_add_arrays2viewer = wx.Button(self._panel, label=_('Add arrays to viewer'))
+            self._btn_add_arrays2viewer.SetToolTip(_('Add all model arrays to the viewer'))
+            self._btn_add_arrays2viewer.Bind(wx.EVT_BUTTON, self._add_arrays2viewer)
+
+            self._btn_apply_mask = wx.Button(self._panel, label=_('Apply mask from active array to all'))
+            self._btn_apply_mask.SetToolTip(_('Apply the mask from the active array to all arrays'))
+            self._btn_apply_mask.Bind(wx.EVT_BUTTON, self._apply_mask)
+
+            self._sizer_add_mesh_create.Add(self._btn_add_arrays2viewer, 1, wx.EXPAND)
+            self._sizer_add_mesh_create.Add(self._btn_apply_mask, 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)
+
+            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, 3, 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
+
+            # Create the widget PropertyGridManager for the parameters
+            self._wp = Wolf_Param(self._panel, to_read=False, force_even_if_same_default=True, withbuttons=False, init_GUI=False)
+            self._wp.ensure_prop(wxparent = self._panel, show_in_active_if_default= True)
+            self._append_magnetic_grid_to_prop()
+
+            if self._sim.sim is not None:
+                self._sim.sim.add_to_wolfparam(self._wp)
+                self._wp.Populate(sorted_groups=True)
+
+            # add the properties to the sizer
+            self._sizer_properties.Add(self._wp.prop, 5, wx.EXPAND)
+
+            # self._sizer_properties.Add(self._sizer_btnsblocks, 1, wx.EXPAND)
+
+            self._prop_frame.Bind(wx.EVT_CLOSE, self.onclose)
+
+            # Show the frame
+            self._prop_frame.Show()
+
+        else:
+            logging.info(_('No GUI available'))
+
+    def onclose(self, e:wx.EVT_CLOSE):
+        """ Close the properties frame """
+
+        if self._prop_frame is not None:
+            self._prop_frame.Hide()
+
+    def _append_magnetic_grid_to_prop(self):
+        """ Append the magnetic grid to the properties """
+
+        self._wp.add_param(MAGN_GROUP_NAME,
+                                         'Dx',
+                                            0.,
+                                            Type_Param.Float,
+                                            _('Spatial resolution of the magnetic grid along X-axis'),
+                                            whichdict='All'
+                                            )
+        self._wp.add_param(MAGN_GROUP_NAME,
+                                            'Dy',
+                                            0.,
+                                            Type_Param.Float,
+                                            _('Spatial resolution of the magnetic grid along Y-axis'),
+                                            whichdict='All'
+                                            )
+
+        self._wp.add_param(MAGN_GROUP_NAME,
+                                            'Ox',
+                                            -99999.,
+                                            Type_Param.Float,
+                                            _('Origin of the magnetic grid along X-axis'),
+                                            whichdict='All'
+                                            )
+
+        self._wp.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._wp[(MAGN_GROUP_NAME, 'Dx')] = self._sim.magnetic_grid.dx
+        self._wp[(MAGN_GROUP_NAME, 'Dy')] = self._sim.magnetic_grid.dy
+
+        self._wp[(MAGN_GROUP_NAME, 'Ox')] = self._sim.magnetic_grid.origx
+        self._wp[(MAGN_GROUP_NAME, 'Oy')] = self._sim.magnetic_grid.origy
+
+        self._wp.Populate(sorted_groups=True)
+
+    def update_wp(self):
+        """ Update the properties """
+
+        if self._wp is not None:
+            self._wp[(MAGN_GROUP_NAME, 'Dx')] = self._sim.magnetic_grid.dx
+            self._wp[(MAGN_GROUP_NAME, 'Dy')] = self._sim.magnetic_grid.dy
+
+            self._wp[(MAGN_GROUP_NAME, 'Ox')] = self._sim.magnetic_grid.origx
+            self._wp[(MAGN_GROUP_NAME, 'Oy')] = self._sim.magnetic_grid.origy
+
+            if self._sim.sim is not None:
+                self._sim.sim.add_to_wolfparam(self._wp)
+
+            self._wp.Populate(sorted_groups=True)
+
+    def clear_infos(self):
+        """ Clear the information zone """
+
+        if self.wx_exists:
+            self._txt_info.Clear()
+
+    def append_infos(self, text):
+        """ Append text to the information zone """
+
+        if self.wx_exists:
+            self._txt_info.AppendText(text)