wolfhece 2.2.18__py3-none-any.whl → 2.2.23__py3-none-any.whl

wolfhece/PyDraw.py

@@ -2287,6 +2287,7 @@ class WolfMapViewer(wx.Frame):
         self.analyzeplot = wx.Menu()
         self.analyzeexport = wx.Menu()
         self.analyzeinpaint = wx.Menu()
+        self.analyzesimsheet = wx.Menu()
 
         plotvect = self.analyzeplot.Append(wx.ID_ANY, _("Plot active vector..."),
                                            _("Plot the active vector and linked arrays"))
@@ -2299,6 +2300,17 @@ class WolfMapViewer(wx.Frame):
         self.analyzemenu.Append(wx.ID_ANY,_('Export...'), self.analyzeexport)
         self.analyzemenu.Append(wx.ID_ANY,_('Inpaint...'), self.analyzeinpaint)
 
+        self.analyzemenu.AppendSeparator()
+
+        self.analyzemenu.Append(wx.ID_ANY,_('Report...'), self.analyzesimsheet)
+
+        self.analyzesimsheet.Append(wx.ID_ANY, _("Active simulation..."), _("Generate a summary PDF report for the active simulation"))
+        self.analyzesimsheet.Append(wx.ID_ANY, _("All checked simulations..."), _("Generate a summary PDF report for all checked simulations"))
+        self.analyzesimsheet.Append(wx.ID_ANY, _("All simulations in directory..."), _("Generate a summary PDF report for all simulations in the current directory"))
+        self.analyzesimsheet.AppendSeparator()
+        self.analyzesimsheet.Append(wx.ID_ANY, _("Compare checked simulations..."), _("Generate a summary PDF report for all the loaded simulations"))
+        self.analyzesimsheet.Append(wx.ID_ANY, _("Compare all simulations in a directory..."), _("Generate a summary PDF report for all the simulations in a directory"))
+
 
         self.analyzeinpaint.Append(wx.ID_ANY, _("Inpaint active array..."), _("Inpaint active array"))
         self.analyzeinpaint.Append(wx.ID_ANY, _("Inpaint waterlevel..."), _("Inpaint a waterlevel result array based on sepcified dem and dtm data"))
@@ -8301,6 +8313,121 @@ class WolfMapViewer(wx.Frame):
         elif itemlabel == _("Load and apply mask (nap)..."):
             self.loadnap_and_apply()
 
+        elif itemlabel == _("Active simulation..."):
+            if self.active_res2d is None:
+                logging.warning(_('No active simulation !'))
+                return
+
+            from .report.simplesimgpu import SimpleSimGPU_Report_wx
+
+            if isinstance(self.active_res2d, wolfres2DGPU):
+                newsheet = SimpleSimGPU_Report_wx(Path(self.active_res2d.filename).parent, size=(800, 600))
+                newsheet.Show()
+            else:
+                logging.warning(_('Active simulation is not a GPU simulation - Not yet implemented for CPU simulations !'))
+
+        elif itemlabel == _("All checked simulations..."):
+
+            sims = self.get_list_keys(draw_type.RES2D, checked_state=True)
+            if len(sims) == 0:
+                logging.warning(_('No checked simulation !'))
+                return
+
+            from .report.simplesimgpu import SimpleSimGPU_Report_wx
+
+            for curkey in sims:
+                curmodel = self.get_obj_from_id(curkey, draw_type.RES2D)
+                if isinstance(curmodel, wolfres2DGPU):
+                    newsheet = SimpleSimGPU_Report_wx(Path(curmodel.filename).parent, size=(800, 600))
+                    newsheet.Show()
+                else:
+                    logging.warning(_('Simulation {} is not a GPU simulation - Not yet implemented for CPU simulations !').format(curmodel.idx))
+
+        elif itemlabel == _("All simulations in directory..."):
+            dlg = wx.DirDialog(None, _('Choose the directory containing the simulations'), style=wx.DD_DEFAULT_STYLE)
+            ret = dlg.ShowModal()
+            if ret == wx.ID_CANCEL:
+                dlg.Destroy()
+                return
+            directory = Path(dlg.GetPath())
+            dlg.Destroy()
+            if not directory.exists():
+                logging.error(_('Directory {} does not exist !').format(directory))
+                wx.MessageBox(_('Directory {} does not exist !').format(directory), _('Error'), wx.OK | wx.ICON_ERROR)
+                return
+            if not directory.is_dir():
+                logging.error(_('Path {} is not a directory !').format(directory))
+                wx.MessageBox(_('Path {} is not a directory !').format(directory), _('Error'), wx.OK | wx.ICON_ERROR)
+                return
+            from .report.simplesimgpu import SimpleSimGPU_Reports_wx
+
+
+            # check if we want to show all wx reports
+            dlg = wx.MessageDialog(None, _('Do you want to show all reports ?'), _('Show all reports'), style=wx.YES_NO | wx.YES_DEFAULT)
+            ret = dlg.ShowModal()
+            dlg.Destroy()
+
+            newsheets = SimpleSimGPU_Reports_wx(directory, show = ret == wx.ID_YES, size=(800, 600))
+
+        elif itemlabel == _("Compare checked simulations..."):
+
+            sims = self.get_list_keys(draw_type.RES2D, checked_state=True)
+            if len(sims) == 0:
+                logging.warning(_('No checked simulation !'))
+                return
+
+            elif len(sims) == 1:
+                logging.warning(_('Only one checked simulation - Nothing to compare !'))
+                return
+
+            from .report.simplesimgpu import SimpleSimGPU_Report_Compare_wx
+
+            sims = [self.get_obj_from_id(curkey, draw_type.RES2D) for curkey in sims]
+            # conserve only GPU simulations
+            sims = [Path(curmodel.filename) for curmodel in sims if isinstance(curmodel, wolfres2DGPU)]
+
+            # take parent if "simul_gpu_results" in sims
+            sims = [sim.parent for sim in sims if 'simul_gpu_results' in str(sim)]
+
+            if len(sims) == 0:
+                logging.warning(_('No GPU simulation to compare !'))
+                return
+            elif len(sims) == 1:
+                logging.warning(_('Only one GPU simulation - Nothing to compare !'))
+                return
+            elif len(sims) > 1:
+                try:
+                    newsheet = SimpleSimGPU_Report_Compare_wx(sims, size=(800, 600))
+                    newsheet.Show()
+                except Exception as e:
+                    logging.error(_('Error in comparing simulations\n{}'.format(e)))
+
+        elif itemlabel == _("Compare all simulations in a directory..."):
+
+            dlg = wx.DirDialog(None, _('Choose the directory containing the simulations'), style=wx.DD_DEFAULT_STYLE)
+            ret = dlg.ShowModal()
+            if ret == wx.ID_CANCEL:
+                dlg.Destroy()
+                return
+
+            directory = Path(dlg.GetPath())
+            dlg.Destroy()
+
+            if not directory.exists():
+                logging.error(_('Directory {} does not exist !').format(directory))
+                wx.MessageBox(_('Directory {} does not exist !').format(directory), _('Error'), wx.OK | wx.ICON_ERROR)
+                return
+            if not directory.is_dir():
+                logging.error(_('Path {} is not a directory !').format(directory))
+                wx.MessageBox(_('Path {} is not a directory !').format(directory), _('Error'), wx.OK | wx.ICON_ERROR)
+                return
+            from .report.simplesimgpu import SimpleSimGPU_Report_Compare_wx
+            try:
+                newsheet = SimpleSimGPU_Report_Compare_wx(directory, size= (800,600))
+                newsheet.Show()
+            except Exception as e:
+                logging.error(_('Error in comparing simulations in directory\n{}'.format(e)))
+
         elif itemlabel == _("Inpaint active array..."):
 
             if self.active_array is None:
@@ -13209,7 +13336,7 @@ class WolfMapViewer(wx.Frame):
         width, height = self.canvas.GetSize()
 
         if iwidth == 0 or iheight == 0:
-            logging.error(_('Width or height of the canvas is null -- Please check the "findminmax" routine in "Autoscale" !'))
+            logging.warning(_('Width or height of the canvas is null -- Please check the "findminmax" routine in "Autoscale" !'))
             iwidth = 1
             iheight = 1
 

wolfhece/PyVertexvectors.py

@@ -1124,9 +1124,9 @@ if :\n \
             self.myprops[('Move','Delta Y')] = 0.
 
             self.parent.update_lengths()
