Merge branch 'master' into terraz_dev

.gitignore

@@ -41,6 +41,9 @@ __old__
 
 *-venv
 
+mage8
+adists
+
 ### END CUSTOM ###
 
 # Created by https://www.toptal.com/developers/gitignore/api/python

src/View/Results/CustomPlot/Plot.py

@@ -21,6 +21,7 @@ import logging
 from functools import reduce
 from datetime import datetime
 from numpy import sqrt
+from numpy import asarray
 
 from tools import timer
 from View.Tools.PamhyrPlot import PamhyrPlot
@@ -31,6 +32,7 @@ logger = logging.getLogger()
 
 unit = {
     "bed_elevation": "0-meter",
+    "bed_elevation_envelop": "0-meter",
     "water_elevation": "0-meter",
     "water_elevation_envelop": "0-meter",
     "discharge": "1-m3s",
@@ -82,11 +84,97 @@ class CustomPlot(PamhyrPlot):
 
         self._axes = {}
 
+    def draw_bottom_with_bedload(self, reach):
+        self._bedrock = self.sl_compute_bedrock(reach)
+
+        rk = reach.geometry.get_rk()
+        z = self.sl_compute_current_z(reach)
+
+        return z
+
+    def sl_compute_current_z(self, reach):
+        z_br = self._bedrock
+        sl = self.sl_compute_current_rk(reach)
+
+        z = list(
+            map(
+                lambda z, sl: reduce(
+                    lambda z, h: z + h[0],
+                    sl, z
+                ),
+                z_br,           # Bedrock elevation
+                sl              # Current sediment layers
+            )
+        )
+
+        return z
+
+    def sl_compute_bedrock(self, reach):
+        z_min = reach.geometry.get_z_min()
+        sl = self.sl_compute_initial(reach)
+
+        z = list(
+            map(
+                lambda z, sl: reduce(
+                    lambda z, h: z - h[0],
+                    sl, z
+                ),
+                z_min,          # Original geometry
+                sl              # Original sediment layers
+            )
+        )
+
+        return z
+
+    def sl_compute_initial(self, reach):
+        """
+        Get SL list for profile p at initial time (initial data)
+        """
+        t0 = min(list(self.data.get("timestamps")))
+        return map(
+            lambda p: p.get_ts_key(t0, "sl")[0],
+            reach.profiles
+        )
+
+    def sl_compute_current_rk(self, reach):
+        """
+        Get SL list for profile p at current time
+        """
+        return map(
+            lambda p: p.get_ts_key(self._timestamp, "sl")[0],
+            reach.profiles
+        )
+
+    def get_ts_zmin(self, profile):
+        results = self.data
+        nt = len(list(results.get("timestamps")))
+        reach = results.river.reach(self._reach)
+        berdrock = self.sl_compute_bedrock(reach)
+        sl = reach.profile(profile).get_key("sl")
+
+        ts_z_bedrock = [berdrock[profile]]*nt
+
+        ts_z_min = list(
+            map(
+                lambda z, sl: reduce(
+                    lambda z, h: z + h,
+                    sl, z
+                ),
+                ts_z_bedrock,           # Bedrock elevations
+                asarray(sl)[:,0,:,0]    # Sediment layers
+            )
+        )
+        return ts_z_min
+
     def _draw_rk(self):
         results = self.data
         reach = results.river.reach(self._reach)
         rk = reach.geometry.get_rk()
-        z_min = reach.geometry.get_z_min()
+        if reach.has_sediment():
+            z_min = self.draw_bottom_with_bedload(reach)
+        else:
+            z_min = reach.geometry.get_z_min()
+
         q = list(
             map(
                 lambda p: p.get_ts_key(self._timestamp, "Q"),
@@ -120,6 +208,36 @@ class CustomPlot(PamhyrPlot):
             )
             self.lines["bed_elevation"] = line
 
+            if self._envelop and reach.has_sediment():
+
+                ax = self._axes[unit["bed_elevation_envelop"]]
+
+                e = list(
+                        map(
+                            lambda p: max(self.get_ts_zmin(p)),
+                            range(len(reach))
+                        )
+                    )
+                line1 = ax.plot(
+                    rk, e,
+                    color='grey', lw=1.,
+                    linestyle='dotted',
+                )
+                self.lines["bed_elevation_envelop"] = line1
+
+                e = list(
+                        map(
+                            lambda p: min(self.get_ts_zmin(p)),
+                            range(len(reach))
+                        )
+                    )
+                line2 = ax.plot(
+                    rk, e,
+                    color='grey', lw=1.,
+                    linestyle='dotted',
+                )
+                # self.lines["bed_elevation_envelop"] = line2
+
         if "water_elevation" in self._y:
 
             ax = self._axes[unit["water_elevation"]]
@@ -371,6 +489,11 @@ class CustomPlot(PamhyrPlot):
         reach = results.river.reach(self._reach)
         rk = reach.geometry.get_rk()
         z_min = reach.geometry.get_z_min()
+        if reach.has_sediment():
+            z_min = self.draw_bottom_with_bedload(reach)
+        else:
+            z_min = reach.geometry.get_z_min()
+
         q = list(
             map(
                 lambda p: p.get_ts_key(self._timestamp, "Q"),
@@ -520,12 +643,15 @@ class CustomPlot(PamhyrPlot):
         q = profile.get_key("Q")
         z = profile.get_key("Z")
         z_min = profile.geometry.z_min()
-        ts_z_min = list(
+        if reach.has_sediment():
-            map(
+            ts_z_min = self.get_ts_zmin(self._profile)
-                lambda ts:  z_min,
+        else:
-                ts
+            ts_z_min = list(
+                map(
+                    lambda ts:  z_min,
+                    ts
+                )
             )
-        )
 
         self.lines = {}
         if "bed_elevation" in self._y:
@@ -656,13 +782,18 @@ class CustomPlot(PamhyrPlot):
 
         q = profile.get_key("Q")
         z = profile.get_key("Z")
-        z_min = profile.geometry.z_min()
+        if reach.has_sediment():
-        ts_z_min = list(
+            ts_z_min = self.get_ts_zmin(self._profile)
-            map(
+        else:
-                lambda ts:  z_min,
+            z_min = profile.geometry.z_min()
-                ts
+            ts_z_min = list(
+                map(
+                    lambda ts:  z_min,
+                    ts
+                )
             )
-        )
+        if "bed_elevation" in self._y:
+            self.lines["bed_elevation"][0].set_ydata(ts_z_min)
 
         if "water_elevation" in self._y:
             self.lines["water_elevation"][0].set_ydata(z)
@@ -716,6 +847,9 @@ class CustomPlot(PamhyrPlot):
             )
             self.lines["wet_area"][0].set_ydata(d)
 
+        self.canvas.axes.relim(visible_only=True)
+        self.canvas.axes.autoscale_view()
+
     def draw(self):
         self.draw_static()
 
@@ -776,15 +910,15 @@ class CustomPlot(PamhyrPlot):
             lw=1.,
         )
 
-        self.canvas.figure.canvas.draw_idle()
         if self.toolbar is not None:
             self.toolbar.update()
+        self.canvas.draw_idle()
 
     @timer
     def update(self):
-        # if not self._init:
         self.draw_update()
         self.draw_current()
+        # self.draw_static()
         return
 
     def set_reach(self, reach_id):
@@ -817,4 +951,5 @@ class CustomPlot(PamhyrPlot):
         elif self._x == "time":
             x = self._timestamp
         self._current.set_data([x, x], self.canvas.axes.get_ylim())
-        self.canvas.figure.canvas.draw_idle()
+        self.canvas.draw_idle()
+

src/View/Results/CustomPlot/Translate.py

@@ -42,6 +42,9 @@ class CustomPlotTranslate(ResultsTranslate):
         self._dict['discharge'] = self._dict["unit_discharge"]
         self._dict['discharge_envelop'] = self._dict["unit_discharge_envelop"]
         self._dict['bed_elevation'] = self._dict["unit_bed_elevation"]
+        self._dict['bed_elevation_envelop'] = self._dict[
+            "unit_bed_elevation_envelop"
+        ]
         self._dict['velocity'] = self._dict["unit_velocity"]
         self._dict['width'] = self._dict["unit_width"]
         self._dict['velocity_envelop'] = self._dict["unit_velocity_envelop"]

src/View/Results/Window.py

@@ -685,6 +685,7 @@ class ResultsWindow(PamhyrWindow):
         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 envelop and reach.has_sediment():
         if "discharge" in y:
             my_dict[dict_y["discharge"]] = list(
                 map(

src/View/Results/translate.py

@@ -113,6 +113,8 @@ class ResultsTranslate(MainTranslate):
             }
 
         self._sub_dict["values_y_envelop"] = {
+            "min_bed_elevation": self._dict["unit_min_bed_elevation"],
+            "max_bed_elevation": self._dict["unit_max_bed_elevation"],
             "min_water_elevation": self._dict["unit_min_water_elevation"],
             "max_water_elevation": self._dict["unit_max_water_elevation"],
             "min_discharge": self._dict["unit_min_discharge"],

src/View/Translate.py

@@ -75,6 +75,15 @@ class UnitTranslate(CommonWordTranslate):
         self._dict["unit_bed_elevation"] = _translate(
             "Unit", "Bed Elevation (m)"
         )
+        self._dict["unit_bed_elevation_envelop"] = _translate(
+            "Unit", "Bed Elevation Envelop (m)"
+        )
+        self._dict["unit_max_bed_elevation"] = _translate(
+            "Unit", "Max Bed Elevation (m)"
+        )
+        self._dict["unit_min_bed_elevation"] = _translate(
+            "Unit", "Min Bed Elevation (m)"
+        )
         self._dict["unit_water_elevation"] = _translate(
             "Unit", "Water Elevation (m)"
         )