wolfhece 1.8.12__py3-none-any.whl → 2.0.0__py3-none-any.whl

wolfhece/PyDraw.py

@@ -4,6 +4,7 @@ import numpy as np
 from wx import dataview, TreeCtrl
 import wx
 import wx.propgrid as pg
+# from wxasync import AsyncBind
 from wx.core import VERTICAL, BoxSizer, Height, ListCtrl, StaticText, TextCtrl, Width
 from wx.glcanvas import GLCanvas, GLContext
 from wx.dataview import TreeListCtrl
@@ -18,7 +19,8 @@ import cv2
 from time import sleep
 from datetime import timedelta
 from multiprocessing import Pool
-import pathlib
+from pathlib import Path
+from time import sleep
 
 try:
     from OpenGL.GL import *
@@ -49,15 +51,21 @@ from .PyTranslate import _
 from .PyVertex import cloud_vertices, getIfromRGB
 from .RatingCurve import SPWMIGaugingStations, SPWDCENNGaugingStations
 from .wolf_array import WOLF_ARRAY_MB, SelectionData, WolfArray, WolfArray_Sim2D, WolfArrayMB, CropDialog, header_wolf, WolfArrayMNAP
-from .PyParams import Wolf_Param
+from .PyParams import Wolf_Param, key_Param, Type_Param
 from .mesh2d.bc_manager import BcManager
 from .PyVertexvectors import *
 from .Results2DGPU import wolfres2DGPU
-from .PyCrosssections import crosssections, profile
+from .PyCrosssections import crosssections, profile, Interpolator, Interpolators
 from .GraphNotebook import PlotNotebook
 from .lazviewer.laz_viewer import myviewer, read_laz, clip_data_xyz, xyz_laz_grids, choices_laz_colormap, Classification_LAZ
 from . import Lidar2002
-from .hydrometry.kiwis_hece import hydrometry_hece
+
+try:
+    from .hydrometry.kiwis_hece import hydrometry_hece as hydrometry
+except:
+    logging.warning(_('Hydrometry HECE module not found - Load hydrometry instead of hydrometry_hece'))
+    from .hydrometry.kiwis import hydrometry
+
 from .pyshields import get_d_cr
 from .pyviews import WolfViews
 from .PyConfig import handle_configuration_dialog, WolfConfiguration, ConfigurationKeys
@@ -65,6 +73,7 @@ from .GraphProfile import ProfileNotebook
 from .pybridges import Bridges, Bridge, Weirs, Weir
 from .tools_mpl import *
 from .wolf_tiles import Tiles
+from .lagrangian.particle_system_ui import Particle_system_to_draw as Particle_system
 
 ID_SELECTCS = 1000
 ID_SORTALONG = 1001
@@ -72,12 +81,16 @@ ID_LOCMINMAX = 1002
 ID_PLOTCS = 1003   #Manageactions ID for profile plots
 
 class draw_type(Enum):
+    # FIXME: change this to be more robust -> Done !
+    # Be careful with the enum name, it must be the same than the one used to create the tree list elements, but in lower case
+    # see : self.treelist.AppendItem in __init__
     ARRAYS = 'arrays'
     BRIDGES= 'bridges'
     WEIRS = 'weirs'
     VECTORS = 'vectors'
     CLOUD = 'clouds'
     TRIANGULATION = 'triangulations'
+    PARTICLE_SYSTEM = 'particle systems'
     CROSS_SECTIONS = 'cross_sections'
     OTHER = 'others'
     VIEWS = 'views'
@@ -94,15 +107,16 @@ class WolfMapViewer(wx.Frame):
 
     mybc: list[BcManager]  # Gestionnaire de CL
     myarrays: list  # matrices ajoutées
-    myvectors: list  # zones vectorielles ajoutées
-    myclouds: list  # nuages de vertices
-    mytri: list  # triangulations
+    myvectors: list[Zones]  # zones vectorielles ajoutées
+    myclouds: list[cloud_vertices]  # nuages de vertices
+    mytri: list[Triangulation]  # triangulations
     myothers: list
-    myviews:list
+    myviews:list[views_2D]
     mywmsback: list
     mywmsfore: list
     myres2D: list
-    mytiles: list
+    mytiles: list[Tiles]
+    mypartsystems: list[Particle_system]
 
     canvas: ogl.ShapeCanvas # GLCanvas  # canvas OpenGL
     context: GLContext  # context OpenGL
@@ -122,6 +136,7 @@ class WolfMapViewer(wx.Frame):
     active_cs: crosssections
     active_tri: Triangulation
     active_tile: Tiles
+    active_particle_system: Particle_system
 
     def __init__(self, wxparent, title, w=500, h=500, treewidth=200, wolfparent=None):
 
@@ -186,6 +201,8 @@ class WolfMapViewer(wx.Frame):
         self.menubar = wx.MenuBar()
 
         self.menuwolf2d = None
+        self.menuparticlesystem = None
+        self.timer_ps = None
         self.menusim2D  = None
         self.menulaz    = None
         self.menutiles  = None
@@ -230,6 +247,7 @@ class WolfMapViewer(wx.Frame):
         createmanager2D = self.menucreateobj.Append(wx.ID_ANY, _('Create Wolf2D manager ...'), _('New manager 2D'))
         createscenario2D = self.menucreateobj.Append(wx.ID_ANY, _('Create scenarios manager ...'), _('New scenarios manager 2D'))
         createbcmanager2D = self.menucreateobj.Append(wx.ID_ANY, _('Create BC manager Wolf2D...'), _('New BC manager 2D'))
+        createpartsystem = self.menucreateobj.Append(wx.ID_ANY, _('Create particle system...'), _('Create a particle system - Lagrangian view'))
 
         self.filemenu.AppendSeparator()
 
@@ -249,6 +267,7 @@ class WolfMapViewer(wx.Frame):
         addprofiles = self.menuaddobj.Append(wx.ID_FILE4, _('Add cross sections...'), _('Add cross sections'))
         addres2D = self.menuaddobj.Append(wx.ID_ANY, _('Add Wolf2D results...'), _('Add Wolf 2D results'))
         addres2Dgpu = self.menuaddobj.Append(wx.ID_ANY, _('Add Wolf2D GPU results...'), _('Add Wolf 2D GPU results'))
+        addpartsystem = self.menuaddobj.Append(wx.ID_ANY, _('Add particle system...'), _('Add a particle system - Lagrangian view'))
         addbridges = self.menuaddobj.Append(wx.ID_ANY, _('Add bridges...'), _('Add bridges from directory'))
         addweirs = self.menuaddobj.Append(wx.ID_ANY, _('Add weirs...'), _('Add bridges from directory'))
         addview = self.menuaddobj.Append(wx.ID_ANY, _('Add view...'), _('Add view from project file'))
@@ -346,6 +365,7 @@ class WolfMapViewer(wx.Frame):
         self.active_cs = None
         self.active_profile = None
         self.active_res2d = None
+        self.active_particle_system = None
         self.selected_treeitem = None
 
         curtool = self.tools[ID_SORTALONG] = {}
@@ -387,23 +407,17 @@ class WolfMapViewer(wx.Frame):
         self.myitemscloud = self.treelist.AppendItem(self.root, _("Clouds"))
         self.myitemstri = self.treelist.AppendItem(self.root, _("Triangulations"))
         self.myitemsres2d = self.treelist.AppendItem(self.root, _("Wolf2D"))
+        self.myitemsps = self.treelist.AppendItem(self.root, _("Particle systems"))
         self.myitemsothers = self.treelist.AppendItem(self.root, _("Others"))
         self.myitemsviews = self.treelist.AppendItem(self.root, _("Views"))
         self.myitemswmsback = self.treelist.AppendItem(self.root, _("WMS-background"))
         self.myitemswmsfore = self.treelist.AppendItem(self.root, _("WMS-foreground"))
 
+        # dictionnaire contenant les objets par catégorie
+        #FIXME : Useful? the lists can be accessed directly and idx attributes contains the key of the dictionary
         self.added = {}
         for curkey in draw_type:
-            self.added[curkey.value] = {}
-        # self.added['arrays'] = {}
-        # self.added['vectors'] = {}
-        # self.added['clouds'] = {}
-        # self.added['triangulations'] = {}
-        # self.added['wolf2d'] = {}
-        # self.added['others'] = {}
-        # self.added['views'] = {}
-        # self.added['wms-background'] = {}
-        # self.added['wms-foreground'] = {}
+            self.added[curkey]:dict[str:Element_To_Draw] = {}
 
         width, height = self.GetClientSize()
         self.bordersize = int((w - width + self.treewidth) / 2)
@@ -599,6 +613,239 @@ class WolfMapViewer(wx.Frame):
             self.menu2d_video = self.menuwolf2d.Append(wx.ID_ANY, _("Create video..."), _("Video/Movie"))
             self.menubar.Append(self.menuwolf2d, _('Options 2D'))
 
