diff --git a/src/Model/BoundaryCondition/BoundaryCondition.py b/src/Model/BoundaryCondition/BoundaryCondition.py
index ef1433a1..0e213ad2 100644
--- a/src/Model/BoundaryCondition/BoundaryCondition.py
+++ b/src/Model/BoundaryCondition/BoundaryCondition.py
@@ -52,10 +52,10 @@ class Data(SQLSubModel):
             ind INTEGER NOT NULL,
             data0 TEXT NOT NULL,
             data1 TEXT NOT NULL,
-            lc INTEGER,
+            bc INTEGER,
             {Scenario.create_db_add_scenario()},
             {Scenario.create_db_add_scenario_fk()},
-            FOREIGN KEY(lc) REFERENCES boundary_condition(pamhyr_id),
+            FOREIGN KEY(bc) REFERENCES boundary_condition(pamhyr_id),
             PRIMARY KEY(pamhyr_id, scenario)
           )
         """)
@@ -67,22 +67,25 @@ class Data(SQLSubModel):
         major, minor, release = version.strip().split(".")
 
         if major == "0" and int(minor) < 1:
-            cls._db_update_to_0_1_0(execute)
+            cls._db_update_to_0_1_0(execute, data)
 
         return cls._update_submodel(execute, version, data)
 
     @classmethod
-    def _db_update_to_0_1_0(cls, execute):
+    def _db_update_to_0_1_0(cls, execute, data):
         table = "boundary_condition_data"
 
-        cls.update_db_add_pamhyr_id(execute, table)
+        cls.update_db_add_pamhyr_id(
+            execute, table,
+            data=data
+        )
         Scenario.update_db_add_scenario(execute, table)
 
         cls._db_create(execute, ext="_tmp")
         execute(
             f"INSERT INTO {table} " +
-            "(pamhyr_id, ind, data0, data1, lc, scenario) " +
-            "SELECT pamhyr_id, ind, data0, data1, lc, scenario " +
+            "(pamhyr_id, ind, data0, data1, bc, scenario) " +
+            "SELECT pamhyr_id, ind, data0, data1, bc, scenario " +
             f"FROM {table}"
         )
 
@@ -92,12 +95,12 @@ class Data(SQLSubModel):
     @classmethod
     def _db_load(cls, execute, data=None):
         new = []
-        lc = data["lc"]
+        bc = data["bc"]
 
         values = execute(
             "SELECT pamhyr_id, ind, data0, data1 " +
             "FROM boundary_condition_data " +
-            f"WHERE lc = {lc._pamhyr_id} " +
+            f"WHERE bc = {bc._pamhyr_id} " +
             "ORDER BY ind ASC"
         )
 
@@ -111,12 +114,12 @@ class Data(SQLSubModel):
 
             nd = cls(
                 id=pid,
-                types=lc._types,
+                types=bc._types,
                 status=data['status']
             )
             nd._data = [data0, data1]
 
-            new.append((ind, nd))
+            new.append(nd)
 
         return new
 
@@ -125,12 +128,12 @@ class Data(SQLSubModel):
         ind = data["ind"]
         data0 = self._db_format(str(self[0]))
         data1 = self._db_format(str(self[1]))
-        lc = data["lc"]
+        bc = data["bc"]
 
         sql = (
             "INSERT INTO " +
             "boundary_condition_data(pamhyr_id, ind, data0, data1, bc) " +
-            f"VALUES ({pid}, {ind}, '{data0}', {data1}, {lc._pamhyr_id})"
+            f"VALUES ({pid}, {ind}, '{data0}', {data1}, {bc._pamhyr_id})"
         )
         execute(sql)
 
diff --git a/src/Model/Reservoir/Reservoir.py b/src/Model/Reservoir/Reservoir.py
index c93e0faa..ed33eac7 100644
--- a/src/Model/Reservoir/Reservoir.py
+++ b/src/Model/Reservoir/Reservoir.py
@@ -19,50 +19,146 @@
 import logging
 
 from Model.Tools.PamhyrDB import SQLSubModel
+from Model.Scenario import Scenario
 
 logger = logging.getLogger()
 
+class Data(SQLSubModel):
+    _sub_classes = []
+
+    def __init__(self, id: int = -1, status=None):
+        super(Data, self).__init__(id)
+        self._status = status
+
+        self._data = []
+
+    @classmethod
+    def _db_create(cls, execute, ext=""):
+        execute(f"""
+          CREATE TABLE reservoir_data{ext}(
+            {cls.create_db_add_pamhyr_id()},
+            ind INTEGER NOT NULL,
+            elevation REAL NOT NULL,
+            surface REAL NOT NULL,
+            reservoir INTEGER,
+            {Scenario.create_db_add_scenario()},
+            {Scenario.create_db_add_scenario_fk()},
+            FOREIGN KEY(reservoir) REFERENCES reservoir(pamhyr_id),
+            PRIMARY KEY(pamhyr_id, scenario)
+          )
+        """)
+
+        return cls._create_submodel(execute)
+
+    @classmethod
+    def _db_update(cls, execute, version, data=None):
+        major, minor, release = version.strip().split(".")
+
+        if major == minor == "0":
+            cls._db_update_to_0_1_0(execute, data)
+
+        return cls._update_submodel(execute, version, data)
+
+    @classmethod
+    def _db_update_to_0_1_0(cls, execute, data):
+        table = "reservoir_data"
+
+        cls.update_db_add_pamhyr_id(
+            execute, table,
+            data=data
+        )
+        Scenario.update_db_add_scenario(execute, table)
+
+        cls._db_create(execute, ext="_tmp")
+        execute(
+            f"INSERT INTO {table} " +
+            "(pamhyr_id, ind, elevation, surface, reservoir, scenario) " +
+            "SELECT pamhyr_id, ind, elevation, surface, reservoir, scenario " +
+            f"FROM {table}"
+        )
+
+        execute(f"DROP TABLE {table}")
+        execute(f"ALTER TABLE {table}_tmp RENAME TO {table}")
+
+    @classmethod
+    def _db_load(cls, execute, data=None):
+        new = []
+        reseroire = data["reservoir"]
+
+        values = execute(
+            "SELECT pamhyr_id, ind, elevation, surface " +
+            "FROM reservoir_data " +
+            f"WHERE reservoir = {reseroire.pamhyr_id} " +
+            "ORDER BY ind ASC"
+        )
+
+        for v in values:
+            it = iter(v)
+
+            pid = next(it)
+            ind = next(it)
+            elevation = next(it)
+            surface = next(it)
+
+            nd = cls(
+                id=pid, status=data['status']
+            )
+            nd._data = [elevation, surface]
+
+            new.append(nd)
+
+        return new
+
+    def _db_save(self, execute, data=None):
+        pid = self._pamhyr_id
+        ind = data["ind"]
+        elevation = self._db_format(str(self[0]))
+        surface = self._db_format(str(self[1]))
+        bc = data["bc"]
+
+        execute(
+            "INSERT INTO " +
+            "reservoir_data " +
+            "(pamhyr_id, ind, elevation, surface, reservoir) " +
+            "VALUES (" +
+            f"{pid}, {ind}, '{elevation}', {surface}, "+
+            f"{reservoir._pamhyr_id}" +
+            ")"
+        )
+
+
+    def __getitem__(self, key):
+        return self._data[key]
+
+    def __setitem__(self, key, value):
+        self._data[key] = float(value)
+
 
 class Reservoir(SQLSubModel):
     _sub_classes = []
-    _id_cnt = 0
 
-    def __init__(self, id: int = -1, name: str = "",
+    def __init__(self, id: int = -1,
+                 name: str = "",
                  status=None):
-        super(Reservoir, self).__init__()
+        super(Reservoir, self).__init__(id)
 
         self._status = status
 
-        if id == -1:
-            self.id = Reservoir._id_cnt
-        else:
-            self.id = id
-
         self._name = name
         self._node = None
         self._data = []
 
-        Reservoir._id_cnt = max(Reservoir._id_cnt + 1, self.id)
-
     @classmethod
-    def _db_create(cls, execute):
-        execute("""
-          CREATE TABLE reservoir(
-            id INTEGER NOT NULL PRIMARY KEY,
+    def _db_create(cls, execute, ext=""):
+        execute(f"""
+          CREATE TABLE reservoir{ext} (
+            {cls.create_db_add_pamhyr_id()},
             name TEXT NOT NULL,
             node INTEGER,
-            FOREIGN KEY(node) REFERENCES river_node(id)
-          )
-        """)
-
-        execute("""
-          CREATE TABLE reservoir_data(
-            id INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT,
-            ind INTEGER NOT NULL,
-            elevation REAL NOT NULL,
-            surface REAL NOT NULL,
-            reservoir INTEGER,
-            FOREIGN KEY(reservoir) REFERENCES reservoir(id)
+            {Scenario.create_db_add_scenario()},
+            {Scenario.create_db_add_scenario_fk()},
+            FOREIGN KEY(node) REFERENCES river_node(pamhyr_id),
+            PRIMARY KEY(pamhyr_id, scenario)
           )
         """)
 
@@ -75,21 +171,48 @@ class Reservoir(SQLSubModel):
             if int(release) < 5:
                 cls._db_create(execute)
 
+            cls._db_update_to_0_1_0(execute, data)
+
         return cls._update_submodel(execute, version, data)
 
+
+    @classmethod
+    def _db_update_to_0_1_0(cls, execute, data):
+        table = "reservoir"
+
+        cls.update_db_add_pamhyr_id(
+            execute, table,
+            data=data
+        )
+        Scenario.update_db_add_scenario(execute, table)
+
+        cls._db_create(execute, ext="_tmp")
+        execute(
+            f"INSERT INTO {table} " +
+            "(pamhyr_id, name, node, scenario) " +
+            "SELECT pamhyr_id, name, node, scenario " +
+            f"FROM {table}"
+        )
+
+        execute(f"DROP TABLE {table}")
+        execute(f"ALTER TABLE {table}_tmp RENAME TO {table}")
+
     @classmethod
     def _db_load(cls, execute, data=None):
         new = []
 
         table = execute(
-            "SELECT id, name, node " +
+            "SELECT pamhyr_id, name, node " +
             "FROM reservoir "
         )
 
         for row in table:
-            id = row[0]
-            name = row[1]
-            node_id = row[2]
+            it = iter(row)
+
+            id = next(it)
+            name = next(it)
+            node_id = next(it)
+
             new_reservoir = cls(id, name, status=data["status"])
 
             new_reservoir._node = None
@@ -100,36 +223,34 @@ class Reservoir(SQLSubModel):
                     )
                 )
 
-            new_data = []
-            table = execute(
-                "SELECT elevation, surface " +
-                "FROM reservoir_data " +
-                f"WHERE reservoir = {id} " +
-                "ORDER BY ind ASC"
+            data["reservoir"] = new_reservoir
+            new_reservoir._data = Data._db_load(
+                execute, data=data
             )
-            for t in table:
-                new_data.append((t[0], t[1]))
-
-            new_reservoir._data = new_data
 
             new.append(new_reservoir)
 
         return new
 
     def _db_save(self, execute, data=None):
+        execute(
+            "DELETE FROM reservoir " +
+            f"WHERE pamhyr_id = {self.pamhyr_id}"
+        )
+        execute(
+            "DELETE FROM reservoir_data " +
+            f"WHERE reservoir = {self.pamhyr_id}"
+        )
 
-        execute(f"DELETE FROM reservoir WHERE id = {self.id}")
-        execute(f"DELETE FROM reservoir_data WHERE reservoir = {self.id}")
-
-        node_id = -1
+        node_id = 'NULL'
         if self._node is not None:
-            node_id = self._node.id
+            node_id = self._node.pamhyr_id
 
         sql = (
             "INSERT INTO " +
             "reservoir(id, name, node) " +
             "VALUES (" +
-            f"{self.id}, '{self._db_format(self._name)}', " +
+            f"{self.pamhyr_id}, '{self._db_format(self._name)}', " +
             f"{node_id}" +
             ")"
         )
@@ -137,12 +258,10 @@ class Reservoir(SQLSubModel):
 
         ind = 0
         for d in self._data:
-            sql = (
-                "INSERT INTO " +
-                "reservoir_data(ind, elevation, surface, reservoir) " +
-                f"VALUES ({ind}, '{d[0]}', {d[1]}, {self.id})"
-            )
-            execute(sql)
+            data["ind"] = ind
+
+            d._db_save(execute, data)
+
             ind += 1
 
         return True
@@ -153,7 +272,7 @@ class Reservoir(SQLSubModel):
     @property
     def name(self):
         if self._name == "":
-            return f"R{self.id + 1}"
+            return f"Reservoir #{self.pamhyr_id}"
 
         return self._name