src/Model/Results/River/River.py

@@ -104,7 +104,7 @@ class Profile(SQLSubModel):
         return any(map(lambda ts: "sl" in self._data[ts], self._data))
 
     def has_bedload(self):
-        return any(map(lambda ts: "sl" in self._data[ts], self._data))
+        return any(map(lambda ts: "zfd" in self._data[ts], self._data))
 
     @classmethod
     def _db_create(cls, execute, ext=""):

src/Solver/Mage.py

@@ -1393,14 +1393,12 @@ class Mage8(Mage):
 
             logger.info(f"compute river bed elevation...")
 
-            zfd_lst = []
-
             for r in reachs:
                 z_min = r.geometry.get_z_min()
-                sls = map(
+                sls = list(map(
                     lambda p: p.get_ts_key(ts_list[0], "sl")[0],
                     r.profiles
-                )
+                    ))
                 z_br = list(map(
                     lambda z, sl: reduce(
                         lambda z, h: z - h[0],
@@ -1409,11 +1407,11 @@ class Mage8(Mage):
                     z_min,          # Original geometry
                     sls             # Original sediment layers
                 ))
-                for its, t in enumerate(ts_list):
+                for t in ts_list:
-                    sls = map(
+                    sls = list(map(
                         lambda p: p.get_ts_key(t, "sl")[0],
                         r.profiles
-                    )
+                    ))
                     zfd = list(map(
                         lambda z, sl: reduce(
                             lambda z, h: z + h[0],
@@ -1422,13 +1420,8 @@ class Mage8(Mage):
                         z_br,       # bedrock
                         sls         # Original sediment layers
                     ))
-
+                    for i, p in enumerate(r.profiles):
-                    zfd_lst.append(np.array(zfd))
+                        r.set(i, t, "zfd", zfd[i])
-
-            table = results.get("table")
-            table["zfd"] = results.new_table_data(
-                "zfd", np.array(zfd_lst)
-            )
 
             results.set("sediment_timestamps", ts)
             logger.info(f"read_gra: ... end with {len(ts)} timestamp read")

src/View/Results/CustomPlot/Plot.py

@@ -91,14 +91,12 @@ class CustomPlot(PamhyrPlot):
         self.lines = {}
 
     def draw_bottom_with_bedload(self, reach):
-        results = self.data[self._current_res_id]
-        table = results.get("table")["zfd"]
-        ts = results.get_timestamp_id(self._current_timestamp)
-
         rk = reach.geometry.get_rk()
         z = list(
             map(
-                lambda p: table[ts, p.global_index],
+                lambda p: p.get_ts_key(
+                    self._current_timestamp, "zfd"
+                ),
                 reach.profiles
             )
         )
@@ -108,10 +106,7 @@ class CustomPlot(PamhyrPlot):
     def get_ts_zmin(self, profile, res_id):
         results = self.data[res_id]
         reach = results.river.reach(self._current_reach)
-
+        zfd = reach.profile(profile).get_key("zfd")
-        table = results.get("table")["zfd"]
-
-        zfd = table[:, reach.profile(profile).global_index]
         return zfd
 
     def _draw_rk(self):
@@ -175,14 +170,22 @@ class CustomPlot(PamhyrPlot):
                 )
             else:
                 if reach.has_bedload():
-                    z_min1 = list(map(
+                    z_min1 = list(
-                        lambda p: table["zfd"][id_ts, p.global_index],
+                            map(
+                                lambda p: p.get_ts_key(
+                                    self._current_timestamp, "zfd"
+                                ),
                                 reach1.profiles
-                    ))
+                            )
-                    z_min2 = list(map(
+                        )
-                        lambda p: table["zfd"][id_ts, p.global_index],
+                    z_min2 = list(
+                            map(
+                                lambda p: p.get_ts_key(
+                                    self._current_timestamp, "zfd"
+                                ),
                                 reach2.profiles
-                    ))
+                            )
+                        )
                 else:
                     z_min1 = reach1.geometry.get_z_min()
                     z_min2 = reach2.geometry.get_z_min()

src/View/Results/PlotRKC.py

@@ -103,15 +103,12 @@ class PlotRKC(PamhyrPlot):
             self.draw_bottom_geometry(reach)
 
     def draw_bottom_with_bedload(self, reach):
-        results = self.results[self._current_res_id]
         rk = reach.geometry.get_rk()
-
-        table = results.get("table")["zfd"]
-        ts = results.get_timestamp_id(self._current_timestamp)
-
         zfd = list(
             map(
-                lambda p: table[ts, p.global_index],
+                lambda p: p.get_ts_key(
+                    self._current_timestamp, "zfd"
+                ),
                 reach.profiles
             )
         )
@@ -399,13 +396,14 @@ class PlotRKC(PamhyrPlot):
         rk = reach.geometry.get_rk()
         # z = self.sl_compute_current_z(reach)
 
-        table = results.get("table")["zfd"]
+        zfd = list(
-        ts = results.get_timestamp_id(self._current_timestamp)
+            map(
-
+                lambda p: p.get_ts_key(
-        zfd = list(map(
+                    self._current_timestamp, "zfd"
-            lambda p: table[ts, p.global_index],
+                ),
                 reach.profiles
-        ))
+            )
+        )
 
         self.line_bottom.remove()
 

src/View/Results/Window.py

@@ -891,14 +891,17 @@ class ResultsWindow(PamhyrWindow):
         z = table["Z"]
         q = table["Q"]
         v = table["V"]
-        zfd = table["zfd"]
 
         if "bed_elevation" in y:
             if reach.has_bedload():
-                zmin = list(map(
+                zmin = list(
-                    lambda p: zfd[id_ts, p.global_index],
+                        map(
+                            lambda p: p.get_ts_key(
+                                timestamp, "zfd"
+                            ),
                             reach.profiles
-                ))
+                        )
+                    )
             else:
                 zmin = reach.geometry.get_z_min()
             my_dict[dict_y["bed_elevation"]] = zmin
@@ -1150,7 +1153,6 @@ class ResultsWindow(PamhyrWindow):
         z = table["Z"][:, profile.global_index]
         q = table["Q"][:, profile.global_index]
         v = table["V"][:, profile.global_index]
-        zfd = table["zfd"][:, profile.global_index]
 
         if self._current_results == 2:
             reach1 = self._results[0].river.reach(self._reach)
@@ -1170,7 +1172,7 @@ class ResultsWindow(PamhyrWindow):
 
         if "bed_elevation" in y:
             if reach.has_bedload():
-                z_min = zfd
+                z_min = profile.get_key("zfd")
             else:
                 z_min = [profile.geometry.z_min()] * len(self._timestamps)