wolfhece 1.8.7__py3-none-any.whl → 1.8.9__py3-none-any.whl

wolfhece/ftp/downloader.py

@@ -0,0 +1,141 @@
+import ftplib
+import os
+import re
+
+"""
+MIT license: 2017 - Jwely
+
+Example usage:
+``` python
+import ftplib
+ftp = ftplib.FTP(mysite, username, password)
+download_ftp_tree(ftp, remote_dir, local_dir)
+```
+
+The code above will look for a directory called "remote_dir" on the ftp host, and then duplicate the
+directory and its entire contents into the "local_dir".
+
+*** Note that if wget is an option, I recommend using that instead ***
+
+"""
+
+
+def _is_ftp_dir(ftp_handle, name, guess_by_extension=True):
+    """ simply determines if an item listed on the ftp server is a valid directory or not """
+
+    # if the name has a "." in the fourth to last position, its probably a file extension
+    # this is MUCH faster than trying to set every file to a working directory, and will work 99% of time.
+    if guess_by_extension is True:
+        if len(name) >= 4:
+            if name[-4] == '.':
+                return False
+
+    original_cwd = ftp_handle.pwd()  # remember the current working directory
+    try:
+        ftp_handle.cwd(name)  # try to set directory to new name
+        ftp_handle.cwd(original_cwd)  # set it back to what it was
+        return True
+
+    except ftplib.error_perm as e:
+        print(e)
+        return False
+
+    except Exception as e:
+        print(e)
+        return False
+
+
+def _make_parent_dir(fpath):
+    """ ensures the parent directory of a filepath exists """
+    dirname = os.path.dirname(fpath)
+    while not os.path.exists(dirname):
+        try:
+            os.makedirs(dirname)
+            print("created {0}".format(dirname))
+        except OSError as e:
+            print(e)
+            _make_parent_dir(dirname)
+
+
+def _download_ftp_file(ftp_handle, name, dest, overwrite):
+    """ downloads a single file from an ftp server """
+    #_make_parent_dir(dest.lstrip("/"))
+    if not os.path.exists(dest) or overwrite is True:
+        try:
+            with open(dest, 'wb') as f:
+                ftp_handle.retrbinary("RETR {0}".format(name), f.write)
+            print("downloaded: {0}".format(dest))
+        except FileNotFoundError:
+            print("FAILED: {0}".format(dest))
+    else:
+        print("already exists: {0}".format(dest))
+
+
+def _file_name_match_patern(pattern, name):
+    """ returns True if filename matches the pattern"""
+    if pattern is None:
+        return True
+    else:
+        return bool(re.match(pattern, name))
+
+
+def _mirror_ftp_dir(ftp_handle, name, overwrite, guess_by_extension, pattern):
+    """ replicates a directory on an ftp server recursively """
+    
+    ftp_handle.cwd(name)
+    files=[]
+    ftp_handle.dir(files.append)
+    files = [curf.split()[8] for curf in files]
+    for item in files:
+        if _is_ftp_dir(ftp_handle, item, guess_by_extension):
+                
+            original_directory = os.getcwd()  # remember working directory before function is executed
+            os.makedirs(item, exist_ok=True)
+            os.chdir(item)  # change working directory to ftp mirror directory
+            _mirror_ftp_dir(ftp_handle, item, overwrite, guess_by_extension, pattern)
+            os.chdir(original_directory)
+            ftp_handle.cwd('..')
+        else:
+            if _file_name_match_patern(pattern, name):
+                _download_ftp_file(ftp_handle, item, item, overwrite)
+            else:
+                # quietly skip the file
+                pass
+
+
+def download_ftp_tree(ftp_handle, path, destination, pattern=None, overwrite=False, guess_by_extension=True):
+    """
+    Downloads an entire directory tree from an ftp server to the local destination
+    :param ftp_handle: an authenticated ftplib.FTP instance
+    :param path: the folder on the ftp server to download
+    :param destination: the local directory to store the copied folder
+    :param pattern: Python regex pattern, only files that match this pattern will be downloaded.
+    :param overwrite: set to True to force re-download of all files, even if they appear to exist already
+    :param guess_by_extension: It takes a while to explicitly check if every item is a directory or a file.
+        if this flag is set to True, it will assume any file ending with a three character extension ".???" is
+        a file and not a directory. Set to False if some folders may have a "." in their names -4th position.
+    """
+    path = path.lstrip("/")
+    original_directory = os.getcwd()  # remember working directory before function is executed
+    os.chdir(destination)  # change working directory to ftp mirror directory
+
+    _mirror_ftp_dir(
+        ftp_handle,
+        path,
+        pattern=pattern,
+        overwrite=overwrite,
+        guess_by_extension=guess_by_extension)
+
+    os.chdir(original_directory)  # reset working directory to what it was before function exec
+
+
+if __name__ == "__main__":
+    # Example usage mirroring all jpg files in an FTP directory tree.
+    mysite = "some_ftp_site"
+    username = "anonymous"
+    password = None
+    remote_dir = ""
+    local_dir = ""
+    pattern = ".*\.jpg$"
+    ftp = ftplib.FTP(mysite, username, password)
+    download_ftp_tree(ftp, remote_dir, local_dir, pattern=pattern, overwrite=False, guess_by_extension=True)

