src/Model/Results/Results.py

@@ -164,7 +164,7 @@ class Results(SQLSubModel):
             ts = struct.unpack(sf, timestamps_bytes)
             new_results.set("timestamps", ts)
 
-            data["timestamps"] = sorted(ts)
+            data["timestamps"] = ts
             new_results._river = River._db_load(execute, data)
 
             new = new_results
@@ -192,7 +192,7 @@ class Results(SQLSubModel):
             solver_name = self._solver._name
             solver_type = self._solver._type
 
-        ts = sorted(self.get("timestamps"))
+        ts = self.get("timestamps")
         sf = ">" + ''.join(itertools.repeat("d", len(ts)))
 
         execute(

src/Model/Results/River/River.py

@@ -65,8 +65,7 @@ class Profile(SQLSubModel):
 
     def get_key(self, key):
         res = list(
-            map(lambda ts: self._data[ts][key],
+            map(lambda ts: self._data[ts][key], self._data)
-                sorted(self._data.keys()))
         )
         return res
 
@@ -153,9 +152,29 @@ class Profile(SQLSubModel):
                 len_values = len(values)
                 values = struct.unpack(sf, data)
             elif key in ["sl"]:
+                nb_layer = len_data / len(timestamps) / 3
                 sf = ">" + ''.join(itertools.repeat("f", len_data))
                 values = struct.unpack(sf, data)
-                values = cls._db_load_data_sl_format(values, len_data, timestamps)
+
+                tmp_values = [[]]
+                for value in values:
+                    t = tmp_values[-1]
+                    if len(t) < 3:
+                        t.append(value)
+                    else:
+                        tmp_values.append([value])
+
+                tmp_values = list(map(tuple, tmp_values))
+
+                values = [[]]
+                for value in tmp_values:
+                    t = values[-1]
+                    if len(t) < nb_layer:
+                        t.append(value)
+                    else:
+                        values.append([value])
+
+                values = list(map(lambda x: [x], values))
 
             for timestamp, value in zip(timestamps, values):
                 new_data.set(timestamp, key, value)
@@ -164,35 +183,6 @@ class Profile(SQLSubModel):
 
         return list(new.values())
 
-    @classmethod
-    def _db_load_data_sl_format(cls, values, len_data, timestamps):
-        tuple_size = 3
-
-        # HACK: Transforme list of value to list of n-tuple
-        # sediment results: (h, d50, sigma)
-        tmp_values = [[]]
-        for value in values:
-            t = tmp_values[-1]
-            if len(t) < tuple_size:
-                t.append(value)
-            else:
-                tmp_values.append([value])
-
-        tmp_values = list(map(tuple, tmp_values))
-
-        # HACK: Transforme list of n-tuple to list of n-list
-        # of n-tuple, where n is the number of layer.
-        nb_layer = len_data / len(timestamps) / tuple_size
-        values = [[]]
-        for value in tmp_values:
-            t = values[-1]
-            if len(t) < nb_layer:
-                t.append(value)
-            else:
-                values.append([value])
-
-        return list(map(lambda x: [x], values))
-
     def update_water_limits(self, timestamp, z):
         limits = self.geometry.get_water_limits(z)
         self.set(
@@ -219,9 +209,6 @@ class Profile(SQLSubModel):
                 sf = ">" + ''.join(itertools.repeat("f", len(values)))
                 len_values = len(values)
             elif key is "sl":
-                # HACK: Some dirty code to transforme list of list of
-                # tuple to list of values and ensure the values is
-                # float type...
                 values = flatten(
                     flatten(
                         map(lambda v: list(