+    def menu_particlesystem(self):
+        if self.menuparticlesystem is None:
+
+            self.menuparticlesystem = wx.Menu()
+            self.menuparticlesystem_load = wx.Menu()
+
+            self.menuparticlesystem.Append(wx.ID_ANY, _("Set..."), _("Set arrays as the domain/uv of the particle system -- Must be a 2D array - Mask will be used to separate water and land"))
+            self.menuparticlesystem.Append(wx.ID_ANY, _("Set emitter from selected nodes"), _("Set the selected nodes as emitters of the particle system"))
+            self.menuparticlesystem.AppendSubMenu(self.menuparticlesystem_load, _("Load..."),  _('Load data for the particle system in the UI'))
+
+            self.menuparticlesystem_load.Append(wx.ID_ANY, _("Load domain..."), _("Loading the domain in the UI"))
+            self.menuparticlesystem_load.Append(wx.ID_ANY, _("Load ~domain..."), _("Loading the negative of the domain in the UI"))
+            self.menuparticlesystem_load.Append(wx.ID_ANY, _("Load emitters..."), _("Loading the emitters in the UI"))
+            self.menuparticlesystem_load.Append(wx.ID_ANY, _("Load uv..."), _("Loading the UV velocity field in the UI"))
+            self.menuparticlesystem_load.Append(wx.ID_ANY, _("Load uv norm..."), _("Loading the norm of the velocity field in the UI"))
+            # self.menuparticlesystem.Append(wx.ID_ANY, _("Set emitters..."), _("Set active zones as the emitters of the particle system -- Each checked zone will be used as an emitter"))
+            # self.menuparticlesystem.Append(wx.ID_ANY, _("Set emitter..."), _("Set only the active vector as an emitters of the particle system"))
+            # self.menuparticlesystem.Append(wx.ID_ANY, _("Set uv..."), _("Choose U and V arrays for the particle system -- Must be 2D arrays"))
+            self.menuparticlesystem.AppendSeparator()
+            self.menuparticlesystem.Append(wx.ID_ANY, _("Check"), _("Check if the particle system is ready to be computed"))
+            self.menuparticlesystem.Append(wx.ID_ANY, _("Bake"), _("Compute the particle system"))
+            self.menuparticlesystem.Append(wx.ID_ANY, _("Reset"), _("Clear all results but keep the particle system settings"))
+            self.menuparticlesystem.AppendSeparator()
+            # self.menuparticlesystem.AppendSeparator()
+            self.menuparticlesystem.Append(wx.ID_ANY, _("Start"), _("Run all steps"))
+            self.menuparticlesystem.Append(wx.ID_ANY, _("Stop"), _("Stop the current animation"))
+            self.menuparticlesystem.Append(wx.ID_ANY, _("Resume"), _("Resume animation"))
+
+            self.timer_ps = wx.Timer(self)
+
+            self.menuparticlesystem.Bind(wx.EVT_MENU, self.action_menu_particlesystem)
+            self.Bind(wx.EVT_TIMER, self.update_particlesystem, self.timer_ps)
+
+            self.menubar.Append(self.menuparticlesystem, _('Particle system'))
+
+    def action_menu_particlesystem(self, event: wx.Event):
+        """ Action to perform when the timer is triggered """
+
+        if self.active_particle_system is not None:
+
+            itemlabel = self.menuparticlesystem.FindItemById(event.GetId()).GetItemLabelText()
+
+
+            if itemlabel == _("Start"):
+
+                if self.active_particle_system is not None:
+                    self.active_particle_system.current_step = 0
+                    self.active_particle_system.current_step_idx = 0
+                    self.timer_ps.Start(1000. / self.active_particle_system.fps)
+
+            elif itemlabel == _("Stop"):
+
+                self.timer_ps.Stop()
+
+            elif itemlabel == _("Resume"):
+
+                self.timer_ps.Start(1000. / self.active_particle_system.fps)
+
+            elif itemlabel == _("Load domain..."):
+                domain = self.active_particle_system.get_domain(output_type='wolf')
+                self.add_object('array', id=domain.idx, newobj=domain, ToCheck=True)
+                self.Refresh()
+
+            elif itemlabel == _("Load ~domain..."):
+                domain:WolfArray = self.active_particle_system.get_domain(output_type='wolf')
+                domain.idx = domain.idx + '_neg'
+                domain.mask_reset()
+
+                ones = np.where(domain.array.data == 1)
+                domain.array[:,:] = 1
+                domain.array[ones] = 0
+
+                domain.mask_data(domain.nullvalue)
+                self.add_object('array', id=domain.idx, newobj=domain, ToCheck=True)
+                self.Refresh()
+
+            elif itemlabel == _("Load emitters..."):
+                emitters = self.active_particle_system.get_emitters(output_type='wolf')
+                self.add_object('vector', id=emitters.idx, newobj=emitters, ToCheck=True)
+                self.Refresh()
+
+            elif itemlabel == _("Load uv..."):
+                u = self.active_particle_system.get_u(output_type='wolf')
+                v = self.active_particle_system.get_v(output_type='wolf')
+                self.add_object('array', id=u.idx, newobj=u, ToCheck=True)
+                self.add_object('array', id=v.idx, newobj=v, ToCheck=True)
+                self.Refresh()
+
+            elif itemlabel == _("Load uv norm..."):
+                uvnorm = self.active_particle_system.get_uv_absolute(output_type='wolf')
+                self.add_object('array', id=uvnorm.idx, newobj=uvnorm, ToCheck=True)
+                self.Refresh()
+
+            elif itemlabel == _("Bake"):
+                check, msg = self.active_particle_system.bake()
+
+                if not check:
+                    dlg = wx.MessageDialog(self, msg, _('Error'), wx.OK | wx.ICON_ERROR)
+                    dlg.ShowModal()
+                    dlg.Destroy()
+                    return
+            elif itemlabel == _("Reset"):
+                self.active_particle_system.reset()
+
+            elif itemlabel == _("Set..."):
+                from .ui.wolf_multiselection_collapsiblepane import Wolf_MultipleSelection
+
+                setter = Wolf_MultipleSelection(self,
+                                                title=_("Set particle system"),
+                                                message=_("Choose arrays/emitters for the particle system"),
+                                                values_dict={'domain': self.get_list_keys(draw_type.ARRAYS),
+                                                             'u': self.get_list_keys(draw_type.ARRAYS),
+                                                             'v': self.get_list_keys(draw_type.ARRAYS),
+                                                             'emitters': self.get_list_keys(draw_type.VECTORS)},
+                                                info='Set : \n - domain (1 value)\n - u and v (multiple values)\n - emitters (multiple values)',
+                                                styles=[wx.LB_SINGLE, wx.LB_EXTENDED, wx.LB_EXTENDED, wx.LB_EXTENDED],
+                                                max_choices=[1, None, None, None],
+                                                delete_if_transfer = [True, False, False, True],
+                                                destroyOK=False)
+                setter.ShowModal()
+                ret_dict = setter.get_values()
+                setter.Destroy()
+
+                if 'domain' in ret_dict:
+                    if len(ret_dict['domain']) == 1:
+                        domain =self.added[draw_type.ARRAYS][ret_dict['domain'][0]]
+                        self.active_particle_system.set_domain(domain)
+                if 'u' in ret_dict and 'v' in ret_dict:
+                    if len(ret_dict['u']) >0:
+                        assert len(ret_dict['u']) == len(ret_dict['v']), _('Please select the same number of u and v arrays')
+
+                        time = 0.
+                        for u,v in zip(ret_dict['u'], ret_dict['v']):
+                            u = self.added[draw_type.ARRAYS][u]
+                            v = self.added[draw_type.ARRAYS][v]
+                            u:WolfArray
+                            v:WolfArray
+                            assert u.array.shape == v.array.shape, _('Please select arrays with the same shape')
+                            assert u.origx == v.origx and u.origy == v.origy, _('Please select arrays with the same origin')
+                            assert u.dx == v.dx and u.dy == v.dy, _('Please select arrays with the same resolution')
+                            self.active_particle_system.set_uv((u, v),
+                                                            (u.origx, u.origy, u.dx, u.dy),
+                                                            time = time)
+                            time += 1.
+
+                if 'emitters' in ret_dict:
+                    if len(ret_dict['emitters'])>0:
+                        emitters = [self.added[draw_type.VECTORS][cur] for cur in ret_dict['emitters']]
+                        self.active_particle_system.set_emitters(emitters)
+
+                if self.active_particle_system._ui is not None:
+                    self.active_particle_system.show_properties()
+
+            elif itemlabel == _("Set emitter from selected nodes"):
+                if self.active_array is None:
+                    logging.warning(_('No active array -- Please activate an array first'))
+                    return
+                if len(self.active_array.mngselection.myselection) == 0 and len(self.active_array.mngselection.selections) ==0:
+                    logging.warning(_('No selection -- Please select some nodes first'))
+                    return
+
+                from .lagrangian.emitter import Emitter
+
+                newemitters=[]
+                if len(self.active_array.mngselection.myselection) > 0:
+                    indices = [self.active_array.get_ij_from_xy(cur[0], cur[1]) for cur in self.active_array.mngselection.myselection]
+                    newemitters = [Emitter(indices,
+                                         header = (self.active_array.origx, self.active_array.origy, self.active_array.dx, self.active_array.dy))]
+
+                if len(self.active_array.mngselection.selections) > 0:
+
+                    for cursel in self.active_array.mngselection.selections.values():
+                        indices = [self.active_array.get_ij_from_xy(cur[0], cur[1]) for cur in cursel['select']]
+                        newemitters += [Emitter(indices, header = (self.active_array.origx, self.active_array.origy, self.active_array.dx, self.active_array.dy))]
+
+                self.active_particle_system.set_emitters(newemitters)
+
+                if self.active_particle_system._ui is not None:
+                    self.active_particle_system.show_properties()
+
+            # elif itemlabel == _("Set emitters..."):
+
+            #     if self.active_zones is None:
+            #         logging.warning(_('No active zones -- Please activate zones first'))
+            #         return
+
+            #     self.active_particle_system.set_emitters(self.active_zones)
+
+            # elif itemlabel == _("Set emitter..."):
+
+            #     if self.active_vector is None:
+            #         logging.warning(_('No active vector -- Please activate a vector first'))
+            #         return
+
+            #     self.active_particle_system.set_emitter(self.active_vector)
+
+            # elif itemlabel == _("Set uv..."):
+
+            #     list_arrays = self.multiple_choice_object(draw_type.ARRAYS, message=_('Choose U and V arrays for the particle system -- first == u ; second == v'), titel='UV choice' )
+
+            #     if len(list_arrays) != 2:
+            #         logging.error(_('Please select two arrays and ONLY two arrays'))
+            #         return
+
+            #     self.active_particle_system.set_uv(tuple(list_arrays))
+
+            elif itemlabel == _("Check"):
+                check, msg = self.active_particle_system.check()
+
+                if not check:
+                    dlg = wx.MessageDialog(self, msg, _('Error'), wx.OK | wx.ICON_ERROR)
+                    dlg.ShowModal()
+                    dlg.Destroy()
+                    return
+                else:
+                    dlg = wx.MessageDialog(self, _('All is fine -- You can bake you system !'), _('Chesk particle system'), wx.OK | wx.ICON_INFORMATION)
+                    dlg.ShowModal()
+                    dlg.Destroy()
+                    return
+
+    def update_particlesystem(self, event: wx.Event):
+        """ Animation of the particle system """
+
+        if self.active_particle_system is not None:
+
+            nb = self.active_particle_system.nb_steps
+            self.active_particle_system.current_step_idx += 1
+            self.Paint()
+            self._update_mytooltip()
+
+            if self.active_particle_system.current_step_idx == nb-1:
+                self.timer_ps.Stop()
+
     def menu_sim2D(self):
         if self.menusim2D is None:
             self.menusim2D = wx.Menu()
@@ -1275,6 +1522,7 @@ class WolfMapViewer(wx.Frame):
 
         self.mybc = []
         self.myarrays = []
+        self.mypartsystems = []
         self.myvectors = []
         self.mytiles = []
         self.myclouds = []
@@ -1285,7 +1533,8 @@ class WolfMapViewer(wx.Frame):
         self.mywmsfore = []
         self.myres2D = []
 
-        self.all_lists = [self.myarrays, self.myvectors, self.myclouds, self.mytri, self.myothers, self.myviews, self.myres2D, self.mytiles]
+        # liste des éléments modifiable dans l'arbre
+        self.all_lists = [self.myarrays, self.myvectors, self.myclouds, self.mytri, self.myothers, self.myviews, self.myres2D, self.mytiles, self.mypartsystems]
 
         if self.get_configuration() is not None:
             self.menu_options = wx.Menu()
@@ -2016,12 +2265,12 @@ class WolfMapViewer(wx.Frame):
         with wx.lib.busy.BusyInfo(_('Opening project')):
             wait = wx.BusyCursor()
             if 'which' in myproject.myparams.keys():
-                which = myproject.myparams['which']['action']['value']
+                which = myproject.myparams['which']['action'][key_Param.VALUE]
                 if which == 'compare':
                     ListCompare = []
                     if 'array' in myproject.myparams.keys():
                         for curid, curname in zip(myproject.myparams['array'].keys(), myproject.myparams['array'].values()):
-                            ListCompare.append(WolfArray(normpath(curname['value'])))
+                            ListCompare.append(WolfArray(normpath(curname[key_Param.VALUE])))
 
                     self.set_compare(ListCompare)
                     return
@@ -2030,9 +2279,9 @@ class WolfMapViewer(wx.Frame):
                 for curid, curname in zip(myproject.myparams['cross_sections'].keys(),
                                         myproject.myparams['cross_sections'].values()):
                     if curid != 'format' and curid != 'dirlaz':
-                        mycs = crosssections(curname['value'],
-                                            format=myproject.myparams['cross_sections']['format']['value'],
-                                            dirlaz=myproject.myparams['cross_sections']['dirlaz']['value'])
+                        mycs = crosssections(curname[key_Param.VALUE],
+                                            format=myproject.myparams['cross_sections']['format'][key_Param.VALUE],
+                                            dirlaz=myproject.myparams['cross_sections']['dirlaz'][key_Param.VALUE])
 
                         self.add_object('cross_sections', newobj=mycs, id=curid)
 
@@ -2059,54 +2308,54 @@ class WolfMapViewer(wx.Frame):
 
             if 'vector' in myproject.myparams.keys():
                 for curid, curname in zip(myproject.myparams['vector'].keys(), myproject.myparams['vector'].values()):
-                    if exists(curname['value']):
-                        myvec = Zones(curname['value'], parent=self)
+                    if exists(curname[key_Param.VALUE]):
+                        myvec = Zones(curname[key_Param.VALUE], parent=self)
                         self.add_object('vector', newobj=myvec, id=curid)
                     else:
-                        logging.info(_('Bad parameter in project file - vector : ')+ curname['value'])
+                        logging.info(_('Bad parameter in project file - vector : ')+ curname[key_Param.VALUE])
 
             if 'array' in myproject.myparams.keys():
                 for curid, curname in zip(myproject.myparams['array'].keys(), myproject.myparams['array'].values()):
 
-                    if exists(curname['value']):
-                        curarray = WolfArray(curname['value'])
+                    if exists(curname[key_Param.VALUE]):
+                        curarray = WolfArray(curname[key_Param.VALUE])
                         self.add_object('array', newobj=curarray, id=curid)
                     else:
-                        logging.info(_('Bad parameter in project file - array : ')+ curname['value'])
+                        logging.info(_('Bad parameter in project file - array : ')+ curname[key_Param.VALUE])
 
 
             if 'wolf2d' in myproject.myparams.keys():
                 for curid, curname in zip(myproject.myparams['wolf2d'].keys(), myproject.myparams['wolf2d'].values()):
-                    if exists(curname['value']):
-                        curwolf = Wolfresults_2D(curname['value'])
+                    if exists(curname[key_Param.VALUE]):
+                        curwolf = Wolfresults_2D(curname[key_Param.VALUE])
                         self.add_object('res2d', newobj=curwolf, id=curid)
                     else:
-                        logging.info(_('Bad parameter in project file - wolf2d : ')+ curname['value'])
+                        logging.info(_('Bad parameter in project file - wolf2d : ')+ curname[key_Param.VALUE])
 
                 self.menu_wolf2d()
 
             if 'palette' in myproject.myparams.keys():
                 self.project_pal = {}
                 for curid, curname in zip(myproject.myparams['palette'].keys(), myproject.myparams['palette'].values()):
-                    if exists(curname['value']):
+                    if exists(curname[key_Param.VALUE]):
                         mypal = wolfpalette(None, '')
-                        mypal.readfile(curname['value'])
+                        mypal.readfile(curname[key_Param.VALUE])
                         mypal.automatic = False
 
                         self.project_pal[curid] = mypal
                     else:
-                        logging.info(_('Bad parameter in project file - palette : ')+ curname['value'])
+                        logging.info(_('Bad parameter in project file - palette : ')+ curname[key_Param.VALUE])
 
             if 'palette-array' in myproject.myparams.keys():
                 curarray: WolfArray
                 if self.project_pal is not None:
                     for curid, curname in zip(myproject.myparams['palette-array'].keys(),
                                             myproject.myparams['palette-array'].values()):
-                        if curname['value'] in self.project_pal.keys():
+                        if curname[key_Param.VALUE] in self.project_pal.keys():
                             curarray = self.getobj(curid)
                             if curarray is not None:
                                 mypal:wolfpalette
-                                mypal = self.project_pal[curname['value']]
+                                mypal = self.project_pal[curname[key_Param.VALUE]]
                                 curarray.mypal = mypal
                                 if mypal.automatic:
                                     curarray.myops.palauto.SetValue(1)
@@ -2119,26 +2368,31 @@ class WolfMapViewer(wx.Frame):
 
             if 'cross_sections_link' in myproject.myparams.keys():
                 if 'linkzones' in myproject.myparams['cross_sections_link'].keys():
-                    idx = myproject.myparams['cross_sections_link']['linkzones']['value']
+                    idx = myproject.myparams['cross_sections_link']['linkzones'][key_Param.VALUE]
 
-                    for curvect in self.added['vectors']:
-                        myzones: Zones
-                        myzones = self.added['vectors'][curvect]['values']
-                        if myzones.idx == idx:
-                            self.active_cs.link_external_zones(myzones)
+                    for curzones in self.iterator_over_objects(draw_type.VECTORS):
+                        curzones: Zones
+                        if curzones.idx == idx:
+                            self.active_cs.link_external_zones(curzones)
+
+                    # for curvect in self.added[draw_type.VECTORS.value]:
+                    #     myzones: Zones
+                    #     myzones = self.added[draw_type.VECTORS.value][curvect]['values']
+                    #     if myzones.idx == idx:
+                    #         self.active_cs.link_external_zones(myzones)
 
                     zonename = ''
                     vecname = ''
 
                     if 'sortzone' in myproject.myparams['cross_sections_link'].keys():
