Results: Compare: Simplify compare method and add message box on error.

src/View/MainWindow.py

@@ -1710,12 +1710,13 @@ class ApplicationWindow(QMainWindow, ListedSubWindow, WindowToolKit):
             config=self.conf,
             parent=self
         )
-        if run.exec():
+        if not 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
@@ -1737,97 +1738,95 @@ 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"]
+        )
+
     def diff_results(self, solver1, solver2):
-        if solver1 is None:
+        if solver1 is None or solver2 is None:
-            # TODO message
+            self.msg_diff_results_param()
-            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 result2 is None:
+        if result1 is None or result2 is None:
-            # TODO message
+            self.msg_diff_results_param()
             return None
 
         if result2.get("nb_reach") != result1.get("nb_reach"):
-            # TODO message
+            self.msg_diff_results_compatibility()
             return None
 
         if result2.get("nb_profile") != result1.get("nb_profile"):
-            # TODO message
+            self.msg_diff_results_compatibility()
             return None
 
-        # return [result1, result2]
+        return self._diff_results(
+            solver1, solver2, solver3,
+            result1, result2,
+        )
+
+    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(
-                for p, (profile1, profile2) in enumerate(zip(
+                        zip(reach1.profiles,
-                        reach1.profiles, reach2.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]
+                        reach3.set(p, timestamp, key, d)
+
+                    limits = reach3.profile(p)\
+                                   .geometry\
+                                   .get_water_limits(
+                                       reach3.profile(p)\
+                                             .get_ts_key(timestamp, "Z")
+                                   )
+                    reach3.set(p, 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")