wolfhece 2.2.38__py3-none-any.whl → 2.2.39__py3-none-any.whl

wolfhece/hydrology/PyWatershed.py

@@ -25,6 +25,7 @@ from ..wolf_array import *
 from ..PyCrosssections import crosssections as CrossSections
 from ..GraphNotebook import PlotNotebook
 from .read import *
+from ..PyParams import Wolf_Param
 
 LISTDEM=['dem_before_corr','dem_after_corr','dem_10m','dem_20m','crosssection']
 #LISTDEM=['dem_after_corr']
@@ -607,17 +608,21 @@ class RiverSystem:
 
         #recherche de l'index max --> à l'exutoire
         self.maxlevels = self.parent.outlet.reachlevel
-        self.maxstrahler=0
-        self.reaches['indexed']={}
-        for i in range(1,self.maxlevels+1):
-            self.reaches['indexed'][i]=[]
 
-        #création de listes pour chaque niveau
-        for curreach in self.reaches['reaches']:
-            curdict=self.reaches['reaches'][curreach]
-            listreach=curdict['baselist']
-            curlevel=listreach[0].reachlevel
-            self.reaches['indexed'][curlevel].append(curreach)
+        if self.maxlevels == 0:
+            logging.warning(_("No reaches found in the watershed. Please check the model configuration and the outlet's position."))
+        else:
+            self.maxstrahler=0
+            self.reaches['indexed']={}
+            for i in range(1,self.maxlevels+1):
+                self.reaches['indexed'][i]=[]
+
+            #création de listes pour chaque niveau
+            for curreach in self.reaches['reaches']:
+                curdict=self.reaches['reaches'][curreach]
+                listreach=curdict['baselist']
+                curlevel=listreach[0].reachlevel
+                self.reaches['indexed'][curlevel].append(curreach)
 
         #création de listes pour chaque amont
         #  on parcourt toutes les mailles depuis chaque amont et on ajoute les index de biefs qui sont différents
@@ -632,57 +637,58 @@ class RiverSystem:
                     curdict['fromuptodown'].append(curnode.reach)
                 curnode=curnode.down
 
