diff --git a/src/Model/River.py b/src/Model/River.py
index a46661f492c02f9ad1966d23b676ff6a61e00e47..2ff98bd8cfb28ef9d4d6ca93c657ca71fb2caf7f 100644
--- a/src/Model/River.py
+++ b/src/Model/River.py
@@ -209,7 +209,7 @@ class River(Graph, SQLSubModel):
self._initial_conditions = InitialConditionsDict(status=self._status)
self._stricklers = StricklersList(status=self._status)
self._parameters = {}
- self._sediment_layers = SedimentLayerList()
+ self._sediment_layers = SedimentLayerList(status=self._status)
@classmethod
def _sql_create(cls, execute):
@@ -263,6 +263,12 @@ class River(Graph, SQLSubModel):
data
)
+ # Initial conditions
+ new._sediment_layers = SedimentLayerList._sql_load(
+ execute,
+ data
+ )
+
# Parameters
new._parameters = SolverParametersList._sql_load(
execute,
diff --git a/src/Model/SedimentLayer/SedimentLayer.py b/src/Model/SedimentLayer/SedimentLayer.py
new file mode 100644
index 0000000000000000000000000000000000000000..47d84df5a94d1b72f782ed361ccf467535c179a8
--- /dev/null
+++ b/src/Model/SedimentLayer/SedimentLayer.py
@@ -0,0 +1,186 @@
+# -*- coding: utf-8 -*-
+
+from tools import trace, timer
+
+from Model.DB import SQLSubModel
+from Model.Except import NotImplementedMethodeError
+
+class Layer(SQLSubModel):
+ _sub_classes = []
+ _id_cnt = 0
+
+ def __init__(self,
+ id:int = -1, name:str = "",
+ type = "", height = 0,
+ sl = None, status = None):
+ super(Layer, self).__init__()
+
+ self._status = status
+ self._sl = sl
+
+ self._name = name
+ self._type = type
+ self._height = height
+
+ if id == -1:
+ self.id = Layer._id_cnt
+ else:
+ self.id = id
+
+
+ @classmethod
+ def _sql_create(cls, execute):
+ execute("""
+ CREATE TABLE sedimentary_layer_layer(
+ id INTEGER NOT NULL PRIMARY KEY,
+ ind INTEGER NOT NULL,
+ name TEXT NOT NULL,
+ type TEXT NOT NULL,
+ height INTEGER NOT NULL,
+ sl INTEGER,
+ FOREIGN KEY(sl) REFERENCES sedimentary_layer(id)
+ )
+ """)
+
+ return cls._create_submodel(execute)
+
+ @classmethod
+ def _sql_update(cls, execute, version):
+ return True
+
+ @classmethod
+ def _sql_load(cls, execute, data = None):
+ new = []
+ sl = data["sl"]
+
+ table = execute(
+ "SELECT id, ind, name, type, height " +
+ "FROM sedimentary_layer_layer " +
+ f"WHERE sl = {sl.id}"
+ )
+
+ for _ in table:
+ new.append(None)
+
+ for row in table:
+ ind = row[1]
+
+ layer = cls(
+ id = row[0], name = row[2],
+ type = row[3], height = row[4],
+ sl = sl, status = data['status']
+ )
+
+ new[ind] = layer
+
+ return new
+
+ def _sql_save(self, execute, data = None):
+ ind = data["ind"]
+
+ sql = (
+ "INSERT INTO " +
+ "sedimentary_layer_layer(id, ind, name, type, height, sl) "+
+ "VALUES (" +
+ f"{self.id}, {ind}, '{self._sql_format(self._name)}', " +
+ f"'{self._sql_format(self._type)}', '{self._height}', {self._sl.id}" +
+ ")"
+ )
+ execute(sql)
+
+ return True
+
+
+class SedimentLayer(SQLSubModel):
+ _sub_classes = [Layer]
+ _id_cnt = 0
+
+ def __init__(self, id:int = -1,
+ name:str = "", comment:str = "",
+ status = None):
+ super(SedimentLayer, self).__init__()
+
+ self._status = status
+ self._name = name
+ self._comment = comment
+ self._layers = []
+
+ if id == -1:
+ self.id = SedimentLayer._id_cnt
+ else:
+ self.id = id
+
+ @property
+ def name(self):
+ return self._name
+
+ @name.setter
+ def name(self, name):
+ self._name = name
+
+ @property
+ def comment(self):
+ return self._comment
+
+ @comment.setter
+ def comment(self, comment):
+ self._comment = comment
+
+ @classmethod
+ def _sql_create(cls, execute):
+ execute("""
+ CREATE TABLE sedimentary_layer(
+ id INTEGER NOT NULL PRIMARY KEY,
+ name TEXT NOT NULL,
+ comment TEXT NOT NULL
+ )
+ """)
+
+ return cls._create_submodel(execute)
+
+ @classmethod
+ def _sql_update(cls, execute, version):
+ return True
+
+ @classmethod
+ def _sql_load(cls, execute, data = None):
+ new = []
+
+ table = execute(
+ "SELECT id, name, comment" +
+ "FROM sedimentary_layer "
+ )
+
+ for row in table:
+ sl = cls(
+ id = row[0],
+ name = row[1],
+ comment = row[2],
+ status = data['status']
+ )
+
+ data["sl"] = sl.id
+ sl._layers = Layer._sql_load(execute, data)
+
+ new.append(sl)
+
+ return new
+
+ def _sql_save(self, execute, data = None):
+ if data is None:
+ data = {}
+
+ sql = (
+ "INSERT INTO sedimentary_layer (id, name) "+
+ f"VALUES ({self.id}, '{self._sql_format(self._name)}')"
+ )
+ execute(sql)
+
+ ind = 0
+ for l in self._layers:
+ data["ind"] = ind
+ l._sql_save(execute, data)
+
+ ind += 1
+
+ return True
diff --git a/src/Model/SedimentLayer/SedimentLayerList.py b/src/Model/SedimentLayer/SedimentLayerList.py
new file mode 100644
index 0000000000000000000000000000000000000000..b360c7233c092258927e700595d37823aaf27f6f
--- /dev/null
+++ b/src/Model/SedimentLayer/SedimentLayerList.py
@@ -0,0 +1,93 @@
+# -*- coding: utf-8 -*-
+
+from tools import trace, timer
+
+from Model.DB import SQLSubModel
+from Model.Except import NotImplementedMethodeError
+from Model.SedimentLayer.SedimentLayer import SedimentLayer
+
+class SedimentLayerList(SQLSubModel):
+ _sub_classes = [SedimentLayer]
+
+ def __init__(self, status = None):
+ super(SedimentLayerList, self).__init__()
+
+ self._status = status
+ self._sl = []
+
+ def __len__(self):
+ return len(self._sl)
+
+ @classmethod
+ def _sql_create(cls, execute):
+ return cls._create_submodel(execute)
+
+ @classmethod
+ def _sql_update(cls, execute, version):
+ return cls._update_submodel(execute, version)
+
+ @classmethod
+ def _sql_load(cls, execute, data = None):
+ new = cls(status = data["status"])
+
+ new._sl = SedimentLayer._sql_load(execute, data)
+
+ return new
+
+ def _sql_save(self, execute, data = None):
+ ok = True
+
+ for sl in self._sl:
+ ok &= sl._sql_save(execute, data)
+
+ return ok
+
+ def get(self, index):
+ return self._sl[index]
+
+ def set(self, index, new):
+ self._sl[index] = new
+ self._status.modified()
+
+ def insert(self, index, new):
+ self._sl.insert(index, new)
+ self._status.modified()
+
+ def new(self, index):
+ n = SedimentLayer(status = self._status)
+ self.insert(index, n)
+ self._status.modified()
+ return n
+
+ def delete(self, els):
+ for el in els:
+ self._sl.remove(el)
+ self._status.modified()
+
+ def delete_i(self, indexes):
+ els = list(
+ map(
+ lambda x: x[1],
+ filter(
+ lambda x: x[0] in indexes,
+ enumerate(self._sl)
+ )
+ )
+ )
+ self.delete(els)
+
+ def move_up(self, index):
+ if index < len(self._sl):
+ next = index - 1
+
+ l = self._sl
+ l[index], l[next] = l[next], l[index]
+ self._status.modified()
+
+ def move_down(self, index):
+ if index >= 0:
+ prev = index + 1
+
+ l = self._sl
+ l[index], l[prev] = l[prev], l[index]
+ self._status.modified()
diff --git a/src/View/SedimentLayers/Table.py b/src/View/SedimentLayers/Table.py
index 7abbd869102b3683b621080da82024c9b77217f7..f375c3188bba6cf0100b327d38197c1f5a8b0fa4 100644
--- a/src/View/SedimentLayers/Table.py
+++ b/src/View/SedimentLayers/Table.py
@@ -51,7 +51,7 @@ class TableModel(QAbstractTableModel):
if self._headers[column] == "name":
return self._sl.get(row).name
elif self._headers[column] == "comment":
- return self._sl.get(row).name
+ return self._sl.get(row).comment
return QVariant()
@@ -89,7 +89,7 @@ class TableModel(QAbstractTableModel):
self._undo.push(
AddCommand(
- self._sl, row, self._data
+ self._sl, row
)
)
diff --git a/src/View/SedimentLayers/UndoCommand.py b/src/View/SedimentLayers/UndoCommand.py
index 84c4027b7e11da2d61955fc8d0072da2899104d1..f785743b4aa0b455a51bdb4228d0f961af3ee013 100644
--- a/src/View/SedimentLayers/UndoCommand.py
+++ b/src/View/SedimentLayers/UndoCommand.py
@@ -41,7 +41,7 @@ class SetCommentCommand(QUndoCommand):
self._sediment_layers_list.get(self._index).comment = self._new
class AddCommand(QUndoCommand):
- def __init__(self, sediment_layers_list, index, reach):
+ def __init__(self, sediment_layers_list, index):
QUndoCommand.__init__(self)
self._sediment_layers_list = sediment_layers_list