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

wolfhece/PyGui.py

@@ -13,6 +13,8 @@ except ImportError as e:
     print(f"Import Error: {e} - GDAL")
     print("Please install GDAL for your Python version.")
 
+import logging
+
 try:
     from os import scandir, getcwd, makedirs
     from os.path import exists, join, isdir, isfile, dirname, normpath, splitext
@@ -32,7 +34,7 @@ except ImportError as e:
     print("Please install the required modules using 'pip install -r requirements.txt'")
 
 try:
-    from .wolf_array import WOLF_ARRAY_FULL_LOGICAL, WOLF_ARRAY_MB_SINGLE, WolfArray, getkeyblock, WOLF_ARRAY_FULL_INTEGER16, WOLF_ARRAY_MB_INTEGER
+    from .wolf_array import WOLF_ARRAY_FULL_LOGICAL, WOLF_ARRAY_MB_SINGLE, WolfArray, getkeyblock, WOLF_ARRAY_FULL_INTEGER16, WOLF_ARRAY_MB_INTEGER, header_wolf
 except ImportError as e:
     print(f"Import Error: {e} - WolfArray")
     print("Please install the required modules using 'pip install -r requirements.txt'")
@@ -80,6 +82,11 @@ except ImportError as e:
     print(f"Import Error: {e} - RatingCurve, mesh2d, Results2DGPU, PyGuiHydrology, RatingCurve, hydrology, PyParams, picc, wolf_zi_db, CpGrid")
     print("Please install the required modules using 'pip install -r requirements.txt'")
 
+try:
+    from .toolshydrology_dll import ToolsHydrologyFortran
+except ImportError as e:
+    print(f"Import Error: {e} - ToolsHydrologyFortran")
+
 
 GEOM_GROUP_NAME = _('Block geometry')
 MAGN_GROUP_NAME = _('Magnetic grid')
@@ -315,6 +322,34 @@ class MapManager(GenMapManager):
 #         self.mapviewer.findminmax(True)
 #         self.mapviewer.Autoscale(False)
 
+DEBUG_HYDROLOGY_DLL = False
+
+HYDROLOGY_ARRAYS = {'Characteristic_maps':[
+                ('.b','Raw elevation [m]'), # extension, name for GUI
+                ('corr.b','Corrected elevation [m]'),
+                ('diff.b','Corrections (corr-raw) [m]'),
+                ('.nap','Mask [-]'),
+                ('.sub','SubBasin index [-]'),
+                ('.cnv','Accumulation [km²]'),
+                ('.time','Total time [s]'),
+                ('.coeff','RunOff coeff [-]'),
+                ('.slope','Slope [-]'),
+                ('.reachs','Reach index [-]'),
+                ('.strahler','Strahler index [-]'),
+                ('.reachlevel','Reach accumulation [-]'),
+                ('.landuse1','Woodlands [m²]'),
+                ('.landuse2','Pastures [m²]'),
+                ('.landuse3','Cultivated [m²]'),
+                ('.landuse4','Pavements [m²]'),
+                ('.landuse5','Water [m²]'),
+                ('.landuse6','River [m²]'),
+                ('.landuse_cropped','LandUse Cropped'),
+                # ('.principal_landuse_cropped','Principal landuse [-]'),
+                ('_encode.sub','Coded index SubB [-]')]}
+
+HYDROLOGY_VECTORS = {'Characteristic_vectors':[('.delimit.vec','Watershed')],  # extension, name for GUI
+                     'Whole_basin':[('Rain_basin_geom.vec','Rain geom'),       # file, name for GUI
+                                    ('Evap_basin_geom.vec','Evapotranspiration geom')]}
 class HydrologyModel(GenMapManager):
 
     mydir:str
@@ -329,20 +364,50 @@ class HydrologyModel(GenMapManager):
     mycatchment:Catchment
     myexchanges:forced_exchanges
 
-    def __init__(self,dir:str='', splash=True, *args, **kw):
+    def __init__(self, directory:str = '', splash:bool = True, *args, **kw):
 
         self.wx_exists = wx.App.Get() is not None # test if wx App is running
 
-        self.SPWstations=SPWMIGaugingStations()
-        self.DCENNstations=SPWDCENNGaugingStations()
+        self.SPWstations  = SPWMIGaugingStations()
+        self.DCENNstations= SPWDCENNGaugingStations()
 
-        if dir=='':
-            idir=wx.DirDialog(None,"Choose Directory")
-            if idir.ShowModal() == wx.ID_CANCEL:
+        if directory=='':
+            if self.wx_exists:
+                idir = wx.DirDialog(None,"Choose Directory")
+                if idir.ShowModal() == wx.ID_CANCEL:
+                    idir.Destroy()
+                    logging.error("Directory selection cancelled. Cannot proceed with HydrologyModel initialization.")
+                    return
+
+                self.mydir =idir.GetPath()
+                idir.Destroy()
+            else:
+                logging.error("No directory selected. Cannot proceed with HydrologyModel initialization.")
                 return
-            self.mydir =idir.GetPath()
         else:
-            self.mydir=normpath(dir)
+            self.mydir = normpath(directory)
+
+        # Test if the directory is void
+        if not exists(self.mydir):
+            if self.wx_exists:
+                dlg = wx.MessageDialog(None,
+                                        _("The directory you selected does not exist. Please select a valid directory."),
+                                        _("Invalid Directory"),
+                                        wx.OK | wx.ICON_ERROR)
+                dlg.ShowModal()
+                dlg.Destroy()
+                return
+            else:
+                raise FileNotFoundError(f"The directory {self.mydir} does not exist.")
+
+        logging.info(_("Loading is on going - Please wait..."))
+
+        self._dlltools = ToolsHydrologyFortran(self.mydir, debugmode=DEBUG_HYDROLOGY_DLL)
+
+        new_sim = self.is_new_sim()
+        if new_sim is None:
+            logging.error("No new simulation defined. Cannot proceed with HydrologyModel initialization.")
+            return
 
         if self.wx_exists:
             super(HydrologyModel, self).__init__(splash=splash, *args, **kw)