-            self.myprops[( 'Geometry','Length 2D')] = self.parent.length2D
-            self.myprops[( 'Geometry','Length 3D')] = self.parent.length3D
-            self.myprops[( 'Geometry','Surface')] = self.parent.area
+            self.myprops[( 'Geometry','Length 2D')] = self.parent.length2D if self.parent.length2D is not None else 0.
+            self.myprops[( 'Geometry','Length 3D')] = self.parent.length3D if self.parent.length3D is not None else 0.
+            self.myprops[( 'Geometry','Surface')] = self.parent.area if self.parent.area is not None else 0.
 
             self.myprops.Populate()
 class vector:
@@ -6811,6 +6811,10 @@ class Zones(wx.Frame, Element_To_Draw):
             self.sascending.SetToolTip(_("Check whether the vertices of the activated vector are ordered according to increasing 's' defined as 2D geometric distance \n If needed, invert some positions and return information to the user"))
             self.sascending.Bind(wx.EVT_BUTTON,self.Onsascending)
 
+            self._btn_buffer = wx.Button(self,label=_('Buffer'))
+            self._btn_buffer.SetToolTip(_("Create a buffer around the currently activated vector\nThe buffer replaces the current vector"))
+            self._btn_buffer.Bind(wx.EVT_BUTTON,self.Onbuffer)
+
             self.insertvertices = wx.Button(self,label=_('Insert'))
             self.insertvertices.SetToolTip(_("Insert new vertex into the currently active vector from mouse clicks \n The new vertex is inserted along the nearest segment  \n\n Keyboard 'Return' to stop the action ! "))
             self.insertvertices.Bind(wx.EVT_BUTTON,self.Oninsert)
@@ -6929,8 +6933,11 @@ class Zones(wx.Frame, Element_To_Draw):
             box_s.Add(self.getxyfromsz,1,wx.EXPAND) # Added
 
             boxright.Add(self.interpxyz,0,wx.EXPAND)
-            boxright.Add(self.sascending,0,wx.EXPAND)
 
+            _sizer_ascbuffer = wx.BoxSizer(wx.HORIZONTAL)
+            _sizer_ascbuffer.Add(self.sascending,1,wx.EXPAND)
+            _sizer_ascbuffer.Add(self._btn_buffer,1,wx.EXPAND)
+            boxright.Add(_sizer_ascbuffer,0,wx.EXPAND)
 
             sizer_values_surface = wx.BoxSizer(wx.HORIZONTAL)
             self.butgetval = wx.Button(self,label=_('Get values'))
@@ -7491,6 +7498,37 @@ class Zones(wx.Frame, Element_To_Draw):
                 dlg.ShowModal()
                 dlg.Destroy()
 
+    def Onbuffer(self, e:wx.MouseEvent):
+        """ Create a buffer around the currently activated vector.
+        The buffer replaces the active vector in the same zone."""
+
+        if self.wx_exists:
+            if self.verify_activevec():
+                return
+
+            dlg = wx.TextEntryDialog(None, _('Buffer distance ?'), value='5.0')
+            ret = dlg.ShowModal()
+            dist = dlg.GetValue()
+            dlg.Destroy()
+            try:
+                dist = float(dist)
+            except:
+                logging.warning(_('Bad value -- Retry !'))
+                return
+            if dist <= 0:
+                logging.warning(_('Buffer distance must be > 0 -- Retry !'))
+                return
+
+            if self.active_vector.nbvertices == 1:
+                self.active_vector.myvertices = self.active_vector.myvertices * 3
+                logging.warning(_('The active vector has only one vertex. It will be duplicated to create a buffer.'))
+            if self.active_vector.nbvertices == 2:
+                self.active_vector.myvertices = self.active_vector.myvertices + [self.active_vector.myvertices[0]]
+                logging.warning(_('The active vector has only two vertices. The first one will be duplicated to create a buffer.'))
+
+            self.active_vector.buffer(dist)
+            self.active_vector._reset_listogl()
+
     def Onmodify(self, event:wx.MouseEvent):
         """
         Permet la modification interactive de vertex dans le vector actif

wolfhece/Results2DGPU.py

@@ -186,6 +186,7 @@ class wolfres2DGPU(Wolfresults_2D):
         self._cache = None
 
     def __getstate__(self):
+        """ Get state for pickle """
         dct= super().__getstate__()
 
         to_pop = ['_result_store', '_cache']
@@ -193,17 +194,25 @@ class wolfres2DGPU(Wolfresults_2D):
             if key in dct:
                 dct.pop(key)
 
-        dct['isGPU'] = True
+        dct['isGPU'] = True # Indicate that this is a GPU result --> to avoid confusion with CPU results and loading phase "_loader", "_post_loader"
 
         return dct
 
     def __setstate__(self, dct):
-
+        """ Set state from a dictionary from pickle """
         super().__setstate__(dct)
 
         self._loader(self.filename)
         self._post_loader()
 
+        if len(dct['myblocks']) > 0:
+            self.myblocks = dct['myblocks']
+            self.head_blocks = dct['head_blocks']
+            self.loaded_rough = dct['loaded_rough']
+            self.current_result = dct['current_result']
+            self.loaded = dct['loaded']
+            self._nap = dct['_nap']
+
         self._result_store = None
         self._cache = None
         self.setup_store(self._result_store)

wolfhece/__init__.py

@@ -1,4 +1,5 @@
 from . import _add_path
+from .libs import *
 from .PyTranslate import _
 
 try:
@@ -11,5 +12,18 @@ except ImportError as e:
     raise Exception(_('Error importing GDAL library\nPlease ensure GDAL is installed and the Python bindings are available\n\ngdal wheels can be found at https://github.com/cgohlke/geospatial-wheels'))
 
 from .apps.version import WolfVersion
+from packaging.version import Version
 
-__version__ = WolfVersion().get_version()
+__version__ = WolfVersion().get_version()
+
+def is_enough(version: str) -> bool:
+    """
+    Compare the current version of WolfHece to a given version string.
+
+    Args:
+        version (str): The version string to compare against.
+
+    Returns:
+        bool: True if the current version is greater than or equal to the given version, False otherwise.
+    """
+    return Version(__version__) >= Version(version)

wolfhece/_add_path.py

@@ -3,6 +3,11 @@ import os.path
 import sys
 import platform
 
+try:
+    import wolf_libs
+except ImportError:
+    print("wolf_libs not found. Please install the wolf-libs package -- pip install wolf-libs.")
+    sys.exit(1)
 
 def _add_path():
     _root_dir = os.path.dirname(os.path.realpath(__file__))
@@ -10,6 +15,10 @@ def _add_path():
     # manual specify list of dll directories, with paths relative to _root_dir
     _dll_dirs = ['libs', 'shaders']
 
+    # add wolf_libs path to __dll_dirs
+    if wolf_libs.__path__:
+        _dll_dirs.insert(0, os.path.join(wolf_libs.__path__[0]))
+
     if platform.system() == 'Windows':
         os.environ.setdefault('PATH', '')
         paths = os.environ['PATH'].split(';')

wolfhece/apps/check_install.py

@@ -37,12 +37,12 @@ def main():
     else:
         ret += 'WolfGPU not installed\n Please install WolfGPU if needed\n\n'
 
-    # try:
-    #     from ..libs import wolfpy
-    #     ret += 'Wolfpy accessible\n\n'
-    # except ImportError as e:
-    #     ret += 'Wolfpy not accessible\n\n'
-    #     ret += 'Error : ' + str(e) + '\n\n'
+    try:
+        from wolf_libs import wolfpy
+        ret += 'Wolfpy accessible\n\n'
+    except ImportError as e:
+        ret += 'Wolfpy not accessible\n\n'
+        ret += 'Error : ' + str(e) + '\n\n'
 
     try:
         from ..PyGui import MapManager

wolfhece/apps/splashscreen.py

@@ -23,7 +23,7 @@ import time
 from   wx.adv import SplashScreen as SplashScreen,SPLASH_CENTRE_ON_SCREEN,SPLASH_TIMEOUT,Sound
 
 try:
-    from ..libs import wolfogl
+    from wolf_libs import wolfogl
 except ImportError:
     print("** WolfOGL not found **")
     print("Without WolfOGL, the application will not work !")

wolfhece/apps/version.py

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

wolfhece/cli.py

@@ -15,7 +15,8 @@ def check():
 
 def license():
     """ Main wolf application : License """
-    from .libs.wolfogl import request_license
+    from wolf_libs.wolfogl import request_license
+
     from pathlib import Path
 
     if Path(__file__).parent / 'license' / 'wolf.lic':
@@ -76,6 +77,100 @@ def hydro():
     from .apps.wolfhydro import main
     main()
 
+def report_gpu():
+    """ Application for generating GPU simulation reports """
+    from .report.simplesimgpu import SimpleSimGPU_Report
+
+    # récupère l'argument de la ligne de commande
+    from pathlib import Path
+    import sys
+    n = len(sys.argv)
+
+    if n == 3:
+        outpath = Path(sys.argv[2])
+        mydir = Path(sys.argv[1])
+    elif n == 2:
+        outpath = Path('.')
+        mydir = Path(sys.argv[1])
+    else:
+        print('Usage: wolf_report_gpu <directory> or wolf_report_gpu <directory> <directory_out>')
+
+    if n in [2, 3]:
+        if mydir.exists():
+            report = SimpleSimGPU_Report(mydir)
+            report.create_report()
+            report.save_report(outpath / (mydir.name + '_report.pdf'))
+        else:
+            print('Directory not found')
+    else:
+        print('Usage: wolf_report_gpu <directory>')
+
+def reports_gpu():
+    """ Application for generating GPU simulation reports """
+    from .report.simplesimgpu import SimpleSimGPU_Report
+
+    # récupère l'argument de la ligne de commande
+    from pathlib import Path
+    import glob
+    import sys
+    n = len(sys.argv)
+
+    if n == 3:
+        outpath = Path(sys.argv[2])
+        mydir = Path(sys.argv[1])
+    elif n == 2:
+        mydir = Path(sys.argv[1])
+        outpath = Path('.')
+    else:
+        print('Usage: wolf_reports_gpu <directory> or wolf_reports_gpu <directory> <directory_out>')
+
+    if n in [2, 3]:
+        if mydir.exists():
+            # find all sims in the directory
+            sim_dirs = Path(mydir).rglob('parameters.json')
+            sim_dirs = [Path(d).parent for d in sim_dirs]
+            if not sim_dirs:
+                print('No simulation directories found in {}'.format(mydir))
+                return
+            # create a report for each simulation
+            for sim_dir in sim_dirs:
+                print('Creating report for {}'.format(sim_dir))
+                report = SimpleSimGPU_Report(sim_dir)
+                report.create_report()
+                report.save_report(outpath / (sim_dir.name + '_report.pdf'))
+        else:
+            print('Directory not found')
+
+def report_compare():
+    """ Application for comparing GPU simulation reports """
+    from .report.simplesimgpu import SimpleSimGPU_Report_Compare
+
+    # récupère l'argument de la ligne de commande
+    from pathlib import Path
+    import sys
+    n = len(sys.argv)
+    if n == 2:
+        mydir = Path(sys.argv[1])
+        if mydir.exists():
+            report = SimpleSimGPU_Report_Compare(mydir)
+            report.create_report()
+            report.save_report(mydir.name + '_report_compare.pdf')
+        else:
+            print('Directory not found')
+    elif n > 2:
+        files = [Path(f) for f in sys.argv[1:]]
+        if all(f.exists() for f in files):
+            report = SimpleSimGPU_Report_Compare(files)
+            report.create_report()
+            report.save_report('report_compare.pdf')
+        else:
+            for f in files:
+                if not f.exists():
+                    print('File {} not found'.format(f))
+    else:
+        print('Usage: wolf_report_compare <directory> or wolf_report_compare <file1> <file2> ...')
+
+
 def compare():
     """ Application for comparing 2D arrays """
     from .apps.wolfcompare2Darrays import main

wolfhece/hydrology/Optimisation.py

@@ -19,6 +19,8 @@ from matplotlib.backends.backend_wxagg import (
 import shutil
 import ctypes as ct
 
+
+import wolf_libs
 from .PostProcessHydrology import PostProcessHydrology
 from .Catchment import *
 from .Comparison import *
@@ -148,7 +150,10 @@ class Optimisation(wx.Frame):
         self.myParams = {}
         self.myParamsPy = {}
         self.nbParams = 0
-        self.pathDll = Path(os.path.dirname(__file__)).parent
+
+        #self.pathDll = Path(os.path.dirname(__file__)).parent
+        # point to the wolf_libs package directory
+        self.pathDll = wolf_libs.__path__[0]
 
         self.callBack_proc = {}
         self.callBack_ptr = {}
@@ -234,8 +239,8 @@ class Optimisation(wx.Frame):
         self.Bind(wx.EVT_MENU, self.launch_models_propertie_with_Nash, testEquiFinClick)
         plotEquiFinClick = toolMenu.Append(wx.ID_ANY, 'Plot analysis with Nash')
         self.Bind(wx.EVT_MENU, self.plot_model_analysis, plotEquiFinClick)
-        
-        
+
+
 
         # Creation of the Lauch Menu
         launchMenu = wx.Menu()
@@ -2021,7 +2026,7 @@ class Optimisation(wx.Frame):
                             myGroup = myModelDict[int(myType)]["Group"][iFile]
                             myKey = myModelDict[int(myType)]["Key"][iFile]
                             self.write_one_opti_param(filePath, fileName, myGroup, myKey, params[i], convers_factor=convFact[iFile])
-                else:               
+                else:
                     self.curParams_vec_F[i] = params[i]
                     self.update_timeDelay(i+1)
                     refCatch.save_timeDelays([self.myParams[i+1]["junction_name"]])
@@ -2676,10 +2681,10 @@ class Optimisation(wx.Frame):
         logging.info("The equifinality test is finished!")
 
 
-    def get_best_params(self, stationOut:str, 
+    def get_best_params(self, stationOut:str,
                         criterion:str="Nash", quantile:float=0.99, std:float=0.05, eps:float=0.2, rmv_near_max=1e-4, nb_rand_close:int=10,
                         objective_fct:bool= True, apply_clustering:bool=False, objective_weight:float=1.0):
-        from sklearn.cluster import DBSCAN        
+        from sklearn.cluster import DBSCAN
         """
         Get the best parameters for a given station.
 
@@ -2832,10 +2837,10 @@ class Optimisation(wx.Frame):
             return None
         cur_fracts = curBasin.get_volume_fractions(interval=intervals)
         return cur_fracts
-    
-    def _get_flow_fractions(self, idLauncher:int=0, stationOut:str="", 
+
+    def _get_flow_fractions(self, idLauncher:int=0, stationOut:str="",
                          intervals:list[tuple[datetime.datetime, datetime.datetime]]=[]) -> dict[list[str], list[float]]:
-        
+
         curCatch:Catchment = self.myCases[idLauncher].refCatchment
         cur_key = curCatch.get_key_catchmentDict(stationOut)
         curBasin: SubBasin = curCatch.catchmentDict[cur_key]
@@ -2844,11 +2849,11 @@ class Optimisation(wx.Frame):
             return None
         cur_fracts = curBasin.get_flow_fractions(interval=intervals, summary="mean")
         return cur_fracts
-    
 
-    def _get_punctual_reservoir_fractions(self, eval_date:datetime.datetime, 
+
+    def _get_punctual_reservoir_fractions(self, eval_date:datetime.datetime,
                                           idLauncher:int=0, stationOut:str="") -> dict[list[str], list[float]]:
-        
+
         curCatch:Catchment = self.myCases[idLauncher].refCatchment
         cur_key = curCatch.get_key_catchmentDict(stationOut)
         curBasin: SubBasin = curCatch.catchmentDict[cur_key]
@@ -2856,7 +2861,7 @@ class Optimisation(wx.Frame):
             logging.warning("The current module is not a SubBasin object!")
             return None
         linked_params = mc.MODELS_VAR[curBasin.model].get_all_linked_params()
-        i_params = self._get_key_from_type_all_parameters(list(linked_params.values()))    
+        i_params = self._get_key_from_type_all_parameters(list(linked_params.values()))
         max_params = {var_name: self.myParams[i_params[param_id]]["value"] for var_name, param_id in linked_params.items()}
         cur_fracts = curBasin.get_iv_fractions_one_date(max_params=max_params, eval_date=eval_date)
         return cur_fracts
@@ -3021,7 +3026,7 @@ class Optimisation(wx.Frame):
                     cur_columns = [col for col in df.columns if cur_prop in col.replace(" ", "")]
                     if cur_columns != []:
                         corr_prop = cur_columns[0]
-                        ax.scatter(df.loc[:,corr_prop], df.loc[:,y_label], s=0.5, c=cur_color, 
+                        ax.scatter(df.loc[:,corr_prop], df.loc[:,y_label], s=0.5, c=cur_color,
                                    marker='o', label=cur_prop, alpha=0.4)
                 ax.set_xlabel("% of the rain [-]")
                 ax.set_ylabel(y_label+" [-]")
@@ -3049,10 +3054,10 @@ class Optimisation(wx.Frame):
                 ax.set_title("Peak analysis : "+stationOut)
                 ax.legend()
                 fig.savefig(os.path.join(self.workingDir, "Equifinality_peaks_ratio_"+stationOut+".png"))
-                
+
             else:
                 logging.error("The file "+filename+" does not exist!")
-                
+
         plt.show()
 
 
@@ -3212,7 +3217,7 @@ class Optimisation(wx.Frame):
 
     # FIXME : this function has been dashed off -> functionnal but not well written!!
     # TODO : to improve !!!!!!
-    def launch_models_propertie_with_Nash(self, event, idLauncher:int=0, idOpti:int=1, quantile_Nash:float=0.01, std_Nash:float=0.03, clustering_Nash:bool=True, 
+    def launch_models_propertie_with_Nash(self, event, idLauncher:int=0, idOpti:int=1, quantile_Nash:float=0.01, std_Nash:float=0.03, clustering_Nash:bool=True,
                                           save_every:int=100, restart_from_file:bool=True):
         """
         Analyse the properties of the model and compare them with the Nash coefficient.
@@ -3232,11 +3237,11 @@ class Optimisation(wx.Frame):
         if onlyOwnSub is None:
             onlyOwnSub = False
         doneList = []
-        previousLevel = 1 
+        previousLevel = 1
         # Collect sort and save the compare stations
         self.set_compare_stations(idLauncher=idLauncher)
         sortJct = self.myStations
-        # Get the initial number of intervals 
+        # Get the initial number of intervals
         # -> these can evolve according to the measurement available at each station
         is_ok = self._save_opti_intervals()
         all_intervals = self.all_intervals
@@ -3268,14 +3273,14 @@ class Optimisation(wx.Frame):
             # Reload the useful modules
             self.reload_hydro(idCompar=0, fromStation=stationOut, lastLevel=previousLevel, updateAll=True)
             ## =======
-            ## Init 
+            ## Init
             ## =======
             self.init_optimizer(idOpti)
             self.associate_ptr(None, idOpti=idOpti)
             # Get the best parameters to test
             all_params = self.get_best_params(stationOut=stationOut, quantile=quantile_Nash, std=std_Nash, rmv_near_max=1e-4, apply_clustering=clustering_Nash)
             ## =======
-            ## Compute 
+            ## Compute
             ## =======
             all_frac = []
             # Check if the excel file already exists and load it to check if some parameters have already been tested
@@ -3307,7 +3312,7 @@ class Optimisation(wx.Frame):
                 cur_all_frac = (list(cur_p)
                                 + cur_timeDelays
                                 + list(frac_flow_dict.values())
-                                + list(init_iv.values()) 
+                                + list(init_iv.values())
                                 + [p_excess, max_sim_obs, cur_obj])
                 all_frac.append(cur_all_frac)
                 # Periodically save the evaluations in case of trouble
@@ -3364,14 +3369,14 @@ class Optimisation(wx.Frame):
     # FIXME : it might be better to pass the myParams to the CaseOpti object instead to allow parallelisation
     def _build_type_to_key_index(self) -> dict[int, int]:
         return {param["type"]: i for i, param in self.myParams.items()}
-    
+
     def _get_key_from_type_all_parameters(self, list_type_param: list[int]) -> dict[int | None]:
         type_to_key = self._build_type_to_key_index()
         return {cur_key: type_to_key.get(cur_key) for cur_key in list_type_param}
 
     def _get_key_from_type_parameter(self, type_param:int) -> int:
         return next((i for i, param in self.myParams.items() if param["type"] == type_param), None)
-    
+
 
     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
@@ -3417,5 +3422,5 @@ class Optimisation(wx.Frame):
             # Remove the parameters that have already been tested
             new_params = np.array([el for el in all_params if ~np.any(np.all(np.isclose(all_params_tested, el[:-1], atol=1e-6), axis=1))])
             return all_data_tested, new_params
-        
+
         return [], all_params

wolfhece/mesh2d/cst_2D_boundary_conditions.py

@@ -30,7 +30,7 @@ class BCType_2D_GPU(Enum):
     """ Boundary conditions for 2D simulations with wolfgpu """
 
     # The numbers match the numbers in Wolf's simulations parameters.
-    # H    = (1,_('Water level [m]'))
+    H    = (1,_('Water level [m]'))
     QX   = (2,_('Flow rate along X [m²/s]'))
     QY   = (3,_('Flow rate along Y [m²/s]'))
     NONE = (4,_('None'))