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

wolfhece/Model1D.py

@@ -8,6 +8,7 @@ import math
 import matplotlib.pyplot as plt
 import multiprocessing
 import numpy as np
+
 import os, warnings
 import pandas as pd
 import shutil
@@ -862,6 +863,343 @@ class Creator_1D:
         znes.myzones.pop(id)
         return znes
 
+    def place_minimum_altitude(self, zones: Zones, filename: str, save_as: str = '') -> Zones:
+        """Return a Zones object in which all altitudes below a defined treshold
+        for specific vectors (sections specified in a csv file) are raised
+        to the new altitudes.
+
+        :param zones: Zones object containing the vectors
+        :type zones: Zones
+        :param filename: .csv file containing the sections and their minimum altitudes,
+        first column is the section name and second column is the minimum altitude.
+        :type filename: str
+        :param save_as: path to the the file where the modified Zones will be saved
+        if no path is given the results is not saved but only returned , defaults to ''
+        :type save_as: str, optional
+        :return: New Zones object with the modified altitudes
+        :rtype: Zones
+        """
+        # Read the csv file as a pandas dataframe
+        # df_sections = self.read_csv_as_dataframe(filename, column_names=['section', 'altitude'])
+        df_sections = pd.read_csv(filename, names=['section', 'altitude'])
+        df_sections['section'] = df_sections['section'].astype(str)
+        # Replace the minimum altitude by comparing the altitude of each vertex to the minimum altitude
+        for zne in zones.myzones:
+            for vec in tqdm(zne.myvectors, desc='Replacing minimum altitude', colour= Colors.TQDM.value, unit='vector'):
+                if vec.myname in df_sections['section'].values:
+                    index = df_sections.index[df_sections['section'] == vec.myname][0]
+                    test =  df_sections['altitude'][index]
+                    for vert in vec.myvertices:
+                        if vert.z < test:
+                            vert.z = test
+                    if self.wx_exists:
+                        logging.info(f"Minimum altitude for {vec.myname} is now {test}")
+                    else:
+                        print(f"Minimum altitude for {vec.myname} is now {test}")
+        # Save the new Zones
+        zones.find_minmax(update=True)
+        if save_as:
+            zones.saveas(save_as)
+        return zones
+
+    def change_minimum_altitude(self, zones: Zones,filename: str, save_as: str = '') -> Zones:
+        """Return a Zones object in which all altitudes below a defined treshold
+        for specific vectors (sections specified in a csv file) are raised
+        to the new altitudes.
+
+        :param zones: Zones object containing the vectors
+        :type zones: Zones
+        :param filename: .csv file containing the sections and their minimum altitudes,
+        first column is the section name and second column is the minimum altitude.
+        :type filename: str
+        :param save_as: path to the the file where the modified Zones will be saved
+        if no path is given the results is not saved but only returned , defaults to ''
+        :type save_as: str, optional
+        :return: New Zones object with the modified altitudes
+        :rtype: Zones
+        """
+        # Read the csv file as a pandas dataframe
+        # df_sections = self.read_csv_as_dataframe(filename, column_names=['section', 'altitude'])
+        df_sections = pd.read_csv(filename, names=['section', 'altitude', 'new_altitude'])
+        df_sections['section'] = df_sections['section'].astype(str)
+        # Replace the minimum altitude by comparing the altitude of each vertex to the minimum altitude
+        for zne in zones.myzones:
+            for vec in tqdm(zne.myvectors, desc='Replacing minimum altitude', colour= Colors.TQDM.value, unit='vector'):
+                if vec.myname in df_sections['section'].values:
+                    index = df_sections.index[df_sections['section'] == vec.myname][0]
+                    test =  df_sections['altitude'][index]
+                    new_value = df_sections['new_altitude'][index]
+                    for vert in vec.myvertices:
+                        if vert.z < test:
+                            vert.z =new_value
+                    if self.wx_exists:
+                        logging.info(f"Minimum altitude for {vec.myname} has been changed to {new_value}.")
+                    else:
+                        print(f"Minimum altitude for {vec.myname} has been changed to {new_value}.")
+        # Save the new Zones
+        zones.find_minmax(update=True)
+        if save_as:
+            zones.saveas(save_as)
+        return zones
+
+    def __change_minimum_altitude(self, zones: Zones,filename: str, save_as: str = '') -> Zones:
+        """Return a Zones object in which all altitudes below a defined treshold
+        for specific vectors (sections specified in a csv file) are raised
+        to the new altitudes.
+
+        :param zones: Zones object containing the vectors
+        :type zones: Zones
+        :param filename: .csv file containing the sections and their minimum altitudes,
+        first column is the section name and second column is the minimum altitude.
+        :type filename: str
+        :param save_as: path to the the file where the modified Zones will be saved
+        if no path is given the results is not saved but only returned , defaults to ''
+        :type save_as: str, optional
+        :return: New Zones object with the modified altitudes
+        :rtype: Zones
+        """
+        # Read the csv file as a pandas dataframe
+        # df_sections = self.read_csv_as_dataframe(filename, column_names=['section', 'altitude'])
+        df_sections = pd.read_csv(filename, names=['section', 'altitude', 'new_altitude'])
+        # Replace the minimum altitude by comparing the altitude of each vertex to the minimum altitude
+        for zne in zones.myzones:
+            for vec in tqdm(zne.myvectors, desc='Replacing minimum altitude', colour= Colors.TQDM.value, unit='vector'):
+                if vec.myname in df_sections['section'].values or int(vec.myname) in df_sections['section'].values:
+
+                    try:
+                        index = df_sections.index[df_sections['section'] == vec.myname][0]
+                    except IndexError:
+                        index = df_sections.index[df_sections['section'] == int(vec.myname)][0]
+
+                    test =  df_sections['altitude'][index]
+                    new_value = df_sections['new_altitude'][index]
+                    for vert in vec.myvertices:
+                        if vert.z < test:
+                            vert.z =new_value
+                    if self.wx_exists:
+                        logging.info(f"Minimum altitude for {vec.myname} has been changed to {new_value}.")
+                    else:
+                        print(f"Minimum altitude for {vec.myname} has been changed to {new_value}.")
+        # Save the new Zones
+        zones.find_minmax(update=True)
+        if save_as:
+            zones.saveas(save_as)
+        return zones
+
+    def reverse_sense_zones(self, zones: Zones, save_as: str = '') -> Zones:
+        """Reverse the sense of the vectors in a Zones object.
+
+        :param zones: Zones object containing the vectors
+        :type zones: Zones
+        :param save_as: path to the the file where the modified Zones will be saved
+        if no path is given the results is not saved but only returned , defaults to ''
+        :type save_as: str, optional
+        :return: New Zones object with the reversed vectors
+        :rtype: Zones
+        """
+        znes = zones.deepcopy_zones()
+        for zne in znes.myzones:
+            for vec in zne.myvectors:
+                vec.myvertices.reverse()
+        znes.find_minmax(update=True)
+        if save_as:
+            znes.saveas(save_as)
+        return znes
+
+    def v_shape_cross_section(self,
+                            cross_sections: crosssections,
+                            profile_name: str,
+                            increment:float = None,
+                            zmax:float = None,
+                            save_as:str ='') -> crosssections:
+        """Create a V shape profile from a given profile in a cross section object
+        and return the new cross section object.
+        """
+
+        prof = cross_sections.get_profile(profile_name)
+        self.v_shape(prof, increment, zmax)
+        cross_sections.find_minmax(update=True)
+
+        if save_as:
+            cross_sections.saveas(save_as)
+        return cross_sections
+
+    def v_shape(self,
+                prof: profile,
+                increment = None,
+                zmax = None) -> profile:
+        sz = prof.get_sz()
+
+        # If the max height is not provided.
+        if zmax is None:
+            zmax = max(sz[1])
+        zmin = min(sz[1])
+        # Distance between point
+        height = zmax - zmin
+
+        #  To check if the number of vertices is odd or even
+        modulus = len(sz[0]) % 2
+
+        # Odd case
+        if modulus != 0:
+            start = round(len(sz[0])/2)
+            coords_mid = prof.myvertices[start -1]
+            coords_mid.z = zmin
+        # Even case
+        elif modulus == 0:
+            start = int(len(sz[0])/2)
+            coords_mid = prof.myvertices[start - 1]
+            coords_mid.z = zmin
+            coords_mid_1 = prof.myvertices[start]
+            coords_mid_1.z = zmin
+        # in case the increment is not given,the height is divided equally
+        if increment is None:
+            number_of_increment = start
+            increment = height/number_of_increment
+
+        for i in range(1, start):
+            z = zmin + (increment*i)
+            vert_1 = prof.myvertices[(start - 1) - i]
+            if modulus == 0:
+                vert_2 = prof.myvertices[(start ) + i]
+            elif modulus != 0:
+                vert_2 = prof.myvertices [(start - 1) + i]
+
+            vert_1.z = z
+            vert_2.z = z
+
+
+        prof.find_minmax()
+
+    def transform_to_rectangular_shape(self,
+                                       prof: profile,
+                                       nb_vertices: int,
+                                       zmin: float = None,
+                                       zmax: float = None):
+        sz = prof.get_sz()
+        if zmin is None:
+            zmin = min(sz[1])
+        if zmax is None:
+            zmax = max(sz[1])
+        modulus = len(sz[0]) % 2
+        if modulus != 0:
+            start = round(len(sz[0])/2)
+            coords_mid = prof.myvertices[start -1]
+            coords_mid.z = zmin
+
+        elif modulus == 0:
+            start = int(len(sz[0])/2)
+            coords_mid = prof.myvertices[start - 1]
+            coords_mid.z = zmin
+            coords_mid_1 = prof.myvertices[start]
+            coords_mid_1.z = zmin
+
+        for i in range(1,start):
+            vert_1 = prof.myvertices[(start - 1) - i]
+            if modulus == 0:
+                vert_2 = prof.myvertices[(start ) + i]
+            elif modulus != 0:
+                vert_2 = prof.myvertices [(start - 1) + i]
+            if i < nb_vertices:
+                vert_1.z = zmin
+                vert_2.z = zmin
+            else:
+                vert_1.z = zmax
+                vert_2.z = zmax
+
+        prof.find_minmax()
+
+    def rectangular_shape_cross_section(self,
+                                        cross_sections: crosssections,
+                                        profile_name: str,
+                                        nb_vertices: int,
+                                        zmin: float = None,
+                                        zmax: float = None,
+                                        save_as: str = '') -> crosssections:
+        """Create a rectangular shape profile from a given profile in a cross section object
+        and return the new cross section object.
+        """
+        prof = cross_sections.get_profile(profile_name)
+        self.transform_to_rectangular_shape(prof, nb_vertices, zmin, zmax)
+        cross_sections.find_minmax(update=True)
+        if save_as:
+            cross_sections.saveas(save_as)
+        return cross_sections
+
+    def v_shape_vector(self,
+                prof: vector,
+                increment = None,
+                zmax = None) -> vector:
+        sz = prof.get_sz()
+        if zmax is None:
+            zmax = max(sz[1])
+        zmin = min(sz[1])
+        # Distance between point
+        height = zmax - zmin
+        #  To check if the number of vertices is odd or even
+        modulus = len(sz[0]) % 2
+
+        # Odd case
+        if modulus != 0:
+            start = round(len(sz[0])/2)
+            sz[1][start] = zmin
+        # Even case
+        elif modulus == 0:
+            start = int(len(sz[0])/2)
+            sz[1][start] = zmin
+            sz[1][start+1] = zmin
+
+        # in case the increment is not given,the height is divided equally
+        if increment is None:
+            number_of_increment = len(range(start))
+            increment = height/number_of_increment
+
+    def _v_shape(self,
+                prof: profile,
+                increment = None,
+                zmax = None) -> profile:
+        sz = prof.get_sz()
+        # If the max height is not provided.
+        if zmax is None:
+            zmax = max(sz[1])
+        zmin = min(sz[1])
+        # Distance between point
+        height = zmax - zmin
+        # Reshaping the profile
+        origin = prof.get_xy_from_s(sz[0][0])
+        end = prof.get_xy_from_s(sz[0][-1])
+        sz[1] = 0
+        trace = [[origin.x, origin.y], [end.x, end.y]]
+        prof.set_sz(np.array([sz[0], sz[1]]), trace)
+        #  To check if the number of vertices is odd or even
+        modulus = len(sz[0]) % 2
+        # Odd case
+        if modulus != 0:
+            start = round(len(sz[0])/2)
+            sz[1][start] = zmin
+        # Even case
+        else:
+            start = int(len(sz[0])/2)
+            sz[1][start] = zmin
+            sz[1][start+1] = zmin
+
+        # in case the increment is not given,the height is divided equally
+        if increment is None:
+            number_of_increment = len(range(start))
+            increment = height/number_of_increment
+
+        for i in range(start):
+            sz[1][i] = zmax - increment*i
+            sz[1][-i] = sz[1][i]
+        origin = prof.get_xy_from_s(sz[0][0])
+        end = prof.get_xy_from_s(sz[0][-1])
+        # origin = prof.myvertices[0]
+        # end = prof.myvertices[-1]
+        trace = [[origin.x, origin.y], [end.x, end.y]]
+        prof.set_sz(np.array([sz[0], sz[1]]), trace)
+
+
+
     # --- Vectors - plotting methods ---
     #____________________________________
 
