debug AdisTS BCs

.gitlab-ci.yml

@@ -30,6 +30,7 @@ stages:
 
 variables:
   MAGE_8_VERSION: "v8.3.6"
+  ADISTS_VERSION: "v1.0.2"
 
 dl-mage8-doc:
   stage: downloads
@@ -92,7 +93,7 @@ dl-adists-linux:
   script:
     - mkdir -p adists-linux
     - cd adists-linux
-    - curl -L -o adists https://gitlab.irstea.fr/jean-baptiste.faure/adists/-/releases/v1.0.1/downloads/executables/adists
+    - curl -L -o adists https://gitlab.irstea.fr/jean-baptiste.faure/adists/-/releases/$ADISTS_VERSION/downloads/executables/adists
   artifacts:
     paths:
       - adists-linux/adists
@@ -106,7 +107,7 @@ dl-adists-windows:
   script:
     - mkdir -p adists-windows
     - cd adists-windows
-    - curl -L -o adists.exe https://gitlab.irstea.fr/jean-baptiste.faure/adists/-/releases/v1.0.1/downloads/executables/adists_win64.exe
+    - curl -L -o adists.exe https://gitlab.irstea.fr/jean-baptiste.faure/adists/-/releases/$ADISTS_VERSION/downloads/executables/adists_win64.exe
   artifacts:
     paths:
       - adists-windows/adists.exe

doc/dev/documentation.org

@@ -1375,7 +1375,7 @@ contribution.
 #+INCLUDE: "../../AUTHORS" src text
 
 [fn:p2-gitlab] The {{{pamhyr2}}} Gitlab project page:
-https://gitlab.irstea.fr/theophile.terraz/pamhyr
+https://gitlab.com/pamhyr/pamhyr2
 [fn:inrae] The INRAE web site: https://www.inrae.fr/
 
 ** Translate

doc/paper/2023/simhydro/presentation/presentation.org

@@ -424,7 +424,7 @@ Create a new version of {{{pamhyr}}} called {{{pamhyr2}}}
 
 ** Contribution
 #+LaTeX: \begin{center}
-\faIcon{gitlab} https://gitlab.irstea.fr/theophile.terraz/pamhyr/
+\faIcon{gitlab} https://gitlab.com/pamhyr/pamhyr2/
 #+LaTeX: \end{center}
 
 *** For users
@@ -462,7 +462,7 @@ Create a new version of {{{pamhyr}}} called {{{pamhyr2}}}
 # #+END_EXPORT
 
 #+LaTeX: \begin{center}
-\faIcon{gitlab} https://gitlab.irstea.fr/theophile.terraz/pamhyr/
+\faIcon{gitlab} https://gitlab.com/pamhyr/pamhyr2/
 #+LaTeX: \end{center}
 
 #+LaTeX: \begin{center}

doc/users/TP_Hydraulique_Hogneau/Tuto-2-fr.tex

@@ -112,7 +112,7 @@ Auteurs : & Céline Berni & celine.berni@inrae.fr\tabularnewline
 % \pagebreak{}
 
 
-\section{Préambule}
+\section*{Préambule}
 
 Dans ce document, nous expliciterons les fonctionnalités de PamHyr utiles à la modélisation de scénarii d'aménagement de la rivière Hogneau comme décrit dans le document de TP.
 Il est utile au préalable d'avoir suivi le tutoriel pour la modélisation de la rivière Hogneau fourni avec le logiciel (Tuto1-fr.pdf).
@@ -121,16 +121,36 @@ Suivre le tutoriel 1 vous permettra de construire le modèle avec le scénario d
 Notez que l'outil PamHyr ne permet pas au stade actuel de comparer plusieurs scenarii.
 Vous devrez pour ce faire exporter les vos résultats à partir de la fenêtre \textit{Résultats} qui s'ouvre en cliquant sur \texttt{[Résultats] => [Visualiser les derniers résultats]} à partir de la fenêtre principale.
 
-Le bouton \includegraphics[width=0.5cm]{../../../src/View/ui/ressources/export.png} vous permet d'exporter les résultats au format CSV pour une utilisation en dehors de Pamhyr2.
-Vous pouvez soit vous placer en un point kilométrique (PK) donné (celui marqué en rouge sur la visualisation du profil en long ou sélectionné dans le tableau) et exporter la hauteur d'eau, le niveau d'eau le débit ou autre en fonction du temps (sélectionnez alors \texttt{Temps (s)} pour l'axe X), soit vous placer à un instant donné et exporter la grandeur de votre choix  pour tous les points kilométriques de votre maillage (sélectionnez alors \texttt{Point Kilométrique (m)} pour l'axe X).
-Si vous choisissez cette seconde option, cocher \texttt{envelop} vous permettra d'exporter en plus la valeur maximale au cours du temps pour la grandeur choisie.
-
-Ainsi dans l'exemple ci-dessous, les données exportées le seront au point kilométrique 34000\,m, à l'instant $t=1$ jour et 12h.
 \begin{center}
-\includegraphics[width=15cm]{img/export_resultats.png}
+\includegraphics[width=15cm]{img/export_resultats_commentee.png}
-\includegraphics[width=12cm]{img/export_resultats2.png}
+%\includegraphics[width=12cm]{../../../src/View/ui/ressources/export_resultats2.png}
 \par\end{center}
 
+Le bouton \includegraphics[width=0.5cm]{../../../src/View/ui/ressources/export.png} vous permet d'exporter les résultats au format CSV pour une utilisation en dehors de Pamhyr2.
+
+Deux options s'offrent à vous :
+\begin{itemize}
+	\item Vous souhaitez avoir une vue d'ensemble du cours d'eau (et tracer une courbe de remous par exemple). Vous allez exporter une variable en un instant donné tout le long du cours d'eau. Il faut alors vous placer à un instant donné (à l'aide du curseur en bas à gauche) et exporter la grandeur de votre choix  pour tous les points kilométriques de votre maillage. Dans la fenêtre d'export, vous devrez sélectionner \texttt{Point Kilométrique (m)} pour l'axe X, et la variable que vous souhaitez exporter pour l'axe Y.
+
+Cocher \texttt{enveloppe} vous permettra d'exporter en plus les valeurs minimale et maximale au cours du temps pour la grandeur choisie.
+
+Par exemple, vous choisissez d'exporter la cote du fond et la cote de l'eau et vous cochez \texttt{enveloppe}. Vous obtiendrez un tableau avec les colonnes suivantes :
+\begin{itemize}
+	\item \texttt{Point Kilométrique (m)} : toutes les valeurs de PK le long de votre bief
+	\item \texttt{Cote du fond (m)} : la cote du fond correspondante à chaque PK
+	\item \texttt{Cote de l'eau (m)} : la cote de l'eau correspondante à chaque PK à l'instant sélectionné (voir figure ci-dessous)
+	\item \texttt{Cote de l'eau min (m)} : la cote de l'eau minimale atteinte correspondante à chaque PK
+	\item \texttt{Cote de l'eau max (m)} : la cote de l'eau maximale atteinte correspondante à chaque PK
+\end{itemize}
+ces deux dernières colonnes constituant l'enveloppe de la cote de l'eau.
+	\item Vous souhaitez regarder l'évolution au cours du temps de ce qu'il se passe en un point précis du cours d'eau (regarder l'hydrogramme de crue à l'aval d'un aménagement par exemple). Vous devez alors vous placer au point kilométrique (PK) qui vous intéresse (le PK sélectionné est marqué en rouge sur la visualisation du profil en long ou sélectionné dans le tableau) et exporter la hauteur d'eau, le niveau d'eau, le débit ou autre en fonction du temps. Dans la fenêtre d'export, vous devrez sélectionner \texttt{Temps (s)} pour l'axe X.
+\end{itemize}
+
+Ainsi dans l'exemple ci-dessus, les données exportées le seront au point kilométrique 34000\,m, à l'instant $t=1$ jour et 12h.
+
+
+\pagebreak{}
+
 \section{Premier scénario d'aménagement : abaissement du seuil}
 
 Parmi les 3 options d'aménagement évoquées par la collectivité locale, jouer sur le contrôle aval en abaissant le seuil qui marque la jonction avec le canal de Condé-Pommeroeul peut faire baisser le niveau à l’amont.
@@ -156,6 +176,8 @@ Sur quelle distance le seuil aval influence-t-il la hauteur d'eau ?
 Est-ce suffisant pour limiter la hauteur d'eau au niveau du pont de l'A2 ($PK \approx 33000$\,m) ?
 \end{remark}
 
+\pagebreak{}
+
 \section{Second scénario d'aménagement : élargissement du lit moyen}
 
 Ce scénario d'aménagement consiste à essayer d’augmenter le laminage en créant un lit moyen en rive droite entre les PKs 32 015 et 33 920\,m. Pour rappel, cette localisation est imposée pour des raisons de disponibilité des terrains et on ne peut pas envisager une largeur du lit moyen supérieure à 50 mètres.
@@ -166,8 +188,9 @@ Pourquoi élargir le lit moyen peut-il avoir un effet sur le niveau d'eau durant
 
 Pour élargir le lit moyen, la géométrie doit être modifiée.
 Il est judicieux d'enregistrer votre étude sous un autre nom avant de procéder à ces modifications (cliquez sur \texttt{[Fichier] => [Sauvegarder sous]}).
-Le plus simple est de repartir de la géométrie avant maillage avant de modifier les transects.
+
-Vous pouvez supprimer les sections interpolées en les sélectionnant dans la fenêtre \textit{Géométrie} et en appuyant sur le bouton \includegraphics[width=0.5cm]{../../../src/View/ui/ressources/del.png}.
+Vous aurez un certain nombre de sections à modifier. Pour limiter leur nombre, le plus simple est de repartir de la géométrie initiale (avant maillage) avant de modifier les transects et de mailler à nouveau après les modifications.
+Vous pouvez supprimer les sections interpolées (notées interpol\textit{i}) en les sélectionnant dans la fenêtre \textit{Géométrie} et en appuyant sur le bouton \includegraphics[width=0.5cm]{../../../src/View/ui/ressources/del.png}.
 
 Cliquez sur \texttt{[Géométrie] => [Modifier la géométrie]} ou sur l'icône \includegraphics[width=0.5cm]{../../../src/View/ui/ressources/geometry.png} pour définir la géométrie du bief.
 Sélectionnez la section en travers que vous souhaitez modifier.
@@ -197,6 +220,8 @@ Quel est l'effet de cet aménagement sur l'hydrogramme de crue ?
 Peut-on s'attendre à ce résultat compte tenu du volume qu'il est possible de stocker en lit moyen et du volume total de la crue ?
 \end{remark}
 
+\pagebreak{}
+
 \section{Troisième scénario d'aménagement : casier de stockage}
 
 Ce troisième scénario consiste à faire baisser le débit dans la rivière en créant un déversement vers un casier de stockage en rive gauche juste en aval du pont de l'A2.
@@ -216,7 +241,7 @@ Cliquez sur \texttt{[Réseau] => [Modifier le réseau]} ou sur l'icône \include
 Le réseau pour la configuration de référence ne comportait qu'un seul bief entre deux noeuds.
 Pour ajouter un casier, il faut ajouter un noeud pour la diffluence, un noeud en amont du casier et un noeud en aval du casier.
 Le casier ne peut en effet pas être en limite aval du modèle ni directement au niveau de la confluence.
-Pour ajouter un noeud, cliquez \includegraphics[width=0.5cm]{../../../src/View/ui/ressources/add.png} pour sélectionner l'outil ``d'addition'' et cliquez ensuite dans la fenêtre grise à l'endroit ou vous souhaitez ajouter un noeud.
+Pour ajouter un noeud, cliquez sur \includegraphics[width=0.5cm]{../../../src/View/ui/ressources/add.png} pour sélectionner l'outil ``d'addition'' et cliquez ensuite dans la fenêtre grise à l'endroit ou vous souhaitez ajouter un noeud.
 De la même façon vous pourrez avec cet outil ajouter un bief entre deux noeuds en cliquant successivement sur l'un puis sur l'autre.
 Vous pourrez alors créer un réseau tel que celui ci-dessous où DevLat est le noeud marquant la diffluence.
 \begin{center}
@@ -236,6 +261,11 @@ Il vous faudra supprimer les sections dans l'un que vous implémenterez dans l'a
 L'outil d'import de géométrie pourra  vous aider.
 Il faudra le cas échéant réimplémenter également les ouvrages.
 
+Vous devrez ensuite implémenter le casier sur le noeud nommé casier. Cliquez sur \texttt{[Hydraulique] => [Casiers]}. Vous pouvez ajouter un casier en cliquant sur \includegraphics[width=0.5cm]{../../../src/View/ui/ressources/add.png}. Vous devrez ensuite configurer le casier  en cliquant sur l'icône \includegraphics[width=0.5cm]{"../../../src/View/ui/ressources/edit.png"}. Pour chaque altitude, vous pouvez définir l'aire de stockage (en ha). Vous pourrez ainsi configurer votre casier de la façon suivante :
+\begin{center}
+\includegraphics[width=10cm]{img/Casier.png}
+\par\end{center}
+
 Lancez le calcul pour chacune des crues proposées avec ce nouvel aménagement.
 
 \begin{remark}

doc/users/TP_Hydraulique_Hogneau/step-by-step.tex

@@ -101,7 +101,7 @@ Authors : & Pierre-Antoine Rouby & pierre-antoine.rouby@inrae.fr\tabularnewline
 
 \section{Install Pamhyr2}
 
-Pamhyr2 can be downloaded from \url{https://gitlab.irstea.fr/theophile.terraz/pamhyr}.
+Pamhyr2 can be downloaded from \url{https://gitlab.com/pamhyr/pamhyr2}.
 \begin{center}
 \includegraphics[width=15cm]{img/dl.png}
 \par\end{center}

src/Model/BoundaryConditionsAdisTS/BoundaryConditionAdisTS.py

@@ -222,3 +222,82 @@ class BoundaryConditionAdisTS(SQLSubModel):
     @property
     def data(self):
         return self._data.copy()
+
+    @property
+    def _default_0(self):
+        return self._types[0](0)
+
+    @property
+    def _default_1(self):
+        return self._types[1](0.0)
+
+    def new_from_data(self, header, data):
+        new_0 = self._default_0
+        new_1 = self._default_1
+
+        if len(header) != 0:
+            for i in [0, 1]:
+                for j in range(len(header)):
+                    if self._header[i] == header[j]:
+                        if i == 0:
+                            new_0 = self._types[i](data[j].replace(",", "."))
+                        else:
+                            new_1 = self._types[i](data[j].replace(",", "."))
+        else:
+            new_0 = self._types[0](data[0].replace(",", "."))
+            new_1 = self._types[1](data[1].replace(",", "."))
+
+        return (new_0, new_1)
+
+    def add(self, index: int):
+        value = (self._default_0, self._default_1)
+        self._data.insert(index, value)
+        self._status.modified()
+        return value
+
+    def insert(self, index: int, value):
+        self._data.insert(index, value)
+        self._status.modified()
+
+    def delete_i(self, indexes):
+        self._data = list(
+            map(
+                lambda e: e[1],
+                filter(
+                    lambda e: e[0] not in indexes,
+                    enumerate(self.data)
+                )
+            )
+        )
+        self._status.modified()
+
+    def sort(self, _reverse=False, key=None):
+        if key is None:
+            self._data.sort(reverse=_reverse)
+        else:
+            self._data.sort(reverse=_reverse, key=key)
+        self._status.modified()
+
+    def index(self, bc):
+        self._data.index(bc)
+
+    def get_i(self, index):
+        return self.data[index]
+
+    def get_range(self, _range):
+        lst = []
+        for r in _range:
+            lst.append(r)
+        return lst
+
+    def _set_i_c_v(self, index, column, value):
+        v = list(self._data[index])
+        v[column] = self._types[column](value)
+        self._data[index] = tuple(v)
+        self._status.modified()
+
+    def set_i_0(self, index: int, value):
+        self._set_i_c_v(index, 0, value)
+
+    def set_i_1(self, index: int, value):
+        self._set_i_c_v(index, 1, value)

src/Model/Geometry/ProfileXYZ.py

@@ -167,8 +167,7 @@ class ProfileXYZ(Profile, SQLSubModel):
                     filter(
                         lambda s: s.id == sl,
                         data["sediment_layers_list"].sediment_layers
-                    )
+                    ), None)
-                )
 
             data["profile"] = new
             new._points = PointXYZ._db_load(execute, data.copy())

src/Model/HydraulicStructures/HydraulicStructures.py

@@ -155,7 +155,6 @@ class HydraulicStructure(SQLSubModel):
         return new
 
     def _db_save(self, execute, data=None):
-        print("save hs unit")
         execute(f"DELETE FROM hydraulic_structures WHERE id = {self.id}")
 
         input_reach_id = -1

src/Model/InitialConditions/InitialConditions.py

@@ -384,6 +384,8 @@ class InitialConditions(SQLSubModel):
             width = profile.wet_width(profile.z_min() + height)
             frictions = self._reach.frictions.frictions
             strickler = None
+            if frictions is not None:
+                if len(frictions) >= 1:
                     for f in frictions:
                         if f.contains_rk(profile.rk):
                             strickler = f.get_friction(profile.rk)[0]
@@ -423,6 +425,8 @@ class InitialConditions(SQLSubModel):
     def generate_discharge(self, discharge: float, compute_height: bool):
 
         profiles = self._reach.reach.profiles.copy()
+        if profiles is None:
+            return None
         profiles.reverse()
 
         previous_elevation = -99999.99
@@ -443,6 +447,8 @@ class InitialConditions(SQLSubModel):
             width = profile.width_approximation()
             frictions = self._reach.frictions.frictions
             strickler = None
+            if frictions is not None:
+                if len(frictions) >= 1:
                     for f in frictions:
                         if f.contains_rk(profile.rk):
                             strickler = f.get_friction(profile.rk)[0]

src/Model/Pollutants/Pollutants.py

@@ -45,6 +45,9 @@ class Pollutants(SQLSubModel):
         else:
             self.id = id
 
+        if name is None or name == "":
+            self.name = f"pol{self.id}"
+        else:
             self._name = str(name)
         self._enabled = True
 
@@ -179,7 +182,6 @@ class Pollutants(SQLSubModel):
 
     def new_from_data(self, data):
 
-        print("from_data before : ", data)
         try:
             new = [int(data[0])]
             new += [float(d) for d in data[1:]]
@@ -187,8 +189,6 @@ class Pollutants(SQLSubModel):
             logger.error(e)
             new = None
 
-        print("from_data after : ", new)
-
         return new
 
     def __len__(self):

src/Model/Results/Results.py

@@ -56,6 +56,10 @@ class Results(object):
     def set(self, key, value):
         self._meta_data[key] = value
 
+    @property
+    def is_valid(self):
+        return ("timestamps" in self._meta_data)
+
     def get(self, key):
         return self._meta_data[key]
 

src/Model/Results/River/River.py

@@ -57,7 +57,10 @@ class Profile(object):
         )
 
     def get_ts_key(self, timestamp, key):
+        if timestamp in self._data:
+            if key in self._data[timestamp]:
                 return self._data[timestamp][key]
+        return None
 
     def has_sediment(self):
         return any(map(lambda ts: "sl" in self._data[ts], self._data))

src/Solver/AdisTS.py

@@ -128,9 +128,9 @@ class AdisTS(CommandLineSolver):
                     repertory, f"{name}.REP"
                 ), "w+"
         ) as f:
-
+            path = os.path.join("..", mage_rep, name)
-            f.write(f"NET ../{mage_rep}/{name}.NET\n")
+            f.write(f"NET {path}.NET\n")
-            f.write(f"REP ../{mage_rep}/{name}.REP\n")
+            f.write(f"REP {path}.REP\n")
 
             for file in files:
                 EXT = file.split('.')[1]
@@ -140,7 +140,7 @@ class AdisTS(CommandLineSolver):
 
         path_mage_net = os.path.join(os.path.abspath(
                 os.path.join(repertory, os.pardir)
-        ), f"{mage_rep}/net")
+        ), os.path.join(mage_rep, "net"))
         path_adists_net = os.path.join(repertory, "net")
 
         if os.path.exists(path_mage_net):