wolfhece/hydrology/Catchment.py

@@ -31,6 +31,7 @@ from .read import *
 from ..wolf_array import *
 from ..PyParams import *
 from ..PyVertex import cloud_vertices, getIfromRGB,wolfvertex
+from .PyWatershed import Watershed, Node_Watershed
 
 
 # %% Classes
@@ -50,6 +51,9 @@ class Catchment:
 
     time_delays_F:np.ndarray                                                # array pointed to the array time_delays in Fortran and composed the time delays of each subbasin
     _version:float                                                          # version of the wolfHydro python code. Useful for identifying the file versions to read and how to interpret them
+    charact_watrshd:Watershed                                               # Watershed object containing the most useful properties of the arrays in Characteristics maps
+    subBasinCloud:cloud_vertices                                            # cloud of points containing the true coordinates (used in simulation) of all subbasin outlets
+    iP_Cloud:cloud_vertices                                                 # cloud of points containing the given coordinates (given in param files) of all subbasin outlets
 
 
     def __init__(self, _name, _workingDir, _plotAllSub, _plotNothing, _initWithResults=True, _catchmentFileName="", _rbFileName="", _tz=0, version=cst.VERSION_WOLFHYDRO):
@@ -62,7 +66,7 @@ class Catchment:
         if(self.plotNothing == True):
             self.plotAllSub = False
         self.tz = _tz                                                       # time zone in GMT+0
-        self.time = []                                                      #
+        self.time = None                                                    #
         self.deltaT = 0.0                                                   # Time step of the simulation
         self.dateBegin = None                                               # Object datetime of the beginning date of the simulation
         self.dateEnd = None                                                 # Object datetime of the end date of the simulation
@@ -77,6 +81,10 @@ class Catchment:
         self.subBasinCloud.myprop.color=getIfromRGB((255,131,250))
         self.subBasinCloud.myprop.filled=True
 
+        self.iP_Cloud=cloud_vertices()
+        self.iP_Cloud.myprop.color=getIfromRGB((255,131,250))
+        self.iP_Cloud.myprop.filled=True
+
         self.retentionBasinDict = {}
         self.topologyDict = {}
         self.dictIdConversion = {}
@@ -183,6 +191,8 @@ class Catchment:
         # self.topo_wolf_array = WolfArray(self.workingDir + "Characteristic_maps/Drainage_basin.b2")
         self.time_wolf_array = WolfArray(os.path.join(self.workingDir,"Characteristic_maps/Drainage_basin.time"))
         self.conv_wolf_array = WolfArray(os.path.join(self.workingDir,"Characteristic_maps/Drainage_basin.cnv"))
+        self.charact_watrshd = Watershed(self.workingDir)
+        self.set_eff_outlet_coord()
 
         # time array:
         self.get_time()
@@ -465,15 +475,19 @@ class Catchment:
             else:
                 print("ERROR: Impossible to indentify the position of the interior points! Please check your param file!")
                 sys.exit()
+            
+            mysubxy=wolfvertex(x,y)
+            self.iP_Cloud.add_vertex(mysubxy)
 
             idSorted = self.catchmentDict['dictIdConversion'][counter]
+            cur_outlet:wolfvertex = self.subBasinCloud.myvertices[idSorted-1]["vertex"]
             # self.subBasinDict[counter] = SubBasin(counter, self.time, self.workingDir, self.hyeto, x, y, idSorted)
             self.subBasinDict[counter] = SubBasin(self.dateBegin, self.dateEnd, self.deltaT, self.myModel, self.workingDir,
-                                         _iD_interiorPoint=counter, _idSorted=idSorted, _hyeto=self.hyeto, _x=x, _y=y, _tz=self.tz, version=self._version)
+                                         _iD_interiorPoint=counter, _idSorted=idSorted, _hyeto=self.hyeto, _x=cur_outlet.x, _y=cur_outlet.y, _tz=self.tz, version=self._version)
             self.catchmentDict['ss'+str(counter)] = self.subBasinDict[counter]
 
             mysubxy=wolfvertex(x,y)
-            self.subBasinCloud.add_vertex(mysubxy)
+            self.iP_Cloud.add_vertex(mysubxy)
 
         counter += 1
         tmpNameParam = 'Outlet Coordinates'
@@ -494,12 +508,13 @@ class Catchment:
         # x = float(self.paramsInput.myparams[tmpNameParam]['X']['value'])
         # y = float(self.paramsInput.myparams[tmpNameParam]['Y']['value'])
         idSorted = self.catchmentDict['dictIdConversion'][counter]
+        cur_outlet:wolfvertex = self.subBasinCloud.myvertices[idSorted-1]["vertex"]
         # self.subBasinDict[counter] = SubBasin(counter, self.time, self.workingDir, self.hyeto, x, y, idSorted)
         self.subBasinDict[counter] = SubBasin(self.dateBegin, self.dateEnd, self.deltaT, self.myModel, self.workingDir,
                                      _iD_interiorPoint=counter, _idSorted=idSorted, _hyeto=self.hyeto, _x=x, _y=y, _tz=self.tz, version=self._version)
 
         mysubxy=wolfvertex(x,y)
-        self.subBasinCloud.add_vertex(mysubxy)
+        self.iP_Cloud.add_vertex(mysubxy)
 
         self.catchmentDict['ss'+str(counter)] = self.subBasinDict[counter]
         # This following line must be present to create the outFlow dictionary of the last element
@@ -1803,6 +1818,26 @@ class Catchment:
         if(show):
             plt.show()
 
+    
+    def get_all_cumulRain(self, selection_by_iD=[]) -> tuple[np.array, list[np.array]]:
+        '''
+
+        '''
+        list_rain = []
+
+        if(selection_by_iD==[]):
+            for iBasin in range(1,len(self.subBasinDict)+1):
+                curBasin:SubBasin = self.subBasinDict[iBasin]
+                list_rain.append(curBasin.cumul_rain)
+        else:
+            for iBasin in self.subBasinDict:
+                if iBasin in selection_by_iD:
+                    curBasin:SubBasin = self.subBasinDict[iBasin]
+                    list_rain.append(curBasin.cumul_rain)
+
+        
+        return self.time, list_rain
+
 
     def read_measuring_stations_SPW(self, fileNameIn=""):
         """
@@ -2336,6 +2371,48 @@ class Catchment:
         return self._version
 
 
+
+    def get_sub_Nash(self, measure:SubBasin,
+                     selection_by_iD, 
+                     intervals:list[tuple[datetime.datetime]]=[]):
+        
+        # for element in selection_by_iD:
+        #     junctionKey = self.get_key_catchmentDict(name=element)
+        #     if junctionKey in self.subBasinDict:
+        #         curSub:SubBasin = self.subBasinDict[junctionKey]
+        #         ns = curSub.evaluate_Nash(measure=measure, intervals=intervals)
+        junctionKey = self.get_key_catchmentDict(name=selection_by_iD)
+        if junctionKey in self.catchmentDict:
+            curSub:SubBasin = self.catchmentDict[junctionKey]
+            ns = curSub.evaluate_Nash(measure=measure, intervals=intervals)
+
+        return ns
+    
+
+
+    def get_sub_peak(self, selection_by_iD, 
+                     intervals:list[tuple[datetime.datetime]]=[]):
+        
+        junctionKey = self.get_key_catchmentDict(name=selection_by_iD)
+        if junctionKey in self.catchmentDict:
+            curSub:SubBasin = self.catchmentDict[junctionKey]
+            ns = curSub.get_peak(intervals=intervals)
+            
+        return ns
+    
+
+    def set_eff_outlet_coord(self):
+        
+        all_nodes = [self.charact_watrshd.find_rivers(whichsub=ii+1)[0][0] for ii in range(self.nbSubBasin)]
+        for el in all_nodes:
+            el:Node_Watershed
+            mysubxy=wolfvertex(el.x,el.y)
+            self.subBasinCloud.add_vertex(mysubxy)
+
+        return 0
+
+    
+
     def make_nd_array(self, c_pointer, shape, dtype=np.float64, order='C', own_data=True,readonly=False):
         arr_size = np.prod(shape[:]) * np.dtype(dtype).itemsize
 

wolfhece/hydrology/Comparison.py

@@ -1368,9 +1368,29 @@ class Comparison:
     def plot_all_diff_cumulRain_with_lagtime(self, interval, selection_by_iD=[], writeDir=""):
 
         for idCatch in self.myCatchments:
-            curCatch = self.myCatchments[idCatch]['Object']
+            curCatch:Catchment = self.myCatchments[idCatch]['Object']
             graph_title = curCatch.name + " :"
-            curCatch.plot_all_diff_cumulRain_with_lagtime(interval, selection_by_iD=selection_by_iD, graph_title=graph_title, show=False, writeDir=writeDir)
+            curCatch.plot_all_diff_cumulRain_with_lagtime(interval, lagTime=0.0, selection_by_iD=selection_by_iD, graph_title=graph_title, show=False, writeDir=writeDir)
+
+
+
+    # FIXME : TODO complete that function that plot a comparison of the cumulated volumes
+    # def plot_all_cumulRain(self, selection_by_iD:list=[], writeDir:str="", show:bool=True):
+
+    #     times = []
+    #     for idCatch in self.myCatchments:
+    #         curCatch:Catchment = self.myCatchments[idCatch]['Object']
+    #         graph_title = curCatch.name + " :"
+    #         cur_t, curVol = curCatch.get_all_cumulRain(selection_by_iD)
+
+    #     for 
+    #         plt.figure()
+    #         plt.title(graph_title)
+    #         for i in range(len(curVol)):
+    #             plt.plot(cur_t, curVol[i])
+    #         plt.savefig(os.path.join(writeDir, graph_title))
+        
+    #     if show : plt.show()
 
 
 
@@ -1533,4 +1553,91 @@ class Comparison:
 
         backupAddData = self.plotDict[stationKey]["Add Data"]
         # self.plotDict[stationKey]["Add Data"] = {}
-        del self.plotDict[stationKey]["Add Data"]
+        del self.plotDict[stationKey]["Add Data"]
+
+
+    
+    def plot_Nash_and_peak(self, stationKey:list[str, int], measures:list[SubBasin], intervals:list=[]):
+        assert len(stationKey) == len(measures)
+
+        all_ns = {stationKey[i]: [ self.myCatchments[el]["Object"].get_sub_Nash(measures[i], stationKey[i], intervals) 
+                    for el in self.myCatchments ] 
+                  for i in range(len(stationKey))
+                }
+        print(all_ns)
+
+        all_peaks = [ [ self.myCatchments[el]["Object"].get_sub_peak(stationKey[i], intervals) 
+                        for el in self.myCatchments ] 
+                     for i in range(len(stationKey)) 
+                    ]
+        
+        print(all_peaks)
+
+        meas_peak = [ measures[i].get_peak(intervals) 
+                     for i in range(len(stationKey)) ]
+        
+        # The following lines is take the peak difference between simulation and measurements -> Display 0.0 if the measurement is 0.0
+        isZero = np.array(meas_peak)==0
+        notZero = np.array(meas_peak)!=0
+        peak_prop = {stationKey[i]: [ list( (np.array(meas_peak[i])-np.array(el))/(np.array(meas_peak[i])+isZero[i]) *notZero[i] ) 
+                        for el in all_peaks[i] ] 
+                     for i in range(len(stationKey))
+                    }
+        
+        print(meas_peak)
+        print(peak_prop)
+
+        all_data = [all_ns, peak_prop]
+
+        # Define all colors
+        colors_Nash = {}
+        for key, value in all_ns.items():
+            colors_Nash[key] = []
+            for i_model in range(len(value)):
+                colors_Nash[key].append([])
+                for j in range(len(value[i_model])):
+                    curNS = value[i_model][j]
+                    if curNS<0.0:
+                        colors_Nash[key][i_model].append("r")
+                        continue
+                    elif curNS<0.4:
+                        colors_Nash[key][i_model].append("tab:orange")
+                        continue
+                    elif curNS<0.6:
+                        colors_Nash[key][i_model].append("tab:olive")
+                        continue
+                    elif curNS<0.8:
+                        colors_Nash[key][i_model].append("tab:green")
+                        continue
+                    else:
+                        colors_Nash[key][i_model].append("g")
+        
+
+        colors_peaks = {}
+        for key, value in peak_prop.items():
+            colors_peaks[key] = []
+            for i_model in range(len(value)):
+                colors_peaks[key].append([])
+                for j in range(len(value[i_model])):
+                    curP = value[i_model][j]
+                    if curP<0.0:
+                        colors_peaks[key][i_model].append("r")
+                    else:
+                        colors_peaks[key][i_model].append("b")
+
+        all_colors = [colors_Nash, colors_peaks]
+
+        ## Sort all station in a particular order
+        sorted_keys = list(all_data[0].keys())
+
+        ## Str of dates
+        all_names = ["-".join([cdate[0].strftime("%d/%m/%Y"), cdate[1].strftime("%d/%m/%Y")]) for cdate in intervals]
+
+
+        ## Plot 
+        nb_stations = len(stationKey)
+        type_of_model = [self.myCatchments[el]["Title"] for el in self.myCatchments]
+        type_of_data = type_of_data = ["Nash", r"$  \frac{Q^{s}_{max}-Q^{m}_{max}}{Q^{m}_{max}} $ "]
+        
+        ph.bar_Nash_n_other(all_data, all_colors, nb_x=len(intervals), nb_data=len(type_of_model), nb_lines=nb_stations, 
+                            y_titles=type_of_data, x_titles=all_names, nameModel=type_of_model, line_names=sorted_keys, toShow=True)

wolfhece/hydrology/Optimisation.py

@@ -412,6 +412,8 @@ class Optimisation(wx.Frame):
         self.enable_MenuBar("Param files")
         self.enable_MenuBar("Launch")
         self.enable_MenuBar("Tools")
+        if self.debugDLL:
+            self.enable_MenuBar("Debug")
     
     def apply_optim(self, event, idLauncher=0):
 
@@ -572,14 +574,13 @@ class Optimisation(wx.Frame):
         optimFileBin = os.path.join(self.workingDir, nameTMP+".rpt.dat")
         
         isOk, optimFileBin = check_path(optimFileBin)
-        if isOk:
+        if isOk>0:
             optimFile = optimFileBin
-
             allParams = read_bin(self.workingDir, nameTMP+".rpt.dat", uniform_format=8)
             matrixData = np.array(allParams[-1]).astype("float")
         else:
             isOk, optimFileTxt = check_path(optimFileTxt)
-            if isOk:
+            if isOk>0:
                 optimFile = optimFileTxt
                 try:
                     with open(optimFile, newline = '') as fileID:
@@ -1210,6 +1211,7 @@ class Optimisation(wx.Frame):
                 self.optiParam.SavetoFile(None)
                 self.optiParam.Reload(None)
                 self.update_myParams(idLauncher)
+                # Prepare the paramPy dictionnary before calibration
                 self.prepare_calibration_timeDelay(stationOut=stationOut)
                 # Reload the useful modules
                 self.reload_hydro(idCompar=0, fromStation=stationOut, lastLevel=previousLevel, updateAll=True)
@@ -1465,7 +1467,7 @@ class Optimisation(wx.Frame):
 
     
     ## Update the dictionnaries of myParams if any changes is identified
-    # TO DO : Generalised for all type of changes and all the necessary tests -> So far just update the junction name
+    # TODO : Generalised for all type of changes and all the necessary tests -> So far just update the junction name
     def update_myParams(self, idLauncher=0):
         curCatch:Catchment
 
@@ -1528,6 +1530,13 @@ class Optimisation(wx.Frame):
         refCatch.plot_landuses(onlySub=False, show=True)
 
 
+    ## Apply the best parameters of an optimisation which implies that :
+    #   - the ".rpt" file of the results of an optimisation should be present
+    #   - the optimal paramters will be replaced in their respective param files
+    #   - the timeDelays will then be updated either with :
+    #           - Python paramters itself 
+    #           - an estimation from the runnof model
+    # Once all the optimal parameters are applied, a new simulation is launched to generate the "best" hydrograph
     def generate_semiDist_optim_simul(self, event, idOpti=1,idLauncher:int=0):
 
         curCatch:Catchment = self.myCases[idLauncher].refCatchment
@@ -1559,13 +1568,22 @@ class Optimisation(wx.Frame):
                 curCatch.define_station_out(stationOut)
                 # Activate all the useful subs and write it in the param file
                 curCatch.activate_usefulSubs(blockJunction=doneList, onlyItself=onlyOwnSub)
+                # Rename the result file
+                self.optiParam.change_param("Optimizer", "fname", stationOut)
+                self.optiParam.SavetoFile(None)
+                self.optiParam.Reload(None)
+                # 
                 self.update_myParams(idLauncher)
+                # Preparing the dictionnaries of Parameters to be updated -> not just useful for calibration here !
+                self.prepare_calibration_timeDelay(stationOut=stationOut)
                 # Fill the param files with their best values
                 self.apply_optim(None)
                 # Simulation with the best parameters
                 self.compute_distributed_hydro_model()
                 # Update myHydro of all effective subbasins to get the best configuration upstream
                 curCatch.read_hydro_eff_subBasin()
+                # Update timeDelays according to time wolf_array
+                self.apply_timeDelay_dist(idOpti=idOpti, idLauncher=idLauncher, junctionKey=stationOut)
                 # Update the outflows
                 curCatch.update_hydro(idCompar=0)
                 # All upstream elements of a reference will be fixed
@@ -1603,6 +1621,10 @@ class Optimisation(wx.Frame):
                 curCatch.define_station_out(stationOut)
                 # Activate all the useful subs and write it in the param file
                 curCatch.activate_usefulSubs(blockJunction=doneList, onlyItself=onlyOwnSub)
+                # Rename the result file
+                self.optiParam.change_param("Optimizer", "fname", stationOut)
+                self.optiParam.SavetoFile(None)
+                self.optiParam.Reload(None)
                 # 
                 self.update_myParams(idLauncher)
                 # TO DO -> adapt all the debug_info files
@@ -1649,7 +1671,7 @@ class Optimisation(wx.Frame):
         elif format==".dat":
             optimFile = os.path.join(self.workingDir, nameTMP+".rpt.dat")
             isOk, optimFile = check_path(optimFile)
-            if isOk:
+            if isOk>0:
                 allData = read_bin(self.workingDir, nameTMP+".rpt.dat", uniform_format=8)
                 allData = np.array(allData).astype("float")
                 matrixParam = allData[:-1,:-1]
@@ -1667,6 +1689,10 @@ class Optimisation(wx.Frame):
 
         myModelDict = cste.modelParamsDict[myModel]["Parameters"]
 
+        if self.curParams_vec is None \
+           or len(self.curParams_vec) != self.nbParams:
+            self.curParams_vec = np.empty((self.nbParams,), dtype=ct.c_double, order='F')
+
         for i in range(self.nbParams):
             myType = self.myParams[i+1]["type"]
             if(int(myType)>0):
@@ -1684,9 +1710,7 @@ class Optimisation(wx.Frame):
                 tmpWolf.OnClose(None)
                 tmpWolf = None
             else:
-                if self.curParams_vec is None:
-                    self.curParams_vec = np.empty((self.nbParams,), dtype=ct.c_double, order='F')
-
+                
                 self.curParams_vec[i] = params[i]
                 self.update_timeDelay(i+1)
                 refCatch.save_timeDelays([self.myParams[i+1]["junction_name"]])

wolfhece/hydrology/Outlet.py

@@ -14,8 +14,8 @@ if not '_' in __builtins__:
     _=gettext.gettext
 
 class Outlet:
-
-    def __init__(self, _retentionBasinDict, _workingDir="", time=[]):
+    
+    def __init__(self, _retentionBasinDict, _workingDir="", time=None):
         print("Run Outlet")
         self.myType = ''
         self.myRbDict = _retentionBasinDict
@@ -45,7 +45,7 @@ class Outlet:
 
         if(fileRef!=""):
             self.myRefInterp = self.read_ref(fileRef, tz=tz)
-            if self.time!=[]:
+            if self.time is not None:
                 # FIXME : if dt(reference) < dt(simulation) => utiliser une moyenne sur tout l'intervalle !!!!!! --> TO DO !!!!
                 self.myRef = np.zeros(np.shape(self.time))
                 # Check the indices useful for simulation and put the other
@@ -117,7 +117,7 @@ class Outlet:
     #     return q
 
     def compute_forcedDam(self, time, index=-1):
-        if self.time==[] or index<0:
+        if self.time is None or index<0:
             if(time<min(self.myRefInterp.x) or time>max(self.myRefInterp.x)):
                 q=0.0
             else: