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

wolfhece/Results2DGPU.py

@@ -18,7 +18,6 @@ try:
     from wolfgpu.results_store import ResultsStore, ResultType
 except :
     logging.error(_("Unable to import wolfgpu.results_store.ResultsStore. Please install wolfgpu package or add a symlink to the wolfgpu package in the wolfhece directory"))
-    # raise ImportError(_("Unable to import wolfgpu.results_store.ResultsStore. Please install wolfgpu package or add a symlink to the wolfgpu package in the wolfhece directory"))
 
 def _load_res(x) -> tuple[csr_array, csr_array, csr_array]:
     store:ResultsStore
@@ -125,71 +124,6 @@ class Cache_Results2DGPU():
         else:
             return None
 
-    # def danger_map(self, start:int=0, end:int=-1, every:int=1) -> Union[WolfArray, tuple[WolfArray, WolfArray, WolfArray]]:
-    #     """
-    #     Create Danger Maps
-
-    #     From start to end (index 0-based)
-    #     Indexes are related to the self._results, not the absolute GPU results
-    #     """
-
-    #     # If __init__ with only_h==True, only wd is pre-loaded into memory
-    #     # all_maps ==True is more than one Numpy array in self.results
-    #     all_maps = not self.only_h
-
-    #     # Number of  time steps
-    #     number_of_time_steps = len(self._results)
-    #     if end ==-1:
-    #         end = number_of_time_steps
-
-    #     # Init Danger Maps based on results type
-    #     # GPU --> 1 block, Numpy array
-    #     danger_map_matrix_h = self.get_h(0, dense=True)
-
-    #     # set zeros
-    #     danger_map_matrix_h[:,:] = 0.
-
-    #     if all_maps:
-    #         danger_map_matrix_v   = danger_map_matrix_h.copy()
-    #         danger_map_matrix_mom = danger_map_matrix_h.copy()
-    #         danger = [danger_map_matrix_h, danger_map_matrix_v, danger_map_matrix_mom]
-
-    #     if all_maps:
-
-    #         for time_step in tqdm(range(start, end, every)):
-
-    #             wd = self.get_h(time_step, dense=True)
-    #             qx = self.get_qx(time_step, dense=True)
-    #             qy = self.get_qy(time_step, dense=True)
-
-    #             v = np.zeros(wd.shape)
-    #             mom = np.zeros(wd.shape)
-
-    #             i,j = np.where(wd > 0.)
-    #             v[i,j] = (qx[i,j]**2.+qy[i,j]**2.)**.5/wd[i,j]
-
-    #             mom = v*wd
-
-    #             comp = [wd, v, mom]
-
-    #             # Comparison
-    #             for curdanger, curcomp in zip(danger, comp):
-    #                 i,j = np.where(curdanger < curcomp)
-    #                 curdanger[i,j] = curcomp[i,j]
-
-    #     else:
-    #         for time_step in tqdm(range(start, end, every)):
-
-    #             wd = self.get_h(time_step)
-    #             i,j = np.where(danger_map_matrix_h < wd)
-    #             danger_map_matrix_h[i,j] = wd[i,j]
-
-
-    #     if all_maps:
-    #         return (danger_map_matrix_h, danger_map_matrix_v, danger_map_matrix_mom)
-    #     else:
-    #         return danger_map_matrix_h
-
 
 class wolfres2DGPU(Wolfresults_2D):
     """
@@ -442,3 +376,24 @@ class wolfres2DGPU(Wolfresults_2D):
             return self._cache.get_qy(idx+1, True).T
         else:
             return None
+
+
+class Sim_2D_GPU():
+    """ Simulation 2D GPU -- Interface """
+
+    def __init__(self, fname:Union[str,Path] = '') -> None:
+
+        try:
+            from wolfgpu.simple_simulation import SimpleSimulation
+        except:
+            logging.error(_("Unable to import wolfgpu.simple_simulation.SimpleSimulation. Please install wolfgpu package or add a symlink to the wolfgpu package in the wolfhece directory"))
+
+        self.filename = Path(fname)
+        self.loaded = False
+
+        if self.filename.exists():
+            self.sim = SimpleSimulation()
+            self.sim.load(self.filename)
+            self.loaded = True
+
+        pass

wolfhece/apps/__init__.py

@@ -0,0 +1 @@
+""" Ceci est une doc """

wolfhece/apps/version.py

@@ -5,7 +5,7 @@ class WolfVersion():
 
         self.major = 2
         self.minor = 0
-        self.patch = 23
+        self.patch = 25
 
     def __str__(self):
 

wolfhece/drawing_obj.py

@@ -9,6 +9,15 @@ class Element_To_Draw:
     """
 
     def __init__(self, idx:str = '', plotted:bool = True, mapviewer = None, need_for_wx:bool = False) -> None:
+        """
+        Constructor of the class
+
+        :param idx: identifier
+        :param plotted: boolean if plotting action must be processed
+        :param mapviewer: WolfMapViewer instance attached to the object
+        :param need_for_wx: test if wx App is running. If not, raise an error
+    
+        """
 
         self.idx = idx  # identifier
         self.xmin=0.    # spatial extension - lower left corner X
@@ -27,7 +36,7 @@ class Element_To_Draw:
         if need_for_wx and (not self.wx_exists):
             raise NameError(_('wx App is not running or you need it --> check your code and retry !'))
 
-    #FIXME : checked and plotted are the same thing ??
+    #FIXME : checked and plotted are the same thing ?? -- YES but conserve for retro-compatibility
     @property
     def checked(self) -> bool:
         """

wolfhece/hydrology/Catchment.py

@@ -1779,7 +1779,7 @@ class Catchment:
                 paramsInput = Wolf_Param(to_read=False,toShow=False)
                 paramsInput.ReadFile(fileToModif)
                 try:
-                    myInterval = float(paramsInput.myparams["Distributed production model parameters"]["Time span soil"]["value"])
+                    myInterval = paramsInput.get_param("Distributed production model parameters", "Time span soil")
                     nbIntervals = math.floor(myInterval/myBasin.deltaT)
                 except:
                     nbIntervals = len(myBasin.myRain)-1
@@ -1847,12 +1847,11 @@ class Catchment:
         if fileNameIn!="":
              fileName = fileNameIn
         else:
-            directory = self.paramsInput.myparams["Measuring stations SPW"]["Directory"]["value"]
+            directory = self.paramsInput.get_param("Measuring stations SPW", "Directory")
             isOk, directory = check_path(directory, self.workingDir)
             if isOk<0:
                 print("ERROR : measuring station data path not present! ")
-            fileName = directory + "\\" + self.paramsInput.myparams["Measuring stations SPW"]["Filename"]["value"]
-            fileName = os.path.join(directory, self.paramsInput.myparams["Measuring stations SPW"]["Filename"]["value"])
+            fileName = os.path.join(directory, self.paramsInput.get_param("Measuring stations SPW", "Filename")) 
 
 
         if os.path.exists(fileName):

wolfhece/hydrology/Dumping.py

@@ -1,4 +1,5 @@
 import datetime                         # module which contains objects treating dates
+from ..PyParams import key_Param
 
 from ..PyTranslate import _
 
@@ -16,17 +17,17 @@ class Dumping:
         self.flows = []
         self.times = []
         
-        self.myType = self.myRbDict['type']['value']
+        self.myType = self.myRbDict['type'][key_Param.VALUE]
         
         if("nb ecretages" in self.myRbDict): 
-            self.nbFlows = int(self.myRbDict["nb ecretages"]["value"])
+            self.nbFlows = int(self.myRbDict["nb ecretages"][key_Param.VALUE])
 
             for i in range(1,self.nbFlows+1):
-                self.flows.append(float(self.myRbDict['ecretage '+str(i)]['value']))
+                self.flows.append(float(self.myRbDict['ecretage '+str(i)][key_Param.VALUE]))
                 if(i==1):
                     self.times.append(-1.0)
                 else:
-                    tmpDate = datetime.datetime.strptime(self.myRbDict['time ecr. '+str(i)]['value'], "%d-%m-%Y %H:%M:%S").replace(tzinfo=datetime.timezone.utc)
+                    tmpDate = datetime.datetime.strptime(self.myRbDict['time ecr. '+str(i)][key_Param.VALUE], "%d-%m-%Y %H:%M:%S").replace(tzinfo=datetime.timezone.utc)
                     tmpTime = datetime.datetime.timestamp(tmpDate)
                     self.times.append(tmpTime)
 
@@ -47,7 +48,7 @@ class Dumping:
 
 
     def compute_constant(self):
-        qLim = float(self.myRbDict['ecretage']['value'])
+        qLim = float(self.myRbDict['ecretage'][key_Param.VALUE])
         return qLim
 
     

wolfhece/hydrology/Optimisation.py

@@ -522,10 +522,12 @@ class Optimisation(wx.Frame):
     # def init_2layers_linIF(self):
     def init_lumped_model(self):
 
-        self.saParam.myparams["Initial parameters"]["Read initial parameters?"]["value"] = 0
+        curCase = self.myCases[0]
+
+        self.saParam.change_param("Initial parameters", "Read initial parameters?", 0)
 
         # Retrieve the dictionnary with the properties of all models (parameters, files, etc)
-        myModel = self.myCases[0].refCatchment.myModel
+        myModel = curCase.refCatchment.myModel
         nbParams = cste.modelParamsDict[myModel]["Nb"]
         myModelDict = cste.modelParamsDict[myModel]["Parameters"]
 
@@ -533,36 +535,40 @@ class Optimisation(wx.Frame):
         i=1
         for element in myModelDict:
             paramName = prefix1 + str(i)
-            self.myCases[0].launcherParam.myparams[paramName]={}
-            self.myCases[0].launcherParam.myparams[paramName]["type_of_data"] = {}
-            self.myCases[0].launcherParam.myparams[paramName]["type_of_data"]["value"] = element
+            curCase.launcherParam.add_param(groupname=paramName, name="type_of_data", value=element, type="int")
             i+=1
 
-        self.myCases[0].launcherParam.myparams["Paramètres à varier"]["Nombre de paramètres à varier"]["value"] = nbParams
+        curCase.launcherParam.change_param("Paramètres à varier","Nombre de paramètres à varier",nbParams)
         self.nbParams = nbParams
 
         prefix2 = "Parameter "
         for i in range(1,self.nbParams+1):
             paramName = prefix2 + str(i)
-            if not paramName in self.saParam.myparams["Lowest values"]:
-                self.saParam.myparams["Lowest values"][paramName] = {}
-                self.saParam.myparams["Lowest values"][paramName]["value"] = 0.0
-            if not paramName in self.saParam.myparams["Highest values"]:
-                self.saParam.myparams["Highest values"][paramName] = {}
-                self.saParam.myparams["Highest values"][paramName]["value"] = 0.0
+            self.saParam.add_param(groupname="Lowest values", name=paramName, value=0.0)
+            # if not paramName in self.saParam.myparams["Lowest values"]:
+            #     self.saParam.myparams["Lowest values"][paramName] = {}
+            #     self.saParam.myparams["Lowest values"][paramName]["value"] = 0.0
+            self.saParam.add_param(groupname="Highest values", name=paramName, value=0.0)
+            # if not paramName in self.saParam.myparams["Highest values"]:
+            #     self.saParam.myparams["Highest values"][paramName] = {}
+            #     self.saParam.myparams["Highest values"][paramName]["value"] = 0.0
             if not paramName in self.saParam.myparams["Steps"]:
                 self.saParam.myparams["Steps"][paramName] = {}
                 self.saParam.myparams["Steps"][paramName]["value"] = 0.0
-            if not paramName in self.saParam.myparams["Initial parameters"]:
-                self.saParam.myparams["Initial parameters"][paramName] = {}
-                self.saParam.myparams["Initial parameters"][paramName]["value"] = 0.0
+            self.saParam.add_param(groupname="Initial parameters", name=paramName, value=0.0)
+            # if not paramName in self.saParam.myparams["Initial parameters"]:
+            #     self.saParam.myparams["Initial parameters"][paramName] = {}
+            #     self.saParam.myparams["Initial parameters"][paramName]["value"] = 0.0
             paramName = prefix1 + str(i)
-            self.myCases[0].launcherParam.myparams[paramName]["geom_filename"] = {}
-            self.myCases[0].launcherParam.myparams[paramName]["geom_filename"]["value"] = "my_geom.txt"
-            self.myCases[0].launcherParam.myparams[paramName]["type_of_geom"] = {}
-            self.myCases[0].launcherParam.myparams[paramName]["type_of_geom"]["value"] = 0
-            self.myCases[0].launcherParam.myparams[paramName]["type_of_exchange"] = {}
-            self.myCases[0].launcherParam.myparams[paramName]["type_of_exchange"]["value"] = -3
+            curCase.launcherParam.add_param(groupname=paramName, name="geom_filename", value="my_geom.txt")
+            curCase.launcherParam.add_param(groupname=paramName, name="type_of_geom", value=0)
+            curCase.launcherParam.add_param(groupname=paramName, name="type_of_exchange", value=-3)
+            # self.myCases[0].launcherParam.myparams[paramName]["geom_filename"] = {}
+            # self.myCases[0].launcherParam.myparams[paramName]["geom_filename"]["value"] = "my_geom.txt"
+            # self.myCases[0].launcherParam.myparams[paramName]["type_of_geom"] = {}
+            # self.myCases[0].launcherParam.myparams[paramName]["type_of_geom"]["value"] = 0
+            # self.myCases[0].launcherParam.myparams[paramName]["type_of_exchange"] = {}
+            # self.myCases[0].launcherParam.myparams[paramName]["type_of_exchange"]["value"] = -3
 
 
     def init_myParams(self, idLauncher=0):
@@ -636,6 +642,9 @@ class Optimisation(wx.Frame):
 
 
     def init_with_reference(self, idLauncher=0):
+        
+        curCase = self.myCases[idLauncher]
+        refCatch = curCase.refCatchment
 
         # First path opened by the GUI selecting the the working directory
         defaultPath = self.myCases[idLauncher].launcherParam.get_param("Calculs","Répertoire simulation de référence")
@@ -657,7 +666,7 @@ class Optimisation(wx.Frame):
 
         # Recover the Catchment object
         self.myCases[idLauncher].refCatchment = myPostPro.myCatchments["Catchment 1"]['Object']
-        self.myCases[idLauncher].launcherParam.myparams["Calculs"]["Répertoire simulation de référence"]["value"] = self.myCases[idLauncher].refCatchment.workingDir
+        curCase.launcherParam.change_param("Calculs", "Répertoire simulation de référence", refCatch.workingDir)
 
         # Create an empty geom.txt file
         geomName = self.myCases[idLauncher].launcherParam.get_param("Récupération des résultats","geom_filename")
@@ -668,10 +677,10 @@ class Optimisation(wx.Frame):
 
 
         # Complete compare.how file
-        dateTmp = self.myCases[idLauncher].refCatchment.paramsInput.myparams["Temporal Parameters"]["Start date time"]["value"]
-        self.comparHowParam.myparams["Comparison 1"]["date begin 1"]["value"] = dateTmp
-        dateTmp = self.myCases[idLauncher].refCatchment.paramsInput.myparams["Temporal Parameters"]["End date time"]["value"]
-        self.comparHowParam.myparams["Comparison 1"]["date end 1"]["value"] = dateTmp
+        dateTmp = refCatch.paramsInput.get_param("Temporal Parameters","Start date time")
+        self.comparHowParam.change_param("Comparison 1","date begin 1",dateTmp)
+        dateTmp = refCatch.paramsInput.get_param("Temporal Parameters","End date time")
+        self.comparHowParam.change_param("Comparison 1","date end 1",dateTmp)
 
         # update param files
         self.myCases[idLauncher].launcherParam.SavetoFile(None)
@@ -716,36 +725,33 @@ class Optimisation(wx.Frame):
         self.myCases[idLauncher].launcherParam.Reload(None)
 
         # Init the outlet ID
-        try:
-            # In semi distributed optimisation the stations in which there are measurements is read first
-            stationOut = self.optiParam.myparams["Semi-Distributed"]["Station measures 1"]["value"]
-            compareFileName = self.optiParam.myparams["Semi-Distributed"]["File reference 1"]["value"]
-            shutil.copyfile(compareFileName, os.path.join(self.workingDir,"compare.txt"))
-        except:
-            # If only one station is specified, it could also be present in the compare.how file
-            try:
-                stationOut = self.comparHowParam.myparams["Comparison 1"]["station measures"]["value"]
-            except:
+        stationOut = self.optiParam.get_param("Semi-Distributed","Station measures 1")
+        if stationOut is None:
+            stationOut = self.comparHowParam.get_param("Comparison 1","station measures")
+            if stationOut is None:
                 stationOut = " "
+        else:
+            compareFileName = self.optiParam.get_param("Semi-Distributed","File reference 1")
+            shutil.copyfile(os.path.join(self.workingDir,compareFileName), os.path.join(self.workingDir,"compare.txt"))
         self.myCases[idLauncher].refCatchment.define_station_out(stationOut)
 
 
     def init_dir_in_params(self):
 
-        self.optiParam.myparams["Optimizer"]["dir"]["value"] = self.workingDir
+        self.optiParam.change_param("Optimizer","dir", self.workingDir)
         for i in range(len(self.myCases)):
-            self.optiParam.myparams["Cases"]["dir_"+str(i+1)]["value"] = os.path.join(self.workingDir,"simul_"+str(i+1))
-        self.optiParam.myparams["Predefined parameters"]["fname"]["value"] = self.workingDir+"param.what"
+            self.optiParam.change_param("Cases","dir_"+str(i+1), os.path.join(self.workingDir,"simul_"+str(i+1)))
+        self.optiParam.change_param("Predefined parameters","fname", os.path.join(self.workingDir,"param.what"))
         self.optiParam.SavetoFile(None)
         self.optiParam.Reload(None)
 
 
     def update_dir_in_params(self):
 
-        self.optiParam.myparams["Optimizer"]["dir"]["value"] = self.workingDir
+        self.optiParam.change_param("Optimizer","dir", self.workingDir)
         for i in range(len(self.myCases)):
-            self.optiParam.myparams["Cases"]["dir_"+str(i+1)]["value"] = self.myCases[i].launcherDir
-        self.optiParam.myparams["Predefined parameters"]["fname"]["value"] = self.workingDir+"param.what"
+            self.optiParam.change_param("Cases","dir_"+str(i+1), self.myCases[i].launcherDir)
+        self.optiParam.change_param("Predefined parameters","fname", os.path.join(self.workingDir,"param.what"))
         self.optiParam.SavetoFile(None)
         self.optiParam.Reload(None)
 
@@ -757,7 +763,7 @@ class Optimisation(wx.Frame):
 
 
     def update_parameters_launcher(self, idLauncher=0):
-        self.myCases[idLauncher].launcherParam.myparams["Paramètres à varier"]["Nombre de paramètres à varier"]["value"] = self.nbParams
+        self.myCases[idLauncher].launcherParam.change_param("Paramètres à varier","Nombre de paramètres à varier",self.nbParams)
 
 
     def update_parameters_SA(self):
@@ -1232,8 +1238,8 @@ class Optimisation(wx.Frame):
             previousLevel = 1
             # Read all ref data
             for iRef in range(1, nbRefs+1):
-                stationOut = self.optiParam.myparams["Semi-Distributed"]["Station measures "+str(iRef)]["value"]
-                compareFileName = self.optiParam.myparams["Semi-Distributed"]["File reference "+str(iRef)]["value"]
+                stationOut = self.optiParam.get_param("Semi-Distributed","Station measures "+str(iRef))
+                compareFileName = self.optiParam.get_param("Semi-Distributed","File reference "+str(iRef))
                 readDict[stationOut] = compareFileName
             self.compareFilesDict = readDict
             # Get the initial number of intervals 
@@ -1431,19 +1437,26 @@ class Optimisation(wx.Frame):
 
             for i in range(nbInlets):
                 paramName = prefix1 + str(nbParamsModel+i+1)
-                self.myCases[idLauncher].launcherParam.myparams[paramName]={}
-                self.myCases[idLauncher].launcherParam.myparams[paramName]["type_of_data"] = {}
-                self.myCases[idLauncher].launcherParam.myparams[paramName]["type_of_data"]["value"] = cste.exchange_parameters_py_timeDelay
-                self.myCases[idLauncher].launcherParam.myparams[paramName]["type_of_data"]["type"] = 'Integer'
-                self.myCases[idLauncher].launcherParam.myparams[paramName]["geom_filename"] = {}
-                self.myCases[idLauncher].launcherParam.myparams[paramName]["geom_filename"]["value"] = "my_geom.txt"
-                self.myCases[idLauncher].launcherParam.myparams[paramName]["type_of_geom"] = {}
-                self.myCases[idLauncher].launcherParam.myparams[paramName]["type_of_geom"]["value"] = 0
-                self.myCases[idLauncher].launcherParam.myparams[paramName]["type_of_exchange"] = {}
-                self.myCases[idLauncher].launcherParam.myparams[paramName]["type_of_exchange"]["value"] = -3
+                # self.myCases[idLauncher].launcherParam.myparams[paramName]={}
+                # self.myCases[idLauncher].launcherParam.myparams[paramName]["type_of_data"] = {}
+                # self.myCases[idLauncher].launcherParam.myparams[paramName]["type_of_data"]["value"] = cste.exchange_parameters_py_timeDelay
+                # self.myCases[idLauncher].launcherParam.myparams[paramName]["type_of_data"]["type"] = 'Integer'
+                self.myCases[idLauncher].launcherParam.add_group(paramName)
+                self.myCases[idLauncher].launcherParam.add_param(paramName, "type_of_data", cste.exchange_parameters_py_timeDelay, Type_Param.Integer)
+                # self.myCases[idLauncher].launcherParam.myparams[paramName]["geom_filename"] = {}
+                # self.myCases[idLauncher].launcherParam.myparams[paramName]["geom_filename"]["value"] = "my_geom.txt"
+                self.myCases[idLauncher].launcherParam.add_param(paramName, "geom_filename", "my_geom.txt", Type_Param.File)
+                # self.myCases[idLauncher].launcherParam.myparams[paramName]["type_of_geom"] = {}
+                # self.myCases[idLauncher].launcherParam.myparams[paramName]["type_of_geom"]["value"] = 0
+                self.myCases[idLauncher].launcherParam.add_param(paramName, "type_of_geom", 0, Type_Param.Integer)
+                # self.myCases[idLauncher].launcherParam.myparams[paramName]["type_of_exchange"] = {}
+                # self.myCases[idLauncher].launcherParam.myparams[paramName]["type_of_exchange"]["value"] = -3
+                self.myCases[idLauncher].launcherParam.add_param(paramName, "type_of_exchange", -3, Type_Param.Integer)
+
                 # Particularity of this Python parameter
-                self.myCases[idLauncher].launcherParam.myparams[paramName]["junction_name"] = {}
-                self.myCases[idLauncher].launcherParam.myparams[paramName]["junction_name"]["value"] = inletsNames[i]
+                # self.myCases[idLauncher].launcherParam.myparams[paramName]["junction_name"] = {}
+                # self.myCases[idLauncher].launcherParam.myparams[paramName]["junction_name"]["value"] = inletsNames[i]
+                self.myCases[idLauncher].launcherParam.add_param(paramName, "junction_name", inletsNames[i], Type_Param.String)
 
                 self.myParams[nbParamsModel+i+1] = {}
                 self.myParams[nbParamsModel+i+1]["type"] = self.myCases[idLauncher].launcherParam.get_param(paramName, "type_of_data")
@@ -1609,8 +1622,8 @@ class Optimisation(wx.Frame):
             readDict = {}
             # Read all ref data
             for iRef in range(1, nbRefs+1):
-                stationOut = self.optiParam.myparams["Semi-Distributed"]["Station measures "+str(iRef)]["value"]
-                compareFileName = self.optiParam.myparams["Semi-Distributed"]["File reference "+str(iRef)]["value"]
+                stationOut = self.optiParam.get_param("Semi-Distributed","Station measures "+str(iRef))
+                compareFileName = self.optiParam.get_param("Semi-Distributed","File reference "+str(iRef))
                 readDict[stationOut] = compareFileName
             self.compareFilesDict = readDict
             # Sort all the junctions by level
@@ -1672,8 +1685,8 @@ class Optimisation(wx.Frame):
             readDict = {}
             # Read all ref data
             for iRef in range(1, nbRefs+1):
-                stationOut = self.optiParam.myparams["Semi-Distributed"]["Station measures "+str(iRef)]["value"]
-                compareFileName = self.optiParam.myparams["Semi-Distributed"]["File reference "+str(iRef)]["value"]
+                stationOut = self.optiParam.get_param("Semi-Distributed","Station measures "+str(iRef))
+                compareFileName = self.optiParam.get_param("Semi-Distributed","File reference "+str(iRef))
                 readDict[stationOut] = compareFileName
             self.compareFilesDict = readDict
             # Sort all the junctions by level
@@ -1725,8 +1738,8 @@ class Optimisation(wx.Frame):
             readDict = {}
             # Read all ref data
             for iRef in range(1, nbRefs+1):
-                stationOut = self.optiParam.myparams["Semi-Distributed"]["Station measures "+str(iRef)]["value"]
-                compareFileName = self.optiParam.myparams["Semi-Distributed"]["File reference "+str(iRef)]["value"]
+                stationOut = self.optiParam.get_param("Semi-Distributed","Station measures "+str(iRef))
+                compareFileName = self.optiParam.get_param("Semi-Distributed","File reference "+str(iRef))
                 readDict[stationOut] = compareFileName
             self.compareFilesDict = readDict
             # Sort all the junctions by level

wolfhece/hydrology/Outlet.py

@@ -6,6 +6,8 @@ from scipy.interpolate import interp1d
 import csv
 import datetime                         # module which contains objects treating dates
 
+from ..PyParams import key_Param
+
 from .read import *
 from ..PyTranslate import _
 
@@ -26,12 +28,12 @@ class Outlet:
         self.times = []
         self.time = time
 
-        self.myType = self.myRbDict['type']['value']
+        self.myType = self.myRbDict['type'][key_Param.VALUE]
         self.myRef = []
         self.myRefInterp = None
 
         try:
-            fileRef = self.myRbDict["Reference fileName"]['value']
+            fileRef = self.myRbDict["Reference fileName"][key_Param.VALUE]
             isOk, fileRef = check_path(fileRef, self.fileNameRead, applyCWD=True)
             if isOk<0:
                 print("ERROR : Problem in the Reference fileName!")
@@ -39,7 +41,8 @@ class Outlet:
         except:
             fileRef = ""
         try:
-            tz = float(self.myRbDict["Time zone"]["value"])
+            tz = float(self.myRbDict["Time zone"][key_Param.VALUE])
+            tz = float(self.myRbDict["Time zone"][key_Param.VALUE])
         except:
             tz = 0.0
 
@@ -58,14 +61,14 @@ class Outlet:
 
 
         if("nb flows" in self.myRbDict):
-            self.nbFlows = int(self.myRbDict["nb flows"]["value"])
+            self.nbFlows = int(self.myRbDict["nb flows"][key_Param.VALUE])
 
             for i in range(1,self.nbFlows+1):
-                self.flows.append(float(self.myRbDict['flow '+str(i)]['value']))
+                self.flows.append(float(self.myRbDict['flow '+str(i)][key_Param.VALUE]))
                 if(i==1):
                     self.times.append(-1.0)
                 else:
-                    tmpDate = datetime.datetime.strptime(self.myRbDict['time '+str(i)]['value'], "%d-%m-%Y %H:%M:%S").replace(tzinfo=datetime.timezone.utc)
+                    tmpDate = datetime.datetime.strptime(self.myRbDict['time '+str(i)][key_Param.VALUE], "%d-%m-%Y %H:%M:%S").replace(tzinfo=datetime.timezone.utc)
                     tmpTime = datetime.datetime.timestamp(tmpDate)
                     self.times.append(tmpTime)
 
@@ -90,11 +93,11 @@ class Outlet:
     def compute_HighwayRB(self, h):
         "This function compute the "
         q = 0.0
-        h0 = float(self.myRbDict['stagnant height']['value'])
-        h1 = float(self.myRbDict['height 1']['value'])
-        h2 = float(self.myRbDict['height 2']['value'])
-        q1 = float(self.myRbDict['flow 1']['value'])
-        q2 = float(self.myRbDict['flow 2']['value'])
+        h0 = float(self.myRbDict['stagnant height'][key_Param.VALUE])
+        h1 = float(self.myRbDict['height 1'][key_Param.VALUE])
+        h2 = float(self.myRbDict['height 2'][key_Param.VALUE])
+        q1 = float(self.myRbDict['flow 1'][key_Param.VALUE])
+        q2 = float(self.myRbDict['flow 2'][key_Param.VALUE])
 
         if(h<=h1):
             q = q1
@@ -103,11 +106,11 @@ class Outlet:
         return q
 
     def compute_RobiernuRB(self, h):
-        q = float(self.myRbDict['flow 1']['value'])
+        q = float(self.myRbDict['flow 1'][key_Param.VALUE])
         return q
 
     def compute_OrbaisRB(self, h):
-        q = float(self.myRbDict['flow 1']['value'])
+        q = float(self.myRbDict['flow 1'][key_Param.VALUE])
         return q