wolfhece 2.0.44__py3-none-any.whl → 2.0.46__py3-none-any.whl

wolfhece/PyCrosssections.py

@@ -1173,32 +1173,33 @@ class profile(vector):
 
         return copied_profile
 
-    def color_active_profile(self, width: float = 3., color: list = [255, 0, 0]):
+    def color_active_profile(self, width: float = 3., color: list = [255, 0, 0], plot_opengl = True):
         """
         This method colors and thickens the active profile
         (default width : 3, default color: red).
         """
         self.myprop.width = width
         self.myprop.color = getIfromRGB(color)
+        if plot_opengl:
+            self.parentzone.plot(True) # FIXME (Parent zone)
 
-        self.parentzone.plot(True)
-
-    def highlightning(self, width: float = 3., color: list = [255, 0, 0]):
+    def highlightning(self, width: float = 3., color: list = [255, 0, 0] , plot_opengl = True):
         """Alias for color_active_profile"""
         self.color_active_profile(width, color)
 
-    def uncolor_active_profile(self):
+    def uncolor_active_profile(self, plot_opengl = True):
         """
         This method resets the width and the color of the active profile to 1 and black.
         """
         self.myprop.width = 1
         self.myprop.color = getIfromRGB([0, 0, 0])
 
-        self.parentzone.plot(True)
+        if plot_opengl:
+            self.parentzone.plot(True)
 
-    def withdrawing(self):
+    def withdrawing(self , plot_opengl = True):
         """Alias for uncolor_active_profile"""
-        self.uncolor_active_profile()
+        self.uncolor_active_profile(plot_opengl)
 
     def ManningStrickler_profile(self, slope: float =1.e-3, nManning: float =0., KStrickler: float=0.):
         """

wolfhece/PyDraw.py

@@ -1178,7 +1178,7 @@ class WolfMapViewer(wx.Frame):
         if wx.TheClipboard.Open():
             self.Paint()
 
-            if self.canvas.SetCurrent(self.context):
+            if self.SetCurrentContext():
 
                 # Récupération  du buffer OpenGL
                 glPixelStorei(GL_PACK_ALIGNMENT, 1)
@@ -1341,7 +1341,7 @@ class WolfMapViewer(wx.Frame):
                 myax.clear()
 
 
-        if self.canvas.SetCurrent(self.context):
+        if self.SetCurrentContext():
             glPixelStorei(GL_PACK_ALIGNMENT, 1)
             data = glReadPixels(0,0,self.canvaswidth, self.canvasheight, GL_RGBA,GL_UNSIGNED_BYTE)
             myimage: Image.Image
@@ -1547,7 +1547,7 @@ class WolfMapViewer(wx.Frame):
 
         self.Paint()
 
-        if self.canvas.SetCurrent(self.context):
+        if self.SetCurrentContext():
             glPixelStorei(GL_PACK_ALIGNMENT, 1)
             data = glReadPixels(0, 0, self.canvaswidth, self.canvasheight, GL_RGBA, GL_UNSIGNED_BYTE)
             myimage: Image.Image
@@ -1578,7 +1578,7 @@ class WolfMapViewer(wx.Frame):
             fn = dlg.GetPath()
             dlg.Destroy()
 
-        if self.canvas.SetCurrent(self.context):
+        if self.SetCurrentContext():
             glPixelStorei(GL_PACK_ALIGNMENT, 1)
             data = glReadPixels(0, 0, self.canvaswidth, self.canvasheight, GL_RGBA, GL_UNSIGNED_BYTE)
             myimage: Image.Image
@@ -4739,7 +4739,7 @@ class WolfMapViewer(wx.Frame):
 
     def thread_update_blender(self):
         print("Update blender")
-        if self.canvas.SetCurrent(self.context):
+        if self.SetCurrentContext():
             self.update_blender_sculpting()
             t = threading.Timer(10.0, self.thread_update_blender)
             t.start()
@@ -5961,7 +5961,7 @@ class WolfMapViewer(wx.Frame):
         """
         return self.active_profile
 
-    def plot_cs(self, x:float, y:float):
+    def plot_cross(self, x:float, y:float):
 
         # Search for cross sections (List of profiles)
         if self.active_cs is None:
@@ -6059,8 +6059,7 @@ class WolfMapViewer(wx.Frame):
 
         # Profile plots
         elif self.action == 'Plot cross section':
-
-            self.plot_cs(x, y)
+            self.plot_cross(x, y)
 
         elif self.action == 'Set 1D profile':
             if self.active_cs is None:
@@ -7649,7 +7648,7 @@ class WolfMapViewer(wx.Frame):
     def get_MVP_Viewport_matrix(self):
         """ Get the modelview projection matrix """
 
-        if self.canvas.SetCurrent(self.context):
+        if self.SetCurrentContext():
             modelview = glGetFloatv(GL_MODELVIEW_MATRIX)
             projection = glGetFloatv(GL_PROJECTION_MATRIX)
             viewport = glGetIntegerv(GL_VIEWPORT)
@@ -7659,6 +7658,14 @@ class WolfMapViewer(wx.Frame):
 
             return None, None, None
 
+    def SetCurrentContext(self):
+        """ Set the current OGL context if exists otherwise return False """
+
+        if self.context is None:
+            return False
+
+        return self.canvas.SetCurrent(self.context)
+
     def Paint(self):
 
         if self.currently_readresults:
@@ -7673,7 +7680,7 @@ class WolfMapViewer(wx.Frame):
         self.xmax = self.mousex + self.width / 2.
         self.ymax = self.mousey + self.height / 2.
 
-        if self.canvas.SetCurrent(self.context):
+        if self.SetCurrentContext():
 
             bkg_color = self.bkg_color
 

wolfhece/PyVertexvectors.py

@@ -317,27 +317,30 @@ class Triangulation(Element_To_Draw):
     def plot(self, sx=None, sy=None, xmin=None, ymin=None, xmax=None, ymax=None, size=None ):
 
         if self.id_list == -99999:
-            self.id_list = glGenLists(1)
+            try:
+                self.id_list = glGenLists(1)
 
-            glNewList(self.id_list, GL_COMPILE)
+                glNewList(self.id_list, GL_COMPILE)
 
-            glPolygonMode(GL_FRONT_AND_BACK,GL_LINE)
+                glPolygonMode(GL_FRONT_AND_BACK,GL_LINE)
 
-            for curtri in self.tri:
-                glBegin(GL_LINE_STRIP)
+                for curtri in self.tri:
+                    glBegin(GL_LINE_STRIP)
 
-                glColor3ub(int(0),int(0),int(0))
+                    glColor3ub(int(0),int(0),int(0))
 
-                glVertex2d(self.pts[curtri[0]][0], self.pts[curtri[0]][1])
-                glVertex2d(self.pts[curtri[1]][0], self.pts[curtri[1]][1])
-                glVertex2d(self.pts[curtri[2]][0], self.pts[curtri[2]][1])
-                glVertex2d(self.pts[curtri[0]][0], self.pts[curtri[0]][1])
+                    glVertex2d(self.pts[curtri[0]][0], self.pts[curtri[0]][1])
+                    glVertex2d(self.pts[curtri[1]][0], self.pts[curtri[1]][1])
+                    glVertex2d(self.pts[curtri[2]][0], self.pts[curtri[2]][1])
+                    glVertex2d(self.pts[curtri[0]][0], self.pts[curtri[0]][1])
 
-                glEnd()
+                    glEnd()
 
-            glPolygonMode(GL_FRONT_AND_BACK,GL_LINE)
+                glPolygonMode(GL_FRONT_AND_BACK,GL_LINE)
 
-            glEndList()
+                glEndList()
+            except:
+                logging.warning('Problem with OpenGL plot - Triangulation.plot')
         else:
             glCallList(self.id_list)
 
@@ -519,7 +522,7 @@ class vectorproperties:
 
         if len(linesextra)>4:
             self.attachedimage = Path(linesextra[4])
-            self.imagevisible = linesextra[5]
+            self.imagevisible = linesextra[5].lower() == 'true'
 
     def load_extra(self, lines:list[str]) -> int:
         """ Load extra properties from lines """
@@ -1539,9 +1542,15 @@ class vector:
             logging.warning(_('No mapviewer available for image plot'))
             return
 
-        if self.myprop.imagevisible and self.myprop.textureimage is not None:
+        if self.myprop.imagevisible:
+            
+            if self.myprop.textureimage is None:
+                self.myprop.load_unload_image()
 
-            self.myprop.textureimage.paint()
+            if self.myprop.textureimage is not None:
+                self.myprop.textureimage.paint()
+            else:
+                logging.warning(_('No image texture available for plot'))
 
     def _get_textfont(self):
         """ Retunr a 'Text_Infos' instance for the legend """
@@ -2434,18 +2443,21 @@ class zone:
         :param prep: True = préparation des listes OpenGL ; False = affichage direct
         """
         if prep:
-            if self.idgllist==-99999:
-                self.idgllist = glGenLists(1)
+            try:
+                if self.idgllist==-99999:
+                    self.idgllist = glGenLists(1)
 
-            self.has_legend = False
-            self.has_image  = False
+                self.has_legend = False
+                self.has_image  = False
 
-            glNewList(self.idgllist,GL_COMPILE)
-            for curvect in self.myvectors:
-                curvect.plot()
-                self.has_legend |= curvect.myprop.legendvisible
-                self.has_image  |= curvect.myprop.imagevisible
-            glEndList()
+                glNewList(self.idgllist,GL_COMPILE)
+                for curvect in self.myvectors:
+                    curvect.plot()
+                    self.has_legend |= curvect.myprop.legendvisible
+                    self.has_image  |= curvect.myprop.imagevisible
+                glEndList()
+            except:
+                logging.error(_('OpenGL error in zone.plot'))
         else:
             if self.idgllist!=-99999:
                 glCallList(self.idgllist)
@@ -3794,7 +3806,7 @@ class Zones(wx.Frame, Element_To_Draw):
             if find_minmax:
                 self.find_minmax(True)
 
-        if plotted:
+        if plotted and self.has_OGLContext:
             self.prep_listogl()
 
     @property

wolfhece/apps/version.py

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

wolfhece/drawing_obj.py

@@ -108,3 +108,13 @@ class Element_To_Draw:
         self.ymax=0.    # spatial extension - upper right corner Y
 
         pass
+
+    @property
+    def has_OGLContext(self):
+        """
+        Test if the object has a canvas
+        """
+        if self.mapviewer is None:
+            return False
+        
+        return self.mapviewer.SetCurrentContext()

wolfhece/hydrology/Catchment.py

@@ -55,6 +55,10 @@ class Catchment:
     subBasinCloud:cloud_vertices                                            # cloud of points containing the true coordinates (used in simulation) of all subbasin outlets
     iP_Cloud:cloud_vertices                                                 # cloud of points containing the given coordinates (given in param files) of all subbasin outlets
 
+    subBasinDict:dict[int:SubBasin]
+
+    catchmentDict:dict[Union[str, int], Union[SubBasin, RetentionBasin]]    # dictionnary containing all the elements of the catchment
+    subBasinDict:dict[int, SubBasin]                                        # dictionnary containing all the subbasins
 
     def __init__(self, _name, _workingDir, _plotAllSub, _plotNothing, _initWithResults=True, _catchmentFileName="", _rbFileName="", _tz=0, version=cst.VERSION_WOLFHYDRO):
         "This is the constructor of the class Catchment in which all the caractertics and the network of sub-basins will be created"
@@ -1118,8 +1122,10 @@ class Catchment:
             excelData = np.zeros((len(self.time),iIndex+nbInlets))
             sheetName = curRB.name
             excelData[:,0] = curRB.time
-            excelData[:,1] = curRB.get_outFlow_noDelay()
-            excelData[:,2] = curRB.get_inlets_noDelay(unit="m3/s")
+            excelData[:,1] = curRB.get_outFlow(unit="m3/s")
+            # excelData[:,2] = curRB.get_inlets_noDelay(unit="m3/s")
+            excelData[:,2] = curRB.get_inlets(unit="m3/s") + curRB.get_direct_insideRB_inlets(unit="m3/s")
+
             i = iIndex
             for iInlet in curRB.intletsObj:
                 curIn = curRB.intletsObj[iInlet]
@@ -1963,9 +1969,9 @@ class Catchment:
             lastLevel = len(self.topologyDict)
             prefix = "Level "
             nameSub = list(self.topologyDict[prefix+str(lastLevel)].items())[0][0]
-            myArray[:,1] = self.topologyDict[prefix+str(lastLevel)][nameSub].get_outFlow_noDelay(unit='mm/h')
+            myArray[:,1] = self.topologyDict[prefix+str(lastLevel)][nameSub].evaluate_objective_function(unit='mm/h')
         else:
-            myArray[:,1] = self.catchmentDict[self.junctionOut].get_outFlow_noDelay(unit='mm/h')
+            myArray[:,1] = self.catchmentDict[self.junctionOut].evaluate_objective_function(unit='mm/h')
 
 
         # pointerData = myData.ctypes.data_as(ct.POINTER(ct.c_double))
@@ -2054,7 +2060,8 @@ class Catchment:
             if blockKey is not None:
                 self.catchmentDict[blockKey].alreadyUsed = True
 
-        self.myEffSubBasins, self.myEffSortSubBasins = self.catchmentDict[junctionName].activate(effSubs=[], effSubsSort=[], mask=mask, onlyItself=onlyItself)
+        self.myEffSubBasins, self.myEffSortSubBasins = self.catchmentDict[junctionName].activate(
+            effSubs=[], effSubsSort=[], mask=mask, onlyItself=onlyItself)
 
         self.write_eff_subBasin()
 
@@ -2204,6 +2211,24 @@ class Catchment:
 
 
         return timeDelays
+    
+
+    def get_timeDelays_inlets(self, ref:str = "") -> dict[str, float]:
+        
+        
+        if(ref==""):
+            junctionKey = self.junctionOut
+        else:
+            junctionKey = self.get_key_catchmentDict(name=ref)
+            if junctionKey is None:
+                logging.error("ERROR : Wrong reference to extract timeDelay !")
+                return
+        
+        junctionKey = self.junctionOut
+        refObj = self.catchmentDict[junctionKey]
+        time_delays_inlets = refObj.get_timeDelays_inlets()
+
+        return time_delays_inlets
 
 
     ## Procedure that force all SubBasins to write their timeDelays and all upstream elements
@@ -2416,6 +2441,305 @@ class Catchment:
         if self.charact_watrshd.to_update_times:
             self.charact_watrshd.update_times(self.time_wolf_array)
 
+    
+    def get_all_x_production(self, selection_by_iD: list = [], to_save:bool=True, to_plot:bool=False) -> dict:
+        """
+        Retrieves the x production values for all sub-basins or a specific selection of sub-basins.
+
+        Args:
+            selection_by_iD (list, optional): A list of sub-basin IDs to retrieve x production values for. 
+                                              If empty, retrieves x production values for all sub-basins. 
+                                              Defaults to [].
+
+        Returns:
+            dict: A dictionary containing the sub-basin names or IDs as keys and their corresponding x production values as values.
+        """
+
+        all_x = {}
+
+        if selection_by_iD == []:
+            for iBasin in range(1, len(self.subBasinDict) + 1):
+                curBasin: SubBasin = self.subBasinDict[iBasin]
+                all_x[curBasin.name] = curBasin.collect_x_from_production()
+        else:
+            for curID in selection_by_iD:
+                cur_key = self.get_key_catchmentDict(curID)
+                curBasin: SubBasin = self.catchmentDict[cur_key]
+                all_x[curID] = curBasin.collect_x_from_production()
+        
+        if to_save:
+            rd.write_excel_from_dict(all_x, path=self.workingDir, fileName="PostProcess/all_x.xlsx", time=self.time)
+
+        return all_x
+    
+
+    def get_all_fractions(self, plt_dict:dict[str:np.array]={},selection_by_iD: list = [], 
+                          to_save:bool=True, to_plot:bool=False,
+                          summary:str=None, summary_interval:list[datetime.datetime]=None, 
+                          add_info:dict[dict[str,float]]={}) -> dict:
+        """
+        Retrieves the physical flux fractions values for all sub-basins or a specific selection of sub-basins.
+
+        Args:
+            selection_by_iD (list, optional): A list of sub-basin IDs to retrieve fractions values for. 
+                                              If empty, retrieves fractions values for all sub-basins. 
+                                              Defaults to [].
+
+        Returns:
+            dict: A dictionary containing the sub-basin names or IDs as keys and their corresponding fractions values as values.
+        """
+
+        all_fractions = {}
+
+        if selection_by_iD == []:
+            all_fractions = {curBasin.name: curBasin.collect_fractions() for curBasin in self.subBasinDict.values()}
+
+        else:
+            for curID in selection_by_iD:
+                cur_key = self.get_key_catchmentDict(curID)
+                curBasin: SubBasin = self.catchmentDict[cur_key]
+                all_fractions[curID] = curBasin.collect_fractions()
+
+        if summary is not None:
+            summary_fractions = {}
+            summary_dict = {}
+            if selection_by_iD == []:
+                summary_fractions = {curBasin.name: curBasin.get_summary_fractions(summary=summary, interval=summary_interval) 
+                                     for curBasin in self.subBasinDict.values()}
+            else:
+                for curID in selection_by_iD:
+                    cur_key = self.get_key_catchmentDict(curID)
+                    curBasin: SubBasin = self.catchmentDict[cur_key]
+                    summary_fractions[curID] = curBasin.get_summary_fractions(summary=summary, interval=summary_interval)
+
+            summary_dict["Stations"] = [cur_name for cur_name in summary_fractions]
+            # Get columns names and remove all duplicates with set
+            all_columns = list(set(cur_key for cur_dict in summary_fractions.values() for cur_key in cur_dict.keys()))
+
+            for cur_dict in summary_fractions.values():
+                for cur_key in all_columns:
+                    if cur_key not in summary_dict:
+                        summary_dict[cur_key] = []
+                    if not cur_key in cur_dict:
+                        summary_dict[cur_key].append(np.nan)
+                    else:
+                        summary_dict[cur_key].append(cur_dict[cur_key])
+
+            if add_info!={}:
+                for key_add, add_dict in add_info.items():
+                    summary_dict[key_add] = []
+                    for key in summary_dict["Stations"]:
+                        if key in add_dict:
+                            summary_dict[key_add].append(add_dict[key])
+                        else:
+                            summary_dict[key_add].append(np.nan)
+
+                            
+
+            # summary_dict = {cur_key: [cur_dict[cur_key] for cur_dict in summary_fractions.values() if cur_key in cur_dict] 
+            #                 for cur_dict in summary_fractions.values() for cur_key in cur_dict}
+            # all_fractions["Summary"] = summary_dict
+
+        if to_save:
+            rd.write_excel_from_dict(all_fractions, path=self.workingDir, fileName="PostProcess/all_frac.xlsx", time=self.time, summary=summary_dict)
+
+        if to_plot:
+            self.plot_all_fractions(all_fractions)
+
+        return all_fractions
+        
+
+    def plot_all_fractions(self, all_fractions:dict[str:np.array]={}, selection_by_iD:list=[], to_show:bool=False, writeDir:str="", range_data:list[datetime.datetime]=[]):
+
+        if(writeDir==""):
+            writeDir = os.path.join(self.workingDir, "PostProcess")
+
+        if selection_by_iD == []:
+            for curBasin in self.subBasinDict.values():
+                curBasin.plot_all_fractions(all_fractions=all_fractions, to_show=False, writeDir=writeDir, range_data=range_data)
+        else:
+            for curID in selection_by_iD:
+                cur_key = self.get_key_catchmentDict(curID)
+                curBasin: SubBasin = self.catchmentDict[cur_key]
+                curBasin.plot_all_fractions(to_show=False, writeDir=writeDir, range_data=range_data) 
+
+        if to_show:
+            plt.show()
+
+        return
+
+    def get_all_iv_production(self, selection_by_iD: list = [], to_save:bool=True) -> dict:
+        """
+        Retrieves the x production values for all sub-basins or a specific selection of sub-basins.
+
+        Args:
+            selection_by_iD (list, optional): A list of sub-basin IDs to retrieve x production values for. 
+                                              If empty, retrieves x production values for all sub-basins. 
+                                              Defaults to [].
+
+        Returns:
+            dict: A dictionary containing the sub-basin names or IDs as keys and their corresponding x production values as values.
+        """
+
+        all_iv = {}
+
+        if selection_by_iD == []:
+            for iBasin in range(1, len(self.subBasinDict) + 1):
+                curBasin: SubBasin = self.subBasinDict[iBasin]
+                all_iv[curBasin.name] = curBasin.collect_all_internal_variables()
+        else:
+            for curID in selection_by_iD:
+                cur_key = self.get_key_catchmentDict(curID)
+                curBasin: SubBasin = self.catchmentDict[cur_key]
+                all_iv[curID] = curBasin.collect_all_internal_variables()
+
+        if to_save:
+            rd.write_excel_from_dict(all_iv, path=self.workingDir, fileName="PostProcess/all_iv.xlsx", time=self.time)
+
+        return all_iv
+    
+    
+    def activate_all_internal_variables(self, selection_by_iD: list = [])->dict:
+        """
+        Activates all internal variables for all sub-basins or a specific selection of sub-basins.
+
+        Args:
+            selection_by_iD (list, optional): A list of sub-basin IDs to activate internal variables for. 
+                                              If empty, activates internal variables for all sub-basins. 
+                                              Defaults to [].
+
+        Returns:
+            dict: A dictionary containing the sub-basin names or IDs as keys and their corresponding internal variables as values.
+        """
+
+        if selection_by_iD == []:
+            for iBasin in range(1, len(self.subBasinDict) + 1):
+                curBasin: SubBasin = self.subBasinDict[iBasin]
+                curBasin.activate_all_internal_variables()
+        else:
+            for curID in selection_by_iD:
+                cur_key = self.get_key_catchmentDict(curID)
+                curBasin: SubBasin = self.catchmentDict[cur_key]
+                curBasin.activate_all_internal_variables()
+
+
+    def check_presence_of_iv(self, selection_by_iD: list = []) -> dict:
+        """
+        Checks the presence of internal variables for all sub-basins or a specific selection of sub-basins.
+
+        Args:
+            selection_by_iD (list, optional): A list of sub-basin IDs to check the presence of internal variables for. 
+                                              If empty, checks the presence of internal variables for all sub-basins. 
+                                              Defaults to [].
+
+        Returns:
+            dict: A dictionary containing the sub-basin names or IDs as keys and their corresponding internal variables as values.
+        """
+
+        all_x = {}
+
+        if selection_by_iD == []:
+            for iBasin in range(1, len(self.subBasinDict) + 1):
+                curBasin: SubBasin = self.subBasinDict[iBasin]
+                all_x[curBasin.name] = curBasin.check_presence_of_iv()
+        else:
+            for curID in selection_by_iD:
+                cur_key = self.get_key_catchmentDict(curID)
+                curBasin: SubBasin = self.catchmentDict[cur_key]
+                all_x[curID] = curBasin.check_presence_of_iv()
+
+        return all_x
+    
+
+    def get_all_Qtest(self, selection_by_iD: list = [], nb_atttempts:int=-1) :
+
+        if selection_by_iD == []:
+            q_test = [curBasin.get_all_Qtest(nb_atttempts) for curBasin in self.subBasinDict.values()]
+        else:
+            # for curID in selection_by_iD:
+            #     cur_key = self.get_key_catchmentDict(curID)
+            #     curBasin: SubBasin = self.catchmentDict[cur_key]
+            #     q_test = curBasin.get_all_Qtest(nb_atttempts)
+            q_test = [
+                self.catchmentDict[self.get_key_catchmentDict(curID)].get_all_Qtest(nb_atttempts) 
+                for curID in selection_by_iD ]
+
+        return q_test
+    
+
+    def _get_simulation_intervals(self):
+        """
+        This procedure is getting the simulation intervals of the current module.
+        """
+        
+        nb_interv = self.paramsInput.get_param("Simulation intervals", "Nb", default_value=0)
+        simulation_intervals = []
+        for i in range(1, nb_interv+1):
+            str_di = self.paramsInput.get_param("Simulation intervals", "Date begin "+str(i))
+            di = datetime.datetime.strptime(str_di, cst.DATE_FORMAT_HYDRO).replace(tzinfo=datetime.timezone.utc)
+            str_df = self.paramsInput.get_param("Simulation intervals", "Date end "+str(i))
+            df = datetime.datetime.strptime(str_df, cst.DATE_FORMAT_HYDRO).replace(tzinfo=datetime.timezone.utc)
+            simulation_intervals.append((di,df))
+
+        return simulation_intervals
+    
+
+    def _set_simulation_intervals(self, simulation_intervals:list[tuple[datetime.datetime,datetime.datetime]]):
+        """
+        This procedure is setting the simulation intervals of the current module.
+        """
+        
+        self.paramsInput.change_param("Simulation intervals", "Nb", len(simulation_intervals))
+        for i, interval in enumerate(simulation_intervals):
+            self.paramsInput.change_param("Simulation intervals", "Date begin "+str(i+1), interval[0].strftime(cst.DATE_FORMAT_HYDRO))
+            self.paramsInput.change_param("Simulation intervals", "Date end "+str(i+1), interval[1].strftime(cst.DATE_FORMAT_HYDRO))
+        
+        self.paramsInput.SavetoFile(None)
+        self.paramsInput.Reload(None)
+
+
+    @property
+    def simulation_intervals(self) ->list[tuple[datetime.datetime,datetime.datetime]]:
+        return self._get_simulation_intervals()
+    
+
+    @simulation_intervals.setter
+    def simulation_intervals(self, value:list[tuple[datetime.datetime,datetime.datetime]]):
+        self._set_simulation_intervals(value)
+
+
+    def _get_temporal_parameters(self) ->tuple[datetime.datetime, datetime.datetime]:
+        """
+        This procedure is getting the temporal parameters of the current module.
+        """
+        
+        return (self.dateBegin, self.dateEnd)
+    
+    
+    def _set_temporal_parameters(self, simulation_intervals:tuple[datetime.datetime,datetime.datetime]):
+        """
+        This procedure is setting the temporal parameters of the current module.
+        """
+        
+        self.dateBegin = simulation_intervals[0]
+        self.dateEnd = simulation_intervals[1]
+
+        self.paramsInput.change_param("Temporal Parameters", "Start date time", self.dateBegin.strftime(cst.DATE_FORMAT_HYDRO))
+        self.paramsInput.change_param("Temporal Parameters", "End date time", self.dateEnd.strftime(cst.DATE_FORMAT_HYDRO))
+        
+        self.paramsInput.SavetoFile(None)
+        self.paramsInput.Reload(None)
+
+    
+    @property
+    def temporal_parameters(self) ->tuple[datetime.datetime, datetime.datetime]:
+        return self._get_temporal_parameters()
+    
+
+    @temporal_parameters.setter
+    def temporal_parameters(self, value:tuple[datetime.datetime,datetime.datetime]):
+        self._set_temporal_parameters(value)
+
 
     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