wolfhece 1.8.7__py3-none-any.whl → 1.8.9__py3-none-any.whl

wolfhece/GraphNotebook.py

@@ -5,6 +5,8 @@ import wx.lib.agw.aui as aui
 from shapely.geometry import LineString,Point
 from matplotlib import figure as mplfig
 import matplotlib.pyplot as plt
+from matplotlib.axes import Axes
+from matplotlib.figure import Figure
 from matplotlib.backends.backend_wxagg import FigureCanvasWxAgg as FigureCanvas, NavigationToolbar2WxAgg as NavigationToolbar
 import logging
 
@@ -54,7 +56,7 @@ class PlotPanel(wx.Panel):
 
             self.SetSizer(self.sizer)                                    #application du sizer
 
-    def add_ax(self, ax3d=False):
+    def add_ax(self, ax3d=False) -> Axes:
         if ax3d:
             if self.myax is None:
                 self.myax = self.figure.add_subplot(projection='3d')
@@ -63,7 +65,7 @@ class PlotPanel(wx.Panel):
                 self.myax = self.figure.add_subplot()
         return self.myax
 
-    def get_fig_ax(self, ax3d=False):
+    def get_fig_ax(self, ax3d=False) -> tuple[Figure, Axes]:
 
         if self.myax is None:
             self.myax = self.add_ax(ax3d)
@@ -653,7 +655,7 @@ class PlotNotebook(wx.Panel):
             except:
                 pass
 