@@ -350,104 +415,880 @@ class HydrologyModel(GenMapManager):
             if "splash" in kw and kw["splash"]:
                 raise Exception("You can't have the splash screen outside a GUI")
 
-        self.mydircharact=join(self.mydir,'Characteristic_maps\\Drainage_basin')
-        self.mydirwhole=join(self.mydir,'Whole_basin\\')
+        self.mydircharact= join(self.mydir,'Characteristic_maps\\Drainage_basin')
+        self.mydirwhole  = join(self.mydir,'Whole_basin\\')
+
+        if new_sim:
+            self.mycatchment = None
+        else:
+            self.mycatchment = Catchment('Mysim', self.mydir, False, True)
+
+        #Fichiers de paramètres
+        self.mainparams=Wolf_Param(self.mapviewer,
+                                    filename=self.mydir+'\\Main_model.param',
+                                    title="Model parameters",
+                                    DestroyAtClosing=False)
 
-        self.mycatchment = Catchment('Mysim',self.mydir,False,True)
-        self.myexchanges = forced_exchanges(self.mydir)
+        self.basinparams=Wolf_Param(self.mapviewer,
+                                    filename=self.mydircharact+'.param',
+                                    title="Basin parameters",
+                                    DestroyAtClosing=False)
+
+        self.mainparams.Hide()
+        self.basinparams.Hide()
 
         if self.wx_exists:
             self.mapviewer=GuiHydrology(title='Model : '+self.mydir, wolfparent=self, wxlogging=self.mylogs)
             # self.setup_mapviewer(title='Wolf - Hydrology model', wolfparent=self)
 
+            if self.mainparams[('Forced Exchanges','Directory')] is not None:
+                self.myexchanges = forced_exchanges(Path(self.mydir) / self.mainparams[('Forced Exchanges','Directory')],
+                                                    fname = self.mainparams[('Forced Exchanges','Filename')],
+                                                    mapviewer=self.mapviewer)
+            else:
+                self.myexchanges = forced_exchanges(Path(self.mydir),
+                                                    fname = 'Coupled_pairs.txt',
+                                                    mapviewer=self.mapviewer)
 
-            self.files_hydrology_array={'Characteristic_maps':[
-                ('.b','Raw elevation [m]'),
-                ('corr.b','Corrected elevation [m]'),
-                #('diff.b','Corrections (corr-raw) [m]'),
-                ('.nap','Mask [-]'),
-                ('.sub','SubBasin index [-]'),
-                ('.cnv','Accumulation [km²]'),
-                ('.time','Total time [s]'),
-                ('.coeff','RunOff coeff [-]'),
-                ('.slope','Slope [-]'),
-                ('.reachs','Reach index [-]'),
-                ('.strahler','Strahler index [-]'),
-                ('.reachlevel','Reach accumulation [-]'),
-                ('.landuse1','Woodlands [m²]'),
-                ('.landuse2','Pastures [m²]'),
-                ('.landuse3','Cultivated [m²]'),
-                ('.landuse4','Pavements [m²]'),
-                ('.landuse5','Water [m²]'),
-                ('.landuse6','River [m²]'),
-                ('.landuse_limited_area','LandUse Verif'),
-                ('.principal_landuse_cropped','Principal landuse [-]'),
-                ('_encode.sub','Coded index SubB [-]')]}
 
+            self.files_hydrology_array = HYDROLOGY_ARRAYS
+            self.files_hydrology_vectors = HYDROLOGY_VECTORS
+
+            for curfile in self.files_hydrology_array['Characteristic_maps']:
+                curext=curfile[0]
+                curidx=curfile[1]
+                fn = Path(self.mydircharact + curext)
+                if fn.exists():
+                    a = WolfArray(fn)
+                    self.mapviewer.add_object(which='array',
+                                              newobj=a,
+                                              id= curidx,
+                                              ToCheck= False,
+                                              )
+                    self._impose_palette(a)
+
+            for curfile in self.files_hydrology_vectors['Characteristic_vectors']:
+                curext=curfile[0]
+                curidx=curfile[1]
+                fn = Path(self.mydircharact + curext)
+                if fn.exists():
+                    delimit = Zones(filename=fn, mapviewer=self.mapviewer, parent=self.mapviewer)
+
+                    if self.mycatchment.nbSubBasin == 1:
+                        cur_zone = delimit.myzones[0]
+                        cur_vect = cur_zone.myvectors[0]
+
+                        cur_zone.myname = _('Watershed')
+                        cur_vect.set_legend_to_centroid(str(1), visible=True)
+                        cur_vect.myprop.legendfontsize = 12
+                    else:
+                        if self.mycatchment.nbSubBasin == delimit.nbzones:
+                            for idx, cur_zone in enumerate(delimit.myzones):
+                                cur_sub = self.mycatchment.get_subBasin(idx+1)
+                                cur_zone.myname = cur_sub.name
+                                cur_vect = cur_zone.myvectors[0]
+                                cur_vect.set_legend_to_centroid(cur_sub.name + ' - ' + str(cur_sub.iDSorted), visible=True)
+                                cur_vect.myprop.legendfontsize = 12
+                        else:
+                            logging.warning(_("The number of sub-basins in the delimit file does not match the number of sub-basins in the catchment."))
+                            logging.warning(_("Please check the delimit file and the catchment parameters."))
+
+                    delimit.reset_listogl()
+
+                    self.mapviewer.add_object(which='vector',
+                                              newobj = delimit,
+                                              id=curidx,
+                                              ToCheck=True)
+
+            for curfile in self.files_hydrology_vectors['Whole_basin']:
+                curext=curfile[0]
+                curidx=curfile[1]
+
+                fn = Path(self.mydirwhole + curext)
+                if fn.exists():
+                    self.mapviewer.add_object(which='vector',
+                                              filename=fn,
+                                              id=curidx,
+                                              ToCheck=False)
+
+            # ------------------------------------------------
+            # FORCED EXCHANGES
+            if self.myexchanges is not None:
+                self.mapviewer.add_object(which='vector',
+                                        newobj=self.myexchanges._mysegs,
+                                        id='Forced exchanges',
+                                        ToCheck=False)
+                self.mapviewer.add_object(which='cloud',
+                                        newobj=self.myexchanges._mycloudup,
+                                        id='Up nodes - FE',
+                                        ToCheck=False)
+                self.myexchanges._mycloudup.set_mapviewer(self.mapviewer)
+
+                self.mapviewer.add_object(which='cloud',
+                                        newobj=self.myexchanges._myclouddown,
+                                        id='Down nodes - FE',
+                                        ToCheck=False)
+
+                self.myexchanges._myclouddown.set_mapviewer(self.mapviewer)
+            # END FORCED EXCHANGES
+            # ------------------------------------------------
+
+            if self.mycatchment is not None:
+
+                zones_RT = self.mycatchment.get_retentionbasin_zones()
+                zones_RT.parent = self
+                self.mapviewer.add_object(which='vector',
+                                          newobj=zones_RT,
+                                          id='Anthropic links',
+                                          ToCheck=False)
+
+                self.mapviewer.add_object(which='cloud',
+                                          newobj=self.mycatchment.subBasinCloud,
+                                          id='Local outlets',
+                                          ToCheck=False)
+
+                self.mapviewer.add_object(which='cloud',
+                                          newobj=self.mycatchment.retentionBasinCloud,
+                                          id='Anthropic inlets/outlets',
+                                          ToCheck=False)
+
+                self.mycatchment.subBasinCloud.set_mapviewer(self.mapviewer)
+                self.mycatchment.retentionBasinCloud.set_mapviewer(self.mapviewer)
+
+
+            self.mapviewer.add_object(which='other',
+                                       newobj=self.SPWstations,
+                                       ToCheck=False,
+                                       id='SPW-MI stations')
+
+            self.mapviewer.add_object(which='other',
+                                       newobj=self.DCENNstations,
+                                       ToCheck=False,
+                                       id='SPW-DCENN stations')
+
+            self.mapviewer.add_grid()
+            self.mapviewer.add_WMS()
+
+            self.mapviewer.active_array = None
+            self.mapviewer.active_vector = None
+            self.mapviewer.active_zone = None
+            self.mapviewer.active_zones = None
+            self.mapviewer.active_cloud = None
+
+            self.mapviewer.findminmax(True)
+            self.mapviewer.Autoscale(False)
+
+        logging.info("Loading hydrology model complete.")
+
+    def _impose_palette(self, array:"WolfArray"):
+        """ Impose a palette to the array.
+
+        This is used to ensure that the array has a consistent color palette.
+        """
+
+        if array is not None:
+            if array.idx == "Corrections (corr-raw) [m]".lower():
+                # Corrections array
+                array.mypal.default_difference3()
+            elif array.idx == 'Accumulation [km²]'.lower():
+                array.mypal.defaultblue3()
+                array.mypal.set_values([0., 0.1, 10.])
+            elif array.idx == 'LandUse Cropped'.lower():
+                from .pywalous import get_palette_walous_ocs
+                array.mypal = get_palette_walous_ocs()
+
+    def reload(self):
+        """ Reload the hydrology model parameters and data. """
+
+        new_sim = self.is_new_sim()
+        if new_sim is None:
+            logging.error("No new simulation defined. Cannot reload hydrology model.")
+            return
+
+        self.mycatchment = Catchment('Mysim', self.mydir, False, True)
 
-            self.files_hydrology_vectors={'Characteristic_vectors':[('.delimit.vec','Watershed')],
-                                        'Whole_basin':[('Rain_basin_geom.vec','Rain geom'),
-                                                        ('Evap_basin_geom.vec','Evapotranspiration geom')]}
+        if self.mapviewer is not None:
+            all_arrays = self.mapviewer.get_list_ids(drawing_type= draw_type.ARRAYS, checked_state= None)
+            all_checked_arrays = self.mapviewer.get_list_ids(drawing_type= draw_type.ARRAYS, checked_state= True)
 
             for curfile in self.files_hydrology_array['Characteristic_maps']:
                 curext=curfile[0]
                 curidx=curfile[1]
-                self.mapviewer.add_object(which='array',filename=self.mydircharact+curext,id=curidx,ToCheck=False)
+                fn = Path(self.mydircharact + curext)
 
+                if fn.exists() and curidx.lower() not in all_arrays:
+                    self.mapviewer.add_object(which='array',
+                                              filename=fn,
+                                              id= curidx,
+                                              ToCheck= False,
+                                              )
+                elif fn.exists() and curidx.lower() in all_arrays:
+                    # force to reload the array
+                    obj:WolfArray
+                    obj = self.mapviewer.get_obj_from_id(curidx, drawing_type= draw_type.ARRAYS)
+                    obj._reload()
+
+            all_vectors = self.mapviewer.get_list_ids(drawing_type= draw_type.VECTORS, checked_state= None)
 
             for curfile in self.files_hydrology_vectors['Characteristic_vectors']:
                 curext=curfile[0]
                 curidx=curfile[1]
+                fn = Path(self.mydircharact + curext)
+                if fn.exists():
+                    delimit = Zones(filename=fn, mapviewer=self.mapviewer, parent=self.mapviewer, idx = curidx.lower())
 
-                delimit = Zones(filename=self.mydircharact+curext, mapviewer=self.mapviewer, parent = self.mapviewer)
+                    if self.mycatchment.nbSubBasin == 1:
+                        cur_zone = delimit.myzones[0]
+                        cur_vect = cur_zone.myvectors[0]
 
-                for idx, cur_zone in enumerate(delimit.myzones):
-                    cur_sub = self.mycatchment.get_subBasin(idx+1)
-                    cur_zone.myname = cur_sub.name
-                    cur_vect = cur_zone.myvectors[0]
-                    cur_vect.set_legend_to_centroid(cur_sub.name + ' - ' + str(cur_sub.iDSorted), visible=True)
-                    cur_vect.myprop.legendfontsize = 12
-
-                delimit.reset_listogl()
+                        cur_zone.myname = _('Watershed')
+                        cur_vect.set_legend_to_centroid(str(1), visible=True)
+                        cur_vect.myprop.legendfontsize = 12
+                    else:
+                        for idx, cur_zone in enumerate(delimit.myzones):
+                            cur_sub = self.mycatchment.get_subBasin(idx+1)
+                            cur_zone.myname = cur_sub.name
+                            cur_vect = cur_zone.myvectors[0]
+                            cur_vect.set_legend_to_centroid(cur_sub.name + ' - ' + str(cur_sub.iDSorted), visible=True)
+                            cur_vect.myprop.legendfontsize = 12
 
-                self.mapviewer.add_object(which='vector',newobj = delimit, id=curidx, ToCheck=True)
+                    if curidx.lower() in all_vectors:
+                        self.mapviewer.replace_object(curidx, delimit, drawing_type=draw_type.VECTORS)
 
             for curfile in self.files_hydrology_vectors['Whole_basin']:
                 curext=curfile[0]
                 curidx=curfile[1]
-                if exists(self.mydirwhole+curext):
-                    self.mapviewer.add_object(which='vector',filename=self.mydirwhole+curext,id=curidx,ToCheck=False)
 
-            self.mapviewer.add_object(which='vector',newobj=self.myexchanges.mysegs,id='Forced exchanges',ToCheck=False)
+                fn = Path(self.mydirwhole + curext)
+                if fn.exists():
+                    if curidx.lower() in all_vectors:
+                        newobj = Zones(filename=fn, mapviewer=self.mapviewer, parent=self.mapviewer)
+                        self.mapviewer.replace_object(curidx,
+                                                      newobj=newobj,
+                                                      drawing_type=draw_type.VECTORS)
+
+            if self.mycatchment is not None:
+                all_clouds = self.mapviewer.get_list_ids(drawing_type= draw_type.CLOUD, checked_state= None)
+
+                if 'Local outlets'.lower() in all_clouds:
+                    # Replace the local outlets cloud
+                    self.mapviewer.replace_object('Local outlets',
+                                                  newobj=self.mycatchment.subBasinCloud,
+                                                  drawing_type=draw_type.CLOUD)
+
+                if 'Anthropic inlets/outlets'.lower() in all_clouds:
+                    self.mapviewer.replace_object('Anthropic inlets/outlets',
+                                              newobj=self.mycatchment.retentionBasinCloud,
+                                              drawing_type=draw_type.CLOUD)
+
+                # self.mapviewer.replace_object('Up nodes - FE',
+                #                               newobj=self.myexchanges._mycloudup,
+                #                               drawing_type=draw_type.CLOUD)
+
+                # self.mapviewer.replace_object('Down nodes - FE',
+                #                               newobj=self.myexchanges._myclouddown,
+                #                               drawing_type=draw_type.CLOUD)
+
+                self.mycatchment.subBasinCloud.set_mapviewer(self.mapviewer)
+                self.mycatchment.retentionBasinCloud.set_mapviewer(self.mapviewer)
+                # self.myexchanges._myclouddown.set_mapviewer(self.mapviewer)
+                # self.myexchanges._mycloudup.set_mapviewer(self.mapviewer)
 
-            zones_RT = self.mycatchment.get_retentionbasin_zones()
-            zones_RT.parent = self
-            self.mapviewer.add_object(which='vector',newobj=zones_RT,id='Anthropic links',ToCheck=False)
+            self.mapviewer.Refresh()
 
-            self.mapviewer.add_object(which='cloud',newobj=self.mycatchment.subBasinCloud,id='Local outlets',ToCheck=False)
-            self.mapviewer.add_object(which='cloud',newobj=self.mycatchment.retentionBasinCloud,id='Anthropic inlets/outlets',ToCheck=False)
+        logging.info("Hydrology model reloaded successfully.")
 
-            self.mycatchment.subBasinCloud.set_mapviewer(self.mapviewer)
-            self.mycatchment.retentionBasinCloud.set_mapviewer(self.mapviewer)
+    def is_new_sim(self) -> bool:
+        """
+        Check if the hydrology model is a new simulation.
 
-            self.mapviewer.add_object(which='cloud',newobj=self.myexchanges.mycloudup,id='Up nodes',ToCheck=False)
-            self.mapviewer.add_object(which='cloud',newobj=self.myexchanges.myclouddown,id='Down nodes',ToCheck=False)
+        Returns:
+            bool: True if it is a new simulation, False otherwise.
+        """
 
-            self.mapviewer.add_object(which='other',newobj=self.SPWstations,ToCheck=False,id='SPW-MI stations')
-            self.mapviewer.add_object(which='other',newobj=self.DCENNstations,ToCheck=False,id='SPW-DCENN stations')
+        nbfiles_in_dir = len([f for f in scandir(self.mydir) if f.is_file()])
+        if nbfiles_in_dir == 0:
+            # Propose to create a new simulation
+            if self.wx_exists:
+                dlg = wx.MessageDialog(None,
+                                        _("The directory you selected is empty. Do you want to create a new simulation?"),
+                                        _("Empty Directory"),
+                                        wx.YES_NO | wx.ICON_QUESTION)
+                if dlg.ShowModal() == wx.ID_YES:
+                    self._dlltools.set_directory()
+                    self._dlltools.create_default_parameters()
+                    return True
+                else:
+                    dlg.Destroy()
+                    return None
 
-            self.mapviewer.add_grid()
-            self.mapviewer.add_WMS()
+                dlg.Destroy()
+            else:
+                self._dlltools = ToolsHydrologyFortran(self.mydir, debugmode=DEBUG_HYDROLOGY_DLL)
+                self._dlltools.set_directory()
+                self._dlltools.create_default_parameters()
+                return True
+        else:
+            return False
 
-            self.mapviewer.findminmax(True)
-            self.mapviewer.Autoscale(False)
+    @property
+    def header(self) -> header_wolf:
+        """ Return the header of the hydrology model. """
+
+        if self.mycatchment is None:
+            fn_dtm = self.path_dtm_raw
+            if fn_dtm is not None:
+                header = header_wolf.read_header(str(fn_dtm))
+                return header
+        else:
+            return self.mycatchment.charact_watrshd.header
 
-            #Fichiers de paramètres
-            self.mainparams=Wolf_Param(self.mapviewer,filename=self.mydir+'\\Main_model.param',title="Model parameters",DestroyAtClosing=False)
-            self.basinparams=Wolf_Param(self.mapviewer,filename=self.mydircharact+'.param',title="Basin parameters",DestroyAtClosing=False)
-            self.mainparams.Hide()
-            self.basinparams.Hide()
+        # If no catchment is defined, return None
+        # This is a fallback in case the catchment is not set or the DTM file
+        logging.error("No catchment defined. Cannot retrieve header.")
+        return None
+
+    @property
+    def path_dtm_raw(self) -> Path:
+        """ Return the raw Digital Terrain Model (DTM) as a Path. """
+
+        fn = Path(self.mydircharact + '.b')
+        if fn.exists():
+            return fn
+        else:
+            logging.error(f"DTM file {fn} does not exist.")
+            return None
+
+    @property
+    def path_dtm_corrected(self) -> Path:
+        """ Return the corrected Digital Terrain Model (DTM) as a Path. """
 
