wolfhece 2.1.6__py3-none-any.whl → 2.1.8__py3-none-any.whl

wolfhece/PyParams.py

@@ -944,7 +944,11 @@ class Wolf_Param(wx.Frame):
                     except:
                         logging.debug("String type will be conserved! -- {}".format(value_param))
 
-                page.AppendIn(parent, pg.EnumProperty(param_name, name=locname, labels=list_keys, values=list_values, value=value_param))
+                if type(value_param) != int:
+                    logging.warning("Parameters -- EnumProperty -- Value {} is not an integer".format(value_param))
+                    logging.debug("EnumProperty value must be an integer")
+
+                page.AppendIn(parent, pg.EnumProperty(param_name, name=locname, labels=list_keys, values=list_values, value=int(value_param))) # force value to 'int' type
             else:
                 self._insert_with_type_based_on_value(page, group, param, prefix)
 
@@ -1055,8 +1059,12 @@ class Wolf_Param(wx.Frame):
                         value_param = int(value_param)
                     except:
                         logging.debug("String type will be conserved! -- {}".format(value_param))
-                # print(value_param)
-                page.Append(pg.EnumProperty(param_name, name=locname, labels=list_keys, values=list_values, value=value_param))
+
+                if type(value_param) != int:
+                    logging.warning("Parameters -- EnumProperty -- Value {} is not an integer".format(value_param))
+                    logging.debug("EnumProperty value must be an integer")
+
+                page.Append(pg.EnumProperty(label= param_name, name= locname, labels= list_keys, values= list_values, value= int(value_param)))
 
             else:
                 # Pas de chaîne JSON mais un commentaire complet

wolfhece/apps/version.py

@@ -5,7 +5,7 @@ class WolfVersion():
 
         self.major = 2
         self.minor = 1
-        self.patch = 6
+        self.patch = 8
 
     def __str__(self):
 

wolfhece/multiprojects.py

@@ -80,7 +80,103 @@ class Wolf2D_Project(Project):
         self.poly = None
         self.poly_values = None
 
-    def load_simulations(self, epsilon, verbose=False):
+    @classmethod
+    def from_existing(cls, sims:dict[str, Union[str, Wolfresults_2D, wolfres2DGPU]]):
+        """
+        Create a MultiProjects object from a dictionary of simulations
+
+        :param sims: dict[str, Union[str, Wolfresults_2D, wolfres2DGPU]] -- dictionary of simulations to add
+        """
+
+        newmp = cls(to_read=False)
+        newmp.add_simulations(sims)
+
+        return newmp
+
+    def __str__(self) -> str:
+        """
+        Return string representation
+        """
+
+        ret = f'Project : {Path(self.wdir)}\n'
+        ret += 'Key : Simulations : Type\n'
+        for curkey, cursim in self.mysims.items():
+            ret+=f'{curkey} : {cursim.filename} : {"GPU" if isinstance(cursim, wolfres2DGPU) else "CPU"}\n'
+
+        return ret
+    
+    def __getitem__(self, key: tuple[str, str]):
+        
+        return self.get_simulation(key)
+
+    def pop(self, key: str):
+        """
+        Remove a simulation from the project
+
+        :param key: str -- key of the simulation to remove
+        """
+
+        if key in self.mysims.keys():
+            self.mysims.pop(key)
+    
+    def add(self, 
+            key:str, 
+            value:Union[Wolfresults_2D, wolfres2DGPU, str], 
+            epsilon:float=None, 
+            force_read:bool = False):
+        """
+        Add a key-value pair to the project
+
+        :param key: str -- key of the simulation to add
+        :param value: Wolfresults_2D, wolfres2DGPU, str -- simulation to add
+        :param epsilon: float -- epsilon value to use for the simulation
+        :param force_read: bool -- force reading the last step of the simulation
+
+        """
+
+        if epsilon is  None:
+            epsilon = self.epsilon
+
+        if isinstance(value, str):
+            
+            locpath = Path(self.wdir) / value
+            if locpath.exists():
+
+                if 'simul_gpu_results' in locpath.name or (locpath / 'simul_gpu_results').exists():
+                    #GPU
+                    self.mysims[key] = wolfres2DGPU(locpath, epsilon=self.epsilon, idx=key)
+                else:
+                    #CPU
+                    self.mysims[key] = Wolfresults_2D(locpath, epsilon=self.epsilon, idx=key)
+
+            else:
+                logging.warning(f'File {locpath} does not exist !')
+
+        elif isinstance(value, wolfres2DGPU):
+
+            self.mysims[key] = value
+
+        elif isinstance(value, Wolfresults_2D):
+                
+            self.mysims[key] = value
+
+        if force_read:
+            self.mysims[key].read_oneresult()
+            
+    def add_simulations(self, 
+                        sims_to_add:dict[str, Union[str, Wolfresults_2D, wolfres2DGPU]],
+                        epsilon:float=None, 
+                        force_read:bool = False):
+        """
+        Add multiple simulations to the project
+
+        :param sims_to_add: dict[str, Union[str, Wolfresults_2D, wolfres2DGPU]] -- dictionary of simulations to add
+        """
+
+        for key, value in sims_to_add.items():
+            self.add(key, value, epsilon, force_read)
+
+    def load_simulations(self, epsilon:float, verbose:bool=False):
         """
         Load all simulations in current project
         """
@@ -92,6 +188,7 @@ class Wolf2D_Project(Project):
             for key,val in sims_wolf2d.items():
                 if verbose:
                     print(key)
+                    logging.info(f'Loading simulation {key} : {val[key_Param.VALUE]}')
 
                 cursim = self.mysims[key] = Wolfresults_2D(join(self.wdir, val[key_Param.VALUE]), eps=epsilon, idx=key)
                 cursim.plotted=True
@@ -102,6 +199,7 @@ class Wolf2D_Project(Project):
             for key,val in sims_gpu2d.items():
                 if verbose:
                     print(key)
+                    logging.info(f'Loading simulation {key} : {val[key_Param.VALUE]}')
 
                 cursim = self.mysims[key] = wolfres2DGPU(Path(join(self.wdir, val[key_Param.VALUE])), eps=epsilon, idx=key)
                 cursim.plotted=True
@@ -128,6 +226,23 @@ class Wolf2D_Project(Project):
         for cursim in self.mysims.values():
             cursim.read_oneresult()
 
+    def get_simulation(self, key:Union[str,int]) -> Union[Wolfresults_2D, wolfres2DGPU]:
+        """
+        Get simulation by key
+
+        :param key: str or int -- key of the simulation to get or index of the simulation to get
+        """
+
+        if isinstance(key,int):
+            if key >=0 and key <len(self.mysims):
+                return self.mysims[self.mysims.keys()[key]]
+
+        elif isinstance(key,str):
+            if key in self.mysims.keys():
+                return self.mysims[key]
+
+        return None
+    
     def get_simulations(self) -> list:
         """
         Return a python list of simulations
@@ -175,6 +290,7 @@ class Wolf2D_Project(Project):
         """
         Lie les palettes d'un fichier projet et leur liaison potentielle avec les matrices
         """
+
         pals = self.get_group('palette')
         if pals is None:
             return
@@ -207,6 +323,7 @@ class Wolf2D_Project(Project):
         """
         Change le mode de vue dans une vue possible de "views_2D"
         """
+
         if which in views_2D:
             with ThreadPoolExecutor() as executor:
                 for cursim in self.mysims.values():
@@ -221,10 +338,11 @@ class Wolf2D_Project(Project):
          - chaque entrée est un dictionnaire dont la clé 'values' contient une liste pour chaque matrice du projet
          - chaque élément de liste est un tuple contenant toutes les valeurs utiles
         """
+
         self.poly = zonepoly
         self.poly_values = zonepoly.get_all_values_linked_polygon(self.get_simulations())
 
-    def get_values(self,which_type):
+    def get_values(self,which_type:Union[views_2D, Literal['i','j','block']]=None):
 
         if self.poly_values is None:
             raise Warning(_('Firstly call get_values_inside with a zone as argument -- Retry !'))
@@ -271,15 +389,58 @@ class Wolf2D_Project(Project):
 
 class MultiProjects():
     """Manager of multiple project files"""
+
     def __init__(self, wdir='') -> None:
 
         self.projects:dict[str, Wolf2D_Project]={}
         self.wdir=wdir
 
+    def __getitem__(self, key:Union[str,int]) -> Project:
+        """
+        Get project by key
+        """
+
+        return self.get_project(key)
+    
+    def get_one_simulation(self, key_project:str, key_sim:str) -> Union[Wolfresults_2D, wolfres2DGPU]:
+        """
+        Get one simulation by key in a project
+        """
+
+        if key_project in self.projects.keys():
+            return self.projects[key_project].get_simulation(key_sim)
+
+        return None
+
+    def get_same_simulation_in_projects(self, key_sim:str) -> dict[str, Union[Wolfresults_2D, wolfres2DGPU]]:
+        """
+        Get simulation by key in all projects
+        """
+
+        allsims = {}
+        for curkey, curproj in self.projects.items():
+            cursim = curproj.get_simulation(key_sim)
+            if cursim is not None:
+                allsims[curkey + ' - ' + key_sim] = cursim
+
+        return allsims
+
+    def __str__(self) -> str:
+        """
+        Return string representation
+        """
+
+        ret = 'Key : Directory\n'
+        for curkey,curproj in self.projects.items():
+            ret+=f'{curkey} : {Path(curproj.wdir)}\n'
+
+        return ret
+
     def add(self, project:Project, key=str, whichtype=project_type.GENERIC):
         """
         Add project to dict
         """
+
         if isinstance(project,str):
             if exists(project):
                 pass
@@ -297,6 +458,7 @@ class MultiProjects():
         """
         Récupération d'un projet sur base du nom ou d'une position
         """
+
         if isinstance(key,int):
             if key >=0 and key <len(self.projects):
                 return self.projects[self.projects.keys()[key]]
@@ -306,11 +468,12 @@ class MultiProjects():
                 return self.projects[key]
 
         return None
-
+    
     def read(self, filepath:str):
         """
         Read from file
         """
+
         if exists(filepath):
             with open(filepath,'r') as f:
                 self.projects = json.load(f)
@@ -319,6 +482,7 @@ class MultiProjects():
         """
         Write to file
         """
+
         with open(filepath,'w') as f:
             json.dump(self.projects,f)
 
@@ -326,6 +490,7 @@ class MultiProjects():
         """
         Load all simulations in projects
         """
+
         for keyp,valp in self.projects.items():
             print(keyp)
             valp.load_simulations(epsilon, verbose)
@@ -334,14 +499,18 @@ class MultiProjects():
         """
         Update all simulations in projects
         """