-    def add(self, name="plot",which=""):
+    def add(self, name="plot",which="") -> PlotPanel:
         """
         Ajout d'un onglet au notebook
         L'onglet contient une Figure Matplotlib

wolfhece/PyDraw.py

@@ -3091,6 +3091,13 @@ class WolfMapViewer(wx.Frame):
 
     def export_results_as(self,which='geotiff'):
 
+        """
+        Export des résultats WOLF2D vers le format GeoTiff
+        On attend que les matrices ".hbin" aient été chargées dans l'interface
+
+        TODO : Modifier la routine pour prendre les classe de résultats 2D
+        """
+
         dlg = wx.DirDialog(self,_('Choose output directory'),style = wx.DD_DIR_MUST_EXIST)
         ret=dlg.ShowModal()
 
@@ -3107,14 +3114,14 @@ class WolfMapViewer(wx.Frame):
             for curarray in self.myarrays:
                 if curarray.plotted:
 
-                    fn = curarray.filename[:-4]
-                    top = WolfArray(fn+'topini_fine')
+                    fn = os.path.splitext(curarray.filename)[0] #curarray.filename[:-4]
+                    top = WolfArray(fn+'.topini_fine')
                     top.array.mask = curarray.array.mask
                     top.array.data[np.where(top.array.mask)] = 0.
-                    qx = WolfArray(fn+'qxbin')
+                    qx = WolfArray(fn+'.qxbin')
                     qx.array.mask = curarray.array.mask
                     qx.array.data[np.where(qx.array.mask)] = 0.
-                    qy = WolfArray(fn+'qybin')
+                    qy = WolfArray(fn+'.qybin')
                     qy.array.mask = curarray.array.mask
                     qy.array.data[np.where(qy.array.mask)] = 0.
 
@@ -3122,7 +3129,7 @@ class WolfMapViewer(wx.Frame):
                     vnorm=qnorm/curarray
                     froude=vnorm/(curarray*9.81)**.5
 
-                    frott = WolfArray(fn+'frot')
+                    frott = WolfArray(fn+'.frot')
 
                     def compute_critdiam(h:WolfArray,qnorm:WolfArray,n:WolfArray):
 
@@ -3138,7 +3145,7 @@ class WolfMapViewer(wx.Frame):
 
                         return diamcrit_shields,diamcrit_izbach
 
-                    shields,izbach = compute_critdiam(curarray,qx,qy,frott)
+                    shields,izbach = compute_critdiam(curarray,qnorm,frott)
 
                     myarrays=[top,curarray,qx,qy,vnorm,froude,shields,izbach]
                     mynames=['Z [mDNG]',

wolfhece/PyVertex.py

@@ -14,6 +14,7 @@ from os.path import exists
 import wx
 import re
 import logging
+from scipy.spatial import KDTree
 
 from .PyParams import Wolf_Param
 from .PyTranslate import _
@@ -370,7 +371,7 @@ class cloud_vertices(Element_To_Draw):
 
     Number os values = nb - (2 or 3) depending if Z coordinate exists
 
-    Date are stored in Python dictionnary :
+    Data are stored in Python dictionnary :
       - ['vertex'] == XY or XYZ
     Each value is accessible through its headname as key :
       - ['headname1'] == value with headname1
@@ -389,6 +390,7 @@ class cloud_vertices(Element_To_Draw):
     zbounds: tuple
 
     myprop: cloudproperties
+    mytree : KDTree
 
     def __init__(self, fname: str = '', fromxls: str = '', header: bool = False, toload=True, idx: str = '', plotted: bool = True, mapviewer=None, need_for_wx: bool = False) -> None:
         super().__init__(idx, plotted, mapviewer, need_for_wx)
@@ -410,6 +412,8 @@ class cloud_vertices(Element_To_Draw):
 
         self.myprop = cloudproperties(parent=self)
 
+        self.mytree = None
+
         if fname != '':
             if toload:
                 if fname[-4:].lower()=='.dxf':
@@ -417,7 +421,37 @@ class cloud_vertices(Element_To_Draw):
                 else:
                     self.readfile(fname, header)
 
+    def __getitem__(self, key):
+
+        return self.myvertices[key]
+
+    def create_kdtree(self):
+        """
+        Set a Scipy KDTree structure based on a copy of the vertices
+        """
+        xyz = self.get_xyz()
+        self.mytree = KDTree(xyz)
+
+    def find_nearest(self, xy:np.ndarray, nb:int =1):
+        """
+        Find nearest neighbors from Scipy KDTree structure based on a copy of the vertices
+
+        Retrun :
+         - list of distances
+         - list of "Wolfvertex"
+         - list of elements stored in self.myvertices
+        """
+        keys = self.myvertices.keys()
+        if self.mytree is None:
+            self.create_kdtree()
+
+        dist, ii = self.mytree.query(xy, k=nb)
+        return dist, [self.myvertices[keys[curi]]['vertex'] for curi in ii], [self.myvertices[keys[curi]] for curi in ii]
+
     def init_from_nparray(self, array):
+        """
+        Fill-in from nparray -- shape (n,3)
+        """
         k = 0
         for curv in array:
             mv = wolfvertex(curv[0], curv[1], curv[2])
@@ -710,19 +744,31 @@ class cloud_vertices(Element_To_Draw):
             self.zmin = 1.e300
             self.zmax = -1.e300
 
-            for item in self.myvertices:
-                curvert = self.myvertices[item]['vertex']
-
-                x = curvert.x
-                y = curvert.y
-                z = curvert.z
-
-                self.xmin = min(x, self.xmin)
-                self.xmax = max(x, self.xmax)
-                self.ymin = min(y, self.ymin)
-                self.ymax = max(y, self.ymax)
-                self.zmin = min(z, self.zmin)
-                self.zmax = max(z, self.zmax)
+            # if no vertice or file not present -> return
+            if len(self.myvertices) == 0 : 
+                return
+            
+            xyz = self.get_xyz()
+            self.xmin = np.min(xyz[:,0])
+            self.xmax = np.max(xyz[:,0])
+            self.ymin = np.min(xyz[:,1])
+            self.ymax = np.max(xyz[:,1])
+            self.zmin = np.min(xyz[:,2])
+            self.zmax = np.max(xyz[:,2])
+
+            # for item in self.myvertices:
+            #     curvert = self.myvertices[item]['vertex']
+
+            #     x = curvert.x
+            #     y = curvert.y
+            #     z = curvert.z
+
+            #     self.xmin = min(x, self.xmin)
+            #     self.xmax = max(x, self.xmax)
+            #     self.ymin = min(y, self.ymin)
+            #     self.ymax = max(y, self.ymax)
+            #     self.zmin = min(z, self.zmin)
+            #     self.zmax = max(z, self.zmax)
 
             self.xbounds = (self.xmin, self.xmax)
             self.ybounds = (self.ymin, self.ymax)
@@ -730,7 +776,7 @@ class cloud_vertices(Element_To_Draw):
 
             pass
 
-    def get_xyz(self,key='vertex'):
+    def get_xyz(self,key='vertex') -> np.ndarray:
         if self.header:
             if key=='vertex':
                 xyz = [[curvert['vertex'].x, curvert['vertex'].y, curvert['vertex'].z]  for curvert in self.myvertices.values()]

wolfhece/eva/hydrogramme_mono.py

@@ -89,13 +89,18 @@ class Hydro_HSMF():
         self._plot_Q(ax)
         plt.show()
 
-    def _plot_Q(self, ax:plt.Axes, decal=0, label=None, lw=2):
+    def _plot_Q(self, ax:plt.Axes, decal=0, label=None, lw=2, xup_bound=None):
 
         ax.step(list(self.temps+decal)+[self.temps[-1]+decal+1],list(self.hydro)+[0.],where='post',label=label,lw=lw)
         ax.set_xlabel('Temps [h]')
         ax.set_ylabel('Débit [$m^3s^{-1}$]')
-        ax.set_xticks(np.arange(0,self.temps_base+1,1))
-        ax.set_xbound(0,self.temps_base)
+
+        if xup_bound is None:
+            ax.set_xticks(np.arange(0,self.temps_base+1,1))
+            ax.set_xbound(0,self.temps_base)
+        else:
+            ax.set_xticks(np.arange(0,xup_bound+1,1))
+            ax.set_xbound(0,xup_bound)
         ax.grid()
 
     def opt_hydro(self, opti_method = 'brent'):

wolfhece/eva/pyseries.py

@@ -31,6 +31,7 @@ try:
     from .hydrogramme_mono import Hydro_HSMF
 except:
     import bootstrap
+    from joint_models import JointModel
     from mixture_models import SeasonMixtureModel
     from hydrogramme_mono import Hydro_HSMF
 
@@ -346,7 +347,7 @@ class EVA_Serie:
         """
         for curindex in self.nodata.values():
             if len(curindex)>0:
-                self.data[curindex]=np.nan
+                self.data.iloc[curindex]=np.nan
 
     def get_date_max(self, year, seasons=None) -> list():
         """
@@ -387,6 +388,46 @@ class EVA_Serie:
 
         return resevents
 
+    def get_nb_maxevents(self, nbevents:int, seasons=None) -> dict[str, pd.DataFrame]:
+        """Récupère les nbevents lus grands pics de crue"""
+        seasons = sanitize_seasons(seasons)
+
+        max_nb = {}
+
+        for curseason in seasons:
+            maxima = pd.DataFrame({'date':self.maxima[curseason]['date'].copy(),
+                                   'value':self.maxima[curseason]['maxval'].copy()})
+            maxima.set_index('date')
+            maxima.sort_values(['value'], inplace=True)
+
+            max_nb[curseason] = maxima.iloc[-nbevents:]
+
+        return max_nb
+
+    def get_nb_max_hydro(self, nbevents:int, seasons=None) -> dict[str, pd.DataFrame]:
+        """Récupère les nbevents plus grands hydrogrammes de crue"""
+        seasons = sanitize_seasons(seasons)
+
+        ret = {}
+        for curseason in seasons:
+
+            if not 'water_year' in self.maxima[curseason].keys():
+                self.find_maxima(self.hydrological_year)
+            if not 'events' in self.maxima[curseason].keys():
+                self.extract_maxevents()
+
+            dates = self.maxima[curseason]['date']
+            water_year = self.maxima[curseason]['water_year']
+            curdict = self.maxima[curseason]['events']
+
+            hydro = pd.DataFrame({'date':water_year,
+                                  'hydro':[val for val in curdict.values()],
+                                  'max':[val.max() for val in curdict.values()]})
+            hydro.sort_values('max', inplace=True)
+            ret[curseason] = hydro.iloc[-nbevents:]
+
+        return ret
+
     def save_max_events(self, filename, years_bounds:list=None, seasons=None):
         """
         Enregistrement des crues maximales dans un fichier CSV
@@ -455,7 +496,13 @@ class EVA_Serie:
 
         return start_date, end_date
 
-    def _get_max(self, year=None, hydrol=True, season=None, method: typing.Literal['BM', 'POT'] ='BM', threshold=0., r: typing.Union[pd.Timedelta, typing.Any] = "24H"):
+    def _get_max(self,
+                 year=None,
+                 hydrol=True,
+                 season=None,
+                 method: typing.Literal['BM', 'POT'] ='BM',
+                 threshold=0.,
+                 r: typing.Union[pd.Timedelta, typing.Any] = "24H"):
         """
         Find maxima in specific period
         """
@@ -466,7 +513,7 @@ class EVA_Serie:
         if method=='BM':
             if len(df)>0:
                 idx = df.argmax()
-                return [df.index[idx], df[idx]]
+                return [df.index[idx], df.iloc[idx]]
             else:
                 return [None, np.nan]
         elif method =='POT':
@@ -612,7 +659,7 @@ class EVA_Serie:
                 res = stats.gumbel_r.fit(data,method=method)
                 res = dist.fit(data,0.,loc=res[0],scale=res[1],method=method)
             elif dist is stats.weibull_min :
-                # la loi de Weibull étant un cas particulier de la GEV, on initialise les paramétres sur base du fit de la GEV
+                # la loi de Weibull étant un cas particulier de la GEV
                 res = stats.gumbel_r.fit(data,method=method)
                 res = dist.fit(data,0.,loc=res[0],scale=res[1],method=method)
                 res = dist.fit(data,1.,loc=res[0],scale=res[1],method=method)
@@ -1123,16 +1170,101 @@ class EVA_Serie:
             curdict['Weibull'] = np.asarray([weibull(i+1,nb) for i in range(nb)])
             curdict['Filliben'] = np.asarray([filliben(i+1,nb) for i in range(nb)])
 
-    def get_median_event(self, seasons = None)-> dict[str, pd.DataFrame]:
+    def compute_median_event(self, seasons = None, before:int = 1, after:int = 2):
+        """
+        Evaluation de la crue mediane
+        Stockage dans "self.maxima[curseason]['median_event']"
+        """
+        seasons = sanitize_seasons(seasons)
+
+        nbmax=0
+        for curseason in seasons:
+
+            if not 'events' in self.maxima[curseason].keys():
+                self.extract_maxevents(before,after)
+            elif (self.maxima[curseason]['before'] != before) or (self.maxima[curseason]['after'] != after):
+                self.extract_maxevents(before,after)
+
+            curdict = self.maxima[curseason]['events']
+            dates   = self.maxima[curseason]['date']
+
+            all_adims = {}
+            for idx in np.arange((before+after)*24+1, dtype=np.int16):
+                all_adims[idx]=[]
+
+            for idx,(key,curevent) in enumerate(curdict.items()):
+                nb    = len(curevent)
+                nbmax = max(nb,nbmax)
+
+                mymax  = np.max(curevent)
+                values = curevent.copy()/mymax
+
+                if nb != (before+after)*24+1:
+                    x = np.zeros(nb)
+                    for curidx, curdelta in enumerate(values.index):
+                        curhour = int(((curdelta-dates[idx]).days *24)+((curdelta-dates[idx]).seconds)/3600) + before*24
+                        x[curidx] = curhour
+                        all_adims[curhour].append(values[curidx])
+                else:
+                    x = np.arange((before+after)*24+1, dtype=np.int16)
+                    for curidx, curq in enumerate(values):
+                        all_adims[curidx].append(curq)
+
+            time= np.arange((before+after)*24+1, dtype=np.int16)
+            crue_mediane = [np.median(curval) for curval in all_adims.values()]
+            self.maxima[curseason]['median_event'] = pd.DataFrame({'time [hour]':time, 'Discharge[m3s-1]':crue_mediane})
+
+    def get_median_event(self, seasons = None, before=1, after=2)-> dict[str, pd.DataFrame]:
+        """
+        Get median hydrograph
+        """
 
         seasons = sanitize_seasons(seasons)
 
         retdict = {}
         for cur in seasons:
+            # if not 'median_event' in self.maxima[cur].keys():
+            self.compute_median_event(seasons, before, after)
+
             retdict[cur] = self.maxima[cur]['median_event']
 
         return retdict
 
+    def plot_median_event(self,
+                          scale:float,
+                          seasons = None,
+                          before=1,
+                          after=2,
+                          fig:Figure=None,
+                          ax:Axes=None,
+                          color:str='red',
+                          alpha=1.) -> tuple([Figure,Axes]):
+        """
+        Plot median hydrograph scale by constant
+        """
+
+        seasons = sanitize_seasons(seasons)
+
+        if fig is None and ax is None:
+            fig,ax = plt.subplots(len(seasons),1)
+
+        qmedian = self.get_median_event(seasons, before, after)
+
+        k=0
+        for curseason in seasons:
+            if len(seasons)==1:
+                curax=ax
+            else:
+                curax=ax[k]
+
+            x = qmedian[curseason]['time [hour]']
+            crue_mediane = qmedian[curseason]['Discharge[m3s-1]'].copy() * scale
+
+            curax.step(x,crue_mediane,where='post', c=color, alpha=alpha, lw=2, label = "Median")
+
+            k+=1
+
+
     def plot_classified_flowrate_curve(self, fig:Figure=None, ax:Axes=None, label='', textvalues=True, show=False) -> tuple([Figure,Axes]):
 
         if ax is None:
@@ -1435,6 +1567,10 @@ class EVA_Serie:
         else:
             for curseason in seasons:
                 if curseason != 'mixture' and curseason != 'joint':
+
+                    if len(self.maxima.keys())==0:
+                        self.find_maxima()
+
                     if not 'sorted_maxval' in self.maxima[curseason].keys():
                         self.sort_maxima(curseason)
                         self.set_empfreq(curseason)
@@ -1475,6 +1611,8 @@ class EVA_Serie:
         if fig is None and ax is None:
             fig,ax = plt.subplots(len(seasons),1)
 
+        self.compute_median_event(seasons, before, after)
+
         nbmax=0
         k=0
         for curseason in seasons:
@@ -1498,12 +1636,12 @@ class EVA_Serie:
                 locmax = list(locmax[-nbevents:])
 
             all_adims = {}
-            for idx in np.arange((before+after)*24+1, dtype=np.int16): #np.arange(-before*24,after*24+1, dtype=np.int16):
+            for idx in np.arange((before+after)*24+1, dtype=np.int16):
                 all_adims[idx]=[]
 
             for idx,(key,curevent) in enumerate(curdict.items()):
-                nb=len(curevent)
-                nbmax=max(nb,nbmax)
+                nb    = len(curevent)
+                nbmax = max(nb,nbmax)
 
                 mymax = np.max(curevent)
                 if adim:
@@ -1518,7 +1656,7 @@ class EVA_Serie:
                         x[curidx] = curhour
                         all_adims[curhour].append(values[curidx])
                 else:
-                    x = np.arange((before+after)*24+1, dtype=np.int16) #np.arange(-before*24,after*24+1, dtype=np.int16)
+                    x = np.arange((before+after)*24+1, dtype=np.int16)
                     for curidx, curq in enumerate(values):
                         all_adims[curidx].append(curq)
 
@@ -1526,21 +1664,24 @@ class EVA_Serie:
                     curax.step(x,values,where='post',alpha=alpha,c=colors[k], label = dates[idx].strftime("%m/%Y"))
                 elif mymax in locmax:
                     curax.step(x,values,where='post',alpha=alpha,c=colors[k], label = dates[idx].strftime("%m/%Y"))
+                    print(dates[idx].strftime("%m/%Y"), mymax)
 
             if adim:
-                x = np.arange((before+after)*24+1, dtype=np.int16) #np.arange(-before*24,after*24+1, dtype=np.int16)
-                crue_mediane = [np.median(curval) for curval in all_adims.values()]
-                curax.step(x,crue_mediane,where='post',alpha=1., c=colors[k], lw=2, label = "median")
-
-                self.maxima[curseason]['median_event'] = pd.DataFrame({'time [hour]':x, 'Discharge[m3s-1]':crue_mediane})
+                x = self.maxima[curseason]['median_event']['time [hour]']
+                crue_mediane = self.maxima[curseason]['median_event']['Discharge[m3s-1]']
+                curax.step(x,crue_mediane,where='post',alpha=1., c=colors[k], lw=2, label = "Median")
 
             curax.set_xticks(np.arange(0, (before+after)*24+1, 6, dtype=np.int16))
             curax.set_xticklabels(np.arange(0, (before+after)*24+1, 6, dtype=np.int16))
             curax.grid(True)
-            # ax.legend()
+
             curax.set_title('Maxima events - duration : {} - {}'.format(self.duration,curseason))
             curax.set_xlabel('Time [hour]')
-            curax.set_ylabel('Discharge / DisMax [-]')
+
+            if adim:
+                curax.set_ylabel('Discharge / DisMax [-]')
+            else:
+                curax.set_ylabel('Discharge [$m^3s^{-1}$]')
             curax.set_xbound(0,(before+after)*24+1)
             k+=1
 
@@ -1610,7 +1751,7 @@ class EVA_Serie:
 
             x = np.arange((before+after)*24+1, dtype=np.int16)
             crue_mediane = [np.median(curval) for curval in all_adims.values()]
-            curax.step(x,crue_mediane,where='post',alpha=1., c=colors[k], lw=2, label = curseason)
+            curax.step(x,crue_mediane,where='post',alpha=1., c=colors[k], lw=2, label = 'MedianQ {}'.format(curseason))
 
             self.maxima[curseason]['median_event'] = pd.DataFrame({'time [hour]':x, 'Discharge[m3s-1]':crue_mediane})
 
@@ -1916,11 +2057,14 @@ class EVA_Serie:
                         aic  = np.asarray([curdictm[curlaw]['aic'] for curlaw in curdictm.keys()])
                         aicc = np.asarray([curdictm[curlaw]['aicc'] for curlaw in curdictm.keys()])
                         bic  = np.asarray([curdictm[curlaw]['bic'] for curlaw in curdictm.keys()])
-                        rss  = np.asarray([curdictm[curlaw]['rss'] for curlaw in curdictm.keys()])
+                        rss  = np.asarray([curdictm[curlaw]['rss'] for curlaw in curdictm.keys()] )
 
                         labels = np.asarray(list(curdictm.keys()))
 
-                        if (nb_laws>len(aicc)) or (nb_laws is None):
+                        if nb_laws is None:
+                            nb_laws=len(aicc)
+
+                        if nb_laws>len(aicc):
                             nb_laws=len(aicc)
 
                         if sort=='RSS':
@@ -1978,7 +2122,7 @@ class EVA_Serie:
         if show:
             plt.show()
 
-        return fig, ax, list(labels[index_sort])
+        return fig, ax, list(labels[index_sort][:nb_laws])
 
     def summary_max(self, seasons=None):
 
@@ -2232,7 +2376,7 @@ class EVA_Series:
             threshold: float=0.,
             r: typing.Union[pd.Timedelta, typing.Any] = "24H",
             verbose=True,
-            show=False) -> list:
+            show=False) -> dict[str, tuple]:
         """
         Extreme Value Analysis
 
@@ -2410,8 +2554,14 @@ class EVA_Series:
         for curT in return_period:
             dict[curT] = self.get_one_MFSH(rising_time, curT, deltat)
 
-    def plot_msfh(self, label, return_period= [2, 5, 10, 25, 50, 100, 200, 500, 1000],
-                  ref_season='annual', ylim=None, show=False) -> tuple([Figure, Axes, Axes]):
+    def plot_msfh(self,
+                  label,
+                  return_period= [2, 5, 10, 25, 50, 100, 200, 500, 1000],
+                  ref_season='annual',
+                  ylim=None,
+                  before = 1,
+                  after = 3,
+                  show=False) -> tuple([Figure, Axes, Axes]):
         """
         ################
         ## GRAPHIQUES ##
@@ -2422,7 +2572,7 @@ class EVA_Series:
             raise Warning('No hydrogram to plot -- retry')
 
         ref_serie = self.all_series[1]
-        fig, ax = ref_serie.plot_maxevents(ref_season, 1, 4, alpha=.15)
+        fig, ax = ref_serie.plot_maxevents(ref_season, before, after, alpha=.15)
 
         ax2 = ax.twinx()
 
@@ -2430,7 +2580,7 @@ class EVA_Series:
             curhydro:Hydro_HSMF
             curhydro=self.MFSH[label][curT]
 
-            curhydro._plot_Q(ax2, 24 - curhydro.temps_montee, label=str(curT), lw=3)
+            curhydro._plot_Q(ax2, before*24 - curhydro.temps_montee, label=str(curT), lw=3, xup_bound=(before+after)*24)
 
         ax.legend().set_visible(False)
         ax2.legend()
@@ -2443,6 +2593,41 @@ class EVA_Series:
 
         return fig,ax,ax2
 
+    def plot_msfh_mainplot(self,
+                           label,
+                           return_period= [2, 5, 10, 25, 50, 100, 200, 500, 1000],
+                           ref_season='annual',
+                           ylim=None,
+                           before = 1,
+                           after=2,
+                           show=False) -> tuple([Figure, Axes]):
+        """
+        ################
+        ## GRAPHIQUES ##
+        ################
+        """
+
+        if not label in self.MFSH.keys():
+            raise Warning('No hydrogram to plot -- retry')
+
+        fig,ax = plt.subplots(1,1)
+
+        for curT in return_period:
+            curhydro:Hydro_HSMF
+            curhydro=self.MFSH[label][curT]
+
+            curhydro._plot_Q(ax, before*24 - curhydro.temps_montee, label=str(curT), lw=3, xup_bound=(before+after)*24)
+
+        ax.legend()
+
+        if ylim is not None:
+            ax.set_ylim(ylim)
+
+        if show:
+            plt.show()
+
+        return fig,ax
+
     def save_max_event(self,
                        filename:str,
                        years_bounds:list,