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

wolfhece/PyParams.py

@@ -5,6 +5,9 @@ import os.path
 import json
 import logging
 from typing import Union, Literal
+from enum import Enum
+from copy import deepcopy
+import numpy as np
 
 try:
     from .PyTranslate import _
@@ -17,112 +20,290 @@ if not '_' in __builtins__:
 
 PARAM_TRUE = '.True.'
 PARAM_FALSE = '.False.'
-
-def new_json(values:dict, fullcomment:str=''):
+PREFIX_DEFAULT = 'def'
+
+class Type_Param(Enum):
+    """
+    Enum to define the type of a parameter
+
+    Strings are also used by Fortran Code -- modify with care
+    """
+    Integer_or_Float = 'Integer_or_Float'
+    Integer = 'integer'
+    Logical = 'Logical'
+    Float = 'Float'
+    File = 'File'
+    file = 'file'
+    Directory = 'Directory'
+    directory = 'directory'
+    Color = 'Color'
+    Fontname = 'Fontname'
+    String = 'String'
+    Empty = ''
+    Double = 'double'
+    Real = 'real'
+
+
+class key_Param(Enum):
+    """
+    Enum to define the keys of a parameter
+
+    """
+    NAME = 'name'
+    TYPE = 'type'
+    VALUE = 'value'
+    COMMENT = 'comment'
+    ADDED_JSON = 'added_json'
+
+class Buttons(Enum):
+    """ Enum to define the buttons """
+    Load = 'Load'
+    Save = 'Save'
+    Apply = 'Apply'
+    Reload = 'Reload'
+
+def new_json(values:dict, fullcomment:str='') -> dict:
+    """
+    Create a new JSON string from values and fullcomment
+
+    @param values : values to store in the JSON string - dict of key:value - value must be integer
+    @param fullcomment : full comment to store in the JSON string - str - can be multiline with \n
+    """
     return {"Values":values, "Full_Comment":fullcomment}
 
-#Gestion des paramètres au format WOLF
+def new_infos_incr(groupname:str= None, paramname:str='nb', min:int=1, max:int=100) -> tuple[str]:
+    """
+    Create a new string for an incrementable group or parameter
+
+    @param groupname : name of the reference group (optional) -- if ommitted, the reference group is in the same group as the parameter
+    @param paramname : name of the reference parameter
+    @param min : minimum value
+    @param max : maximum value
+    """
+    if groupname is None:
+        return paramname, str(min), str(max)
+    else:
+        return groupname, paramname, str(min), str(max)
+
+# FIXME : Généliser avec les dictionnaire avec Enum
+def search_type(chain:str) -> Type_Param:
+    """ recherche du typage dans une chaîne de caractères """
+
+    if chain.lower().find(Type_Param.Integer.value)>-1 and chain.find(Type_Param.Double.value)>-1:
+        return Type_Param.Integer_or_Float
+    elif chain.lower().find(Type_Param.Integer.value)>-1:
+        return Type_Param.Integer
+    elif chain.find(Type_Param.Logical.value)>-1:
+        return Type_Param.Logical
+    elif chain.find(Type_Param.Double.value)>-1 or chain.find('dble')>-1 or chain.find(Type_Param.Real.value)>-1:
+        return Type_Param.Float
+    elif chain.find('({})'.format(Type_Param.file))>-1:
+        return Type_Param.File
+    elif chain.find('({})'.format(Type_Param.directory))>-1 or chain.find('(dir)')>-1:
+        return Type_Param.Directory
+    else:
+        return Type_Param.String
+
+
 class Wolf_Param(wx.Frame):
-    #Définition des propriétés
-    filename:str
-    myparams:dict[str, dict]
-    myparams_default:dict[str, dict]
-    myIncGroup:dict
-    myIncParam:dict
-    prop:pg.PropertyGridManager
-    wx_exists:bool
+    """
+    **FR**
+        Gestion des paramètres au format WOLF.
 
-    def addparam(self,
-                 groupname='',
-                 name='',
-                 value='',
-                 type:Literal['Integer_or_Float',
-                              'Integer',
-                              'Logical',
-                              'Float',
-                              'File',
-                              'Directory',
-                              'Color',
-                              'Fontname',
-                              '']='',
-                 comment='',
-                 jsonstr=None,
-                 whichdict:Literal['All', 'Default', 'Active', '']=''):
-        """
-        Add or update a parameter
+        Fichier texte
+        -------------
 
-        @param groupname : groupe in which the new param will be strored - If it does not exist, it will be created
-        @param name      : param's name - If it does not exist, it will be created
-        @param value     : param'a value
-        @param type      : type -> will influence the GUI
-        @param comment   : param's comment -- helpful to understand the parameter
-        @param jsonstr   : string containing JSON data -- used in GUI
-        param whichdict  : where to store the param -- Default, Active or All
+        Les fichiers '*.param' sont des fichiers texte contenant des paramètres de type nom=valeur et compatibles avec les codes Fortran.
+        L'extension '.param.default' est utilisée pour stocker les paramètres par défaut.
 
-        jsonstr can be a dict i.e. '{"Values:{choice1:1, choice2:2, choice3:3}, Full_Comment:'Yeah baby !'}'
-        """
-        if whichdict=='All':
-            locparams=[self.myparams,self.myparams_default]
-        elif whichdict=='Default':
-            locparams=[self.myparams_default]
-        elif whichdict=='Active' or whichdict=='':
-            locparams=[self.myparams]
+        Une autre extension est possible mais un fichier '.default' sera créé automatiquement si ce fichier n'existe pas.
 
-        for curdict in locparams:
-            if not groupname in curdict.keys():
-                curdict[groupname]={}
+        Le séparateur (nom, valeur, commentaire) est la tabulation '\t'. Aucun autre caractère ne doit être utilisé comme séparateur.
 
-            if not name in curdict[groupname].keys():
-                curdict[groupname][name]={}
+        Les groupes sont définis par un nom suivi de ':'. Cela signifie que ':' ne peut pas être utilisé dans un nom de paramètre.
 
-            curpar=curdict[groupname][name]
+        Les lignes débutant par '%' sont des commentaires. Il est possible d'ajouter du code JSON dans un commentaire. Pour cela, il faut ajouter '%json' au début de la ligne suivi d'un dictionnaire (e.g. %json{"Values":{'key1':1, 'key2':2}, "Full_Comment":"fullcomment"} ).
 
-            curpar['name']=name
-            curpar['type']=type
-            curpar['value']=value
-            curpar['comment']=comment
+        Organisation Python
+        -------------------
 
-            if jsonstr is not None:
-                if isinstance(jsonstr, str):
-                    parsed_json = json.loads(jsonstr)
-                elif isinstance(jsonstr, dict):
-                    parsed_json = jsonstr
+        L'objet Python est basé sur des dictionnaires Python. Un dictionnaire par groupe de paramètres.
 
-                curpar['added_json']=parsed_json
+        Les paramètres sont donc stockés dans un dictionnaire de dictionnaires. Le premier niveau est le nom du groupe, le second niveau est le nom du paramètre.
 
-    def __getitem__(self, key):
-        """
-        Retrieve :
-          - value's parameter from group if key is a tuple or a list (group, param_name)
-          - group dict if key is a string
-        """
-        if isinstance(key, tuple) or isinstance(key, list):
-            group, name = key
-            return self.get_param(group, name)
-        elif isinstance(key, str):
-            return self.get_group(key)
+        Les paramètres disposent des clés suivantes :
+            - name : nom du paramètre (str)
+            - type : type du paramètre (str) -- see Type_Param
+            - value : valeur du paramètre (str) -- peut être converti dynamiquement en int, float, bool, str, ... sur base du type
+            - comment : commentaire du paramètre (str) -- helpful to understand the parameter
+            - added_json : dictionnaire contenant des informations supplémentaires (optionnel) -- permet de stocker des informations supplémentaires sur le paramètre (ex : valeurs possibles, commentaires étendus, ...)
 
-    def __setitem__(self, key, value):
-        """set item, key is a tuple or a list (group, param_name)"""
+        Dictionnaires
+        -------------
 
-        if isinstance(key, tuple) or isinstance(key, list):
-            group, name = key
-            if self.get_param(group, name) is not None:
-                self.change_param(group, name, value)
-            else:
-                self.addparam(group, name, value)
+        Il existe un dictionnaire de valeurs par défaut "myparams_default". Pour l'interaction Python-Fortran, c'est le Fortran qui écrit ces paramètres.
+        Il existe un dictionnaire de paramètres actifs "myparams". Il est utilisé pour stocker les paramètres modifiés par l'utilisateur. Normalement, seuls les paramètres modifiés par l'utilisateur sont stockés dans ce dictionnaire et sont écrits sur disque.
+
+        Groupe/Paramètre incrémentable
+        ------------------------------
+
+        Il est également possible de définir des groupes ou des paramètres incrémentables.
+        Pour cela, dans le nom du groupe/paramètre, il faut ajouter, à l'emplacement souhaité du **numéro** du groupe/paramètre, des informations entre '$...$' :
+            - groupname : nom du groupe (uniquement pour groupe incrémentable)
+            - paramname : nom du paramètre contenant le nombre de groupe/paramètre
+            - min : valeur minimale
+            - max : valeur maximale
+
+        Le nombre de groupes est ainsi défini par le couple (key:value) = (groupname:paramname). Le nombre de groupes doit donc être logiquement positionné dans un groupe distinct.
+        Le nombre de paramètres est ainsi défini par le paramètre "paramname" qui est attendu dans le groupe contenant le paramètre incrémentable.
+        Le nombre de groupes/paramètres est un entier compris entre 'min' et 'max'.
+
+        Les informations génériques sont stockées dans les dictionnaires "myIncGroup" et "myIncParam".
+
+        UI
+        --
+
+        Une interface graphique est disponible pour modifier les paramètres. Elle est basée sur "wxPython" et la classe "wxPropertyGrid".
+        L'attribut wx_exists permet de savoir si wxPython est en cours d'excution ou non.
+
+        Accès aux données
+        -----------------
+
+        Les paramètres sont accessibles via la procédure __getitem__ en fournissant un tuple (groupname, paramname).
+        Il est possible de modifier un paramètre via la procédure __setitem__.
+
+        Il est possible :
+            - d'ajoutrer un groupe via la procédure add_group. Pour un groupe incrémentabe, le nom doit contenir les infos génériques entre '$...$'.
+            - d'ajouter un paramètre ou un paramètre incrémentable via la procédure addparam :
+                - pour un paramètre classique en choisissant le dictionnaire cible ['All', 'Default', 'Active', 'IncGroup', '']
+                    - '' == 'Active'
+                    - 'All' == 'Default' + 'Active'
+                    - 'IncGroup' pour ajouter un paramètre au template du groupe incrémentable --> sera dupliqué lors de la MAJ du nompbre réel de groupes
+                - pour un paramètre incrémentable, en fournissant les données nécessaires dans une chaîne $n(refname,min,max)$ ou $n(groupname,refname,min,max)$
+                - si le groupe visé n'existe pas, il sera créé si toutes les infos sont disponibles.
+            - d'ajouter seulement un paramètre incrémentable via la procédure add_IncParam.
+
+    **EN**
+        Management of parameters in WOLF format.
+
+        Text File
+        ----------
+
+        '*.param' files are text files containing parameters in the name=value format and compatible with Fortran codes.
+        The '.param.default' extension is used to store default parameters.
+
+        Another extension is possible, but a '.default' file will be automatically created if this file does not exist.
+
+        The separator (name, value, comment) is the tab character '\t'. No other character should be used as a separator.
+
+        Groups are defined by a name followed by ':'. This means that ':' cannot be used in a parameter name.
+
+        Lines starting with '%' are comments. It is possible to add JSON code in a comment. To do this, add '%json' at the beginning of the line followed by a dictionary (e.g., %json{"Values":{'key1':1, 'key2':2}, "Full_Comment":"fullcomment"}).
+
+        Python Organization
+        -------------------
+
+        The Python object is based on Python dictionaries. One dictionary per parameter group.
+
+        Therefore, parameters are stored in a dictionary of dictionaries. The first level is the group name, and the second level is the parameter name.
+
+        Parameters have the following keys:
+            - name: parameter name (str)
+            - type: parameter type (str) -- see Type_Param
+            - value: parameter value (str) -- can be dynamically converted to int, float, bool, str, ... based on the type
+            - comment: parameter comment (str) -- helpful to understand the parameter
+            - added_json: dictionary containing additional information (optional) -- used to store additional information about the parameter (e.g., possible values, extended comments, ...)
+
+        Dictionaries
+        -------------
+
+        There is a default values dictionary "myparams_default." For Python-Fortran interaction, Fortran writes these parameters.
+        There is an active parameters dictionary "myparams." It is used to store parameters modified by the user. Normally, only parameters modified by the user are stored in this dictionary and written to disk.
+
+        Incrementable Group/Parameter
+        ------------------------------
+
+        It is also possible to define incrementable groups or parameters.
+        To do this, in the group/parameter name, add information between '$...$' at the desired **number** location of the group/parameter:
+            - groupname: group name (only for incrementable group)
+            - paramname: parameter name containing the group/parameter number
+            - min: minimum value
+            - max: maximum value
+
+        The number of groups is defined by the (key:value) pair (groupname:paramname). The number of groups must logically be positioned in a distinct group.
+        The number of parameters is defined by the "paramname" parameter expected in the group containing the incrementable parameter.
+        The number of groups/parameters is an integer between 'min' and 'max'.
+
+        Generic information is stored in the "myIncGroup" and "myIncParam" dictionaries.
+
+        UI
+        --
+
+        A graphical interface is available to modify parameters. It is based on "wxPython" and the "wxPropertyGrid" class.
+        The wx_exists attribute indicates whether wxPython is currently running or not.
+
+        Data Access
+        -----------------
+
+        Parameters are accessible via the __getitem__ method by providing a tuple (groupname, paramname).
+        It is possible to modify a parameter via the __setitem__ method.
+
+        It is possible to:
+            - add a group via the add_group method. For an incrementable group, the name must contain generic information between '$...$'.
+            - add a parameter or an incrementable parameter via the addparam method:
+                - for a regular parameter by choosing the target dictionary ['All', 'Default', 'Active', 'IncGroup', '']
+                    - '' == 'Active'
+                    - 'All' == 'Default' + 'Active'
+                    - 'IncGroup' to add a parameter to the template of the incrementable group --> will be duplicated when updating the actual number of groups
+                - for an incrementable parameter, by providing the necessary data in a string $n(refname,min,max)$ or $n(groupname,refname,min,max)$
+                - if the targeted group does not exist, it will be created if all information is available.
+            - only add an incrementable parameter via the add_IncParam method.
+```
+    """
+
+    # Définition des propriétés
+    filename:str                        # File name
+    myparams:dict[str, dict]            # dict for active parameters, see key_Param for keys
+    myparams_default:dict[str, dict]    # dict for default parameters, see key_Param for keys
+
+    myIncGroup:dict                     # dict for incrementable groups
+    myIncParam:dict                     # dict for incrementable parameters
+
+    prop:pg.PropertyGridManager         # wxPropertyGridManager -- see UI
+    wx_exists:bool                      # True if wxPython is running
 
-    #Initialisation
     def __init__(self,
-                 parent=None,
-                 title="Default Title",
-                 w=500, h=800,
-                 ontop=False,
-                 to_read=True,
-                 filename='',
-                 withbuttons=True,
-                 DestroyAtClosing=True,
-                 toShow=True):
+                 parent:wx.Window = None,
+                 title:str = "Default Title",
+                 w:int = 500,
+                 h:int = 800,
+                 ontop:bool   = False,
+                 to_read:bool = True,
+                 filename:str = '',
+                 withbuttons: bool = True,
+                 DestroyAtClosing:bool = True,
+                 toShow:bool = True,
+                 init_GUI:bool = True):
+        """
+        Initialisation
+
+        @param parent : parent frame (wx.Window)
+        @param title : title of the frame
+        @param w : width of the frame
+        @param h : height of the frame
+        @param ontop : if True, the frame will be on top of all other windows
+        @param to_read : if True, the file will be read
+        @param filename : filename to read
+        @param withbuttons : if True, buttons will be displayed
+        @param DestroyAtClosing : if True, the frame will be destroyed when closed
+        @param toShow : if True, the frame will be displayed
+
+
+        Callbacks (see 'set_callbacks'):
+            - callback : callback function when 'apply' is pressed
+            - callbackdestroy : callback function before destroying the frame
+
+        """
 
         # Initialisation des propriétés
         self.filename=filename
@@ -130,35 +311,98 @@ class Wolf_Param(wx.Frame):
         self.myparams_default={}
         self.myIncGroup={}
         self.myIncParam={}
+        self.update_incr_at_every_change = True
 
-        self._callback = None
-        self._callbackdestroy=None
+        self._callback:function = None
+        self._callbackdestroy:function = None
 
         self.wx_exists = wx.App.Get() is not None # test if wx App is running
+        self.show_in_active_if_default = False
 
         if to_read:
             self.ReadFile(filename)
 
-        if self.wx_exists:
-            self.set_gui(parent,title,w,h,ontop,to_read,withbuttons,DestroyAtClosing,toShow)
+        if self.wx_exists and init_GUI:
+            self._set_gui(parent,title,w,h,ontop,to_read,withbuttons,DestroyAtClosing,toShow)
+        else:
+            self.prop = None
+
+    def set_callbacks(self, callback_update, callback_destroy):
+        """ Set the callbacks for the update and destroy events """
+
+        self.callback = callback_update
+        self.callbackdestroy = callback_destroy
+
+    def get_nb_groups(self) -> tuple[int, int]:
+        """ Return the number of groups in active and default parameters """
+        return len(self.myparams.keys()), len(self.myparams_default.keys())
+
+    def get_nb_params(self, group:str) -> tuple[int, int]:
+        """ Return the number of parameters in a group in active and default parameters """
+        return len(self.myparams[group].keys()) if group in self.myparams.keys() else None, len(self.myparams_default[group].keys()) if group in self.myparams_default.keys() else None
+
+    def get_nb_inc_params(self) -> int:
+        """ Return the number of incrementable parameters """
+        return len(self.myIncParam.keys())
+
+    def get_nb_inc_groups(self) -> int:
+        """ Return the number of incrementable groups """
+        return len(self.myIncGroup.keys())
 
     @property
     def callback(self):
+        """ Return the callback function """
         return self._callback
 
     @callback.setter
     def callback(self, value):
+        """ Set the callback function """
         self._callback= value
 
     @property
     def callbackdestroy(self):
-        return self.callbackdestroy
+        """ Return the callback function """
+        return self._callbackdestroy
 
     @callbackdestroy.setter
     def callbackdestroy(self, value):
+        """ Set the callback function """
         self._callbackdestroy= value
 
-    def set_gui(self, parent=None, title="Default Title", w=500,h=800,ontop=False,to_read=True,withbuttons=True,DestroyAtClosing=True, toShow=True):
+    # GUI Events - WxPython
+    # ---------------------
+
+    def _set_gui(self,
+                parent:wx.Window = None,
+                title:str = "Default Title",
+                w:int = 500,
+                h:int = 800,
+                ontop:bool = False,
+                to_read:bool = True,
+                withbuttons:bool = True,
+                DestroyAtClosing:bool = True,
+                toShow:bool = True):
+        """
+        Set the GUI if wxPython is running
+
+        Gui is based on wxPropertyGridManager.
+
+        On the left, there is a group of buttons to load, save, apply or reload the parameters.
+        On the right, there is the wxPropertyGridManager for the default and active parameters. Active parameters are displayed in bold.
+
+        To activate a parameter, double-click on it in the default tab. It will be copied to the active tab and the value will be modifiable.
+
+        @param parent : parent frame
+        @param title : title of the frame
+        @param w : width of the frame
+        @param h : height of the frame
+        @param ontop : if True, the frame will be on top of all other windows
+        @param to_read : if True, the file will be read
+        @param withbuttons : if True, buttons will be displayed
+        @param DestroyAtClosing : if True, the frame will be destroyed when closed
+        @param toShow : if True, the frame will be displayed
+
+        """
 
         #Appel à l'initialisation d'un frame général
         if ontop:
@@ -221,677 +465,1116 @@ class Wolf_Param(wx.Frame):
 
         #ajout du sizert à la page
         self.SetSizer(self.sizer)
-        #self.SetSize(w,h)
+        # self.SetSize(w,h)
         self.SetAutoLayout(1)
         self.sizer.Fit(self)
 
         #affichage de la page
         self.Show(toShow)
 
-    def hide_selected_buttons(self):
-        """ Mask selected buttons but conserve 'Apply change'"""
-        self.sizerbut.Hide(self.loadme)
-        self.sizerbut.Hide(self.saveme)
-        # self.sizerbut.Hide(self.applychange)
-        self.sizerbut.Hide(self.reloadme)
+    def hide_selected_buttons(self, to_hide:list[Buttons] = [Buttons.Load, Buttons.Save, Buttons.Reload]):
+        """ Mask selected buttons - Default conserve only 'Apply change' """
+
+        for locbutton in to_hide:
+            if locbutton == Buttons.Load:
+                self.sizerbut.Hide(self.loadme)
+            elif locbutton == Buttons.Save:
+                self.sizerbut.Hide(self.saveme)
+            elif locbutton == Buttons.Reload:
+                self.sizerbut.Hide(self.reloadme)
+            elif locbutton == Buttons.Apply:
+                self.sizerbut.Hide(self.applychange)
 
-    #Gestion du double-click pour ajouter des éléments ou remise à valeur par défaut
-    def OnDblClick(self, event):
+    def OnDblClick(self, event:wx.MouseEvent):
+        """
+        Double-click event handler to add a parameter to the active tab or reset to default value.
+        Gestion du double-click pour ajouter des éléments ou remise à valeur par défaut.
+        """
 
-        #obtention de la propriété sur laquelle on a cliqué
+        # obtention de la propriété sur laquelle on a cliqué
         p = event.GetProperty()
-        #nom et valeur du paramètre
+        # nom et valeur du paramètre
         name = p.GetName()
-        val = p.GetValue()
+        from_default_page = name[0:3]==PREFIX_DEFAULT
+        # val = p.GetValue()
 
-        #nom du groupe
+        # nom du groupe
         group=p.GetParent()
         groupname=group.GetName()
 
-        #on se place sur la page des paramètres actifs
-        page = self.prop.GetPage(0)
-        if name[0:3]=='def':
-            propname = name[3+len(groupname):]
+        # on se place sur la page des paramètres actifs
+        page_active:pg.PropertyGridPage
+        page_active = self.prop.GetPage(0)
+        # on récupère le nom du paramètre sans le nom du groupe
+        if from_default_page:
+            paramname = name[3+len(groupname):]
         else:
-            propname = name[len(groupname):]
+            paramname = name[len(groupname):]
+
+        if not self.is_in_default(groupname):
+            logging.debug(_('Group {} not found in default parameters -- Maybe an incrementable group'.format(groupname)))
+            return
+
+        if not self.is_in_default(groupname, paramname):
+            logging.warning(_('Param {} not found in default parameters -- Maybe an incrementable param '.format(paramname)))
+            return
 
         #pointage vers le paramètre par défaut
-        param_def = self.myparams_default[groupname][propname]
+        param_def = self.myparams_default[groupname][paramname]
 
-        if name[0:3]=='def':
+        if from_default_page:
             #click depuis la page des param par défaut
 
             #essai pour voir si le groupe existe ou non dans les params actifs
-            try:
-                locgroup = self.myparams[groupname]
-            except:
-                locgroup=None
-
-            #si groupe non existant on ajoute
-            if locgroup is None:
-                page.Append(pg.PropertyCategory(groupname))
+            if not self.is_in_active(groupname):
+                page_active.Append(pg.PropertyCategory(groupname))
 
             #teste si param existe
-            try:
-                param = self.myparams[groupname][propname]
-            except:
-                param=None
-
-            if param is None:
-                #si non existant --> on ajoute, si existant --> rien
-                locname = groupname + propname
-                if 'added_json' in param_def.keys():
-                    list_keys = [ k for k in param_def['added_json']['Values'].keys()]
-                    list_values = [ k for k in param_def['added_json']['Values'].values()]
-                    page.AppendIn(groupname,pg.EnumProperty(propname,name=locname,labels=list_keys,values=list_values,value=int(param_def['value'])))
-                else:
-                    if param_def['type']=='Integer_or_Float':
-                        page.AppendIn(groupname,pg.IntProperty(propname,name=locname,value=float(param_def['value'])))
-                    elif param_def['type']=='Integer':
-                        page.AppendIn(groupname,pg.IntProperty(propname,name=locname,value=int(param_def['value'])))
-                    elif param_def['type']=='Logical':
-                        if param_def['value']=='.true.' or param_def['value']=='.True.':
-                            mybool=True
-                        elif param_def['value']=='.false.' or param_def['value']=='.False.':
-                            mybool=False
-                        page.AppendIn(groupname,pg.BoolProperty(propname,name=locname,value=mybool))
-                    elif param_def['type']=='Float':
-                        page.AppendIn(groupname,pg.FloatProperty(propname,name=locname,value=float(param_def['value'])))
-                    elif param_def['type']=='File':
-                        page.AppendIn(groupname,pg.FileProperty(propname,name=locname,value=param_def['value']))
-                    elif param_def['type']=='Directory':
-                        newobj=pg.DirProperty(locname,locname,value=param_def['value'])
-                        newobj.SetLabel(propname)
-                        page.Append(newobj)
-                    elif param_def['type']=='Color':
-                        page.AppendIn(groupname,pg.ColourProperty(propname,name=locname,value=param_def['value']))
-                    elif param_def['type']=='Fontname':
-                        page.AppendIn(groupname,pg.FontProperty(propname,name=locname,value=param_def['value']))
-                    else:
-                        page.AppendIn(groupname,pg.StringProperty(propname,name=locname,value=param_def['value']))
-
-                    try:
-                        self.prop.SetPropertyHelpString(locname,param_def['added_json']['Full_Comment'])
-                    except:
-                        self.prop.SetPropertyHelpString(locname,param_def['comment'])
+            if not self.is_in_active(groupname, paramname):
+                #si non existant --> on ajoute, si existant --> rien à faire
+                self._add_elem_to_page(page_active, groupname, param_def)
 
         else:
             #recopiage de la valeur par défaut
