wolfhece 2.1.99__py3-none-any.whl → 2.1.101__py3-none-any.whl

wolfhece/mesh2d/wolf2dprev.py

@@ -40,7 +40,7 @@ from ..PyVertex import getIfromRGB
 from ..PyTranslate import _
 from ..CpGrid import CpGrid
 from ..GraphNotebook import PlotPanel
-from ..PyParams import Wolf_Param, new_json
+from ..PyParams import Wolf_Param, new_json, key_Param, Type_Param
 from .cst_2D_boundary_conditions import BCType_2D, Direction, BCType_2D_To_BCType_2D_GPU
 
 PREV_INFILTRATION_NULL = 0  #PAS D'INFILTRATION
@@ -8100,9 +8100,12 @@ class prev_infiltration():
 
         sequence, nb_zones = self._infiltrations_chronology.shape
         for zone in range(1,nb_zones):
-            ax.plot(self._infiltrations_chronology[:, 0], self._infiltrations_chronology[:, zone], label=f'Infil {zone}')
+            ax.plot(self._infiltrations_chronology[:, 0], self._infiltrations_chronology[:, zone], label=f'Zone {zone}')
 
+        ax.set_xlabel(_('Time [s]'))
+        ax.set_ylabel(_('Infiltration [$m^3/s$]'))
         ax.legend()
+        fig.tight_layout()
 
         if show:
             fig.show()

wolfhece/pidcontroller.py

@@ -0,0 +1,131 @@
+import numpy as np
+
+class PIDController:
+    """
+    Tuning a PID controller -- https://dewesoft.com/blog/what-is-pid-controller
+
+    Tuning the PID parameters Kp, Ki and Kd is crucial in PID controller design. 
+    Tuning must be customized for each of the many PID applications. 
+    Key tuning parameters include:
+
+     - Proportional Gain (Kp): This parameter determines the proportion of 
+       the error signal contributing to the controller output. A higher  
+       Kp value results in a stronger response to the current error. 
+       Too high a Kp can lead to oscillations or instability, while too 
+       low a value can result in a sluggish response.
+
+     - Integral Gain (Ki): The integral term considers the accumulation 
+       of past errors and amplifies them over time. It helps eliminate 
+       steady-state error by continuously adjusting the control signal. 
+       A higher Ki value helps reduce steady-state error but can lead 
+       to overshoot or instability if set too high.
+
+     - Derivative Gain (Kd): The derivative term predicts the future behavior 
+       of the error based on its current rate of change. It helps dampen 
+       oscillations by counteracting rapid changes in the error signal. 
+       Increasing Kd enhances damping and reduces overshoot, but too high 
+       a value can lead to instability or sensitivity to noise.
+
+    The tuning process involves adjusting these parameters to achieve 
+    desired system performance, such as stability, responsiveness, 
+    and minimal overshoot. Several methods are used for PID tuning, 
+    including manual tuning, Ziegler-Nichols method, and optimization 
+    algorithms. Let’s take a closer look at each of these methods:
+
+    In manual tuning, the engineer adjusts the parameters based on their 
+    understanding of the system dynamics and the desired performance criteria. 
+    This method involves iteratively tweaking the parameters while observing 
+    the system's response until satisfactory performance is achieved.
+
+    The Ziegler-Nichols Method provides a systematic approach to PID 
+    tuning based on step response experiments. The integral and derivative 
+    gains are set to zero and gradually increased until the system oscillates 
+    at a constant amplitude. The proportional gain and oscillation period 
+    are determined from the oscillation period and amplitude, which are 
+    then used to calculate suitable PID parameters. Several other tuning 
+    methods exist, including Cohen-Coon, Lambda, and Dead Time. 
+
+    Optimization algorithms such as gradient descent, genetic algorithms, 
+    or particle swarm optimization automatically search for optimal PID 
+    parameters based on specified performance criteria and system models.
+
+    PID tuning is a critical step in control system design. It ensures 
+    that the controller effectively regulates the system while meeting 
+    performance requirements.    
+    """
+
+    def __init__(self, kp, ki, kd):
+        """
+        Initialize the PID controller with given coefficients.
+
+        :params kp (float): Proportional gain coefficient.
+        :params ki (float): Integral gain coefficient.
+        :params kd (float): Derivative gain coefficient.
+        """
+
+        self.kp = kp
+        self.ki = ki
+        self.kd = kd
+        self.error_sum = 0
+        self.last_error = 0
+
+    def calculate(self, setpoint, feedback):
+        """ Compute the PID response.
+        
+        :param setpoint: Objective value to achieve.
+        :type setpoint: float
+        :param feedback: Current measured value.
+        :type feedback: float
+        :return: PID control output.
+        :rtype: float
+        """ 
+
+        error = setpoint - feedback
+        self.error_sum += error
+        error_diff = error - self.last_error
+        self.last_error = error
+
+        p = self.kp * error
+        i = self.ki * self.error_sum
+        d = self.kd * error_diff
+
+        return p + i + d
+
+if __name__ == "__main__":    
+
+    import matplotlib.pyplot as plt
+
+    # Create a PIDController instance
+    pid_controller = PIDController(kp=0.5, ki=0.1, kd=.5)
+
+    # Define time range and step size
+    t_start = 0
+    t_end = 10
+    dt = 0.1
+
+    # Initialize lists to store time and output values
+    time = []
+    output = []
+    measures = [1]
+
+    # Simulate the system over time
+    for t in np.arange(t_start, t_end, dt):
+        # Calculate the output using the PID controller
+        setpoint = 10  # Example setpoint
+        control_signal = pid_controller.calculate(setpoint, measures[-1])
+
+        # Simulate the system dynamics
+        # In a real-world application, this would be replaced by actual measurements
+        measures.append(measures[-1] + .4 * control_signal)
+        
+        # Store the time and output values
+        time.append(t)
+        output.append(control_signal)
+
+    # Plot the output over time
+    plt.plot(time, measures[1:], label='System Output')
+    plt.xlabel('Time')
+    plt.ylabel('Output')
+    plt.title('PID Controller Output')
+    plt.grid(True)
+    plt.show()

