wolfhece 2.0.23__py3-none-any.whl → 2.0.25__py3-none-any.whl

wolfhece/hydrology/RetentionBasin.py

@@ -102,7 +102,7 @@ class RetentionBasin():
             # Init of the object allowing to determine the outlet flux
             tmpCounter = 0
             for element in _dictRB:
-                if(_dictRB[element]['from']['value'] == self.iD):
+                if(_dictRB[element]['from'][key_Param.VALUE] == self.iD):
                     if(tmpCounter>0):
                         print("ERROR: the same RB associated to two different caracteristics. Please check the RetentionBasin.postPro file.")
                         sys.exit()
@@ -122,28 +122,28 @@ class RetentionBasin():
                 if(myAnswer=="Y" or myAnswer=="y"):
                     isOk = True
                     self.dictRB['type'] = {}
-                    self.dictRB['type']['value'] = ""
+                    self.dictRB['type'][key_Param.VALUE] = ""
                 elif(myAnswer=="N" or myAnswer=="n"):
                     sys.exit()
         else:
             self.dictRB['type'] = {}
-            self.dictRB['type']['value'] = ""
+            self.dictRB['type'][key_Param.VALUE] = ""
 
 
 
-        self.type = self.dictRB['type']['value']
+        self.type = self.dictRB['type'][key_Param.VALUE]
         if('stagnant height' in self.dictRB):
-            self.hStagn =  float(self.dictRB['stagnant height']['value'])
+            self.hStagn =  float(self.dictRB['stagnant height'][key_Param.VALUE])
         if(self.type == 'HighwayRB'):
-            self.surface = float(self.dictRB['surface']['value'])
-            self.hBank = float(self.dictRB['height 2']['value'])
+            self.surface = float(self.dictRB['surface'][key_Param.VALUE])
+            self.hBank = float(self.dictRB['height 2'][key_Param.VALUE])
             self.volume = self.surface * self.hBank
         elif(self.type == 'RobiernuRB'):
-            self.volume = float(self.dictRB['volume']['value'])
+            self.volume = float(self.dictRB['volume'][key_Param.VALUE])
         elif(self.type == 'OrbaisRB'):
-            self.volume = float(self.dictRB['volume']['value'])
+            self.volume = float(self.dictRB['volume'][key_Param.VALUE])
             try:
-                zvFile = self.dictRB['Z-V file']['value']
+                zvFile = self.dictRB['Z-V file'][key_Param.VALUE]
             except:
                 zvFile = ""
             if(zvFile!=""):
@@ -156,12 +156,12 @@ class RetentionBasin():
         #     print("ERROR: Not implemented yet!")
         #     sys.exit()
         elif(self.type == 'ForcedDam'):
-            self.volume = float(self.dictRB['volume']['value'])
-            self.hi = float(self.dictRB['initial height']['value'])
+            self.volume = float(self.dictRB['volume'][key_Param.VALUE])
+            self.hi = float(self.dictRB['initial height'][key_Param.VALUE])
             self.vi = self.h_to_volume(self.hi)
 
             try:
-                zvFile = self.dictRB['Z-V file']['value']
+                zvFile = self.dictRB['Z-V file'][key_Param.VALUE]
             except:
                 zvFile = ""
             if(zvFile!=""):
@@ -174,11 +174,11 @@ class RetentionBasin():
                     self.read_zv(os.path.join(self.fileNameRead,zvFile))
 
             if("time delay" in self.dictRB):
-                self.timeDelay = float(self.dictRB["time delay"]["value"])
+                self.timeDelay = float(self.dictRB["time delay"][key_Param.VALUE])
         elif(self.type == "HelleRB"):
-            self.volume = float(self.dictRB['volume']['value'])
+            self.volume = float(self.dictRB['volume'][key_Param.VALUE])
             try:
-                zvFile = self.dictRB['Z-V file']['value']
+                zvFile = self.dictRB['Z-V file'][key_Param.VALUE]
                 isOk, zvFile = check_path(zvFile, self.fileNameRead, applyCWD=True)
                 if isOk<0:
                     print("ERROR : Problem in the Z-V file!")
@@ -194,13 +194,13 @@ class RetentionBasin():
 
 
         if ("initial height" in self.dictRB):
-            self.hi = float(self.dictRB['initial height']['value'])
+            self.hi = float(self.dictRB['initial height'][key_Param.VALUE])
             self.vi = self.h_to_volume(self.hi)
 
         if("time delay" in self.dictRB):
-            self.timeDelay = float(self.dictRB["time delay"]["value"])
+            self.timeDelay = float(self.dictRB["time delay"][key_Param.VALUE])
 
-         # Creation of Outlet object
+        # Creation of Outlet object
         self.outletObj = Outlet(self.dictRB, _workingDir=self.fileNameRead, time=self.time)
         self.qLim = Dumping(self.dictRB)
 
@@ -223,7 +223,7 @@ class RetentionBasin():
         self.intletsObj[name] = toPoint
 
         if("time delay from module" in self.dictRB):
-            nameModule = self.dictRB["time delay from module"]['value']
+            nameModule = self.dictRB["time delay from module"][key_Param.VALUE]
             if(toPoint.iD == nameModule):
                 self.timeDelay = toPoint.timeDelay
                 self.x = toPoint.x
@@ -250,7 +250,7 @@ class RetentionBasin():
         self._outFlow[name]["delta time"] = deltaTime
 
         if("time delay from module" in self.dictRB):
-            nameModule = self.dictRB["time delay from module"]['value']
+            nameModule = self.dictRB["time delay from module"][key_Param.VALUE]
             if(toPoint.iD == nameModule):
                 self.timeDelay = toPoint.timeDelay
                 self.x = toPoint.x
@@ -262,7 +262,7 @@ class RetentionBasin():
         self.directFluxObj[name] = toPoint
 
         if("time delay from module" in self.dictRB):
-            nameModule = self.dictRB["time delay from module"]['value']
+            nameModule = self.dictRB["time delay from module"][key_Param.VALUE]
             if(toPoint.iD == nameModule):
                 self.timeDelay = toPoint.timeDelay
                 self.x = toPoint.x
@@ -1332,7 +1332,7 @@ class RetentionBasin():
         self.timeDelayObj = None
 
         if("time delay from module" in self.dictRB):
-            nameModule = self.dictRB["time delay from module"]['value']
+            nameModule = self.dictRB["time delay from module"][key_Param.VALUE]
         else:
             return timeDelay
 

wolfhece/hydrology/SubBasin.py

@@ -2272,22 +2272,23 @@ class SubBasin:
 
         if method == -1 :
             # detect the method on the params files -> TO DO
-            myMethod = int(wolf_If.myparams["Distributed production model parameters"]["Type of infiltration"]["value"])
+            myMethod = int(wolf_If.get_param("Distributed production model parameters","Type of infiltration"))
 
 
         if(myMethod==cst.tom_infil_Horton):
             myParams = []
-            myParams.append(float(wolf_If.myparams["Horton parameters"]["F0"]["value"]))
-            myParams.append(float(wolf_If.myparams["Horton parameters"]["Fc"]["value"]))
-            myParams.append(float(wolf_If.myparams["Horton parameters"]["k"]["value"]))
+            myParams.append(float(wolf_If.get_param("Horton parameters","F0")))
+            myParams.append(float(wolf_If.get_param("Horton parameters","Fc")))
+            myParams.append(float(wolf_If.get_param("Horton parameters","k")))
+            
 
-            uMax = float(wolf_If.myparams["Distributed production model parameters"]["Umax"]["value"])
+            uMax = float(wolf_If.get_param("Distributed production model parameters","Umax"))
             p = self.myRain[:]
             nb_timesteps = len(p)
 
-            timeLag = float(wolf_If.myparams["Distributed production model parameters"]["Time lag"]["value"])
+            timeLag = float(wolf_If.get_param("Distributed production model parameters","Time lag"))
             try:
-                timeSpan = float(wolf_If.myparams["Distributed production model parameters"]["Time span soil"]["value"])
+                timeSpan = float(wolf_If.get_param("Distributed production model parameters","Time span soil"))
                 nbIntervals = math.ceil(timeSpan/self.deltaT)
             except:
                 nbIntervals = len(self.myRain)

wolfhece/lazviewer/points/expr.py

@@ -1,4 +1,4 @@
-from ..vfuncs import vfuncs
+from ..vfuncsdir import vfuncs
 from scipy.spatial import kdtree
 import numpy as np
 import copy

wolfhece/mesh2d/config_manager.py

@@ -7,7 +7,8 @@ import numpy as np
 import subprocess
 
 from ..PyTranslate import _
-from ..wolfresults_2D import wolf2dprev,Wolfresults_2D
+from ..wolfresults_2D import Wolfresults_2D
+from .wolf2dprev import prev_infiltration
 from ..wolf_array import WolfArray
 
 CHECK_EXT=['.top', '.frot']
@@ -313,7 +314,7 @@ class config_manager_2D:
         nameitem = self.treelist.GetItemText(myitem).lower()
 
         if nameitem=='fil':
-            mydata:wolf2dprev.prev_infiltration
+            mydata:prev_infiltration
             txt = _('Number of zones : {} \n'.format(mydata.nb_zones))
             for i in range(1,mydata.nb_zones+1):
                 txt += _('Q zone {} : {} \n'.format(i,mydata.my_Q[0][i]))
@@ -381,7 +382,7 @@ class config_manager_2D:
         name = self._find_sim(keyname)
         if name is not None:
             curdict['genfile'] = name
-            curdict['fil'] = wolf2dprev.prev_infiltration(None,name)
+            curdict['fil'] = prev_infiltration(None,name)
             curdict['fil'].read_file()
 
     def _find_sim(self,wd):

wolfhece/mesh2d/wolf2dprev.py

@@ -42,7 +42,18 @@ PREV_READ_TXT = 1
 PREV_READ_FINE = 2
 PREV_READ_MB = 3
 
-
+def find_sep(line:str):
+    if ',' in line:
+        return ','
+    elif ' ' in line:
+        return ' '
+    elif '\t' in line:
+        return '\t'
+    elif ';' in line:
+        return ';'
+    else:
+        logging.error(f"Unrecognized separator in line {line}")
+        return None
 
 class prev_parameters_blocks:
     """ #> Paramètres de calcul propres aux blocs
@@ -1677,9 +1688,12 @@ class prev_boundary_conditions():
             pass
 
     def read_file(self, lines: list, orient):
-        """#> lecture du fichier de paramètres"""
+        """ Lecture du fichier de paramètres"""
+
         for curline in lines:
-            tmp = curline.split(',')
+
+            tmp = curline.split(find_sep(curline))
+
             i = int(tmp[0])
             j = int(tmp[1])
             ntype = int(tmp[2])
@@ -1708,7 +1722,7 @@ class prev_boundary_conditions():
                 # Strong boundary conditions are not vectors.
                 pass
             else:
-                raise Exception(f"Unrecognized orientation {orient}")
+               logging.error(f"Unrecognized orientation {orient}")
 
     def get_xy(self, i, j, orient, aswolf=False):
 
@@ -2388,20 +2402,15 @@ class prev_infiltration():
 
         if self.nb_steps > 0:
 
-            if ',' in lines[1]:
-                sep = ','
-            elif '\t' in lines[1]:
-                sep = '\t'
-            elif ';' in lines[1]:
-                sep = ';'
-            else:
+            sep = find_sep(lines[1])
+
+            if sep is None:
                 logging.error(_("Values in the '.fil' file are not separated by comma, semi-comma or tabulation -- Check your file -- Continuing with zero values"))
                 self.my_Q = np.zerons((self.nb_steps, self.nb_zones))
                 return
-
-            locarray = [[float(val) for val in lines[i].strip().split(sep)[:self.nb_zones + 1]] for i in
-                        range(1, len(lines))]
-            self.my_Q = np.asarray(locarray)
+            else:
+                locarray = [[float(val) for val in lines[i].strip().split(sep)[:self.nb_zones + 1]] for i in range(1, len(lines))]
+                self.my_Q = np.asarray(locarray)
 
     def read_array(self):
         """lecture de la matrice d'infiltration"""
@@ -2487,8 +2496,8 @@ class prev_suxsuy():
         with open(self.filenamesuy, 'r') as f:
             linesY = f.read().splitlines()
 
-        linesX = [np.float64(curline.split(',')) for curline in linesX]
-        linesY = [np.float64(curline.split(',')) for curline in linesY]
+        linesX = [np.float64(curline.split(find_sep(curline))) for curline in linesX]
+        linesY = [np.float64(curline.split(find_sep(curline))) for curline in linesY]
 
         myparams: prev_parameters_simul
         myparams = self.parent.myparam
@@ -2666,7 +2675,7 @@ class bloc_file():
             lines = f.read().splitlines()
 
         # #lecture du nombre de blocs et de la taille maximale du contour
-        tmpline = lines[0].split(',')
+        tmpline = lines[0].split(find_sep(lines[0]))
         self.nb_blocks = int(tmpline[0])
         self.max_size_cont = int(tmpline[1])
 
@@ -2689,7 +2698,7 @@ class bloc_file():
         decal = 2
         if self.interior:
             for i in range(decal, nb + decal):
-                tmpline = lines[i].split(',')
+                tmpline = lines[i].split(find_sep(lines[i]))
                 # FIXME no *dx, *dy ??? I think it's i,j : cell coordinates
                 x = float(tmpline[0]) + trlx
                 y = float(tmpline[1]) + trly
@@ -2702,7 +2711,7 @@ class bloc_file():
                 external_border.add_vertex(curvert)
         else:
             for i in range(decal, nb + decal):
-                tmpline = lines[i].split(',')
+                tmpline = lines[i].split(find_sep(lines[i]))
                 x = float(tmpline[0]) + trlx
                 y = float(tmpline[1]) + trly
                 curvert = wolfvertex(x, y)
@@ -2728,7 +2737,7 @@ class bloc_file():
 
         # lecture des tailles de maille pour tous les blocs
         for i in range(self.nb_blocks):
-            tmp = lines[decal].split(',')
+            tmp = lines[decal].split(find_sep(lines[decal]))
             self.my_blocks[i].dx = float(tmp[0])
             self.my_blocks[i].dy = float(tmp[1])
             decal += 1
@@ -2921,7 +2930,7 @@ class bloc_extent:
 
             ##lecture des données
             for i in range(self.nb):
-                tmp = lines[i + 1].split(',')
+                tmp = lines[i + 1].split(find_sep(lines[i+1]))
 
                 x = float(tmp[0]) + trlx
                 y = float(tmp[1]) + trly
@@ -2933,10 +2942,10 @@ class bloc_extent:
             self.external_border.set_limits() # on retient les limites en cas de modifications
 
             ##emprise du bloc en accord avec le grid magnétique et l'extension de surface utile pour les relations de voisinage entre blocs
-            tmp = lines[self.nb + 1].split(',')
+            tmp = lines[self.nb + 1].split(find_sep(lines[self.nb + 1]))
             self.xmin = float(tmp[0])
             self.xmax = float(tmp[1])
-            tmp = lines[self.nb + 2].split(',')
+            tmp = lines[self.nb + 2].split(find_sep(lines[self.nb + 2]))
             self.ymin = float(tmp[0])
             self.ymax = float(tmp[1])
 

wolfhece/pybridges.py

@@ -1,7 +1,7 @@
 """
 Bridges manager
 
-@author : Pierre Archambeau
+:author : Pierre Archambeau
 
 2023 - Liège University - HECE
 """
@@ -253,9 +253,8 @@ class Bridge(Zones):
          - 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
 
-        ***
+
         ATTENTION : si linked_arrays est un dictionnaire, alors un niveau supérieur est ajouté sur base des clés de ce dictionnaire, dans ce cas, self.linked est un dict et non une liste
-        ***
 
         """
         curzone = self.get_zone(zones_in_file.PARTS.value)

wolfhece/scenario/config_manager.py

@@ -19,7 +19,7 @@ import matplotlib.pyplot as plt
 import types
 
 from ..PyTranslate import _
-from ..wolfresults_2D import wolf2dprev,Wolfresults_2D
+from ..wolfresults_2D import Wolfresults_2D
 from ..wolf_array import WolfArray, header_wolf, WOLF_ARRAY_FULL_INTEGER
 from .check_scenario import check_file_update, check_file_bc, import_files
 from .update_void import create_new_file as update_void