+        fn = Path(self.mydircharact + 'corr.b')
+        if fn.exists():
+            return fn
+        else:
+            logging.error(f"Corrected DTM file {fn} does not exist.")
+            return None
+
+    @property
+    def path_mask(self) -> Path:
+        """ Return the mask of the Digital Terrain Model (DTM) as a Path. """
+
+        fn = Path(self.mydircharact + '.nap')
+        if fn.exists():
+            return fn
+        else:
+            logging.error(f"Mask DTM file {fn} does not exist.")
+            return None
+
+    @property
+    def path_subbasin(self) -> Path:
+        """ Return the subbasin index as a Path. """
+
+        fn = Path(self.mydircharact + '.sub')
+        if fn.exists():
+            return fn
+        else:
+            logging.error(f"Subbasin DTM file {fn} does not exist.")
+            return None
+
+    @property
+    def path_accumulation(self) -> Path:
+        """ Return the accumulation as a Path. """
+
+        fn = Path(self.mydircharact + '.cnv')
+        if fn.exists():
+            return fn
+        else:
+            logging.error(f"Accumulation DTM file {fn} does not exist.")
+            return None
+
+    @property
+    def path_total_time(self) -> Path:
+        """ Return the total time as a Path. """
+
+        fn = Path(self.mydircharact + '.time')
+        if fn.exists():
+            return fn
+        else:
+            logging.error(f"Total time DTM file {fn} does not exist.")
+            return None
+
+    @property
+    def path_runoff_coeff(self) -> Path:
+        """ Return the runoff coefficient as a Path. """
+
+        fn = Path(self.mydircharact + '.coeff')
+        if fn.exists():
+            return fn
+        else:
+            logging.error(f"Runoff coefficient DTM file {fn} does not exist.")
+            return None
+
+    @property
+    def path_slope(self) -> Path:
+        """ Return the slope of the Digital Terrain Model (DTM) as a Path. """
+
+        fn = Path(self.mydircharact + '.slope')
+        if fn.exists():
+            return fn
+        else:
+            logging.error(f"Slope DTM file {fn} does not exist.")
+            return None
+
+    @property
+    def path_reachs(self) -> Path:
+        """ Return the reach file as a Path. """
+
+        fn = Path(self.mydircharact + '.reach')
+        if fn.exists():
+            return fn
+        else:
+            logging.error(f"Reach DTM file {fn} does not exist.")
+            return None
+
+    def set_outlet(self, x:float, y:float):
+        """
+        Set the outlet coordinates for the hydrology model.
+        """
+        if self.mainparams is not None:
+            self.mainparams[('Outlet Coordinates', 'X')] = x
+            self.mainparams[('Outlet Coordinates', 'Y')] = y
+            self.mainparams.Save()
+            logging.info(f"Outlet set to coordinates: ({x}, {y})")
+        else:
+            logging.error("Main parameters not loaded. Cannot set outlet coordinates.")
+
+    def set_active_array_as_dtm(self, active_array:WolfArray):
+        """
+        Set the active array as the Digital Terrain Model (DTM) for the hydrology model.
+
+        Implications :
+        - Update the mesh size in the main parameters.
+        - Saving the active array as the '.b' file in the characteristic maps directory.
+        """
+
+        assert active_array.dx == active_array.dy, "The active array must have equal dx and dy for DTM."
+
+        if self.mainparams is not None:
+            self.mainparams[('Topographical mesh', 'Space step')] = active_array.dx
+            self.mainparams[('Preprocessing', 'Cropping topo')] = 0
+
+            fn = Path(self.mydircharact + '.b')
+            self.mainparams[('Topography', 'Directory')] = fn.parent
+            self.mainparams[('Topography', 'Filename')]  = fn.name
+
+            active_array.write_all(fn)
+            self.mainparams.Save()
+
+            # self.myexchanges.save()
+
+            # self.mainparams[('Forced Exchanges', 'Directory')] = self.mydir
+            # self.mainparams[('Forced Exchanges', 'Filename')] = 'Coupled_pairs.txt'
+
+            # with open(Path(self.mydir) / 'Coupled_pairs.txt', 'w') as f:
+            #     f.write(f"{active_array.dx} {active_array.dy}\n")
+
+            logging.info(f"Active array set as DTM: {active_array.filename}")
+        else:
+            logging.error("Main parameters not loaded. Cannot set active array as DTM.")
+
+    def set_only_preprocess_data(self):
+        """ Set the hydrology model to only preprocess data. """
+        from datetime import timedelta, datetime as dt
+
+
+        if self.mainparams is not None:
+            self.mainparams[('Preprocessing', 'Cropping topo')] = 0
+            self.mainparams[('Preprocessing', 'Quit immediatly after')] = 1
+            self.mainparams[('Preprocessing', 'Delimiting subbasin')] = 1
+            self.mainparams[('Preprocessing', 'Whole basin (atmospheric geometry & data)')] = 1
+            self.mainparams[('Preprocessing', 'Subbasin (atmospheric geometry & data)')] = 1
+            self.mainparams[('Preprocessing', 'Lumped input')] = 1
+
+            self.mainparams[('Atmospheric data', 'Type of source')] = -1 # To ignore atmospheric data
+            self.mainparams[('Atmospheric data', 'Time step')] = 1
+
+            self.mainparams[('Temporal Parameters', 'Start date time')] = dt.now().strftime('%Y%m%d-%H%M%S')
+            self.mainparams[('Temporal Parameters', 'End date time')] = (dt.now()+timedelta(seconds=1)).strftime('%Y%m%d-%H%M%S')
+            self.mainparams[('Temporal Parameters', 'Time step')] = 1
+
+            self.mainparams[('Simulation intervals', 'Nb')] = 0 # Preprocess data only
+
+            self.mainparams[('Measuring stations SPW', 'To read')] = 0
+
+            self.mainparams.Save()
+
+            logging.info("Hydrology model set to preprocess data only.")
+        else:
+            logging.error("Main parameters not loaded. Cannot set model type to preprocess data.")
+
+        if self.basinparams is not None:
+            self.basinparams[('Preprocessing DEM', 'Import flt')] = 0
+            if DEBUG_HYDROLOGY_DLL:
+                self.basinparams[('Verbosity', 'Code Verbosity')] = 1
+            else:
+                self.basinparams[('Verbosity', 'Code Verbosity')] = 0
+
+            if self.is_topo_already_corrected():
+                dlg = wx.MessageDialog(None,
+                                        _("The topography is already corrected. Do you want to set the model to not process it?"),
+                                        _("Topography Already Corrected"),
+                                        wx.YES_NO | wx.ICON_QUESTION)
+                if dlg.ShowModal() == wx.ID_YES:
+                    self.basinparams[('Preprocessing DEM', 'Todo DEM correction')] = 0
+                else:
+                    self.basinparams[('Preprocessing DEM', 'Todo DEM correction')] = 1
+                dlg.Destroy()
+            else:
+                self.basinparams[('Preprocessing DEM', 'Todo DEM correction')] = 1 # Fill-in and relief phase
+
+            self.basinparams[('Preprocessing DEM', 'nb Neighbors')] = 4
+            self.basinparams[('Preprocessing DEM', 'indeterminate value')] = self.header.nullvalue
+
+            if self.path_accumulation.exists():
+                dlg = wx.MessageDialog(None,
+                                        _("The accumulation/convergence file already exists. Do you want to set the model to not compute it?"),
+                                        _("Accumulation File Exists"),
+                                        wx.YES_NO | wx.ICON_QUESTION)
+                if dlg.ShowModal() == wx.ID_YES:
+                    self.basinparams[('Preprocessing Flux', 'Todo compute flux')] = 0
+                else:
+                    self.basinparams[('Preprocessing Flux', 'Todo compute flux')] = 1
+                dlg.Destroy()
+            else:
+                self.basinparams[('Preprocessing Flux', 'Todo compute flux')] = 1 # Convergence/Accumulation phase
+
+            self.basinparams.Save()
+
+            logging.info("Basin parameters set to not import DEM as flt.")
+        else:
+            logging.error("Basin parameters not loaded. Cannot set model type to preprocess data.")
+
+    def is_topo_already_corrected(self) -> bool:
+        """ Check if the topography has already been corrected.
+
+        :return: True if the topography is already corrected, False otherwise.
+        :rtype: bool
+        """
+
+        if self.path_dtm_corrected.exists():
+            logging.info("Topography is already corrected.")
+            return True
+        else:
+            logging.info("Topography is not corrected yet.")
+            return False
+
+    def set_model_type(self, which_model:int | str):
+        """ Set the hydrology model to a lumped model.
+
+        :param which_model: Model type to set. 1 for lumped model, 2 for semi-distributed model, 3 for meshed.
+        """
+
+        if isinstance(which_model, str):
+            if which_model.lower() == 'lumped':
+                which_model = 1
+            elif which_model.lower() == 'semi-distributed':
+                which_model = 2
+            elif which_model.lower() == 'meshed':
+                which_model = 3
+            else:
+                logging.error(f"Invalid model type string: {which_model}. Must be 'lumped', 'semi-distributed', or 'meshed'.")
+                return
+
+        if which_model not in [1, 2, 3]:
+            logging.error(f"Invalid model type: {which_model}. Must be 1, 2, or 3.")
+            return
+
+        if self.mainparams is not None:
+            self.mainparams[('Model Type', 'Spatial distribution')] = which_model
+            # self.mainparams[('Preprocessing', 'Delimiting subbasin')] = 1 if which_model == 1 else 1
+            # self.mainparams[('Preprocessing', 'Whole basin (atmospheric geometry & data)')] = 0
+            # self.mainparams[('Preprocessing', 'Subbasin (atmospheric geometry & data)')] = 0
+
+            self.mainparams.Save()
+
+            logging.info("Hydrology model set to lumped model.")
+        else:
+            logging.error("Main parameters not loaded. Cannot set model type to lumped.")
+
+    def _check_files(self):
+        """ Check if the necessary files for the hydrology model exist.
+        """
+
+        tmp_dir = self.mainparams[('Measuring stations SPW', 'Directory')]
+        tmp_fn  = self.mainparams[('Measuring stations SPW', 'Filename')]
+
+        # Stations file must exist
+        if not (Path(tmp_dir) / tmp_fn).exists():
+            logging.error(f"SPW measuring stations file not found: {tmp_dir}/{tmp_fn}.")
+
+            dlg = wx.FileDialog(None,
+                                message=_("Select the SPW measuring stations file"),
+                                defaultDir=tmp_dir,
+                                defaultFile=tmp_fn,
+                                wildcard="*.txt",
+                                style=wx.FD_OPEN | wx.FD_FILE_MUST_EXIST)
+
+            if dlg.ShowModal() == wx.ID_OK:
+                selected_file = Path(dlg.GetPath())
+                if exists(selected_file):
+                    self.mainparams[('Measuring stations SPW', 'Directory')] = str(selected_file.parent)
+                    self.mainparams[('Measuring stations SPW', 'Filename')] = str(selected_file.name)
+                    self.mainparams.Save()
+                    logging.info(f"SPW measuring stations file set to: {selected_file}")
+                else:
+                    logging.error(f"Selected file does not exist: {selected_file}")
+            dlg.Destroy()
+
+        # Landuse Directory must exist
+        tmp_dir = Path(self.mainparams[('LandUse', 'Directory')])
+        if not tmp_dir.exists() or not tmp_dir.is_dir():
+            logging.error(f"Landuse directory not found: {tmp_dir}.")
+
+            dlg = wx.DirDialog(None,
+                                message=_("Select the Landuse directory"),
+                                defaultPath=str(tmp_dir),
+                                style=wx.DD_DEFAULT_STYLE)
+
+            if dlg.ShowModal() == wx.ID_OK:
+                selected_dir = dlg.GetPath()
+                if exists(selected_dir):
+                    self.mainparams[('LandUse', 'Directory')] = str(selected_dir)
+                    self.mainparams.Save()
+                    logging.info(f"LandUse directory set to: {selected_dir}")
+                else:
+                    logging.error(f"Selected directory does not exist: {selected_dir}")
+            dlg.Destroy()
+
+        # Municipality QDF file must exist
+        tmp_dir = Path(self.mainparams[('Municipality QDF', 'Directory')])
+        if not tmp_dir.exists() or not tmp_dir.is_dir():
+            logging.error(f"Municipality directory not found: {tmp_dir}.")
+
+            # dlg = wx.DirDialog(None,
+            #                     message=_("Select the Municipality directory"),
+            #                     defaultPath=tmp_dir,
+            #                     style=wx.DD_DEFAULT_STYLE)
+
+            # if dlg.ShowModal() == wx.ID_OK:
+            #     selected_dir = dlg.GetPath()
+            #     if exists(selected_dir):
+            #         self.mainparams[('Municipality', 'Directory')] = selected_dir
+            #         self.mainparams.Save()
+            #         logging.info(f"Municipality directory set to: {selected_dir}")
+            #     else:
+            #         logging.error(f"Selected directory does not exist: {selected_dir}")
+            # dlg.Destroy()
+
+        return True
+
+    def _check_threshold(self):
+        """
+        Check if the threshold for the hydrology model is set correctly.
+        """
+
+        if self.basinparams is not None:
+            threshold = self.basinparams[('Preprocessing Flux', 'threshold convergence')]
+            dtm = self.header
+
+            surface = dtm.nbx * dtm.nby * dtm.dx * dtm.dy
+            surface /= 1000. * 1000.  # Convert to km²
+
+            if threshold > surface / 10.:
+                logging.warning(f"Threshold value {threshold} is too high compared to the dtm surface {surface}.")
+                threshold = float(((surface / 10.) //5.) *5.) # rounded to 5 km²
+                self.basinparams[('Preprocessing Flux', 'threshold convergence')] = threshold
+            elif threshold <= 0.:
+                logging.error(f"Threshold value {threshold} is invalid. It must be greater than 0.")
+                logging.info("Setting threshold to 10% of the DTM surface.")
+
+                threshold = float(((surface / 10.) //5.) *5.)
+                self.basinparams[('Preprocessing Flux', 'threshold convergence')] = threshold
+            else:
+                logging.info(f"Threshold value is set to: {threshold}")
+
+            return True
+        else:
+            logging.error("Main parameters not loaded. Cannot check threshold.")
+            return False
+
+    def run_preprocessing(self, verbose:bool = DEBUG_HYDROLOGY_DLL):
+        """ Run the preprocessing of the hydrology model.
+
+        This will create the characteristic maps and the whole basin data.
+        """
+
+        self._check_files()
+        self._check_threshold()
+
+        if self.myexchanges.is_empty():
+            self.mainparams[('Forced Exchanges', 'Directory')] = '.'
+            self.mainparams[('Forced Exchanges', 'Filename')] = 'N-O'
+        else:
+            self.mainparams[('Forced Exchanges', 'Directory')] = Path(str(self.myexchanges._filename)).parent.relative_to(self.mydir)
+            self.mainparams[('Forced Exchanges', 'Filename')] = self.myexchanges._filename.name
+            self.myexchanges.save()
+
+        if self.nb_interior_points() in [0,1]:
+            self.set_model_type('lumped')  # Lumped model
+        elif self.nb_interior_points() > 1:
+            self.set_model_type('meshed')  # Meshed model
+
+        self.mainparams.compare_active_to_default()
+        self.mainparams.Save()
+
+        self.basinparams.compare_active_to_default()
+        self.basinparams.Save()
+
+        # Create a progress bar with pulse
+        if self.wx_exists:
+            progress_dialog = wx.ProgressDialog(_("Preprocessing Hydrology Model"),
+                                                _("Running preprocessing..."),
+                                                maximum=100,
+                                                parent=self,
+                                                style=wx.PD_APP_MODAL | wx.PD_ELAPSED_TIME)
+
+            progress_dialog.Pulse(_("Compute preprocessing..."))
+
+        logging.info("Starting preprocessing of the hydrology model...")
+        self._dlltools.run_preprocessing()
+        logging.info("Finished preprocessing of the hydrology model.")
+
+        if self.wx_exists:
+            # Update the progress dialog
+            progress_dialog.Destroy()
+
+        self.reload()
+
+    def set_runoff_type(self, which_runoff:int | str, timestep:float = 300.):
+        """ Set the runoff type for the hydrology model.
+
+        :param which_runoff: Runoff type to set. ADALI = 3 ; Ven te Chow = 2 ; Froude based = 1
+        """
+
+        if isinstance(which_runoff, str):
+            if which_runoff.lower() == 'adali':
+                which_runoff = 3
+            elif which_runoff.lower() == 'ven te chow':
+                which_runoff = 2
+            elif which_runoff.lower() == 'froude based':
+                which_runoff = 1
+            else:
+                logging.error(f"Invalid runoff type string: {which_runoff}. Must be 'ADALI', 'Ven te Chow', or 'Froude based'.")
+                return
+
+        if which_runoff not in [1, 2, 3]:
+            logging.error(f"Invalid runoff type: {which_runoff}. Must be 1, 2, or 3.")
+            return
+
+        if self.mainparams is not None:
+            self.mainparams[('Runoff', 'How to compute local runoff speed?')] = which_runoff
+            self.mainparams[('Runoff', 'Time step')] = timestep
+            logging.info(f"Runoff type set to {which_runoff}.")
+        else:
+            logging.error("Main parameters not loaded. Cannot set runoff type.")
+
+    def nb_interior_points(self) -> int:
+        """ Get the number of interior points in the hydrology model.
+
+        Returns:
+            int: Number of interior points.
+        """
+        if self.mainparams is not None:
+            nb = self.mainparams[('Semi distributed model', ('How many?'))]
+            logging.info(f"Number of interior points: {nb}")
+            return nb
+        else:
+            logging.error("No catchment defined. Cannot get number of interior points.")
+            return 0
+
+    def get_interior_points(self) -> dict:
+        """ Get the interior points of the hydrology model.
+
+        Returns:
+            list: List of interior points.
+        """
+        if self.mainparams is not None:
+            nb = self.mainparams[('Semi distributed model', ('How many?'))]
+
+            all_ip = {}
+            for i in range(1, nb + 1):
+                ip = self.mainparams[f'Interior point {i}']
+                if ip is None:
+                    logging.warning(f"Interior point {i} is not defined.")
+                    continue
+
+                x = ip['X']
+                y = ip['Y']
+                type_ip = ip['Which type']
+                active = ip['Active']
+                all_ip[i] = {'X': x, 'Y': y,
+                             'Type': type_ip,
+                             'Active': active
+                             }
+            logging.info(f"Found {len(all_ip)} interior points.")
+            return all_ip
+        else:
+            logging.error("No catchment defined. Cannot get interior points.")
+            return {}
+
+    def set_interior_points(self, points:dict):
+        """ Set the interior points of the hydrology model.
+
+        :param points: Dictionary of interior points to set.
+        """
+        if self.mainparams is not None:
+            nb = len(points)
+            self.mainparams[('Semi distributed model', ('How many?'))] = nb
+
+            for i, (key, value) in enumerate(points.items(), start=1):
+                self.mainparams[f'Interior point {i}'] = {
+                    'X': value['X'],
+                    'Y': value['Y'],
+                    'Which type': value['Type'],
+                    'Active': value['Active']
+                }
+            self.mainparams.Save()
+            logging.info(f"Set {nb} interior points.")
+        else:
+            logging.error("No catchment defined. Cannot set interior points.")
+
+    def edit_interior_point(self):
+        """ Edit IP in CpGrid. """
+        from .PandasGrid import DictGrid
+
+        dlg = DictGrid(parent = None,
+                       id=_("Edit Interior Points"),
+                       data = self.get_interior_points())
+
+        dlg.ShowModal()
+
+        self.set_interior_points(dlg.get_dict())
+        dlg.Destroy()
+
+    def add_interior_point(self, x:float, y:float, type_ip:int = 0, active:bool = True):
+        """ Add an interior point to the hydrology model.
+
+        :param x: X coordinate of the interior point.
+        :param y: Y coordinate of the interior point.
+        :param type_ip: Type of the interior point (default is 1).
+        :param active: Whether the interior point is active (default is True).
+        """
+
+        if self.mainparams is not None:
+            nb = self.mainparams[('Semi distributed model', ('How many?'))] + 1
+            self.mainparams[('Semi distributed model', ('How many?'))] = nb
+
+            self.mainparams[(f'Interior point {nb}', 'X')] = x
+            self.mainparams[(f'Interior point {nb}', 'Y')] = y
+            self.mainparams[(f'Interior point {nb}', 'Which type')] = type_ip
+            self.mainparams[(f'Interior point {nb}', 'Active')] = 1 if active else 0
+
+            self.mainparams.Save()
+            logging.info(f"Added interior point {nb} at ({x}, {y}) with type {type_ip} and active status {active}.")
+        else:
+            logging.error("No catchment defined. Cannot add interior point.")
 
 class Wolf2DPartArrays():