+
         for keyp,valp in self.projects.items():
             print(keyp)
             valp.update_simulations(epsilon, verbose)
 
-    def get_simulations_list(self, which_project=None) -> list:
+    def get_simulations_list(self, which_project:Union[str, list[str]]=None) -> list:
         """
         Return a python list of simulations
+
+        :param which_project: str or list of str -- key(s) of the project(s) to get simulations from
         """
+
         if which_project is None:
             allsims=[]
             for curproj in self.projects.values():
@@ -349,6 +518,15 @@ class MultiProjects():
                     allsims+=curproj.get_simulations()
             return allsims
 
+        elif isinstance(which_project, list):
+            allsims=[]
+            for curkey in which_project:
+                if curkey in self.projects.keys():
+                    curproj = self.projects[curkey]
+                    if isinstance(curproj, Wolf2D_Project):
+                        allsims+=curproj.get_simulations()
+            return allsims
+
         elif which_project in self.projects.keys():
             curproj = self.projects[which_project]
             if isinstance(curproj, Wolf2D_Project):
@@ -356,10 +534,13 @@ class MultiProjects():
 
         return None
 
-    def get_simulations_dict(self, which_project=None) -> dict:
+    def get_simulations_dict(self, which_project:Union[str, list[str]]=None) -> dict:
         """
         Return a python dict of simulations
+
+        :param which_project: str or list of str -- key(s) of the project(s) to get simulations from
         """
+
         if which_project is None:
             allsims={}
             for curkey, curproj in self.projects.items():
@@ -367,6 +548,15 @@ class MultiProjects():
                     allsims[curkey] = curproj.get_simulations()
             return allsims
 
+        elif isinstance(which_project, list):
+            allsims={}
+            for curkey in which_project:
+                if curkey in self.projects.keys():
+                    curproj = self.projects[curkey]
+                    if isinstance(curproj, Wolf2D_Project):
+                        allsims[curkey] = curproj.get_simulations()
+            return allsims
+
         elif which_project in self.projects.keys():
             curproj = self.projects[which_project]
             if isinstance(curproj, Wolf2D_Project):
@@ -374,7 +564,9 @@ class MultiProjects():
 
         return None
 
-    def set_currentview(self, which):
+    def set_currentview(self, which:views_2D):
+        """ Change le mode de vue dans une vue possible de 'views_2D' """
+
         for curproj in self.projects.values():
             if isinstance(curproj, Wolf2D_Project):
                 curproj.set_currentview(which)

wolfhece/pybridges.py

@@ -31,6 +31,7 @@ class stored_values_unk(Enum):
     UNORM      = (5, views_2D.UNORM.value)
     FROUDE     = (6, views_2D.FROUDE.value)
     WATERLEVEL = (7, views_2D.WATERLEVEL.value)
+    WATERSTAGE = (7, views_2D.WATERLEVEL.value)
     TOPOGRAPHY = (8, views_2D.TOPOGRAPHY.value)
     HEAD       = (-1, _('Difference of waterlevel (up-down)'))
     DIFFERENCE_Z_UP_DOWN    = (-1, _('Difference of waterlevel (up-down)'))

wolfhece/pypolygons_scen.py

@@ -7,20 +7,151 @@ from typing import Literal, Union
 import matplotlib.pyplot as plt
 from enum import Enum
 import logging
+from pathlib import Path
 
 from .PyTranslate import _
 from .PyVertexvectors import Zones, zone, vector, vectorproperties, getIfromRGB
 from .drawing_obj import Element_To_Draw
 from .PyTranslate import _
-from .wolfresults_2D import views_2D
+from .wolfresults_2D import views_2D, Wolfresults_2D
+from .Results2DGPU import wolfres2DGPU
 from .pybridges import stored_values_pos,stored_values_unk, parts_values, operators, stored_values_coords
 
+from zipfile import ZIP_DEFLATED, ZipFile
+
+class ZipFileWrapper(ZipFile):
+    def open(self, name="data", mode="r", pwd=None, **kwargs):
+        return super().open(name=name, mode=mode, pwd=pwd, **kwargs)
+
+    def read(self):
+        return super().read(name="data")
+
 class Extracting_Zones(Zones):
+    """ 
+    Classe permettant de récupérer les valeurs à l'intérieur des polygones
+    définis dans plusieurs zones.
+
+    Ces polygones ne sont pas nécessairement ordonnés ou relatifs au lit mineur.
+    
+    """
 
     def __init__(self, filename='', ox: float = 0, oy: float = 0, tx: float = 0, ty: float = 0, parent=None, is2D=True, idx: str = '', plotted: bool = True, mapviewer=None, need_for_wx: bool = False) -> None:
         super().__init__(filename, ox, oy, tx, ty, parent, is2D, idx, plotted, mapviewer, need_for_wx)
-        self.parts = {}
-        self.linked = {}
+        
+        self.parts:dict = None
+        self.linked:Union[dict, list] = None
+
+    def cache_data(self, outputfile:str):
+        """
+        Serialize the values in a file
+        """
+        self._serialize_values(outputfile)
+
+    def load_data(self, inputfile:str):
+        """
+        Deserialize the values from a file
+        """
+        self._deserialize_values(inputfile)
+
+    def _serialize_values(self, outputfile:str):
+        """
+        Serialize the values in a file
+        """
+        
+        import json
+        from codecs import getwriter
+        from typing import IO
+
+        class NumpyArrayEncoder(json.JSONEncoder):
+            def default(self, obj):
+                if isinstance(obj, np.integer):
+                    return int(obj)
+                elif isinstance(obj, np.floating):
+                    return float(obj)
+                elif isinstance(obj, np.ndarray):
+                    return obj.tolist()       
+                elif obj == Wolfresults_2D:
+                    return 'CPU'
+                elif obj == wolfres2DGPU:
+                    return 'GPU'         
+                
+                return json.JSONEncoder.default(self, obj)        
+
+        def _json_dump_bytes(fp: IO, obj):
+            StreamWriter = getwriter("utf-8")
+            return json.dump(fp=StreamWriter(fp), obj=obj, cls=NumpyArrayEncoder, indent=4)
+
+        def json_dump_zip(fp: IO, obj):
+            with ZipFileWrapper(fp, mode="w", compression=ZIP_DEFLATED, compresslevel=9) as zip_file:
+                with zip_file.open(mode="w") as _fp:
+                    _json_dump_bytes(fp=_fp, obj=obj)
+
+
+        with open(outputfile, 'wb') as f:
+
+            json_dump_zip(fp = f, obj = {'linked' : self.linked, 'values': self.parts})
+
+
+    def _deserialize_values(self, inputfile:str):
+        """
+        Deserialize the values from a file
+        """
+        
+        import json
+        from codecs import getwriter
+        from typing import IO
+
+        def json_load_zip(fp: IO):
+            with ZipFileWrapper(fp, mode="r") as zip_file:
+                return json.load(zip_file)
+
+        inputfile = Path(inputfile)
+        if not inputfile.exists():
+            logging.error(_('File {0} does not exist').format(inputfile))
+            return
+
+        with open(inputfile, 'rb') as f:
+            data = json_load_zip(f) #json.load(f)
+
+        tmp_linked = data['linked']
+        if isinstance(tmp_linked, dict):
+            self.linked = {}
+            for curkey, curgroup in tmp_linked.items():
+                self.linked[curkey] = [(curlink[0], Wolfresults_2D if curlink[1] == 'CPU' else wolfres2DGPU) for curlink in curgroup]
+
+            tmp_values = data['values']
+            self.parts = {}
+
+            for cuzone, curparts in tmp_values.items():
+                self.parts[cuzone] = {}
+
+                for curproj, curdict in curparts.items():
+                    self.parts[cuzone][curproj] = {}
+                    for curpoly, curval in curdict.items():
+                        self.parts[cuzone][curproj][curpoly] = {}
+                        for curgroup, curarray in curval.items():
+                            locdict = self.parts[cuzone][curproj][curpoly][curgroup] = {}
+                            
+                            for cursim, curnparray in curarray.items():
+                                locdict[cursim] = np.array([np.array([ tuple(lst1), np.array(lst2, dtype= np.int32)], dtype=object ) for lst1, lst2 in curnparray], dtype=object)
+                        
+        elif isinstance(tmp_linked, list):
+            self.linked = [(curlink[0], Wolfresults_2D if curlink[1] == 'CPU' else wolfres2DGPU) for curlink in tmp_linked]
+
+            tmp_values = data['values']
+            self.parts = {}
+
+            for cuzone, curparts in tmp_values.items():
+                self.parts[cuzone] = {}
+
+                for curpoly, curval in curparts.items():
+                    self.parts[cuzone][curpoly] = {}
+                    for curgroup, curarray in curval.items():
+                            locdict = self.parts[cuzone][curpoly][curgroup] = {}
+                            
+                            for cursim, curnparray in curarray.items():
+                                locdict[cursim] = np.array([np.array([ tuple(lst1), np.array(lst2, dtype= np.int32)], dtype=object ) for lst1, lst2 in curnparray], dtype=object)
+
 
     def find_values_inside_parts(self, linked_arrays):
         """
@@ -45,13 +176,14 @@ class Extracting_Zones(Zones):
 
             self.linked = [(curlink.idx, type(curlink)) for curlink in linked_arrays]
 
+        self.parts = {}
         for curzone in self.myzones:
-
             if isinstance(linked_arrays, dict):
                 locparts = self.parts[curzone.myname] = {}
                 for curkey, curgroup in linked_arrays.items():
                     locparts[curkey] = curzone.get_all_values_linked_polygon(curgroup, key_idx_names='name', getxy=True)
-            elif isinstance(linked_arrays, list):
+            
+            elif isinstance(linked_arrays, list):    
                 self.parts[curzone.myname]  = curzone.get_all_values_linked_polygon(linked_arrays, key_idx_names='name', getxy=True)
 
     def _get_heads(self,
@@ -228,6 +360,14 @@ class Extracting_Zones(Zones):
 
 class Polygons_Analyze(Zones):
     """
+    Classe permettant de récupérer les valeurs à l'intérieur des polygones
+    définis dans la dernière zone d'une fichier .vecz.
+
+    Ce fichier est typiquement le résultat de la création de polygones 
+    sur base de parallèles via l'interface graphique.
+
+    Utile notamment dans l'analyse de modélisations 2D (CPU et/ou GPU).
+
     """
 
     def __init__(self, myfile='', ds:float=5., ox: float = 0, oy: float = 0, tx: float = 0, ty: float = 0, parent=None, is2D=True, wx_exists:bool = False):
@@ -235,11 +375,15 @@ class Polygons_Analyze(Zones):
 
         self.myname = splitext(basename(myfile))[0]
 
+        self.linked:Union[dict,list] = None # type is depending on the type of linked arrays
+        self.river_values:dict = None
+
         self.riverbed = self.get_zone(0).myvectors[1]
         self.riverbed.prepare_shapely()
 
         self.polygons_zone:zone
         self.polygons_zone = self.get_zone(-1)
+        
         self.polygons_curvi = {}
         for curvert in self.polygons_zone.myvectors:
             self.polygons_curvi[curvert.myname] = curvert.myvertices[0].z
@@ -247,41 +391,130 @@ class Polygons_Analyze(Zones):
         for vec in self.polygons_zone.myvectors:
             vec.myprop.used=False # cache les polygones pour ne pas surcharger l'affichage éventuel
 
-    def colorize(self):
-        """Colorisation des polygones pour l'interface graphique"""
-        self.centralpart.myprop.color = getIfromRGB((0,255,0))
-        self.upstream.myprop.color = getIfromRGB((255,0,0))
-        self.downstream.myprop.color = getIfromRGB((0,0,255))
+    def cache_data(self, outputfile:str):
+        """
+        Serialize the values in a json file -- zipped
+        """
+
+        self._serialize_values(outputfile)
 
-    def highlighting(self, rgb=(255,0,0), linewidth=3):
+    def load_data(self, inputfile:str):
         """
-        Mise en évidence
+        Deserialize the values from a json file -- zipped
         """
-        self.centralpart.highlighting(rgb,linewidth)
 
-    def withdrawal(self):
+        self._deserialize_values(inputfile)
+
+    def _serialize_values(self, outputfile:str):
         """
-        Mise en retrait
+        Serialize the values in a file
         """
-        self.centralpart.withdrawal()
+        
+        import json
+        from codecs import getwriter
+        from typing import IO
+
+        class NumpyArrayEncoder(json.JSONEncoder):
+            def default(self, obj):
+                if isinstance(obj, np.integer):
+                    return int(obj)
+                elif isinstance(obj, np.floating):
+                    return float(obj)
+                elif isinstance(obj, np.ndarray):
+                    return obj.tolist()       
+                elif obj == Wolfresults_2D:
+                    return 'CPU'
+                elif obj == wolfres2DGPU:
+                    return 'GPU'         
+                
+                return json.JSONEncoder.default(self, obj)        
+
+        def _json_dump_bytes(fp: IO, obj):
+            StreamWriter = getwriter("utf-8")
+            return json.dump(fp=StreamWriter(fp), obj=obj, cls=NumpyArrayEncoder, indent=4)
+
+        def json_dump_zip(fp: IO, obj):
+            with ZipFileWrapper(fp, mode="w", compression=ZIP_DEFLATED, compresslevel=9) as zip_file:
+                with zip_file.open(mode="w") as _fp:
+                    _json_dump_bytes(fp=_fp, obj=obj)
+
+
+        with open(outputfile, 'wb') as f:
+
+            json_dump_zip(fp = f, obj = {'linked' : self.linked, 'values': self.river_values})
+
+
+    def _deserialize_values(self, inputfile:str):
+        """
+        Deserialize the values from a file
+        """
+        
+        import json
+        from codecs import getwriter
+        from typing import IO
+
+        def json_load_zip(fp: IO):
+            with ZipFileWrapper(fp, mode="r") as zip_file:
+                return json.load(zip_file)
+
+        inputfile = Path(inputfile)
+        if not inputfile.exists():
+            logging.error(_('File {0} does not exist').format(inputfile))
+            return
+
+        with open(inputfile, 'rb') as f:
+            data = json_load_zip(f) #json.load(f)
+
+        tmp_linked = data['linked']
+        if isinstance(tmp_linked, dict):
+            self.linked = {}
+            for curkey, curgroup in tmp_linked.items():
+                self.linked[curkey] = [(curlink[0], Wolfresults_2D if curlink[1] == 'CPU' else wolfres2DGPU) for curlink in curgroup]
+
+            tmp_values = data['values']
+            self.river_values = {}
+            for curproj, curdict in tmp_values.items():
+                self.river_values[curproj] = {}
+                for curpoly, curval in curdict.items():
+                    self.river_values[curproj][curpoly] = {}
+                    for curgroup, curarray in curval.items():
+                        locdict = self.river_values[curproj][curpoly][curgroup] = {}
+                        
+                        for cursim, curnparray in curarray.items():
+                            locdict[cursim] = np.array([np.array([ tuple(lst1), np.array(lst2, dtype= np.int32)], dtype=object ) for lst1, lst2 in curnparray], dtype=object)
+                        
+        elif isinstance(tmp_linked, list):
+            self.linked = [(curlink[0], Wolfresults_2D if curlink[1] == 'CPU' else wolfres2DGPU) for curlink in tmp_linked]
+
+            tmp_values = data['values']
+            self.river_values = {}
+            for curpoly, curval in tmp_values.items():
+                self.river_values[curpoly] = {}
+                for curgroup, curarray in curval.items():
+                        locdict = self.river_values[curpoly][curgroup] = {}
+                        
+                        for cursim, curnparray in curarray.items():
+                            locdict[cursim] = np.array([np.array([ tuple(lst1), np.array(lst2, dtype= np.int32)], dtype=object ) for lst1, lst2 in curnparray], dtype=object)
+
 
     def compute_distance(self, poly:LineString):
         """
         Compute the curvilinear distance along a support polyline
         """
+
         for curvert in self.polygons_zone.myvectors:
+            # Centre du polygone
             centerx = np.sum(np.asarray([cur.x for cur in curvert.myvertices[:4]]))/4.
             centery = np.sum(np.asarray([cur.y for cur in curvert.myvertices[:4]]))/4.
+            
             self.polygons_curvi[curvert.myname] = poly.project(Point([centerx,centery]))
 
-    def find_values_inside_parts(self, linked_arrays):
+    def find_values_inside_parts(self, linked_arrays:Union[dict,list]):
         """
-        Récupère les valeurs à l'intérieur :
-         - des parties du pont (amont, centrale, aval)
-         - de la discrétisation rivière en polygones
+        Récupère les valeurs à l'intérieur des polygones - dernière zone du fichier
 
-        Retour :
-         - dictionnaire dont la clé est le nom (ou l'index) du polygone dans la zone --> parties centrale, amont ou aval
+        Stockage :
+         - dictionnaire dont la clé est le nom (ou l'index) du polygone dans la zone
          - chaque entrée est un dictionnaire dont la clé 'values' contient un dictionnaire pour chaque matrice du projet
          - chaque élément de ce sous-dictionnaire est un tuple contenant toutes les valeurs utiles
 
@@ -291,9 +524,16 @@ class Polygons_Analyze(Zones):
 
         """
 
-        self.linked={}
-        for curkey, curgroup in linked_arrays.items():
-            self.linked[curkey] = [(curlink.idx, type(curlink)) for curlink in curgroup]
+        if isinstance(linked_arrays, dict):
+
+            self.linked={}
+
+            for curkey, curgroup in linked_arrays.items():
+                self.linked[curkey] = [(curlink.idx, type(curlink)) for curlink in curgroup]
+
+        elif isinstance(linked_arrays, list):
+
+            self.linked = [(curlink.idx, type(curlink)) for curlink in linked_arrays]
 
         # récupération des valeurs danbs les polygones "rivière"
         curzone = self.polygons_zone
@@ -302,12 +542,15 @@ class Polygons_Analyze(Zones):
                 self.river_values={}
                 for curkey, curgroup in linked_arrays.items():
                     self.river_values[curkey] = curzone.get_all_values_linked_polygon(curgroup, key_idx_names='name')
+
             elif isinstance(linked_arrays, list):
+
                 self.river_values = curzone.get_all_values_linked_polygon(linked_arrays, key_idx_names='name')
 
     def _get_river_heads(self,
                        which_group=None):
         """Compute Head"""
+
         head = {}
 
         z   = self.get_river_values(stored_values_unk.WATERLEVEL, which_group)
@@ -400,6 +643,11 @@ class Polygons_Analyze(Zones):
                             which_value:Union[stored_values_unk,stored_values_pos],
                             which_group=None,
                             operator:operators=operators.MEDIAN) -> dict:
+        """ 
+        Get values for the river polygons with an operator 
+        
+        operator : MEDIAN, MIN, MAX, PERCENTILE95, PERCENTILE5, ALL
+        """
 
         def extract_info(vals):
             vals_ret={}
@@ -407,18 +655,23 @@ class Polygons_Analyze(Zones):
                 curdict = vals_ret[curkeypoly]={}
                 for curkey, curvals in curpoly.items():
                     if curvals is not None:
-                        if operator == operators.MEDIAN:
-                            curdict[curkey] = np.median(curvals)
-                        elif operator == operators.MIN:
-                            curdict[curkey] = np.min(curvals)
-                        elif operator == operators.MAX:
-                            curdict[curkey] = np.max(curvals)
-                        elif operator == operators.PERCENTILE95:
-                            curdict[curkey] = np.percentile(curvals,95)
-                        elif operator == operators.PERCENTILE5:
-                            curdict[curkey] = np.percentile(curvals,5)
-                        elif operator == operators.ALL:
-                            curdict[curkey] =  (np.median(curvals), np.min(curvals), np.max(curvals), np.percentile(curvals,95), np.percentile(curvals,5))
+                        try:
+                            if operator == operators.MEDIAN:
+                                curdict[curkey] = np.median(curvals)
+                            elif operator == operators.MIN:
+                                curdict[curkey] = np.min(curvals)
+                            elif operator == operators.MAX:
+                                curdict[curkey] = np.max(curvals)
+                            elif operator == operators.PERCENTILE95:
+                                curdict[curkey] = np.percentile(curvals,95)
+                            elif operator == operators.PERCENTILE5:
+                                curdict[curkey] = np.percentile(curvals,5)
+                            elif operator == operators.ALL:
+                                curdict[curkey] =  (np.median(curvals), np.min(curvals), np.max(curvals), np.percentile(curvals,95), np.percentile(curvals,5))
+                        except:
+                            logging.error(_('Error in extract_info for key {0}').format(curkey))
+                            curdict[curkey] = -1.
+
             return vals_ret
 
         vals = self.get_river_values(which_value, which_group)
@@ -432,6 +685,32 @@ class Polygons_Analyze(Zones):
 
         return vals_ret
 
+    def get_s_values(self,
+                     which_value:Union[stored_values_unk,stored_values_pos]=stored_values_unk.WATERLEVEL,
+                     which_group:str=None,
+                     which_sim:str=None,
+                     operator:operators=operators.MEDIAN):
+        """ Get the values of the river polygons for a specific simulation """
+
+        s=[]
+        val=[]
+
+        myval = self.get_river_values_op(which_value, which_group, operator)
+
+        for curkey, curval in myval.items():
+            if len(curval)>0 and which_sim in curval.keys():
+                val.append(curval[which_sim])
+                s.append(self.polygons_curvi[curkey])
+
+        # Tri des valeurs selon l'absisse curviligne
+        ret = sorted(zip(s, val))
+
+        # Séparation des listes triées
+        s, val = zip(*ret)
+        
+        return s, val
+
+    
     def plot_unk(self,
                  figax = None,
                  which_value:Union[stored_values_unk,stored_values_pos]=stored_values_unk.WATERLEVEL,
@@ -440,6 +719,7 @@ class Polygons_Analyze(Zones):
                  options:dict=None,
                  label=True,
                  show=False):
+        """ Plot the values of the river polygons """
 
         if figax is None:
             fig,ax = plt.subplots(1,1)
@@ -520,6 +800,7 @@ class Polygons_Analyze(Zones):
                        which_group=None,
                        operator:operators=operators.MEDIAN,
                        show=False):
+        """ Plot the waterline """
 
         fig,ax = self.plot_unk(figax, stored_values_unk.TOPOGRAPHY, which_group, operator, options={'color':'black', 'linewidth':2}, label=False, show=False)
         figax=(fig,ax)
@@ -539,6 +820,7 @@ class Polygons_Analyze(Zones):
                        which_group=None,
                        operator:operators=operators.MEDIAN,
                        show=False):
+        """ Plot the bed elevation """
 
         fig,ax = self.plot_unk(figax, stored_values_unk.TOPOGRAPHY, which_group, operator, options={'color':'black', 'linewidth':2}, label=False, show=False)
 
@@ -555,6 +837,7 @@ class Polygons_Analyze(Zones):
                        which_group=None,
                        operator:operators=operators.MEDIAN,
                        show=False):
+        """ Plot the water stage /water level """
 
         fig,ax = self.plot_unk(figax, stored_values_unk.WATERLEVEL, which_group, operator, options={'color':'blue', 'linewidth':2}, show=False)
 
@@ -571,6 +854,7 @@ class Polygons_Analyze(Zones):
                        which_group=None,
                        operator:operators=operators.MEDIAN,
                        show=False):
+        """ Plot the water head """
 
         fig,ax = self.plot_unk(figax, stored_values_unk.HEAD, which_group, operator, options={'color':'blue', 'linewidth':2}, show=False)
 

{wolfhece-2.1.6.dist-info → wolfhece-2.1.8.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: wolfhece
-Version: 2.1.6
+Version: 2.1.8
 Author-email: Pierre Archambeau <pierre.archambeau@uliege.be>
 License: AGPL-v3 License
 Project-URL: Homepage, https://uee.uliege.be/hece

{wolfhece-2.1.6.dist-info → wolfhece-2.1.8.dist-info}/RECORD

@@ -11,7 +11,7 @@ wolfhece/PyGui.py,sha256=VKE785z9XLIWNbxqpyEceLK_wtmPJyq6A_M_qX_94Lg,104772
 wolfhece/PyGuiHydrology.py,sha256=wKhR-KthPRyzJ887NmsozmUpm2CIQIwO3IbYORCYjrE,7290
 wolfhece/PyHydrographs.py,sha256=GKK8U0byI45H9O_e4LAOOi7Aw0Tg7Q0Lx322stPg5IQ,3453
 wolfhece/PyPalette.py,sha256=_Nm2Lc4UxYlZgK8ifZDioG8a0at8oiteYC0x_4XugFc,24384
-wolfhece/PyParams.py,sha256=361iy9b9zTjoPCj9gh8-OIo0TBW5laLG87AkWE6f_eg,96290
+wolfhece/PyParams.py,sha256=963fkDSEadlLLxe7WM4Nl6nLOeZsOWSFmfg7hIsWPU4,96785
 wolfhece/PyPictures.py,sha256=-mJB0JL2YYiEK3D7_ssDkvYiMWK4ve9kXhozQXNeSx8,2216
 wolfhece/PyTranslate.py,sha256=4appkmNeHHZLFmUtaA_k5_5QL-5ymxnbVN4R2OblmtE,622
 wolfhece/PyVertex.py,sha256=dHTjyYYTn0F_NWerlAOBKHV79RUzEEtMJMldQtVc1Cs,40092
@@ -34,13 +34,13 @@ wolfhece/import_ascfiles.py,sha256=jg4urcLdSgFS1Knvh7AVGJqM44qc_uYDNrR568tMh-A,4
 wolfhece/ins.py,sha256=0aU1mo4tYbw64Gwzrqbh-NCTH1tukmk0mpPHjRPHZXU,12661
 wolfhece/irm_qdf.py,sha256=749SlAXiN1oXp5tfBJoPNJWxydQlY55K0qvIM5YexlM,15436
 wolfhece/ismember.py,sha256=fkLvaH9fhx-p0QrlEzqa6ySO-ios3ysjAgXVXzLgSpY,2482
-wolfhece/multiprojects.py,sha256=AMwEQZqo1Twh6tSPP-4L29-Fa8cI9d6dWce7l88awws,14675
+wolfhece/multiprojects.py,sha256=tHrAdOBoEEsuNS8hV7udbvduOZLj_NqF3ee5hSDBhN8,20903
 wolfhece/picc.py,sha256=KKPNk1BEe7QBzo2icIsdsxUopJ1LXYTomfdfeG2gCeA,7419
 wolfhece/pyGui1D.py,sha256=pzLWXQ_w3Y_yI846w1GklFO9h5lWZOqiUzg1BUPkuRI,121616
-wolfhece/pybridges.py,sha256=HJ1BL1HC7UrgpQ-3jKXkqPFmc-TzToL28Uex2hjHk6c,57166
+wolfhece/pybridges.py,sha256=4PRSsWngDmQnlVuN2tJj0C_HT1h47ExH9QTUPs_Wxlg,57215
 wolfhece/pydike.py,sha256=G4jfSZaAHHr4VWEJqnXSvEswXvlOz1yhbhQ6uu3AqyM,1943
 wolfhece/pylogging.py,sha256=i9Zugx3t9dPc7nBwcP20L_R4_k_WawpAQsvbZU8l9Hg,4230
-wolfhece/pypolygons_scen.py,sha256=lrUty990vT1iiILiIuTY8pNStiaZOi2dXWJuL9C-4Ps,26211
+wolfhece/pypolygons_scen.py,sha256=Zqr_vs--QEKRSxG-SfduqSR0aPT5rM3BRxmXTOSh2Iw,37146
 wolfhece/pyshields.py,sha256=YS6VVjjzoA-ZR6YRccqjMcW3McNqNLoQODC6TNNkmPw,22983
 wolfhece/pyviews.py,sha256=hYdyrEvWF48dGBDOLIwmC28C0L8I28U4ohXk9nltF94,9666
 wolfhece/pywalous.py,sha256=GRS5TKoVT0J-3PBqMdlyFRHrqkdYC-uHgDPcMjoDEZw,18674
@@ -66,7 +66,7 @@ wolfhece/apps/check_install.py,sha256=jrKR-njqnpIh6ZJqvP6KbDUPVCfwTNQj4glQhcyzs9
 wolfhece/apps/curvedigitizer.py,sha256=avWERHuVxPnJBOD_ibczwW_XG4vAenqWS8W1zjhBox8,4898
 wolfhece/apps/isocurrent.py,sha256=4XnNWPa8mYUK7V4zdDRFrHFIXNG2AN2og3TqWKKcqjY,3811
 wolfhece/apps/splashscreen.py,sha256=LkEVMK0eCc84NeCWD3CGja7fuQ_k1PrZdyqD3GQk_8c,2118
-wolfhece/apps/version.py,sha256=e4viWx1A5GTOG7x_ee5ipUIoVs03YPj1mmqIboCFecM,387
+wolfhece/apps/version.py,sha256=PDHOsWyysK2-MjO9X84FVTmdBAJq_uSXODfI01muO7E,387
 wolfhece/apps/wolf.py,sha256=gqfm-ZaUJqNsfCzmdtemSeqLw-GVdSVix-evg5WArJI,293
 wolfhece/apps/wolf2D.py,sha256=gWD9ee2-1pw_nUxjgRaJMuSe4kUT-RWhOeoTt_Lh1mM,267
 wolfhece/apps/wolf_logo.bmp,sha256=ruJ4MA51CpGO_AYUp_dB4SWKHelvhOvd7Q8NrVOjDJk,3126
@@ -264,8 +264,8 @@ wolfhece/sounds/sonsw2.wav,sha256=pFLVt6By0_EPQNt_3KfEZ9a1uSuYTgQSX1I_Zurv9Rc,11
 wolfhece/ui/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 wolfhece/ui/wolf_multiselection_collapsiblepane.py,sha256=yGbU_JsF56jsmms0gh7mxa7tbNQ_SxqhpAZxhm-mTy4,14860
 wolfhece/ui/wolf_times_selection_comparison_models.py,sha256=wCxGRnE3kzEkWlWA6-3X8ADOFux_B0a5QWJ2GnXTgJw,4709
-wolfhece-2.1.6.dist-info/METADATA,sha256=cugMr7AdpxcXB9lUui3lqbla85asvy4lo-Q8-0per-Y,2281
-wolfhece-2.1.6.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
-wolfhece-2.1.6.dist-info/entry_points.txt,sha256=AIu1KMswrdsqNq_2jPtrRIU4tLjuTnj2dCY-pxIlshw,276
-wolfhece-2.1.6.dist-info/top_level.txt,sha256=EfqZXMVCn7eILUzx9xsEu2oBbSo9liWPFWjIHik0iCI,9
-wolfhece-2.1.6.dist-info/RECORD,,
+wolfhece-2.1.8.dist-info/METADATA,sha256=na4Fmpn_XCY_8wAgiMs1m3YfEMKwUNC7mZ33W2JzU70,2281
+wolfhece-2.1.8.dist-info/WHEEL,sha256=cpQTJ5IWu9CdaPViMhC9YzF8gZuS5-vlfoFihTBC86A,91
+wolfhece-2.1.8.dist-info/entry_points.txt,sha256=AIu1KMswrdsqNq_2jPtrRIU4tLjuTnj2dCY-pxIlshw,276
+wolfhece-2.1.8.dist-info/top_level.txt,sha256=EfqZXMVCn7eILUzx9xsEu2oBbSo9liWPFWjIHik0iCI,9
+wolfhece-2.1.8.dist-info/RECORD,,

{wolfhece-2.1.6.dist-info → wolfhece-2.1.8.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: bdist_wheel (0.43.0)
+Generator: setuptools (70.1.0)
 Root-Is-Purelib: true
 Tag: py3-none-any