wolfhece 2.1.118__py3-none-any.whl → 2.1.120__py3-none-any.whl

wolfhece/wolfresults_2D.py

@@ -41,6 +41,7 @@ from .pyviews import WolfViews
 from .mesh2d.wolf2dprev import prev_parameters_simul, blocks_file
 from .GraphNotebook import PlotPanel
 from .CpGrid import CpGrid
+from .matplotlib_fig import  Matplotlib_Figure
 
 
 try:
@@ -1458,6 +1459,38 @@ VIEWS_COMPLEX = [views_2D.T_WD_Q,
 
 VIEWS_VECTOR_FIELD = [views_2D.VECTOR_FIELD_Q, views_2D.VECTOR_FIELD_U]
 
+
+class Extractable_results(Enum):
+    # (h,qx,qy,vx,vy,vabs,fr,h+top,top)
+    H = (_('Water depth [m]'), 0)
+    Z = (_('Water level [m]'), 7)
+    HEAD = (_('Head [m]'), None)
+    FROUDE = (_('Froude [-]'), 6)
+    VX = (_('Velocity X [ms-1]'), 3)
+    VY = (_('Velocity Y [ms-1]'), 4)
+    V_NORM = (_('Velocity norm [ms-1]'), 5)
+    QX = (_('Specific discharge X [m2s-1]'), 1)
+    QY = (_('Specific discharge Y [m2s-1]'), 2)
+    TOP = (_('TopoBathymetry [m]'), 8)
+    # INT_QX = (_('Discharge X [m3s-1]'), None)
+    # INT_QY = (_('Discharge Y [m3s-1]'), None)
+
+    @classmethod
+    def get_from_key(cls,key):
+        for cur in Extractable_results:
+            if cur.value[0] == key:
+                return cur
+
+        return None
+
+    @classmethod
+    def get_list(cls):
+        return [cur.value[0] for cur in Extractable_results]
+
+ER_DIRECT_ACCESS = [Extractable_results.H, Extractable_results.QX, Extractable_results.QY, Extractable_results.VX,
+                    Extractable_results.VY, Extractable_results.V_NORM, Extractable_results.FROUDE, Extractable_results.Z,
+                    Extractable_results.TOP]
+
 class OneWolfResult:
     """
     Stockage des résultats d'un bloc de modèle WOLF2D
@@ -3464,7 +3497,7 @@ class Wolfresults_2D(Element_To_Draw):
         :param agglo (optional) agglomère le résultat en une seule liste plutôt que d'avoir autant de liste que de blocs
         :param getxy (optional) retourne en plus les coordonnées des points
 
-        :return myvalues : valeurs des mailles
+        :return: valeurs, valeurs d'élévation, coordonnées des points (si getxy=True)
 
         """
         myvalues={}
@@ -3502,12 +3535,16 @@ class Wolfresults_2D(Element_To_Draw):
             else:
                 return myvalues,None
 
-    def get_all_values_insidepoly(self,myvect:vector, usemask=True, agglo=True, getxy=False):
+    def get_all_values_insidepoly(self, myvect:vector, usemask:bool= True, agglo:bool= True, getxy:bool= False):
         """
         Récupération de toutes les valeurs dans un polygone
 
-        usemask (optional) restreint les éléments aux éléments non masqués de la matrice
-        getxy (optional) retourne en plus les coordonnées des points
+        :param myvect: polygone
+        :param usemask: (optional) restreint les éléments aux éléments non masqués de la matrice
+        :param agglo: (optional) agglomère le résultat en une seule liste plutôt que d'avoir autant de liste que de blocs
+        :param getxy: (optional) retourne en plus les coordonnées des points
+
+        :return: valeurs, coordonnées des points (si getxy=True)
         """
 
         myvalues={}
@@ -3532,14 +3569,19 @@ class Wolfresults_2D(Element_To_Draw):
         else:
             return myvalues
 
-    def get_all_values_underpoly(self,myvect:vector, usemask=True, agglo=True, getxy=False, integrate_q = False):
+    def get_all_values_underpoly(self,myvect:vector, usemask:bool= True, agglo:bool= True, getxy:bool= False, integrate_q:bool = False):
         """
-        Récupération de toutes les valeurs sous la polyligne
+        Récupération de toutes les valeurs sous la polyligne.
+
         Les valeurs retrounées sont identiques à la fonction "get_values_from_xy" soit (h,qx,qy,vx,vy,vabs,fr,h+top,top),(i+1,j+1,curblock.idx+1)
 
-        usemask (optional) restreint les éléments aux éléments non masqués de la matrice
-        getxy (optional) retourne en plus les coordonnées des points
-        agglo (optional) agglomère le résultat en une seule liste plutôt que d'avoir autant de liste que de blocs
+        :param myvect: polygone
+        :param usemask :(optional) restreint les éléments aux éléments non masqués de la matrice
+        :param getxy: (optional) retourne en plus les coordonnées des points
+        :param agglo: (optional) agglomère le résultat en une seule liste plutôt que d'avoir autant de liste que de blocs
+        :param integrate_q: (optional) pour intégrer les débits
+
+        :return: valeurs, coordonnées des points (si getxy=True)
         """
         myvalues={}
         mypoints = self.get_xy_under_polyline(myvect)
@@ -3878,17 +3920,96 @@ class Wolfresults_2D(Element_To_Draw):
 
         return fig,ax
 
-    def plot_h(self, xy:Union[list[float], vector], h_or_z:Literal['h', 'z', 'head'], toshow=False, figax = None):
+    def plot_q_wx(self,
+               vect:Union[vector, list[vector]],
+               x_or_y:Union[str, list[str]] = 'border',
+               toshow=False,
+               absolute=True,
+               fig:Matplotlib_Figure = None):
         """
-        Plot water depth at one or multiple coordinates
+        Plot discharge along vector
 
-        :param xy : list of coordinates
-        :param h_or_z : 'h' for water depth, 'z' for bed elevation, 'head' for water head
+        :param vector : wolf polyline -- will be splitted according to spatial step size
+        :param x_or_y : 'x' for qx, 'y' for qy - integration axis or 'border' for q normal at border
         :param toshow : show the plot
+        :param absolute : plot absolute value of discharge
         :param figax : tuple of matplotlib figure and axis
 
         """
 
+        nb = self.get_nbresults()
+        times, steps = self.times, self.timesteps
+
+        if fig is None:
+            fig:Matplotlib_Figure
+        else:
+            assert isinstance(fig, Matplotlib_Figure), 'Expected a WOLF Matplotlib_Figure'
+
+        if isinstance(vect, vector):
+            assert x_or_y in ['x', 'y', 'border'], 'x_or_y must be "x", "y" or "border"'
+
+            q=[]
+            for i in tqdm(range(nb)):
+                self.read_oneresult(i)
+                if x_or_y in ['x', 'y']:
+                    q.append(self._plot_one_q(vect, x_or_y, absolute))
+                elif x_or_y == 'border':
+                    if i==0:
+                        myhead = self.get_header_block(1)
+                        vect_raster = myhead.rasterize_vector(vect)
+                    q.append(self._plot_one_q_raster_splitting(vect_raster, absolute, to_rasterize = False))
+
+            fig.plot(times,q, c='blue', label=vect.myname)
+
+        else:
+
+            assert len(vect) == len(x_or_y), 'Exepected same length for vect and x_or_y'
+            for cur in x_or_y:
+                assert cur in ['x', 'y', 'border'], 'x_or_y must be "x", "y" or "border"'
+
+            q={int:list}
+            vect_raster = []
+            myhead = self.get_header_block(1)
+
+            for i in range(len(vect)):
+                q[i]= []
+                if x_or_y[i] == 'border':
+                    vect_raster.append(myhead.rasterize_vector(vect[i]))
+
+            for i in tqdm(range(nb)):
+                self.read_oneresult(i)
+
+                for idx, (curvec, orient) in enumerate(zip(vect, x_or_y)):
+
+                    if orient in ['x', 'y']:
+                        q[idx].append(self._plot_one_q(curvec, orient, absolute))
+                    elif orient == 'border':
+                        cur_vect_raster = vect_raster[idx]
+                        q[idx].append(self._plot_one_q_raster_splitting(cur_vect_raster, absolute, to_rasterize = False))
+
+            for i in range(len(vect)):
+                fig.plot(times,q[i], label=vect[i].myname)
+
+        fig.cur_ax.set_xlabel(_('Time [s]'))
+        fig.cur_ax.set_ylabel(_('Discharge/Flow rate [$m^3s^{-1}$]'))
+        fig.cur_ax.legend(loc=2)
+
+        if toshow:
+            fig.Show()
+
+        return fig
+
+    def get_values_xyorpoly_depr(self, xy:Union[list[float], vector], h_or_z:Literal['h', 'z', 'head']):
+        """
+        ** DEPRECATED : Will be removed in future version -- Please use get_values_xyorpoly instead **
+
+        Get water depth at one or multiple coordinates
+
+        :param xy : list of coordinates
+        :param h_or_z : 'h' for water depth, 'z' for bed elevation, 'head' for water head
+
+        """
+
         nb = self.get_nbresults(force_update_timessteps=True)
         times, steps = self.times, self.timesteps
 
@@ -3937,6 +4058,23 @@ class Wolfresults_2D(Element_To_Draw):
 
                 vals.append(values)
 
+        return times, steps, vals, label, label_y
+
+    def plot_h(self, xy:Union[list[float], vector], h_or_z:Literal['h', 'z', 'head'], toshow=False, figax = None):
+        """
+        **DEPRECATED : Will be removed in future version -- Please use plot_results_mpl instead**
+
+        Plot water depth at one or multiple coordinates
+
+        :param xy : list of coordinates
+        :param h_or_z : 'h' for water depth, 'z' for bed elevation, 'head' for water head
+        :param toshow : show the plot
+        :param figax : tuple of matplotlib figure and axis
+
+        """
+
+        times, steps, vals, legend, label_y = self.get_values_xyorpoly_depr(xy, h_or_z)
+
         if figax is None:
             fig, ax = plt.subplots()
         else:
@@ -3950,9 +4088,9 @@ class Wolfresults_2D(Element_To_Draw):
             min.append(curvals.min())
             max.append(curvals.max())
 
-        ax.plot(times, means, label=_('Mean value - {}'.format(label)))
-        ax.plot(times, min, label=_('Min value - {}'.format(label)))
-        ax.plot(times, max, label=_('Max value - {}'.format(label)))
+        ax.plot(times, means, label=_('Mean value - {}'.format(legend)))
+        ax.plot(times, min, label=_('Min value - {}'.format(legend)))
+        ax.plot(times, max, label=_('Max value - {}'.format(legend)))
 
         ax.set_xlabel(_('Time [s]'))
         ax.set_ylabel(label_y)
@@ -3964,11 +4102,332 @@ class Wolfresults_2D(Element_To_Draw):
 
         return fig,ax
 
-    def get_values_from_xy(self, x:float, y:float, aswolf=True, integrate_q = False):
+    def get_all_values_xyorpoly_series(self, xy:Union[list[float], vector], for_steps:tuple[int] | list[int] = (0,-1,1)):
         """
-        Retrouve les valeurs sur base de la coordonnée (x,y)
+        Get water depth at one or multiple coordinates.
 
-        aswolf : (optional) si True alors ajoute 1 à i et j pour se retrouver en numérotation VB6/Fortran
+        :param xy : list of coordinates
+        :param for_steps : tuple of start, end and step -- 0-based -- default is all steps (0,-1,1)
+
+        :return: (times, steps), values -- numpy arrays
+        """
+
+        assert isinstance(xy, vector) or isinstance(xy, list), 'Expected a vector or a list of coordinates'
+        if isinstance(for_steps, tuple):
+            assert len(for_steps) == 3, 'Expected a tuple of 3 integers -- start, end and step'
+        else:
+            assert isinstance(for_steps, list), 'Expected a list of integers'
+
+        # Récupération du nombre de résultats
+        nb = self.get_nbresults(force_update_timessteps=True)
+
+        # Définition des bornes -- tests de validité
+        if isinstance(for_steps, tuple):
+            first, last, step = for_steps
+
+            if last == -1:
+                last = nb
+
+            assert last > first, 'Expected end step greater than start step'
+
+            if first < 0:
+                first = 0
+            if last > nb:
+                last = nb
+
+            all_steps = np.arange(0, nb, step)
+            if step > 1 and last < nb:
+                if all_steps[-1] != last:
+                    all_steps = np.append(all_steps, last)
+
+        else:
+            all_steps = list(set(for_steps))
+            all_steps.sort()
+
+            filter(lambda x: x >= 0 and x < nb, all_steps)
+
+        # Récupération des temps et des pas
+        times = np.asarray([self.times[i] for i in all_steps])
+        steps = np.asarray([self.timesteps[i] for i in all_steps])
+
+        pg_bar = None
+        if self.wx_exists:
+            pg_bar = wx.ProgressDialog(_('Extracting values'), _('Extracting values for each step'), len(all_steps)-1, style=wx.PD_ELAPSED_TIME | wx.PD_REMAINING_TIME | wx.PD_AUTO_HIDE)
+
+        # extraction des valeurs pour chaque pas de temps souhaité
+        tmp_vals=[]
+        if isinstance(xy, vector):
+
+            for i, curstep in tqdm(enumerate(all_steps)):
+                self.read_oneresult(curstep)
+                locvals = self.get_all_values_insidepoly(xy, getxy= False)
+
+                if pg_bar:
+                    pg_bar.Update(i)
+
+                vals = []
+                for values in locvals:
+                    vals.append(np.asarray([cur for cur in values.T[0]]))
+
+                tmp_vals.append(vals)
+
+        else:
+            for i, curstep in tqdm(enumerate(all_steps)):
+                self.read_oneresult(curstep)
+
+                tmp_vals.append([self.get_values_from_xy(x,y)[0] for x,y in xy])
+
+                if pg_bar:
+                    pg_bar.Update(i)
+
+        return (times, steps), tmp_vals
+
+    def get_values_xyorpoly_series(self, xy:Union[list[float], vector], which:Extractable_results, for_steps:tuple[int] | list[int] = (0,-1,1)):
+        """
+        Get water depth at one or multiple coordinates.
+
+        :param xy : list of coordinates
+        :param which : which results to plot -- see Extractable_results Enum
+        :param for_steps : tuple of start, end and step -- 0-based -- default is all steps (0,-1,1)
+
+        :return: (times, steps), values -- numpy arrays
+        """
+
+        assert which in Extractable_results, 'Expected a valid Extractable_results'
+        assert isinstance(xy, vector) or isinstance(xy, list), 'Expected a vector or a list of coordinates'
+        if isinstance(for_steps, tuple):
+            assert len(for_steps) == 3, 'Expected a tuple of 3 integers -- start, end and step'
+        else:
+            assert isinstance(for_steps, list), 'Expected a list of integers'
+
+        (times, steps), tmp_vals = self.get_all_values_xyorpoly_series(xy, for_steps)
+
+        vals = []
+        if which in ER_DIRECT_ACCESS:
+            idx = which.value[1]
+            for step in tmp_vals:
+                vals.append(np.asarray([node[idx] for node in step]))
+        elif which == Extractable_results.HEAD:
+            for step in tmp_vals:
+                vals.append(np.asarray([node[7]+node[5]**2./2/9.81 for node in step]))
+
+        return (times, steps), vals
+
+    def plot_some_values(self, xy:Union[list[float], vector], which:Extractable_results, toshow=False, figax = None, for_steps:tuple[int] | list[int] = (0,-1,1), x_axis:Literal['time', 'step'] = 'time'):
+        """
+        Plot some results at one or multiple coordinates defined by a vector or a list of coordinates
+        or a polygon
+
+        :param xy : list of coordinates or vector
+        :param which : which results to plot -- see Extractable_results Enum
+        :param toshow : show the plot
+        :param figax : tuple of matplotlib figure and axis
+        :param for_steps : tuple of start, end and step -- 0-based -- default is all steps (0,-1,1)
+
+        """
+
+        assert which in Extractable_results, 'Expected a valid Extractable_results'
+        assert x_axis in ['time', 'step'], 'Expected "time" or "step" for x_axis'
+
+        (times, steps), vals = self.get_values_xyorpoly_series(xy, which, for_steps)
+
+        means= []
+        median = []
+        min = []
+        max = []
+        for curvals in vals:
+            means.append(curvals.mean())
+            median.append(np.median(curvals))
+            min.append(curvals.min())
+            max.append(curvals.max())
+
+        legend = xy.myname if isinstance(xy, vector) else _('Selected nodes')
+
+        x_label = _('Time [s]') if x_axis == 'time' else _('Step [-]')
+
+        if isinstance(figax, Matplotlib_Figure):
+            fig, ax = figax.get_figax()
+
+            if x_axis == 'time':
+                figax.plot(times, means, label=_('Mean value - {}'.format(legend)))
+                figax.plot(times, median, label=_('Median value - {}'.format(legend)))
+                figax.plot(times, min, label=_('Min value - {}'.format(legend)))
+                figax.plot(times, max, label=_('Max value - {}'.format(legend)))
+
+            elif x_axis == 'step':
+                figax.plot(steps, means, label=_('Mean value - {}'.format(legend)))
+                figax.plot(steps, median, label=_('Median value - {}'.format(legend)))
+                figax.plot(steps, min, label=_('Min value - {}'.format(legend)))
+                figax.plot(steps, max, label=_('Max value - {}'.format(legend)))
+
+            figax.cur_ax.set_xlabel(x_label)
+            figax.cur_ax.set_ylabel(which.value[0])
+
+        else:
+            if figax is None:
+                fig, ax = plt.subplots()
+            else:
+                fig, ax = figax
+
+            if x_axis == 'time':
+                ax.plot(times, means, label=_('Mean value - {}'.format(legend)))
+                ax.plot(times, median, label=_('Median value - {}'.format(legend)))
+                ax.plot(times, min, label=_('Min value - {}'.format(legend)))
+                ax.plot(times, max, label=_('Max value - {}'.format(legend)))
+            elif x_axis == 'step':
+                ax.plot(steps, means, label=_('Mean value - {}'.format(legend)))
+                ax.plot(steps, median, label=_('Median value - {}'.format(legend)))
+                ax.plot(steps, min, label=_('Min value - {}'.format(legend)))
+                ax.plot(steps, max, label=_('Max value - {}'.format(legend)))
+
+            ax.set_xlabel(x_label)
+            ax.set_ylabel(which.value[0])
+
+            fig.tight_layout()
+
+            if toshow:
+                fig.show()
+
+        return fig,ax
+
+    def plot_violin_values(self, xy:Union[list[float], vector], which:Extractable_results, toshow=False, figax = None, for_steps:tuple[int] | list[int] = (0,-1,1), x_axis:Literal['time', 'step'] = 'time'):
+        """
+        Plot some results at one or multiple coordinates defined by a vector or a list of coordinates
+        or a polygon
+
+        :param xy : list of coordinates or vector
+        :param which : which results to plot -- see Extractable_results Enum
+        :param toshow : show the plot
+        :param figax : tuple of matplotlib figure and axis
+        :param for_steps : tuple of start, end and step -- 0-based -- default is all steps (0,-1,1)
+
+        """
+
+        assert which in Extractable_results, 'Expected a valid Extractable_results'
+        assert x_axis in ['time', 'step'], 'Expected "time" or "step" for x_axis'
+
+        (times, steps), vals = self.get_values_xyorpoly_series(xy, which, for_steps)
+
+        legend = xy.myname if isinstance(xy, vector) else _('Selected nodes')
+
+        x_label = _('Time [s]') if x_axis == 'time' else _('Step [-]')
+
+        if isinstance(figax, Matplotlib_Figure):
+            fig, ax = figax.get_figax()
+
+            if x_axis == 'time':
+                figax.violinplot(vals)
+
+            elif x_axis == 'step':
+                figax.violinplot(vals)
+
+            figax.cur_ax.set_xlabel(x_label)
+            figax.cur_ax.set_ylabel(which.value[0])
+
+        else:
+            if figax is None:
+                fig, ax = plt.subplots()
+            else:
+                fig, ax = figax
+
+            if x_axis == 'time':
+                ax.violinplot(vals)
+            elif x_axis == 'step':
+                ax.violinplot(vals)
+
+            ax.set_xlabel(x_label)
+            ax.set_ylabel(which.value[0])
+
+            fig.tight_layout()
+
+            if toshow:
+                fig.show()
+
+        return fig,ax
+
+    def export_some_values_to_csv(self, xy:Union[list[float], vector],
+                                  which:Extractable_results,
+                                  filename: str | Path,
+                                  for_steps:tuple[int] | list[int] = (0,-1,1),
+                                  erase_if_exists:bool = True,
+                                  only_stats:bool = True):
+        """ Export some results at one or multiple coordinates defined by a vector or a list of coordinates
+        or a polygon as CSV file
+        """
+
+        assert which in Extractable_results, 'Expected a valid Extractable_results'
+
+        filename = Path(filename)
+        filename = filename.with_suffix('.csv')
+
+        if erase_if_exists and filename.exists():
+            filename.unlink()
+
+        (times, steps), vals = self.get_values_xyorpoly_series(xy, which, for_steps)
+
+        mean= []
+        median = []
+        min = []
+        max = []
+        for curvals in vals:
+            curvals:np.ndarray
+            mean.append(curvals.mean())
+            median.append(np.median(curvals))
+            min.append(curvals.min())
+            max.append(curvals.max())
+
+        with open(filename.with_stem(filename.stem + '_stats'), 'a') as f:
+            if isinstance(xy, list):
+                f.write(_('Selected nodes') + '\n')
+                f.write('X [m]\tY [m]'+ '\n')
+                for cur in xy:
+                    f.write(f'{cur[0]}\t{cur[1]}\n')
+
+                f.write('\n\n')
+
+            f.write(f'{which.value[0]}\n')
+
+            columns = [_('Time [s]'), _('Step [-]'), _('Average'), _('Median'), _('Minimum'), _('Maximum')]
+            f.write('\t'.join(columns) + '\n')
+
+            for i in range(len(times)):
+                f.write(f'{times[i]}\t{steps[i]}\t{mean[i]}\t{median[i]}\t{min[i]}\t{max[i]}\n')
+
+        if not only_stats:
+
+            with open(filename, 'a') as f:
+                if isinstance(xy, list):
+                    f.write(_('Selected nodes'))
+                    f.write('X [m]\tY [m]')
+                    for cur in xy:
+                        f.write(f'{cur[0]}\t{cur[1]}')
+
+                    f.write('\n')
+
+                f.write(f'Time [s]\tStep [-]\t{which.value[0]}\n')
+
+                for i in range(len(times)):
+                    f.write(f'{times[i]}\t{steps[i]}\t{vals[i]}\n')
+
+        return True
+
+    def get_values_from_xy(self, x:float, y:float, aswolf:bool = True, integrate_q:bool = False):
+        """
+        Retrouve les valeurs sur base de la coordonnée (x,y).
+
+        Les valeurs retournées sont (h,qx,qy,vx,vy,vabs,fr,h+top,top), (i+1,j+1,curblock.idx+1)
+
+        Si aucun résultat n'existe à l'emplacement souhaité, les valeurs sont (-1,-1,-1,-1,-1,-1,-1),('-','-','-')
+
+        Le test de validité est basé sur la valeur de la hauteur d'eau strictement positive et
+        topographie positive et non égale à 99999.
+
+        :param x : coordonnée x
+        :param y : coordonnée y
+        :param aswolf : (optional) si True alors ajoute 1 à i et j pour se retrouver en numérotation VB6/Fortran
+        :param integrate_q : (optional) si True alors intègre le débit sur la maille (multiplie par la taille de maille perpendiculaire au sens du débit)
+
+        :return : tuple of values and indices
         """
         h=-1
         qx=-1
@@ -3985,12 +4444,12 @@ class Wolfresults_2D(Element_To_Draw):
             qx = curblock.qx.array[i,j]
             qy = curblock.qy.array[i,j]
 
-            exists = top>0.
+            exists = top > 0. and top != 99999.
 
             if(h>0.):
                 vx = qx/h
                 vy = qy/h
-                vabs=(vx**2.+vy**2.)**.5
+                vabs=(vx**2. + vy**2.)**.5
                 fr = vabs/(9.81*h)**.5
                 exists=True
 
@@ -4043,6 +4502,10 @@ class Wolfresults_2D(Element_To_Draw):
     def get_value(self, x:float, y:float, nullvalue=-1):
         """
         Return the value of the current array at (X,Y) position
+
+        :param x: x coordinate
+        :param y: y coordinate
+        :param nullvalue: value to return if no value is found
         """
         h=-1
         exists=False

{wolfhece-2.1.118.dist-info → wolfhece-2.1.120.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: wolfhece
-Version: 2.1.118
+Version: 2.1.120
 Author-email: Pierre Archambeau <pierre.archambeau@uliege.be>
 License: Copyright (c) 2024 University of Liege. All rights reserved.
 Project-URL: Homepage, https://uee.uliege.be/hece