wolfhece 2.2.43__py3-none-any.whl → 2.2.45__py3-none-any.whl

wolfhece/Model1D.py

@@ -33,7 +33,8 @@ from matplotlib import animation ,rcParams
 from matplotlib.axes import Axes
 from matplotlib.figure import Figure
 from matplotlib.lines import Line2D
-from matplotlib.ticker import MultipleLocator
+from matplotlib.ticker import MultipleLocator,FuncFormatter
+from PIL import Image
 from shapely.ops import substring, split, LineString, Point
 from subprocess import Popen, PIPE
 from tqdm import tqdm
@@ -47,8 +48,9 @@ from .pylogging import create_wxlogwindow
 from .PyParams import Wolf_Param
 from .PyTranslate import _
 from .PyVertexvectors import Zones, zone, vector, wolfvertex
-from .wolf_array import WolfArray
+from .wolf_array import WolfArray, header_wolf
 from .wolf_vrt import crop_vrt
+from .xyz_file import xyz_scandir
 
 # --- Constants ---
 # __________________
@@ -1576,6 +1578,10 @@ class Creator_1D:
             nby = int(round(y/dy))
         else:
             array1.dy= array2.dy = dx
+            # Added
+            # ----------------
+            dy = dx
+            nby = int(round(y/dy))
 
         if array1.dz == array2.dz:
             dz= array1.dz
@@ -1850,6 +1856,121 @@ class Creator_1D:
             vecz_file = self.initialize_file(save_as,'.vecz')
             new_zones.saveas(vecz_file)
 
+    def wolfarray_from_xyz(self,
+                           xyz_directory: str,
+                           coordinate_origin: tuple,
+                           coordinate_extent: tuple,
+                            dx: float= 1,
+                            dy: float= 1,
+                           save_as: str = '',
+                           nullvalue: float = -99999.,
+                           mask_nullvalue = True) -> WolfArray:
+        """
+        return a WolfArray from a .XYZ file.
+
+        .. notes:: After scanning the directory and concatenating all the the xyz  files into one file,
+        a wolfarry with the given extent is created. All  values are first set  to -99999.
+        Then, the array is filled with the values from the xyz file and mask is placed wherever values are not available.
+
+        :param wyz_directory: computer path to the folder containing the .XYZ files
+        :type wyz_directory: str
+        :param coordinate_origin: Origin of the WolfArray. (x,y) of the lower left corner.
+        :type coordinate_origin: tuple
+        :param coordinate_extent: Extent of the WolfArray. (x,y) of the upper right corner.
+        :type coordinate_extent: tuple
+        :param dx: Cell size in x direction, defaults to 1
+        :type dx: float, optional
+        :param dy: Cell size in y direction, defaults to 1
+        :type dy: float, optional
+        :param save_as: computer path of the file where new WolfArray will be stored, defaults to ''
+        :type save_as: str, optional
+        :return: WolfArray
+
+        """
+
+        header = self.create_header_wolf_array(dx = dx,
+                                               dy = dy,
+                                               originx = coordinate_origin[0],
+                                               originy = coordinate_origin[1],
+                                               extentx = coordinate_extent[0],
+                                               extenty = coordinate_extent[1]
+                                               )
+
+        cropini = [[float(coordinate_origin[0]), float(coordinate_extent[0])],
+                                   [float(coordinate_origin[1]), float(coordinate_extent[1])]]
+
+
+
+        file_xyz = xyz_scandir(xyz_directory, cropini)
+
+        new_array = WolfArray()
+        new_array.init_from_header(header)
+        new_array.nullvalue = nullvalue
+        new_array.array.data[:,:] = nullvalue
+        new_array.fillin_from_xyz(file_xyz)
+        if mask_nullvalue:
+            new_array.mask_data(new_array.nullvalue)
+        if save_as:
+            new_array.write_all(save_as)
+        return new_array
+
+    def create_header_wolf_array(self,
+                    dx: float,
+                    dy: float,
+                    originx: float,
+                    originy: float,
+                    extentx:float = None,
+                    extenty:float = None,
+                    nbx: int = None,
+                    nby: int = None) -> header_wolf:
+        """ Fill and return a header of a wolf_2D array (header_wolf object).
+
+        :param dx: Cell size in x direction
+        :type dx: float
+        :param dy: Cell size in y direction
+        :type dy: float
+        :param originx: x coordinate of the origin of the WolfArray (lower left corner).
+        :type originx: float
+        :param originy: y coordinate of the origin of the WolfArray (lower left corner).
+        :type originy: float
+        :param extentx: x coordinate of the upper right corner, defaults to None
+        :type extentx: float, optional
+        :param extenty: y coordinate of the upper right corner, defaults to None
+        :type extenty: float, optional
+        :param nbx: Number of cells in x direction, defaults to None
+        :type nbx: int, optional
+        :param nby: Number of cells in y direction, defaults to None
+        :type nby: int, optional
+        :return: Header of the WolfArray
+        :rtype: header_wolf
+        """
+        assert isinstance(originx, (float, int)), 'originx should be a float'
+        assert isinstance(originy,( float,int)), 'originy should be a float'
+        assert isinstance(dx, (float,int)), 'dx should be a float'
+        assert isinstance(dy, (float,int)), 'dy should be a float'
+
+        if extentx is not None and extenty is not None:
+            assert isinstance(extentx, (float,int)), 'extentx should be a float'
+            assert isinstance(extenty, (float,int)), 'extenty should be a float'
+            nbx = int((extentx- originx)/dx)
+            nby = int((extenty- originy)/dy)
+
+        if nbx is not None and nby is not None:
+            assert isinstance(nbx, int), 'nbx should be an integer'
+            assert isinstance(nby, int), 'nby should be an integer'
+            nbx = nbx
+            nby = nby
+
+        myhead = header_wolf()
+        myhead.origx = originx
+        myhead.origy = originy
+        myhead.dx = dx
+        myhead.dy = dy
+        myhead.nbx = nbx
+        myhead.nby = nby
+
+        return myhead
+
 
     # --- Cross sections ---
     #_______________________
@@ -1857,7 +1978,7 @@ class Creator_1D:
 
     def save_as_1D_crossections(self,
                                 zones: Zones,
-                                format ='zones',
+                                format ='vecz',
                                 save_as: str='',
                                 return_list = True) -> list[crosssections]: # FIXME list of cross sections
         r"""
@@ -2168,7 +2289,7 @@ class Creator_1D:
         new_zones.add_zone(new_zone)
         new_zone.myvectors = profiles
         new_zones.find_minmax(True)
-        new_crossections = crosssections(new_zones, 'zones')
+        new_crossections = crosssections(new_zones, 'vecz')
         return new_crossections
 
     def extrapolate_extremities(self,
@@ -2416,6 +2537,89 @@ class Creator_1D:
         relations = np.array(all_relations)
         return relations, (zne_id_skeleton - 1)
 
+    def test_presence_section_name(self, section: vector, list_of_names:list[str]):
+        """Check if a section is in a list of names. Return True if it's not.
+
+        :param section: section (profile)
+        :type section: vector
+        :param list_of_names: list of section names to check
+        :type list_of_names: list[str]
+        :return: bool
+        """
+        name = section.myname
+        if isinstance(name, str):
+            if "copy" in name.lower():
+                name = name.split('_')[0]
+        return not name in list_of_names
+
+    def delete_sections_from_cross_sections(self,
+                                            cross_sections: crosssections,
+                                            list_to_delete: list[str],
+                                            save_as = '',
+                                            id_zone: int= 0) -> crosssections:
+        """Delete a list of sections from a cross_sections object based on their names and
+        return a new cross_sections object.
+
+        :param cross_sections: cross sections object
+        :type cross_sections: crosssections
+        :param list_to_delete: list of section names to delete
+        :type list_to_delete: list[str]
+        :param id_zone: index of the zone  from which vectors are selected, defaults to 0
+        :return: crosssections where the sections are deleted.
+        :rtype: crosssections
+        """
+        # 1. Get all sections as vector from cross_sections
+        # all_sections = cross_sections.myzones.deepcopy_zones(add_suffix = False) # add_suffix deepcopy_zones is not needed anymore
+        all_sections = cross_sections.myzones.deepcopy_zones()
+        sections  = all_sections.myzones[id_zone].myvectors
+        # indices_to_delete = []
+        sections_filtered = list(filter(lambda section: self.test_presence_section_name(section, list_to_delete), sections))
+        all_sections.myzones[id_zone].myvectors = sections_filtered
+
+
+        # 3. Updating the zone  of sections
+        all_sections.find_minmax(update=True)
+        # 4. Create a new cross_sections
+        new_cross_sections = crosssections(all_sections, format='vecz')
+        if save_as != '':
+            new_cross_sections.saveas(save_as)
+        # Return the new cross_sections
+        return new_cross_sections
+
+    def select_sections_from_cross_sections(self,
+                                                 cross_sections: crosssections,
+                                                 list_to_select: list[str],
+                                                 save_as:str ='',
+                                                 id_zone: int= 0) -> crosssections:
+        """Select a list of sections from a cross_sections object based on their names and
+        return a new cross_sections object.
+
+        :param cross_sections: cross sections object
+        :type cross_sections: crosssections
+        :param list_to_select: list of section names to select
+        :type list_to_select: list[str]
+        :param id_zone: index of the zone  from which vectors are selected, defaults to 0
+        :return: crosssections where the sections are selected.
+        :rtype: crosssections
+        """
+
+        all_sections =  cross_sections.myzones.myzones[id_zone].myvectors
+        names = [section.myname for section in all_sections]
+        selection = []
+        for name in list_to_select:
+            if name in names:
+                selection.append(all_sections[names.index(name)])
+        zones = Zones()
+        zne = zone(parent = zones)
+        zones.myzones.append(zne)
+        zones.myzones[0].myvectors = selection
+        zones.find_minmax(update=True)
+        new_cross_sections = crosssections(zones, format='vecz')
+        if save_as != '':
+            new_cross_sections.saveas(save_as)
+        return new_cross_sections
+
+
     # --- Graph cross sections ---
     #______________________________
 
@@ -4192,7 +4396,14 @@ class Creator_1D:
                     val1 = prof_indices[0] # FIXME check whether it should start from 0 or from 1
                     val2 = prof_indices[1]
                     # Writing the condition.
-                    cl.write(f'{val1:12d}{sep}{val2:12d}{sep}{loc:12d}{sep}{condition_type:12d}{sep}{condition_value:20.14f}' +'\n')
+                    # cl.write(f'{val1:12d}{sep}{val2:12d}{sep}{loc:12d}{sep}{condition_type:12d}{sep}{condition_value:20.14f}' +'\n')
+
+                    # FIXME testing the location
+                    if loc == 1:
+                        cl.write(f'{np.int32(val1)}{sep}{np.int32(val2)}{sep}{np.int32(loc)}{sep}{np.int32(condition_type)}{sep}{np.float32(condition_value)}{sep}zone, vecteur, amont=1 & aval=-1, type,  valeur' +'\n')
+                    else:
+                        cl.write(f'{np.int32(val1)}{sep}{np.int32(val2)}{sep}{np.int32(loc)}{sep}{np.int32(condition_type)}{sep}{np.float32(condition_value)}' +'\n')
+
                 # Log messages
                 else:
                     if self.wx_exists:
@@ -5991,7 +6202,7 @@ class Creator_1D:
         # check wolfresults_1D update ini file or find another way to update the file.
 
 
-    # --- Outdated methods ---
+    # --- Outdated methods (deprecated) ---
     #_________________________
 
     def __write_batch_file(self,
@@ -6810,6 +7021,7 @@ class Wolfresults_1D:
 
         .. todo:: FIXME Implement a consitency check of the files
         .. to do:: FIXME  Use a multiprocess to speed up the creation of `.gif` files.
+        .. to do: FIXME: find a way to implement an initial time for the simulation
         """
         # Useful properties for other methds
         self.directory = simulation_directory
@@ -6844,6 +7056,11 @@ class Wolfresults_1D:
             elif file.endswith('banks.vecz'):
                 self.bank_file = os.path.join(simulation_directory,file)
 
+            elif file.endswith('_banksbed.vecz'):
+                self.banksbed_file = os.path.join(simulation_directory,file)
+
+
+
         # Reading the results
         #  # head file
         file_size = os.path.getsize(self.head_file) # size of head file in bytes
@@ -6870,7 +7087,8 @@ class Wolfresults_1D:
 
             # Extraction of time steps
             all_times = head_data[nb_coordinates_data + 1::]
-            self.simulated_times = all_times[1::2]
+            self.simulated_times = all_times[1::2] # FIXME why does it start from 1?
+            # self.simulated_times = all_times[::2]
             self.real_times = all_times[::2]
 
             # Formula for available results
@@ -6945,8 +7163,76 @@ class Wolfresults_1D:
         self.froudes_max = self.find_max(self.froudes)
         self.water_level_ymax = self.depths_max + self.find_max(self.topo) # FIXME
 
+        if self.banksbed_file is not None:
+            self._river_banksbed(self.banksbed_file)
+            # FIXME delete the unnecessary call of this function (self._river_banksbed) in the plotting methods
+
         # print('done')
 
+    def get_closest_simulated_time_index(self, time:float)-> int:
+        """Return the index of the closest time step to a given time.
+
+        The closest time step is obtained by subtracting
+        the provided time from all simulated times steps.
+        The smallest difference is then used to find the index of
+        closest time step.
+
+        :param time: the desired time
+        :type time: float
+        :return: the index of the closest time step
+        :rtype: int
+        """
+        assert time >= 0 and time <= self.simulated_times[-1],\
+            f'The time ({time}) should be greater than 0 and less than the last simulated time - ({self.simulated_times[-1]})'
+        dif_array = np.absolute(self.simulated_times - time)
+        id = np.argmin(dif_array)
+        return id
+
+    def get_closest_simulated_results(self,
+                                      time:float,
+                                      node:int,
+                                      which_results: Literal['water level',
+                                                             'water depth',
+                                                             'discharge',
+                                                             'velocity',
+                                                             'froude',
+                                                             'wetted section',
+                                                             'top width',
+                                                             'all'] = 'all'
+                                      )-> Union[float, dict]:
+        """
+        Return the simulated conditions (water level, water depth, discharge, velocity, froude, wetted section, top width
+        ) at the closest time step to a given time.
+
+        :param time: the desired time
+        :type time: float
+        :param node: the desired node
+        :type node: int
+        :return: the conditions at the closest time step
+        :rtype: np.ndarray
+        """
+        id = self.get_closest_simulated_time_index(time)
+        water_level = self.water_levels[node,id]
+        depth = self.depths[node][id]
+        disharge = self.discharges[node][id]
+        velocity = self.velocities[node][id]
+        froude = self.froudes[node][id]
+        wetted_section = self.wetted_sections[node][id]
+        top_width = self.widths[node][id]
+        results = {'water level': water_level,
+                   'water depth': depth,
+                   'discharge': disharge,
+                   'velocity': velocity,
+                   'froude': froude,
+                   'wetted section': wetted_section,
+                   'top width': top_width}
+
+        if which_results == 'all':
+
+            return results
+        else:
+            return results[which_results]
+
     def update_ic_from_time_steps(self, time_step:int = -1) -> np.ndarray:
         """Return the simulated conditions (a,q,h, r) at a given time step as a `np.ndarray`.
             - a: Wetted section (index 0),
@@ -7004,6 +7290,77 @@ class Wolfresults_1D:
             for i in range(lgth_values):
                 f.write(f"{df['skeleton'][i]}{sep}{df['zone'][i]}{sep}{df['segment'][i]}{sep}{str(df['value'][i])}\n")
 
+    def get_one_node_evolution(self,
+                                node:int = 0,
+                                variable:Literal['water level', 'discharge', 'water depth', 'velocity', 'wetted section', 'froude'] = 'discharge',
+                                first_time_step = 0,
+                                last_time_step = -1 )-> np.ndarray:
+        """Return the discharges at a given node (cross section) for all time steps.
+
+        :param node: the desired node, defaults to 0
+        :type node: int, optional
+        :return: the discharges at the specified node for all time steps
+        :rtype: np.ndarray
+        """
+        assert isinstance(node, int),\
+            f"The node should be an integer greater than 0, not {node}."
+        assert isinstance(first_time_step, int) and isinstance(last_time_step, int),\
+            f"The time steps should be integers, not {first_time_step} and {last_time_step}."
+
+        if variable == 'discharge':
+            variable_data = self.discharges
+        elif variable == 'water depth':
+            variable_data = self.depths
+        elif variable == 'water level':
+            variable_data = self.water_levels
+        elif variable == 'velocity':
+            variable_data = self.velocities
+        elif variable == 'wetted section':
+            variable_data = self.wetted_sections
+        elif variable == 'froude':
+            variable_data = self.froudes
+        else:
+            raise ValueError(f"The variable {variable} is not available in results.")
+
+        real_first_time_step = self.convert_time_step(first_time_step)
+        real_last_time_step = self.convert_time_step(last_time_step)
+        assert real_first_time_step < real_last_time_step,\
+            f"The first time step should be less than the last time step, not {real_first_time_step} and {real_last_time_step}."
+
+        if last_time_step == -1:
+            data = variable_data[node,first_time_step:]
+            time = self.simulated_times[first_time_step:]
+        elif last_time_step < 0 and last_time_step != -1:
+            data = variable_data[node,first_time_step: (last_time_step +1)]
+            time = self.simulated_times[first_time_step: (last_time_step +1)]
+        else:
+            data = variable_data[node,first_time_step:last_time_step]
+            time = self.simulated_times[first_time_step:last_time_step]
+        node_data = pd.Series(data, index = time)
+        return node_data
+
+    def get_one_node_evolution_on_hydrograph_format(self,
+                                             node:int = 0,
+                                             variable: Literal['water level', 'discharge', 'water depth',
+                                                               'velocity', 'wetted section', 'froude'] = 'discharge',
+                                             first_time_step = 0,
+                                             last_time_step = -1,
+                                             ) -> Hydrograph:
+        """Return  the hydrograph of a given node for a speiciified range of time steps.
+
+        :param node: the desired node, defaults to 0
+        :type node: int, optional
+        :param first_time_step: the first time step, defaults to 0
+        :type first_time_step: int, optional
+        :param last_time_step: the last time step, defaults to -1
+        :type last_time_step: int, optional
+        :return: the hydrograph of the specified node
+        :rtype: Hydrograph
+        """
+
+        node_data = self.get_one_node_evolution(node=node,variable=variable,first_time_step=first_time_step,last_time_step=last_time_step)
+        return Hydrograph(node_data)
+
     def plot_water_level(self,
                          figax:tuple = None,
                          time_step:int = 1,
@@ -8735,6 +9092,216 @@ class Wolfresults_1D:
         :rtype: list
         """
 
+        animation_axes = self.plot_variables(figures,
+                                  time_step,
+                                  banksbed,
+                                  landmark= landmark,
+                                  figsize=figsize,
+                                  alpha=alpha,
+                                  grid_x_m = grid_x,
+                                  grid_y_m = grid_y,
+                                  show=False)
+        for charactetristic in animation_axes:
+                if len(charactetristic) == 3:
+                    fig = charactetristic[2]
+                    break
+        real_time_step = self.convert_time_step(time_step)
+        new_axes = self.create_axis(figures)
+        if banksbed != '':
+            minimum_banks = np.minimum(self.z_bankleft,self.z_bankright)
+            maximum_banks = np.maximum(self.z_bankleft,self.z_bankright)
+
+        # animation_axes = figure_charateristics[0]
+        # fig = figure_charateristics[-1]
+        def _update_plots(i:int):
+            index = i + real_time_step -1
+            h = self.depths[:, index]
+            wl= self.z_coords + h
+            q = self.discharges[:, index]
+            a = self.wetted_sections[:, index]
+            v = self.velocities[:, index]
+            # if self.froudes != None:
+            fr = self.froudes[:, index]
+
+            if 'water level' in figures:
+                wl_id= figures.index('water level')
+                water_level = animation_axes[wl_id][0]
+                ax_wl = animation_axes[wl_id][1]
+                water_level.set_data(self.s_coords,wl)
+                for coll in ax_wl.collections:
+                    coll.remove()
+                # ax_wl.collections.clear()
+                # ax_wl.fill_between(self.s_coords,
+                #                 self.z_coords,
+                #                 wl,
+                #                 where=self.z_coords <= wl,
+                #                 facecolor='cyan',
+                #                 alpha=0.3,
+                #                 interpolate=True )
+
+                if banksbed != '':
+
+                    ax_wl.fill_between(self.s_coords, self.z_coords, wl, where =   minimum_banks[:-1] <= wl,
+                                                    color = Colors.RIVER_COLOR.value,
+                                                    alpha = Constants.TRANSPARENCY_RIVER.value,
+                                                    interpolate=True, label='Below banks')
+                    ax_wl.fill_between(self.s_coords, self.z_coords, wl, where =   wl <= maximum_banks[:-1],
+                                                    color = Colors.RIVER_COLOR.value,
+                                                    alpha = Constants.TRANSPARENCY_RIVER.value,
+                                                    interpolate=True)
+
+
+                    ax_wl.fill_between(self.s_coords, self.z_bankright[:-1],  wl, where =   self.z_bankright[:-1] < wl,
+                                                    color =Colors.FLOODED_RIGHT.value, alpha=Constants.TRANSPARENCY_FLOOD.value,
+                                                    interpolate=True, label='Right flooded')
+
+                    ax_wl.fill_between(self.s_coords, self.z_bankleft[:-1],  wl, where =   self.z_bankleft[:-1] < wl,
+                                                    color =Colors.FLOODED_LEFT.value, alpha=Constants.TRANSPARENCY_FLOOD.value,
+                                                    interpolate=True, label='left flooded')
+
+                    ax_wl.fill_between(self.s_coords, maximum_banks[:-1], wl, where =   maximum_banks[:-1] <= wl,
+                                                    color =Colors.FLOODED_ALL.value,
+                                                    alpha=Constants.TRANSPARENCY_FLOOD.value,interpolate=True, label='All flooded')
+
+                ax_wl.fill_between(self.s_coords,
+                                self.z_coords,
+                                y2 = self.z_min,
+                                color='black',
+                                label ='topo',
+                                alpha =0.3
+                                    )
+
+                # # to be verified
+                if banksbed != '':
+                    ax_wl.fill_between(self.s_coords, wl, self.z_bankleft[:-1], where = wl >= self.z_bankleft[:-1],
+                                            color ='red', alpha=alpha, interpolate=True, label='Left flooded')
+                    ax_wl.fill_between(self.s_coords, wl, self.z_bankright[:-1], where = wl >= self.z_bankright[:-1],
+                                            color ='magenta', alpha=alpha, interpolate=True, label='Right flooded')
+
+                if landmark != '':
+                    self._landmark(landmark,ax_wl,index, variable='water level', text= False)
+                # ax_wl.grid()
+
+            if 'water depth' in figures:
+                h_id= figures.index('water depth')
+                water_depth = animation_axes[h_id][0]
+                ax_h = animation_axes[h_id][1]
+                water_depth.set_data(self.s_coords, h)
+                for coll in ax_h.collections:
+                    coll.remove()
+                # ax_h.collections.clear()
+                ax_h.fill_between(self.s_coords, h, facecolor= 'cyan', alpha= 0.3, interpolate=True)
+                if landmark != '':
+                    self._landmark(landmark,ax_h,index, variable='water depth', text= False)
+
+            if 'discharge' in figures:
+                q_id= figures.index('discharge')
+                discharge = animation_axes[q_id][0]
+                ax_q = animation_axes[q_id][1]
+                discharge.set_data(self.s_coords,q)
+                for coll in ax_q.collections:
+                    coll.remove()
+                # ax_q.collections.clear()
+                ax_q.fill_between(self.s_coords, q, facecolor= 'red', alpha= 0.3, interpolate=True)
+                if landmark != '':
+                    self._landmark(landmark,ax_q,index, variable='discharge', text= False)
+
+            if 'wetted section' in figures:
+                a_id= figures.index('wetted section')
+                wetted_section= animation_axes[a_id][0]
+                ax_a = animation_axes[a_id][1]
+                wetted_section.set_data(self.s_coords, a)
+                for coll in ax_a.collections:
+                    coll.remove()
+                # ax_a.collections.clear()
+                ax_a.fill_between(self.s_coords, a, facecolor= 'blue', alpha= 0.3, interpolate=True)
+                if landmark != '':
+                    self._landmark(landmark,ax_a,index, variable='wetted sections', text= False)
+
+            if 'velocity' in figures:
+                v_id= figures.index('velocity')
+                velocity = animation_axes[v_id][0]
+                ax_v = animation_axes[v_id][1]
+                velocity.set_data(self.s_coords, v)
+                for coll in ax_v.collections:
+                    coll.remove()
+                # ax_v.collections.clear()
+                ax_v.fill_between(self.s_coords, v, facecolor= 'red', alpha= 0.3, interpolate=True)
+                if landmark != '':
+                    self._landmark(landmark,ax_v,index, variable='velocity', text= False)
+
+            if 'froude' in figures:
+                fr_id= figures.index('froude')
+                froude = animation_axes[fr_id][0]
+                ax_fr = animation_axes[fr_id][1]
+                froude.set_data(self.s_coords, fr)
+                for coll in ax_fr.collections:
+                    coll.remove()
+                # ax_fr.collections.clear()
+                # ax_fr.fill_between(self.s_coords, fr, facecolor= 'blue', alpha= 0.3, interpolate=True)
+
+                ax_fr.fill_between(self.s_coords, fr,
+                                       color ='blue', alpha=alpha, interpolate=True, label='Subcritical')
+                ax_fr.fill_between(self.s_coords, fr,y2 =1, where= 1<= fr,
+                                       color ='blue', alpha=1, interpolate=True, label='Supercritical')
+
+                ax_fr.hlines([1], 0, self.s_max, colors='red',linestyles= 'dotted')
+                if landmark != '':
+                    self._landmark(landmark,ax_fr,index, variable='froude', text= False)
+
+
+            fig.suptitle(f'Results - 1D model\n$Time: (step: {index+1} - $simulated: {self.simulated_times[index+1]:#.1f}s$ - real: {self.real_times[index+1]:#.1e} s)$',
+                        fontsize= 'x-large', fontweight= 'bold')
+
+
+        rcParams['animation.embed_limit'] = 2**128 # Maximum size gif
+        ani = animation.FuncAnimation(fig,
+                                    _update_plots,
+                                    interval = 200,
+                                    blit = False,
+                                    frames = self.simulated_times.shape[0] - real_time_step,
+                                    repeat_delay = 100)
+
+        if save_as != '':
+            writergif = animation.PillowWriter(fps=5)
+            ani.save(save_as, writer=writergif)
+
+        return HTML(ani.to_jshtml())
+
+    def ____FIXMEanimate_1D_plots(self,
+                            figures:list[Literal['water level', 'discharge', 'wetted section','water depth', 'velocity', 'froude']] =['water level', 'discharge', 'wetted section','water depth', 'velocity', 'froude'],
+                            time_step:int = 1,
+                            banksbed: Union[str, Zones] = '',
+                            landmark: Union[str,Zones]= '',
+                            figsize:tuple = (20,10),
+                            alpha:float = 0.3,
+                            save_as:str='',
+                            grid_x = 1000,
+                            grid_y = 10):
+        """
+        Animate the selected variables in figures, save them as a file and
+        return  the information associated with their axes.
+
+        FIXME: implement multiprocesses to speed up the process.
+
+        :param figures: List of figures
+        :type figures: list
+        :param time_step: Time step, defaults to 1
+        :type time_step: int, optional
+        :param banksbed: Banksbed, defaults to ''
+        :type banksbed: Union[str, Zones], optional
+        :param landmark: Landmark, defaults to ''
+        :type landmark: Union[str,Zones], optional
+        :param figsize: Figsize, defaults to (20,10)
+        :type figsize: tuple, optional
+        :param alpha: Alpha, defaults to 0.3
+        :type alpha: float, optional
+        :param save_as: Save as, defaults to ''
+        :type save_as: str, optional
+        :return: List of axes
+        :rtype: list
+        """
+
         animation_axes = self.plot_variables(figures,
                                   time_step,
                                   banksbed,
@@ -8884,6 +9451,7 @@ class Wolfresults_1D:
             fig.suptitle(f'Results - 1D model\n$Time: (step: {index+1} - $simulated: {self.simulated_times[index+1]:#.1f}s$ - real: {self.real_times[index+1]:#.1e} s)$',
                         fontsize= 'x-large', fontweight= 'bold')
 
+            # pillow_image = Image.frombytes('RGB',fig.canvas.get_width_height(),fig.canvas.tostring_rgb())
 
         rcParams['animation.embed_limit'] = 2**128 # Maximum size gif
         ani = animation.FuncAnimation(fig,
@@ -9066,6 +9634,8 @@ class Wolfresults_1D:
             real_timestep = self.results_length + time_step
         elif time_step > 0 and time_step <= self.results_length:
             real_timestep= time_step - 1 # Python counts from 0.
+        elif time_step == 0:
+            real_timestep = 0
         else:
             real_timestep = self.results_length - 1
             warnings.warn(f'The input (time step) was not found; therefore, the last time step is plotted.', UserWarning)
@@ -9256,7 +9826,15 @@ class Wolfresults_1D:
         :rtype: float
         """
 
-        if y_max < 1:
+        if y_max < 0.0001:
+            grid_y = .00001
+        elif y_max < 0.001:
+            grid_y = .0001
+        elif y_max < 0.01:
+            grid_y = .001
+        elif y_max < 0.1:
+            grid_y = .01
+        elif y_max < 1:
             grid_y = .1
         elif y_max < 3:
             grid_y = .2
@@ -9582,7 +10160,8 @@ class Wolfresults_1D:
                            save_as:str = '',
                            figure_size = (25,15),
                            linewidth = 2.,
-                           plotting_style:Literal['scatter','line', 'combined'] = 'line'
+                           plotting_style:Literal['scatter','line', 'combined'] = 'line',
+                           convert_to: Literal['days', 'hours', 'minutes', 'seconds'] = 'seconds'
                            ):
         """
         Plot the evolution in time of specified nodes for a variable.
@@ -9600,10 +10179,17 @@ class Wolfresults_1D:
         :param plotting_style: Plotting style (matplotlib format), defaults to 'line'
         :type plotting_style: Literal['scatter','line', 'combined'], optional
         """
+        coefficient = self.find_conversion_factor_from_seconds(convert_to)
+
+        def axis_as_time_unit(val, pos):
+            value = val/coefficient
+            return f'{value:#.1F}'
 
         fig = plt.figure(figsize = figure_size, facecolor='white')
         ax1 = fig.add_subplot(121)
         ax2 = fig.add_subplot(122)
+        ax1.xaxis.set_major_formatter(FuncFormatter(axis_as_time_unit))
+        ax2.xaxis.set_major_formatter(FuncFormatter(axis_as_time_unit))
 
         # Define the variable
         if variable_name == 'discharge':
@@ -9678,7 +10264,8 @@ class Wolfresults_1D:
         ax1.set_xlim(np.min(self.simulated_times),np.max(self.simulated_times))
         ax1.set_ylim(min(min_variable), (max(max_variable) + 0.1*max(max_variable)))
         # ax1.set_ylabel('Discharge [$m^3$]', fontsize= 'x-large')
-        ax1.set_xlabel('Simulated times [$s$]', fontsize= 'x-large')
+        # ax1.set_xlabel('Simulated time [$s$]', fontsize= 'x-large')
+        ax1.set_xlabel(f'Time [{convert_to}]')
         ax1.legend()
         # ax1.xaxis.set_ticks(np.arange(min(times),max(times),900))
         x_max = max(self.simulated_times)
@@ -9696,7 +10283,8 @@ class Wolfresults_1D:
         #          max(max_variable) + 0.05* max(max_variable),
         #          f'$Phase-shift: {max_times[0]-max_times[-1]:#.2f}s$', fontsize =14)
         ax2.set_ylim(min(min_variable), (max(max_variable) + 0.1*max(max_variable)))
-        ax2.set_xlabel('Time from maximum [s]', fontsize= 'x-large')
+        # ax2.set_xlabel('Time from maximum [s]', fontsize= 'x-large')
+        ax2.set_xlabel(f'Time from maximum [{convert_to}]')
         ax2.legend()
         # ax2.xaxis.set_ticks(np.arange((-tmax/2),(tmax/2),900))
         ax2.grid()
@@ -9799,6 +10387,1184 @@ class Wolfresults_1D:
             fig.savefig(save_as, dpi =300)
         plt.show()
 
+    @staticmethod
+    def find_conversion_factor_from_seconds(convert_to: Literal['days', 'hours', 'minutes', 'seconds'] = 'seconds') -> int:
+        """
+        Find the conversion factor of a given time format to seconds.
+
+        :param convert_to: The time format to convert to.
+        :type convert_to: Literal['days', 'hours', 'minutes', 'seconds']
+        :return: The conversion factor.
+        :rtype: int
+        """
+        if convert_to == 'days':
+            return 86400
+        elif convert_to == 'hours':
+            return 3600
+        elif convert_to == 'minutes':
+            return 60
+        elif convert_to == 'seconds':
+            return 1
+        else:
+            raise ValueError('The time format is not recognized')
+
+    def project_coordinates_on_bed(self, x:float, y:float, z:float = None) -> tuple[int, float]:
+        """
+        Return the projection of the given point coorinates on the river bed.
+        The return format is the following (x, y, s).
+        Where,
+         - x is the x coordinate of the projected point,
+         - y is the y coordinate of the projected point,
+         - s is the curviligne coordinate of the projected point (length from origin).
+
+        :param x: X coordinate
+        :type x: float
+        :param y: Y coordinate
+        :type y: float
+        :param z: Z coordinate, defaults to None
+        :type z: float, optional
+        :return: Projected coordinates
+        :rtype: tuple[float,float,float]
+        """
+
+        if z is None:
+            projection = self.mid_river_ls.project(Point(x,y))
+
+        else:
+            projection = self.mid_river_ls.project(Point(x,y,z))
+
+
+        closest_length, index_in_the_simulation = self.find_nearest(self.s_coords, projection)
+
+        return index_in_the_simulation, closest_length
+
+    def find_nearest(self, array: np.array, value: Literal[int, float]) -> tuple[float,int]:
+        "Find the nearest value to the <value> and its index in an array."
+        array = np.asarray(array)
+        idx = (np.abs(array - value)).argmin()
+        return array[idx], idx
+
+    def get_results_from_xy_coordinates(self, x:float, y:float, time:int) -> dict:
+        """
+        Return the results of the closest point coordinates for a given time.
+
+        :param x: X coordinate
+        :type x: float
+        :param y: Y coordinate
+        :type y: float
+        :param time: Time step
+        :type time: int
+        :return: Results
+        :rtype: dict
+        """
+        assert isinstance(time, int), 'The time step must be an integer.'
+
+        index, s = self.project_coordinates_on_bed(x,y)
+        # results = self.get_closest_simulated_results(time, index)
+        # results['Distance'] = s
+        return self.get_closest_simulated_results(time, index)
+
+    def get_simulated_velocity(self, node_index: int, time_index: int) -> float:
+        """Return the simulated velocity at a given node and time step."""
+        # assert isinstance(time_index, (int, np.ndarray)), 'The time step must be an integer or an array of integers.'
+        # assert isinstance(node_index, (int, np.ndarray)), 'The node index must be an integer or an array of integers.'
+        return self.velocities[node_index][time_index]
+
+    def _get_buoy_trajectories(self,
+                              time:float,
+                              x:float,
+                              y:float,
+                              distance: float = None,
+                              number_cells = None) -> pd.DataFrame:
+        assert time>=0 and time <= self.simulated_times[-1],\
+            f'The time must be within the simulation time range. {self.simulated_times[0]} <= time <= {self.simulated_times[-1]}'
+
+        buoy_data = pd.DataFrame(columns = ['time',
+                                            'distance',
+                                            'water level',
+                                            'water depth',
+                                            'discharge',
+                                            'velocity',
+                                            'froude',
+                                            'wetted section',
+                                            'top width'])
+
+
+        if distance is None and number_cells is None:
+            all_cells = len(self.s_coords)
+            index, s = self.project_coordinates_on_bed(x, y)
+            distance = s
+
+        while tqdm(index < all_cells, desc='Computing buoy trajectories', unit='node', disable = True):
+
+            results = self.get_closest_simulated_results(time, index)
+
+            buoy_data.loc[len(buoy_data.index)] ={'time': time,
+                                                'distance': distance,
+                                                'water level': results['water level'],
+                                                'water depth': results['water depth'],
+                                                'discharge': results['discharge'],
+                                                'velocity': results['velocity'],
+                                                'froude': results['froude'],
+                                                'wetted section': results['wetted section'],
+                                                'top width': results['top width']}
+
+            new_index = index + 1
+            if new_index < all_cells:
+                distance = self.s_coords[new_index]
+                distance_difference = self.s_coords[new_index] - self.s_coords[index]
+                # time += distance_difference / results['velocity']
+                time += distance_difference / abs(results['velocity']) # FIXME
+            index = new_index
+
+        return buoy_data
+
+    def update_spatial_index_from_velocity(self, spatial_index:int, velocity:float,) -> int:
+        """
+        Update the spatial index based on the velocity.
+        """
+        if velocity > 0:
+            new_spatial_index = spatial_index + 1
+        elif velocity < 0:
+            new_spatial_index = spatial_index - 1
+        elif velocity == 0:
+            raise ValueError(f'The velocity at node - {spatial_index} is null. The buoy is not moving.')
+        else:
+            raise ValueError(f'The velocity at node - {spatial_index} is not a number.')
+        return new_spatial_index
+
+    def update_spatial_index_from_velocity_backwards(self, spatial_index:int, velocity:float,) -> int:
+        """
+        Update the spatial index based on the velocity.
+        """
+        if velocity > 0:
+            new_spatial_index = spatial_index - 1
+        elif velocity < 0:
+            new_spatial_index = spatial_index + 1
+        elif velocity == 0:
+            raise ValueError(f'The velocity at node - {spatial_index} is null. The buoy is not moving.')
+        else:
+            raise ValueError(f'The velocity at node - {spatial_index} is not a number.')
+        return new_spatial_index
+
+    def update_null_and_missing_velocities(self, velocity: float, treshold: float = 0.0001):
+        """
+        If the velocity is null or a missing value,
+        a treshold (preferably very small) is returned
+        as the new velocity to avoid division by zero or nan.
+
+        @ Added during Gaia's internship
+        to handle null and missing velocities.
+        """
+        if velocity > 0:
+            return velocity
+        elif  velocity < 0:
+            return velocity
+        elif velocity == 0:
+            logging.warning(f'The velocity was zero. It has been changed to 0.0001m/s')
+            return treshold
+        else:
+            logging.warning(f'The velocity was not a number. It has been changed to 0.0001m/s')
+            return treshold
+
+    def _create_buoy_dataframe(self) -> pd.DataFrame:
+        """
+        Create a DataFrame to store data from a drifter (buoy) trajectory.
+        """
+        columns = ['time',
+                'distance',
+                'water level',
+                'water depth',
+                'discharge',
+                'velocity',
+                'froude',
+                'wetted section',
+                'top width']
+        return pd.DataFrame(columns=columns)
+
+    def _compute_number_of_cells_on_curvilinear_vector(self) -> int:
+        """Return the number of cells on the curvilinear vector."""
+        return len(self.s_coords)
+
+    def _get_results_velocity_for_buoy(self, results: dict) -> float:
+        """
+        Extract the velocity result for the buoy from the results dictionary.
+        """
+        assert isinstance(results, dict), 'The results must be a dictionary.'
+        velocity = results.get('velocity', None)
+        if velocity is None:
+            raise Exception('Velocity not found')
+        return self.update_null_and_missing_velocities(velocity)
+
+    def _get_distance_between_spatial_indices(self, from_index:int, to_index:int) -> float:
+        """
+        Compute the distance between two spatial indices.
+        """
+        return self.s_coords[to_index] - self.s_coords[from_index]
+
+    def _update_time_from_distance_and_velocity(self,
+                                               time: float,
+                                               distance: float,
+                                               velocity:float) -> float:
+        """
+        Return the updated time which is computed
+        based on the provided distance and velocity.
+
+        !!! Mainly used in buoy applications (drifters)
+        in the forward direction.
+
+        :param time: Initial time
+        :type time: float
+        :param distance: Distance travelled between two points.
+        :type distance: float
+        :param velocity: Velocity
+        :type velocity: float
+        :return: Updated time
+        :rtype: float
+        """
+        time_delta = abs(distance)/ abs(velocity)
+        return time + time_delta
+
+    def _update_time_from_distance_and_velocity_backwards(self,
+                                               time: float,
+                                               distance: float,
+                                               velocity:float) -> float:
+        """
+        Return the updated time which is computed
+        based on the provided distance and velocity.
+
+        !!! Mainly used in buoy applications (drifters)
+        in the backward direction.
+
+        :param time: Initial time
+        :type time: float
+        :param distance: Distance travelled between two points.
+        :type distance: float
+        :param velocity: Velocity
+        :type velocity: float
+        :return: Updated time
+        :rtype: float
+        """
+        time_delta = abs(distance)/ abs(velocity)
+        return time - time_delta
+
+    def _verify_and_correct_overtime(self, time: float):
+        """
+        Ensure the time does not exceed the simulated time range.
+        """
+        if time > self.simulated_times [-1]:
+            return self.simulated_times[-1]
+        return time
+
+    def _verify_and_correct_overtime_backwards(self, time: float):
+        """
+        Return the starting time  of the simulation
+        if the provided time is less than the first simulated time.
+        
+        ! To ensure the time does not exceed the simulated time range,
+        lowest boundary.
+        """
+        if time < self.simulated_times[0]:
+            return self.simulated_times[0]
+        return time
+
+    def _verify_and_correct_overtime_smart_way(self,
+                                               time_0: float,
+                                               time_1: float,
+                                               temporal_index_0: int,
+                                               temporal_index_1: int,
+                                               distance: float,
+                                               spatial_index: int) -> tuple[float, int]:
+        """
+        FIXME: examine this algorithm and check its impact on results.
+        to ensure the time does not exceed the simulated time range.
+        """
+        if time_1 > self.simulated_times [-1]:
+            while time_1 > self.simulated_times[-1]:
+                temporal_index_1 += 1
+                results = self.get_closest_simulated_results(self.simulated_times[temporal_index_1], spatial_index)
+                velocity = self._get_results_velocity_for_buoy(results)
+                time = self._update_time_from_distance_and_velocity(time, distance, velocity)
+
+                time_delta = abs(distance) / abs(velocity)
+                time_1 = time_0 + time_delta
+            # To avoid repeating the same procedure at the next test.
+            temporal_index_0 = temporal_index_1
+        return time_1, temporal_index_0
+
+    def _verify_and_correct_overtime_smart_way_backwards(self,
+                                               time_0: float,
+                                               time_1: float,
+                                               temporal_index_0: int,
+                                               temporal_index_1: int,
+                                               distance: float,
+                                               spatial_index: int) -> tuple[float, int]:
+        """
+        FIXME: examine this algorithm and check its impact on results.
+        Ensure the time does not exceed the simulated time range.
+        """
+        if time_1 < self.simulated_times [0]:
+            while time_1 < self.simulated_times[0]:
+                temporal_index_1 -= 1
+                results = self.get_closest_simulated_results(self.simulated_times[temporal_index_1], spatial_index)
+                velocity = self._get_results_velocity_for_buoy(results)
+                time = self._update_time_from_distance_and_velocity(time, distance, velocity)
+
+                time_delta = abs(distance) / abs(velocity)
+                time_1 = time_0 - time_delta
+            # To avoid repeating the same procedure at the next test.
+            temporal_index_0 = temporal_index_1
+        return time_1, temporal_index_0
+
+    def _corrected_skipped_temporal_indices(self,
+                                             time_0: float,
+                                             time_1: float,
+                                             temporal_index_0: int,
+                                             temporal_index_1: int,
+                                             distance: float,
+                                             spatial_index: int,
+                                             velocity: float) -> tuple[float, int]:
+        
+        """
+        Correct the time and spatial index if some temporal indices were skipped.
+        (! Mainly for forwards direction)
+
+        This can happen when the buoy moved faster 
+        than the first encountered flow velocity in the simulation.
+
+        For instance, if the buoy moved from temporal index 5 to 10,
+        the maximum simulated velocity  between indices 5 and 10 is searched.
+
+        :param time_0: Initial time
+        :type time_0: float
+        :param time_1: Updated time
+        :type time_1: float
+        :param temporal_index_0: Initial temporal index
+        :type temporal_index_0: int
+        :param temporal_index_1: Updated temporal index
+        :type temporal_index_1: int
+        :param distance: Distance travelled between two points.
+        :type distance: float
+        :param spatial_index: Spatial index
+        :type spatial_index: int
+        :param velocity: Velocity
+        :type velocity: float
+        :return: Updated time and spatial index
+        :rtype: tuple[float, int]
+        """
+        if temporal_index_1 - temporal_index_0 > 1:
+            potential_temporal_indices = np.arange(temporal_index_0, temporal_index_1 + 1, 1)
+            potential_velocities = self.get_simulated_velocity(spatial_index, potential_temporal_indices)
+
+            # 1. Getting the maximum velocity in the time range.
+            maximum_velocity = np.max(potential_velocities)
+            # 2. If the maximum velocity is not the previously extracted velocity which means the buoy moved faster,
+            # the temporal index is updated to the index of the maximum velocity.
+            if maximum_velocity != velocity:
+                updated_temporal_index = potential_temporal_indices[np.argmax(potential_velocities)]
+                # 3. The time and the results are updated.
+                updated_time = self.simulated_times[updated_temporal_index]
+                results = self.get_closest_simulated_results(updated_time, spatial_index)
+                velocity = self._get_results_velocity_for_buoy(results)
+                time_1 = self._update_time_from_distance_and_velocity(time_0, distance, velocity)
+                # The spatial index is updated (mainly the sign)
+                new_spatial_index = self.update_spatial_index_from_velocity(spatial_index, velocity)
+                return time_1, new_spatial_index
+        return time_1, spatial_index
+
+    def _corrected_skipped_temporal_indices_backwards(self,
+                                             time_0: float,
+                                             time_1: float,
+                                             temporal_index_0: int,
+                                             temporal_index_1: int,
+                                             distance: float,
+                                             spatial_index: int,
+                                             velocity: float) -> tuple[float, int]:
+        
+        """
+        Correct the time and spatial index if some temporal indices were skipped.
+        (! Mainly for backwards direction)
+        This can happen when the buoy moved faster
+        than the first encountered flow velocity in the simulation.
+        For instance, if the buoy moved from temporal index 10 to 5,
+        the maximum simulated velocity  between indices 5 and 10 is searched.
+        :param time_0: Initial time
+        :type time_0: float
+        :param time_1: Updated time
+        :type time_1: float
+        :param temporal_index_0: Initial temporal index
+        :type temporal_index_0: int
+        :param temporal_index_1: Updated temporal index
+        :type temporal_index_1: int
+        :param distance: Distance travelled between two points.
+        :type distance: float
+        :param spatial_index: Spatial index
+        :type spatial_index: int
+        :param velocity: Velocity
+        :type velocity: float
+        :return: Updated time and spatial index
+        :rtype: tuple[float, int]
+        """
+        if  temporal_index_0 - temporal_index_1> 1:
+            potential_temporal_indices = np.arange(temporal_index_1,temporal_index_0 + 1, 1)
+            potential_velocities = self.get_simulated_velocity(spatial_index, potential_temporal_indices)
+
+            # 1. Getting the maximum velocity in the time range.
+            maximum_velocity = np.max(potential_velocities)
+            # 2. If the maximum velocity is not the previously extracted velocity which means the buoy moved faster,
+            # the temporal index is updated to the index of the maximum velocity.
+            if maximum_velocity != velocity:
+                updated_temporal_index = potential_temporal_indices[np.argmax(potential_velocities)]
+                # 3. The time and the results are updated.
+                updated_time = self.simulated_times[updated_temporal_index]
+                results = self.get_closest_simulated_results(updated_time, spatial_index)
+                velocity = self._get_results_velocity_for_buoy(results)
+                time_1 = self._update_time_from_distance_and_velocity_backwards(time_0, distance, velocity)
+                # The spatial index is updated (mainly the sign)
+                new_spatial_index = self.update_spatial_index_from_velocity_backwards(spatial_index, velocity)
+                return time_1, new_spatial_index
+        return time_1, spatial_index
+
+    def get_buoy_forward_trajectory(self,
+                              time:float,
+                              x:float,
+                              y:float,
+                              debug = False) -> pd.DataFrame:
+        """
+        Compute the trajectory of a buoy (drifter) in the forward direction.
+        :param time: Initial time
+        :type time: float
+        :param x: X coordinate of the initial position
+        :type x: float
+        :param y: Y coordinate of the initial position
+        :type y: float
+        :param debug: If True, print debug information, defaults to False
+        :type debug: bool, optional
+        :return: DataFrame containing the buoy trajectory data
+        :rtype: pd.DataFrame
+        """
+
+        # Step 1: We verify whether the time is within the simulated range.
+        # ----------------------------------------------------------------
+        assert time>=0 and time <= self.simulated_times[-1],\
+            f'The time must be within the simulated time span.\
+                {self.simulated_times[0]} <= time - {time} <= {self.simulated_times[-1]}'
+        # Step 2: We create a DataFrame to store the buoy trajectory data.
+        # ---------------------------------------------------------------
+        buoy_data = self._create_buoy_dataframe()
+
+        # Step 3: Compute the  curvilinear distance from the first simulation cell
+        # and its index (spatial index). FInd the number of cells in the results
+        # -------------------------------------------------------------------------
+        spatial_index, distance = self.project_coordinates_on_bed(x, y)
+        number_of_cells = self._compute_number_of_cells_on_curvilinear_vector()
+
+        # Step 4: Extraction of results
+        # -----------------------------
+
+        # 4.1. Creation of loop to ensure that the computations are done within
+        # the simulated time range and spatial limits.
+        # -------------------------------------------------------------------
+        if debug:
+            # disable = False
+            disable = True
+        else:
+            disable = True
+        while tqdm(spatial_index <  number_of_cells-1 and time < self.simulated_times[-1],\
+                   desc='Computing buoy trajectories', unit='cell', disable=disable):
+            # 4.1.2. Get the closest simulated results in time at the provided coordinates.
+            # -------------------------------------------------------------------------
+            results = self.get_closest_simulated_results(time, spatial_index)
+            time_0 = time   # Is it necessary? doesnt look great, isn't it?
+
+            # 4.1.3. Extract the velocity from the results dictionary.
+            # -------------------------------------------------------------------------
+            velocity = self._get_results_velocity_for_buoy(results)
+
+            # 4.1.4. Update the spatial index based on the velocity extracted.
+            # -------------------------------------------------------------------------
+            new_spatial_index = self.update_spatial_index_from_velocity(spatial_index, velocity)
+
+            # 4.1.5. Compute the distance between the 2 spatial indices.
+            # -------------------------------------------------------------------------
+            distance_between_cells = self._get_distance_between_spatial_indices(spatial_index, new_spatial_index)
+
+            # 4.1.6. Update the time based on the distance and velocity.
+            # -------------------------------------------------------------------------
+            time_1 = self._update_time_from_distance_and_velocity(time_0, distance_between_cells, velocity)
+
+            # 4.1.7. Results verifications
+            # -------------------------------------------------------------------------
+            time_1 = self._verify_and_correct_overtime(time_1)
+
+            # 4.1.8. Get the temporal indices of the computed time
+            # -------------------------------------------------------------------------
+            temporal_index_0 = self.get_closest_simulated_time_index(time_0)
+            temporal_index_1 = self.get_closest_simulated_time_index(time_1)
+
+            # 4.1.9. Another correction of times
+            # ----------------------------------
+            # FIXME: This step is probably useless.Check it in debug mode..
+            time_1, temporal_index_0 = self._verify_and_correct_overtime_smart_way(time_0=time_0,
+                                                                                   time_1=time_1,
+                                                                                   temporal_index_0=temporal_index_0,
+                                                                                   temporal_index_1=temporal_index_1,
+                                                                                   distance=distance_between_cells,
+                                                                                   spatial_index=spatial_index,
+                                                                                   )
+
+            # 4.1.10. Case for temporal indices which have been skipped (not).
+            # ----------------------------------------------------------------
+            if temporal_index_1 - temporal_index_0 > 1:
+                time_1, new_spatial_index = self._corrected_skipped_temporal_indices(time_0=time_0,
+                                                                                    time_1=time_1,
+                                                                                    temporal_index_0=temporal_index_0,
+                                                                                    temporal_index_1=temporal_index_1,
+                                                                                    distance=distance_between_cells,
+                                                                                    spatial_index=spatial_index,
+                                                                                    velocity=velocity)
+            # 4.1.11. the results are added to the dataframe.
+            # ----------------------------------------------------------------
+            buoy_data.loc[len(buoy_data.index)] ={'time': time,
+                                            'distance': distance,
+                                            'water level': results['water level'],
+                                            'water depth': results['water depth'],
+                                            'discharge': results['discharge'],
+                                            'velocity': results['velocity'],
+                                            'froude': results['froude'],
+                                            'wetted section': results['wetted section'],
+                                            'top width': results['top width']}
+
+            # 4.1.12. Updating the time and spatial index for the next  iteration.
+            if new_spatial_index < number_of_cells:
+                time = time_1
+                spatial_index = new_spatial_index
+                distance = self.s_coords[spatial_index]
+                if debug:
+                    text_limit = '*'
+                    logging.info(f'\n{text_limit*50}\
+                                 \n\tTime: {time:#.2F} s,\
+                                 \n\tSpatial index: {spatial_index} out of {number_of_cells - 1},\
+                                 \n\tDistance: {distance:#.2F} m,\
+                                 \n\tVelocity: {velocity:#.2F} m/s\
+                                 \n{text_limit*50}')
+                # (print(f'New spatial index: {spatial_index} out of {number_of_cells}'))
+
+        return buoy_data
+
+    def get_buoy_backward_trajectory(self,
+                              time:float,
+                              x:float,
+                              y:float,
+                              debug = False) -> pd.DataFrame:
+        """
+        Compute the trajectory of a buoy (drifter) in the backward direction.
+
+        :param time: Initial time
+        :type time: float
+        :param x: X coordinate of the initial position
+        :type x: float
+        :param y: Y coordinate of the initial position
+        :type y: float
+        :param debug: If True, print debug information, defaults to False
+        :type debug: bool, optional
+        :return: DataFrame containing the buoy trajectory data
+        :rtype: pd.DataFrame
+        """
+
+        # Step 1: We verify whether the time is within the simulated range.
+        # ----------------------------------------------------------------
+        assert time>=0 and time <= self.simulated_times[-1],\
+            f'The time must be within the simulated time span.\
+                {self.simulated_times[0]} <= time - {time} <= {self.simulated_times[-1]}'
+        # Step 2: We create a DataFrame to store the buoy trajectory data.
+        # ---------------------------------------------------------------
+        buoy_data = self._create_buoy_dataframe()
+
+        # Step 3: Compute the  curvilinear distance from the first simulation cell
+        # and its index (spatial index). FInd the number of cells in the results
+        # -------------------------------------------------------------------------
+        spatial_index, distance = self.project_coordinates_on_bed(x, y)
+        number_of_cells = self._compute_number_of_cells_on_curvilinear_vector()
+
+        # Step 4: Extraction of results
+        # -----------------------------
+
+        # 4.1. Creation of loop to ensure that the computations are done within
+        # the simulated time range and spatial limits.
+        # -------------------------------------------------------------------
+        if debug:
+            # disable = False
+            disable = True
+        else:
+            disable = True
+        while tqdm(spatial_index >=  0 and time >= self.simulated_times[0],\
+                   desc='Computing buoy trajectory backwards', unit='cell', disable=disable):
+            # 4.1.2. Get the closest simulated results in time at the provided coordinates.
+            # -------------------------------------------------------------------------
+            results = self.get_closest_simulated_results(time, spatial_index)
+            time_0 = time
+
+            # 4.1.3. Extract the velocity from the results dictionary.
+            # -------------------------------------------------------------------------
+            velocity = self._get_results_velocity_for_buoy(results)
+
+            # 4.1.4. Update the spatial index based on the velocity extracted.
+            # -------------------------------------------------------------------------
+            new_spatial_index = self.update_spatial_index_from_velocity_backwards(spatial_index, velocity)
+            if new_spatial_index > 0:
+
+                # 4.1.5. Compute the distance between the 2 spatial indices.
+                # -------------------------------------------------------------------------
+                distance_between_cells = self._get_distance_between_spatial_indices(spatial_index, new_spatial_index)
+
+                # 4.1.6. Update the time based on the distance and velocity.
+                # -------------------------------------------------------------------------
+                time_1 = self._update_time_from_distance_and_velocity_backwards(time_0, distance_between_cells, velocity)
+
+                # 4.1.7. Results verifications
+                # -------------------------------------------------------------------------
+                time_1 = self._verify_and_correct_overtime_backwards(time_1)
+
+                # 4.1.8. Get the temporal indices of the computed time
+                # -------------------------------------------------------------------------
+                temporal_index_0 = self.get_closest_simulated_time_index(time_0)
+                temporal_index_1 = self.get_closest_simulated_time_index(time_1)
+
+                # 4.1.9. Another correction of times
+                # ----------------------------------
+                # FIXME: This step is probably useless.Check it in debug mode..
+                time_1, temporal_index_0 = self._verify_and_correct_overtime_smart_way_backwards(time_0=time_0,
+                                                                                    time_1=time_1,
+                                                                                    temporal_index_0=temporal_index_0,
+                                                                                    temporal_index_1=temporal_index_1,
+                                                                                    distance=distance_between_cells,
+                                                                                    spatial_index=spatial_index,
+                                                                                    )
+
+                # 4.1.10. Case for temporal indices which have been skipped (not).
+                # ----------------------------------------------------------------
+                if  temporal_index_0 - temporal_index_1 > 1:
+                    time_1, new_spatial_index = self._corrected_skipped_temporal_indices_backwards(time_0=time_0,
+                                                                                        time_1=time_1,
+                                                                                        temporal_index_0=temporal_index_0,
+                                                                                        temporal_index_1=temporal_index_1,
+                                                                                        distance=distance_between_cells,
+                                                                                        spatial_index=spatial_index,
+                                                                                        velocity=velocity)
+                # 4.1.11. the results are added to the dataframe.
+                # ----------------------------------------------------------------
+                buoy_data.loc[len(buoy_data.index)] ={'time': time,
+                                                'distance': distance,
+                                                'water level': results['water level'],
+                                                'water depth': results['water depth'],
+                                                'discharge': results['discharge'],
+                                                'velocity': results['velocity'],
+                                                'froude': results['froude'],
+                                                'wetted section': results['wetted section'],
+                                                'top width': results['top width']}
+
+                # 4.1.12. Updating the time and spatial index for the next  iteration.
+                if new_spatial_index >= 0:
+                    time = time_1
+                    spatial_index = new_spatial_index
+                    distance = self.s_coords[spatial_index]
+                    if debug:
+                        text_limit = '*'
+                        print(f'\n{text_limit*50}\
+                                    \n\tTime: {time:#.2F} s,\
+                                    \n\tSpatial index: {spatial_index} out of {number_of_cells - 1},\
+                                    \n\tDistance: {distance:#.2F} m,\
+                                    \n\tVelocity: {velocity:#.2F} m/s\
+                                    \n{text_limit*50}')
+                        if spatial_index == 0:
+                            print('The spatial index has reached the first cell.')
+                    # (print(f'New spatial index: {spatial_index} out of {number_of_cells}'))
+
+            else:
+                spatial_index = new_spatial_index
+                if debug:
+                    print(f'\n{text_limit*50}\
+                            \n\tTime: {time:#.2F} s,\
+                            \n\tSpatial index: {spatial_index} out of {number_of_cells - 1},\
+                            \n\tDistance: {distance:#.2F} m,\
+                            \n\tVelocity: {velocity:#.2F} m/s\
+                            \n{text_limit*50}')
+
+        return buoy_data
+
+    def get_buoy_trajectories(self,
+                              time:float,
+                              x:float,
+                              y:float,
+                              distance: float = None,
+                              number_cells = None) -> pd.DataFrame:
+        assert time>=0 and time <= self.simulated_times[-1],\
+            f'The time must be within the simulation time range. {self.simulated_times[0]} <= time - {time} <= {self.simulated_times[-1]}'
+
+        buoy_data = pd.DataFrame(columns = ['time',
+                                            'distance',
+                                            'water level',
+                                            'water depth',
+                                            'discharge',
+                                            'velocity',
+                                            'froude',
+                                            'wetted section',
+                                            'top width'])
+
+
+
+        # 1. Definition of spatial and temporal indices
+        # FIXME: What if only the distance is provided? or the opposite?
+        # also what if one or both of them are wrong?
+        # This should be a method make it robust.
+        if distance is None and number_cells is None:
+            # all_cells = len(self.s_coords)
+            # index, s = self.project_coordinates_on_bed(x, y)
+            spatial_index, distance = self.project_coordinates_on_bed(x, y)
+            # time_0 = time
+            number_of_cells = len(self.s_coords)
+
+        # 2. Extraction of results
+
+        # while tqdm(spatial_index >= 0 and spatial_index <  number_of_cells, desc='Computing buoy trajectories', unit='cell', disable=True):
+        while tqdm(spatial_index <  number_of_cells-1 and time < self.simulated_times[-1],\
+                   desc='Computing buoy trajectories', unit='cell', disable=True):
+
+            results = self.get_closest_simulated_results(time, spatial_index)
+            time_0 = time
+
+            # 2. 1.  updating the spatial index (forard or backward movement)
+            # FIXME: create a method for extracting and updating the velocity
+            # because it's somehow recurrent throughout the code.
+            velocity = results['velocity']
+            # FIXME rethink this approach of changing null & missing values.
+            velocity = self.update_null_and_missing_velocities(velocity)
+            new_spatial_index = self.update_spatial_index_from_velocity(spatial_index, velocity)
+
+            # 2.2.  Computing the distance between cells
+            # FIXME: Make it a method and add assert for verifications.
+            distance_between_cells = self.s_coords[new_spatial_index] - self.s_coords[spatial_index]
+
+            # 2.3.  Updating the time
+            # FIXME: Create a methods one for computing the time between successive cells and,
+            # another for updating the time.
+            time_delta = abs(distance_between_cells) / abs(velocity)
+            time_1 = time_0 + time_delta
+
+            # 2.4.  Correction of the results
+            temporal_index_0 = self.get_closest_simulated_time_index(time_0)
+
+            if time_1 > self.simulated_times [-1]:
+                time_1 = self.simulated_times[-1]
+            temporal_index_1 = self.get_closest_simulated_time_index(time_1)
+
+
+            # FIXME time -1 has a big issue.
+            # In case the time is bigger than the simulation time range, the time is updated to the last time step.
+            # This is the case for extremely low velocities which could lead to infinitely very long times.
+            #FIXME: clean these steps (make them cleaner)
+            if time_1 > self.simulated_times [-1] or time_1 < 0:
+                while time_1 > self.simulated_times[-1]:
+                    temporal_index_1 += 1
+                    results = self.get_closest_simulated_results(self.simulated_times[temporal_index_1], spatial_index)
+                    velocity = results['velocity']
+                    velocity = self.update_null_and_missing_velocities(velocity)
+                    time_delta = abs(distance_between_cells) / abs(velocity)
+                    time_1 = time_0 + time_delta
+                # To avoid repeating the same procedure at the next test.
+                temporal_index_0 = temporal_index_1
+
+            # temporal_index_1 = self.get_closest_simulated_time_index(time_1)
+
+            # Case for temporal indices which have been skipped (not).
+            if temporal_index_1 - temporal_index_0 > 1:
+                potential_temporal_indices = np.arange(temporal_index_0, temporal_index_1+1, 1)
+                potential_velocities = self.get_simulated_velocity(spatial_index, potential_temporal_indices) # FIXME check if it works for arrays.
+                # 2.5. Checking whether the extracted velocities are rigoursly the same.
+                # FIXME assert velocity in potential_velocities, \
+                    # f'The velocity extracted - {velocity} is not in the potential velocities - {potential_velocities}.'
+                # assert potential_velocities[0]- velocity < 1e-5, 'The velocities extracted are not the same.'
+                # 2.6. Getting the maximum velocity in the time range.
+                maximum_velocity = np.max(potential_velocities) # FIXME find  a better way to do this.
+                # 2.7. If the maximum velocity is not the previously extracted velocity which means the buoy moved faster,
+                # the temporal index is updated to the index of the maximum velocity.
+                if maximum_velocity != velocity:
+                    updated_temporal_index = potential_temporal_indices[np.argmax(potential_velocities)]
+                    # 2.8. The time and the results are updated.
+                    updated_time = self.simulated_times[updated_temporal_index]
+                    results = self.get_closest_simulated_results(updated_time, spatial_index)
+                    velocity = results['velocity']
+                    velocity = self.update_null_and_missing_velocities(velocity)
+                    # The time increment is updated.
+                    new_time_delta = abs(distance_between_cells) / abs(velocity)
+                    # The spatial index is updated (mainly the sign)
+                    new_spatial_index = self.update_spatial_index_from_velocity(spatial_index, velocity)
+                    time_1 =  time_0 + new_time_delta
+
+            # 2.9. The results are added to the dataframe.
+            buoy_data.loc[len(buoy_data.index)] ={'time': time,
+                                            'distance': distance,
+                                            'water level': results['water level'],
+                                            'water depth': results['water depth'],
+                                            'discharge': results['discharge'],
+                                            'velocity': results['velocity'],
+                                            'froude': results['froude'],
+                                            'wetted section': results['wetted section'],
+                                            'top width': results['top width']}
+
+            # 2.10. Updating the time and spatial index for the next  iteration.
+            if new_spatial_index < number_of_cells:
+                time = time_1
+                spatial_index = new_spatial_index
+                distance = self.s_coords[spatial_index]
+                # (print(f'New spatial index: {spatial_index} out of {number_of_cells}'))
+
+        return buoy_data
+
+    def get_backwards_buoy_trajectories(self,
+                              time:float,
+                              x:float,
+                              y:float,
+                              distance: float = None,
+                              number_cells = None) -> pd.DataFrame:
+        """Deprecated: Use get_buoy_backward_trajectory instead."""
+        assert time>=0 and time <= self.simulated_times[-1],\
+            f'The time must be within the simulation time range. {self.simulated_times[0]} <= time - {time} <= {self.simulated_times[-1]}'
+
+        buoy_data = pd.DataFrame(columns = ['time',
+                                            'distance',
+                                            'water level',
+                                            'water depth',
+                                            'discharge',
+                                            'velocity',
+                                            'froude',
+                                            'wetted section',
+                                            'top width'])
+
+
+
+        # 1. Definition of spatial and temporal indices
+        if distance is None and number_cells is None:
+            # all_cells = len(self.s_coords)
+            # index, s = self.project_coordinates_on_bed(x, y)
+            spatial_index, distance = self.project_coordinates_on_bed(x, y)
+            # time_0 = time
+            number_of_cells = len(self.s_coords)
+
+        # 2. Extraction of results
+
+        # while tqdm(spatial_index >= 0 and spatial_index <  number_of_cells, desc='Computing buoy trajectories', unit='cell', disable=True):
+        while tqdm(spatial_index <  number_of_cells-1 and time < self.simulated_times[-1],\
+                   desc='Computing buoy trajectories', unit='cell', disable=True):
+
+            results = self.get_closest_simulated_results(time, spatial_index)
+            time_0 = time
+
+            # 2. 1.  updating the spatial index (forard or backward movement)
+            velocity = results['velocity']
+            # FIXME rethink this approach of changing null & missing vaalues
+            velocity = self.update_null_and_missing_velocities(velocity)
+            new_spatial_index = self.update_spatial_index_from_velocity_backwards(spatial_index, velocity)
+
+            # 2.2.  Computing the distance between cells
+            distance_between_cells = self.s_coords[new_spatial_index] - self.s_coords[spatial_index]
+
+            # 2.3.  Updating the time
+            time_delta = abs(distance_between_cells) / abs(velocity)
+            time_1 = time_0 + time_delta
+
+            # 2.4.  Correction of the results
+            temporal_index_0 = self.get_closest_simulated_time_index(time_0)
+
+            if time_1 > self.simulated_times[-1]:
+                time_1 = self.simulated_times[-1]
+            elif time_1 < self.simulated_times[0]:
+                time_1 = self.simulated_times[0]
+            temporal_index_1 = self.get_closest_simulated_time_index(time_1)
+
+
+
+            # FIXME time -1 has a big issue.
+            # In case the time is bigger than the simulation time range, the time is updated to the last time step.
+            # This is the case for extremely low velocities which could lead to infinitely very long times.
+            if time_1 > self.simulated_times [-1] or time_1 < self.simulated_times[0]:
+                while time_1 > self.simulated_times[-1]:
+                    temporal_index_1 -= 1
+                    results = self.get_closest_simulated_results(self.simulated_times[temporal_index_1], spatial_index)
+                    velocity = results['velocity']
+                    velocity = self.update_null_and_missing_velocities(velocity)
+                    time_delta = abs(distance_between_cells) / abs(velocity)
+                    time_1 = time_0 + time_delta
+                # To avoid repeating the same procedure at the next test.
+                temporal_index_0 = temporal_index_1
+
+            # temporal_index_1 = self.get_closest_simulated_time_index(time_1)
+
+            # Case for temporal indices which have been skipped (not).
+            if temporal_index_0 - temporal_index_1 > 1:
+                # potential_temporal_indices = np.arange(temporal_index_0, temporal_index_1+1, 1)
+                potential_temporal_indices = np.arange(temporal_index_1, temporal_index_0+1, 1)
+                potential_velocities = self.get_simulated_velocity(spatial_index, potential_temporal_indices) # FIXME check if it works for arrays.
+                # 2.5. Checking whether the extracted velocities are rigoursly the same.
+                # FIXME assert velocity in potential_velocities, \
+                    # f'The velocity extracted - {velocity} is not in the potential velocities - {potential_velocities}.'
+                # assert potential_velocities[0]- velocity < 1e-5, 'The velocities extracted are not the same.'
+                # 2.6. Getting the maximum velocity in the time range.
+                maximum_velocity = np.max(potential_velocities) # FIXME find  a better way to do this.
+                # 2.7. If the maximum velocity is not the previously extracted velocity which means the buoy moved faster,
+                # the temporal index is updated to the index of the maximum velocity.
+                if maximum_velocity != velocity:
+                    updated_temporal_index = potential_temporal_indices[np.argmax(potential_velocities)]
+                    # 2.8. The time and the results are updated.
+                    updated_time = self.simulated_times[updated_temporal_index]
+                    results = self.get_closest_simulated_results(updated_time, spatial_index)
+                    velocity = results['velocity']
+                    velocity = self.update_null_and_missing_velocities(velocity)
+                    # The time increment is updated.
+                    new_time_delta = abs(distance_between_cells) / abs(velocity)
+                    # The spatial index is updated (mainly the sign)
+                    new_spatial_index = self.update_spatial_index_from_velocity_backwards(spatial_index, velocity)
+                    time_1 =  time_0 + new_time_delta
+
+            # 2.9. The results are added to the dataframe.
+            buoy_data.loc[len(buoy_data.index)] ={'time': time,
+                                            'distance': distance,
+                                            'water level': results['water level'],
+                                            'water depth': results['water depth'],
+                                            'discharge': results['discharge'],
+                                            'velocity': results['velocity'],
+                                            'froude': results['froude'],
+                                            'wetted section': results['wetted section'],
+                                            'top width': results['top width']}
+
+            # 2.10. Updating the time and spatial index for the next  iteration.
+            if new_spatial_index <  number_of_cells and new_spatial_index >=0:
+                time = time_1
+                spatial_index = new_spatial_index
+                distance = self.s_coords[spatial_index]
+                # (print(f'New spatial index: {spatial_index} out of {number_of_cells}'))
+
+        return buoy_data
+
+    def get_mean_values_along_trajectory(self,
+                                    time_1:float,
+                                    x_1:float,
+                                    y_1:float,
+                                    time_2:float,
+                                    x_2:float,
+                                    y_2:float
+                                    ) -> pd.DataFrame:
+        """
+        Return the mean of all simulated values along a trajectory defined by two points and two times.
+        The distance in the returned dataframe is the curvilinear distance along the river bed 
+        for each reported time step.
+
+        :param time_1: Initial time
+        :type time_1: float
+        :param x_1: X coordinate of the initial position
+        :type x_1: float
+        :param y_1: Y coordinate of the initial position
+        :type y_1: float
+        :param time_2: Final time
+        :type time_2: float
+        :param x_2: X coordinate of the final position
+        :type x_2: float
+        :param y_2: Y coordinate of the final position
+        :type y_2: float
+        """
+        assert time_1 >= 0 and time_1 <= self.simulated_times[-1],\
+            f'The time_1 must be within the simulation time range.\
+                {self.simulated_times[0]} <= time_1 - {time_1} <= {self.simulated_times[-1]}'
+
+        assert time_2 >= 0 and time_2 <= self.simulated_times[-1],\
+            f'The time_2 must be within the simulation time range.\
+                {self.simulated_times[0]} <= time_2 - {time_2} <= {self.simulated_times[-1]}'
+        assert time_2 > time_1, 'The time_2 must be greater than time_1.'
+
+        spatial_index_1, distance_1 = self.project_coordinates_on_bed(x_1, y_1)
+        spatial_index_2, distance_2 = self.project_coordinates_on_bed(x_2, y_2)
+        assert spatial_index_2 > spatial_index_1, 'The second point must be downstream the first point.'
+        temporal_index_1 = self.get_closest_simulated_time_index(time_1)
+        temporal_index_2 = self.get_closest_simulated_time_index(time_2)
+
+        results ={'distance': self.s_coords[spatial_index_1: spatial_index_2 + 1],
+                'water level': np.mean(self.water_levels[spatial_index_1: spatial_index_2 + 1, temporal_index_1: temporal_index_2 + 1], axis =1),
+                'water depth': np.mean(self.depths[spatial_index_1: spatial_index_2 + 1, temporal_index_1: temporal_index_2 + 1], axis =1),
+                'discharge': np.mean(self.discharges[spatial_index_1: spatial_index_2 + 1, temporal_index_1: temporal_index_2 + 1], axis =1),
+                'velocity': np.mean(self.velocities[spatial_index_1: spatial_index_2 + 1, temporal_index_1: temporal_index_2 + 1], axis =1),
+                'froude': np.mean(self.froudes[spatial_index_1: spatial_index_2 + 1, temporal_index_1: temporal_index_2 + 1], axis =1),
+                'wetted section':np.mean(self.wetted_sections[spatial_index_1: spatial_index_2 + 1, temporal_index_1: temporal_index_2 + 1], axis =1),
+                'top width': np.mean(self.widths[spatial_index_1: spatial_index_2 + 1, temporal_index_1: temporal_index_2 + 1], axis =1),
+                  }
+        mean_values = pd.DataFrame(results)
+        return mean_values
+
+    def get_mean_of_trajectory_variables(self,
+                                    time_1:float,
+                                    x_1:float,
+                                    y_1:float,
+                                    time_2:float,
+                                    x_2:float,
+                                    y_2:float
+                                    ) -> dict:
+        """
+        Return all simulated values along a trajectory defined by two points and two times.
+        The  curvilinear distance along the river bed for each reported time step is not returned.
+
+        :param time_1: Initial time
+        :type time_1: float
+        :param x_1: X coordinate of the initial position
+        :type x_1: float
+        :param y_1: Y coordinate of the initial position
+        :type y_1: float
+        :param time_2: Final time
+        :type time_2: float
+        :param x_2: X coordinate of the final position
+        :type x_2: float
+        :param y_2: Y coordinate of the final position
+        :type y_2: float
+        :return: A dictionary containing the mean values of the simulated variables along the trajectory.
+        :rtype: dict
+        """
+        assert time_1 >= 0 and time_1 <= self.simulated_times[-1],\
+            f'The time_1 must be within the simulation time range.\
+                {self.simulated_times[0]} <= time_1 - {time_1} <= {self.simulated_times[-1]}'
+
+        assert time_2 >= 0 and time_2 <= self.simulated_times[-1],\
+            f'The time_2 must be within the simulation time range.\
+                {self.simulated_times[0]} <= time_2 - {time_2} <= {self.simulated_times[-1]}'
+        assert time_2 > time_1, 'The time_2 must be greater than time_1.'
+
+        spatial_index_1, distance_1 = self.project_coordinates_on_bed(x_1, y_1)
+        spatial_index_2, distance_2 = self.project_coordinates_on_bed(x_2, y_2)
+        assert spatial_index_2 > spatial_index_1, 'The second point must be downstream the first point.'
+        temporal_index_1 = self.get_closest_simulated_time_index(time_1)
+        temporal_index_2 = self.get_closest_simulated_time_index(time_2)
+
+        results ={
+                'water level': np.mean(self.water_levels[spatial_index_1: spatial_index_2 + 1, temporal_index_1: temporal_index_2 + 1]),
+                'water depth': np.mean(self.depths[spatial_index_1: spatial_index_2 + 1, temporal_index_1: temporal_index_2 + 1]),
+                'discharge': np.mean(self.discharges[spatial_index_1: spatial_index_2 + 1, temporal_index_1: temporal_index_2 + 1]),
+                'velocity': np.mean(self.velocities[spatial_index_1: spatial_index_2 + 1, temporal_index_1: temporal_index_2 + 1]),
+                'froude': np.mean(self.froudes[spatial_index_1: spatial_index_2 + 1, temporal_index_1: temporal_index_2 + 1]),
+                'wetted section':np.mean(self.wetted_sections[spatial_index_1: spatial_index_2 + 1, temporal_index_1: temporal_index_2 + 1]),
+                'top width': np.mean(self.widths[spatial_index_1: spatial_index_2 + 1, temporal_index_1: temporal_index_2 + 1]),
+                  }
+
+        return results
+
+    def ___get_buoy_trajectories(self,
+                              time:float,
+                              x:float,
+                              y:float,
+                              distance: float = None,
+                              number_cells = None) -> pd.DataFrame:
+        """Deprecated: Use get_buoy_trajectories instead."""
+        assert time>=0 and time <= self.simulated_times[-1],\
+            f'The time must be within the simulation time range. {self.simulated_times[0]} <= time <= {self.simulated_times[-1]}'
+
+        buoy_data = pd.DataFrame(columns = ['time',
+                                            'distance',
+                                            'water level',
+                                            'water depth',
+                                            'discharge',
+                                            'velocity',
+                                            'froude',
+                                            'wetted section',
+                                            'top width'])
+
+
+
+        # 1. Definition of spatial and temporal indices
+        if distance is None and number_cells is None:
+            # all_cells = len(self.s_coords)
+            # index, s = self.project_coordinates_on_bed(x, y)
+            spatial_index, distance = self.project_coordinates_on_bed(x, y)
+            time_0 = time
+            number_of_cells = len(self.s_coords)
+
+        # 2. Extraction of results
+
+        # while tqdm(spatial_index >= 0 and spatial_index <  number_of_cells, desc='Computing buoy trajectories', unit='cell', disable=True):
+        while tqdm(spatial_index <  number_of_cells-1, desc='Computing buoy trajectories', unit='cell', disable=True):
+
+            results = self.get_closest_simulated_results(time, spatial_index)
+
+            # 2. 1.  updating the spatial index (forard or backward movement)
+            velocity = results['velocity']
+            new_spatial_index = self.update_spatial_index_from_velocity(spatial_index, velocity)
+
+            # 2.2.  Computing the distance between cells
+            distance_between_cells = self.s_coords[new_spatial_index] - self.s_coords[spatial_index]
+
+            # 2.3.  Updating the time
+            time_delta = abs(distance_between_cells) / abs(velocity)
+            time_1 = time_0 + time_delta
+
+            # 2.4.  Correction of the results
+            temporal_index_0 = self.get_closest_simulated_time_index(time_0)
+            temporal_index_1 = self.get_closest_simulated_time_index(time_1)
+
+            if time_1 > self.simulated_times [-1] or time_1 < 0:
+                # # temporal_index_1 =  temporal_index_0
+                time = self.simulated_times[-1]
+                time_1 = self.simulated_times[-1]
+                spatial_index =  len(self.s_coords) - 1
+
+
+                # while time_1 > self.simulated_times[-1]:
+                #     temporal_index_1 += 1
+                #     results = self.get_closest_simulated_results(self.simulated_times[temporal_index_1], spatial_index)
+                #     velocity = results['velocity']
+                #     time_delta = abs(distance_between_cells) / abs(velocity)
+                #     time_1 = time_0 + time_delta
+
+            else:
+                if temporal_index_1 - temporal_index_0 > 1:
+                    potential_temporal_indices = np.arange(temporal_index_0, temporal_index_1+1, 1)
+                    potential_velocities = self.get_simulated_velocity(spatial_index, potential_temporal_indices) # FIXME check if it works for arrays.
+                    # 2.5. Checking whether the extracted velocities are rigoursly the same.
+                    # FIXME assert velocity in potential_velocities, \
+                        # f'The velocity extracted - {velocity} is not in the potential velocities - {potential_velocities}.'
+                    # assert potential_velocities[0]- velocity < 1e-5, 'The velocities extracted are not the same.'
+                    # 2.6. Getting the maximum velocity in the time range.
+                    maximum_velocity = np.max(potential_velocities) # FIXME find  a better way to do this.
+                    # 2.7. If the maximum velocity is not the previously extracted velocity which means the buoy moved faster,
+                    # the temporal index is updated to the index of the maximum velocity.
+                    if maximum_velocity != velocity:
+                        updated_temporal_index = potential_temporal_indices[np.argmax(potential_velocities)]
+                        # 2.8. The time and the results are updated.
+                        updated_time = self.simulated_times[updated_temporal_index]
+                        results = self.get_closest_simulated_results(updated_time, spatial_index)
+                        velocity = results['velocity']
+                        # The time increment is updated.
+                        new_time_delta = abs(distance_between_cells) / abs(velocity)
+                        # The spatial index is updated (mainly the sign)
+                        new_spatial_index = self.update_spatial_index_from_velocity(spatial_index, velocity)
+                        time_1 =  time_0 + new_time_delta
+
+            # 2.9. The results are added to the dataframe.
+            buoy_data.loc[len(buoy_data.index)] ={'time': time,
+                                            'distance': distance,
+                                            'water level': results['water level'],
+                                            'water depth': results['water depth'],
+                                            'discharge': results['discharge'],
+                                            'velocity': results['velocity'],
+                                            'froude': results['froude'],
+                                            'wetted section': results['wetted section'],
+                                            'top width': results['top width']}
+
+            # 2.10. Updating the time and spatial index for the next  iteration.
+            if new_spatial_index < number_of_cells:
+                time = time_1
+                spatial_index = new_spatial_index
+
+                # (print(f'New spatial index: {spatial_index} out of {number_of_cells}'))
+
+        return buoy_data
+
+
 # --- Multiple Wolf 1D results ---
 #_________________________________
 class MultipleWolfresults_1D:
@@ -9875,6 +11641,10 @@ class MultipleWolfresults_1D:
         self.max_froude= max([model.froudes_max for model in self.models])
         self.max_water_level = max([model.water_level_ymax for model in self.models])
 
+        # grid
+        self.subdivisions_x = 1000
+        self.subdivisions_y = 2
+
     def create_graph(self, show_landmarks = False):
         """
         Create the initial figure on which other simulated results will be added.
@@ -9891,6 +11661,8 @@ class MultipleWolfresults_1D:
                                                                         save_as= self.save_as,
                                                                         figsize= self.figsize,
                                                                         alpha=self.alpha,
+                                                                        grid_x_m=self.subdivisions_x,
+                                                                        grid_y_m=self.subdivisions_y,
                                                                         show=False)
         else:
             self.graph = self.models[self.model_index].plot_variables(figures=self.figures,
@@ -9899,6 +11671,8 @@ class MultipleWolfresults_1D:
                                                                     save_as= self.save_as,
                                                                     figsize= self.figsize,
                                                                     alpha=self.alpha,
+                                                                    grid_x_m=self.subdivisions_x,
+                                                                    grid_y_m=self.subdivisions_y,
                                                                     show=False)
         # Dictionary containing each plot characteristics(plot for update, axis, figure)
         self.characteristics = self.models[self.model_index].find_figures_characteristics(self.graph,self.figures)