src/Solver/Mage.py

@@ -177,15 +177,15 @@ class Mage(CommandLineSolver):
         return lst
 
     def input_param(self):
-        name = self._study.name.replace(" ", "_")
+        name = self._study.name
         return f"{name}.REP"
 
     def output_param(self):
-        name = self._study.name.replace(" ", "_")
+        name = self._study.name
         return f"{name}.BIN"
 
     def log_file(self):
-        name = self._study.name.replace(" ", "_")
+        name = self._study.name
         return f"{name}.TRA"
 
     def _export_REP_additional_lines(self, study, rep_file):
@@ -819,8 +819,7 @@ class Mage(CommandLineSolver):
             repertory=repertory,
             name=name,
         )
-
+        fname = os.path.join(repertory, f"{name}.BIN")
-        fname = os.path.join(repertory, f"{name}.BIN".replace(" ", "_"))
         if not os.path.isfile(fname):
             logger.info(f"Result file {name}.BIN does not exist")
             return None

src/View/MainWindow.py

@@ -32,7 +32,7 @@ from platformdirs import user_cache_dir
 from Solver.AdisTS import AdisTS
 from Solver.Mage import Mage8
 from Solver.RubarBE import Rubar3
-from tools import logger_exception, pamhyr_db_need_update, timer
+from tools import logger_exception, pamhyr_db_need_update
 
 from PyQt5 import QtGui
 from PyQt5.QtGui import (
@@ -1710,13 +1710,12 @@ class ApplicationWindow(QMainWindow, ListedSubWindow, WindowToolKit):
             config=self.conf,
             parent=self
         )
-        if not run.exec():
+        if run.exec():
+            results = self.diff_results(run.solver1,
+                                        run.solver2)
+        else:
             return
 
-        results = self.diff_results(
-            run.solver1, run.solver2
-        )
-
         # At least one result not available
         if results is None:
             return
@@ -1738,96 +1737,97 @@ class ApplicationWindow(QMainWindow, ListedSubWindow, WindowToolKit):
         )
         res.show()
 
-    def msg_diff_results_param(self):
-        self.message_box(
-            window_title=self._trad["Error"],
-            text=self._trad["mb_diff_results_title"],
-            informative_text=self._trad["mb_diff_results_param_msg"]
-        )
-
-    def msg_diff_results_compatibility(self):
-        self.message_box(
-            window_title=self._trad["Error"],
-            text=self._trad["mb_diff_results_title"],
-            informative_text=self._trad["mb_diff_results_compatibility_msg"]
-        )
-
-    @timer
     def diff_results(self, solver1, solver2):
-        if solver1 is None or solver2 is None:
+        if solver1 is None:
-            self.msg_diff_results_param()
+            # TODO message
+            return None
+        if solver2 is None:
+            # TODO message
             return None
 
-        solver3 = GenericSolver(solver1.name + " <> " + solver2.name)
+        solver3 = GenericSolver(solver1.name+" - "+solver2.name)
+        solver4 = GenericSolver(solver1.name)
+        solver5 = GenericSolver(solver2.name)
 
         result1 = solver1.results(
-            self._study,
+                        self._study,
-            self._solver_workdir(solver1),
+                        self._solver_workdir(solver1),
-        )
+                    )
+
+        if result1 is None:
+            # TODO message
+            return None
 
         result2 = solver2.results(
-            self._study,
+                        self._study,
-            self._solver_workdir(solver2),
+                        self._solver_workdir(solver2),
-        )
+                    )
 
-        if result1 is None or result2 is None:
+        if result2 is None:
-            self.msg_diff_results_param()
+            # TODO message
             return None
 
-        if result1.get("nb_reach") != result2.get("nb_reach"):
+        if result2.get("nb_reach") != result1.get("nb_reach"):
-            self.msg_diff_results_compatibility()
+            # TODO message
             return None
 
-        if result1.get("nb_profile") != result2.get("nb_profile"):
+        if result2.get("nb_profile") != result1.get("nb_profile"):
-            self.msg_diff_results_compatibility()
+            # TODO message
             return None
 
-        return self._diff_results(
+        # return [result1, result2]
-            solver1, solver2, solver3,
-            result1, result2,
-        )
-
-    @timer
-    def _diff_results(self, solver1, solver2, solver3, result1, result2):
-        result3 = Results(study=self._study, solver=solver3)
-        ts = sorted(
-            list(
-                result1.get("timestamps")\
-                       .intersection(result2.get("timestamps"))
-            )
-        )
 
+        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 = sorted(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)
-                for profile1, profile2, profile3 in zip(
+                reach5 = result5.river.reach(r)
-                        reach1.profiles,
+                for p, (profile1, profile2) in enumerate(zip(
-                        reach2.profiles,
+                        reach1.profiles, reach2.profiles)):
-                        reach3.profiles):
                     for key in ["Z", "Q", "V"]:
                         d1 = profile1.get_ts_key(timestamp, key)
                         d2 = profile2.get_ts_key(timestamp, key)
-                        d = d1 - d2
+                        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)
 
-                        profile3.set(timestamp, key, d)
+        return [result4, result5, result3]
-
-                    limits = profile3.geometry\
-                                     .get_water_limits(
-                                         profile3.get_ts_key(timestamp, "Z")
-                                     )
-                    profile3.set(timestamp, "water_limits", limits)
-
-        return [result1, result2, result3]
 
     def open_results_adists(self):
         if self._study is None:

src/View/Translate.py

@@ -228,18 +228,6 @@ class MainTranslate(UnitTranslate):
             "Do you still want to open those results?"
         )
 
-        self._dict["mb_diff_results_title"] = _translate(
-            "MainWindow", "Results compare"
-        )
-        self._dict["mb_diff_results_param_msg"] = _translate(
-            "MainWindow", "Results comparison parameters is invalid"
-        )
-        self._dict["mb_diff_results_compatibility_msg"] = _translate(
-            "MainWindow",
-            "Results comparison with two "
-            "incompatible study version"
-        )
-
         self._dict["x"] = _translate("MainWindow", "X (m)")
         self._dict["y"] = _translate("MainWindow", "Y (m)")
         self._dict["Yes"] = _translate("MainWindow", "Yes")