Results: Clear db load code.

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"] = ts
+            data["timestamps"] = sorted(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 = self.get("timestamps")
+        ts = sorted(self.get("timestamps"))
         sf = ">" + ''.join(itertools.repeat("d", len(ts)))
 
         execute(

src/Model/Results/River/River.py

@@ -65,7 +65,8 @@ class Profile(SQLSubModel):
 
     def get_key(self, key):
         res = list(
-            map(lambda ts: self._data[ts][key], self._data)
+            map(lambda ts: self._data[ts][key],
+                sorted(self._data.keys()))
         )
         return res
 
@@ -152,29 +153,9 @@ 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)
-
-                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))
+                values = cls._db_load_data_sl_format(values, len_data, timestamps)
 
             for timestamp, value in zip(timestamps, values):
                 new_data.set(timestamp, key, value)
@@ -183,6 +164,35 @@ 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(
@@ -209,6 +219,9 @@ 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(