wolfhece/pywalous.py

@@ -130,13 +130,13 @@ def update_palette_walous(which:Literal['MAJ_NIV1', 'MAJ_NIV2'], pal:wolfpalette
     return 0
 
 
-WALOUS2MANNING_MAJ_NIV1 = {1.: 0.04,
-                           2.: 0.02,
-                           3.: 0.02,
-                           4.: 0.03,
-                           5.: 0.025,
-                           6.: 0.04,
-                           7.: 0.05}
+WALOUS2MANNING_MAJ_NIV1 = {1.: 0.04, # Production primaire
+                           2.: 0.02, # Production secondaire
+                           3.: 0.02, # Production tertiaire
+                           4.: 0.03, # Réseaux de transport, Logistique et réseaux d'utilité publique
+                           5.: 0.025,# Usage résidentiel
+                           6.: 0.04, # Autres usages
+                           7.: 0.05} # Zones naturelles
 
 WALOUS2MANNING_MAJ_NIV2 = {11.: 0.04, # Agriculture
                            12.: 0.04, # Sylviculture

wolfhece/scenario/config_manager.py

@@ -202,14 +202,15 @@ class Config_Manager_2D_GPU:
     Gestionnaire de configurations 2D - code GPU
     """
 
-    def __init__(self, workingdir:str = '', mapviewer:WolfMapViewer = None) -> None:
+    def __init__(self, workingdir:str = '', mapviewer:WolfMapViewer = None, python_venv:Path = None) -> None:
         """
         Recherche de toutes les modélisation dans un répertoire et ses sous-répertoires
         """
         self.wx_exists = wx.App.Get() is not None
 
-        self.workingdir = ''
-        self.wolfcli    = ''
+        self.workingdir:Path = None
+        self.wolfgpu:Path = None
+        self._py_env:Path = python_venv
 
         if workingdir == '':
             if self.wx_exists:
@@ -228,6 +229,7 @@ class Config_Manager_2D_GPU:
             logging.error(_('Directory does not exist !'))
             return
 
+        self.find_wolfgpu()
         self.workingdir = Path(workingdir)
         self.mapviewer  = mapviewer
 
@@ -239,6 +241,33 @@ class Config_Manager_2D_GPU:
 
         self.load_data()
 
+    def find_wolfgpu(self):
+        """ Find the wolfgpu Path from wolfgpu package"""
+
+        import importlib.util
+        import sys
+
+        if self._py_env is None:
+            self._py_env = Path(sys.executable).parent
+
+        # Find wolfgpu.exe in script directory
+        candidate = self._py_env / 'wolfgpu.exe'
+
+        if candidate.exists():
+            self.wolfgpu = candidate
+            return
+
+        candidate = self._py_env / 'Scripts' / 'wolfgpu.exe'
+
+        if candidate.exists():
+            self.wolfgpu = candidate
+            return
+        else:
+            logging.error(_('WOLFGPU not found !'))
+            self.wolfgpu = None
+            self._py_env = None
+
+
     def _test_ui(self):
         """ Test if the UI is available """
 
@@ -1142,7 +1171,7 @@ class Config_Manager_2D_GPU:
             quit = True
 
         if quit:
-            logging.error(_('Bas assembly operation -- Simulation creation aborted !'))
+            logging.error(_('Bad assembly operation -- Simulation creation aborted !'))
             return
 
         bat = WolfArray(str(dir / '__bathymetry.tif'))
@@ -1263,25 +1292,35 @@ class Config_Manager_2D_GPU:
             logging.info(cursim.check_errors())
             logging.info(_('Simulation {} created !'.format(curdir)))
 
-
             with open(curdir / 'quickrun.bat', 'w', encoding='utf-8') as f:
+                f.write("@echo off\n")
+                f.write("\n")
                 f.write(str(curdir.drive) + '\n')
                 f.write('cd {}\n'.format(str(curdir.parent)))
-                f.write('wolfgpu -quickrun ' + str(curdir.name) + '\n')
-
-                # f.write("from pathlib import Path\n")
-                # f.write("from wolfgpu.simple_simulation import SimpleSimulation\n")
-                # f.write("from wolfgpu.SimulationRunner import SimulationRunner\n")
-                # f.write("from wolfgpu.glsimulation import ResultsStore\n\n")
-                # f.write("def main():\n")
-                # f.write("\tsim = SimpleSimulation.load(Path(__file__).parent)\n")
-                # f.write("\tresult_store:ResultsStore = SimulationRunner.quick_run(sim, Path(__file__).parent)")
-                # f.write("\n\nif __name__ == '__main__':\n")
-                # f.write("\tmain()\n")
+                f.write("\n")
+                f.write("WOLFGPU_PARAMS=-quickrun " + str(curdir.name) + "\n")
+                f.write("\n")
+                f.write("where wolfgpu.exe\n")
+                f.write("IF %ERRORLEVEL%==0 (\n")
+                f.write("wolfgpu %WOLFGPU_PARAMS%\n")
+                f.write("goto :end\n")
+                f.write(")\n")
+                f.write("\n")
+                f.write("echo -------------------------------\n")
+                f.write("echo ERROR !!!\n")
+                f.write("echo -------------------------------\n")
+                f.write("echo I can't find wolfgpu.exe.\n")
+                f.write("echo It is normally installed in the 'Scripts' subdirectory of your python\n")
+                f.write("echo directory (or environment).\n")
+                f.write("echo This 'Scripts' subdirectory must be available on the PATH environment variable.\n")
+                f.write("echo I am now going to try to run wolfgpu as a regular python module\n")
+                f.write("echo -------------------------------\n")
+                f.write("pause\n")
+                f.write("python -m wolfgpu.cli %WOLFGPU_PARAMS%\n")
+                f.write(":end\n")
 
             allsims.append(curdir / 'quickrun.bat')
 
-
         logging.info(_('Simulation creation finished !'))
         logging.warning(_('Do not forget to update/set the boundary conditions if not set by scripts !'))
 
@@ -1303,10 +1342,24 @@ class Config_Manager_2D_GPU:
         with open(path, 'w', encoding='utf-8') as f:
             f.write(batch)
 
+        if self.wolfgpu is None:
+            logging.warning('****************************************************')
+            logging.warning(_('Wolfgpu.exe not found !'))
+            logging.warning(_('It is normally installed in the "Scripts" subdirectory of your python directory (or environment).'))
+            logging.warning(_('This "Scripts" subdirectory must be available on the PATH environment variable.'))
+            logging.warning('****************************************************')
+        else:
+            logging.info('****************************************************')
+            logging.info(_('Wolfgpu.exe found in {}!').format(self.wolfgpu))
+            logging.info(_('You can now run the simulations !'))
+            logging.info(_('Do not forget to activate your Python virtual environment if you are using one !'))
+            logging.info('****************************************************')
+
         return batch
 
     def run_batch(self, batch:Path):
         """ run a batch file in a subprocess """
+
         if not batch.exists():
             logging.error(_('Batch file {} does not exist !'.format(batch)))
             return
@@ -1763,9 +1816,33 @@ class UI_Manager_2D_GPU():
 
         log = self._parent.check_consistency()
         if log =='':
-            self._txtctrl.WriteText(_("All is fine !"))
+            self._txtctrl.WriteText(_("All is fine !\n\n"))
         else:
-            self._txtctrl.WriteText(log)
+            self._txtctrl.WriteText(log +"\n\n")
+
+        # Info on Python Environment and wolfgpu Path and version
+        # -------------------------------------------------------
+
+        import sys
+        # Python Environment
+        self._txtctrl.write(_('Python Environment\n'))
+        self._txtctrl.write('-------------------\n')
+        self._txtctrl.write('Python version : {}\n'.format(sys.version))
+        self._txtctrl.write('Python path : {}\n'.format(sys.executable))
+        self._txtctrl.write('Python version info : {}\n'.format(sys.version_info))
+
+        # Test if wolfgpu.exe exists in script directory
+        # wolfgpu Path and version
+        self._txtctrl.write('\nWolfgpu Path and version\n')
+        self._txtctrl.write('------------------------\n')
+
+        wolfgpu = self._parent.wolfgpu
+        if wolfgpu.exists():
+            self._txtctrl.write('Wolfgpu.exe found in : {}\n'.format(self._parent.wolfgpu.parent))
+        else:
+            self._txtctrl.write('Wolfgpu.exe not found !\n')
+            self._parent.wolfgpu = None
+
 
     def choice_hydrograph(self) -> list[int]:
 
@@ -1975,7 +2052,7 @@ class UI_Manager_2D_GPU():
                 try:
                     if curwp.Shown:
                         cursim.from_wolfparam(curwp)
-                        cursim.save_json()
+                        cursim._save_json()
                 except Exception as e:
                     self._wp[cursim] = None
                     logging.debug(_('Error while saving parameters for simulation {}'.format(cursim.path.name)))
@@ -1989,7 +2066,7 @@ class UI_Manager_2D_GPU():
                 try:
                     if curwp.Shown:
                         cursim.from_wolfparam(curwp)
-                        cursim.save_json()
+                        cursim._save_json()
                 except Exception as e:
                     self._wp[cursim] = None
                     logging.debug(_('Error while saving parameters for simulation {}'.format(cursim.path.name)))