-                        zonename = myproject.myparams['cross_sections_link']['sortzone']['value']
+                        zonename = myproject.myparams['cross_sections_link']['sortzone'][key_Param.VALUE]
                     if 'sortname' in myproject.myparams['cross_sections_link'].keys():
-                        vecname = myproject.myparams['cross_sections_link']['sortname']['value']
+                        vecname = myproject.myparams['cross_sections_link']['sortname'][key_Param.VALUE]
 
                     if zonename != '' and vecname != '':
-                        names = [cur.myname for cur in myzones.myzones]
+                        names = [cur.myname for cur in curzones.myzones]
                         idx = names.index(zonename)
-                        curzone = myzones.myzones[idx]
+                        curzone = curzones.myzones[idx]
                         names = [cur.myname for cur in curzone.myvectors]
                         idx = names.index(vecname)
                         curvec = curzone.myvectors[idx]
@@ -2153,7 +2407,7 @@ class WolfMapViewer(wx.Frame):
                     locvec = None
                     locarray = None
                     for curvec in self.myvectors:
-                        if curvec.idx == curname['value'].lower():
+                        if curvec.idx == curname[key_Param.VALUE].lower():
                             locvec=curvec
                             break
 
@@ -2170,7 +2424,7 @@ class WolfMapViewer(wx.Frame):
 
                         logging.warning(_('Bad vec-array association in project file !'))
                         logging.warning(curid)
-                        logging.warning(curname['value'])
+                        logging.warning(curname[key_Param.VALUE])
             del wait
 
     def save_project(self, fn):
@@ -2182,53 +2436,65 @@ class WolfMapViewer(wx.Frame):
         """
         # myproject.myparams['which']={}
         # myproject.myparams['which']['action']={}
-        # myproject.myparams['which']['action']['value']
+        # myproject.myparams['which']['action'][key_Param.VALUE]
 
         # mycs = self.active_cs
         # if mycs is not None:
         #     myproject.myparams['cross_sections']={}
         #     myproject.myparams['cross_sections']['mycs']={}
-        #     myproject.myparams['cross_sections']['mycs']['value']=mycs.filename
+        #     myproject.myparams['cross_sections']['mycs'][key_Param.VALUE]=mycs.filename
 
         #     myproject.myparams['vector']={}
         #     myproject.myparams['vector']['river']={}
-        #     myproject.myparams['vector']['river']['value']=self.added['vectors'][0].filename
+        #     myproject.myparams['vector']['river'][key_Param.VALUE]=self.added[draw_type.VECTORS.value][0].filename
 
         # if 'array' in myproject.myparams.key():
         #     for curid,curname in zip(myproject.myparams['array'].keys(),myproject.myparams['array'].values()):
-        #         curarray=WolfArray(curname['value'])
+        #         curarray=WolfArray(curname[key_Param.VALUE])
         #         self.add_object('array',newobj=curarray,id=curid)
         """
-        # Dessin des matrices
+        # matrices
         try:
-            for curarray in self.added['arrays']:
-                if self.added['arrays'][curarray]['checked']:
-                    locarray: WolfArray
-                    locarray = self.added['arrays'][curarray]['values']
-                    myproject['array'][locarray.idx] = {}
-                    myproject['array'][locarray.idx]['value'] = locarray.filename
+            for curel in self.iterator_over_objects(draw_type.ARRAYS):
+                myproject['array'][curel.idx] = {}
+                myproject['array'][curel.idx][key_Param.VALUE] = curel.filename
+
+            # for curarray in self.added[draw_type.ARRAYS.value]:
+            #     if self.added[draw_type.ARRAYS.value][curarray]['checked']:
+            #         locarray: WolfArray
+            #         locarray = self.added[draw_type.ARRAYS.value][curarray]['values']
+            #         myproject['array'][locarray.idx] = {}
+            #         myproject['array'][locarray.idx][key_Param.VALUE] = locarray.filename
         except:
             pass
 
-        # Dessin des résultats 2D
+        # résultats 2D
         try:
-            for curarray in self.added['wolf2d']:
-                if self.added['wolf2d'][curarray]['checked']:
-                    locarray: wolf2dprev
-                    locarray = self.added['wolf2d'][curarray]['values']
-                    myproject['wolf2d'][locarray.idx] = {}
-                    myproject['wolf2d'][locarray.idx]['value'] = locarray.filename
+            for curel in self.iterator_over_objects(draw_type.RES2D):
+                myproject['wolf2d'][curel.idx] = {}
+                myproject['wolf2d'][curel.idx][key_Param.VALUE] = curel.filename
+
+            # for curarray in self.added[draw_type.RES2D.value]:
+            #     if self.added[draw_type.RES2D.value][curarray]['checked']:
+            #         locarray: wolf2dprev
+            #         locarray = self.added[draw_type.RES2D.value][curarray]['values']
+            #         myproject['wolf2d'][locarray.idx] = {}
+            #         myproject['wolf2d'][locarray.idx][key_Param.VALUE] = locarray.filename
         except:
             pass
 
-        # Dessin des vecteurs
+        # vecteurs
         try:
-            for curvect in self.added['vectors']:
-                if self.added['vectors'][curvect]['checked']:
-                    curvec: Zones
-                    curvec = self.added['vectors'][curvect]['values']
-                    myproject['wolf2d'][curvec.idx] = {}
-                    myproject['wolf2d'][curvec.idx]['value'] = curvec.filename
+            for curel in self.iterator_over_objects(draw_type.VECTORS):
+                myproject['vector'][curel.idx] = {}
+                myproject['vector'][curel.idx][key_Param.VALUE] = curel.filename
+
+            # for curvect in self.added[draw_type.VECTORS.value]:
+            #     if self.added[draw_type.VECTORS.value][curvect]['checked']:
+            #         curvec: Zones
+            #         curvec = self.added[draw_type.VECTORS.value][curvect]['values']
+            #         myproject['wolf2d'][curvec.idx] = {}
+            #         myproject['wolf2d'][curvec.idx][key_Param.VALUE] = curvec.filename
         except:
             pass
 
@@ -2254,7 +2520,6 @@ class WolfMapViewer(wx.Frame):
         if self.active_array is not None:
             copy_vec = vector()
             copy_vec.myvertices = self.active_vector.myvertices.copy()
-            copy_vec.nbvertices = self.active_vector.nbvertices
             copy_vec.split(abs(self.active_array.dx)/2., False)
             copy_vec.get_values_on_vertices(self.active_array)
             s,z = copy_vec.get_sz()
@@ -2411,37 +2676,54 @@ class WolfMapViewer(wx.Frame):
 
     def read_last_result(self):
         """Lecture du dernier résultat pour les modèles ajoutés et plottés"""
+
         self.currently_readresults = True
 
-        for curmodel in self.added['wolf2d']:
-            if self.added['wolf2d'][curmodel]['checked']:
-                locmodel: Wolfresults_2D
-                locmodel = self.added['wolf2d'][curmodel]['values']
+        for curmodel in self.iterator_over_objects(draw_type.RES2D):
+            curmodel: Wolfresults_2D
+            logging.info(_('Updating {} - Last result'.format(curmodel.idx)))
 
-                logging.info(_('Updating {}'.format(locmodel.idx)))
+            curmodel.read_oneresult()
+            curmodel.set_currentview()
 
-                locmodel.read_oneresult()
-                locmodel.set_currentview()
+        # for curmodel in self.added[draw_type.RES2D.value]:
+        #     if self.added[draw_type.RES2D.value][curmodel]['checked']:
+        #         locmodel: Wolfresults_2D
+        #         locmodel = self.added[draw_type.RES2D.value][curmodel]['values']
+
+        #         logging.info(_('Updating {}'.format(locmodel.idx)))
+
+        #         locmodel.read_oneresult()
+        #         locmodel.set_currentview()
 
         self.Refresh()
         self.currently_readresults = False
         self._update_mytooltip()
 
-    def read_one_result(self, which):
+    def read_one_result(self, which:int):
         """
         Lecture d'un résultat spécific pour les modèles ajoutés et plottés
         """
         self.currently_readresults = True
 
-        for curmodel in self.added['wolf2d']:
-            if self.added['wolf2d'][curmodel]['checked']:
-                locmodel: Wolfresults_2D
-                locmodel = self.added['wolf2d'][curmodel]['values']
+        for curmodel in self.iterator_over_objects(draw_type.RES2D):
+            curmodel: Wolfresults_2D
+            if curmodel.checked:
+                logging.info(_('Updating {} - Specific result {}'.format(curmodel.idx, which)))
+
+                curmodel.read_oneresult(which)
+                curmodel.set_currentview()
+
+
+        # for curmodel in self.added[draw_type.RES2D.value]:
+        #     if self.added[draw_type.RES2D.value][curmodel]['checked']:
+        #         locmodel: Wolfresults_2D
+        #         locmodel = self.added[draw_type.RES2D.value][curmodel]['values']
 
-                logging.info(_('Updating {}'.format(locmodel.idx)))
+        #         logging.info(_('Updating {}'.format(locmodel.idx)))
 
-                locmodel.read_oneresult(which)
-                locmodel.set_currentview()
+        #         locmodel.read_oneresult(which)
+        #         locmodel.set_currentview()
 
         self.Refresh()
         self.currently_readresults = False
@@ -2454,35 +2736,73 @@ class WolfMapViewer(wx.Frame):
         """
         self.currently_readresults = True
 
-        for curmodel in self.added['wolf2d']:
-            if self.added['wolf2d'][curmodel]['checked']:
-                locmodel: Wolfresults_2D
-                locmodel = self.added['wolf2d'][curmodel]['values']
+        for curmodel in self.iterator_over_objects(draw_type.RES2D):
+            curmodel: Wolfresults_2D
+            logging.info(_('Updating {} - Previous result'.format(curmodel.idx)))
 
-                logging.info(_('Updating {}'.format(locmodel.idx)))
+            curmodel.read_previous()
+            curmodel.set_currentview()
 
-                locmodel.read_previous()
-                locmodel.set_currentview()
+        # for curmodel in self.added[draw_type.RES2D.value]:
+        #     if self.added[draw_type.RES2D.value][curmodel]['checked']:
+        #         locmodel: Wolfresults_2D
+        #         locmodel = self.added[draw_type.RES2D.value][curmodel]['values']
+
+        #         logging.info(_('Updating {}'.format(locmodel.idx)))
+
+        #         locmodel.read_previous()
+        #         locmodel.set_currentview()
 
         self.Refresh()
         self.currently_readresults = False
         self._update_mytooltip()
 
+    def particle_next_step(self):
+        """ Mise à jour au pas suivant """
+
+        for curps in self.iterator_over_objects(draw_type.PARTICLE_SYSTEM):
+            curps: Particle_system
+            logging.info(_('Updating {} - Next result'.format(curps.idx)))
+
+            curps.next_step()
+
+        self._update_mytooltip()
+        self.Refresh()
+
+    def particle_previous_step(self):
+        """ Mise à jour au pas précédent """
+
+        for curps in self.iterator_over_objects(draw_type.PARTICLE_SYSTEM):
+            curps: Particle_system
+            logging.info(_('Updating {} - Next result'.format(curps.idx)))
+
+            curps.previous_step()
+
+        self._update_mytooltip()
+        self.Refresh()
+
     def simul_next_step(self):
         """
         Mise à jour au pas suivant
         """
         self.currently_readresults = True
 
-        for curmodel in self.added['wolf2d']:
-            if self.added['wolf2d'][curmodel]['checked']:
-                locmodel: Wolfresults_2D
-                locmodel = self.added['wolf2d'][curmodel]['values']
+        for curmodel in self.iterator_over_objects(draw_type.RES2D):
+            curmodel: Wolfresults_2D
+            logging.info(_('Updating {} - Next result'.format(curmodel.idx)))
 
-                logging.info(_('Updating {}'.format(locmodel.idx)))
+            curmodel.read_next()
+            curmodel.set_currentview()
 
-                locmodel.read_next()
-                locmodel.set_currentview()
+        # for curmodel in self.added[draw_type.RES2D.value]:
+        #     if self.added[draw_type.RES2D.value][curmodel]['checked']:
+        #         locmodel: Wolfresults_2D
+        #         locmodel = self.added[draw_type.RES2D.value][curmodel]['values']
+
+        #         logging.info(_('Updating {}'.format(locmodel.idx)))
+
+        #         locmodel.read_next()
+        #         locmodel.set_currentview()
 
         self.Refresh()
         self.currently_readresults = False
@@ -2711,23 +3031,35 @@ class WolfMapViewer(wx.Frame):
             linkedarrays = {}
 
             # Matrices 2D
-            for curarray in self.added['arrays']:
-                if self.added['arrays'][curarray]['checked']:
-                    locarray = self.added['arrays'][curarray]['values']
-                    linkedarrays[locarray.idx] = locarray
+            for curarray in self.iterator_over_objects(draw_type.ARRAYS):
+                curarray: WolfArray
+                linkedarrays[curarray.idx] = curarray
+
+            # for curarray in self.added[draw_type.ARRAYS.value]:
+            #     if self.added[draw_type.ARRAYS.value][curarray]['checked']:
+            #         locarray = self.added[draw_type.ARRAYS.value][curarray]['values']
+            #         linkedarrays[locarray.idx] = locarray
 
             # Résultats 2D
-            for curarray in self.added['wolf2d']:
-                if self.added['wolf2d'][curarray]['checked']:
-                    locarray = self.added['wolf2d'][curarray]['values']
-                    linkedarrays[locarray.idx] = locarray
+            for curarray in self.iterator_over_objects(draw_type.RES2D):
+                curarray: Wolfresults_2D
+                linkedarrays[curarray.idx] = curarray
+
+            # for curarray in self.added[draw_type.RES2D.value]:
+            #     if self.added[draw_type.RES2D.value][curarray]['checked']:
+            #         locarray = self.added[draw_type.RES2D.value][curarray]['values']
+            #         linkedarrays[locarray.idx] = locarray
 
             linkedvecs={}
-            for curvect in self.added['vectors']:
-                if self.added['vectors'][curvect]['checked']:
-                    myzones: Zones
-                    myzones = self.added['vectors'][curvect]['values']
-                    linkedvecs[myzones.idx] = myzones
+            for curvect in self.iterator_over_objects(draw_type.VECTORS):
+                curvect: Zones
+                linkedvecs[curvect.idx] = curvect
+
+            # for curvect in self.added[draw_type.VECTORS.value]:
+            #     if self.added[draw_type.VECTORS.value][curvect]['checked']:
+            #         myzones: Zones
+            #         myzones = self.added[draw_type.VECTORS.value][curvect]['values']
+            #         linkedvecs[myzones.idx] = myzones
 
             if len(plotzone) > 1:
                 for curzone in plotzone:
@@ -2779,7 +3111,7 @@ class WolfMapViewer(wx.Frame):
                     logging.warning(_("Bad value -- Rety"))
                     return
 
-            if len(self.added['wolf2d'])>1:
+            if len(self.added[draw_type.RES2D])>1:
 
                 dlg = wx.MessageDialog(None, _('Apply to all results?'), style=wx.YES_NO)
                 ret = dlg.ShowModal()
@@ -2789,14 +3121,21 @@ class WolfMapViewer(wx.Frame):
                         self.active_res2d.load_default_colormap('shields_cst')
                     self.active_res2d.set_currentview(method, True)
                 else:
-                    for curarray in self.added['wolf2d']:
-                        if self.added['wolf2d'][curarray]['checked']:
-                            locarray:Wolfresults_2D
-                            locarray = self.added['wolf2d'][curarray]['values']
-                            if diamsize is not None:
-                                locarray.sediment_diameter = diamsize
-                                locarray.load_default_colormap('shields_cst')
-                            locarray.set_currentview(method)
+                    for curarray in self.iterator_over_objects(draw_type.RES2D):
+                        curarray:Wolfresults_2D
+                        if diamsize is not None:
+                            curarray.sediment_diameter = diamsize
+                            curarray.load_default_colormap('shields_cst')
+                        curarray.set_currentview(method)
+
+                    # for curarray in self.added[draw_type.RES2D.value]:
+                    #     if self.added[draw_type.RES2D.value][curarray]['checked']:
+                    #         locarray:Wolfresults_2D
+                    #         locarray = self.added[draw_type.RES2D.value][curarray]['values']
+                    #         if diamsize is not None:
+                    #             locarray.sediment_diameter = diamsize
+                    #             locarray.load_default_colormap('shields_cst')
+                    #         locarray.set_currentview(method)
             else:
                 if diamsize is not None:
                     self.active_res2d.sediment_diameter = diamsize
@@ -2825,18 +3164,26 @@ class WolfMapViewer(wx.Frame):
                 dlg.Destroy()
                 return
 
-            for curmodel in self.added['wolf2d']:
-                if self.added['wolf2d'][curmodel]['checked']:
-                    locmodel: Wolfresults_2D
-                    locmodel = self.added['wolf2d'][curmodel]['values']
-                    locmodel.epsilon = neweps
-                    locmodel._epsilon_default = neweps
-                    locmodel.read_oneresult(locmodel.current_result)
-                    locmodel.set_currentview()
+            for curmodel in self.iterator_over_objects(draw_type.RES2D):
+                curmodel: Wolfresults_2D
+                curmodel.epsilon = neweps
+                curmodel._epsilon_default = neweps
+                curmodel.read_oneresult(curmodel.current_result)
+                curmodel.set_currentview()
+
+            # for curmodel in self.added[draw_type.RES2D.value]:
+            #     if self.added[draw_type.RES2D.value][curmodel]['checked']:
+            #         locmodel: Wolfresults_2D
+            #         locmodel = self.added[draw_type.RES2D.value][curmodel]['values']
+            #         locmodel.epsilon = neweps
+            #         locmodel._epsilon_default = neweps
+            #         locmodel.read_oneresult(locmodel.current_result)
+            #         locmodel.set_currentview()
 
         elif itemlabel == _("Manage boundary conditions..."):
+
             if self.active_res2d is not None:
-                self.active_res2d.myparams.editing_bc(self.added['wolf2d'])
+                self.active_res2d.myparams.editing_bc(self.added[draw_type.RES2D])
 
         elif itemlabel ==_("Create video..."):
             if self.active_res2d is not None:
@@ -3125,8 +3472,8 @@ class WolfMapViewer(wx.Frame):
 
                 first = WolfArray(ListArrays[0], preload=False)
                 sec = WolfArray(ListArrays[1], preload=False)
-                first.read_txt_header(ListArrays[0])
-                sec.read_txt_header(ListArrays[1])
+                first.read_txt_header()
+                sec.read_txt_header()
 
                 if first.nbx == sec.nbx and first.nby == sec.nby and first.origx == sec.origx and first.origy == sec.origy:
                     first.preload = True
@@ -3190,11 +3537,22 @@ class WolfMapViewer(wx.Frame):
             self.add_object(which='cloud', ToCheck=True)
         elif itemlabel == _('Add triangulation...'):
             self.add_object(which='triangulation', ToCheck=True)
+
+        elif itemlabel == _('Add particle system...'):
+            self.add_object(which = 'particlesystem', ToCheck = True)
+            self.menu_particlesystem()
+
+        elif itemlabel == _('Create particle system...'):
+            self.active_particlesystem = newpart = Particle_system()
+            self.add_object(which='particlesystem', newobj=newpart, ToCheck=True)
+            self.menu_particlesystem()
+
         elif id == wx.ID_FILE4:
             self.add_object(which='cross_sections', ToCheck=True)
         elif itemlabel == _('Add Wolf2D results...'):
             self.add_object(which='res2d', ToCheck=True)
             self.menu_wolf2d()
+
         elif itemlabel == _('Add Wolf2D GPU results...'):
             self.add_object(which='res2d_gpu', ToCheck=True)
             self.menu_wolf2d()
@@ -3322,24 +3680,41 @@ class WolfMapViewer(wx.Frame):
             self.ManageActions(id)
         elif id == wx.ID_SAVE:
 
-            for curarray in self.added['arrays']:
-                if self.added['arrays'][curarray]['checked']:
-                    obj: WolfArray
-                    obj = self.added['arrays'][curarray]['values']
+            for obj in self.iterator_over_objects(draw_type.ARRAYS):
+                obj: WolfArray
 
-                    if obj.filename == '':
-                        filterArray = "bin (*.bin)|*.bin|all (*.*)|*.*"
-                        fdlg = wx.FileDialog(self, "Choose file", wildcard=filterArray, style=wx.FD_SAVE)
-                        fdlg.ShowModal()
-                        if fdlg.ShowModal() == wx.ID_OK:
-                            obj.filename = fdlg.GetPath()
+                if obj.filename == '':
+                    filterArray = "bin (*.bin)|*.bin|all (*.*)|*.*"
+                    fdlg = wx.FileDialog(self, "Choose file", wildcard=filterArray, style=wx.FD_SAVE)
+                    fdlg.ShowModal()
+                    if fdlg.ShowModal() == wx.ID_OK:
+                        obj.filename = fdlg.GetPath()
+
+                obj.write_all()
 
-                    obj.write_all()
 
-            for curvect in self.added['vectors']:
-                if self.added['vectors'][curvect]['checked']:
-                    obj = self.added['vectors'][curvect]['values']
-                    obj.saveas()
+            # for curarray in self.added[draw_type.ARRAYS.value]:
+            #     if self.added[draw_type.ARRAYS.value][curarray]['checked']:
+            #         obj: WolfArray
+            #         obj = self.added[draw_type.ARRAYS.value][curarray]['values']
+
+            #         if obj.filename == '':
+            #             filterArray = "bin (*.bin)|*.bin|all (*.*)|*.*"
+            #             fdlg = wx.FileDialog(self, "Choose file", wildcard=filterArray, style=wx.FD_SAVE)
+            #             fdlg.ShowModal()
+            #             if fdlg.ShowModal() == wx.ID_OK:
+            #                 obj.filename = fdlg.GetPath()
+
+            #         obj.write_all()
+
+            for obj in self.iterator_over_objects(draw_type.VECTORS):
+                obj:Zones
+                obj.saveas()
+
+            # for curvect in self.added[draw_type.VECTORS.value]:
+            #     if self.added[draw_type.VECTORS.value][curvect]['checked']:
+            #         obj = self.added[draw_type.VECTORS.value][curvect]['values']
+            #         obj.saveas()
 
         elif itemlabel == 'Save to image...':
             autoscale = False
@@ -3487,37 +3862,62 @@ class WolfMapViewer(wx.Frame):
 
         elif id == wx.ID_SAVEAS:
 
-            for curarray in self.added['arrays']:
-                if self.added['arrays'][curarray]['checked']:
-                    obj: WolfArray
-                    obj = self.added['arrays'][curarray]['values']
+            for obj in self.iterator_over_objects(draw_type.ARRAYS):
+                obj: WolfArray
 
-                    filterArray = "bin (*.bin)|*.bin|all (*.*)|*.*"
-                    fdlg = wx.FileDialog(self, "Choose file name for Array : " + obj.idx, wildcard=filterArray,
-                                         style=wx.FD_SAVE)
-                    ret = fdlg.ShowModal()
-                    if ret == wx.ID_OK:
-                        obj.filename = fdlg.GetPath()
-                        obj.write_all()
+                filterArray = "bin (*.bin)|*.bin|all (*.*)|*.*"
+                fdlg = wx.FileDialog(self, "Choose file name for Array : " + obj.idx, wildcard=filterArray,
+                                        style=wx.FD_SAVE)
+                ret = fdlg.ShowModal()
+                if ret == wx.ID_OK:
+                    obj.filename = fdlg.GetPath()
+                    obj.write_all()
 
-            for curvect in self.added['vectors']:
-                if curvect == 'grid':
-                    pass
-                elif self.added['vectors'][curvect]['checked']:
-                    obj = self.added['vectors'][curvect]['values']
 
+            # for curarray in self.added[draw_type.ARRAYS.value]:
+            #     if self.added[draw_type.ARRAYS.value][curarray]['checked']:
+            #         obj: WolfArray
+            #         obj = self.added[draw_type.ARRAYS.value][curarray]['values']
+
+            #         filterArray = "bin (*.bin)|*.bin|all (*.*)|*.*"
+            #         fdlg = wx.FileDialog(self, "Choose file name for Array : " + obj.idx, wildcard=filterArray,
+            #                              style=wx.FD_SAVE)
+            #         ret = fdlg.ShowModal()
+            #         if ret == wx.ID_OK:
+            #             obj.filename = fdlg.GetPath()
+            #             obj.write_all()
+
+            for obj in self.iterator_over_objects(draw_type.VECTORS):
+                obj:Zones
+                if obj.idx=='grid':
+                    pass
+                else:
                     filterArray = "vec (*.vec)|*.vec|vecz (*.vecz)|*.vecz|all (*.*)|*.*"
                     fdlg = wx.FileDialog(self, "Choose file name for Vector :" + obj.idx, wildcard=filterArray,
                                          style=wx.FD_SAVE)
                     ret = fdlg.ShowModal()
                     if ret == wx.ID_OK:
                         obj.saveas(fdlg.GetPath())
+
+            # for curvect in self.added[draw_type.VECTORS.value]:
+            #     if curvect == 'grid':
+            #         pass
+            #     elif self.added[draw_type.VECTORS.value][curvect]['checked']:
+            #         obj = self.added[draw_type.VECTORS.value][curvect]['values']
+
+            #         filterArray = "vec (*.vec)|*.vec|vecz (*.vecz)|*.vecz|all (*.*)|*.*"
+            #         fdlg = wx.FileDialog(self, "Choose file name for Vector :" + obj.idx, wildcard=filterArray,
+            #                              style=wx.FD_SAVE)
+            #         ret = fdlg.ShowModal()
+            #         if ret == wx.ID_OK:
+            #             obj.saveas(fdlg.GetPath())
+
         # elif id == ID_RUN_SIMULATION:
         #     from ..debug.test_glsim.wolf_gpu import load_sim_to_gpu
         #     print("Simulation")
         #     load_sim_to_gpu()
 
-        if len(self.myarrays) + len(self.myvectors) + len(self.myclouds) + len(self.mytri) + len(self.myres2D) + len(self.mytiles) == 2 and autoscale:
+        if len(self.myarrays) + len(self.myvectors) + len(self.myclouds) + len(self.mytri) + len(self.myres2D) + len(self.mytiles) + len(self.mypartsystems) == 2 and autoscale:
             # Trouve les bornzs si un seul élément est présent, sinon on conserve l'état du zoom
             self.Autoscale()
 
@@ -3805,15 +4205,21 @@ class WolfMapViewer(wx.Frame):
     def get_linked_arrays(self) -> dict:
         linkedarrays = {}
 
-        for curarray in self.added['arrays']:
-            if self.added['arrays'][curarray]['checked']:
-                locarray = self.added['arrays'][curarray]['values']
-                linkedarrays[locarray.idx] = locarray
+        for locarray in self.iterator_over_objects(draw_type.ARRAYS):
+            linkedarrays[locarray.idx] = locarray
+
+        for locarray in self.iterator_over_objects(draw_type.RES2D):
+            linkedarrays[locarray.idx] = locarray
 
-        for curarray in self.added['wolf2d']:
-            if self.added['wolf2d'][curarray]['checked']:
-                locarray = self.added['wolf2d'][curarray]['values']
-                linkedarrays[locarray.idx] = locarray
+        # for curarray in self.added[draw_type.ARRAYS.value]:
+        #     if self.added[draw_type.ARRAYS.value][curarray]['checked']:
+        #         locarray = self.added[draw_type.ARRAYS.value][curarray]['values']
+        #         linkedarrays[locarray.idx] = locarray
+
+        # for curarray in self.added[draw_type.RES2D.value]:
+        #     if self.added[draw_type.RES2D.value][curarray]['checked']:
+        #         locarray = self.added[draw_type.RES2D.value][curarray]['values']
+        #         linkedarrays[locarray.idx] = locarray
 
         return linkedarrays
 
@@ -3842,6 +4248,7 @@ class WolfMapViewer(wx.Frame):
                                  'views',
                                  'res2d',
                                  'res2d_gpu',
+                                 'particlesystem',
                                  'wmsback',
                                  'wmsfore'] = 'array',
                    filename='',
@@ -3853,7 +4260,8 @@ class WolfMapViewer(wx.Frame):
         Add object to current Frame/Drawing area
         """
 
-        filterArray = "bin (*.bin)|*.bin|Elevation WOLF2D (*.top)|*.top|Geotif (*.tif)|*.tif|Float ESRI (*.flt)|*.flt|Numpy (*.npy)|*.npy|all (*.*)|*.*"
+        filterArray = "bin (*.bin)|*.bin|Elevation WOLF2D (*.top)|*.top|Geotif (*.tif)|*.tif|Float ESRI (*.flt)|*.flt|Numpy (*.npy)|*.npy|Numpy named arrays(*.npz)|*.npz|all (*.*)|*.*"
+        filterjson = "json (*.json)|*.json|all (*.*)|*.*"
         filterall = "all (*.*)|*.*"
         filterres2d = "all (*.*)|*.*"
         filterVector = "vec (*.vec)|*.vec|vecz (*.vecz)|*.vecz|dxf (*.dxf)|*.dxf|shp (*.shp)|*.shp|all (*.*)|*.*"
@@ -3865,6 +4273,8 @@ class WolfMapViewer(wx.Frame):
             # ouverture d'une boîte de dialogue
             if which.lower() == 'array' or which.lower() == 'array_crop':
                 file = wx.FileDialog(self, "Choose file", wildcard=filterArray)
+            elif which.lower() == 'particlesystem':
+                file = wx.FileDialog(self, "Choose file", wildcard=filterjson)
             elif which.lower() == 'array_lidar_first' or which.lower() == 'array_lidar_second':
                 file = wx.DirDialog(self, "Choose directory containing Lidar data")
             elif which.lower() == 'array_xyz':
@@ -3910,28 +4320,77 @@ class WolfMapViewer(wx.Frame):
                 return
 
         if which.lower() == 'array' or which.lower() == 'array_crop':
-            curdict = self.added['arrays']
+            curdict = self.added[draw_type.ARRAYS]
             curtree = self.myitemsarray
 
             if newobj is None:
 
-                testobj = WolfArray()
-                testobj.filename = filename
-                testobj.read_txt_header(filename)
+                if filename.endswith('.npz'):
+
+                    wait = wx.BusyCursor()
+                    logging.info(_('Start of importing arrays from npz file'))
+
+                    with np.load(filename) as data:
+                        if 'header' in data.keys():
+                            header = data['header']
+
+                            if len(header) == 6:
+                                logging.info(_('Header found in npz file'))
 
-                if testobj.wolftype in WOLF_ARRAY_MB:
-                    with wx.lib.busy.BusyInfo(_('Importing array')):
-                        wait = wx.BusyCursor()
-                        newobj = WolfArrayMB(filename, mapviewer=self)
-                        del wait
+                                origx, origy, dx, dy, nbx, nby = header
+
+                                logging.info(_('Origin X : ') + str(origx))
+                                logging.info(_('Origin Y : ') + str(origy))
+                                logging.info(_('dx : ') + str(dx))
+                                logging.info(_('dy : ') + str(dy))
+                                logging.info(_('nbx : ') + str(nbx))
+                                logging.info(_('nby : ') + str(nby))
+                                nbx, nby = int(nbx), int(nby)
+                            else:
+                                logging.warning(_('Header found in npz file but not complete -- Only {} values found - Must be 6').format(len(header)))
+
+                            for key, curarray in data.items():
+                                if isinstance(curarray, np.ndarray):
+                                    if curarray.shape == (nby, nbx):
+                                        logging.info("Importing array : " + key)
+                                        curhead = header_wolf()
+                                        curhead.origx, curhead.origy, curhead.dx, curhead.dy, curhead.nbx, curhead.nby = origx, origy, dx, dy, nbx, nby
+                                        newobj = WolfArray(srcheader=curhead, idx = key)
+                                        newobj.set_array_from_numpy(curarray)
+                                        self.add_object('array', newobj= newobj, id= key)
+                        else:
+                            origx, origy, dx, dy, nbx, nby = 0.,0.,1,1.,1,1
+                            for key, curarray in data.items():
+                                if isinstance(curarray, np.ndarray):
+                                    logging.info(_('No header found in npz file - Using default values for header'))
+                                    logging.info("Importing array : " + key)
+                                    curhead = header_wolf()
+                                    curhead.origx, curhead.origy, curhead.dx, curhead.dy, curhead.nbx, curhead.nby = 0., 0., 1., 1., curarray.shape[0], curarray.shape[1]
+                                    newobj = WolfArray(srcheader=curhead, idx = key)
+                                    newobj.set_array_from_numpy(curarray)
+                                    self.add_object('array', newobj= newobj, id= key)
+
+                    logging.info(_('End of importing arrays from npz file'))
+                    del wait
+                    return
                 else:
-                    if which.lower() == 'array_crop':
-                        newobj = WolfArray(filename, mapviewer=self, crop='newcrop')
-                    else:
+                    testobj = WolfArray()
+                    testobj.filename = filename
+                    testobj.read_txt_header()
+
+                    if testobj.wolftype in WOLF_ARRAY_MB:
                         with wx.lib.busy.BusyInfo(_('Importing array')):
                             wait = wx.BusyCursor()
-                            newobj = WolfArray(filename, mapviewer=self)
+                            newobj = WolfArrayMB(filename, mapviewer=self)
                             del wait
+                    else:
+                        if which.lower() == 'array_crop':
+                            newobj = WolfArray(filename, mapviewer=self, crop='newcrop')
+                        else:
+                            with wx.lib.busy.BusyInfo(_('Importing array')):
+                                wait = wx.BusyCursor()
+                                newobj = WolfArray(filename, mapviewer=self)
+                                del wait
 
                 if newobj is not None:
                     if newobj.dx==0. or newobj.dy==0.:
@@ -3981,7 +4440,7 @@ class WolfMapViewer(wx.Frame):
             self._set_active_bc()
 
         elif which.lower() == 'bridges':
-            curdict = self.added['vectors']
+            curdict = self.added[draw_type.VECTORS]
             curtree = self.myitemsvector
 
             if newobj is None:
@@ -3992,7 +4451,7 @@ class WolfMapViewer(wx.Frame):
             self.myvectors.append(newobj)
 
         elif which.lower() == 'weirs':
-            curdict = self.added['vectors']
+            curdict = self.added[draw_type.VECTORS]
             curtree = self.myitemsvector
 
             if newobj is None:
@@ -4003,7 +4462,7 @@ class WolfMapViewer(wx.Frame):
             self.myvectors.append(newobj)
 
         elif which.lower() in ['tiles', 'tilescomp']:
-            curdict = self.added['vectors']
+            curdict = self.added[draw_type.VECTORS]
             curtree = self.myitemsvector
 
             if newobj is None:
@@ -4041,7 +4500,7 @@ class WolfMapViewer(wx.Frame):
 
         elif which.lower() == 'array_xyz':
 
-            curdict = self.added['arrays']
+            curdict = self.added[draw_type.ARRAYS]
             curtree = self.myitemsarray
 
             msg = wx.MessageDialog(self, _('Do you want to crop the data?'), style=wx.YES_NO | wx.YES_DEFAULT)
@@ -4116,7 +4575,7 @@ class WolfMapViewer(wx.Frame):
             self._set_active_bc()
 
         elif which.lower() == 'array_lidar_first' or which.lower() == 'array_lidar_second':
-            curdict = self.added['arrays']
+            curdict = self.added[draw_type.ARRAYS]
             curtree = self.myitemsarray
 
             newcrop = CropDialog(None)
@@ -4170,7 +4629,7 @@ class WolfMapViewer(wx.Frame):
                 id = 'lidar2002_secondecho'
 
         elif which.lower() == 'res2d':
-            curdict = self.added['wolf2d']
+            curdict = self.added[draw_type.RES2D]
             curtree = self.myitemsres2d
 
             if newobj is None:
@@ -4179,12 +4638,13 @@ class WolfMapViewer(wx.Frame):
                     newobj = Wolfresults_2D(filename, mapviewer=self)
                     del wait
 
+            newobj.get_nbresults(True)
             newobj.updatepalette()
             self.myres2D.append(newobj)
             self.active_res2d = newobj
 
         elif which.lower() == 'res2d_gpu':
-            curdict = self.added['wolf2d']
+            curdict = self.added[draw_type.RES2D]
             curtree = self.myitemsres2d
 
             if newobj is None:
@@ -4193,12 +4653,13 @@ class WolfMapViewer(wx.Frame):
                     newobj = wolfres2DGPU(filename, mapviewer=self)
                     del wait
 
+            newobj.get_nbresults(True)
             newobj.updatepalette()
             self.myres2D.append(newobj)
             self.active_res2d = newobj
 
         elif which.lower() == 'vector':
-            curdict = self.added['vectors']
+            curdict = self.added[draw_type.VECTORS]
             curtree = self.myitemsvector
             if newobj is None:
                 with wx.lib.busy.BusyInfo(_('Importing file')):
@@ -4208,7 +4669,7 @@ class WolfMapViewer(wx.Frame):
             self.myvectors.append(newobj)
 
         elif which.lower() == 'cross_sections':
-            curdict = self.added['vectors']
+            curdict = self.added[draw_type.VECTORS]
             curtree = self.myitemsvector
 
             if newobj is None:
@@ -4252,7 +4713,7 @@ class WolfMapViewer(wx.Frame):
             newobj.mapviewer = self
 
         elif which.lower() == 'cloud':
-            curdict = self.added['clouds']
+            curdict = self.added[draw_type.CLOUD]
             curtree = self.myitemscloud
             if newobj is None:
 
@@ -4281,7 +4742,7 @@ class WolfMapViewer(wx.Frame):
             self.create_cloud_menu()
 
         elif which.lower() == 'triangulation':
-            curdict = self.added['triangulations']
+            curdict = self.added[draw_type.TRIANGULATION]
             curtree = self.myitemstri
             if newobj is None:
                 with wx.lib.busy.BusyInfo(_('Importing triangulation')):
@@ -4294,48 +4755,67 @@ class WolfMapViewer(wx.Frame):
 
         elif which.lower() == 'other':
             if not newobj is None:
-                curdict = self.added['others']
+                curdict = self.added[draw_type.OTHER]
                 curtree = self.myitemsothers
                 self.myothers.append(newobj)
 
         elif which.lower() == 'views':
             if newobj is None:
                 newobj = WolfViews(plotted=ToCheck, mapviewer=self)
-                newobj.read_from_file(file)
+                newobj.read_from_file(filename)
 
-            curdict = self.added['views']
+            curdict = self.added[draw_type.VIEWS]
             curtree = self.myitemsviews
             self.myviews.append(newobj)
 
         elif which.lower() == 'wmsback':
             if not newobj is None:
-                curdict = self.added[draw_type.WMSBACK.value]
+                curdict = self.added[draw_type.WMSBACK]
                 curtree = self.myitemswmsback
                 self.mywmsback.append(newobj)
 
         elif which.lower() == 'wmsfore':
             if not newobj is None:
-                curdict = self.added[draw_type.WMSFORE.value]
+                curdict = self.added[draw_type.WMSFORE]
                 curtree = self.myitemswmsfore
                 self.mywmsfore.append(newobj)
 
+        elif which.lower() == 'particlesystem':
+            curdict = self.added[draw_type.PARTICLE_SYSTEM]
+            curtree = self.myitemsps
+            if newobj is None:
+                    newobj = Particle_system()
+                    newobj.load(filename)
+
+            self.mypartsystems.append(newobj)
+            self.active_particle_system = newobj
+
         if id == '':
-            dlg = wx.TextEntryDialog(self, 'ID ? (case insensitive)', 'Choose an identifier', _('NewObject'))
-            dlg.SetValue('')
+            dlg = wx.TextEntryDialog(self, 'ID ? (case insensitive)', 'Choose an identifier', '')
+            if filename != '':
+                dlg.SetValue((Path(filename).with_suffix('')).name)
+            else:
+                dlg.SetValue('')
+
             if len(curdict) == 0:
                 if dlg.ShowModal() == wx.ID_OK:
                     id = dlg.GetValue()
+                    if id =='':
+                        id = '001'
             else:
                 id = list(curdict.keys())[0]
                 while id.lower() in curdict:
                     if dlg.ShowModal() == wx.ID_OK:
                         id = dlg.GetValue()
+                        if id =='':
+                            id = '001'
             dlg.Destroy()
 
         if id.lower() in curdict:
-            endid = '_'
-            while id.lower() in curdict:
-                id += endid
+            # endid = '_'
+            endid = 1
+            while (id + str(endid).zfill(3)).lower() in curdict:
+                endid += 1
 
         newobj.idx = id.lower()
 
@@ -4347,13 +4827,10 @@ class WolfMapViewer(wx.Frame):
 
             newobj.check_plot()
 
-        loc = curdict[id.lower()] = {}
+        curdict[id.lower()] = newobj
         if filename != '':
-            loc['listname'] = filename.lower()
-            loc['filename'] = filename.lower()
-        loc['values'] = newobj
-        # loc['listitem'] = myitem
-        loc['checked'] = ToCheck
+            newobj._filename = filename.lower() # FIXME useful ??
+        newobj.checked = ToCheck
 
         if isinstance(newobj,crosssections):
             self.add_object('cloud',newobj=newobj.cloud,id=newobj.idx+'_intersect',ToCheck=False)
@@ -4376,13 +4853,108 @@ class WolfMapViewer(wx.Frame):
 
         """ Find the object associated with id """
 
-        for curdict in self.added:
-            if id.lower() in self.added[curdict].keys():
+        for curdict in draw_type:
+            keys = self.get_list_keys(curdict, checked_state=None)
+            if id.lower() in keys:
                 try:
-                    return self.added[curdict][id.lower()]['values']
+                    idx = keys.index(id.lower())
+                    return self.get_list_objects(curdict, checked_state=None)[idx]
                 except:
                     return None
 
+        # for curdict in self.added:
+        #     if id.lower() in self.added[curdict].keys():
+        #         try:
+        #             return self.added[curdict][id.lower()]['values']
+        #         except:
+        #             return None
+
+    def get_list_keys(self, drawing_type:draw_type, checked_state:bool=True):
+        """ Create a list of keys of type draw_type """
+        if checked_state is None:
+            return [key for key, curobj in self.added[drawing_type].items()]
+        else:
+            return [key for key, curobj in self.added[drawing_type].items() if curobj.checked == checked_state]
+
+    def get_list_objects(self, drawing_type:draw_type, checked_state:bool=True):
+        """ Create a list of objects of type draw_type """
+        if checked_state is None:
+            return [curobj for key, curobj in self.added[drawing_type].items()]
+        else:
+            return [curobj for key, curobj in self.added[drawing_type].items() if curobj.checked == checked_state]
+
+    def single_choice_key(self, draw_type:draw_type, checked_state:bool=True, message:str=_('Make a choice'), title:str=_('Choice')):
+        """ Create wx dialog to choose a key object of type draw_type """
+
+        keys = self.get_list_keys(draw_type, checked_state)
+        dlg = wx.SingleChoiceDialog(None, message, title, keys, style=wx.CHOICEDLG_STYLE)
+        ret = dlg.ShowModal()
+
+        if ret != wx.ID_OK:
+            dlg.Destroy()
+            return None
+
+        idx = dlg.GetSelection()
+        dlg.Destroy()
+
+        return keys[idx]
+
+    def single_choice_object(self, draw_type:draw_type, checked_state:bool=True, message:str=_('Make a choice'), title:str=_('Choice')):
+        """ Create wx dialog to choose an object of type draw_type """
+
+        keys = self.get_list_keys(draw_type, checked_state)
+        obj = self.get_list_objects
+        dlg = wx.SingleChoiceDialog(None, message, title, keys, style=wx.CHOICEDLG_STYLE)
+        ret = dlg.ShowModal()
+
+        if ret != wx.ID_OK:
+            dlg.Destroy()
+            return None
+
+        idx = dlg.GetSelection()
+        dlg.Destroy()
+
+        return obj[idx]
+
+    def multiple_choice_key(self, draw_type:draw_type, checked_state:bool=True, message:str=_('Make a choice'), title:str=_('Choice')):
+        """ Create wx dialog to choose multiple keys object of type draw_type """
+
+        keys = self.get_list_keys(draw_type, checked_state)
+        dlg = wx.MultiChoiceDialog(None, message, title, keys, style=wx.CHOICEDLG_STYLE)
+        ret = dlg.ShowModal()
+
+        if ret != wx.ID_OK:
+            dlg.Destroy()
+            return None
+
+        idx = dlg.GetSelections()
+        dlg.Destroy()
+
+        return [keys[i] for i in idx]
+
+    def multiple_choice_object(self, draw_type:draw_type, checked_state:bool=True, message:str=_('Make a choice'), title:str=_('Choice')):
+        """ Create wx dialog to choose multiple objects of type draw_type """
+
+        keys = self.get_list_keys(draw_type, checked_state)
+        obj = self.get_list_objects
+        dlg = wx.MultiChoiceDialog(None, message, title, keys, style=wx.CHOICEDLG_STYLE)
+        ret = dlg.ShowModal()
+
+        if ret != wx.ID_OK:
+            dlg.Destroy()
+            return None
+
+        idx = dlg.GetSelections()
+        dlg.Destroy()
+
+        return [obj[i] for i in idx]
+
+    def iterator_over_objects(self, drawing_type:draw_type, checked_state:bool=True) -> Element_To_Draw:
+        """ Create iterator over objects of type draw_type """
+
+        for obj in self.get_list_objects(drawing_type, checked_state):
+            yield obj
+
     def gettreeitem(self, obj):
 
         """ Find the tree item associated with obj """
@@ -4567,6 +5139,8 @@ class WolfMapViewer(wx.Frame):
                     self.selobj.saveas()
                 elif type(self.selobj) is Triangulation:
                     self.selobj.saveas()
+                elif isinstance(self.selobj, Particle_system):
+                    self.selobj.save()
         elif text==_('Up'):
             self.upobj()
         elif text == _('Down'):
@@ -4601,6 +5175,8 @@ class WolfMapViewer(wx.Frame):
                         break
 
         elif text == _('Save as'):
+            # save objet to file, choosing the file name
+
             if self.selobj is not None:
                 if type(self.selobj) is WolfArray or type(self.selobj) is WolfArray_Sim2D:
                     filterArray = "bin (*.bin)|*.bin|tif (*.tif)|*.tif|all (*.*)|*.*"
@@ -4631,11 +5207,20 @@ class WolfMapViewer(wx.Frame):
                         self.selobj.saveas(fdlg.GetPath())
 
                     fdlg.Destroy()
+                elif isinstance(self.selobj, Particle_system):
+                    filterArray = "json (*.json)|*.json|all (*.*)|*.*"
+                    fdlg = wx.FileDialog(self, "Choose file name for particle system :" + self.selobj.idx, wildcard=filterArray,
+                                         style=wx.FD_SAVE)
+                    ret = fdlg.ShowModal()
+                    if ret == wx.ID_OK:
+                        self.selobj.save(fdlg.GetPath())
+
+                    fdlg.Destroy()
 
         elif text == _('Properties'):
 
             myobj = self.selobj
-            if type(myobj) in [WolfArray, WolfArray_Sim2D, WolfArrayMB, WolfArrayMNAP, Zones, Wolfresults_2D, wolfres2DGPU]:
+            if type(myobj) in [WolfArray, WolfArray_Sim2D, WolfArrayMB, WolfArrayMNAP, Zones, Wolfresults_2D, wolfres2DGPU, Particle_system]:
                 myobj.show_properties()
 
 
@@ -4682,7 +5267,10 @@ class WolfMapViewer(wx.Frame):
 
         if nameparent != '':
             curobj = self.getobj(nameitem)
-            self.added[nameparent][nameitem]['checked'] = bool(check)
+            if curobj is None:
+                return
+            # curobj.checked = bool(check)
+            # self.added[nameparent][nameitem]['checked'] = bool(check)
 
             if bool(check):
                 try:
@@ -4708,6 +5296,8 @@ class WolfMapViewer(wx.Frame):
                     size = float(dlg.GetValue())
                 curobj.creategrid(size, self.xmin, self.ymin, self.xmax, self.ymax)
 
+            self.Refresh()
+
     def getXY(self, pospix):
 
         width, height = self.canvas.GetSize()
@@ -4726,11 +5316,15 @@ class WolfMapViewer(wx.Frame):
         """
         Récupération du premier objet crosssections disponible
         """
-        for curvect in self.added['vectors']:
-            if self.added['vectors'][curvect]['checked']:
-                obj = self.added['vectors'][curvect]['values']
-                if type(obj) is crosssections:
-                    return obj
+        for obj in self.iterator_over_objects(draw_type.VECTORS):
+            if isinstance(obj,crosssections):
+                return obj
+
+        # for curvect in self.added[draw_type.VECTORS.value]:
+        #     if self.added[draw_type.VECTORS.value][curvect]['checked']:
+        #         obj = self.added[draw_type.VECTORS.value][curvect]['values']
+        #         if type(obj) is crosssections:
+        #             return obj
 
         return None
 
@@ -5051,6 +5645,7 @@ class WolfMapViewer(wx.Frame):
                 return
 
     def OnActivateTreeElem(self, e): #:dataview.TreeListEvent ):
+        """ Activate the selected item in the tree list """
         curzones: Zones
         curzone: zone
         curvect: vector
@@ -5070,10 +5665,15 @@ class WolfMapViewer(wx.Frame):
         self.selobj = myobj
         self.selitem.SetLabel(nameitem)
 
+        #FIXME : To generalize using draw_type
         if type(myobj) == Zones:
             if ctrl:
                 myobj.show_properties()
 
+        elif type(myobj) == Particle_system:
+            if ctrl:
+                myobj.show_properties()
+
         elif type(myobj) == Tiles:
             self.active_tile= myobj
 
@@ -5140,103 +5740,130 @@ class WolfMapViewer(wx.Frame):
         self.mytooltip.myparams[curgroup] = {}
 
         curpar = 'Pixel'
-        self.mytooltip.myparams[curgroup][curpar] = {}
-        self.mytooltip.myparams[curgroup][curpar]['name'] = 'Pixel'
-        self.mytooltip.myparams[curgroup][curpar]['value'] = '(' + str(pos[0]) + ' ; ' + str(pos[1]) + ')'
-        self.mytooltip.myparams[curgroup][curpar]['type'] = 'String'
-        self.mytooltip.myparams[curgroup][curpar]['comment'] = ''
-
-        curpar = 'x'
-        self.mytooltip.myparams[curgroup][curpar] = {}
-        self.mytooltip.myparams[curgroup][curpar]['name'] = 'Coordinate X'
-        self.mytooltip.myparams[curgroup][curpar]['value'] = '{:3f}'.format(x)
-        self.mytooltip.myparams[curgroup][curpar]['type'] = 'String'
-        self.mytooltip.myparams[curgroup][curpar]['comment'] = ''
-
-        curpar = 'y'
-        self.mytooltip.myparams[curgroup][curpar] = {}
-        self.mytooltip.myparams[curgroup][curpar]['name'] = 'Coordinate Y'
-        self.mytooltip.myparams[curgroup][curpar]['value'] = '{:3f}'.format(y)
-        self.mytooltip.myparams[curgroup][curpar]['type'] = 'String'
-        self.mytooltip.myparams[curgroup][curpar]['comment'] = ''
+        self.mytooltip.add_param(groupname = curgroup,
+                                 name = curpar,
+                                 value = '(' + str(pos[0]) + ' ; ' + str(pos[1]) + ')',
+                                 type = Type_Param.String,
+                                 comment = '')
+
+        curpar = 'Coordinate X'
+        self.mytooltip.add_param(groupname = curgroup,
+                                 name = curpar,
+                                 value = '{:3f}'.format(x),
+                                 type = Type_Param.String,
+                                 comment = '')
+
+        curpar = 'Coordinate Y'
+        self.mytooltip.add_param(groupname = curgroup,
+                                 name = curpar,
+                                 value = '{:3f}'.format(y),
+                                 type = Type_Param.String,
+                                 comment = '')
 
         for locarray in self.myres2D:
             locarray:Wolfresults_2D
             curgroup = locarray.idx
-            if self.added['wolf2d'][curgroup]['checked']:
+            if locarray.checked:
                 try:
-
                     vals,labs = locarray.get_values_labels(x,y)
 
                     i, j, curbloc = locarray.get_blockij_from_xy(x, y)
 
                     if i != '-':
-                        self.mytooltip.myparams[curgroup] = {}
-                        curpar = 'Indices (1-based)'
-                        self.mytooltip.myparams[curgroup][curpar] = {}
-                        self.mytooltip.myparams[curgroup][curpar]['name'] = 'Indice (i;j;bloc)'
-                        self.mytooltip.myparams[curgroup][curpar]['value'] = '(' + str(i) + ';' + str(j) + ';' + str(curbloc) + ')'
-                        self.mytooltip.myparams[curgroup][curpar]['type'] = 'String'
-                        self.mytooltip.myparams[curgroup][curpar]['comment'] = ''
+                        curpar = 'Indices (i;j;bloc) (1-based)'
+
+                        self.mytooltip.add_param(groupname = curgroup,
+                                                 name = curpar,
+                                                 value =  '(' + str(i) + ';' + str(j) + ';' + str(curbloc) + ')',
+                                                 type = Type_Param.String,
+                                                 comment = '')
 
                         for val,curpar in zip(vals,labs):
-                            self.mytooltip.myparams[curgroup][curpar] = {}
-                            self.mytooltip.myparams[curgroup][curpar]['name'] = 'Value'
+
                             if val is np.nan:
-                                self.mytooltip.myparams[curgroup][curpar]['value'] = "Nan"
+                                self.mytooltip.add_param(groupname = curgroup,
+                                                        name = 'Value',
+                                                        value =  "Nan",
+                                                        type = Type_Param.String,
+                                                        comment = '')
+                            elif isinstance(val, str):
+                                self.mytooltip.add_param(groupname = curgroup,
+                                                        name = curpar,
+                                                        value =  val,
+                                                        type = Type_Param.String,
+                                                        comment = '')
+                            elif isinstance(val, int):
+                                self.mytooltip.add_param(groupname = curgroup,
+                                                        name = curpar,
+                                                        value =  int(val),
+                                                        type = Type_Param.Integer,
+                                                        comment = '')
                             else:
-                                if isinstance(val, str):
-                                    self.mytooltip.myparams[curgroup][curpar]['value'] = val
-                                    self.mytooltip.myparams[curgroup][curpar]['type'] = 'String'
-                                elif isinstance(val, int):
-                                    self.mytooltip.myparams[curgroup][curpar]['value'] = int(val)
-                                    self.mytooltip.myparams[curgroup][curpar]['type'] = 'Integer'
-                                else:
-                                    self.mytooltip.myparams[curgroup][curpar]['value'] = float(val)
-                                    self.mytooltip.myparams[curgroup][curpar]['type'] = 'Float'
-                            self.mytooltip.myparams[curgroup][curpar]['comment'] = ''
+                                self.mytooltip.add_param(groupname = curgroup,
+                                                        name = curpar,
+                                                        value =  float(val),
+                                                        type = Type_Param.Float,
+                                                        comment = '')
+
                 except:
                     pass
 
         for locarray in self.myarrays:
-            curgroup = locarray.idx
-            if self.added['arrays'][curgroup]['checked']:
+            if locarray.checked:
+                curgroup = locarray.idx
 
                 try:
                     val = locarray.get_value(x, y)
 
                     if val != -99999.:
-                        self.mytooltip.myparams[curgroup] = {}
 
                         if locarray.wolftype in WOLF_ARRAY_MB:
                             i, j, curbloc = locarray.get_blockij_from_xy(x, y)
-                            curpar = 'Indices (1-based)'
-                            self.mytooltip.myparams[curgroup][curpar] = {}
-                            self.mytooltip.myparams[curgroup][curpar]['name'] = 'Indice (i;j;bloc)'
-                            self.mytooltip.myparams[curgroup][curpar]['value'] = '(' + str(i + 1) + ';' + str(
-                                j + 1) + ';' + str(curbloc) + ')'
-                            self.mytooltip.myparams[curgroup][curpar]['type'] = 'String'
-                            self.mytooltip.myparams[curgroup][curpar]['comment'] = ''
+                            curpar = 'Indices (i;j;bloc) (1-based)'
+
+                            self.mytooltip.add_param(groupname = curgroup,
+                                                        name = curpar,
+                                                        value =  '(' + str(i+1) + ';' + str(j+1) + ';' + str(curbloc) + ')',
+                                                        type = Type_Param.String,
+                                                        comment = '')
+
                         else:
                             i, j = locarray.get_ij_from_xy(x, y)
-                            curpar = 'Indices (1-based)'
-                            self.mytooltip.myparams[curgroup][curpar] = {}
-                            self.mytooltip.myparams[curgroup][curpar]['name'] = 'Indice (i;j)'
-                            self.mytooltip.myparams[curgroup][curpar]['value'] = '(' + str(i + 1) + ';' + str(
-                                j + 1) + ')'
-                            self.mytooltip.myparams[curgroup][curpar]['type'] = 'String'
-                            self.mytooltip.myparams[curgroup][curpar]['comment'] = ''
+                            curpar = 'Indices (i;j) (1-based)'
+
+                            self.mytooltip.add_param(groupname = curgroup,
+                                                        name = curpar,
+                                                        value =  '(' + str(i+1) + ';' + str(j+1) + ')',
+                                                        type = Type_Param.String,
+                                                        comment = '')
 
                         curpar = 'Value'
-                        self.mytooltip.myparams[curgroup][curpar] = {}
-                        self.mytooltip.myparams[curgroup][curpar]['name'] = 'Value'
+
                         if val is np.nan:
-                            self.mytooltip.myparams[curgroup][curpar]['value'] = "Nan"
+                            self.mytooltip.add_param(groupname = curgroup,
+                                                    name = 'Value',
+                                                    value =  "Nan",
+                                                    type = Type_Param.String,
+                                                    comment = '')
+                        elif isinstance(val, str):
+                            self.mytooltip.add_param(groupname = curgroup,
+                                                    name = curpar,
+                                                    value =  val,
+                                                    type = Type_Param.String,
+                                                    comment = '')
+                        elif isinstance(val, int):
+                            self.mytooltip.add_param(groupname = curgroup,
+                                                    name = curpar,
+                                                    value =  int(val),
+                                                    type = Type_Param.Integer,
+                                                    comment = '')
                         else:
-                            self.mytooltip.myparams[curgroup][curpar]['value'] = float(val)
-                        # self.mytooltip.myparams[curgroup][curpar]['value'] = val
-                        self.mytooltip.myparams[curgroup][curpar]['type'] = 'Float'
-                        self.mytooltip.myparams[curgroup][curpar]['comment'] = ''
+                            self.mytooltip.add_param(groupname = curgroup,
+                                                    name = curpar,
+                                                    value =  float(val),
+                                                    type = Type_Param.Float,
+                                                    comment = '')
+
                 except:
                     pass
 
@@ -5246,29 +5873,76 @@ class WolfMapViewer(wx.Frame):
                     for locarray in curFrame.myarrays:
                         curgroup = locarray.idx
                         if curFrame.added['arrays'][curgroup]['checked']:
-                            self.mytooltip.myparams[curgroup] = {}
 
                             try:
                                 val = locarray.get_value(x, y)
-                                i, j = locarray.get_ij_from_xy(x, y)
 
-                                curpar = 'Indices (1-based)'
-                                self.mytooltip.myparams[curgroup][curpar] = {}
-                                self.mytooltip.myparams[curgroup][curpar]['name'] = 'Indice (i;j)'
-                                self.mytooltip.myparams[curgroup][curpar]['value'] = '(' + str(i + 1) + ';' + str(
-                                    j + 1) + ')'
-                                self.mytooltip.myparams[curgroup][curpar]['type'] = 'String'
-                                self.mytooltip.myparams[curgroup][curpar]['comment'] = ''
+                                if locarray.wolftype in WOLF_ARRAY_MB:
+                                    i, j, curbloc = locarray.get_blockij_from_xy(x, y)
+                                    curpar = 'Indices (i;j;bloc) (1-based)'
+
+                                    self.mytooltip.add_param(groupname = curgroup,
+                                                                name = curpar,
+                                                                value =  '(' + str(i+1) + ';' + str(j+1) + ';' + str(curbloc) + ')',
+                                                                type = Type_Param.String,
+                                                                comment = '')
+
+                                else:
+                                    i, j = locarray.get_ij_from_xy(x, y)
+                                    curpar = 'Indices (i;j) (1-based)'
+
+                                    self.mytooltip.add_param(groupname = curgroup,
+                                                                name = curpar,
+                                                                value =  '(' + str(i+1) + ';' + str(j+1) + ')',
+                                                                type = Type_Param.String,
+                                                                comment = '')
 
                                 curpar = 'Value'
-                                self.mytooltip.myparams[curgroup][curpar] = {}
-                                self.mytooltip.myparams[curgroup][curpar]['name'] = 'Value'
-                                self.mytooltip.myparams[curgroup][curpar]['value'] = val
-                                self.mytooltip.myparams[curgroup][curpar]['type'] = 'Float'
-                                self.mytooltip.myparams[curgroup][curpar]['comment'] = ''
+
+                                if val is np.nan:
+                                    self.mytooltip.add_param(groupname = curgroup,
+                                                            name = 'Value',
+                                                            value =  "Nan",
+                                                            type = Type_Param.String,
+                                                            comment = '')
+                                elif isinstance(val, str):
+                                    self.mytooltip.add_param(groupname = curgroup,
+                                                            name = curpar,
+                                                            value =  val,
+                                                            type = Type_Param.String,
+                                                            comment = '')
+                                elif isinstance(val, int):
+                                    self.mytooltip.add_param(groupname = curgroup,
+                                                            name = curpar,
+                                                            value =  int(val),
+                                                            type = Type_Param.Integer,
+                                                            comment = '')
+                                else:
+                                    self.mytooltip.add_param(groupname = curgroup,
+                                                            name = curpar,
+                                                            value =  float(val),
+                                                            type = Type_Param.Float,
+                                                            comment = '')
                             except:
                                 pass
 
+        for loc_ps in self.mypartsystems:
+            if loc_ps.checked:
+                curgroup = loc_ps.idx
+                try:
+                    self.mytooltip.add_param(groupname = curgroup,
+                                            name = _('Step [s]'),
+                                            value =  loc_ps.current_step,
+                                            type = Type_Param.Float,
+                                            comment = 'Step in seconds')
+                    self.mytooltip.add_param(groupname = curgroup,
+                                            name = _('Step [-]'),
+                                            value =  loc_ps.current_step_idx,
+                                            type = Type_Param.Integer,
+                                            comment = 'Step index')
+                except:
+                    pass
+
         self.mytooltip.PopulateOnePage()
 
 
@@ -5334,6 +6008,8 @@ class WolfMapViewer(wx.Frame):
             if self.action == 'dynamic parallel':
                 self.active_zone.parallel_active(self.dynapar_dist)
 
+            self.Refresh()
+
         self._last_mouse_pos = (x,y,pos)
         self._update_mytooltip()
 
@@ -5350,6 +6026,8 @@ class WolfMapViewer(wx.Frame):
         self.mytooltip.Show(True)
 
     def Autoscale(self, update_backfore=True):
+        """ Redimensionnement de la fenêtre pour afficher tous les objets """
+
         self.findminmax()
         self.width = self.xmax - self.xmin
         self.height = self.ymax - self.ymin
@@ -5377,13 +6055,19 @@ class WolfMapViewer(wx.Frame):
 
         if update_backfore:
             # dessin du background
-            for id, (key, curmap) in enumerate(self.added[draw_type.WMSBACK.value].items()):
-                if curmap['checked']:
-                    curmap['values'].reload()
+            for obj in self.iterator_over_objects(draw_type.WMSBACK):
+                obj.reload()
+
+            # for id, (key, curmap) in enumerate(self.added[draw_type.WMSBACK.value].items()):
+            #     if curmap['checked']:
+            #         curmap['values'].reload()
             # dessin du foreground
-            for id, (key, curmap) in enumerate(self.added[draw_type.WMSFORE.value].items()):
-                if curmap['checked']:
-                    curmap['values'].reload()
+            for obj in self.iterator_over_objects(draw_type.WMSFORE):
+                obj.reload()
+
+            # for id, (key, curmap) in enumerate(self.added[draw_type.WMSFORE.value].items()):
+            #     if curmap['checked']:
+            #         curmap['values'].reload()
 
         self.setbounds()
 
@@ -5394,7 +6078,6 @@ class WolfMapViewer(wx.Frame):
                 inside_under = 'inside' in self.action
                 self.action = None
 
-                self.active_vector.nbvertices = self.active_vector.nbvertices - 1
                 self.active_vector.myvertices.pop(-1)
 
                 if inside_under:
@@ -5405,13 +6088,11 @@ class WolfMapViewer(wx.Frame):
 
             if self.action == 'laz tmp vector':
                 self.action = None
-                self.active_vector.nbvertices = self.active_vector.nbvertices - 1
                 self.active_vector.myvertices.pop(-1)
                 self.plot_laz_around_active_vec()
 
             if self.action == 'create polygon - tiles':
                 self.action = None
-                self.active_vector.nbvertices = self.active_vector.nbvertices - 1
                 self.active_vector.myvertices.pop(-1)
                 self.active_vector.close_force()
 
@@ -5450,7 +6131,6 @@ class WolfMapViewer(wx.Frame):
 
             if self.action == 'capture vertices':
                 self.action = None
-                self.active_vector.nbvertices = self.active_vector.nbvertices - 1
                 self.active_vector.myvertices.pop(-1)
                 r = wx.MessageDialog(
                     None,
@@ -5471,7 +6151,6 @@ class WolfMapViewer(wx.Frame):
                 self.action = None
 
             if self.action == 'dynamic parallel':
-                self.active_vector.nbvertices -= 1
                 self.active_vector.myvertices.pop(-1)
                 self.active_zone.parallel_active(self.dynapar_dist)
 
@@ -5485,6 +6164,7 @@ class WolfMapViewer(wx.Frame):
 
         self.copyfrom = None
 
+        self.Refresh()
         self.mimicme()
 
     def OnHotKey(self, e: wx.KeyEvent):
@@ -5492,15 +6172,21 @@ class WolfMapViewer(wx.Frame):
         Gestion des touches clavier
             F1 : mise à jour du dernier pas de résultat
             F2 : mise à jour du résultat pas suivant
+            F4 : mise à jour du particle system au pas suivant
             Shift+F2 : mise à jour du résultat pas précédent
+            Shift+F4 : mise à jour du particle system au pas précédent
             CTRL+F2 : choix du pas
+            CTRL+F4 : choix du pas (particle system)
             CTRL+Shift+F2 : choix du pas sur base du temps
+            CTRL+Shift+F4 : choix du pas sur base du temps (particle system)
             F5 : autoscale
             F7 : refresh
             F9 : sélection de toutes les mailles dans la matrice courante
             F11 : sélection sur matrice courante
             F12 : opération sur matrice courante
 
+            ESPACE : pause/resume animation
+
             Z  : zoom avant
             z  : zoom artrière
             Flèches : déplacements latéraux
@@ -5557,6 +6243,7 @@ class WolfMapViewer(wx.Frame):
 
                     self.active_res2d.read_oneresult(nb-1)
                     self.active_res2d.set_currentview()
+                    self.Refresh()
 
                 else:
                     logging.info(_('Please activate a simulation before search a specific result'))
@@ -5584,10 +6271,57 @@ class WolfMapViewer(wx.Frame):
 
                     self.active_res2d.read_oneresult(choices.index(keyvalue))
                     self.active_res2d.set_currentview()
+                    self.Refresh()
+
+                else:
+                    logging.info(_('Please activate a simulation before searching a specific result'))
+
+            if key == wx.WXK_F4 and not e.ShiftDown():
+
+                if self.active_particle_system is not None:
+
+                    nb = self.active_particle_system.nb_steps
+                    dlg = wx.NumberEntryDialog(None,_('Please choose a step (1 -> {})'.format(nb)),'Step :', _('Select a specific step'), nb, min=1, max=nb)
+                    ret = dlg.ShowModal()
+
+                    nb = dlg.GetValue()
+                    dlg.Destroy()
+
+                    self.active_particle_system.current_step = nb-1
+                    self.Refresh()
+                    self._update_mytooltip()
+
+                else:
+                    logging.info(_('Please activate a particle system before searching a specific result'))
+
+            elif key == wx.WXK_F4 and e.ShiftDown():
+
+                if self.active_particle_system is not None:
+
+                    choices = ['{:.3f} [s] - {} [h:m:s]'.format(cur, timedelta(seconds=int(cur),
+                                                                   milliseconds=int(cur-int(cur))*1000))
+                               for cur in self.active_particle_system.get_times()]
+
+                    dlg = wx.SingleChoiceDialog(None,
+                                                _('Please choose a time step'),
+                                                _('Select a specific step'),
+                                                choices)
+                    ret = dlg.ShowModal()
+                    if ret == wx.ID_CANCEL:
+                        dlg.Destroy()
+                        return
+
+                    keyvalue = dlg.GetStringSelection()
+                    dlg.Destroy()
+
+                    self.active_particle_system.current_step = choices.index(keyvalue)
+                    self.Refresh()
+                    self._update_mytooltip()
 
                 else:
                     logging.info(_('Please activate a simulation before search a specific result'))
 
+
             elif key == 388: #+ from numpad
                 if self.active_res2d is not None:
                     self.active_res2d.update_zoom_2(1.1)
@@ -5709,6 +6443,16 @@ class WolfMapViewer(wx.Frame):
             if key == wx.WXK_DELETE:
                 self.removeobj()
 
+            elif key == wx.WXK_SPACE:
+                if self.timer_ps is not None and self.active_particle_system is not None :
+                    if self.timer_ps.IsRunning():
+                        self.timer_ps.Stop()
+                    else:
+                        if self.active_particle_system.current_step_idx == self.active_particle_system.nb_steps-1:
+                            self.active_particle_system.current_step_idx = 0
+                            self.active_particle_system.current_step = 0
+                        self.timer_ps.Start(1000. / self.active_particle_system.fps)
+
             elif key == 388: #+ from numpad
                 if self.active_res2d is not None:
                     self.active_res2d.update_arrowpixelsize_vectorfield(-1)
@@ -5747,6 +6491,12 @@ class WolfMapViewer(wx.Frame):
             elif key == wx.WXK_F2 and e.ShiftDown():
                 self.simul_previous_step()
 
+            elif key == wx.WXK_F4 and e.ShiftDown():
+                self.particle_previous_step()
+
+            elif key == wx.WXK_F4:
+                self.particle_next_step()
+
             elif key == wx.WXK_F2:
                 self.simul_next_step()
 
@@ -5841,27 +6591,55 @@ class WolfMapViewer(wx.Frame):
 
     def update(self):
         # dessin du background
-        for id, (key, curmap) in enumerate(self.added[draw_type.WMSBACK.value].items()):
-            if curmap['checked']:
-                curmap['values'].reload()
+        for obj in self.iterator_over_objects(draw_type.WMSBACK):
+            obj.reload()
+
+        # for id, (key, curmap) in enumerate(self.added[draw_type.WMSBACK.value].items()):
+        #     if curmap['checked']:
+        #         curmap['values'].reload()
         # dessin du foreground
-        for id, (key, curmap) in enumerate(self.added[draw_type.WMSFORE.value].items()):
-            if curmap['checked']:
-                curmap['values'].reload()
+        for obj in self.iterator_over_objects(draw_type.WMSFORE):
+            obj.reload()
+
+        # for id, (key, curmap) in enumerate(self.added[draw_type.WMSFORE.value].items()):
+        #     if curmap['checked']:
+        #         curmap['values'].reload()
 
         if self.locminmax.IsChecked() or self.update_absolute_minmax:
-            for id, (key, curmap) in enumerate(self.added['arrays'].items()):
-                if curmap['checked']:
-                    curarray: WolfArray
-                    curarray = curmap['values']
-                    if self.update_absolute_minmax:
-                        curarray.updatepalette()
-                        self.update_absolute_minmax = False
-                    else:
-                        curarray.updatepalette(onzoom=[self.xmin, self.xmax, self.ymin, self.ymax])
-                    curarray.delete_lists()
+            for curarray in self.iterator_over_objects(draw_type.ARRAYS):
+                curarray: WolfArray
+                if self.update_absolute_minmax:
+                    curarray.updatepalette()
+                    self.update_absolute_minmax = False
+                else:
+                    curarray.updatepalette(onzoom=[self.xmin, self.xmax, self.ymin, self.ymax])
+                curarray.delete_lists()
+
+            # for id, (key, curmap) in enumerate(self.added[draw_type.ARRAYS.value].items()):
+            #     if curmap['checked']:
+            #         curarray: WolfArray
+            #         curarray = curmap['values']
+            #         if self.update_absolute_minmax:
+            #             curarray.updatepalette()
+            #             self.update_absolute_minmax = False
+            #         else:
+            #             curarray.updatepalette(onzoom=[self.xmin, self.xmax, self.ymin, self.ymax])
+            #         curarray.delete_lists()
         self.Paint()
 
+    def _plotting(self, drawing_type: draw_type, checked_state: bool = True):
+        """ Drawing objets on canvas"""
+
+        try:
+            for curobj in self.iterator_over_objects(drawing_type, checked_state=checked_state):
+                if not curobj.plotting:
+                    curobj.plotting = True
+                    curobj.plot(sx = self.sx, sy=self.sy, xmin=self.xmin, ymin=self.ymin, xmax=self.xmax, ymax=self.ymax, size = (self.xmax - self.xmin) / 100.)
+                    curobj.plotting = False
+        except:
+            curobj.plotting = False
+            logging.error(_('Error while plotting objects of type {}').format(drawing_type.name))
+
     def Paint(self):
 
         if self.currently_readresults:
@@ -5890,92 +6668,38 @@ class WolfMapViewer(wx.Frame):
             glLoadIdentity()
 
             # dessin du background
-            for id, (key, curmap) in enumerate(self.added[draw_type.WMSBACK.value].items()):
-                if curmap['checked']:
-                    curmap['values'].paint()
+            self._plotting(draw_type.WMSBACK)
 
             # Dessin des matrices
-            try:
-                for curarray in self.added['arrays']:
-                    if self.added['arrays'][curarray]['checked']:
-                        locarray = self.added['arrays'][curarray]['values']
-                        if not locarray.plotting:
-                            locarray.plotting = True
-                            self.added['arrays'][curarray]['values'].plot(self.sx, self.sy, self.xmin, self.ymin,
-                                                                          self.xmax, self.ymax)
-                            locarray.plotting = False
-            except:
-                pass
+            self._plotting(draw_type.ARRAYS)
 
             # Dessin des résultats 2D
-            try:
-                for curarray in self.added['wolf2d']:
-                    if self.added['wolf2d'][curarray]['checked']:
-                        locarray = self.added['wolf2d'][curarray]['values']
-                        if not locarray.plotting:
-                            locarray.plotting = True
-                            self.added['wolf2d'][curarray]['values'].plot(self.sx, self.sy, self.xmin, self.ymin,
-                                                                          self.xmax, self.ymax)
-                            locarray.plotting = False
-            except:
-                pass
+            self._plotting(draw_type.RES2D)
 
             # Dessin des vecteurs
-            try:
-                for curvect in self.added['vectors']:
-                    if self.added['vectors'][curvect]['checked']:
-                        self.added['vectors'][curvect]['values'].plot()
-            except:
-                pass
+            self._plotting(draw_type.VECTORS)
 
             if self.active_vector is not None:
                 if self.active_vector.parentzone is None:
                     self.active_vector.plot()
 
             # Dessin des triangulations
-            try:
-                for curvect in self.added['triangulations']:
-                    if self.added['triangulations'][curvect]['checked']:
-                        self.added['triangulations'][curvect]['values'].plot()
-            except:
-                pass
+            self._plotting(draw_type.TRIANGULATION)
 
             # Dessin des nuages
-            try:
-                for curcloud in self.added['clouds']:
-                    if self.added['clouds'][curcloud]['checked']:
-                        self.added['clouds'][curcloud]['values'].plot()
-            except:
-                pass
+            self._plotting(draw_type.CLOUD)
 
             # Dessin des vues
-            try:
-                for curobj in self.added['views']:
-                    if self.added['views'][curobj]['checked']:
-                        curobj = self.added['views'][curobj]['values']
-                        curobj.plot(self.sx, self.sy, self.xmin, self.ymin,self.xmax, self.ymax)
-            except:
-                pass
+            self._plotting(draw_type.VIEWS)
 
-            # Dessin du reste
-            try:
-                for curobj in self.added['others']:
-                    if self.added['others'][curobj]['checked']:
-                        curobj = self.added['others'][curobj]['values']
-                        if type(curobj) is SPWDCENNGaugingStations or \
-                           type(curobj) is SPWMIGaugingStations or \
-                           type(curobj) is hydrometry_hece:
-                            curobj.plot((self.xmax - self.xmin) / 100.)
-                        elif type(curobj) is genericImagetexture:
-                            curobj.paint()
+            # Dessin des "particule systems"
+            self._plotting(draw_type.PARTICLE_SYSTEM)
 
-            except:
-                pass
+            # Dessin du reste
+            self._plotting(draw_type.OTHER)
 
             # Dessin du Front
-            for id, (key, curmap) in enumerate(self.added[draw_type.WMSFORE.value].items()):
-                if curmap['checked']:
-                    curmap['values'].paint()
+            self._plotting(draw_type.WMSFORE)
 
             # Gestion des BC (si actif)
             try:
@@ -5991,12 +6715,16 @@ class WolfMapViewer(wx.Frame):
                 'Opengl setcurrent -- maybe a conflict with an existing opengl32.dll file - please rename the opengl32.dll in the libs directory and retry')
 
     def OnPaint(self, e):
-
+        """ event handler for paint event"""
         self.Paint()
         if e is not None:
             e.Skip()
 
     def findminmax(self, force=False):
+        """ Find min/max of all objects """
+
+        # FIXME : use iterator
+
         xmin = 1.e30
         ymin = 1.e30
         xmax = -1.e30
@@ -6004,7 +6732,7 @@ class WolfMapViewer(wx.Frame):
 
         k = 0
         for locarray in self.myarrays:
-            if self.added['arrays'][locarray.idx]['checked'] or force:
+            if self.added[draw_type.ARRAYS][locarray.idx].checked or force:
                 xmin = min(locarray.origx + locarray.translx, xmin)
                 xmax = max(locarray.origx + locarray.translx + float(locarray.nbx) * locarray.dx, xmax)
                 ymin = min(locarray.origy + locarray.transly, ymin)
@@ -6012,7 +6740,7 @@ class WolfMapViewer(wx.Frame):
                 k += 1
 
         for locvector in self.myvectors:
-            if self.added['vectors'][locvector.idx]['checked'] or force:
+            if self.added[draw_type.VECTORS][locvector.idx].checked or force:
                 if locvector.idx != 'grid':
                     locvector.find_minmax()
                     if isinstance(locvector,Zones):
@@ -6033,7 +6761,7 @@ class WolfMapViewer(wx.Frame):
                     k += 1
 
         for locvector in self.mytiles:
-            if self.added['vectors'][locvector.idx]['checked'] or force:
+            if self.added[draw_type.VECTORS][locvector.idx].checked or force:
                 if locvector.idx != 'grid':
                     locvector.find_minmax()
                     if isinstance(locvector,Zones):
@@ -6054,7 +6782,7 @@ class WolfMapViewer(wx.Frame):
                     k += 1
 
         for loccloud in self.myclouds:
-            if self.added['clouds'][loccloud.idx]['checked'] or force:
+            if self.added['clouds'][loccloud.idx].checked or force:
                 loccloud.find_minmax(force)
                 xmin = min(loccloud.xbounds[0], xmin)
                 xmax = max(loccloud.xbounds[1], xmax)
@@ -6063,7 +6791,7 @@ class WolfMapViewer(wx.Frame):
                 k += 1
 
         for loctri in self.mytri:
-            if self.added['triangulations'][loctri.idx]['checked'] or force:
+            if self.added['triangulations'][loctri.idx].checked or force:
                 loctri.find_minmax(force)
                 xmin = min(loctri.minx, xmin)
                 xmax = max(loctri.maxx, xmax)
@@ -6073,7 +6801,7 @@ class WolfMapViewer(wx.Frame):
 
         for locres2d in self.myres2D:
             locres2d:Wolfresults_2D
-            if self.added['wolf2d'][locres2d.idx]['checked'] or force:
+            if self.added[draw_type.RES2D][locres2d.idx].checked or force:
                 locres2d.find_minmax(force)
                 xmin = min(locres2d.xmin, xmin)
                 xmax = max(locres2d.xmax, xmax)
@@ -6081,6 +6809,16 @@ class WolfMapViewer(wx.Frame):
                 ymax = max(locres2d.ymax, ymax)
                 k += 1
 
+        for locps in self.mypartsystems:
+            locps:Particle_system
+            if self.added[draw_type.PARTICLE_SYSTEM][locps.idx].checked or force:
+                locps.find_minmax(force)
+                xmin = min(locps.xmin, xmin)
+                xmax = max(locps.xmax, xmax)
+                ymin = min(locps.ymin, ymin)
+                ymax = max(locps.ymax, ymax)
+                k += 1
+
         for locview in self.myviews:
             locview.find_minmax(force)
             xmin = locview.xmin
@@ -6169,10 +6907,10 @@ class WolfMapViewer(wx.Frame):
         logging.info(_('Activating zone : ' + zone.myname))
 
     def list_background(self):
-        return self.added[draw_type.WMSBACK.value].keys()
+        return self.added[draw_type.WMSBACK].keys()
 
     def list_foreground(self):
-        return self.added[draw_type.WMSFORE.value].keys()
+        return self.added[draw_type.WMSFORE].keys()
 
     def check_id(self, id=str, gridsize = 100.):
         curobj = self.getobj(id)
@@ -6183,7 +6921,7 @@ class WolfMapViewer(wx.Frame):
 
         for curlist in self.added.values():
             if id in curlist.keys():
-                curlist[id]['checked'] = True
+                curlist[id].checked = True
 
         curobj.check_plot()
 
@@ -6202,7 +6940,7 @@ class WolfMapViewer(wx.Frame):
 
         for curlist in self.added.values():
             if id in curlist.keys():
-                curlist[id]['checked'] = False
+                curlist[id].checked = False
 
         if type(curobj) in [WolfArray, WolfArrayMB]:
             curobj.uncheck_plot(unload, forceresetOGL, askquestion)