@@ -729,7 +729,7 @@ class AdisTSwc(AdisTS):
         data_tmp = {}
 
         for file_bin in path_files:
-            key_pol = file_bin.split("/")[-1][0:-4]
+            key_pol = os.path.basename(file_bin)[0:-4]
             data_tmp[key_pol] = {}
             with open(file_bin, 'rb') as f:
                 # header

src/Solver/Mage.py

@@ -717,7 +717,7 @@ class Mage(CommandLineSolver):
     # RESULTS #
     ###########
 
-    def read_bin(self, study, repertory, results, qlog=None, name="0"):
+    def read_bin(self, study, fname, results, qlog=None, name="0"):
         return
 
     @timer
@@ -728,7 +728,16 @@ class Mage(CommandLineSolver):
             repertory=repertory,
             name=name,
         )
-        self.read_bin(study, repertory, results, qlog, name=name)
+        fname = os.path.join(repertory, f"{name}.BIN")
+        if not os.path.isfile(fname):
+            logger.info(f"Result file {name}.BIN does not exist")
+            return None
+        try:
+            self.read_bin(study, fname, results, qlog, name=name)
+        except Exception as e:
+            logger.error(f"Failed to read results")
+            logger_exception(e)
+            return None
 
         return results
 
@@ -934,8 +943,7 @@ class Mage8(Mage):
     ###########
 
     @timer
-    def read_bin(self, study, repertory, results, qlog=None, name="0"):
+    def read_bin(self, study, fname, results, qlog=None, name="0"):
-        fname = os.path.join(repertory, f"{name}.BIN")
         logger.info(f"read_bin: Start reading '{fname}' ...")
 
         with mage_file_open(fname, "r") as f:
@@ -986,6 +994,7 @@ class Mage8(Mage):
 
             reachs = []
             iprofiles = {}
+            profile_len = []
             reach_offset = {}
 
             data = read_int(2*nb_reach)
@@ -1005,6 +1014,7 @@ class Mage8(Mage):
 
                 # Profile ID offset
                 reach_offset[r] = i1
+                profile_len.append(i2-i1+1)
 
             logger.debug(f"read_bin: iprofiles = {iprofiles}")
 
@@ -1033,6 +1043,15 @@ class Mage8(Mage):
             ]
             def ip_to_ri(r, i): return i - reach_offset[r]
 
+            # check results and geometry consistency
+            for i, r in enumerate(reachs):
+                lp = len(r.profiles)
+                pl = profile_len[i]
+                if lp != pl:
+                    logger.warning(f"geometry reach {i} has {lp} profiles")
+                    logger.warning(f"results reach {i} has {pl} values")
+                    return
+
             ts = set()
             end = False
             while not end:
@@ -1042,7 +1061,7 @@ class Mage8(Mage):
                     f, dtype=np.byte, count=1)).decode()
                 data = read_float(n)
 
-                logger.debug(f"read_bin: timestamp = {timestamp} sec")
+                # logger.debug(f"read_bin: timestamp = {timestamp} sec")
                 ts.add(timestamp)
 
                 if key in ["Z", "Q"]:
@@ -1066,7 +1085,6 @@ class Mage8(Mage):
                 endline()
                 end = newline().size <= 0
 
-            logger.debug(reachs[0].profiles[0]._data)
             results.set("timestamps", ts)
             ts_list = sorted(ts)
             logger.info(f"compute tab...")
@@ -1265,6 +1283,8 @@ class Mage8(Mage):
             name = study.name.replace(" ", "_")
 
         results = super(Mage8, self).results(study, repertory, qlog, name=name)
+        if results is None:
+            return None
         if with_gra:
             self.read_gra(study, repertory, results, qlog, name=name)
 

src/View/BoundaryConditionsAdisTS/Edit/Table.py

@@ -41,7 +41,7 @@ from PyQt5.QtWidgets import (
 )
 
 from View.BoundaryConditionsAdisTS.Edit.UndoCommand import (
-    AddCommand, DelCommand, SetDataCommand,
+    AddCommand, DelCommand, SetDataCommand, PasteCommand, SortCommand,
 )
 
 _translate = QCoreApplication.translate
@@ -118,3 +118,40 @@ class TableModel(PamhyrTableModel):
         )
 
         self.endRemoveRows()
+
+    def sort(self, _reverse, parent=QModelIndex()):
+        self.layoutAboutToBeChanged.emit()
+
+        self._undo.push(
+            SortCommand(
+                self._data, _reverse
+            )
+        )
+
+        self.layoutAboutToBeChanged.emit()
+        self.update()
+
+    def paste(self, row, header, data):
+        if len(data) == 0:
+            return
+
+        self.layoutAboutToBeChanged.emit()
+
+        self._undo.push(
+            PasteCommand(
+                self._data, row,
+                list(
+                    map(
+                        lambda d: self._data.new_from_data(header, d),
+                        data
+                    )
+                )
+            )
+        )
+
+        self.layoutAboutToBeChanged.emit()
+        self.update()
+
+    def update(self):
+        # self.auto_sort()
+        self.layoutChanged.emit()

src/View/BoundaryConditionsAdisTS/Edit/UndoCommand.py

@@ -38,29 +38,14 @@ class SetDataCommand(QUndoCommand):
         self._data = data
         self._index = index
         self._column = column
-        self._old = self._data._data[self._index][self._column]
+        self._old = self._data.get_i(self._index)[self._column]
-        _type = self._data._types[self._column]
+        self._new = new_value
-        self._new = _type(new_value)
 
     def undo(self):
-        if self._column == 0:
+        self._data._set_i_c_v(self._index, self._column, self._old)
-            self._data._data[self._index] = (
-                self._old, self._data._data[self._index][1]
-            )
-        else:
-            self._data._data[self._index] = (
-                self._data._data[self._index][0], self._old
-            )
 
     def redo(self):
-        if self._column == 0:
+        self._data._set_i_c_v(self._index, self._column, self._new)
-            self._data._data[self._index] = (
-                self._new, self._data._data[self._index][1]
-            )
-        else:
-            self._data._data[self._index] = (
-                self._data._data[self._index][0], self._new
-            )
 
 
 class AddCommand(QUndoCommand):
@@ -76,11 +61,11 @@ class AddCommand(QUndoCommand):
 
     def redo(self):
         if self._new is None:
-            self._new = self._data._data.insert(self._index, (
+            self._new = self._data.insert(self._index, (
                 self._data._types[0](0), self._data._types[1](0.0)
             ))
         else:
-            self._data._data.insert(self._index, self._new)
+            self._data.insert(self._index, self._new)
 
 
 class DelCommand(QUndoCommand):
@@ -97,8 +82,57 @@ class DelCommand(QUndoCommand):
 
     def undo(self):
         for row, el in self._bc:
-            self._data._data.insert(row, el)
+            self._data.insert(row, el)
 
     def redo(self):
-        for row in self._rows:
+        self._data.delete_i(self._rows)
-            del self._data._data[row]
+
+
+class PasteCommand(QUndoCommand):
+    def __init__(self, data, row, bcs):
+        QUndoCommand.__init__(self)
+
+        self._data = data
+        self._row = row
+        self._bcs = bcs
+        self._bcs.reverse()
+
+    def undo(self):
+        self._data.delete_i(
+            range(self._row, self._row + len(self._bcs))
+        )
+
+    def redo(self):
+        for bc in self._bcs:
+            self._data.insert(self._row, bc)
+
+
+class SortCommand(QUndoCommand):
+    def __init__(self, data, _reverse):
+        QUndoCommand.__init__(self)
+
+        self._data = data
+        self._reverse = _reverse
+
+        self._old = self._data.data
+        self._indexes = None
+
+    def undo(self):
+        ll = self._data.data
+        self._data.sort(
+            key=lambda x: self._indexes[ll.index(x)]
+        )
+
+    def redo(self):
+        self._data.sort(
+            _reverse=self._reverse,
+            key=lambda x: x[0]
+        )
+        if self._indexes is None:
+            self._indexes = list(
+                map(
+                    lambda p: self._old.index(p),
+                    self._data.data
+                )
+            )
+            self._old = None

src/View/BoundaryConditionsAdisTS/Edit/Window.py

@@ -143,7 +143,7 @@ class EditBoundaryConditionWindow(PamhyrWindow):
     def setup_connections(self):
         self.find(QAction, "action_add").triggered.connect(self.add)
         self.find(QAction, "action_del").triggered.connect(self.delete)
-
+        self.find(QAction, "action_sort").triggered.connect(self.sort)
         self._table.dataChanged.connect(self.update)
 
     def update(self):
@@ -200,6 +200,22 @@ class EditBoundaryConditionWindow(PamhyrWindow):
 
         self.copyTableIntoClipboard(table)
 
+    def _paste(self):
+        header, data = self.parseClipboardTable()
+
+        logger.debug(f"paste: h:{header}, d:{data}")
+
+        if len(data) == 0:
+            return
+
+        row = 0
+        rows = self.index_selected_rows()
+        if len(rows) != 0:
+            row = rows[0]
+
+        self._table.paste(row, header, data)
+        self.plot.update()
+
     def _undo(self):
         self._table.undo()
         self.plot.update()

src/View/BoundaryConditionsAdisTS/Table.py

@@ -119,17 +119,10 @@ class TableModel(PamhyrTableModel):
 
         super(TableModel, self).__init__(trad=trad, **kwargs)
 
-    def _setup_lst(self):
-        self._lst = self._bc_list.lst
-
     def rowCount(self, parent):
-        return len(self._lst)
+        return len(self._bc_list)
 
     def data(self, index, role):
-        if len(self._lst) != 0:
-            data = self._lst
-        else:
-            data = []
 
         if role != Qt.ItemDataRole.DisplayRole:
             return QVariant()
@@ -138,12 +131,12 @@ class TableModel(PamhyrTableModel):
         column = index.column()
 
         if self._headers[column] == "type":
-            n = data[row].type
+            n = self._bc_list.get(row).type
             if n is None or n == "":
                 return self._trad["not_associated"]
             return n
         elif self._headers[column] == "node":
-            n = data[row].node
+            n = self._bc_list.get(row).node
             if n is None:
                 return self._trad["not_associated"]
             tmp = next(filter(lambda x: x.id == n, self._data._nodes), None)
@@ -152,7 +145,7 @@ class TableModel(PamhyrTableModel):
             else:
                 return self._trad["not_associated"]
         elif self._headers[column] == "pol":
-            n = data[row].pollutant
+            n = self._bc_list.get(row).pollutant
             if n is None or n == "not_associated" or n == "":
                 return self._trad["not_associated"]
             tmp = next(filter(lambda x: x.id == n,
@@ -177,20 +170,20 @@ class TableModel(PamhyrTableModel):
             if self._headers[column] == "type":
                 self._undo.push(
                     SetTypeCommand(
-                        self._lst, row, value
+                        self._bc_list, row, value
                     )
                 )
             elif self._headers[column] == "node":
                 self._undo.push(
                     SetNodeCommand(
-                        self._lst, row, self._data.node(value)
+                        self._bc_list, row, self._data.node(value)
                     )
                 )
             elif self._headers[column] == "pol":
                 if value == self._trad["not_associated"]:
                     self._undo.push(
                         SetPolCommand(
-                            self._lst, row, None
+                            self._bc_list, row, None
                         )
                     )
                 else:
@@ -199,7 +192,7 @@ class TableModel(PamhyrTableModel):
                                )
                     self._undo.push(
                         SetPolCommand(
-                            self._lst, row, pol.id
+                            self._bc_list, row, pol.id
                         )
                     )
         except Exception as e:
@@ -214,7 +207,7 @@ class TableModel(PamhyrTableModel):
 
         self._undo.push(
             AddCommand(
-                self._pollutant, self._bc_list, self._lst, row
+                self._pollutant, self._bc_list, row
             )
         )
 
@@ -226,7 +219,7 @@ class TableModel(PamhyrTableModel):
 
         self._undo.push(
             DelCommand(
-                self._lst, rows
+                self._bc_list, rows
             )
         )
 

src/View/BoundaryConditionsAdisTS/UndoCommand.py

@@ -35,14 +35,14 @@ class SetNodeCommand(QUndoCommand):
 
         self._bcs = bcs
         self._index = index
-        self._old = self._bcs[self._index].node
+        self._old = self._bcs.get(self._index).node
         self._new = node.id
 
     def undo(self):
-        self._bcs[self._index].node = self._old
+        self._bcs.get(self._index).node = self._old
 
     def redo(self):
-        self._bcs[self._index].node = self._new
+        self._bcs.get(self._index).node = self._new
 
 
 class SetTypeCommand(QUndoCommand):
@@ -52,14 +52,14 @@ class SetTypeCommand(QUndoCommand):
         self._bcs = bcs
         self._index = index
         self._type = _type
-        self._old = self._bcs[self._index].type
+        self._old = self._bcs.get(self._index).type
         self._new = self._type
 
     def undo(self):
-        self._bcs[self._index].type = self._old
+        self._bcs.get(self._index).type = self._old
 
     def redo(self):
-        self._bcs[self._index].type = self._new
+        self._bcs.get(self._index).type = self._new
 
 
 class SetPolCommand(QUndoCommand):
@@ -68,32 +68,31 @@ class SetPolCommand(QUndoCommand):
 
         self._bcs = bcs
         self._index = index
-        self._old = self._bcs[self._index].pollutant
+        self._old = self._bcs.get(self._index).pollutant
         self._new = pollutant
 
     def undo(self):
-        self._bcs[self._index].pollutant = self._old
+        self._bcs.get(self._index).pollutant = self._old
 
     def redo(self):
-        self._bcs[self._index].pollutant = self._new
+        self._bcs.get(self._index).pollutant = self._new
 
 
 class AddCommand(QUndoCommand):
-    def __init__(self, pollutant, bcs_list, bcs, index):
+    def __init__(self, pollutant, bcs, index):
         QUndoCommand.__init__(self)
 
         self._bcs = bcs
-        self._bc_list = bcs_list
         self._pollutant = pollutant
         self._index = index
         self._new = None
 
     def undo(self):
-        del self._bcs[self._index]
+        self._bcs.delete_i([self._index])
 
     def redo(self):
         if self._new is None:
-            self._new = self._bc_list.new(self._index, self._pollutant)
+            self._new = self._bcs.new(self._index, self._pollutant)
         else:
             self._bcs.insert(self._index, self._new)
 
@@ -107,7 +106,7 @@ class DelCommand(QUndoCommand):
 
         self._bc = []
         for row in rows:
-            self._bc.append((row, self._bcs[row]))
+            self._bc.append((row, self._bcs.get(row)))
         self._bc.sort()
 
     def undo(self):
@@ -115,5 +114,4 @@ class DelCommand(QUndoCommand):
             self._bcs.insert(row, el)
 
     def redo(self):
-        for row in self._rows:
+        self._bcs.delete_i(self._rows)
-            del self._bcs[row]

src/View/BoundaryConditionsAdisTS/Window.py

@@ -180,7 +180,10 @@ class BoundaryConditionAdisTSWindow(PamhyrWindow):
     def edit(self):
         rows = self.index_selected_rows()
         for row in rows:
-            data = self._bcs.lst[row]
+            data = self._bcs.get(row)
+
+            if data.node is None:
+                continue
 
             if self.sub_window_exists(
                 EditBoundaryConditionWindow,

src/View/D90AdisTS/Table.py

@@ -175,7 +175,6 @@ class D90TableModel(PamhyrTableModel):
                     )
                 )
             elif self._headers[column] == "reach":
-                print(self._river.edge(value).id)
                 self._undo.push(
                     SetCommandSpec(
                         self._lst, row, self._headers[column],

src/View/D90AdisTS/Window.py

@@ -279,9 +279,7 @@ class D90AdisTSWindow(PamhyrWindow):
             self._table_spec.add(rows[0])
 
     def delete(self):
-        print("del")
         rows = self.index_selected_rows()
         if len(rows) == 0:
-            print("len 0")
             return
         self._table_spec.delete(rows)

src/View/InitialConditions/Window.py

@@ -23,6 +23,7 @@ from tools import trace, timer, logger_exception
 
 from View.Tools.PamhyrWindow import PamhyrWindow
 
+from PyQt5 import QtWidgets
 from PyQt5.QtGui import (
     QKeySequence,
 )
@@ -30,7 +31,7 @@ from PyQt5.QtGui import (
 from PyQt5.QtCore import (
     Qt, QVariant, QAbstractTableModel,
     QCoreApplication, QModelIndex, pyqtSlot,
-    QRect,
+    QRect, QSettings, QItemSelectionModel,
 )
 
 from PyQt5.QtWidgets import (
@@ -260,16 +261,23 @@ class InitialConditionsWindow(PamhyrWindow):
         self._update()
 
     def import_from_file(self):
-        workdir = os.path.dirname(self._study.filename)
+        options = QFileDialog.Options()
-
+        settings = QSettings(QSettings.IniFormat,
-        return self.file_dialog(
+                             QSettings.UserScope, 'MyOrg', )
-            select_file="ExistingFile",
+        options |= QFileDialog.DontUseNativeDialog
-            callback=lambda d: self._import_from_file(d[0]),
+        filename, _ = QtWidgets.QFileDialog.getOpenFileName(
-            directory=workdir,
+            self,
-            default_suffix=".BIN",
+            self._trad["open_file"],
-            file_filter=["Mage (*.BIN)"],
+            "",
+            ";; ".join(["Mage (*.BIN)"]),
+            options=options
         )
 
+        if filename != "":
+            size = os.stat(filename).st_size
+            # self._table.import_geometry(0, filename)
+            self._import_from_file(filename)
+
     def _import_from_file(self, file_name):
         solver = Mage8("dummy")
         name = os.path.basename(file_name)\
@@ -292,6 +300,7 @@ class InitialConditionsWindow(PamhyrWindow):
         )
         dlg.exec_()
         results = self._tmp_results
+        if results.is_valid:
             self._import_from_results(results)
 
     def _import_from_results(self, results):

src/View/InitialConditionsAdisTS/Table.py

@@ -194,7 +194,6 @@ class InitialConditionTableModel(PamhyrTableModel):
                     )
                 )
             elif self._headers[column] == "reach":
-                print(self._river.edge(value).id)
                 self._undo.push(
                     SetCommandSpec(
                         self._lst, row, self._headers[column],

src/View/InitialConditionsAdisTS/Window.py

@@ -281,9 +281,7 @@ class InitialConditionsAdisTSWindow(PamhyrWindow):
             self._table_spec.add(rows[0])
 
     def delete(self):
-        print("del")
         rows = self.index_selected_rows()
         if len(rows) == 0:
-            print("len 0")
             return
         self._table_spec.delete(rows)

src/View/MainWindow.py

@@ -77,14 +77,18 @@ from View.SedimentLayers.Reach.Window import ReachSedimentLayersWindow
 from View.AdditionalFiles.Window import AddFileListWindow
 from View.REPLines.Window import REPLineListWindow
 from View.SolverParameters.Window import SolverParametersWindow
-from View.RunSolver.Window import SelectSolverWindow, SolverLogWindow
+from View.RunSolver.Window import (
+                                   SelectSolverWindow,
+                                   SolverLogWindow,
+                                   CompareSolversWindow
+                                   )
+from View.Results.Window import ResultsWindow
 from View.RunSolver.WindowAdisTS import (
     SelectSolverWindowAdisTS,
     SolverLogWindowAdisTS
 )
 from View.CheckList.Window import CheckListWindow
 from View.CheckList.WindowAdisTS import CheckListWindowAdisTS
-from View.Results.Window import ResultsWindow
 from View.Results.WindowAdisTS import ResultsWindowAdisTS
 from View.Results.ReadingResultsDialog import ReadingResultsDialog
 from View.Debug.Window import ReplWindow
@@ -93,6 +97,10 @@ from View.Pollutants.Window import PollutantsWindow
 from View.D90AdisTS.Window import D90AdisTSWindow
 from View.DIFAdisTS.Window import DIFAdisTSWindow
 
+from Solver.Solvers import GenericSolver
+
+from Model.Results.Results import Results
+
 # Optional internal display of documentation for make the application
 # package lighter...
 try:
@@ -135,7 +143,7 @@ define_model_action = [
     "action_menu_edit_reach_sediment_layers", "action_menu_edit_reservoirs",
     "action_menu_edit_hydraulic_structures", "action_menu_additional_file",
     "action_menu_results_last", "action_open_results_from_file",
-    "action_menu_boundary_conditions_sediment",
+    "action_compare_results", "action_menu_boundary_conditions_sediment",
     "action_menu_rep_additional_lines", "action_menu_output_rk",
     "action_menu_run_adists", "action_menu_pollutants",
     "action_menu_d90", "action_menu_dif",
@@ -280,6 +288,7 @@ class ApplicationWindow(QMainWindow, ListedSubWindow, WindowToolKit):
             "action_menu_close": self.close_model,
             "action_menu_results_last": self.open_last_results,
             "action_open_results_from_file": self.open_results_from_file,
+            "action_compare_results": self.compare_results,
             "action_open_results_adists": self.open_results_adists,
             # Help
             "action_menu_pamhyr_users_wiki": self.open_doc_user,
@@ -339,10 +348,12 @@ class ApplicationWindow(QMainWindow, ListedSubWindow, WindowToolKit):
     def closeEvent(self, event):
         if not self._close_question:
             if self._study is not None and not self._study.is_saved:
-                if self.dialog_close(cancel=False):
+                if self.dialog_close():
                     # PAMHYR is close correctly (no crash)
                     self.conf.set_close_correctly()
                     super(ApplicationWindow, self).closeEvent(event)
+                else:
+                    event.ignore()
         else:
             super(ApplicationWindow, self).closeEvent(event)
 
@@ -522,7 +533,7 @@ class ApplicationWindow(QMainWindow, ListedSubWindow, WindowToolKit):
         self.update()
 
     def close_model(self):
-        if not self.dialog_close(cancel=True):
+        if not self.dialog_close():
             return
 
         self._study = None
@@ -824,20 +835,18 @@ class ApplicationWindow(QMainWindow, ListedSubWindow, WindowToolKit):
 
         return file
 
-    def dialog_close(self, cancel=True):
+    def dialog_close(self):
         dlg = QMessageBox(self)
 
         dlg.setWindowTitle(self._trad["mb_close_title"])
         dlg.setText(self._trad["mb_close_msg"])
         opt = QMessageBox.Save | QMessageBox.Close
-        if cancel:
         opt |= QMessageBox.Cancel
 
         dlg.setStandardButtons(opt)
         dlg.setIcon(QMessageBox.Warning)
         dlg.button(QMessageBox.Save).setText(self._trad["Save"])
         dlg.button(QMessageBox.Close).setText(self._trad["Close"])
-        if cancel:
         dlg.button(QMessageBox.Cancel).setText(self._trad["Cancel"])
 
         res = dlg.exec()
@@ -1310,7 +1319,6 @@ class ApplicationWindow(QMainWindow, ListedSubWindow, WindowToolKit):
         #                      self.conf.solvers))
         # solver = next(filter(lambda x: x.name == "AdisTS-WC",
         #                      self.conf.solvers))
-        # print(solver._type)
         # self.run_solver(solver)
 
         run = SelectSolverWindowAdisTS(
@@ -1423,22 +1431,25 @@ class ApplicationWindow(QMainWindow, ListedSubWindow, WindowToolKit):
         if results is None:
             return
 
+        # results does not have values, for example if geometry missmatch
+        if not results.is_valid:
+            return
+
         # Windows already opened
         if self.sub_window_exists(
                 ResultsWindow,
                 data=[
                     self._study,
-                    None,       # No config
+                    None,      # No config,
-                    solver,
+                    results._solver,
-                    results
+                    results._repertory,
-                ]
+                    results._name]
         ):
             return
 
         res = ResultsWindow(
             study=self._study,
-            solver=solver,
+            results=[results],
-            results=results,
             parent=self
         )
         res.show()
@@ -1487,7 +1498,8 @@ class ApplicationWindow(QMainWindow, ListedSubWindow, WindowToolKit):
                     self._study,
                     None,       # No config
                     solver,
-                    results
+                    results._repertory,
+                    results._name,
                 ]
         ):
             return
@@ -1525,9 +1537,6 @@ class ApplicationWindow(QMainWindow, ListedSubWindow, WindowToolKit):
         if self._study is None:
             return
 
-        if self._study.filename == "":
-            return
-
         options = QFileDialog.Options()
         options |= QFileDialog.DontUseNativeDialog
 
@@ -1538,6 +1547,7 @@ class ApplicationWindow(QMainWindow, ListedSubWindow, WindowToolKit):
         # dialog.setFilter(dialog.filter() | QtCore.QDir.Hidden)
         dialog.setNameFilters(['Mage (*.BIN)'])
 
+        if self._study.filename is not None:
             if self._last_solver is None:
                 dialog.setDirectory(
                     os.path.dirname(self._study.filename)
@@ -1555,6 +1565,134 @@ class ApplicationWindow(QMainWindow, ListedSubWindow, WindowToolKit):
                 results=file_name[0]
             )
 
+    def compare_results(self):
+        if self._study is None:
+            return
+
+        run = CompareSolversWindow(
+            study=self._study,
+            config=self.conf,
+            parent=self
+        )
+        if run.exec():
+            results = self.diff_results(run.solver1,
+                                        run.solver2)
+        else:
+            return
+
+        # At least one result not available
+        if results is None:
+            return
+
+        # Windows already opened
+        if self.sub_window_exists(
+                ResultsWindow,
+                data=[self._study, None] +
+                     [r._solver for r in results] +
+                     [r._repertory for r in results] +
+                     [r._name for r in results]
+        ):
+            return
+
+        res = ResultsWindow(
+            study=self._study,
+            results=results,
+            parent=self
+        )
+        res.show()
+
+    def diff_results(self, solver1, solver2):
+        if solver1 is None:
+            # TODO message
+            return None
+        if solver2 is None:
+            # TODO message
+            return None
+
+        solver3 = GenericSolver(solver1.name+" - "+solver2.name)
+        solver4 = GenericSolver(solver1.name)
+        solver5 = GenericSolver(solver2.name)
+
+        result1 = solver1.results(
+                        self._study,
+                        self._solver_workdir(solver1),
+                    )
+
+        if result1 is None:
+            # TODO message
+            return None
+
+        result2 = solver2.results(
+                        self._study,
+                        self._solver_workdir(solver2),
+                    )
+
+        if result2 is None:
+            # TODO message
+            return None
+
+        if result2.get("nb_reach") != result1.get("nb_reach"):
+            # TODO message
+            return None
+
+        if result2.get("nb_profile") != result1.get("nb_profile"):
+            # TODO message
+            return None
+
+        # return [result1, result2]
+
+        result3 = Results(self._study, solver3)
+        result4 = Results(self._study, solver1)
+        result5 = Results(self._study, solver2)
+        result3.set("nb_reach", result1.get("nb_reach"))
+        result4.set("nb_reach", result1.get("nb_reach"))
+        result5.set("nb_reach", result1.get("nb_reach"))
+        result3.set("nb_profile", result1.get("nb_profile"))
+        result4.set("nb_profile", result1.get("nb_profile"))
+        result5.set("nb_profile", result1.get("nb_profile"))
+        ts = list(result1.get("timestamps").intersection(
+            result2.get("timestamps")))
+        result3.set("timestamps", ts)
+        result4.set("timestamps", ts)
+        result5.set("timestamps", ts)
+
+        for i in range(int(result1.get("nb_reach"))):
+            # Add reach to results reach list
+            r = result3.river.add(i)
+            r = result4.river.add(i)
+            r = result5.river.add(i)
+
+        for timestamp in result3.get("timestamps"):
+            for r in range(int(result1.get("nb_reach"))):
+                reach1 = result1.river.reach(r)
+                reach2 = result2.river.reach(r)
+                reach3 = result3.river.reach(r)
+                reach4 = result4.river.reach(r)
+                reach5 = result5.river.reach(r)
+                for p, (profile1, profile2) in enumerate(zip(
+                        reach1.profiles, reach2.profiles)):
+                    for key in ["Z", "Q", "V"]:
+                        d1 = profile1.get_ts_key(timestamp, key)
+                        d2 = profile2.get_ts_key(timestamp, key)
+                        d = d1-d2
+                        reach3.set(p, timestamp, key, d)
+                        reach4.set(p, timestamp, key, d1)
+                        reach5.set(p, timestamp, key, d2)
+                    limits = reach3.profile(p).geometry.get_water_limits(
+                            reach3.profile(p).get_ts_key(timestamp, "Z")
+                    )
+                    reach3.set(
+                            p, timestamp,
+                            "water_limits",
+                            limits
+                        )
+                    limits = profile1.get_ts_key(timestamp, "water_limits")
+                    reach4.set(p, timestamp, "water_limits", limits)
+                    limits = profile2.get_ts_key(timestamp, "water_limits")
+                    reach5.set(p, timestamp, "water_limits", limits)
+
+        return [result4, result5, result3]
+
     def open_results_adists(self):
         if self._study is None:
             return

src/View/Reservoir/Edit/Translate.py

@@ -35,5 +35,5 @@ class EditReservoirTranslate(ReservoirTranslate):
 
         self._sub_dict["table_headers"] = {
             "z": self._dict["unit_elevation"],
-            "area": self._dict["unit_area"],
+            "area": self._dict["unit_area_he"],
         }

src/View/Results/CustomExport/CustomExport.py

@@ -0,0 +1,151 @@
+# CustomExport.py -- Pamhyr
+# Copyright (C) 2023-2025  INRAE
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+# -*- coding: utf-8 -*-
+
+from View.Tools.PamhyrWindow import PamhyrDialog
+
+from PyQt5.QtWidgets import (
+    QRadioButton, QCheckBox, QVBoxLayout, QLabel,
+)
+
+from View.Results.translate import ResultsTranslate
+
+
+class CustomExportDialog(PamhyrDialog):
+    _pamhyr_ui = "CustomExportAdisDialog"
+    _pamhyr_name = "Custom Plot Selection"
+
+    def __init__(self, parent=None):
+        trad = ResultsTranslate()
+        super(CustomExportDialog, self).__init__(
+            title=trad[self._pamhyr_name],
+            options=[],
+            trad=trad,
+            parent=parent
+        )
+
+        self._available_values_x = self._trad.get_dict("values_x")
+        self._available_values_y = self._trad.get_dict("values_y")
+
+        self.setup_radio_buttons_x()
+        self.setup_radio_buttons_res()
+        self.setup_envelop_box()
+        self.setup_check_boxes()
+
+        self.value = None
+
+    def setup_radio_buttons_x(self):
+        self._radio = []
+        layout = self.find(QVBoxLayout, "verticalLayout_x")
+
+        for value in self._available_values_x:
+            btn = QRadioButton(
+                self._available_values_x[value],
+                parent=self
+            )
+            self._radio.append((value, btn))
+            layout.addWidget(btn)
+
+        self._radio[0][1].setChecked(True)
+        layout.addStretch()
+
+    def setup_radio_buttons_res(self):
+        self._radio2 = []
+        layout = self.find(QVBoxLayout, "verticalLayout_pol")
+        label = self.find(QLabel, "label_3")
+        label.setText(self._trad["solver"])
+
+        for solver in self.parent._solvers:
+            btn = QRadioButton(
+                solver.name,
+                parent=self
+            )
+            self._radio2.append((solver.name, btn))
+            layout.addWidget(btn)
+
+        self._radio2[0][1].setChecked(True)
+        if len(self.parent._results) == 1:
+            self._radio2[0][1].setEnabled(False)
+            label.setEnabled(False)
+        else:
+            self._radio2[0][1].setEnabled(True)
+            label.setEnabled(True)
+
+        layout.addStretch()
+
+    def setup_envelop_box(self):
+        layout = self.find(QVBoxLayout, "verticalLayout_x")
+        self._envelop = QCheckBox(
+            self._trad["envelop"],
+            parent=self
+        )
+        layout.addWidget(self._envelop)
+        self._envelop.setChecked(True)
+        for r in self._radio:
+            r[1].clicked.connect(self.envelop_box_status)
+
+    def envelop_box_status(self):
+        if self._radio[0][1].isChecked():
+            if len(self.parent._results) > 1:
+                self._envelop.setEnabled(False)
+            else:
+                self._envelop.setEnabled(True)
+        else:
+            self._envelop.setEnabled(False)
+
+    def setup_check_boxes(self):
+        self._check = []
+        layout = self.find(QVBoxLayout, "verticalLayout_y")
+
+        for value in self._available_values_y:
+            btn = QCheckBox(
+                self._available_values_y[value],
+                parent=self
+            )
+            self._check.append((value, btn))
+            layout.addWidget(btn)
+
+        self._check[0][1].setChecked(True)
+        layout.addStretch()
+
+    def accept(self):
+        x = next(
+            filter(
+                lambda r: r[1].isChecked(),
+                self._radio
+            )
+        )[0]
+
+        y = list(
+            map(
+                lambda b: b[0],
+                filter(
+                    lambda b: b[1].isChecked(),
+                    self._check
+                )
+            )
+        )
+
+        res = 0
+        for i, b in enumerate(self._radio2):
+            if b[1].isChecked():
+                res = i
+                break
+
+        self.value = x, y, self._envelop.isChecked(), res
+
+        super().accept()

src/View/Results/CustomExport/CustomExportAdis.py

@@ -1,5 +1,5 @@
-# CustomPlotValuesSelectionDialog.py -- Pamhyr
+# CustomExportAdis.py -- Pamhyr
-# Copyright (C) 2023-2024  INRAE
+# Copyright (C) 2023-2025  INRAE
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU General Public License as published by

src/View/Results/CustomPlot/Plot.py

@@ -49,7 +49,7 @@ unit = {
 
 class CustomPlot(PamhyrPlot):
     def __init__(self, x, y, envelop, reach, profile, timestamp,
-                 data=None, canvas=None, trad=None,
+                 data=None, canvas=None, trad=None, res_id=[0],
                  toolbar=None, parent=None):
         super(CustomPlot, self).__init__(
             canvas=canvas,
@@ -65,6 +65,8 @@ class CustomPlot(PamhyrPlot):
         self._reach = reach
         self._profile = profile
         self._timestamp = timestamp
+        self._current_res_id = res_id[0]
+        self._parent = parent
 
         logger.debug(
             "Create custom plot for: " +
@@ -83,6 +85,7 @@ class CustomPlot(PamhyrPlot):
         )
 
         self._axes = {}
+        self.lines = {}
 
     def draw_bottom_with_bedload(self, reach):
         self._bedrock = self.sl_compute_bedrock(reach)
@@ -130,7 +133,7 @@ class CustomPlot(PamhyrPlot):
         """
         Get SL list for profile p at initial time (initial data)
         """
-        t0 = min(list(self.data.get("timestamps")))
+        t0 = min(list(self.data[self._current_res_id[0]].get("timestamps")))
         return map(
             lambda p: p.get_ts_key(t0, "sl")[0],
             reach.profiles
@@ -145,8 +148,8 @@ class CustomPlot(PamhyrPlot):
             reach.profiles
         )
 
-    def get_ts_zmin(self, profile):
+    def get_ts_zmin(self, profile, res_id):
-        results = self.data
+        results = self.data[res_id]
         nt = len(list(results.get("timestamps")))
         reach = results.river.reach(self._reach)
         berdrock = self.sl_compute_bedrock(reach)
@@ -167,8 +170,11 @@ class CustomPlot(PamhyrPlot):
         return ts_z_min
 
     def _draw_rk(self):
-        results = self.data
+        results = self.data[self._current_res_id]
         reach = results.river.reach(self._reach)
+        if self._current_res_id == 2:  # compare results
+            reach1 = self.data[0].river.reach(self._reach)
+            reach2 = self.data[1].river.reach(self._reach)
         rk = reach.geometry.get_rk()
         if reach.has_sediment():
             z_min = self.draw_bottom_with_bedload(reach)
@@ -204,23 +210,45 @@ class CustomPlot(PamhyrPlot):
                 self._axes[ax].spines['right'].set_position(('outward', shift))
                 shift += 60
 
+        if len(self.lines) != 0:
             self.lines = {}
         if "bed_elevation" in self._y:
 
             ax = self._axes[unit["bed_elevation"]]
+            if self._current_res_id < 2:
                 line = ax.plot(
                     rk, z_min,
                     color='grey', lw=1.,
                 )
+            else:
+                if reach.has_sediment():
+                    z_min1 = self.draw_bottom_with_bedload(reach1)
+                    z_min2 = self.draw_bottom_with_bedload(reach2)
+                else:
+                    z_min1 = reach1.geometry.get_z_min()
+                    z_min2 = reach2.geometry.get_z_min()
+                dz = list(
+                    map(
+                        lambda x, y: x - y,
+                        z_min2, z_min2
+                        )
+                    )
+                line = ax.plot(
+                    rk, dz,
+                    color='grey', lw=1.,
+                )
+
             self.lines["bed_elevation"] = line
 
-            if self._envelop and reach.has_sediment():
+            if (self._envelop and
+                    reach.has_sediment() and
+                    self._current_res_id < 2):
 
                 ax = self._axes[unit["bed_elevation_envelop"]]
 
                 e = list(
                         map(
-                            lambda p: max(self.get_ts_zmin(p)),
+                            lambda p: max(self.get_ts_zmin(p, res_id)),
                             range(len(reach))
                         )
                     )
@@ -233,7 +261,7 @@ class CustomPlot(PamhyrPlot):
 
                 e = list(
                         map(
-                            lambda p: min(self.get_ts_zmin(p)),
+                            lambda p: min(self.get_ts_zmin(p, res_id)),
                             range(len(reach))
                         )
                     )
@@ -253,7 +281,7 @@ class CustomPlot(PamhyrPlot):
             )
             self.lines["water_elevation"] = line
 
-            if "bed_elevation" in self._y:
+            if "bed_elevation" in self._y and self._current_res_id < 2:
                 self.fill = ax.fill_between(
                     rk, z_min, z,
                     color='blue', alpha=0.5, interpolate=True
@@ -370,6 +398,7 @@ class CustomPlot(PamhyrPlot):
         if "depth" in self._y:
 
             ax = self._axes[unit["depth"]]
+            if self._current_res_id < 2:
                 d = list(
                     map(
                         lambda p: p.geometry.max_water_depth(
@@ -377,13 +406,35 @@ class CustomPlot(PamhyrPlot):
                         reach.profiles
                     )
                 )
+            else:
+                d1 = list(
+                    map(
+                        lambda p: p.geometry.max_water_depth(
+                            p.get_ts_key(self._timestamp, "Z")),
+                        reach1.profiles
+                    )
+                )
+                d2 = list(
+                    map(
+                        lambda p: p.geometry.max_water_depth(
+                            p.get_ts_key(self._timestamp, "Z")),
+                        reach2.profiles
+                    )
+                )
+                d = list(
+                    map(
+                        lambda x, y: x - y,
+                        d1, d2
+                        )
+                    )
+
             line = ax.plot(
                 rk, d,
                 color='brown', lw=1.,
             )
             self.lines["depth"] = line
 
-            if self._envelop:
+            if self._envelop and self._current_res_id < 2:
 
                 ax = self._axes[unit["depth_envelop"]]
 
@@ -416,6 +467,7 @@ class CustomPlot(PamhyrPlot):
         if "mean_depth" in self._y:
 
             ax = self._axes[unit["mean_depth"]]
+            if self._current_res_id < 2:
                 d = list(
                     map(
                         lambda p: p.geometry.mean_water_depth(
@@ -423,6 +475,27 @@ class CustomPlot(PamhyrPlot):
                         reach.profiles
                     )
                 )
+            else:
+                d1 = list(
+                    map(
+                        lambda p: p.geometry.mean_water_depth(
+                            p.get_ts_key(self._timestamp, "Z")),
+                        reach1.profiles
+                    )
+                )
+                d2 = list(
+                    map(
+                        lambda p: p.geometry.mean_water_depth(
+                            p.get_ts_key(self._timestamp, "Z")),
+                        reach2.profiles
+                    )
+                )
+                d = list(
+                    map(
+                        lambda x, y: x - y,
+                        d1, d2
+                        )
+                    )
 
             line = ax.plot(
                 rk, d,
@@ -433,6 +506,7 @@ class CustomPlot(PamhyrPlot):
         if "froude" in self._y:
 
             ax = self._axes[unit["froude"]]
+            if self._current_res_id < 2:
                 fr = list(
                     map(
                         lambda p:
@@ -446,6 +520,39 @@ class CustomPlot(PamhyrPlot):
                         reach.profiles
                     )
                 )
+            else:
+                fr1 = list(
+                    map(
+                        lambda p:
+                            p.get_ts_key(self._timestamp, "V") /
+                            sqrt(9.81 * (
+                                p.geometry.wet_area(
+                                    p.get_ts_key(self._timestamp, "Z")) /
+                                p.geometry.wet_width(
+                                    p.get_ts_key(self._timestamp, "Z"))
+                                )),
+                        reach1.profiles
+                    )
+                )
+                fr2 = list(
+                    map(
+                        lambda p:
+                            p.get_ts_key(self._timestamp, "V") /
+                            sqrt(9.81 * (
+                                p.geometry.wet_area(
+                                    p.get_ts_key(self._timestamp, "Z")) /
+                                p.geometry.wet_width(
+                                    p.get_ts_key(self._timestamp, "Z"))
+                                )),
+                        reach2.profiles
+                    )
+                )
+                fr = list(
+                    map(
+                        lambda x, y: x - y,
+                        fr1, fr2
+                        )
+                    )
 
             line = ax.plot(
                 rk, fr, color='black', linestyle='--', lw=1.,
@@ -455,6 +562,7 @@ class CustomPlot(PamhyrPlot):
         if "wet_area" in self._y:
 
             ax = self._axes[unit["wet_area"]]
+            if self._current_res_id < 2:
                 d = list(
                     map(
                         lambda p: p.geometry.wet_area(
@@ -462,6 +570,27 @@ class CustomPlot(PamhyrPlot):
                         reach.profiles
                     )
                 )
+            else:
+                d1 = list(
+                    map(
+                        lambda p: p.geometry.wet_area(
+                            p.get_ts_key(self._timestamp, "Z")),
+                        reach1.profiles
+                    )
+                )
+                d2 = list(
+                    map(
+                        lambda p: p.geometry.wet_area(
+                            p.get_ts_key(self._timestamp, "Z")),
+                        reach2.profiles
+                    )
+                )
+                d = list(
+                    map(
+                        lambda x, y: x - y,
+                        d1, d2
+                        )
+                    )
 
             line = ax.plot(
                 rk, d,
@@ -479,8 +608,12 @@ class CustomPlot(PamhyrPlot):
         self.canvas.axes.legend(lns, labs, loc="best")
 
     def _redraw_rk(self):
-        results = self.data
+        results = self.data[self._current_res_id]
         reach = results.river.reach(self._reach)
+        if self._current_res_id == 2:  # compare results
+            reach1 = self.data[0].river.reach(self._reach)
+            reach2 = self.data[1].river.reach(self._reach)
+
         rk = reach.geometry.get_rk()
         z_min = reach.geometry.get_z_min()
         if reach.has_sediment():
@@ -507,12 +640,27 @@ class CustomPlot(PamhyrPlot):
             )
         )
         if "bed_elevation" in self._y:
-            self.lines["bed_elevation"][0].set_ydata(z_min)
+            if self._current_res_id < 2:
+                dz = z_min
+            else:
+                if reach.has_sediment():
+                    z_min1 = self.draw_bottom_with_bedload(reach1)
+                    z_min2 = self.draw_bottom_with_bedload(reach2)
+                else:
+                    z_min1 = reach1.geometry.get_z_min()
+                    z_min2 = reach2.geometry.get_z_min()
+                dz = list(
+                    map(
+                        lambda x, y: x - y,
+                        z_min2, z_min2
+                        )
+                    )
+            self.lines["bed_elevation"][0].set_ydata(dz)
 
         if "water_elevation" in self._y:
             self.lines["water_elevation"][0].set_ydata(z)
 
-            if "bed_elevation" in self._y:
+            if "bed_elevation" in self._y and self._current_res_id < 2:
                 ax = self._axes[unit["water_elevation"]]
                 self.fill.remove()
                 self.fill = ax.fill_between(
@@ -527,6 +675,7 @@ class CustomPlot(PamhyrPlot):
             self.lines["velocity"][0].set_ydata(v)
 
         if "depth" in self._y:
+            if self._current_res_id < 2:
                 d = list(
                     map(
                         lambda p: p.geometry.max_water_depth(
@@ -534,9 +683,32 @@ class CustomPlot(PamhyrPlot):
                         reach.profiles
                     )
                 )
+            else:
+                d1 = list(
+                    map(
+                        lambda p: p.geometry.max_water_depth(
+                            p.get_ts_key(self._timestamp, "Z")),
+                        reach1.profiles
+                    )
+                )
+                d2 = list(
+                    map(
+                        lambda p: p.geometry.max_water_depth(
+                            p.get_ts_key(self._timestamp, "Z")),
+                        reach2.profiles
+                    )
+                )
+                d = list(
+                    map(
+                        lambda x, y: x - y,
+                        d1, d2
+                        )
+                    )
+
             self.lines["depth"][0].set_ydata(d)
 
         if "mean_depth" in self._y:
+            if self._current_res_id < 2:
                 d = list(
                     map(
                         lambda p: p.geometry.mean_water_depth(
@@ -544,9 +716,32 @@ class CustomPlot(PamhyrPlot):
                         reach.profiles
                     )
                 )
+            else:
+                d1 = list(
+                    map(
+                        lambda p: p.geometry.mean_water_depth(
+                            p.get_ts_key(self._timestamp, "Z")),
+                        reach1.profiles
+                    )
+                )
+                d2 = list(
+                    map(
+                        lambda p: p.geometry.mean_water_depth(
+                            p.get_ts_key(self._timestamp, "Z")),
+                        reach2.profiles
+                    )
+                )
+                d = list(
+                    map(
+                        lambda x, y: x - y,
+                        d1, d2
+                        )
+                    )
+
             self.lines["mean_depth"][0].set_ydata(d)
 
         if "froude" in self._y:
+            if self._current_res_id < 2:
                 fr = list(
                     map(
                         lambda p:
@@ -560,9 +755,44 @@ class CustomPlot(PamhyrPlot):
                         reach.profiles
                     )
                 )
+            else:
+                fr1 = list(
+                    map(
+                        lambda p:
+                            p.get_ts_key(self._timestamp, "V") /
+                            sqrt(9.81 * (
+                                p.geometry.wet_area(
+                                    p.get_ts_key(self._timestamp, "Z")) /
+                                p.geometry.wet_width(
+                                    p.get_ts_key(self._timestamp, "Z"))
+                                )),
+                        reach1.profiles
+                    )
+                )
+                fr2 = list(
+                    map(
+                        lambda p:
+                            p.get_ts_key(self._timestamp, "V") /
+                            sqrt(9.81 * (
+                                p.geometry.wet_area(
+                                    p.get_ts_key(self._timestamp, "Z")) /
+                                p.geometry.wet_width(
+                                    p.get_ts_key(self._timestamp, "Z"))
+                                )),
+                        reach2.profiles
+                    )
+                )
+                fr = list(
+                    map(
+                        lambda x, y: x - y,
+                        fr1, fr2
+                        )
+                    )
+
             self.lines["froude"][0].set_ydata(fr)
 
         if "wet_area" in self._y:
+            if self._current_res_id < 2:
                 d = list(
                     map(
                         lambda p: p.geometry.wet_area(
@@ -570,6 +800,28 @@ class CustomPlot(PamhyrPlot):
                         reach.profiles
                     )
                 )
+            else:
+                d1 = list(
+                    map(
+                        lambda p: p.geometry.wet_area(
+                            p.get_ts_key(self._timestamp, "Z")),
+                        reach1.profiles
+                    )
+                )
+                d2 = list(
+                    map(
+                        lambda p: p.geometry.wet_area(
+                            p.get_ts_key(self._timestamp, "Z")),
+                        reach2.profiles
+                    )
+                )
+                d = list(
+                    map(
+                        lambda x, y: x - y,
+                        d1, d2
+                        )
+                    )
+
             self.lines["wet_area"][0].set_ydata(d)
 
     def _customize_x_axes_time(self, ts, mode="time"):
@@ -611,9 +863,11 @@ class CustomPlot(PamhyrPlot):
             )
 
         self.canvas.axes.set_xticks(ticks=fx, labels=xt, rotation=45)
+        self.canvas.axes.relim(visible_only=True)
+        self.canvas.axes.autoscale_view()
 
     def _draw_time(self):
-        results = self.data
+        results = self.data[self._current_res_id]
         reach = results.river.reach(self._reach)
         profile = reach.profile(self._profile)
 
@@ -627,15 +881,29 @@ class CustomPlot(PamhyrPlot):
                 self._axes[ax].spines['right'].set_position(('outward', shift))
                 shift += 60
 
-        ts = list(results.get("timestamps"))
+        ts = self._parent._timestamps
-        ts.sort()
+
+        if self._current_res_id == 2:  # compare results
+            reach1 = self.data[0].river.reach(self._reach)
+            reach2 = self.data[1].river.reach(self._reach)
+            profile1 = reach1.profile(self._profile)
+            profile2 = reach2.profile(self._profile)
+
+            q1 = profile1.get_key("Q")
+            z1 = profile1.get_key("Z")
+            v1 = profile1.get_key("V")
+
+            q2 = profile2.get_key("Q")
+            z2 = profile2.get_key("Z")
+            v2 = profile2.get_key("V")
 
         q = profile.get_key("Q")
         z = profile.get_key("Z")
         v = profile.get_key("V")
         z_min = profile.geometry.z_min()
+        if self._current_res_id < 2:
             if reach.has_sediment():
-            ts_z_min = self.get_ts_zmin(self._profile)
+                ts_z_min = self.get_ts_zmin(self._profile, res_id)
             else:
                 ts_z_min = list(
                     map(
@@ -650,6 +918,26 @@ class CustomPlot(PamhyrPlot):
 
             ax = self._axes[unit["bed_elevation"]]
 
+            if self._current_res_id == 2:
+                if reach.has_sediment():
+                    ts_z_min1 = self.get_ts_zmin(self._profile1, 0)
+                    ts_z_min2 = self.get_ts_zmin(self._profile2, 1)
+                    ts_z_min = list(
+                        map(
+                            lambda x, y: x - y,
+                            ts_z_min1, ts_z_min2
+                            )
+                        )
+                else:
+                    z_min1 = profile1.geometry.z_min()
+                    z_min2 = profile2.geometry.z_min()
+                    ts_z_min = list(
+                        map(
+                            lambda ts:  z_min1 - z_min2,
+                            ts
+                        )
+                    )
+
             line = ax.plot(
                 ts, ts_z_min,
                 color='grey', lw=1.
@@ -665,7 +953,7 @@ class CustomPlot(PamhyrPlot):
             )
             self.lines["water_elevation"] = line
 
-            if "bed_elevation" in self._y:
+            if "bed_elevation" in self._y and self._current_res_id < 2:
 
                 self.fill = ax.fill_between(
                     ts, ts_z_min, z,
@@ -694,9 +982,23 @@ class CustomPlot(PamhyrPlot):
         if "depth" in self._y:
 
             ax = self._axes[unit["depth"]]
+            if self._current_res_id < 2:
                 d = list(
                     map(lambda z: profile.geometry.max_water_depth(z), z)
                 )
+            else:
+                d1 = list(
+                    map(lambda z: profile1.geometry.max_water_depth(z), z1)
+                )
+                d2 = list(
+                    map(lambda z: profile2.geometry.max_water_depth(z), z2)
+                )
+                d = list(
+                    map(
+                        lambda x, y: x - y,
+                        d1, d2
+                        )
+                    )
 
             line = ax.plot(
                 ts, d,
@@ -707,9 +1009,23 @@ class CustomPlot(PamhyrPlot):
         if "mean_depth" in self._y:
 
             ax = self._axes[unit["mean_depth"]]
+            if self._current_res_id < 2:
                 d = list(
                     map(lambda z: profile.geometry.mean_water_depth(z), z)
                 )
+            else:
+                d1 = list(
+                    map(lambda z: profile1.geometry.mean_water_depth(z), z1)
+                )
+                d2 = list(
+                    map(lambda z: profile2.geometry.mean_water_depth(z), z2)
+                )
+                d = list(
+                    map(
+                        lambda x, y: x - y,
+                        d1, d2
+                        )
+                    )
 
             line = ax.plot(
                 ts, d,
@@ -720,6 +1036,7 @@ class CustomPlot(PamhyrPlot):
         if "froude" in self._y:
 
             ax = self._axes[unit["froude"]]
+            if self._current_res_id < 2:
                 d = list(
                     map(lambda z, v:
                         v /
@@ -728,6 +1045,29 @@ class CustomPlot(PamhyrPlot):
                             profile.geometry.wet_width(z))
                         ), z, v)
                     )
+            else:
+                d1 = list(
+                    map(lambda z, v:
+                        v /
+                        sqrt(9.81 * (
+                            profile1.geometry.wet_area(z) /
+                            profile1.geometry.wet_width(z))
+                        ), z1, v1)
+                    )
+                d2 = list(
+                    map(lambda z, v:
+                        v /
+                        sqrt(9.81 * (
+                            profile2.geometry.wet_area(z) /
+                            profile2.geometry.wet_width(z))
+                        ), z2, v2)
+                    )
+                d = list(
+                    map(
+                        lambda x, y: x - y,
+                        d1, d2
+                        )
+                    )
 
             line = ax.plot(
                 ts, d, color='black', linestyle='--', lw=1.,
@@ -737,9 +1077,23 @@ class CustomPlot(PamhyrPlot):
         if "wet_area" in self._y:
 
             ax = self._axes[unit["wet_area"]]
+            if self._current_res_id < 2:
                 d = list(
                     map(lambda z: profile.geometry.wet_area(z), z)
                 )
+            else:
+                d1 = list(
+                    map(lambda z: profile1.geometry.wet_area(z), z1)
+                )
+                d2 = list(
+                    map(lambda z: profile2.geometry.wet_area(z), z2)
+                )
+                d = list(
+                    map(
+                        lambda x, y: x - y,
+                        d1, d2
+                        )
+                    )
 
             line = ax.plot(
                 ts, d, color='blue', linestyle='--', lw=1.,
@@ -759,15 +1113,30 @@ class CustomPlot(PamhyrPlot):
 
     def _redraw_time(self):
 
-        results = self.data
+        results = self.data[self._current_res_id]
         reach = results.river.reach(self._reach)
         profile = reach.profile(self._profile)
         ts = list(results.get("timestamps"))
         ts.sort()
 
+        if self._current_res_id == 2:  # compare results
+            reach1 = self.data[0].river.reach(self._reach)
+            reach2 = self.data[1].river.reach(self._reach)
+            profile1 = reach1.profile(self._profile)
+            profile2 = reach2.profile(self._profile)
+
+            q1 = profile1.get_key("Q")
+            z1 = profile1.get_key("Z")
+            v1 = profile1.get_key("V")
+
+            q2 = profile2.get_key("Q")
+            z2 = profile2.get_key("Z")
+            v2 = profile2.get_key("V")
+
         q = profile.get_key("Q")
         z = profile.get_key("Z")
         v = profile.get_key("V")
+        if self._current_res_id < 2:
             if reach.has_sediment():
                 ts_z_min = self.get_ts_zmin(self._profile)
             else:
@@ -779,12 +1148,31 @@ class CustomPlot(PamhyrPlot):
                     )
                 )
         if "bed_elevation" in self._y:
+            if self._current_res_id == 2:
+                if reach.has_sediment():
+                    ts_z_min1 = self.get_ts_zmin(self._profile1, 0)
+                    ts_z_min2 = self.get_ts_zmin(self._profile2, 1)
+                    ts_z_min = list(
+                        map(
+                            lambda x, y: x - y,
+                            ts_z_min1, ts_z_min2
+                            )
+                        )
+                else:
+                    z_min1 = profile1.geometry.z_min()
+                    z_min2 = profile2.geometry.z_min()
+                    ts_z_min = list(
+                        map(
+                            lambda ts:  z_min1 - z_min2,
+                            ts
+                        )
+                    )
             self.lines["bed_elevation"][0].set_ydata(ts_z_min)
 
         if "water_elevation" in self._y:
             self.lines["water_elevation"][0].set_ydata(z)
 
-            if "bed_elevation" in self._y:
+            if "bed_elevation" in self._y and self._current_res_id < 2:
                 ax = self._axes[unit["bed_elevation"]]
                 self.fill.remove()
                 self.fill = ax.fill_between(
@@ -799,18 +1187,49 @@ class CustomPlot(PamhyrPlot):
             self.lines["velocity"][0].set_ydata(v)
 
         if "depth" in self._y:
+            if self._current_res_id < 2:
                 d = list(
                     map(lambda z: profile.geometry.max_water_depth(z), z)
                 )
+            else:
+                d1 = list(
+                    map(lambda z: profile1.geometry.max_water_depth(z), z1)
+                )
+                d2 = list(
+                    map(lambda z: profile2.geometry.max_water_depth(z), z2)
+                )
+                d = list(
+                    map(
+                        lambda x, y: x - y,
+                        d1, d2
+                        )
+                    )
+
             self.lines["depth"][0].set_ydata(d)
 
         if "mean_depth" in self._y:
+            if self._current_res_id < 2:
                 d = list(
                     map(lambda z: profile.geometry.mean_water_depth(z), z)
                 )
+            else:
+                d1 = list(
+                    map(lambda z: profile1.geometry.mean_water_depth(z), z1)
+                )
+                d2 = list(
+                    map(lambda z: profile2.geometry.mean_water_depth(z), z2)
+                )
+                d = list(
+                    map(
+                        lambda x, y: x - y,
+                        d1, d2
+                        )
+                    )
+
             self.lines["mean_depth"][0].set_ydata(d)
 
         if "froude" in self._y:
+            if self._current_res_id < 2:
                 d = list(
                     map(lambda z, v:
                         v /
@@ -819,16 +1238,57 @@ class CustomPlot(PamhyrPlot):
                             profile.geometry.wet_width(z))
                         ), z, v)
                     )
+            else:
+                d1 = list(
+                    map(lambda z, v:
+                        v /
+                        sqrt(9.81 * (
+                            profile1.geometry.wet_area(z) /
+                            profile1.geometry.wet_width(z))
+                        ), z1, v1)
+                    )
+                d2 = list(
+                    map(lambda z, v:
+                        v /
+                        sqrt(9.81 * (
+                            profile2.geometry.wet_area(z) /
+                            profile2.geometry.wet_width(z))
+                        ), z2, v2)
+                    )
+                d = list(
+                    map(
+                        lambda x, y: x - y,
+                        d1, d2
+                        )
+                    )
+
             self.lines["froude"][0].set_ydata(d)
 
         if "wet_area" in self._y:
+            if self._current_res_id < 2:
                 d = list(
                     map(lambda z: profile.geometry.wet_area(z), z)
                 )
+            else:
+                d1 = list(
+                    map(lambda z: profile1.geometry.wet_area(z), z1)
+                )
+                d2 = list(
+                    map(lambda z: profile2.geometry.wet_area(z), z2)
+                )
+                d = list(
+                    map(
+                        lambda x, y: x - y,
+                        d1, d2
+                        )
+                    )
+
             self.lines["wet_area"][0].set_ydata(d)
 
+        self._current.set_visible(False)
         self.canvas.axes.relim(visible_only=True)
         self.canvas.axes.autoscale_view()
+        self._current.set_visible(True)
 
     def draw(self):
         self.draw_static()
@@ -847,35 +1307,58 @@ class CustomPlot(PamhyrPlot):
         if self.data is None:
             return
 
+        self._y_axes = sorted(
+            set(
+                map(
+                    lambda y: unit[y],
+                    self._y
+                )
+            )
+        )
+
         self.canvas.axes.set_xlabel(
             self._trad[self._x],
             color='black', fontsize=10
         )
 
+        if self._current_res_id < 2:
             self.canvas.axes.set_ylabel(
                 self._trad[self._y_axes[0]],
                 color='black', fontsize=10
             )
+        else:
+            self.canvas.axes.set_ylabel(
+                "Δ " + self._trad[self._y_axes[0]],
+                color='black', fontsize=10
+            )
 
         self._axes[self._y_axes[0]] = self.canvas.axes
+        if len(self.lines) != 0:
+            self.lines.clear()
         for axes in self._y_axes[1:]:
-            if axes in self._axes:
+            if axes in self._axes.keys():
-                self._axes[axes].clear()
+                for ll in self._axes[axes].lines:
-                continue
+                    ll.remove()
-
+            else:
                 ax_new = self.canvas.axes.twinx()
-            ax_new.set_ylabel(
+                self._axes[axes] = ax_new
+            if self._current_res_id < 2:
+                self._axes[axes].set_ylabel(
                     self._trad[axes],
                     color='black', fontsize=10
                 )
-            self._axes[axes] = ax_new
+            else:
+                self._axes[axes].set_ylabel(
+                    "Δ " + self._trad[axes],
+                    color='black', fontsize=10
+                )
 
         if self._x == "rk":
             self._draw_rk()
         elif self._x == "time":
             self._draw_time()
         if self._x == "rk":
-            reach = self.data.river.reach(self._reach)
+            reach = self.data[self._current_res_id].river.reach(self._reach)
             profile = reach.profile(self._profile)
             x = profile.rk
         elif self._x == "time":
@@ -915,6 +1398,10 @@ class CustomPlot(PamhyrPlot):
         else:
             self.draw_current()
 
+    def set_result(self, res_id):
+        self._current_res_id = res_id[0]
+        self.draw()
+
     def set_timestamp(self, timestamp):
         self._timestamp = timestamp
 
@@ -925,7 +1412,7 @@ class CustomPlot(PamhyrPlot):
 
     def draw_current(self):
         if self._x == "rk":
-            reach = self.data.river.reach(self._reach)
+            reach = self.data[self._current_res_id].river.reach(self._reach)
             profile = reach.profile(self._profile)
             x = profile.rk
         elif self._x == "time":

src/View/Results/PlotAC.py

@@ -29,7 +29,7 @@ _translate = QCoreApplication.translate
 
 class PlotAC(PamhyrPlot):
     def __init__(self, canvas=None, trad=None, toolbar=None,
-                 results=None, reach_id=0, profile_id=0,
+                 results=None, reach_id=0, profile_id=0, res_id=0,
                  parent=None):
         super(PlotAC, self).__init__(
             canvas=canvas,
@@ -39,9 +39,11 @@ class PlotAC(PamhyrPlot):
             parent=parent
         )
 
-        self._current_timestamp = max(results.get("timestamps"))
         self._current_reach_id = reach_id
         self._current_profile_id = profile_id
+        self._current_res_id = res_id[0]
+        self._timestamps = parent._timestamps
+        self._current_timestamp = max(self._timestamps)
 
         self.label_x = self._trad['x']
         self.label_y = self._trad["unit_elevation"]
@@ -62,7 +64,7 @@ class PlotAC(PamhyrPlot):
     @results.setter
     def results(self, results):
         self.data = results
-        self._current_timestamp = max(results.get("timestamps"))
+        self._current_timestamp = max(self._timestamps)
 
     @timer
     def draw(self, highlight=None):
@@ -71,7 +73,11 @@ class PlotAC(PamhyrPlot):
         if self.results is None:
             return
 
-        reach = self.results.river.reach(self._current_reach_id)
+        if self.results[self._current_res_id] is None:
+            return
+
+        results = self.results[self._current_res_id]
+        reach = results.river.reach(self._current_reach_id)
         profile = reach.profile(self._current_profile_id)
 
         self.draw_profile(reach, profile)
@@ -137,10 +143,15 @@ class PlotAC(PamhyrPlot):
         self._current_profile_id = profile_id
         self.update()
 
+    def set_result(self, res_id):
+        self._current_res_id = res_id[0]
+        self.update()
+
     def set_timestamp(self, timestamp):
         self._current_timestamp = timestamp
 
-        reach = self.results.river.reach(self._current_reach_id)
+        reach = self.results[self._current_res_id].river.reach(
+            self._current_reach_id)
         profile = reach.profile(self._current_profile_id)
         x = profile.geometry.get_station()
         z = profile.geometry.z()
@@ -152,7 +163,8 @@ class PlotAC(PamhyrPlot):
         if not self._init:
             self.draw()
 
-        reach = self.results.river.reach(self._current_reach_id)
+        reach = self.results[self._current_res_id].river.reach(
+            self._current_reach_id)
         profile = reach.profile(self._current_profile_id)
         x = profile.geometry.get_station()
         z = profile.geometry.z()

src/View/Results/PlotH.py

@@ -35,7 +35,7 @@ logger = logging.getLogger()
 
 class PlotH(PamhyrPlot):
     def __init__(self, canvas=None, trad=None, toolbar=None,
-                 results=None, reach_id=0, profile_id=0,
+                 results=None, reach_id=0, profile_id=0, res_id=[0],
                  parent=None):
         super(PlotH, self).__init__(
             canvas=canvas,
@@ -47,9 +47,11 @@ class PlotH(PamhyrPlot):
 
         self._mode = "time"
 
-        self._current_timestamp = max(results.get("timestamps"))
         self._current_reach_id = reach_id
         self._current_profile_id = profile_id
+        self._current_res_id = res_id
+        self._timestamps = parent._timestamps
+        self._current_timestamp = max(self._timestamps)
 
         self.label_x = self._trad["unit_time_s"]
         self.label_y = self._trad["unit_discharge"]
@@ -60,8 +62,11 @@ class PlotH(PamhyrPlot):
 
         self._isometric_axis = False
 
-        self._auto_relim_update = False
+        # self._auto_relim_update = False
-        self._autoscale_update = False
+        # self._autoscale_update = False
+
+        self._line_max = []
+        self._line = []
 
     @property
     def results(self):
@@ -70,47 +75,79 @@ class PlotH(PamhyrPlot):
     @results.setter
     def results(self, results):
         self.data = results
-        self._current_timestamp = max(results.get("timestamps"))
+        self._current_timestamp = max(self._timestamps)
 
     @timer
     def draw(self, highlight=None):
-        self.init_axes()
+        self.canvas.axes.cla()
+        self.canvas.axes.grid(color='grey', linestyle='--', linewidth=0.5)
 
         if self.results is None:
             return
 
-        reach = self.results.river.reach(self._current_reach_id)
+        if len(self._current_res_id) < 1:
-        profile = reach.profile(self._current_profile_id)
+            return
+
+        if len(self._current_res_id) == 1:
+            self.draw_max(self._current_res_id[0])
+
+        for res_id in self._current_res_id:
+            if self.results[res_id] is None:
+                continue
+
+            results = self.results[res_id]
+            reach = results.river.reach(self._current_reach_id)
 
             if reach.geometry.number_profiles == 0:
                 self._init = False
                 return
 
-        self.draw_max(reach)
+            self.draw_data(res_id)
-        self.draw_data(reach, profile)
+
-        self.draw_current()
+        self.canvas.axes.set_xlabel(
+            self._trad["unit_time_s"],
+            color='black', fontsize=10
+        )
+
+        self.canvas.axes.set_ylabel(
+            self._trad["unit_discharge"],
+            color='black', fontsize=10
+        )
 
         self.set_ticks_time_formater()
 
         self.enable_legend()
 
-        self.idle()
+        self.canvas.draw_idle()
-        self.update_current()
+        self.update_idle
+        self.draw_current()
         self._init = True
 
-    def draw_data(self, reach, profile):
+    def draw_data(self, res_id):
-        self.ts = list(self.results.get("timestamps"))
-        self.ts.sort()
 
-        x = self.ts
+        results = self.results[res_id]
+        reach = results.river.reach(self._current_reach_id)
+        profile = reach.profile(self._current_profile_id)
+
+        x = self._timestamps
         y = profile.get_key("Q")
 
-        self._line, = self.canvas.axes.plot(
+        if res_id == 2:
+            label = "Δ " + self.label_discharge
+        else:
+            label = self.label_discharge
+
+        if len(self._current_res_id) > 1:
+            if res_id != 2:
+                label += f" ({results._solver.name})"
+
+        line, = self.canvas.axes.plot(
             x, y,
-            label=self.label_discharge,
+            label=label,
-            color=self.color_plot,
+            color=self.colors[res_id + 1],
             **self.plot_default_kargs
         )
+        self._line.append(line)
 
     def draw_current(self):
         self._current, = self.canvas.axes.plot(
@@ -122,12 +159,23 @@ class PlotH(PamhyrPlot):
             lw=1.,
         )
 
-    def draw_max(self, reach):
+    def draw_max(self, res_id):
-        self.ts = list(self.results.get("timestamps"))
+        results = self.results[res_id]
-        self.ts.sort()
+        reach = results.river.reach(self._current_reach_id)
+        profile = reach.profile(self._current_profile_id)
 
-        x = self.ts
+        if reach.geometry.number_profiles == 0:
+            self._init = False
+            return
+
+        x = self._timestamps
         y = []
+
+        if res_id == 2:
+            label = "Δ " + self.label_discharge_max
+        else:
+            label = self.label_discharge_max
+
         for ts in x:
             ts_y = -9999
             for profile in reach.profiles:
@@ -135,13 +183,14 @@ class PlotH(PamhyrPlot):
                 ts_y = max(ts_y, q)
             y.append(ts_y)
 
-        self._line_max, = self.canvas.axes.plot(
+        m, = self.canvas.axes.plot(
             x, y,
-            label=self.label_discharge_max,
+            label=label,
             color=self.color_plot_highlight,
             linestyle='dotted',
             **self.plot_default_kargs
         )
+        self._line_max.append(m)
 
     def set_reach(self, reach_id):
         self._current_reach_id = reach_id
@@ -152,6 +201,10 @@ class PlotH(PamhyrPlot):
         self._current_profile_id = profile_id
         self.update()
 
+    def set_result(self, res_id):
+        self._current_res_id = res_id
+        self.draw()
+
     def set_timestamp(self, timestamp):
         self._current_timestamp = timestamp
         self.update_current()
@@ -162,24 +215,23 @@ class PlotH(PamhyrPlot):
             self.draw()
 
         self.update_data()
+        self.update_current()
         self.update_idle()
 
     def update_data(self):
-        reach = self.results.river.reach(self._current_reach_id)
+        for res, res_id in enumerate(self._current_res_id):
+            results = self.results[res_id]
+            reach = results.river.reach(self._current_reach_id)
             profile = reach.profile(self._current_profile_id)
 
-        x = self.ts
+            x = self._timestamps
             y = profile.get_key("Q")
 
-        self._line.set_data(x, y)
+            self._line[res].set_data(x, y)
-
-        self._current.set_data(
-            [self._current_timestamp, self._current_timestamp],
-            self.canvas.axes.get_ylim()
-        )
 
     def update_current(self):
+        y = self._current.get_ydata()
         self._current.set_data(
             [self._current_timestamp, self._current_timestamp],
-            self.canvas.axes.get_ylim()
+            y
         )

src/View/Results/PlotRKC.py

@@ -32,7 +32,7 @@ logger = logging.getLogger()
 
 class PlotRKC(PamhyrPlot):
     def __init__(self, canvas=None, trad=None, toolbar=None,
-                 results=None, reach_id=0, profile_id=0,
+                 results=None, reach_id=0, profile_id=0, res_id=0,
                  parent=None):
         super(PlotRKC, self).__init__(
             canvas=canvas,
@@ -42,10 +42,11 @@ class PlotRKC(PamhyrPlot):
             parent=parent
         )
 
-        self._timestamps = results.get("timestamps")
-        self._current_timestamp = max(self._timestamps)
         self._current_reach_id = reach_id
         self._current_profile_id = profile_id
+        self._current_res_id = res_id[0]
+        self._timestamps = parent._timestamps
+        self._current_timestamp = max(self._timestamps)
 
         self.label_x = self._trad["unit_rk"]
         self.label_y = self._trad["unit_elevation"]
@@ -56,6 +57,9 @@ class PlotRKC(PamhyrPlot):
 
         self._isometric_axis = False
 
+        self._auto_relim_update = True
+        self._autoscale_update = True
+
     @property
     def results(self):
         return self.data
@@ -63,7 +67,7 @@ class PlotRKC(PamhyrPlot):
     @results.setter
     def results(self, results):
         self.data = results
-        self._current_timestamp = max(results.get("timestamps"))
+        self._current_timestamp = max(self._timestamps)
 
     @timer
     def draw(self, highlight=None):
@@ -72,7 +76,11 @@ class PlotRKC(PamhyrPlot):
         if self.results is None:
             return
 
-        reach = self.results.river.reach(self._current_reach_id)
+        if self.results[self._current_res_id] is None:
+            return
+
+        results = self.results[self._current_res_id]
+        reach = results.river.reach(self._current_reach_id)
 
         self.draw_bottom(reach)
         self.draw_water_elevation(reach)
@@ -107,11 +115,12 @@ class PlotRKC(PamhyrPlot):
         self._river_bottom = z
 
     def draw_profiles_hs(self, reach):
+        results = self.results[self._current_res_id]
         lhs = filter(
             lambda hs: hs._input_reach.reach is reach.geometry,
             filter(
                 lambda hs: hs._input_reach is not None,
-                self.results.study.river.hydraulic_structures.lst
+                results.study.river.hydraulic_structures.lst
             )
         )
 
@@ -223,6 +232,7 @@ class PlotRKC(PamhyrPlot):
 
             self.water_fill = self.canvas.axes.fill_between(
                 rk, self._river_bottom, water_z,
+                where=[b <= z for b, z in zip(self._river_bottom, water_z)],
                 color=self.color_plot_river_water_zone,
                 alpha=0.7,
                 interpolate=True
@@ -312,6 +322,10 @@ class PlotRKC(PamhyrPlot):
         self._current_profile_id = profile_id
         self.update_current()
 
+    def set_result(self, res_id):
+        self._current_res_id = res_id[0]
+        self.update()
+
     def set_timestamp(self, timestamp):
         self._current_timestamp = timestamp
         self.update()
@@ -320,7 +334,8 @@ class PlotRKC(PamhyrPlot):
         if not self._init:
             self.draw()
 
-        reach = self.results.river.reach(self._current_reach_id)
+        results = self.results[self._current_res_id]
+        reach = results.river.reach(self._current_reach_id)
         if reach.has_sediment():
             self.update_bottom_with_bedload()
 
@@ -329,7 +344,8 @@ class PlotRKC(PamhyrPlot):
         self.update_idle()
 
     def update_water_elevation(self):
-        reach = self.results.river.reach(self._current_reach_id)
+        results = self.results[self._current_res_id]
+        reach = results.river.reach(self._current_reach_id)
         rk = reach.geometry.get_rk()
         z_min = reach.geometry.get_z_min()
 
@@ -349,12 +365,14 @@ class PlotRKC(PamhyrPlot):
         self.water_fill.remove()
         self.water_fill = self.canvas.axes.fill_between(
             rk, self._river_bottom, water_z,
+            where=[rb <= wz for rb, wz in zip(self._river_bottom, water_z)],
             color=self.color_plot_river_water_zone,
             alpha=0.7, interpolate=True
         )
 
     def update_current(self):
-        reach = self.results.river.reach(self._current_reach_id)
+        results = self.results[self._current_res_id]
+        reach = results.river.reach(self._current_reach_id)
         rk = reach.geometry.get_rk()
         z_min = reach.geometry.get_z_min()
         z_max = reach.geometry.get_z_max()
@@ -367,7 +385,8 @@ class PlotRKC(PamhyrPlot):
         self.canvas.figure.canvas.draw_idle()
 
     def update_bottom_with_bedload(self):
-        reach = self.results.river.reach(self._current_reach_id)
+        results = self.results[self._current_res_id]
+        reach = results.river.reach(self._current_reach_id)
         rk = reach.geometry.get_rk()
         z = self.sl_compute_current_z(reach)
 

src/View/Results/PlotXY.py

@@ -38,7 +38,7 @@ logger = logging.getLogger()
 
 class PlotXY(PamhyrPlot):
     def __init__(self, canvas=None, trad=None, toolbar=None,
-                 results=None, reach_id=0, profile_id=0,
+                 results=None, reach_id=0, profile_id=0, res_id=0,
                  display_current=True, parent=None):
         super(PlotXY, self).__init__(
             canvas=canvas,
@@ -52,10 +52,11 @@ class PlotXY(PamhyrPlot):
         self.line_gl = []
         self.overflow = []
 
-        self._timestamps = results.get("timestamps")
+        self._timestamps = parent._timestamps
         self._current_timestamp = max(self._timestamps)
         self._current_reach_id = reach_id
         self._current_profile_id = profile_id
+        self._current_res_id = res_id[0]
 
         self.label_x = _translate("Results", "X (m)")
         self.label_y = _translate("Results", "Y (m)")
@@ -136,7 +137,7 @@ class PlotXY(PamhyrPlot):
     @results.setter
     def results(self, results):
         self.data = results
-        self._current_timestamp = max(results.get("timestamps"))
+        self._current_timestamp = max(self._timestamps)
 
     @timer
     def draw(self, highlight=None):
@@ -145,8 +146,12 @@ class PlotXY(PamhyrPlot):
         if self.results is None:
             return
 
-        reach = self.results.river.reach(self._current_reach_id)
+        if self.results[self._current_res_id] is None:
-        reaches = self.results.river.reachs
+            return
+
+        results = self.results[self._current_res_id]
+        reach = results.river.reach(self._current_reach_id)
+        reaches = results.river.reachs
 
         self.draw_profiles(reach, reaches)
         self.draw_water_elevation(reach)
@@ -161,6 +166,7 @@ class PlotXY(PamhyrPlot):
         if reach.geometry.number_profiles == 0:
             self._init = False
             return
+        self.line_xy = []
         # TODO uncomment to draw all the reaches
         # self.draw_other_profiles(reaches)
         for xy in zip(reach.geometry.get_x(),
@@ -272,7 +278,8 @@ class PlotXY(PamhyrPlot):
         )
 
     def draw_water_elevation(self, reach):
-        reach = self.results.river.reach(self._current_reach_id)
+        results = self.results[self._current_res_id]
+        reach = results.river.reach(self._current_reach_id)
         poly_l_x, poly_l_y, poly_r_x, poly_r_y = [], [], [], []
 
         for profile in reach.profiles:
@@ -308,6 +315,10 @@ class PlotXY(PamhyrPlot):
         self.update_profile()
         self.update_idle()
 
+    def set_result(self, res_id):
+        self._current_res_id = res_id[0]
+        self.update()
+
     def set_timestamp(self, timestamp):
         self._current_timestamp = timestamp
         self.update()
@@ -322,7 +333,8 @@ class PlotXY(PamhyrPlot):
         self.update_idle()
 
     def update_profile(self):
-        reach = self.results.river.reach(self._current_reach_id)
+        results = self.results[self._current_res_id]
+        reach = results.river.reach(self._current_reach_id)
         profile = reach.profile(self._current_profile_id)
 
         self.plot_selected.set_data(
@@ -331,7 +343,8 @@ class PlotXY(PamhyrPlot):
         )
 
     def update_water_elevation(self):
-        reach = self.results.river.reach(self._current_reach_id)
+        results = self.results[self._current_res_id]
+        reach = results.river.reach(self._current_reach_id)
         poly_l_x, poly_l_y, poly_r_x, poly_r_y = [], [], [], []
 
         for profile in reach.profiles:
@@ -358,7 +371,8 @@ class PlotXY(PamhyrPlot):
         self.water_fill[0].set_xy(poly)
 
     def update_water_elevation_overflow(self):
-        reach = self.results.river.reach(self._current_reach_id)
+        results = self.results[self._current_res_id]
+        reach = results.river.reach(self._current_reach_id)
         profile = reach.profile(self._current_profile_id)
 
         overflow = []

src/View/Results/Table.py

@@ -46,13 +46,15 @@ _translate = QCoreApplication.translate
 
 class TableModel(PamhyrTableModel):
     def _setup_lst(self):
-        _river = self._data.river
+        _river = self._data[0].river
         if self._opt_data == "reach":
             self._lst = _river.reachs
         elif self._opt_data == "profile":
             self._lst = _river.reach(0).profiles
         elif self._opt_data == "raw_data":
             self._lst = _river.reach(0).profiles
+        elif self._opt_data == "solver":
+            self._lst = self._parent._solvers
 
     def __init__(self, **kwargs):
         self._timestamp = 0.0
@@ -76,6 +78,10 @@ class TableModel(PamhyrTableModel):
             elif self._headers[column] == "rk":
                 v = self._lst[row].rk
                 return f"{v:.4f}"
+        elif self._opt_data == "solver":
+            if self._headers[column] == "solver":
+                v = self._lst[row].name
+                return str(v)
         elif self._opt_data == "raw_data":
             p = self._lst[row]
             if self._headers[column] == "name":
@@ -84,14 +90,18 @@ class TableModel(PamhyrTableModel):
                 return f"{p.name}"
             elif self._headers[column] == "water_elevation":
                 v = self._lst[row].get_ts_key(self._timestamp, "Z")
+                if v is None:
+                    v = 0.0
                 return f"{v:.4f}"
             elif self._headers[column] == "discharge":
                 v = self._lst[row].get_ts_key(self._timestamp, "Q")
+                if v is None:
+                    v = 0.0
                 return f"{v:.4f}"
             elif self._headers[column] == "velocity":
-                q = self._lst[row].get_ts_key(self._timestamp, "Q")
-                z = self._lst[row].get_ts_key(self._timestamp, "Z")
                 v = self._lst[row].get_ts_key(self._timestamp, "V")
+                if v is None:
+                    v = 0.0
                 return f"{v:.4f}"
             elif self._headers[column] == "width":
                 z = self._lst[row].get_ts_key(self._timestamp, "Z")
@@ -123,6 +133,9 @@ class TableModel(PamhyrTableModel):
                 v = self._lst[row].get_ts_key(self._timestamp, "V")
                 a = self._lst[row].geometry.wet_area(z)
                 b = self._lst[row].geometry.wet_width(z)
+                if b == 0.0 or a == 0.0:
+                    froude = 0.0
+                else:
                     froude = v / sqrt(9.81 * (a / b))
                 return f"{froude:.4f}"
             else:
@@ -132,12 +145,14 @@ class TableModel(PamhyrTableModel):
         return QVariant()
 
     def update(self, reach):
-        _river = self._data.river
+        _river = self._data[0].river
 
         if self._opt_data == "reach":
             self._lst = _river.reachs
         elif self._opt_data == "profile" or self._opt_data == "raw_data":
             self._lst = _river.reach(reach).profiles
+        elif self._opt_data == "solver":
+            self._lst = self._parent._solvers
 
         self.layoutChanged.emit()
 

src/View/Results/TableAdisTS.py

@@ -45,6 +45,7 @@ _translate = QCoreApplication.translate
 class TableModel(PamhyrTableModel):
     def _setup_lst(self):
         _river = self._data.river
+        self._timestamp = min(list(self._data.get("timestamps")))
         if self._opt_data == "reach":
             self._lst = _river.reachs
         elif self._opt_data == "profile":
@@ -57,7 +58,6 @@ class TableModel(PamhyrTableModel):
             self._lst = tmp_list
 
     def __init__(self, type_pol, **kwargs):
-        self._timestamp = 0.0
         self._type_pol = type_pol
         super(TableModel, self).__init__(**kwargs)
 
@@ -99,8 +99,8 @@ class TableModel(PamhyrTableModel):
                     v = self._lst[row].get_ts_key(
                         self._timestamp, "pols")[pol_index][0]
                     return f"{v:.4f}"
-                if (self._headers[column] == pol + " Mass"
+                if self._headers[column] == pol + " Mass":
-                        and self._type_pol[pol_index] == 7):
+                    if self._type_pol[pol_index] == 7:
                         m1 = self._lst[row].get_ts_key(
                             self._timestamp, "pols")[pol_index][1]
                         m2 = self._lst[row].get_ts_key(
@@ -109,6 +109,8 @@ class TableModel(PamhyrTableModel):
                             self._timestamp, "pols")[pol_index][3]
                         v = m1 + m2 + m3
                         return f"{v:.4f}"
+                    else:
+                        return ""
 
         return QVariant()
 

src/View/Results/Window.py

@@ -59,9 +59,13 @@ from View.Results.CustomPlot.Plot import CustomPlot
 from View.Results.CustomPlot.CustomPlotValuesSelectionDialog import (
     CustomPlotValuesSelectionDialog,
 )
+from View.Results.CustomExport.CustomExport import CustomExportDialog
 
 from View.Results.Table import TableModel
-from View.Results.translate import ResultsTranslate
+from View.Results.translate import (
+    ResultsTranslate,
+    CompareResultsTranslate
+)
 from View.Stricklers.Window import StricklersWindow
 
 _translate = QCoreApplication.translate
@@ -82,16 +86,17 @@ class ResultsWindow(PamhyrWindow):
         )
 
     def __init__(self, study=None, config=None,
-                 solver=None, results=None,
+                 results=None, parent=None, trad=None):
-                 parent=None):
+        self._solvers = [r._solver for r in results]
-        self._solver = solver
         self._results = results
+        self._current_results = [0]
 
+        if trad is None:
             trad = ResultsTranslate()
         name = (
             trad[self._pamhyr_name] + " - "
             + study.name + " - "
-            + self._solver.name
+            + " - ".join([s.name for s in self._solvers])
         )
 
         super(ResultsWindow, self).__init__(
@@ -102,14 +107,15 @@ class ResultsWindow(PamhyrWindow):
             parent=parent
         )
 
-        self._hash_data.append(self._solver)
+        for r in results:
-        self._hash_data.append(self._results)
+            self._hash_data.append(r._solver)
+            self._hash_data.append(r._repertory)
+            self._hash_data.append(r._name)
 
         self._additional_plot = {}
 
         try:
-            self._timestamps = sorted(list(self._results.get("timestamps")))
+            self.get_timestamps()
-
             self.setup_slider()
             self.setup_table()
             self.setup_plots()
@@ -119,22 +125,31 @@ class ResultsWindow(PamhyrWindow):
             logger_exception(e)
             return
 
+        self.update(reach_id=0,
+                    profile_id=0)
+
+        self.update_table_selection_solver(0)
+
     def setup_table(self):
         self._table = {}
-        for t in ["reach", "profile", "raw_data"]:
+        for t in ["reach", "profile", "raw_data", "solver"]:
             table = self.find(QTableView, f"tableView_{t}")
             self._table[t] = TableModel(
                 table_view=table,
                 table_headers=self._trad.get_dict(f"table_headers_{t}"),
                 data=self._results,
                 undo=self._undo_stack,
-                opt_data=t
+                opt_data=t,
+                parent=self
             )
             self._table[t]._timestamp = self._timestamps[
                 self._slider_time.value()]
+        if len(self._results) <= 1:
+            table = self.find(QTableView, f"tableView_solver")
+            table.hide()
 
     def setup_slider(self):
-        default_reach = self._results.river.reach(0)
+        default_reach = self._results[self._current_results[0]].river.reach(0)
 
         self._slider_time = self.find(QSlider, f"horizontalSlider_time")
         self._slider_time.setMaximum(len(self._timestamps) - 1)
@@ -181,6 +196,7 @@ class ResultsWindow(PamhyrWindow):
             results=self._results,
             reach_id=0,
             profile_id=0,
+            res_id=self._current_results,
             trad=self._trad,
             toolbar=self.toolbar,
             display_current=True,
@@ -205,8 +221,10 @@ class ResultsWindow(PamhyrWindow):
             results=self._results,
             reach_id=0,
             profile_id=0,
+            res_id=self._current_results,
             trad=self._trad,
-            toolbar=self.toolbar_2
+            toolbar=self.toolbar_2,
+            parent=self
         )
         self.plot_rkc.draw()
 
@@ -227,8 +245,10 @@ class ResultsWindow(PamhyrWindow):
             results=self._results,
             reach_id=0,
             profile_id=0,
+            res_id=self._current_results,
             trad=self._trad,
-            toolbar=self.toolbar_3
+            toolbar=self.toolbar_3,
+            parent=self
         )
         self.plot_ac.draw()
 
@@ -250,8 +270,10 @@ class ResultsWindow(PamhyrWindow):
             results=self._results,
             reach_id=0,
             profile_id=0,
+            res_id=self._current_results,
             trad=self._trad,
-            toolbar=self.toolbar_4
+            toolbar=self.toolbar_4,
+            parent=self
         )
         self.plot_h.draw()
 
@@ -314,6 +336,9 @@ class ResultsWindow(PamhyrWindow):
             # "action_export": self.export_current,
         }
 
+        if len(self._results) > 1:
+            self.find(QAction, "action_reload").setEnabled(False)
+
         for action in actions:
             self.find(QAction, action).triggered.connect(
                 actions[action]
@@ -324,9 +349,10 @@ class ResultsWindow(PamhyrWindow):
             "reach": self._set_current_reach,
             "profile": self._set_current_profile,
             "raw_data": self._set_current_profile_raw_data,
+            "solver": self._set_current_results,
         }
 
-        for t in ["reach", "profile", "raw_data"]:
+        for t in ["reach", "profile", "raw_data", "solver"]:
             table = self.find(QTableView, f"tableView_{t}")
 
             table.selectionModel()\
@@ -374,7 +400,25 @@ class ResultsWindow(PamhyrWindow):
             )
             table.scrollTo(index)
 
-    def update(self, reach_id=None, profile_id=None, timestamp=None):
+    def update_table_selection_solver(self, ind):
+        table = self.find(QTableView, f"tableView_solver")
+        selectionModel = table.selectionModel()
+        index = table.model().index(ind, 0)
+
+        selectionModel.select(
+            index,
+            QItemSelectionModel.Rows |
+            QItemSelectionModel.ClearAndSelect |
+            QItemSelectionModel.Select
+        )
+        table.scrollTo(index)
+
+    def update(self,
+               reach_id=None,
+               profile_id=None,
+               solver_id=None,
+               timestamp=None):
+
         if reach_id is not None:
             self.plot_xy.set_reach(reach_id)
             self.plot_ac.set_reach(reach_id)
@@ -398,6 +442,16 @@ class ResultsWindow(PamhyrWindow):
 
             self.update_table_selection_profile(profile_id)
 
+        if solver_id is not None:
+            self._current_results = solver_id
+            self.plot_xy.set_result(solver_id)
+            self.plot_ac.set_result(solver_id)
+            self.plot_rkc.set_result(solver_id)
+            self.plot_h.set_result(solver_id)
+
+            for plot in self._additional_plot:
+                self._additional_plot[plot].set_result(solver_id)
+
         if timestamp is not None:
             self.plot_xy.set_timestamp(timestamp)
             self.plot_ac.set_timestamp(timestamp)
@@ -450,13 +504,15 @@ class ResultsWindow(PamhyrWindow):
         self.update(profile_id=ind)
 
     def _set_current_profile_raw_data(self):
-        table = self.find(QTableView, f"tableView_raw_data")
+        return
+
+    def _set_current_results(self):
+        table = self.find(QTableView, f"tableView_solver")
         indexes = table.selectedIndexes()
         if len(indexes) == 0:
             return
 
-        ind = indexes[0].row()
+        self.update(solver_id=[i.row() for i in indexes])
-        self.update(profile_id=ind)
 
     def _set_current_timestamp(self):
         timestamp = self._timestamps[self._slider_time.value()]
@@ -480,9 +536,10 @@ class ResultsWindow(PamhyrWindow):
 
     def _reload(self):
         logger.debug("Reload results...")
-        self._results = self._results.reload()
+        if len(self._results) == 1:
+            self._results[0] = self._results[0].reload()
 
-        self._timestamps = sorted(list(self._results.get("timestamps")))
+            self.get_timestamps()
 
             self._reload_plots()
             self._reload_slider()
@@ -526,6 +583,7 @@ class ResultsWindow(PamhyrWindow):
             self._get_current_timestamp(),
             data=self._results,
             canvas=canvas,
+            res_id=self._current_results,
             toolbar=toolbar,
             parent=self,
         )
@@ -541,6 +599,25 @@ class ResultsWindow(PamhyrWindow):
         tab_widget.setCurrentWidget(widget)
 
     def _copy(self):
+        # focus on raw data table
+        if self.find(QTabWidget, f"tabWidget").currentIndex() == 0:
+            table = self.find(QTableView, f"tableView_raw_data")
+            model = self._table["raw_data"]
+
+            coltext = []
+            for index in sorted(table.selectionModel().selectedRows()):
+                row = index.row()
+                rowtext = []
+                for column in range(model.columnCount()):
+                    i = model.createIndex(row, column)
+                    try:
+                        rowtext.append(model.data(i))
+                    except AttributeError:
+                        rowtext.append("")
+                coltext.append(rowtext)
+
+            self.copyTableIntoClipboard(coltext)
+        else:
             logger.info("TODO: copy")
 
     def _paste(self):
@@ -589,9 +666,9 @@ class ResultsWindow(PamhyrWindow):
 
     def _export(self):
 
-        dlg = CustomPlotValuesSelectionDialog(parent=self)
+        dlg = CustomExportDialog(parent=self)
         if dlg.exec():
-            x, y, envelop = dlg.value
+            x, y, envelop, solver_id = dlg.value
         else:
             return
 
@@ -601,26 +678,26 @@ class ResultsWindow(PamhyrWindow):
         )
         self.file_dialog(
             select_file="AnyFile",
-            callback=lambda f: self.export_to(f[0], x, y, envelop),
+            callback=lambda f: self.export_to(f[0], x, y, envelop, solver_id),
             default_suffix=".csv",
             file_filter=["CSV (*.csv)"],
         )
 
-    def export_to(self, filename, x, y, envelop):
+    def export_to(self, filename, x, y, envelop, solver_id):
-        timestamps = sorted(self._results.get("timestamps"))
+        results = self._results[solver_id]
-        reach = self._results.river.reachs[self._get_current_reach()]
+        reach = results.river.reachs[self._get_current_reach()]
-        first_line = [f"Study: {self._results.study.name}",
+        first_line = [f"Study: {results.study.name}",
                       f"Reach: {reach.name}"]
         if x == "rk":
             timestamp = self._get_current_timestamp()
             first_line.append(f"Time: {timestamp}s")
-            val_dict = self._export_rk(timestamp, y, envelop)
+            val_dict = self._export_rk(timestamp, y, envelop, solver_id)
         elif x == "time":
             profile_id = self._get_current_profile()
             profile = reach.profile(profile_id)
             pname = profile.name if profile.name != "" else profile.rk
             first_line.append(f"Profile: {pname}")
-            val_dict = self._export_time(profile_id, y)
+            val_dict = self._export_time(profile_id, y, solver_id)
 
         with open(filename, 'w', newline='') as csvfile:
             writer = csv.writer(csvfile, delimiter=',',
@@ -667,7 +744,8 @@ class ResultsWindow(PamhyrWindow):
         )
 
     def export_current_to(self, directory):
-        reach = self._results.river.reachs[self._get_current_reach()]
+        results = self._results[self._current_results]
+        reach = results.river.reachs[self._get_current_reach()]
         self.export_all(reach, directory, [self._get_current_timestamp()])
 
     def delete_tab(self, index):
@@ -675,16 +753,32 @@ class ResultsWindow(PamhyrWindow):
         self._additional_plot.pop(tab_widget.tabText(index))
         tab_widget.removeTab(index)
 
-    def _export_rk(self, timestamp, y, envelop):
+    def _export_rk(self, timestamp, y, envelop, solver_id):
-        reach = self._results.river.reachs[self._get_current_reach()]
+        results = self._results[solver_id]
+        reach = results.river.reachs[self._get_current_reach()]
         dict_x = self._trad.get_dict("values_x")
         dict_y = self._trad.get_dict("values_y")
+        if self._current_results == 2:
+            envelop = False
+            reach1 = results[0].river.reachs[self._get_current_reach()]
+            reach2 = results[1].river.reachs[self._get_current_reach()]
         if envelop:
             dict_y.update(self._trad.get_dict("values_y_envelop"))
         my_dict = {}
         my_dict[dict_x["rk"]] = reach.geometry.get_rk()
         if "bed_elevation" in y:
-            my_dict[dict_y["bed_elevation"]] = reach.geometry.get_z_min()
+            if self._current_results != 2:
+                zmin = reach.geometry.get_z_min()
+            else:
+                z_min1 = reach1.geometry.get_z_min()
+                z_min2 = reach2.geometry.get_z_min()
+                zmin = list(
+                    map(
+                        lambda x, y: x - y,
+                        z_min2, z_min2
+                        )
+                    )
+            my_dict[dict_y["bed_elevation"]] = zmin
             # if envelop and reach.has_sediment():
         if "discharge" in y:
             my_dict[dict_y["discharge"]] = list(
@@ -744,13 +838,36 @@ class ResultsWindow(PamhyrWindow):
                 my_dict[dict_y["max_velocity"]] = [max(v) for v in velocities]
 
         if "depth" in y:
-            my_dict[dict_y["depth"]] = list(
+            if self._current_results != 2:
+                d = my_dict[dict_y["depth"]] = list(
                     map(
                         lambda p: p.geometry.max_water_depth(
                             p.get_ts_key(timestamp, "Z")),
                         reach.profiles
                     )
                 )
+            else:
+                d1 = list(
+                    map(
+                        lambda p: p.geometry.max_water_depth(
+                            p.get_ts_key(timestamp, "Z")),
+                        reach1.profiles
+                    )
+                )
+                d2 = list(
+                    map(
+                        lambda p: p.geometry.max_water_depth(
+                            p.get_ts_key(timestamp, "Z")),
+                        reach2.profiles
+                    )
+                )
+                d = list(
+                    map(
+                        lambda x, y: x - y,
+                        d1, d2
+                        )
+                    )
+            my_dict[dict_y["depth"]] = d
             if envelop:
                 my_dict[dict_y["min_depth"]] = list(map(
                     lambda p1, p2: p1 - p2, map(
@@ -768,15 +885,39 @@ class ResultsWindow(PamhyrWindow):
                 )
 
         if "mean_depth" in y:
-            my_dict[dict_y["mean_depth"]] = list(
+            if self._current_results != 2:
+                d = list(
                     map(
                         lambda p: p.geometry.mean_water_depth(
                             p.get_ts_key(timestamp, "Z")),
                         reach.profiles
                     )
                 )
+            else:
+                d1 = list(
+                    map(
+                        lambda p: p.geometry.mean_water_depth(
+                            p.get_ts_key(timestamp, "Z")),
+                        reach1.profiles
+                    )
+                )
+                d2 = list(
+                    map(
+                        lambda p: p.geometry.mean_water_depth(
+                            p.get_ts_key(timestamp, "Z")),
+                        reach2.profiles
+                    )
+                )
+                d = list(
+                    map(
+                        lambda x, y: x - y,
+                        d1, d2
+                        )
+                    )
+            my_dict[dict_y["mean_depth"]] = d
         if "froude" in y:
-            my_dict[dict_y["froude"]] = list(
+            if self._current_results != 2:
+                fr = my_dict[dict_y["froude"]] = list(
                     map(
                         lambda p:
                             p.get_ts_key(timestamp, "V") /
@@ -789,32 +930,112 @@ class ResultsWindow(PamhyrWindow):
                         reach.profiles
                     )
                 )
+            else:
+                fr1 = list(
+                    map(
+                        lambda p:
+                            p.get_ts_key(timestamp, "V") /
+                            sqrt(9.81 * (
+                                p.geometry.wet_area(
+                                    p.get_ts_key(timestamp, "Z")) /
+                                p.geometry.wet_width(
+                                    p.get_ts_key(timestamp, "Z"))
+                                )),
+                        reach1.profiles
+                    )
+                )
+                fr2 = list(
+                    map(
+                        lambda p:
+                            p.get_ts_key(timestamp, "V") /
+                            sqrt(9.81 * (
+                                p.geometry.wet_area(
+                                    p.get_ts_key(timestamp, "Z")) /
+                                p.geometry.wet_width(
+                                    p.get_ts_key(timestamp, "Z"))
+                                )),
+                        reach2.profiles
+                    )
+                )
+                fr = list(
+                    map(
+                        lambda x, y: x - y,
+                        fr1, fr2
+                        )
+                    )
+            my_dict[dict_y["froude"]] = fr
         if "wet_area" in y:
-            my_dict[dict_y["wet_area"]] = list(
+            if self._current_results != 2:
+                wa = list(
                     map(
                         lambda p: p.geometry.wet_area(
                             p.get_ts_key(timestamp, "Z")),
                         reach.profiles
                     )
                 )
+            else:
+                wa1 = list(
+                    map(
+                        lambda p: p.geometry.wet_area(
+                            p.get_ts_key(timestamp, "Z")),
+                        reach1.profiles
+                    )
+                )
+                wa2 = list(
+                    map(
+                        lambda p: p.geometry.wet_area(
+                            p.get_ts_key(timestamp, "Z")),
+                        reach2.profiles
+                    )
+                )
+                wa = list(
+                    map(
+                        lambda x, y: x - y,
+                        wa1, wa2
+                        )
+                    )
+            my_dict[dict_y["wet_area"]] = wa
 
         return my_dict
 
-    def _export_time(self, profile, y):
+    def _export_time(self, profile, y, solver_id):
-        reach = self._results.river.reachs[self._get_current_reach()]
+        results = self._results[solver_id]
+        reach = results.river.reachs[self._get_current_reach()]
         profile = reach.profile(profile)
-        ts = list(self._results.get("timestamps"))
-        ts.sort()
         dict_x = self._trad.get_dict("values_x")
         dict_y = self._trad.get_dict("values_y")
         my_dict = {}
-        my_dict[dict_x["time"]] = ts
+        my_dict[dict_x["time"]] = self._timestamps
         z = profile.get_key("Z")
         q = profile.get_key("Q")
         v = profile.get_key("V")
+        if self._current_results == 2:
+            reach1 = self._results[0].river.reach(self._reach)
+            reach2 = self._results[1].river.reach(self._reach)
+            profile1 = reach1.profile(self._profile)
+            profile2 = reach2.profile(self._profile)
+
+            q1 = profile1.get_key("Q")
+            z1 = profile1.get_key("Z")
+            v1 = profile1.get_key("V")
+
+            q2 = profile2.get_key("Q")
+            z2 = profile2.get_key("Z")
+            v2 = profile2.get_key("V")
+
         if "bed_elevation" in y:
-            my_dict[dict_y["bed_elevation"]] = [
+            if self._current_results != 2:
-                profile.geometry.z_min()] * len(ts)
+                z_min = [profile.geometry.z_min()] * len(self._timestamps)
+            else:
+                z_min1 = profile1.geometry.z_min()
+                z_min2 = profile2.geometry.z_min()
+                z_min = list(
+                    map(
+                        lambda ts:  z_min1 - z_min2,
+                        self._timestamps
+                    )
+                )
+            my_dict[dict_y["bed_elevation"]] = z_min
         if "discharge" in y:
             my_dict[dict_y["discharge"]] = q
         if "water_elevation" in y:
@@ -822,24 +1043,97 @@ class ResultsWindow(PamhyrWindow):
         if "velocity" in y:
             my_dict[dict_y["velocity"]] = v
         if "depth" in y:
-            my_dict[dict_y["depth"]] = list(
+            if self._current_results != 2:
+                d = list(
                     map(lambda z: profile.geometry.max_water_depth(z), z)
                 )
+            else:
+                d1 = list(
+                    map(lambda z: profile1.geometry.max_water_depth(z), z1)
+                )
+                d2 = list(
+                    map(lambda z: profile2.geometry.max_water_depth(z), z2)
+                )
+                d = list(
+                    map(
+                        lambda x, y: x - y,
+                        d1, d2
+                        )
+                    )
+            my_dict[dict_y["depth"]] = d
         if "mean_depth" in y:
-            my_dict[dict_y["mean_depth"]] = list(
+            if self._current_results != 2:
+                d = list(
                     map(lambda z: profile.geometry.mean_water_depth(z), z)
                 )
+            else:
+                d1 = list(
+                    map(lambda z: profile1.geometry.mean_water_depth(z), z1)
+                )
+                d2 = list(
+                    map(lambda z: profile2.geometry.mean_water_depth(z), z2)
+                )
+                d = list(
+                    map(
+                        lambda x, y: x - y,
+                        d1, d2
+                        )
+                    )
+            my_dict[dict_y["mean_depth"]] = d
         if "froude" in y:
-            my_dict[dict_y["froude"]] = list(
+            if self._current_results != 2:
+                fr = my_dict[dict_y["froude"]] = list(
                     map(lambda z, v:
                         v / sqrt(9.81 * (
                             profile.geometry.wet_area(z) /
                             profile.geometry.wet_width(z))
                         ), z, v)
                     )
+            else:
+                fr1 = list(
+                    map(lambda z, v:
+                        v /
+                        sqrt(9.81 * (
+                            profile1.geometry.wet_area(z) /
+                            profile1.geometry.wet_width(z))
+                        ), z1, v1)
+                    )
+                fr2 = list(
+                    map(lambda z, v:
+                        v /
+                        sqrt(9.81 * (
+                            profile2.geometry.wet_area(z) /
+                            profile2.geometry.wet_width(z))
+                        ), z2, v2)
+                    )
+                fr = list(
+                    map(
+                        lambda x, y: x - y,
+                        fr1, fr2
+                        )
+                    )
+            my_dict[dict_y["froude"]] = fr
         if "wet_area" in y:
-            my_dict[dict_y["wet_area"]] = list(
+            if self._current_results != 2:
+                wa = list(
                     map(lambda z: profile.geometry.wet_area(z), z)
                 )
+            else:
+                wa1 = list(
+                    map(lambda z: profile1.geometry.wet_area(z), z1)
+                )
+                wa2 = list(
+                    map(lambda z: profile2.geometry.wet_area(z), z2)
+                )
+                wa = list(
+                    map(
+                        lambda x, y: x - y,
+                        wa1, wa2
+                        )
+                    )
+            my_dict[dict_y["wet_area"]] = wa
 
         return my_dict
+
+    def get_timestamps(self):
+        self._timestamps = sorted(list(self._results[0].get("timestamps")))

src/View/Results/WindowAdisTS.py

@@ -49,7 +49,7 @@ from View.Tools.Plot.PamhyrToolbar import PamhyrPlotToolbar
 from View.Results.PlotSedAdis import PlotAdis_dx, PlotAdis_dt
 
 from View.Results.CustomPlot.Plot import CustomPlot
-from View.Results.CustomExportAdis import (
+from View.Results.CustomExport.CustomExportAdis import (
     CustomExportAdisDialog,
 )
 
@@ -98,7 +98,8 @@ class ResultsWindowAdisTS(PamhyrWindow):
         )
 
         self._hash_data.append(self._solver)
-        self._hash_data.append(self._results)
+        self._hash_data.append(self._results._repertory)
+        self._hash_data.append(self._results._name)
 
         self._additional_plot = {}
         self._current_pol_id = [1]
@@ -380,8 +381,8 @@ class ResultsWindowAdisTS(PamhyrWindow):
                 self._results.pollutants_list[i.row()+1] for i in indexes
             ]
 
-        return (f"Reach: {reach.name} | " +
+        return (f"{self._trad['reach']}: {reach.name} | " +
-                f"Profile: {pname} | " +
+                f"{self._trad['cross_section']}: {pname} | " +
                 f"Pollutant: {', '.join(self.pollutant_label)} | " +
                 f"{self._trad['unit_time_s']} : {fts} ({ts} sec)")
 
@@ -554,15 +555,8 @@ class ResultsWindowAdisTS(PamhyrWindow):
         self.update(pol_id=rows)
 
     def _set_current_profile_raw_data(self):
-        table = self.find(QTableView, f"tableView_raw_data")
-        indexes = table.selectedIndexes()
-        if len(indexes) == 0:
         return
 
-        ind = indexes[0].row()
-        self.update(profile_id=ind)
-        self._slider_profile.setValue(ind)
-
     def _set_current_timestamp(self):
         timestamp = self._timestamps[self._slider_time.value()]
         self.update(timestamp=timestamp)
@@ -597,6 +591,25 @@ class ResultsWindowAdisTS(PamhyrWindow):
         self._reload_slider()
 
     def _copy(self):
+        # focus on raw data table
+        if self.find(QTabWidget, f"tabWidget").currentIndex() == 0:
+            table = self.find(QTableView, f"tableView_raw_data")
+            model = self._table["raw_data"]
+
+            coltext = []
+            for index in sorted(table.selectionModel().selectedRows()):
+                row = index.row()
+                rowtext = []
+                for column in range(model.columnCount()):
+                    i = model.createIndex(row, column)
+                    try:
+                        rowtext.append(str(model.data(i)))
+                    except AttributeError:
+                        rowtext.append("")
+                coltext.append(rowtext)
+
+            self.copyTableIntoClipboard(coltext)
+        else:
             logger.info("TODO: copy")
 
     def _paste(self):

src/View/Results/translate.py

@@ -42,7 +42,8 @@ class ResultsTranslate(MainTranslate):
         self._dict['day'] = _translate("Results", "day")
         self._dict['days'] = _translate("Results", "days")
 
-        self._dict['envelop'] = _translate("Results", "envelop")
+        self._dict['envelop'] = _translate("Results", "Envelop")
+        self._dict['solver'] = _translate("Results", "Solver")
 
         self._dict['x'] = _translate("Results", "X (m)")
 
@@ -62,10 +63,14 @@ class ResultsTranslate(MainTranslate):
         }
 
         self._sub_dict["table_headers_profile"] = {
-            "name": self._dict["name"],
+            "name": _translate("Results", "Profile name"),
             "rk": self._dict["unit_rk"],
         }
 
+        self._sub_dict["table_headers_solver"] = {
+            "solver": self._dict['solver'],
+        }
+
         self._sub_dict["table_headers_pollutants"] = {
             "name": _translate("Results", "Pollutant name"),
         }
@@ -134,3 +139,38 @@ class ResultsTranslate(MainTranslate):
             "unit_M": self._dict["unit_mass"],
             "unit_thickness": self._dict["unit_thickness"],
             }
+
+
+class CompareResultsTranslate(ResultsTranslate):
+    def __init__(self):
+        super(CompareResultsTranslate, self).__init__()
+
+        self._dict['label_water'] = u"Δ "+_translate(
+            "Results", "Water elevation"
+            )
+        self._dict['unit_elevation'] = u"Δ "+self._dict["unit_elevation"]
+
+        self._sub_dict["table_headers_raw_data"] = {
+            "name": _translate("Results", "Profile"),
+            "water_elevation": u"Δ "+self._dict["unit_water_elevation"],
+            "discharge": u"Δ "+self._dict["unit_discharge"],
+            "velocity": u"Δ "+self._dict["unit_velocity"],
+            "width": u"Δ "+self._dict["unit_width"],
+            "depth": u"Δ "+self._dict["unit_depth"],
+            "mean_depth": u"Δ "+self._dict["unit_mean_depth"],
+            "wet_area": u"Δ "+self._dict["unit_wet_area"],
+            "wet_perimeter": u"Δ "+self._dict["unit_wet_perimeter"],
+            "hydraulic_radius": u"Δ "+self._dict["unit_hydraulic_radius"],
+            "froude": u"Δ "+self._dict["unit_froude"],
+        }
+
+        self._sub_dict["values_y"] = {
+            "bed_elevation": u"Δ "+self._dict["unit_bed_elevation"],
+            "water_elevation": u"Δ "+self._dict["unit_water_elevation"],
+            "discharge": u"Δ "+self._dict["unit_discharge"],
+            "velocity": u"Δ "+self._dict["unit_velocity"],
+            "depth": u"Δ "+self._dict["unit_depth"],
+            "mean_depth": u"Δ "+self._dict["unit_mean_depth"],
+            "froude": u"Δ "+self._dict["unit_froude"],
+            "wet_area": u"Δ "+self._dict["unit_wet_area"],
+        }

src/View/RunSolver/Window.py

@@ -138,6 +138,107 @@ class SelectSolverWindow(PamhyrDialog):
         super(SelectSolverWindow, self).accept()
 
 
+class CompareSolversWindow(PamhyrDialog):
+    _pamhyr_ui = "CompareSolvers"
+    _pamhyr_name = "Compare solvers"
+
+    def __init__(self, study=None, config=None,
+                 parent=None):
+        self._solver1 = None
+        self._solver2 = None
+
+        name = _translate("Solver", "Compare solvers")
+        super(CompareSolversWindow, self).__init__(
+            title=name,
+            study=study,
+            config=config,
+            options=[],
+            parent=parent
+        )
+
+        self.setup_combobox1()
+        self.setup_combobox2()
+        self.setup_connections()
+        self.select_last_solver()
+
+    def setup_combobox1(self):
+        solvers = self._config.solvers
+        solvers_name = list(
+            map(
+                self._format_solver_name,
+                solvers
+            )
+        )
+
+        self.combobox_add_items("comboBox1", solvers_name)
+
+    def setup_combobox2(self):
+        solvers = self._config.solvers
+        solvers_name = list(
+            map(
+                self._format_solver_name,
+                solvers
+            )
+        )
+
+        self.combobox_add_items("comboBox2", solvers_name)
+
+    def setup_connections(self):
+        self.find(QPushButton, "pushButton_ok").clicked.connect(self.accept)
+        self.find(QPushButton, "pushButton_cancel")\
+            .clicked.connect(self.reject)
+
+    def select_last_solver(self):
+        solvers = self._config.solvers
+        last = self._config.last_solver_name
+
+        solver = list(
+            filter(
+                lambda s: s.name == last,
+                solvers
+            )
+        )
+
+        if len(solver) != 0:
+            self.set_combobox_text(
+                "comboBox1",
+                self._format_solver_name(solver[0])
+            )
+
+    def _format_solver_name(self, solver):
+        return f"{solver.name} - ({solver._type})"
+
+    @property
+    def solver1(self):
+        return self._solver1
+
+    @property
+    def solver2(self):
+        return self._solver2
+
+    def accept(self):
+        solver_name1 = self.get_combobox_text("comboBox1")
+        solver_name1 = solver_name1.rsplit(" - ", 1)[0]
+
+        self._solver1 = next(
+            filter(
+                lambda s: s.name == solver_name1,
+                self._config.solvers
+            )
+        )
+        solver_name2 = self.get_combobox_text("comboBox2")
+        solver_name2 = solver_name2.rsplit(" - ", 1)[0]
+
+        self._solver2 = next(
+            filter(
+                lambda s: s.name == solver_name2,
+                self._config.solvers
+            )
+        )
+
+        super(CompareSolversWindow, self).accept()
+
+
 class SolverLogWindow(PamhyrWindow):
     _pamhyr_ui = "SolverLog"
     _pamhyr_name = "Solver Log"

src/View/Translate.py

@@ -106,17 +106,15 @@ class UnitTranslate(CommonWordTranslate):
         self._dict["unit_min_velocity"] = _translate(
             "Unit", "Min Velocity (m/s)"
         )
-        self._dict["unit_discharge"] = _translate("Unit", "Discharge (m^3/s)")
+        self._dict["unit_discharge"] = _translate(
+                "Unit", "Discharge") + f" (m³/s)"
         self._dict["unit_discharge_envelop"] = _translate(
-            "Unit", "Discharge Envelop (m^3/s)"
+            "Unit", "Discharge Envelop") + " (m³/s)"
-        )
         self._dict["unit_max_discharge"] = _translate(
-            "Unit", "Max Discharge (m^3/s)"
+            "Unit", "Max Discharge") + " (m³/s)"
-        )
         self._dict["unit_min_discharge"] = _translate(
-            "Unit", "Min Discharge (m^3/s)"
+            "Unit", "Min Discharge") + " (m³/s)"
-        )
+        self._dict["unit_area_he"] = _translate("Unit", "Area (hectare)")
-        self._dict["unit_area"] = _translate("Unit", "Area (hectare)")
 
         self._dict["unit_time_s"] = _translate("Unit", "Time (sec)")
         self._dict["unit_time_p"] = _translate("Unit", "Time (JJJ:HH:MM:SS)")
@@ -136,7 +134,7 @@ class UnitTranslate(CommonWordTranslate):
         self._dict["unit_concentration"] = _translate(
             "Unit", "Concentration (g/l)"
         )
-        self._dict["unit_wet_area"] = _translate("Unit", "Wet Area (m²)")
+        self._dict["unit_wet_area"] = _translate("Unit", "Wet Area") + " (m²)"
         self._dict["unit_wet_perimeter"] = _translate(
             "Unit", "Wet Perimeter (m)"
         )
@@ -146,8 +144,7 @@ class UnitTranslate(CommonWordTranslate):
         self._dict["unit_froude"] = _translate("Unit", "Froude number")
         self._dict["unit_mass"] = _translate("Unit", "Mass (kg)")
         self._dict["unit_concentration"] = _translate(
-            "Unit", "Concentration (kg/m^3)"
+            "Unit", "Concentration") + " (kg/m³)"
-        )
 
 
 class MainTranslate(UnitTranslate):

src/View/ui/CompareSolvers.ui

@@ -0,0 +1,61 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<ui version="4.0">
+ <class>Dialog</class>
+ <widget class="QDialog" name="Dialog">
+  <property name="geometry">
+   <rect>
+    <x>0</x>
+    <y>0</y>
+    <width>320</width>
+    <height>80</height>
+   </rect>
+  </property>
+  <property name="windowTitle">
+   <string>Dialog</string>
+  </property>
+  <property name="locale">
+   <locale language="English" country="Europe"/>
+  </property>
+  <layout class="QGridLayout" name="gridLayout">
+   <item row="0" column="0">
+    <widget class="QComboBox" name="comboBox1"/>
+   </item>
+   <item row="2" column="0">
+    <layout class="QHBoxLayout" name="horizontalLayout">
+     <item>
+      <spacer name="horizontalSpacer">
+       <property name="orientation">
+        <enum>Qt::Horizontal</enum>
+       </property>
+       <property name="sizeHint" stdset="0">
+        <size>
+         <width>40</width>
+         <height>20</height>
+        </size>
+       </property>
+      </spacer>
+     </item>
+     <item>
+      <widget class="QPushButton" name="pushButton_cancel">
+       <property name="text">
+        <string>Cancel</string>
+       </property>
+      </widget>
+     </item>
+     <item>
+      <widget class="QPushButton" name="pushButton_ok">
+       <property name="text">
+        <string>OK</string>
+       </property>
+      </widget>
+     </item>
+    </layout>
+   </item>
+   <item row="1" column="0">
+    <widget class="QComboBox" name="comboBox2"/>
+   </item>
+  </layout>
+ </widget>
+ <resources/>
+ <connections/>
+</ui>

src/View/ui/EditBoundaryConditions.ui

@@ -113,7 +113,7 @@
   <action name="action_sort">
    <property name="icon">
     <iconset>
-     <normaloff>ressources/sort_A-Z.png</normaloff>ressources/sort_A-Z.png</iconset>
+     <normaloff>ressources/sort_1-9.png</normaloff>ressources/sort_1-9.png</iconset>
    </property>
    <property name="text">
     <string>Sort</string>

src/View/ui/EditBoundaryConditionsAdisTS.ui

@@ -72,6 +72,7 @@
    </attribute>
    <addaction name="action_add"/>
    <addaction name="action_del"/>
+   <addaction name="action_sort"/>
   </widget>
   <action name="action_add">
    <property name="checkable">
@@ -106,6 +107,18 @@
     <string>Ctrl+D</string>
    </property>
   </action>
+  <action name="action_sort">
+   <property name="icon">
+    <iconset>
+     <normaloff>ressources/sort_1-9.png</normaloff>ressources/sort_1-9.png</iconset>
+   </property>
+   <property name="text">
+    <string>Sort</string>
+   </property>
+   <property name="toolTip">
+    <string>Sort points</string>
+   </property>
+  </action>
  </widget>
  <resources/>
  <connections/>

src/View/ui/MainWindow.ui

@@ -161,6 +161,7 @@
     </property>
     <addaction name="action_menu_results_last"/>
     <addaction name="action_open_results_from_file"/>
+    <addaction name="action_compare_results"/>
     <addaction name="action_open_results_adists"/>
    </widget>
    <widget class="QMenu" name="menu_help">
@@ -774,6 +775,11 @@
     <string>DIF</string>
    </property>
   </action>
+  <action name="action_compare_results">
+   <property name="text">
+    <string>Compare results</string>
+   </property>
+  </action>
   <action name="action_open_results_adists">
    <property name="enabled">
     <bool>false</bool>

src/View/ui/Results.ui

@@ -41,6 +41,13 @@
          </item>
         </layout>
        </widget>
+       <widget class="QWidget" name="horizontalLayoutWidget">
+        <layout class="QHBoxLayout" name="horizontalLayout_5">
+         <item>
+          <widget class="QTableView" name="tableView_solver"/>
+         </item>
+        </layout>
+       </widget>
       </widget>
       <widget class="QWidget" name="layoutWidget">
        <layout class="QGridLayout" name="gridLayout_2">

src/View/ui/ResultsAdisTS.ui

@@ -46,9 +46,6 @@
          <item>
           <widget class="QTableView" name="tableView_pollutants"/>
          </item>
-         <item>
-          <layout class="QVBoxLayout" name="verticalLayout_tot_left"/>
-         </item>
         </layout>
        </widget>
       </widget>
@@ -457,7 +454,7 @@
  <resources/>
  <connections/>
  <buttongroups>
-  <buttongroup name="buttonGroup"/>
   <buttongroup name="buttonGroup_2"/>
+  <buttongroup name="buttonGroup"/>
  </buttongroups>
 </ui>