-            if param_def['type']=='Integer_or_Float':
-                self.prop.SetPropertyValue(groupname + propname,float(param_def['value']))
-            elif param_def['type']=='Integer':
-                self.prop.SetPropertyValue(groupname + propname,int(param_def['value']))
-            elif param_def['type']=='Logical':
-                if param_def['value']=='.true.' or param_def['value']=='.True.':
-                    mybool=True
-                elif param_def['value']=='.false.' or param_def['value']=='.False.':
-                    mybool=False
-                self.prop.SetPropertyValue(groupname + propname,mybool)
-            elif param_def['type']=='Float':
-                self.prop.SetPropertyValue(groupname + propname,float(param_def['value']))
-            elif param_def['type']=='File':
-                self.prop.SetPropertyValue(groupname + propname,param_def['value'])
-            elif param_def['type']=='Directory':
-                self.prop.SetPropertyValue(groupname + propname,param_def['value'])
-            elif param_def['type']=='Color':
-                self.prop.SetPropertyValue(groupname + propname,param_def['value'])
-            elif param_def['type']=='Fontname':
-                self.prop.SetPropertyValue(groupname + propname,param_def['value'])
-            else:
-                self.prop.SetPropertyValue(groupname + propname,param_def['value'])
+            defvalue = self.value_as_type(param_def[key_Param.VALUE],
+                                          param_def[key_Param.TYPE],
+                                          bool_as_int=True,
+                                          color_as=str)
+            self.prop.SetPropertyValue(groupname + paramname, defvalue)
+
+    def OnClose(self, event:wx.MouseEvent):
+        """ Close event of the frame """
+        if not self._callbackdestroy is None:
+            self._callbackdestroy()
 
-    def LoadFromFile(self,event):
-        self.myparams.clear()
-        self.myparams_default.clear()
+        if self.DestroyAtClosing:
+            self.Destroy()
+        else:
+            self.Hide()
+        pass
+
+    def SavetoFile(self, event:wx.MouseEvent):
+        """ sauvegarde dans le fichier texte """
+
+        with open(self.filename, 'w') as myfile:
+
+            for group in self.myparams.keys():
+                myfile.write(' ' + group +':\n')
+                for param_name in self.myparams[group].keys():
+                    myfile.write(param_name +'\t' + str(self.myparams[group][param_name][key_Param.VALUE])+'\n')
+
+            myfile.close()
+
+    def Reload(self, event:wx.MouseEvent):
+        """ relecture du fichier sur base du nom déjà connu """
+        if self.filename=='':
+            logging.warning(_('No filename given'))
+            return
+        self.Clear()
+        self.ReadFile(self.filename)
+        self.Populate()
+
+    def LoadFromFile(self, event:wx.MouseEvent):
+        """ Load parameters from file """
+
+        self.Clear()
+        # read the file
         self.ReadFile()
+        # populate the property grid
         self.Populate()
 
-    #Lecture d'un fichier .param
-    def ReadFile(self,*args):
-        if len(args)>0:
-            #s'il y a un argument on le prend tel quel
-            self.filename = str(args[0])
-        else:
-            #ouverture d'une boîte de dialogue
-            file=wx.FileDialog(self,"Choose .param file", wildcard="param (*.param)|*.param|all (*.*)|*.*")
-            if file.ShowModal() == wx.ID_CANCEL:
-                return
-            else:
-                #récuparétaion du nom de fichier avec chemin d'accès
-                self.filename =file.GetPath()
+    def ApplytoMemory(self, event:wx.MouseEvent):
+        """ Transfert des données en mémoire --> remplissage des dictionnaires """
 
-        haveDefaultParams = True
-        #idem pour les param par défaut le cas échéant
-        if os.path.isfile(self.filename + '.default') :
-            with open(self.filename+'.default', 'r') as myfile:
-                myparamsline = myfile.read().splitlines()
-                myfile.close()
-            self.ParseFile(myparamsline,self.myparams_default)
-        else:
-            haveDefaultParams = False
-
-        #lecture du contenu
-        if os.path.isfile(self.filename):
-            with open(self.filename, 'r') as myfile:
-                #split des lignes --> récupération des infos sans '\n' en fin de ligne
-                #  différent de .readlines() qui lui ne supprime pas les '\n'
-                myparamsline = myfile.read().splitlines()
-                myfile.close()
+        if self.prop.IsPageModified(0):
+            #on boucle sur tous les paramètres pour les ajouter au dictionnaire si non présents
+            for group in self.myparams_default.keys():
+                for param_name in self.myparams_default[group].keys():
+                    self._Apply1ParamtoMemory(group, param_name)
+            self._update_IncGroup(withGUI=True)
+            self._update_IncParam(withGUI=True)
+
+            if not self._callback is None:
+                self._callback()
         else:
-            logging.warning("ERROR : cannot find the following file :")
-            logging.warning(self.filename)
-            return
+            wx.MessageDialog(self,'Nothing to do!')
 
-        #conversion et remplissage du dictionnaire
-        self.ParseFile(myparamsline,self.myparams)
-        if(not(haveDefaultParams)):
-            self.ParseFile(myparamsline,self.myparams_default)
-            self.createDefaultFile()
+    def _Apply1ParamtoMemory(self,
+                             group:str,
+                             param_name:str,
+                             isIncrementable:bool=False,
+                             genGroup:str="",
+                             genParam:str=""):
+        """
+        Routine interne de MAJ d'un paramètre
 
-        self.Update_IncGroup()
-        self.Update_IncParam()
+        @param group : nom du groupe
+        @param param_name : nom du paramètre
+        @param isIncrementable : True si le paramètre est incrémentable
+        @param genGroup : generic name of an incrementable group
+        @param genParam : generic name of an incrementable param
 
-    #Parsing du fichier pour trouver groupes et paramètres et remplissage d'un dictionnaire
-    def ParseFile(self,myparamsline,todict):
+        """
 
-        for param in myparamsline:
-            if param.endswith(':'):
-                #création d'un dict sur base du nom de groupe, sans le :
-                curgroup = param.replace(':','')
-                curgroup = curgroup.strip()
-                #Par défaut un groupe n'est pas incrémentable
-                isInc = False
-                #On verifie si le groupe est incrémentable
-                curgroup,iterInfo = self.Extract_IncrInfo(curgroup)
-                # Groupe avec indice incrémentable
-                if iterInfo is not None:
-                    isInc = True
-                    iterGroup = iterInfo[0]
-                    iterParam = iterInfo[1]
-                    iterMin = iterInfo[2]
-                    iterMax = iterInfo[3]
-                    if not curgroup in self.myIncGroup:
-                        self.myIncGroup[curgroup] = {}
-                    # self.myIncGroup[curgroup] = {}
-                    self.myIncGroup[curgroup]["Ref group"] = iterGroup
-                    self.myIncGroup[curgroup]["Ref param"] = iterParam
-                    self.myIncGroup[curgroup]["Min"] = iterMin
-                    self.myIncGroup[curgroup]["Max"] = iterMax
-                    self.myIncGroup[curgroup]["Dict"] = {}
-                    if not "Saved" in self.myIncGroup[curgroup]:
-                        self.myIncGroup[curgroup]["Saved"] = {}
-                # Groupe classique
-                else:
-                    todict[curgroup]={}
-            elif param.startswith('%'):
-                #c'est du commentaire --> rien à faire sauf si c'est du code json
-                if param.startswith('%json'):
-                    #c'est du code json --> on le prend tel quel
-                    parsed_json = json.loads(param.replace('%json',''))
-                    curparam['added_json']=parsed_json
-            elif param.strip() == '':
-                if self.wx_exists:
-                    wx.LogWarning(_("WARNING : A void line is present where it should not be. Removing the blank line"))
-                else:
-                    logging.warning(_('A void line is present where it should not be. Removing the blank line'))
-                myparamsline.remove(param)
-            else:
-                #split sur base d'une tabulation
-                paramloc=param.split('\t')
-                #on enlève les espaces avant et après toutes les variables
-                for i in range(len(paramloc)) :
-                    paramloc[i] = paramloc[i].strip()
-                paramloc[0], iterInfo = self.Extract_IncrInfo(paramloc[0])
-                #le parametre courant est pas incrémentable -> ajout au dictionnaire particulier des paramètres
-                if iterInfo is not None:
-                    if not curgroup in self.myIncParam:
-                        self.myIncParam[curgroup] = {}
-                    if not paramloc[0] in self.myIncParam[curgroup]:
-                        self.myIncParam[curgroup][paramloc[0]] = {}
-                    # self.myIncParam[curgroup][paramloc[0]] = {}
-                    self.myIncParam[curgroup][paramloc[0]]["Group"] = curgroup
-                    if len(iterInfo)>1:
-                        self.myIncParam[curgroup][paramloc[0]]["Ref param"] = iterInfo[0]
-                        self.myIncParam[curgroup][paramloc[0]]["Min"] = iterInfo[1]
-                        self.myIncParam[curgroup][paramloc[0]]["Max"] = iterInfo[2]
-                        self.myIncParam[curgroup][paramloc[0]]["Dict"] = {}
-
-                    if not "Saved" in self.myIncParam[curgroup][paramloc[0]]:
-                        self.myIncParam[curgroup][paramloc[0]]["Saved"] = {}
-                        # self.myIncGroup[curgroup]["Dict"][paramloc[0]]=self.myIncParam[paramloc[0]]
-                        #pointage du param courant dans le dict de référence
-                    curparam=self.myIncParam[curgroup][paramloc[0]]["Dict"]
-                else:
-                    #on verifie si le groupe est incrémentable pour pointer vers le bon dictionnaire
-                    if isInc:
-                        #création d'un dict sur base du nom de paramètre
-                        self.myIncGroup[curgroup]["Dict"][paramloc[0]]={}
-                        #pointage du param courant dans le dict de référence
-                        curparam=self.myIncGroup[curgroup]["Dict"][paramloc[0]]
-                    else:
-                        #création d'un dict sur base du nom de paramètre
-                        todict[curgroup][paramloc[0]]={}
-                        #pointage du param courant dans le dict
-                        curparam=todict[curgroup][paramloc[0]]
+        assert self.wx_exists, "wxPython is not running"
 
-                #ajout de la valeur et du commentaire
-                curparam['value']=paramloc[1]
-                try:
-                    curparam['comment']=paramloc[2]
-
-                    #recherche du typage
-                    if paramloc[2].find('integer')>-1 and paramloc[2].find('double')>-1:
-                        curparam['type']='Integer_or_Float'
-                    elif paramloc[2].find('integer')>-1:
-                        curparam['type']='Integer'
-                    elif paramloc[2].find('logical')>-1:
-                        curparam['type']='Logical'
-                    elif paramloc[2].find('double')>-1 or param.find('dble')>-1 or param.find('real')>-1:
-                        curparam['type']='Float'
-                    elif paramloc[2].find('(file)')>-1:
-                        curparam['type']='File'
-                    elif paramloc[2].find('(directory)')>-1 or param.find('(dir)')>-1:
-                        curparam['type']='Directory'
-                    else:
-                        if not 'type' in curparam:
-                            curparam['type'] = None
-
-                    try:
-                        param_def=self.myparams_default[curgroup][paramloc[0]]
-                        curparam['type']=param_def['type']
-                    except:
-                        pass
-                except:
-                    curparam['comment']=''
-                    if not 'type' in curparam:
-                        curparam['type'] = None
+        if isIncrementable:
+            if(genParam != ""):
+                if(genGroup != ""):
+                    dict_param_def = self.myIncParam[genGroup][genParam]["Dict"][genParam]
+                else:
+                    dict_param_def = self.myIncParam[group][genParam]["Dict"]
 
-    #Remplissage de l'objet de gestion de propriétés sur base des dictionnaires
-    def Populate(self):
-        #gestion des paramètres actifs
-        try:
-            self.prop.Clear()
-        except:
-            pass
-        page = self.prop.AddPage("Active Parameters")
-        page = self.prop.AddPage("Default Parameters")
+            elif(genGroup != ""):
+                dict_param_def = self.myIncGroup[genGroup]["Dict"][param_name]
 
-        page = self.prop.GetPage(self.prop.GetPageByName("Active Parameters"))
+        else:
+            dict_param_def = self.myparams_default[group][param_name]
 
-        if len(self.myparams)>0:
-            for group in self.myparams.keys():
-                page.Append(pg.PropertyCategory(group))
+        if self.is_in_default(group, param_name):
 
-                for param_name in self.myparams[group].keys():
+            # récupératrion de la valeur par défaut
+            val_default = self.prop.GetPropertyByName(PREFIX_DEFAULT + group + param_name).m_value
 
-                    param=self.myparams[group][param_name]
-                    locname=group + param_name
+            # on tente de rcupérer la valeur active mais il ets possible qu'elle n'existe pas si sa valeur est identique à la valeur par défaut
+            if self.is_in_active(group, param_name):
+                val_active  = self.prop.GetPropertyByName(group + param_name).m_value
+            else:
+                val_active = val_default
 
-                    try:
-                        #on donne priorité aux données (type, commentaire) du groupe par défaut mais on utilise la valeur des paramètres actifs
-                        param_def=self.myparams_default[group][param_name]
-                        if 'added_json' in param_def.keys():
-                            list_keys = [ k for k in param_def['added_json']['Values'].keys()]
-                            list_values = [ k for k in param_def['added_json']['Values'].values()]
-                            page.Append(pg.EnumProperty(param_name,name=locname,labels=list_keys,values=list_values,value=int(float(param['value']))))
-                        else:
-                            if param_def['type']=='Integer_or_Float':
-                                page.Append(pg.IntProperty(label=param_name,name=locname,value=float(param['value'])))
-                            elif param_def['type']=='Integer':
-                                page.Append(pg.IntProperty(label=param_name,name=locname,value=int(param['value'])))
-                            elif param_def['type']=='Logical':
-                                if param['value']=='.true.' or param['value']=='.True.':
-                                    mybool=True
-                                elif param['value']=='.false.' or param['value']=='.False.':
-                                    mybool=False
-                                elif param['value']==False or param['value']=='false':
-                                    mybool=False
-                                elif param['value']==True or param['value']=='true':
-                                    mybool=True
-                                page.Append(pg.BoolProperty(label=param_name,name=locname,value=mybool))
-                            elif param_def['type']=='Float':
-                                page.Append(pg.FloatProperty(label=param_name,name=locname,value=float(param['value'])))
-                            elif param_def['type']=='File':
-                                page.Append(pg.FileProperty(label=param_name,name=locname,value=param['value']))
-                            elif param_def['type']=='Directory':
-                                newobj=pg.DirProperty(locname,locname,value=param['value'])
-                                newobj.SetLabel(param_name)
-                                page.Append(newobj)
-                            elif param_def['type']=='Color':
-                                page.Append(pg.ColourProperty(label=param_name,name=locname,value=param['value']))
-                            elif param_def['type']=='Fontname':
-                                page.Append(pg.FontProperty(label=param_name,name=locname,value=param['value']))
-                            else:
-                                page.Append(pg.StringProperty(label=param_name,name=locname,value=param['value']))
-                    except:
-                        #si le groupe par défaut n'a pas de groupe équivalent, on lit les élément du groupe actif
-                        if 'added_json' in param.keys():
-                            list_keys = [ k for k in param['added_json']['Values'].keys()]
-                            list_values = [ k for k in param['added_json']['Values'].values()]
-                            page.Append(pg.EnumProperty(label=param_name,name=locname,labels=list_keys,values=list_values,value=int(param['value'])))
-                        else:
-                            if param['type']=='Integer_or_Float':
-                                page.Append(pg.IntProperty(label=param_name,name=locname,value=float(param['value'])))
-                            elif param['type']=='Integer':
-                                page.Append(pg.IntProperty(label=param_name,name=locname,value=int(param['value'])))
-                            elif param['type']=='Logical':
-                                if param['value']=='.true.' or param['value']=='.True.':
-                                    mybool=True
-                                elif param['value']=='.false.' or param['value']=='.False.':
-                                    mybool=False
-                                elif param['value']==False or param['value']=='false':
-                                    mybool=False
-                                elif param['value']==True or param['value']=='true':
-                                    mybool=True
-                                page.Append(pg.BoolProperty(label=param_name,name=locname,value=mybool))
-                            elif param['type']=='Float':
-                                page.Append(pg.FloatProperty(label=param_name,name=locname,value=float(param['value'])))
-                            elif param['type']=='File':
-                                page.Append(pg.FileProperty(label=param_name,name=locname,value=param['value']))
-                            elif param['type']=='Directory':
-                                newobj=pg.DirProperty(locname,locname,value=param['value'])
-                                newobj.SetLabel(param_name)
-                                page.Append(newobj)
-                            elif param['type']=='Color':
-                                page.Append(pg.ColourProperty(label=param_name,name=locname,value=param['value']))
-                            elif param['type']=='Fontname':
-                                page.Append(pg.FontProperty(label=param_name,name=locname,value=param['value']))
-                            else:
-                                page.Append(pg.StringProperty(label=param_name,name=locname,value=param['value']))
-
-                    try:
-                        self.prop.SetPropertyHelpString(locname,param_def['added_json']['Full_Comment'])
-                    except:
-                        try:
-                            self.prop.SetPropertyHelpString(locname,param_def['comment'])
-                        except:
-                            self.prop.SetPropertyHelpString(locname,param['comment'])
+            val_active  = self.value_as_type(val_active, dict_param_def[key_Param.TYPE])
+            val_default = self.value_as_type(val_default, dict_param_def[key_Param.TYPE])
 
-        #gestion des paramètres par défaut
-        page = self.prop.GetPage(self.prop.GetPageByName("Default Parameters"))
+            if val_active != val_default:
+                self[(group, param_name)] = val_active
+            else:
+                logging.debug(_('Parameter {} not modified'.format(param_name)))
 
-        if len(self.myparams_default)>0:
-            for group in self.myparams_default.keys():
-                page.Append(pg.PropertyCategory(group))
+        else:
+            # La valeur par défaut n'existe pas --> on prend la valeur active car c'est certainement une valeur incrémentable ou d'un groupe incrémentable
+            # Si la valeur n'est pas présente, on ne fait rien
+            if self.is_in_active(group, param_name):
+                val_active  = self.prop.GetPropertyByName(group + param_name).m_value
+                val_active  = self.value_as_type(val_active, dict_param_def[key_Param.TYPE])
 
-                for param_name in self.myparams_default[group].keys():
+                self[(group, param_name)] = val_active
+            else:
+                logging.debug(_('Parameter {} not found in default parameters'.format(param_name)))
 
-                    param=self.myparams_default[group][param_name]
-                    locname='def' + group + param_name
+    def position(self,position):
+        """ Position the frame """
+        self.SetPosition(wx.Point(position[0],position[1]+50))
 
-                    addJson=False
-                    if 'added_json' in param.keys():
-                        addJson=True
+    def Populate(self):
+        """
+        Filling the property management object based on dictionaries
 
-                    if addJson:
-                        list_keys = [ k for k in param['added_json']['Values'].keys()]
-                        list_values = [ k for k in param['added_json']['Values'].values()]
-                        page.Append(pg.EnumProperty(param_name,name=locname,labels=list_keys,values=list_values,value=int(float(param['value']))))
-                    else:
-                        if param['type']=='Integer_or_Float':
-                            page.Append(pg.IntProperty(label=param_name,name=locname,value=float(param['value'])))
-                        elif param['type']=='Integer':
-                            page.Append(pg.IntProperty(label=param_name,name=locname,value=int(param['value'])))
-                        elif param['type']=='Logical':
-                            if param['value']=='.true.' or param['value']=='.True.':
-                                mybool=True
-                            elif param['value']=='.false.' or param['value']=='.False.':
-                                mybool=False
-                            elif param['value']==False or param['value']=='false':
-                                mybool=False
-                            elif param['value']==True or param['value']=='true':
-                                mybool=True
-                            page.Append(pg.BoolProperty(label=param_name,name=locname,value=mybool))
-                        elif param['type']=='Float':
-                            page.Append(pg.FloatProperty(label=param_name,name=locname,value=float(param['value'])))
-                        elif param['type']=='File':
-                            page.Append(pg.FileProperty(label=param_name,name=locname,value=param['value']))
-                        elif param['type']=='Directory':
-                            newobj=pg.DirProperty(locname,locname,value=param['value'])
-                            newobj.SetLabel(param_name)
-                            page.Append(newobj)
-                        elif param['type']=='Color':
-                            page.Append(pg.ColourProperty(label=param_name,name=locname,value=param['value']))
-                        elif param_def['type']=='Fontname':
-                            page.Append(pg.FontProperty(label=param_name,name=locname,value=param['value']))
-                        else:
-                            page.Append(pg.StringProperty(label=param_name,name=locname,value=param['value']))
+        Use default AND active parameters
 
-                    try:
-                        self.prop.SetPropertyHelpString(locname,param['added_json']['Full_Comment'])
-                    except:
-                        self.prop.SetPropertyHelpString(locname,param['comment'])
+        Useful only if wxPython is running
+        """
 
-        # Display a header above the grid
-        self.prop.ShowHeader()
-        self.prop.Refresh()
+        if self.prop is None:
+            logging.error("ERROR : wxPython is not running - Impossible to populate the property grid")
+            return
 
-    def PopulateOnePage(self):
-        #gestion des paramètres actifs
         self.prop.Clear()
-        page = self.prop.AddPage("Current")
-
-        if len(self.myparams)>0:
-            for group in self.myparams.keys():
-                page.Append(pg.PropertyCategory(group))
 
-                for param_name in self.myparams[group].keys():
-
-                    param=self.myparams[group][param_name]
-                    locname=group + param_name
+        page_active:pg.PropertyGridPage
+        page_default:pg.PropertyGridPage
+        page_active = self.prop.AddPage(_("Active Parameters"))
+        page_default = self.prop.AddPage(_("Default Parameters"))
 
-                    if 'added_json' in param.keys():
-                        list_keys = [ k for k in param['added_json']['Values'].keys()]
-                        list_values = [ k for k in param['added_json']['Values'].values()]
-                        page.Append(pg.EnumProperty(param_name,name=locname,labels=list_keys,values=list_values,value=int(param['value'])))
-                    else:
-                        if param['type']=='Integer_or_Float':
-                            page.Append(pg.IntProperty(label=param_name,name=locname,value=float(param['value'])))
-                        elif param['type']=='Integer':
-                            page.Append(pg.IntProperty(label=param_name,name=locname,value=int(param['value'])))
-                        elif param['type']=='Logical':
-                            if param['value']=='.true.' or param['value']=='.True.':
-                                mybool=True
-                            elif param['value']=='.false.' or param['value']=='.False.':
-                                mybool=False
-                            page.Append(pg.BoolProperty(label=param_name,name=locname,value=mybool))
-                        elif param['type']=='Float':
-                            page.Append(pg.FloatProperty(label=param_name,name=locname,value=float(param['value'])))
-                        elif param['type']=='File':
-                            page.Append(pg.FileProperty(label=param_name,name=locname,value=param['value']))
-                        elif param['type']=='Directory':
-                            newobj=pg.DirProperty(locname,locname,value=param['value'])
-                            newobj.SetLabel(param_name)
-                            page.Append(newobj)
-                        elif param['type']=='Color':
-                            page.Append(pg.ColourProperty(label=param_name,name=locname,value=param['value']))
-                        elif param['type']=='Fontname':
-                            page.Append(pg.FontProperty(label=param_name,name=locname,value=param['value']))
-                        else:
-                            page.Append(pg.StringProperty(label=param_name,name=locname,value=param['value']))
+        #gestion des paramètres actifs
+        for group, params in self.myparams.items():
+            page_active.Append(pg.PropertyCategory(group))
+            for param_name, param in params.items():
+                param:dict
+                if self.is_in_default(group, param_name):
+                    param_def = self.myparams_default[group][param_name]
+
+                    if self.show_in_active_if_default:
+                        self._add_elem_to_page(page_active, group, param, param_def = param_def)
+                    elif param[key_Param.VALUE] != param_def[key_Param.VALUE]:
+                        self._add_elem_to_page(page_active, group, param, param_def = param_def)
+                else:
+                    logging.debug(_('Parameter {} not found in default parameters'.format(param_name)))
+                    param_def = None
+                    self._add_elem_to_page(page_active, group, param, param_def = param_def)
 
-                    if 'added_json' in param.keys():
-                        self.prop.SetPropertyHelpString(locname,param['added_json']['Full_Comment'])
-                    else:
-                        self.prop.SetPropertyHelpString(locname,param['comment'])
+        #gestion des paramètres par défaut
+        for group, params in self.myparams_default.items():
+            page_default.Append(pg.PropertyCategory(group))
+            for param_name, param in params.items():
+                param:dict
+                self._add_elem_to_page(page_default, group, param, prefix = PREFIX_DEFAULT)
 
         # Display a header above the grid
         self.prop.ShowHeader()
         self.prop.Refresh()
 
-    #sauvegarde dans le fichier texte
-    def SavetoFile(self,event):
-        # self.ApplytoMemory(0)
+    def _add_elem_to_page(self, page:pg.PropertyGridPage, group:str, param:dict, param_def:dict = None, prefix:str=''):
+        """ Add an element to a page """
 
-        with open(self.filename, 'w') as myfile:
+        param_name = param[key_Param.NAME]
+        locname = prefix + group + param_name
 
-            for group in self.myparams.keys():
-                myfile.write(' ' + group +':\n')
-                for param_name in self.myparams[group].keys():
-                    myfile.write(param_name +'\t' + str(self.myparams[group][param_name]['value'])+'\n')
+        if param_def is not None:
+            # priority to default parameters
+            if key_Param.ADDED_JSON in param_def.keys():
+                param[key_Param.ADDED_JSON] = param_def[key_Param.ADDED_JSON]
+            param[key_Param.COMMENT] = param_def[key_Param.COMMENT]
+            param[key_Param.TYPE] = param_def[key_Param.TYPE]
 
-            myfile.close()
+        if key_Param.ADDED_JSON in param.keys() and param[key_Param.ADDED_JSON] is not None:
+            # Ajout des choix via chaîne JSON
+            list_keys   = [ k for k in param[key_Param.ADDED_JSON]['Values'].keys()]
+            list_values = [ k for k in param[key_Param.ADDED_JSON]['Values'].values()]
 
-    #relecture du fichier sur base du nom déjà connu
-    def Reload(self,event):
-        self.myparams.clear()
-        self.myparams_default.clear()
-        self.ReadFile(self.filename)
-        self.Populate()
+            page.Append(pg.EnumProperty(param_name, name=locname, labels=list_keys, values=list_values, value=int(param[key_Param.VALUE])))
 
-    #Transfert des données en mémoire --> remplissage des dictionnaires
-    def ApplytoMemory(self,event):
+            self.prop.SetPropertyHelpString(locname , param[key_Param.ADDED_JSON]['Full_Comment'])
+        else:
 
-        #on vide le dictionnaire des paramètres actifs
-        self.myparams={}
+            locvalue = self[(group, param_name)]
 
-        if self.prop.IsPageModified:
-            #on boucle sur tous les paramètres du défault
-            for group in self.myparams_default.keys():
-                groupexists = False
-                for param_name in self.myparams_default[group].keys():
-                    groupexists = self.Apply1ParamtoMemory(group, param_name, groupexists=groupexists)
+            if isinstance(locvalue, float):
+                page.Append(pg.FloatProperty(label = param_name, name = locname, value = locvalue))
 
+            elif isinstance(locvalue, int):
+                # bool is also an int
+                if isinstance(locvalue, bool):
+                    page.Append(pg.BoolProperty(label=param_name, name = locname, value = locvalue))
+                else:
+                    page.Append(pg.IntProperty(label = param_name, name = locname, value = locvalue))
 
-            if not self._callback is None:
-                self._callback()
-            self.Update_IncGroup(withGUI=True)
-            self.Update_IncParam(withGUI=True)
-        else:
-            wx.MessageDialog(self,'Nothing to do!')
+            elif param[key_Param.TYPE]==Type_Param.File:
+                page.Append(pg.FileProperty(label=param_name, name = locname, value = param[key_Param.VALUE]))
 
-    def position(self,position):
-        self.SetPosition(wx.Point(position[0],position[1]+50))
+            elif param[key_Param.TYPE]==Type_Param.Directory:
+                page.Append(pg.DirProperty(label = param_name, name = locname, value = locvalue))
+                # newobj.SetLabel(param_name)
+                # page.Append(newobj)
 
-    def OnClose(self, event):
-        if not self._callbackdestroy is None:
-            self._callbackdestroy()
+            elif param[key_Param.TYPE]==Type_Param.Color:
+                page.Append(pg.ColourProperty(label = param_name, name = locname, value = locvalue))
 
-        if self.DestroyAtClosing:
-            self.Destroy()
-        else:
-            self.Hide()
-        pass
+            elif param[key_Param.TYPE]==Type_Param.Fontname:
+                page.Append(pg.FontProperty(label = param_name, name = locname, value = locvalue))
 
-    def createDefaultFile(self):
+            else:
+                page.Append(pg.StringProperty(label = param_name, name = locname, value = locvalue))
 
-        with open(self.filename+'.default', 'w') as myfile:
+            self.prop.SetPropertyHelpString(locname, param[key_Param.COMMENT])
 
-            for group in self.myparams.keys():
-                myfile.write(' ' + group +':\n')
-                for param_name in self.myparams[group].keys():
-                    myfile.write(param_name +'\t' + str(self.myparams[group][param_name]['value'])+'\n')
+    def PopulateOnePage(self):
+        """
+        Filling the property management object based on dictionaries
 
-            myfile.close()
+        Use ONLY active parameters
 
+        Useful only if wxPython is running -- e.g. class "PyDraw"
+        """
 
-    # Returns the value of the parameter if found, otherwise None obj
-    def get_param(self, group, name):
+        if self.prop is None:
+            logging.error("ERROR : wxPython is not running - Impossible to populate the property grid")
+            return
 
-        try:
-            element = self.myparams[group][name]["value"]
-        except:
-            try:
-                element = self.myparams_default[group][name]["value"]
-            except:
-                element  = None
-                return element
+        #gestion des paramètres actifs
+        self.prop.Clear()
+        page:pg.PropertyGridPage
+        page = self.prop.AddPage("Current")
 
-        # String conversion according to its type
-        try:
-            curType = self.myparams[group][name]["type"]
-            if curType is None:
-                curType = self.myparams_default[group][name]["type"]
-                if curType is None:
-                    curType = 'String'
-        except:
-            try:
-                curType = self.myparams_default[group][name]["type"]
-            except:
-                curType = 'String'
+        for group, params in self.myparams.items():
+            page.Append(pg.PropertyCategory(group))
+            for param_name, param in params.items():
+                param:dict
+                self._add_elem_to_page(page, group, param)
 
+        # Display a header above the grid
+        self.prop.ShowHeader()
+        self.prop.Refresh()
 
-        if curType == 'Integer':
-            element = int(element)
-        elif curType == 'Logical':
-            element = bool(element)
-        elif curType == 'Float':
-            element = float(element)
-        elif curType == 'Integer_or_Float':
-            element = float(element)
-        elif curType == 'Color':
-            if isinstance(element,str):
-                element = element.replace('(','')
-                element = element.replace(')','')
-                element = element.split(',')
 
-        return element
+    # File management
+    # ---------------
 
+    def check_default_file(self, filename:str):
+        """ Check if a default file exists """
 
-    # Return the group dictionnary if found, otherwise None obj
-    def get_group(self, group) -> dict:
+        if os.path.isfile(filename + '.default'):
+            return True
+        else:
+            return False
 
-        try:
-            element = self.myparams[group]
-        except:
-            element = None
+    def ReadFile(self,*args):
+        """ Lecture d'un fichier .param et remplissage des dictionnaires myparams et myparams_default """
 
-        return element
+        if len(args)>0:
+            #s'il y a un argument on le prend tel quel
+            self.filename = str(args[0])
+        else:
+            if self.wx_exists:
+                #ouverture d'une boîte de dialogue
+                file=wx.FileDialog(self,"Choose .param file", wildcard="param (*.param)|*.param|all (*.*)|*.*")
+                if file.ShowModal() == wx.ID_CANCEL:
+                    return
+                else:
+                    #récuparétaion du nom de fichier avec chemin d'accès
+                    self.filename =file.GetPath()
+            else:
+                logging.warning("ERROR : no filename given and wxPython is not running")
+                return
 
+        if not os.path.isfile(self.filename):
+            logging.warning("ERROR : cannot find the following file : {}".format(self.filename))
+            return
 
-    def change_param(self, group, name, value):
-        #essai pour voir si le groupe existe ou non dans les params actifs
-        try:
-            locgroup = self.myparams[group]
-        except:
-            locgroup=None
+        myparamsline_default = None
+        if self.check_default_file(self.filename):
+            with open(self.filename+'.default', 'r') as myfile:
+                myparamsline_default = myfile.read()
+
+        # lecture du contenu
+        with open(self.filename, 'r') as myfile:
+            myparamsline = myfile.read()
+
+        self.fill_from_strings(myparamsline, myparamsline_default)
+
+        if not self.check_default_file(self.filename):
+            self._CreateDefaultFile()
+
+    def fill_from_strings(self, chain:str, chaindefault:str = None):
+        """ Fill the dictionaries from a string """
+
+        myparamsline = chain.splitlines()
+        self.ParseFile(myparamsline,self.myparams)
+
+        if chaindefault is not None:
+            myparamsline = chaindefault.splitlines()
+
+        self.ParseFile(myparamsline,self.myparams_default)
+
+        # mise à jour des groupes incrémentables et des paramètres incrémentables
+        self._update_IncGroup()
+        self._update_IncParam()
+
+    def ParseFile(self, myparamsline:list[str], todict:dict):
+        """
+        Parsing the file to find groups and parameters and filling a dictionary
+
+        Each parameter is stored in a dictionary associated to the upper group.
+
+        'add_group' is used to add a group in the dictionary 'todict'.
+        'groupname' will be there sanitized (strip, decoded if iteratable...) to be used in '_add_param_from_str'.
+
+        myparamsline format:
+            ['groupname1:', 'param1', 'param2', 'groupname2:', 'param1', ...]
+
+        """
+
+        if isinstance(myparamsline, str):
+            logging.warning("ERROR : myparamsline must be a list of strings -- forcing conversion")
+            myparamsline = myparamsline.splitlines()
+
+        for param in myparamsline:
+            if param.endswith(':'):
+                # GROUPE
+                # ------
+
+                #création d'un dict sur base du nom de groupe, sans le :
+                groupname = param.replace(':','')
+                groupname, groupdict = self.add_group(groupname, todict)
+
+            elif param.startswith('%'):
+                # COMMENTAIRE
+                # -----------
+                #c'est du commentaire --> rien à faire sauf si c'est du code json
+                if param.startswith('%json'):
+                    #c'est du code json --> on le prend tel quel
+                    parsed_json = json.loads(param.replace('%json',''))
+                    curparam[key_Param.ADDED_JSON]=parsed_json
+
+            elif param.strip() == '':
+                # VOID LINE
+                # ---------
+                logging.warning(_('A void line is present where it should not be. Removing the blank line'))
+                myparamsline.remove(param)
+
+            else:
+                # PARAMETRE
+                # ---------
+                curparam = self._add_param_from_str(param, groupname, groupdict)
+
+    def _CreateDefaultFile(self):
+        """ Create a default file """
+
+        with open(self.filename+'.default', 'w') as myfile:
+
+            for group in self.myparams.keys():
+                myfile.write(' ' + group +':\n')
+                for param_name in self.myparams[group].keys():
+                    myfile.write(param_name +'\t' + str(self.myparams[group][param_name][key_Param.VALUE])+'\n')
+
+            myfile.close()
+
+    def _Extract_IncrInfo(self, nameStr:str) -> tuple[str, list[str, str, int, int]]:
+        """
+        Extract the information of an incrementable group or param
+
+        The name of an incrementable group or param is of the form: $n(group, param, min, max)$
+        """
+        iterInfo = []
+        newName = ""
+
+        positions = [i for i, char in enumerate(nameStr) if char == "$"]
+
+        assert np.mod(len(positions),2) == 0, "ERROR : the number of '$' must be even"
+
+        if len(positions)>0:
+            # indice incrémentable détecté
+
+            # search for the first '$'
+            posSep1 = positions[0] #nameStr.find("$")
+            # search for the last '$'
+            posSep2 = positions[-1] #nameStr[posSep1+1:].find("$")
+
+            # select the string between the two '$'
+            iterCode = nameStr[posSep1:posSep1+posSep2+1]
+
+            positions_left = [i for i, char in enumerate(iterCode) if char == "("]
+            positions_right = [i for i, char in enumerate(iterCode) if char == ")"]
+
+            if len(positions_left)==0 and len(positions_right)==0:
+                # no '(' and no ')' --> no incrementable information
+                return nameStr, None
+
+            assert len(positions_left)>0, "ERROR : no '(' found in the name of an incrementable group or param"
+            assert len(positions_right)>0, "ERROR : no ')' found in the name of an incrementable group or param"
+
+            # search for the first '('
+            posSep1 = positions_left[0] #iterCode.find("(")
+            # search for the second ')'
+            posSep2 = positions_right[-1] #iterCode[posSep1:].find(")")
+
+            # select the string between the two '('
+            iterCode = iterCode[posSep1:posSep2+1]
+
+            # remove the incrementable code from the name --> conserve $n$
+            newName = nameStr.replace(iterCode,'')
+            # remove the spaces before and after the name
+            newName = newName.strip()
+
+            # decode the incrementable information
+            iterInfo = iterCode[1:-1].split(',')
+            # remove the spaces before and after the information
+            iterInfo = [x.strip() for x in iterInfo]
+
+            if len(iterInfo)==3:
+                # no group name provided --> use the current group
+                iterInfo = [iterInfo[0], int(iterInfo[1]), int(iterInfo[2])]
+            elif len(iterInfo)==4:
+                # group name provided --> use the provided group
+                iterInfo = [iterInfo[0], iterInfo[1], int(iterInfo[2]), int(iterInfo[3])]
+            else:
+                logging.error(_("The incrementable information must be of the form: $n(group, param, min, max)$ or $n(param, min, max)$"))
+        else:
+            newName = nameStr
+            iterInfo = None
+
+        return newName, iterInfo
+
+
+    # Clear/Rest
+    # ----------
+
+    def Clear(self):
+        """ Clear all the parameters """
+
+        self.myparams.clear()
+        self.myparams_default.clear()
+        self.myIncGroup.clear()
+        self.myIncParam.clear()
+        if self.prop is not None:
+            self.prop.Clear()
+
+    # Object access
+    # -------------
+
+    def add_group(self, groupname:str, todict:dict = None) -> tuple[str,dict]:
+        """
+        Add a group in the dictionary 'todict' if provided or in the IncGroup dictionary
+
+        return sanitized groupname and dictionnary attached to the group
+        """
+
+        groupname = groupname.strip()
+
+        #On verifie si le groupe est incrémentable
+        groupname, iterInfo = self._Extract_IncrInfo(groupname)
+
+        if iterInfo is None:
+            if todict is None:
+                logging.error(_("You must provide a dictionary to store the group -- Retry"))
+                return None
+
+            # Groupe classique
+            todict[groupname]={}
+            return groupname, todict[groupname]
+        else:
+            # Le groupe est incrémentable
+            iterGroup = iterInfo[0] # nom du groupe contenant le paramètre de nombre de groupes
+            iterParam = iterInfo[1] # nom du paramètre contenant le nombre de groupes
+            iterMin = iterInfo[2]   # valeur minimale
+            iterMax = iterInfo[3]   # valeur maximale
+
+            return groupname, self.add_IncGroup(groupname, iterMin, iterMax, iterGroup, iterParam)
+
+    def _add_param_in_dict(self,
+                           group:dict,
+                           name:str,
+                           value:Union[float, int, str] = '', # la valeur est de toute façon stockée en 'str'
+                           type:Type_Param=None,
+                           comment:str = '',
+                           jsonstr:str = None) -> dict:
+
+        if not name in group.keys():
+            group[name]={}
+
+        curpar=group[name]
+
+        curpar[key_Param.NAME]=name
+        curpar[key_Param.TYPE]=type
+        curpar[key_Param.VALUE]=value
+        curpar[key_Param.COMMENT]=comment
+
+        if jsonstr is not None:
+            if isinstance(jsonstr, str):
+                parsed_json = json.loads(jsonstr.replace('%json',''))
+            elif isinstance(jsonstr, dict):
+                parsed_json = jsonstr
+
+            curpar[key_Param.ADDED_JSON]=parsed_json
+        else:
+            curpar[key_Param.ADDED_JSON]=None
+        return curpar
+
+    def _new_IncParam_dict(self, groupname, refgroupname, refparamname, min_value, max_value) -> dict:
+        """ Create a new dictionary for an incrementable parameter """
+
+        newdict = {}
+        newdict["Group"] = groupname
+        newdict["Ref group"] = refgroupname
+        newdict["Ref param"] = refparamname
+        newdict["Min"] = min_value
+        newdict["Max"] = max_value
+        newdict["Dict"] = {}
+
+        return newdict
+
+    def _add_param_from_str(self, param:str, groupname:str, groupdict:dict, seperator:str = '\t'):
+        """ Add a parameter from a complex string """
+
+        #split sur base du sépérateur
+        paramloc=param.split(seperator)
+
+        #on enlève les espaces avant et après toutes les variables
+        paramloc = [x.strip() for x in paramloc]
+
+        paramloc[0], iterInfo = self._Extract_IncrInfo(paramloc[0])
+
+        if iterInfo is not None:
+            #le parametre courant est incrémentable -> ajout au dictionnaire particulier des paramètres
+            if not groupname in self.myIncParam:
+                self.myIncParam[groupname] = {}
+
+            if not paramloc[0] in self.myIncParam[groupname]:
+                curdict = self.myIncParam[groupname][paramloc[0]] = self._new_IncParam_dict(groupname, groupname if len(iterInfo)==3 else iterInfo[0], iterInfo[-3], iterInfo[-2], iterInfo[-1])
+
+            if not "Saved" in curdict:
+                curdict["Saved"] = {}
+
+            #pointage du param courant dans le dict de référence
+            curparam=curdict["Dict"]
+        else:
+            #création d'un dict sur base du nom de paramètre
+            curparam=groupdict[paramloc[0]]={}
+
+        curparam[key_Param.NAME]=paramloc[0]
+
+        if len(paramloc)>1:
+            #ajout de la valeur
+            curparam[key_Param.VALUE]=paramloc[1]
 
-        #teste si param existe
-        try:
-            param = self.myparams[group][name]
-        except:
-            param=None
             try:
-                defparam = self.myparams_default[group][name]
+                # tentative d'ajout du commentaire --> pas obligatoirement présent
+                curparam[key_Param.COMMENT]=paramloc[2]
+
+                # recherche du type dans le commentaire
+                curparam[key_Param.TYPE]=search_type(paramloc[2])
+                if curparam[key_Param.TYPE] == Type_Param.String:
+                    # recherche du type dans la châine complète
+                    type_in_fulchain = search_type(param)
+
+                    if type_in_fulchain != Type_Param.String:
+                        curparam[key_Param.TYPE] = type_in_fulchain
+                try:
+                    # tentaive de recherche du type dans les valeurs par défaut
+                    param_def=self.myparams_default[groupname][paramloc[0]]
+                    curparam[key_Param.TYPE]=param_def[key_Param.TYPE]
+                except:
+                    pass
             except:
-                if self.wx_exists:
-                    wx.MessageBox(_('This parameter is neither in the current file nor in the default file!'), _('Error'), wx.OK|wx.ICON_ERROR)
+                curparam[key_Param.COMMENT]=''
+                try:
+                    # tentative de recherche du type dans les valeurs par défaut
+                    param_def=self.myparams_default[groupname][paramloc[0]]
+                    curparam[key_Param.TYPE]=param_def[key_Param.TYPE]
+                except:
+                    if not key_Param.TYPE in curparam:
+                        curparam[key_Param.TYPE] = None
+        else:
+            curparam[key_Param.VALUE]=''
+            curparam[key_Param.COMMENT]=''
+            curparam[key_Param.TYPE]=None
+
+        return curparam
+
+    def addparam(self,
+                 groupname:str = '',
+                 name:str = '',
+                 value:Union[float, int, str] = '', # la valeur est de toute façon stockée en 'str'
+                 type:Type_Param=None,
+                 comment:str = '',
+                 jsonstr:str = None,
+                 whichdict:Literal['All', 'Default', 'Active', 'IncGroup', '']=''):
+        """
+        Add or update a parameter
+
+        @param groupname : groupe in which the new param will be strored - If it does not exist, it will be created
+        @param name      : param's name - If it does not exist, it will be created
+        @param value     : param'a value
+        @param type      : type -> will influence the GUI
+        @param comment   : param's comment -- helpful to understand the parameter
+        @param jsonstr   : string containing JSON data -- used in GUI
+        param whichdict  : where to store the param -- Default, Active or All, or IncGroup if the param is part of an incrementable group
+
+        jsonstr can be a dict i.e. '{"Values":{choice1:1, choice2:2, choice3:3}, "Full_Comment":'Yeah baby !'}'
+
+        Return 0 if OK, -1 if the group is incrementable and not created, -2 if the group does not exist
+        """
+
+        if isinstance(type, str):
+            if type == 'Integer':
+                type = Type_Param.Integer
+            elif type == 'Float':
+                type = Type_Param.Float
+            elif type == 'Integer_or_Float':
+                type = Type_Param.Integer_or_Float
+            elif type == 'Logical':
+                type = Type_Param.Logical
+            elif type == 'File':
+                type = Type_Param.File
+            elif type == 'Directory':
+                type = Type_Param.Directory
+            elif type == 'Color':
+                type = Type_Param.Color
+            elif type == 'Fontname':
+                type = Type_Param.Fontname
+            elif type == 'String':
+                type = Type_Param.String
+            else:
+                type = None
+
+        name_wo, iterInfo = self._Extract_IncrInfo(name)
+        if iterInfo is not None:
+            return self.add_IncParam(groupname, name, value, comment, type, added_json=jsonstr)
+
+        if '$n$' in groupname:
+            if whichdict != 'IncGroup':
+                logging.warning(_("WARNING : group is incrementable. -- You must use 'IncGroup' for whichdict"))
+                whichdict = 'IncGroup'
+        elif '$n(' in groupname:
+            if whichdict != 'IncGroup':
+                logging.warning(_("WARNING : group is incrementable. -- You must use 'IncGroup' for whichdict"))
+                whichdict = 'IncGroup'
+
+            groupname, iterInfo = self._Extract_IncrInfo(groupname)
+
+            if iterInfo is None:
+                logging.error(_("ERROR : infos not found in {} -- Retry".format(groupname)))
+                return -1
+
+            # Le groupe est incrémentable
+            iterGroup = iterInfo[0] # nom du groupe contenant le paramètre de nombre de groupes
+            iterParam = iterInfo[1] # nom du paramètre contenant le nombre de groupes
+            iterMin = iterInfo[2]   # valeur minimale
+            iterMax = iterInfo[3]   # valeur maximale
+
+            if groupname not in self.myIncGroup.keys():
+                self.add_IncGroup(groupname, iterMin, iterMax, iterGroup, iterParam)
+
+        if whichdict=='IncGroup':
+            if not groupname in self.myIncGroup.keys():
+                logging.error(_("ERROR : group {} does not exist. -- You must first create it".format(groupname)))
+                logging.error(_("   or pass infos in the group name : $n(group, param, min, max)$"))
+                return -2
+
+            self._add_param_in_dict(self.myIncGroup[groupname]["Dict"], name, value, type, comment, jsonstr)
+            return 0
+
+        else:
+            if whichdict=='All':
+                locparams=[self.myparams, self.myparams_default]
+            elif whichdict=='Default':
+                locparams=[self.myparams_default]
+            elif whichdict=='Active' or whichdict=='':
+                locparams=[self.myparams]
+
+            for curdict in locparams:
+                if not groupname in curdict.keys():
+                    curdict[groupname]={}
+
+                self._add_param_in_dict(curdict[groupname], name, value, type, comment, jsonstr)
+
+            return 0
+
+    def add_param(self,
+                 groupname:str = '',
+                 name:str = '',
+                 value:Union[float, int, str] = '', # la valeur est de toute façon stockée en 'str'
+                 type:Type_Param=None,
+                 comment:str = '',
+                 jsonstr:str = None,
+                 whichdict:Literal['All', 'Default', 'Active', 'IncGroup', '']=''):
+        """alias of addparam"""
+        return self.addparam(groupname, name, value, type, comment, jsonstr, whichdict)
+
+    def __getitem__(self, key:tuple[str, str]):
+        """
+        Retrieve :
+          - value's parameter from group if key is a tuple or a list (group, param_name)
+          - group dict if key is a string
+        """
+        if isinstance(key, tuple) or isinstance(key, list):
+            group, name = key
+            return self.get_param(group, name)
+        elif isinstance(key, str):
+            return self.get_group(key)
+
+    def __setitem__(self, key:str, value:Union[float, int, str, bool]):
+        """set item, key is a tuple or a list (group, param_name)"""
+
+        if isinstance(key, tuple) or isinstance(key, list):
+            group, name = key
+            if self.get_param(group, name) is not None:
+                self.change_param(group, name, value)
+            else:
+                self.addparam(group, name, value, self._detect_type_from_value(value))
+
+    def is_in_active(self, group:str, name:str = None) -> bool:
+        """ Return True if the parameter is in the active parameters """
+        return self.is_in(group, name, whichdict='Active')
+
+    def is_in_default(self, group:str, name:str = None) -> bool:
+        """ Return True if the parameter is in the default parameters """
+        return self.is_in(group, name, whichdict='Default')
+
+    def is_in(self, group:str, name:str = None, whichdict:Literal['All', 'Default', 'Active', 'IncGroup', '']='Active') -> bool:
+        """ Return True if the parameter is in the whichdict parameters """
+
+        if whichdict=='All':
+            locparams=[self.myparams, self.myparams_default]
+        elif whichdict=='Default':
+            locparams=[self.myparams_default]
+        elif whichdict=='Active' or whichdict=='':
+            locparams=[self.myparams]
+
+        for curdict in locparams:
+            if group in curdict.keys():
+                if name is not None:
+                    if name in curdict[group].keys():
+                        ret = True
+                    else:
+                        return False
                 else:
-                    logging.error(_('This parameter is neither in the current file nor in the default file!'))
-                self.myparams[group][name] = {}
-                param = self.myparams[group][name]
+                    ret = True
+            else:
+                return False
 
-        if(locgroup is None):
-            self.myparams[group] = {}
-            self.myparams[group][name] = self.myparams_default[group].copy()
-            param = self.myparams[group][name]
-        elif(param is None):
-            locgroup[name] = {}
-            locgroup[name] = self.myparams_default[group][name].copy()
+        return ret
+
+    def get_param_dict(self, group:str, name:str) -> dict[str, Union[str, int, float, bool, tuple[int, int, int]]]:
+        """
+        Returns the parameter dict if found, otherwise None obj
+        """
+
+        if self.is_in_active(group, name):
+            return self.myparams[group][name]
+        elif self.is_in_default(group, name):
+            return self.myparams_default[group][name]
+        else:
+            return None
+
+    def get_type(self, group:str, name:str) -> Type_Param:
+        """
+        Returns the type of the parameter if found, otherwise None obj
+        """
+
+        curtype = None
+
+        if self.is_in_default(group, name):
+            if key_Param.TYPE in self.myparams_default[group][name].keys():
+                curtype = self.myparams_default[group][name][key_Param.TYPE]
+
+        if self.is_in_active(group, name) and curtype is None:
+            if key_Param.TYPE in self.myparams[group][name].keys():
+                curtype = self.myparams[group][name][key_Param.TYPE]
+
+        return curtype if curtype is not None else Type_Param.String
+
+    def value_as_type(self, value, type,
+                      bool_as_int:bool = False,
+                      color_as:Union[int,str,float]= int) :
+
+        """ Convert the value to the right type """
+        if type == Type_Param.Integer:
+            value = int(value)
+        elif type == Type_Param.Float:
+            value = float(value)
+        elif type == Type_Param.Logical:
+            if isinstance(value,str):
+                if value.lower() in ['.false.', 'false', 'faux']:
+                    value = False
+                elif value.lower() in ['.true.', 'true', 'vrai']:
+                    value = True
+            else:
+                value = bool(value)
+
+            if bool_as_int:
+                value = int(value)
+
+        elif type == Type_Param.Color:
+            if color_as == str:
+                value = str(value)
+            else:
+                if isinstance(value,str):
+                    value = value.replace('(','')
+                    value = value.replace(')','')
+                    value = value.split(',')
+                elif isinstance(value, wx.Colour):
+                    value = [value.Red(), value.Green(), value.Blue(), value.Alpha()]
+
+                if color_as == int:
+                    value = tuple([int(x) for x in value])
+
+                elif color_as == float:
+                    value = tuple([float(x)/255. for x in value])
+
+        elif type == Type_Param.Integer_or_Float:
+            value = float(value)
+        elif type == Type_Param.String:
+            value = str(value)
+        elif type == Type_Param.File:
+            value = str(value)
+        elif type == Type_Param.Directory:
+            value = str(value)
+        elif type == Type_Param.Fontname:
+            value = str(value)
+        else:
+            value = str(value)
+
+        return value
+
+    def get_param(self, group:str, name:str, default_value=None):
+        """
+        Returns the value of the parameter if found, otherwise None obj
+
+        used in __getitem__
+        """
+
+        if self.is_in_active(group, name):
+            element = self.myparams[group][name][key_Param.VALUE]
+        elif self.is_in_default(group, name):
+            element = self.myparams_default[group][name][key_Param.VALUE]
+        else:
+            element  = default_value
+            return element
+
+        # String conversion according to its type
+        curType = self.get_type(group, name)
+        return self.value_as_type(element, curType)
+
+    def get_group(self, group:str) -> dict:
+        """
+        Return the group dictionnary if found, otherwise None obj
+        Check the active parameters first, then the default parameters
+
+        Used in __getitem__
+        """
+
+        if self.is_in_active(group):
+            return self.myparams[group]
+        elif self.is_in_default(group):
+            return self.myparams_default[group]
+        else:
+            return None
+
+    def _detect_type_from_value(self, value:Union[float, int, str, bool, tuple[int, int, int]]) -> Type_Param:
+        """ Detect the type from the value """
+
+        if isinstance(value, float):
+            return Type_Param.Float
+        elif isinstance(value, int):
+            return Type_Param.Integer
+        elif isinstance(value, bool):
+            return Type_Param.Logical
+        elif isinstance(value, tuple):
+            return Type_Param.Color
+        else:
+            return Type_Param.String
+
+    def change_param(self, group:str, name:str, value:Union[float, int, str, bool]):
+        """ Modify the value of the parameter if found, otherwise None obj """
+
+        #essai pour voir si le groupe existe ou non
+        param = self.get_param_dict(group, name)
+
+        if param is None:
+            # le paramètre n'existe pas --> on l'ajoute
+            if self.wx_exists:
+                wx.MessageBox(_('This parameter is neither in the active group nor in the default group!'), _('Error'), wx.OK|wx.ICON_ERROR)
+            else:
+                logging.error(_('This parameter is neither in the current group nor in the default group!'))
+
+            self.add_param(group, name, value,
+                           self._detect_type_from_value(value),
+                           whichdict='All')
+
+        elif not self.is_in_active(group, name) and self.is_in_default(group, name):
+            # le paramètre est dans les paramètres par défaut mais pas dans les paramètres actifs --> on l'ajoute
+            default_value = self.myparams_default[group][name]
+            self.add_param(group, name, value,
+                           default_value[key_Param.TYPE],
+                           comment=default_value[key_Param.COMMENT],
+                           jsonstr=default_value[key_Param.ADDED_JSON],
+                           whichdict='Active')
+        elif self.is_in_active(group, name):
             param = self.myparams[group][name]
+            param[key_Param.VALUE] = value
+
+        if self.update_incr_at_every_change:
+            self._update_IncGroup()
+            self._update_IncParam()
+
+
+    # GROUPES/PARAMETRES INCREMENTABLES
+    # ---------------------------------
+
+    def update_incremental_groups_params(self, update_groups=True, update_params=True):
+        """ Update the incremental groups and parameters """
+
+        if update_groups:
+            self._update_IncGroup()
+        if update_params:
+            self._update_IncParam()
+
+
+    def isIncrementable_group(self, group:Union[str, dict]) -> bool:
+        """
+        Return True if the group is incrementable
+        """
+
+        if isinstance(group, str):
+            if group in self.myIncGroup.keys():
+                return True
+            elif '$n$' in group:
+                return True
+            elif '$n(' in group:
+                return True
+            else:
+                return False
+        elif isinstance(group, dict):
+            if group in self.myIncGroup:
+                return True
+            else:
+                return False
+
+
+    def isIncrementable_param(self, param:Union[str, dict]) -> bool:
+        """
+        Return True if the group is incrementable
+        """
+        if isinstance(param, str):
+            if param in self.myIncGroup.keys():
+                return True
+            elif '$n$' in param:
+                return True
+            elif '$n(' in param:
+                return True
+            else:
+                return False
+        elif isinstance(param, dict):
+            if param in self.myIncParam:
+                return True
+            else:
+                return False
+
+    def add_IncGroup(self,
+                     group:str,
+                     min:int,
+                     max:int,
+                     refGroup:str,
+                     refParam:str):
+
+        if not group in self.myIncGroup:
+            # creation d'un dict sur base du nom de groupe
+            curdict = self.myIncGroup[group] = {}
+        else:
+            curdict = self.myIncGroup[group]
 
-        param["value"] = value
+        curdict["Ref group"] = refGroup
+        curdict["Ref param"] = refParam
+        curdict["Min"] = int(min)
+        curdict["Max"] = int(max)
+        curdict["Dict"] = {}
 
+        if not "Saved" in curdict:
+            curdict["Saved"] = {}
 
+        return curdict["Dict"]
 
-    # Mise à jour des groupes inctrémmentables:
-    # Les groupes existants dans les paramètres courants seront sauvés dans le dicionnaire myIncGroup avec son incrément associé.
-    # Tout groupe sauvé avec le même incrément sera écrasé.
-    # Si le nombre associé au groupe est plus grand que désiré, tous les groupes en surplus seront sauvés dans dans le dicionnaire myIncGroup
-    # mais supprimé du dictionnaire de paramètre courant.
-    # S'il n'y a pas assez de groupe dans les paramètres courant, on les ajoute avec les valeurs sauvées, sinon avec des valeurs par défaut.
-    # Also check the max and min values
-    def Update_IncGroup(self, withGUI=False):
 
+    def _update_IncGroup(self, withGUI:bool=False):
+        """
+        Mise à jour des groupes inctrémmentables:
+        Les groupes existants dans les paramètres courants seront sauvés dans le dicionnaire myIncGroup avec son incrément associé.
+        Tout groupe sauvé avec le même incrément sera écrasé.
+        Si le nombre associé au groupe est plus grand que désiré, tous les groupes en surplus seront sauvés dans dans le dicionnaire myIncGroup
+        mais supprimé du dictionnaire de paramètre courant.
+        S'il n'y a pas assez de groupe dans les paramètres courant, on les ajoute avec les valeurs sauvées, sinon avec des valeurs par défaut.
+
+        Also check the max and min values
+        """
         for curIncGroup in self.myIncGroup:
+
+            # groupe contenant le paramètre du nombre de groupes incrémentables
             refGroup = self.myIncGroup[curIncGroup]["Ref group"]
+            # paramètre contenant le nompbre de groupes incrémentables
             refParam = self.myIncGroup[curIncGroup]["Ref param"]
+            # nombre de groupes min
             iterMin = int(self.myIncGroup[curIncGroup]["Min"])
+            # nombre de groupes max
             iterMax = int(self.myIncGroup[curIncGroup]["Max"])
+
+            # nombre de groupes
             nbElements = int(self.get_param(refGroup,refParam))
-            savedDict = {}
+
+            # dictionnaire de sauvegarde
+            # savedDict = {}
             savedDict = self.myIncGroup[curIncGroup]["Saved"]
             templateDict = self.myIncGroup[curIncGroup]["Dict"]
+
             if(nbElements is None):
                 if self.wx_exists:
                     wx.MessageBox(_('The reference of the incrementable group does not exist!'), _('Error'), wx.OK|wx.ICON_ERROR)
@@ -900,77 +1583,194 @@ class Wolf_Param(wx.Frame):
 
             elif(nbElements>iterMax):
                 nbElements = iterMax
+
             # elif(nbElements<iterMin):
             #     nbElements = iterMax
 
             for i in range(1,nbElements+1):
+                # nom indicé du groupe incrémpentable
                 curGroup = curIncGroup.replace("$n$",str(i))
+
                 if(withGUI):
-                    groupexists = False
+                    # If a graphical interface exists, we need to ensure that the encoded data is transferred to memory/object first.
                     for curParam in templateDict:
-                        groupexists = self.Apply1ParamtoMemory(curGroup, curParam, groupexists=groupexists, isIncrementable=True, genGroup=curIncGroup)
+                        self._Apply1ParamtoMemory(curGroup, curParam, isIncrementable=True, genGroup=curIncGroup)
 
                 if(curGroup in self.myparams):
-                    savedDict[curGroup] = {}
-                    savedDict[curGroup] = self.myparams[curGroup]
+                    # We keep a copy in the 'Saved' dictionary
+                    savedDict[curGroup] = deepcopy(self.myparams[curGroup]) # deepcopy is necessary because it is a dict od dict
+
                 elif(curGroup in savedDict):
-                    self.myparams[curGroup] = {}
-                    self.myparams[curGroup] = savedDict[curGroup]
+                    # Priority to the saved dictionary, rather than the default dictionary
+                    self.myparams[curGroup] = deepcopy(savedDict[curGroup]) # deepcopy is necessary because it is a dict od dict
+
                 else:
-                    self.myparams[curGroup] = {}
-                    self.myparams[curGroup] = templateDict.copy()
+                    # nothing found --> we create a new group from the default dictionary
+                    self.myparams[curGroup] = deepcopy(templateDict) # deepcopy is necessary because it is a dict od dict
 
             for i in range(nbElements+1,iterMax+1):
+                # all potential groups with an index greater than the desired number of elements
                 curGroup = curIncGroup.replace("$n$",str(i))
+
                 if(curGroup in self.myparams):
-                    savedDict[curGroup] = {}
-                    savedDict[curGroup] = self.myparams[curGroup].copy()
-                    self.myparams[curGroup] = {}
+                    savedDict[curGroup] = deepcopy(self.myparams[curGroup]) # deepcopy is necessary because it is a dict od dict, copy is not enough
                     del self.myparams[curGroup]
                 else:
                     break
 
 
-    # Mise à jour des paramètres inctrémmentables:
-    # Les paramètres existants dans les paramètres courants seront sauvés dans le dicionnaire myIncParam avec son incrément associé.
-    # Tout groupe sauvé avec le même incrément sera écrasé.
-    # Si le nombre associé au groupe est plus grand que désiré, tous les groupe en surplus seront sauvé dans dans le dicionnaire myIncParam
-    # mais supprimé du dictionnaire de paramètre courant.
-    # S'il n'y a pas assez de groupe dans les paramètres courant, on les ajoute avec les valeurs sauvées, sinon avec des valeurs par défaut.
-    # Also check the max and min values
-    def Update_IncParam(self, withGUI=False):
+    def add_IncParam(self,
+                     group:str,
+                     name:str,
+                     value:Union[float, int, str],
+                     comment:str,
+                     type:Type_Param,
+                     min:int = 0,
+                     max:int = 0,
+                     refParam:str = None,
+                     refGroup:str = None,
+                     added_json:str = None):
+        """
+        Ajout d'un paramètre incrémentable
+
+        @param group: nom du groupe
+        @param name: nom du paramètre
+        @param value: valeur du paramètre
+        @param comment: commentaire du paramètre
+        @param type: type du paramètre
+        @param min: valeur minimale
+        @param max: valeur maximale
+        @param refParam: nom du paramètre contenant le nombre de paramètres - doit être dans le même groupe
+
+        """
+
+        if added_json is not None:
+            if isinstance(added_json, str):
+                added_json = json.loads(added_json.replace('%json',''))
+            elif isinstance(added_json, dict):
+                pass
+
+        if group not in self.myIncParam:
+            self.myIncParam[group] = {}
+
+        name, iterInfo = self._Extract_IncrInfo(name)
+
+        if iterInfo is not None:
+            if len(iterInfo) == 3:
+                refParam, min, max = iterInfo
+                refGroup = None
+            elif len(iterInfo) == 4:
+                refGroup, refParam, min, max = iterInfo
+            else:
+                logging.error("ERROR : wrong number of arguments in the incrementable parameter name {}!".format(name))
+
+        refGroup = refGroup if refGroup is not None else group
+
+        assert min >=0, "ERROR : min must be >= 0"
+        assert max >0,  "ERROR : max must be > 0"
+        assert max >= min, "ERROR : max must be >= min"
+        assert refParam is not None, "ERROR : refParam can not be None"
+        assert refGroup is not None, "ERROR : refGroup can not be None"
+
+        curdict = self.myIncParam[group][name] = {}
+        curdict["Group"] = group
+        curdict["Ref group"] = refGroup
+        curdict["Ref param"] = refParam
+        curdict["Min"] = min
+        curdict["Max"] = max
+        curdict["Dict"] = {}
+        curdict["Dict"][name] = {}
+        curdict["Dict"][name][key_Param.NAME] = name
+        curdict["Dict"][name][key_Param.VALUE] = value
+        curdict["Dict"][name][key_Param.COMMENT] = comment
+        curdict["Dict"][name][key_Param.TYPE] = type
+        if added_json is not None:
+            curdict["Dict"][name][key_Param.ADDED_JSON] = added_json
+        else:
+            curdict["Dict"][name][key_Param.ADDED_JSON] = None
+        curdict["Saved"] = {}
+        curdict["Saved"][group] = {}
+        curdict["Saved"][group][name] = {}
+        curdict["Saved"][group][name][key_Param.NAME] = name
+        curdict["Saved"][group][name][key_Param.VALUE] = value
+        curdict["Saved"][group][name][key_Param.COMMENT] = comment
+        curdict["Saved"][group][name][key_Param.TYPE] = type
+        if added_json is not None:
+            curdict["Saved"][group][name][key_Param.ADDED_JSON] = added_json
+        else:
+            curdict["Saved"][group][name][key_Param.ADDED_JSON] = None
+
+        return 0
+
 
+    def _update_IncParam(self, withGUI:bool=False):
+        """
+        Mise à jour des paramètres inctrémmentables:
+        Les paramètres existants dans les paramètres courants seront sauvés dans le dicionnaire myIncParam avec son incrément associé.
+        Tout groupe sauvé avec le même incrément sera écrasé.
+        Si le nombre associé au groupe est plus grand que désiré, tous les groupe en surplus seront sauvé dans dans le dicionnaire myIncParam
+        mais supprimé du dictionnaire de paramètre courant.
+        S'il n'y a pas assez de groupe dans les paramètres courant, on les ajoute avec les valeurs sauvées, sinon avec des valeurs par défaut.
+
+        Also check the max and min values
+        """
         for refGroup in self.myIncParam:
             for curIncParam in self.myIncParam[refGroup]:
                 if(refGroup.find("$n$")>-1):
                     nbMax = int(self.myIncGroup[refGroup]["Max"])
-                    # refGroup = refGroup.replace("$n$","")
+
                     i=1
                     while(i<nbMax+1):
                         curGroup = refGroup.replace("$n$",str(i))
                         i += 1
                         if curGroup in self.myparams:
-                            self.Update_OneIncParam(curIncParam, curGroup, genGroup=refGroup,withGUI=withGUI)
+                            self._Update_OneIncParam(curIncParam, curGroup, genGroup=refGroup, withGUI=withGUI)
                         else:
                             break
                 else:
-                    # Si tous les autres paramètres restent inchangés, ce groupe n'est pas présent dans le dictionnaire.
-                    # Il faut donc le créer
                     if not refGroup in self.myparams:
                         self.myparams[refGroup] = {}
-                    self.Update_OneIncParam(curIncParam, refGroup, genGroup=refGroup, withGUI=withGUI)
+                    self._Update_OneIncParam(curIncParam, refGroup, genGroup=refGroup, withGUI=withGUI)
+
+
+    def _Update_OneIncParam(self, curIncParam:str, curGroup:str, genGroup:str, withGUI:bool=False):
+        """
+        Routine interne de mise à jour d'un seul paramétre incrémentable
+
+        @param curIncParam : nom du paramètre incrémentable - contient $n$ à remplacer par le numéro
+        @param curGroup : nom du groupe de référence - ! peut être un groupe icrémentable !
+        @param genGroup : nom du groupe générique dans lequel sont stockés les informations sur le paramètre (key, value, min, max, ...)
+        @param withGUI : True si on est en mode GUI
+
+        """
 
+        refGroup = self.myIncParam[genGroup][curIncParam]["Ref group"] # groupe dans lequel est stocké le nombre de paramètres
+        refParam = self.myIncParam[genGroup][curIncParam]["Ref param"] # nom du paramètre contenant le nombre de paramètres
+        iterMin = int(self.myIncParam[genGroup][curIncParam]["Min"])   # nombre minimal de paramètres
+        iterMax = int(self.myIncParam[genGroup][curIncParam]["Max"])   # nombre maximal de paramètres
+
+        # logging.info(curGroup+" / "+refParam)
+
+        if '$n$' in refGroup:
+            # le groupe de référence est incrémentable --> le paramètre est à trouver dans le groupe courant
+
+            part_Group = refGroup.replace("$n$","")
+            if part_Group in curGroup:
+                refGroup = curGroup
+            else:
+                logging.error(_("ERROR : the reference group {} does not exist or is not well defined {}!".format(part_Group, curGroup)))
+
+        nbElements = self[(refGroup, refParam)] #int(self.get_param(refGroup, refParam))
+
+        if nbElements is None:
+            logging.error(_("ERROR : the reference of the incrementable parameter does not exist!"))
+            return
 
-    def Update_OneIncParam(self, curIncParam, refGroup, genGroup, withGUI=False):
-        refParam = self.myIncParam[genGroup][curIncParam]["Ref param"]
-        iterMin = int(self.myIncParam[genGroup][curIncParam]["Min"])
-        iterMax = int(self.myIncParam[genGroup][curIncParam]["Max"])
-        logging.info(refGroup+" / "+refParam)
-        nbElements = int(self.get_param(refGroup,refParam))
         savedDict = {}
         savedDict = self.myIncParam[genGroup][curIncParam]["Saved"]
-        if(not(refGroup in savedDict)):
-            savedDict[refGroup] = {}
+        if(not(curGroup in savedDict)):
+            savedDict[curGroup] = {}
+
         templateDict = self.myIncParam[genGroup][curIncParam]["Dict"]
         if(nbElements is None):
             if self.wx_exists:
@@ -982,178 +1782,41 @@ class Wolf_Param(wx.Frame):
         # elif(nbElements<iterMin):
         #     nbElements = iterMax
 
-        for i in range(1,nbElements+1):
+        for i in range(1, nbElements+1):
             curParam = curIncParam.replace("$n$",str(i))
 
             if(withGUI):
-                groupexists = True
-                groupexists = self.Apply1ParamtoMemory(refGroup, curParam, groupexists=groupexists,isIncrementable=True,genGroup=genGroup,genParam=curIncParam)
-
-            if(curParam in self.myparams[refGroup]):
-                savedDict[refGroup][curParam] = {}
-                savedDict[refGroup][curParam] = self.myparams[refGroup][curParam]
-            elif(curParam in savedDict[refGroup]):
-                self.myparams[refGroup][curParam] = {}
-                self.myparams[refGroup][curParam] = savedDict[refGroup][curParam]
-            else:
-                self.myparams[refGroup][curParam] = {}
-                self.myparams[refGroup][curParam] = templateDict.copy()
-
-        for i in range(nbElements+1,iterMax+1):
-            curParam = curIncParam.replace("$n$",str(i))
-            if(curParam in self.myparams):
-                savedDict[refGroup][curParam] = {}
-                savedDict[refGroup][curParam] = self.myparams[refGroup][curParam].copy()
-                self.myparams[refGroup][curParam] = {}
-            else:
-                break
-
-
-
-
-    def Extract_IncrInfo(self, nameStr:str):
-
-        iterInfo = []
-        newName = ""
-        posSep1 = nameStr.find("$")
-        posSep2 = nameStr[posSep1+1:].find("$")
-
-        # Groupe avec indice incrémentable
-        if posSep1>-1 or posSep2>-1:
-            iterCode = nameStr[posSep1+1:posSep1+posSep2+1]
-            posSep1 = iterCode.find("(")
-            posSep2 = iterCode[posSep1:].find(")")
-            iterCode = iterCode[posSep1+1:posSep2+1]
-            newName = nameStr.replace("("+iterCode+")",'')
-            # newName = nameStr.replace(':','')
-            newName = newName.strip()
-            iterInfo = iterCode.split(',')
-        else:
-            newName = nameStr
-            iterInfo = None
+                self._Apply1ParamtoMemory(curGroup, curParam, isIncrementable=True, genGroup=genGroup, genParam=curIncParam)
 
-        return newName, iterInfo
-
-
-    # @var genGroup : generic name of an incrementable group
-    # @var genParam : generic name of an incrementable param
-    def Apply1ParamtoMemory(self, group, param_name, groupexists=False, isIncrementable=False, genGroup="", genParam=""):
+            if(curParam in self.myparams[curGroup]):
+                savedDict[curGroup][curParam] = {}
+                savedDict[curGroup][curParam] = self.myparams[curGroup][curParam]
 
-        if isIncrementable:
-            if(genParam!=""):
-                if(genGroup!=""):
-                    param = self.myIncParam[genGroup][genParam]["Dict"]
-                else:
-                    param = self.myIncParam[group][genParam]["Dict"]
+            elif(curParam in savedDict[curGroup]):
+                self.myparams[curGroup][curParam] = {}
+                self.myparams[curGroup][curParam] = savedDict[curGroup][curParam]
 
-            elif(genGroup!=""):
-                param = self.myIncGroup[genGroup]["Dict"][param_name]
-
-        else:
-            param = self.myparams_default[group][param_name]
+            else:
+                self.myparams[curGroup][curParam] = {}
+                self.myparams[curGroup][curParam][key_Param.NAME] = curParam
+                self.myparams[curGroup][curParam][key_Param.VALUE] = templateDict[curIncParam][key_Param.VALUE]
+                self.myparams[curGroup][curParam][key_Param.COMMENT] = templateDict[curIncParam][key_Param.COMMENT]
+                self.myparams[curGroup][curParam][key_Param.TYPE] = templateDict[curIncParam][key_Param.TYPE]
+                if key_Param.ADDED_JSON in templateDict[curIncParam]:
+                    self.myparams[curGroup][curParam][key_Param.ADDED_JSON] = templateDict[curIncParam][key_Param.ADDED_JSON]
+
+        # transfert des paramètres en surplus dans le dictionnaire savedDict
+        for i in range(nbElements+1, iterMax+1):
+            curParam = curIncParam.replace("$n$",str(i))
 
-        curprop = self.prop.GetPropertyByName(group + param_name)
-        curdefprop = self.prop.GetPropertyByName('def' + group + param_name)
+            if(curParam in self.myparams[curGroup]):
+                savedDict[curGroup][curParam] = {}
+                savedDict[curGroup][curParam] = self.myparams[curGroup][curParam].copy()
+                self.myparams[curGroup].pop(curParam)
 
-        if curprop is not None :
-            toApply = False
-            if param['type']=='Integer_or_Float':
-                vpar = float(curprop.m_value)
-                if isIncrementable:
-                    toApply = True
-                else:
-                    vpardef = float(curdefprop.m_value)
-                    if vpar != vpardef :
-                        toApply = True
-                if toApply:
-                    if not groupexists :
-                        self.myparams[group]={}
-                        groupexists = True
-                    self.myparams[group][param_name] = {}
-                    self.myparams[group][param_name]['value']=vpar
-            elif param['type']=='Integer':
-                if isIncrementable:
-                    toApply = True
-                elif int(curprop.m_value) != int(curdefprop.m_value) :
-                    toApply = True
-                if toApply:
-                    if not groupexists :
-                        self.myparams[group]={}
-                        groupexists = True
-                    self.myparams[group][param_name] = {}
-                    self.myparams[group][param_name]['value']=int(curprop.m_value)
-            elif param['type']=='Logical':
-                if isIncrementable:
-                    toApply = True
-                elif curprop.m_value != curdefprop.m_value :
-                    toApply = True
-                if toApply:
-                    if not groupexists :
-                        self.myparams[group]={}
-                        groupexists = True
-                    self.myparams[group][param_name] = {}
-                    if curprop.m_value:
-                        self.myparams[group][param_name]['value']='.true.'
-                    else:
-                        self.myparams[group][param_name]['value']='.false.'
-            elif param['type']=='Float':
-                #try:
-                #    vpar = float(curprop.m_value.replace('d','e'))
-                #except:
-                vpar = float(curprop.m_value)
-
-                #try:
-                #    vpardef = float(curdefprop.m_value.replace('d','e'))
-                #except:
-                if isIncrementable:
-                    toApply = True
-                else:
-                    vpardef = float(curdefprop.m_value)
-                    if vpar != vpardef :
-                        toApply = True
-
-                if toApply:
-                    if not groupexists :
-                        self.myparams[group]={}
-                        groupexists = True
-                    self.myparams[group][param_name] = {}
-                    self.myparams[group][param_name]['value']=vpar
-            elif param['type']=='File':
-                if isIncrementable:
-                    toApply = True
-                elif str(curprop.m_value) != str(curdefprop.m_value) :
-                    toApply = True
-                if toApply:
-                    if not groupexists :
-                        self.myparams[group]={}
-                        groupexists = True
-                    self.myparams[group][param_name] = {}
-                    self.myparams[group][param_name]['value']=str(curprop.m_value)
-            elif param['type']=='Directory':
-                if isIncrementable:
-                    toApply = True
-                elif str(curprop.m_value) != str(curdefprop.m_value) :
-                    toApply = True
-                if toApply:
-                    if not groupexists :
-                        self.myparams[group]={}
-                        groupexists = True
-                    self.myparams[group][param_name] = {}
-                    self.myparams[group][param_name]['value']=str(curprop.m_value)
             else:
-                if isIncrementable:
-                    toApply = True
-                elif str(curprop.m_value) != str(curdefprop.m_value) :
-                    toApply = True
-                if toApply:
-                    if not groupexists :
-                        self.myparams[group]={}
-                        groupexists = True
-                    self.myparams[group][param_name] = {}
-                    self.myparams[group][param_name]['value']=str(curprop.m_value)
-
-        return groupexists
-
+                # inutile de continuer, on a atteint le dernier paramètre
+                break
 
 if __name__ =="__main__":
     test = Wolf_Param()