@@ -944,11 +1282,23 @@ class Creator_1D:
                              fig_width = 30,
                              fig_height = 10,
                              color = 'red',
-                             linewidth = 2) -> None:
+                             linewidth = 2,
+                             x_unit = '$m$',
+                             y_unit = '$m$') -> None:
         """Plot the distance between 2 parallels (for instance river width)
         as a function of their mid-vector length.
             - Id : zone index
-            - The discretization step is chosen by the user
+            - The discretization step is chosen by the user.
+
+        .. notes:: The procedure is the following:
+        From the 3 vectors of the zone, the center vector is discretized
+        based on the discretization step provided by the user (1 length unit by default).
+        The number of points is calculated as the length of the center vector divided by the discretization step.
+        the number of points selected is the smallest integer greater than the division result.
+        The newpoints  are then projected on the left and right vectors.
+        The distance between the left and right vectors is then calculated,
+        and plotted as a function of the distance along the center vector, after a postprocessing check using
+        subtrings and vectors.
 
         :param zones: `Zones` object containing the vectors,
         :type zones: Zones
@@ -961,7 +1311,7 @@ class Creator_1D:
         :param ticks_spacing: Discretization of the x axis, defaults to 1000
         :type ticks_spacing: int, optional
 
-        .. notes:: FIXME Should be an option in GUI.
+        .. notes:: FIXME Should be an option in GUI and check whether the substring step is necessary.
         .. todo:: 1) FIXME Add detailed information (legends, title, an so on) to the plot.
         .. todo:: 2) FIXME Think about a test for this method. could it be used in GUI?
         """
@@ -977,21 +1327,51 @@ class Creator_1D:
         lsc = vec2.asshapely_ls()
         lsr = vec3.asshapely_ls()
         lss= [lsl,lsc,lsr] # FIXME
+
+        # Visual idea of the river as linestrings
+        # lsl _________________________
+
+        # lsc -------------------------
+
+        # lsr _________________________
+
         #Number of points
         nb = int(np.ceil(lsc.length/discretization))
         #Adimensional distances along center vector
         sloc = np.linspace(0.,1.,nb,endpoint=True)
+
+        # Visual idea of the adimendsional riverbed rediscretized with equidistant points
+        # 0|-----|-----|-----|-----|1
+
         #Points along center vector
         ptsc = [lsc.interpolate(curs,True) for curs in sloc]
+
+        # Visual idea of the riverbed rediscretized with equidistant points
+        # lsc0|-----|-----|-----|-----|lscf
+
         #Real distances along left, right and center vector
         sl = [lsl.project(curs) for curs in ptsc]
         sr = [lsr.project(curs) for curs in ptsc]
         sc = [lsc.project(curs) for curs in ptsc]
+
+        # Visual idea of the river rediscretized with equidistant points (projection of those points on banks)
+
+        # lsl0|_____|_____|_____|_____|lslf
+
+        # lsc0|-----|-----|-----|-----|lscf
+
+        # lsr0|_____|_____|_____|_____|lsrf
+
         # Zones of polygones
         zonepoly1 = zone(name='polygons_1')
         zonepoly2 = zone(name='polygons_2')
         left = []
         right = []
+        # For consistency reasons, the distance between 2 successive points is converted
+        # to substring and then each point of the substring is stored as a vertex.
+        # The operation is done at both banks at the same time,
+        # therefore, each vertex has it corresponding point on the other bank.
+        # The point are then stored in 2 vectors from which the distance is computed since the number of vertex is the same.
 
         for i in range(len(sl)-1):
             #mean distance along center will be stored as Z value of each vertex
@@ -1049,8 +1429,8 @@ class Creator_1D:
 
         ax.set_ylim(min(width)-0.5, max(width)+0.5)
         ax.set_xlim(0,max(sc))
-        ax.set_ylabel('Width ($m$)', fontsize='large' )
-        ax.set_xlabel('Length ($m$)', fontsize='large')
+        ax.set_ylabel(f'Width [{y_unit}]', fontsize='large' )
+        ax.set_xlabel(f'Length [{x_unit}]', fontsize='large')
         ax.xaxis.set_major_locator(MultipleLocator(ticks_spacing))
         ax.xaxis.set_major_formatter('{x:.0f}')
         ax.xaxis.set_minor_locator(MultipleLocator(ticks_spacing/5))
@@ -1346,7 +1726,7 @@ class Creator_1D:
             else:
                 raise Exception('An error occured while extracting the WolfArrays from the VRT file.')
 
-    
+
 
     # # --- Vector + Arrays Get values from array (Vector + Arrays) ---
     #__________________________________________________________________
@@ -1968,6 +2348,7 @@ class Creator_1D:
         """
         Return the HSPW relations (Initial Conditions) of all profiles
         as a numpy arrray for a given water depth or a given altitude.
+        np.array
 
         :param crosses: List of cross sections
         :type crosses: list[list[profile]]
@@ -2577,16 +2958,20 @@ class Creator_1D:
         :rtype: None
         """
         # Files
+        # Implemented to write only the qini file
         file_aini = self.initialize_file(save_as, fileExtensions.AINI.value)
         file_zini = self.initialize_file(save_as, fileExtensions.ZINI.value)
         file_hini = self.initialize_file(save_as, fileExtensions.HINI.value)
         file_qini = self.initialize_file(save_as, fileExtensions.QINI.value)
+
         if '.aini' in file_choice:
             self.write_file_from_np_array(file_aini,  ic, [0, 1, 2, 3], nb_updates=nb_updates, desc= 'Writing aini:')
         if '.zini' in file_choice:
             self.write_file_from_np_array(file_zini,  ic, [0, 1, 2, -1], nb_updates=nb_updates, desc ='Writing zini:')
         if '.hini' in file_choice:
             self.write_file_from_np_array(file_hini,  ic, [0, 1, 2, -2], nb_updates=nb_updates, desc = 'Writing hini:')
+
+        # qini
         self.write_file_from_np_array(file_qini,  ic, [0, 1, 2], nb_updates=nb_updates, desc= 'Writing qini:', force_last=True, q=q)
 
     def write_lengthsvecz_file(self,
@@ -2777,8 +3162,8 @@ class Creator_1D:
         :rtype: list[list[list,list]]
         """
         data = pd.read_csv(file,header=0, delimiter='\t',names=['time','discharge'])
-        hydroraph = [[list(data['time']), list(data['discharge'])]]
-        return hydroraph
+        hydrograph = [[list(data['time']), list(data['discharge'])]]
+        return hydrograph
 
     def _write_infiltrations(self,
                              selected_profiles:list[str],
@@ -3216,6 +3601,7 @@ class Creator_1D:
         """
         # FIXME add an option to select the middle of the crossection instead of just the bottom.
         # FIXME delete discretization from all examples and from this method. It's not used
+
         # Creation of files
         vecz_file = self.initialize_file(save_as,'.vecz')
         vec_file = self.initialize_file(save_as,'.vec')
@@ -3331,8 +3717,10 @@ class Creator_1D:
 
         assert prof.banksbed_postype == postype.BY_VERTEX
         # FIXME insert a test checking the intersections between profiles and parallels.
+        assert isinstance(left_inter, Point), f'The section: {prof.myname} - left intersection is not a Point but a {type(left_inter)}'
         prof.bankleft = wolfvertex(left_inter.x, left_inter.y, left_inter.z)
         prof.bed = wolfvertex(bed_inter.x, bed_inter.y, bed_inter.z)
+        assert isinstance(right_inter, Point), f'The section: {prof.myname} - left intersection is not a Point but a {type(right_inter)}'
         prof.bankright = wolfvertex(right_inter.x, right_inter.y, right_inter.z)
         prof.find_minmax()
 
@@ -3987,8 +4375,8 @@ class Creator_1D:
         """
         splitted_path = os.path.split(batch_file)
         directory = splitted_path[0]
-        command = f"start cmd.exe /k {batch_file}"
-        shell_window = subprocess.Popen(command, shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE, stdin=subprocess.PIPE)
+        command = f'start cmd.exe /k "{batch_file}"'
+        subprocess.Popen(command, shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE, stdin=subprocess.PIPE)
 
         if self.wx_exists:
             logging.info(f'{directory} Check the new shell window.\nThe simulation is running...')
@@ -4096,7 +4484,7 @@ class Creator_1D:
                     break
                 print(l)
 
-    def _run_bat_files(self, bat_file, force_cwd = False):
+    def _run_bat_files(self, bat_file, force_cwd = False, initial_condition = False):
         """
         Run the .bat file in a windows shell
         to start the computations (simulation).
@@ -4105,12 +4493,18 @@ class Creator_1D:
         :type batch_file: str
         :param force_cwd: Force current working directory, defaults to False
         :type force_cwd: bool, optional
-        FIXME Deprecated.
         """
         splitted_path = os.path.split(bat_file)
         directory = splitted_path[0]
         simulation_name = splitted_path[1]
-        logging.warn(f'{simulation_name} running... \nThe process may take time.')
+        if initial_condition:
+            if self.wx_exists:
+                logging.info(f'{simulation_name} running... \nComputing initial conditions.')
+            else:
+                logging.warn(f'{simulation_name} running... \nComputing initial conditions.')
+        else:
+            logging.warn(f'{simulation_name} running... \nThe process may take time.')
+
         if force_cwd:
             directory = os.path.split(bat_file)[0]
             run = subprocess.run(bat_file, shell=True, capture_output= True, text=True,cwd=directory )
@@ -4864,10 +5258,9 @@ class Creator_1D:
             bank_file = banks
             bank_file.saveas(directory + '\\banks.vecz')
 
-        # Polygons
+
         # FIXME is it necessery  to have parallels (next round), is it only for cell size or a better used could be found?
-        if isinstance(parallels, Zones):
-            polygons = self.create_polygons(parallels, discretisation, polygon_number, directory)
+
 
         # Write the tabulated relations of each cross section (profile)
         write_relations = self.write_relations_profiles(sorted_crosssections, directory)
@@ -4884,7 +5277,10 @@ class Creator_1D:
                 # FIXME to be verified issue with the extent of profiles
                 # (the number of new polygons is different from the number of digitized profiles)
                 # May be a test should be implemented on each profiles (probable solution).
-                roughnesses = self.roughness_from_polygons(roughness, polygons, mode=roughness_selection)
+                if isinstance(parallels, Zones):
+                    # Polygons
+                    polygons = self.create_polygons(parallels, discretisation, polygon_number, directory)
+                    roughnesses = self.roughness_from_polygons(roughness, polygons, mode=roughness_selection)
 
         roughness_file = self.write_roughnesses(roughnesses, directory)
 
@@ -4913,6 +5309,11 @@ class Creator_1D:
         # Write the .vec file (discretization file of the simulation topography - midriver)
         vec_file2 = self.write_vector_files(sorted_crosssections, save_as=directory, which_type='vec')
 
+        # Write the generic file
+        genfile = self.write_generic_file(directory)
+
+        #-----------------------------------------------------------
+
         # Write the infiltrations
         if isinstance(hydrographs, dict):
             infil = self.write_infiltrations_from_dict(sorted_crosssections,
@@ -4928,6 +5329,35 @@ class Creator_1D:
                                             writing_type_infiltration,
                                             epsilon_infiltration)
 
+
+
+        # Update the distribution of initial discharges from the infiltrations
+        self.update_qini_file_from_infiltration_dict(hydrographs, directory)
+
+        # 22. Compute a steady state solution
+        #---------------------------------------------------------------
+        if steady == 'precomputation':
+            # The first batch file is used to compute the steady state solution
+            bat_file = self.write_batch_file(directory_of_executable = exe_file,
+                                                directory_simulation= directory,
+                                                simulation_name= simulation_name)
+            self.start_from_steady_state(directory)
+            batch_file = self.write_batch_file(directory_of_executable = exe_file,
+                                           directory_simulation = directory,
+                                           simulation_name = simulation_name,
+                                           wetdry = wetdry,
+                                           steady ='no precomputation',
+                                           executable_type = executable_type)
+        else:
+            batch_file = self.write_batch_file(directory_of_executable = exe_file,
+                                           directory_simulation = directory,
+                                           simulation_name = simulation_name,
+                                           wetdry = wetdry,
+                                           steady = steady,
+                                           executable_type = executable_type)
+
+        #------------------------------
+
         # write the simulation parameters
         if write_in == 'times':
             write_type = 2
@@ -4935,25 +5365,69 @@ class Creator_1D:
             write_type = 1
         if self.wx_exists == None:
             param = self.write_parameters(directory, write_freq= output_frequency, write_type= write_type, max_time=time)
-        # # if steady == 'precomputation' or steady == 'steady':
-        # #     self.correct_parameters(directory, from_steady=True)
-        # # else:
-        # #     self.correct_parameters(directory)
-        # self.correct_parameters(directory) FIXME for other cases when the GUI is not used
 
-        genfile = self.write_generic_file(directory)
-        batch_file = self.write_batch_file(directory_of_executable = exe_file,
-                                           directory_simulation = directory,
-                                           simulation_name = simulation_name,
-                                           wetdry = wetdry,
-                                           steady = steady,
-                                           executable_type = executable_type)
+
         if run_simulation == 'yes':
             # logging.warn(f'{simulation_name} running... \nThe process may take time.')
             self.run_bat_files(batch_file)
             # logging.warn(f'{simulation_name} completed.')
         return (directory,simulation_name, sorted_crosssections, ic_relations, nb_updates)
 
+    def find_file_from_extension(self, directory:str, file_extension:str) -> str:
+        """Return a file in a directory based on its extension.
+
+        :param directory: file path to the folder
+        :type directory: str
+        :param file_extension: file extension
+        :type file_extension: str
+        :return: file path
+        """
+        for file in os.listdir(directory):
+            if file.endswith(file_extension):
+                return os.path.join(directory, file)
+
+        raise Exception(f'No file with the extension {file_extension} was found in the directory {directory}.')
+
+    def start_from_steady_state(self, directory:str, plot = True):
+        """Compute the steady state solution and update the initial conditions based on the results.
+
+        :param directory: directory (simulation folder)
+        :type directory: str
+        :param plot: wheter the process should open a matplotlib figure
+        containing the steady state solution or not, defaults to True
+        :type plot: bool, optional
+        """
+        self.write_parameters(directory, write_type= 2, max_time=0)
+        bat_file = self.find_file_from_extension(directory, '.bat')
+        self._run_bat_files(bat_file, initial_condition= True)
+        # self.run_bat_files(bat_file)
+        self.update_initial_conditions_from_results(directory, time_step=1, plot=plot)
+
+    def update_initial_conditions_from_results(self,
+                                               directory:str,
+                                               time_step:int =1,
+                                               plot:bool = True):
+        results = Wolfresults_1D(directory)
+
+        if plot:
+            results.plot_variables(figures=['water level','discharge', 'froude','water depth','velocity','wetted section' ]
+                                   ,time_step=time_step, grid_x_m= 1000)
+            self.log_message('Proposed initial conditions plotted.')
+
+        results.update_ic_from_time_steps(time_step)
+        self.log_message('New initial conditions.')
+
+    def log_message(self, message:str):
+        """Message for the user.
+
+        :param message: message
+        :type message: str
+        """
+        if self.wx_exists:
+            logging.info(message)
+        else:
+            print(message)
+
     def create_multiple_simulations_from_csv(self,
                                             csv_filename:str,
                                             folder_path:str,
@@ -5125,7 +5599,7 @@ class Creator_1D:
                 infiltrations.append(infiltration)
         return infiltrations
 
-    def _create_simulations_from_csv(self,
+    def create_simulations_from_csv(self,
                                     csv_filename:str,
                                     folder_path:str,
                                     cross_sections: crosssections,
@@ -5133,8 +5607,8 @@ class Creator_1D:
                                     banks: Zones,
                                     boundary_conditions: dict,
                                     roughness:Union[float,WolfArray],
-                                    hydrographs: list[list[list]],
                                     exe_file:str,
+                                    hydrographs: list[list[list]] = None,
                                     topography: WolfArray = None,
                                     initial_discharge:float = None,
                                     simulation_name:str = 'simul',
@@ -5157,18 +5631,78 @@ class Creator_1D:
                                     writing_type_infiltration: Literal['continuous', 'stepwise'] = 'continuous',
                                     epsilon_infiltration:float = 0.01,
                                     force_steady = True) -> None:
-        """Deprecated"""
-
-        infiltrations = self.read_csv_as_infiltrations(csv_filename)
-        names = self.read_csv_as_dataframe(csv_filename)
+        """
+        Create simulations from a csv file.
 
-        # # df = self.read_csv_as_dataframe(csv_filename,column_names=['discharge'])
-        # # discharge = df['discharge'][0]
+        :param csv_filename: Csv filename
+        :type csv_filename: str
+        :param folder_path: Folder path
+        :type folder_path: str
+        :param cross_sections: Cross sections
+        :type cross_sections: crosssections
+        :param parallels: Parallels
+        :type parallels: Zones
+        :param banks: Banks
+        :type banks: Zones
+        :param boundary_conditions: Boundary conditions
+        :type boundary_conditions: dict
+        :param roughness: Roughness
+        :type roughness: Union[float,WolfArray]
+        :param exe_file: Exe file
+        :type exe_file: str
+        :param hydrographs: Hydrographs, defaults to None
+        :type hydrographs: list[list[list]], optional
+        :param topography: Topography, defaults to None
+        :type topography: WolfArray, optional
+        :param initial_discharge: Initial discharge, defaults to None
+        :type initial_discharge: float, optional
+        :param simulation_name: Simulation name, defaults to 'simul'
+        :type simulation_name: str, optional
+        :param discretisation: Discretisation, defaults to 10.
+        :type discretisation: float, optional
+        :param extrapolation_of_extremities: Extrapolation of extremities, defaults to 100.
+        :type extrapolation_of_extremities: float, optional
+        :param initial_depth: Initial depth, defaults to 1.
+        :type initial_depth: float, optional
+        :param write_in: Write in, defaults to 'times'
+        :type write_in: Literal['iterations', 'times'], optional
+        :param output_frequency: Output frequency, defaults to 900
+        :type output_frequency: int, optional
+        :param polygon_number: Polygon number, defaults to 1
+        :type polygon_number: int, optional
+        :param code_verbosity_profile: Code verbosity profile, defaults to [1]
+        :type code_verbosity_profile: list, optional
+        :param simulation_time: Simulation time, defaults to None
+        :type simulation_time: int, optional
+        :param roughness_option: Roughness option, defaults to 'under_profile'
+        :type roughness_option: Literal['under_profile', 'under_polygons'], optional
+        :param roughness_selection: Roughness selection, defaults to 'mean'
+        :type roughness_selection: Literal['min','mean','median','max'], optional
+        :param file_type_initial_cond: File type initial cond, defaults to '.aini'
+        :type file_type_initial_cond: Literal['.aini','.hini','.zini'], optional
+        :param infiltration_profiles: Infiltration profiles, defaults to ['1']
+        :type infiltration_profiles: list, optional
+        :param wetdry: Wetdry, defaults to 'evolutive'
+        :type wetdry: Literal['fixed', 'evolutive'], optional
+        :param steady: Steady, defaults to 'precomputation'
+        :type steady: Literal['no precomputation', 'precomputation', 'steady'], optional
+        :param executable_type: Executable type, defaults to 'wolfcli'
+        :type executable_type: Literal['wolfcli', 'wolfclid'], optional
+        :param run_simulation: Run simulation, defaults to 'no'
+        :type run_simulation: Literal['yes', 'no'], optional
+        :param writing_type_infiltration: Writing type infiltration, defaults to 'continuous'
+        :type writing_type_infiltration: Literal['continuous', 'stepwise'], optional
+        :param epsilon_infiltration: Epsilon infiltration, defaults to 0.01
+        :type epsilon_infiltration: float, optional
+        :param force_steady: Force steady, defaults to True
+        :type force_steady: bool, optional
+        """
+        df = self.read_csv_as_dataframe(csv_filename,column_names=['discharge'])
+        discharge = df['discharge'][0]
         # hydrograph = Hydrograph({0:discharge})
         if force_steady:
-                hydrographs = infiltrations[0]
                 # hydrographs = {}
-                # hydrographs =[[[0],[discharge]]]
+                hydrographs =[[[0],[discharge]]]
         original_simulation =self.write_simulation_files_from_crosssections(folder_path,
                                                             cross_sections,
                                                             parallels,
@@ -5178,7 +5712,7 @@ class Creator_1D:
                                                             hydrographs,
                                                             exe_file,
                                                             topography,
-                                                            initial_discharge,
+                                                            discharge,
                                                             simulation_name,
                                                             discretisation,
                                                             extrapolation_of_extremities,
@@ -5200,15 +5734,19 @@ class Creator_1D:
                                                             epsilon_infiltration = epsilon_infiltration)
         procedures =[]
 
-        for new_infiltration in infiltrations:
-            hydrographs = new_infiltration
-            values = list(new_infiltration.values())
-            extension =f'_Q{int(values[0])}' # FIXME
-            new_sim = self.copy_simulation_files(original_simulation[0],original_simulation[0] + extension)
+        new_sims =[]
+        for new_discharge in list(df['discharge']):
+            hydrographs =[[[0],[new_discharge]]]
+
+            extension =f'_Q{int(new_discharge)}'
+            new_sim_name = original_simulation[0] + extension
+            new_sim = self.copy_simulation_files(original_simulation[0],new_sim_name, ignore_filetype='*.bat')
+            new_sims.append(new_sim)
+
 
             self.write_ini_files(original_simulation[3],
                                  new_sim,
-                                 new_infiltration,
+                                 new_discharge,
                                  original_simulation[4],
                                  file_choice=file_type_initial_cond)
 
@@ -5224,7 +5762,6 @@ class Creator_1D:
                                 new_name=simulation_name + extension)
             procedures.append(new_batchfile)
 
-
             # # procedure = multiprocessing.Process(target= run_batch_file_multiprocess, args = (new_batchfile))
             # # procedure.start()
             # procedures.append(new_batchfile)
@@ -5232,48 +5769,762 @@ class Creator_1D:
             #     self.run_batch_file(new_batchfile)
             #     # procedure.start()
 
+        batch_file_group = self.write_batch_simulations(directory_of_executable = exe_file,
+                                                       simulations_path=new_sims,
+                                                       wetdry = wetdry,
+                                                       steady = steady,
+                                                       executable_type = executable_type)
+
         if run_simulation == 'yes':
-            runs=[self.run_batch_file(i) for i in tqdm(procedures,'Running simulations', colour= Colors.TQDM.value)]
-            # # pool = multiprocessing.Pool(processes=len(procedures))
+            # runs=[self.run_batch_file(i) for i in tqdm(procedures,'Running simulations', colour= Colors.TQDM.value)]
+            # run = self.run_batch_file(batch_file_group)
+            run = self.run_bat_files(batch_file_group)
+            # # pool = multiprocessing.Pool(processes=len(procedures))
+            # runs=[multiprocessing.Process(run_batch_file_multiprocess, args=i) for i in tqdm(procedures)]
+
+    def copy_simulation_files(self,
+                              simulation:str,
+                              save_as:str,
+                              ignore_filetype: Literal['.*qini','*.aini', '*.zini','*.hini','*.cl', '*.rough', 'infil*','*.inf'
+                                                            '*.infil','*.param','*.top','*.ptv','*.gtv','.log', '.count'
+                                                            '*.HEAD','*.RA', '*.RB','*.RQ','*.RS','*.vecz','*.vec','*.txt', '*.bat'] = '') -> str:
+        """
+        Copy simulation files.
+
+        :param simulation: Simulation
+        :type simulation: str
+        :param save_as: Save as
+        :type save_as: str
+        :param ignore_filetype: Ignore filetype, defaults to ''
+        :type ignore_filetype: str, optional
+        :return: Copied directory
+        :rtype: str
+        """
+        if ignore_filetype != '':
+            try:
+                copied_directory = shutil.copytree(src = simulation, dst= save_as)
+            except FileExistsError:
+                # os.rmdir(save_as)
+                # copied_directory = shutil.copytree(src = simulation, dst= save_as)
+                raise Exception(f"The file named ({save_as}) exists already.\n Rename the new file or delete the existing file.")
+        else:
+            try:
+                copied_directory = shutil.copytree(src = simulation, dst= save_as, ignore=shutil.ignore_patterns(ignore_filetype))
+            except FileExistsError:
+                # os.rmdir(save_as)
+                # copied_directory = shutil.copytree(src = simulation, dst= save_as, ignore=shutil.ignore_patterns(ignore_filetype))
+                raise Exception(f"The file named ({save_as}) exists already.\n Rename the new file or delete the existing file.")
+        return copied_directory
+
+    def copy_multiple_simulations_from_csv(self, csv_filename:str, simulation:str) -> None:
+        """
+        Copy multiple simulations from a csv file.
+
+        :param csv_filename: Csv filename
+        :type csv_filename: str
+        :param simulation: Simulation
+        :type simulation: str
+        """
+
+        df = self.read_csv_as_dataframe(csv_filename,column_names=['discharge'])
+        lgth = df.shape[0]
+        for discharge in tqdm(df['discharge']):
+            self.copy_simulation_files(simulation, simulation + f'_Q{discharge}')
+
+    def distribute_values_as_sum(self, array: np.ndarray) -> np.ndarray:
+        """Return a 1D array were the 0 are filled with the previous value in the table, and
+        the existing values are replaced by their summed with the previous value in the table.
+
+        :param array: Array(1D) containing the vaalues of the initial discharge at specific profiles
+        :type array: np.ndarray
+        :return: Updated array
+        :rtype: np.ndarray
+        """
+        for i in range(len(array) - 1):
+            j = i + 1
+            if array[j] == 0:
+                array[j] = array[i]
+            elif  array[i] != 0:
+                array[j] += array[i]
+        return array
+
+    def find_qini_values_from_infiltration_dict(self, infiltration:dict) -> dict:
+        """
+        Return a dictionnary  containing the infiltration profiles and their initial discharge (first value).
+
+        These dictionnary can be used
+
+        :param infiltration: Infiltration
+        :type infiltration: dict
+        :return: Initial infiltrations
+        :rtype: dict
+        """
+
+        keys = []
+        values =[]
+        initial_infiltrations = {}
+        for key in infiltration:
+            if isinstance(infiltration[key], Hydrograph):
+                qini = infiltration[key].values[0]
+            elif isinstance(infiltration[key], (list,tuple)):
+                qini = infiltration[key][0]
+            elif isinstance(infiltration[key], (float,int)):
+                qini = infiltration[key]
+            else:
+                raise Exception('The initial discharge is not well defined.')
+            initial_infiltrations[int(key)-1] = qini
+
+        return initial_infiltrations
+
+    def compute_qini_values_from_infiltrations_dict(self,
+                                                   infiltrations: dict,
+                                                   nb_cells: int) -> np.ndarray:
+        """Compute the initial discharge from a dictionary of infiltrations.
+        The method returns an array of initial discharges. The array values are
+        distributed from the distribution (linear sum) of the first infiltration values.
+
+        :param infiltrations: Infiltrations (dictionnary of hydrographs)
+        :type infiltrations: dict
+        :param nb_cells: Number of cells
+        :type nb_cells: int
+        :return: Initial discharges
+        :rtype: np.ndarray
+        """
+        qini_values = np.zeros(nb_cells)
+        initial_infiltrations = self.find_qini_values_from_infiltration_dict(infiltrations)
+        for key in initial_infiltrations:
+            qini_values[key] = initial_infiltrations[key]
+
+        qini_values = self.distribute_values_as_sum(qini_values)
+        # print(qini_values)
+        return qini_values
+
+    def update_qini_file_from_infiltration_dict(self,
+                                                infiltrations: dict,
+                                                directory:str):
+        """Upadte the qini file from a dictionary of infiltrations.
+
+        :param infiltrations: Infiltrations
+        :type infiltrations: dict
+        :param directory: Directory (folder)
+        :type directory: str
+        """
+        # Find the qini file from the simulation directory
+        qini_file = self.find_file_from_extension(directory, '.qini')
+        # Read the qini file as a  pandas dataframe
+        qini_dataframe = self.read_ini_file_as_dataframe(qini_file)
+        # Find the number of cells in the simulation
+        number_of_cells = len(qini_dataframe['value'])
+        # Compute the qini values from the infiltrations dictionary
+        qini = self.compute_qini_values_from_infiltrations_dict(infiltrations, number_of_cells)
+        # Update the qini file with the computed values
+        self.update_ini_file(qini_file, qini)
+
+    def read_ini_file_as_dataframe(self, ini_file:str):
+        """Read an ini file and return a pandas dataframe.
+
+        :param ini_file: File of initial conditions
+        :type ini_file: str
+        :return: Pandas dataframe
+        :rtype: pd.DataFrame
+        """
+        dataframe = pd.read_csv(ini_file,
+                         sep= Constants.SEPARATOR.value,
+                         skiprows=1,
+                         names=['skeleton', 'zone', 'segment','value']
+                         )
+        return dataframe
+
+    def update_ini_file(self, ini_file:str, new_values: np.ndarray)-> None:
+        """Update the initial condition file with new values.
+        The method reads the initial condition file as a pandas dataframe,
+        then replace old the values by the new values.
+
+        :param ini_file: File of initial condition
+        :type ini_file: str
+        :param new_values: New values
+        :type new_values: np.ndarray
+        """
+        df = self.read_ini_file_as_dataframe(ini_file)
+        lgth_values = len(df['value'])
+        lgth_new_values = len(new_values)
+        assert lgth_values == lgth_new_values,\
+            f"The length of the new values - {lgth_new_values} is not consistent with the initial condition file - {lgth_values}."
+
+        df['value'] = new_values
+        sep = Constants.SEPARATOR.value
+        with open(ini_file, 'w') as f:
+            f.write(f"{lgth_new_values}\n")
+            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")
+
+        # Implement a clever way of writing or updating this file from ic or existing files.
+        # check wolfresults_1D update ini file or find another way to update the file.
+
+
+    # --- Outdated methods ---
+    #_________________________
+
+    def __write_batch_file(self,
+                         directory_of_executable:str,
+                         directory_simulation:str,
+                         simulation_name:str,
+                         wetdry:Literal['fixed', 'evolutive']='evolutive',
+                         steady:Literal['no precomputation', 'precomputation', 'steady'] = 'precomputation',
+                         executable_type: Literal['wolfcli', 'wolfclid'] = 'wolfcli',
+                         different_names=False,
+                         new_name:str =''
+                         ) -> str:
+        if different_names:
+            batch_file =self.initialize_file(directory_of_executable, f'{new_name}.bat','') # To avoid simul name FIXME make it clean
+        else:
+            batch_file =self.initialize_file(directory_of_executable, '.bat')
+
+
+
+        if wetdry == 'fixed':
+            wtd = 0
+        elif wetdry == 'evolutive':
+            wtd= 1
+
+        if steady== 'precomputation':
+            std= 1
+        elif steady == 'no precomputation':
+            std = 0
+        elif steady == 'steady':
+            std=2
+
+        find_full_path ='%~dp0'
+        with open(batch_file,'w') as bat:
+            bat.write(f'cd "{directory_of_executable}"\n')
+            # bat.write(f'{executable_type} run_wolf1d dirin="%~dp0{simulation_name}" in="{simulation_name}" wetdry={wtd} steady={std}')
+            if different_names:
+                bat.write(f'{executable_type} run_wolf1d dirin="{find_full_path}{new_name}" in="{simulation_name}" wetdry={wtd} steady={std}')
+                # if directory_simulation[0] =='.':
+                #     bat.write(f'{executable_type} run_wolf1d dirin="{find_full_path}{directory_simulation}" in="{simulation_name}" wetdry={wtd} steady={std}')
+                # else:
+                #     bat.write(f'{executable_type} run_wolf1d dirin="{find_full_path}{directory_simulation}" in="{simulation_name}" wetdry={wtd} steady={std}')
+
+            else:
+                bat.write(f'{executable_type} run_wolf1d dirin="{find_full_path}{simulation_name}" in="{simulation_name}" wetdry={wtd} steady={std}')
+
+        return batch_file
+
+    def match_ends_2vectors_outdated(self,
+                            zones1: Zones,
+                            zones2: Zones,
+                            id1:int = 0,
+                            id2:int = 0) -> Zones:
+        """
+        Aligns the vertices of  2 successive zone
+        containing each 3 vectors (1 vector and its 2 parallels),
+        so that, the end of each vector matches the begining of its corresponding in the other zone.
+            - id1: zone id in zones1.myzones,
+            - id2: zone id in zones2.myzones.
+        """
+        znes1 = zones1
+        znes2 = zones2
+        vector1_1 = znes1.myzones[id1].myvectors[0]
+        vector1_2 = znes1.myzones[id1].myvectors[1]
+        vector1_3 = znes1.myzones[id1].myvectors[2]
+        vector2_1 = znes2.myzones[id2].myvectors[0]
+        vector2_2 = znes2.myzones[id2].myvectors[1]
+        vector2_3 = znes2.myzones[id2].myvectors[2]
+        i = vector1_1.myvertices
+        j = vector2_1.myvertices
+
+        distance1 = math.sqrt(((i[-1].x - j[0].x)**2) + ((i[-1].y - j[0].y)**2)) #last point - first point
+        distance2 = math.sqrt(((i[-1].x - j[-1].x)**2) + ((i[-1].y - j[-1].y)**2)) #last point - last point
+        distance1_r = math.sqrt(((i[0].x - j[0].x)**2) + ((i[0].y - j[0].y)**2)) # first point - first point
+        distance2_r = math.sqrt(((i[0].x - j[-1].x)**2) + ((i[0].y - j[-1].y)**2)) #first point - last point
+
+        all = [distance1, distance2, distance1_r, distance2_r]
+
+        if min(all) == distance2:
+            vector2_1.myvertices.reverse()
+            vector2_2.myvertices.reverse()
+            vector2_3.myvertices.reverse()
+
+        elif min(all) == distance1_r:
+            vector1_1.myvertices.reverse()
+            vector1_2.myvertices.reverse()
+            vector1_3.myvertices.reverse()
+
+        elif min(all) ==distance2_r:
+            vector1_1.myvertices.reverse()
+            vector1_2.myvertices.reverse()
+            vector1_3.myvertices.reverse()
+            vector2_1.myvertices.reverse()
+            vector2_2.myvertices.reverse()
+            vector2_3.myvertices.reverse()
+
+        return znes1, znes2
+
+    def __save_as_1D_crossections(self,
+                                  zones: Zones,
+                                  format ='vecz',
+                                  save_as: str='') -> crosssections:
+        znes = zones
+        path = save_as + 'profiles' + id +'.vecz'
+        index = 1
+        for vec in znes.myzones[0].myvectors:
+            vec.myname = '%s'%(index)
+            index+=1
+
+        znes.find_minmax()
+        znes.saveas(path)
+        cross= crosssections(mydata= path,format='vecz')
+        cross.format = format
+        if save_as:
+            cross.saveas(save_as)
+        return cross
+
+    def __update_qini_file_from_infiltration_dict(self,
+                                                infiltrations: dict,
+                                                directory:str):
+        """Deprecating due to the last for loop (it's obviously a code duplication)."""
+
+        qini_file = self.find_file_from_extension(directory, '.qini')
+        qini_dataframe = self.read_ini_file_as_dataframe(qini_file)
+        number_of_cells = len(qini_dataframe['value'])
+        qini = self.compute_qini_values_from_infiltrations_dict(infiltrations, number_of_cells)
+        for file in os.listdir(directory):
+            if file.endswith('.qini'):
+                qini_file = os.path.join(directory, file)
+                self.update_ini_file(qini_file, qini)
+
+    def _create_simulations_from_csv(self,
+                                    csv_filename:str,
+                                    folder_path:str,
+                                    cross_sections: crosssections,
+                                    parallels: Zones,
+                                    banks: Zones,
+                                    boundary_conditions: dict,
+                                    roughness:Union[float,WolfArray],
+                                    hydrographs: list[list[list]],
+                                    exe_file:str,
+                                    topography: WolfArray = None,
+                                    initial_discharge:float = None,
+                                    simulation_name:str = 'simul',
+                                    discretisation:float = 10.,
+                                    extrapolation_of_extremities:float = 100.,
+                                    initial_depth:float = 1.,
+                                    write_in: Literal['iterations', 'times'] = 'times',
+                                    output_frequency:int = 900,
+                                    polygon_number:int = 1,
+                                    code_verbosity_profile: list = [1],
+                                    simulation_time:int = None,
+                                    roughness_option: Literal['under_profile', 'under_polygons']= 'under_profile',
+                                    roughness_selection:Literal['min','mean','median','max'] = 'mean',
+                                    file_type_initial_cond: Literal['.aini','.hini','.zini'] = '.aini',
+                                    infiltration_profiles:list =['1'],
+                                    wetdry:Literal['fixed', 'evolutive']='evolutive',
+                                    steady:Literal['no precomputation', 'precomputation', 'steady'] = 'precomputation',
+                                    executable_type: Literal['wolfcli', 'wolfclid'] = 'wolfcli',
+                                    run_simulation: Literal['yes', 'no'] = 'no',
+                                    writing_type_infiltration: Literal['continuous', 'stepwise'] = 'continuous',
+                                    epsilon_infiltration:float = 0.01,
+                                    force_steady = True) -> None:
+        """Deprecated"""
+
+        infiltrations = self.read_csv_as_infiltrations(csv_filename)
+        names = self.read_csv_as_dataframe(csv_filename)
+
+        # # df = self.read_csv_as_dataframe(csv_filename,column_names=['discharge'])
+        # # discharge = df['discharge'][0]
+        # hydrograph = Hydrograph({0:discharge})
+        if force_steady:
+                hydrographs = infiltrations[0]
+                # hydrographs = {}
+                # hydrographs =[[[0],[discharge]]]
+        original_simulation =self.write_simulation_files_from_crosssections(folder_path,
+                                                            cross_sections,
+                                                            parallels,
+                                                            banks,
+                                                            boundary_conditions,
+                                                            roughness,
+                                                            hydrographs,
+                                                            exe_file,
+                                                            topography,
+                                                            initial_discharge,
+                                                            simulation_name,
+                                                            discretisation,
+                                                            extrapolation_of_extremities,
+                                                            initial_depth,
+                                                            write_in,
+                                                            output_frequency,
+                                                            polygon_number,
+                                                            code_verbosity_profile,
+                                                            simulation_time,
+                                                            roughness_option,
+                                                            roughness_selection,
+                                                            file_type_initial_cond,
+                                                            infiltration_profiles,
+                                                            wetdry,
+                                                            steady,
+                                                            executable_type,
+                                                            run_simulation ='no',
+                                                            writing_type_infiltration = writing_type_infiltration,
+                                                            epsilon_infiltration = epsilon_infiltration)
+        procedures =[]
+
+        for new_infiltration in infiltrations:
+            hydrographs = new_infiltration
+            values = list(new_infiltration.values())
+            extension =f'_Q{int(values[0])}' # FIXME
+            new_sim = self.copy_simulation_files(original_simulation[0],original_simulation[0] + extension)
+
+            self.write_ini_files(original_simulation[3],
+                                 new_sim,
+                                 new_infiltration,
+                                 original_simulation[4],
+                                 file_choice=file_type_initial_cond)
+
+            self.write_infiltrations(infiltration_profiles,original_simulation[2],hydrographs,new_sim)
+
+            new_batchfile = self.write_batch_file(directory_of_executable = exe_file,
+                                directory_simulation = new_sim,
+                                simulation_name = simulation_name,
+                                wetdry = wetdry,
+                                steady = steady,
+                                executable_type = executable_type,
+                                different_names= True,
+                                new_name=simulation_name + extension)
+            procedures.append(new_batchfile)
+
+
+            # # procedure = multiprocessing.Process(target= run_batch_file_multiprocess, args = (new_batchfile))
+            # # procedure.start()
+            # procedures.append(new_batchfile)
+            # if run_simulation == 'yes':
+            #     self.run_batch_file(new_batchfile)
+            #     # procedure.start()
+
+        if run_simulation == 'yes':
+            runs=[self.run_batch_file(i) for i in tqdm(procedures,'Running simulations', colour= Colors.TQDM.value)]
+            # # pool = multiprocessing.Pool(processes=len(procedures))
             # runs=[multiprocessing.Process(run_batch_file_multiprocess, args=i) for i in tqdm(procedures)]
 
-    def create_simulations_from_csv(self,
-                                    csv_filename:str,
-                                    folder_path:str,
-                                    cross_sections: crosssections,
-                                    parallels: Zones,
-                                    banks: Zones,
-                                    boundary_conditions: dict,
-                                    roughness:Union[float,WolfArray],
-                                    exe_file:str,
-                                    hydrographs: list[list[list]] = None,
-                                    topography: WolfArray = None,
-                                    initial_discharge:float = None,
-                                    simulation_name:str = 'simul',
-                                    discretisation:float = 10.,
-                                    extrapolation_of_extremities:float = 100.,
-                                    initial_depth:float = 1.,
-                                    write_in: Literal['iterations', 'times'] = 'times',
-                                    output_frequency:int = 900,
-                                    polygon_number:int = 1,
-                                    code_verbosity_profile: list = [1],
-                                    simulation_time:int = None,
-                                    roughness_option: Literal['under_profile', 'under_polygons']= 'under_profile',
-                                    roughness_selection:Literal['min','mean','median','max'] = 'mean',
-                                    file_type_initial_cond: Literal['.aini','.hini','.zini'] = '.aini',
-                                    infiltration_profiles:list =['1'],
-                                    wetdry:Literal['fixed', 'evolutive']='evolutive',
-                                    steady:Literal['no precomputation', 'precomputation', 'steady'] = 'precomputation',
-                                    executable_type: Literal['wolfcli', 'wolfclid'] = 'wolfcli',
-                                    run_simulation: Literal['yes', 'no'] = 'no',
-                                    writing_type_infiltration: Literal['continuous', 'stepwise'] = 'continuous',
-                                    epsilon_infiltration:float = 0.01,
-                                    force_steady = True) -> None:
+    def _start_from_steady_state(self,
+                                profile:str,
+                                infiltrations:dict,
+                                list_of_sorted_cross: list,
+                                directory,
+                                plot = True,
+                                ):
+        qini = infiltrations[profile]
+        if isinstance(qini, Hydrograph):
+            qini = qini.values[0]
+        elif isinstance(qini, (list,tuple)):
+            # FIXME to be verified
+            qini = qini[0]
+        elif qini == float:
+            qini = qini
+        else:
+            raise ValueError('The initial discharge is not well defined.')
+
+        hydrograph = Hydrograph({0:qini})
+
+        new_infiltrations = {profile:hydrograph}
+        self.write_infiltrations_from_dict(list_of_sorted_cross, new_infiltrations, directory)
+        self.write_parameters(directory, write_type= 2, max_time=0)
+        bat_file = self.find_file_from_extension(directory, '.bat')
+        self._run_bat_files(bat_file, initial_condition= True)
+        # self.run_bat_files(bat_file)
+        self.update_initial_conditions_from_results(directory, time_step=1, plot=plot)
+
+    def __write_simulation_files_from_crosssections(self,
+                                                folder_path:str,
+                                                cross_sections: crosssections,
+                                                parallels: Zones,
+                                                banks: Zones,
+                                                boundary_conditions: dict,
+                                                roughness:Union[float,WolfArray],
+                                                hydrographs: list[list[list]],
+                                                exe_file:str,
+                                                topography: WolfArray = None,
+                                                initial_discharge:float = None,
+                                                simulation_name:str = 'simul',
+                                                discretisation:float = 10.,
+                                                extrapolation_of_extremities:float = 100.,
+                                                initial_depth:float = 1.,
+                                                write_in: Literal['iterations', 'times'] = 'times',
+                                                output_frequency:int = 900,
+                                                polygon_number:int = 1,
+                                                code_verbosity_profile: list = [1],
+                                                simulation_time:int = None,
+                                                roughness_option: Literal['under_profile', 'under_polygons']= 'under_profile',
+                                                roughness_selection:Literal['min','mean','median','max'] = 'mean',
+                                                file_type_initial_cond: Literal['.aini','.hini','.zini'] = '.aini',
+                                                infiltration_profiles:list =['1'],
+                                                wetdry:Literal['fixed', 'evolutive']='evolutive',
+                                                steady:Literal['no precomputation', 'precomputation', 'steady'] = 'precomputation',
+                                                executable_type: Literal['wolfcli', 'wolfclid'] = 'wolfcli',
+                                                run_simulation: Literal['yes', 'no'] = 'no',
+                                                writing_type_infiltration: Literal['continuous', 'stepwise'] = 'continuous',
+                                                epsilon_infiltration:float = 0.01,
+                                                new_directory = '',
+                                                force_steady = True
+                                                ) -> tuple:
+        """
+        Write the simulation files (the 1D model) from the cross sections and the other parameters with one line of code.
+
+        :param folder_path: Folder path
+        :type folder_path: str
+        :param cross_sections: Cross sections
+        :type cross_sections: crosssections
+        :param parallels: Parallels
+        :type parallels: Zones
+        :param banks: Banks
+        :type banks: Zones
+        :param boundary_conditions: Boundary conditions
+        :type boundary_conditions: dict
+        :param roughness: Roughness
+        :type roughness: Union[float,WolfArray]
+        :param hydrographs: Hydrographs
+        :type hydrographs: list[list[list]]
+        :param exe_file: Exe file
+        :type exe_file: str
+        :param topography: Topography, defaults to None
+        :type topography: WolfArray, optional
+        :param initial_discharge: Initial discharge, defaults to None
+        :type initial_discharge: float, optional
+        :param simulation_name: Simulation name, defaults to 'simul'
+        :type simulation_name: str, optional
+        :param discretisation: Discretisation, defaults to 10.
+        :type discretisation: float, optional
+        :param extrapolation_of_extremities: Extrapolation of extremities, defaults to 100.
+        :type extrapolation_of_extremities: float, optional
+        :param initial_depth: Initial depth, defaults to 1.
+        :type initial_depth: float, optional
+        :param write_in: Write in, defaults to 'times'
+        :type write_in: Literal['iterations', 'times'], optional
+        :param output_frequency: Output frequency, defaults to 900
+        :type output_frequency: int, optional
+        :param polygon_number: Polygon number, defaults to 1
+        :type polygon_number: int, optional
+        :param code_verbosity_profile: Code verbosity profile, defaults to [1]
+        :type code_verbosity_profile: list, optional
+        :param simulation_time: Simulation time, defaults to None
+        :type simulation_time: int, optional
+        :param roughness_option: Roughness option, defaults to 'under_profile'
+        :type roughness_option: Literal['under_profile', 'under_polygons'], optional
+        :param roughness_selection: Roughness selection, defaults to 'mean'
+        :type roughness_selection: Literal['min','mean','median','max'], optional
+        :param file_type_initial_cond: File type initial cond, defaults to '.aini'
+        :type file_type_initial_cond: Literal['.aini','.hini','.zini'], optional
+        :param infiltration_profiles: Infiltration profiles, defaults to ['1']
+        :type infiltration_profiles: list, optional
+        :param wetdry: Wetdry, defaults to 'evolutive'
+        :type wetdry: Literal['fixed', 'evolutive'], optional
+        :param steady: Steady, defaults to 'precomputation'
+        :type steady: Literal['no precomputation', 'precomputation', 'steady'], optional
+        :param executable_type: Executable type, defaults to 'wolfcli'
+        :type executable_type: Literal['wolfcli', 'wolfclid'], optional
+        :param run_simulation: Run simulation, defaults to 'no'
+        :type run_simulation: Literal['yes', 'no'], optional
+        :param writing_type_infiltration: Writing type infiltration, defaults to 'continuous'
+        :type writing_type_infiltration: Literal['continuous', 'stepwise'], optional
+        :param epsilon_infiltration: Epsilon infiltration, defaults to 0.01
+        :type epsilon_infiltration: float, optional
+        :param new_directory: New directory, defaults to ''
+        :type new_directory: str, optional
+        :param force_steady: Force steady, defaults to True
+        :type force_steady: bool, optional
+        :return: tuple
+        :rtype: tuple
+        """
+
+
+        # Simulation directory (contains all simulation files)
+        if new_directory != '':
+            directory = new_directory
+        else:
+            directory = self.create_simulation_directory(folder_path,simulation_name)
+
+        # The extremities of each profile is extrapolated to avoid negative water depths in case of high discharges
+        extrapolated_cross_sections = self.extrapolate_extremities(cross_sections,
+                                                                    extrapolation_of_extremities,
+                                                                    directory)
+        # The crossection are sorted based on the river bed (middle parallel)
+        sorted_crosssections = self.sort_crossections_list([extrapolated_cross_sections], banks)
+        #
+        if simulation_time:
+            time = simulation_time
+        else:
+            # FIXME Multiple hydrographs
+            if isinstance(hydrographs,dict):
+                times = []
+                for hydro, prof in hydrographs.items():
+                    if isinstance(prof, Hydrograph):
+                        times.append(max(prof.index))
+                    elif isinstance(prof, list):
+                        latest_time = prof[0][-1]
+                        times.append(latest_time)
+
+                time = max(times)
+
+            else:
+                if isinstance(hydrographs[0], Hydrograph):
+                    time = max(hydrographs[0].index)
+                elif isinstance(hydrographs[0], list):
+                    time = hydrographs[0][0][-1]
+
+        if initial_discharge:
+            q_ini = initial_discharge
+        else:
+            if isinstance(hydrographs,dict):
+                discharges = []
+                for hydro, prof in hydrographs.items():
+                    if isinstance(prof, Hydrograph):
+                        first_discharge = prof.values[0]
+                        discharges.append(first_discharge)
+                    elif isinstance(prof, list):
+                        first_discharge = prof[0][0]
+                        discharges.append(first_discharge)
+                q_ini = min(discharges)
+            else:
+                if isinstance(hydrographs[0], Hydrograph):
+                    q_ini = hydrographs[0].values[0]
+                elif isinstance(hydrographs[0], list):
+                    q_ini = hydrographs[0][1][0]
+
+        # Bank file
+        if banks.is2D:
+            bank_file = self.get_values_from_array(banks, topography, directory + '\\banks.vecz')
+        else:
+            bank_file = banks
+            bank_file.saveas(directory + '\\banks.vecz')
+
+        # Polygons
+        # FIXME is it necessery  to have parallels (next round), is it only for cell size or a better used could be found?
+        if isinstance(parallels, Zones):
+            polygons = self.create_polygons(parallels, discretisation, polygon_number, directory)
+
+        # Write the tabulated relations of each cross section (profile)
+        write_relations = self.write_relations_profiles(sorted_crosssections, directory)
+
+        # Write roughnesses
+        if isinstance(roughness, float) or isinstance(roughness, int):
+            roughnesses = self.roughness_from_value(sorted_crosssections,  value = roughness)
+
+        elif isinstance(roughness, WolfArray):
+            if roughness_option == 'under_profile':
+                roughnesses = self.roughness_from_profiles(roughness, sorted_crosssections, mode=roughness_selection)
+
+            elif roughness_option == 'under_polygons':
+                # FIXME to be verified issue with the extent of profiles
+                # (the number of new polygons is different from the number of digitized profiles)
+                # May be a test should be implemented on each profiles (probable solution).
+                roughnesses = self.roughness_from_polygons(roughness, polygons, mode=roughness_selection)
+
+        roughness_file = self.write_roughnesses(roughnesses, directory)
+
+        # Compute & write the intial conditions
+        ic_relations, nb_updates = self.ic_relations_hspw(sorted_crosssections, initial_depth)
+
+        # The simulation is initialized based on the wetted area (more practical)
+        ini_files = self.write_ini_files(ic_relations,
+                                            directory,
+                                            q = q_ini,
+                                            nb_updates= nb_updates,
+                                            file_choice=[file_type_initial_cond])
+
+        # Write the boundary conditions
+        cl_file = self.write_cl_file(sorted_crosssections, boundary_conditions, directory)
+
+        # Write .top file (topography)
+        top_file = self.write_top_file(sorted_crosssections,directory)
+
+        # Write the .vec file (discretization file of the simulation topography - lowest riverbed point)
+        vec_file1 = self.write_vector_files(sorted_crosssections, save_as=directory,which_type='vecz')
+
+        # Sets the predefined river banks and bed on each cross sections
+        set_bank = self.set_banksbed_vectors(bank_file)
+
+        # Write the .vec file (discretization file of the simulation topography - midriver)
+        vec_file2 = self.write_vector_files(sorted_crosssections, save_as=directory, which_type='vec')
+
+        # Write the infiltrations
+        if isinstance(hydrographs, dict):
+            infil = self.write_infiltrations_from_dict(sorted_crosssections,
+                                         hydrographs,
+                                         directory,
+                                         writing_type_infiltration,
+                                         epsilon_infiltration)
+        elif isinstance(hydrographs,list):
+            infil = self.write_infiltrations(infiltration_profiles,
+                                            sorted_crosssections,
+                                            hydrographs,
+                                            directory,
+                                            writing_type_infiltration,
+                                            epsilon_infiltration)
+
+        # write the simulation parameters
+        if write_in == 'times':
+            write_type = 2
+        elif write_in =='iterations':
+            write_type = 1
+        if self.wx_exists == None:
+            param = self.write_parameters(directory, write_freq= output_frequency, write_type= write_type, max_time=time)
+        # # if steady == 'precomputation' or steady == 'steady':
+        # #     self.correct_parameters(directory, from_steady=True)
+        # # else:
+        # #     self.correct_parameters(directory)
+        # self.correct_parameters(directory) FIXME for other cases when the GUI is not used
+
+        genfile = self.write_generic_file(directory)
+        batch_file = self.write_batch_file(directory_of_executable = exe_file,
+                                           directory_simulation = directory,
+                                           simulation_name = simulation_name,
+                                           wetdry = wetdry,
+                                           steady = steady,
+                                           executable_type = executable_type)
+        if run_simulation == 'yes':
+            # logging.warn(f'{simulation_name} running... \nThe process may take time.')
+            self.run_bat_files(batch_file)
+            # logging.warn(f'{simulation_name} completed.')
+        return (directory,simulation_name, sorted_crosssections, ic_relations, nb_updates)
+
+    def ____write_simulation_files_from_crosssections(self,
+                                                folder_path:str,
+                                                cross_sections: crosssections,
+                                                parallels: Zones,
+                                                banks: Zones,
+                                                boundary_conditions: dict,
+                                                roughness:Union[float,WolfArray],
+                                                hydrographs: list[list[list]],
+                                                exe_file:str,
+                                                topography: WolfArray = None,
+                                                initial_discharge:float = None,
+                                                simulation_name:str = 'simul',
+                                                discretisation:float = 10.,
+                                                extrapolation_of_extremities:float = 100.,
+                                                initial_depth:float = 1.,
+                                                write_in: Literal['iterations', 'times'] = 'times',
+                                                output_frequency:int = 900,
+                                                polygon_number:int = 1,
+                                                code_verbosity_profile: list = [1],
+                                                simulation_time:int = None,
+                                                roughness_option: Literal['under_profile', 'under_polygons']= 'under_profile',
+                                                roughness_selection:Literal['min','mean','median','max'] = 'mean',
+                                                file_type_initial_cond: Literal['.aini','.hini','.zini'] = '.aini',
+                                                infiltration_profiles:list =['1'],
+                                                wetdry:Literal['fixed', 'evolutive']='evolutive',
+                                                steady:Literal['no precomputation', 'precomputation', 'steady'] = 'precomputation',
+                                                executable_type: Literal['wolfcli', 'wolfclid'] = 'wolfcli',
+                                                run_simulation: Literal['yes', 'no'] = 'no',
+                                                writing_type_infiltration: Literal['continuous', 'stepwise'] = 'continuous',
+                                                epsilon_infiltration:float = 0.01,
+                                                new_directory = '',
+                                                steady_state_profile = '',
+                                                force_steady = True,
+                                                start_from_steady_state = False,
+                                                plot_steady_state = True
+                                                ) -> tuple:
         """
-        Create simulations from a csv file.
+        Write the simulation files (the 1D model) from the cross sections and the other parameters with one line of code.
 
-        :param csv_filename: Csv filename
-        :type csv_filename: str
         :param folder_path: Folder path
         :type folder_path: str
         :param cross_sections: Cross sections
@@ -5286,10 +6537,10 @@ class Creator_1D:
         :type boundary_conditions: dict
         :param roughness: Roughness
         :type roughness: Union[float,WolfArray]
+        :param hydrographs: Hydrographs
+        :type hydrographs: list[list[list]]
         :param exe_file: Exe file
         :type exe_file: str
-        :param hydrographs: Hydrographs, defaults to None
-        :type hydrographs: list[list[list]], optional
         :param topography: Topography, defaults to None
         :type topography: WolfArray, optional
         :param initial_discharge: Initial discharge, defaults to None
@@ -5332,260 +6583,181 @@ class Creator_1D:
         :type writing_type_infiltration: Literal['continuous', 'stepwise'], optional
         :param epsilon_infiltration: Epsilon infiltration, defaults to 0.01
         :type epsilon_infiltration: float, optional
+        :param new_directory: New directory, defaults to ''
+        :type new_directory: str, optional
         :param force_steady: Force steady, defaults to True
         :type force_steady: bool, optional
-        """
-        df = self.read_csv_as_dataframe(csv_filename,column_names=['discharge'])
-        discharge = df['discharge'][0]
-        # hydrograph = Hydrograph({0:discharge})
-        if force_steady:
-                # hydrographs = {}
-                hydrographs =[[[0],[discharge]]]
-        original_simulation =self.write_simulation_files_from_crosssections(folder_path,
-                                                            cross_sections,
-                                                            parallels,
-                                                            banks,
-                                                            boundary_conditions,
-                                                            roughness,
-                                                            hydrographs,
-                                                            exe_file,
-                                                            topography,
-                                                            discharge,
-                                                            simulation_name,
-                                                            discretisation,
-                                                            extrapolation_of_extremities,
-                                                            initial_depth,
-                                                            write_in,
-                                                            output_frequency,
-                                                            polygon_number,
-                                                            code_verbosity_profile,
-                                                            simulation_time,
-                                                            roughness_option,
-                                                            roughness_selection,
-                                                            file_type_initial_cond,
-                                                            infiltration_profiles,
-                                                            wetdry,
-                                                            steady,
-                                                            executable_type,
-                                                            run_simulation ='no',
-                                                            writing_type_infiltration = writing_type_infiltration,
-                                                            epsilon_infiltration = epsilon_infiltration)
-        procedures =[]
-
-        new_sims =[]
-        for new_discharge in list(df['discharge']):
-            hydrographs =[[[0],[new_discharge]]]
-
-            extension =f'_Q{int(new_discharge)}'
-            new_sim_name = original_simulation[0] + extension
-            new_sim = self.copy_simulation_files(original_simulation[0],new_sim_name, ignore_filetype='*.bat')
-            new_sims.append(new_sim)
-
-
-            self.write_ini_files(original_simulation[3],
-                                 new_sim,
-                                 new_discharge,
-                                 original_simulation[4],
-                                 file_choice=file_type_initial_cond)
-
-            self.write_infiltrations(infiltration_profiles,original_simulation[2],hydrographs,new_sim)
-
-            new_batchfile = self.write_batch_file(directory_of_executable = exe_file,
-                                directory_simulation = new_sim,
-                                simulation_name = simulation_name,
-                                wetdry = wetdry,
-                                steady = steady,
-                                executable_type = executable_type,
-                                different_names= True,
-                                new_name=simulation_name + extension)
-            procedures.append(new_batchfile)
-
-            # # procedure = multiprocessing.Process(target= run_batch_file_multiprocess, args = (new_batchfile))
-            # # procedure.start()
-            # procedures.append(new_batchfile)
-            # if run_simulation == 'yes':
-            #     self.run_batch_file(new_batchfile)
-            #     # procedure.start()
-
-        batch_file_group = self.write_batch_simulations(directory_of_executable = exe_file,
-                                                       simulations_path=new_sims,
-                                                       wetdry = wetdry,
-                                                       steady = steady,
-                                                       executable_type = executable_type)
-
-        if run_simulation == 'yes':
-            # runs=[self.run_batch_file(i) for i in tqdm(procedures,'Running simulations', colour= Colors.TQDM.value)]
-            # run = self.run_batch_file(batch_file_group)
-            run = self.run_bat_files(batch_file_group)
-            # # pool = multiprocessing.Pool(processes=len(procedures))
-            # runs=[multiprocessing.Process(run_batch_file_multiprocess, args=i) for i in tqdm(procedures)]
-
-    def copy_simulation_files(self,
-                              simulation:str,
-                              save_as:str,
-                              ignore_filetype: Literal['.*qini','*.aini', '*.zini','*.hini','*.cl', '*.rough', 'infil*','*.inf'
-                                                            '*.infil','*.param','*.top','*.ptv','*.gtv','.log', '.count'
-                                                            '*.HEAD','*.RA', '*.RB','*.RQ','*.RS','*.vecz','*.vec','*.txt', '*.bat'] = '') -> str:
-        """
-        Copy simulation files.
-
-        :param simulation: Simulation
-        :type simulation: str
-        :param save_as: Save as
-        :type save_as: str
-        :param ignore_filetype: Ignore filetype, defaults to ''
-        :type ignore_filetype: str, optional
-        :return: Copied directory
-        :rtype: str
-        """
-        if ignore_filetype != '':
-            try:
-                copied_directory = shutil.copytree(src = simulation, dst= save_as)
-            except FileExistsError:
-                # os.rmdir(save_as)
-                # copied_directory = shutil.copytree(src = simulation, dst= save_as)
-                raise Exception(f"The file named ({save_as}) exists already.\n Rename the new file or delete the existing file.")
+        :return: tuple
+        :rtype: tuple
+        """
+
+
+        # Simulation directory (contains all simulation files)
+        if new_directory != '':
+            directory = new_directory
         else:
-            try:
-                copied_directory = shutil.copytree(src = simulation, dst= save_as, ignore=shutil.ignore_patterns(ignore_filetype))
-            except FileExistsError:
-                # os.rmdir(save_as)
-                # copied_directory = shutil.copytree(src = simulation, dst= save_as, ignore=shutil.ignore_patterns(ignore_filetype))
-                raise Exception(f"The file named ({save_as}) exists already.\n Rename the new file or delete the existing file.")
-        return copied_directory
+            directory = self.create_simulation_directory(folder_path,simulation_name)
 
-    def copy_multiple_simulations_from_csv(self, csv_filename:str, simulation:str) -> None:
-        """
-        Copy multiple simulations from a csv file.
+        # The extremities of each profile is extrapolated to avoid negative water depths in case of high discharges
+        extrapolated_cross_sections = self.extrapolate_extremities(cross_sections,
+                                                                    extrapolation_of_extremities,
+                                                                    directory)
+        # The crossection are sorted based on the river bed (middle parallel)
+        sorted_crosssections = self.sort_crossections_list([extrapolated_cross_sections], banks)
+        #
+        if simulation_time:
+            time = simulation_time
+        else:
+            # FIXME Multiple hydrographs
+            if isinstance(hydrographs,dict):
+                times = []
+                for hydro, prof in hydrographs.items():
+                    if isinstance(prof, Hydrograph):
+                        times.append(max(prof.index))
+                    elif isinstance(prof, list):
+                        latest_time = prof[0][-1]
+                        times.append(latest_time)
 
-        :param csv_filename: Csv filename
-        :type csv_filename: str
-        :param simulation: Simulation
-        :type simulation: str
-        """
+                time = max(times)
 
-        df = self.read_csv_as_dataframe(csv_filename,column_names=['discharge'])
-        lgth = df.shape[0]
-        for discharge in tqdm(df['discharge']):
-            self.copy_simulation_files(simulation, simulation + f'_Q{discharge}')
+            else:
+                if isinstance(hydrographs[0], Hydrograph):
+                    time = max(hydrographs[0].index)
+                elif isinstance(hydrographs[0], list):
+                    time = hydrographs[0][0][-1]
 
-    # --- Outdated methods ---
-    #_________________________
+        if initial_discharge:
+            q_ini = initial_discharge
+        else:
+            if isinstance(hydrographs,dict):
+                discharges = []
+                for hydro, prof in hydrographs.items():
+                    if isinstance(prof, Hydrograph):
+                        first_discharge = prof.values[0]
+                        discharges.append(first_discharge)
+                    elif isinstance(prof, list):
+                        first_discharge = prof[0][0]
+                        discharges.append(first_discharge)
+                q_ini = min(discharges)
+            else:
+                if isinstance(hydrographs[0], Hydrograph):
+                    q_ini = hydrographs[0].values[0]
+                elif isinstance(hydrographs[0], list):
+                    q_ini = hydrographs[0][1][0]
 
-    def __write_batch_file(self,
-                         directory_of_executable:str,
-                         directory_simulation:str,
-                         simulation_name:str,
-                         wetdry:Literal['fixed', 'evolutive']='evolutive',
-                         steady:Literal['no precomputation', 'precomputation', 'steady'] = 'precomputation',
-                         executable_type: Literal['wolfcli', 'wolfclid'] = 'wolfcli',
-                         different_names=False,
-                         new_name:str =''
-                         ) -> str:
-        if different_names:
-            batch_file =self.initialize_file(directory_of_executable, f'{new_name}.bat','') # To avoid simul name FIXME make it clean
+        # Bank file
+        if banks.is2D:
+            bank_file = self.get_values_from_array(banks, topography, directory + '\\banks.vecz')
         else:
-            batch_file =self.initialize_file(directory_of_executable, '.bat')
+            bank_file = banks
+            bank_file.saveas(directory + '\\banks.vecz')
 
+        # Polygons
+        # FIXME is it necessery  to have parallels (next round), is it only for cell size or a better used could be found?
+        if isinstance(parallels, Zones):
+            polygons = self.create_polygons(parallels, discretisation, polygon_number, directory)
 
+        # Write the tabulated relations of each cross section (profile)
+        write_relations = self.write_relations_profiles(sorted_crosssections, directory)
 
-        if wetdry == 'fixed':
-            wtd = 0
-        elif wetdry == 'evolutive':
-            wtd= 1
+        # Write roughnesses
+        if isinstance(roughness, float) or isinstance(roughness, int):
+            roughnesses = self.roughness_from_value(sorted_crosssections,  value = roughness)
 
-        if steady== 'precomputation':
-            std= 1
-        elif steady == 'no precomputation':
-            std = 0
-        elif steady == 'steady':
-            std=2
+        elif isinstance(roughness, WolfArray):
+            if roughness_option == 'under_profile':
+                roughnesses = self.roughness_from_profiles(roughness, sorted_crosssections, mode=roughness_selection)
 
-        find_full_path ='%~dp0'
-        with open(batch_file,'w') as bat:
-            bat.write(f'cd "{directory_of_executable}"\n')
-            # bat.write(f'{executable_type} run_wolf1d dirin="%~dp0{simulation_name}" in="{simulation_name}" wetdry={wtd} steady={std}')
-            if different_names:
-                bat.write(f'{executable_type} run_wolf1d dirin="{find_full_path}{new_name}" in="{simulation_name}" wetdry={wtd} steady={std}')
-                # if directory_simulation[0] =='.':
-                #     bat.write(f'{executable_type} run_wolf1d dirin="{find_full_path}{directory_simulation}" in="{simulation_name}" wetdry={wtd} steady={std}')
-                # else:
-                #     bat.write(f'{executable_type} run_wolf1d dirin="{find_full_path}{directory_simulation}" in="{simulation_name}" wetdry={wtd} steady={std}')
+            elif roughness_option == 'under_polygons':
+                # FIXME to be verified issue with the extent of profiles
+                # (the number of new polygons is different from the number of digitized profiles)
+                # May be a test should be implemented on each profiles (probable solution).
+                roughnesses = self.roughness_from_polygons(roughness, polygons, mode=roughness_selection)
 
-            else:
-                bat.write(f'{executable_type} run_wolf1d dirin="{find_full_path}{simulation_name}" in="{simulation_name}" wetdry={wtd} steady={std}')
+        roughness_file = self.write_roughnesses(roughnesses, directory)
 
-        return batch_file
+        # Compute & write the intial conditions
+        ic_relations, nb_updates = self.ic_relations_hspw(sorted_crosssections, initial_depth)
 
-    def match_ends_2vectors_outdated(self,
-                            zones1: Zones,
-                            zones2: Zones,
-                            id1:int = 0,
-                            id2:int = 0) -> Zones:
-        """
-        Aligns the vertices of  2 successive zone
-        containing each 3 vectors (1 vector and its 2 parallels),
-        so that, the end of each vector matches the begining of its corresponding in the other zone.
-            - id1: zone id in zones1.myzones,
-            - id2: zone id in zones2.myzones.
-        """
-        znes1 = zones1
-        znes2 = zones2
-        vector1_1 = znes1.myzones[id1].myvectors[0]
-        vector1_2 = znes1.myzones[id1].myvectors[1]
-        vector1_3 = znes1.myzones[id1].myvectors[2]
-        vector2_1 = znes2.myzones[id2].myvectors[0]
-        vector2_2 = znes2.myzones[id2].myvectors[1]
-        vector2_3 = znes2.myzones[id2].myvectors[2]
-        i = vector1_1.myvertices
-        j = vector2_1.myvertices
+        # The simulation is initialized based on the wetted area (more practical)
+        ini_files = self.write_ini_files(ic_relations,
+                                            directory,
+                                            q = q_ini,
+                                            nb_updates= nb_updates,
+                                            file_choice=[file_type_initial_cond])
 
-        distance1 = math.sqrt(((i[-1].x - j[0].x)**2) + ((i[-1].y - j[0].y)**2)) #last point - first point
-        distance2 = math.sqrt(((i[-1].x - j[-1].x)**2) + ((i[-1].y - j[-1].y)**2)) #last point - last point
-        distance1_r = math.sqrt(((i[0].x - j[0].x)**2) + ((i[0].y - j[0].y)**2)) # first point - first point
-        distance2_r = math.sqrt(((i[0].x - j[-1].x)**2) + ((i[0].y - j[-1].y)**2)) #first point - last point
+        # Write the boundary conditions
+        cl_file = self.write_cl_file(sorted_crosssections, boundary_conditions, directory)
 
-        all = [distance1, distance2, distance1_r, distance2_r]
+        # Write .top file (topography)
+        top_file = self.write_top_file(sorted_crosssections,directory)
 
-        if min(all) == distance2:
-            vector2_1.myvertices.reverse()
-            vector2_2.myvertices.reverse()
-            vector2_3.myvertices.reverse()
+        # Write the .vec file (discretization file of the simulation topography - lowest riverbed point)
+        vec_file1 = self.write_vector_files(sorted_crosssections, save_as=directory,which_type='vecz')
 
-        elif min(all) == distance1_r:
-            vector1_1.myvertices.reverse()
-            vector1_2.myvertices.reverse()
-            vector1_3.myvertices.reverse()
+        # Sets the predefined river banks and bed on each cross sections
+        set_bank = self.set_banksbed_vectors(bank_file)
 
-        elif min(all) ==distance2_r:
-            vector1_1.myvertices.reverse()
-            vector1_2.myvertices.reverse()
-            vector1_3.myvertices.reverse()
-            vector2_1.myvertices.reverse()
-            vector2_2.myvertices.reverse()
-            vector2_3.myvertices.reverse()
+        # Write the .vec file (discretization file of the simulation topography - midriver)
+        vec_file2 = self.write_vector_files(sorted_crosssections, save_as=directory, which_type='vec')
+        # write the generic file
+        genfile = self.write_generic_file(directory)
+        # Write the batch file
+        batch_file = self.write_batch_file(directory_of_executable = exe_file,
+                                           directory_simulation = directory,
+                                           simulation_name = simulation_name,
+                                           wetdry = wetdry,
+                                           steady = steady,
+                                           executable_type = executable_type)
 
-        return znes1, znes2
+        # Update initial conditions
+        if start_from_steady_state:
+            self.start_from_steady_state(directory, plot = plot_steady_state)
+
+            # # if profile == '':
+            # #     profile = '1'
+            # # self.start_from_steady_state(profile=steady_state_profile,
+            # #                              infiltrations= hydrographs,
+            # #                              list_of_sorted_cross= sorted_crosssections,
+            # #                              directory= directory,
+            # #                              plot= plot_steady_state)
+
+            # Write the batch file
+            batch_file = self.write_batch_file(directory_of_executable = exe_file,
+                                            directory_simulation = directory,
+                                            simulation_name = simulation_name,
+                                            wetdry = wetdry,
+                                            steady = 'no precomputation',
+                                            executable_type = executable_type)
 
-    def __save_as_1D_crossections(self,
-                                  zones: Zones,
-                                  format ='vecz',
-                                  save_as: str='') -> crosssections:
-        znes = zones
-        path = save_as + 'profiles' + id +'.vecz'
-        index = 1
-        for vec in znes.myzones[0].myvectors:
-            vec.myname = '%s'%(index)
-            index+=1
+        # Write the infiltrations
+        if isinstance(hydrographs, dict):
+            infil = self.write_infiltrations_from_dict(sorted_crosssections,
+                                         hydrographs,
+                                         directory,
+                                         writing_type_infiltration,
+                                         epsilon_infiltration)
+        elif isinstance(hydrographs,list):
+            infil = self.write_infiltrations(infiltration_profiles,
+                                            sorted_crosssections,
+                                            hydrographs,
+                                            directory,
+                                            writing_type_infiltration,
+                                            epsilon_infiltration)
 
-        znes.find_minmax()
-        znes.saveas(path)
-        cross= crosssections(mydata= path,format='vecz')
-        cross.format = format
-        if save_as:
-            cross.saveas(save_as)
-        return cross
+        # write the simulation parameters
+        if write_in == 'times':
+            write_type = 2
+        elif write_in =='iterations':
+            write_type = 1
+        if self.wx_exists == None:
+            param = self.write_parameters(directory, write_freq= output_frequency, write_type= write_type, max_time=time)
 
+        if run_simulation == 'yes':
+            # logging.warn(f'{simulation_name} running... \nThe process may take time.')
+            self.run_bat_files(batch_file)
+            # logging.warn(f'{simulation_name} completed.')
+        return (directory,simulation_name, sorted_crosssections, ic_relations, nb_updates)
 
 # --- Wolf 1D results ---
 #________________________
@@ -5703,11 +6875,14 @@ class Wolfresults_1D:
             self.wetted_sections = np.roll(wetted_sections, 1, axis=0)
 
         self.velocities = self.discharges/self.wetted_sections
-        # # FIXME implement a clever way of computing the froude number (TOP width from wetted sections)
+        # To avoid nan values, copy false means the original array is modified and returned.
+        self.velocities = np.nan_to_num(self.velocities, copy=False)
         if self.breath_file != None:
             self.widths = np.loadtxt(self.breath_file)
             if self.widths.shape == self.wetted_sections.shape:
                 self.froudes = self.discharges / (self.wetted_sections*np.sqrt(Constants.GRAVITATION.value*(self.wetted_sections/self.widths)))
+                # To avoid nan values, copy false means the original array is modified and returned.
+                self.froudes = np.nan_to_num(self.froudes, copy=False, nan=0.0, posinf=0.0,neginf=0.0)
             # In case the model has written new results
             else:
                 if self.breath_directory != None:
@@ -5743,6 +6918,63 @@ class Wolfresults_1D:
 
         # print('done')
 
+    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),
+            - s: Wetted perimeter (index 1),
+            - w: Top width (index 2),
+            - r: Hydraulic radius (index 3).
+
+        :param time_step: the desired time steps, defaults to -1
+        :type time_step: int, optional
+        :return: the conditions at the specified time step
+        :rtype: np.ndarray
+        """
+        real_time_step = self.convert_time_step(time_step)
+        for file in os.listdir(self.directory):
+            if file.endswith(".aini"):
+                aini_file = os.path.join(self.directory,file)
+                wetted_sections = self.wetted_sections[:,real_time_step]
+                self.update_ini_file(aini_file, wetted_sections)
+            elif file.endswith(".hini"):
+                hini_file = os.path.join(self.directory,file)
+                depths = self.depths[:,real_time_step]
+                self.update_ini_file(hini_file, depths)
+            elif file.endswith(".zini"):
+                zini_file = os.path.join(self.directory,file)
+                water_level = self.water_levels[:,real_time_step]
+                self.update_ini_file(zini_file, water_level)
+            elif file.endswith(".qini"):
+                qini_file = os.path.join(self.directory,file)
+                discharges = self.discharges[:,real_time_step]
+                self.update_ini_file(qini_file, discharges)
+
+
+        # wetted_sections = self.wetted_sections[:,real_time_step]
+        # discharges = self.discharges[:,real_time_step]
+        # depths = self.depths[:,real_time_step]
+        # wetted_perimeters = self.wetted_sections[:,real_time_step] # FIXME not yet available
+        # top_widths = self.widths[:,real_time_step] # FIXME not yet available
+
+    def update_ini_file(self, ini_file:str, new_values: np.ndarray)-> None:
+        """Update the initial condition file with new values."""
+        df = pd.read_csv(ini_file,
+                         sep= Constants.SEPARATOR.value,
+                         skiprows=1,
+                         names=['skeleton', 'zone', 'segment','value']
+                         )
+        lgth_values = len(df['value'])
+        lgth_new_values = len(new_values)
+        assert lgth_values == lgth_new_values,\
+            f"The length of the new values - {lgth_new_values} is not consistent with the initial condition file - {lgth_values}."
+
+        df['value'] = new_values
+        sep = Constants.SEPARATOR.value
+        with open(ini_file, 'w') as f:
+            f.write(f"{lgth_new_values}\n")
+            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 plot_water_level(self,
                          figax:tuple = None,
                          time_step:int = 1,
@@ -7381,8 +8613,8 @@ class Wolfresults_1D:
                                                        banksbed,
                                                        landmark,
                                                        save_as,
-                                                       grid_x_m = grid_x_m,
-                                                       grid_y_m = grid_y_m,
+                                                       grid_x = grid_x_m,
+                                                       grid_y = grid_y_m,
                                                        convert_step=False,
                                                        steps_limit=steps_limit)
             # axes_for_updates.append((wetted_section,ax4,fig))
@@ -7428,9 +8660,16 @@ class Wolfresults_1D:
 
         fig.suptitle(f'Results - 1D model\n$Time: (step: {real_time_step+1} - $simulated: {self.simulated_times[real_time_step]:#.1f}s$ - real: {self.real_times[real_time_step]:#.1e} s)$',
                         fontsize= 'x-large', fontweight= 'bold')
+
+        plt.tight_layout()
+        if save_as != '':
+            plt.savefig(save_as)
         if show:
-            plt.tight_layout()
+            # plt.tight_layout()
             plt.show()
+
+
+
         return axes_for_updates
 
     def animate_1D_plots(self,
@@ -7440,7 +8679,9 @@ class Wolfresults_1D:
                             landmark: Union[str,Zones]= '',
                             figsize:tuple = (20,10),
                             alpha:float = 0.3,
-                            save_as:str=''):
+                            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.
@@ -7471,6 +8712,8 @@ class Wolfresults_1D:
                                   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: