Solver: Mage: Fix path name with whitespaces.

src/Solver/Mage.py

@@ -177,15 +177,15 @@ class Mage(CommandLineSolver):
         return lst
 
     def input_param(self):
-        name = self._study.name
+        name = self._study.name.replace(" ", "_")
         return f"{name}.REP"
 
     def output_param(self):
-        name = self._study.name
+        name = self._study.name.replace(" ", "_")
         return f"{name}.BIN"
 
     def log_file(self):
-        name = self._study.name
+        name = self._study.name.replace(" ", "_")
         return f"{name}.TRA"
 
     def _export_REP_additional_lines(self, study, rep_file):
@@ -819,7 +819,8 @@ 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
+from tools import logger_exception, pamhyr_db_need_update, timer
 
 from PyQt5 import QtGui
 from PyQt5.QtGui import (
@@ -1710,12 +1710,13 @@ class ApplicationWindow(QMainWindow, ListedSubWindow, WindowToolKit):
             config=self.conf,
             parent=self
         )
-        if run.exec():
-            results = self.diff_results(run.solver1,
-                                        run.solver2)
-        else:
+        if not run.exec():
             return
 
+        results = self.diff_results(
+            run.solver1, run.solver2
+        )
+
         # At least one result not available
         if results is None:
             return
@@ -1737,97 +1738,96 @@ 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:
-            # TODO message
-            return None
-        if solver2 is None:
-            # TODO message
+        if solver1 is None or solver2 is None:
+            self.msg_diff_results_param()
             return None
 
-        solver3 = GenericSolver(solver1.name+" - "+solver2.name)
-        solver4 = GenericSolver(solver1.name)
-        solver5 = GenericSolver(solver2.name)
+        solver3 = GenericSolver(solver1.name + " <> " + 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
+        if result1 is None or result2 is None:
+            self.msg_diff_results_param()
             return None
 
-        if result2.get("nb_reach") != result1.get("nb_reach"):
-            # TODO message
+        if result1.get("nb_reach") != result2.get("nb_reach"):
+            self.msg_diff_results_compatibility()
             return None
 
-        if result2.get("nb_profile") != result1.get("nb_profile"):
-            # TODO message
+        if result1.get("nb_profile") != result2.get("nb_profile"):
+            self.msg_diff_results_compatibility()
             return None
 
-        # return [result1, result2]
+        return self._diff_results(
+            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)
-                reach5 = result5.river.reach(r)
-                for p, (profile1, profile2) in enumerate(zip(
-                        reach1.profiles, reach2.profiles)):
+
+                for profile1, profile2, profile3 in zip(
+                        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
-                        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]
+                        profile3.set(timestamp, key, d)
+
+                    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,6 +228,18 @@ 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")