-        #création de l'indice de Strahler
-        self.reaches['strahler']={}
-        #on commence par ajouter les biefs de 1er niveau qui sont à coup sûr d'indice 1
-        self.reaches['strahler'][1]=self.reaches['indexed'][1]
-        for curreach in self.reaches['strahler'][1]:
-            self.set_strahler_in_nodes(curreach,1)
-
-        #on parcourt les différents niveaux
-        for i in range(2,self.maxlevels+1):
-            listlevel=self.reaches['indexed'][i]
-            for curreach in listlevel:
-                curup:Node_Watershed
-                curup=self.reaches['reaches'][curreach]['upstream']
-                upidx=list(x.strahler for x in curup.upriver)
-                sameidx=upidx[0]==upidx[-1]
-                maxidx=max(upidx)
-
-                curidx=maxidx
-                if sameidx:
-                    curidx+=1
-                    if not curidx in self.reaches['strahler'].keys():
-                         #création de la liste du niveau supérieur
-                         self.reaches['strahler'][curidx]=[]
-                         self.maxstrahler=curidx
-
-                self.reaches['strahler'][curidx].append(curreach)
-                self.set_strahler_in_nodes(curreach,curidx)
-
-
-        myarray=WolfArray(mold=self.parent.subs_array)
-        myarray.reset()
-        curnode:Node_Watershed
-        for curreach in self.reaches['reaches']:
-            curdict=self.reaches['reaches'][curreach]
-            listreach=curdict['baselist']
-            for curnode in listreach:
-                i=curnode.i
-                j=curnode.j
-                myarray.array[i,j]=curnode.strahler
-        myarray.filename = self.parent.dir+'\\Characteristic_maps\\Drainage_basin.strahler'
-        myarray.write_all()
-        myarray.reset()
-        for curreach in self.reaches['reaches']:
-            curdict=self.reaches['reaches'][curreach]
-            listreach=curdict['baselist']
-            for curnode in listreach:
-                i=curnode.i
-                j=curnode.j
-                myarray.array[i,j]=curnode.reachlevel
-        myarray.filename = self.parent.dir+'\\Characteristic_maps\\Drainage_basin.reachlevel'
-        myarray.write_all()
+        if self.maxlevels > 0:
+            #création de l'indice de Strahler
+            self.reaches['strahler']={}
+            #on commence par ajouter les biefs de 1er niveau qui sont à coup sûr d'indice 1
+            self.reaches['strahler'][1]=self.reaches['indexed'][1]
+            for curreach in self.reaches['strahler'][1]:
+                self.set_strahler_in_nodes(curreach,1)
+
+            #on parcourt les différents niveaux
+            for i in range(2,self.maxlevels+1):
+                listlevel=self.reaches['indexed'][i]
+                for curreach in listlevel:
+                    curup:Node_Watershed
+                    curup=self.reaches['reaches'][curreach]['upstream']
+                    upidx=list(x.strahler for x in curup.upriver)
+                    sameidx=upidx[0]==upidx[-1]
+                    maxidx=max(upidx)
+
+                    curidx=maxidx
+                    if sameidx:
+                        curidx+=1
+                        if not curidx in self.reaches['strahler'].keys():
+                            #création de la liste du niveau supérieur
+                            self.reaches['strahler'][curidx]=[]
+                            self.maxstrahler=curidx
+
+                    self.reaches['strahler'][curidx].append(curreach)
+                    self.set_strahler_in_nodes(curreach,curidx)
+
+
+            myarray=WolfArray(mold=self.parent.subs_array)
+            myarray.reset()
+            curnode:Node_Watershed
+            for curreach in self.reaches['reaches']:
+                curdict=self.reaches['reaches'][curreach]
+                listreach=curdict['baselist']
+                for curnode in listreach:
+                    i=curnode.i
+                    j=curnode.j
+                    myarray.array[i,j]=curnode.strahler
+            myarray.filename = self.parent.directory+'\\Characteristic_maps\\Drainage_basin.strahler'
+            myarray.write_all()
+            myarray.reset()
+            for curreach in self.reaches['reaches']:
+                curdict=self.reaches['reaches'][curreach]
+                listreach=curdict['baselist']
+                for curnode in listreach:
+                    i=curnode.i
+                    j=curnode.j
+                    myarray.array[i,j]=curnode.reachlevel
+            myarray.filename = self.parent.directory+'\\Characteristic_maps\\Drainage_basin.reachlevel'
+            myarray.write_all()
 
     def set_strahler_in_nodes(self, whichreach:int, strahler:int):
         """
@@ -862,7 +868,7 @@ class RiverSystem:
         """
         #Uniquement les pentes rivières
         for curlist in LISTDEM:
-            slopes= WolfArray(self.parent.dir+'\\Characteristic_maps\\Drainage_basin.slope')
+            slopes= WolfArray(self.parent.directory+'\\Characteristic_maps\\Drainage_basin.slope')
             slopes.reset()
             for curreach in self.reaches['reaches']:
                 curdict=self.reaches['reaches'][curreach]
@@ -872,7 +878,7 @@ class RiverSystem:
                 ijval = np.asarray([[curnode.i, curnode.j, curnode.slopecorr[curlist]['value']]  for curnode in listreach])
                 slopes.array[np.int32(ijval[:,0]),np.int32(ijval[:,1])]=ijval[:,2]
 
-            slopes.filename = self.parent.dir+'\\Characteristic_maps\\Drainage_basin.slope_corr_riv_'+curlist
+            slopes.filename = self.parent.directory+'\\Characteristic_maps\\Drainage_basin.slope_corr_riv_'+curlist
             slopes.write_all()
 
     def slope_correctionmin(self):
@@ -1224,7 +1230,7 @@ class RunoffSystem:
     def write_slopes(self):
         #Uniquement les pentes runoff
         for curlist in LISTDEM:
-            slopes= WolfArray(self.parent.dir+'\\Characteristic_maps\\Drainage_basin.slope')
+            slopes= WolfArray(self.parent.directory+'\\Characteristic_maps\\Drainage_basin.slope')
             slopes.reset()
             curnode:Node_Watershed
             for curnode in self.nodes:
@@ -1232,7 +1238,7 @@ class RunoffSystem:
                 j=curnode.j
                 slopes.array[i,j]=curnode.slopecorr[curlist]['value']
 
-            slopes.filename = self.parent.dir+'\\Characteristic_maps\\Drainage_basin.slope_corr_run_'+curlist
+            slopes.filename = self.parent.directory+'\\Characteristic_maps\\Drainage_basin.slope_corr_run_'+curlist
             slopes.write_all()
 
     def slope_correctionmin(self):
@@ -1638,12 +1644,13 @@ class SubWatershed:
 
         # rivers are sorted by dem value, so the first one is the outlet
         return self.get_list_nodes_river(reach)[0]
+
 class Watershed:
     """Classe bassin versant"""
 
     header:header_wolf  # header_wolf of "Drainage_basin.sub" wolf_array
 
-    dir: str            # Répertoire de modélisation
+    directory: str            # Répertoire de modélisation
 
     outlet:Node_Watershed   # exutoire
 
@@ -1669,7 +1676,7 @@ class Watershed:
     to_update_times:bool        # switch to detect if the time matrix should be updated
 
     def __init__(self,
-                 dir:str,
+                 directory:str,
                  thzmin:float=None,
                  thslopemin:float=None,
                  thzmax:float=None,
@@ -1682,19 +1689,37 @@ class Watershed:
                  dir_mnt_subpixels:str=None,
                  *args, **kwargs):
 
+        self.rivers = []
+        self.runoff = []
+        self.nodes = []
+        self.subcatchments = []
+        self.statisticss = {}
+        self.header = None
+        self.couplednodesij = []
+        self.couplednodesxy = []
+        self.couplednodes = []
+
         self.virtualcatchments = []
 
         logging.info(_('Read files...'))
 
-        self.dir=os.path.normpath(dir)
-        self.dir_mnt_subpixels = dir_mnt_subpixels if dir_mnt_subpixels is not None else self.dir
+        self.directory = os.path.normpath(directory)
+        self.dir_mnt_subpixels = dir_mnt_subpixels if dir_mnt_subpixels is not None else self.directory
 
-        self.subs_array   = WolfArray(self.dir+'\\Characteristic_maps\\Drainage_basin.sub')
+        self.subs_array   = WolfArray(self.directory+'\\Characteristic_maps\\Drainage_basin.sub')
 
-        self.header = self.subs_array.get_header()
+        self.header = header_wolf.read_header((self.directory+'\\Characteristic_maps\\Drainage_basin.b'))
 
-        #FIXME
-        isOk, fe_file = check_path(os.path.join(self.dir, "Coupled_pairs.txt"), prefix=self.dir)
+        if self.subs_array.nbx == 0 or self.subs_array.nby == 0:
+            logging.error(_('The Watershed sub file is empty or not valid.'))
+            return
+
+        # Use params to get the directory and filename of forced exchanges
+        _mainparams = Wolf_Param(filename = os.path.join(self.directory, "Main_model.param"), init_GUI= False, toShow= False)
+        dir_fe = _mainparams[('Forced Exchanges', 'Directory')]
+        fn_fe = _mainparams[('Forced Exchanges', 'Filename')]
+
+        isOk, fe_file = check_path(os.path.join(self.directory, dir_fe, fn_fe), prefix=self.directory)
         self.couplednodesxy=[]
         self.couplednodesij=[]
 
@@ -1703,15 +1728,19 @@ class Watershed:
             lines = f.read().splitlines()
             f.close()
 
-            if lines[0]=='COORDINATES':
-                for xy in enumerate(lines[1:]):
-                    xy_split = xy[1].split('\t')
-                    if len(xy_split)==4:
-                        xup,yup,xdown,ydown=xy_split
-                    else:
-                        xup,yup,xdown,ydown=xy_split[:4]
-                    self.couplednodesxy.append([float(xup),float(yup),float(xdown),float(ydown)])
-                    self.couplednodesij.append([self.subs_array.get_ij_from_xy(float(xup),float(yup)),self.subs_array.get_ij_from_xy(float(xdown),float(ydown))])
+            if len(lines) > 1:
+
+                if lines[0]=='COORDINATES':
+                    for xy in enumerate(lines[1:]):
+                        xy_split = xy[1].split('\t')
+                        if len(xy_split)==4:
+                            xup,yup,xdown,ydown=xy_split
+                        else:
+                            xup,yup,xdown,ydown=xy_split[:4]
+                        self.couplednodesxy.append([float(xup),float(yup),float(xdown),float(ydown)])
+                        self.couplednodesij.append([self.subs_array.get_ij_from_xy(float(xup),float(yup)),self.subs_array.get_ij_from_xy(float(xdown),float(ydown))])
+                else:
+                    logging.warning(_('Unknown format in Coupled_pairs.txt'))
 
         logging.info(_('Initialization of nodes...'))
         self.nodesindex = np.zeros([self.subs_array.nbx,self.subs_array.nby], dtype=int)
@@ -1753,6 +1782,13 @@ class Watershed:
 
     @property
     def nb_subs(self):
+        """ Nombre de sous-bassins """
+
+        if self.subs_array is None:
+            return 0
+        if self.subs_array.array is None:
+            return 0
+
         return int(ma.max(self.subs_array.array))
 
     @property
@@ -1891,6 +1927,24 @@ class Watershed:
         vect.find_minmax()
         return vect
 
+    def get_vector_from_xy_to_outlet(self,
+                                      x:float,
+                                      y:float) -> vector:
+
+        down_to_outlet = self.get_node_from_xy(x, y)
+
+        if down_to_outlet is None:
+            logging.error(_('No node found at coordinates ({}, {})').format(x, y))
+            return None
+
+        vec_to_outlet = vector(name='Vector from ({}, {}) to outlet'.format(down_to_outlet.i, down_to_outlet.j))
+
+        while down_to_outlet is not None:
+            vec_to_outlet.add_vertex(wolfvertex(down_to_outlet.x, down_to_outlet.y, down_to_outlet.dem['dem_after_corr']))
+            down_to_outlet = down_to_outlet.down
+
+        return vec_to_outlet
+
     def get_subwatershed(self, idx_sorted_or_name:int | str) -> SubWatershed:
         """
         Récupération d'un sous-bassin sur base de l'index trié
@@ -1920,7 +1974,7 @@ class Watershed:
 
         return None
 
-    def get_node_from_ij(self, i:int,j:int):
+    def get_node_from_ij(self, i:int,j:int) -> Node_Watershed:
         """
         Récupération d'un objet Node_Watershed sur base des indices (i,j)
         """
@@ -1935,7 +1989,7 @@ class Watershed:
 
         return self.nodes[idx]
 
-    def get_node_from_xy(self, x:float, y:float):
+    def get_node_from_xy(self, x:float, y:float) -> Node_Watershed:
         """
         Récupération d'un objet Node_Watershed sur base des coordonnées (x,y)
         """
@@ -1947,9 +2001,9 @@ class Watershed:
         Ecriture sur disque
         """
         for curlist in LISTDEM:
-            curpath=self.dir+'\\Characteristic_maps\\corrslopes\\'+curlist
+            curpath=self.directory+'\\Characteristic_maps\\corrslopes\\'+curlist
             os.makedirs(curpath,exist_ok=True)
-            slopes= WolfArray(self.dir+'\\Characteristic_maps\\Drainage_basin.slope')
+            slopes= WolfArray(self.directory+'\\Characteristic_maps\\Drainage_basin.slope')
 
             ijval = np.asarray([[curnode.i, curnode.j, curnode.slopecorr[curlist]['value']]  for curnode in self.nodes])
             slopes.array[np.int32(ijval[:,0]),np.int32(ijval[:,1])]=ijval[:,2]
@@ -1962,9 +2016,9 @@ class Watershed:
         Ecriture sur disque
         """
         for curlist in LISTDEM:
-            curpath=self.dir+'\\Characteristic_maps\\corrdem\\'+curlist
+            curpath=self.directory+'\\Characteristic_maps\\corrdem\\'+curlist
             os.makedirs(curpath,exist_ok=True)
-            dem= WolfArray(self.dir+'\\Characteristic_maps\\Drainage_basincorr.b')
+            dem= WolfArray(self.directory+'\\Characteristic_maps\\Drainage_basincorr.b')
 
             ijval = np.asarray([[curnode.i, curnode.j, curnode.demcorr[curlist]['value']]  for curnode in self.nodes])
             dem.array[np.int32(ijval[:,0]),np.int32(ijval[:,1])]=ijval[:,2]
@@ -2012,10 +2066,10 @@ class Watershed:
 
         self.nodes=[Node_Watershed() for i in range(self.subs_array.nbnotnull)]
 
-        dem_before_corr= WolfArray(self.dir+'\\Characteristic_maps\\Drainage_basin.b')
-        dem_after_corr= WolfArray(self.dir+'\\Characteristic_maps\\Drainage_basincorr.b')
+        dem_before_corr= WolfArray(self.directory+'\\Characteristic_maps\\Drainage_basin.b')
+        dem_after_corr= WolfArray(self.directory+'\\Characteristic_maps\\Drainage_basincorr.b')
         #Tests of the existance of the delta dem
-        isOk,demdeltaFile = check_path(os.path.join(self.dir,'Characteristic_maps\\Drainage_basindiff.b'))
+        isOk,demdeltaFile = check_path(os.path.join(self.directory,'Characteristic_maps\\Drainage_basindiff.b'))
         if isOk<0:
             logging.error("The ...dif.b file is not present! Please check the reason or launch again the hydrological preprocessing! A Null diff matrix will then be considered for the next steps.")
             demdelta = WolfArray(mold=dem_after_corr)
@@ -2023,76 +2077,102 @@ class Watershed:
         else:
             demdelta = WolfArray(demdeltaFile)
         #
-        slopes= WolfArray(self.dir+'\\Characteristic_maps\\Drainage_basin.slope',masknull=False)
-        reaches= WolfArray(self.dir+'\\Characteristic_maps\\Drainage_basin.reachs')
-        cnv= WolfArray(self.dir+'\\Characteristic_maps\\Drainage_basin.cnv')
-        times= WolfArray(self.dir+'\\Characteristic_maps\\Drainage_basin.time')
+        if (Path(self.directory) / 'Characteristic_maps' /'Drainage_basin.slope').exists():
+            # If the slope file exists, read it
+            slopes = WolfArray(self.directory+'\\Characteristic_maps\\Drainage_basin.slope', masknull=False)
+        else:
+            slopes = None
+            logging.error(_('The slope file is not present! Please check the reason or launch again the hydrological preprocessing! A Null slope matrix will then be considered for the next steps.'))
+
+        if (Path(self.directory) / 'Characteristic_maps' /'Drainage_basin.reachs').exists():
+            # If the reaches file exists, read it
+            reaches = WolfArray(self.directory+'\\Characteristic_maps\\Drainage_basin.reachs')
+        else:
+            reaches = None
+            logging.error(_('The reaches file is not present! Please check the reason or launch again the hydrological preprocessing! A Null reaches matrix will then be considered for the next steps.'))
+
+        if (Path(self.directory) / 'Characteristic_maps' /'Drainage_basin.cnv').exists():
+            # If the cnv file exists, read it
+            cnv = WolfArray(self.directory+'\\Characteristic_maps\\Drainage_basin.cnv')
+        else:
+            cnv = None
+            logging.error(_('The cnv file is not present! Please check the reason or launch again the hydrological preprocessing! A Null cnv matrix will then be considered for the next steps.'))
 
+        if (Path(self.directory) / 'Characteristic_maps' /'Drainage_basin.time').exists():
+            # If the time file exists, read it
+            times = WolfArray(self.directory+'\\Characteristic_maps\\Drainage_basin.time')
+        else:
+            times = None
+            logging.error(_('The time file is not present! Please check the reason or launch again the hydrological preprocessing! A Null time matrix will then be considered for the next steps.'))
 
         dem_after_corr.array.mask = self.subs_array.array.mask
 
-        nb=0
-        for index,i_sub in tqdm(np.ndenumerate(self.subs_array.array), 'Numbering'):
-            if(i_sub>0):
-                i=int(index[0])
-                j=int(index[1])
-                self.nodesindex[i,j]=nb
-                nb+=1
+        # Efficiently fill nodesindex using numpy where and flat indexing
+        indices = np.argwhere(self.subs_array.array > 0)
+        position = np.arange(len(indices))
+        self.nodesindex[indices[:, 0], indices[:, 1]] = position
 
-        curnode:Node_Watershed
-        nb=0
-        for index, i_sub in tqdm(np.ndenumerate(self.subs_array.array), 'Initialization'):
-            if(i_sub>0):
-                i=int(index[0])
-                j=int(index[1])
-                x, y = self.header.get_xy_from_ij(i,j)
-                curnode =self.nodes[self.nodesindex[i,j]]
-
-                curnode.i = i
-                curnode.j = j
-
-                curnode.x = x
-                curnode.y = y
-
-                curnode.crosssections = None
-                curnode.down = None
-
-                curnode.index=nb
-                curnode.dem={}
-                curnode.dem['dem_before_corr']=dem_before_corr.array[i,j]
-                curnode.dem['dem_after_corr']=dem_after_corr.array[i,j]
-                curnode.dem['crosssection']=99999.
-                curnode.demdelta=demdelta.array[i,j]
-                curnode.slope=slopes.array[i,j]
-
-                curnode.slopecorr={}
-                for curlist in LISTDEM:
-                    curnode.slopecorr[curlist]={}
-                    curnode.slopecorr[curlist]['parts']=[]
-                    curnode.slopecorr[curlist]['value']=curnode.slope
-
-                curnode.demcorr={}
-                for curlist in LISTDEM:
-                    curnode.demcorr[curlist]={}
-                    curnode.demcorr[curlist]['parts']=[]
-                    curnode.demcorr[curlist]['value']=curnode.dem['dem_after_corr']
-
-                curnode.sub=int(i_sub)
-                curnode.time=times.array[i,j]
-                curnode.uparea=cnv.array[i,j]
+        def init_node(i, j):
+            """ Initialisation d'un noeud
+            """
+            curnode:Node_Watershed
+            x, y = self.header.get_xy_from_ij(i,j)
+            curnode =self.nodes[self.nodesindex[i,j]]
+
+            curnode.i = i
+            curnode.j = j
+
+            curnode.x = x
+            curnode.y = y
+
+            curnode.crosssections = None
+            curnode.down = None
+
+            curnode.index=self.nodesindex[i,j]
+            curnode.dem={}
+            curnode.dem['dem_before_corr']=dem_before_corr.array[i,j]
+            curnode.dem['dem_after_corr']=dem_after_corr.array[i,j]
+            curnode.dem['crosssection']=99999.
+            curnode.demdelta=demdelta.array[i,j]
+            curnode.slope=slopes.array[i,j] if slopes is not None else 0.0
+
+            curnode.slopecorr={}
+            for curlist in LISTDEM:
+                curnode.slopecorr[curlist]={}
+                curnode.slopecorr[curlist]['parts']=[]
+                curnode.slopecorr[curlist]['value']=curnode.slope
+
+            curnode.demcorr={}
+            for curlist in LISTDEM:
+                curnode.demcorr[curlist]={}
+                curnode.demcorr[curlist]['parts']=[]
+                curnode.demcorr[curlist]['value']=curnode.dem['dem_after_corr']
+
+            curnode.sub=int(self.subs_array.array[i,j])
+            curnode.time=times.array[i,j] if times is not None else 0.0
+            curnode.uparea=cnv.array[i,j] if cnv is not None else 0.0
+
+            if reaches is not None:
                 curnode.river=not reaches.array.mask[i,j]
                 if curnode.river:
                     curnode.reach=int(reaches.array[i,j])
-                curnode.forced=False
-                curnode.up=[]
-                curnode.upriver=[]
-                curnode.strahler=0
-                curnode.reachlevel=0
-                nb+=1
+            else:
+                curnode.river=False
+                curnode.reach=0
+
+            curnode.forced=False
+
+            curnode.up=[]
+            curnode.upriver=[]
+            curnode.strahler=0
+            curnode.reachlevel=0
+            # nb+=1
+
+        all_init = list(map(lambda p: init_node(*p), tqdm(indices, 'Initialization')))
 
         curdown:Node_Watershed
         #Liaison échanges forcés
-        incr=slopes.dx
+        incr=self.header.dx
         for curexch in self.couplednodesij:
             i=int(curexch[0][0])
             j=int(curexch[0][1])
@@ -2135,27 +2215,49 @@ class Watershed:
                         curdown.upriver.append(curnode)
                     curnode.incrs=incr
                 else:
-                    self.outlet = curnode
+                    if self.outlet is None:
+                        self.outlet = curnode
 
-        #Rechreche de la pente dans les voisins en croix dans la topo non remaniée
-        for curnode in tqdm(self.nodes, 'Finding slope'):
+        # Recherche de la pente dans les voisins en croix dans la topo non remaniée
+        import concurrent.futures
+
+        def compute_sloped8(args):
+            curnode, dem_before_corr, resolution = args
             if not curnode.forced:
-                i=curnode.i
-                j=curnode.j
+                i = curnode.i
+                j = curnode.j
 
                 curtop = curnode.dem['dem_before_corr']
 
-                neigh = [[i-1,j], [i+1,j], [i,j-1], [i,j+1], [i-1,j-1], [i+1,j+1], [i+1,j-1], [i-1,j+1]]
-                diff = [dem_before_corr.array[curi,curj]-curtop if not dem_before_corr.array.mask[curi,curj] else 100000. for curi,curj in neigh ]
+                neigh = [
+                    [i-1, j], [i+1, j], [i, j-1], [i, j+1],
+                    [i-1, j-1], [i+1, j+1], [i+1, j-1], [i-1, j+1]
+                ]
+                diff = [
+                    dem_before_corr.array[curi, curj] - curtop
+                    if not dem_before_corr.array.mask[curi, curj] else 100000.
+                    for curi, curj in neigh
+                ]
                 mindiff = np.min(diff)
 
-                fact=1.
-                if mindiff<0:
+                fact = 1.
+                if mindiff < 0:
                     index = diff.index(mindiff)
-                    if index>3:
-                        fact=np.sqrt(2)
+                    if index > 3:
+                        fact = np.sqrt(2)
+                return curnode, -mindiff / (resolution * fact)
+            else:
+                return curnode, 0.0
+
+        # Prepare arguments for multiprocessing
+        args_list = [(curnode, dem_before_corr, self.resolution) for curnode in self.nodes]
+
+        with concurrent.futures.ProcessPoolExecutor() as executor:
+            results = list(tqdm(executor.map(compute_sloped8, args_list), total=len(args_list), desc='Finding slope'))
 
-                curnode.sloped8 = -mindiff/(self.resolution*fact)
+        # Assign results back to nodes
+        for curnode, sloped8 in results:
+            curnode.sloped8 = sloped8
 
         self.rivers=list(filter(lambda x: x.river,self.nodes))
         self.rivers.sort(key=lambda x: x.dem['dem_after_corr'])
@@ -2293,7 +2395,7 @@ class Watershed:
         demsubs = {}
 
         file_10m = os.path.join(self.dir_mnt_subpixels,'mnt10m.bin')
-        isOk, file_10m = check_path(file_10m, prefix=self.dir)
+        isOk, file_10m = check_path(file_10m, prefix=self.directory)
         if isOk>=0:
             dem_10m=WolfArray(file_10m)
             demsubs["dem_10m"] = dem_10m
@@ -2301,7 +2403,7 @@ class Watershed:
             logging.warning(_('No 10m DEM found'))
 
         file_20m = os.path.join(self.dir_mnt_subpixels,'mnt20m.bin')
-        isOk, file_20m = check_path(file_20m, prefix=self.dir)
+        isOk, file_20m = check_path(file_20m, prefix=self.directory)
         if isOk>=0:
             dem_20m=WolfArray(file_20m)
             demsubs["dem_20m"] = dem_20m
@@ -2637,7 +2739,7 @@ class Watershed:
     def update_times(self, wolf_time=None):
 
         if wolf_time is None:
-            wolf_time = WolfArray(self.dir+'\\Characteristic_maps\\Drainage_basin.time')
+            wolf_time = WolfArray(self.directory+'\\Characteristic_maps\\Drainage_basin.time')
 
         for cur_node in self.nodes:
             cur_node.time = wolf_time[cur_node.i, cur_node.j]